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