1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /****************************************************************************** 3 * QLOGIC LINUX SOFTWARE 4 * 5 * QLogic QLA1280 (Ultra2) and QLA12160 (Ultra3) SCSI driver 6 * Copyright (C) 2000 Qlogic Corporation (www.qlogic.com) 7 * Copyright (C) 2001-2004 Jes Sorensen, Wild Open Source Inc. 8 * Copyright (C) 2003-2004 Christoph Hellwig 9 * 10 ******************************************************************************/ 11 #define QLA1280_VERSION "3.27.1" 12 /***************************************************************************** 13 Revision History: 14 Rev 3.27.1, February 8, 2010, Michael Reed 15 - Retain firmware image for error recovery. 16 Rev 3.27, February 10, 2009, Michael Reed 17 - General code cleanup. 18 - Improve error recovery. 19 Rev 3.26, January 16, 2006 Jes Sorensen 20 - Ditch all < 2.6 support 21 Rev 3.25.1, February 10, 2005 Christoph Hellwig 22 - use pci_map_single to map non-S/G requests 23 - remove qla1280_proc_info 24 Rev 3.25, September 28, 2004, Christoph Hellwig 25 - add support for ISP1020/1040 26 - don't include "scsi.h" anymore for 2.6.x 27 Rev 3.24.4 June 7, 2004 Christoph Hellwig 28 - restructure firmware loading, cleanup initialization code 29 - prepare support for ISP1020/1040 chips 30 Rev 3.24.3 January 19, 2004, Jes Sorensen 31 - Handle PCI DMA mask settings correctly 32 - Correct order of error handling in probe_one, free_irq should not 33 be called if request_irq failed 34 Rev 3.24.2 January 19, 2004, James Bottomley & Andrew Vasquez 35 - Big endian fixes (James) 36 - Remove bogus IOCB content on zero data transfer commands (Andrew) 37 Rev 3.24.1 January 5, 2004, Jes Sorensen 38 - Initialize completion queue to avoid OOPS on probe 39 - Handle interrupts during mailbox testing 40 Rev 3.24 November 17, 2003, Christoph Hellwig 41 - use struct list_head for completion queue 42 - avoid old Scsi_FOO typedefs 43 - cleanup 2.4 compat glue a bit 44 - use <scsi/scsi_*.h> headers on 2.6 instead of "scsi.h" 45 - make initialization for memory mapped vs port I/O more similar 46 - remove broken pci config space manipulation 47 - kill more cruft 48 - this is an almost perfect 2.6 scsi driver now! ;) 49 Rev 3.23.39 December 17, 2003, Jes Sorensen 50 - Delete completion queue from srb if mailbox command failed to 51 to avoid qla1280_done completeting qla1280_error_action's 52 obsolete context 53 - Reduce arguments for qla1280_done 54 Rev 3.23.38 October 18, 2003, Christoph Hellwig 55 - Convert to new-style hotplugable driver for 2.6 56 - Fix missing scsi_unregister/scsi_host_put on HBA removal 57 - Kill some more cruft 58 Rev 3.23.37 October 1, 2003, Jes Sorensen 59 - Make MMIO depend on CONFIG_X86_VISWS instead of yet another 60 random CONFIG option 61 - Clean up locking in probe path 62 Rev 3.23.36 October 1, 2003, Christoph Hellwig 63 - queuecommand only ever receives new commands - clear flags 64 - Reintegrate lost fixes from Linux 2.5 65 Rev 3.23.35 August 14, 2003, Jes Sorensen 66 - Build against 2.6 67 Rev 3.23.34 July 23, 2003, Jes Sorensen 68 - Remove pointless TRUE/FALSE macros 69 - Clean up vchan handling 70 Rev 3.23.33 July 3, 2003, Jes Sorensen 71 - Don't define register access macros before define determining MMIO. 72 This just happened to work out on ia64 but not elsewhere. 73 - Don't try and read from the card while it is in reset as 74 it won't respond and causes an MCA 75 Rev 3.23.32 June 23, 2003, Jes Sorensen 76 - Basic support for boot time arguments 77 Rev 3.23.31 June 8, 2003, Jes Sorensen 78 - Reduce boot time messages 79 Rev 3.23.30 June 6, 2003, Jes Sorensen 80 - Do not enable sync/wide/ppr before it has been determined 81 that the target device actually supports it 82 - Enable DMA arbitration for multi channel controllers 83 Rev 3.23.29 June 3, 2003, Jes Sorensen 84 - Port to 2.5.69 85 Rev 3.23.28 June 3, 2003, Jes Sorensen 86 - Eliminate duplicate marker commands on bus resets 87 - Handle outstanding commands appropriately on bus/device resets 88 Rev 3.23.27 May 28, 2003, Jes Sorensen 89 - Remove bogus input queue code, let the Linux SCSI layer do the work 90 - Clean up NVRAM handling, only read it once from the card 91 - Add a number of missing default nvram parameters 92 Rev 3.23.26 Beta May 28, 2003, Jes Sorensen 93 - Use completion queue for mailbox commands instead of busy wait 94 Rev 3.23.25 Beta May 27, 2003, James Bottomley 95 - Migrate to use new error handling code 96 Rev 3.23.24 Beta May 21, 2003, James Bottomley 97 - Big endian support 98 - Cleanup data direction code 99 Rev 3.23.23 Beta May 12, 2003, Jes Sorensen 100 - Switch to using MMIO instead of PIO 101 Rev 3.23.22 Beta April 15, 2003, Jes Sorensen 102 - Fix PCI parity problem with 12160 during reset. 103 Rev 3.23.21 Beta April 14, 2003, Jes Sorensen 104 - Use pci_map_page()/pci_unmap_page() instead of map_single version. 105 Rev 3.23.20 Beta April 9, 2003, Jes Sorensen 106 - Remove < 2.4.x support 107 - Introduce HOST_LOCK to make the spin lock changes portable. 108 - Remove a bunch of idiotic and unnecessary typedef's 109 - Kill all leftovers of target-mode support which never worked anyway 110 Rev 3.23.19 Beta April 11, 2002, Linus Torvalds 111 - Do qla1280_pci_config() before calling request_irq() and 112 request_region() 113 - Use pci_dma_hi32() to handle upper word of DMA addresses instead 114 of large shifts 115 - Hand correct arguments to free_irq() in case of failure 116 Rev 3.23.18 Beta April 11, 2002, Jes Sorensen 117 - Run source through Lindent and clean up the output 118 Rev 3.23.17 Beta April 11, 2002, Jes Sorensen 119 - Update SCSI firmware to qla1280 v8.15.00 and qla12160 v10.04.32 120 Rev 3.23.16 Beta March 19, 2002, Jes Sorensen 121 - Rely on mailbox commands generating interrupts - do not 122 run qla1280_isr() from ql1280_mailbox_command() 123 - Remove device_reg_t 124 - Integrate ql12160_set_target_parameters() with 1280 version 125 - Make qla1280_setup() non static 126 - Do not call qla1280_check_for_dead_scsi_bus() on every I/O request 127 sent to the card - this command pauses the firmware!!! 128 Rev 3.23.15 Beta March 19, 2002, Jes Sorensen 129 - Clean up qla1280.h - remove obsolete QL_DEBUG_LEVEL_x definitions 130 - Remove a pile of pointless and confusing (srb_t **) and 131 (scsi_lu_t *) typecasts 132 - Explicit mark that we do not use the new error handling (for now) 133 - Remove scsi_qla_host_t and use 'struct' instead 134 - Remove in_abort, watchdog_enabled, dpc, dpc_sched, bios_enabled, 135 pci_64bit_slot flags which weren't used for anything anyway 136 - Grab host->host_lock while calling qla1280_isr() from abort() 137 - Use spin_lock()/spin_unlock() in qla1280_intr_handler() - we 138 do not need to save/restore flags in the interrupt handler 139 - Enable interrupts early (before any mailbox access) in preparation 140 for cleaning up the mailbox handling 141 Rev 3.23.14 Beta March 14, 2002, Jes Sorensen 142 - Further cleanups. Remove all trace of QL_DEBUG_LEVEL_x and replace 143 it with proper use of dprintk(). 144 - Make qla1280_print_scsi_cmd() and qla1280_dump_buffer() both take 145 a debug level argument to determine if data is to be printed 146 - Add KERN_* info to printk() 147 Rev 3.23.13 Beta March 14, 2002, Jes Sorensen 148 - Significant cosmetic cleanups 149 - Change debug code to use dprintk() and remove #if mess 150 Rev 3.23.12 Beta March 13, 2002, Jes Sorensen 151 - More cosmetic cleanups, fix places treating return as function 152 - use cpu_relax() in qla1280_debounce_register() 153 Rev 3.23.11 Beta March 13, 2002, Jes Sorensen 154 - Make it compile under 2.5.5 155 Rev 3.23.10 Beta October 1, 2001, Jes Sorensen 156 - Do no typecast short * to long * in QL1280BoardTbl, this 157 broke miserably on big endian boxes 158 Rev 3.23.9 Beta September 30, 2001, Jes Sorensen 159 - Remove pre 2.2 hack for checking for reentrance in interrupt handler 160 - Make data types used to receive from SCSI_{BUS,TCN,LUN}_32 161 unsigned int to match the types from struct scsi_cmnd 162 Rev 3.23.8 Beta September 29, 2001, Jes Sorensen 163 - Remove bogus timer_t typedef from qla1280.h 164 - Remove obsolete pre 2.2 PCI setup code, use proper #define's 165 for PCI_ values, call pci_set_master() 166 - Fix memleak of qla1280_buffer on module unload 167 - Only compile module parsing code #ifdef MODULE - should be 168 changed to use individual MODULE_PARM's later 169 - Remove dummy_buffer that was never modified nor printed 170 - ENTER()/LEAVE() are noops unless QL_DEBUG_LEVEL_3, hence remove 171 #ifdef QL_DEBUG_LEVEL_3/#endif around ENTER()/LEAVE() calls 172 - Remove \r from print statements, this is Linux, not DOS 173 - Remove obsolete QLA1280_{SCSILU,INTR,RING}_{LOCK,UNLOCK} 174 dummy macros 175 - Remove C++ compile hack in header file as Linux driver are not 176 supposed to be compiled as C++ 177 - Kill MS_64BITS macro as it makes the code more readable 178 - Remove unnecessary flags.in_interrupts bit 179 Rev 3.23.7 Beta August 20, 2001, Jes Sorensen 180 - Dont' check for set flags on q->q_flag one by one in qla1280_next() 181 - Check whether the interrupt was generated by the QLA1280 before 182 doing any processing 183 - qla1280_status_entry(): Only zero out part of sense_buffer that 184 is not being copied into 185 - Remove more superflouous typecasts 186 - qla1280_32bit_start_scsi() replace home-brew memcpy() with memcpy() 187 Rev 3.23.6 Beta August 20, 2001, Tony Luck, Intel 188 - Don't walk the entire list in qla1280_putq_t() just to directly 189 grab the pointer to the last element afterwards 190 Rev 3.23.5 Beta August 9, 2001, Jes Sorensen 191 - Don't use IRQF_DISABLED, it's use is deprecated for this kinda driver 192 Rev 3.23.4 Beta August 8, 2001, Jes Sorensen 193 - Set dev->max_sectors to 1024 194 Rev 3.23.3 Beta August 6, 2001, Jes Sorensen 195 - Provide compat macros for pci_enable_device(), pci_find_subsys() 196 and scsi_set_pci_device() 197 - Call scsi_set_pci_device() for all devices 198 - Reduce size of kernel version dependent device probe code 199 - Move duplicate probe/init code to separate function 200 - Handle error if qla1280_mem_alloc() fails 201 - Kill OFFSET() macro and use Linux's PCI definitions instead 202 - Kill private structure defining PCI config space (struct config_reg) 203 - Only allocate I/O port region if not in MMIO mode 204 - Remove duplicate (unused) sanity check of sife of srb_t 205 Rev 3.23.2 Beta August 6, 2001, Jes Sorensen 206 - Change home-brew memset() implementations to use memset() 207 - Remove all references to COMTRACE() - accessing a PC's COM2 serial 208 port directly is not legal under Linux. 209 Rev 3.23.1 Beta April 24, 2001, Jes Sorensen 210 - Remove pre 2.2 kernel support 211 - clean up 64 bit DMA setting to use 2.4 API (provide backwards compat) 212 - Fix MMIO access to use readl/writel instead of directly 213 dereferencing pointers 214 - Nuke MSDOS debugging code 215 - Change true/false data types to int from uint8_t 216 - Use int for counters instead of uint8_t etc. 217 - Clean up size & byte order conversion macro usage 218 Rev 3.23 Beta January 11, 2001 BN Qlogic 219 - Added check of device_id when handling non 220 QLA12160s during detect(). 221 Rev 3.22 Beta January 5, 2001 BN Qlogic 222 - Changed queue_task() to schedule_task() 223 for kernels 2.4.0 and higher. 224 Note: 2.4.0-testxx kernels released prior to 225 the actual 2.4.0 kernel release on January 2001 226 will get compile/link errors with schedule_task(). 227 Please update your kernel to released 2.4.0 level, 228 or comment lines in this file flagged with 3.22 229 to resolve compile/link error of schedule_task(). 230 - Added -DCONFIG_SMP in addition to -D__SMP__ 231 in Makefile for 2.4.0 builds of driver as module. 232 Rev 3.21 Beta January 4, 2001 BN Qlogic 233 - Changed criteria of 64/32 Bit mode of HBA 234 operation according to BITS_PER_LONG rather 235 than HBA's NVRAM setting of >4Gig memory bit; 236 so that the HBA auto-configures without the need 237 to setup each system individually. 238 Rev 3.20 Beta December 5, 2000 BN Qlogic 239 - Added priority handling to IA-64 onboard SCSI 240 ISP12160 chip for kernels greater than 2.3.18. 241 - Added irqrestore for qla1280_intr_handler. 242 - Enabled /proc/scsi/qla1280 interface. 243 - Clear /proc/scsi/qla1280 counters in detect(). 244 Rev 3.19 Beta October 13, 2000 BN Qlogic 245 - Declare driver_template for new kernel 246 (2.4.0 and greater) scsi initialization scheme. 247 - Update /proc/scsi entry for 2.3.18 kernels and 248 above as qla1280 249 Rev 3.18 Beta October 10, 2000 BN Qlogic 250 - Changed scan order of adapters to map 251 the QLA12160 followed by the QLA1280. 252 Rev 3.17 Beta September 18, 2000 BN Qlogic 253 - Removed warnings for 32 bit 2.4.x compiles 254 - Corrected declared size for request and response 255 DMA addresses that are kept in each ha 256 Rev. 3.16 Beta August 25, 2000 BN Qlogic 257 - Corrected 64 bit addressing issue on IA-64 258 where the upper 32 bits were not properly 259 passed to the RISC engine. 260 Rev. 3.15 Beta August 22, 2000 BN Qlogic 261 - Modified qla1280_setup_chip to properly load 262 ISP firmware for greater that 4 Gig memory on IA-64 263 Rev. 3.14 Beta August 16, 2000 BN Qlogic 264 - Added setting of dma_mask to full 64 bit 265 if flags.enable_64bit_addressing is set in NVRAM 266 Rev. 3.13 Beta August 16, 2000 BN Qlogic 267 - Use new PCI DMA mapping APIs for 2.4.x kernel 268 Rev. 3.12 July 18, 2000 Redhat & BN Qlogic 269 - Added check of pci_enable_device to detect() for 2.3.x 270 - Use pci_resource_start() instead of 271 pdev->resource[0].start in detect() for 2.3.x 272 - Updated driver version 273 Rev. 3.11 July 14, 2000 BN Qlogic 274 - Updated SCSI Firmware to following versions: 275 qla1x80: 8.13.08 276 qla1x160: 10.04.08 277 - Updated driver version to 3.11 278 Rev. 3.10 June 23, 2000 BN Qlogic 279 - Added filtering of AMI SubSys Vendor ID devices 280 Rev. 3.9 281 - DEBUG_QLA1280 undefined and new version BN Qlogic 282 Rev. 3.08b May 9, 2000 MD Dell 283 - Added logic to check against AMI subsystem vendor ID 284 Rev. 3.08 May 4, 2000 DG Qlogic 285 - Added logic to check for PCI subsystem ID. 286 Rev. 3.07 Apr 24, 2000 DG & BN Qlogic 287 - Updated SCSI Firmware to following versions: 288 qla12160: 10.01.19 289 qla1280: 8.09.00 290 Rev. 3.06 Apr 12, 2000 DG & BN Qlogic 291 - Internal revision; not released 292 Rev. 3.05 Mar 28, 2000 DG & BN Qlogic 293 - Edit correction for virt_to_bus and PROC. 294 Rev. 3.04 Mar 28, 2000 DG & BN Qlogic 295 - Merge changes from ia64 port. 296 Rev. 3.03 Mar 28, 2000 BN Qlogic 297 - Increase version to reflect new code drop with compile fix 298 of issue with inclusion of linux/spinlock for 2.3 kernels 299 Rev. 3.02 Mar 15, 2000 BN Qlogic 300 - Merge qla1280_proc_info from 2.10 code base 301 Rev. 3.01 Feb 10, 2000 BN Qlogic 302 - Corrected code to compile on a 2.2.x kernel. 303 Rev. 3.00 Jan 17, 2000 DG Qlogic 304 - Added 64-bit support. 305 Rev. 2.07 Nov 9, 1999 DG Qlogic 306 - Added new routine to set target parameters for ISP12160. 307 Rev. 2.06 Sept 10, 1999 DG Qlogic 308 - Added support for ISP12160 Ultra 3 chip. 309 Rev. 2.03 August 3, 1999 Fred Lewis, Intel DuPont 310 - Modified code to remove errors generated when compiling with 311 Cygnus IA64 Compiler. 312 - Changed conversion of pointers to unsigned longs instead of integers. 313 - Changed type of I/O port variables from uint32_t to unsigned long. 314 - Modified OFFSET macro to work with 64-bit as well as 32-bit. 315 - Changed sprintf and printk format specifiers for pointers to %p. 316 - Changed some int to long type casts where needed in sprintf & printk. 317 - Added l modifiers to sprintf and printk format specifiers for longs. 318 - Removed unused local variables. 319 Rev. 1.20 June 8, 1999 DG, Qlogic 320 Changes to support RedHat release 6.0 (kernel 2.2.5). 321 - Added SCSI exclusive access lock (io_request_lock) when accessing 322 the adapter. 323 - Added changes for the new LINUX interface template. Some new error 324 handling routines have been added to the template, but for now we 325 will use the old ones. 326 - Initial Beta Release. 327 *****************************************************************************/ 328 329 330 #include <linux/module.h> 331 332 #include <linux/types.h> 333 #include <linux/string.h> 334 #include <linux/errno.h> 335 #include <linux/kernel.h> 336 #include <linux/ioport.h> 337 #include <linux/delay.h> 338 #include <linux/timer.h> 339 #include <linux/pci.h> 340 #include <linux/proc_fs.h> 341 #include <linux/stat.h> 342 #include <linux/pci_ids.h> 343 #include <linux/interrupt.h> 344 #include <linux/init.h> 345 #include <linux/dma-mapping.h> 346 #include <linux/firmware.h> 347 348 #include <asm/io.h> 349 #include <asm/irq.h> 350 #include <asm/byteorder.h> 351 #include <asm/processor.h> 352 #include <asm/types.h> 353 354 #include <scsi/scsi.h> 355 #include <scsi/scsi_cmnd.h> 356 #include <scsi/scsi_device.h> 357 #include <scsi/scsi_host.h> 358 #include <scsi/scsi_tcq.h> 359 360 361 /* 362 * Compile time Options: 363 * 0 - Disable and 1 - Enable 364 */ 365 #define DEBUG_QLA1280_INTR 0 366 #define DEBUG_PRINT_NVRAM 0 367 #define DEBUG_QLA1280 0 368 369 #define MEMORY_MAPPED_IO 1 370 371 #include "qla1280.h" 372 373 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT 374 #define QLA_64BIT_PTR 1 375 #endif 376 377 #define NVRAM_DELAY() udelay(500) /* 2 microseconds */ 378 379 #define IS_ISP1040(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020) 380 #define IS_ISP1x40(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020 || \ 381 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1240) 382 #define IS_ISP1x160(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP10160 || \ 383 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP12160) 384 385 386 static int qla1280_probe_one(struct pci_dev *, const struct pci_device_id *); 387 static void qla1280_remove_one(struct pci_dev *); 388 389 /* 390 * QLogic Driver Support Function Prototypes. 391 */ 392 static void qla1280_done(struct scsi_qla_host *); 393 static int qla1280_get_token(char *); 394 static int qla1280_setup(char *s) __init; 395 396 /* 397 * QLogic ISP1280 Hardware Support Function Prototypes. 398 */ 399 static int qla1280_load_firmware(struct scsi_qla_host *); 400 static int qla1280_init_rings(struct scsi_qla_host *); 401 static int qla1280_nvram_config(struct scsi_qla_host *); 402 static int qla1280_mailbox_command(struct scsi_qla_host *, 403 uint8_t, uint16_t *); 404 static int qla1280_bus_reset(struct scsi_qla_host *, int); 405 static int qla1280_device_reset(struct scsi_qla_host *, int, int); 406 static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int); 407 static int qla1280_abort_isp(struct scsi_qla_host *); 408 #ifdef QLA_64BIT_PTR 409 static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *); 410 #else 411 static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *); 412 #endif 413 static void qla1280_nv_write(struct scsi_qla_host *, uint16_t); 414 static void qla1280_poll(struct scsi_qla_host *); 415 static void qla1280_reset_adapter(struct scsi_qla_host *); 416 static void qla1280_marker(struct scsi_qla_host *, int, int, int, u8); 417 static void qla1280_isp_cmd(struct scsi_qla_host *); 418 static void qla1280_isr(struct scsi_qla_host *, struct list_head *); 419 static void qla1280_rst_aen(struct scsi_qla_host *); 420 static void qla1280_status_entry(struct scsi_qla_host *, struct response *, 421 struct list_head *); 422 static void qla1280_error_entry(struct scsi_qla_host *, struct response *, 423 struct list_head *); 424 static uint16_t qla1280_get_nvram_word(struct scsi_qla_host *, uint32_t); 425 static uint16_t qla1280_nvram_request(struct scsi_qla_host *, uint32_t); 426 static uint16_t qla1280_debounce_register(volatile uint16_t __iomem *); 427 static request_t *qla1280_req_pkt(struct scsi_qla_host *); 428 static int qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *, 429 unsigned int); 430 static void qla1280_get_target_parameters(struct scsi_qla_host *, 431 struct scsi_device *); 432 static int qla1280_set_target_parameters(struct scsi_qla_host *, int, int); 433 434 435 static struct qla_driver_setup driver_setup; 436 437 /* 438 * convert scsi data direction to request_t control flags 439 */ 440 static inline uint16_t 441 qla1280_data_direction(struct scsi_cmnd *cmnd) 442 { 443 switch(cmnd->sc_data_direction) { 444 case DMA_FROM_DEVICE: 445 return BIT_5; 446 case DMA_TO_DEVICE: 447 return BIT_6; 448 case DMA_BIDIRECTIONAL: 449 return BIT_5 | BIT_6; 450 /* 451 * We could BUG() on default here if one of the four cases aren't 452 * met, but then again if we receive something like that from the 453 * SCSI layer we have more serious problems. This shuts up GCC. 454 */ 455 case DMA_NONE: 456 default: 457 return 0; 458 } 459 } 460 461 #if DEBUG_QLA1280 462 static void __qla1280_print_scsi_cmd(struct scsi_cmnd * cmd); 463 static void __qla1280_dump_buffer(char *, int); 464 #endif 465 466 467 /* 468 * insmod needs to find the variable and make it point to something 469 */ 470 #ifdef MODULE 471 static char *qla1280; 472 473 /* insmod qla1280 options=verbose" */ 474 module_param(qla1280, charp, 0); 475 #else 476 __setup("qla1280=", qla1280_setup); 477 #endif 478 479 480 /* 481 * We use the scsi_pointer structure that's included with each scsi_command 482 * to overlay our struct srb over it. qla1280_init() checks that a srb is not 483 * bigger than a scsi_pointer. 484 */ 485 486 #define CMD_SP(Cmnd) &Cmnd->SCp 487 #define CMD_CDBLEN(Cmnd) Cmnd->cmd_len 488 #define CMD_CDBP(Cmnd) Cmnd->cmnd 489 #define CMD_SNSP(Cmnd) Cmnd->sense_buffer 490 #define CMD_SNSLEN(Cmnd) SCSI_SENSE_BUFFERSIZE 491 #define CMD_RESULT(Cmnd) Cmnd->result 492 #define CMD_HANDLE(Cmnd) Cmnd->host_scribble 493 494 #define CMD_HOST(Cmnd) Cmnd->device->host 495 #define SCSI_BUS_32(Cmnd) Cmnd->device->channel 496 #define SCSI_TCN_32(Cmnd) Cmnd->device->id 497 #define SCSI_LUN_32(Cmnd) Cmnd->device->lun 498 499 500 /*****************************************/ 501 /* ISP Boards supported by this driver */ 502 /*****************************************/ 503 504 struct qla_boards { 505 char *name; /* Board ID String */ 506 int numPorts; /* Number of SCSI ports */ 507 int fw_index; /* index into qla1280_fw_tbl for firmware */ 508 }; 509 510 /* NOTE: the last argument in each entry is used to index ql1280_board_tbl */ 511 static struct pci_device_id qla1280_pci_tbl[] = { 512 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP12160, 513 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 514 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020, 515 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1}, 516 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1080, 517 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2}, 518 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1240, 519 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3}, 520 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1280, 521 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4}, 522 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP10160, 523 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5}, 524 {0,} 525 }; 526 MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl); 527 528 static DEFINE_MUTEX(qla1280_firmware_mutex); 529 530 struct qla_fw { 531 char *fwname; 532 const struct firmware *fw; 533 }; 534 535 #define QL_NUM_FW_IMAGES 3 536 537 static struct qla_fw qla1280_fw_tbl[QL_NUM_FW_IMAGES] = { 538 {"qlogic/1040.bin", NULL}, /* image 0 */ 539 {"qlogic/1280.bin", NULL}, /* image 1 */ 540 {"qlogic/12160.bin", NULL}, /* image 2 */ 541 }; 542 543 /* NOTE: Order of boards in this table must match order in qla1280_pci_tbl */ 544 static struct qla_boards ql1280_board_tbl[] = { 545 {.name = "QLA12160", .numPorts = 2, .fw_index = 2}, 546 {.name = "QLA1040" , .numPorts = 1, .fw_index = 0}, 547 {.name = "QLA1080" , .numPorts = 1, .fw_index = 1}, 548 {.name = "QLA1240" , .numPorts = 2, .fw_index = 1}, 549 {.name = "QLA1280" , .numPorts = 2, .fw_index = 1}, 550 {.name = "QLA10160", .numPorts = 1, .fw_index = 2}, 551 {.name = " ", .numPorts = 0, .fw_index = -1}, 552 }; 553 554 static int qla1280_verbose = 1; 555 556 #if DEBUG_QLA1280 557 static int ql_debug_level = 1; 558 #define dprintk(level, format, a...) \ 559 do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0) 560 #define qla1280_dump_buffer(level, buf, size) \ 561 if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size) 562 #define qla1280_print_scsi_cmd(level, cmd) \ 563 if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd) 564 #else 565 #define ql_debug_level 0 566 #define dprintk(level, format, a...) do{}while(0) 567 #define qla1280_dump_buffer(a, b, c) do{}while(0) 568 #define qla1280_print_scsi_cmd(a, b) do{}while(0) 569 #endif 570 571 #define ENTER(x) dprintk(3, "qla1280 : Entering %s()\n", x); 572 #define LEAVE(x) dprintk(3, "qla1280 : Leaving %s()\n", x); 573 #define ENTER_INTR(x) dprintk(4, "qla1280 : Entering %s()\n", x); 574 #define LEAVE_INTR(x) dprintk(4, "qla1280 : Leaving %s()\n", x); 575 576 577 static int qla1280_read_nvram(struct scsi_qla_host *ha) 578 { 579 uint16_t *wptr; 580 uint8_t chksum; 581 int cnt, i; 582 struct nvram *nv; 583 584 ENTER("qla1280_read_nvram"); 585 586 if (driver_setup.no_nvram) 587 return 1; 588 589 printk(KERN_INFO "scsi(%ld): Reading NVRAM\n", ha->host_no); 590 591 wptr = (uint16_t *)&ha->nvram; 592 nv = &ha->nvram; 593 chksum = 0; 594 for (cnt = 0; cnt < 3; cnt++) { 595 *wptr = qla1280_get_nvram_word(ha, cnt); 596 chksum += *wptr & 0xff; 597 chksum += (*wptr >> 8) & 0xff; 598 wptr++; 599 } 600 601 if (nv->id0 != 'I' || nv->id1 != 'S' || 602 nv->id2 != 'P' || nv->id3 != ' ' || nv->version < 1) { 603 dprintk(2, "Invalid nvram ID or version!\n"); 604 chksum = 1; 605 } else { 606 for (; cnt < sizeof(struct nvram); cnt++) { 607 *wptr = qla1280_get_nvram_word(ha, cnt); 608 chksum += *wptr & 0xff; 609 chksum += (*wptr >> 8) & 0xff; 610 wptr++; 611 } 612 } 613 614 dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x" 615 " version %i\n", nv->id0, nv->id1, nv->id2, nv->id3, 616 nv->version); 617 618 619 if (chksum) { 620 if (!driver_setup.no_nvram) 621 printk(KERN_WARNING "scsi(%ld): Unable to identify or " 622 "validate NVRAM checksum, using default " 623 "settings\n", ha->host_no); 624 ha->nvram_valid = 0; 625 } else 626 ha->nvram_valid = 1; 627 628 /* The firmware interface is, um, interesting, in that the 629 * actual firmware image on the chip is little endian, thus, 630 * the process of taking that image to the CPU would end up 631 * little endian. However, the firmware interface requires it 632 * to be read a word (two bytes) at a time. 633 * 634 * The net result of this would be that the word (and 635 * doubleword) quantities in the firmware would be correct, but 636 * the bytes would be pairwise reversed. Since most of the 637 * firmware quantities are, in fact, bytes, we do an extra 638 * le16_to_cpu() in the firmware read routine. 639 * 640 * The upshot of all this is that the bytes in the firmware 641 * are in the correct places, but the 16 and 32 bit quantities 642 * are still in little endian format. We fix that up below by 643 * doing extra reverses on them */ 644 nv->isp_parameter = cpu_to_le16(nv->isp_parameter); 645 nv->firmware_feature.w = cpu_to_le16(nv->firmware_feature.w); 646 for(i = 0; i < MAX_BUSES; i++) { 647 nv->bus[i].selection_timeout = cpu_to_le16(nv->bus[i].selection_timeout); 648 nv->bus[i].max_queue_depth = cpu_to_le16(nv->bus[i].max_queue_depth); 649 } 650 dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n"); 651 LEAVE("qla1280_read_nvram"); 652 653 return chksum; 654 } 655 656 /************************************************************************** 657 * qla1280_info 658 * Return a string describing the driver. 659 **************************************************************************/ 660 static const char * 661 qla1280_info(struct Scsi_Host *host) 662 { 663 static char qla1280_scsi_name_buffer[125]; 664 char *bp; 665 struct scsi_qla_host *ha; 666 struct qla_boards *bdp; 667 668 bp = &qla1280_scsi_name_buffer[0]; 669 ha = (struct scsi_qla_host *)host->hostdata; 670 bdp = &ql1280_board_tbl[ha->devnum]; 671 memset(bp, 0, sizeof(qla1280_scsi_name_buffer)); 672 673 sprintf (bp, 674 "QLogic %s PCI to SCSI Host Adapter\n" 675 " Firmware version: %2d.%02d.%02d, Driver version %s", 676 &bdp->name[0], ha->fwver1, ha->fwver2, ha->fwver3, 677 QLA1280_VERSION); 678 return bp; 679 } 680 681 /************************************************************************** 682 * qla1280_queuecommand 683 * Queue a command to the controller. 684 * 685 * Note: 686 * The mid-level driver tries to ensures that queuecommand never gets invoked 687 * concurrently with itself or the interrupt handler (although the 688 * interrupt handler may call this routine as part of request-completion 689 * handling). Unfortunately, it sometimes calls the scheduler in interrupt 690 * context which is a big NO! NO!. 691 **************************************************************************/ 692 static int qla1280_queuecommand_lck(struct scsi_cmnd *cmd) 693 { 694 struct Scsi_Host *host = cmd->device->host; 695 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata; 696 struct srb *sp = (struct srb *)CMD_SP(cmd); 697 int status; 698 699 sp->cmd = cmd; 700 sp->flags = 0; 701 sp->wait = NULL; 702 CMD_HANDLE(cmd) = (unsigned char *)NULL; 703 704 qla1280_print_scsi_cmd(5, cmd); 705 706 #ifdef QLA_64BIT_PTR 707 /* 708 * Using 64 bit commands if the PCI bridge doesn't support it is a 709 * bit wasteful, however this should really only happen if one's 710 * PCI controller is completely broken, like the BCM1250. For 711 * sane hardware this is not an issue. 712 */ 713 status = qla1280_64bit_start_scsi(ha, sp); 714 #else 715 status = qla1280_32bit_start_scsi(ha, sp); 716 #endif 717 return status; 718 } 719 720 static DEF_SCSI_QCMD(qla1280_queuecommand) 721 722 enum action { 723 ABORT_COMMAND, 724 DEVICE_RESET, 725 BUS_RESET, 726 ADAPTER_RESET, 727 }; 728 729 730 static void qla1280_mailbox_timeout(struct timer_list *t) 731 { 732 struct scsi_qla_host *ha = from_timer(ha, t, mailbox_timer); 733 struct device_reg __iomem *reg; 734 reg = ha->iobase; 735 736 ha->mailbox_out[0] = RD_REG_WORD(®->mailbox0); 737 printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, " 738 "ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0], 739 RD_REG_WORD(®->ictrl), RD_REG_WORD(®->istatus)); 740 complete(ha->mailbox_wait); 741 } 742 743 static int 744 _qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp, 745 struct completion *wait) 746 { 747 int status = FAILED; 748 struct scsi_cmnd *cmd = sp->cmd; 749 750 spin_unlock_irq(ha->host->host_lock); 751 wait_for_completion_timeout(wait, 4*HZ); 752 spin_lock_irq(ha->host->host_lock); 753 sp->wait = NULL; 754 if(CMD_HANDLE(cmd) == COMPLETED_HANDLE) { 755 status = SUCCESS; 756 scsi_done(cmd); 757 } 758 return status; 759 } 760 761 static int 762 qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp) 763 { 764 DECLARE_COMPLETION_ONSTACK(wait); 765 766 sp->wait = &wait; 767 return _qla1280_wait_for_single_command(ha, sp, &wait); 768 } 769 770 static int 771 qla1280_wait_for_pending_commands(struct scsi_qla_host *ha, int bus, int target) 772 { 773 int cnt; 774 int status; 775 struct srb *sp; 776 struct scsi_cmnd *cmd; 777 778 status = SUCCESS; 779 780 /* 781 * Wait for all commands with the designated bus/target 782 * to be completed by the firmware 783 */ 784 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) { 785 sp = ha->outstanding_cmds[cnt]; 786 if (sp) { 787 cmd = sp->cmd; 788 789 if (bus >= 0 && SCSI_BUS_32(cmd) != bus) 790 continue; 791 if (target >= 0 && SCSI_TCN_32(cmd) != target) 792 continue; 793 794 status = qla1280_wait_for_single_command(ha, sp); 795 if (status == FAILED) 796 break; 797 } 798 } 799 return status; 800 } 801 802 /************************************************************************** 803 * qla1280_error_action 804 * The function will attempt to perform a specified error action and 805 * wait for the results (or time out). 806 * 807 * Input: 808 * cmd = Linux SCSI command packet of the command that cause the 809 * bus reset. 810 * action = error action to take (see action_t) 811 * 812 * Returns: 813 * SUCCESS or FAILED 814 * 815 **************************************************************************/ 816 static int 817 qla1280_error_action(struct scsi_cmnd *cmd, enum action action) 818 { 819 struct scsi_qla_host *ha; 820 int bus, target, lun; 821 struct srb *sp; 822 int i, found; 823 int result=FAILED; 824 int wait_for_bus=-1; 825 int wait_for_target = -1; 826 DECLARE_COMPLETION_ONSTACK(wait); 827 828 ENTER("qla1280_error_action"); 829 830 ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata); 831 sp = (struct srb *)CMD_SP(cmd); 832 bus = SCSI_BUS_32(cmd); 833 target = SCSI_TCN_32(cmd); 834 lun = SCSI_LUN_32(cmd); 835 836 dprintk(4, "error_action %i, istatus 0x%04x\n", action, 837 RD_REG_WORD(&ha->iobase->istatus)); 838 839 dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n", 840 RD_REG_WORD(&ha->iobase->host_cmd), 841 RD_REG_WORD(&ha->iobase->ictrl), jiffies); 842 843 if (qla1280_verbose) 844 printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, " 845 "Handle=0x%p, action=0x%x\n", 846 ha->host_no, cmd, CMD_HANDLE(cmd), action); 847 848 /* 849 * Check to see if we have the command in the outstanding_cmds[] 850 * array. If not then it must have completed before this error 851 * action was initiated. If the error_action isn't ABORT_COMMAND 852 * then the driver must proceed with the requested action. 853 */ 854 found = -1; 855 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) { 856 if (sp == ha->outstanding_cmds[i]) { 857 found = i; 858 sp->wait = &wait; /* we'll wait for it to complete */ 859 break; 860 } 861 } 862 863 if (found < 0) { /* driver doesn't have command */ 864 result = SUCCESS; 865 if (qla1280_verbose) { 866 printk(KERN_INFO 867 "scsi(%ld:%d:%d:%d): specified command has " 868 "already completed.\n", ha->host_no, bus, 869 target, lun); 870 } 871 } 872 873 switch (action) { 874 875 case ABORT_COMMAND: 876 dprintk(1, "qla1280: RISC aborting command\n"); 877 /* 878 * The abort might fail due to race when the host_lock 879 * is released to issue the abort. As such, we 880 * don't bother to check the return status. 881 */ 882 if (found >= 0) 883 qla1280_abort_command(ha, sp, found); 884 break; 885 886 case DEVICE_RESET: 887 if (qla1280_verbose) 888 printk(KERN_INFO 889 "scsi(%ld:%d:%d:%d): Queueing device reset " 890 "command.\n", ha->host_no, bus, target, lun); 891 if (qla1280_device_reset(ha, bus, target) == 0) { 892 /* issued device reset, set wait conditions */ 893 wait_for_bus = bus; 894 wait_for_target = target; 895 } 896 break; 897 898 case BUS_RESET: 899 if (qla1280_verbose) 900 printk(KERN_INFO "qla1280(%ld:%d): Issued bus " 901 "reset.\n", ha->host_no, bus); 902 if (qla1280_bus_reset(ha, bus) == 0) { 903 /* issued bus reset, set wait conditions */ 904 wait_for_bus = bus; 905 } 906 break; 907 908 case ADAPTER_RESET: 909 default: 910 if (qla1280_verbose) { 911 printk(KERN_INFO 912 "scsi(%ld): Issued ADAPTER RESET\n", 913 ha->host_no); 914 printk(KERN_INFO "scsi(%ld): I/O processing will " 915 "continue automatically\n", ha->host_no); 916 } 917 ha->flags.reset_active = 1; 918 919 if (qla1280_abort_isp(ha) != 0) { /* it's dead */ 920 result = FAILED; 921 } 922 923 ha->flags.reset_active = 0; 924 } 925 926 /* 927 * At this point, the host_lock has been released and retaken 928 * by the issuance of the mailbox command. 929 * Wait for the command passed in by the mid-layer if it 930 * was found by the driver. It might have been returned 931 * between eh recovery steps, hence the check of the "found" 932 * variable. 933 */ 934 935 if (found >= 0) 936 result = _qla1280_wait_for_single_command(ha, sp, &wait); 937 938 if (action == ABORT_COMMAND && result != SUCCESS) { 939 printk(KERN_WARNING 940 "scsi(%li:%i:%i:%i): " 941 "Unable to abort command!\n", 942 ha->host_no, bus, target, lun); 943 } 944 945 /* 946 * If the command passed in by the mid-layer has been 947 * returned by the board, then wait for any additional 948 * commands which are supposed to complete based upon 949 * the error action. 950 * 951 * All commands are unconditionally returned during a 952 * call to qla1280_abort_isp(), ADAPTER_RESET. No need 953 * to wait for them. 954 */ 955 if (result == SUCCESS && wait_for_bus >= 0) { 956 result = qla1280_wait_for_pending_commands(ha, 957 wait_for_bus, wait_for_target); 958 } 959 960 dprintk(1, "RESET returning %d\n", result); 961 962 LEAVE("qla1280_error_action"); 963 return result; 964 } 965 966 /************************************************************************** 967 * qla1280_abort 968 * Abort the specified SCSI command(s). 969 **************************************************************************/ 970 static int 971 qla1280_eh_abort(struct scsi_cmnd * cmd) 972 { 973 int rc; 974 975 spin_lock_irq(cmd->device->host->host_lock); 976 rc = qla1280_error_action(cmd, ABORT_COMMAND); 977 spin_unlock_irq(cmd->device->host->host_lock); 978 979 return rc; 980 } 981 982 /************************************************************************** 983 * qla1280_device_reset 984 * Reset the specified SCSI device 985 **************************************************************************/ 986 static int 987 qla1280_eh_device_reset(struct scsi_cmnd *cmd) 988 { 989 int rc; 990 991 spin_lock_irq(cmd->device->host->host_lock); 992 rc = qla1280_error_action(cmd, DEVICE_RESET); 993 spin_unlock_irq(cmd->device->host->host_lock); 994 995 return rc; 996 } 997 998 /************************************************************************** 999 * qla1280_bus_reset 1000 * Reset the specified bus. 1001 **************************************************************************/ 1002 static int 1003 qla1280_eh_bus_reset(struct scsi_cmnd *cmd) 1004 { 1005 int rc; 1006 1007 spin_lock_irq(cmd->device->host->host_lock); 1008 rc = qla1280_error_action(cmd, BUS_RESET); 1009 spin_unlock_irq(cmd->device->host->host_lock); 1010 1011 return rc; 1012 } 1013 1014 /************************************************************************** 1015 * qla1280_adapter_reset 1016 * Reset the specified adapter (both channels) 1017 **************************************************************************/ 1018 static int 1019 qla1280_eh_adapter_reset(struct scsi_cmnd *cmd) 1020 { 1021 int rc; 1022 1023 spin_lock_irq(cmd->device->host->host_lock); 1024 rc = qla1280_error_action(cmd, ADAPTER_RESET); 1025 spin_unlock_irq(cmd->device->host->host_lock); 1026 1027 return rc; 1028 } 1029 1030 static int 1031 qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev, 1032 sector_t capacity, int geom[]) 1033 { 1034 int heads, sectors, cylinders; 1035 1036 heads = 64; 1037 sectors = 32; 1038 cylinders = (unsigned long)capacity / (heads * sectors); 1039 if (cylinders > 1024) { 1040 heads = 255; 1041 sectors = 63; 1042 cylinders = (unsigned long)capacity / (heads * sectors); 1043 /* if (cylinders > 1023) 1044 cylinders = 1023; */ 1045 } 1046 1047 geom[0] = heads; 1048 geom[1] = sectors; 1049 geom[2] = cylinders; 1050 1051 return 0; 1052 } 1053 1054 1055 /* disable risc and host interrupts */ 1056 static inline void 1057 qla1280_disable_intrs(struct scsi_qla_host *ha) 1058 { 1059 WRT_REG_WORD(&ha->iobase->ictrl, 0); 1060 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */ 1061 } 1062 1063 /* enable risc and host interrupts */ 1064 static inline void 1065 qla1280_enable_intrs(struct scsi_qla_host *ha) 1066 { 1067 WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC)); 1068 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */ 1069 } 1070 1071 /************************************************************************** 1072 * qla1280_intr_handler 1073 * Handles the H/W interrupt 1074 **************************************************************************/ 1075 static irqreturn_t 1076 qla1280_intr_handler(int irq, void *dev_id) 1077 { 1078 struct scsi_qla_host *ha; 1079 struct device_reg __iomem *reg; 1080 u16 data; 1081 int handled = 0; 1082 1083 ENTER_INTR ("qla1280_intr_handler"); 1084 ha = (struct scsi_qla_host *)dev_id; 1085 1086 spin_lock(ha->host->host_lock); 1087 1088 ha->isr_count++; 1089 reg = ha->iobase; 1090 1091 qla1280_disable_intrs(ha); 1092 1093 data = qla1280_debounce_register(®->istatus); 1094 /* Check for pending interrupts. */ 1095 if (data & RISC_INT) { 1096 qla1280_isr(ha, &ha->done_q); 1097 handled = 1; 1098 } 1099 if (!list_empty(&ha->done_q)) 1100 qla1280_done(ha); 1101 1102 spin_unlock(ha->host->host_lock); 1103 1104 qla1280_enable_intrs(ha); 1105 1106 LEAVE_INTR("qla1280_intr_handler"); 1107 return IRQ_RETVAL(handled); 1108 } 1109 1110 1111 static int 1112 qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target) 1113 { 1114 uint8_t mr; 1115 uint16_t mb[MAILBOX_REGISTER_COUNT]; 1116 struct nvram *nv; 1117 int status, lun; 1118 1119 nv = &ha->nvram; 1120 1121 mr = BIT_3 | BIT_2 | BIT_1 | BIT_0; 1122 1123 /* Set Target Parameters. */ 1124 mb[0] = MBC_SET_TARGET_PARAMETERS; 1125 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8); 1126 mb[2] = nv->bus[bus].target[target].parameter.renegotiate_on_error << 8; 1127 mb[2] |= nv->bus[bus].target[target].parameter.stop_queue_on_check << 9; 1128 mb[2] |= nv->bus[bus].target[target].parameter.auto_request_sense << 10; 1129 mb[2] |= nv->bus[bus].target[target].parameter.tag_queuing << 11; 1130 mb[2] |= nv->bus[bus].target[target].parameter.enable_sync << 12; 1131 mb[2] |= nv->bus[bus].target[target].parameter.enable_wide << 13; 1132 mb[2] |= nv->bus[bus].target[target].parameter.parity_checking << 14; 1133 mb[2] |= nv->bus[bus].target[target].parameter.disconnect_allowed << 15; 1134 1135 if (IS_ISP1x160(ha)) { 1136 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5; 1137 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8); 1138 mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) | 1139 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width; 1140 mr |= BIT_6; 1141 } else { 1142 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8); 1143 } 1144 mb[3] |= nv->bus[bus].target[target].sync_period; 1145 1146 status = qla1280_mailbox_command(ha, mr, mb); 1147 1148 /* Set Device Queue Parameters. */ 1149 for (lun = 0; lun < MAX_LUNS; lun++) { 1150 mb[0] = MBC_SET_DEVICE_QUEUE; 1151 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8); 1152 mb[1] |= lun; 1153 mb[2] = nv->bus[bus].max_queue_depth; 1154 mb[3] = nv->bus[bus].target[target].execution_throttle; 1155 status |= qla1280_mailbox_command(ha, 0x0f, mb); 1156 } 1157 1158 if (status) 1159 printk(KERN_WARNING "scsi(%ld:%i:%i): " 1160 "qla1280_set_target_parameters() failed\n", 1161 ha->host_no, bus, target); 1162 return status; 1163 } 1164 1165 1166 /************************************************************************** 1167 * qla1280_slave_configure 1168 * 1169 * Description: 1170 * Determines the queue depth for a given device. There are two ways 1171 * a queue depth can be obtained for a tagged queueing device. One 1172 * way is the default queue depth which is determined by whether 1173 * If it is defined, then it is used 1174 * as the default queue depth. Otherwise, we use either 4 or 8 as the 1175 * default queue depth (dependent on the number of hardware SCBs). 1176 **************************************************************************/ 1177 static int 1178 qla1280_slave_configure(struct scsi_device *device) 1179 { 1180 struct scsi_qla_host *ha; 1181 int default_depth = 3; 1182 int bus = device->channel; 1183 int target = device->id; 1184 int status = 0; 1185 struct nvram *nv; 1186 unsigned long flags; 1187 1188 ha = (struct scsi_qla_host *)device->host->hostdata; 1189 nv = &ha->nvram; 1190 1191 if (qla1280_check_for_dead_scsi_bus(ha, bus)) 1192 return 1; 1193 1194 if (device->tagged_supported && 1195 (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) { 1196 scsi_change_queue_depth(device, ha->bus_settings[bus].hiwat); 1197 } else { 1198 scsi_change_queue_depth(device, default_depth); 1199 } 1200 1201 nv->bus[bus].target[target].parameter.enable_sync = device->sdtr; 1202 nv->bus[bus].target[target].parameter.enable_wide = device->wdtr; 1203 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr; 1204 1205 if (driver_setup.no_sync || 1206 (driver_setup.sync_mask && 1207 (~driver_setup.sync_mask & (1 << target)))) 1208 nv->bus[bus].target[target].parameter.enable_sync = 0; 1209 if (driver_setup.no_wide || 1210 (driver_setup.wide_mask && 1211 (~driver_setup.wide_mask & (1 << target)))) 1212 nv->bus[bus].target[target].parameter.enable_wide = 0; 1213 if (IS_ISP1x160(ha)) { 1214 if (driver_setup.no_ppr || 1215 (driver_setup.ppr_mask && 1216 (~driver_setup.ppr_mask & (1 << target)))) 1217 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0; 1218 } 1219 1220 spin_lock_irqsave(ha->host->host_lock, flags); 1221 if (nv->bus[bus].target[target].parameter.enable_sync) 1222 status = qla1280_set_target_parameters(ha, bus, target); 1223 qla1280_get_target_parameters(ha, device); 1224 spin_unlock_irqrestore(ha->host->host_lock, flags); 1225 return status; 1226 } 1227 1228 1229 /* 1230 * qla1280_done 1231 * Process completed commands. 1232 * 1233 * Input: 1234 * ha = adapter block pointer. 1235 */ 1236 static void 1237 qla1280_done(struct scsi_qla_host *ha) 1238 { 1239 struct srb *sp; 1240 struct list_head *done_q; 1241 int bus, target; 1242 struct scsi_cmnd *cmd; 1243 1244 ENTER("qla1280_done"); 1245 1246 done_q = &ha->done_q; 1247 1248 while (!list_empty(done_q)) { 1249 sp = list_entry(done_q->next, struct srb, list); 1250 1251 list_del(&sp->list); 1252 1253 cmd = sp->cmd; 1254 bus = SCSI_BUS_32(cmd); 1255 target = SCSI_TCN_32(cmd); 1256 1257 switch ((CMD_RESULT(cmd) >> 16)) { 1258 case DID_RESET: 1259 /* Issue marker command. */ 1260 if (!ha->flags.abort_isp_active) 1261 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID); 1262 break; 1263 case DID_ABORT: 1264 sp->flags &= ~SRB_ABORT_PENDING; 1265 sp->flags |= SRB_ABORTED; 1266 break; 1267 default: 1268 break; 1269 } 1270 1271 /* Release memory used for this I/O */ 1272 scsi_dma_unmap(cmd); 1273 1274 /* Call the mid-level driver interrupt handler */ 1275 ha->actthreads--; 1276 1277 if (sp->wait == NULL) 1278 scsi_done(cmd); 1279 else 1280 complete(sp->wait); 1281 } 1282 LEAVE("qla1280_done"); 1283 } 1284 1285 /* 1286 * Translates a ISP error to a Linux SCSI error 1287 */ 1288 static int 1289 qla1280_return_status(struct response * sts, struct scsi_cmnd *cp) 1290 { 1291 int host_status = DID_ERROR; 1292 uint16_t comp_status = le16_to_cpu(sts->comp_status); 1293 uint16_t state_flags = le16_to_cpu(sts->state_flags); 1294 uint32_t residual_length = le32_to_cpu(sts->residual_length); 1295 uint16_t scsi_status = le16_to_cpu(sts->scsi_status); 1296 #if DEBUG_QLA1280_INTR 1297 static char *reason[] = { 1298 "DID_OK", 1299 "DID_NO_CONNECT", 1300 "DID_BUS_BUSY", 1301 "DID_TIME_OUT", 1302 "DID_BAD_TARGET", 1303 "DID_ABORT", 1304 "DID_PARITY", 1305 "DID_ERROR", 1306 "DID_RESET", 1307 "DID_BAD_INTR" 1308 }; 1309 #endif /* DEBUG_QLA1280_INTR */ 1310 1311 ENTER("qla1280_return_status"); 1312 1313 #if DEBUG_QLA1280_INTR 1314 /* 1315 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n", 1316 comp_status); 1317 */ 1318 #endif 1319 1320 switch (comp_status) { 1321 case CS_COMPLETE: 1322 host_status = DID_OK; 1323 break; 1324 1325 case CS_INCOMPLETE: 1326 if (!(state_flags & SF_GOT_BUS)) 1327 host_status = DID_NO_CONNECT; 1328 else if (!(state_flags & SF_GOT_TARGET)) 1329 host_status = DID_BAD_TARGET; 1330 else if (!(state_flags & SF_SENT_CDB)) 1331 host_status = DID_ERROR; 1332 else if (!(state_flags & SF_TRANSFERRED_DATA)) 1333 host_status = DID_ERROR; 1334 else if (!(state_flags & SF_GOT_STATUS)) 1335 host_status = DID_ERROR; 1336 else if (!(state_flags & SF_GOT_SENSE)) 1337 host_status = DID_ERROR; 1338 break; 1339 1340 case CS_RESET: 1341 host_status = DID_RESET; 1342 break; 1343 1344 case CS_ABORTED: 1345 host_status = DID_ABORT; 1346 break; 1347 1348 case CS_TIMEOUT: 1349 host_status = DID_TIME_OUT; 1350 break; 1351 1352 case CS_DATA_OVERRUN: 1353 dprintk(2, "Data overrun 0x%x\n", residual_length); 1354 dprintk(2, "qla1280_return_status: response packet data\n"); 1355 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE); 1356 host_status = DID_ERROR; 1357 break; 1358 1359 case CS_DATA_UNDERRUN: 1360 if ((scsi_bufflen(cp) - residual_length) < 1361 cp->underflow) { 1362 printk(KERN_WARNING 1363 "scsi: Underflow detected - retrying " 1364 "command.\n"); 1365 host_status = DID_ERROR; 1366 } else { 1367 scsi_set_resid(cp, residual_length); 1368 host_status = DID_OK; 1369 } 1370 break; 1371 1372 default: 1373 host_status = DID_ERROR; 1374 break; 1375 } 1376 1377 #if DEBUG_QLA1280_INTR 1378 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n", 1379 reason[host_status], scsi_status); 1380 #endif 1381 1382 LEAVE("qla1280_return_status"); 1383 1384 return (scsi_status & 0xff) | (host_status << 16); 1385 } 1386 1387 /****************************************************************************/ 1388 /* QLogic ISP1280 Hardware Support Functions. */ 1389 /****************************************************************************/ 1390 1391 /* 1392 * qla1280_initialize_adapter 1393 * Initialize board. 1394 * 1395 * Input: 1396 * ha = adapter block pointer. 1397 * 1398 * Returns: 1399 * 0 = success 1400 */ 1401 static int 1402 qla1280_initialize_adapter(struct scsi_qla_host *ha) 1403 { 1404 struct device_reg __iomem *reg; 1405 int status; 1406 int bus; 1407 unsigned long flags; 1408 1409 ENTER("qla1280_initialize_adapter"); 1410 1411 /* Clear adapter flags. */ 1412 ha->flags.online = 0; 1413 ha->flags.disable_host_adapter = 0; 1414 ha->flags.reset_active = 0; 1415 ha->flags.abort_isp_active = 0; 1416 1417 /* TODO: implement support for the 1040 nvram format */ 1418 if (IS_ISP1040(ha)) 1419 driver_setup.no_nvram = 1; 1420 1421 dprintk(1, "Configure PCI space for adapter...\n"); 1422 1423 reg = ha->iobase; 1424 1425 /* Insure mailbox registers are free. */ 1426 WRT_REG_WORD(®->semaphore, 0); 1427 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT); 1428 WRT_REG_WORD(®->host_cmd, HC_CLR_HOST_INT); 1429 RD_REG_WORD(®->host_cmd); 1430 1431 if (qla1280_read_nvram(ha)) { 1432 dprintk(2, "qla1280_initialize_adapter: failed to read " 1433 "NVRAM\n"); 1434 } 1435 1436 /* 1437 * It's necessary to grab the spin here as qla1280_mailbox_command 1438 * needs to be able to drop the lock unconditionally to wait 1439 * for completion. 1440 */ 1441 spin_lock_irqsave(ha->host->host_lock, flags); 1442 1443 status = qla1280_load_firmware(ha); 1444 if (status) { 1445 printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n", 1446 ha->host_no); 1447 goto out; 1448 } 1449 1450 /* Setup adapter based on NVRAM parameters. */ 1451 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no); 1452 qla1280_nvram_config(ha); 1453 1454 if (ha->flags.disable_host_adapter) { 1455 status = 1; 1456 goto out; 1457 } 1458 1459 status = qla1280_init_rings(ha); 1460 if (status) 1461 goto out; 1462 1463 /* Issue SCSI reset, if we can't reset twice then bus is dead */ 1464 for (bus = 0; bus < ha->ports; bus++) { 1465 if (!ha->bus_settings[bus].disable_scsi_reset && 1466 qla1280_bus_reset(ha, bus) && 1467 qla1280_bus_reset(ha, bus)) 1468 ha->bus_settings[bus].scsi_bus_dead = 1; 1469 } 1470 1471 ha->flags.online = 1; 1472 out: 1473 spin_unlock_irqrestore(ha->host->host_lock, flags); 1474 1475 if (status) 1476 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n"); 1477 1478 LEAVE("qla1280_initialize_adapter"); 1479 return status; 1480 } 1481 1482 /* 1483 * qla1280_request_firmware 1484 * Acquire firmware for chip. Retain in memory 1485 * for error recovery. 1486 * 1487 * Input: 1488 * ha = adapter block pointer. 1489 * 1490 * Returns: 1491 * Pointer to firmware image or an error code 1492 * cast to pointer via ERR_PTR(). 1493 */ 1494 static const struct firmware * 1495 qla1280_request_firmware(struct scsi_qla_host *ha) 1496 { 1497 const struct firmware *fw; 1498 int err; 1499 int index; 1500 char *fwname; 1501 1502 spin_unlock_irq(ha->host->host_lock); 1503 mutex_lock(&qla1280_firmware_mutex); 1504 1505 index = ql1280_board_tbl[ha->devnum].fw_index; 1506 fw = qla1280_fw_tbl[index].fw; 1507 if (fw) 1508 goto out; 1509 1510 fwname = qla1280_fw_tbl[index].fwname; 1511 err = request_firmware(&fw, fwname, &ha->pdev->dev); 1512 1513 if (err) { 1514 printk(KERN_ERR "Failed to load image \"%s\" err %d\n", 1515 fwname, err); 1516 fw = ERR_PTR(err); 1517 goto unlock; 1518 } 1519 if ((fw->size % 2) || (fw->size < 6)) { 1520 printk(KERN_ERR "Invalid firmware length %zu in image \"%s\"\n", 1521 fw->size, fwname); 1522 release_firmware(fw); 1523 fw = ERR_PTR(-EINVAL); 1524 goto unlock; 1525 } 1526 1527 qla1280_fw_tbl[index].fw = fw; 1528 1529 out: 1530 ha->fwver1 = fw->data[0]; 1531 ha->fwver2 = fw->data[1]; 1532 ha->fwver3 = fw->data[2]; 1533 unlock: 1534 mutex_unlock(&qla1280_firmware_mutex); 1535 spin_lock_irq(ha->host->host_lock); 1536 return fw; 1537 } 1538 1539 /* 1540 * Chip diagnostics 1541 * Test chip for proper operation. 1542 * 1543 * Input: 1544 * ha = adapter block pointer. 1545 * 1546 * Returns: 1547 * 0 = success. 1548 */ 1549 static int 1550 qla1280_chip_diag(struct scsi_qla_host *ha) 1551 { 1552 uint16_t mb[MAILBOX_REGISTER_COUNT]; 1553 struct device_reg __iomem *reg = ha->iobase; 1554 int status = 0; 1555 int cnt; 1556 uint16_t data; 1557 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", ®->id_l); 1558 1559 dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no); 1560 1561 /* Soft reset chip and wait for it to finish. */ 1562 WRT_REG_WORD(®->ictrl, ISP_RESET); 1563 1564 /* 1565 * We can't do a traditional PCI write flush here by reading 1566 * back the register. The card will not respond once the reset 1567 * is in action and we end up with a machine check exception 1568 * instead. Nothing to do but wait and hope for the best. 1569 * A portable pci_write_flush(pdev) call would be very useful here. 1570 */ 1571 udelay(20); 1572 data = qla1280_debounce_register(®->ictrl); 1573 /* 1574 * Yet another QLogic gem ;-( 1575 */ 1576 for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) { 1577 udelay(5); 1578 data = RD_REG_WORD(®->ictrl); 1579 } 1580 1581 if (!cnt) 1582 goto fail; 1583 1584 /* Reset register cleared by chip reset. */ 1585 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n"); 1586 1587 WRT_REG_WORD(®->cfg_1, 0); 1588 1589 /* Reset RISC and disable BIOS which 1590 allows RISC to execute out of RAM. */ 1591 WRT_REG_WORD(®->host_cmd, HC_RESET_RISC | 1592 HC_RELEASE_RISC | HC_DISABLE_BIOS); 1593 1594 RD_REG_WORD(®->id_l); /* Flush PCI write */ 1595 data = qla1280_debounce_register(®->mailbox0); 1596 1597 /* 1598 * I *LOVE* this code! 1599 */ 1600 for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) { 1601 udelay(5); 1602 data = RD_REG_WORD(®->mailbox0); 1603 } 1604 1605 if (!cnt) 1606 goto fail; 1607 1608 /* Check product ID of chip */ 1609 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n"); 1610 1611 if (RD_REG_WORD(®->mailbox1) != PROD_ID_1 || 1612 (RD_REG_WORD(®->mailbox2) != PROD_ID_2 && 1613 RD_REG_WORD(®->mailbox2) != PROD_ID_2a) || 1614 RD_REG_WORD(®->mailbox3) != PROD_ID_3 || 1615 RD_REG_WORD(®->mailbox4) != PROD_ID_4) { 1616 printk(KERN_INFO "qla1280: Wrong product ID = " 1617 "0x%x,0x%x,0x%x,0x%x\n", 1618 RD_REG_WORD(®->mailbox1), 1619 RD_REG_WORD(®->mailbox2), 1620 RD_REG_WORD(®->mailbox3), 1621 RD_REG_WORD(®->mailbox4)); 1622 goto fail; 1623 } 1624 1625 /* 1626 * Enable ints early!!! 1627 */ 1628 qla1280_enable_intrs(ha); 1629 1630 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n"); 1631 /* Wrap Incoming Mailboxes Test. */ 1632 mb[0] = MBC_MAILBOX_REGISTER_TEST; 1633 mb[1] = 0xAAAA; 1634 mb[2] = 0x5555; 1635 mb[3] = 0xAA55; 1636 mb[4] = 0x55AA; 1637 mb[5] = 0xA5A5; 1638 mb[6] = 0x5A5A; 1639 mb[7] = 0x2525; 1640 1641 status = qla1280_mailbox_command(ha, 0xff, mb); 1642 if (status) 1643 goto fail; 1644 1645 if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 || 1646 mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A || 1647 mb[7] != 0x2525) { 1648 printk(KERN_INFO "qla1280: Failed mbox check\n"); 1649 goto fail; 1650 } 1651 1652 dprintk(3, "qla1280_chip_diag: exiting normally\n"); 1653 return 0; 1654 fail: 1655 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n"); 1656 return status; 1657 } 1658 1659 static int 1660 qla1280_load_firmware_pio(struct scsi_qla_host *ha) 1661 { 1662 /* enter with host_lock acquired */ 1663 1664 const struct firmware *fw; 1665 const __le16 *fw_data; 1666 uint16_t risc_address, risc_code_size; 1667 uint16_t mb[MAILBOX_REGISTER_COUNT], i; 1668 int err = 0; 1669 1670 fw = qla1280_request_firmware(ha); 1671 if (IS_ERR(fw)) 1672 return PTR_ERR(fw); 1673 1674 fw_data = (const __le16 *)&fw->data[0]; 1675 ha->fwstart = __le16_to_cpu(fw_data[2]); 1676 1677 /* Load RISC code. */ 1678 risc_address = ha->fwstart; 1679 fw_data = (const __le16 *)&fw->data[6]; 1680 risc_code_size = (fw->size - 6) / 2; 1681 1682 for (i = 0; i < risc_code_size; i++) { 1683 mb[0] = MBC_WRITE_RAM_WORD; 1684 mb[1] = risc_address + i; 1685 mb[2] = __le16_to_cpu(fw_data[i]); 1686 1687 err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb); 1688 if (err) { 1689 printk(KERN_ERR "scsi(%li): Failed to load firmware\n", 1690 ha->host_no); 1691 break; 1692 } 1693 } 1694 1695 return err; 1696 } 1697 1698 #ifdef QLA_64BIT_PTR 1699 #define LOAD_CMD MBC_LOAD_RAM_A64_ROM 1700 #define DUMP_CMD MBC_DUMP_RAM_A64_ROM 1701 #define CMD_ARGS (BIT_7 | BIT_6 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0) 1702 #else 1703 #define LOAD_CMD MBC_LOAD_RAM 1704 #define DUMP_CMD MBC_DUMP_RAM 1705 #define CMD_ARGS (BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0) 1706 #endif 1707 1708 #define DUMP_IT_BACK 0 /* for debug of RISC loading */ 1709 static int 1710 qla1280_load_firmware_dma(struct scsi_qla_host *ha) 1711 { 1712 /* enter with host_lock acquired */ 1713 const struct firmware *fw; 1714 const __le16 *fw_data; 1715 uint16_t risc_address, risc_code_size; 1716 uint16_t mb[MAILBOX_REGISTER_COUNT], cnt; 1717 int err = 0, num, i; 1718 #if DUMP_IT_BACK 1719 uint8_t *sp, *tbuf; 1720 dma_addr_t p_tbuf; 1721 1722 tbuf = dma_alloc_coherent(&ha->pdev->dev, 8000, &p_tbuf, GFP_KERNEL); 1723 if (!tbuf) 1724 return -ENOMEM; 1725 #endif 1726 1727 fw = qla1280_request_firmware(ha); 1728 if (IS_ERR(fw)) 1729 return PTR_ERR(fw); 1730 1731 fw_data = (const __le16 *)&fw->data[0]; 1732 ha->fwstart = __le16_to_cpu(fw_data[2]); 1733 1734 /* Load RISC code. */ 1735 risc_address = ha->fwstart; 1736 fw_data = (const __le16 *)&fw->data[6]; 1737 risc_code_size = (fw->size - 6) / 2; 1738 1739 dprintk(1, "%s: DMA RISC code (%i) words\n", 1740 __func__, risc_code_size); 1741 1742 num = 0; 1743 while (risc_code_size > 0) { 1744 int warn __attribute__((unused)) = 0; 1745 1746 cnt = 2000 >> 1; 1747 1748 if (cnt > risc_code_size) 1749 cnt = risc_code_size; 1750 1751 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p)," 1752 "%d,%d(0x%x)\n", 1753 fw_data, cnt, num, risc_address); 1754 for(i = 0; i < cnt; i++) 1755 ((__le16 *)ha->request_ring)[i] = fw_data[i]; 1756 1757 mb[0] = LOAD_CMD; 1758 mb[1] = risc_address; 1759 mb[4] = cnt; 1760 mb[3] = ha->request_dma & 0xffff; 1761 mb[2] = (ha->request_dma >> 16) & 0xffff; 1762 mb[7] = upper_32_bits(ha->request_dma) & 0xffff; 1763 mb[6] = upper_32_bits(ha->request_dma) >> 16; 1764 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n", 1765 __func__, mb[0], 1766 (void *)(long)ha->request_dma, 1767 mb[6], mb[7], mb[2], mb[3]); 1768 err = qla1280_mailbox_command(ha, CMD_ARGS, mb); 1769 if (err) { 1770 printk(KERN_ERR "scsi(%li): Failed to load partial " 1771 "segment of f\n", ha->host_no); 1772 goto out; 1773 } 1774 1775 #if DUMP_IT_BACK 1776 mb[0] = DUMP_CMD; 1777 mb[1] = risc_address; 1778 mb[4] = cnt; 1779 mb[3] = p_tbuf & 0xffff; 1780 mb[2] = (p_tbuf >> 16) & 0xffff; 1781 mb[7] = upper_32_bits(p_tbuf) & 0xffff; 1782 mb[6] = upper_32_bits(p_tbuf) >> 16; 1783 1784 err = qla1280_mailbox_command(ha, CMD_ARGS, mb); 1785 if (err) { 1786 printk(KERN_ERR 1787 "Failed to dump partial segment of f/w\n"); 1788 goto out; 1789 } 1790 sp = (uint8_t *)ha->request_ring; 1791 for (i = 0; i < (cnt << 1); i++) { 1792 if (tbuf[i] != sp[i] && warn++ < 10) { 1793 printk(KERN_ERR "%s: FW compare error @ " 1794 "byte(0x%x) loop#=%x\n", 1795 __func__, i, num); 1796 printk(KERN_ERR "%s: FWbyte=%x " 1797 "FWfromChip=%x\n", 1798 __func__, sp[i], tbuf[i]); 1799 /*break; */ 1800 } 1801 } 1802 #endif 1803 risc_address += cnt; 1804 risc_code_size = risc_code_size - cnt; 1805 fw_data = fw_data + cnt; 1806 num++; 1807 } 1808 1809 out: 1810 #if DUMP_IT_BACK 1811 dma_free_coherent(&ha->pdev->dev, 8000, tbuf, p_tbuf); 1812 #endif 1813 return err; 1814 } 1815 1816 static int 1817 qla1280_start_firmware(struct scsi_qla_host *ha) 1818 { 1819 uint16_t mb[MAILBOX_REGISTER_COUNT]; 1820 int err; 1821 1822 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n", 1823 __func__); 1824 1825 /* Verify checksum of loaded RISC code. */ 1826 mb[0] = MBC_VERIFY_CHECKSUM; 1827 /* mb[1] = ql12_risc_code_addr01; */ 1828 mb[1] = ha->fwstart; 1829 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb); 1830 if (err) { 1831 printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no); 1832 return err; 1833 } 1834 1835 /* Start firmware execution. */ 1836 dprintk(1, "%s: start firmware running.\n", __func__); 1837 mb[0] = MBC_EXECUTE_FIRMWARE; 1838 mb[1] = ha->fwstart; 1839 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]); 1840 if (err) { 1841 printk(KERN_ERR "scsi(%li): Failed to start firmware\n", 1842 ha->host_no); 1843 } 1844 1845 return err; 1846 } 1847 1848 static int 1849 qla1280_load_firmware(struct scsi_qla_host *ha) 1850 { 1851 /* enter with host_lock taken */ 1852 int err; 1853 1854 err = qla1280_chip_diag(ha); 1855 if (err) 1856 goto out; 1857 if (IS_ISP1040(ha)) 1858 err = qla1280_load_firmware_pio(ha); 1859 else 1860 err = qla1280_load_firmware_dma(ha); 1861 if (err) 1862 goto out; 1863 err = qla1280_start_firmware(ha); 1864 out: 1865 return err; 1866 } 1867 1868 /* 1869 * Initialize rings 1870 * 1871 * Input: 1872 * ha = adapter block pointer. 1873 * ha->request_ring = request ring virtual address 1874 * ha->response_ring = response ring virtual address 1875 * ha->request_dma = request ring physical address 1876 * ha->response_dma = response ring physical address 1877 * 1878 * Returns: 1879 * 0 = success. 1880 */ 1881 static int 1882 qla1280_init_rings(struct scsi_qla_host *ha) 1883 { 1884 uint16_t mb[MAILBOX_REGISTER_COUNT]; 1885 int status = 0; 1886 1887 ENTER("qla1280_init_rings"); 1888 1889 /* Clear outstanding commands array. */ 1890 memset(ha->outstanding_cmds, 0, 1891 sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS); 1892 1893 /* Initialize request queue. */ 1894 ha->request_ring_ptr = ha->request_ring; 1895 ha->req_ring_index = 0; 1896 ha->req_q_cnt = REQUEST_ENTRY_CNT; 1897 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */ 1898 mb[0] = MBC_INIT_REQUEST_QUEUE_A64; 1899 mb[1] = REQUEST_ENTRY_CNT; 1900 mb[3] = ha->request_dma & 0xffff; 1901 mb[2] = (ha->request_dma >> 16) & 0xffff; 1902 mb[4] = 0; 1903 mb[7] = upper_32_bits(ha->request_dma) & 0xffff; 1904 mb[6] = upper_32_bits(ha->request_dma) >> 16; 1905 if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 | 1906 BIT_3 | BIT_2 | BIT_1 | BIT_0, 1907 &mb[0]))) { 1908 /* Initialize response queue. */ 1909 ha->response_ring_ptr = ha->response_ring; 1910 ha->rsp_ring_index = 0; 1911 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */ 1912 mb[0] = MBC_INIT_RESPONSE_QUEUE_A64; 1913 mb[1] = RESPONSE_ENTRY_CNT; 1914 mb[3] = ha->response_dma & 0xffff; 1915 mb[2] = (ha->response_dma >> 16) & 0xffff; 1916 mb[5] = 0; 1917 mb[7] = upper_32_bits(ha->response_dma) & 0xffff; 1918 mb[6] = upper_32_bits(ha->response_dma) >> 16; 1919 status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 | 1920 BIT_3 | BIT_2 | BIT_1 | BIT_0, 1921 &mb[0]); 1922 } 1923 1924 if (status) 1925 dprintk(2, "qla1280_init_rings: **** FAILED ****\n"); 1926 1927 LEAVE("qla1280_init_rings"); 1928 return status; 1929 } 1930 1931 static void 1932 qla1280_print_settings(struct nvram *nv) 1933 { 1934 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n", 1935 nv->bus[0].config_1.initiator_id); 1936 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n", 1937 nv->bus[1].config_1.initiator_id); 1938 1939 dprintk(1, "qla1280 : bus reset delay[0]=%d\n", 1940 nv->bus[0].bus_reset_delay); 1941 dprintk(1, "qla1280 : bus reset delay[1]=%d\n", 1942 nv->bus[1].bus_reset_delay); 1943 1944 dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count); 1945 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay); 1946 dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count); 1947 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay); 1948 1949 dprintk(1, "qla1280 : async data setup time[0]=%d\n", 1950 nv->bus[0].config_2.async_data_setup_time); 1951 dprintk(1, "qla1280 : async data setup time[1]=%d\n", 1952 nv->bus[1].config_2.async_data_setup_time); 1953 1954 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n", 1955 nv->bus[0].config_2.req_ack_active_negation); 1956 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n", 1957 nv->bus[1].config_2.req_ack_active_negation); 1958 1959 dprintk(1, "qla1280 : data line active negation[0]=%d\n", 1960 nv->bus[0].config_2.data_line_active_negation); 1961 dprintk(1, "qla1280 : data line active negation[1]=%d\n", 1962 nv->bus[1].config_2.data_line_active_negation); 1963 1964 dprintk(1, "qla1280 : disable loading risc code=%d\n", 1965 nv->cntr_flags_1.disable_loading_risc_code); 1966 1967 dprintk(1, "qla1280 : enable 64bit addressing=%d\n", 1968 nv->cntr_flags_1.enable_64bit_addressing); 1969 1970 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n", 1971 nv->bus[0].selection_timeout); 1972 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n", 1973 nv->bus[1].selection_timeout); 1974 1975 dprintk(1, "qla1280 : max queue depth[0]=%d\n", 1976 nv->bus[0].max_queue_depth); 1977 dprintk(1, "qla1280 : max queue depth[1]=%d\n", 1978 nv->bus[1].max_queue_depth); 1979 } 1980 1981 static void 1982 qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target) 1983 { 1984 struct nvram *nv = &ha->nvram; 1985 1986 nv->bus[bus].target[target].parameter.renegotiate_on_error = 1; 1987 nv->bus[bus].target[target].parameter.auto_request_sense = 1; 1988 nv->bus[bus].target[target].parameter.tag_queuing = 1; 1989 nv->bus[bus].target[target].parameter.enable_sync = 1; 1990 #if 1 /* Some SCSI Processors do not seem to like this */ 1991 nv->bus[bus].target[target].parameter.enable_wide = 1; 1992 #endif 1993 nv->bus[bus].target[target].execution_throttle = 1994 nv->bus[bus].max_queue_depth - 1; 1995 nv->bus[bus].target[target].parameter.parity_checking = 1; 1996 nv->bus[bus].target[target].parameter.disconnect_allowed = 1; 1997 1998 if (IS_ISP1x160(ha)) { 1999 nv->bus[bus].target[target].flags.flags1x160.device_enable = 1; 2000 nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e; 2001 nv->bus[bus].target[target].sync_period = 9; 2002 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1; 2003 nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2; 2004 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1; 2005 } else { 2006 nv->bus[bus].target[target].flags.flags1x80.device_enable = 1; 2007 nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12; 2008 nv->bus[bus].target[target].sync_period = 10; 2009 } 2010 } 2011 2012 static void 2013 qla1280_set_defaults(struct scsi_qla_host *ha) 2014 { 2015 struct nvram *nv = &ha->nvram; 2016 int bus, target; 2017 2018 dprintk(1, "Using defaults for NVRAM: \n"); 2019 memset(nv, 0, sizeof(struct nvram)); 2020 2021 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */ 2022 nv->firmware_feature.f.enable_fast_posting = 1; 2023 nv->firmware_feature.f.disable_synchronous_backoff = 1; 2024 nv->termination.scsi_bus_0_control = 3; 2025 nv->termination.scsi_bus_1_control = 3; 2026 nv->termination.auto_term_support = 1; 2027 2028 /* 2029 * Set default FIFO magic - What appropriate values would be here 2030 * is unknown. This is what I have found testing with 12160s. 2031 * 2032 * Now, I would love the magic decoder ring for this one, the 2033 * header file provided by QLogic seems to be bogus or incomplete 2034 * at best. 2035 */ 2036 nv->isp_config.burst_enable = 1; 2037 if (IS_ISP1040(ha)) 2038 nv->isp_config.fifo_threshold |= 3; 2039 else 2040 nv->isp_config.fifo_threshold |= 4; 2041 2042 if (IS_ISP1x160(ha)) 2043 nv->isp_parameter = 0x01; /* fast memory enable */ 2044 2045 for (bus = 0; bus < MAX_BUSES; bus++) { 2046 nv->bus[bus].config_1.initiator_id = 7; 2047 nv->bus[bus].config_2.req_ack_active_negation = 1; 2048 nv->bus[bus].config_2.data_line_active_negation = 1; 2049 nv->bus[bus].selection_timeout = 250; 2050 nv->bus[bus].max_queue_depth = 32; 2051 2052 if (IS_ISP1040(ha)) { 2053 nv->bus[bus].bus_reset_delay = 3; 2054 nv->bus[bus].config_2.async_data_setup_time = 6; 2055 nv->bus[bus].retry_delay = 1; 2056 } else { 2057 nv->bus[bus].bus_reset_delay = 5; 2058 nv->bus[bus].config_2.async_data_setup_time = 8; 2059 } 2060 2061 for (target = 0; target < MAX_TARGETS; target++) 2062 qla1280_set_target_defaults(ha, bus, target); 2063 } 2064 } 2065 2066 static int 2067 qla1280_config_target(struct scsi_qla_host *ha, int bus, int target) 2068 { 2069 struct nvram *nv = &ha->nvram; 2070 uint16_t mb[MAILBOX_REGISTER_COUNT]; 2071 int status, lun; 2072 uint16_t flag; 2073 2074 /* Set Target Parameters. */ 2075 mb[0] = MBC_SET_TARGET_PARAMETERS; 2076 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8); 2077 2078 /* 2079 * Do not enable sync and ppr for the initial INQUIRY run. We 2080 * enable this later if we determine the target actually 2081 * supports it. 2082 */ 2083 mb[2] = (TP_RENEGOTIATE | TP_AUTO_REQUEST_SENSE | TP_TAGGED_QUEUE 2084 | TP_WIDE | TP_PARITY | TP_DISCONNECT); 2085 2086 if (IS_ISP1x160(ha)) 2087 mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8; 2088 else 2089 mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8; 2090 mb[3] |= nv->bus[bus].target[target].sync_period; 2091 status = qla1280_mailbox_command(ha, 0x0f, mb); 2092 2093 /* Save Tag queuing enable flag. */ 2094 flag = (BIT_0 << target); 2095 if (nv->bus[bus].target[target].parameter.tag_queuing) 2096 ha->bus_settings[bus].qtag_enables |= flag; 2097 2098 /* Save Device enable flag. */ 2099 if (IS_ISP1x160(ha)) { 2100 if (nv->bus[bus].target[target].flags.flags1x160.device_enable) 2101 ha->bus_settings[bus].device_enables |= flag; 2102 ha->bus_settings[bus].lun_disables |= 0; 2103 } else { 2104 if (nv->bus[bus].target[target].flags.flags1x80.device_enable) 2105 ha->bus_settings[bus].device_enables |= flag; 2106 /* Save LUN disable flag. */ 2107 if (nv->bus[bus].target[target].flags.flags1x80.lun_disable) 2108 ha->bus_settings[bus].lun_disables |= flag; 2109 } 2110 2111 /* Set Device Queue Parameters. */ 2112 for (lun = 0; lun < MAX_LUNS; lun++) { 2113 mb[0] = MBC_SET_DEVICE_QUEUE; 2114 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8); 2115 mb[1] |= lun; 2116 mb[2] = nv->bus[bus].max_queue_depth; 2117 mb[3] = nv->bus[bus].target[target].execution_throttle; 2118 status |= qla1280_mailbox_command(ha, 0x0f, mb); 2119 } 2120 2121 return status; 2122 } 2123 2124 static int 2125 qla1280_config_bus(struct scsi_qla_host *ha, int bus) 2126 { 2127 struct nvram *nv = &ha->nvram; 2128 uint16_t mb[MAILBOX_REGISTER_COUNT]; 2129 int target, status; 2130 2131 /* SCSI Reset Disable. */ 2132 ha->bus_settings[bus].disable_scsi_reset = 2133 nv->bus[bus].config_1.scsi_reset_disable; 2134 2135 /* Initiator ID. */ 2136 ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id; 2137 mb[0] = MBC_SET_INITIATOR_ID; 2138 mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 : 2139 ha->bus_settings[bus].id; 2140 status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]); 2141 2142 /* Reset Delay. */ 2143 ha->bus_settings[bus].bus_reset_delay = 2144 nv->bus[bus].bus_reset_delay; 2145 2146 /* Command queue depth per device. */ 2147 ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1; 2148 2149 /* Set target parameters. */ 2150 for (target = 0; target < MAX_TARGETS; target++) 2151 status |= qla1280_config_target(ha, bus, target); 2152 2153 return status; 2154 } 2155 2156 static int 2157 qla1280_nvram_config(struct scsi_qla_host *ha) 2158 { 2159 struct device_reg __iomem *reg = ha->iobase; 2160 struct nvram *nv = &ha->nvram; 2161 int bus, target, status = 0; 2162 uint16_t mb[MAILBOX_REGISTER_COUNT]; 2163 2164 ENTER("qla1280_nvram_config"); 2165 2166 if (ha->nvram_valid) { 2167 /* Always force AUTO sense for LINUX SCSI */ 2168 for (bus = 0; bus < MAX_BUSES; bus++) 2169 for (target = 0; target < MAX_TARGETS; target++) { 2170 nv->bus[bus].target[target].parameter. 2171 auto_request_sense = 1; 2172 } 2173 } else { 2174 qla1280_set_defaults(ha); 2175 } 2176 2177 qla1280_print_settings(nv); 2178 2179 /* Disable RISC load of firmware. */ 2180 ha->flags.disable_risc_code_load = 2181 nv->cntr_flags_1.disable_loading_risc_code; 2182 2183 if (IS_ISP1040(ha)) { 2184 uint16_t hwrev, cfg1, cdma_conf; 2185 2186 hwrev = RD_REG_WORD(®->cfg_0) & ISP_CFG0_HWMSK; 2187 2188 cfg1 = RD_REG_WORD(®->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6); 2189 cdma_conf = RD_REG_WORD(®->cdma_cfg); 2190 2191 /* Busted fifo, says mjacob. */ 2192 if (hwrev != ISP_CFG0_1040A) 2193 cfg1 |= nv->isp_config.fifo_threshold << 4; 2194 2195 cfg1 |= nv->isp_config.burst_enable << 2; 2196 WRT_REG_WORD(®->cfg_1, cfg1); 2197 2198 WRT_REG_WORD(®->cdma_cfg, cdma_conf | CDMA_CONF_BENAB); 2199 WRT_REG_WORD(®->ddma_cfg, cdma_conf | DDMA_CONF_BENAB); 2200 } else { 2201 uint16_t cfg1, term; 2202 2203 /* Set ISP hardware DMA burst */ 2204 cfg1 = nv->isp_config.fifo_threshold << 4; 2205 cfg1 |= nv->isp_config.burst_enable << 2; 2206 /* Enable DMA arbitration on dual channel controllers */ 2207 if (ha->ports > 1) 2208 cfg1 |= BIT_13; 2209 WRT_REG_WORD(®->cfg_1, cfg1); 2210 2211 /* Set SCSI termination. */ 2212 WRT_REG_WORD(®->gpio_enable, 2213 BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0); 2214 term = nv->termination.scsi_bus_1_control; 2215 term |= nv->termination.scsi_bus_0_control << 2; 2216 term |= nv->termination.auto_term_support << 7; 2217 RD_REG_WORD(®->id_l); /* Flush PCI write */ 2218 WRT_REG_WORD(®->gpio_data, term); 2219 } 2220 RD_REG_WORD(®->id_l); /* Flush PCI write */ 2221 2222 /* ISP parameter word. */ 2223 mb[0] = MBC_SET_SYSTEM_PARAMETER; 2224 mb[1] = nv->isp_parameter; 2225 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]); 2226 2227 if (IS_ISP1x40(ha)) { 2228 /* clock rate - for qla1240 and older, only */ 2229 mb[0] = MBC_SET_CLOCK_RATE; 2230 mb[1] = 40; 2231 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb); 2232 } 2233 2234 /* Firmware feature word. */ 2235 mb[0] = MBC_SET_FIRMWARE_FEATURES; 2236 mb[1] = nv->firmware_feature.f.enable_fast_posting; 2237 mb[1] |= nv->firmware_feature.f.report_lvd_bus_transition << 1; 2238 mb[1] |= nv->firmware_feature.f.disable_synchronous_backoff << 5; 2239 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb); 2240 2241 /* Retry count and delay. */ 2242 mb[0] = MBC_SET_RETRY_COUNT; 2243 mb[1] = nv->bus[0].retry_count; 2244 mb[2] = nv->bus[0].retry_delay; 2245 mb[6] = nv->bus[1].retry_count; 2246 mb[7] = nv->bus[1].retry_delay; 2247 status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 | 2248 BIT_1 | BIT_0, &mb[0]); 2249 2250 /* ASYNC data setup time. */ 2251 mb[0] = MBC_SET_ASYNC_DATA_SETUP; 2252 mb[1] = nv->bus[0].config_2.async_data_setup_time; 2253 mb[2] = nv->bus[1].config_2.async_data_setup_time; 2254 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]); 2255 2256 /* Active negation states. */ 2257 mb[0] = MBC_SET_ACTIVE_NEGATION; 2258 mb[1] = 0; 2259 if (nv->bus[0].config_2.req_ack_active_negation) 2260 mb[1] |= BIT_5; 2261 if (nv->bus[0].config_2.data_line_active_negation) 2262 mb[1] |= BIT_4; 2263 mb[2] = 0; 2264 if (nv->bus[1].config_2.req_ack_active_negation) 2265 mb[2] |= BIT_5; 2266 if (nv->bus[1].config_2.data_line_active_negation) 2267 mb[2] |= BIT_4; 2268 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb); 2269 2270 mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY; 2271 mb[1] = 2; /* Reset SCSI bus and return all outstanding IO */ 2272 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb); 2273 2274 /* thingy */ 2275 mb[0] = MBC_SET_PCI_CONTROL; 2276 mb[1] = BIT_1; /* Data DMA Channel Burst Enable */ 2277 mb[2] = BIT_1; /* Command DMA Channel Burst Enable */ 2278 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb); 2279 2280 mb[0] = MBC_SET_TAG_AGE_LIMIT; 2281 mb[1] = 8; 2282 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb); 2283 2284 /* Selection timeout. */ 2285 mb[0] = MBC_SET_SELECTION_TIMEOUT; 2286 mb[1] = nv->bus[0].selection_timeout; 2287 mb[2] = nv->bus[1].selection_timeout; 2288 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb); 2289 2290 for (bus = 0; bus < ha->ports; bus++) 2291 status |= qla1280_config_bus(ha, bus); 2292 2293 if (status) 2294 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n"); 2295 2296 LEAVE("qla1280_nvram_config"); 2297 return status; 2298 } 2299 2300 /* 2301 * Get NVRAM data word 2302 * Calculates word position in NVRAM and calls request routine to 2303 * get the word from NVRAM. 2304 * 2305 * Input: 2306 * ha = adapter block pointer. 2307 * address = NVRAM word address. 2308 * 2309 * Returns: 2310 * data word. 2311 */ 2312 static uint16_t 2313 qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address) 2314 { 2315 uint32_t nv_cmd; 2316 uint16_t data; 2317 2318 nv_cmd = address << 16; 2319 nv_cmd |= NV_READ_OP; 2320 2321 data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd)); 2322 2323 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = " 2324 "0x%x", data); 2325 2326 return data; 2327 } 2328 2329 /* 2330 * NVRAM request 2331 * Sends read command to NVRAM and gets data from NVRAM. 2332 * 2333 * Input: 2334 * ha = adapter block pointer. 2335 * nv_cmd = Bit 26 = start bit 2336 * Bit 25, 24 = opcode 2337 * Bit 23-16 = address 2338 * Bit 15-0 = write data 2339 * 2340 * Returns: 2341 * data word. 2342 */ 2343 static uint16_t 2344 qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd) 2345 { 2346 struct device_reg __iomem *reg = ha->iobase; 2347 int cnt; 2348 uint16_t data = 0; 2349 uint16_t reg_data; 2350 2351 /* Send command to NVRAM. */ 2352 2353 nv_cmd <<= 5; 2354 for (cnt = 0; cnt < 11; cnt++) { 2355 if (nv_cmd & BIT_31) 2356 qla1280_nv_write(ha, NV_DATA_OUT); 2357 else 2358 qla1280_nv_write(ha, 0); 2359 nv_cmd <<= 1; 2360 } 2361 2362 /* Read data from NVRAM. */ 2363 2364 for (cnt = 0; cnt < 16; cnt++) { 2365 WRT_REG_WORD(®->nvram, (NV_SELECT | NV_CLOCK)); 2366 RD_REG_WORD(®->id_l); /* Flush PCI write */ 2367 NVRAM_DELAY(); 2368 data <<= 1; 2369 reg_data = RD_REG_WORD(®->nvram); 2370 if (reg_data & NV_DATA_IN) 2371 data |= BIT_0; 2372 WRT_REG_WORD(®->nvram, NV_SELECT); 2373 RD_REG_WORD(®->id_l); /* Flush PCI write */ 2374 NVRAM_DELAY(); 2375 } 2376 2377 /* Deselect chip. */ 2378 2379 WRT_REG_WORD(®->nvram, NV_DESELECT); 2380 RD_REG_WORD(®->id_l); /* Flush PCI write */ 2381 NVRAM_DELAY(); 2382 2383 return data; 2384 } 2385 2386 static void 2387 qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data) 2388 { 2389 struct device_reg __iomem *reg = ha->iobase; 2390 2391 WRT_REG_WORD(®->nvram, data | NV_SELECT); 2392 RD_REG_WORD(®->id_l); /* Flush PCI write */ 2393 NVRAM_DELAY(); 2394 WRT_REG_WORD(®->nvram, data | NV_SELECT | NV_CLOCK); 2395 RD_REG_WORD(®->id_l); /* Flush PCI write */ 2396 NVRAM_DELAY(); 2397 WRT_REG_WORD(®->nvram, data | NV_SELECT); 2398 RD_REG_WORD(®->id_l); /* Flush PCI write */ 2399 NVRAM_DELAY(); 2400 } 2401 2402 /* 2403 * Mailbox Command 2404 * Issue mailbox command and waits for completion. 2405 * 2406 * Input: 2407 * ha = adapter block pointer. 2408 * mr = mailbox registers to load. 2409 * mb = data pointer for mailbox registers. 2410 * 2411 * Output: 2412 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data. 2413 * 2414 * Returns: 2415 * 0 = success 2416 */ 2417 static int 2418 qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb) 2419 { 2420 struct device_reg __iomem *reg = ha->iobase; 2421 int status = 0; 2422 int cnt; 2423 uint16_t *optr, *iptr; 2424 uint16_t __iomem *mptr; 2425 DECLARE_COMPLETION_ONSTACK(wait); 2426 2427 ENTER("qla1280_mailbox_command"); 2428 2429 if (ha->mailbox_wait) { 2430 printk(KERN_ERR "Warning mailbox wait already in use!\n"); 2431 } 2432 ha->mailbox_wait = &wait; 2433 2434 /* 2435 * We really should start out by verifying that the mailbox is 2436 * available before starting sending the command data 2437 */ 2438 /* Load mailbox registers. */ 2439 mptr = (uint16_t __iomem *) ®->mailbox0; 2440 iptr = mb; 2441 for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) { 2442 if (mr & BIT_0) { 2443 WRT_REG_WORD(mptr, (*iptr)); 2444 } 2445 2446 mr >>= 1; 2447 mptr++; 2448 iptr++; 2449 } 2450 2451 /* Issue set host interrupt command. */ 2452 2453 /* set up a timer just in case we're really jammed */ 2454 timer_setup(&ha->mailbox_timer, qla1280_mailbox_timeout, 0); 2455 mod_timer(&ha->mailbox_timer, jiffies + 20 * HZ); 2456 2457 spin_unlock_irq(ha->host->host_lock); 2458 WRT_REG_WORD(®->host_cmd, HC_SET_HOST_INT); 2459 qla1280_debounce_register(®->istatus); 2460 2461 wait_for_completion(&wait); 2462 del_timer_sync(&ha->mailbox_timer); 2463 2464 spin_lock_irq(ha->host->host_lock); 2465 2466 ha->mailbox_wait = NULL; 2467 2468 /* Check for mailbox command timeout. */ 2469 if (ha->mailbox_out[0] != MBS_CMD_CMP) { 2470 printk(KERN_WARNING "qla1280_mailbox_command: Command failed, " 2471 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = " 2472 "0x%04x\n", 2473 mb[0], ha->mailbox_out[0], RD_REG_WORD(®->istatus)); 2474 printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n", 2475 RD_REG_WORD(®->mailbox0), RD_REG_WORD(®->mailbox1), 2476 RD_REG_WORD(®->mailbox2), RD_REG_WORD(®->mailbox3)); 2477 printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n", 2478 RD_REG_WORD(®->mailbox4), RD_REG_WORD(®->mailbox5), 2479 RD_REG_WORD(®->mailbox6), RD_REG_WORD(®->mailbox7)); 2480 status = 1; 2481 } 2482 2483 /* Load return mailbox registers. */ 2484 optr = mb; 2485 iptr = (uint16_t *) &ha->mailbox_out[0]; 2486 mr = MAILBOX_REGISTER_COUNT; 2487 memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t)); 2488 2489 if (ha->flags.reset_marker) 2490 qla1280_rst_aen(ha); 2491 2492 if (status) 2493 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = " 2494 "0x%x ****\n", mb[0]); 2495 2496 LEAVE("qla1280_mailbox_command"); 2497 return status; 2498 } 2499 2500 /* 2501 * qla1280_poll 2502 * Polls ISP for interrupts. 2503 * 2504 * Input: 2505 * ha = adapter block pointer. 2506 */ 2507 static void 2508 qla1280_poll(struct scsi_qla_host *ha) 2509 { 2510 struct device_reg __iomem *reg = ha->iobase; 2511 uint16_t data; 2512 LIST_HEAD(done_q); 2513 2514 /* ENTER("qla1280_poll"); */ 2515 2516 /* Check for pending interrupts. */ 2517 data = RD_REG_WORD(®->istatus); 2518 if (data & RISC_INT) 2519 qla1280_isr(ha, &done_q); 2520 2521 if (!ha->mailbox_wait) { 2522 if (ha->flags.reset_marker) 2523 qla1280_rst_aen(ha); 2524 } 2525 2526 if (!list_empty(&done_q)) 2527 qla1280_done(ha); 2528 2529 /* LEAVE("qla1280_poll"); */ 2530 } 2531 2532 /* 2533 * qla1280_bus_reset 2534 * Issue SCSI bus reset. 2535 * 2536 * Input: 2537 * ha = adapter block pointer. 2538 * bus = SCSI bus number. 2539 * 2540 * Returns: 2541 * 0 = success 2542 */ 2543 static int 2544 qla1280_bus_reset(struct scsi_qla_host *ha, int bus) 2545 { 2546 uint16_t mb[MAILBOX_REGISTER_COUNT]; 2547 uint16_t reset_delay; 2548 int status; 2549 2550 dprintk(3, "qla1280_bus_reset: entered\n"); 2551 2552 if (qla1280_verbose) 2553 printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n", 2554 ha->host_no, bus); 2555 2556 reset_delay = ha->bus_settings[bus].bus_reset_delay; 2557 mb[0] = MBC_BUS_RESET; 2558 mb[1] = reset_delay; 2559 mb[2] = (uint16_t) bus; 2560 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]); 2561 2562 if (status) { 2563 if (ha->bus_settings[bus].failed_reset_count > 2) 2564 ha->bus_settings[bus].scsi_bus_dead = 1; 2565 ha->bus_settings[bus].failed_reset_count++; 2566 } else { 2567 spin_unlock_irq(ha->host->host_lock); 2568 ssleep(reset_delay); 2569 spin_lock_irq(ha->host->host_lock); 2570 2571 ha->bus_settings[bus].scsi_bus_dead = 0; 2572 ha->bus_settings[bus].failed_reset_count = 0; 2573 ha->bus_settings[bus].reset_marker = 0; 2574 /* Issue marker command. */ 2575 qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL); 2576 } 2577 2578 /* 2579 * We should probably call qla1280_set_target_parameters() 2580 * here as well for all devices on the bus. 2581 */ 2582 2583 if (status) 2584 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n"); 2585 else 2586 dprintk(3, "qla1280_bus_reset: exiting normally\n"); 2587 2588 return status; 2589 } 2590 2591 /* 2592 * qla1280_device_reset 2593 * Issue bus device reset message to the target. 2594 * 2595 * Input: 2596 * ha = adapter block pointer. 2597 * bus = SCSI BUS number. 2598 * target = SCSI ID. 2599 * 2600 * Returns: 2601 * 0 = success 2602 */ 2603 static int 2604 qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target) 2605 { 2606 uint16_t mb[MAILBOX_REGISTER_COUNT]; 2607 int status; 2608 2609 ENTER("qla1280_device_reset"); 2610 2611 mb[0] = MBC_ABORT_TARGET; 2612 mb[1] = (bus ? (target | BIT_7) : target) << 8; 2613 mb[2] = 1; 2614 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]); 2615 2616 /* Issue marker command. */ 2617 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID); 2618 2619 if (status) 2620 dprintk(2, "qla1280_device_reset: **** FAILED ****\n"); 2621 2622 LEAVE("qla1280_device_reset"); 2623 return status; 2624 } 2625 2626 /* 2627 * qla1280_abort_command 2628 * Abort command aborts a specified IOCB. 2629 * 2630 * Input: 2631 * ha = adapter block pointer. 2632 * sp = SB structure pointer. 2633 * 2634 * Returns: 2635 * 0 = success 2636 */ 2637 static int 2638 qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle) 2639 { 2640 uint16_t mb[MAILBOX_REGISTER_COUNT]; 2641 unsigned int bus, target, lun; 2642 int status; 2643 2644 ENTER("qla1280_abort_command"); 2645 2646 bus = SCSI_BUS_32(sp->cmd); 2647 target = SCSI_TCN_32(sp->cmd); 2648 lun = SCSI_LUN_32(sp->cmd); 2649 2650 sp->flags |= SRB_ABORT_PENDING; 2651 2652 mb[0] = MBC_ABORT_COMMAND; 2653 mb[1] = (bus ? target | BIT_7 : target) << 8 | lun; 2654 mb[2] = handle >> 16; 2655 mb[3] = handle & 0xffff; 2656 status = qla1280_mailbox_command(ha, 0x0f, &mb[0]); 2657 2658 if (status) { 2659 dprintk(2, "qla1280_abort_command: **** FAILED ****\n"); 2660 sp->flags &= ~SRB_ABORT_PENDING; 2661 } 2662 2663 2664 LEAVE("qla1280_abort_command"); 2665 return status; 2666 } 2667 2668 /* 2669 * qla1280_reset_adapter 2670 * Reset adapter. 2671 * 2672 * Input: 2673 * ha = adapter block pointer. 2674 */ 2675 static void 2676 qla1280_reset_adapter(struct scsi_qla_host *ha) 2677 { 2678 struct device_reg __iomem *reg = ha->iobase; 2679 2680 ENTER("qla1280_reset_adapter"); 2681 2682 /* Disable ISP chip */ 2683 ha->flags.online = 0; 2684 WRT_REG_WORD(®->ictrl, ISP_RESET); 2685 WRT_REG_WORD(®->host_cmd, 2686 HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS); 2687 RD_REG_WORD(®->id_l); /* Flush PCI write */ 2688 2689 LEAVE("qla1280_reset_adapter"); 2690 } 2691 2692 /* 2693 * Issue marker command. 2694 * Function issues marker IOCB. 2695 * 2696 * Input: 2697 * ha = adapter block pointer. 2698 * bus = SCSI BUS number 2699 * id = SCSI ID 2700 * lun = SCSI LUN 2701 * type = marker modifier 2702 */ 2703 static void 2704 qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type) 2705 { 2706 struct mrk_entry *pkt; 2707 2708 ENTER("qla1280_marker"); 2709 2710 /* Get request packet. */ 2711 if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) { 2712 pkt->entry_type = MARKER_TYPE; 2713 pkt->lun = (uint8_t) lun; 2714 pkt->target = (uint8_t) (bus ? (id | BIT_7) : id); 2715 pkt->modifier = type; 2716 pkt->entry_status = 0; 2717 2718 /* Issue command to ISP */ 2719 qla1280_isp_cmd(ha); 2720 } 2721 2722 LEAVE("qla1280_marker"); 2723 } 2724 2725 2726 /* 2727 * qla1280_64bit_start_scsi 2728 * The start SCSI is responsible for building request packets on 2729 * request ring and modifying ISP input pointer. 2730 * 2731 * Input: 2732 * ha = adapter block pointer. 2733 * sp = SB structure pointer. 2734 * 2735 * Returns: 2736 * 0 = success, was able to issue command. 2737 */ 2738 #ifdef QLA_64BIT_PTR 2739 static int 2740 qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp) 2741 { 2742 struct device_reg __iomem *reg = ha->iobase; 2743 struct scsi_cmnd *cmd = sp->cmd; 2744 cmd_a64_entry_t *pkt; 2745 __le32 *dword_ptr; 2746 dma_addr_t dma_handle; 2747 int status = 0; 2748 int cnt; 2749 int req_cnt; 2750 int seg_cnt; 2751 u8 dir; 2752 2753 ENTER("qla1280_64bit_start_scsi:"); 2754 2755 /* Calculate number of entries and segments required. */ 2756 req_cnt = 1; 2757 seg_cnt = scsi_dma_map(cmd); 2758 if (seg_cnt > 0) { 2759 if (seg_cnt > 2) { 2760 req_cnt += (seg_cnt - 2) / 5; 2761 if ((seg_cnt - 2) % 5) 2762 req_cnt++; 2763 } 2764 } else if (seg_cnt < 0) { 2765 status = 1; 2766 goto out; 2767 } 2768 2769 if ((req_cnt + 2) >= ha->req_q_cnt) { 2770 /* Calculate number of free request entries. */ 2771 cnt = RD_REG_WORD(®->mailbox4); 2772 if (ha->req_ring_index < cnt) 2773 ha->req_q_cnt = cnt - ha->req_ring_index; 2774 else 2775 ha->req_q_cnt = 2776 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt); 2777 } 2778 2779 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n", 2780 ha->req_q_cnt, seg_cnt); 2781 2782 /* If room for request in request ring. */ 2783 if ((req_cnt + 2) >= ha->req_q_cnt) { 2784 status = SCSI_MLQUEUE_HOST_BUSY; 2785 dprintk(2, "qla1280_start_scsi: in-ptr=0x%x req_q_cnt=" 2786 "0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt, 2787 req_cnt); 2788 goto out; 2789 } 2790 2791 /* Check for room in outstanding command list. */ 2792 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS && 2793 ha->outstanding_cmds[cnt] != NULL; cnt++); 2794 2795 if (cnt >= MAX_OUTSTANDING_COMMANDS) { 2796 status = SCSI_MLQUEUE_HOST_BUSY; 2797 dprintk(2, "qla1280_start_scsi: NO ROOM IN " 2798 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt); 2799 goto out; 2800 } 2801 2802 ha->outstanding_cmds[cnt] = sp; 2803 ha->req_q_cnt -= req_cnt; 2804 CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1); 2805 2806 dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp, 2807 cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd)); 2808 dprintk(2, " bus %i, target %i, lun %i\n", 2809 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd)); 2810 qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE); 2811 2812 /* 2813 * Build command packet. 2814 */ 2815 pkt = (cmd_a64_entry_t *) ha->request_ring_ptr; 2816 2817 pkt->entry_type = COMMAND_A64_TYPE; 2818 pkt->entry_count = (uint8_t) req_cnt; 2819 pkt->sys_define = (uint8_t) ha->req_ring_index; 2820 pkt->entry_status = 0; 2821 pkt->handle = cpu_to_le32(cnt); 2822 2823 /* Zero out remaining portion of packet. */ 2824 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8)); 2825 2826 /* Set ISP command timeout. */ 2827 pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ); 2828 2829 /* Set device target ID and LUN */ 2830 pkt->lun = SCSI_LUN_32(cmd); 2831 pkt->target = SCSI_BUS_32(cmd) ? 2832 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd); 2833 2834 /* Enable simple tag queuing if device supports it. */ 2835 if (cmd->device->simple_tags) 2836 pkt->control_flags |= cpu_to_le16(BIT_3); 2837 2838 /* Load SCSI command packet. */ 2839 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd)); 2840 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd)); 2841 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */ 2842 2843 /* Set transfer direction. */ 2844 dir = qla1280_data_direction(cmd); 2845 pkt->control_flags |= cpu_to_le16(dir); 2846 2847 /* Set total data segment count. */ 2848 pkt->dseg_count = cpu_to_le16(seg_cnt); 2849 2850 /* 2851 * Load data segments. 2852 */ 2853 if (seg_cnt) { /* If data transfer. */ 2854 struct scatterlist *sg, *s; 2855 int remseg = seg_cnt; 2856 2857 sg = scsi_sglist(cmd); 2858 2859 /* Setup packet address segment pointer. */ 2860 dword_ptr = (u32 *)&pkt->dseg_0_address; 2861 2862 /* Load command entry data segments. */ 2863 for_each_sg(sg, s, seg_cnt, cnt) { 2864 if (cnt == 2) 2865 break; 2866 2867 dma_handle = sg_dma_address(s); 2868 *dword_ptr++ = 2869 cpu_to_le32(lower_32_bits(dma_handle)); 2870 *dword_ptr++ = 2871 cpu_to_le32(upper_32_bits(dma_handle)); 2872 *dword_ptr++ = cpu_to_le32(sg_dma_len(s)); 2873 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n", 2874 cpu_to_le32(upper_32_bits(dma_handle)), 2875 cpu_to_le32(lower_32_bits(dma_handle)), 2876 cpu_to_le32(sg_dma_len(sg_next(s)))); 2877 remseg--; 2878 } 2879 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather " 2880 "command packet data - b %i, t %i, l %i \n", 2881 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), 2882 SCSI_LUN_32(cmd)); 2883 qla1280_dump_buffer(5, (char *)pkt, 2884 REQUEST_ENTRY_SIZE); 2885 2886 /* 2887 * Build continuation packets. 2888 */ 2889 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x " 2890 "remains\n", seg_cnt); 2891 2892 while (remseg > 0) { 2893 /* Update sg start */ 2894 sg = s; 2895 /* Adjust ring index. */ 2896 ha->req_ring_index++; 2897 if (ha->req_ring_index == REQUEST_ENTRY_CNT) { 2898 ha->req_ring_index = 0; 2899 ha->request_ring_ptr = 2900 ha->request_ring; 2901 } else 2902 ha->request_ring_ptr++; 2903 2904 pkt = (cmd_a64_entry_t *)ha->request_ring_ptr; 2905 2906 /* Zero out packet. */ 2907 memset(pkt, 0, REQUEST_ENTRY_SIZE); 2908 2909 /* Load packet defaults. */ 2910 ((struct cont_a64_entry *) pkt)->entry_type = 2911 CONTINUE_A64_TYPE; 2912 ((struct cont_a64_entry *) pkt)->entry_count = 1; 2913 ((struct cont_a64_entry *) pkt)->sys_define = 2914 (uint8_t)ha->req_ring_index; 2915 /* Setup packet address segment pointer. */ 2916 dword_ptr = 2917 (u32 *)&((struct cont_a64_entry *) pkt)->dseg_0_address; 2918 2919 /* Load continuation entry data segments. */ 2920 for_each_sg(sg, s, remseg, cnt) { 2921 if (cnt == 5) 2922 break; 2923 dma_handle = sg_dma_address(s); 2924 *dword_ptr++ = 2925 cpu_to_le32(lower_32_bits(dma_handle)); 2926 *dword_ptr++ = 2927 cpu_to_le32(upper_32_bits(dma_handle)); 2928 *dword_ptr++ = 2929 cpu_to_le32(sg_dma_len(s)); 2930 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n", 2931 cpu_to_le32(upper_32_bits(dma_handle)), 2932 cpu_to_le32(lower_32_bits(dma_handle)), 2933 cpu_to_le32(sg_dma_len(s))); 2934 } 2935 remseg -= cnt; 2936 dprintk(5, "qla1280_64bit_start_scsi: " 2937 "continuation packet data - b %i, t " 2938 "%i, l %i \n", SCSI_BUS_32(cmd), 2939 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd)); 2940 qla1280_dump_buffer(5, (char *)pkt, 2941 REQUEST_ENTRY_SIZE); 2942 } 2943 } else { /* No data transfer */ 2944 dprintk(5, "qla1280_64bit_start_scsi: No data, command " 2945 "packet data - b %i, t %i, l %i \n", 2946 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd)); 2947 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE); 2948 } 2949 /* Adjust ring index. */ 2950 ha->req_ring_index++; 2951 if (ha->req_ring_index == REQUEST_ENTRY_CNT) { 2952 ha->req_ring_index = 0; 2953 ha->request_ring_ptr = ha->request_ring; 2954 } else 2955 ha->request_ring_ptr++; 2956 2957 /* Set chip new ring index. */ 2958 dprintk(2, 2959 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n"); 2960 sp->flags |= SRB_SENT; 2961 ha->actthreads++; 2962 WRT_REG_WORD(®->mailbox4, ha->req_ring_index); 2963 2964 out: 2965 if (status) 2966 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n"); 2967 else 2968 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n"); 2969 2970 return status; 2971 } 2972 #else /* !QLA_64BIT_PTR */ 2973 2974 /* 2975 * qla1280_32bit_start_scsi 2976 * The start SCSI is responsible for building request packets on 2977 * request ring and modifying ISP input pointer. 2978 * 2979 * The Qlogic firmware interface allows every queue slot to have a SCSI 2980 * command and up to 4 scatter/gather (SG) entries. If we need more 2981 * than 4 SG entries, then continuation entries are used that can 2982 * hold another 7 entries each. The start routine determines if there 2983 * is eought empty slots then build the combination of requests to 2984 * fulfill the OS request. 2985 * 2986 * Input: 2987 * ha = adapter block pointer. 2988 * sp = SCSI Request Block structure pointer. 2989 * 2990 * Returns: 2991 * 0 = success, was able to issue command. 2992 */ 2993 static int 2994 qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp) 2995 { 2996 struct device_reg __iomem *reg = ha->iobase; 2997 struct scsi_cmnd *cmd = sp->cmd; 2998 struct cmd_entry *pkt; 2999 __le32 *dword_ptr; 3000 int status = 0; 3001 int cnt; 3002 int req_cnt; 3003 int seg_cnt; 3004 u8 dir; 3005 3006 ENTER("qla1280_32bit_start_scsi"); 3007 3008 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp, 3009 cmd->cmnd[0]); 3010 3011 /* Calculate number of entries and segments required. */ 3012 req_cnt = 1; 3013 seg_cnt = scsi_dma_map(cmd); 3014 if (seg_cnt) { 3015 /* 3016 * if greater than four sg entries then we need to allocate 3017 * continuation entries 3018 */ 3019 if (seg_cnt > 4) { 3020 req_cnt += (seg_cnt - 4) / 7; 3021 if ((seg_cnt - 4) % 7) 3022 req_cnt++; 3023 } 3024 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n", 3025 cmd, seg_cnt, req_cnt); 3026 } else if (seg_cnt < 0) { 3027 status = 1; 3028 goto out; 3029 } 3030 3031 if ((req_cnt + 2) >= ha->req_q_cnt) { 3032 /* Calculate number of free request entries. */ 3033 cnt = RD_REG_WORD(®->mailbox4); 3034 if (ha->req_ring_index < cnt) 3035 ha->req_q_cnt = cnt - ha->req_ring_index; 3036 else 3037 ha->req_q_cnt = 3038 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt); 3039 } 3040 3041 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n", 3042 ha->req_q_cnt, seg_cnt); 3043 /* If room for request in request ring. */ 3044 if ((req_cnt + 2) >= ha->req_q_cnt) { 3045 status = SCSI_MLQUEUE_HOST_BUSY; 3046 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, " 3047 "req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index, 3048 ha->req_q_cnt, req_cnt); 3049 goto out; 3050 } 3051 3052 /* Check for empty slot in outstanding command list. */ 3053 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS && 3054 ha->outstanding_cmds[cnt]; cnt++); 3055 3056 if (cnt >= MAX_OUTSTANDING_COMMANDS) { 3057 status = SCSI_MLQUEUE_HOST_BUSY; 3058 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING " 3059 "ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt); 3060 goto out; 3061 } 3062 3063 CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1); 3064 ha->outstanding_cmds[cnt] = sp; 3065 ha->req_q_cnt -= req_cnt; 3066 3067 /* 3068 * Build command packet. 3069 */ 3070 pkt = (struct cmd_entry *) ha->request_ring_ptr; 3071 3072 pkt->entry_type = COMMAND_TYPE; 3073 pkt->entry_count = (uint8_t) req_cnt; 3074 pkt->sys_define = (uint8_t) ha->req_ring_index; 3075 pkt->entry_status = 0; 3076 pkt->handle = cpu_to_le32(cnt); 3077 3078 /* Zero out remaining portion of packet. */ 3079 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8)); 3080 3081 /* Set ISP command timeout. */ 3082 pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ); 3083 3084 /* Set device target ID and LUN */ 3085 pkt->lun = SCSI_LUN_32(cmd); 3086 pkt->target = SCSI_BUS_32(cmd) ? 3087 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd); 3088 3089 /* Enable simple tag queuing if device supports it. */ 3090 if (cmd->device->simple_tags) 3091 pkt->control_flags |= cpu_to_le16(BIT_3); 3092 3093 /* Load SCSI command packet. */ 3094 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd)); 3095 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd)); 3096 3097 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */ 3098 /* Set transfer direction. */ 3099 dir = qla1280_data_direction(cmd); 3100 pkt->control_flags |= cpu_to_le16(dir); 3101 3102 /* Set total data segment count. */ 3103 pkt->dseg_count = cpu_to_le16(seg_cnt); 3104 3105 /* 3106 * Load data segments. 3107 */ 3108 if (seg_cnt) { 3109 struct scatterlist *sg, *s; 3110 int remseg = seg_cnt; 3111 3112 sg = scsi_sglist(cmd); 3113 3114 /* Setup packet address segment pointer. */ 3115 dword_ptr = &pkt->dseg_0_address; 3116 3117 dprintk(3, "Building S/G data segments..\n"); 3118 qla1280_dump_buffer(1, (char *)sg, 4 * 16); 3119 3120 /* Load command entry data segments. */ 3121 for_each_sg(sg, s, seg_cnt, cnt) { 3122 if (cnt == 4) 3123 break; 3124 *dword_ptr++ = 3125 cpu_to_le32(lower_32_bits(sg_dma_address(s))); 3126 *dword_ptr++ = cpu_to_le32(sg_dma_len(s)); 3127 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n", 3128 (lower_32_bits(sg_dma_address(s))), 3129 (sg_dma_len(s))); 3130 remseg--; 3131 } 3132 /* 3133 * Build continuation packets. 3134 */ 3135 dprintk(3, "S/G Building Continuation" 3136 "...seg_cnt=0x%x remains\n", seg_cnt); 3137 while (remseg > 0) { 3138 /* Continue from end point */ 3139 sg = s; 3140 /* Adjust ring index. */ 3141 ha->req_ring_index++; 3142 if (ha->req_ring_index == REQUEST_ENTRY_CNT) { 3143 ha->req_ring_index = 0; 3144 ha->request_ring_ptr = 3145 ha->request_ring; 3146 } else 3147 ha->request_ring_ptr++; 3148 3149 pkt = (struct cmd_entry *)ha->request_ring_ptr; 3150 3151 /* Zero out packet. */ 3152 memset(pkt, 0, REQUEST_ENTRY_SIZE); 3153 3154 /* Load packet defaults. */ 3155 ((struct cont_entry *) pkt)-> 3156 entry_type = CONTINUE_TYPE; 3157 ((struct cont_entry *) pkt)->entry_count = 1; 3158 3159 ((struct cont_entry *) pkt)->sys_define = 3160 (uint8_t) ha->req_ring_index; 3161 3162 /* Setup packet address segment pointer. */ 3163 dword_ptr = 3164 &((struct cont_entry *) pkt)->dseg_0_address; 3165 3166 /* Load continuation entry data segments. */ 3167 for_each_sg(sg, s, remseg, cnt) { 3168 if (cnt == 7) 3169 break; 3170 *dword_ptr++ = 3171 cpu_to_le32(lower_32_bits(sg_dma_address(s))); 3172 *dword_ptr++ = 3173 cpu_to_le32(sg_dma_len(s)); 3174 dprintk(1, 3175 "S/G Segment Cont. phys_addr=0x%x, " 3176 "len=0x%x\n", 3177 cpu_to_le32(lower_32_bits(sg_dma_address(s))), 3178 cpu_to_le32(sg_dma_len(s))); 3179 } 3180 remseg -= cnt; 3181 dprintk(5, "qla1280_32bit_start_scsi: " 3182 "continuation packet data - " 3183 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd), 3184 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd)); 3185 qla1280_dump_buffer(5, (char *)pkt, 3186 REQUEST_ENTRY_SIZE); 3187 } 3188 } else { /* No data transfer at all */ 3189 dprintk(5, "qla1280_32bit_start_scsi: No data, command " 3190 "packet data - \n"); 3191 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE); 3192 } 3193 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n"); 3194 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr, 3195 REQUEST_ENTRY_SIZE); 3196 3197 /* Adjust ring index. */ 3198 ha->req_ring_index++; 3199 if (ha->req_ring_index == REQUEST_ENTRY_CNT) { 3200 ha->req_ring_index = 0; 3201 ha->request_ring_ptr = ha->request_ring; 3202 } else 3203 ha->request_ring_ptr++; 3204 3205 /* Set chip new ring index. */ 3206 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC " 3207 "for pending command\n"); 3208 sp->flags |= SRB_SENT; 3209 ha->actthreads++; 3210 WRT_REG_WORD(®->mailbox4, ha->req_ring_index); 3211 3212 out: 3213 if (status) 3214 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n"); 3215 3216 LEAVE("qla1280_32bit_start_scsi"); 3217 3218 return status; 3219 } 3220 #endif 3221 3222 /* 3223 * qla1280_req_pkt 3224 * Function is responsible for locking ring and 3225 * getting a zeroed out request packet. 3226 * 3227 * Input: 3228 * ha = adapter block pointer. 3229 * 3230 * Returns: 3231 * 0 = failed to get slot. 3232 */ 3233 static request_t * 3234 qla1280_req_pkt(struct scsi_qla_host *ha) 3235 { 3236 struct device_reg __iomem *reg = ha->iobase; 3237 request_t *pkt = NULL; 3238 int cnt; 3239 uint32_t timer; 3240 3241 ENTER("qla1280_req_pkt"); 3242 3243 /* 3244 * This can be called from interrupt context, damn it!!! 3245 */ 3246 /* Wait for 30 seconds for slot. */ 3247 for (timer = 15000000; timer; timer--) { 3248 if (ha->req_q_cnt > 0) { 3249 /* Calculate number of free request entries. */ 3250 cnt = RD_REG_WORD(®->mailbox4); 3251 if (ha->req_ring_index < cnt) 3252 ha->req_q_cnt = cnt - ha->req_ring_index; 3253 else 3254 ha->req_q_cnt = 3255 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt); 3256 } 3257 3258 /* Found empty request ring slot? */ 3259 if (ha->req_q_cnt > 0) { 3260 ha->req_q_cnt--; 3261 pkt = ha->request_ring_ptr; 3262 3263 /* Zero out packet. */ 3264 memset(pkt, 0, REQUEST_ENTRY_SIZE); 3265 3266 /* 3267 * How can this be right when we have a ring 3268 * size of 512??? 3269 */ 3270 /* Set system defined field. */ 3271 pkt->sys_define = (uint8_t) ha->req_ring_index; 3272 3273 /* Set entry count. */ 3274 pkt->entry_count = 1; 3275 3276 break; 3277 } 3278 3279 udelay(2); /* 10 */ 3280 3281 /* Check for pending interrupts. */ 3282 qla1280_poll(ha); 3283 } 3284 3285 if (!pkt) 3286 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n"); 3287 else 3288 dprintk(3, "qla1280_req_pkt: exiting normally\n"); 3289 3290 return pkt; 3291 } 3292 3293 /* 3294 * qla1280_isp_cmd 3295 * Function is responsible for modifying ISP input pointer. 3296 * Releases ring lock. 3297 * 3298 * Input: 3299 * ha = adapter block pointer. 3300 */ 3301 static void 3302 qla1280_isp_cmd(struct scsi_qla_host *ha) 3303 { 3304 struct device_reg __iomem *reg = ha->iobase; 3305 3306 ENTER("qla1280_isp_cmd"); 3307 3308 dprintk(5, "qla1280_isp_cmd: IOCB data:\n"); 3309 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr, 3310 REQUEST_ENTRY_SIZE); 3311 3312 /* Adjust ring index. */ 3313 ha->req_ring_index++; 3314 if (ha->req_ring_index == REQUEST_ENTRY_CNT) { 3315 ha->req_ring_index = 0; 3316 ha->request_ring_ptr = ha->request_ring; 3317 } else 3318 ha->request_ring_ptr++; 3319 3320 /* 3321 * Update request index to mailbox4 (Request Queue In). 3322 */ 3323 WRT_REG_WORD(®->mailbox4, ha->req_ring_index); 3324 3325 LEAVE("qla1280_isp_cmd"); 3326 } 3327 3328 /****************************************************************************/ 3329 /* Interrupt Service Routine. */ 3330 /****************************************************************************/ 3331 3332 /**************************************************************************** 3333 * qla1280_isr 3334 * Calls I/O done on command completion. 3335 * 3336 * Input: 3337 * ha = adapter block pointer. 3338 * done_q = done queue. 3339 ****************************************************************************/ 3340 static void 3341 qla1280_isr(struct scsi_qla_host *ha, struct list_head *done_q) 3342 { 3343 struct device_reg __iomem *reg = ha->iobase; 3344 struct response *pkt; 3345 struct srb *sp = NULL; 3346 uint16_t mailbox[MAILBOX_REGISTER_COUNT]; 3347 uint16_t *wptr; 3348 uint32_t index; 3349 u16 istatus; 3350 3351 ENTER("qla1280_isr"); 3352 3353 istatus = RD_REG_WORD(®->istatus); 3354 if (!(istatus & (RISC_INT | PCI_INT))) 3355 return; 3356 3357 /* Save mailbox register 5 */ 3358 mailbox[5] = RD_REG_WORD(®->mailbox5); 3359 3360 /* Check for mailbox interrupt. */ 3361 3362 mailbox[0] = RD_REG_WORD_dmasync(®->semaphore); 3363 3364 if (mailbox[0] & BIT_0) { 3365 /* Get mailbox data. */ 3366 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */ 3367 3368 wptr = &mailbox[0]; 3369 *wptr++ = RD_REG_WORD(®->mailbox0); 3370 *wptr++ = RD_REG_WORD(®->mailbox1); 3371 *wptr = RD_REG_WORD(®->mailbox2); 3372 if (mailbox[0] != MBA_SCSI_COMPLETION) { 3373 wptr++; 3374 *wptr++ = RD_REG_WORD(®->mailbox3); 3375 *wptr++ = RD_REG_WORD(®->mailbox4); 3376 wptr++; 3377 *wptr++ = RD_REG_WORD(®->mailbox6); 3378 *wptr = RD_REG_WORD(®->mailbox7); 3379 } 3380 3381 /* Release mailbox registers. */ 3382 3383 WRT_REG_WORD(®->semaphore, 0); 3384 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT); 3385 3386 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x", 3387 mailbox[0]); 3388 3389 /* Handle asynchronous event */ 3390 switch (mailbox[0]) { 3391 case MBA_SCSI_COMPLETION: /* Response completion */ 3392 dprintk(5, "qla1280_isr: mailbox SCSI response " 3393 "completion\n"); 3394 3395 if (ha->flags.online) { 3396 /* Get outstanding command index. */ 3397 index = mailbox[2] << 16 | mailbox[1]; 3398 3399 /* Validate handle. */ 3400 if (index < MAX_OUTSTANDING_COMMANDS) 3401 sp = ha->outstanding_cmds[index]; 3402 else 3403 sp = NULL; 3404 3405 if (sp) { 3406 /* Free outstanding command slot. */ 3407 ha->outstanding_cmds[index] = NULL; 3408 3409 /* Save ISP completion status */ 3410 CMD_RESULT(sp->cmd) = 0; 3411 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE; 3412 3413 /* Place block on done queue */ 3414 list_add_tail(&sp->list, done_q); 3415 } else { 3416 /* 3417 * If we get here we have a real problem! 3418 */ 3419 printk(KERN_WARNING 3420 "qla1280: ISP invalid handle\n"); 3421 } 3422 } 3423 break; 3424 3425 case MBA_BUS_RESET: /* SCSI Bus Reset */ 3426 ha->flags.reset_marker = 1; 3427 index = mailbox[6] & BIT_0; 3428 ha->bus_settings[index].reset_marker = 1; 3429 3430 printk(KERN_DEBUG "qla1280_isr(): index %i " 3431 "asynchronous BUS_RESET\n", index); 3432 break; 3433 3434 case MBA_SYSTEM_ERR: /* System Error */ 3435 printk(KERN_WARNING 3436 "qla1280: ISP System Error - mbx1=%xh, mbx2=" 3437 "%xh, mbx3=%xh\n", mailbox[1], mailbox[2], 3438 mailbox[3]); 3439 break; 3440 3441 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */ 3442 printk(KERN_WARNING 3443 "qla1280: ISP Request Transfer Error\n"); 3444 break; 3445 3446 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */ 3447 printk(KERN_WARNING 3448 "qla1280: ISP Response Transfer Error\n"); 3449 break; 3450 3451 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */ 3452 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n"); 3453 break; 3454 3455 case MBA_TIMEOUT_RESET: /* Execution Timeout Reset */ 3456 dprintk(2, 3457 "qla1280_isr: asynchronous TIMEOUT_RESET\n"); 3458 break; 3459 3460 case MBA_DEVICE_RESET: /* Bus Device Reset */ 3461 printk(KERN_INFO "qla1280_isr(): asynchronous " 3462 "BUS_DEVICE_RESET\n"); 3463 3464 ha->flags.reset_marker = 1; 3465 index = mailbox[6] & BIT_0; 3466 ha->bus_settings[index].reset_marker = 1; 3467 break; 3468 3469 case MBA_BUS_MODE_CHANGE: 3470 dprintk(2, 3471 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n"); 3472 break; 3473 3474 default: 3475 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */ 3476 if (mailbox[0] < MBA_ASYNC_EVENT) { 3477 wptr = &mailbox[0]; 3478 memcpy((uint16_t *) ha->mailbox_out, wptr, 3479 MAILBOX_REGISTER_COUNT * 3480 sizeof(uint16_t)); 3481 3482 if(ha->mailbox_wait != NULL) 3483 complete(ha->mailbox_wait); 3484 } 3485 break; 3486 } 3487 } else { 3488 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT); 3489 } 3490 3491 /* 3492 * We will receive interrupts during mailbox testing prior to 3493 * the card being marked online, hence the double check. 3494 */ 3495 if (!(ha->flags.online && !ha->mailbox_wait)) { 3496 dprintk(2, "qla1280_isr: Response pointer Error\n"); 3497 goto out; 3498 } 3499 3500 if (mailbox[5] >= RESPONSE_ENTRY_CNT) 3501 goto out; 3502 3503 while (ha->rsp_ring_index != mailbox[5]) { 3504 pkt = ha->response_ring_ptr; 3505 3506 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]" 3507 " = 0x%x\n", ha->rsp_ring_index, mailbox[5]); 3508 dprintk(5,"qla1280_isr: response packet data\n"); 3509 qla1280_dump_buffer(5, (char *)pkt, RESPONSE_ENTRY_SIZE); 3510 3511 if (pkt->entry_type == STATUS_TYPE) { 3512 if ((le16_to_cpu(pkt->scsi_status) & 0xff) 3513 || pkt->comp_status || pkt->entry_status) { 3514 dprintk(2, "qla1280_isr: ha->rsp_ring_index = " 3515 "0x%x mailbox[5] = 0x%x, comp_status " 3516 "= 0x%x, scsi_status = 0x%x\n", 3517 ha->rsp_ring_index, mailbox[5], 3518 le16_to_cpu(pkt->comp_status), 3519 le16_to_cpu(pkt->scsi_status)); 3520 } 3521 } else { 3522 dprintk(2, "qla1280_isr: ha->rsp_ring_index = " 3523 "0x%x, mailbox[5] = 0x%x\n", 3524 ha->rsp_ring_index, mailbox[5]); 3525 dprintk(2, "qla1280_isr: response packet data\n"); 3526 qla1280_dump_buffer(2, (char *)pkt, 3527 RESPONSE_ENTRY_SIZE); 3528 } 3529 3530 if (pkt->entry_type == STATUS_TYPE || pkt->entry_status) { 3531 dprintk(2, "status: Cmd %p, handle %i\n", 3532 ha->outstanding_cmds[pkt->handle]->cmd, 3533 pkt->handle); 3534 if (pkt->entry_type == STATUS_TYPE) 3535 qla1280_status_entry(ha, pkt, done_q); 3536 else 3537 qla1280_error_entry(ha, pkt, done_q); 3538 /* Adjust ring index. */ 3539 ha->rsp_ring_index++; 3540 if (ha->rsp_ring_index == RESPONSE_ENTRY_CNT) { 3541 ha->rsp_ring_index = 0; 3542 ha->response_ring_ptr = ha->response_ring; 3543 } else 3544 ha->response_ring_ptr++; 3545 WRT_REG_WORD(®->mailbox5, ha->rsp_ring_index); 3546 } 3547 } 3548 3549 out: 3550 LEAVE("qla1280_isr"); 3551 } 3552 3553 /* 3554 * qla1280_rst_aen 3555 * Processes asynchronous reset. 3556 * 3557 * Input: 3558 * ha = adapter block pointer. 3559 */ 3560 static void 3561 qla1280_rst_aen(struct scsi_qla_host *ha) 3562 { 3563 uint8_t bus; 3564 3565 ENTER("qla1280_rst_aen"); 3566 3567 if (ha->flags.online && !ha->flags.reset_active && 3568 !ha->flags.abort_isp_active) { 3569 ha->flags.reset_active = 1; 3570 while (ha->flags.reset_marker) { 3571 /* Issue marker command. */ 3572 ha->flags.reset_marker = 0; 3573 for (bus = 0; bus < ha->ports && 3574 !ha->flags.reset_marker; bus++) { 3575 if (ha->bus_settings[bus].reset_marker) { 3576 ha->bus_settings[bus].reset_marker = 0; 3577 qla1280_marker(ha, bus, 0, 0, 3578 MK_SYNC_ALL); 3579 } 3580 } 3581 } 3582 } 3583 3584 LEAVE("qla1280_rst_aen"); 3585 } 3586 3587 3588 /* 3589 * qla1280_status_entry 3590 * Processes received ISP status entry. 3591 * 3592 * Input: 3593 * ha = adapter block pointer. 3594 * pkt = entry pointer. 3595 * done_q = done queue. 3596 */ 3597 static void 3598 qla1280_status_entry(struct scsi_qla_host *ha, struct response *pkt, 3599 struct list_head *done_q) 3600 { 3601 int sense_sz; 3602 struct srb *sp; 3603 struct scsi_cmnd *cmd; 3604 uint32_t handle = le32_to_cpu(pkt->handle); 3605 uint16_t scsi_status = le16_to_cpu(pkt->scsi_status); 3606 uint16_t comp_status = le16_to_cpu(pkt->comp_status); 3607 3608 ENTER("qla1280_status_entry"); 3609 3610 /* Validate handle. */ 3611 if (handle < MAX_OUTSTANDING_COMMANDS) 3612 sp = ha->outstanding_cmds[handle]; 3613 else 3614 sp = NULL; 3615 3616 if (!sp) { 3617 printk(KERN_WARNING "qla1280: Status Entry invalid handle\n"); 3618 goto out; 3619 } 3620 3621 /* Free outstanding command slot. */ 3622 ha->outstanding_cmds[handle] = NULL; 3623 3624 cmd = sp->cmd; 3625 3626 if (comp_status || scsi_status) { 3627 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = " 3628 "0x%x, handle = 0x%x\n", comp_status, 3629 scsi_status, handle); 3630 } 3631 3632 /* Target busy or queue full */ 3633 if ((scsi_status & 0xFF) == SAM_STAT_TASK_SET_FULL || 3634 (scsi_status & 0xFF) == SAM_STAT_BUSY) { 3635 CMD_RESULT(cmd) = scsi_status & 0xff; 3636 } else { 3637 3638 /* Save ISP completion status */ 3639 CMD_RESULT(cmd) = qla1280_return_status(pkt, cmd); 3640 3641 if (scsi_status & SAM_STAT_CHECK_CONDITION) { 3642 if (comp_status != CS_ARS_FAILED) { 3643 uint16_t req_sense_length = 3644 le16_to_cpu(pkt->req_sense_length); 3645 if (req_sense_length < CMD_SNSLEN(cmd)) 3646 sense_sz = req_sense_length; 3647 else 3648 /* 3649 * scsi_cmnd->sense_buffer is 3650 * 64 bytes, why only copy 63? 3651 * This looks wrong! /Jes 3652 */ 3653 sense_sz = CMD_SNSLEN(cmd) - 1; 3654 3655 memcpy(cmd->sense_buffer, 3656 &pkt->req_sense_data, sense_sz); 3657 } else 3658 sense_sz = 0; 3659 memset(cmd->sense_buffer + sense_sz, 0, 3660 SCSI_SENSE_BUFFERSIZE - sense_sz); 3661 3662 dprintk(2, "qla1280_status_entry: Check " 3663 "condition Sense data, b %i, t %i, " 3664 "l %i\n", SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), 3665 SCSI_LUN_32(cmd)); 3666 if (sense_sz) 3667 qla1280_dump_buffer(2, 3668 (char *)cmd->sense_buffer, 3669 sense_sz); 3670 } 3671 } 3672 3673 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE; 3674 3675 /* Place command on done queue. */ 3676 list_add_tail(&sp->list, done_q); 3677 out: 3678 LEAVE("qla1280_status_entry"); 3679 } 3680 3681 /* 3682 * qla1280_error_entry 3683 * Processes error entry. 3684 * 3685 * Input: 3686 * ha = adapter block pointer. 3687 * pkt = entry pointer. 3688 * done_q = done queue. 3689 */ 3690 static void 3691 qla1280_error_entry(struct scsi_qla_host *ha, struct response *pkt, 3692 struct list_head *done_q) 3693 { 3694 struct srb *sp; 3695 uint32_t handle = le32_to_cpu(pkt->handle); 3696 3697 ENTER("qla1280_error_entry"); 3698 3699 if (pkt->entry_status & BIT_3) 3700 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n"); 3701 else if (pkt->entry_status & BIT_2) 3702 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n"); 3703 else if (pkt->entry_status & BIT_1) 3704 dprintk(2, "qla1280_error_entry: FULL flag error\n"); 3705 else 3706 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n"); 3707 3708 /* Validate handle. */ 3709 if (handle < MAX_OUTSTANDING_COMMANDS) 3710 sp = ha->outstanding_cmds[handle]; 3711 else 3712 sp = NULL; 3713 3714 if (sp) { 3715 /* Free outstanding command slot. */ 3716 ha->outstanding_cmds[handle] = NULL; 3717 3718 /* Bad payload or header */ 3719 if (pkt->entry_status & (BIT_3 + BIT_2)) { 3720 /* Bad payload or header, set error status. */ 3721 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */ 3722 CMD_RESULT(sp->cmd) = DID_ERROR << 16; 3723 } else if (pkt->entry_status & BIT_1) { /* FULL flag */ 3724 CMD_RESULT(sp->cmd) = DID_BUS_BUSY << 16; 3725 } else { 3726 /* Set error status. */ 3727 CMD_RESULT(sp->cmd) = DID_ERROR << 16; 3728 } 3729 3730 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE; 3731 3732 /* Place command on done queue. */ 3733 list_add_tail(&sp->list, done_q); 3734 } 3735 #ifdef QLA_64BIT_PTR 3736 else if (pkt->entry_type == COMMAND_A64_TYPE) { 3737 printk(KERN_WARNING "!qla1280: Error Entry invalid handle"); 3738 } 3739 #endif 3740 3741 LEAVE("qla1280_error_entry"); 3742 } 3743 3744 /* 3745 * qla1280_abort_isp 3746 * Resets ISP and aborts all outstanding commands. 3747 * 3748 * Input: 3749 * ha = adapter block pointer. 3750 * 3751 * Returns: 3752 * 0 = success 3753 */ 3754 static int 3755 qla1280_abort_isp(struct scsi_qla_host *ha) 3756 { 3757 struct device_reg __iomem *reg = ha->iobase; 3758 struct srb *sp; 3759 int status = 0; 3760 int cnt; 3761 int bus; 3762 3763 ENTER("qla1280_abort_isp"); 3764 3765 if (ha->flags.abort_isp_active || !ha->flags.online) 3766 goto out; 3767 3768 ha->flags.abort_isp_active = 1; 3769 3770 /* Disable ISP interrupts. */ 3771 qla1280_disable_intrs(ha); 3772 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC); 3773 RD_REG_WORD(®->id_l); 3774 3775 printk(KERN_INFO "scsi(%li): dequeuing outstanding commands\n", 3776 ha->host_no); 3777 /* Dequeue all commands in outstanding command list. */ 3778 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) { 3779 struct scsi_cmnd *cmd; 3780 sp = ha->outstanding_cmds[cnt]; 3781 if (sp) { 3782 cmd = sp->cmd; 3783 CMD_RESULT(cmd) = DID_RESET << 16; 3784 CMD_HANDLE(cmd) = COMPLETED_HANDLE; 3785 ha->outstanding_cmds[cnt] = NULL; 3786 list_add_tail(&sp->list, &ha->done_q); 3787 } 3788 } 3789 3790 qla1280_done(ha); 3791 3792 status = qla1280_load_firmware(ha); 3793 if (status) 3794 goto out; 3795 3796 /* Setup adapter based on NVRAM parameters. */ 3797 qla1280_nvram_config (ha); 3798 3799 status = qla1280_init_rings(ha); 3800 if (status) 3801 goto out; 3802 3803 /* Issue SCSI reset. */ 3804 for (bus = 0; bus < ha->ports; bus++) 3805 qla1280_bus_reset(ha, bus); 3806 3807 ha->flags.abort_isp_active = 0; 3808 out: 3809 if (status) { 3810 printk(KERN_WARNING 3811 "qla1280: ISP error recovery failed, board disabled"); 3812 qla1280_reset_adapter(ha); 3813 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n"); 3814 } 3815 3816 LEAVE("qla1280_abort_isp"); 3817 return status; 3818 } 3819 3820 3821 /* 3822 * qla1280_debounce_register 3823 * Debounce register. 3824 * 3825 * Input: 3826 * port = register address. 3827 * 3828 * Returns: 3829 * register value. 3830 */ 3831 static u16 3832 qla1280_debounce_register(volatile u16 __iomem * addr) 3833 { 3834 volatile u16 ret; 3835 volatile u16 ret2; 3836 3837 ret = RD_REG_WORD(addr); 3838 ret2 = RD_REG_WORD(addr); 3839 3840 if (ret == ret2) 3841 return ret; 3842 3843 do { 3844 cpu_relax(); 3845 ret = RD_REG_WORD(addr); 3846 ret2 = RD_REG_WORD(addr); 3847 } while (ret != ret2); 3848 3849 return ret; 3850 } 3851 3852 3853 /************************************************************************ 3854 * qla1280_check_for_dead_scsi_bus * 3855 * * 3856 * This routine checks for a dead SCSI bus * 3857 ************************************************************************/ 3858 #define SET_SXP_BANK 0x0100 3859 #define SCSI_PHASE_INVALID 0x87FF 3860 static int 3861 qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *ha, unsigned int bus) 3862 { 3863 uint16_t config_reg, scsi_control; 3864 struct device_reg __iomem *reg = ha->iobase; 3865 3866 if (ha->bus_settings[bus].scsi_bus_dead) { 3867 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC); 3868 config_reg = RD_REG_WORD(®->cfg_1); 3869 WRT_REG_WORD(®->cfg_1, SET_SXP_BANK); 3870 scsi_control = RD_REG_WORD(®->scsiControlPins); 3871 WRT_REG_WORD(®->cfg_1, config_reg); 3872 WRT_REG_WORD(®->host_cmd, HC_RELEASE_RISC); 3873 3874 if (scsi_control == SCSI_PHASE_INVALID) { 3875 ha->bus_settings[bus].scsi_bus_dead = 1; 3876 return 1; /* bus is dead */ 3877 } else { 3878 ha->bus_settings[bus].scsi_bus_dead = 0; 3879 ha->bus_settings[bus].failed_reset_count = 0; 3880 } 3881 } 3882 return 0; /* bus is not dead */ 3883 } 3884 3885 static void 3886 qla1280_get_target_parameters(struct scsi_qla_host *ha, 3887 struct scsi_device *device) 3888 { 3889 uint16_t mb[MAILBOX_REGISTER_COUNT]; 3890 int bus, target, lun; 3891 3892 bus = device->channel; 3893 target = device->id; 3894 lun = device->lun; 3895 3896 3897 mb[0] = MBC_GET_TARGET_PARAMETERS; 3898 mb[1] = (uint16_t) (bus ? target | BIT_7 : target); 3899 mb[1] <<= 8; 3900 qla1280_mailbox_command(ha, BIT_6 | BIT_3 | BIT_2 | BIT_1 | BIT_0, 3901 &mb[0]); 3902 3903 printk(KERN_INFO "scsi(%li:%d:%d:%d):", ha->host_no, bus, target, lun); 3904 3905 if (mb[3] != 0) { 3906 printk(KERN_CONT " Sync: period %d, offset %d", 3907 (mb[3] & 0xff), (mb[3] >> 8)); 3908 if (mb[2] & BIT_13) 3909 printk(KERN_CONT ", Wide"); 3910 if ((mb[2] & BIT_5) && ((mb[6] >> 8) & 0xff) >= 2) 3911 printk(KERN_CONT ", DT"); 3912 } else 3913 printk(KERN_CONT " Async"); 3914 3915 if (device->simple_tags) 3916 printk(KERN_CONT ", Tagged queuing: depth %d", device->queue_depth); 3917 printk(KERN_CONT "\n"); 3918 } 3919 3920 3921 #if DEBUG_QLA1280 3922 static void 3923 __qla1280_dump_buffer(char *b, int size) 3924 { 3925 int cnt; 3926 u8 c; 3927 3928 printk(KERN_DEBUG " 0 1 2 3 4 5 6 7 8 9 Ah " 3929 "Bh Ch Dh Eh Fh\n"); 3930 printk(KERN_DEBUG "---------------------------------------------" 3931 "------------------\n"); 3932 3933 for (cnt = 0; cnt < size;) { 3934 c = *b++; 3935 3936 printk("0x%02x", c); 3937 cnt++; 3938 if (!(cnt % 16)) 3939 printk("\n"); 3940 else 3941 printk(" "); 3942 } 3943 if (cnt % 16) 3944 printk("\n"); 3945 } 3946 3947 /************************************************************************** 3948 * ql1280_print_scsi_cmd 3949 * 3950 **************************************************************************/ 3951 static void 3952 __qla1280_print_scsi_cmd(struct scsi_cmnd *cmd) 3953 { 3954 struct scsi_qla_host *ha; 3955 struct Scsi_Host *host = CMD_HOST(cmd); 3956 struct srb *sp; 3957 /* struct scatterlist *sg; */ 3958 3959 int i; 3960 ha = (struct scsi_qla_host *)host->hostdata; 3961 3962 sp = (struct srb *)CMD_SP(cmd); 3963 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd, CMD_HANDLE(cmd)); 3964 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n", 3965 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd), 3966 CMD_CDBLEN(cmd)); 3967 printk(" CDB = "); 3968 for (i = 0; i < cmd->cmd_len; i++) { 3969 printk("0x%02x ", cmd->cmnd[i]); 3970 } 3971 printk(" seg_cnt =%d\n", scsi_sg_count(cmd)); 3972 printk(" request buffer=0x%p, request buffer len=0x%x\n", 3973 scsi_sglist(cmd), scsi_bufflen(cmd)); 3974 /* if (cmd->use_sg) 3975 { 3976 sg = (struct scatterlist *) cmd->request_buffer; 3977 printk(" SG buffer: \n"); 3978 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist))); 3979 } */ 3980 printk(" tag=%d, transfersize=0x%x \n", 3981 scsi_cmd_to_rq(cmd)->tag, cmd->transfersize); 3982 printk(" SP=0x%p\n", CMD_SP(cmd)); 3983 printk(" underflow size = 0x%x, direction=0x%x\n", 3984 cmd->underflow, cmd->sc_data_direction); 3985 } 3986 3987 /************************************************************************** 3988 * ql1280_dump_device 3989 * 3990 **************************************************************************/ 3991 static void 3992 ql1280_dump_device(struct scsi_qla_host *ha) 3993 { 3994 3995 struct scsi_cmnd *cp; 3996 struct srb *sp; 3997 int i; 3998 3999 printk(KERN_DEBUG "Outstanding Commands on controller:\n"); 4000 4001 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) { 4002 if ((sp = ha->outstanding_cmds[i]) == NULL) 4003 continue; 4004 if ((cp = sp->cmd) == NULL) 4005 continue; 4006 qla1280_print_scsi_cmd(1, cp); 4007 } 4008 } 4009 #endif 4010 4011 4012 enum tokens { 4013 TOKEN_NVRAM, 4014 TOKEN_SYNC, 4015 TOKEN_WIDE, 4016 TOKEN_PPR, 4017 TOKEN_VERBOSE, 4018 TOKEN_DEBUG, 4019 }; 4020 4021 struct setup_tokens { 4022 char *token; 4023 int val; 4024 }; 4025 4026 static struct setup_tokens setup_token[] __initdata = 4027 { 4028 { "nvram", TOKEN_NVRAM }, 4029 { "sync", TOKEN_SYNC }, 4030 { "wide", TOKEN_WIDE }, 4031 { "ppr", TOKEN_PPR }, 4032 { "verbose", TOKEN_VERBOSE }, 4033 { "debug", TOKEN_DEBUG }, 4034 }; 4035 4036 4037 /************************************************************************** 4038 * qla1280_setup 4039 * 4040 * Handle boot parameters. This really needs to be changed so one 4041 * can specify per adapter parameters. 4042 **************************************************************************/ 4043 static int __init 4044 qla1280_setup(char *s) 4045 { 4046 char *cp, *ptr; 4047 unsigned long val; 4048 int toke; 4049 4050 cp = s; 4051 4052 while (cp && (ptr = strchr(cp, ':'))) { 4053 ptr++; 4054 if (!strcmp(ptr, "yes")) { 4055 val = 0x10000; 4056 ptr += 3; 4057 } else if (!strcmp(ptr, "no")) { 4058 val = 0; 4059 ptr += 2; 4060 } else 4061 val = simple_strtoul(ptr, &ptr, 0); 4062 4063 switch ((toke = qla1280_get_token(cp))) { 4064 case TOKEN_NVRAM: 4065 if (!val) 4066 driver_setup.no_nvram = 1; 4067 break; 4068 case TOKEN_SYNC: 4069 if (!val) 4070 driver_setup.no_sync = 1; 4071 else if (val != 0x10000) 4072 driver_setup.sync_mask = val; 4073 break; 4074 case TOKEN_WIDE: 4075 if (!val) 4076 driver_setup.no_wide = 1; 4077 else if (val != 0x10000) 4078 driver_setup.wide_mask = val; 4079 break; 4080 case TOKEN_PPR: 4081 if (!val) 4082 driver_setup.no_ppr = 1; 4083 else if (val != 0x10000) 4084 driver_setup.ppr_mask = val; 4085 break; 4086 case TOKEN_VERBOSE: 4087 qla1280_verbose = val; 4088 break; 4089 default: 4090 printk(KERN_INFO "qla1280: unknown boot option %s\n", 4091 cp); 4092 } 4093 4094 cp = strchr(ptr, ';'); 4095 if (cp) 4096 cp++; 4097 else { 4098 break; 4099 } 4100 } 4101 return 1; 4102 } 4103 4104 4105 static int __init 4106 qla1280_get_token(char *str) 4107 { 4108 char *sep; 4109 long ret = -1; 4110 int i; 4111 4112 sep = strchr(str, ':'); 4113 4114 if (sep) { 4115 for (i = 0; i < ARRAY_SIZE(setup_token); i++) { 4116 if (!strncmp(setup_token[i].token, str, (sep - str))) { 4117 ret = setup_token[i].val; 4118 break; 4119 } 4120 } 4121 } 4122 4123 return ret; 4124 } 4125 4126 4127 static struct scsi_host_template qla1280_driver_template = { 4128 .module = THIS_MODULE, 4129 .proc_name = "qla1280", 4130 .name = "Qlogic ISP 1280/12160", 4131 .info = qla1280_info, 4132 .slave_configure = qla1280_slave_configure, 4133 .queuecommand = qla1280_queuecommand, 4134 .eh_abort_handler = qla1280_eh_abort, 4135 .eh_device_reset_handler= qla1280_eh_device_reset, 4136 .eh_bus_reset_handler = qla1280_eh_bus_reset, 4137 .eh_host_reset_handler = qla1280_eh_adapter_reset, 4138 .bios_param = qla1280_biosparam, 4139 .can_queue = MAX_OUTSTANDING_COMMANDS, 4140 .this_id = -1, 4141 .sg_tablesize = SG_ALL, 4142 }; 4143 4144 4145 static int 4146 qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id) 4147 { 4148 int devnum = id->driver_data; 4149 struct qla_boards *bdp = &ql1280_board_tbl[devnum]; 4150 struct Scsi_Host *host; 4151 struct scsi_qla_host *ha; 4152 int error = -ENODEV; 4153 4154 /* Bypass all AMI SUBSYS VENDOR IDs */ 4155 if (pdev->subsystem_vendor == PCI_VENDOR_ID_AMI) { 4156 printk(KERN_INFO 4157 "qla1280: Skipping AMI SubSys Vendor ID Chip\n"); 4158 goto error; 4159 } 4160 4161 printk(KERN_INFO "qla1280: %s found on PCI bus %i, dev %i\n", 4162 bdp->name, pdev->bus->number, PCI_SLOT(pdev->devfn)); 4163 4164 if (pci_enable_device(pdev)) { 4165 printk(KERN_WARNING 4166 "qla1280: Failed to enabled pci device, aborting.\n"); 4167 goto error; 4168 } 4169 4170 pci_set_master(pdev); 4171 4172 error = -ENOMEM; 4173 host = scsi_host_alloc(&qla1280_driver_template, sizeof(*ha)); 4174 if (!host) { 4175 printk(KERN_WARNING 4176 "qla1280: Failed to register host, aborting.\n"); 4177 goto error_disable_device; 4178 } 4179 4180 ha = (struct scsi_qla_host *)host->hostdata; 4181 memset(ha, 0, sizeof(struct scsi_qla_host)); 4182 4183 ha->pdev = pdev; 4184 ha->devnum = devnum; /* specifies microcode load address */ 4185 4186 #ifdef QLA_64BIT_PTR 4187 if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) { 4188 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) { 4189 printk(KERN_WARNING "scsi(%li): Unable to set a " 4190 "suitable DMA mask - aborting\n", ha->host_no); 4191 error = -ENODEV; 4192 goto error_put_host; 4193 } 4194 } else 4195 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n", 4196 ha->host_no); 4197 #else 4198 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) { 4199 printk(KERN_WARNING "scsi(%li): Unable to set a " 4200 "suitable DMA mask - aborting\n", ha->host_no); 4201 error = -ENODEV; 4202 goto error_put_host; 4203 } 4204 #endif 4205 4206 ha->request_ring = dma_alloc_coherent(&ha->pdev->dev, 4207 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)), 4208 &ha->request_dma, GFP_KERNEL); 4209 if (!ha->request_ring) { 4210 printk(KERN_INFO "qla1280: Failed to get request memory\n"); 4211 goto error_put_host; 4212 } 4213 4214 ha->response_ring = dma_alloc_coherent(&ha->pdev->dev, 4215 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)), 4216 &ha->response_dma, GFP_KERNEL); 4217 if (!ha->response_ring) { 4218 printk(KERN_INFO "qla1280: Failed to get response memory\n"); 4219 goto error_free_request_ring; 4220 } 4221 4222 ha->ports = bdp->numPorts; 4223 4224 ha->host = host; 4225 ha->host_no = host->host_no; 4226 4227 host->irq = pdev->irq; 4228 host->max_channel = bdp->numPorts - 1; 4229 host->max_lun = MAX_LUNS - 1; 4230 host->max_id = MAX_TARGETS; 4231 host->max_sectors = 1024; 4232 host->unique_id = host->host_no; 4233 4234 error = -ENODEV; 4235 4236 #if MEMORY_MAPPED_IO 4237 ha->mmpbase = pci_ioremap_bar(ha->pdev, 1); 4238 if (!ha->mmpbase) { 4239 printk(KERN_INFO "qla1280: Unable to map I/O memory\n"); 4240 goto error_free_response_ring; 4241 } 4242 4243 host->base = (unsigned long)ha->mmpbase; 4244 ha->iobase = (struct device_reg __iomem *)ha->mmpbase; 4245 #else 4246 host->io_port = pci_resource_start(ha->pdev, 0); 4247 if (!request_region(host->io_port, 0xff, "qla1280")) { 4248 printk(KERN_INFO "qla1280: Failed to reserve i/o region " 4249 "0x%04lx-0x%04lx - already in use\n", 4250 host->io_port, host->io_port + 0xff); 4251 goto error_free_response_ring; 4252 } 4253 4254 ha->iobase = (struct device_reg *)host->io_port; 4255 #endif 4256 4257 INIT_LIST_HEAD(&ha->done_q); 4258 4259 /* Disable ISP interrupts. */ 4260 qla1280_disable_intrs(ha); 4261 4262 if (request_irq(pdev->irq, qla1280_intr_handler, IRQF_SHARED, 4263 "qla1280", ha)) { 4264 printk("qla1280 : Failed to reserve interrupt %d already " 4265 "in use\n", pdev->irq); 4266 goto error_release_region; 4267 } 4268 4269 /* load the F/W, read paramaters, and init the H/W */ 4270 if (qla1280_initialize_adapter(ha)) { 4271 printk(KERN_INFO "qla1x160: Failed to initialize adapter\n"); 4272 goto error_free_irq; 4273 } 4274 4275 /* set our host ID (need to do something about our two IDs) */ 4276 host->this_id = ha->bus_settings[0].id; 4277 4278 pci_set_drvdata(pdev, host); 4279 4280 error = scsi_add_host(host, &pdev->dev); 4281 if (error) 4282 goto error_disable_adapter; 4283 scsi_scan_host(host); 4284 4285 return 0; 4286 4287 error_disable_adapter: 4288 qla1280_disable_intrs(ha); 4289 error_free_irq: 4290 free_irq(pdev->irq, ha); 4291 error_release_region: 4292 #if MEMORY_MAPPED_IO 4293 iounmap(ha->mmpbase); 4294 #else 4295 release_region(host->io_port, 0xff); 4296 #endif 4297 error_free_response_ring: 4298 dma_free_coherent(&ha->pdev->dev, 4299 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)), 4300 ha->response_ring, ha->response_dma); 4301 error_free_request_ring: 4302 dma_free_coherent(&ha->pdev->dev, 4303 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)), 4304 ha->request_ring, ha->request_dma); 4305 error_put_host: 4306 scsi_host_put(host); 4307 error_disable_device: 4308 pci_disable_device(pdev); 4309 error: 4310 return error; 4311 } 4312 4313 4314 static void 4315 qla1280_remove_one(struct pci_dev *pdev) 4316 { 4317 struct Scsi_Host *host = pci_get_drvdata(pdev); 4318 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata; 4319 4320 scsi_remove_host(host); 4321 4322 qla1280_disable_intrs(ha); 4323 4324 free_irq(pdev->irq, ha); 4325 4326 #if MEMORY_MAPPED_IO 4327 iounmap(ha->mmpbase); 4328 #else 4329 release_region(host->io_port, 0xff); 4330 #endif 4331 4332 dma_free_coherent(&ha->pdev->dev, 4333 ((REQUEST_ENTRY_CNT + 1) * (sizeof(request_t))), 4334 ha->request_ring, ha->request_dma); 4335 dma_free_coherent(&ha->pdev->dev, 4336 ((RESPONSE_ENTRY_CNT + 1) * (sizeof(struct response))), 4337 ha->response_ring, ha->response_dma); 4338 4339 pci_disable_device(pdev); 4340 4341 scsi_host_put(host); 4342 } 4343 4344 static struct pci_driver qla1280_pci_driver = { 4345 .name = "qla1280", 4346 .id_table = qla1280_pci_tbl, 4347 .probe = qla1280_probe_one, 4348 .remove = qla1280_remove_one, 4349 }; 4350 4351 static int __init 4352 qla1280_init(void) 4353 { 4354 if (sizeof(struct srb) > sizeof(struct scsi_pointer)) { 4355 printk(KERN_WARNING 4356 "qla1280: struct srb too big, aborting\n"); 4357 return -EINVAL; 4358 } 4359 4360 #ifdef MODULE 4361 /* 4362 * If we are called as a module, the qla1280 pointer may not be null 4363 * and it would point to our bootup string, just like on the lilo 4364 * command line. IF not NULL, then process this config string with 4365 * qla1280_setup 4366 * 4367 * Boot time Options 4368 * To add options at boot time add a line to your lilo.conf file like: 4369 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}" 4370 * which will result in the first four devices on the first two 4371 * controllers being set to a tagged queue depth of 32. 4372 */ 4373 if (qla1280) 4374 qla1280_setup(qla1280); 4375 #endif 4376 4377 return pci_register_driver(&qla1280_pci_driver); 4378 } 4379 4380 static void __exit 4381 qla1280_exit(void) 4382 { 4383 int i; 4384 4385 pci_unregister_driver(&qla1280_pci_driver); 4386 /* release any allocated firmware images */ 4387 for (i = 0; i < QL_NUM_FW_IMAGES; i++) { 4388 release_firmware(qla1280_fw_tbl[i].fw); 4389 qla1280_fw_tbl[i].fw = NULL; 4390 } 4391 } 4392 4393 module_init(qla1280_init); 4394 module_exit(qla1280_exit); 4395 4396 MODULE_AUTHOR("Qlogic & Jes Sorensen"); 4397 MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver"); 4398 MODULE_LICENSE("GPL"); 4399 MODULE_FIRMWARE("qlogic/1040.bin"); 4400 MODULE_FIRMWARE("qlogic/1280.bin"); 4401 MODULE_FIRMWARE("qlogic/12160.bin"); 4402 MODULE_VERSION(QLA1280_VERSION); 4403