1 /* 2 3w-xxxx.c -- 3ware Storage Controller device driver for Linux. 3 4 Written By: Adam Radford <linuxraid@amcc.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-2005 3ware Inc. 10 11 Kernel compatiblity 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@amcc.com 51 52 For more information, goto: 53 http://www.amcc.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 */ 195 196 #include <linux/module.h> 197 #include <linux/reboot.h> 198 #include <linux/spinlock.h> 199 #include <linux/interrupt.h> 200 #include <linux/moduleparam.h> 201 #include <linux/errno.h> 202 #include <linux/types.h> 203 #include <linux/delay.h> 204 #include <linux/pci.h> 205 #include <linux/time.h> 206 #include <asm/io.h> 207 #include <asm/irq.h> 208 #include <asm/uaccess.h> 209 #include <scsi/scsi.h> 210 #include <scsi/scsi_host.h> 211 #include <scsi/scsi_tcq.h> 212 #include <scsi/scsi_cmnd.h> 213 #include "3w-xxxx.h" 214 215 /* Globals */ 216 #define TW_DRIVER_VERSION "1.26.02.001" 217 static TW_Device_Extension *tw_device_extension_list[TW_MAX_SLOT]; 218 static int tw_device_extension_count = 0; 219 static int twe_major = -1; 220 221 /* Module parameters */ 222 MODULE_AUTHOR("AMCC"); 223 MODULE_DESCRIPTION("3ware Storage Controller Linux Driver"); 224 MODULE_LICENSE("GPL"); 225 MODULE_VERSION(TW_DRIVER_VERSION); 226 227 /* Function prototypes */ 228 static int tw_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset); 229 230 /* Functions */ 231 232 /* This function will check the status register for unexpected bits */ 233 static int tw_check_bits(u32 status_reg_value) 234 { 235 if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS) { 236 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): No expected bits (0x%x).\n", status_reg_value); 237 return 1; 238 } 239 if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0) { 240 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): Found unexpected bits (0x%x).\n", status_reg_value); 241 return 1; 242 } 243 244 return 0; 245 } /* End tw_check_bits() */ 246 247 /* This function will print readable messages from status register errors */ 248 static int tw_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value, int print_host) 249 { 250 char host[16]; 251 252 dprintk(KERN_WARNING "3w-xxxx: tw_decode_bits()\n"); 253 254 if (print_host) 255 sprintf(host, " scsi%d:", tw_dev->host->host_no); 256 else 257 host[0] = '\0'; 258 259 if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) { 260 printk(KERN_WARNING "3w-xxxx:%s PCI Parity Error: clearing.\n", host); 261 outl(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 262 } 263 264 if (status_reg_value & TW_STATUS_PCI_ABORT) { 265 printk(KERN_WARNING "3w-xxxx:%s PCI Abort: clearing.\n", host); 266 outl(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev)); 267 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT); 268 } 269 270 if (status_reg_value & TW_STATUS_QUEUE_ERROR) { 271 printk(KERN_WARNING "3w-xxxx:%s Controller Queue Error: clearing.\n", host); 272 outl(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 273 } 274 275 if (status_reg_value & TW_STATUS_SBUF_WRITE_ERROR) { 276 printk(KERN_WARNING "3w-xxxx:%s SBUF Write Error: clearing.\n", host); 277 outl(TW_CONTROL_CLEAR_SBUF_WRITE_ERROR, TW_CONTROL_REG_ADDR(tw_dev)); 278 } 279 280 if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) { 281 if (tw_dev->reset_print == 0) { 282 printk(KERN_WARNING "3w-xxxx:%s Microcontroller Error: clearing.\n", host); 283 tw_dev->reset_print = 1; 284 } 285 return 1; 286 } 287 288 return 0; 289 } /* End tw_decode_bits() */ 290 291 /* This function will poll the status register for a flag */ 292 static int tw_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds) 293 { 294 u32 status_reg_value; 295 unsigned long before; 296 int retval = 1; 297 298 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 299 before = jiffies; 300 301 if (tw_check_bits(status_reg_value)) 302 tw_decode_bits(tw_dev, status_reg_value, 0); 303 304 while ((status_reg_value & flag) != flag) { 305 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 306 307 if (tw_check_bits(status_reg_value)) 308 tw_decode_bits(tw_dev, status_reg_value, 0); 309 310 if (time_after(jiffies, before + HZ * seconds)) 311 goto out; 312 313 msleep(50); 314 } 315 retval = 0; 316 out: 317 return retval; 318 } /* End tw_poll_status() */ 319 320 /* This function will poll the status register for disappearance of a flag */ 321 static int tw_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds) 322 { 323 u32 status_reg_value; 324 unsigned long before; 325 int retval = 1; 326 327 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 328 before = jiffies; 329 330 if (tw_check_bits(status_reg_value)) 331 tw_decode_bits(tw_dev, status_reg_value, 0); 332 333 while ((status_reg_value & flag) != 0) { 334 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 335 336 if (tw_check_bits(status_reg_value)) 337 tw_decode_bits(tw_dev, status_reg_value, 0); 338 339 if (time_after(jiffies, before + HZ * seconds)) 340 goto out; 341 342 msleep(50); 343 } 344 retval = 0; 345 out: 346 return retval; 347 } /* End tw_poll_status_gone() */ 348 349 /* This function will attempt to post a command packet to the board */ 350 static int tw_post_command_packet(TW_Device_Extension *tw_dev, int request_id) 351 { 352 u32 status_reg_value; 353 unsigned long command_que_value; 354 355 dprintk(KERN_NOTICE "3w-xxxx: tw_post_command_packet()\n"); 356 command_que_value = tw_dev->command_packet_physical_address[request_id]; 357 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 358 359 if (tw_check_bits(status_reg_value)) { 360 dprintk(KERN_WARNING "3w-xxxx: tw_post_command_packet(): Unexpected bits.\n"); 361 tw_decode_bits(tw_dev, status_reg_value, 1); 362 } 363 364 if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) { 365 /* We successfully posted the command packet */ 366 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 367 tw_dev->state[request_id] = TW_S_POSTED; 368 tw_dev->posted_request_count++; 369 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) { 370 tw_dev->max_posted_request_count = tw_dev->posted_request_count; 371 } 372 } else { 373 /* Couldn't post the command packet, so we do it in the isr */ 374 if (tw_dev->state[request_id] != TW_S_PENDING) { 375 tw_dev->state[request_id] = TW_S_PENDING; 376 tw_dev->pending_request_count++; 377 if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) { 378 tw_dev->max_pending_request_count = tw_dev->pending_request_count; 379 } 380 tw_dev->pending_queue[tw_dev->pending_tail] = request_id; 381 if (tw_dev->pending_tail == TW_Q_LENGTH-1) { 382 tw_dev->pending_tail = TW_Q_START; 383 } else { 384 tw_dev->pending_tail = tw_dev->pending_tail + 1; 385 } 386 } 387 TW_UNMASK_COMMAND_INTERRUPT(tw_dev); 388 return 1; 389 } 390 return 0; 391 } /* End tw_post_command_packet() */ 392 393 /* This function will return valid sense buffer information for failed cmds */ 394 static int tw_decode_sense(TW_Device_Extension *tw_dev, int request_id, int fill_sense) 395 { 396 int i; 397 TW_Command *command; 398 399 dprintk(KERN_WARNING "3w-xxxx: tw_decode_sense()\n"); 400 command = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 401 402 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)); 403 404 /* Attempt to return intelligent sense information */ 405 if (fill_sense) { 406 if ((command->status == 0xc7) || (command->status == 0xcb)) { 407 for (i=0;i<(sizeof(tw_sense_table)/sizeof(tw_sense_table[0]));i++) { 408 if (command->flags == tw_sense_table[i][0]) { 409 410 /* Valid bit and 'current errors' */ 411 tw_dev->srb[request_id]->sense_buffer[0] = (0x1 << 7 | 0x70); 412 413 /* Sense key */ 414 tw_dev->srb[request_id]->sense_buffer[2] = tw_sense_table[i][1]; 415 416 /* Additional sense length */ 417 tw_dev->srb[request_id]->sense_buffer[7] = 0xa; /* 10 bytes */ 418 419 /* Additional sense code */ 420 tw_dev->srb[request_id]->sense_buffer[12] = tw_sense_table[i][2]; 421 422 /* Additional sense code qualifier */ 423 tw_dev->srb[request_id]->sense_buffer[13] = tw_sense_table[i][3]; 424 425 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1); 426 return TW_ISR_DONT_RESULT; /* Special case for isr to not over-write result */ 427 } 428 } 429 } 430 431 /* If no table match, error so we get a reset */ 432 return 1; 433 } 434 435 return 0; 436 } /* End tw_decode_sense() */ 437 438 /* This function will report controller error status */ 439 static int tw_check_errors(TW_Device_Extension *tw_dev) 440 { 441 u32 status_reg_value; 442 443 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 444 445 if (TW_STATUS_ERRORS(status_reg_value) || tw_check_bits(status_reg_value)) { 446 tw_decode_bits(tw_dev, status_reg_value, 0); 447 return 1; 448 } 449 450 return 0; 451 } /* End tw_check_errors() */ 452 453 /* This function will empty the response que */ 454 static void tw_empty_response_que(TW_Device_Extension *tw_dev) 455 { 456 u32 status_reg_value, response_que_value; 457 458 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 459 460 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) { 461 response_que_value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 462 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 463 } 464 } /* End tw_empty_response_que() */ 465 466 /* This function will free a request_id */ 467 static void tw_state_request_finish(TW_Device_Extension *tw_dev, int request_id) 468 { 469 tw_dev->free_queue[tw_dev->free_tail] = request_id; 470 tw_dev->state[request_id] = TW_S_FINISHED; 471 tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH; 472 } /* End tw_state_request_finish() */ 473 474 /* This function will assign an available request_id */ 475 static void tw_state_request_start(TW_Device_Extension *tw_dev, int *request_id) 476 { 477 *request_id = tw_dev->free_queue[tw_dev->free_head]; 478 tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH; 479 tw_dev->state[*request_id] = TW_S_STARTED; 480 } /* End tw_state_request_start() */ 481 482 /* Show some statistics about the card */ 483 static ssize_t tw_show_stats(struct class_device *class_dev, char *buf) 484 { 485 struct Scsi_Host *host = class_to_shost(class_dev); 486 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 487 unsigned long flags = 0; 488 ssize_t len; 489 490 spin_lock_irqsave(tw_dev->host->host_lock, flags); 491 len = snprintf(buf, PAGE_SIZE, "3w-xxxx Driver version: %s\n" 492 "Current commands posted: %4d\n" 493 "Max commands posted: %4d\n" 494 "Current pending commands: %4d\n" 495 "Max pending commands: %4d\n" 496 "Last sgl length: %4d\n" 497 "Max sgl length: %4d\n" 498 "Last sector count: %4d\n" 499 "Max sector count: %4d\n" 500 "SCSI Host Resets: %4d\n" 501 "AEN's: %4d\n", 502 TW_DRIVER_VERSION, 503 tw_dev->posted_request_count, 504 tw_dev->max_posted_request_count, 505 tw_dev->pending_request_count, 506 tw_dev->max_pending_request_count, 507 tw_dev->sgl_entries, 508 tw_dev->max_sgl_entries, 509 tw_dev->sector_count, 510 tw_dev->max_sector_count, 511 tw_dev->num_resets, 512 tw_dev->aen_count); 513 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 514 return len; 515 } /* End tw_show_stats() */ 516 517 /* This function will set a devices queue depth */ 518 static int tw_change_queue_depth(struct scsi_device *sdev, int queue_depth) 519 { 520 if (queue_depth > TW_Q_LENGTH-2) 521 queue_depth = TW_Q_LENGTH-2; 522 scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth); 523 return queue_depth; 524 } /* End tw_change_queue_depth() */ 525 526 /* Create sysfs 'stats' entry */ 527 static struct class_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 */ 536 static struct class_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 */ 542 static 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 */ 608 static 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 = sizeof(tw_aen_string)/sizeof(char *); 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 */ 672 static 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 = sizeof(tw_aen_string)/sizeof(char *); 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 */ 830 static 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 */ 872 static int tw_chrdev_ioctl(struct inode *inode, 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 unsigned long *cpu_addr; 881 long timeout; 882 TW_New_Ioctl *tw_ioctl; 883 TW_Passthru *passthru; 884 TW_Device_Extension *tw_dev = tw_device_extension_list[iminor(inode)]; 885 int retval = -EFAULT; 886 void __user *argp = (void __user *)arg; 887 888 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n"); 889 890 /* Only let one of these through at a time */ 891 if (down_interruptible(&tw_dev->ioctl_sem)) 892 return -EINTR; 893 894 /* First copy down the buffer length */ 895 if (copy_from_user(&data_buffer_length, argp, sizeof(unsigned int))) 896 goto out; 897 898 /* Check size */ 899 if (data_buffer_length > TW_MAX_IOCTL_SECTORS * 512) { 900 retval = -EINVAL; 901 goto out; 902 } 903 904 /* Hardware can only do multiple of 512 byte transfers */ 905 data_buffer_length_adjusted = (data_buffer_length + 511) & ~511; 906 907 /* Now allocate ioctl buf memory */ 908 cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, &dma_handle, GFP_KERNEL); 909 if (cpu_addr == NULL) { 910 retval = -ENOMEM; 911 goto out; 912 } 913 914 tw_ioctl = (TW_New_Ioctl *)cpu_addr; 915 916 /* Now copy down the entire ioctl */ 917 if (copy_from_user(tw_ioctl, argp, data_buffer_length + sizeof(TW_New_Ioctl) - 1)) 918 goto out2; 919 920 passthru = (TW_Passthru *)&tw_ioctl->firmware_command; 921 922 /* See which ioctl we are doing */ 923 switch (cmd) { 924 case TW_OP_NOP: 925 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_OP_NOP.\n"); 926 break; 927 case TW_OP_AEN_LISTEN: 928 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_AEN_LISTEN.\n"); 929 memset(tw_ioctl->data_buffer, 0, data_buffer_length); 930 931 spin_lock_irqsave(tw_dev->host->host_lock, flags); 932 if (tw_dev->aen_head == tw_dev->aen_tail) { 933 tw_aen_code = TW_AEN_QUEUE_EMPTY; 934 } else { 935 tw_aen_code = tw_dev->aen_queue[tw_dev->aen_head]; 936 if (tw_dev->aen_head == TW_Q_LENGTH - 1) { 937 tw_dev->aen_head = TW_Q_START; 938 } else { 939 tw_dev->aen_head = tw_dev->aen_head + 1; 940 } 941 } 942 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 943 memcpy(tw_ioctl->data_buffer, &tw_aen_code, sizeof(tw_aen_code)); 944 break; 945 case TW_CMD_PACKET_WITH_DATA: 946 dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n"); 947 spin_lock_irqsave(tw_dev->host->host_lock, flags); 948 949 tw_state_request_start(tw_dev, &request_id); 950 951 /* Flag internal command */ 952 tw_dev->srb[request_id] = NULL; 953 954 /* Flag chrdev ioctl */ 955 tw_dev->chrdev_request_id = request_id; 956 957 tw_ioctl->firmware_command.request_id = request_id; 958 959 /* Load the sg list */ 960 switch (TW_SGL_OUT(tw_ioctl->firmware_command.opcode__sgloffset)) { 961 case 2: 962 tw_ioctl->firmware_command.byte8.param.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1; 963 tw_ioctl->firmware_command.byte8.param.sgl[0].length = data_buffer_length_adjusted; 964 break; 965 case 3: 966 tw_ioctl->firmware_command.byte8.io.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1; 967 tw_ioctl->firmware_command.byte8.io.sgl[0].length = data_buffer_length_adjusted; 968 break; 969 case 5: 970 passthru->sg_list[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1; 971 passthru->sg_list[0].length = data_buffer_length_adjusted; 972 break; 973 } 974 975 memcpy(tw_dev->command_packet_virtual_address[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command)); 976 977 /* Now post the command packet to the controller */ 978 tw_post_command_packet(tw_dev, request_id); 979 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 980 981 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ; 982 983 /* Now wait for the command to complete */ 984 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout); 985 986 /* See if we reset while waiting for the ioctl to complete */ 987 if (test_bit(TW_IN_RESET, &tw_dev->flags)) { 988 clear_bit(TW_IN_RESET, &tw_dev->flags); 989 retval = -ERESTARTSYS; 990 goto out2; 991 } 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 spin_lock_irqsave(tw_dev->host->host_lock, flags); 999 tw_dev->state[request_id] = TW_S_COMPLETED; 1000 tw_state_request_finish(tw_dev, request_id); 1001 tw_dev->posted_request_count--; 1002 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 1003 if (tw_reset_device_extension(tw_dev, 1)) { 1004 printk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): Reset failed for card %d.\n", tw_dev->host->host_no); 1005 } 1006 goto out2; 1007 } 1008 1009 /* Now copy in the command packet response */ 1010 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command)); 1011 1012 /* Now complete the io */ 1013 spin_lock_irqsave(tw_dev->host->host_lock, flags); 1014 tw_dev->posted_request_count--; 1015 tw_dev->state[request_id] = TW_S_COMPLETED; 1016 tw_state_request_finish(tw_dev, request_id); 1017 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 1018 break; 1019 default: 1020 retval = -ENOTTY; 1021 goto out2; 1022 } 1023 1024 /* Now copy the response to userspace */ 1025 if (copy_to_user(argp, tw_ioctl, sizeof(TW_New_Ioctl) + data_buffer_length - 1)) 1026 goto out2; 1027 retval = 0; 1028 out2: 1029 /* Now free ioctl buf memory */ 1030 dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, cpu_addr, dma_handle); 1031 out: 1032 up(&tw_dev->ioctl_sem); 1033 return retval; 1034 } /* End tw_chrdev_ioctl() */ 1035 1036 /* This function handles open for the character device */ 1037 static int tw_chrdev_open(struct inode *inode, struct file *file) 1038 { 1039 unsigned int minor_number; 1040 1041 dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_open()\n"); 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 struct file_operations tw_fops = { 1052 .owner = THIS_MODULE, 1053 .ioctl = tw_chrdev_ioctl, 1054 .open = tw_chrdev_open, 1055 .release = NULL 1056 }; 1057 1058 /* This function will free up device extension resources */ 1059 static void tw_free_device_extension(TW_Device_Extension *tw_dev) 1060 { 1061 dprintk(KERN_NOTICE "3w-xxxx: tw_free_device_extension()\n"); 1062 1063 /* Free command packet and generic buffer memory */ 1064 if (tw_dev->command_packet_virtual_address[0]) 1065 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]); 1066 1067 if (tw_dev->alignment_virtual_address[0]) 1068 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]); 1069 } /* End tw_free_device_extension() */ 1070 1071 /* This function will send an initconnection command to controller */ 1072 static int tw_initconnection(TW_Device_Extension *tw_dev, int message_credits) 1073 { 1074 unsigned long command_que_value; 1075 TW_Command *command_packet; 1076 TW_Response_Queue response_queue; 1077 int request_id = 0; 1078 1079 dprintk(KERN_NOTICE "3w-xxxx: tw_initconnection()\n"); 1080 1081 /* Initialize InitConnection command packet */ 1082 if (tw_dev->command_packet_virtual_address[request_id] == NULL) { 1083 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet virtual address.\n"); 1084 return 1; 1085 } 1086 1087 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1088 memset(command_packet, 0, sizeof(TW_Sector)); 1089 command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_INIT_CONNECTION); 1090 command_packet->size = TW_INIT_COMMAND_PACKET_SIZE; 1091 command_packet->request_id = request_id; 1092 command_packet->status = 0x0; 1093 command_packet->flags = 0x0; 1094 command_packet->byte6.message_credits = message_credits; 1095 command_packet->byte8.init_connection.response_queue_pointer = 0x0; 1096 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1097 1098 if (command_que_value == 0) { 1099 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet physical address.\n"); 1100 return 1; 1101 } 1102 1103 /* Send command packet to the board */ 1104 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 1105 1106 /* Poll for completion */ 1107 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) { 1108 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 1109 request_id = TW_RESID_OUT(response_queue.response_id); 1110 1111 if (request_id != 0) { 1112 /* unexpected request id */ 1113 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Unexpected request id.\n"); 1114 return 1; 1115 } 1116 if (command_packet->status != 0) { 1117 /* bad response */ 1118 tw_decode_sense(tw_dev, request_id, 0); 1119 return 1; 1120 } 1121 } 1122 return 0; 1123 } /* End tw_initconnection() */ 1124 1125 /* Set a value in the features table */ 1126 static int tw_setfeature(TW_Device_Extension *tw_dev, int parm, int param_size, 1127 unsigned char *val) 1128 { 1129 TW_Param *param; 1130 TW_Command *command_packet; 1131 TW_Response_Queue response_queue; 1132 int request_id = 0; 1133 unsigned long command_que_value; 1134 unsigned long param_value; 1135 1136 /* Initialize SetParam command packet */ 1137 if (tw_dev->command_packet_virtual_address[request_id] == NULL) { 1138 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet virtual address.\n"); 1139 return 1; 1140 } 1141 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1142 memset(command_packet, 0, sizeof(TW_Sector)); 1143 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1144 1145 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM); 1146 param->table_id = 0x404; /* Features table */ 1147 param->parameter_id = parm; 1148 param->parameter_size_bytes = param_size; 1149 memcpy(param->data, val, param_size); 1150 1151 param_value = tw_dev->alignment_physical_address[request_id]; 1152 if (param_value == 0) { 1153 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad alignment physical address.\n"); 1154 tw_dev->state[request_id] = TW_S_COMPLETED; 1155 tw_state_request_finish(tw_dev, request_id); 1156 tw_dev->srb[request_id]->result = (DID_OK << 16); 1157 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 1158 } 1159 command_packet->byte8.param.sgl[0].address = param_value; 1160 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1161 1162 command_packet->size = 4; 1163 command_packet->request_id = request_id; 1164 command_packet->byte6.parameter_count = 1; 1165 1166 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1167 if (command_que_value == 0) { 1168 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet physical address.\n"); 1169 return 1; 1170 } 1171 1172 /* Send command packet to the board */ 1173 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev)); 1174 1175 /* Poll for completion */ 1176 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) { 1177 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 1178 request_id = TW_RESID_OUT(response_queue.response_id); 1179 1180 if (request_id != 0) { 1181 /* unexpected request id */ 1182 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Unexpected request id.\n"); 1183 return 1; 1184 } 1185 if (command_packet->status != 0) { 1186 /* bad response */ 1187 tw_decode_sense(tw_dev, request_id, 0); 1188 return 1; 1189 } 1190 } 1191 1192 return 0; 1193 } /* End tw_setfeature() */ 1194 1195 /* This function will reset a controller */ 1196 static int tw_reset_sequence(TW_Device_Extension *tw_dev) 1197 { 1198 int error = 0; 1199 int tries = 0; 1200 unsigned char c = 1; 1201 1202 /* Reset the board */ 1203 while (tries < TW_MAX_RESET_TRIES) { 1204 TW_SOFT_RESET(tw_dev); 1205 1206 error = tw_aen_drain_queue(tw_dev); 1207 if (error) { 1208 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN drain failed, retrying.\n", tw_dev->host->host_no); 1209 tries++; 1210 continue; 1211 } 1212 1213 /* Check for controller errors */ 1214 if (tw_check_errors(tw_dev)) { 1215 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors found, retrying.\n", tw_dev->host->host_no); 1216 tries++; 1217 continue; 1218 } 1219 1220 /* Now the controller is in a good state */ 1221 break; 1222 } 1223 1224 if (tries >= TW_MAX_RESET_TRIES) { 1225 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors, card not responding, check all cabling.\n", tw_dev->host->host_no); 1226 return 1; 1227 } 1228 1229 error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS); 1230 if (error) { 1231 printk(KERN_WARNING "3w-xxxx: scsi%d: Connection initialization failed.\n", tw_dev->host->host_no); 1232 return 1; 1233 } 1234 1235 error = tw_setfeature(tw_dev, 2, 1, &c); 1236 if (error) { 1237 printk(KERN_WARNING "3w-xxxx: Unable to set features for card, probable old firmware or card.\n"); 1238 } 1239 1240 return 0; 1241 } /* End tw_reset_sequence() */ 1242 1243 /* This function will initialize the fields of a device extension */ 1244 static int tw_initialize_device_extension(TW_Device_Extension *tw_dev) 1245 { 1246 int i, error=0; 1247 1248 dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_device_extension()\n"); 1249 1250 /* Initialize command packet buffers */ 1251 error = tw_allocate_memory(tw_dev, sizeof(TW_Command), 0); 1252 if (error) { 1253 printk(KERN_WARNING "3w-xxxx: Command packet memory allocation failed.\n"); 1254 return 1; 1255 } 1256 1257 /* Initialize generic buffer */ 1258 error = tw_allocate_memory(tw_dev, sizeof(TW_Sector), 1); 1259 if (error) { 1260 printk(KERN_WARNING "3w-xxxx: Generic memory allocation failed.\n"); 1261 return 1; 1262 } 1263 1264 for (i=0;i<TW_Q_LENGTH;i++) { 1265 tw_dev->free_queue[i] = i; 1266 tw_dev->state[i] = TW_S_INITIAL; 1267 } 1268 1269 tw_dev->pending_head = TW_Q_START; 1270 tw_dev->pending_tail = TW_Q_START; 1271 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1272 1273 init_MUTEX(&tw_dev->ioctl_sem); 1274 init_waitqueue_head(&tw_dev->ioctl_wqueue); 1275 1276 return 0; 1277 } /* End tw_initialize_device_extension() */ 1278 1279 static int tw_map_scsi_sg_data(struct pci_dev *pdev, struct scsi_cmnd *cmd) 1280 { 1281 int use_sg; 1282 1283 dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data()\n"); 1284 1285 if (cmd->use_sg == 0) 1286 return 0; 1287 1288 use_sg = pci_map_sg(pdev, cmd->buffer, cmd->use_sg, DMA_BIDIRECTIONAL); 1289 1290 if (use_sg == 0) { 1291 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data(): pci_map_sg() failed.\n"); 1292 return 0; 1293 } 1294 1295 cmd->SCp.phase = TW_PHASE_SGLIST; 1296 cmd->SCp.have_data_in = use_sg; 1297 1298 return use_sg; 1299 } /* End tw_map_scsi_sg_data() */ 1300 1301 static u32 tw_map_scsi_single_data(struct pci_dev *pdev, struct scsi_cmnd *cmd) 1302 { 1303 dma_addr_t mapping; 1304 1305 dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_single_data()\n"); 1306 1307 if (cmd->request_bufflen == 0) 1308 return 0; 1309 1310 mapping = pci_map_page(pdev, virt_to_page(cmd->request_buffer), offset_in_page(cmd->request_buffer), cmd->request_bufflen, DMA_BIDIRECTIONAL); 1311 1312 if (mapping == 0) { 1313 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_single_data(): pci_map_page() failed.\n"); 1314 return 0; 1315 } 1316 1317 cmd->SCp.phase = TW_PHASE_SINGLE; 1318 cmd->SCp.have_data_in = mapping; 1319 1320 return mapping; 1321 } /* End tw_map_scsi_single_data() */ 1322 1323 static void tw_unmap_scsi_data(struct pci_dev *pdev, struct scsi_cmnd *cmd) 1324 { 1325 dprintk(KERN_WARNING "3w-xxxx: tw_unmap_scsi_data()\n"); 1326 1327 switch(cmd->SCp.phase) { 1328 case TW_PHASE_SINGLE: 1329 pci_unmap_page(pdev, cmd->SCp.have_data_in, cmd->request_bufflen, DMA_BIDIRECTIONAL); 1330 break; 1331 case TW_PHASE_SGLIST: 1332 pci_unmap_sg(pdev, cmd->request_buffer, cmd->use_sg, DMA_BIDIRECTIONAL); 1333 break; 1334 } 1335 } /* End tw_unmap_scsi_data() */ 1336 1337 /* This function will reset a device extension */ 1338 static int tw_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset) 1339 { 1340 int i = 0; 1341 struct scsi_cmnd *srb; 1342 unsigned long flags = 0; 1343 1344 dprintk(KERN_NOTICE "3w-xxxx: tw_reset_device_extension()\n"); 1345 1346 set_bit(TW_IN_RESET, &tw_dev->flags); 1347 TW_DISABLE_INTERRUPTS(tw_dev); 1348 TW_MASK_COMMAND_INTERRUPT(tw_dev); 1349 spin_lock_irqsave(tw_dev->host->host_lock, flags); 1350 1351 /* Abort all requests that are in progress */ 1352 for (i=0;i<TW_Q_LENGTH;i++) { 1353 if ((tw_dev->state[i] != TW_S_FINISHED) && 1354 (tw_dev->state[i] != TW_S_INITIAL) && 1355 (tw_dev->state[i] != TW_S_COMPLETED)) { 1356 srb = tw_dev->srb[i]; 1357 if (srb != NULL) { 1358 srb->result = (DID_RESET << 16); 1359 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]); 1360 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[i]); 1361 } 1362 } 1363 } 1364 1365 /* Reset queues and counts */ 1366 for (i=0;i<TW_Q_LENGTH;i++) { 1367 tw_dev->free_queue[i] = i; 1368 tw_dev->state[i] = TW_S_INITIAL; 1369 } 1370 tw_dev->free_head = TW_Q_START; 1371 tw_dev->free_tail = TW_Q_START; 1372 tw_dev->posted_request_count = 0; 1373 tw_dev->pending_request_count = 0; 1374 tw_dev->pending_head = TW_Q_START; 1375 tw_dev->pending_tail = TW_Q_START; 1376 tw_dev->reset_print = 0; 1377 1378 spin_unlock_irqrestore(tw_dev->host->host_lock, flags); 1379 1380 if (tw_reset_sequence(tw_dev)) { 1381 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset sequence failed.\n", tw_dev->host->host_no); 1382 return 1; 1383 } 1384 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 1385 1386 /* Wake up any ioctl that was pending before the reset */ 1387 if ((tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE) || (ioctl_reset)) { 1388 clear_bit(TW_IN_RESET, &tw_dev->flags); 1389 } else { 1390 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 1391 wake_up(&tw_dev->ioctl_wqueue); 1392 } 1393 1394 return 0; 1395 } /* End tw_reset_device_extension() */ 1396 1397 /* This funciton returns unit geometry in cylinders/heads/sectors */ 1398 static int tw_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, 1399 sector_t capacity, int geom[]) 1400 { 1401 int heads, sectors, cylinders; 1402 TW_Device_Extension *tw_dev; 1403 1404 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam()\n"); 1405 tw_dev = (TW_Device_Extension *)sdev->host->hostdata; 1406 1407 heads = 64; 1408 sectors = 32; 1409 cylinders = sector_div(capacity, heads * sectors); 1410 1411 if (capacity >= 0x200000) { 1412 heads = 255; 1413 sectors = 63; 1414 cylinders = sector_div(capacity, heads * sectors); 1415 } 1416 1417 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam(): heads = %d, sectors = %d, cylinders = %d\n", heads, sectors, cylinders); 1418 geom[0] = heads; 1419 geom[1] = sectors; 1420 geom[2] = cylinders; 1421 1422 return 0; 1423 } /* End tw_scsi_biosparam() */ 1424 1425 /* This is the new scsi eh reset function */ 1426 static int tw_scsi_eh_reset(struct scsi_cmnd *SCpnt) 1427 { 1428 TW_Device_Extension *tw_dev=NULL; 1429 int retval = FAILED; 1430 1431 tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 1432 1433 tw_dev->num_resets++; 1434 1435 printk(KERN_WARNING "3w-xxxx: scsi%d: WARNING: Unit #%d: Command (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, SCpnt->device->id, SCpnt->cmnd[0]); 1436 1437 /* Now reset the card and some of the device extension data */ 1438 if (tw_reset_device_extension(tw_dev, 0)) { 1439 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset failed.\n", tw_dev->host->host_no); 1440 goto out; 1441 } 1442 1443 retval = SUCCESS; 1444 out: 1445 return retval; 1446 } /* End tw_scsi_eh_reset() */ 1447 1448 /* This function handles scsi inquiry commands */ 1449 static int tw_scsiop_inquiry(TW_Device_Extension *tw_dev, int request_id) 1450 { 1451 TW_Param *param; 1452 TW_Command *command_packet; 1453 unsigned long command_que_value; 1454 unsigned long param_value; 1455 1456 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry()\n"); 1457 1458 /* Initialize command packet */ 1459 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1460 if (command_packet == NULL) { 1461 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet virtual address.\n"); 1462 return 1; 1463 } 1464 memset(command_packet, 0, sizeof(TW_Sector)); 1465 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1466 command_packet->size = 4; 1467 command_packet->request_id = request_id; 1468 command_packet->status = 0; 1469 command_packet->flags = 0; 1470 command_packet->byte6.parameter_count = 1; 1471 1472 /* Now setup the param */ 1473 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1474 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment virtual address.\n"); 1475 return 1; 1476 } 1477 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1478 memset(param, 0, sizeof(TW_Sector)); 1479 param->table_id = 3; /* unit summary table */ 1480 param->parameter_id = 3; /* unitsstatus parameter */ 1481 param->parameter_size_bytes = TW_MAX_UNITS; 1482 param_value = tw_dev->alignment_physical_address[request_id]; 1483 if (param_value == 0) { 1484 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment physical address.\n"); 1485 return 1; 1486 } 1487 1488 command_packet->byte8.param.sgl[0].address = param_value; 1489 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1490 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1491 if (command_que_value == 0) { 1492 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet physical address.\n"); 1493 return 1; 1494 } 1495 1496 /* Now try to post the command packet */ 1497 tw_post_command_packet(tw_dev, request_id); 1498 1499 return 0; 1500 } /* End tw_scsiop_inquiry() */ 1501 1502 static void tw_transfer_internal(TW_Device_Extension *tw_dev, int request_id, 1503 void *data, unsigned int len) 1504 { 1505 struct scsi_cmnd *cmd = tw_dev->srb[request_id]; 1506 void *buf; 1507 unsigned int transfer_len; 1508 1509 if (cmd->use_sg) { 1510 struct scatterlist *sg = 1511 (struct scatterlist *)cmd->request_buffer; 1512 buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset; 1513 transfer_len = min(sg->length, len); 1514 } else { 1515 buf = cmd->request_buffer; 1516 transfer_len = min(cmd->request_bufflen, len); 1517 } 1518 1519 memcpy(buf, data, transfer_len); 1520 1521 if (cmd->use_sg) { 1522 struct scatterlist *sg; 1523 1524 sg = (struct scatterlist *)cmd->request_buffer; 1525 kunmap_atomic(buf - sg->offset, KM_IRQ0); 1526 } 1527 } 1528 1529 /* This function is called by the isr to complete an inquiry command */ 1530 static int tw_scsiop_inquiry_complete(TW_Device_Extension *tw_dev, int request_id) 1531 { 1532 unsigned char *is_unit_present; 1533 unsigned char request_buffer[36]; 1534 TW_Param *param; 1535 1536 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry_complete()\n"); 1537 1538 memset(request_buffer, 0, sizeof(request_buffer)); 1539 request_buffer[0] = TYPE_DISK; /* Peripheral device type */ 1540 request_buffer[1] = 0; /* Device type modifier */ 1541 request_buffer[2] = 0; /* No ansi/iso compliance */ 1542 request_buffer[4] = 31; /* Additional length */ 1543 memcpy(&request_buffer[8], "3ware ", 8); /* Vendor ID */ 1544 sprintf(&request_buffer[16], "Logical Disk %-2d ", tw_dev->srb[request_id]->device->id); 1545 memcpy(&request_buffer[32], TW_DRIVER_VERSION, 3); 1546 tw_transfer_internal(tw_dev, request_id, request_buffer, 1547 sizeof(request_buffer)); 1548 1549 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1550 if (param == NULL) { 1551 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Bad alignment virtual address.\n"); 1552 return 1; 1553 } 1554 is_unit_present = &(param->data[0]); 1555 1556 if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) { 1557 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1; 1558 } else { 1559 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0; 1560 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16); 1561 return TW_ISR_DONT_RESULT; 1562 } 1563 1564 return 0; 1565 } /* End tw_scsiop_inquiry_complete() */ 1566 1567 /* This function handles scsi mode_sense commands */ 1568 static int tw_scsiop_mode_sense(TW_Device_Extension *tw_dev, int request_id) 1569 { 1570 TW_Param *param; 1571 TW_Command *command_packet; 1572 unsigned long command_que_value; 1573 unsigned long param_value; 1574 1575 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense()\n"); 1576 1577 /* Only page control = 0, page code = 0x8 (cache page) supported */ 1578 if (tw_dev->srb[request_id]->cmnd[2] != 0x8) { 1579 tw_dev->state[request_id] = TW_S_COMPLETED; 1580 tw_state_request_finish(tw_dev, request_id); 1581 tw_dev->srb[request_id]->result = (DID_OK << 16); 1582 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 1583 return 0; 1584 } 1585 1586 /* Now read firmware cache setting for this unit */ 1587 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1588 if (command_packet == NULL) { 1589 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet virtual address.\n"); 1590 return 1; 1591 } 1592 1593 /* Setup the command packet */ 1594 memset(command_packet, 0, sizeof(TW_Sector)); 1595 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1596 command_packet->size = 4; 1597 command_packet->request_id = request_id; 1598 command_packet->status = 0; 1599 command_packet->flags = 0; 1600 command_packet->byte6.parameter_count = 1; 1601 1602 /* Setup the param */ 1603 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1604 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment virtual address.\n"); 1605 return 1; 1606 } 1607 1608 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1609 memset(param, 0, sizeof(TW_Sector)); 1610 param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + tw_dev->srb[request_id]->device->id; 1611 param->parameter_id = 7; /* unit flags */ 1612 param->parameter_size_bytes = 1; 1613 param_value = tw_dev->alignment_physical_address[request_id]; 1614 if (param_value == 0) { 1615 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment physical address.\n"); 1616 return 1; 1617 } 1618 1619 command_packet->byte8.param.sgl[0].address = param_value; 1620 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1621 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1622 if (command_que_value == 0) { 1623 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet physical address.\n"); 1624 return 1; 1625 } 1626 1627 /* Now try to post the command packet */ 1628 tw_post_command_packet(tw_dev, request_id); 1629 1630 return 0; 1631 } /* End tw_scsiop_mode_sense() */ 1632 1633 /* This function is called by the isr to complete a mode sense command */ 1634 static int tw_scsiop_mode_sense_complete(TW_Device_Extension *tw_dev, int request_id) 1635 { 1636 TW_Param *param; 1637 unsigned char *flags; 1638 unsigned char request_buffer[8]; 1639 1640 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense_complete()\n"); 1641 1642 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1643 if (param == NULL) { 1644 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense_complete(): Bad alignment virtual address.\n"); 1645 return 1; 1646 } 1647 flags = (char *)&(param->data[0]); 1648 memset(request_buffer, 0, sizeof(request_buffer)); 1649 1650 request_buffer[0] = 0xf; /* mode data length */ 1651 request_buffer[1] = 0; /* default medium type */ 1652 request_buffer[2] = 0x10; /* dpo/fua support on */ 1653 request_buffer[3] = 0; /* no block descriptors */ 1654 request_buffer[4] = 0x8; /* caching page */ 1655 request_buffer[5] = 0xa; /* page length */ 1656 if (*flags & 0x1) 1657 request_buffer[6] = 0x4; /* WCE on */ 1658 else 1659 request_buffer[6] = 0x0; /* WCE off */ 1660 tw_transfer_internal(tw_dev, request_id, request_buffer, 1661 sizeof(request_buffer)); 1662 1663 return 0; 1664 } /* End tw_scsiop_mode_sense_complete() */ 1665 1666 /* This function handles scsi read_capacity commands */ 1667 static int tw_scsiop_read_capacity(TW_Device_Extension *tw_dev, int request_id) 1668 { 1669 TW_Param *param; 1670 TW_Command *command_packet; 1671 unsigned long command_que_value; 1672 unsigned long param_value; 1673 1674 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity()\n"); 1675 1676 /* Initialize command packet */ 1677 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1678 1679 if (command_packet == NULL) { 1680 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet virtual address.\n"); 1681 return 1; 1682 } 1683 memset(command_packet, 0, sizeof(TW_Sector)); 1684 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1685 command_packet->size = 4; 1686 command_packet->request_id = request_id; 1687 command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id); 1688 command_packet->status = 0; 1689 command_packet->flags = 0; 1690 command_packet->byte6.block_count = 1; 1691 1692 /* Now setup the param */ 1693 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1694 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment virtual address.\n"); 1695 return 1; 1696 } 1697 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1698 memset(param, 0, sizeof(TW_Sector)); 1699 param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + 1700 tw_dev->srb[request_id]->device->id; 1701 param->parameter_id = 4; /* unitcapacity parameter */ 1702 param->parameter_size_bytes = 4; 1703 param_value = tw_dev->alignment_physical_address[request_id]; 1704 if (param_value == 0) { 1705 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment physical address.\n"); 1706 return 1; 1707 } 1708 1709 command_packet->byte8.param.sgl[0].address = param_value; 1710 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1711 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1712 if (command_que_value == 0) { 1713 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet physical address.\n"); 1714 return 1; 1715 } 1716 1717 /* Now try to post the command to the board */ 1718 tw_post_command_packet(tw_dev, request_id); 1719 1720 return 0; 1721 } /* End tw_scsiop_read_capacity() */ 1722 1723 /* This function is called by the isr to complete a readcapacity command */ 1724 static int tw_scsiop_read_capacity_complete(TW_Device_Extension *tw_dev, int request_id) 1725 { 1726 unsigned char *param_data; 1727 u32 capacity; 1728 char buff[8]; 1729 TW_Param *param; 1730 1731 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete()\n"); 1732 1733 memset(buff, 0, sizeof(buff)); 1734 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1735 if (param == NULL) { 1736 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Bad alignment virtual address.\n"); 1737 return 1; 1738 } 1739 param_data = &(param->data[0]); 1740 1741 capacity = (param_data[3] << 24) | (param_data[2] << 16) | 1742 (param_data[1] << 8) | param_data[0]; 1743 1744 /* Subtract one sector to fix get last sector ioctl */ 1745 capacity -= 1; 1746 1747 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete(): Capacity = 0x%x.\n", capacity); 1748 1749 /* Number of LBA's */ 1750 buff[0] = (capacity >> 24); 1751 buff[1] = (capacity >> 16) & 0xff; 1752 buff[2] = (capacity >> 8) & 0xff; 1753 buff[3] = capacity & 0xff; 1754 1755 /* Block size in bytes (512) */ 1756 buff[4] = (TW_BLOCK_SIZE >> 24); 1757 buff[5] = (TW_BLOCK_SIZE >> 16) & 0xff; 1758 buff[6] = (TW_BLOCK_SIZE >> 8) & 0xff; 1759 buff[7] = TW_BLOCK_SIZE & 0xff; 1760 1761 tw_transfer_internal(tw_dev, request_id, buff, sizeof(buff)); 1762 1763 return 0; 1764 } /* End tw_scsiop_read_capacity_complete() */ 1765 1766 /* This function handles scsi read or write commands */ 1767 static int tw_scsiop_read_write(TW_Device_Extension *tw_dev, int request_id) 1768 { 1769 TW_Command *command_packet; 1770 unsigned long command_que_value; 1771 u32 lba = 0x0, num_sectors = 0x0, buffaddr = 0x0; 1772 int i, use_sg; 1773 struct scsi_cmnd *srb; 1774 struct scatterlist *sglist; 1775 1776 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write()\n"); 1777 1778 if (tw_dev->srb[request_id]->request_buffer == NULL) { 1779 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Request buffer NULL.\n"); 1780 return 1; 1781 } 1782 sglist = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer; 1783 srb = tw_dev->srb[request_id]; 1784 1785 /* Initialize command packet */ 1786 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1787 if (command_packet == NULL) { 1788 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): Bad command packet virtual address.\n"); 1789 return 1; 1790 } 1791 1792 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == READ_10) { 1793 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_READ); 1794 } else { 1795 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_WRITE); 1796 } 1797 1798 command_packet->size = 3; 1799 command_packet->request_id = request_id; 1800 command_packet->unit__hostid = TW_UNITHOST_IN(0, srb->device->id); 1801 command_packet->status = 0; 1802 command_packet->flags = 0; 1803 1804 if (srb->cmnd[0] == WRITE_10) { 1805 if ((srb->cmnd[1] & 0x8) || (srb->cmnd[1] & 0x10)) 1806 command_packet->flags = 1; 1807 } 1808 1809 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) { 1810 lba = ((u32)srb->cmnd[1] << 16) | ((u32)srb->cmnd[2] << 8) | (u32)srb->cmnd[3]; 1811 num_sectors = (u32)srb->cmnd[4]; 1812 } else { 1813 lba = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) | ((u32)srb->cmnd[4] << 8) | (u32)srb->cmnd[5]; 1814 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8); 1815 } 1816 1817 /* Update sector statistic */ 1818 tw_dev->sector_count = num_sectors; 1819 if (tw_dev->sector_count > tw_dev->max_sector_count) 1820 tw_dev->max_sector_count = tw_dev->sector_count; 1821 1822 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): lba = 0x%x num_sectors = 0x%x\n", lba, num_sectors); 1823 command_packet->byte8.io.lba = lba; 1824 command_packet->byte6.block_count = num_sectors; 1825 1826 /* Do this if there are no sg list entries */ 1827 if (tw_dev->srb[request_id]->use_sg == 0) { 1828 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): SG = 0\n"); 1829 buffaddr = tw_map_scsi_single_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]); 1830 if (buffaddr == 0) 1831 return 1; 1832 1833 command_packet->byte8.io.sgl[0].address = buffaddr; 1834 command_packet->byte8.io.sgl[0].length = tw_dev->srb[request_id]->request_bufflen; 1835 command_packet->size+=2; 1836 } 1837 1838 /* Do this if we have multiple sg list entries */ 1839 if (tw_dev->srb[request_id]->use_sg > 0) { 1840 use_sg = tw_map_scsi_sg_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]); 1841 if (use_sg == 0) 1842 return 1; 1843 1844 for (i=0;i<use_sg; i++) { 1845 command_packet->byte8.io.sgl[i].address = sg_dma_address(&sglist[i]); 1846 command_packet->byte8.io.sgl[i].length = sg_dma_len(&sglist[i]); 1847 command_packet->size+=2; 1848 } 1849 } 1850 1851 /* Update SG statistics */ 1852 tw_dev->sgl_entries = tw_dev->srb[request_id]->use_sg; 1853 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries) 1854 tw_dev->max_sgl_entries = tw_dev->sgl_entries; 1855 1856 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1857 if (command_que_value == 0) { 1858 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Bad command packet physical address.\n"); 1859 return 1; 1860 } 1861 1862 /* Now try to post the command to the board */ 1863 tw_post_command_packet(tw_dev, request_id); 1864 1865 return 0; 1866 } /* End tw_scsiop_read_write() */ 1867 1868 /* This function will handle the request sense scsi command */ 1869 static int tw_scsiop_request_sense(TW_Device_Extension *tw_dev, int request_id) 1870 { 1871 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_request_sense()\n"); 1872 1873 /* For now we just zero the request buffer */ 1874 memset(tw_dev->srb[request_id]->request_buffer, 0, tw_dev->srb[request_id]->request_bufflen); 1875 tw_dev->state[request_id] = TW_S_COMPLETED; 1876 tw_state_request_finish(tw_dev, request_id); 1877 1878 /* If we got a request_sense, we probably want a reset, return error */ 1879 tw_dev->srb[request_id]->result = (DID_ERROR << 16); 1880 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 1881 1882 return 0; 1883 } /* End tw_scsiop_request_sense() */ 1884 1885 /* This function will handle synchronize cache scsi command */ 1886 static int tw_scsiop_synchronize_cache(TW_Device_Extension *tw_dev, int request_id) 1887 { 1888 TW_Command *command_packet; 1889 unsigned long command_que_value; 1890 1891 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_synchronize_cache()\n"); 1892 1893 /* Send firmware flush command for this unit */ 1894 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1895 if (command_packet == NULL) { 1896 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet virtual address.\n"); 1897 return 1; 1898 } 1899 1900 /* Setup the command packet */ 1901 memset(command_packet, 0, sizeof(TW_Sector)); 1902 command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_FLUSH_CACHE); 1903 command_packet->size = 2; 1904 command_packet->request_id = request_id; 1905 command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id); 1906 command_packet->status = 0; 1907 command_packet->flags = 0; 1908 command_packet->byte6.parameter_count = 1; 1909 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1910 if (command_que_value == 0) { 1911 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet physical address.\n"); 1912 return 1; 1913 } 1914 1915 /* Now try to post the command packet */ 1916 tw_post_command_packet(tw_dev, request_id); 1917 1918 return 0; 1919 } /* End tw_scsiop_synchronize_cache() */ 1920 1921 /* This function will handle test unit ready scsi command */ 1922 static int tw_scsiop_test_unit_ready(TW_Device_Extension *tw_dev, int request_id) 1923 { 1924 TW_Param *param; 1925 TW_Command *command_packet; 1926 unsigned long command_que_value; 1927 unsigned long param_value; 1928 1929 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_test_unit_ready()\n"); 1930 1931 /* Initialize command packet */ 1932 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 1933 if (command_packet == NULL) { 1934 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet virtual address.\n"); 1935 return 1; 1936 } 1937 memset(command_packet, 0, sizeof(TW_Sector)); 1938 command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM); 1939 command_packet->size = 4; 1940 command_packet->request_id = request_id; 1941 command_packet->status = 0; 1942 command_packet->flags = 0; 1943 command_packet->byte6.parameter_count = 1; 1944 1945 /* Now setup the param */ 1946 if (tw_dev->alignment_virtual_address[request_id] == NULL) { 1947 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment virtual address.\n"); 1948 return 1; 1949 } 1950 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1951 memset(param, 0, sizeof(TW_Sector)); 1952 param->table_id = 3; /* unit summary table */ 1953 param->parameter_id = 3; /* unitsstatus parameter */ 1954 param->parameter_size_bytes = TW_MAX_UNITS; 1955 param_value = tw_dev->alignment_physical_address[request_id]; 1956 if (param_value == 0) { 1957 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment physical address.\n"); 1958 return 1; 1959 } 1960 1961 command_packet->byte8.param.sgl[0].address = param_value; 1962 command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector); 1963 command_que_value = tw_dev->command_packet_physical_address[request_id]; 1964 if (command_que_value == 0) { 1965 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet physical address.\n"); 1966 return 1; 1967 } 1968 1969 /* Now try to post the command packet */ 1970 tw_post_command_packet(tw_dev, request_id); 1971 1972 return 0; 1973 } /* End tw_scsiop_test_unit_ready() */ 1974 1975 /* This function is called by the isr to complete a testunitready command */ 1976 static int tw_scsiop_test_unit_ready_complete(TW_Device_Extension *tw_dev, int request_id) 1977 { 1978 unsigned char *is_unit_present; 1979 TW_Param *param; 1980 1981 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete()\n"); 1982 1983 param = (TW_Param *)tw_dev->alignment_virtual_address[request_id]; 1984 if (param == NULL) { 1985 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete(): Bad alignment virtual address.\n"); 1986 return 1; 1987 } 1988 is_unit_present = &(param->data[0]); 1989 1990 if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) { 1991 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1; 1992 } else { 1993 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0; 1994 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16); 1995 return TW_ISR_DONT_RESULT; 1996 } 1997 1998 return 0; 1999 } /* End tw_scsiop_test_unit_ready_complete() */ 2000 2001 /* This is the main scsi queue function to handle scsi opcodes */ 2002 static int tw_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 2003 { 2004 unsigned char *command = SCpnt->cmnd; 2005 int request_id = 0; 2006 int retval = 1; 2007 TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata; 2008 2009 /* Save done function into Scsi_Cmnd struct */ 2010 SCpnt->scsi_done = done; 2011 2012 /* Queue the command and get a request id */ 2013 tw_state_request_start(tw_dev, &request_id); 2014 2015 /* Save the scsi command for use by the ISR */ 2016 tw_dev->srb[request_id] = SCpnt; 2017 2018 /* Initialize phase to zero */ 2019 SCpnt->SCp.phase = TW_PHASE_INITIAL; 2020 2021 switch (*command) { 2022 case READ_10: 2023 case READ_6: 2024 case WRITE_10: 2025 case WRITE_6: 2026 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ/WRITE.\n"); 2027 retval = tw_scsiop_read_write(tw_dev, request_id); 2028 break; 2029 case TEST_UNIT_READY: 2030 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TEST_UNIT_READY.\n"); 2031 retval = tw_scsiop_test_unit_ready(tw_dev, request_id); 2032 break; 2033 case INQUIRY: 2034 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught INQUIRY.\n"); 2035 retval = tw_scsiop_inquiry(tw_dev, request_id); 2036 break; 2037 case READ_CAPACITY: 2038 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ_CAPACITY.\n"); 2039 retval = tw_scsiop_read_capacity(tw_dev, request_id); 2040 break; 2041 case REQUEST_SENSE: 2042 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught REQUEST_SENSE.\n"); 2043 retval = tw_scsiop_request_sense(tw_dev, request_id); 2044 break; 2045 case MODE_SENSE: 2046 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught MODE_SENSE.\n"); 2047 retval = tw_scsiop_mode_sense(tw_dev, request_id); 2048 break; 2049 case SYNCHRONIZE_CACHE: 2050 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught SYNCHRONIZE_CACHE.\n"); 2051 retval = tw_scsiop_synchronize_cache(tw_dev, request_id); 2052 break; 2053 case TW_IOCTL: 2054 printk(KERN_WARNING "3w-xxxx: SCSI_IOCTL_SEND_COMMAND deprecated, please update your 3ware tools.\n"); 2055 break; 2056 default: 2057 printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command); 2058 tw_dev->state[request_id] = TW_S_COMPLETED; 2059 tw_state_request_finish(tw_dev, request_id); 2060 SCpnt->result = (DID_BAD_TARGET << 16); 2061 done(SCpnt); 2062 retval = 0; 2063 } 2064 if (retval) { 2065 tw_dev->state[request_id] = TW_S_COMPLETED; 2066 tw_state_request_finish(tw_dev, request_id); 2067 SCpnt->result = (DID_ERROR << 16); 2068 done(SCpnt); 2069 retval = 0; 2070 } 2071 return retval; 2072 } /* End tw_scsi_queue() */ 2073 2074 /* This function is the interrupt service routine */ 2075 static irqreturn_t tw_interrupt(int irq, void *dev_instance, 2076 struct pt_regs *regs) 2077 { 2078 int request_id; 2079 u32 status_reg_value; 2080 TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance; 2081 TW_Response_Queue response_que; 2082 int error = 0, retval = 0; 2083 TW_Command *command_packet; 2084 int handled = 0; 2085 2086 /* Get the host lock for io completions */ 2087 spin_lock(tw_dev->host->host_lock); 2088 2089 /* Read the registers */ 2090 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 2091 2092 /* Check if this is our interrupt, otherwise bail */ 2093 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT)) 2094 goto tw_interrupt_bail; 2095 2096 handled = 1; 2097 2098 /* Check controller for errors */ 2099 if (tw_check_bits(status_reg_value)) { 2100 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n"); 2101 if (tw_decode_bits(tw_dev, status_reg_value, 1)) { 2102 TW_CLEAR_ALL_INTERRUPTS(tw_dev); 2103 goto tw_interrupt_bail; 2104 } 2105 } 2106 2107 /* Handle host interrupt */ 2108 if (status_reg_value & TW_STATUS_HOST_INTERRUPT) { 2109 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received host interrupt.\n"); 2110 TW_CLEAR_HOST_INTERRUPT(tw_dev); 2111 } 2112 2113 /* Handle attention interrupt */ 2114 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) { 2115 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received attention interrupt.\n"); 2116 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev); 2117 tw_state_request_start(tw_dev, &request_id); 2118 error = tw_aen_read_queue(tw_dev, request_id); 2119 if (error) { 2120 printk(KERN_WARNING "3w-xxxx: scsi%d: Error reading aen queue.\n", tw_dev->host->host_no); 2121 tw_dev->state[request_id] = TW_S_COMPLETED; 2122 tw_state_request_finish(tw_dev, request_id); 2123 } 2124 } 2125 2126 /* Handle command interrupt */ 2127 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) { 2128 /* Drain as many pending commands as we can */ 2129 while (tw_dev->pending_request_count > 0) { 2130 request_id = tw_dev->pending_queue[tw_dev->pending_head]; 2131 if (tw_dev->state[request_id] != TW_S_PENDING) { 2132 printk(KERN_WARNING "3w-xxxx: scsi%d: Found request id that wasn't pending.\n", tw_dev->host->host_no); 2133 break; 2134 } 2135 if (tw_post_command_packet(tw_dev, request_id)==0) { 2136 if (tw_dev->pending_head == TW_Q_LENGTH-1) { 2137 tw_dev->pending_head = TW_Q_START; 2138 } else { 2139 tw_dev->pending_head = tw_dev->pending_head + 1; 2140 } 2141 tw_dev->pending_request_count--; 2142 } else { 2143 /* If we get here, we will continue re-posting on the next command interrupt */ 2144 break; 2145 } 2146 } 2147 /* If there are no more pending requests, we mask command interrupt */ 2148 if (tw_dev->pending_request_count == 0) 2149 TW_MASK_COMMAND_INTERRUPT(tw_dev); 2150 } 2151 2152 /* Handle response interrupt */ 2153 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) { 2154 /* Drain the response queue from the board */ 2155 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) { 2156 /* Read response queue register */ 2157 response_que.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev)); 2158 request_id = TW_RESID_OUT(response_que.response_id); 2159 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id]; 2160 error = 0; 2161 2162 /* Check for bad response */ 2163 if (command_packet->status != 0) { 2164 /* If internal command, don't error, don't fill sense */ 2165 if (tw_dev->srb[request_id] == NULL) { 2166 tw_decode_sense(tw_dev, request_id, 0); 2167 } else { 2168 error = tw_decode_sense(tw_dev, request_id, 1); 2169 } 2170 } 2171 2172 /* Check for correct state */ 2173 if (tw_dev->state[request_id] != TW_S_POSTED) { 2174 if (tw_dev->srb[request_id] != NULL) { 2175 printk(KERN_WARNING "3w-xxxx: scsi%d: Received a request id that wasn't posted.\n", tw_dev->host->host_no); 2176 error = 1; 2177 } 2178 } 2179 2180 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Response queue request id: %d.\n", request_id); 2181 2182 /* Check for internal command completion */ 2183 if (tw_dev->srb[request_id] == NULL) { 2184 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Found internally posted command.\n"); 2185 /* Check for chrdev ioctl completion */ 2186 if (request_id != tw_dev->chrdev_request_id) { 2187 retval = tw_aen_complete(tw_dev, request_id); 2188 if (retval) { 2189 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing aen.\n", tw_dev->host->host_no); 2190 } 2191 } else { 2192 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE; 2193 wake_up(&tw_dev->ioctl_wqueue); 2194 } 2195 } else { 2196 switch (tw_dev->srb[request_id]->cmnd[0]) { 2197 case READ_10: 2198 case READ_6: 2199 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_10/READ_6\n"); 2200 break; 2201 case WRITE_10: 2202 case WRITE_6: 2203 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught WRITE_10/WRITE_6\n"); 2204 break; 2205 case TEST_UNIT_READY: 2206 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TEST_UNIT_READY\n"); 2207 error = tw_scsiop_test_unit_ready_complete(tw_dev, request_id); 2208 break; 2209 case INQUIRY: 2210 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught INQUIRY\n"); 2211 error = tw_scsiop_inquiry_complete(tw_dev, request_id); 2212 break; 2213 case READ_CAPACITY: 2214 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_CAPACITY\n"); 2215 error = tw_scsiop_read_capacity_complete(tw_dev, request_id); 2216 break; 2217 case MODE_SENSE: 2218 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught MODE_SENSE\n"); 2219 error = tw_scsiop_mode_sense_complete(tw_dev, request_id); 2220 break; 2221 case SYNCHRONIZE_CACHE: 2222 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught SYNCHRONIZE_CACHE\n"); 2223 break; 2224 default: 2225 printk(KERN_WARNING "3w-xxxx: case slip in tw_interrupt()\n"); 2226 error = 1; 2227 } 2228 2229 /* If no error command was a success */ 2230 if (error == 0) { 2231 tw_dev->srb[request_id]->result = (DID_OK << 16); 2232 } 2233 2234 /* If error, command failed */ 2235 if (error == 1) { 2236 /* Ask for a host reset */ 2237 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1); 2238 } 2239 2240 /* Now complete the io */ 2241 if ((error != TW_ISR_DONT_COMPLETE)) { 2242 tw_dev->state[request_id] = TW_S_COMPLETED; 2243 tw_state_request_finish(tw_dev, request_id); 2244 tw_dev->posted_request_count--; 2245 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]); 2246 2247 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]); 2248 } 2249 } 2250 2251 /* Check for valid status after each drain */ 2252 status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev)); 2253 if (tw_check_bits(status_reg_value)) { 2254 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n"); 2255 if (tw_decode_bits(tw_dev, status_reg_value, 1)) { 2256 TW_CLEAR_ALL_INTERRUPTS(tw_dev); 2257 goto tw_interrupt_bail; 2258 } 2259 } 2260 } 2261 } 2262 2263 tw_interrupt_bail: 2264 spin_unlock(tw_dev->host->host_lock); 2265 return IRQ_RETVAL(handled); 2266 } /* End tw_interrupt() */ 2267 2268 /* This function tells the controller to shut down */ 2269 static void __tw_shutdown(TW_Device_Extension *tw_dev) 2270 { 2271 /* Disable interrupts */ 2272 TW_DISABLE_INTERRUPTS(tw_dev); 2273 2274 printk(KERN_WARNING "3w-xxxx: Shutting down host %d.\n", tw_dev->host->host_no); 2275 2276 /* Tell the card we are shutting down */ 2277 if (tw_initconnection(tw_dev, 1)) { 2278 printk(KERN_WARNING "3w-xxxx: Connection shutdown failed.\n"); 2279 } else { 2280 printk(KERN_WARNING "3w-xxxx: Shutdown complete.\n"); 2281 } 2282 2283 /* Clear all interrupts just before exit */ 2284 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 2285 } /* End __tw_shutdown() */ 2286 2287 /* Wrapper for __tw_shutdown */ 2288 static void tw_shutdown(struct pci_dev *pdev) 2289 { 2290 struct Scsi_Host *host = pci_get_drvdata(pdev); 2291 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 2292 2293 __tw_shutdown(tw_dev); 2294 } /* End tw_shutdown() */ 2295 2296 static struct scsi_host_template driver_template = { 2297 .module = THIS_MODULE, 2298 .name = "3ware Storage Controller", 2299 .queuecommand = tw_scsi_queue, 2300 .eh_host_reset_handler = tw_scsi_eh_reset, 2301 .bios_param = tw_scsi_biosparam, 2302 .change_queue_depth = tw_change_queue_depth, 2303 .can_queue = TW_Q_LENGTH-2, 2304 .this_id = -1, 2305 .sg_tablesize = TW_MAX_SGL_LENGTH, 2306 .max_sectors = TW_MAX_SECTORS, 2307 .cmd_per_lun = TW_MAX_CMDS_PER_LUN, 2308 .use_clustering = ENABLE_CLUSTERING, 2309 .shost_attrs = tw_host_attrs, 2310 .emulated = 1 2311 }; 2312 2313 /* This function will probe and initialize a card */ 2314 static int __devinit tw_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id) 2315 { 2316 struct Scsi_Host *host = NULL; 2317 TW_Device_Extension *tw_dev; 2318 int retval = -ENODEV; 2319 2320 retval = pci_enable_device(pdev); 2321 if (retval) { 2322 printk(KERN_WARNING "3w-xxxx: Failed to enable pci device."); 2323 goto out_disable_device; 2324 } 2325 2326 pci_set_master(pdev); 2327 2328 retval = pci_set_dma_mask(pdev, TW_DMA_MASK); 2329 if (retval) { 2330 printk(KERN_WARNING "3w-xxxx: Failed to set dma mask."); 2331 goto out_disable_device; 2332 } 2333 2334 host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension)); 2335 if (!host) { 2336 printk(KERN_WARNING "3w-xxxx: Failed to allocate memory for device extension."); 2337 retval = -ENOMEM; 2338 goto out_disable_device; 2339 } 2340 tw_dev = (TW_Device_Extension *)host->hostdata; 2341 2342 memset(tw_dev, 0, sizeof(TW_Device_Extension)); 2343 2344 /* Save values to device extension */ 2345 tw_dev->host = host; 2346 tw_dev->tw_pci_dev = pdev; 2347 2348 if (tw_initialize_device_extension(tw_dev)) { 2349 printk(KERN_WARNING "3w-xxxx: Failed to initialize device extension."); 2350 goto out_free_device_extension; 2351 } 2352 2353 /* Request IO regions */ 2354 retval = pci_request_regions(pdev, "3w-xxxx"); 2355 if (retval) { 2356 printk(KERN_WARNING "3w-xxxx: Failed to get mem region."); 2357 goto out_free_device_extension; 2358 } 2359 2360 /* Save base address */ 2361 tw_dev->base_addr = pci_resource_start(pdev, 0); 2362 if (!tw_dev->base_addr) { 2363 printk(KERN_WARNING "3w-xxxx: Failed to get io address."); 2364 goto out_release_mem_region; 2365 } 2366 2367 /* Disable interrupts on the card */ 2368 TW_DISABLE_INTERRUPTS(tw_dev); 2369 2370 /* Initialize the card */ 2371 if (tw_reset_sequence(tw_dev)) 2372 goto out_release_mem_region; 2373 2374 /* Set host specific parameters */ 2375 host->max_id = TW_MAX_UNITS; 2376 host->max_cmd_len = TW_MAX_CDB_LEN; 2377 2378 /* Luns and channels aren't supported by adapter */ 2379 host->max_lun = 0; 2380 host->max_channel = 0; 2381 2382 /* Register the card with the kernel SCSI layer */ 2383 retval = scsi_add_host(host, &pdev->dev); 2384 if (retval) { 2385 printk(KERN_WARNING "3w-xxxx: scsi add host failed"); 2386 goto out_release_mem_region; 2387 } 2388 2389 pci_set_drvdata(pdev, host); 2390 2391 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); 2392 2393 /* Now setup the interrupt handler */ 2394 retval = request_irq(pdev->irq, tw_interrupt, SA_SHIRQ, "3w-xxxx", tw_dev); 2395 if (retval) { 2396 printk(KERN_WARNING "3w-xxxx: Error requesting IRQ."); 2397 goto out_remove_host; 2398 } 2399 2400 tw_device_extension_list[tw_device_extension_count] = tw_dev; 2401 tw_device_extension_count++; 2402 2403 /* Re-enable interrupts on the card */ 2404 TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev); 2405 2406 /* Finally, scan the host */ 2407 scsi_scan_host(host); 2408 2409 if (twe_major == -1) { 2410 if ((twe_major = register_chrdev (0, "twe", &tw_fops)) < 0) 2411 printk(KERN_WARNING "3w-xxxx: Failed to register character device."); 2412 } 2413 return 0; 2414 2415 out_remove_host: 2416 scsi_remove_host(host); 2417 out_release_mem_region: 2418 pci_release_regions(pdev); 2419 out_free_device_extension: 2420 tw_free_device_extension(tw_dev); 2421 scsi_host_put(host); 2422 out_disable_device: 2423 pci_disable_device(pdev); 2424 2425 return retval; 2426 } /* End tw_probe() */ 2427 2428 /* This function is called to remove a device */ 2429 static void tw_remove(struct pci_dev *pdev) 2430 { 2431 struct Scsi_Host *host = pci_get_drvdata(pdev); 2432 TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata; 2433 2434 scsi_remove_host(tw_dev->host); 2435 2436 /* Unregister character device */ 2437 if (twe_major >= 0) { 2438 unregister_chrdev(twe_major, "twe"); 2439 twe_major = -1; 2440 } 2441 2442 /* Free up the IRQ */ 2443 free_irq(tw_dev->tw_pci_dev->irq, tw_dev); 2444 2445 /* Shutdown the card */ 2446 __tw_shutdown(tw_dev); 2447 2448 /* Free up the mem region */ 2449 pci_release_regions(pdev); 2450 2451 /* Free up device extension resources */ 2452 tw_free_device_extension(tw_dev); 2453 2454 scsi_host_put(tw_dev->host); 2455 pci_disable_device(pdev); 2456 tw_device_extension_count--; 2457 } /* End tw_remove() */ 2458 2459 /* PCI Devices supported by this driver */ 2460 static struct pci_device_id tw_pci_tbl[] __devinitdata = { 2461 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_1000, 2462 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2463 { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_7000, 2464 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0}, 2465 { } 2466 }; 2467 MODULE_DEVICE_TABLE(pci, tw_pci_tbl); 2468 2469 /* pci_driver initializer */ 2470 static struct pci_driver tw_driver = { 2471 .name = "3w-xxxx", 2472 .id_table = tw_pci_tbl, 2473 .probe = tw_probe, 2474 .remove = tw_remove, 2475 .shutdown = tw_shutdown, 2476 }; 2477 2478 /* This function is called on driver initialization */ 2479 static int __init tw_init(void) 2480 { 2481 printk(KERN_WARNING "3ware Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION); 2482 2483 return pci_module_init(&tw_driver); 2484 } /* End tw_init() */ 2485 2486 /* This function is called on driver exit */ 2487 static void __exit tw_exit(void) 2488 { 2489 pci_unregister_driver(&tw_driver); 2490 } /* End tw_exit() */ 2491 2492 module_init(tw_init); 2493 module_exit(tw_exit); 2494 2495