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 /* 7.10.18 - Add highmem_io flag in SCSI Templete for 2.4 kernels */
137 /* - Fix path/name for scsi_hosts.h include for 2.6 kernels */
138 /* - Fix sort order of 7k */
139 /* - Remove 3 unused "inline" functions */
140 /* 7.12.xx - Use STATIC functions whereever possible */
141 /* - Clean up deprecated MODULE_PARM calls */
142 /*****************************************************************************/
145 * Conditional Compilation directives for this driver:
147 * IPS_DEBUG - Turn on debugging info
151 * debug:<number> - Set debug level to <number>
152 * NOTE: only works when IPS_DEBUG compile directive is used.
153 * 1 - Normal debug messages
154 * 2 - Verbose debug messages
155 * 11 - Method trace (non interrupt)
156 * 12 - Method trace (includes interrupt)
158 * noi2o - Don't use I2O Queues (ServeRAID 4 only)
159 * nommap - Don't use memory mapped I/O
160 * ioctlsize - Initial size of the IOCTL buffer
164 #include <asm/byteorder.h>
165 #include <asm/page.h>
166 #include <linux/stddef.h>
167 #include <linux/version.h>
168 #include <linux/string.h>
169 #include <linux/errno.h>
170 #include <linux/kernel.h>
171 #include <linux/ioport.h>
172 #include <linux/slab.h>
173 #include <linux/delay.h>
174 #include <linux/pci.h>
175 #include <linux/proc_fs.h>
176 #include <linux/reboot.h>
177 #include <linux/interrupt.h>
179 #include <linux/blkdev.h>
180 #include <linux/types.h>
186 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
189 #include <scsi/scsi_host.h>
194 #include <linux/module.h>
196 #include <linux/stat.h>
197 #include <linux/config.h>
199 #include <linux/spinlock.h>
200 #include <linux/init.h>
202 #include <linux/smp.h>
205 static char *ips = NULL;
206 module_param(ips, charp, 0);
212 #define IPS_VERSION_HIGH "7.12"
213 #define IPS_VERSION_LOW ".02 "
215 #if !defined(__i386__) && !defined(__ia64__) && !defined(__x86_64__)
216 #warning "This driver has only been tested on the x86/ia64/x86_64 platforms"
219 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
220 #include <linux/blk.h>
222 #define IPS_LOCK_SAVE(lock,flags) spin_lock_irqsave(&io_request_lock,flags)
223 #define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock_irqrestore(&io_request_lock,flags)
225 #define __devexit_p(x) x
228 #define IPS_LOCK_SAVE(lock,flags) do{spin_lock(lock);(void)flags;}while(0)
229 #define IPS_UNLOCK_RESTORE(lock,flags) do{spin_unlock(lock);(void)flags;}while(0)
232 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
233 DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
234 PCI_DMA_BIDIRECTIONAL : \
235 scb->scsi_cmd->sc_data_direction)
238 #define METHOD_TRACE(s, i) if (ips_debug >= (i+10)) printk(KERN_NOTICE s "\n");
239 #define DEBUG(i, s) if (ips_debug >= i) printk(KERN_NOTICE s "\n");
240 #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "\n", v);
242 #define METHOD_TRACE(s, i)
244 #define DEBUG_VAR(i, s, v...)
248 * Function prototypes
250 static int ips_detect(Scsi_Host_Template *);
251 static int ips_release(struct Scsi_Host *);
252 static int ips_eh_abort(Scsi_Cmnd *);
253 static int ips_eh_reset(Scsi_Cmnd *);
254 static int ips_queue(Scsi_Cmnd *, void (*)(Scsi_Cmnd *));
255 static const char *ips_info(struct Scsi_Host *);
256 static irqreturn_t do_ipsintr(int, void *, struct pt_regs *);
257 static int ips_hainit(ips_ha_t *);
258 static int ips_map_status(ips_ha_t *, ips_scb_t *, ips_stat_t *);
259 static int ips_send_wait(ips_ha_t *, ips_scb_t *, int, int);
260 static int ips_send_cmd(ips_ha_t *, ips_scb_t *);
261 static int ips_online(ips_ha_t *, ips_scb_t *);
262 static int ips_inquiry(ips_ha_t *, ips_scb_t *);
263 static int ips_rdcap(ips_ha_t *, ips_scb_t *);
264 static int ips_msense(ips_ha_t *, ips_scb_t *);
265 static int ips_reqsen(ips_ha_t *, ips_scb_t *);
266 static int ips_deallocatescbs(ips_ha_t *, int);
267 static int ips_allocatescbs(ips_ha_t *);
268 static int ips_reset_copperhead(ips_ha_t *);
269 static int ips_reset_copperhead_memio(ips_ha_t *);
270 static int ips_reset_morpheus(ips_ha_t *);
271 static int ips_issue_copperhead(ips_ha_t *, ips_scb_t *);
272 static int ips_issue_copperhead_memio(ips_ha_t *, ips_scb_t *);
273 static int ips_issue_i2o(ips_ha_t *, ips_scb_t *);
274 static int ips_issue_i2o_memio(ips_ha_t *, ips_scb_t *);
275 static int ips_isintr_copperhead(ips_ha_t *);
276 static int ips_isintr_copperhead_memio(ips_ha_t *);
277 static int ips_isintr_morpheus(ips_ha_t *);
278 static int ips_wait(ips_ha_t *, int, int);
279 static int ips_write_driver_status(ips_ha_t *, int);
280 static int ips_read_adapter_status(ips_ha_t *, int);
281 static int ips_read_subsystem_parameters(ips_ha_t *, int);
282 static int ips_read_config(ips_ha_t *, int);
283 static int ips_clear_adapter(ips_ha_t *, int);
284 static int ips_readwrite_page5(ips_ha_t *, int, int);
285 static int ips_init_copperhead(ips_ha_t *);
286 static int ips_init_copperhead_memio(ips_ha_t *);
287 static int ips_init_morpheus(ips_ha_t *);
288 static int ips_isinit_copperhead(ips_ha_t *);
289 static int ips_isinit_copperhead_memio(ips_ha_t *);
290 static int ips_isinit_morpheus(ips_ha_t *);
291 static int ips_erase_bios(ips_ha_t *);
292 static int ips_program_bios(ips_ha_t *, char *, uint32_t, uint32_t);
293 static int ips_verify_bios(ips_ha_t *, char *, uint32_t, uint32_t);
294 static int ips_erase_bios_memio(ips_ha_t *);
295 static int ips_program_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
296 static int ips_verify_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
297 static int ips_flash_copperhead(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
298 static int ips_flash_bios(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
299 static int ips_flash_firmware(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
300 static void ips_free_flash_copperhead(ips_ha_t * ha);
301 static void ips_get_bios_version(ips_ha_t *, int);
302 static void ips_identify_controller(ips_ha_t *);
303 static void ips_chkstatus(ips_ha_t *, IPS_STATUS *);
304 static void ips_enable_int_copperhead(ips_ha_t *);
305 static void ips_enable_int_copperhead_memio(ips_ha_t *);
306 static void ips_enable_int_morpheus(ips_ha_t *);
307 static int ips_intr_copperhead(ips_ha_t *);
308 static int ips_intr_morpheus(ips_ha_t *);
309 static void ips_next(ips_ha_t *, int);
310 static void ipsintr_blocking(ips_ha_t *, struct ips_scb *);
311 static void ipsintr_done(ips_ha_t *, struct ips_scb *);
312 static void ips_done(ips_ha_t *, ips_scb_t *);
313 static void ips_free(ips_ha_t *);
314 static void ips_init_scb(ips_ha_t *, ips_scb_t *);
315 static void ips_freescb(ips_ha_t *, ips_scb_t *);
316 static void ips_setup_funclist(ips_ha_t *);
317 static void ips_statinit(ips_ha_t *);
318 static void ips_statinit_memio(ips_ha_t *);
319 static void ips_fix_ffdc_time(ips_ha_t *, ips_scb_t *, time_t);
320 static void ips_ffdc_reset(ips_ha_t *, int);
321 static void ips_ffdc_time(ips_ha_t *);
322 static uint32_t ips_statupd_copperhead(ips_ha_t *);
323 static uint32_t ips_statupd_copperhead_memio(ips_ha_t *);
324 static uint32_t ips_statupd_morpheus(ips_ha_t *);
325 static ips_scb_t *ips_getscb(ips_ha_t *);
326 static void ips_putq_scb_head(ips_scb_queue_t *, ips_scb_t *);
327 static void ips_putq_wait_tail(ips_wait_queue_t *, Scsi_Cmnd *);
328 static void ips_putq_copp_tail(ips_copp_queue_t *,
329 ips_copp_wait_item_t *);
330 static ips_scb_t *ips_removeq_scb_head(ips_scb_queue_t *);
331 static ips_scb_t *ips_removeq_scb(ips_scb_queue_t *, ips_scb_t *);
332 static Scsi_Cmnd *ips_removeq_wait_head(ips_wait_queue_t *);
333 static Scsi_Cmnd *ips_removeq_wait(ips_wait_queue_t *, Scsi_Cmnd *);
334 static ips_copp_wait_item_t *ips_removeq_copp(ips_copp_queue_t *,
335 ips_copp_wait_item_t *);
336 static ips_copp_wait_item_t *ips_removeq_copp_head(ips_copp_queue_t *);
338 static int ips_is_passthru(Scsi_Cmnd *);
339 static int ips_make_passthru(ips_ha_t *, Scsi_Cmnd *, ips_scb_t *, int);
340 static int ips_usrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
341 static void ips_cleanup_passthru(ips_ha_t *, ips_scb_t *);
342 static void ips_scmd_buf_write(Scsi_Cmnd * scmd, void *data,
344 static void ips_scmd_buf_read(Scsi_Cmnd * scmd, void *data, unsigned int count);
346 static int ips_proc_info(struct Scsi_Host *, char *, char **, off_t, int, int);
347 static int ips_host_info(ips_ha_t *, char *, off_t, int);
348 static void copy_mem_info(IPS_INFOSTR *, char *, int);
349 static int copy_info(IPS_INFOSTR *, char *, ...);
350 static int ips_get_version_info(ips_ha_t * ha, dma_addr_t, int intr);
351 static void ips_version_check(ips_ha_t * ha, int intr);
352 static int ips_abort_init(ips_ha_t * ha, int index);
353 static int ips_init_phase2(int index);
355 static int ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr);
356 static int ips_register_scsi(int index);
358 static int ips_poll_for_flush_complete(ips_ha_t * ha);
359 static void ips_flush_and_reset(ips_ha_t *ha);
364 static const char ips_name[] = "ips";
365 static struct Scsi_Host *ips_sh[IPS_MAX_ADAPTERS]; /* Array of host controller structures */
366 static ips_ha_t *ips_ha[IPS_MAX_ADAPTERS]; /* Array of HA structures */
367 static unsigned int ips_next_controller;
368 static unsigned int ips_num_controllers;
369 static unsigned int ips_released_controllers;
370 static int ips_hotplug;
371 static int ips_cmd_timeout = 60;
372 static int ips_reset_timeout = 60 * 5;
373 static int ips_force_memio = 1; /* Always use Memory Mapped I/O */
374 static int ips_force_i2o = 1; /* Always use I2O command delivery */
375 static int ips_ioctlsize = IPS_IOCTL_SIZE; /* Size of the ioctl buffer */
376 static int ips_cd_boot; /* Booting from Manager CD */
377 static char *ips_FlashData = NULL; /* CD Boot - Flash Data Buffer */
378 static dma_addr_t ips_flashbusaddr;
379 static long ips_FlashDataInUse; /* CD Boot - Flash Data In Use Flag */
380 static uint32_t MaxLiteCmds = 32; /* Max Active Cmds for a Lite Adapter */
381 static Scsi_Host_Template ips_driver_template = {
382 .detect = ips_detect,
383 .release = ips_release,
385 .queuecommand = ips_queue,
386 .eh_abort_handler = ips_eh_abort,
387 .eh_host_reset_handler = ips_eh_reset,
389 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
390 .proc_info = ips_proc_info,
391 .slave_configure = ips_slave_configure,
393 .proc_info = ips_proc24_info,
394 .select_queue_depths = ips_select_queue_depth,
396 .bios_param = ips_biosparam,
398 .sg_tablesize = IPS_MAX_SG,
400 .use_clustering = ENABLE_CLUSTERING,
401 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
402 .use_new_eh_code = 1,
404 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20) && LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
409 static IPS_DEFINE_COMPAT_TABLE( Compatable ); /* Version Compatability Table */
412 /* This table describes all ServeRAID Adapters */
413 static struct pci_device_id ips_pci_table[] = {
414 { 0x1014, 0x002E, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
415 { 0x1014, 0x01BD, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
416 { 0x9005, 0x0250, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
420 MODULE_DEVICE_TABLE( pci, ips_pci_table );
422 static char ips_hot_plug_name[] = "ips";
424 static int __devinit ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent);
425 static void __devexit ips_remove_device(struct pci_dev *pci_dev);
427 static struct pci_driver ips_pci_driver = {
428 .name = ips_hot_plug_name,
429 .id_table = ips_pci_table,
430 .probe = ips_insert_device,
431 .remove = __devexit_p(ips_remove_device),
436 * Necessary forward function protoypes
438 static int ips_halt(struct notifier_block *nb, ulong event, void *buf);
440 #define MAX_ADAPTER_NAME 15
442 static char ips_adapter_name[][30] = {
445 "ServeRAID on motherboard",
446 "ServeRAID on motherboard",
463 static struct notifier_block ips_notifier = {
470 static char ips_command_direction[] = {
471 IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT,
472 IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK,
473 IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
474 IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
475 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_OUT,
476 IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
477 IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_IN,
478 IPS_DATA_UNK, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
479 IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_UNK,
480 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
481 IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE,
482 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
483 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT,
484 IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_NONE,
485 IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,
486 IPS_DATA_NONE, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
487 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
488 IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
489 IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
490 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
491 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
492 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
493 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
494 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
495 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
496 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
497 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
498 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
499 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
500 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
501 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
502 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
503 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
504 IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_NONE,
505 IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_OUT,
506 IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_NONE,
507 IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN,
508 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
509 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
510 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
511 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
512 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
513 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
514 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
515 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
516 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
517 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_OUT,
518 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
519 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
520 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
521 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK
525 /****************************************************************************/
527 /* Routine Name: ips_setup */
529 /* Routine Description: */
531 /* setup parameters to the driver */
533 /****************************************************************************/
535 ips_setup(char *ips_str)
541 IPS_OPTION options[] = {
542 {"noi2o", &ips_force_i2o, 0},
543 {"nommap", &ips_force_memio, 0},
544 {"ioctlsize", &ips_ioctlsize, IPS_IOCTL_SIZE},
545 {"cdboot", &ips_cd_boot, 0},
546 {"maxcmds", &MaxLiteCmds, 32},
549 /* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
550 /* Search for value */
551 while ((key = strsep(&ips_str, ",."))) {
554 value = strchr(key, ':');
558 * We now have key/value pairs.
559 * Update the variables
561 for (i = 0; i < (sizeof (options) / sizeof (options[0])); i++) {
563 (key, options[i].option_name,
564 strlen(options[i].option_name)) == 0) {
566 *options[i].option_flag =
567 simple_strtoul(value, NULL, 0);
569 *options[i].option_flag =
570 options[i].option_value;
579 __setup("ips=", ips_setup);
581 /****************************************************************************/
583 /* Routine Name: ips_detect */
585 /* Routine Description: */
587 /* Detect and initialize the driver */
589 /* NOTE: this routine is called under the io_request_lock spinlock */
591 /****************************************************************************/
593 ips_detect(Scsi_Host_Template * SHT)
597 METHOD_TRACE("ips_detect", 1);
604 for (i = 0; i < ips_num_controllers; i++) {
605 if (ips_register_scsi(i))
607 ips_released_controllers++;
610 return (ips_num_controllers);
613 /****************************************************************************/
614 /* configure the function pointers to use the functions that will work */
615 /* with the found version of the adapter */
616 /****************************************************************************/
618 ips_setup_funclist(ips_ha_t * ha)
624 if (IPS_IS_MORPHEUS(ha) || IPS_IS_MARCO(ha)) {
625 /* morpheus / marco / sebring */
626 ha->func.isintr = ips_isintr_morpheus;
627 ha->func.isinit = ips_isinit_morpheus;
628 ha->func.issue = ips_issue_i2o_memio;
629 ha->func.init = ips_init_morpheus;
630 ha->func.statupd = ips_statupd_morpheus;
631 ha->func.reset = ips_reset_morpheus;
632 ha->func.intr = ips_intr_morpheus;
633 ha->func.enableint = ips_enable_int_morpheus;
634 } else if (IPS_USE_MEMIO(ha)) {
635 /* copperhead w/MEMIO */
636 ha->func.isintr = ips_isintr_copperhead_memio;
637 ha->func.isinit = ips_isinit_copperhead_memio;
638 ha->func.init = ips_init_copperhead_memio;
639 ha->func.statupd = ips_statupd_copperhead_memio;
640 ha->func.statinit = ips_statinit_memio;
641 ha->func.reset = ips_reset_copperhead_memio;
642 ha->func.intr = ips_intr_copperhead;
643 ha->func.erasebios = ips_erase_bios_memio;
644 ha->func.programbios = ips_program_bios_memio;
645 ha->func.verifybios = ips_verify_bios_memio;
646 ha->func.enableint = ips_enable_int_copperhead_memio;
647 if (IPS_USE_I2O_DELIVER(ha))
648 ha->func.issue = ips_issue_i2o_memio;
650 ha->func.issue = ips_issue_copperhead_memio;
653 ha->func.isintr = ips_isintr_copperhead;
654 ha->func.isinit = ips_isinit_copperhead;
655 ha->func.init = ips_init_copperhead;
656 ha->func.statupd = ips_statupd_copperhead;
657 ha->func.statinit = ips_statinit;
658 ha->func.reset = ips_reset_copperhead;
659 ha->func.intr = ips_intr_copperhead;
660 ha->func.erasebios = ips_erase_bios;
661 ha->func.programbios = ips_program_bios;
662 ha->func.verifybios = ips_verify_bios;
663 ha->func.enableint = ips_enable_int_copperhead;
665 if (IPS_USE_I2O_DELIVER(ha))
666 ha->func.issue = ips_issue_i2o;
668 ha->func.issue = ips_issue_copperhead;
672 /****************************************************************************/
674 /* Routine Name: ips_release */
676 /* Routine Description: */
678 /* Remove a driver */
680 /****************************************************************************/
682 ips_release(struct Scsi_Host *sh)
688 METHOD_TRACE("ips_release", 1);
690 for (i = 0; i < IPS_MAX_ADAPTERS && ips_sh[i] != sh; i++) ;
692 if (i == IPS_MAX_ADAPTERS) {
694 "(%s) release, invalid Scsi_Host pointer.\n", ips_name);
704 /* flush the cache on the controller */
705 scb = &ha->scbs[ha->max_cmds - 1];
707 ips_init_scb(ha, scb);
709 scb->timeout = ips_cmd_timeout;
710 scb->cdb[0] = IPS_CMD_FLUSH;
712 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
713 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
714 scb->cmd.flush_cache.state = IPS_NORM_STATE;
715 scb->cmd.flush_cache.reserved = 0;
716 scb->cmd.flush_cache.reserved2 = 0;
717 scb->cmd.flush_cache.reserved3 = 0;
718 scb->cmd.flush_cache.reserved4 = 0;
720 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
723 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
724 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Incomplete Flush.\n");
726 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Complete.\n");
731 /* free extra memory */
734 /* Free I/O Region */
736 release_region(ha->io_addr, ha->io_len);
739 free_irq(ha->irq, ha);
744 ips_released_controllers++;
749 /****************************************************************************/
751 /* Routine Name: ips_halt */
753 /* Routine Description: */
755 /* Perform cleanup when the system reboots */
757 /****************************************************************************/
759 ips_halt(struct notifier_block *nb, ulong event, void *buf)
765 if ((event != SYS_RESTART) && (event != SYS_HALT) &&
766 (event != SYS_POWER_OFF))
767 return (NOTIFY_DONE);
769 for (i = 0; i < ips_next_controller; i++) {
770 ha = (ips_ha_t *) ips_ha[i];
778 /* flush the cache on the controller */
779 scb = &ha->scbs[ha->max_cmds - 1];
781 ips_init_scb(ha, scb);
783 scb->timeout = ips_cmd_timeout;
784 scb->cdb[0] = IPS_CMD_FLUSH;
786 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
787 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
788 scb->cmd.flush_cache.state = IPS_NORM_STATE;
789 scb->cmd.flush_cache.reserved = 0;
790 scb->cmd.flush_cache.reserved2 = 0;
791 scb->cmd.flush_cache.reserved3 = 0;
792 scb->cmd.flush_cache.reserved4 = 0;
794 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
797 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) ==
799 IPS_PRINTK(KERN_WARNING, ha->pcidev,
800 "Incomplete Flush.\n");
802 IPS_PRINTK(KERN_WARNING, ha->pcidev,
803 "Flushing Complete.\n");
809 /****************************************************************************/
811 /* Routine Name: ips_eh_abort */
813 /* Routine Description: */
815 /* Abort a command (using the new error code stuff) */
816 /* Note: this routine is called under the io_request_lock */
817 /****************************************************************************/
819 ips_eh_abort(Scsi_Cmnd * SC)
822 ips_copp_wait_item_t *item;
824 unsigned long cpu_flags;
825 struct Scsi_Host *host;
827 METHOD_TRACE("ips_eh_abort", 1);
832 host = SC->device->host;
833 ha = (ips_ha_t *) SC->device->host->hostdata;
841 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
843 /* See if the command is on the copp queue */
844 item = ha->copp_waitlist.head;
845 while ((item) && (item->scsi_cmd != SC))
850 ips_removeq_copp(&ha->copp_waitlist, item);
853 /* See if the command is on the wait queue */
854 } else if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
855 /* command not sent yet */
858 /* command must have already been sent */
862 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
866 /****************************************************************************/
868 /* Routine Name: ips_eh_reset */
870 /* Routine Description: */
872 /* Reset the controller (with new eh error code) */
874 /* NOTE: this routine is called under the io_request_lock spinlock */
876 /****************************************************************************/
878 __ips_eh_reset(Scsi_Cmnd * SC)
884 ips_copp_wait_item_t *item;
886 METHOD_TRACE("ips_eh_reset", 1);
893 DEBUG(1, "Reset called with NULL scsi command");
898 ha = (ips_ha_t *) SC->device->host->hostdata;
901 DEBUG(1, "Reset called with NULL ha struct");
909 /* See if the command is on the copp queue */
910 item = ha->copp_waitlist.head;
911 while ((item) && (item->scsi_cmd != SC))
916 ips_removeq_copp(&ha->copp_waitlist, item);
920 /* See if the command is on the wait queue */
921 if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
922 /* command not sent yet */
926 /* An explanation for the casual observer: */
927 /* Part of the function of a RAID controller is automatic error */
928 /* detection and recovery. As such, the only problem that physically */
929 /* resetting an adapter will ever fix is when, for some reason, */
930 /* the driver is not successfully communicating with the adapter. */
931 /* Therefore, we will attempt to flush this adapter. If that succeeds, */
932 /* then there's no real purpose in a physical reset. This will complete */
933 /* much faster and avoids any problems that might be caused by a */
934 /* physical reset ( such as having to fail all the outstanding I/O's ). */
936 if (ha->ioctl_reset == 0) { /* IF Not an IOCTL Requested Reset */
937 scb = &ha->scbs[ha->max_cmds - 1];
939 ips_init_scb(ha, scb);
941 scb->timeout = ips_cmd_timeout;
942 scb->cdb[0] = IPS_CMD_FLUSH;
944 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
945 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
946 scb->cmd.flush_cache.state = IPS_NORM_STATE;
947 scb->cmd.flush_cache.reserved = 0;
948 scb->cmd.flush_cache.reserved2 = 0;
949 scb->cmd.flush_cache.reserved3 = 0;
950 scb->cmd.flush_cache.reserved4 = 0;
952 /* Attempt the flush command */
953 ret = ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_IORL);
954 if (ret == IPS_SUCCESS) {
955 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
956 "Reset Request - Flushed Cache\n");
961 /* Either we can't communicate with the adapter or it's an IOCTL request */
962 /* from a utility. A physical reset is needed at this point. */
964 ha->ioctl_reset = 0; /* Reset the IOCTL Requested Reset Flag */
967 * command must have already been sent
968 * reset the controller
970 IPS_PRINTK(KERN_NOTICE, ha->pcidev, "Resetting controller.\n");
971 ret = (*ha->func.reset) (ha);
976 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
977 "Controller reset failed - controller now offline.\n");
979 /* Now fail all of the active commands */
980 DEBUG_VAR(1, "(%s%d) Failing active commands",
981 ips_name, ha->host_num);
983 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
984 scb->scsi_cmd->result = DID_ERROR << 16;
985 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
986 ips_freescb(ha, scb);
989 /* Now fail all of the pending commands */
990 DEBUG_VAR(1, "(%s%d) Failing pending commands",
991 ips_name, ha->host_num);
993 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
994 scsi_cmd->result = DID_ERROR;
995 scsi_cmd->scsi_done(scsi_cmd);
1002 if (!ips_clear_adapter(ha, IPS_INTR_IORL)) {
1003 Scsi_Cmnd *scsi_cmd;
1005 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
1006 "Controller reset failed - controller now offline.\n");
1008 /* Now fail all of the active commands */
1009 DEBUG_VAR(1, "(%s%d) Failing active commands",
1010 ips_name, ha->host_num);
1012 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
1013 scb->scsi_cmd->result = DID_ERROR << 16;
1014 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1015 ips_freescb(ha, scb);
1018 /* Now fail all of the pending commands */
1019 DEBUG_VAR(1, "(%s%d) Failing pending commands",
1020 ips_name, ha->host_num);
1022 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
1023 scsi_cmd->result = DID_ERROR << 16;
1024 scsi_cmd->scsi_done(scsi_cmd);
1032 if (le32_to_cpu(ha->subsys->param[3]) & 0x300000) {
1035 do_gettimeofday(&tv);
1036 ha->last_ffdc = tv.tv_sec;
1038 ips_ffdc_reset(ha, IPS_INTR_IORL);
1041 /* Now fail all of the active commands */
1042 DEBUG_VAR(1, "(%s%d) Failing active commands", ips_name, ha->host_num);
1044 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
1045 scb->scsi_cmd->result =
1046 (DID_RESET << 16) | (SUGGEST_RETRY << 24);
1047 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1048 ips_freescb(ha, scb);
1051 /* Reset DCDB active command bits */
1052 for (i = 1; i < ha->nbus; i++)
1053 ha->dcdb_active[i - 1] = 0;
1055 /* Reset the number of active IOCTLs */
1058 ips_next(ha, IPS_INTR_IORL);
1061 #endif /* NO_IPS_RESET */
1066 ips_eh_reset(Scsi_Cmnd * SC)
1070 spin_lock_irq(SC->device->host->host_lock);
1071 rc = __ips_eh_reset(SC);
1072 spin_unlock_irq(SC->device->host->host_lock);
1077 /****************************************************************************/
1079 /* Routine Name: ips_queue */
1081 /* Routine Description: */
1083 /* Send a command to the controller */
1086 /* Linux obtains io_request_lock before calling this function */
1088 /****************************************************************************/
1090 ips_queue(Scsi_Cmnd * SC, void (*done) (Scsi_Cmnd *))
1095 METHOD_TRACE("ips_queue", 1);
1097 ha = (ips_ha_t *) SC->device->host->hostdata;
1105 if (ips_is_passthru(SC)) {
1106 if (ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
1107 SC->result = DID_BUS_BUSY << 16;
1112 } else if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
1113 SC->result = DID_BUS_BUSY << 16;
1119 SC->scsi_done = done;
1121 DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
1125 SC->device->channel, SC->device->id, SC->device->lun);
1127 /* Check for command to initiator IDs */
1128 if ((scmd_channel(SC) > 0)
1129 && (scmd_id(SC) == ha->ha_id[scmd_channel(SC)])) {
1130 SC->result = DID_NO_CONNECT << 16;
1136 if (ips_is_passthru(SC)) {
1138 ips_copp_wait_item_t *scratch;
1140 /* A Reset IOCTL is only sent by the boot CD in extreme cases. */
1141 /* There can never be any system activity ( network or disk ), but check */
1142 /* anyway just as a good practice. */
1143 pt = (ips_passthru_t *) SC->request_buffer;
1144 if ((pt->CoppCP.cmd.reset.op_code == IPS_CMD_RESET_CHANNEL) &&
1145 (pt->CoppCP.cmd.reset.adapter_flag == 1)) {
1146 if (ha->scb_activelist.count != 0) {
1147 SC->result = DID_BUS_BUSY << 16;
1151 ha->ioctl_reset = 1; /* This reset request is from an IOCTL */
1153 SC->result = DID_OK << 16;
1158 /* allocate space for the scribble */
1159 scratch = kmalloc(sizeof (ips_copp_wait_item_t), GFP_ATOMIC);
1162 SC->result = DID_ERROR << 16;
1168 scratch->scsi_cmd = SC;
1169 scratch->next = NULL;
1171 ips_putq_copp_tail(&ha->copp_waitlist, scratch);
1173 ips_putq_wait_tail(&ha->scb_waitlist, SC);
1176 ips_next(ha, IPS_INTR_IORL);
1181 /****************************************************************************/
1183 /* Routine Name: ips_biosparam */
1185 /* Routine Description: */
1187 /* Set bios geometry for the controller */
1189 /****************************************************************************/
1191 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1192 ips_biosparam(Disk * disk, kdev_t dev, int geom[])
1194 ips_ha_t *ha = (ips_ha_t *) disk->device->host->hostdata;
1195 unsigned long capacity = disk->capacity;
1197 ips_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1198 sector_t capacity, int geom[])
1200 ips_ha_t *ha = (ips_ha_t *) sdev->host->hostdata;
1206 METHOD_TRACE("ips_biosparam", 1);
1209 /* ?!?! host adater info invalid */
1215 if (!ips_read_adapter_status(ha, IPS_INTR_ON))
1216 /* ?!?! Enquiry command failed */
1219 if ((capacity > 0x400000) && ((ha->enq->ucMiscFlag & 0x8) == 0)) {
1220 heads = IPS_NORM_HEADS;
1221 sectors = IPS_NORM_SECTORS;
1223 heads = IPS_COMP_HEADS;
1224 sectors = IPS_COMP_SECTORS;
1227 cylinders = (unsigned long) capacity / (heads * sectors);
1229 DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
1230 heads, sectors, cylinders);
1234 geom[2] = cylinders;
1239 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1241 /* ips_proc24_info is a wrapper around ips_proc_info *
1242 * for compatibility with the 2.4 scsi parameters */
1244 ips_proc24_info(char *buffer, char **start, off_t offset, int length,
1245 int hostno, int func)
1249 for (i = 0; i < ips_next_controller; i++) {
1250 if (ips_sh[i] && ips_sh[i]->host_no == hostno) {
1251 return ips_proc_info(ips_sh[i], buffer, start,
1252 offset, length, func);
1258 /****************************************************************************/
1260 /* Routine Name: ips_select_queue_depth */
1262 /* Routine Description: */
1264 /* Select queue depths for the devices on the contoller */
1266 /****************************************************************************/
1268 ips_select_queue_depth(struct Scsi_Host *host, Scsi_Device * scsi_devs)
1270 Scsi_Device *device;
1276 min = ha->max_cmds / 4;
1278 for (device = scsi_devs; device; device = device->next) {
1279 if (device->host == host) {
1280 if ((device->channel == 0) && (device->type == 0))
1285 for (device = scsi_devs; device; device = device->next) {
1286 if (device->host == host) {
1287 if ((device->channel == 0) && (device->type == 0)) {
1288 device->queue_depth =
1289 (ha->max_cmds - 1) / count;
1290 if (device->queue_depth < min)
1291 device->queue_depth = min;
1293 device->queue_depth = 2;
1296 if (device->queue_depth < 2)
1297 device->queue_depth = 2;
1303 /****************************************************************************/
1305 /* Routine Name: ips_slave_configure */
1307 /* Routine Description: */
1309 /* Set queue depths on devices once scan is complete */
1311 /****************************************************************************/
1313 ips_slave_configure(Scsi_Device * SDptr)
1318 ha = IPS_HA(SDptr->host);
1319 if (SDptr->tagged_supported && SDptr->type == TYPE_DISK) {
1320 min = ha->max_cmds / 2;
1321 if (ha->enq->ucLogDriveCount <= 2)
1322 min = ha->max_cmds - 1;
1323 scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, min);
1329 /****************************************************************************/
1331 /* Routine Name: do_ipsintr */
1333 /* Routine Description: */
1335 /* Wrapper for the interrupt handler */
1337 /****************************************************************************/
1339 do_ipsintr(int irq, void *dev_id, struct pt_regs * regs)
1342 unsigned long cpu_flags;
1343 struct Scsi_Host *host;
1346 METHOD_TRACE("do_ipsintr", 2);
1348 ha = (ips_ha_t *) dev_id;
1351 host = ips_sh[ha->host_num];
1352 /* interrupt during initialization */
1354 (*ha->func.intr) (ha);
1358 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
1361 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1365 irqstatus = (*ha->func.intr) (ha);
1367 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1369 /* start the next command */
1370 ips_next(ha, IPS_INTR_ON);
1371 return IRQ_RETVAL(irqstatus);
1374 /****************************************************************************/
1376 /* Routine Name: ips_intr_copperhead */
1378 /* Routine Description: */
1380 /* Polling interrupt handler */
1382 /* ASSUMES interrupts are disabled */
1384 /****************************************************************************/
1386 ips_intr_copperhead(ips_ha_t * ha)
1393 METHOD_TRACE("ips_intr", 2);
1401 intrstatus = (*ha->func.isintr) (ha);
1405 * Unexpected/Shared interrupt
1414 intrstatus = (*ha->func.isintr) (ha);
1419 cstatus.value = (*ha->func.statupd) (ha);
1421 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1422 /* Spurious Interupt ? */
1426 ips_chkstatus(ha, &cstatus);
1427 scb = (ips_scb_t *) sp->scb_addr;
1430 * use the callback function to finish things up
1431 * NOTE: interrupts are OFF for this
1433 (*scb->callback) (ha, scb);
1438 /****************************************************************************/
1440 /* Routine Name: ips_intr_morpheus */
1442 /* Routine Description: */
1444 /* Polling interrupt handler */
1446 /* ASSUMES interrupts are disabled */
1448 /****************************************************************************/
1450 ips_intr_morpheus(ips_ha_t * ha)
1457 METHOD_TRACE("ips_intr_morpheus", 2);
1465 intrstatus = (*ha->func.isintr) (ha);
1469 * Unexpected/Shared interrupt
1478 intrstatus = (*ha->func.isintr) (ha);
1483 cstatus.value = (*ha->func.statupd) (ha);
1485 if (cstatus.value == 0xffffffff)
1486 /* No more to process */
1489 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1490 IPS_PRINTK(KERN_WARNING, ha->pcidev,
1491 "Spurious interrupt; no ccb.\n");
1496 ips_chkstatus(ha, &cstatus);
1497 scb = (ips_scb_t *) sp->scb_addr;
1500 * use the callback function to finish things up
1501 * NOTE: interrupts are OFF for this
1503 (*scb->callback) (ha, scb);
1508 /****************************************************************************/
1510 /* Routine Name: ips_info */
1512 /* Routine Description: */
1514 /* Return info about the driver */
1516 /****************************************************************************/
1518 ips_info(struct Scsi_Host *SH)
1520 static char buffer[256];
1524 METHOD_TRACE("ips_info", 1);
1532 memset(bp, 0, sizeof (buffer));
1534 sprintf(bp, "%s%s%s Build %d", "IBM PCI ServeRAID ",
1535 IPS_VERSION_HIGH, IPS_VERSION_LOW, IPS_BUILD_IDENT);
1537 if (ha->ad_type > 0 && ha->ad_type <= MAX_ADAPTER_NAME) {
1539 strcat(bp, ips_adapter_name[ha->ad_type - 1]);
1546 /****************************************************************************/
1548 /* Routine Name: ips_proc_info */
1550 /* Routine Description: */
1552 /* The passthru interface for the driver */
1554 /****************************************************************************/
1556 ips_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
1557 int length, int func)
1561 ips_ha_t *ha = NULL;
1563 METHOD_TRACE("ips_proc_info", 1);
1565 /* Find our host structure */
1566 for (i = 0; i < ips_next_controller; i++) {
1568 if (ips_sh[i] == host) {
1569 ha = (ips_ha_t *) ips_sh[i]->hostdata;
1586 ret = ips_host_info(ha, buffer, offset, length);
1592 /*--------------------------------------------------------------------------*/
1593 /* Helper Functions */
1594 /*--------------------------------------------------------------------------*/
1596 /****************************************************************************/
1598 /* Routine Name: ips_is_passthru */
1600 /* Routine Description: */
1602 /* Determine if the specified SCSI command is really a passthru command */
1604 /****************************************************************************/
1606 ips_is_passthru(Scsi_Cmnd * SC)
1608 unsigned long flags;
1610 METHOD_TRACE("ips_is_passthru", 1);
1615 if ((SC->cmnd[0] == IPS_IOCTL_COMMAND) &&
1616 (SC->device->channel == 0) &&
1617 (SC->device->id == IPS_ADAPTER_ID) &&
1618 (SC->device->lun == 0) && SC->request_buffer) {
1619 if ((!SC->use_sg) && SC->request_bufflen &&
1620 (((char *) SC->request_buffer)[0] == 'C') &&
1621 (((char *) SC->request_buffer)[1] == 'O') &&
1622 (((char *) SC->request_buffer)[2] == 'P') &&
1623 (((char *) SC->request_buffer)[3] == 'P'))
1625 else if (SC->use_sg) {
1626 struct scatterlist *sg = SC->request_buffer;
1629 /* kmap_atomic() ensures addressability of the user buffer.*/
1630 /* local_irq_save() protects the KM_IRQ0 address slot. */
1631 local_irq_save(flags);
1632 buffer = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1633 if (buffer && buffer[0] == 'C' && buffer[1] == 'O' &&
1634 buffer[2] == 'P' && buffer[3] == 'P') {
1635 kunmap_atomic(buffer - sg->offset, KM_IRQ0);
1636 local_irq_restore(flags);
1639 kunmap_atomic(buffer - sg->offset, KM_IRQ0);
1640 local_irq_restore(flags);
1646 /****************************************************************************/
1648 /* Routine Name: ips_alloc_passthru_buffer */
1650 /* Routine Description: */
1651 /* allocate a buffer large enough for the ioctl data if the ioctl buffer */
1652 /* is too small or doesn't exist */
1653 /****************************************************************************/
1655 ips_alloc_passthru_buffer(ips_ha_t * ha, int length)
1658 dma_addr_t dma_busaddr;
1660 if (ha->ioctl_data && length <= ha->ioctl_len)
1662 /* there is no buffer or it's not big enough, allocate a new one */
1663 bigger_buf = pci_alloc_consistent(ha->pcidev, length, &dma_busaddr);
1665 /* free the old memory */
1666 pci_free_consistent(ha->pcidev, ha->ioctl_len, ha->ioctl_data,
1668 /* use the new memory */
1669 ha->ioctl_data = (char *) bigger_buf;
1670 ha->ioctl_len = length;
1671 ha->ioctl_busaddr = dma_busaddr;
1678 /****************************************************************************/
1680 /* Routine Name: ips_make_passthru */
1682 /* Routine Description: */
1684 /* Make a passthru command out of the info in the Scsi block */
1686 /****************************************************************************/
1688 ips_make_passthru(ips_ha_t * ha, Scsi_Cmnd * SC, ips_scb_t * scb, int intr)
1694 METHOD_TRACE("ips_make_passthru", 1);
1697 length = SC->request_bufflen;
1699 struct scatterlist *sg = SC->request_buffer;
1701 for (i = 0; i < SC->use_sg; i++)
1702 length += sg[i].length;
1704 if (length < sizeof (ips_passthru_t)) {
1706 DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
1707 ips_name, ha->host_num);
1708 return (IPS_FAILURE);
1710 if (ips_alloc_passthru_buffer(ha, length)) {
1711 /* allocation failure! If ha->ioctl_data exists, use it to return
1712 some error codes. Return a failed command to the scsi layer. */
1713 if (ha->ioctl_data) {
1714 pt = (ips_passthru_t *) ha->ioctl_data;
1715 ips_scmd_buf_read(SC, pt, sizeof (ips_passthru_t));
1716 pt->BasicStatus = 0x0B;
1717 pt->ExtendedStatus = 0x00;
1718 ips_scmd_buf_write(SC, pt, sizeof (ips_passthru_t));
1722 ha->ioctl_datasize = length;
1724 ips_scmd_buf_read(SC, ha->ioctl_data, ha->ioctl_datasize);
1725 pt = (ips_passthru_t *) ha->ioctl_data;
1728 * Some notes about the passthru interface used
1730 * IF the scsi op_code == 0x0d then we assume
1731 * that the data came along with/goes with the
1732 * packet we received from the sg driver. In this
1733 * case the CmdBSize field of the pt structure is
1734 * used for the size of the buffer.
1737 switch (pt->CoppCmd) {
1739 memcpy(ha->ioctl_data + sizeof (ips_passthru_t),
1740 &ips_num_controllers, sizeof (int));
1741 ips_scmd_buf_write(SC, ha->ioctl_data,
1742 sizeof (ips_passthru_t) + sizeof (int));
1743 SC->result = DID_OK << 16;
1745 return (IPS_SUCCESS_IMM);
1747 case IPS_COPPUSRCMD:
1748 case IPS_COPPIOCCMD:
1749 if (SC->cmnd[0] == IPS_IOCTL_COMMAND) {
1750 if (length < (sizeof (ips_passthru_t) + pt->CmdBSize)) {
1753 "(%s%d) Passthru structure wrong size",
1754 ips_name, ha->host_num);
1756 return (IPS_FAILURE);
1759 if (ha->device_id == IPS_DEVICEID_COPPERHEAD &&
1760 pt->CoppCP.cmd.flashfw.op_code ==
1761 IPS_CMD_RW_BIOSFW) {
1762 ret = ips_flash_copperhead(ha, pt, scb);
1763 ips_scmd_buf_write(SC, ha->ioctl_data,
1764 sizeof (ips_passthru_t));
1767 if (ips_usrcmd(ha, pt, scb))
1768 return (IPS_SUCCESS);
1770 return (IPS_FAILURE);
1777 return (IPS_FAILURE);
1780 /****************************************************************************/
1781 /* Routine Name: ips_flash_copperhead */
1782 /* Routine Description: */
1783 /* Flash the BIOS/FW on a Copperhead style controller */
1784 /****************************************************************************/
1786 ips_flash_copperhead(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1790 /* Trombone is the only copperhead that can do packet flash, but only
1791 * for firmware. No one said it had to make sence. */
1792 if (IPS_IS_TROMBONE(ha) && pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE) {
1793 if (ips_usrcmd(ha, pt, scb))
1798 pt->BasicStatus = 0x0B;
1799 pt->ExtendedStatus = 0;
1800 scb->scsi_cmd->result = DID_OK << 16;
1801 /* IF it's OK to Use the "CD BOOT" Flash Buffer, then you can */
1802 /* avoid allocating a huge buffer per adapter ( which can fail ). */
1803 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1804 pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1805 pt->BasicStatus = 0;
1806 return ips_flash_bios(ha, pt, scb);
1807 } else if (pt->CoppCP.cmd.flashfw.packet_num == 0) {
1808 if (ips_FlashData && !test_and_set_bit(0, &ips_FlashDataInUse)){
1809 ha->flash_data = ips_FlashData;
1810 ha->flash_busaddr = ips_flashbusaddr;
1811 ha->flash_len = PAGE_SIZE << 7;
1812 ha->flash_datasize = 0;
1813 } else if (!ha->flash_data) {
1814 datasize = pt->CoppCP.cmd.flashfw.total_packets *
1815 pt->CoppCP.cmd.flashfw.count;
1816 ha->flash_data = pci_alloc_consistent(ha->pcidev,
1818 &ha->flash_busaddr);
1819 if (!ha->flash_data){
1820 printk(KERN_WARNING "Unable to allocate a flash buffer\n");
1823 ha->flash_datasize = 0;
1824 ha->flash_len = datasize;
1828 if (pt->CoppCP.cmd.flashfw.count + ha->flash_datasize >
1830 ips_free_flash_copperhead(ha);
1831 IPS_PRINTK(KERN_WARNING, ha->pcidev,
1832 "failed size sanity check\n");
1836 if (!ha->flash_data)
1838 pt->BasicStatus = 0;
1839 memcpy(&ha->flash_data[ha->flash_datasize], pt + 1,
1840 pt->CoppCP.cmd.flashfw.count);
1841 ha->flash_datasize += pt->CoppCP.cmd.flashfw.count;
1842 if (pt->CoppCP.cmd.flashfw.packet_num ==
1843 pt->CoppCP.cmd.flashfw.total_packets - 1) {
1844 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE)
1845 return ips_flash_bios(ha, pt, scb);
1846 else if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE)
1847 return ips_flash_firmware(ha, pt, scb);
1849 return IPS_SUCCESS_IMM;
1852 /****************************************************************************/
1853 /* Routine Name: ips_flash_bios */
1854 /* Routine Description: */
1855 /* flashes the bios of a copperhead adapter */
1856 /****************************************************************************/
1858 ips_flash_bios(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1861 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1862 pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_BIOS) {
1863 if ((!ha->func.programbios) || (!ha->func.erasebios) ||
1864 (!ha->func.verifybios))
1866 if ((*ha->func.erasebios) (ha)) {
1868 "(%s%d) flash bios failed - unable to erase flash",
1869 ips_name, ha->host_num);
1872 if ((*ha->func.programbios) (ha,
1875 ha->flash_datasize -
1876 IPS_BIOS_HEADER, 0)) {
1878 "(%s%d) flash bios failed - unable to flash",
1879 ips_name, ha->host_num);
1882 if ((*ha->func.verifybios) (ha,
1885 ha->flash_datasize -
1886 IPS_BIOS_HEADER, 0)) {
1888 "(%s%d) flash bios failed - unable to verify flash",
1889 ips_name, ha->host_num);
1892 ips_free_flash_copperhead(ha);
1893 return IPS_SUCCESS_IMM;
1894 } else if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1895 pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1896 if (!ha->func.erasebios)
1898 if ((*ha->func.erasebios) (ha)) {
1900 "(%s%d) flash bios failed - unable to erase flash",
1901 ips_name, ha->host_num);
1904 return IPS_SUCCESS_IMM;
1907 pt->BasicStatus = 0x0B;
1908 pt->ExtendedStatus = 0x00;
1909 ips_free_flash_copperhead(ha);
1913 /****************************************************************************/
1915 /* Routine Name: ips_fill_scb_sg_single */
1917 /* Routine Description: */
1918 /* Fill in a single scb sg_list element from an address */
1919 /* return a -1 if a breakup occurred */
1920 /****************************************************************************/
1922 ips_fill_scb_sg_single(ips_ha_t * ha, dma_addr_t busaddr,
1923 ips_scb_t * scb, int indx, unsigned int e_len)
1928 if ((scb->data_len + e_len) > ha->max_xfer) {
1929 e_len = ha->max_xfer - scb->data_len;
1930 scb->breakup = indx;
1937 if (IPS_USE_ENH_SGLIST(ha)) {
1938 scb->sg_list.enh_list[indx].address_lo =
1939 cpu_to_le32(pci_dma_lo32(busaddr));
1940 scb->sg_list.enh_list[indx].address_hi =
1941 cpu_to_le32(pci_dma_hi32(busaddr));
1942 scb->sg_list.enh_list[indx].length = cpu_to_le32(e_len);
1944 scb->sg_list.std_list[indx].address =
1945 cpu_to_le32(pci_dma_lo32(busaddr));
1946 scb->sg_list.std_list[indx].length = cpu_to_le32(e_len);
1950 scb->data_len += e_len;
1954 /****************************************************************************/
1955 /* Routine Name: ips_flash_firmware */
1956 /* Routine Description: */
1957 /* flashes the firmware of a copperhead adapter */
1958 /****************************************************************************/
1960 ips_flash_firmware(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1962 IPS_SG_LIST sg_list;
1963 uint32_t cmd_busaddr;
1965 if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE &&
1966 pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_FW) {
1967 memset(&pt->CoppCP.cmd, 0, sizeof (IPS_HOST_COMMAND));
1968 pt->CoppCP.cmd.flashfw.op_code = IPS_CMD_DOWNLOAD;
1969 pt->CoppCP.cmd.flashfw.count = cpu_to_le32(ha->flash_datasize);
1971 pt->BasicStatus = 0x0B;
1972 pt->ExtendedStatus = 0x00;
1973 ips_free_flash_copperhead(ha);
1976 /* Save the S/G list pointer so it doesn't get clobbered */
1977 sg_list.list = scb->sg_list.list;
1978 cmd_busaddr = scb->scb_busaddr;
1979 /* copy in the CP */
1980 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1981 /* FIX stuff that might be wrong */
1982 scb->sg_list.list = sg_list.list;
1983 scb->scb_busaddr = cmd_busaddr;
1984 scb->bus = scb->scsi_cmd->device->channel;
1985 scb->target_id = scb->scsi_cmd->device->id;
1986 scb->lun = scb->scsi_cmd->device->lun;
1991 scb->callback = ipsintr_done;
1992 scb->timeout = ips_cmd_timeout;
1994 scb->data_len = ha->flash_datasize;
1996 pci_map_single(ha->pcidev, ha->flash_data, scb->data_len,
1998 scb->flags |= IPS_SCB_MAP_SINGLE;
1999 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
2000 scb->cmd.flashfw.buffer_addr = cpu_to_le32(scb->data_busaddr);
2002 scb->timeout = pt->TimeOut;
2003 scb->scsi_cmd->result = DID_OK << 16;
2007 /****************************************************************************/
2008 /* Routine Name: ips_free_flash_copperhead */
2009 /* Routine Description: */
2010 /* release the memory resources used to hold the flash image */
2011 /****************************************************************************/
2013 ips_free_flash_copperhead(ips_ha_t * ha)
2015 if (ha->flash_data == ips_FlashData)
2016 test_and_clear_bit(0, &ips_FlashDataInUse);
2017 else if (ha->flash_data)
2018 pci_free_consistent(ha->pcidev, ha->flash_len, ha->flash_data,
2020 ha->flash_data = NULL;
2023 /****************************************************************************/
2025 /* Routine Name: ips_usrcmd */
2027 /* Routine Description: */
2029 /* Process a user command and make it ready to send */
2031 /****************************************************************************/
2033 ips_usrcmd(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
2035 IPS_SG_LIST sg_list;
2036 uint32_t cmd_busaddr;
2038 METHOD_TRACE("ips_usrcmd", 1);
2040 if ((!scb) || (!pt) || (!ha))
2043 /* Save the S/G list pointer so it doesn't get clobbered */
2044 sg_list.list = scb->sg_list.list;
2045 cmd_busaddr = scb->scb_busaddr;
2046 /* copy in the CP */
2047 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
2048 memcpy(&scb->dcdb, &pt->CoppCP.dcdb, sizeof (IPS_DCDB_TABLE));
2050 /* FIX stuff that might be wrong */
2051 scb->sg_list.list = sg_list.list;
2052 scb->scb_busaddr = cmd_busaddr;
2053 scb->bus = scb->scsi_cmd->device->channel;
2054 scb->target_id = scb->scsi_cmd->device->id;
2055 scb->lun = scb->scsi_cmd->device->lun;
2060 scb->callback = ipsintr_done;
2061 scb->timeout = ips_cmd_timeout;
2062 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
2064 /* we don't support DCDB/READ/WRITE Scatter Gather */
2065 if ((scb->cmd.basic_io.op_code == IPS_CMD_READ_SG) ||
2066 (scb->cmd.basic_io.op_code == IPS_CMD_WRITE_SG) ||
2067 (scb->cmd.basic_io.op_code == IPS_CMD_DCDB_SG))
2071 scb->data_len = pt->CmdBSize;
2072 scb->data_busaddr = ha->ioctl_busaddr + sizeof (ips_passthru_t);
2074 scb->data_busaddr = 0L;
2077 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
2078 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
2079 (unsigned long) &scb->
2081 (unsigned long) scb);
2084 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
2085 scb->dcdb.buffer_pointer =
2086 cpu_to_le32(scb->data_busaddr);
2088 scb->cmd.basic_io.sg_addr =
2089 cpu_to_le32(scb->data_busaddr);
2094 scb->timeout = pt->TimeOut;
2096 if (pt->TimeOut <= 10)
2097 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;
2098 else if (pt->TimeOut <= 60)
2099 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;
2101 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
2104 /* assume success */
2105 scb->scsi_cmd->result = DID_OK << 16;
2111 /****************************************************************************/
2113 /* Routine Name: ips_cleanup_passthru */
2115 /* Routine Description: */
2117 /* Cleanup after a passthru command */
2119 /****************************************************************************/
2121 ips_cleanup_passthru(ips_ha_t * ha, ips_scb_t * scb)
2125 METHOD_TRACE("ips_cleanup_passthru", 1);
2127 if ((!scb) || (!scb->scsi_cmd) || (!scb->scsi_cmd->request_buffer)) {
2128 DEBUG_VAR(1, "(%s%d) couldn't cleanup after passthru",
2129 ips_name, ha->host_num);
2133 pt = (ips_passthru_t *) ha->ioctl_data;
2135 /* Copy data back to the user */
2136 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB) /* Copy DCDB Back to Caller's Area */
2137 memcpy(&pt->CoppCP.dcdb, &scb->dcdb, sizeof (IPS_DCDB_TABLE));
2139 pt->BasicStatus = scb->basic_status;
2140 pt->ExtendedStatus = scb->extended_status;
2141 pt->AdapterType = ha->ad_type;
2143 if (ha->device_id == IPS_DEVICEID_COPPERHEAD &&
2144 (scb->cmd.flashfw.op_code == IPS_CMD_DOWNLOAD ||
2145 scb->cmd.flashfw.op_code == IPS_CMD_RW_BIOSFW))
2146 ips_free_flash_copperhead(ha);
2148 ips_scmd_buf_write(scb->scsi_cmd, ha->ioctl_data, ha->ioctl_datasize);
2151 /****************************************************************************/
2153 /* Routine Name: ips_host_info */
2155 /* Routine Description: */
2157 /* The passthru interface for the driver */
2159 /****************************************************************************/
2161 ips_host_info(ips_ha_t * ha, char *ptr, off_t offset, int len)
2165 METHOD_TRACE("ips_host_info", 1);
2169 info.offset = offset;
2173 copy_info(&info, "\nIBM ServeRAID General Information:\n\n");
2175 if ((le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) &&
2176 (le16_to_cpu(ha->nvram->adapter_type) != 0))
2177 copy_info(&info, "\tController Type : %s\n",
2178 ips_adapter_name[ha->ad_type - 1]);
2181 "\tController Type : Unknown\n");
2185 "\tIO region : 0x%lx (%d bytes)\n",
2186 ha->io_addr, ha->io_len);
2190 "\tMemory region : 0x%lx (%d bytes)\n",
2191 ha->mem_addr, ha->mem_len);
2193 "\tShared memory address : 0x%lx\n",
2197 copy_info(&info, "\tIRQ number : %d\n", ha->irq);
2199 /* For the Next 3 lines Check for Binary 0 at the end and don't include it if it's there. */
2200 /* That keeps everything happy for "text" operations on the proc file. */
2202 if (le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) {
2203 if (ha->nvram->bios_low[3] == 0) {
2205 "\tBIOS Version : %c%c%c%c%c%c%c\n",
2206 ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2207 ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2208 ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2209 ha->nvram->bios_low[2]);
2213 "\tBIOS Version : %c%c%c%c%c%c%c%c\n",
2214 ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2215 ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2216 ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2217 ha->nvram->bios_low[2], ha->nvram->bios_low[3]);
2222 if (ha->enq->CodeBlkVersion[7] == 0) {
2224 "\tFirmware Version : %c%c%c%c%c%c%c\n",
2225 ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2226 ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2227 ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2228 ha->enq->CodeBlkVersion[6]);
2231 "\tFirmware Version : %c%c%c%c%c%c%c%c\n",
2232 ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2233 ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2234 ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2235 ha->enq->CodeBlkVersion[6], ha->enq->CodeBlkVersion[7]);
2238 if (ha->enq->BootBlkVersion[7] == 0) {
2240 "\tBoot Block Version : %c%c%c%c%c%c%c\n",
2241 ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2242 ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2243 ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2244 ha->enq->BootBlkVersion[6]);
2247 "\tBoot Block Version : %c%c%c%c%c%c%c%c\n",
2248 ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2249 ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2250 ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2251 ha->enq->BootBlkVersion[6], ha->enq->BootBlkVersion[7]);
2254 copy_info(&info, "\tDriver Version : %s%s\n",
2255 IPS_VERSION_HIGH, IPS_VERSION_LOW);
2257 copy_info(&info, "\tDriver Build : %d\n",
2260 copy_info(&info, "\tMax Physical Devices : %d\n",
2261 ha->enq->ucMaxPhysicalDevices);
2262 copy_info(&info, "\tMax Active Commands : %d\n",
2264 copy_info(&info, "\tCurrent Queued Commands : %d\n",
2265 ha->scb_waitlist.count);
2266 copy_info(&info, "\tCurrent Active Commands : %d\n",
2267 ha->scb_activelist.count - ha->num_ioctl);
2268 copy_info(&info, "\tCurrent Queued PT Commands : %d\n",
2269 ha->copp_waitlist.count);
2270 copy_info(&info, "\tCurrent Active PT Commands : %d\n",
2273 copy_info(&info, "\n");
2275 return (info.localpos);
2278 /****************************************************************************/
2280 /* Routine Name: copy_mem_info */
2282 /* Routine Description: */
2284 /* Copy data into an IPS_INFOSTR structure */
2286 /****************************************************************************/
2288 copy_mem_info(IPS_INFOSTR * info, char *data, int len)
2290 METHOD_TRACE("copy_mem_info", 1);
2292 if (info->pos + len < info->offset) {
2297 if (info->pos < info->offset) {
2298 data += (info->offset - info->pos);
2299 len -= (info->offset - info->pos);
2300 info->pos += (info->offset - info->pos);
2303 if (info->localpos + len > info->length)
2304 len = info->length - info->localpos;
2307 memcpy(info->buffer + info->localpos, data, len);
2309 info->localpos += len;
2313 /****************************************************************************/
2315 /* Routine Name: copy_info */
2317 /* Routine Description: */
2319 /* printf style wrapper for an info structure */
2321 /****************************************************************************/
2323 copy_info(IPS_INFOSTR * info, char *fmt, ...)
2329 METHOD_TRACE("copy_info", 1);
2331 va_start(args, fmt);
2332 len = vsprintf(buf, fmt, args);
2335 copy_mem_info(info, buf, len);
2340 /****************************************************************************/
2342 /* Routine Name: ips_identify_controller */
2344 /* Routine Description: */
2346 /* Identify this controller */
2348 /****************************************************************************/
2350 ips_identify_controller(ips_ha_t * ha)
2352 METHOD_TRACE("ips_identify_controller", 1);
2354 switch (ha->device_id) {
2355 case IPS_DEVICEID_COPPERHEAD:
2356 if (ha->revision_id <= IPS_REVID_SERVERAID) {
2357 ha->ad_type = IPS_ADTYPE_SERVERAID;
2358 } else if (ha->revision_id == IPS_REVID_SERVERAID2) {
2359 ha->ad_type = IPS_ADTYPE_SERVERAID2;
2360 } else if (ha->revision_id == IPS_REVID_NAVAJO) {
2361 ha->ad_type = IPS_ADTYPE_NAVAJO;
2362 } else if ((ha->revision_id == IPS_REVID_SERVERAID2)
2363 && (ha->slot_num == 0)) {
2364 ha->ad_type = IPS_ADTYPE_KIOWA;
2365 } else if ((ha->revision_id >= IPS_REVID_CLARINETP1) &&
2366 (ha->revision_id <= IPS_REVID_CLARINETP3)) {
2367 if (ha->enq->ucMaxPhysicalDevices == 15)
2368 ha->ad_type = IPS_ADTYPE_SERVERAID3L;
2370 ha->ad_type = IPS_ADTYPE_SERVERAID3;
2371 } else if ((ha->revision_id >= IPS_REVID_TROMBONE32) &&
2372 (ha->revision_id <= IPS_REVID_TROMBONE64)) {
2373 ha->ad_type = IPS_ADTYPE_SERVERAID4H;
2377 case IPS_DEVICEID_MORPHEUS:
2378 switch (ha->subdevice_id) {
2379 case IPS_SUBDEVICEID_4L:
2380 ha->ad_type = IPS_ADTYPE_SERVERAID4L;
2383 case IPS_SUBDEVICEID_4M:
2384 ha->ad_type = IPS_ADTYPE_SERVERAID4M;
2387 case IPS_SUBDEVICEID_4MX:
2388 ha->ad_type = IPS_ADTYPE_SERVERAID4MX;
2391 case IPS_SUBDEVICEID_4LX:
2392 ha->ad_type = IPS_ADTYPE_SERVERAID4LX;
2395 case IPS_SUBDEVICEID_5I2:
2396 ha->ad_type = IPS_ADTYPE_SERVERAID5I2;
2399 case IPS_SUBDEVICEID_5I1:
2400 ha->ad_type = IPS_ADTYPE_SERVERAID5I1;
2406 case IPS_DEVICEID_MARCO:
2407 switch (ha->subdevice_id) {
2408 case IPS_SUBDEVICEID_6M:
2409 ha->ad_type = IPS_ADTYPE_SERVERAID6M;
2411 case IPS_SUBDEVICEID_6I:
2412 ha->ad_type = IPS_ADTYPE_SERVERAID6I;
2414 case IPS_SUBDEVICEID_7k:
2415 ha->ad_type = IPS_ADTYPE_SERVERAID7k;
2417 case IPS_SUBDEVICEID_7M:
2418 ha->ad_type = IPS_ADTYPE_SERVERAID7M;
2425 /****************************************************************************/
2427 /* Routine Name: ips_get_bios_version */
2429 /* Routine Description: */
2431 /* Get the BIOS revision number */
2433 /****************************************************************************/
2435 ips_get_bios_version(ips_ha_t * ha, int intr)
2444 { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
2447 METHOD_TRACE("ips_get_bios_version", 1);
2452 strncpy(ha->bios_version, " ?", 8);
2454 if (ha->device_id == IPS_DEVICEID_COPPERHEAD) {
2455 if (IPS_USE_MEMIO(ha)) {
2456 /* Memory Mapped I/O */
2459 writel(0, ha->mem_ptr + IPS_REG_FLAP);
2460 if (ha->revision_id == IPS_REVID_TROMBONE64)
2461 udelay(25); /* 25 us */
2463 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
2466 writel(1, ha->mem_ptr + IPS_REG_FLAP);
2467 if (ha->revision_id == IPS_REVID_TROMBONE64)
2468 udelay(25); /* 25 us */
2470 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
2473 /* Get Major version */
2474 writel(0x1FF, ha->mem_ptr + IPS_REG_FLAP);
2475 if (ha->revision_id == IPS_REVID_TROMBONE64)
2476 udelay(25); /* 25 us */
2478 major = readb(ha->mem_ptr + IPS_REG_FLDP);
2480 /* Get Minor version */
2481 writel(0x1FE, ha->mem_ptr + IPS_REG_FLAP);
2482 if (ha->revision_id == IPS_REVID_TROMBONE64)
2483 udelay(25); /* 25 us */
2484 minor = readb(ha->mem_ptr + IPS_REG_FLDP);
2486 /* Get SubMinor version */
2487 writel(0x1FD, ha->mem_ptr + IPS_REG_FLAP);
2488 if (ha->revision_id == IPS_REVID_TROMBONE64)
2489 udelay(25); /* 25 us */
2490 subminor = readb(ha->mem_ptr + IPS_REG_FLDP);
2493 /* Programmed I/O */
2496 outl(0, ha->io_addr + IPS_REG_FLAP);
2497 if (ha->revision_id == IPS_REVID_TROMBONE64)
2498 udelay(25); /* 25 us */
2500 if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
2503 outl(cpu_to_le32(1), ha->io_addr + IPS_REG_FLAP);
2504 if (ha->revision_id == IPS_REVID_TROMBONE64)
2505 udelay(25); /* 25 us */
2507 if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
2510 /* Get Major version */
2511 outl(cpu_to_le32(0x1FF), ha->io_addr + IPS_REG_FLAP);
2512 if (ha->revision_id == IPS_REVID_TROMBONE64)
2513 udelay(25); /* 25 us */
2515 major = inb(ha->io_addr + IPS_REG_FLDP);
2517 /* Get Minor version */
2518 outl(cpu_to_le32(0x1FE), ha->io_addr + IPS_REG_FLAP);
2519 if (ha->revision_id == IPS_REVID_TROMBONE64)
2520 udelay(25); /* 25 us */
2522 minor = inb(ha->io_addr + IPS_REG_FLDP);
2524 /* Get SubMinor version */
2525 outl(cpu_to_le32(0x1FD), ha->io_addr + IPS_REG_FLAP);
2526 if (ha->revision_id == IPS_REVID_TROMBONE64)
2527 udelay(25); /* 25 us */
2529 subminor = inb(ha->io_addr + IPS_REG_FLDP);
2533 /* Morpheus Family - Send Command to the card */
2535 buffer = ha->ioctl_data;
2537 memset(buffer, 0, 0x1000);
2539 scb = &ha->scbs[ha->max_cmds - 1];
2541 ips_init_scb(ha, scb);
2543 scb->timeout = ips_cmd_timeout;
2544 scb->cdb[0] = IPS_CMD_RW_BIOSFW;
2546 scb->cmd.flashfw.op_code = IPS_CMD_RW_BIOSFW;
2547 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
2548 scb->cmd.flashfw.type = 1;
2549 scb->cmd.flashfw.direction = 0;
2550 scb->cmd.flashfw.count = cpu_to_le32(0x800);
2551 scb->cmd.flashfw.total_packets = 1;
2552 scb->cmd.flashfw.packet_num = 0;
2553 scb->data_len = 0x1000;
2554 scb->cmd.flashfw.buffer_addr = ha->ioctl_busaddr;
2556 /* issue the command */
2558 ips_send_wait(ha, scb, ips_cmd_timeout,
2559 intr)) == IPS_FAILURE)
2560 || (ret == IPS_SUCCESS_IMM)
2561 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
2562 /* Error occurred */
2567 if ((buffer[0xC0] == 0x55) && (buffer[0xC1] == 0xAA)) {
2568 major = buffer[0x1ff + 0xC0]; /* Offset 0x1ff after the header (0xc0) */
2569 minor = buffer[0x1fe + 0xC0]; /* Offset 0x1fe after the header (0xc0) */
2570 subminor = buffer[0x1fd + 0xC0]; /* Offset 0x1fd after the header (0xc0) */
2576 ha->bios_version[0] = hexDigits[(major & 0xF0) >> 4];
2577 ha->bios_version[1] = '.';
2578 ha->bios_version[2] = hexDigits[major & 0x0F];
2579 ha->bios_version[3] = hexDigits[subminor];
2580 ha->bios_version[4] = '.';
2581 ha->bios_version[5] = hexDigits[(minor & 0xF0) >> 4];
2582 ha->bios_version[6] = hexDigits[minor & 0x0F];
2583 ha->bios_version[7] = 0;
2586 /****************************************************************************/
2588 /* Routine Name: ips_hainit */
2590 /* Routine Description: */
2592 /* Initialize the controller */
2594 /* NOTE: Assumes to be called from with a lock */
2596 /****************************************************************************/
2598 ips_hainit(ips_ha_t * ha)
2603 METHOD_TRACE("ips_hainit", 1);
2608 if (ha->func.statinit)
2609 (*ha->func.statinit) (ha);
2611 if (ha->func.enableint)
2612 (*ha->func.enableint) (ha);
2615 ha->reset_count = 1;
2616 do_gettimeofday(&tv);
2617 ha->last_ffdc = tv.tv_sec;
2618 ips_ffdc_reset(ha, IPS_INTR_IORL);
2620 if (!ips_read_config(ha, IPS_INTR_IORL)) {
2621 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2622 "unable to read config from controller.\n");
2627 if (!ips_read_adapter_status(ha, IPS_INTR_IORL)) {
2628 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2629 "unable to read controller status.\n");
2634 /* Identify this controller */
2635 ips_identify_controller(ha);
2637 if (!ips_read_subsystem_parameters(ha, IPS_INTR_IORL)) {
2638 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2639 "unable to read subsystem parameters.\n");
2644 /* write nvram user page 5 */
2645 if (!ips_write_driver_status(ha, IPS_INTR_IORL)) {
2646 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2647 "unable to write driver info to controller.\n");
2652 /* If there are Logical Drives and a Reset Occurred, then an EraseStripeLock is Needed */
2653 if ((ha->conf->ucLogDriveCount > 0) && (ha->requires_esl == 1))
2654 ips_clear_adapter(ha, IPS_INTR_IORL);
2656 /* set limits on SID, LUN, BUS */
2657 ha->ntargets = IPS_MAX_TARGETS + 1;
2659 ha->nbus = (ha->enq->ucMaxPhysicalDevices / IPS_MAX_TARGETS) + 1;
2661 switch (ha->conf->logical_drive[0].ucStripeSize) {
2663 ha->max_xfer = 0x10000;
2667 ha->max_xfer = 0x20000;
2671 ha->max_xfer = 0x40000;
2676 ha->max_xfer = 0x80000;
2680 /* setup max concurrent commands */
2681 if (le32_to_cpu(ha->subsys->param[4]) & 0x1) {
2682 /* Use the new method */
2683 ha->max_cmds = ha->enq->ucConcurrentCmdCount;
2685 /* use the old method */
2686 switch (ha->conf->logical_drive[0].ucStripeSize) {
2706 /* Limit the Active Commands on a Lite Adapter */
2707 if ((ha->ad_type == IPS_ADTYPE_SERVERAID3L) ||
2708 (ha->ad_type == IPS_ADTYPE_SERVERAID4L) ||
2709 (ha->ad_type == IPS_ADTYPE_SERVERAID4LX)) {
2710 if ((ha->max_cmds > MaxLiteCmds) && (MaxLiteCmds))
2711 ha->max_cmds = MaxLiteCmds;
2714 /* set controller IDs */
2715 ha->ha_id[0] = IPS_ADAPTER_ID;
2716 for (i = 1; i < ha->nbus; i++) {
2717 ha->ha_id[i] = ha->conf->init_id[i - 1] & 0x1f;
2718 ha->dcdb_active[i - 1] = 0;
2724 /****************************************************************************/
2726 /* Routine Name: ips_next */
2728 /* Routine Description: */
2730 /* Take the next command off the queue and send it to the controller */
2732 /****************************************************************************/
2734 ips_next(ips_ha_t * ha, int intr)
2740 ips_copp_wait_item_t *item;
2742 unsigned long cpu_flags = 0;
2743 struct Scsi_Host *host;
2744 METHOD_TRACE("ips_next", 1);
2748 host = ips_sh[ha->host_num];
2750 * Block access to the queue function so
2751 * this command won't time out
2753 if (intr == IPS_INTR_ON)
2754 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2756 if ((ha->subsys->param[3] & 0x300000)
2757 && (ha->scb_activelist.count == 0)) {
2760 do_gettimeofday(&tv);
2762 if (tv.tv_sec - ha->last_ffdc > IPS_SECS_8HOURS) {
2763 ha->last_ffdc = tv.tv_sec;
2769 * Send passthru commands
2770 * These have priority over normal I/O
2771 * but shouldn't affect performance too much
2772 * since we limit the number that can be active
2773 * on the card at any one time
2775 while ((ha->num_ioctl < IPS_MAX_IOCTL) &&
2776 (ha->copp_waitlist.head) && (scb = ips_getscb(ha))) {
2778 item = ips_removeq_copp_head(&ha->copp_waitlist);
2780 if (intr == IPS_INTR_ON)
2781 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2782 scb->scsi_cmd = item->scsi_cmd;
2785 ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
2787 if (intr == IPS_INTR_ON)
2788 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2791 if (scb->scsi_cmd) {
2792 scb->scsi_cmd->result = DID_ERROR << 16;
2793 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2796 ips_freescb(ha, scb);
2798 case IPS_SUCCESS_IMM:
2799 if (scb->scsi_cmd) {
2800 scb->scsi_cmd->result = DID_OK << 16;
2801 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2804 ips_freescb(ha, scb);
2810 if (ret != IPS_SUCCESS) {
2815 ret = ips_send_cmd(ha, scb);
2817 if (ret == IPS_SUCCESS)
2818 ips_putq_scb_head(&ha->scb_activelist, scb);
2824 if (scb->scsi_cmd) {
2825 scb->scsi_cmd->result = DID_ERROR << 16;
2828 ips_freescb(ha, scb);
2830 case IPS_SUCCESS_IMM:
2831 ips_freescb(ha, scb);
2840 * Send "Normal" I/O commands
2843 p = ha->scb_waitlist.head;
2844 while ((p) && (scb = ips_getscb(ha))) {
2845 if ((scmd_channel(p) > 0)
2847 dcdb_active[scmd_channel(p) -
2848 1] & (1 << scmd_id(p)))) {
2849 ips_freescb(ha, scb);
2850 p = (Scsi_Cmnd *) p->host_scribble;
2855 SC = ips_removeq_wait(&ha->scb_waitlist, q);
2857 if (intr == IPS_INTR_ON)
2858 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags); /* Unlock HA after command is taken off queue */
2860 SC->result = DID_OK;
2861 SC->host_scribble = NULL;
2863 memset(SC->sense_buffer, 0, sizeof (SC->sense_buffer));
2865 scb->target_id = SC->device->id;
2866 scb->lun = SC->device->lun;
2867 scb->bus = SC->device->channel;
2871 scb->callback = ipsintr_done;
2872 scb->timeout = ips_cmd_timeout;
2873 memset(&scb->cmd, 0, 16);
2875 /* copy in the CDB */
2876 memcpy(scb->cdb, SC->cmnd, SC->cmd_len);
2878 /* Now handle the data buffer */
2880 struct scatterlist *sg;
2883 sg = SC->request_buffer;
2884 scb->sg_count = pci_map_sg(ha->pcidev, sg, SC->use_sg,
2885 SC->sc_data_direction);
2886 scb->flags |= IPS_SCB_MAP_SG;
2887 for (i = 0; i < scb->sg_count; i++) {
2888 if (ips_fill_scb_sg_single
2889 (ha, sg_dma_address(&sg[i]), scb, i,
2890 sg_dma_len(&sg[i])) < 0)
2893 scb->dcdb.transfer_length = scb->data_len;
2895 if (SC->request_bufflen) {
2897 pci_map_single(ha->pcidev,
2899 SC->request_bufflen,
2900 SC->sc_data_direction);
2901 scb->flags |= IPS_SCB_MAP_SINGLE;
2902 ips_fill_scb_sg_single(ha, scb->data_busaddr,
2904 SC->request_bufflen);
2905 scb->dcdb.transfer_length = scb->data_len;
2907 scb->data_busaddr = 0L;
2910 scb->dcdb.transfer_length = 0;
2915 scb->dcdb.cmd_attribute =
2916 ips_command_direction[scb->scsi_cmd->cmnd[0]];
2918 /* Allow a WRITE BUFFER Command to Have no Data */
2919 /* This is Used by Tape Flash Utilites */
2920 if ((scb->scsi_cmd->cmnd[0] == WRITE_BUFFER) && (scb->data_len == 0))
2921 scb->dcdb.cmd_attribute = 0;
2923 if (!(scb->dcdb.cmd_attribute & 0x3))
2924 scb->dcdb.transfer_length = 0;
2926 if (scb->data_len >= IPS_MAX_XFER) {
2927 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
2928 scb->dcdb.transfer_length = 0;
2930 if (intr == IPS_INTR_ON)
2931 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2933 ret = ips_send_cmd(ha, scb);
2937 ips_putq_scb_head(&ha->scb_activelist, scb);
2940 if (scb->scsi_cmd) {
2941 scb->scsi_cmd->result = DID_ERROR << 16;
2942 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2946 ha->dcdb_active[scb->bus - 1] &=
2947 ~(1 << scb->target_id);
2949 ips_freescb(ha, scb);
2951 case IPS_SUCCESS_IMM:
2953 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2956 ha->dcdb_active[scb->bus - 1] &=
2957 ~(1 << scb->target_id);
2959 ips_freescb(ha, scb);
2965 p = (Scsi_Cmnd *) p->host_scribble;
2969 if (intr == IPS_INTR_ON)
2970 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2973 /****************************************************************************/
2975 /* Routine Name: ips_putq_scb_head */
2977 /* Routine Description: */
2979 /* Add an item to the head of the queue */
2981 /* ASSUMED to be called from within the HA lock */
2983 /****************************************************************************/
2985 ips_putq_scb_head(ips_scb_queue_t * queue, ips_scb_t * item)
2987 METHOD_TRACE("ips_putq_scb_head", 1);
2992 item->q_next = queue->head;
3001 /****************************************************************************/
3003 /* Routine Name: ips_removeq_scb_head */
3005 /* Routine Description: */
3007 /* Remove the head of the queue */
3009 /* ASSUMED to be called from within the HA lock */
3011 /****************************************************************************/
3013 ips_removeq_scb_head(ips_scb_queue_t * queue)
3017 METHOD_TRACE("ips_removeq_scb_head", 1);
3025 queue->head = item->q_next;
3026 item->q_next = NULL;
3028 if (queue->tail == item)
3036 /****************************************************************************/
3038 /* Routine Name: ips_removeq_scb */
3040 /* Routine Description: */
3042 /* Remove an item from a queue */
3044 /* ASSUMED to be called from within the HA lock */
3046 /****************************************************************************/
3048 ips_removeq_scb(ips_scb_queue_t * queue, ips_scb_t * item)
3052 METHOD_TRACE("ips_removeq_scb", 1);
3057 if (item == queue->head) {
3058 return (ips_removeq_scb_head(queue));
3063 while ((p) && (item != p->q_next))
3068 p->q_next = item->q_next;
3073 item->q_next = NULL;
3082 /****************************************************************************/
3084 /* Routine Name: ips_putq_wait_tail */
3086 /* Routine Description: */
3088 /* Add an item to the tail of the queue */
3090 /* ASSUMED to be called from within the HA lock */
3092 /****************************************************************************/
3094 ips_putq_wait_tail(ips_wait_queue_t * queue, Scsi_Cmnd * item)
3096 METHOD_TRACE("ips_putq_wait_tail", 1);
3101 item->host_scribble = NULL;
3104 queue->tail->host_scribble = (char *) item;
3114 /****************************************************************************/
3116 /* Routine Name: ips_removeq_wait_head */
3118 /* Routine Description: */
3120 /* Remove the head of the queue */
3122 /* ASSUMED to be called from within the HA lock */
3124 /****************************************************************************/
3126 ips_removeq_wait_head(ips_wait_queue_t * queue)
3130 METHOD_TRACE("ips_removeq_wait_head", 1);
3138 queue->head = (Scsi_Cmnd *) item->host_scribble;
3139 item->host_scribble = NULL;
3141 if (queue->tail == item)
3149 /****************************************************************************/
3151 /* Routine Name: ips_removeq_wait */
3153 /* Routine Description: */
3155 /* Remove an item from a queue */
3157 /* ASSUMED to be called from within the HA lock */
3159 /****************************************************************************/
3161 ips_removeq_wait(ips_wait_queue_t * queue, Scsi_Cmnd * item)
3165 METHOD_TRACE("ips_removeq_wait", 1);
3170 if (item == queue->head) {
3171 return (ips_removeq_wait_head(queue));
3176 while ((p) && (item != (Scsi_Cmnd *) p->host_scribble))
3177 p = (Scsi_Cmnd *) p->host_scribble;
3181 p->host_scribble = item->host_scribble;
3183 if (!item->host_scribble)
3186 item->host_scribble = NULL;
3195 /****************************************************************************/
3197 /* Routine Name: ips_putq_copp_tail */
3199 /* Routine Description: */
3201 /* Add an item to the tail of the queue */
3203 /* ASSUMED to be called from within the HA lock */
3205 /****************************************************************************/
3207 ips_putq_copp_tail(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3209 METHOD_TRACE("ips_putq_copp_tail", 1);
3217 queue->tail->next = item;
3227 /****************************************************************************/
3229 /* Routine Name: ips_removeq_copp_head */
3231 /* Routine Description: */
3233 /* Remove the head of the queue */
3235 /* ASSUMED to be called from within the HA lock */
3237 /****************************************************************************/
3238 static ips_copp_wait_item_t *
3239 ips_removeq_copp_head(ips_copp_queue_t * queue)
3241 ips_copp_wait_item_t *item;
3243 METHOD_TRACE("ips_removeq_copp_head", 1);
3251 queue->head = item->next;
3254 if (queue->tail == item)
3262 /****************************************************************************/
3264 /* Routine Name: ips_removeq_copp */
3266 /* Routine Description: */
3268 /* Remove an item from a queue */
3270 /* ASSUMED to be called from within the HA lock */
3272 /****************************************************************************/
3273 static ips_copp_wait_item_t *
3274 ips_removeq_copp(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3276 ips_copp_wait_item_t *p;
3278 METHOD_TRACE("ips_removeq_copp", 1);
3283 if (item == queue->head) {
3284 return (ips_removeq_copp_head(queue));
3289 while ((p) && (item != p->next))
3294 p->next = item->next;
3308 /****************************************************************************/
3310 /* Routine Name: ipsintr_blocking */
3312 /* Routine Description: */
3314 /* Finalize an interrupt for internal commands */
3316 /****************************************************************************/
3318 ipsintr_blocking(ips_ha_t * ha, ips_scb_t * scb)
3320 METHOD_TRACE("ipsintr_blocking", 2);
3322 ips_freescb(ha, scb);
3323 if ((ha->waitflag == TRUE) && (ha->cmd_in_progress == scb->cdb[0])) {
3324 ha->waitflag = FALSE;
3330 /****************************************************************************/
3332 /* Routine Name: ipsintr_done */
3334 /* Routine Description: */
3336 /* Finalize an interrupt for non-internal commands */
3338 /****************************************************************************/
3340 ipsintr_done(ips_ha_t * ha, ips_scb_t * scb)
3342 METHOD_TRACE("ipsintr_done", 2);
3345 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3346 "Spurious interrupt; scb NULL.\n");
3351 if (scb->scsi_cmd == NULL) {
3352 /* unexpected interrupt */
3353 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3354 "Spurious interrupt; scsi_cmd not set.\n");
3362 /****************************************************************************/
3364 /* Routine Name: ips_done */
3366 /* Routine Description: */
3368 /* Do housekeeping on completed commands */
3369 /* ASSUMED to be called form within the request lock */
3370 /****************************************************************************/
3372 ips_done(ips_ha_t * ha, ips_scb_t * scb)
3376 METHOD_TRACE("ips_done", 1);
3381 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd))) {
3382 ips_cleanup_passthru(ha, scb);
3386 * Check to see if this command had too much
3387 * data and had to be broke up. If so, queue
3388 * the rest of the data and continue.
3390 if ((scb->breakup) || (scb->sg_break)) {
3391 /* we had a data breakup */
3394 if (scb->sg_count) {
3396 struct scatterlist *sg;
3397 int ips_sg_index = 0;
3400 sg = scb->scsi_cmd->request_buffer;
3402 /* Spin forward to last dma chunk */
3403 sg_dma_index = scb->breakup;
3405 /* Take care of possible partial on last chunk */
3406 ips_fill_scb_sg_single(ha,
3409 scb, ips_sg_index++,
3413 for (; sg_dma_index < scb->sg_count;
3415 if (ips_fill_scb_sg_single
3417 sg_dma_address(&sg[sg_dma_index]),
3418 scb, ips_sg_index++,
3419 sg_dma_len(&sg[sg_dma_index])) < 0)
3425 /* Non S/G Request */
3426 (void) ips_fill_scb_sg_single(ha,
3438 scb->dcdb.transfer_length = scb->data_len;
3439 scb->dcdb.cmd_attribute |=
3440 ips_command_direction[scb->scsi_cmd->cmnd[0]];
3442 if (!(scb->dcdb.cmd_attribute & 0x3))
3443 scb->dcdb.transfer_length = 0;
3445 if (scb->data_len >= IPS_MAX_XFER) {
3446 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
3447 scb->dcdb.transfer_length = 0;
3450 ret = ips_send_cmd(ha, scb);
3454 if (scb->scsi_cmd) {
3455 scb->scsi_cmd->result = DID_ERROR << 16;
3456 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3459 ips_freescb(ha, scb);
3461 case IPS_SUCCESS_IMM:
3462 if (scb->scsi_cmd) {
3463 scb->scsi_cmd->result = DID_ERROR << 16;
3464 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3467 ips_freescb(ha, scb);
3475 } /* end if passthru */
3478 ha->dcdb_active[scb->bus - 1] &= ~(1 << scb->target_id);
3481 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3483 ips_freescb(ha, scb);
3486 /****************************************************************************/
3488 /* Routine Name: ips_map_status */
3490 /* Routine Description: */
3492 /* Map Controller Error codes to Linux Error Codes */
3494 /****************************************************************************/
3496 ips_map_status(ips_ha_t * ha, ips_scb_t * scb, ips_stat_t * sp)
3500 uint32_t transfer_len;
3501 IPS_DCDB_TABLE_TAPE *tapeDCDB;
3503 METHOD_TRACE("ips_map_status", 1);
3507 "(%s%d) Physical device error (%d %d %d): %x %x, Sense Key: %x, ASC: %x, ASCQ: %x",
3508 ips_name, ha->host_num,
3509 scb->scsi_cmd->device->channel,
3510 scb->scsi_cmd->device->id, scb->scsi_cmd->device->lun,
3511 scb->basic_status, scb->extended_status,
3512 scb->extended_status ==
3513 IPS_ERR_CKCOND ? scb->dcdb.sense_info[2] & 0xf : 0,
3514 scb->extended_status ==
3515 IPS_ERR_CKCOND ? scb->dcdb.sense_info[12] : 0,
3516 scb->extended_status ==
3517 IPS_ERR_CKCOND ? scb->dcdb.sense_info[13] : 0);
3520 /* default driver error */
3521 errcode = DID_ERROR;
3524 switch (scb->basic_status & IPS_GSC_STATUS_MASK) {
3525 case IPS_CMD_TIMEOUT:
3526 errcode = DID_TIME_OUT;
3529 case IPS_INVAL_OPCO:
3530 case IPS_INVAL_CMD_BLK:
3531 case IPS_INVAL_PARM_BLK:
3533 case IPS_CMD_CMPLT_WERROR:
3536 case IPS_PHYS_DRV_ERROR:
3537 switch (scb->extended_status) {
3538 case IPS_ERR_SEL_TO:
3540 errcode = DID_NO_CONNECT;
3544 case IPS_ERR_OU_RUN:
3545 if ((scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB) ||
3546 (scb->cmd.dcdb.op_code ==
3547 IPS_CMD_EXTENDED_DCDB_SG)) {
3548 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3549 transfer_len = tapeDCDB->transfer_length;
3552 (uint32_t) scb->dcdb.transfer_length;
3555 if ((scb->bus) && (transfer_len < scb->data_len)) {
3556 /* Underrun - set default to no error */
3559 /* Restrict access to physical DASD */
3560 if ((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
3561 ((((char *) scb->scsi_cmd->
3562 buffer)[0] & 0x1f) == TYPE_DISK)) {
3563 /* underflow -- no error */
3564 /* restrict access to physical DASD */
3565 errcode = DID_TIME_OUT;
3569 errcode = DID_ERROR;
3573 case IPS_ERR_RECOVERY:
3574 /* don't fail recovered errors */
3580 case IPS_ERR_HOST_RESET:
3581 case IPS_ERR_DEV_RESET:
3582 errcode = DID_RESET;
3585 case IPS_ERR_CKCOND:
3587 if ((scb->cmd.dcdb.op_code ==
3588 IPS_CMD_EXTENDED_DCDB)
3589 || (scb->cmd.dcdb.op_code ==
3590 IPS_CMD_EXTENDED_DCDB_SG)) {
3592 (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3593 memcpy(scb->scsi_cmd->sense_buffer,
3594 tapeDCDB->sense_info,
3595 sizeof (scb->scsi_cmd->
3598 memcpy(scb->scsi_cmd->sense_buffer,
3599 scb->dcdb.sense_info,
3600 sizeof (scb->scsi_cmd->
3603 device_error = 2; /* check condition */
3611 errcode = DID_ERROR;
3617 scb->scsi_cmd->result = device_error | (errcode << 16);
3622 /****************************************************************************/
3624 /* Routine Name: ips_send_wait */
3626 /* Routine Description: */
3628 /* Send a command to the controller and wait for it to return */
3630 /* The FFDC Time Stamp use this function for the callback, but doesn't */
3631 /* actually need to wait. */
3632 /****************************************************************************/
3634 ips_send_wait(ips_ha_t * ha, ips_scb_t * scb, int timeout, int intr)
3638 METHOD_TRACE("ips_send_wait", 1);
3640 if (intr != IPS_FFDC) { /* Won't be Waiting if this is a Time Stamp */
3641 ha->waitflag = TRUE;
3642 ha->cmd_in_progress = scb->cdb[0];
3644 scb->callback = ipsintr_blocking;
3645 ret = ips_send_cmd(ha, scb);
3647 if ((ret == IPS_FAILURE) || (ret == IPS_SUCCESS_IMM))
3650 if (intr != IPS_FFDC) /* Don't Wait around if this is a Time Stamp */
3651 ret = ips_wait(ha, timeout, intr);
3656 /****************************************************************************/
3658 /* Routine Name: ips_scmd_buf_write */
3660 /* Routine Description: */
3661 /* Write data to Scsi_Cmnd request_buffer at proper offsets */
3662 /****************************************************************************/
3664 ips_scmd_buf_write(Scsi_Cmnd * scmd, void *data, unsigned
3669 unsigned int min_cnt, xfer_cnt;
3670 char *cdata = (char *) data;
3671 unsigned char *buffer;
3672 unsigned long flags;
3673 struct scatterlist *sg = scmd->request_buffer;
3674 for (i = 0, xfer_cnt = 0;
3675 (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3676 min_cnt = min(count - xfer_cnt, sg[i].length);
3678 /* kmap_atomic() ensures addressability of the data buffer.*/
3679 /* local_irq_save() protects the KM_IRQ0 address slot. */
3680 local_irq_save(flags);
3681 buffer = kmap_atomic(sg[i].page, KM_IRQ0) + sg[i].offset;
3682 memcpy(buffer, &cdata[xfer_cnt], min_cnt);
3683 kunmap_atomic(buffer - sg[i].offset, KM_IRQ0);
3684 local_irq_restore(flags);
3686 xfer_cnt += min_cnt;
3690 unsigned int min_cnt = min(count, scmd->request_bufflen);
3691 memcpy(scmd->request_buffer, data, min_cnt);
3695 /****************************************************************************/
3697 /* Routine Name: ips_scmd_buf_read */
3699 /* Routine Description: */
3700 /* Copy data from a Scsi_Cmnd to a new, linear buffer */
3701 /****************************************************************************/
3703 ips_scmd_buf_read(Scsi_Cmnd * scmd, void *data, unsigned
3708 unsigned int min_cnt, xfer_cnt;
3709 char *cdata = (char *) data;
3710 unsigned char *buffer;
3711 unsigned long flags;
3712 struct scatterlist *sg = scmd->request_buffer;
3713 for (i = 0, xfer_cnt = 0;
3714 (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3715 min_cnt = min(count - xfer_cnt, sg[i].length);
3717 /* kmap_atomic() ensures addressability of the data buffer.*/
3718 /* local_irq_save() protects the KM_IRQ0 address slot. */
3719 local_irq_save(flags);
3720 buffer = kmap_atomic(sg[i].page, KM_IRQ0) + sg[i].offset;
3721 memcpy(&cdata[xfer_cnt], buffer, min_cnt);
3722 kunmap_atomic(buffer - sg[i].offset, KM_IRQ0);
3723 local_irq_restore(flags);
3725 xfer_cnt += min_cnt;
3729 unsigned int min_cnt = min(count, scmd->request_bufflen);
3730 memcpy(data, scmd->request_buffer, min_cnt);
3734 /****************************************************************************/
3736 /* Routine Name: ips_send_cmd */
3738 /* Routine Description: */
3740 /* Map SCSI commands to ServeRAID commands for logical drives */
3742 /****************************************************************************/
3744 ips_send_cmd(ips_ha_t * ha, ips_scb_t * scb)
3749 IPS_DCDB_TABLE_TAPE *tapeDCDB;
3752 METHOD_TRACE("ips_send_cmd", 1);
3756 if (!scb->scsi_cmd) {
3757 /* internal command */
3760 /* Controller commands can't be issued */
3761 /* to real devices -- fail them */
3762 if ((ha->waitflag == TRUE) &&
3763 (ha->cmd_in_progress == scb->cdb[0])) {
3764 ha->waitflag = FALSE;
3769 } else if ((scb->bus == 0) && (!ips_is_passthru(scb->scsi_cmd))) {
3770 /* command to logical bus -- interpret */
3771 ret = IPS_SUCCESS_IMM;
3773 switch (scb->scsi_cmd->cmnd[0]) {
3774 case ALLOW_MEDIUM_REMOVAL:
3777 case WRITE_FILEMARKS:
3779 scb->scsi_cmd->result = DID_ERROR << 16;
3783 scb->scsi_cmd->result = DID_OK << 16;
3785 case TEST_UNIT_READY:
3787 if (scb->target_id == IPS_ADAPTER_ID) {
3789 * Either we have a TUR
3790 * or we have a SCSI inquiry
3792 if (scb->scsi_cmd->cmnd[0] == TEST_UNIT_READY)
3793 scb->scsi_cmd->result = DID_OK << 16;
3795 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3796 IPS_SCSI_INQ_DATA inquiry;
3799 sizeof (IPS_SCSI_INQ_DATA));
3801 inquiry.DeviceType =
3802 IPS_SCSI_INQ_TYPE_PROCESSOR;
3803 inquiry.DeviceTypeQualifier =
3804 IPS_SCSI_INQ_LU_CONNECTED;
3805 inquiry.Version = IPS_SCSI_INQ_REV2;
3806 inquiry.ResponseDataFormat =
3807 IPS_SCSI_INQ_RD_REV2;
3808 inquiry.AdditionalLength = 31;
3810 IPS_SCSI_INQ_Address16;
3812 IPS_SCSI_INQ_WBus16 |
3814 strncpy(inquiry.VendorId, "IBM ",
3816 strncpy(inquiry.ProductId,
3818 strncpy(inquiry.ProductRevisionLevel,
3821 ips_scmd_buf_write(scb->scsi_cmd,
3825 scb->scsi_cmd->result = DID_OK << 16;
3828 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3829 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3830 scb->cmd.logical_info.reserved = 0;
3831 scb->cmd.logical_info.reserved2 = 0;
3832 scb->data_len = sizeof (IPS_LD_INFO);
3833 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3835 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3842 ips_reqsen(ha, scb);
3843 scb->scsi_cmd->result = DID_OK << 16;
3849 scb->cmd.basic_io.op_code =
3850 (scb->scsi_cmd->cmnd[0] ==
3851 READ_6) ? IPS_CMD_READ : IPS_CMD_WRITE;
3852 scb->cmd.basic_io.enhanced_sg = 0;
3853 scb->cmd.basic_io.sg_addr =
3854 cpu_to_le32(scb->data_busaddr);
3856 scb->cmd.basic_io.op_code =
3857 (scb->scsi_cmd->cmnd[0] ==
3858 READ_6) ? IPS_CMD_READ_SG :
3860 scb->cmd.basic_io.enhanced_sg =
3861 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3862 scb->cmd.basic_io.sg_addr =
3863 cpu_to_le32(scb->sg_busaddr);
3866 scb->cmd.basic_io.segment_4G = 0;
3867 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3868 scb->cmd.basic_io.log_drv = scb->target_id;
3869 scb->cmd.basic_io.sg_count = scb->sg_len;
3871 if (scb->cmd.basic_io.lba)
3872 scb->cmd.basic_io.lba =
3873 cpu_to_le32(le32_to_cpu
3874 (scb->cmd.basic_io.lba) +
3875 le16_to_cpu(scb->cmd.basic_io.
3878 scb->cmd.basic_io.lba =
3880 cmnd[1] & 0x1f) << 16) | (scb->scsi_cmd->
3882 (scb->scsi_cmd->cmnd[3]));
3884 scb->cmd.basic_io.sector_count =
3885 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3887 if (le16_to_cpu(scb->cmd.basic_io.sector_count) == 0)
3888 scb->cmd.basic_io.sector_count =
3897 scb->cmd.basic_io.op_code =
3898 (scb->scsi_cmd->cmnd[0] ==
3899 READ_10) ? IPS_CMD_READ : IPS_CMD_WRITE;
3900 scb->cmd.basic_io.enhanced_sg = 0;
3901 scb->cmd.basic_io.sg_addr =
3902 cpu_to_le32(scb->data_busaddr);
3904 scb->cmd.basic_io.op_code =
3905 (scb->scsi_cmd->cmnd[0] ==
3906 READ_10) ? IPS_CMD_READ_SG :
3908 scb->cmd.basic_io.enhanced_sg =
3909 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3910 scb->cmd.basic_io.sg_addr =
3911 cpu_to_le32(scb->sg_busaddr);
3914 scb->cmd.basic_io.segment_4G = 0;
3915 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3916 scb->cmd.basic_io.log_drv = scb->target_id;
3917 scb->cmd.basic_io.sg_count = scb->sg_len;
3919 if (scb->cmd.basic_io.lba)
3920 scb->cmd.basic_io.lba =
3921 cpu_to_le32(le32_to_cpu
3922 (scb->cmd.basic_io.lba) +
3923 le16_to_cpu(scb->cmd.basic_io.
3926 scb->cmd.basic_io.lba =
3927 ((scb->scsi_cmd->cmnd[2] << 24) | (scb->
3931 (scb->scsi_cmd->cmnd[4] << 8) | scb->
3934 scb->cmd.basic_io.sector_count =
3935 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3937 if (cpu_to_le16(scb->cmd.basic_io.sector_count) == 0) {
3939 * This is a null condition
3940 * we don't have to do anything
3943 scb->scsi_cmd->result = DID_OK << 16;
3951 scb->scsi_cmd->result = DID_OK << 16;
3955 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
3956 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3957 scb->cmd.basic_io.segment_4G = 0;
3958 scb->cmd.basic_io.enhanced_sg = 0;
3959 scb->data_len = sizeof (*ha->enq);
3960 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
3965 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3966 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3967 scb->cmd.logical_info.reserved = 0;
3968 scb->cmd.logical_info.reserved2 = 0;
3969 scb->cmd.logical_info.reserved3 = 0;
3970 scb->data_len = sizeof (IPS_LD_INFO);
3971 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3973 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3977 case SEND_DIAGNOSTIC:
3978 case REASSIGN_BLOCKS:
3982 case READ_DEFECT_DATA:
3985 scb->scsi_cmd->result = DID_OK << 16;
3989 /* Set the Return Info to appear like the Command was */
3990 /* attempted, a Check Condition occurred, and Sense */
3991 /* Data indicating an Invalid CDB OpCode is returned. */
3992 sp = (char *) scb->scsi_cmd->sense_buffer;
3993 memset(sp, 0, sizeof (scb->scsi_cmd->sense_buffer));
3995 sp[0] = 0x70; /* Error Code */
3996 sp[2] = ILLEGAL_REQUEST; /* Sense Key 5 Illegal Req. */
3997 sp[7] = 0x0A; /* Additional Sense Length */
3998 sp[12] = 0x20; /* ASC = Invalid OpCode */
3999 sp[13] = 0x00; /* ASCQ */
4001 device_error = 2; /* Indicate Check Condition */
4002 scb->scsi_cmd->result = device_error | (DID_OK << 16);
4007 if (ret == IPS_SUCCESS_IMM)
4013 /* If we already know the Device is Not there, no need to attempt a Command */
4014 /* This also protects an NT FailOver Controller from getting CDB's sent to it */
4015 if (ha->conf->dev[scb->bus - 1][scb->target_id].ucState == 0) {
4016 scb->scsi_cmd->result = DID_NO_CONNECT << 16;
4017 return (IPS_SUCCESS_IMM);
4020 ha->dcdb_active[scb->bus - 1] |= (1 << scb->target_id);
4021 scb->cmd.dcdb.command_id = IPS_COMMAND_ID(ha, scb);
4022 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
4023 (unsigned long) &scb->
4025 (unsigned long) scb);
4026 scb->cmd.dcdb.reserved = 0;
4027 scb->cmd.dcdb.reserved2 = 0;
4028 scb->cmd.dcdb.reserved3 = 0;
4029 scb->cmd.dcdb.segment_4G = 0;
4030 scb->cmd.dcdb.enhanced_sg = 0;
4032 TimeOut = scb->scsi_cmd->timeout_per_command;
4034 if (ha->subsys->param[4] & 0x00100000) { /* If NEW Tape DCDB is Supported */
4036 scb->cmd.dcdb.op_code = IPS_CMD_EXTENDED_DCDB;
4038 scb->cmd.dcdb.op_code =
4039 IPS_CMD_EXTENDED_DCDB_SG;
4040 scb->cmd.dcdb.enhanced_sg =
4041 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
4044 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb; /* Use Same Data Area as Old DCDB Struct */
4045 tapeDCDB->device_address =
4046 ((scb->bus - 1) << 4) | scb->target_id;
4047 tapeDCDB->cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4048 tapeDCDB->cmd_attribute &= ~IPS_TRANSFER64K; /* Always Turn OFF 64K Size Flag */
4051 if (TimeOut < (10 * HZ))
4052 tapeDCDB->cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
4053 else if (TimeOut < (60 * HZ))
4054 tapeDCDB->cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
4055 else if (TimeOut < (1200 * HZ))
4056 tapeDCDB->cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
4059 tapeDCDB->cdb_length = scb->scsi_cmd->cmd_len;
4060 tapeDCDB->reserved_for_LUN = 0;
4061 tapeDCDB->transfer_length = scb->data_len;
4062 if (scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB_SG)
4063 tapeDCDB->buffer_pointer =
4064 cpu_to_le32(scb->sg_busaddr);
4066 tapeDCDB->buffer_pointer =
4067 cpu_to_le32(scb->data_busaddr);
4068 tapeDCDB->sg_count = scb->sg_len;
4069 tapeDCDB->sense_length = sizeof (tapeDCDB->sense_info);
4070 tapeDCDB->scsi_status = 0;
4071 tapeDCDB->reserved = 0;
4072 memcpy(tapeDCDB->scsi_cdb, scb->scsi_cmd->cmnd,
4073 scb->scsi_cmd->cmd_len);
4076 scb->cmd.dcdb.op_code = IPS_CMD_DCDB;
4078 scb->cmd.dcdb.op_code = IPS_CMD_DCDB_SG;
4079 scb->cmd.dcdb.enhanced_sg =
4080 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
4083 scb->dcdb.device_address =
4084 ((scb->bus - 1) << 4) | scb->target_id;
4085 scb->dcdb.cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4088 if (TimeOut < (10 * HZ))
4089 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
4090 else if (TimeOut < (60 * HZ))
4091 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
4092 else if (TimeOut < (1200 * HZ))
4093 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
4096 scb->dcdb.transfer_length = scb->data_len;
4097 if (scb->dcdb.cmd_attribute & IPS_TRANSFER64K)
4098 scb->dcdb.transfer_length = 0;
4099 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB_SG)
4100 scb->dcdb.buffer_pointer =
4101 cpu_to_le32(scb->sg_busaddr);
4103 scb->dcdb.buffer_pointer =
4104 cpu_to_le32(scb->data_busaddr);
4105 scb->dcdb.cdb_length = scb->scsi_cmd->cmd_len;
4106 scb->dcdb.sense_length = sizeof (scb->dcdb.sense_info);
4107 scb->dcdb.sg_count = scb->sg_len;
4108 scb->dcdb.reserved = 0;
4109 memcpy(scb->dcdb.scsi_cdb, scb->scsi_cmd->cmnd,
4110 scb->scsi_cmd->cmd_len);
4111 scb->dcdb.scsi_status = 0;
4112 scb->dcdb.reserved2[0] = 0;
4113 scb->dcdb.reserved2[1] = 0;
4114 scb->dcdb.reserved2[2] = 0;
4118 return ((*ha->func.issue) (ha, scb));
4121 /****************************************************************************/
4123 /* Routine Name: ips_chk_status */
4125 /* Routine Description: */
4127 /* Check the status of commands to logical drives */
4128 /* Assumed to be called with the HA lock */
4129 /****************************************************************************/
4131 ips_chkstatus(ips_ha_t * ha, IPS_STATUS * pstatus)
4135 uint8_t basic_status;
4139 METHOD_TRACE("ips_chkstatus", 1);
4141 scb = &ha->scbs[pstatus->fields.command_id];
4142 scb->basic_status = basic_status =
4143 pstatus->fields.basic_status & IPS_BASIC_STATUS_MASK;
4144 scb->extended_status = ext_status = pstatus->fields.extended_status;
4147 sp->residue_len = 0;
4148 sp->scb_addr = (void *) scb;
4150 /* Remove the item from the active queue */
4151 ips_removeq_scb(&ha->scb_activelist, scb);
4154 /* internal commands are handled in do_ipsintr */
4157 DEBUG_VAR(2, "(%s%d) ips_chkstatus: cmd 0x%X id %d (%d %d %d)",
4161 scb->cmd.basic_io.command_id,
4162 scb->bus, scb->target_id, scb->lun);
4164 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd)))
4165 /* passthru - just returns the raw result */
4170 if (((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_SUCCESS) ||
4171 ((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_RECOVERED_ERROR)) {
4173 if (scb->bus == 0) {
4174 if ((basic_status & IPS_GSC_STATUS_MASK) ==
4175 IPS_CMD_RECOVERED_ERROR) {
4177 "(%s%d) Recovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4178 ips_name, ha->host_num,
4179 scb->cmd.basic_io.op_code,
4180 basic_status, ext_status);
4183 switch (scb->scsi_cmd->cmnd[0]) {
4184 case ALLOW_MEDIUM_REMOVAL:
4187 case WRITE_FILEMARKS:
4189 errcode = DID_ERROR;
4195 case TEST_UNIT_READY:
4196 if (!ips_online(ha, scb)) {
4197 errcode = DID_TIME_OUT;
4202 if (ips_online(ha, scb)) {
4203 ips_inquiry(ha, scb);
4205 errcode = DID_TIME_OUT;
4210 ips_reqsen(ha, scb);
4222 if (!ips_online(ha, scb)
4223 || !ips_msense(ha, scb)) {
4224 errcode = DID_ERROR;
4229 if (ips_online(ha, scb))
4232 errcode = DID_TIME_OUT;
4236 case SEND_DIAGNOSTIC:
4237 case REASSIGN_BLOCKS:
4241 errcode = DID_ERROR;
4246 case READ_DEFECT_DATA:
4252 errcode = DID_ERROR;
4255 scb->scsi_cmd->result = errcode << 16;
4256 } else { /* bus == 0 */
4257 /* restrict access to physical drives */
4258 if ((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
4259 ((((char *) scb->scsi_cmd->buffer)[0] & 0x1f) ==
4262 scb->scsi_cmd->result = DID_TIME_OUT << 16;
4265 } else { /* recovered error / success */
4266 if (scb->bus == 0) {
4268 "(%s%d) Unrecovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4269 ips_name, ha->host_num,
4270 scb->cmd.basic_io.op_code, basic_status,
4274 ips_map_status(ha, scb, sp);
4278 /****************************************************************************/
4280 /* Routine Name: ips_online */
4282 /* Routine Description: */
4284 /* Determine if a logical drive is online */
4286 /****************************************************************************/
4288 ips_online(ips_ha_t * ha, ips_scb_t * scb)
4290 METHOD_TRACE("ips_online", 1);
4292 if (scb->target_id >= IPS_MAX_LD)
4295 if ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1) {
4296 memset(ha->logical_drive_info, 0, sizeof (IPS_LD_INFO));
4300 if (ha->logical_drive_info->drive_info[scb->target_id].state !=
4302 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4304 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4306 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4313 /****************************************************************************/
4315 /* Routine Name: ips_inquiry */
4317 /* Routine Description: */
4319 /* Simulate an inquiry command to a logical drive */
4321 /****************************************************************************/
4323 ips_inquiry(ips_ha_t * ha, ips_scb_t * scb)
4325 IPS_SCSI_INQ_DATA inquiry;
4327 METHOD_TRACE("ips_inquiry", 1);
4329 memset(&inquiry, 0, sizeof (IPS_SCSI_INQ_DATA));
4331 inquiry.DeviceType = IPS_SCSI_INQ_TYPE_DASD;
4332 inquiry.DeviceTypeQualifier = IPS_SCSI_INQ_LU_CONNECTED;
4333 inquiry.Version = IPS_SCSI_INQ_REV2;
4334 inquiry.ResponseDataFormat = IPS_SCSI_INQ_RD_REV2;
4335 inquiry.AdditionalLength = 31;
4336 inquiry.Flags[0] = IPS_SCSI_INQ_Address16;
4338 IPS_SCSI_INQ_WBus16 | IPS_SCSI_INQ_Sync | IPS_SCSI_INQ_CmdQue;
4339 strncpy(inquiry.VendorId, "IBM ", 8);
4340 strncpy(inquiry.ProductId, "SERVERAID ", 16);
4341 strncpy(inquiry.ProductRevisionLevel, "1.00", 4);
4343 ips_scmd_buf_write(scb->scsi_cmd, &inquiry, sizeof (inquiry));
4348 /****************************************************************************/
4350 /* Routine Name: ips_rdcap */
4352 /* Routine Description: */
4354 /* Simulate a read capacity command to a logical drive */
4356 /****************************************************************************/
4358 ips_rdcap(ips_ha_t * ha, ips_scb_t * scb)
4360 IPS_SCSI_CAPACITY cap;
4362 METHOD_TRACE("ips_rdcap", 1);
4364 if (scb->scsi_cmd->bufflen < 8)
4368 cpu_to_be32(le32_to_cpu
4369 (ha->logical_drive_info->
4370 drive_info[scb->target_id].sector_count) - 1);
4371 cap.len = cpu_to_be32((uint32_t) IPS_BLKSIZE);
4373 ips_scmd_buf_write(scb->scsi_cmd, &cap, sizeof (cap));
4378 /****************************************************************************/
4380 /* Routine Name: ips_msense */
4382 /* Routine Description: */
4384 /* Simulate a mode sense command to a logical drive */
4386 /****************************************************************************/
4388 ips_msense(ips_ha_t * ha, ips_scb_t * scb)
4393 IPS_SCSI_MODE_PAGE_DATA mdata;
4395 METHOD_TRACE("ips_msense", 1);
4397 if (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) > 0x400000 &&
4398 (ha->enq->ucMiscFlag & 0x8) == 0) {
4399 heads = IPS_NORM_HEADS;
4400 sectors = IPS_NORM_SECTORS;
4402 heads = IPS_COMP_HEADS;
4403 sectors = IPS_COMP_SECTORS;
4407 (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) -
4408 1) / (heads * sectors);
4410 memset(&mdata, 0, sizeof (IPS_SCSI_MODE_PAGE_DATA));
4412 mdata.hdr.BlockDescLength = 8;
4414 switch (scb->scsi_cmd->cmnd[2] & 0x3f) {
4415 case 0x03: /* page 3 */
4416 mdata.pdata.pg3.PageCode = 3;
4417 mdata.pdata.pg3.PageLength = sizeof (IPS_SCSI_MODE_PAGE3);
4418 mdata.hdr.DataLength =
4419 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg3.PageLength;
4420 mdata.pdata.pg3.TracksPerZone = 0;
4421 mdata.pdata.pg3.AltSectorsPerZone = 0;
4422 mdata.pdata.pg3.AltTracksPerZone = 0;
4423 mdata.pdata.pg3.AltTracksPerVolume = 0;
4424 mdata.pdata.pg3.SectorsPerTrack = cpu_to_be16(sectors);
4425 mdata.pdata.pg3.BytesPerSector = cpu_to_be16(IPS_BLKSIZE);
4426 mdata.pdata.pg3.Interleave = cpu_to_be16(1);
4427 mdata.pdata.pg3.TrackSkew = 0;
4428 mdata.pdata.pg3.CylinderSkew = 0;
4429 mdata.pdata.pg3.flags = IPS_SCSI_MP3_SoftSector;
4433 mdata.pdata.pg4.PageCode = 4;
4434 mdata.pdata.pg4.PageLength = sizeof (IPS_SCSI_MODE_PAGE4);
4435 mdata.hdr.DataLength =
4436 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg4.PageLength;
4437 mdata.pdata.pg4.CylindersHigh =
4438 cpu_to_be16((cylinders >> 8) & 0xFFFF);
4439 mdata.pdata.pg4.CylindersLow = (cylinders & 0xFF);
4440 mdata.pdata.pg4.Heads = heads;
4441 mdata.pdata.pg4.WritePrecompHigh = 0;
4442 mdata.pdata.pg4.WritePrecompLow = 0;
4443 mdata.pdata.pg4.ReducedWriteCurrentHigh = 0;
4444 mdata.pdata.pg4.ReducedWriteCurrentLow = 0;
4445 mdata.pdata.pg4.StepRate = cpu_to_be16(1);
4446 mdata.pdata.pg4.LandingZoneHigh = 0;
4447 mdata.pdata.pg4.LandingZoneLow = 0;
4448 mdata.pdata.pg4.flags = 0;
4449 mdata.pdata.pg4.RotationalOffset = 0;
4450 mdata.pdata.pg4.MediumRotationRate = 0;
4453 mdata.pdata.pg8.PageCode = 8;
4454 mdata.pdata.pg8.PageLength = sizeof (IPS_SCSI_MODE_PAGE8);
4455 mdata.hdr.DataLength =
4456 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg8.PageLength;
4457 /* everything else is left set to 0 */
4464 ips_scmd_buf_write(scb->scsi_cmd, &mdata, sizeof (mdata));
4469 /****************************************************************************/
4471 /* Routine Name: ips_reqsen */
4473 /* Routine Description: */
4475 /* Simulate a request sense command to a logical drive */
4477 /****************************************************************************/
4479 ips_reqsen(ips_ha_t * ha, ips_scb_t * scb)
4481 IPS_SCSI_REQSEN reqsen;
4483 METHOD_TRACE("ips_reqsen", 1);
4485 memset(&reqsen, 0, sizeof (IPS_SCSI_REQSEN));
4487 reqsen.ResponseCode =
4488 IPS_SCSI_REQSEN_VALID | IPS_SCSI_REQSEN_CURRENT_ERR;
4489 reqsen.AdditionalLength = 10;
4490 reqsen.AdditionalSenseCode = IPS_SCSI_REQSEN_NO_SENSE;
4491 reqsen.AdditionalSenseCodeQual = IPS_SCSI_REQSEN_NO_SENSE;
4493 ips_scmd_buf_write(scb->scsi_cmd, &reqsen, sizeof (reqsen));
4498 /****************************************************************************/
4500 /* Routine Name: ips_free */
4502 /* Routine Description: */
4504 /* Free any allocated space for this controller */
4506 /****************************************************************************/
4508 ips_free(ips_ha_t * ha)
4511 METHOD_TRACE("ips_free", 1);
4515 pci_free_consistent(ha->pcidev, sizeof(IPS_ENQ),
4516 ha->enq, ha->enq_busaddr);
4526 pci_free_consistent(ha->pcidev,
4527 sizeof (IPS_ADAPTER) +
4528 sizeof (IPS_IO_CMD), ha->adapt,
4529 ha->adapt->hw_status_start);
4533 if (ha->logical_drive_info) {
4534 pci_free_consistent(ha->pcidev,
4535 sizeof (IPS_LD_INFO),
4536 ha->logical_drive_info,
4537 ha->logical_drive_info_dma_addr);
4538 ha->logical_drive_info = NULL;
4551 if (ha->ioctl_data) {
4552 pci_free_consistent(ha->pcidev, ha->ioctl_len,
4553 ha->ioctl_data, ha->ioctl_busaddr);
4554 ha->ioctl_data = NULL;
4555 ha->ioctl_datasize = 0;
4558 ips_deallocatescbs(ha, ha->max_cmds);
4560 /* free memory mapped (if applicable) */
4562 iounmap(ha->ioremap_ptr);
4563 ha->ioremap_ptr = NULL;
4568 release_mem_region(ha->mem_addr, ha->mem_len);
4574 /****************************************************************************/
4576 /* Routine Name: ips_deallocatescbs */
4578 /* Routine Description: */
4580 /* Free the command blocks */
4582 /****************************************************************************/
4584 ips_deallocatescbs(ips_ha_t * ha, int cmds)
4587 pci_free_consistent(ha->pcidev,
4588 IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * cmds,
4589 ha->scbs->sg_list.list,
4590 ha->scbs->sg_busaddr);
4591 pci_free_consistent(ha->pcidev, sizeof (ips_scb_t) * cmds,
4592 ha->scbs, ha->scbs->scb_busaddr);
4598 /****************************************************************************/
4600 /* Routine Name: ips_allocatescbs */
4602 /* Routine Description: */
4604 /* Allocate the command blocks */
4606 /****************************************************************************/
4608 ips_allocatescbs(ips_ha_t * ha)
4613 dma_addr_t command_dma, sg_dma;
4615 METHOD_TRACE("ips_allocatescbs", 1);
4617 /* Allocate memory for the SCBs */
4619 pci_alloc_consistent(ha->pcidev, ha->max_cmds * sizeof (ips_scb_t),
4621 if (ha->scbs == NULL)
4624 pci_alloc_consistent(ha->pcidev,
4625 IPS_SGLIST_SIZE(ha) * IPS_MAX_SG *
4626 ha->max_cmds, &sg_dma);
4627 if (ips_sg.list == NULL) {
4628 pci_free_consistent(ha->pcidev,
4629 ha->max_cmds * sizeof (ips_scb_t), ha->scbs,
4634 memset(ha->scbs, 0, ha->max_cmds * sizeof (ips_scb_t));
4636 for (i = 0; i < ha->max_cmds; i++) {
4637 scb_p = &ha->scbs[i];
4638 scb_p->scb_busaddr = command_dma + sizeof (ips_scb_t) * i;
4639 /* set up S/G list */
4640 if (IPS_USE_ENH_SGLIST(ha)) {
4641 scb_p->sg_list.enh_list =
4642 ips_sg.enh_list + i * IPS_MAX_SG;
4644 sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4646 scb_p->sg_list.std_list =
4647 ips_sg.std_list + i * IPS_MAX_SG;
4649 sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4652 /* add to the free list */
4653 if (i < ha->max_cmds - 1) {
4654 scb_p->q_next = ha->scb_freelist;
4655 ha->scb_freelist = scb_p;
4663 /****************************************************************************/
4665 /* Routine Name: ips_init_scb */
4667 /* Routine Description: */
4669 /* Initialize a CCB to default values */
4671 /****************************************************************************/
4673 ips_init_scb(ips_ha_t * ha, ips_scb_t * scb)
4675 IPS_SG_LIST sg_list;
4676 uint32_t cmd_busaddr, sg_busaddr;
4677 METHOD_TRACE("ips_init_scb", 1);
4682 sg_list.list = scb->sg_list.list;
4683 cmd_busaddr = scb->scb_busaddr;
4684 sg_busaddr = scb->sg_busaddr;
4686 memset(scb, 0, sizeof (ips_scb_t));
4687 memset(ha->dummy, 0, sizeof (IPS_IO_CMD));
4689 /* Initialize dummy command bucket */
4690 ha->dummy->op_code = 0xFF;
4691 ha->dummy->ccsar = cpu_to_le32(ha->adapt->hw_status_start
4692 + sizeof (IPS_ADAPTER));
4693 ha->dummy->command_id = IPS_MAX_CMDS;
4695 /* set bus address of scb */
4696 scb->scb_busaddr = cmd_busaddr;
4697 scb->sg_busaddr = sg_busaddr;
4698 scb->sg_list.list = sg_list.list;
4701 scb->cmd.basic_io.cccr = cpu_to_le32((uint32_t) IPS_BIT_ILE);
4702 scb->cmd.basic_io.ccsar = cpu_to_le32(ha->adapt->hw_status_start
4703 + sizeof (IPS_ADAPTER));
4706 /****************************************************************************/
4708 /* Routine Name: ips_get_scb */
4710 /* Routine Description: */
4712 /* Initialize a CCB to default values */
4714 /* ASSUMED to be callled from within a lock */
4716 /****************************************************************************/
4718 ips_getscb(ips_ha_t * ha)
4722 METHOD_TRACE("ips_getscb", 1);
4724 if ((scb = ha->scb_freelist) == NULL) {
4729 ha->scb_freelist = scb->q_next;
4733 ips_init_scb(ha, scb);
4738 /****************************************************************************/
4740 /* Routine Name: ips_free_scb */
4742 /* Routine Description: */
4744 /* Return an unused CCB back to the free list */
4746 /* ASSUMED to be called from within a lock */
4748 /****************************************************************************/
4750 ips_freescb(ips_ha_t * ha, ips_scb_t * scb)
4753 METHOD_TRACE("ips_freescb", 1);
4754 if (scb->flags & IPS_SCB_MAP_SG)
4755 pci_unmap_sg(ha->pcidev, scb->scsi_cmd->request_buffer,
4756 scb->scsi_cmd->use_sg, IPS_DMA_DIR(scb));
4757 else if (scb->flags & IPS_SCB_MAP_SINGLE)
4758 pci_unmap_single(ha->pcidev, scb->data_busaddr, scb->data_len,
4761 /* check to make sure this is not our "special" scb */
4762 if (IPS_COMMAND_ID(ha, scb) < (ha->max_cmds - 1)) {
4763 scb->q_next = ha->scb_freelist;
4764 ha->scb_freelist = scb;
4768 /****************************************************************************/
4770 /* Routine Name: ips_isinit_copperhead */
4772 /* Routine Description: */
4774 /* Is controller initialized ? */
4776 /****************************************************************************/
4778 ips_isinit_copperhead(ips_ha_t * ha)
4783 METHOD_TRACE("ips_isinit_copperhead", 1);
4785 isr = inb(ha->io_addr + IPS_REG_HISR);
4786 scpr = inb(ha->io_addr + IPS_REG_SCPR);
4788 if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4794 /****************************************************************************/
4796 /* Routine Name: ips_isinit_copperhead_memio */
4798 /* Routine Description: */
4800 /* Is controller initialized ? */
4802 /****************************************************************************/
4804 ips_isinit_copperhead_memio(ips_ha_t * ha)
4809 METHOD_TRACE("ips_is_init_copperhead_memio", 1);
4811 isr = readb(ha->mem_ptr + IPS_REG_HISR);
4812 scpr = readb(ha->mem_ptr + IPS_REG_SCPR);
4814 if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4820 /****************************************************************************/
4822 /* Routine Name: ips_isinit_morpheus */
4824 /* Routine Description: */
4826 /* Is controller initialized ? */
4828 /****************************************************************************/
4830 ips_isinit_morpheus(ips_ha_t * ha)
4835 METHOD_TRACE("ips_is_init_morpheus", 1);
4837 if (ips_isintr_morpheus(ha))
4838 ips_flush_and_reset(ha);
4840 post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
4841 bits = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
4845 else if (bits & 0x3)
4851 /****************************************************************************/
4853 /* Routine Name: ips_flush_and_reset */
4855 /* Routine Description: */
4857 /* Perform cleanup ( FLUSH and RESET ) when the adapter is in an unknown */
4858 /* state ( was trying to INIT and an interrupt was already pending ) ... */
4860 /****************************************************************************/
4862 ips_flush_and_reset(ips_ha_t *ha)
4868 dma_addr_t command_dma;
4870 /* Create a usuable SCB */
4871 scb = pci_alloc_consistent(ha->pcidev, sizeof(ips_scb_t), &command_dma);
4873 memset(scb, 0, sizeof(ips_scb_t));
4874 ips_init_scb(ha, scb);
4875 scb->scb_busaddr = command_dma;
4877 scb->timeout = ips_cmd_timeout;
4878 scb->cdb[0] = IPS_CMD_FLUSH;
4880 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
4881 scb->cmd.flush_cache.command_id = IPS_MAX_CMDS; /* Use an ID that would otherwise not exist */
4882 scb->cmd.flush_cache.state = IPS_NORM_STATE;
4883 scb->cmd.flush_cache.reserved = 0;
4884 scb->cmd.flush_cache.reserved2 = 0;
4885 scb->cmd.flush_cache.reserved3 = 0;
4886 scb->cmd.flush_cache.reserved4 = 0;
4888 ret = ips_send_cmd(ha, scb); /* Send the Flush Command */
4890 if (ret == IPS_SUCCESS) {
4891 time = 60 * IPS_ONE_SEC; /* Max Wait time is 60 seconds */
4894 while ((time > 0) && (!done)) {
4895 done = ips_poll_for_flush_complete(ha);
4896 /* This may look evil, but it's only done during extremely rare start-up conditions ! */
4903 /* Now RESET and INIT the adapter */
4904 (*ha->func.reset) (ha);
4906 pci_free_consistent(ha->pcidev, sizeof(ips_scb_t), scb, command_dma);
4910 /****************************************************************************/
4912 /* Routine Name: ips_poll_for_flush_complete */
4914 /* Routine Description: */
4916 /* Poll for the Flush Command issued by ips_flush_and_reset() to complete */
4917 /* All other responses are just taken off the queue and ignored */
4919 /****************************************************************************/
4921 ips_poll_for_flush_complete(ips_ha_t * ha)
4926 cstatus.value = (*ha->func.statupd) (ha);
4928 if (cstatus.value == 0xffffffff) /* If No Interrupt to process */
4931 /* Success is when we see the Flush Command ID */
4932 if (cstatus.fields.command_id == IPS_MAX_CMDS )
4938 /****************************************************************************/
4940 /* Routine Name: ips_enable_int_copperhead */
4942 /* Routine Description: */
4943 /* Turn on interrupts */
4945 /****************************************************************************/
4947 ips_enable_int_copperhead(ips_ha_t * ha)
4949 METHOD_TRACE("ips_enable_int_copperhead", 1);
4951 outb(ha->io_addr + IPS_REG_HISR, IPS_BIT_EI);
4952 inb(ha->io_addr + IPS_REG_HISR); /*Ensure PCI Posting Completes*/
4955 /****************************************************************************/
4957 /* Routine Name: ips_enable_int_copperhead_memio */
4959 /* Routine Description: */
4960 /* Turn on interrupts */
4962 /****************************************************************************/
4964 ips_enable_int_copperhead_memio(ips_ha_t * ha)
4966 METHOD_TRACE("ips_enable_int_copperhead_memio", 1);
4968 writeb(IPS_BIT_EI, ha->mem_ptr + IPS_REG_HISR);
4969 readb(ha->mem_ptr + IPS_REG_HISR); /*Ensure PCI Posting Completes*/
4972 /****************************************************************************/
4974 /* Routine Name: ips_enable_int_morpheus */
4976 /* Routine Description: */
4977 /* Turn on interrupts */
4979 /****************************************************************************/
4981 ips_enable_int_morpheus(ips_ha_t * ha)
4985 METHOD_TRACE("ips_enable_int_morpheus", 1);
4987 Oimr = readl(ha->mem_ptr + IPS_REG_I960_OIMR);
4989 writel(Oimr, ha->mem_ptr + IPS_REG_I960_OIMR);
4990 readl(ha->mem_ptr + IPS_REG_I960_OIMR); /*Ensure PCI Posting Completes*/
4993 /****************************************************************************/
4995 /* Routine Name: ips_init_copperhead */
4997 /* Routine Description: */
4999 /* Initialize a copperhead controller */
5001 /****************************************************************************/
5003 ips_init_copperhead(ips_ha_t * ha)
5007 uint8_t PostByte[IPS_MAX_POST_BYTES];
5008 uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
5011 METHOD_TRACE("ips_init_copperhead", 1);
5013 for (i = 0; i < IPS_MAX_POST_BYTES; i++) {
5014 for (j = 0; j < 45; j++) {
5015 Isr = inb(ha->io_addr + IPS_REG_HISR);
5016 if (Isr & IPS_BIT_GHI)
5019 /* Delay for 1 Second */
5020 MDELAY(IPS_ONE_SEC);
5024 /* error occurred */
5027 PostByte[i] = inb(ha->io_addr + IPS_REG_ISPR);
5028 outb(Isr, ha->io_addr + IPS_REG_HISR);
5031 if (PostByte[0] < IPS_GOOD_POST_STATUS) {
5032 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5033 "reset controller fails (post status %x %x).\n",
5034 PostByte[0], PostByte[1]);
5039 for (i = 0; i < IPS_MAX_CONFIG_BYTES; i++) {
5040 for (j = 0; j < 240; j++) {
5041 Isr = inb(ha->io_addr + IPS_REG_HISR);
5042 if (Isr & IPS_BIT_GHI)
5045 /* Delay for 1 Second */
5046 MDELAY(IPS_ONE_SEC);
5050 /* error occurred */
5053 ConfigByte[i] = inb(ha->io_addr + IPS_REG_ISPR);
5054 outb(Isr, ha->io_addr + IPS_REG_HISR);
5057 for (i = 0; i < 240; i++) {
5058 Cbsp = inb(ha->io_addr + IPS_REG_CBSP);
5060 if ((Cbsp & IPS_BIT_OP) == 0)
5063 /* Delay for 1 Second */
5064 MDELAY(IPS_ONE_SEC);
5072 outl(cpu_to_le32(0x1010), ha->io_addr + IPS_REG_CCCR);
5074 /* Enable busmastering */
5075 outb(IPS_BIT_EBM, ha->io_addr + IPS_REG_SCPR);
5077 if (ha->revision_id == IPS_REVID_TROMBONE64)
5078 /* fix for anaconda64 */
5079 outl(0, ha->io_addr + IPS_REG_NDAE);
5081 /* Enable interrupts */
5082 outb(IPS_BIT_EI, ha->io_addr + IPS_REG_HISR);
5087 /****************************************************************************/
5089 /* Routine Name: ips_init_copperhead_memio */
5091 /* Routine Description: */
5093 /* Initialize a copperhead controller with memory mapped I/O */
5095 /****************************************************************************/
5097 ips_init_copperhead_memio(ips_ha_t * ha)
5101 uint8_t PostByte[IPS_MAX_POST_BYTES];
5102 uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
5105 METHOD_TRACE("ips_init_copperhead_memio", 1);
5107 for (i = 0; i < IPS_MAX_POST_BYTES; i++) {
5108 for (j = 0; j < 45; j++) {
5109 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5110 if (Isr & IPS_BIT_GHI)
5113 /* Delay for 1 Second */
5114 MDELAY(IPS_ONE_SEC);
5118 /* error occurred */
5121 PostByte[i] = readb(ha->mem_ptr + IPS_REG_ISPR);
5122 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5125 if (PostByte[0] < IPS_GOOD_POST_STATUS) {
5126 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5127 "reset controller fails (post status %x %x).\n",
5128 PostByte[0], PostByte[1]);
5133 for (i = 0; i < IPS_MAX_CONFIG_BYTES; i++) {
5134 for (j = 0; j < 240; j++) {
5135 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5136 if (Isr & IPS_BIT_GHI)
5139 /* Delay for 1 Second */
5140 MDELAY(IPS_ONE_SEC);
5144 /* error occurred */
5147 ConfigByte[i] = readb(ha->mem_ptr + IPS_REG_ISPR);
5148 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5151 for (i = 0; i < 240; i++) {
5152 Cbsp = readb(ha->mem_ptr + IPS_REG_CBSP);
5154 if ((Cbsp & IPS_BIT_OP) == 0)
5157 /* Delay for 1 Second */
5158 MDELAY(IPS_ONE_SEC);
5162 /* error occurred */
5166 writel(0x1010, ha->mem_ptr + IPS_REG_CCCR);
5168 /* Enable busmastering */
5169 writeb(IPS_BIT_EBM, ha->mem_ptr + IPS_REG_SCPR);
5171 if (ha->revision_id == IPS_REVID_TROMBONE64)
5172 /* fix for anaconda64 */
5173 writel(0, ha->mem_ptr + IPS_REG_NDAE);
5175 /* Enable interrupts */
5176 writeb(IPS_BIT_EI, ha->mem_ptr + IPS_REG_HISR);
5178 /* if we get here then everything went OK */
5182 /****************************************************************************/
5184 /* Routine Name: ips_init_morpheus */
5186 /* Routine Description: */
5188 /* Initialize a morpheus controller */
5190 /****************************************************************************/
5192 ips_init_morpheus(ips_ha_t * ha)
5200 METHOD_TRACE("ips_init_morpheus", 1);
5202 /* Wait up to 45 secs for Post */
5203 for (i = 0; i < 45; i++) {
5204 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5206 if (Isr & IPS_BIT_I960_MSG0I)
5209 /* Delay for 1 Second */
5210 MDELAY(IPS_ONE_SEC);
5214 /* error occurred */
5215 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5216 "timeout waiting for post.\n");
5221 Post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
5223 if (Post == 0x4F00) { /* If Flashing the Battery PIC */
5224 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5225 "Flashing Battery PIC, Please wait ...\n");
5227 /* Clear the interrupt bit */
5228 Isr = (uint32_t) IPS_BIT_I960_MSG0I;
5229 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5231 for (i = 0; i < 120; i++) { /* Wait Up to 2 Min. for Completion */
5232 Post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
5235 /* Delay for 1 Second */
5236 MDELAY(IPS_ONE_SEC);
5240 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5241 "timeout waiting for Battery PIC Flash\n");
5247 /* Clear the interrupt bit */
5248 Isr = (uint32_t) IPS_BIT_I960_MSG0I;
5249 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5251 if (Post < (IPS_GOOD_POST_STATUS << 8)) {
5252 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5253 "reset controller fails (post status %x).\n", Post);
5258 /* Wait up to 240 secs for config bytes */
5259 for (i = 0; i < 240; i++) {
5260 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5262 if (Isr & IPS_BIT_I960_MSG1I)
5265 /* Delay for 1 Second */
5266 MDELAY(IPS_ONE_SEC);
5270 /* error occurred */
5271 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5272 "timeout waiting for config.\n");
5277 Config = readl(ha->mem_ptr + IPS_REG_I960_MSG1);
5279 /* Clear interrupt bit */
5280 Isr = (uint32_t) IPS_BIT_I960_MSG1I;
5281 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5283 /* Turn on the interrupts */
5284 Oimr = readl(ha->mem_ptr + IPS_REG_I960_OIMR);
5286 writel(Oimr, ha->mem_ptr + IPS_REG_I960_OIMR);
5288 /* if we get here then everything went OK */
5290 /* Since we did a RESET, an EraseStripeLock may be needed */
5291 if (Post == 0xEF10) {
5292 if ((Config == 0x000F) || (Config == 0x0009))
5293 ha->requires_esl = 1;
5299 /****************************************************************************/
5301 /* Routine Name: ips_reset_copperhead */
5303 /* Routine Description: */
5305 /* Reset the controller */
5307 /****************************************************************************/
5309 ips_reset_copperhead(ips_ha_t * ha)
5313 METHOD_TRACE("ips_reset_copperhead", 1);
5315 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead: io addr: %x, irq: %d",
5316 ips_name, ha->host_num, ha->io_addr, ha->irq);
5320 while (reset_counter < 2) {
5323 outb(IPS_BIT_RST, ha->io_addr + IPS_REG_SCPR);
5325 /* Delay for 1 Second */
5326 MDELAY(IPS_ONE_SEC);
5328 outb(0, ha->io_addr + IPS_REG_SCPR);
5330 /* Delay for 1 Second */
5331 MDELAY(IPS_ONE_SEC);
5333 if ((*ha->func.init) (ha))
5335 else if (reset_counter >= 2) {
5344 /****************************************************************************/
5346 /* Routine Name: ips_reset_copperhead_memio */
5348 /* Routine Description: */
5350 /* Reset the controller */
5352 /****************************************************************************/
5354 ips_reset_copperhead_memio(ips_ha_t * ha)
5358 METHOD_TRACE("ips_reset_copperhead_memio", 1);
5360 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead_memio: mem addr: %x, irq: %d",
5361 ips_name, ha->host_num, ha->mem_addr, ha->irq);
5365 while (reset_counter < 2) {
5368 writeb(IPS_BIT_RST, ha->mem_ptr + IPS_REG_SCPR);
5370 /* Delay for 1 Second */
5371 MDELAY(IPS_ONE_SEC);
5373 writeb(0, ha->mem_ptr + IPS_REG_SCPR);
5375 /* Delay for 1 Second */
5376 MDELAY(IPS_ONE_SEC);
5378 if ((*ha->func.init) (ha))
5380 else if (reset_counter >= 2) {
5389 /****************************************************************************/
5391 /* Routine Name: ips_reset_morpheus */
5393 /* Routine Description: */
5395 /* Reset the controller */
5397 /****************************************************************************/
5399 ips_reset_morpheus(ips_ha_t * ha)
5404 METHOD_TRACE("ips_reset_morpheus", 1);
5406 DEBUG_VAR(1, "(%s%d) ips_reset_morpheus: mem addr: %x, irq: %d",
5407 ips_name, ha->host_num, ha->mem_addr, ha->irq);
5411 while (reset_counter < 2) {
5414 writel(0x80000000, ha->mem_ptr + IPS_REG_I960_IDR);
5416 /* Delay for 5 Seconds */
5417 MDELAY(5 * IPS_ONE_SEC);
5419 /* Do a PCI config read to wait for adapter */
5420 pci_read_config_byte(ha->pcidev, 4, &junk);
5422 if ((*ha->func.init) (ha))
5424 else if (reset_counter >= 2) {
5433 /****************************************************************************/
5435 /* Routine Name: ips_statinit */
5437 /* Routine Description: */
5439 /* Initialize the status queues on the controller */
5441 /****************************************************************************/
5443 ips_statinit(ips_ha_t * ha)
5445 uint32_t phys_status_start;
5447 METHOD_TRACE("ips_statinit", 1);
5449 ha->adapt->p_status_start = ha->adapt->status;
5450 ha->adapt->p_status_end = ha->adapt->status + IPS_MAX_CMDS;
5451 ha->adapt->p_status_tail = ha->adapt->status;
5453 phys_status_start = ha->adapt->hw_status_start;
5454 outl(cpu_to_le32(phys_status_start), ha->io_addr + IPS_REG_SQSR);
5455 outl(cpu_to_le32(phys_status_start + IPS_STATUS_Q_SIZE),
5456 ha->io_addr + IPS_REG_SQER);
5457 outl(cpu_to_le32(phys_status_start + IPS_STATUS_SIZE),
5458 ha->io_addr + IPS_REG_SQHR);
5459 outl(cpu_to_le32(phys_status_start), ha->io_addr + IPS_REG_SQTR);
5461 ha->adapt->hw_status_tail = phys_status_start;
5464 /****************************************************************************/
5466 /* Routine Name: ips_statinit_memio */
5468 /* Routine Description: */
5470 /* Initialize the status queues on the controller */
5472 /****************************************************************************/
5474 ips_statinit_memio(ips_ha_t * ha)
5476 uint32_t phys_status_start;
5478 METHOD_TRACE("ips_statinit_memio", 1);
5480 ha->adapt->p_status_start = ha->adapt->status;
5481 ha->adapt->p_status_end = ha->adapt->status + IPS_MAX_CMDS;
5482 ha->adapt->p_status_tail = ha->adapt->status;
5484 phys_status_start = ha->adapt->hw_status_start;
5485 writel(phys_status_start, ha->mem_ptr + IPS_REG_SQSR);
5486 writel(phys_status_start + IPS_STATUS_Q_SIZE,
5487 ha->mem_ptr + IPS_REG_SQER);
5488 writel(phys_status_start + IPS_STATUS_SIZE, ha->mem_ptr + IPS_REG_SQHR);
5489 writel(phys_status_start, ha->mem_ptr + IPS_REG_SQTR);
5491 ha->adapt->hw_status_tail = phys_status_start;
5494 /****************************************************************************/
5496 /* Routine Name: ips_statupd_copperhead */
5498 /* Routine Description: */
5500 /* Remove an element from the status queue */
5502 /****************************************************************************/
5504 ips_statupd_copperhead(ips_ha_t * ha)
5506 METHOD_TRACE("ips_statupd_copperhead", 1);
5508 if (ha->adapt->p_status_tail != ha->adapt->p_status_end) {
5509 ha->adapt->p_status_tail++;
5510 ha->adapt->hw_status_tail += sizeof (IPS_STATUS);
5512 ha->adapt->p_status_tail = ha->adapt->p_status_start;
5513 ha->adapt->hw_status_tail = ha->adapt->hw_status_start;
5516 outl(cpu_to_le32(ha->adapt->hw_status_tail),
5517 ha->io_addr + IPS_REG_SQTR);
5519 return (ha->adapt->p_status_tail->value);
5522 /****************************************************************************/
5524 /* Routine Name: ips_statupd_copperhead_memio */
5526 /* Routine Description: */
5528 /* Remove an element from the status queue */
5530 /****************************************************************************/
5532 ips_statupd_copperhead_memio(ips_ha_t * ha)
5534 METHOD_TRACE("ips_statupd_copperhead_memio", 1);
5536 if (ha->adapt->p_status_tail != ha->adapt->p_status_end) {
5537 ha->adapt->p_status_tail++;
5538 ha->adapt->hw_status_tail += sizeof (IPS_STATUS);
5540 ha->adapt->p_status_tail = ha->adapt->p_status_start;
5541 ha->adapt->hw_status_tail = ha->adapt->hw_status_start;
5544 writel(ha->adapt->hw_status_tail, ha->mem_ptr + IPS_REG_SQTR);
5546 return (ha->adapt->p_status_tail->value);
5549 /****************************************************************************/
5551 /* Routine Name: ips_statupd_morpheus */
5553 /* Routine Description: */
5555 /* Remove an element from the status queue */
5557 /****************************************************************************/
5559 ips_statupd_morpheus(ips_ha_t * ha)
5563 METHOD_TRACE("ips_statupd_morpheus", 1);
5565 val = readl(ha->mem_ptr + IPS_REG_I2O_OUTMSGQ);
5570 /****************************************************************************/
5572 /* Routine Name: ips_issue_copperhead */
5574 /* Routine Description: */
5576 /* Send a command down to the controller */
5578 /****************************************************************************/
5580 ips_issue_copperhead(ips_ha_t * ha, ips_scb_t * scb)
5585 METHOD_TRACE("ips_issue_copperhead", 1);
5587 if (scb->scsi_cmd) {
5588 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5592 scb->cmd.basic_io.command_id,
5593 scb->bus, scb->target_id, scb->lun);
5595 DEBUG_VAR(2, KERN_NOTICE "(%s%d) ips_issue: logical cmd id %d",
5596 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5602 le32_to_cpu(inl(ha->io_addr + IPS_REG_CCCR))) & IPS_BIT_SEM) {
5605 if (++TimeOut >= IPS_SEM_TIMEOUT) {
5606 if (!(val & IPS_BIT_START_STOP))
5609 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5610 "ips_issue val [0x%x].\n", val);
5611 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5612 "ips_issue semaphore chk timeout.\n");
5614 return (IPS_FAILURE);
5618 outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_CCSAR);
5619 outw(cpu_to_le32(IPS_BIT_START_CMD), ha->io_addr + IPS_REG_CCCR);
5621 return (IPS_SUCCESS);
5624 /****************************************************************************/
5626 /* Routine Name: ips_issue_copperhead_memio */
5628 /* Routine Description: */
5630 /* Send a command down to the controller */
5632 /****************************************************************************/
5634 ips_issue_copperhead_memio(ips_ha_t * ha, ips_scb_t * scb)
5639 METHOD_TRACE("ips_issue_copperhead_memio", 1);
5641 if (scb->scsi_cmd) {
5642 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5646 scb->cmd.basic_io.command_id,
5647 scb->bus, scb->target_id, scb->lun);
5649 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5650 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5655 while ((val = readl(ha->mem_ptr + IPS_REG_CCCR)) & IPS_BIT_SEM) {
5658 if (++TimeOut >= IPS_SEM_TIMEOUT) {
5659 if (!(val & IPS_BIT_START_STOP))
5662 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5663 "ips_issue val [0x%x].\n", val);
5664 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5665 "ips_issue semaphore chk timeout.\n");
5667 return (IPS_FAILURE);
5671 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_CCSAR);
5672 writel(IPS_BIT_START_CMD, ha->mem_ptr + IPS_REG_CCCR);
5674 return (IPS_SUCCESS);
5677 /****************************************************************************/
5679 /* Routine Name: ips_issue_i2o */
5681 /* Routine Description: */
5683 /* Send a command down to the controller */
5685 /****************************************************************************/
5687 ips_issue_i2o(ips_ha_t * ha, ips_scb_t * scb)
5690 METHOD_TRACE("ips_issue_i2o", 1);
5692 if (scb->scsi_cmd) {
5693 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5697 scb->cmd.basic_io.command_id,
5698 scb->bus, scb->target_id, scb->lun);
5700 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5701 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5704 outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_I2O_INMSGQ);
5706 return (IPS_SUCCESS);
5709 /****************************************************************************/
5711 /* Routine Name: ips_issue_i2o_memio */
5713 /* Routine Description: */
5715 /* Send a command down to the controller */
5717 /****************************************************************************/
5719 ips_issue_i2o_memio(ips_ha_t * ha, ips_scb_t * scb)
5722 METHOD_TRACE("ips_issue_i2o_memio", 1);
5724 if (scb->scsi_cmd) {
5725 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5729 scb->cmd.basic_io.command_id,
5730 scb->bus, scb->target_id, scb->lun);
5732 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5733 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5736 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_I2O_INMSGQ);
5738 return (IPS_SUCCESS);
5741 /****************************************************************************/
5743 /* Routine Name: ips_isintr_copperhead */
5745 /* Routine Description: */
5747 /* Test to see if an interrupt is for us */
5749 /****************************************************************************/
5751 ips_isintr_copperhead(ips_ha_t * ha)
5755 METHOD_TRACE("ips_isintr_copperhead", 2);
5757 Isr = inb(ha->io_addr + IPS_REG_HISR);
5760 /* ?!?! Nothing really there */
5763 if (Isr & IPS_BIT_SCE)
5765 else if (Isr & (IPS_BIT_SQO | IPS_BIT_GHI)) {
5766 /* status queue overflow or GHI */
5767 /* just clear the interrupt */
5768 outb(Isr, ha->io_addr + IPS_REG_HISR);
5774 /****************************************************************************/
5776 /* Routine Name: ips_isintr_copperhead_memio */
5778 /* Routine Description: */
5780 /* Test to see if an interrupt is for us */
5782 /****************************************************************************/
5784 ips_isintr_copperhead_memio(ips_ha_t * ha)
5788 METHOD_TRACE("ips_isintr_memio", 2);
5790 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5793 /* ?!?! Nothing really there */
5796 if (Isr & IPS_BIT_SCE)
5798 else if (Isr & (IPS_BIT_SQO | IPS_BIT_GHI)) {
5799 /* status queue overflow or GHI */
5800 /* just clear the interrupt */
5801 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5807 /****************************************************************************/
5809 /* Routine Name: ips_isintr_morpheus */
5811 /* Routine Description: */
5813 /* Test to see if an interrupt is for us */
5815 /****************************************************************************/
5817 ips_isintr_morpheus(ips_ha_t * ha)
5821 METHOD_TRACE("ips_isintr_morpheus", 2);
5823 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5825 if (Isr & IPS_BIT_I2O_OPQI)
5831 /****************************************************************************/
5833 /* Routine Name: ips_wait */
5835 /* Routine Description: */
5837 /* Wait for a command to complete */
5839 /****************************************************************************/
5841 ips_wait(ips_ha_t * ha, int time, int intr)
5846 METHOD_TRACE("ips_wait", 1);
5851 time *= IPS_ONE_SEC; /* convert seconds */
5853 while ((time > 0) && (!done)) {
5854 if (intr == IPS_INTR_ON) {
5855 if (ha->waitflag == FALSE) {
5860 } else if (intr == IPS_INTR_IORL) {
5861 if (ha->waitflag == FALSE) {
5863 * controller generated an interrupt to
5864 * acknowledge completion of the command
5865 * and ips_intr() has serviced the interrupt.
5873 * NOTE: we already have the io_request_lock so
5874 * even if we get an interrupt it won't get serviced
5875 * until after we finish.
5878 (*ha->func.intr) (ha);
5881 /* This looks like a very evil loop, but it only does this during start-up */
5889 /****************************************************************************/
5891 /* Routine Name: ips_write_driver_status */
5893 /* Routine Description: */
5895 /* Write OS/Driver version to Page 5 of the nvram on the controller */
5897 /****************************************************************************/
5899 ips_write_driver_status(ips_ha_t * ha, int intr)
5901 METHOD_TRACE("ips_write_driver_status", 1);
5903 if (!ips_readwrite_page5(ha, FALSE, intr)) {
5904 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5905 "unable to read NVRAM page 5.\n");
5910 /* check to make sure the page has a valid */
5912 if (le32_to_cpu(ha->nvram->signature) != IPS_NVRAM_P5_SIG) {
5914 "(%s%d) NVRAM page 5 has an invalid signature: %X.",
5915 ips_name, ha->host_num, ha->nvram->signature);
5916 ha->nvram->signature = IPS_NVRAM_P5_SIG;
5920 "(%s%d) Ad Type: %d, Ad Slot: %d, BIOS: %c%c%c%c %c%c%c%c.",
5921 ips_name, ha->host_num, le16_to_cpu(ha->nvram->adapter_type),
5922 ha->nvram->adapter_slot, ha->nvram->bios_high[0],
5923 ha->nvram->bios_high[1], ha->nvram->bios_high[2],
5924 ha->nvram->bios_high[3], ha->nvram->bios_low[0],
5925 ha->nvram->bios_low[1], ha->nvram->bios_low[2],
5926 ha->nvram->bios_low[3]);
5928 ips_get_bios_version(ha, intr);
5930 /* change values (as needed) */
5931 ha->nvram->operating_system = IPS_OS_LINUX;
5932 ha->nvram->adapter_type = ha->ad_type;
5933 strncpy((char *) ha->nvram->driver_high, IPS_VERSION_HIGH, 4);
5934 strncpy((char *) ha->nvram->driver_low, IPS_VERSION_LOW, 4);
5935 strncpy((char *) ha->nvram->bios_high, ha->bios_version, 4);
5936 strncpy((char *) ha->nvram->bios_low, ha->bios_version + 4, 4);
5938 ips_version_check(ha, intr); /* Check BIOS/FW/Driver Versions */
5940 /* now update the page */
5941 if (!ips_readwrite_page5(ha, TRUE, intr)) {
5942 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5943 "unable to write NVRAM page 5.\n");
5948 /* IF NVRAM Page 5 is OK, Use it for Slot Number Info Because Linux Doesn't Do Slots */
5949 ha->slot_num = ha->nvram->adapter_slot;
5954 /****************************************************************************/
5956 /* Routine Name: ips_read_adapter_status */
5958 /* Routine Description: */
5960 /* Do an Inquiry command to the adapter */
5962 /****************************************************************************/
5964 ips_read_adapter_status(ips_ha_t * ha, int intr)
5969 METHOD_TRACE("ips_read_adapter_status", 1);
5971 scb = &ha->scbs[ha->max_cmds - 1];
5973 ips_init_scb(ha, scb);
5975 scb->timeout = ips_cmd_timeout;
5976 scb->cdb[0] = IPS_CMD_ENQUIRY;
5978 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
5979 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5980 scb->cmd.basic_io.sg_count = 0;
5981 scb->cmd.basic_io.lba = 0;
5982 scb->cmd.basic_io.sector_count = 0;
5983 scb->cmd.basic_io.log_drv = 0;
5984 scb->data_len = sizeof (*ha->enq);
5985 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
5989 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5990 || (ret == IPS_SUCCESS_IMM)
5991 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5997 /****************************************************************************/
5999 /* Routine Name: ips_read_subsystem_parameters */
6001 /* Routine Description: */
6003 /* Read subsystem parameters from the adapter */
6005 /****************************************************************************/
6007 ips_read_subsystem_parameters(ips_ha_t * ha, int intr)
6012 METHOD_TRACE("ips_read_subsystem_parameters", 1);
6014 scb = &ha->scbs[ha->max_cmds - 1];
6016 ips_init_scb(ha, scb);
6018 scb->timeout = ips_cmd_timeout;
6019 scb->cdb[0] = IPS_CMD_GET_SUBSYS;
6021 scb->cmd.basic_io.op_code = IPS_CMD_GET_SUBSYS;
6022 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
6023 scb->cmd.basic_io.sg_count = 0;
6024 scb->cmd.basic_io.lba = 0;
6025 scb->cmd.basic_io.sector_count = 0;
6026 scb->cmd.basic_io.log_drv = 0;
6027 scb->data_len = sizeof (*ha->subsys);
6028 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
6032 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6033 || (ret == IPS_SUCCESS_IMM)
6034 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6037 memcpy(ha->subsys, ha->ioctl_data, sizeof(*ha->subsys));
6041 /****************************************************************************/
6043 /* Routine Name: ips_read_config */
6045 /* Routine Description: */
6047 /* Read the configuration on the adapter */
6049 /****************************************************************************/
6051 ips_read_config(ips_ha_t * ha, int intr)
6057 METHOD_TRACE("ips_read_config", 1);
6059 /* set defaults for initiator IDs */
6060 for (i = 0; i < 4; i++)
6061 ha->conf->init_id[i] = 7;
6063 scb = &ha->scbs[ha->max_cmds - 1];
6065 ips_init_scb(ha, scb);
6067 scb->timeout = ips_cmd_timeout;
6068 scb->cdb[0] = IPS_CMD_READ_CONF;
6070 scb->cmd.basic_io.op_code = IPS_CMD_READ_CONF;
6071 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
6072 scb->data_len = sizeof (*ha->conf);
6073 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
6077 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6078 || (ret == IPS_SUCCESS_IMM)
6079 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
6081 memset(ha->conf, 0, sizeof (IPS_CONF));
6083 /* reset initiator IDs */
6084 for (i = 0; i < 4; i++)
6085 ha->conf->init_id[i] = 7;
6087 /* Allow Completed with Errors, so JCRM can access the Adapter to fix the problems */
6088 if ((scb->basic_status & IPS_GSC_STATUS_MASK) ==
6089 IPS_CMD_CMPLT_WERROR)
6095 memcpy(ha->conf, ha->ioctl_data, sizeof(*ha->conf));
6099 /****************************************************************************/
6101 /* Routine Name: ips_readwrite_page5 */
6103 /* Routine Description: */
6105 /* Read nvram page 5 from the adapter */
6107 /****************************************************************************/
6109 ips_readwrite_page5(ips_ha_t * ha, int write, int intr)
6114 METHOD_TRACE("ips_readwrite_page5", 1);
6116 scb = &ha->scbs[ha->max_cmds - 1];
6118 ips_init_scb(ha, scb);
6120 scb->timeout = ips_cmd_timeout;
6121 scb->cdb[0] = IPS_CMD_RW_NVRAM_PAGE;
6123 scb->cmd.nvram.op_code = IPS_CMD_RW_NVRAM_PAGE;
6124 scb->cmd.nvram.command_id = IPS_COMMAND_ID(ha, scb);
6125 scb->cmd.nvram.page = 5;
6126 scb->cmd.nvram.write = write;
6127 scb->cmd.nvram.reserved = 0;
6128 scb->cmd.nvram.reserved2 = 0;
6129 scb->data_len = sizeof (*ha->nvram);
6130 scb->cmd.nvram.buffer_addr = ha->ioctl_busaddr;
6132 memcpy(ha->ioctl_data, ha->nvram, sizeof(*ha->nvram));
6134 /* issue the command */
6136 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6137 || (ret == IPS_SUCCESS_IMM)
6138 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
6140 memset(ha->nvram, 0, sizeof (IPS_NVRAM_P5));
6145 memcpy(ha->nvram, ha->ioctl_data, sizeof(*ha->nvram));
6149 /****************************************************************************/
6151 /* Routine Name: ips_clear_adapter */
6153 /* Routine Description: */
6155 /* Clear the stripe lock tables */
6157 /****************************************************************************/
6159 ips_clear_adapter(ips_ha_t * ha, int intr)
6164 METHOD_TRACE("ips_clear_adapter", 1);
6166 scb = &ha->scbs[ha->max_cmds - 1];
6168 ips_init_scb(ha, scb);
6170 scb->timeout = ips_reset_timeout;
6171 scb->cdb[0] = IPS_CMD_CONFIG_SYNC;
6173 scb->cmd.config_sync.op_code = IPS_CMD_CONFIG_SYNC;
6174 scb->cmd.config_sync.command_id = IPS_COMMAND_ID(ha, scb);
6175 scb->cmd.config_sync.channel = 0;
6176 scb->cmd.config_sync.source_target = IPS_POCL;
6177 scb->cmd.config_sync.reserved = 0;
6178 scb->cmd.config_sync.reserved2 = 0;
6179 scb->cmd.config_sync.reserved3 = 0;
6183 ips_send_wait(ha, scb, ips_reset_timeout, intr)) == IPS_FAILURE)
6184 || (ret == IPS_SUCCESS_IMM)
6185 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6188 /* send unlock stripe command */
6189 ips_init_scb(ha, scb);
6191 scb->cdb[0] = IPS_CMD_ERROR_TABLE;
6192 scb->timeout = ips_reset_timeout;
6194 scb->cmd.unlock_stripe.op_code = IPS_CMD_ERROR_TABLE;
6195 scb->cmd.unlock_stripe.command_id = IPS_COMMAND_ID(ha, scb);
6196 scb->cmd.unlock_stripe.log_drv = 0;
6197 scb->cmd.unlock_stripe.control = IPS_CSL;
6198 scb->cmd.unlock_stripe.reserved = 0;
6199 scb->cmd.unlock_stripe.reserved2 = 0;
6200 scb->cmd.unlock_stripe.reserved3 = 0;
6204 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6205 || (ret == IPS_SUCCESS_IMM)
6206 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6212 /****************************************************************************/
6214 /* Routine Name: ips_ffdc_reset */
6216 /* Routine Description: */
6218 /* FFDC: write reset info */
6220 /****************************************************************************/
6222 ips_ffdc_reset(ips_ha_t * ha, int intr)
6226 METHOD_TRACE("ips_ffdc_reset", 1);
6228 scb = &ha->scbs[ha->max_cmds - 1];
6230 ips_init_scb(ha, scb);
6232 scb->timeout = ips_cmd_timeout;
6233 scb->cdb[0] = IPS_CMD_FFDC;
6234 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
6235 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
6236 scb->cmd.ffdc.reset_count = ha->reset_count;
6237 scb->cmd.ffdc.reset_type = 0x80;
6239 /* convert time to what the card wants */
6240 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
6243 ips_send_wait(ha, scb, ips_cmd_timeout, intr);
6246 /****************************************************************************/
6248 /* Routine Name: ips_ffdc_time */
6250 /* Routine Description: */
6252 /* FFDC: write time info */
6254 /****************************************************************************/
6256 ips_ffdc_time(ips_ha_t * ha)
6260 METHOD_TRACE("ips_ffdc_time", 1);
6262 DEBUG_VAR(1, "(%s%d) Sending time update.", ips_name, ha->host_num);
6264 scb = &ha->scbs[ha->max_cmds - 1];
6266 ips_init_scb(ha, scb);
6268 scb->timeout = ips_cmd_timeout;
6269 scb->cdb[0] = IPS_CMD_FFDC;
6270 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
6271 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
6272 scb->cmd.ffdc.reset_count = 0;
6273 scb->cmd.ffdc.reset_type = 0;
6275 /* convert time to what the card wants */
6276 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
6279 ips_send_wait(ha, scb, ips_cmd_timeout, IPS_FFDC);
6282 /****************************************************************************/
6284 /* Routine Name: ips_fix_ffdc_time */
6286 /* Routine Description: */
6287 /* Adjust time_t to what the card wants */
6289 /****************************************************************************/
6291 ips_fix_ffdc_time(ips_ha_t * ha, ips_scb_t * scb, time_t current_time)
6298 int year_lengths[2] = { IPS_DAYS_NORMAL_YEAR, IPS_DAYS_LEAP_YEAR };
6299 int month_lengths[12][2] = { {31, 31},
6313 METHOD_TRACE("ips_fix_ffdc_time", 1);
6315 days = current_time / IPS_SECS_DAY;
6316 rem = current_time % IPS_SECS_DAY;
6318 scb->cmd.ffdc.hour = (rem / IPS_SECS_HOUR);
6319 rem = rem % IPS_SECS_HOUR;
6320 scb->cmd.ffdc.minute = (rem / IPS_SECS_MIN);
6321 scb->cmd.ffdc.second = (rem % IPS_SECS_MIN);
6323 year = IPS_EPOCH_YEAR;
6324 while (days < 0 || days >= year_lengths[yleap = IPS_IS_LEAP_YEAR(year)]) {
6327 newy = year + (days / IPS_DAYS_NORMAL_YEAR);
6330 days -= (newy - year) * IPS_DAYS_NORMAL_YEAR +
6331 IPS_NUM_LEAP_YEARS_THROUGH(newy - 1) -
6332 IPS_NUM_LEAP_YEARS_THROUGH(year - 1);
6336 scb->cmd.ffdc.yearH = year / 100;
6337 scb->cmd.ffdc.yearL = year % 100;
6339 for (i = 0; days >= month_lengths[i][yleap]; ++i)
6340 days -= month_lengths[i][yleap];
6342 scb->cmd.ffdc.month = i + 1;
6343 scb->cmd.ffdc.day = days + 1;
6346 /****************************************************************************
6347 * BIOS Flash Routines *
6348 ****************************************************************************/
6350 /****************************************************************************/
6352 /* Routine Name: ips_erase_bios */
6354 /* Routine Description: */
6355 /* Erase the BIOS on the adapter */
6357 /****************************************************************************/
6359 ips_erase_bios(ips_ha_t * ha)
6364 METHOD_TRACE("ips_erase_bios", 1);
6368 /* Clear the status register */
6369 outl(0, ha->io_addr + IPS_REG_FLAP);
6370 if (ha->revision_id == IPS_REVID_TROMBONE64)
6371 udelay(25); /* 25 us */
6373 outb(0x50, ha->io_addr + IPS_REG_FLDP);
6374 if (ha->revision_id == IPS_REVID_TROMBONE64)
6375 udelay(25); /* 25 us */
6378 outb(0x20, ha->io_addr + IPS_REG_FLDP);
6379 if (ha->revision_id == IPS_REVID_TROMBONE64)
6380 udelay(25); /* 25 us */
6383 outb(0xD0, ha->io_addr + IPS_REG_FLDP);
6384 if (ha->revision_id == IPS_REVID_TROMBONE64)
6385 udelay(25); /* 25 us */
6388 outb(0x70, ha->io_addr + IPS_REG_FLDP);
6389 if (ha->revision_id == IPS_REVID_TROMBONE64)
6390 udelay(25); /* 25 us */
6392 timeout = 80000; /* 80 seconds */
6394 while (timeout > 0) {
6395 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6396 outl(0, ha->io_addr + IPS_REG_FLAP);
6397 udelay(25); /* 25 us */
6400 status = inb(ha->io_addr + IPS_REG_FLDP);
6409 /* check for timeout */
6413 /* try to suspend the erase */
6414 outb(0xB0, ha->io_addr + IPS_REG_FLDP);
6415 if (ha->revision_id == IPS_REVID_TROMBONE64)
6416 udelay(25); /* 25 us */
6418 /* wait for 10 seconds */
6420 while (timeout > 0) {
6421 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6422 outl(0, ha->io_addr + IPS_REG_FLAP);
6423 udelay(25); /* 25 us */
6426 status = inb(ha->io_addr + IPS_REG_FLDP);
6438 /* check for valid VPP */
6443 /* check for succesful flash */
6445 /* sequence error */
6448 /* Otherwise, we were successful */
6450 outb(0x50, ha->io_addr + IPS_REG_FLDP);
6451 if (ha->revision_id == IPS_REVID_TROMBONE64)
6452 udelay(25); /* 25 us */
6455 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6456 if (ha->revision_id == IPS_REVID_TROMBONE64)
6457 udelay(25); /* 25 us */
6462 /****************************************************************************/
6464 /* Routine Name: ips_erase_bios_memio */
6466 /* Routine Description: */
6467 /* Erase the BIOS on the adapter */
6469 /****************************************************************************/
6471 ips_erase_bios_memio(ips_ha_t * ha)
6476 METHOD_TRACE("ips_erase_bios_memio", 1);
6480 /* Clear the status register */
6481 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6482 if (ha->revision_id == IPS_REVID_TROMBONE64)
6483 udelay(25); /* 25 us */
6485 writeb(0x50, ha->mem_ptr + IPS_REG_FLDP);
6486 if (ha->revision_id == IPS_REVID_TROMBONE64)
6487 udelay(25); /* 25 us */
6490 writeb(0x20, ha->mem_ptr + IPS_REG_FLDP);
6491 if (ha->revision_id == IPS_REVID_TROMBONE64)
6492 udelay(25); /* 25 us */
6495 writeb(0xD0, ha->mem_ptr + IPS_REG_FLDP);
6496 if (ha->revision_id == IPS_REVID_TROMBONE64)
6497 udelay(25); /* 25 us */
6500 writeb(0x70, ha->mem_ptr + IPS_REG_FLDP);
6501 if (ha->revision_id == IPS_REVID_TROMBONE64)
6502 udelay(25); /* 25 us */
6504 timeout = 80000; /* 80 seconds */
6506 while (timeout > 0) {
6507 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6508 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6509 udelay(25); /* 25 us */
6512 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6521 /* check for timeout */
6525 /* try to suspend the erase */
6526 writeb(0xB0, ha->mem_ptr + IPS_REG_FLDP);
6527 if (ha->revision_id == IPS_REVID_TROMBONE64)
6528 udelay(25); /* 25 us */
6530 /* wait for 10 seconds */
6532 while (timeout > 0) {
6533 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6534 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6535 udelay(25); /* 25 us */
6538 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6550 /* check for valid VPP */
6555 /* check for succesful flash */
6557 /* sequence error */
6560 /* Otherwise, we were successful */
6562 writeb(0x50, ha->mem_ptr + IPS_REG_FLDP);
6563 if (ha->revision_id == IPS_REVID_TROMBONE64)
6564 udelay(25); /* 25 us */
6567 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6568 if (ha->revision_id == IPS_REVID_TROMBONE64)
6569 udelay(25); /* 25 us */
6574 /****************************************************************************/
6576 /* Routine Name: ips_program_bios */
6578 /* Routine Description: */
6579 /* Program the BIOS on the adapter */
6581 /****************************************************************************/
6583 ips_program_bios(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6590 METHOD_TRACE("ips_program_bios", 1);
6594 for (i = 0; i < buffersize; i++) {
6596 outl(cpu_to_le32(i + offset), ha->io_addr + IPS_REG_FLAP);
6597 if (ha->revision_id == IPS_REVID_TROMBONE64)
6598 udelay(25); /* 25 us */
6600 outb(0x40, ha->io_addr + IPS_REG_FLDP);
6601 if (ha->revision_id == IPS_REVID_TROMBONE64)
6602 udelay(25); /* 25 us */
6604 outb(buffer[i], ha->io_addr + IPS_REG_FLDP);
6605 if (ha->revision_id == IPS_REVID_TROMBONE64)
6606 udelay(25); /* 25 us */
6608 /* wait up to one second */
6610 while (timeout > 0) {
6611 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6612 outl(0, ha->io_addr + IPS_REG_FLAP);
6613 udelay(25); /* 25 us */
6616 status = inb(ha->io_addr + IPS_REG_FLDP);
6627 outl(0, ha->io_addr + IPS_REG_FLAP);
6628 if (ha->revision_id == IPS_REVID_TROMBONE64)
6629 udelay(25); /* 25 us */
6631 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6632 if (ha->revision_id == IPS_REVID_TROMBONE64)
6633 udelay(25); /* 25 us */
6638 /* check the status */
6639 if (status & 0x18) {
6640 /* programming error */
6641 outl(0, ha->io_addr + IPS_REG_FLAP);
6642 if (ha->revision_id == IPS_REVID_TROMBONE64)
6643 udelay(25); /* 25 us */
6645 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6646 if (ha->revision_id == IPS_REVID_TROMBONE64)
6647 udelay(25); /* 25 us */
6653 /* Enable reading */
6654 outl(0, ha->io_addr + IPS_REG_FLAP);
6655 if (ha->revision_id == IPS_REVID_TROMBONE64)
6656 udelay(25); /* 25 us */
6658 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6659 if (ha->revision_id == IPS_REVID_TROMBONE64)
6660 udelay(25); /* 25 us */
6665 /****************************************************************************/
6667 /* Routine Name: ips_program_bios_memio */
6669 /* Routine Description: */
6670 /* Program the BIOS on the adapter */
6672 /****************************************************************************/
6674 ips_program_bios_memio(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6681 METHOD_TRACE("ips_program_bios_memio", 1);
6685 for (i = 0; i < buffersize; i++) {
6687 writel(i + offset, ha->mem_ptr + IPS_REG_FLAP);
6688 if (ha->revision_id == IPS_REVID_TROMBONE64)
6689 udelay(25); /* 25 us */
6691 writeb(0x40, ha->mem_ptr + IPS_REG_FLDP);
6692 if (ha->revision_id == IPS_REVID_TROMBONE64)
6693 udelay(25); /* 25 us */
6695 writeb(buffer[i], ha->mem_ptr + IPS_REG_FLDP);
6696 if (ha->revision_id == IPS_REVID_TROMBONE64)
6697 udelay(25); /* 25 us */
6699 /* wait up to one second */
6701 while (timeout > 0) {
6702 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6703 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6704 udelay(25); /* 25 us */
6707 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6718 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6719 if (ha->revision_id == IPS_REVID_TROMBONE64)
6720 udelay(25); /* 25 us */
6722 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6723 if (ha->revision_id == IPS_REVID_TROMBONE64)
6724 udelay(25); /* 25 us */
6729 /* check the status */
6730 if (status & 0x18) {
6731 /* programming error */
6732 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6733 if (ha->revision_id == IPS_REVID_TROMBONE64)
6734 udelay(25); /* 25 us */
6736 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6737 if (ha->revision_id == IPS_REVID_TROMBONE64)
6738 udelay(25); /* 25 us */
6744 /* Enable reading */
6745 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6746 if (ha->revision_id == IPS_REVID_TROMBONE64)
6747 udelay(25); /* 25 us */
6749 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6750 if (ha->revision_id == IPS_REVID_TROMBONE64)
6751 udelay(25); /* 25 us */
6756 /****************************************************************************/
6758 /* Routine Name: ips_verify_bios */
6760 /* Routine Description: */
6761 /* Verify the BIOS on the adapter */
6763 /****************************************************************************/
6765 ips_verify_bios(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6771 METHOD_TRACE("ips_verify_bios", 1);
6774 outl(0, ha->io_addr + IPS_REG_FLAP);
6775 if (ha->revision_id == IPS_REVID_TROMBONE64)
6776 udelay(25); /* 25 us */
6778 if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
6781 outl(cpu_to_le32(1), ha->io_addr + IPS_REG_FLAP);
6782 if (ha->revision_id == IPS_REVID_TROMBONE64)
6783 udelay(25); /* 25 us */
6784 if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
6788 for (i = 2; i < buffersize; i++) {
6790 outl(cpu_to_le32(i + offset), ha->io_addr + IPS_REG_FLAP);
6791 if (ha->revision_id == IPS_REVID_TROMBONE64)
6792 udelay(25); /* 25 us */
6794 checksum = (uint8_t) checksum + inb(ha->io_addr + IPS_REG_FLDP);
6805 /****************************************************************************/
6807 /* Routine Name: ips_verify_bios_memio */
6809 /* Routine Description: */
6810 /* Verify the BIOS on the adapter */
6812 /****************************************************************************/
6814 ips_verify_bios_memio(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6820 METHOD_TRACE("ips_verify_bios_memio", 1);
6823 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6824 if (ha->revision_id == IPS_REVID_TROMBONE64)
6825 udelay(25); /* 25 us */
6827 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
6830 writel(1, ha->mem_ptr + IPS_REG_FLAP);
6831 if (ha->revision_id == IPS_REVID_TROMBONE64)
6832 udelay(25); /* 25 us */
6833 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
6837 for (i = 2; i < buffersize; i++) {
6839 writel(i + offset, ha->mem_ptr + IPS_REG_FLAP);
6840 if (ha->revision_id == IPS_REVID_TROMBONE64)
6841 udelay(25); /* 25 us */
6844 (uint8_t) checksum + readb(ha->mem_ptr + IPS_REG_FLDP);
6855 /*---------------------------------------------------------------------------*/
6856 /* Routine Name: ips_version_check */
6859 /* Assumes that ips_read_adapter_status() is called first filling in */
6860 /* the data for SubSystem Parameters. */
6861 /* Called from ips_write_driver_status() so it also assumes NVRAM Page 5 */
6862 /* Data is available. */
6864 /*---------------------------------------------------------------------------*/
6866 ips_version_check(ips_ha_t * ha, int intr)
6868 IPS_VERSION_DATA *VersionInfo;
6869 uint8_t FirmwareVersion[IPS_COMPAT_ID_LENGTH + 1];
6870 uint8_t BiosVersion[IPS_COMPAT_ID_LENGTH + 1];
6873 char BiosString[10];
6874 char FirmwareString[10];
6876 METHOD_TRACE("ips_version_check", 1);
6878 VersionInfo = ( IPS_VERSION_DATA * ) ha->ioctl_data;
6880 memset(FirmwareVersion, 0, IPS_COMPAT_ID_LENGTH + 1);
6881 memset(BiosVersion, 0, IPS_COMPAT_ID_LENGTH + 1);
6883 /* Get the Compatible BIOS Version from NVRAM Page 5 */
6884 memcpy(BiosVersion, ha->nvram->BiosCompatibilityID,
6885 IPS_COMPAT_ID_LENGTH);
6888 if (ha->subsys->param[4] & IPS_GET_VERSION_SUPPORT) { /* If Versioning is Supported */
6889 /* Get the Version Info with a Get Version Command */
6890 memset( VersionInfo, 0, sizeof (IPS_VERSION_DATA));
6891 rc = ips_get_version_info(ha, ha->ioctl_busaddr, intr);
6892 if (rc == IPS_SUCCESS)
6893 memcpy(FirmwareVersion, VersionInfo->compatibilityId,
6894 IPS_COMPAT_ID_LENGTH);
6897 if (rc != IPS_SUCCESS) { /* If Data Not Obtainable from a GetVersion Command */
6898 /* Get the Firmware Version from Enquiry Data */
6899 memcpy(FirmwareVersion, ha->enq->CodeBlkVersion,
6900 IPS_COMPAT_ID_LENGTH);
6903 /* printk(KERN_WARNING "Adapter's BIOS Version = %s\n", BiosVersion); */
6904 /* printk(KERN_WARNING "BIOS Compatible Version = %s\n", IPS_COMPAT_BIOS); */
6905 /* printk(KERN_WARNING "Adapter's Firmware Version = %s\n", FirmwareVersion); */
6906 /* printk(KERN_WARNING "Firmware Compatible Version = %s \n", Compatable[ ha->nvram->adapter_type ]); */
6911 (FirmwareVersion, Compatable[ha->nvram->adapter_type],
6912 IPS_COMPAT_ID_LENGTH) != 0)
6915 if (strncmp(BiosVersion, IPS_COMPAT_BIOS, IPS_COMPAT_ID_LENGTH) != 0)
6918 ha->nvram->versioning = 1; /* Indicate the Driver Supports Versioning */
6921 ha->nvram->version_mismatch = 1;
6922 if (ips_cd_boot == 0) {
6923 strncpy(&BiosString[0], ha->nvram->bios_high, 4);
6924 strncpy(&BiosString[4], ha->nvram->bios_low, 4);
6927 strncpy(&FirmwareString[0], ha->enq->CodeBlkVersion, 8);
6928 FirmwareString[8] = 0;
6930 IPS_PRINTK(KERN_WARNING, ha->pcidev,
6931 "Warning ! ! ! ServeRAID Version Mismatch\n");
6932 IPS_PRINTK(KERN_WARNING, ha->pcidev,
6933 "Bios = %s, Firmware = %s, Device Driver = %s%s\n",
6934 BiosString, FirmwareString, IPS_VERSION_HIGH,
6936 IPS_PRINTK(KERN_WARNING, ha->pcidev,
6937 "These levels should match to avoid possible compatibility problems.\n");
6940 ha->nvram->version_mismatch = 0;
6946 /*---------------------------------------------------------------------------*/
6947 /* Routine Name: ips_get_version_info */
6949 /* Routine Description: */
6950 /* Issue an internal GETVERSION Command */
6953 /* 0 if Successful, else non-zero */
6954 /*---------------------------------------------------------------------------*/
6956 ips_get_version_info(ips_ha_t * ha, dma_addr_t Buffer, int intr)
6961 METHOD_TRACE("ips_get_version_info", 1);
6963 scb = &ha->scbs[ha->max_cmds - 1];
6965 ips_init_scb(ha, scb);
6967 scb->timeout = ips_cmd_timeout;
6968 scb->cdb[0] = IPS_CMD_GET_VERSION_INFO;
6969 scb->cmd.version_info.op_code = IPS_CMD_GET_VERSION_INFO;
6970 scb->cmd.version_info.command_id = IPS_COMMAND_ID(ha, scb);
6971 scb->cmd.version_info.reserved = 0;
6972 scb->cmd.version_info.count = sizeof (IPS_VERSION_DATA);
6973 scb->cmd.version_info.reserved2 = 0;
6974 scb->data_len = sizeof (IPS_VERSION_DATA);
6975 scb->data_busaddr = Buffer;
6976 scb->cmd.version_info.buffer_addr = Buffer;
6980 rc = ips_send_wait(ha, scb, ips_cmd_timeout, intr);
6984 /****************************************************************************/
6986 /* Routine Name: ips_abort_init */
6988 /* Routine Description: */
6989 /* cleanup routine for a failed adapter initialization */
6990 /****************************************************************************/
6992 ips_abort_init(ips_ha_t * ha, int index)
6996 ips_ha[index] = NULL;
6997 ips_sh[index] = NULL;
7001 /****************************************************************************/
7003 /* Routine Name: ips_shift_controllers */
7005 /* Routine Description: */
7006 /* helper function for ordering adapters */
7007 /****************************************************************************/
7009 ips_shift_controllers(int lowindex, int highindex)
7011 ips_ha_t *ha_sav = ips_ha[highindex];
7012 struct Scsi_Host *sh_sav = ips_sh[highindex];
7015 for (i = highindex; i > lowindex; i--) {
7016 ips_ha[i] = ips_ha[i - 1];
7017 ips_sh[i] = ips_sh[i - 1];
7018 ips_ha[i]->host_num = i;
7020 ha_sav->host_num = lowindex;
7021 ips_ha[lowindex] = ha_sav;
7022 ips_sh[lowindex] = sh_sav;
7025 /****************************************************************************/
7027 /* Routine Name: ips_order_controllers */
7029 /* Routine Description: */
7030 /* place controllers is the "proper" boot order */
7031 /****************************************************************************/
7033 ips_order_controllers(void)
7035 int i, j, tmp, position = 0;
7036 IPS_NVRAM_P5 *nvram;
7039 nvram = ips_ha[0]->nvram;
7041 if (nvram->adapter_order[0]) {
7042 for (i = 1; i <= nvram->adapter_order[0]; i++) {
7043 for (j = position; j < ips_num_controllers; j++) {
7044 switch (ips_ha[j]->ad_type) {
7045 case IPS_ADTYPE_SERVERAID6M:
7046 case IPS_ADTYPE_SERVERAID7M:
7047 if (nvram->adapter_order[i] == 'M') {
7048 ips_shift_controllers(position,
7053 case IPS_ADTYPE_SERVERAID4L:
7054 case IPS_ADTYPE_SERVERAID4M:
7055 case IPS_ADTYPE_SERVERAID4MX:
7056 case IPS_ADTYPE_SERVERAID4LX:
7057 if (nvram->adapter_order[i] == 'N') {
7058 ips_shift_controllers(position,
7063 case IPS_ADTYPE_SERVERAID6I:
7064 case IPS_ADTYPE_SERVERAID5I2:
7065 case IPS_ADTYPE_SERVERAID5I1:
7066 case IPS_ADTYPE_SERVERAID7k:
7067 if (nvram->adapter_order[i] == 'S') {
7068 ips_shift_controllers(position,
7073 case IPS_ADTYPE_SERVERAID:
7074 case IPS_ADTYPE_SERVERAID2:
7075 case IPS_ADTYPE_NAVAJO:
7076 case IPS_ADTYPE_KIOWA:
7077 case IPS_ADTYPE_SERVERAID3L:
7078 case IPS_ADTYPE_SERVERAID3:
7079 case IPS_ADTYPE_SERVERAID4H:
7080 if (nvram->adapter_order[i] == 'A') {
7081 ips_shift_controllers(position,
7091 /* if adapter_order[0], then ordering is complete */
7094 /* old bios, use older ordering */
7096 for (i = position; i < ips_num_controllers; i++) {
7097 if (ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID5I2 ||
7098 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID5I1) {
7099 ips_shift_controllers(position, i);
7104 /* if there were no 5I cards, then don't do any extra ordering */
7107 for (i = position; i < ips_num_controllers; i++) {
7108 if (ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4L ||
7109 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4M ||
7110 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4LX ||
7111 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4MX) {
7112 ips_shift_controllers(position, i);
7120 /****************************************************************************/
7122 /* Routine Name: ips_register_scsi */
7124 /* Routine Description: */
7125 /* perform any registration and setup with the scsi layer */
7126 /****************************************************************************/
7128 ips_register_scsi(int index)
7130 struct Scsi_Host *sh;
7131 ips_ha_t *ha, *oldha = ips_ha[index];
7132 sh = scsi_host_alloc(&ips_driver_template, sizeof (ips_ha_t));
7134 IPS_PRINTK(KERN_WARNING, oldha->pcidev,
7135 "Unable to register controller with SCSI subsystem\n");
7139 memcpy(ha, oldha, sizeof (ips_ha_t));
7140 free_irq(oldha->irq, oldha);
7141 /* Install the interrupt handler with the new ha */
7142 if (request_irq(ha->irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
7143 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7144 "Unable to install interrupt handler\n");
7152 IPS_SCSI_SET_DEVICE(sh, ha);
7154 /* Store away needed values for later use */
7155 sh->io_port = ha->io_addr;
7156 sh->n_io_port = ha->io_addr ? 255 : 0;
7157 sh->unique_id = (ha->io_addr) ? ha->io_addr : ha->mem_addr;
7159 sh->sg_tablesize = sh->hostt->sg_tablesize;
7160 sh->can_queue = sh->hostt->can_queue;
7161 sh->cmd_per_lun = sh->hostt->cmd_per_lun;
7162 sh->unchecked_isa_dma = sh->hostt->unchecked_isa_dma;
7163 sh->use_clustering = sh->hostt->use_clustering;
7165 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,7)
7166 sh->max_sectors = 128;
7169 sh->max_id = ha->ntargets;
7170 sh->max_lun = ha->nlun;
7171 sh->max_channel = ha->nbus - 1;
7172 sh->can_queue = ha->max_cmds - 1;
7174 IPS_ADD_HOST(sh, NULL);
7178 /*---------------------------------------------------------------------------*/
7179 /* Routine Name: ips_remove_device */
7181 /* Routine Description: */
7182 /* Remove one Adapter ( Hot Plugging ) */
7183 /*---------------------------------------------------------------------------*/
7184 static void __devexit
7185 ips_remove_device(struct pci_dev *pci_dev)
7188 struct Scsi_Host *sh;
7191 for (i = 0; i < IPS_MAX_ADAPTERS; i++) {
7194 if ((pci_dev->bus->number == ha->pcidev->bus->number) &&
7195 (pci_dev->devfn == ha->pcidev->devfn)) {
7203 /****************************************************************************/
7205 /* Routine Name: ips_module_init */
7207 /* Routine Description: */
7208 /* function called on module load */
7209 /****************************************************************************/
7211 ips_module_init(void)
7213 if (pci_module_init(&ips_pci_driver) < 0)
7215 ips_driver_template.module = THIS_MODULE;
7216 ips_order_controllers();
7217 if (IPS_REGISTER_HOSTS(&ips_driver_template)) {
7218 pci_unregister_driver(&ips_pci_driver);
7221 register_reboot_notifier(&ips_notifier);
7225 /****************************************************************************/
7227 /* Routine Name: ips_module_exit */
7229 /* Routine Description: */
7230 /* function called on module unload */
7231 /****************************************************************************/
7233 ips_module_exit(void)
7235 IPS_UNREGISTER_HOSTS(&ips_driver_template);
7236 pci_unregister_driver(&ips_pci_driver);
7237 unregister_reboot_notifier(&ips_notifier);
7240 module_init(ips_module_init);
7241 module_exit(ips_module_exit);
7243 /*---------------------------------------------------------------------------*/
7244 /* Routine Name: ips_insert_device */
7246 /* Routine Description: */
7247 /* Add One Adapter ( Hot Plug ) */
7250 /* 0 if Successful, else non-zero */
7251 /*---------------------------------------------------------------------------*/
7252 static int __devinit
7253 ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent)
7258 METHOD_TRACE("ips_insert_device", 1);
7259 if (pci_enable_device(pci_dev))
7262 rc = ips_init_phase1(pci_dev, &index);
7264 rc = ips_init_phase2(index);
7267 if (ips_register_scsi(index)) {
7268 ips_free(ips_ha[index]);
7273 ips_num_controllers++;
7275 ips_next_controller = ips_num_controllers;
7279 /*---------------------------------------------------------------------------*/
7280 /* Routine Name: ips_init_phase1 */
7282 /* Routine Description: */
7283 /* Adapter Initialization */
7286 /* 0 if Successful, else non-zero */
7287 /*---------------------------------------------------------------------------*/
7289 ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr)
7296 uint8_t revision_id;
7300 uint16_t subdevice_id;
7303 dma_addr_t dma_address;
7304 char __iomem *ioremap_ptr;
7305 char __iomem *mem_ptr;
7308 METHOD_TRACE("ips_init_phase1", 1);
7309 index = IPS_MAX_ADAPTERS;
7310 for (j = 0; j < IPS_MAX_ADAPTERS; j++) {
7311 if (ips_ha[j] == 0) {
7317 if (index >= IPS_MAX_ADAPTERS)
7320 /* stuff that we get in dev */
7322 bus = pci_dev->bus->number;
7323 func = pci_dev->devfn;
7325 /* Init MEM/IO addresses to 0 */
7331 for (j = 0; j < 2; j++) {
7332 if (!pci_resource_start(pci_dev, j))
7335 if (pci_resource_flags(pci_dev, j) & IORESOURCE_IO) {
7336 io_addr = pci_resource_start(pci_dev, j);
7337 io_len = pci_resource_len(pci_dev, j);
7339 mem_addr = pci_resource_start(pci_dev, j);
7340 mem_len = pci_resource_len(pci_dev, j);
7344 /* setup memory mapped area (if applicable) */
7349 if (!request_mem_region(mem_addr, mem_len, "ips")) {
7350 IPS_PRINTK(KERN_WARNING, pci_dev,
7351 "Couldn't allocate IO Memory space %x len %d.\n",
7356 base = mem_addr & PAGE_MASK;
7357 offs = mem_addr - base;
7358 ioremap_ptr = ioremap(base, PAGE_SIZE);
7359 mem_ptr = ioremap_ptr + offs;
7365 /* setup I/O mapped area (if applicable) */
7367 if (!request_region(io_addr, io_len, "ips")) {
7368 IPS_PRINTK(KERN_WARNING, pci_dev,
7369 "Couldn't allocate IO space %x len %d.\n",
7375 /* get the revision ID */
7376 if (pci_read_config_byte(pci_dev, PCI_REVISION_ID, &revision_id)) {
7377 IPS_PRINTK(KERN_WARNING, pci_dev, "Can't get revision id.\n");
7381 subdevice_id = pci_dev->subsystem_device;
7383 /* found a controller */
7384 ha = kmalloc(sizeof (ips_ha_t), GFP_KERNEL);
7386 IPS_PRINTK(KERN_WARNING, pci_dev,
7387 "Unable to allocate temporary ha struct\n");
7391 memset(ha, 0, sizeof (ips_ha_t));
7393 ips_sh[index] = NULL;
7397 /* Store info in HA structure */
7399 ha->io_addr = io_addr;
7400 ha->io_len = io_len;
7401 ha->mem_addr = mem_addr;
7402 ha->mem_len = mem_len;
7403 ha->mem_ptr = mem_ptr;
7404 ha->ioremap_ptr = ioremap_ptr;
7405 ha->host_num = (uint32_t) index;
7406 ha->revision_id = revision_id;
7407 ha->slot_num = PCI_SLOT(pci_dev->devfn);
7408 ha->device_id = pci_dev->device;
7409 ha->subdevice_id = subdevice_id;
7410 ha->pcidev = pci_dev;
7413 * Set the pci_dev's dma_mask. Not all adapters support 64bit
7414 * addressing so don't enable it if the adapter can't support
7415 * it! Also, don't use 64bit addressing if dma addresses
7416 * are guaranteed to be < 4G.
7418 if (IPS_ENABLE_DMA64 && IPS_HAS_ENH_SGLIST(ha) &&
7419 !pci_set_dma_mask(ha->pcidev, 0xffffffffffffffffULL)) {
7420 (ha)->flags |= IPS_HA_ENH_SG;
7422 if (pci_set_dma_mask(ha->pcidev, 0xffffffffULL) != 0) {
7423 printk(KERN_WARNING "Unable to set DMA Mask\n");
7424 return ips_abort_init(ha, index);
7427 if(ips_cd_boot && !ips_FlashData){
7428 ips_FlashData = pci_alloc_consistent(pci_dev, PAGE_SIZE << 7,
7432 ha->enq = pci_alloc_consistent(pci_dev, sizeof (IPS_ENQ),
7435 IPS_PRINTK(KERN_WARNING, pci_dev,
7436 "Unable to allocate host inquiry structure\n");
7437 return ips_abort_init(ha, index);
7440 ha->adapt = pci_alloc_consistent(pci_dev, sizeof (IPS_ADAPTER) +
7441 sizeof (IPS_IO_CMD), &dma_address);
7443 IPS_PRINTK(KERN_WARNING, pci_dev,
7444 "Unable to allocate host adapt & dummy structures\n");
7445 return ips_abort_init(ha, index);
7447 ha->adapt->hw_status_start = dma_address;
7448 ha->dummy = (void *) (ha->adapt + 1);
7452 ha->logical_drive_info = pci_alloc_consistent(pci_dev, sizeof (IPS_LD_INFO), &dma_address);
7453 if (!ha->logical_drive_info) {
7454 IPS_PRINTK(KERN_WARNING, pci_dev,
7455 "Unable to allocate logical drive info structure\n");
7456 return ips_abort_init(ha, index);
7458 ha->logical_drive_info_dma_addr = dma_address;
7461 ha->conf = kmalloc(sizeof (IPS_CONF), GFP_KERNEL);
7464 IPS_PRINTK(KERN_WARNING, pci_dev,
7465 "Unable to allocate host conf structure\n");
7466 return ips_abort_init(ha, index);
7469 ha->nvram = kmalloc(sizeof (IPS_NVRAM_P5), GFP_KERNEL);
7472 IPS_PRINTK(KERN_WARNING, pci_dev,
7473 "Unable to allocate host NVRAM structure\n");
7474 return ips_abort_init(ha, index);
7477 ha->subsys = kmalloc(sizeof (IPS_SUBSYS), GFP_KERNEL);
7480 IPS_PRINTK(KERN_WARNING, pci_dev,
7481 "Unable to allocate host subsystem structure\n");
7482 return ips_abort_init(ha, index);
7485 /* the ioctl buffer is now used during adapter initialization, so its
7486 * successful allocation is now required */
7487 if (ips_ioctlsize < PAGE_SIZE)
7488 ips_ioctlsize = PAGE_SIZE;
7490 ha->ioctl_data = pci_alloc_consistent(pci_dev, ips_ioctlsize,
7491 &ha->ioctl_busaddr);
7492 ha->ioctl_len = ips_ioctlsize;
7493 if (!ha->ioctl_data) {
7494 IPS_PRINTK(KERN_WARNING, pci_dev,
7495 "Unable to allocate IOCTL data\n");
7496 return ips_abort_init(ha, index);
7502 ips_setup_funclist(ha);
7504 if ((IPS_IS_MORPHEUS(ha)) || (IPS_IS_MARCO(ha))) {
7505 /* If Morpheus appears dead, reset it */
7506 IsDead = readl(ha->mem_ptr + IPS_REG_I960_MSG1);
7507 if (IsDead == 0xDEADBEEF) {
7508 ips_reset_morpheus(ha);
7513 * Initialize the card if it isn't already
7516 if (!(*ha->func.isinit) (ha)) {
7517 if (!(*ha->func.init) (ha)) {
7519 * Initialization failed
7521 IPS_PRINTK(KERN_WARNING, pci_dev,
7522 "Unable to initialize controller\n");
7523 return ips_abort_init(ha, index);
7531 /*---------------------------------------------------------------------------*/
7532 /* Routine Name: ips_init_phase2 */
7534 /* Routine Description: */
7535 /* Adapter Initialization Phase 2 */
7538 /* 0 if Successful, else non-zero */
7539 /*---------------------------------------------------------------------------*/
7541 ips_init_phase2(int index)
7547 METHOD_TRACE("ips_init_phase2", 1);
7549 ips_ha[index] = NULL;
7553 /* Install the interrupt handler */
7554 if (request_irq(ha->irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
7555 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7556 "Unable to install interrupt handler\n");
7557 return ips_abort_init(ha, index);
7561 * Allocate a temporary SCB for initialization
7564 if (!ips_allocatescbs(ha)) {
7565 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7566 "Unable to allocate a CCB\n");
7567 free_irq(ha->irq, ha);
7568 return ips_abort_init(ha, index);
7571 if (!ips_hainit(ha)) {
7572 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7573 "Unable to initialize controller\n");
7574 free_irq(ha->irq, ha);
7575 return ips_abort_init(ha, index);
7577 /* Free the temporary SCB */
7578 ips_deallocatescbs(ha, 1);
7581 if (!ips_allocatescbs(ha)) {
7582 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7583 "Unable to allocate CCBs\n");
7584 free_irq(ha->irq, ha);
7585 return ips_abort_init(ha, index);
7591 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9)
7592 MODULE_LICENSE("GPL");
7595 MODULE_DESCRIPTION("IBM ServeRAID Adapter Driver " IPS_VER_STRING);
7597 #ifdef MODULE_VERSION
7598 MODULE_VERSION(IPS_VER_STRING);
7603 * Overrides for Emacs so that we almost follow Linus's tabbing style.
7604 * Emacs will notice this stuff at the end of the file and automatically
7605 * adjust the settings for this buffer only. This must remain at the end
7607 * ---------------------------------------------------------------------------
7610 * c-brace-imaginary-offset: 0
7611 * c-brace-offset: -2
7612 * c-argdecl-indent: 2
7613 * c-label-offset: -2
7614 * c-continued-statement-offset: 2
7615 * c-continued-brace-offset: 0
7616 * indent-tabs-mode: nil