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