git.oblomov.eu Git - linux-2.6/blob - 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 whereever 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/version.h>
 169 #include <linux/string.h>
 170 #include <linux/errno.h>
 171 #include <linux/kernel.h>
 172 #include <linux/ioport.h>
 173 #include <linux/slab.h>
 174 #include <linux/delay.h>
 175 #include <linux/pci.h>
 176 #include <linux/proc_fs.h>
 177 #include <linux/reboot.h>
 178 #include <linux/interrupt.h>
 179
 180 #include <linux/blkdev.h>
 181 #include <linux/types.h>
 182 #include <linux/dma-mapping.h>
 183
 184 #include <scsi/sg.h>
 185 #include "scsi.h"
 186 #include <scsi/scsi_host.h>
 187
 188 #include "ips.h"
 189
 190 #include <linux/module.h>
 191
 192 #include <linux/stat.h>
 193
 194 #include <linux/spinlock.h>
 195 #include <linux/init.h>
 196
 197 #include <linux/smp.h>
 198
 199 #ifdef MODULE
 200 static char *ips = NULL;
 201 module_param(ips, charp, 0);
 202 #endif
 203
 204 /*
 205  * DRIVER_VER
 206  */
 207 #define IPS_VERSION_HIGH        "7.12"
 208 #define IPS_VERSION_LOW         ".05 "
 209
 210 #if !defined(__i386__) && !defined(__ia64__) && !defined(__x86_64__)
 211 #warning "This driver has only been tested on the x86/ia64/x86_64 platforms"
 212 #endif
 213
 214 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
 215 #include <linux/blk.h>
 216 #include "sd.h"
 217 #define IPS_LOCK_SAVE(lock,flags) spin_lock_irqsave(&io_request_lock,flags)
 218 #define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock_irqrestore(&io_request_lock,flags)
 219 #ifndef __devexit_p
 220 #define __devexit_p(x) x
 221 #endif
 222 #else
 223 #define IPS_LOCK_SAVE(lock,flags) do{spin_lock(lock);(void)flags;}while(0)
 224 #define IPS_UNLOCK_RESTORE(lock,flags) do{spin_unlock(lock);(void)flags;}while(0)
 225 #endif
 226
 227 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
 228                          DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
 229                          PCI_DMA_BIDIRECTIONAL : \
 230                          scb->scsi_cmd->sc_data_direction)
 231
 232 #ifdef IPS_DEBUG
 233 #define METHOD_TRACE(s, i)    if (ips_debug >= (i+10)) printk(KERN_NOTICE s "\n");
 234 #define DEBUG(i, s)           if (ips_debug >= i) printk(KERN_NOTICE s "\n");
 235 #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "\n", v);
 236 #else
 237 #define METHOD_TRACE(s, i)
 238 #define DEBUG(i, s)
 239 #define DEBUG_VAR(i, s, v...)
 240 #endif
 241
 242 /*
 243  * Function prototypes
 244  */
 245 static int ips_detect(struct scsi_host_template *);
 246 static int ips_release(struct Scsi_Host *);
 247 static int ips_eh_abort(struct scsi_cmnd *);
 248 static int ips_eh_reset(struct scsi_cmnd *);
 249 static int ips_queue(struct scsi_cmnd *, void (*)(struct scsi_cmnd *));
 250 static const char *ips_info(struct Scsi_Host *);
 251 static irqreturn_t do_ipsintr(int, void *);
 252 static int ips_hainit(ips_ha_t *);
 253 static int ips_map_status(ips_ha_t *, ips_scb_t *, ips_stat_t *);
 254 static int ips_send_wait(ips_ha_t *, ips_scb_t *, int, int);
 255 static int ips_send_cmd(ips_ha_t *, ips_scb_t *);
 256 static int ips_online(ips_ha_t *, ips_scb_t *);
 257 static int ips_inquiry(ips_ha_t *, ips_scb_t *);
 258 static int ips_rdcap(ips_ha_t *, ips_scb_t *);
 259 static int ips_msense(ips_ha_t *, ips_scb_t *);
 260 static int ips_reqsen(ips_ha_t *, ips_scb_t *);
 261 static int ips_deallocatescbs(ips_ha_t *, int);
 262 static int ips_allocatescbs(ips_ha_t *);
 263 static int ips_reset_copperhead(ips_ha_t *);
 264 static int ips_reset_copperhead_memio(ips_ha_t *);
 265 static int ips_reset_morpheus(ips_ha_t *);
 266 static int ips_issue_copperhead(ips_ha_t *, ips_scb_t *);
 267 static int ips_issue_copperhead_memio(ips_ha_t *, ips_scb_t *);
 268 static int ips_issue_i2o(ips_ha_t *, ips_scb_t *);
 269 static int ips_issue_i2o_memio(ips_ha_t *, ips_scb_t *);
 270 static int ips_isintr_copperhead(ips_ha_t *);
 271 static int ips_isintr_copperhead_memio(ips_ha_t *);
 272 static int ips_isintr_morpheus(ips_ha_t *);
 273 static int ips_wait(ips_ha_t *, int, int);
 274 static int ips_write_driver_status(ips_ha_t *, int);
 275 static int ips_read_adapter_status(ips_ha_t *, int);
 276 static int ips_read_subsystem_parameters(ips_ha_t *, int);
 277 static int ips_read_config(ips_ha_t *, int);
 278 static int ips_clear_adapter(ips_ha_t *, int);
 279 static int ips_readwrite_page5(ips_ha_t *, int, int);
 280 static int ips_init_copperhead(ips_ha_t *);
 281 static int ips_init_copperhead_memio(ips_ha_t *);
 282 static int ips_init_morpheus(ips_ha_t *);
 283 static int ips_isinit_copperhead(ips_ha_t *);
 284 static int ips_isinit_copperhead_memio(ips_ha_t *);
 285 static int ips_isinit_morpheus(ips_ha_t *);
 286 static int ips_erase_bios(ips_ha_t *);
 287 static int ips_program_bios(ips_ha_t *, char *, uint32_t, uint32_t);
 288 static int ips_verify_bios(ips_ha_t *, char *, uint32_t, uint32_t);
 289 static int ips_erase_bios_memio(ips_ha_t *);
 290 static int ips_program_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
 291 static int ips_verify_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
 292 static int ips_flash_copperhead(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
 293 static int ips_flash_bios(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
 294 static int ips_flash_firmware(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
 295 static void ips_free_flash_copperhead(ips_ha_t * ha);
 296 static void ips_get_bios_version(ips_ha_t *, int);
 297 static void ips_identify_controller(ips_ha_t *);
 298 static void ips_chkstatus(ips_ha_t *, IPS_STATUS *);
 299 static void ips_enable_int_copperhead(ips_ha_t *);
 300 static void ips_enable_int_copperhead_memio(ips_ha_t *);
 301 static void ips_enable_int_morpheus(ips_ha_t *);
 302 static int ips_intr_copperhead(ips_ha_t *);
 303 static int ips_intr_morpheus(ips_ha_t *);
 304 static void ips_next(ips_ha_t *, int);
 305 static void ipsintr_blocking(ips_ha_t *, struct ips_scb *);
 306 static void ipsintr_done(ips_ha_t *, struct ips_scb *);
 307 static void ips_done(ips_ha_t *, ips_scb_t *);
 308 static void ips_free(ips_ha_t *);
 309 static void ips_init_scb(ips_ha_t *, ips_scb_t *);
 310 static void ips_freescb(ips_ha_t *, ips_scb_t *);
 311 static void ips_setup_funclist(ips_ha_t *);
 312 static void ips_statinit(ips_ha_t *);
 313 static void ips_statinit_memio(ips_ha_t *);
 314 static void ips_fix_ffdc_time(ips_ha_t *, ips_scb_t *, time_t);
 315 static void ips_ffdc_reset(ips_ha_t *, int);
 316 static void ips_ffdc_time(ips_ha_t *);
 317 static uint32_t ips_statupd_copperhead(ips_ha_t *);
 318 static uint32_t ips_statupd_copperhead_memio(ips_ha_t *);
 319 static uint32_t ips_statupd_morpheus(ips_ha_t *);
 320 static ips_scb_t *ips_getscb(ips_ha_t *);
 321 static void ips_putq_scb_head(ips_scb_queue_t *, ips_scb_t *);
 322 static void ips_putq_wait_tail(ips_wait_queue_t *, struct scsi_cmnd *);
 323 static void ips_putq_copp_tail(ips_copp_queue_t *,
 324                                       ips_copp_wait_item_t *);
 325 static ips_scb_t *ips_removeq_scb_head(ips_scb_queue_t *);
 326 static ips_scb_t *ips_removeq_scb(ips_scb_queue_t *, ips_scb_t *);
 327 static struct scsi_cmnd *ips_removeq_wait_head(ips_wait_queue_t *);
 328 static struct scsi_cmnd *ips_removeq_wait(ips_wait_queue_t *,
 329                                           struct scsi_cmnd *);
 330 static ips_copp_wait_item_t *ips_removeq_copp(ips_copp_queue_t *,
 331                                                      ips_copp_wait_item_t *);
 332 static ips_copp_wait_item_t *ips_removeq_copp_head(ips_copp_queue_t *);
 333
 334 static int ips_is_passthru(struct scsi_cmnd *);
 335 static int ips_make_passthru(ips_ha_t *, struct scsi_cmnd *, ips_scb_t *, int);
 336 static int ips_usrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
 337 static void ips_cleanup_passthru(ips_ha_t *, ips_scb_t *);
 338 static void ips_scmd_buf_write(struct scsi_cmnd * scmd, void *data,
 339                                unsigned int count);
 340 static void ips_scmd_buf_read(struct scsi_cmnd * scmd, void *data,
 341                               unsigned int count);
 342
 343 static int ips_proc_info(struct Scsi_Host *, char *, char **, off_t, int, int);
 344 static int ips_host_info(ips_ha_t *, char *, off_t, int);
 345 static void copy_mem_info(IPS_INFOSTR *, char *, int);
 346 static int copy_info(IPS_INFOSTR *, char *, ...);
 347 static int ips_abort_init(ips_ha_t * ha, int index);
 348 static int ips_init_phase2(int index);
 349
 350 static int ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr);
 351 static int ips_register_scsi(int index);
 352
 353 static int  ips_poll_for_flush_complete(ips_ha_t * ha);
 354 static void ips_flush_and_reset(ips_ha_t *ha);
 355
 356 /*
 357  * global variables
 358  */
 359 static const char ips_name[] = "ips";
 360 static struct Scsi_Host *ips_sh[IPS_MAX_ADAPTERS];      /* Array of host controller structures */
 361 static ips_ha_t *ips_ha[IPS_MAX_ADAPTERS];      /* Array of HA structures */
 362 static unsigned int ips_next_controller;
 363 static unsigned int ips_num_controllers;
 364 static unsigned int ips_released_controllers;
 365 static int ips_hotplug;
 366 static int ips_cmd_timeout = 60;
 367 static int ips_reset_timeout = 60 * 5;
 368 static int ips_force_memio = 1;         /* Always use Memory Mapped I/O    */
 369 static int ips_force_i2o = 1;   /* Always use I2O command delivery */
 370 static int ips_ioctlsize = IPS_IOCTL_SIZE;      /* Size of the ioctl buffer        */
 371 static int ips_cd_boot;                 /* Booting from Manager CD         */
 372 static char *ips_FlashData = NULL;      /* CD Boot - Flash Data Buffer      */
 373 static dma_addr_t ips_flashbusaddr;
 374 static long ips_FlashDataInUse;         /* CD Boot - Flash Data In Use Flag */
 375 static uint32_t MaxLiteCmds = 32;       /* Max Active Cmds for a Lite Adapter */
 376 static struct scsi_host_template ips_driver_template = {
 377         .detect                 = ips_detect,
 378         .release                = ips_release,
 379         .info                   = ips_info,
 380         .queuecommand           = ips_queue,
 381         .eh_abort_handler       = ips_eh_abort,
 382         .eh_host_reset_handler  = ips_eh_reset,
 383         .proc_name              = "ips",
 384 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
 385         .proc_info              = ips_proc_info,
 386         .slave_configure        = ips_slave_configure,
 387 #else
 388         .proc_info              = ips_proc24_info,
 389         .select_queue_depths    = ips_select_queue_depth,
 390 #endif
 391         .bios_param             = ips_biosparam,
 392         .this_id                = -1,
 393         .sg_tablesize           = IPS_MAX_SG,
 394         .cmd_per_lun            = 3,
 395         .use_clustering         = ENABLE_CLUSTERING,
 396 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
 397         .use_new_eh_code        = 1,
 398 #endif
 399 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20)  &&  LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
 400     .highmem_io          = 1,
 401 #endif
 402 };
 403
 404
 405 /* This table describes all ServeRAID Adapters */
 406 static struct  pci_device_id  ips_pci_table[] = {
 407         { 0x1014, 0x002E, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
 408         { 0x1014, 0x01BD, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
 409         { 0x9005, 0x0250, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
 410         { 0, }
 411 };
 412
 413 MODULE_DEVICE_TABLE( pci, ips_pci_table );
 414
 415 static char ips_hot_plug_name[] = "ips";
 416
 417 static int __devinit  ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent);
 418 static void __devexit ips_remove_device(struct pci_dev *pci_dev);
 419
 420 static struct pci_driver ips_pci_driver = {
 421         .name           = ips_hot_plug_name,
 422         .id_table       = ips_pci_table,
 423         .probe          = ips_insert_device,
 424         .remove         = __devexit_p(ips_remove_device),
 425 };
 426
 427
 428 /*
 429  * Necessary forward function protoypes
 430  */
 431 static int ips_halt(struct notifier_block *nb, ulong event, void *buf);
 432
 433 #define MAX_ADAPTER_NAME 15
 434
 435 static char ips_adapter_name[][30] = {
 436         "ServeRAID",
 437         "ServeRAID II",
 438         "ServeRAID on motherboard",
 439         "ServeRAID on motherboard",
 440         "ServeRAID 3H",
 441         "ServeRAID 3L",
 442         "ServeRAID 4H",
 443         "ServeRAID 4M",
 444         "ServeRAID 4L",
 445         "ServeRAID 4Mx",
 446         "ServeRAID 4Lx",
 447         "ServeRAID 5i",
 448         "ServeRAID 5i",
 449         "ServeRAID 6M",
 450         "ServeRAID 6i",
 451         "ServeRAID 7t",
 452         "ServeRAID 7k",
 453         "ServeRAID 7M"
 454 };
 455
 456 static struct notifier_block ips_notifier = {
 457         ips_halt, NULL, 0
 458 };
 459
 460 /*
 461  * Direction table
 462  */
 463 static char ips_command_direction[] = {
 464         IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT,
 465         IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK,
 466         IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 467         IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
 468         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_OUT,
 469         IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
 470         IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_IN,
 471         IPS_DATA_UNK, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
 472         IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_UNK,
 473         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
 474         IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE,
 475         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
 476         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT,
 477         IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_NONE,
 478         IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,
 479         IPS_DATA_NONE, IPS_DATA_OUT, IPS_DATA_IN, 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_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 482         IPS_DATA_IN, 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_UNK,
 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         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 492         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 493         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 494         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 495         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 496         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 497         IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_NONE,
 498         IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_OUT,
 499         IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_NONE,
 500         IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN,
 501         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 502         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 503         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 504         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 505         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 506         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 507         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 508         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 509         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 510         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_OUT,
 511         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 512         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 513         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
 514         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK
 515 };
 516
 517
 518 /****************************************************************************/
 519 /*                                                                          */
 520 /* Routine Name: ips_setup                                                  */
 521 /*                                                                          */
 522 /* Routine Description:                                                     */
 523 /*                                                                          */
 524 /*   setup parameters to the driver                                         */
 525 /*                                                                          */
 526 /****************************************************************************/
 527 static int
 528 ips_setup(char *ips_str)
 529 {
 530
 531         int i;
 532         char *key;
 533         char *value;
 534         IPS_OPTION options[] = {
 535                 {"noi2o", &ips_force_i2o, 0},
 536                 {"nommap", &ips_force_memio, 0},
 537                 {"ioctlsize", &ips_ioctlsize, IPS_IOCTL_SIZE},
 538                 {"cdboot", &ips_cd_boot, 0},
 539                 {"maxcmds", &MaxLiteCmds, 32},
 540         };
 541
 542         /* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
 543         /* Search for value */
 544         while ((key = strsep(&ips_str, ",."))) {
 545                 if (!*key)
 546                         continue;
 547                 value = strchr(key, ':');
 548                 if (value)
 549                         *value++ = '\0';
 550                 /*
 551                  * We now have key/value pairs.
 552                  * Update the variables
 553                  */
 554                 for (i = 0; i < ARRAY_SIZE(options); i++) {
 555                         if (strnicmp
 556                             (key, options[i].option_name,
 557                              strlen(options[i].option_name)) == 0) {
 558                                 if (value)
 559                                         *options[i].option_flag =
 560                                             simple_strtoul(value, NULL, 0);
 561                                 else
 562                                         *options[i].option_flag =
 563                                             options[i].option_value;
 564                                 break;
 565                         }
 566                 }
 567         }
 568
 569         return (1);
 570 }
 571
 572 __setup("ips=", ips_setup);
 573
 574 /****************************************************************************/
 575 /*                                                                          */
 576 /* Routine Name: ips_detect                                                 */
 577 /*                                                                          */
 578 /* Routine Description:                                                     */
 579 /*                                                                          */
 580 /*   Detect and initialize the driver                                       */
 581 /*                                                                          */
 582 /* NOTE: this routine is called under the io_request_lock spinlock          */
 583 /*                                                                          */
 584 /****************************************************************************/
 585 static int
 586 ips_detect(struct scsi_host_template * SHT)
 587 {
 588         int i;
 589
 590         METHOD_TRACE("ips_detect", 1);
 591
 592 #ifdef MODULE
 593         if (ips)
 594                 ips_setup(ips);
 595 #endif
 596
 597         for (i = 0; i < ips_num_controllers; i++) {
 598                 if (ips_register_scsi(i))
 599                         ips_free(ips_ha[i]);
 600                 ips_released_controllers++;
 601         }
 602         ips_hotplug = 1;
 603         return (ips_num_controllers);
 604 }
 605
 606 /****************************************************************************/
 607 /*   configure the function pointers to use the functions that will work    */
 608 /*   with the found version of the adapter                                  */
 609 /****************************************************************************/
 610 static void
 611 ips_setup_funclist(ips_ha_t * ha)
 612 {
 613
 614         /*
 615          * Setup Functions
 616          */
 617         if (IPS_IS_MORPHEUS(ha) || IPS_IS_MARCO(ha)) {
 618                 /* morpheus / marco / sebring */
 619                 ha->func.isintr = ips_isintr_morpheus;
 620                 ha->func.isinit = ips_isinit_morpheus;
 621                 ha->func.issue = ips_issue_i2o_memio;
 622                 ha->func.init = ips_init_morpheus;
 623                 ha->func.statupd = ips_statupd_morpheus;
 624                 ha->func.reset = ips_reset_morpheus;
 625                 ha->func.intr = ips_intr_morpheus;
 626                 ha->func.enableint = ips_enable_int_morpheus;
 627         } else if (IPS_USE_MEMIO(ha)) {
 628                 /* copperhead w/MEMIO */
 629                 ha->func.isintr = ips_isintr_copperhead_memio;
 630                 ha->func.isinit = ips_isinit_copperhead_memio;
 631                 ha->func.init = ips_init_copperhead_memio;
 632                 ha->func.statupd = ips_statupd_copperhead_memio;
 633                 ha->func.statinit = ips_statinit_memio;
 634                 ha->func.reset = ips_reset_copperhead_memio;
 635                 ha->func.intr = ips_intr_copperhead;
 636                 ha->func.erasebios = ips_erase_bios_memio;
 637                 ha->func.programbios = ips_program_bios_memio;
 638                 ha->func.verifybios = ips_verify_bios_memio;
 639                 ha->func.enableint = ips_enable_int_copperhead_memio;
 640                 if (IPS_USE_I2O_DELIVER(ha))
 641                         ha->func.issue = ips_issue_i2o_memio;
 642                 else
 643                         ha->func.issue = ips_issue_copperhead_memio;
 644         } else {
 645                 /* copperhead */
 646                 ha->func.isintr = ips_isintr_copperhead;
 647                 ha->func.isinit = ips_isinit_copperhead;
 648                 ha->func.init = ips_init_copperhead;
 649                 ha->func.statupd = ips_statupd_copperhead;
 650                 ha->func.statinit = ips_statinit;
 651                 ha->func.reset = ips_reset_copperhead;
 652                 ha->func.intr = ips_intr_copperhead;
 653                 ha->func.erasebios = ips_erase_bios;
 654                 ha->func.programbios = ips_program_bios;
 655                 ha->func.verifybios = ips_verify_bios;
 656                 ha->func.enableint = ips_enable_int_copperhead;
 657
 658                 if (IPS_USE_I2O_DELIVER(ha))
 659                         ha->func.issue = ips_issue_i2o;
 660                 else
 661                         ha->func.issue = ips_issue_copperhead;
 662         }
 663 }
 664
 665 /****************************************************************************/
 666 /*                                                                          */
 667 /* Routine Name: ips_release                                                */
 668 /*                                                                          */
 669 /* Routine Description:                                                     */
 670 /*                                                                          */
 671 /*   Remove a driver                                                        */
 672 /*                                                                          */
 673 /****************************************************************************/
 674 static int
 675 ips_release(struct Scsi_Host *sh)
 676 {
 677         ips_scb_t *scb;
 678         ips_ha_t *ha;
 679         int i;
 680
 681         METHOD_TRACE("ips_release", 1);
 682
 683         for (i = 0; i < IPS_MAX_ADAPTERS && ips_sh[i] != sh; i++) ;
 684
 685         if (i == IPS_MAX_ADAPTERS) {
 686                 printk(KERN_WARNING
 687                        "(%s) release, invalid Scsi_Host pointer.\n", ips_name);
 688                 BUG();
 689                 return (FALSE);
 690         }
 691
 692         ha = IPS_HA(sh);
 693
 694         if (!ha)
 695                 return (FALSE);
 696
 697         /* flush the cache on the controller */
 698         scb = &ha->scbs[ha->max_cmds - 1];
 699
 700         ips_init_scb(ha, scb);
 701
 702         scb->timeout = ips_cmd_timeout;
 703         scb->cdb[0] = IPS_CMD_FLUSH;
 704
 705         scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
 706         scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
 707         scb->cmd.flush_cache.state = IPS_NORM_STATE;
 708         scb->cmd.flush_cache.reserved = 0;
 709         scb->cmd.flush_cache.reserved2 = 0;
 710         scb->cmd.flush_cache.reserved3 = 0;
 711         scb->cmd.flush_cache.reserved4 = 0;
 712
 713         IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
 714
 715         /* send command */
 716         if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
 717                 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Incomplete Flush.\n");
 718
 719         IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Complete.\n");
 720
 721         ips_sh[i] = NULL;
 722         ips_ha[i] = NULL;
 723
 724         /* free extra memory */
 725         ips_free(ha);
 726
 727         /* Free I/O Region */
 728         if (ha->io_addr)
 729                 release_region(ha->io_addr, ha->io_len);
 730
 731         /* free IRQ */
 732         free_irq(ha->irq, ha);
 733
 734         IPS_REMOVE_HOST(sh);
 735         scsi_host_put(sh);
 736
 737         ips_released_controllers++;
 738
 739         return (FALSE);
 740 }
 741
 742 /****************************************************************************/
 743 /*                                                                          */
 744 /* Routine Name: ips_halt                                                   */
 745 /*                                                                          */
 746 /* Routine Description:                                                     */
 747 /*                                                                          */
 748 /*   Perform cleanup when the system reboots                                */
 749 /*                                                                          */
 750 /****************************************************************************/
 751 static int
 752 ips_halt(struct notifier_block *nb, ulong event, void *buf)
 753 {
 754         ips_scb_t *scb;
 755         ips_ha_t *ha;
 756         int i;
 757
 758         if ((event != SYS_RESTART) && (event != SYS_HALT) &&
 759             (event != SYS_POWER_OFF))
 760                 return (NOTIFY_DONE);
 761
 762         for (i = 0; i < ips_next_controller; i++) {
 763                 ha = (ips_ha_t *) ips_ha[i];
 764
 765                 if (!ha)
 766                         continue;
 767
 768                 if (!ha->active)
 769                         continue;
 770
 771                 /* flush the cache on the controller */
 772                 scb = &ha->scbs[ha->max_cmds - 1];
 773
 774                 ips_init_scb(ha, scb);
 775
 776                 scb->timeout = ips_cmd_timeout;
 777                 scb->cdb[0] = IPS_CMD_FLUSH;
 778
 779                 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
 780                 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
 781                 scb->cmd.flush_cache.state = IPS_NORM_STATE;
 782                 scb->cmd.flush_cache.reserved = 0;
 783                 scb->cmd.flush_cache.reserved2 = 0;
 784                 scb->cmd.flush_cache.reserved3 = 0;
 785                 scb->cmd.flush_cache.reserved4 = 0;
 786
 787                 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
 788
 789                 /* send command */
 790                 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) ==
 791                     IPS_FAILURE)
 792                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
 793                                    "Incomplete Flush.\n");
 794                 else
 795                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
 796                                    "Flushing Complete.\n");
 797         }
 798
 799         return (NOTIFY_OK);
 800 }
 801
 802 /****************************************************************************/
 803 /*                                                                          */
 804 /* Routine Name: ips_eh_abort                                               */
 805 /*                                                                          */
 806 /* Routine Description:                                                     */
 807 /*                                                                          */
 808 /*   Abort a command (using the new error code stuff)                       */
 809 /* Note: this routine is called under the io_request_lock                   */
 810 /****************************************************************************/
 811 int ips_eh_abort(struct scsi_cmnd *SC)
 812 {
 813         ips_ha_t *ha;
 814         ips_copp_wait_item_t *item;
 815         int ret;
 816         unsigned long cpu_flags;
 817         struct Scsi_Host *host;
 818
 819         METHOD_TRACE("ips_eh_abort", 1);
 820
 821         if (!SC)
 822                 return (FAILED);
 823
 824         host = SC->device->host;
 825         ha = (ips_ha_t *) SC->device->host->hostdata;
 826
 827         if (!ha)
 828                 return (FAILED);
 829
 830         if (!ha->active)
 831                 return (FAILED);
 832
 833         IPS_LOCK_SAVE(host->host_lock, cpu_flags);
 834
 835         /* See if the command is on the copp queue */
 836         item = ha->copp_waitlist.head;
 837         while ((item) && (item->scsi_cmd != SC))
 838                 item = item->next;
 839
 840         if (item) {
 841                 /* Found it */
 842                 ips_removeq_copp(&ha->copp_waitlist, item);
 843                 ret = (SUCCESS);
 844
 845                 /* See if the command is on the wait queue */
 846         } else if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
 847                 /* command not sent yet */
 848                 ret = (SUCCESS);
 849         } else {
 850                 /* command must have already been sent */
 851                 ret = (FAILED);
 852         }
 853
 854         IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
 855         return ret;
 856 }
 857
 858 /****************************************************************************/
 859 /*                                                                          */
 860 /* Routine Name: ips_eh_reset                                               */
 861 /*                                                                          */
 862 /* Routine Description:                                                     */
 863 /*                                                                          */
 864 /*   Reset the controller (with new eh error code)                          */
 865 /*                                                                          */
 866 /* NOTE: this routine is called under the io_request_lock spinlock          */
 867 /*                                                                          */
 868 /****************************************************************************/
 869 static int __ips_eh_reset(struct scsi_cmnd *SC)
 870 {
 871         int ret;
 872         int i;
 873         ips_ha_t *ha;
 874         ips_scb_t *scb;
 875         ips_copp_wait_item_t *item;
 876
 877         METHOD_TRACE("ips_eh_reset", 1);
 878
 879 #ifdef NO_IPS_RESET
 880         return (FAILED);
 881 #else
 882
 883         if (!SC) {
 884                 DEBUG(1, "Reset called with NULL scsi command");
 885
 886                 return (FAILED);
 887         }
 888
 889         ha = (ips_ha_t *) SC->device->host->hostdata;
 890
 891         if (!ha) {
 892                 DEBUG(1, "Reset called with NULL ha struct");
 893
 894                 return (FAILED);
 895         }
 896
 897         if (!ha->active)
 898                 return (FAILED);
 899
 900         /* See if the command is on the copp queue */
 901         item = ha->copp_waitlist.head;
 902         while ((item) && (item->scsi_cmd != SC))
 903                 item = item->next;
 904
 905         if (item) {
 906                 /* Found it */
 907                 ips_removeq_copp(&ha->copp_waitlist, item);
 908                 return (SUCCESS);
 909         }
 910
 911         /* See if the command is on the wait queue */
 912         if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
 913                 /* command not sent yet */
 914                 return (SUCCESS);
 915         }
 916
 917         /* An explanation for the casual observer:                              */
 918         /* Part of the function of a RAID controller is automatic error         */
 919         /* detection and recovery.  As such, the only problem that physically   */
 920         /* resetting an adapter will ever fix is when, for some reason,         */
 921         /* the driver is not successfully communicating with the adapter.       */
 922         /* Therefore, we will attempt to flush this adapter.  If that succeeds, */
 923         /* then there's no real purpose in a physical reset. This will complete */
 924         /* much faster and avoids any problems that might be caused by a        */
 925         /* physical reset ( such as having to fail all the outstanding I/O's ). */
 926
 927         if (ha->ioctl_reset == 0) {     /* IF Not an IOCTL Requested Reset */
 928                 scb = &ha->scbs[ha->max_cmds - 1];
 929
 930                 ips_init_scb(ha, scb);
 931
 932                 scb->timeout = ips_cmd_timeout;
 933                 scb->cdb[0] = IPS_CMD_FLUSH;
 934
 935                 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
 936                 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
 937                 scb->cmd.flush_cache.state = IPS_NORM_STATE;
 938                 scb->cmd.flush_cache.reserved = 0;
 939                 scb->cmd.flush_cache.reserved2 = 0;
 940                 scb->cmd.flush_cache.reserved3 = 0;
 941                 scb->cmd.flush_cache.reserved4 = 0;
 942
 943                 /* Attempt the flush command */
 944                 ret = ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_IORL);
 945                 if (ret == IPS_SUCCESS) {
 946                         IPS_PRINTK(KERN_NOTICE, ha->pcidev,
 947                                    "Reset Request - Flushed Cache\n");
 948                         return (SUCCESS);
 949                 }
 950         }
 951
 952         /* Either we can't communicate with the adapter or it's an IOCTL request */
 953         /* from a utility.  A physical reset is needed at this point.            */
 954
 955         ha->ioctl_reset = 0;    /* Reset the IOCTL Requested Reset Flag */
 956
 957         /*
 958          * command must have already been sent
 959          * reset the controller
 960          */
 961         IPS_PRINTK(KERN_NOTICE, ha->pcidev, "Resetting controller.\n");
 962         ret = (*ha->func.reset) (ha);
 963
 964         if (!ret) {
 965                 struct scsi_cmnd *scsi_cmd;
 966
 967                 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
 968                            "Controller reset failed - controller now offline.\n");
 969
 970                 /* Now fail all of the active commands */
 971                 DEBUG_VAR(1, "(%s%d) Failing active commands",
 972                           ips_name, ha->host_num);
 973
 974                 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
 975                         scb->scsi_cmd->result = DID_ERROR << 16;
 976                         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
 977                         ips_freescb(ha, scb);
 978                 }
 979
 980                 /* Now fail all of the pending commands */
 981                 DEBUG_VAR(1, "(%s%d) Failing pending commands",
 982                           ips_name, ha->host_num);
 983
 984                 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
 985                         scsi_cmd->result = DID_ERROR;
 986                         scsi_cmd->scsi_done(scsi_cmd);
 987                 }
 988
 989                 ha->active = FALSE;
 990                 return (FAILED);
 991         }
 992
 993         if (!ips_clear_adapter(ha, IPS_INTR_IORL)) {
 994                 struct scsi_cmnd *scsi_cmd;
 995
 996                 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
 997                            "Controller reset failed - controller now offline.\n");
 998
 999                 /* Now fail all of the active commands */
