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