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.xx - Add highmem_io flag in SCSI Templete for 2.4 kernels */
137 /* - Fix path/name for scsi_hosts.h include for 2.6 kernels */
138 /* - Fix sort order of 7k */
139 /* - Remove 3 unused "inline" functions */
140 /*****************************************************************************/
143 * Conditional Compilation directives for this driver:
145 * IPS_DEBUG - Turn on debugging info
149 * debug:<number> - Set debug level to <number>
150 * NOTE: only works when IPS_DEBUG compile directive is used.
151 * 1 - Normal debug messages
152 * 2 - Verbose debug messages
153 * 11 - Method trace (non interrupt)
154 * 12 - Method trace (includes interrupt)
156 * noi2o - Don't use I2O Queues (ServeRAID 4 only)
157 * nommap - Don't use memory mapped I/O
158 * ioctlsize - Initial size of the IOCTL buffer
162 #include <asm/byteorder.h>
163 #include <asm/page.h>
164 #include <linux/stddef.h>
165 #include <linux/version.h>
166 #include <linux/string.h>
167 #include <linux/errno.h>
168 #include <linux/kernel.h>
169 #include <linux/ioport.h>
170 #include <linux/slab.h>
171 #include <linux/delay.h>
172 #include <linux/pci.h>
173 #include <linux/proc_fs.h>
174 #include <linux/reboot.h>
175 #include <linux/interrupt.h>
177 #include <linux/blkdev.h>
178 #include <linux/types.h>
184 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
187 #include <scsi/scsi_host.h>
192 #include <linux/module.h>
194 #include <linux/stat.h>
195 #include <linux/config.h>
197 #include <linux/spinlock.h>
198 #include <linux/init.h>
200 #include <linux/smp.h>
203 static char *ips = NULL;
204 module_param(ips, charp, 0);
210 #define IPS_VERSION_HIGH "7.10"
211 #define IPS_VERSION_LOW ".18 "
213 #if !defined(__i386__) && !defined(__ia64__) && !defined(__x86_64__)
214 #warning "This driver has only been tested on the x86/ia64/x86_64 platforms"
217 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
218 #include <linux/blk.h>
220 #define IPS_SG_ADDRESS(sg) ((sg)->address)
221 #define IPS_LOCK_SAVE(lock,flags) spin_lock_irqsave(&io_request_lock,flags)
222 #define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock_irqrestore(&io_request_lock,flags)
224 #define __devexit_p(x) x
227 #define IPS_SG_ADDRESS(sg) (page_address((sg)->page) ? \
228 page_address((sg)->page)+(sg)->offset : NULL)
229 #define IPS_LOCK_SAVE(lock,flags) do{spin_lock(lock);(void)flags;}while(0)
230 #define IPS_UNLOCK_RESTORE(lock,flags) do{spin_unlock(lock);(void)flags;}while(0)
233 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
234 DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
235 PCI_DMA_BIDIRECTIONAL : \
236 scb->scsi_cmd->sc_data_direction)
239 #define METHOD_TRACE(s, i) if (ips_debug >= (i+10)) printk(KERN_NOTICE s "\n");
240 #define DEBUG(i, s) if (ips_debug >= i) printk(KERN_NOTICE s "\n");
241 #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "\n", v);
243 #define METHOD_TRACE(s, i)
245 #define DEBUG_VAR(i, s, v...)
249 * Function prototypes
251 static int ips_detect(Scsi_Host_Template *);
252 static int ips_release(struct Scsi_Host *);
253 static int ips_eh_abort(Scsi_Cmnd *);
254 static int ips_eh_reset(Scsi_Cmnd *);
255 static int ips_queue(Scsi_Cmnd *, void (*)(Scsi_Cmnd *));
256 static const char *ips_info(struct Scsi_Host *);
257 static irqreturn_t do_ipsintr(int, void *, struct pt_regs *);
258 static int ips_hainit(ips_ha_t *);
259 static int ips_map_status(ips_ha_t *, ips_scb_t *, ips_stat_t *);
260 static int ips_send_wait(ips_ha_t *, ips_scb_t *, int, int);
261 static int ips_send_cmd(ips_ha_t *, ips_scb_t *);
262 static int ips_online(ips_ha_t *, ips_scb_t *);
263 static int ips_inquiry(ips_ha_t *, ips_scb_t *);
264 static int ips_rdcap(ips_ha_t *, ips_scb_t *);
265 static int ips_msense(ips_ha_t *, ips_scb_t *);
266 static int ips_reqsen(ips_ha_t *, ips_scb_t *);
267 static int ips_deallocatescbs(ips_ha_t *, int);
268 static int ips_allocatescbs(ips_ha_t *);
269 static int ips_reset_copperhead(ips_ha_t *);
270 static int ips_reset_copperhead_memio(ips_ha_t *);
271 static int ips_reset_morpheus(ips_ha_t *);
272 static int ips_issue_copperhead(ips_ha_t *, ips_scb_t *);
273 static int ips_issue_copperhead_memio(ips_ha_t *, ips_scb_t *);
274 static int ips_issue_i2o(ips_ha_t *, ips_scb_t *);
275 static int ips_issue_i2o_memio(ips_ha_t *, ips_scb_t *);
276 static int ips_isintr_copperhead(ips_ha_t *);
277 static int ips_isintr_copperhead_memio(ips_ha_t *);
278 static int ips_isintr_morpheus(ips_ha_t *);
279 static int ips_wait(ips_ha_t *, int, int);
280 static int ips_write_driver_status(ips_ha_t *, int);
281 static int ips_read_adapter_status(ips_ha_t *, int);
282 static int ips_read_subsystem_parameters(ips_ha_t *, int);
283 static int ips_read_config(ips_ha_t *, int);
284 static int ips_clear_adapter(ips_ha_t *, int);
285 static int ips_readwrite_page5(ips_ha_t *, int, int);
286 static int ips_init_copperhead(ips_ha_t *);
287 static int ips_init_copperhead_memio(ips_ha_t *);
288 static int ips_init_morpheus(ips_ha_t *);
289 static int ips_isinit_copperhead(ips_ha_t *);
290 static int ips_isinit_copperhead_memio(ips_ha_t *);
291 static int ips_isinit_morpheus(ips_ha_t *);
292 static int ips_erase_bios(ips_ha_t *);
293 static int ips_program_bios(ips_ha_t *, char *, uint32_t, uint32_t);
294 static int ips_verify_bios(ips_ha_t *, char *, uint32_t, uint32_t);
295 static int ips_erase_bios_memio(ips_ha_t *);
296 static int ips_program_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
297 static int ips_verify_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
298 static int ips_flash_copperhead(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
299 static int ips_flash_bios(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
300 static int ips_flash_firmware(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
301 static void ips_free_flash_copperhead(ips_ha_t * ha);
302 static void ips_get_bios_version(ips_ha_t *, int);
303 static void ips_identify_controller(ips_ha_t *);
304 static void ips_chkstatus(ips_ha_t *, IPS_STATUS *);
305 static void ips_enable_int_copperhead(ips_ha_t *);
306 static void ips_enable_int_copperhead_memio(ips_ha_t *);
307 static void ips_enable_int_morpheus(ips_ha_t *);
308 static int ips_intr_copperhead(ips_ha_t *);
309 static int ips_intr_morpheus(ips_ha_t *);
310 static void ips_next(ips_ha_t *, int);
311 static void ipsintr_blocking(ips_ha_t *, struct ips_scb *);
312 static void ipsintr_done(ips_ha_t *, struct ips_scb *);
313 static void ips_done(ips_ha_t *, ips_scb_t *);
314 static void ips_free(ips_ha_t *);
315 static void ips_init_scb(ips_ha_t *, ips_scb_t *);
316 static void ips_freescb(ips_ha_t *, ips_scb_t *);
317 static void ips_setup_funclist(ips_ha_t *);
318 static void ips_statinit(ips_ha_t *);
319 static void ips_statinit_memio(ips_ha_t *);
320 static void ips_fix_ffdc_time(ips_ha_t *, ips_scb_t *, time_t);
321 static void ips_ffdc_reset(ips_ha_t *, int);
322 static void ips_ffdc_time(ips_ha_t *);
323 static uint32_t ips_statupd_copperhead(ips_ha_t *);
324 static uint32_t ips_statupd_copperhead_memio(ips_ha_t *);
325 static uint32_t ips_statupd_morpheus(ips_ha_t *);
326 static ips_scb_t *ips_getscb(ips_ha_t *);
327 static void ips_putq_scb_head(ips_scb_queue_t *, ips_scb_t *);
328 static void ips_putq_wait_tail(ips_wait_queue_t *, Scsi_Cmnd *);
329 static void ips_putq_copp_tail(ips_copp_queue_t *,
330 ips_copp_wait_item_t *);
331 static ips_scb_t *ips_removeq_scb_head(ips_scb_queue_t *);
332 static ips_scb_t *ips_removeq_scb(ips_scb_queue_t *, ips_scb_t *);
333 static Scsi_Cmnd *ips_removeq_wait_head(ips_wait_queue_t *);
334 static Scsi_Cmnd *ips_removeq_wait(ips_wait_queue_t *, Scsi_Cmnd *);
335 static ips_copp_wait_item_t *ips_removeq_copp(ips_copp_queue_t *,
336 ips_copp_wait_item_t *);
337 static ips_copp_wait_item_t *ips_removeq_copp_head(ips_copp_queue_t *);
339 static int ips_is_passthru(Scsi_Cmnd *);
340 static int ips_make_passthru(ips_ha_t *, Scsi_Cmnd *, ips_scb_t *, int);
341 static int ips_usrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
342 static void ips_cleanup_passthru(ips_ha_t *, ips_scb_t *);
343 static void ips_scmd_buf_write(Scsi_Cmnd * scmd, void *data,
345 static void ips_scmd_buf_read(Scsi_Cmnd * scmd, void *data, unsigned int count);
347 static int ips_proc_info(struct Scsi_Host *, char *, char **, off_t, int, int);
348 static int ips_host_info(ips_ha_t *, char *, off_t, int);
349 static void copy_mem_info(IPS_INFOSTR *, char *, int);
350 static int copy_info(IPS_INFOSTR *, char *, ...);
351 static int ips_get_version_info(ips_ha_t * ha, dma_addr_t, int intr);
352 static void ips_version_check(ips_ha_t * ha, int intr);
353 static int ips_abort_init(ips_ha_t * ha, int index);
354 static int ips_init_phase2(int index);
356 static int ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr);
357 static int ips_register_scsi(int index);
362 static const char ips_name[] = "ips";
363 static struct Scsi_Host *ips_sh[IPS_MAX_ADAPTERS]; /* Array of host controller structures */
364 static ips_ha_t *ips_ha[IPS_MAX_ADAPTERS]; /* Array of HA structures */
365 static unsigned int ips_next_controller;
366 static unsigned int ips_num_controllers;
367 static unsigned int ips_released_controllers;
368 static int ips_hotplug;
369 static int ips_cmd_timeout = 60;
370 static int ips_reset_timeout = 60 * 5;
371 static int ips_force_memio = 1; /* Always use Memory Mapped I/O */
372 static int ips_force_i2o = 1; /* Always use I2O command delivery */
373 static int ips_ioctlsize = IPS_IOCTL_SIZE; /* Size of the ioctl buffer */
374 static int ips_cd_boot; /* Booting from Manager CD */
375 static char *ips_FlashData = NULL; /* CD Boot - Flash Data Buffer */
376 static dma_addr_t ips_flashbusaddr;
377 static long ips_FlashDataInUse; /* CD Boot - Flash Data In Use Flag */
378 static uint32_t MaxLiteCmds = 32; /* Max Active Cmds for a Lite Adapter */
379 static Scsi_Host_Template ips_driver_template = {
380 .detect = ips_detect,
381 .release = ips_release,
383 .queuecommand = ips_queue,
384 .eh_abort_handler = ips_eh_abort,
385 .eh_host_reset_handler = ips_eh_reset,
387 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
388 .proc_info = ips_proc_info,
389 .slave_configure = ips_slave_configure,
391 .proc_info = ips_proc24_info,
392 .select_queue_depths = ips_select_queue_depth,
394 .bios_param = ips_biosparam,
396 .sg_tablesize = IPS_MAX_SG,
398 .use_clustering = ENABLE_CLUSTERING,
399 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
400 .use_new_eh_code = 1,
402 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20) && LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
407 static IPS_DEFINE_COMPAT_TABLE( Compatable ); /* Version Compatability Table */
410 /* This table describes all ServeRAID Adapters */
411 static struct pci_device_id ips_pci_table[] = {
412 { 0x1014, 0x002E, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
413 { 0x1014, 0x01BD, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
414 { 0x9005, 0x0250, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
418 MODULE_DEVICE_TABLE( pci, ips_pci_table );
420 static char ips_hot_plug_name[] = "ips";
422 static int __devinit ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent);
423 static void __devexit ips_remove_device(struct pci_dev *pci_dev);
425 static struct pci_driver ips_pci_driver = {
426 .name = ips_hot_plug_name,
427 .id_table = ips_pci_table,
428 .probe = ips_insert_device,
429 .remove = __devexit_p(ips_remove_device),
434 * Necessary forward function protoypes
436 static int ips_halt(struct notifier_block *nb, ulong event, void *buf);
438 #define MAX_ADAPTER_NAME 15
440 static char ips_adapter_name[][30] = {
443 "ServeRAID on motherboard",
444 "ServeRAID on motherboard",
461 static struct notifier_block ips_notifier = {
468 static char ips_command_direction[] = {
469 IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT,
470 IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK,
471 IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
472 IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
473 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_OUT,
474 IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
475 IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_IN,
476 IPS_DATA_UNK, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
477 IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_UNK,
478 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
479 IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE,
480 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
481 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT,
482 IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_NONE,
483 IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,
484 IPS_DATA_NONE, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
485 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
486 IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
487 IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
488 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
489 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
490 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
491 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
492 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
493 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
494 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
495 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
496 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
497 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
498 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
499 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
500 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
501 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
502 IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_NONE,
503 IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_OUT,
504 IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_NONE,
505 IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN,
506 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
507 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
508 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
509 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
510 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
511 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
512 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
513 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
514 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
515 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_OUT,
516 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
517 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
518 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
519 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK
523 /****************************************************************************/
525 /* Routine Name: ips_setup */
527 /* Routine Description: */
529 /* setup parameters to the driver */
531 /****************************************************************************/
533 ips_setup(char *ips_str)
539 IPS_OPTION options[] = {
540 {"noi2o", &ips_force_i2o, 0},
541 {"nommap", &ips_force_memio, 0},
542 {"ioctlsize", &ips_ioctlsize, IPS_IOCTL_SIZE},
543 {"cdboot", &ips_cd_boot, 0},
544 {"maxcmds", &MaxLiteCmds, 32},
547 /* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
548 /* Search for value */
549 while ((key = strsep(&ips_str, ",."))) {
552 value = strchr(key, ':');
556 * We now have key/value pairs.
557 * Update the variables
559 for (i = 0; i < (sizeof (options) / sizeof (options[0])); i++) {
561 (key, options[i].option_name,
562 strlen(options[i].option_name)) == 0) {
564 *options[i].option_flag =
565 simple_strtoul(value, NULL, 0);
567 *options[i].option_flag =
568 options[i].option_value;
577 __setup("ips=", ips_setup);
579 /****************************************************************************/
581 /* Routine Name: ips_detect */
583 /* Routine Description: */
585 /* Detect and initialize the driver */
587 /* NOTE: this routine is called under the io_request_lock spinlock */
589 /****************************************************************************/
591 ips_detect(Scsi_Host_Template * SHT)
595 METHOD_TRACE("ips_detect", 1);
602 for (i = 0; i < ips_num_controllers; i++) {
603 if (ips_register_scsi(i))
605 ips_released_controllers++;
608 return (ips_num_controllers);
611 /****************************************************************************/
612 /* configure the function pointers to use the functions that will work */
613 /* with the found version of the adapter */
614 /****************************************************************************/
616 ips_setup_funclist(ips_ha_t * ha)
622 if (IPS_IS_MORPHEUS(ha) || IPS_IS_MARCO(ha)) {
623 /* morpheus / marco / sebring */
624 ha->func.isintr = ips_isintr_morpheus;
625 ha->func.isinit = ips_isinit_morpheus;
626 ha->func.issue = ips_issue_i2o_memio;
627 ha->func.init = ips_init_morpheus;
628 ha->func.statupd = ips_statupd_morpheus;
629 ha->func.reset = ips_reset_morpheus;
630 ha->func.intr = ips_intr_morpheus;
631 ha->func.enableint = ips_enable_int_morpheus;
632 } else if (IPS_USE_MEMIO(ha)) {
633 /* copperhead w/MEMIO */
634 ha->func.isintr = ips_isintr_copperhead_memio;
635 ha->func.isinit = ips_isinit_copperhead_memio;
636 ha->func.init = ips_init_copperhead_memio;
637 ha->func.statupd = ips_statupd_copperhead_memio;
638 ha->func.statinit = ips_statinit_memio;
639 ha->func.reset = ips_reset_copperhead_memio;
640 ha->func.intr = ips_intr_copperhead;
641 ha->func.erasebios = ips_erase_bios_memio;
642 ha->func.programbios = ips_program_bios_memio;
643 ha->func.verifybios = ips_verify_bios_memio;
644 ha->func.enableint = ips_enable_int_copperhead_memio;
645 if (IPS_USE_I2O_DELIVER(ha))
646 ha->func.issue = ips_issue_i2o_memio;
648 ha->func.issue = ips_issue_copperhead_memio;
651 ha->func.isintr = ips_isintr_copperhead;
652 ha->func.isinit = ips_isinit_copperhead;
653 ha->func.init = ips_init_copperhead;
654 ha->func.statupd = ips_statupd_copperhead;
655 ha->func.statinit = ips_statinit;
656 ha->func.reset = ips_reset_copperhead;
657 ha->func.intr = ips_intr_copperhead;
658 ha->func.erasebios = ips_erase_bios;
659 ha->func.programbios = ips_program_bios;
660 ha->func.verifybios = ips_verify_bios;
661 ha->func.enableint = ips_enable_int_copperhead;
663 if (IPS_USE_I2O_DELIVER(ha))
664 ha->func.issue = ips_issue_i2o;
666 ha->func.issue = ips_issue_copperhead;
670 /****************************************************************************/
672 /* Routine Name: ips_release */
674 /* Routine Description: */
676 /* Remove a driver */
678 /****************************************************************************/
680 ips_release(struct Scsi_Host *sh)
686 METHOD_TRACE("ips_release", 1);
688 for (i = 0; i < IPS_MAX_ADAPTERS && ips_sh[i] != sh; i++) ;
690 if (i == IPS_MAX_ADAPTERS) {
692 "(%s) release, invalid Scsi_Host pointer.\n", ips_name);
702 /* flush the cache on the controller */
703 scb = &ha->scbs[ha->max_cmds - 1];
705 ips_init_scb(ha, scb);
707 scb->timeout = ips_cmd_timeout;
708 scb->cdb[0] = IPS_CMD_FLUSH;
710 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
711 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
712 scb->cmd.flush_cache.state = IPS_NORM_STATE;
713 scb->cmd.flush_cache.reserved = 0;
714 scb->cmd.flush_cache.reserved2 = 0;
715 scb->cmd.flush_cache.reserved3 = 0;
716 scb->cmd.flush_cache.reserved4 = 0;
718 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
721 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
722 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Incomplete Flush.\n");
724 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Complete.\n");
729 /* free extra memory */
732 /* Free I/O Region */
734 release_region(ha->io_addr, ha->io_len);
737 free_irq(ha->irq, ha);
742 ips_released_controllers++;
747 /****************************************************************************/
749 /* Routine Name: ips_halt */
751 /* Routine Description: */
753 /* Perform cleanup when the system reboots */
755 /****************************************************************************/
757 ips_halt(struct notifier_block *nb, ulong event, void *buf)
763 if ((event != SYS_RESTART) && (event != SYS_HALT) &&
764 (event != SYS_POWER_OFF))
765 return (NOTIFY_DONE);
767 for (i = 0; i < ips_next_controller; i++) {
768 ha = (ips_ha_t *) ips_ha[i];
776 /* flush the cache on the controller */
777 scb = &ha->scbs[ha->max_cmds - 1];
779 ips_init_scb(ha, scb);
781 scb->timeout = ips_cmd_timeout;
782 scb->cdb[0] = IPS_CMD_FLUSH;
784 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
785 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
786 scb->cmd.flush_cache.state = IPS_NORM_STATE;
787 scb->cmd.flush_cache.reserved = 0;
788 scb->cmd.flush_cache.reserved2 = 0;
789 scb->cmd.flush_cache.reserved3 = 0;
790 scb->cmd.flush_cache.reserved4 = 0;
792 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
795 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) ==
797 IPS_PRINTK(KERN_WARNING, ha->pcidev,
798 "Incomplete Flush.\n");
800 IPS_PRINTK(KERN_WARNING, ha->pcidev,
801 "Flushing Complete.\n");
807 /****************************************************************************/
809 /* Routine Name: ips_eh_abort */
811 /* Routine Description: */
813 /* Abort a command (using the new error code stuff) */
814 /* Note: this routine is called under the io_request_lock */
815 /****************************************************************************/
817 ips_eh_abort(Scsi_Cmnd * SC)
820 ips_copp_wait_item_t *item;
822 unsigned long cpu_flags;
823 struct Scsi_Host *host;
825 METHOD_TRACE("ips_eh_abort", 1);
830 host = SC->device->host;
831 ha = (ips_ha_t *) SC->device->host->hostdata;
839 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
841 /* See if the command is on the copp queue */
842 item = ha->copp_waitlist.head;
843 while ((item) && (item->scsi_cmd != SC))
848 ips_removeq_copp(&ha->copp_waitlist, item);
851 /* See if the command is on the wait queue */
852 } else if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
853 /* command not sent yet */
856 /* command must have already been sent */
860 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
864 /****************************************************************************/
866 /* Routine Name: ips_eh_reset */
868 /* Routine Description: */
870 /* Reset the controller (with new eh error code) */
872 /* NOTE: this routine is called under the io_request_lock spinlock */
874 /****************************************************************************/
876 ips_eh_reset(Scsi_Cmnd * SC)
882 ips_copp_wait_item_t *item;
884 METHOD_TRACE("ips_eh_reset", 1);
891 DEBUG(1, "Reset called with NULL scsi command");
896 ha = (ips_ha_t *) SC->device->host->hostdata;
899 DEBUG(1, "Reset called with NULL ha struct");
907 /* See if the command is on the copp queue */
908 item = ha->copp_waitlist.head;
909 while ((item) && (item->scsi_cmd != SC))
914 ips_removeq_copp(&ha->copp_waitlist, item);
918 /* See if the command is on the wait queue */
919 if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
920 /* command not sent yet */
924 /* An explanation for the casual observer: */
925 /* Part of the function of a RAID controller is automatic error */
926 /* detection and recovery. As such, the only problem that physically */
927 /* resetting an adapter will ever fix is when, for some reason, */
928 /* the driver is not successfully communicating with the adapter. */
929 /* Therefore, we will attempt to flush this adapter. If that succeeds, */
930 /* then there's no real purpose in a physical reset. This will complete */
931 /* much faster and avoids any problems that might be caused by a */
932 /* physical reset ( such as having to fail all the outstanding I/O's ). */
934 if (ha->ioctl_reset == 0) { /* IF Not an IOCTL Requested Reset */
935 scb = &ha->scbs[ha->max_cmds - 1];
937 ips_init_scb(ha, scb);
939 scb->timeout = ips_cmd_timeout;
940 scb->cdb[0] = IPS_CMD_FLUSH;
942 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
943 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
944 scb->cmd.flush_cache.state = IPS_NORM_STATE;
945 scb->cmd.flush_cache.reserved = 0;
946 scb->cmd.flush_cache.reserved2 = 0;
947 scb->cmd.flush_cache.reserved3 = 0;
948 scb->cmd.flush_cache.reserved4 = 0;
950 /* Attempt the flush command */
951 ret = ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_IORL);
952 if (ret == IPS_SUCCESS) {
953 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
954 "Reset Request - Flushed Cache\n");
959 /* Either we can't communicate with the adapter or it's an IOCTL request */
960 /* from a utility. A physical reset is needed at this point. */
962 ha->ioctl_reset = 0; /* Reset the IOCTL Requested Reset Flag */
965 * command must have already been sent
966 * reset the controller
968 IPS_PRINTK(KERN_NOTICE, ha->pcidev, "Resetting controller.\n");
969 ret = (*ha->func.reset) (ha);
974 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
975 "Controller reset failed - controller now offline.\n");
977 /* Now fail all of the active commands */
978 DEBUG_VAR(1, "(%s%d) Failing active commands",
979 ips_name, ha->host_num);
981 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
982 scb->scsi_cmd->result = DID_ERROR << 16;
983 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
984 ips_freescb(ha, scb);
987 /* Now fail all of the pending commands */
988 DEBUG_VAR(1, "(%s%d) Failing pending commands",
989 ips_name, ha->host_num);
991 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
992 scsi_cmd->result = DID_ERROR;
993 scsi_cmd->scsi_done(scsi_cmd);
1000 if (!ips_clear_adapter(ha, IPS_INTR_IORL)) {
1001 Scsi_Cmnd *scsi_cmd;
1003 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
1004 "Controller reset failed - controller now offline.\n");
1006 /* Now fail all of the active commands */
1007 DEBUG_VAR(1, "(%s%d) Failing active commands",
1008 ips_name, ha->host_num);
1010 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
1011 scb->scsi_cmd->result = DID_ERROR << 16;
1012 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1013 ips_freescb(ha, scb);
1016 /* Now fail all of the pending commands */
1017 DEBUG_VAR(1, "(%s%d) Failing pending commands",
1018 ips_name, ha->host_num);
1020 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
1021 scsi_cmd->result = DID_ERROR << 16;
1022 scsi_cmd->scsi_done(scsi_cmd);
1030 if (le32_to_cpu(ha->subsys->param[3]) & 0x300000) {
1033 do_gettimeofday(&tv);
1034 ha->last_ffdc = tv.tv_sec;
1036 ips_ffdc_reset(ha, IPS_INTR_IORL);
1039 /* Now fail all of the active commands */
1040 DEBUG_VAR(1, "(%s%d) Failing active commands", ips_name, ha->host_num);
1042 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
1043 scb->scsi_cmd->result =
1044 (DID_RESET << 16) | (SUGGEST_RETRY << 24);
1045 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1046 ips_freescb(ha, scb);
1049 /* Reset DCDB active command bits */
1050 for (i = 1; i < ha->nbus; i++)
1051 ha->dcdb_active[i - 1] = 0;
1053 /* Reset the number of active IOCTLs */
1056 ips_next(ha, IPS_INTR_IORL);
1059 #endif /* NO_IPS_RESET */
1063 /****************************************************************************/
1065 /* Routine Name: ips_queue */
1067 /* Routine Description: */
1069 /* Send a command to the controller */
1072 /* Linux obtains io_request_lock before calling this function */
1074 /****************************************************************************/
1076 ips_queue(Scsi_Cmnd * SC, void (*done) (Scsi_Cmnd *))
1081 METHOD_TRACE("ips_queue", 1);
1083 ha = (ips_ha_t *) SC->device->host->hostdata;
1091 if (ips_is_passthru(SC)) {
1092 if (ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
1093 SC->result = DID_BUS_BUSY << 16;
1098 } else if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
1099 SC->result = DID_BUS_BUSY << 16;
1105 SC->scsi_done = done;
1107 DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
1111 SC->device->channel, SC->device->id, SC->device->lun);
1113 /* Check for command to initiator IDs */
1114 if ((SC->device->channel > 0)
1115 && (SC->device->id == ha->ha_id[SC->device->channel])) {
1116 SC->result = DID_NO_CONNECT << 16;
1122 if (ips_is_passthru(SC)) {
1124 ips_copp_wait_item_t *scratch;
1126 /* A Reset IOCTL is only sent by the boot CD in extreme cases. */
1127 /* There can never be any system activity ( network or disk ), but check */
1128 /* anyway just as a good practice. */
1129 pt = (ips_passthru_t *) SC->request_buffer;
1130 if ((pt->CoppCP.cmd.reset.op_code == IPS_CMD_RESET_CHANNEL) &&
1131 (pt->CoppCP.cmd.reset.adapter_flag == 1)) {
1132 if (ha->scb_activelist.count != 0) {
1133 SC->result = DID_BUS_BUSY << 16;
1137 ha->ioctl_reset = 1; /* This reset request is from an IOCTL */
1139 SC->result = DID_OK << 16;
1144 /* allocate space for the scribble */
1145 scratch = kmalloc(sizeof (ips_copp_wait_item_t), GFP_ATOMIC);
1148 SC->result = DID_ERROR << 16;
1154 scratch->scsi_cmd = SC;
1155 scratch->next = NULL;
1157 ips_putq_copp_tail(&ha->copp_waitlist, scratch);
1159 ips_putq_wait_tail(&ha->scb_waitlist, SC);
1162 ips_next(ha, IPS_INTR_IORL);
1167 /****************************************************************************/
1169 /* Routine Name: ips_biosparam */
1171 /* Routine Description: */
1173 /* Set bios geometry for the controller */
1175 /****************************************************************************/
1177 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1178 ips_biosparam(Disk * disk, kdev_t dev, int geom[])
1180 ips_ha_t *ha = (ips_ha_t *) disk->device->host->hostdata;
1181 unsigned long capacity = disk->capacity;
1183 ips_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1184 sector_t capacity, int geom[])
1186 ips_ha_t *ha = (ips_ha_t *) sdev->host->hostdata;
1192 METHOD_TRACE("ips_biosparam", 1);
1195 /* ?!?! host adater info invalid */
1201 if (!ips_read_adapter_status(ha, IPS_INTR_ON))
1202 /* ?!?! Enquiry command failed */
1205 if ((capacity > 0x400000) && ((ha->enq->ucMiscFlag & 0x8) == 0)) {
1206 heads = IPS_NORM_HEADS;
1207 sectors = IPS_NORM_SECTORS;
1209 heads = IPS_COMP_HEADS;
1210 sectors = IPS_COMP_SECTORS;
1213 cylinders = (unsigned long) capacity / (heads * sectors);
1215 DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
1216 heads, sectors, cylinders);
1220 geom[2] = cylinders;
1225 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1227 /* ips_proc24_info is a wrapper around ips_proc_info *
1228 * for compatibility with the 2.4 scsi parameters */
1230 ips_proc24_info(char *buffer, char **start, off_t offset, int length,
1231 int hostno, int func)
1235 for (i = 0; i < ips_next_controller; i++) {
1236 if (ips_sh[i] && ips_sh[i]->host_no == hostno) {
1237 return ips_proc_info(ips_sh[i], buffer, start,
1238 offset, length, func);
1244 /****************************************************************************/
1246 /* Routine Name: ips_select_queue_depth */
1248 /* Routine Description: */
1250 /* Select queue depths for the devices on the contoller */
1252 /****************************************************************************/
1254 ips_select_queue_depth(struct Scsi_Host *host, Scsi_Device * scsi_devs)
1256 Scsi_Device *device;
1262 min = ha->max_cmds / 4;
1264 for (device = scsi_devs; device; device = device->next) {
1265 if (device->host == host) {
1266 if ((device->channel == 0) && (device->type == 0))
1271 for (device = scsi_devs; device; device = device->next) {
1272 if (device->host == host) {
1273 if ((device->channel == 0) && (device->type == 0)) {
1274 device->queue_depth =
1275 (ha->max_cmds - 1) / count;
1276 if (device->queue_depth < min)
1277 device->queue_depth = min;
1279 device->queue_depth = 2;
1282 if (device->queue_depth < 2)
1283 device->queue_depth = 2;
1289 /****************************************************************************/
1291 /* Routine Name: ips_slave_configure */
1293 /* Routine Description: */
1295 /* Set queue depths on devices once scan is complete */
1297 /****************************************************************************/
1299 ips_slave_configure(Scsi_Device * SDptr)
1304 ha = IPS_HA(SDptr->host);
1305 if (SDptr->tagged_supported && SDptr->type == TYPE_DISK) {
1306 min = ha->max_cmds / 2;
1307 if (ha->enq->ucLogDriveCount <= 2)
1308 min = ha->max_cmds - 1;
1309 scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, min);
1315 /****************************************************************************/
1317 /* Routine Name: do_ipsintr */
1319 /* Routine Description: */
1321 /* Wrapper for the interrupt handler */
1323 /****************************************************************************/
1325 do_ipsintr(int irq, void *dev_id, struct pt_regs * regs)
1328 unsigned long cpu_flags;
1329 struct Scsi_Host *host;
1332 METHOD_TRACE("do_ipsintr", 2);
1334 ha = (ips_ha_t *) dev_id;
1337 host = ips_sh[ha->host_num];
1338 /* interrupt during initialization */
1340 (*ha->func.intr) (ha);
1344 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
1347 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1351 irqstatus = (*ha->func.intr) (ha);
1353 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1355 /* start the next command */
1356 ips_next(ha, IPS_INTR_ON);
1357 return IRQ_RETVAL(irqstatus);
1360 /****************************************************************************/
1362 /* Routine Name: ips_intr_copperhead */
1364 /* Routine Description: */
1366 /* Polling interrupt handler */
1368 /* ASSUMES interrupts are disabled */
1370 /****************************************************************************/
1372 ips_intr_copperhead(ips_ha_t * ha)
1379 METHOD_TRACE("ips_intr", 2);
1387 intrstatus = (*ha->func.isintr) (ha);
1391 * Unexpected/Shared interrupt
1400 intrstatus = (*ha->func.isintr) (ha);
1405 cstatus.value = (*ha->func.statupd) (ha);
1407 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1408 /* Spurious Interupt ? */
1412 ips_chkstatus(ha, &cstatus);
1413 scb = (ips_scb_t *) sp->scb_addr;
1416 * use the callback function to finish things up
1417 * NOTE: interrupts are OFF for this
1419 (*scb->callback) (ha, scb);
1424 /****************************************************************************/
1426 /* Routine Name: ips_intr_morpheus */
1428 /* Routine Description: */
1430 /* Polling interrupt handler */
1432 /* ASSUMES interrupts are disabled */
1434 /****************************************************************************/
1436 ips_intr_morpheus(ips_ha_t * ha)
1443 METHOD_TRACE("ips_intr_morpheus", 2);
1451 intrstatus = (*ha->func.isintr) (ha);
1455 * Unexpected/Shared interrupt
1464 intrstatus = (*ha->func.isintr) (ha);
1469 cstatus.value = (*ha->func.statupd) (ha);
1471 if (cstatus.value == 0xffffffff)
1472 /* No more to process */
1475 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1476 IPS_PRINTK(KERN_WARNING, ha->pcidev,
1477 "Spurious interrupt; no ccb.\n");
1482 ips_chkstatus(ha, &cstatus);
1483 scb = (ips_scb_t *) sp->scb_addr;
1486 * use the callback function to finish things up
1487 * NOTE: interrupts are OFF for this
1489 (*scb->callback) (ha, scb);
1494 /****************************************************************************/
1496 /* Routine Name: ips_info */
1498 /* Routine Description: */
1500 /* Return info about the driver */
1502 /****************************************************************************/
1504 ips_info(struct Scsi_Host *SH)
1506 static char buffer[256];
1510 METHOD_TRACE("ips_info", 1);
1518 memset(bp, 0, sizeof (buffer));
1520 sprintf(bp, "%s%s%s Build %d", "IBM PCI ServeRAID ",
1521 IPS_VERSION_HIGH, IPS_VERSION_LOW, IPS_BUILD_IDENT);
1523 if (ha->ad_type > 0 && ha->ad_type <= MAX_ADAPTER_NAME) {
1525 strcat(bp, ips_adapter_name[ha->ad_type - 1]);
1532 /****************************************************************************/
1534 /* Routine Name: ips_proc_info */
1536 /* Routine Description: */
1538 /* The passthru interface for the driver */
1540 /****************************************************************************/
1542 ips_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
1543 int length, int func)
1547 ips_ha_t *ha = NULL;
1549 METHOD_TRACE("ips_proc_info", 1);
1551 /* Find our host structure */
1552 for (i = 0; i < ips_next_controller; i++) {
1554 if (ips_sh[i] == host) {
1555 ha = (ips_ha_t *) ips_sh[i]->hostdata;
1572 ret = ips_host_info(ha, buffer, offset, length);
1578 /*--------------------------------------------------------------------------*/
1579 /* Helper Functions */
1580 /*--------------------------------------------------------------------------*/
1582 /****************************************************************************/
1584 /* Routine Name: ips_is_passthru */
1586 /* Routine Description: */
1588 /* Determine if the specified SCSI command is really a passthru command */
1590 /****************************************************************************/
1592 ips_is_passthru(Scsi_Cmnd * SC)
1594 METHOD_TRACE("ips_is_passthru", 1);
1599 if ((SC->cmnd[0] == IPS_IOCTL_COMMAND) &&
1600 (SC->device->channel == 0) &&
1601 (SC->device->id == IPS_ADAPTER_ID) &&
1602 (SC->device->lun == 0) && SC->request_buffer) {
1603 if ((!SC->use_sg) && SC->request_bufflen &&
1604 (((char *) SC->request_buffer)[0] == 'C') &&
1605 (((char *) SC->request_buffer)[1] == 'O') &&
1606 (((char *) SC->request_buffer)[2] == 'P') &&
1607 (((char *) SC->request_buffer)[3] == 'P'))
1609 else if (SC->use_sg) {
1610 struct scatterlist *sg = SC->request_buffer;
1611 char *buffer = IPS_SG_ADDRESS(sg);
1612 if (buffer && buffer[0] == 'C' && buffer[1] == 'O' &&
1613 buffer[2] == 'P' && buffer[3] == 'P')
1620 /****************************************************************************/
1622 /* Routine Name: ips_alloc_passthru_buffer */
1624 /* Routine Description: */
1625 /* allocate a buffer large enough for the ioctl data if the ioctl buffer */
1626 /* is too small or doesn't exist */
1627 /****************************************************************************/
1629 ips_alloc_passthru_buffer(ips_ha_t * ha, int length)
1632 dma_addr_t dma_busaddr;
1634 if (ha->ioctl_data && length <= ha->ioctl_len)
1636 /* there is no buffer or it's not big enough, allocate a new one */
1637 bigger_buf = pci_alloc_consistent(ha->pcidev, length, &dma_busaddr);
1639 /* free the old memory */
1640 pci_free_consistent(ha->pcidev, ha->ioctl_len, ha->ioctl_data,
1642 /* use the new memory */
1643 ha->ioctl_data = (char *) bigger_buf;
1644 ha->ioctl_len = length;
1645 ha->ioctl_busaddr = dma_busaddr;
1652 /****************************************************************************/
1654 /* Routine Name: ips_make_passthru */
1656 /* Routine Description: */
1658 /* Make a passthru command out of the info in the Scsi block */
1660 /****************************************************************************/
1662 ips_make_passthru(ips_ha_t * ha, Scsi_Cmnd * SC, ips_scb_t * scb, int intr)
1668 METHOD_TRACE("ips_make_passthru", 1);
1671 length = SC->request_bufflen;
1673 struct scatterlist *sg = SC->request_buffer;
1675 for (i = 0; i < SC->use_sg; i++)
1676 length += sg[i].length;
1678 if (length < sizeof (ips_passthru_t)) {
1680 DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
1681 ips_name, ha->host_num);
1682 return (IPS_FAILURE);
1684 if (ips_alloc_passthru_buffer(ha, length)) {
1685 /* allocation failure! If ha->ioctl_data exists, use it to return
1686 some error codes. Return a failed command to the scsi layer. */
1687 if (ha->ioctl_data) {
1688 pt = (ips_passthru_t *) ha->ioctl_data;
1689 ips_scmd_buf_read(SC, pt, sizeof (ips_passthru_t));
1690 pt->BasicStatus = 0x0B;
1691 pt->ExtendedStatus = 0x00;
1692 ips_scmd_buf_write(SC, pt, sizeof (ips_passthru_t));
1696 ha->ioctl_datasize = length;
1698 ips_scmd_buf_read(SC, ha->ioctl_data, ha->ioctl_datasize);
1699 pt = (ips_passthru_t *) ha->ioctl_data;
1702 * Some notes about the passthru interface used
1704 * IF the scsi op_code == 0x0d then we assume
1705 * that the data came along with/goes with the
1706 * packet we received from the sg driver. In this
1707 * case the CmdBSize field of the pt structure is
1708 * used for the size of the buffer.
1711 switch (pt->CoppCmd) {
1713 memcpy(ha->ioctl_data + sizeof (ips_passthru_t),
1714 &ips_num_controllers, sizeof (int));
1715 ips_scmd_buf_write(SC, ha->ioctl_data,
1716 sizeof (ips_passthru_t) + sizeof (int));
1717 SC->result = DID_OK << 16;
1719 return (IPS_SUCCESS_IMM);
1721 case IPS_COPPUSRCMD:
1722 case IPS_COPPIOCCMD:
1723 if (SC->cmnd[0] == IPS_IOCTL_COMMAND) {
1724 if (length < (sizeof (ips_passthru_t) + pt->CmdBSize)) {
1727 "(%s%d) Passthru structure wrong size",
1728 ips_name, ha->host_num);
1730 return (IPS_FAILURE);
1733 if (ha->device_id == IPS_DEVICEID_COPPERHEAD &&
1734 pt->CoppCP.cmd.flashfw.op_code ==
1735 IPS_CMD_RW_BIOSFW) {
1736 ret = ips_flash_copperhead(ha, pt, scb);
1737 ips_scmd_buf_write(SC, ha->ioctl_data,
1738 sizeof (ips_passthru_t));
1741 if (ips_usrcmd(ha, pt, scb))
1742 return (IPS_SUCCESS);
1744 return (IPS_FAILURE);
1751 return (IPS_FAILURE);
1754 /****************************************************************************/
1755 /* Routine Name: ips_flash_copperhead */
1756 /* Routine Description: */
1757 /* Flash the BIOS/FW on a Copperhead style controller */
1758 /****************************************************************************/
1760 ips_flash_copperhead(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1764 /* Trombone is the only copperhead that can do packet flash, but only
1765 * for firmware. No one said it had to make sence. */
1766 if (IPS_IS_TROMBONE(ha) && pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE) {
1767 if (ips_usrcmd(ha, pt, scb))
1772 pt->BasicStatus = 0x0B;
1773 pt->ExtendedStatus = 0;
1774 scb->scsi_cmd->result = DID_OK << 16;
1775 /* IF it's OK to Use the "CD BOOT" Flash Buffer, then you can */
1776 /* avoid allocating a huge buffer per adapter ( which can fail ). */
1777 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1778 pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1779 pt->BasicStatus = 0;
1780 return ips_flash_bios(ha, pt, scb);
1781 } else if (pt->CoppCP.cmd.flashfw.packet_num == 0) {
1782 if (ips_FlashData && !test_and_set_bit(0, &ips_FlashDataInUse)){
1783 ha->flash_data = ips_FlashData;
1784 ha->flash_busaddr = ips_flashbusaddr;
1785 ha->flash_len = PAGE_SIZE << 7;
1786 ha->flash_datasize = 0;
1787 } else if (!ha->flash_data) {
1788 datasize = pt->CoppCP.cmd.flashfw.total_packets *
1789 pt->CoppCP.cmd.flashfw.count;
1790 ha->flash_data = pci_alloc_consistent(ha->pcidev,
1792 &ha->flash_busaddr);
1793 if (!ha->flash_data){
1794 printk(KERN_WARNING "Unable to allocate a flash buffer\n");
1797 ha->flash_datasize = 0;
1798 ha->flash_len = datasize;
1802 if (pt->CoppCP.cmd.flashfw.count + ha->flash_datasize >
1804 ips_free_flash_copperhead(ha);
1805 IPS_PRINTK(KERN_WARNING, ha->pcidev,
1806 "failed size sanity check\n");
1810 if (!ha->flash_data)
1812 pt->BasicStatus = 0;
1813 memcpy(&ha->flash_data[ha->flash_datasize], pt + 1,
1814 pt->CoppCP.cmd.flashfw.count);
1815 ha->flash_datasize += pt->CoppCP.cmd.flashfw.count;
1816 if (pt->CoppCP.cmd.flashfw.packet_num ==
1817 pt->CoppCP.cmd.flashfw.total_packets - 1) {
1818 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE)
1819 return ips_flash_bios(ha, pt, scb);
1820 else if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE)
1821 return ips_flash_firmware(ha, pt, scb);
1823 return IPS_SUCCESS_IMM;
1826 /****************************************************************************/
1827 /* Routine Name: ips_flash_bios */
1828 /* Routine Description: */
1829 /* flashes the bios of a copperhead adapter */
1830 /****************************************************************************/
1832 ips_flash_bios(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1835 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1836 pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_BIOS) {
1837 if ((!ha->func.programbios) || (!ha->func.erasebios) ||
1838 (!ha->func.verifybios))
1840 if ((*ha->func.erasebios) (ha)) {
1842 "(%s%d) flash bios failed - unable to erase flash",
1843 ips_name, ha->host_num);
1846 if ((*ha->func.programbios) (ha,
1849 ha->flash_datasize -
1850 IPS_BIOS_HEADER, 0)) {
1852 "(%s%d) flash bios failed - unable to flash",
1853 ips_name, ha->host_num);
1856 if ((*ha->func.verifybios) (ha,
1859 ha->flash_datasize -
1860 IPS_BIOS_HEADER, 0)) {
1862 "(%s%d) flash bios failed - unable to verify flash",
1863 ips_name, ha->host_num);
1866 ips_free_flash_copperhead(ha);
1867 return IPS_SUCCESS_IMM;
1868 } else if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1869 pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1870 if (!ha->func.erasebios)
1872 if ((*ha->func.erasebios) (ha)) {
1874 "(%s%d) flash bios failed - unable to erase flash",
1875 ips_name, ha->host_num);
1878 return IPS_SUCCESS_IMM;
1881 pt->BasicStatus = 0x0B;
1882 pt->ExtendedStatus = 0x00;
1883 ips_free_flash_copperhead(ha);
1887 /****************************************************************************/
1889 /* Routine Name: ips_fill_scb_sg_single */
1891 /* Routine Description: */
1892 /* Fill in a single scb sg_list element from an address */
1893 /* return a -1 if a breakup occurred */
1894 /****************************************************************************/
1896 ips_fill_scb_sg_single(ips_ha_t * ha, dma_addr_t busaddr,
1897 ips_scb_t * scb, int indx, unsigned int e_len)
1902 if ((scb->data_len + e_len) > ha->max_xfer) {
1903 e_len = ha->max_xfer - scb->data_len;
1904 scb->breakup = indx;
1911 if (IPS_USE_ENH_SGLIST(ha)) {
1912 scb->sg_list.enh_list[indx].address_lo =
1913 cpu_to_le32(pci_dma_lo32(busaddr));
1914 scb->sg_list.enh_list[indx].address_hi =
1915 cpu_to_le32(pci_dma_hi32(busaddr));
1916 scb->sg_list.enh_list[indx].length = cpu_to_le32(e_len);
1918 scb->sg_list.std_list[indx].address =
1919 cpu_to_le32(pci_dma_lo32(busaddr));
1920 scb->sg_list.std_list[indx].length = cpu_to_le32(e_len);
1924 scb->data_len += e_len;
1928 /****************************************************************************/
1929 /* Routine Name: ips_flash_firmware */
1930 /* Routine Description: */
1931 /* flashes the firmware of a copperhead adapter */
1932 /****************************************************************************/
1934 ips_flash_firmware(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1936 IPS_SG_LIST sg_list;
1937 uint32_t cmd_busaddr;
1939 if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE &&
1940 pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_FW) {
1941 memset(&pt->CoppCP.cmd, 0, sizeof (IPS_HOST_COMMAND));
1942 pt->CoppCP.cmd.flashfw.op_code = IPS_CMD_DOWNLOAD;
1943 pt->CoppCP.cmd.flashfw.count = cpu_to_le32(ha->flash_datasize);
1945 pt->BasicStatus = 0x0B;
1946 pt->ExtendedStatus = 0x00;
1947 ips_free_flash_copperhead(ha);
1950 /* Save the S/G list pointer so it doesn't get clobbered */
1951 sg_list.list = scb->sg_list.list;
1952 cmd_busaddr = scb->scb_busaddr;
1953 /* copy in the CP */
1954 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1955 /* FIX stuff that might be wrong */
1956 scb->sg_list.list = sg_list.list;
1957 scb->scb_busaddr = cmd_busaddr;
1958 scb->bus = scb->scsi_cmd->device->channel;
1959 scb->target_id = scb->scsi_cmd->device->id;
1960 scb->lun = scb->scsi_cmd->device->lun;
1965 scb->callback = ipsintr_done;
1966 scb->timeout = ips_cmd_timeout;
1968 scb->data_len = ha->flash_datasize;
1970 pci_map_single(ha->pcidev, ha->flash_data, scb->data_len,
1972 scb->flags |= IPS_SCB_MAP_SINGLE;
1973 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
1974 scb->cmd.flashfw.buffer_addr = cpu_to_le32(scb->data_busaddr);
1976 scb->timeout = pt->TimeOut;
1977 scb->scsi_cmd->result = DID_OK << 16;
1981 /****************************************************************************/
1982 /* Routine Name: ips_free_flash_copperhead */
1983 /* Routine Description: */
1984 /* release the memory resources used to hold the flash image */
1985 /****************************************************************************/
1987 ips_free_flash_copperhead(ips_ha_t * ha)
1989 if (ha->flash_data == ips_FlashData)
1990 test_and_clear_bit(0, &ips_FlashDataInUse);
1991 else if (ha->flash_data)
1992 pci_free_consistent(ha->pcidev, ha->flash_len, ha->flash_data,
1994 ha->flash_data = NULL;
1997 /****************************************************************************/
1999 /* Routine Name: ips_usrcmd */
2001 /* Routine Description: */
2003 /* Process a user command and make it ready to send */
2005 /****************************************************************************/
2007 ips_usrcmd(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
2009 IPS_SG_LIST sg_list;
2010 uint32_t cmd_busaddr;
2012 METHOD_TRACE("ips_usrcmd", 1);
2014 if ((!scb) || (!pt) || (!ha))
2017 /* Save the S/G list pointer so it doesn't get clobbered */
2018 sg_list.list = scb->sg_list.list;
2019 cmd_busaddr = scb->scb_busaddr;
2020 /* copy in the CP */
2021 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
2022 memcpy(&scb->dcdb, &pt->CoppCP.dcdb, sizeof (IPS_DCDB_TABLE));
2024 /* FIX stuff that might be wrong */
2025 scb->sg_list.list = sg_list.list;
2026 scb->scb_busaddr = cmd_busaddr;
2027 scb->bus = scb->scsi_cmd->device->channel;
2028 scb->target_id = scb->scsi_cmd->device->id;
2029 scb->lun = scb->scsi_cmd->device->lun;
2034 scb->callback = ipsintr_done;
2035 scb->timeout = ips_cmd_timeout;
2036 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
2038 /* we don't support DCDB/READ/WRITE Scatter Gather */
2039 if ((scb->cmd.basic_io.op_code == IPS_CMD_READ_SG) ||
2040 (scb->cmd.basic_io.op_code == IPS_CMD_WRITE_SG) ||
2041 (scb->cmd.basic_io.op_code == IPS_CMD_DCDB_SG))
2045 scb->data_len = pt->CmdBSize;
2046 scb->data_busaddr = ha->ioctl_busaddr + sizeof (ips_passthru_t);
2048 scb->data_busaddr = 0L;
2051 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
2052 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
2053 (unsigned long) &scb->
2055 (unsigned long) scb);
2058 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
2059 scb->dcdb.buffer_pointer =
2060 cpu_to_le32(scb->data_busaddr);
2062 scb->cmd.basic_io.sg_addr =
2063 cpu_to_le32(scb->data_busaddr);
2068 scb->timeout = pt->TimeOut;
2070 if (pt->TimeOut <= 10)
2071 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;
2072 else if (pt->TimeOut <= 60)
2073 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;
2075 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
2078 /* assume success */
2079 scb->scsi_cmd->result = DID_OK << 16;
2085 /****************************************************************************/
2087 /* Routine Name: ips_cleanup_passthru */
2089 /* Routine Description: */
2091 /* Cleanup after a passthru command */
2093 /****************************************************************************/
2095 ips_cleanup_passthru(ips_ha_t * ha, ips_scb_t * scb)
2099 METHOD_TRACE("ips_cleanup_passthru", 1);
2101 if ((!scb) || (!scb->scsi_cmd) || (!scb->scsi_cmd->request_buffer)) {
2102 DEBUG_VAR(1, "(%s%d) couldn't cleanup after passthru",
2103 ips_name, ha->host_num);
2107 pt = (ips_passthru_t *) ha->ioctl_data;
2109 /* Copy data back to the user */
2110 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB) /* Copy DCDB Back to Caller's Area */
2111 memcpy(&pt->CoppCP.dcdb, &scb->dcdb, sizeof (IPS_DCDB_TABLE));
2113 pt->BasicStatus = scb->basic_status;
2114 pt->ExtendedStatus = scb->extended_status;
2115 pt->AdapterType = ha->ad_type;
2117 if (ha->device_id == IPS_DEVICEID_COPPERHEAD &&
2118 (scb->cmd.flashfw.op_code == IPS_CMD_DOWNLOAD ||
2119 scb->cmd.flashfw.op_code == IPS_CMD_RW_BIOSFW))
2120 ips_free_flash_copperhead(ha);
2122 ips_scmd_buf_write(scb->scsi_cmd, ha->ioctl_data, ha->ioctl_datasize);
2125 /****************************************************************************/
2127 /* Routine Name: ips_host_info */
2129 /* Routine Description: */
2131 /* The passthru interface for the driver */
2133 /****************************************************************************/
2135 ips_host_info(ips_ha_t * ha, char *ptr, off_t offset, int len)
2139 METHOD_TRACE("ips_host_info", 1);
2143 info.offset = offset;
2147 copy_info(&info, "\nIBM ServeRAID General Information:\n\n");
2149 if ((le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) &&
2150 (le16_to_cpu(ha->nvram->adapter_type) != 0))
2151 copy_info(&info, "\tController Type : %s\n",
2152 ips_adapter_name[ha->ad_type - 1]);
2155 "\tController Type : Unknown\n");
2159 "\tIO region : 0x%lx (%d bytes)\n",
2160 ha->io_addr, ha->io_len);
2164 "\tMemory region : 0x%lx (%d bytes)\n",
2165 ha->mem_addr, ha->mem_len);
2167 "\tShared memory address : 0x%lx\n",
2171 copy_info(&info, "\tIRQ number : %d\n", ha->irq);
2173 /* For the Next 3 lines Check for Binary 0 at the end and don't include it if it's there. */
2174 /* That keeps everything happy for "text" operations on the proc file. */
2176 if (le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) {
2177 if (ha->nvram->bios_low[3] == 0) {
2179 "\tBIOS Version : %c%c%c%c%c%c%c\n",
2180 ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2181 ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2182 ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2183 ha->nvram->bios_low[2]);
2187 "\tBIOS Version : %c%c%c%c%c%c%c%c\n",
2188 ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2189 ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2190 ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2191 ha->nvram->bios_low[2], ha->nvram->bios_low[3]);
2196 if (ha->enq->CodeBlkVersion[7] == 0) {
2198 "\tFirmware Version : %c%c%c%c%c%c%c\n",
2199 ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2200 ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2201 ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2202 ha->enq->CodeBlkVersion[6]);
2205 "\tFirmware Version : %c%c%c%c%c%c%c%c\n",
2206 ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2207 ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2208 ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2209 ha->enq->CodeBlkVersion[6], ha->enq->CodeBlkVersion[7]);
2212 if (ha->enq->BootBlkVersion[7] == 0) {
2214 "\tBoot Block Version : %c%c%c%c%c%c%c\n",
2215 ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2216 ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2217 ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2218 ha->enq->BootBlkVersion[6]);
2221 "\tBoot Block Version : %c%c%c%c%c%c%c%c\n",
2222 ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2223 ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2224 ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2225 ha->enq->BootBlkVersion[6], ha->enq->BootBlkVersion[7]);
2228 copy_info(&info, "\tDriver Version : %s%s\n",
2229 IPS_VERSION_HIGH, IPS_VERSION_LOW);
2231 copy_info(&info, "\tDriver Build : %d\n",
2234 copy_info(&info, "\tMax Physical Devices : %d\n",
2235 ha->enq->ucMaxPhysicalDevices);
2236 copy_info(&info, "\tMax Active Commands : %d\n",
2238 copy_info(&info, "\tCurrent Queued Commands : %d\n",
2239 ha->scb_waitlist.count);
2240 copy_info(&info, "\tCurrent Active Commands : %d\n",
2241 ha->scb_activelist.count - ha->num_ioctl);
2242 copy_info(&info, "\tCurrent Queued PT Commands : %d\n",
2243 ha->copp_waitlist.count);
2244 copy_info(&info, "\tCurrent Active PT Commands : %d\n",
2247 copy_info(&info, "\n");
2249 return (info.localpos);
2252 /****************************************************************************/
2254 /* Routine Name: copy_mem_info */
2256 /* Routine Description: */
2258 /* Copy data into an IPS_INFOSTR structure */
2260 /****************************************************************************/
2262 copy_mem_info(IPS_INFOSTR * info, char *data, int len)
2264 METHOD_TRACE("copy_mem_info", 1);
2266 if (info->pos + len < info->offset) {
2271 if (info->pos < info->offset) {
2272 data += (info->offset - info->pos);
2273 len -= (info->offset - info->pos);
2274 info->pos += (info->offset - info->pos);
2277 if (info->localpos + len > info->length)
2278 len = info->length - info->localpos;
2281 memcpy(info->buffer + info->localpos, data, len);
2283 info->localpos += len;
2287 /****************************************************************************/
2289 /* Routine Name: copy_info */
2291 /* Routine Description: */
2293 /* printf style wrapper for an info structure */
2295 /****************************************************************************/
2297 copy_info(IPS_INFOSTR * info, char *fmt, ...)
2303 METHOD_TRACE("copy_info", 1);
2305 va_start(args, fmt);
2306 len = vsprintf(buf, fmt, args);
2309 copy_mem_info(info, buf, len);
2314 /****************************************************************************/
2316 /* Routine Name: ips_identify_controller */
2318 /* Routine Description: */
2320 /* Identify this controller */
2322 /****************************************************************************/
2324 ips_identify_controller(ips_ha_t * ha)
2326 METHOD_TRACE("ips_identify_controller", 1);
2328 switch (ha->device_id) {
2329 case IPS_DEVICEID_COPPERHEAD:
2330 if (ha->revision_id <= IPS_REVID_SERVERAID) {
2331 ha->ad_type = IPS_ADTYPE_SERVERAID;
2332 } else if (ha->revision_id == IPS_REVID_SERVERAID2) {
2333 ha->ad_type = IPS_ADTYPE_SERVERAID2;
2334 } else if (ha->revision_id == IPS_REVID_NAVAJO) {
2335 ha->ad_type = IPS_ADTYPE_NAVAJO;
2336 } else if ((ha->revision_id == IPS_REVID_SERVERAID2)
2337 && (ha->slot_num == 0)) {
2338 ha->ad_type = IPS_ADTYPE_KIOWA;
2339 } else if ((ha->revision_id >= IPS_REVID_CLARINETP1) &&
2340 (ha->revision_id <= IPS_REVID_CLARINETP3)) {
2341 if (ha->enq->ucMaxPhysicalDevices == 15)
2342 ha->ad_type = IPS_ADTYPE_SERVERAID3L;
2344 ha->ad_type = IPS_ADTYPE_SERVERAID3;
2345 } else if ((ha->revision_id >= IPS_REVID_TROMBONE32) &&
2346 (ha->revision_id <= IPS_REVID_TROMBONE64)) {
2347 ha->ad_type = IPS_ADTYPE_SERVERAID4H;
2351 case IPS_DEVICEID_MORPHEUS:
2352 switch (ha->subdevice_id) {
2353 case IPS_SUBDEVICEID_4L:
2354 ha->ad_type = IPS_ADTYPE_SERVERAID4L;
2357 case IPS_SUBDEVICEID_4M:
2358 ha->ad_type = IPS_ADTYPE_SERVERAID4M;
2361 case IPS_SUBDEVICEID_4MX:
2362 ha->ad_type = IPS_ADTYPE_SERVERAID4MX;
2365 case IPS_SUBDEVICEID_4LX:
2366 ha->ad_type = IPS_ADTYPE_SERVERAID4LX;
2369 case IPS_SUBDEVICEID_5I2:
2370 ha->ad_type = IPS_ADTYPE_SERVERAID5I2;
2373 case IPS_SUBDEVICEID_5I1:
2374 ha->ad_type = IPS_ADTYPE_SERVERAID5I1;
2380 case IPS_DEVICEID_MARCO:
2381 switch (ha->subdevice_id) {
2382 case IPS_SUBDEVICEID_6M:
2383 ha->ad_type = IPS_ADTYPE_SERVERAID6M;
2385 case IPS_SUBDEVICEID_6I:
2386 ha->ad_type = IPS_ADTYPE_SERVERAID6I;
2388 case IPS_SUBDEVICEID_7k:
2389 ha->ad_type = IPS_ADTYPE_SERVERAID7k;
2391 case IPS_SUBDEVICEID_7M:
2392 ha->ad_type = IPS_ADTYPE_SERVERAID7M;
2399 /****************************************************************************/
2401 /* Routine Name: ips_get_bios_version */
2403 /* Routine Description: */
2405 /* Get the BIOS revision number */
2407 /****************************************************************************/
2409 ips_get_bios_version(ips_ha_t * ha, int intr)
2418 { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
2421 METHOD_TRACE("ips_get_bios_version", 1);
2426 strncpy(ha->bios_version, " ?", 8);
2428 if (ha->device_id == IPS_DEVICEID_COPPERHEAD) {
2429 if (IPS_USE_MEMIO(ha)) {
2430 /* Memory Mapped I/O */
2433 writel(0, ha->mem_ptr + IPS_REG_FLAP);
2434 if (ha->revision_id == IPS_REVID_TROMBONE64)
2435 udelay(25); /* 25 us */
2437 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
2440 writel(1, ha->mem_ptr + IPS_REG_FLAP);
2441 if (ha->revision_id == IPS_REVID_TROMBONE64)
2442 udelay(25); /* 25 us */
2444 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
2447 /* Get Major version */
2448 writel(0x1FF, ha->mem_ptr + IPS_REG_FLAP);
2449 if (ha->revision_id == IPS_REVID_TROMBONE64)
2450 udelay(25); /* 25 us */
2452 major = readb(ha->mem_ptr + IPS_REG_FLDP);
2454 /* Get Minor version */
2455 writel(0x1FE, ha->mem_ptr + IPS_REG_FLAP);
2456 if (ha->revision_id == IPS_REVID_TROMBONE64)
2457 udelay(25); /* 25 us */
2458 minor = readb(ha->mem_ptr + IPS_REG_FLDP);
2460 /* Get SubMinor version */
2461 writel(0x1FD, ha->mem_ptr + IPS_REG_FLAP);
2462 if (ha->revision_id == IPS_REVID_TROMBONE64)
2463 udelay(25); /* 25 us */
2464 subminor = readb(ha->mem_ptr + IPS_REG_FLDP);
2467 /* Programmed I/O */
2470 outl(0, ha->io_addr + IPS_REG_FLAP);
2471 if (ha->revision_id == IPS_REVID_TROMBONE64)
2472 udelay(25); /* 25 us */
2474 if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
2477 outl(cpu_to_le32(1), ha->io_addr + IPS_REG_FLAP);
2478 if (ha->revision_id == IPS_REVID_TROMBONE64)
2479 udelay(25); /* 25 us */
2481 if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
2484 /* Get Major version */
2485 outl(cpu_to_le32(0x1FF), ha->io_addr + IPS_REG_FLAP);
2486 if (ha->revision_id == IPS_REVID_TROMBONE64)
2487 udelay(25); /* 25 us */
2489 major = inb(ha->io_addr + IPS_REG_FLDP);
2491 /* Get Minor version */
2492 outl(cpu_to_le32(0x1FE), ha->io_addr + IPS_REG_FLAP);
2493 if (ha->revision_id == IPS_REVID_TROMBONE64)
2494 udelay(25); /* 25 us */
2496 minor = inb(ha->io_addr + IPS_REG_FLDP);
2498 /* Get SubMinor version */
2499 outl(cpu_to_le32(0x1FD), ha->io_addr + IPS_REG_FLAP);
2500 if (ha->revision_id == IPS_REVID_TROMBONE64)
2501 udelay(25); /* 25 us */
2503 subminor = inb(ha->io_addr + IPS_REG_FLDP);
2507 /* Morpheus Family - Send Command to the card */
2509 buffer = ha->ioctl_data;
2511 memset(buffer, 0, 0x1000);
2513 scb = &ha->scbs[ha->max_cmds - 1];
2515 ips_init_scb(ha, scb);
2517 scb->timeout = ips_cmd_timeout;
2518 scb->cdb[0] = IPS_CMD_RW_BIOSFW;
2520 scb->cmd.flashfw.op_code = IPS_CMD_RW_BIOSFW;
2521 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
2522 scb->cmd.flashfw.type = 1;
2523 scb->cmd.flashfw.direction = 0;
2524 scb->cmd.flashfw.count = cpu_to_le32(0x800);
2525 scb->cmd.flashfw.total_packets = 1;
2526 scb->cmd.flashfw.packet_num = 0;
2527 scb->data_len = 0x1000;
2528 scb->cmd.flashfw.buffer_addr = ha->ioctl_busaddr;
2530 /* issue the command */
2532 ips_send_wait(ha, scb, ips_cmd_timeout,
2533 intr)) == IPS_FAILURE)
2534 || (ret == IPS_SUCCESS_IMM)
2535 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
2536 /* Error occurred */
2541 if ((buffer[0xC0] == 0x55) && (buffer[0xC1] == 0xAA)) {
2542 major = buffer[0x1ff + 0xC0]; /* Offset 0x1ff after the header (0xc0) */
2543 minor = buffer[0x1fe + 0xC0]; /* Offset 0x1fe after the header (0xc0) */
2544 subminor = buffer[0x1fd + 0xC0]; /* Offset 0x1fd after the header (0xc0) */
2550 ha->bios_version[0] = hexDigits[(major & 0xF0) >> 4];
2551 ha->bios_version[1] = '.';
2552 ha->bios_version[2] = hexDigits[major & 0x0F];
2553 ha->bios_version[3] = hexDigits[subminor];
2554 ha->bios_version[4] = '.';
2555 ha->bios_version[5] = hexDigits[(minor & 0xF0) >> 4];
2556 ha->bios_version[6] = hexDigits[minor & 0x0F];
2557 ha->bios_version[7] = 0;
2560 /****************************************************************************/
2562 /* Routine Name: ips_hainit */
2564 /* Routine Description: */
2566 /* Initialize the controller */
2568 /* NOTE: Assumes to be called from with a lock */
2570 /****************************************************************************/
2572 ips_hainit(ips_ha_t * ha)
2577 METHOD_TRACE("ips_hainit", 1);
2582 if (ha->func.statinit)
2583 (*ha->func.statinit) (ha);
2585 if (ha->func.enableint)
2586 (*ha->func.enableint) (ha);
2589 ha->reset_count = 1;
2590 do_gettimeofday(&tv);
2591 ha->last_ffdc = tv.tv_sec;
2592 ips_ffdc_reset(ha, IPS_INTR_IORL);
2594 if (!ips_read_config(ha, IPS_INTR_IORL)) {
2595 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2596 "unable to read config from controller.\n");
2601 if (!ips_read_adapter_status(ha, IPS_INTR_IORL)) {
2602 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2603 "unable to read controller status.\n");
2608 /* Identify this controller */
2609 ips_identify_controller(ha);
2611 if (!ips_read_subsystem_parameters(ha, IPS_INTR_IORL)) {
2612 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2613 "unable to read subsystem parameters.\n");
2618 /* write nvram user page 5 */
2619 if (!ips_write_driver_status(ha, IPS_INTR_IORL)) {
2620 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2621 "unable to write driver info to controller.\n");
2626 /* If there are Logical Drives and a Reset Occurred, then an EraseStripeLock is Needed */
2627 if ((ha->conf->ucLogDriveCount > 0) && (ha->requires_esl == 1))
2628 ips_clear_adapter(ha, IPS_INTR_IORL);
2630 /* set limits on SID, LUN, BUS */
2631 ha->ntargets = IPS_MAX_TARGETS + 1;
2633 ha->nbus = (ha->enq->ucMaxPhysicalDevices / IPS_MAX_TARGETS) + 1;
2635 switch (ha->conf->logical_drive[0].ucStripeSize) {
2637 ha->max_xfer = 0x10000;
2641 ha->max_xfer = 0x20000;
2645 ha->max_xfer = 0x40000;
2650 ha->max_xfer = 0x80000;
2654 /* setup max concurrent commands */
2655 if (le32_to_cpu(ha->subsys->param[4]) & 0x1) {
2656 /* Use the new method */
2657 ha->max_cmds = ha->enq->ucConcurrentCmdCount;
2659 /* use the old method */
2660 switch (ha->conf->logical_drive[0].ucStripeSize) {
2680 /* Limit the Active Commands on a Lite Adapter */
2681 if ((ha->ad_type == IPS_ADTYPE_SERVERAID3L) ||
2682 (ha->ad_type == IPS_ADTYPE_SERVERAID4L) ||
2683 (ha->ad_type == IPS_ADTYPE_SERVERAID4LX)) {
2684 if ((ha->max_cmds > MaxLiteCmds) && (MaxLiteCmds))
2685 ha->max_cmds = MaxLiteCmds;
2688 /* set controller IDs */
2689 ha->ha_id[0] = IPS_ADAPTER_ID;
2690 for (i = 1; i < ha->nbus; i++) {
2691 ha->ha_id[i] = ha->conf->init_id[i - 1] & 0x1f;
2692 ha->dcdb_active[i - 1] = 0;
2698 /****************************************************************************/
2700 /* Routine Name: ips_next */
2702 /* Routine Description: */
2704 /* Take the next command off the queue and send it to the controller */
2706 /****************************************************************************/
2708 ips_next(ips_ha_t * ha, int intr)
2714 ips_copp_wait_item_t *item;
2716 unsigned long cpu_flags = 0;
2717 struct Scsi_Host *host;
2718 METHOD_TRACE("ips_next", 1);
2722 host = ips_sh[ha->host_num];
2724 * Block access to the queue function so
2725 * this command won't time out
2727 if (intr == IPS_INTR_ON)
2728 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2730 if ((ha->subsys->param[3] & 0x300000)
2731 && (ha->scb_activelist.count == 0)) {
2734 do_gettimeofday(&tv);
2736 if (tv.tv_sec - ha->last_ffdc > IPS_SECS_8HOURS) {
2737 ha->last_ffdc = tv.tv_sec;
2743 * Send passthru commands
2744 * These have priority over normal I/O
2745 * but shouldn't affect performance too much
2746 * since we limit the number that can be active
2747 * on the card at any one time
2749 while ((ha->num_ioctl < IPS_MAX_IOCTL) &&
2750 (ha->copp_waitlist.head) && (scb = ips_getscb(ha))) {
2752 item = ips_removeq_copp_head(&ha->copp_waitlist);
2754 if (intr == IPS_INTR_ON)
2755 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2756 scb->scsi_cmd = item->scsi_cmd;
2759 ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
2761 if (intr == IPS_INTR_ON)
2762 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2765 if (scb->scsi_cmd) {
2766 scb->scsi_cmd->result = DID_ERROR << 16;
2767 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2770 ips_freescb(ha, scb);
2772 case IPS_SUCCESS_IMM:
2773 if (scb->scsi_cmd) {
2774 scb->scsi_cmd->result = DID_OK << 16;
2775 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2778 ips_freescb(ha, scb);
2784 if (ret != IPS_SUCCESS) {
2789 ret = ips_send_cmd(ha, scb);
2791 if (ret == IPS_SUCCESS)
2792 ips_putq_scb_head(&ha->scb_activelist, scb);
2798 if (scb->scsi_cmd) {
2799 scb->scsi_cmd->result = DID_ERROR << 16;
2802 ips_freescb(ha, scb);
2804 case IPS_SUCCESS_IMM:
2805 ips_freescb(ha, scb);
2814 * Send "Normal" I/O commands
2817 p = ha->scb_waitlist.head;
2818 while ((p) && (scb = ips_getscb(ha))) {
2819 if ((p->device->channel > 0)
2821 dcdb_active[p->device->channel -
2822 1] & (1 << p->device->id))) {
2823 ips_freescb(ha, scb);
2824 p = (Scsi_Cmnd *) p->host_scribble;
2829 SC = ips_removeq_wait(&ha->scb_waitlist, q);
2831 if (intr == IPS_INTR_ON)
2832 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags); /* Unlock HA after command is taken off queue */
2834 SC->result = DID_OK;
2835 SC->host_scribble = NULL;
2837 memset(SC->sense_buffer, 0, sizeof (SC->sense_buffer));
2839 scb->target_id = SC->device->id;
2840 scb->lun = SC->device->lun;
2841 scb->bus = SC->device->channel;
2845 scb->callback = ipsintr_done;
2846 scb->timeout = ips_cmd_timeout;
2847 memset(&scb->cmd, 0, 16);
2849 /* copy in the CDB */
2850 memcpy(scb->cdb, SC->cmnd, SC->cmd_len);
2852 /* Now handle the data buffer */
2854 struct scatterlist *sg;
2857 sg = SC->request_buffer;
2858 scb->sg_count = pci_map_sg(ha->pcidev, sg, SC->use_sg,
2859 SC->sc_data_direction);
2860 scb->flags |= IPS_SCB_MAP_SG;
2861 for (i = 0; i < scb->sg_count; i++) {
2862 if (ips_fill_scb_sg_single
2863 (ha, sg_dma_address(&sg[i]), scb, i,
2864 sg_dma_len(&sg[i])) < 0)
2867 scb->dcdb.transfer_length = scb->data_len;
2869 if (SC->request_bufflen) {
2871 pci_map_single(ha->pcidev,
2873 SC->request_bufflen,
2874 SC->sc_data_direction);
2875 scb->flags |= IPS_SCB_MAP_SINGLE;
2876 ips_fill_scb_sg_single(ha, scb->data_busaddr,
2878 SC->request_bufflen);
2879 scb->dcdb.transfer_length = scb->data_len;
2881 scb->data_busaddr = 0L;
2884 scb->dcdb.transfer_length = 0;
2889 scb->dcdb.cmd_attribute =
2890 ips_command_direction[scb->scsi_cmd->cmnd[0]];
2892 /* Allow a WRITE BUFFER Command to Have no Data */
2893 /* This is Used by Tape Flash Utilites */
2894 if ((scb->scsi_cmd->cmnd[0] == WRITE_BUFFER) && (scb->data_len == 0))
2895 scb->dcdb.cmd_attribute = 0;
2897 if (!(scb->dcdb.cmd_attribute & 0x3))
2898 scb->dcdb.transfer_length = 0;
2900 if (scb->data_len >= IPS_MAX_XFER) {
2901 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
2902 scb->dcdb.transfer_length = 0;
2904 if (intr == IPS_INTR_ON)
2905 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2907 ret = ips_send_cmd(ha, scb);
2911 ips_putq_scb_head(&ha->scb_activelist, scb);
2914 if (scb->scsi_cmd) {
2915 scb->scsi_cmd->result = DID_ERROR << 16;
2916 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2920 ha->dcdb_active[scb->bus - 1] &=
2921 ~(1 << scb->target_id);
2923 ips_freescb(ha, scb);
2925 case IPS_SUCCESS_IMM:
2927 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2930 ha->dcdb_active[scb->bus - 1] &=
2931 ~(1 << scb->target_id);
2933 ips_freescb(ha, scb);
2939 p = (Scsi_Cmnd *) p->host_scribble;
2943 if (intr == IPS_INTR_ON)
2944 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2947 /****************************************************************************/
2949 /* Routine Name: ips_putq_scb_head */
2951 /* Routine Description: */
2953 /* Add an item to the head of the queue */
2955 /* ASSUMED to be called from within the HA lock */
2957 /****************************************************************************/
2959 ips_putq_scb_head(ips_scb_queue_t * queue, ips_scb_t * item)
2961 METHOD_TRACE("ips_putq_scb_head", 1);
2966 item->q_next = queue->head;
2975 /****************************************************************************/
2977 /* Routine Name: ips_removeq_scb_head */
2979 /* Routine Description: */
2981 /* Remove the head of the queue */
2983 /* ASSUMED to be called from within the HA lock */
2985 /****************************************************************************/
2987 ips_removeq_scb_head(ips_scb_queue_t * queue)
2991 METHOD_TRACE("ips_removeq_scb_head", 1);
2999 queue->head = item->q_next;
3000 item->q_next = NULL;
3002 if (queue->tail == item)
3010 /****************************************************************************/
3012 /* Routine Name: ips_removeq_scb */
3014 /* Routine Description: */
3016 /* Remove an item from a queue */
3018 /* ASSUMED to be called from within the HA lock */
3020 /****************************************************************************/
3022 ips_removeq_scb(ips_scb_queue_t * queue, ips_scb_t * item)
3026 METHOD_TRACE("ips_removeq_scb", 1);
3031 if (item == queue->head) {
3032 return (ips_removeq_scb_head(queue));
3037 while ((p) && (item != p->q_next))
3042 p->q_next = item->q_next;
3047 item->q_next = NULL;
3056 /****************************************************************************/
3058 /* Routine Name: ips_putq_wait_tail */
3060 /* Routine Description: */
3062 /* Add an item to the tail of the queue */
3064 /* ASSUMED to be called from within the HA lock */
3066 /****************************************************************************/
3068 ips_putq_wait_tail(ips_wait_queue_t * queue, Scsi_Cmnd * item)
3070 METHOD_TRACE("ips_putq_wait_tail", 1);
3075 item->host_scribble = NULL;
3078 queue->tail->host_scribble = (char *) item;
3088 /****************************************************************************/
3090 /* Routine Name: ips_removeq_wait_head */
3092 /* Routine Description: */
3094 /* Remove the head of the queue */
3096 /* ASSUMED to be called from within the HA lock */
3098 /****************************************************************************/
3100 ips_removeq_wait_head(ips_wait_queue_t * queue)
3104 METHOD_TRACE("ips_removeq_wait_head", 1);
3112 queue->head = (Scsi_Cmnd *) item->host_scribble;
3113 item->host_scribble = NULL;
3115 if (queue->tail == item)
3123 /****************************************************************************/
3125 /* Routine Name: ips_removeq_wait */
3127 /* Routine Description: */
3129 /* Remove an item from a queue */
3131 /* ASSUMED to be called from within the HA lock */
3133 /****************************************************************************/
3135 ips_removeq_wait(ips_wait_queue_t * queue, Scsi_Cmnd * item)
3139 METHOD_TRACE("ips_removeq_wait", 1);
3144 if (item == queue->head) {
3145 return (ips_removeq_wait_head(queue));
3150 while ((p) && (item != (Scsi_Cmnd *) p->host_scribble))
3151 p = (Scsi_Cmnd *) p->host_scribble;
3155 p->host_scribble = item->host_scribble;
3157 if (!item->host_scribble)
3160 item->host_scribble = NULL;
3169 /****************************************************************************/
3171 /* Routine Name: ips_putq_copp_tail */
3173 /* Routine Description: */
3175 /* Add an item to the tail of the queue */
3177 /* ASSUMED to be called from within the HA lock */
3179 /****************************************************************************/
3181 ips_putq_copp_tail(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3183 METHOD_TRACE("ips_putq_copp_tail", 1);
3191 queue->tail->next = item;
3201 /****************************************************************************/
3203 /* Routine Name: ips_removeq_copp_head */
3205 /* Routine Description: */
3207 /* Remove the head of the queue */
3209 /* ASSUMED to be called from within the HA lock */
3211 /****************************************************************************/
3212 static ips_copp_wait_item_t *
3213 ips_removeq_copp_head(ips_copp_queue_t * queue)
3215 ips_copp_wait_item_t *item;
3217 METHOD_TRACE("ips_removeq_copp_head", 1);
3225 queue->head = item->next;
3228 if (queue->tail == item)
3236 /****************************************************************************/
3238 /* Routine Name: ips_removeq_copp */
3240 /* Routine Description: */
3242 /* Remove an item from a queue */
3244 /* ASSUMED to be called from within the HA lock */
3246 /****************************************************************************/
3247 static ips_copp_wait_item_t *
3248 ips_removeq_copp(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3250 ips_copp_wait_item_t *p;
3252 METHOD_TRACE("ips_removeq_copp", 1);
3257 if (item == queue->head) {
3258 return (ips_removeq_copp_head(queue));
3263 while ((p) && (item != p->next))
3268 p->next = item->next;
3282 /****************************************************************************/
3284 /* Routine Name: ipsintr_blocking */
3286 /* Routine Description: */
3288 /* Finalize an interrupt for internal commands */
3290 /****************************************************************************/
3292 ipsintr_blocking(ips_ha_t * ha, ips_scb_t * scb)
3294 METHOD_TRACE("ipsintr_blocking", 2);
3296 ips_freescb(ha, scb);
3297 if ((ha->waitflag == TRUE) && (ha->cmd_in_progress == scb->cdb[0])) {
3298 ha->waitflag = FALSE;
3304 /****************************************************************************/
3306 /* Routine Name: ipsintr_done */
3308 /* Routine Description: */
3310 /* Finalize an interrupt for non-internal commands */
3312 /****************************************************************************/
3314 ipsintr_done(ips_ha_t * ha, ips_scb_t * scb)
3316 METHOD_TRACE("ipsintr_done", 2);
3319 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3320 "Spurious interrupt; scb NULL.\n");
3325 if (scb->scsi_cmd == NULL) {
3326 /* unexpected interrupt */
3327 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3328 "Spurious interrupt; scsi_cmd not set.\n");
3336 /****************************************************************************/
3338 /* Routine Name: ips_done */
3340 /* Routine Description: */
3342 /* Do housekeeping on completed commands */
3343 /* ASSUMED to be called form within the request lock */
3344 /****************************************************************************/
3346 ips_done(ips_ha_t * ha, ips_scb_t * scb)
3350 METHOD_TRACE("ips_done", 1);
3355 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd))) {
3356 ips_cleanup_passthru(ha, scb);
3360 * Check to see if this command had too much
3361 * data and had to be broke up. If so, queue
3362 * the rest of the data and continue.
3364 if ((scb->breakup) || (scb->sg_break)) {
3365 /* we had a data breakup */
3368 if (scb->sg_count) {
3370 struct scatterlist *sg;
3371 int ips_sg_index = 0;
3374 sg = scb->scsi_cmd->request_buffer;
3376 /* Spin forward to last dma chunk */
3377 sg_dma_index = scb->breakup;
3379 /* Take care of possible partial on last chunk */
3380 ips_fill_scb_sg_single(ha,
3383 scb, ips_sg_index++,
3387 for (; sg_dma_index < scb->sg_count;
3389 if (ips_fill_scb_sg_single
3391 sg_dma_address(&sg[sg_dma_index]),
3392 scb, ips_sg_index++,
3393 sg_dma_len(&sg[sg_dma_index])) < 0)
3399 /* Non S/G Request */
3400 (void) ips_fill_scb_sg_single(ha,
3412 scb->dcdb.transfer_length = scb->data_len;
3413 scb->dcdb.cmd_attribute |=
3414 ips_command_direction[scb->scsi_cmd->cmnd[0]];
3416 if (!(scb->dcdb.cmd_attribute & 0x3))
3417 scb->dcdb.transfer_length = 0;
3419 if (scb->data_len >= IPS_MAX_XFER) {
3420 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
3421 scb->dcdb.transfer_length = 0;
3424 ret = ips_send_cmd(ha, scb);
3428 if (scb->scsi_cmd) {
3429 scb->scsi_cmd->result = DID_ERROR << 16;
3430 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3433 ips_freescb(ha, scb);
3435 case IPS_SUCCESS_IMM:
3436 if (scb->scsi_cmd) {
3437 scb->scsi_cmd->result = DID_ERROR << 16;
3438 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3441 ips_freescb(ha, scb);
3449 } /* end if passthru */
3452 ha->dcdb_active[scb->bus - 1] &= ~(1 << scb->target_id);
3455 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3457 ips_freescb(ha, scb);
3460 /****************************************************************************/
3462 /* Routine Name: ips_map_status */
3464 /* Routine Description: */
3466 /* Map Controller Error codes to Linux Error Codes */
3468 /****************************************************************************/
3470 ips_map_status(ips_ha_t * ha, ips_scb_t * scb, ips_stat_t * sp)
3474 uint32_t transfer_len;
3475 IPS_DCDB_TABLE_TAPE *tapeDCDB;
3477 METHOD_TRACE("ips_map_status", 1);
3481 "(%s%d) Physical device error (%d %d %d): %x %x, Sense Key: %x, ASC: %x, ASCQ: %x",
3482 ips_name, ha->host_num,
3483 scb->scsi_cmd->device->channel,
3484 scb->scsi_cmd->device->id, scb->scsi_cmd->device->lun,
3485 scb->basic_status, scb->extended_status,
3486 scb->extended_status ==
3487 IPS_ERR_CKCOND ? scb->dcdb.sense_info[2] & 0xf : 0,
3488 scb->extended_status ==
3489 IPS_ERR_CKCOND ? scb->dcdb.sense_info[12] : 0,
3490 scb->extended_status ==
3491 IPS_ERR_CKCOND ? scb->dcdb.sense_info[13] : 0);
3494 /* default driver error */
3495 errcode = DID_ERROR;
3498 switch (scb->basic_status & IPS_GSC_STATUS_MASK) {
3499 case IPS_CMD_TIMEOUT:
3500 errcode = DID_TIME_OUT;
3503 case IPS_INVAL_OPCO:
3504 case IPS_INVAL_CMD_BLK:
3505 case IPS_INVAL_PARM_BLK:
3507 case IPS_CMD_CMPLT_WERROR:
3510 case IPS_PHYS_DRV_ERROR:
3511 switch (scb->extended_status) {
3512 case IPS_ERR_SEL_TO:
3514 errcode = DID_NO_CONNECT;
3518 case IPS_ERR_OU_RUN:
3519 if ((scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB) ||
3520 (scb->cmd.dcdb.op_code ==
3521 IPS_CMD_EXTENDED_DCDB_SG)) {
3522 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3523 transfer_len = tapeDCDB->transfer_length;
3526 (uint32_t) scb->dcdb.transfer_length;
3529 if ((scb->bus) && (transfer_len < scb->data_len)) {
3530 /* Underrun - set default to no error */
3533 /* Restrict access to physical DASD */
3534 if ((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
3535 ((((char *) scb->scsi_cmd->
3536 buffer)[0] & 0x1f) == TYPE_DISK)) {
3537 /* underflow -- no error */
3538 /* restrict access to physical DASD */
3539 errcode = DID_TIME_OUT;
3543 errcode = DID_ERROR;
3547 case IPS_ERR_RECOVERY:
3548 /* don't fail recovered errors */
3554 case IPS_ERR_HOST_RESET:
3555 case IPS_ERR_DEV_RESET:
3556 errcode = DID_RESET;
3559 case IPS_ERR_CKCOND:
3561 if ((scb->cmd.dcdb.op_code ==
3562 IPS_CMD_EXTENDED_DCDB)
3563 || (scb->cmd.dcdb.op_code ==
3564 IPS_CMD_EXTENDED_DCDB_SG)) {
3566 (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3567 memcpy(scb->scsi_cmd->sense_buffer,
3568 tapeDCDB->sense_info,
3569 sizeof (scb->scsi_cmd->
3572 memcpy(scb->scsi_cmd->sense_buffer,
3573 scb->dcdb.sense_info,
3574 sizeof (scb->scsi_cmd->
3577 device_error = 2; /* check condition */
3585 errcode = DID_ERROR;
3591 scb->scsi_cmd->result = device_error | (errcode << 16);
3596 /****************************************************************************/
3598 /* Routine Name: ips_send_wait */
3600 /* Routine Description: */
3602 /* Send a command to the controller and wait for it to return */
3604 /* The FFDC Time Stamp use this function for the callback, but doesn't */
3605 /* actually need to wait. */
3606 /****************************************************************************/
3608 ips_send_wait(ips_ha_t * ha, ips_scb_t * scb, int timeout, int intr)
3612 METHOD_TRACE("ips_send_wait", 1);
3614 if (intr != IPS_FFDC) { /* Won't be Waiting if this is a Time Stamp */
3615 ha->waitflag = TRUE;
3616 ha->cmd_in_progress = scb->cdb[0];
3618 scb->callback = ipsintr_blocking;
3619 ret = ips_send_cmd(ha, scb);
3621 if ((ret == IPS_FAILURE) || (ret == IPS_SUCCESS_IMM))
3624 if (intr != IPS_FFDC) /* Don't Wait around if this is a Time Stamp */
3625 ret = ips_wait(ha, timeout, intr);
3630 /****************************************************************************/
3632 /* Routine Name: ips_scmd_buf_write */
3634 /* Routine Description: */
3635 /* Write data to Scsi_Cmnd request_buffer at proper offsets */
3636 /****************************************************************************/
3638 ips_scmd_buf_write(Scsi_Cmnd * scmd, void *data, unsigned
3643 unsigned int min_cnt, xfer_cnt;
3644 char *cdata = (char *) data;
3645 struct scatterlist *sg = scmd->request_buffer;
3646 for (i = 0, xfer_cnt = 0;
3647 (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3648 if (!IPS_SG_ADDRESS(&sg[i]))
3650 min_cnt = min(count - xfer_cnt, sg[i].length);
3651 memcpy(IPS_SG_ADDRESS(&sg[i]), &cdata[xfer_cnt],
3653 xfer_cnt += min_cnt;
3657 unsigned int min_cnt = min(count, scmd->request_bufflen);
3658 memcpy(scmd->request_buffer, data, min_cnt);
3662 /****************************************************************************/
3664 /* Routine Name: ips_scmd_buf_read */
3666 /* Routine Description: */
3667 /* Copy data from a Scsi_Cmnd to a new, linear buffer */
3668 /****************************************************************************/
3670 ips_scmd_buf_read(Scsi_Cmnd * scmd, void *data, unsigned
3675 unsigned int min_cnt, xfer_cnt;
3676 char *cdata = (char *) data;
3677 struct scatterlist *sg = scmd->request_buffer;
3678 for (i = 0, xfer_cnt = 0;
3679 (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3680 if (!IPS_SG_ADDRESS(&sg[i]))
3682 min_cnt = min(count - xfer_cnt, sg[i].length);
3683 memcpy(&cdata[xfer_cnt], IPS_SG_ADDRESS(&sg[i]),
3685 xfer_cnt += min_cnt;
3689 unsigned int min_cnt = min(count, scmd->request_bufflen);
3690 memcpy(data, scmd->request_buffer, min_cnt);
3694 /****************************************************************************/
3696 /* Routine Name: ips_send_cmd */
3698 /* Routine Description: */
3700 /* Map SCSI commands to ServeRAID commands for logical drives */
3702 /****************************************************************************/
3704 ips_send_cmd(ips_ha_t * ha, ips_scb_t * scb)
3709 IPS_DCDB_TABLE_TAPE *tapeDCDB;
3712 METHOD_TRACE("ips_send_cmd", 1);
3716 if (!scb->scsi_cmd) {
3717 /* internal command */
3720 /* Controller commands can't be issued */
3721 /* to real devices -- fail them */
3722 if ((ha->waitflag == TRUE) &&
3723 (ha->cmd_in_progress == scb->cdb[0])) {
3724 ha->waitflag = FALSE;
3729 } else if ((scb->bus == 0) && (!ips_is_passthru(scb->scsi_cmd))) {
3730 /* command to logical bus -- interpret */
3731 ret = IPS_SUCCESS_IMM;
3733 switch (scb->scsi_cmd->cmnd[0]) {
3734 case ALLOW_MEDIUM_REMOVAL:
3737 case WRITE_FILEMARKS:
3739 scb->scsi_cmd->result = DID_ERROR << 16;
3743 scb->scsi_cmd->result = DID_OK << 16;
3745 case TEST_UNIT_READY:
3747 if (scb->target_id == IPS_ADAPTER_ID) {
3749 * Either we have a TUR
3750 * or we have a SCSI inquiry
3752 if (scb->scsi_cmd->cmnd[0] == TEST_UNIT_READY)
3753 scb->scsi_cmd->result = DID_OK << 16;
3755 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3756 IPS_SCSI_INQ_DATA inquiry;
3759 sizeof (IPS_SCSI_INQ_DATA));
3761 inquiry.DeviceType =
3762 IPS_SCSI_INQ_TYPE_PROCESSOR;
3763 inquiry.DeviceTypeQualifier =
3764 IPS_SCSI_INQ_LU_CONNECTED;
3765 inquiry.Version = IPS_SCSI_INQ_REV2;
3766 inquiry.ResponseDataFormat =
3767 IPS_SCSI_INQ_RD_REV2;
3768 inquiry.AdditionalLength = 31;
3770 IPS_SCSI_INQ_Address16;
3772 IPS_SCSI_INQ_WBus16 |
3774 strncpy(inquiry.VendorId, "IBM ",
3776 strncpy(inquiry.ProductId,
3778 strncpy(inquiry.ProductRevisionLevel,
3781 ips_scmd_buf_write(scb->scsi_cmd,
3785 scb->scsi_cmd->result = DID_OK << 16;
3788 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3789 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3790 scb->cmd.logical_info.reserved = 0;
3791 scb->cmd.logical_info.reserved2 = 0;
3792 scb->data_len = sizeof (IPS_LD_INFO);
3793 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3795 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3802 ips_reqsen(ha, scb);
3803 scb->scsi_cmd->result = DID_OK << 16;
3809 scb->cmd.basic_io.op_code =
3810 (scb->scsi_cmd->cmnd[0] ==
3811 READ_6) ? IPS_CMD_READ : IPS_CMD_WRITE;
3812 scb->cmd.basic_io.enhanced_sg = 0;
3813 scb->cmd.basic_io.sg_addr =
3814 cpu_to_le32(scb->data_busaddr);
3816 scb->cmd.basic_io.op_code =
3817 (scb->scsi_cmd->cmnd[0] ==
3818 READ_6) ? IPS_CMD_READ_SG :
3820 scb->cmd.basic_io.enhanced_sg =
3821 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3822 scb->cmd.basic_io.sg_addr =
3823 cpu_to_le32(scb->sg_busaddr);
3826 scb->cmd.basic_io.segment_4G = 0;
3827 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3828 scb->cmd.basic_io.log_drv = scb->target_id;
3829 scb->cmd.basic_io.sg_count = scb->sg_len;
3831 if (scb->cmd.basic_io.lba)
3832 scb->cmd.basic_io.lba =
3833 cpu_to_le32(le32_to_cpu
3834 (scb->cmd.basic_io.lba) +
3835 le16_to_cpu(scb->cmd.basic_io.
3838 scb->cmd.basic_io.lba =
3840 cmnd[1] & 0x1f) << 16) | (scb->scsi_cmd->
3842 (scb->scsi_cmd->cmnd[3]));
3844 scb->cmd.basic_io.sector_count =
3845 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3847 if (le16_to_cpu(scb->cmd.basic_io.sector_count) == 0)
3848 scb->cmd.basic_io.sector_count =
3857 scb->cmd.basic_io.op_code =
3858 (scb->scsi_cmd->cmnd[0] ==
3859 READ_10) ? IPS_CMD_READ : IPS_CMD_WRITE;
3860 scb->cmd.basic_io.enhanced_sg = 0;
3861 scb->cmd.basic_io.sg_addr =
3862 cpu_to_le32(scb->data_busaddr);
3864 scb->cmd.basic_io.op_code =
3865 (scb->scsi_cmd->cmnd[0] ==
3866 READ_10) ? IPS_CMD_READ_SG :
3868 scb->cmd.basic_io.enhanced_sg =
3869 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3870 scb->cmd.basic_io.sg_addr =
3871 cpu_to_le32(scb->sg_busaddr);
3874 scb->cmd.basic_io.segment_4G = 0;
3875 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3876 scb->cmd.basic_io.log_drv = scb->target_id;
3877 scb->cmd.basic_io.sg_count = scb->sg_len;
3879 if (scb->cmd.basic_io.lba)
3880 scb->cmd.basic_io.lba =
3881 cpu_to_le32(le32_to_cpu
3882 (scb->cmd.basic_io.lba) +
3883 le16_to_cpu(scb->cmd.basic_io.
3886 scb->cmd.basic_io.lba =
3887 ((scb->scsi_cmd->cmnd[2] << 24) | (scb->
3891 (scb->scsi_cmd->cmnd[4] << 8) | scb->
3894 scb->cmd.basic_io.sector_count =
3895 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3897 if (cpu_to_le16(scb->cmd.basic_io.sector_count) == 0) {
3899 * This is a null condition
3900 * we don't have to do anything
3903 scb->scsi_cmd->result = DID_OK << 16;
3911 scb->scsi_cmd->result = DID_OK << 16;
3915 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
3916 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3917 scb->cmd.basic_io.segment_4G = 0;
3918 scb->cmd.basic_io.enhanced_sg = 0;
3919 scb->data_len = sizeof (*ha->enq);
3920 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
3925 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3926 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3927 scb->cmd.logical_info.reserved = 0;
3928 scb->cmd.logical_info.reserved2 = 0;
3929 scb->cmd.logical_info.reserved3 = 0;
3930 scb->data_len = sizeof (IPS_LD_INFO);
3931 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3933 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3937 case SEND_DIAGNOSTIC:
3938 case REASSIGN_BLOCKS:
3942 case READ_DEFECT_DATA:
3945 scb->scsi_cmd->result = DID_OK << 16;
3949 /* Set the Return Info to appear like the Command was */
3950 /* attempted, a Check Condition occurred, and Sense */
3951 /* Data indicating an Invalid CDB OpCode is returned. */
3952 sp = (char *) scb->scsi_cmd->sense_buffer;
3953 memset(sp, 0, sizeof (scb->scsi_cmd->sense_buffer));
3955 sp[0] = 0x70; /* Error Code */
3956 sp[2] = ILLEGAL_REQUEST; /* Sense Key 5 Illegal Req. */
3957 sp[7] = 0x0A; /* Additional Sense Length */
3958 sp[12] = 0x20; /* ASC = Invalid OpCode */
3959 sp[13] = 0x00; /* ASCQ */
3961 device_error = 2; /* Indicate Check Condition */
3962 scb->scsi_cmd->result = device_error | (DID_OK << 16);
3967 if (ret == IPS_SUCCESS_IMM)
3973 /* If we already know the Device is Not there, no need to attempt a Command */
3974 /* This also protects an NT FailOver Controller from getting CDB's sent to it */
3975 if (ha->conf->dev[scb->bus - 1][scb->target_id].ucState == 0) {
3976 scb->scsi_cmd->result = DID_NO_CONNECT << 16;
3977 return (IPS_SUCCESS_IMM);
3980 ha->dcdb_active[scb->bus - 1] |= (1 << scb->target_id);
3981 scb->cmd.dcdb.command_id = IPS_COMMAND_ID(ha, scb);
3982 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
3983 (unsigned long) &scb->
3985 (unsigned long) scb);
3986 scb->cmd.dcdb.reserved = 0;
3987 scb->cmd.dcdb.reserved2 = 0;
3988 scb->cmd.dcdb.reserved3 = 0;
3989 scb->cmd.dcdb.segment_4G = 0;
3990 scb->cmd.dcdb.enhanced_sg = 0;
3992 TimeOut = scb->scsi_cmd->timeout_per_command;
3994 if (ha->subsys->param[4] & 0x00100000) { /* If NEW Tape DCDB is Supported */
3996 scb->cmd.dcdb.op_code = IPS_CMD_EXTENDED_DCDB;
3998 scb->cmd.dcdb.op_code =
3999 IPS_CMD_EXTENDED_DCDB_SG;
4000 scb->cmd.dcdb.enhanced_sg =
4001 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
4004 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb; /* Use Same Data Area as Old DCDB Struct */
4005 tapeDCDB->device_address =
4006 ((scb->bus - 1) << 4) | scb->target_id;
4007 tapeDCDB->cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4008 tapeDCDB->cmd_attribute &= ~IPS_TRANSFER64K; /* Always Turn OFF 64K Size Flag */
4011 if (TimeOut < (10 * HZ))
4012 tapeDCDB->cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
4013 else if (TimeOut < (60 * HZ))
4014 tapeDCDB->cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
4015 else if (TimeOut < (1200 * HZ))
4016 tapeDCDB->cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
4019 tapeDCDB->cdb_length = scb->scsi_cmd->cmd_len;
4020 tapeDCDB->reserved_for_LUN = 0;
4021 tapeDCDB->transfer_length = scb->data_len;
4022 if (scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB_SG)
4023 tapeDCDB->buffer_pointer =
4024 cpu_to_le32(scb->sg_busaddr);
4026 tapeDCDB->buffer_pointer =
4027 cpu_to_le32(scb->data_busaddr);
4028 tapeDCDB->sg_count = scb->sg_len;
4029 tapeDCDB->sense_length = sizeof (tapeDCDB->sense_info);
4030 tapeDCDB->scsi_status = 0;
4031 tapeDCDB->reserved = 0;
4032 memcpy(tapeDCDB->scsi_cdb, scb->scsi_cmd->cmnd,
4033 scb->scsi_cmd->cmd_len);
4036 scb->cmd.dcdb.op_code = IPS_CMD_DCDB;
4038 scb->cmd.dcdb.op_code = IPS_CMD_DCDB_SG;
4039 scb->cmd.dcdb.enhanced_sg =
4040 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
4043 scb->dcdb.device_address =
4044 ((scb->bus - 1) << 4) | scb->target_id;
4045 scb->dcdb.cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4048 if (TimeOut < (10 * HZ))
4049 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
4050 else if (TimeOut < (60 * HZ))
4051 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
4052 else if (TimeOut < (1200 * HZ))
4053 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
4056 scb->dcdb.transfer_length = scb->data_len;
4057 if (scb->dcdb.cmd_attribute & IPS_TRANSFER64K)
4058 scb->dcdb.transfer_length = 0;
4059 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB_SG)
4060 scb->dcdb.buffer_pointer =
4061 cpu_to_le32(scb->sg_busaddr);
4063 scb->dcdb.buffer_pointer =
4064 cpu_to_le32(scb->data_busaddr);
4065 scb->dcdb.cdb_length = scb->scsi_cmd->cmd_len;
4066 scb->dcdb.sense_length = sizeof (scb->dcdb.sense_info);
4067 scb->dcdb.sg_count = scb->sg_len;
4068 scb->dcdb.reserved = 0;
4069 memcpy(scb->dcdb.scsi_cdb, scb->scsi_cmd->cmnd,
4070 scb->scsi_cmd->cmd_len);
4071 scb->dcdb.scsi_status = 0;
4072 scb->dcdb.reserved2[0] = 0;
4073 scb->dcdb.reserved2[1] = 0;
4074 scb->dcdb.reserved2[2] = 0;
4078 return ((*ha->func.issue) (ha, scb));
4081 /****************************************************************************/
4083 /* Routine Name: ips_chk_status */
4085 /* Routine Description: */
4087 /* Check the status of commands to logical drives */
4088 /* Assumed to be called with the HA lock */
4089 /****************************************************************************/
4091 ips_chkstatus(ips_ha_t * ha, IPS_STATUS * pstatus)
4095 uint8_t basic_status;
4099 METHOD_TRACE("ips_chkstatus", 1);
4101 scb = &ha->scbs[pstatus->fields.command_id];
4102 scb->basic_status = basic_status =
4103 pstatus->fields.basic_status & IPS_BASIC_STATUS_MASK;
4104 scb->extended_status = ext_status = pstatus->fields.extended_status;
4107 sp->residue_len = 0;
4108 sp->scb_addr = (void *) scb;
4110 /* Remove the item from the active queue */
4111 ips_removeq_scb(&ha->scb_activelist, scb);
4114 /* internal commands are handled in do_ipsintr */
4117 DEBUG_VAR(2, "(%s%d) ips_chkstatus: cmd 0x%X id %d (%d %d %d)",
4121 scb->cmd.basic_io.command_id,
4122 scb->bus, scb->target_id, scb->lun);
4124 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd)))
4125 /* passthru - just returns the raw result */
4130 if (((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_SUCCESS) ||
4131 ((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_RECOVERED_ERROR)) {
4133 if (scb->bus == 0) {
4134 if ((basic_status & IPS_GSC_STATUS_MASK) ==
4135 IPS_CMD_RECOVERED_ERROR) {
4137 "(%s%d) Recovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4138 ips_name, ha->host_num,
4139 scb->cmd.basic_io.op_code,
4140 basic_status, ext_status);
4143 switch (scb->scsi_cmd->cmnd[0]) {
4144 case ALLOW_MEDIUM_REMOVAL:
4147 case WRITE_FILEMARKS:
4149 errcode = DID_ERROR;
4155 case TEST_UNIT_READY:
4156 if (!ips_online(ha, scb)) {
4157 errcode = DID_TIME_OUT;
4162 if (ips_online(ha, scb)) {
4163 ips_inquiry(ha, scb);
4165 errcode = DID_TIME_OUT;
4170 ips_reqsen(ha, scb);
4182 if (!ips_online(ha, scb)
4183 || !ips_msense(ha, scb)) {
4184 errcode = DID_ERROR;
4189 if (ips_online(ha, scb))
4192 errcode = DID_TIME_OUT;
4196 case SEND_DIAGNOSTIC:
4197 case REASSIGN_BLOCKS:
4201 errcode = DID_ERROR;
4206 case READ_DEFECT_DATA:
4212 errcode = DID_ERROR;
4215 scb->scsi_cmd->result = errcode << 16;
4216 } else { /* bus == 0 */
4217 /* restrict access to physical drives */
4218 if ((scb->scsi_cmd->cmnd[0] == INQUIRY) &&
4219 ((((char *) scb->scsi_cmd->buffer)[0] & 0x1f) ==
4222 scb->scsi_cmd->result = DID_TIME_OUT << 16;
4225 } else { /* recovered error / success */
4226 if (scb->bus == 0) {
4228 "(%s%d) Unrecovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4229 ips_name, ha->host_num,
4230 scb->cmd.basic_io.op_code, basic_status,
4234 ips_map_status(ha, scb, sp);
4238 /****************************************************************************/
4240 /* Routine Name: ips_online */
4242 /* Routine Description: */
4244 /* Determine if a logical drive is online */
4246 /****************************************************************************/
4248 ips_online(ips_ha_t * ha, ips_scb_t * scb)
4250 METHOD_TRACE("ips_online", 1);
4252 if (scb->target_id >= IPS_MAX_LD)
4255 if ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1) {
4256 memset(ha->logical_drive_info, 0, sizeof (IPS_LD_INFO));
4260 if (ha->logical_drive_info->drive_info[scb->target_id].state !=
4262 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4264 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4266 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4273 /****************************************************************************/
4275 /* Routine Name: ips_inquiry */
4277 /* Routine Description: */
4279 /* Simulate an inquiry command to a logical drive */
4281 /****************************************************************************/
4283 ips_inquiry(ips_ha_t * ha, ips_scb_t * scb)
4285 IPS_SCSI_INQ_DATA inquiry;
4287 METHOD_TRACE("ips_inquiry", 1);
4289 memset(&inquiry, 0, sizeof (IPS_SCSI_INQ_DATA));
4291 inquiry.DeviceType = IPS_SCSI_INQ_TYPE_DASD;
4292 inquiry.DeviceTypeQualifier = IPS_SCSI_INQ_LU_CONNECTED;
4293 inquiry.Version = IPS_SCSI_INQ_REV2;
4294 inquiry.ResponseDataFormat = IPS_SCSI_INQ_RD_REV2;
4295 inquiry.AdditionalLength = 31;
4296 inquiry.Flags[0] = IPS_SCSI_INQ_Address16;
4298 IPS_SCSI_INQ_WBus16 | IPS_SCSI_INQ_Sync | IPS_SCSI_INQ_CmdQue;
4299 strncpy(inquiry.VendorId, "IBM ", 8);
4300 strncpy(inquiry.ProductId, "SERVERAID ", 16);
4301 strncpy(inquiry.ProductRevisionLevel, "1.00", 4);
4303 ips_scmd_buf_write(scb->scsi_cmd, &inquiry, sizeof (inquiry));
4308 /****************************************************************************/
4310 /* Routine Name: ips_rdcap */
4312 /* Routine Description: */
4314 /* Simulate a read capacity command to a logical drive */
4316 /****************************************************************************/
4318 ips_rdcap(ips_ha_t * ha, ips_scb_t * scb)
4320 IPS_SCSI_CAPACITY cap;
4322 METHOD_TRACE("ips_rdcap", 1);
4324 if (scb->scsi_cmd->bufflen < 8)
4328 cpu_to_be32(le32_to_cpu
4329 (ha->logical_drive_info->
4330 drive_info[scb->target_id].sector_count) - 1);
4331 cap.len = cpu_to_be32((uint32_t) IPS_BLKSIZE);
4333 ips_scmd_buf_write(scb->scsi_cmd, &cap, sizeof (cap));
4338 /****************************************************************************/
4340 /* Routine Name: ips_msense */
4342 /* Routine Description: */
4344 /* Simulate a mode sense command to a logical drive */
4346 /****************************************************************************/
4348 ips_msense(ips_ha_t * ha, ips_scb_t * scb)
4353 IPS_SCSI_MODE_PAGE_DATA mdata;
4355 METHOD_TRACE("ips_msense", 1);
4357 if (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) > 0x400000 &&
4358 (ha->enq->ucMiscFlag & 0x8) == 0) {
4359 heads = IPS_NORM_HEADS;
4360 sectors = IPS_NORM_SECTORS;
4362 heads = IPS_COMP_HEADS;
4363 sectors = IPS_COMP_SECTORS;
4367 (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) -
4368 1) / (heads * sectors);
4370 memset(&mdata, 0, sizeof (IPS_SCSI_MODE_PAGE_DATA));
4372 mdata.hdr.BlockDescLength = 8;
4374 switch (scb->scsi_cmd->cmnd[2] & 0x3f) {
4375 case 0x03: /* page 3 */
4376 mdata.pdata.pg3.PageCode = 3;
4377 mdata.pdata.pg3.PageLength = sizeof (IPS_SCSI_MODE_PAGE3);
4378 mdata.hdr.DataLength =
4379 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg3.PageLength;
4380 mdata.pdata.pg3.TracksPerZone = 0;
4381 mdata.pdata.pg3.AltSectorsPerZone = 0;
4382 mdata.pdata.pg3.AltTracksPerZone = 0;
4383 mdata.pdata.pg3.AltTracksPerVolume = 0;
4384 mdata.pdata.pg3.SectorsPerTrack = cpu_to_be16(sectors);
4385 mdata.pdata.pg3.BytesPerSector = cpu_to_be16(IPS_BLKSIZE);
4386 mdata.pdata.pg3.Interleave = cpu_to_be16(1);
4387 mdata.pdata.pg3.TrackSkew = 0;
4388 mdata.pdata.pg3.CylinderSkew = 0;
4389 mdata.pdata.pg3.flags = IPS_SCSI_MP3_SoftSector;
4393 mdata.pdata.pg4.PageCode = 4;
4394 mdata.pdata.pg4.PageLength = sizeof (IPS_SCSI_MODE_PAGE4);
4395 mdata.hdr.DataLength =
4396 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg4.PageLength;
4397 mdata.pdata.pg4.CylindersHigh =
4398 cpu_to_be16((cylinders >> 8) & 0xFFFF);
4399 mdata.pdata.pg4.CylindersLow = (cylinders & 0xFF);
4400 mdata.pdata.pg4.Heads = heads;
4401 mdata.pdata.pg4.WritePrecompHigh = 0;
4402 mdata.pdata.pg4.WritePrecompLow = 0;
4403 mdata.pdata.pg4.ReducedWriteCurrentHigh = 0;
4404 mdata.pdata.pg4.ReducedWriteCurrentLow = 0;
4405 mdata.pdata.pg4.StepRate = cpu_to_be16(1);
4406 mdata.pdata.pg4.LandingZoneHigh = 0;
4407 mdata.pdata.pg4.LandingZoneLow = 0;
4408 mdata.pdata.pg4.flags = 0;
4409 mdata.pdata.pg4.RotationalOffset = 0;
4410 mdata.pdata.pg4.MediumRotationRate = 0;
4413 mdata.pdata.pg8.PageCode = 8;
4414 mdata.pdata.pg8.PageLength = sizeof (IPS_SCSI_MODE_PAGE8);
4415 mdata.hdr.DataLength =
4416 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg8.PageLength;
4417 /* everything else is left set to 0 */
4424 ips_scmd_buf_write(scb->scsi_cmd, &mdata, sizeof (mdata));
4429 /****************************************************************************/
4431 /* Routine Name: ips_reqsen */
4433 /* Routine Description: */
4435 /* Simulate a request sense command to a logical drive */
4437 /****************************************************************************/
4439 ips_reqsen(ips_ha_t * ha, ips_scb_t * scb)
4441 IPS_SCSI_REQSEN reqsen;
4443 METHOD_TRACE("ips_reqsen", 1);
4445 memset(&reqsen, 0, sizeof (IPS_SCSI_REQSEN));
4447 reqsen.ResponseCode =
4448 IPS_SCSI_REQSEN_VALID | IPS_SCSI_REQSEN_CURRENT_ERR;
4449 reqsen.AdditionalLength = 10;
4450 reqsen.AdditionalSenseCode = IPS_SCSI_REQSEN_NO_SENSE;
4451 reqsen.AdditionalSenseCodeQual = IPS_SCSI_REQSEN_NO_SENSE;
4453 ips_scmd_buf_write(scb->scsi_cmd, &reqsen, sizeof (reqsen));
4458 /****************************************************************************/
4460 /* Routine Name: ips_free */
4462 /* Routine Description: */
4464 /* Free any allocated space for this controller */
4466 /****************************************************************************/
4468 ips_free(ips_ha_t * ha)
4471 METHOD_TRACE("ips_free", 1);
4475 pci_free_consistent(ha->pcidev, sizeof(IPS_ENQ),
4476 ha->enq, ha->enq_busaddr);
4486 pci_free_consistent(ha->pcidev,
4487 sizeof (IPS_ADAPTER) +
4488 sizeof (IPS_IO_CMD), ha->adapt,
4489 ha->adapt->hw_status_start);
4493 if (ha->logical_drive_info) {
4494 pci_free_consistent(ha->pcidev,
4495 sizeof (IPS_LD_INFO),
4496 ha->logical_drive_info,
4497 ha->logical_drive_info_dma_addr);
4498 ha->logical_drive_info = NULL;
4511 if (ha->ioctl_data) {
4512 pci_free_consistent(ha->pcidev, ha->ioctl_len,
4513 ha->ioctl_data, ha->ioctl_busaddr);
4514 ha->ioctl_data = NULL;
4515 ha->ioctl_datasize = 0;
4518 ips_deallocatescbs(ha, ha->max_cmds);
4520 /* free memory mapped (if applicable) */
4522 iounmap(ha->ioremap_ptr);
4523 ha->ioremap_ptr = NULL;
4528 release_mem_region(ha->mem_addr, ha->mem_len);
4534 /****************************************************************************/
4536 /* Routine Name: ips_deallocatescbs */
4538 /* Routine Description: */
4540 /* Free the command blocks */
4542 /****************************************************************************/
4544 ips_deallocatescbs(ips_ha_t * ha, int cmds)
4547 pci_free_consistent(ha->pcidev,
4548 IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * cmds,
4549 ha->scbs->sg_list.list,
4550 ha->scbs->sg_busaddr);
4551 pci_free_consistent(ha->pcidev, sizeof (ips_scb_t) * cmds,
4552 ha->scbs, ha->scbs->scb_busaddr);
4558 /****************************************************************************/
4560 /* Routine Name: ips_allocatescbs */
4562 /* Routine Description: */
4564 /* Allocate the command blocks */
4566 /****************************************************************************/
4568 ips_allocatescbs(ips_ha_t * ha)
4573 dma_addr_t command_dma, sg_dma;
4575 METHOD_TRACE("ips_allocatescbs", 1);
4577 /* Allocate memory for the SCBs */
4579 pci_alloc_consistent(ha->pcidev, ha->max_cmds * sizeof (ips_scb_t),
4581 if (ha->scbs == NULL)
4584 pci_alloc_consistent(ha->pcidev,
4585 IPS_SGLIST_SIZE(ha) * IPS_MAX_SG *
4586 ha->max_cmds, &sg_dma);
4587 if (ips_sg.list == NULL) {
4588 pci_free_consistent(ha->pcidev,
4589 ha->max_cmds * sizeof (ips_scb_t), ha->scbs,
4594 memset(ha->scbs, 0, ha->max_cmds * sizeof (ips_scb_t));
4596 for (i = 0; i < ha->max_cmds; i++) {
4597 scb_p = &ha->scbs[i];
4598 scb_p->scb_busaddr = command_dma + sizeof (ips_scb_t) * i;
4599 /* set up S/G list */
4600 if (IPS_USE_ENH_SGLIST(ha)) {
4601 scb_p->sg_list.enh_list =
4602 ips_sg.enh_list + i * IPS_MAX_SG;
4604 sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4606 scb_p->sg_list.std_list =
4607 ips_sg.std_list + i * IPS_MAX_SG;
4609 sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4612 /* add to the free list */
4613 if (i < ha->max_cmds - 1) {
4614 scb_p->q_next = ha->scb_freelist;
4615 ha->scb_freelist = scb_p;
4623 /****************************************************************************/
4625 /* Routine Name: ips_init_scb */
4627 /* Routine Description: */
4629 /* Initialize a CCB to default values */
4631 /****************************************************************************/
4633 ips_init_scb(ips_ha_t * ha, ips_scb_t * scb)
4635 IPS_SG_LIST sg_list;
4636 uint32_t cmd_busaddr, sg_busaddr;
4637 METHOD_TRACE("ips_init_scb", 1);
4642 sg_list.list = scb->sg_list.list;
4643 cmd_busaddr = scb->scb_busaddr;
4644 sg_busaddr = scb->sg_busaddr;
4646 memset(scb, 0, sizeof (ips_scb_t));
4647 memset(ha->dummy, 0, sizeof (IPS_IO_CMD));
4649 /* Initialize dummy command bucket */
4650 ha->dummy->op_code = 0xFF;
4651 ha->dummy->ccsar = cpu_to_le32(ha->adapt->hw_status_start
4652 + sizeof (IPS_ADAPTER));
4653 ha->dummy->command_id = IPS_MAX_CMDS;
4655 /* set bus address of scb */
4656 scb->scb_busaddr = cmd_busaddr;
4657 scb->sg_busaddr = sg_busaddr;
4658 scb->sg_list.list = sg_list.list;
4661 scb->cmd.basic_io.cccr = cpu_to_le32((uint32_t) IPS_BIT_ILE);
4662 scb->cmd.basic_io.ccsar = cpu_to_le32(ha->adapt->hw_status_start
4663 + sizeof (IPS_ADAPTER));
4666 /****************************************************************************/
4668 /* Routine Name: ips_get_scb */
4670 /* Routine Description: */
4672 /* Initialize a CCB to default values */
4674 /* ASSUMED to be callled from within a lock */
4676 /****************************************************************************/
4678 ips_getscb(ips_ha_t * ha)
4682 METHOD_TRACE("ips_getscb", 1);
4684 if ((scb = ha->scb_freelist) == NULL) {
4689 ha->scb_freelist = scb->q_next;
4693 ips_init_scb(ha, scb);
4698 /****************************************************************************/
4700 /* Routine Name: ips_free_scb */
4702 /* Routine Description: */
4704 /* Return an unused CCB back to the free list */
4706 /* ASSUMED to be called from within a lock */
4708 /****************************************************************************/
4710 ips_freescb(ips_ha_t * ha, ips_scb_t * scb)
4713 METHOD_TRACE("ips_freescb", 1);
4714 if (scb->flags & IPS_SCB_MAP_SG)
4715 pci_unmap_sg(ha->pcidev, scb->scsi_cmd->request_buffer,
4716 scb->scsi_cmd->use_sg, IPS_DMA_DIR(scb));
4717 else if (scb->flags & IPS_SCB_MAP_SINGLE)
4718 pci_unmap_single(ha->pcidev, scb->data_busaddr, scb->data_len,
4721 /* check to make sure this is not our "special" scb */
4722 if (IPS_COMMAND_ID(ha, scb) < (ha->max_cmds - 1)) {
4723 scb->q_next = ha->scb_freelist;
4724 ha->scb_freelist = scb;
4728 /****************************************************************************/
4730 /* Routine Name: ips_isinit_copperhead */
4732 /* Routine Description: */
4734 /* Is controller initialized ? */
4736 /****************************************************************************/
4738 ips_isinit_copperhead(ips_ha_t * ha)
4743 METHOD_TRACE("ips_isinit_copperhead", 1);
4745 isr = inb(ha->io_addr + IPS_REG_HISR);
4746 scpr = inb(ha->io_addr + IPS_REG_SCPR);
4748 if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4754 /****************************************************************************/
4756 /* Routine Name: ips_isinit_copperhead_memio */
4758 /* Routine Description: */
4760 /* Is controller initialized ? */
4762 /****************************************************************************/
4764 ips_isinit_copperhead_memio(ips_ha_t * ha)
4769 METHOD_TRACE("ips_is_init_copperhead_memio", 1);
4771 isr = readb(ha->mem_ptr + IPS_REG_HISR);
4772 scpr = readb(ha->mem_ptr + IPS_REG_SCPR);
4774 if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4780 /****************************************************************************/
4782 /* Routine Name: ips_isinit_morpheus */
4784 /* Routine Description: */
4786 /* Is controller initialized ? */
4788 /****************************************************************************/
4790 ips_isinit_morpheus(ips_ha_t * ha)
4795 METHOD_TRACE("ips_is_init_morpheus", 1);
4797 post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
4798 bits = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
4802 else if (bits & 0x3)
4808 /****************************************************************************/
4810 /* Routine Name: ips_enable_int_copperhead */
4812 /* Routine Description: */
4813 /* Turn on interrupts */
4815 /****************************************************************************/
4817 ips_enable_int_copperhead(ips_ha_t * ha)
4819 METHOD_TRACE("ips_enable_int_copperhead", 1);
4821 outb(ha->io_addr + IPS_REG_HISR, IPS_BIT_EI);
4822 inb(ha->io_addr + IPS_REG_HISR); /*Ensure PCI Posting Completes*/
4825 /****************************************************************************/
4827 /* Routine Name: ips_enable_int_copperhead_memio */
4829 /* Routine Description: */
4830 /* Turn on interrupts */
4832 /****************************************************************************/
4834 ips_enable_int_copperhead_memio(ips_ha_t * ha)
4836 METHOD_TRACE("ips_enable_int_copperhead_memio", 1);
4838 writeb(IPS_BIT_EI, ha->mem_ptr + IPS_REG_HISR);
4839 readb(ha->mem_ptr + IPS_REG_HISR); /*Ensure PCI Posting Completes*/
4842 /****************************************************************************/
4844 /* Routine Name: ips_enable_int_morpheus */
4846 /* Routine Description: */
4847 /* Turn on interrupts */
4849 /****************************************************************************/
4851 ips_enable_int_morpheus(ips_ha_t * ha)
4855 METHOD_TRACE("ips_enable_int_morpheus", 1);
4857 Oimr = readl(ha->mem_ptr + IPS_REG_I960_OIMR);
4859 writel(Oimr, ha->mem_ptr + IPS_REG_I960_OIMR);
4860 readl(ha->mem_ptr + IPS_REG_I960_OIMR); /*Ensure PCI Posting Completes*/
4863 /****************************************************************************/
4865 /* Routine Name: ips_init_copperhead */
4867 /* Routine Description: */
4869 /* Initialize a copperhead controller */
4871 /****************************************************************************/
4873 ips_init_copperhead(ips_ha_t * ha)
4877 uint8_t PostByte[IPS_MAX_POST_BYTES];
4878 uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
4881 METHOD_TRACE("ips_init_copperhead", 1);
4883 for (i = 0; i < IPS_MAX_POST_BYTES; i++) {
4884 for (j = 0; j < 45; j++) {
4885 Isr = inb(ha->io_addr + IPS_REG_HISR);
4886 if (Isr & IPS_BIT_GHI)
4889 /* Delay for 1 Second */
4890 MDELAY(IPS_ONE_SEC);
4894 /* error occurred */
4897 PostByte[i] = inb(ha->io_addr + IPS_REG_ISPR);
4898 outb(Isr, ha->io_addr + IPS_REG_HISR);
4901 if (PostByte[0] < IPS_GOOD_POST_STATUS) {
4902 IPS_PRINTK(KERN_WARNING, ha->pcidev,
4903 "reset controller fails (post status %x %x).\n",
4904 PostByte[0], PostByte[1]);
4909 for (i = 0; i < IPS_MAX_CONFIG_BYTES; i++) {
4910 for (j = 0; j < 240; j++) {
4911 Isr = inb(ha->io_addr + IPS_REG_HISR);
4912 if (Isr & IPS_BIT_GHI)
4915 /* Delay for 1 Second */
4916 MDELAY(IPS_ONE_SEC);
4920 /* error occurred */
4923 ConfigByte[i] = inb(ha->io_addr + IPS_REG_ISPR);
4924 outb(Isr, ha->io_addr + IPS_REG_HISR);
4927 for (i = 0; i < 240; i++) {
4928 Cbsp = inb(ha->io_addr + IPS_REG_CBSP);
4930 if ((Cbsp & IPS_BIT_OP) == 0)
4933 /* Delay for 1 Second */
4934 MDELAY(IPS_ONE_SEC);
4942 outl(cpu_to_le32(0x1010), ha->io_addr + IPS_REG_CCCR);
4944 /* Enable busmastering */
4945 outb(IPS_BIT_EBM, ha->io_addr + IPS_REG_SCPR);
4947 if (ha->revision_id == IPS_REVID_TROMBONE64)
4948 /* fix for anaconda64 */
4949 outl(0, ha->io_addr + IPS_REG_NDAE);
4951 /* Enable interrupts */
4952 outb(IPS_BIT_EI, ha->io_addr + IPS_REG_HISR);
4957 /****************************************************************************/
4959 /* Routine Name: ips_init_copperhead_memio */
4961 /* Routine Description: */
4963 /* Initialize a copperhead controller with memory mapped I/O */
4965 /****************************************************************************/
4967 ips_init_copperhead_memio(ips_ha_t * ha)
4971 uint8_t PostByte[IPS_MAX_POST_BYTES];
4972 uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
4975 METHOD_TRACE("ips_init_copperhead_memio", 1);
4977 for (i = 0; i < IPS_MAX_POST_BYTES; i++) {
4978 for (j = 0; j < 45; j++) {
4979 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
4980 if (Isr & IPS_BIT_GHI)
4983 /* Delay for 1 Second */
4984 MDELAY(IPS_ONE_SEC);
4988 /* error occurred */
4991 PostByte[i] = readb(ha->mem_ptr + IPS_REG_ISPR);
4992 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
4995 if (PostByte[0] < IPS_GOOD_POST_STATUS) {
4996 IPS_PRINTK(KERN_WARNING, ha->pcidev,
4997 "reset controller fails (post status %x %x).\n",
4998 PostByte[0], PostByte[1]);
5003 for (i = 0; i < IPS_MAX_CONFIG_BYTES; i++) {
5004 for (j = 0; j < 240; j++) {
5005 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5006 if (Isr & IPS_BIT_GHI)
5009 /* Delay for 1 Second */
5010 MDELAY(IPS_ONE_SEC);
5014 /* error occurred */
5017 ConfigByte[i] = readb(ha->mem_ptr + IPS_REG_ISPR);
5018 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5021 for (i = 0; i < 240; i++) {
5022 Cbsp = readb(ha->mem_ptr + IPS_REG_CBSP);
5024 if ((Cbsp & IPS_BIT_OP) == 0)
5027 /* Delay for 1 Second */
5028 MDELAY(IPS_ONE_SEC);
5032 /* error occurred */
5036 writel(0x1010, ha->mem_ptr + IPS_REG_CCCR);
5038 /* Enable busmastering */
5039 writeb(IPS_BIT_EBM, ha->mem_ptr + IPS_REG_SCPR);
5041 if (ha->revision_id == IPS_REVID_TROMBONE64)
5042 /* fix for anaconda64 */
5043 writel(0, ha->mem_ptr + IPS_REG_NDAE);
5045 /* Enable interrupts */
5046 writeb(IPS_BIT_EI, ha->mem_ptr + IPS_REG_HISR);
5048 /* if we get here then everything went OK */
5052 /****************************************************************************/
5054 /* Routine Name: ips_init_morpheus */
5056 /* Routine Description: */
5058 /* Initialize a morpheus controller */
5060 /****************************************************************************/
5062 ips_init_morpheus(ips_ha_t * ha)
5070 METHOD_TRACE("ips_init_morpheus", 1);
5072 /* Wait up to 45 secs for Post */
5073 for (i = 0; i < 45; i++) {
5074 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5076 if (Isr & IPS_BIT_I960_MSG0I)
5079 /* Delay for 1 Second */
5080 MDELAY(IPS_ONE_SEC);
5084 /* error occurred */
5085 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5086 "timeout waiting for post.\n");
5091 Post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
5093 if (Post == 0x4F00) { /* If Flashing the Battery PIC */
5094 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5095 "Flashing Battery PIC, Please wait ...\n");
5097 /* Clear the interrupt bit */
5098 Isr = (uint32_t) IPS_BIT_I960_MSG0I;
5099 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5101 for (i = 0; i < 120; i++) { /* Wait Up to 2 Min. for Completion */
5102 Post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
5105 /* Delay for 1 Second */
5106 MDELAY(IPS_ONE_SEC);
5110 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5111 "timeout waiting for Battery PIC Flash\n");
5117 /* Clear the interrupt bit */
5118 Isr = (uint32_t) IPS_BIT_I960_MSG0I;
5119 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5121 if (Post < (IPS_GOOD_POST_STATUS << 8)) {
5122 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5123 "reset controller fails (post status %x).\n", Post);
5128 /* Wait up to 240 secs for config bytes */
5129 for (i = 0; i < 240; i++) {
5130 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5132 if (Isr & IPS_BIT_I960_MSG1I)
5135 /* Delay for 1 Second */
5136 MDELAY(IPS_ONE_SEC);
5140 /* error occurred */
5141 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5142 "timeout waiting for config.\n");
5147 Config = readl(ha->mem_ptr + IPS_REG_I960_MSG1);
5149 /* Clear interrupt bit */
5150 Isr = (uint32_t) IPS_BIT_I960_MSG1I;
5151 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5153 /* Turn on the interrupts */
5154 Oimr = readl(ha->mem_ptr + IPS_REG_I960_OIMR);
5156 writel(Oimr, ha->mem_ptr + IPS_REG_I960_OIMR);
5158 /* if we get here then everything went OK */
5160 /* Since we did a RESET, an EraseStripeLock may be needed */
5161 if (Post == 0xEF10) {
5162 if ((Config == 0x000F) || (Config == 0x0009))
5163 ha->requires_esl = 1;
5169 /****************************************************************************/
5171 /* Routine Name: ips_reset_copperhead */
5173 /* Routine Description: */
5175 /* Reset the controller */
5177 /****************************************************************************/
5179 ips_reset_copperhead(ips_ha_t * ha)
5183 METHOD_TRACE("ips_reset_copperhead", 1);
5185 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead: io addr: %x, irq: %d",
5186 ips_name, ha->host_num, ha->io_addr, ha->irq);
5190 while (reset_counter < 2) {
5193 outb(IPS_BIT_RST, ha->io_addr + IPS_REG_SCPR);
5195 /* Delay for 1 Second */
5196 MDELAY(IPS_ONE_SEC);
5198 outb(0, ha->io_addr + IPS_REG_SCPR);
5200 /* Delay for 1 Second */
5201 MDELAY(IPS_ONE_SEC);
5203 if ((*ha->func.init) (ha))
5205 else if (reset_counter >= 2) {
5214 /****************************************************************************/
5216 /* Routine Name: ips_reset_copperhead_memio */
5218 /* Routine Description: */
5220 /* Reset the controller */
5222 /****************************************************************************/
5224 ips_reset_copperhead_memio(ips_ha_t * ha)
5228 METHOD_TRACE("ips_reset_copperhead_memio", 1);
5230 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead_memio: mem addr: %x, irq: %d",
5231 ips_name, ha->host_num, ha->mem_addr, ha->irq);
5235 while (reset_counter < 2) {
5238 writeb(IPS_BIT_RST, ha->mem_ptr + IPS_REG_SCPR);
5240 /* Delay for 1 Second */
5241 MDELAY(IPS_ONE_SEC);
5243 writeb(0, ha->mem_ptr + IPS_REG_SCPR);
5245 /* Delay for 1 Second */
5246 MDELAY(IPS_ONE_SEC);
5248 if ((*ha->func.init) (ha))
5250 else if (reset_counter >= 2) {
5259 /****************************************************************************/
5261 /* Routine Name: ips_reset_morpheus */
5263 /* Routine Description: */
5265 /* Reset the controller */
5267 /****************************************************************************/
5269 ips_reset_morpheus(ips_ha_t * ha)
5274 METHOD_TRACE("ips_reset_morpheus", 1);
5276 DEBUG_VAR(1, "(%s%d) ips_reset_morpheus: mem addr: %x, irq: %d",
5277 ips_name, ha->host_num, ha->mem_addr, ha->irq);
5281 while (reset_counter < 2) {
5284 writel(0x80000000, ha->mem_ptr + IPS_REG_I960_IDR);
5286 /* Delay for 5 Seconds */
5287 MDELAY(5 * IPS_ONE_SEC);
5289 /* Do a PCI config read to wait for adapter */
5290 pci_read_config_byte(ha->pcidev, 4, &junk);
5292 if ((*ha->func.init) (ha))
5294 else if (reset_counter >= 2) {
5303 /****************************************************************************/
5305 /* Routine Name: ips_statinit */
5307 /* Routine Description: */
5309 /* Initialize the status queues on the controller */
5311 /****************************************************************************/
5313 ips_statinit(ips_ha_t * ha)
5315 uint32_t phys_status_start;
5317 METHOD_TRACE("ips_statinit", 1);
5319 ha->adapt->p_status_start = ha->adapt->status;
5320 ha->adapt->p_status_end = ha->adapt->status + IPS_MAX_CMDS;
5321 ha->adapt->p_status_tail = ha->adapt->status;
5323 phys_status_start = ha->adapt->hw_status_start;
5324 outl(cpu_to_le32(phys_status_start), ha->io_addr + IPS_REG_SQSR);
5325 outl(cpu_to_le32(phys_status_start + IPS_STATUS_Q_SIZE),
5326 ha->io_addr + IPS_REG_SQER);
5327 outl(cpu_to_le32(phys_status_start + IPS_STATUS_SIZE),
5328 ha->io_addr + IPS_REG_SQHR);
5329 outl(cpu_to_le32(phys_status_start), ha->io_addr + IPS_REG_SQTR);
5331 ha->adapt->hw_status_tail = phys_status_start;
5334 /****************************************************************************/
5336 /* Routine Name: ips_statinit_memio */
5338 /* Routine Description: */
5340 /* Initialize the status queues on the controller */
5342 /****************************************************************************/
5344 ips_statinit_memio(ips_ha_t * ha)
5346 uint32_t phys_status_start;
5348 METHOD_TRACE("ips_statinit_memio", 1);
5350 ha->adapt->p_status_start = ha->adapt->status;
5351 ha->adapt->p_status_end = ha->adapt->status + IPS_MAX_CMDS;
5352 ha->adapt->p_status_tail = ha->adapt->status;
5354 phys_status_start = ha->adapt->hw_status_start;
5355 writel(phys_status_start, ha->mem_ptr + IPS_REG_SQSR);
5356 writel(phys_status_start + IPS_STATUS_Q_SIZE,
5357 ha->mem_ptr + IPS_REG_SQER);
5358 writel(phys_status_start + IPS_STATUS_SIZE, ha->mem_ptr + IPS_REG_SQHR);
5359 writel(phys_status_start, ha->mem_ptr + IPS_REG_SQTR);
5361 ha->adapt->hw_status_tail = phys_status_start;
5364 /****************************************************************************/
5366 /* Routine Name: ips_statupd_copperhead */
5368 /* Routine Description: */
5370 /* Remove an element from the status queue */
5372 /****************************************************************************/
5374 ips_statupd_copperhead(ips_ha_t * ha)
5376 METHOD_TRACE("ips_statupd_copperhead", 1);
5378 if (ha->adapt->p_status_tail != ha->adapt->p_status_end) {
5379 ha->adapt->p_status_tail++;
5380 ha->adapt->hw_status_tail += sizeof (IPS_STATUS);
5382 ha->adapt->p_status_tail = ha->adapt->p_status_start;
5383 ha->adapt->hw_status_tail = ha->adapt->hw_status_start;
5386 outl(cpu_to_le32(ha->adapt->hw_status_tail),
5387 ha->io_addr + IPS_REG_SQTR);
5389 return (ha->adapt->p_status_tail->value);
5392 /****************************************************************************/
5394 /* Routine Name: ips_statupd_copperhead_memio */
5396 /* Routine Description: */
5398 /* Remove an element from the status queue */
5400 /****************************************************************************/
5402 ips_statupd_copperhead_memio(ips_ha_t * ha)
5404 METHOD_TRACE("ips_statupd_copperhead_memio", 1);
5406 if (ha->adapt->p_status_tail != ha->adapt->p_status_end) {
5407 ha->adapt->p_status_tail++;
5408 ha->adapt->hw_status_tail += sizeof (IPS_STATUS);
5410 ha->adapt->p_status_tail = ha->adapt->p_status_start;
5411 ha->adapt->hw_status_tail = ha->adapt->hw_status_start;
5414 writel(ha->adapt->hw_status_tail, ha->mem_ptr + IPS_REG_SQTR);
5416 return (ha->adapt->p_status_tail->value);
5419 /****************************************************************************/
5421 /* Routine Name: ips_statupd_morpheus */
5423 /* Routine Description: */
5425 /* Remove an element from the status queue */
5427 /****************************************************************************/
5429 ips_statupd_morpheus(ips_ha_t * ha)
5433 METHOD_TRACE("ips_statupd_morpheus", 1);
5435 val = readl(ha->mem_ptr + IPS_REG_I2O_OUTMSGQ);
5440 /****************************************************************************/
5442 /* Routine Name: ips_issue_copperhead */
5444 /* Routine Description: */
5446 /* Send a command down to the controller */
5448 /****************************************************************************/
5450 ips_issue_copperhead(ips_ha_t * ha, ips_scb_t * scb)
5455 METHOD_TRACE("ips_issue_copperhead", 1);
5457 if (scb->scsi_cmd) {
5458 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5462 scb->cmd.basic_io.command_id,
5463 scb->bus, scb->target_id, scb->lun);
5465 DEBUG_VAR(2, KERN_NOTICE "(%s%d) ips_issue: logical cmd id %d",
5466 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5472 le32_to_cpu(inl(ha->io_addr + IPS_REG_CCCR))) & IPS_BIT_SEM) {
5475 if (++TimeOut >= IPS_SEM_TIMEOUT) {
5476 if (!(val & IPS_BIT_START_STOP))
5479 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5480 "ips_issue val [0x%x].\n", val);
5481 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5482 "ips_issue semaphore chk timeout.\n");
5484 return (IPS_FAILURE);
5488 outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_CCSAR);
5489 outw(cpu_to_le32(IPS_BIT_START_CMD), ha->io_addr + IPS_REG_CCCR);
5491 return (IPS_SUCCESS);
5494 /****************************************************************************/
5496 /* Routine Name: ips_issue_copperhead_memio */
5498 /* Routine Description: */
5500 /* Send a command down to the controller */
5502 /****************************************************************************/
5504 ips_issue_copperhead_memio(ips_ha_t * ha, ips_scb_t * scb)
5509 METHOD_TRACE("ips_issue_copperhead_memio", 1);
5511 if (scb->scsi_cmd) {
5512 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5516 scb->cmd.basic_io.command_id,
5517 scb->bus, scb->target_id, scb->lun);
5519 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5520 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5525 while ((val = readl(ha->mem_ptr + IPS_REG_CCCR)) & IPS_BIT_SEM) {
5528 if (++TimeOut >= IPS_SEM_TIMEOUT) {
5529 if (!(val & IPS_BIT_START_STOP))
5532 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5533 "ips_issue val [0x%x].\n", val);
5534 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5535 "ips_issue semaphore chk timeout.\n");
5537 return (IPS_FAILURE);
5541 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_CCSAR);
5542 writel(IPS_BIT_START_CMD, ha->mem_ptr + IPS_REG_CCCR);
5544 return (IPS_SUCCESS);
5547 /****************************************************************************/
5549 /* Routine Name: ips_issue_i2o */
5551 /* Routine Description: */
5553 /* Send a command down to the controller */
5555 /****************************************************************************/
5557 ips_issue_i2o(ips_ha_t * ha, ips_scb_t * scb)
5560 METHOD_TRACE("ips_issue_i2o", 1);
5562 if (scb->scsi_cmd) {
5563 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5567 scb->cmd.basic_io.command_id,
5568 scb->bus, scb->target_id, scb->lun);
5570 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5571 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5574 outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_I2O_INMSGQ);
5576 return (IPS_SUCCESS);
5579 /****************************************************************************/
5581 /* Routine Name: ips_issue_i2o_memio */
5583 /* Routine Description: */
5585 /* Send a command down to the controller */
5587 /****************************************************************************/
5589 ips_issue_i2o_memio(ips_ha_t * ha, ips_scb_t * scb)
5592 METHOD_TRACE("ips_issue_i2o_memio", 1);
5594 if (scb->scsi_cmd) {
5595 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5599 scb->cmd.basic_io.command_id,
5600 scb->bus, scb->target_id, scb->lun);
5602 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5603 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5606 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_I2O_INMSGQ);
5608 return (IPS_SUCCESS);
5611 /****************************************************************************/
5613 /* Routine Name: ips_isintr_copperhead */
5615 /* Routine Description: */
5617 /* Test to see if an interrupt is for us */
5619 /****************************************************************************/
5621 ips_isintr_copperhead(ips_ha_t * ha)
5625 METHOD_TRACE("ips_isintr_copperhead", 2);
5627 Isr = inb(ha->io_addr + IPS_REG_HISR);
5630 /* ?!?! Nothing really there */
5633 if (Isr & IPS_BIT_SCE)
5635 else if (Isr & (IPS_BIT_SQO | IPS_BIT_GHI)) {
5636 /* status queue overflow or GHI */
5637 /* just clear the interrupt */
5638 outb(Isr, ha->io_addr + IPS_REG_HISR);
5644 /****************************************************************************/
5646 /* Routine Name: ips_isintr_copperhead_memio */
5648 /* Routine Description: */
5650 /* Test to see if an interrupt is for us */
5652 /****************************************************************************/
5654 ips_isintr_copperhead_memio(ips_ha_t * ha)
5658 METHOD_TRACE("ips_isintr_memio", 2);
5660 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5663 /* ?!?! Nothing really there */
5666 if (Isr & IPS_BIT_SCE)
5668 else if (Isr & (IPS_BIT_SQO | IPS_BIT_GHI)) {
5669 /* status queue overflow or GHI */
5670 /* just clear the interrupt */
5671 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5677 /****************************************************************************/
5679 /* Routine Name: ips_isintr_morpheus */
5681 /* Routine Description: */
5683 /* Test to see if an interrupt is for us */
5685 /****************************************************************************/
5687 ips_isintr_morpheus(ips_ha_t * ha)
5691 METHOD_TRACE("ips_isintr_morpheus", 2);
5693 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5695 if (Isr & IPS_BIT_I2O_OPQI)
5701 /****************************************************************************/
5703 /* Routine Name: ips_wait */
5705 /* Routine Description: */
5707 /* Wait for a command to complete */
5709 /****************************************************************************/
5711 ips_wait(ips_ha_t * ha, int time, int intr)
5716 METHOD_TRACE("ips_wait", 1);
5721 time *= IPS_ONE_SEC; /* convert seconds */
5723 while ((time > 0) && (!done)) {
5724 if (intr == IPS_INTR_ON) {
5725 if (ha->waitflag == FALSE) {
5730 } else if (intr == IPS_INTR_IORL) {
5731 if (ha->waitflag == FALSE) {
5733 * controller generated an interrupt to
5734 * acknowledge completion of the command
5735 * and ips_intr() has serviced the interrupt.
5743 * NOTE: we already have the io_request_lock so
5744 * even if we get an interrupt it won't get serviced
5745 * until after we finish.
5748 (*ha->func.intr) (ha);
5751 /* This looks like a very evil loop, but it only does this during start-up */
5759 /****************************************************************************/
5761 /* Routine Name: ips_write_driver_status */
5763 /* Routine Description: */
5765 /* Write OS/Driver version to Page 5 of the nvram on the controller */
5767 /****************************************************************************/
5769 ips_write_driver_status(ips_ha_t * ha, int intr)
5771 METHOD_TRACE("ips_write_driver_status", 1);
5773 if (!ips_readwrite_page5(ha, FALSE, intr)) {
5774 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5775 "unable to read NVRAM page 5.\n");
5780 /* check to make sure the page has a valid */
5782 if (le32_to_cpu(ha->nvram->signature) != IPS_NVRAM_P5_SIG) {
5784 "(%s%d) NVRAM page 5 has an invalid signature: %X.",
5785 ips_name, ha->host_num, ha->nvram->signature);
5786 ha->nvram->signature = IPS_NVRAM_P5_SIG;
5790 "(%s%d) Ad Type: %d, Ad Slot: %d, BIOS: %c%c%c%c %c%c%c%c.",
5791 ips_name, ha->host_num, le16_to_cpu(ha->nvram->adapter_type),
5792 ha->nvram->adapter_slot, ha->nvram->bios_high[0],
5793 ha->nvram->bios_high[1], ha->nvram->bios_high[2],
5794 ha->nvram->bios_high[3], ha->nvram->bios_low[0],
5795 ha->nvram->bios_low[1], ha->nvram->bios_low[2],
5796 ha->nvram->bios_low[3]);
5798 ips_get_bios_version(ha, intr);
5800 /* change values (as needed) */
5801 ha->nvram->operating_system = IPS_OS_LINUX;
5802 ha->nvram->adapter_type = ha->ad_type;
5803 strncpy((char *) ha->nvram->driver_high, IPS_VERSION_HIGH, 4);
5804 strncpy((char *) ha->nvram->driver_low, IPS_VERSION_LOW, 4);
5805 strncpy((char *) ha->nvram->bios_high, ha->bios_version, 4);
5806 strncpy((char *) ha->nvram->bios_low, ha->bios_version + 4, 4);
5808 ips_version_check(ha, intr); /* Check BIOS/FW/Driver Versions */
5810 /* now update the page */
5811 if (!ips_readwrite_page5(ha, TRUE, intr)) {
5812 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5813 "unable to write NVRAM page 5.\n");
5818 /* IF NVRAM Page 5 is OK, Use it for Slot Number Info Because Linux Doesn't Do Slots */
5819 ha->slot_num = ha->nvram->adapter_slot;
5824 /****************************************************************************/
5826 /* Routine Name: ips_read_adapter_status */
5828 /* Routine Description: */
5830 /* Do an Inquiry command to the adapter */
5832 /****************************************************************************/
5834 ips_read_adapter_status(ips_ha_t * ha, int intr)
5839 METHOD_TRACE("ips_read_adapter_status", 1);
5841 scb = &ha->scbs[ha->max_cmds - 1];
5843 ips_init_scb(ha, scb);
5845 scb->timeout = ips_cmd_timeout;
5846 scb->cdb[0] = IPS_CMD_ENQUIRY;
5848 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
5849 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5850 scb->cmd.basic_io.sg_count = 0;
5851 scb->cmd.basic_io.lba = 0;
5852 scb->cmd.basic_io.sector_count = 0;
5853 scb->cmd.basic_io.log_drv = 0;
5854 scb->data_len = sizeof (*ha->enq);
5855 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
5859 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5860 || (ret == IPS_SUCCESS_IMM)
5861 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5867 /****************************************************************************/
5869 /* Routine Name: ips_read_subsystem_parameters */
5871 /* Routine Description: */
5873 /* Read subsystem parameters from the adapter */
5875 /****************************************************************************/
5877 ips_read_subsystem_parameters(ips_ha_t * ha, int intr)
5882 METHOD_TRACE("ips_read_subsystem_parameters", 1);
5884 scb = &ha->scbs[ha->max_cmds - 1];
5886 ips_init_scb(ha, scb);
5888 scb->timeout = ips_cmd_timeout;
5889 scb->cdb[0] = IPS_CMD_GET_SUBSYS;
5891 scb->cmd.basic_io.op_code = IPS_CMD_GET_SUBSYS;
5892 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5893 scb->cmd.basic_io.sg_count = 0;
5894 scb->cmd.basic_io.lba = 0;
5895 scb->cmd.basic_io.sector_count = 0;
5896 scb->cmd.basic_io.log_drv = 0;
5897 scb->data_len = sizeof (*ha->subsys);
5898 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
5902 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5903 || (ret == IPS_SUCCESS_IMM)
5904 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5907 memcpy(ha->subsys, ha->ioctl_data, sizeof(*ha->subsys));
5911 /****************************************************************************/
5913 /* Routine Name: ips_read_config */
5915 /* Routine Description: */
5917 /* Read the configuration on the adapter */
5919 /****************************************************************************/
5921 ips_read_config(ips_ha_t * ha, int intr)
5927 METHOD_TRACE("ips_read_config", 1);
5929 /* set defaults for initiator IDs */
5930 for (i = 0; i < 4; i++)
5931 ha->conf->init_id[i] = 7;
5933 scb = &ha->scbs[ha->max_cmds - 1];
5935 ips_init_scb(ha, scb);
5937 scb->timeout = ips_cmd_timeout;
5938 scb->cdb[0] = IPS_CMD_READ_CONF;
5940 scb->cmd.basic_io.op_code = IPS_CMD_READ_CONF;
5941 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5942 scb->data_len = sizeof (*ha->conf);
5943 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
5947 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5948 || (ret == IPS_SUCCESS_IMM)
5949 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
5951 memset(ha->conf, 0, sizeof (IPS_CONF));
5953 /* reset initiator IDs */
5954 for (i = 0; i < 4; i++)
5955 ha->conf->init_id[i] = 7;
5957 /* Allow Completed with Errors, so JCRM can access the Adapter to fix the problems */
5958 if ((scb->basic_status & IPS_GSC_STATUS_MASK) ==
5959 IPS_CMD_CMPLT_WERROR)
5965 memcpy(ha->conf, ha->ioctl_data, sizeof(*ha->conf));
5969 /****************************************************************************/
5971 /* Routine Name: ips_readwrite_page5 */
5973 /* Routine Description: */
5975 /* Read nvram page 5 from the adapter */
5977 /****************************************************************************/
5979 ips_readwrite_page5(ips_ha_t * ha, int write, int intr)
5984 METHOD_TRACE("ips_readwrite_page5", 1);
5986 scb = &ha->scbs[ha->max_cmds - 1];
5988 ips_init_scb(ha, scb);
5990 scb->timeout = ips_cmd_timeout;
5991 scb->cdb[0] = IPS_CMD_RW_NVRAM_PAGE;
5993 scb->cmd.nvram.op_code = IPS_CMD_RW_NVRAM_PAGE;
5994 scb->cmd.nvram.command_id = IPS_COMMAND_ID(ha, scb);
5995 scb->cmd.nvram.page = 5;
5996 scb->cmd.nvram.write = write;
5997 scb->cmd.nvram.reserved = 0;
5998 scb->cmd.nvram.reserved2 = 0;
5999 scb->data_len = sizeof (*ha->nvram);
6000 scb->cmd.nvram.buffer_addr = ha->ioctl_busaddr;
6002 memcpy(ha->ioctl_data, ha->nvram, sizeof(*ha->nvram));
6004 /* issue the command */
6006 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6007 || (ret == IPS_SUCCESS_IMM)
6008 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
6010 memset(ha->nvram, 0, sizeof (IPS_NVRAM_P5));
6015 memcpy(ha->nvram, ha->ioctl_data, sizeof(*ha->nvram));
6019 /****************************************************************************/
6021 /* Routine Name: ips_clear_adapter */
6023 /* Routine Description: */
6025 /* Clear the stripe lock tables */
6027 /****************************************************************************/
6029 ips_clear_adapter(ips_ha_t * ha, int intr)
6034 METHOD_TRACE("ips_clear_adapter", 1);
6036 scb = &ha->scbs[ha->max_cmds - 1];
6038 ips_init_scb(ha, scb);
6040 scb->timeout = ips_reset_timeout;
6041 scb->cdb[0] = IPS_CMD_CONFIG_SYNC;
6043 scb->cmd.config_sync.op_code = IPS_CMD_CONFIG_SYNC;
6044 scb->cmd.config_sync.command_id = IPS_COMMAND_ID(ha, scb);
6045 scb->cmd.config_sync.channel = 0;
6046 scb->cmd.config_sync.source_target = IPS_POCL;
6047 scb->cmd.config_sync.reserved = 0;
6048 scb->cmd.config_sync.reserved2 = 0;
6049 scb->cmd.config_sync.reserved3 = 0;
6053 ips_send_wait(ha, scb, ips_reset_timeout, intr)) == IPS_FAILURE)
6054 || (ret == IPS_SUCCESS_IMM)
6055 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6058 /* send unlock stripe command */
6059 ips_init_scb(ha, scb);
6061 scb->cdb[0] = IPS_CMD_ERROR_TABLE;
6062 scb->timeout = ips_reset_timeout;
6064 scb->cmd.unlock_stripe.op_code = IPS_CMD_ERROR_TABLE;
6065 scb->cmd.unlock_stripe.command_id = IPS_COMMAND_ID(ha, scb);
6066 scb->cmd.unlock_stripe.log_drv = 0;
6067 scb->cmd.unlock_stripe.control = IPS_CSL;
6068 scb->cmd.unlock_stripe.reserved = 0;
6069 scb->cmd.unlock_stripe.reserved2 = 0;
6070 scb->cmd.unlock_stripe.reserved3 = 0;
6074 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6075 || (ret == IPS_SUCCESS_IMM)
6076 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6082 /****************************************************************************/
6084 /* Routine Name: ips_ffdc_reset */
6086 /* Routine Description: */
6088 /* FFDC: write reset info */
6090 /****************************************************************************/
6092 ips_ffdc_reset(ips_ha_t * ha, int intr)
6096 METHOD_TRACE("ips_ffdc_reset", 1);
6098 scb = &ha->scbs[ha->max_cmds - 1];
6100 ips_init_scb(ha, scb);
6102 scb->timeout = ips_cmd_timeout;
6103 scb->cdb[0] = IPS_CMD_FFDC;
6104 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
6105 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
6106 scb->cmd.ffdc.reset_count = ha->reset_count;
6107 scb->cmd.ffdc.reset_type = 0x80;
6109 /* convert time to what the card wants */
6110 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
6113 ips_send_wait(ha, scb, ips_cmd_timeout, intr);
6116 /****************************************************************************/
6118 /* Routine Name: ips_ffdc_time */
6120 /* Routine Description: */
6122 /* FFDC: write time info */
6124 /****************************************************************************/
6126 ips_ffdc_time(ips_ha_t * ha)
6130 METHOD_TRACE("ips_ffdc_time", 1);
6132 DEBUG_VAR(1, "(%s%d) Sending time update.", ips_name, ha->host_num);
6134 scb = &ha->scbs[ha->max_cmds - 1];
6136 ips_init_scb(ha, scb);
6138 scb->timeout = ips_cmd_timeout;
6139 scb->cdb[0] = IPS_CMD_FFDC;
6140 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
6141 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
6142 scb->cmd.ffdc.reset_count = 0;
6143 scb->cmd.ffdc.reset_type = 0;
6145 /* convert time to what the card wants */
6146 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
6149 ips_send_wait(ha, scb, ips_cmd_timeout, IPS_FFDC);
6152 /****************************************************************************/
6154 /* Routine Name: ips_fix_ffdc_time */
6156 /* Routine Description: */
6157 /* Adjust time_t to what the card wants */
6159 /****************************************************************************/
6161 ips_fix_ffdc_time(ips_ha_t * ha, ips_scb_t * scb, time_t current_time)
6168 int year_lengths[2] = { IPS_DAYS_NORMAL_YEAR, IPS_DAYS_LEAP_YEAR };
6169 int month_lengths[12][2] = { {31, 31},
6183 METHOD_TRACE("ips_fix_ffdc_time", 1);
6185 days = current_time / IPS_SECS_DAY;
6186 rem = current_time % IPS_SECS_DAY;
6188 scb->cmd.ffdc.hour = (rem / IPS_SECS_HOUR);
6189 rem = rem % IPS_SECS_HOUR;
6190 scb->cmd.ffdc.minute = (rem / IPS_SECS_MIN);
6191 scb->cmd.ffdc.second = (rem % IPS_SECS_MIN);
6193 year = IPS_EPOCH_YEAR;
6194 while (days < 0 || days >= year_lengths[yleap = IPS_IS_LEAP_YEAR(year)]) {
6197 newy = year + (days / IPS_DAYS_NORMAL_YEAR);
6200 days -= (newy - year) * IPS_DAYS_NORMAL_YEAR +
6201 IPS_NUM_LEAP_YEARS_THROUGH(newy - 1) -
6202 IPS_NUM_LEAP_YEARS_THROUGH(year - 1);
6206 scb->cmd.ffdc.yearH = year / 100;
6207 scb->cmd.ffdc.yearL = year % 100;
6209 for (i = 0; days >= month_lengths[i][yleap]; ++i)
6210 days -= month_lengths[i][yleap];
6212 scb->cmd.ffdc.month = i + 1;
6213 scb->cmd.ffdc.day = days + 1;
6216 /****************************************************************************
6217 * BIOS Flash Routines *
6218 ****************************************************************************/
6220 /****************************************************************************/
6222 /* Routine Name: ips_erase_bios */
6224 /* Routine Description: */
6225 /* Erase the BIOS on the adapter */
6227 /****************************************************************************/
6229 ips_erase_bios(ips_ha_t * ha)
6234 METHOD_TRACE("ips_erase_bios", 1);
6238 /* Clear the status register */
6239 outl(0, ha->io_addr + IPS_REG_FLAP);
6240 if (ha->revision_id == IPS_REVID_TROMBONE64)
6241 udelay(25); /* 25 us */
6243 outb(0x50, ha->io_addr + IPS_REG_FLDP);
6244 if (ha->revision_id == IPS_REVID_TROMBONE64)
6245 udelay(25); /* 25 us */
6248 outb(0x20, ha->io_addr + IPS_REG_FLDP);
6249 if (ha->revision_id == IPS_REVID_TROMBONE64)
6250 udelay(25); /* 25 us */
6253 outb(0xD0, ha->io_addr + IPS_REG_FLDP);
6254 if (ha->revision_id == IPS_REVID_TROMBONE64)
6255 udelay(25); /* 25 us */
6258 outb(0x70, ha->io_addr + IPS_REG_FLDP);
6259 if (ha->revision_id == IPS_REVID_TROMBONE64)
6260 udelay(25); /* 25 us */
6262 timeout = 80000; /* 80 seconds */
6264 while (timeout > 0) {
6265 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6266 outl(0, ha->io_addr + IPS_REG_FLAP);
6267 udelay(25); /* 25 us */
6270 status = inb(ha->io_addr + IPS_REG_FLDP);
6279 /* check for timeout */
6283 /* try to suspend the erase */
6284 outb(0xB0, ha->io_addr + IPS_REG_FLDP);
6285 if (ha->revision_id == IPS_REVID_TROMBONE64)
6286 udelay(25); /* 25 us */
6288 /* wait for 10 seconds */
6290 while (timeout > 0) {
6291 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6292 outl(0, ha->io_addr + IPS_REG_FLAP);
6293 udelay(25); /* 25 us */
6296 status = inb(ha->io_addr + IPS_REG_FLDP);
6308 /* check for valid VPP */
6313 /* check for succesful flash */
6315 /* sequence error */
6318 /* Otherwise, we were successful */
6320 outb(0x50, ha->io_addr + IPS_REG_FLDP);
6321 if (ha->revision_id == IPS_REVID_TROMBONE64)
6322 udelay(25); /* 25 us */
6325 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6326 if (ha->revision_id == IPS_REVID_TROMBONE64)
6327 udelay(25); /* 25 us */
6332 /****************************************************************************/
6334 /* Routine Name: ips_erase_bios_memio */
6336 /* Routine Description: */
6337 /* Erase the BIOS on the adapter */
6339 /****************************************************************************/
6341 ips_erase_bios_memio(ips_ha_t * ha)
6346 METHOD_TRACE("ips_erase_bios_memio", 1);
6350 /* Clear the status register */
6351 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6352 if (ha->revision_id == IPS_REVID_TROMBONE64)
6353 udelay(25); /* 25 us */
6355 writeb(0x50, ha->mem_ptr + IPS_REG_FLDP);
6356 if (ha->revision_id == IPS_REVID_TROMBONE64)
6357 udelay(25); /* 25 us */
6360 writeb(0x20, ha->mem_ptr + IPS_REG_FLDP);
6361 if (ha->revision_id == IPS_REVID_TROMBONE64)
6362 udelay(25); /* 25 us */
6365 writeb(0xD0, ha->mem_ptr + IPS_REG_FLDP);
6366 if (ha->revision_id == IPS_REVID_TROMBONE64)
6367 udelay(25); /* 25 us */
6370 writeb(0x70, ha->mem_ptr + IPS_REG_FLDP);
6371 if (ha->revision_id == IPS_REVID_TROMBONE64)
6372 udelay(25); /* 25 us */
6374 timeout = 80000; /* 80 seconds */
6376 while (timeout > 0) {
6377 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6378 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6379 udelay(25); /* 25 us */
6382 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6391 /* check for timeout */
6395 /* try to suspend the erase */
6396 writeb(0xB0, ha->mem_ptr + IPS_REG_FLDP);
6397 if (ha->revision_id == IPS_REVID_TROMBONE64)
6398 udelay(25); /* 25 us */
6400 /* wait for 10 seconds */
6402 while (timeout > 0) {
6403 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6404 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6405 udelay(25); /* 25 us */
6408 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6420 /* check for valid VPP */
6425 /* check for succesful flash */
6427 /* sequence error */
6430 /* Otherwise, we were successful */
6432 writeb(0x50, ha->mem_ptr + IPS_REG_FLDP);
6433 if (ha->revision_id == IPS_REVID_TROMBONE64)
6434 udelay(25); /* 25 us */
6437 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6438 if (ha->revision_id == IPS_REVID_TROMBONE64)
6439 udelay(25); /* 25 us */
6444 /****************************************************************************/
6446 /* Routine Name: ips_program_bios */
6448 /* Routine Description: */
6449 /* Program the BIOS on the adapter */
6451 /****************************************************************************/
6453 ips_program_bios(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6460 METHOD_TRACE("ips_program_bios", 1);
6464 for (i = 0; i < buffersize; i++) {
6466 outl(cpu_to_le32(i + offset), ha->io_addr + IPS_REG_FLAP);
6467 if (ha->revision_id == IPS_REVID_TROMBONE64)
6468 udelay(25); /* 25 us */
6470 outb(0x40, ha->io_addr + IPS_REG_FLDP);
6471 if (ha->revision_id == IPS_REVID_TROMBONE64)
6472 udelay(25); /* 25 us */
6474 outb(buffer[i], ha->io_addr + IPS_REG_FLDP);
6475 if (ha->revision_id == IPS_REVID_TROMBONE64)
6476 udelay(25); /* 25 us */
6478 /* wait up to one second */
6480 while (timeout > 0) {
6481 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6482 outl(0, ha->io_addr + IPS_REG_FLAP);
6483 udelay(25); /* 25 us */
6486 status = inb(ha->io_addr + IPS_REG_FLDP);
6497 outl(0, ha->io_addr + IPS_REG_FLAP);
6498 if (ha->revision_id == IPS_REVID_TROMBONE64)
6499 udelay(25); /* 25 us */
6501 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6502 if (ha->revision_id == IPS_REVID_TROMBONE64)
6503 udelay(25); /* 25 us */
6508 /* check the status */
6509 if (status & 0x18) {
6510 /* programming error */
6511 outl(0, ha->io_addr + IPS_REG_FLAP);
6512 if (ha->revision_id == IPS_REVID_TROMBONE64)
6513 udelay(25); /* 25 us */
6515 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6516 if (ha->revision_id == IPS_REVID_TROMBONE64)
6517 udelay(25); /* 25 us */
6523 /* Enable reading */
6524 outl(0, ha->io_addr + IPS_REG_FLAP);
6525 if (ha->revision_id == IPS_REVID_TROMBONE64)
6526 udelay(25); /* 25 us */
6528 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6529 if (ha->revision_id == IPS_REVID_TROMBONE64)
6530 udelay(25); /* 25 us */
6535 /****************************************************************************/
6537 /* Routine Name: ips_program_bios_memio */
6539 /* Routine Description: */
6540 /* Program the BIOS on the adapter */
6542 /****************************************************************************/
6544 ips_program_bios_memio(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6551 METHOD_TRACE("ips_program_bios_memio", 1);
6555 for (i = 0; i < buffersize; i++) {
6557 writel(i + offset, ha->mem_ptr + IPS_REG_FLAP);
6558 if (ha->revision_id == IPS_REVID_TROMBONE64)
6559 udelay(25); /* 25 us */
6561 writeb(0x40, ha->mem_ptr + IPS_REG_FLDP);
6562 if (ha->revision_id == IPS_REVID_TROMBONE64)
6563 udelay(25); /* 25 us */
6565 writeb(buffer[i], ha->mem_ptr + IPS_REG_FLDP);
6566 if (ha->revision_id == IPS_REVID_TROMBONE64)
6567 udelay(25); /* 25 us */
6569 /* wait up to one second */
6571 while (timeout > 0) {
6572 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6573 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6574 udelay(25); /* 25 us */
6577 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6588 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6589 if (ha->revision_id == IPS_REVID_TROMBONE64)
6590 udelay(25); /* 25 us */
6592 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6593 if (ha->revision_id == IPS_REVID_TROMBONE64)
6594 udelay(25); /* 25 us */
6599 /* check the status */
6600 if (status & 0x18) {
6601 /* programming error */
6602 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6603 if (ha->revision_id == IPS_REVID_TROMBONE64)
6604 udelay(25); /* 25 us */
6606 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6607 if (ha->revision_id == IPS_REVID_TROMBONE64)
6608 udelay(25); /* 25 us */
6614 /* Enable reading */
6615 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6616 if (ha->revision_id == IPS_REVID_TROMBONE64)
6617 udelay(25); /* 25 us */
6619 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6620 if (ha->revision_id == IPS_REVID_TROMBONE64)
6621 udelay(25); /* 25 us */
6626 /****************************************************************************/
6628 /* Routine Name: ips_verify_bios */
6630 /* Routine Description: */
6631 /* Verify the BIOS on the adapter */
6633 /****************************************************************************/
6635 ips_verify_bios(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6641 METHOD_TRACE("ips_verify_bios", 1);
6644 outl(0, ha->io_addr + IPS_REG_FLAP);
6645 if (ha->revision_id == IPS_REVID_TROMBONE64)
6646 udelay(25); /* 25 us */
6648 if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
6651 outl(cpu_to_le32(1), ha->io_addr + IPS_REG_FLAP);
6652 if (ha->revision_id == IPS_REVID_TROMBONE64)
6653 udelay(25); /* 25 us */
6654 if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
6658 for (i = 2; i < buffersize; i++) {
6660 outl(cpu_to_le32(i + offset), ha->io_addr + IPS_REG_FLAP);
6661 if (ha->revision_id == IPS_REVID_TROMBONE64)
6662 udelay(25); /* 25 us */
6664 checksum = (uint8_t) checksum + inb(ha->io_addr + IPS_REG_FLDP);
6675 /****************************************************************************/
6677 /* Routine Name: ips_verify_bios_memio */
6679 /* Routine Description: */
6680 /* Verify the BIOS on the adapter */
6682 /****************************************************************************/
6684 ips_verify_bios_memio(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6690 METHOD_TRACE("ips_verify_bios_memio", 1);
6693 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6694 if (ha->revision_id == IPS_REVID_TROMBONE64)
6695 udelay(25); /* 25 us */
6697 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
6700 writel(1, ha->mem_ptr + IPS_REG_FLAP);
6701 if (ha->revision_id == IPS_REVID_TROMBONE64)
6702 udelay(25); /* 25 us */
6703 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
6707 for (i = 2; i < buffersize; i++) {
6709 writel(i + offset, ha->mem_ptr + IPS_REG_FLAP);
6710 if (ha->revision_id == IPS_REVID_TROMBONE64)
6711 udelay(25); /* 25 us */
6714 (uint8_t) checksum + readb(ha->mem_ptr + IPS_REG_FLDP);
6725 /*---------------------------------------------------------------------------*/
6726 /* Routine Name: ips_version_check */
6729 /* Assumes that ips_read_adapter_status() is called first filling in */
6730 /* the data for SubSystem Parameters. */
6731 /* Called from ips_write_driver_status() so it also assumes NVRAM Page 5 */
6732 /* Data is available. */
6734 /*---------------------------------------------------------------------------*/
6736 ips_version_check(ips_ha_t * ha, int intr)
6738 IPS_VERSION_DATA *VersionInfo;
6739 uint8_t FirmwareVersion[IPS_COMPAT_ID_LENGTH + 1];
6740 uint8_t BiosVersion[IPS_COMPAT_ID_LENGTH + 1];
6743 char BiosString[10];
6744 char FirmwareString[10];
6746 METHOD_TRACE("ips_version_check", 1);
6748 VersionInfo = ( IPS_VERSION_DATA * ) ha->ioctl_data;
6750 memset(FirmwareVersion, 0, IPS_COMPAT_ID_LENGTH + 1);
6751 memset(BiosVersion, 0, IPS_COMPAT_ID_LENGTH + 1);
6753 /* Get the Compatible BIOS Version from NVRAM Page 5 */
6754 memcpy(BiosVersion, ha->nvram->BiosCompatibilityID,
6755 IPS_COMPAT_ID_LENGTH);
6758 if (ha->subsys->param[4] & IPS_GET_VERSION_SUPPORT) { /* If Versioning is Supported */
6759 /* Get the Version Info with a Get Version Command */
6760 memset( VersionInfo, 0, sizeof (IPS_VERSION_DATA));
6761 rc = ips_get_version_info(ha, ha->ioctl_busaddr, intr);
6762 if (rc == IPS_SUCCESS)
6763 memcpy(FirmwareVersion, VersionInfo->compatibilityId,
6764 IPS_COMPAT_ID_LENGTH);
6767 if (rc != IPS_SUCCESS) { /* If Data Not Obtainable from a GetVersion Command */
6768 /* Get the Firmware Version from Enquiry Data */
6769 memcpy(FirmwareVersion, ha->enq->CodeBlkVersion,
6770 IPS_COMPAT_ID_LENGTH);
6773 /* printk(KERN_WARNING "Adapter's BIOS Version = %s\n", BiosVersion); */
6774 /* printk(KERN_WARNING "BIOS Compatible Version = %s\n", IPS_COMPAT_BIOS); */
6775 /* printk(KERN_WARNING "Adapter's Firmware Version = %s\n", FirmwareVersion); */
6776 /* printk(KERN_WARNING "Firmware Compatible Version = %s \n", Compatable[ ha->nvram->adapter_type ]); */
6781 (FirmwareVersion, Compatable[ha->nvram->adapter_type],
6782 IPS_COMPAT_ID_LENGTH) != 0)
6785 if (strncmp(BiosVersion, IPS_COMPAT_BIOS, IPS_COMPAT_ID_LENGTH) != 0)
6788 ha->nvram->versioning = 1; /* Indicate the Driver Supports Versioning */
6791 ha->nvram->version_mismatch = 1;
6792 if (ips_cd_boot == 0) {
6793 strncpy(&BiosString[0], ha->nvram->bios_high, 4);
6794 strncpy(&BiosString[4], ha->nvram->bios_low, 4);
6797 strncpy(&FirmwareString[0], ha->enq->CodeBlkVersion, 8);
6798 FirmwareString[8] = 0;
6800 IPS_PRINTK(KERN_WARNING, ha->pcidev,
6801 "Warning ! ! ! ServeRAID Version Mismatch\n");
6802 IPS_PRINTK(KERN_WARNING, ha->pcidev,
6803 "Bios = %s, Firmware = %s, Device Driver = %s%s\n",
6804 BiosString, FirmwareString, IPS_VERSION_HIGH,
6806 IPS_PRINTK(KERN_WARNING, ha->pcidev,
6807 "These levels should match to avoid possible compatibility problems.\n");
6810 ha->nvram->version_mismatch = 0;
6816 /*---------------------------------------------------------------------------*/
6817 /* Routine Name: ips_get_version_info */
6819 /* Routine Description: */
6820 /* Issue an internal GETVERSION Command */
6823 /* 0 if Successful, else non-zero */
6824 /*---------------------------------------------------------------------------*/
6826 ips_get_version_info(ips_ha_t * ha, dma_addr_t Buffer, int intr)
6831 METHOD_TRACE("ips_get_version_info", 1);
6833 scb = &ha->scbs[ha->max_cmds - 1];
6835 ips_init_scb(ha, scb);
6837 scb->timeout = ips_cmd_timeout;
6838 scb->cdb[0] = IPS_CMD_GET_VERSION_INFO;
6839 scb->cmd.version_info.op_code = IPS_CMD_GET_VERSION_INFO;
6840 scb->cmd.version_info.command_id = IPS_COMMAND_ID(ha, scb);
6841 scb->cmd.version_info.reserved = 0;
6842 scb->cmd.version_info.count = sizeof (IPS_VERSION_DATA);
6843 scb->cmd.version_info.reserved2 = 0;
6844 scb->data_len = sizeof (IPS_VERSION_DATA);
6845 scb->data_busaddr = Buffer;
6846 scb->cmd.version_info.buffer_addr = Buffer;
6850 rc = ips_send_wait(ha, scb, ips_cmd_timeout, intr);
6854 /****************************************************************************/
6856 /* Routine Name: ips_abort_init */
6858 /* Routine Description: */
6859 /* cleanup routine for a failed adapter initialization */
6860 /****************************************************************************/
6862 ips_abort_init(ips_ha_t * ha, int index)
6866 ips_ha[index] = NULL;
6867 ips_sh[index] = NULL;
6871 /****************************************************************************/
6873 /* Routine Name: ips_shift_controllers */
6875 /* Routine Description: */
6876 /* helper function for ordering adapters */
6877 /****************************************************************************/
6879 ips_shift_controllers(int lowindex, int highindex)
6881 ips_ha_t *ha_sav = ips_ha[highindex];
6882 struct Scsi_Host *sh_sav = ips_sh[highindex];
6885 for (i = highindex; i > lowindex; i--) {
6886 ips_ha[i] = ips_ha[i - 1];
6887 ips_sh[i] = ips_sh[i - 1];
6888 ips_ha[i]->host_num = i;
6890 ha_sav->host_num = lowindex;
6891 ips_ha[lowindex] = ha_sav;
6892 ips_sh[lowindex] = sh_sav;
6895 /****************************************************************************/
6897 /* Routine Name: ips_order_controllers */
6899 /* Routine Description: */
6900 /* place controllers is the "proper" boot order */
6901 /****************************************************************************/
6903 ips_order_controllers(void)
6905 int i, j, tmp, position = 0;
6906 IPS_NVRAM_P5 *nvram;
6909 nvram = ips_ha[0]->nvram;
6911 if (nvram->adapter_order[0]) {
6912 for (i = 1; i <= nvram->adapter_order[0]; i++) {
6913 for (j = position; j < ips_num_controllers; j++) {
6914 switch (ips_ha[j]->ad_type) {
6915 case IPS_ADTYPE_SERVERAID6M:
6916 case IPS_ADTYPE_SERVERAID7M:
6917 if (nvram->adapter_order[i] == 'M') {
6918 ips_shift_controllers(position,
6923 case IPS_ADTYPE_SERVERAID4L:
6924 case IPS_ADTYPE_SERVERAID4M:
6925 case IPS_ADTYPE_SERVERAID4MX:
6926 case IPS_ADTYPE_SERVERAID4LX:
6927 if (nvram->adapter_order[i] == 'N') {
6928 ips_shift_controllers(position,
6933 case IPS_ADTYPE_SERVERAID6I:
6934 case IPS_ADTYPE_SERVERAID5I2:
6935 case IPS_ADTYPE_SERVERAID5I1:
6936 case IPS_ADTYPE_SERVERAID7k:
6937 if (nvram->adapter_order[i] == 'S') {
6938 ips_shift_controllers(position,
6943 case IPS_ADTYPE_SERVERAID:
6944 case IPS_ADTYPE_SERVERAID2:
6945 case IPS_ADTYPE_NAVAJO:
6946 case IPS_ADTYPE_KIOWA:
6947 case IPS_ADTYPE_SERVERAID3L:
6948 case IPS_ADTYPE_SERVERAID3:
6949 case IPS_ADTYPE_SERVERAID4H:
6950 if (nvram->adapter_order[i] == 'A') {
6951 ips_shift_controllers(position,
6961 /* if adapter_order[0], then ordering is complete */
6964 /* old bios, use older ordering */
6966 for (i = position; i < ips_num_controllers; i++) {
6967 if (ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID5I2 ||
6968 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID5I1) {
6969 ips_shift_controllers(position, i);
6974 /* if there were no 5I cards, then don't do any extra ordering */
6977 for (i = position; i < ips_num_controllers; i++) {
6978 if (ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4L ||
6979 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4M ||
6980 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4LX ||
6981 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4MX) {
6982 ips_shift_controllers(position, i);
6990 /****************************************************************************/
6992 /* Routine Name: ips_register_scsi */
6994 /* Routine Description: */
6995 /* perform any registration and setup with the scsi layer */
6996 /****************************************************************************/
6998 ips_register_scsi(int index)
7000 struct Scsi_Host *sh;
7001 ips_ha_t *ha, *oldha = ips_ha[index];
7002 sh = scsi_host_alloc(&ips_driver_template, sizeof (ips_ha_t));
7004 IPS_PRINTK(KERN_WARNING, oldha->pcidev,
7005 "Unable to register controller with SCSI subsystem\n");
7009 memcpy(ha, oldha, sizeof (ips_ha_t));
7010 free_irq(oldha->irq, oldha);
7011 /* Install the interrupt handler with the new ha */
7012 if (request_irq(ha->irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
7013 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7014 "Unable to install interrupt handler\n");
7022 IPS_SCSI_SET_DEVICE(sh, ha);
7024 /* Store away needed values for later use */
7025 sh->io_port = ha->io_addr;
7026 sh->n_io_port = ha->io_addr ? 255 : 0;
7027 sh->unique_id = (ha->io_addr) ? ha->io_addr : ha->mem_addr;
7029 sh->sg_tablesize = sh->hostt->sg_tablesize;
7030 sh->can_queue = sh->hostt->can_queue;
7031 sh->cmd_per_lun = sh->hostt->cmd_per_lun;
7032 sh->unchecked_isa_dma = sh->hostt->unchecked_isa_dma;
7033 sh->use_clustering = sh->hostt->use_clustering;
7035 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,7)
7036 sh->max_sectors = 128;
7039 sh->max_id = ha->ntargets;
7040 sh->max_lun = ha->nlun;
7041 sh->max_channel = ha->nbus - 1;
7042 sh->can_queue = ha->max_cmds - 1;
7044 IPS_ADD_HOST(sh, NULL);
7048 /*---------------------------------------------------------------------------*/
7049 /* Routine Name: ips_remove_device */
7051 /* Routine Description: */
7052 /* Remove one Adapter ( Hot Plugging ) */
7053 /*---------------------------------------------------------------------------*/
7054 static void __devexit
7055 ips_remove_device(struct pci_dev *pci_dev)
7058 struct Scsi_Host *sh;
7061 for (i = 0; i < IPS_MAX_ADAPTERS; i++) {
7064 if ((pci_dev->bus->number == ha->pcidev->bus->number) &&
7065 (pci_dev->devfn == ha->pcidev->devfn)) {
7073 /****************************************************************************/
7075 /* Routine Name: ips_module_init */
7077 /* Routine Description: */
7078 /* function called on module load */
7079 /****************************************************************************/
7081 ips_module_init(void)
7083 if (pci_module_init(&ips_pci_driver) < 0)
7085 ips_driver_template.module = THIS_MODULE;
7086 ips_order_controllers();
7087 if (IPS_REGISTER_HOSTS(&ips_driver_template)) {
7088 pci_unregister_driver(&ips_pci_driver);
7091 register_reboot_notifier(&ips_notifier);
7095 /****************************************************************************/
7097 /* Routine Name: ips_module_exit */
7099 /* Routine Description: */
7100 /* function called on module unload */
7101 /****************************************************************************/
7103 ips_module_exit(void)
7105 IPS_UNREGISTER_HOSTS(&ips_driver_template);
7106 pci_unregister_driver(&ips_pci_driver);
7107 unregister_reboot_notifier(&ips_notifier);
7110 module_init(ips_module_init);
7111 module_exit(ips_module_exit);
7113 /*---------------------------------------------------------------------------*/
7114 /* Routine Name: ips_insert_device */
7116 /* Routine Description: */
7117 /* Add One Adapter ( Hot Plug ) */
7120 /* 0 if Successful, else non-zero */
7121 /*---------------------------------------------------------------------------*/
7122 static int __devinit
7123 ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent)
7128 METHOD_TRACE("ips_insert_device", 1);
7129 if (pci_enable_device(pci_dev))
7132 rc = ips_init_phase1(pci_dev, &index);
7134 rc = ips_init_phase2(index);
7137 if (ips_register_scsi(index)) {
7138 ips_free(ips_ha[index]);
7143 ips_num_controllers++;
7145 ips_next_controller = ips_num_controllers;
7149 /*---------------------------------------------------------------------------*/
7150 /* Routine Name: ips_init_phase1 */
7152 /* Routine Description: */
7153 /* Adapter Initialization */
7156 /* 0 if Successful, else non-zero */
7157 /*---------------------------------------------------------------------------*/
7159 ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr)
7166 uint8_t revision_id;
7170 uint16_t subdevice_id;
7173 dma_addr_t dma_address;
7174 char __iomem *ioremap_ptr;
7175 char __iomem *mem_ptr;
7178 METHOD_TRACE("ips_init_phase1", 1);
7179 index = IPS_MAX_ADAPTERS;
7180 for (j = 0; j < IPS_MAX_ADAPTERS; j++) {
7181 if (ips_ha[j] == 0) {
7187 if (index >= IPS_MAX_ADAPTERS)
7190 /* stuff that we get in dev */
7192 bus = pci_dev->bus->number;
7193 func = pci_dev->devfn;
7195 /* Init MEM/IO addresses to 0 */
7201 for (j = 0; j < 2; j++) {
7202 if (!pci_resource_start(pci_dev, j))
7205 if (pci_resource_flags(pci_dev, j) & IORESOURCE_IO) {
7206 io_addr = pci_resource_start(pci_dev, j);
7207 io_len = pci_resource_len(pci_dev, j);
7209 mem_addr = pci_resource_start(pci_dev, j);
7210 mem_len = pci_resource_len(pci_dev, j);
7214 /* setup memory mapped area (if applicable) */
7219 if (!request_mem_region(mem_addr, mem_len, "ips")) {
7220 IPS_PRINTK(KERN_WARNING, pci_dev,
7221 "Couldn't allocate IO Memory space %x len %d.\n",
7226 base = mem_addr & PAGE_MASK;
7227 offs = mem_addr - base;
7228 ioremap_ptr = ioremap(base, PAGE_SIZE);
7229 mem_ptr = ioremap_ptr + offs;
7235 /* setup I/O mapped area (if applicable) */
7237 if (!request_region(io_addr, io_len, "ips")) {
7238 IPS_PRINTK(KERN_WARNING, pci_dev,
7239 "Couldn't allocate IO space %x len %d.\n",
7245 /* get the revision ID */
7246 if (pci_read_config_byte(pci_dev, PCI_REVISION_ID, &revision_id)) {
7247 IPS_PRINTK(KERN_WARNING, pci_dev, "Can't get revision id.\n");
7251 subdevice_id = pci_dev->subsystem_device;
7253 /* found a controller */
7254 ha = kmalloc(sizeof (ips_ha_t), GFP_KERNEL);
7256 IPS_PRINTK(KERN_WARNING, pci_dev,
7257 "Unable to allocate temporary ha struct\n");
7261 memset(ha, 0, sizeof (ips_ha_t));
7263 ips_sh[index] = NULL;
7267 /* Store info in HA structure */
7269 ha->io_addr = io_addr;
7270 ha->io_len = io_len;
7271 ha->mem_addr = mem_addr;
7272 ha->mem_len = mem_len;
7273 ha->mem_ptr = mem_ptr;
7274 ha->ioremap_ptr = ioremap_ptr;
7275 ha->host_num = (uint32_t) index;
7276 ha->revision_id = revision_id;
7277 ha->slot_num = PCI_SLOT(pci_dev->devfn);
7278 ha->device_id = pci_dev->device;
7279 ha->subdevice_id = subdevice_id;
7280 ha->pcidev = pci_dev;
7283 * Set the pci_dev's dma_mask. Not all adapters support 64bit
7284 * addressing so don't enable it if the adapter can't support
7285 * it! Also, don't use 64bit addressing if dma addresses
7286 * are guaranteed to be < 4G.
7288 if (IPS_ENABLE_DMA64 && IPS_HAS_ENH_SGLIST(ha) &&
7289 !pci_set_dma_mask(ha->pcidev, 0xffffffffffffffffULL)) {
7290 (ha)->flags |= IPS_HA_ENH_SG;
7292 if (pci_set_dma_mask(ha->pcidev, 0xffffffffULL) != 0) {
7293 printk(KERN_WARNING "Unable to set DMA Mask\n");
7294 return ips_abort_init(ha, index);
7297 if(ips_cd_boot && !ips_FlashData){
7298 ips_FlashData = pci_alloc_consistent(pci_dev, PAGE_SIZE << 7,
7302 ha->enq = pci_alloc_consistent(pci_dev, sizeof (IPS_ENQ),
7305 IPS_PRINTK(KERN_WARNING, pci_dev,
7306 "Unable to allocate host inquiry structure\n");
7307 return ips_abort_init(ha, index);
7310 ha->adapt = pci_alloc_consistent(pci_dev, sizeof (IPS_ADAPTER) +
7311 sizeof (IPS_IO_CMD), &dma_address);
7313 IPS_PRINTK(KERN_WARNING, pci_dev,
7314 "Unable to allocate host adapt & dummy structures\n");
7315 return ips_abort_init(ha, index);
7317 ha->adapt->hw_status_start = dma_address;
7318 ha->dummy = (void *) (ha->adapt + 1);
7322 ha->logical_drive_info = pci_alloc_consistent(pci_dev, sizeof (IPS_LD_INFO), &dma_address);
7323 if (!ha->logical_drive_info) {
7324 IPS_PRINTK(KERN_WARNING, pci_dev,
7325 "Unable to allocate logical drive info structure\n");
7326 return ips_abort_init(ha, index);
7328 ha->logical_drive_info_dma_addr = dma_address;
7331 ha->conf = kmalloc(sizeof (IPS_CONF), GFP_KERNEL);
7334 IPS_PRINTK(KERN_WARNING, pci_dev,
7335 "Unable to allocate host conf structure\n");
7336 return ips_abort_init(ha, index);
7339 ha->nvram = kmalloc(sizeof (IPS_NVRAM_P5), GFP_KERNEL);
7342 IPS_PRINTK(KERN_WARNING, pci_dev,
7343 "Unable to allocate host NVRAM structure\n");
7344 return ips_abort_init(ha, index);
7347 ha->subsys = kmalloc(sizeof (IPS_SUBSYS), GFP_KERNEL);
7350 IPS_PRINTK(KERN_WARNING, pci_dev,
7351 "Unable to allocate host subsystem structure\n");
7352 return ips_abort_init(ha, index);
7355 /* the ioctl buffer is now used during adapter initialization, so its
7356 * successful allocation is now required */
7357 if (ips_ioctlsize < PAGE_SIZE)
7358 ips_ioctlsize = PAGE_SIZE;
7360 ha->ioctl_data = pci_alloc_consistent(pci_dev, ips_ioctlsize,
7361 &ha->ioctl_busaddr);
7362 ha->ioctl_len = ips_ioctlsize;
7363 if (!ha->ioctl_data) {
7364 IPS_PRINTK(KERN_WARNING, pci_dev,
7365 "Unable to allocate IOCTL data\n");
7366 return ips_abort_init(ha, index);
7372 ips_setup_funclist(ha);
7374 if ((IPS_IS_MORPHEUS(ha)) || (IPS_IS_MARCO(ha))) {
7375 /* If Morpheus appears dead, reset it */
7376 IsDead = readl(ha->mem_ptr + IPS_REG_I960_MSG1);
7377 if (IsDead == 0xDEADBEEF) {
7378 ips_reset_morpheus(ha);
7383 * Initialize the card if it isn't already
7386 if (!(*ha->func.isinit) (ha)) {
7387 if (!(*ha->func.init) (ha)) {
7389 * Initialization failed
7391 IPS_PRINTK(KERN_WARNING, pci_dev,
7392 "Unable to initialize controller\n");
7393 return ips_abort_init(ha, index);
7401 /*---------------------------------------------------------------------------*/
7402 /* Routine Name: ips_init_phase2 */
7404 /* Routine Description: */
7405 /* Adapter Initialization Phase 2 */
7408 /* 0 if Successful, else non-zero */
7409 /*---------------------------------------------------------------------------*/
7411 ips_init_phase2(int index)
7417 METHOD_TRACE("ips_init_phase2", 1);
7419 ips_ha[index] = NULL;
7423 /* Install the interrupt handler */
7424 if (request_irq(ha->irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
7425 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7426 "Unable to install interrupt handler\n");
7427 return ips_abort_init(ha, index);
7431 * Allocate a temporary SCB for initialization
7434 if (!ips_allocatescbs(ha)) {
7435 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7436 "Unable to allocate a CCB\n");
7437 free_irq(ha->irq, ha);
7438 return ips_abort_init(ha, index);
7441 if (!ips_hainit(ha)) {
7442 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7443 "Unable to initialize controller\n");
7444 free_irq(ha->irq, ha);
7445 return ips_abort_init(ha, index);
7447 /* Free the temporary SCB */
7448 ips_deallocatescbs(ha, 1);
7451 if (!ips_allocatescbs(ha)) {
7452 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7453 "Unable to allocate CCBs\n");
7454 free_irq(ha->irq, ha);
7455 return ips_abort_init(ha, index);
7461 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9)
7462 MODULE_LICENSE("GPL");
7465 MODULE_DESCRIPTION("IBM ServeRAID Adapter Driver " IPS_VER_STRING);
7467 #ifdef MODULE_VERSION
7468 MODULE_VERSION(IPS_VER_STRING);
7473 * Overrides for Emacs so that we almost follow Linus's tabbing style.
7474 * Emacs will notice this stuff at the end of the file and automatically
7475 * adjust the settings for this buffer only. This must remain at the end
7477 * ---------------------------------------------------------------------------
7480 * c-brace-imaginary-offset: 0
7481 * c-brace-offset: -2
7482 * c-argdecl-indent: 2
7483 * c-label-offset: -2
7484 * c-continued-statement-offset: 2
7485 * c-continued-brace-offset: 0
7486 * indent-tabs-mode: nil