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 SCSI_DATA_NONE == scb->scsi_cmd->sc_data_direction) ? \
235 PCI_DMA_BIDIRECTIONAL : \
236 scsi_to_pci_dma_dir(scb->scsi_cmd->sc_data_direction))
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
;
823 METHOD_TRACE("ips_eh_abort", 1);
828 ha
= (ips_ha_t
*) SC
->device
->host
->hostdata
;
836 if (SC
->serial_number
!= SC
->serial_number_at_timeout
) {
837 /* HMM, looks like a bogus command */
838 DEBUG(1, "Abort called with bogus scsi command");
843 /* See if the command is on the copp queue */
844 item
= ha
->copp_waitlist
.head
;
845 while ((item
) && (item
->scsi_cmd
!= SC
))
850 ips_removeq_copp(&ha
->copp_waitlist
, item
);
853 /* See if the command is on the wait queue */
854 } else if (ips_removeq_wait(&ha
->scb_waitlist
, SC
)) {
855 /* command not sent yet */
858 /* command must have already been sent */
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 scsi_to_pci_dma_dir(SC
->
2860 sc_data_direction
));
2861 scb
->flags
|= IPS_SCB_MAP_SG
;
2862 for (i
= 0; i
< scb
->sg_count
; i
++) {
2863 if (ips_fill_scb_sg_single
2864 (ha
, sg_dma_address(&sg
[i
]), scb
, i
,
2865 sg_dma_len(&sg
[i
])) < 0)
2868 scb
->dcdb
.transfer_length
= scb
->data_len
;
2870 if (SC
->request_bufflen
) {
2872 pci_map_single(ha
->pcidev
,
2874 SC
->request_bufflen
,
2875 scsi_to_pci_dma_dir(SC
->
2876 sc_data_direction
));
2877 scb
->flags
|= IPS_SCB_MAP_SINGLE
;
2878 ips_fill_scb_sg_single(ha
, scb
->data_busaddr
,
2880 SC
->request_bufflen
);
2881 scb
->dcdb
.transfer_length
= scb
->data_len
;
2883 scb
->data_busaddr
= 0L;
2886 scb
->dcdb
.transfer_length
= 0;
2891 scb
->dcdb
.cmd_attribute
=
2892 ips_command_direction
[scb
->scsi_cmd
->cmnd
[0]];
2894 /* Allow a WRITE BUFFER Command to Have no Data */
2895 /* This is Used by Tape Flash Utilites */
2896 if ((scb
->scsi_cmd
->cmnd
[0] == WRITE_BUFFER
) && (scb
->data_len
== 0))
2897 scb
->dcdb
.cmd_attribute
= 0;
2899 if (!(scb
->dcdb
.cmd_attribute
& 0x3))
2900 scb
->dcdb
.transfer_length
= 0;
2902 if (scb
->data_len
>= IPS_MAX_XFER
) {
2903 scb
->dcdb
.cmd_attribute
|= IPS_TRANSFER64K
;
2904 scb
->dcdb
.transfer_length
= 0;
2906 if (intr
== IPS_INTR_ON
)
2907 IPS_LOCK_SAVE(host
->host_lock
, cpu_flags
);
2909 ret
= ips_send_cmd(ha
, scb
);
2913 ips_putq_scb_head(&ha
->scb_activelist
, scb
);
2916 if (scb
->scsi_cmd
) {
2917 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
2918 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
2922 ha
->dcdb_active
[scb
->bus
- 1] &=
2923 ~(1 << scb
->target_id
);
2925 ips_freescb(ha
, scb
);
2927 case IPS_SUCCESS_IMM
:
2929 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
2932 ha
->dcdb_active
[scb
->bus
- 1] &=
2933 ~(1 << scb
->target_id
);
2935 ips_freescb(ha
, scb
);
2941 p
= (Scsi_Cmnd
*) p
->host_scribble
;
2945 if (intr
== IPS_INTR_ON
)
2946 IPS_UNLOCK_RESTORE(host
->host_lock
, cpu_flags
);
2949 /****************************************************************************/
2951 /* Routine Name: ips_putq_scb_head */
2953 /* Routine Description: */
2955 /* Add an item to the head of the queue */
2957 /* ASSUMED to be called from within the HA lock */
2959 /****************************************************************************/
2961 ips_putq_scb_head(ips_scb_queue_t
* queue
, ips_scb_t
* item
)
2963 METHOD_TRACE("ips_putq_scb_head", 1);
2968 item
->q_next
= queue
->head
;
2977 /****************************************************************************/
2979 /* Routine Name: ips_removeq_scb_head */
2981 /* Routine Description: */
2983 /* Remove the head of the queue */
2985 /* ASSUMED to be called from within the HA lock */
2987 /****************************************************************************/
2989 ips_removeq_scb_head(ips_scb_queue_t
* queue
)
2993 METHOD_TRACE("ips_removeq_scb_head", 1);
3001 queue
->head
= item
->q_next
;
3002 item
->q_next
= NULL
;
3004 if (queue
->tail
== item
)
3012 /****************************************************************************/
3014 /* Routine Name: ips_removeq_scb */
3016 /* Routine Description: */
3018 /* Remove an item from a queue */
3020 /* ASSUMED to be called from within the HA lock */
3022 /****************************************************************************/
3024 ips_removeq_scb(ips_scb_queue_t
* queue
, ips_scb_t
* item
)
3028 METHOD_TRACE("ips_removeq_scb", 1);
3033 if (item
== queue
->head
) {
3034 return (ips_removeq_scb_head(queue
));
3039 while ((p
) && (item
!= p
->q_next
))
3044 p
->q_next
= item
->q_next
;
3049 item
->q_next
= NULL
;
3058 /****************************************************************************/
3060 /* Routine Name: ips_putq_wait_tail */
3062 /* Routine Description: */
3064 /* Add an item to the tail of the queue */
3066 /* ASSUMED to be called from within the HA lock */
3068 /****************************************************************************/
3070 ips_putq_wait_tail(ips_wait_queue_t
* queue
, Scsi_Cmnd
* item
)
3072 METHOD_TRACE("ips_putq_wait_tail", 1);
3077 item
->host_scribble
= NULL
;
3080 queue
->tail
->host_scribble
= (char *) item
;
3090 /****************************************************************************/
3092 /* Routine Name: ips_removeq_wait_head */
3094 /* Routine Description: */
3096 /* Remove the head of the queue */
3098 /* ASSUMED to be called from within the HA lock */
3100 /****************************************************************************/
3102 ips_removeq_wait_head(ips_wait_queue_t
* queue
)
3106 METHOD_TRACE("ips_removeq_wait_head", 1);
3114 queue
->head
= (Scsi_Cmnd
*) item
->host_scribble
;
3115 item
->host_scribble
= NULL
;
3117 if (queue
->tail
== item
)
3125 /****************************************************************************/
3127 /* Routine Name: ips_removeq_wait */
3129 /* Routine Description: */
3131 /* Remove an item from a queue */
3133 /* ASSUMED to be called from within the HA lock */
3135 /****************************************************************************/
3137 ips_removeq_wait(ips_wait_queue_t
* queue
, Scsi_Cmnd
* item
)
3141 METHOD_TRACE("ips_removeq_wait", 1);
3146 if (item
== queue
->head
) {
3147 return (ips_removeq_wait_head(queue
));
3152 while ((p
) && (item
!= (Scsi_Cmnd
*) p
->host_scribble
))
3153 p
= (Scsi_Cmnd
*) p
->host_scribble
;
3157 p
->host_scribble
= item
->host_scribble
;
3159 if (!item
->host_scribble
)
3162 item
->host_scribble
= NULL
;
3171 /****************************************************************************/
3173 /* Routine Name: ips_putq_copp_tail */
3175 /* Routine Description: */
3177 /* Add an item to the tail of the queue */
3179 /* ASSUMED to be called from within the HA lock */
3181 /****************************************************************************/
3183 ips_putq_copp_tail(ips_copp_queue_t
* queue
, ips_copp_wait_item_t
* item
)
3185 METHOD_TRACE("ips_putq_copp_tail", 1);
3193 queue
->tail
->next
= item
;
3203 /****************************************************************************/
3205 /* Routine Name: ips_removeq_copp_head */
3207 /* Routine Description: */
3209 /* Remove the head of the queue */
3211 /* ASSUMED to be called from within the HA lock */
3213 /****************************************************************************/
3214 static ips_copp_wait_item_t
*
3215 ips_removeq_copp_head(ips_copp_queue_t
* queue
)
3217 ips_copp_wait_item_t
*item
;
3219 METHOD_TRACE("ips_removeq_copp_head", 1);
3227 queue
->head
= item
->next
;
3230 if (queue
->tail
== item
)
3238 /****************************************************************************/
3240 /* Routine Name: ips_removeq_copp */
3242 /* Routine Description: */
3244 /* Remove an item from a queue */
3246 /* ASSUMED to be called from within the HA lock */
3248 /****************************************************************************/
3249 static ips_copp_wait_item_t
*
3250 ips_removeq_copp(ips_copp_queue_t
* queue
, ips_copp_wait_item_t
* item
)
3252 ips_copp_wait_item_t
*p
;
3254 METHOD_TRACE("ips_removeq_copp", 1);
3259 if (item
== queue
->head
) {
3260 return (ips_removeq_copp_head(queue
));
3265 while ((p
) && (item
!= p
->next
))
3270 p
->next
= item
->next
;
3284 /****************************************************************************/
3286 /* Routine Name: ipsintr_blocking */
3288 /* Routine Description: */
3290 /* Finalize an interrupt for internal commands */
3292 /****************************************************************************/
3294 ipsintr_blocking(ips_ha_t
* ha
, ips_scb_t
* scb
)
3296 METHOD_TRACE("ipsintr_blocking", 2);
3298 ips_freescb(ha
, scb
);
3299 if ((ha
->waitflag
== TRUE
) && (ha
->cmd_in_progress
== scb
->cdb
[0])) {
3300 ha
->waitflag
= FALSE
;
3306 /****************************************************************************/
3308 /* Routine Name: ipsintr_done */
3310 /* Routine Description: */
3312 /* Finalize an interrupt for non-internal commands */
3314 /****************************************************************************/
3316 ipsintr_done(ips_ha_t
* ha
, ips_scb_t
* scb
)
3318 METHOD_TRACE("ipsintr_done", 2);
3321 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
3322 "Spurious interrupt; scb NULL.\n");
3327 if (scb
->scsi_cmd
== NULL
) {
3328 /* unexpected interrupt */
3329 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
3330 "Spurious interrupt; scsi_cmd not set.\n");
3338 /****************************************************************************/
3340 /* Routine Name: ips_done */
3342 /* Routine Description: */
3344 /* Do housekeeping on completed commands */
3345 /* ASSUMED to be called form within the request lock */
3346 /****************************************************************************/
3348 ips_done(ips_ha_t
* ha
, ips_scb_t
* scb
)
3352 METHOD_TRACE("ips_done", 1);
3357 if ((scb
->scsi_cmd
) && (ips_is_passthru(scb
->scsi_cmd
))) {
3358 ips_cleanup_passthru(ha
, scb
);
3362 * Check to see if this command had too much
3363 * data and had to be broke up. If so, queue
3364 * the rest of the data and continue.
3366 if ((scb
->breakup
) || (scb
->sg_break
)) {
3367 /* we had a data breakup */
3370 if (scb
->sg_count
) {
3372 struct scatterlist
*sg
;
3373 int ips_sg_index
= 0;
3376 sg
= scb
->scsi_cmd
->request_buffer
;
3378 /* Spin forward to last dma chunk */
3379 sg_dma_index
= scb
->breakup
;
3381 /* Take care of possible partial on last chunk */
3382 ips_fill_scb_sg_single(ha
,
3385 scb
, ips_sg_index
++,
3389 for (; sg_dma_index
< scb
->sg_count
;
3391 if (ips_fill_scb_sg_single
3393 sg_dma_address(&sg
[sg_dma_index
]),
3394 scb
, ips_sg_index
++,
3395 sg_dma_len(&sg
[sg_dma_index
])) < 0)
3401 /* Non S/G Request */
3402 (void) ips_fill_scb_sg_single(ha
,
3414 scb
->dcdb
.transfer_length
= scb
->data_len
;
3415 scb
->dcdb
.cmd_attribute
|=
3416 ips_command_direction
[scb
->scsi_cmd
->cmnd
[0]];
3418 if (!(scb
->dcdb
.cmd_attribute
& 0x3))
3419 scb
->dcdb
.transfer_length
= 0;
3421 if (scb
->data_len
>= IPS_MAX_XFER
) {
3422 scb
->dcdb
.cmd_attribute
|= IPS_TRANSFER64K
;
3423 scb
->dcdb
.transfer_length
= 0;
3426 ret
= ips_send_cmd(ha
, scb
);
3430 if (scb
->scsi_cmd
) {
3431 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
3432 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
3435 ips_freescb(ha
, scb
);
3437 case IPS_SUCCESS_IMM
:
3438 if (scb
->scsi_cmd
) {
3439 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
3440 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
3443 ips_freescb(ha
, scb
);
3451 } /* end if passthru */
3454 ha
->dcdb_active
[scb
->bus
- 1] &= ~(1 << scb
->target_id
);
3457 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
3459 ips_freescb(ha
, scb
);
3462 /****************************************************************************/
3464 /* Routine Name: ips_map_status */
3466 /* Routine Description: */
3468 /* Map Controller Error codes to Linux Error Codes */
3470 /****************************************************************************/
3472 ips_map_status(ips_ha_t
* ha
, ips_scb_t
* scb
, ips_stat_t
* sp
)
3476 uint32_t transfer_len
;
3477 IPS_DCDB_TABLE_TAPE
*tapeDCDB
;
3479 METHOD_TRACE("ips_map_status", 1);
3483 "(%s%d) Physical device error (%d %d %d): %x %x, Sense Key: %x, ASC: %x, ASCQ: %x",
3484 ips_name
, ha
->host_num
,
3485 scb
->scsi_cmd
->device
->channel
,
3486 scb
->scsi_cmd
->device
->id
, scb
->scsi_cmd
->device
->lun
,
3487 scb
->basic_status
, scb
->extended_status
,
3488 scb
->extended_status
==
3489 IPS_ERR_CKCOND
? scb
->dcdb
.sense_info
[2] & 0xf : 0,
3490 scb
->extended_status
==
3491 IPS_ERR_CKCOND
? scb
->dcdb
.sense_info
[12] : 0,
3492 scb
->extended_status
==
3493 IPS_ERR_CKCOND
? scb
->dcdb
.sense_info
[13] : 0);
3496 /* default driver error */
3497 errcode
= DID_ERROR
;
3500 switch (scb
->basic_status
& IPS_GSC_STATUS_MASK
) {
3501 case IPS_CMD_TIMEOUT
:
3502 errcode
= DID_TIME_OUT
;
3505 case IPS_INVAL_OPCO
:
3506 case IPS_INVAL_CMD_BLK
:
3507 case IPS_INVAL_PARM_BLK
:
3509 case IPS_CMD_CMPLT_WERROR
:
3512 case IPS_PHYS_DRV_ERROR
:
3513 switch (scb
->extended_status
) {
3514 case IPS_ERR_SEL_TO
:
3516 errcode
= DID_NO_CONNECT
;
3520 case IPS_ERR_OU_RUN
:
3521 if ((scb
->cmd
.dcdb
.op_code
== IPS_CMD_EXTENDED_DCDB
) ||
3522 (scb
->cmd
.dcdb
.op_code
==
3523 IPS_CMD_EXTENDED_DCDB_SG
)) {
3524 tapeDCDB
= (IPS_DCDB_TABLE_TAPE
*) & scb
->dcdb
;
3525 transfer_len
= tapeDCDB
->transfer_length
;
3528 (uint32_t) scb
->dcdb
.transfer_length
;
3531 if ((scb
->bus
) && (transfer_len
< scb
->data_len
)) {
3532 /* Underrun - set default to no error */
3535 /* Restrict access to physical DASD */
3536 if ((scb
->scsi_cmd
->cmnd
[0] == INQUIRY
) &&
3537 ((((char *) scb
->scsi_cmd
->
3538 buffer
)[0] & 0x1f) == TYPE_DISK
)) {
3539 /* underflow -- no error */
3540 /* restrict access to physical DASD */
3541 errcode
= DID_TIME_OUT
;
3545 errcode
= DID_ERROR
;
3549 case IPS_ERR_RECOVERY
:
3550 /* don't fail recovered errors */
3556 case IPS_ERR_HOST_RESET
:
3557 case IPS_ERR_DEV_RESET
:
3558 errcode
= DID_RESET
;
3561 case IPS_ERR_CKCOND
:
3563 if ((scb
->cmd
.dcdb
.op_code
==
3564 IPS_CMD_EXTENDED_DCDB
)
3565 || (scb
->cmd
.dcdb
.op_code
==
3566 IPS_CMD_EXTENDED_DCDB_SG
)) {
3568 (IPS_DCDB_TABLE_TAPE
*) & scb
->dcdb
;
3569 memcpy(scb
->scsi_cmd
->sense_buffer
,
3570 tapeDCDB
->sense_info
,
3571 sizeof (scb
->scsi_cmd
->
3574 memcpy(scb
->scsi_cmd
->sense_buffer
,
3575 scb
->dcdb
.sense_info
,
3576 sizeof (scb
->scsi_cmd
->
3579 device_error
= 2; /* check condition */
3587 errcode
= DID_ERROR
;
3593 scb
->scsi_cmd
->result
= device_error
| (errcode
<< 16);
3598 /****************************************************************************/
3600 /* Routine Name: ips_send_wait */
3602 /* Routine Description: */
3604 /* Send a command to the controller and wait for it to return */
3606 /* The FFDC Time Stamp use this function for the callback, but doesn't */
3607 /* actually need to wait. */
3608 /****************************************************************************/
3610 ips_send_wait(ips_ha_t
* ha
, ips_scb_t
* scb
, int timeout
, int intr
)
3614 METHOD_TRACE("ips_send_wait", 1);
3616 if (intr
!= IPS_FFDC
) { /* Won't be Waiting if this is a Time Stamp */
3617 ha
->waitflag
= TRUE
;
3618 ha
->cmd_in_progress
= scb
->cdb
[0];
3620 scb
->callback
= ipsintr_blocking
;
3621 ret
= ips_send_cmd(ha
, scb
);
3623 if ((ret
== IPS_FAILURE
) || (ret
== IPS_SUCCESS_IMM
))
3626 if (intr
!= IPS_FFDC
) /* Don't Wait around if this is a Time Stamp */
3627 ret
= ips_wait(ha
, timeout
, intr
);
3632 /****************************************************************************/
3634 /* Routine Name: ips_scmd_buf_write */
3636 /* Routine Description: */
3637 /* Write data to Scsi_Cmnd request_buffer at proper offsets */
3638 /****************************************************************************/
3640 ips_scmd_buf_write(Scsi_Cmnd
* scmd
, void *data
, unsigned
3645 unsigned int min_cnt
, xfer_cnt
;
3646 char *cdata
= (char *) data
;
3647 struct scatterlist
*sg
= scmd
->request_buffer
;
3648 for (i
= 0, xfer_cnt
= 0;
3649 (i
< scmd
->use_sg
) && (xfer_cnt
< count
); i
++) {
3650 if (!IPS_SG_ADDRESS(&sg
[i
]))
3652 min_cnt
= min(count
- xfer_cnt
, sg
[i
].length
);
3653 memcpy(IPS_SG_ADDRESS(&sg
[i
]), &cdata
[xfer_cnt
],
3655 xfer_cnt
+= min_cnt
;
3659 unsigned int min_cnt
= min(count
, scmd
->request_bufflen
);
3660 memcpy(scmd
->request_buffer
, data
, min_cnt
);
3664 /****************************************************************************/
3666 /* Routine Name: ips_scmd_buf_read */
3668 /* Routine Description: */
3669 /* Copy data from a Scsi_Cmnd to a new, linear buffer */
3670 /****************************************************************************/
3672 ips_scmd_buf_read(Scsi_Cmnd
* scmd
, void *data
, unsigned
3677 unsigned int min_cnt
, xfer_cnt
;
3678 char *cdata
= (char *) data
;
3679 struct scatterlist
*sg
= scmd
->request_buffer
;
3680 for (i
= 0, xfer_cnt
= 0;
3681 (i
< scmd
->use_sg
) && (xfer_cnt
< count
); i
++) {
3682 if (!IPS_SG_ADDRESS(&sg
[i
]))
3684 min_cnt
= min(count
- xfer_cnt
, sg
[i
].length
);
3685 memcpy(&cdata
[xfer_cnt
], IPS_SG_ADDRESS(&sg
[i
]),
3687 xfer_cnt
+= min_cnt
;
3691 unsigned int min_cnt
= min(count
, scmd
->request_bufflen
);
3692 memcpy(data
, scmd
->request_buffer
, min_cnt
);
3696 /****************************************************************************/
3698 /* Routine Name: ips_send_cmd */
3700 /* Routine Description: */
3702 /* Map SCSI commands to ServeRAID commands for logical drives */
3704 /****************************************************************************/
3706 ips_send_cmd(ips_ha_t
* ha
, ips_scb_t
* scb
)
3711 IPS_DCDB_TABLE_TAPE
*tapeDCDB
;
3714 METHOD_TRACE("ips_send_cmd", 1);
3718 if (!scb
->scsi_cmd
) {
3719 /* internal command */
3722 /* Controller commands can't be issued */
3723 /* to real devices -- fail them */
3724 if ((ha
->waitflag
== TRUE
) &&
3725 (ha
->cmd_in_progress
== scb
->cdb
[0])) {
3726 ha
->waitflag
= FALSE
;
3731 } else if ((scb
->bus
== 0) && (!ips_is_passthru(scb
->scsi_cmd
))) {
3732 /* command to logical bus -- interpret */
3733 ret
= IPS_SUCCESS_IMM
;
3735 switch (scb
->scsi_cmd
->cmnd
[0]) {
3736 case ALLOW_MEDIUM_REMOVAL
:
3739 case WRITE_FILEMARKS
:
3741 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
3745 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3747 case TEST_UNIT_READY
:
3749 if (scb
->target_id
== IPS_ADAPTER_ID
) {
3751 * Either we have a TUR
3752 * or we have a SCSI inquiry
3754 if (scb
->scsi_cmd
->cmnd
[0] == TEST_UNIT_READY
)
3755 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3757 if (scb
->scsi_cmd
->cmnd
[0] == INQUIRY
) {
3758 IPS_SCSI_INQ_DATA inquiry
;
3761 sizeof (IPS_SCSI_INQ_DATA
));
3763 inquiry
.DeviceType
=
3764 IPS_SCSI_INQ_TYPE_PROCESSOR
;
3765 inquiry
.DeviceTypeQualifier
=
3766 IPS_SCSI_INQ_LU_CONNECTED
;
3767 inquiry
.Version
= IPS_SCSI_INQ_REV2
;
3768 inquiry
.ResponseDataFormat
=
3769 IPS_SCSI_INQ_RD_REV2
;
3770 inquiry
.AdditionalLength
= 31;
3772 IPS_SCSI_INQ_Address16
;
3774 IPS_SCSI_INQ_WBus16
|
3776 strncpy(inquiry
.VendorId
, "IBM ",
3778 strncpy(inquiry
.ProductId
,
3780 strncpy(inquiry
.ProductRevisionLevel
,
3783 ips_scmd_buf_write(scb
->scsi_cmd
,
3787 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3790 scb
->cmd
.logical_info
.op_code
= IPS_CMD_GET_LD_INFO
;
3791 scb
->cmd
.logical_info
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3792 scb
->cmd
.logical_info
.reserved
= 0;
3793 scb
->cmd
.logical_info
.reserved2
= 0;
3794 scb
->data_len
= sizeof (IPS_LD_INFO
);
3795 scb
->data_busaddr
= ha
->logical_drive_info_dma_addr
;
3797 scb
->cmd
.logical_info
.buffer_addr
= scb
->data_busaddr
;
3804 ips_reqsen(ha
, scb
);
3805 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3811 scb
->cmd
.basic_io
.op_code
=
3812 (scb
->scsi_cmd
->cmnd
[0] ==
3813 READ_6
) ? IPS_CMD_READ
: IPS_CMD_WRITE
;
3814 scb
->cmd
.basic_io
.enhanced_sg
= 0;
3815 scb
->cmd
.basic_io
.sg_addr
=
3816 cpu_to_le32(scb
->data_busaddr
);
3818 scb
->cmd
.basic_io
.op_code
=
3819 (scb
->scsi_cmd
->cmnd
[0] ==
3820 READ_6
) ? IPS_CMD_READ_SG
:
3822 scb
->cmd
.basic_io
.enhanced_sg
=
3823 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
3824 scb
->cmd
.basic_io
.sg_addr
=
3825 cpu_to_le32(scb
->sg_busaddr
);
3828 scb
->cmd
.basic_io
.segment_4G
= 0;
3829 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3830 scb
->cmd
.basic_io
.log_drv
= scb
->target_id
;
3831 scb
->cmd
.basic_io
.sg_count
= scb
->sg_len
;
3833 if (scb
->cmd
.basic_io
.lba
)
3834 scb
->cmd
.basic_io
.lba
=
3835 cpu_to_le32(le32_to_cpu
3836 (scb
->cmd
.basic_io
.lba
) +
3837 le16_to_cpu(scb
->cmd
.basic_io
.
3840 scb
->cmd
.basic_io
.lba
=
3842 cmnd
[1] & 0x1f) << 16) | (scb
->scsi_cmd
->
3844 (scb
->scsi_cmd
->cmnd
[3]));
3846 scb
->cmd
.basic_io
.sector_count
=
3847 cpu_to_le16(scb
->data_len
/ IPS_BLKSIZE
);
3849 if (le16_to_cpu(scb
->cmd
.basic_io
.sector_count
) == 0)
3850 scb
->cmd
.basic_io
.sector_count
=
3859 scb
->cmd
.basic_io
.op_code
=
3860 (scb
->scsi_cmd
->cmnd
[0] ==
3861 READ_10
) ? IPS_CMD_READ
: IPS_CMD_WRITE
;
3862 scb
->cmd
.basic_io
.enhanced_sg
= 0;
3863 scb
->cmd
.basic_io
.sg_addr
=
3864 cpu_to_le32(scb
->data_busaddr
);
3866 scb
->cmd
.basic_io
.op_code
=
3867 (scb
->scsi_cmd
->cmnd
[0] ==
3868 READ_10
) ? IPS_CMD_READ_SG
:
3870 scb
->cmd
.basic_io
.enhanced_sg
=
3871 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
3872 scb
->cmd
.basic_io
.sg_addr
=
3873 cpu_to_le32(scb
->sg_busaddr
);
3876 scb
->cmd
.basic_io
.segment_4G
= 0;
3877 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3878 scb
->cmd
.basic_io
.log_drv
= scb
->target_id
;
3879 scb
->cmd
.basic_io
.sg_count
= scb
->sg_len
;
3881 if (scb
->cmd
.basic_io
.lba
)
3882 scb
->cmd
.basic_io
.lba
=
3883 cpu_to_le32(le32_to_cpu
3884 (scb
->cmd
.basic_io
.lba
) +
3885 le16_to_cpu(scb
->cmd
.basic_io
.
3888 scb
->cmd
.basic_io
.lba
=
3889 ((scb
->scsi_cmd
->cmnd
[2] << 24) | (scb
->
3893 (scb
->scsi_cmd
->cmnd
[4] << 8) | scb
->
3896 scb
->cmd
.basic_io
.sector_count
=
3897 cpu_to_le16(scb
->data_len
/ IPS_BLKSIZE
);
3899 if (cpu_to_le16(scb
->cmd
.basic_io
.sector_count
) == 0) {
3901 * This is a null condition
3902 * we don't have to do anything
3905 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3913 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3917 scb
->cmd
.basic_io
.op_code
= IPS_CMD_ENQUIRY
;
3918 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3919 scb
->cmd
.basic_io
.segment_4G
= 0;
3920 scb
->cmd
.basic_io
.enhanced_sg
= 0;
3921 scb
->data_len
= sizeof (*ha
->enq
);
3922 scb
->cmd
.basic_io
.sg_addr
= ha
->enq_busaddr
;
3927 scb
->cmd
.logical_info
.op_code
= IPS_CMD_GET_LD_INFO
;
3928 scb
->cmd
.logical_info
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3929 scb
->cmd
.logical_info
.reserved
= 0;
3930 scb
->cmd
.logical_info
.reserved2
= 0;
3931 scb
->cmd
.logical_info
.reserved3
= 0;
3932 scb
->data_len
= sizeof (IPS_LD_INFO
);
3933 scb
->data_busaddr
= ha
->logical_drive_info_dma_addr
;
3935 scb
->cmd
.logical_info
.buffer_addr
= scb
->data_busaddr
;
3939 case SEND_DIAGNOSTIC
:
3940 case REASSIGN_BLOCKS
:
3944 case READ_DEFECT_DATA
:
3947 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3951 /* Set the Return Info to appear like the Command was */
3952 /* attempted, a Check Condition occurred, and Sense */
3953 /* Data indicating an Invalid CDB OpCode is returned. */
3954 sp
= (char *) scb
->scsi_cmd
->sense_buffer
;
3955 memset(sp
, 0, sizeof (scb
->scsi_cmd
->sense_buffer
));
3957 sp
[0] = 0x70; /* Error Code */
3958 sp
[2] = ILLEGAL_REQUEST
; /* Sense Key 5 Illegal Req. */
3959 sp
[7] = 0x0A; /* Additional Sense Length */
3960 sp
[12] = 0x20; /* ASC = Invalid OpCode */
3961 sp
[13] = 0x00; /* ASCQ */
3963 device_error
= 2; /* Indicate Check Condition */
3964 scb
->scsi_cmd
->result
= device_error
| (DID_OK
<< 16);
3969 if (ret
== IPS_SUCCESS_IMM
)
3975 /* If we already know the Device is Not there, no need to attempt a Command */
3976 /* This also protects an NT FailOver Controller from getting CDB's sent to it */
3977 if (ha
->conf
->dev
[scb
->bus
- 1][scb
->target_id
].ucState
== 0) {
3978 scb
->scsi_cmd
->result
= DID_NO_CONNECT
<< 16;
3979 return (IPS_SUCCESS_IMM
);
3982 ha
->dcdb_active
[scb
->bus
- 1] |= (1 << scb
->target_id
);
3983 scb
->cmd
.dcdb
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3984 scb
->cmd
.dcdb
.dcdb_address
= cpu_to_le32(scb
->scb_busaddr
+
3985 (unsigned long) &scb
->
3987 (unsigned long) scb
);
3988 scb
->cmd
.dcdb
.reserved
= 0;
3989 scb
->cmd
.dcdb
.reserved2
= 0;
3990 scb
->cmd
.dcdb
.reserved3
= 0;
3991 scb
->cmd
.dcdb
.segment_4G
= 0;
3992 scb
->cmd
.dcdb
.enhanced_sg
= 0;
3994 TimeOut
= scb
->scsi_cmd
->timeout_per_command
;
3996 if (ha
->subsys
->param
[4] & 0x00100000) { /* If NEW Tape DCDB is Supported */
3998 scb
->cmd
.dcdb
.op_code
= IPS_CMD_EXTENDED_DCDB
;
4000 scb
->cmd
.dcdb
.op_code
=
4001 IPS_CMD_EXTENDED_DCDB_SG
;
4002 scb
->cmd
.dcdb
.enhanced_sg
=
4003 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
4006 tapeDCDB
= (IPS_DCDB_TABLE_TAPE
*) & scb
->dcdb
; /* Use Same Data Area as Old DCDB Struct */
4007 tapeDCDB
->device_address
=
4008 ((scb
->bus
- 1) << 4) | scb
->target_id
;
4009 tapeDCDB
->cmd_attribute
|= IPS_DISCONNECT_ALLOWED
;
4010 tapeDCDB
->cmd_attribute
&= ~IPS_TRANSFER64K
; /* Always Turn OFF 64K Size Flag */
4013 if (TimeOut
< (10 * HZ
))
4014 tapeDCDB
->cmd_attribute
|= IPS_TIMEOUT10
; /* TimeOut is 10 Seconds */
4015 else if (TimeOut
< (60 * HZ
))
4016 tapeDCDB
->cmd_attribute
|= IPS_TIMEOUT60
; /* TimeOut is 60 Seconds */
4017 else if (TimeOut
< (1200 * HZ
))
4018 tapeDCDB
->cmd_attribute
|= IPS_TIMEOUT20M
; /* TimeOut is 20 Minutes */
4021 tapeDCDB
->cdb_length
= scb
->scsi_cmd
->cmd_len
;
4022 tapeDCDB
->reserved_for_LUN
= 0;
4023 tapeDCDB
->transfer_length
= scb
->data_len
;
4024 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_EXTENDED_DCDB_SG
)
4025 tapeDCDB
->buffer_pointer
=
4026 cpu_to_le32(scb
->sg_busaddr
);
4028 tapeDCDB
->buffer_pointer
=
4029 cpu_to_le32(scb
->data_busaddr
);
4030 tapeDCDB
->sg_count
= scb
->sg_len
;
4031 tapeDCDB
->sense_length
= sizeof (tapeDCDB
->sense_info
);
4032 tapeDCDB
->scsi_status
= 0;
4033 tapeDCDB
->reserved
= 0;
4034 memcpy(tapeDCDB
->scsi_cdb
, scb
->scsi_cmd
->cmnd
,
4035 scb
->scsi_cmd
->cmd_len
);
4038 scb
->cmd
.dcdb
.op_code
= IPS_CMD_DCDB
;
4040 scb
->cmd
.dcdb
.op_code
= IPS_CMD_DCDB_SG
;
4041 scb
->cmd
.dcdb
.enhanced_sg
=
4042 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
4045 scb
->dcdb
.device_address
=
4046 ((scb
->bus
- 1) << 4) | scb
->target_id
;
4047 scb
->dcdb
.cmd_attribute
|= IPS_DISCONNECT_ALLOWED
;
4050 if (TimeOut
< (10 * HZ
))
4051 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT10
; /* TimeOut is 10 Seconds */
4052 else if (TimeOut
< (60 * HZ
))
4053 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT60
; /* TimeOut is 60 Seconds */
4054 else if (TimeOut
< (1200 * HZ
))
4055 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT20M
; /* TimeOut is 20 Minutes */
4058 scb
->dcdb
.transfer_length
= scb
->data_len
;
4059 if (scb
->dcdb
.cmd_attribute
& IPS_TRANSFER64K
)
4060 scb
->dcdb
.transfer_length
= 0;
4061 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_DCDB_SG
)
4062 scb
->dcdb
.buffer_pointer
=
4063 cpu_to_le32(scb
->sg_busaddr
);
4065 scb
->dcdb
.buffer_pointer
=
4066 cpu_to_le32(scb
->data_busaddr
);
4067 scb
->dcdb
.cdb_length
= scb
->scsi_cmd
->cmd_len
;
4068 scb
->dcdb
.sense_length
= sizeof (scb
->dcdb
.sense_info
);
4069 scb
->dcdb
.sg_count
= scb
->sg_len
;
4070 scb
->dcdb
.reserved
= 0;
4071 memcpy(scb
->dcdb
.scsi_cdb
, scb
->scsi_cmd
->cmnd
,
4072 scb
->scsi_cmd
->cmd_len
);
4073 scb
->dcdb
.scsi_status
= 0;
4074 scb
->dcdb
.reserved2
[0] = 0;
4075 scb
->dcdb
.reserved2
[1] = 0;
4076 scb
->dcdb
.reserved2
[2] = 0;
4080 return ((*ha
->func
.issue
) (ha
, scb
));
4083 /****************************************************************************/
4085 /* Routine Name: ips_chk_status */
4087 /* Routine Description: */
4089 /* Check the status of commands to logical drives */
4090 /* Assumed to be called with the HA lock */
4091 /****************************************************************************/
4093 ips_chkstatus(ips_ha_t
* ha
, IPS_STATUS
* pstatus
)
4097 uint8_t basic_status
;
4101 METHOD_TRACE("ips_chkstatus", 1);
4103 scb
= &ha
->scbs
[pstatus
->fields
.command_id
];
4104 scb
->basic_status
= basic_status
=
4105 pstatus
->fields
.basic_status
& IPS_BASIC_STATUS_MASK
;
4106 scb
->extended_status
= ext_status
= pstatus
->fields
.extended_status
;
4109 sp
->residue_len
= 0;
4110 sp
->scb_addr
= (void *) scb
;
4112 /* Remove the item from the active queue */
4113 ips_removeq_scb(&ha
->scb_activelist
, scb
);
4116 /* internal commands are handled in do_ipsintr */
4119 DEBUG_VAR(2, "(%s%d) ips_chkstatus: cmd 0x%X id %d (%d %d %d)",
4123 scb
->cmd
.basic_io
.command_id
,
4124 scb
->bus
, scb
->target_id
, scb
->lun
);
4126 if ((scb
->scsi_cmd
) && (ips_is_passthru(scb
->scsi_cmd
)))
4127 /* passthru - just returns the raw result */
4132 if (((basic_status
& IPS_GSC_STATUS_MASK
) == IPS_CMD_SUCCESS
) ||
4133 ((basic_status
& IPS_GSC_STATUS_MASK
) == IPS_CMD_RECOVERED_ERROR
)) {
4135 if (scb
->bus
== 0) {
4136 if ((basic_status
& IPS_GSC_STATUS_MASK
) ==
4137 IPS_CMD_RECOVERED_ERROR
) {
4139 "(%s%d) Recovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4140 ips_name
, ha
->host_num
,
4141 scb
->cmd
.basic_io
.op_code
,
4142 basic_status
, ext_status
);
4145 switch (scb
->scsi_cmd
->cmnd
[0]) {
4146 case ALLOW_MEDIUM_REMOVAL
:
4149 case WRITE_FILEMARKS
:
4151 errcode
= DID_ERROR
;
4157 case TEST_UNIT_READY
:
4158 if (!ips_online(ha
, scb
)) {
4159 errcode
= DID_TIME_OUT
;
4164 if (ips_online(ha
, scb
)) {
4165 ips_inquiry(ha
, scb
);
4167 errcode
= DID_TIME_OUT
;
4172 ips_reqsen(ha
, scb
);
4184 if (!ips_online(ha
, scb
)
4185 || !ips_msense(ha
, scb
)) {
4186 errcode
= DID_ERROR
;
4191 if (ips_online(ha
, scb
))
4194 errcode
= DID_TIME_OUT
;
4198 case SEND_DIAGNOSTIC
:
4199 case REASSIGN_BLOCKS
:
4203 errcode
= DID_ERROR
;
4208 case READ_DEFECT_DATA
:
4214 errcode
= DID_ERROR
;
4217 scb
->scsi_cmd
->result
= errcode
<< 16;
4218 } else { /* bus == 0 */
4219 /* restrict access to physical drives */
4220 if ((scb
->scsi_cmd
->cmnd
[0] == INQUIRY
) &&
4221 ((((char *) scb
->scsi_cmd
->buffer
)[0] & 0x1f) ==
4224 scb
->scsi_cmd
->result
= DID_TIME_OUT
<< 16;
4227 } else { /* recovered error / success */
4228 if (scb
->bus
== 0) {
4230 "(%s%d) Unrecovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4231 ips_name
, ha
->host_num
,
4232 scb
->cmd
.basic_io
.op_code
, basic_status
,
4236 ips_map_status(ha
, scb
, sp
);
4240 /****************************************************************************/
4242 /* Routine Name: ips_online */
4244 /* Routine Description: */
4246 /* Determine if a logical drive is online */
4248 /****************************************************************************/
4250 ips_online(ips_ha_t
* ha
, ips_scb_t
* scb
)
4252 METHOD_TRACE("ips_online", 1);
4254 if (scb
->target_id
>= IPS_MAX_LD
)
4257 if ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1) {
4258 memset(ha
->logical_drive_info
, 0, sizeof (IPS_LD_INFO
));
4262 if (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
!=
4268 && ha
->logical_drive_info
->drive_info
[scb
->target_id
].state
!=
4275 /****************************************************************************/
4277 /* Routine Name: ips_inquiry */
4279 /* Routine Description: */
4281 /* Simulate an inquiry command to a logical drive */
4283 /****************************************************************************/
4285 ips_inquiry(ips_ha_t
* ha
, ips_scb_t
* scb
)
4287 IPS_SCSI_INQ_DATA inquiry
;
4289 METHOD_TRACE("ips_inquiry", 1);
4291 memset(&inquiry
, 0, sizeof (IPS_SCSI_INQ_DATA
));
4293 inquiry
.DeviceType
= IPS_SCSI_INQ_TYPE_DASD
;
4294 inquiry
.DeviceTypeQualifier
= IPS_SCSI_INQ_LU_CONNECTED
;
4295 inquiry
.Version
= IPS_SCSI_INQ_REV2
;
4296 inquiry
.ResponseDataFormat
= IPS_SCSI_INQ_RD_REV2
;
4297 inquiry
.AdditionalLength
= 31;
4298 inquiry
.Flags
[0] = IPS_SCSI_INQ_Address16
;
4300 IPS_SCSI_INQ_WBus16
| IPS_SCSI_INQ_Sync
| IPS_SCSI_INQ_CmdQue
;
4301 strncpy(inquiry
.VendorId
, "IBM ", 8);
4302 strncpy(inquiry
.ProductId
, "SERVERAID ", 16);
4303 strncpy(inquiry
.ProductRevisionLevel
, "1.00", 4);
4305 ips_scmd_buf_write(scb
->scsi_cmd
, &inquiry
, sizeof (inquiry
));
4310 /****************************************************************************/
4312 /* Routine Name: ips_rdcap */
4314 /* Routine Description: */
4316 /* Simulate a read capacity command to a logical drive */
4318 /****************************************************************************/
4320 ips_rdcap(ips_ha_t
* ha
, ips_scb_t
* scb
)
4322 IPS_SCSI_CAPACITY cap
;
4324 METHOD_TRACE("ips_rdcap", 1);
4326 if (scb
->scsi_cmd
->bufflen
< 8)
4330 cpu_to_be32(le32_to_cpu
4331 (ha
->logical_drive_info
->
4332 drive_info
[scb
->target_id
].sector_count
) - 1);
4333 cap
.len
= cpu_to_be32((uint32_t) IPS_BLKSIZE
);
4335 ips_scmd_buf_write(scb
->scsi_cmd
, &cap
, sizeof (cap
));
4340 /****************************************************************************/
4342 /* Routine Name: ips_msense */
4344 /* Routine Description: */
4346 /* Simulate a mode sense command to a logical drive */
4348 /****************************************************************************/
4350 ips_msense(ips_ha_t
* ha
, ips_scb_t
* scb
)
4355 IPS_SCSI_MODE_PAGE_DATA mdata
;
4357 METHOD_TRACE("ips_msense", 1);
4359 if (le32_to_cpu(ha
->enq
->ulDriveSize
[scb
->target_id
]) > 0x400000 &&
4360 (ha
->enq
->ucMiscFlag
& 0x8) == 0) {
4361 heads
= IPS_NORM_HEADS
;
4362 sectors
= IPS_NORM_SECTORS
;
4364 heads
= IPS_COMP_HEADS
;
4365 sectors
= IPS_COMP_SECTORS
;
4369 (le32_to_cpu(ha
->enq
->ulDriveSize
[scb
->target_id
]) -
4370 1) / (heads
* sectors
);
4372 memset(&mdata
, 0, sizeof (IPS_SCSI_MODE_PAGE_DATA
));
4374 mdata
.hdr
.BlockDescLength
= 8;
4376 switch (scb
->scsi_cmd
->cmnd
[2] & 0x3f) {
4377 case 0x03: /* page 3 */
4378 mdata
.pdata
.pg3
.PageCode
= 3;
4379 mdata
.pdata
.pg3
.PageLength
= sizeof (IPS_SCSI_MODE_PAGE3
);
4380 mdata
.hdr
.DataLength
=
4381 3 + mdata
.hdr
.BlockDescLength
+ mdata
.pdata
.pg3
.PageLength
;
4382 mdata
.pdata
.pg3
.TracksPerZone
= 0;
4383 mdata
.pdata
.pg3
.AltSectorsPerZone
= 0;
4384 mdata
.pdata
.pg3
.AltTracksPerZone
= 0;
4385 mdata
.pdata
.pg3
.AltTracksPerVolume
= 0;
4386 mdata
.pdata
.pg3
.SectorsPerTrack
= cpu_to_be16(sectors
);
4387 mdata
.pdata
.pg3
.BytesPerSector
= cpu_to_be16(IPS_BLKSIZE
);
4388 mdata
.pdata
.pg3
.Interleave
= cpu_to_be16(1);
4389 mdata
.pdata
.pg3
.TrackSkew
= 0;
4390 mdata
.pdata
.pg3
.CylinderSkew
= 0;
4391 mdata
.pdata
.pg3
.flags
= IPS_SCSI_MP3_SoftSector
;
4395 mdata
.pdata
.pg4
.PageCode
= 4;
4396 mdata
.pdata
.pg4
.PageLength
= sizeof (IPS_SCSI_MODE_PAGE4
);
4397 mdata
.hdr
.DataLength
=
4398 3 + mdata
.hdr
.BlockDescLength
+ mdata
.pdata
.pg4
.PageLength
;
4399 mdata
.pdata
.pg4
.CylindersHigh
=
4400 cpu_to_be16((cylinders
>> 8) & 0xFFFF);
4401 mdata
.pdata
.pg4
.CylindersLow
= (cylinders
& 0xFF);
4402 mdata
.pdata
.pg4
.Heads
= heads
;
4403 mdata
.pdata
.pg4
.WritePrecompHigh
= 0;
4404 mdata
.pdata
.pg4
.WritePrecompLow
= 0;
4405 mdata
.pdata
.pg4
.ReducedWriteCurrentHigh
= 0;
4406 mdata
.pdata
.pg4
.ReducedWriteCurrentLow
= 0;
4407 mdata
.pdata
.pg4
.StepRate
= cpu_to_be16(1);
4408 mdata
.pdata
.pg4
.LandingZoneHigh
= 0;
4409 mdata
.pdata
.pg4
.LandingZoneLow
= 0;
4410 mdata
.pdata
.pg4
.flags
= 0;
4411 mdata
.pdata
.pg4
.RotationalOffset
= 0;
4412 mdata
.pdata
.pg4
.MediumRotationRate
= 0;
4415 mdata
.pdata
.pg8
.PageCode
= 8;
4416 mdata
.pdata
.pg8
.PageLength
= sizeof (IPS_SCSI_MODE_PAGE8
);
4417 mdata
.hdr
.DataLength
=
4418 3 + mdata
.hdr
.BlockDescLength
+ mdata
.pdata
.pg8
.PageLength
;
4419 /* everything else is left set to 0 */
4426 ips_scmd_buf_write(scb
->scsi_cmd
, &mdata
, sizeof (mdata
));
4431 /****************************************************************************/
4433 /* Routine Name: ips_reqsen */
4435 /* Routine Description: */
4437 /* Simulate a request sense command to a logical drive */
4439 /****************************************************************************/
4441 ips_reqsen(ips_ha_t
* ha
, ips_scb_t
* scb
)
4443 IPS_SCSI_REQSEN reqsen
;
4445 METHOD_TRACE("ips_reqsen", 1);
4447 memset(&reqsen
, 0, sizeof (IPS_SCSI_REQSEN
));
4449 reqsen
.ResponseCode
=
4450 IPS_SCSI_REQSEN_VALID
| IPS_SCSI_REQSEN_CURRENT_ERR
;
4451 reqsen
.AdditionalLength
= 10;
4452 reqsen
.AdditionalSenseCode
= IPS_SCSI_REQSEN_NO_SENSE
;
4453 reqsen
.AdditionalSenseCodeQual
= IPS_SCSI_REQSEN_NO_SENSE
;
4455 ips_scmd_buf_write(scb
->scsi_cmd
, &reqsen
, sizeof (reqsen
));
4460 /****************************************************************************/
4462 /* Routine Name: ips_free */
4464 /* Routine Description: */
4466 /* Free any allocated space for this controller */
4468 /****************************************************************************/
4470 ips_free(ips_ha_t
* ha
)
4473 METHOD_TRACE("ips_free", 1);
4477 pci_free_consistent(ha
->pcidev
, sizeof(IPS_ENQ
),
4478 ha
->enq
, ha
->enq_busaddr
);
4488 pci_free_consistent(ha
->pcidev
,
4489 sizeof (IPS_ADAPTER
) +
4490 sizeof (IPS_IO_CMD
), ha
->adapt
,
4491 ha
->adapt
->hw_status_start
);
4495 if (ha
->logical_drive_info
) {
4496 pci_free_consistent(ha
->pcidev
,
4497 sizeof (IPS_LD_INFO
),
4498 ha
->logical_drive_info
,
4499 ha
->logical_drive_info_dma_addr
);
4500 ha
->logical_drive_info
= NULL
;
4513 if (ha
->ioctl_data
) {
4514 pci_free_consistent(ha
->pcidev
, ha
->ioctl_len
,
4515 ha
->ioctl_data
, ha
->ioctl_busaddr
);
4516 ha
->ioctl_data
= NULL
;
4517 ha
->ioctl_datasize
= 0;
4520 ips_deallocatescbs(ha
, ha
->max_cmds
);
4522 /* free memory mapped (if applicable) */
4524 iounmap(ha
->ioremap_ptr
);
4525 ha
->ioremap_ptr
= NULL
;
4530 release_mem_region(ha
->mem_addr
, ha
->mem_len
);
4536 /****************************************************************************/
4538 /* Routine Name: ips_deallocatescbs */
4540 /* Routine Description: */
4542 /* Free the command blocks */
4544 /****************************************************************************/
4546 ips_deallocatescbs(ips_ha_t
* ha
, int cmds
)
4549 pci_free_consistent(ha
->pcidev
,
4550 IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
* cmds
,
4551 ha
->scbs
->sg_list
.list
,
4552 ha
->scbs
->sg_busaddr
);
4553 pci_free_consistent(ha
->pcidev
, sizeof (ips_scb_t
) * cmds
,
4554 ha
->scbs
, ha
->scbs
->scb_busaddr
);
4560 /****************************************************************************/
4562 /* Routine Name: ips_allocatescbs */
4564 /* Routine Description: */
4566 /* Allocate the command blocks */
4568 /****************************************************************************/
4570 ips_allocatescbs(ips_ha_t
* ha
)
4575 dma_addr_t command_dma
, sg_dma
;
4577 METHOD_TRACE("ips_allocatescbs", 1);
4579 /* Allocate memory for the SCBs */
4581 pci_alloc_consistent(ha
->pcidev
, ha
->max_cmds
* sizeof (ips_scb_t
),
4583 if (ha
->scbs
== NULL
)
4586 pci_alloc_consistent(ha
->pcidev
,
4587 IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
*
4588 ha
->max_cmds
, &sg_dma
);
4589 if (ips_sg
.list
== NULL
) {
4590 pci_free_consistent(ha
->pcidev
,
4591 ha
->max_cmds
* sizeof (ips_scb_t
), ha
->scbs
,
4596 memset(ha
->scbs
, 0, ha
->max_cmds
* sizeof (ips_scb_t
));
4598 for (i
= 0; i
< ha
->max_cmds
; i
++) {
4599 scb_p
= &ha
->scbs
[i
];
4600 scb_p
->scb_busaddr
= command_dma
+ sizeof (ips_scb_t
) * i
;
4601 /* set up S/G list */
4602 if (IPS_USE_ENH_SGLIST(ha
)) {
4603 scb_p
->sg_list
.enh_list
=
4604 ips_sg
.enh_list
+ i
* IPS_MAX_SG
;
4606 sg_dma
+ IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
* i
;
4608 scb_p
->sg_list
.std_list
=
4609 ips_sg
.std_list
+ i
* IPS_MAX_SG
;
4611 sg_dma
+ IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
* i
;
4614 /* add to the free list */
4615 if (i
< ha
->max_cmds
- 1) {
4616 scb_p
->q_next
= ha
->scb_freelist
;
4617 ha
->scb_freelist
= scb_p
;
4625 /****************************************************************************/
4627 /* Routine Name: ips_init_scb */
4629 /* Routine Description: */
4631 /* Initialize a CCB to default values */
4633 /****************************************************************************/
4635 ips_init_scb(ips_ha_t
* ha
, ips_scb_t
* scb
)
4637 IPS_SG_LIST sg_list
;
4638 uint32_t cmd_busaddr
, sg_busaddr
;
4639 METHOD_TRACE("ips_init_scb", 1);
4644 sg_list
.list
= scb
->sg_list
.list
;
4645 cmd_busaddr
= scb
->scb_busaddr
;
4646 sg_busaddr
= scb
->sg_busaddr
;
4648 memset(scb
, 0, sizeof (ips_scb_t
));
4649 memset(ha
->dummy
, 0, sizeof (IPS_IO_CMD
));
4651 /* Initialize dummy command bucket */
4652 ha
->dummy
->op_code
= 0xFF;
4653 ha
->dummy
->ccsar
= cpu_to_le32(ha
->adapt
->hw_status_start
4654 + sizeof (IPS_ADAPTER
));
4655 ha
->dummy
->command_id
= IPS_MAX_CMDS
;
4657 /* set bus address of scb */
4658 scb
->scb_busaddr
= cmd_busaddr
;
4659 scb
->sg_busaddr
= sg_busaddr
;
4660 scb
->sg_list
.list
= sg_list
.list
;
4663 scb
->cmd
.basic_io
.cccr
= cpu_to_le32((uint32_t) IPS_BIT_ILE
);
4664 scb
->cmd
.basic_io
.ccsar
= cpu_to_le32(ha
->adapt
->hw_status_start
4665 + sizeof (IPS_ADAPTER
));
4668 /****************************************************************************/
4670 /* Routine Name: ips_get_scb */
4672 /* Routine Description: */
4674 /* Initialize a CCB to default values */
4676 /* ASSUMED to be callled from within a lock */
4678 /****************************************************************************/
4680 ips_getscb(ips_ha_t
* ha
)
4684 METHOD_TRACE("ips_getscb", 1);
4686 if ((scb
= ha
->scb_freelist
) == NULL
) {
4691 ha
->scb_freelist
= scb
->q_next
;
4695 ips_init_scb(ha
, scb
);
4700 /****************************************************************************/
4702 /* Routine Name: ips_free_scb */
4704 /* Routine Description: */
4706 /* Return an unused CCB back to the free list */
4708 /* ASSUMED to be called from within a lock */
4710 /****************************************************************************/
4712 ips_freescb(ips_ha_t
* ha
, ips_scb_t
* scb
)
4715 METHOD_TRACE("ips_freescb", 1);
4716 if (scb
->flags
& IPS_SCB_MAP_SG
)
4717 pci_unmap_sg(ha
->pcidev
, scb
->scsi_cmd
->request_buffer
,
4718 scb
->scsi_cmd
->use_sg
, IPS_DMA_DIR(scb
));
4719 else if (scb
->flags
& IPS_SCB_MAP_SINGLE
)
4720 pci_unmap_single(ha
->pcidev
, scb
->data_busaddr
, scb
->data_len
,
4723 /* check to make sure this is not our "special" scb */
4724 if (IPS_COMMAND_ID(ha
, scb
) < (ha
->max_cmds
- 1)) {
4725 scb
->q_next
= ha
->scb_freelist
;
4726 ha
->scb_freelist
= scb
;
4730 /****************************************************************************/
4732 /* Routine Name: ips_isinit_copperhead */
4734 /* Routine Description: */
4736 /* Is controller initialized ? */
4738 /****************************************************************************/
4740 ips_isinit_copperhead(ips_ha_t
* ha
)
4745 METHOD_TRACE("ips_isinit_copperhead", 1);
4747 isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
4748 scpr
= inb(ha
->io_addr
+ IPS_REG_SCPR
);
4750 if (((isr
& IPS_BIT_EI
) == 0) && ((scpr
& IPS_BIT_EBM
) == 0))
4756 /****************************************************************************/
4758 /* Routine Name: ips_isinit_copperhead_memio */
4760 /* Routine Description: */
4762 /* Is controller initialized ? */
4764 /****************************************************************************/
4766 ips_isinit_copperhead_memio(ips_ha_t
* ha
)
4771 METHOD_TRACE("ips_is_init_copperhead_memio", 1);
4773 isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
4774 scpr
= readb(ha
->mem_ptr
+ IPS_REG_SCPR
);
4776 if (((isr
& IPS_BIT_EI
) == 0) && ((scpr
& IPS_BIT_EBM
) == 0))
4782 /****************************************************************************/
4784 /* Routine Name: ips_isinit_morpheus */
4786 /* Routine Description: */
4788 /* Is controller initialized ? */
4790 /****************************************************************************/
4792 ips_isinit_morpheus(ips_ha_t
* ha
)
4797 METHOD_TRACE("ips_is_init_morpheus", 1);
4799 post
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG0
);
4800 bits
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
4804 else if (bits
& 0x3)
4810 /****************************************************************************/
4812 /* Routine Name: ips_enable_int_copperhead */
4814 /* Routine Description: */
4815 /* Turn on interrupts */
4817 /****************************************************************************/
4819 ips_enable_int_copperhead(ips_ha_t
* ha
)
4821 METHOD_TRACE("ips_enable_int_copperhead", 1);
4823 outb(ha
->io_addr
+ IPS_REG_HISR
, IPS_BIT_EI
);
4824 inb(ha
->io_addr
+ IPS_REG_HISR
); /*Ensure PCI Posting Completes*/
4827 /****************************************************************************/
4829 /* Routine Name: ips_enable_int_copperhead_memio */
4831 /* Routine Description: */
4832 /* Turn on interrupts */
4834 /****************************************************************************/
4836 ips_enable_int_copperhead_memio(ips_ha_t
* ha
)
4838 METHOD_TRACE("ips_enable_int_copperhead_memio", 1);
4840 writeb(IPS_BIT_EI
, ha
->mem_ptr
+ IPS_REG_HISR
);
4841 readb(ha
->mem_ptr
+ IPS_REG_HISR
); /*Ensure PCI Posting Completes*/
4844 /****************************************************************************/
4846 /* Routine Name: ips_enable_int_morpheus */
4848 /* Routine Description: */
4849 /* Turn on interrupts */
4851 /****************************************************************************/
4853 ips_enable_int_morpheus(ips_ha_t
* ha
)
4857 METHOD_TRACE("ips_enable_int_morpheus", 1);
4859 Oimr
= readl(ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
4861 writel(Oimr
, ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
4862 readl(ha
->mem_ptr
+ IPS_REG_I960_OIMR
); /*Ensure PCI Posting Completes*/
4865 /****************************************************************************/
4867 /* Routine Name: ips_init_copperhead */
4869 /* Routine Description: */
4871 /* Initialize a copperhead controller */
4873 /****************************************************************************/
4875 ips_init_copperhead(ips_ha_t
* ha
)
4879 uint8_t PostByte
[IPS_MAX_POST_BYTES
];
4880 uint8_t ConfigByte
[IPS_MAX_CONFIG_BYTES
];
4883 METHOD_TRACE("ips_init_copperhead", 1);
4885 for (i
= 0; i
< IPS_MAX_POST_BYTES
; i
++) {
4886 for (j
= 0; j
< 45; j
++) {
4887 Isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
4888 if (Isr
& IPS_BIT_GHI
)
4891 /* Delay for 1 Second */
4892 MDELAY(IPS_ONE_SEC
);
4896 /* error occurred */
4899 PostByte
[i
] = inb(ha
->io_addr
+ IPS_REG_ISPR
);
4900 outb(Isr
, ha
->io_addr
+ IPS_REG_HISR
);
4903 if (PostByte
[0] < IPS_GOOD_POST_STATUS
) {
4904 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
4905 "reset controller fails (post status %x %x).\n",
4906 PostByte
[0], PostByte
[1]);
4911 for (i
= 0; i
< IPS_MAX_CONFIG_BYTES
; i
++) {
4912 for (j
= 0; j
< 240; j
++) {
4913 Isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
4914 if (Isr
& IPS_BIT_GHI
)
4917 /* Delay for 1 Second */
4918 MDELAY(IPS_ONE_SEC
);
4922 /* error occurred */
4925 ConfigByte
[i
] = inb(ha
->io_addr
+ IPS_REG_ISPR
);
4926 outb(Isr
, ha
->io_addr
+ IPS_REG_HISR
);
4929 for (i
= 0; i
< 240; i
++) {
4930 Cbsp
= inb(ha
->io_addr
+ IPS_REG_CBSP
);
4932 if ((Cbsp
& IPS_BIT_OP
) == 0)
4935 /* Delay for 1 Second */
4936 MDELAY(IPS_ONE_SEC
);
4944 outl(cpu_to_le32(0x1010), ha
->io_addr
+ IPS_REG_CCCR
);
4946 /* Enable busmastering */
4947 outb(IPS_BIT_EBM
, ha
->io_addr
+ IPS_REG_SCPR
);
4949 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
4950 /* fix for anaconda64 */
4951 outl(0, ha
->io_addr
+ IPS_REG_NDAE
);
4953 /* Enable interrupts */
4954 outb(IPS_BIT_EI
, ha
->io_addr
+ IPS_REG_HISR
);
4959 /****************************************************************************/
4961 /* Routine Name: ips_init_copperhead_memio */
4963 /* Routine Description: */
4965 /* Initialize a copperhead controller with memory mapped I/O */
4967 /****************************************************************************/
4969 ips_init_copperhead_memio(ips_ha_t
* ha
)
4973 uint8_t PostByte
[IPS_MAX_POST_BYTES
];
4974 uint8_t ConfigByte
[IPS_MAX_CONFIG_BYTES
];
4977 METHOD_TRACE("ips_init_copperhead_memio", 1);
4979 for (i
= 0; i
< IPS_MAX_POST_BYTES
; i
++) {
4980 for (j
= 0; j
< 45; j
++) {
4981 Isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
4982 if (Isr
& IPS_BIT_GHI
)
4985 /* Delay for 1 Second */
4986 MDELAY(IPS_ONE_SEC
);
4990 /* error occurred */
4993 PostByte
[i
] = readb(ha
->mem_ptr
+ IPS_REG_ISPR
);
4994 writeb(Isr
, ha
->mem_ptr
+ IPS_REG_HISR
);
4997 if (PostByte
[0] < IPS_GOOD_POST_STATUS
) {
4998 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
4999 "reset controller fails (post status %x %x).\n",
5000 PostByte
[0], PostByte
[1]);
5005 for (i
= 0; i
< IPS_MAX_CONFIG_BYTES
; i
++) {
5006 for (j
= 0; j
< 240; j
++) {
5007 Isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
5008 if (Isr
& IPS_BIT_GHI
)
5011 /* Delay for 1 Second */
5012 MDELAY(IPS_ONE_SEC
);
5016 /* error occurred */
5019 ConfigByte
[i
] = readb(ha
->mem_ptr
+ IPS_REG_ISPR
);
5020 writeb(Isr
, ha
->mem_ptr
+ IPS_REG_HISR
);
5023 for (i
= 0; i
< 240; i
++) {
5024 Cbsp
= readb(ha
->mem_ptr
+ IPS_REG_CBSP
);
5026 if ((Cbsp
& IPS_BIT_OP
) == 0)
5029 /* Delay for 1 Second */
5030 MDELAY(IPS_ONE_SEC
);
5034 /* error occurred */
5038 writel(0x1010, ha
->mem_ptr
+ IPS_REG_CCCR
);
5040 /* Enable busmastering */
5041 writeb(IPS_BIT_EBM
, ha
->mem_ptr
+ IPS_REG_SCPR
);
5043 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
5044 /* fix for anaconda64 */
5045 writel(0, ha
->mem_ptr
+ IPS_REG_NDAE
);
5047 /* Enable interrupts */
5048 writeb(IPS_BIT_EI
, ha
->mem_ptr
+ IPS_REG_HISR
);
5050 /* if we get here then everything went OK */
5054 /****************************************************************************/
5056 /* Routine Name: ips_init_morpheus */
5058 /* Routine Description: */
5060 /* Initialize a morpheus controller */
5062 /****************************************************************************/
5064 ips_init_morpheus(ips_ha_t
* ha
)
5072 METHOD_TRACE("ips_init_morpheus", 1);
5074 /* Wait up to 45 secs for Post */
5075 for (i
= 0; i
< 45; i
++) {
5076 Isr
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5078 if (Isr
& IPS_BIT_I960_MSG0I
)
5081 /* Delay for 1 Second */
5082 MDELAY(IPS_ONE_SEC
);
5086 /* error occurred */
5087 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5088 "timeout waiting for post.\n");
5093 Post
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG0
);
5095 if (Post
== 0x4F00) { /* If Flashing the Battery PIC */
5096 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5097 "Flashing Battery PIC, Please wait ...\n");
5099 /* Clear the interrupt bit */
5100 Isr
= (uint32_t) IPS_BIT_I960_MSG0I
;
5101 writel(Isr
, ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5103 for (i
= 0; i
< 120; i
++) { /* Wait Up to 2 Min. for Completion */
5104 Post
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG0
);
5107 /* Delay for 1 Second */
5108 MDELAY(IPS_ONE_SEC
);
5112 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5113 "timeout waiting for Battery PIC Flash\n");
5119 /* Clear the interrupt bit */
5120 Isr
= (uint32_t) IPS_BIT_I960_MSG0I
;
5121 writel(Isr
, ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5123 if (Post
< (IPS_GOOD_POST_STATUS
<< 8)) {
5124 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5125 "reset controller fails (post status %x).\n", Post
);
5130 /* Wait up to 240 secs for config bytes */
5131 for (i
= 0; i
< 240; i
++) {
5132 Isr
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5134 if (Isr
& IPS_BIT_I960_MSG1I
)
5137 /* Delay for 1 Second */
5138 MDELAY(IPS_ONE_SEC
);
5142 /* error occurred */
5143 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5144 "timeout waiting for config.\n");
5149 Config
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG1
);
5151 /* Clear interrupt bit */
5152 Isr
= (uint32_t) IPS_BIT_I960_MSG1I
;
5153 writel(Isr
, ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5155 /* Turn on the interrupts */
5156 Oimr
= readl(ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
5158 writel(Oimr
, ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
5160 /* if we get here then everything went OK */
5162 /* Since we did a RESET, an EraseStripeLock may be needed */
5163 if (Post
== 0xEF10) {
5164 if ((Config
== 0x000F) || (Config
== 0x0009))
5165 ha
->requires_esl
= 1;
5171 /****************************************************************************/
5173 /* Routine Name: ips_reset_copperhead */
5175 /* Routine Description: */
5177 /* Reset the controller */
5179 /****************************************************************************/
5181 ips_reset_copperhead(ips_ha_t
* ha
)
5185 METHOD_TRACE("ips_reset_copperhead", 1);
5187 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead: io addr: %x, irq: %d",
5188 ips_name
, ha
->host_num
, ha
->io_addr
, ha
->irq
);
5192 while (reset_counter
< 2) {
5195 outb(IPS_BIT_RST
, ha
->io_addr
+ IPS_REG_SCPR
);
5197 /* Delay for 1 Second */
5198 MDELAY(IPS_ONE_SEC
);
5200 outb(0, ha
->io_addr
+ IPS_REG_SCPR
);
5202 /* Delay for 1 Second */
5203 MDELAY(IPS_ONE_SEC
);
5205 if ((*ha
->func
.init
) (ha
))
5207 else if (reset_counter
>= 2) {
5216 /****************************************************************************/
5218 /* Routine Name: ips_reset_copperhead_memio */
5220 /* Routine Description: */
5222 /* Reset the controller */
5224 /****************************************************************************/
5226 ips_reset_copperhead_memio(ips_ha_t
* ha
)
5230 METHOD_TRACE("ips_reset_copperhead_memio", 1);
5232 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead_memio: mem addr: %x, irq: %d",
5233 ips_name
, ha
->host_num
, ha
->mem_addr
, ha
->irq
);
5237 while (reset_counter
< 2) {
5240 writeb(IPS_BIT_RST
, ha
->mem_ptr
+ IPS_REG_SCPR
);
5242 /* Delay for 1 Second */
5243 MDELAY(IPS_ONE_SEC
);
5245 writeb(0, ha
->mem_ptr
+ IPS_REG_SCPR
);
5247 /* Delay for 1 Second */
5248 MDELAY(IPS_ONE_SEC
);
5250 if ((*ha
->func
.init
) (ha
))
5252 else if (reset_counter
>= 2) {
5261 /****************************************************************************/
5263 /* Routine Name: ips_reset_morpheus */
5265 /* Routine Description: */
5267 /* Reset the controller */
5269 /****************************************************************************/
5271 ips_reset_morpheus(ips_ha_t
* ha
)
5276 METHOD_TRACE("ips_reset_morpheus", 1);
5278 DEBUG_VAR(1, "(%s%d) ips_reset_morpheus: mem addr: %x, irq: %d",
5279 ips_name
, ha
->host_num
, ha
->mem_addr
, ha
->irq
);
5283 while (reset_counter
< 2) {
5286 writel(0x80000000, ha
->mem_ptr
+ IPS_REG_I960_IDR
);
5288 /* Delay for 5 Seconds */
5289 MDELAY(5 * IPS_ONE_SEC
);
5291 /* Do a PCI config read to wait for adapter */
5292 pci_read_config_byte(ha
->pcidev
, 4, &junk
);
5294 if ((*ha
->func
.init
) (ha
))
5296 else if (reset_counter
>= 2) {
5305 /****************************************************************************/
5307 /* Routine Name: ips_statinit */
5309 /* Routine Description: */
5311 /* Initialize the status queues on the controller */
5313 /****************************************************************************/
5315 ips_statinit(ips_ha_t
* ha
)
5317 uint32_t phys_status_start
;
5319 METHOD_TRACE("ips_statinit", 1);
5321 ha
->adapt
->p_status_start
= ha
->adapt
->status
;
5322 ha
->adapt
->p_status_end
= ha
->adapt
->status
+ IPS_MAX_CMDS
;
5323 ha
->adapt
->p_status_tail
= ha
->adapt
->status
;
5325 phys_status_start
= ha
->adapt
->hw_status_start
;
5326 outl(cpu_to_le32(phys_status_start
), ha
->io_addr
+ IPS_REG_SQSR
);
5327 outl(cpu_to_le32(phys_status_start
+ IPS_STATUS_Q_SIZE
),
5328 ha
->io_addr
+ IPS_REG_SQER
);
5329 outl(cpu_to_le32(phys_status_start
+ IPS_STATUS_SIZE
),
5330 ha
->io_addr
+ IPS_REG_SQHR
);
5331 outl(cpu_to_le32(phys_status_start
), ha
->io_addr
+ IPS_REG_SQTR
);
5333 ha
->adapt
->hw_status_tail
= phys_status_start
;
5336 /****************************************************************************/
5338 /* Routine Name: ips_statinit_memio */
5340 /* Routine Description: */
5342 /* Initialize the status queues on the controller */
5344 /****************************************************************************/
5346 ips_statinit_memio(ips_ha_t
* ha
)
5348 uint32_t phys_status_start
;
5350 METHOD_TRACE("ips_statinit_memio", 1);
5352 ha
->adapt
->p_status_start
= ha
->adapt
->status
;
5353 ha
->adapt
->p_status_end
= ha
->adapt
->status
+ IPS_MAX_CMDS
;
5354 ha
->adapt
->p_status_tail
= ha
->adapt
->status
;
5356 phys_status_start
= ha
->adapt
->hw_status_start
;
5357 writel(phys_status_start
, ha
->mem_ptr
+ IPS_REG_SQSR
);
5358 writel(phys_status_start
+ IPS_STATUS_Q_SIZE
,
5359 ha
->mem_ptr
+ IPS_REG_SQER
);
5360 writel(phys_status_start
+ IPS_STATUS_SIZE
, ha
->mem_ptr
+ IPS_REG_SQHR
);
5361 writel(phys_status_start
, ha
->mem_ptr
+ IPS_REG_SQTR
);
5363 ha
->adapt
->hw_status_tail
= phys_status_start
;
5366 /****************************************************************************/
5368 /* Routine Name: ips_statupd_copperhead */
5370 /* Routine Description: */
5372 /* Remove an element from the status queue */
5374 /****************************************************************************/
5376 ips_statupd_copperhead(ips_ha_t
* ha
)
5378 METHOD_TRACE("ips_statupd_copperhead", 1);
5380 if (ha
->adapt
->p_status_tail
!= ha
->adapt
->p_status_end
) {
5381 ha
->adapt
->p_status_tail
++;
5382 ha
->adapt
->hw_status_tail
+= sizeof (IPS_STATUS
);
5384 ha
->adapt
->p_status_tail
= ha
->adapt
->p_status_start
;
5385 ha
->adapt
->hw_status_tail
= ha
->adapt
->hw_status_start
;
5388 outl(cpu_to_le32(ha
->adapt
->hw_status_tail
),
5389 ha
->io_addr
+ IPS_REG_SQTR
);
5391 return (ha
->adapt
->p_status_tail
->value
);
5394 /****************************************************************************/
5396 /* Routine Name: ips_statupd_copperhead_memio */
5398 /* Routine Description: */
5400 /* Remove an element from the status queue */
5402 /****************************************************************************/
5404 ips_statupd_copperhead_memio(ips_ha_t
* ha
)
5406 METHOD_TRACE("ips_statupd_copperhead_memio", 1);
5408 if (ha
->adapt
->p_status_tail
!= ha
->adapt
->p_status_end
) {
5409 ha
->adapt
->p_status_tail
++;
5410 ha
->adapt
->hw_status_tail
+= sizeof (IPS_STATUS
);
5412 ha
->adapt
->p_status_tail
= ha
->adapt
->p_status_start
;
5413 ha
->adapt
->hw_status_tail
= ha
->adapt
->hw_status_start
;
5416 writel(ha
->adapt
->hw_status_tail
, ha
->mem_ptr
+ IPS_REG_SQTR
);
5418 return (ha
->adapt
->p_status_tail
->value
);
5421 /****************************************************************************/
5423 /* Routine Name: ips_statupd_morpheus */
5425 /* Routine Description: */
5427 /* Remove an element from the status queue */
5429 /****************************************************************************/
5431 ips_statupd_morpheus(ips_ha_t
* ha
)
5435 METHOD_TRACE("ips_statupd_morpheus", 1);
5437 val
= readl(ha
->mem_ptr
+ IPS_REG_I2O_OUTMSGQ
);
5442 /****************************************************************************/
5444 /* Routine Name: ips_issue_copperhead */
5446 /* Routine Description: */
5448 /* Send a command down to the controller */
5450 /****************************************************************************/
5452 ips_issue_copperhead(ips_ha_t
* ha
, ips_scb_t
* scb
)
5457 METHOD_TRACE("ips_issue_copperhead", 1);
5459 if (scb
->scsi_cmd
) {
5460 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5464 scb
->cmd
.basic_io
.command_id
,
5465 scb
->bus
, scb
->target_id
, scb
->lun
);
5467 DEBUG_VAR(2, KERN_NOTICE
"(%s%d) ips_issue: logical cmd id %d",
5468 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5474 le32_to_cpu(inl(ha
->io_addr
+ IPS_REG_CCCR
))) & IPS_BIT_SEM
) {
5477 if (++TimeOut
>= IPS_SEM_TIMEOUT
) {
5478 if (!(val
& IPS_BIT_START_STOP
))
5481 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5482 "ips_issue val [0x%x].\n", val
);
5483 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5484 "ips_issue semaphore chk timeout.\n");
5486 return (IPS_FAILURE
);
5490 outl(cpu_to_le32(scb
->scb_busaddr
), ha
->io_addr
+ IPS_REG_CCSAR
);
5491 outw(cpu_to_le32(IPS_BIT_START_CMD
), ha
->io_addr
+ IPS_REG_CCCR
);
5493 return (IPS_SUCCESS
);
5496 /****************************************************************************/
5498 /* Routine Name: ips_issue_copperhead_memio */
5500 /* Routine Description: */
5502 /* Send a command down to the controller */
5504 /****************************************************************************/
5506 ips_issue_copperhead_memio(ips_ha_t
* ha
, ips_scb_t
* scb
)
5511 METHOD_TRACE("ips_issue_copperhead_memio", 1);
5513 if (scb
->scsi_cmd
) {
5514 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5518 scb
->cmd
.basic_io
.command_id
,
5519 scb
->bus
, scb
->target_id
, scb
->lun
);
5521 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5522 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5527 while ((val
= readl(ha
->mem_ptr
+ IPS_REG_CCCR
)) & IPS_BIT_SEM
) {
5530 if (++TimeOut
>= IPS_SEM_TIMEOUT
) {
5531 if (!(val
& IPS_BIT_START_STOP
))
5534 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5535 "ips_issue val [0x%x].\n", val
);
5536 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5537 "ips_issue semaphore chk timeout.\n");
5539 return (IPS_FAILURE
);
5543 writel(scb
->scb_busaddr
, ha
->mem_ptr
+ IPS_REG_CCSAR
);
5544 writel(IPS_BIT_START_CMD
, ha
->mem_ptr
+ IPS_REG_CCCR
);
5546 return (IPS_SUCCESS
);
5549 /****************************************************************************/
5551 /* Routine Name: ips_issue_i2o */
5553 /* Routine Description: */
5555 /* Send a command down to the controller */
5557 /****************************************************************************/
5559 ips_issue_i2o(ips_ha_t
* ha
, ips_scb_t
* scb
)
5562 METHOD_TRACE("ips_issue_i2o", 1);
5564 if (scb
->scsi_cmd
) {
5565 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5569 scb
->cmd
.basic_io
.command_id
,
5570 scb
->bus
, scb
->target_id
, scb
->lun
);
5572 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5573 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5576 outl(cpu_to_le32(scb
->scb_busaddr
), ha
->io_addr
+ IPS_REG_I2O_INMSGQ
);
5578 return (IPS_SUCCESS
);
5581 /****************************************************************************/
5583 /* Routine Name: ips_issue_i2o_memio */
5585 /* Routine Description: */
5587 /* Send a command down to the controller */
5589 /****************************************************************************/
5591 ips_issue_i2o_memio(ips_ha_t
* ha
, ips_scb_t
* scb
)
5594 METHOD_TRACE("ips_issue_i2o_memio", 1);
5596 if (scb
->scsi_cmd
) {
5597 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5601 scb
->cmd
.basic_io
.command_id
,
5602 scb
->bus
, scb
->target_id
, scb
->lun
);
5604 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5605 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5608 writel(scb
->scb_busaddr
, ha
->mem_ptr
+ IPS_REG_I2O_INMSGQ
);
5610 return (IPS_SUCCESS
);
5613 /****************************************************************************/
5615 /* Routine Name: ips_isintr_copperhead */
5617 /* Routine Description: */
5619 /* Test to see if an interrupt is for us */
5621 /****************************************************************************/
5623 ips_isintr_copperhead(ips_ha_t
* ha
)
5627 METHOD_TRACE("ips_isintr_copperhead", 2);
5629 Isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
5632 /* ?!?! Nothing really there */
5635 if (Isr
& IPS_BIT_SCE
)
5637 else if (Isr
& (IPS_BIT_SQO
| IPS_BIT_GHI
)) {
5638 /* status queue overflow or GHI */
5639 /* just clear the interrupt */
5640 outb(Isr
, ha
->io_addr
+ IPS_REG_HISR
);
5646 /****************************************************************************/
5648 /* Routine Name: ips_isintr_copperhead_memio */
5650 /* Routine Description: */
5652 /* Test to see if an interrupt is for us */
5654 /****************************************************************************/
5656 ips_isintr_copperhead_memio(ips_ha_t
* ha
)
5660 METHOD_TRACE("ips_isintr_memio", 2);
5662 Isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
5665 /* ?!?! Nothing really there */
5668 if (Isr
& IPS_BIT_SCE
)
5670 else if (Isr
& (IPS_BIT_SQO
| IPS_BIT_GHI
)) {
5671 /* status queue overflow or GHI */
5672 /* just clear the interrupt */
5673 writeb(Isr
, ha
->mem_ptr
+ IPS_REG_HISR
);
5679 /****************************************************************************/
5681 /* Routine Name: ips_isintr_morpheus */
5683 /* Routine Description: */
5685 /* Test to see if an interrupt is for us */
5687 /****************************************************************************/
5689 ips_isintr_morpheus(ips_ha_t
* ha
)
5693 METHOD_TRACE("ips_isintr_morpheus", 2);
5695 Isr
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5697 if (Isr
& IPS_BIT_I2O_OPQI
)
5703 /****************************************************************************/
5705 /* Routine Name: ips_wait */
5707 /* Routine Description: */
5709 /* Wait for a command to complete */
5711 /****************************************************************************/
5713 ips_wait(ips_ha_t
* ha
, int time
, int intr
)
5718 METHOD_TRACE("ips_wait", 1);
5723 time
*= IPS_ONE_SEC
; /* convert seconds */
5725 while ((time
> 0) && (!done
)) {
5726 if (intr
== IPS_INTR_ON
) {
5727 if (ha
->waitflag
== FALSE
) {
5732 } else if (intr
== IPS_INTR_IORL
) {
5733 if (ha
->waitflag
== FALSE
) {
5735 * controller generated an interrupt to
5736 * acknowledge completion of the command
5737 * and ips_intr() has serviced the interrupt.
5745 * NOTE: we already have the io_request_lock so
5746 * even if we get an interrupt it won't get serviced
5747 * until after we finish.
5750 (*ha
->func
.intr
) (ha
);
5753 /* This looks like a very evil loop, but it only does this during start-up */
5761 /****************************************************************************/
5763 /* Routine Name: ips_write_driver_status */
5765 /* Routine Description: */
5767 /* Write OS/Driver version to Page 5 of the nvram on the controller */
5769 /****************************************************************************/
5771 ips_write_driver_status(ips_ha_t
* ha
, int intr
)
5773 METHOD_TRACE("ips_write_driver_status", 1);
5775 if (!ips_readwrite_page5(ha
, FALSE
, intr
)) {
5776 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5777 "unable to read NVRAM page 5.\n");
5782 /* check to make sure the page has a valid */
5784 if (le32_to_cpu(ha
->nvram
->signature
) != IPS_NVRAM_P5_SIG
) {
5786 "(%s%d) NVRAM page 5 has an invalid signature: %X.",
5787 ips_name
, ha
->host_num
, ha
->nvram
->signature
);
5788 ha
->nvram
->signature
= IPS_NVRAM_P5_SIG
;
5792 "(%s%d) Ad Type: %d, Ad Slot: %d, BIOS: %c%c%c%c %c%c%c%c.",
5793 ips_name
, ha
->host_num
, le16_to_cpu(ha
->nvram
->adapter_type
),
5794 ha
->nvram
->adapter_slot
, ha
->nvram
->bios_high
[0],
5795 ha
->nvram
->bios_high
[1], ha
->nvram
->bios_high
[2],
5796 ha
->nvram
->bios_high
[3], ha
->nvram
->bios_low
[0],
5797 ha
->nvram
->bios_low
[1], ha
->nvram
->bios_low
[2],
5798 ha
->nvram
->bios_low
[3]);
5800 ips_get_bios_version(ha
, intr
);
5802 /* change values (as needed) */
5803 ha
->nvram
->operating_system
= IPS_OS_LINUX
;
5804 ha
->nvram
->adapter_type
= ha
->ad_type
;
5805 strncpy((char *) ha
->nvram
->driver_high
, IPS_VERSION_HIGH
, 4);
5806 strncpy((char *) ha
->nvram
->driver_low
, IPS_VERSION_LOW
, 4);
5807 strncpy((char *) ha
->nvram
->bios_high
, ha
->bios_version
, 4);
5808 strncpy((char *) ha
->nvram
->bios_low
, ha
->bios_version
+ 4, 4);
5810 ips_version_check(ha
, intr
); /* Check BIOS/FW/Driver Versions */
5812 /* now update the page */
5813 if (!ips_readwrite_page5(ha
, TRUE
, intr
)) {
5814 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5815 "unable to write NVRAM page 5.\n");
5820 /* IF NVRAM Page 5 is OK, Use it for Slot Number Info Because Linux Doesn't Do Slots */
5821 ha
->slot_num
= ha
->nvram
->adapter_slot
;
5826 /****************************************************************************/
5828 /* Routine Name: ips_read_adapter_status */
5830 /* Routine Description: */
5832 /* Do an Inquiry command to the adapter */
5834 /****************************************************************************/
5836 ips_read_adapter_status(ips_ha_t
* ha
, int intr
)
5841 METHOD_TRACE("ips_read_adapter_status", 1);
5843 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5845 ips_init_scb(ha
, scb
);
5847 scb
->timeout
= ips_cmd_timeout
;
5848 scb
->cdb
[0] = IPS_CMD_ENQUIRY
;
5850 scb
->cmd
.basic_io
.op_code
= IPS_CMD_ENQUIRY
;
5851 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5852 scb
->cmd
.basic_io
.sg_count
= 0;
5853 scb
->cmd
.basic_io
.lba
= 0;
5854 scb
->cmd
.basic_io
.sector_count
= 0;
5855 scb
->cmd
.basic_io
.log_drv
= 0;
5856 scb
->data_len
= sizeof (*ha
->enq
);
5857 scb
->cmd
.basic_io
.sg_addr
= ha
->enq_busaddr
;
5861 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
5862 || (ret
== IPS_SUCCESS_IMM
)
5863 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
5869 /****************************************************************************/
5871 /* Routine Name: ips_read_subsystem_parameters */
5873 /* Routine Description: */
5875 /* Read subsystem parameters from the adapter */
5877 /****************************************************************************/
5879 ips_read_subsystem_parameters(ips_ha_t
* ha
, int intr
)
5884 METHOD_TRACE("ips_read_subsystem_parameters", 1);
5886 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5888 ips_init_scb(ha
, scb
);
5890 scb
->timeout
= ips_cmd_timeout
;
5891 scb
->cdb
[0] = IPS_CMD_GET_SUBSYS
;
5893 scb
->cmd
.basic_io
.op_code
= IPS_CMD_GET_SUBSYS
;
5894 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5895 scb
->cmd
.basic_io
.sg_count
= 0;
5896 scb
->cmd
.basic_io
.lba
= 0;
5897 scb
->cmd
.basic_io
.sector_count
= 0;
5898 scb
->cmd
.basic_io
.log_drv
= 0;
5899 scb
->data_len
= sizeof (*ha
->subsys
);
5900 scb
->cmd
.basic_io
.sg_addr
= ha
->ioctl_busaddr
;
5904 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
5905 || (ret
== IPS_SUCCESS_IMM
)
5906 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
5909 memcpy(ha
->subsys
, ha
->ioctl_data
, sizeof(*ha
->subsys
));
5913 /****************************************************************************/
5915 /* Routine Name: ips_read_config */
5917 /* Routine Description: */
5919 /* Read the configuration on the adapter */
5921 /****************************************************************************/
5923 ips_read_config(ips_ha_t
* ha
, int intr
)
5929 METHOD_TRACE("ips_read_config", 1);
5931 /* set defaults for initiator IDs */
5932 for (i
= 0; i
< 4; i
++)
5933 ha
->conf
->init_id
[i
] = 7;
5935 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5937 ips_init_scb(ha
, scb
);
5939 scb
->timeout
= ips_cmd_timeout
;
5940 scb
->cdb
[0] = IPS_CMD_READ_CONF
;
5942 scb
->cmd
.basic_io
.op_code
= IPS_CMD_READ_CONF
;
5943 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5944 scb
->data_len
= sizeof (*ha
->conf
);
5945 scb
->cmd
.basic_io
.sg_addr
= ha
->ioctl_busaddr
;
5949 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
5950 || (ret
== IPS_SUCCESS_IMM
)
5951 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1)) {
5953 memset(ha
->conf
, 0, sizeof (IPS_CONF
));
5955 /* reset initiator IDs */
5956 for (i
= 0; i
< 4; i
++)
5957 ha
->conf
->init_id
[i
] = 7;
5959 /* Allow Completed with Errors, so JCRM can access the Adapter to fix the problems */
5960 if ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) ==
5961 IPS_CMD_CMPLT_WERROR
)
5967 memcpy(ha
->conf
, ha
->ioctl_data
, sizeof(*ha
->conf
));
5971 /****************************************************************************/
5973 /* Routine Name: ips_readwrite_page5 */
5975 /* Routine Description: */
5977 /* Read nvram page 5 from the adapter */
5979 /****************************************************************************/
5981 ips_readwrite_page5(ips_ha_t
* ha
, int write
, int intr
)
5986 METHOD_TRACE("ips_readwrite_page5", 1);
5988 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5990 ips_init_scb(ha
, scb
);
5992 scb
->timeout
= ips_cmd_timeout
;
5993 scb
->cdb
[0] = IPS_CMD_RW_NVRAM_PAGE
;
5995 scb
->cmd
.nvram
.op_code
= IPS_CMD_RW_NVRAM_PAGE
;
5996 scb
->cmd
.nvram
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5997 scb
->cmd
.nvram
.page
= 5;
5998 scb
->cmd
.nvram
.write
= write
;
5999 scb
->cmd
.nvram
.reserved
= 0;
6000 scb
->cmd
.nvram
.reserved2
= 0;
6001 scb
->data_len
= sizeof (*ha
->nvram
);
6002 scb
->cmd
.nvram
.buffer_addr
= ha
->ioctl_busaddr
;
6004 memcpy(ha
->ioctl_data
, ha
->nvram
, sizeof(*ha
->nvram
));
6006 /* issue the command */
6008 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
6009 || (ret
== IPS_SUCCESS_IMM
)
6010 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1)) {
6012 memset(ha
->nvram
, 0, sizeof (IPS_NVRAM_P5
));
6017 memcpy(ha
->nvram
, ha
->ioctl_data
, sizeof(*ha
->nvram
));
6021 /****************************************************************************/
6023 /* Routine Name: ips_clear_adapter */
6025 /* Routine Description: */
6027 /* Clear the stripe lock tables */
6029 /****************************************************************************/
6031 ips_clear_adapter(ips_ha_t
* ha
, int intr
)
6036 METHOD_TRACE("ips_clear_adapter", 1);
6038 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
6040 ips_init_scb(ha
, scb
);
6042 scb
->timeout
= ips_reset_timeout
;
6043 scb
->cdb
[0] = IPS_CMD_CONFIG_SYNC
;
6045 scb
->cmd
.config_sync
.op_code
= IPS_CMD_CONFIG_SYNC
;
6046 scb
->cmd
.config_sync
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6047 scb
->cmd
.config_sync
.channel
= 0;
6048 scb
->cmd
.config_sync
.source_target
= IPS_POCL
;
6049 scb
->cmd
.config_sync
.reserved
= 0;
6050 scb
->cmd
.config_sync
.reserved2
= 0;
6051 scb
->cmd
.config_sync
.reserved3
= 0;
6055 ips_send_wait(ha
, scb
, ips_reset_timeout
, intr
)) == IPS_FAILURE
)
6056 || (ret
== IPS_SUCCESS_IMM
)
6057 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
6060 /* send unlock stripe command */
6061 ips_init_scb(ha
, scb
);
6063 scb
->cdb
[0] = IPS_CMD_ERROR_TABLE
;
6064 scb
->timeout
= ips_reset_timeout
;
6066 scb
->cmd
.unlock_stripe
.op_code
= IPS_CMD_ERROR_TABLE
;
6067 scb
->cmd
.unlock_stripe
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6068 scb
->cmd
.unlock_stripe
.log_drv
= 0;
6069 scb
->cmd
.unlock_stripe
.control
= IPS_CSL
;
6070 scb
->cmd
.unlock_stripe
.reserved
= 0;
6071 scb
->cmd
.unlock_stripe
.reserved2
= 0;
6072 scb
->cmd
.unlock_stripe
.reserved3
= 0;
6076 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
6077 || (ret
== IPS_SUCCESS_IMM
)
6078 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
6084 /****************************************************************************/
6086 /* Routine Name: ips_ffdc_reset */
6088 /* Routine Description: */
6090 /* FFDC: write reset info */
6092 /****************************************************************************/
6094 ips_ffdc_reset(ips_ha_t
* ha
, int intr
)
6098 METHOD_TRACE("ips_ffdc_reset", 1);
6100 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
6102 ips_init_scb(ha
, scb
);
6104 scb
->timeout
= ips_cmd_timeout
;
6105 scb
->cdb
[0] = IPS_CMD_FFDC
;
6106 scb
->cmd
.ffdc
.op_code
= IPS_CMD_FFDC
;
6107 scb
->cmd
.ffdc
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6108 scb
->cmd
.ffdc
.reset_count
= ha
->reset_count
;
6109 scb
->cmd
.ffdc
.reset_type
= 0x80;
6111 /* convert time to what the card wants */
6112 ips_fix_ffdc_time(ha
, scb
, ha
->last_ffdc
);
6115 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
);
6118 /****************************************************************************/
6120 /* Routine Name: ips_ffdc_time */
6122 /* Routine Description: */
6124 /* FFDC: write time info */
6126 /****************************************************************************/
6128 ips_ffdc_time(ips_ha_t
* ha
)
6132 METHOD_TRACE("ips_ffdc_time", 1);
6134 DEBUG_VAR(1, "(%s%d) Sending time update.", ips_name
, ha
->host_num
);
6136 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
6138 ips_init_scb(ha
, scb
);
6140 scb
->timeout
= ips_cmd_timeout
;
6141 scb
->cdb
[0] = IPS_CMD_FFDC
;
6142 scb
->cmd
.ffdc
.op_code
= IPS_CMD_FFDC
;
6143 scb
->cmd
.ffdc
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6144 scb
->cmd
.ffdc
.reset_count
= 0;
6145 scb
->cmd
.ffdc
.reset_type
= 0;
6147 /* convert time to what the card wants */
6148 ips_fix_ffdc_time(ha
, scb
, ha
->last_ffdc
);
6151 ips_send_wait(ha
, scb
, ips_cmd_timeout
, IPS_FFDC
);
6154 /****************************************************************************/
6156 /* Routine Name: ips_fix_ffdc_time */
6158 /* Routine Description: */
6159 /* Adjust time_t to what the card wants */
6161 /****************************************************************************/
6163 ips_fix_ffdc_time(ips_ha_t
* ha
, ips_scb_t
* scb
, time_t current_time
)
6170 int year_lengths
[2] = { IPS_DAYS_NORMAL_YEAR
, IPS_DAYS_LEAP_YEAR
};
6171 int month_lengths
[12][2] = { {31, 31},
6185 METHOD_TRACE("ips_fix_ffdc_time", 1);
6187 days
= current_time
/ IPS_SECS_DAY
;
6188 rem
= current_time
% IPS_SECS_DAY
;
6190 scb
->cmd
.ffdc
.hour
= (rem
/ IPS_SECS_HOUR
);
6191 rem
= rem
% IPS_SECS_HOUR
;
6192 scb
->cmd
.ffdc
.minute
= (rem
/ IPS_SECS_MIN
);
6193 scb
->cmd
.ffdc
.second
= (rem
% IPS_SECS_MIN
);
6195 year
= IPS_EPOCH_YEAR
;
6196 while (days
< 0 || days
>= year_lengths
[yleap
= IPS_IS_LEAP_YEAR(year
)]) {
6199 newy
= year
+ (days
/ IPS_DAYS_NORMAL_YEAR
);
6202 days
-= (newy
- year
) * IPS_DAYS_NORMAL_YEAR
+
6203 IPS_NUM_LEAP_YEARS_THROUGH(newy
- 1) -
6204 IPS_NUM_LEAP_YEARS_THROUGH(year
- 1);
6208 scb
->cmd
.ffdc
.yearH
= year
/ 100;
6209 scb
->cmd
.ffdc
.yearL
= year
% 100;
6211 for (i
= 0; days
>= month_lengths
[i
][yleap
]; ++i
)
6212 days
-= month_lengths
[i
][yleap
];
6214 scb
->cmd
.ffdc
.month
= i
+ 1;
6215 scb
->cmd
.ffdc
.day
= days
+ 1;
6218 /****************************************************************************
6219 * BIOS Flash Routines *
6220 ****************************************************************************/
6222 /****************************************************************************/
6224 /* Routine Name: ips_erase_bios */
6226 /* Routine Description: */
6227 /* Erase the BIOS on the adapter */
6229 /****************************************************************************/
6231 ips_erase_bios(ips_ha_t
* ha
)
6236 METHOD_TRACE("ips_erase_bios", 1);
6240 /* Clear the status register */
6241 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6242 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6243 udelay(25); /* 25 us */
6245 outb(0x50, ha
->io_addr
+ IPS_REG_FLDP
);
6246 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6247 udelay(25); /* 25 us */
6250 outb(0x20, ha
->io_addr
+ IPS_REG_FLDP
);
6251 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6252 udelay(25); /* 25 us */
6255 outb(0xD0, ha
->io_addr
+ IPS_REG_FLDP
);
6256 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6257 udelay(25); /* 25 us */
6260 outb(0x70, ha
->io_addr
+ IPS_REG_FLDP
);
6261 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6262 udelay(25); /* 25 us */
6264 timeout
= 80000; /* 80 seconds */
6266 while (timeout
> 0) {
6267 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6268 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6269 udelay(25); /* 25 us */
6272 status
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
6281 /* check for timeout */
6285 /* try to suspend the erase */
6286 outb(0xB0, ha
->io_addr
+ IPS_REG_FLDP
);
6287 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6288 udelay(25); /* 25 us */
6290 /* wait for 10 seconds */
6292 while (timeout
> 0) {
6293 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6294 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6295 udelay(25); /* 25 us */
6298 status
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
6310 /* check for valid VPP */
6315 /* check for succesful flash */
6317 /* sequence error */
6320 /* Otherwise, we were successful */
6322 outb(0x50, ha
->io_addr
+ IPS_REG_FLDP
);
6323 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6324 udelay(25); /* 25 us */
6327 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6328 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6329 udelay(25); /* 25 us */
6334 /****************************************************************************/
6336 /* Routine Name: ips_erase_bios_memio */
6338 /* Routine Description: */
6339 /* Erase the BIOS on the adapter */
6341 /****************************************************************************/
6343 ips_erase_bios_memio(ips_ha_t
* ha
)
6348 METHOD_TRACE("ips_erase_bios_memio", 1);
6352 /* Clear the status register */
6353 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6354 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6355 udelay(25); /* 25 us */
6357 writeb(0x50, ha
->mem_ptr
+ IPS_REG_FLDP
);
6358 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6359 udelay(25); /* 25 us */
6362 writeb(0x20, ha
->mem_ptr
+ IPS_REG_FLDP
);
6363 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6364 udelay(25); /* 25 us */
6367 writeb(0xD0, ha
->mem_ptr
+ IPS_REG_FLDP
);
6368 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6369 udelay(25); /* 25 us */
6372 writeb(0x70, ha
->mem_ptr
+ IPS_REG_FLDP
);
6373 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6374 udelay(25); /* 25 us */
6376 timeout
= 80000; /* 80 seconds */
6378 while (timeout
> 0) {
6379 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6380 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6381 udelay(25); /* 25 us */
6384 status
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6393 /* check for timeout */
6397 /* try to suspend the erase */
6398 writeb(0xB0, ha
->mem_ptr
+ IPS_REG_FLDP
);
6399 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6400 udelay(25); /* 25 us */
6402 /* wait for 10 seconds */
6404 while (timeout
> 0) {
6405 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6406 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6407 udelay(25); /* 25 us */
6410 status
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6422 /* check for valid VPP */
6427 /* check for succesful flash */
6429 /* sequence error */
6432 /* Otherwise, we were successful */
6434 writeb(0x50, ha
->mem_ptr
+ IPS_REG_FLDP
);
6435 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6436 udelay(25); /* 25 us */
6439 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6440 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6441 udelay(25); /* 25 us */
6446 /****************************************************************************/
6448 /* Routine Name: ips_program_bios */
6450 /* Routine Description: */
6451 /* Program the BIOS on the adapter */
6453 /****************************************************************************/
6455 ips_program_bios(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6462 METHOD_TRACE("ips_program_bios", 1);
6466 for (i
= 0; i
< buffersize
; i
++) {
6468 outl(cpu_to_le32(i
+ offset
), ha
->io_addr
+ IPS_REG_FLAP
);
6469 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6470 udelay(25); /* 25 us */
6472 outb(0x40, ha
->io_addr
+ IPS_REG_FLDP
);
6473 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6474 udelay(25); /* 25 us */
6476 outb(buffer
[i
], ha
->io_addr
+ IPS_REG_FLDP
);
6477 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6478 udelay(25); /* 25 us */
6480 /* wait up to one second */
6482 while (timeout
> 0) {
6483 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6484 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6485 udelay(25); /* 25 us */
6488 status
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
6499 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6500 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6501 udelay(25); /* 25 us */
6503 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6504 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6505 udelay(25); /* 25 us */
6510 /* check the status */
6511 if (status
& 0x18) {
6512 /* programming error */
6513 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6514 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6515 udelay(25); /* 25 us */
6517 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6518 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6519 udelay(25); /* 25 us */
6525 /* Enable reading */
6526 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6527 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6528 udelay(25); /* 25 us */
6530 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6531 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6532 udelay(25); /* 25 us */
6537 /****************************************************************************/
6539 /* Routine Name: ips_program_bios_memio */
6541 /* Routine Description: */
6542 /* Program the BIOS on the adapter */
6544 /****************************************************************************/
6546 ips_program_bios_memio(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6553 METHOD_TRACE("ips_program_bios_memio", 1);
6557 for (i
= 0; i
< buffersize
; i
++) {
6559 writel(i
+ offset
, ha
->mem_ptr
+ IPS_REG_FLAP
);
6560 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6561 udelay(25); /* 25 us */
6563 writeb(0x40, ha
->mem_ptr
+ IPS_REG_FLDP
);
6564 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6565 udelay(25); /* 25 us */
6567 writeb(buffer
[i
], ha
->mem_ptr
+ IPS_REG_FLDP
);
6568 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6569 udelay(25); /* 25 us */
6571 /* wait up to one second */
6573 while (timeout
> 0) {
6574 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6575 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6576 udelay(25); /* 25 us */
6579 status
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6590 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6591 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6592 udelay(25); /* 25 us */
6594 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6595 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6596 udelay(25); /* 25 us */
6601 /* check the status */
6602 if (status
& 0x18) {
6603 /* programming error */
6604 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6605 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6606 udelay(25); /* 25 us */
6608 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6609 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6610 udelay(25); /* 25 us */
6616 /* Enable reading */
6617 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6618 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6619 udelay(25); /* 25 us */
6621 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6622 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6623 udelay(25); /* 25 us */
6628 /****************************************************************************/
6630 /* Routine Name: ips_verify_bios */
6632 /* Routine Description: */
6633 /* Verify the BIOS on the adapter */
6635 /****************************************************************************/
6637 ips_verify_bios(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6643 METHOD_TRACE("ips_verify_bios", 1);
6646 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6647 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6648 udelay(25); /* 25 us */
6650 if (inb(ha
->io_addr
+ IPS_REG_FLDP
) != 0x55)
6653 outl(cpu_to_le32(1), ha
->io_addr
+ IPS_REG_FLAP
);
6654 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6655 udelay(25); /* 25 us */
6656 if (inb(ha
->io_addr
+ IPS_REG_FLDP
) != 0xAA)
6660 for (i
= 2; i
< buffersize
; i
++) {
6662 outl(cpu_to_le32(i
+ offset
), ha
->io_addr
+ IPS_REG_FLAP
);
6663 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6664 udelay(25); /* 25 us */
6666 checksum
= (uint8_t) checksum
+ inb(ha
->io_addr
+ IPS_REG_FLDP
);
6677 /****************************************************************************/
6679 /* Routine Name: ips_verify_bios_memio */
6681 /* Routine Description: */
6682 /* Verify the BIOS on the adapter */
6684 /****************************************************************************/
6686 ips_verify_bios_memio(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6692 METHOD_TRACE("ips_verify_bios_memio", 1);
6695 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6696 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6697 udelay(25); /* 25 us */
6699 if (readb(ha
->mem_ptr
+ IPS_REG_FLDP
) != 0x55)
6702 writel(1, ha
->mem_ptr
+ IPS_REG_FLAP
);
6703 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6704 udelay(25); /* 25 us */
6705 if (readb(ha
->mem_ptr
+ IPS_REG_FLDP
) != 0xAA)
6709 for (i
= 2; i
< buffersize
; i
++) {
6711 writel(i
+ offset
, ha
->mem_ptr
+ IPS_REG_FLAP
);
6712 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6713 udelay(25); /* 25 us */
6716 (uint8_t) checksum
+ readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6727 /*---------------------------------------------------------------------------*/
6728 /* Routine Name: ips_version_check */
6731 /* Assumes that ips_read_adapter_status() is called first filling in */
6732 /* the data for SubSystem Parameters. */
6733 /* Called from ips_write_driver_status() so it also assumes NVRAM Page 5 */
6734 /* Data is available. */
6736 /*---------------------------------------------------------------------------*/
6738 ips_version_check(ips_ha_t
* ha
, int intr
)
6740 IPS_VERSION_DATA
*VersionInfo
;
6741 uint8_t FirmwareVersion
[IPS_COMPAT_ID_LENGTH
+ 1];
6742 uint8_t BiosVersion
[IPS_COMPAT_ID_LENGTH
+ 1];
6745 char BiosString
[10];
6746 char FirmwareString
[10];
6748 METHOD_TRACE("ips_version_check", 1);
6750 VersionInfo
= ( IPS_VERSION_DATA
* ) ha
->ioctl_data
;
6752 memset(FirmwareVersion
, 0, IPS_COMPAT_ID_LENGTH
+ 1);
6753 memset(BiosVersion
, 0, IPS_COMPAT_ID_LENGTH
+ 1);
6755 /* Get the Compatible BIOS Version from NVRAM Page 5 */
6756 memcpy(BiosVersion
, ha
->nvram
->BiosCompatibilityID
,
6757 IPS_COMPAT_ID_LENGTH
);
6760 if (ha
->subsys
->param
[4] & IPS_GET_VERSION_SUPPORT
) { /* If Versioning is Supported */
6761 /* Get the Version Info with a Get Version Command */
6762 memset( VersionInfo
, 0, sizeof (IPS_VERSION_DATA
));
6763 rc
= ips_get_version_info(ha
, ha
->ioctl_busaddr
, intr
);
6764 if (rc
== IPS_SUCCESS
)
6765 memcpy(FirmwareVersion
, VersionInfo
->compatibilityId
,
6766 IPS_COMPAT_ID_LENGTH
);
6769 if (rc
!= IPS_SUCCESS
) { /* If Data Not Obtainable from a GetVersion Command */
6770 /* Get the Firmware Version from Enquiry Data */
6771 memcpy(FirmwareVersion
, ha
->enq
->CodeBlkVersion
,
6772 IPS_COMPAT_ID_LENGTH
);
6775 /* printk(KERN_WARNING "Adapter's BIOS Version = %s\n", BiosVersion); */
6776 /* printk(KERN_WARNING "BIOS Compatible Version = %s\n", IPS_COMPAT_BIOS); */
6777 /* printk(KERN_WARNING "Adapter's Firmware Version = %s\n", FirmwareVersion); */
6778 /* printk(KERN_WARNING "Firmware Compatible Version = %s \n", Compatable[ ha->nvram->adapter_type ]); */
6783 (FirmwareVersion
, Compatable
[ha
->nvram
->adapter_type
],
6784 IPS_COMPAT_ID_LENGTH
) != 0)
6787 if (strncmp(BiosVersion
, IPS_COMPAT_BIOS
, IPS_COMPAT_ID_LENGTH
) != 0)
6790 ha
->nvram
->versioning
= 1; /* Indicate the Driver Supports Versioning */
6793 ha
->nvram
->version_mismatch
= 1;
6794 if (ips_cd_boot
== 0) {
6795 strncpy(&BiosString
[0], ha
->nvram
->bios_high
, 4);
6796 strncpy(&BiosString
[4], ha
->nvram
->bios_low
, 4);
6799 strncpy(&FirmwareString
[0], ha
->enq
->CodeBlkVersion
, 8);
6800 FirmwareString
[8] = 0;
6802 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
6803 "Warning ! ! ! ServeRAID Version Mismatch\n");
6804 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
6805 "Bios = %s, Firmware = %s, Device Driver = %s%s\n",
6806 BiosString
, FirmwareString
, IPS_VERSION_HIGH
,
6808 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
6809 "These levels should match to avoid possible compatibility problems.\n");
6812 ha
->nvram
->version_mismatch
= 0;
6818 /*---------------------------------------------------------------------------*/
6819 /* Routine Name: ips_get_version_info */
6821 /* Routine Description: */
6822 /* Issue an internal GETVERSION Command */
6825 /* 0 if Successful, else non-zero */
6826 /*---------------------------------------------------------------------------*/
6828 ips_get_version_info(ips_ha_t
* ha
, dma_addr_t Buffer
, int intr
)
6833 METHOD_TRACE("ips_get_version_info", 1);
6835 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
6837 ips_init_scb(ha
, scb
);
6839 scb
->timeout
= ips_cmd_timeout
;
6840 scb
->cdb
[0] = IPS_CMD_GET_VERSION_INFO
;
6841 scb
->cmd
.version_info
.op_code
= IPS_CMD_GET_VERSION_INFO
;
6842 scb
->cmd
.version_info
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6843 scb
->cmd
.version_info
.reserved
= 0;
6844 scb
->cmd
.version_info
.count
= sizeof (IPS_VERSION_DATA
);
6845 scb
->cmd
.version_info
.reserved2
= 0;
6846 scb
->data_len
= sizeof (IPS_VERSION_DATA
);
6847 scb
->data_busaddr
= Buffer
;
6848 scb
->cmd
.version_info
.buffer_addr
= Buffer
;
6852 rc
= ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
);
6856 /****************************************************************************/
6858 /* Routine Name: ips_abort_init */
6860 /* Routine Description: */
6861 /* cleanup routine for a failed adapter initialization */
6862 /****************************************************************************/
6864 ips_abort_init(ips_ha_t
* ha
, int index
)
6868 ips_ha
[index
] = NULL
;
6869 ips_sh
[index
] = NULL
;
6873 /****************************************************************************/
6875 /* Routine Name: ips_shift_controllers */
6877 /* Routine Description: */
6878 /* helper function for ordering adapters */
6879 /****************************************************************************/
6881 ips_shift_controllers(int lowindex
, int highindex
)
6883 ips_ha_t
*ha_sav
= ips_ha
[highindex
];
6884 struct Scsi_Host
*sh_sav
= ips_sh
[highindex
];
6887 for (i
= highindex
; i
> lowindex
; i
--) {
6888 ips_ha
[i
] = ips_ha
[i
- 1];
6889 ips_sh
[i
] = ips_sh
[i
- 1];
6890 ips_ha
[i
]->host_num
= i
;
6892 ha_sav
->host_num
= lowindex
;
6893 ips_ha
[lowindex
] = ha_sav
;
6894 ips_sh
[lowindex
] = sh_sav
;
6897 /****************************************************************************/
6899 /* Routine Name: ips_order_controllers */
6901 /* Routine Description: */
6902 /* place controllers is the "proper" boot order */
6903 /****************************************************************************/
6905 ips_order_controllers(void)
6907 int i
, j
, tmp
, position
= 0;
6908 IPS_NVRAM_P5
*nvram
;
6911 nvram
= ips_ha
[0]->nvram
;
6913 if (nvram
->adapter_order
[0]) {
6914 for (i
= 1; i
<= nvram
->adapter_order
[0]; i
++) {
6915 for (j
= position
; j
< ips_num_controllers
; j
++) {
6916 switch (ips_ha
[j
]->ad_type
) {
6917 case IPS_ADTYPE_SERVERAID6M
:
6918 case IPS_ADTYPE_SERVERAID7M
:
6919 if (nvram
->adapter_order
[i
] == 'M') {
6920 ips_shift_controllers(position
,
6925 case IPS_ADTYPE_SERVERAID4L
:
6926 case IPS_ADTYPE_SERVERAID4M
:
6927 case IPS_ADTYPE_SERVERAID4MX
:
6928 case IPS_ADTYPE_SERVERAID4LX
:
6929 if (nvram
->adapter_order
[i
] == 'N') {
6930 ips_shift_controllers(position
,
6935 case IPS_ADTYPE_SERVERAID6I
:
6936 case IPS_ADTYPE_SERVERAID5I2
:
6937 case IPS_ADTYPE_SERVERAID5I1
:
6938 case IPS_ADTYPE_SERVERAID7k
:
6939 if (nvram
->adapter_order
[i
] == 'S') {
6940 ips_shift_controllers(position
,
6945 case IPS_ADTYPE_SERVERAID
:
6946 case IPS_ADTYPE_SERVERAID2
:
6947 case IPS_ADTYPE_NAVAJO
:
6948 case IPS_ADTYPE_KIOWA
:
6949 case IPS_ADTYPE_SERVERAID3L
:
6950 case IPS_ADTYPE_SERVERAID3
:
6951 case IPS_ADTYPE_SERVERAID4H
:
6952 if (nvram
->adapter_order
[i
] == 'A') {
6953 ips_shift_controllers(position
,
6963 /* if adapter_order[0], then ordering is complete */
6966 /* old bios, use older ordering */
6968 for (i
= position
; i
< ips_num_controllers
; i
++) {
6969 if (ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID5I2
||
6970 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID5I1
) {
6971 ips_shift_controllers(position
, i
);
6976 /* if there were no 5I cards, then don't do any extra ordering */
6979 for (i
= position
; i
< ips_num_controllers
; i
++) {
6980 if (ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4L
||
6981 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4M
||
6982 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4LX
||
6983 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4MX
) {
6984 ips_shift_controllers(position
, i
);
6992 /****************************************************************************/
6994 /* Routine Name: ips_register_scsi */
6996 /* Routine Description: */
6997 /* perform any registration and setup with the scsi layer */
6998 /****************************************************************************/
7000 ips_register_scsi(int index
)
7002 struct Scsi_Host
*sh
;
7003 ips_ha_t
*ha
, *oldha
= ips_ha
[index
];
7004 sh
= scsi_host_alloc(&ips_driver_template
, sizeof (ips_ha_t
));
7006 IPS_PRINTK(KERN_WARNING
, oldha
->pcidev
,
7007 "Unable to register controller with SCSI subsystem\n");
7011 memcpy(ha
, oldha
, sizeof (ips_ha_t
));
7012 free_irq(oldha
->irq
, oldha
);
7013 /* Install the interrupt handler with the new ha */
7014 if (request_irq(ha
->irq
, do_ipsintr
, SA_SHIRQ
, ips_name
, ha
)) {
7015 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7016 "Unable to install interrupt handler\n");
7024 IPS_SCSI_SET_DEVICE(sh
, ha
);
7026 /* Store away needed values for later use */
7027 sh
->io_port
= ha
->io_addr
;
7028 sh
->n_io_port
= ha
->io_addr
? 255 : 0;
7029 sh
->unique_id
= (ha
->io_addr
) ? ha
->io_addr
: ha
->mem_addr
;
7031 sh
->sg_tablesize
= sh
->hostt
->sg_tablesize
;
7032 sh
->can_queue
= sh
->hostt
->can_queue
;
7033 sh
->cmd_per_lun
= sh
->hostt
->cmd_per_lun
;
7034 sh
->unchecked_isa_dma
= sh
->hostt
->unchecked_isa_dma
;
7035 sh
->use_clustering
= sh
->hostt
->use_clustering
;
7037 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,7)
7038 sh
->max_sectors
= 128;
7041 sh
->max_id
= ha
->ntargets
;
7042 sh
->max_lun
= ha
->nlun
;
7043 sh
->max_channel
= ha
->nbus
- 1;
7044 sh
->can_queue
= ha
->max_cmds
- 1;
7046 IPS_ADD_HOST(sh
, NULL
);
7050 /*---------------------------------------------------------------------------*/
7051 /* Routine Name: ips_remove_device */
7053 /* Routine Description: */
7054 /* Remove one Adapter ( Hot Plugging ) */
7055 /*---------------------------------------------------------------------------*/
7056 static void __devexit
7057 ips_remove_device(struct pci_dev
*pci_dev
)
7060 struct Scsi_Host
*sh
;
7063 for (i
= 0; i
< IPS_MAX_ADAPTERS
; i
++) {
7066 if ((pci_dev
->bus
->number
== ha
->pcidev
->bus
->number
) &&
7067 (pci_dev
->devfn
== ha
->pcidev
->devfn
)) {
7075 /****************************************************************************/
7077 /* Routine Name: ips_module_init */
7079 /* Routine Description: */
7080 /* function called on module load */
7081 /****************************************************************************/
7083 ips_module_init(void)
7085 if (pci_module_init(&ips_pci_driver
) < 0)
7087 ips_driver_template
.module
= THIS_MODULE
;
7088 ips_order_controllers();
7089 if (IPS_REGISTER_HOSTS(&ips_driver_template
)) {
7090 pci_unregister_driver(&ips_pci_driver
);
7093 register_reboot_notifier(&ips_notifier
);
7097 /****************************************************************************/
7099 /* Routine Name: ips_module_exit */
7101 /* Routine Description: */
7102 /* function called on module unload */
7103 /****************************************************************************/
7105 ips_module_exit(void)
7107 IPS_UNREGISTER_HOSTS(&ips_driver_template
);
7108 pci_unregister_driver(&ips_pci_driver
);
7109 unregister_reboot_notifier(&ips_notifier
);
7112 module_init(ips_module_init
);
7113 module_exit(ips_module_exit
);
7115 /*---------------------------------------------------------------------------*/
7116 /* Routine Name: ips_insert_device */
7118 /* Routine Description: */
7119 /* Add One Adapter ( Hot Plug ) */
7122 /* 0 if Successful, else non-zero */
7123 /*---------------------------------------------------------------------------*/
7124 static int __devinit
7125 ips_insert_device(struct pci_dev
*pci_dev
, const struct pci_device_id
*ent
)
7130 METHOD_TRACE("ips_insert_device", 1);
7131 if (pci_enable_device(pci_dev
))
7134 rc
= ips_init_phase1(pci_dev
, &index
);
7136 rc
= ips_init_phase2(index
);
7139 if (ips_register_scsi(index
)) {
7140 ips_free(ips_ha
[index
]);
7145 ips_num_controllers
++;
7147 ips_next_controller
= ips_num_controllers
;
7151 /*---------------------------------------------------------------------------*/
7152 /* Routine Name: ips_init_phase1 */
7154 /* Routine Description: */
7155 /* Adapter Initialization */
7158 /* 0 if Successful, else non-zero */
7159 /*---------------------------------------------------------------------------*/
7161 ips_init_phase1(struct pci_dev
*pci_dev
, int *indexPtr
)
7168 uint8_t revision_id
;
7172 uint16_t subdevice_id
;
7175 dma_addr_t dma_address
;
7176 char __iomem
*ioremap_ptr
;
7177 char __iomem
*mem_ptr
;
7180 METHOD_TRACE("ips_init_phase1", 1);
7181 index
= IPS_MAX_ADAPTERS
;
7182 for (j
= 0; j
< IPS_MAX_ADAPTERS
; j
++) {
7183 if (ips_ha
[j
] == 0) {
7189 if (index
>= IPS_MAX_ADAPTERS
)
7192 /* stuff that we get in dev */
7194 bus
= pci_dev
->bus
->number
;
7195 func
= pci_dev
->devfn
;
7197 /* Init MEM/IO addresses to 0 */
7203 for (j
= 0; j
< 2; j
++) {
7204 if (!pci_resource_start(pci_dev
, j
))
7207 if (pci_resource_flags(pci_dev
, j
) & IORESOURCE_IO
) {
7208 io_addr
= pci_resource_start(pci_dev
, j
);
7209 io_len
= pci_resource_len(pci_dev
, j
);
7211 mem_addr
= pci_resource_start(pci_dev
, j
);
7212 mem_len
= pci_resource_len(pci_dev
, j
);
7216 /* setup memory mapped area (if applicable) */
7221 if (!request_mem_region(mem_addr
, mem_len
, "ips")) {
7222 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7223 "Couldn't allocate IO Memory space %x len %d.\n",
7228 base
= mem_addr
& PAGE_MASK
;
7229 offs
= mem_addr
- base
;
7230 ioremap_ptr
= ioremap(base
, PAGE_SIZE
);
7231 mem_ptr
= ioremap_ptr
+ offs
;
7237 /* setup I/O mapped area (if applicable) */
7239 if (!request_region(io_addr
, io_len
, "ips")) {
7240 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7241 "Couldn't allocate IO space %x len %d.\n",
7247 /* get the revision ID */
7248 if (pci_read_config_byte(pci_dev
, PCI_REVISION_ID
, &revision_id
)) {
7249 IPS_PRINTK(KERN_WARNING
, pci_dev
, "Can't get revision id.\n");
7253 subdevice_id
= pci_dev
->subsystem_device
;
7255 /* found a controller */
7256 ha
= kmalloc(sizeof (ips_ha_t
), GFP_KERNEL
);
7258 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7259 "Unable to allocate temporary ha struct\n");
7263 memset(ha
, 0, sizeof (ips_ha_t
));
7265 ips_sh
[index
] = NULL
;
7269 /* Store info in HA structure */
7271 ha
->io_addr
= io_addr
;
7272 ha
->io_len
= io_len
;
7273 ha
->mem_addr
= mem_addr
;
7274 ha
->mem_len
= mem_len
;
7275 ha
->mem_ptr
= mem_ptr
;
7276 ha
->ioremap_ptr
= ioremap_ptr
;
7277 ha
->host_num
= (uint32_t) index
;
7278 ha
->revision_id
= revision_id
;
7279 ha
->slot_num
= PCI_SLOT(pci_dev
->devfn
);
7280 ha
->device_id
= pci_dev
->device
;
7281 ha
->subdevice_id
= subdevice_id
;
7282 ha
->pcidev
= pci_dev
;
7285 * Set the pci_dev's dma_mask. Not all adapters support 64bit
7286 * addressing so don't enable it if the adapter can't support
7287 * it! Also, don't use 64bit addressing if dma addresses
7288 * are guaranteed to be < 4G.
7290 if (IPS_ENABLE_DMA64
&& IPS_HAS_ENH_SGLIST(ha
) &&
7291 !pci_set_dma_mask(ha
->pcidev
, 0xffffffffffffffffULL
)) {
7292 (ha
)->flags
|= IPS_HA_ENH_SG
;
7294 if (pci_set_dma_mask(ha
->pcidev
, 0xffffffffULL
) != 0) {
7295 printk(KERN_WARNING
"Unable to set DMA Mask\n");
7296 return ips_abort_init(ha
, index
);
7299 if(ips_cd_boot
&& !ips_FlashData
){
7300 ips_FlashData
= pci_alloc_consistent(pci_dev
, PAGE_SIZE
<< 7,
7304 ha
->enq
= pci_alloc_consistent(pci_dev
, sizeof (IPS_ENQ
),
7307 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7308 "Unable to allocate host inquiry structure\n");
7309 return ips_abort_init(ha
, index
);
7312 ha
->adapt
= pci_alloc_consistent(pci_dev
, sizeof (IPS_ADAPTER
) +
7313 sizeof (IPS_IO_CMD
), &dma_address
);
7315 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7316 "Unable to allocate host adapt & dummy structures\n");
7317 return ips_abort_init(ha
, index
);
7319 ha
->adapt
->hw_status_start
= dma_address
;
7320 ha
->dummy
= (void *) (ha
->adapt
+ 1);
7324 ha
->logical_drive_info
= pci_alloc_consistent(pci_dev
, sizeof (IPS_LD_INFO
), &dma_address
);
7325 if (!ha
->logical_drive_info
) {
7326 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7327 "Unable to allocate logical drive info structure\n");
7328 return ips_abort_init(ha
, index
);
7330 ha
->logical_drive_info_dma_addr
= dma_address
;
7333 ha
->conf
= kmalloc(sizeof (IPS_CONF
), GFP_KERNEL
);
7336 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7337 "Unable to allocate host conf structure\n");
7338 return ips_abort_init(ha
, index
);
7341 ha
->nvram
= kmalloc(sizeof (IPS_NVRAM_P5
), GFP_KERNEL
);
7344 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7345 "Unable to allocate host NVRAM structure\n");
7346 return ips_abort_init(ha
, index
);
7349 ha
->subsys
= kmalloc(sizeof (IPS_SUBSYS
), GFP_KERNEL
);
7352 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7353 "Unable to allocate host subsystem structure\n");
7354 return ips_abort_init(ha
, index
);
7357 /* the ioctl buffer is now used during adapter initialization, so its
7358 * successful allocation is now required */
7359 if (ips_ioctlsize
< PAGE_SIZE
)
7360 ips_ioctlsize
= PAGE_SIZE
;
7362 ha
->ioctl_data
= pci_alloc_consistent(pci_dev
, ips_ioctlsize
,
7363 &ha
->ioctl_busaddr
);
7364 ha
->ioctl_len
= ips_ioctlsize
;
7365 if (!ha
->ioctl_data
) {
7366 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7367 "Unable to allocate IOCTL data\n");
7368 return ips_abort_init(ha
, index
);
7374 ips_setup_funclist(ha
);
7376 if ((IPS_IS_MORPHEUS(ha
)) || (IPS_IS_MARCO(ha
))) {
7377 /* If Morpheus appears dead, reset it */
7378 IsDead
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG1
);
7379 if (IsDead
== 0xDEADBEEF) {
7380 ips_reset_morpheus(ha
);
7385 * Initialize the card if it isn't already
7388 if (!(*ha
->func
.isinit
) (ha
)) {
7389 if (!(*ha
->func
.init
) (ha
)) {
7391 * Initialization failed
7393 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7394 "Unable to initialize controller\n");
7395 return ips_abort_init(ha
, index
);
7403 /*---------------------------------------------------------------------------*/
7404 /* Routine Name: ips_init_phase2 */
7406 /* Routine Description: */
7407 /* Adapter Initialization Phase 2 */
7410 /* 0 if Successful, else non-zero */
7411 /*---------------------------------------------------------------------------*/
7413 ips_init_phase2(int index
)
7419 METHOD_TRACE("ips_init_phase2", 1);
7421 ips_ha
[index
] = NULL
;
7425 /* Install the interrupt handler */
7426 if (request_irq(ha
->irq
, do_ipsintr
, SA_SHIRQ
, ips_name
, ha
)) {
7427 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7428 "Unable to install interrupt handler\n");
7429 return ips_abort_init(ha
, index
);
7433 * Allocate a temporary SCB for initialization
7436 if (!ips_allocatescbs(ha
)) {
7437 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7438 "Unable to allocate a CCB\n");
7439 free_irq(ha
->irq
, ha
);
7440 return ips_abort_init(ha
, index
);
7443 if (!ips_hainit(ha
)) {
7444 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7445 "Unable to initialize controller\n");
7446 free_irq(ha
->irq
, ha
);
7447 return ips_abort_init(ha
, index
);
7449 /* Free the temporary SCB */
7450 ips_deallocatescbs(ha
, 1);
7453 if (!ips_allocatescbs(ha
)) {
7454 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7455 "Unable to allocate CCBs\n");
7456 free_irq(ha
->irq
, ha
);
7457 return ips_abort_init(ha
, index
);
7463 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9)
7464 MODULE_LICENSE("GPL");
7467 MODULE_DESCRIPTION("IBM ServeRAID Adapter Driver " IPS_VER_STRING
);
7469 #ifdef MODULE_VERSION
7470 MODULE_VERSION(IPS_VER_STRING
);
7475 * Overrides for Emacs so that we almost follow Linus's tabbing style.
7476 * Emacs will notice this stuff at the end of the file and automatically
7477 * adjust the settings for this buffer only. This must remain at the end
7479 * ---------------------------------------------------------------------------
7482 * c-brace-imaginary-offset: 0
7483 * c-brace-offset: -2
7484 * c-argdecl-indent: 2
7485 * c-label-offset: -2
7486 * c-continued-statement-offset: 2
7487 * c-continued-brace-offset: 0
7488 * indent-tabs-mode: nil