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