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