1 /*****************************************************************************/
2 /* ips.c -- driver for the Adaptec / IBM ServeRAID controller */
4 /* Written By: Keith Mitchell, IBM Corporation */
5 /* Jack Hammer, Adaptec, Inc. */
6 /* David Jeffery, Adaptec, Inc. */
8 /* Copyright (C) 2000 IBM Corporation */
9 /* Copyright (C) 2002,2003 Adaptec, Inc. */
11 /* This program is free software; you can redistribute it and/or modify */
12 /* it under the terms of the GNU General Public License as published by */
13 /* the Free Software Foundation; either version 2 of the License, or */
14 /* (at your option) any later version. */
16 /* This program is distributed in the hope that it will be useful, */
17 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
18 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
19 /* GNU General Public License for more details. */
22 /* THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR */
23 /* CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT */
24 /* LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, */
25 /* MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is */
26 /* solely responsible for determining the appropriateness of using and */
27 /* distributing the Program and assumes all risks associated with its */
28 /* exercise of rights under this Agreement, including but not limited to */
29 /* the risks and costs of program errors, damage to or loss of data, */
30 /* programs or equipment, and unavailability or interruption of operations. */
32 /* DISCLAIMER OF LIABILITY */
33 /* NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY */
34 /* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL */
35 /* DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND */
36 /* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR */
37 /* TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE */
38 /* USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED */
39 /* HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES */
41 /* You should have received a copy of the GNU General Public License */
42 /* along with this program; if not, write to the Free Software */
43 /* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
45 /* Bugs/Comments/Suggestions about this driver should be mailed to: */
46 /* ipslinux@adaptec.com */
48 /* For system support issues, contact your local IBM Customer support. */
49 /* Directions to find IBM Customer Support for each country can be found at: */
50 /* http://www.ibm.com/planetwide/ */
52 /*****************************************************************************/
54 /*****************************************************************************/
57 /* 0.99.02 - Breakup commands that are bigger than 8 * the stripe size */
58 /* 0.99.03 - Make interrupt routine handle all completed request on the */
59 /* adapter not just the first one */
60 /* - Make sure passthru commands get woken up if we run out of */
62 /* - Send all of the commands on the queue at once rather than */
63 /* one at a time since the card will support it. */
64 /* 0.99.04 - Fix race condition in the passthru mechanism -- this required */
65 /* the interface to the utilities to change */
66 /* - Fix error recovery code */
67 /* 0.99.05 - Fix an oops when we get certain passthru commands */
68 /* 1.00.00 - Initial Public Release */
69 /* Functionally equivalent to 0.99.05 */
70 /* 3.60.00 - Bump max commands to 128 for use with firmware 3.60 */
71 /* - Change version to 3.60 to coincide with release numbering. */
72 /* 3.60.01 - Remove bogus error check in passthru routine */
73 /* 3.60.02 - Make DCDB direction based on lookup table */
74 /* - Only allow one DCDB command to a SCSI ID at a time */
75 /* 4.00.00 - Add support for ServeRAID 4 */
76 /* 4.00.01 - Add support for First Failure Data Capture */
77 /* 4.00.02 - Fix problem with PT DCDB with no buffer */
78 /* 4.00.03 - Add alternative passthru interface */
79 /* - Add ability to flash BIOS */
80 /* 4.00.04 - Rename structures/constants to be prefixed with IPS_ */
81 /* 4.00.05 - Remove wish_block from init routine */
82 /* - Use linux/spinlock.h instead of asm/spinlock.h for kernels */
83 /* 2.3.18 and later */
84 /* - Sync with other changes from the 2.3 kernels */
85 /* 4.00.06 - Fix timeout with initial FFDC command */
86 /* 4.00.06a - Port to 2.4 (trivial) -- Christoph Hellwig <hch@infradead.org> */
87 /* 4.10.00 - Add support for ServeRAID 4M/4L */
88 /* 4.10.13 - Fix for dynamic unload and proc file system */
89 /* 4.20.03 - Rename version to coincide with new release schedules */
90 /* Performance fixes */
91 /* Fix truncation of /proc files with cat */
92 /* Merge in changes through kernel 2.4.0test1ac21 */
93 /* 4.20.13 - Fix some failure cases / reset code */
94 /* - Hook into the reboot_notifier to flush the controller cache */
95 /* 4.50.01 - Fix problem when there is a hole in logical drive numbering */
96 /* 4.70.09 - Use a Common ( Large Buffer ) for Flashing from the JCRM CD */
97 /* - Add IPSSEND Flash Support */
98 /* - Set Sense Data for Unknown SCSI Command */
99 /* - Use Slot Number from NVRAM Page 5 */
100 /* - Restore caller's DCDB Structure */
101 /* 4.70.12 - Corrective actions for bad controller ( during initialization )*/
102 /* 4.70.13 - Don't Send CDB's if we already know the device is not present */
103 /* - Don't release HA Lock in ips_next() until SC taken off queue */
104 /* - Unregister SCSI device in ips_release() */
105 /* 4.70.15 - Fix Breakup for very large ( non-SG ) requests in ips_done() */
106 /* 4.71.00 - Change all memory allocations to not use GFP_DMA flag */
107 /* Code Clean-Up for 2.4.x kernel */
108 /* 4.72.00 - Allow for a Scatter-Gather Element to exceed MAX_XFER Size */
109 /* 4.72.01 - I/O Mapped Memory release ( so "insmod ips" does not Fail ) */
110 /* - Don't Issue Internal FFDC Command if there are Active Commands */
111 /* - Close Window for getting too many IOCTL's active */
112 /* 4.80.00 - Make ia64 Safe */
113 /* 4.80.04 - Eliminate calls to strtok() if 2.4.x or greater */
114 /* - Adjustments to Device Queue Depth */
115 /* 4.80.14 - Take all semaphores off stack */
116 /* - Clean Up New_IOCTL path */
117 /* 4.80.20 - Set max_sectors in Scsi_Host structure ( if >= 2.4.7 kernel ) */
118 /* - 5 second delay needed after resetting an i960 adapter */
119 /* 4.80.26 - Clean up potential code problems ( Arjan's recommendations ) */
120 /* 4.90.01 - Version Matching for FirmWare, BIOS, and Driver */
121 /* 4.90.05 - Use New PCI Architecture to facilitate Hot Plug Development */
122 /* 4.90.08 - Increase Delays in Flashing ( Trombone Only - 4H ) */
123 /* 4.90.08 - Data Corruption if First Scatter Gather Element is > 64K */
124 /* 4.90.11 - Don't actually RESET unless it's physically required */
125 /* - Remove unused compile options */
126 /* 5.00.01 - Sarasota ( 5i ) adapters must always be scanned first */
127 /* - Get rid on IOCTL_NEW_COMMAND code */
128 /* - Add Extended DCDB Commands for Tape Support in 5I */
129 /* 5.10.12 - use pci_dma interfaces, update for 2.5 kernel changes */
130 /* 5.10.15 - remove unused code (sem, macros, etc.) */
131 /* 5.30.00 - use __devexit_p() */
132 /* 6.00.00 - Add 6x Adapters and Battery Flash */
133 /* 6.10.00 - Remove 1G Addressing Limitations */
134 /* 6.11.xx - Get VersionInfo buffer off the stack ! DDTS 60401 */
135 /* 6.11.xx - Make Logical Drive Info structure safe for DMA DDTS 60639 */
136 /* 7.10.18 - Add highmem_io flag in SCSI Templete for 2.4 kernels */
137 /* - Fix path/name for scsi_hosts.h include for 2.6 kernels */
138 /* - Fix sort order of 7k */
139 /* - Remove 3 unused "inline" functions */
140 /* 7.12.xx - Use STATIC functions whereever possible */
141 /* - Clean up deprecated MODULE_PARM calls */
142 /*****************************************************************************/
145 * Conditional Compilation directives for this driver:
147 * IPS_DEBUG - Turn on debugging info
151 * debug:<number> - Set debug level to <number>
152 * NOTE: only works when IPS_DEBUG compile directive is used.
153 * 1 - Normal debug messages
154 * 2 - Verbose debug messages
155 * 11 - Method trace (non interrupt)
156 * 12 - Method trace (includes interrupt)
158 * noi2o - Don't use I2O Queues (ServeRAID 4 only)
159 * nommap - Don't use memory mapped I/O
160 * ioctlsize - Initial size of the IOCTL buffer
164 #include <asm/byteorder.h>
165 #include <asm/page.h>
166 #include <linux/stddef.h>
167 #include <linux/version.h>
168 #include <linux/string.h>
169 #include <linux/errno.h>
170 #include <linux/kernel.h>
171 #include <linux/ioport.h>
172 #include <linux/slab.h>
173 #include <linux/delay.h>
174 #include <linux/pci.h>
175 #include <linux/proc_fs.h>
176 #include <linux/reboot.h>
177 #include <linux/interrupt.h>
179 #include <linux/blkdev.h>
180 #include <linux/types.h>
186 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
189 #include <scsi/scsi_host.h>
194 #include <linux/module.h>
196 #include <linux/stat.h>
197 #include <linux/config.h>
199 #include <linux/spinlock.h>
200 #include <linux/init.h>
202 #include <linux/smp.h>
205 static char *ips
= NULL
;
206 module_param(ips
, charp
, 0);
212 #define IPS_VERSION_HIGH "7.12"
213 #define IPS_VERSION_LOW ".02 "
215 #if !defined(__i386__) && !defined(__ia64__) && !defined(__x86_64__)
216 #warning "This driver has only been tested on the x86/ia64/x86_64 platforms"
219 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
220 #include <linux/blk.h>
222 #define IPS_LOCK_SAVE(lock,flags) spin_lock_irqsave(&io_request_lock,flags)
223 #define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock_irqrestore(&io_request_lock,flags)
225 #define __devexit_p(x) x
228 #define IPS_LOCK_SAVE(lock,flags) do{spin_lock(lock);(void)flags;}while(0)
229 #define IPS_UNLOCK_RESTORE(lock,flags) do{spin_unlock(lock);(void)flags;}while(0)
232 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
233 DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
234 PCI_DMA_BIDIRECTIONAL : \
235 scb->scsi_cmd->sc_data_direction)
238 #define METHOD_TRACE(s, i) if (ips_debug >= (i+10)) printk(KERN_NOTICE s "\n");
239 #define DEBUG(i, s) if (ips_debug >= i) printk(KERN_NOTICE s "\n");
240 #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "\n", v);
242 #define METHOD_TRACE(s, i)
244 #define DEBUG_VAR(i, s, v...)
248 * Function prototypes
250 static int ips_detect(Scsi_Host_Template
*);
251 static int ips_release(struct Scsi_Host
*);
252 static int ips_eh_abort(Scsi_Cmnd
*);
253 static int ips_eh_reset(Scsi_Cmnd
*);
254 static int ips_queue(Scsi_Cmnd
*, void (*)(Scsi_Cmnd
*));
255 static const char *ips_info(struct Scsi_Host
*);
256 static irqreturn_t
do_ipsintr(int, void *, struct pt_regs
*);
257 static int ips_hainit(ips_ha_t
*);
258 static int ips_map_status(ips_ha_t
*, ips_scb_t
*, ips_stat_t
*);
259 static int ips_send_wait(ips_ha_t
*, ips_scb_t
*, int, int);
260 static int ips_send_cmd(ips_ha_t
*, ips_scb_t
*);
261 static int ips_online(ips_ha_t
*, ips_scb_t
*);
262 static int ips_inquiry(ips_ha_t
*, ips_scb_t
*);
263 static int ips_rdcap(ips_ha_t
*, ips_scb_t
*);
264 static int ips_msense(ips_ha_t
*, ips_scb_t
*);
265 static int ips_reqsen(ips_ha_t
*, ips_scb_t
*);
266 static int ips_deallocatescbs(ips_ha_t
*, int);
267 static int ips_allocatescbs(ips_ha_t
*);
268 static int ips_reset_copperhead(ips_ha_t
*);
269 static int ips_reset_copperhead_memio(ips_ha_t
*);
270 static int ips_reset_morpheus(ips_ha_t
*);
271 static int ips_issue_copperhead(ips_ha_t
*, ips_scb_t
*);
272 static int ips_issue_copperhead_memio(ips_ha_t
*, ips_scb_t
*);
273 static int ips_issue_i2o(ips_ha_t
*, ips_scb_t
*);
274 static int ips_issue_i2o_memio(ips_ha_t
*, ips_scb_t
*);
275 static int ips_isintr_copperhead(ips_ha_t
*);
276 static int ips_isintr_copperhead_memio(ips_ha_t
*);
277 static int ips_isintr_morpheus(ips_ha_t
*);
278 static int ips_wait(ips_ha_t
*, int, int);
279 static int ips_write_driver_status(ips_ha_t
*, int);
280 static int ips_read_adapter_status(ips_ha_t
*, int);
281 static int ips_read_subsystem_parameters(ips_ha_t
*, int);
282 static int ips_read_config(ips_ha_t
*, int);
283 static int ips_clear_adapter(ips_ha_t
*, int);
284 static int ips_readwrite_page5(ips_ha_t
*, int, int);
285 static int ips_init_copperhead(ips_ha_t
*);
286 static int ips_init_copperhead_memio(ips_ha_t
*);
287 static int ips_init_morpheus(ips_ha_t
*);
288 static int ips_isinit_copperhead(ips_ha_t
*);
289 static int ips_isinit_copperhead_memio(ips_ha_t
*);
290 static int ips_isinit_morpheus(ips_ha_t
*);
291 static int ips_erase_bios(ips_ha_t
*);
292 static int ips_program_bios(ips_ha_t
*, char *, uint32_t, uint32_t);
293 static int ips_verify_bios(ips_ha_t
*, char *, uint32_t, uint32_t);
294 static int ips_erase_bios_memio(ips_ha_t
*);
295 static int ips_program_bios_memio(ips_ha_t
*, char *, uint32_t, uint32_t);
296 static int ips_verify_bios_memio(ips_ha_t
*, char *, uint32_t, uint32_t);
297 static int ips_flash_copperhead(ips_ha_t
*, ips_passthru_t
*, ips_scb_t
*);
298 static int ips_flash_bios(ips_ha_t
*, ips_passthru_t
*, ips_scb_t
*);
299 static int ips_flash_firmware(ips_ha_t
*, ips_passthru_t
*, ips_scb_t
*);
300 static void ips_free_flash_copperhead(ips_ha_t
* ha
);
301 static void ips_get_bios_version(ips_ha_t
*, int);
302 static void ips_identify_controller(ips_ha_t
*);
303 static void ips_chkstatus(ips_ha_t
*, IPS_STATUS
*);
304 static void ips_enable_int_copperhead(ips_ha_t
*);
305 static void ips_enable_int_copperhead_memio(ips_ha_t
*);
306 static void ips_enable_int_morpheus(ips_ha_t
*);
307 static int ips_intr_copperhead(ips_ha_t
*);
308 static int ips_intr_morpheus(ips_ha_t
*);
309 static void ips_next(ips_ha_t
*, int);
310 static void ipsintr_blocking(ips_ha_t
*, struct ips_scb
*);
311 static void ipsintr_done(ips_ha_t
*, struct ips_scb
*);
312 static void ips_done(ips_ha_t
*, ips_scb_t
*);
313 static void ips_free(ips_ha_t
*);
314 static void ips_init_scb(ips_ha_t
*, ips_scb_t
*);
315 static void ips_freescb(ips_ha_t
*, ips_scb_t
*);
316 static void ips_setup_funclist(ips_ha_t
*);
317 static void ips_statinit(ips_ha_t
*);
318 static void ips_statinit_memio(ips_ha_t
*);
319 static void ips_fix_ffdc_time(ips_ha_t
*, ips_scb_t
*, time_t);
320 static void ips_ffdc_reset(ips_ha_t
*, int);
321 static void ips_ffdc_time(ips_ha_t
*);
322 static uint32_t ips_statupd_copperhead(ips_ha_t
*);
323 static uint32_t ips_statupd_copperhead_memio(ips_ha_t
*);
324 static uint32_t ips_statupd_morpheus(ips_ha_t
*);
325 static ips_scb_t
*ips_getscb(ips_ha_t
*);
326 static void ips_putq_scb_head(ips_scb_queue_t
*, ips_scb_t
*);
327 static void ips_putq_wait_tail(ips_wait_queue_t
*, Scsi_Cmnd
*);
328 static void ips_putq_copp_tail(ips_copp_queue_t
*,
329 ips_copp_wait_item_t
*);
330 static ips_scb_t
*ips_removeq_scb_head(ips_scb_queue_t
*);
331 static ips_scb_t
*ips_removeq_scb(ips_scb_queue_t
*, ips_scb_t
*);
332 static Scsi_Cmnd
*ips_removeq_wait_head(ips_wait_queue_t
*);
333 static Scsi_Cmnd
*ips_removeq_wait(ips_wait_queue_t
*, Scsi_Cmnd
*);
334 static ips_copp_wait_item_t
*ips_removeq_copp(ips_copp_queue_t
*,
335 ips_copp_wait_item_t
*);
336 static ips_copp_wait_item_t
*ips_removeq_copp_head(ips_copp_queue_t
*);
338 static int ips_is_passthru(Scsi_Cmnd
*);
339 static int ips_make_passthru(ips_ha_t
*, Scsi_Cmnd
*, ips_scb_t
*, int);
340 static int ips_usrcmd(ips_ha_t
*, ips_passthru_t
*, ips_scb_t
*);
341 static void ips_cleanup_passthru(ips_ha_t
*, ips_scb_t
*);
342 static void ips_scmd_buf_write(Scsi_Cmnd
* scmd
, void *data
,
344 static void ips_scmd_buf_read(Scsi_Cmnd
* scmd
, void *data
, unsigned int count
);
346 static int ips_proc_info(struct Scsi_Host
*, char *, char **, off_t
, int, int);
347 static int ips_host_info(ips_ha_t
*, char *, off_t
, int);
348 static void copy_mem_info(IPS_INFOSTR
*, char *, int);
349 static int copy_info(IPS_INFOSTR
*, char *, ...);
350 static int ips_get_version_info(ips_ha_t
* ha
, dma_addr_t
, int intr
);
351 static void ips_version_check(ips_ha_t
* ha
, int intr
);
352 static int ips_abort_init(ips_ha_t
* ha
, int index
);
353 static int ips_init_phase2(int index
);
355 static int ips_init_phase1(struct pci_dev
*pci_dev
, int *indexPtr
);
356 static int ips_register_scsi(int index
);
358 static int ips_poll_for_flush_complete(ips_ha_t
* ha
);
359 static void ips_flush_and_reset(ips_ha_t
*ha
);
364 static const char ips_name
[] = "ips";
365 static struct Scsi_Host
*ips_sh
[IPS_MAX_ADAPTERS
]; /* Array of host controller structures */
366 static ips_ha_t
*ips_ha
[IPS_MAX_ADAPTERS
]; /* Array of HA structures */
367 static unsigned int ips_next_controller
;
368 static unsigned int ips_num_controllers
;
369 static unsigned int ips_released_controllers
;
370 static int ips_hotplug
;
371 static int ips_cmd_timeout
= 60;
372 static int ips_reset_timeout
= 60 * 5;
373 static int ips_force_memio
= 1; /* Always use Memory Mapped I/O */
374 static int ips_force_i2o
= 1; /* Always use I2O command delivery */
375 static int ips_ioctlsize
= IPS_IOCTL_SIZE
; /* Size of the ioctl buffer */
376 static int ips_cd_boot
; /* Booting from Manager CD */
377 static char *ips_FlashData
= NULL
; /* CD Boot - Flash Data Buffer */
378 static dma_addr_t ips_flashbusaddr
;
379 static long ips_FlashDataInUse
; /* CD Boot - Flash Data In Use Flag */
380 static uint32_t MaxLiteCmds
= 32; /* Max Active Cmds for a Lite Adapter */
381 static Scsi_Host_Template ips_driver_template
= {
382 .detect
= ips_detect
,
383 .release
= ips_release
,
385 .queuecommand
= ips_queue
,
386 .eh_abort_handler
= ips_eh_abort
,
387 .eh_host_reset_handler
= ips_eh_reset
,
389 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
390 .proc_info
= ips_proc_info
,
391 .slave_configure
= ips_slave_configure
,
393 .proc_info
= ips_proc24_info
,
394 .select_queue_depths
= ips_select_queue_depth
,
396 .bios_param
= ips_biosparam
,
398 .sg_tablesize
= IPS_MAX_SG
,
400 .use_clustering
= ENABLE_CLUSTERING
,
401 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
402 .use_new_eh_code
= 1,
404 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20) && LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
409 static IPS_DEFINE_COMPAT_TABLE( Compatable
); /* Version Compatability Table */
412 /* This table describes all ServeRAID Adapters */
413 static struct pci_device_id ips_pci_table
[] = {
414 { 0x1014, 0x002E, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0 },
415 { 0x1014, 0x01BD, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0 },
416 { 0x9005, 0x0250, PCI_ANY_ID
, PCI_ANY_ID
, 0, 0 },
420 MODULE_DEVICE_TABLE( pci
, ips_pci_table
);
422 static char ips_hot_plug_name
[] = "ips";
424 static int __devinit
ips_insert_device(struct pci_dev
*pci_dev
, const struct pci_device_id
*ent
);
425 static void __devexit
ips_remove_device(struct pci_dev
*pci_dev
);
427 static struct pci_driver ips_pci_driver
= {
428 .name
= ips_hot_plug_name
,
429 .id_table
= ips_pci_table
,
430 .probe
= ips_insert_device
,
431 .remove
= __devexit_p(ips_remove_device
),
436 * Necessary forward function protoypes
438 static int ips_halt(struct notifier_block
*nb
, ulong event
, void *buf
);
440 #define MAX_ADAPTER_NAME 15
442 static char ips_adapter_name
[][30] = {
445 "ServeRAID on motherboard",
446 "ServeRAID on motherboard",
463 static struct notifier_block ips_notifier
= {
470 static char ips_command_direction
[] = {
471 IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_IN
, IPS_DATA_IN
, IPS_DATA_OUT
,
472 IPS_DATA_IN
, IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_UNK
,
473 IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
474 IPS_DATA_IN
, IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_IN
, IPS_DATA_OUT
,
475 IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_OUT
,
476 IPS_DATA_NONE
, IPS_DATA_IN
, IPS_DATA_NONE
, IPS_DATA_IN
, IPS_DATA_OUT
,
477 IPS_DATA_NONE
, IPS_DATA_UNK
, IPS_DATA_IN
, IPS_DATA_UNK
, IPS_DATA_IN
,
478 IPS_DATA_UNK
, IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_UNK
, IPS_DATA_UNK
,
479 IPS_DATA_IN
, IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_NONE
, IPS_DATA_UNK
,
480 IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
,
481 IPS_DATA_OUT
, IPS_DATA_NONE
, IPS_DATA_IN
, IPS_DATA_NONE
, IPS_DATA_NONE
,
482 IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
,
483 IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_OUT
,
484 IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_IN
, IPS_DATA_IN
, IPS_DATA_NONE
,
485 IPS_DATA_UNK
, IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_UNK
,
486 IPS_DATA_NONE
, IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_UNK
, IPS_DATA_UNK
,
487 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
488 IPS_DATA_OUT
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
489 IPS_DATA_IN
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
490 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
491 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
492 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
493 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
494 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
495 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
496 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
497 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
498 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
499 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
500 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
501 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
502 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
503 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
504 IPS_DATA_NONE
, IPS_DATA_NONE
, IPS_DATA_UNK
, IPS_DATA_IN
, IPS_DATA_NONE
,
505 IPS_DATA_OUT
, IPS_DATA_UNK
, IPS_DATA_NONE
, IPS_DATA_UNK
, IPS_DATA_OUT
,
506 IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_OUT
, IPS_DATA_NONE
,
507 IPS_DATA_UNK
, IPS_DATA_IN
, IPS_DATA_OUT
, IPS_DATA_IN
, IPS_DATA_IN
,
508 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
509 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
510 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
511 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
512 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
513 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
514 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
515 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
516 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
517 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_OUT
,
518 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
519 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
520 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
,
521 IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
, IPS_DATA_UNK
525 /****************************************************************************/
527 /* Routine Name: ips_setup */
529 /* Routine Description: */
531 /* setup parameters to the driver */
533 /****************************************************************************/
535 ips_setup(char *ips_str
)
541 IPS_OPTION options
[] = {
542 {"noi2o", &ips_force_i2o
, 0},
543 {"nommap", &ips_force_memio
, 0},
544 {"ioctlsize", &ips_ioctlsize
, IPS_IOCTL_SIZE
},
545 {"cdboot", &ips_cd_boot
, 0},
546 {"maxcmds", &MaxLiteCmds
, 32},
549 /* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
550 /* Search for value */
551 while ((key
= strsep(&ips_str
, ",."))) {
554 value
= strchr(key
, ':');
558 * We now have key/value pairs.
559 * Update the variables
561 for (i
= 0; i
< (sizeof (options
) / sizeof (options
[0])); i
++) {
563 (key
, options
[i
].option_name
,
564 strlen(options
[i
].option_name
)) == 0) {
566 *options
[i
].option_flag
=
567 simple_strtoul(value
, NULL
, 0);
569 *options
[i
].option_flag
=
570 options
[i
].option_value
;
579 __setup("ips=", ips_setup
);
581 /****************************************************************************/
583 /* Routine Name: ips_detect */
585 /* Routine Description: */
587 /* Detect and initialize the driver */
589 /* NOTE: this routine is called under the io_request_lock spinlock */
591 /****************************************************************************/
593 ips_detect(Scsi_Host_Template
* SHT
)
597 METHOD_TRACE("ips_detect", 1);
604 for (i
= 0; i
< ips_num_controllers
; i
++) {
605 if (ips_register_scsi(i
))
607 ips_released_controllers
++;
610 return (ips_num_controllers
);
613 /****************************************************************************/
614 /* configure the function pointers to use the functions that will work */
615 /* with the found version of the adapter */
616 /****************************************************************************/
618 ips_setup_funclist(ips_ha_t
* ha
)
624 if (IPS_IS_MORPHEUS(ha
) || IPS_IS_MARCO(ha
)) {
625 /* morpheus / marco / sebring */
626 ha
->func
.isintr
= ips_isintr_morpheus
;
627 ha
->func
.isinit
= ips_isinit_morpheus
;
628 ha
->func
.issue
= ips_issue_i2o_memio
;
629 ha
->func
.init
= ips_init_morpheus
;
630 ha
->func
.statupd
= ips_statupd_morpheus
;
631 ha
->func
.reset
= ips_reset_morpheus
;
632 ha
->func
.intr
= ips_intr_morpheus
;
633 ha
->func
.enableint
= ips_enable_int_morpheus
;
634 } else if (IPS_USE_MEMIO(ha
)) {
635 /* copperhead w/MEMIO */
636 ha
->func
.isintr
= ips_isintr_copperhead_memio
;
637 ha
->func
.isinit
= ips_isinit_copperhead_memio
;
638 ha
->func
.init
= ips_init_copperhead_memio
;
639 ha
->func
.statupd
= ips_statupd_copperhead_memio
;
640 ha
->func
.statinit
= ips_statinit_memio
;
641 ha
->func
.reset
= ips_reset_copperhead_memio
;
642 ha
->func
.intr
= ips_intr_copperhead
;
643 ha
->func
.erasebios
= ips_erase_bios_memio
;
644 ha
->func
.programbios
= ips_program_bios_memio
;
645 ha
->func
.verifybios
= ips_verify_bios_memio
;
646 ha
->func
.enableint
= ips_enable_int_copperhead_memio
;
647 if (IPS_USE_I2O_DELIVER(ha
))
648 ha
->func
.issue
= ips_issue_i2o_memio
;
650 ha
->func
.issue
= ips_issue_copperhead_memio
;
653 ha
->func
.isintr
= ips_isintr_copperhead
;
654 ha
->func
.isinit
= ips_isinit_copperhead
;
655 ha
->func
.init
= ips_init_copperhead
;
656 ha
->func
.statupd
= ips_statupd_copperhead
;
657 ha
->func
.statinit
= ips_statinit
;
658 ha
->func
.reset
= ips_reset_copperhead
;
659 ha
->func
.intr
= ips_intr_copperhead
;
660 ha
->func
.erasebios
= ips_erase_bios
;
661 ha
->func
.programbios
= ips_program_bios
;
662 ha
->func
.verifybios
= ips_verify_bios
;
663 ha
->func
.enableint
= ips_enable_int_copperhead
;
665 if (IPS_USE_I2O_DELIVER(ha
))
666 ha
->func
.issue
= ips_issue_i2o
;
668 ha
->func
.issue
= ips_issue_copperhead
;
672 /****************************************************************************/
674 /* Routine Name: ips_release */
676 /* Routine Description: */
678 /* Remove a driver */
680 /****************************************************************************/
682 ips_release(struct Scsi_Host
*sh
)
688 METHOD_TRACE("ips_release", 1);
690 for (i
= 0; i
< IPS_MAX_ADAPTERS
&& ips_sh
[i
] != sh
; i
++) ;
692 if (i
== IPS_MAX_ADAPTERS
) {
694 "(%s) release, invalid Scsi_Host pointer.\n", ips_name
);
704 /* flush the cache on the controller */
705 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
707 ips_init_scb(ha
, scb
);
709 scb
->timeout
= ips_cmd_timeout
;
710 scb
->cdb
[0] = IPS_CMD_FLUSH
;
712 scb
->cmd
.flush_cache
.op_code
= IPS_CMD_FLUSH
;
713 scb
->cmd
.flush_cache
.command_id
= IPS_COMMAND_ID(ha
, scb
);
714 scb
->cmd
.flush_cache
.state
= IPS_NORM_STATE
;
715 scb
->cmd
.flush_cache
.reserved
= 0;
716 scb
->cmd
.flush_cache
.reserved2
= 0;
717 scb
->cmd
.flush_cache
.reserved3
= 0;
718 scb
->cmd
.flush_cache
.reserved4
= 0;
720 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
, "Flushing Cache.\n");
723 if (ips_send_wait(ha
, scb
, ips_cmd_timeout
, IPS_INTR_ON
) == IPS_FAILURE
)
724 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
, "Incomplete Flush.\n");
726 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
, "Flushing Complete.\n");
731 /* free extra memory */
734 /* Free I/O Region */
736 release_region(ha
->io_addr
, ha
->io_len
);
739 free_irq(ha
->irq
, ha
);
744 ips_released_controllers
++;
749 /****************************************************************************/
751 /* Routine Name: ips_halt */
753 /* Routine Description: */
755 /* Perform cleanup when the system reboots */
757 /****************************************************************************/
759 ips_halt(struct notifier_block
*nb
, ulong event
, void *buf
)
765 if ((event
!= SYS_RESTART
) && (event
!= SYS_HALT
) &&
766 (event
!= SYS_POWER_OFF
))
767 return (NOTIFY_DONE
);
769 for (i
= 0; i
< ips_next_controller
; i
++) {
770 ha
= (ips_ha_t
*) ips_ha
[i
];
778 /* flush the cache on the controller */
779 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
781 ips_init_scb(ha
, scb
);
783 scb
->timeout
= ips_cmd_timeout
;
784 scb
->cdb
[0] = IPS_CMD_FLUSH
;
786 scb
->cmd
.flush_cache
.op_code
= IPS_CMD_FLUSH
;
787 scb
->cmd
.flush_cache
.command_id
= IPS_COMMAND_ID(ha
, scb
);
788 scb
->cmd
.flush_cache
.state
= IPS_NORM_STATE
;
789 scb
->cmd
.flush_cache
.reserved
= 0;
790 scb
->cmd
.flush_cache
.reserved2
= 0;
791 scb
->cmd
.flush_cache
.reserved3
= 0;
792 scb
->cmd
.flush_cache
.reserved4
= 0;
794 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
, "Flushing Cache.\n");
797 if (ips_send_wait(ha
, scb
, ips_cmd_timeout
, IPS_INTR_ON
) ==
799 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
800 "Incomplete Flush.\n");
802 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
803 "Flushing Complete.\n");
809 /****************************************************************************/
811 /* Routine Name: ips_eh_abort */
813 /* Routine Description: */
815 /* Abort a command (using the new error code stuff) */
816 /* Note: this routine is called under the io_request_lock */
817 /****************************************************************************/
819 ips_eh_abort(Scsi_Cmnd
* SC
)
822 ips_copp_wait_item_t
*item
;
824 unsigned long cpu_flags
;
825 struct Scsi_Host
*host
;
827 METHOD_TRACE("ips_eh_abort", 1);
832 host
= SC
->device
->host
;
833 ha
= (ips_ha_t
*) SC
->device
->host
->hostdata
;
841 IPS_LOCK_SAVE(host
->host_lock
, cpu_flags
);
843 /* See if the command is on the copp queue */
844 item
= ha
->copp_waitlist
.head
;
845 while ((item
) && (item
->scsi_cmd
!= SC
))
850 ips_removeq_copp(&ha
->copp_waitlist
, item
);
853 /* See if the command is on the wait queue */
854 } else if (ips_removeq_wait(&ha
->scb_waitlist
, SC
)) {
855 /* command not sent yet */
858 /* command must have already been sent */
862 IPS_UNLOCK_RESTORE(host
->host_lock
, cpu_flags
);
866 /****************************************************************************/
868 /* Routine Name: ips_eh_reset */
870 /* Routine Description: */
872 /* Reset the controller (with new eh error code) */
874 /* NOTE: this routine is called under the io_request_lock spinlock */
876 /****************************************************************************/
878 __ips_eh_reset(Scsi_Cmnd
* SC
)
884 ips_copp_wait_item_t
*item
;
886 METHOD_TRACE("ips_eh_reset", 1);
893 DEBUG(1, "Reset called with NULL scsi command");
898 ha
= (ips_ha_t
*) SC
->device
->host
->hostdata
;
901 DEBUG(1, "Reset called with NULL ha struct");
909 /* See if the command is on the copp queue */
910 item
= ha
->copp_waitlist
.head
;
911 while ((item
) && (item
->scsi_cmd
!= SC
))
916 ips_removeq_copp(&ha
->copp_waitlist
, item
);
920 /* See if the command is on the wait queue */
921 if (ips_removeq_wait(&ha
->scb_waitlist
, SC
)) {
922 /* command not sent yet */
926 /* An explanation for the casual observer: */
927 /* Part of the function of a RAID controller is automatic error */
928 /* detection and recovery. As such, the only problem that physically */
929 /* resetting an adapter will ever fix is when, for some reason, */
930 /* the driver is not successfully communicating with the adapter. */
931 /* Therefore, we will attempt to flush this adapter. If that succeeds, */
932 /* then there's no real purpose in a physical reset. This will complete */
933 /* much faster and avoids any problems that might be caused by a */
934 /* physical reset ( such as having to fail all the outstanding I/O's ). */
936 if (ha
->ioctl_reset
== 0) { /* IF Not an IOCTL Requested Reset */
937 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
939 ips_init_scb(ha
, scb
);
941 scb
->timeout
= ips_cmd_timeout
;
942 scb
->cdb
[0] = IPS_CMD_FLUSH
;
944 scb
->cmd
.flush_cache
.op_code
= IPS_CMD_FLUSH
;
945 scb
->cmd
.flush_cache
.command_id
= IPS_COMMAND_ID(ha
, scb
);
946 scb
->cmd
.flush_cache
.state
= IPS_NORM_STATE
;
947 scb
->cmd
.flush_cache
.reserved
= 0;
948 scb
->cmd
.flush_cache
.reserved2
= 0;
949 scb
->cmd
.flush_cache
.reserved3
= 0;
950 scb
->cmd
.flush_cache
.reserved4
= 0;
952 /* Attempt the flush command */
953 ret
= ips_send_wait(ha
, scb
, ips_cmd_timeout
, IPS_INTR_IORL
);
954 if (ret
== IPS_SUCCESS
) {
955 IPS_PRINTK(KERN_NOTICE
, ha
->pcidev
,
956 "Reset Request - Flushed Cache\n");
961 /* Either we can't communicate with the adapter or it's an IOCTL request */
962 /* from a utility. A physical reset is needed at this point. */
964 ha
->ioctl_reset
= 0; /* Reset the IOCTL Requested Reset Flag */
967 * command must have already been sent
968 * reset the controller
970 IPS_PRINTK(KERN_NOTICE
, ha
->pcidev
, "Resetting controller.\n");
971 ret
= (*ha
->func
.reset
) (ha
);
976 IPS_PRINTK(KERN_NOTICE
, ha
->pcidev
,
977 "Controller reset failed - controller now offline.\n");
979 /* Now fail all of the active commands */
980 DEBUG_VAR(1, "(%s%d) Failing active commands",
981 ips_name
, ha
->host_num
);
983 while ((scb
= ips_removeq_scb_head(&ha
->scb_activelist
))) {
984 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
985 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
986 ips_freescb(ha
, scb
);
989 /* Now fail all of the pending commands */
990 DEBUG_VAR(1, "(%s%d) Failing pending commands",
991 ips_name
, ha
->host_num
);
993 while ((scsi_cmd
= ips_removeq_wait_head(&ha
->scb_waitlist
))) {
994 scsi_cmd
->result
= DID_ERROR
;
995 scsi_cmd
->scsi_done(scsi_cmd
);
1002 if (!ips_clear_adapter(ha
, IPS_INTR_IORL
)) {
1003 Scsi_Cmnd
*scsi_cmd
;
1005 IPS_PRINTK(KERN_NOTICE
, ha
->pcidev
,
1006 "Controller reset failed - controller now offline.\n");
1008 /* Now fail all of the active commands */
1009 DEBUG_VAR(1, "(%s%d) Failing active commands",
1010 ips_name
, ha
->host_num
);
1012 while ((scb
= ips_removeq_scb_head(&ha
->scb_activelist
))) {
1013 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
1014 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
1015 ips_freescb(ha
, scb
);
1018 /* Now fail all of the pending commands */
1019 DEBUG_VAR(1, "(%s%d) Failing pending commands",
1020 ips_name
, ha
->host_num
);
1022 while ((scsi_cmd
= ips_removeq_wait_head(&ha
->scb_waitlist
))) {
1023 scsi_cmd
->result
= DID_ERROR
<< 16;
1024 scsi_cmd
->scsi_done(scsi_cmd
);
1032 if (le32_to_cpu(ha
->subsys
->param
[3]) & 0x300000) {
1035 do_gettimeofday(&tv
);
1036 ha
->last_ffdc
= tv
.tv_sec
;
1038 ips_ffdc_reset(ha
, IPS_INTR_IORL
);
1041 /* Now fail all of the active commands */
1042 DEBUG_VAR(1, "(%s%d) Failing active commands", ips_name
, ha
->host_num
);
1044 while ((scb
= ips_removeq_scb_head(&ha
->scb_activelist
))) {
1045 scb
->scsi_cmd
->result
=
1046 (DID_RESET
<< 16) | (SUGGEST_RETRY
<< 24);
1047 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
1048 ips_freescb(ha
, scb
);
1051 /* Reset DCDB active command bits */
1052 for (i
= 1; i
< ha
->nbus
; i
++)
1053 ha
->dcdb_active
[i
- 1] = 0;
1055 /* Reset the number of active IOCTLs */
1058 ips_next(ha
, IPS_INTR_IORL
);
1061 #endif /* NO_IPS_RESET */
1066 ips_eh_reset(Scsi_Cmnd
* SC
)
1070 spin_lock_irq(SC
->device
->host
->host_lock
);
1071 rc
= __ips_eh_reset(SC
);
1072 spin_unlock_irq(SC
->device
->host
->host_lock
);
1077 /****************************************************************************/
1079 /* Routine Name: ips_queue */
1081 /* Routine Description: */
1083 /* Send a command to the controller */
1086 /* Linux obtains io_request_lock before calling this function */
1088 /****************************************************************************/
1090 ips_queue(Scsi_Cmnd
* SC
, void (*done
) (Scsi_Cmnd
*))
1095 METHOD_TRACE("ips_queue", 1);
1097 ha
= (ips_ha_t
*) SC
->device
->host
->hostdata
;
1105 if (ips_is_passthru(SC
)) {
1106 if (ha
->copp_waitlist
.count
== IPS_MAX_IOCTL_QUEUE
) {
1107 SC
->result
= DID_BUS_BUSY
<< 16;
1112 } else if (ha
->scb_waitlist
.count
== IPS_MAX_QUEUE
) {
1113 SC
->result
= DID_BUS_BUSY
<< 16;
1119 SC
->scsi_done
= done
;
1121 DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
1125 SC
->device
->channel
, SC
->device
->id
, SC
->device
->lun
);
1127 /* Check for command to initiator IDs */
1128 if ((scmd_channel(SC
) > 0)
1129 && (scmd_id(SC
) == ha
->ha_id
[scmd_channel(SC
)])) {
1130 SC
->result
= DID_NO_CONNECT
<< 16;
1136 if (ips_is_passthru(SC
)) {
1138 ips_copp_wait_item_t
*scratch
;
1140 /* A Reset IOCTL is only sent by the boot CD in extreme cases. */
1141 /* There can never be any system activity ( network or disk ), but check */
1142 /* anyway just as a good practice. */
1143 pt
= (ips_passthru_t
*) SC
->request_buffer
;
1144 if ((pt
->CoppCP
.cmd
.reset
.op_code
== IPS_CMD_RESET_CHANNEL
) &&
1145 (pt
->CoppCP
.cmd
.reset
.adapter_flag
== 1)) {
1146 if (ha
->scb_activelist
.count
!= 0) {
1147 SC
->result
= DID_BUS_BUSY
<< 16;
1151 ha
->ioctl_reset
= 1; /* This reset request is from an IOCTL */
1153 SC
->result
= DID_OK
<< 16;
1158 /* allocate space for the scribble */
1159 scratch
= kmalloc(sizeof (ips_copp_wait_item_t
), GFP_ATOMIC
);
1162 SC
->result
= DID_ERROR
<< 16;
1168 scratch
->scsi_cmd
= SC
;
1169 scratch
->next
= NULL
;
1171 ips_putq_copp_tail(&ha
->copp_waitlist
, scratch
);
1173 ips_putq_wait_tail(&ha
->scb_waitlist
, SC
);
1176 ips_next(ha
, IPS_INTR_IORL
);
1181 /****************************************************************************/
1183 /* Routine Name: ips_biosparam */
1185 /* Routine Description: */
1187 /* Set bios geometry for the controller */
1189 /****************************************************************************/
1191 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1192 ips_biosparam(Disk
* disk
, kdev_t dev
, int geom
[])
1194 ips_ha_t
*ha
= (ips_ha_t
*) disk
->device
->host
->hostdata
;
1195 unsigned long capacity
= disk
->capacity
;
1197 ips_biosparam(struct scsi_device
*sdev
, struct block_device
*bdev
,
1198 sector_t capacity
, int geom
[])
1200 ips_ha_t
*ha
= (ips_ha_t
*) sdev
->host
->hostdata
;
1206 METHOD_TRACE("ips_biosparam", 1);
1209 /* ?!?! host adater info invalid */
1215 if (!ips_read_adapter_status(ha
, IPS_INTR_ON
))
1216 /* ?!?! Enquiry command failed */
1219 if ((capacity
> 0x400000) && ((ha
->enq
->ucMiscFlag
& 0x8) == 0)) {
1220 heads
= IPS_NORM_HEADS
;
1221 sectors
= IPS_NORM_SECTORS
;
1223 heads
= IPS_COMP_HEADS
;
1224 sectors
= IPS_COMP_SECTORS
;
1227 cylinders
= (unsigned long) capacity
/ (heads
* sectors
);
1229 DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
1230 heads
, sectors
, cylinders
);
1234 geom
[2] = cylinders
;
1239 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1241 /* ips_proc24_info is a wrapper around ips_proc_info *
1242 * for compatibility with the 2.4 scsi parameters */
1244 ips_proc24_info(char *buffer
, char **start
, off_t offset
, int length
,
1245 int hostno
, int func
)
1249 for (i
= 0; i
< ips_next_controller
; i
++) {
1250 if (ips_sh
[i
] && ips_sh
[i
]->host_no
== hostno
) {
1251 return ips_proc_info(ips_sh
[i
], buffer
, start
,
1252 offset
, length
, func
);
1258 /****************************************************************************/
1260 /* Routine Name: ips_select_queue_depth */
1262 /* Routine Description: */
1264 /* Select queue depths for the devices on the contoller */
1266 /****************************************************************************/
1268 ips_select_queue_depth(struct Scsi_Host
*host
, Scsi_Device
* scsi_devs
)
1270 Scsi_Device
*device
;
1276 min
= ha
->max_cmds
/ 4;
1278 for (device
= scsi_devs
; device
; device
= device
->next
) {
1279 if (device
->host
== host
) {
1280 if ((device
->channel
== 0) && (device
->type
== 0))
1285 for (device
= scsi_devs
; device
; device
= device
->next
) {
1286 if (device
->host
== host
) {
1287 if ((device
->channel
== 0) && (device
->type
== 0)) {
1288 device
->queue_depth
=
1289 (ha
->max_cmds
- 1) / count
;
1290 if (device
->queue_depth
< min
)
1291 device
->queue_depth
= min
;
1293 device
->queue_depth
= 2;
1296 if (device
->queue_depth
< 2)
1297 device
->queue_depth
= 2;
1303 /****************************************************************************/
1305 /* Routine Name: ips_slave_configure */
1307 /* Routine Description: */
1309 /* Set queue depths on devices once scan is complete */
1311 /****************************************************************************/
1313 ips_slave_configure(Scsi_Device
* SDptr
)
1318 ha
= IPS_HA(SDptr
->host
);
1319 if (SDptr
->tagged_supported
&& SDptr
->type
== TYPE_DISK
) {
1320 min
= ha
->max_cmds
/ 2;
1321 if (ha
->enq
->ucLogDriveCount
<= 2)
1322 min
= ha
->max_cmds
- 1;
1323 scsi_adjust_queue_depth(SDptr
, MSG_ORDERED_TAG
, min
);
1329 /****************************************************************************/
1331 /* Routine Name: do_ipsintr */
1333 /* Routine Description: */
1335 /* Wrapper for the interrupt handler */
1337 /****************************************************************************/
1339 do_ipsintr(int irq
, void *dev_id
, struct pt_regs
* regs
)
1342 unsigned long cpu_flags
;
1343 struct Scsi_Host
*host
;
1346 METHOD_TRACE("do_ipsintr", 2);
1348 ha
= (ips_ha_t
*) dev_id
;
1351 host
= ips_sh
[ha
->host_num
];
1352 /* interrupt during initialization */
1354 (*ha
->func
.intr
) (ha
);
1358 IPS_LOCK_SAVE(host
->host_lock
, cpu_flags
);
1361 IPS_UNLOCK_RESTORE(host
->host_lock
, cpu_flags
);
1365 irqstatus
= (*ha
->func
.intr
) (ha
);
1367 IPS_UNLOCK_RESTORE(host
->host_lock
, cpu_flags
);
1369 /* start the next command */
1370 ips_next(ha
, IPS_INTR_ON
);
1371 return IRQ_RETVAL(irqstatus
);
1374 /****************************************************************************/
1376 /* Routine Name: ips_intr_copperhead */
1378 /* Routine Description: */
1380 /* Polling interrupt handler */
1382 /* ASSUMES interrupts are disabled */
1384 /****************************************************************************/
1386 ips_intr_copperhead(ips_ha_t
* ha
)
1393 METHOD_TRACE("ips_intr", 2);
1401 intrstatus
= (*ha
->func
.isintr
) (ha
);
1405 * Unexpected/Shared interrupt
1414 intrstatus
= (*ha
->func
.isintr
) (ha
);
1419 cstatus
.value
= (*ha
->func
.statupd
) (ha
);
1421 if (cstatus
.fields
.command_id
> (IPS_MAX_CMDS
- 1)) {
1422 /* Spurious Interupt ? */
1426 ips_chkstatus(ha
, &cstatus
);
1427 scb
= (ips_scb_t
*) sp
->scb_addr
;
1430 * use the callback function to finish things up
1431 * NOTE: interrupts are OFF for this
1433 (*scb
->callback
) (ha
, scb
);
1438 /****************************************************************************/
1440 /* Routine Name: ips_intr_morpheus */
1442 /* Routine Description: */
1444 /* Polling interrupt handler */
1446 /* ASSUMES interrupts are disabled */
1448 /****************************************************************************/
1450 ips_intr_morpheus(ips_ha_t
* ha
)
1457 METHOD_TRACE("ips_intr_morpheus", 2);
1465 intrstatus
= (*ha
->func
.isintr
) (ha
);
1469 * Unexpected/Shared interrupt
1478 intrstatus
= (*ha
->func
.isintr
) (ha
);
1483 cstatus
.value
= (*ha
->func
.statupd
) (ha
);
1485 if (cstatus
.value
== 0xffffffff)
1486 /* No more to process */
1489 if (cstatus
.fields
.command_id
> (IPS_MAX_CMDS
- 1)) {
1490 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
1491 "Spurious interrupt; no ccb.\n");
1496 ips_chkstatus(ha
, &cstatus
);
1497 scb
= (ips_scb_t
*) sp
->scb_addr
;
1500 * use the callback function to finish things up
1501 * NOTE: interrupts are OFF for this
1503 (*scb
->callback
) (ha
, scb
);
1508 /****************************************************************************/
1510 /* Routine Name: ips_info */
1512 /* Routine Description: */
1514 /* Return info about the driver */
1516 /****************************************************************************/
1518 ips_info(struct Scsi_Host
*SH
)
1520 static char buffer
[256];
1524 METHOD_TRACE("ips_info", 1);
1532 memset(bp
, 0, sizeof (buffer
));
1534 sprintf(bp
, "%s%s%s Build %d", "IBM PCI ServeRAID ",
1535 IPS_VERSION_HIGH
, IPS_VERSION_LOW
, IPS_BUILD_IDENT
);
1537 if (ha
->ad_type
> 0 && ha
->ad_type
<= MAX_ADAPTER_NAME
) {
1539 strcat(bp
, ips_adapter_name
[ha
->ad_type
- 1]);
1546 /****************************************************************************/
1548 /* Routine Name: ips_proc_info */
1550 /* Routine Description: */
1552 /* The passthru interface for the driver */
1554 /****************************************************************************/
1556 ips_proc_info(struct Scsi_Host
*host
, char *buffer
, char **start
, off_t offset
,
1557 int length
, int func
)
1561 ips_ha_t
*ha
= NULL
;
1563 METHOD_TRACE("ips_proc_info", 1);
1565 /* Find our host structure */
1566 for (i
= 0; i
< ips_next_controller
; i
++) {
1568 if (ips_sh
[i
] == host
) {
1569 ha
= (ips_ha_t
*) ips_sh
[i
]->hostdata
;
1586 ret
= ips_host_info(ha
, buffer
, offset
, length
);
1592 /*--------------------------------------------------------------------------*/
1593 /* Helper Functions */
1594 /*--------------------------------------------------------------------------*/
1596 /****************************************************************************/
1598 /* Routine Name: ips_is_passthru */
1600 /* Routine Description: */
1602 /* Determine if the specified SCSI command is really a passthru command */
1604 /****************************************************************************/
1606 ips_is_passthru(Scsi_Cmnd
* SC
)
1608 unsigned long flags
;
1610 METHOD_TRACE("ips_is_passthru", 1);
1615 if ((SC
->cmnd
[0] == IPS_IOCTL_COMMAND
) &&
1616 (SC
->device
->channel
== 0) &&
1617 (SC
->device
->id
== IPS_ADAPTER_ID
) &&
1618 (SC
->device
->lun
== 0) && SC
->request_buffer
) {
1619 if ((!SC
->use_sg
) && SC
->request_bufflen
&&
1620 (((char *) SC
->request_buffer
)[0] == 'C') &&
1621 (((char *) SC
->request_buffer
)[1] == 'O') &&
1622 (((char *) SC
->request_buffer
)[2] == 'P') &&
1623 (((char *) SC
->request_buffer
)[3] == 'P'))
1625 else if (SC
->use_sg
) {
1626 struct scatterlist
*sg
= SC
->request_buffer
;
1629 /* kmap_atomic() ensures addressability of the user buffer.*/
1630 /* local_irq_save() protects the KM_IRQ0 address slot. */
1631 local_irq_save(flags
);
1632 buffer
= kmap_atomic(sg
->page
, KM_IRQ0
) + sg
->offset
;
1633 if (buffer
&& buffer
[0] == 'C' && buffer
[1] == 'O' &&
1634 buffer
[2] == 'P' && buffer
[3] == 'P') {
1635 kunmap_atomic(buffer
- sg
->offset
, KM_IRQ0
);
1636 local_irq_restore(flags
);
1639 kunmap_atomic(buffer
- sg
->offset
, KM_IRQ0
);
1640 local_irq_restore(flags
);
1646 /****************************************************************************/
1648 /* Routine Name: ips_alloc_passthru_buffer */
1650 /* Routine Description: */
1651 /* allocate a buffer large enough for the ioctl data if the ioctl buffer */
1652 /* is too small or doesn't exist */
1653 /****************************************************************************/
1655 ips_alloc_passthru_buffer(ips_ha_t
* ha
, int length
)
1658 dma_addr_t dma_busaddr
;
1660 if (ha
->ioctl_data
&& length
<= ha
->ioctl_len
)
1662 /* there is no buffer or it's not big enough, allocate a new one */
1663 bigger_buf
= pci_alloc_consistent(ha
->pcidev
, length
, &dma_busaddr
);
1665 /* free the old memory */
1666 pci_free_consistent(ha
->pcidev
, ha
->ioctl_len
, ha
->ioctl_data
,
1668 /* use the new memory */
1669 ha
->ioctl_data
= (char *) bigger_buf
;
1670 ha
->ioctl_len
= length
;
1671 ha
->ioctl_busaddr
= dma_busaddr
;
1678 /****************************************************************************/
1680 /* Routine Name: ips_make_passthru */
1682 /* Routine Description: */
1684 /* Make a passthru command out of the info in the Scsi block */
1686 /****************************************************************************/
1688 ips_make_passthru(ips_ha_t
* ha
, Scsi_Cmnd
* SC
, ips_scb_t
* scb
, int intr
)
1694 METHOD_TRACE("ips_make_passthru", 1);
1697 length
= SC
->request_bufflen
;
1699 struct scatterlist
*sg
= SC
->request_buffer
;
1701 for (i
= 0; i
< SC
->use_sg
; i
++)
1702 length
+= sg
[i
].length
;
1704 if (length
< sizeof (ips_passthru_t
)) {
1706 DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
1707 ips_name
, ha
->host_num
);
1708 return (IPS_FAILURE
);
1710 if (ips_alloc_passthru_buffer(ha
, length
)) {
1711 /* allocation failure! If ha->ioctl_data exists, use it to return
1712 some error codes. Return a failed command to the scsi layer. */
1713 if (ha
->ioctl_data
) {
1714 pt
= (ips_passthru_t
*) ha
->ioctl_data
;
1715 ips_scmd_buf_read(SC
, pt
, sizeof (ips_passthru_t
));
1716 pt
->BasicStatus
= 0x0B;
1717 pt
->ExtendedStatus
= 0x00;
1718 ips_scmd_buf_write(SC
, pt
, sizeof (ips_passthru_t
));
1722 ha
->ioctl_datasize
= length
;
1724 ips_scmd_buf_read(SC
, ha
->ioctl_data
, ha
->ioctl_datasize
);
1725 pt
= (ips_passthru_t
*) ha
->ioctl_data
;
1728 * Some notes about the passthru interface used
1730 * IF the scsi op_code == 0x0d then we assume
1731 * that the data came along with/goes with the
1732 * packet we received from the sg driver. In this
1733 * case the CmdBSize field of the pt structure is
1734 * used for the size of the buffer.
1737 switch (pt
->CoppCmd
) {
1739 memcpy(ha
->ioctl_data
+ sizeof (ips_passthru_t
),
1740 &ips_num_controllers
, sizeof (int));
1741 ips_scmd_buf_write(SC
, ha
->ioctl_data
,
1742 sizeof (ips_passthru_t
) + sizeof (int));
1743 SC
->result
= DID_OK
<< 16;
1745 return (IPS_SUCCESS_IMM
);
1747 case IPS_COPPUSRCMD
:
1748 case IPS_COPPIOCCMD
:
1749 if (SC
->cmnd
[0] == IPS_IOCTL_COMMAND
) {
1750 if (length
< (sizeof (ips_passthru_t
) + pt
->CmdBSize
)) {
1753 "(%s%d) Passthru structure wrong size",
1754 ips_name
, ha
->host_num
);
1756 return (IPS_FAILURE
);
1759 if (ha
->device_id
== IPS_DEVICEID_COPPERHEAD
&&
1760 pt
->CoppCP
.cmd
.flashfw
.op_code
==
1761 IPS_CMD_RW_BIOSFW
) {
1762 ret
= ips_flash_copperhead(ha
, pt
, scb
);
1763 ips_scmd_buf_write(SC
, ha
->ioctl_data
,
1764 sizeof (ips_passthru_t
));
1767 if (ips_usrcmd(ha
, pt
, scb
))
1768 return (IPS_SUCCESS
);
1770 return (IPS_FAILURE
);
1777 return (IPS_FAILURE
);
1780 /****************************************************************************/
1781 /* Routine Name: ips_flash_copperhead */
1782 /* Routine Description: */
1783 /* Flash the BIOS/FW on a Copperhead style controller */
1784 /****************************************************************************/
1786 ips_flash_copperhead(ips_ha_t
* ha
, ips_passthru_t
* pt
, ips_scb_t
* scb
)
1790 /* Trombone is the only copperhead that can do packet flash, but only
1791 * for firmware. No one said it had to make sence. */
1792 if (IPS_IS_TROMBONE(ha
) && pt
->CoppCP
.cmd
.flashfw
.type
== IPS_FW_IMAGE
) {
1793 if (ips_usrcmd(ha
, pt
, scb
))
1798 pt
->BasicStatus
= 0x0B;
1799 pt
->ExtendedStatus
= 0;
1800 scb
->scsi_cmd
->result
= DID_OK
<< 16;
1801 /* IF it's OK to Use the "CD BOOT" Flash Buffer, then you can */
1802 /* avoid allocating a huge buffer per adapter ( which can fail ). */
1803 if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_BIOS_IMAGE
&&
1804 pt
->CoppCP
.cmd
.flashfw
.direction
== IPS_ERASE_BIOS
) {
1805 pt
->BasicStatus
= 0;
1806 return ips_flash_bios(ha
, pt
, scb
);
1807 } else if (pt
->CoppCP
.cmd
.flashfw
.packet_num
== 0) {
1808 if (ips_FlashData
&& !test_and_set_bit(0, &ips_FlashDataInUse
)){
1809 ha
->flash_data
= ips_FlashData
;
1810 ha
->flash_busaddr
= ips_flashbusaddr
;
1811 ha
->flash_len
= PAGE_SIZE
<< 7;
1812 ha
->flash_datasize
= 0;
1813 } else if (!ha
->flash_data
) {
1814 datasize
= pt
->CoppCP
.cmd
.flashfw
.total_packets
*
1815 pt
->CoppCP
.cmd
.flashfw
.count
;
1816 ha
->flash_data
= pci_alloc_consistent(ha
->pcidev
,
1818 &ha
->flash_busaddr
);
1819 if (!ha
->flash_data
){
1820 printk(KERN_WARNING
"Unable to allocate a flash buffer\n");
1823 ha
->flash_datasize
= 0;
1824 ha
->flash_len
= datasize
;
1828 if (pt
->CoppCP
.cmd
.flashfw
.count
+ ha
->flash_datasize
>
1830 ips_free_flash_copperhead(ha
);
1831 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
1832 "failed size sanity check\n");
1836 if (!ha
->flash_data
)
1838 pt
->BasicStatus
= 0;
1839 memcpy(&ha
->flash_data
[ha
->flash_datasize
], pt
+ 1,
1840 pt
->CoppCP
.cmd
.flashfw
.count
);
1841 ha
->flash_datasize
+= pt
->CoppCP
.cmd
.flashfw
.count
;
1842 if (pt
->CoppCP
.cmd
.flashfw
.packet_num
==
1843 pt
->CoppCP
.cmd
.flashfw
.total_packets
- 1) {
1844 if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_BIOS_IMAGE
)
1845 return ips_flash_bios(ha
, pt
, scb
);
1846 else if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_FW_IMAGE
)
1847 return ips_flash_firmware(ha
, pt
, scb
);
1849 return IPS_SUCCESS_IMM
;
1852 /****************************************************************************/
1853 /* Routine Name: ips_flash_bios */
1854 /* Routine Description: */
1855 /* flashes the bios of a copperhead adapter */
1856 /****************************************************************************/
1858 ips_flash_bios(ips_ha_t
* ha
, ips_passthru_t
* pt
, ips_scb_t
* scb
)
1861 if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_BIOS_IMAGE
&&
1862 pt
->CoppCP
.cmd
.flashfw
.direction
== IPS_WRITE_BIOS
) {
1863 if ((!ha
->func
.programbios
) || (!ha
->func
.erasebios
) ||
1864 (!ha
->func
.verifybios
))
1866 if ((*ha
->func
.erasebios
) (ha
)) {
1868 "(%s%d) flash bios failed - unable to erase flash",
1869 ips_name
, ha
->host_num
);
1872 if ((*ha
->func
.programbios
) (ha
,
1875 ha
->flash_datasize
-
1876 IPS_BIOS_HEADER
, 0)) {
1878 "(%s%d) flash bios failed - unable to flash",
1879 ips_name
, ha
->host_num
);
1882 if ((*ha
->func
.verifybios
) (ha
,
1885 ha
->flash_datasize
-
1886 IPS_BIOS_HEADER
, 0)) {
1888 "(%s%d) flash bios failed - unable to verify flash",
1889 ips_name
, ha
->host_num
);
1892 ips_free_flash_copperhead(ha
);
1893 return IPS_SUCCESS_IMM
;
1894 } else if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_BIOS_IMAGE
&&
1895 pt
->CoppCP
.cmd
.flashfw
.direction
== IPS_ERASE_BIOS
) {
1896 if (!ha
->func
.erasebios
)
1898 if ((*ha
->func
.erasebios
) (ha
)) {
1900 "(%s%d) flash bios failed - unable to erase flash",
1901 ips_name
, ha
->host_num
);
1904 return IPS_SUCCESS_IMM
;
1907 pt
->BasicStatus
= 0x0B;
1908 pt
->ExtendedStatus
= 0x00;
1909 ips_free_flash_copperhead(ha
);
1913 /****************************************************************************/
1915 /* Routine Name: ips_fill_scb_sg_single */
1917 /* Routine Description: */
1918 /* Fill in a single scb sg_list element from an address */
1919 /* return a -1 if a breakup occurred */
1920 /****************************************************************************/
1922 ips_fill_scb_sg_single(ips_ha_t
* ha
, dma_addr_t busaddr
,
1923 ips_scb_t
* scb
, int indx
, unsigned int e_len
)
1928 if ((scb
->data_len
+ e_len
) > ha
->max_xfer
) {
1929 e_len
= ha
->max_xfer
- scb
->data_len
;
1930 scb
->breakup
= indx
;
1937 if (IPS_USE_ENH_SGLIST(ha
)) {
1938 scb
->sg_list
.enh_list
[indx
].address_lo
=
1939 cpu_to_le32(pci_dma_lo32(busaddr
));
1940 scb
->sg_list
.enh_list
[indx
].address_hi
=
1941 cpu_to_le32(pci_dma_hi32(busaddr
));
1942 scb
->sg_list
.enh_list
[indx
].length
= cpu_to_le32(e_len
);
1944 scb
->sg_list
.std_list
[indx
].address
=
1945 cpu_to_le32(pci_dma_lo32(busaddr
));
1946 scb
->sg_list
.std_list
[indx
].length
= cpu_to_le32(e_len
);
1950 scb
->data_len
+= e_len
;
1954 /****************************************************************************/
1955 /* Routine Name: ips_flash_firmware */
1956 /* Routine Description: */
1957 /* flashes the firmware of a copperhead adapter */
1958 /****************************************************************************/
1960 ips_flash_firmware(ips_ha_t
* ha
, ips_passthru_t
* pt
, ips_scb_t
* scb
)
1962 IPS_SG_LIST sg_list
;
1963 uint32_t cmd_busaddr
;
1965 if (pt
->CoppCP
.cmd
.flashfw
.type
== IPS_FW_IMAGE
&&
1966 pt
->CoppCP
.cmd
.flashfw
.direction
== IPS_WRITE_FW
) {
1967 memset(&pt
->CoppCP
.cmd
, 0, sizeof (IPS_HOST_COMMAND
));
1968 pt
->CoppCP
.cmd
.flashfw
.op_code
= IPS_CMD_DOWNLOAD
;
1969 pt
->CoppCP
.cmd
.flashfw
.count
= cpu_to_le32(ha
->flash_datasize
);
1971 pt
->BasicStatus
= 0x0B;
1972 pt
->ExtendedStatus
= 0x00;
1973 ips_free_flash_copperhead(ha
);
1976 /* Save the S/G list pointer so it doesn't get clobbered */
1977 sg_list
.list
= scb
->sg_list
.list
;
1978 cmd_busaddr
= scb
->scb_busaddr
;
1979 /* copy in the CP */
1980 memcpy(&scb
->cmd
, &pt
->CoppCP
.cmd
, sizeof (IPS_IOCTL_CMD
));
1981 /* FIX stuff that might be wrong */
1982 scb
->sg_list
.list
= sg_list
.list
;
1983 scb
->scb_busaddr
= cmd_busaddr
;
1984 scb
->bus
= scb
->scsi_cmd
->device
->channel
;
1985 scb
->target_id
= scb
->scsi_cmd
->device
->id
;
1986 scb
->lun
= scb
->scsi_cmd
->device
->lun
;
1991 scb
->callback
= ipsintr_done
;
1992 scb
->timeout
= ips_cmd_timeout
;
1994 scb
->data_len
= ha
->flash_datasize
;
1996 pci_map_single(ha
->pcidev
, ha
->flash_data
, scb
->data_len
,
1998 scb
->flags
|= IPS_SCB_MAP_SINGLE
;
1999 scb
->cmd
.flashfw
.command_id
= IPS_COMMAND_ID(ha
, scb
);
2000 scb
->cmd
.flashfw
.buffer_addr
= cpu_to_le32(scb
->data_busaddr
);
2002 scb
->timeout
= pt
->TimeOut
;
2003 scb
->scsi_cmd
->result
= DID_OK
<< 16;
2007 /****************************************************************************/
2008 /* Routine Name: ips_free_flash_copperhead */
2009 /* Routine Description: */
2010 /* release the memory resources used to hold the flash image */
2011 /****************************************************************************/
2013 ips_free_flash_copperhead(ips_ha_t
* ha
)
2015 if (ha
->flash_data
== ips_FlashData
)
2016 test_and_clear_bit(0, &ips_FlashDataInUse
);
2017 else if (ha
->flash_data
)
2018 pci_free_consistent(ha
->pcidev
, ha
->flash_len
, ha
->flash_data
,
2020 ha
->flash_data
= NULL
;
2023 /****************************************************************************/
2025 /* Routine Name: ips_usrcmd */
2027 /* Routine Description: */
2029 /* Process a user command and make it ready to send */
2031 /****************************************************************************/
2033 ips_usrcmd(ips_ha_t
* ha
, ips_passthru_t
* pt
, ips_scb_t
* scb
)
2035 IPS_SG_LIST sg_list
;
2036 uint32_t cmd_busaddr
;
2038 METHOD_TRACE("ips_usrcmd", 1);
2040 if ((!scb
) || (!pt
) || (!ha
))
2043 /* Save the S/G list pointer so it doesn't get clobbered */
2044 sg_list
.list
= scb
->sg_list
.list
;
2045 cmd_busaddr
= scb
->scb_busaddr
;
2046 /* copy in the CP */
2047 memcpy(&scb
->cmd
, &pt
->CoppCP
.cmd
, sizeof (IPS_IOCTL_CMD
));
2048 memcpy(&scb
->dcdb
, &pt
->CoppCP
.dcdb
, sizeof (IPS_DCDB_TABLE
));
2050 /* FIX stuff that might be wrong */
2051 scb
->sg_list
.list
= sg_list
.list
;
2052 scb
->scb_busaddr
= cmd_busaddr
;
2053 scb
->bus
= scb
->scsi_cmd
->device
->channel
;
2054 scb
->target_id
= scb
->scsi_cmd
->device
->id
;
2055 scb
->lun
= scb
->scsi_cmd
->device
->lun
;
2060 scb
->callback
= ipsintr_done
;
2061 scb
->timeout
= ips_cmd_timeout
;
2062 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
2064 /* we don't support DCDB/READ/WRITE Scatter Gather */
2065 if ((scb
->cmd
.basic_io
.op_code
== IPS_CMD_READ_SG
) ||
2066 (scb
->cmd
.basic_io
.op_code
== IPS_CMD_WRITE_SG
) ||
2067 (scb
->cmd
.basic_io
.op_code
== IPS_CMD_DCDB_SG
))
2071 scb
->data_len
= pt
->CmdBSize
;
2072 scb
->data_busaddr
= ha
->ioctl_busaddr
+ sizeof (ips_passthru_t
);
2074 scb
->data_busaddr
= 0L;
2077 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_DCDB
)
2078 scb
->cmd
.dcdb
.dcdb_address
= cpu_to_le32(scb
->scb_busaddr
+
2079 (unsigned long) &scb
->
2081 (unsigned long) scb
);
2084 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_DCDB
)
2085 scb
->dcdb
.buffer_pointer
=
2086 cpu_to_le32(scb
->data_busaddr
);
2088 scb
->cmd
.basic_io
.sg_addr
=
2089 cpu_to_le32(scb
->data_busaddr
);
2094 scb
->timeout
= pt
->TimeOut
;
2096 if (pt
->TimeOut
<= 10)
2097 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT10
;
2098 else if (pt
->TimeOut
<= 60)
2099 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT60
;
2101 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT20M
;
2104 /* assume success */
2105 scb
->scsi_cmd
->result
= DID_OK
<< 16;
2111 /****************************************************************************/
2113 /* Routine Name: ips_cleanup_passthru */
2115 /* Routine Description: */
2117 /* Cleanup after a passthru command */
2119 /****************************************************************************/
2121 ips_cleanup_passthru(ips_ha_t
* ha
, ips_scb_t
* scb
)
2125 METHOD_TRACE("ips_cleanup_passthru", 1);
2127 if ((!scb
) || (!scb
->scsi_cmd
) || (!scb
->scsi_cmd
->request_buffer
)) {
2128 DEBUG_VAR(1, "(%s%d) couldn't cleanup after passthru",
2129 ips_name
, ha
->host_num
);
2133 pt
= (ips_passthru_t
*) ha
->ioctl_data
;
2135 /* Copy data back to the user */
2136 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_DCDB
) /* Copy DCDB Back to Caller's Area */
2137 memcpy(&pt
->CoppCP
.dcdb
, &scb
->dcdb
, sizeof (IPS_DCDB_TABLE
));
2139 pt
->BasicStatus
= scb
->basic_status
;
2140 pt
->ExtendedStatus
= scb
->extended_status
;
2141 pt
->AdapterType
= ha
->ad_type
;
2143 if (ha
->device_id
== IPS_DEVICEID_COPPERHEAD
&&
2144 (scb
->cmd
.flashfw
.op_code
== IPS_CMD_DOWNLOAD
||
2145 scb
->cmd
.flashfw
.op_code
== IPS_CMD_RW_BIOSFW
))
2146 ips_free_flash_copperhead(ha
);
2148 ips_scmd_buf_write(scb
->scsi_cmd
, ha
->ioctl_data
, ha
->ioctl_datasize
);
2151 /****************************************************************************/
2153 /* Routine Name: ips_host_info */
2155 /* Routine Description: */
2157 /* The passthru interface for the driver */
2159 /****************************************************************************/
2161 ips_host_info(ips_ha_t
* ha
, char *ptr
, off_t offset
, int len
)
2165 METHOD_TRACE("ips_host_info", 1);
2169 info
.offset
= offset
;
2173 copy_info(&info
, "\nIBM ServeRAID General Information:\n\n");
2175 if ((le32_to_cpu(ha
->nvram
->signature
) == IPS_NVRAM_P5_SIG
) &&
2176 (le16_to_cpu(ha
->nvram
->adapter_type
) != 0))
2177 copy_info(&info
, "\tController Type : %s\n",
2178 ips_adapter_name
[ha
->ad_type
- 1]);
2181 "\tController Type : Unknown\n");
2185 "\tIO region : 0x%lx (%d bytes)\n",
2186 ha
->io_addr
, ha
->io_len
);
2190 "\tMemory region : 0x%lx (%d bytes)\n",
2191 ha
->mem_addr
, ha
->mem_len
);
2193 "\tShared memory address : 0x%lx\n",
2197 copy_info(&info
, "\tIRQ number : %d\n", ha
->irq
);
2199 /* For the Next 3 lines Check for Binary 0 at the end and don't include it if it's there. */
2200 /* That keeps everything happy for "text" operations on the proc file. */
2202 if (le32_to_cpu(ha
->nvram
->signature
) == IPS_NVRAM_P5_SIG
) {
2203 if (ha
->nvram
->bios_low
[3] == 0) {
2205 "\tBIOS Version : %c%c%c%c%c%c%c\n",
2206 ha
->nvram
->bios_high
[0], ha
->nvram
->bios_high
[1],
2207 ha
->nvram
->bios_high
[2], ha
->nvram
->bios_high
[3],
2208 ha
->nvram
->bios_low
[0], ha
->nvram
->bios_low
[1],
2209 ha
->nvram
->bios_low
[2]);
2213 "\tBIOS Version : %c%c%c%c%c%c%c%c\n",
2214 ha
->nvram
->bios_high
[0], ha
->nvram
->bios_high
[1],
2215 ha
->nvram
->bios_high
[2], ha
->nvram
->bios_high
[3],
2216 ha
->nvram
->bios_low
[0], ha
->nvram
->bios_low
[1],
2217 ha
->nvram
->bios_low
[2], ha
->nvram
->bios_low
[3]);
2222 if (ha
->enq
->CodeBlkVersion
[7] == 0) {
2224 "\tFirmware Version : %c%c%c%c%c%c%c\n",
2225 ha
->enq
->CodeBlkVersion
[0], ha
->enq
->CodeBlkVersion
[1],
2226 ha
->enq
->CodeBlkVersion
[2], ha
->enq
->CodeBlkVersion
[3],
2227 ha
->enq
->CodeBlkVersion
[4], ha
->enq
->CodeBlkVersion
[5],
2228 ha
->enq
->CodeBlkVersion
[6]);
2231 "\tFirmware Version : %c%c%c%c%c%c%c%c\n",
2232 ha
->enq
->CodeBlkVersion
[0], ha
->enq
->CodeBlkVersion
[1],
2233 ha
->enq
->CodeBlkVersion
[2], ha
->enq
->CodeBlkVersion
[3],
2234 ha
->enq
->CodeBlkVersion
[4], ha
->enq
->CodeBlkVersion
[5],
2235 ha
->enq
->CodeBlkVersion
[6], ha
->enq
->CodeBlkVersion
[7]);
2238 if (ha
->enq
->BootBlkVersion
[7] == 0) {
2240 "\tBoot Block Version : %c%c%c%c%c%c%c\n",
2241 ha
->enq
->BootBlkVersion
[0], ha
->enq
->BootBlkVersion
[1],
2242 ha
->enq
->BootBlkVersion
[2], ha
->enq
->BootBlkVersion
[3],
2243 ha
->enq
->BootBlkVersion
[4], ha
->enq
->BootBlkVersion
[5],
2244 ha
->enq
->BootBlkVersion
[6]);
2247 "\tBoot Block Version : %c%c%c%c%c%c%c%c\n",
2248 ha
->enq
->BootBlkVersion
[0], ha
->enq
->BootBlkVersion
[1],
2249 ha
->enq
->BootBlkVersion
[2], ha
->enq
->BootBlkVersion
[3],
2250 ha
->enq
->BootBlkVersion
[4], ha
->enq
->BootBlkVersion
[5],
2251 ha
->enq
->BootBlkVersion
[6], ha
->enq
->BootBlkVersion
[7]);
2254 copy_info(&info
, "\tDriver Version : %s%s\n",
2255 IPS_VERSION_HIGH
, IPS_VERSION_LOW
);
2257 copy_info(&info
, "\tDriver Build : %d\n",
2260 copy_info(&info
, "\tMax Physical Devices : %d\n",
2261 ha
->enq
->ucMaxPhysicalDevices
);
2262 copy_info(&info
, "\tMax Active Commands : %d\n",
2264 copy_info(&info
, "\tCurrent Queued Commands : %d\n",
2265 ha
->scb_waitlist
.count
);
2266 copy_info(&info
, "\tCurrent Active Commands : %d\n",
2267 ha
->scb_activelist
.count
- ha
->num_ioctl
);
2268 copy_info(&info
, "\tCurrent Queued PT Commands : %d\n",
2269 ha
->copp_waitlist
.count
);
2270 copy_info(&info
, "\tCurrent Active PT Commands : %d\n",
2273 copy_info(&info
, "\n");
2275 return (info
.localpos
);
2278 /****************************************************************************/
2280 /* Routine Name: copy_mem_info */
2282 /* Routine Description: */
2284 /* Copy data into an IPS_INFOSTR structure */
2286 /****************************************************************************/
2288 copy_mem_info(IPS_INFOSTR
* info
, char *data
, int len
)
2290 METHOD_TRACE("copy_mem_info", 1);
2292 if (info
->pos
+ len
< info
->offset
) {
2297 if (info
->pos
< info
->offset
) {
2298 data
+= (info
->offset
- info
->pos
);
2299 len
-= (info
->offset
- info
->pos
);
2300 info
->pos
+= (info
->offset
- info
->pos
);
2303 if (info
->localpos
+ len
> info
->length
)
2304 len
= info
->length
- info
->localpos
;
2307 memcpy(info
->buffer
+ info
->localpos
, data
, len
);
2309 info
->localpos
+= len
;
2313 /****************************************************************************/
2315 /* Routine Name: copy_info */
2317 /* Routine Description: */
2319 /* printf style wrapper for an info structure */
2321 /****************************************************************************/
2323 copy_info(IPS_INFOSTR
* info
, char *fmt
, ...)
2329 METHOD_TRACE("copy_info", 1);
2331 va_start(args
, fmt
);
2332 len
= vsprintf(buf
, fmt
, args
);
2335 copy_mem_info(info
, buf
, len
);
2340 /****************************************************************************/
2342 /* Routine Name: ips_identify_controller */
2344 /* Routine Description: */
2346 /* Identify this controller */
2348 /****************************************************************************/
2350 ips_identify_controller(ips_ha_t
* ha
)
2352 METHOD_TRACE("ips_identify_controller", 1);
2354 switch (ha
->device_id
) {
2355 case IPS_DEVICEID_COPPERHEAD
:
2356 if (ha
->revision_id
<= IPS_REVID_SERVERAID
) {
2357 ha
->ad_type
= IPS_ADTYPE_SERVERAID
;
2358 } else if (ha
->revision_id
== IPS_REVID_SERVERAID2
) {
2359 ha
->ad_type
= IPS_ADTYPE_SERVERAID2
;
2360 } else if (ha
->revision_id
== IPS_REVID_NAVAJO
) {
2361 ha
->ad_type
= IPS_ADTYPE_NAVAJO
;
2362 } else if ((ha
->revision_id
== IPS_REVID_SERVERAID2
)
2363 && (ha
->slot_num
== 0)) {
2364 ha
->ad_type
= IPS_ADTYPE_KIOWA
;
2365 } else if ((ha
->revision_id
>= IPS_REVID_CLARINETP1
) &&
2366 (ha
->revision_id
<= IPS_REVID_CLARINETP3
)) {
2367 if (ha
->enq
->ucMaxPhysicalDevices
== 15)
2368 ha
->ad_type
= IPS_ADTYPE_SERVERAID3L
;
2370 ha
->ad_type
= IPS_ADTYPE_SERVERAID3
;
2371 } else if ((ha
->revision_id
>= IPS_REVID_TROMBONE32
) &&
2372 (ha
->revision_id
<= IPS_REVID_TROMBONE64
)) {
2373 ha
->ad_type
= IPS_ADTYPE_SERVERAID4H
;
2377 case IPS_DEVICEID_MORPHEUS
:
2378 switch (ha
->subdevice_id
) {
2379 case IPS_SUBDEVICEID_4L
:
2380 ha
->ad_type
= IPS_ADTYPE_SERVERAID4L
;
2383 case IPS_SUBDEVICEID_4M
:
2384 ha
->ad_type
= IPS_ADTYPE_SERVERAID4M
;
2387 case IPS_SUBDEVICEID_4MX
:
2388 ha
->ad_type
= IPS_ADTYPE_SERVERAID4MX
;
2391 case IPS_SUBDEVICEID_4LX
:
2392 ha
->ad_type
= IPS_ADTYPE_SERVERAID4LX
;
2395 case IPS_SUBDEVICEID_5I2
:
2396 ha
->ad_type
= IPS_ADTYPE_SERVERAID5I2
;
2399 case IPS_SUBDEVICEID_5I1
:
2400 ha
->ad_type
= IPS_ADTYPE_SERVERAID5I1
;
2406 case IPS_DEVICEID_MARCO
:
2407 switch (ha
->subdevice_id
) {
2408 case IPS_SUBDEVICEID_6M
:
2409 ha
->ad_type
= IPS_ADTYPE_SERVERAID6M
;
2411 case IPS_SUBDEVICEID_6I
:
2412 ha
->ad_type
= IPS_ADTYPE_SERVERAID6I
;
2414 case IPS_SUBDEVICEID_7k
:
2415 ha
->ad_type
= IPS_ADTYPE_SERVERAID7k
;
2417 case IPS_SUBDEVICEID_7M
:
2418 ha
->ad_type
= IPS_ADTYPE_SERVERAID7M
;
2425 /****************************************************************************/
2427 /* Routine Name: ips_get_bios_version */
2429 /* Routine Description: */
2431 /* Get the BIOS revision number */
2433 /****************************************************************************/
2435 ips_get_bios_version(ips_ha_t
* ha
, int intr
)
2444 { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
2447 METHOD_TRACE("ips_get_bios_version", 1);
2452 strncpy(ha
->bios_version
, " ?", 8);
2454 if (ha
->device_id
== IPS_DEVICEID_COPPERHEAD
) {
2455 if (IPS_USE_MEMIO(ha
)) {
2456 /* Memory Mapped I/O */
2459 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
2460 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
2461 udelay(25); /* 25 us */
2463 if (readb(ha
->mem_ptr
+ IPS_REG_FLDP
) != 0x55)
2466 writel(1, ha
->mem_ptr
+ IPS_REG_FLAP
);
2467 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
2468 udelay(25); /* 25 us */
2470 if (readb(ha
->mem_ptr
+ IPS_REG_FLDP
) != 0xAA)
2473 /* Get Major version */
2474 writel(0x1FF, ha
->mem_ptr
+ IPS_REG_FLAP
);
2475 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
2476 udelay(25); /* 25 us */
2478 major
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
2480 /* Get Minor version */
2481 writel(0x1FE, ha
->mem_ptr
+ IPS_REG_FLAP
);
2482 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
2483 udelay(25); /* 25 us */
2484 minor
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
2486 /* Get SubMinor version */
2487 writel(0x1FD, ha
->mem_ptr
+ IPS_REG_FLAP
);
2488 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
2489 udelay(25); /* 25 us */
2490 subminor
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
2493 /* Programmed I/O */
2496 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
2497 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
2498 udelay(25); /* 25 us */
2500 if (inb(ha
->io_addr
+ IPS_REG_FLDP
) != 0x55)
2503 outl(cpu_to_le32(1), ha
->io_addr
+ IPS_REG_FLAP
);
2504 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
2505 udelay(25); /* 25 us */
2507 if (inb(ha
->io_addr
+ IPS_REG_FLDP
) != 0xAA)
2510 /* Get Major version */
2511 outl(cpu_to_le32(0x1FF), ha
->io_addr
+ IPS_REG_FLAP
);
2512 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
2513 udelay(25); /* 25 us */
2515 major
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
2517 /* Get Minor version */
2518 outl(cpu_to_le32(0x1FE), ha
->io_addr
+ IPS_REG_FLAP
);
2519 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
2520 udelay(25); /* 25 us */
2522 minor
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
2524 /* Get SubMinor version */
2525 outl(cpu_to_le32(0x1FD), ha
->io_addr
+ IPS_REG_FLAP
);
2526 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
2527 udelay(25); /* 25 us */
2529 subminor
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
2533 /* Morpheus Family - Send Command to the card */
2535 buffer
= ha
->ioctl_data
;
2537 memset(buffer
, 0, 0x1000);
2539 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
2541 ips_init_scb(ha
, scb
);
2543 scb
->timeout
= ips_cmd_timeout
;
2544 scb
->cdb
[0] = IPS_CMD_RW_BIOSFW
;
2546 scb
->cmd
.flashfw
.op_code
= IPS_CMD_RW_BIOSFW
;
2547 scb
->cmd
.flashfw
.command_id
= IPS_COMMAND_ID(ha
, scb
);
2548 scb
->cmd
.flashfw
.type
= 1;
2549 scb
->cmd
.flashfw
.direction
= 0;
2550 scb
->cmd
.flashfw
.count
= cpu_to_le32(0x800);
2551 scb
->cmd
.flashfw
.total_packets
= 1;
2552 scb
->cmd
.flashfw
.packet_num
= 0;
2553 scb
->data_len
= 0x1000;
2554 scb
->cmd
.flashfw
.buffer_addr
= ha
->ioctl_busaddr
;
2556 /* issue the command */
2558 ips_send_wait(ha
, scb
, ips_cmd_timeout
,
2559 intr
)) == IPS_FAILURE
)
2560 || (ret
== IPS_SUCCESS_IMM
)
2561 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1)) {
2562 /* Error occurred */
2567 if ((buffer
[0xC0] == 0x55) && (buffer
[0xC1] == 0xAA)) {
2568 major
= buffer
[0x1ff + 0xC0]; /* Offset 0x1ff after the header (0xc0) */
2569 minor
= buffer
[0x1fe + 0xC0]; /* Offset 0x1fe after the header (0xc0) */
2570 subminor
= buffer
[0x1fd + 0xC0]; /* Offset 0x1fd after the header (0xc0) */
2576 ha
->bios_version
[0] = hexDigits
[(major
& 0xF0) >> 4];
2577 ha
->bios_version
[1] = '.';
2578 ha
->bios_version
[2] = hexDigits
[major
& 0x0F];
2579 ha
->bios_version
[3] = hexDigits
[subminor
];
2580 ha
->bios_version
[4] = '.';
2581 ha
->bios_version
[5] = hexDigits
[(minor
& 0xF0) >> 4];
2582 ha
->bios_version
[6] = hexDigits
[minor
& 0x0F];
2583 ha
->bios_version
[7] = 0;
2586 /****************************************************************************/
2588 /* Routine Name: ips_hainit */
2590 /* Routine Description: */
2592 /* Initialize the controller */
2594 /* NOTE: Assumes to be called from with a lock */
2596 /****************************************************************************/
2598 ips_hainit(ips_ha_t
* ha
)
2603 METHOD_TRACE("ips_hainit", 1);
2608 if (ha
->func
.statinit
)
2609 (*ha
->func
.statinit
) (ha
);
2611 if (ha
->func
.enableint
)
2612 (*ha
->func
.enableint
) (ha
);
2615 ha
->reset_count
= 1;
2616 do_gettimeofday(&tv
);
2617 ha
->last_ffdc
= tv
.tv_sec
;
2618 ips_ffdc_reset(ha
, IPS_INTR_IORL
);
2620 if (!ips_read_config(ha
, IPS_INTR_IORL
)) {
2621 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
2622 "unable to read config from controller.\n");
2627 if (!ips_read_adapter_status(ha
, IPS_INTR_IORL
)) {
2628 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
2629 "unable to read controller status.\n");
2634 /* Identify this controller */
2635 ips_identify_controller(ha
);
2637 if (!ips_read_subsystem_parameters(ha
, IPS_INTR_IORL
)) {
2638 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
2639 "unable to read subsystem parameters.\n");
2644 /* write nvram user page 5 */
2645 if (!ips_write_driver_status(ha
, IPS_INTR_IORL
)) {
2646 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
2647 "unable to write driver info to controller.\n");
2652 /* If there are Logical Drives and a Reset Occurred, then an EraseStripeLock is Needed */
2653 if ((ha
->conf
->ucLogDriveCount
> 0) && (ha
->requires_esl
== 1))
2654 ips_clear_adapter(ha
, IPS_INTR_IORL
);
2656 /* set limits on SID, LUN, BUS */
2657 ha
->ntargets
= IPS_MAX_TARGETS
+ 1;
2659 ha
->nbus
= (ha
->enq
->ucMaxPhysicalDevices
/ IPS_MAX_TARGETS
) + 1;
2661 switch (ha
->conf
->logical_drive
[0].ucStripeSize
) {
2663 ha
->max_xfer
= 0x10000;
2667 ha
->max_xfer
= 0x20000;
2671 ha
->max_xfer
= 0x40000;
2676 ha
->max_xfer
= 0x80000;
2680 /* setup max concurrent commands */
2681 if (le32_to_cpu(ha
->subsys
->param
[4]) & 0x1) {
2682 /* Use the new method */
2683 ha
->max_cmds
= ha
->enq
->ucConcurrentCmdCount
;
2685 /* use the old method */
2686 switch (ha
->conf
->logical_drive
[0].ucStripeSize
) {
2706 /* Limit the Active Commands on a Lite Adapter */
2707 if ((ha
->ad_type
== IPS_ADTYPE_SERVERAID3L
) ||
2708 (ha
->ad_type
== IPS_ADTYPE_SERVERAID4L
) ||
2709 (ha
->ad_type
== IPS_ADTYPE_SERVERAID4LX
)) {
2710 if ((ha
->max_cmds
> MaxLiteCmds
) && (MaxLiteCmds
))
2711 ha
->max_cmds
= MaxLiteCmds
;
2714 /* set controller IDs */
2715 ha
->ha_id
[0] = IPS_ADAPTER_ID
;
2716 for (i
= 1; i
< ha
->nbus
; i
++) {
2717 ha
->ha_id
[i
] = ha
->conf
->init_id
[i
- 1] & 0x1f;
2718 ha
->dcdb_active
[i
- 1] = 0;
2724 /****************************************************************************/
2726 /* Routine Name: ips_next */
2728 /* Routine Description: */
2730 /* Take the next command off the queue and send it to the controller */
2732 /****************************************************************************/
2734 ips_next(ips_ha_t
* ha
, int intr
)
2740 ips_copp_wait_item_t
*item
;
2742 unsigned long cpu_flags
= 0;
2743 struct Scsi_Host
*host
;
2744 METHOD_TRACE("ips_next", 1);
2748 host
= ips_sh
[ha
->host_num
];
2750 * Block access to the queue function so
2751 * this command won't time out
2753 if (intr
== IPS_INTR_ON
)
2754 IPS_LOCK_SAVE(host
->host_lock
, cpu_flags
);
2756 if ((ha
->subsys
->param
[3] & 0x300000)
2757 && (ha
->scb_activelist
.count
== 0)) {
2760 do_gettimeofday(&tv
);
2762 if (tv
.tv_sec
- ha
->last_ffdc
> IPS_SECS_8HOURS
) {
2763 ha
->last_ffdc
= tv
.tv_sec
;
2769 * Send passthru commands
2770 * These have priority over normal I/O
2771 * but shouldn't affect performance too much
2772 * since we limit the number that can be active
2773 * on the card at any one time
2775 while ((ha
->num_ioctl
< IPS_MAX_IOCTL
) &&
2776 (ha
->copp_waitlist
.head
) && (scb
= ips_getscb(ha
))) {
2778 item
= ips_removeq_copp_head(&ha
->copp_waitlist
);
2780 if (intr
== IPS_INTR_ON
)
2781 IPS_UNLOCK_RESTORE(host
->host_lock
, cpu_flags
);
2782 scb
->scsi_cmd
= item
->scsi_cmd
;
2785 ret
= ips_make_passthru(ha
, scb
->scsi_cmd
, scb
, intr
);
2787 if (intr
== IPS_INTR_ON
)
2788 IPS_LOCK_SAVE(host
->host_lock
, cpu_flags
);
2791 if (scb
->scsi_cmd
) {
2792 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
2793 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
2796 ips_freescb(ha
, scb
);
2798 case IPS_SUCCESS_IMM
:
2799 if (scb
->scsi_cmd
) {
2800 scb
->scsi_cmd
->result
= DID_OK
<< 16;
2801 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
2804 ips_freescb(ha
, scb
);
2810 if (ret
!= IPS_SUCCESS
) {
2815 ret
= ips_send_cmd(ha
, scb
);
2817 if (ret
== IPS_SUCCESS
)
2818 ips_putq_scb_head(&ha
->scb_activelist
, scb
);
2824 if (scb
->scsi_cmd
) {
2825 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
2828 ips_freescb(ha
, scb
);
2830 case IPS_SUCCESS_IMM
:
2831 ips_freescb(ha
, scb
);
2840 * Send "Normal" I/O commands
2843 p
= ha
->scb_waitlist
.head
;
2844 while ((p
) && (scb
= ips_getscb(ha
))) {
2845 if ((scmd_channel(p
) > 0)
2847 dcdb_active
[scmd_channel(p
) -
2848 1] & (1 << scmd_id(p
)))) {
2849 ips_freescb(ha
, scb
);
2850 p
= (Scsi_Cmnd
*) p
->host_scribble
;
2855 SC
= ips_removeq_wait(&ha
->scb_waitlist
, q
);
2857 if (intr
== IPS_INTR_ON
)
2858 IPS_UNLOCK_RESTORE(host
->host_lock
, cpu_flags
); /* Unlock HA after command is taken off queue */
2860 SC
->result
= DID_OK
;
2861 SC
->host_scribble
= NULL
;
2863 memset(SC
->sense_buffer
, 0, sizeof (SC
->sense_buffer
));
2865 scb
->target_id
= SC
->device
->id
;
2866 scb
->lun
= SC
->device
->lun
;
2867 scb
->bus
= SC
->device
->channel
;
2871 scb
->callback
= ipsintr_done
;
2872 scb
->timeout
= ips_cmd_timeout
;
2873 memset(&scb
->cmd
, 0, 16);
2875 /* copy in the CDB */
2876 memcpy(scb
->cdb
, SC
->cmnd
, SC
->cmd_len
);
2878 /* Now handle the data buffer */
2880 struct scatterlist
*sg
;
2883 sg
= SC
->request_buffer
;
2884 scb
->sg_count
= pci_map_sg(ha
->pcidev
, sg
, SC
->use_sg
,
2885 SC
->sc_data_direction
);
2886 scb
->flags
|= IPS_SCB_MAP_SG
;
2887 for (i
= 0; i
< scb
->sg_count
; i
++) {
2888 if (ips_fill_scb_sg_single
2889 (ha
, sg_dma_address(&sg
[i
]), scb
, i
,
2890 sg_dma_len(&sg
[i
])) < 0)
2893 scb
->dcdb
.transfer_length
= scb
->data_len
;
2895 if (SC
->request_bufflen
) {
2897 pci_map_single(ha
->pcidev
,
2899 SC
->request_bufflen
,
2900 SC
->sc_data_direction
);
2901 scb
->flags
|= IPS_SCB_MAP_SINGLE
;
2902 ips_fill_scb_sg_single(ha
, scb
->data_busaddr
,
2904 SC
->request_bufflen
);
2905 scb
->dcdb
.transfer_length
= scb
->data_len
;
2907 scb
->data_busaddr
= 0L;
2910 scb
->dcdb
.transfer_length
= 0;
2915 scb
->dcdb
.cmd_attribute
=
2916 ips_command_direction
[scb
->scsi_cmd
->cmnd
[0]];
2918 /* Allow a WRITE BUFFER Command to Have no Data */
2919 /* This is Used by Tape Flash Utilites */
2920 if ((scb
->scsi_cmd
->cmnd
[0] == WRITE_BUFFER
) && (scb
->data_len
== 0))
2921 scb
->dcdb
.cmd_attribute
= 0;
2923 if (!(scb
->dcdb
.cmd_attribute
& 0x3))
2924 scb
->dcdb
.transfer_length
= 0;
2926 if (scb
->data_len
>= IPS_MAX_XFER
) {
2927 scb
->dcdb
.cmd_attribute
|= IPS_TRANSFER64K
;
2928 scb
->dcdb
.transfer_length
= 0;
2930 if (intr
== IPS_INTR_ON
)
2931 IPS_LOCK_SAVE(host
->host_lock
, cpu_flags
);
2933 ret
= ips_send_cmd(ha
, scb
);
2937 ips_putq_scb_head(&ha
->scb_activelist
, scb
);
2940 if (scb
->scsi_cmd
) {
2941 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
2942 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
2946 ha
->dcdb_active
[scb
->bus
- 1] &=
2947 ~(1 << scb
->target_id
);
2949 ips_freescb(ha
, scb
);
2951 case IPS_SUCCESS_IMM
:
2953 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
2956 ha
->dcdb_active
[scb
->bus
- 1] &=
2957 ~(1 << scb
->target_id
);
2959 ips_freescb(ha
, scb
);
2965 p
= (Scsi_Cmnd
*) p
->host_scribble
;
2969 if (intr
== IPS_INTR_ON
)
2970 IPS_UNLOCK_RESTORE(host
->host_lock
, cpu_flags
);
2973 /****************************************************************************/
2975 /* Routine Name: ips_putq_scb_head */
2977 /* Routine Description: */
2979 /* Add an item to the head of the queue */
2981 /* ASSUMED to be called from within the HA lock */
2983 /****************************************************************************/
2985 ips_putq_scb_head(ips_scb_queue_t
* queue
, ips_scb_t
* item
)
2987 METHOD_TRACE("ips_putq_scb_head", 1);
2992 item
->q_next
= queue
->head
;
3001 /****************************************************************************/
3003 /* Routine Name: ips_removeq_scb_head */
3005 /* Routine Description: */
3007 /* Remove the head of the queue */
3009 /* ASSUMED to be called from within the HA lock */
3011 /****************************************************************************/
3013 ips_removeq_scb_head(ips_scb_queue_t
* queue
)
3017 METHOD_TRACE("ips_removeq_scb_head", 1);
3025 queue
->head
= item
->q_next
;
3026 item
->q_next
= NULL
;
3028 if (queue
->tail
== item
)
3036 /****************************************************************************/
3038 /* Routine Name: ips_removeq_scb */
3040 /* Routine Description: */
3042 /* Remove an item from a queue */
3044 /* ASSUMED to be called from within the HA lock */
3046 /****************************************************************************/
3048 ips_removeq_scb(ips_scb_queue_t
* queue
, ips_scb_t
* item
)
3052 METHOD_TRACE("ips_removeq_scb", 1);
3057 if (item
== queue
->head
) {
3058 return (ips_removeq_scb_head(queue
));
3063 while ((p
) && (item
!= p
->q_next
))
3068 p
->q_next
= item
->q_next
;
3073 item
->q_next
= NULL
;
3082 /****************************************************************************/
3084 /* Routine Name: ips_putq_wait_tail */
3086 /* Routine Description: */
3088 /* Add an item to the tail of the queue */
3090 /* ASSUMED to be called from within the HA lock */
3092 /****************************************************************************/
3094 ips_putq_wait_tail(ips_wait_queue_t
* queue
, Scsi_Cmnd
* item
)
3096 METHOD_TRACE("ips_putq_wait_tail", 1);
3101 item
->host_scribble
= NULL
;
3104 queue
->tail
->host_scribble
= (char *) item
;
3114 /****************************************************************************/
3116 /* Routine Name: ips_removeq_wait_head */
3118 /* Routine Description: */
3120 /* Remove the head of the queue */
3122 /* ASSUMED to be called from within the HA lock */
3124 /****************************************************************************/
3126 ips_removeq_wait_head(ips_wait_queue_t
* queue
)
3130 METHOD_TRACE("ips_removeq_wait_head", 1);
3138 queue
->head
= (Scsi_Cmnd
*) item
->host_scribble
;
3139 item
->host_scribble
= NULL
;
3141 if (queue
->tail
== item
)
3149 /****************************************************************************/
3151 /* Routine Name: ips_removeq_wait */
3153 /* Routine Description: */
3155 /* Remove an item from a queue */
3157 /* ASSUMED to be called from within the HA lock */
3159 /****************************************************************************/
3161 ips_removeq_wait(ips_wait_queue_t
* queue
, Scsi_Cmnd
* item
)
3165 METHOD_TRACE("ips_removeq_wait", 1);
3170 if (item
== queue
->head
) {
3171 return (ips_removeq_wait_head(queue
));
3176 while ((p
) && (item
!= (Scsi_Cmnd
*) p
->host_scribble
))
3177 p
= (Scsi_Cmnd
*) p
->host_scribble
;
3181 p
->host_scribble
= item
->host_scribble
;
3183 if (!item
->host_scribble
)
3186 item
->host_scribble
= NULL
;
3195 /****************************************************************************/
3197 /* Routine Name: ips_putq_copp_tail */
3199 /* Routine Description: */
3201 /* Add an item to the tail of the queue */
3203 /* ASSUMED to be called from within the HA lock */
3205 /****************************************************************************/
3207 ips_putq_copp_tail(ips_copp_queue_t
* queue
, ips_copp_wait_item_t
* item
)
3209 METHOD_TRACE("ips_putq_copp_tail", 1);
3217 queue
->tail
->next
= item
;
3227 /****************************************************************************/
3229 /* Routine Name: ips_removeq_copp_head */
3231 /* Routine Description: */
3233 /* Remove the head of the queue */
3235 /* ASSUMED to be called from within the HA lock */
3237 /****************************************************************************/
3238 static ips_copp_wait_item_t
*
3239 ips_removeq_copp_head(ips_copp_queue_t
* queue
)
3241 ips_copp_wait_item_t
*item
;
3243 METHOD_TRACE("ips_removeq_copp_head", 1);
3251 queue
->head
= item
->next
;
3254 if (queue
->tail
== item
)
3262 /****************************************************************************/
3264 /* Routine Name: ips_removeq_copp */
3266 /* Routine Description: */
3268 /* Remove an item from a queue */
3270 /* ASSUMED to be called from within the HA lock */
3272 /****************************************************************************/
3273 static ips_copp_wait_item_t
*
3274 ips_removeq_copp(ips_copp_queue_t
* queue
, ips_copp_wait_item_t
* item
)
3276 ips_copp_wait_item_t
*p
;
3278 METHOD_TRACE("ips_removeq_copp", 1);
3283 if (item
== queue
->head
) {
3284 return (ips_removeq_copp_head(queue
));
3289 while ((p
) && (item
!= p
->next
))
3294 p
->next
= item
->next
;
3308 /****************************************************************************/
3310 /* Routine Name: ipsintr_blocking */
3312 /* Routine Description: */
3314 /* Finalize an interrupt for internal commands */
3316 /****************************************************************************/
3318 ipsintr_blocking(ips_ha_t
* ha
, ips_scb_t
* scb
)
3320 METHOD_TRACE("ipsintr_blocking", 2);
3322 ips_freescb(ha
, scb
);
3323 if ((ha
->waitflag
== TRUE
) && (ha
->cmd_in_progress
== scb
->cdb
[0])) {
3324 ha
->waitflag
= FALSE
;
3330 /****************************************************************************/
3332 /* Routine Name: ipsintr_done */
3334 /* Routine Description: */
3336 /* Finalize an interrupt for non-internal commands */
3338 /****************************************************************************/
3340 ipsintr_done(ips_ha_t
* ha
, ips_scb_t
* scb
)
3342 METHOD_TRACE("ipsintr_done", 2);
3345 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
3346 "Spurious interrupt; scb NULL.\n");
3351 if (scb
->scsi_cmd
== NULL
) {
3352 /* unexpected interrupt */
3353 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
3354 "Spurious interrupt; scsi_cmd not set.\n");
3362 /****************************************************************************/
3364 /* Routine Name: ips_done */
3366 /* Routine Description: */
3368 /* Do housekeeping on completed commands */
3369 /* ASSUMED to be called form within the request lock */
3370 /****************************************************************************/
3372 ips_done(ips_ha_t
* ha
, ips_scb_t
* scb
)
3376 METHOD_TRACE("ips_done", 1);
3381 if ((scb
->scsi_cmd
) && (ips_is_passthru(scb
->scsi_cmd
))) {
3382 ips_cleanup_passthru(ha
, scb
);
3386 * Check to see if this command had too much
3387 * data and had to be broke up. If so, queue
3388 * the rest of the data and continue.
3390 if ((scb
->breakup
) || (scb
->sg_break
)) {
3391 /* we had a data breakup */
3394 if (scb
->sg_count
) {
3396 struct scatterlist
*sg
;
3397 int ips_sg_index
= 0;
3400 sg
= scb
->scsi_cmd
->request_buffer
;
3402 /* Spin forward to last dma chunk */
3403 sg_dma_index
= scb
->breakup
;
3405 /* Take care of possible partial on last chunk */
3406 ips_fill_scb_sg_single(ha
,
3409 scb
, ips_sg_index
++,
3413 for (; sg_dma_index
< scb
->sg_count
;
3415 if (ips_fill_scb_sg_single
3417 sg_dma_address(&sg
[sg_dma_index
]),
3418 scb
, ips_sg_index
++,
3419 sg_dma_len(&sg
[sg_dma_index
])) < 0)
3425 /* Non S/G Request */
3426 (void) ips_fill_scb_sg_single(ha
,
3438 scb
->dcdb
.transfer_length
= scb
->data_len
;
3439 scb
->dcdb
.cmd_attribute
|=
3440 ips_command_direction
[scb
->scsi_cmd
->cmnd
[0]];
3442 if (!(scb
->dcdb
.cmd_attribute
& 0x3))
3443 scb
->dcdb
.transfer_length
= 0;
3445 if (scb
->data_len
>= IPS_MAX_XFER
) {
3446 scb
->dcdb
.cmd_attribute
|= IPS_TRANSFER64K
;
3447 scb
->dcdb
.transfer_length
= 0;
3450 ret
= ips_send_cmd(ha
, scb
);
3454 if (scb
->scsi_cmd
) {
3455 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
3456 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
3459 ips_freescb(ha
, scb
);
3461 case IPS_SUCCESS_IMM
:
3462 if (scb
->scsi_cmd
) {
3463 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
3464 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
3467 ips_freescb(ha
, scb
);
3475 } /* end if passthru */
3478 ha
->dcdb_active
[scb
->bus
- 1] &= ~(1 << scb
->target_id
);
3481 scb
->scsi_cmd
->scsi_done(scb
->scsi_cmd
);
3483 ips_freescb(ha
, scb
);
3486 /****************************************************************************/
3488 /* Routine Name: ips_map_status */
3490 /* Routine Description: */
3492 /* Map Controller Error codes to Linux Error Codes */
3494 /****************************************************************************/
3496 ips_map_status(ips_ha_t
* ha
, ips_scb_t
* scb
, ips_stat_t
* sp
)
3500 uint32_t transfer_len
;
3501 IPS_DCDB_TABLE_TAPE
*tapeDCDB
;
3503 METHOD_TRACE("ips_map_status", 1);
3507 "(%s%d) Physical device error (%d %d %d): %x %x, Sense Key: %x, ASC: %x, ASCQ: %x",
3508 ips_name
, ha
->host_num
,
3509 scb
->scsi_cmd
->device
->channel
,
3510 scb
->scsi_cmd
->device
->id
, scb
->scsi_cmd
->device
->lun
,
3511 scb
->basic_status
, scb
->extended_status
,
3512 scb
->extended_status
==
3513 IPS_ERR_CKCOND
? scb
->dcdb
.sense_info
[2] & 0xf : 0,
3514 scb
->extended_status
==
3515 IPS_ERR_CKCOND
? scb
->dcdb
.sense_info
[12] : 0,
3516 scb
->extended_status
==
3517 IPS_ERR_CKCOND
? scb
->dcdb
.sense_info
[13] : 0);
3520 /* default driver error */
3521 errcode
= DID_ERROR
;
3524 switch (scb
->basic_status
& IPS_GSC_STATUS_MASK
) {
3525 case IPS_CMD_TIMEOUT
:
3526 errcode
= DID_TIME_OUT
;
3529 case IPS_INVAL_OPCO
:
3530 case IPS_INVAL_CMD_BLK
:
3531 case IPS_INVAL_PARM_BLK
:
3533 case IPS_CMD_CMPLT_WERROR
:
3536 case IPS_PHYS_DRV_ERROR
:
3537 switch (scb
->extended_status
) {
3538 case IPS_ERR_SEL_TO
:
3540 errcode
= DID_NO_CONNECT
;
3544 case IPS_ERR_OU_RUN
:
3545 if ((scb
->cmd
.dcdb
.op_code
== IPS_CMD_EXTENDED_DCDB
) ||
3546 (scb
->cmd
.dcdb
.op_code
==
3547 IPS_CMD_EXTENDED_DCDB_SG
)) {
3548 tapeDCDB
= (IPS_DCDB_TABLE_TAPE
*) & scb
->dcdb
;
3549 transfer_len
= tapeDCDB
->transfer_length
;
3552 (uint32_t) scb
->dcdb
.transfer_length
;
3555 if ((scb
->bus
) && (transfer_len
< scb
->data_len
)) {
3556 /* Underrun - set default to no error */
3559 /* Restrict access to physical DASD */
3560 if ((scb
->scsi_cmd
->cmnd
[0] == INQUIRY
) &&
3561 ((((char *) scb
->scsi_cmd
->
3562 buffer
)[0] & 0x1f) == TYPE_DISK
)) {
3563 /* underflow -- no error */
3564 /* restrict access to physical DASD */
3565 errcode
= DID_TIME_OUT
;
3569 errcode
= DID_ERROR
;
3573 case IPS_ERR_RECOVERY
:
3574 /* don't fail recovered errors */
3580 case IPS_ERR_HOST_RESET
:
3581 case IPS_ERR_DEV_RESET
:
3582 errcode
= DID_RESET
;
3585 case IPS_ERR_CKCOND
:
3587 if ((scb
->cmd
.dcdb
.op_code
==
3588 IPS_CMD_EXTENDED_DCDB
)
3589 || (scb
->cmd
.dcdb
.op_code
==
3590 IPS_CMD_EXTENDED_DCDB_SG
)) {
3592 (IPS_DCDB_TABLE_TAPE
*) & scb
->dcdb
;
3593 memcpy(scb
->scsi_cmd
->sense_buffer
,
3594 tapeDCDB
->sense_info
,
3595 sizeof (scb
->scsi_cmd
->
3598 memcpy(scb
->scsi_cmd
->sense_buffer
,
3599 scb
->dcdb
.sense_info
,
3600 sizeof (scb
->scsi_cmd
->
3603 device_error
= 2; /* check condition */
3611 errcode
= DID_ERROR
;
3617 scb
->scsi_cmd
->result
= device_error
| (errcode
<< 16);
3622 /****************************************************************************/
3624 /* Routine Name: ips_send_wait */
3626 /* Routine Description: */
3628 /* Send a command to the controller and wait for it to return */
3630 /* The FFDC Time Stamp use this function for the callback, but doesn't */
3631 /* actually need to wait. */
3632 /****************************************************************************/
3634 ips_send_wait(ips_ha_t
* ha
, ips_scb_t
* scb
, int timeout
, int intr
)
3638 METHOD_TRACE("ips_send_wait", 1);
3640 if (intr
!= IPS_FFDC
) { /* Won't be Waiting if this is a Time Stamp */
3641 ha
->waitflag
= TRUE
;
3642 ha
->cmd_in_progress
= scb
->cdb
[0];
3644 scb
->callback
= ipsintr_blocking
;
3645 ret
= ips_send_cmd(ha
, scb
);
3647 if ((ret
== IPS_FAILURE
) || (ret
== IPS_SUCCESS_IMM
))
3650 if (intr
!= IPS_FFDC
) /* Don't Wait around if this is a Time Stamp */
3651 ret
= ips_wait(ha
, timeout
, intr
);
3656 /****************************************************************************/
3658 /* Routine Name: ips_scmd_buf_write */
3660 /* Routine Description: */
3661 /* Write data to Scsi_Cmnd request_buffer at proper offsets */
3662 /****************************************************************************/
3664 ips_scmd_buf_write(Scsi_Cmnd
* scmd
, void *data
, unsigned
3669 unsigned int min_cnt
, xfer_cnt
;
3670 char *cdata
= (char *) data
;
3671 unsigned char *buffer
;
3672 unsigned long flags
;
3673 struct scatterlist
*sg
= scmd
->request_buffer
;
3674 for (i
= 0, xfer_cnt
= 0;
3675 (i
< scmd
->use_sg
) && (xfer_cnt
< count
); i
++) {
3676 min_cnt
= min(count
- xfer_cnt
, sg
[i
].length
);
3678 /* kmap_atomic() ensures addressability of the data buffer.*/
3679 /* local_irq_save() protects the KM_IRQ0 address slot. */
3680 local_irq_save(flags
);
3681 buffer
= kmap_atomic(sg
[i
].page
, KM_IRQ0
) + sg
[i
].offset
;
3682 memcpy(buffer
, &cdata
[xfer_cnt
], min_cnt
);
3683 kunmap_atomic(buffer
- sg
[i
].offset
, KM_IRQ0
);
3684 local_irq_restore(flags
);
3686 xfer_cnt
+= min_cnt
;
3690 unsigned int min_cnt
= min(count
, scmd
->request_bufflen
);
3691 memcpy(scmd
->request_buffer
, data
, min_cnt
);
3695 /****************************************************************************/
3697 /* Routine Name: ips_scmd_buf_read */
3699 /* Routine Description: */
3700 /* Copy data from a Scsi_Cmnd to a new, linear buffer */
3701 /****************************************************************************/
3703 ips_scmd_buf_read(Scsi_Cmnd
* scmd
, void *data
, unsigned
3708 unsigned int min_cnt
, xfer_cnt
;
3709 char *cdata
= (char *) data
;
3710 unsigned char *buffer
;
3711 unsigned long flags
;
3712 struct scatterlist
*sg
= scmd
->request_buffer
;
3713 for (i
= 0, xfer_cnt
= 0;
3714 (i
< scmd
->use_sg
) && (xfer_cnt
< count
); i
++) {
3715 min_cnt
= min(count
- xfer_cnt
, sg
[i
].length
);
3717 /* kmap_atomic() ensures addressability of the data buffer.*/
3718 /* local_irq_save() protects the KM_IRQ0 address slot. */
3719 local_irq_save(flags
);
3720 buffer
= kmap_atomic(sg
[i
].page
, KM_IRQ0
) + sg
[i
].offset
;
3721 memcpy(&cdata
[xfer_cnt
], buffer
, min_cnt
);
3722 kunmap_atomic(buffer
- sg
[i
].offset
, KM_IRQ0
);
3723 local_irq_restore(flags
);
3725 xfer_cnt
+= min_cnt
;
3729 unsigned int min_cnt
= min(count
, scmd
->request_bufflen
);
3730 memcpy(data
, scmd
->request_buffer
, min_cnt
);
3734 /****************************************************************************/
3736 /* Routine Name: ips_send_cmd */
3738 /* Routine Description: */
3740 /* Map SCSI commands to ServeRAID commands for logical drives */
3742 /****************************************************************************/
3744 ips_send_cmd(ips_ha_t
* ha
, ips_scb_t
* scb
)
3749 IPS_DCDB_TABLE_TAPE
*tapeDCDB
;
3752 METHOD_TRACE("ips_send_cmd", 1);
3756 if (!scb
->scsi_cmd
) {
3757 /* internal command */
3760 /* Controller commands can't be issued */
3761 /* to real devices -- fail them */
3762 if ((ha
->waitflag
== TRUE
) &&
3763 (ha
->cmd_in_progress
== scb
->cdb
[0])) {
3764 ha
->waitflag
= FALSE
;
3769 } else if ((scb
->bus
== 0) && (!ips_is_passthru(scb
->scsi_cmd
))) {
3770 /* command to logical bus -- interpret */
3771 ret
= IPS_SUCCESS_IMM
;
3773 switch (scb
->scsi_cmd
->cmnd
[0]) {
3774 case ALLOW_MEDIUM_REMOVAL
:
3777 case WRITE_FILEMARKS
:
3779 scb
->scsi_cmd
->result
= DID_ERROR
<< 16;
3783 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3785 case TEST_UNIT_READY
:
3787 if (scb
->target_id
== IPS_ADAPTER_ID
) {
3789 * Either we have a TUR
3790 * or we have a SCSI inquiry
3792 if (scb
->scsi_cmd
->cmnd
[0] == TEST_UNIT_READY
)
3793 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3795 if (scb
->scsi_cmd
->cmnd
[0] == INQUIRY
) {
3796 IPS_SCSI_INQ_DATA inquiry
;
3799 sizeof (IPS_SCSI_INQ_DATA
));
3801 inquiry
.DeviceType
=
3802 IPS_SCSI_INQ_TYPE_PROCESSOR
;
3803 inquiry
.DeviceTypeQualifier
=
3804 IPS_SCSI_INQ_LU_CONNECTED
;
3805 inquiry
.Version
= IPS_SCSI_INQ_REV2
;
3806 inquiry
.ResponseDataFormat
=
3807 IPS_SCSI_INQ_RD_REV2
;
3808 inquiry
.AdditionalLength
= 31;
3810 IPS_SCSI_INQ_Address16
;
3812 IPS_SCSI_INQ_WBus16
|
3814 strncpy(inquiry
.VendorId
, "IBM ",
3816 strncpy(inquiry
.ProductId
,
3818 strncpy(inquiry
.ProductRevisionLevel
,
3821 ips_scmd_buf_write(scb
->scsi_cmd
,
3825 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3828 scb
->cmd
.logical_info
.op_code
= IPS_CMD_GET_LD_INFO
;
3829 scb
->cmd
.logical_info
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3830 scb
->cmd
.logical_info
.reserved
= 0;
3831 scb
->cmd
.logical_info
.reserved2
= 0;
3832 scb
->data_len
= sizeof (IPS_LD_INFO
);
3833 scb
->data_busaddr
= ha
->logical_drive_info_dma_addr
;
3835 scb
->cmd
.logical_info
.buffer_addr
= scb
->data_busaddr
;
3842 ips_reqsen(ha
, scb
);
3843 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3849 scb
->cmd
.basic_io
.op_code
=
3850 (scb
->scsi_cmd
->cmnd
[0] ==
3851 READ_6
) ? IPS_CMD_READ
: IPS_CMD_WRITE
;
3852 scb
->cmd
.basic_io
.enhanced_sg
= 0;
3853 scb
->cmd
.basic_io
.sg_addr
=
3854 cpu_to_le32(scb
->data_busaddr
);
3856 scb
->cmd
.basic_io
.op_code
=
3857 (scb
->scsi_cmd
->cmnd
[0] ==
3858 READ_6
) ? IPS_CMD_READ_SG
:
3860 scb
->cmd
.basic_io
.enhanced_sg
=
3861 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
3862 scb
->cmd
.basic_io
.sg_addr
=
3863 cpu_to_le32(scb
->sg_busaddr
);
3866 scb
->cmd
.basic_io
.segment_4G
= 0;
3867 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3868 scb
->cmd
.basic_io
.log_drv
= scb
->target_id
;
3869 scb
->cmd
.basic_io
.sg_count
= scb
->sg_len
;
3871 if (scb
->cmd
.basic_io
.lba
)
3872 scb
->cmd
.basic_io
.lba
=
3873 cpu_to_le32(le32_to_cpu
3874 (scb
->cmd
.basic_io
.lba
) +
3875 le16_to_cpu(scb
->cmd
.basic_io
.
3878 scb
->cmd
.basic_io
.lba
=
3880 cmnd
[1] & 0x1f) << 16) | (scb
->scsi_cmd
->
3882 (scb
->scsi_cmd
->cmnd
[3]));
3884 scb
->cmd
.basic_io
.sector_count
=
3885 cpu_to_le16(scb
->data_len
/ IPS_BLKSIZE
);
3887 if (le16_to_cpu(scb
->cmd
.basic_io
.sector_count
) == 0)
3888 scb
->cmd
.basic_io
.sector_count
=
3897 scb
->cmd
.basic_io
.op_code
=
3898 (scb
->scsi_cmd
->cmnd
[0] ==
3899 READ_10
) ? IPS_CMD_READ
: IPS_CMD_WRITE
;
3900 scb
->cmd
.basic_io
.enhanced_sg
= 0;
3901 scb
->cmd
.basic_io
.sg_addr
=
3902 cpu_to_le32(scb
->data_busaddr
);
3904 scb
->cmd
.basic_io
.op_code
=
3905 (scb
->scsi_cmd
->cmnd
[0] ==
3906 READ_10
) ? IPS_CMD_READ_SG
:
3908 scb
->cmd
.basic_io
.enhanced_sg
=
3909 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
3910 scb
->cmd
.basic_io
.sg_addr
=
3911 cpu_to_le32(scb
->sg_busaddr
);
3914 scb
->cmd
.basic_io
.segment_4G
= 0;
3915 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3916 scb
->cmd
.basic_io
.log_drv
= scb
->target_id
;
3917 scb
->cmd
.basic_io
.sg_count
= scb
->sg_len
;
3919 if (scb
->cmd
.basic_io
.lba
)
3920 scb
->cmd
.basic_io
.lba
=
3921 cpu_to_le32(le32_to_cpu
3922 (scb
->cmd
.basic_io
.lba
) +
3923 le16_to_cpu(scb
->cmd
.basic_io
.
3926 scb
->cmd
.basic_io
.lba
=
3927 ((scb
->scsi_cmd
->cmnd
[2] << 24) | (scb
->
3931 (scb
->scsi_cmd
->cmnd
[4] << 8) | scb
->
3934 scb
->cmd
.basic_io
.sector_count
=
3935 cpu_to_le16(scb
->data_len
/ IPS_BLKSIZE
);
3937 if (cpu_to_le16(scb
->cmd
.basic_io
.sector_count
) == 0) {
3939 * This is a null condition
3940 * we don't have to do anything
3943 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3951 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3955 scb
->cmd
.basic_io
.op_code
= IPS_CMD_ENQUIRY
;
3956 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3957 scb
->cmd
.basic_io
.segment_4G
= 0;
3958 scb
->cmd
.basic_io
.enhanced_sg
= 0;
3959 scb
->data_len
= sizeof (*ha
->enq
);
3960 scb
->cmd
.basic_io
.sg_addr
= ha
->enq_busaddr
;
3965 scb
->cmd
.logical_info
.op_code
= IPS_CMD_GET_LD_INFO
;
3966 scb
->cmd
.logical_info
.command_id
= IPS_COMMAND_ID(ha
, scb
);
3967 scb
->cmd
.logical_info
.reserved
= 0;
3968 scb
->cmd
.logical_info
.reserved2
= 0;
3969 scb
->cmd
.logical_info
.reserved3
= 0;
3970 scb
->data_len
= sizeof (IPS_LD_INFO
);
3971 scb
->data_busaddr
= ha
->logical_drive_info_dma_addr
;
3973 scb
->cmd
.logical_info
.buffer_addr
= scb
->data_busaddr
;
3977 case SEND_DIAGNOSTIC
:
3978 case REASSIGN_BLOCKS
:
3982 case READ_DEFECT_DATA
:
3985 scb
->scsi_cmd
->result
= DID_OK
<< 16;
3989 /* Set the Return Info to appear like the Command was */
3990 /* attempted, a Check Condition occurred, and Sense */
3991 /* Data indicating an Invalid CDB OpCode is returned. */
3992 sp
= (char *) scb
->scsi_cmd
->sense_buffer
;
3993 memset(sp
, 0, sizeof (scb
->scsi_cmd
->sense_buffer
));
3995 sp
[0] = 0x70; /* Error Code */
3996 sp
[2] = ILLEGAL_REQUEST
; /* Sense Key 5 Illegal Req. */
3997 sp
[7] = 0x0A; /* Additional Sense Length */
3998 sp
[12] = 0x20; /* ASC = Invalid OpCode */
3999 sp
[13] = 0x00; /* ASCQ */
4001 device_error
= 2; /* Indicate Check Condition */
4002 scb
->scsi_cmd
->result
= device_error
| (DID_OK
<< 16);
4007 if (ret
== IPS_SUCCESS_IMM
)
4013 /* If we already know the Device is Not there, no need to attempt a Command */
4014 /* This also protects an NT FailOver Controller from getting CDB's sent to it */
4015 if (ha
->conf
->dev
[scb
->bus
- 1][scb
->target_id
].ucState
== 0) {
4016 scb
->scsi_cmd
->result
= DID_NO_CONNECT
<< 16;
4017 return (IPS_SUCCESS_IMM
);
4020 ha
->dcdb_active
[scb
->bus
- 1] |= (1 << scb
->target_id
);
4021 scb
->cmd
.dcdb
.command_id
= IPS_COMMAND_ID(ha
, scb
);
4022 scb
->cmd
.dcdb
.dcdb_address
= cpu_to_le32(scb
->scb_busaddr
+
4023 (unsigned long) &scb
->
4025 (unsigned long) scb
);
4026 scb
->cmd
.dcdb
.reserved
= 0;
4027 scb
->cmd
.dcdb
.reserved2
= 0;
4028 scb
->cmd
.dcdb
.reserved3
= 0;
4029 scb
->cmd
.dcdb
.segment_4G
= 0;
4030 scb
->cmd
.dcdb
.enhanced_sg
= 0;
4032 TimeOut
= scb
->scsi_cmd
->timeout_per_command
;
4034 if (ha
->subsys
->param
[4] & 0x00100000) { /* If NEW Tape DCDB is Supported */
4036 scb
->cmd
.dcdb
.op_code
= IPS_CMD_EXTENDED_DCDB
;
4038 scb
->cmd
.dcdb
.op_code
=
4039 IPS_CMD_EXTENDED_DCDB_SG
;
4040 scb
->cmd
.dcdb
.enhanced_sg
=
4041 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
4044 tapeDCDB
= (IPS_DCDB_TABLE_TAPE
*) & scb
->dcdb
; /* Use Same Data Area as Old DCDB Struct */
4045 tapeDCDB
->device_address
=
4046 ((scb
->bus
- 1) << 4) | scb
->target_id
;
4047 tapeDCDB
->cmd_attribute
|= IPS_DISCONNECT_ALLOWED
;
4048 tapeDCDB
->cmd_attribute
&= ~IPS_TRANSFER64K
; /* Always Turn OFF 64K Size Flag */
4051 if (TimeOut
< (10 * HZ
))
4052 tapeDCDB
->cmd_attribute
|= IPS_TIMEOUT10
; /* TimeOut is 10 Seconds */
4053 else if (TimeOut
< (60 * HZ
))
4054 tapeDCDB
->cmd_attribute
|= IPS_TIMEOUT60
; /* TimeOut is 60 Seconds */
4055 else if (TimeOut
< (1200 * HZ
))
4056 tapeDCDB
->cmd_attribute
|= IPS_TIMEOUT20M
; /* TimeOut is 20 Minutes */
4059 tapeDCDB
->cdb_length
= scb
->scsi_cmd
->cmd_len
;
4060 tapeDCDB
->reserved_for_LUN
= 0;
4061 tapeDCDB
->transfer_length
= scb
->data_len
;
4062 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_EXTENDED_DCDB_SG
)
4063 tapeDCDB
->buffer_pointer
=
4064 cpu_to_le32(scb
->sg_busaddr
);
4066 tapeDCDB
->buffer_pointer
=
4067 cpu_to_le32(scb
->data_busaddr
);
4068 tapeDCDB
->sg_count
= scb
->sg_len
;
4069 tapeDCDB
->sense_length
= sizeof (tapeDCDB
->sense_info
);
4070 tapeDCDB
->scsi_status
= 0;
4071 tapeDCDB
->reserved
= 0;
4072 memcpy(tapeDCDB
->scsi_cdb
, scb
->scsi_cmd
->cmnd
,
4073 scb
->scsi_cmd
->cmd_len
);
4076 scb
->cmd
.dcdb
.op_code
= IPS_CMD_DCDB
;
4078 scb
->cmd
.dcdb
.op_code
= IPS_CMD_DCDB_SG
;
4079 scb
->cmd
.dcdb
.enhanced_sg
=
4080 IPS_USE_ENH_SGLIST(ha
) ? 0xFF : 0;
4083 scb
->dcdb
.device_address
=
4084 ((scb
->bus
- 1) << 4) | scb
->target_id
;
4085 scb
->dcdb
.cmd_attribute
|= IPS_DISCONNECT_ALLOWED
;
4088 if (TimeOut
< (10 * HZ
))
4089 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT10
; /* TimeOut is 10 Seconds */
4090 else if (TimeOut
< (60 * HZ
))
4091 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT60
; /* TimeOut is 60 Seconds */
4092 else if (TimeOut
< (1200 * HZ
))
4093 scb
->dcdb
.cmd_attribute
|= IPS_TIMEOUT20M
; /* TimeOut is 20 Minutes */
4096 scb
->dcdb
.transfer_length
= scb
->data_len
;
4097 if (scb
->dcdb
.cmd_attribute
& IPS_TRANSFER64K
)
4098 scb
->dcdb
.transfer_length
= 0;
4099 if (scb
->cmd
.dcdb
.op_code
== IPS_CMD_DCDB_SG
)
4100 scb
->dcdb
.buffer_pointer
=
4101 cpu_to_le32(scb
->sg_busaddr
);
4103 scb
->dcdb
.buffer_pointer
=
4104 cpu_to_le32(scb
->data_busaddr
);
4105 scb
->dcdb
.cdb_length
= scb
->scsi_cmd
->cmd_len
;
4106 scb
->dcdb
.sense_length
= sizeof (scb
->dcdb
.sense_info
);
4107 scb
->dcdb
.sg_count
= scb
->sg_len
;
4108 scb
->dcdb
.reserved
= 0;
4109 memcpy(scb
->dcdb
.scsi_cdb
, scb
->scsi_cmd
->cmnd
,
4110 scb
->scsi_cmd
->cmd_len
);
4111 scb
->dcdb
.scsi_status
= 0;
4112 scb
->dcdb
.reserved2
[0] = 0;
4113 scb
->dcdb
.reserved2
[1] = 0;
4114 scb
->dcdb
.reserved2
[2] = 0;
4118 return ((*ha
->func
.issue
) (ha
, scb
));
4121 /****************************************************************************/
4123 /* Routine Name: ips_chk_status */
4125 /* Routine Description: */
4127 /* Check the status of commands to logical drives */
4128 /* Assumed to be called with the HA lock */
4129 /****************************************************************************/
4131 ips_chkstatus(ips_ha_t
* ha
, IPS_STATUS
* pstatus
)
4135 uint8_t basic_status
;
4139 METHOD_TRACE("ips_chkstatus", 1);
4141 scb
= &ha
->scbs
[pstatus
->fields
.command_id
];
4142 scb
->basic_status
= basic_status
=
4143 pstatus
->fields
.basic_status
& IPS_BASIC_STATUS_MASK
;
4144 scb
->extended_status
= ext_status
= pstatus
->fields
.extended_status
;
4147 sp
->residue_len
= 0;
4148 sp
->scb_addr
= (void *) scb
;
4150 /* Remove the item from the active queue */
4151 ips_removeq_scb(&ha
->scb_activelist
, scb
);
4154 /* internal commands are handled in do_ipsintr */
4157 DEBUG_VAR(2, "(%s%d) ips_chkstatus: cmd 0x%X id %d (%d %d %d)",
4161 scb
->cmd
.basic_io
.command_id
,
4162 scb
->bus
, scb
->target_id
, scb
->lun
);
4164 if ((scb
->scsi_cmd
) && (ips_is_passthru(scb
->scsi_cmd
)))
4165 /* passthru - just returns the raw result */
4170 if (((basic_status
& IPS_GSC_STATUS_MASK
) == IPS_CMD_SUCCESS
) ||
4171 ((basic_status
& IPS_GSC_STATUS_MASK
) == IPS_CMD_RECOVERED_ERROR
)) {
4173 if (scb
->bus
== 0) {
4174 if ((basic_status
& IPS_GSC_STATUS_MASK
) ==
4175 IPS_CMD_RECOVERED_ERROR
) {
4177 "(%s%d) Recovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4178 ips_name
, ha
->host_num
,
4179 scb
->cmd
.basic_io
.op_code
,
4180 basic_status
, ext_status
);
4183 switch (scb
->scsi_cmd
->cmnd
[0]) {
4184 case ALLOW_MEDIUM_REMOVAL
:
4187 case WRITE_FILEMARKS
:
4189 errcode
= DID_ERROR
;
4195 case TEST_UNIT_READY
:
4196 if (!ips_online(ha
, scb
)) {
4197 errcode
= DID_TIME_OUT
;
4202 if (ips_online(ha
, scb
)) {
4203 ips_inquiry(ha
, scb
);
4205 errcode
= DID_TIME_OUT
;
4210 ips_reqsen(ha
, scb
);
4222 if (!ips_online(ha
, scb
)
4223 || !ips_msense(ha
, scb
)) {
4224 errcode
= DID_ERROR
;
4229 if (ips_online(ha
, scb
))
4232 errcode
= DID_TIME_OUT
;
4236 case SEND_DIAGNOSTIC
:
4237 case REASSIGN_BLOCKS
:
4241 errcode
= DID_ERROR
;
4246 case READ_DEFECT_DATA
:
4252 errcode
= DID_ERROR
;
4255 scb
->scsi_cmd
->result
= errcode
<< 16;
4256 } else { /* bus == 0 */
4257 /* restrict access to physical drives */
4258 if ((scb
->scsi_cmd
->cmnd
[0] == INQUIRY
) &&
4259 ((((char *) scb
->scsi_cmd
->buffer
)[0] & 0x1f) ==
4262 scb
->scsi_cmd
->result
= DID_TIME_OUT
<< 16;
4265 } else { /* recovered error / success */
4266 if (scb
->bus
== 0) {
4268 "(%s%d) Unrecovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4269 ips_name
, ha
->host_num
,
4270 scb
->cmd
.basic_io
.op_code
, basic_status
,
4274 ips_map_status(ha
, scb
, sp
);
4278 /****************************************************************************/
4280 /* Routine Name: ips_online */
4282 /* Routine Description: */
4284 /* Determine if a logical drive is online */
4286 /****************************************************************************/
4288 ips_online(ips_ha_t
* ha
, ips_scb_t
* scb
)
4290 METHOD_TRACE("ips_online", 1);
4292 if (scb
->target_id
>= IPS_MAX_LD
)
4295 if ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1) {
4296 memset(ha
->logical_drive_info
, 0, sizeof (IPS_LD_INFO
));
4300 if (ha
->logical_drive_info
->drive_info
[scb
->target_id
].state
!=
4302 && ha
->logical_drive_info
->drive_info
[scb
->target_id
].state
!=
4304 && ha
->logical_drive_info
->drive_info
[scb
->target_id
].state
!=
4306 && ha
->logical_drive_info
->drive_info
[scb
->target_id
].state
!=
4313 /****************************************************************************/
4315 /* Routine Name: ips_inquiry */
4317 /* Routine Description: */
4319 /* Simulate an inquiry command to a logical drive */
4321 /****************************************************************************/
4323 ips_inquiry(ips_ha_t
* ha
, ips_scb_t
* scb
)
4325 IPS_SCSI_INQ_DATA inquiry
;
4327 METHOD_TRACE("ips_inquiry", 1);
4329 memset(&inquiry
, 0, sizeof (IPS_SCSI_INQ_DATA
));
4331 inquiry
.DeviceType
= IPS_SCSI_INQ_TYPE_DASD
;
4332 inquiry
.DeviceTypeQualifier
= IPS_SCSI_INQ_LU_CONNECTED
;
4333 inquiry
.Version
= IPS_SCSI_INQ_REV2
;
4334 inquiry
.ResponseDataFormat
= IPS_SCSI_INQ_RD_REV2
;
4335 inquiry
.AdditionalLength
= 31;
4336 inquiry
.Flags
[0] = IPS_SCSI_INQ_Address16
;
4338 IPS_SCSI_INQ_WBus16
| IPS_SCSI_INQ_Sync
| IPS_SCSI_INQ_CmdQue
;
4339 strncpy(inquiry
.VendorId
, "IBM ", 8);
4340 strncpy(inquiry
.ProductId
, "SERVERAID ", 16);
4341 strncpy(inquiry
.ProductRevisionLevel
, "1.00", 4);
4343 ips_scmd_buf_write(scb
->scsi_cmd
, &inquiry
, sizeof (inquiry
));
4348 /****************************************************************************/
4350 /* Routine Name: ips_rdcap */
4352 /* Routine Description: */
4354 /* Simulate a read capacity command to a logical drive */
4356 /****************************************************************************/
4358 ips_rdcap(ips_ha_t
* ha
, ips_scb_t
* scb
)
4360 IPS_SCSI_CAPACITY cap
;
4362 METHOD_TRACE("ips_rdcap", 1);
4364 if (scb
->scsi_cmd
->bufflen
< 8)
4368 cpu_to_be32(le32_to_cpu
4369 (ha
->logical_drive_info
->
4370 drive_info
[scb
->target_id
].sector_count
) - 1);
4371 cap
.len
= cpu_to_be32((uint32_t) IPS_BLKSIZE
);
4373 ips_scmd_buf_write(scb
->scsi_cmd
, &cap
, sizeof (cap
));
4378 /****************************************************************************/
4380 /* Routine Name: ips_msense */
4382 /* Routine Description: */
4384 /* Simulate a mode sense command to a logical drive */
4386 /****************************************************************************/
4388 ips_msense(ips_ha_t
* ha
, ips_scb_t
* scb
)
4393 IPS_SCSI_MODE_PAGE_DATA mdata
;
4395 METHOD_TRACE("ips_msense", 1);
4397 if (le32_to_cpu(ha
->enq
->ulDriveSize
[scb
->target_id
]) > 0x400000 &&
4398 (ha
->enq
->ucMiscFlag
& 0x8) == 0) {
4399 heads
= IPS_NORM_HEADS
;
4400 sectors
= IPS_NORM_SECTORS
;
4402 heads
= IPS_COMP_HEADS
;
4403 sectors
= IPS_COMP_SECTORS
;
4407 (le32_to_cpu(ha
->enq
->ulDriveSize
[scb
->target_id
]) -
4408 1) / (heads
* sectors
);
4410 memset(&mdata
, 0, sizeof (IPS_SCSI_MODE_PAGE_DATA
));
4412 mdata
.hdr
.BlockDescLength
= 8;
4414 switch (scb
->scsi_cmd
->cmnd
[2] & 0x3f) {
4415 case 0x03: /* page 3 */
4416 mdata
.pdata
.pg3
.PageCode
= 3;
4417 mdata
.pdata
.pg3
.PageLength
= sizeof (IPS_SCSI_MODE_PAGE3
);
4418 mdata
.hdr
.DataLength
=
4419 3 + mdata
.hdr
.BlockDescLength
+ mdata
.pdata
.pg3
.PageLength
;
4420 mdata
.pdata
.pg3
.TracksPerZone
= 0;
4421 mdata
.pdata
.pg3
.AltSectorsPerZone
= 0;
4422 mdata
.pdata
.pg3
.AltTracksPerZone
= 0;
4423 mdata
.pdata
.pg3
.AltTracksPerVolume
= 0;
4424 mdata
.pdata
.pg3
.SectorsPerTrack
= cpu_to_be16(sectors
);
4425 mdata
.pdata
.pg3
.BytesPerSector
= cpu_to_be16(IPS_BLKSIZE
);
4426 mdata
.pdata
.pg3
.Interleave
= cpu_to_be16(1);
4427 mdata
.pdata
.pg3
.TrackSkew
= 0;
4428 mdata
.pdata
.pg3
.CylinderSkew
= 0;
4429 mdata
.pdata
.pg3
.flags
= IPS_SCSI_MP3_SoftSector
;
4433 mdata
.pdata
.pg4
.PageCode
= 4;
4434 mdata
.pdata
.pg4
.PageLength
= sizeof (IPS_SCSI_MODE_PAGE4
);
4435 mdata
.hdr
.DataLength
=
4436 3 + mdata
.hdr
.BlockDescLength
+ mdata
.pdata
.pg4
.PageLength
;
4437 mdata
.pdata
.pg4
.CylindersHigh
=
4438 cpu_to_be16((cylinders
>> 8) & 0xFFFF);
4439 mdata
.pdata
.pg4
.CylindersLow
= (cylinders
& 0xFF);
4440 mdata
.pdata
.pg4
.Heads
= heads
;
4441 mdata
.pdata
.pg4
.WritePrecompHigh
= 0;
4442 mdata
.pdata
.pg4
.WritePrecompLow
= 0;
4443 mdata
.pdata
.pg4
.ReducedWriteCurrentHigh
= 0;
4444 mdata
.pdata
.pg4
.ReducedWriteCurrentLow
= 0;
4445 mdata
.pdata
.pg4
.StepRate
= cpu_to_be16(1);
4446 mdata
.pdata
.pg4
.LandingZoneHigh
= 0;
4447 mdata
.pdata
.pg4
.LandingZoneLow
= 0;
4448 mdata
.pdata
.pg4
.flags
= 0;
4449 mdata
.pdata
.pg4
.RotationalOffset
= 0;
4450 mdata
.pdata
.pg4
.MediumRotationRate
= 0;
4453 mdata
.pdata
.pg8
.PageCode
= 8;
4454 mdata
.pdata
.pg8
.PageLength
= sizeof (IPS_SCSI_MODE_PAGE8
);
4455 mdata
.hdr
.DataLength
=
4456 3 + mdata
.hdr
.BlockDescLength
+ mdata
.pdata
.pg8
.PageLength
;
4457 /* everything else is left set to 0 */
4464 ips_scmd_buf_write(scb
->scsi_cmd
, &mdata
, sizeof (mdata
));
4469 /****************************************************************************/
4471 /* Routine Name: ips_reqsen */
4473 /* Routine Description: */
4475 /* Simulate a request sense command to a logical drive */
4477 /****************************************************************************/
4479 ips_reqsen(ips_ha_t
* ha
, ips_scb_t
* scb
)
4481 IPS_SCSI_REQSEN reqsen
;
4483 METHOD_TRACE("ips_reqsen", 1);
4485 memset(&reqsen
, 0, sizeof (IPS_SCSI_REQSEN
));
4487 reqsen
.ResponseCode
=
4488 IPS_SCSI_REQSEN_VALID
| IPS_SCSI_REQSEN_CURRENT_ERR
;
4489 reqsen
.AdditionalLength
= 10;
4490 reqsen
.AdditionalSenseCode
= IPS_SCSI_REQSEN_NO_SENSE
;
4491 reqsen
.AdditionalSenseCodeQual
= IPS_SCSI_REQSEN_NO_SENSE
;
4493 ips_scmd_buf_write(scb
->scsi_cmd
, &reqsen
, sizeof (reqsen
));
4498 /****************************************************************************/
4500 /* Routine Name: ips_free */
4502 /* Routine Description: */
4504 /* Free any allocated space for this controller */
4506 /****************************************************************************/
4508 ips_free(ips_ha_t
* ha
)
4511 METHOD_TRACE("ips_free", 1);
4515 pci_free_consistent(ha
->pcidev
, sizeof(IPS_ENQ
),
4516 ha
->enq
, ha
->enq_busaddr
);
4526 pci_free_consistent(ha
->pcidev
,
4527 sizeof (IPS_ADAPTER
) +
4528 sizeof (IPS_IO_CMD
), ha
->adapt
,
4529 ha
->adapt
->hw_status_start
);
4533 if (ha
->logical_drive_info
) {
4534 pci_free_consistent(ha
->pcidev
,
4535 sizeof (IPS_LD_INFO
),
4536 ha
->logical_drive_info
,
4537 ha
->logical_drive_info_dma_addr
);
4538 ha
->logical_drive_info
= NULL
;
4551 if (ha
->ioctl_data
) {
4552 pci_free_consistent(ha
->pcidev
, ha
->ioctl_len
,
4553 ha
->ioctl_data
, ha
->ioctl_busaddr
);
4554 ha
->ioctl_data
= NULL
;
4555 ha
->ioctl_datasize
= 0;
4558 ips_deallocatescbs(ha
, ha
->max_cmds
);
4560 /* free memory mapped (if applicable) */
4562 iounmap(ha
->ioremap_ptr
);
4563 ha
->ioremap_ptr
= NULL
;
4568 release_mem_region(ha
->mem_addr
, ha
->mem_len
);
4574 /****************************************************************************/
4576 /* Routine Name: ips_deallocatescbs */
4578 /* Routine Description: */
4580 /* Free the command blocks */
4582 /****************************************************************************/
4584 ips_deallocatescbs(ips_ha_t
* ha
, int cmds
)
4587 pci_free_consistent(ha
->pcidev
,
4588 IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
* cmds
,
4589 ha
->scbs
->sg_list
.list
,
4590 ha
->scbs
->sg_busaddr
);
4591 pci_free_consistent(ha
->pcidev
, sizeof (ips_scb_t
) * cmds
,
4592 ha
->scbs
, ha
->scbs
->scb_busaddr
);
4598 /****************************************************************************/
4600 /* Routine Name: ips_allocatescbs */
4602 /* Routine Description: */
4604 /* Allocate the command blocks */
4606 /****************************************************************************/
4608 ips_allocatescbs(ips_ha_t
* ha
)
4613 dma_addr_t command_dma
, sg_dma
;
4615 METHOD_TRACE("ips_allocatescbs", 1);
4617 /* Allocate memory for the SCBs */
4619 pci_alloc_consistent(ha
->pcidev
, ha
->max_cmds
* sizeof (ips_scb_t
),
4621 if (ha
->scbs
== NULL
)
4624 pci_alloc_consistent(ha
->pcidev
,
4625 IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
*
4626 ha
->max_cmds
, &sg_dma
);
4627 if (ips_sg
.list
== NULL
) {
4628 pci_free_consistent(ha
->pcidev
,
4629 ha
->max_cmds
* sizeof (ips_scb_t
), ha
->scbs
,
4634 memset(ha
->scbs
, 0, ha
->max_cmds
* sizeof (ips_scb_t
));
4636 for (i
= 0; i
< ha
->max_cmds
; i
++) {
4637 scb_p
= &ha
->scbs
[i
];
4638 scb_p
->scb_busaddr
= command_dma
+ sizeof (ips_scb_t
) * i
;
4639 /* set up S/G list */
4640 if (IPS_USE_ENH_SGLIST(ha
)) {
4641 scb_p
->sg_list
.enh_list
=
4642 ips_sg
.enh_list
+ i
* IPS_MAX_SG
;
4644 sg_dma
+ IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
* i
;
4646 scb_p
->sg_list
.std_list
=
4647 ips_sg
.std_list
+ i
* IPS_MAX_SG
;
4649 sg_dma
+ IPS_SGLIST_SIZE(ha
) * IPS_MAX_SG
* i
;
4652 /* add to the free list */
4653 if (i
< ha
->max_cmds
- 1) {
4654 scb_p
->q_next
= ha
->scb_freelist
;
4655 ha
->scb_freelist
= scb_p
;
4663 /****************************************************************************/
4665 /* Routine Name: ips_init_scb */
4667 /* Routine Description: */
4669 /* Initialize a CCB to default values */
4671 /****************************************************************************/
4673 ips_init_scb(ips_ha_t
* ha
, ips_scb_t
* scb
)
4675 IPS_SG_LIST sg_list
;
4676 uint32_t cmd_busaddr
, sg_busaddr
;
4677 METHOD_TRACE("ips_init_scb", 1);
4682 sg_list
.list
= scb
->sg_list
.list
;
4683 cmd_busaddr
= scb
->scb_busaddr
;
4684 sg_busaddr
= scb
->sg_busaddr
;
4686 memset(scb
, 0, sizeof (ips_scb_t
));
4687 memset(ha
->dummy
, 0, sizeof (IPS_IO_CMD
));
4689 /* Initialize dummy command bucket */
4690 ha
->dummy
->op_code
= 0xFF;
4691 ha
->dummy
->ccsar
= cpu_to_le32(ha
->adapt
->hw_status_start
4692 + sizeof (IPS_ADAPTER
));
4693 ha
->dummy
->command_id
= IPS_MAX_CMDS
;
4695 /* set bus address of scb */
4696 scb
->scb_busaddr
= cmd_busaddr
;
4697 scb
->sg_busaddr
= sg_busaddr
;
4698 scb
->sg_list
.list
= sg_list
.list
;
4701 scb
->cmd
.basic_io
.cccr
= cpu_to_le32((uint32_t) IPS_BIT_ILE
);
4702 scb
->cmd
.basic_io
.ccsar
= cpu_to_le32(ha
->adapt
->hw_status_start
4703 + sizeof (IPS_ADAPTER
));
4706 /****************************************************************************/
4708 /* Routine Name: ips_get_scb */
4710 /* Routine Description: */
4712 /* Initialize a CCB to default values */
4714 /* ASSUMED to be callled from within a lock */
4716 /****************************************************************************/
4718 ips_getscb(ips_ha_t
* ha
)
4722 METHOD_TRACE("ips_getscb", 1);
4724 if ((scb
= ha
->scb_freelist
) == NULL
) {
4729 ha
->scb_freelist
= scb
->q_next
;
4733 ips_init_scb(ha
, scb
);
4738 /****************************************************************************/
4740 /* Routine Name: ips_free_scb */
4742 /* Routine Description: */
4744 /* Return an unused CCB back to the free list */
4746 /* ASSUMED to be called from within a lock */
4748 /****************************************************************************/
4750 ips_freescb(ips_ha_t
* ha
, ips_scb_t
* scb
)
4753 METHOD_TRACE("ips_freescb", 1);
4754 if (scb
->flags
& IPS_SCB_MAP_SG
)
4755 pci_unmap_sg(ha
->pcidev
, scb
->scsi_cmd
->request_buffer
,
4756 scb
->scsi_cmd
->use_sg
, IPS_DMA_DIR(scb
));
4757 else if (scb
->flags
& IPS_SCB_MAP_SINGLE
)
4758 pci_unmap_single(ha
->pcidev
, scb
->data_busaddr
, scb
->data_len
,
4761 /* check to make sure this is not our "special" scb */
4762 if (IPS_COMMAND_ID(ha
, scb
) < (ha
->max_cmds
- 1)) {
4763 scb
->q_next
= ha
->scb_freelist
;
4764 ha
->scb_freelist
= scb
;
4768 /****************************************************************************/
4770 /* Routine Name: ips_isinit_copperhead */
4772 /* Routine Description: */
4774 /* Is controller initialized ? */
4776 /****************************************************************************/
4778 ips_isinit_copperhead(ips_ha_t
* ha
)
4783 METHOD_TRACE("ips_isinit_copperhead", 1);
4785 isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
4786 scpr
= inb(ha
->io_addr
+ IPS_REG_SCPR
);
4788 if (((isr
& IPS_BIT_EI
) == 0) && ((scpr
& IPS_BIT_EBM
) == 0))
4794 /****************************************************************************/
4796 /* Routine Name: ips_isinit_copperhead_memio */
4798 /* Routine Description: */
4800 /* Is controller initialized ? */
4802 /****************************************************************************/
4804 ips_isinit_copperhead_memio(ips_ha_t
* ha
)
4809 METHOD_TRACE("ips_is_init_copperhead_memio", 1);
4811 isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
4812 scpr
= readb(ha
->mem_ptr
+ IPS_REG_SCPR
);
4814 if (((isr
& IPS_BIT_EI
) == 0) && ((scpr
& IPS_BIT_EBM
) == 0))
4820 /****************************************************************************/
4822 /* Routine Name: ips_isinit_morpheus */
4824 /* Routine Description: */
4826 /* Is controller initialized ? */
4828 /****************************************************************************/
4830 ips_isinit_morpheus(ips_ha_t
* ha
)
4835 METHOD_TRACE("ips_is_init_morpheus", 1);
4837 if (ips_isintr_morpheus(ha
))
4838 ips_flush_and_reset(ha
);
4840 post
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG0
);
4841 bits
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
4845 else if (bits
& 0x3)
4851 /****************************************************************************/
4853 /* Routine Name: ips_flush_and_reset */
4855 /* Routine Description: */
4857 /* Perform cleanup ( FLUSH and RESET ) when the adapter is in an unknown */
4858 /* state ( was trying to INIT and an interrupt was already pending ) ... */
4860 /****************************************************************************/
4862 ips_flush_and_reset(ips_ha_t
*ha
)
4868 dma_addr_t command_dma
;
4870 /* Create a usuable SCB */
4871 scb
= pci_alloc_consistent(ha
->pcidev
, sizeof(ips_scb_t
), &command_dma
);
4873 memset(scb
, 0, sizeof(ips_scb_t
));
4874 ips_init_scb(ha
, scb
);
4875 scb
->scb_busaddr
= command_dma
;
4877 scb
->timeout
= ips_cmd_timeout
;
4878 scb
->cdb
[0] = IPS_CMD_FLUSH
;
4880 scb
->cmd
.flush_cache
.op_code
= IPS_CMD_FLUSH
;
4881 scb
->cmd
.flush_cache
.command_id
= IPS_MAX_CMDS
; /* Use an ID that would otherwise not exist */
4882 scb
->cmd
.flush_cache
.state
= IPS_NORM_STATE
;
4883 scb
->cmd
.flush_cache
.reserved
= 0;
4884 scb
->cmd
.flush_cache
.reserved2
= 0;
4885 scb
->cmd
.flush_cache
.reserved3
= 0;
4886 scb
->cmd
.flush_cache
.reserved4
= 0;
4888 ret
= ips_send_cmd(ha
, scb
); /* Send the Flush Command */
4890 if (ret
== IPS_SUCCESS
) {
4891 time
= 60 * IPS_ONE_SEC
; /* Max Wait time is 60 seconds */
4894 while ((time
> 0) && (!done
)) {
4895 done
= ips_poll_for_flush_complete(ha
);
4896 /* This may look evil, but it's only done during extremely rare start-up conditions ! */
4903 /* Now RESET and INIT the adapter */
4904 (*ha
->func
.reset
) (ha
);
4906 pci_free_consistent(ha
->pcidev
, sizeof(ips_scb_t
), scb
, command_dma
);
4910 /****************************************************************************/
4912 /* Routine Name: ips_poll_for_flush_complete */
4914 /* Routine Description: */
4916 /* Poll for the Flush Command issued by ips_flush_and_reset() to complete */
4917 /* All other responses are just taken off the queue and ignored */
4919 /****************************************************************************/
4921 ips_poll_for_flush_complete(ips_ha_t
* ha
)
4926 cstatus
.value
= (*ha
->func
.statupd
) (ha
);
4928 if (cstatus
.value
== 0xffffffff) /* If No Interrupt to process */
4931 /* Success is when we see the Flush Command ID */
4932 if (cstatus
.fields
.command_id
== IPS_MAX_CMDS
)
4939 /****************************************************************************/
4941 /* Routine Name: ips_enable_int_copperhead */
4943 /* Routine Description: */
4944 /* Turn on interrupts */
4946 /****************************************************************************/
4948 ips_enable_int_copperhead(ips_ha_t
* ha
)
4950 METHOD_TRACE("ips_enable_int_copperhead", 1);
4952 outb(ha
->io_addr
+ IPS_REG_HISR
, IPS_BIT_EI
);
4953 inb(ha
->io_addr
+ IPS_REG_HISR
); /*Ensure PCI Posting Completes*/
4956 /****************************************************************************/
4958 /* Routine Name: ips_enable_int_copperhead_memio */
4960 /* Routine Description: */
4961 /* Turn on interrupts */
4963 /****************************************************************************/
4965 ips_enable_int_copperhead_memio(ips_ha_t
* ha
)
4967 METHOD_TRACE("ips_enable_int_copperhead_memio", 1);
4969 writeb(IPS_BIT_EI
, ha
->mem_ptr
+ IPS_REG_HISR
);
4970 readb(ha
->mem_ptr
+ IPS_REG_HISR
); /*Ensure PCI Posting Completes*/
4973 /****************************************************************************/
4975 /* Routine Name: ips_enable_int_morpheus */
4977 /* Routine Description: */
4978 /* Turn on interrupts */
4980 /****************************************************************************/
4982 ips_enable_int_morpheus(ips_ha_t
* ha
)
4986 METHOD_TRACE("ips_enable_int_morpheus", 1);
4988 Oimr
= readl(ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
4990 writel(Oimr
, ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
4991 readl(ha
->mem_ptr
+ IPS_REG_I960_OIMR
); /*Ensure PCI Posting Completes*/
4994 /****************************************************************************/
4996 /* Routine Name: ips_init_copperhead */
4998 /* Routine Description: */
5000 /* Initialize a copperhead controller */
5002 /****************************************************************************/
5004 ips_init_copperhead(ips_ha_t
* ha
)
5008 uint8_t PostByte
[IPS_MAX_POST_BYTES
];
5009 uint8_t ConfigByte
[IPS_MAX_CONFIG_BYTES
];
5012 METHOD_TRACE("ips_init_copperhead", 1);
5014 for (i
= 0; i
< IPS_MAX_POST_BYTES
; i
++) {
5015 for (j
= 0; j
< 45; j
++) {
5016 Isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
5017 if (Isr
& IPS_BIT_GHI
)
5020 /* Delay for 1 Second */
5021 MDELAY(IPS_ONE_SEC
);
5025 /* error occurred */
5028 PostByte
[i
] = inb(ha
->io_addr
+ IPS_REG_ISPR
);
5029 outb(Isr
, ha
->io_addr
+ IPS_REG_HISR
);
5032 if (PostByte
[0] < IPS_GOOD_POST_STATUS
) {
5033 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5034 "reset controller fails (post status %x %x).\n",
5035 PostByte
[0], PostByte
[1]);
5040 for (i
= 0; i
< IPS_MAX_CONFIG_BYTES
; i
++) {
5041 for (j
= 0; j
< 240; j
++) {
5042 Isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
5043 if (Isr
& IPS_BIT_GHI
)
5046 /* Delay for 1 Second */
5047 MDELAY(IPS_ONE_SEC
);
5051 /* error occurred */
5054 ConfigByte
[i
] = inb(ha
->io_addr
+ IPS_REG_ISPR
);
5055 outb(Isr
, ha
->io_addr
+ IPS_REG_HISR
);
5058 for (i
= 0; i
< 240; i
++) {
5059 Cbsp
= inb(ha
->io_addr
+ IPS_REG_CBSP
);
5061 if ((Cbsp
& IPS_BIT_OP
) == 0)
5064 /* Delay for 1 Second */
5065 MDELAY(IPS_ONE_SEC
);
5073 outl(cpu_to_le32(0x1010), ha
->io_addr
+ IPS_REG_CCCR
);
5075 /* Enable busmastering */
5076 outb(IPS_BIT_EBM
, ha
->io_addr
+ IPS_REG_SCPR
);
5078 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
5079 /* fix for anaconda64 */
5080 outl(0, ha
->io_addr
+ IPS_REG_NDAE
);
5082 /* Enable interrupts */
5083 outb(IPS_BIT_EI
, ha
->io_addr
+ IPS_REG_HISR
);
5088 /****************************************************************************/
5090 /* Routine Name: ips_init_copperhead_memio */
5092 /* Routine Description: */
5094 /* Initialize a copperhead controller with memory mapped I/O */
5096 /****************************************************************************/
5098 ips_init_copperhead_memio(ips_ha_t
* ha
)
5102 uint8_t PostByte
[IPS_MAX_POST_BYTES
];
5103 uint8_t ConfigByte
[IPS_MAX_CONFIG_BYTES
];
5106 METHOD_TRACE("ips_init_copperhead_memio", 1);
5108 for (i
= 0; i
< IPS_MAX_POST_BYTES
; i
++) {
5109 for (j
= 0; j
< 45; j
++) {
5110 Isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
5111 if (Isr
& IPS_BIT_GHI
)
5114 /* Delay for 1 Second */
5115 MDELAY(IPS_ONE_SEC
);
5119 /* error occurred */
5122 PostByte
[i
] = readb(ha
->mem_ptr
+ IPS_REG_ISPR
);
5123 writeb(Isr
, ha
->mem_ptr
+ IPS_REG_HISR
);
5126 if (PostByte
[0] < IPS_GOOD_POST_STATUS
) {
5127 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5128 "reset controller fails (post status %x %x).\n",
5129 PostByte
[0], PostByte
[1]);
5134 for (i
= 0; i
< IPS_MAX_CONFIG_BYTES
; i
++) {
5135 for (j
= 0; j
< 240; j
++) {
5136 Isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
5137 if (Isr
& IPS_BIT_GHI
)
5140 /* Delay for 1 Second */
5141 MDELAY(IPS_ONE_SEC
);
5145 /* error occurred */
5148 ConfigByte
[i
] = readb(ha
->mem_ptr
+ IPS_REG_ISPR
);
5149 writeb(Isr
, ha
->mem_ptr
+ IPS_REG_HISR
);
5152 for (i
= 0; i
< 240; i
++) {
5153 Cbsp
= readb(ha
->mem_ptr
+ IPS_REG_CBSP
);
5155 if ((Cbsp
& IPS_BIT_OP
) == 0)
5158 /* Delay for 1 Second */
5159 MDELAY(IPS_ONE_SEC
);
5163 /* error occurred */
5167 writel(0x1010, ha
->mem_ptr
+ IPS_REG_CCCR
);
5169 /* Enable busmastering */
5170 writeb(IPS_BIT_EBM
, ha
->mem_ptr
+ IPS_REG_SCPR
);
5172 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
5173 /* fix for anaconda64 */
5174 writel(0, ha
->mem_ptr
+ IPS_REG_NDAE
);
5176 /* Enable interrupts */
5177 writeb(IPS_BIT_EI
, ha
->mem_ptr
+ IPS_REG_HISR
);
5179 /* if we get here then everything went OK */
5183 /****************************************************************************/
5185 /* Routine Name: ips_init_morpheus */
5187 /* Routine Description: */
5189 /* Initialize a morpheus controller */
5191 /****************************************************************************/
5193 ips_init_morpheus(ips_ha_t
* ha
)
5201 METHOD_TRACE("ips_init_morpheus", 1);
5203 /* Wait up to 45 secs for Post */
5204 for (i
= 0; i
< 45; i
++) {
5205 Isr
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5207 if (Isr
& IPS_BIT_I960_MSG0I
)
5210 /* Delay for 1 Second */
5211 MDELAY(IPS_ONE_SEC
);
5215 /* error occurred */
5216 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5217 "timeout waiting for post.\n");
5222 Post
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG0
);
5224 if (Post
== 0x4F00) { /* If Flashing the Battery PIC */
5225 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5226 "Flashing Battery PIC, Please wait ...\n");
5228 /* Clear the interrupt bit */
5229 Isr
= (uint32_t) IPS_BIT_I960_MSG0I
;
5230 writel(Isr
, ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5232 for (i
= 0; i
< 120; i
++) { /* Wait Up to 2 Min. for Completion */
5233 Post
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG0
);
5236 /* Delay for 1 Second */
5237 MDELAY(IPS_ONE_SEC
);
5241 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5242 "timeout waiting for Battery PIC Flash\n");
5248 /* Clear the interrupt bit */
5249 Isr
= (uint32_t) IPS_BIT_I960_MSG0I
;
5250 writel(Isr
, ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5252 if (Post
< (IPS_GOOD_POST_STATUS
<< 8)) {
5253 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5254 "reset controller fails (post status %x).\n", Post
);
5259 /* Wait up to 240 secs for config bytes */
5260 for (i
= 0; i
< 240; i
++) {
5261 Isr
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5263 if (Isr
& IPS_BIT_I960_MSG1I
)
5266 /* Delay for 1 Second */
5267 MDELAY(IPS_ONE_SEC
);
5271 /* error occurred */
5272 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5273 "timeout waiting for config.\n");
5278 Config
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG1
);
5280 /* Clear interrupt bit */
5281 Isr
= (uint32_t) IPS_BIT_I960_MSG1I
;
5282 writel(Isr
, ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5284 /* Turn on the interrupts */
5285 Oimr
= readl(ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
5287 writel(Oimr
, ha
->mem_ptr
+ IPS_REG_I960_OIMR
);
5289 /* if we get here then everything went OK */
5291 /* Since we did a RESET, an EraseStripeLock may be needed */
5292 if (Post
== 0xEF10) {
5293 if ((Config
== 0x000F) || (Config
== 0x0009))
5294 ha
->requires_esl
= 1;
5300 /****************************************************************************/
5302 /* Routine Name: ips_reset_copperhead */
5304 /* Routine Description: */
5306 /* Reset the controller */
5308 /****************************************************************************/
5310 ips_reset_copperhead(ips_ha_t
* ha
)
5314 METHOD_TRACE("ips_reset_copperhead", 1);
5316 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead: io addr: %x, irq: %d",
5317 ips_name
, ha
->host_num
, ha
->io_addr
, ha
->irq
);
5321 while (reset_counter
< 2) {
5324 outb(IPS_BIT_RST
, ha
->io_addr
+ IPS_REG_SCPR
);
5326 /* Delay for 1 Second */
5327 MDELAY(IPS_ONE_SEC
);
5329 outb(0, ha
->io_addr
+ IPS_REG_SCPR
);
5331 /* Delay for 1 Second */
5332 MDELAY(IPS_ONE_SEC
);
5334 if ((*ha
->func
.init
) (ha
))
5336 else if (reset_counter
>= 2) {
5345 /****************************************************************************/
5347 /* Routine Name: ips_reset_copperhead_memio */
5349 /* Routine Description: */
5351 /* Reset the controller */
5353 /****************************************************************************/
5355 ips_reset_copperhead_memio(ips_ha_t
* ha
)
5359 METHOD_TRACE("ips_reset_copperhead_memio", 1);
5361 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead_memio: mem addr: %x, irq: %d",
5362 ips_name
, ha
->host_num
, ha
->mem_addr
, ha
->irq
);
5366 while (reset_counter
< 2) {
5369 writeb(IPS_BIT_RST
, ha
->mem_ptr
+ IPS_REG_SCPR
);
5371 /* Delay for 1 Second */
5372 MDELAY(IPS_ONE_SEC
);
5374 writeb(0, ha
->mem_ptr
+ IPS_REG_SCPR
);
5376 /* Delay for 1 Second */
5377 MDELAY(IPS_ONE_SEC
);
5379 if ((*ha
->func
.init
) (ha
))
5381 else if (reset_counter
>= 2) {
5390 /****************************************************************************/
5392 /* Routine Name: ips_reset_morpheus */
5394 /* Routine Description: */
5396 /* Reset the controller */
5398 /****************************************************************************/
5400 ips_reset_morpheus(ips_ha_t
* ha
)
5405 METHOD_TRACE("ips_reset_morpheus", 1);
5407 DEBUG_VAR(1, "(%s%d) ips_reset_morpheus: mem addr: %x, irq: %d",
5408 ips_name
, ha
->host_num
, ha
->mem_addr
, ha
->irq
);
5412 while (reset_counter
< 2) {
5415 writel(0x80000000, ha
->mem_ptr
+ IPS_REG_I960_IDR
);
5417 /* Delay for 5 Seconds */
5418 MDELAY(5 * IPS_ONE_SEC
);
5420 /* Do a PCI config read to wait for adapter */
5421 pci_read_config_byte(ha
->pcidev
, 4, &junk
);
5423 if ((*ha
->func
.init
) (ha
))
5425 else if (reset_counter
>= 2) {
5434 /****************************************************************************/
5436 /* Routine Name: ips_statinit */
5438 /* Routine Description: */
5440 /* Initialize the status queues on the controller */
5442 /****************************************************************************/
5444 ips_statinit(ips_ha_t
* ha
)
5446 uint32_t phys_status_start
;
5448 METHOD_TRACE("ips_statinit", 1);
5450 ha
->adapt
->p_status_start
= ha
->adapt
->status
;
5451 ha
->adapt
->p_status_end
= ha
->adapt
->status
+ IPS_MAX_CMDS
;
5452 ha
->adapt
->p_status_tail
= ha
->adapt
->status
;
5454 phys_status_start
= ha
->adapt
->hw_status_start
;
5455 outl(cpu_to_le32(phys_status_start
), ha
->io_addr
+ IPS_REG_SQSR
);
5456 outl(cpu_to_le32(phys_status_start
+ IPS_STATUS_Q_SIZE
),
5457 ha
->io_addr
+ IPS_REG_SQER
);
5458 outl(cpu_to_le32(phys_status_start
+ IPS_STATUS_SIZE
),
5459 ha
->io_addr
+ IPS_REG_SQHR
);
5460 outl(cpu_to_le32(phys_status_start
), ha
->io_addr
+ IPS_REG_SQTR
);
5462 ha
->adapt
->hw_status_tail
= phys_status_start
;
5465 /****************************************************************************/
5467 /* Routine Name: ips_statinit_memio */
5469 /* Routine Description: */
5471 /* Initialize the status queues on the controller */
5473 /****************************************************************************/
5475 ips_statinit_memio(ips_ha_t
* ha
)
5477 uint32_t phys_status_start
;
5479 METHOD_TRACE("ips_statinit_memio", 1);
5481 ha
->adapt
->p_status_start
= ha
->adapt
->status
;
5482 ha
->adapt
->p_status_end
= ha
->adapt
->status
+ IPS_MAX_CMDS
;
5483 ha
->adapt
->p_status_tail
= ha
->adapt
->status
;
5485 phys_status_start
= ha
->adapt
->hw_status_start
;
5486 writel(phys_status_start
, ha
->mem_ptr
+ IPS_REG_SQSR
);
5487 writel(phys_status_start
+ IPS_STATUS_Q_SIZE
,
5488 ha
->mem_ptr
+ IPS_REG_SQER
);
5489 writel(phys_status_start
+ IPS_STATUS_SIZE
, ha
->mem_ptr
+ IPS_REG_SQHR
);
5490 writel(phys_status_start
, ha
->mem_ptr
+ IPS_REG_SQTR
);
5492 ha
->adapt
->hw_status_tail
= phys_status_start
;
5495 /****************************************************************************/
5497 /* Routine Name: ips_statupd_copperhead */
5499 /* Routine Description: */
5501 /* Remove an element from the status queue */
5503 /****************************************************************************/
5505 ips_statupd_copperhead(ips_ha_t
* ha
)
5507 METHOD_TRACE("ips_statupd_copperhead", 1);
5509 if (ha
->adapt
->p_status_tail
!= ha
->adapt
->p_status_end
) {
5510 ha
->adapt
->p_status_tail
++;
5511 ha
->adapt
->hw_status_tail
+= sizeof (IPS_STATUS
);
5513 ha
->adapt
->p_status_tail
= ha
->adapt
->p_status_start
;
5514 ha
->adapt
->hw_status_tail
= ha
->adapt
->hw_status_start
;
5517 outl(cpu_to_le32(ha
->adapt
->hw_status_tail
),
5518 ha
->io_addr
+ IPS_REG_SQTR
);
5520 return (ha
->adapt
->p_status_tail
->value
);
5523 /****************************************************************************/
5525 /* Routine Name: ips_statupd_copperhead_memio */
5527 /* Routine Description: */
5529 /* Remove an element from the status queue */
5531 /****************************************************************************/
5533 ips_statupd_copperhead_memio(ips_ha_t
* ha
)
5535 METHOD_TRACE("ips_statupd_copperhead_memio", 1);
5537 if (ha
->adapt
->p_status_tail
!= ha
->adapt
->p_status_end
) {
5538 ha
->adapt
->p_status_tail
++;
5539 ha
->adapt
->hw_status_tail
+= sizeof (IPS_STATUS
);
5541 ha
->adapt
->p_status_tail
= ha
->adapt
->p_status_start
;
5542 ha
->adapt
->hw_status_tail
= ha
->adapt
->hw_status_start
;
5545 writel(ha
->adapt
->hw_status_tail
, ha
->mem_ptr
+ IPS_REG_SQTR
);
5547 return (ha
->adapt
->p_status_tail
->value
);
5550 /****************************************************************************/
5552 /* Routine Name: ips_statupd_morpheus */
5554 /* Routine Description: */
5556 /* Remove an element from the status queue */
5558 /****************************************************************************/
5560 ips_statupd_morpheus(ips_ha_t
* ha
)
5564 METHOD_TRACE("ips_statupd_morpheus", 1);
5566 val
= readl(ha
->mem_ptr
+ IPS_REG_I2O_OUTMSGQ
);
5571 /****************************************************************************/
5573 /* Routine Name: ips_issue_copperhead */
5575 /* Routine Description: */
5577 /* Send a command down to the controller */
5579 /****************************************************************************/
5581 ips_issue_copperhead(ips_ha_t
* ha
, ips_scb_t
* scb
)
5586 METHOD_TRACE("ips_issue_copperhead", 1);
5588 if (scb
->scsi_cmd
) {
5589 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5593 scb
->cmd
.basic_io
.command_id
,
5594 scb
->bus
, scb
->target_id
, scb
->lun
);
5596 DEBUG_VAR(2, KERN_NOTICE
"(%s%d) ips_issue: logical cmd id %d",
5597 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5603 le32_to_cpu(inl(ha
->io_addr
+ IPS_REG_CCCR
))) & IPS_BIT_SEM
) {
5606 if (++TimeOut
>= IPS_SEM_TIMEOUT
) {
5607 if (!(val
& IPS_BIT_START_STOP
))
5610 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5611 "ips_issue val [0x%x].\n", val
);
5612 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5613 "ips_issue semaphore chk timeout.\n");
5615 return (IPS_FAILURE
);
5619 outl(cpu_to_le32(scb
->scb_busaddr
), ha
->io_addr
+ IPS_REG_CCSAR
);
5620 outw(cpu_to_le32(IPS_BIT_START_CMD
), ha
->io_addr
+ IPS_REG_CCCR
);
5622 return (IPS_SUCCESS
);
5625 /****************************************************************************/
5627 /* Routine Name: ips_issue_copperhead_memio */
5629 /* Routine Description: */
5631 /* Send a command down to the controller */
5633 /****************************************************************************/
5635 ips_issue_copperhead_memio(ips_ha_t
* ha
, ips_scb_t
* scb
)
5640 METHOD_TRACE("ips_issue_copperhead_memio", 1);
5642 if (scb
->scsi_cmd
) {
5643 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5647 scb
->cmd
.basic_io
.command_id
,
5648 scb
->bus
, scb
->target_id
, scb
->lun
);
5650 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5651 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5656 while ((val
= readl(ha
->mem_ptr
+ IPS_REG_CCCR
)) & IPS_BIT_SEM
) {
5659 if (++TimeOut
>= IPS_SEM_TIMEOUT
) {
5660 if (!(val
& IPS_BIT_START_STOP
))
5663 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5664 "ips_issue val [0x%x].\n", val
);
5665 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5666 "ips_issue semaphore chk timeout.\n");
5668 return (IPS_FAILURE
);
5672 writel(scb
->scb_busaddr
, ha
->mem_ptr
+ IPS_REG_CCSAR
);
5673 writel(IPS_BIT_START_CMD
, ha
->mem_ptr
+ IPS_REG_CCCR
);
5675 return (IPS_SUCCESS
);
5678 /****************************************************************************/
5680 /* Routine Name: ips_issue_i2o */
5682 /* Routine Description: */
5684 /* Send a command down to the controller */
5686 /****************************************************************************/
5688 ips_issue_i2o(ips_ha_t
* ha
, ips_scb_t
* scb
)
5691 METHOD_TRACE("ips_issue_i2o", 1);
5693 if (scb
->scsi_cmd
) {
5694 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5698 scb
->cmd
.basic_io
.command_id
,
5699 scb
->bus
, scb
->target_id
, scb
->lun
);
5701 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5702 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5705 outl(cpu_to_le32(scb
->scb_busaddr
), ha
->io_addr
+ IPS_REG_I2O_INMSGQ
);
5707 return (IPS_SUCCESS
);
5710 /****************************************************************************/
5712 /* Routine Name: ips_issue_i2o_memio */
5714 /* Routine Description: */
5716 /* Send a command down to the controller */
5718 /****************************************************************************/
5720 ips_issue_i2o_memio(ips_ha_t
* ha
, ips_scb_t
* scb
)
5723 METHOD_TRACE("ips_issue_i2o_memio", 1);
5725 if (scb
->scsi_cmd
) {
5726 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5730 scb
->cmd
.basic_io
.command_id
,
5731 scb
->bus
, scb
->target_id
, scb
->lun
);
5733 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5734 ips_name
, ha
->host_num
, scb
->cmd
.basic_io
.command_id
);
5737 writel(scb
->scb_busaddr
, ha
->mem_ptr
+ IPS_REG_I2O_INMSGQ
);
5739 return (IPS_SUCCESS
);
5742 /****************************************************************************/
5744 /* Routine Name: ips_isintr_copperhead */
5746 /* Routine Description: */
5748 /* Test to see if an interrupt is for us */
5750 /****************************************************************************/
5752 ips_isintr_copperhead(ips_ha_t
* ha
)
5756 METHOD_TRACE("ips_isintr_copperhead", 2);
5758 Isr
= inb(ha
->io_addr
+ IPS_REG_HISR
);
5761 /* ?!?! Nothing really there */
5764 if (Isr
& IPS_BIT_SCE
)
5766 else if (Isr
& (IPS_BIT_SQO
| IPS_BIT_GHI
)) {
5767 /* status queue overflow or GHI */
5768 /* just clear the interrupt */
5769 outb(Isr
, ha
->io_addr
+ IPS_REG_HISR
);
5775 /****************************************************************************/
5777 /* Routine Name: ips_isintr_copperhead_memio */
5779 /* Routine Description: */
5781 /* Test to see if an interrupt is for us */
5783 /****************************************************************************/
5785 ips_isintr_copperhead_memio(ips_ha_t
* ha
)
5789 METHOD_TRACE("ips_isintr_memio", 2);
5791 Isr
= readb(ha
->mem_ptr
+ IPS_REG_HISR
);
5794 /* ?!?! Nothing really there */
5797 if (Isr
& IPS_BIT_SCE
)
5799 else if (Isr
& (IPS_BIT_SQO
| IPS_BIT_GHI
)) {
5800 /* status queue overflow or GHI */
5801 /* just clear the interrupt */
5802 writeb(Isr
, ha
->mem_ptr
+ IPS_REG_HISR
);
5808 /****************************************************************************/
5810 /* Routine Name: ips_isintr_morpheus */
5812 /* Routine Description: */
5814 /* Test to see if an interrupt is for us */
5816 /****************************************************************************/
5818 ips_isintr_morpheus(ips_ha_t
* ha
)
5822 METHOD_TRACE("ips_isintr_morpheus", 2);
5824 Isr
= readl(ha
->mem_ptr
+ IPS_REG_I2O_HIR
);
5826 if (Isr
& IPS_BIT_I2O_OPQI
)
5832 /****************************************************************************/
5834 /* Routine Name: ips_wait */
5836 /* Routine Description: */
5838 /* Wait for a command to complete */
5840 /****************************************************************************/
5842 ips_wait(ips_ha_t
* ha
, int time
, int intr
)
5847 METHOD_TRACE("ips_wait", 1);
5852 time
*= IPS_ONE_SEC
; /* convert seconds */
5854 while ((time
> 0) && (!done
)) {
5855 if (intr
== IPS_INTR_ON
) {
5856 if (ha
->waitflag
== FALSE
) {
5861 } else if (intr
== IPS_INTR_IORL
) {
5862 if (ha
->waitflag
== FALSE
) {
5864 * controller generated an interrupt to
5865 * acknowledge completion of the command
5866 * and ips_intr() has serviced the interrupt.
5874 * NOTE: we already have the io_request_lock so
5875 * even if we get an interrupt it won't get serviced
5876 * until after we finish.
5879 (*ha
->func
.intr
) (ha
);
5882 /* This looks like a very evil loop, but it only does this during start-up */
5890 /****************************************************************************/
5892 /* Routine Name: ips_write_driver_status */
5894 /* Routine Description: */
5896 /* Write OS/Driver version to Page 5 of the nvram on the controller */
5898 /****************************************************************************/
5900 ips_write_driver_status(ips_ha_t
* ha
, int intr
)
5902 METHOD_TRACE("ips_write_driver_status", 1);
5904 if (!ips_readwrite_page5(ha
, FALSE
, intr
)) {
5905 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5906 "unable to read NVRAM page 5.\n");
5911 /* check to make sure the page has a valid */
5913 if (le32_to_cpu(ha
->nvram
->signature
) != IPS_NVRAM_P5_SIG
) {
5915 "(%s%d) NVRAM page 5 has an invalid signature: %X.",
5916 ips_name
, ha
->host_num
, ha
->nvram
->signature
);
5917 ha
->nvram
->signature
= IPS_NVRAM_P5_SIG
;
5921 "(%s%d) Ad Type: %d, Ad Slot: %d, BIOS: %c%c%c%c %c%c%c%c.",
5922 ips_name
, ha
->host_num
, le16_to_cpu(ha
->nvram
->adapter_type
),
5923 ha
->nvram
->adapter_slot
, ha
->nvram
->bios_high
[0],
5924 ha
->nvram
->bios_high
[1], ha
->nvram
->bios_high
[2],
5925 ha
->nvram
->bios_high
[3], ha
->nvram
->bios_low
[0],
5926 ha
->nvram
->bios_low
[1], ha
->nvram
->bios_low
[2],
5927 ha
->nvram
->bios_low
[3]);
5929 ips_get_bios_version(ha
, intr
);
5931 /* change values (as needed) */
5932 ha
->nvram
->operating_system
= IPS_OS_LINUX
;
5933 ha
->nvram
->adapter_type
= ha
->ad_type
;
5934 strncpy((char *) ha
->nvram
->driver_high
, IPS_VERSION_HIGH
, 4);
5935 strncpy((char *) ha
->nvram
->driver_low
, IPS_VERSION_LOW
, 4);
5936 strncpy((char *) ha
->nvram
->bios_high
, ha
->bios_version
, 4);
5937 strncpy((char *) ha
->nvram
->bios_low
, ha
->bios_version
+ 4, 4);
5939 ips_version_check(ha
, intr
); /* Check BIOS/FW/Driver Versions */
5941 /* now update the page */
5942 if (!ips_readwrite_page5(ha
, TRUE
, intr
)) {
5943 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
5944 "unable to write NVRAM page 5.\n");
5949 /* IF NVRAM Page 5 is OK, Use it for Slot Number Info Because Linux Doesn't Do Slots */
5950 ha
->slot_num
= ha
->nvram
->adapter_slot
;
5955 /****************************************************************************/
5957 /* Routine Name: ips_read_adapter_status */
5959 /* Routine Description: */
5961 /* Do an Inquiry command to the adapter */
5963 /****************************************************************************/
5965 ips_read_adapter_status(ips_ha_t
* ha
, int intr
)
5970 METHOD_TRACE("ips_read_adapter_status", 1);
5972 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
5974 ips_init_scb(ha
, scb
);
5976 scb
->timeout
= ips_cmd_timeout
;
5977 scb
->cdb
[0] = IPS_CMD_ENQUIRY
;
5979 scb
->cmd
.basic_io
.op_code
= IPS_CMD_ENQUIRY
;
5980 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
5981 scb
->cmd
.basic_io
.sg_count
= 0;
5982 scb
->cmd
.basic_io
.lba
= 0;
5983 scb
->cmd
.basic_io
.sector_count
= 0;
5984 scb
->cmd
.basic_io
.log_drv
= 0;
5985 scb
->data_len
= sizeof (*ha
->enq
);
5986 scb
->cmd
.basic_io
.sg_addr
= ha
->enq_busaddr
;
5990 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
5991 || (ret
== IPS_SUCCESS_IMM
)
5992 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
5998 /****************************************************************************/
6000 /* Routine Name: ips_read_subsystem_parameters */
6002 /* Routine Description: */
6004 /* Read subsystem parameters from the adapter */
6006 /****************************************************************************/
6008 ips_read_subsystem_parameters(ips_ha_t
* ha
, int intr
)
6013 METHOD_TRACE("ips_read_subsystem_parameters", 1);
6015 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
6017 ips_init_scb(ha
, scb
);
6019 scb
->timeout
= ips_cmd_timeout
;
6020 scb
->cdb
[0] = IPS_CMD_GET_SUBSYS
;
6022 scb
->cmd
.basic_io
.op_code
= IPS_CMD_GET_SUBSYS
;
6023 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6024 scb
->cmd
.basic_io
.sg_count
= 0;
6025 scb
->cmd
.basic_io
.lba
= 0;
6026 scb
->cmd
.basic_io
.sector_count
= 0;
6027 scb
->cmd
.basic_io
.log_drv
= 0;
6028 scb
->data_len
= sizeof (*ha
->subsys
);
6029 scb
->cmd
.basic_io
.sg_addr
= ha
->ioctl_busaddr
;
6033 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
6034 || (ret
== IPS_SUCCESS_IMM
)
6035 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
6038 memcpy(ha
->subsys
, ha
->ioctl_data
, sizeof(*ha
->subsys
));
6042 /****************************************************************************/
6044 /* Routine Name: ips_read_config */
6046 /* Routine Description: */
6048 /* Read the configuration on the adapter */
6050 /****************************************************************************/
6052 ips_read_config(ips_ha_t
* ha
, int intr
)
6058 METHOD_TRACE("ips_read_config", 1);
6060 /* set defaults for initiator IDs */
6061 for (i
= 0; i
< 4; i
++)
6062 ha
->conf
->init_id
[i
] = 7;
6064 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
6066 ips_init_scb(ha
, scb
);
6068 scb
->timeout
= ips_cmd_timeout
;
6069 scb
->cdb
[0] = IPS_CMD_READ_CONF
;
6071 scb
->cmd
.basic_io
.op_code
= IPS_CMD_READ_CONF
;
6072 scb
->cmd
.basic_io
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6073 scb
->data_len
= sizeof (*ha
->conf
);
6074 scb
->cmd
.basic_io
.sg_addr
= ha
->ioctl_busaddr
;
6078 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
6079 || (ret
== IPS_SUCCESS_IMM
)
6080 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1)) {
6082 memset(ha
->conf
, 0, sizeof (IPS_CONF
));
6084 /* reset initiator IDs */
6085 for (i
= 0; i
< 4; i
++)
6086 ha
->conf
->init_id
[i
] = 7;
6088 /* Allow Completed with Errors, so JCRM can access the Adapter to fix the problems */
6089 if ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) ==
6090 IPS_CMD_CMPLT_WERROR
)
6096 memcpy(ha
->conf
, ha
->ioctl_data
, sizeof(*ha
->conf
));
6100 /****************************************************************************/
6102 /* Routine Name: ips_readwrite_page5 */
6104 /* Routine Description: */
6106 /* Read nvram page 5 from the adapter */
6108 /****************************************************************************/
6110 ips_readwrite_page5(ips_ha_t
* ha
, int write
, int intr
)
6115 METHOD_TRACE("ips_readwrite_page5", 1);
6117 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
6119 ips_init_scb(ha
, scb
);
6121 scb
->timeout
= ips_cmd_timeout
;
6122 scb
->cdb
[0] = IPS_CMD_RW_NVRAM_PAGE
;
6124 scb
->cmd
.nvram
.op_code
= IPS_CMD_RW_NVRAM_PAGE
;
6125 scb
->cmd
.nvram
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6126 scb
->cmd
.nvram
.page
= 5;
6127 scb
->cmd
.nvram
.write
= write
;
6128 scb
->cmd
.nvram
.reserved
= 0;
6129 scb
->cmd
.nvram
.reserved2
= 0;
6130 scb
->data_len
= sizeof (*ha
->nvram
);
6131 scb
->cmd
.nvram
.buffer_addr
= ha
->ioctl_busaddr
;
6133 memcpy(ha
->ioctl_data
, ha
->nvram
, sizeof(*ha
->nvram
));
6135 /* issue the command */
6137 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
6138 || (ret
== IPS_SUCCESS_IMM
)
6139 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1)) {
6141 memset(ha
->nvram
, 0, sizeof (IPS_NVRAM_P5
));
6146 memcpy(ha
->nvram
, ha
->ioctl_data
, sizeof(*ha
->nvram
));
6150 /****************************************************************************/
6152 /* Routine Name: ips_clear_adapter */
6154 /* Routine Description: */
6156 /* Clear the stripe lock tables */
6158 /****************************************************************************/
6160 ips_clear_adapter(ips_ha_t
* ha
, int intr
)
6165 METHOD_TRACE("ips_clear_adapter", 1);
6167 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
6169 ips_init_scb(ha
, scb
);
6171 scb
->timeout
= ips_reset_timeout
;
6172 scb
->cdb
[0] = IPS_CMD_CONFIG_SYNC
;
6174 scb
->cmd
.config_sync
.op_code
= IPS_CMD_CONFIG_SYNC
;
6175 scb
->cmd
.config_sync
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6176 scb
->cmd
.config_sync
.channel
= 0;
6177 scb
->cmd
.config_sync
.source_target
= IPS_POCL
;
6178 scb
->cmd
.config_sync
.reserved
= 0;
6179 scb
->cmd
.config_sync
.reserved2
= 0;
6180 scb
->cmd
.config_sync
.reserved3
= 0;
6184 ips_send_wait(ha
, scb
, ips_reset_timeout
, intr
)) == IPS_FAILURE
)
6185 || (ret
== IPS_SUCCESS_IMM
)
6186 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
6189 /* send unlock stripe command */
6190 ips_init_scb(ha
, scb
);
6192 scb
->cdb
[0] = IPS_CMD_ERROR_TABLE
;
6193 scb
->timeout
= ips_reset_timeout
;
6195 scb
->cmd
.unlock_stripe
.op_code
= IPS_CMD_ERROR_TABLE
;
6196 scb
->cmd
.unlock_stripe
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6197 scb
->cmd
.unlock_stripe
.log_drv
= 0;
6198 scb
->cmd
.unlock_stripe
.control
= IPS_CSL
;
6199 scb
->cmd
.unlock_stripe
.reserved
= 0;
6200 scb
->cmd
.unlock_stripe
.reserved2
= 0;
6201 scb
->cmd
.unlock_stripe
.reserved3
= 0;
6205 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
)) == IPS_FAILURE
)
6206 || (ret
== IPS_SUCCESS_IMM
)
6207 || ((scb
->basic_status
& IPS_GSC_STATUS_MASK
) > 1))
6213 /****************************************************************************/
6215 /* Routine Name: ips_ffdc_reset */
6217 /* Routine Description: */
6219 /* FFDC: write reset info */
6221 /****************************************************************************/
6223 ips_ffdc_reset(ips_ha_t
* ha
, int intr
)
6227 METHOD_TRACE("ips_ffdc_reset", 1);
6229 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
6231 ips_init_scb(ha
, scb
);
6233 scb
->timeout
= ips_cmd_timeout
;
6234 scb
->cdb
[0] = IPS_CMD_FFDC
;
6235 scb
->cmd
.ffdc
.op_code
= IPS_CMD_FFDC
;
6236 scb
->cmd
.ffdc
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6237 scb
->cmd
.ffdc
.reset_count
= ha
->reset_count
;
6238 scb
->cmd
.ffdc
.reset_type
= 0x80;
6240 /* convert time to what the card wants */
6241 ips_fix_ffdc_time(ha
, scb
, ha
->last_ffdc
);
6244 ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
);
6247 /****************************************************************************/
6249 /* Routine Name: ips_ffdc_time */
6251 /* Routine Description: */
6253 /* FFDC: write time info */
6255 /****************************************************************************/
6257 ips_ffdc_time(ips_ha_t
* ha
)
6261 METHOD_TRACE("ips_ffdc_time", 1);
6263 DEBUG_VAR(1, "(%s%d) Sending time update.", ips_name
, ha
->host_num
);
6265 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
6267 ips_init_scb(ha
, scb
);
6269 scb
->timeout
= ips_cmd_timeout
;
6270 scb
->cdb
[0] = IPS_CMD_FFDC
;
6271 scb
->cmd
.ffdc
.op_code
= IPS_CMD_FFDC
;
6272 scb
->cmd
.ffdc
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6273 scb
->cmd
.ffdc
.reset_count
= 0;
6274 scb
->cmd
.ffdc
.reset_type
= 0;
6276 /* convert time to what the card wants */
6277 ips_fix_ffdc_time(ha
, scb
, ha
->last_ffdc
);
6280 ips_send_wait(ha
, scb
, ips_cmd_timeout
, IPS_FFDC
);
6283 /****************************************************************************/
6285 /* Routine Name: ips_fix_ffdc_time */
6287 /* Routine Description: */
6288 /* Adjust time_t to what the card wants */
6290 /****************************************************************************/
6292 ips_fix_ffdc_time(ips_ha_t
* ha
, ips_scb_t
* scb
, time_t current_time
)
6299 int year_lengths
[2] = { IPS_DAYS_NORMAL_YEAR
, IPS_DAYS_LEAP_YEAR
};
6300 int month_lengths
[12][2] = { {31, 31},
6314 METHOD_TRACE("ips_fix_ffdc_time", 1);
6316 days
= current_time
/ IPS_SECS_DAY
;
6317 rem
= current_time
% IPS_SECS_DAY
;
6319 scb
->cmd
.ffdc
.hour
= (rem
/ IPS_SECS_HOUR
);
6320 rem
= rem
% IPS_SECS_HOUR
;
6321 scb
->cmd
.ffdc
.minute
= (rem
/ IPS_SECS_MIN
);
6322 scb
->cmd
.ffdc
.second
= (rem
% IPS_SECS_MIN
);
6324 year
= IPS_EPOCH_YEAR
;
6325 while (days
< 0 || days
>= year_lengths
[yleap
= IPS_IS_LEAP_YEAR(year
)]) {
6328 newy
= year
+ (days
/ IPS_DAYS_NORMAL_YEAR
);
6331 days
-= (newy
- year
) * IPS_DAYS_NORMAL_YEAR
+
6332 IPS_NUM_LEAP_YEARS_THROUGH(newy
- 1) -
6333 IPS_NUM_LEAP_YEARS_THROUGH(year
- 1);
6337 scb
->cmd
.ffdc
.yearH
= year
/ 100;
6338 scb
->cmd
.ffdc
.yearL
= year
% 100;
6340 for (i
= 0; days
>= month_lengths
[i
][yleap
]; ++i
)
6341 days
-= month_lengths
[i
][yleap
];
6343 scb
->cmd
.ffdc
.month
= i
+ 1;
6344 scb
->cmd
.ffdc
.day
= days
+ 1;
6347 /****************************************************************************
6348 * BIOS Flash Routines *
6349 ****************************************************************************/
6351 /****************************************************************************/
6353 /* Routine Name: ips_erase_bios */
6355 /* Routine Description: */
6356 /* Erase the BIOS on the adapter */
6358 /****************************************************************************/
6360 ips_erase_bios(ips_ha_t
* ha
)
6365 METHOD_TRACE("ips_erase_bios", 1);
6369 /* Clear the status register */
6370 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6371 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6372 udelay(25); /* 25 us */
6374 outb(0x50, ha
->io_addr
+ IPS_REG_FLDP
);
6375 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6376 udelay(25); /* 25 us */
6379 outb(0x20, ha
->io_addr
+ IPS_REG_FLDP
);
6380 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6381 udelay(25); /* 25 us */
6384 outb(0xD0, ha
->io_addr
+ IPS_REG_FLDP
);
6385 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6386 udelay(25); /* 25 us */
6389 outb(0x70, ha
->io_addr
+ IPS_REG_FLDP
);
6390 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6391 udelay(25); /* 25 us */
6393 timeout
= 80000; /* 80 seconds */
6395 while (timeout
> 0) {
6396 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6397 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6398 udelay(25); /* 25 us */
6401 status
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
6410 /* check for timeout */
6414 /* try to suspend the erase */
6415 outb(0xB0, ha
->io_addr
+ IPS_REG_FLDP
);
6416 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6417 udelay(25); /* 25 us */
6419 /* wait for 10 seconds */
6421 while (timeout
> 0) {
6422 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6423 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6424 udelay(25); /* 25 us */
6427 status
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
6439 /* check for valid VPP */
6444 /* check for succesful flash */
6446 /* sequence error */
6449 /* Otherwise, we were successful */
6451 outb(0x50, ha
->io_addr
+ IPS_REG_FLDP
);
6452 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6453 udelay(25); /* 25 us */
6456 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6457 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6458 udelay(25); /* 25 us */
6463 /****************************************************************************/
6465 /* Routine Name: ips_erase_bios_memio */
6467 /* Routine Description: */
6468 /* Erase the BIOS on the adapter */
6470 /****************************************************************************/
6472 ips_erase_bios_memio(ips_ha_t
* ha
)
6477 METHOD_TRACE("ips_erase_bios_memio", 1);
6481 /* Clear the status register */
6482 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6483 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6484 udelay(25); /* 25 us */
6486 writeb(0x50, ha
->mem_ptr
+ IPS_REG_FLDP
);
6487 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6488 udelay(25); /* 25 us */
6491 writeb(0x20, ha
->mem_ptr
+ IPS_REG_FLDP
);
6492 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6493 udelay(25); /* 25 us */
6496 writeb(0xD0, ha
->mem_ptr
+ IPS_REG_FLDP
);
6497 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6498 udelay(25); /* 25 us */
6501 writeb(0x70, ha
->mem_ptr
+ IPS_REG_FLDP
);
6502 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6503 udelay(25); /* 25 us */
6505 timeout
= 80000; /* 80 seconds */
6507 while (timeout
> 0) {
6508 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6509 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6510 udelay(25); /* 25 us */
6513 status
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6522 /* check for timeout */
6526 /* try to suspend the erase */
6527 writeb(0xB0, ha
->mem_ptr
+ IPS_REG_FLDP
);
6528 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6529 udelay(25); /* 25 us */
6531 /* wait for 10 seconds */
6533 while (timeout
> 0) {
6534 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6535 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6536 udelay(25); /* 25 us */
6539 status
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6551 /* check for valid VPP */
6556 /* check for succesful flash */
6558 /* sequence error */
6561 /* Otherwise, we were successful */
6563 writeb(0x50, ha
->mem_ptr
+ IPS_REG_FLDP
);
6564 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6565 udelay(25); /* 25 us */
6568 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6569 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6570 udelay(25); /* 25 us */
6575 /****************************************************************************/
6577 /* Routine Name: ips_program_bios */
6579 /* Routine Description: */
6580 /* Program the BIOS on the adapter */
6582 /****************************************************************************/
6584 ips_program_bios(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6591 METHOD_TRACE("ips_program_bios", 1);
6595 for (i
= 0; i
< buffersize
; i
++) {
6597 outl(cpu_to_le32(i
+ offset
), ha
->io_addr
+ IPS_REG_FLAP
);
6598 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6599 udelay(25); /* 25 us */
6601 outb(0x40, ha
->io_addr
+ IPS_REG_FLDP
);
6602 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6603 udelay(25); /* 25 us */
6605 outb(buffer
[i
], ha
->io_addr
+ IPS_REG_FLDP
);
6606 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6607 udelay(25); /* 25 us */
6609 /* wait up to one second */
6611 while (timeout
> 0) {
6612 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6613 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6614 udelay(25); /* 25 us */
6617 status
= inb(ha
->io_addr
+ IPS_REG_FLDP
);
6628 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6629 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6630 udelay(25); /* 25 us */
6632 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6633 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6634 udelay(25); /* 25 us */
6639 /* check the status */
6640 if (status
& 0x18) {
6641 /* programming error */
6642 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6643 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6644 udelay(25); /* 25 us */
6646 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6647 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6648 udelay(25); /* 25 us */
6654 /* Enable reading */
6655 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6656 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6657 udelay(25); /* 25 us */
6659 outb(0xFF, ha
->io_addr
+ IPS_REG_FLDP
);
6660 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6661 udelay(25); /* 25 us */
6666 /****************************************************************************/
6668 /* Routine Name: ips_program_bios_memio */
6670 /* Routine Description: */
6671 /* Program the BIOS on the adapter */
6673 /****************************************************************************/
6675 ips_program_bios_memio(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6682 METHOD_TRACE("ips_program_bios_memio", 1);
6686 for (i
= 0; i
< buffersize
; i
++) {
6688 writel(i
+ offset
, ha
->mem_ptr
+ IPS_REG_FLAP
);
6689 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6690 udelay(25); /* 25 us */
6692 writeb(0x40, ha
->mem_ptr
+ IPS_REG_FLDP
);
6693 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6694 udelay(25); /* 25 us */
6696 writeb(buffer
[i
], ha
->mem_ptr
+ IPS_REG_FLDP
);
6697 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6698 udelay(25); /* 25 us */
6700 /* wait up to one second */
6702 while (timeout
> 0) {
6703 if (ha
->revision_id
== IPS_REVID_TROMBONE64
) {
6704 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6705 udelay(25); /* 25 us */
6708 status
= readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6719 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6720 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6721 udelay(25); /* 25 us */
6723 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6724 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6725 udelay(25); /* 25 us */
6730 /* check the status */
6731 if (status
& 0x18) {
6732 /* programming error */
6733 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6734 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6735 udelay(25); /* 25 us */
6737 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6738 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6739 udelay(25); /* 25 us */
6745 /* Enable reading */
6746 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6747 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6748 udelay(25); /* 25 us */
6750 writeb(0xFF, ha
->mem_ptr
+ IPS_REG_FLDP
);
6751 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6752 udelay(25); /* 25 us */
6757 /****************************************************************************/
6759 /* Routine Name: ips_verify_bios */
6761 /* Routine Description: */
6762 /* Verify the BIOS on the adapter */
6764 /****************************************************************************/
6766 ips_verify_bios(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6772 METHOD_TRACE("ips_verify_bios", 1);
6775 outl(0, ha
->io_addr
+ IPS_REG_FLAP
);
6776 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6777 udelay(25); /* 25 us */
6779 if (inb(ha
->io_addr
+ IPS_REG_FLDP
) != 0x55)
6782 outl(cpu_to_le32(1), ha
->io_addr
+ IPS_REG_FLAP
);
6783 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6784 udelay(25); /* 25 us */
6785 if (inb(ha
->io_addr
+ IPS_REG_FLDP
) != 0xAA)
6789 for (i
= 2; i
< buffersize
; i
++) {
6791 outl(cpu_to_le32(i
+ offset
), ha
->io_addr
+ IPS_REG_FLAP
);
6792 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6793 udelay(25); /* 25 us */
6795 checksum
= (uint8_t) checksum
+ inb(ha
->io_addr
+ IPS_REG_FLDP
);
6806 /****************************************************************************/
6808 /* Routine Name: ips_verify_bios_memio */
6810 /* Routine Description: */
6811 /* Verify the BIOS on the adapter */
6813 /****************************************************************************/
6815 ips_verify_bios_memio(ips_ha_t
* ha
, char *buffer
, uint32_t buffersize
,
6821 METHOD_TRACE("ips_verify_bios_memio", 1);
6824 writel(0, ha
->mem_ptr
+ IPS_REG_FLAP
);
6825 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6826 udelay(25); /* 25 us */
6828 if (readb(ha
->mem_ptr
+ IPS_REG_FLDP
) != 0x55)
6831 writel(1, ha
->mem_ptr
+ IPS_REG_FLAP
);
6832 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6833 udelay(25); /* 25 us */
6834 if (readb(ha
->mem_ptr
+ IPS_REG_FLDP
) != 0xAA)
6838 for (i
= 2; i
< buffersize
; i
++) {
6840 writel(i
+ offset
, ha
->mem_ptr
+ IPS_REG_FLAP
);
6841 if (ha
->revision_id
== IPS_REVID_TROMBONE64
)
6842 udelay(25); /* 25 us */
6845 (uint8_t) checksum
+ readb(ha
->mem_ptr
+ IPS_REG_FLDP
);
6856 /*---------------------------------------------------------------------------*/
6857 /* Routine Name: ips_version_check */
6860 /* Assumes that ips_read_adapter_status() is called first filling in */
6861 /* the data for SubSystem Parameters. */
6862 /* Called from ips_write_driver_status() so it also assumes NVRAM Page 5 */
6863 /* Data is available. */
6865 /*---------------------------------------------------------------------------*/
6867 ips_version_check(ips_ha_t
* ha
, int intr
)
6869 IPS_VERSION_DATA
*VersionInfo
;
6870 uint8_t FirmwareVersion
[IPS_COMPAT_ID_LENGTH
+ 1];
6871 uint8_t BiosVersion
[IPS_COMPAT_ID_LENGTH
+ 1];
6874 char BiosString
[10];
6875 char FirmwareString
[10];
6877 METHOD_TRACE("ips_version_check", 1);
6879 VersionInfo
= ( IPS_VERSION_DATA
* ) ha
->ioctl_data
;
6881 memset(FirmwareVersion
, 0, IPS_COMPAT_ID_LENGTH
+ 1);
6882 memset(BiosVersion
, 0, IPS_COMPAT_ID_LENGTH
+ 1);
6884 /* Get the Compatible BIOS Version from NVRAM Page 5 */
6885 memcpy(BiosVersion
, ha
->nvram
->BiosCompatibilityID
,
6886 IPS_COMPAT_ID_LENGTH
);
6889 if (ha
->subsys
->param
[4] & IPS_GET_VERSION_SUPPORT
) { /* If Versioning is Supported */
6890 /* Get the Version Info with a Get Version Command */
6891 memset( VersionInfo
, 0, sizeof (IPS_VERSION_DATA
));
6892 rc
= ips_get_version_info(ha
, ha
->ioctl_busaddr
, intr
);
6893 if (rc
== IPS_SUCCESS
)
6894 memcpy(FirmwareVersion
, VersionInfo
->compatibilityId
,
6895 IPS_COMPAT_ID_LENGTH
);
6898 if (rc
!= IPS_SUCCESS
) { /* If Data Not Obtainable from a GetVersion Command */
6899 /* Get the Firmware Version from Enquiry Data */
6900 memcpy(FirmwareVersion
, ha
->enq
->CodeBlkVersion
,
6901 IPS_COMPAT_ID_LENGTH
);
6904 /* printk(KERN_WARNING "Adapter's BIOS Version = %s\n", BiosVersion); */
6905 /* printk(KERN_WARNING "BIOS Compatible Version = %s\n", IPS_COMPAT_BIOS); */
6906 /* printk(KERN_WARNING "Adapter's Firmware Version = %s\n", FirmwareVersion); */
6907 /* printk(KERN_WARNING "Firmware Compatible Version = %s \n", Compatable[ ha->nvram->adapter_type ]); */
6912 (FirmwareVersion
, Compatable
[ha
->nvram
->adapter_type
],
6913 IPS_COMPAT_ID_LENGTH
) != 0)
6916 if (strncmp(BiosVersion
, IPS_COMPAT_BIOS
, IPS_COMPAT_ID_LENGTH
) != 0)
6919 ha
->nvram
->versioning
= 1; /* Indicate the Driver Supports Versioning */
6922 ha
->nvram
->version_mismatch
= 1;
6923 if (ips_cd_boot
== 0) {
6924 strncpy(&BiosString
[0], ha
->nvram
->bios_high
, 4);
6925 strncpy(&BiosString
[4], ha
->nvram
->bios_low
, 4);
6928 strncpy(&FirmwareString
[0], ha
->enq
->CodeBlkVersion
, 8);
6929 FirmwareString
[8] = 0;
6931 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
6932 "Warning ! ! ! ServeRAID Version Mismatch\n");
6933 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
6934 "Bios = %s, Firmware = %s, Device Driver = %s%s\n",
6935 BiosString
, FirmwareString
, IPS_VERSION_HIGH
,
6937 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
6938 "These levels should match to avoid possible compatibility problems.\n");
6941 ha
->nvram
->version_mismatch
= 0;
6947 /*---------------------------------------------------------------------------*/
6948 /* Routine Name: ips_get_version_info */
6950 /* Routine Description: */
6951 /* Issue an internal GETVERSION Command */
6954 /* 0 if Successful, else non-zero */
6955 /*---------------------------------------------------------------------------*/
6957 ips_get_version_info(ips_ha_t
* ha
, dma_addr_t Buffer
, int intr
)
6962 METHOD_TRACE("ips_get_version_info", 1);
6964 scb
= &ha
->scbs
[ha
->max_cmds
- 1];
6966 ips_init_scb(ha
, scb
);
6968 scb
->timeout
= ips_cmd_timeout
;
6969 scb
->cdb
[0] = IPS_CMD_GET_VERSION_INFO
;
6970 scb
->cmd
.version_info
.op_code
= IPS_CMD_GET_VERSION_INFO
;
6971 scb
->cmd
.version_info
.command_id
= IPS_COMMAND_ID(ha
, scb
);
6972 scb
->cmd
.version_info
.reserved
= 0;
6973 scb
->cmd
.version_info
.count
= sizeof (IPS_VERSION_DATA
);
6974 scb
->cmd
.version_info
.reserved2
= 0;
6975 scb
->data_len
= sizeof (IPS_VERSION_DATA
);
6976 scb
->data_busaddr
= Buffer
;
6977 scb
->cmd
.version_info
.buffer_addr
= Buffer
;
6981 rc
= ips_send_wait(ha
, scb
, ips_cmd_timeout
, intr
);
6985 /****************************************************************************/
6987 /* Routine Name: ips_abort_init */
6989 /* Routine Description: */
6990 /* cleanup routine for a failed adapter initialization */
6991 /****************************************************************************/
6993 ips_abort_init(ips_ha_t
* ha
, int index
)
6997 ips_ha
[index
] = NULL
;
6998 ips_sh
[index
] = NULL
;
7002 /****************************************************************************/
7004 /* Routine Name: ips_shift_controllers */
7006 /* Routine Description: */
7007 /* helper function for ordering adapters */
7008 /****************************************************************************/
7010 ips_shift_controllers(int lowindex
, int highindex
)
7012 ips_ha_t
*ha_sav
= ips_ha
[highindex
];
7013 struct Scsi_Host
*sh_sav
= ips_sh
[highindex
];
7016 for (i
= highindex
; i
> lowindex
; i
--) {
7017 ips_ha
[i
] = ips_ha
[i
- 1];
7018 ips_sh
[i
] = ips_sh
[i
- 1];
7019 ips_ha
[i
]->host_num
= i
;
7021 ha_sav
->host_num
= lowindex
;
7022 ips_ha
[lowindex
] = ha_sav
;
7023 ips_sh
[lowindex
] = sh_sav
;
7026 /****************************************************************************/
7028 /* Routine Name: ips_order_controllers */
7030 /* Routine Description: */
7031 /* place controllers is the "proper" boot order */
7032 /****************************************************************************/
7034 ips_order_controllers(void)
7036 int i
, j
, tmp
, position
= 0;
7037 IPS_NVRAM_P5
*nvram
;
7040 nvram
= ips_ha
[0]->nvram
;
7042 if (nvram
->adapter_order
[0]) {
7043 for (i
= 1; i
<= nvram
->adapter_order
[0]; i
++) {
7044 for (j
= position
; j
< ips_num_controllers
; j
++) {
7045 switch (ips_ha
[j
]->ad_type
) {
7046 case IPS_ADTYPE_SERVERAID6M
:
7047 case IPS_ADTYPE_SERVERAID7M
:
7048 if (nvram
->adapter_order
[i
] == 'M') {
7049 ips_shift_controllers(position
,
7054 case IPS_ADTYPE_SERVERAID4L
:
7055 case IPS_ADTYPE_SERVERAID4M
:
7056 case IPS_ADTYPE_SERVERAID4MX
:
7057 case IPS_ADTYPE_SERVERAID4LX
:
7058 if (nvram
->adapter_order
[i
] == 'N') {
7059 ips_shift_controllers(position
,
7064 case IPS_ADTYPE_SERVERAID6I
:
7065 case IPS_ADTYPE_SERVERAID5I2
:
7066 case IPS_ADTYPE_SERVERAID5I1
:
7067 case IPS_ADTYPE_SERVERAID7k
:
7068 if (nvram
->adapter_order
[i
] == 'S') {
7069 ips_shift_controllers(position
,
7074 case IPS_ADTYPE_SERVERAID
:
7075 case IPS_ADTYPE_SERVERAID2
:
7076 case IPS_ADTYPE_NAVAJO
:
7077 case IPS_ADTYPE_KIOWA
:
7078 case IPS_ADTYPE_SERVERAID3L
:
7079 case IPS_ADTYPE_SERVERAID3
:
7080 case IPS_ADTYPE_SERVERAID4H
:
7081 if (nvram
->adapter_order
[i
] == 'A') {
7082 ips_shift_controllers(position
,
7092 /* if adapter_order[0], then ordering is complete */
7095 /* old bios, use older ordering */
7097 for (i
= position
; i
< ips_num_controllers
; i
++) {
7098 if (ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID5I2
||
7099 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID5I1
) {
7100 ips_shift_controllers(position
, i
);
7105 /* if there were no 5I cards, then don't do any extra ordering */
7108 for (i
= position
; i
< ips_num_controllers
; i
++) {
7109 if (ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4L
||
7110 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4M
||
7111 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4LX
||
7112 ips_ha
[i
]->ad_type
== IPS_ADTYPE_SERVERAID4MX
) {
7113 ips_shift_controllers(position
, i
);
7121 /****************************************************************************/
7123 /* Routine Name: ips_register_scsi */
7125 /* Routine Description: */
7126 /* perform any registration and setup with the scsi layer */
7127 /****************************************************************************/
7129 ips_register_scsi(int index
)
7131 struct Scsi_Host
*sh
;
7132 ips_ha_t
*ha
, *oldha
= ips_ha
[index
];
7133 sh
= scsi_host_alloc(&ips_driver_template
, sizeof (ips_ha_t
));
7135 IPS_PRINTK(KERN_WARNING
, oldha
->pcidev
,
7136 "Unable to register controller with SCSI subsystem\n");
7140 memcpy(ha
, oldha
, sizeof (ips_ha_t
));
7141 free_irq(oldha
->irq
, oldha
);
7142 /* Install the interrupt handler with the new ha */
7143 if (request_irq(ha
->irq
, do_ipsintr
, SA_SHIRQ
, ips_name
, ha
)) {
7144 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7145 "Unable to install interrupt handler\n");
7153 IPS_SCSI_SET_DEVICE(sh
, ha
);
7155 /* Store away needed values for later use */
7156 sh
->io_port
= ha
->io_addr
;
7157 sh
->n_io_port
= ha
->io_addr
? 255 : 0;
7158 sh
->unique_id
= (ha
->io_addr
) ? ha
->io_addr
: ha
->mem_addr
;
7160 sh
->sg_tablesize
= sh
->hostt
->sg_tablesize
;
7161 sh
->can_queue
= sh
->hostt
->can_queue
;
7162 sh
->cmd_per_lun
= sh
->hostt
->cmd_per_lun
;
7163 sh
->unchecked_isa_dma
= sh
->hostt
->unchecked_isa_dma
;
7164 sh
->use_clustering
= sh
->hostt
->use_clustering
;
7166 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,7)
7167 sh
->max_sectors
= 128;
7170 sh
->max_id
= ha
->ntargets
;
7171 sh
->max_lun
= ha
->nlun
;
7172 sh
->max_channel
= ha
->nbus
- 1;
7173 sh
->can_queue
= ha
->max_cmds
- 1;
7175 IPS_ADD_HOST(sh
, NULL
);
7179 /*---------------------------------------------------------------------------*/
7180 /* Routine Name: ips_remove_device */
7182 /* Routine Description: */
7183 /* Remove one Adapter ( Hot Plugging ) */
7184 /*---------------------------------------------------------------------------*/
7185 static void __devexit
7186 ips_remove_device(struct pci_dev
*pci_dev
)
7189 struct Scsi_Host
*sh
;
7192 for (i
= 0; i
< IPS_MAX_ADAPTERS
; i
++) {
7195 if ((pci_dev
->bus
->number
== ha
->pcidev
->bus
->number
) &&
7196 (pci_dev
->devfn
== ha
->pcidev
->devfn
)) {
7204 /****************************************************************************/
7206 /* Routine Name: ips_module_init */
7208 /* Routine Description: */
7209 /* function called on module load */
7210 /****************************************************************************/
7212 ips_module_init(void)
7214 if (pci_module_init(&ips_pci_driver
) < 0)
7216 ips_driver_template
.module
= THIS_MODULE
;
7217 ips_order_controllers();
7218 if (IPS_REGISTER_HOSTS(&ips_driver_template
)) {
7219 pci_unregister_driver(&ips_pci_driver
);
7222 register_reboot_notifier(&ips_notifier
);
7226 /****************************************************************************/
7228 /* Routine Name: ips_module_exit */
7230 /* Routine Description: */
7231 /* function called on module unload */
7232 /****************************************************************************/
7234 ips_module_exit(void)
7236 IPS_UNREGISTER_HOSTS(&ips_driver_template
);
7237 pci_unregister_driver(&ips_pci_driver
);
7238 unregister_reboot_notifier(&ips_notifier
);
7241 module_init(ips_module_init
);
7242 module_exit(ips_module_exit
);
7244 /*---------------------------------------------------------------------------*/
7245 /* Routine Name: ips_insert_device */
7247 /* Routine Description: */
7248 /* Add One Adapter ( Hot Plug ) */
7251 /* 0 if Successful, else non-zero */
7252 /*---------------------------------------------------------------------------*/
7253 static int __devinit
7254 ips_insert_device(struct pci_dev
*pci_dev
, const struct pci_device_id
*ent
)
7259 METHOD_TRACE("ips_insert_device", 1);
7260 if (pci_enable_device(pci_dev
))
7263 rc
= ips_init_phase1(pci_dev
, &index
);
7265 rc
= ips_init_phase2(index
);
7268 if (ips_register_scsi(index
)) {
7269 ips_free(ips_ha
[index
]);
7274 ips_num_controllers
++;
7276 ips_next_controller
= ips_num_controllers
;
7280 /*---------------------------------------------------------------------------*/
7281 /* Routine Name: ips_init_phase1 */
7283 /* Routine Description: */
7284 /* Adapter Initialization */
7287 /* 0 if Successful, else non-zero */
7288 /*---------------------------------------------------------------------------*/
7290 ips_init_phase1(struct pci_dev
*pci_dev
, int *indexPtr
)
7297 uint8_t revision_id
;
7301 uint16_t subdevice_id
;
7304 dma_addr_t dma_address
;
7305 char __iomem
*ioremap_ptr
;
7306 char __iomem
*mem_ptr
;
7309 METHOD_TRACE("ips_init_phase1", 1);
7310 index
= IPS_MAX_ADAPTERS
;
7311 for (j
= 0; j
< IPS_MAX_ADAPTERS
; j
++) {
7312 if (ips_ha
[j
] == 0) {
7318 if (index
>= IPS_MAX_ADAPTERS
)
7321 /* stuff that we get in dev */
7323 bus
= pci_dev
->bus
->number
;
7324 func
= pci_dev
->devfn
;
7326 /* Init MEM/IO addresses to 0 */
7332 for (j
= 0; j
< 2; j
++) {
7333 if (!pci_resource_start(pci_dev
, j
))
7336 if (pci_resource_flags(pci_dev
, j
) & IORESOURCE_IO
) {
7337 io_addr
= pci_resource_start(pci_dev
, j
);
7338 io_len
= pci_resource_len(pci_dev
, j
);
7340 mem_addr
= pci_resource_start(pci_dev
, j
);
7341 mem_len
= pci_resource_len(pci_dev
, j
);
7345 /* setup memory mapped area (if applicable) */
7350 if (!request_mem_region(mem_addr
, mem_len
, "ips")) {
7351 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7352 "Couldn't allocate IO Memory space %x len %d.\n",
7357 base
= mem_addr
& PAGE_MASK
;
7358 offs
= mem_addr
- base
;
7359 ioremap_ptr
= ioremap(base
, PAGE_SIZE
);
7360 mem_ptr
= ioremap_ptr
+ offs
;
7366 /* setup I/O mapped area (if applicable) */
7368 if (!request_region(io_addr
, io_len
, "ips")) {
7369 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7370 "Couldn't allocate IO space %x len %d.\n",
7376 /* get the revision ID */
7377 if (pci_read_config_byte(pci_dev
, PCI_REVISION_ID
, &revision_id
)) {
7378 IPS_PRINTK(KERN_WARNING
, pci_dev
, "Can't get revision id.\n");
7382 subdevice_id
= pci_dev
->subsystem_device
;
7384 /* found a controller */
7385 ha
= kmalloc(sizeof (ips_ha_t
), GFP_KERNEL
);
7387 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7388 "Unable to allocate temporary ha struct\n");
7392 memset(ha
, 0, sizeof (ips_ha_t
));
7394 ips_sh
[index
] = NULL
;
7398 /* Store info in HA structure */
7400 ha
->io_addr
= io_addr
;
7401 ha
->io_len
= io_len
;
7402 ha
->mem_addr
= mem_addr
;
7403 ha
->mem_len
= mem_len
;
7404 ha
->mem_ptr
= mem_ptr
;
7405 ha
->ioremap_ptr
= ioremap_ptr
;
7406 ha
->host_num
= (uint32_t) index
;
7407 ha
->revision_id
= revision_id
;
7408 ha
->slot_num
= PCI_SLOT(pci_dev
->devfn
);
7409 ha
->device_id
= pci_dev
->device
;
7410 ha
->subdevice_id
= subdevice_id
;
7411 ha
->pcidev
= pci_dev
;
7414 * Set the pci_dev's dma_mask. Not all adapters support 64bit
7415 * addressing so don't enable it if the adapter can't support
7416 * it! Also, don't use 64bit addressing if dma addresses
7417 * are guaranteed to be < 4G.
7419 if (IPS_ENABLE_DMA64
&& IPS_HAS_ENH_SGLIST(ha
) &&
7420 !pci_set_dma_mask(ha
->pcidev
, 0xffffffffffffffffULL
)) {
7421 (ha
)->flags
|= IPS_HA_ENH_SG
;
7423 if (pci_set_dma_mask(ha
->pcidev
, 0xffffffffULL
) != 0) {
7424 printk(KERN_WARNING
"Unable to set DMA Mask\n");
7425 return ips_abort_init(ha
, index
);
7428 if(ips_cd_boot
&& !ips_FlashData
){
7429 ips_FlashData
= pci_alloc_consistent(pci_dev
, PAGE_SIZE
<< 7,
7433 ha
->enq
= pci_alloc_consistent(pci_dev
, sizeof (IPS_ENQ
),
7436 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7437 "Unable to allocate host inquiry structure\n");
7438 return ips_abort_init(ha
, index
);
7441 ha
->adapt
= pci_alloc_consistent(pci_dev
, sizeof (IPS_ADAPTER
) +
7442 sizeof (IPS_IO_CMD
), &dma_address
);
7444 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7445 "Unable to allocate host adapt & dummy structures\n");
7446 return ips_abort_init(ha
, index
);
7448 ha
->adapt
->hw_status_start
= dma_address
;
7449 ha
->dummy
= (void *) (ha
->adapt
+ 1);
7453 ha
->logical_drive_info
= pci_alloc_consistent(pci_dev
, sizeof (IPS_LD_INFO
), &dma_address
);
7454 if (!ha
->logical_drive_info
) {
7455 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7456 "Unable to allocate logical drive info structure\n");
7457 return ips_abort_init(ha
, index
);
7459 ha
->logical_drive_info_dma_addr
= dma_address
;
7462 ha
->conf
= kmalloc(sizeof (IPS_CONF
), GFP_KERNEL
);
7465 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7466 "Unable to allocate host conf structure\n");
7467 return ips_abort_init(ha
, index
);
7470 ha
->nvram
= kmalloc(sizeof (IPS_NVRAM_P5
), GFP_KERNEL
);
7473 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7474 "Unable to allocate host NVRAM structure\n");
7475 return ips_abort_init(ha
, index
);
7478 ha
->subsys
= kmalloc(sizeof (IPS_SUBSYS
), GFP_KERNEL
);
7481 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7482 "Unable to allocate host subsystem structure\n");
7483 return ips_abort_init(ha
, index
);
7486 /* the ioctl buffer is now used during adapter initialization, so its
7487 * successful allocation is now required */
7488 if (ips_ioctlsize
< PAGE_SIZE
)
7489 ips_ioctlsize
= PAGE_SIZE
;
7491 ha
->ioctl_data
= pci_alloc_consistent(pci_dev
, ips_ioctlsize
,
7492 &ha
->ioctl_busaddr
);
7493 ha
->ioctl_len
= ips_ioctlsize
;
7494 if (!ha
->ioctl_data
) {
7495 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7496 "Unable to allocate IOCTL data\n");
7497 return ips_abort_init(ha
, index
);
7503 ips_setup_funclist(ha
);
7505 if ((IPS_IS_MORPHEUS(ha
)) || (IPS_IS_MARCO(ha
))) {
7506 /* If Morpheus appears dead, reset it */
7507 IsDead
= readl(ha
->mem_ptr
+ IPS_REG_I960_MSG1
);
7508 if (IsDead
== 0xDEADBEEF) {
7509 ips_reset_morpheus(ha
);
7514 * Initialize the card if it isn't already
7517 if (!(*ha
->func
.isinit
) (ha
)) {
7518 if (!(*ha
->func
.init
) (ha
)) {
7520 * Initialization failed
7522 IPS_PRINTK(KERN_WARNING
, pci_dev
,
7523 "Unable to initialize controller\n");
7524 return ips_abort_init(ha
, index
);
7532 /*---------------------------------------------------------------------------*/
7533 /* Routine Name: ips_init_phase2 */
7535 /* Routine Description: */
7536 /* Adapter Initialization Phase 2 */
7539 /* 0 if Successful, else non-zero */
7540 /*---------------------------------------------------------------------------*/
7542 ips_init_phase2(int index
)
7548 METHOD_TRACE("ips_init_phase2", 1);
7550 ips_ha
[index
] = NULL
;
7554 /* Install the interrupt handler */
7555 if (request_irq(ha
->irq
, do_ipsintr
, SA_SHIRQ
, ips_name
, ha
)) {
7556 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7557 "Unable to install interrupt handler\n");
7558 return ips_abort_init(ha
, index
);
7562 * Allocate a temporary SCB for initialization
7565 if (!ips_allocatescbs(ha
)) {
7566 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7567 "Unable to allocate a CCB\n");
7568 free_irq(ha
->irq
, ha
);
7569 return ips_abort_init(ha
, index
);
7572 if (!ips_hainit(ha
)) {
7573 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7574 "Unable to initialize controller\n");
7575 free_irq(ha
->irq
, ha
);
7576 return ips_abort_init(ha
, index
);
7578 /* Free the temporary SCB */
7579 ips_deallocatescbs(ha
, 1);
7582 if (!ips_allocatescbs(ha
)) {
7583 IPS_PRINTK(KERN_WARNING
, ha
->pcidev
,
7584 "Unable to allocate CCBs\n");
7585 free_irq(ha
->irq
, ha
);
7586 return ips_abort_init(ha
, index
);
7592 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9)
7593 MODULE_LICENSE("GPL");
7596 MODULE_DESCRIPTION("IBM ServeRAID Adapter Driver " IPS_VER_STRING
);
7598 #ifdef MODULE_VERSION
7599 MODULE_VERSION(IPS_VER_STRING
);
7604 * Overrides for Emacs so that we almost follow Linus's tabbing style.
7605 * Emacs will notice this stuff at the end of the file and automatically
7606 * adjust the settings for this buffer only. This must remain at the end
7608 * ---------------------------------------------------------------------------
7611 * c-brace-imaginary-offset: 0
7612 * c-brace-offset: -2
7613 * c-argdecl-indent: 2
7614 * c-label-offset: -2
7615 * c-continued-statement-offset: 2
7616 * c-continued-brace-offset: 0
7617 * indent-tabs-mode: nil