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