?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[CONNECTOR]: Initialize subsystem earlier.
[linux-2.6/verdex.git] / drivers / scsi / ips.c
bloba4c0b04cfdbdb14af7b17cdec0180a59b44c2725
1 /*****************************************************************************/
2 /* ips.c -- driver for the Adaptec / IBM ServeRAID controller */
3 /* */
4 /* Written By: Keith Mitchell, IBM Corporation */
5 /* Jack Hammer, Adaptec, Inc. */
6 /* David Jeffery, Adaptec, Inc. */
7 /* */
8 /* Copyright (C) 2000 IBM Corporation */
9 /* Copyright (C) 2002,2003 Adaptec, Inc. */
10 /* */
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. */
15 /* */
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. */
20 /* */
21 /* NO WARRANTY */
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. */
31 /* */
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 */
40 /* */
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 */
44 /* */
45 /* Bugs/Comments/Suggestions about this driver should be mailed to: */
46 /* ipslinux@adaptec.com */
47 /* */
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/ */
51 /* */
52 /*****************************************************************************/
53
54 /*****************************************************************************/
55 /* Change Log */
56 /* */
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 */
61 /* SCBs */
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 /* 7.12.05 - Remove Version Matching per IBM request */
143 /*****************************************************************************/
144
145 /*
146 * Conditional Compilation directives for this driver:
147 *
148 * IPS_DEBUG - Turn on debugging info
149 *
150 * Parameters:
151 *
152 * debug:<number> - Set debug level to <number>
153 * NOTE: only works when IPS_DEBUG compile directive is used.
154 * 1 - Normal debug messages
155 * 2 - Verbose debug messages
156 * 11 - Method trace (non interrupt)
157 * 12 - Method trace (includes interrupt)
158 *
159 * noi2o - Don't use I2O Queues (ServeRAID 4 only)
160 * nommap - Don't use memory mapped I/O
161 * ioctlsize - Initial size of the IOCTL buffer
162 */
163
164 #include <asm/io.h>
165 #include <asm/byteorder.h>
166 #include <asm/page.h>
167 #include <linux/stddef.h>
168 #include <linux/version.h>
169 #include <linux/string.h>
170 #include <linux/errno.h>
171 #include <linux/kernel.h>
172 #include <linux/ioport.h>
173 #include <linux/slab.h>
174 #include <linux/delay.h>
175 #include <linux/pci.h>
176 #include <linux/proc_fs.h>
177 #include <linux/reboot.h>
178 #include <linux/interrupt.h>
179
180 #include <linux/blkdev.h>
181 #include <linux/types.h>
182 #include <linux/dma-mapping.h>
183
184 #include <scsi/sg.h>
185
186 #include "scsi.h"
187
188 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
189 #include "hosts.h"
190 #else
191 #include <scsi/scsi_host.h>
192 #endif
193
194 #include "ips.h"
195
196 #include <linux/module.h>
197
198 #include <linux/stat.h>
199 #include <linux/config.h>
200
201 #include <linux/spinlock.h>
202 #include <linux/init.h>
203
204 #include <linux/smp.h>
205
206 #ifdef MODULE
207 static char *ips = NULL;
208 module_param(ips, charp, 0);
209 #endif
210
211 /*
212 * DRIVER_VER
213 */
214 #define IPS_VERSION_HIGH "7.12"
215 #define IPS_VERSION_LOW ".05 "
216
217 #if !defined(__i386__) && !defined(__ia64__) && !defined(__x86_64__)
218 #warning "This driver has only been tested on the x86/ia64/x86_64 platforms"
219 #endif
220
221 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,5,0)
222 #include <linux/blk.h>
223 #include "sd.h"
224 #define IPS_LOCK_SAVE(lock,flags) spin_lock_irqsave(&io_request_lock,flags)
225 #define IPS_UNLOCK_RESTORE(lock,flags) spin_unlock_irqrestore(&io_request_lock,flags)
226 #ifndef __devexit_p
227 #define __devexit_p(x) x
228 #endif
229 #else
230 #define IPS_LOCK_SAVE(lock,flags) do{spin_lock(lock);(void)flags;}while(0)
231 #define IPS_UNLOCK_RESTORE(lock,flags) do{spin_unlock(lock);(void)flags;}while(0)
232 #endif
233
234 #define IPS_DMA_DIR(scb) ((!scb->scsi_cmd || ips_is_passthru(scb->scsi_cmd) || \
235 DMA_NONE == scb->scsi_cmd->sc_data_direction) ? \
236 PCI_DMA_BIDIRECTIONAL : \
237 scb->scsi_cmd->sc_data_direction)
238
239 #ifdef IPS_DEBUG
240 #define METHOD_TRACE(s, i) if (ips_debug >= (i+10)) printk(KERN_NOTICE s "\n");
241 #define DEBUG(i, s) if (ips_debug >= i) printk(KERN_NOTICE s "\n");
242 #define DEBUG_VAR(i, s, v...) if (ips_debug >= i) printk(KERN_NOTICE s "\n", v);
243 #else
244 #define METHOD_TRACE(s, i)
245 #define DEBUG(i, s)
246 #define DEBUG_VAR(i, s, v...)
247 #endif
248
249 /*
250 * Function prototypes
251 */
252 static int ips_detect(struct scsi_host_template *);
253 static int ips_release(struct Scsi_Host *);
254 static int ips_eh_abort(Scsi_Cmnd *);
255 static int ips_eh_reset(Scsi_Cmnd *);
256 static int ips_queue(Scsi_Cmnd *, void (*)(Scsi_Cmnd *));
257 static const char *ips_info(struct Scsi_Host *);
258 static irqreturn_t do_ipsintr(int, void *, struct pt_regs *);
259 static int ips_hainit(ips_ha_t *);
260 static int ips_map_status(ips_ha_t *, ips_scb_t *, ips_stat_t *);
261 static int ips_send_wait(ips_ha_t *, ips_scb_t *, int, int);
262 static int ips_send_cmd(ips_ha_t *, ips_scb_t *);
263 static int ips_online(ips_ha_t *, ips_scb_t *);
264 static int ips_inquiry(ips_ha_t *, ips_scb_t *);
265 static int ips_rdcap(ips_ha_t *, ips_scb_t *);
266 static int ips_msense(ips_ha_t *, ips_scb_t *);
267 static int ips_reqsen(ips_ha_t *, ips_scb_t *);
268 static int ips_deallocatescbs(ips_ha_t *, int);
269 static int ips_allocatescbs(ips_ha_t *);
270 static int ips_reset_copperhead(ips_ha_t *);
271 static int ips_reset_copperhead_memio(ips_ha_t *);
272 static int ips_reset_morpheus(ips_ha_t *);
273 static int ips_issue_copperhead(ips_ha_t *, ips_scb_t *);
274 static int ips_issue_copperhead_memio(ips_ha_t *, ips_scb_t *);
275 static int ips_issue_i2o(ips_ha_t *, ips_scb_t *);
276 static int ips_issue_i2o_memio(ips_ha_t *, ips_scb_t *);
277 static int ips_isintr_copperhead(ips_ha_t *);
278 static int ips_isintr_copperhead_memio(ips_ha_t *);
279 static int ips_isintr_morpheus(ips_ha_t *);
280 static int ips_wait(ips_ha_t *, int, int);
281 static int ips_write_driver_status(ips_ha_t *, int);
282 static int ips_read_adapter_status(ips_ha_t *, int);
283 static int ips_read_subsystem_parameters(ips_ha_t *, int);
284 static int ips_read_config(ips_ha_t *, int);
285 static int ips_clear_adapter(ips_ha_t *, int);
286 static int ips_readwrite_page5(ips_ha_t *, int, int);
287 static int ips_init_copperhead(ips_ha_t *);
288 static int ips_init_copperhead_memio(ips_ha_t *);
289 static int ips_init_morpheus(ips_ha_t *);
290 static int ips_isinit_copperhead(ips_ha_t *);
291 static int ips_isinit_copperhead_memio(ips_ha_t *);
292 static int ips_isinit_morpheus(ips_ha_t *);
293 static int ips_erase_bios(ips_ha_t *);
294 static int ips_program_bios(ips_ha_t *, char *, uint32_t, uint32_t);
295 static int ips_verify_bios(ips_ha_t *, char *, uint32_t, uint32_t);
296 static int ips_erase_bios_memio(ips_ha_t *);
297 static int ips_program_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
298 static int ips_verify_bios_memio(ips_ha_t *, char *, uint32_t, uint32_t);
299 static int ips_flash_copperhead(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
300 static int ips_flash_bios(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
301 static int ips_flash_firmware(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
302 static void ips_free_flash_copperhead(ips_ha_t * ha);
303 static void ips_get_bios_version(ips_ha_t *, int);
304 static void ips_identify_controller(ips_ha_t *);
305 static void ips_chkstatus(ips_ha_t *, IPS_STATUS *);
306 static void ips_enable_int_copperhead(ips_ha_t *);
307 static void ips_enable_int_copperhead_memio(ips_ha_t *);
308 static void ips_enable_int_morpheus(ips_ha_t *);
309 static int ips_intr_copperhead(ips_ha_t *);
310 static int ips_intr_morpheus(ips_ha_t *);
311 static void ips_next(ips_ha_t *, int);
312 static void ipsintr_blocking(ips_ha_t *, struct ips_scb *);
313 static void ipsintr_done(ips_ha_t *, struct ips_scb *);
314 static void ips_done(ips_ha_t *, ips_scb_t *);
315 static void ips_free(ips_ha_t *);
316 static void ips_init_scb(ips_ha_t *, ips_scb_t *);
317 static void ips_freescb(ips_ha_t *, ips_scb_t *);
318 static void ips_setup_funclist(ips_ha_t *);
319 static void ips_statinit(ips_ha_t *);
320 static void ips_statinit_memio(ips_ha_t *);
321 static void ips_fix_ffdc_time(ips_ha_t *, ips_scb_t *, time_t);
322 static void ips_ffdc_reset(ips_ha_t *, int);
323 static void ips_ffdc_time(ips_ha_t *);
324 static uint32_t ips_statupd_copperhead(ips_ha_t *);
325 static uint32_t ips_statupd_copperhead_memio(ips_ha_t *);
326 static uint32_t ips_statupd_morpheus(ips_ha_t *);
327 static ips_scb_t *ips_getscb(ips_ha_t *);
328 static void ips_putq_scb_head(ips_scb_queue_t *, ips_scb_t *);
329 static void ips_putq_wait_tail(ips_wait_queue_t *, Scsi_Cmnd *);
330 static void ips_putq_copp_tail(ips_copp_queue_t *,
331 ips_copp_wait_item_t *);
332 static ips_scb_t *ips_removeq_scb_head(ips_scb_queue_t *);
333 static ips_scb_t *ips_removeq_scb(ips_scb_queue_t *, ips_scb_t *);
334 static Scsi_Cmnd *ips_removeq_wait_head(ips_wait_queue_t *);
335 static Scsi_Cmnd *ips_removeq_wait(ips_wait_queue_t *, Scsi_Cmnd *);
336 static ips_copp_wait_item_t *ips_removeq_copp(ips_copp_queue_t *,
337 ips_copp_wait_item_t *);
338 static ips_copp_wait_item_t *ips_removeq_copp_head(ips_copp_queue_t *);
339
340 static int ips_is_passthru(Scsi_Cmnd *);
341 static int ips_make_passthru(ips_ha_t *, Scsi_Cmnd *, ips_scb_t *, int);
342 static int ips_usrcmd(ips_ha_t *, ips_passthru_t *, ips_scb_t *);
343 static void ips_cleanup_passthru(ips_ha_t *, ips_scb_t *);
344 static void ips_scmd_buf_write(Scsi_Cmnd * scmd, void *data,
345 unsigned int count);
346 static void ips_scmd_buf_read(Scsi_Cmnd * scmd, void *data, unsigned int count);
347
348 static int ips_proc_info(struct Scsi_Host *, char *, char **, off_t, int, int);
349 static int ips_host_info(ips_ha_t *, char *, off_t, int);
350 static void copy_mem_info(IPS_INFOSTR *, char *, int);
351 static int copy_info(IPS_INFOSTR *, char *, ...);
352 static int ips_abort_init(ips_ha_t * ha, int index);
353 static int ips_init_phase2(int index);
354
355 static int ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr);
356 static int ips_register_scsi(int index);
357
358 static int ips_poll_for_flush_complete(ips_ha_t * ha);
359 static void ips_flush_and_reset(ips_ha_t *ha);
360
361 /*
362 * global variables
363 */
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 struct scsi_host_template ips_driver_template = {
382 .detect = ips_detect,
383 .release = ips_release,
384 .info = ips_info,
385 .queuecommand = ips_queue,
386 .eh_abort_handler = ips_eh_abort,
387 .eh_host_reset_handler = ips_eh_reset,
388 .proc_name = "ips",
389 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)
390 .proc_info = ips_proc_info,
391 .slave_configure = ips_slave_configure,
392 #else
393 .proc_info = ips_proc24_info,
394 .select_queue_depths = ips_select_queue_depth,
395 #endif
396 .bios_param = ips_biosparam,
397 .this_id = -1,
398 .sg_tablesize = IPS_MAX_SG,
399 .cmd_per_lun = 3,
400 .use_clustering = ENABLE_CLUSTERING,
401 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
402 .use_new_eh_code = 1,
403 #endif
404 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,20) && LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
405 .highmem_io = 1,
406 #endif
407 };
408
409
410 /* This table describes all ServeRAID Adapters */
411 static struct pci_device_id ips_pci_table[] = {
412 { 0x1014, 0x002E, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
413 { 0x1014, 0x01BD, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
414 { 0x9005, 0x0250, PCI_ANY_ID, PCI_ANY_ID, 0, 0 },
415 { 0, }
416 };
417
418 MODULE_DEVICE_TABLE( pci, ips_pci_table );
419
420 static char ips_hot_plug_name[] = "ips";
421
422 static int __devinit ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent);
423 static void __devexit ips_remove_device(struct pci_dev *pci_dev);
424
425 static struct pci_driver ips_pci_driver = {
426 .name = ips_hot_plug_name,
427 .id_table = ips_pci_table,
428 .probe = ips_insert_device,
429 .remove = __devexit_p(ips_remove_device),
430 };
431
432
433 /*
434 * Necessary forward function protoypes
435 */
436 static int ips_halt(struct notifier_block *nb, ulong event, void *buf);
437
438 #define MAX_ADAPTER_NAME 15
439
440 static char ips_adapter_name[][30] = {
441 "ServeRAID",
442 "ServeRAID II",
443 "ServeRAID on motherboard",
444 "ServeRAID on motherboard",
445 "ServeRAID 3H",
446 "ServeRAID 3L",
447 "ServeRAID 4H",
448 "ServeRAID 4M",
449 "ServeRAID 4L",
450 "ServeRAID 4Mx",
451 "ServeRAID 4Lx",
452 "ServeRAID 5i",
453 "ServeRAID 5i",
454 "ServeRAID 6M",
455 "ServeRAID 6i",
456 "ServeRAID 7t",
457 "ServeRAID 7k",
458 "ServeRAID 7M"
459 };
460
461 static struct notifier_block ips_notifier = {
462 ips_halt, NULL, 0
463 };
464
465 /*
466 * Direction table
467 */
468 static char ips_command_direction[] = {
469 IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT,
470 IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK,
471 IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
472 IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
473 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_OUT,
474 IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_OUT,
475 IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_IN,
476 IPS_DATA_UNK, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
477 IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_UNK,
478 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
479 IPS_DATA_OUT, IPS_DATA_NONE, IPS_DATA_IN, IPS_DATA_NONE, IPS_DATA_NONE,
480 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT,
481 IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_OUT,
482 IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_IN, IPS_DATA_NONE,
483 IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK,
484 IPS_DATA_NONE, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK,
485 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
486 IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
487 IPS_DATA_IN, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
488 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
489 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
490 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
491 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
492 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
493 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
494 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
495 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
496 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
497 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
498 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
499 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
500 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
501 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
502 IPS_DATA_NONE, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_NONE,
503 IPS_DATA_OUT, IPS_DATA_UNK, IPS_DATA_NONE, IPS_DATA_UNK, IPS_DATA_OUT,
504 IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_OUT, IPS_DATA_NONE,
505 IPS_DATA_UNK, IPS_DATA_IN, IPS_DATA_OUT, IPS_DATA_IN, IPS_DATA_IN,
506 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
507 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
508 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
509 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
510 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
511 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
512 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
513 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
514 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
515 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_OUT,
516 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
517 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
518 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK,
519 IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK, IPS_DATA_UNK
520 };
521
522
523 /****************************************************************************/
524 /* */
525 /* Routine Name: ips_setup */
526 /* */
527 /* Routine Description: */
528 /* */
529 /* setup parameters to the driver */
530 /* */
531 /****************************************************************************/
532 static int
533 ips_setup(char *ips_str)
534 {
535
536 int i;
537 char *key;
538 char *value;
539 IPS_OPTION options[] = {
540 {"noi2o", &ips_force_i2o, 0},
541 {"nommap", &ips_force_memio, 0},
542 {"ioctlsize", &ips_ioctlsize, IPS_IOCTL_SIZE},
543 {"cdboot", &ips_cd_boot, 0},
544 {"maxcmds", &MaxLiteCmds, 32},
545 };
546
547 /* Don't use strtok() anymore ( if 2.4 Kernel or beyond ) */
548 /* Search for value */
549 while ((key = strsep(&ips_str, ",."))) {
550 if (!*key)
551 continue;
552 value = strchr(key, ':');
553 if (value)
554 *value++ = '\0';
555 /*
556 * We now have key/value pairs.
557 * Update the variables
558 */
559 for (i = 0; i < (sizeof (options) / sizeof (options[0])); i++) {
560 if (strnicmp
561 (key, options[i].option_name,
562 strlen(options[i].option_name)) == 0) {
563 if (value)
564 *options[i].option_flag =
565 simple_strtoul(value, NULL, 0);
566 else
567 *options[i].option_flag =
568 options[i].option_value;
569 break;
570 }
571 }
572 }
573
574 return (1);
575 }
576
577 __setup("ips=", ips_setup);
578
579 /****************************************************************************/
580 /* */
581 /* Routine Name: ips_detect */
582 /* */
583 /* Routine Description: */
584 /* */
585 /* Detect and initialize the driver */
586 /* */
587 /* NOTE: this routine is called under the io_request_lock spinlock */
588 /* */
589 /****************************************************************************/
590 static int
591 ips_detect(struct scsi_host_template * SHT)
592 {
593 int i;
594
595 METHOD_TRACE("ips_detect", 1);
596
597 #ifdef MODULE
598 if (ips)
599 ips_setup(ips);
600 #endif
601
602 for (i = 0; i < ips_num_controllers; i++) {
603 if (ips_register_scsi(i))
604 ips_free(ips_ha[i]);
605 ips_released_controllers++;
606 }
607 ips_hotplug = 1;
608 return (ips_num_controllers);
609 }
610
611 /****************************************************************************/
612 /* configure the function pointers to use the functions that will work */
613 /* with the found version of the adapter */
614 /****************************************************************************/
615 static void
616 ips_setup_funclist(ips_ha_t * ha)
617 {
618
619 /*
620 * Setup Functions
621 */
622 if (IPS_IS_MORPHEUS(ha) || IPS_IS_MARCO(ha)) {
623 /* morpheus / marco / sebring */
624 ha->func.isintr = ips_isintr_morpheus;
625 ha->func.isinit = ips_isinit_morpheus;
626 ha->func.issue = ips_issue_i2o_memio;
627 ha->func.init = ips_init_morpheus;
628 ha->func.statupd = ips_statupd_morpheus;
629 ha->func.reset = ips_reset_morpheus;
630 ha->func.intr = ips_intr_morpheus;
631 ha->func.enableint = ips_enable_int_morpheus;
632 } else if (IPS_USE_MEMIO(ha)) {
633 /* copperhead w/MEMIO */
634 ha->func.isintr = ips_isintr_copperhead_memio;
635 ha->func.isinit = ips_isinit_copperhead_memio;
636 ha->func.init = ips_init_copperhead_memio;
637 ha->func.statupd = ips_statupd_copperhead_memio;
638 ha->func.statinit = ips_statinit_memio;
639 ha->func.reset = ips_reset_copperhead_memio;
640 ha->func.intr = ips_intr_copperhead;
641 ha->func.erasebios = ips_erase_bios_memio;
642 ha->func.programbios = ips_program_bios_memio;
643 ha->func.verifybios = ips_verify_bios_memio;
644 ha->func.enableint = ips_enable_int_copperhead_memio;
645 if (IPS_USE_I2O_DELIVER(ha))
646 ha->func.issue = ips_issue_i2o_memio;
647 else
648 ha->func.issue = ips_issue_copperhead_memio;
649 } else {
650 /* copperhead */
651 ha->func.isintr = ips_isintr_copperhead;
652 ha->func.isinit = ips_isinit_copperhead;
653 ha->func.init = ips_init_copperhead;
654 ha->func.statupd = ips_statupd_copperhead;
655 ha->func.statinit = ips_statinit;
656 ha->func.reset = ips_reset_copperhead;
657 ha->func.intr = ips_intr_copperhead;
658 ha->func.erasebios = ips_erase_bios;
659 ha->func.programbios = ips_program_bios;
660 ha->func.verifybios = ips_verify_bios;
661 ha->func.enableint = ips_enable_int_copperhead;
662
663 if (IPS_USE_I2O_DELIVER(ha))
664 ha->func.issue = ips_issue_i2o;
665 else
666 ha->func.issue = ips_issue_copperhead;
667 }
668 }
669
670 /****************************************************************************/
671 /* */
672 /* Routine Name: ips_release */
673 /* */
674 /* Routine Description: */
675 /* */
676 /* Remove a driver */
677 /* */
678 /****************************************************************************/
679 static int
680 ips_release(struct Scsi_Host *sh)
681 {
682 ips_scb_t *scb;
683 ips_ha_t *ha;
684 int i;
685
686 METHOD_TRACE("ips_release", 1);
687
688 for (i = 0; i < IPS_MAX_ADAPTERS && ips_sh[i] != sh; i++) ;
689
690 if (i == IPS_MAX_ADAPTERS) {
691 printk(KERN_WARNING
692 "(%s) release, invalid Scsi_Host pointer.\n", ips_name);
693 BUG();
694 return (FALSE);
695 }
696
697 ha = IPS_HA(sh);
698
699 if (!ha)
700 return (FALSE);
701
702 /* flush the cache on the controller */
703 scb = &ha->scbs[ha->max_cmds - 1];
704
705 ips_init_scb(ha, scb);
706
707 scb->timeout = ips_cmd_timeout;
708 scb->cdb[0] = IPS_CMD_FLUSH;
709
710 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
711 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
712 scb->cmd.flush_cache.state = IPS_NORM_STATE;
713 scb->cmd.flush_cache.reserved = 0;
714 scb->cmd.flush_cache.reserved2 = 0;
715 scb->cmd.flush_cache.reserved3 = 0;
716 scb->cmd.flush_cache.reserved4 = 0;
717
718 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
719
720 /* send command */
721 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) == IPS_FAILURE)
722 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Incomplete Flush.\n");
723
724 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Complete.\n");
725
726 ips_sh[i] = NULL;
727 ips_ha[i] = NULL;
728
729 /* free extra memory */
730 ips_free(ha);
731
732 /* Free I/O Region */
733 if (ha->io_addr)
734 release_region(ha->io_addr, ha->io_len);
735
736 /* free IRQ */
737 free_irq(ha->irq, ha);
738
739 IPS_REMOVE_HOST(sh);
740 scsi_host_put(sh);
741
742 ips_released_controllers++;
743
744 return (FALSE);
745 }
746
747 /****************************************************************************/
748 /* */
749 /* Routine Name: ips_halt */
750 /* */
751 /* Routine Description: */
752 /* */
753 /* Perform cleanup when the system reboots */
754 /* */
755 /****************************************************************************/
756 static int
757 ips_halt(struct notifier_block *nb, ulong event, void *buf)
758 {
759 ips_scb_t *scb;
760 ips_ha_t *ha;
761 int i;
762
763 if ((event != SYS_RESTART) && (event != SYS_HALT) &&
764 (event != SYS_POWER_OFF))
765 return (NOTIFY_DONE);
766
767 for (i = 0; i < ips_next_controller; i++) {
768 ha = (ips_ha_t *) ips_ha[i];
769
770 if (!ha)
771 continue;
772
773 if (!ha->active)
774 continue;
775
776 /* flush the cache on the controller */
777 scb = &ha->scbs[ha->max_cmds - 1];
778
779 ips_init_scb(ha, scb);
780
781 scb->timeout = ips_cmd_timeout;
782 scb->cdb[0] = IPS_CMD_FLUSH;
783
784 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
785 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
786 scb->cmd.flush_cache.state = IPS_NORM_STATE;
787 scb->cmd.flush_cache.reserved = 0;
788 scb->cmd.flush_cache.reserved2 = 0;
789 scb->cmd.flush_cache.reserved3 = 0;
790 scb->cmd.flush_cache.reserved4 = 0;
791
792 IPS_PRINTK(KERN_WARNING, ha->pcidev, "Flushing Cache.\n");
793
794 /* send command */
795 if (ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_ON) ==
796 IPS_FAILURE)
797 IPS_PRINTK(KERN_WARNING, ha->pcidev,
798 "Incomplete Flush.\n");
799 else
800 IPS_PRINTK(KERN_WARNING, ha->pcidev,
801 "Flushing Complete.\n");
802 }
803
804 return (NOTIFY_OK);
805 }
806
807 /****************************************************************************/
808 /* */
809 /* Routine Name: ips_eh_abort */
810 /* */
811 /* Routine Description: */
812 /* */
813 /* Abort a command (using the new error code stuff) */
814 /* Note: this routine is called under the io_request_lock */
815 /****************************************************************************/
816 int
817 ips_eh_abort(Scsi_Cmnd * SC)
818 {
819 ips_ha_t *ha;
820 ips_copp_wait_item_t *item;
821 int ret;
822 unsigned long cpu_flags;
823 struct Scsi_Host *host;
824
825 METHOD_TRACE("ips_eh_abort", 1);
826
827 if (!SC)
828 return (FAILED);
829
830 host = SC->device->host;
831 ha = (ips_ha_t *) SC->device->host->hostdata;
832
833 if (!ha)
834 return (FAILED);
835
836 if (!ha->active)
837 return (FAILED);
838
839 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
840
841 /* See if the command is on the copp queue */
842 item = ha->copp_waitlist.head;
843 while ((item) && (item->scsi_cmd != SC))
844 item = item->next;
845
846 if (item) {
847 /* Found it */
848 ips_removeq_copp(&ha->copp_waitlist, item);
849 ret = (SUCCESS);
850
851 /* See if the command is on the wait queue */
852 } else if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
853 /* command not sent yet */
854 ret = (SUCCESS);
855 } else {
856 /* command must have already been sent */
857 ret = (FAILED);
858 }
859
860 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
861 return ret;
862 }
863
864 /****************************************************************************/
865 /* */
866 /* Routine Name: ips_eh_reset */
867 /* */
868 /* Routine Description: */
869 /* */
870 /* Reset the controller (with new eh error code) */
871 /* */
872 /* NOTE: this routine is called under the io_request_lock spinlock */
873 /* */
874 /****************************************************************************/
875 static int
876 __ips_eh_reset(Scsi_Cmnd * SC)
877 {
878 int ret;
879 int i;
880 ips_ha_t *ha;
881 ips_scb_t *scb;
882 ips_copp_wait_item_t *item;
883
884 METHOD_TRACE("ips_eh_reset", 1);
885
886 #ifdef NO_IPS_RESET
887 return (FAILED);
888 #else
889
890 if (!SC) {
891 DEBUG(1, "Reset called with NULL scsi command");
892
893 return (FAILED);
894 }
895
896 ha = (ips_ha_t *) SC->device->host->hostdata;
897
898 if (!ha) {
899 DEBUG(1, "Reset called with NULL ha struct");
900
901 return (FAILED);
902 }
903
904 if (!ha->active)
905 return (FAILED);
906
907 /* See if the command is on the copp queue */
908 item = ha->copp_waitlist.head;
909 while ((item) && (item->scsi_cmd != SC))
910 item = item->next;
911
912 if (item) {
913 /* Found it */
914 ips_removeq_copp(&ha->copp_waitlist, item);
915 return (SUCCESS);
916 }
917
918 /* See if the command is on the wait queue */
919 if (ips_removeq_wait(&ha->scb_waitlist, SC)) {
920 /* command not sent yet */
921 return (SUCCESS);
922 }
923
924 /* An explanation for the casual observer: */
925 /* Part of the function of a RAID controller is automatic error */
926 /* detection and recovery. As such, the only problem that physically */
927 /* resetting an adapter will ever fix is when, for some reason, */
928 /* the driver is not successfully communicating with the adapter. */
929 /* Therefore, we will attempt to flush this adapter. If that succeeds, */
930 /* then there's no real purpose in a physical reset. This will complete */
931 /* much faster and avoids any problems that might be caused by a */
932 /* physical reset ( such as having to fail all the outstanding I/O's ). */
933
934 if (ha->ioctl_reset == 0) { /* IF Not an IOCTL Requested Reset */
935 scb = &ha->scbs[ha->max_cmds - 1];
936
937 ips_init_scb(ha, scb);
938
939 scb->timeout = ips_cmd_timeout;
940 scb->cdb[0] = IPS_CMD_FLUSH;
941
942 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
943 scb->cmd.flush_cache.command_id = IPS_COMMAND_ID(ha, scb);
944 scb->cmd.flush_cache.state = IPS_NORM_STATE;
945 scb->cmd.flush_cache.reserved = 0;
946 scb->cmd.flush_cache.reserved2 = 0;
947 scb->cmd.flush_cache.reserved3 = 0;
948 scb->cmd.flush_cache.reserved4 = 0;
949
950 /* Attempt the flush command */
951 ret = ips_send_wait(ha, scb, ips_cmd_timeout, IPS_INTR_IORL);
952 if (ret == IPS_SUCCESS) {
953 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
954 "Reset Request - Flushed Cache\n");
955 return (SUCCESS);
956 }
957 }
958
959 /* Either we can't communicate with the adapter or it's an IOCTL request */
960 /* from a utility. A physical reset is needed at this point. */
961
962 ha->ioctl_reset = 0; /* Reset the IOCTL Requested Reset Flag */
963
964 /*
965 * command must have already been sent
966 * reset the controller
967 */
968 IPS_PRINTK(KERN_NOTICE, ha->pcidev, "Resetting controller.\n");
969 ret = (*ha->func.reset) (ha);
970
971 if (!ret) {
972 Scsi_Cmnd *scsi_cmd;
973
974 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
975 "Controller reset failed - controller now offline.\n");
976
977 /* Now fail all of the active commands */
978 DEBUG_VAR(1, "(%s%d) Failing active commands",
979 ips_name, ha->host_num);
980
981 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
982 scb->scsi_cmd->result = DID_ERROR << 16;
983 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
984 ips_freescb(ha, scb);
985 }
986
987 /* Now fail all of the pending commands */
988 DEBUG_VAR(1, "(%s%d) Failing pending commands",
989 ips_name, ha->host_num);
990
991 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
992 scsi_cmd->result = DID_ERROR;
993 scsi_cmd->scsi_done(scsi_cmd);
994 }
995
996 ha->active = FALSE;
997 return (FAILED);
998 }
999
1000 if (!ips_clear_adapter(ha, IPS_INTR_IORL)) {
1001 Scsi_Cmnd *scsi_cmd;
1002
1003 IPS_PRINTK(KERN_NOTICE, ha->pcidev,
1004 "Controller reset failed - controller now offline.\n");
1005
1006 /* Now fail all of the active commands */
1007 DEBUG_VAR(1, "(%s%d) Failing active commands",
1008 ips_name, ha->host_num);
1009
1010 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
1011 scb->scsi_cmd->result = DID_ERROR << 16;
1012 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1013 ips_freescb(ha, scb);
1014 }
1015
1016 /* Now fail all of the pending commands */
1017 DEBUG_VAR(1, "(%s%d) Failing pending commands",
1018 ips_name, ha->host_num);
1019
1020 while ((scsi_cmd = ips_removeq_wait_head(&ha->scb_waitlist))) {
1021 scsi_cmd->result = DID_ERROR << 16;
1022 scsi_cmd->scsi_done(scsi_cmd);
1023 }
1024
1025 ha->active = FALSE;
1026 return (FAILED);
1027 }
1028
1029 /* FFDC */
1030 if (le32_to_cpu(ha->subsys->param[3]) & 0x300000) {
1031 struct timeval tv;
1032
1033 do_gettimeofday(&tv);
1034 ha->last_ffdc = tv.tv_sec;
1035 ha->reset_count++;
1036 ips_ffdc_reset(ha, IPS_INTR_IORL);
1037 }
1038
1039 /* Now fail all of the active commands */
1040 DEBUG_VAR(1, "(%s%d) Failing active commands", ips_name, ha->host_num);
1041
1042 while ((scb = ips_removeq_scb_head(&ha->scb_activelist))) {
1043 scb->scsi_cmd->result =
1044 (DID_RESET << 16) | (SUGGEST_RETRY << 24);
1045 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
1046 ips_freescb(ha, scb);
1047 }
1048
1049 /* Reset DCDB active command bits */
1050 for (i = 1; i < ha->nbus; i++)
1051 ha->dcdb_active[i - 1] = 0;
1052
1053 /* Reset the number of active IOCTLs */
1054 ha->num_ioctl = 0;
1055
1056 ips_next(ha, IPS_INTR_IORL);
1057
1058 return (SUCCESS);
1059 #endif /* NO_IPS_RESET */
1060
1061 }
1062
1063 static int
1064 ips_eh_reset(Scsi_Cmnd * SC)
1065 {
1066 int rc;
1067
1068 spin_lock_irq(SC->device->host->host_lock);
1069 rc = __ips_eh_reset(SC);
1070 spin_unlock_irq(SC->device->host->host_lock);
1071
1072 return rc;
1073 }
1074
1075 /****************************************************************************/
1076 /* */
1077 /* Routine Name: ips_queue */
1078 /* */
1079 /* Routine Description: */
1080 /* */
1081 /* Send a command to the controller */
1082 /* */
1083 /* NOTE: */
1084 /* Linux obtains io_request_lock before calling this function */
1085 /* */
1086 /****************************************************************************/
1087 static int
1088 ips_queue(Scsi_Cmnd * SC, void (*done) (Scsi_Cmnd *))
1089 {
1090 ips_ha_t *ha;
1091 ips_passthru_t *pt;
1092
1093 METHOD_TRACE("ips_queue", 1);
1094
1095 ha = (ips_ha_t *) SC->device->host->hostdata;
1096
1097 if (!ha)
1098 return (1);
1099
1100 if (!ha->active)
1101 return (DID_ERROR);
1102
1103 if (ips_is_passthru(SC)) {
1104 if (ha->copp_waitlist.count == IPS_MAX_IOCTL_QUEUE) {
1105 SC->result = DID_BUS_BUSY << 16;
1106 done(SC);
1107
1108 return (0);
1109 }
1110 } else if (ha->scb_waitlist.count == IPS_MAX_QUEUE) {
1111 SC->result = DID_BUS_BUSY << 16;
1112 done(SC);
1113
1114 return (0);
1115 }
1116
1117 SC->scsi_done = done;
1118
1119 DEBUG_VAR(2, "(%s%d): ips_queue: cmd 0x%X (%d %d %d)",
1120 ips_name,
1121 ha->host_num,
1122 SC->cmnd[0],
1123 SC->device->channel, SC->device->id, SC->device->lun);
1124
1125 /* Check for command to initiator IDs */
1126 if ((scmd_channel(SC) > 0)
1127 && (scmd_id(SC) == ha->ha_id[scmd_channel(SC)])) {
1128 SC->result = DID_NO_CONNECT << 16;
1129 done(SC);
1130
1131 return (0);
1132 }
1133
1134 if (ips_is_passthru(SC)) {
1135
1136 ips_copp_wait_item_t *scratch;
1137
1138 /* A Reset IOCTL is only sent by the boot CD in extreme cases. */
1139 /* There can never be any system activity ( network or disk ), but check */
1140 /* anyway just as a good practice. */
1141 pt = (ips_passthru_t *) SC->request_buffer;
1142 if ((pt->CoppCP.cmd.reset.op_code == IPS_CMD_RESET_CHANNEL) &&
1143 (pt->CoppCP.cmd.reset.adapter_flag == 1)) {
1144 if (ha->scb_activelist.count != 0) {
1145 SC->result = DID_BUS_BUSY << 16;
1146 done(SC);
1147 return (0);
1148 }
1149 ha->ioctl_reset = 1; /* This reset request is from an IOCTL */
1150 __ips_eh_reset(SC);
1151 SC->result = DID_OK << 16;
1152 SC->scsi_done(SC);
1153 return (0);
1154 }
1155
1156 /* allocate space for the scribble */
1157 scratch = kmalloc(sizeof (ips_copp_wait_item_t), GFP_ATOMIC);
1158
1159 if (!scratch) {
1160 SC->result = DID_ERROR << 16;
1161 done(SC);
1162
1163 return (0);
1164 }
1165
1166 scratch->scsi_cmd = SC;
1167 scratch->next = NULL;
1168
1169 ips_putq_copp_tail(&ha->copp_waitlist, scratch);
1170 } else {
1171 ips_putq_wait_tail(&ha->scb_waitlist, SC);
1172 }
1173
1174 ips_next(ha, IPS_INTR_IORL);
1175
1176 return (0);
1177 }
1178
1179 /****************************************************************************/
1180 /* */
1181 /* Routine Name: ips_biosparam */
1182 /* */
1183 /* Routine Description: */
1184 /* */
1185 /* Set bios geometry for the controller */
1186 /* */
1187 /****************************************************************************/
1188 static int
1189 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1190 ips_biosparam(Disk * disk, kdev_t dev, int geom[])
1191 {
1192 ips_ha_t *ha = (ips_ha_t *) disk->device->host->hostdata;
1193 unsigned long capacity = disk->capacity;
1194 #else
1195 ips_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1196 sector_t capacity, int geom[])
1197 {
1198 ips_ha_t *ha = (ips_ha_t *) sdev->host->hostdata;
1199 #endif
1200 int heads;
1201 int sectors;
1202 int cylinders;
1203
1204 METHOD_TRACE("ips_biosparam", 1);
1205
1206 if (!ha)
1207 /* ?!?! host adater info invalid */
1208 return (0);
1209
1210 if (!ha->active)
1211 return (0);
1212
1213 if (!ips_read_adapter_status(ha, IPS_INTR_ON))
1214 /* ?!?! Enquiry command failed */
1215 return (0);
1216
1217 if ((capacity > 0x400000) && ((ha->enq->ucMiscFlag & 0x8) == 0)) {
1218 heads = IPS_NORM_HEADS;
1219 sectors = IPS_NORM_SECTORS;
1220 } else {
1221 heads = IPS_COMP_HEADS;
1222 sectors = IPS_COMP_SECTORS;
1223 }
1224
1225 cylinders = (unsigned long) capacity / (heads * sectors);
1226
1227 DEBUG_VAR(2, "Geometry: heads: %d, sectors: %d, cylinders: %d",
1228 heads, sectors, cylinders);
1229
1230 geom[0] = heads;
1231 geom[1] = sectors;
1232 geom[2] = cylinders;
1233
1234 return (0);
1235 }
1236
1237 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)
1238
1239 /* ips_proc24_info is a wrapper around ips_proc_info *
1240 * for compatibility with the 2.4 scsi parameters */
1241 static int
1242 ips_proc24_info(char *buffer, char **start, off_t offset, int length,
1243 int hostno, int func)
1244 {
1245 int i;
1246
1247 for (i = 0; i < ips_next_controller; i++) {
1248 if (ips_sh[i] && ips_sh[i]->host_no == hostno) {
1249 return ips_proc_info(ips_sh[i], buffer, start,
1250 offset, length, func);
1251 }
1252 }
1253 return -EINVAL;
1254 }
1255
1256 /****************************************************************************/
1257 /* */
1258 /* Routine Name: ips_select_queue_depth */
1259 /* */
1260 /* Routine Description: */
1261 /* */
1262 /* Select queue depths for the devices on the contoller */
1263 /* */
1264 /****************************************************************************/
1265 static void
1266 ips_select_queue_depth(struct Scsi_Host *host, struct scsi_device * scsi_devs)
1267 {
1268 struct scsi_device *device;
1269 ips_ha_t *ha;
1270 int count = 0;
1271 int min;
1272
1273 ha = IPS_HA(host);
1274 min = ha->max_cmds / 4;
1275
1276 for (device = scsi_devs; device; device = device->next) {
1277 if (device->host == host) {
1278 if ((device->channel == 0) && (device->type == 0))
1279 count++;
1280 }
1281 }
1282
1283 for (device = scsi_devs; device; device = device->next) {
1284 if (device->host == host) {
1285 if ((device->channel == 0) && (device->type == 0)) {
1286 device->queue_depth =
1287 (ha->max_cmds - 1) / count;
1288 if (device->queue_depth < min)
1289 device->queue_depth = min;
1290 } else {
1291 device->queue_depth = 2;
1292 }
1293
1294 if (device->queue_depth < 2)
1295 device->queue_depth = 2;
1296 }
1297 }
1298 }
1299
1300 #else
1301 /****************************************************************************/
1302 /* */
1303 /* Routine Name: ips_slave_configure */
1304 /* */
1305 /* Routine Description: */
1306 /* */
1307 /* Set queue depths on devices once scan is complete */
1308 /* */
1309 /****************************************************************************/
1310 static int
1311 ips_slave_configure(struct scsi_device * SDptr)
1312 {
1313 ips_ha_t *ha;
1314 int min;
1315
1316 ha = IPS_HA(SDptr->host);
1317 if (SDptr->tagged_supported && SDptr->type == TYPE_DISK) {
1318 min = ha->max_cmds / 2;
1319 if (ha->enq->ucLogDriveCount <= 2)
1320 min = ha->max_cmds - 1;
1321 scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, min);
1322 }
1323
1324 SDptr->skip_ms_page_8 = 1;
1325 SDptr->skip_ms_page_3f = 1;
1326 return 0;
1327 }
1328 #endif
1329
1330 /****************************************************************************/
1331 /* */
1332 /* Routine Name: do_ipsintr */
1333 /* */
1334 /* Routine Description: */
1335 /* */
1336 /* Wrapper for the interrupt handler */
1337 /* */
1338 /****************************************************************************/
1339 static irqreturn_t
1340 do_ipsintr(int irq, void *dev_id, struct pt_regs * regs)
1341 {
1342 ips_ha_t *ha;
1343 unsigned long cpu_flags;
1344 struct Scsi_Host *host;
1345 int irqstatus;
1346
1347 METHOD_TRACE("do_ipsintr", 2);
1348
1349 ha = (ips_ha_t *) dev_id;
1350 if (!ha)
1351 return IRQ_NONE;
1352 host = ips_sh[ha->host_num];
1353 /* interrupt during initialization */
1354 if (!host) {
1355 (*ha->func.intr) (ha);
1356 return IRQ_HANDLED;
1357 }
1358
1359 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
1360
1361 if (!ha->active) {
1362 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1363 return IRQ_HANDLED;
1364 }
1365
1366 irqstatus = (*ha->func.intr) (ha);
1367
1368 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
1369
1370 /* start the next command */
1371 ips_next(ha, IPS_INTR_ON);
1372 return IRQ_RETVAL(irqstatus);
1373 }
1374
1375 /****************************************************************************/
1376 /* */
1377 /* Routine Name: ips_intr_copperhead */
1378 /* */
1379 /* Routine Description: */
1380 /* */
1381 /* Polling interrupt handler */
1382 /* */
1383 /* ASSUMES interrupts are disabled */
1384 /* */
1385 /****************************************************************************/
1386 int
1387 ips_intr_copperhead(ips_ha_t * ha)
1388 {
1389 ips_stat_t *sp;
1390 ips_scb_t *scb;
1391 IPS_STATUS cstatus;
1392 int intrstatus;
1393
1394 METHOD_TRACE("ips_intr", 2);
1395
1396 if (!ha)
1397 return 0;
1398
1399 if (!ha->active)
1400 return 0;
1401
1402 intrstatus = (*ha->func.isintr) (ha);
1403
1404 if (!intrstatus) {
1405 /*
1406 * Unexpected/Shared interrupt
1407 */
1408
1409 return 0;
1410 }
1411
1412 while (TRUE) {
1413 sp = &ha->sp;
1414
1415 intrstatus = (*ha->func.isintr) (ha);
1416
1417 if (!intrstatus)
1418 break;
1419 else
1420 cstatus.value = (*ha->func.statupd) (ha);
1421
1422 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1423 /* Spurious Interupt ? */
1424 continue;
1425 }
1426
1427 ips_chkstatus(ha, &cstatus);
1428 scb = (ips_scb_t *) sp->scb_addr;
1429
1430 /*
1431 * use the callback function to finish things up
1432 * NOTE: interrupts are OFF for this
1433 */
1434 (*scb->callback) (ha, scb);
1435 } /* end while */
1436 return 1;
1437 }
1438
1439 /****************************************************************************/
1440 /* */
1441 /* Routine Name: ips_intr_morpheus */
1442 /* */
1443 /* Routine Description: */
1444 /* */
1445 /* Polling interrupt handler */
1446 /* */
1447 /* ASSUMES interrupts are disabled */
1448 /* */
1449 /****************************************************************************/
1450 int
1451 ips_intr_morpheus(ips_ha_t * ha)
1452 {
1453 ips_stat_t *sp;
1454 ips_scb_t *scb;
1455 IPS_STATUS cstatus;
1456 int intrstatus;
1457
1458 METHOD_TRACE("ips_intr_morpheus", 2);
1459
1460 if (!ha)
1461 return 0;
1462
1463 if (!ha->active)
1464 return 0;
1465
1466 intrstatus = (*ha->func.isintr) (ha);
1467
1468 if (!intrstatus) {
1469 /*
1470 * Unexpected/Shared interrupt
1471 */
1472
1473 return 0;
1474 }
1475
1476 while (TRUE) {
1477 sp = &ha->sp;
1478
1479 intrstatus = (*ha->func.isintr) (ha);
1480
1481 if (!intrstatus)
1482 break;
1483 else
1484 cstatus.value = (*ha->func.statupd) (ha);
1485
1486 if (cstatus.value == 0xffffffff)
1487 /* No more to process */
1488 break;
1489
1490 if (cstatus.fields.command_id > (IPS_MAX_CMDS - 1)) {
1491 IPS_PRINTK(KERN_WARNING, ha->pcidev,
1492 "Spurious interrupt; no ccb.\n");
1493
1494 continue;
1495 }
1496
1497 ips_chkstatus(ha, &cstatus);
1498 scb = (ips_scb_t *) sp->scb_addr;
1499
1500 /*
1501 * use the callback function to finish things up
1502 * NOTE: interrupts are OFF for this
1503 */
1504 (*scb->callback) (ha, scb);
1505 } /* end while */
1506 return 1;
1507 }
1508
1509 /****************************************************************************/
1510 /* */
1511 /* Routine Name: ips_info */
1512 /* */
1513 /* Routine Description: */
1514 /* */
1515 /* Return info about the driver */
1516 /* */
1517 /****************************************************************************/
1518 static const char *
1519 ips_info(struct Scsi_Host *SH)
1520 {
1521 static char buffer[256];
1522 char *bp;
1523 ips_ha_t *ha;
1524
1525 METHOD_TRACE("ips_info", 1);
1526
1527 ha = IPS_HA(SH);
1528
1529 if (!ha)
1530 return (NULL);
1531
1532 bp = &buffer[0];
1533 memset(bp, 0, sizeof (buffer));
1534
1535 sprintf(bp, "%s%s%s Build %d", "IBM PCI ServeRAID ",
1536 IPS_VERSION_HIGH, IPS_VERSION_LOW, IPS_BUILD_IDENT);
1537
1538 if (ha->ad_type > 0 && ha->ad_type <= MAX_ADAPTER_NAME) {
1539 strcat(bp, " <");
1540 strcat(bp, ips_adapter_name[ha->ad_type - 1]);
1541 strcat(bp, ">");
1542 }
1543
1544 return (bp);
1545 }
1546
1547 /****************************************************************************/
1548 /* */
1549 /* Routine Name: ips_proc_info */
1550 /* */
1551 /* Routine Description: */
1552 /* */
1553 /* The passthru interface for the driver */
1554 /* */
1555 /****************************************************************************/
1556 static int
1557 ips_proc_info(struct Scsi_Host *host, char *buffer, char **start, off_t offset,
1558 int length, int func)
1559 {
1560 int i;
1561 int ret;
1562 ips_ha_t *ha = NULL;
1563
1564 METHOD_TRACE("ips_proc_info", 1);
1565
1566 /* Find our host structure */
1567 for (i = 0; i < ips_next_controller; i++) {
1568 if (ips_sh[i]) {
1569 if (ips_sh[i] == host) {
1570 ha = (ips_ha_t *) ips_sh[i]->hostdata;
1571 break;
1572 }
1573 }
1574 }
1575
1576 if (!ha)
1577 return (-EINVAL);
1578
1579 if (func) {
1580 /* write */
1581 return (0);
1582 } else {
1583 /* read */
1584 if (start)
1585 *start = buffer;
1586
1587 ret = ips_host_info(ha, buffer, offset, length);
1588
1589 return (ret);
1590 }
1591 }
1592
1593 /*--------------------------------------------------------------------------*/
1594 /* Helper Functions */
1595 /*--------------------------------------------------------------------------*/
1596
1597 /****************************************************************************/
1598 /* */
1599 /* Routine Name: ips_is_passthru */
1600 /* */
1601 /* Routine Description: */
1602 /* */
1603 /* Determine if the specified SCSI command is really a passthru command */
1604 /* */
1605 /****************************************************************************/
1606 static int
1607 ips_is_passthru(Scsi_Cmnd * SC)
1608 {
1609 unsigned long flags;
1610
1611 METHOD_TRACE("ips_is_passthru", 1);
1612
1613 if (!SC)
1614 return (0);
1615
1616 if ((SC->cmnd[0] == IPS_IOCTL_COMMAND) &&
1617 (SC->device->channel == 0) &&
1618 (SC->device->id == IPS_ADAPTER_ID) &&
1619 (SC->device->lun == 0) && SC->request_buffer) {
1620 if ((!SC->use_sg) && SC->request_bufflen &&
1621 (((char *) SC->request_buffer)[0] == 'C') &&
1622 (((char *) SC->request_buffer)[1] == 'O') &&
1623 (((char *) SC->request_buffer)[2] == 'P') &&
1624 (((char *) SC->request_buffer)[3] == 'P'))
1625 return 1;
1626 else if (SC->use_sg) {
1627 struct scatterlist *sg = SC->request_buffer;
1628 char *buffer;
1629
1630 /* kmap_atomic() ensures addressability of the user buffer.*/
1631 /* local_irq_save() protects the KM_IRQ0 address slot. */
1632 local_irq_save(flags);
1633 buffer = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1634 if (buffer && buffer[0] == 'C' && buffer[1] == 'O' &&
1635 buffer[2] == 'P' && buffer[3] == 'P') {
1636 kunmap_atomic(buffer - sg->offset, KM_IRQ0);
1637 local_irq_restore(flags);
1638 return 1;
1639 }
1640 kunmap_atomic(buffer - sg->offset, KM_IRQ0);
1641 local_irq_restore(flags);
1642 }
1643 }
1644 return 0;
1645 }
1646
1647 /****************************************************************************/
1648 /* */
1649 /* Routine Name: ips_alloc_passthru_buffer */
1650 /* */
1651 /* Routine Description: */
1652 /* allocate a buffer large enough for the ioctl data if the ioctl buffer */
1653 /* is too small or doesn't exist */
1654 /****************************************************************************/
1655 static int
1656 ips_alloc_passthru_buffer(ips_ha_t * ha, int length)
1657 {
1658 void *bigger_buf;
1659 dma_addr_t dma_busaddr;
1660
1661 if (ha->ioctl_data && length <= ha->ioctl_len)
1662 return 0;
1663 /* there is no buffer or it's not big enough, allocate a new one */
1664 bigger_buf = pci_alloc_consistent(ha->pcidev, length, &dma_busaddr);
1665 if (bigger_buf) {
1666 /* free the old memory */
1667 pci_free_consistent(ha->pcidev, ha->ioctl_len, ha->ioctl_data,
1668 ha->ioctl_busaddr);
1669 /* use the new memory */
1670 ha->ioctl_data = (char *) bigger_buf;
1671 ha->ioctl_len = length;
1672 ha->ioctl_busaddr = dma_busaddr;
1673 } else {
1674 return -1;
1675 }
1676 return 0;
1677 }
1678
1679 /****************************************************************************/
1680 /* */
1681 /* Routine Name: ips_make_passthru */
1682 /* */
1683 /* Routine Description: */
1684 /* */
1685 /* Make a passthru command out of the info in the Scsi block */
1686 /* */
1687 /****************************************************************************/
1688 static int
1689 ips_make_passthru(ips_ha_t * ha, Scsi_Cmnd * SC, ips_scb_t * scb, int intr)
1690 {
1691 ips_passthru_t *pt;
1692 int length = 0;
1693 int ret;
1694
1695 METHOD_TRACE("ips_make_passthru", 1);
1696
1697 if (!SC->use_sg) {
1698 length = SC->request_bufflen;
1699 } else {
1700 struct scatterlist *sg = SC->request_buffer;
1701 int i;
1702 for (i = 0; i < SC->use_sg; i++)
1703 length += sg[i].length;
1704 }
1705 if (length < sizeof (ips_passthru_t)) {
1706 /* wrong size */
1707 DEBUG_VAR(1, "(%s%d) Passthru structure wrong size",
1708 ips_name, ha->host_num);
1709 return (IPS_FAILURE);
1710 }
1711 if (ips_alloc_passthru_buffer(ha, length)) {
1712 /* allocation failure! If ha->ioctl_data exists, use it to return
1713 some error codes. Return a failed command to the scsi layer. */
1714 if (ha->ioctl_data) {
1715 pt = (ips_passthru_t *) ha->ioctl_data;
1716 ips_scmd_buf_read(SC, pt, sizeof (ips_passthru_t));
1717 pt->BasicStatus = 0x0B;
1718 pt->ExtendedStatus = 0x00;
1719 ips_scmd_buf_write(SC, pt, sizeof (ips_passthru_t));
1720 }
1721 return IPS_FAILURE;
1722 }
1723 ha->ioctl_datasize = length;
1724
1725 ips_scmd_buf_read(SC, ha->ioctl_data, ha->ioctl_datasize);
1726 pt = (ips_passthru_t *) ha->ioctl_data;
1727
1728 /*
1729 * Some notes about the passthru interface used
1730 *
1731 * IF the scsi op_code == 0x0d then we assume
1732 * that the data came along with/goes with the
1733 * packet we received from the sg driver. In this
1734 * case the CmdBSize field of the pt structure is
1735 * used for the size of the buffer.
1736 */
1737
1738 switch (pt->CoppCmd) {
1739 case IPS_NUMCTRLS:
1740 memcpy(ha->ioctl_data + sizeof (ips_passthru_t),
1741 &ips_num_controllers, sizeof (int));
1742 ips_scmd_buf_write(SC, ha->ioctl_data,
1743 sizeof (ips_passthru_t) + sizeof (int));
1744 SC->result = DID_OK << 16;
1745
1746 return (IPS_SUCCESS_IMM);
1747
1748 case IPS_COPPUSRCMD:
1749 case IPS_COPPIOCCMD:
1750 if (SC->cmnd[0] == IPS_IOCTL_COMMAND) {
1751 if (length < (sizeof (ips_passthru_t) + pt->CmdBSize)) {
1752 /* wrong size */
1753 DEBUG_VAR(1,
1754 "(%s%d) Passthru structure wrong size",
1755 ips_name, ha->host_num);
1756
1757 return (IPS_FAILURE);
1758 }
1759
1760 if (ha->device_id == IPS_DEVICEID_COPPERHEAD &&
1761 pt->CoppCP.cmd.flashfw.op_code ==
1762 IPS_CMD_RW_BIOSFW) {
1763 ret = ips_flash_copperhead(ha, pt, scb);
1764 ips_scmd_buf_write(SC, ha->ioctl_data,
1765 sizeof (ips_passthru_t));
1766 return ret;
1767 }
1768 if (ips_usrcmd(ha, pt, scb))
1769 return (IPS_SUCCESS);
1770 else
1771 return (IPS_FAILURE);
1772 }
1773
1774 break;
1775
1776 } /* end switch */
1777
1778 return (IPS_FAILURE);
1779 }
1780
1781 /****************************************************************************/
1782 /* Routine Name: ips_flash_copperhead */
1783 /* Routine Description: */
1784 /* Flash the BIOS/FW on a Copperhead style controller */
1785 /****************************************************************************/
1786 static int
1787 ips_flash_copperhead(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1788 {
1789 int datasize;
1790
1791 /* Trombone is the only copperhead that can do packet flash, but only
1792 * for firmware. No one said it had to make sence. */
1793 if (IPS_IS_TROMBONE(ha) && pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE) {
1794 if (ips_usrcmd(ha, pt, scb))
1795 return IPS_SUCCESS;
1796 else
1797 return IPS_FAILURE;
1798 }
1799 pt->BasicStatus = 0x0B;
1800 pt->ExtendedStatus = 0;
1801 scb->scsi_cmd->result = DID_OK << 16;
1802 /* IF it's OK to Use the "CD BOOT" Flash Buffer, then you can */
1803 /* avoid allocating a huge buffer per adapter ( which can fail ). */
1804 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1805 pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1806 pt->BasicStatus = 0;
1807 return ips_flash_bios(ha, pt, scb);
1808 } else if (pt->CoppCP.cmd.flashfw.packet_num == 0) {
1809 if (ips_FlashData && !test_and_set_bit(0, &ips_FlashDataInUse)){
1810 ha->flash_data = ips_FlashData;
1811 ha->flash_busaddr = ips_flashbusaddr;
1812 ha->flash_len = PAGE_SIZE << 7;
1813 ha->flash_datasize = 0;
1814 } else if (!ha->flash_data) {
1815 datasize = pt->CoppCP.cmd.flashfw.total_packets *
1816 pt->CoppCP.cmd.flashfw.count;
1817 ha->flash_data = pci_alloc_consistent(ha->pcidev,
1818 datasize,
1819 &ha->flash_busaddr);
1820 if (!ha->flash_data){
1821 printk(KERN_WARNING "Unable to allocate a flash buffer\n");
1822 return IPS_FAILURE;
1823 }
1824 ha->flash_datasize = 0;
1825 ha->flash_len = datasize;
1826 } else
1827 return IPS_FAILURE;
1828 } else {
1829 if (pt->CoppCP.cmd.flashfw.count + ha->flash_datasize >
1830 ha->flash_len) {
1831 ips_free_flash_copperhead(ha);
1832 IPS_PRINTK(KERN_WARNING, ha->pcidev,
1833 "failed size sanity check\n");
1834 return IPS_FAILURE;
1835 }
1836 }
1837 if (!ha->flash_data)
1838 return IPS_FAILURE;
1839 pt->BasicStatus = 0;
1840 memcpy(&ha->flash_data[ha->flash_datasize], pt + 1,
1841 pt->CoppCP.cmd.flashfw.count);
1842 ha->flash_datasize += pt->CoppCP.cmd.flashfw.count;
1843 if (pt->CoppCP.cmd.flashfw.packet_num ==
1844 pt->CoppCP.cmd.flashfw.total_packets - 1) {
1845 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE)
1846 return ips_flash_bios(ha, pt, scb);
1847 else if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE)
1848 return ips_flash_firmware(ha, pt, scb);
1849 }
1850 return IPS_SUCCESS_IMM;
1851 }
1852
1853 /****************************************************************************/
1854 /* Routine Name: ips_flash_bios */
1855 /* Routine Description: */
1856 /* flashes the bios of a copperhead adapter */
1857 /****************************************************************************/
1858 static int
1859 ips_flash_bios(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1860 {
1861
1862 if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1863 pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_BIOS) {
1864 if ((!ha->func.programbios) || (!ha->func.erasebios) ||
1865 (!ha->func.verifybios))
1866 goto error;
1867 if ((*ha->func.erasebios) (ha)) {
1868 DEBUG_VAR(1,
1869 "(%s%d) flash bios failed - unable to erase flash",
1870 ips_name, ha->host_num);
1871 goto error;
1872 } else
1873 if ((*ha->func.programbios) (ha,
1874 ha->flash_data +
1875 IPS_BIOS_HEADER,
1876 ha->flash_datasize -
1877 IPS_BIOS_HEADER, 0)) {
1878 DEBUG_VAR(1,
1879 "(%s%d) flash bios failed - unable to flash",
1880 ips_name, ha->host_num);
1881 goto error;
1882 } else
1883 if ((*ha->func.verifybios) (ha,
1884 ha->flash_data +
1885 IPS_BIOS_HEADER,
1886 ha->flash_datasize -
1887 IPS_BIOS_HEADER, 0)) {
1888 DEBUG_VAR(1,
1889 "(%s%d) flash bios failed - unable to verify flash",
1890 ips_name, ha->host_num);
1891 goto error;
1892 }
1893 ips_free_flash_copperhead(ha);
1894 return IPS_SUCCESS_IMM;
1895 } else if (pt->CoppCP.cmd.flashfw.type == IPS_BIOS_IMAGE &&
1896 pt->CoppCP.cmd.flashfw.direction == IPS_ERASE_BIOS) {
1897 if (!ha->func.erasebios)
1898 goto error;
1899 if ((*ha->func.erasebios) (ha)) {
1900 DEBUG_VAR(1,
1901 "(%s%d) flash bios failed - unable to erase flash",
1902 ips_name, ha->host_num);
1903 goto error;
1904 }
1905 return IPS_SUCCESS_IMM;
1906 }
1907 error:
1908 pt->BasicStatus = 0x0B;
1909 pt->ExtendedStatus = 0x00;
1910 ips_free_flash_copperhead(ha);
1911 return IPS_FAILURE;
1912 }
1913
1914 /****************************************************************************/
1915 /* */
1916 /* Routine Name: ips_fill_scb_sg_single */
1917 /* */
1918 /* Routine Description: */
1919 /* Fill in a single scb sg_list element from an address */
1920 /* return a -1 if a breakup occurred */
1921 /****************************************************************************/
1922 static int
1923 ips_fill_scb_sg_single(ips_ha_t * ha, dma_addr_t busaddr,
1924 ips_scb_t * scb, int indx, unsigned int e_len)
1925 {
1926
1927 int ret_val = 0;
1928
1929 if ((scb->data_len + e_len) > ha->max_xfer) {
1930 e_len = ha->max_xfer - scb->data_len;
1931 scb->breakup = indx;
1932 ++scb->sg_break;
1933 ret_val = -1;
1934 } else {
1935 scb->breakup = 0;
1936 scb->sg_break = 0;
1937 }
1938 if (IPS_USE_ENH_SGLIST(ha)) {
1939 scb->sg_list.enh_list[indx].address_lo =
1940 cpu_to_le32(pci_dma_lo32(busaddr));
1941 scb->sg_list.enh_list[indx].address_hi =
1942 cpu_to_le32(pci_dma_hi32(busaddr));
1943 scb->sg_list.enh_list[indx].length = cpu_to_le32(e_len);
1944 } else {
1945 scb->sg_list.std_list[indx].address =
1946 cpu_to_le32(pci_dma_lo32(busaddr));
1947 scb->sg_list.std_list[indx].length = cpu_to_le32(e_len);
1948 }
1949
1950 ++scb->sg_len;
1951 scb->data_len += e_len;
1952 return ret_val;
1953 }
1954
1955 /****************************************************************************/
1956 /* Routine Name: ips_flash_firmware */
1957 /* Routine Description: */
1958 /* flashes the firmware of a copperhead adapter */
1959 /****************************************************************************/
1960 static int
1961 ips_flash_firmware(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
1962 {
1963 IPS_SG_LIST sg_list;
1964 uint32_t cmd_busaddr;
1965
1966 if (pt->CoppCP.cmd.flashfw.type == IPS_FW_IMAGE &&
1967 pt->CoppCP.cmd.flashfw.direction == IPS_WRITE_FW) {
1968 memset(&pt->CoppCP.cmd, 0, sizeof (IPS_HOST_COMMAND));
1969 pt->CoppCP.cmd.flashfw.op_code = IPS_CMD_DOWNLOAD;
1970 pt->CoppCP.cmd.flashfw.count = cpu_to_le32(ha->flash_datasize);
1971 } else {
1972 pt->BasicStatus = 0x0B;
1973 pt->ExtendedStatus = 0x00;
1974 ips_free_flash_copperhead(ha);
1975 return IPS_FAILURE;
1976 }
1977 /* Save the S/G list pointer so it doesn't get clobbered */
1978 sg_list.list = scb->sg_list.list;
1979 cmd_busaddr = scb->scb_busaddr;
1980 /* copy in the CP */
1981 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
1982 /* FIX stuff that might be wrong */
1983 scb->sg_list.list = sg_list.list;
1984 scb->scb_busaddr = cmd_busaddr;
1985 scb->bus = scb->scsi_cmd->device->channel;
1986 scb->target_id = scb->scsi_cmd->device->id;
1987 scb->lun = scb->scsi_cmd->device->lun;
1988 scb->sg_len = 0;
1989 scb->data_len = 0;
1990 scb->flags = 0;
1991 scb->op_code = 0;
1992 scb->callback = ipsintr_done;
1993 scb->timeout = ips_cmd_timeout;
1994
1995 scb->data_len = ha->flash_datasize;
1996 scb->data_busaddr =
1997 pci_map_single(ha->pcidev, ha->flash_data, scb->data_len,
1998 IPS_DMA_DIR(scb));
1999 scb->flags |= IPS_SCB_MAP_SINGLE;
2000 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
2001 scb->cmd.flashfw.buffer_addr = cpu_to_le32(scb->data_busaddr);
2002 if (pt->TimeOut)
2003 scb->timeout = pt->TimeOut;
2004 scb->scsi_cmd->result = DID_OK << 16;
2005 return IPS_SUCCESS;
2006 }
2007
2008 /****************************************************************************/
2009 /* Routine Name: ips_free_flash_copperhead */
2010 /* Routine Description: */
2011 /* release the memory resources used to hold the flash image */
2012 /****************************************************************************/
2013 static void
2014 ips_free_flash_copperhead(ips_ha_t * ha)
2015 {
2016 if (ha->flash_data == ips_FlashData)
2017 test_and_clear_bit(0, &ips_FlashDataInUse);
2018 else if (ha->flash_data)
2019 pci_free_consistent(ha->pcidev, ha->flash_len, ha->flash_data,
2020 ha->flash_busaddr);
2021 ha->flash_data = NULL;
2022 }
2023
2024 /****************************************************************************/
2025 /* */
2026 /* Routine Name: ips_usrcmd */
2027 /* */
2028 /* Routine Description: */
2029 /* */
2030 /* Process a user command and make it ready to send */
2031 /* */
2032 /****************************************************************************/
2033 static int
2034 ips_usrcmd(ips_ha_t * ha, ips_passthru_t * pt, ips_scb_t * scb)
2035 {
2036 IPS_SG_LIST sg_list;
2037 uint32_t cmd_busaddr;
2038
2039 METHOD_TRACE("ips_usrcmd", 1);
2040
2041 if ((!scb) || (!pt) || (!ha))
2042 return (0);
2043
2044 /* Save the S/G list pointer so it doesn't get clobbered */
2045 sg_list.list = scb->sg_list.list;
2046 cmd_busaddr = scb->scb_busaddr;
2047 /* copy in the CP */
2048 memcpy(&scb->cmd, &pt->CoppCP.cmd, sizeof (IPS_IOCTL_CMD));
2049 memcpy(&scb->dcdb, &pt->CoppCP.dcdb, sizeof (IPS_DCDB_TABLE));
2050
2051 /* FIX stuff that might be wrong */
2052 scb->sg_list.list = sg_list.list;
2053 scb->scb_busaddr = cmd_busaddr;
2054 scb->bus = scb->scsi_cmd->device->channel;
2055 scb->target_id = scb->scsi_cmd->device->id;
2056 scb->lun = scb->scsi_cmd->device->lun;
2057 scb->sg_len = 0;
2058 scb->data_len = 0;
2059 scb->flags = 0;
2060 scb->op_code = 0;
2061 scb->callback = ipsintr_done;
2062 scb->timeout = ips_cmd_timeout;
2063 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
2064
2065 /* we don't support DCDB/READ/WRITE Scatter Gather */
2066 if ((scb->cmd.basic_io.op_code == IPS_CMD_READ_SG) ||
2067 (scb->cmd.basic_io.op_code == IPS_CMD_WRITE_SG) ||
2068 (scb->cmd.basic_io.op_code == IPS_CMD_DCDB_SG))
2069 return (0);
2070
2071 if (pt->CmdBSize) {
2072 scb->data_len = pt->CmdBSize;
2073 scb->data_busaddr = ha->ioctl_busaddr + sizeof (ips_passthru_t);
2074 } else {
2075 scb->data_busaddr = 0L;
2076 }
2077
2078 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
2079 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
2080 (unsigned long) &scb->
2081 dcdb -
2082 (unsigned long) scb);
2083
2084 if (pt->CmdBSize) {
2085 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB)
2086 scb->dcdb.buffer_pointer =
2087 cpu_to_le32(scb->data_busaddr);
2088 else
2089 scb->cmd.basic_io.sg_addr =
2090 cpu_to_le32(scb->data_busaddr);
2091 }
2092
2093 /* set timeouts */
2094 if (pt->TimeOut) {
2095 scb->timeout = pt->TimeOut;
2096
2097 if (pt->TimeOut <= 10)
2098 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10;
2099 else if (pt->TimeOut <= 60)
2100 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60;
2101 else
2102 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M;
2103 }
2104
2105 /* assume success */
2106 scb->scsi_cmd->result = DID_OK << 16;
2107
2108 /* success */
2109 return (1);
2110 }
2111
2112 /****************************************************************************/
2113 /* */
2114 /* Routine Name: ips_cleanup_passthru */
2115 /* */
2116 /* Routine Description: */
2117 /* */
2118 /* Cleanup after a passthru command */
2119 /* */
2120 /****************************************************************************/
2121 static void
2122 ips_cleanup_passthru(ips_ha_t * ha, ips_scb_t * scb)
2123 {
2124 ips_passthru_t *pt;
2125
2126 METHOD_TRACE("ips_cleanup_passthru", 1);
2127
2128 if ((!scb) || (!scb->scsi_cmd) || (!scb->scsi_cmd->request_buffer)) {
2129 DEBUG_VAR(1, "(%s%d) couldn't cleanup after passthru",
2130 ips_name, ha->host_num);
2131
2132 return;
2133 }
2134 pt = (ips_passthru_t *) ha->ioctl_data;
2135
2136 /* Copy data back to the user */
2137 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB) /* Copy DCDB Back to Caller's Area */
2138 memcpy(&pt->CoppCP.dcdb, &scb->dcdb, sizeof (IPS_DCDB_TABLE));
2139
2140 pt->BasicStatus = scb->basic_status;
2141 pt->ExtendedStatus = scb->extended_status;
2142 pt->AdapterType = ha->ad_type;
2143
2144 if (ha->device_id == IPS_DEVICEID_COPPERHEAD &&
2145 (scb->cmd.flashfw.op_code == IPS_CMD_DOWNLOAD ||
2146 scb->cmd.flashfw.op_code == IPS_CMD_RW_BIOSFW))
2147 ips_free_flash_copperhead(ha);
2148
2149 ips_scmd_buf_write(scb->scsi_cmd, ha->ioctl_data, ha->ioctl_datasize);
2150 }
2151
2152 /****************************************************************************/
2153 /* */
2154 /* Routine Name: ips_host_info */
2155 /* */
2156 /* Routine Description: */
2157 /* */
2158 /* The passthru interface for the driver */
2159 /* */
2160 /****************************************************************************/
2161 static int
2162 ips_host_info(ips_ha_t * ha, char *ptr, off_t offset, int len)
2163 {
2164 IPS_INFOSTR info;
2165
2166 METHOD_TRACE("ips_host_info", 1);
2167
2168 info.buffer = ptr;
2169 info.length = len;
2170 info.offset = offset;
2171 info.pos = 0;
2172 info.localpos = 0;
2173
2174 copy_info(&info, "\nIBM ServeRAID General Information:\n\n");
2175
2176 if ((le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) &&
2177 (le16_to_cpu(ha->nvram->adapter_type) != 0))
2178 copy_info(&info, "\tController Type : %s\n",
2179 ips_adapter_name[ha->ad_type - 1]);
2180 else
2181 copy_info(&info,
2182 "\tController Type : Unknown\n");
2183
2184 if (ha->io_addr)
2185 copy_info(&info,
2186 "\tIO region : 0x%lx (%d bytes)\n",
2187 ha->io_addr, ha->io_len);
2188
2189 if (ha->mem_addr) {
2190 copy_info(&info,
2191 "\tMemory region : 0x%lx (%d bytes)\n",
2192 ha->mem_addr, ha->mem_len);
2193 copy_info(&info,
2194 "\tShared memory address : 0x%lx\n",
2195 ha->mem_ptr);
2196 }
2197
2198 copy_info(&info, "\tIRQ number : %d\n", ha->irq);
2199
2200 /* For the Next 3 lines Check for Binary 0 at the end and don't include it if it's there. */
2201 /* That keeps everything happy for "text" operations on the proc file. */
2202
2203 if (le32_to_cpu(ha->nvram->signature) == IPS_NVRAM_P5_SIG) {
2204 if (ha->nvram->bios_low[3] == 0) {
2205 copy_info(&info,
2206 "\tBIOS Version : %c%c%c%c%c%c%c\n",
2207 ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2208 ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2209 ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2210 ha->nvram->bios_low[2]);
2211
2212 } else {
2213 copy_info(&info,
2214 "\tBIOS Version : %c%c%c%c%c%c%c%c\n",
2215 ha->nvram->bios_high[0], ha->nvram->bios_high[1],
2216 ha->nvram->bios_high[2], ha->nvram->bios_high[3],
2217 ha->nvram->bios_low[0], ha->nvram->bios_low[1],
2218 ha->nvram->bios_low[2], ha->nvram->bios_low[3]);
2219 }
2220
2221 }
2222
2223 if (ha->enq->CodeBlkVersion[7] == 0) {
2224 copy_info(&info,
2225 "\tFirmware Version : %c%c%c%c%c%c%c\n",
2226 ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2227 ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2228 ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2229 ha->enq->CodeBlkVersion[6]);
2230 } else {
2231 copy_info(&info,
2232 "\tFirmware Version : %c%c%c%c%c%c%c%c\n",
2233 ha->enq->CodeBlkVersion[0], ha->enq->CodeBlkVersion[1],
2234 ha->enq->CodeBlkVersion[2], ha->enq->CodeBlkVersion[3],
2235 ha->enq->CodeBlkVersion[4], ha->enq->CodeBlkVersion[5],
2236 ha->enq->CodeBlkVersion[6], ha->enq->CodeBlkVersion[7]);
2237 }
2238
2239 if (ha->enq->BootBlkVersion[7] == 0) {
2240 copy_info(&info,
2241 "\tBoot Block Version : %c%c%c%c%c%c%c\n",
2242 ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2243 ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2244 ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2245 ha->enq->BootBlkVersion[6]);
2246 } else {
2247 copy_info(&info,
2248 "\tBoot Block Version : %c%c%c%c%c%c%c%c\n",
2249 ha->enq->BootBlkVersion[0], ha->enq->BootBlkVersion[1],
2250 ha->enq->BootBlkVersion[2], ha->enq->BootBlkVersion[3],
2251 ha->enq->BootBlkVersion[4], ha->enq->BootBlkVersion[5],
2252 ha->enq->BootBlkVersion[6], ha->enq->BootBlkVersion[7]);
2253 }
2254
2255 copy_info(&info, "\tDriver Version : %s%s\n",
2256 IPS_VERSION_HIGH, IPS_VERSION_LOW);
2257
2258 copy_info(&info, "\tDriver Build : %d\n",
2259 IPS_BUILD_IDENT);
2260
2261 copy_info(&info, "\tMax Physical Devices : %d\n",
2262 ha->enq->ucMaxPhysicalDevices);
2263 copy_info(&info, "\tMax Active Commands : %d\n",
2264 ha->max_cmds);
2265 copy_info(&info, "\tCurrent Queued Commands : %d\n",
2266 ha->scb_waitlist.count);
2267 copy_info(&info, "\tCurrent Active Commands : %d\n",
2268 ha->scb_activelist.count - ha->num_ioctl);
2269 copy_info(&info, "\tCurrent Queued PT Commands : %d\n",
2270 ha->copp_waitlist.count);
2271 copy_info(&info, "\tCurrent Active PT Commands : %d\n",
2272 ha->num_ioctl);
2273
2274 copy_info(&info, "\n");
2275
2276 return (info.localpos);
2277 }
2278
2279 /****************************************************************************/
2280 /* */
2281 /* Routine Name: copy_mem_info */
2282 /* */
2283 /* Routine Description: */
2284 /* */
2285 /* Copy data into an IPS_INFOSTR structure */
2286 /* */
2287 /****************************************************************************/
2288 static void
2289 copy_mem_info(IPS_INFOSTR * info, char *data, int len)
2290 {
2291 METHOD_TRACE("copy_mem_info", 1);
2292
2293 if (info->pos + len < info->offset) {
2294 info->pos += len;
2295 return;
2296 }
2297
2298 if (info->pos < info->offset) {
2299 data += (info->offset - info->pos);
2300 len -= (info->offset - info->pos);
2301 info->pos += (info->offset - info->pos);
2302 }
2303
2304 if (info->localpos + len > info->length)
2305 len = info->length - info->localpos;
2306
2307 if (len > 0) {
2308 memcpy(info->buffer + info->localpos, data, len);
2309 info->pos += len;
2310 info->localpos += len;
2311 }
2312 }
2313
2314 /****************************************************************************/
2315 /* */
2316 /* Routine Name: copy_info */
2317 /* */
2318 /* Routine Description: */
2319 /* */
2320 /* printf style wrapper for an info structure */
2321 /* */
2322 /****************************************************************************/
2323 static int
2324 copy_info(IPS_INFOSTR * info, char *fmt, ...)
2325 {
2326 va_list args;
2327 char buf[128];
2328 int len;
2329
2330 METHOD_TRACE("copy_info", 1);
2331
2332 va_start(args, fmt);
2333 len = vsprintf(buf, fmt, args);
2334 va_end(args);
2335
2336 copy_mem_info(info, buf, len);
2337
2338 return (len);
2339 }
2340
2341 /****************************************************************************/
2342 /* */
2343 /* Routine Name: ips_identify_controller */
2344 /* */
2345 /* Routine Description: */
2346 /* */
2347 /* Identify this controller */
2348 /* */
2349 /****************************************************************************/
2350 static void
2351 ips_identify_controller(ips_ha_t * ha)
2352 {
2353 METHOD_TRACE("ips_identify_controller", 1);
2354
2355 switch (ha->device_id) {
2356 case IPS_DEVICEID_COPPERHEAD:
2357 if (ha->revision_id <= IPS_REVID_SERVERAID) {
2358 ha->ad_type = IPS_ADTYPE_SERVERAID;
2359 } else if (ha->revision_id == IPS_REVID_SERVERAID2) {
2360 ha->ad_type = IPS_ADTYPE_SERVERAID2;
2361 } else if (ha->revision_id == IPS_REVID_NAVAJO) {
2362 ha->ad_type = IPS_ADTYPE_NAVAJO;
2363 } else if ((ha->revision_id == IPS_REVID_SERVERAID2)
2364 && (ha->slot_num == 0)) {
2365 ha->ad_type = IPS_ADTYPE_KIOWA;
2366 } else if ((ha->revision_id >= IPS_REVID_CLARINETP1) &&
2367 (ha->revision_id <= IPS_REVID_CLARINETP3)) {
2368 if (ha->enq->ucMaxPhysicalDevices == 15)
2369 ha->ad_type = IPS_ADTYPE_SERVERAID3L;
2370 else
2371 ha->ad_type = IPS_ADTYPE_SERVERAID3;
2372 } else if ((ha->revision_id >= IPS_REVID_TROMBONE32) &&
2373 (ha->revision_id <= IPS_REVID_TROMBONE64)) {
2374 ha->ad_type = IPS_ADTYPE_SERVERAID4H;
2375 }
2376 break;
2377
2378 case IPS_DEVICEID_MORPHEUS:
2379 switch (ha->subdevice_id) {
2380 case IPS_SUBDEVICEID_4L:
2381 ha->ad_type = IPS_ADTYPE_SERVERAID4L;
2382 break;
2383
2384 case IPS_SUBDEVICEID_4M:
2385 ha->ad_type = IPS_ADTYPE_SERVERAID4M;
2386 break;
2387
2388 case IPS_SUBDEVICEID_4MX:
2389 ha->ad_type = IPS_ADTYPE_SERVERAID4MX;
2390 break;
2391
2392 case IPS_SUBDEVICEID_4LX:
2393 ha->ad_type = IPS_ADTYPE_SERVERAID4LX;
2394 break;
2395
2396 case IPS_SUBDEVICEID_5I2:
2397 ha->ad_type = IPS_ADTYPE_SERVERAID5I2;
2398 break;
2399
2400 case IPS_SUBDEVICEID_5I1:
2401 ha->ad_type = IPS_ADTYPE_SERVERAID5I1;
2402 break;
2403 }
2404
2405 break;
2406
2407 case IPS_DEVICEID_MARCO:
2408 switch (ha->subdevice_id) {
2409 case IPS_SUBDEVICEID_6M:
2410 ha->ad_type = IPS_ADTYPE_SERVERAID6M;
2411 break;
2412 case IPS_SUBDEVICEID_6I:
2413 ha->ad_type = IPS_ADTYPE_SERVERAID6I;
2414 break;
2415 case IPS_SUBDEVICEID_7k:
2416 ha->ad_type = IPS_ADTYPE_SERVERAID7k;
2417 break;
2418 case IPS_SUBDEVICEID_7M:
2419 ha->ad_type = IPS_ADTYPE_SERVERAID7M;
2420 break;
2421 }
2422 break;
2423 }
2424 }
2425
2426 /****************************************************************************/
2427 /* */
2428 /* Routine Name: ips_get_bios_version */
2429 /* */
2430 /* Routine Description: */
2431 /* */
2432 /* Get the BIOS revision number */
2433 /* */
2434 /****************************************************************************/
2435 static void
2436 ips_get_bios_version(ips_ha_t * ha, int intr)
2437 {
2438 ips_scb_t *scb;
2439 int ret;
2440 uint8_t major;
2441 uint8_t minor;
2442 uint8_t subminor;
2443 uint8_t *buffer;
2444 char hexDigits[] =
2445 { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C',
2446 'D', 'E', 'F' };
2447
2448 METHOD_TRACE("ips_get_bios_version", 1);
2449
2450 major = 0;
2451 minor = 0;
2452
2453 strncpy(ha->bios_version, " ?", 8);
2454
2455 if (ha->device_id == IPS_DEVICEID_COPPERHEAD) {
2456 if (IPS_USE_MEMIO(ha)) {
2457 /* Memory Mapped I/O */
2458
2459 /* test 1st byte */
2460 writel(0, ha->mem_ptr + IPS_REG_FLAP);
2461 if (ha->revision_id == IPS_REVID_TROMBONE64)
2462 udelay(25); /* 25 us */
2463
2464 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
2465 return;
2466
2467 writel(1, ha->mem_ptr + IPS_REG_FLAP);
2468 if (ha->revision_id == IPS_REVID_TROMBONE64)
2469 udelay(25); /* 25 us */
2470
2471 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
2472 return;
2473
2474 /* Get Major version */
2475 writel(0x1FF, ha->mem_ptr + IPS_REG_FLAP);
2476 if (ha->revision_id == IPS_REVID_TROMBONE64)
2477 udelay(25); /* 25 us */
2478
2479 major = readb(ha->mem_ptr + IPS_REG_FLDP);
2480
2481 /* Get Minor version */
2482 writel(0x1FE, ha->mem_ptr + IPS_REG_FLAP);
2483 if (ha->revision_id == IPS_REVID_TROMBONE64)
2484 udelay(25); /* 25 us */
2485 minor = readb(ha->mem_ptr + IPS_REG_FLDP);
2486
2487 /* Get SubMinor version */
2488 writel(0x1FD, ha->mem_ptr + IPS_REG_FLAP);
2489 if (ha->revision_id == IPS_REVID_TROMBONE64)
2490 udelay(25); /* 25 us */
2491 subminor = readb(ha->mem_ptr + IPS_REG_FLDP);
2492
2493 } else {
2494 /* Programmed I/O */
2495
2496 /* test 1st byte */
2497 outl(0, ha->io_addr + IPS_REG_FLAP);
2498 if (ha->revision_id == IPS_REVID_TROMBONE64)
2499 udelay(25); /* 25 us */
2500
2501 if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
2502 return;
2503
2504 outl(cpu_to_le32(1), ha->io_addr + IPS_REG_FLAP);
2505 if (ha->revision_id == IPS_REVID_TROMBONE64)
2506 udelay(25); /* 25 us */
2507
2508 if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
2509 return;
2510
2511 /* Get Major version */
2512 outl(cpu_to_le32(0x1FF), ha->io_addr + IPS_REG_FLAP);
2513 if (ha->revision_id == IPS_REVID_TROMBONE64)
2514 udelay(25); /* 25 us */
2515
2516 major = inb(ha->io_addr + IPS_REG_FLDP);
2517
2518 /* Get Minor version */
2519 outl(cpu_to_le32(0x1FE), ha->io_addr + IPS_REG_FLAP);
2520 if (ha->revision_id == IPS_REVID_TROMBONE64)
2521 udelay(25); /* 25 us */
2522
2523 minor = inb(ha->io_addr + IPS_REG_FLDP);
2524
2525 /* Get SubMinor version */
2526 outl(cpu_to_le32(0x1FD), ha->io_addr + IPS_REG_FLAP);
2527 if (ha->revision_id == IPS_REVID_TROMBONE64)
2528 udelay(25); /* 25 us */
2529
2530 subminor = inb(ha->io_addr + IPS_REG_FLDP);
2531
2532 }
2533 } else {
2534 /* Morpheus Family - Send Command to the card */
2535
2536 buffer = ha->ioctl_data;
2537
2538 memset(buffer, 0, 0x1000);
2539
2540 scb = &ha->scbs[ha->max_cmds - 1];
2541
2542 ips_init_scb(ha, scb);
2543
2544 scb->timeout = ips_cmd_timeout;
2545 scb->cdb[0] = IPS_CMD_RW_BIOSFW;
2546
2547 scb->cmd.flashfw.op_code = IPS_CMD_RW_BIOSFW;
2548 scb->cmd.flashfw.command_id = IPS_COMMAND_ID(ha, scb);
2549 scb->cmd.flashfw.type = 1;
2550 scb->cmd.flashfw.direction = 0;
2551 scb->cmd.flashfw.count = cpu_to_le32(0x800);
2552 scb->cmd.flashfw.total_packets = 1;
2553 scb->cmd.flashfw.packet_num = 0;
2554 scb->data_len = 0x1000;
2555 scb->cmd.flashfw.buffer_addr = ha->ioctl_busaddr;
2556
2557 /* issue the command */
2558 if (((ret =
2559 ips_send_wait(ha, scb, ips_cmd_timeout,
2560 intr)) == IPS_FAILURE)
2561 || (ret == IPS_SUCCESS_IMM)
2562 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
2563 /* Error occurred */
2564
2565 return;
2566 }
2567
2568 if ((buffer[0xC0] == 0x55) && (buffer[0xC1] == 0xAA)) {
2569 major = buffer[0x1ff + 0xC0]; /* Offset 0x1ff after the header (0xc0) */
2570 minor = buffer[0x1fe + 0xC0]; /* Offset 0x1fe after the header (0xc0) */
2571 subminor = buffer[0x1fd + 0xC0]; /* Offset 0x1fd after the header (0xc0) */
2572 } else {
2573 return;
2574 }
2575 }
2576
2577 ha->bios_version[0] = hexDigits[(major & 0xF0) >> 4];
2578 ha->bios_version[1] = '.';
2579 ha->bios_version[2] = hexDigits[major & 0x0F];
2580 ha->bios_version[3] = hexDigits[subminor];
2581 ha->bios_version[4] = '.';
2582 ha->bios_version[5] = hexDigits[(minor & 0xF0) >> 4];
2583 ha->bios_version[6] = hexDigits[minor & 0x0F];
2584 ha->bios_version[7] = 0;
2585 }
2586
2587 /****************************************************************************/
2588 /* */
2589 /* Routine Name: ips_hainit */
2590 /* */
2591 /* Routine Description: */
2592 /* */
2593 /* Initialize the controller */
2594 /* */
2595 /* NOTE: Assumes to be called from with a lock */
2596 /* */
2597 /****************************************************************************/
2598 static int
2599 ips_hainit(ips_ha_t * ha)
2600 {
2601 int i;
2602 struct timeval tv;
2603
2604 METHOD_TRACE("ips_hainit", 1);
2605
2606 if (!ha)
2607 return (0);
2608
2609 if (ha->func.statinit)
2610 (*ha->func.statinit) (ha);
2611
2612 if (ha->func.enableint)
2613 (*ha->func.enableint) (ha);
2614
2615 /* Send FFDC */
2616 ha->reset_count = 1;
2617 do_gettimeofday(&tv);
2618 ha->last_ffdc = tv.tv_sec;
2619 ips_ffdc_reset(ha, IPS_INTR_IORL);
2620
2621 if (!ips_read_config(ha, IPS_INTR_IORL)) {
2622 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2623 "unable to read config from controller.\n");
2624
2625 return (0);
2626 }
2627 /* end if */
2628 if (!ips_read_adapter_status(ha, IPS_INTR_IORL)) {
2629 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2630 "unable to read controller status.\n");
2631
2632 return (0);
2633 }
2634
2635 /* Identify this controller */
2636 ips_identify_controller(ha);
2637
2638 if (!ips_read_subsystem_parameters(ha, IPS_INTR_IORL)) {
2639 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2640 "unable to read subsystem parameters.\n");
2641
2642 return (0);
2643 }
2644
2645 /* write nvram user page 5 */
2646 if (!ips_write_driver_status(ha, IPS_INTR_IORL)) {
2647 IPS_PRINTK(KERN_WARNING, ha->pcidev,
2648 "unable to write driver info to controller.\n");
2649
2650 return (0);
2651 }
2652
2653 /* If there are Logical Drives and a Reset Occurred, then an EraseStripeLock is Needed */
2654 if ((ha->conf->ucLogDriveCount > 0) && (ha->requires_esl == 1))
2655 ips_clear_adapter(ha, IPS_INTR_IORL);
2656
2657 /* set limits on SID, LUN, BUS */
2658 ha->ntargets = IPS_MAX_TARGETS + 1;
2659 ha->nlun = 1;
2660 ha->nbus = (ha->enq->ucMaxPhysicalDevices / IPS_MAX_TARGETS) + 1;
2661
2662 switch (ha->conf->logical_drive[0].ucStripeSize) {
2663 case 4:
2664 ha->max_xfer = 0x10000;
2665 break;
2666
2667 case 5:
2668 ha->max_xfer = 0x20000;
2669 break;
2670
2671 case 6:
2672 ha->max_xfer = 0x40000;
2673 break;
2674
2675 case 7:
2676 default:
2677 ha->max_xfer = 0x80000;
2678 break;
2679 }
2680
2681 /* setup max concurrent commands */
2682 if (le32_to_cpu(ha->subsys->param[4]) & 0x1) {
2683 /* Use the new method */
2684 ha->max_cmds = ha->enq->ucConcurrentCmdCount;
2685 } else {
2686 /* use the old method */
2687 switch (ha->conf->logical_drive[0].ucStripeSize) {
2688 case 4:
2689 ha->max_cmds = 32;
2690 break;
2691
2692 case 5:
2693 ha->max_cmds = 16;
2694 break;
2695
2696 case 6:
2697 ha->max_cmds = 8;
2698 break;
2699
2700 case 7:
2701 default:
2702 ha->max_cmds = 4;
2703 break;
2704 }
2705 }
2706
2707 /* Limit the Active Commands on a Lite Adapter */
2708 if ((ha->ad_type == IPS_ADTYPE_SERVERAID3L) ||
2709 (ha->ad_type == IPS_ADTYPE_SERVERAID4L) ||
2710 (ha->ad_type == IPS_ADTYPE_SERVERAID4LX)) {
2711 if ((ha->max_cmds > MaxLiteCmds) && (MaxLiteCmds))
2712 ha->max_cmds = MaxLiteCmds;
2713 }
2714
2715 /* set controller IDs */
2716 ha->ha_id[0] = IPS_ADAPTER_ID;
2717 for (i = 1; i < ha->nbus; i++) {
2718 ha->ha_id[i] = ha->conf->init_id[i - 1] & 0x1f;
2719 ha->dcdb_active[i - 1] = 0;
2720 }
2721
2722 return (1);
2723 }
2724
2725 /****************************************************************************/
2726 /* */
2727 /* Routine Name: ips_next */
2728 /* */
2729 /* Routine Description: */
2730 /* */
2731 /* Take the next command off the queue and send it to the controller */
2732 /* */
2733 /****************************************************************************/
2734 static void
2735 ips_next(ips_ha_t * ha, int intr)
2736 {
2737 ips_scb_t *scb;
2738 Scsi_Cmnd *SC;
2739 Scsi_Cmnd *p;
2740 Scsi_Cmnd *q;
2741 ips_copp_wait_item_t *item;
2742 int ret;
2743 unsigned long cpu_flags = 0;
2744 struct Scsi_Host *host;
2745 METHOD_TRACE("ips_next", 1);
2746
2747 if (!ha)
2748 return;
2749 host = ips_sh[ha->host_num];
2750 /*
2751 * Block access to the queue function so
2752 * this command won't time out
2753 */
2754 if (intr == IPS_INTR_ON)
2755 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2756
2757 if ((ha->subsys->param[3] & 0x300000)
2758 && (ha->scb_activelist.count == 0)) {
2759 struct timeval tv;
2760
2761 do_gettimeofday(&tv);
2762
2763 if (tv.tv_sec - ha->last_ffdc > IPS_SECS_8HOURS) {
2764 ha->last_ffdc = tv.tv_sec;
2765 ips_ffdc_time(ha);
2766 }
2767 }
2768
2769 /*
2770 * Send passthru commands
2771 * These have priority over normal I/O
2772 * but shouldn't affect performance too much
2773 * since we limit the number that can be active
2774 * on the card at any one time
2775 */
2776 while ((ha->num_ioctl < IPS_MAX_IOCTL) &&
2777 (ha->copp_waitlist.head) && (scb = ips_getscb(ha))) {
2778
2779 item = ips_removeq_copp_head(&ha->copp_waitlist);
2780 ha->num_ioctl++;
2781 if (intr == IPS_INTR_ON)
2782 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2783 scb->scsi_cmd = item->scsi_cmd;
2784 kfree(item);
2785
2786 ret = ips_make_passthru(ha, scb->scsi_cmd, scb, intr);
2787
2788 if (intr == IPS_INTR_ON)
2789 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2790 switch (ret) {
2791 case IPS_FAILURE:
2792 if (scb->scsi_cmd) {
2793 scb->scsi_cmd->result = DID_ERROR << 16;
2794 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2795 }
2796
2797 ips_freescb(ha, scb);
2798 break;
2799 case IPS_SUCCESS_IMM:
2800 if (scb->scsi_cmd) {
2801 scb->scsi_cmd->result = DID_OK << 16;
2802 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2803 }
2804
2805 ips_freescb(ha, scb);
2806 break;
2807 default:
2808 break;
2809 } /* end case */
2810
2811 if (ret != IPS_SUCCESS) {
2812 ha->num_ioctl--;
2813 continue;
2814 }
2815
2816 ret = ips_send_cmd(ha, scb);
2817
2818 if (ret == IPS_SUCCESS)
2819 ips_putq_scb_head(&ha->scb_activelist, scb);
2820 else
2821 ha->num_ioctl--;
2822
2823 switch (ret) {
2824 case IPS_FAILURE:
2825 if (scb->scsi_cmd) {
2826 scb->scsi_cmd->result = DID_ERROR << 16;
2827 }
2828
2829 ips_freescb(ha, scb);
2830 break;
2831 case IPS_SUCCESS_IMM:
2832 ips_freescb(ha, scb);
2833 break;
2834 default:
2835 break;
2836 } /* end case */
2837
2838 }
2839
2840 /*
2841 * Send "Normal" I/O commands
2842 */
2843
2844 p = ha->scb_waitlist.head;
2845 while ((p) && (scb = ips_getscb(ha))) {
2846 if ((scmd_channel(p) > 0)
2847 && (ha->
2848 dcdb_active[scmd_channel(p) -
2849 1] & (1 << scmd_id(p)))) {
2850 ips_freescb(ha, scb);
2851 p = (Scsi_Cmnd *) p->host_scribble;
2852 continue;
2853 }
2854
2855 q = p;
2856 SC = ips_removeq_wait(&ha->scb_waitlist, q);
2857
2858 if (intr == IPS_INTR_ON)
2859 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags); /* Unlock HA after command is taken off queue */
2860
2861 SC->result = DID_OK;
2862 SC->host_scribble = NULL;
2863
2864 memset(SC->sense_buffer, 0, sizeof (SC->sense_buffer));
2865
2866 scb->target_id = SC->device->id;
2867 scb->lun = SC->device->lun;
2868 scb->bus = SC->device->channel;
2869 scb->scsi_cmd = SC;
2870 scb->breakup = 0;
2871 scb->data_len = 0;
2872 scb->callback = ipsintr_done;
2873 scb->timeout = ips_cmd_timeout;
2874 memset(&scb->cmd, 0, 16);
2875
2876 /* copy in the CDB */
2877 memcpy(scb->cdb, SC->cmnd, SC->cmd_len);
2878
2879 /* Now handle the data buffer */
2880 if (SC->use_sg) {
2881 struct scatterlist *sg;
2882 int i;
2883
2884 sg = SC->request_buffer;
2885 scb->sg_count = pci_map_sg(ha->pcidev, sg, SC->use_sg,
2886 SC->sc_data_direction);
2887 scb->flags |= IPS_SCB_MAP_SG;
2888 for (i = 0; i < scb->sg_count; i++) {
2889 if (ips_fill_scb_sg_single
2890 (ha, sg_dma_address(&sg[i]), scb, i,
2891 sg_dma_len(&sg[i])) < 0)
2892 break;
2893 }
2894 scb->dcdb.transfer_length = scb->data_len;
2895 } else {
2896 if (SC->request_bufflen) {
2897 scb->data_busaddr =
2898 pci_map_single(ha->pcidev,
2899 SC->request_buffer,
2900 SC->request_bufflen,
2901 SC->sc_data_direction);
2902 scb->flags |= IPS_SCB_MAP_SINGLE;
2903 ips_fill_scb_sg_single(ha, scb->data_busaddr,
2904 scb, 0,
2905 SC->request_bufflen);
2906 scb->dcdb.transfer_length = scb->data_len;
2907 } else {
2908 scb->data_busaddr = 0L;
2909 scb->sg_len = 0;
2910 scb->data_len = 0;
2911 scb->dcdb.transfer_length = 0;
2912 }
2913
2914 }
2915
2916 scb->dcdb.cmd_attribute =
2917 ips_command_direction[scb->scsi_cmd->cmnd[0]];
2918
2919 /* Allow a WRITE BUFFER Command to Have no Data */
2920 /* This is Used by Tape Flash Utilites */
2921 if ((scb->scsi_cmd->cmnd[0] == WRITE_BUFFER) && (scb->data_len == 0))
2922 scb->dcdb.cmd_attribute = 0;
2923
2924 if (!(scb->dcdb.cmd_attribute & 0x3))
2925 scb->dcdb.transfer_length = 0;
2926
2927 if (scb->data_len >= IPS_MAX_XFER) {
2928 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
2929 scb->dcdb.transfer_length = 0;
2930 }
2931 if (intr == IPS_INTR_ON)
2932 IPS_LOCK_SAVE(host->host_lock, cpu_flags);
2933
2934 ret = ips_send_cmd(ha, scb);
2935
2936 switch (ret) {
2937 case IPS_SUCCESS:
2938 ips_putq_scb_head(&ha->scb_activelist, scb);
2939 break;
2940 case IPS_FAILURE:
2941 if (scb->scsi_cmd) {
2942 scb->scsi_cmd->result = DID_ERROR << 16;
2943 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2944 }
2945
2946 if (scb->bus)
2947 ha->dcdb_active[scb->bus - 1] &=
2948 ~(1 << scb->target_id);
2949
2950 ips_freescb(ha, scb);
2951 break;
2952 case IPS_SUCCESS_IMM:
2953 if (scb->scsi_cmd)
2954 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
2955
2956 if (scb->bus)
2957 ha->dcdb_active[scb->bus - 1] &=
2958 ~(1 << scb->target_id);
2959
2960 ips_freescb(ha, scb);
2961 break;
2962 default:
2963 break;
2964 } /* end case */
2965
2966 p = (Scsi_Cmnd *) p->host_scribble;
2967
2968 } /* end while */
2969
2970 if (intr == IPS_INTR_ON)
2971 IPS_UNLOCK_RESTORE(host->host_lock, cpu_flags);
2972 }
2973
2974 /****************************************************************************/
2975 /* */
2976 /* Routine Name: ips_putq_scb_head */
2977 /* */
2978 /* Routine Description: */
2979 /* */
2980 /* Add an item to the head of the queue */
2981 /* */
2982 /* ASSUMED to be called from within the HA lock */
2983 /* */
2984 /****************************************************************************/
2985 static void
2986 ips_putq_scb_head(ips_scb_queue_t * queue, ips_scb_t * item)
2987 {
2988 METHOD_TRACE("ips_putq_scb_head", 1);
2989
2990 if (!item)
2991 return;
2992
2993 item->q_next = queue->head;
2994 queue->head = item;
2995
2996 if (!queue->tail)
2997 queue->tail = item;
2998
2999 queue->count++;
3000 }
3001
3002 /****************************************************************************/
3003 /* */
3004 /* Routine Name: ips_removeq_scb_head */
3005 /* */
3006 /* Routine Description: */
3007 /* */
3008 /* Remove the head of the queue */
3009 /* */
3010 /* ASSUMED to be called from within the HA lock */
3011 /* */
3012 /****************************************************************************/
3013 static ips_scb_t *
3014 ips_removeq_scb_head(ips_scb_queue_t * queue)
3015 {
3016 ips_scb_t *item;
3017
3018 METHOD_TRACE("ips_removeq_scb_head", 1);
3019
3020 item = queue->head;
3021
3022 if (!item) {
3023 return (NULL);
3024 }
3025
3026 queue->head = item->q_next;
3027 item->q_next = NULL;
3028
3029 if (queue->tail == item)
3030 queue->tail = NULL;
3031
3032 queue->count--;
3033
3034 return (item);
3035 }
3036
3037 /****************************************************************************/
3038 /* */
3039 /* Routine Name: ips_removeq_scb */
3040 /* */
3041 /* Routine Description: */
3042 /* */
3043 /* Remove an item from a queue */
3044 /* */
3045 /* ASSUMED to be called from within the HA lock */
3046 /* */
3047 /****************************************************************************/
3048 static ips_scb_t *
3049 ips_removeq_scb(ips_scb_queue_t * queue, ips_scb_t * item)
3050 {
3051 ips_scb_t *p;
3052
3053 METHOD_TRACE("ips_removeq_scb", 1);
3054
3055 if (!item)
3056 return (NULL);
3057
3058 if (item == queue->head) {
3059 return (ips_removeq_scb_head(queue));
3060 }
3061
3062 p = queue->head;
3063
3064 while ((p) && (item != p->q_next))
3065 p = p->q_next;
3066
3067 if (p) {
3068 /* found a match */
3069 p->q_next = item->q_next;
3070
3071 if (!item->q_next)
3072 queue->tail = p;
3073
3074 item->q_next = NULL;
3075 queue->count--;
3076
3077 return (item);
3078 }
3079
3080 return (NULL);
3081 }
3082
3083 /****************************************************************************/
3084 /* */
3085 /* Routine Name: ips_putq_wait_tail */
3086 /* */
3087 /* Routine Description: */
3088 /* */
3089 /* Add an item to the tail of the queue */
3090 /* */
3091 /* ASSUMED to be called from within the HA lock */
3092 /* */
3093 /****************************************************************************/
3094 static void
3095 ips_putq_wait_tail(ips_wait_queue_t * queue, Scsi_Cmnd * item)
3096 {
3097 METHOD_TRACE("ips_putq_wait_tail", 1);
3098
3099 if (!item)
3100 return;
3101
3102 item->host_scribble = NULL;
3103
3104 if (queue->tail)
3105 queue->tail->host_scribble = (char *) item;
3106
3107 queue->tail = item;
3108
3109 if (!queue->head)
3110 queue->head = item;
3111
3112 queue->count++;
3113 }
3114
3115 /****************************************************************************/
3116 /* */
3117 /* Routine Name: ips_removeq_wait_head */
3118 /* */
3119 /* Routine Description: */
3120 /* */
3121 /* Remove the head of the queue */
3122 /* */
3123 /* ASSUMED to be called from within the HA lock */
3124 /* */
3125 /****************************************************************************/
3126 static Scsi_Cmnd *
3127 ips_removeq_wait_head(ips_wait_queue_t * queue)
3128 {
3129 Scsi_Cmnd *item;
3130
3131 METHOD_TRACE("ips_removeq_wait_head", 1);
3132
3133 item = queue->head;
3134
3135 if (!item) {
3136 return (NULL);
3137 }
3138
3139 queue->head = (Scsi_Cmnd *) item->host_scribble;
3140 item->host_scribble = NULL;
3141
3142 if (queue->tail == item)
3143 queue->tail = NULL;
3144
3145 queue->count--;
3146
3147 return (item);
3148 }
3149
3150 /****************************************************************************/
3151 /* */
3152 /* Routine Name: ips_removeq_wait */
3153 /* */
3154 /* Routine Description: */
3155 /* */
3156 /* Remove an item from a queue */
3157 /* */
3158 /* ASSUMED to be called from within the HA lock */
3159 /* */
3160 /****************************************************************************/
3161 static Scsi_Cmnd *
3162 ips_removeq_wait(ips_wait_queue_t * queue, Scsi_Cmnd * item)
3163 {
3164 Scsi_Cmnd *p;
3165
3166 METHOD_TRACE("ips_removeq_wait", 1);
3167
3168 if (!item)
3169 return (NULL);
3170
3171 if (item == queue->head) {
3172 return (ips_removeq_wait_head(queue));
3173 }
3174
3175 p = queue->head;
3176
3177 while ((p) && (item != (Scsi_Cmnd *) p->host_scribble))
3178 p = (Scsi_Cmnd *) p->host_scribble;
3179
3180 if (p) {
3181 /* found a match */
3182 p->host_scribble = item->host_scribble;
3183
3184 if (!item->host_scribble)
3185 queue->tail = p;
3186
3187 item->host_scribble = NULL;
3188 queue->count--;
3189
3190 return (item);
3191 }
3192
3193 return (NULL);
3194 }
3195
3196 /****************************************************************************/
3197 /* */
3198 /* Routine Name: ips_putq_copp_tail */
3199 /* */
3200 /* Routine Description: */
3201 /* */
3202 /* Add an item to the tail of the queue */
3203 /* */
3204 /* ASSUMED to be called from within the HA lock */
3205 /* */
3206 /****************************************************************************/
3207 static void
3208 ips_putq_copp_tail(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3209 {
3210 METHOD_TRACE("ips_putq_copp_tail", 1);
3211
3212 if (!item)
3213 return;
3214
3215 item->next = NULL;
3216
3217 if (queue->tail)
3218 queue->tail->next = item;
3219
3220 queue->tail = item;
3221
3222 if (!queue->head)
3223 queue->head = item;
3224
3225 queue->count++;
3226 }
3227
3228 /****************************************************************************/
3229 /* */
3230 /* Routine Name: ips_removeq_copp_head */
3231 /* */
3232 /* Routine Description: */
3233 /* */
3234 /* Remove the head of the queue */
3235 /* */
3236 /* ASSUMED to be called from within the HA lock */
3237 /* */
3238 /****************************************************************************/
3239 static ips_copp_wait_item_t *
3240 ips_removeq_copp_head(ips_copp_queue_t * queue)
3241 {
3242 ips_copp_wait_item_t *item;
3243
3244 METHOD_TRACE("ips_removeq_copp_head", 1);
3245
3246 item = queue->head;
3247
3248 if (!item) {
3249 return (NULL);
3250 }
3251
3252 queue->head = item->next;
3253 item->next = NULL;
3254
3255 if (queue->tail == item)
3256 queue->tail = NULL;
3257
3258 queue->count--;
3259
3260 return (item);
3261 }
3262
3263 /****************************************************************************/
3264 /* */
3265 /* Routine Name: ips_removeq_copp */
3266 /* */
3267 /* Routine Description: */
3268 /* */
3269 /* Remove an item from a queue */
3270 /* */
3271 /* ASSUMED to be called from within the HA lock */
3272 /* */
3273 /****************************************************************************/
3274 static ips_copp_wait_item_t *
3275 ips_removeq_copp(ips_copp_queue_t * queue, ips_copp_wait_item_t * item)
3276 {
3277 ips_copp_wait_item_t *p;
3278
3279 METHOD_TRACE("ips_removeq_copp", 1);
3280
3281 if (!item)
3282 return (NULL);
3283
3284 if (item == queue->head) {
3285 return (ips_removeq_copp_head(queue));
3286 }
3287
3288 p = queue->head;
3289
3290 while ((p) && (item != p->next))
3291 p = p->next;
3292
3293 if (p) {
3294 /* found a match */
3295 p->next = item->next;
3296
3297 if (!item->next)
3298 queue->tail = p;
3299
3300 item->next = NULL;
3301 queue->count--;
3302
3303 return (item);
3304 }
3305
3306 return (NULL);
3307 }
3308
3309 /****************************************************************************/
3310 /* */
3311 /* Routine Name: ipsintr_blocking */
3312 /* */
3313 /* Routine Description: */
3314 /* */
3315 /* Finalize an interrupt for internal commands */
3316 /* */
3317 /****************************************************************************/
3318 static void
3319 ipsintr_blocking(ips_ha_t * ha, ips_scb_t * scb)
3320 {
3321 METHOD_TRACE("ipsintr_blocking", 2);
3322
3323 ips_freescb(ha, scb);
3324 if ((ha->waitflag == TRUE) && (ha->cmd_in_progress == scb->cdb[0])) {
3325 ha->waitflag = FALSE;
3326
3327 return;
3328 }
3329 }
3330
3331 /****************************************************************************/
3332 /* */
3333 /* Routine Name: ipsintr_done */
3334 /* */
3335 /* Routine Description: */
3336 /* */
3337 /* Finalize an interrupt for non-internal commands */
3338 /* */
3339 /****************************************************************************/
3340 static void
3341 ipsintr_done(ips_ha_t * ha, ips_scb_t * scb)
3342 {
3343 METHOD_TRACE("ipsintr_done", 2);
3344
3345 if (!scb) {
3346 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3347 "Spurious interrupt; scb NULL.\n");
3348
3349 return;
3350 }
3351
3352 if (scb->scsi_cmd == NULL) {
3353 /* unexpected interrupt */
3354 IPS_PRINTK(KERN_WARNING, ha->pcidev,
3355 "Spurious interrupt; scsi_cmd not set.\n");
3356
3357 return;
3358 }
3359
3360 ips_done(ha, scb);
3361 }
3362
3363 /****************************************************************************/
3364 /* */
3365 /* Routine Name: ips_done */
3366 /* */
3367 /* Routine Description: */
3368 /* */
3369 /* Do housekeeping on completed commands */
3370 /* ASSUMED to be called form within the request lock */
3371 /****************************************************************************/
3372 static void
3373 ips_done(ips_ha_t * ha, ips_scb_t * scb)
3374 {
3375 int ret;
3376
3377 METHOD_TRACE("ips_done", 1);
3378
3379 if (!scb)
3380 return;
3381
3382 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd))) {
3383 ips_cleanup_passthru(ha, scb);
3384 ha->num_ioctl--;
3385 } else {
3386 /*
3387 * Check to see if this command had too much
3388 * data and had to be broke up. If so, queue
3389 * the rest of the data and continue.
3390 */
3391 if ((scb->breakup) || (scb->sg_break)) {
3392 /* we had a data breakup */
3393 scb->data_len = 0;
3394
3395 if (scb->sg_count) {
3396 /* S/G request */
3397 struct scatterlist *sg;
3398 int ips_sg_index = 0;
3399 int sg_dma_index;
3400
3401 sg = scb->scsi_cmd->request_buffer;
3402
3403 /* Spin forward to last dma chunk */
3404 sg_dma_index = scb->breakup;
3405
3406 /* Take care of possible partial on last chunk */
3407 ips_fill_scb_sg_single(ha,
3408 sg_dma_address(&sg
3409 [sg_dma_index]),
3410 scb, ips_sg_index++,
3411 sg_dma_len(&sg
3412 [sg_dma_index]));
3413
3414 for (; sg_dma_index < scb->sg_count;
3415 sg_dma_index++) {
3416 if (ips_fill_scb_sg_single
3417 (ha,
3418 sg_dma_address(&sg[sg_dma_index]),
3419 scb, ips_sg_index++,
3420 sg_dma_len(&sg[sg_dma_index])) < 0)
3421 break;
3422
3423 }
3424
3425 } else {
3426 /* Non S/G Request */
3427 (void) ips_fill_scb_sg_single(ha,
3428 scb->
3429 data_busaddr +
3430 (scb->sg_break *
3431 ha->max_xfer),
3432 scb, 0,
3433 scb->scsi_cmd->
3434 request_bufflen -
3435 (scb->sg_break *
3436 ha->max_xfer));
3437 }
3438
3439 scb->dcdb.transfer_length = scb->data_len;
3440 scb->dcdb.cmd_attribute |=
3441 ips_command_direction[scb->scsi_cmd->cmnd[0]];
3442
3443 if (!(scb->dcdb.cmd_attribute & 0x3))
3444 scb->dcdb.transfer_length = 0;
3445
3446 if (scb->data_len >= IPS_MAX_XFER) {
3447 scb->dcdb.cmd_attribute |= IPS_TRANSFER64K;
3448 scb->dcdb.transfer_length = 0;
3449 }
3450
3451 ret = ips_send_cmd(ha, scb);
3452
3453 switch (ret) {
3454 case IPS_FAILURE:
3455 if (scb->scsi_cmd) {
3456 scb->scsi_cmd->result = DID_ERROR << 16;
3457 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3458 }
3459
3460 ips_freescb(ha, scb);
3461 break;
3462 case IPS_SUCCESS_IMM:
3463 if (scb->scsi_cmd) {
3464 scb->scsi_cmd->result = DID_ERROR << 16;
3465 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3466 }
3467
3468 ips_freescb(ha, scb);
3469 break;
3470 default:
3471 break;
3472 } /* end case */
3473
3474 return;
3475 }
3476 } /* end if passthru */
3477
3478 if (scb->bus) {
3479 ha->dcdb_active[scb->bus - 1] &= ~(1 << scb->target_id);
3480 }
3481
3482 scb->scsi_cmd->scsi_done(scb->scsi_cmd);
3483
3484 ips_freescb(ha, scb);
3485 }
3486
3487 /****************************************************************************/
3488 /* */
3489 /* Routine Name: ips_map_status */
3490 /* */
3491 /* Routine Description: */
3492 /* */
3493 /* Map Controller Error codes to Linux Error Codes */
3494 /* */
3495 /****************************************************************************/
3496 static int
3497 ips_map_status(ips_ha_t * ha, ips_scb_t * scb, ips_stat_t * sp)
3498 {
3499 int errcode;
3500 int device_error;
3501 uint32_t transfer_len;
3502 IPS_DCDB_TABLE_TAPE *tapeDCDB;
3503 IPS_SCSI_INQ_DATA inquiryData;
3504
3505 METHOD_TRACE("ips_map_status", 1);
3506
3507 if (scb->bus) {
3508 DEBUG_VAR(2,
3509 "(%s%d) Physical device error (%d %d %d): %x %x, Sense Key: %x, ASC: %x, ASCQ: %x",
3510 ips_name, ha->host_num,
3511 scb->scsi_cmd->device->channel,
3512 scb->scsi_cmd->device->id, scb->scsi_cmd->device->lun,
3513 scb->basic_status, scb->extended_status,
3514 scb->extended_status ==
3515 IPS_ERR_CKCOND ? scb->dcdb.sense_info[2] & 0xf : 0,
3516 scb->extended_status ==
3517 IPS_ERR_CKCOND ? scb->dcdb.sense_info[12] : 0,
3518 scb->extended_status ==
3519 IPS_ERR_CKCOND ? scb->dcdb.sense_info[13] : 0);
3520 }
3521
3522 /* default driver error */
3523 errcode = DID_ERROR;
3524 device_error = 0;
3525
3526 switch (scb->basic_status & IPS_GSC_STATUS_MASK) {
3527 case IPS_CMD_TIMEOUT:
3528 errcode = DID_TIME_OUT;
3529 break;
3530
3531 case IPS_INVAL_OPCO:
3532 case IPS_INVAL_CMD_BLK:
3533 case IPS_INVAL_PARM_BLK:
3534 case IPS_LD_ERROR:
3535 case IPS_CMD_CMPLT_WERROR:
3536 break;
3537
3538 case IPS_PHYS_DRV_ERROR:
3539 switch (scb->extended_status) {
3540 case IPS_ERR_SEL_TO:
3541 if (scb->bus)
3542 errcode = DID_NO_CONNECT;
3543
3544 break;
3545
3546 case IPS_ERR_OU_RUN:
3547 if ((scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB) ||
3548 (scb->cmd.dcdb.op_code ==
3549 IPS_CMD_EXTENDED_DCDB_SG)) {
3550 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3551 transfer_len = tapeDCDB->transfer_length;
3552 } else {
3553 transfer_len =
3554 (uint32_t) scb->dcdb.transfer_length;
3555 }
3556
3557 if ((scb->bus) && (transfer_len < scb->data_len)) {
3558 /* Underrun - set default to no error */
3559 errcode = DID_OK;
3560
3561 /* Restrict access to physical DASD */
3562 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3563 ips_scmd_buf_read(scb->scsi_cmd,
3564 &inquiryData, sizeof (inquiryData));
3565 if ((inquiryData.DeviceType & 0x1f) == TYPE_DISK) {
3566 errcode = DID_TIME_OUT;
3567 break;
3568 }
3569 }
3570 } else
3571 errcode = DID_ERROR;
3572
3573 break;
3574
3575 case IPS_ERR_RECOVERY:
3576 /* don't fail recovered errors */
3577 if (scb->bus)
3578 errcode = DID_OK;
3579
3580 break;
3581
3582 case IPS_ERR_HOST_RESET:
3583 case IPS_ERR_DEV_RESET:
3584 errcode = DID_RESET;
3585 break;
3586
3587 case IPS_ERR_CKCOND:
3588 if (scb->bus) {
3589 if ((scb->cmd.dcdb.op_code ==
3590 IPS_CMD_EXTENDED_DCDB)
3591 || (scb->cmd.dcdb.op_code ==
3592 IPS_CMD_EXTENDED_DCDB_SG)) {
3593 tapeDCDB =
3594 (IPS_DCDB_TABLE_TAPE *) & scb->dcdb;
3595 memcpy(scb->scsi_cmd->sense_buffer,
3596 tapeDCDB->sense_info,
3597 sizeof (scb->scsi_cmd->
3598 sense_buffer));
3599 } else {
3600 memcpy(scb->scsi_cmd->sense_buffer,
3601 scb->dcdb.sense_info,
3602 sizeof (scb->scsi_cmd->
3603 sense_buffer));
3604 }
3605 device_error = 2; /* check condition */
3606 }
3607
3608 errcode = DID_OK;
3609
3610 break;
3611
3612 default:
3613 errcode = DID_ERROR;
3614 break;
3615
3616 } /* end switch */
3617 } /* end switch */
3618
3619 scb->scsi_cmd->result = device_error | (errcode << 16);
3620
3621 return (1);
3622 }
3623
3624 /****************************************************************************/
3625 /* */
3626 /* Routine Name: ips_send_wait */
3627 /* */
3628 /* Routine Description: */
3629 /* */
3630 /* Send a command to the controller and wait for it to return */
3631 /* */
3632 /* The FFDC Time Stamp use this function for the callback, but doesn't */
3633 /* actually need to wait. */
3634 /****************************************************************************/
3635 static int
3636 ips_send_wait(ips_ha_t * ha, ips_scb_t * scb, int timeout, int intr)
3637 {
3638 int ret;
3639
3640 METHOD_TRACE("ips_send_wait", 1);
3641
3642 if (intr != IPS_FFDC) { /* Won't be Waiting if this is a Time Stamp */
3643 ha->waitflag = TRUE;
3644 ha->cmd_in_progress = scb->cdb[0];
3645 }
3646 scb->callback = ipsintr_blocking;
3647 ret = ips_send_cmd(ha, scb);
3648
3649 if ((ret == IPS_FAILURE) || (ret == IPS_SUCCESS_IMM))
3650 return (ret);
3651
3652 if (intr != IPS_FFDC) /* Don't Wait around if this is a Time Stamp */
3653 ret = ips_wait(ha, timeout, intr);
3654
3655 return (ret);
3656 }
3657
3658 /****************************************************************************/
3659 /* */
3660 /* Routine Name: ips_scmd_buf_write */
3661 /* */
3662 /* Routine Description: */
3663 /* Write data to Scsi_Cmnd request_buffer at proper offsets */
3664 /****************************************************************************/
3665 static void
3666 ips_scmd_buf_write(Scsi_Cmnd * scmd, void *data, unsigned
3667 int count)
3668 {
3669 if (scmd->use_sg) {
3670 int i;
3671 unsigned int min_cnt, xfer_cnt;
3672 char *cdata = (char *) data;
3673 unsigned char *buffer;
3674 unsigned long flags;
3675 struct scatterlist *sg = scmd->request_buffer;
3676 for (i = 0, xfer_cnt = 0;
3677 (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3678 min_cnt = min(count - xfer_cnt, sg[i].length);
3679
3680 /* kmap_atomic() ensures addressability of the data buffer.*/
3681 /* local_irq_save() protects the KM_IRQ0 address slot. */
3682 local_irq_save(flags);
3683 buffer = kmap_atomic(sg[i].page, KM_IRQ0) + sg[i].offset;
3684 memcpy(buffer, &cdata[xfer_cnt], min_cnt);
3685 kunmap_atomic(buffer - sg[i].offset, KM_IRQ0);
3686 local_irq_restore(flags);
3687
3688 xfer_cnt += min_cnt;
3689 }
3690
3691 } else {
3692 unsigned int min_cnt = min(count, scmd->request_bufflen);
3693 memcpy(scmd->request_buffer, data, min_cnt);
3694 }
3695 }
3696
3697 /****************************************************************************/
3698 /* */
3699 /* Routine Name: ips_scmd_buf_read */
3700 /* */
3701 /* Routine Description: */
3702 /* Copy data from a Scsi_Cmnd to a new, linear buffer */
3703 /****************************************************************************/
3704 static void
3705 ips_scmd_buf_read(Scsi_Cmnd * scmd, void *data, unsigned
3706 int count)
3707 {
3708 if (scmd->use_sg) {
3709 int i;
3710 unsigned int min_cnt, xfer_cnt;
3711 char *cdata = (char *) data;
3712 unsigned char *buffer;
3713 unsigned long flags;
3714 struct scatterlist *sg = scmd->request_buffer;
3715 for (i = 0, xfer_cnt = 0;
3716 (i < scmd->use_sg) && (xfer_cnt < count); i++) {
3717 min_cnt = min(count - xfer_cnt, sg[i].length);
3718
3719 /* kmap_atomic() ensures addressability of the data buffer.*/
3720 /* local_irq_save() protects the KM_IRQ0 address slot. */
3721 local_irq_save(flags);
3722 buffer = kmap_atomic(sg[i].page, KM_IRQ0) + sg[i].offset;
3723 memcpy(&cdata[xfer_cnt], buffer, min_cnt);
3724 kunmap_atomic(buffer - sg[i].offset, KM_IRQ0);
3725 local_irq_restore(flags);
3726
3727 xfer_cnt += min_cnt;
3728 }
3729
3730 } else {
3731 unsigned int min_cnt = min(count, scmd->request_bufflen);
3732 memcpy(data, scmd->request_buffer, min_cnt);
3733 }
3734 }
3735
3736 /****************************************************************************/
3737 /* */
3738 /* Routine Name: ips_send_cmd */
3739 /* */
3740 /* Routine Description: */
3741 /* */
3742 /* Map SCSI commands to ServeRAID commands for logical drives */
3743 /* */
3744 /****************************************************************************/
3745 static int
3746 ips_send_cmd(ips_ha_t * ha, ips_scb_t * scb)
3747 {
3748 int ret;
3749 char *sp;
3750 int device_error;
3751 IPS_DCDB_TABLE_TAPE *tapeDCDB;
3752 int TimeOut;
3753
3754 METHOD_TRACE("ips_send_cmd", 1);
3755
3756 ret = IPS_SUCCESS;
3757
3758 if (!scb->scsi_cmd) {
3759 /* internal command */
3760
3761 if (scb->bus > 0) {
3762 /* Controller commands can't be issued */
3763 /* to real devices -- fail them */
3764 if ((ha->waitflag == TRUE) &&
3765 (ha->cmd_in_progress == scb->cdb[0])) {
3766 ha->waitflag = FALSE;
3767 }
3768
3769 return (1);
3770 }
3771 } else if ((scb->bus == 0) && (!ips_is_passthru(scb->scsi_cmd))) {
3772 /* command to logical bus -- interpret */
3773 ret = IPS_SUCCESS_IMM;
3774
3775 switch (scb->scsi_cmd->cmnd[0]) {
3776 case ALLOW_MEDIUM_REMOVAL:
3777 case REZERO_UNIT:
3778 case ERASE:
3779 case WRITE_FILEMARKS:
3780 case SPACE:
3781 scb->scsi_cmd->result = DID_ERROR << 16;
3782 break;
3783
3784 case START_STOP:
3785 scb->scsi_cmd->result = DID_OK << 16;
3786
3787 case TEST_UNIT_READY:
3788 case INQUIRY:
3789 if (scb->target_id == IPS_ADAPTER_ID) {
3790 /*
3791 * Either we have a TUR
3792 * or we have a SCSI inquiry
3793 */
3794 if (scb->scsi_cmd->cmnd[0] == TEST_UNIT_READY)
3795 scb->scsi_cmd->result = DID_OK << 16;
3796
3797 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
3798 IPS_SCSI_INQ_DATA inquiry;
3799
3800 memset(&inquiry, 0,
3801 sizeof (IPS_SCSI_INQ_DATA));
3802
3803 inquiry.DeviceType =
3804 IPS_SCSI_INQ_TYPE_PROCESSOR;
3805 inquiry.DeviceTypeQualifier =
3806 IPS_SCSI_INQ_LU_CONNECTED;
3807 inquiry.Version = IPS_SCSI_INQ_REV2;
3808 inquiry.ResponseDataFormat =
3809 IPS_SCSI_INQ_RD_REV2;
3810 inquiry.AdditionalLength = 31;
3811 inquiry.Flags[0] =
3812 IPS_SCSI_INQ_Address16;
3813 inquiry.Flags[1] =
3814 IPS_SCSI_INQ_WBus16 |
3815 IPS_SCSI_INQ_Sync;
3816 strncpy(inquiry.VendorId, "IBM ",
3817 8);
3818 strncpy(inquiry.ProductId,
3819 "SERVERAID ", 16);
3820 strncpy(inquiry.ProductRevisionLevel,
3821 "1.00", 4);
3822
3823 ips_scmd_buf_write(scb->scsi_cmd,
3824 &inquiry,
3825 sizeof (inquiry));
3826
3827 scb->scsi_cmd->result = DID_OK << 16;
3828 }
3829 } else {
3830 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3831 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3832 scb->cmd.logical_info.reserved = 0;
3833 scb->cmd.logical_info.reserved2 = 0;
3834 scb->data_len = sizeof (IPS_LD_INFO);
3835 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3836 scb->flags = 0;
3837 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3838 ret = IPS_SUCCESS;
3839 }
3840
3841 break;
3842
3843 case REQUEST_SENSE:
3844 ips_reqsen(ha, scb);
3845 scb->scsi_cmd->result = DID_OK << 16;
3846 break;
3847
3848 case READ_6:
3849 case WRITE_6:
3850 if (!scb->sg_len) {
3851 scb->cmd.basic_io.op_code =
3852 (scb->scsi_cmd->cmnd[0] ==
3853 READ_6) ? IPS_CMD_READ : IPS_CMD_WRITE;
3854 scb->cmd.basic_io.enhanced_sg = 0;
3855 scb->cmd.basic_io.sg_addr =
3856 cpu_to_le32(scb->data_busaddr);
3857 } else {
3858 scb->cmd.basic_io.op_code =
3859 (scb->scsi_cmd->cmnd[0] ==
3860 READ_6) ? IPS_CMD_READ_SG :
3861 IPS_CMD_WRITE_SG;
3862 scb->cmd.basic_io.enhanced_sg =
3863 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3864 scb->cmd.basic_io.sg_addr =
3865 cpu_to_le32(scb->sg_busaddr);
3866 }
3867
3868 scb->cmd.basic_io.segment_4G = 0;
3869 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3870 scb->cmd.basic_io.log_drv = scb->target_id;
3871 scb->cmd.basic_io.sg_count = scb->sg_len;
3872
3873 if (scb->cmd.basic_io.lba)
3874 scb->cmd.basic_io.lba =
3875 cpu_to_le32(le32_to_cpu
3876 (scb->cmd.basic_io.lba) +
3877 le16_to_cpu(scb->cmd.basic_io.
3878 sector_count));
3879 else
3880 scb->cmd.basic_io.lba =
3881 (((scb->scsi_cmd->
3882 cmnd[1] & 0x1f) << 16) | (scb->scsi_cmd->
3883 cmnd[2] << 8) |
3884 (scb->scsi_cmd->cmnd[3]));
3885
3886 scb->cmd.basic_io.sector_count =
3887 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3888
3889 if (le16_to_cpu(scb->cmd.basic_io.sector_count) == 0)
3890 scb->cmd.basic_io.sector_count =
3891 cpu_to_le16(256);
3892
3893 ret = IPS_SUCCESS;
3894 break;
3895
3896 case READ_10:
3897 case WRITE_10:
3898 if (!scb->sg_len) {
3899 scb->cmd.basic_io.op_code =
3900 (scb->scsi_cmd->cmnd[0] ==
3901 READ_10) ? IPS_CMD_READ : IPS_CMD_WRITE;
3902 scb->cmd.basic_io.enhanced_sg = 0;
3903 scb->cmd.basic_io.sg_addr =
3904 cpu_to_le32(scb->data_busaddr);
3905 } else {
3906 scb->cmd.basic_io.op_code =
3907 (scb->scsi_cmd->cmnd[0] ==
3908 READ_10) ? IPS_CMD_READ_SG :
3909 IPS_CMD_WRITE_SG;
3910 scb->cmd.basic_io.enhanced_sg =
3911 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
3912 scb->cmd.basic_io.sg_addr =
3913 cpu_to_le32(scb->sg_busaddr);
3914 }
3915
3916 scb->cmd.basic_io.segment_4G = 0;
3917 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3918 scb->cmd.basic_io.log_drv = scb->target_id;
3919 scb->cmd.basic_io.sg_count = scb->sg_len;
3920
3921 if (scb->cmd.basic_io.lba)
3922 scb->cmd.basic_io.lba =
3923 cpu_to_le32(le32_to_cpu
3924 (scb->cmd.basic_io.lba) +
3925 le16_to_cpu(scb->cmd.basic_io.
3926 sector_count));
3927 else
3928 scb->cmd.basic_io.lba =
3929 ((scb->scsi_cmd->cmnd[2] << 24) | (scb->
3930 scsi_cmd->
3931 cmnd[3]
3932 << 16) |
3933 (scb->scsi_cmd->cmnd[4] << 8) | scb->
3934 scsi_cmd->cmnd[5]);
3935
3936 scb->cmd.basic_io.sector_count =
3937 cpu_to_le16(scb->data_len / IPS_BLKSIZE);
3938
3939 if (cpu_to_le16(scb->cmd.basic_io.sector_count) == 0) {
3940 /*
3941 * This is a null condition
3942 * we don't have to do anything
3943 * so just return
3944 */
3945 scb->scsi_cmd->result = DID_OK << 16;
3946 } else
3947 ret = IPS_SUCCESS;
3948
3949 break;
3950
3951 case RESERVE:
3952 case RELEASE:
3953 scb->scsi_cmd->result = DID_OK << 16;
3954 break;
3955
3956 case MODE_SENSE:
3957 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
3958 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
3959 scb->cmd.basic_io.segment_4G = 0;
3960 scb->cmd.basic_io.enhanced_sg = 0;
3961 scb->data_len = sizeof (*ha->enq);
3962 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
3963 ret = IPS_SUCCESS;
3964 break;
3965
3966 case READ_CAPACITY:
3967 scb->cmd.logical_info.op_code = IPS_CMD_GET_LD_INFO;
3968 scb->cmd.logical_info.command_id = IPS_COMMAND_ID(ha, scb);
3969 scb->cmd.logical_info.reserved = 0;
3970 scb->cmd.logical_info.reserved2 = 0;
3971 scb->cmd.logical_info.reserved3 = 0;
3972 scb->data_len = sizeof (IPS_LD_INFO);
3973 scb->data_busaddr = ha->logical_drive_info_dma_addr;
3974 scb->flags = 0;
3975 scb->cmd.logical_info.buffer_addr = scb->data_busaddr;
3976 ret = IPS_SUCCESS;
3977 break;
3978
3979 case SEND_DIAGNOSTIC:
3980 case REASSIGN_BLOCKS:
3981 case FORMAT_UNIT:
3982 case SEEK_10:
3983 case VERIFY:
3984 case READ_DEFECT_DATA:
3985 case READ_BUFFER:
3986 case WRITE_BUFFER:
3987 scb->scsi_cmd->result = DID_OK << 16;
3988 break;
3989
3990 default:
3991 /* Set the Return Info to appear like the Command was */
3992 /* attempted, a Check Condition occurred, and Sense */
3993 /* Data indicating an Invalid CDB OpCode is returned. */
3994 sp = (char *) scb->scsi_cmd->sense_buffer;
3995 memset(sp, 0, sizeof (scb->scsi_cmd->sense_buffer));
3996
3997 sp[0] = 0x70; /* Error Code */
3998 sp[2] = ILLEGAL_REQUEST; /* Sense Key 5 Illegal Req. */
3999 sp[7] = 0x0A; /* Additional Sense Length */
4000 sp[12] = 0x20; /* ASC = Invalid OpCode */
4001 sp[13] = 0x00; /* ASCQ */
4002
4003 device_error = 2; /* Indicate Check Condition */
4004 scb->scsi_cmd->result = device_error | (DID_OK << 16);
4005 break;
4006 } /* end switch */
4007 }
4008 /* end if */
4009 if (ret == IPS_SUCCESS_IMM)
4010 return (ret);
4011
4012 /* setup DCDB */
4013 if (scb->bus > 0) {
4014
4015 /* If we already know the Device is Not there, no need to attempt a Command */
4016 /* This also protects an NT FailOver Controller from getting CDB's sent to it */
4017 if (ha->conf->dev[scb->bus - 1][scb->target_id].ucState == 0) {
4018 scb->scsi_cmd->result = DID_NO_CONNECT << 16;
4019 return (IPS_SUCCESS_IMM);
4020 }
4021
4022 ha->dcdb_active[scb->bus - 1] |= (1 << scb->target_id);
4023 scb->cmd.dcdb.command_id = IPS_COMMAND_ID(ha, scb);
4024 scb->cmd.dcdb.dcdb_address = cpu_to_le32(scb->scb_busaddr +
4025 (unsigned long) &scb->
4026 dcdb -
4027 (unsigned long) scb);
4028 scb->cmd.dcdb.reserved = 0;
4029 scb->cmd.dcdb.reserved2 = 0;
4030 scb->cmd.dcdb.reserved3 = 0;
4031 scb->cmd.dcdb.segment_4G = 0;
4032 scb->cmd.dcdb.enhanced_sg = 0;
4033
4034 TimeOut = scb->scsi_cmd->timeout_per_command;
4035
4036 if (ha->subsys->param[4] & 0x00100000) { /* If NEW Tape DCDB is Supported */
4037 if (!scb->sg_len) {
4038 scb->cmd.dcdb.op_code = IPS_CMD_EXTENDED_DCDB;
4039 } else {
4040 scb->cmd.dcdb.op_code =
4041 IPS_CMD_EXTENDED_DCDB_SG;
4042 scb->cmd.dcdb.enhanced_sg =
4043 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
4044 }
4045
4046 tapeDCDB = (IPS_DCDB_TABLE_TAPE *) & scb->dcdb; /* Use Same Data Area as Old DCDB Struct */
4047 tapeDCDB->device_address =
4048 ((scb->bus - 1) << 4) | scb->target_id;
4049 tapeDCDB->cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4050 tapeDCDB->cmd_attribute &= ~IPS_TRANSFER64K; /* Always Turn OFF 64K Size Flag */
4051
4052 if (TimeOut) {
4053 if (TimeOut < (10 * HZ))
4054 tapeDCDB->cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
4055 else if (TimeOut < (60 * HZ))
4056 tapeDCDB->cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
4057 else if (TimeOut < (1200 * HZ))
4058 tapeDCDB->cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
4059 }
4060
4061 tapeDCDB->cdb_length = scb->scsi_cmd->cmd_len;
4062 tapeDCDB->reserved_for_LUN = 0;
4063 tapeDCDB->transfer_length = scb->data_len;
4064 if (scb->cmd.dcdb.op_code == IPS_CMD_EXTENDED_DCDB_SG)
4065 tapeDCDB->buffer_pointer =
4066 cpu_to_le32(scb->sg_busaddr);
4067 else
4068 tapeDCDB->buffer_pointer =
4069 cpu_to_le32(scb->data_busaddr);
4070 tapeDCDB->sg_count = scb->sg_len;
4071 tapeDCDB->sense_length = sizeof (tapeDCDB->sense_info);
4072 tapeDCDB->scsi_status = 0;
4073 tapeDCDB->reserved = 0;
4074 memcpy(tapeDCDB->scsi_cdb, scb->scsi_cmd->cmnd,
4075 scb->scsi_cmd->cmd_len);
4076 } else {
4077 if (!scb->sg_len) {
4078 scb->cmd.dcdb.op_code = IPS_CMD_DCDB;
4079 } else {
4080 scb->cmd.dcdb.op_code = IPS_CMD_DCDB_SG;
4081 scb->cmd.dcdb.enhanced_sg =
4082 IPS_USE_ENH_SGLIST(ha) ? 0xFF : 0;
4083 }
4084
4085 scb->dcdb.device_address =
4086 ((scb->bus - 1) << 4) | scb->target_id;
4087 scb->dcdb.cmd_attribute |= IPS_DISCONNECT_ALLOWED;
4088
4089 if (TimeOut) {
4090 if (TimeOut < (10 * HZ))
4091 scb->dcdb.cmd_attribute |= IPS_TIMEOUT10; /* TimeOut is 10 Seconds */
4092 else if (TimeOut < (60 * HZ))
4093 scb->dcdb.cmd_attribute |= IPS_TIMEOUT60; /* TimeOut is 60 Seconds */
4094 else if (TimeOut < (1200 * HZ))
4095 scb->dcdb.cmd_attribute |= IPS_TIMEOUT20M; /* TimeOut is 20 Minutes */
4096 }
4097
4098 scb->dcdb.transfer_length = scb->data_len;
4099 if (scb->dcdb.cmd_attribute & IPS_TRANSFER64K)
4100 scb->dcdb.transfer_length = 0;
4101 if (scb->cmd.dcdb.op_code == IPS_CMD_DCDB_SG)
4102 scb->dcdb.buffer_pointer =
4103 cpu_to_le32(scb->sg_busaddr);
4104 else
4105 scb->dcdb.buffer_pointer =
4106 cpu_to_le32(scb->data_busaddr);
4107 scb->dcdb.cdb_length = scb->scsi_cmd->cmd_len;
4108 scb->dcdb.sense_length = sizeof (scb->dcdb.sense_info);
4109 scb->dcdb.sg_count = scb->sg_len;
4110 scb->dcdb.reserved = 0;
4111 memcpy(scb->dcdb.scsi_cdb, scb->scsi_cmd->cmnd,
4112 scb->scsi_cmd->cmd_len);
4113 scb->dcdb.scsi_status = 0;
4114 scb->dcdb.reserved2[0] = 0;
4115 scb->dcdb.reserved2[1] = 0;
4116 scb->dcdb.reserved2[2] = 0;
4117 }
4118 }
4119
4120 return ((*ha->func.issue) (ha, scb));
4121 }
4122
4123 /****************************************************************************/
4124 /* */
4125 /* Routine Name: ips_chk_status */
4126 /* */
4127 /* Routine Description: */
4128 /* */
4129 /* Check the status of commands to logical drives */
4130 /* Assumed to be called with the HA lock */
4131 /****************************************************************************/
4132 static void
4133 ips_chkstatus(ips_ha_t * ha, IPS_STATUS * pstatus)
4134 {
4135 ips_scb_t *scb;
4136 ips_stat_t *sp;
4137 uint8_t basic_status;
4138 uint8_t ext_status;
4139 int errcode;
4140 IPS_SCSI_INQ_DATA inquiryData;
4141
4142 METHOD_TRACE("ips_chkstatus", 1);
4143
4144 scb = &ha->scbs[pstatus->fields.command_id];
4145 scb->basic_status = basic_status =
4146 pstatus->fields.basic_status & IPS_BASIC_STATUS_MASK;
4147 scb->extended_status = ext_status = pstatus->fields.extended_status;
4148
4149 sp = &ha->sp;
4150 sp->residue_len = 0;
4151 sp->scb_addr = (void *) scb;
4152
4153 /* Remove the item from the active queue */
4154 ips_removeq_scb(&ha->scb_activelist, scb);
4155
4156 if (!scb->scsi_cmd)
4157 /* internal commands are handled in do_ipsintr */
4158 return;
4159
4160 DEBUG_VAR(2, "(%s%d) ips_chkstatus: cmd 0x%X id %d (%d %d %d)",
4161 ips_name,
4162 ha->host_num,
4163 scb->cdb[0],
4164 scb->cmd.basic_io.command_id,
4165 scb->bus, scb->target_id, scb->lun);
4166
4167 if ((scb->scsi_cmd) && (ips_is_passthru(scb->scsi_cmd)))
4168 /* passthru - just returns the raw result */
4169 return;
4170
4171 errcode = DID_OK;
4172
4173 if (((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_SUCCESS) ||
4174 ((basic_status & IPS_GSC_STATUS_MASK) == IPS_CMD_RECOVERED_ERROR)) {
4175
4176 if (scb->bus == 0) {
4177 if ((basic_status & IPS_GSC_STATUS_MASK) ==
4178 IPS_CMD_RECOVERED_ERROR) {
4179 DEBUG_VAR(1,
4180 "(%s%d) Recovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4181 ips_name, ha->host_num,
4182 scb->cmd.basic_io.op_code,
4183 basic_status, ext_status);
4184 }
4185
4186 switch (scb->scsi_cmd->cmnd[0]) {
4187 case ALLOW_MEDIUM_REMOVAL:
4188 case REZERO_UNIT:
4189 case ERASE:
4190 case WRITE_FILEMARKS:
4191 case SPACE:
4192 errcode = DID_ERROR;
4193 break;
4194
4195 case START_STOP:
4196 break;
4197
4198 case TEST_UNIT_READY:
4199 if (!ips_online(ha, scb)) {
4200 errcode = DID_TIME_OUT;
4201 }
4202 break;
4203
4204 case INQUIRY:
4205 if (ips_online(ha, scb)) {
4206 ips_inquiry(ha, scb);
4207 } else {
4208 errcode = DID_TIME_OUT;
4209 }
4210 break;
4211
4212 case REQUEST_SENSE:
4213 ips_reqsen(ha, scb);
4214 break;
4215
4216 case READ_6:
4217 case WRITE_6:
4218 case READ_10:
4219 case WRITE_10:
4220 case RESERVE:
4221 case RELEASE:
4222 break;
4223
4224 case MODE_SENSE:
4225 if (!ips_online(ha, scb)
4226 || !ips_msense(ha, scb)) {
4227 errcode = DID_ERROR;
4228 }
4229 break;
4230
4231 case READ_CAPACITY:
4232 if (ips_online(ha, scb))
4233 ips_rdcap(ha, scb);
4234 else {
4235 errcode = DID_TIME_OUT;
4236 }
4237 break;
4238
4239 case SEND_DIAGNOSTIC:
4240 case REASSIGN_BLOCKS:
4241 break;
4242
4243 case FORMAT_UNIT:
4244 errcode = DID_ERROR;
4245 break;
4246
4247 case SEEK_10:
4248 case VERIFY:
4249 case READ_DEFECT_DATA:
4250 case READ_BUFFER:
4251 case WRITE_BUFFER:
4252 break;
4253
4254 default:
4255 errcode = DID_ERROR;
4256 } /* end switch */
4257
4258 scb->scsi_cmd->result = errcode << 16;
4259 } else { /* bus == 0 */
4260 /* restrict access to physical drives */
4261 if (scb->scsi_cmd->cmnd[0] == INQUIRY) {
4262 ips_scmd_buf_read(scb->scsi_cmd,
4263 &inquiryData, sizeof (inquiryData));
4264 if ((inquiryData.DeviceType & 0x1f) == TYPE_DISK)
4265 scb->scsi_cmd->result = DID_TIME_OUT << 16;
4266 }
4267 } /* else */
4268 } else { /* recovered error / success */
4269 if (scb->bus == 0) {
4270 DEBUG_VAR(1,
4271 "(%s%d) Unrecovered Logical Drive Error OpCode: %x, BSB: %x, ESB: %x",
4272 ips_name, ha->host_num,
4273 scb->cmd.basic_io.op_code, basic_status,
4274 ext_status);
4275 }
4276
4277 ips_map_status(ha, scb, sp);
4278 } /* else */
4279 }
4280
4281 /****************************************************************************/
4282 /* */
4283 /* Routine Name: ips_online */
4284 /* */
4285 /* Routine Description: */
4286 /* */
4287 /* Determine if a logical drive is online */
4288 /* */
4289 /****************************************************************************/
4290 static int
4291 ips_online(ips_ha_t * ha, ips_scb_t * scb)
4292 {
4293 METHOD_TRACE("ips_online", 1);
4294
4295 if (scb->target_id >= IPS_MAX_LD)
4296 return (0);
4297
4298 if ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1) {
4299 memset(ha->logical_drive_info, 0, sizeof (IPS_LD_INFO));
4300 return (0);
4301 }
4302
4303 if (ha->logical_drive_info->drive_info[scb->target_id].state !=
4304 IPS_LD_OFFLINE
4305 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4306 IPS_LD_FREE
4307 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4308 IPS_LD_CRS
4309 && ha->logical_drive_info->drive_info[scb->target_id].state !=
4310 IPS_LD_SYS)
4311 return (1);
4312 else
4313 return (0);
4314 }
4315
4316 /****************************************************************************/
4317 /* */
4318 /* Routine Name: ips_inquiry */
4319 /* */
4320 /* Routine Description: */
4321 /* */
4322 /* Simulate an inquiry command to a logical drive */
4323 /* */
4324 /****************************************************************************/
4325 static int
4326 ips_inquiry(ips_ha_t * ha, ips_scb_t * scb)
4327 {
4328 IPS_SCSI_INQ_DATA inquiry;
4329
4330 METHOD_TRACE("ips_inquiry", 1);
4331
4332 memset(&inquiry, 0, sizeof (IPS_SCSI_INQ_DATA));
4333
4334 inquiry.DeviceType = IPS_SCSI_INQ_TYPE_DASD;
4335 inquiry.DeviceTypeQualifier = IPS_SCSI_INQ_LU_CONNECTED;
4336 inquiry.Version = IPS_SCSI_INQ_REV2;
4337 inquiry.ResponseDataFormat = IPS_SCSI_INQ_RD_REV2;
4338 inquiry.AdditionalLength = 31;
4339 inquiry.Flags[0] = IPS_SCSI_INQ_Address16;
4340 inquiry.Flags[1] =
4341 IPS_SCSI_INQ_WBus16 | IPS_SCSI_INQ_Sync | IPS_SCSI_INQ_CmdQue;
4342 strncpy(inquiry.VendorId, "IBM ", 8);
4343 strncpy(inquiry.ProductId, "SERVERAID ", 16);
4344 strncpy(inquiry.ProductRevisionLevel, "1.00", 4);
4345
4346 ips_scmd_buf_write(scb->scsi_cmd, &inquiry, sizeof (inquiry));
4347
4348 return (1);
4349 }
4350
4351 /****************************************************************************/
4352 /* */
4353 /* Routine Name: ips_rdcap */
4354 /* */
4355 /* Routine Description: */
4356 /* */
4357 /* Simulate a read capacity command to a logical drive */
4358 /* */
4359 /****************************************************************************/
4360 static int
4361 ips_rdcap(ips_ha_t * ha, ips_scb_t * scb)
4362 {
4363 IPS_SCSI_CAPACITY cap;
4364
4365 METHOD_TRACE("ips_rdcap", 1);
4366
4367 if (scb->scsi_cmd->bufflen < 8)
4368 return (0);
4369
4370 cap.lba =
4371 cpu_to_be32(le32_to_cpu
4372 (ha->logical_drive_info->
4373 drive_info[scb->target_id].sector_count) - 1);
4374 cap.len = cpu_to_be32((uint32_t) IPS_BLKSIZE);
4375
4376 ips_scmd_buf_write(scb->scsi_cmd, &cap, sizeof (cap));
4377
4378 return (1);
4379 }
4380
4381 /****************************************************************************/
4382 /* */
4383 /* Routine Name: ips_msense */
4384 /* */
4385 /* Routine Description: */
4386 /* */
4387 /* Simulate a mode sense command to a logical drive */
4388 /* */
4389 /****************************************************************************/
4390 static int
4391 ips_msense(ips_ha_t * ha, ips_scb_t * scb)
4392 {
4393 uint16_t heads;
4394 uint16_t sectors;
4395 uint32_t cylinders;
4396 IPS_SCSI_MODE_PAGE_DATA mdata;
4397
4398 METHOD_TRACE("ips_msense", 1);
4399
4400 if (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) > 0x400000 &&
4401 (ha->enq->ucMiscFlag & 0x8) == 0) {
4402 heads = IPS_NORM_HEADS;
4403 sectors = IPS_NORM_SECTORS;
4404 } else {
4405 heads = IPS_COMP_HEADS;
4406 sectors = IPS_COMP_SECTORS;
4407 }
4408
4409 cylinders =
4410 (le32_to_cpu(ha->enq->ulDriveSize[scb->target_id]) -
4411 1) / (heads * sectors);
4412
4413 memset(&mdata, 0, sizeof (IPS_SCSI_MODE_PAGE_DATA));
4414
4415 mdata.hdr.BlockDescLength = 8;
4416
4417 switch (scb->scsi_cmd->cmnd[2] & 0x3f) {
4418 case 0x03: /* page 3 */
4419 mdata.pdata.pg3.PageCode = 3;
4420 mdata.pdata.pg3.PageLength = sizeof (IPS_SCSI_MODE_PAGE3);
4421 mdata.hdr.DataLength =
4422 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg3.PageLength;
4423 mdata.pdata.pg3.TracksPerZone = 0;
4424 mdata.pdata.pg3.AltSectorsPerZone = 0;
4425 mdata.pdata.pg3.AltTracksPerZone = 0;
4426 mdata.pdata.pg3.AltTracksPerVolume = 0;
4427 mdata.pdata.pg3.SectorsPerTrack = cpu_to_be16(sectors);
4428 mdata.pdata.pg3.BytesPerSector = cpu_to_be16(IPS_BLKSIZE);
4429 mdata.pdata.pg3.Interleave = cpu_to_be16(1);
4430 mdata.pdata.pg3.TrackSkew = 0;
4431 mdata.pdata.pg3.CylinderSkew = 0;
4432 mdata.pdata.pg3.flags = IPS_SCSI_MP3_SoftSector;
4433 break;
4434
4435 case 0x4:
4436 mdata.pdata.pg4.PageCode = 4;
4437 mdata.pdata.pg4.PageLength = sizeof (IPS_SCSI_MODE_PAGE4);
4438 mdata.hdr.DataLength =
4439 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg4.PageLength;
4440 mdata.pdata.pg4.CylindersHigh =
4441 cpu_to_be16((cylinders >> 8) & 0xFFFF);
4442 mdata.pdata.pg4.CylindersLow = (cylinders & 0xFF);
4443 mdata.pdata.pg4.Heads = heads;
4444 mdata.pdata.pg4.WritePrecompHigh = 0;
4445 mdata.pdata.pg4.WritePrecompLow = 0;
4446 mdata.pdata.pg4.ReducedWriteCurrentHigh = 0;
4447 mdata.pdata.pg4.ReducedWriteCurrentLow = 0;
4448 mdata.pdata.pg4.StepRate = cpu_to_be16(1);
4449 mdata.pdata.pg4.LandingZoneHigh = 0;
4450 mdata.pdata.pg4.LandingZoneLow = 0;
4451 mdata.pdata.pg4.flags = 0;
4452 mdata.pdata.pg4.RotationalOffset = 0;
4453 mdata.pdata.pg4.MediumRotationRate = 0;
4454 break;
4455 case 0x8:
4456 mdata.pdata.pg8.PageCode = 8;
4457 mdata.pdata.pg8.PageLength = sizeof (IPS_SCSI_MODE_PAGE8);
4458 mdata.hdr.DataLength =
4459 3 + mdata.hdr.BlockDescLength + mdata.pdata.pg8.PageLength;
4460 /* everything else is left set to 0 */
4461 break;
4462
4463 default:
4464 return (0);
4465 } /* end switch */
4466
4467 ips_scmd_buf_write(scb->scsi_cmd, &mdata, sizeof (mdata));
4468
4469 return (1);
4470 }
4471
4472 /****************************************************************************/
4473 /* */
4474 /* Routine Name: ips_reqsen */
4475 /* */
4476 /* Routine Description: */
4477 /* */
4478 /* Simulate a request sense command to a logical drive */
4479 /* */
4480 /****************************************************************************/
4481 static int
4482 ips_reqsen(ips_ha_t * ha, ips_scb_t * scb)
4483 {
4484 IPS_SCSI_REQSEN reqsen;
4485
4486 METHOD_TRACE("ips_reqsen", 1);
4487
4488 memset(&reqsen, 0, sizeof (IPS_SCSI_REQSEN));
4489
4490 reqsen.ResponseCode =
4491 IPS_SCSI_REQSEN_VALID | IPS_SCSI_REQSEN_CURRENT_ERR;
4492 reqsen.AdditionalLength = 10;
4493 reqsen.AdditionalSenseCode = IPS_SCSI_REQSEN_NO_SENSE;
4494 reqsen.AdditionalSenseCodeQual = IPS_SCSI_REQSEN_NO_SENSE;
4495
4496 ips_scmd_buf_write(scb->scsi_cmd, &reqsen, sizeof (reqsen));
4497
4498 return (1);
4499 }
4500
4501 /****************************************************************************/
4502 /* */
4503 /* Routine Name: ips_free */
4504 /* */
4505 /* Routine Description: */
4506 /* */
4507 /* Free any allocated space for this controller */
4508 /* */
4509 /****************************************************************************/
4510 static void
4511 ips_free(ips_ha_t * ha)
4512 {
4513
4514 METHOD_TRACE("ips_free", 1);
4515
4516 if (ha) {
4517 if (ha->enq) {
4518 pci_free_consistent(ha->pcidev, sizeof(IPS_ENQ),
4519 ha->enq, ha->enq_busaddr);
4520 ha->enq = NULL;
4521 }
4522
4523 kfree(ha->conf);
4524 ha->conf = NULL;
4525
4526 if (ha->adapt) {
4527 pci_free_consistent(ha->pcidev,
4528 sizeof (IPS_ADAPTER) +
4529 sizeof (IPS_IO_CMD), ha->adapt,
4530 ha->adapt->hw_status_start);
4531 ha->adapt = NULL;
4532 }
4533
4534 if (ha->logical_drive_info) {
4535 pci_free_consistent(ha->pcidev,
4536 sizeof (IPS_LD_INFO),
4537 ha->logical_drive_info,
4538 ha->logical_drive_info_dma_addr);
4539 ha->logical_drive_info = NULL;
4540 }
4541
4542 kfree(ha->nvram);
4543 ha->nvram = NULL;
4544
4545 kfree(ha->subsys);
4546 ha->subsys = NULL;
4547
4548 if (ha->ioctl_data) {
4549 pci_free_consistent(ha->pcidev, ha->ioctl_len,
4550 ha->ioctl_data, ha->ioctl_busaddr);
4551 ha->ioctl_data = NULL;
4552 ha->ioctl_datasize = 0;
4553 ha->ioctl_len = 0;
4554 }
4555 ips_deallocatescbs(ha, ha->max_cmds);
4556
4557 /* free memory mapped (if applicable) */
4558 if (ha->mem_ptr) {
4559 iounmap(ha->ioremap_ptr);
4560 ha->ioremap_ptr = NULL;
4561 ha->mem_ptr = NULL;
4562 }
4563
4564 if (ha->mem_addr)
4565 release_mem_region(ha->mem_addr, ha->mem_len);
4566 ha->mem_addr = 0;
4567
4568 }
4569 }
4570
4571 /****************************************************************************/
4572 /* */
4573 /* Routine Name: ips_deallocatescbs */
4574 /* */
4575 /* Routine Description: */
4576 /* */
4577 /* Free the command blocks */
4578 /* */
4579 /****************************************************************************/
4580 static int
4581 ips_deallocatescbs(ips_ha_t * ha, int cmds)
4582 {
4583 if (ha->scbs) {
4584 pci_free_consistent(ha->pcidev,
4585 IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * cmds,
4586 ha->scbs->sg_list.list,
4587 ha->scbs->sg_busaddr);
4588 pci_free_consistent(ha->pcidev, sizeof (ips_scb_t) * cmds,
4589 ha->scbs, ha->scbs->scb_busaddr);
4590 ha->scbs = NULL;
4591 } /* end if */
4592 return 1;
4593 }
4594
4595 /****************************************************************************/
4596 /* */
4597 /* Routine Name: ips_allocatescbs */
4598 /* */
4599 /* Routine Description: */
4600 /* */
4601 /* Allocate the command blocks */
4602 /* */
4603 /****************************************************************************/
4604 static int
4605 ips_allocatescbs(ips_ha_t * ha)
4606 {
4607 ips_scb_t *scb_p;
4608 IPS_SG_LIST ips_sg;
4609 int i;
4610 dma_addr_t command_dma, sg_dma;
4611
4612 METHOD_TRACE("ips_allocatescbs", 1);
4613
4614 /* Allocate memory for the SCBs */
4615 ha->scbs =
4616 pci_alloc_consistent(ha->pcidev, ha->max_cmds * sizeof (ips_scb_t),
4617 &command_dma);
4618 if (ha->scbs == NULL)
4619 return 0;
4620 ips_sg.list =
4621 pci_alloc_consistent(ha->pcidev,
4622 IPS_SGLIST_SIZE(ha) * IPS_MAX_SG *
4623 ha->max_cmds, &sg_dma);
4624 if (ips_sg.list == NULL) {
4625 pci_free_consistent(ha->pcidev,
4626 ha->max_cmds * sizeof (ips_scb_t), ha->scbs,
4627 command_dma);
4628 return 0;
4629 }
4630
4631 memset(ha->scbs, 0, ha->max_cmds * sizeof (ips_scb_t));
4632
4633 for (i = 0; i < ha->max_cmds; i++) {
4634 scb_p = &ha->scbs[i];
4635 scb_p->scb_busaddr = command_dma + sizeof (ips_scb_t) * i;
4636 /* set up S/G list */
4637 if (IPS_USE_ENH_SGLIST(ha)) {
4638 scb_p->sg_list.enh_list =
4639 ips_sg.enh_list + i * IPS_MAX_SG;
4640 scb_p->sg_busaddr =
4641 sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4642 } else {
4643 scb_p->sg_list.std_list =
4644 ips_sg.std_list + i * IPS_MAX_SG;
4645 scb_p->sg_busaddr =
4646 sg_dma + IPS_SGLIST_SIZE(ha) * IPS_MAX_SG * i;
4647 }
4648
4649 /* add to the free list */
4650 if (i < ha->max_cmds - 1) {
4651 scb_p->q_next = ha->scb_freelist;
4652 ha->scb_freelist = scb_p;
4653 }
4654 }
4655
4656 /* success */
4657 return (1);
4658 }
4659
4660 /****************************************************************************/
4661 /* */
4662 /* Routine Name: ips_init_scb */
4663 /* */
4664 /* Routine Description: */
4665 /* */
4666 /* Initialize a CCB to default values */
4667 /* */
4668 /****************************************************************************/
4669 static void
4670 ips_init_scb(ips_ha_t * ha, ips_scb_t * scb)
4671 {
4672 IPS_SG_LIST sg_list;
4673 uint32_t cmd_busaddr, sg_busaddr;
4674 METHOD_TRACE("ips_init_scb", 1);
4675
4676 if (scb == NULL)
4677 return;
4678
4679 sg_list.list = scb->sg_list.list;
4680 cmd_busaddr = scb->scb_busaddr;
4681 sg_busaddr = scb->sg_busaddr;
4682 /* zero fill */
4683 memset(scb, 0, sizeof (ips_scb_t));
4684 memset(ha->dummy, 0, sizeof (IPS_IO_CMD));
4685
4686 /* Initialize dummy command bucket */
4687 ha->dummy->op_code = 0xFF;
4688 ha->dummy->ccsar = cpu_to_le32(ha->adapt->hw_status_start
4689 + sizeof (IPS_ADAPTER));
4690 ha->dummy->command_id = IPS_MAX_CMDS;
4691
4692 /* set bus address of scb */
4693 scb->scb_busaddr = cmd_busaddr;
4694 scb->sg_busaddr = sg_busaddr;
4695 scb->sg_list.list = sg_list.list;
4696
4697 /* Neptune Fix */
4698 scb->cmd.basic_io.cccr = cpu_to_le32((uint32_t) IPS_BIT_ILE);
4699 scb->cmd.basic_io.ccsar = cpu_to_le32(ha->adapt->hw_status_start
4700 + sizeof (IPS_ADAPTER));
4701 }
4702
4703 /****************************************************************************/
4704 /* */
4705 /* Routine Name: ips_get_scb */
4706 /* */
4707 /* Routine Description: */
4708 /* */
4709 /* Initialize a CCB to default values */
4710 /* */
4711 /* ASSUMED to be callled from within a lock */
4712 /* */
4713 /****************************************************************************/
4714 static ips_scb_t *
4715 ips_getscb(ips_ha_t * ha)
4716 {
4717 ips_scb_t *scb;
4718
4719 METHOD_TRACE("ips_getscb", 1);
4720
4721 if ((scb = ha->scb_freelist) == NULL) {
4722
4723 return (NULL);
4724 }
4725
4726 ha->scb_freelist = scb->q_next;
4727 scb->flags = 0;
4728 scb->q_next = NULL;
4729
4730 ips_init_scb(ha, scb);
4731
4732 return (scb);
4733 }
4734
4735 /****************************************************************************/
4736 /* */
4737 /* Routine Name: ips_free_scb */
4738 /* */
4739 /* Routine Description: */
4740 /* */
4741 /* Return an unused CCB back to the free list */
4742 /* */
4743 /* ASSUMED to be called from within a lock */
4744 /* */
4745 /****************************************************************************/
4746 static void
4747 ips_freescb(ips_ha_t * ha, ips_scb_t * scb)
4748 {
4749
4750 METHOD_TRACE("ips_freescb", 1);
4751 if (scb->flags & IPS_SCB_MAP_SG)
4752 pci_unmap_sg(ha->pcidev, scb->scsi_cmd->request_buffer,
4753 scb->scsi_cmd->use_sg, IPS_DMA_DIR(scb));
4754 else if (scb->flags & IPS_SCB_MAP_SINGLE)
4755 pci_unmap_single(ha->pcidev, scb->data_busaddr, scb->data_len,
4756 IPS_DMA_DIR(scb));
4757
4758 /* check to make sure this is not our "special" scb */
4759 if (IPS_COMMAND_ID(ha, scb) < (ha->max_cmds - 1)) {
4760 scb->q_next = ha->scb_freelist;
4761 ha->scb_freelist = scb;
4762 }
4763 }
4764
4765 /****************************************************************************/
4766 /* */
4767 /* Routine Name: ips_isinit_copperhead */
4768 /* */
4769 /* Routine Description: */
4770 /* */
4771 /* Is controller initialized ? */
4772 /* */
4773 /****************************************************************************/
4774 static int
4775 ips_isinit_copperhead(ips_ha_t * ha)
4776 {
4777 uint8_t scpr;
4778 uint8_t isr;
4779
4780 METHOD_TRACE("ips_isinit_copperhead", 1);
4781
4782 isr = inb(ha->io_addr + IPS_REG_HISR);
4783 scpr = inb(ha->io_addr + IPS_REG_SCPR);
4784
4785 if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4786 return (0);
4787 else
4788 return (1);
4789 }
4790
4791 /****************************************************************************/
4792 /* */
4793 /* Routine Name: ips_isinit_copperhead_memio */
4794 /* */
4795 /* Routine Description: */
4796 /* */
4797 /* Is controller initialized ? */
4798 /* */
4799 /****************************************************************************/
4800 static int
4801 ips_isinit_copperhead_memio(ips_ha_t * ha)
4802 {
4803 uint8_t isr = 0;
4804 uint8_t scpr;
4805
4806 METHOD_TRACE("ips_is_init_copperhead_memio", 1);
4807
4808 isr = readb(ha->mem_ptr + IPS_REG_HISR);
4809 scpr = readb(ha->mem_ptr + IPS_REG_SCPR);
4810
4811 if (((isr & IPS_BIT_EI) == 0) && ((scpr & IPS_BIT_EBM) == 0))
4812 return (0);
4813 else
4814 return (1);
4815 }
4816
4817 /****************************************************************************/
4818 /* */
4819 /* Routine Name: ips_isinit_morpheus */
4820 /* */
4821 /* Routine Description: */
4822 /* */
4823 /* Is controller initialized ? */
4824 /* */
4825 /****************************************************************************/
4826 static int
4827 ips_isinit_morpheus(ips_ha_t * ha)
4828 {
4829 uint32_t post;
4830 uint32_t bits;
4831
4832 METHOD_TRACE("ips_is_init_morpheus", 1);
4833
4834 if (ips_isintr_morpheus(ha))
4835 ips_flush_and_reset(ha);
4836
4837 post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
4838 bits = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
4839
4840 if (post == 0)
4841 return (0);
4842 else if (bits & 0x3)
4843 return (0);
4844 else
4845 return (1);
4846 }
4847
4848 /****************************************************************************/
4849 /* */
4850 /* Routine Name: ips_flush_and_reset */
4851 /* */
4852 /* Routine Description: */
4853 /* */
4854 /* Perform cleanup ( FLUSH and RESET ) when the adapter is in an unknown */
4855 /* state ( was trying to INIT and an interrupt was already pending ) ... */
4856 /* */
4857 /****************************************************************************/
4858 static void
4859 ips_flush_and_reset(ips_ha_t *ha)
4860 {
4861 ips_scb_t *scb;
4862 int ret;
4863 int time;
4864 int done;
4865 dma_addr_t command_dma;
4866
4867 /* Create a usuable SCB */
4868 scb = pci_alloc_consistent(ha->pcidev, sizeof(ips_scb_t), &command_dma);
4869 if (scb) {
4870 memset(scb, 0, sizeof(ips_scb_t));
4871 ips_init_scb(ha, scb);
4872 scb->scb_busaddr = command_dma;
4873
4874 scb->timeout = ips_cmd_timeout;
4875 scb->cdb[0] = IPS_CMD_FLUSH;
4876
4877 scb->cmd.flush_cache.op_code = IPS_CMD_FLUSH;
4878 scb->cmd.flush_cache.command_id = IPS_MAX_CMDS; /* Use an ID that would otherwise not exist */
4879 scb->cmd.flush_cache.state = IPS_NORM_STATE;
4880 scb->cmd.flush_cache.reserved = 0;
4881 scb->cmd.flush_cache.reserved2 = 0;
4882 scb->cmd.flush_cache.reserved3 = 0;
4883 scb->cmd.flush_cache.reserved4 = 0;
4884
4885 ret = ips_send_cmd(ha, scb); /* Send the Flush Command */
4886
4887 if (ret == IPS_SUCCESS) {
4888 time = 60 * IPS_ONE_SEC; /* Max Wait time is 60 seconds */
4889 done = 0;
4890
4891 while ((time > 0) && (!done)) {
4892 done = ips_poll_for_flush_complete(ha);
4893 /* This may look evil, but it's only done during extremely rare start-up conditions ! */
4894 udelay(1000);
4895 time--;
4896 }
4897 }
4898 }
4899
4900 /* Now RESET and INIT the adapter */
4901 (*ha->func.reset) (ha);
4902
4903 pci_free_consistent(ha->pcidev, sizeof(ips_scb_t), scb, command_dma);
4904 return;
4905 }
4906
4907 /****************************************************************************/
4908 /* */
4909 /* Routine Name: ips_poll_for_flush_complete */
4910 /* */
4911 /* Routine Description: */
4912 /* */
4913 /* Poll for the Flush Command issued by ips_flush_and_reset() to complete */
4914 /* All other responses are just taken off the queue and ignored */
4915 /* */
4916 /****************************************************************************/
4917 static int
4918 ips_poll_for_flush_complete(ips_ha_t * ha)
4919 {
4920 IPS_STATUS cstatus;
4921
4922 while (TRUE) {
4923 cstatus.value = (*ha->func.statupd) (ha);
4924
4925 if (cstatus.value == 0xffffffff) /* If No Interrupt to process */
4926 break;
4927
4928 /* Success is when we see the Flush Command ID */
4929 if (cstatus.fields.command_id == IPS_MAX_CMDS )
4930 return 1;
4931 }
4932
4933 return 0;
4934 }
4935
4936 /****************************************************************************/
4937 /* */
4938 /* Routine Name: ips_enable_int_copperhead */
4939 /* */
4940 /* Routine Description: */
4941 /* Turn on interrupts */
4942 /* */
4943 /****************************************************************************/
4944 static void
4945 ips_enable_int_copperhead(ips_ha_t * ha)
4946 {
4947 METHOD_TRACE("ips_enable_int_copperhead", 1);
4948
4949 outb(ha->io_addr + IPS_REG_HISR, IPS_BIT_EI);
4950 inb(ha->io_addr + IPS_REG_HISR); /*Ensure PCI Posting Completes*/
4951 }
4952
4953 /****************************************************************************/
4954 /* */
4955 /* Routine Name: ips_enable_int_copperhead_memio */
4956 /* */
4957 /* Routine Description: */
4958 /* Turn on interrupts */
4959 /* */
4960 /****************************************************************************/
4961 static void
4962 ips_enable_int_copperhead_memio(ips_ha_t * ha)
4963 {
4964 METHOD_TRACE("ips_enable_int_copperhead_memio", 1);
4965
4966 writeb(IPS_BIT_EI, ha->mem_ptr + IPS_REG_HISR);
4967 readb(ha->mem_ptr + IPS_REG_HISR); /*Ensure PCI Posting Completes*/
4968 }
4969
4970 /****************************************************************************/
4971 /* */
4972 /* Routine Name: ips_enable_int_morpheus */
4973 /* */
4974 /* Routine Description: */
4975 /* Turn on interrupts */
4976 /* */
4977 /****************************************************************************/
4978 static void
4979 ips_enable_int_morpheus(ips_ha_t * ha)
4980 {
4981 uint32_t Oimr;
4982
4983 METHOD_TRACE("ips_enable_int_morpheus", 1);
4984
4985 Oimr = readl(ha->mem_ptr + IPS_REG_I960_OIMR);
4986 Oimr &= ~0x08;
4987 writel(Oimr, ha->mem_ptr + IPS_REG_I960_OIMR);
4988 readl(ha->mem_ptr + IPS_REG_I960_OIMR); /*Ensure PCI Posting Completes*/
4989 }
4990
4991 /****************************************************************************/
4992 /* */
4993 /* Routine Name: ips_init_copperhead */
4994 /* */
4995 /* Routine Description: */
4996 /* */
4997 /* Initialize a copperhead controller */
4998 /* */
4999 /****************************************************************************/
5000 static int
5001 ips_init_copperhead(ips_ha_t * ha)
5002 {
5003 uint8_t Isr;
5004 uint8_t Cbsp;
5005 uint8_t PostByte[IPS_MAX_POST_BYTES];
5006 uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
5007 int i, j;
5008
5009 METHOD_TRACE("ips_init_copperhead", 1);
5010
5011 for (i = 0; i < IPS_MAX_POST_BYTES; i++) {
5012 for (j = 0; j < 45; j++) {
5013 Isr = inb(ha->io_addr + IPS_REG_HISR);
5014 if (Isr & IPS_BIT_GHI)
5015 break;
5016
5017 /* Delay for 1 Second */
5018 msleep(IPS_ONE_SEC);
5019 }
5020
5021 if (j >= 45)
5022 /* error occurred */
5023 return (0);
5024
5025 PostByte[i] = inb(ha->io_addr + IPS_REG_ISPR);
5026 outb(Isr, ha->io_addr + IPS_REG_HISR);
5027 }
5028
5029 if (PostByte[0] < IPS_GOOD_POST_STATUS) {
5030 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5031 "reset controller fails (post status %x %x).\n",
5032 PostByte[0], PostByte[1]);
5033
5034 return (0);
5035 }
5036
5037 for (i = 0; i < IPS_MAX_CONFIG_BYTES; i++) {
5038 for (j = 0; j < 240; j++) {
5039 Isr = inb(ha->io_addr + IPS_REG_HISR);
5040 if (Isr & IPS_BIT_GHI)
5041 break;
5042
5043 /* Delay for 1 Second */
5044 msleep(IPS_ONE_SEC);
5045 }
5046
5047 if (j >= 240)
5048 /* error occurred */
5049 return (0);
5050
5051 ConfigByte[i] = inb(ha->io_addr + IPS_REG_ISPR);
5052 outb(Isr, ha->io_addr + IPS_REG_HISR);
5053 }
5054
5055 for (i = 0; i < 240; i++) {
5056 Cbsp = inb(ha->io_addr + IPS_REG_CBSP);
5057
5058 if ((Cbsp & IPS_BIT_OP) == 0)
5059 break;
5060
5061 /* Delay for 1 Second */
5062 msleep(IPS_ONE_SEC);
5063 }
5064
5065 if (i >= 240)
5066 /* reset failed */
5067 return (0);
5068
5069 /* setup CCCR */
5070 outl(cpu_to_le32(0x1010), ha->io_addr + IPS_REG_CCCR);
5071
5072 /* Enable busmastering */
5073 outb(IPS_BIT_EBM, ha->io_addr + IPS_REG_SCPR);
5074
5075 if (ha->revision_id == IPS_REVID_TROMBONE64)
5076 /* fix for anaconda64 */
5077 outl(0, ha->io_addr + IPS_REG_NDAE);
5078
5079 /* Enable interrupts */
5080 outb(IPS_BIT_EI, ha->io_addr + IPS_REG_HISR);
5081
5082 return (1);
5083 }
5084
5085 /****************************************************************************/
5086 /* */
5087 /* Routine Name: ips_init_copperhead_memio */
5088 /* */
5089 /* Routine Description: */
5090 /* */
5091 /* Initialize a copperhead controller with memory mapped I/O */
5092 /* */
5093 /****************************************************************************/
5094 static int
5095 ips_init_copperhead_memio(ips_ha_t * ha)
5096 {
5097 uint8_t Isr = 0;
5098 uint8_t Cbsp;
5099 uint8_t PostByte[IPS_MAX_POST_BYTES];
5100 uint8_t ConfigByte[IPS_MAX_CONFIG_BYTES];
5101 int i, j;
5102
5103 METHOD_TRACE("ips_init_copperhead_memio", 1);
5104
5105 for (i = 0; i < IPS_MAX_POST_BYTES; i++) {
5106 for (j = 0; j < 45; j++) {
5107 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5108 if (Isr & IPS_BIT_GHI)
5109 break;
5110
5111 /* Delay for 1 Second */
5112 msleep(IPS_ONE_SEC);
5113 }
5114
5115 if (j >= 45)
5116 /* error occurred */
5117 return (0);
5118
5119 PostByte[i] = readb(ha->mem_ptr + IPS_REG_ISPR);
5120 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5121 }
5122
5123 if (PostByte[0] < IPS_GOOD_POST_STATUS) {
5124 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5125 "reset controller fails (post status %x %x).\n",
5126 PostByte[0], PostByte[1]);
5127
5128 return (0);
5129 }
5130
5131 for (i = 0; i < IPS_MAX_CONFIG_BYTES; i++) {
5132 for (j = 0; j < 240; j++) {
5133 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5134 if (Isr & IPS_BIT_GHI)
5135 break;
5136
5137 /* Delay for 1 Second */
5138 msleep(IPS_ONE_SEC);
5139 }
5140
5141 if (j >= 240)
5142 /* error occurred */
5143 return (0);
5144
5145 ConfigByte[i] = readb(ha->mem_ptr + IPS_REG_ISPR);
5146 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5147 }
5148
5149 for (i = 0; i < 240; i++) {
5150 Cbsp = readb(ha->mem_ptr + IPS_REG_CBSP);
5151
5152 if ((Cbsp & IPS_BIT_OP) == 0)
5153 break;
5154
5155 /* Delay for 1 Second */
5156 msleep(IPS_ONE_SEC);
5157 }
5158
5159 if (i >= 240)
5160 /* error occurred */
5161 return (0);
5162
5163 /* setup CCCR */
5164 writel(0x1010, ha->mem_ptr + IPS_REG_CCCR);
5165
5166 /* Enable busmastering */
5167 writeb(IPS_BIT_EBM, ha->mem_ptr + IPS_REG_SCPR);
5168
5169 if (ha->revision_id == IPS_REVID_TROMBONE64)
5170 /* fix for anaconda64 */
5171 writel(0, ha->mem_ptr + IPS_REG_NDAE);
5172
5173 /* Enable interrupts */
5174 writeb(IPS_BIT_EI, ha->mem_ptr + IPS_REG_HISR);
5175
5176 /* if we get here then everything went OK */
5177 return (1);
5178 }
5179
5180 /****************************************************************************/
5181 /* */
5182 /* Routine Name: ips_init_morpheus */
5183 /* */
5184 /* Routine Description: */
5185 /* */
5186 /* Initialize a morpheus controller */
5187 /* */
5188 /****************************************************************************/
5189 static int
5190 ips_init_morpheus(ips_ha_t * ha)
5191 {
5192 uint32_t Post;
5193 uint32_t Config;
5194 uint32_t Isr;
5195 uint32_t Oimr;
5196 int i;
5197
5198 METHOD_TRACE("ips_init_morpheus", 1);
5199
5200 /* Wait up to 45 secs for Post */
5201 for (i = 0; i < 45; i++) {
5202 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5203
5204 if (Isr & IPS_BIT_I960_MSG0I)
5205 break;
5206
5207 /* Delay for 1 Second */
5208 msleep(IPS_ONE_SEC);
5209 }
5210
5211 if (i >= 45) {
5212 /* error occurred */
5213 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5214 "timeout waiting for post.\n");
5215
5216 return (0);
5217 }
5218
5219 Post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
5220
5221 if (Post == 0x4F00) { /* If Flashing the Battery PIC */
5222 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5223 "Flashing Battery PIC, Please wait ...\n");
5224
5225 /* Clear the interrupt bit */
5226 Isr = (uint32_t) IPS_BIT_I960_MSG0I;
5227 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5228
5229 for (i = 0; i < 120; i++) { /* Wait Up to 2 Min. for Completion */
5230 Post = readl(ha->mem_ptr + IPS_REG_I960_MSG0);
5231 if (Post != 0x4F00)
5232 break;
5233 /* Delay for 1 Second */
5234 msleep(IPS_ONE_SEC);
5235 }
5236
5237 if (i >= 120) {
5238 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5239 "timeout waiting for Battery PIC Flash\n");
5240 return (0);
5241 }
5242
5243 }
5244
5245 /* Clear the interrupt bit */
5246 Isr = (uint32_t) IPS_BIT_I960_MSG0I;
5247 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5248
5249 if (Post < (IPS_GOOD_POST_STATUS << 8)) {
5250 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5251 "reset controller fails (post status %x).\n", Post);
5252
5253 return (0);
5254 }
5255
5256 /* Wait up to 240 secs for config bytes */
5257 for (i = 0; i < 240; i++) {
5258 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5259
5260 if (Isr & IPS_BIT_I960_MSG1I)
5261 break;
5262
5263 /* Delay for 1 Second */
5264 msleep(IPS_ONE_SEC);
5265 }
5266
5267 if (i >= 240) {
5268 /* error occurred */
5269 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5270 "timeout waiting for config.\n");
5271
5272 return (0);
5273 }
5274
5275 Config = readl(ha->mem_ptr + IPS_REG_I960_MSG1);
5276
5277 /* Clear interrupt bit */
5278 Isr = (uint32_t) IPS_BIT_I960_MSG1I;
5279 writel(Isr, ha->mem_ptr + IPS_REG_I2O_HIR);
5280
5281 /* Turn on the interrupts */
5282 Oimr = readl(ha->mem_ptr + IPS_REG_I960_OIMR);
5283 Oimr &= ~0x8;
5284 writel(Oimr, ha->mem_ptr + IPS_REG_I960_OIMR);
5285
5286 /* if we get here then everything went OK */
5287
5288 /* Since we did a RESET, an EraseStripeLock may be needed */
5289 if (Post == 0xEF10) {
5290 if ((Config == 0x000F) || (Config == 0x0009))
5291 ha->requires_esl = 1;
5292 }
5293
5294 return (1);
5295 }
5296
5297 /****************************************************************************/
5298 /* */
5299 /* Routine Name: ips_reset_copperhead */
5300 /* */
5301 /* Routine Description: */
5302 /* */
5303 /* Reset the controller */
5304 /* */
5305 /****************************************************************************/
5306 static int
5307 ips_reset_copperhead(ips_ha_t * ha)
5308 {
5309 int reset_counter;
5310
5311 METHOD_TRACE("ips_reset_copperhead", 1);
5312
5313 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead: io addr: %x, irq: %d",
5314 ips_name, ha->host_num, ha->io_addr, ha->irq);
5315
5316 reset_counter = 0;
5317
5318 while (reset_counter < 2) {
5319 reset_counter++;
5320
5321 outb(IPS_BIT_RST, ha->io_addr + IPS_REG_SCPR);
5322
5323 /* Delay for 1 Second */
5324 msleep(IPS_ONE_SEC);
5325
5326 outb(0, ha->io_addr + IPS_REG_SCPR);
5327
5328 /* Delay for 1 Second */
5329 msleep(IPS_ONE_SEC);
5330
5331 if ((*ha->func.init) (ha))
5332 break;
5333 else if (reset_counter >= 2) {
5334
5335 return (0);
5336 }
5337 }
5338
5339 return (1);
5340 }
5341
5342 /****************************************************************************/
5343 /* */
5344 /* Routine Name: ips_reset_copperhead_memio */
5345 /* */
5346 /* Routine Description: */
5347 /* */
5348 /* Reset the controller */
5349 /* */
5350 /****************************************************************************/
5351 static int
5352 ips_reset_copperhead_memio(ips_ha_t * ha)
5353 {
5354 int reset_counter;
5355
5356 METHOD_TRACE("ips_reset_copperhead_memio", 1);
5357
5358 DEBUG_VAR(1, "(%s%d) ips_reset_copperhead_memio: mem addr: %x, irq: %d",
5359 ips_name, ha->host_num, ha->mem_addr, ha->irq);
5360
5361 reset_counter = 0;
5362
5363 while (reset_counter < 2) {
5364 reset_counter++;
5365
5366 writeb(IPS_BIT_RST, ha->mem_ptr + IPS_REG_SCPR);
5367
5368 /* Delay for 1 Second */
5369 msleep(IPS_ONE_SEC);
5370
5371 writeb(0, ha->mem_ptr + IPS_REG_SCPR);
5372
5373 /* Delay for 1 Second */
5374 msleep(IPS_ONE_SEC);
5375
5376 if ((*ha->func.init) (ha))
5377 break;
5378 else if (reset_counter >= 2) {
5379
5380 return (0);
5381 }
5382 }
5383
5384 return (1);
5385 }
5386
5387 /****************************************************************************/
5388 /* */
5389 /* Routine Name: ips_reset_morpheus */
5390 /* */
5391 /* Routine Description: */
5392 /* */
5393 /* Reset the controller */
5394 /* */
5395 /****************************************************************************/
5396 static int
5397 ips_reset_morpheus(ips_ha_t * ha)
5398 {
5399 int reset_counter;
5400 uint8_t junk;
5401
5402 METHOD_TRACE("ips_reset_morpheus", 1);
5403
5404 DEBUG_VAR(1, "(%s%d) ips_reset_morpheus: mem addr: %x, irq: %d",
5405 ips_name, ha->host_num, ha->mem_addr, ha->irq);
5406
5407 reset_counter = 0;
5408
5409 while (reset_counter < 2) {
5410 reset_counter++;
5411
5412 writel(0x80000000, ha->mem_ptr + IPS_REG_I960_IDR);
5413
5414 /* Delay for 5 Seconds */
5415 msleep(5 * IPS_ONE_SEC);
5416
5417 /* Do a PCI config read to wait for adapter */
5418 pci_read_config_byte(ha->pcidev, 4, &junk);
5419
5420 if ((*ha->func.init) (ha))
5421 break;
5422 else if (reset_counter >= 2) {
5423
5424 return (0);
5425 }
5426 }
5427
5428 return (1);
5429 }
5430
5431 /****************************************************************************/
5432 /* */
5433 /* Routine Name: ips_statinit */
5434 /* */
5435 /* Routine Description: */
5436 /* */
5437 /* Initialize the status queues on the controller */
5438 /* */
5439 /****************************************************************************/
5440 static void
5441 ips_statinit(ips_ha_t * ha)
5442 {
5443 uint32_t phys_status_start;
5444
5445 METHOD_TRACE("ips_statinit", 1);
5446
5447 ha->adapt->p_status_start = ha->adapt->status;
5448 ha->adapt->p_status_end = ha->adapt->status + IPS_MAX_CMDS;
5449 ha->adapt->p_status_tail = ha->adapt->status;
5450
5451 phys_status_start = ha->adapt->hw_status_start;
5452 outl(cpu_to_le32(phys_status_start), ha->io_addr + IPS_REG_SQSR);
5453 outl(cpu_to_le32(phys_status_start + IPS_STATUS_Q_SIZE),
5454 ha->io_addr + IPS_REG_SQER);
5455 outl(cpu_to_le32(phys_status_start + IPS_STATUS_SIZE),
5456 ha->io_addr + IPS_REG_SQHR);
5457 outl(cpu_to_le32(phys_status_start), ha->io_addr + IPS_REG_SQTR);
5458
5459 ha->adapt->hw_status_tail = phys_status_start;
5460 }
5461
5462 /****************************************************************************/
5463 /* */
5464 /* Routine Name: ips_statinit_memio */
5465 /* */
5466 /* Routine Description: */
5467 /* */
5468 /* Initialize the status queues on the controller */
5469 /* */
5470 /****************************************************************************/
5471 static void
5472 ips_statinit_memio(ips_ha_t * ha)
5473 {
5474 uint32_t phys_status_start;
5475
5476 METHOD_TRACE("ips_statinit_memio", 1);
5477
5478 ha->adapt->p_status_start = ha->adapt->status;
5479 ha->adapt->p_status_end = ha->adapt->status + IPS_MAX_CMDS;
5480 ha->adapt->p_status_tail = ha->adapt->status;
5481
5482 phys_status_start = ha->adapt->hw_status_start;
5483 writel(phys_status_start, ha->mem_ptr + IPS_REG_SQSR);
5484 writel(phys_status_start + IPS_STATUS_Q_SIZE,
5485 ha->mem_ptr + IPS_REG_SQER);
5486 writel(phys_status_start + IPS_STATUS_SIZE, ha->mem_ptr + IPS_REG_SQHR);
5487 writel(phys_status_start, ha->mem_ptr + IPS_REG_SQTR);
5488
5489 ha->adapt->hw_status_tail = phys_status_start;
5490 }
5491
5492 /****************************************************************************/
5493 /* */
5494 /* Routine Name: ips_statupd_copperhead */
5495 /* */
5496 /* Routine Description: */
5497 /* */
5498 /* Remove an element from the status queue */
5499 /* */
5500 /****************************************************************************/
5501 static uint32_t
5502 ips_statupd_copperhead(ips_ha_t * ha)
5503 {
5504 METHOD_TRACE("ips_statupd_copperhead", 1);
5505
5506 if (ha->adapt->p_status_tail != ha->adapt->p_status_end) {
5507 ha->adapt->p_status_tail++;
5508 ha->adapt->hw_status_tail += sizeof (IPS_STATUS);
5509 } else {
5510 ha->adapt->p_status_tail = ha->adapt->p_status_start;
5511 ha->adapt->hw_status_tail = ha->adapt->hw_status_start;
5512 }
5513
5514 outl(cpu_to_le32(ha->adapt->hw_status_tail),
5515 ha->io_addr + IPS_REG_SQTR);
5516
5517 return (ha->adapt->p_status_tail->value);
5518 }
5519
5520 /****************************************************************************/
5521 /* */
5522 /* Routine Name: ips_statupd_copperhead_memio */
5523 /* */
5524 /* Routine Description: */
5525 /* */
5526 /* Remove an element from the status queue */
5527 /* */
5528 /****************************************************************************/
5529 static uint32_t
5530 ips_statupd_copperhead_memio(ips_ha_t * ha)
5531 {
5532 METHOD_TRACE("ips_statupd_copperhead_memio", 1);
5533
5534 if (ha->adapt->p_status_tail != ha->adapt->p_status_end) {
5535 ha->adapt->p_status_tail++;
5536 ha->adapt->hw_status_tail += sizeof (IPS_STATUS);
5537 } else {
5538 ha->adapt->p_status_tail = ha->adapt->p_status_start;
5539 ha->adapt->hw_status_tail = ha->adapt->hw_status_start;
5540 }
5541
5542 writel(ha->adapt->hw_status_tail, ha->mem_ptr + IPS_REG_SQTR);
5543
5544 return (ha->adapt->p_status_tail->value);
5545 }
5546
5547 /****************************************************************************/
5548 /* */
5549 /* Routine Name: ips_statupd_morpheus */
5550 /* */
5551 /* Routine Description: */
5552 /* */
5553 /* Remove an element from the status queue */
5554 /* */
5555 /****************************************************************************/
5556 static uint32_t
5557 ips_statupd_morpheus(ips_ha_t * ha)
5558 {
5559 uint32_t val;
5560
5561 METHOD_TRACE("ips_statupd_morpheus", 1);
5562
5563 val = readl(ha->mem_ptr + IPS_REG_I2O_OUTMSGQ);
5564
5565 return (val);
5566 }
5567
5568 /****************************************************************************/
5569 /* */
5570 /* Routine Name: ips_issue_copperhead */
5571 /* */
5572 /* Routine Description: */
5573 /* */
5574 /* Send a command down to the controller */
5575 /* */
5576 /****************************************************************************/
5577 static int
5578 ips_issue_copperhead(ips_ha_t * ha, ips_scb_t * scb)
5579 {
5580 uint32_t TimeOut;
5581 uint32_t val;
5582
5583 METHOD_TRACE("ips_issue_copperhead", 1);
5584
5585 if (scb->scsi_cmd) {
5586 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5587 ips_name,
5588 ha->host_num,
5589 scb->cdb[0],
5590 scb->cmd.basic_io.command_id,
5591 scb->bus, scb->target_id, scb->lun);
5592 } else {
5593 DEBUG_VAR(2, KERN_NOTICE "(%s%d) ips_issue: logical cmd id %d",
5594 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5595 }
5596
5597 TimeOut = 0;
5598
5599 while ((val =
5600 le32_to_cpu(inl(ha->io_addr + IPS_REG_CCCR))) & IPS_BIT_SEM) {
5601 udelay(1000);
5602
5603 if (++TimeOut >= IPS_SEM_TIMEOUT) {
5604 if (!(val & IPS_BIT_START_STOP))
5605 break;
5606
5607 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5608 "ips_issue val [0x%x].\n", val);
5609 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5610 "ips_issue semaphore chk timeout.\n");
5611
5612 return (IPS_FAILURE);
5613 } /* end if */
5614 } /* end while */
5615
5616 outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_CCSAR);
5617 outw(cpu_to_le32(IPS_BIT_START_CMD), ha->io_addr + IPS_REG_CCCR);
5618
5619 return (IPS_SUCCESS);
5620 }
5621
5622 /****************************************************************************/
5623 /* */
5624 /* Routine Name: ips_issue_copperhead_memio */
5625 /* */
5626 /* Routine Description: */
5627 /* */
5628 /* Send a command down to the controller */
5629 /* */
5630 /****************************************************************************/
5631 static int
5632 ips_issue_copperhead_memio(ips_ha_t * ha, ips_scb_t * scb)
5633 {
5634 uint32_t TimeOut;
5635 uint32_t val;
5636
5637 METHOD_TRACE("ips_issue_copperhead_memio", 1);
5638
5639 if (scb->scsi_cmd) {
5640 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5641 ips_name,
5642 ha->host_num,
5643 scb->cdb[0],
5644 scb->cmd.basic_io.command_id,
5645 scb->bus, scb->target_id, scb->lun);
5646 } else {
5647 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5648 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5649 }
5650
5651 TimeOut = 0;
5652
5653 while ((val = readl(ha->mem_ptr + IPS_REG_CCCR)) & IPS_BIT_SEM) {
5654 udelay(1000);
5655
5656 if (++TimeOut >= IPS_SEM_TIMEOUT) {
5657 if (!(val & IPS_BIT_START_STOP))
5658 break;
5659
5660 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5661 "ips_issue val [0x%x].\n", val);
5662 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5663 "ips_issue semaphore chk timeout.\n");
5664
5665 return (IPS_FAILURE);
5666 } /* end if */
5667 } /* end while */
5668
5669 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_CCSAR);
5670 writel(IPS_BIT_START_CMD, ha->mem_ptr + IPS_REG_CCCR);
5671
5672 return (IPS_SUCCESS);
5673 }
5674
5675 /****************************************************************************/
5676 /* */
5677 /* Routine Name: ips_issue_i2o */
5678 /* */
5679 /* Routine Description: */
5680 /* */
5681 /* Send a command down to the controller */
5682 /* */
5683 /****************************************************************************/
5684 static int
5685 ips_issue_i2o(ips_ha_t * ha, ips_scb_t * scb)
5686 {
5687
5688 METHOD_TRACE("ips_issue_i2o", 1);
5689
5690 if (scb->scsi_cmd) {
5691 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5692 ips_name,
5693 ha->host_num,
5694 scb->cdb[0],
5695 scb->cmd.basic_io.command_id,
5696 scb->bus, scb->target_id, scb->lun);
5697 } else {
5698 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5699 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5700 }
5701
5702 outl(cpu_to_le32(scb->scb_busaddr), ha->io_addr + IPS_REG_I2O_INMSGQ);
5703
5704 return (IPS_SUCCESS);
5705 }
5706
5707 /****************************************************************************/
5708 /* */
5709 /* Routine Name: ips_issue_i2o_memio */
5710 /* */
5711 /* Routine Description: */
5712 /* */
5713 /* Send a command down to the controller */
5714 /* */
5715 /****************************************************************************/
5716 static int
5717 ips_issue_i2o_memio(ips_ha_t * ha, ips_scb_t * scb)
5718 {
5719
5720 METHOD_TRACE("ips_issue_i2o_memio", 1);
5721
5722 if (scb->scsi_cmd) {
5723 DEBUG_VAR(2, "(%s%d) ips_issue: cmd 0x%X id %d (%d %d %d)",
5724 ips_name,
5725 ha->host_num,
5726 scb->cdb[0],
5727 scb->cmd.basic_io.command_id,
5728 scb->bus, scb->target_id, scb->lun);
5729 } else {
5730 DEBUG_VAR(2, "(%s%d) ips_issue: logical cmd id %d",
5731 ips_name, ha->host_num, scb->cmd.basic_io.command_id);
5732 }
5733
5734 writel(scb->scb_busaddr, ha->mem_ptr + IPS_REG_I2O_INMSGQ);
5735
5736 return (IPS_SUCCESS);
5737 }
5738
5739 /****************************************************************************/
5740 /* */
5741 /* Routine Name: ips_isintr_copperhead */
5742 /* */
5743 /* Routine Description: */
5744 /* */
5745 /* Test to see if an interrupt is for us */
5746 /* */
5747 /****************************************************************************/
5748 static int
5749 ips_isintr_copperhead(ips_ha_t * ha)
5750 {
5751 uint8_t Isr;
5752
5753 METHOD_TRACE("ips_isintr_copperhead", 2);
5754
5755 Isr = inb(ha->io_addr + IPS_REG_HISR);
5756
5757 if (Isr == 0xFF)
5758 /* ?!?! Nothing really there */
5759 return (0);
5760
5761 if (Isr & IPS_BIT_SCE)
5762 return (1);
5763 else if (Isr & (IPS_BIT_SQO | IPS_BIT_GHI)) {
5764 /* status queue overflow or GHI */
5765 /* just clear the interrupt */
5766 outb(Isr, ha->io_addr + IPS_REG_HISR);
5767 }
5768
5769 return (0);
5770 }
5771
5772 /****************************************************************************/
5773 /* */
5774 /* Routine Name: ips_isintr_copperhead_memio */
5775 /* */
5776 /* Routine Description: */
5777 /* */
5778 /* Test to see if an interrupt is for us */
5779 /* */
5780 /****************************************************************************/
5781 static int
5782 ips_isintr_copperhead_memio(ips_ha_t * ha)
5783 {
5784 uint8_t Isr;
5785
5786 METHOD_TRACE("ips_isintr_memio", 2);
5787
5788 Isr = readb(ha->mem_ptr + IPS_REG_HISR);
5789
5790 if (Isr == 0xFF)
5791 /* ?!?! Nothing really there */
5792 return (0);
5793
5794 if (Isr & IPS_BIT_SCE)
5795 return (1);
5796 else if (Isr & (IPS_BIT_SQO | IPS_BIT_GHI)) {
5797 /* status queue overflow or GHI */
5798 /* just clear the interrupt */
5799 writeb(Isr, ha->mem_ptr + IPS_REG_HISR);
5800 }
5801
5802 return (0);
5803 }
5804
5805 /****************************************************************************/
5806 /* */
5807 /* Routine Name: ips_isintr_morpheus */
5808 /* */
5809 /* Routine Description: */
5810 /* */
5811 /* Test to see if an interrupt is for us */
5812 /* */
5813 /****************************************************************************/
5814 static int
5815 ips_isintr_morpheus(ips_ha_t * ha)
5816 {
5817 uint32_t Isr;
5818
5819 METHOD_TRACE("ips_isintr_morpheus", 2);
5820
5821 Isr = readl(ha->mem_ptr + IPS_REG_I2O_HIR);
5822
5823 if (Isr & IPS_BIT_I2O_OPQI)
5824 return (1);
5825 else
5826 return (0);
5827 }
5828
5829 /****************************************************************************/
5830 /* */
5831 /* Routine Name: ips_wait */
5832 /* */
5833 /* Routine Description: */
5834 /* */
5835 /* Wait for a command to complete */
5836 /* */
5837 /****************************************************************************/
5838 static int
5839 ips_wait(ips_ha_t * ha, int time, int intr)
5840 {
5841 int ret;
5842 int done;
5843
5844 METHOD_TRACE("ips_wait", 1);
5845
5846 ret = IPS_FAILURE;
5847 done = FALSE;
5848
5849 time *= IPS_ONE_SEC; /* convert seconds */
5850
5851 while ((time > 0) && (!done)) {
5852 if (intr == IPS_INTR_ON) {
5853 if (ha->waitflag == FALSE) {
5854 ret = IPS_SUCCESS;
5855 done = TRUE;
5856 break;
5857 }
5858 } else if (intr == IPS_INTR_IORL) {
5859 if (ha->waitflag == FALSE) {
5860 /*
5861 * controller generated an interrupt to
5862 * acknowledge completion of the command
5863 * and ips_intr() has serviced the interrupt.
5864 */
5865 ret = IPS_SUCCESS;
5866 done = TRUE;
5867 break;
5868 }
5869
5870 /*
5871 * NOTE: we already have the io_request_lock so
5872 * even if we get an interrupt it won't get serviced
5873 * until after we finish.
5874 */
5875
5876 (*ha->func.intr) (ha);
5877 }
5878
5879 /* This looks like a very evil loop, but it only does this during start-up */
5880 udelay(1000);
5881 time--;
5882 }
5883
5884 return (ret);
5885 }
5886
5887 /****************************************************************************/
5888 /* */
5889 /* Routine Name: ips_write_driver_status */
5890 /* */
5891 /* Routine Description: */
5892 /* */
5893 /* Write OS/Driver version to Page 5 of the nvram on the controller */
5894 /* */
5895 /****************************************************************************/
5896 static int
5897 ips_write_driver_status(ips_ha_t * ha, int intr)
5898 {
5899 METHOD_TRACE("ips_write_driver_status", 1);
5900
5901 if (!ips_readwrite_page5(ha, FALSE, intr)) {
5902 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5903 "unable to read NVRAM page 5.\n");
5904
5905 return (0);
5906 }
5907
5908 /* check to make sure the page has a valid */
5909 /* signature */
5910 if (le32_to_cpu(ha->nvram->signature) != IPS_NVRAM_P5_SIG) {
5911 DEBUG_VAR(1,
5912 "(%s%d) NVRAM page 5 has an invalid signature: %X.",
5913 ips_name, ha->host_num, ha->nvram->signature);
5914 ha->nvram->signature = IPS_NVRAM_P5_SIG;
5915 }
5916
5917 DEBUG_VAR(2,
5918 "(%s%d) Ad Type: %d, Ad Slot: %d, BIOS: %c%c%c%c %c%c%c%c.",
5919 ips_name, ha->host_num, le16_to_cpu(ha->nvram->adapter_type),
5920 ha->nvram->adapter_slot, ha->nvram->bios_high[0],
5921 ha->nvram->bios_high[1], ha->nvram->bios_high[2],
5922 ha->nvram->bios_high[3], ha->nvram->bios_low[0],
5923 ha->nvram->bios_low[1], ha->nvram->bios_low[2],
5924 ha->nvram->bios_low[3]);
5925
5926 ips_get_bios_version(ha, intr);
5927
5928 /* change values (as needed) */
5929 ha->nvram->operating_system = IPS_OS_LINUX;
5930 ha->nvram->adapter_type = ha->ad_type;
5931 strncpy((char *) ha->nvram->driver_high, IPS_VERSION_HIGH, 4);
5932 strncpy((char *) ha->nvram->driver_low, IPS_VERSION_LOW, 4);
5933 strncpy((char *) ha->nvram->bios_high, ha->bios_version, 4);
5934 strncpy((char *) ha->nvram->bios_low, ha->bios_version + 4, 4);
5935
5936 ha->nvram->versioning = 0; /* Indicate the Driver Does Not Support Versioning */
5937
5938 /* now update the page */
5939 if (!ips_readwrite_page5(ha, TRUE, intr)) {
5940 IPS_PRINTK(KERN_WARNING, ha->pcidev,
5941 "unable to write NVRAM page 5.\n");
5942
5943 return (0);
5944 }
5945
5946 /* IF NVRAM Page 5 is OK, Use it for Slot Number Info Because Linux Doesn't Do Slots */
5947 ha->slot_num = ha->nvram->adapter_slot;
5948
5949 return (1);
5950 }
5951
5952 /****************************************************************************/
5953 /* */
5954 /* Routine Name: ips_read_adapter_status */
5955 /* */
5956 /* Routine Description: */
5957 /* */
5958 /* Do an Inquiry command to the adapter */
5959 /* */
5960 /****************************************************************************/
5961 static int
5962 ips_read_adapter_status(ips_ha_t * ha, int intr)
5963 {
5964 ips_scb_t *scb;
5965 int ret;
5966
5967 METHOD_TRACE("ips_read_adapter_status", 1);
5968
5969 scb = &ha->scbs[ha->max_cmds - 1];
5970
5971 ips_init_scb(ha, scb);
5972
5973 scb->timeout = ips_cmd_timeout;
5974 scb->cdb[0] = IPS_CMD_ENQUIRY;
5975
5976 scb->cmd.basic_io.op_code = IPS_CMD_ENQUIRY;
5977 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
5978 scb->cmd.basic_io.sg_count = 0;
5979 scb->cmd.basic_io.lba = 0;
5980 scb->cmd.basic_io.sector_count = 0;
5981 scb->cmd.basic_io.log_drv = 0;
5982 scb->data_len = sizeof (*ha->enq);
5983 scb->cmd.basic_io.sg_addr = ha->enq_busaddr;
5984
5985 /* send command */
5986 if (((ret =
5987 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
5988 || (ret == IPS_SUCCESS_IMM)
5989 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
5990 return (0);
5991
5992 return (1);
5993 }
5994
5995 /****************************************************************************/
5996 /* */
5997 /* Routine Name: ips_read_subsystem_parameters */
5998 /* */
5999 /* Routine Description: */
6000 /* */
6001 /* Read subsystem parameters from the adapter */
6002 /* */
6003 /****************************************************************************/
6004 static int
6005 ips_read_subsystem_parameters(ips_ha_t * ha, int intr)
6006 {
6007 ips_scb_t *scb;
6008 int ret;
6009
6010 METHOD_TRACE("ips_read_subsystem_parameters", 1);
6011
6012 scb = &ha->scbs[ha->max_cmds - 1];
6013
6014 ips_init_scb(ha, scb);
6015
6016 scb->timeout = ips_cmd_timeout;
6017 scb->cdb[0] = IPS_CMD_GET_SUBSYS;
6018
6019 scb->cmd.basic_io.op_code = IPS_CMD_GET_SUBSYS;
6020 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
6021 scb->cmd.basic_io.sg_count = 0;
6022 scb->cmd.basic_io.lba = 0;
6023 scb->cmd.basic_io.sector_count = 0;
6024 scb->cmd.basic_io.log_drv = 0;
6025 scb->data_len = sizeof (*ha->subsys);
6026 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
6027
6028 /* send command */
6029 if (((ret =
6030 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6031 || (ret == IPS_SUCCESS_IMM)
6032 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6033 return (0);
6034
6035 memcpy(ha->subsys, ha->ioctl_data, sizeof(*ha->subsys));
6036 return (1);
6037 }
6038
6039 /****************************************************************************/
6040 /* */
6041 /* Routine Name: ips_read_config */
6042 /* */
6043 /* Routine Description: */
6044 /* */
6045 /* Read the configuration on the adapter */
6046 /* */
6047 /****************************************************************************/
6048 static int
6049 ips_read_config(ips_ha_t * ha, int intr)
6050 {
6051 ips_scb_t *scb;
6052 int i;
6053 int ret;
6054
6055 METHOD_TRACE("ips_read_config", 1);
6056
6057 /* set defaults for initiator IDs */
6058 for (i = 0; i < 4; i++)
6059 ha->conf->init_id[i] = 7;
6060
6061 scb = &ha->scbs[ha->max_cmds - 1];
6062
6063 ips_init_scb(ha, scb);
6064
6065 scb->timeout = ips_cmd_timeout;
6066 scb->cdb[0] = IPS_CMD_READ_CONF;
6067
6068 scb->cmd.basic_io.op_code = IPS_CMD_READ_CONF;
6069 scb->cmd.basic_io.command_id = IPS_COMMAND_ID(ha, scb);
6070 scb->data_len = sizeof (*ha->conf);
6071 scb->cmd.basic_io.sg_addr = ha->ioctl_busaddr;
6072
6073 /* send command */
6074 if (((ret =
6075 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6076 || (ret == IPS_SUCCESS_IMM)
6077 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
6078
6079 memset(ha->conf, 0, sizeof (IPS_CONF));
6080
6081 /* reset initiator IDs */
6082 for (i = 0; i < 4; i++)
6083 ha->conf->init_id[i] = 7;
6084
6085 /* Allow Completed with Errors, so JCRM can access the Adapter to fix the problems */
6086 if ((scb->basic_status & IPS_GSC_STATUS_MASK) ==
6087 IPS_CMD_CMPLT_WERROR)
6088 return (1);
6089
6090 return (0);
6091 }
6092
6093 memcpy(ha->conf, ha->ioctl_data, sizeof(*ha->conf));
6094 return (1);
6095 }
6096
6097 /****************************************************************************/
6098 /* */
6099 /* Routine Name: ips_readwrite_page5 */
6100 /* */
6101 /* Routine Description: */
6102 /* */
6103 /* Read nvram page 5 from the adapter */
6104 /* */
6105 /****************************************************************************/
6106 static int
6107 ips_readwrite_page5(ips_ha_t * ha, int write, int intr)
6108 {
6109 ips_scb_t *scb;
6110 int ret;
6111
6112 METHOD_TRACE("ips_readwrite_page5", 1);
6113
6114 scb = &ha->scbs[ha->max_cmds - 1];
6115
6116 ips_init_scb(ha, scb);
6117
6118 scb->timeout = ips_cmd_timeout;
6119 scb->cdb[0] = IPS_CMD_RW_NVRAM_PAGE;
6120
6121 scb->cmd.nvram.op_code = IPS_CMD_RW_NVRAM_PAGE;
6122 scb->cmd.nvram.command_id = IPS_COMMAND_ID(ha, scb);
6123 scb->cmd.nvram.page = 5;
6124 scb->cmd.nvram.write = write;
6125 scb->cmd.nvram.reserved = 0;
6126 scb->cmd.nvram.reserved2 = 0;
6127 scb->data_len = sizeof (*ha->nvram);
6128 scb->cmd.nvram.buffer_addr = ha->ioctl_busaddr;
6129 if (write)
6130 memcpy(ha->ioctl_data, ha->nvram, sizeof(*ha->nvram));
6131
6132 /* issue the command */
6133 if (((ret =
6134 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6135 || (ret == IPS_SUCCESS_IMM)
6136 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1)) {
6137
6138 memset(ha->nvram, 0, sizeof (IPS_NVRAM_P5));
6139
6140 return (0);
6141 }
6142 if (!write)
6143 memcpy(ha->nvram, ha->ioctl_data, sizeof(*ha->nvram));
6144 return (1);
6145 }
6146
6147 /****************************************************************************/
6148 /* */
6149 /* Routine Name: ips_clear_adapter */
6150 /* */
6151 /* Routine Description: */
6152 /* */
6153 /* Clear the stripe lock tables */
6154 /* */
6155 /****************************************************************************/
6156 static int
6157 ips_clear_adapter(ips_ha_t * ha, int intr)
6158 {
6159 ips_scb_t *scb;
6160 int ret;
6161
6162 METHOD_TRACE("ips_clear_adapter", 1);
6163
6164 scb = &ha->scbs[ha->max_cmds - 1];
6165
6166 ips_init_scb(ha, scb);
6167
6168 scb->timeout = ips_reset_timeout;
6169 scb->cdb[0] = IPS_CMD_CONFIG_SYNC;
6170
6171 scb->cmd.config_sync.op_code = IPS_CMD_CONFIG_SYNC;
6172 scb->cmd.config_sync.command_id = IPS_COMMAND_ID(ha, scb);
6173 scb->cmd.config_sync.channel = 0;
6174 scb->cmd.config_sync.source_target = IPS_POCL;
6175 scb->cmd.config_sync.reserved = 0;
6176 scb->cmd.config_sync.reserved2 = 0;
6177 scb->cmd.config_sync.reserved3 = 0;
6178
6179 /* issue command */
6180 if (((ret =
6181 ips_send_wait(ha, scb, ips_reset_timeout, intr)) == IPS_FAILURE)
6182 || (ret == IPS_SUCCESS_IMM)
6183 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6184 return (0);
6185
6186 /* send unlock stripe command */
6187 ips_init_scb(ha, scb);
6188
6189 scb->cdb[0] = IPS_CMD_ERROR_TABLE;
6190 scb->timeout = ips_reset_timeout;
6191
6192 scb->cmd.unlock_stripe.op_code = IPS_CMD_ERROR_TABLE;
6193 scb->cmd.unlock_stripe.command_id = IPS_COMMAND_ID(ha, scb);
6194 scb->cmd.unlock_stripe.log_drv = 0;
6195 scb->cmd.unlock_stripe.control = IPS_CSL;
6196 scb->cmd.unlock_stripe.reserved = 0;
6197 scb->cmd.unlock_stripe.reserved2 = 0;
6198 scb->cmd.unlock_stripe.reserved3 = 0;
6199
6200 /* issue command */
6201 if (((ret =
6202 ips_send_wait(ha, scb, ips_cmd_timeout, intr)) == IPS_FAILURE)
6203 || (ret == IPS_SUCCESS_IMM)
6204 || ((scb->basic_status & IPS_GSC_STATUS_MASK) > 1))
6205 return (0);
6206
6207 return (1);
6208 }
6209
6210 /****************************************************************************/
6211 /* */
6212 /* Routine Name: ips_ffdc_reset */
6213 /* */
6214 /* Routine Description: */
6215 /* */
6216 /* FFDC: write reset info */
6217 /* */
6218 /****************************************************************************/
6219 static void
6220 ips_ffdc_reset(ips_ha_t * ha, int intr)
6221 {
6222 ips_scb_t *scb;
6223
6224 METHOD_TRACE("ips_ffdc_reset", 1);
6225
6226 scb = &ha->scbs[ha->max_cmds - 1];
6227
6228 ips_init_scb(ha, scb);
6229
6230 scb->timeout = ips_cmd_timeout;
6231 scb->cdb[0] = IPS_CMD_FFDC;
6232 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
6233 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
6234 scb->cmd.ffdc.reset_count = ha->reset_count;
6235 scb->cmd.ffdc.reset_type = 0x80;
6236
6237 /* convert time to what the card wants */
6238 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
6239
6240 /* issue command */
6241 ips_send_wait(ha, scb, ips_cmd_timeout, intr);
6242 }
6243
6244 /****************************************************************************/
6245 /* */
6246 /* Routine Name: ips_ffdc_time */
6247 /* */
6248 /* Routine Description: */
6249 /* */
6250 /* FFDC: write time info */
6251 /* */
6252 /****************************************************************************/
6253 static void
6254 ips_ffdc_time(ips_ha_t * ha)
6255 {
6256 ips_scb_t *scb;
6257
6258 METHOD_TRACE("ips_ffdc_time", 1);
6259
6260 DEBUG_VAR(1, "(%s%d) Sending time update.", ips_name, ha->host_num);
6261
6262 scb = &ha->scbs[ha->max_cmds - 1];
6263
6264 ips_init_scb(ha, scb);
6265
6266 scb->timeout = ips_cmd_timeout;
6267 scb->cdb[0] = IPS_CMD_FFDC;
6268 scb->cmd.ffdc.op_code = IPS_CMD_FFDC;
6269 scb->cmd.ffdc.command_id = IPS_COMMAND_ID(ha, scb);
6270 scb->cmd.ffdc.reset_count = 0;
6271 scb->cmd.ffdc.reset_type = 0;
6272
6273 /* convert time to what the card wants */
6274 ips_fix_ffdc_time(ha, scb, ha->last_ffdc);
6275
6276 /* issue command */
6277 ips_send_wait(ha, scb, ips_cmd_timeout, IPS_FFDC);
6278 }
6279
6280 /****************************************************************************/
6281 /* */
6282 /* Routine Name: ips_fix_ffdc_time */
6283 /* */
6284 /* Routine Description: */
6285 /* Adjust time_t to what the card wants */
6286 /* */
6287 /****************************************************************************/
6288 static void
6289 ips_fix_ffdc_time(ips_ha_t * ha, ips_scb_t * scb, time_t current_time)
6290 {
6291 long days;
6292 long rem;
6293 int i;
6294 int year;
6295 int yleap;
6296 int year_lengths[2] = { IPS_DAYS_NORMAL_YEAR, IPS_DAYS_LEAP_YEAR };
6297 int month_lengths[12][2] = { {31, 31},
6298 {28, 29},
6299 {31, 31},
6300 {30, 30},
6301 {31, 31},
6302 {30, 30},
6303 {31, 31},
6304 {31, 31},
6305 {30, 30},
6306 {31, 31},
6307 {30, 30},
6308 {31, 31}
6309 };
6310
6311 METHOD_TRACE("ips_fix_ffdc_time", 1);
6312
6313 days = current_time / IPS_SECS_DAY;
6314 rem = current_time % IPS_SECS_DAY;
6315
6316 scb->cmd.ffdc.hour = (rem / IPS_SECS_HOUR);
6317 rem = rem % IPS_SECS_HOUR;
6318 scb->cmd.ffdc.minute = (rem / IPS_SECS_MIN);
6319 scb->cmd.ffdc.second = (rem % IPS_SECS_MIN);
6320
6321 year = IPS_EPOCH_YEAR;
6322 while (days < 0 || days >= year_lengths[yleap = IPS_IS_LEAP_YEAR(year)]) {
6323 int newy;
6324
6325 newy = year + (days / IPS_DAYS_NORMAL_YEAR);
6326 if (days < 0)
6327 --newy;
6328 days -= (newy - year) * IPS_DAYS_NORMAL_YEAR +
6329 IPS_NUM_LEAP_YEARS_THROUGH(newy - 1) -
6330 IPS_NUM_LEAP_YEARS_THROUGH(year - 1);
6331 year = newy;
6332 }
6333
6334 scb->cmd.ffdc.yearH = year / 100;
6335 scb->cmd.ffdc.yearL = year % 100;
6336
6337 for (i = 0; days >= month_lengths[i][yleap]; ++i)
6338 days -= month_lengths[i][yleap];
6339
6340 scb->cmd.ffdc.month = i + 1;
6341 scb->cmd.ffdc.day = days + 1;
6342 }
6343
6344 /****************************************************************************
6345 * BIOS Flash Routines *
6346 ****************************************************************************/
6347
6348 /****************************************************************************/
6349 /* */
6350 /* Routine Name: ips_erase_bios */
6351 /* */
6352 /* Routine Description: */
6353 /* Erase the BIOS on the adapter */
6354 /* */
6355 /****************************************************************************/
6356 static int
6357 ips_erase_bios(ips_ha_t * ha)
6358 {
6359 int timeout;
6360 uint8_t status = 0;
6361
6362 METHOD_TRACE("ips_erase_bios", 1);
6363
6364 status = 0;
6365
6366 /* Clear the status register */
6367 outl(0, ha->io_addr + IPS_REG_FLAP);
6368 if (ha->revision_id == IPS_REVID_TROMBONE64)
6369 udelay(25); /* 25 us */
6370
6371 outb(0x50, ha->io_addr + IPS_REG_FLDP);
6372 if (ha->revision_id == IPS_REVID_TROMBONE64)
6373 udelay(25); /* 25 us */
6374
6375 /* Erase Setup */
6376 outb(0x20, ha->io_addr + IPS_REG_FLDP);
6377 if (ha->revision_id == IPS_REVID_TROMBONE64)
6378 udelay(25); /* 25 us */
6379
6380 /* Erase Confirm */
6381 outb(0xD0, ha->io_addr + IPS_REG_FLDP);
6382 if (ha->revision_id == IPS_REVID_TROMBONE64)
6383 udelay(25); /* 25 us */
6384
6385 /* Erase Status */
6386 outb(0x70, ha->io_addr + IPS_REG_FLDP);
6387 if (ha->revision_id == IPS_REVID_TROMBONE64)
6388 udelay(25); /* 25 us */
6389
6390 timeout = 80000; /* 80 seconds */
6391
6392 while (timeout > 0) {
6393 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6394 outl(0, ha->io_addr + IPS_REG_FLAP);
6395 udelay(25); /* 25 us */
6396 }
6397
6398 status = inb(ha->io_addr + IPS_REG_FLDP);
6399
6400 if (status & 0x80)
6401 break;
6402
6403 MDELAY(1);
6404 timeout--;
6405 }
6406
6407 /* check for timeout */
6408 if (timeout <= 0) {
6409 /* timeout */
6410
6411 /* try to suspend the erase */
6412 outb(0xB0, ha->io_addr + IPS_REG_FLDP);
6413 if (ha->revision_id == IPS_REVID_TROMBONE64)
6414 udelay(25); /* 25 us */
6415
6416 /* wait for 10 seconds */
6417 timeout = 10000;
6418 while (timeout > 0) {
6419 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6420 outl(0, ha->io_addr + IPS_REG_FLAP);
6421 udelay(25); /* 25 us */
6422 }
6423
6424 status = inb(ha->io_addr + IPS_REG_FLDP);
6425
6426 if (status & 0xC0)
6427 break;
6428
6429 MDELAY(1);
6430 timeout--;
6431 }
6432
6433 return (1);
6434 }
6435
6436 /* check for valid VPP */
6437 if (status & 0x08)
6438 /* VPP failure */
6439 return (1);
6440
6441 /* check for succesful flash */
6442 if (status & 0x30)
6443 /* sequence error */
6444 return (1);
6445
6446 /* Otherwise, we were successful */
6447 /* clear status */
6448 outb(0x50, ha->io_addr + IPS_REG_FLDP);
6449 if (ha->revision_id == IPS_REVID_TROMBONE64)
6450 udelay(25); /* 25 us */
6451
6452 /* enable reads */
6453 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6454 if (ha->revision_id == IPS_REVID_TROMBONE64)
6455 udelay(25); /* 25 us */
6456
6457 return (0);
6458 }
6459
6460 /****************************************************************************/
6461 /* */
6462 /* Routine Name: ips_erase_bios_memio */
6463 /* */
6464 /* Routine Description: */
6465 /* Erase the BIOS on the adapter */
6466 /* */
6467 /****************************************************************************/
6468 static int
6469 ips_erase_bios_memio(ips_ha_t * ha)
6470 {
6471 int timeout;
6472 uint8_t status;
6473
6474 METHOD_TRACE("ips_erase_bios_memio", 1);
6475
6476 status = 0;
6477
6478 /* Clear the status register */
6479 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6480 if (ha->revision_id == IPS_REVID_TROMBONE64)
6481 udelay(25); /* 25 us */
6482
6483 writeb(0x50, ha->mem_ptr + IPS_REG_FLDP);
6484 if (ha->revision_id == IPS_REVID_TROMBONE64)
6485 udelay(25); /* 25 us */
6486
6487 /* Erase Setup */
6488 writeb(0x20, ha->mem_ptr + IPS_REG_FLDP);
6489 if (ha->revision_id == IPS_REVID_TROMBONE64)
6490 udelay(25); /* 25 us */
6491
6492 /* Erase Confirm */
6493 writeb(0xD0, ha->mem_ptr + IPS_REG_FLDP);
6494 if (ha->revision_id == IPS_REVID_TROMBONE64)
6495 udelay(25); /* 25 us */
6496
6497 /* Erase Status */
6498 writeb(0x70, ha->mem_ptr + IPS_REG_FLDP);
6499 if (ha->revision_id == IPS_REVID_TROMBONE64)
6500 udelay(25); /* 25 us */
6501
6502 timeout = 80000; /* 80 seconds */
6503
6504 while (timeout > 0) {
6505 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6506 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6507 udelay(25); /* 25 us */
6508 }
6509
6510 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6511
6512 if (status & 0x80)
6513 break;
6514
6515 MDELAY(1);
6516 timeout--;
6517 }
6518
6519 /* check for timeout */
6520 if (timeout <= 0) {
6521 /* timeout */
6522
6523 /* try to suspend the erase */
6524 writeb(0xB0, ha->mem_ptr + IPS_REG_FLDP);
6525 if (ha->revision_id == IPS_REVID_TROMBONE64)
6526 udelay(25); /* 25 us */
6527
6528 /* wait for 10 seconds */
6529 timeout = 10000;
6530 while (timeout > 0) {
6531 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6532 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6533 udelay(25); /* 25 us */
6534 }
6535
6536 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6537
6538 if (status & 0xC0)
6539 break;
6540
6541 MDELAY(1);
6542 timeout--;
6543 }
6544
6545 return (1);
6546 }
6547
6548 /* check for valid VPP */
6549 if (status & 0x08)
6550 /* VPP failure */
6551 return (1);
6552
6553 /* check for succesful flash */
6554 if (status & 0x30)
6555 /* sequence error */
6556 return (1);
6557
6558 /* Otherwise, we were successful */
6559 /* clear status */
6560 writeb(0x50, ha->mem_ptr + IPS_REG_FLDP);
6561 if (ha->revision_id == IPS_REVID_TROMBONE64)
6562 udelay(25); /* 25 us */
6563
6564 /* enable reads */
6565 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6566 if (ha->revision_id == IPS_REVID_TROMBONE64)
6567 udelay(25); /* 25 us */
6568
6569 return (0);
6570 }
6571
6572 /****************************************************************************/
6573 /* */
6574 /* Routine Name: ips_program_bios */
6575 /* */
6576 /* Routine Description: */
6577 /* Program the BIOS on the adapter */
6578 /* */
6579 /****************************************************************************/
6580 static int
6581 ips_program_bios(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6582 uint32_t offset)
6583 {
6584 int i;
6585 int timeout;
6586 uint8_t status = 0;
6587
6588 METHOD_TRACE("ips_program_bios", 1);
6589
6590 status = 0;
6591
6592 for (i = 0; i < buffersize; i++) {
6593 /* write a byte */
6594 outl(cpu_to_le32(i + offset), ha->io_addr + IPS_REG_FLAP);
6595 if (ha->revision_id == IPS_REVID_TROMBONE64)
6596 udelay(25); /* 25 us */
6597
6598 outb(0x40, ha->io_addr + IPS_REG_FLDP);
6599 if (ha->revision_id == IPS_REVID_TROMBONE64)
6600 udelay(25); /* 25 us */
6601
6602 outb(buffer[i], ha->io_addr + IPS_REG_FLDP);
6603 if (ha->revision_id == IPS_REVID_TROMBONE64)
6604 udelay(25); /* 25 us */
6605
6606 /* wait up to one second */
6607 timeout = 1000;
6608 while (timeout > 0) {
6609 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6610 outl(0, ha->io_addr + IPS_REG_FLAP);
6611 udelay(25); /* 25 us */
6612 }
6613
6614 status = inb(ha->io_addr + IPS_REG_FLDP);
6615
6616 if (status & 0x80)
6617 break;
6618
6619 MDELAY(1);
6620 timeout--;
6621 }
6622
6623 if (timeout == 0) {
6624 /* timeout error */
6625 outl(0, ha->io_addr + IPS_REG_FLAP);
6626 if (ha->revision_id == IPS_REVID_TROMBONE64)
6627 udelay(25); /* 25 us */
6628
6629 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6630 if (ha->revision_id == IPS_REVID_TROMBONE64)
6631 udelay(25); /* 25 us */
6632
6633 return (1);
6634 }
6635
6636 /* check the status */
6637 if (status & 0x18) {
6638 /* programming error */
6639 outl(0, ha->io_addr + IPS_REG_FLAP);
6640 if (ha->revision_id == IPS_REVID_TROMBONE64)
6641 udelay(25); /* 25 us */
6642
6643 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6644 if (ha->revision_id == IPS_REVID_TROMBONE64)
6645 udelay(25); /* 25 us */
6646
6647 return (1);
6648 }
6649 } /* end for */
6650
6651 /* Enable reading */
6652 outl(0, ha->io_addr + IPS_REG_FLAP);
6653 if (ha->revision_id == IPS_REVID_TROMBONE64)
6654 udelay(25); /* 25 us */
6655
6656 outb(0xFF, ha->io_addr + IPS_REG_FLDP);
6657 if (ha->revision_id == IPS_REVID_TROMBONE64)
6658 udelay(25); /* 25 us */
6659
6660 return (0);
6661 }
6662
6663 /****************************************************************************/
6664 /* */
6665 /* Routine Name: ips_program_bios_memio */
6666 /* */
6667 /* Routine Description: */
6668 /* Program the BIOS on the adapter */
6669 /* */
6670 /****************************************************************************/
6671 static int
6672 ips_program_bios_memio(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6673 uint32_t offset)
6674 {
6675 int i;
6676 int timeout;
6677 uint8_t status = 0;
6678
6679 METHOD_TRACE("ips_program_bios_memio", 1);
6680
6681 status = 0;
6682
6683 for (i = 0; i < buffersize; i++) {
6684 /* write a byte */
6685 writel(i + offset, ha->mem_ptr + IPS_REG_FLAP);
6686 if (ha->revision_id == IPS_REVID_TROMBONE64)
6687 udelay(25); /* 25 us */
6688
6689 writeb(0x40, ha->mem_ptr + IPS_REG_FLDP);
6690 if (ha->revision_id == IPS_REVID_TROMBONE64)
6691 udelay(25); /* 25 us */
6692
6693 writeb(buffer[i], ha->mem_ptr + IPS_REG_FLDP);
6694 if (ha->revision_id == IPS_REVID_TROMBONE64)
6695 udelay(25); /* 25 us */
6696
6697 /* wait up to one second */
6698 timeout = 1000;
6699 while (timeout > 0) {
6700 if (ha->revision_id == IPS_REVID_TROMBONE64) {
6701 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6702 udelay(25); /* 25 us */
6703 }
6704
6705 status = readb(ha->mem_ptr + IPS_REG_FLDP);
6706
6707 if (status & 0x80)
6708 break;
6709
6710 MDELAY(1);
6711 timeout--;
6712 }
6713
6714 if (timeout == 0) {
6715 /* timeout error */
6716 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6717 if (ha->revision_id == IPS_REVID_TROMBONE64)
6718 udelay(25); /* 25 us */
6719
6720 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6721 if (ha->revision_id == IPS_REVID_TROMBONE64)
6722 udelay(25); /* 25 us */
6723
6724 return (1);
6725 }
6726
6727 /* check the status */
6728 if (status & 0x18) {
6729 /* programming error */
6730 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6731 if (ha->revision_id == IPS_REVID_TROMBONE64)
6732 udelay(25); /* 25 us */
6733
6734 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6735 if (ha->revision_id == IPS_REVID_TROMBONE64)
6736 udelay(25); /* 25 us */
6737
6738 return (1);
6739 }
6740 } /* end for */
6741
6742 /* Enable reading */
6743 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6744 if (ha->revision_id == IPS_REVID_TROMBONE64)
6745 udelay(25); /* 25 us */
6746
6747 writeb(0xFF, ha->mem_ptr + IPS_REG_FLDP);
6748 if (ha->revision_id == IPS_REVID_TROMBONE64)
6749 udelay(25); /* 25 us */
6750
6751 return (0);
6752 }
6753
6754 /****************************************************************************/
6755 /* */
6756 /* Routine Name: ips_verify_bios */
6757 /* */
6758 /* Routine Description: */
6759 /* Verify the BIOS on the adapter */
6760 /* */
6761 /****************************************************************************/
6762 static int
6763 ips_verify_bios(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6764 uint32_t offset)
6765 {
6766 uint8_t checksum;
6767 int i;
6768
6769 METHOD_TRACE("ips_verify_bios", 1);
6770
6771 /* test 1st byte */
6772 outl(0, ha->io_addr + IPS_REG_FLAP);
6773 if (ha->revision_id == IPS_REVID_TROMBONE64)
6774 udelay(25); /* 25 us */
6775
6776 if (inb(ha->io_addr + IPS_REG_FLDP) != 0x55)
6777 return (1);
6778
6779 outl(cpu_to_le32(1), ha->io_addr + IPS_REG_FLAP);
6780 if (ha->revision_id == IPS_REVID_TROMBONE64)
6781 udelay(25); /* 25 us */
6782 if (inb(ha->io_addr + IPS_REG_FLDP) != 0xAA)
6783 return (1);
6784
6785 checksum = 0xff;
6786 for (i = 2; i < buffersize; i++) {
6787
6788 outl(cpu_to_le32(i + offset), ha->io_addr + IPS_REG_FLAP);
6789 if (ha->revision_id == IPS_REVID_TROMBONE64)
6790 udelay(25); /* 25 us */
6791
6792 checksum = (uint8_t) checksum + inb(ha->io_addr + IPS_REG_FLDP);
6793 }
6794
6795 if (checksum != 0)
6796 /* failure */
6797 return (1);
6798 else
6799 /* success */
6800 return (0);
6801 }
6802
6803 /****************************************************************************/
6804 /* */
6805 /* Routine Name: ips_verify_bios_memio */
6806 /* */
6807 /* Routine Description: */
6808 /* Verify the BIOS on the adapter */
6809 /* */
6810 /****************************************************************************/
6811 static int
6812 ips_verify_bios_memio(ips_ha_t * ha, char *buffer, uint32_t buffersize,
6813 uint32_t offset)
6814 {
6815 uint8_t checksum;
6816 int i;
6817
6818 METHOD_TRACE("ips_verify_bios_memio", 1);
6819
6820 /* test 1st byte */
6821 writel(0, ha->mem_ptr + IPS_REG_FLAP);
6822 if (ha->revision_id == IPS_REVID_TROMBONE64)
6823 udelay(25); /* 25 us */
6824
6825 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0x55)
6826 return (1);
6827
6828 writel(1, ha->mem_ptr + IPS_REG_FLAP);
6829 if (ha->revision_id == IPS_REVID_TROMBONE64)
6830 udelay(25); /* 25 us */
6831 if (readb(ha->mem_ptr + IPS_REG_FLDP) != 0xAA)
6832 return (1);
6833
6834 checksum = 0xff;
6835 for (i = 2; i < buffersize; i++) {
6836
6837 writel(i + offset, ha->mem_ptr + IPS_REG_FLAP);
6838 if (ha->revision_id == IPS_REVID_TROMBONE64)
6839 udelay(25); /* 25 us */
6840
6841 checksum =
6842 (uint8_t) checksum + readb(ha->mem_ptr + IPS_REG_FLDP);
6843 }
6844
6845 if (checksum != 0)
6846 /* failure */
6847 return (1);
6848 else
6849 /* success */
6850 return (0);
6851 }
6852
6853 /****************************************************************************/
6854 /* */
6855 /* Routine Name: ips_abort_init */
6856 /* */
6857 /* Routine Description: */
6858 /* cleanup routine for a failed adapter initialization */
6859 /****************************************************************************/
6860 static int
6861 ips_abort_init(ips_ha_t * ha, int index)
6862 {
6863 ha->active = 0;
6864 ips_free(ha);
6865 ips_ha[index] = NULL;
6866 ips_sh[index] = NULL;
6867 return -1;
6868 }
6869
6870 /****************************************************************************/
6871 /* */
6872 /* Routine Name: ips_shift_controllers */
6873 /* */
6874 /* Routine Description: */
6875 /* helper function for ordering adapters */
6876 /****************************************************************************/
6877 static void
6878 ips_shift_controllers(int lowindex, int highindex)
6879 {
6880 ips_ha_t *ha_sav = ips_ha[highindex];
6881 struct Scsi_Host *sh_sav = ips_sh[highindex];
6882 int i;
6883
6884 for (i = highindex; i > lowindex; i--) {
6885 ips_ha[i] = ips_ha[i - 1];
6886 ips_sh[i] = ips_sh[i - 1];
6887 ips_ha[i]->host_num = i;
6888 }
6889 ha_sav->host_num = lowindex;
6890 ips_ha[lowindex] = ha_sav;
6891 ips_sh[lowindex] = sh_sav;
6892 }
6893
6894 /****************************************************************************/
6895 /* */
6896 /* Routine Name: ips_order_controllers */
6897 /* */
6898 /* Routine Description: */
6899 /* place controllers is the "proper" boot order */
6900 /****************************************************************************/
6901 static void
6902 ips_order_controllers(void)
6903 {
6904 int i, j, tmp, position = 0;
6905 IPS_NVRAM_P5 *nvram;
6906 if (!ips_ha[0])
6907 return;
6908 nvram = ips_ha[0]->nvram;
6909
6910 if (nvram->adapter_order[0]) {
6911 for (i = 1; i <= nvram->adapter_order[0]; i++) {
6912 for (j = position; j < ips_num_controllers; j++) {
6913 switch (ips_ha[j]->ad_type) {
6914 case IPS_ADTYPE_SERVERAID6M:
6915 case IPS_ADTYPE_SERVERAID7M:
6916 if (nvram->adapter_order[i] == 'M') {
6917 ips_shift_controllers(position,
6918 j);
6919 position++;
6920 }
6921 break;
6922 case IPS_ADTYPE_SERVERAID4L:
6923 case IPS_ADTYPE_SERVERAID4M:
6924 case IPS_ADTYPE_SERVERAID4MX:
6925 case IPS_ADTYPE_SERVERAID4LX:
6926 if (nvram->adapter_order[i] == 'N') {
6927 ips_shift_controllers(position,
6928 j);
6929 position++;
6930 }
6931 break;
6932 case IPS_ADTYPE_SERVERAID6I:
6933 case IPS_ADTYPE_SERVERAID5I2:
6934 case IPS_ADTYPE_SERVERAID5I1:
6935 case IPS_ADTYPE_SERVERAID7k:
6936 if (nvram->adapter_order[i] == 'S') {
6937 ips_shift_controllers(position,
6938 j);
6939 position++;
6940 }
6941 break;
6942 case IPS_ADTYPE_SERVERAID:
6943 case IPS_ADTYPE_SERVERAID2:
6944 case IPS_ADTYPE_NAVAJO:
6945 case IPS_ADTYPE_KIOWA:
6946 case IPS_ADTYPE_SERVERAID3L:
6947 case IPS_ADTYPE_SERVERAID3:
6948 case IPS_ADTYPE_SERVERAID4H:
6949 if (nvram->adapter_order[i] == 'A') {
6950 ips_shift_controllers(position,
6951 j);
6952 position++;
6953 }
6954 break;
6955 default:
6956 break;
6957 }
6958 }
6959 }
6960 /* if adapter_order[0], then ordering is complete */
6961 return;
6962 }
6963 /* old bios, use older ordering */
6964 tmp = 0;
6965 for (i = position; i < ips_num_controllers; i++) {
6966 if (ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID5I2 ||
6967 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID5I1) {
6968 ips_shift_controllers(position, i);
6969 position++;
6970 tmp = 1;
6971 }
6972 }
6973 /* if there were no 5I cards, then don't do any extra ordering */
6974 if (!tmp)
6975 return;
6976 for (i = position; i < ips_num_controllers; i++) {
6977 if (ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4L ||
6978 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4M ||
6979 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4LX ||
6980 ips_ha[i]->ad_type == IPS_ADTYPE_SERVERAID4MX) {
6981 ips_shift_controllers(position, i);
6982 position++;
6983 }
6984 }
6985
6986 return;
6987 }
6988
6989 /****************************************************************************/
6990 /* */
6991 /* Routine Name: ips_register_scsi */
6992 /* */
6993 /* Routine Description: */
6994 /* perform any registration and setup with the scsi layer */
6995 /****************************************************************************/
6996 static int
6997 ips_register_scsi(int index)
6998 {
6999 struct Scsi_Host *sh;
7000 ips_ha_t *ha, *oldha = ips_ha[index];
7001 sh = scsi_host_alloc(&ips_driver_template, sizeof (ips_ha_t));
7002 if (!sh) {
7003 IPS_PRINTK(KERN_WARNING, oldha->pcidev,
7004 "Unable to register controller with SCSI subsystem\n");
7005 return -1;
7006 }
7007 ha = IPS_HA(sh);
7008 memcpy(ha, oldha, sizeof (ips_ha_t));
7009 free_irq(oldha->irq, oldha);
7010 /* Install the interrupt handler with the new ha */
7011 if (request_irq(ha->irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
7012 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7013 "Unable to install interrupt handler\n");
7014 scsi_host_put(sh);
7015 return -1;
7016 }
7017
7018 kfree(oldha);
7019 ips_sh[index] = sh;
7020 ips_ha[index] = ha;
7021 IPS_SCSI_SET_DEVICE(sh, ha);
7022
7023 /* Store away needed values for later use */
7024 sh->io_port = ha->io_addr;
7025 sh->n_io_port = ha->io_addr ? 255 : 0;
7026 sh->unique_id = (ha->io_addr) ? ha->io_addr : ha->mem_addr;
7027 sh->irq = ha->irq;
7028 sh->sg_tablesize = sh->hostt->sg_tablesize;
7029 sh->can_queue = sh->hostt->can_queue;
7030 sh->cmd_per_lun = sh->hostt->cmd_per_lun;
7031 sh->unchecked_isa_dma = sh->hostt->unchecked_isa_dma;
7032 sh->use_clustering = sh->hostt->use_clustering;
7033
7034 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,7)
7035 sh->max_sectors = 128;
7036 #endif
7037
7038 sh->max_id = ha->ntargets;
7039 sh->max_lun = ha->nlun;
7040 sh->max_channel = ha->nbus - 1;
7041 sh->can_queue = ha->max_cmds - 1;
7042
7043 IPS_ADD_HOST(sh, NULL);
7044 return 0;
7045 }
7046
7047 /*---------------------------------------------------------------------------*/
7048 /* Routine Name: ips_remove_device */
7049 /* */
7050 /* Routine Description: */
7051 /* Remove one Adapter ( Hot Plugging ) */
7052 /*---------------------------------------------------------------------------*/
7053 static void __devexit
7054 ips_remove_device(struct pci_dev *pci_dev)
7055 {
7056 int i;
7057 struct Scsi_Host *sh;
7058 ips_ha_t *ha;
7059
7060 for (i = 0; i < IPS_MAX_ADAPTERS; i++) {
7061 ha = ips_ha[i];
7062 if (ha) {
7063 if ((pci_dev->bus->number == ha->pcidev->bus->number) &&
7064 (pci_dev->devfn == ha->pcidev->devfn)) {
7065 sh = ips_sh[i];
7066 ips_release(sh);
7067 }
7068 }
7069 }
7070 }
7071
7072 /****************************************************************************/
7073 /* */
7074 /* Routine Name: ips_module_init */
7075 /* */
7076 /* Routine Description: */
7077 /* function called on module load */
7078 /****************************************************************************/
7079 static int __init
7080 ips_module_init(void)
7081 {
7082 if (pci_module_init(&ips_pci_driver) < 0)
7083 return -ENODEV;
7084 ips_driver_template.module = THIS_MODULE;
7085 ips_order_controllers();
7086 if (IPS_REGISTER_HOSTS(&ips_driver_template)) {
7087 pci_unregister_driver(&ips_pci_driver);
7088 return -ENODEV;
7089 }
7090 register_reboot_notifier(&ips_notifier);
7091 return 0;
7092 }
7093
7094 /****************************************************************************/
7095 /* */
7096 /* Routine Name: ips_module_exit */
7097 /* */
7098 /* Routine Description: */
7099 /* function called on module unload */
7100 /****************************************************************************/
7101 static void __exit
7102 ips_module_exit(void)
7103 {
7104 IPS_UNREGISTER_HOSTS(&ips_driver_template);
7105 pci_unregister_driver(&ips_pci_driver);
7106 unregister_reboot_notifier(&ips_notifier);
7107 }
7108
7109 module_init(ips_module_init);
7110 module_exit(ips_module_exit);
7111
7112 /*---------------------------------------------------------------------------*/
7113 /* Routine Name: ips_insert_device */
7114 /* */
7115 /* Routine Description: */
7116 /* Add One Adapter ( Hot Plug ) */
7117 /* */
7118 /* Return Value: */
7119 /* 0 if Successful, else non-zero */
7120 /*---------------------------------------------------------------------------*/
7121 static int __devinit
7122 ips_insert_device(struct pci_dev *pci_dev, const struct pci_device_id *ent)
7123 {
7124 int index;
7125 int rc;
7126
7127 METHOD_TRACE("ips_insert_device", 1);
7128 if (pci_enable_device(pci_dev))
7129 return -1;
7130
7131 rc = ips_init_phase1(pci_dev, &index);
7132 if (rc == SUCCESS)
7133 rc = ips_init_phase2(index);
7134
7135 if (ips_hotplug)
7136 if (ips_register_scsi(index)) {
7137 ips_free(ips_ha[index]);
7138 rc = -1;
7139 }
7140
7141 if (rc == SUCCESS)
7142 ips_num_controllers++;
7143
7144 ips_next_controller = ips_num_controllers;
7145 return rc;
7146 }
7147
7148 /*---------------------------------------------------------------------------*/
7149 /* Routine Name: ips_init_phase1 */
7150 /* */
7151 /* Routine Description: */
7152 /* Adapter Initialization */
7153 /* */
7154 /* Return Value: */
7155 /* 0 if Successful, else non-zero */
7156 /*---------------------------------------------------------------------------*/
7157 static int
7158 ips_init_phase1(struct pci_dev *pci_dev, int *indexPtr)
7159 {
7160 ips_ha_t *ha;
7161 uint32_t io_addr;
7162 uint32_t mem_addr;
7163 uint32_t io_len;
7164 uint32_t mem_len;
7165 uint8_t revision_id;
7166 uint8_t bus;
7167 uint8_t func;
7168 uint8_t irq;
7169 uint16_t subdevice_id;
7170 int j;
7171 int index;
7172 dma_addr_t dma_address;
7173 char __iomem *ioremap_ptr;
7174 char __iomem *mem_ptr;
7175 uint32_t IsDead;
7176
7177 METHOD_TRACE("ips_init_phase1", 1);
7178 index = IPS_MAX_ADAPTERS;
7179 for (j = 0; j < IPS_MAX_ADAPTERS; j++) {
7180 if (ips_ha[j] == 0) {
7181 index = j;
7182 break;
7183 }
7184 }
7185
7186 if (index >= IPS_MAX_ADAPTERS)
7187 return -1;
7188
7189 /* stuff that we get in dev */
7190 irq = pci_dev->irq;
7191 bus = pci_dev->bus->number;
7192 func = pci_dev->devfn;
7193
7194 /* Init MEM/IO addresses to 0 */
7195 mem_addr = 0;
7196 io_addr = 0;
7197 mem_len = 0;
7198 io_len = 0;
7199
7200 for (j = 0; j < 2; j++) {
7201 if (!pci_resource_start(pci_dev, j))
7202 break;
7203
7204 if (pci_resource_flags(pci_dev, j) & IORESOURCE_IO) {
7205 io_addr = pci_resource_start(pci_dev, j);
7206 io_len = pci_resource_len(pci_dev, j);
7207 } else {
7208 mem_addr = pci_resource_start(pci_dev, j);
7209 mem_len = pci_resource_len(pci_dev, j);
7210 }
7211 }
7212
7213 /* setup memory mapped area (if applicable) */
7214 if (mem_addr) {
7215 uint32_t base;
7216 uint32_t offs;
7217
7218 if (!request_mem_region(mem_addr, mem_len, "ips")) {
7219 IPS_PRINTK(KERN_WARNING, pci_dev,
7220 "Couldn't allocate IO Memory space %x len %d.\n",
7221 mem_addr, mem_len);
7222 return -1;
7223 }
7224
7225 base = mem_addr & PAGE_MASK;
7226 offs = mem_addr - base;
7227 ioremap_ptr = ioremap(base, PAGE_SIZE);
7228 mem_ptr = ioremap_ptr + offs;
7229 } else {
7230 ioremap_ptr = NULL;
7231 mem_ptr = NULL;
7232 }
7233
7234 /* setup I/O mapped area (if applicable) */
7235 if (io_addr) {
7236 if (!request_region(io_addr, io_len, "ips")) {
7237 IPS_PRINTK(KERN_WARNING, pci_dev,
7238 "Couldn't allocate IO space %x len %d.\n",
7239 io_addr, io_len);
7240 return -1;
7241 }
7242 }
7243
7244 /* get the revision ID */
7245 if (pci_read_config_byte(pci_dev, PCI_REVISION_ID, &revision_id)) {
7246 IPS_PRINTK(KERN_WARNING, pci_dev, "Can't get revision id.\n");
7247 return -1;
7248 }
7249
7250 subdevice_id = pci_dev->subsystem_device;
7251
7252 /* found a controller */
7253 ha = kmalloc(sizeof (ips_ha_t), GFP_KERNEL);
7254 if (ha == NULL) {
7255 IPS_PRINTK(KERN_WARNING, pci_dev,
7256 "Unable to allocate temporary ha struct\n");
7257 return -1;
7258 }
7259
7260 memset(ha, 0, sizeof (ips_ha_t));
7261
7262 ips_sh[index] = NULL;
7263 ips_ha[index] = ha;
7264 ha->active = 1;
7265
7266 /* Store info in HA structure */
7267 ha->irq = irq;
7268 ha->io_addr = io_addr;
7269 ha->io_len = io_len;
7270 ha->mem_addr = mem_addr;
7271 ha->mem_len = mem_len;
7272 ha->mem_ptr = mem_ptr;
7273 ha->ioremap_ptr = ioremap_ptr;
7274 ha->host_num = (uint32_t) index;
7275 ha->revision_id = revision_id;
7276 ha->slot_num = PCI_SLOT(pci_dev->devfn);
7277 ha->device_id = pci_dev->device;
7278 ha->subdevice_id = subdevice_id;
7279 ha->pcidev = pci_dev;
7280
7281 /*
7282 * Set the pci_dev's dma_mask. Not all adapters support 64bit
7283 * addressing so don't enable it if the adapter can't support
7284 * it! Also, don't use 64bit addressing if dma addresses
7285 * are guaranteed to be < 4G.
7286 */
7287 if (IPS_ENABLE_DMA64 && IPS_HAS_ENH_SGLIST(ha) &&
7288 !pci_set_dma_mask(ha->pcidev, DMA_64BIT_MASK)) {
7289 (ha)->flags |= IPS_HA_ENH_SG;
7290 } else {
7291 if (pci_set_dma_mask(ha->pcidev, DMA_32BIT_MASK) != 0) {
7292 printk(KERN_WARNING "Unable to set DMA Mask\n");
7293 return ips_abort_init(ha, index);
7294 }
7295 }
7296 if(ips_cd_boot && !ips_FlashData){
7297 ips_FlashData = pci_alloc_consistent(pci_dev, PAGE_SIZE << 7,
7298 &ips_flashbusaddr);
7299 }
7300
7301 ha->enq = pci_alloc_consistent(pci_dev, sizeof (IPS_ENQ),
7302 &ha->enq_busaddr);
7303 if (!ha->enq) {
7304 IPS_PRINTK(KERN_WARNING, pci_dev,
7305 "Unable to allocate host inquiry structure\n");
7306 return ips_abort_init(ha, index);
7307 }
7308
7309 ha->adapt = pci_alloc_consistent(pci_dev, sizeof (IPS_ADAPTER) +
7310 sizeof (IPS_IO_CMD), &dma_address);
7311 if (!ha->adapt) {
7312 IPS_PRINTK(KERN_WARNING, pci_dev,
7313 "Unable to allocate host adapt & dummy structures\n");
7314 return ips_abort_init(ha, index);
7315 }
7316 ha->adapt->hw_status_start = dma_address;
7317 ha->dummy = (void *) (ha->adapt + 1);
7318
7319
7320
7321 ha->logical_drive_info = pci_alloc_consistent(pci_dev, sizeof (IPS_LD_INFO), &dma_address);
7322 if (!ha->logical_drive_info) {
7323 IPS_PRINTK(KERN_WARNING, pci_dev,
7324 "Unable to allocate logical drive info structure\n");
7325 return ips_abort_init(ha, index);
7326 }
7327 ha->logical_drive_info_dma_addr = dma_address;
7328
7329
7330 ha->conf = kmalloc(sizeof (IPS_CONF), GFP_KERNEL);
7331
7332 if (!ha->conf) {
7333 IPS_PRINTK(KERN_WARNING, pci_dev,
7334 "Unable to allocate host conf structure\n");
7335 return ips_abort_init(ha, index);
7336 }
7337
7338 ha->nvram = kmalloc(sizeof (IPS_NVRAM_P5), GFP_KERNEL);
7339
7340 if (!ha->nvram) {
7341 IPS_PRINTK(KERN_WARNING, pci_dev,
7342 "Unable to allocate host NVRAM structure\n");
7343 return ips_abort_init(ha, index);
7344 }
7345
7346 ha->subsys = kmalloc(sizeof (IPS_SUBSYS), GFP_KERNEL);
7347
7348 if (!ha->subsys) {
7349 IPS_PRINTK(KERN_WARNING, pci_dev,
7350 "Unable to allocate host subsystem structure\n");
7351 return ips_abort_init(ha, index);
7352 }
7353
7354 /* the ioctl buffer is now used during adapter initialization, so its
7355 * successful allocation is now required */
7356 if (ips_ioctlsize < PAGE_SIZE)
7357 ips_ioctlsize = PAGE_SIZE;
7358
7359 ha->ioctl_data = pci_alloc_consistent(pci_dev, ips_ioctlsize,
7360 &ha->ioctl_busaddr);
7361 ha->ioctl_len = ips_ioctlsize;
7362 if (!ha->ioctl_data) {
7363 IPS_PRINTK(KERN_WARNING, pci_dev,
7364 "Unable to allocate IOCTL data\n");
7365 return ips_abort_init(ha, index);
7366 }
7367
7368 /*
7369 * Setup Functions
7370 */
7371 ips_setup_funclist(ha);
7372
7373 if ((IPS_IS_MORPHEUS(ha)) || (IPS_IS_MARCO(ha))) {
7374 /* If Morpheus appears dead, reset it */
7375 IsDead = readl(ha->mem_ptr + IPS_REG_I960_MSG1);
7376 if (IsDead == 0xDEADBEEF) {
7377 ips_reset_morpheus(ha);
7378 }
7379 }
7380
7381 /*
7382 * Initialize the card if it isn't already
7383 */
7384
7385 if (!(*ha->func.isinit) (ha)) {
7386 if (!(*ha->func.init) (ha)) {
7387 /*
7388 * Initialization failed
7389 */
7390 IPS_PRINTK(KERN_WARNING, pci_dev,
7391 "Unable to initialize controller\n");
7392 return ips_abort_init(ha, index);
7393 }
7394 }
7395
7396 *indexPtr = index;
7397 return SUCCESS;
7398 }
7399
7400 /*---------------------------------------------------------------------------*/
7401 /* Routine Name: ips_init_phase2 */
7402 /* */
7403 /* Routine Description: */
7404 /* Adapter Initialization Phase 2 */
7405 /* */
7406 /* Return Value: */
7407 /* 0 if Successful, else non-zero */
7408 /*---------------------------------------------------------------------------*/
7409 static int
7410 ips_init_phase2(int index)
7411 {
7412 ips_ha_t *ha;
7413
7414 ha = ips_ha[index];
7415
7416 METHOD_TRACE("ips_init_phase2", 1);
7417 if (!ha->active) {
7418 ips_ha[index] = NULL;
7419 return -1;
7420 }
7421
7422 /* Install the interrupt handler */
7423 if (request_irq(ha->irq, do_ipsintr, SA_SHIRQ, ips_name, ha)) {
7424 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7425 "Unable to install interrupt handler\n");
7426 return ips_abort_init(ha, index);
7427 }
7428
7429 /*
7430 * Allocate a temporary SCB for initialization
7431 */
7432 ha->max_cmds = 1;
7433 if (!ips_allocatescbs(ha)) {
7434 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7435 "Unable to allocate a CCB\n");
7436 free_irq(ha->irq, ha);
7437 return ips_abort_init(ha, index);
7438 }
7439
7440 if (!ips_hainit(ha)) {
7441 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7442 "Unable to initialize controller\n");
7443 free_irq(ha->irq, ha);
7444 return ips_abort_init(ha, index);
7445 }
7446 /* Free the temporary SCB */
7447 ips_deallocatescbs(ha, 1);
7448
7449 /* allocate CCBs */
7450 if (!ips_allocatescbs(ha)) {
7451 IPS_PRINTK(KERN_WARNING, ha->pcidev,
7452 "Unable to allocate CCBs\n");
7453 free_irq(ha->irq, ha);
7454 return ips_abort_init(ha, index);
7455 }
7456
7457 return SUCCESS;
7458 }
7459
7460 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,9)
7461 MODULE_LICENSE("GPL");
7462 #endif
7463
7464 MODULE_DESCRIPTION("IBM ServeRAID Adapter Driver " IPS_VER_STRING);
7465
7466 #ifdef MODULE_VERSION
7467 MODULE_VERSION(IPS_VER_STRING);
7468 #endif
7469
7470
7471 /*
7472 * Overrides for Emacs so that we almost follow Linus's tabbing style.
7473 * Emacs will notice this stuff at the end of the file and automatically
7474 * adjust the settings for this buffer only. This must remain at the end
7475 * of the file.
7476 * ---------------------------------------------------------------------------
7477 * Local variables:
7478 * c-indent-level: 2
7479 * c-brace-imaginary-offset: 0
7480 * c-brace-offset: -2
7481 * c-argdecl-indent: 2
7482 * c-label-offset: -2
7483 * c-continued-statement-offset: 2
7484 * c-continued-brace-offset: 0
7485 * indent-tabs-mode: nil
7486 * tab-width: 8
7487 * End:
7488 */
Verdex Pro support