drivers/scsi/ips.c

   1 /*****************************************************************************/
   2 /* ips.c -- driver for the Adaptec / IBM ServeRAID controller                */
   3 /*                                                                           */
   4 /* Written By: Keith Mitchell, IBM Corporation                               */
   5 /*             Jack Hammer, Adaptec, Inc.                                    */
   6 /*             David Jeffery, Adaptec, Inc.                                  */
   7 /*                                                                           */
   8 /* Copyright (C) 2000 IBM Corporation                                        */
   9 /* Copyright (C) 2002,2003 Adaptec, Inc.                                     */
  10 /*                                                                           */
  11 /* This program is free software; you can redistribute it and/or modify      */
  12 /* it under the terms of the GNU General Public License as published by      */
  13 /* the Free Software Foundation; either version 2 of the License, or         */
  14 /* (at your option) any later version.                                       */
  15 /*                                                                           */
  16 /* This program is distributed in the hope that it will be useful,           */
  17 /* but WITHOUT ANY WARRANTY; without even the implied warranty of            */
  18 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             */
  19 /* GNU General Public License for more details.                              */
  20 /*                                                                           */
  21 /* NO WARRANTY                                                               */
  22 /* THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR        */
  23 /* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT      */
  24 /* LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,      */
  25 /* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is    */
  26 /* solely responsible for determining the appropriateness of using and       */
  27 /* distributing the Program and assumes all risks associated with its        */
  28 /* exercise of rights under this Agreement, including but not limited to     */
  29 /* the risks and costs of program errors, damage to or loss of data,         */
  30 /* programs or equipment, and unavailability or interruption of operations.  */
  31 /*                                                                           */
  32 /* DISCLAIMER OF LIABILITY                                                   */
  33 /* NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY   */
  34 /* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL        */
  35 /* DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND   */
  36 /* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR     */
  37 /* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE    */
  38 /* USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED  */
  39 /* HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES             */
  40 /*                                                                           */
  41 /* You should have received a copy of the GNU General Public License         */
  42 /* along with this program; if not, write to the Free Software               */
  43 /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  44 /*                                                                           */
  45 /* Bugs/Comments/Suggestions about this driver should be mailed to:          */
  46 /*      ipslinux@adaptec.com                                                 */
  47 /*                                                                           */
  48 /* For system support issues, contact your local IBM Customer support.       */
  49 /* Directions to find IBM Customer Support for each country can be found at: */
  50 /*      http://www.ibm.com/planetwide/                                       */
  51 /*                                                                           */
  52 /*****************************************************************************/
  53
  54 /*****************************************************************************/
  55 /* Change Log                                                                */
  56 /*                                                                           */
  57 /* 0.99.02  - Breakup commands that are bigger than 8 * the stripe size      */
  58 /* 0.99.03  - Make interrupt routine handle all completed request on the     */
  59 /*            adapter not just the first one                                 */
  60 /*          - Make sure passthru commands get woken up if we run out of      */
  61 /*            SCBs                                                           */
  62 /*          - Send all of the commands on the queue at once rather than      */
  63 /*            one at a time since the card will support it.                  */
  64 /* 0.99.04  - Fix race condition in the passthru mechanism -- this required  */
  65 /*            the interface to the utilities to change                       */
  66 /*          - Fix error recovery code                                        */
  67 /* 0.99.05  - Fix an oops when we get certain passthru commands              */
  68 /* 1.00.00  - Initial Public Release                                         */
  69 /*            Functionally equivalent to 0.99.05                             */
  70 /* 3.60.00  - Bump max commands to 128 for use with firmware 3.60            */
  71 /*          - Change version to 3.60 to coincide with release numbering.     */
  72 /* 3.60.01  - Remove bogus error check in passthru routine                   */
  73 /* 3.60.02  - Make DCDB direction based on lookup table                      */
  74 /*          - Only allow one DCDB command to a SCSI ID at a time             */
  75 /* 4.00.00  - Add support for ServeRAID 4                                    */
  76 /* 4.00.01  - Add support for First Failure Data Capture                     */
  77 /* 4.00.02  - Fix problem with PT DCDB with no buffer                        */
  78 /* 4.00.03  - Add alternative passthru interface                             */
  79 /*          - Add ability to flash BIOS                                      */
  80 /* 4.00.04  - Rename structures/constants to be prefixed with IPS_           */
  81 /* 4.00.05  - Remove wish_block from init routine                            */
  82 /*          - Use linux/spinlock.h instead of asm/spinlock.h for kernels     */
  83 /*            2.3.18 and later                                               */
  84 /*          - Sync with other changes from the 2.3 kernels                   */
  85 /* 4.00.06  - Fix timeout with initial FFDC command                          */
  86 /* 4.00.06a - Port to 2.4 (trivial) -- Christoph Hellwig <hch@infradead.org> */
  87 /* 4.10.00  - Add support for ServeRAID 4M/4L                                */
  88 /* 4.10.13  - Fix for dynamic unload and proc file system                    */
  89 /* 4.20.03  - Rename version to coincide with new release schedules          */
  90 /*            Performance fixes                                              */
  91 /*            Fix truncation of /proc files with cat                         */
  92 /*            Merge in changes through kernel 2.4.0test1ac21                 */
  93 /* 4.20.13  - Fix some failure cases / reset code                            */
  94 /*          - Hook into the reboot_notifier to flush the controller cache    */
  95 /* 4.50.01  - Fix problem when there is a hole in logical drive numbering    */
  96 /* 4.70.09  - Use a Common ( Large Buffer ) for Flashing from the JCRM CD    */
  97 /*          - Add IPSSEND Flash Support                                      */
  98 /*          - Set Sense Data for Unknown SCSI Command                        */
  99 /*          - Use Slot Number from NVRAM Page 5                              */
 100 /*          - Restore caller's DCDB Structure                                */
 101 /* 4.70.12  - Corrective actions for bad controller ( during initialization )*/
 102 /* 4.70.13  - Don't Send CDB's if we already know the device is not present  */
 103 /*          - Don't release HA Lock in ips_next() until SC taken off queue   */
 104 /*          - Unregister SCSI device in ips_release()                        */
 105 /* 4.70.15  - Fix Breakup for very large ( non-SG ) requests in ips_done()   */
 106 /* 4.71.00  - Change all memory allocations to not use GFP_DMA flag          */
 107 /*            Code Clean-Up for 2.4.x kernel                                 */
 108 /* 4.72.00  - Allow for a Scatter-Gather Element to exceed MAX_XFER Size     */
 109 /* 4.72.01  - I/O Mapped Memory release ( so "insmod ips" does not Fail )    */
 110 /*          - Don't Issue Internal FFDC Command if there are Active Commands */
 111 /*          - Close Window for getting too many IOCTL's active               */
 112 /* 4.80.00  - Make ia64 Safe                                                 */
 113 /* 4.80.04  - Eliminate calls to strtok() if 2.4.x or greater                */
 114 /*          - Adjustments to Device Queue Depth                              */
 115 /* 4.80.14  - Take all semaphores off stack                                  */
 116 /*          - Clean Up New_IOCTL path                                        */
 117 /* 4.80.20  - Set max_sectors in Scsi_Host structure ( if >= 2.4.7 kernel )  */
 118 /*          - 5 second delay needed after resetting an i960 adapter          */
 119 /* 4.80.26  - Clean up potential code problems ( Arjan's recommendations )   */
 120 /* 4.90.01  - Version Matching for FirmWare, BIOS, and Driver                */
 121 /* 4.90.05  - Use New PCI Architecture to facilitate Hot Plug Development    */
 122 /* 4.90.08  - Increase Delays in Flashing ( Trombone Only - 4H )             */
 123 /* 4.90.08  - Data Corruption if First Scatter Gather Element is > 64K       */
 124 /* 4.90.11  - Don't actually RESET unless it's physically required           */
 125 /*          - Remove unused compile options                                  */
 126 /* 5.00.01  - Sarasota ( 5i ) adapters must always be scanned first          */
 127 /*          - Get rid on IOCTL_NEW_COMMAND code                              */
 128 /*          - Add Extended DCDB Commands for Tape Support in 5I              */
 129 /* 5.10.12  - use pci_dma interfaces, update for 2.5 kernel changes          */
 130 /* 5.10.15  - remove unused code (sem, macros, etc.)                         */
 131 /* 5.30.00  - use __devexit_p()                                              */
 132 /* 6.00.00  - Add 6x Adapters and Battery Flash                              */
 133 /* 6.10.00  - Remove 1G Addressing Limitations                               */
 134 /* 6.11.xx  - Get VersionInfo buffer off the stack !              DDTS 60401 */
 135 /* 6.11.xx  - Make Logical Drive Info structure safe for DMA      DDTS 60639 */
 136 /* 7.10.18  - Add highmem_io flag in SCSI Templete for 2.4 kernels           */
 137 /*          - Fix path/name for scsi_hosts.h include for 2.6 kernels         */
 138 /*          - Fix sort order of 7k                                           */
 139 /*          - Remove 3 unused "inline" functions                             */
 140 /* 7.12.xx  - Use STATIC functions wherever possible                        */
 141 /*          - Clean up deprecated MODULE_PARM calls                          */
 142 /* 7.12.05  - Remove Version Matching per IBM request                        */
 143 /*****************************************************************************/
 144
 145 /*
 146  * Conditional Compilation directives for this driver:
 147  *
 148  * IPS_DEBUG            - Turn on debugging info
 149  *
 150  * Parameters:
 151  *
 152  * debug:<number>       - Set debug level to <number>
 153  *                        NOTE: only works when IPS_DEBUG compile directive is used.
 154  *       1              - Normal debug messages
 155  *       2              - Verbose debug messages
 156  *       11             - Method trace (non interrupt)
 157  *       12             - Method trace (includes interrupt)
 158  *
 159  * noi2o                - Don't use I2O Queues (ServeRAID 4 only)
 160  * nommap               - Don't use memory mapped I/O
 161  * ioctlsize            - Initial size of the IOCTL buffer
 162  */
 163
 164 #include <asm/io.h>
 165 #include <asm/byteorder.h>
 166 #include <asm/page.h>
 167 #include <linux/stddef.h>
 168 #include <linux/string.h>
 169 #include <linux/errno.h>
 170 #include <linux/kernel.h>
 171 #include <linux/ioport.h>
 172 #include <linux/slab.h>
 173 #include <linux/delay.h>
 174 #include <linux/pci.h>
 175 #include <linux/proc_fs.h>
 176 #include <linux/reboot.h>
 177 #include <linux/interrupt.h>
 178
 179 #include <linux/blkdev.h>
 180 #include <linux/types.h>
 181 #include <linux/dma-mapping.h>
 182
 183 #include <scsi/sg.h>
 184 #include "scsi.h"
 185 #include <scsi/scsi_host.h>
 186
 187 #include "ips.h"
 188
 189 #include <linux/module.h>
 190
 191 #include <linux/stat.h>
 192
 193 #include <linux/spinlock.h>
 194 #include <linux/init.h>
 195
 196 #include <linux/smp.h>
 197
 198 #ifdef MODULE
 199 static char *ips = NULL;
 200 module_param(ips, charp, 0);
 201 #endif
 202
 203 /*
 204  * DRIVER_VER
 205  */
 206 #define IPS_VERSION_HIGH        IPS_VER_MAJOR_STRING "." IPS_VER_MINOR_STRING
 207 #define IPS_VERSION_LOW         "." IPS_VER_BUILD_STRING " "
 208
 209 #if !defined(__i386__) && !defined(__ia64__) && !defined(__x86_64__)
 210 #warning "This driver has only been tested on the x86/ia64/x86_64 platforms"
 211 #endif
 212
 213 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
 214                          DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
 215                          PCI_DMA_BIDIRECTIONAL : \
 216                          scb->scsi_cmd->sc_data_direction)
 217
 218 #ifdef IPS_DEBUG
 219 #define METHOD_TRACE(s, i)    if (ips_debug >= (i+10)) printk(KERN_NOTICE s "\n");
 220 #define DEBUG(i, s)           if (ips_debug >= i) printk(KERN_NOTICE s "\n");
 221 #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "\n", v);
 222 #else
 223 #define METHOD_TRACE(s, i)
 224 #define DEBUG(i, s)
 225 #define DEBUG_VAR(i, s, v...)
 226 #endif
 227
 228 /*
 229  * Function prototypes
 230  */
 231 static int ips_detect(struct scsi_host_template *);
 232 static int ips_release(struct Scsi_Host *);
 233 static int ips_eh_abort(struct scsi_cmnd *);
 234 static int ips_eh_reset(struct scsi_cmnd *);
 235 static int ips_queue(struct Scsi_Host *, struct scsi_cmnd *);
 236 static const char *ips_info(struct Scsi_Host *);
 237 static irqreturn_t do_ipsintr(int, void *);
 238 static int ips_hainit(ips_ha_t *);
 239 static int ips_map_status(ips_ha_t *, ips_scb_t *, ips_stat_t *);
 240 static int ips_send_wait(ips_ha_t *, ips_scb_t *, int, int);
 241 static int ips_send_cmd(ips_ha_t *, ips_scb_t *);
 242 static int ips_online(ips_ha_t *, ips_scb_t *);
 243 static int ips_inquiry(ips_ha_t *, ips_scb_t *);
 244 static int ips_rdcap(ips_ha_t *, ips_scb_t *);
 245 static int ips_msense(ips_ha_t *, ips_scb_t *);
 246 static int ips_reqsen(ips_ha_t *, ips_scb_t *);
 247 static int ips_deallocatescbs(ips_ha_t *, int);
 248 static int ips_allocatescbs(ips_ha_t *);
 249 static int ips_reset_copperhead(ips_ha_t *);
 250 static int ips_reset_copperhead_memio(ips_ha_t *);
 251 static int ips_reset_morpheus(ips_ha_t *);
 252 static int ips_issue_copperhead(ips_ha_t *, ips_scb_t *);
 253 static int ips_issue_copperhead_memio(ips_ha_t *, ips_scb_t *);
 254 static int ips_issue_i2o(ips_ha_t *, ips_scb_t *);
 255 static int ips_issue_i2o_memio(ips_ha_t *, ips_scb_t *);
 256 static int ips_isintr_copperhead(ips_ha_t *);
 257 static int ips_isintr_copperhead_memio(ips_ha_t *);
 258 static int ips_isintr_morpheus(ips_ha_t *);
 259 static int ips_wait(ips_ha_t *, int, int);
 260 static int ips_write_driver_status(ips_ha_t *, int);
 261 static int ips_read_adapter_status(ips_ha_t *, int);
 262 static int ips_read_subsystem_parameters(ips_ha_t *, int);
 263 static int ips_read_config(ips_ha_t *, int);
 264 static int ips_clear_adapter(ips_ha_t *, int);
 265 static int ips_readwrite_page5(ips_ha_t *, int, int);
 266 static int ips_init_copperhead(ips_ha_t *);
 267 static int ips_init_copperhead_memio(ips_ha_t *);
 268 static int ips_init_morpheus(ips_ha_t *);
 269 static int ips_isinit_copperhead(ips_ha_t *);
 270 static int ips_isinit_copperhead_memio(ips_ha_t *);
 271 static int ips_isinit_morpheus(ips_ha_t *);
 272 static int ips_erase_bios(ips_ha_t *);
 273 static int ips_program_bios(ips_ha_t *, char *, uint32_t, uint32_t);
 274 static int ips_verify_bios(ips_ha_t *, char *, uint32_t, uint32_t);
 275 static int ips_erase_bios_memio(ips_ha_t *);
 276 static int ips_program_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
 277 static int ips_verify_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
 278 static int ips_flash_copperhead(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
 279 static int ips_flash_bios(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
 280 static int ips_flash_firmware(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
 281 static void ips_free_flash_copperhead(ips_ha_t * ha);
 282 static void ips_get_bios_version(ips_ha_t *, int);
 283 static void ips_identify_controller(ips_ha_t *);
 284 static void ips_chkstatus(ips_ha_t *, IPS_STATUS *);
 285 static void ips_enable_int_copperhead(ips_ha_t *);
 286 static void ips_enable_int_copperhead_memio(ips_ha_t *);
 287 static void ips_enable_int_morpheus(ips_ha_t *);
 288 static int ips_intr_copperhead(ips_ha_t *);
 289 static int ips_intr_morpheus(ips_ha_t *);
 290 static void ips_next(ips_ha_t *, int);
 291 static void ipsintr_blocking(ips_ha_t *, struct ips_scb *);
 292 static void ipsintr_done(ips_ha_t *, struct ips_scb *);
 293 static void ips_done(ips_ha_t *, ips_scb_t *);
 294 static void ips_free(ips_ha_t *);
 295 static void ips_init_scb(ips_ha_t *, ips_scb_t *);
 296 static void ips_freescb(ips_ha_t *, ips_scb_t *);
 297 static void ips_setup_funclist(ips_ha_t *);
 298 static void ips_statinit(ips_ha_t *);
 299 static void ips_statinit_memio(ips_ha_t *);
 300 static void ips_fix_ffdc_time(ips_ha_t *, ips_scb_t *, time_t);
 301 static void ips_ffdc_reset(ips_ha_t *, int);
 302 static void ips_ffdc_time(ips_ha_t *);
 303 static uint32_t ips_statupd_copperhead(ips_ha_t *);
 304 static uint32_t ips_statupd_copperhead_memio(ips_ha_t *);
 305 static uint32_t ips_statupd_morpheus(ips_ha_t *);
 306 static ips_scb_t *ips_getscb(ips_ha_t *);
 307 static void ips_putq_scb_head(ips_scb_queue_t *, ips_scb_t *);
 308 static void ips_putq_wait_tail(ips_wait_queue_t *, struct scsi_cmnd *);
 309 static void ips_putq_copp_tail(ips_copp_queue_t *,
 310                                       ips_copp_wait_item_t *);
 311 static ips_scb_t *ips_removeq_scb_head(ips_scb_queue_t *);
 312 static ips_scb_t *ips_removeq_scb(ips_scb_queue_t *, ips_scb_t *);
 313 static struct scsi_cmnd *ips_removeq_wait_head(ips_wait_queue_t *);
 314 static struct scsi_cmnd *ips_removeq_wait(ips_wait_queue_t *,
 315                                           struct scsi_cmnd *);
 316 static ips_copp_wait_item_t *ips_removeq_copp(ips_copp_queue_t *,
 317                                                      ips_copp_wait_item_t *);
 318 static ips_copp_wait_item_t *ips_removeq_copp_head(ips_copp_queue_t *);
 319
 320 static int ips_is_passthru(struct scsi_cmnd *);
 321 static int ips_make_passthru(ips_ha_t *, struct scsi_cmnd *, ips_scb_t *, int);
 322 static int ips_usrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
 323 static void ips_cleanup_passthru(ips_ha_t *, ips_scb_t *);
 324 static void ips_scmd_buf_write(struct scsi_cmnd * scmd, void *data,
 325                                unsigned int count);
 326 static void ips_scmd_buf_read(struct scsi_cmnd * scmd, void *data,
 327                               unsigned int count);
 328
 329 static int ips_write_info(struct Scsi_Host *, char *, int);
 330 static int ips_show_info(struct seq_file *, struct Scsi_Host *);
 331 static int ips_host_info(ips_ha_t *, struct seq_file *);
 332 static int ips_abort_init(ips_ha_t * ha, int index);
 333 static int ips_init_phase2(int index);
 334
 335 static int ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr);
 336 static int ips_register_scsi(int index);
 337
 338 static int  ips_poll_for_flush_complete(ips_ha_t * ha);
 339 static void ips_flush_and_reset(ips_ha_t *ha);
 340
 341 /*
 342  * global variables
 343  */
 344 static const char ips_name[] = "ips";
 345 static struct Scsi_Host *ips_sh[IPS_MAX_ADAPTERS];      /* Array of host controller structures */
 346 static ips_ha_t *ips_ha[IPS_MAX_ADAPTERS];      /* Array of HA structures */
 347 static unsigned int ips_next_controller;
 348 static unsigned int ips_num_controllers;
 349 static unsigned int ips_released_controllers;
 350 static int ips_hotplug;
 351 static int ips_cmd_timeout = 60;
 352 static int ips_reset_timeout = 60 * 5;
 353 static int ips_force_memio = 1;         /* Always use Memory Mapped I/O    */
 354 static int ips_force_i2o = 1;   /* Always use I2O command delivery */
 355 static int ips_ioctlsize = IPS_IOCTL_SIZE;      /* Size of the ioctl buffer        */
 356 static int ips_cd_boot;                 /* Booting from Manager CD         */
 357 static char *ips_FlashData = NULL;      /* CD Boot - Flash Data Buffer      */
 358 static dma_addr_t ips_flashbusaddr;
 359 static long ips_FlashDataInUse;         /* CD Boot - Flash Data In Use Flag */
 360 static uint32_t MaxLiteCmds = 32;       /* Max Active Cmds for a Lite Adapter */
 361 static struct scsi_host_template ips_driver_template = {
 362         .detect                 = ips_detect,
 363         .release                = ips_release,
 364         .info                   = ips_info,
 365         .queuecommand           = ips_queue,
 366         .eh_abort_handler       = ips_eh_abort,
 367         .eh_host_reset_handler  = ips_eh_reset,
 368         .proc_name              = "ips",
 369         .show_info              = ips_show_info,
 370         .write_info             = ips_write_info,
 371         .slave_configure        = ips_slave_configure,
 372         .bios_param             = ips_biosparam,
 373         .this_id                = -1,
 374         .sg_tablesize           = IPS_MAX_SG,
 375         .cmd_per_lun            = 3,
 376         .use_clustering         = ENABLE_CLUSTERING,
 377         .no_write_same          = 1,
 378 };
 379
 380
 381 /* This table describes all ServeRAID Adapters */
 382 static struct  pci_device_id  ips_pci_table[] = {
 383         { 0x1014, 0x002E, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
 384         { 0x1014, 0x01BD, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
 385         { 0x9005, 0x0250, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
 386         { 0, }
 387 };
 388
 389 MODULE_DEVICE_TABLE( pci, ips_pci_table );
 390
 391 static char ips_hot_plug_name[] = "ips";
 392
 393 static int  ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent);
 394 static void ips_remove_device(struct pci_dev *pci_dev);
 395
 396 static struct pci_driver ips_pci_driver = {
 397         .name           = ips_hot_plug_name,
 398         .id_table       = ips_pci_table,
 399         .probe          = ips_insert_device,
 400         .remove         = ips_remove_device,
 401 };
 402
 403
 404 /*
 405  * Necessary forward function protoypes
 406  */
 407 static int ips_halt(struct notifier_block *nb, ulong event, void *buf);
 408
 409 #define MAX_ADAPTER_NAME 15
 410
 411 static char ips_adapter_name[][30] = {
 412         "ServeRAID",
 413         "ServeRAID II",
 414         "ServeRAID on motherboard",
 415         "ServeRAID on motherboard",
 416         "ServeRAID 3H",
 417         "ServeRAID 3L",
 418         "ServeRAID 4H",
 419         "ServeRAID 4M",
 420         "ServeRAID 4L",
 421         "ServeRAID 4Mx",
 422         "ServeRAID 4Lx",
 423         "ServeRAID 5i",
 424         "ServeRAID 5i",
 425         "ServeRAID 6M",
 426         "ServeRAID 6i",
 427         "ServeRAID 7t",
 428         "ServeRAID 7k",
 429         "ServeRAID 7M"
 430 };
 431
 432 static struct notifier_block ips_notifier = {
 433         ips_halt, NULL, 0
 434 };
 435
 436 /*
 437  * Direction table
 438  */
 439 static char ips_command_direction[] = {
 440         IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT,
 441         IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK,
 442         IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 443         IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
 444         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_OUT,
 445         IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
 446         IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_IN,
 447         IPS_DATA_UNK, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
 448         IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_UNK,
 449         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
 450         IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE,
 451         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
 452         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT,
 453         IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_NONE,
 454         IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,
 455         IPS_DATA_NONE, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
 456         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 457         IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 458         IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 459         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 460         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 461         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 462         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 463         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 464         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 465         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 466         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 467         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 468         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 469         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 470         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 471         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 472         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 473         IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_NONE,
 474         IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_OUT,
 475         IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_NONE,
 476         IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN,
 477         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 478         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 479         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 480         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 481         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 482         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 483         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 484         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 485         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 486         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_OUT,
 487         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 488         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 489         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 490         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK
 491 };
 492
 493
 494 /****************************************************************************/
 495 /*                                                                          */
 496 /* Routine Name: ips_setup                                                  */
 497 /*                                                                          */
 498 /* Routine Description:                                                     */
 499 /*                                                                          */
 500 /*   setup parameters to the driver                                         */
 501 /*                                                                          */
 502 /****************************************************************************/
 503 static int
 504 ips_setup(char *ips_str)
 505 {
 506
 507         int i;
 508         char *key;
 509         char *value;
 510         IPS_OPTION options[] = {
 511                 {"noi2o", &ips_force_i2o, 0},
 512                 {"nommap", &ips_force_memio, 0},
 513                 {"ioctlsize", &ips_ioctlsize, IPS_IOCTL_SIZE},
 514                 {"cdboot", &ips_cd_boot, 0},
 515                 {"maxcmds", &MaxLiteCmds, 32},
 516         };
 517
 518         /* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
 519         /* Search for value */
 520         while ((key = strsep(&ips_str, ",."))) {
 521                 if (!*key)
 522                         continue;
 523                 value = strchr(key, ':');
 524                 if (value)
 525                         *value++ = '\0';
 526                 /*
 527                  * We now have key/value pairs.
 528                  * Update the variables
 529                  */
 530                 for (i = 0; i < ARRAY_SIZE(options); i++) {
 531                         if (strnicmp
 532                             (key, options[i].option_name,
 533                              strlen(options[i].option_name)) == 0) {
 534                                 if (value)
 535                                         *options[i].option_flag =
 536                                             simple_strtoul(value, NULL, 0);
 537                                 else
 538                                         *options[i].option_flag =
 539                                             options[i].option_value;
 540                                 break;
 541                         }
 542                 }
 543         }
 544
 545         return (1);
 546 }
 547
 548 __setup("ips=", ips_setup);
 549
 550 /****************************************************************************/
 551 /*                                                                          */
 552 /* Routine Name: ips_detect                                                 */
 553 /*                                                                          */
 554 /* Routine Description:                                                     */
 555 /*                                                                          */
 556 /*   Detect and initialize the driver                                       */
 557 /*                                                                          */
 558 /* NOTE: this routine is called under the io_request_lock spinlock          */
 559 /*                                                                          */
 560 /****************************************************************************/
 561 static int
 562 ips_detect(struct scsi_host_template * SHT)
 563 {
 564         int i;
 565
 566         METHOD_TRACE("ips_detect", 1);
 567
 568 #ifdef MODULE
 569         if (ips)
 570                 ips_setup(ips);
 571 #endif
 572
 573         for (i = 0; i < ips_num_controllers; i++) {
 574                 if (ips_register_scsi(i))
 575                         ips_free(ips_ha[i]);
 576                 ips_released_controllers++;
 577         }
 578         ips_hotplug = 1;
 579         return (ips_num_controllers);
 580 }
 581
 582 /****************************************************************************/
 583 /*   configure the function pointers to use the functions that will work    */
 584 /*   with the found version of the adapter                                  */
 585 /****************************************************************************/
 586 static void
 587 ips_setup_funclist(ips_ha_t * ha)
 588 {
 589
 590         /*
 591          * Setup Functions
 592          */
 593         if (IPS_IS_MORPHEUS(ha) || IPS_IS_MARCO(ha)) {
 594                 /* morpheus / marco / sebring */
 595                 ha->func.isintr = ips_isintr_morpheus;
 596                 ha->func.isinit = ips_isinit_morpheus;
 597                 ha->func.issue = ips_issue_i2o_memio;
 598                 ha->func.init = ips_init_morpheus;
 599                 ha->func.statupd = ips_statupd_morpheus;
 600                 ha->func.reset = ips_reset_morpheus;
 601                 ha->func.intr = ips_intr_morpheus;
 602                 ha->func.enableint = ips_enable_int_morpheus;
 603         } else if (IPS_USE_MEMIO(ha)) {
 604                 /* copperhead w/MEMIO */
 605                 ha->func.isintr = ips_isintr_copperhead_memio;
 606                 ha->func.isinit = ips_isinit_copperhead_memio;
 607                 ha->func.init = ips_init_copperhead_memio;
 608                 ha->func.statupd = ips_statupd_copperhead_memio;
 609                 ha->func.statinit = ips_statinit_memio;
 610                 ha->func.reset = ips_reset_copperhead_memio;
 611                 ha->func.intr = ips_intr_copperhead;
 612                 ha->func.erasebios = ips_erase_bios_memio;
 613                 ha->func.programbios = ips_program_bios_memio;
 614                 ha->func.verifybios = ips_verify_bios_memio;
 615                 ha->func.enableint = ips_enable_int_copperhead_memio;
 616                 if (IPS_USE_I2O_DELIVER(ha))
 617                         ha->func.issue = ips_issue_i2o_memio;
 618                 else
 619                         ha->func.issue = ips_issue_copperhead_memio;
 620         } else {
 621                 /* copperhead */
 622                 ha->func.isintr = ips_isintr_copperhead;
 623                 ha->func.isinit = ips_isinit_copperhead;
 624                 ha->func.init = ips_init_copperhead;
 625                 ha->func.statupd = ips_statupd_copperhead;
 626                 ha->func.statinit = ips_statinit;
 627                 ha->func.reset = ips_reset_copperhead;
 628                 ha->func.intr = ips_intr_copperhead;
 629                 ha->func.erasebios = ips_erase_bios;
 630                 ha->func.programbios = ips_program_bios;
 631                 ha->func.verifybios = ips_verify_bios;
 632                 ha->func.enableint = ips_enable_int_copperhead;
 633
 634                 if (IPS_USE_I2O_DELIVER(ha))
 635                         ha->func.issue = ips_issue_i2o;
 636                 else
 637                         ha->func.issue = ips_issue_copperhead;
 638         }
 639 }
 640
 641 /****************************************************************************/
 642 /*                                                                          */
 643 /* Routine Name: ips_release                                                */
 644 /*                                                                          */
 645 /* Routine Description:                                                     */
 646 /*                                                                          */
 647 /*   Remove a driver                                                        */
 648 /*                                                                          */
 649 /****************************************************************************/
 650 static int
 651 ips_release(struct Scsi_Host *sh)
 652 {
 653         ips_scb_t *scb;
 654         ips_ha_t *ha;
 655         int i;
 656
 657         METHOD_TRACE("ips_release", 1);
 658
 659         scsi_remove_host(sh);
 660
 661         for (i = 0; i < IPS_MAX_ADAPTERS && ips_sh[i] != sh; i++) ;
 662
 663         if (i == IPS_MAX_ADAPTERS) {
 664                 printk(KERN_WARNING
 665                        "(%s) release, invalid Scsi_Host pointer.\n", ips_name);
 666                 BUG();
 667                 return (FALSE);
 668         }
 669
 670         ha = IPS_HA(sh);
 671
 672         if (!ha)
 673                 return (FALSE);
 674
 675         /* flush the cache on the controller */
 676         scb = &ha->scbs[ha->max_cmds - 1];
 677
 678         ips_init_scb(ha, scb);
 679
 680         scb->timeout = ips_cmd_timeout;
 681         scb->cdb[0] = IPS_CMD_FLUSH;
 682
 683         scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
 684         scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
 685         scb->cmd.flush_cache.state = IPS_NORM_STATE;
 686         scb->cmd.flush_cache.reserved = 0;
 687         scb->cmd.flush_cache.reserved2 = 0;
 688         scb->cmd.flush_cache.reserved3 = 0;
 689         scb->cmd.flush_cache.reserved4 = 0;
 690
 691         IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
 692
 693         /* send command */
 694         if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
 695                 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Incomplete Flush.\n");
 696
 697         IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Complete.\n");
 698
 699         ips_sh[i] = NULL;
 700         ips_ha[i] = NULL;
 701
 702         /* free extra memory */
 703         ips_free(ha);
 704
 705         /* free IRQ */
 706         free_irq(ha->pcidev->irq, ha);
 707
 708         scsi_host_put(sh);
 709
 710         ips_released_controllers++;
 711
 712         return (FALSE);
 713 }
 714
 715 /****************************************************************************/
 716 /*                                                                          */
 717 /* Routine Name: ips_halt                                                   */
 718 /*                                                                          */
 719 /* Routine Description:                                                     */
 720 /*                                                                          */
 721 /*   Perform cleanup when the system reboots                                */
 722 /*                                                                          */
 723 /****************************************************************************/
 724 static int
 725 ips_halt(struct notifier_block *nb, ulong event, void *buf)
 726 {
 727         ips_scb_t *scb;
 728         ips_ha_t *ha;
 729         int i;
 730
 731         if ((event != SYS_RESTART) && (event != SYS_HALT) &&
 732             (event != SYS_POWER_OFF))
 733                 return (NOTIFY_DONE);
 734
 735         for (i = 0; i < ips_next_controller; i++) {
 736                 ha = (ips_ha_t *) ips_ha[i];
 737
 738                 if (!ha)
 739                         continue;
 740
 741                 if (!ha->active)
 742                         continue;
 743
 744                 /* flush the cache on the controller */
 745                 scb = &ha->scbs[ha->max_cmds - 1];
 746
 747                 ips_init_scb(ha, scb);
 748
 749                 scb->timeout = ips_cmd_timeout;
 750                 scb->cdb[0] = IPS_CMD_FLUSH;
 751
 752                 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
 753                 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
 754                 scb->cmd.flush_cache.state = IPS_NORM_STATE;
 755                 scb->cmd.flush_cache.reserved = 0;
 756                 scb->cmd.flush_cache.reserved2 = 0;
 757                 scb->cmd.flush_cache.reserved3 = 0;
 758                 scb->cmd.flush_cache.reserved4 = 0;
 759
 760                 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
 761
 762                 /* send command */
 763                 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) ==
 764                     IPS_FAILURE)
 765                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
 766                                    "Incomplete Flush.\n");
 767                 else
 768                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
 769                                    "Flushing Complete.\n");
 770         }
 771
 772         return (NOTIFY_OK);
 773 }
 774
 775 /****************************************************************************/
 776 /*                                                                          */
 777 /* Routine Name: ips_eh_abort                                               */
 778 /*                                                                          */
 779 /* Routine Description:                                                     */
 780 /*                                                                          */
 781 /*   Abort a command (using the new error code stuff)                       */
 782 /* Note: this routine is called under the io_request_lock                   */
 783 /****************************************************************************/
 784 int ips_eh_abort(struct scsi_cmnd *SC)
 785 {
 786         ips_ha_t *ha;
 787         ips_copp_wait_item_t *item;
 788         int ret;
 789         struct Scsi_Host *host;
 790
 791         METHOD_TRACE("ips_eh_abort", 1);
 792
 793         if (!SC)
 794                 return (FAILED);
 795
 796         host = SC->device->host;
 797         ha = (ips_ha_t *) SC->device->host->hostdata;
 798
 799         if (!ha)
 800                 return (FAILED);
 801
 802         if (!ha->active)
 803                 return (FAILED);
 804
 805         spin_lock(host->host_lock);
 806
 807         /* See if the command is on the copp queue */
 808         item = ha->copp_waitlist.head;
 809         while ((item) && (item->scsi_cmd != SC))
 810                 item = item->next;
 811
 812         if (item) {
 813                 /* Found it */
 814                 ips_removeq_copp(&ha->copp_waitlist, item);
 815                 ret = (SUCCESS);
 816
 817                 /* See if the command is on the wait queue */
 818         } else if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
 819                 /* command not sent yet */
 820                 ret = (SUCCESS);
 821         } else {
 822                 /* command must have already been sent */
 823                 ret = (FAILED);
 824         }
 825
 826         spin_unlock(host->host_lock);
 827         return ret;
 828 }
 829
 830 /****************************************************************************/
 831 /*                                                                          */
 832 /* Routine Name: ips_eh_reset                                               */
 833 /*                                                                          */
 834 /* Routine Description:                                                     */
 835 /*                                                                          */
 836 /*   Reset the controller (with new eh error code)                          */
 837 /*                                                                          */
 838 /* NOTE: this routine is called under the io_request_lock spinlock          */
 839 /*                                                                          */
 840 /****************************************************************************/
 841 static int __ips_eh_reset(struct scsi_cmnd *SC)
 842 {
 843         int ret;
 844         int i;
 845         ips_ha_t *ha;
 846         ips_scb_t *scb;
 847         ips_copp_wait_item_t *item;
 848
 849         METHOD_TRACE("ips_eh_reset", 1);
 850
 851 #ifdef NO_IPS_RESET
 852         return (FAILED);
 853 #else
 854
 855         if (!SC) {
 856                 DEBUG(1, "Reset called with NULL scsi command");
 857
 858                 return (FAILED);
 859         }
 860
 861         ha = (ips_ha_t *) SC->device->host->hostdata;
 862
 863         if (!ha) {
 864                 DEBUG(1, "Reset called with NULL ha struct");
 865
 866                 return (FAILED);
 867         }
 868
 869         if (!ha->active)
 870                 return (FAILED);
 871
 872         /* See if the command is on the copp queue */
 873         item = ha->copp_waitlist.head;
 874         while ((item) && (item->scsi_cmd != SC))
 875                 item = item->next;
 876
 877         if (item) {
 878                 /* Found it */
 879                 ips_removeq_copp(&ha->copp_waitlist, item);
 880                 return (SUCCESS);
 881         }
 882
 883         /* See if the command is on the wait queue */
 884         if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
 885                 /* command not sent yet */
 886                 return (SUCCESS);
 887         }
 888
 889         /* An explanation for the casual observer:                              */
 890         /* Part of the function of a RAID controller is automatic error         */
 891         /* detection and recovery.  As such, the only problem that physically   */
 892         /* resetting an adapter will ever fix is when, for some reason,         */
 893         /* the driver is not successfully communicating with the adapter.       */
 894         /* Therefore, we will attempt to flush this adapter.  If that succeeds, */
 895         /* then there's no real purpose in a physical reset. This will complete */
 896         /* much faster and avoids any problems that might be caused by a        */
 897         /* physical reset ( such as having to fail all the outstanding I/O's ). */
 898
 899         if (ha->ioctl_reset == 0) {     /* IF Not an IOCTL Requested Reset */
 900                 scb = &ha->scbs[ha->max_cmds - 1];
 901
 902                 ips_init_scb(ha, scb);
 903
 904                 scb->timeout = ips_cmd_timeout;
 905                 scb->cdb[0] = IPS_CMD_FLUSH;
 906
 907                 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
 908                 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
 909                 scb->cmd.flush_cache.state = IPS_NORM_STATE;
 910                 scb->cmd.flush_cache.reserved = 0;
 911                 scb->cmd.flush_cache.reserved2 = 0;
 912                 scb->cmd.flush_cache.reserved3 = 0;
 913                 scb->cmd.flush_cache.reserved4 = 0;
 914
 915                 /* Attempt the flush command */
 916                 ret = ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_IORL);
 917                 if (ret == IPS_SUCCESS) {
 918                         IPS_PRINTK(KERN_NOTICE, ha->pcidev,
 919                                    "Reset Request - Flushed Cache\n");
 920                         return (SUCCESS);
 921                 }
 922         }
 923
 924         /* Either we can't communicate with the adapter or it's an IOCTL request */
 925         /* from a utility.  A physical reset is needed at this point.            */
 926
 927         ha->ioctl_reset = 0;    /* Reset the IOCTL Requested Reset Flag */
 928
 929         /*
 930          * command must have already been sent
 931          * reset the controller
 932          */
 933         IPS_PRINTK(KERN_NOTICE, ha->pcidev, "Resetting controller.\n");
 934         ret = (*ha->func.reset) (ha);
 935
 936         if (!ret) {
 937                 struct scsi_cmnd *scsi_cmd;
 938
 939                 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
 940                            "Controller reset failed - controller now offline.\n");
 941
 942                 /* Now fail all of the active commands */
 943                 DEBUG_VAR(1, "(%s%d) Failing active commands",
 944                           ips_name, ha->host_num);
 945
 946                 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
 947                         scb->scsi_cmd->result = DID_ERROR << 16;
 948                         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
 949                         ips_freescb(ha, scb);
 950                 }
 951
 952                 /* Now fail all of the pending commands */
 953                 DEBUG_VAR(1, "(%s%d) Failing pending commands",
 954                           ips_name, ha->host_num);
 955
 956                 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
 957                         scsi_cmd->result = DID_ERROR;
 958                         scsi_cmd->scsi_done(scsi_cmd);
 959                 }
 960
 961                 ha->active = FALSE;
 962                 return (FAILED);
 963         }
 964
 965         if (!ips_clear_adapter(ha, IPS_INTR_IORL)) {
 966                 struct scsi_cmnd *scsi_cmd;
 967
 968                 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
 969                            "Controller reset failed - controller now offline.\n");
 970
 971                 /* Now fail all of the active commands */
 972                 DEBUG_VAR(1, "(%s%d) Failing active commands",
 973                           ips_name, ha->host_num);
 974
 975                 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
 976                         scb->scsi_cmd->result = DID_ERROR << 16;
 977                         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
 978                         ips_freescb(ha, scb);
 979                 }
 980
 981                 /* Now fail all of the pending commands */
 982                 DEBUG_VAR(1, "(%s%d) Failing pending commands",
 983                           ips_name, ha->host_num);
 984
 985                 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
 986                         scsi_cmd->result = DID_ERROR << 16;
 987                         scsi_cmd->scsi_done(scsi_cmd);
 988                 }
 989
 990                 ha->active = FALSE;
 991                 return (FAILED);
 992         }
 993
 994         /* FFDC */
 995         if (le32_to_cpu(ha->subsys->param[3]) & 0x300000) {
 996                 struct timeval tv;
 997
 998                 do_gettimeofday(&tv);
 999                 ha->last_ffdc = tv.tv_sec;
1000                 ha->reset_count++;
1001                 ips_ffdc_reset(ha, IPS_INTR_IORL);
1002         }
1003
1004         /* Now fail all of the active commands */
1005         DEBUG_VAR(1, "(%s%d) Failing active commands", ips_name, ha->host_num);
1006
1007         while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
1008                 scb->scsi_cmd->result = DID_RESET << 16;
1009                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1010                 ips_freescb(ha, scb);
1011         }
1012
1013         /* Reset DCDB active command bits */
1014         for (i = 1; i < ha->nbus; i++)
1015                 ha->dcdb_active[i - 1] = 0;
1016
1017         /* Reset the number of active IOCTLs */
1018         ha->num_ioctl = 0;
1019
1020         ips_next(ha, IPS_INTR_IORL);
1021
1022         return (SUCCESS);
1023 #endif                          /* NO_IPS_RESET */
1024
1025 }
1026
1027 static int ips_eh_reset(struct scsi_cmnd *SC)
1028 {
1029         int rc;
1030
1031         spin_lock_irq(SC->device->host->host_lock);
1032         rc = __ips_eh_reset(SC);
1033         spin_unlock_irq(SC->device->host->host_lock);
1034
1035         return rc;
1036 }
1037
1038 /****************************************************************************/
1039 /*                                                                          */
1040 /* Routine Name: ips_queue                                                  */
1041 /*                                                                          */
1042 /* Routine Description:                                                     */
1043 /*                                                                          */
1044 /*   Send a command to the controller                                       */
1045 /*                                                                          */
1046 /* NOTE:                                                                    */
1047 /*    Linux obtains io_request_lock before calling this function            */
1048 /*                                                                          */
1049 /****************************************************************************/
1050 static int ips_queue_lck(struct scsi_cmnd *SC, void (*done) (struct scsi_cmnd *))
1051 {
1052         ips_ha_t *ha;
1053         ips_passthru_t *pt;
1054
1055         METHOD_TRACE("ips_queue", 1);
1056
1057         ha = (ips_ha_t *) SC->device->host->hostdata;
1058
1059         if (!ha)
1060                 return (1);
1061
1062         if (!ha->active)
1063                 return (DID_ERROR);
1064
1065         if (ips_is_passthru(SC)) {
1066                 if (ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
1067                         SC->result = DID_BUS_BUSY << 16;
1068                         done(SC);
1069
1070                         return (0);
1071                 }
1072         } else if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
1073                 SC->result = DID_BUS_BUSY << 16;
1074                 done(SC);
1075
1076                 return (0);
1077         }
1078
1079         SC->scsi_done = done;
1080
1081         DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
1082                   ips_name,
1083                   ha->host_num,
1084                   SC->cmnd[0],
1085                   SC->device->channel, SC->device->id, SC->device->lun);
1086
1087         /* Check for command to initiator IDs */
1088         if ((scmd_channel(SC) > 0)
1089             && (scmd_id(SC) == ha->ha_id[scmd_channel(SC)])) {
1090                 SC->result = DID_NO_CONNECT << 16;
1091                 done(SC);
1092
1093                 return (0);
1094         }
1095
1096         if (ips_is_passthru(SC)) {
1097
1098                 ips_copp_wait_item_t *scratch;
1099
1100                 /* A Reset IOCTL is only sent by the boot CD in extreme cases.           */
1101                 /* There can never be any system activity ( network or disk ), but check */
1102                 /* anyway just as a good practice.                                       */
1103                 pt = (ips_passthru_t *) scsi_sglist(SC);
1104                 if ((pt->CoppCP.cmd.reset.op_code == IPS_CMD_RESET_CHANNEL) &&
1105                     (pt->CoppCP.cmd.reset.adapter_flag == 1)) {
1106                         if (ha->scb_activelist.count != 0) {
1107                                 SC->result = DID_BUS_BUSY << 16;
1108                                 done(SC);
1109                                 return (0);
1110                         }
1111                         ha->ioctl_reset = 1;    /* This reset request is from an IOCTL */
1112                         __ips_eh_reset(SC);
1113                         SC->result = DID_OK << 16;
1114                         SC->scsi_done(SC);
1115                         return (0);
1116                 }
1117
1118                 /* allocate space for the scribble */
1119                 scratch = kmalloc(sizeof (ips_copp_wait_item_t), GFP_ATOMIC);
1120
1121                 if (!scratch) {
1122                         SC->result = DID_ERROR << 16;
1123                         done(SC);
1124
1125                         return (0);
1126                 }
1127
1128                 scratch->scsi_cmd = SC;
1129                 scratch->next = NULL;
1130
1131                 ips_putq_copp_tail(&ha->copp_waitlist, scratch);
1132         } else {
1133                 ips_putq_wait_tail(&ha->scb_waitlist, SC);
1134         }
1135
1136         ips_next(ha, IPS_INTR_IORL);
1137
1138         return (0);
1139 }
1140
1141 static DEF_SCSI_QCMD(ips_queue)
1142
1143 /****************************************************************************/
1144 /*                                                                          */
1145 /* Routine Name: ips_biosparam                                              */
1146 /*                                                                          */
1147 /* Routine Description:                                                     */
1148 /*                                                                          */
1149 /*   Set bios geometry for the controller                                   */
1150 /*                                                                          */
1151 /****************************************************************************/
1152 static int ips_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1153                          sector_t capacity, int geom[])
1154 {
1155         ips_ha_t *ha = (ips_ha_t *) sdev->host->hostdata;
1156         int heads;
1157         int sectors;
1158         int cylinders;
1159
1160         METHOD_TRACE("ips_biosparam", 1);
1161
1162         if (!ha)
1163                 /* ?!?! host adater info invalid */
1164                 return (0);
1165
1166         if (!ha->active)
1167                 return (0);
1168
1169         if (!ips_read_adapter_status(ha, IPS_INTR_ON))
1170                 /* ?!?! Enquiry command failed */
1171                 return (0);
1172
1173         if ((capacity > 0x400000) && ((ha->enq->ucMiscFlag & 0x8) == 0)) {
1174                 heads = IPS_NORM_HEADS;
1175                 sectors = IPS_NORM_SECTORS;
1176         } else {
1177                 heads = IPS_COMP_HEADS;
1178                 sectors = IPS_COMP_SECTORS;
1179         }
1180
1181         cylinders = (unsigned long) capacity / (heads * sectors);
1182
1183         DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
1184                   heads, sectors, cylinders);
1185
1186         geom[0] = heads;
1187         geom[1] = sectors;
1188         geom[2] = cylinders;
1189
1190         return (0);
1191 }
1192
1193 /****************************************************************************/
1194 /*                                                                          */
1195 /* Routine Name: ips_slave_configure                                        */
1196 /*                                                                          */
1197 /* Routine Description:                                                     */
1198 /*                                                                          */
1199 /*   Set queue depths on devices once scan is complete                      */
1200 /*                                                                          */
1201 /****************************************************************************/
1202 static int
1203 ips_slave_configure(struct scsi_device * SDptr)
1204 {
1205         ips_ha_t *ha;
1206         int min;
1207
1208         ha = IPS_HA(SDptr->host);
1209         if (SDptr->tagged_supported && SDptr->type == TYPE_DISK) {
1210                 min = ha->max_cmds / 2;
1211                 if (ha->enq->ucLogDriveCount <= 2)
1212                         min = ha->max_cmds - 1;
1213                 scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, min);
1214         }
1215
1216         SDptr->skip_ms_page_8 = 1;
1217         SDptr->skip_ms_page_3f = 1;
1218         return 0;
1219 }
1220
1221 /****************************************************************************/
1222 /*                                                                          */
1223 /* Routine Name: do_ipsintr                                                 */
1224 /*                                                                          */
1225 /* Routine Description:                                                     */
1226 /*                                                                          */
1227 /*   Wrapper for the interrupt handler                                      */
1228 /*                                                                          */
1229 /****************************************************************************/
1230 static irqreturn_t
1231 do_ipsintr(int irq, void *dev_id)
1232 {
1233         ips_ha_t *ha;
1234         struct Scsi_Host *host;
1235         int irqstatus;
1236
1237         METHOD_TRACE("do_ipsintr", 2);
1238
1239         ha = (ips_ha_t *) dev_id;
1240         if (!ha)
1241                 return IRQ_NONE;
1242         host = ips_sh[ha->host_num];
1243         /* interrupt during initialization */
1244         if (!host) {
1245                 (*ha->func.intr) (ha);
1246                 return IRQ_HANDLED;
1247         }
1248
1249         spin_lock(host->host_lock);
1250
1251         if (!ha->active) {
1252                 spin_unlock(host->host_lock);
1253                 return IRQ_HANDLED;
1254         }
1255
1256         irqstatus = (*ha->func.intr) (ha);
1257
1258         spin_unlock(host->host_lock);
1259
1260         /* start the next command */
1261         ips_next(ha, IPS_INTR_ON);
1262         return IRQ_RETVAL(irqstatus);
1263 }
1264
1265 /****************************************************************************/
1266 /*                                                                          */
1267 /* Routine Name: ips_intr_copperhead                                        */
1268 /*                                                                          */
1269 /* Routine Description:                                                     */
1270 /*                                                                          */
1271 /*   Polling interrupt handler                                              */
1272 /*                                                                          */
1273 /*   ASSUMES interrupts are disabled                                        */
1274 /*                                                                          */
1275 /****************************************************************************/
1276 int
1277 ips_intr_copperhead(ips_ha_t * ha)
1278 {
1279         ips_stat_t *sp;
1280         ips_scb_t *scb;
1281         IPS_STATUS cstatus;
1282         int intrstatus;
1283
1284         METHOD_TRACE("ips_intr", 2);
1285
1286         if (!ha)
1287                 return 0;
1288
1289         if (!ha->active)
1290                 return 0;
1291
1292         intrstatus = (*ha->func.isintr) (ha);
1293
1294         if (!intrstatus) {
1295                 /*
1296                  * Unexpected/Shared interrupt
1297                  */
1298
1299                 return 0;
1300         }
1301
1302         while (TRUE) {
1303                 sp = &ha->sp;
1304
1305                 intrstatus = (*ha->func.isintr) (ha);
1306
1307                 if (!intrstatus)
1308                         break;
1309                 else
1310                         cstatus.value = (*ha->func.statupd) (ha);
1311
1312                 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1313                         /* Spurious Interrupt ? */
1314                         continue;
1315                 }
1316
1317                 ips_chkstatus(ha, &cstatus);
1318                 scb = (ips_scb_t *) sp->scb_addr;
1319
1320                 /*
1321                  * use the callback function to finish things up
1322                  * NOTE: interrupts are OFF for this
1323                  */
1324                 (*scb->callback) (ha, scb);
1325         }                       /* end while */
1326         return 1;
1327 }
1328
1329 /****************************************************************************/
1330 /*                                                                          */
1331 /* Routine Name: ips_intr_morpheus                                          */
1332 /*                                                                          */
1333 /* Routine Description:                                                     */
1334 /*                                                                          */
1335 /*   Polling interrupt handler                                              */
1336 /*                                                                          */
1337 /*   ASSUMES interrupts are disabled                                        */
1338 /*                                                                          */
1339 /****************************************************************************/
1340 int
1341 ips_intr_morpheus(ips_ha_t * ha)
1342 {
1343         ips_stat_t *sp;
1344         ips_scb_t *scb;
1345         IPS_STATUS cstatus;
1346         int intrstatus;
1347
1348         METHOD_TRACE("ips_intr_morpheus", 2);
1349
1350         if (!ha)
1351                 return 0;
1352
1353         if (!ha->active)
1354                 return 0;
1355
1356         intrstatus = (*ha->func.isintr) (ha);
1357
1358         if (!intrstatus) {
1359                 /*
1360                  * Unexpected/Shared interrupt
1361                  */
1362
1363                 return 0;
1364         }
1365
1366         while (TRUE) {
1367                 sp = &ha->sp;
1368
1369                 intrstatus = (*ha->func.isintr) (ha);
1370
1371                 if (!intrstatus)
1372                         break;
1373                 else
1374                         cstatus.value = (*ha->func.statupd) (ha);
1375
1376                 if (cstatus.value == 0xffffffff)
1377                         /* No more to process */
1378                         break;
1379
1380                 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1381                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
1382                                    "Spurious interrupt; no ccb.\n");
1383
1384                         continue;
1385                 }
1386
1387                 ips_chkstatus(ha, &cstatus);
1388                 scb = (ips_scb_t *) sp->scb_addr;
1389
1390                 /*
1391                  * use the callback function to finish things up
1392                  * NOTE: interrupts are OFF for this
1393                  */
1394                 (*scb->callback) (ha, scb);
1395         }                       /* end while */
1396         return 1;
1397 }
1398
1399 /****************************************************************************/
1400 /*                                                                          */
1401 /* Routine Name: ips_info                                                   */
1402 /*                                                                          */
1403 /* Routine Description:                                                     */
1404 /*                                                                          */
1405 /*   Return info about the driver                                           */
1406 /*                                                                          */
1407 /****************************************************************************/
1408 static const char *
1409 ips_info(struct Scsi_Host *SH)
1410 {
1411         static char buffer[256];
1412         char *bp;
1413         ips_ha_t *ha;
1414
1415         METHOD_TRACE("ips_info", 1);
1416
1417         ha = IPS_HA(SH);
1418
1419         if (!ha)
1420                 return (NULL);
1421
1422         bp = &buffer[0];
1423         memset(bp, 0, sizeof (buffer));
1424
1425         sprintf(bp, "%s%s%s Build %d", "IBM PCI ServeRAID ",
1426                 IPS_VERSION_HIGH, IPS_VERSION_LOW, IPS_BUILD_IDENT);
1427
1428         if (ha->ad_type > 0 && ha->ad_type <= MAX_ADAPTER_NAME) {
1429                 strcat(bp, " <");
1430                 strcat(bp, ips_adapter_name[ha->ad_type - 1]);
1431                 strcat(bp, ">");
1432         }
1433
1434         return (bp);
1435 }
1436
1437 static int
1438 ips_write_info(struct Scsi_Host *host, char *buffer, int length)
1439 {
1440         int i;
1441         ips_ha_t *ha = NULL;
1442
1443         /* Find our host structure */
1444         for (i = 0; i < ips_next_controller; i++) {
1445                 if (ips_sh[i]) {
1446                         if (ips_sh[i] == host) {
1447                                 ha = (ips_ha_t *) ips_sh[i]->hostdata;
1448                                 break;
1449                         }
1450                 }
1451         }
1452
1453         if (!ha)
1454                 return (-EINVAL);
1455
1456         return 0;
1457 }
1458
1459 static int
1460 ips_show_info(struct seq_file *m, struct Scsi_Host *host)
1461 {
1462         int i;
1463         ips_ha_t *ha = NULL;
1464
1465         /* Find our host structure */
1466         for (i = 0; i < ips_next_controller; i++) {
1467                 if (ips_sh[i]) {
1468                         if (ips_sh[i] == host) {
1469                                 ha = (ips_ha_t *) ips_sh[i]->hostdata;
1470                                 break;
1471                         }
1472                 }
1473         }
1474
1475         if (!ha)
1476                 return (-EINVAL);
1477
1478         return ips_host_info(ha, m);
1479 }
1480
1481 /*--------------------------------------------------------------------------*/
1482 /* Helper Functions                                                         */
1483 /*--------------------------------------------------------------------------*/
1484
1485 /****************************************************************************/
1486 /*                                                                          */
1487 /* Routine Name: ips_is_passthru                                            */
1488 /*                                                                          */
1489 /* Routine Description:                                                     */
1490 /*                                                                          */
1491 /*   Determine if the specified SCSI command is really a passthru command   */
1492 /*                                                                          */
1493 /****************************************************************************/
1494 static int ips_is_passthru(struct scsi_cmnd *SC)
1495 {
1496         unsigned long flags;
1497
1498         METHOD_TRACE("ips_is_passthru", 1);
1499
1500         if (!SC)
1501                 return (0);
1502
1503         if ((SC->cmnd[0] == IPS_IOCTL_COMMAND) &&
1504             (SC->device->channel == 0) &&
1505             (SC->device->id == IPS_ADAPTER_ID) &&
1506             (SC->device->lun == 0) && scsi_sglist(SC)) {
1507                 struct scatterlist *sg = scsi_sglist(SC);
1508                 char  *buffer;
1509
1510                 /* kmap_atomic() ensures addressability of the user buffer.*/
1511                 /* local_irq_save() protects the KM_IRQ0 address slot.     */
1512                 local_irq_save(flags);
1513                 buffer = kmap_atomic(sg_page(sg)) + sg->offset;
1514                 if (buffer && buffer[0] == 'C' && buffer[1] == 'O' &&
1515                     buffer[2] == 'P' && buffer[3] == 'P') {
1516                         kunmap_atomic(buffer - sg->offset);
1517                         local_irq_restore(flags);
1518                         return 1;
1519                 }
1520                 kunmap_atomic(buffer - sg->offset);
1521                 local_irq_restore(flags);
1522         }
1523         return 0;
1524 }
1525
1526 /****************************************************************************/
1527 /*                                                                          */
1528 /* Routine Name: ips_alloc_passthru_buffer                                  */
1529 /*                                                                          */
1530 /* Routine Description:                                                     */
1531 /*   allocate a buffer large enough for the ioctl data if the ioctl buffer  */
1532 /*   is too small or doesn't exist                                          */
1533 /****************************************************************************/
1534 static int
1535 ips_alloc_passthru_buffer(ips_ha_t * ha, int length)
1536 {
1537         void *bigger_buf;
1538         dma_addr_t dma_busaddr;
1539
1540         if (ha->ioctl_data && length <= ha->ioctl_len)
1541                 return 0;
1542         /* there is no buffer or it's not big enough, allocate a new one */
1543         bigger_buf = pci_alloc_consistent(ha->pcidev, length, &dma_busaddr);
1544         if (bigger_buf) {
1545                 /* free the old memory */
1546                 pci_free_consistent(ha->pcidev, ha->ioctl_len, ha->ioctl_data,
1547                                     ha->ioctl_busaddr);
1548                 /* use the new memory */
1549                 ha->ioctl_data = (char *) bigger_buf;
1550                 ha->ioctl_len = length;
1551                 ha->ioctl_busaddr = dma_busaddr;
1552         } else {
1553                 return -1;
1554         }
1555         return 0;
1556 }
1557
1558 /****************************************************************************/
1559 /*                                                                          */
1560 /* Routine Name: ips_make_passthru                                          */
1561 /*                                                                          */
1562 /* Routine Description:                                                     */
1563 /*                                                                          */
1564 /*   Make a passthru command out of the info in the Scsi block              */
1565 /*                                                                          */
1566 /****************************************************************************/
1567 static int
1568 ips_make_passthru(ips_ha_t *ha, struct scsi_cmnd *SC, ips_scb_t *scb, int intr)
1569 {
1570         ips_passthru_t *pt;
1571         int length = 0;
1572         int i, ret;
1573         struct scatterlist *sg = scsi_sglist(SC);
1574
1575         METHOD_TRACE("ips_make_passthru", 1);
1576
1577         scsi_for_each_sg(SC, sg, scsi_sg_count(SC), i)
1578                 length += sg->length;
1579
1580         if (length < sizeof (ips_passthru_t)) {
1581                 /* wrong size */
1582                 DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
1583                           ips_name, ha->host_num);
1584                 return (IPS_FAILURE);
1585         }
1586         if (ips_alloc_passthru_buffer(ha, length)) {
1587                 /* allocation failure!  If ha->ioctl_data exists, use it to return
1588                    some error codes.  Return a failed command to the scsi layer. */
1589                 if (ha->ioctl_data) {
1590                         pt = (ips_passthru_t *) ha->ioctl_data;
1591                         ips_scmd_buf_read(SC, pt, sizeof (ips_passthru_t));
1592                         pt->BasicStatus = 0x0B;
1593                         pt->ExtendedStatus = 0x00;
1594                         ips_scmd_buf_write(SC, pt, sizeof (ips_passthru_t));
1595                 }
1596                 return IPS_FAILURE;
1597         }
1598         ha->ioctl_datasize = length;
1599
1600         ips_scmd_buf_read(SC, ha->ioctl_data, ha->ioctl_datasize);
1601         pt = (ips_passthru_t *) ha->ioctl_data;
1602
1603         /*
1604          * Some notes about the passthru interface used
1605          *
1606          * IF the scsi op_code == 0x0d then we assume
1607          * that the data came along with/goes with the
1608          * packet we received from the sg driver. In this
1609          * case the CmdBSize field of the pt structure is
1610          * used for the size of the buffer.
1611          */
1612
1613         switch (pt->CoppCmd) {
1614         case IPS_NUMCTRLS:
1615                 memcpy(ha->ioctl_data + sizeof (ips_passthru_t),
1616                        &ips_num_controllers, sizeof (int));
1617                 ips_scmd_buf_write(SC, ha->ioctl_data,
1618                                    sizeof (ips_passthru_t) + sizeof (int));
1619                 SC->result = DID_OK << 16;
1620
1621                 return (IPS_SUCCESS_IMM);
1622
1623         case IPS_COPPUSRCMD:
1624         case IPS_COPPIOCCMD:
1625                 if (SC->cmnd[0] == IPS_IOCTL_COMMAND) {
1626                         if (length < (sizeof (ips_passthru_t) + pt->CmdBSize)) {
1627                                 /* wrong size */
1628                                 DEBUG_VAR(1,
1629                                           "(%s%d) Passthru structure wrong size",
1630                                           ips_name, ha->host_num);
1631
1632                                 return (IPS_FAILURE);
1633                         }
1634
1635                         if (ha->pcidev->device == IPS_DEVICEID_COPPERHEAD &&
1636                             pt->CoppCP.cmd.flashfw.op_code ==
1637                             IPS_CMD_RW_BIOSFW) {
1638                                 ret = ips_flash_copperhead(ha, pt, scb);
1639                                 ips_scmd_buf_write(SC, ha->ioctl_data,
1640                                                    sizeof (ips_passthru_t));
1641                                 return ret;
1642                         }
1643                         if (ips_usrcmd(ha, pt, scb))
1644                                 return (IPS_SUCCESS);
1645                         else
1646                                 return (IPS_FAILURE);
1647                 }
1648
1649                 break;
1650
1651         }                       /* end switch */
1652
1653         return (IPS_FAILURE);
1654 }
1655
1656 /****************************************************************************/
1657 /* Routine Name: ips_flash_copperhead                                       */
1658 /* Routine Description:                                                     */
1659 /*   Flash the BIOS/FW on a Copperhead style controller                     */
1660 /****************************************************************************/
1661 static int
1662 ips_flash_copperhead(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1663 {
1664         int datasize;
1665
1666         /* Trombone is the only copperhead that can do packet flash, but only
1667          * for firmware. No one said it had to make sense. */
1668         if (IPS_IS_TROMBONE(ha) && pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE) {
1669                 if (ips_usrcmd(ha, pt, scb))
1670                         return IPS_SUCCESS;
1671                 else
1672                         return IPS_FAILURE;
1673         }
1674         pt->BasicStatus = 0x0B;
1675         pt->ExtendedStatus = 0;
1676         scb->scsi_cmd->result = DID_OK << 16;
1677         /* IF it's OK to Use the "CD BOOT" Flash Buffer, then you can     */
1678         /* avoid allocating a huge buffer per adapter ( which can fail ). */
1679         if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1680             pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1681                 pt->BasicStatus = 0;
1682                 return ips_flash_bios(ha, pt, scb);
1683         } else if (pt->CoppCP.cmd.flashfw.packet_num == 0) {
1684                 if (ips_FlashData && !test_and_set_bit(0, &ips_FlashDataInUse)){
1685                         ha->flash_data = ips_FlashData;
1686                         ha->flash_busaddr = ips_flashbusaddr;
1687                         ha->flash_len = PAGE_SIZE << 7;
1688                         ha->flash_datasize = 0;
1689                 } else if (!ha->flash_data) {
1690                         datasize = pt->CoppCP.cmd.flashfw.total_packets *
1691                             pt->CoppCP.cmd.flashfw.count;
1692                         ha->flash_data = pci_alloc_consistent(ha->pcidev,
1693                                                               datasize,
1694                                                               &ha->flash_busaddr);
1695                         if (!ha->flash_data){
1696                                 printk(KERN_WARNING "Unable to allocate a flash buffer\n");
1697                                 return IPS_FAILURE;
1698                         }
1699                         ha->flash_datasize = 0;
1700                         ha->flash_len = datasize;
1701                 } else
1702                         return IPS_FAILURE;
1703         } else {
1704                 if (pt->CoppCP.cmd.flashfw.count + ha->flash_datasize >
1705                     ha->flash_len) {
1706                         ips_free_flash_copperhead(ha);
1707                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
1708                                    "failed size sanity check\n");
1709                         return IPS_FAILURE;
1710                 }
1711         }
1712         if (!ha->flash_data)
1713                 return IPS_FAILURE;
1714         pt->BasicStatus = 0;
1715         memcpy(&ha->flash_data[ha->flash_datasize], pt + 1,
1716                pt->CoppCP.cmd.flashfw.count);
1717         ha->flash_datasize += pt->CoppCP.cmd.flashfw.count;
1718         if (pt->CoppCP.cmd.flashfw.packet_num ==
1719             pt->CoppCP.cmd.flashfw.total_packets - 1) {
1720                 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE)
1721                         return ips_flash_bios(ha, pt, scb);
1722                 else if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE)
1723                         return ips_flash_firmware(ha, pt, scb);
1724         }
1725         return IPS_SUCCESS_IMM;
1726 }
1727
1728 /****************************************************************************/
1729 /* Routine Name: ips_flash_bios                                             */
1730 /* Routine Description:                                                     */
1731 /*   flashes the bios of a copperhead adapter                               */
1732 /****************************************************************************/
1733 static int
1734 ips_flash_bios(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1735 {
1736
1737         if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1738             pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_BIOS) {
1739                 if ((!ha->func.programbios) || (!ha->func.erasebios) ||
1740                     (!ha->func.verifybios))
1741                         goto error;
1742                 if ((*ha->func.erasebios) (ha)) {
1743                         DEBUG_VAR(1,
1744                                   "(%s%d) flash bios failed - unable to erase flash",
1745                                   ips_name, ha->host_num);
1746                         goto error;
1747                 } else
1748                     if ((*ha->func.programbios) (ha,
1749                                                  ha->flash_data +
1750                                                  IPS_BIOS_HEADER,
1751                                                  ha->flash_datasize -
1752                                                  IPS_BIOS_HEADER, 0)) {
1753                         DEBUG_VAR(1,
1754                                   "(%s%d) flash bios failed - unable to flash",
1755                                   ips_name, ha->host_num);
1756                         goto error;
1757                 } else
1758                     if ((*ha->func.verifybios) (ha,
1759                                                 ha->flash_data +
1760                                                 IPS_BIOS_HEADER,
1761                                                 ha->flash_datasize -
1762                                                 IPS_BIOS_HEADER, 0)) {
1763                         DEBUG_VAR(1,
1764                                   "(%s%d) flash bios failed - unable to verify flash",
1765                                   ips_name, ha->host_num);
1766                         goto error;
1767                 }
1768                 ips_free_flash_copperhead(ha);
1769                 return IPS_SUCCESS_IMM;
1770         } else if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1771                    pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1772                 if (!ha->func.erasebios)
1773                         goto error;
1774                 if ((*ha->func.erasebios) (ha)) {
1775                         DEBUG_VAR(1,
1776                                   "(%s%d) flash bios failed - unable to erase flash",
1777                                   ips_name, ha->host_num);
1778                         goto error;
1779                 }
1780                 return IPS_SUCCESS_IMM;
1781         }
1782       error:
1783         pt->BasicStatus = 0x0B;
1784         pt->ExtendedStatus = 0x00;
1785         ips_free_flash_copperhead(ha);
1786         return IPS_FAILURE;
1787 }
1788
1789 /****************************************************************************/
1790 /*                                                                          */
1791 /* Routine Name: ips_fill_scb_sg_single                                     */
1792 /*                                                                          */
1793 /* Routine Description:                                                     */
1794 /*   Fill in a single scb sg_list element from an address                   */
1795 /*   return a -1 if a breakup occurred                                      */
1796 /****************************************************************************/
1797 static int
1798 ips_fill_scb_sg_single(ips_ha_t * ha, dma_addr_t busaddr,
1799                        ips_scb_t * scb, int indx, unsigned int e_len)
1800 {
1801
1802         int ret_val = 0;
1803
1804         if ((scb->data_len + e_len) > ha->max_xfer) {
1805                 e_len = ha->max_xfer - scb->data_len;
1806                 scb->breakup = indx;
1807                 ++scb->sg_break;
1808                 ret_val = -1;
1809         } else {
1810                 scb->breakup = 0;
1811                 scb->sg_break = 0;
1812         }
1813         if (IPS_USE_ENH_SGLIST(ha)) {
1814                 scb->sg_list.enh_list[indx].address_lo =
1815                     cpu_to_le32(pci_dma_lo32(busaddr));
1816                 scb->sg_list.enh_list[indx].address_hi =
1817                     cpu_to_le32(pci_dma_hi32(busaddr));
1818                 scb->sg_list.enh_list[indx].length = cpu_to_le32(e_len);
1819         } else {
1820                 scb->sg_list.std_list[indx].address =
1821                     cpu_to_le32(pci_dma_lo32(busaddr));
1822                 scb->sg_list.std_list[indx].length = cpu_to_le32(e_len);
1823         }
1824
1825         ++scb->sg_len;
1826         scb->data_len += e_len;
1827         return ret_val;
1828 }
1829
1830 /****************************************************************************/
1831 /* Routine Name: ips_flash_firmware                                         */
1832 /* Routine Description:                                                     */
1833 /*   flashes the firmware of a copperhead adapter                           */
1834 /****************************************************************************/
1835 static int
1836 ips_flash_firmware(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1837 {
1838         IPS_SG_LIST sg_list;
1839         uint32_t cmd_busaddr;
1840
1841         if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE &&
1842             pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_FW) {
1843                 memset(&pt->CoppCP.cmd, 0, sizeof (IPS_HOST_COMMAND));
1844                 pt->CoppCP.cmd.flashfw.op_code = IPS_CMD_DOWNLOAD;
1845                 pt->CoppCP.cmd.flashfw.count = cpu_to_le32(ha->flash_datasize);
1846         } else {
1847                 pt->BasicStatus = 0x0B;
1848                 pt->ExtendedStatus = 0x00;
1849                 ips_free_flash_copperhead(ha);
1850                 return IPS_FAILURE;
1851         }
1852         /* Save the S/G list pointer so it doesn't get clobbered */
1853         sg_list.list = scb->sg_list.list;
1854         cmd_busaddr = scb->scb_busaddr;
1855         /* copy in the CP */
1856         memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1857         /* FIX stuff that might be wrong */
1858         scb->sg_list.list = sg_list.list;
1859         scb->scb_busaddr = cmd_busaddr;
1860         scb->bus = scb->scsi_cmd->device->channel;
1861         scb->target_id = scb->scsi_cmd->device->id;
1862         scb->lun = scb->scsi_cmd->device->lun;
1863         scb->sg_len = 0;
1864         scb->data_len = 0;
1865         scb->flags = 0;
1866         scb->op_code = 0;
1867         scb->callback = ipsintr_done;
1868         scb->timeout = ips_cmd_timeout;
1869
1870         scb->data_len = ha->flash_datasize;
1871         scb->data_busaddr =
1872             pci_map_single(ha->pcidev, ha->flash_data, scb->data_len,
1873                            IPS_DMA_DIR(scb));
1874         scb->flags |= IPS_SCB_MAP_SINGLE;
1875         scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
1876         scb->cmd.flashfw.buffer_addr = cpu_to_le32(scb->data_busaddr);
1877         if (pt->TimeOut)
1878                 scb->timeout = pt->TimeOut;
1879         scb->scsi_cmd->result = DID_OK << 16;
1880         return IPS_SUCCESS;
1881 }
1882
1883 /****************************************************************************/
1884 /* Routine Name: ips_free_flash_copperhead                                  */
1885 /* Routine Description:                                                     */
1886 /*   release the memory resources used to hold the flash image              */
1887 /****************************************************************************/
1888 static void
1889 ips_free_flash_copperhead(ips_ha_t * ha)
1890 {
1891         if (ha->flash_data == ips_FlashData)
1892                 test_and_clear_bit(0, &ips_FlashDataInUse);
1893         else if (ha->flash_data)
1894                 pci_free_consistent(ha->pcidev, ha->flash_len, ha->flash_data,
1895                                     ha->flash_busaddr);
1896         ha->flash_data = NULL;
1897 }
1898
1899 /****************************************************************************/
1900 /*                                                                          */
1901 /* Routine Name: ips_usrcmd                                                 */
1902 /*                                                                          */
1903 /* Routine Description:                                                     */
1904 /*                                                                          */
1905 /*   Process a user command and make it ready to send                       */
1906 /*                                                                          */
1907 /****************************************************************************/
1908 static int
1909 ips_usrcmd(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1910 {
1911         IPS_SG_LIST sg_list;
1912         uint32_t cmd_busaddr;
1913
1914         METHOD_TRACE("ips_usrcmd", 1);
1915
1916         if ((!scb) || (!pt) || (!ha))
1917                 return (0);
1918
1919         /* Save the S/G list pointer so it doesn't get clobbered */
1920         sg_list.list = scb->sg_list.list;
1921         cmd_busaddr = scb->scb_busaddr;
1922         /* copy in the CP */
1923         memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1924         memcpy(&scb->dcdb, &pt->CoppCP.dcdb, sizeof (IPS_DCDB_TABLE));
1925
1926         /* FIX stuff that might be wrong */
1927         scb->sg_list.list = sg_list.list;
1928         scb->scb_busaddr = cmd_busaddr;
1929         scb->bus = scb->scsi_cmd->device->channel;
1930         scb->target_id = scb->scsi_cmd->device->id;
1931         scb->lun = scb->scsi_cmd->device->lun;
1932         scb->sg_len = 0;
1933         scb->data_len = 0;
1934         scb->flags = 0;
1935         scb->op_code = 0;
1936         scb->callback = ipsintr_done;
1937         scb->timeout = ips_cmd_timeout;
1938         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
1939
1940         /* we don't support DCDB/READ/WRITE Scatter Gather */
1941         if ((scb->cmd.basic_io.op_code == IPS_CMD_READ_SG) ||
1942             (scb->cmd.basic_io.op_code == IPS_CMD_WRITE_SG) ||
1943             (scb->cmd.basic_io.op_code == IPS_CMD_DCDB_SG))
1944                 return (0);
1945
1946         if (pt->CmdBSize) {
1947                 scb->data_len = pt->CmdBSize;
1948                 scb->data_busaddr = ha->ioctl_busaddr + sizeof (ips_passthru_t);
1949         } else {
1950                 scb->data_busaddr = 0L;
1951         }
1952
1953         if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
1954                 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
1955                                                          (unsigned long) &scb->
1956                                                          dcdb -
1957                                                          (unsigned long) scb);
1958
1959         if (pt->CmdBSize) {
1960                 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
1961                         scb->dcdb.buffer_pointer =
1962                             cpu_to_le32(scb->data_busaddr);
1963                 else
1964                         scb->cmd.basic_io.sg_addr =
1965                             cpu_to_le32(scb->data_busaddr);
1966         }
1967
1968         /* set timeouts */
1969         if (pt->TimeOut) {
1970                 scb->timeout = pt->TimeOut;
1971
1972                 if (pt->TimeOut <= 10)
1973                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;
1974                 else if (pt->TimeOut <= 60)
1975                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;
1976                 else
1977                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
1978         }
1979
1980         /* assume success */
1981         scb->scsi_cmd->result = DID_OK << 16;
1982
1983         /* success */
1984         return (1);
1985 }
1986
1987 /****************************************************************************/
1988 /*                                                                          */
1989 /* Routine Name: ips_cleanup_passthru                                       */
1990 /*                                                                          */
1991 /* Routine Description:                                                     */
1992 /*                                                                          */
1993 /*   Cleanup after a passthru command                                       */
1994 /*                                                                          */
1995 /****************************************************************************/
1996 static void
1997 ips_cleanup_passthru(ips_ha_t * ha, ips_scb_t * scb)
1998 {
1999         ips_passthru_t *pt;
2000
2001         METHOD_TRACE("ips_cleanup_passthru", 1);
2002
2003         if ((!scb) || (!scb->scsi_cmd) || (!scsi_sglist(scb->scsi_cmd))) {
2004                 DEBUG_VAR(1, "(%s%d) couldn't cleanup after passthru",
2005                           ips_name, ha->host_num);
2006
2007                 return;
2008         }
2009         pt = (ips_passthru_t *) ha->ioctl_data;
2010
2011         /* Copy data back to the user */
2012         if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)      /* Copy DCDB Back to Caller's Area */
2013                 memcpy(&pt->CoppCP.dcdb, &scb->dcdb, sizeof (IPS_DCDB_TABLE));
2014
2015         pt->BasicStatus = scb->basic_status;
2016         pt->ExtendedStatus = scb->extended_status;
2017         pt->AdapterType = ha->ad_type;
2018
2019         if (ha->pcidev->device == IPS_DEVICEID_COPPERHEAD &&
2020             (scb->cmd.flashfw.op_code == IPS_CMD_DOWNLOAD ||
2021              scb->cmd.flashfw.op_code == IPS_CMD_RW_BIOSFW))
2022                 ips_free_flash_copperhead(ha);
2023
2024         ips_scmd_buf_write(scb->scsi_cmd, ha->ioctl_data, ha->ioctl_datasize);
2025 }
2026
2027 /****************************************************************************/
2028 /*                                                                          */
2029 /* Routine Name: ips_host_info                                              */
2030 /*                                                                          */
2031 /* Routine Description:                                                     */
2032 /*                                                                          */
2033 /*   The passthru interface for the driver                                  */
2034 /*                                                                          */
2035 /****************************************************************************/
2036 static int
2037 ips_host_info(ips_ha_t *ha, struct seq_file *m)
2038 {
2039         METHOD_TRACE("ips_host_info", 1);
2040
2041         seq_printf(m, "\nIBM ServeRAID General Information:\n\n");
2042
2043         if ((le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) &&
2044             (le16_to_cpu(ha->nvram->adapter_type) != 0))
2045                 seq_printf(m, "\tController Type                   : %s\n",
2046                           ips_adapter_name[ha->ad_type - 1]);
2047         else
2048                 seq_printf(m,
2049                           "\tController Type                   : Unknown\n");
2050
2051         if (ha->io_addr)
2052                 seq_printf(m,
2053                           "\tIO region                         : 0x%x (%d bytes)\n",
2054                           ha->io_addr, ha->io_len);
2055
2056         if (ha->mem_addr) {
2057                 seq_printf(m,
2058                           "\tMemory region                     : 0x%x (%d bytes)\n",
2059                           ha->mem_addr, ha->mem_len);
2060                 seq_printf(m,
2061                           "\tShared memory address             : 0x%lx\n",
2062                           (unsigned long)ha->mem_ptr);
2063         }
2064
2065         seq_printf(m, "\tIRQ number                        : %d\n", ha->pcidev->irq);
2066
2067     /* For the Next 3 lines Check for Binary 0 at the end and don't include it if it's there. */
2068     /* That keeps everything happy for "text" operations on the proc file.                    */
2069
2070         if (le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) {
2071         if (ha->nvram->bios_low[3] == 0) {
2072                 seq_printf(m,
2073                           "\tBIOS Version                      : %c%c%c%c%c%c%c\n",
2074                           ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2075                           ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2076                           ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2077                           ha->nvram->bios_low[2]);
2078
2079         } else {
2080                 seq_printf(m,
2081                           "\tBIOS Version                      : %c%c%c%c%c%c%c%c\n",
2082                           ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2083                           ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2084                           ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2085                           ha->nvram->bios_low[2], ha->nvram->bios_low[3]);
2086         }
2087
2088     }
2089
2090     if (ha->enq->CodeBlkVersion[7] == 0) {
2091         seq_printf(m,
2092                   "\tFirmware Version                  : %c%c%c%c%c%c%c\n",
2093                   ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2094                   ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2095                   ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2096                   ha->enq->CodeBlkVersion[6]);
2097     } else {
2098         seq_printf(m,
2099                   "\tFirmware Version                  : %c%c%c%c%c%c%c%c\n",
2100                   ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2101                   ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2102                   ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2103                   ha->enq->CodeBlkVersion[6], ha->enq->CodeBlkVersion[7]);
2104     }
2105
2106     if (ha->enq->BootBlkVersion[7] == 0) {
2107         seq_printf(m,
2108                   "\tBoot Block Version                : %c%c%c%c%c%c%c\n",
2109                   ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2110                   ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2111                   ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2112                   ha->enq->BootBlkVersion[6]);
2113     } else {
2114         seq_printf(m,
2115                   "\tBoot Block Version                : %c%c%c%c%c%c%c%c\n",
2116                   ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2117                   ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2118                   ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2119                   ha->enq->BootBlkVersion[6], ha->enq->BootBlkVersion[7]);
2120     }
2121
2122         seq_printf(m, "\tDriver Version                    : %s%s\n",
2123                   IPS_VERSION_HIGH, IPS_VERSION_LOW);
2124
2125         seq_printf(m, "\tDriver Build                      : %d\n",
2126                   IPS_BUILD_IDENT);
2127
2128         seq_printf(m, "\tMax Physical Devices              : %d\n",
2129                   ha->enq->ucMaxPhysicalDevices);
2130         seq_printf(m, "\tMax Active Commands               : %d\n",
2131                   ha->max_cmds);
2132         seq_printf(m, "\tCurrent Queued Commands           : %d\n",
2133                   ha->scb_waitlist.count);
2134         seq_printf(m, "\tCurrent Active Commands           : %d\n",
2135                   ha->scb_activelist.count - ha->num_ioctl);
2136         seq_printf(m, "\tCurrent Queued PT Commands        : %d\n",
2137                   ha->copp_waitlist.count);
2138         seq_printf(m, "\tCurrent Active PT Commands        : %d\n",
2139                   ha->num_ioctl);
2140
2141         seq_printf(m, "\n");
2142
2143         return 0;
2144 }
2145
2146 /****************************************************************************/
2147 /*                                                                          */
2148 /* Routine Name: ips_identify_controller                                    */
2149 /*                                                                          */
2150 /* Routine Description:                                                     */
2151 /*                                                                          */
2152 /*   Identify this controller                                               */
2153 /*                                                                          */
2154 /****************************************************************************/
2155 static void
2156 ips_identify_controller(ips_ha_t * ha)
2157 {
2158         METHOD_TRACE("ips_identify_controller", 1);
2159
2160         switch (ha->pcidev->device) {
2161         case IPS_DEVICEID_COPPERHEAD:
2162                 if (ha->pcidev->revision <= IPS_REVID_SERVERAID) {
2163                         ha->ad_type = IPS_ADTYPE_SERVERAID;
2164                 } else if (ha->pcidev->revision == IPS_REVID_SERVERAID2) {
2165                         ha->ad_type = IPS_ADTYPE_SERVERAID2;
2166                 } else if (ha->pcidev->revision == IPS_REVID_NAVAJO) {
2167                         ha->ad_type = IPS_ADTYPE_NAVAJO;
2168                 } else if ((ha->pcidev->revision == IPS_REVID_SERVERAID2)
2169                            && (ha->slot_num == 0)) {
2170                         ha->ad_type = IPS_ADTYPE_KIOWA;
2171                 } else if ((ha->pcidev->revision >= IPS_REVID_CLARINETP1) &&
2172                            (ha->pcidev->revision <= IPS_REVID_CLARINETP3)) {
2173                         if (ha->enq->ucMaxPhysicalDevices == 15)
2174                                 ha->ad_type = IPS_ADTYPE_SERVERAID3L;
2175                         else
2176                                 ha->ad_type = IPS_ADTYPE_SERVERAID3;
2177                 } else if ((ha->pcidev->revision >= IPS_REVID_TROMBONE32) &&
2178                            (ha->pcidev->revision <= IPS_REVID_TROMBONE64)) {
2179                         ha->ad_type = IPS_ADTYPE_SERVERAID4H;
2180                 }
2181                 break;
2182
2183         case IPS_DEVICEID_MORPHEUS:
2184                 switch (ha->pcidev->subsystem_device) {
2185                 case IPS_SUBDEVICEID_4L:
2186                         ha->ad_type = IPS_ADTYPE_SERVERAID4L;
2187                         break;
2188
2189                 case IPS_SUBDEVICEID_4M:
2190                         ha->ad_type = IPS_ADTYPE_SERVERAID4M;
2191                         break;
2192
2193                 case IPS_SUBDEVICEID_4MX:
2194                         ha->ad_type = IPS_ADTYPE_SERVERAID4MX;
2195                         break;
2196
2197                 case IPS_SUBDEVICEID_4LX:
2198                         ha->ad_type = IPS_ADTYPE_SERVERAID4LX;
2199                         break;
2200
2201                 case IPS_SUBDEVICEID_5I2:
2202                         ha->ad_type = IPS_ADTYPE_SERVERAID5I2;
2203                         break;
2204
2205                 case IPS_SUBDEVICEID_5I1:
2206                         ha->ad_type = IPS_ADTYPE_SERVERAID5I1;
2207                         break;
2208                 }
2209
2210                 break;
2211
2212         case IPS_DEVICEID_MARCO:
2213                 switch (ha->pcidev->subsystem_device) {
2214                 case IPS_SUBDEVICEID_6M:
2215                         ha->ad_type = IPS_ADTYPE_SERVERAID6M;
2216                         break;
2217                 case IPS_SUBDEVICEID_6I:
2218                         ha->ad_type = IPS_ADTYPE_SERVERAID6I;
2219                         break;
2220                 case IPS_SUBDEVICEID_7k:
2221                         ha->ad_type = IPS_ADTYPE_SERVERAID7k;
2222                         break;
2223                 case IPS_SUBDEVICEID_7M:
2224                         ha->ad_type = IPS_ADTYPE_SERVERAID7M;
2225                         break;
2226                 }
2227                 break;
2228         }
2229 }
2230
2231 /****************************************************************************/
2232 /*                                                                          */
2233 /* Routine Name: ips_get_bios_version                                       */
2234 /*                                                                          */
2235 /* Routine Description:                                                     */
2236 /*                                                                          */
2237 /*   Get the BIOS revision number                                           */
2238 /*                                                                          */
2239 /****************************************************************************/
2240 static void
2241 ips_get_bios_version(ips_ha_t * ha, int intr)
2242 {
2243         ips_scb_t *scb;
2244         int ret;
2245         uint8_t major;
2246         uint8_t minor;
2247         uint8_t subminor;
2248         uint8_t *buffer;
2249         char hexDigits[] =
2250             { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
2251      'D', 'E', 'F' };
2252
2253         METHOD_TRACE("ips_get_bios_version", 1);
2254
2255         major = 0;
2256         minor = 0;
2257
2258         strncpy(ha->bios_version, "       ?", 8);
2259
2260         if (ha->pcidev->device == IPS_DEVICEID_COPPERHEAD) {
2261                 if (IPS_USE_MEMIO(ha)) {
2262                         /* Memory Mapped I/O */
2263
2264                         /* test 1st byte */
2265                         writel(0, ha->mem_ptr + IPS_REG_FLAP);
2266                         if (ha->pcidev->revision == IPS_REVID_TROMBONE64)
2267                                 udelay(25);     /* 25 us */
2268
2269                         if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
2270                                 return;
2271
2272                         writel(1, ha->mem_ptr + IPS_REG_FLAP);
2273                         if (ha->pcidev->revision == IPS_REVID_TROMBONE64)
2274                                 udelay(25);     /* 25 us */
2275
2276                         if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
2277                                 return;
2278
2279                         /* Get Major version */
2280                         writel(0x1FF, ha->mem_ptr + IPS_REG_FLAP);
2281                         if (ha->pcidev->revision == IPS_REVID_TROMBONE64)
2282                                 udelay(25);     /* 25 us */
2283
2284                         major = readb(ha->mem_ptr + IPS_REG_FLDP);
2285
2286                         /* Get Minor version */
2287                         writel(0x1FE, ha->mem_ptr + IPS_REG_FLAP);
2288                         if (ha->pcidev->revision == IPS_REVID_TROMBONE64)
2289                                 udelay(25);     /* 25 us */
2290                         minor = readb(ha->mem_ptr + IPS_REG_FLDP);
2291
2292                         /* Get SubMinor version */
2293                         writel(0x1FD, ha->mem_ptr + IPS_REG_FLAP);
2294                         if (ha->pcidev->revision == IPS_REVID_TROMBONE64)
2295                                 udelay(25);     /* 25 us */
2296                         subminor = readb(ha->mem_ptr + IPS_REG_FLDP);
2297
2298                 } else {
2299                         /* Programmed I/O */
2300
2301                         /* test 1st byte */
2302                         outl(0, ha->io_addr + IPS_REG_FLAP);
2303                         if (ha->pcidev->revision == IPS_REVID_TROMBONE64)
2304                                 udelay(25);     /* 25 us */
2305
2306                         if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
2307                                 return;
2308
2309                         outl(1, ha->io_addr + IPS_REG_FLAP);
2310                         if (ha->pcidev->revision == IPS_REVID_TROMBONE64)
2311                                 udelay(25);     /* 25 us */
2312
2313                         if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
2314                                 return;
2315
2316                         /* Get Major version */
2317                         outl(0x1FF, ha->io_addr + IPS_REG_FLAP);
2318                         if (ha->pcidev->revision == IPS_REVID_TROMBONE64)
2319                                 udelay(25);     /* 25 us */
2320
2321                         major = inb(ha->io_addr + IPS_REG_FLDP);
2322
2323                         /* Get Minor version */
2324                         outl(0x1FE, ha->io_addr + IPS_REG_FLAP);
2325                         if (ha->pcidev->revision == IPS_REVID_TROMBONE64)
2326                                 udelay(25);     /* 25 us */
2327
2328                         minor = inb(ha->io_addr + IPS_REG_FLDP);
2329
2330                         /* Get SubMinor version */
2331                         outl(0x1FD, ha->io_addr + IPS_REG_FLAP);
2332                         if (ha->pcidev->revision == IPS_REVID_TROMBONE64)
2333                                 udelay(25);     /* 25 us */
2334
2335                         subminor = inb(ha->io_addr + IPS_REG_FLDP);
2336
2337                 }
2338         } else {
2339                 /* Morpheus Family - Send Command to the card */
2340
2341                 buffer = ha->ioctl_data;
2342
2343                 memset(buffer, 0, 0x1000);
2344
2345                 scb = &ha->scbs[ha->max_cmds - 1];
2346
2347                 ips_init_scb(ha, scb);
2348
2349                 scb->timeout = ips_cmd_timeout;
2350                 scb->cdb[0] = IPS_CMD_RW_BIOSFW;
2351
2352                 scb->cmd.flashfw.op_code = IPS_CMD_RW_BIOSFW;
2353                 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
2354                 scb->cmd.flashfw.type = 1;
2355                 scb->cmd.flashfw.direction = 0;
2356                 scb->cmd.flashfw.count = cpu_to_le32(0x800);
2357                 scb->cmd.flashfw.total_packets = 1;
2358                 scb->cmd.flashfw.packet_num = 0;
2359                 scb->data_len = 0x1000;
2360                 scb->cmd.flashfw.buffer_addr = ha->ioctl_busaddr;
2361
2362                 /* issue the command */
2363                 if (((ret =
2364                       ips_send_wait(ha, scb, ips_cmd_timeout,
2365                                     intr)) == IPS_FAILURE)
2366                     || (ret == IPS_SUCCESS_IMM)
2367                     || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
2368                         /* Error occurred */
2369
2370                         return;
2371                 }
2372
2373                 if ((buffer[0xC0] == 0x55) && (buffer[0xC1] == 0xAA)) {
2374                         major = buffer[0x1ff + 0xC0];   /* Offset 0x1ff after the header (0xc0) */
2375                         minor = buffer[0x1fe + 0xC0];   /* Offset 0x1fe after the header (0xc0) */
2376                         subminor = buffer[0x1fd + 0xC0];        /* Offset 0x1fd after the header (0xc0) */
2377                 } else {
2378                         return;
2379                 }
2380         }
2381
2382         ha->bios_version[0] = hexDigits[(major & 0xF0) >> 4];
2383         ha->bios_version[1] = '.';
2384         ha->bios_version[2] = hexDigits[major & 0x0F];
2385         ha->bios_version[3] = hexDigits[subminor];
2386         ha->bios_version[4] = '.';
2387         ha->bios_version[5] = hexDigits[(minor & 0xF0) >> 4];
2388         ha->bios_version[6] = hexDigits[minor & 0x0F];
2389         ha->bios_version[7] = 0;
2390 }
2391
2392 /****************************************************************************/
2393 /*                                                                          */
2394 /* Routine Name: ips_hainit                                                 */
2395 /*                                                                          */
2396 /* Routine Description:                                                     */
2397 /*                                                                          */
2398 /*   Initialize the controller                                              */
2399 /*                                                                          */
2400 /* NOTE: Assumes to be called from with a lock                              */
2401 /*                                                                          */
2402 /****************************************************************************/
2403 static int
2404 ips_hainit(ips_ha_t * ha)
2405 {
2406         int i;
2407         struct timeval tv;
2408
2409         METHOD_TRACE("ips_hainit", 1);
2410
2411         if (!ha)
2412                 return (0);
2413
2414         if (ha->func.statinit)
2415                 (*ha->func.statinit) (ha);
2416
2417         if (ha->func.enableint)
2418                 (*ha->func.enableint) (ha);
2419
2420         /* Send FFDC */
2421         ha->reset_count = 1;
2422         do_gettimeofday(&tv);
2423         ha->last_ffdc = tv.tv_sec;
2424         ips_ffdc_reset(ha, IPS_INTR_IORL);
2425
2426         if (!ips_read_config(ha, IPS_INTR_IORL)) {
2427                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2428                            "unable to read config from controller.\n");
2429
2430                 return (0);
2431         }
2432         /* end if */
2433         if (!ips_read_adapter_status(ha, IPS_INTR_IORL)) {
2434                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2435                            "unable to read controller status.\n");
2436
2437                 return (0);
2438         }
2439
2440         /* Identify this controller */
2441         ips_identify_controller(ha);
2442
2443         if (!ips_read_subsystem_parameters(ha, IPS_INTR_IORL)) {
2444                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2445                            "unable to read subsystem parameters.\n");
2446
2447                 return (0);
2448         }
2449
2450         /* write nvram user page 5 */
2451         if (!ips_write_driver_status(ha, IPS_INTR_IORL)) {
2452                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2453                            "unable to write driver info to controller.\n");
2454
2455                 return (0);
2456         }
2457
2458         /* If there are Logical Drives and a Reset Occurred, then an EraseStripeLock is Needed */
2459         if ((ha->conf->ucLogDriveCount > 0) && (ha->requires_esl == 1))
2460                 ips_clear_adapter(ha, IPS_INTR_IORL);
2461
2462         /* set limits on SID, LUN, BUS */
2463         ha->ntargets = IPS_MAX_TARGETS + 1;
2464         ha->nlun = 1;
2465         ha->nbus = (ha->enq->ucMaxPhysicalDevices / IPS_MAX_TARGETS) + 1;
2466
2467         switch (ha->conf->logical_drive[0].ucStripeSize) {
2468         case 4:
2469                 ha->max_xfer = 0x10000;
2470                 break;
2471
2472         case 5:
2473                 ha->max_xfer = 0x20000;
2474                 break;
2475
2476         case 6:
2477                 ha->max_xfer = 0x40000;
2478                 break;
2479
2480         case 7:
2481         default:
2482                 ha->max_xfer = 0x80000;
2483                 break;
2484         }
2485
2486         /* setup max concurrent commands */
2487         if (le32_to_cpu(ha->subsys->param[4]) & 0x1) {
2488                 /* Use the new method */
2489                 ha->max_cmds = ha->enq->ucConcurrentCmdCount;
2490         } else {
2491                 /* use the old method */
2492                 switch (ha->conf->logical_drive[0].ucStripeSize) {
2493                 case 4:
2494                         ha->max_cmds = 32;
2495                         break;
2496
2497                 case 5:
2498                         ha->max_cmds = 16;
2499                         break;
2500
2501                 case 6:
2502                         ha->max_cmds = 8;
2503                         break;
2504
2505                 case 7:
2506                 default:
2507                         ha->max_cmds = 4;
2508                         break;
2509                 }
2510         }
2511
2512         /* Limit the Active Commands on a Lite Adapter */
2513         if ((ha->ad_type == IPS_ADTYPE_SERVERAID3L) ||
2514             (ha->ad_type == IPS_ADTYPE_SERVERAID4L) ||
2515             (ha->ad_type == IPS_ADTYPE_SERVERAID4LX)) {
2516                 if ((ha->max_cmds > MaxLiteCmds) && (MaxLiteCmds))
2517                         ha->max_cmds = MaxLiteCmds;
2518         }
2519
2520         /* set controller IDs */
2521         ha->ha_id[0] = IPS_ADAPTER_ID;
2522         for (i = 1; i < ha->nbus; i++) {
2523                 ha->ha_id[i] = ha->conf->init_id[i - 1] & 0x1f;
2524                 ha->dcdb_active[i - 1] = 0;
2525         }
2526
2527         return (1);
2528 }
2529
2530 /****************************************************************************/
2531 /*                                                                          */
2532 /* Routine Name: ips_next                                                   */
2533 /*                                                                          */
2534 /* Routine Description:                                                     */
2535 /*                                                                          */
2536 /*   Take the next command off the queue and send it to the controller      */
2537 /*                                                                          */
2538 /****************************************************************************/
2539 static void
2540 ips_next(ips_ha_t * ha, int intr)
2541 {
2542         ips_scb_t *scb;
2543         struct scsi_cmnd *SC;
2544         struct scsi_cmnd *p;
2545         struct scsi_cmnd *q;
2546         ips_copp_wait_item_t *item;
2547         int ret;
2548         struct Scsi_Host *host;
2549         METHOD_TRACE("ips_next", 1);
2550
2551         if (!ha)
2552                 return;
2553         host = ips_sh[ha->host_num];
2554         /*
2555          * Block access to the queue function so
2556          * this command won't time out
2557          */
2558         if (intr == IPS_INTR_ON)
2559                 spin_lock(host->host_lock);
2560
2561         if ((ha->subsys->param[3] & 0x300000)
2562             && (ha->scb_activelist.count == 0)) {
2563                 struct timeval tv;
2564
2565                 do_gettimeofday(&tv);
2566
2567                 if (tv.tv_sec - ha->last_ffdc > IPS_SECS_8HOURS) {
2568                         ha->last_ffdc = tv.tv_sec;
2569                         ips_ffdc_time(ha);
2570                 }
2571         }
2572
2573         /*
2574          * Send passthru commands
2575          * These have priority over normal I/O
2576          * but shouldn't affect performance too much
2577          * since we limit the number that can be active
2578          * on the card at any one time
2579          */
2580         while ((ha->num_ioctl < IPS_MAX_IOCTL) &&
2581                (ha->copp_waitlist.head) && (scb = ips_getscb(ha))) {
2582
2583                 item = ips_removeq_copp_head(&ha->copp_waitlist);
2584                 ha->num_ioctl++;
2585                 if (intr == IPS_INTR_ON)
2586                         spin_unlock(host->host_lock);
2587                 scb->scsi_cmd = item->scsi_cmd;
2588                 kfree(item);
2589
2590                 ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
2591
2592                 if (intr == IPS_INTR_ON)
2593                         spin_lock(host->host_lock);
2594                 switch (ret) {
2595                 case IPS_FAILURE:
2596                         if (scb->scsi_cmd) {
2597                                 scb->scsi_cmd->result = DID_ERROR << 16;
2598                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2599                         }
2600
2601                         ips_freescb(ha, scb);
2602                         break;
2603                 case IPS_SUCCESS_IMM:
2604                         if (scb->scsi_cmd) {
2605                                 scb->scsi_cmd->result = DID_OK << 16;
2606                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2607                         }
2608
2609                         ips_freescb(ha, scb);
2610                         break;
2611                 default:
2612                         break;
2613                 }               /* end case */
2614
2615                 if (ret != IPS_SUCCESS) {
2616                         ha->num_ioctl--;
2617                         continue;
2618                 }
2619
2620                 ret = ips_send_cmd(ha, scb);
2621
2622                 if (ret == IPS_SUCCESS)
2623                         ips_putq_scb_head(&ha->scb_activelist, scb);
2624                 else
2625                         ha->num_ioctl--;
2626
2627                 switch (ret) {
2628                 case IPS_FAILURE:
2629                         if (scb->scsi_cmd) {
2630                                 scb->scsi_cmd->result = DID_ERROR << 16;
2631                         }
2632
2633                         ips_freescb(ha, scb);
2634                         break;
2635                 case IPS_SUCCESS_IMM:
2636                         ips_freescb(ha, scb);
2637                         break;
2638                 default:
2639                         break;
2640                 }               /* end case */
2641
2642         }
2643
2644         /*
2645          * Send "Normal" I/O commands
2646          */
2647
2648         p = ha->scb_waitlist.head;
2649         while ((p) && (scb = ips_getscb(ha))) {
2650                 if ((scmd_channel(p) > 0)
2651                     && (ha->
2652                         dcdb_active[scmd_channel(p) -
2653                                     1] & (1 << scmd_id(p)))) {
2654                         ips_freescb(ha, scb);
2655                         p = (struct scsi_cmnd *) p->host_scribble;
2656                         continue;
2657                 }
2658
2659                 q = p;
2660                 SC = ips_removeq_wait(&ha->scb_waitlist, q);
2661
2662                 if (intr == IPS_INTR_ON)
2663                         spin_unlock(host->host_lock);   /* Unlock HA after command is taken off queue */
2664
2665                 SC->result = DID_OK;
2666                 SC->host_scribble = NULL;
2667
2668                 scb->target_id = SC->device->id;
2669                 scb->lun = SC->device->lun;
2670                 scb->bus = SC->device->channel;
2671                 scb->scsi_cmd = SC;
2672                 scb->breakup = 0;
2673                 scb->data_len = 0;
2674                 scb->callback = ipsintr_done;
2675                 scb->timeout = ips_cmd_timeout;
2676                 memset(&scb->cmd, 0, 16);
2677
2678                 /* copy in the CDB */
2679                 memcpy(scb->cdb, SC->cmnd, SC->cmd_len);
2680
2681                 scb->sg_count = scsi_dma_map(SC);
2682                 BUG_ON(scb->sg_count < 0);
2683                 if (scb->sg_count) {
2684                         struct scatterlist *sg;
2685                         int i;
2686
2687                         scb->flags |= IPS_SCB_MAP_SG;
2688
2689                         scsi_for_each_sg(SC, sg, scb->sg_count, i) {
2690                                 if (ips_fill_scb_sg_single
2691                                     (ha, sg_dma_address(sg), scb, i,
2692                                      sg_dma_len(sg)) < 0)
2693                                         break;
2694                         }
2695                         scb->dcdb.transfer_length = scb->data_len;
2696                 } else {
2697                         scb->data_busaddr = 0L;
2698                         scb->sg_len = 0;
2699                         scb->data_len = 0;
2700                         scb->dcdb.transfer_length = 0;
2701                 }
2702
2703                 scb->dcdb.cmd_attribute =
2704                     ips_command_direction[scb->scsi_cmd->cmnd[0]];
2705
2706                 /* Allow a WRITE BUFFER Command to Have no Data */
2707                 /* This is Used by Tape Flash Utilites          */
2708                 if ((scb->scsi_cmd->cmnd[0] == WRITE_BUFFER) &&
2709                                 (scb->data_len == 0))
2710                         scb->dcdb.cmd_attribute = 0;
2711
2712                 if (!(scb->dcdb.cmd_attribute & 0x3))
2713                         scb->dcdb.transfer_length = 0;
2714
2715                 if (scb->data_len >= IPS_MAX_XFER) {
2716                         scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
2717                         scb->dcdb.transfer_length = 0;
2718                 }
2719                 if (intr == IPS_INTR_ON)
2720                         spin_lock(host->host_lock);
2721
2722                 ret = ips_send_cmd(ha, scb);
2723
2724                 switch (ret) {
2725                 case IPS_SUCCESS:
2726                         ips_putq_scb_head(&ha->scb_activelist, scb);
2727                         break;
2728                 case IPS_FAILURE:
2729                         if (scb->scsi_cmd) {
2730                                 scb->scsi_cmd->result = DID_ERROR << 16;
2731                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2732                         }
2733
2734                         if (scb->bus)
2735                                 ha->dcdb_active[scb->bus - 1] &=
2736                                     ~(1 << scb->target_id);
2737
2738                         ips_freescb(ha, scb);
2739                         break;
2740                 case IPS_SUCCESS_IMM:
2741                         if (scb->scsi_cmd)
2742                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2743
2744                         if (scb->bus)
2745                                 ha->dcdb_active[scb->bus - 1] &=
2746                                     ~(1 << scb->target_id);
2747
2748                         ips_freescb(ha, scb);
2749                         break;
2750                 default:
2751                         break;
2752                 }               /* end case */
2753
2754                 p = (struct scsi_cmnd *) p->host_scribble;
2755
2756         }                       /* end while */
2757
2758         if (intr == IPS_INTR_ON)
2759                 spin_unlock(host->host_lock);
2760 }
2761
2762 /****************************************************************************/
2763 /*                                                                          */
2764 /* Routine Name: ips_putq_scb_head                                          */
2765 /*                                                                          */
2766 /* Routine Description:                                                     */
2767 /*                                                                          */
2768 /*   Add an item to the head of the queue                                   */
2769 /*                                                                          */
2770 /* ASSUMED to be called from within the HA lock                             */
2771 /*                                                                          */
2772 /****************************************************************************/
2773 static void
2774 ips_putq_scb_head(ips_scb_queue_t * queue, ips_scb_t * item)
2775 {
2776         METHOD_TRACE("ips_putq_scb_head", 1);
2777
2778         if (!item)
2779                 return;
2780
2781         item->q_next = queue->head;
2782         queue->head = item;
2783
2784         if (!queue->tail)
2785                 queue->tail = item;
2786
2787         queue->count++;
2788 }
2789
2790 /****************************************************************************/
2791 /*                                                                          */
2792 /* Routine Name: ips_removeq_scb_head                                       */
2793 /*                                                                          */
2794 /* Routine Description:                                                     */
2795 /*                                                                          */
2796 /*   Remove the head of the queue                                           */
2797 /*                                                                          */
2798 /* ASSUMED to be called from within the HA lock                             */
2799 /*                                                                          */
2800 /****************************************************************************/
2801 static ips_scb_t *
2802 ips_removeq_scb_head(ips_scb_queue_t * queue)
2803 {
2804         ips_scb_t *item;
2805
2806         METHOD_TRACE("ips_removeq_scb_head", 1);
2807
2808         item = queue->head;
2809
2810         if (!item) {
2811                 return (NULL);
2812         }
2813
2814         queue->head = item->q_next;
2815         item->q_next = NULL;
2816
2817         if (queue->tail == item)
2818                 queue->tail = NULL;
2819
2820         queue->count--;
2821
2822         return (item);
2823 }
2824
2825 /****************************************************************************/
2826 /*                                                                          */
2827 /* Routine Name: ips_removeq_scb                                            */
2828 /*                                                                          */
2829 /* Routine Description:                                                     */
2830 /*                                                                          */
2831 /*   Remove an item from a queue                                            */
2832 /*                                                                          */
2833 /* ASSUMED to be called from within the HA lock                             */
2834 /*                                                                          */
2835 /****************************************************************************/
2836 static ips_scb_t *
2837 ips_removeq_scb(ips_scb_queue_t * queue, ips_scb_t * item)
2838 {
2839         ips_scb_t *p;
2840
2841         METHOD_TRACE("ips_removeq_scb", 1);
2842
2843         if (!item)
2844                 return (NULL);
2845
2846         if (item == queue->head) {
2847                 return (ips_removeq_scb_head(queue));
2848         }
2849
2850         p = queue->head;
2851
2852         while ((p) && (item != p->q_next))
2853                 p = p->q_next;
2854
2855         if (p) {
2856                 /* found a match */
2857                 p->q_next = item->q_next;
2858
2859                 if (!item->q_next)
2860                         queue->tail = p;
2861
2862                 item->q_next = NULL;
2863                 queue->count--;
2864
2865                 return (item);
2866         }
2867
2868         return (NULL);
2869 }
2870
2871 /****************************************************************************/
2872 /*                                                                          */
2873 /* Routine Name: ips_putq_wait_tail                                         */
2874 /*                                                                          */
2875 /* Routine Description:                                                     */
2876 /*                                                                          */
2877 /*   Add an item to the tail of the queue                                   */
2878 /*                                                                          */
2879 /* ASSUMED to be called from within the HA lock                             */
2880 /*                                                                          */
2881 /****************************************************************************/
2882 static void ips_putq_wait_tail(ips_wait_queue_t *queue, struct scsi_cmnd *item)
2883 {
2884         METHOD_TRACE("ips_putq_wait_tail", 1);
2885
2886         if (!item)
2887                 return;
2888
2889         item->host_scribble = NULL;
2890
2891         if (queue->tail)
2892                 queue->tail->host_scribble = (char *) item;
2893
2894         queue->tail = item;
2895
2896         if (!queue->head)
2897                 queue->head = item;
2898
2899         queue->count++;
2900 }
2901
2902 /****************************************************************************/
2903 /*                                                                          */
2904 /* Routine Name: ips_removeq_wait_head                                      */
2905 /*                                                                          */
2906 /* Routine Description:                                                     */
2907 /*                                                                          */
2908 /*   Remove the head of the queue                                           */
2909 /*                                                                          */
2910 /* ASSUMED to be called from within the HA lock                             */
2911 /*                                                                          */
2912 /****************************************************************************/
2913 static struct scsi_cmnd *ips_removeq_wait_head(ips_wait_queue_t *queue)
2914 {
2915         struct scsi_cmnd *item;
2916
2917         METHOD_TRACE("ips_removeq_wait_head", 1);
2918
2919         item = queue->head;
2920
2921         if (!item) {
2922                 return (NULL);
2923         }
2924
2925         queue->head = (struct scsi_cmnd *) item->host_scribble;
2926         item->host_scribble = NULL;
2927
2928         if (queue->tail == item)
2929                 queue->tail = NULL;
2930
2931         queue->count--;
2932
2933         return (item);
2934 }
2935
2936 /****************************************************************************/
2937 /*                                                                          */
2938 /* Routine Name: ips_removeq_wait                                           */
2939 /*                                                                          */
2940 /* Routine Description:                                                     */
2941 /*                                                                          */
2942 /*   Remove an item from a queue                                            */
2943 /*                                                                          */
2944 /* ASSUMED to be called from within the HA lock                             */
2945 /*                                                                          */
2946 /****************************************************************************/