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