1 /*****************************************************************************/
2 /* ips.c -- driver for the Adaptec / IBM ServeRAID controller */
4 /* Written By: Keith Mitchell, IBM Corporation */
5 /* Jack Hammer, Adaptec, Inc. */
6 /* David Jeffery, Adaptec, Inc. */
8 /* Copyright (C) 2000 IBM Corporation */
9 /* Copyright (C) 2002,2003 Adaptec, Inc. */
11 /* This program is free software; you can redistribute it and/or modify */
12 /* it under the terms of the GNU General Public License as published by */
13 /* the Free Software Foundation; either version 2 of the License, or */
14 /* (at your option) any later version. */
16 /* This program is distributed in the hope that it will be useful, */
17 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
18 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
19 /* GNU General Public License for more details. */
22 /* THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR */
23 /* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT */
24 /* LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, */
25 /* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is */
26 /* solely responsible for determining the appropriateness of using and */
27 /* distributing the Program and assumes all risks associated with its */
28 /* exercise of rights under this Agreement, including but not limited to */
29 /* the risks and costs of program errors, damage to or loss of data, */
30 /* programs or equipment, and unavailability or interruption of operations. */
32 /* DISCLAIMER OF LIABILITY */
33 /* NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY */
34 /* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL */
35 /* DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND */
36 /* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR */
37 /* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE */
38 /* USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED */
39 /* HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES */
41 /* You should have received a copy of the GNU General Public License */
42 /* along with this program; if not, write to the Free Software */
43 /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
45 /* Bugs/Comments/Suggestions about this driver should be mailed to: */
46 /* ipslinux@adaptec.com */
48 /* For system support issues, contact your local IBM Customer support. */
49 /* Directions to find IBM Customer Support for each country can be found at: */
50 /* http://www.ibm.com/planetwide/ */
52 /*****************************************************************************/
54 /*****************************************************************************/
57 /* 0.99.02 - Breakup commands that are bigger than 8 * the stripe size */
58 /* 0.99.03 - Make interrupt routine handle all completed request on the */
59 /* adapter not just the first one */
60 /* - Make sure passthru commands get woken up if we run out of */
62 /* - Send all of the commands on the queue at once rather than */
63 /* one at a time since the card will support it. */
64 /* 0.99.04 - Fix race condition in the passthru mechanism -- this required */
65 /* the interface to the utilities to change */
66 /* - Fix error recovery code */
67 /* 0.99.05 - Fix an oops when we get certain passthru commands */
68 /* 1.00.00 - Initial Public Release */
69 /* Functionally equivalent to 0.99.05 */
70 /* 3.60.00 - Bump max commands to 128 for use with firmware 3.60 */
71 /* - Change version to 3.60 to coincide with release numbering. */
72 /* 3.60.01 - Remove bogus error check in passthru routine */
73 /* 3.60.02 - Make DCDB direction based on lookup table */
74 /* - Only allow one DCDB command to a SCSI ID at a time */
75 /* 4.00.00 - Add support for ServeRAID 4 */
76 /* 4.00.01 - Add support for First Failure Data Capture */
77 /* 4.00.02 - Fix problem with PT DCDB with no buffer */
78 /* 4.00.03 - Add alternative passthru interface */
79 /* - Add ability to flash BIOS */
80 /* 4.00.04 - Rename structures/constants to be prefixed with IPS_ */
81 /* 4.00.05 - Remove wish_block from init routine */
82 /* - Use linux/spinlock.h instead of asm/spinlock.h for kernels */
83 /* 2.3.18 and later */
84 /* - Sync with other changes from the 2.3 kernels */
85 /* 4.00.06 - Fix timeout with initial FFDC command */
86 /* 4.00.06a - Port to 2.4 (trivial) -- Christoph Hellwig <hch@infradead.org> */
87 /* 4.10.00 - Add support for ServeRAID 4M/4L */
88 /* 4.10.13 - Fix for dynamic unload and proc file system */
89 /* 4.20.03 - Rename version to coincide with new release schedules */
90 /* Performance fixes */
91 /* Fix truncation of /proc files with cat */
92 /* Merge in changes through kernel 2.4.0test1ac21 */
93 /* 4.20.13 - Fix some failure cases / reset code */
94 /* - Hook into the reboot_notifier to flush the controller cache */
95 /* 4.50.01 - Fix problem when there is a hole in logical drive numbering */
96 /* 4.70.09 - Use a Common ( Large Buffer ) for Flashing from the JCRM CD */
97 /* - Add IPSSEND Flash Support */
98 /* - Set Sense Data for Unknown SCSI Command */
99 /* - Use Slot Number from NVRAM Page 5 */
100 /* - Restore caller's DCDB Structure */
101 /* 4.70.12 - Corrective actions for bad controller ( during initialization )*/
102 /* 4.70.13 - Don't Send CDB's if we already know the device is not present */
103 /* - Don't release HA Lock in ips_next() until SC taken off queue */
104 /* - Unregister SCSI device in ips_release() */
105 /* 4.70.15 - Fix Breakup for very large ( non-SG ) requests in ips_done() */
106 /* 4.71.00 - Change all memory allocations to not use GFP_DMA flag */
107 /* Code Clean-Up for 2.4.x kernel */
108 /* 4.72.00 - Allow for a Scatter-Gather Element to exceed MAX_XFER Size */
109 /* 4.72.01 - I/O Mapped Memory release ( so "insmod ips" does not Fail ) */
110 /* - Don't Issue Internal FFDC Command if there are Active Commands */
111 /* - Close Window for getting too many IOCTL's active */
112 /* 4.80.00 - Make ia64 Safe */
113 /* 4.80.04 - Eliminate calls to strtok() if 2.4.x or greater */
114 /* - Adjustments to Device Queue Depth */
115 /* 4.80.14 - Take all semaphores off stack */
116 /* - Clean Up New_IOCTL path */
117 /* 4.80.20 - Set max_sectors in Scsi_Host structure ( if >= 2.4.7 kernel ) */
118 /* - 5 second delay needed after resetting an i960 adapter */
119 /* 4.80.26 - Clean up potential code problems ( Arjan's recommendations ) */
120 /* 4.90.01 - Version Matching for FirmWare, BIOS, and Driver */
121 /* 4.90.05 - Use New PCI Architecture to facilitate Hot Plug Development */
122 /* 4.90.08 - Increase Delays in Flashing ( Trombone Only - 4H ) */
123 /* 4.90.08 - Data Corruption if First Scatter Gather Element is > 64K */
124 /* 4.90.11 - Don't actually RESET unless it's physically required */
125 /* - Remove unused compile options */
126 /* 5.00.01 - Sarasota ( 5i ) adapters must always be scanned first */
127 /* - Get rid on IOCTL_NEW_COMMAND code */
128 /* - Add Extended DCDB Commands for Tape Support in 5I */
129 /* 5.10.12 - use pci_dma interfaces, update for 2.5 kernel changes */
130 /* 5.10.15 - remove unused code (sem, macros, etc.) */
131 /* 5.30.00 - use __devexit_p() */
132 /* 6.00.00 - Add 6x Adapters and Battery Flash */
133 /* 6.10.00 - Remove 1G Addressing Limitations */
134 /* 6.11.xx - Get VersionInfo buffer off the stack ! DDTS 60401 */
135 /* 6.11.xx - Make Logical Drive Info structure safe for DMA DDTS 60639 */
136 /* 7.10.18 - Add highmem_io flag in SCSI Templete for 2.4 kernels */
137 /* - Fix path/name for scsi_hosts.h include for 2.6 kernels */
138 /* - Fix sort order of 7k */
139 /* - Remove 3 unused "inline" functions */
140 /* 7.12.xx - Use STATIC functions wherever possible */
141 /* - Clean up deprecated MODULE_PARM calls */
142 /* 7.12.05 - Remove Version Matching per IBM request */
143 /*****************************************************************************/
146 * Conditional Compilation directives for this driver:
148 * IPS_DEBUG - Turn on debugging info
152 * debug:<number> - Set debug level to <number>
153 * NOTE: only works when IPS_DEBUG compile directive is used.
154 * 1 - Normal debug messages
155 * 2 - Verbose debug messages
156 * 11 - Method trace (non interrupt)
157 * 12 - Method trace (includes interrupt)
159 * noi2o - Don't use I2O Queues (ServeRAID 4 only)
160 * nommap - Don't use memory mapped I/O
161 * ioctlsize - Initial size of the IOCTL buffer
165 #include <asm/byteorder.h>
166 #include <asm/page.h>
167 #include <linux/stddef.h>
168 #include <linux/string.h>
169 #include <linux/errno.h>
170 #include <linux/kernel.h>
171 #include <linux/ioport.h>
172 #include <linux/slab.h>
173 #include <linux/delay.h>
174 #include <linux/pci.h>
175 #include <linux/proc_fs.h>
176 #include <linux/reboot.h>
177 #include <linux/interrupt.h>
179 #include <linux/blkdev.h>
180 #include <linux/types.h>
181 #include <linux/dma-mapping.h>
185 #include <scsi/scsi_host.h>
189 #include <linux/module.h>
191 #include <linux/stat.h>
193 #include <linux/spinlock.h>
194 #include <linux/init.h>
196 #include <linux/smp.h>
199 static char *ips
= NULL
;
200 module_param(ips
, charp
, 0);
206 #define IPS_VERSION_HIGH IPS_VER_MAJOR_STRING "." IPS_VER_MINOR_STRING
207 #define IPS_VERSION_LOW "." IPS_VER_BUILD_STRING " "
209 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
210 DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
211 PCI_DMA_BIDIRECTIONAL : \
212 scb->scsi_cmd->sc_data_direction)
215 #define METHOD_TRACE(s, i) if (ips_debug >= (i+10)) printk(KERN_NOTICE s "\n");
216 #define DEBUG(i, s) if (ips_debug >= i) printk(KERN_NOTICE s "\n");
217 #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "\n", v);
219 #define METHOD_TRACE(s, i)
221 #define DEBUG_VAR(i, s, v...)
225 * Function prototypes
227 static int ips_detect(struct scsi_host_template
*);
228 static int ips_release(struct Scsi_Host
*);
229 static int ips_eh_abort(struct scsi_cmnd
*);
230 static int ips_eh_reset(struct scsi_cmnd
*);
231 static int ips_queue(struct Scsi_Host
*, struct scsi_cmnd
*);
232 static const char *ips_info(struct Scsi_Host
*);
233 static irqreturn_t
do_ipsintr(int, void *);
234 static int ips_hainit(ips_ha_t
*);
235 static int ips_map_status(ips_ha_t
*, ips_scb_t
*, ips_stat_t
*);
236 static int ips_send_wait(ips_ha_t
*, ips_scb_t
*, int, int);
237 static int ips_send_cmd(ips_ha_t
*, ips_scb_t
*);
238 static int ips_online(ips_ha_t
*, ips_scb_t
*);
239 static int ips_inquiry(ips_ha_t
*, ips_scb_t
*);
240 static int ips_rdcap(ips_ha_t
*, ips_scb_t
*);
241 static int ips_msense(ips_ha_t
*, ips_scb_t
*);
242 static int ips_reqsen(ips_ha_t
*, ips_scb_t
*);
243 static int ips_deallocatescbs(ips_ha_t
*, int);
244 static int ips_allocatescbs(ips_ha_t
*);
245 static int ips_reset_copperhead(ips_ha_t
*);
246 static int ips_reset_copperhead_memio(ips_ha_t
*);
247 static int ips_reset_morpheus(ips_ha_t
*);
248 static int ips_issue_copperhead(ips_ha_t
*, ips_scb_t
*);
249 static int ips_issue_copperhead_memio(ips_ha_t
*, ips_scb_t
*);
250 static int ips_issue_i2o(ips_ha_t
*, ips_scb_t
*);
251 static int ips_issue_i2o_memio(ips_ha_t
*, ips_scb_t
*);
252 static int ips_isintr_copperhead(ips_ha_t
*);
253 static int ips_isintr_copperhead_memio(ips_ha_t
*);
254 static int ips_isintr_morpheus(ips_ha_t
*);
255 static int ips_wait(ips_ha_t
*, int, int);
256 static int ips_write_driver_status(ips_ha_t
*, int);
257 static int ips_read_adapter_status(ips_ha_t
*, int);
258 static int ips_read_subsystem_parameters(ips_ha_t
*, int);
259 static int ips_read_config(ips_ha_t
*, int);
260 static int ips_clear_adapter(ips_ha_t
*, int);
261 static int ips_readwrite_page5(ips_ha_t
*, int, int);
262 static int ips_init_copperhead(ips_ha_t
*);
263 static int ips_init_copperhead_memio(ips_ha_t
*);
264 static int ips_init_morpheus(ips_ha_t
*);
265 static int ips_isinit_copperhead(ips_ha_t
*);
266 static int ips_isinit_copperhead_memio(ips_ha_t
*);
267 static int ips_isinit_morpheus(ips_ha_t
*);
268 static int ips_erase_bios(ips_ha_t
*);
269 static int ips_program_bios(ips_ha_t
*, char *, uint32_t, uint32_t);
270 static int ips_verify_bios(ips_ha_t
*, char *, uint32_t, uint32_t);
271 static int ips_erase_bios_memio(ips_ha_t
*);
272 static int ips_program_bios_memio(ips_ha_t
*, char *, uint32_t, uint32_t);
273 static int ips_verify_bios_memio(ips_ha_t
*, char *, uint32_t, uint32_t);
274 static int ips_flash_copperhead(ips_ha_t
*, ips_passthru_t
*, ips_scb_t
*);
275 static int ips_flash_bios(ips_ha_t
*, ips_passthru_t
*, ips_scb_t
*);
276 static int ips_flash_firmware(ips_ha_t
*, ips_passthru_t
*, ips_scb_t
*);
277 static void ips_free_flash_copperhead(ips_ha_t
* ha
);
278 static void ips_get_bios_version(ips_ha_t
*, int);
279 static void ips_identify_controller(ips_ha_t
*);
280 static void ips_chkstatus(ips_ha_t
*, IPS_STATUS
*);
281 static void ips_enable_int_copperhead(ips_ha_t
*);
282 static void ips_enable_int_copperhead_memio(ips_ha_t
*);
283 static void ips_enable_int_morpheus(ips_ha_t
*);
284 static int ips_intr_copperhead(ips_ha_t
*);
285 static int ips_intr_morpheus(ips_ha_t
*);
286 static void ips_next(ips_ha_t
*, int);
287 static void ipsintr_blocking(ips_ha_t
*, struct ips_scb
*);
288 static void ipsintr_done(ips_ha_t
*, struct ips_scb
*);
289 static void ips_done(ips_ha_t
*, ips_scb_t
*);
290 static void ips_free(ips_ha_t
*);
291 static void ips_init_scb(ips_ha_t
*, ips_scb_t
*);
292 static void ips_freescb(ips_ha_t
*, ips_scb_t
*);
293 static void ips_setup_funclist(ips_ha_t
*);
294 static void ips_statinit(ips_ha_t
*);
295 static void ips_statinit_memio(ips_ha_t
*);
296 static void ips_fix_ffdc_time(ips_ha_t
*, ips_scb_t
*, time_t);
297 static void ips_ffdc_reset(ips_ha_t
*, int);
298 static void ips_ffdc_time(ips_ha_t
*);
299 static uint32_t ips_statupd_copperhead(ips_ha_t
*);
300 static uint32_t ips_statupd_copperhead_memio(ips_ha_t
*);
301 static uint32_t ips_statupd_morpheus(ips_ha_t
*);
302 static ips_scb_t
*ips_getscb(ips_ha_t
*);
303 static void ips_putq_scb_head(ips_scb_queue_t
*, ips_scb_t
*);
304 static void ips_putq_wait_tail(ips_wait_queue_entry_t
*, struct scsi_cmnd
*);
305 static void ips_putq_copp_tail(ips_copp_queue_t
*,
306 ips_copp_wait_item_t
*);
307 static ips_scb_t
*ips_removeq_scb_head(ips_scb_queue_t
*);
308 static ips_scb_t
*ips_removeq_scb(ips_scb_queue_t
*, ips_scb_t
*);
309 static struct scsi_cmnd
*ips_removeq_wait_head(ips_wait_queue_entry_t
*);
310 static struct scsi_cmnd
*ips_removeq_wait(ips_wait_queue_entry_t
*,
312 static ips_copp_wait_item_t
*ips_removeq_copp(ips_copp_queue_t
*,
313 ips_copp_wait_item_t
*);
314 static ips_copp_wait_item_t
*ips_removeq_copp_head(ips_copp_queue_t
*);
316 static int ips_is_passthru(struct scsi_cmnd
*);
317 static int ips_make_passthru(ips_ha_t
*, struct scsi_cmnd
*, ips_scb_t
*, int);
318 static int ips_usrcmd(ips_ha_t
*, ips_passthru_t
*, ips_scb_t
*);
319 static void ips_cleanup_passthru(ips_ha_t
*, ips_scb_t
*);
320 static void ips_scmd_buf_write(struct scsi_cmnd
* scmd
, void *data
,
322 static void ips_scmd_buf_read(struct scsi_cmnd
* scmd
, void *data
,
325 static int ips_write_info(struct Scsi_Host
*, char *, int);
326 static int ips_show_info(struct seq_file
*, struct Scsi_Host
*);
327 static int ips_host_info(ips_ha_t
*, struct seq_file
*);
328 static int ips_abort_init(ips_ha_t
* ha
, int index
);
329 static int ips_init_phase2(int index
);
331 static int ips_init_phase1(struct pci_dev
*pci_dev
, int *indexPtr
);
332 static int ips_register_scsi(int index
);
334 static int ips_poll_for_flush_complete(ips_ha_t
* ha
);
335 static void ips_flush_and_reset(ips_ha_t
*ha
);
340 static const char ips_name
[] = "ips";
341 static struct Scsi_Host
*ips_sh
[IPS_MAX_ADAPTERS
]; /* Array of host controller structures */
342 static ips_ha_t
*ips_ha
[IPS_MAX_ADAPTERS
]; /* Array of HA structures */
343 static unsigned int ips_next_controller
;
344 static unsigned int ips_num_controllers
;
345 static unsigned int ips_released_controllers
;
346 static int ips_hotplug
;
347 static int ips_cmd_timeout
= 60;
348 static int ips_reset_timeout
= 60 * 5;
349 static int ips_force_memio
= 1; /* Always use Memory Mapped I/O */
350 static int ips_force_i2o
= 1; /* Always use I2O command delivery */
351 static int ips_ioctlsize
= IPS_IOCTL_SIZE
; /* Size of the ioctl buffer */
352 static int ips_cd_boot
; /* Booting from Manager CD */
353 static char *ips_FlashData
= NULL
; /* CD Boot - Flash Data Buffer */
354 static dma_addr_t ips_flashbusaddr
;
355 static long ips_FlashDataInUse
; /* CD Boot - Flash Data In Use Flag */
356 static uint32_t MaxLiteCmds
= 32; /* Max Active Cmds for a Lite Adapter */
357 static struct scsi_host_template ips_driver_template
= {
358 .detect
= ips_detect
,
359 .release
= ips_release
,
361 .queuecommand
= ips_queue
,
362 .eh_abort_handler
= ips_eh_abort
,
363 .eh_host_reset_handler
= ips_eh_reset
,
365 .show_info
= ips_show_info
,
366 .write_info
= ips_write_info
,
367 .slave_configure
= ips_slave_configure
,
368 .bios_param
= ips_biosparam
,
370 .sg_tablesize
= IPS_MAX_SG
,
372 .use_clustering
= ENABLE_CLUSTERING
,
377 /* This table describes all ServeRAID Adapters */
378 static struct pci_device_id ips_pci_table
[] = {
379 { 0x1014, 0x002E, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0 },
380 { 0x1014, 0x01BD, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0 },
381 { 0x9005, 0x0250, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0 },
385 MODULE_DEVICE_TABLE( pci
, ips_pci_table
);
387 static char ips_hot_plug_name
[] = "ips";
389 static int ips_insert_device(struct pci_dev
*pci_dev
, const struct pci_device_id
*ent
);
390 static void ips_remove_device(struct pci_dev
*pci_dev
);
392 static struct pci_driver ips_pci_driver
= {
393 .name
= ips_hot_plug_name
,
394 .id_table
= ips_pci_table
,
395 .probe
= ips_insert_device
,
396 .remove
= ips_remove_device
,
401 * Necessary forward function protoypes
403 static int ips_halt(struct notifier_block
*nb
, ulong event
, void *buf
);
405 #define MAX_ADAPTER_NAME 15
407 static char ips_adapter_name
[][30] = {
410 "ServeRAID on motherboard",
411 "ServeRAID on motherboard",
428 static struct notifier_block ips_notifier
= {
435 static char ips_command_direction
[] = {
436 IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_IN
, IPS_DATA_IN
, IPS_DATA_OUT
,
437 IPS_DATA_IN
, IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_UNK
,
438 IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
439 IPS_DATA_IN
, IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_IN
, IPS_DATA_OUT
,
440 IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_OUT
,
441 IPS_DATA_NONE
, IPS_DATA_IN
, IPS_DATA_NONE
, IPS_DATA_IN
, IPS_DATA_OUT
,
442 IPS_DATA_NONE
, IPS_DATA_UNK
, IPS_DATA_IN
, IPS_DATA_UNK
, IPS_DATA_IN
,
443 IPS_DATA_UNK
, IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_UNK
, IPS_DATA_UNK
,
444 IPS_DATA_IN
, IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_NONE
, IPS_DATA_UNK
,
445 IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
,
446 IPS_DATA_OUT
, IPS_DATA_NONE
, IPS_DATA_IN
, IPS_DATA_NONE
, IPS_DATA_NONE
,
447 IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
,
448 IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_OUT
,
449 IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_IN
, IPS_DATA_IN
, IPS_DATA_NONE
,
450 IPS_DATA_UNK
, IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_UNK
,
451 IPS_DATA_NONE
, IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_UNK
, IPS_DATA_UNK
,
452 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
453 IPS_DATA_OUT
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
454 IPS_DATA_IN
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
455 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
456 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
457 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
458 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
459 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
460 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
461 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
462 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
463 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
464 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
465 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
466 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
467 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
468 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
469 IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_UNK
, IPS_DATA_IN
, IPS_DATA_NONE
,
470 IPS_DATA_OUT
, IPS_DATA_UNK
, IPS_DATA_NONE
, IPS_DATA_UNK
, IPS_DATA_OUT
,
471 IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_NONE
,
472 IPS_DATA_UNK
, IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_IN
,
473 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
474 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
475 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
476 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
477 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
478 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
479 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
480 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
481 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
482 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_OUT
,
483 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
484 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, 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_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
490 /****************************************************************************/
492 /* Routine Name: ips_setup */
494 /* Routine Description: */
496 /* setup parameters to the driver */
498 /****************************************************************************/
500 ips_setup(char *ips_str
)
506 IPS_OPTION options
[] = {
507 {"noi2o", &ips_force_i2o
, 0},
508 {"nommap", &ips_force_memio
, 0},
509 {"ioctlsize", &ips_ioctlsize
, IPS_IOCTL_SIZE
},
510 {"cdboot", &ips_cd_boot
, 0},
511 {"maxcmds", &MaxLiteCmds
, 32},
514 /* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
515 /* Search for value */
516 while ((key
= strsep(&ips_str
, ",."))) {
519 value
= strchr(key
, ':');
523 * We now have key/value pairs.
524 * Update the variables
526 for (i
= 0; i
< ARRAY_SIZE(options
); i
++) {
528 (key
, options
[i
].option_name
,
529 strlen(options
[i
].option_name
)) == 0) {
531 *options
[i
].option_flag
=
532 simple_strtoul(value
, NULL
, 0);
534 *options
[i
].option_flag
=
535 options
[i
].option_value
;
544 __setup("ips=", ips_setup
);
546 /****************************************************************************/
548 /* Routine Name: ips_detect */
550 /* Routine Description: */
552 /* Detect and initialize the driver */
554 /* NOTE: this routine is called under the io_request_lock spinlock */
556 /****************************************************************************/
558 ips_detect(struct scsi_host_template
* SHT
)
562 METHOD_TRACE("ips_detect", 1);
569 for (i
= 0; i
< ips_num_controllers
; i
++) {
570 if (ips_register_scsi(i
))
572 ips_released_controllers
++;
575 return (ips_num_controllers
);
578 /****************************************************************************/
579 /* configure the function pointers to use the functions that will work */
580 /* with the found version of the adapter */
581 /****************************************************************************/
583 ips_setup_funclist(ips_ha_t
* ha
)
589 if (IPS_IS_MORPHEUS(ha
) || IPS_IS_MARCO(ha
)) {
590 /* morpheus / marco / sebring */
591 ha
->func
.isintr
= ips_isintr_morpheus
;
592 ha
->func
.isinit
= ips_isinit_morpheus
;
593 ha
->func
.issue
= ips_issue_i2o_memio
;
594 ha
->func
.init
= ips_init_morpheus
;
595 ha
->func
.statupd
= ips_statupd_morpheus
;
596 ha
->func
.reset
= ips_reset_morpheus
;
597 ha
->func
.intr
= ips_intr_morpheus
;
598 ha
->func
.enableint
= ips_enable_int_morpheus
;
599 } else if (IPS_USE_MEMIO(ha
)) {
600 /* copperhead w/MEMIO */
601 ha
->func
.isintr
= ips_isintr_copperhead_memio
;
602 ha
->func
.isinit
= ips_isinit_copperhead_memio
;
603 ha
->func
.init
= ips_init_copperhead_memio
;
604 ha
->func
.statupd
= ips_statupd_copperhead_memio
;
605 ha
->func
.statinit
= ips_statinit_memio
;
606 ha
->func
.reset
= ips_reset_copperhead_memio
;
607 ha
->func
.intr
= ips_intr_copperhead
;
608 ha
->func
.erasebios
= ips_erase_bios_memio
;
609 ha
->func
.programbios
= ips_program_bios_memio
;
610 ha
->func
.verifybios
= ips_verify_bios_memio
;
611 ha
->func
.enableint
= ips_enable_int_copperhead_memio
;
612 if (IPS_USE_I2O_DELIVER(ha
))
613 ha
->func
.issue
= ips_issue_i2o_memio
;
615 ha
->func
.issue
= ips_issue_copperhead_memio
;
618 ha
->func
.isintr
= ips_isintr_copperhead
;
619 ha
->func
.isinit
= ips_isinit_copperhead
;
620 ha
->func
.init
= ips_init_copperhead
;
621 ha
->func
.statupd
= ips_statupd_copperhead
;
622 ha
->func
.statinit
= ips_statinit
;
623 ha
->func
.reset
= ips_reset_copperhead
;
624 ha
->func
.intr
= ips_intr_copperhead
;
625 ha
->func
.erasebios
= ips_erase_bios
;
626 ha
->func
.programbios
= ips_program_bios
;
627 ha
->func
.verifybios
= ips_verify_bios
;
628 ha
->func
.enableint
= ips_enable_int_copperhead
;
630 if (IPS_USE_I2O_DELIVER(ha
))
631 ha
->func
.issue
= ips_issue_i2o
;
633 ha
->func
.issue
= ips_issue_copperhead
;
637 /****************************************************************************/
639 /* Routine Name: ips_release */
641 /* Routine Description: */
643 /* Remove a driver */
645 /****************************************************************************/
647 ips_release(struct Scsi_Host
*sh
)
653 METHOD_TRACE("ips_release", 1);
655 scsi_remove_host(sh
);
657 for (i
= 0; i
< IPS_MAX_ADAPTERS
&& ips_sh
[i
] != sh
; i
++) ;
659 if (i
== IPS_MAX_ADAPTERS
) {
661 "(%s) release, invalid Scsi_Host pointer.\n", ips_name
);
671 /* flush the cache on the controller */
672 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
674 ips_init_scb(ha
, scb
);
676 scb
->timeout
= ips_cmd_timeout
;
677 scb
->cdb
[0] = IPS_CMD_FLUSH
;
679 scb
->cmd
.flush_cache
.op_code
= IPS_CMD_FLUSH
;
680 scb
->cmd
.flush_cache
.command_id
= IPS_COMMAND_ID(ha
, scb
);
681 scb
->cmd
.flush_cache
.state
= IPS_NORM_STATE
;
682 scb
->cmd
.flush_cache
.reserved
= 0;
683 scb
->cmd
.flush_cache
.reserved2
= 0;
684 scb
->cmd
.flush_cache
.reserved3
= 0;
685 scb
->cmd
.flush_cache
.reserved4
= 0;
687 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
, "Flushing Cache.\n");
690 if (ips_send_wait(ha
, scb
, ips_cmd_timeout
, IPS_INTR_ON
) == IPS_FAILURE
)
691 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
, "Incomplete Flush.\n");
693 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
, "Flushing Complete.\n");
698 /* free extra memory */
702 free_irq(ha
->pcidev
->irq
, ha
);
706 ips_released_controllers
++;
711 /****************************************************************************/
713 /* Routine Name: ips_halt */
715 /* Routine Description: */
717 /* Perform cleanup when the system reboots */
719 /****************************************************************************/
721 ips_halt(struct notifier_block
*nb
, ulong event
, void *buf
)
727 if ((event
!= SYS_RESTART
) && (event
!= SYS_HALT
) &&
728 (event
!= SYS_POWER_OFF
))
729 return (NOTIFY_DONE
);
731 for (i
= 0; i
< ips_next_controller
; i
++) {
732 ha
= (ips_ha_t
*) ips_ha
[i
];
740 /* flush the cache on the controller */
741 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
743 ips_init_scb(ha
, scb
);
745 scb
->timeout
= ips_cmd_timeout
;
746 scb
->cdb
[0] = IPS_CMD_FLUSH
;
748 scb
->cmd
.flush_cache
.op_code
= IPS_CMD_FLUSH
;
749 scb
->cmd
.flush_cache
.command_id
= IPS_COMMAND_ID(ha
, scb
);
750 scb
->cmd
.flush_cache
.state
= IPS_NORM_STATE
;
751 scb
->cmd
.flush_cache
.reserved
= 0;
752 scb
->cmd
.flush_cache
.reserved2
= 0;
753 scb
->cmd
.flush_cache
.reserved3
= 0;
754 scb
->cmd
.flush_cache
.reserved4
= 0;
756 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
, "Flushing Cache.\n");
759 if (ips_send_wait(ha
, scb
, ips_cmd_timeout
, IPS_INTR_ON
) ==
761 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
762 "Incomplete Flush.\n");
764 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
765 "Flushing Complete.\n");
771 /****************************************************************************/
773 /* Routine Name: ips_eh_abort */
775 /* Routine Description: */
777 /* Abort a command (using the new error code stuff) */
778 /* Note: this routine is called under the io_request_lock */
779 /****************************************************************************/
780 int ips_eh_abort(struct scsi_cmnd
*SC
)
783 ips_copp_wait_item_t
*item
;
785 struct Scsi_Host
*host
;
787 METHOD_TRACE("ips_eh_abort", 1);
792 host
= SC
->device
->host
;
793 ha
= (ips_ha_t
*) SC
->device
->host
->hostdata
;
801 spin_lock(host
->host_lock
);
803 /* See if the command is on the copp queue */
804 item
= ha
->copp_waitlist
.head
;
805 while ((item
) && (item
->scsi_cmd
!= SC
))
810 ips_removeq_copp(&ha
->copp_waitlist
, item
);
813 /* See if the command is on the wait queue */
814 } else if (ips_removeq_wait(&ha
->scb_waitlist
, SC
)) {
815 /* command not sent yet */
818 /* command must have already been sent */
822 spin_unlock(host
->host_lock
);
826 /****************************************************************************/
828 /* Routine Name: ips_eh_reset */
830 /* Routine Description: */
832 /* Reset the controller (with new eh error code) */
834 /* NOTE: this routine is called under the io_request_lock spinlock */
836 /****************************************************************************/
837 static int __ips_eh_reset(struct scsi_cmnd
*SC
)
843 ips_copp_wait_item_t
*item
;
845 METHOD_TRACE("ips_eh_reset", 1);
852 DEBUG(1, "Reset called with NULL scsi command");
857 ha
= (ips_ha_t
*) SC
->device
->host
->hostdata
;
860 DEBUG(1, "Reset called with NULL ha struct");
868 /* See if the command is on the copp queue */
869 item
= ha
->copp_waitlist
.head
;
870 while ((item
) && (item
->scsi_cmd
!= SC
))
875 ips_removeq_copp(&ha
->copp_waitlist
, item
);
879 /* See if the command is on the wait queue */
880 if (ips_removeq_wait(&ha
->scb_waitlist
, SC
)) {
881 /* command not sent yet */
885 /* An explanation for the casual observer: */
886 /* Part of the function of a RAID controller is automatic error */
887 /* detection and recovery. As such, the only problem that physically */
888 /* resetting an adapter will ever fix is when, for some reason, */
889 /* the driver is not successfully communicating with the adapter. */
890 /* Therefore, we will attempt to flush this adapter. If that succeeds, */
891 /* then there's no real purpose in a physical reset. This will complete */
892 /* much faster and avoids any problems that might be caused by a */
893 /* physical reset ( such as having to fail all the outstanding I/O's ). */
895 if (ha
->ioctl_reset
== 0) { /* IF Not an IOCTL Requested Reset */
896 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
898 ips_init_scb(ha
, scb
);
900 scb
->timeout
= ips_cmd_timeout
;
901 scb
->cdb
[0] = IPS_CMD_FLUSH
;
903 scb
->cmd
.flush_cache
.op_code
= IPS_CMD_FLUSH
;
904 scb
->cmd
.flush_cache
.command_id
= IPS_COMMAND_ID(ha
, scb
);
905 scb
->cmd
.flush_cache
.state
= IPS_NORM_STATE
;
906 scb
->cmd
.flush_cache
.reserved
= 0;
907 scb
->cmd
.flush_cache
.reserved2
= 0;
908 scb
->cmd
.flush_cache
.reserved3
= 0;
909 scb
->cmd
.flush_cache
.reserved4
= 0;
911 /* Attempt the flush command */
912 ret
= ips_send_wait(ha
, scb
, ips_cmd_timeout
, IPS_INTR_IORL
);
913 if (ret
== IPS_SUCCESS
) {
914 IPS_PRINTK(KERN_NOTICE
, ha
->pcidev
,
915 "Reset Request - Flushed Cache\n");
920 /* Either we can't communicate with the adapter or it's an IOCTL request */
921 /* from a utility. A physical reset is needed at this point. */
923 ha
->ioctl_reset
= 0; /* Reset the IOCTL Requested Reset Flag */
926 * command must have already been sent
927 * reset the controller
929 IPS_PRINTK(KERN_NOTICE
, ha
->pcidev
, "Resetting controller.\n");
930 ret
= (*ha
->func
.reset
) (ha
);
933 struct scsi_cmnd
*scsi_cmd
;
935 IPS_PRINTK(KERN_NOTICE
, ha
->pcidev
,
936 "Controller reset failed - controller now offline.\n");
938 /* Now fail all of the active commands */
939 DEBUG_VAR(1, "(%s%d) Failing active commands",
940 ips_name
, ha
->host_num
);
942 while ((scb
= ips_removeq_scb_head(&ha
->scb_activelist
))) {
943 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
944 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
945 ips_freescb(ha
, scb
);
948 /* Now fail all of the pending commands */
949 DEBUG_VAR(1, "(%s%d) Failing pending commands",
950 ips_name
, ha
->host_num
);
952 while ((scsi_cmd
= ips_removeq_wait_head(&ha
->scb_waitlist
))) {
953 scsi_cmd
->result
= DID_ERROR
;
954 scsi_cmd
->scsi_done(scsi_cmd
);
961 if (!ips_clear_adapter(ha
, IPS_INTR_IORL
)) {
962 struct scsi_cmnd
*scsi_cmd
;
964 IPS_PRINTK(KERN_NOTICE
, ha
->pcidev
,
965 "Controller reset failed - controller now offline.\n");
967 /* Now fail all of the active commands */
968 DEBUG_VAR(1, "(%s%d) Failing active commands",
969 ips_name
, ha
->host_num
);
971 while ((scb
= ips_removeq_scb_head(&ha
->scb_activelist
))) {
972 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
973 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
974 ips_freescb(ha
, scb
);
977 /* Now fail all of the pending commands */
978 DEBUG_VAR(1, "(%s%d) Failing pending commands",
979 ips_name
, ha
->host_num
);
981 while ((scsi_cmd
= ips_removeq_wait_head(&ha
->scb_waitlist
))) {
982 scsi_cmd
->result
= DID_ERROR
<< 16;
983 scsi_cmd
->scsi_done(scsi_cmd
);
991 if (le32_to_cpu(ha
->subsys
->param
[3]) & 0x300000) {
994 do_gettimeofday(&tv
);
995 ha
->last_ffdc
= tv
.tv_sec
;
997 ips_ffdc_reset(ha
, IPS_INTR_IORL
);
1000 /* Now fail all of the active commands */
1001 DEBUG_VAR(1, "(%s%d) Failing active commands", ips_name
, ha
->host_num
);
1003 while ((scb
= ips_removeq_scb_head(&ha
->scb_activelist
))) {
1004 scb
->scsi_cmd
->result
= DID_RESET
<< 16;
1005 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
1006 ips_freescb(ha
, scb
);
1009 /* Reset DCDB active command bits */
1010 for (i
= 1; i
< ha
->nbus
; i
++)
1011 ha
->dcdb_active
[i
- 1] = 0;
1013 /* Reset the number of active IOCTLs */
1016 ips_next(ha
, IPS_INTR_IORL
);
1019 #endif /* NO_IPS_RESET */
1023 static int ips_eh_reset(struct scsi_cmnd
*SC
)
1027 spin_lock_irq(SC
->device
->host
->host_lock
);
1028 rc
= __ips_eh_reset(SC
);
1029 spin_unlock_irq(SC
->device
->host
->host_lock
);
1034 /****************************************************************************/
1036 /* Routine Name: ips_queue */
1038 /* Routine Description: */
1040 /* Send a command to the controller */
1043 /* Linux obtains io_request_lock before calling this function */
1045 /****************************************************************************/
1046 static int ips_queue_lck(struct scsi_cmnd
*SC
, void (*done
) (struct scsi_cmnd
*))
1051 METHOD_TRACE("ips_queue", 1);
1053 ha
= (ips_ha_t
*) SC
->device
->host
->hostdata
;
1061 if (ips_is_passthru(SC
)) {
1062 if (ha
->copp_waitlist
.count
== IPS_MAX_IOCTL_QUEUE
) {
1063 SC
->result
= DID_BUS_BUSY
<< 16;
1068 } else if (ha
->scb_waitlist
.count
== IPS_MAX_QUEUE
) {
1069 SC
->result
= DID_BUS_BUSY
<< 16;
1075 SC
->scsi_done
= done
;
1077 DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
1081 SC
->device
->channel
, SC
->device
->id
, SC
->device
->lun
);
1083 /* Check for command to initiator IDs */
1084 if ((scmd_channel(SC
) > 0)
1085 && (scmd_id(SC
) == ha
->ha_id
[scmd_channel(SC
)])) {
1086 SC
->result
= DID_NO_CONNECT
<< 16;
1092 if (ips_is_passthru(SC
)) {
1094 ips_copp_wait_item_t
*scratch
;
1096 /* A Reset IOCTL is only sent by the boot CD in extreme cases. */
1097 /* There can never be any system activity ( network or disk ), but check */
1098 /* anyway just as a good practice. */
1099 pt
= (ips_passthru_t
*) scsi_sglist(SC
);
1100 if ((pt
->CoppCP
.cmd
.reset
.op_code
== IPS_CMD_RESET_CHANNEL
) &&
1101 (pt
->CoppCP
.cmd
.reset
.adapter_flag
== 1)) {
1102 if (ha
->scb_activelist
.count
!= 0) {
1103 SC
->result
= DID_BUS_BUSY
<< 16;
1107 ha
->ioctl_reset
= 1; /* This reset request is from an IOCTL */
1109 SC
->result
= DID_OK
<< 16;
1114 /* allocate space for the scribble */
1115 scratch
= kmalloc(sizeof (ips_copp_wait_item_t
), GFP_ATOMIC
);
1118 SC
->result
= DID_ERROR
<< 16;
1124 scratch
->scsi_cmd
= SC
;
1125 scratch
->next
= NULL
;
1127 ips_putq_copp_tail(&ha
->copp_waitlist
, scratch
);
1129 ips_putq_wait_tail(&ha
->scb_waitlist
, SC
);
1132 ips_next(ha
, IPS_INTR_IORL
);
1137 static DEF_SCSI_QCMD(ips_queue
)
1139 /****************************************************************************/
1141 /* Routine Name: ips_biosparam */
1143 /* Routine Description: */
1145 /* Set bios geometry for the controller */
1147 /****************************************************************************/
1148 static int ips_biosparam(struct scsi_device
*sdev
, struct block_device
*bdev
,
1149 sector_t capacity
, int geom
[])
1151 ips_ha_t
*ha
= (ips_ha_t
*) sdev
->host
->hostdata
;
1156 METHOD_TRACE("ips_biosparam", 1);
1159 /* ?!?! host adater info invalid */
1165 if (!ips_read_adapter_status(ha
, IPS_INTR_ON
))
1166 /* ?!?! Enquiry command failed */
1169 if ((capacity
> 0x400000) && ((ha
->enq
->ucMiscFlag
& 0x8) == 0)) {
1170 heads
= IPS_NORM_HEADS
;
1171 sectors
= IPS_NORM_SECTORS
;
1173 heads
= IPS_COMP_HEADS
;
1174 sectors
= IPS_COMP_SECTORS
;
1177 cylinders
= (unsigned long) capacity
/ (heads
* sectors
);
1179 DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
1180 heads
, sectors
, cylinders
);
1184 geom
[2] = cylinders
;
1189 /****************************************************************************/
1191 /* Routine Name: ips_slave_configure */
1193 /* Routine Description: */
1195 /* Set queue depths on devices once scan is complete */
1197 /****************************************************************************/
1199 ips_slave_configure(struct scsi_device
* SDptr
)
1204 ha
= IPS_HA(SDptr
->host
);
1205 if (SDptr
->tagged_supported
&& SDptr
->type
== TYPE_DISK
) {
1206 min
= ha
->max_cmds
/ 2;
1207 if (ha
->enq
->ucLogDriveCount
<= 2)
1208 min
= ha
->max_cmds
- 1;
1209 scsi_change_queue_depth(SDptr
, min
);
1212 SDptr
->skip_ms_page_8
= 1;
1213 SDptr
->skip_ms_page_3f
= 1;
1217 /****************************************************************************/
1219 /* Routine Name: do_ipsintr */
1221 /* Routine Description: */
1223 /* Wrapper for the interrupt handler */
1225 /****************************************************************************/
1227 do_ipsintr(int irq
, void *dev_id
)
1230 struct Scsi_Host
*host
;
1233 METHOD_TRACE("do_ipsintr", 2);
1235 ha
= (ips_ha_t
*) dev_id
;
1238 host
= ips_sh
[ha
->host_num
];
1239 /* interrupt during initialization */
1241 (*ha
->func
.intr
) (ha
);
1245 spin_lock(host
->host_lock
);
1248 spin_unlock(host
->host_lock
);
1252 irqstatus
= (*ha
->func
.intr
) (ha
);
1254 spin_unlock(host
->host_lock
);
1256 /* start the next command */
1257 ips_next(ha
, IPS_INTR_ON
);
1258 return IRQ_RETVAL(irqstatus
);
1261 /****************************************************************************/
1263 /* Routine Name: ips_intr_copperhead */
1265 /* Routine Description: */
1267 /* Polling interrupt handler */
1269 /* ASSUMES interrupts are disabled */
1271 /****************************************************************************/
1273 ips_intr_copperhead(ips_ha_t
* ha
)
1280 METHOD_TRACE("ips_intr", 2);
1288 intrstatus
= (*ha
->func
.isintr
) (ha
);
1292 * Unexpected/Shared interrupt
1301 intrstatus
= (*ha
->func
.isintr
) (ha
);
1306 cstatus
.value
= (*ha
->func
.statupd
) (ha
);
1308 if (cstatus
.fields
.command_id
> (IPS_MAX_CMDS
- 1)) {
1309 /* Spurious Interrupt ? */
1313 ips_chkstatus(ha
, &cstatus
);
1314 scb
= (ips_scb_t
*) sp
->scb_addr
;
1317 * use the callback function to finish things up
1318 * NOTE: interrupts are OFF for this
1320 (*scb
->callback
) (ha
, scb
);
1325 /****************************************************************************/
1327 /* Routine Name: ips_intr_morpheus */
1329 /* Routine Description: */
1331 /* Polling interrupt handler */
1333 /* ASSUMES interrupts are disabled */
1335 /****************************************************************************/
1337 ips_intr_morpheus(ips_ha_t
* ha
)
1344 METHOD_TRACE("ips_intr_morpheus", 2);
1352 intrstatus
= (*ha
->func
.isintr
) (ha
);
1356 * Unexpected/Shared interrupt
1365 intrstatus
= (*ha
->func
.isintr
) (ha
);
1370 cstatus
.value
= (*ha
->func
.statupd
) (ha
);
1372 if (cstatus
.value
== 0xffffffff)
1373 /* No more to process */
1376 if (cstatus
.fields
.command_id
> (IPS_MAX_CMDS
- 1)) {
1377 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
1378 "Spurious interrupt; no ccb.\n");
1383 ips_chkstatus(ha
, &cstatus
);
1384 scb
= (ips_scb_t
*) sp
->scb_addr
;
1387 * use the callback function to finish things up
1388 * NOTE: interrupts are OFF for this
1390 (*scb
->callback
) (ha
, scb
);
1395 /****************************************************************************/
1397 /* Routine Name: ips_info */
1399 /* Routine Description: */
1401 /* Return info about the driver */
1403 /****************************************************************************/
1405 ips_info(struct Scsi_Host
*SH
)
1407 static char buffer
[256];
1411 METHOD_TRACE("ips_info", 1);
1419 memset(bp
, 0, sizeof (buffer
));
1421 sprintf(bp
, "%s%s%s Build %d", "IBM PCI ServeRAID ",
1422 IPS_VERSION_HIGH
, IPS_VERSION_LOW
, IPS_BUILD_IDENT
);
1424 if (ha
->ad_type
> 0 && ha
->ad_type
<= MAX_ADAPTER_NAME
) {
1426 strcat(bp
, ips_adapter_name
[ha
->ad_type
- 1]);
1434 ips_write_info(struct Scsi_Host
*host
, char *buffer
, int length
)
1437 ips_ha_t
*ha
= NULL
;
1439 /* Find our host structure */
1440 for (i
= 0; i
< ips_next_controller
; i
++) {
1442 if (ips_sh
[i
] == host
) {
1443 ha
= (ips_ha_t
*) ips_sh
[i
]->hostdata
;
1456 ips_show_info(struct seq_file
*m
, struct Scsi_Host
*host
)
1459 ips_ha_t
*ha
= NULL
;
1461 /* Find our host structure */
1462 for (i
= 0; i
< ips_next_controller
; i
++) {
1464 if (ips_sh
[i
] == host
) {
1465 ha
= (ips_ha_t
*) ips_sh
[i
]->hostdata
;
1474 return ips_host_info(ha
, m
);
1477 /*--------------------------------------------------------------------------*/
1478 /* Helper Functions */
1479 /*--------------------------------------------------------------------------*/
1481 /****************************************************************************/
1483 /* Routine Name: ips_is_passthru */
1485 /* Routine Description: */
1487 /* Determine if the specified SCSI command is really a passthru command */
1489 /****************************************************************************/
1490 static int ips_is_passthru(struct scsi_cmnd
*SC
)
1492 unsigned long flags
;
1494 METHOD_TRACE("ips_is_passthru", 1);
1499 if ((SC
->cmnd
[0] == IPS_IOCTL_COMMAND
) &&
1500 (SC
->device
->channel
== 0) &&
1501 (SC
->device
->id
== IPS_ADAPTER_ID
) &&
1502 (SC
->device
->lun
== 0) && scsi_sglist(SC
)) {
1503 struct scatterlist
*sg
= scsi_sglist(SC
);
1506 /* kmap_atomic() ensures addressability of the user buffer.*/
1507 /* local_irq_save() protects the KM_IRQ0 address slot. */
1508 local_irq_save(flags
);
1509 buffer
= kmap_atomic(sg_page(sg
)) + sg
->offset
;
1510 if (buffer
&& buffer
[0] == 'C' && buffer
[1] == 'O' &&
1511 buffer
[2] == 'P' && buffer
[3] == 'P') {
1512 kunmap_atomic(buffer
- sg
->offset
);
1513 local_irq_restore(flags
);
1516 kunmap_atomic(buffer
- sg
->offset
);
1517 local_irq_restore(flags
);
1522 /****************************************************************************/
1524 /* Routine Name: ips_alloc_passthru_buffer */
1526 /* Routine Description: */
1527 /* allocate a buffer large enough for the ioctl data if the ioctl buffer */
1528 /* is too small or doesn't exist */
1529 /****************************************************************************/
1531 ips_alloc_passthru_buffer(ips_ha_t
* ha
, int length
)
1534 dma_addr_t dma_busaddr
;
1536 if (ha
->ioctl_data
&& length
<= ha
->ioctl_len
)
1538 /* there is no buffer or it's not big enough, allocate a new one */
1539 bigger_buf
= pci_alloc_consistent(ha
->pcidev
, length
, &dma_busaddr
);
1541 /* free the old memory */
1542 pci_free_consistent(ha
->pcidev
, ha
->ioctl_len
, ha
->ioctl_data
,
1544 /* use the new memory */
1545 ha
->ioctl_data
= (char *) bigger_buf
;
1546 ha
->ioctl_len
= length
;
1547 ha
->ioctl_busaddr
= dma_busaddr
;
1554 /****************************************************************************/
1556 /* Routine Name: ips_make_passthru */
1558 /* Routine Description: */
1560 /* Make a passthru command out of the info in the Scsi block */
1562 /****************************************************************************/
1564 ips_make_passthru(ips_ha_t
*ha
, struct scsi_cmnd
*SC
, ips_scb_t
*scb
, int intr
)
1569 struct scatterlist
*sg
= scsi_sglist(SC
);
1571 METHOD_TRACE("ips_make_passthru", 1);
1573 scsi_for_each_sg(SC
, sg
, scsi_sg_count(SC
), i
)
1574 length
+= sg
->length
;
1576 if (length
< sizeof (ips_passthru_t
)) {
1578 DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
1579 ips_name
, ha
->host_num
);
1580 return (IPS_FAILURE
);
1582 if (ips_alloc_passthru_buffer(ha
, length
)) {
1583 /* allocation failure! If ha->ioctl_data exists, use it to return
1584 some error codes. Return a failed command to the scsi layer. */
1585 if (ha
->ioctl_data
) {
1586 pt
= (ips_passthru_t
*) ha
->ioctl_data
;
1587 ips_scmd_buf_read(SC
, pt
, sizeof (ips_passthru_t
));
1588 pt
->BasicStatus
= 0x0B;
1589 pt
->ExtendedStatus
= 0x00;
1590 ips_scmd_buf_write(SC
, pt
, sizeof (ips_passthru_t
));
1594 ha
->ioctl_datasize
= length
;
1596 ips_scmd_buf_read(SC
, ha
->ioctl_data
, ha
->ioctl_datasize
);
1597 pt
= (ips_passthru_t
*) ha
->ioctl_data
;
1600 * Some notes about the passthru interface used
1602 * IF the scsi op_code == 0x0d then we assume
1603 * that the data came along with/goes with the
1604 * packet we received from the sg driver. In this
1605 * case the CmdBSize field of the pt structure is
1606 * used for the size of the buffer.
1609 switch (pt
->CoppCmd
) {
1611 memcpy(ha
->ioctl_data
+ sizeof (ips_passthru_t
),
1612 &ips_num_controllers
, sizeof (int));
1613 ips_scmd_buf_write(SC
, ha
->ioctl_data
,
1614 sizeof (ips_passthru_t
) + sizeof (int));
1615 SC
->result
= DID_OK
<< 16;
1617 return (IPS_SUCCESS_IMM
);
1619 case IPS_COPPUSRCMD
:
1620 case IPS_COPPIOCCMD
:
1621 if (SC
->cmnd
[0] == IPS_IOCTL_COMMAND
) {
1622 if (length
< (sizeof (ips_passthru_t
) + pt
->CmdBSize
)) {
1625 "(%s%d) Passthru structure wrong size",
1626 ips_name
, ha
->host_num
);
1628 return (IPS_FAILURE
);
1631 if (ha
->pcidev
->device
== IPS_DEVICEID_COPPERHEAD
&&
1632 pt
->CoppCP
.cmd
.flashfw
.op_code
==
1633 IPS_CMD_RW_BIOSFW
) {
1634 ret
= ips_flash_copperhead(ha
, pt
, scb
);
1635 ips_scmd_buf_write(SC
, ha
->ioctl_data
,
1636 sizeof (ips_passthru_t
));
1639 if (ips_usrcmd(ha
, pt
, scb
))
1640 return (IPS_SUCCESS
);
1642 return (IPS_FAILURE
);
1649 return (IPS_FAILURE
);
1652 /****************************************************************************/
1653 /* Routine Name: ips_flash_copperhead */
1654 /* Routine Description: */
1655 /* Flash the BIOS/FW on a Copperhead style controller */
1656 /****************************************************************************/
1658 ips_flash_copperhead(ips_ha_t
* ha
, ips_passthru_t
* pt
, ips_scb_t
* scb
)
1662 /* Trombone is the only copperhead that can do packet flash, but only
1663 * for firmware. No one said it had to make sense. */
1664 if (IPS_IS_TROMBONE(ha
) && pt
->CoppCP
.cmd
.flashfw
.type
== IPS_FW_IMAGE
) {
1665 if (ips_usrcmd(ha
, pt
, scb
))
1670 pt
->BasicStatus
= 0x0B;
1671 pt
->ExtendedStatus
= 0;
1672 scb
->scsi_cmd
->result
= DID_OK
<< 16;
1673 /* IF it's OK to Use the "CD BOOT" Flash Buffer, then you can */
1674 /* avoid allocating a huge buffer per adapter ( which can fail ). */
1675 if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_BIOS_IMAGE
&&
1676 pt
->CoppCP
.cmd
.flashfw
.direction
== IPS_ERASE_BIOS
) {
1677 pt
->BasicStatus
= 0;
1678 return ips_flash_bios(ha
, pt
, scb
);
1679 } else if (pt
->CoppCP
.cmd
.flashfw
.packet_num
== 0) {
1680 if (ips_FlashData
&& !test_and_set_bit(0, &ips_FlashDataInUse
)){
1681 ha
->flash_data
= ips_FlashData
;
1682 ha
->flash_busaddr
= ips_flashbusaddr
;
1683 ha
->flash_len
= PAGE_SIZE
<< 7;
1684 ha
->flash_datasize
= 0;
1685 } else if (!ha
->flash_data
) {
1686 datasize
= pt
->CoppCP
.cmd
.flashfw
.total_packets
*
1687 pt
->CoppCP
.cmd
.flashfw
.count
;
1688 ha
->flash_data
= pci_alloc_consistent(ha
->pcidev
,
1690 &ha
->flash_busaddr
);
1691 if (!ha
->flash_data
){
1692 printk(KERN_WARNING
"Unable to allocate a flash buffer\n");
1695 ha
->flash_datasize
= 0;
1696 ha
->flash_len
= datasize
;
1700 if (pt
->CoppCP
.cmd
.flashfw
.count
+ ha
->flash_datasize
>
1702 ips_free_flash_copperhead(ha
);
1703 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
1704 "failed size sanity check\n");
1708 if (!ha
->flash_data
)
1710 pt
->BasicStatus
= 0;
1711 memcpy(&ha
->flash_data
[ha
->flash_datasize
], pt
+ 1,
1712 pt
->CoppCP
.cmd
.flashfw
.count
);
1713 ha
->flash_datasize
+= pt
->CoppCP
.cmd
.flashfw
.count
;
1714 if (pt
->CoppCP
.cmd
.flashfw
.packet_num
==
1715 pt
->CoppCP
.cmd
.flashfw
.total_packets
- 1) {
1716 if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_BIOS_IMAGE
)
1717 return ips_flash_bios(ha
, pt
, scb
);
1718 else if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_FW_IMAGE
)
1719 return ips_flash_firmware(ha
, pt
, scb
);
1721 return IPS_SUCCESS_IMM
;
1724 /****************************************************************************/
1725 /* Routine Name: ips_flash_bios */
1726 /* Routine Description: */
1727 /* flashes the bios of a copperhead adapter */
1728 /****************************************************************************/
1730 ips_flash_bios(ips_ha_t
* ha
, ips_passthru_t
* pt
, ips_scb_t
* scb
)
1733 if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_BIOS_IMAGE
&&
1734 pt
->CoppCP
.cmd
.flashfw
.direction
== IPS_WRITE_BIOS
) {
1735 if ((!ha
->func
.programbios
) || (!ha
->func
.erasebios
) ||
1736 (!ha
->func
.verifybios
))
1738 if ((*ha
->func
.erasebios
) (ha
)) {
1740 "(%s%d) flash bios failed - unable to erase flash",
1741 ips_name
, ha
->host_num
);
1744 if ((*ha
->func
.programbios
) (ha
,
1747 ha
->flash_datasize
-
1748 IPS_BIOS_HEADER
, 0)) {
1750 "(%s%d) flash bios failed - unable to flash",
1751 ips_name
, ha
->host_num
);
1754 if ((*ha
->func
.verifybios
) (ha
,
1757 ha
->flash_datasize
-
1758 IPS_BIOS_HEADER
, 0)) {
1760 "(%s%d) flash bios failed - unable to verify flash",
1761 ips_name
, ha
->host_num
);
1764 ips_free_flash_copperhead(ha
);
1765 return IPS_SUCCESS_IMM
;
1766 } else if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_BIOS_IMAGE
&&
1767 pt
->CoppCP
.cmd
.flashfw
.direction
== IPS_ERASE_BIOS
) {
1768 if (!ha
->func
.erasebios
)
1770 if ((*ha
->func
.erasebios
) (ha
)) {
1772 "(%s%d) flash bios failed - unable to erase flash",
1773 ips_name
, ha
->host_num
);
1776 return IPS_SUCCESS_IMM
;
1779 pt
->BasicStatus
= 0x0B;
1780 pt
->ExtendedStatus
= 0x00;
1781 ips_free_flash_copperhead(ha
);
1785 /****************************************************************************/
1787 /* Routine Name: ips_fill_scb_sg_single */
1789 /* Routine Description: */
1790 /* Fill in a single scb sg_list element from an address */
1791 /* return a -1 if a breakup occurred */
1792 /****************************************************************************/
1794 ips_fill_scb_sg_single(ips_ha_t
* ha
, dma_addr_t busaddr
,
1795 ips_scb_t
* scb
, int indx
, unsigned int e_len
)
1800 if ((scb
->data_len
+ e_len
) > ha
->max_xfer
) {
1801 e_len
= ha
->max_xfer
- scb
->data_len
;
1802 scb
->breakup
= indx
;
1809 if (IPS_USE_ENH_SGLIST(ha
)) {
1810 scb
->sg_list
.enh_list
[indx
].address_lo
=
1811 cpu_to_le32(pci_dma_lo32(busaddr
));
1812 scb
->sg_list
.enh_list
[indx
].address_hi
=
1813 cpu_to_le32(pci_dma_hi32(busaddr
));
1814 scb
->sg_list
.enh_list
[indx
].length
= cpu_to_le32(e_len
);
1816 scb
->sg_list
.std_list
[indx
].address
=
1817 cpu_to_le32(pci_dma_lo32(busaddr
));
1818 scb
->sg_list
.std_list
[indx
].length
= cpu_to_le32(e_len
);
1822 scb
->data_len
+= e_len
;
1826 /****************************************************************************/
1827 /* Routine Name: ips_flash_firmware */
1828 /* Routine Description: */
1829 /* flashes the firmware of a copperhead adapter */
1830 /****************************************************************************/
1832 ips_flash_firmware(ips_ha_t
* ha
, ips_passthru_t
* pt
, ips_scb_t
* scb
)
1834 IPS_SG_LIST sg_list
;
1835 uint32_t cmd_busaddr
;
1837 if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_FW_IMAGE
&&
1838 pt
->CoppCP
.cmd
.flashfw
.direction
== IPS_WRITE_FW
) {
1839 memset(&pt
->CoppCP
.cmd
, 0, sizeof (IPS_HOST_COMMAND
));
1840 pt
->CoppCP
.cmd
.flashfw
.op_code
= IPS_CMD_DOWNLOAD
;
1841 pt
->CoppCP
.cmd
.flashfw
.count
= cpu_to_le32(ha
->flash_datasize
);
1843 pt
->BasicStatus
= 0x0B;
1844 pt
->ExtendedStatus
= 0x00;
1845 ips_free_flash_copperhead(ha
);
1848 /* Save the S/G list pointer so it doesn't get clobbered */
1849 sg_list
.list
= scb
->sg_list
.list
;
1850 cmd_busaddr
= scb
->scb_busaddr
;
1851 /* copy in the CP */
1852 memcpy(&scb
->cmd
, &pt
->CoppCP
.cmd
, sizeof (IPS_IOCTL_CMD
));
1853 /* FIX stuff that might be wrong */
1854 scb
->sg_list
.list
= sg_list
.list
;
1855 scb
->scb_busaddr
= cmd_busaddr
;
1856 scb
->bus
= scb
->scsi_cmd
->device
->channel
;
1857 scb
->target_id
= scb
->scsi_cmd
->device
->id
;
1858 scb
->lun
= scb
->scsi_cmd
->device
->lun
;
1863 scb
->callback
= ipsintr_done
;
1864 scb
->timeout
= ips_cmd_timeout
;
1866 scb
->data_len
= ha
->flash_datasize
;
1868 pci_map_single(ha
->pcidev
, ha
->flash_data
, scb
->data_len
,
1870 scb
->flags
|= IPS_SCB_MAP_SINGLE
;
1871 scb
->cmd
.flashfw
.command_id
= IPS_COMMAND_ID(ha
, scb
);
1872 scb
->cmd
.flashfw
.buffer_addr
= cpu_to_le32(scb
->data_busaddr
);
1874 scb
->timeout
= pt
->TimeOut
;
1875 scb
->scsi_cmd
->result
= DID_OK
<< 16;
1879 /****************************************************************************/
1880 /* Routine Name: ips_free_flash_copperhead */
1881 /* Routine Description: */
1882 /* release the memory resources used to hold the flash image */
1883 /****************************************************************************/
1885 ips_free_flash_copperhead(ips_ha_t
* ha
)
1887 if (ha
->flash_data
== ips_FlashData
)
1888 test_and_clear_bit(0, &ips_FlashDataInUse
);
1889 else if (ha
->flash_data
)
1890 pci_free_consistent(ha
->pcidev
, ha
->flash_len
, ha
->flash_data
,
1892 ha
->flash_data
= NULL
;
1895 /****************************************************************************/
1897 /* Routine Name: ips_usrcmd */
1899 /* Routine Description: */
1901 /* Process a user command and make it ready to send */
1903 /****************************************************************************/
1905 ips_usrcmd(ips_ha_t
* ha
, ips_passthru_t
* pt
, ips_scb_t
* scb
)
1907 IPS_SG_LIST sg_list
;
1908 uint32_t cmd_busaddr
;
1910 METHOD_TRACE("ips_usrcmd", 1);
1912 if ((!scb
) || (!pt
) || (!ha
))
1915 /* Save the S/G list pointer so it doesn't get clobbered */
1916 sg_list
.list
= scb
->sg_list
.list
;
1917 cmd_busaddr
= scb
->scb_busaddr
;
1918 /* copy in the CP */
1919 memcpy(&scb
->cmd
, &pt
->CoppCP
.cmd
, sizeof (IPS_IOCTL_CMD
));
1920 memcpy(&scb
->dcdb
, &pt
->CoppCP
.dcdb
, sizeof (IPS_DCDB_TABLE
));
1922 /* FIX stuff that might be wrong */
1923 scb
->sg_list
.list
= sg_list
.list
;
1924 scb
->scb_busaddr
= cmd_busaddr
;
1925 scb
->bus
= scb
->scsi_cmd
->device
->channel
;
1926 scb
->target_id
= scb
->scsi_cmd
->device
->id
;
1927 scb
->lun
= scb
->scsi_cmd
->device
->lun
;
1932 scb
->callback
= ipsintr_done
;
1933 scb
->timeout
= ips_cmd_timeout
;
1934 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
1936 /* we don't support DCDB/READ/WRITE Scatter Gather */
1937 if ((scb
->cmd
.basic_io
.op_code
== IPS_CMD_READ_SG
) ||
1938 (scb
->cmd
.basic_io
.op_code
== IPS_CMD_WRITE_SG
) ||
1939 (scb
->cmd
.basic_io
.op_code
== IPS_CMD_DCDB_SG
))
1943 scb
->data_len
= pt
->CmdBSize
;
1944 scb
->data_busaddr
= ha
->ioctl_busaddr
+ sizeof (ips_passthru_t
);
1946 scb
->data_busaddr
= 0L;
1949 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_DCDB
)
1950 scb
->cmd
.dcdb
.dcdb_address
= cpu_to_le32(scb
->scb_busaddr
+
1951 (unsigned long) &scb
->
1953 (unsigned long) scb
);
1956 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_DCDB
)
1957 scb
->dcdb
.buffer_pointer
=
1958 cpu_to_le32(scb
->data_busaddr
);
1960 scb
->cmd
.basic_io
.sg_addr
=
1961 cpu_to_le32(scb
->data_busaddr
);
1966 scb
->timeout
= pt
->TimeOut
;
1968 if (pt
->TimeOut
<= 10)
1969 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT10
;
1970 else if (pt
->TimeOut
<= 60)
1971 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT60
;
1973 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT20M
;
1976 /* assume success */
1977 scb
->scsi_cmd
->result
= DID_OK
<< 16;
1983 /****************************************************************************/
1985 /* Routine Name: ips_cleanup_passthru */
1987 /* Routine Description: */
1989 /* Cleanup after a passthru command */
1991 /****************************************************************************/
1993 ips_cleanup_passthru(ips_ha_t
* ha
, ips_scb_t
* scb
)
1997 METHOD_TRACE("ips_cleanup_passthru", 1);
1999 if ((!scb
) || (!scb
->scsi_cmd
) || (!scsi_sglist(scb
->scsi_cmd
))) {
2000 DEBUG_VAR(1, "(%s%d) couldn't cleanup after passthru",
2001 ips_name
, ha
->host_num
);
2005 pt
= (ips_passthru_t
*) ha
->ioctl_data
;
2007 /* Copy data back to the user */
2008 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_DCDB
) /* Copy DCDB Back to Caller's Area */
2009 memcpy(&pt
->CoppCP
.dcdb
, &scb
->dcdb
, sizeof (IPS_DCDB_TABLE
));
2011 pt
->BasicStatus
= scb
->basic_status
;
2012 pt
->ExtendedStatus
= scb
->extended_status
;
2013 pt
->AdapterType
= ha
->ad_type
;
2015 if (ha
->pcidev
->device
== IPS_DEVICEID_COPPERHEAD
&&
2016 (scb
->cmd
.flashfw
.op_code
== IPS_CMD_DOWNLOAD
||
2017 scb
->cmd
.flashfw
.op_code
== IPS_CMD_RW_BIOSFW
))
2018 ips_free_flash_copperhead(ha
);
2020 ips_scmd_buf_write(scb
->scsi_cmd
, ha
->ioctl_data
, ha
->ioctl_datasize
);
2023 /****************************************************************************/
2025 /* Routine Name: ips_host_info */
2027 /* Routine Description: */
2029 /* The passthru interface for the driver */
2031 /****************************************************************************/
2033 ips_host_info(ips_ha_t
*ha
, struct seq_file
*m
)
2035 METHOD_TRACE("ips_host_info", 1);
2037 seq_puts(m
, "\nIBM ServeRAID General Information:\n\n");
2039 if ((le32_to_cpu(ha
->nvram
->signature
) == IPS_NVRAM_P5_SIG
) &&
2040 (le16_to_cpu(ha
->nvram
->adapter_type
) != 0))
2041 seq_printf(m
, "\tController Type : %s\n",
2042 ips_adapter_name
[ha
->ad_type
- 1]);
2044 seq_puts(m
, "\tController Type : Unknown\n");
2048 "\tIO region : 0x%x (%d bytes)\n",
2049 ha
->io_addr
, ha
->io_len
);
2053 "\tMemory region : 0x%x (%d bytes)\n",
2054 ha
->mem_addr
, ha
->mem_len
);
2056 "\tShared memory address : 0x%lx\n",
2057 (unsigned long)ha
->mem_ptr
);
2060 seq_printf(m
, "\tIRQ number : %d\n", ha
->pcidev
->irq
);
2062 /* For the Next 3 lines Check for Binary 0 at the end and don't include it if it's there. */
2063 /* That keeps everything happy for "text" operations on the proc file. */
2065 if (le32_to_cpu(ha
->nvram
->signature
) == IPS_NVRAM_P5_SIG
) {
2066 if (ha
->nvram
->bios_low
[3] == 0) {
2068 "\tBIOS Version : %c%c%c%c%c%c%c\n",
2069 ha
->nvram
->bios_high
[0], ha
->nvram
->bios_high
[1],
2070 ha
->nvram
->bios_high
[2], ha
->nvram
->bios_high
[3],
2071 ha
->nvram
->bios_low
[0], ha
->nvram
->bios_low
[1],
2072 ha
->nvram
->bios_low
[2]);
2076 "\tBIOS Version : %c%c%c%c%c%c%c%c\n",
2077 ha
->nvram
->bios_high
[0], ha
->nvram
->bios_high
[1],
2078 ha
->nvram
->bios_high
[2], ha
->nvram
->bios_high
[3],
2079 ha
->nvram
->bios_low
[0], ha
->nvram
->bios_low
[1],
2080 ha
->nvram
->bios_low
[2], ha
->nvram
->bios_low
[3]);
2085 if (ha
->enq
->CodeBlkVersion
[7] == 0) {
2087 "\tFirmware Version : %c%c%c%c%c%c%c\n",
2088 ha
->enq
->CodeBlkVersion
[0], ha
->enq
->CodeBlkVersion
[1],
2089 ha
->enq
->CodeBlkVersion
[2], ha
->enq
->CodeBlkVersion
[3],
2090 ha
->enq
->CodeBlkVersion
[4], ha
->enq
->CodeBlkVersion
[5],
2091 ha
->enq
->CodeBlkVersion
[6]);
2094 "\tFirmware Version : %c%c%c%c%c%c%c%c\n",
2095 ha
->enq
->CodeBlkVersion
[0], ha
->enq
->CodeBlkVersion
[1],
2096 ha
->enq
->CodeBlkVersion
[2], ha
->enq
->CodeBlkVersion
[3],
2097 ha
->enq
->CodeBlkVersion
[4], ha
->enq
->CodeBlkVersion
[5],
2098 ha
->enq
->CodeBlkVersion
[6], ha
->enq
->CodeBlkVersion
[7]);
2101 if (ha
->enq
->BootBlkVersion
[7] == 0) {
2103 "\tBoot Block Version : %c%c%c%c%c%c%c\n",
2104 ha
->enq
->BootBlkVersion
[0], ha
->enq
->BootBlkVersion
[1],
2105 ha
->enq
->BootBlkVersion
[2], ha
->enq
->BootBlkVersion
[3],
2106 ha
->enq
->BootBlkVersion
[4], ha
->enq
->BootBlkVersion
[5],
2107 ha
->enq
->BootBlkVersion
[6]);
2110 "\tBoot Block Version : %c%c%c%c%c%c%c%c\n",
2111 ha
->enq
->BootBlkVersion
[0], ha
->enq
->BootBlkVersion
[1],
2112 ha
->enq
->BootBlkVersion
[2], ha
->enq
->BootBlkVersion
[3],
2113 ha
->enq
->BootBlkVersion
[4], ha
->enq
->BootBlkVersion
[5],
2114 ha
->enq
->BootBlkVersion
[6], ha
->enq
->BootBlkVersion
[7]);
2117 seq_printf(m
, "\tDriver Version : %s%s\n",
2118 IPS_VERSION_HIGH
, IPS_VERSION_LOW
);
2120 seq_printf(m
, "\tDriver Build : %d\n",
2123 seq_printf(m
, "\tMax Physical Devices : %d\n",
2124 ha
->enq
->ucMaxPhysicalDevices
);
2125 seq_printf(m
, "\tMax Active Commands : %d\n",
2127 seq_printf(m
, "\tCurrent Queued Commands : %d\n",
2128 ha
->scb_waitlist
.count
);
2129 seq_printf(m
, "\tCurrent Active Commands : %d\n",
2130 ha
->scb_activelist
.count
- ha
->num_ioctl
);
2131 seq_printf(m
, "\tCurrent Queued PT Commands : %d\n",
2132 ha
->copp_waitlist
.count
);
2133 seq_printf(m
, "\tCurrent Active PT Commands : %d\n",
2141 /****************************************************************************/
2143 /* Routine Name: ips_identify_controller */
2145 /* Routine Description: */
2147 /* Identify this controller */
2149 /****************************************************************************/
2151 ips_identify_controller(ips_ha_t
* ha
)
2153 METHOD_TRACE("ips_identify_controller", 1);
2155 switch (ha
->pcidev
->device
) {
2156 case IPS_DEVICEID_COPPERHEAD
:
2157 if (ha
->pcidev
->revision
<= IPS_REVID_SERVERAID
) {
2158 ha
->ad_type
= IPS_ADTYPE_SERVERAID
;
2159 } else if (ha
->pcidev
->revision
== IPS_REVID_SERVERAID2
) {
2160 ha
->ad_type
= IPS_ADTYPE_SERVERAID2
;
2161 } else if (ha
->pcidev
->revision
== IPS_REVID_NAVAJO
) {
2162 ha
->ad_type
= IPS_ADTYPE_NAVAJO
;
2163 } else if ((ha
->pcidev
->revision
== IPS_REVID_SERVERAID2
)
2164 && (ha
->slot_num
== 0)) {
2165 ha
->ad_type
= IPS_ADTYPE_KIOWA
;
2166 } else if ((ha
->pcidev
->revision
>= IPS_REVID_CLARINETP1
) &&
2167 (ha
->pcidev
->revision
<= IPS_REVID_CLARINETP3
)) {
2168 if (ha
->enq
->ucMaxPhysicalDevices
== 15)
2169 ha
->ad_type
= IPS_ADTYPE_SERVERAID3L
;
2171 ha
->ad_type
= IPS_ADTYPE_SERVERAID3
;
2172 } else if ((ha
->pcidev
->revision
>= IPS_REVID_TROMBONE32
) &&
2173 (ha
->pcidev
->revision
<= IPS_REVID_TROMBONE64
)) {
2174 ha
->ad_type
= IPS_ADTYPE_SERVERAID4H
;
2178 case IPS_DEVICEID_MORPHEUS
:
2179 switch (ha
->pcidev
->subsystem_device
) {
2180 case IPS_SUBDEVICEID_4L
:
2181 ha
->ad_type
= IPS_ADTYPE_SERVERAID4L
;
2184 case IPS_SUBDEVICEID_4M
:
2185 ha
->ad_type
= IPS_ADTYPE_SERVERAID4M
;
2188 case IPS_SUBDEVICEID_4MX
:
2189 ha
->ad_type
= IPS_ADTYPE_SERVERAID4MX
;
2192 case IPS_SUBDEVICEID_4LX
:
2193 ha
->ad_type
= IPS_ADTYPE_SERVERAID4LX
;
2196 case IPS_SUBDEVICEID_5I2
:
2197 ha
->ad_type
= IPS_ADTYPE_SERVERAID5I2
;
2200 case IPS_SUBDEVICEID_5I1
:
2201 ha
->ad_type
= IPS_ADTYPE_SERVERAID5I1
;
2207 case IPS_DEVICEID_MARCO
:
2208 switch (ha
->pcidev
->subsystem_device
) {
2209 case IPS_SUBDEVICEID_6M
:
2210 ha
->ad_type
= IPS_ADTYPE_SERVERAID6M
;
2212 case IPS_SUBDEVICEID_6I
:
2213 ha
->ad_type
= IPS_ADTYPE_SERVERAID6I
;
2215 case IPS_SUBDEVICEID_7k
:
2216 ha
->ad_type
= IPS_ADTYPE_SERVERAID7k
;
2218 case IPS_SUBDEVICEID_7M
:
2219 ha
->ad_type
= IPS_ADTYPE_SERVERAID7M
;
2226 /****************************************************************************/
2228 /* Routine Name: ips_get_bios_version */
2230 /* Routine Description: */
2232 /* Get the BIOS revision number */
2234 /****************************************************************************/
2236 ips_get_bios_version(ips_ha_t
* ha
, int intr
)
2245 METHOD_TRACE("ips_get_bios_version", 1);
2250 strncpy(ha
->bios_version
, " ?", 8);
2252 if (ha
->pcidev
->device
== IPS_DEVICEID_COPPERHEAD
) {
2253 if (IPS_USE_MEMIO(ha
)) {
2254 /* Memory Mapped I/O */
2257 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
2258 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
2259 udelay(25); /* 25 us */
2261 if (readb(ha
->mem_ptr
+ IPS_REG_FLDP
) != 0x55)
2264 writel(1, ha
->mem_ptr
+ IPS_REG_FLAP
);
2265 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
2266 udelay(25); /* 25 us */
2268 if (readb(ha
->mem_ptr
+ IPS_REG_FLDP
) != 0xAA)
2271 /* Get Major version */
2272 writel(0x1FF, ha
->mem_ptr
+ IPS_REG_FLAP
);
2273 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
2274 udelay(25); /* 25 us */
2276 major
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
2278 /* Get Minor version */
2279 writel(0x1FE, ha
->mem_ptr
+ IPS_REG_FLAP
);
2280 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
2281 udelay(25); /* 25 us */
2282 minor
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
2284 /* Get SubMinor version */
2285 writel(0x1FD, ha
->mem_ptr
+ IPS_REG_FLAP
);
2286 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
2287 udelay(25); /* 25 us */
2288 subminor
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
2291 /* Programmed I/O */
2294 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
2295 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
2296 udelay(25); /* 25 us */
2298 if (inb(ha
->io_addr
+ IPS_REG_FLDP
) != 0x55)
2301 outl(1, ha
->io_addr
+ IPS_REG_FLAP
);
2302 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
2303 udelay(25); /* 25 us */
2305 if (inb(ha
->io_addr
+ IPS_REG_FLDP
) != 0xAA)
2308 /* Get Major version */
2309 outl(0x1FF, ha
->io_addr
+ IPS_REG_FLAP
);
2310 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
2311 udelay(25); /* 25 us */
2313 major
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
2315 /* Get Minor version */
2316 outl(0x1FE, ha
->io_addr
+ IPS_REG_FLAP
);
2317 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
2318 udelay(25); /* 25 us */
2320 minor
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
2322 /* Get SubMinor version */
2323 outl(0x1FD, ha
->io_addr
+ IPS_REG_FLAP
);
2324 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
2325 udelay(25); /* 25 us */
2327 subminor
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
2331 /* Morpheus Family - Send Command to the card */
2333 buffer
= ha
->ioctl_data
;
2335 memset(buffer
, 0, 0x1000);
2337 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
2339 ips_init_scb(ha
, scb
);
2341 scb
->timeout
= ips_cmd_timeout
;
2342 scb
->cdb
[0] = IPS_CMD_RW_BIOSFW
;
2344 scb
->cmd
.flashfw
.op_code
= IPS_CMD_RW_BIOSFW
;
2345 scb
->cmd
.flashfw
.command_id
= IPS_COMMAND_ID(ha
, scb
);
2346 scb
->cmd
.flashfw
.type
= 1;
2347 scb
->cmd
.flashfw
.direction
= 0;
2348 scb
->cmd
.flashfw
.count
= cpu_to_le32(0x800);
2349 scb
->cmd
.flashfw
.total_packets
= 1;
2350 scb
->cmd
.flashfw
.packet_num
= 0;
2351 scb
->data_len
= 0x1000;
2352 scb
->cmd
.flashfw
.buffer_addr
= ha
->ioctl_busaddr
;
2354 /* issue the command */
2356 ips_send_wait(ha
, scb
, ips_cmd_timeout
,
2357 intr
)) == IPS_FAILURE
)
2358 || (ret
== IPS_SUCCESS_IMM
)
2359 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1)) {
2360 /* Error occurred */
2365 if ((buffer
[0xC0] == 0x55) && (buffer
[0xC1] == 0xAA)) {
2366 major
= buffer
[0x1ff + 0xC0]; /* Offset 0x1ff after the header (0xc0) */
2367 minor
= buffer
[0x1fe + 0xC0]; /* Offset 0x1fe after the header (0xc0) */
2368 subminor
= buffer
[0x1fd + 0xC0]; /* Offset 0x1fd after the header (0xc0) */
2374 ha
->bios_version
[0] = hex_asc_upper_hi(major
);
2375 ha
->bios_version
[1] = '.';
2376 ha
->bios_version
[2] = hex_asc_upper_lo(major
);
2377 ha
->bios_version
[3] = hex_asc_upper_lo(subminor
);
2378 ha
->bios_version
[4] = '.';
2379 ha
->bios_version
[5] = hex_asc_upper_hi(minor
);
2380 ha
->bios_version
[6] = hex_asc_upper_lo(minor
);
2381 ha
->bios_version
[7] = 0;
2384 /****************************************************************************/
2386 /* Routine Name: ips_hainit */
2388 /* Routine Description: */
2390 /* Initialize the controller */
2392 /* NOTE: Assumes to be called from with a lock */
2394 /****************************************************************************/
2396 ips_hainit(ips_ha_t
* ha
)
2401 METHOD_TRACE("ips_hainit", 1);
2406 if (ha
->func
.statinit
)
2407 (*ha
->func
.statinit
) (ha
);
2409 if (ha
->func
.enableint
)
2410 (*ha
->func
.enableint
) (ha
);
2413 ha
->reset_count
= 1;
2414 do_gettimeofday(&tv
);
2415 ha
->last_ffdc
= tv
.tv_sec
;
2416 ips_ffdc_reset(ha
, IPS_INTR_IORL
);
2418 if (!ips_read_config(ha
, IPS_INTR_IORL
)) {
2419 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
2420 "unable to read config from controller.\n");
2425 if (!ips_read_adapter_status(ha
, IPS_INTR_IORL
)) {
2426 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
2427 "unable to read controller status.\n");
2432 /* Identify this controller */
2433 ips_identify_controller(ha
);
2435 if (!ips_read_subsystem_parameters(ha
, IPS_INTR_IORL
)) {
2436 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
2437 "unable to read subsystem parameters.\n");
2442 /* write nvram user page 5 */
2443 if (!ips_write_driver_status(ha
, IPS_INTR_IORL
)) {
2444 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
2445 "unable to write driver info to controller.\n");
2450 /* If there are Logical Drives and a Reset Occurred, then an EraseStripeLock is Needed */
2451 if ((ha
->conf
->ucLogDriveCount
> 0) && (ha
->requires_esl
== 1))
2452 ips_clear_adapter(ha
, IPS_INTR_IORL
);
2454 /* set limits on SID, LUN, BUS */
2455 ha
->ntargets
= IPS_MAX_TARGETS
+ 1;
2457 ha
->nbus
= (ha
->enq
->ucMaxPhysicalDevices
/ IPS_MAX_TARGETS
) + 1;
2459 switch (ha
->conf
->logical_drive
[0].ucStripeSize
) {
2461 ha
->max_xfer
= 0x10000;
2465 ha
->max_xfer
= 0x20000;
2469 ha
->max_xfer
= 0x40000;
2474 ha
->max_xfer
= 0x80000;
2478 /* setup max concurrent commands */
2479 if (le32_to_cpu(ha
->subsys
->param
[4]) & 0x1) {
2480 /* Use the new method */
2481 ha
->max_cmds
= ha
->enq
->ucConcurrentCmdCount
;
2483 /* use the old method */
2484 switch (ha
->conf
->logical_drive
[0].ucStripeSize
) {
2504 /* Limit the Active Commands on a Lite Adapter */
2505 if ((ha
->ad_type
== IPS_ADTYPE_SERVERAID3L
) ||
2506 (ha
->ad_type
== IPS_ADTYPE_SERVERAID4L
) ||
2507 (ha
->ad_type
== IPS_ADTYPE_SERVERAID4LX
)) {
2508 if ((ha
->max_cmds
> MaxLiteCmds
) && (MaxLiteCmds
))
2509 ha
->max_cmds
= MaxLiteCmds
;
2512 /* set controller IDs */
2513 ha
->ha_id
[0] = IPS_ADAPTER_ID
;
2514 for (i
= 1; i
< ha
->nbus
; i
++) {
2515 ha
->ha_id
[i
] = ha
->conf
->init_id
[i
- 1] & 0x1f;
2516 ha
->dcdb_active
[i
- 1] = 0;
2522 /****************************************************************************/
2524 /* Routine Name: ips_next */
2526 /* Routine Description: */
2528 /* Take the next command off the queue and send it to the controller */
2530 /****************************************************************************/
2532 ips_next(ips_ha_t
* ha
, int intr
)
2535 struct scsi_cmnd
*SC
;
2536 struct scsi_cmnd
*p
;
2537 struct scsi_cmnd
*q
;
2538 ips_copp_wait_item_t
*item
;
2540 struct Scsi_Host
*host
;
2541 METHOD_TRACE("ips_next", 1);
2545 host
= ips_sh
[ha
->host_num
];
2547 * Block access to the queue function so
2548 * this command won't time out
2550 if (intr
== IPS_INTR_ON
)
2551 spin_lock(host
->host_lock
);
2553 if ((ha
->subsys
->param
[3] & 0x300000)
2554 && (ha
->scb_activelist
.count
== 0)) {
2557 do_gettimeofday(&tv
);
2559 if (tv
.tv_sec
- ha
->last_ffdc
> IPS_SECS_8HOURS
) {
2560 ha
->last_ffdc
= tv
.tv_sec
;
2566 * Send passthru commands
2567 * These have priority over normal I/O
2568 * but shouldn't affect performance too much
2569 * since we limit the number that can be active
2570 * on the card at any one time
2572 while ((ha
->num_ioctl
< IPS_MAX_IOCTL
) &&
2573 (ha
->copp_waitlist
.head
) && (scb
= ips_getscb(ha
))) {
2575 item
= ips_removeq_copp_head(&ha
->copp_waitlist
);
2577 if (intr
== IPS_INTR_ON
)
2578 spin_unlock(host
->host_lock
);
2579 scb
->scsi_cmd
= item
->scsi_cmd
;
2582 ret
= ips_make_passthru(ha
, scb
->scsi_cmd
, scb
, intr
);
2584 if (intr
== IPS_INTR_ON
)
2585 spin_lock(host
->host_lock
);
2588 if (scb
->scsi_cmd
) {
2589 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
2590 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
2593 ips_freescb(ha
, scb
);
2595 case IPS_SUCCESS_IMM
:
2596 if (scb
->scsi_cmd
) {
2597 scb
->scsi_cmd
->result
= DID_OK
<< 16;
2598 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
2601 ips_freescb(ha
, scb
);
2607 if (ret
!= IPS_SUCCESS
) {
2612 ret
= ips_send_cmd(ha
, scb
);
2614 if (ret
== IPS_SUCCESS
)
2615 ips_putq_scb_head(&ha
->scb_activelist
, scb
);
2621 if (scb
->scsi_cmd
) {
2622 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
2625 ips_freescb(ha
, scb
);
2627 case IPS_SUCCESS_IMM
:
2628 ips_freescb(ha
, scb
);
2637 * Send "Normal" I/O commands
2640 p
= ha
->scb_waitlist
.head
;
2641 while ((p
) && (scb
= ips_getscb(ha
))) {
2642 if ((scmd_channel(p
) > 0)
2644 dcdb_active
[scmd_channel(p
) -
2645 1] & (1 << scmd_id(p
)))) {
2646 ips_freescb(ha
, scb
);
2647 p
= (struct scsi_cmnd
*) p
->host_scribble
;
2652 SC
= ips_removeq_wait(&ha
->scb_waitlist
, q
);
2654 if (intr
== IPS_INTR_ON
)
2655 spin_unlock(host
->host_lock
); /* Unlock HA after command is taken off queue */
2657 SC
->result
= DID_OK
;
2658 SC
->host_scribble
= NULL
;
2660 scb
->target_id
= SC
->device
->id
;
2661 scb
->lun
= SC
->device
->lun
;
2662 scb
->bus
= SC
->device
->channel
;
2666 scb
->callback
= ipsintr_done
;
2667 scb
->timeout
= ips_cmd_timeout
;
2668 memset(&scb
->cmd
, 0, 16);
2670 /* copy in the CDB */
2671 memcpy(scb
->cdb
, SC
->cmnd
, SC
->cmd_len
);
2673 scb
->sg_count
= scsi_dma_map(SC
);
2674 BUG_ON(scb
->sg_count
< 0);
2675 if (scb
->sg_count
) {
2676 struct scatterlist
*sg
;
2679 scb
->flags
|= IPS_SCB_MAP_SG
;
2681 scsi_for_each_sg(SC
, sg
, scb
->sg_count
, i
) {
2682 if (ips_fill_scb_sg_single
2683 (ha
, sg_dma_address(sg
), scb
, i
,
2684 sg_dma_len(sg
)) < 0)
2687 scb
->dcdb
.transfer_length
= scb
->data_len
;
2689 scb
->data_busaddr
= 0L;
2692 scb
->dcdb
.transfer_length
= 0;
2695 scb
->dcdb
.cmd_attribute
=
2696 ips_command_direction
[scb
->scsi_cmd
->cmnd
[0]];
2698 /* Allow a WRITE BUFFER Command to Have no Data */
2699 /* This is Used by Tape Flash Utilites */
2700 if ((scb
->scsi_cmd
->cmnd
[0] == WRITE_BUFFER
) &&
2701 (scb
->data_len
== 0))
2702 scb
->dcdb
.cmd_attribute
= 0;
2704 if (!(scb
->dcdb
.cmd_attribute
& 0x3))
2705 scb
->dcdb
.transfer_length
= 0;
2707 if (scb
->data_len
>= IPS_MAX_XFER
) {
2708 scb
->dcdb
.cmd_attribute
|= IPS_TRANSFER64K
;
2709 scb
->dcdb
.transfer_length
= 0;
2711 if (intr
== IPS_INTR_ON
)
2712 spin_lock(host
->host_lock
);
2714 ret
= ips_send_cmd(ha
, scb
);
2718 ips_putq_scb_head(&ha
->scb_activelist
, scb
);
2721 if (scb
->scsi_cmd
) {
2722 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
2723 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
2727 ha
->dcdb_active
[scb
->bus
- 1] &=
2728 ~(1 << scb
->target_id
);
2730 ips_freescb(ha
, scb
);
2732 case IPS_SUCCESS_IMM
:
2734 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
2737 ha
->dcdb_active
[scb
->bus
- 1] &=
2738 ~(1 << scb
->target_id
);
2740 ips_freescb(ha
, scb
);
2746 p
= (struct scsi_cmnd
*) p
->host_scribble
;
2750 if (intr
== IPS_INTR_ON
)
2751 spin_unlock(host
->host_lock
);
2754 /****************************************************************************/
2756 /* Routine Name: ips_putq_scb_head */
2758 /* Routine Description: */
2760 /* Add an item to the head of the queue */
2762 /* ASSUMED to be called from within the HA lock */
2764 /****************************************************************************/
2766 ips_putq_scb_head(ips_scb_queue_t
* queue
, ips_scb_t
* item
)
2768 METHOD_TRACE("ips_putq_scb_head", 1);
2773 item
->q_next
= queue
->head
;
2782 /****************************************************************************/
2784 /* Routine Name: ips_removeq_scb_head */
2786 /* Routine Description: */
2788 /* Remove the head of the queue */
2790 /* ASSUMED to be called from within the HA lock */
2792 /****************************************************************************/
2794 ips_removeq_scb_head(ips_scb_queue_t
* queue
)
2798 METHOD_TRACE("ips_removeq_scb_head", 1);
2806 queue
->head
= item
->q_next
;
2807 item
->q_next
= NULL
;
2809 if (queue
->tail
== item
)
2817 /****************************************************************************/
2819 /* Routine Name: ips_removeq_scb */
2821 /* Routine Description: */
2823 /* Remove an item from a queue */
2825 /* ASSUMED to be called from within the HA lock */
2827 /****************************************************************************/
2829 ips_removeq_scb(ips_scb_queue_t
* queue
, ips_scb_t
* item
)
2833 METHOD_TRACE("ips_removeq_scb", 1);
2838 if (item
== queue
->head
) {
2839 return (ips_removeq_scb_head(queue
));
2844 while ((p
) && (item
!= p
->q_next
))
2849 p
->q_next
= item
->q_next
;
2854 item
->q_next
= NULL
;
2863 /****************************************************************************/
2865 /* Routine Name: ips_putq_wait_tail */
2867 /* Routine Description: */
2869 /* Add an item to the tail of the queue */
2871 /* ASSUMED to be called from within the HA lock */
2873 /****************************************************************************/
2874 static void ips_putq_wait_tail(ips_wait_queue_entry_t
*queue
, struct scsi_cmnd
*item
)
2876 METHOD_TRACE("ips_putq_wait_tail", 1);
2881 item
->host_scribble
= NULL
;
2884 queue
->tail
->host_scribble
= (char *) item
;
2894 /****************************************************************************/
2896 /* Routine Name: ips_removeq_wait_head */
2898 /* Routine Description: */
2900 /* Remove the head of the queue */
2902 /* ASSUMED to be called from within the HA lock */
2904 /****************************************************************************/
2905 static struct scsi_cmnd
*ips_removeq_wait_head(ips_wait_queue_entry_t
*queue
)
2907 struct scsi_cmnd
*item
;
2909 METHOD_TRACE("ips_removeq_wait_head", 1);
2917 queue
->head
= (struct scsi_cmnd
*) item
->host_scribble
;
2918 item
->host_scribble
= NULL
;
2920 if (queue
->tail
== item
)
2928 /****************************************************************************/
2930 /* Routine Name: ips_removeq_wait */
2932 /* Routine Description: */
2934 /* Remove an item from a queue */
2936 /* ASSUMED to be called from within the HA lock */
2938 /****************************************************************************/
2939 static struct scsi_cmnd
*ips_removeq_wait(ips_wait_queue_entry_t
*queue
,
2940 struct scsi_cmnd
*item
)
2942 struct scsi_cmnd
*p
;
2944 METHOD_TRACE("ips_removeq_wait", 1);
2949 if (item
== queue
->head
) {
2950 return (ips_removeq_wait_head(queue
));
2955 while ((p
) && (item
!= (struct scsi_cmnd
*) p
->host_scribble
))
2956 p
= (struct scsi_cmnd
*) p
->host_scribble
;
2960 p
->host_scribble
= item
->host_scribble
;
2962 if (!item
->host_scribble
)
2965 item
->host_scribble
= NULL
;
2974 /****************************************************************************/
2976 /* Routine Name: ips_putq_copp_tail */
2978 /* Routine Description: */
2980 /* Add an item to the tail of the queue */
2982 /* ASSUMED to be called from within the HA lock */
2984 /****************************************************************************/
2986 ips_putq_copp_tail(ips_copp_queue_t
* queue
, ips_copp_wait_item_t
* item
)
2988 METHOD_TRACE("ips_putq_copp_tail", 1);
2996 queue
->tail
->next
= item
;
3006 /****************************************************************************/
3008 /* Routine Name: ips_removeq_copp_head */
3010 /* Routine Description: */
3012 /* Remove the head of the queue */
3014 /* ASSUMED to be called from within the HA lock */
3016 /****************************************************************************/
3017 static ips_copp_wait_item_t
*
3018 ips_removeq_copp_head(ips_copp_queue_t
* queue
)
3020 ips_copp_wait_item_t
*item
;
3022 METHOD_TRACE("ips_removeq_copp_head", 1);
3030 queue
->head
= item
->next
;
3033 if (queue
->tail
== item
)
3041 /****************************************************************************/
3043 /* Routine Name: ips_removeq_copp */
3045 /* Routine Description: */
3047 /* Remove an item from a queue */
3049 /* ASSUMED to be called from within the HA lock */
3051 /****************************************************************************/
3052 static ips_copp_wait_item_t
*
3053 ips_removeq_copp(ips_copp_queue_t
* queue
, ips_copp_wait_item_t
* item
)
3055 ips_copp_wait_item_t
*p
;
3057 METHOD_TRACE("ips_removeq_copp", 1);
3062 if (item
== queue
->head
) {
3063 return (ips_removeq_copp_head(queue
));
3068 while ((p
) && (item
!= p
->next
))
3073 p
->next
= item
->next
;
3087 /****************************************************************************/
3089 /* Routine Name: ipsintr_blocking */
3091 /* Routine Description: */
3093 /* Finalize an interrupt for internal commands */
3095 /****************************************************************************/
3097 ipsintr_blocking(ips_ha_t
* ha
, ips_scb_t
* scb
)
3099 METHOD_TRACE("ipsintr_blocking", 2);
3101 ips_freescb(ha
, scb
);
3102 if ((ha
->waitflag
== TRUE
) && (ha
->cmd_in_progress
== scb
->cdb
[0])) {
3103 ha
->waitflag
= FALSE
;
3109 /****************************************************************************/
3111 /* Routine Name: ipsintr_done */
3113 /* Routine Description: */
3115 /* Finalize an interrupt for non-internal commands */
3117 /****************************************************************************/
3119 ipsintr_done(ips_ha_t
* ha
, ips_scb_t
* scb
)
3121 METHOD_TRACE("ipsintr_done", 2);
3124 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
3125 "Spurious interrupt; scb NULL.\n");
3130 if (scb
->scsi_cmd
== NULL
) {
3131 /* unexpected interrupt */
3132 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
3133 "Spurious interrupt; scsi_cmd not set.\n");
3141 /****************************************************************************/
3143 /* Routine Name: ips_done */
3145 /* Routine Description: */
3147 /* Do housekeeping on completed commands */
3148 /* ASSUMED to be called form within the request lock */
3149 /****************************************************************************/
3151 ips_done(ips_ha_t
* ha
, ips_scb_t
* scb
)
3155 METHOD_TRACE("ips_done", 1);
3160 if ((scb
->scsi_cmd
) && (ips_is_passthru(scb
->scsi_cmd
))) {
3161 ips_cleanup_passthru(ha
, scb
);
3165 * Check to see if this command had too much
3166 * data and had to be broke up. If so, queue
3167 * the rest of the data and continue.
3169 if ((scb
->breakup
) || (scb
->sg_break
)) {
3170 struct scatterlist
*sg
;
3171 int i
, sg_dma_index
, ips_sg_index
= 0;
3173 /* we had a data breakup */
3176 sg
= scsi_sglist(scb
->scsi_cmd
);
3178 /* Spin forward to last dma chunk */
3179 sg_dma_index
= scb
->breakup
;
3180 for (i
= 0; i
< scb
->breakup
; i
++)
3183 /* Take care of possible partial on last chunk */
3184 ips_fill_scb_sg_single(ha
,
3186 scb
, ips_sg_index
++,
3189 for (; sg_dma_index
< scsi_sg_count(scb
->scsi_cmd
);
3190 sg_dma_index
++, sg
= sg_next(sg
)) {
3191 if (ips_fill_scb_sg_single
3194 scb
, ips_sg_index
++,
3195 sg_dma_len(sg
)) < 0)
3199 scb
->dcdb
.transfer_length
= scb
->data_len
;
3200 scb
->dcdb
.cmd_attribute
|=
3201 ips_command_direction
[scb
->scsi_cmd
->cmnd
[0]];
3203 if (!(scb
->dcdb
.cmd_attribute
& 0x3))
3204 scb
->dcdb
.transfer_length
= 0;
3206 if (scb
->data_len
>= IPS_MAX_XFER
) {
3207 scb
->dcdb
.cmd_attribute
|= IPS_TRANSFER64K
;
3208 scb
->dcdb
.transfer_length
= 0;
3211 ret
= ips_send_cmd(ha
, scb
);
3215 if (scb
->scsi_cmd
) {
3216 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
3217 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
3220 ips_freescb(ha
, scb
);
3222 case IPS_SUCCESS_IMM
:
3223 if (scb
->scsi_cmd
) {
3224 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
3225 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
3228 ips_freescb(ha
, scb
);
3236 } /* end if passthru */
3239 ha
->dcdb_active
[scb
->bus
- 1] &= ~(1 << scb
->target_id
);
3242 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
3244 ips_freescb(ha
, scb
);
3247 /****************************************************************************/
3249 /* Routine Name: ips_map_status */
3251 /* Routine Description: */
3253 /* Map Controller Error codes to Linux Error Codes */
3255 /****************************************************************************/
3257 ips_map_status(ips_ha_t
* ha
, ips_scb_t
* scb
, ips_stat_t
* sp
)
3261 uint32_t transfer_len
;
3262 IPS_DCDB_TABLE_TAPE
*tapeDCDB
;
3263 IPS_SCSI_INQ_DATA inquiryData
;
3265 METHOD_TRACE("ips_map_status", 1);
3269 "(%s%d) Physical device error (%d %d %d): %x %x, Sense Key: %x, ASC: %x, ASCQ: %x",
3270 ips_name
, ha
->host_num
,
3271 scb
->scsi_cmd
->device
->channel
,
3272 scb
->scsi_cmd
->device
->id
, scb
->scsi_cmd
->device
->lun
,
3273 scb
->basic_status
, scb
->extended_status
,
3274 scb
->extended_status
==
3275 IPS_ERR_CKCOND
? scb
->dcdb
.sense_info
[2] & 0xf : 0,
3276 scb
->extended_status
==
3277 IPS_ERR_CKCOND
? scb
->dcdb
.sense_info
[12] : 0,
3278 scb
->extended_status
==
3279 IPS_ERR_CKCOND
? scb
->dcdb
.sense_info
[13] : 0);
3282 /* default driver error */
3283 errcode
= DID_ERROR
;
3286 switch (scb
->basic_status
& IPS_GSC_STATUS_MASK
) {
3287 case IPS_CMD_TIMEOUT
:
3288 errcode
= DID_TIME_OUT
;
3291 case IPS_INVAL_OPCO
:
3292 case IPS_INVAL_CMD_BLK
:
3293 case IPS_INVAL_PARM_BLK
:
3295 case IPS_CMD_CMPLT_WERROR
:
3298 case IPS_PHYS_DRV_ERROR
:
3299 switch (scb
->extended_status
) {
3300 case IPS_ERR_SEL_TO
:
3302 errcode
= DID_NO_CONNECT
;
3306 case IPS_ERR_OU_RUN
:
3307 if ((scb
->cmd
.dcdb
.op_code
== IPS_CMD_EXTENDED_DCDB
) ||
3308 (scb
->cmd
.dcdb
.op_code
==
3309 IPS_CMD_EXTENDED_DCDB_SG
)) {
3310 tapeDCDB
= (IPS_DCDB_TABLE_TAPE
*) & scb
->dcdb
;
3311 transfer_len
= tapeDCDB
->transfer_length
;
3314 (uint32_t) scb
->dcdb
.transfer_length
;
3317 if ((scb
->bus
) && (transfer_len
< scb
->data_len
)) {
3318 /* Underrun - set default to no error */
3321 /* Restrict access to physical DASD */
3322 if (scb
->scsi_cmd
->cmnd
[0] == INQUIRY
) {
3323 ips_scmd_buf_read(scb
->scsi_cmd
,
3324 &inquiryData
, sizeof (inquiryData
));
3325 if ((inquiryData
.DeviceType
& 0x1f) == TYPE_DISK
) {
3326 errcode
= DID_TIME_OUT
;
3331 errcode
= DID_ERROR
;
3335 case IPS_ERR_RECOVERY
:
3336 /* don't fail recovered errors */
3342 case IPS_ERR_HOST_RESET
:
3343 case IPS_ERR_DEV_RESET
:
3344 errcode
= DID_RESET
;
3347 case IPS_ERR_CKCOND
:
3349 if ((scb
->cmd
.dcdb
.op_code
==
3350 IPS_CMD_EXTENDED_DCDB
)
3351 || (scb
->cmd
.dcdb
.op_code
==
3352 IPS_CMD_EXTENDED_DCDB_SG
)) {
3354 (IPS_DCDB_TABLE_TAPE
*) & scb
->dcdb
;
3355 memcpy(scb
->scsi_cmd
->sense_buffer
,
3356 tapeDCDB
->sense_info
,
3357 SCSI_SENSE_BUFFERSIZE
);
3359 memcpy(scb
->scsi_cmd
->sense_buffer
,
3360 scb
->dcdb
.sense_info
,
3361 SCSI_SENSE_BUFFERSIZE
);
3363 device_error
= 2; /* check condition */
3371 errcode
= DID_ERROR
;
3377 scb
->scsi_cmd
->result
= device_error
| (errcode
<< 16);
3382 /****************************************************************************/
3384 /* Routine Name: ips_send_wait */
3386 /* Routine Description: */
3388 /* Send a command to the controller and wait for it to return */
3390 /* The FFDC Time Stamp use this function for the callback, but doesn't */
3391 /* actually need to wait. */
3392 /****************************************************************************/
3394 ips_send_wait(ips_ha_t
* ha
, ips_scb_t
* scb
, int timeout
, int intr
)
3398 METHOD_TRACE("ips_send_wait", 1);
3400 if (intr
!= IPS_FFDC
) { /* Won't be Waiting if this is a Time Stamp */
3401 ha
->waitflag
= TRUE
;
3402 ha
->cmd_in_progress
= scb
->cdb
[0];
3404 scb
->callback
= ipsintr_blocking
;
3405 ret
= ips_send_cmd(ha
, scb
);
3407 if ((ret
== IPS_FAILURE
) || (ret
== IPS_SUCCESS_IMM
))
3410 if (intr
!= IPS_FFDC
) /* Don't Wait around if this is a Time Stamp */
3411 ret
= ips_wait(ha
, timeout
, intr
);
3416 /****************************************************************************/
3418 /* Routine Name: ips_scmd_buf_write */
3420 /* Routine Description: */
3421 /* Write data to struct scsi_cmnd request_buffer at proper offsets */
3422 /****************************************************************************/
3424 ips_scmd_buf_write(struct scsi_cmnd
*scmd
, void *data
, unsigned int count
)
3426 unsigned long flags
;
3428 local_irq_save(flags
);
3429 scsi_sg_copy_from_buffer(scmd
, data
, count
);
3430 local_irq_restore(flags
);
3433 /****************************************************************************/
3435 /* Routine Name: ips_scmd_buf_read */
3437 /* Routine Description: */
3438 /* Copy data from a struct scsi_cmnd to a new, linear buffer */
3439 /****************************************************************************/
3441 ips_scmd_buf_read(struct scsi_cmnd
*scmd
, void *data
, unsigned int count
)
3443 unsigned long flags
;
3445 local_irq_save(flags
);
3446 scsi_sg_copy_to_buffer(scmd
, data
, count
);
3447 local_irq_restore(flags
);
3450 /****************************************************************************/
3452 /* Routine Name: ips_send_cmd */
3454 /* Routine Description: */
3456 /* Map SCSI commands to ServeRAID commands for logical drives */
3458 /****************************************************************************/
3460 ips_send_cmd(ips_ha_t
* ha
, ips_scb_t
* scb
)
3465 IPS_DCDB_TABLE_TAPE
*tapeDCDB
;
3468 METHOD_TRACE("ips_send_cmd", 1);
3472 if (!scb
->scsi_cmd
) {
3473 /* internal command */
3476 /* Controller commands can't be issued */
3477 /* to real devices -- fail them */
3478 if ((ha
->waitflag
== TRUE
) &&
3479 (ha
->cmd_in_progress
== scb
->cdb
[0])) {
3480 ha
->waitflag
= FALSE
;
3485 } else if ((scb
->bus
== 0) && (!ips_is_passthru(scb
->scsi_cmd
))) {
3486 /* command to logical bus -- interpret */
3487 ret
= IPS_SUCCESS_IMM
;
3489 switch (scb
->scsi_cmd
->cmnd
[0]) {
3490 case ALLOW_MEDIUM_REMOVAL
:
3493 case WRITE_FILEMARKS
:
3495 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
3499 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3502 case TEST_UNIT_READY
:
3504 if (scb
->target_id
== IPS_ADAPTER_ID
) {
3506 * Either we have a TUR
3507 * or we have a SCSI inquiry
3509 if (scb
->scsi_cmd
->cmnd
[0] == TEST_UNIT_READY
)
3510 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3512 if (scb
->scsi_cmd
->cmnd
[0] == INQUIRY
) {
3513 IPS_SCSI_INQ_DATA inquiry
;
3516 sizeof (IPS_SCSI_INQ_DATA
));
3518 inquiry
.DeviceType
=
3519 IPS_SCSI_INQ_TYPE_PROCESSOR
;
3520 inquiry
.DeviceTypeQualifier
=
3521 IPS_SCSI_INQ_LU_CONNECTED
;
3522 inquiry
.Version
= IPS_SCSI_INQ_REV2
;
3523 inquiry
.ResponseDataFormat
=
3524 IPS_SCSI_INQ_RD_REV2
;
3525 inquiry
.AdditionalLength
= 31;
3527 IPS_SCSI_INQ_Address16
;
3529 IPS_SCSI_INQ_WBus16
|
3531 strncpy(inquiry
.VendorId
, "IBM ",
3533 strncpy(inquiry
.ProductId
,
3535 strncpy(inquiry
.ProductRevisionLevel
,
3538 ips_scmd_buf_write(scb
->scsi_cmd
,
3542 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3545 scb
->cmd
.logical_info
.op_code
= IPS_CMD_GET_LD_INFO
;
3546 scb
->cmd
.logical_info
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3547 scb
->cmd
.logical_info
.reserved
= 0;
3548 scb
->cmd
.logical_info
.reserved2
= 0;
3549 scb
->data_len
= sizeof (IPS_LD_INFO
);
3550 scb
->data_busaddr
= ha
->logical_drive_info_dma_addr
;
3552 scb
->cmd
.logical_info
.buffer_addr
= scb
->data_busaddr
;
3559 ips_reqsen(ha
, scb
);
3560 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3566 scb
->cmd
.basic_io
.op_code
=
3567 (scb
->scsi_cmd
->cmnd
[0] ==
3568 READ_6
) ? IPS_CMD_READ
: IPS_CMD_WRITE
;
3569 scb
->cmd
.basic_io
.enhanced_sg
= 0;
3570 scb
->cmd
.basic_io
.sg_addr
=
3571 cpu_to_le32(scb
->data_busaddr
);
3573 scb
->cmd
.basic_io
.op_code
=
3574 (scb
->scsi_cmd
->cmnd
[0] ==
3575 READ_6
) ? IPS_CMD_READ_SG
:
3577 scb
->cmd
.basic_io
.enhanced_sg
=
3578 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
3579 scb
->cmd
.basic_io
.sg_addr
=
3580 cpu_to_le32(scb
->sg_busaddr
);
3583 scb
->cmd
.basic_io
.segment_4G
= 0;
3584 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3585 scb
->cmd
.basic_io
.log_drv
= scb
->target_id
;
3586 scb
->cmd
.basic_io
.sg_count
= scb
->sg_len
;
3588 if (scb
->cmd
.basic_io
.lba
)
3589 le32_add_cpu(&scb
->cmd
.basic_io
.lba
,
3590 le16_to_cpu(scb
->cmd
.basic_io
.
3593 scb
->cmd
.basic_io
.lba
=
3595 cmnd
[1] & 0x1f) << 16) | (scb
->scsi_cmd
->
3597 (scb
->scsi_cmd
->cmnd
[3]));
3599 scb
->cmd
.basic_io
.sector_count
=
3600 cpu_to_le16(scb
->data_len
/ IPS_BLKSIZE
);
3602 if (le16_to_cpu(scb
->cmd
.basic_io
.sector_count
) == 0)
3603 scb
->cmd
.basic_io
.sector_count
=
3612 scb
->cmd
.basic_io
.op_code
=
3613 (scb
->scsi_cmd
->cmnd
[0] ==
3614 READ_10
) ? IPS_CMD_READ
: IPS_CMD_WRITE
;
3615 scb
->cmd
.basic_io
.enhanced_sg
= 0;
3616 scb
->cmd
.basic_io
.sg_addr
=
3617 cpu_to_le32(scb
->data_busaddr
);
3619 scb
->cmd
.basic_io
.op_code
=
3620 (scb
->scsi_cmd
->cmnd
[0] ==
3621 READ_10
) ? IPS_CMD_READ_SG
:
3623 scb
->cmd
.basic_io
.enhanced_sg
=
3624 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
3625 scb
->cmd
.basic_io
.sg_addr
=
3626 cpu_to_le32(scb
->sg_busaddr
);
3629 scb
->cmd
.basic_io
.segment_4G
= 0;
3630 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3631 scb
->cmd
.basic_io
.log_drv
= scb
->target_id
;
3632 scb
->cmd
.basic_io
.sg_count
= scb
->sg_len
;
3634 if (scb
->cmd
.basic_io
.lba
)
3635 le32_add_cpu(&scb
->cmd
.basic_io
.lba
,
3636 le16_to_cpu(scb
->cmd
.basic_io
.
3639 scb
->cmd
.basic_io
.lba
=
3640 ((scb
->scsi_cmd
->cmnd
[2] << 24) | (scb
->
3644 (scb
->scsi_cmd
->cmnd
[4] << 8) | scb
->
3647 scb
->cmd
.basic_io
.sector_count
=
3648 cpu_to_le16(scb
->data_len
/ IPS_BLKSIZE
);
3650 if (cpu_to_le16(scb
->cmd
.basic_io
.sector_count
) == 0) {
3652 * This is a null condition
3653 * we don't have to do anything
3656 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3664 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3668 scb
->cmd
.basic_io
.op_code
= IPS_CMD_ENQUIRY
;
3669 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3670 scb
->cmd
.basic_io
.segment_4G
= 0;
3671 scb
->cmd
.basic_io
.enhanced_sg
= 0;
3672 scb
->data_len
= sizeof (*ha
->enq
);
3673 scb
->cmd
.basic_io
.sg_addr
= ha
->enq_busaddr
;
3678 scb
->cmd
.logical_info
.op_code
= IPS_CMD_GET_LD_INFO
;
3679 scb
->cmd
.logical_info
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3680 scb
->cmd
.logical_info
.reserved
= 0;
3681 scb
->cmd
.logical_info
.reserved2
= 0;
3682 scb
->cmd
.logical_info
.reserved3
= 0;
3683 scb
->data_len
= sizeof (IPS_LD_INFO
);
3684 scb
->data_busaddr
= ha
->logical_drive_info_dma_addr
;
3686 scb
->cmd
.logical_info
.buffer_addr
= scb
->data_busaddr
;
3690 case SEND_DIAGNOSTIC
:
3691 case REASSIGN_BLOCKS
:
3695 case READ_DEFECT_DATA
:
3698 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3702 /* Set the Return Info to appear like the Command was */
3703 /* attempted, a Check Condition occurred, and Sense */
3704 /* Data indicating an Invalid CDB OpCode is returned. */
3705 sp
= (char *) scb
->scsi_cmd
->sense_buffer
;
3707 sp
[0] = 0x70; /* Error Code */
3708 sp
[2] = ILLEGAL_REQUEST
; /* Sense Key 5 Illegal Req. */
3709 sp
[7] = 0x0A; /* Additional Sense Length */
3710 sp
[12] = 0x20; /* ASC = Invalid OpCode */
3711 sp
[13] = 0x00; /* ASCQ */
3713 device_error
= 2; /* Indicate Check Condition */
3714 scb
->scsi_cmd
->result
= device_error
| (DID_OK
<< 16);
3719 if (ret
== IPS_SUCCESS_IMM
)
3725 /* If we already know the Device is Not there, no need to attempt a Command */
3726 /* This also protects an NT FailOver Controller from getting CDB's sent to it */
3727 if (ha
->conf
->dev
[scb
->bus
- 1][scb
->target_id
].ucState
== 0) {
3728 scb
->scsi_cmd
->result
= DID_NO_CONNECT
<< 16;
3729 return (IPS_SUCCESS_IMM
);
3732 ha
->dcdb_active
[scb
->bus
- 1] |= (1 << scb
->target_id
);
3733 scb
->cmd
.dcdb
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3734 scb
->cmd
.dcdb
.dcdb_address
= cpu_to_le32(scb
->scb_busaddr
+
3735 (unsigned long) &scb
->
3737 (unsigned long) scb
);
3738 scb
->cmd
.dcdb
.reserved
= 0;
3739 scb
->cmd
.dcdb
.reserved2
= 0;
3740 scb
->cmd
.dcdb
.reserved3
= 0;
3741 scb
->cmd
.dcdb
.segment_4G
= 0;
3742 scb
->cmd
.dcdb
.enhanced_sg
= 0;
3744 TimeOut
= scb
->scsi_cmd
->request
->timeout
;
3746 if (ha
->subsys
->param
[4] & 0x00100000) { /* If NEW Tape DCDB is Supported */
3748 scb
->cmd
.dcdb
.op_code
= IPS_CMD_EXTENDED_DCDB
;
3750 scb
->cmd
.dcdb
.op_code
=
3751 IPS_CMD_EXTENDED_DCDB_SG
;
3752 scb
->cmd
.dcdb
.enhanced_sg
=
3753 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
3756 tapeDCDB
= (IPS_DCDB_TABLE_TAPE
*) & scb
->dcdb
; /* Use Same Data Area as Old DCDB Struct */
3757 tapeDCDB
->device_address
=
3758 ((scb
->bus
- 1) << 4) | scb
->target_id
;
3759 tapeDCDB
->cmd_attribute
|= IPS_DISCONNECT_ALLOWED
;
3760 tapeDCDB
->cmd_attribute
&= ~IPS_TRANSFER64K
; /* Always Turn OFF 64K Size Flag */
3763 if (TimeOut
< (10 * HZ
))
3764 tapeDCDB
->cmd_attribute
|= IPS_TIMEOUT10
; /* TimeOut is 10 Seconds */
3765 else if (TimeOut
< (60 * HZ
))
3766 tapeDCDB
->cmd_attribute
|= IPS_TIMEOUT60
; /* TimeOut is 60 Seconds */
3767 else if (TimeOut
< (1200 * HZ
))
3768 tapeDCDB
->cmd_attribute
|= IPS_TIMEOUT20M
; /* TimeOut is 20 Minutes */
3771 tapeDCDB
->cdb_length
= scb
->scsi_cmd
->cmd_len
;
3772 tapeDCDB
->reserved_for_LUN
= 0;
3773 tapeDCDB
->transfer_length
= scb
->data_len
;
3774 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_EXTENDED_DCDB_SG
)
3775 tapeDCDB
->buffer_pointer
=
3776 cpu_to_le32(scb
->sg_busaddr
);
3778 tapeDCDB
->buffer_pointer
=
3779 cpu_to_le32(scb
->data_busaddr
);
3780 tapeDCDB
->sg_count
= scb
->sg_len
;
3781 tapeDCDB
->sense_length
= sizeof (tapeDCDB
->sense_info
);
3782 tapeDCDB
->scsi_status
= 0;
3783 tapeDCDB
->reserved
= 0;
3784 memcpy(tapeDCDB
->scsi_cdb
, scb
->scsi_cmd
->cmnd
,
3785 scb
->scsi_cmd
->cmd_len
);
3788 scb
->cmd
.dcdb
.op_code
= IPS_CMD_DCDB
;
3790 scb
->cmd
.dcdb
.op_code
= IPS_CMD_DCDB_SG
;
3791 scb
->cmd
.dcdb
.enhanced_sg
=
3792 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
3795 scb
->dcdb
.device_address
=
3796 ((scb
->bus
- 1) << 4) | scb
->target_id
;
3797 scb
->dcdb
.cmd_attribute
|= IPS_DISCONNECT_ALLOWED
;
3800 if (TimeOut
< (10 * HZ
))
3801 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT10
; /* TimeOut is 10 Seconds */
3802 else if (TimeOut
< (60 * HZ
))
3803 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT60
; /* TimeOut is 60 Seconds */
3804 else if (TimeOut
< (1200 * HZ
))
3805 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT20M
; /* TimeOut is 20 Minutes */
3808 scb
->dcdb
.transfer_length
= scb
->data_len
;
3809 if (scb
->dcdb
.cmd_attribute
& IPS_TRANSFER64K
)
3810 scb
->dcdb
.transfer_length
= 0;
3811 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_DCDB_SG
)
3812 scb
->dcdb
.buffer_pointer
=
3813 cpu_to_le32(scb
->sg_busaddr
);
3815 scb
->dcdb
.buffer_pointer
=
3816 cpu_to_le32(scb
->data_busaddr
);
3817 scb
->dcdb
.cdb_length
= scb
->scsi_cmd
->cmd_len
;
3818 scb
->dcdb
.sense_length
= sizeof (scb
->dcdb
.sense_info
);
3819 scb
->dcdb
.sg_count
= scb
->sg_len
;
3820 scb
->dcdb
.reserved
= 0;
3821 memcpy(scb
->dcdb
.scsi_cdb
, scb
->scsi_cmd
->cmnd
,
3822 scb
->scsi_cmd
->cmd_len
);
3823 scb
->dcdb
.scsi_status
= 0;
3824 scb
->dcdb
.reserved2
[0] = 0;
3825 scb
->dcdb
.reserved2
[1] = 0;
3826 scb
->dcdb
.reserved2
[2] = 0;
3830 return ((*ha
->func
.issue
) (ha
, scb
));
3833 /****************************************************************************/
3835 /* Routine Name: ips_chk_status */
3837 /* Routine Description: */
3839 /* Check the status of commands to logical drives */
3840 /* Assumed to be called with the HA lock */
3841 /****************************************************************************/
3843 ips_chkstatus(ips_ha_t
* ha
, IPS_STATUS
* pstatus
)
3847 uint8_t basic_status
;
3850 IPS_SCSI_INQ_DATA inquiryData
;
3852 METHOD_TRACE("ips_chkstatus", 1);
3854 scb
= &ha
->scbs
[pstatus
->fields
.command_id
];
3855 scb
->basic_status
= basic_status
=
3856 pstatus
->fields
.basic_status
& IPS_BASIC_STATUS_MASK
;
3857 scb
->extended_status
= ext_status
= pstatus
->fields
.extended_status
;
3860 sp
->residue_len
= 0;
3861 sp
->scb_addr
= (void *) scb
;
3863 /* Remove the item from the active queue */
3864 ips_removeq_scb(&ha
->scb_activelist
, scb
);
3867 /* internal commands are handled in do_ipsintr */
3870 DEBUG_VAR(2, "(%s%d) ips_chkstatus: cmd 0x%X id %d (%d %d %d)",
3874 scb
->cmd
.basic_io
.command_id
,
3875 scb
->bus
, scb
->target_id
, scb
->lun
);
3877 if ((scb
->scsi_cmd
) && (ips_is_passthru(scb
->scsi_cmd
)))
3878 /* passthru - just returns the raw result */
3883 if (((basic_status
& IPS_GSC_STATUS_MASK
) == IPS_CMD_SUCCESS
) ||
3884 ((basic_status
& IPS_GSC_STATUS_MASK
) == IPS_CMD_RECOVERED_ERROR
)) {
3886 if (scb
->bus
== 0) {
3887 if ((basic_status
& IPS_GSC_STATUS_MASK
) ==
3888 IPS_CMD_RECOVERED_ERROR
) {
3890 "(%s%d) Recovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
3891 ips_name
, ha
->host_num
,
3892 scb
->cmd
.basic_io
.op_code
,
3893 basic_status
, ext_status
);
3896 switch (scb
->scsi_cmd
->cmnd
[0]) {
3897 case ALLOW_MEDIUM_REMOVAL
:
3900 case WRITE_FILEMARKS
:
3902 errcode
= DID_ERROR
;
3908 case TEST_UNIT_READY
:
3909 if (!ips_online(ha
, scb
)) {
3910 errcode
= DID_TIME_OUT
;
3915 if (ips_online(ha
, scb
)) {
3916 ips_inquiry(ha
, scb
);
3918 errcode
= DID_TIME_OUT
;
3923 ips_reqsen(ha
, scb
);
3935 if (!ips_online(ha
, scb
)
3936 || !ips_msense(ha
, scb
)) {
3937 errcode
= DID_ERROR
;
3942 if (ips_online(ha
, scb
))
3945 errcode
= DID_TIME_OUT
;
3949 case SEND_DIAGNOSTIC
:
3950 case REASSIGN_BLOCKS
:
3954 errcode
= DID_ERROR
;
3959 case READ_DEFECT_DATA
:
3965 errcode
= DID_ERROR
;
3968 scb
->scsi_cmd
->result
= errcode
<< 16;
3969 } else { /* bus == 0 */
3970 /* restrict access to physical drives */
3971 if (scb
->scsi_cmd
->cmnd
[0] == INQUIRY
) {
3972 ips_scmd_buf_read(scb
->scsi_cmd
,
3973 &inquiryData
, sizeof (inquiryData
));
3974 if ((inquiryData
.DeviceType
& 0x1f) == TYPE_DISK
)
3975 scb
->scsi_cmd
->result
= DID_TIME_OUT
<< 16;
3978 } else { /* recovered error / success */
3979 if (scb
->bus
== 0) {
3981 "(%s%d) Unrecovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
3982 ips_name
, ha
->host_num
,
3983 scb
->cmd
.basic_io
.op_code
, basic_status
,
3987 ips_map_status(ha
, scb
, sp
);
3991 /****************************************************************************/
3993 /* Routine Name: ips_online */
3995 /* Routine Description: */
3997 /* Determine if a logical drive is online */
3999 /****************************************************************************/
4001 ips_online(ips_ha_t
* ha
, ips_scb_t
* scb
)
4003 METHOD_TRACE("ips_online", 1);
4005 if (scb
->target_id
>= IPS_MAX_LD
)
4008 if ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1) {
4009 memset(ha
->logical_drive_info
, 0, sizeof (IPS_LD_INFO
));
4013 if (ha
->logical_drive_info
->drive_info
[scb
->target_id
].state
!=
4015 && ha
->logical_drive_info
->drive_info
[scb
->target_id
].state
!=
4017 && ha
->logical_drive_info
->drive_info
[scb
->target_id
].state
!=
4019 && ha
->logical_drive_info
->drive_info
[scb
->target_id
].state
!=
4026 /****************************************************************************/
4028 /* Routine Name: ips_inquiry */
4030 /* Routine Description: */
4032 /* Simulate an inquiry command to a logical drive */
4034 /****************************************************************************/
4036 ips_inquiry(ips_ha_t
* ha
, ips_scb_t
* scb
)
4038 IPS_SCSI_INQ_DATA inquiry
;
4040 METHOD_TRACE("ips_inquiry", 1);
4042 memset(&inquiry
, 0, sizeof (IPS_SCSI_INQ_DATA
));
4044 inquiry
.DeviceType
= IPS_SCSI_INQ_TYPE_DASD
;
4045 inquiry
.DeviceTypeQualifier
= IPS_SCSI_INQ_LU_CONNECTED
;
4046 inquiry
.Version
= IPS_SCSI_INQ_REV2
;
4047 inquiry
.ResponseDataFormat
= IPS_SCSI_INQ_RD_REV2
;
4048 inquiry
.AdditionalLength
= 31;
4049 inquiry
.Flags
[0] = IPS_SCSI_INQ_Address16
;
4051 IPS_SCSI_INQ_WBus16
| IPS_SCSI_INQ_Sync
| IPS_SCSI_INQ_CmdQue
;
4052 strncpy(inquiry
.VendorId
, "IBM ", 8);
4053 strncpy(inquiry
.ProductId
, "SERVERAID ", 16);
4054 strncpy(inquiry
.ProductRevisionLevel
, "1.00", 4);
4056 ips_scmd_buf_write(scb
->scsi_cmd
, &inquiry
, sizeof (inquiry
));
4061 /****************************************************************************/
4063 /* Routine Name: ips_rdcap */
4065 /* Routine Description: */
4067 /* Simulate a read capacity command to a logical drive */
4069 /****************************************************************************/
4071 ips_rdcap(ips_ha_t
* ha
, ips_scb_t
* scb
)
4073 IPS_SCSI_CAPACITY cap
;
4075 METHOD_TRACE("ips_rdcap", 1);
4077 if (scsi_bufflen(scb
->scsi_cmd
) < 8)
4081 cpu_to_be32(le32_to_cpu
4082 (ha
->logical_drive_info
->
4083 drive_info
[scb
->target_id
].sector_count
) - 1);
4084 cap
.len
= cpu_to_be32((uint32_t) IPS_BLKSIZE
);
4086 ips_scmd_buf_write(scb
->scsi_cmd
, &cap
, sizeof (cap
));
4091 /****************************************************************************/
4093 /* Routine Name: ips_msense */
4095 /* Routine Description: */
4097 /* Simulate a mode sense command to a logical drive */
4099 /****************************************************************************/
4101 ips_msense(ips_ha_t
* ha
, ips_scb_t
* scb
)
4106 IPS_SCSI_MODE_PAGE_DATA mdata
;
4108 METHOD_TRACE("ips_msense", 1);
4110 if (le32_to_cpu(ha
->enq
->ulDriveSize
[scb
->target_id
]) > 0x400000 &&
4111 (ha
->enq
->ucMiscFlag
& 0x8) == 0) {
4112 heads
= IPS_NORM_HEADS
;
4113 sectors
= IPS_NORM_SECTORS
;
4115 heads
= IPS_COMP_HEADS
;
4116 sectors
= IPS_COMP_SECTORS
;
4120 (le32_to_cpu(ha
->enq
->ulDriveSize
[scb
->target_id
]) -
4121 1) / (heads
* sectors
);
4123 memset(&mdata
, 0, sizeof (IPS_SCSI_MODE_PAGE_DATA
));
4125 mdata
.hdr
.BlockDescLength
= 8;
4127 switch (scb
->scsi_cmd
->cmnd
[2] & 0x3f) {
4128 case 0x03: /* page 3 */
4129 mdata
.pdata
.pg3
.PageCode
= 3;
4130 mdata
.pdata
.pg3
.PageLength
= sizeof (IPS_SCSI_MODE_PAGE3
);
4131 mdata
.hdr
.DataLength
=
4132 3 + mdata
.hdr
.BlockDescLength
+ mdata
.pdata
.pg3
.PageLength
;
4133 mdata
.pdata
.pg3
.TracksPerZone
= 0;
4134 mdata
.pdata
.pg3
.AltSectorsPerZone
= 0;
4135 mdata
.pdata
.pg3
.AltTracksPerZone
= 0;
4136 mdata
.pdata
.pg3
.AltTracksPerVolume
= 0;
4137 mdata
.pdata
.pg3
.SectorsPerTrack
= cpu_to_be16(sectors
);
4138 mdata
.pdata
.pg3
.BytesPerSector
= cpu_to_be16(IPS_BLKSIZE
);
4139 mdata
.pdata
.pg3
.Interleave
= cpu_to_be16(1);
4140 mdata
.pdata
.pg3
.TrackSkew
= 0;
4141 mdata
.pdata
.pg3
.CylinderSkew
= 0;
4142 mdata
.pdata
.pg3
.flags
= IPS_SCSI_MP3_SoftSector
;
4146 mdata
.pdata
.pg4
.PageCode
= 4;
4147 mdata
.pdata
.pg4
.PageLength
= sizeof (IPS_SCSI_MODE_PAGE4
);
4148 mdata
.hdr
.DataLength
=
4149 3 + mdata
.hdr
.BlockDescLength
+ mdata
.pdata
.pg4
.PageLength
;
4150 mdata
.pdata
.pg4
.CylindersHigh
=
4151 cpu_to_be16((cylinders
>> 8) & 0xFFFF);
4152 mdata
.pdata
.pg4
.CylindersLow
= (cylinders
& 0xFF);
4153 mdata
.pdata
.pg4
.Heads
= heads
;
4154 mdata
.pdata
.pg4
.WritePrecompHigh
= 0;
4155 mdata
.pdata
.pg4
.WritePrecompLow
= 0;
4156 mdata
.pdata
.pg4
.ReducedWriteCurrentHigh
= 0;
4157 mdata
.pdata
.pg4
.ReducedWriteCurrentLow
= 0;
4158 mdata
.pdata
.pg4
.StepRate
= cpu_to_be16(1);
4159 mdata
.pdata
.pg4
.LandingZoneHigh
= 0;
4160 mdata
.pdata
.pg4
.LandingZoneLow
= 0;
4161 mdata
.pdata
.pg4
.flags
= 0;
4162 mdata
.pdata
.pg4
.RotationalOffset
= 0;
4163 mdata
.pdata
.pg4
.MediumRotationRate
= 0;
4166 mdata
.pdata
.pg8
.PageCode
= 8;
4167 mdata
.pdata
.pg8
.PageLength
= sizeof (IPS_SCSI_MODE_PAGE8
);
4168 mdata
.hdr
.DataLength
=
4169 3 + mdata
.hdr
.BlockDescLength
+ mdata
.pdata
.pg8
.PageLength
;
4170 /* everything else is left set to 0 */
4177 ips_scmd_buf_write(scb
->scsi_cmd
, &mdata
, sizeof (mdata
));
4182 /****************************************************************************/
4184 /* Routine Name: ips_reqsen */
4186 /* Routine Description: */
4188 /* Simulate a request sense command to a logical drive */
4190 /****************************************************************************/
4192 ips_reqsen(ips_ha_t
* ha
, ips_scb_t
* scb
)
4194 IPS_SCSI_REQSEN reqsen
;
4196 METHOD_TRACE("ips_reqsen", 1);
4198 memset(&reqsen
, 0, sizeof (IPS_SCSI_REQSEN
));
4200 reqsen
.ResponseCode
=
4201 IPS_SCSI_REQSEN_VALID
| IPS_SCSI_REQSEN_CURRENT_ERR
;
4202 reqsen
.AdditionalLength
= 10;
4203 reqsen
.AdditionalSenseCode
= IPS_SCSI_REQSEN_NO_SENSE
;
4204 reqsen
.AdditionalSenseCodeQual
= IPS_SCSI_REQSEN_NO_SENSE
;
4206 ips_scmd_buf_write(scb
->scsi_cmd
, &reqsen
, sizeof (reqsen
));
4211 /****************************************************************************/
4213 /* Routine Name: ips_free */
4215 /* Routine Description: */
4217 /* Free any allocated space for this controller */
4219 /****************************************************************************/
4221 ips_free(ips_ha_t
* ha
)
4224 METHOD_TRACE("ips_free", 1);
4228 pci_free_consistent(ha
->pcidev
, sizeof(IPS_ENQ
),
4229 ha
->enq
, ha
->enq_busaddr
);
4237 pci_free_consistent(ha
->pcidev
,
4238 sizeof (IPS_ADAPTER
) +
4239 sizeof (IPS_IO_CMD
), ha
->adapt
,
4240 ha
->adapt
->hw_status_start
);
4244 if (ha
->logical_drive_info
) {
4245 pci_free_consistent(ha
->pcidev
,
4246 sizeof (IPS_LD_INFO
),
4247 ha
->logical_drive_info
,
4248 ha
->logical_drive_info_dma_addr
);
4249 ha
->logical_drive_info
= NULL
;
4258 if (ha
->ioctl_data
) {
4259 pci_free_consistent(ha
->pcidev
, ha
->ioctl_len
,
4260 ha
->ioctl_data
, ha
->ioctl_busaddr
);
4261 ha
->ioctl_data
= NULL
;
4262 ha
->ioctl_datasize
= 0;
4265 ips_deallocatescbs(ha
, ha
->max_cmds
);
4267 /* free memory mapped (if applicable) */
4269 iounmap(ha
->ioremap_ptr
);
4270 ha
->ioremap_ptr
= NULL
;
4279 /****************************************************************************/
4281 /* Routine Name: ips_deallocatescbs */
4283 /* Routine Description: */
4285 /* Free the command blocks */
4287 /****************************************************************************/
4289 ips_deallocatescbs(ips_ha_t
* ha
, int cmds
)
4292 pci_free_consistent(ha
->pcidev
,
4293 IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
* cmds
,
4294 ha
->scbs
->sg_list
.list
,
4295 ha
->scbs
->sg_busaddr
);
4296 pci_free_consistent(ha
->pcidev
, sizeof (ips_scb_t
) * cmds
,
4297 ha
->scbs
, ha
->scbs
->scb_busaddr
);
4303 /****************************************************************************/
4305 /* Routine Name: ips_allocatescbs */
4307 /* Routine Description: */
4309 /* Allocate the command blocks */
4311 /****************************************************************************/
4313 ips_allocatescbs(ips_ha_t
* ha
)
4318 dma_addr_t command_dma
, sg_dma
;
4320 METHOD_TRACE("ips_allocatescbs", 1);
4322 /* Allocate memory for the SCBs */
4324 pci_alloc_consistent(ha
->pcidev
, ha
->max_cmds
* sizeof (ips_scb_t
),
4326 if (ha
->scbs
== NULL
)
4329 pci_alloc_consistent(ha
->pcidev
,
4330 IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
*
4331 ha
->max_cmds
, &sg_dma
);
4332 if (ips_sg
.list
== NULL
) {
4333 pci_free_consistent(ha
->pcidev
,
4334 ha
->max_cmds
* sizeof (ips_scb_t
), ha
->scbs
,
4339 memset(ha
->scbs
, 0, ha
->max_cmds
* sizeof (ips_scb_t
));
4341 for (i
= 0; i
< ha
->max_cmds
; i
++) {
4342 scb_p
= &ha
->scbs
[i
];
4343 scb_p
->scb_busaddr
= command_dma
+ sizeof (ips_scb_t
) * i
;
4344 /* set up S/G list */
4345 if (IPS_USE_ENH_SGLIST(ha
)) {
4346 scb_p
->sg_list
.enh_list
=
4347 ips_sg
.enh_list
+ i
* IPS_MAX_SG
;
4349 sg_dma
+ IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
* i
;
4351 scb_p
->sg_list
.std_list
=
4352 ips_sg
.std_list
+ i
* IPS_MAX_SG
;
4354 sg_dma
+ IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
* i
;
4357 /* add to the free list */
4358 if (i
< ha
->max_cmds
- 1) {
4359 scb_p
->q_next
= ha
->scb_freelist
;
4360 ha
->scb_freelist
= scb_p
;
4368 /****************************************************************************/
4370 /* Routine Name: ips_init_scb */
4372 /* Routine Description: */
4374 /* Initialize a CCB to default values */
4376 /****************************************************************************/
4378 ips_init_scb(ips_ha_t
* ha
, ips_scb_t
* scb
)
4380 IPS_SG_LIST sg_list
;
4381 uint32_t cmd_busaddr
, sg_busaddr
;
4382 METHOD_TRACE("ips_init_scb", 1);
4387 sg_list
.list
= scb
->sg_list
.list
;
4388 cmd_busaddr
= scb
->scb_busaddr
;
4389 sg_busaddr
= scb
->sg_busaddr
;
4391 memset(scb
, 0, sizeof (ips_scb_t
));
4392 memset(ha
->dummy
, 0, sizeof (IPS_IO_CMD
));
4394 /* Initialize dummy command bucket */
4395 ha
->dummy
->op_code
= 0xFF;
4396 ha
->dummy
->ccsar
= cpu_to_le32(ha
->adapt
->hw_status_start
4397 + sizeof (IPS_ADAPTER
));
4398 ha
->dummy
->command_id
= IPS_MAX_CMDS
;
4400 /* set bus address of scb */
4401 scb
->scb_busaddr
= cmd_busaddr
;
4402 scb
->sg_busaddr
= sg_busaddr
;
4403 scb
->sg_list
.list
= sg_list
.list
;
4406 scb
->cmd
.basic_io
.cccr
= cpu_to_le32((uint32_t) IPS_BIT_ILE
);
4407 scb
->cmd
.basic_io
.ccsar
= cpu_to_le32(ha
->adapt
->hw_status_start
4408 + sizeof (IPS_ADAPTER
));
4411 /****************************************************************************/
4413 /* Routine Name: ips_get_scb */
4415 /* Routine Description: */
4417 /* Initialize a CCB to default values */
4419 /* ASSUMED to be called from within a lock */
4421 /****************************************************************************/
4423 ips_getscb(ips_ha_t
* ha
)
4427 METHOD_TRACE("ips_getscb", 1);
4429 if ((scb
= ha
->scb_freelist
) == NULL
) {
4434 ha
->scb_freelist
= scb
->q_next
;
4438 ips_init_scb(ha
, scb
);
4443 /****************************************************************************/
4445 /* Routine Name: ips_free_scb */
4447 /* Routine Description: */
4449 /* Return an unused CCB back to the free list */
4451 /* ASSUMED to be called from within a lock */
4453 /****************************************************************************/
4455 ips_freescb(ips_ha_t
* ha
, ips_scb_t
* scb
)
4458 METHOD_TRACE("ips_freescb", 1);
4459 if (scb
->flags
& IPS_SCB_MAP_SG
)
4460 scsi_dma_unmap(scb
->scsi_cmd
);
4461 else if (scb
->flags
& IPS_SCB_MAP_SINGLE
)
4462 pci_unmap_single(ha
->pcidev
, scb
->data_busaddr
, scb
->data_len
,
4465 /* check to make sure this is not our "special" scb */
4466 if (IPS_COMMAND_ID(ha
, scb
) < (ha
->max_cmds
- 1)) {
4467 scb
->q_next
= ha
->scb_freelist
;
4468 ha
->scb_freelist
= scb
;
4472 /****************************************************************************/
4474 /* Routine Name: ips_isinit_copperhead */
4476 /* Routine Description: */
4478 /* Is controller initialized ? */
4480 /****************************************************************************/
4482 ips_isinit_copperhead(ips_ha_t
* ha
)
4487 METHOD_TRACE("ips_isinit_copperhead", 1);
4489 isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
4490 scpr
= inb(ha
->io_addr
+ IPS_REG_SCPR
);
4492 if (((isr
& IPS_BIT_EI
) == 0) && ((scpr
& IPS_BIT_EBM
) == 0))
4498 /****************************************************************************/
4500 /* Routine Name: ips_isinit_copperhead_memio */
4502 /* Routine Description: */
4504 /* Is controller initialized ? */
4506 /****************************************************************************/
4508 ips_isinit_copperhead_memio(ips_ha_t
* ha
)
4513 METHOD_TRACE("ips_is_init_copperhead_memio", 1);
4515 isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
4516 scpr
= readb(ha
->mem_ptr
+ IPS_REG_SCPR
);
4518 if (((isr
& IPS_BIT_EI
) == 0) && ((scpr
& IPS_BIT_EBM
) == 0))
4524 /****************************************************************************/
4526 /* Routine Name: ips_isinit_morpheus */
4528 /* Routine Description: */
4530 /* Is controller initialized ? */
4532 /****************************************************************************/
4534 ips_isinit_morpheus(ips_ha_t
* ha
)
4539 METHOD_TRACE("ips_is_init_morpheus", 1);
4541 if (ips_isintr_morpheus(ha
))
4542 ips_flush_and_reset(ha
);
4544 post
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG0
);
4545 bits
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
4549 else if (bits
& 0x3)
4555 /****************************************************************************/
4557 /* Routine Name: ips_flush_and_reset */
4559 /* Routine Description: */
4561 /* Perform cleanup ( FLUSH and RESET ) when the adapter is in an unknown */
4562 /* state ( was trying to INIT and an interrupt was already pending ) ... */
4564 /****************************************************************************/
4566 ips_flush_and_reset(ips_ha_t
*ha
)
4572 dma_addr_t command_dma
;
4574 /* Create a usuable SCB */
4575 scb
= pci_alloc_consistent(ha
->pcidev
, sizeof(ips_scb_t
), &command_dma
);
4577 memset(scb
, 0, sizeof(ips_scb_t
));
4578 ips_init_scb(ha
, scb
);
4579 scb
->scb_busaddr
= command_dma
;
4581 scb
->timeout
= ips_cmd_timeout
;
4582 scb
->cdb
[0] = IPS_CMD_FLUSH
;
4584 scb
->cmd
.flush_cache
.op_code
= IPS_CMD_FLUSH
;
4585 scb
->cmd
.flush_cache
.command_id
= IPS_MAX_CMDS
; /* Use an ID that would otherwise not exist */
4586 scb
->cmd
.flush_cache
.state
= IPS_NORM_STATE
;
4587 scb
->cmd
.flush_cache
.reserved
= 0;
4588 scb
->cmd
.flush_cache
.reserved2
= 0;
4589 scb
->cmd
.flush_cache
.reserved3
= 0;
4590 scb
->cmd
.flush_cache
.reserved4
= 0;
4592 ret
= ips_send_cmd(ha
, scb
); /* Send the Flush Command */
4594 if (ret
== IPS_SUCCESS
) {
4595 time
= 60 * IPS_ONE_SEC
; /* Max Wait time is 60 seconds */
4598 while ((time
> 0) && (!done
)) {
4599 done
= ips_poll_for_flush_complete(ha
);
4600 /* This may look evil, but it's only done during extremely rare start-up conditions ! */
4607 /* Now RESET and INIT the adapter */
4608 (*ha
->func
.reset
) (ha
);
4610 pci_free_consistent(ha
->pcidev
, sizeof(ips_scb_t
), scb
, command_dma
);
4614 /****************************************************************************/
4616 /* Routine Name: ips_poll_for_flush_complete */
4618 /* Routine Description: */
4620 /* Poll for the Flush Command issued by ips_flush_and_reset() to complete */
4621 /* All other responses are just taken off the queue and ignored */
4623 /****************************************************************************/
4625 ips_poll_for_flush_complete(ips_ha_t
* ha
)
4630 cstatus
.value
= (*ha
->func
.statupd
) (ha
);
4632 if (cstatus
.value
== 0xffffffff) /* If No Interrupt to process */
4635 /* Success is when we see the Flush Command ID */
4636 if (cstatus
.fields
.command_id
== IPS_MAX_CMDS
)
4643 /****************************************************************************/
4645 /* Routine Name: ips_enable_int_copperhead */
4647 /* Routine Description: */
4648 /* Turn on interrupts */
4650 /****************************************************************************/
4652 ips_enable_int_copperhead(ips_ha_t
* ha
)
4654 METHOD_TRACE("ips_enable_int_copperhead", 1);
4656 outb(ha
->io_addr
+ IPS_REG_HISR
, IPS_BIT_EI
);
4657 inb(ha
->io_addr
+ IPS_REG_HISR
); /*Ensure PCI Posting Completes*/
4660 /****************************************************************************/
4662 /* Routine Name: ips_enable_int_copperhead_memio */
4664 /* Routine Description: */
4665 /* Turn on interrupts */
4667 /****************************************************************************/
4669 ips_enable_int_copperhead_memio(ips_ha_t
* ha
)
4671 METHOD_TRACE("ips_enable_int_copperhead_memio", 1);
4673 writeb(IPS_BIT_EI
, ha
->mem_ptr
+ IPS_REG_HISR
);
4674 readb(ha
->mem_ptr
+ IPS_REG_HISR
); /*Ensure PCI Posting Completes*/
4677 /****************************************************************************/
4679 /* Routine Name: ips_enable_int_morpheus */
4681 /* Routine Description: */
4682 /* Turn on interrupts */
4684 /****************************************************************************/
4686 ips_enable_int_morpheus(ips_ha_t
* ha
)
4690 METHOD_TRACE("ips_enable_int_morpheus", 1);
4692 Oimr
= readl(ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
4694 writel(Oimr
, ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
4695 readl(ha
->mem_ptr
+ IPS_REG_I960_OIMR
); /*Ensure PCI Posting Completes*/
4698 /****************************************************************************/
4700 /* Routine Name: ips_init_copperhead */
4702 /* Routine Description: */
4704 /* Initialize a copperhead controller */
4706 /****************************************************************************/
4708 ips_init_copperhead(ips_ha_t
* ha
)
4712 uint8_t PostByte
[IPS_MAX_POST_BYTES
];
4713 uint8_t ConfigByte
[IPS_MAX_CONFIG_BYTES
];
4716 METHOD_TRACE("ips_init_copperhead", 1);
4718 for (i
= 0; i
< IPS_MAX_POST_BYTES
; i
++) {
4719 for (j
= 0; j
< 45; j
++) {
4720 Isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
4721 if (Isr
& IPS_BIT_GHI
)
4724 /* Delay for 1 Second */
4725 MDELAY(IPS_ONE_SEC
);
4729 /* error occurred */
4732 PostByte
[i
] = inb(ha
->io_addr
+ IPS_REG_ISPR
);
4733 outb(Isr
, ha
->io_addr
+ IPS_REG_HISR
);
4736 if (PostByte
[0] < IPS_GOOD_POST_STATUS
) {
4737 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
4738 "reset controller fails (post status %x %x).\n",
4739 PostByte
[0], PostByte
[1]);
4744 for (i
= 0; i
< IPS_MAX_CONFIG_BYTES
; i
++) {
4745 for (j
= 0; j
< 240; j
++) {
4746 Isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
4747 if (Isr
& IPS_BIT_GHI
)
4750 /* Delay for 1 Second */
4751 MDELAY(IPS_ONE_SEC
);
4755 /* error occurred */
4758 ConfigByte
[i
] = inb(ha
->io_addr
+ IPS_REG_ISPR
);
4759 outb(Isr
, ha
->io_addr
+ IPS_REG_HISR
);
4762 for (i
= 0; i
< 240; i
++) {
4763 Cbsp
= inb(ha
->io_addr
+ IPS_REG_CBSP
);
4765 if ((Cbsp
& IPS_BIT_OP
) == 0)
4768 /* Delay for 1 Second */
4769 MDELAY(IPS_ONE_SEC
);
4777 outl(0x1010, ha
->io_addr
+ IPS_REG_CCCR
);
4779 /* Enable busmastering */
4780 outb(IPS_BIT_EBM
, ha
->io_addr
+ IPS_REG_SCPR
);
4782 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
4783 /* fix for anaconda64 */
4784 outl(0, ha
->io_addr
+ IPS_REG_NDAE
);
4786 /* Enable interrupts */
4787 outb(IPS_BIT_EI
, ha
->io_addr
+ IPS_REG_HISR
);
4792 /****************************************************************************/
4794 /* Routine Name: ips_init_copperhead_memio */
4796 /* Routine Description: */
4798 /* Initialize a copperhead controller with memory mapped I/O */
4800 /****************************************************************************/
4802 ips_init_copperhead_memio(ips_ha_t
* ha
)
4806 uint8_t PostByte
[IPS_MAX_POST_BYTES
];
4807 uint8_t ConfigByte
[IPS_MAX_CONFIG_BYTES
];
4810 METHOD_TRACE("ips_init_copperhead_memio", 1);
4812 for (i
= 0; i
< IPS_MAX_POST_BYTES
; i
++) {
4813 for (j
= 0; j
< 45; j
++) {
4814 Isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
4815 if (Isr
& IPS_BIT_GHI
)
4818 /* Delay for 1 Second */
4819 MDELAY(IPS_ONE_SEC
);
4823 /* error occurred */
4826 PostByte
[i
] = readb(ha
->mem_ptr
+ IPS_REG_ISPR
);
4827 writeb(Isr
, ha
->mem_ptr
+ IPS_REG_HISR
);
4830 if (PostByte
[0] < IPS_GOOD_POST_STATUS
) {
4831 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
4832 "reset controller fails (post status %x %x).\n",
4833 PostByte
[0], PostByte
[1]);
4838 for (i
= 0; i
< IPS_MAX_CONFIG_BYTES
; i
++) {
4839 for (j
= 0; j
< 240; j
++) {
4840 Isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
4841 if (Isr
& IPS_BIT_GHI
)
4844 /* Delay for 1 Second */
4845 MDELAY(IPS_ONE_SEC
);
4849 /* error occurred */
4852 ConfigByte
[i
] = readb(ha
->mem_ptr
+ IPS_REG_ISPR
);
4853 writeb(Isr
, ha
->mem_ptr
+ IPS_REG_HISR
);
4856 for (i
= 0; i
< 240; i
++) {
4857 Cbsp
= readb(ha
->mem_ptr
+ IPS_REG_CBSP
);
4859 if ((Cbsp
& IPS_BIT_OP
) == 0)
4862 /* Delay for 1 Second */
4863 MDELAY(IPS_ONE_SEC
);
4867 /* error occurred */
4871 writel(0x1010, ha
->mem_ptr
+ IPS_REG_CCCR
);
4873 /* Enable busmastering */
4874 writeb(IPS_BIT_EBM
, ha
->mem_ptr
+ IPS_REG_SCPR
);
4876 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
4877 /* fix for anaconda64 */
4878 writel(0, ha
->mem_ptr
+ IPS_REG_NDAE
);
4880 /* Enable interrupts */
4881 writeb(IPS_BIT_EI
, ha
->mem_ptr
+ IPS_REG_HISR
);
4883 /* if we get here then everything went OK */
4887 /****************************************************************************/
4889 /* Routine Name: ips_init_morpheus */
4891 /* Routine Description: */
4893 /* Initialize a morpheus controller */
4895 /****************************************************************************/
4897 ips_init_morpheus(ips_ha_t
* ha
)
4905 METHOD_TRACE("ips_init_morpheus", 1);
4907 /* Wait up to 45 secs for Post */
4908 for (i
= 0; i
< 45; i
++) {
4909 Isr
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
4911 if (Isr
& IPS_BIT_I960_MSG0I
)
4914 /* Delay for 1 Second */
4915 MDELAY(IPS_ONE_SEC
);
4919 /* error occurred */
4920 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
4921 "timeout waiting for post.\n");
4926 Post
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG0
);
4928 if (Post
== 0x4F00) { /* If Flashing the Battery PIC */
4929 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
4930 "Flashing Battery PIC, Please wait ...\n");
4932 /* Clear the interrupt bit */
4933 Isr
= (uint32_t) IPS_BIT_I960_MSG0I
;
4934 writel(Isr
, ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
4936 for (i
= 0; i
< 120; i
++) { /* Wait Up to 2 Min. for Completion */
4937 Post
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG0
);
4940 /* Delay for 1 Second */
4941 MDELAY(IPS_ONE_SEC
);
4945 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
4946 "timeout waiting for Battery PIC Flash\n");
4952 /* Clear the interrupt bit */
4953 Isr
= (uint32_t) IPS_BIT_I960_MSG0I
;
4954 writel(Isr
, ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
4956 if (Post
< (IPS_GOOD_POST_STATUS
<< 8)) {
4957 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
4958 "reset controller fails (post status %x).\n", Post
);
4963 /* Wait up to 240 secs for config bytes */
4964 for (i
= 0; i
< 240; i
++) {
4965 Isr
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
4967 if (Isr
& IPS_BIT_I960_MSG1I
)
4970 /* Delay for 1 Second */
4971 MDELAY(IPS_ONE_SEC
);
4975 /* error occurred */
4976 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
4977 "timeout waiting for config.\n");
4982 Config
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG1
);
4984 /* Clear interrupt bit */
4985 Isr
= (uint32_t) IPS_BIT_I960_MSG1I
;
4986 writel(Isr
, ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
4988 /* Turn on the interrupts */
4989 Oimr
= readl(ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
4991 writel(Oimr
, ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
4993 /* if we get here then everything went OK */
4995 /* Since we did a RESET, an EraseStripeLock may be needed */
4996 if (Post
== 0xEF10) {
4997 if ((Config
== 0x000F) || (Config
== 0x0009))
4998 ha
->requires_esl
= 1;
5004 /****************************************************************************/
5006 /* Routine Name: ips_reset_copperhead */
5008 /* Routine Description: */
5010 /* Reset the controller */
5012 /****************************************************************************/
5014 ips_reset_copperhead(ips_ha_t
* ha
)
5018 METHOD_TRACE("ips_reset_copperhead", 1);
5020 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead: io addr: %x, irq: %d",
5021 ips_name
, ha
->host_num
, ha
->io_addr
, ha
->pcidev
->irq
);
5025 while (reset_counter
< 2) {
5028 outb(IPS_BIT_RST
, ha
->io_addr
+ IPS_REG_SCPR
);
5030 /* Delay for 1 Second */
5031 MDELAY(IPS_ONE_SEC
);
5033 outb(0, ha
->io_addr
+ IPS_REG_SCPR
);
5035 /* Delay for 1 Second */
5036 MDELAY(IPS_ONE_SEC
);
5038 if ((*ha
->func
.init
) (ha
))
5040 else if (reset_counter
>= 2) {
5049 /****************************************************************************/
5051 /* Routine Name: ips_reset_copperhead_memio */
5053 /* Routine Description: */
5055 /* Reset the controller */
5057 /****************************************************************************/
5059 ips_reset_copperhead_memio(ips_ha_t
* ha
)
5063 METHOD_TRACE("ips_reset_copperhead_memio", 1);
5065 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead_memio: mem addr: %x, irq: %d",
5066 ips_name
, ha
->host_num
, ha
->mem_addr
, ha
->pcidev
->irq
);
5070 while (reset_counter
< 2) {
5073 writeb(IPS_BIT_RST
, ha
->mem_ptr
+ IPS_REG_SCPR
);
5075 /* Delay for 1 Second */
5076 MDELAY(IPS_ONE_SEC
);
5078 writeb(0, ha
->mem_ptr
+ IPS_REG_SCPR
);
5080 /* Delay for 1 Second */
5081 MDELAY(IPS_ONE_SEC
);
5083 if ((*ha
->func
.init
) (ha
))
5085 else if (reset_counter
>= 2) {
5094 /****************************************************************************/
5096 /* Routine Name: ips_reset_morpheus */
5098 /* Routine Description: */
5100 /* Reset the controller */
5102 /****************************************************************************/
5104 ips_reset_morpheus(ips_ha_t
* ha
)
5109 METHOD_TRACE("ips_reset_morpheus", 1);
5111 DEBUG_VAR(1, "(%s%d) ips_reset_morpheus: mem addr: %x, irq: %d",
5112 ips_name
, ha
->host_num
, ha
->mem_addr
, ha
->pcidev
->irq
);
5116 while (reset_counter
< 2) {
5119 writel(0x80000000, ha
->mem_ptr
+ IPS_REG_I960_IDR
);
5121 /* Delay for 5 Seconds */
5122 MDELAY(5 * IPS_ONE_SEC
);
5124 /* Do a PCI config read to wait for adapter */
5125 pci_read_config_byte(ha
->pcidev
, 4, &junk
);
5127 if ((*ha
->func
.init
) (ha
))
5129 else if (reset_counter
>= 2) {
5138 /****************************************************************************/
5140 /* Routine Name: ips_statinit */
5142 /* Routine Description: */
5144 /* Initialize the status queues on the controller */
5146 /****************************************************************************/
5148 ips_statinit(ips_ha_t
* ha
)
5150 uint32_t phys_status_start
;
5152 METHOD_TRACE("ips_statinit", 1);
5154 ha
->adapt
->p_status_start
= ha
->adapt
->status
;
5155 ha
->adapt
->p_status_end
= ha
->adapt
->status
+ IPS_MAX_CMDS
;
5156 ha
->adapt
->p_status_tail
= ha
->adapt
->status
;
5158 phys_status_start
= ha
->adapt
->hw_status_start
;
5159 outl(phys_status_start
, ha
->io_addr
+ IPS_REG_SQSR
);
5160 outl(phys_status_start
+ IPS_STATUS_Q_SIZE
,
5161 ha
->io_addr
+ IPS_REG_SQER
);
5162 outl(phys_status_start
+ IPS_STATUS_SIZE
,
5163 ha
->io_addr
+ IPS_REG_SQHR
);
5164 outl(phys_status_start
, ha
->io_addr
+ IPS_REG_SQTR
);
5166 ha
->adapt
->hw_status_tail
= phys_status_start
;
5169 /****************************************************************************/
5171 /* Routine Name: ips_statinit_memio */
5173 /* Routine Description: */
5175 /* Initialize the status queues on the controller */
5177 /****************************************************************************/
5179 ips_statinit_memio(ips_ha_t
* ha
)
5181 uint32_t phys_status_start
;
5183 METHOD_TRACE("ips_statinit_memio", 1);
5185 ha
->adapt
->p_status_start
= ha
->adapt
->status
;
5186 ha
->adapt
->p_status_end
= ha
->adapt
->status
+ IPS_MAX_CMDS
;
5187 ha
->adapt
->p_status_tail
= ha
->adapt
->status
;
5189 phys_status_start
= ha
->adapt
->hw_status_start
;
5190 writel(phys_status_start
, ha
->mem_ptr
+ IPS_REG_SQSR
);
5191 writel(phys_status_start
+ IPS_STATUS_Q_SIZE
,
5192 ha
->mem_ptr
+ IPS_REG_SQER
);
5193 writel(phys_status_start
+ IPS_STATUS_SIZE
, ha
->mem_ptr
+ IPS_REG_SQHR
);
5194 writel(phys_status_start
, ha
->mem_ptr
+ IPS_REG_SQTR
);
5196 ha
->adapt
->hw_status_tail
= phys_status_start
;
5199 /****************************************************************************/
5201 /* Routine Name: ips_statupd_copperhead */
5203 /* Routine Description: */
5205 /* Remove an element from the status queue */
5207 /****************************************************************************/
5209 ips_statupd_copperhead(ips_ha_t
* ha
)
5211 METHOD_TRACE("ips_statupd_copperhead", 1);
5213 if (ha
->adapt
->p_status_tail
!= ha
->adapt
->p_status_end
) {
5214 ha
->adapt
->p_status_tail
++;
5215 ha
->adapt
->hw_status_tail
+= sizeof (IPS_STATUS
);
5217 ha
->adapt
->p_status_tail
= ha
->adapt
->p_status_start
;
5218 ha
->adapt
->hw_status_tail
= ha
->adapt
->hw_status_start
;
5221 outl(ha
->adapt
->hw_status_tail
,
5222 ha
->io_addr
+ IPS_REG_SQTR
);
5224 return (ha
->adapt
->p_status_tail
->value
);
5227 /****************************************************************************/
5229 /* Routine Name: ips_statupd_copperhead_memio */
5231 /* Routine Description: */
5233 /* Remove an element from the status queue */
5235 /****************************************************************************/
5237 ips_statupd_copperhead_memio(ips_ha_t
* ha
)
5239 METHOD_TRACE("ips_statupd_copperhead_memio", 1);
5241 if (ha
->adapt
->p_status_tail
!= ha
->adapt
->p_status_end
) {
5242 ha
->adapt
->p_status_tail
++;
5243 ha
->adapt
->hw_status_tail
+= sizeof (IPS_STATUS
);
5245 ha
->adapt
->p_status_tail
= ha
->adapt
->p_status_start
;
5246 ha
->adapt
->hw_status_tail
= ha
->adapt
->hw_status_start
;
5249 writel(ha
->adapt
->hw_status_tail
, ha
->mem_ptr
+ IPS_REG_SQTR
);
5251 return (ha
->adapt
->p_status_tail
->value
);
5254 /****************************************************************************/
5256 /* Routine Name: ips_statupd_morpheus */
5258 /* Routine Description: */
5260 /* Remove an element from the status queue */
5262 /****************************************************************************/
5264 ips_statupd_morpheus(ips_ha_t
* ha
)
5268 METHOD_TRACE("ips_statupd_morpheus", 1);
5270 val
= readl(ha
->mem_ptr
+ IPS_REG_I2O_OUTMSGQ
);
5275 /****************************************************************************/
5277 /* Routine Name: ips_issue_copperhead */
5279 /* Routine Description: */
5281 /* Send a command down to the controller */
5283 /****************************************************************************/
5285 ips_issue_copperhead(ips_ha_t
* ha
, ips_scb_t
* scb
)
5290 METHOD_TRACE("ips_issue_copperhead", 1);
5292 if (scb
->scsi_cmd
) {
5293 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5297 scb
->cmd
.basic_io
.command_id
,
5298 scb
->bus
, scb
->target_id
, scb
->lun
);
5300 DEBUG_VAR(2, KERN_NOTICE
"(%s%d) ips_issue: logical cmd id %d",
5301 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5307 le32_to_cpu(inl(ha
->io_addr
+ IPS_REG_CCCR
))) & IPS_BIT_SEM
) {
5310 if (++TimeOut
>= IPS_SEM_TIMEOUT
) {
5311 if (!(val
& IPS_BIT_START_STOP
))
5314 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5315 "ips_issue val [0x%x].\n", val
);
5316 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5317 "ips_issue semaphore chk timeout.\n");
5319 return (IPS_FAILURE
);
5323 outl(scb
->scb_busaddr
, ha
->io_addr
+ IPS_REG_CCSAR
);
5324 outw(IPS_BIT_START_CMD
, ha
->io_addr
+ IPS_REG_CCCR
);
5326 return (IPS_SUCCESS
);
5329 /****************************************************************************/
5331 /* Routine Name: ips_issue_copperhead_memio */
5333 /* Routine Description: */
5335 /* Send a command down to the controller */
5337 /****************************************************************************/
5339 ips_issue_copperhead_memio(ips_ha_t
* ha
, ips_scb_t
* scb
)
5344 METHOD_TRACE("ips_issue_copperhead_memio", 1);
5346 if (scb
->scsi_cmd
) {
5347 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5351 scb
->cmd
.basic_io
.command_id
,
5352 scb
->bus
, scb
->target_id
, scb
->lun
);
5354 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5355 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5360 while ((val
= readl(ha
->mem_ptr
+ IPS_REG_CCCR
)) & IPS_BIT_SEM
) {
5363 if (++TimeOut
>= IPS_SEM_TIMEOUT
) {
5364 if (!(val
& IPS_BIT_START_STOP
))
5367 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5368 "ips_issue val [0x%x].\n", val
);
5369 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5370 "ips_issue semaphore chk timeout.\n");
5372 return (IPS_FAILURE
);
5376 writel(scb
->scb_busaddr
, ha
->mem_ptr
+ IPS_REG_CCSAR
);
5377 writel(IPS_BIT_START_CMD
, ha
->mem_ptr
+ IPS_REG_CCCR
);
5379 return (IPS_SUCCESS
);
5382 /****************************************************************************/
5384 /* Routine Name: ips_issue_i2o */
5386 /* Routine Description: */
5388 /* Send a command down to the controller */
5390 /****************************************************************************/
5392 ips_issue_i2o(ips_ha_t
* ha
, ips_scb_t
* scb
)
5395 METHOD_TRACE("ips_issue_i2o", 1);
5397 if (scb
->scsi_cmd
) {
5398 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5402 scb
->cmd
.basic_io
.command_id
,
5403 scb
->bus
, scb
->target_id
, scb
->lun
);
5405 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5406 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5409 outl(scb
->scb_busaddr
, ha
->io_addr
+ IPS_REG_I2O_INMSGQ
);
5411 return (IPS_SUCCESS
);
5414 /****************************************************************************/
5416 /* Routine Name: ips_issue_i2o_memio */
5418 /* Routine Description: */
5420 /* Send a command down to the controller */
5422 /****************************************************************************/
5424 ips_issue_i2o_memio(ips_ha_t
* ha
, ips_scb_t
* scb
)
5427 METHOD_TRACE("ips_issue_i2o_memio", 1);
5429 if (scb
->scsi_cmd
) {
5430 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5434 scb
->cmd
.basic_io
.command_id
,
5435 scb
->bus
, scb
->target_id
, scb
->lun
);
5437 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5438 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5441 writel(scb
->scb_busaddr
, ha
->mem_ptr
+ IPS_REG_I2O_INMSGQ
);
5443 return (IPS_SUCCESS
);
5446 /****************************************************************************/
5448 /* Routine Name: ips_isintr_copperhead */
5450 /* Routine Description: */
5452 /* Test to see if an interrupt is for us */
5454 /****************************************************************************/
5456 ips_isintr_copperhead(ips_ha_t
* ha
)
5460 METHOD_TRACE("ips_isintr_copperhead", 2);
5462 Isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
5465 /* ?!?! Nothing really there */
5468 if (Isr
& IPS_BIT_SCE
)
5470 else if (Isr
& (IPS_BIT_SQO
| IPS_BIT_GHI
)) {
5471 /* status queue overflow or GHI */
5472 /* just clear the interrupt */
5473 outb(Isr
, ha
->io_addr
+ IPS_REG_HISR
);
5479 /****************************************************************************/
5481 /* Routine Name: ips_isintr_copperhead_memio */
5483 /* Routine Description: */
5485 /* Test to see if an interrupt is for us */
5487 /****************************************************************************/
5489 ips_isintr_copperhead_memio(ips_ha_t
* ha
)
5493 METHOD_TRACE("ips_isintr_memio", 2);
5495 Isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
5498 /* ?!?! Nothing really there */
5501 if (Isr
& IPS_BIT_SCE
)
5503 else if (Isr
& (IPS_BIT_SQO
| IPS_BIT_GHI
)) {
5504 /* status queue overflow or GHI */
5505 /* just clear the interrupt */
5506 writeb(Isr
, ha
->mem_ptr
+ IPS_REG_HISR
);
5512 /****************************************************************************/
5514 /* Routine Name: ips_isintr_morpheus */
5516 /* Routine Description: */
5518 /* Test to see if an interrupt is for us */
5520 /****************************************************************************/
5522 ips_isintr_morpheus(ips_ha_t
* ha
)
5526 METHOD_TRACE("ips_isintr_morpheus", 2);
5528 Isr
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5530 if (Isr
& IPS_BIT_I2O_OPQI
)
5536 /****************************************************************************/
5538 /* Routine Name: ips_wait */
5540 /* Routine Description: */
5542 /* Wait for a command to complete */
5544 /****************************************************************************/
5546 ips_wait(ips_ha_t
* ha
, int time
, int intr
)
5551 METHOD_TRACE("ips_wait", 1);
5556 time
*= IPS_ONE_SEC
; /* convert seconds */
5558 while ((time
> 0) && (!done
)) {
5559 if (intr
== IPS_INTR_ON
) {
5560 if (ha
->waitflag
== FALSE
) {
5565 } else if (intr
== IPS_INTR_IORL
) {
5566 if (ha
->waitflag
== FALSE
) {
5568 * controller generated an interrupt to
5569 * acknowledge completion of the command
5570 * and ips_intr() has serviced the interrupt.
5578 * NOTE: we already have the io_request_lock so
5579 * even if we get an interrupt it won't get serviced
5580 * until after we finish.
5583 (*ha
->func
.intr
) (ha
);
5586 /* This looks like a very evil loop, but it only does this during start-up */
5594 /****************************************************************************/
5596 /* Routine Name: ips_write_driver_status */
5598 /* Routine Description: */
5600 /* Write OS/Driver version to Page 5 of the nvram on the controller */
5602 /****************************************************************************/
5604 ips_write_driver_status(ips_ha_t
* ha
, int intr
)
5606 METHOD_TRACE("ips_write_driver_status", 1);
5608 if (!ips_readwrite_page5(ha
, FALSE
, intr
)) {
5609 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5610 "unable to read NVRAM page 5.\n");
5615 /* check to make sure the page has a valid */
5617 if (le32_to_cpu(ha
->nvram
->signature
) != IPS_NVRAM_P5_SIG
) {
5619 "(%s%d) NVRAM page 5 has an invalid signature: %X.",
5620 ips_name
, ha
->host_num
, ha
->nvram
->signature
);
5621 ha
->nvram
->signature
= IPS_NVRAM_P5_SIG
;
5625 "(%s%d) Ad Type: %d, Ad Slot: %d, BIOS: %c%c%c%c %c%c%c%c.",
5626 ips_name
, ha
->host_num
, le16_to_cpu(ha
->nvram
->adapter_type
),
5627 ha
->nvram
->adapter_slot
, ha
->nvram
->bios_high
[0],
5628 ha
->nvram
->bios_high
[1], ha
->nvram
->bios_high
[2],
5629 ha
->nvram
->bios_high
[3], ha
->nvram
->bios_low
[0],
5630 ha
->nvram
->bios_low
[1], ha
->nvram
->bios_low
[2],
5631 ha
->nvram
->bios_low
[3]);
5633 ips_get_bios_version(ha
, intr
);
5635 /* change values (as needed) */
5636 ha
->nvram
->operating_system
= IPS_OS_LINUX
;
5637 ha
->nvram
->adapter_type
= ha
->ad_type
;
5638 strncpy((char *) ha
->nvram
->driver_high
, IPS_VERSION_HIGH
, 4);
5639 strncpy((char *) ha
->nvram
->driver_low
, IPS_VERSION_LOW
, 4);
5640 strncpy((char *) ha
->nvram
->bios_high
, ha
->bios_version
, 4);
5641 strncpy((char *) ha
->nvram
->bios_low
, ha
->bios_version
+ 4, 4);
5643 ha
->nvram
->versioning
= 0; /* Indicate the Driver Does Not Support Versioning */
5645 /* now update the page */
5646 if (!ips_readwrite_page5(ha
, TRUE
, intr
)) {
5647 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5648 "unable to write NVRAM page 5.\n");
5653 /* IF NVRAM Page 5 is OK, Use it for Slot Number Info Because Linux Doesn't Do Slots */
5654 ha
->slot_num
= ha
->nvram
->adapter_slot
;
5659 /****************************************************************************/
5661 /* Routine Name: ips_read_adapter_status */
5663 /* Routine Description: */
5665 /* Do an Inquiry command to the adapter */
5667 /****************************************************************************/
5669 ips_read_adapter_status(ips_ha_t
* ha
, int intr
)
5674 METHOD_TRACE("ips_read_adapter_status", 1);
5676 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5678 ips_init_scb(ha
, scb
);
5680 scb
->timeout
= ips_cmd_timeout
;
5681 scb
->cdb
[0] = IPS_CMD_ENQUIRY
;
5683 scb
->cmd
.basic_io
.op_code
= IPS_CMD_ENQUIRY
;
5684 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5685 scb
->cmd
.basic_io
.sg_count
= 0;
5686 scb
->cmd
.basic_io
.lba
= 0;
5687 scb
->cmd
.basic_io
.sector_count
= 0;
5688 scb
->cmd
.basic_io
.log_drv
= 0;
5689 scb
->data_len
= sizeof (*ha
->enq
);
5690 scb
->cmd
.basic_io
.sg_addr
= ha
->enq_busaddr
;
5694 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
5695 || (ret
== IPS_SUCCESS_IMM
)
5696 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
5702 /****************************************************************************/
5704 /* Routine Name: ips_read_subsystem_parameters */
5706 /* Routine Description: */
5708 /* Read subsystem parameters from the adapter */
5710 /****************************************************************************/
5712 ips_read_subsystem_parameters(ips_ha_t
* ha
, int intr
)
5717 METHOD_TRACE("ips_read_subsystem_parameters", 1);
5719 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5721 ips_init_scb(ha
, scb
);
5723 scb
->timeout
= ips_cmd_timeout
;
5724 scb
->cdb
[0] = IPS_CMD_GET_SUBSYS
;
5726 scb
->cmd
.basic_io
.op_code
= IPS_CMD_GET_SUBSYS
;
5727 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5728 scb
->cmd
.basic_io
.sg_count
= 0;
5729 scb
->cmd
.basic_io
.lba
= 0;
5730 scb
->cmd
.basic_io
.sector_count
= 0;
5731 scb
->cmd
.basic_io
.log_drv
= 0;
5732 scb
->data_len
= sizeof (*ha
->subsys
);
5733 scb
->cmd
.basic_io
.sg_addr
= ha
->ioctl_busaddr
;
5737 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
5738 || (ret
== IPS_SUCCESS_IMM
)
5739 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
5742 memcpy(ha
->subsys
, ha
->ioctl_data
, sizeof(*ha
->subsys
));
5746 /****************************************************************************/
5748 /* Routine Name: ips_read_config */
5750 /* Routine Description: */
5752 /* Read the configuration on the adapter */
5754 /****************************************************************************/
5756 ips_read_config(ips_ha_t
* ha
, int intr
)
5762 METHOD_TRACE("ips_read_config", 1);
5764 /* set defaults for initiator IDs */
5765 for (i
= 0; i
< 4; i
++)
5766 ha
->conf
->init_id
[i
] = 7;
5768 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5770 ips_init_scb(ha
, scb
);
5772 scb
->timeout
= ips_cmd_timeout
;
5773 scb
->cdb
[0] = IPS_CMD_READ_CONF
;
5775 scb
->cmd
.basic_io
.op_code
= IPS_CMD_READ_CONF
;
5776 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5777 scb
->data_len
= sizeof (*ha
->conf
);
5778 scb
->cmd
.basic_io
.sg_addr
= ha
->ioctl_busaddr
;
5782 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
5783 || (ret
== IPS_SUCCESS_IMM
)
5784 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1)) {
5786 memset(ha
->conf
, 0, sizeof (IPS_CONF
));
5788 /* reset initiator IDs */
5789 for (i
= 0; i
< 4; i
++)
5790 ha
->conf
->init_id
[i
] = 7;
5792 /* Allow Completed with Errors, so JCRM can access the Adapter to fix the problems */
5793 if ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) ==
5794 IPS_CMD_CMPLT_WERROR
)
5800 memcpy(ha
->conf
, ha
->ioctl_data
, sizeof(*ha
->conf
));
5804 /****************************************************************************/
5806 /* Routine Name: ips_readwrite_page5 */
5808 /* Routine Description: */
5810 /* Read nvram page 5 from the adapter */
5812 /****************************************************************************/
5814 ips_readwrite_page5(ips_ha_t
* ha
, int write
, int intr
)
5819 METHOD_TRACE("ips_readwrite_page5", 1);
5821 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5823 ips_init_scb(ha
, scb
);
5825 scb
->timeout
= ips_cmd_timeout
;
5826 scb
->cdb
[0] = IPS_CMD_RW_NVRAM_PAGE
;
5828 scb
->cmd
.nvram
.op_code
= IPS_CMD_RW_NVRAM_PAGE
;
5829 scb
->cmd
.nvram
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5830 scb
->cmd
.nvram
.page
= 5;
5831 scb
->cmd
.nvram
.write
= write
;
5832 scb
->cmd
.nvram
.reserved
= 0;
5833 scb
->cmd
.nvram
.reserved2
= 0;
5834 scb
->data_len
= sizeof (*ha
->nvram
);
5835 scb
->cmd
.nvram
.buffer_addr
= ha
->ioctl_busaddr
;
5837 memcpy(ha
->ioctl_data
, ha
->nvram
, sizeof(*ha
->nvram
));
5839 /* issue the command */
5841 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
5842 || (ret
== IPS_SUCCESS_IMM
)
5843 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1)) {
5845 memset(ha
->nvram
, 0, sizeof (IPS_NVRAM_P5
));
5850 memcpy(ha
->nvram
, ha
->ioctl_data
, sizeof(*ha
->nvram
));
5854 /****************************************************************************/
5856 /* Routine Name: ips_clear_adapter */
5858 /* Routine Description: */
5860 /* Clear the stripe lock tables */
5862 /****************************************************************************/
5864 ips_clear_adapter(ips_ha_t
* ha
, int intr
)
5869 METHOD_TRACE("ips_clear_adapter", 1);
5871 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5873 ips_init_scb(ha
, scb
);
5875 scb
->timeout
= ips_reset_timeout
;
5876 scb
->cdb
[0] = IPS_CMD_CONFIG_SYNC
;
5878 scb
->cmd
.config_sync
.op_code
= IPS_CMD_CONFIG_SYNC
;
5879 scb
->cmd
.config_sync
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5880 scb
->cmd
.config_sync
.channel
= 0;
5881 scb
->cmd
.config_sync
.source_target
= IPS_POCL
;
5882 scb
->cmd
.config_sync
.reserved
= 0;
5883 scb
->cmd
.config_sync
.reserved2
= 0;
5884 scb
->cmd
.config_sync
.reserved3
= 0;
5888 ips_send_wait(ha
, scb
, ips_reset_timeout
, intr
)) == IPS_FAILURE
)
5889 || (ret
== IPS_SUCCESS_IMM
)
5890 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
5893 /* send unlock stripe command */
5894 ips_init_scb(ha
, scb
);
5896 scb
->cdb
[0] = IPS_CMD_ERROR_TABLE
;
5897 scb
->timeout
= ips_reset_timeout
;
5899 scb
->cmd
.unlock_stripe
.op_code
= IPS_CMD_ERROR_TABLE
;
5900 scb
->cmd
.unlock_stripe
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5901 scb
->cmd
.unlock_stripe
.log_drv
= 0;
5902 scb
->cmd
.unlock_stripe
.control
= IPS_CSL
;
5903 scb
->cmd
.unlock_stripe
.reserved
= 0;
5904 scb
->cmd
.unlock_stripe
.reserved2
= 0;
5905 scb
->cmd
.unlock_stripe
.reserved3
= 0;
5909 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
5910 || (ret
== IPS_SUCCESS_IMM
)
5911 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
5917 /****************************************************************************/
5919 /* Routine Name: ips_ffdc_reset */
5921 /* Routine Description: */
5923 /* FFDC: write reset info */
5925 /****************************************************************************/
5927 ips_ffdc_reset(ips_ha_t
* ha
, int intr
)
5931 METHOD_TRACE("ips_ffdc_reset", 1);
5933 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5935 ips_init_scb(ha
, scb
);
5937 scb
->timeout
= ips_cmd_timeout
;
5938 scb
->cdb
[0] = IPS_CMD_FFDC
;
5939 scb
->cmd
.ffdc
.op_code
= IPS_CMD_FFDC
;
5940 scb
->cmd
.ffdc
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5941 scb
->cmd
.ffdc
.reset_count
= ha
->reset_count
;
5942 scb
->cmd
.ffdc
.reset_type
= 0x80;
5944 /* convert time to what the card wants */
5945 ips_fix_ffdc_time(ha
, scb
, ha
->last_ffdc
);
5948 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
);
5951 /****************************************************************************/
5953 /* Routine Name: ips_ffdc_time */
5955 /* Routine Description: */
5957 /* FFDC: write time info */
5959 /****************************************************************************/
5961 ips_ffdc_time(ips_ha_t
* ha
)
5965 METHOD_TRACE("ips_ffdc_time", 1);
5967 DEBUG_VAR(1, "(%s%d) Sending time update.", ips_name
, ha
->host_num
);
5969 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5971 ips_init_scb(ha
, scb
);
5973 scb
->timeout
= ips_cmd_timeout
;
5974 scb
->cdb
[0] = IPS_CMD_FFDC
;
5975 scb
->cmd
.ffdc
.op_code
= IPS_CMD_FFDC
;
5976 scb
->cmd
.ffdc
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5977 scb
->cmd
.ffdc
.reset_count
= 0;
5978 scb
->cmd
.ffdc
.reset_type
= 0;
5980 /* convert time to what the card wants */
5981 ips_fix_ffdc_time(ha
, scb
, ha
->last_ffdc
);
5984 ips_send_wait(ha
, scb
, ips_cmd_timeout
, IPS_FFDC
);
5987 /****************************************************************************/
5989 /* Routine Name: ips_fix_ffdc_time */
5991 /* Routine Description: */
5992 /* Adjust time_t to what the card wants */
5994 /****************************************************************************/
5996 ips_fix_ffdc_time(ips_ha_t
* ha
, ips_scb_t
* scb
, time_t current_time
)
6003 int year_lengths
[2] = { IPS_DAYS_NORMAL_YEAR
, IPS_DAYS_LEAP_YEAR
};
6004 int month_lengths
[12][2] = { {31, 31},
6018 METHOD_TRACE("ips_fix_ffdc_time", 1);
6020 days
= current_time
/ IPS_SECS_DAY
;
6021 rem
= current_time
% IPS_SECS_DAY
;
6023 scb
->cmd
.ffdc
.hour
= (rem
/ IPS_SECS_HOUR
);
6024 rem
= rem
% IPS_SECS_HOUR
;
6025 scb
->cmd
.ffdc
.minute
= (rem
/ IPS_SECS_MIN
);
6026 scb
->cmd
.ffdc
.second
= (rem
% IPS_SECS_MIN
);
6028 year
= IPS_EPOCH_YEAR
;
6029 while (days
< 0 || days
>= year_lengths
[yleap
= IPS_IS_LEAP_YEAR(year
)]) {
6032 newy
= year
+ (days
/ IPS_DAYS_NORMAL_YEAR
);
6035 days
-= (newy
- year
) * IPS_DAYS_NORMAL_YEAR
+
6036 IPS_NUM_LEAP_YEARS_THROUGH(newy
- 1) -
6037 IPS_NUM_LEAP_YEARS_THROUGH(year
- 1);
6041 scb
->cmd
.ffdc
.yearH
= year
/ 100;
6042 scb
->cmd
.ffdc
.yearL
= year
% 100;
6044 for (i
= 0; days
>= month_lengths
[i
][yleap
]; ++i
)
6045 days
-= month_lengths
[i
][yleap
];
6047 scb
->cmd
.ffdc
.month
= i
+ 1;
6048 scb
->cmd
.ffdc
.day
= days
+ 1;
6051 /****************************************************************************
6052 * BIOS Flash Routines *
6053 ****************************************************************************/
6055 /****************************************************************************/
6057 /* Routine Name: ips_erase_bios */
6059 /* Routine Description: */
6060 /* Erase the BIOS on the adapter */
6062 /****************************************************************************/
6064 ips_erase_bios(ips_ha_t
* ha
)
6069 METHOD_TRACE("ips_erase_bios", 1);
6073 /* Clear the status register */
6074 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6075 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6076 udelay(25); /* 25 us */
6078 outb(0x50, ha
->io_addr
+ IPS_REG_FLDP
);
6079 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6080 udelay(25); /* 25 us */
6083 outb(0x20, ha
->io_addr
+ IPS_REG_FLDP
);
6084 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6085 udelay(25); /* 25 us */
6088 outb(0xD0, ha
->io_addr
+ IPS_REG_FLDP
);
6089 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6090 udelay(25); /* 25 us */
6093 outb(0x70, ha
->io_addr
+ IPS_REG_FLDP
);
6094 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6095 udelay(25); /* 25 us */
6097 timeout
= 80000; /* 80 seconds */
6099 while (timeout
> 0) {
6100 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
) {
6101 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6102 udelay(25); /* 25 us */
6105 status
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
6114 /* check for timeout */
6118 /* try to suspend the erase */
6119 outb(0xB0, ha
->io_addr
+ IPS_REG_FLDP
);
6120 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6121 udelay(25); /* 25 us */
6123 /* wait for 10 seconds */
6125 while (timeout
> 0) {
6126 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
) {
6127 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6128 udelay(25); /* 25 us */
6131 status
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
6143 /* check for valid VPP */
6148 /* check for successful flash */
6150 /* sequence error */
6153 /* Otherwise, we were successful */
6155 outb(0x50, ha
->io_addr
+ IPS_REG_FLDP
);
6156 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6157 udelay(25); /* 25 us */
6160 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6161 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6162 udelay(25); /* 25 us */
6167 /****************************************************************************/
6169 /* Routine Name: ips_erase_bios_memio */
6171 /* Routine Description: */
6172 /* Erase the BIOS on the adapter */
6174 /****************************************************************************/
6176 ips_erase_bios_memio(ips_ha_t
* ha
)
6181 METHOD_TRACE("ips_erase_bios_memio", 1);
6185 /* Clear the status register */
6186 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6187 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6188 udelay(25); /* 25 us */
6190 writeb(0x50, ha
->mem_ptr
+ IPS_REG_FLDP
);
6191 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6192 udelay(25); /* 25 us */
6195 writeb(0x20, ha
->mem_ptr
+ IPS_REG_FLDP
);
6196 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6197 udelay(25); /* 25 us */
6200 writeb(0xD0, ha
->mem_ptr
+ IPS_REG_FLDP
);
6201 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6202 udelay(25); /* 25 us */
6205 writeb(0x70, ha
->mem_ptr
+ IPS_REG_FLDP
);
6206 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6207 udelay(25); /* 25 us */
6209 timeout
= 80000; /* 80 seconds */
6211 while (timeout
> 0) {
6212 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
) {
6213 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6214 udelay(25); /* 25 us */
6217 status
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6226 /* check for timeout */
6230 /* try to suspend the erase */
6231 writeb(0xB0, ha
->mem_ptr
+ IPS_REG_FLDP
);
6232 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6233 udelay(25); /* 25 us */
6235 /* wait for 10 seconds */
6237 while (timeout
> 0) {
6238 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
) {
6239 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6240 udelay(25); /* 25 us */
6243 status
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6255 /* check for valid VPP */
6260 /* check for successful flash */
6262 /* sequence error */
6265 /* Otherwise, we were successful */
6267 writeb(0x50, ha
->mem_ptr
+ IPS_REG_FLDP
);
6268 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6269 udelay(25); /* 25 us */
6272 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6273 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6274 udelay(25); /* 25 us */
6279 /****************************************************************************/
6281 /* Routine Name: ips_program_bios */
6283 /* Routine Description: */
6284 /* Program the BIOS on the adapter */
6286 /****************************************************************************/
6288 ips_program_bios(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6295 METHOD_TRACE("ips_program_bios", 1);
6299 for (i
= 0; i
< buffersize
; i
++) {
6301 outl(i
+ offset
, ha
->io_addr
+ IPS_REG_FLAP
);
6302 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6303 udelay(25); /* 25 us */
6305 outb(0x40, ha
->io_addr
+ IPS_REG_FLDP
);
6306 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6307 udelay(25); /* 25 us */
6309 outb(buffer
[i
], ha
->io_addr
+ IPS_REG_FLDP
);
6310 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6311 udelay(25); /* 25 us */
6313 /* wait up to one second */
6315 while (timeout
> 0) {
6316 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
) {
6317 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6318 udelay(25); /* 25 us */
6321 status
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
6332 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6333 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6334 udelay(25); /* 25 us */
6336 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6337 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6338 udelay(25); /* 25 us */
6343 /* check the status */
6344 if (status
& 0x18) {
6345 /* programming error */
6346 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6347 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6348 udelay(25); /* 25 us */
6350 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6351 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6352 udelay(25); /* 25 us */
6358 /* Enable reading */
6359 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6360 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6361 udelay(25); /* 25 us */
6363 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6364 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6365 udelay(25); /* 25 us */
6370 /****************************************************************************/
6372 /* Routine Name: ips_program_bios_memio */
6374 /* Routine Description: */
6375 /* Program the BIOS on the adapter */
6377 /****************************************************************************/
6379 ips_program_bios_memio(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6386 METHOD_TRACE("ips_program_bios_memio", 1);
6390 for (i
= 0; i
< buffersize
; i
++) {
6392 writel(i
+ offset
, ha
->mem_ptr
+ IPS_REG_FLAP
);
6393 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6394 udelay(25); /* 25 us */
6396 writeb(0x40, ha
->mem_ptr
+ IPS_REG_FLDP
);
6397 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6398 udelay(25); /* 25 us */
6400 writeb(buffer
[i
], ha
->mem_ptr
+ IPS_REG_FLDP
);
6401 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6402 udelay(25); /* 25 us */
6404 /* wait up to one second */
6406 while (timeout
> 0) {
6407 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
) {
6408 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6409 udelay(25); /* 25 us */
6412 status
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6423 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6424 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6425 udelay(25); /* 25 us */
6427 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6428 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6429 udelay(25); /* 25 us */
6434 /* check the status */
6435 if (status
& 0x18) {
6436 /* programming error */
6437 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6438 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6439 udelay(25); /* 25 us */
6441 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6442 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6443 udelay(25); /* 25 us */
6449 /* Enable reading */
6450 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6451 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6452 udelay(25); /* 25 us */
6454 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6455 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6456 udelay(25); /* 25 us */
6461 /****************************************************************************/
6463 /* Routine Name: ips_verify_bios */
6465 /* Routine Description: */
6466 /* Verify the BIOS on the adapter */
6468 /****************************************************************************/
6470 ips_verify_bios(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6476 METHOD_TRACE("ips_verify_bios", 1);
6479 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6480 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6481 udelay(25); /* 25 us */
6483 if (inb(ha
->io_addr
+ IPS_REG_FLDP
) != 0x55)
6486 outl(1, ha
->io_addr
+ IPS_REG_FLAP
);
6487 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6488 udelay(25); /* 25 us */
6489 if (inb(ha
->io_addr
+ IPS_REG_FLDP
) != 0xAA)
6493 for (i
= 2; i
< buffersize
; i
++) {
6495 outl(i
+ offset
, ha
->io_addr
+ IPS_REG_FLAP
);
6496 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6497 udelay(25); /* 25 us */
6499 checksum
= (uint8_t) checksum
+ inb(ha
->io_addr
+ IPS_REG_FLDP
);
6510 /****************************************************************************/
6512 /* Routine Name: ips_verify_bios_memio */
6514 /* Routine Description: */
6515 /* Verify the BIOS on the adapter */
6517 /****************************************************************************/
6519 ips_verify_bios_memio(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6525 METHOD_TRACE("ips_verify_bios_memio", 1);
6528 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6529 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6530 udelay(25); /* 25 us */
6532 if (readb(ha
->mem_ptr
+ IPS_REG_FLDP
) != 0x55)
6535 writel(1, ha
->mem_ptr
+ IPS_REG_FLAP
);
6536 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6537 udelay(25); /* 25 us */
6538 if (readb(ha
->mem_ptr
+ IPS_REG_FLDP
) != 0xAA)
6542 for (i
= 2; i
< buffersize
; i
++) {
6544 writel(i
+ offset
, ha
->mem_ptr
+ IPS_REG_FLAP
);
6545 if (ha
->pcidev
->revision
== IPS_REVID_TROMBONE64
)
6546 udelay(25); /* 25 us */
6549 (uint8_t) checksum
+ readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6560 /****************************************************************************/
6562 /* Routine Name: ips_abort_init */
6564 /* Routine Description: */
6565 /* cleanup routine for a failed adapter initialization */
6566 /****************************************************************************/
6568 ips_abort_init(ips_ha_t
* ha
, int index
)
6572 ips_ha
[index
] = NULL
;
6573 ips_sh
[index
] = NULL
;
6577 /****************************************************************************/
6579 /* Routine Name: ips_shift_controllers */
6581 /* Routine Description: */
6582 /* helper function for ordering adapters */
6583 /****************************************************************************/
6585 ips_shift_controllers(int lowindex
, int highindex
)
6587 ips_ha_t
*ha_sav
= ips_ha
[highindex
];
6588 struct Scsi_Host
*sh_sav
= ips_sh
[highindex
];
6591 for (i
= highindex
; i
> lowindex
; i
--) {
6592 ips_ha
[i
] = ips_ha
[i
- 1];
6593 ips_sh
[i
] = ips_sh
[i
- 1];
6594 ips_ha
[i
]->host_num
= i
;
6596 ha_sav
->host_num
= lowindex
;
6597 ips_ha
[lowindex
] = ha_sav
;
6598 ips_sh
[lowindex
] = sh_sav
;
6601 /****************************************************************************/
6603 /* Routine Name: ips_order_controllers */
6605 /* Routine Description: */
6606 /* place controllers is the "proper" boot order */
6607 /****************************************************************************/
6609 ips_order_controllers(void)
6611 int i
, j
, tmp
, position
= 0;
6612 IPS_NVRAM_P5
*nvram
;
6615 nvram
= ips_ha
[0]->nvram
;
6617 if (nvram
->adapter_order
[0]) {
6618 for (i
= 1; i
<= nvram
->adapter_order
[0]; i
++) {
6619 for (j
= position
; j
< ips_num_controllers
; j
++) {
6620 switch (ips_ha
[j
]->ad_type
) {
6621 case IPS_ADTYPE_SERVERAID6M
:
6622 case IPS_ADTYPE_SERVERAID7M
:
6623 if (nvram
->adapter_order
[i
] == 'M') {
6624 ips_shift_controllers(position
,
6629 case IPS_ADTYPE_SERVERAID4L
:
6630 case IPS_ADTYPE_SERVERAID4M
:
6631 case IPS_ADTYPE_SERVERAID4MX
:
6632 case IPS_ADTYPE_SERVERAID4LX
:
6633 if (nvram
->adapter_order
[i
] == 'N') {
6634 ips_shift_controllers(position
,
6639 case IPS_ADTYPE_SERVERAID6I
:
6640 case IPS_ADTYPE_SERVERAID5I2
:
6641 case IPS_ADTYPE_SERVERAID5I1
:
6642 case IPS_ADTYPE_SERVERAID7k
:
6643 if (nvram
->adapter_order
[i
] == 'S') {
6644 ips_shift_controllers(position
,
6649 case IPS_ADTYPE_SERVERAID
:
6650 case IPS_ADTYPE_SERVERAID2
:
6651 case IPS_ADTYPE_NAVAJO
:
6652 case IPS_ADTYPE_KIOWA
:
6653 case IPS_ADTYPE_SERVERAID3L
:
6654 case IPS_ADTYPE_SERVERAID3
:
6655 case IPS_ADTYPE_SERVERAID4H
:
6656 if (nvram
->adapter_order
[i
] == 'A') {
6657 ips_shift_controllers(position
,
6667 /* if adapter_order[0], then ordering is complete */
6670 /* old bios, use older ordering */
6672 for (i
= position
; i
< ips_num_controllers
; i
++) {
6673 if (ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID5I2
||
6674 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID5I1
) {
6675 ips_shift_controllers(position
, i
);
6680 /* if there were no 5I cards, then don't do any extra ordering */
6683 for (i
= position
; i
< ips_num_controllers
; i
++) {
6684 if (ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4L
||
6685 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4M
||
6686 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4LX
||
6687 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4MX
) {
6688 ips_shift_controllers(position
, i
);
6696 /****************************************************************************/
6698 /* Routine Name: ips_register_scsi */
6700 /* Routine Description: */
6701 /* perform any registration and setup with the scsi layer */
6702 /****************************************************************************/
6704 ips_register_scsi(int index
)
6706 struct Scsi_Host
*sh
;
6707 ips_ha_t
*ha
, *oldha
= ips_ha
[index
];
6708 sh
= scsi_host_alloc(&ips_driver_template
, sizeof (ips_ha_t
));
6710 IPS_PRINTK(KERN_WARNING
, oldha
->pcidev
,
6711 "Unable to register controller with SCSI subsystem\n");
6715 memcpy(ha
, oldha
, sizeof (ips_ha_t
));
6716 free_irq(oldha
->pcidev
->irq
, oldha
);
6717 /* Install the interrupt handler with the new ha */
6718 if (request_irq(ha
->pcidev
->irq
, do_ipsintr
, IRQF_SHARED
, ips_name
, ha
)) {
6719 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
6720 "Unable to install interrupt handler\n");
6726 /* Store away needed values for later use */
6727 sh
->unique_id
= (ha
->io_addr
) ? ha
->io_addr
: ha
->mem_addr
;
6728 sh
->sg_tablesize
= sh
->hostt
->sg_tablesize
;
6729 sh
->can_queue
= sh
->hostt
->can_queue
;
6730 sh
->cmd_per_lun
= sh
->hostt
->cmd_per_lun
;
6731 sh
->use_clustering
= sh
->hostt
->use_clustering
;
6732 sh
->max_sectors
= 128;
6734 sh
->max_id
= ha
->ntargets
;
6735 sh
->max_lun
= ha
->nlun
;
6736 sh
->max_channel
= ha
->nbus
- 1;
6737 sh
->can_queue
= ha
->max_cmds
- 1;
6739 if (scsi_add_host(sh
, &ha
->pcidev
->dev
))
6750 free_irq(ha
->pcidev
->irq
, ha
);
6756 /*---------------------------------------------------------------------------*/
6757 /* Routine Name: ips_remove_device */
6759 /* Routine Description: */
6760 /* Remove one Adapter ( Hot Plugging ) */
6761 /*---------------------------------------------------------------------------*/
6763 ips_remove_device(struct pci_dev
*pci_dev
)
6765 struct Scsi_Host
*sh
= pci_get_drvdata(pci_dev
);
6767 pci_set_drvdata(pci_dev
, NULL
);
6771 pci_release_regions(pci_dev
);
6772 pci_disable_device(pci_dev
);
6775 /****************************************************************************/
6777 /* Routine Name: ips_module_init */
6779 /* Routine Description: */
6780 /* function called on module load */
6781 /****************************************************************************/
6783 ips_module_init(void)
6785 #if !defined(__i386__) && !defined(__ia64__) && !defined(__x86_64__)
6786 printk(KERN_ERR
"ips: This driver has only been tested on the x86/ia64/x86_64 platforms\n");
6787 add_taint(TAINT_CPU_OUT_OF_SPEC
, LOCKDEP_STILL_OK
);
6790 if (pci_register_driver(&ips_pci_driver
) < 0)
6792 ips_driver_template
.module
= THIS_MODULE
;
6793 ips_order_controllers();
6794 if (!ips_detect(&ips_driver_template
)) {
6795 pci_unregister_driver(&ips_pci_driver
);
6798 register_reboot_notifier(&ips_notifier
);
6802 /****************************************************************************/
6804 /* Routine Name: ips_module_exit */
6806 /* Routine Description: */
6807 /* function called on module unload */
6808 /****************************************************************************/
6810 ips_module_exit(void)
6812 pci_unregister_driver(&ips_pci_driver
);
6813 unregister_reboot_notifier(&ips_notifier
);
6816 module_init(ips_module_init
);
6817 module_exit(ips_module_exit
);
6819 /*---------------------------------------------------------------------------*/
6820 /* Routine Name: ips_insert_device */
6822 /* Routine Description: */
6823 /* Add One Adapter ( Hot Plug ) */
6826 /* 0 if Successful, else non-zero */
6827 /*---------------------------------------------------------------------------*/
6829 ips_insert_device(struct pci_dev
*pci_dev
, const struct pci_device_id
*ent
)
6834 METHOD_TRACE("ips_insert_device", 1);
6835 rc
= pci_enable_device(pci_dev
);
6839 rc
= pci_request_regions(pci_dev
, "ips");
6843 rc
= ips_init_phase1(pci_dev
, &index
);
6845 rc
= ips_init_phase2(index
);
6848 if (ips_register_scsi(index
)) {
6849 ips_free(ips_ha
[index
]);
6854 ips_num_controllers
++;
6856 ips_next_controller
= ips_num_controllers
;
6860 goto err_out_regions
;
6863 pci_set_drvdata(pci_dev
, ips_sh
[index
]);
6867 pci_release_regions(pci_dev
);
6869 pci_disable_device(pci_dev
);
6873 /*---------------------------------------------------------------------------*/
6874 /* Routine Name: ips_init_phase1 */
6876 /* Routine Description: */
6877 /* Adapter Initialization */
6880 /* 0 if Successful, else non-zero */
6881 /*---------------------------------------------------------------------------*/
6883 ips_init_phase1(struct pci_dev
*pci_dev
, int *indexPtr
)
6894 dma_addr_t dma_address
;
6895 char __iomem
*ioremap_ptr
;
6896 char __iomem
*mem_ptr
;
6899 METHOD_TRACE("ips_init_phase1", 1);
6900 index
= IPS_MAX_ADAPTERS
;
6901 for (j
= 0; j
< IPS_MAX_ADAPTERS
; j
++) {
6902 if (ips_ha
[j
] == NULL
) {
6908 if (index
>= IPS_MAX_ADAPTERS
)
6911 /* stuff that we get in dev */
6912 bus
= pci_dev
->bus
->number
;
6913 func
= pci_dev
->devfn
;
6915 /* Init MEM/IO addresses to 0 */
6921 for (j
= 0; j
< 2; j
++) {
6922 if (!pci_resource_start(pci_dev
, j
))
6925 if (pci_resource_flags(pci_dev
, j
) & IORESOURCE_IO
) {
6926 io_addr
= pci_resource_start(pci_dev
, j
);
6927 io_len
= pci_resource_len(pci_dev
, j
);
6929 mem_addr
= pci_resource_start(pci_dev
, j
);
6930 mem_len
= pci_resource_len(pci_dev
, j
);
6934 /* setup memory mapped area (if applicable) */
6939 base
= mem_addr
& PAGE_MASK
;
6940 offs
= mem_addr
- base
;
6941 ioremap_ptr
= ioremap(base
, PAGE_SIZE
);
6944 mem_ptr
= ioremap_ptr
+ offs
;
6950 /* found a controller */
6951 ha
= kzalloc(sizeof (ips_ha_t
), GFP_KERNEL
);
6953 IPS_PRINTK(KERN_WARNING
, pci_dev
,
6954 "Unable to allocate temporary ha struct\n");
6958 ips_sh
[index
] = NULL
;
6962 /* Store info in HA structure */
6963 ha
->io_addr
= io_addr
;
6964 ha
->io_len
= io_len
;
6965 ha
->mem_addr
= mem_addr
;
6966 ha
->mem_len
= mem_len
;
6967 ha
->mem_ptr
= mem_ptr
;
6968 ha
->ioremap_ptr
= ioremap_ptr
;
6969 ha
->host_num
= (uint32_t) index
;
6970 ha
->slot_num
= PCI_SLOT(pci_dev
->devfn
);
6971 ha
->pcidev
= pci_dev
;
6974 * Set the pci_dev's dma_mask. Not all adapters support 64bit
6975 * addressing so don't enable it if the adapter can't support
6976 * it! Also, don't use 64bit addressing if dma addresses
6977 * are guaranteed to be < 4G.
6979 if (IPS_ENABLE_DMA64
&& IPS_HAS_ENH_SGLIST(ha
) &&
6980 !pci_set_dma_mask(ha
->pcidev
, DMA_BIT_MASK(64))) {
6981 (ha
)->flags
|= IPS_HA_ENH_SG
;
6983 if (pci_set_dma_mask(ha
->pcidev
, DMA_BIT_MASK(32)) != 0) {
6984 printk(KERN_WARNING
"Unable to set DMA Mask\n");
6985 return ips_abort_init(ha
, index
);
6988 if(ips_cd_boot
&& !ips_FlashData
){
6989 ips_FlashData
= pci_alloc_consistent(pci_dev
, PAGE_SIZE
<< 7,
6993 ha
->enq
= pci_alloc_consistent(pci_dev
, sizeof (IPS_ENQ
),
6996 IPS_PRINTK(KERN_WARNING
, pci_dev
,
6997 "Unable to allocate host inquiry structure\n");
6998 return ips_abort_init(ha
, index
);
7001 ha
->adapt
= pci_alloc_consistent(pci_dev
, sizeof (IPS_ADAPTER
) +
7002 sizeof (IPS_IO_CMD
), &dma_address
);
7004 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7005 "Unable to allocate host adapt & dummy structures\n");
7006 return ips_abort_init(ha
, index
);
7008 ha
->adapt
->hw_status_start
= dma_address
;
7009 ha
->dummy
= (void *) (ha
->adapt
+ 1);
7013 ha
->logical_drive_info
= pci_alloc_consistent(pci_dev
, sizeof (IPS_LD_INFO
), &dma_address
);
7014 if (!ha
->logical_drive_info
) {
7015 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7016 "Unable to allocate logical drive info structure\n");
7017 return ips_abort_init(ha
, index
);
7019 ha
->logical_drive_info_dma_addr
= dma_address
;
7022 ha
->conf
= kmalloc(sizeof (IPS_CONF
), GFP_KERNEL
);
7025 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7026 "Unable to allocate host conf structure\n");
7027 return ips_abort_init(ha
, index
);
7030 ha
->nvram
= kmalloc(sizeof (IPS_NVRAM_P5
), GFP_KERNEL
);
7033 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7034 "Unable to allocate host NVRAM structure\n");
7035 return ips_abort_init(ha
, index
);
7038 ha
->subsys
= kmalloc(sizeof (IPS_SUBSYS
), GFP_KERNEL
);
7041 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7042 "Unable to allocate host subsystem structure\n");
7043 return ips_abort_init(ha
, index
);
7046 /* the ioctl buffer is now used during adapter initialization, so its
7047 * successful allocation is now required */
7048 if (ips_ioctlsize
< PAGE_SIZE
)
7049 ips_ioctlsize
= PAGE_SIZE
;
7051 ha
->ioctl_data
= pci_alloc_consistent(pci_dev
, ips_ioctlsize
,
7052 &ha
->ioctl_busaddr
);
7053 ha
->ioctl_len
= ips_ioctlsize
;
7054 if (!ha
->ioctl_data
) {
7055 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7056 "Unable to allocate IOCTL data\n");
7057 return ips_abort_init(ha
, index
);
7063 ips_setup_funclist(ha
);
7065 if ((IPS_IS_MORPHEUS(ha
)) || (IPS_IS_MARCO(ha
))) {
7066 /* If Morpheus appears dead, reset it */
7067 IsDead
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG1
);
7068 if (IsDead
== 0xDEADBEEF) {
7069 ips_reset_morpheus(ha
);
7074 * Initialize the card if it isn't already
7077 if (!(*ha
->func
.isinit
) (ha
)) {
7078 if (!(*ha
->func
.init
) (ha
)) {
7080 * Initialization failed
7082 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7083 "Unable to initialize controller\n");
7084 return ips_abort_init(ha
, index
);
7092 /*---------------------------------------------------------------------------*/
7093 /* Routine Name: ips_init_phase2 */
7095 /* Routine Description: */
7096 /* Adapter Initialization Phase 2 */
7099 /* 0 if Successful, else non-zero */
7100 /*---------------------------------------------------------------------------*/
7102 ips_init_phase2(int index
)
7108 METHOD_TRACE("ips_init_phase2", 1);
7110 ips_ha
[index
] = NULL
;
7114 /* Install the interrupt handler */
7115 if (request_irq(ha
->pcidev
->irq
, do_ipsintr
, IRQF_SHARED
, ips_name
, ha
)) {
7116 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7117 "Unable to install interrupt handler\n");
7118 return ips_abort_init(ha
, index
);
7122 * Allocate a temporary SCB for initialization
7125 if (!ips_allocatescbs(ha
)) {
7126 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7127 "Unable to allocate a CCB\n");
7128 free_irq(ha
->pcidev
->irq
, ha
);
7129 return ips_abort_init(ha
, index
);
7132 if (!ips_hainit(ha
)) {
7133 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7134 "Unable to initialize controller\n");
7135 free_irq(ha
->pcidev
->irq
, ha
);
7136 return ips_abort_init(ha
, index
);
7138 /* Free the temporary SCB */
7139 ips_deallocatescbs(ha
, 1);
7142 if (!ips_allocatescbs(ha
)) {
7143 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7144 "Unable to allocate CCBs\n");
7145 free_irq(ha
->pcidev
->irq
, ha
);
7146 return ips_abort_init(ha
, index
);
7152 MODULE_LICENSE("GPL");
7153 MODULE_DESCRIPTION("IBM ServeRAID Adapter Driver " IPS_VER_STRING
);
7154 MODULE_VERSION(IPS_VER_STRING
);
7158 * Overrides for Emacs so that we almost follow Linus's tabbing style.
7159 * Emacs will notice this stuff at the end of the file and automatically
7160 * adjust the settings for this buffer only. This must remain at the end
7162 * ---------------------------------------------------------------------------
7165 * c-brace-imaginary-offset: 0
7166 * c-brace-offset: -2
7167 * c-argdecl-indent: 2
7168 * c-label-offset: -2
7169 * c-continued-statement-offset: 2
7170 * c-continued-brace-offset: 0
7171 * indent-tabs-mode: nil