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