1000                 DEBUG_VAR(1, "(%s%d) Failing active commands",
1001                           ips_name, ha->host_num);
1002
1003                 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
1004                         scb->scsi_cmd->result = DID_ERROR << 16;
1005                         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1006                         ips_freescb(ha, scb);
1007                 }
1008
1009                 /* Now fail all of the pending commands */
1010                 DEBUG_VAR(1, "(%s%d) Failing pending commands",
1011                           ips_name, ha->host_num);
1012
1013                 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
1014                         scsi_cmd->result = DID_ERROR << 16;
1015                         scsi_cmd->scsi_done(scsi_cmd);
1016                 }
1017
1018                 ha->active = FALSE;
1019                 return (FAILED);
1020         }
1021
1022         /* FFDC */
1023         if (le32_to_cpu(ha->subsys->param[3]) & 0x300000) {
1024                 struct timeval tv;
1025
1026                 do_gettimeofday(&tv);
1027                 ha->last_ffdc = tv.tv_sec;
1028                 ha->reset_count++;
1029                 ips_ffdc_reset(ha, IPS_INTR_IORL);
1030         }
1031
1032         /* Now fail all of the active commands */
1033         DEBUG_VAR(1, "(%s%d) Failing active commands", ips_name, ha->host_num);
1034
1035         while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
1036                 scb->scsi_cmd->result =
1037                     (DID_RESET << 16) | (SUGGEST_RETRY << 24);
1038                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1039                 ips_freescb(ha, scb);
1040         }
1041
1042         /* Reset DCDB active command bits */
1043         for (i = 1; i < ha->nbus; i++)
1044                 ha->dcdb_active[i - 1] = 0;
1045
1046         /* Reset the number of active IOCTLs */
1047         ha->num_ioctl = 0;
1048
1049         ips_next(ha, IPS_INTR_IORL);
1050
1051         return (SUCCESS);
1052 #endif                          /* NO_IPS_RESET */
1053
1054 }
1055
1056 static int ips_eh_reset(struct scsi_cmnd *SC)
1057 {
1058         int rc;
1059
1060         spin_lock_irq(SC->device->host->host_lock);
1061         rc = __ips_eh_reset(SC);
1062         spin_unlock_irq(SC->device->host->host_lock);
1063
1064         return rc;
1065 }
1066
1067 /****************************************************************************/
1068 /*                                                                          */
1069 /* Routine Name: ips_queue                                                  */
1070 /*                                                                          */
1071 /* Routine Description:                                                     */
1072 /*                                                                          */
1073 /*   Send a command to the controller                                       */
1074 /*                                                                          */
1075 /* NOTE:                                                                    */
1076 /*    Linux obtains io_request_lock before calling this function            */
1077 /*                                                                          */
1078 /****************************************************************************/
1079 static int ips_queue(struct scsi_cmnd *SC, void (*done) (struct scsi_cmnd *))
1080 {
1081         ips_ha_t *ha;
1082         ips_passthru_t *pt;
1083
1084         METHOD_TRACE("ips_queue", 1);
1085
1086         ha = (ips_ha_t *) SC->device->host->hostdata;
1087
1088         if (!ha)
1089                 return (1);
1090
1091         if (!ha->active)
1092                 return (DID_ERROR);
1093
1094         if (ips_is_passthru(SC)) {
1095                 if (ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
1096                         SC->result = DID_BUS_BUSY << 16;
1097                         done(SC);
1098
1099                         return (0);
1100                 }
1101         } else if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
1102                 SC->result = DID_BUS_BUSY << 16;
1103                 done(SC);
1104
1105                 return (0);
1106         }
1107
1108         SC->scsi_done = done;
1109
1110         DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
1111                   ips_name,
1112                   ha->host_num,
1113                   SC->cmnd[0],
1114                   SC->device->channel, SC->device->id, SC->device->lun);
1115
1116         /* Check for command to initiator IDs */
1117         if ((scmd_channel(SC) > 0)
1118             && (scmd_id(SC) == ha->ha_id[scmd_channel(SC)])) {
1119                 SC->result = DID_NO_CONNECT << 16;
1120                 done(SC);
1121
1122                 return (0);
1123         }
1124
1125         if (ips_is_passthru(SC)) {
1126
1127                 ips_copp_wait_item_t *scratch;
1128
1129                 /* A Reset IOCTL is only sent by the boot CD in extreme cases.           */
1130                 /* There can never be any system activity ( network or disk ), but check */
1131                 /* anyway just as a good practice.                                       */
1132                 pt = (ips_passthru_t *) SC->request_buffer;
1133                 if ((pt->CoppCP.cmd.reset.op_code == IPS_CMD_RESET_CHANNEL) &&
1134                     (pt->CoppCP.cmd.reset.adapter_flag == 1)) {
1135                         if (ha->scb_activelist.count != 0) {
1136                                 SC->result = DID_BUS_BUSY << 16;
1137                                 done(SC);
1138                                 return (0);
1139                         }
1140                         ha->ioctl_reset = 1;    /* This reset request is from an IOCTL */
1141                         __ips_eh_reset(SC);
1142                         SC->result = DID_OK << 16;
1143                         SC->scsi_done(SC);
1144                         return (0);
1145                 }
1146
1147                 /* allocate space for the scribble */
1148                 scratch = kmalloc(sizeof (ips_copp_wait_item_t), GFP_ATOMIC);
1149
1150                 if (!scratch) {
1151                         SC->result = DID_ERROR << 16;
1152                         done(SC);
1153
1154                         return (0);
1155                 }
1156
1157                 scratch->scsi_cmd = SC;
1158                 scratch->next = NULL;
1159
1160                 ips_putq_copp_tail(&ha->copp_waitlist, scratch);
1161         } else {
1162                 ips_putq_wait_tail(&ha->scb_waitlist, SC);
1163         }
1164
1165         ips_next(ha, IPS_INTR_IORL);
1166
1167         return (0);
1168 }
1169
1170 /****************************************************************************/
1171 /*                                                                          */
1172 /* Routine Name: ips_biosparam                                              */
1173 /*                                                                          */
1174 /* Routine Description:                                                     */
1175 /*                                                                          */
1176 /*   Set bios geometry for the controller                                   */
1177 /*                                                                          */
1178 /****************************************************************************/
1179 static int
1180 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1181 ips_biosparam(Disk * disk, kdev_t dev, int geom[])
1182 {
1183         ips_ha_t *ha = (ips_ha_t *) disk->device->host->hostdata;
1184         unsigned long capacity = disk->capacity;
1185 #else
1186 ips_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1187               sector_t capacity, int geom[])
1188 {
1189         ips_ha_t *ha = (ips_ha_t *) sdev->host->hostdata;
1190 #endif
1191         int heads;
1192         int sectors;
1193         int cylinders;
1194
1195         METHOD_TRACE("ips_biosparam", 1);
1196
1197         if (!ha)
1198                 /* ?!?! host adater info invalid */
1199                 return (0);
1200
1201         if (!ha->active)
1202                 return (0);
1203
1204         if (!ips_read_adapter_status(ha, IPS_INTR_ON))
1205                 /* ?!?! Enquiry command failed */
1206                 return (0);
1207
1208         if ((capacity > 0x400000) && ((ha->enq->ucMiscFlag & 0x8) == 0)) {
1209                 heads = IPS_NORM_HEADS;
1210                 sectors = IPS_NORM_SECTORS;
1211         } else {
1212                 heads = IPS_COMP_HEADS;
1213                 sectors = IPS_COMP_SECTORS;
1214         }
1215
1216         cylinders = (unsigned long) capacity / (heads * sectors);
1217
1218         DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
1219                   heads, sectors, cylinders);
1220
1221         geom[0] = heads;
1222         geom[1] = sectors;
1223         geom[2] = cylinders;
1224
1225         return (0);
1226 }
1227
1228 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1229
1230 /* ips_proc24_info is a wrapper around ips_proc_info *
1231  * for compatibility with the 2.4 scsi parameters    */
1232 static int
1233 ips_proc24_info(char *buffer, char **start, off_t offset, int length,
1234                               int hostno, int func)
1235 {
1236         int i;
1237
1238         for (i = 0; i < ips_next_controller; i++) {
1239                 if (ips_sh[i] && ips_sh[i]->host_no == hostno) {
1240                         return ips_proc_info(ips_sh[i], buffer, start,
1241                                              offset, length, func);
1242                 }
1243         }
1244         return -EINVAL;
1245 }
1246
1247 /****************************************************************************/
1248 /*                                                                          */
1249 /* Routine Name: ips_select_queue_depth                                     */
1250 /*                                                                          */
1251 /* Routine Description:                                                     */
1252 /*                                                                          */
1253 /*   Select queue depths for the devices on the contoller                   */
1254 /*                                                                          */
1255 /****************************************************************************/
1256 static void
1257 ips_select_queue_depth(struct Scsi_Host *host, struct scsi_device * scsi_devs)
1258 {
1259         struct scsi_device *device;
1260         ips_ha_t *ha;
1261         int count = 0;
1262         int min;
1263
1264         ha = IPS_HA(host);
1265         min = ha->max_cmds / 4;
1266
1267         for (device = scsi_devs; device; device = device->next) {
1268                 if (device->host == host) {
1269                         if ((device->channel == 0) && (device->type == 0))
1270                                 count++;
1271                 }
1272         }
1273
1274         for (device = scsi_devs; device; device = device->next) {
1275                 if (device->host == host) {
1276                         if ((device->channel == 0) && (device->type == 0)) {
1277                                 device->queue_depth =
1278                                     (ha->max_cmds - 1) / count;
1279                                 if (device->queue_depth < min)
1280                                         device->queue_depth = min;
1281                         } else {
1282                                 device->queue_depth = 2;
1283                         }
1284
1285                         if (device->queue_depth < 2)
1286                                 device->queue_depth = 2;
1287                 }
1288         }
1289 }
1290
1291 #else
1292 /****************************************************************************/
1293 /*                                                                          */
1294 /* Routine Name: ips_slave_configure                                        */
1295 /*                                                                          */
1296 /* Routine Description:                                                     */
1297 /*                                                                          */
1298 /*   Set queue depths on devices once scan is complete                      */
1299 /*                                                                          */
1300 /****************************************************************************/
1301 static int
1302 ips_slave_configure(struct scsi_device * SDptr)
1303 {
1304         ips_ha_t *ha;
1305         int min;
1306
1307         ha = IPS_HA(SDptr->host);
1308         if (SDptr->tagged_supported && SDptr->type == TYPE_DISK) {
1309                 min = ha->max_cmds / 2;
1310                 if (ha->enq->ucLogDriveCount <= 2)
1311                         min = ha->max_cmds - 1;
1312                 scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, min);
1313         }
1314
1315         SDptr->skip_ms_page_8 = 1;
1316         SDptr->skip_ms_page_3f = 1;
1317         return 0;
1318 }
1319 #endif
1320
1321 /****************************************************************************/
1322 /*                                                                          */
1323 /* Routine Name: do_ipsintr                                                 */
1324 /*                                                                          */
1325 /* Routine Description:                                                     */
1326 /*                                                                          */
1327 /*   Wrapper for the interrupt handler                                      */
1328 /*                                                                          */
1329 /****************************************************************************/
1330 static irqreturn_t
1331 do_ipsintr(int irq, void *dev_id)
1332 {
1333         ips_ha_t *ha;
1334         unsigned long cpu_flags;
1335         struct Scsi_Host *host;
1336         int irqstatus;
1337
1338         METHOD_TRACE("do_ipsintr", 2);
1339
1340         ha = (ips_ha_t *) dev_id;
1341         if (!ha)
1342                 return IRQ_NONE;
1343         host = ips_sh[ha->host_num];
1344         /* interrupt during initialization */
1345         if (!host) {
1346                 (*ha->func.intr) (ha);
1347                 return IRQ_HANDLED;
1348         }
1349
1350         IPS_LOCK_SAVE(host->host_lock, cpu_flags);
1351
1352         if (!ha->active) {
1353                 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1354                 return IRQ_HANDLED;
1355         }
1356
1357         irqstatus = (*ha->func.intr) (ha);
1358
1359         IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1360
1361         /* start the next command */
1362         ips_next(ha, IPS_INTR_ON);
1363         return IRQ_RETVAL(irqstatus);
1364 }
1365
1366 /****************************************************************************/
1367 /*                                                                          */
1368 /* Routine Name: ips_intr_copperhead                                        */
1369 /*                                                                          */
1370 /* Routine Description:                                                     */
1371 /*                                                                          */
1372 /*   Polling interrupt handler                                              */
1373 /*                                                                          */
1374 /*   ASSUMES interrupts are disabled                                        */
1375 /*                                                                          */
1376 /****************************************************************************/
1377 int
1378 ips_intr_copperhead(ips_ha_t * ha)
1379 {
1380         ips_stat_t *sp;
1381         ips_scb_t *scb;
1382         IPS_STATUS cstatus;
1383         int intrstatus;
1384
1385         METHOD_TRACE("ips_intr", 2);
1386
1387         if (!ha)
1388                 return 0;
1389
1390         if (!ha->active)
1391                 return 0;
1392
1393         intrstatus = (*ha->func.isintr) (ha);
1394
1395         if (!intrstatus) {
1396                 /*
1397                  * Unexpected/Shared interrupt
1398                  */
1399
1400                 return 0;
1401         }
1402
1403         while (TRUE) {
1404                 sp = &ha->sp;
1405
1406                 intrstatus = (*ha->func.isintr) (ha);
1407
1408                 if (!intrstatus)
1409                         break;
1410                 else
1411                         cstatus.value = (*ha->func.statupd) (ha);
1412
1413                 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1414                         /* Spurious Interupt ? */
1415                         continue;
1416                 }
1417
1418                 ips_chkstatus(ha, &cstatus);
1419                 scb = (ips_scb_t *) sp->scb_addr;
1420
1421                 /*
1422                  * use the callback function to finish things up
1423                  * NOTE: interrupts are OFF for this
1424                  */
1425                 (*scb->callback) (ha, scb);
1426         }                       /* end while */
1427         return 1;
1428 }
1429
1430 /****************************************************************************/
1431 /*                                                                          */
1432 /* Routine Name: ips_intr_morpheus                                          */
1433 /*                                                                          */
1434 /* Routine Description:                                                     */
1435 /*                                                                          */
1436 /*   Polling interrupt handler                                              */
1437 /*                                                                          */
1438 /*   ASSUMES interrupts are disabled                                        */
1439 /*                                                                          */
1440 /****************************************************************************/
1441 int
1442 ips_intr_morpheus(ips_ha_t * ha)
1443 {
1444         ips_stat_t *sp;
1445         ips_scb_t *scb;
1446         IPS_STATUS cstatus;
1447         int intrstatus;
1448
1449         METHOD_TRACE("ips_intr_morpheus", 2);
1450
1451         if (!ha)
1452                 return 0;
1453
1454         if (!ha->active)
1455                 return 0;
1456
1457         intrstatus = (*ha->func.isintr) (ha);
1458
1459         if (!intrstatus) {
1460                 /*
1461                  * Unexpected/Shared interrupt
1462                  */
1463
1464                 return 0;
1465         }
1466
1467         while (TRUE) {
1468                 sp = &ha->sp;
1469
1470                 intrstatus = (*ha->func.isintr) (ha);
1471
1472                 if (!intrstatus)
1473                         break;
1474                 else
1475                         cstatus.value = (*ha->func.statupd) (ha);
1476
1477                 if (cstatus.value == 0xffffffff)
1478                         /* No more to process */
1479                         break;
1480
1481                 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1482                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
1483                                    "Spurious interrupt; no ccb.\n");
1484
1485                         continue;
1486                 }
1487
1488                 ips_chkstatus(ha, &cstatus);
1489                 scb = (ips_scb_t *) sp->scb_addr;
1490
1491                 /*
1492                  * use the callback function to finish things up
1493                  * NOTE: interrupts are OFF for this
1494                  */
1495                 (*scb->callback) (ha, scb);
1496         }                       /* end while */
1497         return 1;
1498 }
1499
1500 /****************************************************************************/
1501 /*                                                                          */
1502 /* Routine Name: ips_info                                                   */
1503 /*                                                                          */
1504 /* Routine Description:                                                     */
1505 /*                                                                          */
1506 /*   Return info about the driver                                           */
1507 /*                                                                          */
1508 /****************************************************************************/
1509 static const char *
1510 ips_info(struct Scsi_Host *SH)
1511 {
1512         static char buffer[256];
1513         char *bp;
1514         ips_ha_t *ha;
1515
1516         METHOD_TRACE("ips_info", 1);
1517
1518         ha = IPS_HA(SH);
1519
1520         if (!ha)
1521                 return (NULL);
1522
1523         bp = &buffer[0];
1524         memset(bp, 0, sizeof (buffer));
1525
1526         sprintf(bp, "%s%s%s Build %d", "IBM PCI ServeRAID ",
1527                 IPS_VERSION_HIGH, IPS_VERSION_LOW, IPS_BUILD_IDENT);
1528
1529         if (ha->ad_type > 0 && ha->ad_type <= MAX_ADAPTER_NAME) {
1530                 strcat(bp, " <");
1531                 strcat(bp, ips_adapter_name[ha->ad_type - 1]);
1532                 strcat(bp, ">");
1533         }
1534
1535         return (bp);
1536 }
1537
1538 /****************************************************************************/
1539 /*                                                                          */
1540 /* Routine Name: ips_proc_info                                              */
1541 /*                                                                          */
1542 /* Routine Description:                                                     */
1543 /*                                                                          */
1544 /*   The passthru interface for the driver                                  */
1545 /*                                                                          */
1546 /****************************************************************************/
1547 static int
1548 ips_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
1549               int length, int func)
1550 {
1551         int i;
1552         int ret;
1553         ips_ha_t *ha = NULL;
1554
1555         METHOD_TRACE("ips_proc_info", 1);
1556
1557         /* Find our host structure */
1558         for (i = 0; i < ips_next_controller; i++) {
1559                 if (ips_sh[i]) {
1560                         if (ips_sh[i] == host) {
1561                                 ha = (ips_ha_t *) ips_sh[i]->hostdata;
1562                                 break;
1563                         }
1564                 }
1565         }
1566
1567         if (!ha)
1568                 return (-EINVAL);
1569
1570         if (func) {
1571                 /* write */
1572                 return (0);
1573         } else {
1574                 /* read */
1575                 if (start)
1576                         *start = buffer;
1577
1578                 ret = ips_host_info(ha, buffer, offset, length);
1579
1580                 return (ret);
1581         }
1582 }
1583
1584 /*--------------------------------------------------------------------------*/
1585 /* Helper Functions                                                         */
1586 /*--------------------------------------------------------------------------*/
1587
1588 /****************************************************************************/
1589 /*                                                                          */
1590 /* Routine Name: ips_is_passthru                                            */
1591 /*                                                                          */
1592 /* Routine Description:                                                     */
1593 /*                                                                          */
1594 /*   Determine if the specified SCSI command is really a passthru command   */
1595 /*                                                                          */
1596 /****************************************************************************/
1597 static int ips_is_passthru(struct scsi_cmnd *SC)
1598 {
1599         unsigned long flags;
1600
1601         METHOD_TRACE("ips_is_passthru", 1);
1602
1603         if (!SC)
1604                 return (0);
1605
1606         if ((SC->cmnd[0] == IPS_IOCTL_COMMAND) &&
1607             (SC->device->channel == 0) &&
1608             (SC->device->id == IPS_ADAPTER_ID) &&
1609             (SC->device->lun == 0) && SC->request_buffer) {
1610                 if ((!SC->use_sg) && SC->request_bufflen &&
1611                     (((char *) SC->request_buffer)[0] == 'C') &&
1612                     (((char *) SC->request_buffer)[1] == 'O') &&
1613                     (((char *) SC->request_buffer)[2] == 'P') &&
1614                     (((char *) SC->request_buffer)[3] == 'P'))
1615                         return 1;
1616                 else if (SC->use_sg) {
1617                         struct scatterlist *sg = SC->request_buffer;
1618                         char  *buffer;
1619
1620                         /* kmap_atomic() ensures addressability of the user buffer.*/
1621                         /* local_irq_save() protects the KM_IRQ0 address slot.     */
1622                         local_irq_save(flags);
1623                         buffer = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1624                         if (buffer && buffer[0] == 'C' && buffer[1] == 'O' &&
1625                             buffer[2] == 'P' && buffer[3] == 'P') {
1626                                 kunmap_atomic(buffer - sg->offset, KM_IRQ0);
1627                                 local_irq_restore(flags);
1628                                 return 1;
1629                         }
1630                         kunmap_atomic(buffer - sg->offset, KM_IRQ0);
1631                         local_irq_restore(flags);
1632                 }
1633         }
1634         return 0;
1635 }
1636
1637 /****************************************************************************/
1638 /*                                                                          */
1639 /* Routine Name: ips_alloc_passthru_buffer                                  */
1640 /*                                                                          */
1641 /* Routine Description:                                                     */
1642 /*   allocate a buffer large enough for the ioctl data if the ioctl buffer  */
1643 /*   is too small or doesn't exist                                          */
1644 /****************************************************************************/
1645 static int
1646 ips_alloc_passthru_buffer(ips_ha_t * ha, int length)
1647 {
1648         void *bigger_buf;
1649         dma_addr_t dma_busaddr;
1650
1651         if (ha->ioctl_data && length <= ha->ioctl_len)
1652                 return 0;
1653         /* there is no buffer or it's not big enough, allocate a new one */
1654         bigger_buf = pci_alloc_consistent(ha->pcidev, length, &dma_busaddr);
1655         if (bigger_buf) {
1656                 /* free the old memory */
1657                 pci_free_consistent(ha->pcidev, ha->ioctl_len, ha->ioctl_data,
1658                                     ha->ioctl_busaddr);
1659                 /* use the new memory */
1660                 ha->ioctl_data = (char *) bigger_buf;
1661                 ha->ioctl_len = length;
1662                 ha->ioctl_busaddr = dma_busaddr;
1663         } else {
1664                 return -1;
1665         }
1666         return 0;
1667 }
1668
1669 /****************************************************************************/
1670 /*                                                                          */
1671 /* Routine Name: ips_make_passthru                                          */
1672 /*                                                                          */
1673 /* Routine Description:                                                     */
1674 /*                                                                          */
1675 /*   Make a passthru command out of the info in the Scsi block              */
1676 /*                                                                          */
1677 /****************************************************************************/
1678 static int
1679 ips_make_passthru(ips_ha_t *ha, struct scsi_cmnd *SC, ips_scb_t *scb, int intr)
1680 {
1681         ips_passthru_t *pt;
1682         int length = 0;
1683         int ret;
1684
1685         METHOD_TRACE("ips_make_passthru", 1);
1686
1687         if (!SC->use_sg) {
1688                 length = SC->request_bufflen;
1689         } else {
1690                 struct scatterlist *sg = SC->request_buffer;
1691                 int i;
1692                 for (i = 0; i < SC->use_sg; i++)
1693                         length += sg[i].length;
1694         }
1695         if (length < sizeof (ips_passthru_t)) {
1696                 /* wrong size */
1697                 DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
1698                           ips_name, ha->host_num);
1699                 return (IPS_FAILURE);
1700         }
1701         if (ips_alloc_passthru_buffer(ha, length)) {
1702                 /* allocation failure!  If ha->ioctl_data exists, use it to return
1703                    some error codes.  Return a failed command to the scsi layer. */
1704                 if (ha->ioctl_data) {
1705                         pt = (ips_passthru_t *) ha->ioctl_data;
1706                         ips_scmd_buf_read(SC, pt, sizeof (ips_passthru_t));
1707                         pt->BasicStatus = 0x0B;
1708                         pt->ExtendedStatus = 0x00;
1709                         ips_scmd_buf_write(SC, pt, sizeof (ips_passthru_t));
1710                 }
1711                 return IPS_FAILURE;
1712         }
1713         ha->ioctl_datasize = length;
1714
1715         ips_scmd_buf_read(SC, ha->ioctl_data, ha->ioctl_datasize);
1716         pt = (ips_passthru_t *) ha->ioctl_data;
1717
1718         /*
1719          * Some notes about the passthru interface used
1720          *
1721          * IF the scsi op_code == 0x0d then we assume
1722          * that the data came along with/goes with the
1723          * packet we received from the sg driver. In this
1724          * case the CmdBSize field of the pt structure is
1725          * used for the size of the buffer.
1726          */
1727
1728         switch (pt->CoppCmd) {
1729         case IPS_NUMCTRLS:
1730                 memcpy(ha->ioctl_data + sizeof (ips_passthru_t),
1731                        &ips_num_controllers, sizeof (int));
1732                 ips_scmd_buf_write(SC, ha->ioctl_data,
1733                                    sizeof (ips_passthru_t) + sizeof (int));
1734                 SC->result = DID_OK << 16;
1735
1736                 return (IPS_SUCCESS_IMM);
1737
1738         case IPS_COPPUSRCMD:
1739         case IPS_COPPIOCCMD:
1740                 if (SC->cmnd[0] == IPS_IOCTL_COMMAND) {
1741                         if (length < (sizeof (ips_passthru_t) + pt->CmdBSize)) {
1742                                 /* wrong size */
1743                                 DEBUG_VAR(1,
1744                                           "(%s%d) Passthru structure wrong size",
1745                                           ips_name, ha->host_num);
1746
1747                                 return (IPS_FAILURE);
1748                         }
1749
1750                         if (ha->device_id == IPS_DEVICEID_COPPERHEAD &&
1751                             pt->CoppCP.cmd.flashfw.op_code ==
1752                             IPS_CMD_RW_BIOSFW) {
1753                                 ret = ips_flash_copperhead(ha, pt, scb);
1754                                 ips_scmd_buf_write(SC, ha->ioctl_data,
1755                                                    sizeof (ips_passthru_t));
1756                                 return ret;
1757                         }
1758                         if (ips_usrcmd(ha, pt, scb))
1759                                 return (IPS_SUCCESS);
1760                         else
1761                                 return (IPS_FAILURE);
1762                 }
1763
1764                 break;
1765
1766         }                       /* end switch */
1767
1768         return (IPS_FAILURE);
1769 }
1770
1771 /****************************************************************************/
1772 /* Routine Name: ips_flash_copperhead                                       */
1773 /* Routine Description:                                                     */
1774 /*   Flash the BIOS/FW on a Copperhead style controller                     */
1775 /****************************************************************************/
1776 static int
1777 ips_flash_copperhead(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1778 {
1779         int datasize;
1780
1781         /* Trombone is the only copperhead that can do packet flash, but only
1782          * for firmware. No one said it had to make sence. */
1783         if (IPS_IS_TROMBONE(ha) && pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE) {
1784                 if (ips_usrcmd(ha, pt, scb))
1785                         return IPS_SUCCESS;
1786                 else
1787                         return IPS_FAILURE;
1788         }
1789         pt->BasicStatus = 0x0B;
1790         pt->ExtendedStatus = 0;
1791         scb->scsi_cmd->result = DID_OK << 16;
1792         /* IF it's OK to Use the "CD BOOT" Flash Buffer, then you can     */
1793         /* avoid allocating a huge buffer per adapter ( which can fail ). */
1794         if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1795             pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1796                 pt->BasicStatus = 0;
1797                 return ips_flash_bios(ha, pt, scb);
1798         } else if (pt->CoppCP.cmd.flashfw.packet_num == 0) {
1799                 if (ips_FlashData && !test_and_set_bit(0, &ips_FlashDataInUse)){
1800                         ha->flash_data = ips_FlashData;
1801                         ha->flash_busaddr = ips_flashbusaddr;
1802                         ha->flash_len = PAGE_SIZE << 7;
1803                         ha->flash_datasize = 0;
1804                 } else if (!ha->flash_data) {
1805                         datasize = pt->CoppCP.cmd.flashfw.total_packets *
1806                             pt->CoppCP.cmd.flashfw.count;
1807                         ha->flash_data = pci_alloc_consistent(ha->pcidev,
1808                                                               datasize,
1809                                                               &ha->flash_busaddr);
1810                         if (!ha->flash_data){
1811                                 printk(KERN_WARNING "Unable to allocate a flash buffer\n");
1812                                 return IPS_FAILURE;
1813                         }
1814                         ha->flash_datasize = 0;
1815                         ha->flash_len = datasize;
1816                 } else
1817                         return IPS_FAILURE;
1818         } else {
1819                 if (pt->CoppCP.cmd.flashfw.count + ha->flash_datasize >
1820                     ha->flash_len) {
1821                         ips_free_flash_copperhead(ha);
1822                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
1823                                    "failed size sanity check\n");
1824                         return IPS_FAILURE;
1825                 }
1826         }
1827         if (!ha->flash_data)
1828                 return IPS_FAILURE;
1829         pt->BasicStatus = 0;
1830         memcpy(&ha->flash_data[ha->flash_datasize], pt + 1,
1831                pt->CoppCP.cmd.flashfw.count);
1832         ha->flash_datasize += pt->CoppCP.cmd.flashfw.count;
1833         if (pt->CoppCP.cmd.flashfw.packet_num ==
1834             pt->CoppCP.cmd.flashfw.total_packets - 1) {
1835                 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE)
1836                         return ips_flash_bios(ha, pt, scb);
1837                 else if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE)
1838                         return ips_flash_firmware(ha, pt, scb);
1839         }
1840         return IPS_SUCCESS_IMM;
1841 }
1842
1843 /****************************************************************************/
1844 /* Routine Name: ips_flash_bios                                             */
1845 /* Routine Description:                                                     */
1846 /*   flashes the bios of a copperhead adapter                               */
1847 /****************************************************************************/
1848 static int
1849 ips_flash_bios(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1850 {
1851
1852         if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1853             pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_BIOS) {
1854                 if ((!ha->func.programbios) || (!ha->func.erasebios) ||
1855                     (!ha->func.verifybios))
1856                         goto error;
1857                 if ((*ha->func.erasebios) (ha)) {
1858                         DEBUG_VAR(1,
1859                                   "(%s%d) flash bios failed - unable to erase flash",
1860                                   ips_name, ha->host_num);
1861                         goto error;
1862                 } else
1863                     if ((*ha->func.programbios) (ha,
1864                                                  ha->flash_data +
1865                                                  IPS_BIOS_HEADER,
1866                                                  ha->flash_datasize -
1867                                                  IPS_BIOS_HEADER, 0)) {
1868                         DEBUG_VAR(1,
1869                                   "(%s%d) flash bios failed - unable to flash",
1870                                   ips_name, ha->host_num);
1871                         goto error;
1872                 } else
1873                     if ((*ha->func.verifybios) (ha,
1874                                                 ha->flash_data +
1875                                                 IPS_BIOS_HEADER,
1876                                                 ha->flash_datasize -
1877                                                 IPS_BIOS_HEADER, 0)) {
1878                         DEBUG_VAR(1,
1879                                   "(%s%d) flash bios failed - unable to verify flash",
1880                                   ips_name, ha->host_num);
1881                         goto error;
1882                 }
1883                 ips_free_flash_copperhead(ha);
1884                 return IPS_SUCCESS_IMM;
1885         } else if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1886                    pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1887                 if (!ha->func.erasebios)
1888                         goto error;
1889                 if ((*ha->func.erasebios) (ha)) {
1890                         DEBUG_VAR(1,
1891                                   "(%s%d) flash bios failed - unable to erase flash",
1892                                   ips_name, ha->host_num);
1893                         goto error;
1894                 }
1895                 return IPS_SUCCESS_IMM;
1896         }
1897       error:
1898         pt->BasicStatus = 0x0B;
1899         pt->ExtendedStatus = 0x00;
1900         ips_free_flash_copperhead(ha);
1901         return IPS_FAILURE;
1902 }
1903
1904 /****************************************************************************/
1905 /*                                                                          */
1906 /* Routine Name: ips_fill_scb_sg_single                                     */
1907 /*                                                                          */
1908 /* Routine Description:                                                     */
1909 /*   Fill in a single scb sg_list element from an address                   */
1910 /*   return a -1 if a breakup occurred                                      */
1911 /****************************************************************************/
1912 static int
1913 ips_fill_scb_sg_single(ips_ha_t * ha, dma_addr_t busaddr,
1914                        ips_scb_t * scb, int indx, unsigned int e_len)
1915 {
1916
1917         int ret_val = 0;
1918
1919         if ((scb->data_len + e_len) > ha->max_xfer) {
1920                 e_len = ha->max_xfer - scb->data_len;
1921                 scb->breakup = indx;
1922                 ++scb->sg_break;
1923                 ret_val = -1;
1924         } else {
1925                 scb->breakup = 0;
1926                 scb->sg_break = 0;
1927         }
1928         if (IPS_USE_ENH_SGLIST(ha)) {
1929                 scb->sg_list.enh_list[indx].address_lo =
1930                     cpu_to_le32(pci_dma_lo32(busaddr));
1931                 scb->sg_list.enh_list[indx].address_hi =
1932                     cpu_to_le32(pci_dma_hi32(busaddr));
1933                 scb->sg_list.enh_list[indx].length = cpu_to_le32(e_len);
1934         } else {
1935                 scb->sg_list.std_list[indx].address =
1936                     cpu_to_le32(pci_dma_lo32(busaddr));
1937                 scb->sg_list.std_list[indx].length = cpu_to_le32(e_len);
1938         }
1939
1940         ++scb->sg_len;
1941         scb->data_len += e_len;
1942         return ret_val;
1943 }
1944
1945 /****************************************************************************/
1946 /* Routine Name: ips_flash_firmware                                         */
1947 /* Routine Description:                                                     */
1948 /*   flashes the firmware of a copperhead adapter                           */
1949 /****************************************************************************/
1950 static int
1951 ips_flash_firmware(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1952 {
1953         IPS_SG_LIST sg_list;
1954         uint32_t cmd_busaddr;
1955
1956         if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE &&
1957             pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_FW) {
1958                 memset(&pt->CoppCP.cmd, 0, sizeof (IPS_HOST_COMMAND));
1959                 pt->CoppCP.cmd.flashfw.op_code = IPS_CMD_DOWNLOAD;
1960                 pt->CoppCP.cmd.flashfw.count = cpu_to_le32(ha->flash_datasize);
1961         } else {
1962                 pt->BasicStatus = 0x0B;
1963                 pt->ExtendedStatus = 0x00;
1964                 ips_free_flash_copperhead(ha);
1965                 return IPS_FAILURE;
1966         }
1967         /* Save the S/G list pointer so it doesn't get clobbered */
1968         sg_list.list = scb->sg_list.list;
1969         cmd_busaddr = scb->scb_busaddr;
1970         /* copy in the CP */
1971         memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1972         /* FIX stuff that might be wrong */
1973         scb->sg_list.list = sg_list.list;
1974         scb->scb_busaddr = cmd_busaddr;
1975         scb->bus = scb->scsi_cmd->device->channel;
1976         scb->target_id = scb->scsi_cmd->device->id;
1977         scb->lun = scb->scsi_cmd->device->lun;
1978         scb->sg_len = 0;
1979         scb->data_len = 0;
1980         scb->flags = 0;
1981         scb->op_code = 0;
1982         scb->callback = ipsintr_done;
1983         scb->timeout = ips_cmd_timeout;
1984
1985         scb->data_len = ha->flash_datasize;
1986         scb->data_busaddr =
1987             pci_map_single(ha->pcidev, ha->flash_data, scb->data_len,
1988                            IPS_DMA_DIR(scb));
1989         scb->flags |= IPS_SCB_MAP_SINGLE;
1990         scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
1991         scb->cmd.flashfw.buffer_addr = cpu_to_le32(scb->data_busaddr);
1992         if (pt->TimeOut)
1993                 scb->timeout = pt->TimeOut;
1994         scb->scsi_cmd->result = DID_OK << 16;
1995         return IPS_SUCCESS;
1996 }
1997
1998 /****************************************************************************/
1999 /* Routine Name: ips_free_flash_copperhead                                  */
2000 /* Routine Description:                                                     */
2001 /*   release the memory resources used to hold the flash image              */
2002 /****************************************************************************/
2003 static void
2004 ips_free_flash_copperhead(ips_ha_t * ha)
2005 {
2006         if (ha->flash_data == ips_FlashData)
2007                 test_and_clear_bit(0, &ips_FlashDataInUse);
2008         else if (ha->flash_data)
2009                 pci_free_consistent(ha->pcidev, ha->flash_len, ha->flash_data,
2010                                     ha->flash_busaddr);
2011         ha->flash_data = NULL;
2012 }
2013
2014 /****************************************************************************/
2015 /*                                                                          */
2016 /* Routine Name: ips_usrcmd                                                 */
2017 /*                                                                          */
2018 /* Routine Description:                                                     */
2019 /*                                                                          */
2020 /*   Process a user command and make it ready to send                       */
2021 /*                                                                          */
2022 /****************************************************************************/
2023 static int
2024 ips_usrcmd(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
2025 {
2026         IPS_SG_LIST sg_list;
2027         uint32_t cmd_busaddr;
2028
2029         METHOD_TRACE("ips_usrcmd", 1);
2030
2031         if ((!scb) || (!pt) || (!ha))
2032                 return (0);
2033
2034         /* Save the S/G list pointer so it doesn't get clobbered */
2035         sg_list.list = scb->sg_list.list;
2036         cmd_busaddr = scb->scb_busaddr;
2037         /* copy in the CP */
2038         memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
2039         memcpy(&scb->dcdb, &pt->CoppCP.dcdb, sizeof (IPS_DCDB_TABLE));
2040
2041         /* FIX stuff that might be wrong */
2042         scb->sg_list.list = sg_list.list;
2043         scb->scb_busaddr = cmd_busaddr;
2044         scb->bus = scb->scsi_cmd->device->channel;
2045         scb->target_id = scb->scsi_cmd->device->id;
2046         scb->lun = scb->scsi_cmd->device->lun;
2047         scb->sg_len = 0;
2048         scb->data_len = 0;
2049         scb->flags = 0;
2050         scb->op_code = 0;
2051         scb->callback = ipsintr_done;
2052         scb->timeout = ips_cmd_timeout;
2053         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
2054
2055         /* we don't support DCDB/READ/WRITE Scatter Gather */
2056         if ((scb->cmd.basic_io.op_code == IPS_CMD_READ_SG) ||
2057             (scb->cmd.basic_io.op_code == IPS_CMD_WRITE_SG) ||
2058             (scb->cmd.basic_io.op_code == IPS_CMD_DCDB_SG))
2059                 return (0);
2060
2061         if (pt->CmdBSize) {
2062                 scb->data_len = pt->CmdBSize;
2063                 scb->data_busaddr = ha->ioctl_busaddr + sizeof (ips_passthru_t);
2064         } else {
2065                 scb->data_busaddr = 0L;
2066         }
2067
2068         if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
2069                 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
2070                                                          (unsigned long) &scb->
2071                                                          dcdb -
2072                                                          (unsigned long) scb);
2073
2074         if (pt->CmdBSize) {
2075                 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
2076                         scb->dcdb.buffer_pointer =
2077                             cpu_to_le32(scb->data_busaddr);
2078                 else
2079                         scb->cmd.basic_io.sg_addr =
2080                             cpu_to_le32(scb->data_busaddr);
2081         }
2082
2083         /* set timeouts */
2084         if (pt->TimeOut) {
2085                 scb->timeout = pt->TimeOut;
2086
2087                 if (pt->TimeOut <= 10)
2088                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;
2089                 else if (pt->TimeOut <= 60)
2090                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;
2091                 else
2092                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
2093         }
2094
2095         /* assume success */
2096         scb->scsi_cmd->result = DID_OK << 16;
2097
2098         /* success */
2099         return (1);
2100 }
2101
2102 /****************************************************************************/
2103 /*                                                                          */
2104 /* Routine Name: ips_cleanup_passthru                                       */
2105 /*                                                                          */
2106 /* Routine Description:                                                     */
2107 /*                                                                          */
2108 /*   Cleanup after a passthru command                                       */
2109 /*                                                                          */
2110 /****************************************************************************/
2111 static void
2112 ips_cleanup_passthru(ips_ha_t * ha, ips_scb_t * scb)
2113 {
2114         ips_passthru_t *pt;
2115
2116         METHOD_TRACE("ips_cleanup_passthru", 1);
2117
2118         if ((!scb) || (!scb->scsi_cmd) || (!scb->scsi_cmd->request_buffer)) {
2119                 DEBUG_VAR(1, "(%s%d) couldn't cleanup after passthru",
2120                           ips_name, ha->host_num);
2121
2122                 return;
2123         }
2124         pt = (ips_passthru_t *) ha->ioctl_data;
2125
2126         /* Copy data back to the user */
2127         if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)      /* Copy DCDB Back to Caller's Area */
2128                 memcpy(&pt->CoppCP.dcdb, &scb->dcdb, sizeof (IPS_DCDB_TABLE));
2129
2130         pt->BasicStatus = scb->basic_status;
2131         pt->ExtendedStatus = scb->extended_status;
2132         pt->AdapterType = ha->ad_type;
2133
2134         if (ha->device_id == IPS_DEVICEID_COPPERHEAD &&
2135             (scb->cmd.flashfw.op_code == IPS_CMD_DOWNLOAD ||
2136              scb->cmd.flashfw.op_code == IPS_CMD_RW_BIOSFW))
2137                 ips_free_flash_copperhead(ha);
2138
2139         ips_scmd_buf_write(scb->scsi_cmd, ha->ioctl_data, ha->ioctl_datasize);
2140 }
2141
2142 /****************************************************************************/
2143 /*                                                                          */
2144 /* Routine Name: ips_host_info                                              */
2145 /*                                                                          */
2146 /* Routine Description:                                                     */
2147 /*                                                                          */
2148 /*   The passthru interface for the driver                                  */
2149 /*                                                                          */
2150 /****************************************************************************/
2151 static int
2152 ips_host_info(ips_ha_t * ha, char *ptr, off_t offset, int len)
2153 {
2154         IPS_INFOSTR info;
2155
2156         METHOD_TRACE("ips_host_info", 1);
2157
2158         info.buffer = ptr;
2159         info.length = len;
2160         info.offset = offset;
2161         info.pos = 0;
2162         info.localpos = 0;
2163
2164         copy_info(&info, "\nIBM ServeRAID General Information:\n\n");
2165
2166         if ((le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) &&
2167             (le16_to_cpu(ha->nvram->adapter_type) != 0))
2168                 copy_info(&info, "\tController Type                   : %s\n",
2169                           ips_adapter_name[ha->ad_type - 1]);
2170         else
2171                 copy_info(&info,
2172                           "\tController Type                   : Unknown\n");
2173
2174         if (ha->io_addr)
2175                 copy_info(&info,
2176                           "\tIO region                         : 0x%lx (%d bytes)\n",
2177                           ha->io_addr, ha->io_len);
2178
2179         if (ha->mem_addr) {
2180                 copy_info(&info,
2181                           "\tMemory region                     : 0x%lx (%d bytes)\n",
2182                           ha->mem_addr, ha->mem_len);
2183                 copy_info(&info,
2184                           "\tShared memory address             : 0x%lx\n",
2185                           ha->mem_ptr);
2186         }
2187
2188         copy_info(&info, "\tIRQ number                        : %d\n", ha->irq);
2189
2190     /* For the Next 3 lines Check for Binary 0 at the end and don't include it if it's there. */
2191     /* That keeps everything happy for "text" operations on the proc file.                    */
2192
2193         if (le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) {
2194         if (ha->nvram->bios_low[3] == 0) {
2195             copy_info(&info,
2196                                   "\tBIOS Version                      : %c%c%c%c%c%c%c\n",
2197                                   ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2198                                   ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2199                                   ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2200                                   ha->nvram->bios_low[2]);
2201
2202         } else {
2203                     copy_info(&info,
2204                                   "\tBIOS Version                      : %c%c%c%c%c%c%c%c\n",
2205                                   ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2206                                   ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2207                                   ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2208                                   ha->nvram->bios_low[2], ha->nvram->bios_low[3]);
2209         }
2210
2211     }
2212
2213     if (ha->enq->CodeBlkVersion[7] == 0) {
2214         copy_info(&info,
2215                           "\tFirmware Version                  : %c%c%c%c%c%c%c\n",
2216                           ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2217                           ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2218                           ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2219                           ha->enq->CodeBlkVersion[6]);
2220     } else {
2221         copy_info(&info,
2222                           "\tFirmware Version                  : %c%c%c%c%c%c%c%c\n",
2223                           ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2224                           ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2225                           ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2226                           ha->enq->CodeBlkVersion[6], ha->enq->CodeBlkVersion[7]);
2227     }
2228
2229     if (ha->enq->BootBlkVersion[7] == 0) {
2230         copy_info(&info,
2231                           "\tBoot Block Version                : %c%c%c%c%c%c%c\n",
2232                           ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2233                           ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2234                           ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2235                           ha->enq->BootBlkVersion[6]);
2236     } else {
2237         copy_info(&info,
2238                           "\tBoot Block Version                : %c%c%c%c%c%c%c%c\n",
2239                           ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2240                           ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2241                           ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2242                           ha->enq->BootBlkVersion[6], ha->enq->BootBlkVersion[7]);
2243     }
2244
2245         copy_info(&info, "\tDriver Version                    : %s%s\n",
2246                   IPS_VERSION_HIGH, IPS_VERSION_LOW);
2247
2248         copy_info(&info, "\tDriver Build                      : %d\n",
2249                   IPS_BUILD_IDENT);
2250
2251         copy_info(&info, "\tMax Physical Devices              : %d\n",
2252                   ha->enq->ucMaxPhysicalDevices);
2253         copy_info(&info, "\tMax Active Commands               : %d\n",
2254                   ha->max_cmds);
2255         copy_info(&info, "\tCurrent Queued Commands           : %d\n",
2256                   ha->scb_waitlist.count);
2257         copy_info(&info, "\tCurrent Active Commands           : %d\n",
2258                   ha->scb_activelist.count - ha->num_ioctl);
2259         copy_info(&info, "\tCurrent Queued PT Commands        : %d\n",
2260                   ha->copp_waitlist.count);
2261         copy_info(&info, "\tCurrent Active PT Commands        : %d\n",
2262                   ha->num_ioctl);
2263
2264         copy_info(&info, "\n");
2265
2266         return (info.localpos);
2267 }
2268
2269 /****************************************************************************/
2270 /*                                                                          */
2271 /* Routine Name: copy_mem_info                                              */
2272 /*                                                                          */
2273 /* Routine Description:                                                     */
2274 /*                                                                          */
2275 /*   Copy data into an IPS_INFOSTR structure                                */
2276 /*                                                                          */
2277 /****************************************************************************/
2278 static void
2279 copy_mem_info(IPS_INFOSTR * info, char *data, int len)
2280 {
2281         METHOD_TRACE("copy_mem_info", 1);
2282
2283         if (info->pos + len < info->offset) {
2284                 info->pos += len;
2285                 return;
2286         }
2287
2288         if (info->pos < info->offset) {
2289                 data += (info->offset - info->pos);
2290                 len -= (info->offset - info->pos);
2291                 info->pos += (info->offset - info->pos);
2292         }
2293
2294         if (info->localpos + len > info->length)
2295                 len = info->length - info->localpos;
2296
2297         if (len > 0) {
2298                 memcpy(info->buffer + info->localpos, data, len);
2299                 info->pos += len;
2300                 info->localpos += len;
2301         }
2302 }
2303
2304 /****************************************************************************/
2305 /*                                                                          */
2306 /* Routine Name: copy_info                                                  */
2307 /*                                                                          */
2308 /* Routine Description:                                                     */
2309 /*                                                                          */
2310 /*   printf style wrapper for an info structure                             */
2311 /*                                                                          */
2312 /****************************************************************************/
2313 static int
2314 copy_info(IPS_INFOSTR * info, char *fmt, ...)
2315 {
2316         va_list args;
2317         char buf[128];
2318         int len;
2319
2320         METHOD_TRACE("copy_info", 1);
2321
2322         va_start(args, fmt);
2323         len = vsprintf(buf, fmt, args);
2324         va_end(args);
2325
2326         copy_mem_info(info, buf, len);
2327
2328         return (len);
2329 }
2330
2331 /****************************************************************************/
2332 /*                                                                          */
2333 /* Routine Name: ips_identify_controller                                    */
2334 /*                                                                          */
2335 /* Routine Description:                                                     */
2336 /*                                                                          */
2337 /*   Identify this controller                                               */
2338 /*                                                                          */
2339 /****************************************************************************/
2340 static void
2341 ips_identify_controller(ips_ha_t * ha)
2342 {
2343         METHOD_TRACE("ips_identify_controller", 1);
2344
2345         switch (ha->device_id) {
2346         case IPS_DEVICEID_COPPERHEAD:
2347                 if (ha->revision_id <= IPS_REVID_SERVERAID) {
2348                         ha->ad_type = IPS_ADTYPE_SERVERAID;
2349                 } else if (ha->revision_id == IPS_REVID_SERVERAID2) {
2350                         ha->ad_type = IPS_ADTYPE_SERVERAID2;
2351                 } else if (ha->revision_id == IPS_REVID_NAVAJO) {
2352                         ha->ad_type = IPS_ADTYPE_NAVAJO;
2353                 } else if ((ha->revision_id == IPS_REVID_SERVERAID2)
2354                            && (ha->slot_num == 0)) {
2355                         ha->ad_type = IPS_ADTYPE_KIOWA;
2356                 } else if ((ha->revision_id >= IPS_REVID_CLARINETP1) &&
2357                            (ha->revision_id <= IPS_REVID_CLARINETP3)) {
2358                         if (ha->enq->ucMaxPhysicalDevices == 15)
2359                                 ha->ad_type = IPS_ADTYPE_SERVERAID3L;
2360                         else
2361                                 ha->ad_type = IPS_ADTYPE_SERVERAID3;
2362                 } else if ((ha->revision_id >= IPS_REVID_TROMBONE32) &&
2363                            (ha->revision_id <= IPS_REVID_TROMBONE64)) {
2364                         ha->ad_type = IPS_ADTYPE_SERVERAID4H;
2365                 }
2366                 break;
2367
2368         case IPS_DEVICEID_MORPHEUS:
2369                 switch (ha->subdevice_id) {
2370                 case IPS_SUBDEVICEID_4L:
2371                         ha->ad_type = IPS_ADTYPE_SERVERAID4L;
2372                         break;
2373
2374                 case IPS_SUBDEVICEID_4M:
2375                         ha->ad_type = IPS_ADTYPE_SERVERAID4M;
2376                         break;
2377
2378                 case IPS_SUBDEVICEID_4MX:
2379                         ha->ad_type = IPS_ADTYPE_SERVERAID4MX;
2380                         break;
2381
2382                 case IPS_SUBDEVICEID_4LX:
2383                         ha->ad_type = IPS_ADTYPE_SERVERAID4LX;
2384                         break;
2385
2386                 case IPS_SUBDEVICEID_5I2:
2387                         ha->ad_type = IPS_ADTYPE_SERVERAID5I2;
2388                         break;
2389
2390                 case IPS_SUBDEVICEID_5I1:
2391                         ha->ad_type = IPS_ADTYPE_SERVERAID5I1;
2392                         break;
2393                 }
2394
2395                 break;
2396
2397         case IPS_DEVICEID_MARCO:
2398                 switch (ha->subdevice_id) {
2399                 case IPS_SUBDEVICEID_6M:
2400                         ha->ad_type = IPS_ADTYPE_SERVERAID6M;
2401                         break;
2402                 case IPS_SUBDEVICEID_6I:
2403                         ha->ad_type = IPS_ADTYPE_SERVERAID6I;
2404                         break;
2405                 case IPS_SUBDEVICEID_7k:
2406                         ha->ad_type = IPS_ADTYPE_SERVERAID7k;
2407                         break;
2408                 case IPS_SUBDEVICEID_7M:
2409                         ha->ad_type = IPS_ADTYPE_SERVERAID7M;
2410                         break;
2411                 }
2412                 break;
2413         }
2414 }
2415
2416 /****************************************************************************/
2417 /*                                                                          */
2418 /* Routine Name: ips_get_bios_version                                       */
2419 /*                                                                          */
2420 /* Routine Description:                                                     */
2421 /*                                                                          */
2422 /*   Get the BIOS revision number                                           */
2423 /*                                                                          */
2424 /****************************************************************************/
2425 static void
2426 ips_get_bios_version(ips_ha_t * ha, int intr)
2427 {
2428         ips_scb_t *scb;
2429         int ret;
2430         uint8_t major;
2431         uint8_t minor;
2432         uint8_t subminor;
2433         uint8_t *buffer;
2434         char hexDigits[] =
2435             { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
2436      'D', 'E', 'F' };
2437
2438         METHOD_TRACE("ips_get_bios_version", 1);
2439
2440         major = 0;
2441         minor = 0;
2442
2443         strncpy(ha->bios_version, "       ?", 8);
2444
2445         if (ha->device_id == IPS_DEVICEID_COPPERHEAD) {
2446                 if (IPS_USE_MEMIO(ha)) {
2447                         /* Memory Mapped I/O */
2448
2449                         /* test 1st byte */
2450                         writel(0, ha->mem_ptr + IPS_REG_FLAP);
2451                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2452                                 udelay(25);     /* 25 us */
2453
2454                         if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
2455                                 return;
2456
2457                         writel(1, ha->mem_ptr + IPS_REG_FLAP);
2458                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2459                                 udelay(25);     /* 25 us */
2460
2461                         if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
2462                                 return;
2463
2464                         /* Get Major version */
2465                         writel(0x1FF, ha->mem_ptr + IPS_REG_FLAP);
2466                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2467                                 udelay(25);     /* 25 us */
2468
2469                         major = readb(ha->mem_ptr + IPS_REG_FLDP);
2470
2471                         /* Get Minor version */
2472                         writel(0x1FE, ha->mem_ptr + IPS_REG_FLAP);
2473                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2474                                 udelay(25);     /* 25 us */
2475                         minor = readb(ha->mem_ptr + IPS_REG_FLDP);
2476
2477                         /* Get SubMinor version */
2478                         writel(0x1FD, ha->mem_ptr + IPS_REG_FLAP);
2479                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2480                                 udelay(25);     /* 25 us */
2481                         subminor = readb(ha->mem_ptr + IPS_REG_FLDP);
2482
2483                 } else {
2484                         /* Programmed I/O */
2485
2486                         /* test 1st byte */
2487                         outl(0, ha->io_addr + IPS_REG_FLAP);
2488                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2489                                 udelay(25);     /* 25 us */
2490
2491                         if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
2492                                 return;
2493
2494                         outl(cpu_to_le32(1), ha->io_addr + IPS_REG_FLAP);
2495                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2496                                 udelay(25);     /* 25 us */
2497
2498                         if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
2499                                 return;
2500
2501                         /* Get Major version */
2502                         outl(cpu_to_le32(0x1FF), ha->io_addr + IPS_REG_FLAP);
2503                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2504                                 udelay(25);     /* 25 us */
2505
2506                         major = inb(ha->io_addr + IPS_REG_FLDP);
2507
2508                         /* Get Minor version */
2509                         outl(cpu_to_le32(0x1FE), ha->io_addr + IPS_REG_FLAP);
2510                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2511                                 udelay(25);     /* 25 us */
2512
2513                         minor = inb(ha->io_addr + IPS_REG_FLDP);
2514
2515                         /* Get SubMinor version */
2516                         outl(cpu_to_le32(0x1FD), ha->io_addr + IPS_REG_FLAP);
2517                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2518                                 udelay(25);     /* 25 us */
2519
2520                         subminor = inb(ha->io_addr + IPS_REG_FLDP);
2521
2522                 }
2523         } else {
2524                 /* Morpheus Family - Send Command to the card */
2525
2526                 buffer = ha->ioctl_data;
2527
2528                 memset(buffer, 0, 0x1000);
2529
2530                 scb = &ha->scbs[ha->max_cmds - 1];
2531
2532                 ips_init_scb(ha, scb);
2533
2534                 scb->timeout = ips_cmd_timeout;
2535                 scb->cdb[0] = IPS_CMD_RW_BIOSFW;
2536
2537                 scb->cmd.flashfw.op_code = IPS_CMD_RW_BIOSFW;
2538                 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
2539                 scb->cmd.flashfw.type = 1;
2540                 scb->cmd.flashfw.direction = 0;
2541                 scb->cmd.flashfw.count = cpu_to_le32(0x800);
2542                 scb->cmd.flashfw.total_packets = 1;
2543                 scb->cmd.flashfw.packet_num = 0;
2544                 scb->data_len = 0x1000;
2545                 scb->cmd.flashfw.buffer_addr = ha->ioctl_busaddr;
2546
2547                 /* issue the command */
2548                 if (((ret =
2549                       ips_send_wait(ha, scb, ips_cmd_timeout,
2550                                     intr)) == IPS_FAILURE)
2551                     || (ret == IPS_SUCCESS_IMM)
2552                     || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
2553                         /* Error occurred */
2554
2555                         return;
2556                 }
2557
2558                 if ((buffer[0xC0] == 0x55) && (buffer[0xC1] == 0xAA)) {
2559                         major = buffer[0x1ff + 0xC0];   /* Offset 0x1ff after the header (0xc0) */
2560                         minor = buffer[0x1fe + 0xC0];   /* Offset 0x1fe after the header (0xc0) */
2561                         subminor = buffer[0x1fd + 0xC0];        /* Offset 0x1fd after the header (0xc0) */
2562                 } else {
2563                         return;
2564                 }
2565         }
2566
2567         ha->bios_version[0] = hexDigits[(major & 0xF0) >> 4];
2568         ha->bios_version[1] = '.';
2569         ha->bios_version[2] = hexDigits[major & 0x0F];
2570         ha->bios_version[3] = hexDigits[subminor];
2571         ha->bios_version[4] = '.';
2572         ha->bios_version[5] = hexDigits[(minor & 0xF0) >> 4];
2573         ha->bios_version[6] = hexDigits[minor & 0x0F];
2574         ha->bios_version[7] = 0;
2575 }
2576
2577 /****************************************************************************/
2578 /*                                                                          */
2579 /* Routine Name: ips_hainit                                                 */
2580 /*                                                                          */
2581 /* Routine Description:                                                     */
2582 /*                                                                          */
2583 /*   Initialize the controller                                              */
2584 /*                                                                          */
2585 /* NOTE: Assumes to be called from with a lock                              */
2586 /*                                                                          */
2587 /****************************************************************************/
2588 static int
2589 ips_hainit(ips_ha_t * ha)
2590 {
2591         int i;
2592         struct timeval tv;
2593
2594         METHOD_TRACE("ips_hainit", 1);
2595
2596         if (!ha)
2597                 return (0);
2598
2599         if (ha->func.statinit)
2600                 (*ha->func.statinit) (ha);
2601
2602         if (ha->func.enableint)
2603                 (*ha->func.enableint) (ha);
2604
2605         /* Send FFDC */
2606         ha->reset_count = 1;
2607         do_gettimeofday(&tv);
2608         ha->last_ffdc = tv.tv_sec;
2609         ips_ffdc_reset(ha, IPS_INTR_IORL);
2610
2611         if (!ips_read_config(ha, IPS_INTR_IORL)) {
2612                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2613                            "unable to read config from controller.\n");
2614
2615                 return (0);
2616         }
2617         /* end if */
2618         if (!ips_read_adapter_status(ha, IPS_INTR_IORL)) {
2619                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2620                            "unable to read controller status.\n");
2621
2622                 return (0);
2623         }
2624
2625         /* Identify this controller */
2626         ips_identify_controller(ha);
2627
2628         if (!ips_read_subsystem_parameters(ha, IPS_INTR_IORL)) {
2629                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2630                            "unable to read subsystem parameters.\n");
2631
2632                 return (0);
2633         }
2634
2635         /* write nvram user page 5 */
2636         if (!ips_write_driver_status(ha, IPS_INTR_IORL)) {
2637                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2638                            "unable to write driver info to controller.\n");
2639
2640                 return (0);
2641         }
2642
2643         /* If there are Logical Drives and a Reset Occurred, then an EraseStripeLock is Needed */
2644         if ((ha->conf->ucLogDriveCount > 0) && (ha->requires_esl == 1))
2645                 ips_clear_adapter(ha, IPS_INTR_IORL);
2646
2647         /* set limits on SID, LUN, BUS */
2648         ha->ntargets = IPS_MAX_TARGETS + 1;
2649         ha->nlun = 1;
2650         ha->nbus = (ha->enq->ucMaxPhysicalDevices / IPS_MAX_TARGETS) + 1;
2651
2652         switch (ha->conf->logical_drive[0].ucStripeSize) {
2653         case 4:
2654                 ha->max_xfer = 0x10000;
2655                 break;
2656
2657         case 5:
2658                 ha->max_xfer = 0x20000;
2659                 break;
2660
2661         case 6:
2662                 ha->max_xfer = 0x40000;
2663                 break;
2664
2665         case 7:
2666         default:
2667                 ha->max_xfer = 0x80000;
2668                 break;
2669         }
2670
2671         /* setup max concurrent commands */
2672         if (le32_to_cpu(ha->subsys->param[4]) & 0x1) {
2673                 /* Use the new method */
2674                 ha->max_cmds = ha->enq->ucConcurrentCmdCount;
2675         } else {
2676                 /* use the old method */
2677                 switch (ha->conf->logical_drive[0].ucStripeSize) {
2678                 case 4:
2679                         ha->max_cmds = 32;
2680                         break;
2681
2682                 case 5:
2683                         ha->max_cmds = 16;
2684                         break;
2685
2686                 case 6:
2687                         ha->max_cmds = 8;
2688                         break;
2689
2690                 case 7:
2691                 default:
2692                         ha->max_cmds = 4;
2693                         break;
2694                 }
2695         }
2696
2697         /* Limit the Active Commands on a Lite Adapter */
2698         if ((ha->ad_type == IPS_ADTYPE_SERVERAID3L) ||
2699             (ha->ad_type == IPS_ADTYPE_SERVERAID4L) ||
2700             (ha->ad_type == IPS_ADTYPE_SERVERAID4LX)) {
2701                 if ((ha->max_cmds > MaxLiteCmds) && (MaxLiteCmds))
2702                         ha->max_cmds = MaxLiteCmds;
2703         }
2704
2705         /* set controller IDs */
2706         ha->ha_id[0] = IPS_ADAPTER_ID;
2707         for (i = 1; i < ha->nbus; i++) {
2708                 ha->ha_id[i] = ha->conf->init_id[i - 1] & 0x1f;
2709                 ha->dcdb_active[i - 1] = 0;
2710         }
2711
2712         return (1);
2713 }
2714
2715 /****************************************************************************/
2716 /*                                                                          */
2717 /* Routine Name: ips_next                                                   */
2718 /*                                                                          */
2719 /* Routine Description:                                                     */
2720 /*                                                                          */
2721 /*   Take the next command off the queue and send it to the controller      */
2722 /*                                                                          */
2723 /****************************************************************************/
2724 static void
2725 ips_next(ips_ha_t * ha, int intr)
2726 {
2727         ips_scb_t *scb;
2728         struct scsi_cmnd *SC;
2729         struct scsi_cmnd *p;
2730         struct scsi_cmnd *q;
2731         ips_copp_wait_item_t *item;
2732         int ret;
2733         unsigned long cpu_flags = 0;
2734         struct Scsi_Host *host;
2735         METHOD_TRACE("ips_next", 1);
2736
2737         if (!ha)
2738                 return;
2739         host = ips_sh[ha->host_num];
2740         /*
2741          * Block access to the queue function so
2742          * this command won't time out
2743          */
2744         if (intr == IPS_INTR_ON)
2745                 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2746
2747         if ((ha->subsys->param[3] & 0x300000)
2748             && (ha->scb_activelist.count == 0)) {
2749                 struct timeval tv;
2750
2751                 do_gettimeofday(&tv);
2752
2753                 if (tv.tv_sec - ha->last_ffdc > IPS_SECS_8HOURS) {
2754                         ha->last_ffdc = tv.tv_sec;
2755                         ips_ffdc_time(ha);
2756                 }
2757         }
2758
2759         /*
2760          * Send passthru commands
2761          * These have priority over normal I/O
2762          * but shouldn't affect performance too much
2763          * since we limit the number that can be active
2764          * on the card at any one time
2765          */
2766         while ((ha->num_ioctl < IPS_MAX_IOCTL) &&
2767                (ha->copp_waitlist.head) && (scb = ips_getscb(ha))) {
2768
2769                 item = ips_removeq_copp_head(&ha->copp_waitlist);
2770                 ha->num_ioctl++;
2771                 if (intr == IPS_INTR_ON)
2772                         IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2773                 scb->scsi_cmd = item->scsi_cmd;
2774                 kfree(item);
2775
2776                 ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
2777
2778                 if (intr == IPS_INTR_ON)
2779                         IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2780                 switch (ret) {
2781                 case IPS_FAILURE:
2782                         if (scb->scsi_cmd) {
2783                                 scb->scsi_cmd->result = DID_ERROR << 16;
2784                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2785                         }
2786
2787                         ips_freescb(ha, scb);
2788                         break;
2789                 case IPS_SUCCESS_IMM:
2790                         if (scb->scsi_cmd) {
2791                                 scb->scsi_cmd->result = DID_OK << 16;
2792                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2793                         }
2794
2795                         ips_freescb(ha, scb);
2796                         break;
2797                 default:
2798                         break;
2799                 }               /* end case */
2800
2801                 if (ret != IPS_SUCCESS) {
2802                         ha->num_ioctl--;
2803                         continue;
2804                 }
2805
2806                 ret = ips_send_cmd(ha, scb);
2807
2808                 if (ret == IPS_SUCCESS)
2809                         ips_putq_scb_head(&ha->scb_activelist, scb);
2810                 else
2811                         ha->num_ioctl--;
2812
2813                 switch (ret) {
2814                 case IPS_FAILURE:
2815                         if (scb->scsi_cmd) {
2816                                 scb->scsi_cmd->result = DID_ERROR << 16;
2817                         }
2818
2819                         ips_freescb(ha, scb);
2820                         break;
2821                 case IPS_SUCCESS_IMM:
2822                         ips_freescb(ha, scb);
2823                         break;
2824                 default:
2825                         break;
2826                 }               /* end case */
2827
2828         }
2829
2830         /*
2831          * Send "Normal" I/O commands
2832          */
2833
2834         p = ha->scb_waitlist.head;
2835         while ((p) && (scb = ips_getscb(ha))) {
2836                 if ((scmd_channel(p) > 0)
2837                     && (ha->
2838                         dcdb_active[scmd_channel(p) -
2839                                     1] & (1 << scmd_id(p)))) {
2840                         ips_freescb(ha, scb);
2841                         p = (struct scsi_cmnd *) p->host_scribble;
2842                         continue;
2843                 }
2844
2845                 q = p;
2846                 SC = ips_removeq_wait(&ha->scb_waitlist, q);
2847
2848                 if (intr == IPS_INTR_ON)
2849                         IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags); /* Unlock HA after command is taken off queue */
2850
2851                 SC->result = DID_OK;
2852                 SC->host_scribble = NULL;
2853
2854                 memset(SC->sense_buffer, 0, sizeof (SC->sense_buffer));
2855
2856                 scb->target_id = SC->device->id;
2857                 scb->lun = SC->device->lun;
2858                 scb->bus = SC->device->channel;
2859                 scb->scsi_cmd = SC;
2860                 scb->breakup = 0;
2861                 scb->data_len = 0;
2862                 scb->callback = ipsintr_done;
2863                 scb->timeout = ips_cmd_timeout;
2864                 memset(&scb->cmd, 0, 16);
2865
2866                 /* copy in the CDB */
2867                 memcpy(scb->cdb, SC->cmnd, SC->cmd_len);
2868
2869                 /* Now handle the data buffer */
2870                 if (SC->use_sg) {
2871                         struct scatterlist *sg;
2872                         int i;
2873
2874                         sg = SC->request_buffer;
2875                         scb->sg_count = pci_map_sg(ha->pcidev, sg, SC->use_sg,
2876                                                    SC->sc_data_direction);
2877                         scb->flags |= IPS_SCB_MAP_SG;
2878                         for (i = 0; i < scb->sg_count; i++) {
2879                                 if (ips_fill_scb_sg_single
2880                                     (ha, sg_dma_address(&sg[i]), scb, i,
2881                                      sg_dma_len(&sg[i])) < 0)
2882                                         break;
2883                         }
2884                         scb->dcdb.transfer_length = scb->data_len;
2885                 } else {
2886                         if (SC->request_bufflen) {
2887                                 scb->data_busaddr =
2888                                     pci_map_single(ha->pcidev,
2889                                                    SC->request_buffer,
2890                                                    SC->request_bufflen,
2891                                                    SC->sc_data_direction);
2892                                 scb->flags |= IPS_SCB_MAP_SINGLE;
2893                                 ips_fill_scb_sg_single(ha, scb->data_busaddr,
2894                                                        scb, 0,
2895                                                        SC->request_bufflen);
2896                                 scb->dcdb.transfer_length = scb->data_len;
2897                         } else {
2898                                 scb->data_busaddr = 0L;
2899                                 scb->sg_len = 0;
2900                                 scb->data_len = 0;
2901                                 scb->dcdb.transfer_length = 0;
2902                         }
2903
2904                 }
2905
2906                 scb->dcdb.cmd_attribute =
2907                     ips_command_direction[scb->scsi_cmd->cmnd[0]];
2908
2909         /* Allow a WRITE BUFFER Command to Have no Data */
2910         /* This is Used by Tape Flash Utilites          */
2911         if ((scb->scsi_cmd->cmnd[0] == WRITE_BUFFER) && (scb->data_len == 0))
2912             scb->dcdb.cmd_attribute = 0;
2913
2914                 if (!(scb->dcdb.cmd_attribute & 0x3))
2915                         scb->dcdb.transfer_length = 0;
2916
2917                 if (scb->data_len >= IPS_MAX_XFER) {
2918                         scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
2919                         scb->dcdb.transfer_length = 0;
2920                 }
2921                 if (intr == IPS_INTR_ON)
2922                         IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2923
2924                 ret = ips_send_cmd(ha, scb);
2925
2926                 switch (ret) {
2927                 case IPS_SUCCESS:
2928                         ips_putq_scb_head(&ha->scb_activelist, scb);
2929                         break;
2930                 case IPS_FAILURE:
2931                         if (scb->scsi_cmd) {
2932                                 scb->scsi_cmd->result = DID_ERROR << 16;
2933                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2934                         }
2935
2936                         if (scb->bus)
2937                                 ha->dcdb_active[scb->bus - 1] &=
2938                                     ~(1 << scb->target_id);
2939
2940                         ips_freescb(ha, scb);
2941                         break;
2942                 case IPS_SUCCESS_IMM:
2943                         if (scb->scsi_cmd)
2944                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2945
2946                         if (scb->bus)
2947                                 ha->dcdb_active[scb->bus - 1] &=
2948                                     ~(1 << scb->target_id);
2949
2950                         ips_freescb(ha, scb);
2951                         break;
2952                 default:
2953                         break;
2954                 }               /* end case */
2955
2956                 p = (struct scsi_cmnd *) p->host_scribble;
2957
2958         }                       /* end while */
2959
2960         if (intr == IPS_INTR_ON)
2961                 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2962 }
2963
2964 /****************************************************************************/
2965 /*                                                                          */
2966 /* Routine Name: ips_putq_scb_head                                          */
2967 /*                                                                          */
2968 /* Routine Description:                                                     */
2969 /*                                                                          */
2970 /*   Add an item to the head of the queue                                   */
2971 /*                                                                          */
2972 /* ASSUMED to be called from within the HA lock                             */
2973 /*                                                                          */
2974 /****************************************************************************/
2975 static void
2976 ips_putq_scb_head(ips_scb_queue_t * queue, ips_scb_t * item)
2977 {
2978         METHOD_TRACE("ips_putq_scb_head", 1);
2979
2980         if (!item)
2981                 return;
2982
2983         item->q_next = queue->head;
2984         queue->head = item;
2985
2986         if (!queue->tail)
2987                 queue->tail = item;
2988
2989         queue->count++;
2990 }
2991
2992 /****************************************************************************/
2993 /*                                                                          */
2994 /* Routine Name: ips_removeq_scb_head                                       */
2995 /*                                                                          */
2996 /* Routine Description:                                                     */
2997 /*                                                                          */
2998 /*   Remove the head of the queue                                           */
2999 /*                                                                          */
3000 /* ASSUMED to be called from within the HA lock                             */
3001 /*                                                                          */
3002 /****************************************************************************/
3003 static ips_scb_t *
3004 ips_removeq_scb_head(ips_scb_queue_t * queue)
3005 {
3006         ips_scb_t *item;
3007
3008         METHOD_TRACE("ips_removeq_scb_head", 1);
3009
3010         item = queue->head;
3011
3012         if (!item) {
3013                 return (NULL);
3014         }
3015
3016         queue->head = item->q_next;
3017         item->q_next = NULL;
3018
3019         if (queue->tail == item)
3020                 queue->tail = NULL;
3021
3022         queue->count--;
3023
3024         return (item);
3025 }
3026
3027 /****************************************************************************/
3028 /*                                                                          */
3029 /* Routine Name: ips_removeq_scb                                            */
3030 /*                                                                          */
3031 /* Routine Description:                                                     */
3032 /*                                                                          */
3033 /*   Remove an item from a queue                                            */
3034 /*                                                                          */
3035 /* ASSUMED to be called from within the HA lock                             */
3036 /*                                                                          */
3037 /****************************************************************************/
3038 static ips_scb_t *
3039 ips_removeq_scb(ips_scb_queue_t * queue, ips_scb_t * item)
3040 {
3041         ips_scb_t *p;
3042
3043         METHOD_TRACE("ips_removeq_scb", 1);
3044
3045         if (!item)
3046                 return (NULL);
3047
3048         if (item == queue->head) {
3049                 return (ips_removeq_scb_head(queue));
3050         }
3051
3052         p = queue->head;
3053
3054         while ((p) && (item != p->q_next))
3055                 p = p->q_next;
3056
3057         if (p) {
3058                 /* found a match */
3059                 p->q_next = item->q_next;
3060
3061                 if (!item->q_next)
3062                         queue->tail = p;
3063
3064                 item->q_next = NULL;
3065                 queue->count--;
3066
3067                 return (item);
3068         }
3069
3070         return (NULL);
3071 }
3072
3073 /****************************************************************************/
3074 /*                                                                          */
3075 /* Routine Name: ips_putq_wait_tail                                         */
3076 /*                                                                          */
3077 /* Routine Description:                                                     */
3078 /*                                                                          */
3079 /*   Add an item to the tail of the queue                                   */
3080 /*                                                                          */
3081 /* ASSUMED to be called from within the HA lock                             */
3082 /*                                                                          */
3083 /****************************************************************************/
3084 static void ips_putq_wait_tail(ips_wait_queue_t *queue, struct scsi_cmnd *item)
3085 {
3086         METHOD_TRACE("ips_putq_wait_tail", 1);
3087
3088         if (!item)
3089                 return;
3090
3091         item->host_scribble = NULL;
3092
3093         if (queue->tail)
3094                 queue->tail->host_scribble = (char *) item;
3095
3096         queue->tail = item;
3097
3098         if (!queue->head)
3099                 queue->head = item;
3100
3101         queue->count++;
3102 }
3103
3104 /****************************************************************************/
3105 /*                                                                          */
3106 /* Routine Name: ips_removeq_wait_head                                      */
3107 /*                                                                          */
3108 /* Routine Description:                                                     */
3109 /*                                                                          */
3110 /*   Remove the head of the queue                                           */
3111 /*                                                                          */
3112 /* ASSUMED to be called from within the HA lock                             */
3113 /*                                                                          */
3114 /****************************************************************************/
3115 static struct scsi_cmnd *ips_removeq_wait_head(ips_wait_queue_t *queue)
3116 {
3117         struct scsi_cmnd *item;
3118
3119         METHOD_TRACE("ips_removeq_wait_head", 1);
3120
3121         item = queue->head;
3122
3123         if (!item) {
3124                 return (NULL);
3125         }
3126
3127         queue->head = (struct scsi_cmnd *) item->host_scribble;
3128         item->host_scribble = NULL;
3129
3130         if (queue->tail == item)
3131                 queue->tail = NULL;
3132
3133         queue->count--;
3134
3135         return (item);
3136 }
3137
3138 /****************************************************************************/
3139 /*                                                                          */
3140 /* Routine Name: ips_removeq_wait                                           */
3141 /*                                                                          */
3142 /* Routine Description:                                                     */
3143 /*                                                                          */
3144 /*   Remove an item from a queue                                            */
3145 /*                                                                          */
3146 /* ASSUMED to be called from within the HA lock                             */
3147 /*                                                                          */
3148 /****************************************************************************/
3149 static struct scsi_cmnd *ips_removeq_wait(ips_wait_queue_t *queue,
3150                                           struct scsi_cmnd *item)
3151 {
3152         struct scsi_cmnd *p;
3153
3154         METHOD_TRACE("ips_removeq_wait", 1);
3155
3156         if (!item)
3157                 return (NULL);
3158
3159         if (item == queue->head) {
3160                 return (ips_removeq_wait_head(queue));
3161         }
3162
3163         p = queue->head;
3164
3165         while ((p) && (item != (struct scsi_cmnd *) p->host_scribble))
3166                 p = (struct scsi_cmnd *) p->host_scribble;
3167
3168         if (p) {
3169                 /* found a match */
3170                 p->host_scribble = item->host_scribble;
3171
3172                 if (!item->host_scribble)
3173                         queue->tail = p;
3174
3175                 item->host_scribble = NULL;
3176                 queue->count--;
3177
3178                 return (item);
3179         }
3180
3181         return (NULL);
3182 }
3183
3184 /****************************************************************************/
3185 /*                                                                          */
3186 /* Routine Name: ips_putq_copp_tail                                         */
3187 /*                                                                          */
3188 /* Routine Description:                                                     */
3189 /*                                                                          */
3190 /*   Add an item to the tail of the queue                                   */
3191 /*                                                                          */
3192 /* ASSUMED to be called from within the HA lock                             */
3193 /*                                                                          */
3194 /****************************************************************************/
3195 static void
3196 ips_putq_copp_tail(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3197 {
3198         METHOD_TRACE("ips_putq_copp_tail", 1);
3199
3200         if (!item)
3201                 return;
3202
3203         item->next = NULL;
3204
3205         if (queue->tail)
3206                 queue->tail->next = item;
3207
3208         queue->tail = item;
3209
3210         if (!queue->head)
3211                 queue->head = item;
3212
3213         queue->count++;
3214 }
3215
3216 /****************************************************************************/
3217 /*                                                                          */
3218 /* Routine Name: ips_removeq_copp_head                                      */
3219 /*                                                                          */
3220 /* Routine Description:                                                     */
3221 /*                                                                          */
3222 /*   Remove the head of the queue                                           */
3223 /*                                                                          */
3224 /* ASSUMED to be called from within the HA lock                             */
3225 /*                                                                          */
3226 /****************************************************************************/
3227 static ips_copp_wait_item_t *
3228 ips_removeq_copp_head(ips_copp_queue_t * queue)
3229 {
3230         ips_copp_wait_item_t *item;
3231
3232         METHOD_TRACE("ips_removeq_copp_head", 1);
3233
3234         item = queue->head;
3235
3236         if (!item) {
3237                 return (NULL);
3238         }
3239
3240         queue->head = item->next;
3241         item->next = NULL;
3242
3243         if (queue->tail == item)
3244                 queue->tail = NULL;
3245
3246         queue->count--;
3247
3248         return (item);
3249 }
3250
3251 /****************************************************************************/
3252 /*                                                                          */
3253 /* Routine Name: ips_removeq_copp                                           */
3254 /*                                                                          */
3255 /* Routine Description:                                                     */
3256 /*                                                                          */
3257 /*   Remove an item from a queue                                            */
3258 /*                                                                          */
3259 /* ASSUMED to be called from within the HA lock                             */
3260 /*                                                                          */
3261 /****************************************************************************/
3262 static ips_copp_wait_item_t *
3263 ips_removeq_copp(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3264 {
3265         ips_copp_wait_item_t *p;
3266
3267         METHOD_TRACE("ips_removeq_copp", 1);
3268
3269         if (!item)
3270                 return (NULL);
3271
3272         if (item == queue->head) {
3273                 return (ips_removeq_copp_head(queue));
3274         }
3275
3276         p = queue->head;
3277
3278         while ((p) && (item != p->next))
3279                 p = p->next;
3280
3281         if (p) {
3282                 /* found a match */
3283                 p->next = item->next;
3284
3285                 if (!item->next)
3286                         queue->tail = p;
3287
3288                 item->next = NULL;
3289                 queue->count--;
3290
3291                 return (item);
3292         }
3293
3294         return (NULL);
3295 }
3296
3297 /****************************************************************************/
3298 /*                                                                          */
3299 /* Routine Name: ipsintr_blocking                                           */
3300 /*                                                                          */
3301 /* Routine Description:                                                     */
3302 /*                                                                          */
3303 /*   Finalize an interrupt for internal commands                            */
3304 /*                                                                          */
3305 /****************************************************************************/
3306 static void
3307 ipsintr_blocking(ips_ha_t * ha, ips_scb_t * scb)
3308 {
3309         METHOD_TRACE("ipsintr_blocking", 2);
3310
3311         ips_freescb(ha, scb);
3312         if ((ha->waitflag == TRUE) && (ha->cmd_in_progress == scb->cdb[0])) {
3313                 ha->waitflag = FALSE;
3314
3315                 return;
3316         }
3317 }
3318
3319 /****************************************************************************/
3320 /*                                                                          */
3321 /* Routine Name: ipsintr_done                                               */
3322 /*                                                                          */
3323 /* Routine Description:                                                     */
3324 /*                                                                          */
3325 /*   Finalize an interrupt for non-internal commands                        */
3326 /*                                                                          */
3327 /****************************************************************************/
3328 static void
3329 ipsintr_done(ips_ha_t * ha, ips_scb_t * scb)
3330 {
3331         METHOD_TRACE("ipsintr_done", 2);
3332
3333         if (!scb) {
3334                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3335                            "Spurious interrupt; scb NULL.\n");
3336
3337                 return;
3338         }
3339
3340         if (scb->scsi_cmd == NULL) {
3341                 /* unexpected interrupt */
3342                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3343                            "Spurious interrupt; scsi_cmd not set.\n");
3344
3345                 return;
3346         }
3347
3348         ips_done(ha, scb);
3349 }
3350
3351 /****************************************************************************/
3352 /*                                                                          */
3353 /* Routine Name: ips_done                                                   */
3354 /*                                                                          */
3355 /* Routine Description:                                                     */
3356 /*                                                                          */
3357 /*   Do housekeeping on completed commands                                  */
3358 /*  ASSUMED to be called form within the request lock                       */
3359 /****************************************************************************/
3360 static void
3361 ips_done(ips_ha_t * ha, ips_scb_t * scb)
3362 {
3363         int ret;
3364
3365         METHOD_TRACE("ips_done", 1);
3366
3367         if (!scb)
3368                 return;
3369
3370         if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd))) {
3371                 ips_cleanup_passthru(ha, scb);
3372                 ha->num_ioctl--;
3373         } else {
3374                 /*
3375                  * Check to see if this command had too much
3376                  * data and had to be broke up.  If so, queue
3377                  * the rest of the data and continue.
3378                  */
3379                 if ((scb->breakup) || (scb->sg_break)) {
3380                         /* we had a data breakup */
3381                         scb->data_len = 0;
3382
3383                         if (scb->sg_count) {
3384                                 /* S/G request */
3385                                 struct scatterlist *sg;
3386                                 int ips_sg_index = 0;
3387                                 int sg_dma_index;
3388
3389                                 sg = scb->scsi_cmd->request_buffer;
3390
3391                                 /* Spin forward to last dma chunk */
3392                                 sg_dma_index = scb->breakup;
3393
3394                                 /* Take care of possible partial on last chunk */
3395                                 ips_fill_scb_sg_single(ha,
3396                                                        sg_dma_address(&sg
3397                                                                       [sg_dma_index]),
3398                                                        scb, ips_sg_index++,
3399                                                        sg_dma_len(&sg
3400                                                                   [sg_dma_index]));
3401
3402                                 for (; sg_dma_index < scb->sg_count;
3403                                      sg_dma_index++) {
3404                                         if (ips_fill_scb_sg_single
3405                                             (ha,
3406                                              sg_dma_address(&sg[sg_dma_index]),
3407                                              scb, ips_sg_index++,
3408                                              sg_dma_len(&sg[sg_dma_index])) < 0)
3409                                                 break;
3410
3411                                 }
3412
3413                         } else {
3414                                 /* Non S/G Request */
3415                                 (void) ips_fill_scb_sg_single(ha,
3416                                                               scb->
3417                                                               data_busaddr +
3418                                                               (scb->sg_break *
3419                                                                ha->max_xfer),
3420                                                               scb, 0,
3421                                                               scb->scsi_cmd->
3422                                                               request_bufflen -
3423                                                               (scb->sg_break *
3424                                                                ha->max_xfer));
3425                         }
3426
3427                         scb->dcdb.transfer_length = scb->data_len;
3428                         scb->dcdb.cmd_attribute |=
3429                             ips_command_direction[scb->scsi_cmd->cmnd[0]];
3430
3431                         if (!(scb->dcdb.cmd_attribute & 0x3))
3432                                 scb->dcdb.transfer_length = 0;
3433
3434                         if (scb->data_len >= IPS_MAX_XFER) {
3435                                 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
3436                                 scb->dcdb.transfer_length = 0;
3437                         }
3438
3439                         ret = ips_send_cmd(ha, scb);
3440
3441                         switch (ret) {
3442                         case IPS_FAILURE:
3443                                 if (scb->scsi_cmd) {
3444                                         scb->scsi_cmd->result = DID_ERROR << 16;
3445                                         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3446                                 }
3447
3448                                 ips_freescb(ha, scb);
3449                                 break;
3450                         case IPS_SUCCESS_IMM:
3451                                 if (scb->scsi_cmd) {
3452                                         scb->scsi_cmd->result = DID_ERROR << 16;
3453                                         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3454                                 }
3455
3456                                 ips_freescb(ha, scb);
3457                                 break;
3458                         default:
3459                                 break;
3460                         }       /* end case */
3461
3462                         return;
3463                 }
3464         }                       /* end if passthru */
3465
3466         if (scb->bus) {
3467                 ha->dcdb_active[scb->bus - 1] &= ~(1 << scb->target_id);
3468         }
3469
3470         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3471
3472         ips_freescb(ha, scb);
3473 }
3474
3475 /****************************************************************************/
3476 /*                                                                          */
3477 /* Routine Name: ips_map_status                                             */
3478 /*                                                                          */
3479 /* Routine Description:                                                     */
3480 /*                                                                          */
3481 /*   Map Controller Error codes to Linux Error Codes                        */
3482 /*                                                                          */
3483 /****************************************************************************/
3484 static int
3485 ips_map_status(ips_ha_t * ha, ips_scb_t * scb, ips_stat_t * sp)
3486 {
3487         int errcode;
3488         int device_error;
3489         uint32_t transfer_len;
3490         IPS_DCDB_TABLE_TAPE *tapeDCDB;
3491         IPS_SCSI_INQ_DATA inquiryData;
3492
3493         METHOD_TRACE("ips_map_status", 1);
3494
3495         if (scb->bus) {
3496                 DEBUG_VAR(2,
3497                           "(%s%d) Physical device error (%d %d %d): %x %x, Sense Key: %x, ASC: %x, ASCQ: %x",
3498                           ips_name, ha->host_num,
3499                           scb->scsi_cmd->device->channel,
3500                           scb->scsi_cmd->device->id, scb->scsi_cmd->device->lun,
3501                           scb->basic_status, scb->extended_status,
3502                           scb->extended_status ==
3503                           IPS_ERR_CKCOND ? scb->dcdb.sense_info[2] & 0xf : 0,
3504                           scb->extended_status ==
3505                           IPS_ERR_CKCOND ? scb->dcdb.sense_info[12] : 0,
3506                           scb->extended_status ==
3507                           IPS_ERR_CKCOND ? scb->dcdb.sense_info[13] : 0);
3508         }
3509
3510         /* default driver error */
3511         errcode = DID_ERROR;
3512         device_error = 0;
3513
3514         switch (scb->basic_status & IPS_GSC_STATUS_MASK) {
3515         case IPS_CMD_TIMEOUT:
3516                 errcode = DID_TIME_OUT;
3517                 break;
3518
3519         case IPS_INVAL_OPCO:
3520         case IPS_INVAL_CMD_BLK:
3521         case IPS_INVAL_PARM_BLK:
3522         case IPS_LD_ERROR:
3523         case IPS_CMD_CMPLT_WERROR:
3524                 break;
3525
3526         case IPS_PHYS_DRV_ERROR:
3527                 switch (scb->extended_status) {
3528                 case IPS_ERR_SEL_TO:
3529                         if (scb->bus)
3530                                 errcode = DID_NO_CONNECT;
3531
3532                         break;
3533
3534                 case IPS_ERR_OU_RUN:
3535                         if ((scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB) ||
3536                             (scb->cmd.dcdb.op_code ==
3537                              IPS_CMD_EXTENDED_DCDB_SG)) {
3538                                 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3539                                 transfer_len = tapeDCDB->transfer_length;
3540                         } else {
3541                                 transfer_len =
3542                                     (uint32_t) scb->dcdb.transfer_length;
3543                         }
3544
3545                         if ((scb->bus) && (transfer_len < scb->data_len)) {
3546                                 /* Underrun - set default to no error */
3547                                 errcode = DID_OK;
3548
3549                                 /* Restrict access to physical DASD */
3550                                 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3551                                     ips_scmd_buf_read(scb->scsi_cmd,
3552                                       &inquiryData, sizeof (inquiryData));
3553                                     if ((inquiryData.DeviceType & 0x1f) == TYPE_DISK) {
3554                                         errcode = DID_TIME_OUT;
3555                                         break;
3556                                     }
3557                                 }
3558                         } else
3559                                 errcode = DID_ERROR;
3560
3561                         break;
3562
3563                 case IPS_ERR_RECOVERY:
3564                         /* don't fail recovered errors */
3565                         if (scb->bus)
3566                                 errcode = DID_OK;
3567
3568                         break;
3569
3570                 case IPS_ERR_HOST_RESET:
3571                 case IPS_ERR_DEV_RESET:
3572                         errcode = DID_RESET;
3573                         break;
3574
3575                 case IPS_ERR_CKCOND:
3576                         if (scb->bus) {
3577                                 if ((scb->cmd.dcdb.op_code ==
3578                                      IPS_CMD_EXTENDED_DCDB)
3579                                     || (scb->cmd.dcdb.op_code ==
3580                                         IPS_CMD_EXTENDED_DCDB_SG)) {
3581                                         tapeDCDB =
3582                                             (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3583                                         memcpy(scb->scsi_cmd->sense_buffer,
3584                                                tapeDCDB->sense_info,
3585                                                sizeof (scb->scsi_cmd->
3586                                                        sense_buffer));
3587                                 } else {
3588                                         memcpy(scb->scsi_cmd->sense_buffer,
3589                                                scb->dcdb.sense_info,
3590                                                sizeof (scb->scsi_cmd->
3591                                                        sense_buffer));
3592                                 }
3593                                 device_error = 2;       /* check condition */
3594                         }
3595
3596                         errcode = DID_OK;
3597
3598                         break;
3599
3600                 default:
3601                         errcode = DID_ERROR;
3602                         break;
3603
3604                 }               /* end switch */
3605         }                       /* end switch */
3606
3607         scb->scsi_cmd->result = device_error | (errcode << 16);
3608
3609         return (1);
3610 }
3611
3612 /****************************************************************************/
3613 /*                                                                          */
3614 /* Routine Name: ips_send_wait                                              */
3615 /*                                                                          */
3616 /* Routine Description:                                                     */
3617 /*                                                                          */
3618 /*   Send a command to the controller and wait for it to return             */
3619 /*                                                                          */
3620 /*   The FFDC Time Stamp use this function for the callback, but doesn't    */
3621 /*   actually need to wait.                                                 */
3622 /****************************************************************************/
3623 static int
3624 ips_send_wait(ips_ha_t * ha, ips_scb_t * scb, int timeout, int intr)
3625 {
3626         int ret;
3627
3628         METHOD_TRACE("ips_send_wait", 1);
3629
3630         if (intr != IPS_FFDC) { /* Won't be Waiting if this is a Time Stamp */
3631                 ha->waitflag = TRUE;
3632                 ha->cmd_in_progress = scb->cdb[0];
3633         }
3634         scb->callback = ipsintr_blocking;
3635         ret = ips_send_cmd(ha, scb);
3636
3637         if ((ret == IPS_FAILURE) || (ret == IPS_SUCCESS_IMM))
3638                 return (ret);
3639
3640         if (intr != IPS_FFDC)   /* Don't Wait around if this is a Time Stamp */
3641                 ret = ips_wait(ha, timeout, intr);
3642
3643         return (ret);
3644 }
3645
3646 /****************************************************************************/
3647 /*                                                                          */
3648 /* Routine Name: ips_scmd_buf_write                                         */
3649 /*                                                                          */
3650 /* Routine Description:                                                     */
3651 /*  Write data to struct scsi_cmnd request_buffer at proper offsets         */
3652 /****************************************************************************/
3653 static void
3654 ips_scmd_buf_write(struct scsi_cmnd *scmd, void *data, unsigned int count)
3655 {
3656         if (scmd->use_sg) {
3657                 int i;
3658                 unsigned int min_cnt, xfer_cnt;
3659                 char *cdata = (char *) data;
3660                 unsigned char *buffer;
3661                 unsigned long flags;
3662                 struct scatterlist *sg = scmd->request_buffer;
3663                 for (i = 0, xfer_cnt = 0;
3664                      (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3665                         min_cnt = min(count - xfer_cnt, sg[i].length);
3666
3667                         /* kmap_atomic() ensures addressability of the data buffer.*/
3668                         /* local_irq_save() protects the KM_IRQ0 address slot.     */
3669                         local_irq_save(flags);
3670                         buffer = kmap_atomic(sg[i].page, KM_IRQ0) + sg[i].offset;
3671                         memcpy(buffer, &cdata[xfer_cnt], min_cnt);
3672                         kunmap_atomic(buffer - sg[i].offset, KM_IRQ0);
3673                         local_irq_restore(flags);
3674
3675                         xfer_cnt += min_cnt;
3676                 }
3677
3678         } else {
3679                 unsigned int min_cnt = min(count, scmd->request_bufflen);
3680                 memcpy(scmd->request_buffer, data, min_cnt);
3681         }
3682 }
3683
3684 /****************************************************************************/
3685 /*                                                                          */
3686 /* Routine Name: ips_scmd_buf_read                                          */
3687 /*                                                                          */
3688 /* Routine Description:                                                     */
3689 /*  Copy data from a struct scsi_cmnd to a new, linear buffer               */
3690 /****************************************************************************/
3691 static void
3692 ips_scmd_buf_read(struct scsi_cmnd *scmd, void *data, unsigned int count)
3693 {
3694         if (scmd->use_sg) {
3695                 int i;
3696                 unsigned int min_cnt, xfer_cnt;
3697                 char *cdata = (char *) data;
3698                 unsigned char *buffer;
3699                 unsigned long flags;
3700                 struct scatterlist *sg = scmd->request_buffer;
3701                 for (i = 0, xfer_cnt = 0;
3702                      (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3703                         min_cnt = min(count - xfer_cnt, sg[i].length);
3704
3705                         /* kmap_atomic() ensures addressability of the data buffer.*/
3706                         /* local_irq_save() protects the KM_IRQ0 address slot.     */
3707                         local_irq_save(flags);
3708                         buffer = kmap_atomic(sg[i].page, KM_IRQ0) + sg[i].offset;
3709                         memcpy(&cdata[xfer_cnt], buffer, min_cnt);
3710                         kunmap_atomic(buffer - sg[i].offset, KM_IRQ0);
3711                         local_irq_restore(flags);
3712
3713                         xfer_cnt += min_cnt;
3714                 }
3715
3716         } else {
3717                 unsigned int min_cnt = min(count, scmd->request_bufflen);
3718                 memcpy(data, scmd->request_buffer, min_cnt);
3719         }
3720 }
3721
3722 /****************************************************************************/
3723 /*                                                                          */
3724 /* Routine Name: ips_send_cmd                                               */
3725 /*                                                                          */
3726 /* Routine Description:                                                     */
3727 /*                                                                          */
3728 /*   Map SCSI commands to ServeRAID commands for logical drives             */
3729 /*                                                                          */
3730 /****************************************************************************/
3731 static int
3732 ips_send_cmd(ips_ha_t * ha, ips_scb_t * scb)
3733 {
3734         int ret;
3735         char *sp;
3736         int device_error;
3737         IPS_DCDB_TABLE_TAPE *tapeDCDB;
3738         int TimeOut;
3739
3740         METHOD_TRACE("ips_send_cmd", 1);
3741
3742         ret = IPS_SUCCESS;
3743
3744         if (!scb->scsi_cmd) {
3745                 /* internal command */
3746
3747                 if (scb->bus > 0) {
3748                         /* Controller commands can't be issued */
3749                         /* to real devices -- fail them        */
3750                         if ((ha->waitflag == TRUE) &&
3751                             (ha->cmd_in_progress == scb->cdb[0])) {
3752                                 ha->waitflag = FALSE;
3753                         }
3754
3755                         return (1);
3756                 }
3757         } else if ((scb->bus == 0) && (!ips_is_passthru(scb->scsi_cmd))) {
3758                 /* command to logical bus -- interpret */
3759                 ret = IPS_SUCCESS_IMM;
3760
3761                 switch (scb->scsi_cmd->cmnd[0]) {
3762                 case ALLOW_MEDIUM_REMOVAL:
3763                 case REZERO_UNIT:
3764                 case ERASE:
3765                 case WRITE_FILEMARKS:
3766                 case SPACE:
3767                         scb->scsi_cmd->result = DID_ERROR << 16;
3768                         break;
3769
3770                 case START_STOP:
3771                         scb->scsi_cmd->result = DID_OK << 16;
3772
3773                 case TEST_UNIT_READY:
3774                 case INQUIRY:
3775                         if (scb->target_id == IPS_ADAPTER_ID) {
3776                                 /*
3777                                  * Either we have a TUR
3778                                  * or we have a SCSI inquiry
3779                                  */
3780                                 if (scb->scsi_cmd->cmnd[0] == TEST_UNIT_READY)
3781                                         scb->scsi_cmd->result = DID_OK << 16;
3782
3783                                 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3784                                         IPS_SCSI_INQ_DATA inquiry;
3785
3786                                         memset(&inquiry, 0,
3787                                                sizeof (IPS_SCSI_INQ_DATA));
3788
3789                                         inquiry.DeviceType =
3790                                             IPS_SCSI_INQ_TYPE_PROCESSOR;
3791                                         inquiry.DeviceTypeQualifier =
3792                                             IPS_SCSI_INQ_LU_CONNECTED;
3793                                         inquiry.Version = IPS_SCSI_INQ_REV2;
3794                                         inquiry.ResponseDataFormat =
3795                                             IPS_SCSI_INQ_RD_REV2;
3796                                         inquiry.AdditionalLength = 31;
3797                                         inquiry.Flags[0] =
3798                                             IPS_SCSI_INQ_Address16;
3799                                         inquiry.Flags[1] =
3800                                             IPS_SCSI_INQ_WBus16 |
3801                                             IPS_SCSI_INQ_Sync;
3802                                         strncpy(inquiry.VendorId, "IBM     ",
3803                                                 8);
3804                                         strncpy(inquiry.ProductId,
3805                                                 "SERVERAID       ", 16);
3806                                         strncpy(inquiry.ProductRevisionLevel,
3807                                                 "1.00", 4);
3808
3809                                         ips_scmd_buf_write(scb->scsi_cmd,
3810                                                            &inquiry,
3811                                                            sizeof (inquiry));
3812
3813                                         scb->scsi_cmd->result = DID_OK << 16;
3814                                 }
3815                         } else {
3816                                 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3817                                 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3818                                 scb->cmd.logical_info.reserved = 0;
3819                                 scb->cmd.logical_info.reserved2 = 0;
3820                                 scb->data_len = sizeof (IPS_LD_INFO);
3821                                 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3822                                 scb->flags = 0;
3823                                 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3824                                 ret = IPS_SUCCESS;
3825                         }
3826
3827                         break;
3828
3829                 case REQUEST_SENSE:
3830                         ips_reqsen(ha, scb);
3831                         scb->scsi_cmd->result = DID_OK << 16;
3832                         break;
3833
3834                 case READ_6:
3835                 case WRITE_6:
3836                         if (!scb->sg_len) {
3837                                 scb->cmd.basic_io.op_code =
3838                                     (scb->scsi_cmd->cmnd[0] ==
3839                                      READ_6) ? IPS_CMD_READ : IPS_CMD_WRITE;
3840                                 scb->cmd.basic_io.enhanced_sg = 0;
3841                                 scb->cmd.basic_io.sg_addr =
3842                                     cpu_to_le32(scb->data_busaddr);
3843                         } else {
3844                                 scb->cmd.basic_io.op_code =
3845                                     (scb->scsi_cmd->cmnd[0] ==
3846                                      READ_6) ? IPS_CMD_READ_SG :
3847                                     IPS_CMD_WRITE_SG;
3848                                 scb->cmd.basic_io.enhanced_sg =
3849                                     IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3850                                 scb->cmd.basic_io.sg_addr =
3851                                     cpu_to_le32(scb->sg_busaddr);
3852                         }
3853
3854                         scb->cmd.basic_io.segment_4G = 0;
3855                         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3856                         scb->cmd.basic_io.log_drv = scb->target_id;
3857                         scb->cmd.basic_io.sg_count = scb->sg_len;
3858
3859                         if (scb->cmd.basic_io.lba)
3860                                 scb->cmd.basic_io.lba =
3861                                     cpu_to_le32(le32_to_cpu
3862                                                 (scb->cmd.basic_io.lba) +
3863                                                 le16_to_cpu(scb->cmd.basic_io.
3864                                                             sector_count));
3865                         else
3866                                 scb->cmd.basic_io.lba =
3867                                     (((scb->scsi_cmd->
3868                                        cmnd[1] & 0x1f) << 16) | (scb->scsi_cmd->
3869                                                                  cmnd[2] << 8) |
3870                                      (scb->scsi_cmd->cmnd[3]));
3871
3872                         scb->cmd.basic_io.sector_count =
3873                             cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3874
3875                         if (le16_to_cpu(scb->cmd.basic_io.sector_count) == 0)
3876                                 scb->cmd.basic_io.sector_count =
3877                                     cpu_to_le16(256);
3878
3879                         ret = IPS_SUCCESS;
3880                         break;
3881
3882                 case READ_10:
3883                 case WRITE_10:
3884                         if (!scb->sg_len) {
3885                                 scb->cmd.basic_io.op_code =
3886                                     (scb->scsi_cmd->cmnd[0] ==
3887                                      READ_10) ? IPS_CMD_READ : IPS_CMD_WRITE;
3888                                 scb->cmd.basic_io.enhanced_sg = 0;
3889                                 scb->cmd.basic_io.sg_addr =
3890                                     cpu_to_le32(scb->data_busaddr);
3891                         } else {
3892                                 scb->cmd.basic_io.op_code =
3893                                     (scb->scsi_cmd->cmnd[0] ==
3894                                      READ_10) ? IPS_CMD_READ_SG :
3895                                     IPS_CMD_WRITE_SG;
3896                                 scb->cmd.basic_io.enhanced_sg =
3897                                     IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3898                                 scb->cmd.basic_io.sg_addr =
3899                                     cpu_to_le32(scb->sg_busaddr);
3900                         }
3901
3902                         scb->cmd.basic_io.segment_4G = 0;
3903                         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3904                         scb->cmd.basic_io.log_drv = scb->target_id;
3905                         scb->cmd.basic_io.sg_count = scb->sg_len;
3906
3907                         if (scb->cmd.basic_io.lba)
3908                                 scb->cmd.basic_io.lba =
3909                                     cpu_to_le32(le32_to_cpu
3910                                                 (scb->cmd.basic_io.lba) +
3911                                                 le16_to_cpu(scb->cmd.basic_io.
3912                                                             sector_count));
3913                         else
3914                                 scb->cmd.basic_io.lba =
3915                                     ((scb->scsi_cmd->cmnd[2] << 24) | (scb->
3916                                                                        scsi_cmd->
3917                                                                        cmnd[3]
3918                                                                        << 16) |
3919                                      (scb->scsi_cmd->cmnd[4] << 8) | scb->
3920                                      scsi_cmd->cmnd[5]);
3921
3922                         scb->cmd.basic_io.sector_count =
3923                             cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3924
3925                         if (cpu_to_le16(scb->cmd.basic_io.sector_count) == 0) {
3926                                 /*
3927                                  * This is a null condition
3928                                  * we don't have to do anything
3929                                  * so just return
3930                                  */
3931                                 scb->scsi_cmd->result = DID_OK << 16;
3932                         } else
3933                                 ret = IPS_SUCCESS;
3934
3935                         break;
3936
3937                 case RESERVE:
3938                 case RELEASE:
3939                         scb->scsi_cmd->result = DID_OK << 16;
3940                         break;
3941
3942                 case MODE_SENSE:
3943                         scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
3944                         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3945                         scb->cmd.basic_io.segment_4G = 0;
3946                         scb->cmd.basic_io.enhanced_sg = 0;
3947                         scb->data_len = sizeof (*ha->enq);
3948                         scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
3949                         ret = IPS_SUCCESS;
3950                         break;
3951
3952                 case READ_CAPACITY:
3953                         scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3954                         scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3955                         scb->cmd.logical_info.reserved = 0;
3956                         scb->cmd.logical_info.reserved2 = 0;
3957                         scb->cmd.logical_info.reserved3 = 0;
3958                         scb->data_len = sizeof (IPS_LD_INFO);
3959                         scb->data_busaddr = ha->logical_drive_info_dma_addr;
3960                         scb->flags = 0;
3961                         scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3962                         ret = IPS_SUCCESS;
3963                         break;
3964
3965                 case SEND_DIAGNOSTIC:
3966                 case REASSIGN_BLOCKS:
3967                 case FORMAT_UNIT:
3968                 case SEEK_10:
3969                 case VERIFY:
3970                 case READ_DEFECT_DATA:
3971                 case READ_BUFFER:
3972                 case WRITE_BUFFER:
3973                         scb->scsi_cmd->result = DID_OK << 16;
3974                         break;
3975
3976                 default:
3977                         /* Set the Return Info to appear like the Command was */
3978                         /* attempted, a Check Condition occurred, and Sense   */
3979                         /* Data indicating an Invalid CDB OpCode is returned. */
3980                         sp = (char *) scb->scsi_cmd->sense_buffer;
3981                         memset(sp, 0, sizeof (scb->scsi_cmd->sense_buffer));
3982
3983                         sp[0] = 0x70;   /* Error Code               */
3984                         sp[2] = ILLEGAL_REQUEST;        /* Sense Key 5 Illegal Req. */
3985                         sp[7] = 0x0A;   /* Additional Sense Length  */
3986                         sp[12] = 0x20;  /* ASC = Invalid OpCode     */
3987                         sp[13] = 0x00;  /* ASCQ                     */
3988
3989                         device_error = 2;       /* Indicate Check Condition */
3990                         scb->scsi_cmd->result = device_error | (DID_OK << 16);
3991                         break;
3992                 }               /* end switch */
3993         }
3994         /* end if */
3995         if (ret == IPS_SUCCESS_IMM)
3996                 return (ret);
3997
3998         /* setup DCDB */
3999         if (scb->bus > 0) {
4000
4001                 /* If we already know the Device is Not there, no need to attempt a Command   */
4002                 /* This also protects an NT FailOver Controller from getting CDB's sent to it */
4003                 if (ha->conf->dev[scb->bus - 1][scb->target_id].ucState == 0) {
4004                         scb->scsi_cmd->result = DID_NO_CONNECT << 16;
4005                         return (IPS_SUCCESS_IMM);
4006                 }
4007
4008                 ha->dcdb_active[scb->bus - 1] |= (1 << scb->target_id);
4009                 scb->cmd.dcdb.command_id = IPS_COMMAND_ID(ha, scb);
4010                 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
4011                                                          (unsigned long) &scb->
4012                                                          dcdb -
4013                                                          (unsigned long) scb);
4014                 scb->cmd.dcdb.reserved = 0;
4015                 scb->cmd.dcdb.reserved2 = 0;
4016                 scb->cmd.dcdb.reserved3 = 0;
4017                 scb->cmd.dcdb.segment_4G = 0;
4018                 scb->cmd.dcdb.enhanced_sg = 0;
4019
4020                 TimeOut = scb->scsi_cmd->timeout_per_command;
4021
4022                 if (ha->subsys->param[4] & 0x00100000) {        /* If NEW Tape DCDB is Supported */
4023                         if (!scb->sg_len) {
4024                                 scb->cmd.dcdb.op_code = IPS_CMD_EXTENDED_DCDB;
4025                         } else {
4026                                 scb->cmd.dcdb.op_code =
4027                                     IPS_CMD_EXTENDED_DCDB_SG;
4028                                 scb->cmd.dcdb.enhanced_sg =
4029                                     IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
4030                         }
4031
4032                         tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb; /* Use Same Data Area as Old DCDB Struct */
4033                         tapeDCDB->device_address =
4034                             ((scb->bus - 1) << 4) | scb->target_id;
4035                         tapeDCDB->cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4036                         tapeDCDB->cmd_attribute &= ~IPS_TRANSFER64K;    /* Always Turn OFF 64K Size Flag */
4037
4038                         if (TimeOut) {
4039                                 if (TimeOut < (10 * HZ))
4040                                         tapeDCDB->cmd_attribute |= IPS_TIMEOUT10;       /* TimeOut is 10 Seconds */
4041                                 else if (TimeOut < (60 * HZ))
4042                                         tapeDCDB->cmd_attribute |= IPS_TIMEOUT60;       /* TimeOut is 60 Seconds */
4043                                 else if (TimeOut < (1200 * HZ))
4044                                         tapeDCDB->cmd_attribute |= IPS_TIMEOUT20M;      /* TimeOut is 20 Minutes */
4045                         }
4046
4047                         tapeDCDB->cdb_length = scb->scsi_cmd->cmd_len;
4048                         tapeDCDB->reserved_for_LUN = 0;
4049                         tapeDCDB->transfer_length = scb->data_len;
4050                         if (scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB_SG)
4051                                 tapeDCDB->buffer_pointer =
4052                                     cpu_to_le32(scb->sg_busaddr);
4053                         else
4054                                 tapeDCDB->buffer_pointer =
4055                                     cpu_to_le32(scb->data_busaddr);
4056                         tapeDCDB->sg_count = scb->sg_len;
4057                         tapeDCDB->sense_length = sizeof (tapeDCDB->sense_info);
4058                         tapeDCDB->scsi_status = 0;
4059                         tapeDCDB->reserved = 0;
4060                         memcpy(tapeDCDB->scsi_cdb, scb->scsi_cmd->cmnd,
4061                                scb->scsi_cmd->cmd_len);
4062                 } else {
4063                         if (!scb->sg_len) {
4064                                 scb->cmd.dcdb.op_code = IPS_CMD_DCDB;
4065                         } else {
4066                                 scb->cmd.dcdb.op_code = IPS_CMD_DCDB_SG;
4067                                 scb->cmd.dcdb.enhanced_sg =
4068                                     IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
4069                         }
4070
4071                         scb->dcdb.device_address =
4072                             ((scb->bus - 1) << 4) | scb->target_id;
4073                         scb->dcdb.cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4074
4075                         if (TimeOut) {
4076                                 if (TimeOut < (10 * HZ))
4077                                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;       /* TimeOut is 10 Seconds */
4078                                 else if (TimeOut < (60 * HZ))
4079                                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;       /* TimeOut is 60 Seconds */
4080                                 else if (TimeOut < (1200 * HZ))
4081                                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;      /* TimeOut is 20 Minutes */
4082                         }
4083
4084                         scb->dcdb.transfer_length = scb->data_len;
4085                         if (scb->dcdb.cmd_attribute & IPS_TRANSFER64K)
4086                                 scb->dcdb.transfer_length = 0;
4087                         if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB_SG)
4088                                 scb->dcdb.buffer_pointer =
4089                                     cpu_to_le32(scb->sg_busaddr);
4090                         else
4091                                 scb->dcdb.buffer_pointer =
4092                                     cpu_to_le32(scb->data_busaddr);
4093                         scb->dcdb.cdb_length = scb->scsi_cmd->cmd_len;
4094                         scb->dcdb.sense_length = sizeof (scb->dcdb.sense_info);
4095                         scb->dcdb.sg_count = scb->sg_len;
4096                         scb->dcdb.reserved = 0;
4097                         memcpy(scb->dcdb.scsi_cdb, scb->scsi_cmd->cmnd,
4098                                scb->scsi_cmd->cmd_len);
4099                         scb->dcdb.scsi_status = 0;
4100                         scb->dcdb.reserved2[0] = 0;
4101                         scb->dcdb.reserved2[1] = 0;
4102                         scb->dcdb.reserved2[2] = 0;
4103                 }
4104         }
4105
4106         return ((*ha->func.issue) (ha, scb));
4107 }
4108
4109 /****************************************************************************/
4110 /*                                                                          */
4111 /* Routine Name: ips_chk_status                                             */
4112 /*                                                                          */
4113 /* Routine Description:                                                     */
4114 /*                                                                          */
4115 /*   Check the status of commands to logical drives                         */
4116 /*   Assumed to be called with the HA lock                                  */
4117 /****************************************************************************/
4118 static void
4119 ips_chkstatus(ips_ha_t * ha, IPS_STATUS * pstatus)
4120 {
4121         ips_scb_t *scb;
4122         ips_stat_t *sp;
4123         uint8_t basic_status;
4124         uint8_t ext_status;
4125         int errcode;
4126         IPS_SCSI_INQ_DATA inquiryData;
4127
4128         METHOD_TRACE("ips_chkstatus", 1);
4129
4130         scb = &ha->scbs[pstatus->fields.command_id];
4131         scb->basic_status = basic_status =
4132             pstatus->fields.basic_status & IPS_BASIC_STATUS_MASK;
4133         scb->extended_status = ext_status = pstatus->fields.extended_status;
4134
4135         sp = &ha->sp;
4136         sp->residue_len = 0;
4137         sp->scb_addr = (void *) scb;
4138
4139         /* Remove the item from the active queue */
4140         ips_removeq_scb(&ha->scb_activelist, scb);
4141
4142         if (!scb->scsi_cmd)
4143                 /* internal commands are handled in do_ipsintr */
4144                 return;
4145
4146         DEBUG_VAR(2, "(%s%d) ips_chkstatus: cmd 0x%X id %d (%d %d %d)",
4147                   ips_name,
4148                   ha->host_num,
4149                   scb->cdb[0],
4150                   scb->cmd.basic_io.command_id,
4151                   scb->bus, scb->target_id, scb->lun);
4152
4153         if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd)))
4154                 /* passthru - just returns the raw result */
4155                 return;
4156
4157         errcode = DID_OK;
4158
4159         if (((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_SUCCESS) ||
4160             ((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_RECOVERED_ERROR)) {
4161
4162                 if (scb->bus == 0) {
4163                         if ((basic_status & IPS_GSC_STATUS_MASK) ==
4164                             IPS_CMD_RECOVERED_ERROR) {
4165                                 DEBUG_VAR(1,
4166                                           "(%s%d) Recovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4167                                           ips_name, ha->host_num,
4168                                           scb->cmd.basic_io.op_code,
4169                                           basic_status, ext_status);
4170                         }
4171
4172                         switch (scb->scsi_cmd->cmnd[0]) {
4173                         case ALLOW_MEDIUM_REMOVAL:
4174                         case REZERO_UNIT:
4175                         case ERASE:
4176                         case WRITE_FILEMARKS:
4177                         case SPACE:
4178                                 errcode = DID_ERROR;
4179                                 break;
4180
4181                         case START_STOP:
4182                                 break;
4183
4184                         case TEST_UNIT_READY:
4185                                 if (!ips_online(ha, scb)) {
4186                                         errcode = DID_TIME_OUT;
4187                                 }
4188                                 break;
4189
4190                         case INQUIRY:
4191                                 if (ips_online(ha, scb)) {
4192                                         ips_inquiry(ha, scb);
4193                                 } else {
4194                                         errcode = DID_TIME_OUT;
4195                                 }
4196                                 break;
4197
4198                         case REQUEST_SENSE:
4199                                 ips_reqsen(ha, scb);
4200                                 break;
4201
4202                         case READ_6:
4203                         case WRITE_6:
4204                         case READ_10:
4205                         case WRITE_10:
4206                         case RESERVE:
4207                         case RELEASE:
4208                                 break;
4209
4210                         case MODE_SENSE:
4211                                 if (!ips_online(ha, scb)
4212                                     || !ips_msense(ha, scb)) {
4213                                         errcode = DID_ERROR;
4214                                 }
4215                                 break;
4216
4217                         case READ_CAPACITY:
4218                                 if (ips_online(ha, scb))
4219                                         ips_rdcap(ha, scb);
4220                                 else {
4221                                         errcode = DID_TIME_OUT;
4222                                 }
4223                                 break;
4224
4225                         case SEND_DIAGNOSTIC:
4226                         case REASSIGN_BLOCKS:
4227                                 break;
4228
4229                         case FORMAT_UNIT:
4230                                 errcode = DID_ERROR;
4231                                 break;
4232
4233                         case SEEK_10:
4234                         case VERIFY:
4235                         case READ_DEFECT_DATA:
4236                         case READ_BUFFER:
4237                         case WRITE_BUFFER:
4238                                 break;
4239
4240                         default:
4241                                 errcode = DID_ERROR;
4242                         }       /* end switch */
4243
4244                         scb->scsi_cmd->result = errcode << 16;
4245                 } else {        /* bus == 0 */
4246                         /* restrict access to physical drives */
4247                         if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
4248                             ips_scmd_buf_read(scb->scsi_cmd,
4249                                   &inquiryData, sizeof (inquiryData));
4250                             if ((inquiryData.DeviceType & 0x1f) == TYPE_DISK)
4251                                 scb->scsi_cmd->result = DID_TIME_OUT << 16;
4252                         }
4253                 }               /* else */
4254         } else {                /* recovered error / success */
4255                 if (scb->bus == 0) {
4256                         DEBUG_VAR(1,
4257                                   "(%s%d) Unrecovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4258                                   ips_name, ha->host_num,
4259                                   scb->cmd.basic_io.op_code, basic_status,
4260                                   ext_status);
4261                 }
4262
4263                 ips_map_status(ha, scb, sp);
4264         }                       /* else */
4265 }
4266
4267 /****************************************************************************/
4268 /*                                                                          */
4269 /* Routine Name: ips_online                                                 */
4270 /*                                                                          */
4271 /* Routine Description:                                                     */
4272 /*                                                                          */
4273 /*   Determine if a logical drive is online                                 */
4274 /*                                                                          */
4275 /****************************************************************************/
4276 static int
4277 ips_online(ips_ha_t * ha, ips_scb_t * scb)
4278 {
4279         METHOD_TRACE("ips_online", 1);
4280
4281         if (scb->target_id >= IPS_MAX_LD)
4282                 return (0);
4283
4284         if ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1) {
4285                 memset(ha->logical_drive_info, 0, sizeof (IPS_LD_INFO));
4286                 return (0);
4287         }
4288
4289         if (ha->logical_drive_info->drive_info[scb->target_id].state !=
4290             IPS_LD_OFFLINE
4291             && ha->logical_drive_info->drive_info[scb->target_id].state !=
4292             IPS_LD_FREE
4293             && ha->logical_drive_info->drive_info[scb->target_id].state !=
4294             IPS_LD_CRS
4295             && ha->logical_drive_info->drive_info[scb->target_id].state !=
4296             IPS_LD_SYS)
4297                 return (1);
4298         else
4299                 return (0);
4300 }
4301
4302 /****************************************************************************/
4303 /*                                                                          */
4304 /* Routine Name: ips_inquiry                                                */
4305 /*                                                                          */
4306 /* Routine Description:                                                     */
4307 /*                                                                          */
4308 /*   Simulate an inquiry command to a logical drive                         */
4309 /*                                                                          */
4310 /****************************************************************************/
4311 static int
4312 ips_inquiry(ips_ha_t * ha, ips_scb_t * scb)
4313 {
4314         IPS_SCSI_INQ_DATA inquiry;
4315
4316         METHOD_TRACE("ips_inquiry", 1);
4317
4318         memset(&inquiry, 0, sizeof (IPS_SCSI_INQ_DATA));
4319
4320         inquiry.DeviceType = IPS_SCSI_INQ_TYPE_DASD;
4321         inquiry.DeviceTypeQualifier = IPS_SCSI_INQ_LU_CONNECTED;
4322         inquiry.Version = IPS_SCSI_INQ_REV2;
4323         inquiry.ResponseDataFormat = IPS_SCSI_INQ_RD_REV2;
4324         inquiry.AdditionalLength = 31;
4325         inquiry.Flags[0] = IPS_SCSI_INQ_Address16;
4326         inquiry.Flags[1] =
4327             IPS_SCSI_INQ_WBus16 | IPS_SCSI_INQ_Sync | IPS_SCSI_INQ_CmdQue;
4328         strncpy(inquiry.VendorId, "IBM     ", 8);
4329         strncpy(inquiry.ProductId, "SERVERAID       ", 16);
4330         strncpy(inquiry.ProductRevisionLevel, "1.00", 4);
4331
4332         ips_scmd_buf_write(scb->scsi_cmd, &inquiry, sizeof (inquiry));
4333
4334         return (1);
4335 }
4336
4337 /****************************************************************************/
4338 /*                                                                          */
4339 /* Routine Name: ips_rdcap                                                  */
4340 /*                                                                          */
4341 /* Routine Description:                                                     */
4342 /*                                                                          */
4343 /*   Simulate a read capacity command to a logical drive                    */
4344 /*                                                                          */
4345 /****************************************************************************/
4346 static int
4347 ips_rdcap(ips_ha_t * ha, ips_scb_t * scb)
4348 {
4349         IPS_SCSI_CAPACITY cap;
4350
4351         METHOD_TRACE("ips_rdcap", 1);
4352
4353         if (scb->scsi_cmd->request_bufflen < 8)
4354                 return (0);
4355
4356         cap.lba =
4357             cpu_to_be32(le32_to_cpu
4358                         (ha->logical_drive_info->
4359                          drive_info[scb->target_id].sector_count) - 1);
4360         cap.len = cpu_to_be32((uint32_t) IPS_BLKSIZE);
4361
4362         ips_scmd_buf_write(scb->scsi_cmd, &cap, sizeof (cap));
4363
4364         return (1);
4365 }
4366
4367 /****************************************************************************/
4368 /*                                                                          */
4369 /* Routine Name: ips_msense                                                 */
4370 /*                                                                          */
4371 /* Routine Description:                                                     */
4372 /*                                                                          */
4373 /*   Simulate a mode sense command to a logical drive                       */
4374 /*                                                                          */
4375 /****************************************************************************/
4376 static int
4377 ips_msense(ips_ha_t * ha, ips_scb_t * scb)
4378 {
4379         uint16_t heads;
4380         uint16_t sectors;
4381         uint32_t cylinders;
4382         IPS_SCSI_MODE_PAGE_DATA mdata;
4383
4384         METHOD_TRACE("ips_msense", 1);
4385
4386         if (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) > 0x400000 &&
4387             (ha->enq->ucMiscFlag & 0x8) == 0) {
4388                 heads = IPS_NORM_HEADS;
4389                 sectors = IPS_NORM_SECTORS;
4390         } else {
4391                 heads = IPS_COMP_HEADS;
4392                 sectors = IPS_COMP_SECTORS;
4393         }
4394
4395         cylinders =
4396             (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) -
4397              1) / (heads * sectors);
4398
4399         memset(&mdata, 0, sizeof (IPS_SCSI_MODE_PAGE_DATA));
4400
4401         mdata.hdr.BlockDescLength = 8;
4402
4403         switch (scb->scsi_cmd->cmnd[2] & 0x3f) {
4404         case 0x03:              /* page 3 */
4405                 mdata.pdata.pg3.PageCode = 3;
4406                 mdata.pdata.pg3.PageLength = sizeof (IPS_SCSI_MODE_PAGE3);
4407                 mdata.hdr.DataLength =
4408                     3 + mdata.hdr.BlockDescLength + mdata.pdata.pg3.PageLength;
4409                 mdata.pdata.pg3.TracksPerZone = 0;
4410                 mdata.pdata.pg3.AltSectorsPerZone = 0;
4411                 mdata.pdata.pg3.AltTracksPerZone = 0;
4412                 mdata.pdata.pg3.AltTracksPerVolume = 0;
4413                 mdata.pdata.pg3.SectorsPerTrack = cpu_to_be16(sectors);
4414                 mdata.pdata.pg3.BytesPerSector = cpu_to_be16(IPS_BLKSIZE);
4415                 mdata.pdata.pg3.Interleave = cpu_to_be16(1);
4416                 mdata.pdata.pg3.TrackSkew = 0;
4417                 mdata.pdata.pg3.CylinderSkew = 0;
4418                 mdata.pdata.pg3.flags = IPS_SCSI_MP3_SoftSector;
4419                 break;
4420
4421         case 0x4:
4422                 mdata.pdata.pg4.PageCode = 4;
4423                 mdata.pdata.pg4.PageLength = sizeof (IPS_SCSI_MODE_PAGE4);
4424                 mdata.hdr.DataLength =
4425                     3 + mdata.hdr.BlockDescLength + mdata.pdata.pg4.PageLength;
4426                 mdata.pdata.pg4.CylindersHigh =
4427                     cpu_to_be16((cylinders >> 8) & 0xFFFF);
4428                 mdata.pdata.pg4.CylindersLow = (cylinders & 0xFF);
4429                 mdata.pdata.pg4.Heads = heads;
4430                 mdata.pdata.pg4.WritePrecompHigh = 0;
4431                 mdata.pdata.pg4.WritePrecompLow = 0;
4432                 mdata.pdata.pg4.ReducedWriteCurrentHigh = 0;
4433                 mdata.pdata.pg4.ReducedWriteCurrentLow = 0;
4434                 mdata.pdata.pg4.StepRate = cpu_to_be16(1);
4435                 mdata.pdata.pg4.LandingZoneHigh = 0;
4436                 mdata.pdata.pg4.LandingZoneLow = 0;
4437                 mdata.pdata.pg4.flags = 0;
4438                 mdata.pdata.pg4.RotationalOffset = 0;
4439                 mdata.pdata.pg4.MediumRotationRate = 0;
4440                 break;
4441         case 0x8:
4442                 mdata.pdata.pg8.PageCode = 8;
4443                 mdata.pdata.pg8.PageLength = sizeof (IPS_SCSI_MODE_PAGE8);
4444                 mdata.hdr.DataLength =
4445                     3 + mdata.hdr.BlockDescLength + mdata.pdata.pg8.PageLength;
4446                 /* everything else is left set to 0 */
4447                 break;
4448
4449         default:
4450                 return (0);
4451         }                       /* end switch */
4452
4453         ips_scmd_buf_write(scb->scsi_cmd, &mdata, sizeof (mdata));
4454
4455         return (1);
4456 }
4457
4458 /****************************************************************************/
4459 /*                                                                          */
4460 /* Routine Name: ips_reqsen                                                 */
4461 /*                                                                          */
4462 /* Routine Description:                                                     */
4463 /*                                                                          */
4464 /*   Simulate a request sense command to a logical drive                    */
4465 /*                                                                          */
4466 /****************************************************************************/
4467 static int
4468 ips_reqsen(ips_ha_t * ha, ips_scb_t * scb)
4469 {
4470         IPS_SCSI_REQSEN reqsen;
4471
4472         METHOD_TRACE("ips_reqsen", 1);
4473
4474         memset(&reqsen, 0, sizeof (IPS_SCSI_REQSEN));
4475
4476         reqsen.ResponseCode =
4477             IPS_SCSI_REQSEN_VALID | IPS_SCSI_REQSEN_CURRENT_ERR;
4478         reqsen.AdditionalLength = 10;
4479         reqsen.AdditionalSenseCode = IPS_SCSI_REQSEN_NO_SENSE;
4480         reqsen.AdditionalSenseCodeQual = IPS_SCSI_REQSEN_NO_SENSE;
4481
4482         ips_scmd_buf_write(scb->scsi_cmd, &reqsen, sizeof (reqsen));
4483
4484         return (1);
4485 }
4486
4487 /****************************************************************************/
4488 /*                                                                          */
4489 /* Routine Name: ips_free                                                   */
4490 /*                                                                          */
4491 /* Routine Description:                                                     */
4492 /*                                                                          */
4493 /*   Free any allocated space for this controller                           */
4494 /*                                                                          */
4495 /****************************************************************************/
4496 static void
4497 ips_free(ips_ha_t * ha)
4498 {
4499
4500         METHOD_TRACE("ips_free", 1);
4501
4502         if (ha) {
4503                 if (ha->enq) {
4504                         pci_free_consistent(ha->pcidev, sizeof(IPS_ENQ),
4505                                             ha->enq, ha->enq_busaddr);
4506                         ha->enq = NULL;
4507                 }
4508
4509                 kfree(ha->conf);
4510                 ha->conf = NULL;
4511
4512                 if (ha->adapt) {
4513                         pci_free_consistent(ha->pcidev,
4514                                             sizeof (IPS_ADAPTER) +
4515                                             sizeof (IPS_IO_CMD), ha->adapt,
4516                                             ha->adapt->hw_status_start);
4517                         ha->adapt = NULL;
4518                 }
4519
4520                 if (ha->logical_drive_info) {
4521                         pci_free_consistent(ha->pcidev,
4522                                             sizeof (IPS_LD_INFO),
4523                                             ha->logical_drive_info,
4524                                             ha->logical_drive_info_dma_addr);
4525                         ha->logical_drive_info = NULL;
4526                 }
4527
4528                 kfree(ha->nvram);
4529                 ha->nvram = NULL;
4530
4531                 kfree(ha->subsys);
4532                 ha->subsys = NULL;
4533
4534                 if (ha->ioctl_data) {
4535                         pci_free_consistent(ha->pcidev, ha->ioctl_len,
4536                                             ha->ioctl_data, ha->ioctl_busaddr);
4537                         ha->ioctl_data = NULL;
4538                         ha->ioctl_datasize = 0;
4539                         ha->ioctl_len = 0;
4540                 }
4541                 ips_deallocatescbs(ha, ha->max_cmds);
4542
4543                 /* free memory mapped (if applicable) */
4544                 if (ha->mem_ptr) {
4545                         iounmap(ha->ioremap_ptr);
4546                         ha->ioremap_ptr = NULL;
4547                         ha->mem_ptr = NULL;
4548                 }
4549
4550                 if (ha->mem_addr)
4551                         release_mem_region(ha->mem_addr, ha->mem_len);
4552                 ha->mem_addr = 0;
4553
4554         }
4555 }
4556
4557 /****************************************************************************/
4558 /*                                                                          */
4559 /* Routine Name: ips_deallocatescbs                                         */
4560 /*                                                                          */
4561 /* Routine Description:                                                     */
4562 /*                                                                          */
4563 /*   Free the command blocks                                                */
4564 /*                                                                          */
4565 /****************************************************************************/
4566 static int
4567 ips_deallocatescbs(ips_ha_t * ha, int cmds)
4568 {
4569         if (ha->scbs) {
4570                 pci_free_consistent(ha->pcidev,
4571                                     IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * cmds,
4572                                     ha->scbs->sg_list.list,
4573                                     ha->scbs->sg_busaddr);
4574                 pci_free_consistent(ha->pcidev, sizeof (ips_scb_t) * cmds,
4575                                     ha->scbs, ha->scbs->scb_busaddr);
4576                 ha->scbs = NULL;
4577         }                       /* end if */
4578         return 1;
4579 }
4580
4581 /****************************************************************************/
4582 /*                                                                          */
4583 /* Routine Name: ips_allocatescbs                                           */
4584 /*                                                                          */
4585 /* Routine Description:                                                     */
4586 /*                                                                          */
4587 /*   Allocate the command blocks                                            */
4588 /*                                                                          */
4589 /****************************************************************************/
4590 static int
4591 ips_allocatescbs(ips_ha_t * ha)
4592 {
4593         ips_scb_t *scb_p;
4594         IPS_SG_LIST ips_sg;
4595         int i;
4596         dma_addr_t command_dma, sg_dma;
4597
4598         METHOD_TRACE("ips_allocatescbs", 1);
4599
4600         /* Allocate memory for the SCBs */
4601         ha->scbs =
4602             pci_alloc_consistent(ha->pcidev, ha->max_cmds * sizeof (ips_scb_t),
4603                                  &command_dma);
4604         if (ha->scbs == NULL)
4605                 return 0;
4606         ips_sg.list =
4607             pci_alloc_consistent(ha->pcidev,
4608                                  IPS_SGLIST_SIZE(ha) * IPS_MAX_SG *
4609                                  ha->max_cmds, &sg_dma);
4610         if (ips_sg.list == NULL) {
4611                 pci_free_consistent(ha->pcidev,
4612                                     ha->max_cmds * sizeof (ips_scb_t), ha->scbs,
4613                                     command_dma);
4614                 return 0;
4615         }
4616
4617         memset(ha->scbs, 0, ha->max_cmds * sizeof (ips_scb_t));
4618
4619         for (i = 0; i < ha->max_cmds; i++) {
4620                 scb_p = &ha->scbs[i];
4621                 scb_p->scb_busaddr = command_dma + sizeof (ips_scb_t) * i;
4622                 /* set up S/G list */
4623                 if (IPS_USE_ENH_SGLIST(ha)) {
4624                         scb_p->sg_list.enh_list =
4625                             ips_sg.enh_list + i * IPS_MAX_SG;
4626                         scb_p->sg_busaddr =
4627                             sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4628                 } else {
4629                         scb_p->sg_list.std_list =
4630                             ips_sg.std_list + i * IPS_MAX_SG;
4631                         scb_p->sg_busaddr =
4632                             sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4633                 }
4634
4635                 /* add to the free list */
4636                 if (i < ha->max_cmds - 1) {
4637                         scb_p->q_next = ha->scb_freelist;
4638                         ha->scb_freelist = scb_p;
4639                 }
4640         }
4641
4642         /* success */
4643         return (1);
4644 }
4645
4646 /****************************************************************************/
4647 /*                                                                          */
4648 /* Routine Name: ips_init_scb                                               */
4649 /*                                                                          */
4650 /* Routine Description:                                                     */
4651 /*                                                                          */
4652 /*   Initialize a CCB to default values                                     */
4653 /*                                                                          */
4654 /****************************************************************************/
4655 static void
4656 ips_init_scb(ips_ha_t * ha, ips_scb_t * scb)
4657 {
4658         IPS_SG_LIST sg_list;
4659         uint32_t cmd_busaddr, sg_busaddr;
4660         METHOD_TRACE("ips_init_scb", 1);
4661
4662         if (scb == NULL)
4663                 return;
4664
4665         sg_list.list = scb->sg_list.list;
4666         cmd_busaddr = scb->scb_busaddr;
4667         sg_busaddr = scb->sg_busaddr;
4668         /* zero fill */
4669         memset(scb, 0, sizeof (ips_scb_t));
4670         memset(ha->dummy, 0, sizeof (IPS_IO_CMD));
4671
4672         /* Initialize dummy command bucket */
4673         ha->dummy->op_code = 0xFF;
4674         ha->dummy->ccsar = cpu_to_le32(ha->adapt->hw_status_start
4675                                        + sizeof (IPS_ADAPTER));
4676         ha->dummy->command_id = IPS_MAX_CMDS;
4677
4678         /* set bus address of scb */
4679         scb->scb_busaddr = cmd_busaddr;
4680         scb->sg_busaddr = sg_busaddr;
4681         scb->sg_list.list = sg_list.list;
4682
4683         /* Neptune Fix */
4684         scb->cmd.basic_io.cccr = cpu_to_le32((uint32_t) IPS_BIT_ILE);
4685         scb->cmd.basic_io.ccsar = cpu_to_le32(ha->adapt->hw_status_start
4686                                               + sizeof (IPS_ADAPTER));
4687 }
4688
4689 /****************************************************************************/
4690 /*                                                                          */
4691 /* Routine Name: ips_get_scb                                                */
4692 /*                                                                          */
4693 /* Routine Description:                                                     */
4694 /*                                                                          */
4695 /*   Initialize a CCB to default values                                     */
4696 /*                                                                          */
4697 /* ASSUMED to be callled from within a lock                                 */
4698 /*                                                                          */
4699 /****************************************************************************/
4700 static ips_scb_t *
4701 ips_getscb(ips_ha_t * ha)
4702 {
4703         ips_scb_t *scb;
4704
4705         METHOD_TRACE("ips_getscb", 1);
4706
4707         if ((scb = ha->scb_freelist) == NULL) {
4708
4709                 return (NULL);
4710         }
4711
4712         ha->scb_freelist = scb->q_next;
4713         scb->flags = 0;
4714         scb->q_next = NULL;
4715
4716         ips_init_scb(ha, scb);
4717
4718         return (scb);
4719 }
4720
4721 /****************************************************************************/
4722 /*                                                                          */
4723 /* Routine Name: ips_free_scb                                               */
4724 /*                                                                          */
4725 /* Routine Description:                                                     */
4726 /*                                                                          */
4727 /*   Return an unused CCB back to the free list                             */
4728 /*                                                                          */
4729 /* ASSUMED to be called from within a lock                                  */
4730 /*                                                                          */
4731 /****************************************************************************/
4732 static void
4733 ips_freescb(ips_ha_t * ha, ips_scb_t * scb)
4734 {
4735
4736         METHOD_TRACE("ips_freescb", 1);
4737         if (scb->flags & IPS_SCB_MAP_SG)
4738                 pci_unmap_sg(ha->pcidev, scb->scsi_cmd->request_buffer,
4739                              scb->scsi_cmd->use_sg, IPS_DMA_DIR(scb));
4740         else if (scb->flags & IPS_SCB_MAP_SINGLE)
4741                 pci_unmap_single(ha->pcidev, scb->data_busaddr, scb->data_len,
4742                                  IPS_DMA_DIR(scb));
4743
4744         /* check to make sure this is not our "special" scb */
4745         if (IPS_COMMAND_ID(ha, scb) < (ha->max_cmds - 1)) {
4746                 scb->q_next = ha->scb_freelist;
4747                 ha->scb_freelist = scb;
4748         }
4749 }
4750
4751 /****************************************************************************/
4752 /*                                                                          */
4753 /* Routine Name: ips_isinit_copperhead                                      */
4754 /*                                                                          */
4755 /* Routine Description:                                                     */
4756 /*                                                                          */
4757 /*   Is controller initialized ?                                            */
4758 /*                                                                          */
4759 /****************************************************************************/
4760 static int
4761 ips_isinit_copperhead(ips_ha_t * ha)
4762 {
4763         uint8_t scpr;
4764         uint8_t isr;
4765
4766         METHOD_TRACE("ips_isinit_copperhead", 1);
4767
4768         isr = inb(ha->io_addr + IPS_REG_HISR);
4769         scpr = inb(ha->io_addr + IPS_REG_SCPR);
4770
4771         if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4772                 return (0);
4773         else
4774                 return (1);
4775 }
4776
4777 /****************************************************************************/
4778 /*                                                                          */
4779 /* Routine Name: ips_isinit_copperhead_memio                                */
4780 /*                                                                          */
4781 /* Routine Description:                                                     */
4782 /*                                                                          */
4783 /*   Is controller initialized ?                                            */
4784 /*                                                                          */
4785 /****************************************************************************/
4786 static int
4787 ips_isinit_copperhead_memio(ips_ha_t * ha)
4788 {
4789         uint8_t isr = 0;
4790         uint8_t scpr;
4791
4792         METHOD_TRACE("ips_is_init_copperhead_memio", 1);
4793
4794         isr = readb(ha->mem_ptr + IPS_REG_HISR);
4795         scpr = readb(ha->mem_ptr + IPS_REG_SCPR);
4796
4797         if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4798                 return (0);
4799         else
4800                 return (1);
4801 }
4802
4803 /****************************************************************************/
4804 /*                                                                          */
4805 /* Routine Name: ips_isinit_morpheus                                        */
4806 /*                                                                          */
4807 /* Routine Description:                                                     */
4808 /*                                                                          */
4809 /*   Is controller initialized ?                                            */
4810 /*                                                                          */
4811 /****************************************************************************/
4812 static int
4813 ips_isinit_morpheus(ips_ha_t * ha)
4814 {
4815         uint32_t post;
4816         uint32_t bits;
4817
4818         METHOD_TRACE("ips_is_init_morpheus", 1);
4819
4820         if (ips_isintr_morpheus(ha))
4821             ips_flush_and_reset(ha);
4822
4823         post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
4824         bits = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
4825
4826         if (post == 0)
4827                 return (0);
4828         else if (bits & 0x3)
4829                 return (0);
4830         else
4831                 return (1);
4832 }
4833
4834 /****************************************************************************/
4835 /*                                                                          */
4836 /* Routine Name: ips_flush_and_reset                                        */
4837 /*                                                                          */
4838 /* Routine Description:                                                     */
4839 /*                                                                          */
4840 /*   Perform cleanup ( FLUSH and RESET ) when the adapter is in an unknown  */
4841 /*   state ( was trying to INIT and an interrupt was already pending ) ...  */
4842 /*                                                                          */
4843 /****************************************************************************/
4844 static void
4845 ips_flush_and_reset(ips_ha_t *ha)
4846 {
4847         ips_scb_t *scb;
4848         int  ret;
4849         int  time;
4850         int  done;
4851         dma_addr_t command_dma;
4852
4853         /* Create a usuable SCB */
4854         scb = pci_alloc_consistent(ha->pcidev, sizeof(ips_scb_t), &command_dma);
4855         if (scb) {
4856             memset(scb, 0, sizeof(ips_scb_t));
4857             ips_init_scb(ha, scb);
4858             scb->scb_busaddr = command_dma;
4859
4860             scb->timeout = ips_cmd_timeout;
4861             scb->cdb[0] = IPS_CMD_FLUSH;
4862
4863             scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
4864             scb->cmd.flush_cache.command_id = IPS_MAX_CMDS;   /* Use an ID that would otherwise not exist */
4865             scb->cmd.flush_cache.state = IPS_NORM_STATE;
4866             scb->cmd.flush_cache.reserved = 0;
4867             scb->cmd.flush_cache.reserved2 = 0;
4868             scb->cmd.flush_cache.reserved3 = 0;
4869             scb->cmd.flush_cache.reserved4 = 0;
4870
4871             ret = ips_send_cmd(ha, scb);                      /* Send the Flush Command */
4872
4873             if (ret == IPS_SUCCESS) {
4874                 time = 60 * IPS_ONE_SEC;                      /* Max Wait time is 60 seconds */
4875                 done = 0;
4876
4877                 while ((time > 0) && (!done)) {
4878                    done = ips_poll_for_flush_complete(ha);
4879                    /* This may look evil, but it's only done during extremely rare start-up conditions ! */
4880                    udelay(1000);
4881                    time--;
4882                 }
4883         }
4884         }
4885
4886         /* Now RESET and INIT the adapter */
4887         (*ha->func.reset) (ha);
4888
4889         pci_free_consistent(ha->pcidev, sizeof(ips_scb_t), scb, command_dma);
4890         return;
4891 }
4892
4893 /****************************************************************************/
4894 /*                                                                          */
4895 /* Routine Name: ips_poll_for_flush_complete                                */
4896 /*                                                                          */
4897 /* Routine Description:                                                     */
4898 /*                                                                          */
4899 /*   Poll for the Flush Command issued by ips_flush_and_reset() to complete */
4900 /*   All other responses are just taken off the queue and ignored           */
4901 /*                                                                          */
4902 /****************************************************************************/
4903 static int
4904 ips_poll_for_flush_complete(ips_ha_t * ha)
4905 {
4906         IPS_STATUS cstatus;
4907
4908         while (TRUE) {
4909             cstatus.value = (*ha->func.statupd) (ha);
4910
4911             if (cstatus.value == 0xffffffff)      /* If No Interrupt to process */
4912                         break;
4913
4914             /* Success is when we see the Flush Command ID */
4915             if (cstatus.fields.command_id == IPS_MAX_CMDS )
4916                 return 1;
4917          }
4918
4919         return 0;
4920 }
4921
4922 /****************************************************************************/
4923 /*                                                                          */
4924 /* Routine Name: ips_enable_int_copperhead                                  */
4925 /*                                                                          */
4926 /* Routine Description:                                                     */
4927 /*   Turn on interrupts                                                     */
4928 /*                                                                          */
4929 /****************************************************************************/
4930 static void
4931 ips_enable_int_copperhead(ips_ha_t * ha)
4932 {
4933         METHOD_TRACE("ips_enable_int_copperhead", 1);
4934
4935         outb(ha->io_addr + IPS_REG_HISR, IPS_BIT_EI);
4936         inb(ha->io_addr + IPS_REG_HISR);        /*Ensure PCI Posting Completes*/
4937 }
4938
4939 /****************************************************************************/
4940 /*                                                                          */
4941 /* Routine Name: ips_enable_int_copperhead_memio                            */
4942 /*                                                                          */
4943 /* Routine Description:                                                     */
4944 /*   Turn on interrupts                                                     */
4945 /*                                                                          */
4946 /****************************************************************************/
4947 static void
4948 ips_enable_int_copperhead_memio(ips_ha_t * ha)
4949 {
4950         METHOD_TRACE("ips_enable_int_copperhead_memio", 1);
4951
4952         writeb(IPS_BIT_EI, ha->mem_ptr + IPS_REG_HISR);
4953         readb(ha->mem_ptr + IPS_REG_HISR);      /*Ensure PCI Posting Completes*/
4954 }
4955
4956 /****************************************************************************/
4957 /*                                                                          */
4958 /* Routine Name: ips_enable_int_morpheus                                    */
4959 /*                                                                          */
4960 /* Routine Description:                                                     */
4961 /*   Turn on interrupts                                                     */
4962 /*                                                                          */
4963 /****************************************************************************/
4964 static void
4965 ips_enable_int_morpheus(ips_ha_t * ha)
4966 {
4967         uint32_t Oimr;
4968
4969         METHOD_TRACE("ips_enable_int_morpheus", 1);
4970
4971         Oimr = readl(ha->mem_ptr + IPS_REG_I960_OIMR);
4972         Oimr &= ~0x08;
4973         writel(Oimr, ha->mem_ptr + IPS_REG_I960_OIMR);
4974         readl(ha->mem_ptr + IPS_REG_I960_OIMR); /*Ensure PCI Posting Completes*/
4975 }
4976
4977 /****************************************************************************/
4978 /*                                                                          */
4979 /* Routine Name: ips_init_copperhead                                        */
4980 /*                                                                          */
4981 /* Routine Description:                                                     */
4982 /*                                                                          */
4983 /*   Initialize a copperhead controller                                     */
4984 /*                                                                          */
4985 /****************************************************************************/
4986 static int
4987 ips_init_copperhead(ips_ha_t * ha)
4988 {
4989         uint8_t Isr;
4990         uint8_t Cbsp;
4991         uint8_t PostByte[IPS_MAX_POST_BYTES];
4992         uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
4993         int i, j;
4994
4995         METHOD_TRACE("ips_init_copperhead", 1);
4996
4997         for (i = 0; i < IPS_MAX_POST_BYTES; i++) {
4998                 for (j = 0; j < 45; j++) {
4999                         Isr = inb(ha->io_addr + IPS_REG_HISR);
5000                         if (Isr & IPS_BIT_GHI)
5001                                 break;
5002
5003                         /* Delay for 1 Second */
5004                         msleep(IPS_ONE_SEC);
5005                 }
5006
5007                 if (j >= 45)
5008                         /* error occurred */
5009                         return (0);
5010
5011                 PostByte[i] = inb(ha->io_addr + IPS_REG_ISPR);
5012                 outb(Isr, ha->io_addr + IPS_REG_HISR);
5013         }
5014
5015         if (PostByte[0] < IPS_GOOD_POST_STATUS) {
5016                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5017                            "reset controller fails (post status %x %x).\n",
5018                            PostByte[0], PostByte[1]);
5019
5020                 return (0);
5021         }
5022
5023         for (i = 0; i < IPS_MAX_CONFIG_BYTES; i++) {
5024                 for (j = 0; j < 240; j++) {
5025                         Isr = inb(ha->io_addr + IPS_REG_HISR);
5026                         if (Isr & IPS_BIT_GHI)
5027                                 break;
5028
5029                         /* Delay for 1 Second */
5030                         msleep(IPS_ONE_SEC);
5031                 }
5032
5033                 if (j >= 240)
5034                         /* error occurred */
5035                         return (0);
5036
5037                 ConfigByte[i] = inb(ha->io_addr + IPS_REG_ISPR);
5038                 outb(Isr, ha->io_addr + IPS_REG_HISR);
5039         }
5040
5041         for (i = 0; i < 240; i++) {
5042                 Cbsp = inb(ha->io_addr + IPS_REG_CBSP);
5043
5044                 if ((Cbsp & IPS_BIT_OP) == 0)
5045                         break;
5046
5047                 /* Delay for 1 Second */
5048                 msleep(IPS_ONE_SEC);
5049         }
5050
5051         if (i >= 240)
5052                 /* reset failed */
5053                 return (0);
5054
5055         /* setup CCCR */
5056         outl(cpu_to_le32(0x1010), ha->io_addr + IPS_REG_CCCR);
5057
5058         /* Enable busmastering */
5059         outb(IPS_BIT_EBM, ha->io_addr + IPS_REG_SCPR);
5060
5061         if (ha->revision_id == IPS_REVID_TROMBONE64)
5062                 /* fix for anaconda64 */
5063                 outl(0, ha->io_addr + IPS_REG_NDAE);
5064
5065         /* Enable interrupts */
5066         outb(IPS_BIT_EI, ha->io_addr + IPS_REG_HISR);
5067
5068         return (1);
5069 }
5070
5071 /****************************************************************************/
5072 /*                                                                          */
5073 /* Routine Name: ips_init_copperhead_memio                                  */
5074 /*                                                                          */
5075 /* Routine Description:                                                     */
5076 /*                                                                          */
5077 /*   Initialize a copperhead controller with memory mapped I/O              */
5078 /*                                                                          */
5079 /****************************************************************************/
5080 static int
5081 ips_init_copperhead_memio(ips_ha_t * ha)
5082 {
5083         uint8_t Isr = 0;
5084         uint8_t Cbsp;
5085         uint8_t PostByte[IPS_MAX_POST_BYTES];
5086         uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
5087         int i, j;
5088
5089         METHOD_TRACE("ips_init_copperhead_memio", 1);
5090
5091         for (i = 0; i < IPS_MAX_POST_BYTES; i++) {
5092                 for (j = 0; j < 45; j++) {
5093                         Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5094                         if (Isr & IPS_BIT_GHI)
5095                                 break;
5096
5097                         /* Delay for 1 Second */
5098                         msleep(IPS_ONE_SEC);
5099                 }
5100
5101                 if (j >= 45)
5102                         /* error occurred */
5103                         return (0);
5104
5105                 PostByte[i] = readb(ha->mem_ptr + IPS_REG_ISPR);
5106                 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5107         }
5108
5109         if (PostByte[0] < IPS_GOOD_POST_STATUS) {
5110                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5111                            "reset controller fails (post status %x %x).\n",
5112                            PostByte[0], PostByte[1]);
5113
5114                 return (0);
5115         }
5116
5117         for (i = 0; i < IPS_MAX_CONFIG_BYTES; i++) {
5118                 for (j = 0; j < 240; j++) {
5119                         Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5120                         if (Isr & IPS_BIT_GHI)
5121                                 break;
5122
5123                         /* Delay for 1 Second */
5124                         msleep(IPS_ONE_SEC);
5125                 }
5126
5127                 if (j >= 240)
5128                         /* error occurred */
5129                         return (0);
5130
5131                 ConfigByte[i] = readb(ha->mem_ptr + IPS_REG_ISPR);
5132                 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5133         }
5134
5135         for (i = 0; i < 240; i++) {
5136                 Cbsp = readb(ha->mem_ptr + IPS_REG_CBSP);
5137
5138                 if ((Cbsp & IPS_BIT_OP) == 0)
5139                         break;
5140
5141                 /* Delay for 1 Second */
5142                 msleep(IPS_ONE_SEC);
5143         }
5144
5145         if (i >= 240)
5146                 /* error occurred */
5147                 return (0);
5148
5149         /* setup CCCR */
5150         writel(0x1010, ha->mem_ptr + IPS_REG_CCCR);
5151
5152         /* Enable busmastering */
5153         writeb(IPS_BIT_EBM, ha->mem_ptr + IPS_REG_SCPR);
5154
5155         if (ha->revision_id == IPS_REVID_TROMBONE64)
5156                 /* fix for anaconda64 */
5157                 writel(0, ha->mem_ptr + IPS_REG_NDAE);
5158
5159         /* Enable interrupts */
5160         writeb(IPS_BIT_EI, ha->mem_ptr + IPS_REG_HISR);
5161
5162         /* if we get here then everything went OK */
5163         return (1);
5164 }
5165
5166 /****************************************************************************/
5167 /*                                                                          */
5168 /* Routine Name: ips_init_morpheus                                          */
5169 /*                                                                          */
5170 /* Routine Description:                                                     */
5171 /*                                                                          */
5172 /*   Initialize a morpheus controller                                       */
5173 /*                                                                          */
5174 /****************************************************************************/
5175 static int
5176 ips_init_morpheus(ips_ha_t * ha)
5177 {
5178         uint32_t Post;
5179         uint32_t Config;
5180         uint32_t Isr;
5181         uint32_t Oimr;
5182         int i;
5183
5184         METHOD_TRACE("ips_init_morpheus", 1);
5185
5186         /* Wait up to 45 secs for Post */
5187         for (i = 0; i < 45; i++) {
5188                 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5189
5190                 if (Isr & IPS_BIT_I960_MSG0I)
5191                         break;
5192
5193                 /* Delay for 1 Second */
5194                 msleep(IPS_ONE_SEC);
5195         }
5196
5197         if (i >= 45) {
5198                 /* error occurred */
5199                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5200                            "timeout waiting for post.\n");
5201
5202                 return (0);
5203         }
5204
5205         Post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
5206
5207         if (Post == 0x4F00) {   /* If Flashing the Battery PIC         */
5208                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5209                            "Flashing Battery PIC, Please wait ...\n");
5210
5211                 /* Clear the interrupt bit */
5212                 Isr = (uint32_t) IPS_BIT_I960_MSG0I;
5213                 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5214
5215                 for (i = 0; i < 120; i++) {     /*    Wait Up to 2 Min. for Completion */
5216                         Post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
5217                         if (Post != 0x4F00)
5218                                 break;
5219                         /* Delay for 1 Second */
5220                         msleep(IPS_ONE_SEC);
5221                 }
5222
5223                 if (i >= 120) {
5224                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
5225                                    "timeout waiting for Battery PIC Flash\n");
5226                         return (0);
5227                 }
5228
5229         }
5230
5231         /* Clear the interrupt bit */
5232         Isr = (uint32_t) IPS_BIT_I960_MSG0I;
5233         writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5234
5235         if (Post < (IPS_GOOD_POST_STATUS << 8)) {
5236                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5237                            "reset controller fails (post status %x).\n", Post);
5238
5239                 return (0);
5240         }
5241
5242         /* Wait up to 240 secs for config bytes */
5243         for (i = 0; i < 240; i++) {
5244                 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5245
5246                 if (Isr & IPS_BIT_I960_MSG1I)
5247                         break;
5248
5249                 /* Delay for 1 Second */
5250                 msleep(IPS_ONE_SEC);
5251         }
5252
5253         if (i >= 240) {
5254                 /* error occurred */
5255                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5256                            "timeout waiting for config.\n");
5257
5258                 return (0);
5259         }
5260
5261         Config = readl(ha->mem_ptr + IPS_REG_I960_MSG1);
5262
5263         /* Clear interrupt bit */
5264         Isr = (uint32_t) IPS_BIT_I960_MSG1I;
5265         writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5266
5267         /* Turn on the interrupts */
5268         Oimr = readl(ha->mem_ptr + IPS_REG_I960_OIMR);
5269         Oimr &= ~0x8;
5270         writel(Oimr, ha->mem_ptr + IPS_REG_I960_OIMR);
5271
5272         /* if we get here then everything went OK */
5273
5274         /* Since we did a RESET, an EraseStripeLock may be needed */
5275         if (Post == 0xEF10) {
5276                 if ((Config == 0x000F) || (Config == 0x0009))
5277                         ha->requires_esl = 1;
5278         }
5279
5280         return (1);
5281 }
5282
5283 /****************************************************************************/
5284 /*                                                                          */
5285 /* Routine Name: ips_reset_copperhead                                       */
5286 /*                                                                          */
5287 /* Routine Description:                                                     */
5288 /*                                                                          */
5289 /*   Reset the controller                                                   */
5290 /*                                                                          */
5291 /****************************************************************************/
5292 static int
5293 ips_reset_copperhead(ips_ha_t * ha)
5294 {
5295         int reset_counter;
5296
5297         METHOD_TRACE("ips_reset_copperhead", 1);
5298
5299         DEBUG_VAR(1, "(%s%d) ips_reset_copperhead: io addr: %x, irq: %d",
5300                   ips_name, ha->host_num, ha->io_addr, ha->irq);
5301
5302         reset_counter = 0;
5303
5304         while (reset_counter < 2) {
5305                 reset_counter++;
5306
5307                 outb(IPS_BIT_RST, ha->io_addr + IPS_REG_SCPR);
5308
5309                 /* Delay for 1 Second */
5310                 msleep(IPS_ONE_SEC);
5311
5312                 outb(0, ha->io_addr + IPS_REG_SCPR);
5313
5314                 /* Delay for 1 Second */
5315                 msleep(IPS_ONE_SEC);
5316
5317                 if ((*ha->func.init) (ha))
5318                         break;
5319                 else if (reset_counter >= 2) {
5320
5321                         return (0);
5322                 }
5323         }
5324
5325         return (1);
5326 }
5327
5328 /****************************************************************************/
5329 /*                                                                          */
5330 /* Routine Name: ips_reset_copperhead_memio                                 */
5331 /*                                                                          */
5332 /* Routine Description:                                                     */
5333 /*                                                                          */
5334 /*   Reset the controller                                                   */
5335 /*                                                                          */
5336 /****************************************************************************/
5337 static int
5338 ips_reset_copperhead_memio(ips_ha_t * ha)
5339 {
5340         int reset_counter;
5341
5342         METHOD_TRACE("ips_reset_copperhead_memio", 1);
5343
5344         DEBUG_VAR(1, "(%s%d) ips_reset_copperhead_memio: mem addr: %x, irq: %d",
5345                   ips_name, ha->host_num, ha->mem_addr, ha->irq);
5346
5347         reset_counter = 0;
5348
5349         while (reset_counter < 2) {
5350                 reset_counter++;
5351
5352                 writeb(IPS_BIT_RST, ha->mem_ptr + IPS_REG_SCPR);
5353
5354                 /* Delay for 1 Second */
5355                 msleep(IPS_ONE_SEC);
5356
5357                 writeb(0, ha->mem_ptr + IPS_REG_SCPR);
5358
5359                 /* Delay for 1 Second */
5360                 msleep(IPS_ONE_SEC);
5361
5362                 if ((*ha->func.init) (ha))
5363                         break;
5364                 else if (reset_counter >= 2) {
5365
5366                         return (0);
5367                 }
5368         }
5369
5370         return (1);
5371 }
5372
5373 /****************************************************************************/
5374 /*                                                                          */
5375 /* Routine Name: ips_reset_morpheus                                         */
5376 /*                                                                          */
5377 /* Routine Description:                                                     */
5378 /*                                                                          */
5379 /*   Reset the controller                                                   */
5380 /*                                                                          */
5381 /****************************************************************************/
5382 static int
5383 ips_reset_morpheus(ips_ha_t * ha)
5384 {
5385         int reset_counter;
5386         uint8_t junk;
5387
5388         METHOD_TRACE("ips_reset_morpheus", 1);
5389
5390         DEBUG_VAR(1, "(%s%d) ips_reset_morpheus: mem addr: %x, irq: %d",
5391                   ips_name, ha->host_num, ha->mem_addr, ha->irq);
5392
5393         reset_counter = 0;
5394
5395         while (reset_counter < 2) {
5396                 reset_counter++;
5397
5398                 writel(0x80000000, ha->mem_ptr + IPS_REG_I960_IDR);
5399
5400                 /* Delay for 5 Seconds */
5401                 msleep(5 * IPS_ONE_SEC);
5402
5403                 /* Do a PCI config read to wait for adapter */
5404                 pci_read_config_byte(ha->pcidev, 4, &junk);
5405
5406                 if ((*ha->func.init) (ha))
5407                         break;
5408                 else if (reset_counter >= 2) {
5409
5410                         return (0);
5411                 }
5412         }
5413
5414         return (1);
5415 }
5416
5417 /****************************************************************************/
5418 /*                                                                          */
5419 /* Routine Name: ips_statinit                                               */
5420 /*                                                                          */
5421 /* Routine Description:                                                     */
5422 /*                                                                          */
5423 /*   Initialize the status queues on the controller                         */
5424 /*                                                                          */
5425 /****************************************************************************/
5426 static void
5427 ips_statinit(ips_ha_t * ha)
5428 {
5429         uint32_t phys_status_start;
5430
5431         METHOD_TRACE("ips_statinit", 1);
5432
5433         ha->adapt->p_status_start = ha->adapt->status;
5434         ha->adapt->p_status_end = ha->adapt->status + IPS_MAX_CMDS;
5435         ha->adapt->p_status_tail = ha->adapt->status;
5436
5437         phys_status_start = ha->adapt->hw_status_start;
5438         outl(cpu_to_le32(phys_status_start), ha->io_addr + IPS_REG_SQSR);
5439         outl(cpu_to_le32(phys_status_start + IPS_STATUS_Q_SIZE),
5440              ha->io_addr + IPS_REG_SQER);
5441         outl(cpu_to_le32(phys_status_start + IPS_STATUS_SIZE),
5442              ha->io_addr + IPS_REG_SQHR);
5443         outl(cpu_to_le32(phys_status_start), ha->io_addr + IPS_REG_SQTR);
5444
5445         ha->adapt->hw_status_tail = phys_status_start;
5446 }
5447
5448 /****************************************************************************/
5449 /*                                                                          */
5450 /* Routine Name: ips_statinit_memio                                         */
5451 /*                                                                          */
5452 /* Routine Description:                                                     */
5453 /*                                                                          */
5454 /*   Initialize the status queues on the controller                         */
5455 /*                                                                          */
5456 /****************************************************************************/
5457 static void
5458 ips_statinit_memio(ips_ha_t * ha)
5459 {
5460         uint32_t phys_status_start;
5461
5462         METHOD_TRACE("ips_statinit_memio", 1);
5463
5464         ha->adapt->p_status_start = ha->adapt->status;
5465         ha->adapt->p_status_end = ha->adapt->status + IPS_MAX_CMDS;
5466         ha->adapt->p_status_tail = ha->adapt->status;
5467
5468         phys_status_start = ha->adapt->hw_status_start;
5469         writel(phys_status_start, ha->mem_ptr + IPS_REG_SQSR);
5470         writel(phys_status_start + IPS_STATUS_Q_SIZE,
5471                ha->mem_ptr + IPS_REG_SQER);
5472         writel(phys_status_start + IPS_STATUS_SIZE, ha->mem_ptr + IPS_REG_SQHR);
5473         writel(phys_status_start, ha->mem_ptr + IPS_REG_SQTR);
5474
5475         ha->adapt->hw_status_tail = phys_status_start;
5476 }
5477
5478 /****************************************************************************/
5479 /*                                                                          */
5480 /* Routine Name: ips_statupd_copperhead                                     */
5481 /*                                                                          */
5482 /* Routine Description:                                                     */
5483 /*                                                                          */
5484 /*   Remove an element from the status queue                                */
5485 /*                                                                          */
5486 /****************************************************************************/
5487 static uint32_t
5488 ips_statupd_copperhead(ips_ha_t * ha)
5489 {
5490         METHOD_TRACE("ips_statupd_copperhead", 1);
5491
5492         if (ha->adapt->p_status_tail != ha->adapt->p_status_end) {
5493                 ha->adapt->p_status_tail++;
5494                 ha->adapt->hw_status_tail += sizeof (IPS_STATUS);
5495         } else {
5496                 ha->adapt->p_status_tail = ha->adapt->p_status_start;
5497                 ha->adapt->hw_status_tail = ha->adapt->hw_status_start;
5498         }
5499
5500         outl(cpu_to_le32(ha->adapt->hw_status_tail),
5501              ha->io_addr + IPS_REG_SQTR);
5502
5503         return (ha->adapt->p_status_tail->value);
5504 }
5505
5506 /****************************************************************************/
5507 /*                                                                          */
5508 /* Routine Name: ips_statupd_copperhead_memio                               */
5509 /*                                                                          */
5510 /* Routine Description:                                                     */
5511 /*                                                                          */
5512 /*   Remove an element from the status queue                                */
5513 /*                                                                          */
5514 /****************************************************************************/
5515 static uint32_t
5516 ips_statupd_copperhead_memio(ips_ha_t * ha)
5517 {
5518         METHOD_TRACE("ips_statupd_copperhead_memio", 1);
5519
5520         if (ha->adapt->p_status_tail != ha->adapt->p_status_end) {
5521                 ha->adapt->p_status_tail++;
5522                 ha->adapt->hw_status_tail += sizeof (IPS_STATUS);
5523         } else {
5524                 ha->adapt->p_status_tail = ha->adapt->p_status_start;
5525                 ha->adapt->hw_status_tail = ha->adapt->hw_status_start;
5526         }
5527
5528         writel(ha->adapt->hw_status_tail, ha->mem_ptr + IPS_REG_SQTR);
5529
5530         return (ha->adapt->p_status_tail->value);
5531 }
5532
5533 /****************************************************************************/
5534 /*                                                                          */
5535 /* Routine Name: ips_statupd_morpheus                                       */
5536 /*                                                                          */
5537 /* Routine Description:                                                     */
5538 /*                                                                          */
5539 /*   Remove an element from the status queue                                */
5540 /*                                                                          */
5541 /****************************************************************************/
5542 static uint32_t
5543 ips_statupd_morpheus(ips_ha_t * ha)
5544 {
5545         uint32_t val;
5546
5547         METHOD_TRACE("ips_statupd_morpheus", 1);
5548
5549         val = readl(ha->mem_ptr + IPS_REG_I2O_OUTMSGQ);
5550
5551         return (val);
5552 }
5553
5554 /****************************************************************************/
5555 /*                                                                          */
5556 /* Routine Name: ips_issue_copperhead                                       */
5557 /*                                                                          */
5558 /* Routine Description:                                                     */
5559 /*                                                                          */
5560 /*   Send a command down to the controller                                  */
5561 /*                                                                          */
5562 /****************************************************************************/
5563 static int
5564 ips_issue_copperhead(ips_ha_t * ha, ips_scb_t * scb)
5565 {
5566         uint32_t TimeOut;
5567         uint32_t val;
5568
5569         METHOD_TRACE("ips_issue_copperhead", 1);
5570
5571         if (scb->scsi_cmd) {
5572                 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5573                           ips_name,
5574                           ha->host_num,
5575                           scb->cdb[0],
5576                           scb->cmd.basic_io.command_id,
5577                           scb->bus, scb->target_id, scb->lun);
5578         } else {
5579                 DEBUG_VAR(2, KERN_NOTICE "(%s%d) ips_issue: logical cmd id %d",
5580                           ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5581         }
5582
5583         TimeOut = 0;
5584
5585         while ((val =
5586                 le32_to_cpu(inl(ha->io_addr + IPS_REG_CCCR))) & IPS_BIT_SEM) {
5587                 udelay(1000);
5588
5589                 if (++TimeOut >= IPS_SEM_TIMEOUT) {
5590                         if (!(val & IPS_BIT_START_STOP))
5591                                 break;
5592
5593                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
5594                                    "ips_issue val [0x%x].\n", val);
5595                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
5596                                    "ips_issue semaphore chk timeout.\n");
5597
5598                         return (IPS_FAILURE);
5599                 }               /* end if */
5600         }                       /* end while */
5601
5602         outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_CCSAR);
5603         outw(cpu_to_le32(IPS_BIT_START_CMD), ha->io_addr + IPS_REG_CCCR);
5604
5605         return (IPS_SUCCESS);
5606 }
5607
5608 /****************************************************************************/
5609 /*                                                                          */
5610 /* Routine Name: ips_issue_copperhead_memio                                 */
5611 /*                                                                          */
5612 /* Routine Description:                                                     */
5613 /*                                                                          */
5614 /*   Send a command down to the controller                                  */
5615 /*                                                                          */
5616 /****************************************************************************/
5617 static int
5618 ips_issue_copperhead_memio(ips_ha_t * ha, ips_scb_t * scb)
5619 {
5620         uint32_t TimeOut;
5621         uint32_t val;
5622
5623         METHOD_TRACE("ips_issue_copperhead_memio", 1);
5624
5625         if (scb->scsi_cmd) {
5626                 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5627                           ips_name,
5628                           ha->host_num,
5629                           scb->cdb[0],
5630                           scb->cmd.basic_io.command_id,
5631                           scb->bus, scb->target_id, scb->lun);
5632         } else {
5633                 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5634                           ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5635         }
5636
5637         TimeOut = 0;
5638
5639         while ((val = readl(ha->mem_ptr + IPS_REG_CCCR)) & IPS_BIT_SEM) {
5640                 udelay(1000);
5641
5642                 if (++TimeOut >= IPS_SEM_TIMEOUT) {
5643                         if (!(val & IPS_BIT_START_STOP))
5644                                 break;
5645
5646                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
5647                                    "ips_issue val [0x%x].\n", val);
5648                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
5649                                    "ips_issue semaphore chk timeout.\n");
5650
5651                         return (IPS_FAILURE);
5652                 }               /* end if */
5653         }                       /* end while */
5654
5655         writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_CCSAR);
5656         writel(IPS_BIT_START_CMD, ha->mem_ptr + IPS_REG_CCCR);
5657
5658         return (IPS_SUCCESS);
5659 }
5660
5661 /****************************************************************************/
5662 /*                                                                          */
5663 /* Routine Name: ips_issue_i2o                                              */
5664 /*                                                                          */
5665 /* Routine Description:                                                     */
5666 /*                                                                          */
5667 /*   Send a command down to the controller                                  */
5668 /*                                                                          */
5669 /****************************************************************************/
5670 static int
5671 ips_issue_i2o(ips_ha_t * ha, ips_scb_t * scb)
5672 {
5673
5674         METHOD_TRACE("ips_issue_i2o", 1);
5675
5676         if (scb->scsi_cmd) {
5677                 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5678                           ips_name,
5679                           ha->host_num,
5680                           scb->cdb[0],
5681                           scb->cmd.basic_io.command_id,
5682                           scb->bus, scb->target_id, scb->lun);
5683         } else {
5684                 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5685                           ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5686         }
5687
5688         outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_I2O_INMSGQ);
5689
5690         return (IPS_SUCCESS);
5691 }
5692
5693 /****************************************************************************/
5694 /*                                                                          */
5695 /* Routine Name: ips_issue_i2o_memio                                        */
5696 /*                                                                          */
5697 /* Routine Description:                                                     */
5698 /*                                                                          */
5699 /*   Send a command down to the controller                                  */
5700 /*                                                                          */
5701 /****************************************************************************/
5702 static int
5703 ips_issue_i2o_memio(ips_ha_t * ha, ips_scb_t * scb)
5704 {
5705
5706         METHOD_TRACE("ips_issue_i2o_memio", 1);
5707
5708         if (scb->scsi_cmd) {
5709                 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5710                           ips_name,
5711                           ha->host_num,
5712                           scb->cdb[0],
5713                           scb->cmd.basic_io.command_id,
5714                           scb->bus, scb->target_id, scb->lun);
5715         } else {
5716                 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5717                           ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5718         }
5719
5720         writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_I2O_INMSGQ);
5721
5722         return (IPS_SUCCESS);
5723 }
5724
5725 /****************************************************************************/
5726 /*                                                                          */
5727 /* Routine Name: ips_isintr_copperhead                                      */
5728 /*                                                                          */
5729 /* Routine Description:                                                     */
5730 /*                                                                          */
5731 /*   Test to see if an interrupt is for us                                  */
5732 /*                                                                          */
5733 /****************************************************************************/
5734 static int
5735 ips_isintr_copperhead(ips_ha_t * ha)
5736 {
5737         uint8_t Isr;
5738
5739         METHOD_TRACE("ips_isintr_copperhead", 2);
5740
5741         Isr = inb(ha->io_addr + IPS_REG_HISR);
5742
5743         if (Isr == 0xFF)
5744                 /* ?!?! Nothing really there */
5745                 return (0);
5746
5747         if (Isr & IPS_BIT_SCE)
5748                 return (1);
5749         else if (Isr & (IPS_BIT_SQO | IPS_BIT_GHI)) {
5750                 /* status queue overflow or GHI */
5751                 /* just clear the interrupt */
5752                 outb(Isr, ha->io_addr + IPS_REG_HISR);
5753         }
5754
5755         return (0);
5756 }
5757
5758 /****************************************************************************/
5759 /*                                                                          */
5760 /* Routine Name: ips_isintr_copperhead_memio                                */
5761 /*                                                                          */
5762 /* Routine Description:                                                     */
5763 /*                                                                          */
5764 /*   Test to see if an interrupt is for us                                  */
5765 /*                                                                          */
5766 /****************************************************************************/
5767 static int
5768 ips_isintr_copperhead_memio(ips_ha_t * ha)
5769 {
5770         uint8_t Isr;
5771
5772         METHOD_TRACE("ips_isintr_memio", 2);
5773
5774         Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5775
5776         if (Isr == 0xFF)
5777                 /* ?!?! Nothing really there */
5778                 return (0);
5779
5780         if (Isr & IPS_BIT_SCE)
5781                 return (1);
5782         else if (Isr & (IPS_BIT_SQO | IPS_BIT_GHI)) {
5783                 /* status queue overflow or GHI */
5784                 /* just clear the interrupt */
5785                 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5786         }
5787
5788         return (0);
5789 }
5790
5791 /****************************************************************************/
5792 /*                                                                          */
5793 /* Routine Name: ips_isintr_morpheus                                        */
5794 /*                                                                          */
5795 /* Routine Description:                                                     */
5796 /*                                                                          */
5797 /*   Test to see if an interrupt is for us                                  */
5798 /*                                                                          */
5799 /****************************************************************************/
5800 static int
5801 ips_isintr_morpheus(ips_ha_t * ha)
5802 {
5803         uint32_t Isr;
5804
5805         METHOD_TRACE("ips_isintr_morpheus", 2);
5806
5807         Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5808
5809         if (Isr & IPS_BIT_I2O_OPQI)
5810                 return (1);
5811         else
5812                 return (0);
5813 }
5814
5815 /****************************************************************************/
5816 /*                                                                          */
5817 /* Routine Name: ips_wait                                                   */
5818 /*                                                                          */
5819 /* Routine Description:                                                     */
5820 /*                                                                          */
5821 /*   Wait for a command to complete                                         */
5822 /*                                                                          */
5823 /****************************************************************************/
5824 static int
5825 ips_wait(ips_ha_t * ha, int time, int intr)
5826 {
5827         int ret;
5828         int done;
5829
5830         METHOD_TRACE("ips_wait", 1);
5831
5832         ret = IPS_FAILURE;
5833         done = FALSE;
5834
5835         time *= IPS_ONE_SEC;    /* convert seconds */
5836
5837         while ((time > 0) && (!done)) {
5838                 if (intr == IPS_INTR_ON) {
5839                         if (ha->waitflag == FALSE) {
5840                                 ret = IPS_SUCCESS;
5841                                 done = TRUE;
5842                                 break;
5843                         }
5844                 } else if (intr == IPS_INTR_IORL) {
5845                         if (ha->waitflag == FALSE) {
5846                                 /*
5847                                  * controller generated an interrupt to
5848                                  * acknowledge completion of the command
5849                                  * and ips_intr() has serviced the interrupt.
5850                                  */
5851                                 ret = IPS_SUCCESS;
5852                                 done = TRUE;
5853                                 break;
5854                         }
5855
5856                         /*
5857                          * NOTE: we already have the io_request_lock so
5858                          * even if we get an interrupt it won't get serviced
5859                          * until after we finish.
5860                          */
5861
5862                         (*ha->func.intr) (ha);
5863                 }
5864
5865                 /* This looks like a very evil loop, but it only does this during start-up */
5866                 udelay(1000);
5867                 time--;
5868         }
5869
5870         return (ret);
5871 }
5872
5873 /****************************************************************************/
5874 /*                                                                          */
5875 /* Routine Name: ips_write_driver_status                                    */
5876 /*                                                                          */
5877 /* Routine Description:                                                     */
5878 /*                                                                          */
5879 /*   Write OS/Driver version to Page 5 of the nvram on the controller       */
5880 /*                                                                          */
5881 /****************************************************************************/
5882 static int
5883 ips_write_driver_status(ips_ha_t * ha, int intr)
5884 {
5885         METHOD_TRACE("ips_write_driver_status", 1);
5886
5887         if (!ips_readwrite_page5(ha, FALSE, intr)) {
5888                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5889                            "unable to read NVRAM page 5.\n");
5890
5891                 return (0);
5892         }
5893
5894         /* check to make sure the page has a valid */
5895         /* signature */
5896         if (le32_to_cpu(ha->nvram->signature) != IPS_NVRAM_P5_SIG) {
5897                 DEBUG_VAR(1,
5898                           "(%s%d) NVRAM page 5 has an invalid signature: %X.",
5899                           ips_name, ha->host_num, ha->nvram->signature);
5900                 ha->nvram->signature = IPS_NVRAM_P5_SIG;
5901         }
5902
5903         DEBUG_VAR(2,
5904                   "(%s%d) Ad Type: %d, Ad Slot: %d, BIOS: %c%c%c%c %c%c%c%c.",
5905                   ips_name, ha->host_num, le16_to_cpu(ha->nvram->adapter_type),
5906                   ha->nvram->adapter_slot, ha->nvram->bios_high[0],
5907                   ha->nvram->bios_high[1], ha->nvram->bios_high[2],
5908                   ha->nvram->bios_high[3], ha->nvram->bios_low[0],
5909                   ha->nvram->bios_low[1], ha->nvram->bios_low[2],
5910                   ha->nvram->bios_low[3]);
5911
5912         ips_get_bios_version(ha, intr);
5913
5914         /* change values (as needed) */
5915         ha->nvram->operating_system = IPS_OS_LINUX;
5916         ha->nvram->adapter_type = ha->ad_type;
5917         strncpy((char *) ha->nvram->driver_high, IPS_VERSION_HIGH, 4);
5918         strncpy((char *) ha->nvram->driver_low, IPS_VERSION_LOW, 4);
5919         strncpy((char *) ha->nvram->bios_high, ha->bios_version, 4);
5920         strncpy((char *) ha->nvram->bios_low, ha->bios_version + 4, 4);
5921
5922         ha->nvram->versioning = 0;      /* Indicate the Driver Does Not Support Versioning */
5923
5924         /* now update the page */
5925         if (!ips_readwrite_page5(ha, TRUE, intr)) {
5926                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5927                            "unable to write NVRAM page 5.\n");
5928
5929                 return (0);
5930         }
5931
5932         /* IF NVRAM Page 5 is OK, Use it for Slot Number Info Because Linux Doesn't Do Slots */
5933         ha->slot_num = ha->nvram->adapter_slot;
5934
5935         return (1);
5936 }
5937
5938 /****************************************************************************/
5939 /*                                                                          */
5940 /* Routine Name: ips_read_adapter_status                                    */
5941 /*                                                                          */
5942 /* Routine Description:                                                     */
5943 /*                                                                          */
5944 /*   Do an Inquiry command to the adapter                                   */
5945 /*                                                                          */
5946 /****************************************************************************/
5947 static int
5948 ips_read_adapter_status(ips_ha_t * ha, int intr)
5949 {
5950         ips_scb_t *scb;
5951         int ret;
5952
5953         METHOD_TRACE("ips_read_adapter_status", 1);
5954
5955         scb = &ha->scbs[ha->max_cmds - 1];
5956
5957         ips_init_scb(ha, scb);
5958
5959         scb->timeout = ips_cmd_timeout;
5960         scb->cdb[0] = IPS_CMD_ENQUIRY;
5961
5962         scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
5963         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5964         scb->cmd.basic_io.sg_count = 0;
5965         scb->cmd.basic_io.lba = 0;
5966         scb->cmd.basic_io.sector_count = 0;
5967         scb->cmd.basic_io.log_drv = 0;
5968         scb->data_len = sizeof (*ha->enq);
5969         scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
5970
5971         /* send command */
5972         if (((ret =
5973               ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5974             || (ret == IPS_SUCCESS_IMM)
5975             || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5976                 return (0);
5977
5978         return (1);
5979 }
5980
5981 /****************************************************************************/
5982 /*                                                                          */
5983 /* Routine Name: ips_read_subsystem_parameters                              */
5984 /*                                                                          */
5985 /* Routine Description:                                                     */
5986 /*                                                                          */
5987 /*   Read subsystem parameters from the adapter                             */
5988 /*                                                                          */
5989 /****************************************************************************/
5990 static int
5991 ips_read_subsystem_parameters(ips_ha_t * ha, int intr)
5992 {
5993         ips_scb_t *scb;
5994         int ret;
5995
5996         METHOD_TRACE("ips_read_subsystem_parameters", 1);
5997
5998         scb = &ha->scbs[ha->max_cmds - 1];
5999
6000         ips_init_scb(ha, scb);
6001
6002         scb->timeout = ips_cmd_timeout;
6003         scb->cdb[0] = IPS_CMD_GET_SUBSYS;
6004
6005         scb->cmd.basic_io.op_code = IPS_CMD_GET_SUBSYS;
6006         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
6007         scb->cmd.basic_io.sg_count = 0;
6008         scb->cmd.basic_io.lba = 0;
6009         scb->cmd.basic_io.sector_count = 0;
6010         scb->cmd.basic_io.log_drv = 0;
6011         scb->data_len = sizeof (*ha->subsys);
6012         scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
6013
6014         /* send command */
6015         if (((ret =
6016               ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6017             || (ret == IPS_SUCCESS_IMM)
6018             || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6019                 return (0);
6020
6021         memcpy(ha->subsys, ha->ioctl_data, sizeof(*ha->subsys));
6022         return (1);
6023 }
6024
6025 /****************************************************************************/
6026 /*                                                                          */
6027 /* Routine Name: ips_read_config                                            */
6028 /*                                                                          */
6029 /* Routine Description:                                                     */
6030 /*                                                                          */
6031 /*   Read the configuration on the adapter                                  */
6032 /*                                                                          */
6033 /****************************************************************************/
6034 static int
6035 ips_read_config(ips_ha_t * ha, int intr)
6036 {
6037         ips_scb_t *scb;
6038         int i;
6039         int ret;
6040
6041         METHOD_TRACE("ips_read_config", 1);
6042
6043         /* set defaults for initiator IDs */
6044         for (i = 0; i < 4; i++)
6045                 ha->conf->init_id[i] = 7;
6046
6047         scb = &ha->scbs[ha->max_cmds - 1];
6048
6049         ips_init_scb(ha, scb);
6050
6051         scb->timeout = ips_cmd_timeout;
6052         scb->cdb[0] = IPS_CMD_READ_CONF;
6053
6054         scb->cmd.basic_io.op_code = IPS_CMD_READ_CONF;
6055         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
6056         scb->data_len = sizeof (*ha->conf);
6057         scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
6058
6059         /* send command */
6060         if (((ret =
6061               ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6062             || (ret == IPS_SUCCESS_IMM)
6063             || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
6064
6065                 memset(ha->conf, 0, sizeof (IPS_CONF));
6066
6067                 /* reset initiator IDs */
6068                 for (i = 0; i < 4; i++)
6069                         ha->conf->init_id[i] = 7;
6070
6071                 /* Allow Completed with Errors, so JCRM can access the Adapter to fix the problems */
6072                 if ((scb->basic_status & IPS_GSC_STATUS_MASK) ==
6073                     IPS_CMD_CMPLT_WERROR)
6074                         return (1);
6075
6076                 return (0);
6077         }
6078
6079         memcpy(ha->conf, ha->ioctl_data, sizeof(*ha->conf));
6080         return (1);
6081 }
6082
6083 /****************************************************************************/
6084 /*                                                                          */
6085 /* Routine Name: ips_readwrite_page5                                        */
6086 /*                                                                          */
6087 /* Routine Description:                                                     */
6088 /*                                                                          */
6089 /*   Read nvram page 5 from the adapter                                     */
6090 /*                                                                          */
6091 /****************************************************************************/
6092 static int
6093 ips_readwrite_page5(ips_ha_t * ha, int write, int intr)
6094 {
6095         ips_scb_t *scb;
6096         int ret;
6097
6098         METHOD_TRACE("ips_readwrite_page5", 1);
6099
6100         scb = &ha->scbs[ha->max_cmds - 1];
6101
6102         ips_init_scb(ha, scb);
6103
6104         scb->timeout = ips_cmd_timeout;
6105         scb->cdb[0] = IPS_CMD_RW_NVRAM_PAGE;
6106
6107         scb->cmd.nvram.op_code = IPS_CMD_RW_NVRAM_PAGE;
6108         scb->cmd.nvram.command_id = IPS_COMMAND_ID(ha, scb);
6109         scb->cmd.nvram.page = 5;
6110         scb->cmd.nvram.write = write;
6111         scb->cmd.nvram.reserved = 0;
6112         scb->cmd.nvram.reserved2 = 0;
6113         scb->data_len = sizeof (*ha->nvram);
6114         scb->cmd.nvram.buffer_addr = ha->ioctl_busaddr;
6115         if (write)
6116                 memcpy(ha->ioctl_data, ha->nvram, sizeof(*ha->nvram));
6117
6118         /* issue the command */
6119         if (((ret =
6120               ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6121             || (ret == IPS_SUCCESS_IMM)
6122             || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
6123
6124                 memset(ha->nvram, 0, sizeof (IPS_NVRAM_P5));
6125
6126                 return (0);
6127         }
6128         if (!write)
6129                 memcpy(ha->nvram, ha->ioctl_data, sizeof(*ha->nvram));
6130         return (1);
6131 }
6132
6133 /****************************************************************************/
6134 /*                                                                          */
6135 /* Routine Name: ips_clear_adapter                                          */
6136 /*                                                                          */
6137 /* Routine Description:                                                     */
6138 /*                                                                          */
6139 /*   Clear the stripe lock tables                                           */
6140 /*                                                                          */
6141 /****************************************************************************/
6142 static int
6143 ips_clear_adapter(ips_ha_t * ha, int intr)
6144 {
6145         ips_scb_t *scb;
6146         int ret;
6147
6148         METHOD_TRACE("ips_clear_adapter", 1);
6149
6150         scb = &ha->scbs[ha->max_cmds - 1];
6151
6152         ips_init_scb(ha, scb);
6153
6154         scb->timeout = ips_reset_timeout;
6155         scb->cdb[0] = IPS_CMD_CONFIG_SYNC;
6156
6157         scb->cmd.config_sync.op_code = IPS_CMD_CONFIG_SYNC;
6158         scb->cmd.config_sync.command_id = IPS_COMMAND_ID(ha, scb);
6159         scb->cmd.config_sync.channel = 0;
6160         scb->cmd.config_sync.source_target = IPS_POCL;
6161         scb->cmd.config_sync.reserved = 0;
6162         scb->cmd.config_sync.reserved2 = 0;
6163         scb->cmd.config_sync.reserved3 = 0;
6164
6165         /* issue command */
6166         if (((ret =
6167               ips_send_wait(ha, scb, ips_reset_timeout, intr)) == IPS_FAILURE)
6168             || (ret == IPS_SUCCESS_IMM)
6169             || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6170                 return (0);
6171
6172         /* send unlock stripe command */
6173         ips_init_scb(ha, scb);
6174
6175         scb->cdb[0] = IPS_CMD_ERROR_TABLE;
6176         scb->timeout = ips_reset_timeout;
6177
6178         scb->cmd.unlock_stripe.op_code = IPS_CMD_ERROR_TABLE;
6179         scb->cmd.unlock_stripe.command_id = IPS_COMMAND_ID(ha, scb);
6180         scb->cmd.unlock_stripe.log_drv = 0;
6181         scb->cmd.unlock_stripe.control = IPS_CSL;
6182         scb->cmd.unlock_stripe.reserved = 0;
6183         scb->cmd.unlock_stripe.reserved2 = 0;
6184         scb->cmd.unlock_stripe.reserved3 = 0;
6185
6186         /* issue command */
6187         if (((ret =
6188               ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6189             || (ret == IPS_SUCCESS_IMM)
6190             || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6191                 return (0);
6192
6193         return (1);
6194 }
6195
6196 /****************************************************************************/
6197 /*                                                                          */
6198 /* Routine Name: ips_ffdc_reset                                             */
6199 /*                                                                          */
6200 /* Routine Description:                                                     */
6201 /*                                                                          */
6202 /*   FFDC: write reset info                                                 */
6203 /*                                                                          */
6204 /****************************************************************************/
6205 static void
6206 ips_ffdc_reset(ips_ha_t * ha, int intr)
6207 {
6208         ips_scb_t *scb;
6209
6210         METHOD_TRACE("ips_ffdc_reset", 1);
6211
6212         scb = &ha->scbs[ha->max_cmds - 1];
6213
6214         ips_init_scb(ha, scb);
6215
6216         scb->timeout = ips_cmd_timeout;
6217         scb->cdb[0] = IPS_CMD_FFDC;
6218         scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
6219         scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
6220         scb->cmd.ffdc.reset_count = ha->reset_count;
6221         scb->cmd.ffdc.reset_type = 0x80;
6222
6223         /* convert time to what the card wants */
6224         ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
6225
6226         /* issue command */
6227         ips_send_wait(ha, scb, ips_cmd_timeout, intr);
6228 }
6229
6230 /****************************************************************************/
6231 /*                                                                          */
6232 /* Routine Name: ips_ffdc_time                                              */
6233 /*                                                                          */
6234 /* Routine Description:                                                     */
6235 /*                                                                          */
6236 /*   FFDC: write time info                                                  */
6237 /*                                                                          */
6238 /****************************************************************************/
6239 static void
6240 ips_ffdc_time(ips_ha_t * ha)
6241 {
6242         ips_scb_t *scb;
6243
6244         METHOD_TRACE("ips_ffdc_time", 1);
6245
6246         DEBUG_VAR(1, "(%s%d) Sending time update.", ips_name, ha->host_num);
6247
6248         scb = &ha->scbs[ha->max_cmds - 1];
6249
6250         ips_init_scb(ha, scb);
6251
6252         scb->timeout = ips_cmd_timeout;
6253         scb->cdb[0] = IPS_CMD_FFDC;
6254         scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
6255         scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
6256         scb->cmd.ffdc.reset_count = 0;
6257         scb->cmd.ffdc.reset_type = 0;
6258
6259         /* convert time to what the card wants */
6260         ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
6261
6262         /* issue command */
6263         ips_send_wait(ha, scb, ips_cmd_timeout, IPS_FFDC);
6264 }
6265
6266 /****************************************************************************/
6267 /*                                                                          */
6268 /* Routine Name: ips_fix_ffdc_time                                          */
6269 /*                                                                          */
6270 /* Routine Description:                                                     */
6271 /*   Adjust time_t to what the card wants                                   */
6272 /*                                                                          */
6273 /****************************************************************************/
6274 static void
6275 ips_fix_ffdc_time(ips_ha_t * ha, ips_scb_t * scb, time_t current_time)
6276 {
6277         long days;
6278         long rem;
6279         int i;
6280         int year;
6281         int yleap;
6282         int year_lengths[2] = { IPS_DAYS_NORMAL_YEAR, IPS_DAYS_LEAP_YEAR };
6283         int month_lengths[12][2] = { {31, 31},
6284         {28, 29},
6285         {31, 31},
6286         {30, 30},
6287         {31, 31},
6288         {30, 30},
6289         {31, 31},
6290         {31, 31},
6291         {30, 30},
6292         {31, 31},
6293         {30, 30},
6294         {31, 31}
6295         };
6296
6297         METHOD_TRACE("ips_fix_ffdc_time", 1);
6298
6299         days = current_time / IPS_SECS_DAY;
6300         rem = current_time % IPS_SECS_DAY;
6301
6302         scb->cmd.ffdc.hour = (rem / IPS_SECS_HOUR);
6303         rem = rem % IPS_SECS_HOUR;
6304         scb->cmd.ffdc.minute = (rem / IPS_SECS_MIN);
6305         scb->cmd.ffdc.second = (rem % IPS_SECS_MIN);
6306
6307         year = IPS_EPOCH_YEAR;
6308         while (days < 0 || days >= year_lengths[yleap = IPS_IS_LEAP_YEAR(year)]) {
6309                 int newy;
6310
6311                 newy = year + (days / IPS_DAYS_NORMAL_YEAR);
6312                 if (days < 0)
6313                         --newy;
6314                 days -= (newy - year) * IPS_DAYS_NORMAL_YEAR +
6315                     IPS_NUM_LEAP_YEARS_THROUGH(newy - 1) -
6316                     IPS_NUM_LEAP_YEARS_THROUGH(year - 1);
6317                 year = newy;
6318         }
6319
6320         scb->cmd.ffdc.yearH = year / 100;
6321         scb->cmd.ffdc.yearL = year % 100;
6322
6323         for (i = 0; days >= month_lengths[i][yleap]; ++i)
6324                 days -= month_lengths[i][yleap];
6325
6326         scb->cmd.ffdc.month = i + 1;
6327         scb->cmd.ffdc.day = days + 1;
6328 }
6329
6330 /****************************************************************************
6331  * BIOS Flash Routines                                                      *
6332  ****************************************************************************/
6333
6334 /****************************************************************************/
6335 /*                                                                          */
6336 /* Routine Name: ips_erase_bios                                             */
6337 /*                                                                          */
6338 /* Routine Description:                                                     */
6339 /*   Erase the BIOS on the adapter                                          */
6340 /*                                                                          */
6341 /****************************************************************************/
6342 static int
6343 ips_erase_bios(ips_ha_t * ha)
6344 {
6345         int timeout;
6346         uint8_t status = 0;
6347
6348         METHOD_TRACE("ips_erase_bios", 1);
6349
6350         status = 0;
6351
6352         /* Clear the status register */
6353         outl(0, ha->io_addr + IPS_REG_FLAP);
6354         if (ha->revision_id == IPS_REVID_TROMBONE64)
6355                 udelay(25);     /* 25 us */
6356
6357         outb(0x50, ha->io_addr + IPS_REG_FLDP);
6358         if (ha->revision_id == IPS_REVID_TROMBONE64)
6359                 udelay(25);     /* 25 us */
6360
6361         /* Erase Setup */
6362         outb(0x20, ha->io_addr + IPS_REG_FLDP);
6363         if (ha->revision_id == IPS_REVID_TROMBONE64)
6364                 udelay(25);     /* 25 us */
6365
6366         /* Erase Confirm */
6367         outb(0xD0, ha->io_addr + IPS_REG_FLDP);
6368         if (ha->revision_id == IPS_REVID_TROMBONE64)
6369                 udelay(25);     /* 25 us */
6370
6371         /* Erase Status */
6372         outb(0x70, ha->io_addr + IPS_REG_FLDP);
6373         if (ha->revision_id == IPS_REVID_TROMBONE64)
6374                 udelay(25);     /* 25 us */
6375
6376         timeout = 80000;        /* 80 seconds */
6377
6378         while (timeout > 0) {
6379                 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6380                         outl(0, ha->io_addr + IPS_REG_FLAP);
6381                         udelay(25);     /* 25 us */
6382                 }
6383
6384                 status = inb(ha->io_addr + IPS_REG_FLDP);
6385
6386                 if (status & 0x80)
6387                         break;
6388
6389                 MDELAY(1);
6390                 timeout--;
6391         }
6392
6393         /* check for timeout */
6394         if (timeout <= 0) {
6395                 /* timeout */
6396
6397                 /* try to suspend the erase */
6398                 outb(0xB0, ha->io_addr + IPS_REG_FLDP);
6399                 if (ha->revision_id == IPS_REVID_TROMBONE64)
6400                         udelay(25);     /* 25 us */
6401
6402                 /* wait for 10 seconds */
6403                 timeout = 10000;
6404                 while (timeout > 0) {
6405                         if (ha->revision_id == IPS_REVID_TROMBONE64) {
6406                                 outl(0, ha->io_addr + IPS_REG_FLAP);
6407                                 udelay(25);     /* 25 us */
6408                         }
6409
6410                         status = inb(ha->io_addr + IPS_REG_FLDP);
6411
6412                         if (status & 0xC0)
6413                                 break;
6414
6415                         MDELAY(1);
6416                         timeout--;
6417                 }
6418
6419                 return (1);
6420         }
6421
6422         /* check for valid VPP */
6423         if (status & 0x08)
6424                 /* VPP failure */
6425                 return (1);
6426
6427         /* check for successful flash */
6428         if (status & 0x30)
6429                 /* sequence error */
6430                 return (1);
6431
6432         /* Otherwise, we were successful */
6433         /* clear status */
6434         outb(0x50, ha->io_addr + IPS_REG_FLDP);
6435         if (ha->revision_id == IPS_REVID_TROMBONE64)
6436                 udelay(25);     /* 25 us */
6437
6438         /* enable reads */
6439         outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6440         if (ha->revision_id == IPS_REVID_TROMBONE64)
6441                 udelay(25);     /* 25 us */
6442
6443         return (0);
6444 }
6445
6446 /****************************************************************************/
6447 /*                                                                          */
6448 /* Routine Name: ips_erase_bios_memio                                       */
6449 /*                                                                          */
6450 /* Routine Description:                                                     */
6451 /*   Erase the BIOS on the adapter                                          */
6452 /*                                                                          */
6453 /****************************************************************************/
6454 static int
6455 ips_erase_bios_memio(ips_ha_t * ha)
6456 {
6457         int timeout;
6458         uint8_t status;
6459
6460         METHOD_TRACE("ips_erase_bios_memio", 1);
6461
6462         status = 0;
6463
6464         /* Clear the status register */
6465         writel(0, ha->mem_ptr + IPS_REG_FLAP);
6466         if (ha->revision_id == IPS_REVID_TROMBONE64)
6467                 udelay(25);     /* 25 us */
6468
6469         writeb(0x50, ha->mem_ptr + IPS_REG_FLDP);
6470         if (ha->revision_id == IPS_REVID_TROMBONE64)
6471                 udelay(25);     /* 25 us */
6472
6473         /* Erase Setup */
6474         writeb(0x20, ha->mem_ptr + IPS_REG_FLDP);
6475         if (ha->revision_id == IPS_REVID_TROMBONE64)
6476                 udelay(25);     /* 25 us */
6477
6478         /* Erase Confirm */
6479         writeb(0xD0, ha->mem_ptr + IPS_REG_FLDP);
6480         if (ha->revision_id == IPS_REVID_TROMBONE64)
6481                 udelay(25);     /* 25 us */
6482
6483         /* Erase Status */
6484         writeb(0x70, ha->mem_ptr + IPS_REG_FLDP);
6485         if (ha->revision_id == IPS_REVID_TROMBONE64)
6486                 udelay(25);     /* 25 us */
6487
6488         timeout = 80000;        /* 80 seconds */
6489
6490         while (timeout > 0) {
6491                 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6492                         writel(0, ha->mem_ptr + IPS_REG_FLAP);
6493                         udelay(25);     /* 25 us */
6494                 }
6495
6496                 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6497
6498                 if (status & 0x80)
6499                         break;
6500
6501                 MDELAY(1);
6502                 timeout--;
6503         }
6504
6505         /* check for timeout */
6506         if (timeout <= 0) {
6507                 /* timeout */
6508
6509                 /* try to suspend the erase */
6510                 writeb(0xB0, ha->mem_ptr + IPS_REG_FLDP);
6511                 if (ha->revision_id == IPS_REVID_TROMBONE64)
6512                         udelay(25);     /* 25 us */
6513
6514                 /* wait for 10 seconds */
6515                 timeout = 10000;
6516                 while (timeout > 0) {
6517                         if (ha->revision_id == IPS_REVID_TROMBONE64) {
6518                                 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6519                                 udelay(25);     /* 25 us */
6520                         }
6521
6522                         status = readb(ha->mem_ptr + IPS_REG_FLDP);
6523
6524                         if (status & 0xC0)
6525                                 break;
6526
6527                         MDELAY(1);
6528                         timeout--;
6529                 }
6530
6531                 return (1);
6532         }
6533
6534         /* check for valid VPP */
6535         if (status & 0x08)
6536                 /* VPP failure */
6537                 return (1);
6538
6539         /* check for successful flash */
6540         if (status & 0x30)
6541                 /* sequence error */
6542                 return (1);
6543
6544         /* Otherwise, we were successful */
6545         /* clear status */
6546         writeb(0x50, ha->mem_ptr + IPS_REG_FLDP);
6547         if (ha->revision_id == IPS_REVID_TROMBONE64)
6548                 udelay(25);     /* 25 us */
6549
6550         /* enable reads */
6551         writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6552         if (ha->revision_id == IPS_REVID_TROMBONE64)
6553                 udelay(25);     /* 25 us */
6554
6555         return (0);
6556 }
6557
6558 /****************************************************************************/
6559 /*                                                                          */
6560 /* Routine Name: ips_program_bios                                           */
6561 /*                                                                          */
6562 /* Routine Description:                                                     */
6563 /*   Program the BIOS on the adapter                                        */
6564 /*                                                                          */
6565 /****************************************************************************/
6566 static int
6567 ips_program_bios(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6568                  uint32_t offset)
6569 {
6570         int i;
6571         int timeout;
6572         uint8_t status = 0;
6573
6574         METHOD_TRACE("ips_program_bios", 1);
6575
6576         status = 0;
6577
6578         for (i = 0; i < buffersize; i++) {
6579                 /* write a byte */
6580                 outl(cpu_to_le32(i + offset), ha->io_addr + IPS_REG_FLAP);
6581                 if (ha->revision_id == IPS_REVID_TROMBONE64)
6582                         udelay(25);     /* 25 us */
6583
6584                 outb(0x40, ha->io_addr + IPS_REG_FLDP);
6585                 if (ha->revision_id == IPS_REVID_TROMBONE64)
6586                         udelay(25);     /* 25 us */
6587
6588                 outb(buffer[i], ha->io_addr + IPS_REG_FLDP);
6589                 if (ha->revision_id == IPS_REVID_TROMBONE64)
6590                         udelay(25);     /* 25 us */
6591
6592                 /* wait up to one second */
6593                 timeout = 1000;
6594                 while (timeout > 0) {
6595                         if (ha->revision_id == IPS_REVID_TROMBONE64) {
6596                                 outl(0, ha->io_addr + IPS_REG_FLAP);
6597                                 udelay(25);     /* 25 us */
6598                         }
6599
6600                         status = inb(ha->io_addr + IPS_REG_FLDP);
6601
6602                         if (status & 0x80)
6603                                 break;
6604
6605                         MDELAY(1);
6606                         timeout--;
6607                 }
6608
6609                 if (timeout == 0) {
6610                         /* timeout error */
6611                         outl(0, ha->io_addr + IPS_REG_FLAP);
6612                         if (ha->revision_id == IPS_REVID_TROMBONE64)
6613                                 udelay(25);     /* 25 us */
6614
6615                         outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6616                         if (ha->revision_id == IPS_REVID_TROMBONE64)
6617                                 udelay(25);     /* 25 us */
6618
6619                         return (1);
6620                 }
6621
6622                 /* check the status */
6623                 if (status & 0x18) {
6624                         /* programming error */
6625                         outl(0, ha->io_addr + IPS_REG_FLAP);
6626                         if (ha->revision_id == IPS_REVID_TROMBONE64)
6627                                 udelay(25);     /* 25 us */
6628
6629                         outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6630                         if (ha->revision_id == IPS_REVID_TROMBONE64)
6631                                 udelay(25);     /* 25 us */
6632
6633                         return (1);
6634                 }
6635         }                       /* end for */
6636
6637         /* Enable reading */
6638         outl(0, ha->io_addr + IPS_REG_FLAP);
6639         if (ha->revision_id == IPS_REVID_TROMBONE64)
6640                 udelay(25);     /* 25 us */
6641
6642         outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6643         if (ha->revision_id == IPS_REVID_TROMBONE64)
6644                 udelay(25);     /* 25 us */
6645
6646         return (0);
6647 }
6648
6649 /****************************************************************************/
6650 /*                                                                          */
6651 /* Routine Name: ips_program_bios_memio                                     */
6652 /*                                                                          */
6653 /* Routine Description:                                                     */
6654 /*   Program the BIOS on the adapter                                        */
6655 /*                                                                          */
6656 /****************************************************************************/
6657 static int
6658 ips_program_bios_memio(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6659                        uint32_t offset)
6660 {
6661         int i;
6662         int timeout;
6663         uint8_t status = 0;
6664
6665         METHOD_TRACE("ips_program_bios_memio", 1);
6666
6667         status = 0;
6668
6669         for (i = 0; i < buffersize; i++) {
6670                 /* write a byte */
6671                 writel(i + offset, ha->mem_ptr + IPS_REG_FLAP);
6672                 if (ha->revision_id == IPS_REVID_TROMBONE64)
6673                         udelay(25);     /* 25 us */
6674
6675                 writeb(0x40, ha->mem_ptr + IPS_REG_FLDP);
6676                 if (ha->revision_id == IPS_REVID_TROMBONE64)
6677                         udelay(25);     /* 25 us */
6678
6679                 writeb(buffer[i], ha->mem_ptr + IPS_REG_FLDP);
6680                 if (ha->revision_id == IPS_REVID_TROMBONE64)
6681                         udelay(25);     /* 25 us */
6682
6683                 /* wait up to one second */
6684                 timeout = 1000;
6685                 while (timeout > 0) {
6686                         if (ha->revision_id == IPS_REVID_TROMBONE64) {
6687                                 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6688                                 udelay(25);     /* 25 us */
6689                         }
6690
6691                         status = readb(ha->mem_ptr + IPS_REG_FLDP);
6692
6693                         if (status & 0x80)
6694                                 break;
6695
6696                         MDELAY(1);
6697                         timeout--;
6698                 }
6699
6700                 if (timeout == 0) {
6701                         /* timeout error */
6702                         writel(0, ha->mem_ptr + IPS_REG_FLAP);
6703                         if (ha->revision_id == IPS_REVID_TROMBONE64)
6704                                 udelay(25);     /* 25 us */
6705
6706                         writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6707                         if (ha->revision_id == IPS_REVID_TROMBONE64)
6708                                 udelay(25);     /* 25 us */
6709
6710                         return (1);
6711                 }
6712
6713                 /* check the status */
6714                 if (status & 0x18) {
6715                         /* programming error */
6716                         writel(0, ha->mem_ptr + IPS_REG_FLAP);
6717                         if (ha->revision_id == IPS_REVID_TROMBONE64)
6718                                 udelay(25);     /* 25 us */
6719
6720                         writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6721                         if (ha->revision_id == IPS_REVID_TROMBONE64)
6722                                 udelay(25);     /* 25 us */
6723
6724                         return (1);
6725                 }
6726         }                       /* end for */
6727
6728         /* Enable reading */
6729         writel(0, ha->mem_ptr + IPS_REG_FLAP);
6730         if (ha->revision_id == IPS_REVID_TROMBONE64)
6731                 udelay(25);     /* 25 us */
6732
6733         writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6734         if (ha->revision_id == IPS_REVID_TROMBONE64)
6735                 udelay(25);     /* 25 us */
6736
6737         return (0);
6738 }
6739
6740 /****************************************************************************/
6741 /*                                                                          */
6742 /* Routine Name: ips_verify_bios                                            */
6743 /*                                                                          */
6744 /* Routine Description:                                                     */
6745 /*   Verify the BIOS on the adapter                                         */
6746 /*                                                                          */
6747 /****************************************************************************/
6748 static int
6749 ips_verify_bios(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6750                 uint32_t offset)
6751 {
6752         uint8_t checksum;
6753         int i;
6754
6755         METHOD_TRACE("ips_verify_bios", 1);
6756
6757         /* test 1st byte */
6758         outl(0, ha->io_addr + IPS_REG_FLAP);
6759         if (ha->revision_id == IPS_REVID_TROMBONE64)
6760                 udelay(25);     /* 25 us */
6761
6762         if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
6763                 return (1);
6764
6765         outl(cpu_to_le32(1), ha->io_addr + IPS_REG_FLAP);
6766         if (ha->revision_id == IPS_REVID_TROMBONE64)
6767                 udelay(25);     /* 25 us */
6768         if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
6769                 return (1);
6770
6771         checksum = 0xff;
6772         for (i = 2; i < buffersize; i++) {
6773
6774                 outl(cpu_to_le32(i + offset), ha->io_addr + IPS_REG_FLAP);
6775                 if (ha->revision_id == IPS_REVID_TROMBONE64)
6776                         udelay(25);     /* 25 us */
6777
6778                 checksum = (uint8_t) checksum + inb(ha->io_addr + IPS_REG_FLDP);
6779         }
6780
6781         if (checksum != 0)
6782                 /* failure */
6783                 return (1);
6784         else
6785                 /* success */
6786                 return (0);
6787 }
6788
6789 /****************************************************************************/
6790 /*                                                                          */
6791 /* Routine Name: ips_verify_bios_memio                                      */
6792 /*                                                                          */
6793 /* Routine Description:                                                     */
6794 /*   Verify the BIOS on the adapter                                         */
6795 /*                                                                          */
6796 /****************************************************************************/
6797 static int
6798 ips_verify_bios_memio(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6799                       uint32_t offset)
6800 {
6801         uint8_t checksum;
6802         int i;
6803
6804         METHOD_TRACE("ips_verify_bios_memio", 1);
6805
6806         /* test 1st byte */
6807         writel(0, ha->mem_ptr + IPS_REG_FLAP);
6808         if (ha->revision_id == IPS_REVID_TROMBONE64)
6809                 udelay(25);     /* 25 us */
6810
6811         if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
6812                 return (1);
6813
6814         writel(1, ha->mem_ptr + IPS_REG_FLAP);
6815         if (ha->revision_id == IPS_REVID_TROMBONE64)
6816                 udelay(25);     /* 25 us */
6817         if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
6818                 return (1);
6819
6820         checksum = 0xff;
6821         for (i = 2; i < buffersize; i++) {
6822
6823                 writel(i + offset, ha->mem_ptr + IPS_REG_FLAP);
6824                 if (ha->revision_id == IPS_REVID_TROMBONE64)
6825                         udelay(25);     /* 25 us */
6826
6827                 checksum =
6828                     (uint8_t) checksum + readb(ha->mem_ptr + IPS_REG_FLDP);
6829         }
6830
6831         if (checksum != 0)
6832                 /* failure */
6833                 return (1);
6834         else
6835                 /* success */
6836                 return (0);
6837 }
6838
6839 /****************************************************************************/
6840 /*                                                                          */
6841 /* Routine Name: ips_abort_init                                             */
6842 /*                                                                          */
6843 /* Routine Description:                                                     */
6844 /*   cleanup routine for a failed adapter initialization                    */
6845 /****************************************************************************/
6846 static int
6847 ips_abort_init(ips_ha_t * ha, int index)
6848 {
6849         ha->active = 0;
6850         ips_free(ha);
6851         ips_ha[index] = NULL;
6852         ips_sh[index] = NULL;
6853         return -1;
6854 }
6855
6856 /****************************************************************************/
6857 /*                                                                          */
6858 /* Routine Name: ips_shift_controllers                                      */
6859 /*                                                                          */
6860 /* Routine Description:                                                     */
6861 /*   helper function for ordering adapters                                  */
6862 /****************************************************************************/
6863 static void
6864 ips_shift_controllers(int lowindex, int highindex)
6865 {
6866         ips_ha_t *ha_sav = ips_ha[highindex];
6867         struct Scsi_Host *sh_sav = ips_sh[highindex];
6868         int i;
6869
6870         for (i = highindex; i > lowindex; i--) {
6871                 ips_ha[i] = ips_ha[i - 1];
6872                 ips_sh[i] = ips_sh[i - 1];
6873                 ips_ha[i]->host_num = i;
6874         }
6875         ha_sav->host_num = lowindex;
6876         ips_ha[lowindex] = ha_sav;
6877         ips_sh[lowindex] = sh_sav;
6878 }
6879
6880 /****************************************************************************/
6881 /*                                                                          */
6882 /* Routine Name: ips_order_controllers                                      */
6883 /*                                                                          */
6884 /* Routine Description:                                                     */
6885 /*   place controllers is the "proper" boot order                           */
6886 /****************************************************************************/
6887 static void
6888 ips_order_controllers(void)
6889 {
6890         int i, j, tmp, position = 0;
6891         IPS_NVRAM_P5 *nvram;
6892         if (!ips_ha[0])
6893                 return;
6894         nvram = ips_ha[0]->nvram;
6895
6896         if (nvram->adapter_order[0]) {
6897                 for (i = 1; i <= nvram->adapter_order[0]; i++) {
6898                         for (j = position; j < ips_num_controllers; j++) {
6899                                 switch (ips_ha[j]->ad_type) {
6900                                 case IPS_ADTYPE_SERVERAID6M:
6901                                 case IPS_ADTYPE_SERVERAID7M:
6902                                         if (nvram->adapter_order[i] == 'M') {
6903                                                 ips_shift_controllers(position,
6904                                                                       j);
6905                                                 position++;
6906                                         }
6907                                         break;
6908                                 case IPS_ADTYPE_SERVERAID4L:
6909                                 case IPS_ADTYPE_SERVERAID4M:
6910                                 case IPS_ADTYPE_SERVERAID4MX:
6911                                 case IPS_ADTYPE_SERVERAID4LX:
6912                                         if (nvram->adapter_order[i] == 'N') {
6913                                                 ips_shift_controllers(position,
6914                                                                       j);
6915                                                 position++;
6916                                         }
6917                                         break;
6918                                 case IPS_ADTYPE_SERVERAID6I:
6919                                 case IPS_ADTYPE_SERVERAID5I2:
6920                                 case IPS_ADTYPE_SERVERAID5I1:
6921                                 case IPS_ADTYPE_SERVERAID7k:
6922                                         if (nvram->adapter_order[i] == 'S') {
6923                                                 ips_shift_controllers(position,
6924                                                                       j);
6925                                                 position++;
6926                                         }
6927                                         break;
6928                                 case IPS_ADTYPE_SERVERAID:
6929                                 case IPS_ADTYPE_SERVERAID2:
6930                                 case IPS_ADTYPE_NAVAJO:
6931                                 case IPS_ADTYPE_KIOWA:
6932                                 case IPS_ADTYPE_SERVERAID3L:
6933                                 case IPS_ADTYPE_SERVERAID3:
6934                                 case IPS_ADTYPE_SERVERAID4H:
6935                                         if (nvram->adapter_order[i] == 'A') {
6936                                                 ips_shift_controllers(position,
6937                                                                       j);
6938                                                 position++;
6939                                         }
6940                                         break;
6941                                 default:
6942                                         break;
6943                                 }
6944                         }
6945                 }
6946                 /* if adapter_order[0], then ordering is complete */
6947                 return;
6948         }
6949         /* old bios, use older ordering */
6950         tmp = 0;
6951         for (i = position; i < ips_num_controllers; i++) {
6952                 if (ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID5I2 ||
6953                     ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID5I1) {
6954                         ips_shift_controllers(position, i);
6955                         position++;
6956                         tmp = 1;
6957                 }
6958         }
6959         /* if there were no 5I cards, then don't do any extra ordering */
6960         if (!tmp)
6961                 return;
6962         for (i = position; i < ips_num_controllers; i++) {
6963                 if (ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4L ||
6964                     ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4M ||
6965                     ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4LX ||
6966                     ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4MX) {
6967                         ips_shift_controllers(position, i);
6968                         position++;
6969                 }
6970         }
6971
6972         return;
6973 }
6974
6975 /****************************************************************************/
6976 /*                                                                          */
6977 /* Routine Name: ips_register_scsi                                          */
6978 /*                                                                          */
6979 /* Routine Description:                                                     */
6980 /*   perform any registration and setup with the scsi layer                 */
6981 /****************************************************************************/
6982 static int
6983 ips_register_scsi(int index)
6984 {
6985         struct Scsi_Host *sh;
6986         ips_ha_t *ha, *oldha = ips_ha[index];
6987         sh = scsi_host_alloc(&ips_driver_template, sizeof (ips_ha_t));
6988         if (!sh) {
6989                 IPS_PRINTK(KERN_WARNING, oldha->pcidev,
6990                            "Unable to register controller with SCSI subsystem\n");
6991                 return -1;
6992         }
6993         ha = IPS_HA(sh);
6994         memcpy(ha, oldha, sizeof (ips_ha_t));
6995         free_irq(oldha->irq, oldha);
6996         /* Install the interrupt handler with the new ha */
6997         if (request_irq(ha->irq, do_ipsintr, IRQF_SHARED, ips_name, ha)) {
6998                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
6999                            "Unable to install interrupt handler\n");
7000                 scsi_host_put(sh);
7001                 return -1;
7002         }
7003
7004         kfree(oldha);
7005         ips_sh[index] = sh;
7006         ips_ha[index] = ha;
7007         IPS_SCSI_SET_DEVICE(sh, ha);
7008
7009         /* Store away needed values for later use */
7010         sh->io_port = ha->io_addr;
7011         sh->n_io_port = ha->io_addr ? 255 : 0;
7012         sh->unique_id = (ha->io_addr) ? ha->io_addr : ha->mem_addr;
7013         sh->irq = ha->irq;
7014         sh->sg_tablesize = sh->hostt->sg_tablesize;
7015         sh->can_queue = sh->hostt->can_queue;
7016         sh->cmd_per_lun = sh->hostt->cmd_per_lun;
7017         sh->unchecked_isa_dma = sh->hostt->unchecked_isa_dma;
7018         sh->use_clustering = sh->hostt->use_clustering;
7019
7020 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,7)
7021         sh->max_sectors = 128;
7022 #endif
7023
7024         sh->max_id = ha->ntargets;
7025         sh->max_lun = ha->nlun;
7026         sh->max_channel = ha->nbus - 1;
7027         sh->can_queue = ha->max_cmds - 1;
7028
7029         IPS_ADD_HOST(sh, NULL);
7030         return 0;
7031 }
7032
7033 /*---------------------------------------------------------------------------*/
7034 /*   Routine Name: ips_remove_device                                         */
7035 /*                                                                           */
7036 /*   Routine Description:                                                    */
7037 /*     Remove one Adapter ( Hot Plugging )                                   */
7038 /*---------------------------------------------------------------------------*/
7039 static void __devexit
7040 ips_remove_device(struct pci_dev *pci_dev)
7041 {
7042         int i;
7043         struct Scsi_Host *sh;
7044         ips_ha_t *ha;
7045
7046         for (i = 0; i < IPS_MAX_ADAPTERS; i++) {
7047                 ha = ips_ha[i];
7048                 if (ha) {
7049                         if ((pci_dev->bus->number == ha->pcidev->bus->number) &&
7050                             (pci_dev->devfn == ha->pcidev->devfn)) {
7051                                 sh = ips_sh[i];
7052                                 ips_release(sh);
7053                         }
7054                 }
7055         }
7056 }
7057
7058 /****************************************************************************/
7059 /*                                                                          */
7060 /* Routine Name: ips_module_init                                            */
7061 /*                                                                          */
7062 /* Routine Description:                                                     */
7063 /*   function called on module load                                         */
7064 /****************************************************************************/
7065 static int __init
7066 ips_module_init(void)
7067 {
7068         if (pci_register_driver(&ips_pci_driver) < 0)
7069                 return -ENODEV;
7070         ips_driver_template.module = THIS_MODULE;
7071         ips_order_controllers();
7072         if (IPS_REGISTER_HOSTS(&ips_driver_template)) {
7073                 pci_unregister_driver(&ips_pci_driver);
7074                 return -ENODEV;
7075         }
7076         register_reboot_notifier(&ips_notifier);
7077         return 0;
7078 }
7079
7080 /****************************************************************************/
7081 /*                                                                          */
7082 /* Routine Name: ips_module_exit                                            */
7083 /*                                                                          */
7084 /* Routine Description:                                                     */
7085 /*   function called on module unload                                       */
7086 /****************************************************************************/
7087 static void __exit
7088 ips_module_exit(void)
7089 {
7090         IPS_UNREGISTER_HOSTS(&ips_driver_template);
7091         pci_unregister_driver(&ips_pci_driver);
7092         unregister_reboot_notifier(&ips_notifier);
7093 }
7094
7095 module_init(ips_module_init);
7096 module_exit(ips_module_exit);
7097
7098 /*---------------------------------------------------------------------------*/
7099 /*   Routine Name: ips_insert_device                                         */
7100 /*                                                                           */
7101 /*   Routine Description:                                                    */
7102 /*     Add One Adapter ( Hot Plug )                                          */
7103 /*                                                                           */
7104 /*   Return Value:                                                           */
7105 /*     0 if Successful, else non-zero                                        */
7106 /*---------------------------------------------------------------------------*/
7107 static int __devinit
7108 ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent)
7109 {
7110         int index;
7111         int rc;
7112
7113         METHOD_TRACE("ips_insert_device", 1);
7114         if (pci_enable_device(pci_dev))
7115                 return -1;
7116
7117         rc = ips_init_phase1(pci_dev, &index);
7118         if (rc == SUCCESS)
7119                 rc = ips_init_phase2(index);
7120
7121         if (ips_hotplug)
7122                 if (ips_register_scsi(index)) {
7123                         ips_free(ips_ha[index]);
7124                         rc = -1;
7125                 }
7126
7127         if (rc == SUCCESS)
7128                 ips_num_controllers++;
7129
7130         ips_next_controller = ips_num_controllers;
7131         return rc;
7132 }
7133
7134 /*---------------------------------------------------------------------------*/
7135 /*   Routine Name: ips_init_phase1                                           */
7136 /*                                                                           */
7137 /*   Routine Description:                                                    */
7138 /*     Adapter Initialization                                                */
7139 /*                                                                           */
7140 /*   Return Value:                                                           */
7141 /*     0 if Successful, else non-zero                                        */
7142 /*---------------------------------------------------------------------------*/
7143 static int
7144 ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr)
7145 {
7146         ips_ha_t *ha;
7147         uint32_t io_addr;
7148         uint32_t mem_addr;
7149         uint32_t io_len;
7150         uint32_t mem_len;
7151         uint8_t revision_id;
7152         uint8_t bus;
7153         uint8_t func;
7154         uint8_t irq;
7155         uint16_t subdevice_id;
7156         int j;
7157         int index;
7158         dma_addr_t dma_address;
7159         char __iomem *ioremap_ptr;
7160         char __iomem *mem_ptr;
7161         uint32_t IsDead;
7162
7163         METHOD_TRACE("ips_init_phase1", 1);
7164         index = IPS_MAX_ADAPTERS;
7165         for (j = 0; j < IPS_MAX_ADAPTERS; j++) {
7166                 if (ips_ha[j] == 0) {
7167                         index = j;
7168                         break;
7169                 }
7170         }
7171
7172         if (index >= IPS_MAX_ADAPTERS)
7173                 return -1;
7174
7175         /* stuff that we get in dev */
7176         irq = pci_dev->irq;
7177         bus = pci_dev->bus->number;
7178         func = pci_dev->devfn;
7179
7180         /* Init MEM/IO addresses to 0 */
7181         mem_addr = 0;
7182         io_addr = 0;
7183         mem_len = 0;
7184         io_len = 0;
7185
7186         for (j = 0; j < 2; j++) {
7187                 if (!pci_resource_start(pci_dev, j))
7188                         break;
7189
7190                 if (pci_resource_flags(pci_dev, j) & IORESOURCE_IO) {
7191                         io_addr = pci_resource_start(pci_dev, j);
7192                         io_len = pci_resource_len(pci_dev, j);
7193                 } else {
7194                         mem_addr = pci_resource_start(pci_dev, j);
7195                         mem_len = pci_resource_len(pci_dev, j);
7196                 }
7197         }
7198
7199         /* setup memory mapped area (if applicable) */
7200         if (mem_addr) {
7201                 uint32_t base;
7202                 uint32_t offs;
7203
7204                 if (!request_mem_region(mem_addr, mem_len, "ips")) {
7205                         IPS_PRINTK(KERN_WARNING, pci_dev,
7206                                    "Couldn't allocate IO Memory space %x len %d.\n",
7207                                    mem_addr, mem_len);
7208                         return -1;
7209                 }
7210
7211                 base = mem_addr & PAGE_MASK;
7212                 offs = mem_addr - base;
7213                 ioremap_ptr = ioremap(base, PAGE_SIZE);
7214                 mem_ptr = ioremap_ptr + offs;
7215         } else {
7216                 ioremap_ptr = NULL;
7217                 mem_ptr = NULL;
7218         }
7219
7220         /* setup I/O mapped area (if applicable) */
7221         if (io_addr) {
7222                 if (!request_region(io_addr, io_len, "ips")) {
7223                         IPS_PRINTK(KERN_WARNING, pci_dev,
7224                                    "Couldn't allocate IO space %x len %d.\n",
7225                                    io_addr, io_len);
7226                         return -1;
7227                 }
7228         }
7229
7230         /* get the revision ID */
7231         if (pci_read_config_byte(pci_dev, PCI_REVISION_ID, &revision_id)) {
7232                 IPS_PRINTK(KERN_WARNING, pci_dev, "Can't get revision id.\n");
7233                 return -1;
7234         }
7235
7236         subdevice_id = pci_dev->subsystem_device;
7237
7238         /* found a controller */
7239         ha = kmalloc(sizeof (ips_ha_t), GFP_KERNEL);
7240         if (ha == NULL) {
7241                 IPS_PRINTK(KERN_WARNING, pci_dev,
7242                            "Unable to allocate temporary ha struct\n");
7243                 return -1;
7244         }
7245
7246         memset(ha, 0, sizeof (ips_ha_t));
7247
7248         ips_sh[index] = NULL;
7249         ips_ha[index] = ha;
7250         ha->active = 1;
7251
7252         /* Store info in HA structure */
7253         ha->irq = irq;
7254         ha->io_addr = io_addr;
7255         ha->io_len = io_len;
7256         ha->mem_addr = mem_addr;
7257         ha->mem_len = mem_len;
7258         ha->mem_ptr = mem_ptr;
7259         ha->ioremap_ptr = ioremap_ptr;
7260         ha->host_num = (uint32_t) index;
7261         ha->revision_id = revision_id;
7262         ha->slot_num = PCI_SLOT(pci_dev->devfn);
7263         ha->device_id = pci_dev->device;
7264         ha->subdevice_id = subdevice_id;
7265         ha->pcidev = pci_dev;
7266
7267         /*
7268          * Set the pci_dev's dma_mask.  Not all adapters support 64bit
7269          * addressing so don't enable it if the adapter can't support
7270          * it!  Also, don't use 64bit addressing if dma addresses
7271          * are guaranteed to be < 4G.
7272          */
7273         if (IPS_ENABLE_DMA64 && IPS_HAS_ENH_SGLIST(ha) &&
7274             !pci_set_dma_mask(ha->pcidev, DMA_64BIT_MASK)) {
7275                 (ha)->flags |= IPS_HA_ENH_SG;
7276         } else {
7277                 if (pci_set_dma_mask(ha->pcidev, DMA_32BIT_MASK) != 0) {
7278                         printk(KERN_WARNING "Unable to set DMA Mask\n");
7279                         return ips_abort_init(ha, index);
7280                 }
7281         }
7282         if(ips_cd_boot && !ips_FlashData){
7283                 ips_FlashData = pci_alloc_consistent(pci_dev, PAGE_SIZE << 7,
7284                                                      &ips_flashbusaddr);
7285         }
7286
7287         ha->enq = pci_alloc_consistent(pci_dev, sizeof (IPS_ENQ),
7288                                        &ha->enq_busaddr);
7289         if (!ha->enq) {
7290                 IPS_PRINTK(KERN_WARNING, pci_dev,
7291                            "Unable to allocate host inquiry structure\n");
7292                 return ips_abort_init(ha, index);
7293         }
7294
7295         ha->adapt = pci_alloc_consistent(pci_dev, sizeof (IPS_ADAPTER) +
7296                                          sizeof (IPS_IO_CMD), &dma_address);
7297         if (!ha->adapt) {
7298                 IPS_PRINTK(KERN_WARNING, pci_dev,
7299                            "Unable to allocate host adapt & dummy structures\n");
7300                 return ips_abort_init(ha, index);
7301         }
7302         ha->adapt->hw_status_start = dma_address;
7303         ha->dummy = (void *) (ha->adapt + 1);
7304
7305
7306
7307         ha->logical_drive_info = pci_alloc_consistent(pci_dev, sizeof (IPS_LD_INFO), &dma_address);
7308         if (!ha->logical_drive_info) {
7309                 IPS_PRINTK(KERN_WARNING, pci_dev,
7310                            "Unable to allocate logical drive info structure\n");
7311                 return ips_abort_init(ha, index);
7312         }
7313         ha->logical_drive_info_dma_addr = dma_address;
7314
7315
7316         ha->conf = kmalloc(sizeof (IPS_CONF), GFP_KERNEL);
7317
7318         if (!ha->conf) {
7319                 IPS_PRINTK(KERN_WARNING, pci_dev,
7320                            "Unable to allocate host conf structure\n");
7321                 return ips_abort_init(ha, index);
7322         }
7323
7324         ha->nvram = kmalloc(sizeof (IPS_NVRAM_P5), GFP_KERNEL);
7325
7326         if (!ha->nvram) {
7327                 IPS_PRINTK(KERN_WARNING, pci_dev,
7328                            "Unable to allocate host NVRAM structure\n");
7329                 return ips_abort_init(ha, index);
7330         }
7331
7332         ha->subsys = kmalloc(sizeof (IPS_SUBSYS), GFP_KERNEL);
7333
7334         if (!ha->subsys) {
7335                 IPS_PRINTK(KERN_WARNING, pci_dev,
7336                            "Unable to allocate host subsystem structure\n");
7337                 return ips_abort_init(ha, index);
7338         }
7339
7340         /* the ioctl buffer is now used during adapter initialization, so its
7341          * successful allocation is now required */
7342         if (ips_ioctlsize < PAGE_SIZE)
7343                 ips_ioctlsize = PAGE_SIZE;
7344
7345         ha->ioctl_data = pci_alloc_consistent(pci_dev, ips_ioctlsize,
7346                                               &ha->ioctl_busaddr);
7347         ha->ioctl_len = ips_ioctlsize;
7348         if (!ha->ioctl_data) {
7349                 IPS_PRINTK(KERN_WARNING, pci_dev,
7350                            "Unable to allocate IOCTL data\n");
7351                 return ips_abort_init(ha, index);
7352         }
7353
7354         /*
7355          * Setup Functions
7356          */
7357         ips_setup_funclist(ha);
7358
7359         if ((IPS_IS_MORPHEUS(ha)) || (IPS_IS_MARCO(ha))) {
7360                 /* If Morpheus appears dead, reset it */
7361                 IsDead = readl(ha->mem_ptr + IPS_REG_I960_MSG1);
7362                 if (IsDead == 0xDEADBEEF) {
7363                         ips_reset_morpheus(ha);
7364                 }
7365         }
7366
7367         /*
7368          * Initialize the card if it isn't already
7369          */
7370
7371         if (!(*ha->func.isinit) (ha)) {
7372                 if (!(*ha->func.init) (ha)) {
7373                         /*
7374                          * Initialization failed
7375                          */
7376                         IPS_PRINTK(KERN_WARNING, pci_dev,
7377                                    "Unable to initialize controller\n");
7378                         return ips_abort_init(ha, index);
7379                 }
7380         }
7381
7382         *indexPtr = index;
7383         return SUCCESS;
7384 }
7385
7386 /*---------------------------------------------------------------------------*/
7387 /*   Routine Name: ips_init_phase2                                           */
7388 /*                                                                           */
7389 /*   Routine Description:                                                    */
7390 /*     Adapter Initialization Phase 2                                        */
7391 /*                                                                           */
7392 /*   Return Value:                                                           */
7393 /*     0 if Successful, else non-zero                                        */
7394 /*---------------------------------------------------------------------------*/
7395 static int
7396 ips_init_phase2(int index)
7397 {
7398         ips_ha_t *ha;
7399
7400         ha = ips_ha[index];
7401
7402         METHOD_TRACE("ips_init_phase2", 1);
7403         if (!ha->active) {
7404                 ips_ha[index] = NULL;
7405                 return -1;
7406         }
7407
7408         /* Install the interrupt handler */
7409         if (request_irq(ha->irq, do_ipsintr, IRQF_SHARED, ips_name, ha)) {
7410                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7411                            "Unable to install interrupt handler\n");
7412                 return ips_abort_init(ha, index);
7413         }
7414
7415         /*
7416          * Allocate a temporary SCB for initialization
7417          */
7418         ha->max_cmds = 1;
7419         if (!ips_allocatescbs(ha)) {
7420                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7421                            "Unable to allocate a CCB\n");
7422                 free_irq(ha->irq, ha);
7423                 return ips_abort_init(ha, index);
7424         }
7425
7426         if (!ips_hainit(ha)) {
7427                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7428                            "Unable to initialize controller\n");
7429                 free_irq(ha->irq, ha);
7430                 return ips_abort_init(ha, index);
7431         }
7432         /* Free the temporary SCB */
7433         ips_deallocatescbs(ha, 1);
7434
7435         /* allocate CCBs */
7436         if (!ips_allocatescbs(ha)) {
7437                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7438                            "Unable to allocate CCBs\n");
7439                 free_irq(ha->irq, ha);
7440                 return ips_abort_init(ha, index);
7441         }
7442
7443         return SUCCESS;
7444 }
7445
7446 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9)
7447 MODULE_LICENSE("GPL");
7448 #endif
7449
7450 MODULE_DESCRIPTION("IBM ServeRAID Adapter Driver " IPS_VER_STRING);
7451
7452 #ifdef MODULE_VERSION
7453 MODULE_VERSION(IPS_VER_STRING);
7454 #endif
7455
7456
7457 /*
7458  * Overrides for Emacs so that we almost follow Linus's tabbing style.
7459  * Emacs will notice this stuff at the end of the file and automatically
7460  * adjust the settings for this buffer only.  This must remain at the end
7461  * of the file.
7462  * ---------------------------------------------------------------------------
7463  * Local variables:
7464  * c-indent-level: 2
7465  * c-brace-imaginary-offset: 0
7466  * c-brace-offset: -2
7467  * c-argdecl-indent: 2
7468  * c-label-offset: -2
7469  * c-continued-statement-offset: 2
7470  * c-continued-brace-offset: 0
7471  * indent-tabs-mode: nil
7472  * tab-width: 8
7473  * End:
7474  */