drivers/scsi/3w-xxxx.c

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