Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/scsi/ips.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us