drivers/scsi/3w-xxxx.c

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