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