[PATCH] scsi: remove meaningless scsi_cmnd->serial_number_at_timeout field
[linux-2.6.git] / drivers / scsi / ips.c
1 /*****************************************************************************/
2 /* ips.c -- driver for the Adaptec / IBM ServeRAID controller                */
3 /*                                                                           */
4 /* Written By: Keith Mitchell, IBM Corporation                               */
5 /*             Jack Hammer, Adaptec, Inc.                                    */
6 /*             David Jeffery, Adaptec, Inc.                                  */
7 /*                                                                           */
8 /* Copyright (C) 2000 IBM Corporation                                        */
9 /* Copyright (C) 2002,2003 Adaptec, Inc.                                     */
10 /*                                                                           */
11 /* This program is free software; you can redistribute it and/or modify      */
12 /* it under the terms of the GNU General Public License as published by      */
13 /* the Free Software Foundation; either version 2 of the License, or         */
14 /* (at your option) any later version.                                       */
15 /*                                                                           */
16 /* This program is distributed in the hope that it will be useful,           */
17 /* but WITHOUT ANY WARRANTY; without even the implied warranty of            */
18 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the             */
19 /* GNU General Public License for more details.                              */
20 /*                                                                           */
21 /* NO WARRANTY                                                               */
22 /* THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR        */
23 /* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT      */
24 /* LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,      */
25 /* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is    */
26 /* solely responsible for determining the appropriateness of using and       */
27 /* distributing the Program and assumes all risks associated with its        */
28 /* exercise of rights under this Agreement, including but not limited to     */
29 /* the risks and costs of program errors, damage to or loss of data,         */
30 /* programs or equipment, and unavailability or interruption of operations.  */
31 /*                                                                           */
32 /* DISCLAIMER OF LIABILITY                                                   */
33 /* NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY   */
34 /* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL        */
35 /* DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND   */
36 /* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR     */
37 /* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE    */
38 /* USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED  */
39 /* HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES             */
40 /*                                                                           */
41 /* You should have received a copy of the GNU General Public License         */
42 /* along with this program; if not, write to the Free Software               */
43 /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
44 /*                                                                           */
45 /* Bugs/Comments/Suggestions about this driver should be mailed to:          */
46 /*      ipslinux@adaptec.com                                                 */
47 /*                                                                           */
48 /* For system support issues, contact your local IBM Customer support.       */
49 /* Directions to find IBM Customer Support for each country can be found at: */
50 /*      http://www.ibm.com/planetwide/                                       */
51 /*                                                                           */
52 /*****************************************************************************/
53
54 /*****************************************************************************/
55 /* Change Log                                                                */
56 /*                                                                           */
57 /* 0.99.02  - Breakup commands that are bigger than 8 * the stripe size      */
58 /* 0.99.03  - Make interrupt routine handle all completed request on the     */
59 /*            adapter not just the first one                                 */
60 /*          - Make sure passthru commands get woken up if we run out of      */
61 /*            SCBs                                                           */
62 /*          - Send all of the commands on the queue at once rather than      */
63 /*            one at a time since the card will support it.                  */
64 /* 0.99.04  - Fix race condition in the passthru mechanism -- this required  */
65 /*            the interface to the utilities to change                       */
66 /*          - Fix error recovery code                                        */
67 /* 0.99.05  - Fix an oops when we get certain passthru commands              */
68 /* 1.00.00  - Initial Public Release                                         */
69 /*            Functionally equivalent to 0.99.05                             */
70 /* 3.60.00  - Bump max commands to 128 for use with firmware 3.60            */
71 /*          - Change version to 3.60 to coincide with release numbering.     */
72 /* 3.60.01  - Remove bogus error check in passthru routine                   */
73 /* 3.60.02  - Make DCDB direction based on lookup table                      */
74 /*          - Only allow one DCDB command to a SCSI ID at a time             */
75 /* 4.00.00  - Add support for ServeRAID 4                                    */
76 /* 4.00.01  - Add support for First Failure Data Capture                     */
77 /* 4.00.02  - Fix problem with PT DCDB with no buffer                        */
78 /* 4.00.03  - Add alternative passthru interface                             */
79 /*          - Add ability to flash BIOS                                      */
80 /* 4.00.04  - Rename structures/constants to be prefixed with IPS_           */
81 /* 4.00.05  - Remove wish_block from init routine                            */
82 /*          - Use linux/spinlock.h instead of asm/spinlock.h for kernels     */
83 /*            2.3.18 and later                                               */
84 /*          - Sync with other changes from the 2.3 kernels                   */
85 /* 4.00.06  - Fix timeout with initial FFDC command                          */
86 /* 4.00.06a - Port to 2.4 (trivial) -- Christoph Hellwig <hch@infradead.org> */
87 /* 4.10.00  - Add support for ServeRAID 4M/4L                                */
88 /* 4.10.13  - Fix for dynamic unload and proc file system                    */
89 /* 4.20.03  - Rename version to coincide with new release schedules          */
90 /*            Performance fixes                                              */
91 /*            Fix truncation of /proc files with cat                         */
92 /*            Merge in changes through kernel 2.4.0test1ac21                 */
93 /* 4.20.13  - Fix some failure cases / reset code                            */
94 /*          - Hook into the reboot_notifier to flush the controller cache    */
95 /* 4.50.01  - Fix problem when there is a hole in logical drive numbering    */
96 /* 4.70.09  - Use a Common ( Large Buffer ) for Flashing from the JCRM CD    */
97 /*          - Add IPSSEND Flash Support                                      */
98 /*          - Set Sense Data for Unknown SCSI Command                        */
99 /*          - Use Slot Number from NVRAM Page 5                              */
100 /*          - Restore caller's DCDB Structure                                */
101 /* 4.70.12  - Corrective actions for bad controller ( during initialization )*/
102 /* 4.70.13  - Don't Send CDB's if we already know the device is not present  */
103 /*          - Don't release HA Lock in ips_next() until SC taken off queue   */
104 /*          - Unregister SCSI device in ips_release()                        */
105 /* 4.70.15  - Fix Breakup for very large ( non-SG ) requests in ips_done()   */
106 /* 4.71.00  - Change all memory allocations to not use GFP_DMA flag          */
107 /*            Code Clean-Up for 2.4.x kernel                                 */
108 /* 4.72.00  - Allow for a Scatter-Gather Element to exceed MAX_XFER Size     */
109 /* 4.72.01  - I/O Mapped Memory release ( so "insmod ips" does not Fail )    */
110 /*          - Don't Issue Internal FFDC Command if there are Active Commands */
111 /*          - Close Window for getting too many IOCTL's active               */
112 /* 4.80.00  - Make ia64 Safe                                                 */
113 /* 4.80.04  - Eliminate calls to strtok() if 2.4.x or greater                */
114 /*          - Adjustments to Device Queue Depth                              */
115 /* 4.80.14  - Take all semaphores off stack                                  */
116 /*          - Clean Up New_IOCTL path                                        */
117 /* 4.80.20  - Set max_sectors in Scsi_Host structure ( if >= 2.4.7 kernel )  */
118 /*          - 5 second delay needed after resetting an i960 adapter          */
119 /* 4.80.26  - Clean up potential code problems ( Arjan's recommendations )   */
120 /* 4.90.01  - Version Matching for FirmWare, BIOS, and Driver                */
121 /* 4.90.05  - Use New PCI Architecture to facilitate Hot Plug Development    */
122 /* 4.90.08  - Increase Delays in Flashing ( Trombone Only - 4H )             */
123 /* 4.90.08  - Data Corruption if First Scatter Gather Element is > 64K       */
124 /* 4.90.11  - Don't actually RESET unless it's physically required           */
125 /*          - Remove unused compile options                                  */
126 /* 5.00.01  - Sarasota ( 5i ) adapters must always be scanned first          */
127 /*          - Get rid on IOCTL_NEW_COMMAND code                              */
128 /*          - Add Extended DCDB Commands for Tape Support in 5I              */
129 /* 5.10.12  - use pci_dma interfaces, update for 2.5 kernel changes          */
130 /* 5.10.15  - remove unused code (sem, macros, etc.)                         */
131 /* 5.30.00  - use __devexit_p()                                              */
132 /* 6.00.00  - Add 6x Adapters and Battery Flash                              */
133 /* 6.10.00  - Remove 1G Addressing Limitations                               */
134 /* 6.11.xx  - Get VersionInfo buffer off the stack !              DDTS 60401 */
135 /* 6.11.xx  - Make Logical Drive Info structure safe for DMA      DDTS 60639 */
136 /* 7.10.xx  - Add highmem_io flag in SCSI Templete for 2.4 kernels           */
137 /*          - Fix path/name for scsi_hosts.h include for 2.6 kernels         */
138 /*          - Fix sort order of 7k                                           */
139 /*          - Remove 3 unused "inline" functions                             */
140 /*****************************************************************************/
141
142 /*
143  * Conditional Compilation directives for this driver:
144  *
145  * IPS_DEBUG            - Turn on debugging info
146  *
147  * Parameters:
148  *
149  * debug:<number>       - Set debug level to <number>
150  *                        NOTE: only works when IPS_DEBUG compile directive is used.
151  *       1              - Normal debug messages
152  *       2              - Verbose debug messages
153  *       11             - Method trace (non interrupt)
154  *       12             - Method trace (includes interrupt)
155  *
156  * noi2o                - Don't use I2O Queues (ServeRAID 4 only)
157  * nommap               - Don't use memory mapped I/O
158  * ioctlsize            - Initial size of the IOCTL buffer
159  */
160
161 #include <asm/io.h>
162 #include <asm/byteorder.h>
163 #include <asm/page.h>
164 #include <linux/stddef.h>
165 #include <linux/version.h>
166 #include <linux/string.h>
167 #include <linux/errno.h>
168 #include <linux/kernel.h>
169 #include <linux/ioport.h>
170 #include <linux/slab.h>
171 #include <linux/delay.h>
172 #include <linux/pci.h>
173 #include <linux/proc_fs.h>
174 #include <linux/reboot.h>
175 #include <linux/interrupt.h>
176
177 #include <linux/blkdev.h>
178 #include <linux/types.h>
179
180 #include <scsi/sg.h>
181
182 #include "scsi.h"
183
184 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
185 #include "hosts.h"
186 #else
187 #include <scsi/scsi_host.h>
188 #endif
189
190 #include "ips.h"
191
192 #include <linux/module.h>
193
194 #include <linux/stat.h>
195 #include <linux/config.h>
196
197 #include <linux/spinlock.h>
198 #include <linux/init.h>
199
200 #include <linux/smp.h>
201
202 #ifdef MODULE
203 static char *ips = NULL;
204 module_param(ips, charp, 0);
205 #endif
206
207 /*
208  * DRIVER_VER
209  */
210 #define IPS_VERSION_HIGH        "7.10"
211 #define IPS_VERSION_LOW         ".18 "
212
213 #if !defined(__i386__) && !defined(__ia64__) && !defined(__x86_64__)
214 #warning "This driver has only been tested on the x86/ia64/x86_64 platforms"
215 #endif
216
217 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
218 #include <linux/blk.h>
219 #include "sd.h"
220 #define IPS_SG_ADDRESS(sg)       ((sg)->address)
221 #define IPS_LOCK_SAVE(lock,flags) spin_lock_irqsave(&io_request_lock,flags)
222 #define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock_irqrestore(&io_request_lock,flags)
223 #ifndef __devexit_p
224 #define __devexit_p(x) x
225 #endif
226 #else
227 #define IPS_SG_ADDRESS(sg)      (page_address((sg)->page) ? \
228                                    page_address((sg)->page)+(sg)->offset : NULL)
229 #define IPS_LOCK_SAVE(lock,flags) do{spin_lock(lock);(void)flags;}while(0)
230 #define IPS_UNLOCK_RESTORE(lock,flags) do{spin_unlock(lock);(void)flags;}while(0)
231 #endif
232
233 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
234                          SCSI_DATA_NONE == scb->scsi_cmd->sc_data_direction) ? \
235                          PCI_DMA_BIDIRECTIONAL : \
236                          scsi_to_pci_dma_dir(scb->scsi_cmd->sc_data_direction))
237
238 #ifdef IPS_DEBUG
239 #define METHOD_TRACE(s, i)    if (ips_debug >= (i+10)) printk(KERN_NOTICE s "\n");
240 #define DEBUG(i, s)           if (ips_debug >= i) printk(KERN_NOTICE s "\n");
241 #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "\n", v);
242 #else
243 #define METHOD_TRACE(s, i)
244 #define DEBUG(i, s)
245 #define DEBUG_VAR(i, s, v...)
246 #endif
247
248 /*
249  * Function prototypes
250  */
251 static int ips_detect(Scsi_Host_Template *);
252 static int ips_release(struct Scsi_Host *);
253 static int ips_eh_abort(Scsi_Cmnd *);
254 static int ips_eh_reset(Scsi_Cmnd *);
255 static int ips_queue(Scsi_Cmnd *, void (*)(Scsi_Cmnd *));
256 static const char *ips_info(struct Scsi_Host *);
257 static irqreturn_t do_ipsintr(int, void *, struct pt_regs *);
258 static int ips_hainit(ips_ha_t *);
259 static int ips_map_status(ips_ha_t *, ips_scb_t *, ips_stat_t *);
260 static int ips_send_wait(ips_ha_t *, ips_scb_t *, int, int);
261 static int ips_send_cmd(ips_ha_t *, ips_scb_t *);
262 static int ips_online(ips_ha_t *, ips_scb_t *);
263 static int ips_inquiry(ips_ha_t *, ips_scb_t *);
264 static int ips_rdcap(ips_ha_t *, ips_scb_t *);
265 static int ips_msense(ips_ha_t *, ips_scb_t *);
266 static int ips_reqsen(ips_ha_t *, ips_scb_t *);
267 static int ips_deallocatescbs(ips_ha_t *, int);
268 static int ips_allocatescbs(ips_ha_t *);
269 static int ips_reset_copperhead(ips_ha_t *);
270 static int ips_reset_copperhead_memio(ips_ha_t *);
271 static int ips_reset_morpheus(ips_ha_t *);
272 static int ips_issue_copperhead(ips_ha_t *, ips_scb_t *);
273 static int ips_issue_copperhead_memio(ips_ha_t *, ips_scb_t *);
274 static int ips_issue_i2o(ips_ha_t *, ips_scb_t *);
275 static int ips_issue_i2o_memio(ips_ha_t *, ips_scb_t *);
276 static int ips_isintr_copperhead(ips_ha_t *);
277 static int ips_isintr_copperhead_memio(ips_ha_t *);
278 static int ips_isintr_morpheus(ips_ha_t *);
279 static int ips_wait(ips_ha_t *, int, int);
280 static int ips_write_driver_status(ips_ha_t *, int);
281 static int ips_read_adapter_status(ips_ha_t *, int);
282 static int ips_read_subsystem_parameters(ips_ha_t *, int);
283 static int ips_read_config(ips_ha_t *, int);
284 static int ips_clear_adapter(ips_ha_t *, int);
285 static int ips_readwrite_page5(ips_ha_t *, int, int);
286 static int ips_init_copperhead(ips_ha_t *);
287 static int ips_init_copperhead_memio(ips_ha_t *);
288 static int ips_init_morpheus(ips_ha_t *);
289 static int ips_isinit_copperhead(ips_ha_t *);
290 static int ips_isinit_copperhead_memio(ips_ha_t *);
291 static int ips_isinit_morpheus(ips_ha_t *);
292 static int ips_erase_bios(ips_ha_t *);
293 static int ips_program_bios(ips_ha_t *, char *, uint32_t, uint32_t);
294 static int ips_verify_bios(ips_ha_t *, char *, uint32_t, uint32_t);
295 static int ips_erase_bios_memio(ips_ha_t *);
296 static int ips_program_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
297 static int ips_verify_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
298 static int ips_flash_copperhead(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
299 static int ips_flash_bios(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
300 static int ips_flash_firmware(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
301 static void ips_free_flash_copperhead(ips_ha_t * ha);
302 static void ips_get_bios_version(ips_ha_t *, int);
303 static void ips_identify_controller(ips_ha_t *);
304 static void ips_chkstatus(ips_ha_t *, IPS_STATUS *);
305 static void ips_enable_int_copperhead(ips_ha_t *);
306 static void ips_enable_int_copperhead_memio(ips_ha_t *);
307 static void ips_enable_int_morpheus(ips_ha_t *);
308 static int ips_intr_copperhead(ips_ha_t *);
309 static int ips_intr_morpheus(ips_ha_t *);
310 static void ips_next(ips_ha_t *, int);
311 static void ipsintr_blocking(ips_ha_t *, struct ips_scb *);
312 static void ipsintr_done(ips_ha_t *, struct ips_scb *);
313 static void ips_done(ips_ha_t *, ips_scb_t *);
314 static void ips_free(ips_ha_t *);
315 static void ips_init_scb(ips_ha_t *, ips_scb_t *);
316 static void ips_freescb(ips_ha_t *, ips_scb_t *);
317 static void ips_setup_funclist(ips_ha_t *);
318 static void ips_statinit(ips_ha_t *);
319 static void ips_statinit_memio(ips_ha_t *);
320 static void ips_fix_ffdc_time(ips_ha_t *, ips_scb_t *, time_t);
321 static void ips_ffdc_reset(ips_ha_t *, int);
322 static void ips_ffdc_time(ips_ha_t *);
323 static uint32_t ips_statupd_copperhead(ips_ha_t *);
324 static uint32_t ips_statupd_copperhead_memio(ips_ha_t *);
325 static uint32_t ips_statupd_morpheus(ips_ha_t *);
326 static ips_scb_t *ips_getscb(ips_ha_t *);
327 static void ips_putq_scb_head(ips_scb_queue_t *, ips_scb_t *);
328 static void ips_putq_wait_tail(ips_wait_queue_t *, Scsi_Cmnd *);
329 static void ips_putq_copp_tail(ips_copp_queue_t *,
330                                       ips_copp_wait_item_t *);
331 static ips_scb_t *ips_removeq_scb_head(ips_scb_queue_t *);
332 static ips_scb_t *ips_removeq_scb(ips_scb_queue_t *, ips_scb_t *);
333 static Scsi_Cmnd *ips_removeq_wait_head(ips_wait_queue_t *);
334 static Scsi_Cmnd *ips_removeq_wait(ips_wait_queue_t *, Scsi_Cmnd *);
335 static ips_copp_wait_item_t *ips_removeq_copp(ips_copp_queue_t *,
336                                                      ips_copp_wait_item_t *);
337 static ips_copp_wait_item_t *ips_removeq_copp_head(ips_copp_queue_t *);
338
339 static int ips_is_passthru(Scsi_Cmnd *);
340 static int ips_make_passthru(ips_ha_t *, Scsi_Cmnd *, ips_scb_t *, int);
341 static int ips_usrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
342 static void ips_cleanup_passthru(ips_ha_t *, ips_scb_t *);
343 static void ips_scmd_buf_write(Scsi_Cmnd * scmd, void *data,
344                                unsigned int count);
345 static void ips_scmd_buf_read(Scsi_Cmnd * scmd, void *data, unsigned int count);
346
347 static int ips_proc_info(struct Scsi_Host *, char *, char **, off_t, int, int);
348 static int ips_host_info(ips_ha_t *, char *, off_t, int);
349 static void copy_mem_info(IPS_INFOSTR *, char *, int);
350 static int copy_info(IPS_INFOSTR *, char *, ...);
351 static int ips_get_version_info(ips_ha_t * ha, dma_addr_t, int intr);
352 static void ips_version_check(ips_ha_t * ha, int intr);
353 static int ips_abort_init(ips_ha_t * ha, int index);
354 static int ips_init_phase2(int index);
355
356 static int ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr);
357 static int ips_register_scsi(int index);
358
359 /*
360  * global variables
361  */
362 static const char ips_name[] = "ips";
363 static struct Scsi_Host *ips_sh[IPS_MAX_ADAPTERS];      /* Array of host controller structures */
364 static ips_ha_t *ips_ha[IPS_MAX_ADAPTERS];      /* Array of HA structures */
365 static unsigned int ips_next_controller;
366 static unsigned int ips_num_controllers;
367 static unsigned int ips_released_controllers;
368 static int ips_hotplug;
369 static int ips_cmd_timeout = 60;
370 static int ips_reset_timeout = 60 * 5;
371 static int ips_force_memio = 1;         /* Always use Memory Mapped I/O    */
372 static int ips_force_i2o = 1;   /* Always use I2O command delivery */
373 static int ips_ioctlsize = IPS_IOCTL_SIZE;      /* Size of the ioctl buffer        */
374 static int ips_cd_boot;                 /* Booting from Manager CD         */
375 static char *ips_FlashData = NULL;      /* CD Boot - Flash Data Buffer      */
376 static dma_addr_t ips_flashbusaddr;
377 static long ips_FlashDataInUse;         /* CD Boot - Flash Data In Use Flag */
378 static uint32_t MaxLiteCmds = 32;       /* Max Active Cmds for a Lite Adapter */
379 static Scsi_Host_Template ips_driver_template = {
380         .detect                 = ips_detect,
381         .release                = ips_release,
382         .info                   = ips_info,
383         .queuecommand           = ips_queue,
384         .eh_abort_handler       = ips_eh_abort,
385         .eh_host_reset_handler  = ips_eh_reset,
386         .proc_name              = "ips",
387 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
388         .proc_info              = ips_proc_info,
389         .slave_configure        = ips_slave_configure,
390 #else
391         .proc_info              = ips_proc24_info,
392         .select_queue_depths    = ips_select_queue_depth,
393 #endif
394         .bios_param             = ips_biosparam,
395         .this_id                = -1,
396         .sg_tablesize           = IPS_MAX_SG,
397         .cmd_per_lun            = 3,
398         .use_clustering         = ENABLE_CLUSTERING,
399 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
400         .use_new_eh_code        = 1,
401 #endif
402 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20)  &&  LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
403     .highmem_io          = 1,   
404 #endif
405 };
406
407 static IPS_DEFINE_COMPAT_TABLE( Compatable );   /* Version Compatability Table      */
408
409
410 /* This table describes all ServeRAID Adapters */
411 static struct  pci_device_id  ips_pci_table[] = {
412         { 0x1014, 0x002E, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
413         { 0x1014, 0x01BD, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
414         { 0x9005, 0x0250, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
415         { 0, }
416 };
417
418 MODULE_DEVICE_TABLE( pci, ips_pci_table );
419
420 static char ips_hot_plug_name[] = "ips";
421    
422 static int __devinit  ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent);
423 static void __devexit ips_remove_device(struct pci_dev *pci_dev);
424    
425 static struct pci_driver ips_pci_driver = {
426         .name           = ips_hot_plug_name,
427         .id_table       = ips_pci_table,
428         .probe          = ips_insert_device,
429         .remove         = __devexit_p(ips_remove_device),
430 };
431            
432
433 /*
434  * Necessary forward function protoypes
435  */
436 static int ips_halt(struct notifier_block *nb, ulong event, void *buf);
437
438 #define MAX_ADAPTER_NAME 15
439
440 static char ips_adapter_name[][30] = {
441         "ServeRAID",
442         "ServeRAID II",
443         "ServeRAID on motherboard",
444         "ServeRAID on motherboard",
445         "ServeRAID 3H",
446         "ServeRAID 3L",
447         "ServeRAID 4H",
448         "ServeRAID 4M",
449         "ServeRAID 4L",
450         "ServeRAID 4Mx",
451         "ServeRAID 4Lx",
452         "ServeRAID 5i",
453         "ServeRAID 5i",
454         "ServeRAID 6M",
455         "ServeRAID 6i",
456         "ServeRAID 7t",
457         "ServeRAID 7k",
458         "ServeRAID 7M"
459 };
460
461 static struct notifier_block ips_notifier = {
462         ips_halt, NULL, 0
463 };
464
465 /*
466  * Direction table
467  */
468 static char ips_command_direction[] = {
469         IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT,
470         IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK,
471         IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
472         IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
473         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_OUT,
474         IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
475         IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_IN,
476         IPS_DATA_UNK, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
477         IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_UNK,
478         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
479         IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE,
480         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
481         IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT,
482         IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_NONE,
483         IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,
484         IPS_DATA_NONE, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
485         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
486         IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
487         IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
488         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
489         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
490         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
491         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
492         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
493         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
494         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
495         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
496         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
497         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
498         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
499         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
500         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
501         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
502         IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_NONE,
503         IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_OUT,
504         IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_NONE,
505         IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN,
506         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
507         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
508         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
509         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
510         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
511         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
512         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
513         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
514         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
515         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_OUT,
516         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
517         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
518         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
519         IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK
520 };
521
522
523 /****************************************************************************/
524 /*                                                                          */
525 /* Routine Name: ips_setup                                                  */
526 /*                                                                          */
527 /* Routine Description:                                                     */
528 /*                                                                          */
529 /*   setup parameters to the driver                                         */
530 /*                                                                          */
531 /****************************************************************************/
532 static int
533 ips_setup(char *ips_str)
534 {
535
536         int i;
537         char *key;
538         char *value;
539         IPS_OPTION options[] = {
540                 {"noi2o", &ips_force_i2o, 0},
541                 {"nommap", &ips_force_memio, 0},
542                 {"ioctlsize", &ips_ioctlsize, IPS_IOCTL_SIZE},
543                 {"cdboot", &ips_cd_boot, 0},
544                 {"maxcmds", &MaxLiteCmds, 32},
545         };
546
547         /* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
548         /* Search for value */
549         while ((key = strsep(&ips_str, ",."))) {
550                 if (!*key)
551                         continue;
552                 value = strchr(key, ':');
553                 if (value)
554                         *value++ = '\0';
555                 /*
556                  * We now have key/value pairs.
557                  * Update the variables
558                  */
559                 for (i = 0; i < (sizeof (options) / sizeof (options[0])); i++) {
560                         if (strnicmp
561                             (key, options[i].option_name,
562                              strlen(options[i].option_name)) == 0) {
563                                 if (value)
564                                         *options[i].option_flag =
565                                             simple_strtoul(value, NULL, 0);
566                                 else
567                                         *options[i].option_flag =
568                                             options[i].option_value;
569                                 break;
570                         }
571                 }
572         }
573
574         return (1);
575 }
576
577 __setup("ips=", ips_setup);
578
579 /****************************************************************************/
580 /*                                                                          */
581 /* Routine Name: ips_detect                                                 */
582 /*                                                                          */
583 /* Routine Description:                                                     */
584 /*                                                                          */
585 /*   Detect and initialize the driver                                       */
586 /*                                                                          */
587 /* NOTE: this routine is called under the io_request_lock spinlock          */
588 /*                                                                          */
589 /****************************************************************************/
590 static int
591 ips_detect(Scsi_Host_Template * SHT)
592 {
593         int i;
594
595         METHOD_TRACE("ips_detect", 1);
596
597 #ifdef MODULE
598         if (ips)
599                 ips_setup(ips);
600 #endif
601
602         for (i = 0; i < ips_num_controllers; i++) {
603                 if (ips_register_scsi(i))
604                         ips_free(ips_ha[i]);
605                 ips_released_controllers++;
606         }
607         ips_hotplug = 1;
608         return (ips_num_controllers);
609 }
610
611 /****************************************************************************/
612 /*   configure the function pointers to use the functions that will work    */
613 /*   with the found version of the adapter                                  */
614 /****************************************************************************/
615 static void
616 ips_setup_funclist(ips_ha_t * ha)
617 {
618
619         /*                                
620          * Setup Functions
621          */
622         if (IPS_IS_MORPHEUS(ha) || IPS_IS_MARCO(ha)) {
623                 /* morpheus / marco / sebring */
624                 ha->func.isintr = ips_isintr_morpheus;
625                 ha->func.isinit = ips_isinit_morpheus;
626                 ha->func.issue = ips_issue_i2o_memio;
627                 ha->func.init = ips_init_morpheus;
628                 ha->func.statupd = ips_statupd_morpheus;
629                 ha->func.reset = ips_reset_morpheus;
630                 ha->func.intr = ips_intr_morpheus;
631                 ha->func.enableint = ips_enable_int_morpheus;
632         } else if (IPS_USE_MEMIO(ha)) {
633                 /* copperhead w/MEMIO */
634                 ha->func.isintr = ips_isintr_copperhead_memio;
635                 ha->func.isinit = ips_isinit_copperhead_memio;
636                 ha->func.init = ips_init_copperhead_memio;
637                 ha->func.statupd = ips_statupd_copperhead_memio;
638                 ha->func.statinit = ips_statinit_memio;
639                 ha->func.reset = ips_reset_copperhead_memio;
640                 ha->func.intr = ips_intr_copperhead;
641                 ha->func.erasebios = ips_erase_bios_memio;
642                 ha->func.programbios = ips_program_bios_memio;
643                 ha->func.verifybios = ips_verify_bios_memio;
644                 ha->func.enableint = ips_enable_int_copperhead_memio;
645                 if (IPS_USE_I2O_DELIVER(ha))
646                         ha->func.issue = ips_issue_i2o_memio;
647                 else
648                         ha->func.issue = ips_issue_copperhead_memio;
649         } else {
650                 /* copperhead */
651                 ha->func.isintr = ips_isintr_copperhead;
652                 ha->func.isinit = ips_isinit_copperhead;
653                 ha->func.init = ips_init_copperhead;
654                 ha->func.statupd = ips_statupd_copperhead;
655                 ha->func.statinit = ips_statinit;
656                 ha->func.reset = ips_reset_copperhead;
657                 ha->func.intr = ips_intr_copperhead;
658                 ha->func.erasebios = ips_erase_bios;
659                 ha->func.programbios = ips_program_bios;
660                 ha->func.verifybios = ips_verify_bios;
661                 ha->func.enableint = ips_enable_int_copperhead;
662
663                 if (IPS_USE_I2O_DELIVER(ha))
664                         ha->func.issue = ips_issue_i2o;
665                 else
666                         ha->func.issue = ips_issue_copperhead;
667         }
668 }
669
670 /****************************************************************************/
671 /*                                                                          */
672 /* Routine Name: ips_release                                                */
673 /*                                                                          */
674 /* Routine Description:                                                     */
675 /*                                                                          */
676 /*   Remove a driver                                                        */
677 /*                                                                          */
678 /****************************************************************************/
679 static int
680 ips_release(struct Scsi_Host *sh)
681 {
682         ips_scb_t *scb;
683         ips_ha_t *ha;
684         int i;
685
686         METHOD_TRACE("ips_release", 1);
687
688         for (i = 0; i < IPS_MAX_ADAPTERS && ips_sh[i] != sh; i++) ;
689
690         if (i == IPS_MAX_ADAPTERS) {
691                 printk(KERN_WARNING
692                        "(%s) release, invalid Scsi_Host pointer.\n", ips_name);
693                 BUG();
694                 return (FALSE);
695         }
696
697         ha = IPS_HA(sh);
698
699         if (!ha)
700                 return (FALSE);
701
702         /* flush the cache on the controller */
703         scb = &ha->scbs[ha->max_cmds - 1];
704
705         ips_init_scb(ha, scb);
706
707         scb->timeout = ips_cmd_timeout;
708         scb->cdb[0] = IPS_CMD_FLUSH;
709
710         scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
711         scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
712         scb->cmd.flush_cache.state = IPS_NORM_STATE;
713         scb->cmd.flush_cache.reserved = 0;
714         scb->cmd.flush_cache.reserved2 = 0;
715         scb->cmd.flush_cache.reserved3 = 0;
716         scb->cmd.flush_cache.reserved4 = 0;
717
718         IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
719
720         /* send command */
721         if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
722                 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Incomplete Flush.\n");
723
724         IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Complete.\n");
725
726         ips_sh[i] = NULL;
727         ips_ha[i] = NULL;
728
729         /* free extra memory */
730         ips_free(ha);
731
732         /* Free I/O Region */
733         if (ha->io_addr)
734                 release_region(ha->io_addr, ha->io_len);
735
736         /* free IRQ */
737         free_irq(ha->irq, ha);
738
739         IPS_REMOVE_HOST(sh);
740         scsi_host_put(sh);
741
742         ips_released_controllers++;
743
744         return (FALSE);
745 }
746
747 /****************************************************************************/
748 /*                                                                          */
749 /* Routine Name: ips_halt                                                   */
750 /*                                                                          */
751 /* Routine Description:                                                     */
752 /*                                                                          */
753 /*   Perform cleanup when the system reboots                                */
754 /*                                                                          */
755 /****************************************************************************/
756 static int
757 ips_halt(struct notifier_block *nb, ulong event, void *buf)
758 {
759         ips_scb_t *scb;
760         ips_ha_t *ha;
761         int i;
762
763         if ((event != SYS_RESTART) && (event != SYS_HALT) &&
764             (event != SYS_POWER_OFF))
765                 return (NOTIFY_DONE);
766
767         for (i = 0; i < ips_next_controller; i++) {
768                 ha = (ips_ha_t *) ips_ha[i];
769
770                 if (!ha)
771                         continue;
772
773                 if (!ha->active)
774                         continue;
775
776                 /* flush the cache on the controller */
777                 scb = &ha->scbs[ha->max_cmds - 1];
778
779                 ips_init_scb(ha, scb);
780
781                 scb->timeout = ips_cmd_timeout;
782                 scb->cdb[0] = IPS_CMD_FLUSH;
783
784                 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
785                 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
786                 scb->cmd.flush_cache.state = IPS_NORM_STATE;
787                 scb->cmd.flush_cache.reserved = 0;
788                 scb->cmd.flush_cache.reserved2 = 0;
789                 scb->cmd.flush_cache.reserved3 = 0;
790                 scb->cmd.flush_cache.reserved4 = 0;
791
792                 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
793
794                 /* send command */
795                 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) ==
796                     IPS_FAILURE)
797                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
798                                    "Incomplete Flush.\n");
799                 else
800                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
801                                    "Flushing Complete.\n");
802         }
803
804         return (NOTIFY_OK);
805 }
806
807 /****************************************************************************/
808 /*                                                                          */
809 /* Routine Name: ips_eh_abort                                               */
810 /*                                                                          */
811 /* Routine Description:                                                     */
812 /*                                                                          */
813 /*   Abort a command (using the new error code stuff)                       */
814 /* Note: this routine is called under the io_request_lock                   */
815 /****************************************************************************/
816 int
817 ips_eh_abort(Scsi_Cmnd * SC)
818 {
819         ips_ha_t *ha;
820         ips_copp_wait_item_t *item;
821         int ret;
822
823         METHOD_TRACE("ips_eh_abort", 1);
824
825         if (!SC)
826                 return (FAILED);
827
828         ha = (ips_ha_t *) SC->device->host->hostdata;
829
830         if (!ha)
831                 return (FAILED);
832
833         if (!ha->active)
834                 return (FAILED);
835
836         /* See if the command is on the copp queue */
837         item = ha->copp_waitlist.head;
838         while ((item) && (item->scsi_cmd != SC))
839                 item = item->next;
840
841         if (item) {
842                 /* Found it */
843                 ips_removeq_copp(&ha->copp_waitlist, item);
844                 ret = (SUCCESS);
845
846                 /* See if the command is on the wait queue */
847         } else if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
848                 /* command not sent yet */
849                 ret = (SUCCESS);
850         } else {
851                 /* command must have already been sent */
852                 ret = (FAILED);
853         }
854         return ret;
855 }
856
857 /****************************************************************************/
858 /*                                                                          */
859 /* Routine Name: ips_eh_reset                                               */
860 /*                                                                          */
861 /* Routine Description:                                                     */
862 /*                                                                          */
863 /*   Reset the controller (with new eh error code)                          */
864 /*                                                                          */
865 /* NOTE: this routine is called under the io_request_lock spinlock          */
866 /*                                                                          */
867 /****************************************************************************/
868 static int
869 ips_eh_reset(Scsi_Cmnd * SC)
870 {
871         int ret;
872         int i;
873         ips_ha_t *ha;
874         ips_scb_t *scb;
875         ips_copp_wait_item_t *item;
876
877         METHOD_TRACE("ips_eh_reset", 1);
878
879 #ifdef NO_IPS_RESET
880         return (FAILED);
881 #else
882
883         if (!SC) {
884                 DEBUG(1, "Reset called with NULL scsi command");
885
886                 return (FAILED);
887         }
888
889         ha = (ips_ha_t *) SC->device->host->hostdata;
890
891         if (!ha) {
892                 DEBUG(1, "Reset called with NULL ha struct");
893
894                 return (FAILED);
895         }
896
897         if (!ha->active)
898                 return (FAILED);
899
900         /* See if the command is on the copp queue */
901         item = ha->copp_waitlist.head;
902         while ((item) && (item->scsi_cmd != SC))
903                 item = item->next;
904
905         if (item) {
906                 /* Found it */
907                 ips_removeq_copp(&ha->copp_waitlist, item);
908                 return (SUCCESS);
909         }
910
911         /* See if the command is on the wait queue */
912         if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
913                 /* command not sent yet */
914                 return (SUCCESS);
915         }
916
917         /* An explanation for the casual observer:                              */
918         /* Part of the function of a RAID controller is automatic error         */
919         /* detection and recovery.  As such, the only problem that physically   */
920         /* resetting an adapter will ever fix is when, for some reason,         */
921         /* the driver is not successfully communicating with the adapter.       */
922         /* Therefore, we will attempt to flush this adapter.  If that succeeds, */
923         /* then there's no real purpose in a physical reset. This will complete */
924         /* much faster and avoids any problems that might be caused by a        */
925         /* physical reset ( such as having to fail all the outstanding I/O's ). */
926
927         if (ha->ioctl_reset == 0) {     /* IF Not an IOCTL Requested Reset */
928                 scb = &ha->scbs[ha->max_cmds - 1];
929
930                 ips_init_scb(ha, scb);
931
932                 scb->timeout = ips_cmd_timeout;
933                 scb->cdb[0] = IPS_CMD_FLUSH;
934
935                 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
936                 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
937                 scb->cmd.flush_cache.state = IPS_NORM_STATE;
938                 scb->cmd.flush_cache.reserved = 0;
939                 scb->cmd.flush_cache.reserved2 = 0;
940                 scb->cmd.flush_cache.reserved3 = 0;
941                 scb->cmd.flush_cache.reserved4 = 0;
942
943                 /* Attempt the flush command */
944                 ret = ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_IORL);
945                 if (ret == IPS_SUCCESS) {
946                         IPS_PRINTK(KERN_NOTICE, ha->pcidev,
947                                    "Reset Request - Flushed Cache\n");
948                         return (SUCCESS);
949                 }
950         }
951
952         /* Either we can't communicate with the adapter or it's an IOCTL request */
953         /* from a utility.  A physical reset is needed at this point.            */
954
955         ha->ioctl_reset = 0;    /* Reset the IOCTL Requested Reset Flag */
956
957         /*
958          * command must have already been sent
959          * reset the controller
960          */
961         IPS_PRINTK(KERN_NOTICE, ha->pcidev, "Resetting controller.\n");
962         ret = (*ha->func.reset) (ha);
963
964         if (!ret) {
965                 Scsi_Cmnd *scsi_cmd;
966
967                 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
968                            "Controller reset failed - controller now offline.\n");
969
970                 /* Now fail all of the active commands */
971                 DEBUG_VAR(1, "(%s%d) Failing active commands",
972                           ips_name, ha->host_num);
973
974                 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
975                         scb->scsi_cmd->result = DID_ERROR << 16;
976                         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
977                         ips_freescb(ha, scb);
978                 }
979
980                 /* Now fail all of the pending commands */
981                 DEBUG_VAR(1, "(%s%d) Failing pending commands",
982                           ips_name, ha->host_num);
983
984                 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
985                         scsi_cmd->result = DID_ERROR;
986                         scsi_cmd->scsi_done(scsi_cmd);
987                 }
988
989                 ha->active = FALSE;
990                 return (FAILED);
991         }
992
993         if (!ips_clear_adapter(ha, IPS_INTR_IORL)) {
994                 Scsi_Cmnd *scsi_cmd;
995
996                 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
997                            "Controller reset failed - controller now offline.\n");
998
999                 /* Now fail all of the active commands */
1000                 DEBUG_VAR(1, "(%s%d) Failing active commands",
1001                           ips_name, ha->host_num);
1002
1003                 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
1004                         scb->scsi_cmd->result = DID_ERROR << 16;
1005                         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1006                         ips_freescb(ha, scb);
1007                 }
1008
1009                 /* Now fail all of the pending commands */
1010                 DEBUG_VAR(1, "(%s%d) Failing pending commands",
1011                           ips_name, ha->host_num);
1012
1013                 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
1014                         scsi_cmd->result = DID_ERROR << 16;
1015                         scsi_cmd->scsi_done(scsi_cmd);
1016                 }
1017
1018                 ha->active = FALSE;
1019                 return (FAILED);
1020         }
1021
1022         /* FFDC */
1023         if (le32_to_cpu(ha->subsys->param[3]) & 0x300000) {
1024                 struct timeval tv;
1025
1026                 do_gettimeofday(&tv);
1027                 ha->last_ffdc = tv.tv_sec;
1028                 ha->reset_count++;
1029                 ips_ffdc_reset(ha, IPS_INTR_IORL);
1030         }
1031
1032         /* Now fail all of the active commands */
1033         DEBUG_VAR(1, "(%s%d) Failing active commands", ips_name, ha->host_num);
1034
1035         while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
1036                 scb->scsi_cmd->result =
1037                     (DID_RESET << 16) | (SUGGEST_RETRY << 24);
1038                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1039                 ips_freescb(ha, scb);
1040         }
1041
1042         /* Reset DCDB active command bits */
1043         for (i = 1; i < ha->nbus; i++)
1044                 ha->dcdb_active[i - 1] = 0;
1045
1046         /* Reset the number of active IOCTLs */
1047         ha->num_ioctl = 0;
1048
1049         ips_next(ha, IPS_INTR_IORL);
1050
1051         return (SUCCESS);
1052 #endif                          /* NO_IPS_RESET */
1053
1054 }
1055
1056 /****************************************************************************/
1057 /*                                                                          */
1058 /* Routine Name: ips_queue                                                  */
1059 /*                                                                          */
1060 /* Routine Description:                                                     */
1061 /*                                                                          */
1062 /*   Send a command to the controller                                       */
1063 /*                                                                          */
1064 /* NOTE:                                                                    */
1065 /*    Linux obtains io_request_lock before calling this function            */
1066 /*                                                                          */
1067 /****************************************************************************/
1068 static int
1069 ips_queue(Scsi_Cmnd * SC, void (*done) (Scsi_Cmnd *))
1070 {
1071         ips_ha_t *ha;
1072         ips_passthru_t *pt;
1073
1074         METHOD_TRACE("ips_queue", 1);
1075
1076         ha = (ips_ha_t *) SC->device->host->hostdata;
1077
1078         if (!ha)
1079                 return (1);
1080
1081         if (!ha->active)
1082                 return (DID_ERROR);
1083
1084         if (ips_is_passthru(SC)) {
1085                 if (ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
1086                         SC->result = DID_BUS_BUSY << 16;
1087                         done(SC);
1088
1089                         return (0);
1090                 }
1091         } else if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
1092                 SC->result = DID_BUS_BUSY << 16;
1093                 done(SC);
1094
1095                 return (0);
1096         }
1097
1098         SC->scsi_done = done;
1099
1100         DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
1101                   ips_name,
1102                   ha->host_num,
1103                   SC->cmnd[0],
1104                   SC->device->channel, SC->device->id, SC->device->lun);
1105
1106         /* Check for command to initiator IDs */
1107         if ((SC->device->channel > 0)
1108             && (SC->device->id == ha->ha_id[SC->device->channel])) {
1109                 SC->result = DID_NO_CONNECT << 16;
1110                 done(SC);
1111
1112                 return (0);
1113         }
1114
1115         if (ips_is_passthru(SC)) {
1116
1117                 ips_copp_wait_item_t *scratch;
1118
1119                 /* A Reset IOCTL is only sent by the boot CD in extreme cases.           */
1120                 /* There can never be any system activity ( network or disk ), but check */
1121                 /* anyway just as a good practice.                                       */
1122                 pt = (ips_passthru_t *) SC->request_buffer;
1123                 if ((pt->CoppCP.cmd.reset.op_code == IPS_CMD_RESET_CHANNEL) &&
1124                     (pt->CoppCP.cmd.reset.adapter_flag == 1)) {
1125                         if (ha->scb_activelist.count != 0) {
1126                                 SC->result = DID_BUS_BUSY << 16;
1127                                 done(SC);
1128                                 return (0);
1129                         }
1130                         ha->ioctl_reset = 1;    /* This reset request is from an IOCTL */
1131                         ips_eh_reset(SC);
1132                         SC->result = DID_OK << 16;
1133                         SC->scsi_done(SC);
1134                         return (0);
1135                 }
1136
1137                 /* allocate space for the scribble */
1138                 scratch = kmalloc(sizeof (ips_copp_wait_item_t), GFP_ATOMIC);
1139
1140                 if (!scratch) {
1141                         SC->result = DID_ERROR << 16;
1142                         done(SC);
1143
1144                         return (0);
1145                 }
1146
1147                 scratch->scsi_cmd = SC;
1148                 scratch->next = NULL;
1149
1150                 ips_putq_copp_tail(&ha->copp_waitlist, scratch);
1151         } else {
1152                 ips_putq_wait_tail(&ha->scb_waitlist, SC);
1153         }
1154
1155         ips_next(ha, IPS_INTR_IORL);
1156
1157         return (0);
1158 }
1159
1160 /****************************************************************************/
1161 /*                                                                          */
1162 /* Routine Name: ips_biosparam                                              */
1163 /*                                                                          */
1164 /* Routine Description:                                                     */
1165 /*                                                                          */
1166 /*   Set bios geometry for the controller                                   */
1167 /*                                                                          */
1168 /****************************************************************************/
1169 static int
1170 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1171 ips_biosparam(Disk * disk, kdev_t dev, int geom[])
1172 {
1173         ips_ha_t *ha = (ips_ha_t *) disk->device->host->hostdata;
1174         unsigned long capacity = disk->capacity;
1175 #else
1176 ips_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1177               sector_t capacity, int geom[])
1178 {
1179         ips_ha_t *ha = (ips_ha_t *) sdev->host->hostdata;
1180 #endif
1181         int heads;
1182         int sectors;
1183         int cylinders;
1184
1185         METHOD_TRACE("ips_biosparam", 1);
1186
1187         if (!ha)
1188                 /* ?!?! host adater info invalid */
1189                 return (0);
1190
1191         if (!ha->active)
1192                 return (0);
1193
1194         if (!ips_read_adapter_status(ha, IPS_INTR_ON))
1195                 /* ?!?! Enquiry command failed */
1196                 return (0);
1197
1198         if ((capacity > 0x400000) && ((ha->enq->ucMiscFlag & 0x8) == 0)) {
1199                 heads = IPS_NORM_HEADS;
1200                 sectors = IPS_NORM_SECTORS;
1201         } else {
1202                 heads = IPS_COMP_HEADS;
1203                 sectors = IPS_COMP_SECTORS;
1204         }
1205
1206         cylinders = (unsigned long) capacity / (heads * sectors);
1207
1208         DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
1209                   heads, sectors, cylinders);
1210
1211         geom[0] = heads;
1212         geom[1] = sectors;
1213         geom[2] = cylinders;
1214
1215         return (0);
1216 }
1217
1218 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1219
1220 /* ips_proc24_info is a wrapper around ips_proc_info *
1221  * for compatibility with the 2.4 scsi parameters    */
1222 static int
1223 ips_proc24_info(char *buffer, char **start, off_t offset, int length,
1224                               int hostno, int func)
1225 {
1226         int i;
1227
1228         for (i = 0; i < ips_next_controller; i++) {
1229                 if (ips_sh[i] && ips_sh[i]->host_no == hostno) {
1230                         return ips_proc_info(ips_sh[i], buffer, start,
1231                                              offset, length, func);
1232                 }
1233         }
1234         return -EINVAL; 
1235 }
1236
1237 /****************************************************************************/
1238 /*                                                                          */
1239 /* Routine Name: ips_select_queue_depth                                     */
1240 /*                                                                          */
1241 /* Routine Description:                                                     */
1242 /*                                                                          */
1243 /*   Select queue depths for the devices on the contoller                   */
1244 /*                                                                          */
1245 /****************************************************************************/
1246 static void
1247 ips_select_queue_depth(struct Scsi_Host *host, Scsi_Device * scsi_devs)
1248 {
1249         Scsi_Device *device;
1250         ips_ha_t *ha;
1251         int count = 0;
1252         int min;
1253
1254         ha = IPS_HA(host);
1255         min = ha->max_cmds / 4;
1256
1257         for (device = scsi_devs; device; device = device->next) {
1258                 if (device->host == host) {
1259                         if ((device->channel == 0) && (device->type == 0))
1260                                 count++;
1261                 }
1262         }
1263
1264         for (device = scsi_devs; device; device = device->next) {
1265                 if (device->host == host) {
1266                         if ((device->channel == 0) && (device->type == 0)) {
1267                                 device->queue_depth =
1268                                     (ha->max_cmds - 1) / count;
1269                                 if (device->queue_depth < min)
1270                                         device->queue_depth = min;
1271                         } else {
1272                                 device->queue_depth = 2;
1273                         }
1274
1275                         if (device->queue_depth < 2)
1276                                 device->queue_depth = 2;
1277                 }
1278         }
1279 }
1280
1281 #else
1282 /****************************************************************************/
1283 /*                                                                          */
1284 /* Routine Name: ips_slave_configure                                        */
1285 /*                                                                          */
1286 /* Routine Description:                                                     */
1287 /*                                                                          */
1288 /*   Set queue depths on devices once scan is complete                      */
1289 /*                                                                          */
1290 /****************************************************************************/
1291 static int
1292 ips_slave_configure(Scsi_Device * SDptr)
1293 {
1294         ips_ha_t *ha;
1295         int min;
1296
1297         ha = IPS_HA(SDptr->host);
1298         if (SDptr->tagged_supported && SDptr->type == TYPE_DISK) {
1299                 min = ha->max_cmds / 2;
1300                 if (ha->enq->ucLogDriveCount <= 2)
1301                         min = ha->max_cmds - 1;
1302                 scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, min);
1303         }
1304         return 0;
1305 }
1306 #endif
1307
1308 /****************************************************************************/
1309 /*                                                                          */
1310 /* Routine Name: do_ipsintr                                                 */
1311 /*                                                                          */
1312 /* Routine Description:                                                     */
1313 /*                                                                          */
1314 /*   Wrapper for the interrupt handler                                      */
1315 /*                                                                          */
1316 /****************************************************************************/
1317 static irqreturn_t
1318 do_ipsintr(int irq, void *dev_id, struct pt_regs * regs)
1319 {
1320         ips_ha_t *ha;
1321         unsigned long cpu_flags;
1322         struct Scsi_Host *host;
1323         int irqstatus;
1324
1325         METHOD_TRACE("do_ipsintr", 2);
1326
1327         ha = (ips_ha_t *) dev_id;
1328         if (!ha)
1329                 return IRQ_NONE;
1330         host = ips_sh[ha->host_num];
1331         /* interrupt during initialization */
1332         if (!host) {
1333                 (*ha->func.intr) (ha);
1334                 return IRQ_HANDLED;
1335         }
1336
1337         IPS_LOCK_SAVE(host->host_lock, cpu_flags);
1338
1339         if (!ha->active) {
1340                 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1341                 return IRQ_HANDLED;
1342         }
1343
1344         irqstatus = (*ha->func.intr) (ha);
1345
1346         IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1347
1348         /* start the next command */
1349         ips_next(ha, IPS_INTR_ON);
1350         return IRQ_RETVAL(irqstatus);
1351 }
1352
1353 /****************************************************************************/
1354 /*                                                                          */
1355 /* Routine Name: ips_intr_copperhead                                        */
1356 /*                                                                          */
1357 /* Routine Description:                                                     */
1358 /*                                                                          */
1359 /*   Polling interrupt handler                                              */
1360 /*                                                                          */
1361 /*   ASSUMES interrupts are disabled                                        */
1362 /*                                                                          */
1363 /****************************************************************************/
1364 int
1365 ips_intr_copperhead(ips_ha_t * ha)
1366 {
1367         ips_stat_t *sp;
1368         ips_scb_t *scb;
1369         IPS_STATUS cstatus;
1370         int intrstatus;
1371
1372         METHOD_TRACE("ips_intr", 2);
1373
1374         if (!ha)
1375                 return 0;
1376
1377         if (!ha->active)
1378                 return 0;
1379
1380         intrstatus = (*ha->func.isintr) (ha);
1381
1382         if (!intrstatus) {
1383                 /*
1384                  * Unexpected/Shared interrupt
1385                  */
1386
1387                 return 0;
1388         }
1389
1390         while (TRUE) {
1391                 sp = &ha->sp;
1392
1393                 intrstatus = (*ha->func.isintr) (ha);
1394
1395                 if (!intrstatus)
1396                         break;
1397                 else
1398                         cstatus.value = (*ha->func.statupd) (ha);
1399
1400                 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1401                         /* Spurious Interupt ? */
1402                         continue;
1403                 }
1404
1405                 ips_chkstatus(ha, &cstatus);
1406                 scb = (ips_scb_t *) sp->scb_addr;
1407
1408                 /*
1409                  * use the callback function to finish things up
1410                  * NOTE: interrupts are OFF for this
1411                  */
1412                 (*scb->callback) (ha, scb);
1413         }                       /* end while */
1414         return 1;
1415 }
1416
1417 /****************************************************************************/
1418 /*                                                                          */
1419 /* Routine Name: ips_intr_morpheus                                          */
1420 /*                                                                          */
1421 /* Routine Description:                                                     */
1422 /*                                                                          */
1423 /*   Polling interrupt handler                                              */
1424 /*                                                                          */
1425 /*   ASSUMES interrupts are disabled                                        */
1426 /*                                                                          */
1427 /****************************************************************************/
1428 int
1429 ips_intr_morpheus(ips_ha_t * ha)
1430 {
1431         ips_stat_t *sp;
1432         ips_scb_t *scb;
1433         IPS_STATUS cstatus;
1434         int intrstatus;
1435
1436         METHOD_TRACE("ips_intr_morpheus", 2);
1437
1438         if (!ha)
1439                 return 0;
1440
1441         if (!ha->active)
1442                 return 0;
1443
1444         intrstatus = (*ha->func.isintr) (ha);
1445
1446         if (!intrstatus) {
1447                 /*
1448                  * Unexpected/Shared interrupt
1449                  */
1450
1451                 return 0;
1452         }
1453
1454         while (TRUE) {
1455                 sp = &ha->sp;
1456
1457                 intrstatus = (*ha->func.isintr) (ha);
1458
1459                 if (!intrstatus)
1460                         break;
1461                 else
1462                         cstatus.value = (*ha->func.statupd) (ha);
1463
1464                 if (cstatus.value == 0xffffffff)
1465                         /* No more to process */
1466                         break;
1467
1468                 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1469                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
1470                                    "Spurious interrupt; no ccb.\n");
1471
1472                         continue;
1473                 }
1474
1475                 ips_chkstatus(ha, &cstatus);
1476                 scb = (ips_scb_t *) sp->scb_addr;
1477
1478                 /*
1479                  * use the callback function to finish things up
1480                  * NOTE: interrupts are OFF for this
1481                  */
1482                 (*scb->callback) (ha, scb);
1483         }                       /* end while */
1484         return 1;
1485 }
1486
1487 /****************************************************************************/
1488 /*                                                                          */
1489 /* Routine Name: ips_info                                                   */
1490 /*                                                                          */
1491 /* Routine Description:                                                     */
1492 /*                                                                          */
1493 /*   Return info about the driver                                           */
1494 /*                                                                          */
1495 /****************************************************************************/
1496 static const char *
1497 ips_info(struct Scsi_Host *SH)
1498 {
1499         static char buffer[256];
1500         char *bp;
1501         ips_ha_t *ha;
1502
1503         METHOD_TRACE("ips_info", 1);
1504
1505         ha = IPS_HA(SH);
1506
1507         if (!ha)
1508                 return (NULL);
1509
1510         bp = &buffer[0];
1511         memset(bp, 0, sizeof (buffer));
1512
1513         sprintf(bp, "%s%s%s Build %d", "IBM PCI ServeRAID ",
1514                 IPS_VERSION_HIGH, IPS_VERSION_LOW, IPS_BUILD_IDENT);
1515
1516         if (ha->ad_type > 0 && ha->ad_type <= MAX_ADAPTER_NAME) {
1517                 strcat(bp, " <");
1518                 strcat(bp, ips_adapter_name[ha->ad_type - 1]);
1519                 strcat(bp, ">");
1520         }
1521
1522         return (bp);
1523 }
1524
1525 /****************************************************************************/
1526 /*                                                                          */
1527 /* Routine Name: ips_proc_info                                              */
1528 /*                                                                          */
1529 /* Routine Description:                                                     */
1530 /*                                                                          */
1531 /*   The passthru interface for the driver                                  */
1532 /*                                                                          */
1533 /****************************************************************************/
1534 static int
1535 ips_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
1536               int length, int func)
1537 {
1538         int i;
1539         int ret;
1540         ips_ha_t *ha = NULL;
1541
1542         METHOD_TRACE("ips_proc_info", 1);
1543
1544         /* Find our host structure */
1545         for (i = 0; i < ips_next_controller; i++) {
1546                 if (ips_sh[i]) {
1547                         if (ips_sh[i] == host) {
1548                                 ha = (ips_ha_t *) ips_sh[i]->hostdata;
1549                                 break;
1550                         }
1551                 }
1552         }
1553
1554         if (!ha)
1555                 return (-EINVAL);
1556
1557         if (func) {
1558                 /* write */
1559                 return (0);
1560         } else {
1561                 /* read */
1562                 if (start)
1563                         *start = buffer;
1564
1565                 ret = ips_host_info(ha, buffer, offset, length);
1566
1567                 return (ret);
1568         }
1569 }
1570
1571 /*--------------------------------------------------------------------------*/
1572 /* Helper Functions                                                         */
1573 /*--------------------------------------------------------------------------*/
1574
1575 /****************************************************************************/
1576 /*                                                                          */
1577 /* Routine Name: ips_is_passthru                                            */
1578 /*                                                                          */
1579 /* Routine Description:                                                     */
1580 /*                                                                          */
1581 /*   Determine if the specified SCSI command is really a passthru command   */
1582 /*                                                                          */
1583 /****************************************************************************/
1584 static int
1585 ips_is_passthru(Scsi_Cmnd * SC)
1586 {
1587         METHOD_TRACE("ips_is_passthru", 1);
1588
1589         if (!SC)
1590                 return (0);
1591
1592         if ((SC->cmnd[0] == IPS_IOCTL_COMMAND) &&
1593             (SC->device->channel == 0) &&
1594             (SC->device->id == IPS_ADAPTER_ID) &&
1595             (SC->device->lun == 0) && SC->request_buffer) {
1596                 if ((!SC->use_sg) && SC->request_bufflen &&
1597                     (((char *) SC->request_buffer)[0] == 'C') &&
1598                     (((char *) SC->request_buffer)[1] == 'O') &&
1599                     (((char *) SC->request_buffer)[2] == 'P') &&
1600                     (((char *) SC->request_buffer)[3] == 'P'))
1601                         return 1;
1602                 else if (SC->use_sg) {
1603                         struct scatterlist *sg = SC->request_buffer;
1604                         char *buffer = IPS_SG_ADDRESS(sg);
1605                         if (buffer && buffer[0] == 'C' && buffer[1] == 'O' &&
1606                             buffer[2] == 'P' && buffer[3] == 'P')
1607                                 return 1;
1608                 }
1609         }
1610         return 0;
1611 }
1612
1613 /****************************************************************************/
1614 /*                                                                          */
1615 /* Routine Name: ips_alloc_passthru_buffer                                  */
1616 /*                                                                          */
1617 /* Routine Description:                                                     */
1618 /*   allocate a buffer large enough for the ioctl data if the ioctl buffer  */
1619 /*   is too small or doesn't exist                                          */
1620 /****************************************************************************/
1621 static int
1622 ips_alloc_passthru_buffer(ips_ha_t * ha, int length)
1623 {
1624         void *bigger_buf;
1625         dma_addr_t dma_busaddr;
1626
1627         if (ha->ioctl_data && length <= ha->ioctl_len)
1628                 return 0;
1629         /* there is no buffer or it's not big enough, allocate a new one */
1630         bigger_buf = pci_alloc_consistent(ha->pcidev, length, &dma_busaddr);
1631         if (bigger_buf) {
1632                 /* free the old memory */
1633                 pci_free_consistent(ha->pcidev, ha->ioctl_len, ha->ioctl_data,
1634                                     ha->ioctl_busaddr);
1635                 /* use the new memory */
1636                 ha->ioctl_data = (char *) bigger_buf;
1637                 ha->ioctl_len = length;
1638                 ha->ioctl_busaddr = dma_busaddr;
1639         } else {
1640                 return -1;
1641         }
1642         return 0;
1643 }
1644
1645 /****************************************************************************/
1646 /*                                                                          */
1647 /* Routine Name: ips_make_passthru                                          */
1648 /*                                                                          */
1649 /* Routine Description:                                                     */
1650 /*                                                                          */
1651 /*   Make a passthru command out of the info in the Scsi block              */
1652 /*                                                                          */
1653 /****************************************************************************/
1654 static int
1655 ips_make_passthru(ips_ha_t * ha, Scsi_Cmnd * SC, ips_scb_t * scb, int intr)
1656 {
1657         ips_passthru_t *pt;
1658         int length = 0;
1659         int ret;
1660
1661         METHOD_TRACE("ips_make_passthru", 1);
1662
1663         if (!SC->use_sg) {
1664                 length = SC->request_bufflen;
1665         } else {
1666                 struct scatterlist *sg = SC->request_buffer;
1667                 int i;
1668                 for (i = 0; i < SC->use_sg; i++)
1669                         length += sg[i].length;
1670         }
1671         if (length < sizeof (ips_passthru_t)) {
1672                 /* wrong size */
1673                 DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
1674                           ips_name, ha->host_num);
1675                 return (IPS_FAILURE);
1676         }
1677         if (ips_alloc_passthru_buffer(ha, length)) {
1678                 /* allocation failure!  If ha->ioctl_data exists, use it to return
1679                    some error codes.  Return a failed command to the scsi layer. */
1680                 if (ha->ioctl_data) {
1681                         pt = (ips_passthru_t *) ha->ioctl_data;
1682                         ips_scmd_buf_read(SC, pt, sizeof (ips_passthru_t));
1683                         pt->BasicStatus = 0x0B;
1684                         pt->ExtendedStatus = 0x00;
1685                         ips_scmd_buf_write(SC, pt, sizeof (ips_passthru_t));
1686                 }
1687                 return IPS_FAILURE;
1688         }
1689         ha->ioctl_datasize = length;
1690
1691         ips_scmd_buf_read(SC, ha->ioctl_data, ha->ioctl_datasize);
1692         pt = (ips_passthru_t *) ha->ioctl_data;
1693
1694         /*
1695          * Some notes about the passthru interface used
1696          *
1697          * IF the scsi op_code == 0x0d then we assume
1698          * that the data came along with/goes with the
1699          * packet we received from the sg driver. In this
1700          * case the CmdBSize field of the pt structure is
1701          * used for the size of the buffer.
1702          */
1703
1704         switch (pt->CoppCmd) {
1705         case IPS_NUMCTRLS:
1706                 memcpy(ha->ioctl_data + sizeof (ips_passthru_t),
1707                        &ips_num_controllers, sizeof (int));
1708                 ips_scmd_buf_write(SC, ha->ioctl_data,
1709                                    sizeof (ips_passthru_t) + sizeof (int));
1710                 SC->result = DID_OK << 16;
1711
1712                 return (IPS_SUCCESS_IMM);
1713
1714         case IPS_COPPUSRCMD:
1715         case IPS_COPPIOCCMD:
1716                 if (SC->cmnd[0] == IPS_IOCTL_COMMAND) {
1717                         if (length < (sizeof (ips_passthru_t) + pt->CmdBSize)) {
1718                                 /* wrong size */
1719                                 DEBUG_VAR(1,
1720                                           "(%s%d) Passthru structure wrong size",
1721                                           ips_name, ha->host_num);
1722
1723                                 return (IPS_FAILURE);
1724                         }
1725
1726                         if (ha->device_id == IPS_DEVICEID_COPPERHEAD &&
1727                             pt->CoppCP.cmd.flashfw.op_code ==
1728                             IPS_CMD_RW_BIOSFW) {
1729                                 ret = ips_flash_copperhead(ha, pt, scb);
1730                                 ips_scmd_buf_write(SC, ha->ioctl_data,
1731                                                    sizeof (ips_passthru_t));
1732                                 return ret;
1733                         }
1734                         if (ips_usrcmd(ha, pt, scb))
1735                                 return (IPS_SUCCESS);
1736                         else
1737                                 return (IPS_FAILURE);
1738                 }
1739
1740                 break;
1741
1742         }                       /* end switch */
1743
1744         return (IPS_FAILURE);
1745 }
1746
1747 /****************************************************************************/
1748 /* Routine Name: ips_flash_copperhead                                       */
1749 /* Routine Description:                                                     */
1750 /*   Flash the BIOS/FW on a Copperhead style controller                     */
1751 /****************************************************************************/
1752 static int
1753 ips_flash_copperhead(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1754 {
1755         int datasize;
1756
1757         /* Trombone is the only copperhead that can do packet flash, but only
1758          * for firmware. No one said it had to make sence. */
1759         if (IPS_IS_TROMBONE(ha) && pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE) {
1760                 if (ips_usrcmd(ha, pt, scb))
1761                         return IPS_SUCCESS;
1762                 else
1763                         return IPS_FAILURE;
1764         }
1765         pt->BasicStatus = 0x0B;
1766         pt->ExtendedStatus = 0;
1767         scb->scsi_cmd->result = DID_OK << 16;
1768         /* IF it's OK to Use the "CD BOOT" Flash Buffer, then you can     */
1769         /* avoid allocating a huge buffer per adapter ( which can fail ). */
1770         if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1771             pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1772                 pt->BasicStatus = 0;
1773                 return ips_flash_bios(ha, pt, scb);
1774         } else if (pt->CoppCP.cmd.flashfw.packet_num == 0) {
1775                 if (ips_FlashData && !test_and_set_bit(0, &ips_FlashDataInUse)){
1776                         ha->flash_data = ips_FlashData;
1777                         ha->flash_busaddr = ips_flashbusaddr;
1778                         ha->flash_len = PAGE_SIZE << 7;
1779                         ha->flash_datasize = 0;
1780                 } else if (!ha->flash_data) {
1781                         datasize = pt->CoppCP.cmd.flashfw.total_packets *
1782                             pt->CoppCP.cmd.flashfw.count;
1783                         ha->flash_data = pci_alloc_consistent(ha->pcidev,
1784                                                               datasize,
1785                                                               &ha->flash_busaddr);
1786                         if (!ha->flash_data){
1787                                 printk(KERN_WARNING "Unable to allocate a flash buffer\n");
1788                                 return IPS_FAILURE;
1789                         }
1790                         ha->flash_datasize = 0;
1791                         ha->flash_len = datasize;
1792                 } else
1793                         return IPS_FAILURE;
1794         } else {
1795                 if (pt->CoppCP.cmd.flashfw.count + ha->flash_datasize >
1796                     ha->flash_len) {
1797                         ips_free_flash_copperhead(ha);
1798                         IPS_PRINTK(KERN_WARNING, ha->pcidev,
1799                                    "failed size sanity check\n");
1800                         return IPS_FAILURE;
1801                 }
1802         }
1803         if (!ha->flash_data)
1804                 return IPS_FAILURE;
1805         pt->BasicStatus = 0;
1806         memcpy(&ha->flash_data[ha->flash_datasize], pt + 1,
1807                pt->CoppCP.cmd.flashfw.count);
1808         ha->flash_datasize += pt->CoppCP.cmd.flashfw.count;
1809         if (pt->CoppCP.cmd.flashfw.packet_num ==
1810             pt->CoppCP.cmd.flashfw.total_packets - 1) {
1811                 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE)
1812                         return ips_flash_bios(ha, pt, scb);
1813                 else if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE)
1814                         return ips_flash_firmware(ha, pt, scb);
1815         }
1816         return IPS_SUCCESS_IMM;
1817 }
1818
1819 /****************************************************************************/
1820 /* Routine Name: ips_flash_bios                                             */
1821 /* Routine Description:                                                     */
1822 /*   flashes the bios of a copperhead adapter                               */
1823 /****************************************************************************/
1824 static int
1825 ips_flash_bios(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1826 {
1827
1828         if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1829             pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_BIOS) {
1830                 if ((!ha->func.programbios) || (!ha->func.erasebios) ||
1831                     (!ha->func.verifybios))
1832                         goto error;
1833                 if ((*ha->func.erasebios) (ha)) {
1834                         DEBUG_VAR(1,
1835                                   "(%s%d) flash bios failed - unable to erase flash",
1836                                   ips_name, ha->host_num);
1837                         goto error;
1838                 } else
1839                     if ((*ha->func.programbios) (ha,
1840                                                  ha->flash_data +
1841                                                  IPS_BIOS_HEADER,
1842                                                  ha->flash_datasize -
1843                                                  IPS_BIOS_HEADER, 0)) {
1844                         DEBUG_VAR(1,
1845                                   "(%s%d) flash bios failed - unable to flash",
1846                                   ips_name, ha->host_num);
1847                         goto error;
1848                 } else
1849                     if ((*ha->func.verifybios) (ha,
1850                                                 ha->flash_data +
1851                                                 IPS_BIOS_HEADER,
1852                                                 ha->flash_datasize -
1853                                                 IPS_BIOS_HEADER, 0)) {
1854                         DEBUG_VAR(1,
1855                                   "(%s%d) flash bios failed - unable to verify flash",
1856                                   ips_name, ha->host_num);
1857                         goto error;
1858                 }
1859                 ips_free_flash_copperhead(ha);
1860                 return IPS_SUCCESS_IMM;
1861         } else if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1862                    pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1863                 if (!ha->func.erasebios)
1864                         goto error;
1865                 if ((*ha->func.erasebios) (ha)) {
1866                         DEBUG_VAR(1,
1867                                   "(%s%d) flash bios failed - unable to erase flash",
1868                                   ips_name, ha->host_num);
1869                         goto error;
1870                 }
1871                 return IPS_SUCCESS_IMM;
1872         }
1873       error:
1874         pt->BasicStatus = 0x0B;
1875         pt->ExtendedStatus = 0x00;
1876         ips_free_flash_copperhead(ha);
1877         return IPS_FAILURE;
1878 }
1879
1880 /****************************************************************************/
1881 /*                                                                          */
1882 /* Routine Name: ips_fill_scb_sg_single                                     */
1883 /*                                                                          */
1884 /* Routine Description:                                                     */
1885 /*   Fill in a single scb sg_list element from an address                   */
1886 /*   return a -1 if a breakup occurred                                      */
1887 /****************************************************************************/
1888 static int
1889 ips_fill_scb_sg_single(ips_ha_t * ha, dma_addr_t busaddr,
1890                        ips_scb_t * scb, int indx, unsigned int e_len)
1891 {
1892
1893         int ret_val = 0;
1894
1895         if ((scb->data_len + e_len) > ha->max_xfer) {
1896                 e_len = ha->max_xfer - scb->data_len;
1897                 scb->breakup = indx;
1898                 ++scb->sg_break;
1899                 ret_val = -1;
1900         } else {
1901                 scb->breakup = 0;
1902                 scb->sg_break = 0;
1903         }
1904         if (IPS_USE_ENH_SGLIST(ha)) {
1905                 scb->sg_list.enh_list[indx].address_lo =
1906                     cpu_to_le32(pci_dma_lo32(busaddr));
1907                 scb->sg_list.enh_list[indx].address_hi =
1908                     cpu_to_le32(pci_dma_hi32(busaddr));
1909                 scb->sg_list.enh_list[indx].length = cpu_to_le32(e_len);
1910         } else {
1911                 scb->sg_list.std_list[indx].address =
1912                     cpu_to_le32(pci_dma_lo32(busaddr));
1913                 scb->sg_list.std_list[indx].length = cpu_to_le32(e_len);
1914         }
1915
1916         ++scb->sg_len;
1917         scb->data_len += e_len;
1918         return ret_val;
1919 }
1920
1921 /****************************************************************************/
1922 /* Routine Name: ips_flash_firmware                                         */
1923 /* Routine Description:                                                     */
1924 /*   flashes the firmware of a copperhead adapter                           */
1925 /****************************************************************************/
1926 static int
1927 ips_flash_firmware(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1928 {
1929         IPS_SG_LIST sg_list;
1930         uint32_t cmd_busaddr;
1931
1932         if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE &&
1933             pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_FW) {
1934                 memset(&pt->CoppCP.cmd, 0, sizeof (IPS_HOST_COMMAND));
1935                 pt->CoppCP.cmd.flashfw.op_code = IPS_CMD_DOWNLOAD;
1936                 pt->CoppCP.cmd.flashfw.count = cpu_to_le32(ha->flash_datasize);
1937         } else {
1938                 pt->BasicStatus = 0x0B;
1939                 pt->ExtendedStatus = 0x00;
1940                 ips_free_flash_copperhead(ha);
1941                 return IPS_FAILURE;
1942         }
1943         /* Save the S/G list pointer so it doesn't get clobbered */
1944         sg_list.list = scb->sg_list.list;
1945         cmd_busaddr = scb->scb_busaddr;
1946         /* copy in the CP */
1947         memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1948         /* FIX stuff that might be wrong */
1949         scb->sg_list.list = sg_list.list;
1950         scb->scb_busaddr = cmd_busaddr;
1951         scb->bus = scb->scsi_cmd->device->channel;
1952         scb->target_id = scb->scsi_cmd->device->id;
1953         scb->lun = scb->scsi_cmd->device->lun;
1954         scb->sg_len = 0;
1955         scb->data_len = 0;
1956         scb->flags = 0;
1957         scb->op_code = 0;
1958         scb->callback = ipsintr_done;
1959         scb->timeout = ips_cmd_timeout;
1960
1961         scb->data_len = ha->flash_datasize;
1962         scb->data_busaddr =
1963             pci_map_single(ha->pcidev, ha->flash_data, scb->data_len,
1964                            IPS_DMA_DIR(scb));
1965         scb->flags |= IPS_SCB_MAP_SINGLE;
1966         scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
1967         scb->cmd.flashfw.buffer_addr = cpu_to_le32(scb->data_busaddr);
1968         if (pt->TimeOut)
1969                 scb->timeout = pt->TimeOut;
1970         scb->scsi_cmd->result = DID_OK << 16;
1971         return IPS_SUCCESS;
1972 }
1973
1974 /****************************************************************************/
1975 /* Routine Name: ips_free_flash_copperhead                                  */
1976 /* Routine Description:                                                     */
1977 /*   release the memory resources used to hold the flash image              */
1978 /****************************************************************************/
1979 static void
1980 ips_free_flash_copperhead(ips_ha_t * ha)
1981 {
1982         if (ha->flash_data == ips_FlashData)
1983                 test_and_clear_bit(0, &ips_FlashDataInUse);
1984         else if (ha->flash_data)
1985                 pci_free_consistent(ha->pcidev, ha->flash_len, ha->flash_data,
1986                                     ha->flash_busaddr);
1987         ha->flash_data = NULL;
1988 }
1989
1990 /****************************************************************************/
1991 /*                                                                          */
1992 /* Routine Name: ips_usrcmd                                                 */
1993 /*                                                                          */
1994 /* Routine Description:                                                     */
1995 /*                                                                          */
1996 /*   Process a user command and make it ready to send                       */
1997 /*                                                                          */
1998 /****************************************************************************/
1999 static int
2000 ips_usrcmd(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
2001 {
2002         IPS_SG_LIST sg_list;
2003         uint32_t cmd_busaddr;
2004
2005         METHOD_TRACE("ips_usrcmd", 1);
2006
2007         if ((!scb) || (!pt) || (!ha))
2008                 return (0);
2009
2010         /* Save the S/G list pointer so it doesn't get clobbered */
2011         sg_list.list = scb->sg_list.list;
2012         cmd_busaddr = scb->scb_busaddr;
2013         /* copy in the CP */
2014         memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
2015         memcpy(&scb->dcdb, &pt->CoppCP.dcdb, sizeof (IPS_DCDB_TABLE));
2016
2017         /* FIX stuff that might be wrong */
2018         scb->sg_list.list = sg_list.list;
2019         scb->scb_busaddr = cmd_busaddr;
2020         scb->bus = scb->scsi_cmd->device->channel;
2021         scb->target_id = scb->scsi_cmd->device->id;
2022         scb->lun = scb->scsi_cmd->device->lun;
2023         scb->sg_len = 0;
2024         scb->data_len = 0;
2025         scb->flags = 0;
2026         scb->op_code = 0;
2027         scb->callback = ipsintr_done;
2028         scb->timeout = ips_cmd_timeout;
2029         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
2030
2031         /* we don't support DCDB/READ/WRITE Scatter Gather */
2032         if ((scb->cmd.basic_io.op_code == IPS_CMD_READ_SG) ||
2033             (scb->cmd.basic_io.op_code == IPS_CMD_WRITE_SG) ||
2034             (scb->cmd.basic_io.op_code == IPS_CMD_DCDB_SG))
2035                 return (0);
2036
2037         if (pt->CmdBSize) {
2038                 scb->data_len = pt->CmdBSize;
2039                 scb->data_busaddr = ha->ioctl_busaddr + sizeof (ips_passthru_t);
2040         } else {
2041                 scb->data_busaddr = 0L;
2042         }
2043
2044         if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
2045                 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
2046                                                          (unsigned long) &scb->
2047                                                          dcdb -
2048                                                          (unsigned long) scb);
2049
2050         if (pt->CmdBSize) {
2051                 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
2052                         scb->dcdb.buffer_pointer =
2053                             cpu_to_le32(scb->data_busaddr);
2054                 else
2055                         scb->cmd.basic_io.sg_addr =
2056                             cpu_to_le32(scb->data_busaddr);
2057         }
2058
2059         /* set timeouts */
2060         if (pt->TimeOut) {
2061                 scb->timeout = pt->TimeOut;
2062
2063                 if (pt->TimeOut <= 10)
2064                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;
2065                 else if (pt->TimeOut <= 60)
2066                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;
2067                 else
2068                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
2069         }
2070
2071         /* assume success */
2072         scb->scsi_cmd->result = DID_OK << 16;
2073
2074         /* success */
2075         return (1);
2076 }
2077
2078 /****************************************************************************/
2079 /*                                                                          */
2080 /* Routine Name: ips_cleanup_passthru                                       */
2081 /*                                                                          */
2082 /* Routine Description:                                                     */
2083 /*                                                                          */
2084 /*   Cleanup after a passthru command                                       */
2085 /*                                                                          */
2086 /****************************************************************************/
2087 static void
2088 ips_cleanup_passthru(ips_ha_t * ha, ips_scb_t * scb)
2089 {
2090         ips_passthru_t *pt;
2091
2092         METHOD_TRACE("ips_cleanup_passthru", 1);
2093
2094         if ((!scb) || (!scb->scsi_cmd) || (!scb->scsi_cmd->request_buffer)) {
2095                 DEBUG_VAR(1, "(%s%d) couldn't cleanup after passthru",
2096                           ips_name, ha->host_num);
2097
2098                 return;
2099         }
2100         pt = (ips_passthru_t *) ha->ioctl_data;
2101
2102         /* Copy data back to the user */
2103         if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)      /* Copy DCDB Back to Caller's Area */
2104                 memcpy(&pt->CoppCP.dcdb, &scb->dcdb, sizeof (IPS_DCDB_TABLE));
2105
2106         pt->BasicStatus = scb->basic_status;
2107         pt->ExtendedStatus = scb->extended_status;
2108         pt->AdapterType = ha->ad_type;
2109
2110         if (ha->device_id == IPS_DEVICEID_COPPERHEAD &&
2111             (scb->cmd.flashfw.op_code == IPS_CMD_DOWNLOAD ||
2112              scb->cmd.flashfw.op_code == IPS_CMD_RW_BIOSFW))
2113                 ips_free_flash_copperhead(ha);
2114
2115         ips_scmd_buf_write(scb->scsi_cmd, ha->ioctl_data, ha->ioctl_datasize);
2116 }
2117
2118 /****************************************************************************/
2119 /*                                                                          */
2120 /* Routine Name: ips_host_info                                              */
2121 /*                                                                          */
2122 /* Routine Description:                                                     */
2123 /*                                                                          */
2124 /*   The passthru interface for the driver                                  */
2125 /*                                                                          */
2126 /****************************************************************************/
2127 static int
2128 ips_host_info(ips_ha_t * ha, char *ptr, off_t offset, int len)
2129 {
2130         IPS_INFOSTR info;
2131
2132         METHOD_TRACE("ips_host_info", 1);
2133
2134         info.buffer = ptr;
2135         info.length = len;
2136         info.offset = offset;
2137         info.pos = 0;
2138         info.localpos = 0;
2139
2140         copy_info(&info, "\nIBM ServeRAID General Information:\n\n");
2141
2142         if ((le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) &&
2143             (le16_to_cpu(ha->nvram->adapter_type) != 0))
2144                 copy_info(&info, "\tController Type                   : %s\n",
2145                           ips_adapter_name[ha->ad_type - 1]);
2146         else
2147                 copy_info(&info,
2148                           "\tController Type                   : Unknown\n");
2149
2150         if (ha->io_addr)
2151                 copy_info(&info,
2152                           "\tIO region                         : 0x%lx (%d bytes)\n",
2153                           ha->io_addr, ha->io_len);
2154
2155         if (ha->mem_addr) {
2156                 copy_info(&info,
2157                           "\tMemory region                     : 0x%lx (%d bytes)\n",
2158                           ha->mem_addr, ha->mem_len);
2159                 copy_info(&info,
2160                           "\tShared memory address             : 0x%lx\n",
2161                           ha->mem_ptr);
2162         }
2163
2164         copy_info(&info, "\tIRQ number                        : %d\n", ha->irq);
2165
2166     /* For the Next 3 lines Check for Binary 0 at the end and don't include it if it's there. */
2167     /* That keeps everything happy for "text" operations on the proc file.                    */
2168
2169         if (le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) {
2170         if (ha->nvram->bios_low[3] == 0) { 
2171             copy_info(&info,
2172                                   "\tBIOS Version                      : %c%c%c%c%c%c%c\n",
2173                                   ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2174                                   ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2175                                   ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2176                                   ha->nvram->bios_low[2]);
2177
2178         } else {
2179                     copy_info(&info,
2180                                   "\tBIOS Version                      : %c%c%c%c%c%c%c%c\n",
2181                                   ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2182                                   ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2183                                   ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2184                                   ha->nvram->bios_low[2], ha->nvram->bios_low[3]);
2185         }
2186
2187     }
2188
2189     if (ha->enq->CodeBlkVersion[7] == 0) {
2190         copy_info(&info,
2191                           "\tFirmware Version                  : %c%c%c%c%c%c%c\n",
2192                           ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2193                           ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2194                           ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2195                           ha->enq->CodeBlkVersion[6]);
2196     } else {
2197         copy_info(&info,
2198                           "\tFirmware Version                  : %c%c%c%c%c%c%c%c\n",
2199                           ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2200                           ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2201                           ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2202                           ha->enq->CodeBlkVersion[6], ha->enq->CodeBlkVersion[7]);
2203     }
2204
2205     if (ha->enq->BootBlkVersion[7] == 0) {
2206         copy_info(&info,
2207                           "\tBoot Block Version                : %c%c%c%c%c%c%c\n",
2208                           ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2209                           ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2210                           ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2211                           ha->enq->BootBlkVersion[6]);
2212     } else {
2213         copy_info(&info,
2214                           "\tBoot Block Version                : %c%c%c%c%c%c%c%c\n",
2215                           ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2216                           ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2217                           ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2218                           ha->enq->BootBlkVersion[6], ha->enq->BootBlkVersion[7]);
2219     }
2220
2221         copy_info(&info, "\tDriver Version                    : %s%s\n",
2222                   IPS_VERSION_HIGH, IPS_VERSION_LOW);
2223
2224         copy_info(&info, "\tDriver Build                      : %d\n",
2225                   IPS_BUILD_IDENT);
2226
2227         copy_info(&info, "\tMax Physical Devices              : %d\n",
2228                   ha->enq->ucMaxPhysicalDevices);
2229         copy_info(&info, "\tMax Active Commands               : %d\n",
2230                   ha->max_cmds);
2231         copy_info(&info, "\tCurrent Queued Commands           : %d\n",
2232                   ha->scb_waitlist.count);
2233         copy_info(&info, "\tCurrent Active Commands           : %d\n",
2234                   ha->scb_activelist.count - ha->num_ioctl);
2235         copy_info(&info, "\tCurrent Queued PT Commands        : %d\n",
2236                   ha->copp_waitlist.count);
2237         copy_info(&info, "\tCurrent Active PT Commands        : %d\n",
2238                   ha->num_ioctl);
2239
2240         copy_info(&info, "\n");
2241
2242         return (info.localpos);
2243 }
2244
2245 /****************************************************************************/
2246 /*                                                                          */
2247 /* Routine Name: copy_mem_info                                              */
2248 /*                                                                          */
2249 /* Routine Description:                                                     */
2250 /*                                                                          */
2251 /*   Copy data into an IPS_INFOSTR structure                                */
2252 /*                                                                          */
2253 /****************************************************************************/
2254 static void
2255 copy_mem_info(IPS_INFOSTR * info, char *data, int len)
2256 {
2257         METHOD_TRACE("copy_mem_info", 1);
2258
2259         if (info->pos + len < info->offset) {
2260                 info->pos += len;
2261                 return;
2262         }
2263
2264         if (info->pos < info->offset) {
2265                 data += (info->offset - info->pos);
2266                 len -= (info->offset - info->pos);
2267                 info->pos += (info->offset - info->pos);
2268         }
2269
2270         if (info->localpos + len > info->length)
2271                 len = info->length - info->localpos;
2272
2273         if (len > 0) {
2274                 memcpy(info->buffer + info->localpos, data, len);
2275                 info->pos += len;
2276                 info->localpos += len;
2277         }
2278 }
2279
2280 /****************************************************************************/
2281 /*                                                                          */
2282 /* Routine Name: copy_info                                                  */
2283 /*                                                                          */
2284 /* Routine Description:                                                     */
2285 /*                                                                          */
2286 /*   printf style wrapper for an info structure                             */
2287 /*                                                                          */
2288 /****************************************************************************/
2289 static int
2290 copy_info(IPS_INFOSTR * info, char *fmt, ...)
2291 {
2292         va_list args;
2293         char buf[128];
2294         int len;
2295
2296         METHOD_TRACE("copy_info", 1);
2297
2298         va_start(args, fmt);
2299         len = vsprintf(buf, fmt, args);
2300         va_end(args);
2301
2302         copy_mem_info(info, buf, len);
2303
2304         return (len);
2305 }
2306
2307 /****************************************************************************/
2308 /*                                                                          */
2309 /* Routine Name: ips_identify_controller                                    */
2310 /*                                                                          */
2311 /* Routine Description:                                                     */
2312 /*                                                                          */
2313 /*   Identify this controller                                               */
2314 /*                                                                          */
2315 /****************************************************************************/
2316 static void
2317 ips_identify_controller(ips_ha_t * ha)
2318 {
2319         METHOD_TRACE("ips_identify_controller", 1);
2320
2321         switch (ha->device_id) {
2322         case IPS_DEVICEID_COPPERHEAD:
2323                 if (ha->revision_id <= IPS_REVID_SERVERAID) {
2324                         ha->ad_type = IPS_ADTYPE_SERVERAID;
2325                 } else if (ha->revision_id == IPS_REVID_SERVERAID2) {
2326                         ha->ad_type = IPS_ADTYPE_SERVERAID2;
2327                 } else if (ha->revision_id == IPS_REVID_NAVAJO) {
2328                         ha->ad_type = IPS_ADTYPE_NAVAJO;
2329                 } else if ((ha->revision_id == IPS_REVID_SERVERAID2)
2330                            && (ha->slot_num == 0)) {
2331                         ha->ad_type = IPS_ADTYPE_KIOWA;
2332                 } else if ((ha->revision_id >= IPS_REVID_CLARINETP1) &&
2333                            (ha->revision_id <= IPS_REVID_CLARINETP3)) {
2334                         if (ha->enq->ucMaxPhysicalDevices == 15)
2335                                 ha->ad_type = IPS_ADTYPE_SERVERAID3L;
2336                         else
2337                                 ha->ad_type = IPS_ADTYPE_SERVERAID3;
2338                 } else if ((ha->revision_id >= IPS_REVID_TROMBONE32) &&
2339                            (ha->revision_id <= IPS_REVID_TROMBONE64)) {
2340                         ha->ad_type = IPS_ADTYPE_SERVERAID4H;
2341                 }
2342                 break;
2343
2344         case IPS_DEVICEID_MORPHEUS:
2345                 switch (ha->subdevice_id) {
2346                 case IPS_SUBDEVICEID_4L:
2347                         ha->ad_type = IPS_ADTYPE_SERVERAID4L;
2348                         break;
2349
2350                 case IPS_SUBDEVICEID_4M:
2351                         ha->ad_type = IPS_ADTYPE_SERVERAID4M;
2352                         break;
2353
2354                 case IPS_SUBDEVICEID_4MX:
2355                         ha->ad_type = IPS_ADTYPE_SERVERAID4MX;
2356                         break;
2357
2358                 case IPS_SUBDEVICEID_4LX:
2359                         ha->ad_type = IPS_ADTYPE_SERVERAID4LX;
2360                         break;
2361
2362                 case IPS_SUBDEVICEID_5I2:
2363                         ha->ad_type = IPS_ADTYPE_SERVERAID5I2;
2364                         break;
2365
2366                 case IPS_SUBDEVICEID_5I1:
2367                         ha->ad_type = IPS_ADTYPE_SERVERAID5I1;
2368                         break;
2369                 }
2370
2371                 break;
2372
2373         case IPS_DEVICEID_MARCO:
2374                 switch (ha->subdevice_id) {
2375                 case IPS_SUBDEVICEID_6M:
2376                         ha->ad_type = IPS_ADTYPE_SERVERAID6M;
2377                         break;
2378                 case IPS_SUBDEVICEID_6I:
2379                         ha->ad_type = IPS_ADTYPE_SERVERAID6I;
2380                         break;
2381                 case IPS_SUBDEVICEID_7k:
2382                         ha->ad_type = IPS_ADTYPE_SERVERAID7k;
2383                         break;
2384                 case IPS_SUBDEVICEID_7M:
2385                         ha->ad_type = IPS_ADTYPE_SERVERAID7M;
2386                         break;
2387                 }
2388                 break;
2389         }
2390 }
2391
2392 /****************************************************************************/
2393 /*                                                                          */
2394 /* Routine Name: ips_get_bios_version                                       */
2395 /*                                                                          */
2396 /* Routine Description:                                                     */
2397 /*                                                                          */
2398 /*   Get the BIOS revision number                                           */
2399 /*                                                                          */
2400 /****************************************************************************/
2401 static void
2402 ips_get_bios_version(ips_ha_t * ha, int intr)
2403 {
2404         ips_scb_t *scb;
2405         int ret;
2406         uint8_t major;
2407         uint8_t minor;
2408         uint8_t subminor;
2409         uint8_t *buffer;
2410         char hexDigits[] =
2411             { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
2412      'D', 'E', 'F' };
2413
2414         METHOD_TRACE("ips_get_bios_version", 1);
2415
2416         major = 0;
2417         minor = 0;
2418
2419         strncpy(ha->bios_version, "       ?", 8);
2420
2421         if (ha->device_id == IPS_DEVICEID_COPPERHEAD) {
2422                 if (IPS_USE_MEMIO(ha)) {
2423                         /* Memory Mapped I/O */
2424
2425                         /* test 1st byte */
2426                         writel(0, ha->mem_ptr + IPS_REG_FLAP);
2427                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2428                                 udelay(25);     /* 25 us */
2429
2430                         if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
2431                                 return;
2432
2433                         writel(1, ha->mem_ptr + IPS_REG_FLAP);
2434                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2435                                 udelay(25);     /* 25 us */
2436
2437                         if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
2438                                 return;
2439
2440                         /* Get Major version */
2441                         writel(0x1FF, ha->mem_ptr + IPS_REG_FLAP);
2442                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2443                                 udelay(25);     /* 25 us */
2444
2445                         major = readb(ha->mem_ptr + IPS_REG_FLDP);
2446
2447                         /* Get Minor version */
2448                         writel(0x1FE, ha->mem_ptr + IPS_REG_FLAP);
2449                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2450                                 udelay(25);     /* 25 us */
2451                         minor = readb(ha->mem_ptr + IPS_REG_FLDP);
2452
2453                         /* Get SubMinor version */
2454                         writel(0x1FD, ha->mem_ptr + IPS_REG_FLAP);
2455                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2456                                 udelay(25);     /* 25 us */
2457                         subminor = readb(ha->mem_ptr + IPS_REG_FLDP);
2458
2459                 } else {
2460                         /* Programmed I/O */
2461
2462                         /* test 1st byte */
2463                         outl(0, ha->io_addr + IPS_REG_FLAP);
2464                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2465                                 udelay(25);     /* 25 us */
2466
2467                         if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
2468                                 return;
2469
2470                         outl(cpu_to_le32(1), ha->io_addr + IPS_REG_FLAP);
2471                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2472                                 udelay(25);     /* 25 us */
2473
2474                         if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
2475                                 return;
2476
2477                         /* Get Major version */
2478                         outl(cpu_to_le32(0x1FF), ha->io_addr + IPS_REG_FLAP);
2479                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2480                                 udelay(25);     /* 25 us */
2481
2482                         major = inb(ha->io_addr + IPS_REG_FLDP);
2483
2484                         /* Get Minor version */
2485                         outl(cpu_to_le32(0x1FE), ha->io_addr + IPS_REG_FLAP);
2486                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2487                                 udelay(25);     /* 25 us */
2488
2489                         minor = inb(ha->io_addr + IPS_REG_FLDP);
2490
2491                         /* Get SubMinor version */
2492                         outl(cpu_to_le32(0x1FD), ha->io_addr + IPS_REG_FLAP);
2493                         if (ha->revision_id == IPS_REVID_TROMBONE64)
2494                                 udelay(25);     /* 25 us */
2495
2496                         subminor = inb(ha->io_addr + IPS_REG_FLDP);
2497
2498                 }
2499         } else {
2500                 /* Morpheus Family - Send Command to the card */
2501
2502                 buffer = ha->ioctl_data;
2503
2504                 memset(buffer, 0, 0x1000);
2505
2506                 scb = &ha->scbs[ha->max_cmds - 1];
2507
2508                 ips_init_scb(ha, scb);
2509
2510                 scb->timeout = ips_cmd_timeout;
2511                 scb->cdb[0] = IPS_CMD_RW_BIOSFW;
2512
2513                 scb->cmd.flashfw.op_code = IPS_CMD_RW_BIOSFW;
2514                 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
2515                 scb->cmd.flashfw.type = 1;
2516                 scb->cmd.flashfw.direction = 0;
2517                 scb->cmd.flashfw.count = cpu_to_le32(0x800);
2518                 scb->cmd.flashfw.total_packets = 1;
2519                 scb->cmd.flashfw.packet_num = 0;
2520                 scb->data_len = 0x1000;
2521                 scb->cmd.flashfw.buffer_addr = ha->ioctl_busaddr;
2522
2523                 /* issue the command */
2524                 if (((ret =
2525                       ips_send_wait(ha, scb, ips_cmd_timeout,
2526                                     intr)) == IPS_FAILURE)
2527                     || (ret == IPS_SUCCESS_IMM)
2528                     || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
2529                         /* Error occurred */
2530
2531                         return;
2532                 }
2533
2534                 if ((buffer[0xC0] == 0x55) && (buffer[0xC1] == 0xAA)) {
2535                         major = buffer[0x1ff + 0xC0];   /* Offset 0x1ff after the header (0xc0) */
2536                         minor = buffer[0x1fe + 0xC0];   /* Offset 0x1fe after the header (0xc0) */
2537                         subminor = buffer[0x1fd + 0xC0];        /* Offset 0x1fd after the header (0xc0) */
2538                 } else {
2539                         return;
2540                 }
2541         }
2542
2543         ha->bios_version[0] = hexDigits[(major & 0xF0) >> 4];
2544         ha->bios_version[1] = '.';
2545         ha->bios_version[2] = hexDigits[major & 0x0F];
2546         ha->bios_version[3] = hexDigits[subminor];
2547         ha->bios_version[4] = '.';
2548         ha->bios_version[5] = hexDigits[(minor & 0xF0) >> 4];
2549         ha->bios_version[6] = hexDigits[minor & 0x0F];
2550         ha->bios_version[7] = 0;
2551 }
2552
2553 /****************************************************************************/
2554 /*                                                                          */
2555 /* Routine Name: ips_hainit                                                 */
2556 /*                                                                          */
2557 /* Routine Description:                                                     */
2558 /*                                                                          */
2559 /*   Initialize the controller                                              */
2560 /*                                                                          */
2561 /* NOTE: Assumes to be called from with a lock                              */
2562 /*                                                                          */
2563 /****************************************************************************/
2564 static int
2565 ips_hainit(ips_ha_t * ha)
2566 {
2567         int i;
2568         struct timeval tv;
2569
2570         METHOD_TRACE("ips_hainit", 1);
2571
2572         if (!ha)
2573                 return (0);
2574
2575         if (ha->func.statinit)
2576                 (*ha->func.statinit) (ha);
2577
2578         if (ha->func.enableint)
2579                 (*ha->func.enableint) (ha);
2580
2581         /* Send FFDC */
2582         ha->reset_count = 1;
2583         do_gettimeofday(&tv);
2584         ha->last_ffdc = tv.tv_sec;
2585         ips_ffdc_reset(ha, IPS_INTR_IORL);
2586
2587         if (!ips_read_config(ha, IPS_INTR_IORL)) {
2588                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2589                            "unable to read config from controller.\n");
2590
2591                 return (0);
2592         }
2593         /* end if */
2594         if (!ips_read_adapter_status(ha, IPS_INTR_IORL)) {
2595                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2596                            "unable to read controller status.\n");
2597
2598                 return (0);
2599         }
2600
2601         /* Identify this controller */
2602         ips_identify_controller(ha);
2603
2604         if (!ips_read_subsystem_parameters(ha, IPS_INTR_IORL)) {
2605                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2606                            "unable to read subsystem parameters.\n");
2607
2608                 return (0);
2609         }
2610
2611         /* write nvram user page 5 */
2612         if (!ips_write_driver_status(ha, IPS_INTR_IORL)) {
2613                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2614                            "unable to write driver info to controller.\n");
2615
2616                 return (0);
2617         }
2618
2619         /* If there are Logical Drives and a Reset Occurred, then an EraseStripeLock is Needed */
2620         if ((ha->conf->ucLogDriveCount > 0) && (ha->requires_esl == 1))
2621                 ips_clear_adapter(ha, IPS_INTR_IORL);
2622
2623         /* set limits on SID, LUN, BUS */
2624         ha->ntargets = IPS_MAX_TARGETS + 1;
2625         ha->nlun = 1;
2626         ha->nbus = (ha->enq->ucMaxPhysicalDevices / IPS_MAX_TARGETS) + 1;
2627
2628         switch (ha->conf->logical_drive[0].ucStripeSize) {
2629         case 4:
2630                 ha->max_xfer = 0x10000;
2631                 break;
2632
2633         case 5:
2634                 ha->max_xfer = 0x20000;
2635                 break;
2636
2637         case 6:
2638                 ha->max_xfer = 0x40000;
2639                 break;
2640
2641         case 7:
2642         default:
2643                 ha->max_xfer = 0x80000;
2644                 break;
2645         }
2646
2647         /* setup max concurrent commands */
2648         if (le32_to_cpu(ha->subsys->param[4]) & 0x1) {
2649                 /* Use the new method */
2650                 ha->max_cmds = ha->enq->ucConcurrentCmdCount;
2651         } else {
2652                 /* use the old method */
2653                 switch (ha->conf->logical_drive[0].ucStripeSize) {
2654                 case 4:
2655                         ha->max_cmds = 32;
2656                         break;
2657
2658                 case 5:
2659                         ha->max_cmds = 16;
2660                         break;
2661
2662                 case 6:
2663                         ha->max_cmds = 8;
2664                         break;
2665
2666                 case 7:
2667                 default:
2668                         ha->max_cmds = 4;
2669                         break;
2670                 }
2671         }
2672
2673         /* Limit the Active Commands on a Lite Adapter */
2674         if ((ha->ad_type == IPS_ADTYPE_SERVERAID3L) ||
2675             (ha->ad_type == IPS_ADTYPE_SERVERAID4L) ||
2676             (ha->ad_type == IPS_ADTYPE_SERVERAID4LX)) {
2677                 if ((ha->max_cmds > MaxLiteCmds) && (MaxLiteCmds))
2678                         ha->max_cmds = MaxLiteCmds;
2679         }
2680
2681         /* set controller IDs */
2682         ha->ha_id[0] = IPS_ADAPTER_ID;
2683         for (i = 1; i < ha->nbus; i++) {
2684                 ha->ha_id[i] = ha->conf->init_id[i - 1] & 0x1f;
2685                 ha->dcdb_active[i - 1] = 0;
2686         }
2687
2688         return (1);
2689 }
2690
2691 /****************************************************************************/
2692 /*                                                                          */
2693 /* Routine Name: ips_next                                                   */
2694 /*                                                                          */
2695 /* Routine Description:                                                     */
2696 /*                                                                          */
2697 /*   Take the next command off the queue and send it to the controller      */
2698 /*                                                                          */
2699 /****************************************************************************/
2700 static void
2701 ips_next(ips_ha_t * ha, int intr)
2702 {
2703         ips_scb_t *scb;
2704         Scsi_Cmnd *SC;
2705         Scsi_Cmnd *p;
2706         Scsi_Cmnd *q;
2707         ips_copp_wait_item_t *item;
2708         int ret;
2709         unsigned long cpu_flags = 0;
2710         struct Scsi_Host *host;
2711         METHOD_TRACE("ips_next", 1);
2712
2713         if (!ha)
2714                 return;
2715         host = ips_sh[ha->host_num];
2716         /*
2717          * Block access to the queue function so
2718          * this command won't time out
2719          */
2720         if (intr == IPS_INTR_ON)
2721                 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2722
2723         if ((ha->subsys->param[3] & 0x300000)
2724             && (ha->scb_activelist.count == 0)) {
2725                 struct timeval tv;
2726
2727                 do_gettimeofday(&tv);
2728
2729                 if (tv.tv_sec - ha->last_ffdc > IPS_SECS_8HOURS) {
2730                         ha->last_ffdc = tv.tv_sec;
2731                         ips_ffdc_time(ha);
2732                 }
2733         }
2734
2735         /*
2736          * Send passthru commands
2737          * These have priority over normal I/O
2738          * but shouldn't affect performance too much
2739          * since we limit the number that can be active
2740          * on the card at any one time
2741          */
2742         while ((ha->num_ioctl < IPS_MAX_IOCTL) &&
2743                (ha->copp_waitlist.head) && (scb = ips_getscb(ha))) {
2744
2745                 item = ips_removeq_copp_head(&ha->copp_waitlist);
2746                 ha->num_ioctl++;
2747                 if (intr == IPS_INTR_ON)
2748                         IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2749                 scb->scsi_cmd = item->scsi_cmd;
2750                 kfree(item);
2751
2752                 ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
2753
2754                 if (intr == IPS_INTR_ON)
2755                         IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2756                 switch (ret) {
2757                 case IPS_FAILURE:
2758                         if (scb->scsi_cmd) {
2759                                 scb->scsi_cmd->result = DID_ERROR << 16;
2760                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2761                         }
2762
2763                         ips_freescb(ha, scb);
2764                         break;
2765                 case IPS_SUCCESS_IMM:
2766                         if (scb->scsi_cmd) {
2767                                 scb->scsi_cmd->result = DID_OK << 16;
2768                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2769                         }
2770
2771                         ips_freescb(ha, scb);
2772                         break;
2773                 default:
2774                         break;
2775                 }               /* end case */
2776
2777                 if (ret != IPS_SUCCESS) {
2778                         ha->num_ioctl--;
2779                         continue;
2780                 }
2781
2782                 ret = ips_send_cmd(ha, scb);
2783
2784                 if (ret == IPS_SUCCESS)
2785                         ips_putq_scb_head(&ha->scb_activelist, scb);
2786                 else
2787                         ha->num_ioctl--;
2788
2789                 switch (ret) {
2790                 case IPS_FAILURE:
2791                         if (scb->scsi_cmd) {
2792                                 scb->scsi_cmd->result = DID_ERROR << 16;
2793                         }
2794
2795                         ips_freescb(ha, scb);
2796                         break;
2797                 case IPS_SUCCESS_IMM:
2798                         ips_freescb(ha, scb);
2799                         break;
2800                 default:
2801                         break;
2802                 }               /* end case */
2803
2804         }
2805
2806         /*
2807          * Send "Normal" I/O commands
2808          */
2809
2810         p = ha->scb_waitlist.head;
2811         while ((p) && (scb = ips_getscb(ha))) {
2812                 if ((p->device->channel > 0)
2813                     && (ha->
2814                         dcdb_active[p->device->channel -
2815                                     1] & (1 << p->device->id))) {
2816                         ips_freescb(ha, scb);
2817                         p = (Scsi_Cmnd *) p->host_scribble;
2818                         continue;
2819                 }
2820
2821                 q = p;
2822                 SC = ips_removeq_wait(&ha->scb_waitlist, q);
2823
2824                 if (intr == IPS_INTR_ON)
2825                         IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags); /* Unlock HA after command is taken off queue */
2826
2827                 SC->result = DID_OK;
2828                 SC->host_scribble = NULL;
2829
2830                 memset(SC->sense_buffer, 0, sizeof (SC->sense_buffer));
2831
2832                 scb->target_id = SC->device->id;
2833                 scb->lun = SC->device->lun;
2834                 scb->bus = SC->device->channel;
2835                 scb->scsi_cmd = SC;
2836                 scb->breakup = 0;
2837                 scb->data_len = 0;
2838                 scb->callback = ipsintr_done;
2839                 scb->timeout = ips_cmd_timeout;
2840                 memset(&scb->cmd, 0, 16);
2841
2842                 /* copy in the CDB */
2843                 memcpy(scb->cdb, SC->cmnd, SC->cmd_len);
2844
2845                 /* Now handle the data buffer */
2846                 if (SC->use_sg) {
2847                         struct scatterlist *sg;
2848                         int i;
2849
2850                         sg = SC->request_buffer;
2851                         scb->sg_count = pci_map_sg(ha->pcidev, sg, SC->use_sg,
2852                                                    scsi_to_pci_dma_dir(SC->
2853                                                                        sc_data_direction));
2854                         scb->flags |= IPS_SCB_MAP_SG;
2855                         for (i = 0; i < scb->sg_count; i++) {
2856                                 if (ips_fill_scb_sg_single
2857                                     (ha, sg_dma_address(&sg[i]), scb, i,
2858                                      sg_dma_len(&sg[i])) < 0)
2859                                         break;
2860                         }
2861                         scb->dcdb.transfer_length = scb->data_len;
2862                 } else {
2863                         if (SC->request_bufflen) {
2864                                 scb->data_busaddr =
2865                                     pci_map_single(ha->pcidev,
2866                                                    SC->request_buffer,
2867                                                    SC->request_bufflen,
2868                                                    scsi_to_pci_dma_dir(SC->
2869                                                                        sc_data_direction));
2870                                 scb->flags |= IPS_SCB_MAP_SINGLE;
2871                                 ips_fill_scb_sg_single(ha, scb->data_busaddr,
2872                                                        scb, 0,
2873                                                        SC->request_bufflen);
2874                                 scb->dcdb.transfer_length = scb->data_len;
2875                         } else {
2876                                 scb->data_busaddr = 0L;
2877                                 scb->sg_len = 0;
2878                                 scb->data_len = 0;
2879                                 scb->dcdb.transfer_length = 0;
2880                         }
2881
2882                 }
2883
2884                 scb->dcdb.cmd_attribute =
2885                     ips_command_direction[scb->scsi_cmd->cmnd[0]];
2886
2887         /* Allow a WRITE BUFFER Command to Have no Data */
2888         /* This is Used by Tape Flash Utilites          */
2889         if ((scb->scsi_cmd->cmnd[0] == WRITE_BUFFER) && (scb->data_len == 0)) 
2890             scb->dcdb.cmd_attribute = 0;                  
2891
2892                 if (!(scb->dcdb.cmd_attribute & 0x3))
2893                         scb->dcdb.transfer_length = 0;
2894
2895                 if (scb->data_len >= IPS_MAX_XFER) {
2896                         scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
2897                         scb->dcdb.transfer_length = 0;
2898                 }
2899                 if (intr == IPS_INTR_ON)
2900                         IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2901
2902                 ret = ips_send_cmd(ha, scb);
2903
2904                 switch (ret) {
2905                 case IPS_SUCCESS:
2906                         ips_putq_scb_head(&ha->scb_activelist, scb);
2907                         break;
2908                 case IPS_FAILURE:
2909                         if (scb->scsi_cmd) {
2910                                 scb->scsi_cmd->result = DID_ERROR << 16;
2911                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2912                         }
2913
2914                         if (scb->bus)
2915                                 ha->dcdb_active[scb->bus - 1] &=
2916                                     ~(1 << scb->target_id);
2917
2918                         ips_freescb(ha, scb);
2919                         break;
2920                 case IPS_SUCCESS_IMM:
2921                         if (scb->scsi_cmd)
2922                                 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2923
2924                         if (scb->bus)
2925                                 ha->dcdb_active[scb->bus - 1] &=
2926                                     ~(1 << scb->target_id);
2927
2928                         ips_freescb(ha, scb);
2929                         break;
2930                 default:
2931                         break;
2932                 }               /* end case */
2933
2934                 p = (Scsi_Cmnd *) p->host_scribble;
2935
2936         }                       /* end while */
2937
2938         if (intr == IPS_INTR_ON)
2939                 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2940 }
2941
2942 /****************************************************************************/
2943 /*                                                                          */
2944 /* Routine Name: ips_putq_scb_head                                          */
2945 /*                                                                          */
2946 /* Routine Description:                                                     */
2947 /*                                                                          */
2948 /*   Add an item to the head of the queue                                   */
2949 /*                                                                          */
2950 /* ASSUMED to be called from within the HA lock                             */
2951 /*                                                                          */
2952 /****************************************************************************/
2953 static void
2954 ips_putq_scb_head(ips_scb_queue_t * queue, ips_scb_t * item)
2955 {
2956         METHOD_TRACE("ips_putq_scb_head", 1);
2957
2958         if (!item)
2959                 return;
2960
2961         item->q_next = queue->head;
2962         queue->head = item;
2963
2964         if (!queue->tail)
2965                 queue->tail = item;
2966
2967         queue->count++;
2968 }
2969
2970 /****************************************************************************/
2971 /*                                                                          */
2972 /* Routine Name: ips_removeq_scb_head                                       */
2973 /*                                                                          */
2974 /* Routine Description:                                                     */
2975 /*                                                                          */
2976 /*   Remove the head of the queue                                           */
2977 /*                                                                          */
2978 /* ASSUMED to be called from within the HA lock                             */
2979 /*                                                                          */
2980 /****************************************************************************/
2981 static ips_scb_t *
2982 ips_removeq_scb_head(ips_scb_queue_t * queue)
2983 {
2984         ips_scb_t *item;
2985
2986         METHOD_TRACE("ips_removeq_scb_head", 1);
2987
2988         item = queue->head;
2989
2990         if (!item) {
2991                 return (NULL);
2992         }
2993
2994         queue->head = item->q_next;
2995         item->q_next = NULL;
2996
2997         if (queue->tail == item)
2998                 queue->tail = NULL;
2999
3000         queue->count--;
3001
3002         return (item);
3003 }
3004
3005 /****************************************************************************/
3006 /*                                                                          */
3007 /* Routine Name: ips_removeq_scb                                            */
3008 /*                                                                          */
3009 /* Routine Description:                                                     */
3010 /*                                                                          */
3011 /*   Remove an item from a queue                                            */
3012 /*                                                                          */
3013 /* ASSUMED to be called from within the HA lock                             */
3014 /*                                                                          */
3015 /****************************************************************************/
3016 static ips_scb_t *
3017 ips_removeq_scb(ips_scb_queue_t * queue, ips_scb_t * item)
3018 {
3019         ips_scb_t *p;
3020
3021         METHOD_TRACE("ips_removeq_scb", 1);
3022
3023         if (!item)
3024                 return (NULL);
3025
3026         if (item == queue->head) {
3027                 return (ips_removeq_scb_head(queue));
3028         }
3029
3030         p = queue->head;
3031
3032         while ((p) && (item != p->q_next))
3033                 p = p->q_next;
3034
3035         if (p) {
3036                 /* found a match */
3037                 p->q_next = item->q_next;
3038
3039                 if (!item->q_next)
3040                         queue->tail = p;
3041
3042                 item->q_next = NULL;
3043                 queue->count--;
3044
3045                 return (item);
3046         }
3047
3048         return (NULL);
3049 }
3050
3051 /****************************************************************************/
3052 /*                                                                          */
3053 /* Routine Name: ips_putq_wait_tail                                         */
3054 /*                                                                          */
3055 /* Routine Description:                                                     */
3056 /*                                                                          */
3057 /*   Add an item to the tail of the queue                                   */
3058 /*                                                                          */
3059 /* ASSUMED to be called from within the HA lock                             */
3060 /*                                                                          */
3061 /****************************************************************************/
3062 static void
3063 ips_putq_wait_tail(ips_wait_queue_t * queue, Scsi_Cmnd * item)
3064 {
3065         METHOD_TRACE("ips_putq_wait_tail", 1);
3066
3067         if (!item)
3068                 return;
3069
3070         item->host_scribble = NULL;
3071
3072         if (queue->tail)
3073                 queue->tail->host_scribble = (char *) item;
3074
3075         queue->tail = item;
3076
3077         if (!queue->head)
3078                 queue->head = item;
3079
3080         queue->count++;
3081 }
3082
3083 /****************************************************************************/
3084 /*                                                                          */
3085 /* Routine Name: ips_removeq_wait_head                                      */
3086 /*                                                                          */
3087 /* Routine Description:                                                     */
3088 /*                                                                          */
3089 /*   Remove the head of the queue                                           */
3090 /*                                                                          */
3091 /* ASSUMED to be called from within the HA lock                             */
3092 /*                                                                          */
3093 /****************************************************************************/
3094 static Scsi_Cmnd *
3095 ips_removeq_wait_head(ips_wait_queue_t * queue)
3096 {
3097         Scsi_Cmnd *item;
3098
3099         METHOD_TRACE("ips_removeq_wait_head", 1);
3100
3101         item = queue->head;
3102
3103         if (!item) {
3104                 return (NULL);
3105         }
3106
3107         queue->head = (Scsi_Cmnd *) item->host_scribble;
3108         item->host_scribble = NULL;
3109
3110         if (queue->tail == item)
3111                 queue->tail = NULL;
3112
3113         queue->count--;
3114
3115         return (item);
3116 }
3117
3118 /****************************************************************************/
3119 /*                                                                          */
3120 /* Routine Name: ips_removeq_wait                                           */
3121 /*                                                                          */
3122 /* Routine Description:                                                     */
3123 /*                                                                          */
3124 /*   Remove an item from a queue                                            */
3125 /*                                                                          */
3126 /* ASSUMED to be called from within the HA lock                             */
3127 /*                                                                          */
3128 /****************************************************************************/
3129 static Scsi_Cmnd *
3130 ips_removeq_wait(ips_wait_queue_t * queue, Scsi_Cmnd * item)
3131 {
3132         Scsi_Cmnd *p;
3133
3134         METHOD_TRACE("ips_removeq_wait", 1);
3135
3136         if (!item)
3137                 return (NULL);
3138
3139         if (item == queue->head) {
3140                 return (ips_removeq_wait_head(queue));
3141         }
3142
3143         p = queue->head;
3144
3145         while ((p) && (item != (Scsi_Cmnd *) p->host_scribble))
3146                 p = (Scsi_Cmnd *) p->host_scribble;
3147
3148         if (p) {
3149                 /* found a match */
3150                 p->host_scribble = item->host_scribble;
3151
3152                 if (!item->host_scribble)
3153                         queue->tail = p;
3154
3155                 item->host_scribble = NULL;
3156                 queue->count--;
3157
3158                 return (item);
3159         }
3160
3161         return (NULL);
3162 }
3163
3164 /****************************************************************************/
3165 /*                                                                          */
3166 /* Routine Name: ips_putq_copp_tail                                         */
3167 /*                                                                          */
3168 /* Routine Description:                                                     */
3169 /*                                                                          */
3170 /*   Add an item to the tail of the queue                                   */
3171 /*                                                                          */
3172 /* ASSUMED to be called from within the HA lock                             */
3173 /*                                                                          */
3174 /****************************************************************************/
3175 static void
3176 ips_putq_copp_tail(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3177 {
3178         METHOD_TRACE("ips_putq_copp_tail", 1);
3179
3180         if (!item)
3181                 return;
3182
3183         item->next = NULL;
3184
3185         if (queue->tail)
3186                 queue->tail->next = item;
3187
3188         queue->tail = item;
3189
3190         if (!queue->head)
3191                 queue->head = item;
3192
3193         queue->count++;
3194 }
3195
3196 /****************************************************************************/
3197 /*                                                                          */
3198 /* Routine Name: ips_removeq_copp_head                                      */
3199 /*                                                                          */
3200 /* Routine Description:                                                     */
3201 /*                                                                          */
3202 /*   Remove the head of the queue                                           */
3203 /*                                                                          */
3204 /* ASSUMED to be called from within the HA lock                             */
3205 /*                                                                          */
3206 /****************************************************************************/
3207 static ips_copp_wait_item_t *
3208 ips_removeq_copp_head(ips_copp_queue_t * queue)
3209 {
3210         ips_copp_wait_item_t *item;
3211
3212         METHOD_TRACE("ips_removeq_copp_head", 1);
3213
3214         item = queue->head;
3215
3216         if (!item) {
3217                 return (NULL);
3218         }
3219
3220         queue->head = item->next;
3221         item->next = NULL;
3222
3223         if (queue->tail == item)
3224                 queue->tail = NULL;
3225
3226         queue->count--;
3227
3228         return (item);
3229 }
3230
3231 /****************************************************************************/
3232 /*                                                                          */
3233 /* Routine Name: ips_removeq_copp                                           */
3234 /*                                                                          */
3235 /* Routine Description:                                                     */
3236 /*                                                                          */
3237 /*   Remove an item from a queue                                            */
3238 /*                                                                          */
3239 /* ASSUMED to be called from within the HA lock                             */
3240 /*                                                                          */
3241 /****************************************************************************/
3242 static ips_copp_wait_item_t *
3243 ips_removeq_copp(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3244 {
3245         ips_copp_wait_item_t *p;
3246
3247         METHOD_TRACE("ips_removeq_copp", 1);
3248
3249         if (!item)
3250                 return (NULL);
3251
3252         if (item == queue->head) {
3253                 return (ips_removeq_copp_head(queue));
3254         }
3255
3256         p = queue->head;
3257
3258         while ((p) && (item != p->next))
3259                 p = p->next;
3260
3261         if (p) {
3262                 /* found a match */
3263                 p->next = item->next;
3264
3265                 if (!item->next)
3266                         queue->tail = p;
3267
3268                 item->next = NULL;
3269                 queue->count--;
3270
3271                 return (item);
3272         }
3273
3274         return (NULL);
3275 }
3276
3277 /****************************************************************************/
3278 /*                                                                          */
3279 /* Routine Name: ipsintr_blocking                                           */
3280 /*                                                                          */
3281 /* Routine Description:                                                     */
3282 /*                                                                          */
3283 /*   Finalize an interrupt for internal commands                            */
3284 /*                                                                          */
3285 /****************************************************************************/
3286 static void
3287 ipsintr_blocking(ips_ha_t * ha, ips_scb_t * scb)
3288 {
3289         METHOD_TRACE("ipsintr_blocking", 2);
3290
3291         ips_freescb(ha, scb);
3292         if ((ha->waitflag == TRUE) && (ha->cmd_in_progress == scb->cdb[0])) {
3293                 ha->waitflag = FALSE;
3294
3295                 return;
3296         }
3297 }
3298
3299 /****************************************************************************/
3300 /*                                                                          */
3301 /* Routine Name: ipsintr_done                                               */
3302 /*                                                                          */
3303 /* Routine Description:                                                     */
3304 /*                                                                          */
3305 /*   Finalize an interrupt for non-internal commands                        */
3306 /*                                                                          */
3307 /****************************************************************************/
3308 static void
3309 ipsintr_done(ips_ha_t * ha, ips_scb_t * scb)
3310 {
3311         METHOD_TRACE("ipsintr_done", 2);
3312
3313         if (!scb) {
3314                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3315                            "Spurious interrupt; scb NULL.\n");
3316
3317                 return;
3318         }
3319
3320         if (scb->scsi_cmd == NULL) {
3321                 /* unexpected interrupt */
3322                 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3323                            "Spurious interrupt; scsi_cmd not set.\n");
3324
3325                 return;
3326         }
3327
3328         ips_done(ha, scb);
3329 }
3330
3331 /****************************************************************************/
3332 /*                                                                          */
3333 /* Routine Name: ips_done                                                   */
3334 /*                                                                          */
3335 /* Routine Description:                                                     */
3336 /*                                                                          */
3337 /*   Do housekeeping on completed commands                                  */
3338 /*  ASSUMED to be called form within the request lock                       */
3339 /****************************************************************************/
3340 static void
3341 ips_done(ips_ha_t * ha, ips_scb_t * scb)
3342 {
3343         int ret;
3344
3345         METHOD_TRACE("ips_done", 1);
3346
3347         if (!scb)
3348                 return;
3349
3350         if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd))) {
3351                 ips_cleanup_passthru(ha, scb);
3352                 ha->num_ioctl--;
3353         } else {
3354                 /*
3355                  * Check to see if this command had too much
3356                  * data and had to be broke up.  If so, queue
3357                  * the rest of the data and continue.
3358                  */
3359                 if ((scb->breakup) || (scb->sg_break)) {
3360                         /* we had a data breakup */
3361                         scb->data_len = 0;
3362
3363                         if (scb->sg_count) {
3364                                 /* S/G request */
3365                                 struct scatterlist *sg;
3366                                 int ips_sg_index = 0;
3367                                 int sg_dma_index;
3368
3369                                 sg = scb->scsi_cmd->request_buffer;
3370
3371                                 /* Spin forward to last dma chunk */
3372                                 sg_dma_index = scb->breakup;
3373
3374                                 /* Take care of possible partial on last chunk */
3375                                 ips_fill_scb_sg_single(ha,
3376                                                        sg_dma_address(&sg
3377                                                                       [sg_dma_index]),
3378                                                        scb, ips_sg_index++,
3379                                                        sg_dma_len(&sg
3380                                                                   [sg_dma_index]));
3381
3382                                 for (; sg_dma_index < scb->sg_count;
3383                                      sg_dma_index++) {
3384                                         if (ips_fill_scb_sg_single
3385                                             (ha,
3386                                              sg_dma_address(&sg[sg_dma_index]),
3387                                              scb, ips_sg_index++,
3388                                              sg_dma_len(&sg[sg_dma_index])) < 0)
3389                                                 break;
3390
3391                                 }
3392
3393                         } else {
3394                                 /* Non S/G Request */
3395                                 (void) ips_fill_scb_sg_single(ha,
3396                                                               scb->
3397                                                               data_busaddr +
3398                                                               (scb->sg_break *
3399                                                                ha->max_xfer),
3400                                                               scb, 0,
3401                                                               scb->scsi_cmd->
3402                                                               request_bufflen -
3403                                                               (scb->sg_break *
3404                                                                ha->max_xfer));
3405                         }
3406
3407                         scb->dcdb.transfer_length = scb->data_len;
3408                         scb->dcdb.cmd_attribute |=
3409                             ips_command_direction[scb->scsi_cmd->cmnd[0]];
3410
3411                         if (!(scb->dcdb.cmd_attribute & 0x3))
3412                                 scb->dcdb.transfer_length = 0;
3413
3414                         if (scb->data_len >= IPS_MAX_XFER) {
3415                                 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
3416                                 scb->dcdb.transfer_length = 0;
3417                         }
3418
3419                         ret = ips_send_cmd(ha, scb);
3420
3421                         switch (ret) {
3422                         case IPS_FAILURE:
3423                                 if (scb->scsi_cmd) {
3424                                         scb->scsi_cmd->result = DID_ERROR << 16;
3425                                         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3426                                 }
3427
3428                                 ips_freescb(ha, scb);
3429                                 break;
3430                         case IPS_SUCCESS_IMM:
3431                                 if (scb->scsi_cmd) {
3432                                         scb->scsi_cmd->result = DID_ERROR << 16;
3433                                         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3434                                 }
3435
3436                                 ips_freescb(ha, scb);
3437                                 break;
3438                         default:
3439                                 break;
3440                         }       /* end case */
3441
3442                         return;
3443                 }
3444         }                       /* end if passthru */
3445
3446         if (scb->bus) {
3447                 ha->dcdb_active[scb->bus - 1] &= ~(1 << scb->target_id);
3448         }
3449
3450         scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3451
3452         ips_freescb(ha, scb);
3453 }
3454
3455 /****************************************************************************/
3456 /*                                                                          */
3457 /* Routine Name: ips_map_status                                             */
3458 /*                                                                          */
3459 /* Routine Description:                                                     */
3460 /*                                                                          */
3461 /*   Map Controller Error codes to Linux Error Codes                        */
3462 /*                                                                          */
3463 /****************************************************************************/
3464 static int
3465 ips_map_status(ips_ha_t * ha, ips_scb_t * scb, ips_stat_t * sp)
3466 {
3467         int errcode;
3468         int device_error;
3469         uint32_t transfer_len;
3470         IPS_DCDB_TABLE_TAPE *tapeDCDB;
3471
3472         METHOD_TRACE("ips_map_status", 1);
3473
3474         if (scb->bus) {
3475                 DEBUG_VAR(2,
3476                           "(%s%d) Physical device error (%d %d %d): %x %x, Sense Key: %x, ASC: %x, ASCQ: %x",
3477                           ips_name, ha->host_num,
3478                           scb->scsi_cmd->device->channel,
3479                           scb->scsi_cmd->device->id, scb->scsi_cmd->device->lun,
3480                           scb->basic_status, scb->extended_status,
3481                           scb->extended_status ==
3482                           IPS_ERR_CKCOND ? scb->dcdb.sense_info[2] & 0xf : 0,
3483                           scb->extended_status ==
3484                           IPS_ERR_CKCOND ? scb->dcdb.sense_info[12] : 0,
3485                           scb->extended_status ==
3486                           IPS_ERR_CKCOND ? scb->dcdb.sense_info[13] : 0);
3487         }
3488
3489         /* default driver error */
3490         errcode = DID_ERROR;
3491         device_error = 0;
3492
3493         switch (scb->basic_status & IPS_GSC_STATUS_MASK) {
3494         case IPS_CMD_TIMEOUT:
3495                 errcode = DID_TIME_OUT;
3496                 break;
3497
3498         case IPS_INVAL_OPCO:
3499         case IPS_INVAL_CMD_BLK:
3500         case IPS_INVAL_PARM_BLK:
3501         case IPS_LD_ERROR:
3502         case IPS_CMD_CMPLT_WERROR:
3503                 break;
3504
3505         case IPS_PHYS_DRV_ERROR:
3506                 switch (scb->extended_status) {
3507                 case IPS_ERR_SEL_TO:
3508                         if (scb->bus)
3509                                 errcode = DID_NO_CONNECT;
3510
3511                         break;
3512
3513                 case IPS_ERR_OU_RUN:
3514                         if ((scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB) ||
3515                             (scb->cmd.dcdb.op_code ==
3516                              IPS_CMD_EXTENDED_DCDB_SG)) {
3517                                 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3518                                 transfer_len = tapeDCDB->transfer_length;
3519                         } else {
3520                                 transfer_len =
3521                                     (uint32_t) scb->dcdb.transfer_length;
3522                         }
3523
3524                         if ((scb->bus) && (transfer_len < scb->data_len)) {
3525                                 /* Underrun - set default to no error */
3526                                 errcode = DID_OK;
3527
3528                                 /* Restrict access to physical DASD */
3529                                 if ((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
3530                                     ((((char *) scb->scsi_cmd->
3531                                        buffer)[0] & 0x1f) == TYPE_DISK)) {
3532                                         /* underflow -- no error               */
3533                                         /* restrict access to physical DASD    */
3534                                         errcode = DID_TIME_OUT;
3535                                         break;
3536                                 }
3537                         } else
3538                                 errcode = DID_ERROR;
3539
3540                         break;
3541
3542                 case IPS_ERR_RECOVERY:
3543                         /* don't fail recovered errors */
3544                         if (scb->bus)
3545                                 errcode = DID_OK;
3546
3547                         break;
3548
3549                 case IPS_ERR_HOST_RESET:
3550                 case IPS_ERR_DEV_RESET:
3551                         errcode = DID_RESET;
3552                         break;
3553
3554                 case IPS_ERR_CKCOND:
3555                         if (scb->bus) {
3556                                 if ((scb->cmd.dcdb.op_code ==
3557                                      IPS_CMD_EXTENDED_DCDB)
3558                                     || (scb->cmd.dcdb.op_code ==
3559                                         IPS_CMD_EXTENDED_DCDB_SG)) {
3560                                         tapeDCDB =
3561                                             (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3562                                         memcpy(scb->scsi_cmd->sense_buffer,
3563                                                tapeDCDB->sense_info,
3564                                                sizeof (scb->scsi_cmd->
3565                                                        sense_buffer));
3566                                 } else {
3567                                         memcpy(scb->scsi_cmd->sense_buffer,
3568                                                scb->dcdb.sense_info,
3569                                                sizeof (scb->scsi_cmd->
3570                                                        sense_buffer));
3571                                 }
3572                                 device_error = 2;       /* check condition */
3573                         }
3574
3575                         errcode = DID_OK;
3576
3577                         break;
3578
3579                 default:
3580                         errcode = DID_ERROR;
3581                         break;
3582
3583                 }               /* end switch */
3584         }                       /* end switch */
3585
3586         scb->scsi_cmd->result = device_error | (errcode << 16);
3587
3588         return (1);
3589 }
3590
3591 /****************************************************************************/
3592 /*                                                                          */
3593 /* Routine Name: ips_send_wait                                              */
3594 /*                                                                          */
3595 /* Routine Description:                                                     */
3596 /*                                                                          */
3597 /*   Send a command to the controller and wait for it to return             */
3598 /*                                                                          */
3599 /*   The FFDC Time Stamp use this function for the callback, but doesn't    */
3600 /*   actually need to wait.                                                 */
3601 /****************************************************************************/
3602 static int
3603 ips_send_wait(ips_ha_t * ha, ips_scb_t * scb, int timeout, int intr)
3604 {
3605         int ret;
3606
3607         METHOD_TRACE("ips_send_wait", 1);
3608
3609         if (intr != IPS_FFDC) { /* Won't be Waiting if this is a Time Stamp */
3610                 ha->waitflag = TRUE;
3611                 ha->cmd_in_progress = scb->cdb[0];
3612         }
3613         scb->callback = ipsintr_blocking;
3614         ret = ips_send_cmd(ha, scb);
3615
3616         if ((ret == IPS_FAILURE) || (ret == IPS_SUCCESS_IMM))
3617                 return (ret);
3618
3619         if (intr != IPS_FFDC)   /* Don't Wait around if this is a Time Stamp */
3620                 ret = ips_wait(ha, timeout, intr);
3621
3622         return (ret);
3623 }
3624
3625 /****************************************************************************/
3626 /*                                                                          */
3627 /* Routine Name: ips_scmd_buf_write                                         */
3628 /*                                                                          */
3629 /* Routine Description:                                                     */
3630 /*  Write data to Scsi_Cmnd request_buffer at proper offsets                */
3631 /****************************************************************************/
3632 static void
3633 ips_scmd_buf_write(Scsi_Cmnd * scmd, void *data, unsigned
3634                    int count)
3635 {
3636         if (scmd->use_sg) {
3637                 int i;
3638                 unsigned int min_cnt, xfer_cnt;
3639                 char *cdata = (char *) data;
3640                 struct scatterlist *sg = scmd->request_buffer;
3641                 for (i = 0, xfer_cnt = 0;
3642                      (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3643                         if (!IPS_SG_ADDRESS(&sg[i]))
3644                                 return;
3645                         min_cnt = min(count - xfer_cnt, sg[i].length);
3646                         memcpy(IPS_SG_ADDRESS(&sg[i]), &cdata[xfer_cnt],
3647                                min_cnt);
3648                         xfer_cnt += min_cnt;
3649                 }
3650
3651         } else {
3652                 unsigned int min_cnt = min(count, scmd->request_bufflen);
3653                 memcpy(scmd->request_buffer, data, min_cnt);
3654         }
3655 }
3656
3657 /****************************************************************************/
3658 /*                                                                          */
3659 /* Routine Name: ips_scmd_buf_read                                          */
3660 /*                                                                          */
3661 /* Routine Description:                                                     */
3662 /*  Copy data from a Scsi_Cmnd to a new, linear buffer                      */
3663 /****************************************************************************/
3664 static void
3665 ips_scmd_buf_read(Scsi_Cmnd * scmd, void *data, unsigned
3666                   int count)
3667 {
3668         if (scmd->use_sg) {
3669                 int i;
3670                 unsigned int min_cnt, xfer_cnt;
3671                 char *cdata = (char *) data;
3672                 struct scatterlist *sg = scmd->request_buffer;
3673                 for (i = 0, xfer_cnt = 0;
3674                      (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3675                         if (!IPS_SG_ADDRESS(&sg[i]))
3676                                 return;
3677                         min_cnt = min(count - xfer_cnt, sg[i].length);
3678                         memcpy(&cdata[xfer_cnt], IPS_SG_ADDRESS(&sg[i]),
3679                                min_cnt);
3680                         xfer_cnt += min_cnt;
3681                 }
3682
3683         } else {
3684                 unsigned int min_cnt = min(count, scmd->request_bufflen);
3685                 memcpy(data, scmd->request_buffer, min_cnt);
3686         }
3687 }
3688
3689 /****************************************************************************/
3690 /*                                                                          */
3691 /* Routine Name: ips_send_cmd                                               */
3692 /*                                                                          */
3693 /* Routine Description:                                                     */
3694 /*                                                                          */
3695 /*   Map SCSI commands to ServeRAID commands for logical drives             */
3696 /*                                                                          */
3697 /****************************************************************************/
3698 static int
3699 ips_send_cmd(ips_ha_t * ha, ips_scb_t * scb)
3700 {
3701         int ret;
3702         char *sp;
3703         int device_error;
3704         IPS_DCDB_TABLE_TAPE *tapeDCDB;
3705         int TimeOut;
3706
3707         METHOD_TRACE("ips_send_cmd", 1);
3708
3709         ret = IPS_SUCCESS;
3710
3711         if (!scb->scsi_cmd) {
3712                 /* internal command */
3713
3714                 if (scb->bus > 0) {
3715                         /* Controller commands can't be issued */
3716                         /* to real devices -- fail them        */
3717                         if ((ha->waitflag == TRUE) &&
3718                             (ha->cmd_in_progress == scb->cdb[0])) {
3719                                 ha->waitflag = FALSE;
3720                         }
3721
3722                         return (1);
3723                 }
3724         } else if ((scb->bus == 0) && (!ips_is_passthru(scb->scsi_cmd))) {
3725                 /* command to logical bus -- interpret */
3726                 ret = IPS_SUCCESS_IMM;
3727
3728                 switch (scb->scsi_cmd->cmnd[0]) {
3729                 case ALLOW_MEDIUM_REMOVAL:
3730                 case REZERO_UNIT:
3731                 case ERASE:
3732                 case WRITE_FILEMARKS:
3733                 case SPACE:
3734                         scb->scsi_cmd->result = DID_ERROR << 16;
3735                         break;
3736
3737                 case START_STOP:
3738                         scb->scsi_cmd->result = DID_OK << 16;
3739
3740                 case TEST_UNIT_READY:
3741                 case INQUIRY:
3742                         if (scb->target_id == IPS_ADAPTER_ID) {
3743                                 /*
3744                                  * Either we have a TUR
3745                                  * or we have a SCSI inquiry
3746                                  */
3747                                 if (scb->scsi_cmd->cmnd[0] == TEST_UNIT_READY)
3748                                         scb->scsi_cmd->result = DID_OK << 16;
3749
3750                                 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3751                                         IPS_SCSI_INQ_DATA inquiry;
3752
3753                                         memset(&inquiry, 0,
3754                                                sizeof (IPS_SCSI_INQ_DATA));
3755
3756                                         inquiry.DeviceType =
3757                                             IPS_SCSI_INQ_TYPE_PROCESSOR;
3758                                         inquiry.DeviceTypeQualifier =
3759                                             IPS_SCSI_INQ_LU_CONNECTED;
3760                                         inquiry.Version = IPS_SCSI_INQ_REV2;
3761                                         inquiry.ResponseDataFormat =
3762                                             IPS_SCSI_INQ_RD_REV2;
3763                                         inquiry.AdditionalLength = 31;
3764                                         inquiry.Flags[0] =
3765                                             IPS_SCSI_INQ_Address16;
3766                                         inquiry.Flags[1] =
3767                                             IPS_SCSI_INQ_WBus16 |
3768                                             IPS_SCSI_INQ_Sync;
3769                                         strncpy(inquiry.VendorId, "IBM     ",
3770                                                 8);
3771                                         strncpy(inquiry.ProductId,
3772                                                 "SERVERAID       ", 16);
3773                                         strncpy(inquiry.ProductRevisionLevel,
3774                                                 "1.00", 4);
3775
3776                                         ips_scmd_buf_write(scb->scsi_cmd,
3777                                                            &inquiry,
3778                                                            sizeof (inquiry));
3779
3780                                         scb->scsi_cmd->result = DID_OK << 16;
3781                                 }
3782                         } else {
3783                                 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3784                                 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3785                                 scb->cmd.logical_info.reserved = 0;
3786                                 scb->cmd.logical_info.reserved2 = 0;
3787                                 scb->data_len = sizeof (IPS_LD_INFO);
3788                                 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3789                                 scb->flags = 0;
3790                                 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3791                                 ret = IPS_SUCCESS;
3792                         }
3793
3794                         break;
3795
3796                 case REQUEST_SENSE:
3797                         ips_reqsen(ha, scb);
3798                         scb->scsi_cmd->result = DID_OK << 16;
3799                         break;
3800
3801                 case READ_6:
3802                 case WRITE_6:
3803                         if (!scb->sg_len) {
3804                                 scb->cmd.basic_io.op_code =
3805                                     (scb->scsi_cmd->cmnd[0] ==
3806                                      READ_6) ? IPS_CMD_READ : IPS_CMD_WRITE;
3807                                 scb->cmd.basic_io.enhanced_sg = 0;
3808                                 scb->cmd.basic_io.sg_addr =
3809                                     cpu_to_le32(scb->data_busaddr);
3810                         } else {
3811                                 scb->cmd.basic_io.op_code =
3812                                     (scb->scsi_cmd->cmnd[0] ==
3813                                      READ_6) ? IPS_CMD_READ_SG :
3814                                     IPS_CMD_WRITE_SG;
3815                                 scb->cmd.basic_io.enhanced_sg =
3816                                     IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3817                                 scb->cmd.basic_io.sg_addr =
3818                                     cpu_to_le32(scb->sg_busaddr);
3819                         }
3820
3821                         scb->cmd.basic_io.segment_4G = 0;
3822                         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3823                         scb->cmd.basic_io.log_drv = scb->target_id;
3824                         scb->cmd.basic_io.sg_count = scb->sg_len;
3825
3826                         if (scb->cmd.basic_io.lba)
3827                                 scb->cmd.basic_io.lba =
3828                                     cpu_to_le32(le32_to_cpu
3829                                                 (scb->cmd.basic_io.lba) +
3830                                                 le16_to_cpu(scb->cmd.basic_io.
3831                                                             sector_count));
3832                         else
3833                                 scb->cmd.basic_io.lba =
3834                                     (((scb->scsi_cmd->
3835                                        cmnd[1] & 0x1f) << 16) | (scb->scsi_cmd->
3836                                                                  cmnd[2] << 8) |
3837                                      (scb->scsi_cmd->cmnd[3]));
3838
3839                         scb->cmd.basic_io.sector_count =
3840                             cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3841
3842                         if (le16_to_cpu(scb->cmd.basic_io.sector_count) == 0)
3843                                 scb->cmd.basic_io.sector_count =
3844                                     cpu_to_le16(256);
3845
3846                         ret = IPS_SUCCESS;
3847                         break;
3848
3849                 case READ_10:
3850                 case WRITE_10:
3851                         if (!scb->sg_len) {
3852                                 scb->cmd.basic_io.op_code =
3853                                     (scb->scsi_cmd->cmnd[0] ==
3854                                      READ_10) ? IPS_CMD_READ : IPS_CMD_WRITE;
3855                                 scb->cmd.basic_io.enhanced_sg = 0;
3856                                 scb->cmd.basic_io.sg_addr =
3857                                     cpu_to_le32(scb->data_busaddr);
3858                         } else {
3859                                 scb->cmd.basic_io.op_code =
3860                                     (scb->scsi_cmd->cmnd[0] ==
3861                                      READ_10) ? IPS_CMD_READ_SG :
3862                                     IPS_CMD_WRITE_SG;
3863                                 scb->cmd.basic_io.enhanced_sg =
3864                                     IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3865                                 scb->cmd.basic_io.sg_addr =
3866                                     cpu_to_le32(scb->sg_busaddr);
3867                         }
3868
3869                         scb->cmd.basic_io.segment_4G = 0;
3870                         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3871                         scb->cmd.basic_io.log_drv = scb->target_id;
3872                         scb->cmd.basic_io.sg_count = scb->sg_len;
3873
3874                         if (scb->cmd.basic_io.lba)
3875                                 scb->cmd.basic_io.lba =
3876                                     cpu_to_le32(le32_to_cpu
3877                                                 (scb->cmd.basic_io.lba) +
3878                                                 le16_to_cpu(scb->cmd.basic_io.
3879                                                             sector_count));
3880                         else
3881                                 scb->cmd.basic_io.lba =
3882                                     ((scb->scsi_cmd->cmnd[2] << 24) | (scb->
3883                                                                        scsi_cmd->
3884                                                                        cmnd[3]
3885                                                                        << 16) |
3886                                      (scb->scsi_cmd->cmnd[4] << 8) | scb->
3887                                      scsi_cmd->cmnd[5]);
3888
3889                         scb->cmd.basic_io.sector_count =
3890                             cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3891
3892                         if (cpu_to_le16(scb->cmd.basic_io.sector_count) == 0) {
3893                                 /*
3894                                  * This is a null condition
3895                                  * we don't have to do anything
3896                                  * so just return
3897                                  */
3898                                 scb->scsi_cmd->result = DID_OK << 16;
3899                         } else
3900                                 ret = IPS_SUCCESS;
3901
3902                         break;
3903
3904                 case RESERVE:
3905                 case RELEASE:
3906                         scb->scsi_cmd->result = DID_OK << 16;
3907                         break;
3908
3909                 case MODE_SENSE:
3910                         scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
3911                         scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3912                         scb->cmd.basic_io.segment_4G = 0;
3913                         scb->cmd.basic_io.enhanced_sg = 0;
3914                         scb->data_len = sizeof (*ha->enq);
3915                         scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
3916                         ret = IPS_SUCCESS;
3917                         break;
3918
3919                 case READ_CAPACITY:
3920                         scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3921                         scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3922                         scb->cmd.logical_info.reserved = 0;
3923                         scb->cmd.logical_info.reserved2 = 0;
3924                         scb->cmd.logical_info.reserved3 = 0;
3925                         scb->data_len = sizeof (IPS_LD_INFO);
3926                         scb->data_busaddr = ha->logical_drive_info_dma_addr;
3927                         scb->flags = 0;
3928                         scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3929                         ret = IPS_SUCCESS;
3930                         break;
3931
3932                 case SEND_DIAGNOSTIC:
3933                 case REASSIGN_BLOCKS:
3934                 case FORMAT_UNIT:
3935                 case SEEK_10:
3936                 case VERIFY:
3937                 case READ_DEFECT_DATA:
3938                 case READ_BUFFER:
3939                 case WRITE_BUFFER:
3940                         scb->scsi_cmd->result = DID_OK << 16;
3941                         break;
3942
3943                 default:
3944                         /* Set the Return Info to appear like the Command was */
3945                         /* attempted, a Check Condition occurred, and Sense   */
3946                         /* Data indicating an Invalid CDB OpCode is returned. */
3947                         sp = (char *) scb->scsi_cmd->sense_buffer;
3948                         memset(sp, 0, sizeof (scb->scsi_cmd->sense_buffer));
3949
3950                         sp[0] = 0x70;   /* Error Code               */
3951                         sp[2] = ILLEGAL_REQUEST;        /* Sense Key 5 Illegal Req. */
3952                         sp[7] = 0x0A;   /* Additional Sense Length  */
3953                         sp[12] = 0x20;  /* ASC = Invalid OpCode     */
3954                         sp[13] = 0x00;  /* ASCQ                     */
3955
3956                         device_error = 2;       /* Indicate Check Condition */
3957                         scb->scsi_cmd->result = device_error | (DID_OK << 16);
3958                         break;
3959                 }               /* end switch */
3960         }
3961         /* end if */
3962         if (ret == IPS_SUCCESS_IMM)
3963                 return (ret);
3964
3965         /* setup DCDB */
3966         if (scb->bus > 0) {
3967
3968                 /* If we already know the Device is Not there, no need to attempt a Command   */
3969                 /* This also protects an NT FailOver Controller from getting CDB's sent to it */
3970                 if (ha->conf->dev[scb->bus - 1][scb->target_id].ucState == 0) {
3971                         scb->scsi_cmd->result = DID_NO_CONNECT << 16;
3972                         return (IPS_SUCCESS_IMM);
3973                 }
3974
3975                 ha->dcdb_active[scb->bus - 1] |= (1 << scb->target_id);
3976                 scb->cmd.dcdb.command_id = IPS_COMMAND_ID(ha, scb);
3977                 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
3978                                                          (unsigned long) &scb->
3979                                                          dcdb -
3980                                                          (unsigned long) scb);
3981                 scb->cmd.dcdb.reserved = 0;
3982                 scb->cmd.dcdb.reserved2 = 0;
3983                 scb->cmd.dcdb.reserved3 = 0;
3984                 scb->cmd.dcdb.segment_4G = 0;
3985                 scb->cmd.dcdb.enhanced_sg = 0;
3986
3987                 TimeOut = scb->scsi_cmd->timeout_per_command;
3988
3989                 if (ha->subsys->param[4] & 0x00100000) {        /* If NEW Tape DCDB is Supported */
3990                         if (!scb->sg_len) {
3991                                 scb->cmd.dcdb.op_code = IPS_CMD_EXTENDED_DCDB;
3992                         } else {
3993                                 scb->cmd.dcdb.op_code =
3994                                     IPS_CMD_EXTENDED_DCDB_SG;
3995                                 scb->cmd.dcdb.enhanced_sg =
3996                                     IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3997                         }
3998
3999                         tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb; /* Use Same Data Area as Old DCDB Struct */
4000                         tapeDCDB->device_address =
4001                             ((scb->bus - 1) << 4) | scb->target_id;
4002                         tapeDCDB->cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4003                         tapeDCDB->cmd_attribute &= ~IPS_TRANSFER64K;    /* Always Turn OFF 64K Size Flag */
4004
4005                         if (TimeOut) {
4006                                 if (TimeOut < (10 * HZ))
4007                                         tapeDCDB->cmd_attribute |= IPS_TIMEOUT10;       /* TimeOut is 10 Seconds */
4008                                 else if (TimeOut < (60 * HZ))
4009                                         tapeDCDB->cmd_attribute |= IPS_TIMEOUT60;       /* TimeOut is 60 Seconds */
4010                                 else if (TimeOut < (1200 * HZ))
4011                                         tapeDCDB->cmd_attribute |= IPS_TIMEOUT20M;      /* TimeOut is 20 Minutes */
4012                         }
4013
4014                         tapeDCDB->cdb_length = scb->scsi_cmd->cmd_len;
4015                         tapeDCDB->reserved_for_LUN = 0;
4016                         tapeDCDB->transfer_length = scb->data_len;
4017                         if (scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB_SG)
4018                                 tapeDCDB->buffer_pointer =
4019                                     cpu_to_le32(scb->sg_busaddr);
4020                         else
4021                                 tapeDCDB->buffer_pointer =
4022                                     cpu_to_le32(scb->data_busaddr);
4023                         tapeDCDB->sg_count = scb->sg_len;
4024                         tapeDCDB->sense_length = sizeof (tapeDCDB->sense_info);
4025                         tapeDCDB->scsi_status = 0;
4026                         tapeDCDB->reserved = 0;
4027                         memcpy(tapeDCDB->scsi_cdb, scb->scsi_cmd->cmnd,
4028                                scb->scsi_cmd->cmd_len);
4029                 } else {
4030                         if (!scb->sg_len) {
4031                                 scb->cmd.dcdb.op_code = IPS_CMD_DCDB;
4032                         } else {
4033                                 scb->cmd.dcdb.op_code = IPS_CMD_DCDB_SG;
4034                                 scb->cmd.dcdb.enhanced_sg =
4035                                     IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
4036                         }
4037
4038                         scb->dcdb.device_address =
4039                             ((scb->bus - 1) << 4) | scb->target_id;
4040                         scb->dcdb.cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4041
4042                         if (TimeOut) {
4043                                 if (TimeOut < (10 * HZ))
4044                                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;       /* TimeOut is 10 Seconds */
4045                                 else if (TimeOut < (60 * HZ))
4046                                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;       /* TimeOut is 60 Seconds */
4047                                 else if (TimeOut < (1200 * HZ))
4048                                         scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;      /* TimeOut is 20 Minutes */
4049                         }
4050
4051                         scb->dcdb.transfer_length = scb->data_len;
4052                         if (scb->dcdb.cmd_attribute & IPS_TRANSFER64K)
4053                                 scb->dcdb.transfer_length = 0;
4054                         if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB_SG)
4055                                 scb->dcdb.buffer_pointer =
4056                                     cpu_to_le32(scb->sg_busaddr);
4057                         else
4058                                 scb->dcdb.buffer_pointer =
4059                                     cpu_to_le32(scb->data_busaddr);
4060                         scb->dcdb.cdb_length = scb->scsi_cmd->cmd_len;
4061                         scb->dcdb.sense_length = sizeof (scb->dcdb.sense_info);
4062                         scb->dcdb.sg_count = scb->sg_len;
4063                         scb->dcdb.reserved = 0;
4064                         memcpy(scb->dcdb.scsi_cdb, scb->scsi_cmd->cmnd,
4065                                scb->scsi_cmd->cmd_len);
4066                         scb->dcdb.scsi_status = 0;
4067                         scb->dcdb.reserved2[0] = 0;
4068                         scb->dcdb.reserved2[1] = 0;
4069                         scb->dcdb.reserved2[2] = 0;
4070                 }
4071         }
4072
4073         return ((*ha->func.issue) (ha, scb));
4074 }
4075
4076 /****************************************************************************/
4077 /*                                                                          */
4078 /* Routine Name: ips_chk_status                                             */
4079 /*                                                                          */
4080 /* Routine Description:                                                     */
4081 /*                                                                          */
4082 /*   Check the status of commands to logical drives                         */
4083 /*   Assumed to be called with the HA lock                                  */
4084 /****************************************************************************/
4085 static void
4086 ips_chkstatus(ips_ha_t * ha, IPS_STATUS * pstatus)
4087 {
4088         ips_scb_t *scb;
4089         ips_stat_t *sp;
4090         uint8_t basic_status;
4091         uint8_t ext_status;
4092         int errcode;
4093
4094         METHOD_TRACE("ips_chkstatus", 1);
4095
4096         scb = &ha->scbs[pstatus->fields.command_id];
4097         scb->basic_status = basic_status =
4098             pstatus->fields.basic_status & IPS_BASIC_STATUS_MASK;
4099         scb->extended_status = ext_status = pstatus->fields.extended_status;
4100
4101         sp = &ha->sp;
4102         sp->residue_len = 0;
4103         sp->scb_addr = (void *) scb;
4104
4105         /* Remove the item from the active queue */
4106         ips_removeq_scb(&ha->scb_activelist, scb);
4107
4108         if (!scb->scsi_cmd)
4109                 /* internal commands are handled in do_ipsintr */
4110                 return;
4111
4112         DEBUG_VAR(2, "(%s%d) ips_chkstatus: cmd 0x%X id %d (%d %d %d)",
4113                   ips_name,
4114                   ha->host_num,
4115                   scb->cdb[0],
4116                   scb->cmd.basic_io.command_id,
4117                   scb->bus, scb->target_id, scb->lun);
4118
4119         if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd)))
4120                 /* passthru - just returns the raw result */
4121                 return;
4122
4123         errcode = DID_OK;
4124
4125         if (((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_SUCCESS) ||
4126             ((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_RECOVERED_ERROR)) {
4127
4128                 if (scb->bus == 0) {
4129                         if ((basic_status & IPS_GSC_STATUS_MASK) ==
4130                             IPS_CMD_RECOVERED_ERROR) {
4131                                 DEBUG_VAR(1,
4132                                           "(%s%d) Recovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4133                                           ips_name, ha->host_num,
4134                                           scb->cmd.basic_io.op_code,
4135                                           basic_status, ext_status);
4136                         }
4137
4138                         switch (scb->scsi_cmd->cmnd[0]) {
4139                         case ALLOW_MEDIUM_REMOVAL:
4140                         case REZERO_UNIT:
4141                         case ERASE:
4142                         case WRITE_FILEMARKS:
4143                         case SPACE:
4144                                 errcode = DID_ERROR;
4145                                 break;
4146
4147                         case START_STOP:
4148                                 break;
4149
4150                         case TEST_UNIT_READY:
4151                                 if (!ips_online(ha, scb)) {
4152                                         errcode = DID_TIME_OUT;
4153                                 }
4154                                 break;
4155
4156                         case INQUIRY:
4157                                 if (ips_online(ha, scb)) {
4158                                         ips_inquiry(ha, scb);
4159                                 } else {
4160                                         errcode = DID_TIME_OUT;
4161                                 }
4162                                 break;
4163
4164                         case REQUEST_SENSE:
4165                                 ips_reqsen(ha, scb);
4166                                 break;
4167
4168                         case READ_6:
4169                         case WRITE_6:
4170                         case READ_10:
4171                         case WRITE_10:
4172                         case RESERVE:
4173                         case RELEASE:
4174                                 break;
4175
4176                         case MODE_SENSE:
4177                                 if (!ips_online(ha, scb)
4178                                     || !ips_msense(ha, scb)) {
4179                                         errcode = DID_ERROR;
4180                                 }
4181                                 break;
4182
4183                         case READ_CAPACITY:
4184                                 if (ips_online(ha, scb))
4185                                         ips_rdcap(ha, scb);
4186                                 else {
4187                                         errcode = DID_TIME_OUT;
4188                                 }
4189                                 break;
4190
4191                         case SEND_DIAGNOSTIC:
4192                         case REASSIGN_BLOCKS:
4193                                 break;
4194
4195                         case FORMAT_UNIT:
4196                                 errcode = DID_ERROR;
4197                                 break;
4198
4199                         case SEEK_10:
4200                         case VERIFY:
4201                         case READ_DEFECT_DATA:
4202                         case READ_BUFFER:
4203                         case WRITE_BUFFER:
4204                                 break;
4205
4206                         default:
4207                                 errcode = DID_ERROR;
4208                         }       /* end switch */
4209
4210                         scb->scsi_cmd->result = errcode << 16;
4211                 } else {        /* bus == 0 */
4212                         /* restrict access to physical drives */
4213                         if ((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
4214                             ((((char *) scb->scsi_cmd->buffer)[0] & 0x1f) ==
4215                              TYPE_DISK)) {
4216
4217                                 scb->scsi_cmd->result = DID_TIME_OUT << 16;
4218                         }
4219                 }               /* else */
4220         } else {                /* recovered error / success */
4221                 if (scb->bus == 0) {
4222                         DEBUG_VAR(1,
4223                                   "(%s%d) Unrecovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4224                                   ips_name, ha->host_num,
4225                                   scb->cmd.basic_io.op_code, basic_status,
4226                                   ext_status);
4227                 }
4228
4229                 ips_map_status(ha, scb, sp);
4230         }                       /* else */
4231 }
4232
4233 /****************************************************************************/
4234 /*                                                                          */
4235 /* Routine Name: ips_online                                                 */
4236 /*                                                                          */
4237 /* Routine Description:                                                     */
4238 /*                                                                          */
4239 /*   Determine if a logical drive is online                                 */
4240 /*                                                                          */
4241 /****************************************************************************/
4242 static int
4243 ips_online(ips_ha_t * ha, ips_scb_t * scb)
4244 {
4245         METHOD_TRACE("ips_online", 1);
4246
4247         if (scb->target_id >= IPS_MAX_LD)
4248                 return (0);
4249
4250         if ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1) {
4251                 memset(ha->logical_drive_info, 0, sizeof (IPS_LD_INFO));
4252                 return (0);
4253         }
4254
4255         if (ha->logical_drive_info->drive_info[scb->target_id].state !=
4256             IPS_LD_OFFLINE
4257             && ha->logical_drive_info->drive_info[scb->target_id].state !=
4258             IPS_LD_FREE
4259             && ha->logical_drive_info->drive_info[scb->target_id].state !=
4260             IPS_LD_CRS
4261             && ha->logical_drive_info->drive_info[scb->target_id].state !=
4262             IPS_LD_SYS)
4263                 return (1);
4264         else
4265                 return (0);
4266 }
4267
4268 /****************************************************************************/
4269 /*                                                                          */
4270 /* Routine Name: ips_inquiry                                                */
4271 /*                                                                          */
4272 /* Routine Description:                                                     */
4273 /*                                                                          */
4274 /*   Simulate an inquiry command to a logical drive                         */
4275 /*                                                                          */
4276 /****************************************************************************/
4277 static int
4278 ips_inquiry(ips_ha_t * ha, ips_scb_t * scb)
4279 {
4280         IPS_SCSI_INQ_DATA inquiry;
4281
4282         METHOD_TRACE("ips_inquiry", 1);
4283
4284         memset(&inquiry, 0, sizeof (IPS_SCSI_INQ_DATA));
4285
4286         inquiry.DeviceType = IPS_SCSI_INQ_TYPE_DASD;
4287         inquiry.DeviceTypeQualifier = IPS_SCSI_INQ_LU_CONNECTED;
4288         inquiry.Version = IPS_SCSI_INQ_REV2;
4289         inquiry.ResponseDataFormat = IPS_SCSI_INQ_RD_REV2;
4290         inquiry.AdditionalLength = 31;
4291         inquiry.Flags[0] = IPS_SCSI_INQ_Address16;
4292         inquiry.Flags[1] =
4293             IPS_SCSI_INQ_WBus16 | IPS_SCSI_INQ_Sync | IPS_SCSI_INQ_CmdQue;
4294         strncpy(inquiry.VendorId, "IBM     ", 8);
4295         strncpy(inquiry.ProductId, "SERVERAID       ", 16);
4296         strncpy(inquiry.ProductRevisionLevel, "1.00", 4);
4297
4298         ips_scmd_buf_write(scb->scsi_cmd, &inquiry, sizeof (inquiry));
4299
4300         return (1);
4301 }
4302
4303 /****************************************************************************/
4304 /*                                                                          */
4305 /* Routine Name: ips_rdcap                                                  */
4306 /*                                                                          */
4307 /* Routine Description:                                                     */
4308 /*                                                                          */
4309 /*   Simulate a read capacity command to a logical drive                    */
4310 /*                                                                          */
4311 /****************************************************************************/
4312 static int
4313 ips_rdcap(ips_ha_t * ha, ips_scb_t * scb)
4314 {
4315         IPS_SCSI_CAPACITY cap;
4316
4317         METHOD_TRACE("ips_rdcap", 1);
4318
4319         if (scb->scsi_cmd->bufflen < 8)
4320                 return (0);
4321
4322         cap.lba =
4323             cpu_to_be32(le32_to_cpu
4324                         (ha->logical_drive_info->
4325                          drive_info[scb->target_id].sector_count) - 1);
4326         cap.len = cpu_to_be32((uint32_t) IPS_BLKSIZE);
4327
4328         ips_scmd_buf_write(scb->scsi_cmd, &cap, sizeof (cap));
4329
4330         return (1);
4331 }
4332
4333 /****************************************************************************/
4334 /*                                                                          */
4335 /* Routine Name: ips_msense                                                 */
4336 /*                                                                          */
4337 /* Routine Description:                                                     */
4338 /*                                                                          */
4339 /*   Simulate a mode sense command to a logical drive                       */
4340 /*                                                                          */
4341 /****************************************************************************/
4342 static int
4343 ips_msense(ips_ha_t * ha, ips_scb_t * scb)
4344 {
4345         uint16_t heads;
4346         uint16_t sectors;
4347         uint32_t cylinders;
4348         IPS_SCSI_MODE_PAGE_DATA mdata;
4349
4350         METHOD_TRACE("ips_msense", 1);
4351
4352         if (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) > 0x400000 &&
4353             (ha->enq->ucMiscFlag & 0x8) == 0) {
4354                 heads = IPS_NORM_HEADS;
4355                 sectors = IPS_NORM_SECTORS;
4356         } else {
4357                 heads = IPS_COMP_HEADS;
4358                 sectors = IPS_COMP_SECTORS;
4359         }
4360
4361         cylinders =
4362             (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) -
4363              1) / (heads * sectors);
4364
4365         memset(&mdata, 0, sizeof (IPS_SCSI_MODE_PAGE_DATA));
4366
4367         mdata.hdr.BlockDescLength = 8;
4368
4369         switch (scb->scsi_cmd->cmnd[2] & 0x3f) {
4370         case 0x03:              /* page 3 */
4371                 mdata.pdata.pg3.PageCode = 3;
4372                 mdata.pdata.pg3.PageLength = sizeof (IPS_SCSI_MODE_PAGE3);
4373                 mdata.hdr.DataLength =
4374                     3 + mdata.hdr.BlockDescLength + mdata.pdata.pg3.PageLength;
4375                 mdata.pdata.pg3.TracksPerZone = 0;
4376                 mdata.pdata.pg3.AltSectorsPerZone = 0;
4377                 mdata.pdata.pg3.AltTracksPerZone = 0;
4378                 mdata.pdata.pg3.AltTracksPerVolume = 0;
4379                 mdata.pdata.pg3.SectorsPerTrack = cpu_to_be16(sectors);
4380                 mdata.pdata.pg3.BytesPerSector = cpu_to_be16(IPS_BLKSIZE);
4381                 mdata.pdata.pg3.Interleave = cpu_to_be16(1);
4382                 mdata.pdata.pg3.TrackSkew = 0;
4383                 mdata.pdata.pg3.CylinderSkew = 0;
4384                 mdata.pdata.pg3.flags = IPS_SCSI_MP3_SoftSector;
4385                 break;
4386
4387         case 0x4:
4388                 mdata.pdata.pg4.PageCode = 4;
4389                 mdata.pdata.pg4.PageLength = sizeof (IPS_SCSI_MODE_PAGE4);
4390                 mdata.hdr.DataLength =
4391                     3 + mdata.hdr.BlockDescLength + mdata.pdata.pg4.PageLength;
4392                 mdata.pdata.pg4.CylindersHigh =
4393                     cpu_to_be16((cylinders >> 8) & 0xFFFF);
4394                 mdata.pdata.pg4.CylindersLow = (cylinders & 0xFF);
4395                 mdata.pdata.pg4.Heads = heads;
4396                 mdata.pdata.pg4.WritePrecompHigh = 0;
4397                 mdata.pdata.pg4.WritePrecompLow = 0;
4398                 mdata.pdata.pg4.ReducedWriteCurrentHigh = 0;
4399                 mdata.pdata.pg4.ReducedWriteCurrentLow = 0;
4400                 mdata.pdata.pg4.StepRate = cpu_to_be16(1);
4401                 mdata.pdata.pg4.LandingZoneHigh = 0;
4402                 mdata.pdata.pg4.LandingZoneLow = 0;
4403                 mdata.pdata.pg4.flags = 0;
4404                 mdata.pdata.pg4.RotationalOffset = 0;
4405                 mdata.pdata.pg4.MediumRotationRate = 0;
4406                 break;
4407         case 0x8:
4408                 mdata.pdata.pg8.PageCode = 8;
4409                 mdata.pdata.pg8.PageLength = sizeof (IPS_SCSI_MODE_PAGE8);
4410                 mdata.hdr.DataLength =
4411                     3 + mdata.hdr.BlockDescLength + mdata.pdata.pg8.PageLength;
4412                 /* everything else is left set to 0 */
4413                 break;
4414
4415         default:
4416                 return (0);
4417         }                       /* end switch */
4418
4419         ips_scmd_buf_write(scb->scsi_cmd, &mdata, sizeof (mdata));
4420
4421         return (1);
4422 }
4423
4424 /****************************************************************************/
4425 /*                                                                          */
4426 /* Routine Name: ips_reqsen                                                 */
4427 /*                                                                          */
4428 /* Routine Description:                                                     */
4429 /*                                                                          */
4430 /*   Simulate a request sense command to a logical drive                    */
4431 /*                                                                          */
4432 /****************************************************************************/
4433 static int
4434 ips_reqsen(ips_ha_t * ha, ips_scb_t * scb)
4435 {
4436         IPS_SCSI_REQSEN reqsen;
4437
4438         METHOD_TRACE("ips_reqsen", 1);
4439
4440         memset(&reqsen, 0, sizeof (IPS_SCSI_REQSEN));
4441
4442         reqsen.ResponseCode =
4443             IPS_SCSI_REQSEN_VALID | IPS_SCSI_REQSEN_CURRENT_ERR;
4444         reqsen.AdditionalLength = 10;
4445         reqsen.AdditionalSenseCode = IPS_SCSI_REQSEN_NO_SENSE;
4446         reqsen.AdditionalSenseCodeQual = IPS_SCSI_REQSEN_NO_SENSE;
4447
4448         ips_scmd_buf_write(scb->scsi_cmd, &reqsen, sizeof (reqsen));
4449
4450         return (1);
4451 }
4452
4453 /****************************************************************************/
4454 /*                                                                          */
4455 /* Routine Name: ips_free                                                   */
4456 /*                                                                          */
4457 /* Routine Description:                                                     */
4458 /*                                                                          */
4459 /*   Free any allocated space for this controller                           */
4460 /*                                                                          */
4461 /****************************************************************************/
4462 static void
4463 ips_free(ips_ha_t * ha)
4464 {
4465
4466         METHOD_TRACE("ips_free", 1);
4467
4468         if (ha) {
4469                 if (ha->enq) {
4470                         pci_free_consistent(ha->pcidev, sizeof(IPS_ENQ),
4471                                             ha->enq, ha->enq_busaddr);
4472                         ha->enq = NULL;
4473                 }
4474
4475                 if (ha->conf) {
4476                         kfree(ha->conf);
4477                         ha->conf = NULL;
4478                 }
4479
4480                 if (ha->adapt) {
4481                         pci_free_consistent(ha->pcidev,
4482                                             sizeof (IPS_ADAPTER) +
4483                                             sizeof (IPS_IO_CMD), ha->adapt,
4484                                             ha->adapt->hw_status_start);
4485                         ha->adapt = NULL;
4486                 }
4487
4488                 if (ha->logical_drive_info) {
4489                         pci_free_consistent(ha->pcidev,
4490                                             sizeof (IPS_LD_INFO),
4491                                             ha->logical_drive_info,
4492                                             ha->logical_drive_info_dma_addr);
4493                         ha->logical_drive_info = NULL;
4494                 }
4495
4496                 if (ha->nvram) {
4497                         kfree(ha->nvram);
4498                         ha->nvram = NULL;
4499                 }
4500
4501                 if (ha->subsys) {
4502                         kfree(ha->subsys);
4503                         ha->subsys = NULL;
4504                 }
4505
4506                 if (ha->ioctl_data) {
4507                         pci_free_consistent(ha->pcidev, ha->ioctl_len,
4508                                             ha->ioctl_data, ha->ioctl_busaddr);
4509                         ha->ioctl_data = NULL;
4510                         ha->ioctl_datasize = 0;
4511                         ha->ioctl_len = 0;
4512                 }
4513                 ips_deallocatescbs(ha, ha->max_cmds);
4514
4515                 /* free memory mapped (if applicable) */
4516                 if (ha->mem_ptr) {
4517                         iounmap(ha->ioremap_ptr);
4518                         ha->ioremap_ptr = NULL;
4519                         ha->mem_ptr = NULL;
4520                 }
4521
4522                 if (ha->mem_addr)
4523                         release_mem_region(ha->mem_addr, ha->mem_len);
4524                 ha->mem_addr = 0;
4525
4526         }
4527 }
4528
4529 /****************************************************************************/
4530 /*                                                                          */
4531 /* Routine Name: ips_deallocatescbs                                         */
4532 /*                                                                          */
4533 /* Routine Description:                                                     */
4534 /*                                                                          */
4535 /*   Free the command blocks                                                */
4536 /*                                                                          */
4537 /****************************************************************************/
4538 static int
4539 ips_deallocatescbs(ips_ha_t * ha, int cmds)
4540 {
4541         if (ha->scbs) {
4542                 pci_free_consistent(ha->pcidev,
4543                                     IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * cmds,
4544                                     ha->scbs->sg_list.list,
4545                                     ha->scbs->sg_busaddr);
4546                 pci_free_consistent(ha->pcidev, sizeof (ips_scb_t) * cmds,
4547                                     ha->scbs, ha->scbs->scb_busaddr);
4548                 ha->scbs = NULL;
4549         }                       /* end if */
4550         return 1;
4551 }
4552
4553 /****************************************************************************/
4554 /*                                                                          */
4555 /* Routine Name: ips_allocatescbs                                           */
4556 /*                                                                          */
4557 /* Routine Description:                                                     */
4558 /*                                                                          */
4559 /*   Allocate the command blocks                                            */
4560 /*                                                                          */
4561 /****************************************************************************/
4562 static int
4563 ips_allocatescbs(ips_ha_t * ha)
4564 {
4565         ips_scb_t *scb_p;
4566         IPS_SG_LIST ips_sg;
4567         int i;
4568         dma_addr_t command_dma, sg_dma;
4569
4570         METHOD_TRACE("ips_allocatescbs", 1);
4571
4572         /* Allocate memory for the SCBs */
4573         ha->scbs =
4574             pci_alloc_consistent(ha->pcidev, ha->max_cmds * sizeof (ips_scb_t),
4575                                  &command_dma);
4576         if (ha->scbs == NULL)
4577                 return 0;
4578         ips_sg.list =
4579             pci_alloc_consistent(ha->pcidev,
4580                                  IPS_SGLIST_SIZE(ha) * IPS_MAX_SG *
4581                                  ha->max_cmds, &sg_dma);
4582         if (ips_sg.list == NULL) {
4583                 pci_free_consistent(ha->pcidev,
4584                                     ha->max_cmds * sizeof (ips_scb_t), ha->scbs,
4585                                     command_dma);
4586                 return 0;
4587         }
4588
4589         memset(ha->scbs, 0, ha->max_cmds * sizeof (ips_scb_t));
4590
4591         for (i = 0; i < ha->max_cmds; i++) {
4592                 scb_p = &ha->scbs[i];
4593                 scb_p->scb_busaddr = command_dma + sizeof (ips_scb_t) * i;
4594                 /* set up S/G list */
4595                 if (IPS_USE_ENH_SGLIST(ha)) {
4596                         scb_p->sg_list.enh_list =
4597                             ips_sg.enh_list + i * IPS_MAX_SG;
4598                         scb_p->sg_busaddr =
4599                             sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4600                 } else {
4601                         scb_p->sg_list.std_list =
4602                             ips_sg.std_list + i * IPS_MAX_SG;
4603                         scb_p->sg_busaddr =
4604                             sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4605                 }
4606
4607                 /* add to the free list */
4608                 if (i < ha->max_cmds - 1) {
4609                         scb_p->q_next = ha->scb_freelist;
4610                         ha->scb_freelist = scb_p;
4611                 }
4612         }
4613
4614         /* success */
4615         return (1);
4616 }
4617
4618 /****************************************************************************/
4619 /*                                                                          */
4620 /* Routine Name: ips_init_scb                                               */
4621 /*                                                                          */
4622 /* Routine Description:                                                     */
4623 /*                                                                          */
4624 /*   Initialize a CCB to default values                                     */
4625 /*                                                                          */
4626 /****************************************************************************/
4627 static void
4628 ips_init_scb(ips_ha_t * ha, ips_scb_t * scb)
4629 {
4630         IPS_SG_LIST sg_list;
4631         uint32_t cmd_busaddr, sg_busaddr;
4632         METHOD_TRACE("ips_init_scb", 1);
4633
4634         if (scb == NULL)
4635                 return;
4636
4637         sg_list.list = scb->sg_list.list;
4638         cmd_busaddr = scb->scb_busaddr;
4639         sg_busaddr = scb->sg_busaddr;
4640         /* zero fill */
4641         memset(scb, 0, sizeof (ips_scb_t));
4642         memset(ha->dummy, 0, sizeof (IPS_IO_CMD));
4643
4644         /* Initialize dummy command bucket */
4645         ha->dummy->op_code = 0xFF;
4646         ha->dummy->ccsar = cpu_to_le32(ha->adapt->hw_status_start
4647                                        + sizeof (IPS_ADAPTER));
4648         ha->dummy->command_id = IPS_MAX_CMDS;
4649
4650         /* set bus address of scb */
4651         scb->scb_busaddr = cmd_busaddr;
4652         scb->sg_busaddr = sg_busaddr;
4653         scb->sg_list.list = sg_list.list;
4654
4655         /* Neptune Fix */
4656         scb->cmd.basic_io.cccr = cpu_to_le32((uint32_t) IPS_BIT_ILE);
4657         scb->cmd.basic_io.ccsar = cpu_to_le32(ha->adapt->hw_status_start
4658                                               + sizeof (IPS_ADAPTER));
4659 }
4660
4661 /****************************************************************************/
4662 /*                                                                          */
4663 /* Routine Name: ips_get_scb                                                */
4664 /*                                                                          */
4665 /* Routine Description:                                                     */
4666 /*                                                                          */
4667 /*   Initialize a CCB to default values                                     */
4668 /*                                                                          */
4669 /* ASSUMED to be callled from within a lock                                 */
4670 /*                                                                          */
4671 /****************************************************************************/
4672 static ips_scb_t *
4673 ips_getscb(ips_ha_t * ha)
4674 {
4675         ips_scb_t *scb;
4676
4677         METHOD_TRACE("ips_getscb", 1);
4678
4679         if ((scb = ha->scb_freelist) == NULL) {
4680
4681                 return (NULL);
4682         }
4683
4684         ha->scb_freelist = scb->q_next;
4685         scb->flags = 0;
4686         scb->q_next = NULL;
4687
4688         ips_init_scb(ha, scb);
4689
4690         return (scb);
4691 }
4692
4693 /****************************************************************************/
4694 /*                                                                          */
4695 /* Routine Name: ips_free_scb                                               */
4696 /*                                                                          */
4697 /* Routine Description:                                                     */
4698 /*                                                                          */
4699 /*   Return an unused CCB back to the free list                             */
4700 /*                                                                          */
4701 /* ASSUMED to be called from within a lock                                  */
4702 /*                                                                          */
4703 /****************************************************************************/
4704 static void
4705 ips_freescb(ips_ha_t * ha, ips_scb_t * scb)
4706 {
4707
4708         METHOD_TRACE("ips_freescb", 1);
4709         if (scb->flags & IPS_SCB_MAP_SG)
4710                 pci_unmap_sg(ha->pcidev, scb->scsi_cmd->request_buffer,
4711                              scb->scsi_cmd->use_sg, IPS_DMA_DIR(scb));
4712         else if (scb->flags & IPS_SCB_MAP_SINGLE)
4713                 pci_unmap_single(ha->pcidev, scb->data_busaddr, scb->data_len,
4714                                  IPS_DMA_DIR(scb));
4715
4716         /* check to make sure this is not our "special" scb */
4717         if (IPS_COMMAND_ID(ha, scb) < (ha->max_cmds - 1)) {
4718                 scb->q_next = ha->scb_freelist;
4719                 ha->scb_freelist = scb;
4720         }
4721 }
4722
4723 /****************************************************************************/
4724 /*                                                                          */
4725 /* Routine Name: ips_isinit_copperhead                                      */
4726 /*                                                                          */
4727 /* Routine Description:                                                     */
4728 /*                                                                          */
4729 /*   Is controller initialized ?                                            */
4730 /*                                                                          */
4731 /****************************************************************************/
4732 static int
4733 ips_isinit_copperhead(ips_ha_t * ha)
4734 {
4735         uint8_t scpr;
4736         uint8_t isr;
4737
4738         METHOD_TRACE("ips_isinit_copperhead", 1);
4739
4740         isr = inb(ha->io_addr + IPS_REG_HISR);
4741         scpr = inb(ha->io_addr + IPS_REG_SCPR);
4742
4743         if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4744                 return (0);
4745         else
4746                 return (1);
4747 }
4748
4749 /****************************************************************************/
4750 /*                                                                          */
4751 /* Routine Name: ips_isinit_copperhead_memio                                */
4752 /*                                                                          */
4753 /* Routine Description:                                                     */
4754 /*                                                                          */
4755 /*   Is controller initialized ?                                            */
4756 /*                                                                          */
4757 /****************************************************************************/
4758 static int
4759 ips_isinit_copperhead_memio(ips_ha_t * ha)
4760 {
4761         uint8_t isr = 0;
4762         uint8_t scpr;
4763
4764         METHOD_TRACE("ips_is_init_copperhead_memio", 1);
4765
4766         isr = readb(ha->mem_ptr + IPS_REG_HISR);
4767         scpr = readb(ha->mem_ptr + IPS_REG_SCPR);
4768
4769         if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4770                 return (0);
4771         else
4772                 return (1);
4773 }
4774
4775 /****************************************************************************/
4776 /*                                                                          */
4777 /* Routine Name: ips_isinit_morpheus                                        */
4778 /*                                                                          */
4779 /* Routine Description:                                                     */
4780 /*                                                                          */
4781 /*   Is controller initialized ?                                            */
4782 /*                                                                          */
4783 /****************************************************************************/
4784 static int
4785 ips_isinit_morpheus(ips_ha_t * ha)
4786 {
4787         uint32_t post;
4788         uint32_t bits;
4789
4790         METHOD_TRACE("ips_is_init_morpheus", 1);
4791
4792         post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
4793         bits = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
4794
4795         if (post == 0)
4796                 return (0);
4797         else if (bits & 0x3)
4798                 return (0);
4799         else
4800                 return (1);
4801 }
4802
4803 /****************************************************************************/
4804 /*                                                                          */
4805 /* Routine Name: ips_enable_int_copperhead                                  */
4806 /*                                                                          */
4807 /* Routine Description:                                                     */
4808 /*   Turn on interrupts                                                     */
4809 /*                                                                          */
4810 /****************************************************************************/
4811 static void
4812 ips_enable_int_copperhead(ips_ha_t * ha)
4813 {
4814         METHOD_TRACE("ips_enable_int_copperhead", 1);
4815
4816         outb(ha->io_addr + IPS_REG_HISR, IPS_BIT_EI);
4817         inb(ha->io_addr + IPS_REG_HISR);        /*Ensure PCI Posting Completes*/
4818 }
4819
4820 /****************************************************************************/
4821 /*                                                                          */
482