1/* 2 3w-xxxx.c -- 3ware Storage Controller device driver for Linux. 3 4 Written By: Adam Radford <linuxraid@lsi.com> 5 Modifications By: Joel Jacobson <linux@3ware.com> 6 Arnaldo Carvalho de Melo <acme@conectiva.com.br> 7 Brad Strand <linux@3ware.com> 8 9 Copyright (C) 1999-2010 3ware Inc. 10 11 Kernel compatibility By: Andre Hedrick <andre@suse.com> 12 Non-Copyright (C) 2000 Andre Hedrick <andre@suse.com> 13 14 Further tiny build fixes and trivial hoovering Alan Cox 15 16 This program is free software; you can redistribute it and/or modify 17 it under the terms of the GNU General Public License as published by 18 the Free Software Foundation; version 2 of the License. 19 20 This program is distributed in the hope that it will be useful, 21 but WITHOUT ANY WARRANTY; without even the implied warranty of 22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 23 GNU General Public License for more details. 24 25 NO WARRANTY 26 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 27 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 28 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 29 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 30 solely responsible for determining the appropriateness of using and 31 distributing the Program and assumes all risks associated with its 32 exercise of rights under this Agreement, including but not limited to 33 the risks and costs of program errors, damage to or loss of data, 34 programs or equipment, and unavailability or interruption of operations. 35 36 DISCLAIMER OF LIABILITY 37 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 38 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 39 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 40 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 41 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 42 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 43 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 44 45 You should have received a copy of the GNU General Public License 46 along with this program; if not, write to the Free Software 47 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 48 49 Bugs/Comments/Suggestions should be mailed to: 50 linuxraid@lsi.com 51 52 For more information, goto: 53 http://www.lsi.com 54 55 History 56 ------- 57 0.1.000 - Initial release. 58 0.4.000 - Added support for Asynchronous Event Notification through 59 ioctls for 3DM. 60 1.0.000 - Added DPO & FUA bit support for WRITE_10 & WRITE_6 cdb 61 to disable drive write-cache before writes. 62 1.1.000 - Fixed performance bug with DPO & FUA not existing for WRITE_6. 63 1.2.000 - Added support for clean shutdown notification/feature table. 64 1.02.00.001 - Added support for full command packet posts through ioctls 65 for 3DM. 66 Bug fix so hot spare drives don't show up. 67 1.02.00.002 - Fix bug with tw_setfeature() call that caused oops on some 68 systems. 69 08/21/00 - release previously allocated resources on failure at 70 tw_allocate_memory (acme) 71 1.02.00.003 - Fix tw_interrupt() to report error to scsi layer when 72 controller status is non-zero. 73 Added handling of request_sense opcode. 74 Fix possible null pointer dereference in 75 tw_reset_device_extension() 76 1.02.00.004 - Add support for device id of 3ware 7000 series controllers. 77 Make tw_setfeature() call with interrupts disabled. 78 Register interrupt handler before enabling interrupts. 79 Clear attention interrupt before draining aen queue. 80 1.02.00.005 - Allocate bounce buffers and custom queue depth for raid5 for 81 6000 and 5000 series controllers. 82 Reduce polling mdelays causing problems on some systems. 83 Fix use_sg = 1 calculation bug. 84 Check for scsi_register returning NULL. 85 Add aen count to /proc/scsi/3w-xxxx. 86 Remove aen code unit masking in tw_aen_complete(). 87 1.02.00.006 - Remove unit from printk in tw_scsi_eh_abort(), causing 88 possible oops. 89 Fix possible null pointer dereference in tw_scsi_queue() 90 if done function pointer was invalid. 91 1.02.00.007 - Fix possible null pointer dereferences in tw_ioctl(). 92 Remove check for invalid done function pointer from 93 tw_scsi_queue(). 94 1.02.00.008 - Set max sectors per io to TW_MAX_SECTORS in tw_findcards(). 95 Add tw_decode_error() for printing readable error messages. 96 Print some useful information on certain aen codes. 97 Add tw_decode_bits() for interpreting status register output. 98 Make scsi_set_pci_device() for kernels >= 2.4.4 99 Fix bug where aen's could be lost before a reset. 100 Re-add spinlocks in tw_scsi_detect(). 101 Fix possible null pointer dereference in tw_aen_drain_queue() 102 during initialization. 103 Clear pci parity errors during initialization and during io. 104 1.02.00.009 - Remove redundant increment in tw_state_request_start(). 105 Add ioctl support for direct ATA command passthru. 106 Add entire aen code string list. 107 1.02.00.010 - Cleanup queueing code, fix jbod thoughput. 108 Fix get_param for specific units. 109 1.02.00.011 - Fix bug in tw_aen_complete() where aen's could be lost. 110 Fix tw_aen_drain_queue() to display useful info at init. 111 Set tw_host->max_id for 12 port cards. 112 Add ioctl support for raw command packet post from userspace 113 with sglist fragments (parameter and io). 114 1.02.00.012 - Fix read capacity to under report by 1 sector to fix get 115 last sector ioctl. 116 1.02.00.013 - Fix bug where more AEN codes weren't coming out during 117 driver initialization. 118 Improved handling of PCI aborts. 119 1.02.00.014 - Fix bug in tw_findcards() where AEN code could be lost. 120 Increase timeout in tw_aen_drain_queue() to 30 seconds. 121 1.02.00.015 - Re-write raw command post with data ioctl method. 122 Remove raid5 bounce buffers for raid5 for 6XXX for kernel 2.5 123 Add tw_map/unmap_scsi_sg/single_data() for kernel 2.5 124 Replace io_request_lock with host_lock for kernel 2.5 125 Set max_cmd_len to 16 for 3dm for kernel 2.5 126 1.02.00.016 - Set host->max_sectors back up to 256. 127 1.02.00.017 - Modified pci parity error handling/clearing from config space 128 during initialization. 129 1.02.00.018 - Better handling of request sense opcode and sense information 130 for failed commands. Add tw_decode_sense(). 131 Replace all mdelay()'s with scsi_sleep(). 132 1.02.00.019 - Revert mdelay's and scsi_sleep's, this caused problems on 133 some SMP systems. 134 1.02.00.020 - Add pci_set_dma_mask(), rewrite kmalloc()/virt_to_bus() to 135 pci_alloc/free_consistent(). 136 Better alignment checking in tw_allocate_memory(). 137 Cleanup tw_initialize_device_extension(). 138 1.02.00.021 - Bump cmd_per_lun in SHT to 255 for better jbod performance. 139 Improve handling of errors in tw_interrupt(). 140 Add handling/clearing of controller queue error. 141 Empty stale responses before draining aen queue. 142 Fix tw_scsi_eh_abort() to not reset on every io abort. 143 Set can_queue in SHT to 255 to prevent hang from AEN. 144 1.02.00.022 - Fix possible null pointer dereference in tw_scsi_release(). 145 1.02.00.023 - Fix bug in tw_aen_drain_queue() where unit # was always zero. 146 1.02.00.024 - Add severity levels to AEN strings. 147 1.02.00.025 - Fix command interrupt spurious error messages. 148 Fix bug in raw command post with data ioctl method. 149 Fix bug where rollcall sometimes failed with cable errors. 150 Print unit # on all command timeouts. 151 1.02.00.026 - Fix possible infinite retry bug with power glitch induced 152 drive timeouts. 153 Cleanup some AEN severity levels. 154 1.02.00.027 - Add drive not supported AEN code for SATA controllers. 155 Remove spurious unknown ioctl error message. 156 1.02.00.028 - Fix bug where multiple controllers with no units were the 157 same card number. 158 Fix bug where cards were being shut down more than once. 159 1.02.00.029 - Add missing pci_free_consistent() in tw_allocate_memory(). 160 Replace pci_map_single() with pci_map_page() for highmem. 161 Check for tw_setfeature() failure. 162 1.02.00.030 - Make driver 64-bit clean. 163 1.02.00.031 - Cleanup polling timeouts/routines in several places. 164 Add support for mode sense opcode. 165 Add support for cache mode page. 166 Add support for synchronize cache opcode. 167 1.02.00.032 - Fix small multicard rollcall bug. 168 Make driver stay loaded with no units for hot add/swap. 169 Add support for "twe" character device for ioctls. 170 Clean up request_id queueing code. 171 Fix tw_scsi_queue() spinlocks. 172 1.02.00.033 - Fix tw_aen_complete() to not queue 'queue empty' AEN's. 173 Initialize queues correctly when loading with no valid units. 174 1.02.00.034 - Fix tw_decode_bits() to handle multiple errors. 175 Add support for user configurable cmd_per_lun. 176 Add support for sht->slave_configure(). 177 1.02.00.035 - Improve tw_allocate_memory() memory allocation. 178 Fix tw_chrdev_ioctl() to sleep correctly. 179 1.02.00.036 - Increase character ioctl timeout to 60 seconds. 180 1.02.00.037 - Fix tw_ioctl() to handle all non-data ATA passthru cmds 181 for 'smartmontools' support. 182 1.26.00.038 - Roll driver minor version to 26 to denote kernel 2.6. 183 Add support for cmds_per_lun module parameter. 184 1.26.00.039 - Fix bug in tw_chrdev_ioctl() polling code. 185 Fix data_buffer_length usage in tw_chrdev_ioctl(). 186 Update contact information. 187 1.26.02.000 - Convert driver to pci_driver format. 188 1.26.02.001 - Increase max ioctl buffer size to 512 sectors. 189 Make tw_scsi_queue() return 0 for 'Unknown scsi opcode'. 190 Fix tw_remove() to free irq handler/unregister_chrdev() 191 before shutting down card. 192 Change to new 'change_queue_depth' api. 193 Fix 'handled=1' ISR usage, remove bogus IRQ check. 194 1.26.02.002 - Free irq handler in __tw_shutdown(). 195 Turn on RCD bit for caching mode page. 196 Serialize reset code. 197 1.26.02.003 - Force 60 second timeout default. 198*/ 199 200#include <linux/module.h> 201#include <linux/reboot.h> 202#include <linux/spinlock.h> 203#include <linux/interrupt.h> 204#include <linux/moduleparam.h> 205#include <linux/errno.h> 206#include <linux/types.h> 207#include <linux/delay.h> 208#include <linux/gfp.h> 209#include <linux/pci.h> 210#include <linux/time.h> 211#include <linux/mutex.h> 212#include <asm/io.h> 213#include <asm/irq.h> 214#include <asm/uaccess.h> 215#include <scsi/scsi.h> 216#include <scsi/scsi_host.h> 217#include <scsi/scsi_tcq.h> 218#include <scsi/scsi_cmnd.h> 219#include <scsi/scsi_eh.h> 220#include "3w-xxxx.h" 221 222/* Globals */ 223#define TW_DRIVER_VERSION "1.26.02.003" 224static DEFINE_MUTEX(tw_mutex); 225static TW_Device_Extension *tw_device_extension_list[TW_MAX_SLOT]; 226static int tw_device_extension_count = 0; 227static int twe_major = -1; 228 229/* Module parameters */ 230MODULE_AUTHOR("LSI"); 231MODULE_DESCRIPTION("3ware Storage Controller Linux Driver"); 232MODULE_LICENSE("GPL"); 233MODULE_VERSION(TW_DRIVER_VERSION); 234 235/* Function prototypes */ 236static int tw_reset_device_extension(TW_Device_Extension *tw_dev); 237 238/* Functions */ 239 240/* This function will check the status register for unexpected bits */ 241static int tw_check_bits(u32 status_reg_value) 242{ 243 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS) { 244 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): No expected bits (0x%x).\n", status_reg_value); 245 return 1; 246 } 247 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0) { 248 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): Found unexpected bits (0x%x).\n", status_reg_value); 249 return 1; 250 } 251 252 return 0; 253} /* End tw_check_bits() */ 254 255/* This function will print readable messages from status register errors */ 256static int tw_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value, int print_host) 257{ 258 char host[16]; 259 260 dprintk(KERN_WARNING "3w-xxxx: tw_decode_bits()\n"); 261 262 if (print_host) 263 sprintf(host, " scsi%d:", tw_dev->host->host_no); 264 else 265 host[0] = '\0'; 266 267 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) { 268 printk(KERN_WARNING "3w-xxxx:%s PCI Parity Error: clearing.\n", host); 269 outl(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 270 } 271 272 if (status_reg_value & TW_STATUS_PCI_ABORT) { 273 printk(KERN_WARNING "3w-xxxx:%s PCI Abort: clearing.\n", host); 274 outl(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev)); 275 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT); 276 } 277 278 if (status_reg_value & TW_STATUS_QUEUE_ERROR) { 279 printk(KERN_WARNING "3w-xxxx:%s Controller Queue Error: clearing.\n", host); 280 outl(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 281 } 282 283 if (status_reg_value & TW_STATUS_SBUF_WRITE_ERROR) { 284 printk(KERN_WARNING "3w-xxxx:%s SBUF Write Error: clearing.\n", host); 285 outl(TW_CONTROL_CLEAR_SBUF_WRITE_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 286 } 287 288 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) { 289 if (tw_dev->reset_print == 0) { 290 printk(KERN_WARNING "3w-xxxx:%s Microcontroller Error: clearing.\n", host); 291 tw_dev->reset_print = 1; 292 } 293 return 1; 294 } 295 296 return 0; 297} /* End tw_decode_bits() */ 298 299/* This function will poll the status register for a flag */ 300static int tw_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds) 301{ 302 u32 status_reg_value; 303 unsigned long before; 304 int retval = 1; 305 306 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 307 before = jiffies; 308 309 if (tw_check_bits(status_reg_value)) 310 tw_decode_bits(tw_dev, status_reg_value, 0); 311 312 while ((status_reg_value & flag) != flag) { 313 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 314 315 if (tw_check_bits(status_reg_value)) 316 tw_decode_bits(tw_dev, status_reg_value, 0); 317 318 if (time_after(jiffies, before + HZ * seconds)) 319 goto out; 320 321 msleep(50); 322 } 323 retval = 0; 324out: 325 return retval; 326} /* End tw_poll_status() */ 327 328/* This function will poll the status register for disappearance of a flag */ 329static int tw_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds) 330{ 331 u32 status_reg_value; 332 unsigned long before; 333 int retval = 1; 334 335 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 336 before = jiffies; 337 338 if (tw_check_bits(status_reg_value)) 339 tw_decode_bits(tw_dev, status_reg_value, 0); 340 341 while ((status_reg_value & flag) != 0) { 342 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 343 344 if (tw_check_bits(status_reg_value)) 345 tw_decode_bits(tw_dev, status_reg_value, 0); 346 347 if (time_after(jiffies, before + HZ * seconds)) 348 goto out; 349 350 msleep(50); 351 } 352 retval = 0; 353out: 354 return retval; 355} /* End tw_poll_status_gone() */ 356 357/* This function will attempt to post a command packet to the board */ 358static int tw_post_command_packet(TW_Device_Extension *tw_dev, int request_id) 359{ 360 u32 status_reg_value; 361 unsigned long command_que_value; 362 363 dprintk(KERN_NOTICE "3w-xxxx: tw_post_command_packet()\n"); 364 command_que_value = tw_dev->command_packet_physical_address[request_id]; 365 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 366 367 if (tw_check_bits(status_reg_value)) { 368 dprintk(KERN_WARNING "3w-xxxx: tw_post_command_packet(): Unexpected bits.\n"); 369 tw_decode_bits(tw_dev, status_reg_value, 1); 370 } 371 372 if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) { 373 /* We successfully posted the command packet */ 374 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 375 tw_dev->state[request_id] = TW_S_POSTED; 376 tw_dev->posted_request_count++; 377 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) { 378 tw_dev->max_posted_request_count = tw_dev->posted_request_count; 379 } 380 } else { 381 /* Couldn't post the command packet, so we do it in the isr */ 382 if (tw_dev->state[request_id] != TW_S_PENDING) { 383 tw_dev->state[request_id] = TW_S_PENDING; 384 tw_dev->pending_request_count++; 385 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) { 386 tw_dev->max_pending_request_count = tw_dev->pending_request_count; 387 } 388 tw_dev->pending_queue[tw_dev->pending_tail] = request_id; 389 if (tw_dev->pending_tail == TW_Q_LENGTH-1) { 390 tw_dev->pending_tail = TW_Q_START; 391 } else { 392 tw_dev->pending_tail = tw_dev->pending_tail + 1; 393 } 394 } 395 TW_UNMASK_COMMAND_INTERRUPT(tw_dev); 396 return 1; 397 } 398 return 0; 399} /* End tw_post_command_packet() */ 400 401/* This function will return valid sense buffer information for failed cmds */ 402static int tw_decode_sense(TW_Device_Extension *tw_dev, int request_id, int fill_sense) 403{ 404 int i; 405 TW_Command *command; 406 407 dprintk(KERN_WARNING "3w-xxxx: tw_decode_sense()\n"); 408 command = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 409 410 printk(KERN_WARNING "3w-xxxx: scsi%d: Command failed: status = 0x%x, flags = 0x%x, unit #%d.\n", tw_dev->host->host_no, command->status, command->flags, TW_UNIT_OUT(command->unit__hostid)); 411 412 /* Attempt to return intelligent sense information */ 413 if (fill_sense) { 414 if ((command->status == 0xc7) || (command->status == 0xcb)) { 415 for (i = 0; i < ARRAY_SIZE(tw_sense_table); i++) { 416 if (command->flags == tw_sense_table[i][0]) { 417 418 /* Valid bit and 'current errors' */ 419 tw_dev->srb[request_id]->sense_buffer[0] = (0x1 << 7 | 0x70); 420 421 /* Sense key */ 422 tw_dev->srb[request_id]->sense_buffer[2] = tw_sense_table[i][1]; 423 424 /* Additional sense length */ 425 tw_dev->srb[request_id]->sense_buffer[7] = 0xa; /* 10 bytes */ 426 427 /* Additional sense code */ 428 tw_dev->srb[request_id]->sense_buffer[12] = tw_sense_table[i][2]; 429 430 /* Additional sense code qualifier */ 431 tw_dev->srb[request_id]->sense_buffer[13] = tw_sense_table[i][3]; 432 433 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1); 434 return TW_ISR_DONT_RESULT; /* Special case for isr to not over-write result */ 435 } 436 } 437 } 438 439 /* If no table match, error so we get a reset */ 440 return 1; 441 } 442 443 return 0; 444} /* End tw_decode_sense() */ 445 446/* This function will report controller error status */ 447static int tw_check_errors(TW_Device_Extension *tw_dev) 448{ 449 u32 status_reg_value; 450 451 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 452 453 if (TW_STATUS_ERRORS(status_reg_value) || tw_check_bits(status_reg_value)) { 454 tw_decode_bits(tw_dev, status_reg_value, 0); 455 return 1; 456 } 457 458 return 0; 459} /* End tw_check_errors() */ 460 461/* This function will empty the response que */ 462static void tw_empty_response_que(TW_Device_Extension *tw_dev) 463{ 464 u32 status_reg_value, response_que_value; 465 466 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 467 468 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) { 469 response_que_value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 470 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 471 } 472} /* End tw_empty_response_que() */ 473 474/* This function will free a request_id */ 475static void tw_state_request_finish(TW_Device_Extension *tw_dev, int request_id) 476{ 477 tw_dev->free_queue[tw_dev->free_tail] = request_id; 478 tw_dev->state[request_id] = TW_S_FINISHED; 479 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH; 480} /* End tw_state_request_finish() */ 481 482/* This function will assign an available request_id */ 483static void tw_state_request_start(TW_Device_Extension *tw_dev, int *request_id) 484{ 485 *request_id = tw_dev->free_queue[tw_dev->free_head]; 486 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH; 487 tw_dev->state[*request_id] = TW_S_STARTED; 488} /* End tw_state_request_start() */ 489 490/* Show some statistics about the card */ 491static ssize_t tw_show_stats(struct device *dev, struct device_attribute *attr, 492 char *buf) 493{ 494 struct Scsi_Host *host = class_to_shost(dev); 495 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 496 unsigned long flags = 0; 497 ssize_t len; 498 499 spin_lock_irqsave(tw_dev->host->host_lock, flags); 500 len = snprintf(buf, PAGE_SIZE, "3w-xxxx Driver version: %s\n" 501 "Current commands posted: %4d\n" 502 "Max commands posted: %4d\n" 503 "Current pending commands: %4d\n" 504 "Max pending commands: %4d\n" 505 "Last sgl length: %4d\n" 506 "Max sgl length: %4d\n" 507 "Last sector count: %4d\n" 508 "Max sector count: %4d\n" 509 "SCSI Host Resets: %4d\n" 510 "AEN's: %4d\n", 511 TW_DRIVER_VERSION, 512 tw_dev->posted_request_count, 513 tw_dev->max_posted_request_count, 514 tw_dev->pending_request_count, 515 tw_dev->max_pending_request_count, 516 tw_dev->sgl_entries, 517 tw_dev->max_sgl_entries, 518 tw_dev->sector_count, 519 tw_dev->max_sector_count, 520 tw_dev->num_resets, 521 tw_dev->aen_count); 522 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 523 return len; 524} /* End tw_show_stats() */ 525 526/* Create sysfs 'stats' entry */ 527static struct device_attribute tw_host_stats_attr = { 528 .attr = { 529 .name = "stats", 530 .mode = S_IRUGO, 531 }, 532 .show = tw_show_stats 533}; 534 535/* Host attributes initializer */ 536static struct device_attribute *tw_host_attrs[] = { 537 &tw_host_stats_attr, 538 NULL, 539}; 540 541/* This function will read the aen queue from the isr */ 542static int tw_aen_read_queue(TW_Device_Extension *tw_dev, int request_id) 543{ 544 TW_Command *command_packet; 545 TW_Param *param; 546 unsigned long command_que_value; 547 u32 status_reg_value; 548 unsigned long param_value = 0; 549 550 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_read_queue()\n"); 551 552 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 553 if (tw_check_bits(status_reg_value)) { 554 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Unexpected bits.\n"); 555 tw_decode_bits(tw_dev, status_reg_value, 1); 556 return 1; 557 } 558 if (tw_dev->command_packet_virtual_address[request_id] == NULL) { 559 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet virtual address.\n"); 560 return 1; 561 } 562 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 563 memset(command_packet, 0, sizeof(TW_Sector)); 564 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 565 command_packet->size = 4; 566 command_packet->request_id = request_id; 567 command_packet->status = 0; 568 command_packet->flags = 0; 569 command_packet->byte6.parameter_count = 1; 570 command_que_value = tw_dev->command_packet_physical_address[request_id]; 571 if (command_que_value == 0) { 572 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet physical address.\n"); 573 return 1; 574 } 575 /* Now setup the param */ 576 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 577 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment virtual address.\n"); 578 return 1; 579 } 580 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 581 memset(param, 0, sizeof(TW_Sector)); 582 param->table_id = 0x401; /* AEN table */ 583 param->parameter_id = 2; /* Unit code */ 584 param->parameter_size_bytes = 2; 585 param_value = tw_dev->alignment_physical_address[request_id]; 586 if (param_value == 0) { 587 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment physical address.\n"); 588 return 1; 589 } 590 command_packet->byte8.param.sgl[0].address = param_value; 591 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 592 593 /* Now post the command packet */ 594 if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) { 595 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post succeeded.\n"); 596 tw_dev->srb[request_id] = NULL; /* Flag internal command */ 597 tw_dev->state[request_id] = TW_S_POSTED; 598 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 599 } else { 600 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post failed, will retry.\n"); 601 return 1; 602 } 603 604 return 0; 605} /* End tw_aen_read_queue() */ 606 607/* This function will complete an aen request from the isr */ 608static int tw_aen_complete(TW_Device_Extension *tw_dev, int request_id) 609{ 610 TW_Param *param; 611 unsigned short aen; 612 int error = 0, table_max = 0; 613 614 dprintk(KERN_WARNING "3w-xxxx: tw_aen_complete()\n"); 615 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 616 printk(KERN_WARNING "3w-xxxx: tw_aen_complete(): Bad alignment virtual address.\n"); 617 return 1; 618 } 619 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 620 aen = *(unsigned short *)(param->data); 621 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_complete(): Queue'd code 0x%x\n", aen); 622 623 /* Print some useful info when certain aen codes come out */ 624 if (aen == 0x0ff) { 625 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: INFO: AEN queue overflow.\n", tw_dev->host->host_no); 626 } else { 627 table_max = ARRAY_SIZE(tw_aen_string); 628 if ((aen & 0x0ff) < table_max) { 629 if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') { 630 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s%d.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff], aen >> 8); 631 } else { 632 if (aen != 0x0) 633 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff]); 634 } 635 } else { 636 printk(KERN_WARNING "3w-xxxx: scsi%d: Received AEN %d.\n", tw_dev->host->host_no, aen); 637 } 638 } 639 if (aen != TW_AEN_QUEUE_EMPTY) { 640 tw_dev->aen_count++; 641 642 /* Now queue the code */ 643 tw_dev->aen_queue[tw_dev->aen_tail] = aen; 644 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) { 645 tw_dev->aen_tail = TW_Q_START; 646 } else { 647 tw_dev->aen_tail = tw_dev->aen_tail + 1; 648 } 649 if (tw_dev->aen_head == tw_dev->aen_tail) { 650 if (tw_dev->aen_head == TW_Q_LENGTH - 1) { 651 tw_dev->aen_head = TW_Q_START; 652 } else { 653 tw_dev->aen_head = tw_dev->aen_head + 1; 654 } 655 } 656 657 error = tw_aen_read_queue(tw_dev, request_id); 658 if (error) { 659 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing AEN.\n", tw_dev->host->host_no); 660 tw_dev->state[request_id] = TW_S_COMPLETED; 661 tw_state_request_finish(tw_dev, request_id); 662 } 663 } else { 664 tw_dev->state[request_id] = TW_S_COMPLETED; 665 tw_state_request_finish(tw_dev, request_id); 666 } 667 668 return 0; 669} /* End tw_aen_complete() */ 670 671/* This function will drain the aen queue after a soft reset */ 672static int tw_aen_drain_queue(TW_Device_Extension *tw_dev) 673{ 674 TW_Command *command_packet; 675 TW_Param *param; 676 int request_id = 0; 677 unsigned long command_que_value; 678 unsigned long param_value; 679 TW_Response_Queue response_queue; 680 unsigned short aen; 681 unsigned short aen_code; 682 int finished = 0; 683 int first_reset = 0; 684 int queue = 0; 685 int found = 0, table_max = 0; 686 687 dprintk(KERN_NOTICE "3w-xxxx: tw_aen_drain_queue()\n"); 688 689 if (tw_poll_status(tw_dev, TW_STATUS_ATTENTION_INTERRUPT | TW_STATUS_MICROCONTROLLER_READY, 30)) { 690 dprintk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): No attention interrupt for card %d.\n", tw_device_extension_count); 691 return 1; 692 } 693 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev); 694 695 /* Empty response queue */ 696 tw_empty_response_que(tw_dev); 697 698 /* Initialize command packet */ 699 if (tw_dev->command_packet_virtual_address[request_id] == NULL) { 700 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet virtual address.\n"); 701 return 1; 702 } 703 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 704 memset(command_packet, 0, sizeof(TW_Sector)); 705 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 706 command_packet->size = 4; 707 command_packet->request_id = request_id; 708 command_packet->status = 0; 709 command_packet->flags = 0; 710 command_packet->byte6.parameter_count = 1; 711 command_que_value = tw_dev->command_packet_physical_address[request_id]; 712 if (command_que_value == 0) { 713 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet physical address.\n"); 714 return 1; 715 } 716 717 /* Now setup the param */ 718 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 719 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment virtual address.\n"); 720 return 1; 721 } 722 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 723 memset(param, 0, sizeof(TW_Sector)); 724 param->table_id = 0x401; /* AEN table */ 725 param->parameter_id = 2; /* Unit code */ 726 param->parameter_size_bytes = 2; 727 param_value = tw_dev->alignment_physical_address[request_id]; 728 if (param_value == 0) { 729 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment physical address.\n"); 730 return 1; 731 } 732 command_packet->byte8.param.sgl[0].address = param_value; 733 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 734 735 /* Now drain the controller's aen queue */ 736 do { 737 /* Post command packet */ 738 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 739 740 /* Now poll for completion */ 741 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) { 742 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 743 request_id = TW_RESID_OUT(response_queue.response_id); 744 745 if (request_id != 0) { 746 /* Unexpected request id */ 747 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Unexpected request id.\n"); 748 return 1; 749 } 750 751 if (command_packet->status != 0) { 752 if (command_packet->flags != TW_AEN_TABLE_UNDEFINED) { 753 /* Bad response */ 754 tw_decode_sense(tw_dev, request_id, 0); 755 return 1; 756 } else { 757 /* We know this is a 3w-1x00, and doesn't support aen's */ 758 return 0; 759 } 760 } 761 762 /* Now check the aen */ 763 aen = *(unsigned short *)(param->data); 764 aen_code = (aen & 0x0ff); 765 queue = 0; 766 switch (aen_code) { 767 case TW_AEN_QUEUE_EMPTY: 768 dprintk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]); 769 if (first_reset != 1) { 770 return 1; 771 } else { 772 finished = 1; 773 } 774 break; 775 case TW_AEN_SOFT_RESET: 776 if (first_reset == 0) { 777 first_reset = 1; 778 } else { 779 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]); 780 tw_dev->aen_count++; 781 queue = 1; 782 } 783 break; 784 default: 785 if (aen == 0x0ff) { 786 printk(KERN_WARNING "3w-xxxx: AEN: INFO: AEN queue overflow.\n"); 787 } else { 788 table_max = ARRAY_SIZE(tw_aen_string); 789 if ((aen & 0x0ff) < table_max) { 790 if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') { 791 printk(KERN_WARNING "3w-xxxx: AEN: %s%d.\n", tw_aen_string[aen & 0xff], aen >> 8); 792 } else { 793 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]); 794 } 795 } else 796 printk(KERN_WARNING "3w-xxxx: Received AEN %d.\n", aen); 797 } 798 tw_dev->aen_count++; 799 queue = 1; 800 } 801 802 /* Now put the aen on the aen_queue */ 803 if (queue == 1) { 804 tw_dev->aen_queue[tw_dev->aen_tail] = aen; 805 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) { 806 tw_dev->aen_tail = TW_Q_START; 807 } else { 808 tw_dev->aen_tail = tw_dev->aen_tail + 1; 809 } 810 if (tw_dev->aen_head == tw_dev->aen_tail) { 811 if (tw_dev->aen_head == TW_Q_LENGTH - 1) { 812 tw_dev->aen_head = TW_Q_START; 813 } else { 814 tw_dev->aen_head = tw_dev->aen_head + 1; 815 } 816 } 817 } 818 found = 1; 819 } 820 if (found == 0) { 821 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Response never received.\n"); 822 return 1; 823 } 824 } while (finished == 0); 825 826 return 0; 827} /* End tw_aen_drain_queue() */ 828 829/* This function will allocate memory */ 830static int tw_allocate_memory(TW_Device_Extension *tw_dev, int size, int which) 831{ 832 int i; 833 dma_addr_t dma_handle; 834 unsigned long *cpu_addr = NULL; 835 836 dprintk(KERN_NOTICE "3w-xxxx: tw_allocate_memory()\n"); 837 838 cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle); 839 if (cpu_addr == NULL) { 840 printk(KERN_WARNING "3w-xxxx: pci_alloc_consistent() failed.\n"); 841 return 1; 842 } 843 844 if ((unsigned long)cpu_addr % (tw_dev->tw_pci_dev->device == TW_DEVICE_ID ? TW_ALIGNMENT_6000 : TW_ALIGNMENT_7000)) { 845 printk(KERN_WARNING "3w-xxxx: Couldn't allocate correctly aligned memory.\n"); 846 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle); 847 return 1; 848 } 849 850 memset(cpu_addr, 0, size*TW_Q_LENGTH); 851 852 for (i=0;i<TW_Q_LENGTH;i++) { 853 switch(which) { 854 case 0: 855 tw_dev->command_packet_physical_address[i] = dma_handle+(i*size); 856 tw_dev->command_packet_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size)); 857 break; 858 case 1: 859 tw_dev->alignment_physical_address[i] = dma_handle+(i*size); 860 tw_dev->alignment_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size)); 861 break; 862 default: 863 printk(KERN_WARNING "3w-xxxx: tw_allocate_memory(): case slip in tw_allocate_memory()\n"); 864 return 1; 865 } 866 } 867 868 return 0; 869} /* End tw_allocate_memory() */ 870 871/* This function handles ioctl for the character device */ 872static long tw_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 873{ 874 int request_id; 875 dma_addr_t dma_handle; 876 unsigned short tw_aen_code; 877 unsigned long flags; 878 unsigned int data_buffer_length = 0; 879 unsigned long data_buffer_length_adjusted = 0; 880 struct inode *inode = file_inode(file); 881 unsigned long *cpu_addr; 882 long timeout; 883 TW_New_Ioctl *tw_ioctl; 884 TW_Passthru *passthru; 885 TW_Device_Extension *tw_dev = tw_device_extension_list[iminor(inode)]; 886 int retval = -EFAULT; 887 void __user *argp = (void __user *)arg; 888 889 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n"); 890 891 mutex_lock(&tw_mutex); 892 /* Only let one of these through at a time */ 893 if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) { 894 mutex_unlock(&tw_mutex); 895 return -EINTR; 896 } 897 898 /* First copy down the buffer length */ 899 if (copy_from_user(&data_buffer_length, argp, sizeof(unsigned int))) 900 goto out; 901 902 /* Check size */ 903 if (data_buffer_length > TW_MAX_IOCTL_SECTORS * 512) { 904 retval = -EINVAL; 905 goto out; 906 } 907 908 /* Hardware can only do multiple of 512 byte transfers */ 909 data_buffer_length_adjusted = (data_buffer_length + 511) & ~511; 910 911 /* Now allocate ioctl buf memory */ 912 cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, &dma_handle, GFP_KERNEL); 913 if (cpu_addr == NULL) { 914 retval = -ENOMEM; 915 goto out; 916 } 917 918 tw_ioctl = (TW_New_Ioctl *)cpu_addr; 919 920 /* Now copy down the entire ioctl */ 921 if (copy_from_user(tw_ioctl, argp, data_buffer_length + sizeof(TW_New_Ioctl) - 1)) 922 goto out2; 923 924 passthru = (TW_Passthru *)&tw_ioctl->firmware_command; 925 926 /* See which ioctl we are doing */ 927 switch (cmd) { 928 case TW_OP_NOP: 929 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_OP_NOP.\n"); 930 break; 931 case TW_OP_AEN_LISTEN: 932 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_AEN_LISTEN.\n"); 933 memset(tw_ioctl->data_buffer, 0, data_buffer_length); 934 935 spin_lock_irqsave(tw_dev->host->host_lock, flags); 936 if (tw_dev->aen_head == tw_dev->aen_tail) { 937 tw_aen_code = TW_AEN_QUEUE_EMPTY; 938 } else { 939 tw_aen_code = tw_dev->aen_queue[tw_dev->aen_head]; 940 if (tw_dev->aen_head == TW_Q_LENGTH - 1) { 941 tw_dev->aen_head = TW_Q_START; 942 } else { 943 tw_dev->aen_head = tw_dev->aen_head + 1; 944 } 945 } 946 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 947 memcpy(tw_ioctl->data_buffer, &tw_aen_code, sizeof(tw_aen_code)); 948 break; 949 case TW_CMD_PACKET_WITH_DATA: 950 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n"); 951 spin_lock_irqsave(tw_dev->host->host_lock, flags); 952 953 tw_state_request_start(tw_dev, &request_id); 954 955 /* Flag internal command */ 956 tw_dev->srb[request_id] = NULL; 957 958 /* Flag chrdev ioctl */ 959 tw_dev->chrdev_request_id = request_id; 960 961 tw_ioctl->firmware_command.request_id = request_id; 962 963 /* Load the sg list */ 964 switch (TW_SGL_OUT(tw_ioctl->firmware_command.opcode__sgloffset)) { 965 case 2: 966 tw_ioctl->firmware_command.byte8.param.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1; 967 tw_ioctl->firmware_command.byte8.param.sgl[0].length = data_buffer_length_adjusted; 968 break; 969 case 3: 970 tw_ioctl->firmware_command.byte8.io.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1; 971 tw_ioctl->firmware_command.byte8.io.sgl[0].length = data_buffer_length_adjusted; 972 break; 973 case 5: 974 passthru->sg_list[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1; 975 passthru->sg_list[0].length = data_buffer_length_adjusted; 976 break; 977 } 978 979 memcpy(tw_dev->command_packet_virtual_address[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command)); 980 981 /* Now post the command packet to the controller */ 982 tw_post_command_packet(tw_dev, request_id); 983 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 984 985 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ; 986 987 /* Now wait for the command to complete */ 988 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout); 989 990 /* We timed out, and didn't get an interrupt */ 991 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) { 992 /* Now we need to reset the board */ 993 printk(KERN_WARNING "3w-xxxx: scsi%d: Character ioctl (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, cmd); 994 retval = -EIO; 995 if (tw_reset_device_extension(tw_dev)) { 996 printk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): Reset failed for card %d.\n", tw_dev->host->host_no); 997 } 998 goto out2; 999 } 1000 1001 /* Now copy in the command packet response */ 1002 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command)); 1003 1004 /* Now complete the io */ 1005 spin_lock_irqsave(tw_dev->host->host_lock, flags); 1006 tw_dev->posted_request_count--; 1007 tw_dev->state[request_id] = TW_S_COMPLETED; 1008 tw_state_request_finish(tw_dev, request_id); 1009 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 1010 break; 1011 default: 1012 retval = -ENOTTY; 1013 goto out2; 1014 } 1015 1016 /* Now copy the response to userspace */ 1017 if (copy_to_user(argp, tw_ioctl, sizeof(TW_New_Ioctl) + data_buffer_length - 1)) 1018 goto out2; 1019 retval = 0; 1020out2: 1021 /* Now free ioctl buf memory */ 1022 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, cpu_addr, dma_handle); 1023out: 1024 mutex_unlock(&tw_dev->ioctl_lock); 1025 mutex_unlock(&tw_mutex); 1026 return retval; 1027} /* End tw_chrdev_ioctl() */ 1028 1029/* This function handles open for the character device */ 1030/* NOTE that this function races with remove. */ 1031static int tw_chrdev_open(struct inode *inode, struct file *file) 1032{ 1033 unsigned int minor_number; 1034 1035 dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_open()\n"); 1036 1037 minor_number = iminor(inode); 1038 if (minor_number >= tw_device_extension_count) 1039 return -ENODEV; 1040 1041 return 0; 1042} /* End tw_chrdev_open() */ 1043 1044/* File operations struct for character device */ 1045static const struct file_operations tw_fops = { 1046 .owner = THIS_MODULE, 1047 .unlocked_ioctl = tw_chrdev_ioctl, 1048 .open = tw_chrdev_open, 1049 .release = NULL, 1050 .llseek = noop_llseek, 1051}; 1052 1053/* This function will free up device extension resources */ 1054static void tw_free_device_extension(TW_Device_Extension *tw_dev) 1055{ 1056 dprintk(KERN_NOTICE "3w-xxxx: tw_free_device_extension()\n"); 1057 1058 /* Free command packet and generic buffer memory */ 1059 if (tw_dev->command_packet_virtual_address[0]) 1060 pci_free_consistent(tw_dev->tw_pci_dev, sizeof(TW_Command)*TW_Q_LENGTH, tw_dev->command_packet_virtual_address[0], tw_dev->command_packet_physical_address[0]); 1061 1062 if (tw_dev->alignment_virtual_address[0]) 1063 pci_free_consistent(tw_dev->tw_pci_dev, sizeof(TW_Sector)*TW_Q_LENGTH, tw_dev->alignment_virtual_address[0], tw_dev->alignment_physical_address[0]); 1064} /* End tw_free_device_extension() */ 1065 1066/* This function will send an initconnection command to controller */ 1067static int tw_initconnection(TW_Device_Extension *tw_dev, int message_credits) 1068{ 1069 unsigned long command_que_value; 1070 TW_Command *command_packet; 1071 TW_Response_Queue response_queue; 1072 int request_id = 0; 1073 1074 dprintk(KERN_NOTICE "3w-xxxx: tw_initconnection()\n"); 1075 1076 /* Initialize InitConnection command packet */ 1077 if (tw_dev->command_packet_virtual_address[request_id] == NULL) { 1078 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet virtual address.\n"); 1079 return 1; 1080 } 1081 1082 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1083 memset(command_packet, 0, sizeof(TW_Sector)); 1084 command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_INIT_CONNECTION); 1085 command_packet->size = TW_INIT_COMMAND_PACKET_SIZE; 1086 command_packet->request_id = request_id; 1087 command_packet->status = 0x0; 1088 command_packet->flags = 0x0; 1089 command_packet->byte6.message_credits = message_credits; 1090 command_packet->byte8.init_connection.response_queue_pointer = 0x0; 1091 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1092 1093 if (command_que_value == 0) { 1094 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet physical address.\n"); 1095 return 1; 1096 } 1097 1098 /* Send command packet to the board */ 1099 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 1100 1101 /* Poll for completion */ 1102 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) { 1103 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 1104 request_id = TW_RESID_OUT(response_queue.response_id); 1105 1106 if (request_id != 0) { 1107 /* unexpected request id */ 1108 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Unexpected request id.\n"); 1109 return 1; 1110 } 1111 if (command_packet->status != 0) { 1112 /* bad response */ 1113 tw_decode_sense(tw_dev, request_id, 0); 1114 return 1; 1115 } 1116 } 1117 return 0; 1118} /* End tw_initconnection() */ 1119 1120/* Set a value in the features table */ 1121static int tw_setfeature(TW_Device_Extension *tw_dev, int parm, int param_size, 1122 unsigned char *val) 1123{ 1124 TW_Param *param; 1125 TW_Command *command_packet; 1126 TW_Response_Queue response_queue; 1127 int request_id = 0; 1128 unsigned long command_que_value; 1129 unsigned long param_value; 1130 1131 /* Initialize SetParam command packet */ 1132 if (tw_dev->command_packet_virtual_address[request_id] == NULL) { 1133 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet virtual address.\n"); 1134 return 1; 1135 } 1136 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1137 memset(command_packet, 0, sizeof(TW_Sector)); 1138 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1139 1140 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM); 1141 param->table_id = 0x404; /* Features table */ 1142 param->parameter_id = parm; 1143 param->parameter_size_bytes = param_size; 1144 memcpy(param->data, val, param_size); 1145 1146 param_value = tw_dev->alignment_physical_address[request_id]; 1147 if (param_value == 0) { 1148 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad alignment physical address.\n"); 1149 tw_dev->state[request_id] = TW_S_COMPLETED; 1150 tw_state_request_finish(tw_dev, request_id); 1151 tw_dev->srb[request_id]->result = (DID_OK << 16); 1152 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 1153 } 1154 command_packet->byte8.param.sgl[0].address = param_value; 1155 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1156 1157 command_packet->size = 4; 1158 command_packet->request_id = request_id; 1159 command_packet->byte6.parameter_count = 1; 1160 1161 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1162 if (command_que_value == 0) { 1163 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet physical address.\n"); 1164 return 1; 1165 } 1166 1167 /* Send command packet to the board */ 1168 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 1169 1170 /* Poll for completion */ 1171 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) { 1172 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 1173 request_id = TW_RESID_OUT(response_queue.response_id); 1174 1175 if (request_id != 0) { 1176 /* unexpected request id */ 1177 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Unexpected request id.\n"); 1178 return 1; 1179 } 1180 if (command_packet->status != 0) { 1181 /* bad response */ 1182 tw_decode_sense(tw_dev, request_id, 0); 1183 return 1; 1184 } 1185 } 1186 1187 return 0; 1188} /* End tw_setfeature() */ 1189 1190/* This function will reset a controller */ 1191static int tw_reset_sequence(TW_Device_Extension *tw_dev) 1192{ 1193 int error = 0; 1194 int tries = 0; 1195 unsigned char c = 1; 1196 1197 /* Reset the board */ 1198 while (tries < TW_MAX_RESET_TRIES) { 1199 TW_SOFT_RESET(tw_dev); 1200 1201 error = tw_aen_drain_queue(tw_dev); 1202 if (error) { 1203 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN drain failed, retrying.\n", tw_dev->host->host_no); 1204 tries++; 1205 continue; 1206 } 1207 1208 /* Check for controller errors */ 1209 if (tw_check_errors(tw_dev)) { 1210 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors found, retrying.\n", tw_dev->host->host_no); 1211 tries++; 1212 continue; 1213 } 1214 1215 /* Now the controller is in a good state */ 1216 break; 1217 } 1218 1219 if (tries >= TW_MAX_RESET_TRIES) { 1220 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors, card not responding, check all cabling.\n", tw_dev->host->host_no); 1221 return 1; 1222 } 1223 1224 error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS); 1225 if (error) { 1226 printk(KERN_WARNING "3w-xxxx: scsi%d: Connection initialization failed.\n", tw_dev->host->host_no); 1227 return 1; 1228 } 1229 1230 error = tw_setfeature(tw_dev, 2, 1, &c); 1231 if (error) { 1232 printk(KERN_WARNING "3w-xxxx: Unable to set features for card, probable old firmware or card.\n"); 1233 } 1234 1235 return 0; 1236} /* End tw_reset_sequence() */ 1237 1238/* This function will initialize the fields of a device extension */ 1239static int tw_initialize_device_extension(TW_Device_Extension *tw_dev) 1240{ 1241 int i, error=0; 1242 1243 dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_device_extension()\n"); 1244 1245 /* Initialize command packet buffers */ 1246 error = tw_allocate_memory(tw_dev, sizeof(TW_Command), 0); 1247 if (error) { 1248 printk(KERN_WARNING "3w-xxxx: Command packet memory allocation failed.\n"); 1249 return 1; 1250 } 1251 1252 /* Initialize generic buffer */ 1253 error = tw_allocate_memory(tw_dev, sizeof(TW_Sector), 1); 1254 if (error) { 1255 printk(KERN_WARNING "3w-xxxx: Generic memory allocation failed.\n"); 1256 return 1; 1257 } 1258 1259 for (i=0;i<TW_Q_LENGTH;i++) { 1260 tw_dev->free_queue[i] = i; 1261 tw_dev->state[i] = TW_S_INITIAL; 1262 } 1263 1264 tw_dev->pending_head = TW_Q_START; 1265 tw_dev->pending_tail = TW_Q_START; 1266 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1267 1268 mutex_init(&tw_dev->ioctl_lock); 1269 init_waitqueue_head(&tw_dev->ioctl_wqueue); 1270 1271 return 0; 1272} /* End tw_initialize_device_extension() */ 1273 1274/* This function will reset a device extension */ 1275static int tw_reset_device_extension(TW_Device_Extension *tw_dev) 1276{ 1277 int i = 0; 1278 struct scsi_cmnd *srb; 1279 unsigned long flags = 0; 1280 1281 dprintk(KERN_NOTICE "3w-xxxx: tw_reset_device_extension()\n"); 1282 1283 set_bit(TW_IN_RESET, &tw_dev->flags); 1284 TW_DISABLE_INTERRUPTS(tw_dev); 1285 TW_MASK_COMMAND_INTERRUPT(tw_dev); 1286 spin_lock_irqsave(tw_dev->host->host_lock, flags); 1287 1288 /* Abort all requests that are in progress */ 1289 for (i=0;i<TW_Q_LENGTH;i++) { 1290 if ((tw_dev->state[i] != TW_S_FINISHED) && 1291 (tw_dev->state[i] != TW_S_INITIAL) && 1292 (tw_dev->state[i] != TW_S_COMPLETED)) { 1293 srb = tw_dev->srb[i]; 1294 if (srb != NULL) { 1295 srb->result = (DID_RESET << 16); 1296 scsi_dma_unmap(srb); 1297 srb->scsi_done(srb); 1298 } 1299 } 1300 } 1301 1302 /* Reset queues and counts */ 1303 for (i=0;i<TW_Q_LENGTH;i++) { 1304 tw_dev->free_queue[i] = i; 1305 tw_dev->state[i] = TW_S_INITIAL; 1306 } 1307 tw_dev->free_head = TW_Q_START; 1308 tw_dev->free_tail = TW_Q_START; 1309 tw_dev->posted_request_count = 0; 1310 tw_dev->pending_request_count = 0; 1311 tw_dev->pending_head = TW_Q_START; 1312 tw_dev->pending_tail = TW_Q_START; 1313 tw_dev->reset_print = 0; 1314 1315 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 1316 1317 if (tw_reset_sequence(tw_dev)) { 1318 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset sequence failed.\n", tw_dev->host->host_no); 1319 return 1; 1320 } 1321 1322 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 1323 clear_bit(TW_IN_RESET, &tw_dev->flags); 1324 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1325 1326 return 0; 1327} /* End tw_reset_device_extension() */ 1328 1329/* This funciton returns unit geometry in cylinders/heads/sectors */ 1330static int tw_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, 1331 sector_t capacity, int geom[]) 1332{ 1333 int heads, sectors, cylinders; 1334 TW_Device_Extension *tw_dev; 1335 1336 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam()\n"); 1337 tw_dev = (TW_Device_Extension *)sdev->host->hostdata; 1338 1339 heads = 64; 1340 sectors = 32; 1341 cylinders = sector_div(capacity, heads * sectors); 1342 1343 if (capacity >= 0x200000) { 1344 heads = 255; 1345 sectors = 63; 1346 cylinders = sector_div(capacity, heads * sectors); 1347 } 1348 1349 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam(): heads = %d, sectors = %d, cylinders = %d\n", heads, sectors, cylinders); 1350 geom[0] = heads; 1351 geom[1] = sectors; 1352 geom[2] = cylinders; 1353 1354 return 0; 1355} /* End tw_scsi_biosparam() */ 1356 1357/* This is the new scsi eh reset function */ 1358static int tw_scsi_eh_reset(struct scsi_cmnd *SCpnt) 1359{ 1360 TW_Device_Extension *tw_dev=NULL; 1361 int retval = FAILED; 1362 1363 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 1364 1365 tw_dev->num_resets++; 1366 1367 sdev_printk(KERN_WARNING, SCpnt->device, 1368 "WARNING: Command (0x%x) timed out, resetting card.\n", 1369 SCpnt->cmnd[0]); 1370 1371 /* Make sure we are not issuing an ioctl or resetting from ioctl */ 1372 mutex_lock(&tw_dev->ioctl_lock); 1373 1374 /* Now reset the card and some of the device extension data */ 1375 if (tw_reset_device_extension(tw_dev)) { 1376 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset failed.\n", tw_dev->host->host_no); 1377 goto out; 1378 } 1379 1380 retval = SUCCESS; 1381out: 1382 mutex_unlock(&tw_dev->ioctl_lock); 1383 return retval; 1384} /* End tw_scsi_eh_reset() */ 1385 1386/* This function handles scsi inquiry commands */ 1387static int tw_scsiop_inquiry(TW_Device_Extension *tw_dev, int request_id) 1388{ 1389 TW_Param *param; 1390 TW_Command *command_packet; 1391 unsigned long command_que_value; 1392 unsigned long param_value; 1393 1394 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry()\n"); 1395 1396 /* Initialize command packet */ 1397 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1398 if (command_packet == NULL) { 1399 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet virtual address.\n"); 1400 return 1; 1401 } 1402 memset(command_packet, 0, sizeof(TW_Sector)); 1403 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1404 command_packet->size = 4; 1405 command_packet->request_id = request_id; 1406 command_packet->status = 0; 1407 command_packet->flags = 0; 1408 command_packet->byte6.parameter_count = 1; 1409 1410 /* Now setup the param */ 1411 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1412 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment virtual address.\n"); 1413 return 1; 1414 } 1415 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1416 memset(param, 0, sizeof(TW_Sector)); 1417 param->table_id = 3; /* unit summary table */ 1418 param->parameter_id = 3; /* unitsstatus parameter */ 1419 param->parameter_size_bytes = TW_MAX_UNITS; 1420 param_value = tw_dev->alignment_physical_address[request_id]; 1421 if (param_value == 0) { 1422 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment physical address.\n"); 1423 return 1; 1424 } 1425 1426 command_packet->byte8.param.sgl[0].address = param_value; 1427 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1428 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1429 if (command_que_value == 0) { 1430 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet physical address.\n"); 1431 return 1; 1432 } 1433 1434 /* Now try to post the command packet */ 1435 tw_post_command_packet(tw_dev, request_id); 1436 1437 return 0; 1438} /* End tw_scsiop_inquiry() */ 1439 1440static void tw_transfer_internal(TW_Device_Extension *tw_dev, int request_id, 1441 void *data, unsigned int len) 1442{ 1443 scsi_sg_copy_from_buffer(tw_dev->srb[request_id], data, len); 1444} 1445 1446/* This function is called by the isr to complete an inquiry command */ 1447static int tw_scsiop_inquiry_complete(TW_Device_Extension *tw_dev, int request_id) 1448{ 1449 unsigned char *is_unit_present; 1450 unsigned char request_buffer[36]; 1451 TW_Param *param; 1452 1453 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry_complete()\n"); 1454 1455 memset(request_buffer, 0, sizeof(request_buffer)); 1456 request_buffer[0] = TYPE_DISK; /* Peripheral device type */ 1457 request_buffer[1] = 0; /* Device type modifier */ 1458 request_buffer[2] = 0; /* No ansi/iso compliance */ 1459 request_buffer[4] = 31; /* Additional length */ 1460 memcpy(&request_buffer[8], "3ware ", 8); /* Vendor ID */ 1461 sprintf(&request_buffer[16], "Logical Disk %-2d ", tw_dev->srb[request_id]->device->id); 1462 memcpy(&request_buffer[32], TW_DRIVER_VERSION, 3); 1463 tw_transfer_internal(tw_dev, request_id, request_buffer, 1464 sizeof(request_buffer)); 1465 1466 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1467 if (param == NULL) { 1468 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Bad alignment virtual address.\n"); 1469 return 1; 1470 } 1471 is_unit_present = &(param->data[0]); 1472 1473 if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) { 1474 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1; 1475 } else { 1476 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0; 1477 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16); 1478 return TW_ISR_DONT_RESULT; 1479 } 1480 1481 return 0; 1482} /* End tw_scsiop_inquiry_complete() */ 1483 1484/* This function handles scsi mode_sense commands */ 1485static int tw_scsiop_mode_sense(TW_Device_Extension *tw_dev, int request_id) 1486{ 1487 TW_Param *param; 1488 TW_Command *command_packet; 1489 unsigned long command_que_value; 1490 unsigned long param_value; 1491 1492 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense()\n"); 1493 1494 /* Only page control = 0, page code = 0x8 (cache page) supported */ 1495 if (tw_dev->srb[request_id]->cmnd[2] != 0x8) { 1496 tw_dev->state[request_id] = TW_S_COMPLETED; 1497 tw_state_request_finish(tw_dev, request_id); 1498 tw_dev->srb[request_id]->result = (DID_OK << 16); 1499 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 1500 return 0; 1501 } 1502 1503 /* Now read firmware cache setting for this unit */ 1504 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1505 if (command_packet == NULL) { 1506 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet virtual address.\n"); 1507 return 1; 1508 } 1509 1510 /* Setup the command packet */ 1511 memset(command_packet, 0, sizeof(TW_Sector)); 1512 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1513 command_packet->size = 4; 1514 command_packet->request_id = request_id; 1515 command_packet->status = 0; 1516 command_packet->flags = 0; 1517 command_packet->byte6.parameter_count = 1; 1518 1519 /* Setup the param */ 1520 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1521 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment virtual address.\n"); 1522 return 1; 1523 } 1524 1525 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1526 memset(param, 0, sizeof(TW_Sector)); 1527 param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + tw_dev->srb[request_id]->device->id; 1528 param->parameter_id = 7; /* unit flags */ 1529 param->parameter_size_bytes = 1; 1530 param_value = tw_dev->alignment_physical_address[request_id]; 1531 if (param_value == 0) { 1532 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment physical address.\n"); 1533 return 1; 1534 } 1535 1536 command_packet->byte8.param.sgl[0].address = param_value; 1537 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1538 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1539 if (command_que_value == 0) { 1540 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet physical address.\n"); 1541 return 1; 1542 } 1543 1544 /* Now try to post the command packet */ 1545 tw_post_command_packet(tw_dev, request_id); 1546 1547 return 0; 1548} /* End tw_scsiop_mode_sense() */ 1549 1550/* This function is called by the isr to complete a mode sense command */ 1551static int tw_scsiop_mode_sense_complete(TW_Device_Extension *tw_dev, int request_id) 1552{ 1553 TW_Param *param; 1554 unsigned char *flags; 1555 unsigned char request_buffer[8]; 1556 1557 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense_complete()\n"); 1558 1559 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1560 if (param == NULL) { 1561 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense_complete(): Bad alignment virtual address.\n"); 1562 return 1; 1563 } 1564 flags = (char *)&(param->data[0]); 1565 memset(request_buffer, 0, sizeof(request_buffer)); 1566 1567 request_buffer[0] = 0xf; /* mode data length */ 1568 request_buffer[1] = 0; /* default medium type */ 1569 request_buffer[2] = 0x10; /* dpo/fua support on */ 1570 request_buffer[3] = 0; /* no block descriptors */ 1571 request_buffer[4] = 0x8; /* caching page */ 1572 request_buffer[5] = 0xa; /* page length */ 1573 if (*flags & 0x1) 1574 request_buffer[6] = 0x5; /* WCE on, RCD on */ 1575 else 1576 request_buffer[6] = 0x1; /* WCE off, RCD on */ 1577 tw_transfer_internal(tw_dev, request_id, request_buffer, 1578 sizeof(request_buffer)); 1579 1580 return 0; 1581} /* End tw_scsiop_mode_sense_complete() */ 1582 1583/* This function handles scsi read_capacity commands */ 1584static int tw_scsiop_read_capacity(TW_Device_Extension *tw_dev, int request_id) 1585{ 1586 TW_Param *param; 1587 TW_Command *command_packet; 1588 unsigned long command_que_value; 1589 unsigned long param_value; 1590 1591 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity()\n"); 1592 1593 /* Initialize command packet */ 1594 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1595 1596 if (command_packet == NULL) { 1597 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet virtual address.\n"); 1598 return 1; 1599 } 1600 memset(command_packet, 0, sizeof(TW_Sector)); 1601 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1602 command_packet->size = 4; 1603 command_packet->request_id = request_id; 1604 command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id); 1605 command_packet->status = 0; 1606 command_packet->flags = 0; 1607 command_packet->byte6.block_count = 1; 1608 1609 /* Now setup the param */ 1610 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1611 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment virtual address.\n"); 1612 return 1; 1613 } 1614 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1615 memset(param, 0, sizeof(TW_Sector)); 1616 param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + 1617 tw_dev->srb[request_id]->device->id; 1618 param->parameter_id = 4; /* unitcapacity parameter */ 1619 param->parameter_size_bytes = 4; 1620 param_value = tw_dev->alignment_physical_address[request_id]; 1621 if (param_value == 0) { 1622 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment physical address.\n"); 1623 return 1; 1624 } 1625 1626 command_packet->byte8.param.sgl[0].address = param_value; 1627 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1628 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1629 if (command_que_value == 0) { 1630 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet physical address.\n"); 1631 return 1; 1632 } 1633 1634 /* Now try to post the command to the board */ 1635 tw_post_command_packet(tw_dev, request_id); 1636 1637 return 0; 1638} /* End tw_scsiop_read_capacity() */ 1639 1640/* This function is called by the isr to complete a readcapacity command */ 1641static int tw_scsiop_read_capacity_complete(TW_Device_Extension *tw_dev, int request_id) 1642{ 1643 unsigned char *param_data; 1644 u32 capacity; 1645 char buff[8]; 1646 TW_Param *param; 1647 1648 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete()\n"); 1649 1650 memset(buff, 0, sizeof(buff)); 1651 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1652 if (param == NULL) { 1653 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Bad alignment virtual address.\n"); 1654 return 1; 1655 } 1656 param_data = &(param->data[0]); 1657 1658 capacity = (param_data[3] << 24) | (param_data[2] << 16) | 1659 (param_data[1] << 8) | param_data[0]; 1660 1661 /* Subtract one sector to fix get last sector ioctl */ 1662 capacity -= 1; 1663 1664 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete(): Capacity = 0x%x.\n", capacity); 1665 1666 /* Number of LBA's */ 1667 buff[0] = (capacity >> 24); 1668 buff[1] = (capacity >> 16) & 0xff; 1669 buff[2] = (capacity >> 8) & 0xff; 1670 buff[3] = capacity & 0xff; 1671 1672 /* Block size in bytes (512) */ 1673 buff[4] = (TW_BLOCK_SIZE >> 24); 1674 buff[5] = (TW_BLOCK_SIZE >> 16) & 0xff; 1675 buff[6] = (TW_BLOCK_SIZE >> 8) & 0xff; 1676 buff[7] = TW_BLOCK_SIZE & 0xff; 1677 1678 tw_transfer_internal(tw_dev, request_id, buff, sizeof(buff)); 1679 1680 return 0; 1681} /* End tw_scsiop_read_capacity_complete() */ 1682 1683/* This function handles scsi read or write commands */ 1684static int tw_scsiop_read_write(TW_Device_Extension *tw_dev, int request_id) 1685{ 1686 TW_Command *command_packet; 1687 unsigned long command_que_value; 1688 u32 lba = 0x0, num_sectors = 0x0; 1689 int i, use_sg; 1690 struct scsi_cmnd *srb; 1691 struct scatterlist *sglist, *sg; 1692 1693 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write()\n"); 1694 1695 srb = tw_dev->srb[request_id]; 1696 1697 sglist = scsi_sglist(srb); 1698 if (!sglist) { 1699 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Request buffer NULL.\n"); 1700 return 1; 1701 } 1702 1703 /* Initialize command packet */ 1704 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1705 if (command_packet == NULL) { 1706 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): Bad command packet virtual address.\n"); 1707 return 1; 1708 } 1709 1710 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == READ_10) { 1711 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_READ); 1712 } else { 1713 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_WRITE); 1714 } 1715 1716 command_packet->size = 3; 1717 command_packet->request_id = request_id; 1718 command_packet->unit__hostid = TW_UNITHOST_IN(0, srb->device->id); 1719 command_packet->status = 0; 1720 command_packet->flags = 0; 1721 1722 if (srb->cmnd[0] == WRITE_10) { 1723 if ((srb->cmnd[1] & 0x8) || (srb->cmnd[1] & 0x10)) 1724 command_packet->flags = 1; 1725 } 1726 1727 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) { 1728 lba = ((u32)srb->cmnd[1] << 16) | ((u32)srb->cmnd[2] << 8) | (u32)srb->cmnd[3]; 1729 num_sectors = (u32)srb->cmnd[4]; 1730 } else { 1731 lba = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) | ((u32)srb->cmnd[4] << 8) | (u32)srb->cmnd[5]; 1732 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8); 1733 } 1734 1735 /* Update sector statistic */ 1736 tw_dev->sector_count = num_sectors; 1737 if (tw_dev->sector_count > tw_dev->max_sector_count) 1738 tw_dev->max_sector_count = tw_dev->sector_count; 1739 1740 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): lba = 0x%x num_sectors = 0x%x\n", lba, num_sectors); 1741 command_packet->byte8.io.lba = lba; 1742 command_packet->byte6.block_count = num_sectors; 1743 1744 use_sg = scsi_dma_map(srb); 1745 if (use_sg <= 0) 1746 return 1; 1747 1748 scsi_for_each_sg(tw_dev->srb[request_id], sg, use_sg, i) { 1749 command_packet->byte8.io.sgl[i].address = sg_dma_address(sg); 1750 command_packet->byte8.io.sgl[i].length = sg_dma_len(sg); 1751 command_packet->size+=2; 1752 } 1753 1754 /* Update SG statistics */ 1755 tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]); 1756 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries) 1757 tw_dev->max_sgl_entries = tw_dev->sgl_entries; 1758 1759 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1760 if (command_que_value == 0) { 1761 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Bad command packet physical address.\n"); 1762 return 1; 1763 } 1764 1765 /* Now try to post the command to the board */ 1766 tw_post_command_packet(tw_dev, request_id); 1767 1768 return 0; 1769} /* End tw_scsiop_read_write() */ 1770 1771/* This function will handle the request sense scsi command */ 1772static int tw_scsiop_request_sense(TW_Device_Extension *tw_dev, int request_id) 1773{ 1774 char request_buffer[18]; 1775 1776 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_request_sense()\n"); 1777 1778 memset(request_buffer, 0, sizeof(request_buffer)); 1779 request_buffer[0] = 0x70; /* Immediate fixed format */ 1780 request_buffer[7] = 10; /* minimum size per SPC: 18 bytes */ 1781 /* leave all other fields zero, giving effectively NO_SENSE return */ 1782 tw_transfer_internal(tw_dev, request_id, request_buffer, 1783 sizeof(request_buffer)); 1784 1785 tw_dev->state[request_id] = TW_S_COMPLETED; 1786 tw_state_request_finish(tw_dev, request_id); 1787 1788 /* If we got a request_sense, we probably want a reset, return error */ 1789 tw_dev->srb[request_id]->result = (DID_ERROR << 16); 1790 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 1791 1792 return 0; 1793} /* End tw_scsiop_request_sense() */ 1794 1795/* This function will handle synchronize cache scsi command */ 1796static int tw_scsiop_synchronize_cache(TW_Device_Extension *tw_dev, int request_id) 1797{ 1798 TW_Command *command_packet; 1799 unsigned long command_que_value; 1800 1801 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_synchronize_cache()\n"); 1802 1803 /* Send firmware flush command for this unit */ 1804 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1805 if (command_packet == NULL) { 1806 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet virtual address.\n"); 1807 return 1; 1808 } 1809 1810 /* Setup the command packet */ 1811 memset(command_packet, 0, sizeof(TW_Sector)); 1812 command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_FLUSH_CACHE); 1813 command_packet->size = 2; 1814 command_packet->request_id = request_id; 1815 command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id); 1816 command_packet->status = 0; 1817 command_packet->flags = 0; 1818 command_packet->byte6.parameter_count = 1; 1819 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1820 if (command_que_value == 0) { 1821 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet physical address.\n"); 1822 return 1; 1823 } 1824 1825 /* Now try to post the command packet */ 1826 tw_post_command_packet(tw_dev, request_id); 1827 1828 return 0; 1829} /* End tw_scsiop_synchronize_cache() */ 1830 1831/* This function will handle test unit ready scsi command */ 1832static int tw_scsiop_test_unit_ready(TW_Device_Extension *tw_dev, int request_id) 1833{ 1834 TW_Param *param; 1835 TW_Command *command_packet; 1836 unsigned long command_que_value; 1837 unsigned long param_value; 1838 1839 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_test_unit_ready()\n"); 1840 1841 /* Initialize command packet */ 1842 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1843 if (command_packet == NULL) { 1844 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet virtual address.\n"); 1845 return 1; 1846 } 1847 memset(command_packet, 0, sizeof(TW_Sector)); 1848 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1849 command_packet->size = 4; 1850 command_packet->request_id = request_id; 1851 command_packet->status = 0; 1852 command_packet->flags = 0; 1853 command_packet->byte6.parameter_count = 1; 1854 1855 /* Now setup the param */ 1856 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1857 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment virtual address.\n"); 1858 return 1; 1859 } 1860 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1861 memset(param, 0, sizeof(TW_Sector)); 1862 param->table_id = 3; /* unit summary table */ 1863 param->parameter_id = 3; /* unitsstatus parameter */ 1864 param->parameter_size_bytes = TW_MAX_UNITS; 1865 param_value = tw_dev->alignment_physical_address[request_id]; 1866 if (param_value == 0) { 1867 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment physical address.\n"); 1868 return 1; 1869 } 1870 1871 command_packet->byte8.param.sgl[0].address = param_value; 1872 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1873 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1874 if (command_que_value == 0) { 1875 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet physical address.\n"); 1876 return 1; 1877 } 1878 1879 /* Now try to post the command packet */ 1880 tw_post_command_packet(tw_dev, request_id); 1881 1882 return 0; 1883} /* End tw_scsiop_test_unit_ready() */ 1884 1885/* This function is called by the isr to complete a testunitready command */ 1886static int tw_scsiop_test_unit_ready_complete(TW_Device_Extension *tw_dev, int request_id) 1887{ 1888 unsigned char *is_unit_present; 1889 TW_Param *param; 1890 1891 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete()\n"); 1892 1893 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1894 if (param == NULL) { 1895 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete(): Bad alignment virtual address.\n"); 1896 return 1; 1897 } 1898 is_unit_present = &(param->data[0]); 1899 1900 if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) { 1901 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1; 1902 } else { 1903 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0; 1904 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16); 1905 return TW_ISR_DONT_RESULT; 1906 } 1907 1908 return 0; 1909} /* End tw_scsiop_test_unit_ready_complete() */ 1910 1911/* This is the main scsi queue function to handle scsi opcodes */ 1912static int tw_scsi_queue_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 1913{ 1914 unsigned char *command = SCpnt->cmnd; 1915 int request_id = 0; 1916 int retval = 1; 1917 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 1918 1919 /* If we are resetting due to timed out ioctl, report as busy */ 1920 if (test_bit(TW_IN_RESET, &tw_dev->flags)) 1921 return SCSI_MLQUEUE_HOST_BUSY; 1922 1923 /* Save done function into Scsi_Cmnd struct */ 1924 SCpnt->scsi_done = done; 1925 1926 /* Queue the command and get a request id */ 1927 tw_state_request_start(tw_dev, &request_id); 1928 1929 /* Save the scsi command for use by the ISR */ 1930 tw_dev->srb[request_id] = SCpnt; 1931 1932 switch (*command) { 1933 case READ_10: 1934 case READ_6: 1935 case WRITE_10: 1936 case WRITE_6: 1937 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ/WRITE.\n"); 1938 retval = tw_scsiop_read_write(tw_dev, request_id); 1939 break; 1940 case TEST_UNIT_READY: 1941 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TEST_UNIT_READY.\n"); 1942 retval = tw_scsiop_test_unit_ready(tw_dev, request_id); 1943 break; 1944 case INQUIRY: 1945 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught INQUIRY.\n"); 1946 retval = tw_scsiop_inquiry(tw_dev, request_id); 1947 break; 1948 case READ_CAPACITY: 1949 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ_CAPACITY.\n"); 1950 retval = tw_scsiop_read_capacity(tw_dev, request_id); 1951 break; 1952 case REQUEST_SENSE: 1953 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught REQUEST_SENSE.\n"); 1954 retval = tw_scsiop_request_sense(tw_dev, request_id); 1955 break; 1956 case MODE_SENSE: 1957 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught MODE_SENSE.\n"); 1958 retval = tw_scsiop_mode_sense(tw_dev, request_id); 1959 break; 1960 case SYNCHRONIZE_CACHE: 1961 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught SYNCHRONIZE_CACHE.\n"); 1962 retval = tw_scsiop_synchronize_cache(tw_dev, request_id); 1963 break; 1964 case TW_IOCTL: 1965 printk(KERN_WARNING "3w-xxxx: SCSI_IOCTL_SEND_COMMAND deprecated, please update your 3ware tools.\n"); 1966 break; 1967 default: 1968 printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command); 1969 tw_dev->state[request_id] = TW_S_COMPLETED; 1970 tw_state_request_finish(tw_dev, request_id); 1971 SCpnt->result = (DRIVER_SENSE << 24) | SAM_STAT_CHECK_CONDITION; 1972 scsi_build_sense_buffer(1, SCpnt->sense_buffer, ILLEGAL_REQUEST, 0x20, 0); 1973 done(SCpnt); 1974 retval = 0; 1975 } 1976 if (retval) { 1977 tw_dev->state[request_id] = TW_S_COMPLETED; 1978 tw_state_request_finish(tw_dev, request_id); 1979 SCpnt->result = (DID_ERROR << 16); 1980 done(SCpnt); 1981 retval = 0; 1982 } 1983 return retval; 1984} /* End tw_scsi_queue() */ 1985 1986static DEF_SCSI_QCMD(tw_scsi_queue) 1987 1988/* This function is the interrupt service routine */ 1989static irqreturn_t tw_interrupt(int irq, void *dev_instance) 1990{ 1991 int request_id; 1992 u32 status_reg_value; 1993 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance; 1994 TW_Response_Queue response_que; 1995 int error = 0, retval = 0; 1996 TW_Command *command_packet; 1997 int handled = 0; 1998 1999 /* Get the host lock for io completions */ 2000 spin_lock(tw_dev->host->host_lock); 2001 2002 /* Read the registers */ 2003 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 2004 2005 /* Check if this is our interrupt, otherwise bail */ 2006 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT)) 2007 goto tw_interrupt_bail; 2008 2009 handled = 1; 2010 2011 /* If we are resetting, bail */ 2012 if (test_bit(TW_IN_RESET, &tw_dev->flags)) 2013 goto tw_interrupt_bail; 2014 2015 /* Check controller for errors */ 2016 if (tw_check_bits(status_reg_value)) { 2017 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n"); 2018 if (tw_decode_bits(tw_dev, status_reg_value, 1)) { 2019 TW_CLEAR_ALL_INTERRUPTS(tw_dev); 2020 goto tw_interrupt_bail; 2021 } 2022 } 2023 2024 /* Handle host interrupt */ 2025 if (status_reg_value & TW_STATUS_HOST_INTERRUPT) { 2026 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received host interrupt.\n"); 2027 TW_CLEAR_HOST_INTERRUPT(tw_dev); 2028 } 2029 2030 /* Handle attention interrupt */ 2031 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) { 2032 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received attention interrupt.\n"); 2033 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev); 2034 tw_state_request_start(tw_dev, &request_id); 2035 error = tw_aen_read_queue(tw_dev, request_id); 2036 if (error) { 2037 printk(KERN_WARNING "3w-xxxx: scsi%d: Error reading aen queue.\n", tw_dev->host->host_no); 2038 tw_dev->state[request_id] = TW_S_COMPLETED; 2039 tw_state_request_finish(tw_dev, request_id); 2040 } 2041 } 2042 2043 /* Handle command interrupt */ 2044 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) { 2045 /* Drain as many pending commands as we can */ 2046 while (tw_dev->pending_request_count > 0) { 2047 request_id = tw_dev->pending_queue[tw_dev->pending_head]; 2048 if (tw_dev->state[request_id] != TW_S_PENDING) { 2049 printk(KERN_WARNING "3w-xxxx: scsi%d: Found request id that wasn't pending.\n", tw_dev->host->host_no); 2050 break; 2051 } 2052 if (tw_post_command_packet(tw_dev, request_id)==0) { 2053 if (tw_dev->pending_head == TW_Q_LENGTH-1) { 2054 tw_dev->pending_head = TW_Q_START; 2055 } else { 2056 tw_dev->pending_head = tw_dev->pending_head + 1; 2057 } 2058 tw_dev->pending_request_count--; 2059 } else { 2060 /* If we get here, we will continue re-posting on the next command interrupt */ 2061 break; 2062 } 2063 } 2064 /* If there are no more pending requests, we mask command interrupt */ 2065 if (tw_dev->pending_request_count == 0) 2066 TW_MASK_COMMAND_INTERRUPT(tw_dev); 2067 } 2068 2069 /* Handle response interrupt */ 2070 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) { 2071 /* Drain the response queue from the board */ 2072 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) { 2073 /* Read response queue register */ 2074 response_que.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 2075 request_id = TW_RESID_OUT(response_que.response_id); 2076 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 2077 error = 0; 2078 2079 /* Check for bad response */ 2080 if (command_packet->status != 0) { 2081 /* If internal command, don't error, don't fill sense */ 2082 if (tw_dev->srb[request_id] == NULL) { 2083 tw_decode_sense(tw_dev, request_id, 0); 2084 } else { 2085 error = tw_decode_sense(tw_dev, request_id, 1); 2086 } 2087 } 2088 2089 /* Check for correct state */ 2090 if (tw_dev->state[request_id] != TW_S_POSTED) { 2091 if (tw_dev->srb[request_id] != NULL) { 2092 printk(KERN_WARNING "3w-xxxx: scsi%d: Received a request id that wasn't posted.\n", tw_dev->host->host_no); 2093 error = 1; 2094 } 2095 } 2096 2097 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Response queue request id: %d.\n", request_id); 2098 2099 /* Check for internal command completion */ 2100 if (tw_dev->srb[request_id] == NULL) { 2101 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Found internally posted command.\n"); 2102 /* Check for chrdev ioctl completion */ 2103 if (request_id != tw_dev->chrdev_request_id) { 2104 retval = tw_aen_complete(tw_dev, request_id); 2105 if (retval) { 2106 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing aen.\n", tw_dev->host->host_no); 2107 } 2108 } else { 2109 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 2110 wake_up(&tw_dev->ioctl_wqueue); 2111 } 2112 } else { 2113 switch (tw_dev->srb[request_id]->cmnd[0]) { 2114 case READ_10: 2115 case READ_6: 2116 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_10/READ_6\n"); 2117 break; 2118 case WRITE_10: 2119 case WRITE_6: 2120 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught WRITE_10/WRITE_6\n"); 2121 break; 2122 case TEST_UNIT_READY: 2123 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TEST_UNIT_READY\n"); 2124 error = tw_scsiop_test_unit_ready_complete(tw_dev, request_id); 2125 break; 2126 case INQUIRY: 2127 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught INQUIRY\n"); 2128 error = tw_scsiop_inquiry_complete(tw_dev, request_id); 2129 break; 2130 case READ_CAPACITY: 2131 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_CAPACITY\n"); 2132 error = tw_scsiop_read_capacity_complete(tw_dev, request_id); 2133 break; 2134 case MODE_SENSE: 2135 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught MODE_SENSE\n"); 2136 error = tw_scsiop_mode_sense_complete(tw_dev, request_id); 2137 break; 2138 case SYNCHRONIZE_CACHE: 2139 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught SYNCHRONIZE_CACHE\n"); 2140 break; 2141 default: 2142 printk(KERN_WARNING "3w-xxxx: case slip in tw_interrupt()\n"); 2143 error = 1; 2144 } 2145 2146 /* If no error command was a success */ 2147 if (error == 0) { 2148 tw_dev->srb[request_id]->result = (DID_OK << 16); 2149 } 2150 2151 /* If error, command failed */ 2152 if (error == 1) { 2153 /* Ask for a host reset */ 2154 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1); 2155 } 2156 2157 /* Now complete the io */ 2158 if ((error != TW_ISR_DONT_COMPLETE)) { 2159 scsi_dma_unmap(tw_dev->srb[request_id]); 2160 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 2161 tw_dev->state[request_id] = TW_S_COMPLETED; 2162 tw_state_request_finish(tw_dev, request_id); 2163 tw_dev->posted_request_count--; 2164 } 2165 } 2166 2167 /* Check for valid status after each drain */ 2168 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 2169 if (tw_check_bits(status_reg_value)) { 2170 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n"); 2171 if (tw_decode_bits(tw_dev, status_reg_value, 1)) { 2172 TW_CLEAR_ALL_INTERRUPTS(tw_dev); 2173 goto tw_interrupt_bail; 2174 } 2175 } 2176 } 2177 } 2178 2179tw_interrupt_bail: 2180 spin_unlock(tw_dev->host->host_lock); 2181 return IRQ_RETVAL(handled); 2182} /* End tw_interrupt() */ 2183 2184/* This function tells the controller to shut down */ 2185static void __tw_shutdown(TW_Device_Extension *tw_dev) 2186{ 2187 /* Disable interrupts */ 2188 TW_DISABLE_INTERRUPTS(tw_dev); 2189 2190 /* Free up the IRQ */ 2191 free_irq(tw_dev->tw_pci_dev->irq, tw_dev); 2192 2193 printk(KERN_WARNING "3w-xxxx: Shutting down host %d.\n", tw_dev->host->host_no); 2194 2195 /* Tell the card we are shutting down */ 2196 if (tw_initconnection(tw_dev, 1)) { 2197 printk(KERN_WARNING "3w-xxxx: Connection shutdown failed.\n"); 2198 } else { 2199 printk(KERN_WARNING "3w-xxxx: Shutdown complete.\n"); 2200 } 2201 2202 /* Clear all interrupts just before exit */ 2203 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 2204} /* End __tw_shutdown() */ 2205 2206/* Wrapper for __tw_shutdown */ 2207static void tw_shutdown(struct pci_dev *pdev) 2208{ 2209 struct Scsi_Host *host = pci_get_drvdata(pdev); 2210 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 2211 2212 __tw_shutdown(tw_dev); 2213} /* End tw_shutdown() */ 2214 2215/* This function gets called when a disk is coming online */ 2216static int tw_slave_configure(struct scsi_device *sdev) 2217{ 2218 /* Force 60 second timeout */ 2219 blk_queue_rq_timeout(sdev->request_queue, 60 * HZ); 2220 2221 return 0; 2222} /* End tw_slave_configure() */ 2223 2224static struct scsi_host_template driver_template = { 2225 .module = THIS_MODULE, 2226 .name = "3ware Storage Controller", 2227 .queuecommand = tw_scsi_queue, 2228 .eh_host_reset_handler = tw_scsi_eh_reset, 2229 .bios_param = tw_scsi_biosparam, 2230 .change_queue_depth = scsi_change_queue_depth, 2231 .can_queue = TW_Q_LENGTH-2, 2232 .slave_configure = tw_slave_configure, 2233 .this_id = -1, 2234 .sg_tablesize = TW_MAX_SGL_LENGTH, 2235 .max_sectors = TW_MAX_SECTORS, 2236 .cmd_per_lun = TW_MAX_CMDS_PER_LUN, 2237 .use_clustering = ENABLE_CLUSTERING, 2238 .shost_attrs = tw_host_attrs, 2239 .emulated = 1, 2240 .no_write_same = 1, 2241}; 2242 2243/* This function will probe and initialize a card */ 2244static int tw_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id) 2245{ 2246 struct Scsi_Host *host = NULL; 2247 TW_Device_Extension *tw_dev; 2248 int retval = -ENODEV; 2249 2250 retval = pci_enable_device(pdev); 2251 if (retval) { 2252 printk(KERN_WARNING "3w-xxxx: Failed to enable pci device."); 2253 goto out_disable_device; 2254 } 2255 2256 pci_set_master(pdev); 2257 2258 retval = pci_set_dma_mask(pdev, TW_DMA_MASK); 2259 if (retval) { 2260 printk(KERN_WARNING "3w-xxxx: Failed to set dma mask."); 2261 goto out_disable_device; 2262 } 2263 2264 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension)); 2265 if (!host) { 2266 printk(KERN_WARNING "3w-xxxx: Failed to allocate memory for device extension."); 2267 retval = -ENOMEM; 2268 goto out_disable_device; 2269 } 2270 tw_dev = (TW_Device_Extension *)host->hostdata; 2271 2272 /* Save values to device extension */ 2273 tw_dev->host = host; 2274 tw_dev->tw_pci_dev = pdev; 2275 2276 if (tw_initialize_device_extension(tw_dev)) { 2277 printk(KERN_WARNING "3w-xxxx: Failed to initialize device extension."); 2278 goto out_free_device_extension; 2279 } 2280 2281 /* Request IO regions */ 2282 retval = pci_request_regions(pdev, "3w-xxxx"); 2283 if (retval) { 2284 printk(KERN_WARNING "3w-xxxx: Failed to get mem region."); 2285 goto out_free_device_extension; 2286 } 2287 2288 /* Save base address */ 2289 tw_dev->base_addr = pci_resource_start(pdev, 0); 2290 if (!tw_dev->base_addr) { 2291 printk(KERN_WARNING "3w-xxxx: Failed to get io address."); 2292 goto out_release_mem_region; 2293 } 2294 2295 /* Disable interrupts on the card */ 2296 TW_DISABLE_INTERRUPTS(tw_dev); 2297 2298 /* Initialize the card */ 2299 if (tw_reset_sequence(tw_dev)) 2300 goto out_release_mem_region; 2301 2302 /* Set host specific parameters */ 2303 host->max_id = TW_MAX_UNITS; 2304 host->max_cmd_len = TW_MAX_CDB_LEN; 2305 2306 /* Luns and channels aren't supported by adapter */ 2307 host->max_lun = 0; 2308 host->max_channel = 0; 2309 2310 /* Register the card with the kernel SCSI layer */ 2311 retval = scsi_add_host(host, &pdev->dev); 2312 if (retval) { 2313 printk(KERN_WARNING "3w-xxxx: scsi add host failed"); 2314 goto out_release_mem_region; 2315 } 2316 2317 pci_set_drvdata(pdev, host); 2318 2319 printk(KERN_WARNING "3w-xxxx: scsi%d: Found a 3ware Storage Controller at 0x%x, IRQ: %d.\n", host->host_no, tw_dev->base_addr, pdev->irq); 2320 2321 /* Now setup the interrupt handler */ 2322 retval = request_irq(pdev->irq, tw_interrupt, IRQF_SHARED, "3w-xxxx", tw_dev); 2323 if (retval) { 2324 printk(KERN_WARNING "3w-xxxx: Error requesting IRQ."); 2325 goto out_remove_host; 2326 } 2327 2328 tw_device_extension_list[tw_device_extension_count] = tw_dev; 2329 tw_device_extension_count++; 2330 2331 /* Re-enable interrupts on the card */ 2332 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 2333 2334 /* Finally, scan the host */ 2335 scsi_scan_host(host); 2336 2337 if (twe_major == -1) { 2338 if ((twe_major = register_chrdev (0, "twe", &tw_fops)) < 0) 2339 printk(KERN_WARNING "3w-xxxx: Failed to register character device."); 2340 } 2341 return 0; 2342 2343out_remove_host: 2344 scsi_remove_host(host); 2345out_release_mem_region: 2346 pci_release_regions(pdev); 2347out_free_device_extension: 2348 tw_free_device_extension(tw_dev); 2349 scsi_host_put(host); 2350out_disable_device: 2351 pci_disable_device(pdev); 2352 2353 return retval; 2354} /* End tw_probe() */ 2355 2356/* This function is called to remove a device */ 2357static void tw_remove(struct pci_dev *pdev) 2358{ 2359 struct Scsi_Host *host = pci_get_drvdata(pdev); 2360 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 2361 2362 scsi_remove_host(tw_dev->host); 2363 2364 /* Unregister character device */ 2365 if (twe_major >= 0) { 2366 unregister_chrdev(twe_major, "twe"); 2367 twe_major = -1; 2368 } 2369 2370 /* Shutdown the card */ 2371 __tw_shutdown(tw_dev); 2372 2373 /* Free up the mem region */ 2374 pci_release_regions(pdev); 2375 2376 /* Free up device extension resources */ 2377 tw_free_device_extension(tw_dev); 2378 2379 scsi_host_put(tw_dev->host); 2380 pci_disable_device(pdev); 2381 tw_device_extension_count--; 2382} /* End tw_remove() */ 2383 2384/* PCI Devices supported by this driver */ 2385static struct pci_device_id tw_pci_tbl[] = { 2386 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_1000, 2387 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2388 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_7000, 2389 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2390 { } 2391}; 2392MODULE_DEVICE_TABLE(pci, tw_pci_tbl); 2393 2394/* pci_driver initializer */ 2395static struct pci_driver tw_driver = { 2396 .name = "3w-xxxx", 2397 .id_table = tw_pci_tbl, 2398 .probe = tw_probe, 2399 .remove = tw_remove, 2400 .shutdown = tw_shutdown, 2401}; 2402 2403/* This function is called on driver initialization */ 2404static int __init tw_init(void) 2405{ 2406 printk(KERN_WARNING "3ware Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION); 2407 2408 return pci_register_driver(&tw_driver); 2409} /* End tw_init() */ 2410 2411/* This function is called on driver exit */ 2412static void __exit tw_exit(void) 2413{ 2414 pci_unregister_driver(&tw_driver); 2415} /* End tw_exit() */ 2416 2417module_init(tw_init); 2418module_exit(tw_exit); 2419 2420