drivers/scsi/3w-xxxx.c

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