git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/ips.c

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