1 /*****************************************************************************/
2 /* ips.c -- driver for the Adaptec / IBM ServeRAID controller */
4 /* Written By: Keith Mitchell, IBM Corporation */
5 /* Jack Hammer, Adaptec, Inc. */
6 /* David Jeffery, Adaptec, Inc. */
8 /* Copyright (C) 2000 IBM Corporation */
9 /* Copyright (C) 2002,2003 Adaptec, Inc. */
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. */
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. */
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. */
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 */
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 */
45 /* Bugs/Comments/Suggestions about this driver should be mailed to: */
46 /* ipslinux@adaptec.com */
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/ */
52 /*****************************************************************************/
54 /*****************************************************************************/
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 */
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 /*****************************************************************************/
139 * Conditional Compilation directives for this driver:
141 * IPS_DEBUG - Turn on debugging info
145 * debug:<number> - Set debug level to <number>
146 * NOTE: only works when IPS_DEBUG compile directive is used.
147 * 1 - Normal debug messages
148 * 2 - Verbose debug messages
149 * 11 - Method trace (non interrupt)
150 * 12 - Method trace (includes interrupt)
152 * noi2o - Don't use I2O Queues (ServeRAID 4 only)
153 * nommap - Don't use memory mapped I/O
154 * ioctlsize - Initial size of the IOCTL buffer
158 #include <asm/byteorder.h>
159 #include <asm/page.h>
160 #include <linux/stddef.h>
161 #include <linux/version.h>
162 #include <linux/string.h>
163 #include <linux/errno.h>
164 #include <linux/kernel.h>
165 #include <linux/ioport.h>
166 #include <linux/slab.h>
167 #include <linux/delay.h>
168 #include <linux/pci.h>
169 #include <linux/proc_fs.h>
170 #include <linux/reboot.h>
171 #include <linux/interrupt.h>
173 #include <linux/blkdev.h>
174 #include <linux/types.h>
182 #include <linux/module.h>
184 #include <linux/stat.h>
185 #include <linux/config.h>
187 #include <linux/spinlock.h>
188 #include <linux/init.h>
190 #include <linux/smp.h>
193 static char *ips = NULL;
194 MODULE_PARM(ips, "s");
200 #define IPS_VERSION_HIGH "7.00"
201 #define IPS_VERSION_LOW ".15 "
203 #if !defined(__i386__) && !defined(__ia64__) && !defined(__x86_64__)
204 #warning "This driver has only been tested on the x86/ia64/x86_64 platforms"
207 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
208 #include <linux/blk.h>
210 #define IPS_SG_ADDRESS(sg) ((sg)->address)
211 #define IPS_LOCK_SAVE(lock,flags) spin_lock_irqsave(&io_request_lock,flags)
212 #define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock_irqrestore(&io_request_lock,flags)
214 #define __devexit_p(x) x
217 #define IPS_SG_ADDRESS(sg) (page_address((sg)->page) ? \
218 page_address((sg)->page)+(sg)->offset : 0)
219 #define IPS_LOCK_SAVE(lock,flags) do{spin_lock(lock);(void)flags;}while(0)
220 #define IPS_UNLOCK_RESTORE(lock,flags) do{spin_unlock(lock);(void)flags;}while(0)
223 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
224 SCSI_DATA_NONE == scb->scsi_cmd->sc_data_direction) ? \
225 PCI_DMA_BIDIRECTIONAL : \
226 scsi_to_pci_dma_dir(scb->scsi_cmd->sc_data_direction))
229 #define METHOD_TRACE(s, i) if (ips_debug >= (i+10)) printk(KERN_NOTICE s "\n");
230 #define DEBUG(i, s) if (ips_debug >= i) printk(KERN_NOTICE s "\n");
231 #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "\n", v);
233 #define METHOD_TRACE(s, i)
235 #define DEBUG_VAR(i, s, v...)
241 static const char ips_name[] = "ips";
242 static struct Scsi_Host *ips_sh[IPS_MAX_ADAPTERS]; /* Array of host controller structures */
243 static ips_ha_t *ips_ha[IPS_MAX_ADAPTERS]; /* Array of HA structures */
244 static unsigned int ips_next_controller;
245 static unsigned int ips_num_controllers;
246 static unsigned int ips_released_controllers;
247 static int ips_hotplug;
248 static int ips_cmd_timeout = 60;
249 static int ips_reset_timeout = 60 * 5;
250 static int ips_force_memio = 1; /* Always use Memory Mapped I/O */
251 static int ips_force_i2o = 1; /* Always use I2O command delivery */
252 static int ips_ioctlsize = IPS_IOCTL_SIZE; /* Size of the ioctl buffer */
253 static int ips_cd_boot; /* Booting from Manager CD */
254 static char *ips_FlashData = NULL; /* CD Boot - Flash Data Buffer */
255 static dma_addr_t ips_flashbusaddr;
256 static long ips_FlashDataInUse; /* CD Boot - Flash Data In Use Flag */
257 static uint32_t MaxLiteCmds = 32; /* Max Active Cmds for a Lite Adapter */
258 static Scsi_Host_Template ips_driver_template = {
259 .detect = ips_detect,
260 .release = ips_release,
262 .queuecommand = ips_queue,
263 .eh_abort_handler = ips_eh_abort,
264 .eh_host_reset_handler = ips_eh_reset,
266 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
267 .proc_info = ips_proc_info,
268 .slave_configure = ips_slave_configure,
270 .proc_info = ips_proc24_info,
271 .select_queue_depths = ips_select_queue_depth,
273 .bios_param = ips_biosparam,
275 .sg_tablesize = IPS_MAX_SG,
277 .use_clustering = ENABLE_CLUSTERING,
278 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
279 .use_new_eh_code = 1,
283 IPS_DEFINE_COMPAT_TABLE( Compatable ); /* Version Compatability Table */
286 /* This table describes all ServeRAID Adapters */
287 static struct pci_device_id ips_pci_table[] = {
288 { 0x1014, 0x002E, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
289 { 0x1014, 0x01BD, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
290 { 0x9005, 0x0250, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
294 MODULE_DEVICE_TABLE( pci, ips_pci_table );
296 static char ips_hot_plug_name[] = "ips";
298 static int __devinit ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent);
299 static void __devexit ips_remove_device(struct pci_dev *pci_dev);
301 struct pci_driver ips_pci_driver = {
302 .name = ips_hot_plug_name,
303 .id_table = ips_pci_table,
304 .probe = ips_insert_device,
305 .remove = __devexit_p(ips_remove_device),
310 * Necessary forward function protoypes
312 static int ips_halt(struct notifier_block *nb, ulong event, void *buf);
314 #define MAX_ADAPTER_NAME 15
316 static char ips_adapter_name[][30] = {
319 "ServeRAID on motherboard",
320 "ServeRAID on motherboard",
337 static struct notifier_block ips_notifier = {
344 static char ips_command_direction[] = {
345 IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT,
346 IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK,
347 IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
348 IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
349 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_OUT,
350 IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
351 IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_IN,
352 IPS_DATA_UNK, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
353 IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_UNK,
354 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
355 IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE,
356 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
357 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT,
358 IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_NONE,
359 IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,
360 IPS_DATA_NONE, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
361 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
362 IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
363 IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
364 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
365 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
366 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
367 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
368 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
369 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
370 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
371 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
372 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
373 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
374 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
375 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
376 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
377 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
378 IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_NONE,
379 IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_OUT,
380 IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_NONE,
381 IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN,
382 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
383 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
384 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
385 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
386 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
387 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
388 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
389 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
390 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
391 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_OUT,
392 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
393 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
394 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
395 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK
399 * Function prototypes
401 int ips_detect(Scsi_Host_Template *);
402 int ips_release(struct Scsi_Host *);
403 int ips_eh_abort(Scsi_Cmnd *);
404 int ips_eh_reset(Scsi_Cmnd *);
405 int ips_queue(Scsi_Cmnd *, void (*)(Scsi_Cmnd *));
406 const char *ips_info(struct Scsi_Host *);
407 irqreturn_t do_ipsintr(int, void *, struct pt_regs *);
408 static int ips_hainit(ips_ha_t *);
409 static int ips_map_status(ips_ha_t *, ips_scb_t *, ips_stat_t *);
410 static int ips_send_wait(ips_ha_t *, ips_scb_t *, int, int);
411 static int ips_send_cmd(ips_ha_t *, ips_scb_t *);
412 static int ips_online(ips_ha_t *, ips_scb_t *);
413 static int ips_inquiry(ips_ha_t *, ips_scb_t *);
414 static int ips_rdcap(ips_ha_t *, ips_scb_t *);
415 static int ips_msense(ips_ha_t *, ips_scb_t *);
416 static int ips_reqsen(ips_ha_t *, ips_scb_t *);
417 static int ips_deallocatescbs(ips_ha_t *, int);
418 static int ips_allocatescbs(ips_ha_t *);
419 static int ips_reset_copperhead(ips_ha_t *);
420 static int ips_reset_copperhead_memio(ips_ha_t *);
421 static int ips_reset_morpheus(ips_ha_t *);
422 static int ips_issue_copperhead(ips_ha_t *, ips_scb_t *);
423 static int ips_issue_copperhead_memio(ips_ha_t *, ips_scb_t *);
424 static int ips_issue_i2o(ips_ha_t *, ips_scb_t *);
425 static int ips_issue_i2o_memio(ips_ha_t *, ips_scb_t *);
426 static int ips_isintr_copperhead(ips_ha_t *);
427 static int ips_isintr_copperhead_memio(ips_ha_t *);
428 static int ips_isintr_morpheus(ips_ha_t *);
429 static int ips_wait(ips_ha_t *, int, int);
430 static int ips_write_driver_status(ips_ha_t *, int);
431 static int ips_read_adapter_status(ips_ha_t *, int);
432 static int ips_read_subsystem_parameters(ips_ha_t *, int);
433 static int ips_read_config(ips_ha_t *, int);
434 static int ips_clear_adapter(ips_ha_t *, int);
435 static int ips_readwrite_page5(ips_ha_t *, int, int);
436 static int ips_init_copperhead(ips_ha_t *);
437 static int ips_init_copperhead_memio(ips_ha_t *);
438 static int ips_init_morpheus(ips_ha_t *);
439 static int ips_isinit_copperhead(ips_ha_t *);
440 static int ips_isinit_copperhead_memio(ips_ha_t *);
441 static int ips_isinit_morpheus(ips_ha_t *);
442 static int ips_erase_bios(ips_ha_t *);
443 static int ips_program_bios(ips_ha_t *, char *, uint32_t, uint32_t);
444 static int ips_verify_bios(ips_ha_t *, char *, uint32_t, uint32_t);
445 static int ips_erase_bios_memio(ips_ha_t *);
446 static int ips_program_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
447 static int ips_verify_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
448 static int ips_flash_copperhead(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
449 static int ips_flash_bios(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
450 static int ips_flash_firmware(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
451 static void ips_free_flash_copperhead(ips_ha_t * ha);
452 static void ips_get_bios_version(ips_ha_t *, int);
453 static void ips_identify_controller(ips_ha_t *);
454 static void ips_chkstatus(ips_ha_t *, IPS_STATUS *);
455 static void ips_enable_int_copperhead(ips_ha_t *);
456 static void ips_enable_int_copperhead_memio(ips_ha_t *);
457 static void ips_enable_int_morpheus(ips_ha_t *);
458 static int ips_intr_copperhead(ips_ha_t *);
459 static int ips_intr_morpheus(ips_ha_t *);
460 static void ips_next(ips_ha_t *, int);
461 static void ipsintr_blocking(ips_ha_t *, struct ips_scb *);
462 static void ipsintr_done(ips_ha_t *, struct ips_scb *);
463 static void ips_done(ips_ha_t *, ips_scb_t *);
464 static void ips_free(ips_ha_t *);
465 static void ips_init_scb(ips_ha_t *, ips_scb_t *);
466 static void ips_freescb(ips_ha_t *, ips_scb_t *);
467 static void ips_setup_funclist(ips_ha_t *);
468 static void ips_statinit(ips_ha_t *);
469 static void ips_statinit_memio(ips_ha_t *);
470 static void ips_fix_ffdc_time(ips_ha_t *, ips_scb_t *, time_t);
471 static void ips_ffdc_reset(ips_ha_t *, int);
472 static void ips_ffdc_time(ips_ha_t *);
473 static uint32_t ips_statupd_copperhead(ips_ha_t *);
474 static uint32_t ips_statupd_copperhead_memio(ips_ha_t *);
475 static uint32_t ips_statupd_morpheus(ips_ha_t *);
476 static ips_scb_t *ips_getscb(ips_ha_t *);
477 static inline void ips_putq_scb_head(ips_scb_queue_t *, ips_scb_t *);
478 static inline void ips_putq_scb_tail(ips_scb_queue_t *, ips_scb_t *);
479 static inline void ips_putq_wait_head(ips_wait_queue_t *, Scsi_Cmnd *);
480 static inline void ips_putq_wait_tail(ips_wait_queue_t *, Scsi_Cmnd *);
481 static inline void ips_putq_copp_head(ips_copp_queue_t *,
482 ips_copp_wait_item_t *);
483 static inline void ips_putq_copp_tail(ips_copp_queue_t *,
484 ips_copp_wait_item_t *);
485 static inline ips_scb_t *ips_removeq_scb_head(ips_scb_queue_t *);
486 static inline ips_scb_t *ips_removeq_scb(ips_scb_queue_t *, ips_scb_t *);
487 static inline Scsi_Cmnd *ips_removeq_wait_head(ips_wait_queue_t *);
488 static inline Scsi_Cmnd *ips_removeq_wait(ips_wait_queue_t *, Scsi_Cmnd *);
489 static inline ips_copp_wait_item_t *ips_removeq_copp(ips_copp_queue_t *,
490 ips_copp_wait_item_t *);
491 static inline ips_copp_wait_item_t *ips_removeq_copp_head(ips_copp_queue_t *);
493 static int ips_is_passthru(Scsi_Cmnd *);
494 static int ips_make_passthru(ips_ha_t *, Scsi_Cmnd *, ips_scb_t *, int);
495 static int ips_usrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
496 static void ips_cleanup_passthru(ips_ha_t *, ips_scb_t *);
497 static void ips_scmd_buf_write(Scsi_Cmnd * scmd, void *data,
499 static void ips_scmd_buf_read(Scsi_Cmnd * scmd, void *data, unsigned int count);
501 int ips_proc_info(struct Scsi_Host *, char *, char **, off_t, int, int);
502 static int ips_host_info(ips_ha_t *, char *, off_t, int);
503 static void copy_mem_info(IPS_INFOSTR *, char *, int);
504 static int copy_info(IPS_INFOSTR *, char *, ...);
505 static int ips_get_version_info(ips_ha_t * ha, dma_addr_t, int intr);
506 static void ips_version_check(ips_ha_t * ha, int intr);
507 static int ips_abort_init(ips_ha_t * ha, int index);
508 static int ips_init_phase2(int index);
510 static int ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr);
511 static int ips_register_scsi(int index);
512 /*--------------------------------------------------------------------------*/
513 /* Exported Functions */
514 /*--------------------------------------------------------------------------*/
516 /****************************************************************************/
518 /* Routine Name: ips_setup */
520 /* Routine Description: */
522 /* setup parameters to the driver */
524 /****************************************************************************/
526 ips_setup(char *ips_str)
532 IPS_OPTION options[] = {
533 {"noi2o", &ips_force_i2o, 0},
534 {"nommap", &ips_force_memio, 0},
535 {"ioctlsize", &ips_ioctlsize, IPS_IOCTL_SIZE},
536 {"cdboot", &ips_cd_boot, 0},
537 {"maxcmds", &MaxLiteCmds, 32},
540 /* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
541 /* Search for value */
542 while ((key = strsep(&ips_str, ",."))) {
545 value = strchr(key, ':');
549 * We now have key/value pairs.
550 * Update the variables
552 for (i = 0; i < (sizeof (options) / sizeof (options[0])); i++) {
554 (key, options[i].option_name,
555 strlen(options[i].option_name)) == 0) {
557 *options[i].option_flag =
558 simple_strtoul(value, NULL, 0);
560 *options[i].option_flag =
561 options[i].option_value;
570 __setup("ips=", ips_setup);
572 /****************************************************************************/
574 /* Routine Name: ips_detect */
576 /* Routine Description: */
578 /* Detect and initialize the driver */
580 /* NOTE: this routine is called under the io_request_lock spinlock */
582 /****************************************************************************/
584 ips_detect(Scsi_Host_Template * SHT)
588 METHOD_TRACE("ips_detect", 1);
595 for (i = 0; i < ips_num_controllers; i++) {
596 if (ips_register_scsi(i))
598 ips_released_controllers++;
601 return (ips_num_controllers);
604 /****************************************************************************/
605 /* configure the function pointers to use the functions that will work */
606 /* with the found version of the adapter */
607 /****************************************************************************/
609 ips_setup_funclist(ips_ha_t * ha)
615 if (IPS_IS_MORPHEUS(ha) || IPS_IS_MARCO(ha)) {
616 /* morpheus / marco / sebring */
617 ha->func.isintr = ips_isintr_morpheus;
618 ha->func.isinit = ips_isinit_morpheus;
619 ha->func.issue = ips_issue_i2o_memio;
620 ha->func.init = ips_init_morpheus;
621 ha->func.statupd = ips_statupd_morpheus;
622 ha->func.reset = ips_reset_morpheus;
623 ha->func.intr = ips_intr_morpheus;
624 ha->func.enableint = ips_enable_int_morpheus;
625 } else if (IPS_USE_MEMIO(ha)) {
626 /* copperhead w/MEMIO */
627 ha->func.isintr = ips_isintr_copperhead_memio;
628 ha->func.isinit = ips_isinit_copperhead_memio;
629 ha->func.init = ips_init_copperhead_memio;
630 ha->func.statupd = ips_statupd_copperhead_memio;
631 ha->func.statinit = ips_statinit_memio;
632 ha->func.reset = ips_reset_copperhead_memio;
633 ha->func.intr = ips_intr_copperhead;
634 ha->func.erasebios = ips_erase_bios_memio;
635 ha->func.programbios = ips_program_bios_memio;
636 ha->func.verifybios = ips_verify_bios_memio;
637 ha->func.enableint = ips_enable_int_copperhead_memio;
638 if (IPS_USE_I2O_DELIVER(ha))
639 ha->func.issue = ips_issue_i2o_memio;
641 ha->func.issue = ips_issue_copperhead_memio;
644 ha->func.isintr = ips_isintr_copperhead;
645 ha->func.isinit = ips_isinit_copperhead;
646 ha->func.init = ips_init_copperhead;
647 ha->func.statupd = ips_statupd_copperhead;
648 ha->func.statinit = ips_statinit;
649 ha->func.reset = ips_reset_copperhead;
650 ha->func.intr = ips_intr_copperhead;
651 ha->func.erasebios = ips_erase_bios;
652 ha->func.programbios = ips_program_bios;
653 ha->func.verifybios = ips_verify_bios;
654 ha->func.enableint = ips_enable_int_copperhead;
656 if (IPS_USE_I2O_DELIVER(ha))
657 ha->func.issue = ips_issue_i2o;
659 ha->func.issue = ips_issue_copperhead;
663 /****************************************************************************/
665 /* Routine Name: ips_release */
667 /* Routine Description: */
669 /* Remove a driver */
671 /****************************************************************************/
673 ips_release(struct Scsi_Host *sh)
679 METHOD_TRACE("ips_release", 1);
681 for (i = 0; i < IPS_MAX_ADAPTERS && ips_sh[i] != sh; i++) ;
683 if (i == IPS_MAX_ADAPTERS) {
685 "(%s) release, invalid Scsi_Host pointer.\n", ips_name);
695 /* flush the cache on the controller */
696 scb = &ha->scbs[ha->max_cmds - 1];
698 ips_init_scb(ha, scb);
700 scb->timeout = ips_cmd_timeout;
701 scb->cdb[0] = IPS_CMD_FLUSH;
703 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
704 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
705 scb->cmd.flush_cache.state = IPS_NORM_STATE;
706 scb->cmd.flush_cache.reserved = 0;
707 scb->cmd.flush_cache.reserved2 = 0;
708 scb->cmd.flush_cache.reserved3 = 0;
709 scb->cmd.flush_cache.reserved4 = 0;
711 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
714 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
715 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Incomplete Flush.\n");
717 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Complete.\n");
722 /* free extra memory */
725 /* Free I/O Region */
727 release_region(ha->io_addr, ha->io_len);
730 free_irq(ha->irq, ha);
735 ips_released_controllers++;
740 /****************************************************************************/
742 /* Routine Name: ips_halt */
744 /* Routine Description: */
746 /* Perform cleanup when the system reboots */
748 /****************************************************************************/
750 ips_halt(struct notifier_block *nb, ulong event, void *buf)
756 if ((event != SYS_RESTART) && (event != SYS_HALT) &&
757 (event != SYS_POWER_OFF))
758 return (NOTIFY_DONE);
760 for (i = 0; i < ips_next_controller; i++) {
761 ha = (ips_ha_t *) ips_ha[i];
769 /* flush the cache on the controller */
770 scb = &ha->scbs[ha->max_cmds - 1];
772 ips_init_scb(ha, scb);
774 scb->timeout = ips_cmd_timeout;
775 scb->cdb[0] = IPS_CMD_FLUSH;
777 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
778 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
779 scb->cmd.flush_cache.state = IPS_NORM_STATE;
780 scb->cmd.flush_cache.reserved = 0;
781 scb->cmd.flush_cache.reserved2 = 0;
782 scb->cmd.flush_cache.reserved3 = 0;
783 scb->cmd.flush_cache.reserved4 = 0;
785 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
788 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) ==
790 IPS_PRINTK(KERN_WARNING, ha->pcidev,
791 "Incomplete Flush.\n");
793 IPS_PRINTK(KERN_WARNING, ha->pcidev,
794 "Flushing Complete.\n");
800 /****************************************************************************/
802 /* Routine Name: ips_eh_abort */
804 /* Routine Description: */
806 /* Abort a command (using the new error code stuff) */
807 /* Note: this routine is called under the io_request_lock */
808 /****************************************************************************/
810 ips_eh_abort(Scsi_Cmnd * SC)
813 ips_copp_wait_item_t *item;
816 METHOD_TRACE("ips_eh_abort", 1);
821 ha = (ips_ha_t *) SC->device->host->hostdata;
829 if (SC->serial_number != SC->serial_number_at_timeout) {
830 /* HMM, looks like a bogus command */
831 DEBUG(1, "Abort called with bogus scsi command");
836 /* See if the command is on the copp queue */
837 item = ha->copp_waitlist.head;
838 while ((item) && (item->scsi_cmd != SC))
843 ips_removeq_copp(&ha->copp_waitlist, item);
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 */
851 /* command must have already been sent */
857 /****************************************************************************/
859 /* Routine Name: ips_eh_reset */
861 /* Routine Description: */
863 /* Reset the controller (with new eh error code) */
865 /* NOTE: this routine is called under the io_request_lock spinlock */
867 /****************************************************************************/
869 ips_eh_reset(Scsi_Cmnd * SC)
875 ips_copp_wait_item_t *item;
877 METHOD_TRACE("ips_eh_reset", 1);
884 DEBUG(1, "Reset called with NULL scsi command");
889 ha = (ips_ha_t *) SC->device->host->hostdata;
892 DEBUG(1, "Reset called with NULL ha struct");
900 /* See if the command is on the copp queue */
901 item = ha->copp_waitlist.head;
902 while ((item) && (item->scsi_cmd != SC))
907 ips_removeq_copp(&ha->copp_waitlist, item);
911 /* See if the command is on the wait queue */
912 if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
913 /* command not sent yet */
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 ). */
927 if (ha->ioctl_reset == 0) { /* IF Not an IOCTL Requested Reset */
928 scb = &ha->scbs[ha->max_cmds - 1];
930 ips_init_scb(ha, scb);
932 scb->timeout = ips_cmd_timeout;
933 scb->cdb[0] = IPS_CMD_FLUSH;
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;
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");
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. */
955 ha->ioctl_reset = 0; /* Reset the IOCTL Requested Reset Flag */
958 * command must have already been sent
959 * reset the controller
961 IPS_PRINTK(KERN_NOTICE, ha->pcidev, "Resetting controller.\n");
962 ret = (*ha->func.reset) (ha);
967 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
968 "Controller reset failed - controller now offline.\n");
970 /* Now fail all of the active commands */
971 DEBUG_VAR(1, "(%s%d) Failing active commands",
972 ips_name, ha->host_num);
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);
980 /* Now fail all of the pending commands */
981 DEBUG_VAR(1, "(%s%d) Failing pending commands",
982 ips_name, ha->host_num);
984 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
985 scsi_cmd->result = DID_ERROR;
986 scsi_cmd->scsi_done(scsi_cmd);
993 if (!ips_clear_adapter(ha, IPS_INTR_IORL)) {
996 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
997 "Controller reset failed - controller now offline.\n");
999 /* Now fail all of the active commands */
1000 DEBUG_VAR(1, "(%s%d) Failing active commands",
1001 ips_name, ha->host_num);
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);
1009 /* Now fail all of the pending commands */
1010 DEBUG_VAR(1, "(%s%d) Failing pending commands",
1011 ips_name, ha->host_num);
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);
1023 if (le32_to_cpu(ha->subsys->param[3]) & 0x300000) {
1026 do_gettimeofday(&tv);
1027 ha->last_ffdc = tv.tv_sec;
1029 ips_ffdc_reset(ha, IPS_INTR_IORL);
1032 /* Now fail all of the active commands */
1033 DEBUG_VAR(1, "(%s%d) Failing active commands", ips_name, ha->host_num);
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);
1042 /* Reset DCDB active command bits */
1043 for (i = 1; i < ha->nbus; i++)
1044 ha->dcdb_active[i - 1] = 0;
1046 /* Reset the number of active IOCTLs */
1049 ips_next(ha, IPS_INTR_IORL);
1052 #endif /* NO_IPS_RESET */
1056 /****************************************************************************/
1058 /* Routine Name: ips_queue */
1060 /* Routine Description: */
1062 /* Send a command to the controller */
1065 /* Linux obtains io_request_lock before calling this function */
1067 /****************************************************************************/
1069 ips_queue(Scsi_Cmnd * SC, void (*done) (Scsi_Cmnd *))
1074 METHOD_TRACE("ips_queue", 1);
1076 ha = (ips_ha_t *) SC->device->host->hostdata;
1084 if (ips_is_passthru(SC)) {
1085 if (ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
1086 SC->result = DID_BUS_BUSY << 16;
1091 } else if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
1092 SC->result = DID_BUS_BUSY << 16;
1098 SC->scsi_done = done;
1100 DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
1104 SC->device->channel, SC->device->id, SC->device->lun);
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;
1115 if (ips_is_passthru(SC)) {
1117 ips_copp_wait_item_t *scratch;
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;
1130 ha->ioctl_reset = 1; /* This reset request is from an IOCTL */
1132 SC->result = DID_OK << 16;
1137 /* allocate space for the scribble */
1138 scratch = kmalloc(sizeof (ips_copp_wait_item_t), GFP_ATOMIC);
1141 SC->result = DID_ERROR << 16;
1147 scratch->scsi_cmd = SC;
1148 scratch->next = NULL;
1150 ips_putq_copp_tail(&ha->copp_waitlist, scratch);
1152 ips_putq_wait_tail(&ha->scb_waitlist, SC);
1155 ips_next(ha, IPS_INTR_IORL);
1160 /****************************************************************************/
1162 /* Routine Name: ips_biosparam */
1164 /* Routine Description: */
1166 /* Set bios geometry for the controller */
1168 /****************************************************************************/
1170 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1171 ips_biosparam(Disk * disk, kdev_t dev, int geom[])
1173 ips_ha_t *ha = (ips_ha_t *) disk->device->host->hostdata;
1174 unsigned long capacity = disk->capacity;
1176 ips_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1177 sector_t capacity, int geom[])
1179 ips_ha_t *ha = (ips_ha_t *) sdev->host->hostdata;
1185 METHOD_TRACE("ips_biosparam", 1);
1188 /* ?!?! host adater info invalid */
1194 if (!ips_read_adapter_status(ha, IPS_INTR_ON))
1195 /* ?!?! Enquiry command failed */
1198 if ((capacity > 0x400000) && ((ha->enq->ucMiscFlag & 0x8) == 0)) {
1199 heads = IPS_NORM_HEADS;
1200 sectors = IPS_NORM_SECTORS;
1202 heads = IPS_COMP_HEADS;
1203 sectors = IPS_COMP_SECTORS;
1206 cylinders = (unsigned long) capacity / (heads * sectors);
1208 DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
1209 heads, sectors, cylinders);
1213 geom[2] = cylinders;
1218 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1220 /* ips_proc24_info is a wrapper around ips_proc_info *
1221 * for compatibility with the 2.4 scsi parameters */
1223 ips_proc24_info(char *buffer, char **start, off_t offset, int length,
1224 int hostno, int func)
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);
1237 /****************************************************************************/
1239 /* Routine Name: ips_select_queue_depth */
1241 /* Routine Description: */
1243 /* Select queue depths for the devices on the contoller */
1245 /****************************************************************************/
1247 ips_select_queue_depth(struct Scsi_Host *host, Scsi_Device * scsi_devs)
1249 Scsi_Device *device;
1255 min = ha->max_cmds / 4;
1257 for (device = scsi_devs; device; device = device->next) {
1258 if (device->host == host) {
1259 if ((device->channel == 0) && (device->type == 0))
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;
1272 device->queue_depth = 2;
1275 if (device->queue_depth < 2)
1276 device->queue_depth = 2;
1282 /****************************************************************************/
1284 /* Routine Name: ips_slave_configure */
1286 /* Routine Description: */
1288 /* Set queue depths on devices once scan is complete */
1290 /****************************************************************************/
1292 ips_slave_configure(Scsi_Device * SDptr)
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);
1308 /****************************************************************************/
1310 /* Routine Name: do_ipsintr */
1312 /* Routine Description: */
1314 /* Wrapper for the interrupt handler */
1316 /****************************************************************************/
1318 do_ipsintr(int irq, void *dev_id, struct pt_regs * regs)
1321 unsigned long cpu_flags;
1322 struct Scsi_Host *host;
1325 METHOD_TRACE("do_ipsintr", 2);
1327 ha = (ips_ha_t *) dev_id;
1330 host = ips_sh[ha->host_num];
1331 /* interrupt during initialization */
1333 (*ha->func.intr) (ha);
1337 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
1340 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1344 irqstatus = (*ha->func.intr) (ha);
1346 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1348 /* start the next command */
1349 ips_next(ha, IPS_INTR_ON);
1350 return IRQ_RETVAL(irqstatus);
1353 /****************************************************************************/
1355 /* Routine Name: ips_intr_copperhead */
1357 /* Routine Description: */
1359 /* Polling interrupt handler */
1361 /* ASSUMES interrupts are disabled */
1363 /****************************************************************************/
1365 ips_intr_copperhead(ips_ha_t * ha)
1372 METHOD_TRACE("ips_intr", 2);
1380 intrstatus = (*ha->func.isintr) (ha);
1384 * Unexpected/Shared interrupt
1393 intrstatus = (*ha->func.isintr) (ha);
1398 cstatus.value = (*ha->func.statupd) (ha);
1400 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1401 /* Spurious Interupt ? */
1405 ips_chkstatus(ha, &cstatus);
1406 scb = (ips_scb_t *) sp->scb_addr;
1409 * use the callback function to finish things up
1410 * NOTE: interrupts are OFF for this
1412 (*scb->callback) (ha, scb);
1417 /****************************************************************************/
1419 /* Routine Name: ips_intr_morpheus */
1421 /* Routine Description: */
1423 /* Polling interrupt handler */
1425 /* ASSUMES interrupts are disabled */
1427 /****************************************************************************/
1429 ips_intr_morpheus(ips_ha_t * ha)
1436 METHOD_TRACE("ips_intr_morpheus", 2);
1444 intrstatus = (*ha->func.isintr) (ha);
1448 * Unexpected/Shared interrupt
1457 intrstatus = (*ha->func.isintr) (ha);
1462 cstatus.value = (*ha->func.statupd) (ha);
1464 if (cstatus.value == 0xffffffff)
1465 /* No more to process */
1468 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1469 IPS_PRINTK(KERN_WARNING, ha->pcidev,
1470 "Spurious interrupt; no ccb.\n");
1475 ips_chkstatus(ha, &cstatus);
1476 scb = (ips_scb_t *) sp->scb_addr;
1479 * use the callback function to finish things up
1480 * NOTE: interrupts are OFF for this
1482 (*scb->callback) (ha, scb);
1487 /****************************************************************************/
1489 /* Routine Name: ips_info */
1491 /* Routine Description: */
1493 /* Return info about the driver */
1495 /****************************************************************************/
1497 ips_info(struct Scsi_Host *SH)
1499 static char buffer[256];
1503 METHOD_TRACE("ips_info", 1);
1511 memset(bp, 0, sizeof (buffer));
1513 sprintf(bp, "%s%s%s Build %d", "IBM PCI ServeRAID ",
1514 IPS_VERSION_HIGH, IPS_VERSION_LOW, IPS_BUILD_IDENT);
1516 if (ha->ad_type > 0 && ha->ad_type <= MAX_ADAPTER_NAME) {
1518 strcat(bp, ips_adapter_name[ha->ad_type - 1]);
1525 /****************************************************************************/
1527 /* Routine Name: ips_proc_info */
1529 /* Routine Description: */
1531 /* The passthru interface for the driver */
1533 /****************************************************************************/
1535 ips_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
1536 int length, int func)
1540 ips_ha_t *ha = NULL;
1542 METHOD_TRACE("ips_proc_info", 1);
1544 /* Find our host structure */
1545 for (i = 0; i < ips_next_controller; i++) {
1547 if (ips_sh[i] == host) {
1548 ha = (ips_ha_t *) ips_sh[i]->hostdata;
1565 ret = ips_host_info(ha, buffer, offset, length);
1571 /*--------------------------------------------------------------------------*/
1572 /* Helper Functions */
1573 /*--------------------------------------------------------------------------*/
1575 /****************************************************************************/
1577 /* Routine Name: ips_is_passthru */
1579 /* Routine Description: */
1581 /* Determine if the specified SCSI command is really a passthru command */
1583 /****************************************************************************/
1585 ips_is_passthru(Scsi_Cmnd * SC)
1587 METHOD_TRACE("ips_is_passthru", 1);
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'))
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')
1613 /****************************************************************************/
1615 /* Routine Name: ips_alloc_passthru_buffer */
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 /****************************************************************************/
1622 ips_alloc_passthru_buffer(ips_ha_t * ha, int length)
1625 dma_addr_t dma_busaddr;
1627 if (ha->ioctl_data && length <= ha->ioctl_len)
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);
1632 /* free the old memory */
1633 pci_free_consistent(ha->pcidev, ha->ioctl_len, ha->ioctl_data,
1635 /* use the new memory */
1636 ha->ioctl_data = (char *) bigger_buf;
1637 ha->ioctl_len = length;
1638 ha->ioctl_busaddr = dma_busaddr;
1645 /****************************************************************************/
1647 /* Routine Name: ips_make_passthru */
1649 /* Routine Description: */
1651 /* Make a passthru command out of the info in the Scsi block */
1653 /****************************************************************************/
1655 ips_make_passthru(ips_ha_t * ha, Scsi_Cmnd * SC, ips_scb_t * scb, int intr)
1661 METHOD_TRACE("ips_make_passthru", 1);
1664 length = SC->request_bufflen;
1666 struct scatterlist *sg = SC->request_buffer;
1668 for (i = 0; i < SC->use_sg; i++)
1669 length += sg[i].length;
1671 if (length < sizeof (ips_passthru_t)) {
1673 DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
1674 ips_name, ha->host_num);
1675 return (IPS_FAILURE);
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));
1689 ha->ioctl_datasize = length;
1691 ips_scmd_buf_read(SC, ha->ioctl_data, ha->ioctl_datasize);
1692 pt = (ips_passthru_t *) ha->ioctl_data;
1695 * Some notes about the passthru interface used
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.
1704 switch (pt->CoppCmd) {
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;
1712 return (IPS_SUCCESS_IMM);
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)) {
1720 "(%s%d) Passthru structure wrong size",
1721 ips_name, ha->host_num);
1723 return (IPS_FAILURE);
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));
1734 if (ips_usrcmd(ha, pt, scb))
1735 return (IPS_SUCCESS);
1737 return (IPS_FAILURE);
1744 return (IPS_FAILURE);
1747 /****************************************************************************/
1748 /* Routine Name: ips_flash_copperhead */
1749 /* Routine Description: */
1750 /* Flash the BIOS/FW on a Copperhead style controller */
1751 /****************************************************************************/
1753 ips_flash_copperhead(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
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))
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,
1785 &ha->flash_busaddr);
1786 if (!ha->flash_data){
1787 printk(KERN_WARNING "Unable to allocate a flash buffer\n");
1790 ha->flash_datasize = 0;
1791 ha->flash_len = datasize;
1795 if (pt->CoppCP.cmd.flashfw.count + ha->flash_datasize >
1797 ips_free_flash_copperhead(ha);
1798 IPS_PRINTK(KERN_WARNING, ha->pcidev,
1799 "failed size sanity check\n");
1803 if (!ha->flash_data)
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);
1816 return IPS_SUCCESS_IMM;
1819 /****************************************************************************/
1820 /* Routine Name: ips_flash_bios */
1821 /* Routine Description: */
1822 /* flashes the bios of a copperhead adapter */
1823 /****************************************************************************/
1825 ips_flash_bios(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
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))
1833 if ((*ha->func.erasebios) (ha)) {
1835 "(%s%d) flash bios failed - unable to erase flash",
1836 ips_name, ha->host_num);
1839 if ((*ha->func.programbios) (ha,
1842 ha->flash_datasize -
1843 IPS_BIOS_HEADER, 0)) {
1845 "(%s%d) flash bios failed - unable to flash",
1846 ips_name, ha->host_num);
1849 if ((*ha->func.verifybios) (ha,
1852 ha->flash_datasize -
1853 IPS_BIOS_HEADER, 0)) {
1855 "(%s%d) flash bios failed - unable to verify flash",
1856 ips_name, ha->host_num);
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)
1865 if ((*ha->func.erasebios) (ha)) {
1867 "(%s%d) flash bios failed - unable to erase flash",
1868 ips_name, ha->host_num);
1871 return IPS_SUCCESS_IMM;
1874 pt->BasicStatus = 0x0B;
1875 pt->ExtendedStatus = 0x00;
1876 ips_free_flash_copperhead(ha);
1880 /****************************************************************************/
1882 /* Routine Name: ips_fill_scb_sg_single */
1884 /* Routine Description: */
1885 /* Fill in a single scb sg_list element from an address */
1886 /* return a -1 if a breakup occurred */
1887 /****************************************************************************/
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)
1895 if ((scb->data_len + e_len) > ha->max_xfer) {
1896 e_len = ha->max_xfer - scb->data_len;
1897 scb->breakup = indx;
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);
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);
1917 scb->data_len += e_len;
1921 /****************************************************************************/
1922 /* Routine Name: ips_flash_firmware */
1923 /* Routine Description: */
1924 /* flashes the firmware of a copperhead adapter */
1925 /****************************************************************************/
1927 ips_flash_firmware(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1929 IPS_SG_LIST sg_list;
1930 uint32_t cmd_busaddr;
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);
1938 pt->BasicStatus = 0x0B;
1939 pt->ExtendedStatus = 0x00;
1940 ips_free_flash_copperhead(ha);
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;
1958 scb->callback = ipsintr_done;
1959 scb->timeout = ips_cmd_timeout;
1961 scb->data_len = ha->flash_datasize;
1963 pci_map_single(ha->pcidev, ha->flash_data, scb->data_len,
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);
1969 scb->timeout = pt->TimeOut;
1970 scb->scsi_cmd->result = DID_OK << 16;
1974 /****************************************************************************/
1975 /* Routine Name: ips_free_flash_copperhead */
1976 /* Routine Description: */
1977 /* release the memory resources used to hold the flash image */
1978 /****************************************************************************/
1980 ips_free_flash_copperhead(ips_ha_t * ha)
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,
1987 ha->flash_data = NULL;
1990 /****************************************************************************/
1992 /* Routine Name: ips_usrcmd */
1994 /* Routine Description: */
1996 /* Process a user command and make it ready to send */
1998 /****************************************************************************/
2000 ips_usrcmd(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
2002 IPS_SG_LIST sg_list;
2003 uint32_t cmd_busaddr;
2005 METHOD_TRACE("ips_usrcmd", 1);
2007 if ((!scb) || (!pt) || (!ha))
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));
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;
2027 scb->callback = ipsintr_done;
2028 scb->timeout = ips_cmd_timeout;
2029 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
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))
2038 scb->data_len = pt->CmdBSize;
2039 scb->data_busaddr = ha->ioctl_busaddr + sizeof (ips_passthru_t);
2041 scb->data_busaddr = 0L;
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->
2048 (unsigned long) scb);
2051 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
2052 scb->dcdb.buffer_pointer =
2053 cpu_to_le32(scb->data_busaddr);
2055 scb->cmd.basic_io.sg_addr =
2056 cpu_to_le32(scb->data_busaddr);
2061 scb->timeout = pt->TimeOut;
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;
2068 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
2071 /* assume success */
2072 scb->scsi_cmd->result = DID_OK << 16;
2078 /****************************************************************************/
2080 /* Routine Name: ips_cleanup_passthru */
2082 /* Routine Description: */
2084 /* Cleanup after a passthru command */
2086 /****************************************************************************/
2088 ips_cleanup_passthru(ips_ha_t * ha, ips_scb_t * scb)
2092 METHOD_TRACE("ips_cleanup_passthru", 1);
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);
2100 pt = (ips_passthru_t *) ha->ioctl_data;
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));
2106 pt->BasicStatus = scb->basic_status;
2107 pt->ExtendedStatus = scb->extended_status;
2108 pt->AdapterType = ha->ad_type;
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);
2115 ips_scmd_buf_write(scb->scsi_cmd, ha->ioctl_data, ha->ioctl_datasize);
2118 /****************************************************************************/
2120 /* Routine Name: ips_host_info */
2122 /* Routine Description: */
2124 /* The passthru interface for the driver */
2126 /****************************************************************************/
2128 ips_host_info(ips_ha_t * ha, char *ptr, off_t offset, int len)
2132 METHOD_TRACE("ips_host_info", 1);
2136 info.offset = offset;
2140 copy_info(&info, "\nIBM ServeRAID General Information:\n\n");
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]);
2148 "\tController Type : Unknown\n");
2152 "\tIO region : 0x%lx (%d bytes)\n",
2153 ha->io_addr, ha->io_len);
2157 "\tMemory region : 0x%lx (%d bytes)\n",
2158 ha->mem_addr, ha->mem_len);
2160 "\tShared memory address : 0x%lx\n",
2164 copy_info(&info, "\tIRQ number : %d\n", ha->irq);
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. */
2169 if (le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) {
2170 if (ha->nvram->bios_low[3] == 0) {
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]);
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]);
2189 if (ha->enq->CodeBlkVersion[7] == 0) {
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]);
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]);
2205 if (ha->enq->BootBlkVersion[7] == 0) {
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]);
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]);
2221 copy_info(&info, "\tDriver Version : %s%s\n",
2222 IPS_VERSION_HIGH, IPS_VERSION_LOW);
2224 copy_info(&info, "\tDriver Build : %d\n",
2227 copy_info(&info, "\tMax Physical Devices : %d\n",
2228 ha->enq->ucMaxPhysicalDevices);
2229 copy_info(&info, "\tMax Active Commands : %d\n",
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",
2240 copy_info(&info, "\n");
2242 return (info.localpos);
2245 /****************************************************************************/
2247 /* Routine Name: copy_mem_info */
2249 /* Routine Description: */
2251 /* Copy data into an IPS_INFOSTR structure */
2253 /****************************************************************************/
2255 copy_mem_info(IPS_INFOSTR * info, char *data, int len)
2257 METHOD_TRACE("copy_mem_info", 1);
2259 if (info->pos + len < info->offset) {
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);
2270 if (info->localpos + len > info->length)
2271 len = info->length - info->localpos;
2274 memcpy(info->buffer + info->localpos, data, len);
2276 info->localpos += len;
2280 /****************************************************************************/
2282 /* Routine Name: copy_info */
2284 /* Routine Description: */
2286 /* printf style wrapper for an info structure */
2288 /****************************************************************************/
2290 copy_info(IPS_INFOSTR * info, char *fmt, ...)
2296 METHOD_TRACE("copy_info", 1);
2298 va_start(args, fmt);
2299 len = vsprintf(buf, fmt, args);
2302 copy_mem_info(info, buf, len);
2307 /****************************************************************************/
2309 /* Routine Name: ips_identify_controller */
2311 /* Routine Description: */
2313 /* Identify this controller */
2315 /****************************************************************************/
2317 ips_identify_controller(ips_ha_t * ha)
2319 METHOD_TRACE("ips_identify_controller", 1);
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;
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;
2344 case IPS_DEVICEID_MORPHEUS:
2345 switch (ha->subdevice_id) {
2346 case IPS_SUBDEVICEID_4L:
2347 ha->ad_type = IPS_ADTYPE_SERVERAID4L;
2350 case IPS_SUBDEVICEID_4M:
2351 ha->ad_type = IPS_ADTYPE_SERVERAID4M;
2354 case IPS_SUBDEVICEID_4MX:
2355 ha->ad_type = IPS_ADTYPE_SERVERAID4MX;
2358 case IPS_SUBDEVICEID_4LX:
2359 ha->ad_type = IPS_ADTYPE_SERVERAID4LX;
2362 case IPS_SUBDEVICEID_5I2:
2363 ha->ad_type = IPS_ADTYPE_SERVERAID5I2;
2366 case IPS_SUBDEVICEID_5I1:
2367 ha->ad_type = IPS_ADTYPE_SERVERAID5I1;
2373 case IPS_DEVICEID_MARCO:
2374 switch (ha->subdevice_id) {
2375 case IPS_SUBDEVICEID_6M:
2376 ha->ad_type = IPS_ADTYPE_SERVERAID6M;
2378 case IPS_SUBDEVICEID_6I:
2379 ha->ad_type = IPS_ADTYPE_SERVERAID6I;
2381 case IPS_SUBDEVICEID_7k:
2382 ha->ad_type = IPS_ADTYPE_SERVERAID7k;
2384 case IPS_SUBDEVICEID_7M:
2385 ha->ad_type = IPS_ADTYPE_SERVERAID7M;
2392 /****************************************************************************/
2394 /* Routine Name: ips_get_bios_version */
2396 /* Routine Description: */
2398 /* Get the BIOS revision number */
2400 /****************************************************************************/
2402 ips_get_bios_version(ips_ha_t * ha, int intr)
2411 { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
2414 METHOD_TRACE("ips_get_bios_version", 1);
2419 strncpy(ha->bios_version, " ?", 8);
2421 if (ha->device_id == IPS_DEVICEID_COPPERHEAD) {
2422 if (IPS_USE_MEMIO(ha)) {
2423 /* Memory Mapped I/O */
2426 writel(0, ha->mem_ptr + IPS_REG_FLAP);
2427 if (ha->revision_id == IPS_REVID_TROMBONE64)
2428 udelay(25); /* 25 us */
2430 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
2433 writel(1, ha->mem_ptr + IPS_REG_FLAP);
2434 if (ha->revision_id == IPS_REVID_TROMBONE64)
2435 udelay(25); /* 25 us */
2437 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
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 */
2445 major = readb(ha->mem_ptr + IPS_REG_FLDP);
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);
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);
2460 /* Programmed I/O */
2463 outl(0, ha->io_addr + IPS_REG_FLAP);
2464 if (ha->revision_id == IPS_REVID_TROMBONE64)
2465 udelay(25); /* 25 us */
2467 if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
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 */
2474 if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
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 */
2482 major = inb(ha->io_addr + IPS_REG_FLDP);
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 */
2489 minor = inb(ha->io_addr + IPS_REG_FLDP);
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 */
2496 subminor = inb(ha->io_addr + IPS_REG_FLDP);
2500 /* Morpheus Family - Send Command to the card */
2502 buffer = ha->ioctl_data;
2504 memset(buffer, 0, 0x1000);
2506 scb = &ha->scbs[ha->max_cmds - 1];
2508 ips_init_scb(ha, scb);
2510 scb->timeout = ips_cmd_timeout;
2511 scb->cdb[0] = IPS_CMD_RW_BIOSFW;
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;
2523 /* issue the command */
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 */
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) */
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;
2553 /****************************************************************************/
2555 /* Routine Name: ips_hainit */
2557 /* Routine Description: */
2559 /* Initialize the controller */
2561 /* NOTE: Assumes to be called from with a lock */
2563 /****************************************************************************/
2565 ips_hainit(ips_ha_t * ha)
2570 METHOD_TRACE("ips_hainit", 1);
2575 if (ha->func.statinit)
2576 (*ha->func.statinit) (ha);
2578 if (ha->func.enableint)
2579 (*ha->func.enableint) (ha);
2582 ha->reset_count = 1;
2583 do_gettimeofday(&tv);
2584 ha->last_ffdc = tv.tv_sec;
2585 ips_ffdc_reset(ha, IPS_INTR_IORL);
2587 if (!ips_read_config(ha, IPS_INTR_IORL)) {
2588 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2589 "unable to read config from controller.\n");
2594 if (!ips_read_adapter_status(ha, IPS_INTR_IORL)) {
2595 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2596 "unable to read controller status.\n");
2601 /* Identify this controller */
2602 ips_identify_controller(ha);
2604 if (!ips_read_subsystem_parameters(ha, IPS_INTR_IORL)) {
2605 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2606 "unable to read subsystem parameters.\n");
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");
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);
2623 /* set limits on SID, LUN, BUS */
2624 ha->ntargets = IPS_MAX_TARGETS + 1;
2626 ha->nbus = (ha->enq->ucMaxPhysicalDevices / IPS_MAX_TARGETS) + 1;
2628 switch (ha->conf->logical_drive[0].ucStripeSize) {
2630 ha->max_xfer = 0x10000;
2634 ha->max_xfer = 0x20000;
2638 ha->max_xfer = 0x40000;
2643 ha->max_xfer = 0x80000;
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;
2652 /* use the old method */
2653 switch (ha->conf->logical_drive[0].ucStripeSize) {
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;
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;
2691 /****************************************************************************/
2693 /* Routine Name: ips_next */
2695 /* Routine Description: */
2697 /* Take the next command off the queue and send it to the controller */
2699 /****************************************************************************/
2701 ips_next(ips_ha_t * ha, int intr)
2707 ips_copp_wait_item_t *item;
2709 unsigned long cpu_flags = 0;
2710 struct Scsi_Host *host;
2711 METHOD_TRACE("ips_next", 1);
2715 host = ips_sh[ha->host_num];
2717 * Block access to the queue function so
2718 * this command won't time out
2720 if (intr == IPS_INTR_ON)
2721 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2723 if ((ha->subsys->param[3] & 0x300000)
2724 && (ha->scb_activelist.count == 0)) {
2727 do_gettimeofday(&tv);
2729 if (tv.tv_sec - ha->last_ffdc > IPS_SECS_8HOURS) {
2730 ha->last_ffdc = tv.tv_sec;
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
2742 while ((ha->num_ioctl < IPS_MAX_IOCTL) &&
2743 (ha->copp_waitlist.head) && (scb = ips_getscb(ha))) {
2745 item = ips_removeq_copp_head(&ha->copp_waitlist);
2747 if (intr == IPS_INTR_ON)
2748 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2749 scb->scsi_cmd = item->scsi_cmd;
2752 ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
2754 if (intr == IPS_INTR_ON)
2755 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2758 if (scb->scsi_cmd) {
2759 scb->scsi_cmd->result = DID_ERROR << 16;
2760 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2763 ips_freescb(ha, scb);
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);
2771 ips_freescb(ha, scb);
2777 if (ret != IPS_SUCCESS) {
2782 ret = ips_send_cmd(ha, scb);
2784 if (ret == IPS_SUCCESS)
2785 ips_putq_scb_head(&ha->scb_activelist, scb);
2791 if (scb->scsi_cmd) {
2792 scb->scsi_cmd->result = DID_ERROR << 16;
2795 ips_freescb(ha, scb);
2797 case IPS_SUCCESS_IMM:
2798 ips_freescb(ha, scb);
2807 * Send "Normal" I/O commands
2810 p = ha->scb_waitlist.head;
2811 while ((p) && (scb = ips_getscb(ha))) {
2812 if ((p->device->channel > 0)
2814 dcdb_active[p->device->channel -
2815 1] & (1 << p->device->id))) {
2816 ips_freescb(ha, scb);
2817 p = (Scsi_Cmnd *) p->host_scribble;
2822 SC = ips_removeq_wait(&ha->scb_waitlist, q);
2824 if (intr == IPS_INTR_ON)
2825 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags); /* Unlock HA after command is taken off queue */
2827 SC->result = DID_OK;
2828 SC->host_scribble = NULL;
2830 memset(SC->sense_buffer, 0, sizeof (SC->sense_buffer));
2832 scb->target_id = SC->device->id;
2833 scb->lun = SC->device->lun;
2834 scb->bus = SC->device->channel;
2838 scb->callback = ipsintr_done;
2839 scb->timeout = ips_cmd_timeout;
2840 memset(&scb->cmd, 0, 16);
2842 /* copy in the CDB */
2843 memcpy(scb->cdb, SC->cmnd, SC->cmd_len);
2845 /* Now handle the data buffer */
2847 struct scatterlist *sg;
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)
2861 scb->dcdb.transfer_length = scb->data_len;
2863 if (SC->request_bufflen) {
2865 pci_map_single(ha->pcidev,
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,
2873 SC->request_bufflen);
2874 scb->dcdb.transfer_length = scb->data_len;
2876 scb->data_busaddr = 0L;
2879 scb->dcdb.transfer_length = 0;
2884 scb->dcdb.cmd_attribute =
2885 ips_command_direction[scb->scsi_cmd->cmnd[0]];
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;
2892 if (!(scb->dcdb.cmd_attribute & 0x3))
2893 scb->dcdb.transfer_length = 0;
2895 if (scb->data_len >= IPS_MAX_XFER) {
2896 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
2897 scb->dcdb.transfer_length = 0;
2899 if (intr == IPS_INTR_ON)
2900 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2902 ret = ips_send_cmd(ha, scb);
2906 ips_putq_scb_head(&ha->scb_activelist, scb);
2909 if (scb->scsi_cmd) {
2910 scb->scsi_cmd->result = DID_ERROR << 16;
2911 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2915 ha->dcdb_active[scb->bus - 1] &=
2916 ~(1 << scb->target_id);
2918 ips_freescb(ha, scb);
2920 case IPS_SUCCESS_IMM:
2922 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2925 ha->dcdb_active[scb->bus - 1] &=
2926 ~(1 << scb->target_id);
2928 ips_freescb(ha, scb);
2934 p = (Scsi_Cmnd *) p->host_scribble;
2938 if (intr == IPS_INTR_ON)
2939 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2942 /****************************************************************************/
2944 /* Routine Name: ips_putq_scb_head */
2946 /* Routine Description: */
2948 /* Add an item to the head of the queue */
2950 /* ASSUMED to be called from within the HA lock */
2952 /****************************************************************************/
2954 ips_putq_scb_head(ips_scb_queue_t * queue, ips_scb_t * item)
2956 METHOD_TRACE("ips_putq_scb_head", 1);
2961 item->q_next = queue->head;
2970 /****************************************************************************/
2972 /* Routine Name: ips_putq_scb_tail */
2974 /* Routine Description: */
2976 /* Add an item to the tail of the queue */
2978 /* ASSUMED to be called from within the HA lock */
2980 /****************************************************************************/
2982 ips_putq_scb_tail(ips_scb_queue_t * queue, ips_scb_t * item)
2984 METHOD_TRACE("ips_putq_scb_tail", 1);
2989 item->q_next = NULL;
2992 queue->tail->q_next = item;
3002 /****************************************************************************/
3004 /* Routine Name: ips_removeq_scb_head */
3006 /* Routine Description: */
3008 /* Remove the head of the queue */
3010 /* ASSUMED to be called from within the HA lock */
3012 /****************************************************************************/
3013 static inline ips_scb_t *
3014 ips_removeq_scb_head(ips_scb_queue_t * queue)
3018 METHOD_TRACE("ips_removeq_scb_head", 1);
3026 queue->head = item->q_next;
3027 item->q_next = NULL;
3029 if (queue->tail == item)
3037 /****************************************************************************/
3039 /* Routine Name: ips_removeq_scb */
3041 /* Routine Description: */
3043 /* Remove an item from a queue */
3045 /* ASSUMED to be called from within the HA lock */
3047 /****************************************************************************/
3048 static inline ips_scb_t *
3049 ips_removeq_scb(ips_scb_queue_t * queue, ips_scb_t * item)
3053 METHOD_TRACE("ips_removeq_scb", 1);
3058 if (item == queue->head) {
3059 return (ips_removeq_scb_head(queue));
3064 while ((p) && (item != p->q_next))
3069 p->q_next = item->q_next;
3074 item->q_next = NULL;
3083 /****************************************************************************/
3085 /* Routine Name: ips_putq_wait_head */
3087 /* Routine Description: */
3089 /* Add an item to the head of the queue */
3091 /* ASSUMED to be called from within the HA lock */
3093 /****************************************************************************/
3095 ips_putq_wait_head(ips_wait_queue_t * queue, Scsi_Cmnd * item)
3097 METHOD_TRACE("ips_putq_wait_head", 1);
3102 item->host_scribble = (char *) queue->head;
3111 /****************************************************************************/
3113 /* Routine Name: ips_putq_wait_tail */
3115 /* Routine Description: */
3117 /* Add an item to the tail of the queue */
3119 /* ASSUMED to be called from within the HA lock */
3121 /****************************************************************************/
3123 ips_putq_wait_tail(ips_wait_queue_t * queue, Scsi_Cmnd * item)
3125 METHOD_TRACE("ips_putq_wait_tail", 1);
3130 item->host_scribble = NULL;
3133 queue->tail->host_scribble = (char *) item;
3143 /****************************************************************************/
3145 /* Routine Name: ips_removeq_wait_head */
3147 /* Routine Description: */
3149 /* Remove the head of the queue */
3151 /* ASSUMED to be called from within the HA lock */
3153 /****************************************************************************/
3154 static inline Scsi_Cmnd *
3155 ips_removeq_wait_head(ips_wait_queue_t * queue)
3159 METHOD_TRACE("ips_removeq_wait_head", 1);
3167 queue->head = (Scsi_Cmnd *) item->host_scribble;
3168 item->host_scribble = NULL;
3170 if (queue->tail == item)
3178 /****************************************************************************/
3180 /* Routine Name: ips_removeq_wait */
3182 /* Routine Description: */
3184 /* Remove an item from a queue */
3186 /* ASSUMED to be called from within the HA lock */
3188 /****************************************************************************/
3189 static inline Scsi_Cmnd *
3190 ips_removeq_wait(ips_wait_queue_t * queue, Scsi_Cmnd * item)
3194 METHOD_TRACE("ips_removeq_wait", 1);
3199 if (item == queue->head) {
3200 return (ips_removeq_wait_head(queue));
3205 while ((p) && (item != (Scsi_Cmnd *) p->host_scribble))
3206 p = (Scsi_Cmnd *) p->host_scribble;
3210 p->host_scribble = item->host_scribble;
3212 if (!item->host_scribble)
3215 item->host_scribble = NULL;
3224 /****************************************************************************/
3226 /* Routine Name: ips_putq_copp_head */
3228 /* Routine Description: */
3230 /* Add an item to the head of the queue */
3232 /* ASSUMED to be called from within the HA lock */
3234 /****************************************************************************/
3236 ips_putq_copp_head(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3238 METHOD_TRACE("ips_putq_copp_head", 1);
3243 item->next = queue->head;
3252 /****************************************************************************/
3254 /* Routine Name: ips_putq_copp_tail */
3256 /* Routine Description: */
3258 /* Add an item to the tail of the queue */
3260 /* ASSUMED to be called from within the HA lock */
3262 /****************************************************************************/
3264 ips_putq_copp_tail(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3266 METHOD_TRACE("ips_putq_copp_tail", 1);
3274 queue->tail->next = item;
3284 /****************************************************************************/
3286 /* Routine Name: ips_removeq_copp_head */
3288 /* Routine Description: */
3290 /* Remove the head of the queue */
3292 /* ASSUMED to be called from within the HA lock */
3294 /****************************************************************************/
3295 static inline ips_copp_wait_item_t *
3296 ips_removeq_copp_head(ips_copp_queue_t * queue)
3298 ips_copp_wait_item_t *item;
3300 METHOD_TRACE("ips_removeq_copp_head", 1);
3308 queue->head = item->next;
3311 if (queue->tail == item)
3319 /****************************************************************************/
3321 /* Routine Name: ips_removeq_copp */
3323 /* Routine Description: */
3325 /* Remove an item from a queue */
3327 /* ASSUMED to be called from within the HA lock */
3329 /****************************************************************************/
3330 static inline ips_copp_wait_item_t *
3331 ips_removeq_copp(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3333 ips_copp_wait_item_t *p;
3335 METHOD_TRACE("ips_removeq_copp", 1);
3340 if (item == queue->head) {
3341 return (ips_removeq_copp_head(queue));
3346 while ((p) && (item != p->next))
3351 p->next = item->next;
3365 /****************************************************************************/
3367 /* Routine Name: ipsintr_blocking */
3369 /* Routine Description: */
3371 /* Finalize an interrupt for internal commands */
3373 /****************************************************************************/
3375 ipsintr_blocking(ips_ha_t * ha, ips_scb_t * scb)
3377 METHOD_TRACE("ipsintr_blocking", 2);
3379 ips_freescb(ha, scb);
3380 if ((ha->waitflag == TRUE) && (ha->cmd_in_progress == scb->cdb[0])) {
3381 ha->waitflag = FALSE;
3387 /****************************************************************************/
3389 /* Routine Name: ipsintr_done */
3391 /* Routine Description: */
3393 /* Finalize an interrupt for non-internal commands */
3395 /****************************************************************************/
3397 ipsintr_done(ips_ha_t * ha, ips_scb_t * scb)
3399 METHOD_TRACE("ipsintr_done", 2);
3402 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3403 "Spurious interrupt; scb NULL.\n");
3408 if (scb->scsi_cmd == NULL) {
3409 /* unexpected interrupt */
3410 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3411 "Spurious interrupt; scsi_cmd not set.\n");
3419 /****************************************************************************/
3421 /* Routine Name: ips_done */
3423 /* Routine Description: */
3425 /* Do housekeeping on completed commands */
3426 /* ASSUMED to be called form within the request lock */
3427 /****************************************************************************/
3429 ips_done(ips_ha_t * ha, ips_scb_t * scb)
3433 METHOD_TRACE("ips_done", 1);
3438 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd))) {
3439 ips_cleanup_passthru(ha, scb);
3443 * Check to see if this command had too much
3444 * data and had to be broke up. If so, queue
3445 * the rest of the data and continue.
3447 if ((scb->breakup) || (scb->sg_break)) {
3448 /* we had a data breakup */
3451 if (scb->sg_count) {
3453 struct scatterlist *sg;
3454 int ips_sg_index = 0;
3457 sg = scb->scsi_cmd->request_buffer;
3459 /* Spin forward to last dma chunk */
3460 sg_dma_index = scb->breakup;
3462 /* Take care of possible partial on last chunk */
3463 ips_fill_scb_sg_single(ha,
3466 scb, ips_sg_index++,
3470 for (; sg_dma_index < scb->sg_count;
3472 if (ips_fill_scb_sg_single
3474 sg_dma_address(&sg[sg_dma_index]),
3475 scb, ips_sg_index++,
3476 sg_dma_len(&sg[sg_dma_index])) < 0)
3482 /* Non S/G Request */
3483 (void) ips_fill_scb_sg_single(ha,
3495 scb->dcdb.transfer_length = scb->data_len;
3496 scb->dcdb.cmd_attribute |=
3497 ips_command_direction[scb->scsi_cmd->cmnd[0]];
3499 if (!(scb->dcdb.cmd_attribute & 0x3))
3500 scb->dcdb.transfer_length = 0;
3502 if (scb->data_len >= IPS_MAX_XFER) {
3503 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
3504 scb->dcdb.transfer_length = 0;
3507 ret = ips_send_cmd(ha, scb);
3511 if (scb->scsi_cmd) {
3512 scb->scsi_cmd->result = DID_ERROR << 16;
3513 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3516 ips_freescb(ha, scb);
3518 case IPS_SUCCESS_IMM:
3519 if (scb->scsi_cmd) {
3520 scb->scsi_cmd->result = DID_ERROR << 16;
3521 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3524 ips_freescb(ha, scb);
3532 } /* end if passthru */
3535 ha->dcdb_active[scb->bus - 1] &= ~(1 << scb->target_id);
3538 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3540 ips_freescb(ha, scb);
3543 /****************************************************************************/
3545 /* Routine Name: ips_map_status */
3547 /* Routine Description: */
3549 /* Map Controller Error codes to Linux Error Codes */
3551 /****************************************************************************/
3553 ips_map_status(ips_ha_t * ha, ips_scb_t * scb, ips_stat_t * sp)
3557 uint32_t transfer_len;
3558 IPS_DCDB_TABLE_TAPE *tapeDCDB;
3560 METHOD_TRACE("ips_map_status", 1);
3564 "(%s%d) Physical device error (%d %d %d): %x %x, Sense Key: %x, ASC: %x, ASCQ: %x",
3565 ips_name, ha->host_num,
3566 scb->scsi_cmd->device->channel,
3567 scb->scsi_cmd->device->id, scb->scsi_cmd->device->lun,
3568 scb->basic_status, scb->extended_status,
3569 scb->extended_status ==
3570 IPS_ERR_CKCOND ? scb->dcdb.sense_info[2] & 0xf : 0,
3571 scb->extended_status ==
3572 IPS_ERR_CKCOND ? scb->dcdb.sense_info[12] : 0,
3573 scb->extended_status ==
3574 IPS_ERR_CKCOND ? scb->dcdb.sense_info[13] : 0);
3577 /* default driver error */
3578 errcode = DID_ERROR;
3581 switch (scb->basic_status & IPS_GSC_STATUS_MASK) {
3582 case IPS_CMD_TIMEOUT:
3583 errcode = DID_TIME_OUT;
3586 case IPS_INVAL_OPCO:
3587 case IPS_INVAL_CMD_BLK:
3588 case IPS_INVAL_PARM_BLK:
3590 case IPS_CMD_CMPLT_WERROR:
3593 case IPS_PHYS_DRV_ERROR:
3594 switch (scb->extended_status) {
3595 case IPS_ERR_SEL_TO:
3597 errcode = DID_NO_CONNECT;
3601 case IPS_ERR_OU_RUN:
3602 if ((scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB) ||
3603 (scb->cmd.dcdb.op_code ==
3604 IPS_CMD_EXTENDED_DCDB_SG)) {
3605 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3606 transfer_len = tapeDCDB->transfer_length;
3609 (uint32_t) scb->dcdb.transfer_length;
3612 if ((scb->bus) && (transfer_len < scb->data_len)) {
3613 /* Underrun - set default to no error */
3616 /* Restrict access to physical DASD */
3617 if ((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
3618 ((((char *) scb->scsi_cmd->
3619 buffer)[0] & 0x1f) == TYPE_DISK)) {
3620 /* underflow -- no error */
3621 /* restrict access to physical DASD */
3622 errcode = DID_TIME_OUT;
3626 errcode = DID_ERROR;
3630 case IPS_ERR_RECOVERY:
3631 /* don't fail recovered errors */
3637 case IPS_ERR_HOST_RESET:
3638 case IPS_ERR_DEV_RESET:
3639 errcode = DID_RESET;
3642 case IPS_ERR_CKCOND:
3644 if ((scb->cmd.dcdb.op_code ==
3645 IPS_CMD_EXTENDED_DCDB)
3646 || (scb->cmd.dcdb.op_code ==
3647 IPS_CMD_EXTENDED_DCDB_SG)) {
3649 (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3650 memcpy(scb->scsi_cmd->sense_buffer,
3651 tapeDCDB->sense_info,
3652 sizeof (scb->scsi_cmd->
3655 memcpy(scb->scsi_cmd->sense_buffer,
3656 scb->dcdb.sense_info,
3657 sizeof (scb->scsi_cmd->
3660 device_error = 2; /* check condition */
3668 errcode = DID_ERROR;
3674 scb->scsi_cmd->result = device_error | (errcode << 16);
3679 /****************************************************************************/
3681 /* Routine Name: ips_send_wait */
3683 /* Routine Description: */
3685 /* Send a command to the controller and wait for it to return */
3687 /* The FFDC Time Stamp use this function for the callback, but doesn't */
3688 /* actually need to wait. */
3689 /****************************************************************************/
3691 ips_send_wait(ips_ha_t * ha, ips_scb_t * scb, int timeout, int intr)
3695 METHOD_TRACE("ips_send_wait", 1);
3697 if (intr != IPS_FFDC) { /* Won't be Waiting if this is a Time Stamp */
3698 ha->waitflag = TRUE;
3699 ha->cmd_in_progress = scb->cdb[0];
3701 scb->callback = ipsintr_blocking;
3702 ret = ips_send_cmd(ha, scb);
3704 if ((ret == IPS_FAILURE) || (ret == IPS_SUCCESS_IMM))
3707 if (intr != IPS_FFDC) /* Don't Wait around if this is a Time Stamp */
3708 ret = ips_wait(ha, timeout, intr);
3713 /****************************************************************************/
3715 /* Routine Name: ips_scmd_buf_write */
3717 /* Routine Description: */
3718 /* Write data to Scsi_Cmnd request_buffer at proper offsets */
3719 /****************************************************************************/
3721 ips_scmd_buf_write(Scsi_Cmnd * scmd, void *data, unsigned
3726 unsigned int min_cnt, xfer_cnt;
3727 char *cdata = (char *) data;
3728 struct scatterlist *sg = scmd->request_buffer;
3729 for (i = 0, xfer_cnt = 0;
3730 (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3731 if (!IPS_SG_ADDRESS(&sg[i]))
3733 min_cnt = min(count - xfer_cnt, sg[i].length);
3734 memcpy(IPS_SG_ADDRESS(&sg[i]), &cdata[xfer_cnt],
3736 xfer_cnt += min_cnt;
3740 unsigned int min_cnt = min(count, scmd->request_bufflen);
3741 memcpy(scmd->request_buffer, data, min_cnt);
3745 /****************************************************************************/
3747 /* Routine Name: ips_scmd_buf_read */
3749 /* Routine Description: */
3750 /* Copy data from a Scsi_Cmnd to a new, linear buffer */
3751 /****************************************************************************/
3753 ips_scmd_buf_read(Scsi_Cmnd * scmd, void *data, unsigned
3758 unsigned int min_cnt, xfer_cnt;
3759 char *cdata = (char *) data;
3760 struct scatterlist *sg = scmd->request_buffer;
3761 for (i = 0, xfer_cnt = 0;
3762 (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3763 if (!IPS_SG_ADDRESS(&sg[i]))
3765 min_cnt = min(count - xfer_cnt, sg[i].length);
3766 memcpy(&cdata[xfer_cnt], IPS_SG_ADDRESS(&sg[i]),
3768 xfer_cnt += min_cnt;
3772 unsigned int min_cnt = min(count, scmd->request_bufflen);
3773 memcpy(data, scmd->request_buffer, min_cnt);
3777 /****************************************************************************/
3779 /* Routine Name: ips_send_cmd */
3781 /* Routine Description: */
3783 /* Map SCSI commands to ServeRAID commands for logical drives */
3785 /****************************************************************************/
3787 ips_send_cmd(ips_ha_t * ha, ips_scb_t * scb)
3792 IPS_DCDB_TABLE_TAPE *tapeDCDB;
3795 METHOD_TRACE("ips_send_cmd", 1);
3799 if (!scb->scsi_cmd) {
3800 /* internal command */
3803 /* Controller commands can't be issued */
3804 /* to real devices -- fail them */
3805 if ((ha->waitflag == TRUE) &&
3806 (ha->cmd_in_progress == scb->cdb[0])) {
3807 ha->waitflag = FALSE;
3812 } else if ((scb->bus == 0) && (!ips_is_passthru(scb->scsi_cmd))) {
3813 /* command to logical bus -- interpret */
3814 ret = IPS_SUCCESS_IMM;
3816 switch (scb->scsi_cmd->cmnd[0]) {
3817 case ALLOW_MEDIUM_REMOVAL:
3820 case WRITE_FILEMARKS:
3822 scb->scsi_cmd->result = DID_ERROR << 16;
3826 scb->scsi_cmd->result = DID_OK << 16;
3828 case TEST_UNIT_READY:
3830 if (scb->target_id == IPS_ADAPTER_ID) {
3832 * Either we have a TUR
3833 * or we have a SCSI inquiry
3835 if (scb->scsi_cmd->cmnd[0] == TEST_UNIT_READY)
3836 scb->scsi_cmd->result = DID_OK << 16;
3838 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3839 IPS_SCSI_INQ_DATA inquiry;
3842 sizeof (IPS_SCSI_INQ_DATA));
3844 inquiry.DeviceType =
3845 IPS_SCSI_INQ_TYPE_PROCESSOR;
3846 inquiry.DeviceTypeQualifier =
3847 IPS_SCSI_INQ_LU_CONNECTED;
3848 inquiry.Version = IPS_SCSI_INQ_REV2;
3849 inquiry.ResponseDataFormat =
3850 IPS_SCSI_INQ_RD_REV2;
3851 inquiry.AdditionalLength = 31;
3853 IPS_SCSI_INQ_Address16;
3855 IPS_SCSI_INQ_WBus16 |
3857 strncpy(inquiry.VendorId, "IBM ",
3859 strncpy(inquiry.ProductId,
3861 strncpy(inquiry.ProductRevisionLevel,
3864 ips_scmd_buf_write(scb->scsi_cmd,
3868 scb->scsi_cmd->result = DID_OK << 16;
3871 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3872 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3873 scb->cmd.logical_info.reserved = 0;
3874 scb->cmd.logical_info.reserved2 = 0;
3875 scb->data_len = sizeof (IPS_LD_INFO);
3876 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3878 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3885 ips_reqsen(ha, scb);
3886 scb->scsi_cmd->result = DID_OK << 16;
3892 scb->cmd.basic_io.op_code =
3893 (scb->scsi_cmd->cmnd[0] ==
3894 READ_6) ? IPS_CMD_READ : IPS_CMD_WRITE;
3895 scb->cmd.basic_io.enhanced_sg = 0;
3896 scb->cmd.basic_io.sg_addr =
3897 cpu_to_le32(scb->data_busaddr);
3899 scb->cmd.basic_io.op_code =
3900 (scb->scsi_cmd->cmnd[0] ==
3901 READ_6) ? IPS_CMD_READ_SG :
3903 scb->cmd.basic_io.enhanced_sg =
3904 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3905 scb->cmd.basic_io.sg_addr =
3906 cpu_to_le32(scb->sg_busaddr);
3909 scb->cmd.basic_io.segment_4G = 0;
3910 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3911 scb->cmd.basic_io.log_drv = scb->target_id;
3912 scb->cmd.basic_io.sg_count = scb->sg_len;
3914 if (scb->cmd.basic_io.lba)
3915 scb->cmd.basic_io.lba =
3916 cpu_to_le32(le32_to_cpu
3917 (scb->cmd.basic_io.lba) +
3918 le16_to_cpu(scb->cmd.basic_io.
3921 scb->cmd.basic_io.lba =
3923 cmnd[1] & 0x1f) << 16) | (scb->scsi_cmd->
3925 (scb->scsi_cmd->cmnd[3]));
3927 scb->cmd.basic_io.sector_count =
3928 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3930 if (le16_to_cpu(scb->cmd.basic_io.sector_count) == 0)
3931 scb->cmd.basic_io.sector_count =
3940 scb->cmd.basic_io.op_code =
3941 (scb->scsi_cmd->cmnd[0] ==
3942 READ_10) ? IPS_CMD_READ : IPS_CMD_WRITE;
3943 scb->cmd.basic_io.enhanced_sg = 0;
3944 scb->cmd.basic_io.sg_addr =
3945 cpu_to_le32(scb->data_busaddr);
3947 scb->cmd.basic_io.op_code =
3948 (scb->scsi_cmd->cmnd[0] ==
3949 READ_10) ? IPS_CMD_READ_SG :
3951 scb->cmd.basic_io.enhanced_sg =
3952 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3953 scb->cmd.basic_io.sg_addr =
3954 cpu_to_le32(scb->sg_busaddr);
3957 scb->cmd.basic_io.segment_4G = 0;
3958 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3959 scb->cmd.basic_io.log_drv = scb->target_id;
3960 scb->cmd.basic_io.sg_count = scb->sg_len;
3962 if (scb->cmd.basic_io.lba)
3963 scb->cmd.basic_io.lba =
3964 cpu_to_le32(le32_to_cpu
3965 (scb->cmd.basic_io.lba) +
3966 le16_to_cpu(scb->cmd.basic_io.
3969 scb->cmd.basic_io.lba =
3970 ((scb->scsi_cmd->cmnd[2] << 24) | (scb->
3974 (scb->scsi_cmd->cmnd[4] << 8) | scb->
3977 scb->cmd.basic_io.sector_count =
3978 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3980 if (cpu_to_le16(scb->cmd.basic_io.sector_count) == 0) {
3982 * This is a null condition
3983 * we don't have to do anything
3986 scb->scsi_cmd->result = DID_OK << 16;
3994 scb->scsi_cmd->result = DID_OK << 16;
3998 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
3999 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
4000 scb->cmd.basic_io.segment_4G = 0;
4001 scb->cmd.basic_io.enhanced_sg = 0;
4002 scb->data_len = sizeof (*ha->enq);
4003 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
4008 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
4009 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
4010 scb->cmd.logical_info.reserved = 0;
4011 scb->cmd.logical_info.reserved2 = 0;
4012 scb->cmd.logical_info.reserved3 = 0;
4013 scb->data_len = sizeof (IPS_LD_INFO);
4014 scb->data_busaddr = ha->logical_drive_info_dma_addr;
4016 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
4020 case SEND_DIAGNOSTIC:
4021 case REASSIGN_BLOCKS:
4025 case READ_DEFECT_DATA:
4028 scb->scsi_cmd->result = DID_OK << 16;
4032 /* Set the Return Info to appear like the Command was */
4033 /* attempted, a Check Condition occurred, and Sense */
4034 /* Data indicating an Invalid CDB OpCode is returned. */
4035 sp = (char *) scb->scsi_cmd->sense_buffer;
4036 memset(sp, 0, sizeof (scb->scsi_cmd->sense_buffer));
4038 sp[0] = 0x70; /* Error Code */
4039 sp[2] = ILLEGAL_REQUEST; /* Sense Key 5 Illegal Req. */
4040 sp[7] = 0x0A; /* Additional Sense Length */
4041 sp[12] = 0x20; /* ASC = Invalid OpCode */
4042 sp[13] = 0x00; /* ASCQ */
4044 device_error = 2; /* Indicate Check Condition */
4045 scb->scsi_cmd->result = device_error | (DID_OK << 16);
4050 if (ret == IPS_SUCCESS_IMM)
4056 /* If we already know the Device is Not there, no need to attempt a Command */
4057 /* This also protects an NT FailOver Controller from getting CDB's sent to it */
4058 if (ha->conf->dev[scb->bus - 1][scb->target_id].ucState == 0) {
4059 scb->scsi_cmd->result = DID_NO_CONNECT << 16;
4060 return (IPS_SUCCESS_IMM);
4063 ha->dcdb_active[scb->bus - 1] |= (1 << scb->target_id);
4064 scb->cmd.dcdb.command_id = IPS_COMMAND_ID(ha, scb);
4065 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
4066 (unsigned long) &scb->
4068 (unsigned long) scb);
4069 scb->cmd.dcdb.reserved = 0;
4070 scb->cmd.dcdb.reserved2 = 0;
4071 scb->cmd.dcdb.reserved3 = 0;
4072 scb->cmd.dcdb.segment_4G = 0;
4073 scb->cmd.dcdb.enhanced_sg = 0;
4075 TimeOut = scb->scsi_cmd->timeout_per_command;
4077 if (ha->subsys->param[4] & 0x00100000) { /* If NEW Tape DCDB is Supported */
4079 scb->cmd.dcdb.op_code = IPS_CMD_EXTENDED_DCDB;
4081 scb->cmd.dcdb.op_code =
4082 IPS_CMD_EXTENDED_DCDB_SG;
4083 scb->cmd.dcdb.enhanced_sg =
4084 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
4087 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb; /* Use Same Data Area as Old DCDB Struct */
4088 tapeDCDB->device_address =
4089 ((scb->bus - 1) << 4) | scb->target_id;
4090 tapeDCDB->cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4091 tapeDCDB->cmd_attribute &= ~IPS_TRANSFER64K; /* Always Turn OFF 64K Size Flag */
4094 if (TimeOut < (10 * HZ))
4095 tapeDCDB->cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
4096 else if (TimeOut < (60 * HZ))
4097 tapeDCDB->cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
4098 else if (TimeOut < (1200 * HZ))
4099 tapeDCDB->cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
4102 tapeDCDB->cdb_length = scb->scsi_cmd->cmd_len;
4103 tapeDCDB->reserved_for_LUN = 0;
4104 tapeDCDB->transfer_length = scb->data_len;
4105 if (scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB_SG)
4106 tapeDCDB->buffer_pointer =
4107 cpu_to_le32(scb->sg_busaddr);
4109 tapeDCDB->buffer_pointer =
4110 cpu_to_le32(scb->data_busaddr);
4111 tapeDCDB->sg_count = scb->sg_len;
4112 tapeDCDB->sense_length = sizeof (tapeDCDB->sense_info);
4113 tapeDCDB->scsi_status = 0;
4114 tapeDCDB->reserved = 0;
4115 memcpy(tapeDCDB->scsi_cdb, scb->scsi_cmd->cmnd,
4116 scb->scsi_cmd->cmd_len);
4119 scb->cmd.dcdb.op_code = IPS_CMD_DCDB;
4121 scb->cmd.dcdb.op_code = IPS_CMD_DCDB_SG;
4122 scb->cmd.dcdb.enhanced_sg =
4123 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
4126 scb->dcdb.device_address =
4127 ((scb->bus - 1) << 4) | scb->target_id;
4128 scb->dcdb.cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4131 if (TimeOut < (10 * HZ))
4132 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
4133 else if (TimeOut < (60 * HZ))
4134 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
4135 else if (TimeOut < (1200 * HZ))
4136 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
4139 scb->dcdb.transfer_length = scb->data_len;
4140 if (scb->dcdb.cmd_attribute & IPS_TRANSFER64K)
4141 scb->dcdb.transfer_length = 0;
4142 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB_SG)
4143 scb->dcdb.buffer_pointer =
4144 cpu_to_le32(scb->sg_busaddr);
4146 scb->dcdb.buffer_pointer =
4147 cpu_to_le32(scb->data_busaddr);
4148 scb->dcdb.cdb_length = scb->scsi_cmd->cmd_len;
4149 scb->dcdb.sense_length = sizeof (scb->dcdb.sense_info);
4150 scb->dcdb.sg_count = scb->sg_len;
4151 scb->dcdb.reserved = 0;
4152 memcpy(scb->dcdb.scsi_cdb, scb->scsi_cmd->cmnd,
4153 scb->scsi_cmd->cmd_len);
4154 scb->dcdb.scsi_status = 0;
4155 scb->dcdb.reserved2[0] = 0;
4156 scb->dcdb.reserved2[1] = 0;
4157 scb->dcdb.reserved2[2] = 0;
4161 return ((*ha->func.issue) (ha, scb));
4164 /****************************************************************************/
4166 /* Routine Name: ips_chk_status */
4168 /* Routine Description: */
4170 /* Check the status of commands to logical drives */
4171 /* Assumed to be called with the HA lock */
4172 /****************************************************************************/
4174 ips_chkstatus(ips_ha_t * ha, IPS_STATUS * pstatus)
4178 uint8_t basic_status;
4182 METHOD_TRACE("ips_chkstatus", 1);
4184 scb = &ha->scbs[pstatus->fields.command_id];
4185 scb->basic_status = basic_status =
4186 pstatus->fields.basic_status & IPS_BASIC_STATUS_MASK;
4187 scb->extended_status = ext_status = pstatus->fields.extended_status;
4190 sp->residue_len = 0;
4191 sp->scb_addr = (void *) scb;
4193 /* Remove the item from the active queue */
4194 ips_removeq_scb(&ha->scb_activelist, scb);
4197 /* internal commands are handled in do_ipsintr */
4200 DEBUG_VAR(2, "(%s%d) ips_chkstatus: cmd 0x%X id %d (%d %d %d)",
4204 scb->cmd.basic_io.command_id,
4205 scb->bus, scb->target_id, scb->lun);
4207 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd)))
4208 /* passthru - just returns the raw result */
4213 if (((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_SUCCESS) ||
4214 ((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_RECOVERED_ERROR)) {
4216 if (scb->bus == 0) {
4217 if ((basic_status & IPS_GSC_STATUS_MASK) ==
4218 IPS_CMD_RECOVERED_ERROR) {
4220 "(%s%d) Recovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4221 ips_name, ha->host_num,
4222 scb->cmd.basic_io.op_code,
4223 basic_status, ext_status);
4226 switch (scb->scsi_cmd->cmnd[0]) {
4227 case ALLOW_MEDIUM_REMOVAL:
4230 case WRITE_FILEMARKS:
4232 errcode = DID_ERROR;
4238 case TEST_UNIT_READY:
4239 if (!ips_online(ha, scb)) {
4240 errcode = DID_TIME_OUT;
4245 if (ips_online(ha, scb)) {
4246 ips_inquiry(ha, scb);
4248 errcode = DID_TIME_OUT;
4253 ips_reqsen(ha, scb);
4265 if (!ips_online(ha, scb)
4266 || !ips_msense(ha, scb)) {
4267 errcode = DID_ERROR;
4272 if (ips_online(ha, scb))
4275 errcode = DID_TIME_OUT;
4279 case SEND_DIAGNOSTIC:
4280 case REASSIGN_BLOCKS:
4284 errcode = DID_ERROR;
4289 case READ_DEFECT_DATA:
4295 errcode = DID_ERROR;
4298 scb->scsi_cmd->result = errcode << 16;
4299 } else { /* bus == 0 */
4300 /* restrict access to physical drives */
4301 if ((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
4302 ((((char *) scb->scsi_cmd->buffer)[0] & 0x1f) ==
4305 scb->scsi_cmd->result = DID_TIME_OUT << 16;
4308 } else { /* recovered error / success */
4309 if (scb->bus == 0) {
4311 "(%s%d) Unrecovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4312 ips_name, ha->host_num,
4313 scb->cmd.basic_io.op_code, basic_status,
4317 ips_map_status(ha, scb, sp);
4321 /****************************************************************************/
4323 /* Routine Name: ips_online */
4325 /* Routine Description: */
4327 /* Determine if a logical drive is online */
4329 /****************************************************************************/
4331 ips_online(ips_ha_t * ha, ips_scb_t * scb)
4333 METHOD_TRACE("ips_online", 1);
4335 if (scb->target_id >= IPS_MAX_LD)
4338 if ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1) {
4339 memset(ha->logical_drive_info, 0, sizeof (IPS_LD_INFO));
4343 if (ha->logical_drive_info->drive_info[scb->target_id].state !=
4345 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4347 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4349 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4356 /****************************************************************************/
4358 /* Routine Name: ips_inquiry */
4360 /* Routine Description: */
4362 /* Simulate an inquiry command to a logical drive */
4364 /****************************************************************************/
4366 ips_inquiry(ips_ha_t * ha, ips_scb_t * scb)
4368 IPS_SCSI_INQ_DATA inquiry;
4370 METHOD_TRACE("ips_inquiry", 1);
4372 memset(&inquiry, 0, sizeof (IPS_SCSI_INQ_DATA));
4374 inquiry.DeviceType = IPS_SCSI_INQ_TYPE_DASD;
4375 inquiry.DeviceTypeQualifier = IPS_SCSI_INQ_LU_CONNECTED;
4376 inquiry.Version = IPS_SCSI_INQ_REV2;
4377 inquiry.ResponseDataFormat = IPS_SCSI_INQ_RD_REV2;
4378 inquiry.AdditionalLength = 31;
4379 inquiry.Flags[0] = IPS_SCSI_INQ_Address16;
4381 IPS_SCSI_INQ_WBus16 | IPS_SCSI_INQ_Sync | IPS_SCSI_INQ_CmdQue;
4382 strncpy(inquiry.VendorId, "IBM ", 8);
4383 strncpy(inquiry.ProductId, "SERVERAID ", 16);
4384 strncpy(inquiry.ProductRevisionLevel, "1.00", 4);
4386 ips_scmd_buf_write(scb->scsi_cmd, &inquiry, sizeof (inquiry));
4391 /****************************************************************************/
4393 /* Routine Name: ips_rdcap */
4395 /* Routine Description: */
4397 /* Simulate a read capacity command to a logical drive */
4399 /****************************************************************************/
4401 ips_rdcap(ips_ha_t * ha, ips_scb_t * scb)
4403 IPS_SCSI_CAPACITY cap;
4405 METHOD_TRACE("ips_rdcap", 1);
4407 if (scb->scsi_cmd->bufflen < 8)
4411 cpu_to_be32(le32_to_cpu
4412 (ha->logical_drive_info->
4413 drive_info[scb->target_id].sector_count) - 1);
4414 cap.len = cpu_to_be32((uint32_t) IPS_BLKSIZE);
4416 ips_scmd_buf_write(scb->scsi_cmd, &cap, sizeof (cap));
4421 /****************************************************************************/
4423 /* Routine Name: ips_msense */
4425 /* Routine Description: */
4427 /* Simulate a mode sense command to a logical drive */
4429 /****************************************************************************/
4431 ips_msense(ips_ha_t * ha, ips_scb_t * scb)
4436 IPS_SCSI_MODE_PAGE_DATA mdata;
4438 METHOD_TRACE("ips_msense", 1);
4440 if (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) > 0x400000 &&
4441 (ha->enq->ucMiscFlag & 0x8) == 0) {
4442 heads = IPS_NORM_HEADS;
4443 sectors = IPS_NORM_SECTORS;
4445 heads = IPS_COMP_HEADS;
4446 sectors = IPS_COMP_SECTORS;
4450 (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) -
4451 1) / (heads * sectors);
4453 memset(&mdata, 0, sizeof (IPS_SCSI_MODE_PAGE_DATA));
4455 mdata.hdr.BlockDescLength = 8;
4457 switch (scb->scsi_cmd->cmnd[2] & 0x3f) {
4458 case 0x03: /* page 3 */
4459 mdata.pdata.pg3.PageCode = 3;
4460 mdata.pdata.pg3.PageLength = sizeof (IPS_SCSI_MODE_PAGE3);
4461 mdata.hdr.DataLength =
4462 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg3.PageLength;
4463 mdata.pdata.pg3.TracksPerZone = 0;
4464 mdata.pdata.pg3.AltSectorsPerZone = 0;
4465 mdata.pdata.pg3.AltTracksPerZone = 0;
4466 mdata.pdata.pg3.AltTracksPerVolume = 0;
4467 mdata.pdata.pg3.SectorsPerTrack = cpu_to_be16(sectors);
4468 mdata.pdata.pg3.BytesPerSector = cpu_to_be16(IPS_BLKSIZE);
4469 mdata.pdata.pg3.Interleave = cpu_to_be16(1);
4470 mdata.pdata.pg3.TrackSkew = 0;
4471 mdata.pdata.pg3.CylinderSkew = 0;
4472 mdata.pdata.pg3.flags = IPS_SCSI_MP3_SoftSector;
4476 mdata.pdata.pg4.PageCode = 4;
4477 mdata.pdata.pg4.PageLength = sizeof (IPS_SCSI_MODE_PAGE4);
4478 mdata.hdr.DataLength =
4479 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg4.PageLength;
4480 mdata.pdata.pg4.CylindersHigh =
4481 cpu_to_be16((cylinders >> 8) & 0xFFFF);
4482 mdata.pdata.pg4.CylindersLow = (cylinders & 0xFF);
4483 mdata.pdata.pg4.Heads = heads;
4484 mdata.pdata.pg4.WritePrecompHigh = 0;
4485 mdata.pdata.pg4.WritePrecompLow = 0;
4486 mdata.pdata.pg4.ReducedWriteCurrentHigh = 0;
4487 mdata.pdata.pg4.ReducedWriteCurrentLow = 0;
4488 mdata.pdata.pg4.StepRate = cpu_to_be16(1);
4489 mdata.pdata.pg4.LandingZoneHigh = 0;
4490 mdata.pdata.pg4.LandingZoneLow = 0;
4491 mdata.pdata.pg4.flags = 0;
4492 mdata.pdata.pg4.RotationalOffset = 0;
4493 mdata.pdata.pg4.MediumRotationRate = 0;
4496 mdata.pdata.pg8.PageCode = 8;
4497 mdata.pdata.pg8.PageLength = sizeof (IPS_SCSI_MODE_PAGE8);
4498 mdata.hdr.DataLength =
4499 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg8.PageLength;
4500 /* everything else is left set to 0 */
4507 ips_scmd_buf_write(scb->scsi_cmd, &mdata, sizeof (mdata));
4512 /****************************************************************************/
4514 /* Routine Name: ips_reqsen */
4516 /* Routine Description: */
4518 /* Simulate a request sense command to a logical drive */
4520 /****************************************************************************/
4522 ips_reqsen(ips_ha_t * ha, ips_scb_t * scb)
4524 IPS_SCSI_REQSEN reqsen;
4526 METHOD_TRACE("ips_reqsen", 1);
4528 memset(&reqsen, 0, sizeof (IPS_SCSI_REQSEN));
4530 reqsen.ResponseCode =
4531 IPS_SCSI_REQSEN_VALID | IPS_SCSI_REQSEN_CURRENT_ERR;
4532 reqsen.AdditionalLength = 10;
4533 reqsen.AdditionalSenseCode = IPS_SCSI_REQSEN_NO_SENSE;
4534 reqsen.AdditionalSenseCodeQual = IPS_SCSI_REQSEN_NO_SENSE;
4536 ips_scmd_buf_write(scb->scsi_cmd, &reqsen, sizeof (reqsen));
4541 /****************************************************************************/
4543 /* Routine Name: ips_free */
4545 /* Routine Description: */
4547 /* Free any allocated space for this controller */
4549 /****************************************************************************/
4551 ips_free(ips_ha_t * ha)
4554 METHOD_TRACE("ips_free", 1);
4558 pci_free_consistent(ha->pcidev, sizeof(IPS_ENQ),
4559 ha->enq, ha->enq_busaddr);
4569 pci_free_consistent(ha->pcidev,
4570 sizeof (IPS_ADAPTER) +
4571 sizeof (IPS_IO_CMD), ha->adapt,
4572 ha->adapt->hw_status_start);
4576 if (ha->logical_drive_info) {
4577 pci_free_consistent(ha->pcidev,
4578 sizeof (IPS_LD_INFO),
4579 ha->logical_drive_info,
4580 ha->logical_drive_info_dma_addr);
4581 ha->logical_drive_info = NULL;
4594 if (ha->ioctl_data) {
4595 pci_free_consistent(ha->pcidev, ha->ioctl_len,
4596 ha->ioctl_data, ha->ioctl_busaddr);
4597 ha->ioctl_data = NULL;
4598 ha->ioctl_datasize = 0;
4601 ips_deallocatescbs(ha, ha->max_cmds);
4603 /* free memory mapped (if applicable) */
4605 iounmap(ha->ioremap_ptr);
4606 ha->ioremap_ptr = NULL;
4611 release_mem_region(ha->mem_addr, ha->mem_len);
4617 /****************************************************************************/
4619 /* Routine Name: ips_deallocatescbs */
4621 /* Routine Description: */
4623 /* Free the command blocks */
4625 /****************************************************************************/
4627 ips_deallocatescbs(ips_ha_t * ha, int cmds)
4630 pci_free_consistent(ha->pcidev,
4631 IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * cmds,
4632 ha->scbs->sg_list.list,
4633 ha->scbs->sg_busaddr);
4634 pci_free_consistent(ha->pcidev, sizeof (ips_scb_t) * cmds,
4635 ha->scbs, ha->scbs->scb_busaddr);
4641 /****************************************************************************/
4643 /* Routine Name: ips_allocatescbs */
4645 /* Routine Description: */
4647 /* Allocate the command blocks */
4649 /****************************************************************************/
4651 ips_allocatescbs(ips_ha_t * ha)
4656 dma_addr_t command_dma, sg_dma;
4658 METHOD_TRACE("ips_allocatescbs", 1);
4660 /* Allocate memory for the SCBs */
4662 pci_alloc_consistent(ha->pcidev, ha->max_cmds * sizeof (ips_scb_t),
4664 if (ha->scbs == NULL)
4667 pci_alloc_consistent(ha->pcidev,
4668 IPS_SGLIST_SIZE(ha) * IPS_MAX_SG *
4669 ha->max_cmds, &sg_dma);
4670 if (ips_sg.list == NULL) {
4671 pci_free_consistent(ha->pcidev,
4672 ha->max_cmds * sizeof (ips_scb_t), ha->scbs,
4677 memset(ha->scbs, 0, ha->max_cmds * sizeof (ips_scb_t));
4679 for (i = 0; i < ha->max_cmds; i++) {
4680 scb_p = &ha->scbs[i];
4681 scb_p->scb_busaddr = command_dma + sizeof (ips_scb_t) * i;
4682 /* set up S/G list */
4683 if (IPS_USE_ENH_SGLIST(ha)) {
4684 scb_p->sg_list.enh_list =
4685 ips_sg.enh_list + i * IPS_MAX_SG;
4687 sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4689 scb_p->sg_list.std_list =
4690 ips_sg.std_list + i * IPS_MAX_SG;
4692 sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4695 /* add to the free list */
4696 if (i < ha->max_cmds - 1) {
4697 scb_p->q_next = ha->scb_freelist;
4698 ha->scb_freelist = scb_p;
4706 /****************************************************************************/
4708 /* Routine Name: ips_init_scb */
4710 /* Routine Description: */
4712 /* Initialize a CCB to default values */
4714 /****************************************************************************/
4716 ips_init_scb(ips_ha_t * ha, ips_scb_t * scb)
4718 IPS_SG_LIST sg_list;
4719 uint32_t cmd_busaddr, sg_busaddr;
4720 METHOD_TRACE("ips_init_scb", 1);
4725 sg_list.list = scb->sg_list.list;
4726 cmd_busaddr = scb->scb_busaddr;
4727 sg_busaddr = scb->sg_busaddr;
4729 memset(scb, 0, sizeof (ips_scb_t));
4730 memset(ha->dummy, 0, sizeof (IPS_IO_CMD));
4732 /* Initialize dummy command bucket */
4733 ha->dummy->op_code = 0xFF;
4734 ha->dummy->ccsar = cpu_to_le32(ha->adapt->hw_status_start
4735 + sizeof (IPS_ADAPTER));
4736 ha->dummy->command_id = IPS_MAX_CMDS;
4738 /* set bus address of scb */
4739 scb->scb_busaddr = cmd_busaddr;
4740 scb->sg_busaddr = sg_busaddr;
4741 scb->sg_list.list = sg_list.list;
4744 scb->cmd.basic_io.cccr = cpu_to_le32((uint32_t) IPS_BIT_ILE);
4745 scb->cmd.basic_io.ccsar = cpu_to_le32(ha->adapt->hw_status_start
4746 + sizeof (IPS_ADAPTER));
4749 /****************************************************************************/
4751 /* Routine Name: ips_get_scb */
4753 /* Routine Description: */
4755 /* Initialize a CCB to default values */
4757 /* ASSUMED to be callled from within a lock */
4759 /****************************************************************************/
4761 ips_getscb(ips_ha_t * ha)
4765 METHOD_TRACE("ips_getscb", 1);
4767 if ((scb = ha->scb_freelist) == NULL) {
4772 ha->scb_freelist = scb->q_next;
4776 ips_init_scb(ha, scb);
4781 /****************************************************************************/
4783 /* Routine Name: ips_free_scb */
4785 /* Routine Description: */
4787 /* Return an unused CCB back to the free list */
4789 /* ASSUMED to be called from within a lock */
4791 /****************************************************************************/
4793 ips_freescb(ips_ha_t * ha, ips_scb_t * scb)
4796 METHOD_TRACE("ips_freescb", 1);
4797 if (scb->flags & IPS_SCB_MAP_SG)
4798 pci_unmap_sg(ha->pcidev, scb->scsi_cmd->request_buffer,
4799 scb->scsi_cmd->use_sg, IPS_DMA_DIR(scb));
4800 else if (scb->flags & IPS_SCB_MAP_SINGLE)
4801 pci_unmap_single(ha->pcidev, scb->data_busaddr, scb->data_len,
4804 /* check to make sure this is not our "special" scb */
4805 if (IPS_COMMAND_ID(ha, scb) < (ha->max_cmds - 1)) {
4806 scb->q_next = ha->scb_freelist;
4807 ha->scb_freelist = scb;
4811 /****************************************************************************/
4813 /* Routine Name: ips_isinit_copperhead */
4815 /* Routine Description: */
4817 /* Is controller initialized ? */
4819 /****************************************************************************/
4821 ips_isinit_copperhead(ips_ha_t * ha)
4826 METHOD_TRACE("ips_isinit_copperhead", 1);
4828 isr = inb(ha->io_addr + IPS_REG_HISR);
4829 scpr = inb(ha->io_addr + IPS_REG_SCPR);
4831 if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4837 /****************************************************************************/
4839 /* Routine Name: ips_isinit_copperhead_memio */
4841 /* Routine Description: */
4843 /* Is controller initialized ? */
4845 /****************************************************************************/
4847 ips_isinit_copperhead_memio(ips_ha_t * ha)
4852 METHOD_TRACE("ips_is_init_copperhead_memio", 1);
4854 isr = readb(ha->mem_ptr + IPS_REG_HISR);
4855 scpr = readb(ha->mem_ptr + IPS_REG_SCPR);
4857 if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4863 /****************************************************************************/
4865 /* Routine Name: ips_isinit_morpheus */
4867 /* Routine Description: */
4869 /* Is controller initialized ? */
4871 /****************************************************************************/
4873 ips_isinit_morpheus(ips_ha_t * ha)
4878 METHOD_TRACE("ips_is_init_morpheus", 1);
4880 post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
4881 bits = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
4885 else if (bits & 0x3)
4891 /****************************************************************************/
4893 /* Routine Name: ips_enable_int_copperhead */
4895 /* Routine Description: */
4896 /* Turn on interrupts */
4898 /****************************************************************************/
4900 ips_enable_int_copperhead(ips_ha_t * ha)
4902 METHOD_TRACE("ips_enable_int_copperhead", 1);
4904 outb(ha->io_addr + IPS_REG_HISR, IPS_BIT_EI);
4905 inb(ha->io_addr + IPS_REG_HISR); /*Ensure PCI Posting Completes*/
4908 /****************************************************************************/
4910 /* Routine Name: ips_enable_int_copperhead_memio */
4912 /* Routine Description: */
4913 /* Turn on interrupts */
4915 /****************************************************************************/
4917 ips_enable_int_copperhead_memio(ips_ha_t * ha)
4919 METHOD_TRACE("ips_enable_int_copperhead_memio", 1);
4921 writeb(IPS_BIT_EI, ha->mem_ptr + IPS_REG_HISR);
4922 readb(ha->mem_ptr + IPS_REG_HISR); /*Ensure PCI Posting Completes*/
4925 /****************************************************************************/
4927 /* Routine Name: ips_enable_int_morpheus */
4929 /* Routine Description: */
4930 /* Turn on interrupts */
4932 /****************************************************************************/
4934 ips_enable_int_morpheus(ips_ha_t * ha)
4938 METHOD_TRACE("ips_enable_int_morpheus", 1);
4940 Oimr = readl(ha->mem_ptr + IPS_REG_I960_OIMR);
4942 writel(Oimr, ha->mem_ptr + IPS_REG_I960_OIMR);
4943 readl(ha->mem_ptr + IPS_REG_I960_OIMR); /*Ensure PCI Posting Completes*/
4946 /****************************************************************************/
4948 /* Routine Name: ips_init_copperhead */
4950 /* Routine Description: */
4952 /* Initialize a copperhead controller */
4954 /****************************************************************************/
4956 ips_init_copperhead(ips_ha_t * ha)
4960 uint8_t PostByte[IPS_MAX_POST_BYTES];
4961 uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
4964 METHOD_TRACE("ips_init_copperhead", 1);
4966 for (i = 0; i < IPS_MAX_POST_BYTES; i++) {
4967 for (j = 0; j < 45; j++) {
4968 Isr = inb(ha->io_addr + IPS_REG_HISR);
4969 if (Isr & IPS_BIT_GHI)
4972 /* Delay for 1 Second */
4973 MDELAY(IPS_ONE_SEC);
4977 /* error occurred */
4980 PostByte[i] = inb(ha->io_addr + IPS_REG_ISPR);
4981 outb(Isr, ha->io_addr + IPS_REG_HISR);
4984 if (PostByte[0] < IPS_GOOD_POST_STATUS) {
4985 IPS_PRINTK(KERN_WARNING, ha->pcidev,
4986 "reset controller fails (post status %x %x).\n",
4987 PostByte[0], PostByte[1]);
4992 for (i = 0; i < IPS_MAX_CONFIG_BYTES; i++) {
4993 for (j = 0; j < 240; j++) {
4994 Isr = inb(ha->io_addr + IPS_REG_HISR);
4995 if (Isr & IPS_BIT_GHI)
4998 /* Delay for 1 Second */
4999 MDELAY(IPS_ONE_SEC);
5003 /* error occurred */
5006 ConfigByte[i] = inb(ha->io_addr + IPS_REG_ISPR);
5007 outb(Isr, ha->io_addr + IPS_REG_HISR);
5010 for (i = 0; i < 240; i++) {
5011 Cbsp = inb(ha->io_addr + IPS_REG_CBSP);
5013 if ((Cbsp & IPS_BIT_OP) == 0)
5016 /* Delay for 1 Second */
5017 MDELAY(IPS_ONE_SEC);
5025 outl(cpu_to_le32(0x1010), ha->io_addr + IPS_REG_CCCR);
5027 /* Enable busmastering */
5028 outb(IPS_BIT_EBM, ha->io_addr + IPS_REG_SCPR);
5030 if (ha->revision_id == IPS_REVID_TROMBONE64)
5031 /* fix for anaconda64 */
5032 outl(0, ha->io_addr + IPS_REG_NDAE);
5034 /* Enable interrupts */
5035 outb(IPS_BIT_EI, ha->io_addr + IPS_REG_HISR);
5040 /****************************************************************************/
5042 /* Routine Name: ips_init_copperhead_memio */
5044 /* Routine Description: */
5046 /* Initialize a copperhead controller with memory mapped I/O */
5048 /****************************************************************************/
5050 ips_init_copperhead_memio(ips_ha_t * ha)
5054 uint8_t PostByte[IPS_MAX_POST_BYTES];
5055 uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
5058 METHOD_TRACE("ips_init_copperhead_memio", 1);
5060 for (i = 0; i < IPS_MAX_POST_BYTES; i++) {
5061 for (j = 0; j < 45; j++) {
5062 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5063 if (Isr & IPS_BIT_GHI)
5066 /* Delay for 1 Second */
5067 MDELAY(IPS_ONE_SEC);
5071 /* error occurred */
5074 PostByte[i] = readb(ha->mem_ptr + IPS_REG_ISPR);
5075 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5078 if (PostByte[0] < IPS_GOOD_POST_STATUS) {
5079 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5080 "reset controller fails (post status %x %x).\n",
5081 PostByte[0], PostByte[1]);
5086 for (i = 0; i < IPS_MAX_CONFIG_BYTES; i++) {
5087 for (j = 0; j < 240; j++) {
5088 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5089 if (Isr & IPS_BIT_GHI)
5092 /* Delay for 1 Second */
5093 MDELAY(IPS_ONE_SEC);
5097 /* error occurred */
5100 ConfigByte[i] = readb(ha->mem_ptr + IPS_REG_ISPR);
5101 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5104 for (i = 0; i < 240; i++) {
5105 Cbsp = readb(ha->mem_ptr + IPS_REG_CBSP);
5107 if ((Cbsp & IPS_BIT_OP) == 0)
5110 /* Delay for 1 Second */
5111 MDELAY(IPS_ONE_SEC);
5115 /* error occurred */
5119 writel(0x1010, ha->mem_ptr + IPS_REG_CCCR);
5121 /* Enable busmastering */
5122 writeb(IPS_BIT_EBM, ha->mem_ptr + IPS_REG_SCPR);
5124 if (ha->revision_id == IPS_REVID_TROMBONE64)
5125 /* fix for anaconda64 */
5126 writel(0, ha->mem_ptr + IPS_REG_NDAE);
5128 /* Enable interrupts */
5129 writeb(IPS_BIT_EI, ha->mem_ptr + IPS_REG_HISR);
5131 /* if we get here then everything went OK */
5135 /****************************************************************************/
5137 /* Routine Name: ips_init_morpheus */
5139 /* Routine Description: */
5141 /* Initialize a morpheus controller */
5143 /****************************************************************************/
5145 ips_init_morpheus(ips_ha_t * ha)
5153 METHOD_TRACE("ips_init_morpheus", 1);
5155 /* Wait up to 45 secs for Post */
5156 for (i = 0; i < 45; i++) {
5157 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5159 if (Isr & IPS_BIT_I960_MSG0I)
5162 /* Delay for 1 Second */
5163 MDELAY(IPS_ONE_SEC);
5167 /* error occurred */
5168 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5169 "timeout waiting for post.\n");
5174 Post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
5176 if (Post == 0x4F00) { /* If Flashing the Battery PIC */
5177 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5178 "Flashing Battery PIC, Please wait ...\n");
5180 /* Clear the interrupt bit */
5181 Isr = (uint32_t) IPS_BIT_I960_MSG0I;
5182 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5184 for (i = 0; i < 120; i++) { /* Wait Up to 2 Min. for Completion */
5185 Post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
5188 /* Delay for 1 Second */
5189 MDELAY(IPS_ONE_SEC);
5193 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5194 "timeout waiting for Battery PIC Flash\n");
5200 /* Clear the interrupt bit */
5201 Isr = (uint32_t) IPS_BIT_I960_MSG0I;
5202 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5204 if (Post < (IPS_GOOD_POST_STATUS << 8)) {
5205 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5206 "reset controller fails (post status %x).\n", Post);
5211 /* Wait up to 240 secs for config bytes */
5212 for (i = 0; i < 240; i++) {
5213 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5215 if (Isr & IPS_BIT_I960_MSG1I)
5218 /* Delay for 1 Second */
5219 MDELAY(IPS_ONE_SEC);
5223 /* error occurred */
5224 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5225 "timeout waiting for config.\n");
5230 Config = readl(ha->mem_ptr + IPS_REG_I960_MSG1);
5232 /* Clear interrupt bit */
5233 Isr = (uint32_t) IPS_BIT_I960_MSG1I;
5234 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5236 /* Turn on the interrupts */
5237 Oimr = readl(ha->mem_ptr + IPS_REG_I960_OIMR);
5239 writel(Oimr, ha->mem_ptr + IPS_REG_I960_OIMR);
5241 /* if we get here then everything went OK */
5243 /* Since we did a RESET, an EraseStripeLock may be needed */
5244 if (Post == 0xEF10) {
5245 if ((Config == 0x000F) || (Config == 0x0009))
5246 ha->requires_esl = 1;
5252 /****************************************************************************/
5254 /* Routine Name: ips_reset_copperhead */
5256 /* Routine Description: */
5258 /* Reset the controller */
5260 /****************************************************************************/
5262 ips_reset_copperhead(ips_ha_t * ha)
5266 METHOD_TRACE("ips_reset_copperhead", 1);
5268 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead: io addr: %x, irq: %d",
5269 ips_name, ha->host_num, ha->io_addr, ha->irq);
5273 while (reset_counter < 2) {
5276 outb(IPS_BIT_RST, ha->io_addr + IPS_REG_SCPR);
5278 /* Delay for 1 Second */
5279 MDELAY(IPS_ONE_SEC);
5281 outb(0, ha->io_addr + IPS_REG_SCPR);
5283 /* Delay for 1 Second */
5284 MDELAY(IPS_ONE_SEC);
5286 if ((*ha->func.init) (ha))
5288 else if (reset_counter >= 2) {
5297 /****************************************************************************/
5299 /* Routine Name: ips_reset_copperhead_memio */
5301 /* Routine Description: */
5303 /* Reset the controller */
5305 /****************************************************************************/
5307 ips_reset_copperhead_memio(ips_ha_t * ha)
5311 METHOD_TRACE("ips_reset_copperhead_memio", 1);
5313 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead_memio: mem addr: %x, irq: %d",
5314 ips_name, ha->host_num, ha->mem_addr, ha->irq);
5318 while (reset_counter < 2) {
5321 writeb(IPS_BIT_RST, ha->mem_ptr + IPS_REG_SCPR);
5323 /* Delay for 1 Second */
5324 MDELAY(IPS_ONE_SEC);
5326 writeb(0, ha->mem_ptr + IPS_REG_SCPR);
5328 /* Delay for 1 Second */
5329 MDELAY(IPS_ONE_SEC);
5331 if ((*ha->func.init) (ha))
5333 else if (reset_counter >= 2) {
5342 /****************************************************************************/
5344 /* Routine Name: ips_reset_morpheus */
5346 /* Routine Description: */
5348 /* Reset the controller */
5350 /****************************************************************************/
5352 ips_reset_morpheus(ips_ha_t * ha)
5357 METHOD_TRACE("ips_reset_morpheus", 1);
5359 DEBUG_VAR(1, "(%s%d) ips_reset_morpheus: mem addr: %x, irq: %d",
5360 ips_name, ha->host_num, ha->mem_addr, ha->irq);
5364 while (reset_counter < 2) {
5367 writel(0x80000000, ha->mem_ptr + IPS_REG_I960_IDR);
5369 /* Delay for 5 Seconds */
5370 MDELAY(5 * IPS_ONE_SEC);
5372 /* Do a PCI config read to wait for adapter */
5373 pci_read_config_byte(ha->pcidev, 4, &junk);
5375 if ((*ha->func.init) (ha))
5377 else if (reset_counter >= 2) {
5386 /****************************************************************************/
5388 /* Routine Name: ips_statinit */
5390 /* Routine Description: */
5392 /* Initialize the status queues on the controller */
5394 /****************************************************************************/
5396 ips_statinit(ips_ha_t * ha)
5398 uint32_t phys_status_start;
5400 METHOD_TRACE("ips_statinit", 1);
5402 ha->adapt->p_status_start = ha->adapt->status;
5403 ha->adapt->p_status_end = ha->adapt->status + IPS_MAX_CMDS;
5404 ha->adapt->p_status_tail = ha->adapt->status;
5406 phys_status_start = ha->adapt->hw_status_start;
5407 outl(cpu_to_le32(phys_status_start), ha->io_addr + IPS_REG_SQSR);
5408 outl(cpu_to_le32(phys_status_start + IPS_STATUS_Q_SIZE),
5409 ha->io_addr + IPS_REG_SQER);
5410 outl(cpu_to_le32(phys_status_start + IPS_STATUS_SIZE),
5411 ha->io_addr + IPS_REG_SQHR);
5412 outl(cpu_to_le32(phys_status_start), ha->io_addr + IPS_REG_SQTR);
5414 ha->adapt->hw_status_tail = phys_status_start;
5417 /****************************************************************************/
5419 /* Routine Name: ips_statinit_memio */
5421 /* Routine Description: */
5423 /* Initialize the status queues on the controller */
5425 /****************************************************************************/
5427 ips_statinit_memio(ips_ha_t * ha)
5429 uint32_t phys_status_start;
5431 METHOD_TRACE("ips_statinit_memio", 1);
5433 ha->adapt->p_status_start = ha->adapt->status;
5434 ha->adapt->p_status_end = ha->adapt->status + IPS_MAX_CMDS;
5435 ha->adapt->p_status_tail = ha->adapt->status;
5437 phys_status_start = ha->adapt->hw_status_start;
5438 writel(phys_status_start, ha->mem_ptr + IPS_REG_SQSR);
5439 writel(phys_status_start + IPS_STATUS_Q_SIZE,
5440 ha->mem_ptr + IPS_REG_SQER);
5441 writel(phys_status_start + IPS_STATUS_SIZE, ha->mem_ptr + IPS_REG_SQHR);
5442 writel(phys_status_start, ha->mem_ptr + IPS_REG_SQTR);
5444 ha->adapt->hw_status_tail = phys_status_start;
5447 /****************************************************************************/
5449 /* Routine Name: ips_statupd_copperhead */
5451 /* Routine Description: */
5453 /* Remove an element from the status queue */
5455 /****************************************************************************/
5457 ips_statupd_copperhead(ips_ha_t * ha)
5459 METHOD_TRACE("ips_statupd_copperhead", 1);
5461 if (ha->adapt->p_status_tail != ha->adapt->p_status_end) {
5462 ha->adapt->p_status_tail++;
5463 ha->adapt->hw_status_tail += sizeof (IPS_STATUS);
5465 ha->adapt->p_status_tail = ha->adapt->p_status_start;
5466 ha->adapt->hw_status_tail = ha->adapt->hw_status_start;
5469 outl(cpu_to_le32(ha->adapt->hw_status_tail),
5470 ha->io_addr + IPS_REG_SQTR);
5472 return (ha->adapt->p_status_tail->value);
5475 /****************************************************************************/
5477 /* Routine Name: ips_statupd_copperhead_memio */
5479 /* Routine Description: */
5481 /* Remove an element from the status queue */
5483 /****************************************************************************/
5485 ips_statupd_copperhead_memio(ips_ha_t * ha)
5487 METHOD_TRACE("ips_statupd_copperhead_memio", 1);
5489 if (ha->adapt->p_status_tail != ha->adapt->p_status_end) {
5490 ha->adapt->p_status_tail++;
5491 ha->adapt->hw_status_tail += sizeof (IPS_STATUS);
5493 ha->adapt->p_status_tail = ha->adapt->p_status_start;
5494 ha->adapt->hw_status_tail = ha->adapt->hw_status_start;
5497 writel(ha->adapt->hw_status_tail, ha->mem_ptr + IPS_REG_SQTR);
5499 return (ha->adapt->p_status_tail->value);
5502 /****************************************************************************/
5504 /* Routine Name: ips_statupd_morpheus */
5506 /* Routine Description: */
5508 /* Remove an element from the status queue */
5510 /****************************************************************************/
5512 ips_statupd_morpheus(ips_ha_t * ha)
5516 METHOD_TRACE("ips_statupd_morpheus", 1);
5518 val = readl(ha->mem_ptr + IPS_REG_I2O_OUTMSGQ);
5523 /****************************************************************************/
5525 /* Routine Name: ips_issue_copperhead */
5527 /* Routine Description: */
5529 /* Send a command down to the controller */
5531 /****************************************************************************/
5533 ips_issue_copperhead(ips_ha_t * ha, ips_scb_t * scb)
5538 METHOD_TRACE("ips_issue_copperhead", 1);
5540 if (scb->scsi_cmd) {
5541 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5545 scb->cmd.basic_io.command_id,
5546 scb->bus, scb->target_id, scb->lun);
5548 DEBUG_VAR(2, KERN_NOTICE "(%s%d) ips_issue: logical cmd id %d",
5549 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5555 le32_to_cpu(inl(ha->io_addr + IPS_REG_CCCR))) & IPS_BIT_SEM) {
5558 if (++TimeOut >= IPS_SEM_TIMEOUT) {
5559 if (!(val & IPS_BIT_START_STOP))
5562 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5563 "ips_issue val [0x%x].\n", val);
5564 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5565 "ips_issue semaphore chk timeout.\n");
5567 return (IPS_FAILURE);
5571 outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_CCSAR);
5572 outw(cpu_to_le32(IPS_BIT_START_CMD), ha->io_addr + IPS_REG_CCCR);
5574 return (IPS_SUCCESS);
5577 /****************************************************************************/
5579 /* Routine Name: ips_issue_copperhead_memio */
5581 /* Routine Description: */
5583 /* Send a command down to the controller */
5585 /****************************************************************************/
5587 ips_issue_copperhead_memio(ips_ha_t * ha, ips_scb_t * scb)
5592 METHOD_TRACE("ips_issue_copperhead_memio", 1);
5594 if (scb->scsi_cmd) {
5595 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5599 scb->cmd.basic_io.command_id,
5600 scb->bus, scb->target_id, scb->lun);
5602 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5603 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5608 while ((val = readl(ha->mem_ptr + IPS_REG_CCCR)) & IPS_BIT_SEM) {
5611 if (++TimeOut >= IPS_SEM_TIMEOUT) {
5612 if (!(val & IPS_BIT_START_STOP))
5615 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5616 "ips_issue val [0x%x].\n", val);
5617 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5618 "ips_issue semaphore chk timeout.\n");
5620 return (IPS_FAILURE);
5624 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_CCSAR);
5625 writel(IPS_BIT_START_CMD, ha->mem_ptr + IPS_REG_CCCR);
5627 return (IPS_SUCCESS);
5630 /****************************************************************************/
5632 /* Routine Name: ips_issue_i2o */
5634 /* Routine Description: */
5636 /* Send a command down to the controller */
5638 /****************************************************************************/
5640 ips_issue_i2o(ips_ha_t * ha, ips_scb_t * scb)
5643 METHOD_TRACE("ips_issue_i2o", 1);
5645 if (scb->scsi_cmd) {
5646 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5650 scb->cmd.basic_io.command_id,
5651 scb->bus, scb->target_id, scb->lun);
5653 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5654 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5657 outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_I2O_INMSGQ);
5659 return (IPS_SUCCESS);
5662 /****************************************************************************/
5664 /* Routine Name: ips_issue_i2o_memio */
5666 /* Routine Description: */
5668 /* Send a command down to the controller */
5670 /****************************************************************************/
5672 ips_issue_i2o_memio(ips_ha_t * ha, ips_scb_t * scb)
5675 METHOD_TRACE("ips_issue_i2o_memio", 1);
5677 if (scb->scsi_cmd) {
5678 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5682 scb->cmd.basic_io.command_id,
5683 scb->bus, scb->target_id, scb->lun);
5685 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5686 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5689 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_I2O_INMSGQ);
5691 return (IPS_SUCCESS);
5694 /****************************************************************************/
5696 /* Routine Name: ips_isintr_copperhead */
5698 /* Routine Description: */
5700 /* Test to see if an interrupt is for us */
5702 /****************************************************************************/
5704 ips_isintr_copperhead(ips_ha_t * ha)
5708 METHOD_TRACE("ips_isintr_copperhead", 2);
5710 Isr = inb(ha->io_addr + IPS_REG_HISR);
5713 /* ?!?! Nothing really there */
5716 if (Isr & IPS_BIT_SCE)
5718 else if (Isr & (IPS_BIT_SQO | IPS_BIT_GHI)) {
5719 /* status queue overflow or GHI */
5720 /* just clear the interrupt */
5721 outb(Isr, ha->io_addr + IPS_REG_HISR);
5727 /****************************************************************************/
5729 /* Routine Name: ips_isintr_copperhead_memio */
5731 /* Routine Description: */
5733 /* Test to see if an interrupt is for us */
5735 /****************************************************************************/
5737 ips_isintr_copperhead_memio(ips_ha_t * ha)
5741 METHOD_TRACE("ips_isintr_memio", 2);
5743 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5746 /* ?!?! Nothing really there */
5749 if (Isr & IPS_BIT_SCE)
5751 else if (Isr & (IPS_BIT_SQO | IPS_BIT_GHI)) {
5752 /* status queue overflow or GHI */
5753 /* just clear the interrupt */
5754 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5760 /****************************************************************************/
5762 /* Routine Name: ips_isintr_morpheus */
5764 /* Routine Description: */
5766 /* Test to see if an interrupt is for us */
5768 /****************************************************************************/
5770 ips_isintr_morpheus(ips_ha_t * ha)
5774 METHOD_TRACE("ips_isintr_morpheus", 2);
5776 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5778 if (Isr & IPS_BIT_I2O_OPQI)
5784 /****************************************************************************/
5786 /* Routine Name: ips_wait */
5788 /* Routine Description: */
5790 /* Wait for a command to complete */
5792 /****************************************************************************/
5794 ips_wait(ips_ha_t * ha, int time, int intr)
5799 METHOD_TRACE("ips_wait", 1);
5804 time *= IPS_ONE_SEC; /* convert seconds */
5806 while ((time > 0) && (!done)) {
5807 if (intr == IPS_INTR_ON) {
5808 if (ha->waitflag == FALSE) {
5813 } else if (intr == IPS_INTR_IORL) {
5814 if (ha->waitflag == FALSE) {
5816 * controller generated an interrupt to
5817 * acknowledge completion of the command
5818 * and ips_intr() has serviced the interrupt.
5826 * NOTE: we already have the io_request_lock so
5827 * even if we get an interrupt it won't get serviced
5828 * until after we finish.
5831 (*ha->func.intr) (ha);
5834 /* This looks like a very evil loop, but it only does this during start-up */
5842 /****************************************************************************/
5844 /* Routine Name: ips_write_driver_status */
5846 /* Routine Description: */
5848 /* Write OS/Driver version to Page 5 of the nvram on the controller */
5850 /****************************************************************************/
5852 ips_write_driver_status(ips_ha_t * ha, int intr)
5854 METHOD_TRACE("ips_write_driver_status", 1);
5856 if (!ips_readwrite_page5(ha, FALSE, intr)) {
5857 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5858 "unable to read NVRAM page 5.\n");
5863 /* check to make sure the page has a valid */
5865 if (le32_to_cpu(ha->nvram->signature) != IPS_NVRAM_P5_SIG) {
5867 "(%s%d) NVRAM page 5 has an invalid signature: %X.",
5868 ips_name, ha->host_num, ha->nvram->signature);
5869 ha->nvram->signature = IPS_NVRAM_P5_SIG;
5873 "(%s%d) Ad Type: %d, Ad Slot: %d, BIOS: %c%c%c%c %c%c%c%c.",
5874 ips_name, ha->host_num, le16_to_cpu(ha->nvram->adapter_type),
5875 ha->nvram->adapter_slot, ha->nvram->bios_high[0],
5876 ha->nvram->bios_high[1], ha->nvram->bios_high[2],
5877 ha->nvram->bios_high[3], ha->nvram->bios_low[0],
5878 ha->nvram->bios_low[1], ha->nvram->bios_low[2],
5879 ha->nvram->bios_low[3]);
5881 ips_get_bios_version(ha, intr);
5883 /* change values (as needed) */
5884 ha->nvram->operating_system = IPS_OS_LINUX;
5885 ha->nvram->adapter_type = ha->ad_type;
5886 strncpy((char *) ha->nvram->driver_high, IPS_VERSION_HIGH, 4);
5887 strncpy((char *) ha->nvram->driver_low, IPS_VERSION_LOW, 4);
5888 strncpy((char *) ha->nvram->bios_high, ha->bios_version, 4);
5889 strncpy((char *) ha->nvram->bios_low, ha->bios_version + 4, 4);
5891 ips_version_check(ha, intr); /* Check BIOS/FW/Driver Versions */
5893 /* now update the page */
5894 if (!ips_readwrite_page5(ha, TRUE, intr)) {
5895 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5896 "unable to write NVRAM page 5.\n");
5901 /* IF NVRAM Page 5 is OK, Use it for Slot Number Info Because Linux Doesn't Do Slots */
5902 ha->slot_num = ha->nvram->adapter_slot;
5907 /****************************************************************************/
5909 /* Routine Name: ips_read_adapter_status */
5911 /* Routine Description: */
5913 /* Do an Inquiry command to the adapter */
5915 /****************************************************************************/
5917 ips_read_adapter_status(ips_ha_t * ha, int intr)
5922 METHOD_TRACE("ips_read_adapter_status", 1);
5924 scb = &ha->scbs[ha->max_cmds - 1];
5926 ips_init_scb(ha, scb);
5928 scb->timeout = ips_cmd_timeout;
5929 scb->cdb[0] = IPS_CMD_ENQUIRY;
5931 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
5932 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5933 scb->cmd.basic_io.sg_count = 0;
5934 scb->cmd.basic_io.lba = 0;
5935 scb->cmd.basic_io.sector_count = 0;
5936 scb->cmd.basic_io.log_drv = 0;
5937 scb->data_len = sizeof (*ha->enq);
5938 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
5942 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5943 || (ret == IPS_SUCCESS_IMM)
5944 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5950 /****************************************************************************/
5952 /* Routine Name: ips_read_subsystem_parameters */
5954 /* Routine Description: */
5956 /* Read subsystem parameters from the adapter */
5958 /****************************************************************************/
5960 ips_read_subsystem_parameters(ips_ha_t * ha, int intr)
5965 METHOD_TRACE("ips_read_subsystem_parameters", 1);
5967 scb = &ha->scbs[ha->max_cmds - 1];
5969 ips_init_scb(ha, scb);
5971 scb->timeout = ips_cmd_timeout;
5972 scb->cdb[0] = IPS_CMD_GET_SUBSYS;
5974 scb->cmd.basic_io.op_code = IPS_CMD_GET_SUBSYS;
5975 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5976 scb->cmd.basic_io.sg_count = 0;
5977 scb->cmd.basic_io.lba = 0;
5978 scb->cmd.basic_io.sector_count = 0;
5979 scb->cmd.basic_io.log_drv = 0;
5980 scb->data_len = sizeof (*ha->subsys);
5981 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
5985 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5986 || (ret == IPS_SUCCESS_IMM)
5987 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5990 memcpy(ha->subsys, ha->ioctl_data, sizeof(*ha->subsys));
5994 /****************************************************************************/
5996 /* Routine Name: ips_read_config */
5998 /* Routine Description: */
6000 /* Read the configuration on the adapter */
6002 /****************************************************************************/
6004 ips_read_config(ips_ha_t * ha, int intr)
6010 METHOD_TRACE("ips_read_config", 1);
6012 /* set defaults for initiator IDs */
6013 for (i = 0; i < 4; i++)
6014 ha->conf->init_id[i] = 7;
6016 scb = &ha->scbs[ha->max_cmds - 1];
6018 ips_init_scb(ha, scb);
6020 scb->timeout = ips_cmd_timeout;
6021 scb->cdb[0] = IPS_CMD_READ_CONF;
6023 scb->cmd.basic_io.op_code = IPS_CMD_READ_CONF;
6024 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
6025 scb->data_len = sizeof (*ha->conf);
6026 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
6030 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6031 || (ret == IPS_SUCCESS_IMM)
6032 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
6034 memset(ha->conf, 0, sizeof (IPS_CONF));
6036 /* reset initiator IDs */
6037 for (i = 0; i < 4; i++)
6038 ha->conf->init_id[i] = 7;
6040 /* Allow Completed with Errors, so JCRM can access the Adapter to fix the problems */
6041 if ((scb->basic_status & IPS_GSC_STATUS_MASK) ==
6042 IPS_CMD_CMPLT_WERROR)
6048 memcpy(ha->conf, ha->ioctl_data, sizeof(*ha->conf));
6052 /****************************************************************************/
6054 /* Routine Name: ips_readwrite_page5 */
6056 /* Routine Description: */
6058 /* Read nvram page 5 from the adapter */
6060 /****************************************************************************/
6062 ips_readwrite_page5(ips_ha_t * ha, int write, int intr)
6067 METHOD_TRACE("ips_readwrite_page5", 1);
6069 scb = &ha->scbs[ha->max_cmds - 1];
6071 ips_init_scb(ha, scb);
6073 scb->timeout = ips_cmd_timeout;
6074 scb->cdb[0] = IPS_CMD_RW_NVRAM_PAGE;
6076 scb->cmd.nvram.op_code = IPS_CMD_RW_NVRAM_PAGE;
6077 scb->cmd.nvram.command_id = IPS_COMMAND_ID(ha, scb);
6078 scb->cmd.nvram.page = 5;
6079 scb->cmd.nvram.write = write;
6080 scb->cmd.nvram.reserved = 0;
6081 scb->cmd.nvram.reserved2 = 0;
6082 scb->data_len = sizeof (*ha->nvram);
6083 scb->cmd.nvram.buffer_addr = ha->ioctl_busaddr;
6085 memcpy(ha->ioctl_data, ha->nvram, sizeof(*ha->nvram));
6087 /* issue the command */
6089 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6090 || (ret == IPS_SUCCESS_IMM)
6091 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
6093 memset(ha->nvram, 0, sizeof (IPS_NVRAM_P5));
6098 memcpy(ha->nvram, ha->ioctl_data, sizeof(*ha->nvram));
6102 /****************************************************************************/
6104 /* Routine Name: ips_clear_adapter */
6106 /* Routine Description: */
6108 /* Clear the stripe lock tables */
6110 /****************************************************************************/
6112 ips_clear_adapter(ips_ha_t * ha, int intr)
6117 METHOD_TRACE("ips_clear_adapter", 1);
6119 scb = &ha->scbs[ha->max_cmds - 1];
6121 ips_init_scb(ha, scb);
6123 scb->timeout = ips_reset_timeout;
6124 scb->cdb[0] = IPS_CMD_CONFIG_SYNC;
6126 scb->cmd.config_sync.op_code = IPS_CMD_CONFIG_SYNC;
6127 scb->cmd.config_sync.command_id = IPS_COMMAND_ID(ha, scb);
6128 scb->cmd.config_sync.channel = 0;
6129 scb->cmd.config_sync.source_target = IPS_POCL;
6130 scb->cmd.config_sync.reserved = 0;
6131 scb->cmd.config_sync.reserved2 = 0;
6132 scb->cmd.config_sync.reserved3 = 0;
6136 ips_send_wait(ha, scb, ips_reset_timeout, intr)) == IPS_FAILURE)
6137 || (ret == IPS_SUCCESS_IMM)
6138 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6141 /* send unlock stripe command */
6142 ips_init_scb(ha, scb);
6144 scb->cdb[0] = IPS_CMD_ERROR_TABLE;
6145 scb->timeout = ips_reset_timeout;
6147 scb->cmd.unlock_stripe.op_code = IPS_CMD_ERROR_TABLE;
6148 scb->cmd.unlock_stripe.command_id = IPS_COMMAND_ID(ha, scb);
6149 scb->cmd.unlock_stripe.log_drv = 0;
6150 scb->cmd.unlock_stripe.control = IPS_CSL;
6151 scb->cmd.unlock_stripe.reserved = 0;
6152 scb->cmd.unlock_stripe.reserved2 = 0;
6153 scb->cmd.unlock_stripe.reserved3 = 0;
6157 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6158 || (ret == IPS_SUCCESS_IMM)
6159 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6165 /****************************************************************************/
6167 /* Routine Name: ips_ffdc_reset */
6169 /* Routine Description: */
6171 /* FFDC: write reset info */
6173 /****************************************************************************/
6175 ips_ffdc_reset(ips_ha_t * ha, int intr)
6179 METHOD_TRACE("ips_ffdc_reset", 1);
6181 scb = &ha->scbs[ha->max_cmds - 1];
6183 ips_init_scb(ha, scb);
6185 scb->timeout = ips_cmd_timeout;
6186 scb->cdb[0] = IPS_CMD_FFDC;
6187 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
6188 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
6189 scb->cmd.ffdc.reset_count = ha->reset_count;
6190 scb->cmd.ffdc.reset_type = 0x80;
6192 /* convert time to what the card wants */
6193 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
6196 ips_send_wait(ha, scb, ips_cmd_timeout, intr);
6199 /****************************************************************************/
6201 /* Routine Name: ips_ffdc_time */
6203 /* Routine Description: */
6205 /* FFDC: write time info */
6207 /****************************************************************************/
6209 ips_ffdc_time(ips_ha_t * ha)
6213 METHOD_TRACE("ips_ffdc_time", 1);
6215 DEBUG_VAR(1, "(%s%d) Sending time update.", ips_name, ha->host_num);
6217 scb = &ha->scbs[ha->max_cmds - 1];
6219 ips_init_scb(ha, scb);
6221 scb->timeout = ips_cmd_timeout;
6222 scb->cdb[0] = IPS_CMD_FFDC;
6223 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
6224 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
6225 scb->cmd.ffdc.reset_count = 0;
6226 scb->cmd.ffdc.reset_type = 0;
6228 /* convert time to what the card wants */
6229 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
6232 ips_send_wait(ha, scb, ips_cmd_timeout, IPS_FFDC);
6235 /****************************************************************************/
6237 /* Routine Name: ips_fix_ffdc_time */
6239 /* Routine Description: */
6240 /* Adjust time_t to what the card wants */
6242 /****************************************************************************/
6244 ips_fix_ffdc_time(ips_ha_t * ha, ips_scb_t * scb, time_t current_time)
6251 int year_lengths[2] = { IPS_DAYS_NORMAL_YEAR, IPS_DAYS_LEAP_YEAR };
6252 int month_lengths[12][2] = { {31, 31},
6266 METHOD_TRACE("ips_fix_ffdc_time", 1);
6268 days = current_time / IPS_SECS_DAY;
6269 rem = current_time % IPS_SECS_DAY;
6271 scb->cmd.ffdc.hour = (rem / IPS_SECS_HOUR);
6272 rem = rem % IPS_SECS_HOUR;
6273 scb->cmd.ffdc.minute = (rem / IPS_SECS_MIN);
6274 scb->cmd.ffdc.second = (rem % IPS_SECS_MIN);
6276 year = IPS_EPOCH_YEAR;
6277 while (days < 0 || days >= year_lengths[yleap = IPS_IS_LEAP_YEAR(year)]) {
6280 newy = year + (days / IPS_DAYS_NORMAL_YEAR);
6283 days -= (newy - year) * IPS_DAYS_NORMAL_YEAR +
6284 IPS_NUM_LEAP_YEARS_THROUGH(newy - 1) -
6285 IPS_NUM_LEAP_YEARS_THROUGH(year - 1);
6289 scb->cmd.ffdc.yearH = year / 100;
6290 scb->cmd.ffdc.yearL = year % 100;
6292 for (i = 0; days >= month_lengths[i][yleap]; ++i)
6293 days -= month_lengths[i][yleap];
6295 scb->cmd.ffdc.month = i + 1;
6296 scb->cmd.ffdc.day = days + 1;
6299 /****************************************************************************
6300 * BIOS Flash Routines *
6301 ****************************************************************************/
6303 /****************************************************************************/
6305 /* Routine Name: ips_erase_bios */
6307 /* Routine Description: */
6308 /* Erase the BIOS on the adapter */
6310 /****************************************************************************/
6312 ips_erase_bios(ips_ha_t * ha)
6317 METHOD_TRACE("ips_erase_bios", 1);
6321 /* Clear the status register */
6322 outl(0, ha->io_addr + IPS_REG_FLAP);
6323 if (ha->revision_id == IPS_REVID_TROMBONE64)
6324 udelay(25); /* 25 us */
6326 outb(0x50, ha->io_addr + IPS_REG_FLDP);
6327 if (ha->revision_id == IPS_REVID_TROMBONE64)
6328 udelay(25); /* 25 us */
6331 outb(0x20, ha->io_addr + IPS_REG_FLDP);
6332 if (ha->revision_id == IPS_REVID_TROMBONE64)
6333 udelay(25); /* 25 us */
6336 outb(0xD0, ha->io_addr + IPS_REG_FLDP);
6337 if (ha->revision_id == IPS_REVID_TROMBONE64)
6338 udelay(25); /* 25 us */
6341 outb(0x70, ha->io_addr + IPS_REG_FLDP);
6342 if (ha->revision_id == IPS_REVID_TROMBONE64)
6343 udelay(25); /* 25 us */
6345 timeout = 80000; /* 80 seconds */
6347 while (timeout > 0) {
6348 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6349 outl(0, ha->io_addr + IPS_REG_FLAP);
6350 udelay(25); /* 25 us */
6353 status = inb(ha->io_addr + IPS_REG_FLDP);
6362 /* check for timeout */
6366 /* try to suspend the erase */
6367 outb(0xB0, ha->io_addr + IPS_REG_FLDP);
6368 if (ha->revision_id == IPS_REVID_TROMBONE64)
6369 udelay(25); /* 25 us */
6371 /* wait for 10 seconds */
6373 while (timeout > 0) {
6374 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6375 outl(0, ha->io_addr + IPS_REG_FLAP);
6376 udelay(25); /* 25 us */
6379 status = inb(ha->io_addr + IPS_REG_FLDP);
6391 /* check for valid VPP */
6396 /* check for succesful flash */
6398 /* sequence error */
6401 /* Otherwise, we were successful */
6403 outb(0x50, ha->io_addr + IPS_REG_FLDP);
6404 if (ha->revision_id == IPS_REVID_TROMBONE64)
6405 udelay(25); /* 25 us */
6408 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6409 if (ha->revision_id == IPS_REVID_TROMBONE64)
6410 udelay(25); /* 25 us */
6415 /****************************************************************************/
6417 /* Routine Name: ips_erase_bios_memio */
6419 /* Routine Description: */
6420 /* Erase the BIOS on the adapter */
6422 /****************************************************************************/
6424 ips_erase_bios_memio(ips_ha_t * ha)
6429 METHOD_TRACE("ips_erase_bios_memio", 1);
6433 /* Clear the status register */
6434 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6435 if (ha->revision_id == IPS_REVID_TROMBONE64)
6436 udelay(25); /* 25 us */
6438 writeb(0x50, ha->mem_ptr + IPS_REG_FLDP);
6439 if (ha->revision_id == IPS_REVID_TROMBONE64)
6440 udelay(25); /* 25 us */
6443 writeb(0x20, ha->mem_ptr + IPS_REG_FLDP);
6444 if (ha->revision_id == IPS_REVID_TROMBONE64)
6445 udelay(25); /* 25 us */
6448 writeb(0xD0, ha->mem_ptr + IPS_REG_FLDP);
6449 if (ha->revision_id == IPS_REVID_TROMBONE64)
6450 udelay(25); /* 25 us */
6453 writeb(0x70, ha->mem_ptr + IPS_REG_FLDP);
6454 if (ha->revision_id == IPS_REVID_TROMBONE64)
6455 udelay(25); /* 25 us */
6457 timeout = 80000; /* 80 seconds */
6459 while (timeout > 0) {
6460 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6461 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6462 udelay(25); /* 25 us */
6465 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6474 /* check for timeout */
6478 /* try to suspend the erase */
6479 writeb(0xB0, ha->mem_ptr + IPS_REG_FLDP);
6480 if (ha->revision_id == IPS_REVID_TROMBONE64)
6481 udelay(25); /* 25 us */
6483 /* wait for 10 seconds */
6485 while (timeout > 0) {
6486 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6487 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6488 udelay(25); /* 25 us */
6491 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6503 /* check for valid VPP */
6508 /* check for succesful flash */
6510 /* sequence error */
6513 /* Otherwise, we were successful */
6515 writeb(0x50, ha->mem_ptr + IPS_REG_FLDP);
6516 if (ha->revision_id == IPS_REVID_TROMBONE64)
6517 udelay(25); /* 25 us */
6520 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6521 if (ha->revision_id == IPS_REVID_TROMBONE64)
6522 udelay(25); /* 25 us */
6527 /****************************************************************************/
6529 /* Routine Name: ips_program_bios */
6531 /* Routine Description: */
6532 /* Program the BIOS on the adapter */
6534 /****************************************************************************/
6536 ips_program_bios(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6543 METHOD_TRACE("ips_program_bios", 1);
6547 for (i = 0; i < buffersize; i++) {
6549 outl(cpu_to_le32(i + offset), ha->io_addr + IPS_REG_FLAP);
6550 if (ha->revision_id == IPS_REVID_TROMBONE64)
6551 udelay(25); /* 25 us */
6553 outb(0x40, ha->io_addr + IPS_REG_FLDP);
6554 if (ha->revision_id == IPS_REVID_TROMBONE64)
6555 udelay(25); /* 25 us */
6557 outb(buffer[i], ha->io_addr + IPS_REG_FLDP);
6558 if (ha->revision_id == IPS_REVID_TROMBONE64)
6559 udelay(25); /* 25 us */
6561 /* wait up to one second */
6563 while (timeout > 0) {
6564 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6565 outl(0, ha->io_addr + IPS_REG_FLAP);
6566 udelay(25); /* 25 us */
6569 status = inb(ha->io_addr + IPS_REG_FLDP);
6580 outl(0, ha->io_addr + IPS_REG_FLAP);
6581 if (ha->revision_id == IPS_REVID_TROMBONE64)
6582 udelay(25); /* 25 us */
6584 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6585 if (ha->revision_id == IPS_REVID_TROMBONE64)
6586 udelay(25); /* 25 us */
6591 /* check the status */
6592 if (status & 0x18) {
6593 /* programming error */
6594 outl(0, ha->io_addr + IPS_REG_FLAP);
6595 if (ha->revision_id == IPS_REVID_TROMBONE64)
6596 udelay(25); /* 25 us */
6598 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6599 if (ha->revision_id == IPS_REVID_TROMBONE64)
6600 udelay(25); /* 25 us */
6606 /* Enable reading */
6607 outl(0, ha->io_addr + IPS_REG_FLAP);
6608 if (ha->revision_id == IPS_REVID_TROMBONE64)
6609 udelay(25); /* 25 us */
6611 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6612 if (ha->revision_id == IPS_REVID_TROMBONE64)
6613 udelay(25); /* 25 us */
6618 /****************************************************************************/
6620 /* Routine Name: ips_program_bios_memio */
6622 /* Routine Description: */
6623 /* Program the BIOS on the adapter */
6625 /****************************************************************************/
6627 ips_program_bios_memio(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6634 METHOD_TRACE("ips_program_bios_memio", 1);
6638 for (i = 0; i < buffersize; i++) {
6640 writel(i + offset, ha->mem_ptr + IPS_REG_FLAP);
6641 if (ha->revision_id == IPS_REVID_TROMBONE64)
6642 udelay(25); /* 25 us */
6644 writeb(0x40, ha->mem_ptr + IPS_REG_FLDP);
6645 if (ha->revision_id == IPS_REVID_TROMBONE64)
6646 udelay(25); /* 25 us */
6648 writeb(buffer[i], ha->mem_ptr + IPS_REG_FLDP);
6649 if (ha->revision_id == IPS_REVID_TROMBONE64)
6650 udelay(25); /* 25 us */
6652 /* wait up to one second */
6654 while (timeout > 0) {
6655 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6656 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6657 udelay(25); /* 25 us */
6660 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6671 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6672 if (ha->revision_id == IPS_REVID_TROMBONE64)
6673 udelay(25); /* 25 us */
6675 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6676 if (ha->revision_id == IPS_REVID_TROMBONE64)
6677 udelay(25); /* 25 us */
6682 /* check the status */
6683 if (status & 0x18) {
6684 /* programming error */
6685 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6686 if (ha->revision_id == IPS_REVID_TROMBONE64)
6687 udelay(25); /* 25 us */
6689 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6690 if (ha->revision_id == IPS_REVID_TROMBONE64)
6691 udelay(25); /* 25 us */
6697 /* Enable reading */
6698 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6699 if (ha->revision_id == IPS_REVID_TROMBONE64)
6700 udelay(25); /* 25 us */
6702 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6703 if (ha->revision_id == IPS_REVID_TROMBONE64)
6704 udelay(25); /* 25 us */
6709 /****************************************************************************/
6711 /* Routine Name: ips_verify_bios */
6713 /* Routine Description: */
6714 /* Verify the BIOS on the adapter */
6716 /****************************************************************************/
6718 ips_verify_bios(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6724 METHOD_TRACE("ips_verify_bios", 1);
6727 outl(0, ha->io_addr + IPS_REG_FLAP);
6728 if (ha->revision_id == IPS_REVID_TROMBONE64)
6729 udelay(25); /* 25 us */
6731 if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
6734 outl(cpu_to_le32(1), ha->io_addr + IPS_REG_FLAP);
6735 if (ha->revision_id == IPS_REVID_TROMBONE64)
6736 udelay(25); /* 25 us */
6737 if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
6741 for (i = 2; i < buffersize; i++) {
6743 outl(cpu_to_le32(i + offset), ha->io_addr + IPS_REG_FLAP);
6744 if (ha->revision_id == IPS_REVID_TROMBONE64)
6745 udelay(25); /* 25 us */
6747 checksum = (uint8_t) checksum + inb(ha->io_addr + IPS_REG_FLDP);
6758 /****************************************************************************/
6760 /* Routine Name: ips_verify_bios_memio */
6762 /* Routine Description: */
6763 /* Verify the BIOS on the adapter */
6765 /****************************************************************************/
6767 ips_verify_bios_memio(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6773 METHOD_TRACE("ips_verify_bios_memio", 1);
6776 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6777 if (ha->revision_id == IPS_REVID_TROMBONE64)
6778 udelay(25); /* 25 us */
6780 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
6783 writel(1, ha->mem_ptr + IPS_REG_FLAP);
6784 if (ha->revision_id == IPS_REVID_TROMBONE64)
6785 udelay(25); /* 25 us */
6786 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
6790 for (i = 2; i < buffersize; i++) {
6792 writel(i + offset, ha->mem_ptr + IPS_REG_FLAP);
6793 if (ha->revision_id == IPS_REVID_TROMBONE64)
6794 udelay(25); /* 25 us */
6797 (uint8_t) checksum + readb(ha->mem_ptr + IPS_REG_FLDP);
6808 /*---------------------------------------------------------------------------*/
6809 /* Routine Name: ips_version_check */
6812 /* Assumes that ips_read_adapter_status() is called first filling in */
6813 /* the data for SubSystem Parameters. */
6814 /* Called from ips_write_driver_status() so it also assumes NVRAM Page 5 */
6815 /* Data is available. */
6817 /*---------------------------------------------------------------------------*/
6819 ips_version_check(ips_ha_t * ha, int intr)
6821 IPS_VERSION_DATA *VersionInfo;
6822 uint8_t FirmwareVersion[IPS_COMPAT_ID_LENGTH + 1];
6823 uint8_t BiosVersion[IPS_COMPAT_ID_LENGTH + 1];
6826 char BiosString[10];
6827 char FirmwareString[10];
6829 METHOD_TRACE("ips_version_check", 1);
6831 VersionInfo = ( IPS_VERSION_DATA * ) ha->ioctl_data;
6833 memset(FirmwareVersion, 0, IPS_COMPAT_ID_LENGTH + 1);
6834 memset(BiosVersion, 0, IPS_COMPAT_ID_LENGTH + 1);
6836 /* Get the Compatible BIOS Version from NVRAM Page 5 */
6837 memcpy(BiosVersion, ha->nvram->BiosCompatibilityID,
6838 IPS_COMPAT_ID_LENGTH);
6841 if (ha->subsys->param[4] & IPS_GET_VERSION_SUPPORT) { /* If Versioning is Supported */
6842 /* Get the Version Info with a Get Version Command */
6843 memset( VersionInfo, 0, sizeof (IPS_VERSION_DATA));
6844 rc = ips_get_version_info(ha, ha->ioctl_busaddr, intr);
6845 if (rc == IPS_SUCCESS)
6846 memcpy(FirmwareVersion, VersionInfo->compatibilityId,
6847 IPS_COMPAT_ID_LENGTH);
6850 if (rc != IPS_SUCCESS) { /* If Data Not Obtainable from a GetVersion Command */
6851 /* Get the Firmware Version from Enquiry Data */
6852 memcpy(FirmwareVersion, ha->enq->CodeBlkVersion,
6853 IPS_COMPAT_ID_LENGTH);
6856 /* printk(KERN_WARNING "Adapter's BIOS Version = %s\n", BiosVersion); */
6857 /* printk(KERN_WARNING "BIOS Compatible Version = %s\n", IPS_COMPAT_BIOS); */
6858 /* printk(KERN_WARNING "Adapter's Firmware Version = %s\n", FirmwareVersion); */
6859 /* printk(KERN_WARNING "Firmware Compatible Version = %s \n", Compatable[ ha->nvram->adapter_type ]); */
6864 (FirmwareVersion, Compatable[ha->nvram->adapter_type],
6865 IPS_COMPAT_ID_LENGTH) != 0)
6868 if (strncmp(BiosVersion, IPS_COMPAT_BIOS, IPS_COMPAT_ID_LENGTH) != 0)
6871 ha->nvram->versioning = 1; /* Indicate the Driver Supports Versioning */
6874 ha->nvram->version_mismatch = 1;
6875 if (ips_cd_boot == 0) {
6876 strncpy(&BiosString[0], ha->nvram->bios_high, 4);
6877 strncpy(&BiosString[4], ha->nvram->bios_low, 4);
6880 strncpy(&FirmwareString[0], ha->enq->CodeBlkVersion, 8);
6881 FirmwareString[8] = 0;
6883 IPS_PRINTK(KERN_WARNING, ha->pcidev,
6884 "Warning ! ! ! ServeRAID Version Mismatch\n");
6885 IPS_PRINTK(KERN_WARNING, ha->pcidev,
6886 "Bios = %s, Firmware = %s, Device Driver = %s%s\n",
6887 BiosString, FirmwareString, IPS_VERSION_HIGH,
6889 IPS_PRINTK(KERN_WARNING, ha->pcidev,
6890 "These levels should match to avoid possible compatibility problems.\n");
6893 ha->nvram->version_mismatch = 0;
6899 /*---------------------------------------------------------------------------*/
6900 /* Routine Name: ips_get_version_info */
6902 /* Routine Description: */
6903 /* Issue an internal GETVERSION Command */
6906 /* 0 if Successful, else non-zero */
6907 /*---------------------------------------------------------------------------*/
6909 ips_get_version_info(ips_ha_t * ha, dma_addr_t Buffer, int intr)
6914 METHOD_TRACE("ips_get_version_info", 1);
6916 scb = &ha->scbs[ha->max_cmds - 1];
6918 ips_init_scb(ha, scb);
6920 scb->timeout = ips_cmd_timeout;
6921 scb->cdb[0] = IPS_CMD_GET_VERSION_INFO;
6922 scb->cmd.version_info.op_code = IPS_CMD_GET_VERSION_INFO;
6923 scb->cmd.version_info.command_id = IPS_COMMAND_ID(ha, scb);
6924 scb->cmd.version_info.reserved = 0;
6925 scb->cmd.version_info.count = sizeof (IPS_VERSION_DATA);
6926 scb->cmd.version_info.reserved2 = 0;
6927 scb->data_len = sizeof (IPS_VERSION_DATA);
6928 scb->data_busaddr = Buffer;
6929 scb->cmd.version_info.buffer_addr = Buffer;
6933 rc = ips_send_wait(ha, scb, ips_cmd_timeout, intr);
6937 /****************************************************************************/
6939 /* Routine Name: ips_abort_init */
6941 /* Routine Description: */
6942 /* cleanup routine for a failed adapter initialization */
6943 /****************************************************************************/
6945 ips_abort_init(ips_ha_t * ha, int index)
6954 /****************************************************************************/
6956 /* Routine Name: ips_shift_controllers */
6958 /* Routine Description: */
6959 /* helper function for ordering adapters */
6960 /****************************************************************************/
6962 ips_shift_controllers(int lowindex, int highindex)
6964 ips_ha_t *ha_sav = ips_ha[highindex];
6965 struct Scsi_Host *sh_sav = ips_sh[highindex];
6968 for (i = highindex; i > lowindex; i--) {
6969 ips_ha[i] = ips_ha[i - 1];
6970 ips_sh[i] = ips_sh[i - 1];
6971 ips_ha[i]->host_num = i;
6973 ha_sav->host_num = lowindex;
6974 ips_ha[lowindex] = ha_sav;
6975 ips_sh[lowindex] = sh_sav;
6978 /****************************************************************************/
6980 /* Routine Name: ips_order_controllers */
6982 /* Routine Description: */
6983 /* place controllers is the "proper" boot order */
6984 /****************************************************************************/
6986 ips_order_controllers(void)
6988 int i, j, tmp, position = 0;
6989 IPS_NVRAM_P5 *nvram;
6992 nvram = ips_ha[0]->nvram;
6994 if (nvram->adapter_order[0]) {
6995 for (i = 1; i <= nvram->adapter_order[0]; i++) {
6996 for (j = position; j < ips_num_controllers; j++) {
6997 switch (ips_ha[j]->ad_type) {
6998 case IPS_ADTYPE_SERVERAID6M:
6999 case IPS_ADTYPE_SERVERAID7k:
7000 case IPS_ADTYPE_SERVERAID7M:
7001 if (nvram->adapter_order[i] == 'M') {
7002 ips_shift_controllers(position,
7007 case IPS_ADTYPE_SERVERAID4L:
7008 case IPS_ADTYPE_SERVERAID4M:
7009 case IPS_ADTYPE_SERVERAID4MX:
7010 case IPS_ADTYPE_SERVERAID4LX:
7011 if (nvram->adapter_order[i] == 'N') {
7012 ips_shift_controllers(position,
7017 case IPS_ADTYPE_SERVERAID6I:
7018 case IPS_ADTYPE_SERVERAID5I2:
7019 case IPS_ADTYPE_SERVERAID5I1:
7020 if (nvram->adapter_order[i] == 'S') {
7021 ips_shift_controllers(position,
7026 case IPS_ADTYPE_SERVERAID:
7027 case IPS_ADTYPE_SERVERAID2:
7028 case IPS_ADTYPE_NAVAJO:
7029 case IPS_ADTYPE_KIOWA:
7030 case IPS_ADTYPE_SERVERAID3L:
7031 case IPS_ADTYPE_SERVERAID3:
7032 case IPS_ADTYPE_SERVERAID4H:
7033 if (nvram->adapter_order[i] == 'A') {
7034 ips_shift_controllers(position,
7044 /* if adapter_order[0], then ordering is complete */
7047 /* old bios, use older ordering */
7049 for (i = position; i < ips_num_controllers; i++) {
7050 if (ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID5I2 ||
7051 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID5I1) {
7052 ips_shift_controllers(position, i);
7057 /* if there were no 5I cards, then don't do any extra ordering */
7060 for (i = position; i < ips_num_controllers; i++) {
7061 if (ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4L ||
7062 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4M ||
7063 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4LX ||
7064 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4MX) {
7065 ips_shift_controllers(position, i);
7073 /****************************************************************************/
7075 /* Routine Name: ips_register_scsi */
7077 /* Routine Description: */
7078 /* perform any registration and setup with the scsi layer */
7079 /****************************************************************************/
7081 ips_register_scsi(int index)
7083 struct Scsi_Host *sh;
7084 ips_ha_t *ha, *oldha = ips_ha[index];
7085 sh = scsi_host_alloc(&ips_driver_template, sizeof (ips_ha_t));
7087 IPS_PRINTK(KERN_WARNING, oldha->pcidev,
7088 "Unable to register controller with SCSI subsystem\n");
7092 memcpy(ha, oldha, sizeof (ips_ha_t));
7093 free_irq(oldha->irq, oldha);
7094 /* Install the interrupt handler with the new ha */
7095 if (request_irq(ha->irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
7096 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7097 "Unable to install interrupt handler\n");
7105 IPS_SCSI_SET_DEVICE(sh, ha);
7107 /* Store away needed values for later use */
7108 sh->io_port = ha->io_addr;
7109 sh->n_io_port = ha->io_addr ? 255 : 0;
7110 sh->unique_id = (ha->io_addr) ? ha->io_addr : ha->mem_addr;
7112 sh->sg_tablesize = sh->hostt->sg_tablesize;
7113 sh->can_queue = sh->hostt->can_queue;
7114 sh->cmd_per_lun = sh->hostt->cmd_per_lun;
7115 sh->unchecked_isa_dma = sh->hostt->unchecked_isa_dma;
7116 sh->use_clustering = sh->hostt->use_clustering;
7118 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,7)
7119 sh->max_sectors = 128;
7122 sh->max_id = ha->ntargets;
7123 sh->max_lun = ha->nlun;
7124 sh->max_channel = ha->nbus - 1;
7125 sh->can_queue = ha->max_cmds - 1;
7127 IPS_ADD_HOST(sh, NULL);
7131 /*---------------------------------------------------------------------------*/
7132 /* Routine Name: ips_remove_device */
7134 /* Routine Description: */
7135 /* Remove one Adapter ( Hot Plugging ) */
7136 /*---------------------------------------------------------------------------*/
7137 static void __devexit
7138 ips_remove_device(struct pci_dev *pci_dev)
7141 struct Scsi_Host *sh;
7144 for (i = 0; i < IPS_MAX_ADAPTERS; i++) {
7147 if ((pci_dev->bus->number == ha->pcidev->bus->number) &&
7148 (pci_dev->devfn == ha->pcidev->devfn)) {
7156 /****************************************************************************/
7158 /* Routine Name: ips_module_init */
7160 /* Routine Description: */
7161 /* function called on module load */
7162 /****************************************************************************/
7164 ips_module_init(void)
7166 if (pci_module_init(&ips_pci_driver) < 0)
7168 ips_driver_template.module = THIS_MODULE;
7169 ips_order_controllers();
7170 if (IPS_REGISTER_HOSTS(&ips_driver_template)) {
7171 pci_unregister_driver(&ips_pci_driver);
7174 register_reboot_notifier(&ips_notifier);
7178 /****************************************************************************/
7180 /* Routine Name: ips_module_exit */
7182 /* Routine Description: */
7183 /* function called on module unload */
7184 /****************************************************************************/
7186 ips_module_exit(void)
7188 IPS_UNREGISTER_HOSTS(&ips_driver_template);
7189 pci_unregister_driver(&ips_pci_driver);
7190 unregister_reboot_notifier(&ips_notifier);
7193 module_init(ips_module_init);
7194 module_exit(ips_module_exit);
7196 /*---------------------------------------------------------------------------*/
7197 /* Routine Name: ips_insert_device */
7199 /* Routine Description: */
7200 /* Add One Adapter ( Hot Plug ) */
7203 /* 0 if Successful, else non-zero */
7204 /*---------------------------------------------------------------------------*/
7205 static int __devinit
7206 ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent)
7211 METHOD_TRACE("ips_insert_device", 1);
7212 if (pci_enable_device(pci_dev))
7215 rc = ips_init_phase1(pci_dev, &index);
7217 rc = ips_init_phase2(index);
7220 if (ips_register_scsi(index)) {
7221 ips_free(ips_ha[index]);
7226 ips_num_controllers++;
7228 ips_next_controller = ips_num_controllers;
7232 /*---------------------------------------------------------------------------*/
7233 /* Routine Name: ips_init_phase1 */
7235 /* Routine Description: */
7236 /* Adapter Initialization */
7239 /* 0 if Successful, else non-zero */
7240 /*---------------------------------------------------------------------------*/
7242 ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr)
7249 uint8_t revision_id;
7253 uint16_t subdevice_id;
7256 dma_addr_t dma_address;
7261 METHOD_TRACE("ips_init_phase1", 1);
7262 index = IPS_MAX_ADAPTERS;
7263 for (j = 0; j < IPS_MAX_ADAPTERS; j++) {
7264 if (ips_ha[j] == 0) {
7270 if (index >= IPS_MAX_ADAPTERS)
7273 /* stuff that we get in dev */
7275 bus = pci_dev->bus->number;
7276 func = pci_dev->devfn;
7278 /* Init MEM/IO addresses to 0 */
7284 for (j = 0; j < 2; j++) {
7285 if (!pci_resource_start(pci_dev, j))
7288 if (pci_resource_flags(pci_dev, j) & IORESOURCE_IO) {
7289 io_addr = pci_resource_start(pci_dev, j);
7290 io_len = pci_resource_len(pci_dev, j);
7292 mem_addr = pci_resource_start(pci_dev, j);
7293 mem_len = pci_resource_len(pci_dev, j);
7297 /* setup memory mapped area (if applicable) */
7302 if (!request_mem_region(mem_addr, mem_len, "ips")) {
7303 IPS_PRINTK(KERN_WARNING, pci_dev,
7304 "Couldn't allocate IO Memory space %x len %d.\n",
7309 base = mem_addr & PAGE_MASK;
7310 offs = mem_addr - base;
7311 ioremap_ptr = ioremap(base, PAGE_SIZE);
7312 mem_ptr = ioremap_ptr + offs;
7318 /* setup I/O mapped area (if applicable) */
7320 if (!request_region(io_addr, io_len, "ips")) {
7321 IPS_PRINTK(KERN_WARNING, pci_dev,
7322 "Couldn't allocate IO space %x len %d.\n",
7328 /* get the revision ID */
7329 if (pci_read_config_byte(pci_dev, PCI_REVISION_ID, &revision_id)) {
7330 IPS_PRINTK(KERN_WARNING, pci_dev, "Can't get revision id.\n");
7334 subdevice_id = pci_dev->subsystem_device;
7336 /* found a controller */
7337 ha = kmalloc(sizeof (ips_ha_t), GFP_KERNEL);
7339 IPS_PRINTK(KERN_WARNING, pci_dev,
7340 "Unable to allocate temporary ha struct\n");
7344 memset(ha, 0, sizeof (ips_ha_t));
7346 ips_sh[index] = NULL;
7350 /* Store info in HA structure */
7352 ha->io_addr = io_addr;
7353 ha->io_len = io_len;
7354 ha->mem_addr = mem_addr;
7355 ha->mem_len = mem_len;
7356 ha->mem_ptr = mem_ptr;
7357 ha->ioremap_ptr = ioremap_ptr;
7358 ha->host_num = (uint32_t) index;
7359 ha->revision_id = revision_id;
7360 ha->slot_num = PCI_SLOT(pci_dev->devfn);
7361 ha->device_id = pci_dev->device;
7362 ha->subdevice_id = subdevice_id;
7363 ha->pcidev = pci_dev;
7366 * Set the pci_dev's dma_mask. Not all adapters support 64bit
7367 * addressing so don't enable it if the adapter can't support
7368 * it! Also, don't use 64bit addressing if dma addresses
7369 * are guaranteed to be < 4G.
7371 if (IPS_ENABLE_DMA64 && IPS_HAS_ENH_SGLIST(ha) &&
7372 !pci_set_dma_mask(ha->pcidev, 0xffffffffffffffffULL)) {
7373 (ha)->flags |= IPS_HA_ENH_SG;
7375 if (pci_set_dma_mask(ha->pcidev, 0xffffffffULL) != 0) {
7376 printk(KERN_WARNING "Unable to set DMA Mask\n");
7377 return ips_abort_init(ha, index);
7380 if(ips_cd_boot && !ips_FlashData){
7381 ips_FlashData = pci_alloc_consistent(pci_dev, PAGE_SIZE << 7,
7385 ha->enq = pci_alloc_consistent(pci_dev, sizeof (IPS_ENQ),
7388 IPS_PRINTK(KERN_WARNING, pci_dev,
7389 "Unable to allocate host inquiry structure\n");
7390 return ips_abort_init(ha, index);
7393 ha->adapt = pci_alloc_consistent(pci_dev, sizeof (IPS_ADAPTER) +
7394 sizeof (IPS_IO_CMD), &dma_address);
7396 IPS_PRINTK(KERN_WARNING, pci_dev,
7397 "Unable to allocate host adapt & dummy structures\n");
7398 return ips_abort_init(ha, index);
7400 ha->adapt->hw_status_start = dma_address;
7401 ha->dummy = (void *) (ha->adapt + 1);
7405 ha->logical_drive_info = pci_alloc_consistent(pci_dev, sizeof (IPS_LD_INFO), &dma_address);
7406 if (!ha->logical_drive_info) {
7407 IPS_PRINTK(KERN_WARNING, pci_dev,
7408 "Unable to allocate logical drive info structure\n");
7409 return ips_abort_init(ha, index);
7411 ha->logical_drive_info_dma_addr = dma_address;
7414 ha->conf = kmalloc(sizeof (IPS_CONF), GFP_KERNEL);
7417 IPS_PRINTK(KERN_WARNING, pci_dev,
7418 "Unable to allocate host conf structure\n");
7419 return ips_abort_init(ha, index);
7422 ha->nvram = kmalloc(sizeof (IPS_NVRAM_P5), GFP_KERNEL);
7425 IPS_PRINTK(KERN_WARNING, pci_dev,
7426 "Unable to allocate host NVRAM structure\n");
7427 return ips_abort_init(ha, index);
7430 ha->subsys = kmalloc(sizeof (IPS_SUBSYS), GFP_KERNEL);
7433 IPS_PRINTK(KERN_WARNING, pci_dev,
7434 "Unable to allocate host subsystem structure\n");
7435 return ips_abort_init(ha, index);
7438 /* the ioctl buffer is now used during adapter initialization, so its
7439 * successful allocation is now required */
7440 if (ips_ioctlsize < PAGE_SIZE)
7441 ips_ioctlsize = PAGE_SIZE;
7443 ha->ioctl_data = pci_alloc_consistent(pci_dev, ips_ioctlsize,
7444 &ha->ioctl_busaddr);
7445 ha->ioctl_len = ips_ioctlsize;
7446 if (!ha->ioctl_data) {
7447 IPS_PRINTK(KERN_WARNING, pci_dev,
7448 "Unable to allocate IOCTL data\n");
7449 return ips_abort_init(ha, index);
7455 ips_setup_funclist(ha);
7457 if ((IPS_IS_MORPHEUS(ha)) || (IPS_IS_MARCO(ha))) {
7458 /* If Morpheus appears dead, reset it */
7459 IsDead = readl(ha->mem_ptr + IPS_REG_I960_MSG1);
7460 if (IsDead == 0xDEADBEEF) {
7461 ips_reset_morpheus(ha);
7466 * Initialize the card if it isn't already
7469 if (!(*ha->func.isinit) (ha)) {
7470 if (!(*ha->func.init) (ha)) {
7472 * Initialization failed
7474 IPS_PRINTK(KERN_WARNING, pci_dev,
7475 "Unable to initialize controller\n");
7476 return ips_abort_init(ha, index);
7484 /*---------------------------------------------------------------------------*/
7485 /* Routine Name: ips_init_phase2 */
7487 /* Routine Description: */
7488 /* Adapter Initialization Phase 2 */
7491 /* 0 if Successful, else non-zero */
7492 /*---------------------------------------------------------------------------*/
7494 ips_init_phase2(int index)
7500 METHOD_TRACE("ips_init_phase2", 1);
7502 ips_ha[index] = NULL;
7506 /* Install the interrupt handler */
7507 if (request_irq(ha->irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
7508 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7509 "Unable to install interrupt handler\n");
7510 return ips_abort_init(ha, index);
7514 * Allocate a temporary SCB for initialization
7517 if (!ips_allocatescbs(ha)) {
7518 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7519 "Unable to allocate a CCB\n");
7520 free_irq(ha->irq, ha);
7521 return ips_abort_init(ha, index);
7524 if (!ips_hainit(ha)) {
7525 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7526 "Unable to initialize controller\n");
7527 free_irq(ha->irq, ha);
7528 return ips_abort_init(ha, index);
7530 /* Free the temporary SCB */
7531 ips_deallocatescbs(ha, 1);
7534 if (!ips_allocatescbs(ha)) {
7535 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7536 "Unable to allocate CCBs\n");
7537 free_irq(ha->irq, ha);
7538 return ips_abort_init(ha, index);
7544 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9)
7545 MODULE_LICENSE("GPL");
7549 * Overrides for Emacs so that we almost follow Linus's tabbing style.
7550 * Emacs will notice this stuff at the end of the file and automatically
7551 * adjust the settings for this buffer only. This must remain at the end
7553 * ---------------------------------------------------------------------------
7556 * c-brace-imaginary-offset: 0
7557 * c-brace-offset: -2
7558 * c-argdecl-indent: 2
7559 * c-label-offset: -2
7560 * c-continued-statement-offset: 2
7561 * c-continued-brace-offset: 0
7562 * indent-tabs-mode: nil