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