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