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 /* This function is called by the isr to complete an inquiry command */
1503 static int tw_scsiop_inquiry_complete(TW_Device_Extension *tw_dev, int request_id)
1504 {
1505         unsigned char *is_unit_present;
1506         unsigned char *request_buffer;
1507         TW_Param *param;
1508
1509         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry_complete()\n");
1510
1511         /* Fill request buffer */
1512         if (tw_dev->srb[request_id]->request_buffer == NULL) {
1513                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Request buffer NULL.\n");
1514                 return 1;
1515         }
1516         request_buffer = tw_dev->srb[request_id]->request_buffer;
1517         memset(request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
1518         request_buffer[0] = TYPE_DISK; /* Peripheral device type */
1519         request_buffer[1] = 0;         /* Device type modifier */
1520         request_buffer[2] = 0;         /* No ansi/iso compliance */
1521         request_buffer[4] = 31;        /* Additional length */
1522         memcpy(&request_buffer[8], "3ware   ", 8);       /* Vendor ID */
1523         sprintf(&request_buffer[16], "Logical Disk %-2d ", tw_dev->srb[request_id]->device->id);
1524         memcpy(&request_buffer[32], TW_DRIVER_VERSION, 3);
1525
1526         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1527         if (param == NULL) {
1528                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Bad alignment virtual address.\n");
1529                 return 1;
1530         }
1531         is_unit_present = &(param->data[0]);
1532
1533         if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
1534                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1;
1535         } else {
1536                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0;
1537                 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
1538                 return TW_ISR_DONT_RESULT;
1539         }
1540
1541         return 0;
1542 } /* End tw_scsiop_inquiry_complete() */
1543
1544 /* This function handles scsi mode_sense commands */
1545 static int tw_scsiop_mode_sense(TW_Device_Extension *tw_dev, int request_id)
1546 {
1547         TW_Param *param;
1548         TW_Command *command_packet;
1549         unsigned long command_que_value;
1550         unsigned long param_value;
1551
1552         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense()\n");
1553
1554         /* Only page control = 0, page code = 0x8 (cache page) supported */
1555         if (tw_dev->srb[request_id]->cmnd[2] != 0x8) {
1556                 tw_dev->state[request_id] = TW_S_COMPLETED;
1557                 tw_state_request_finish(tw_dev, request_id);
1558                 tw_dev->srb[request_id]->result = (DID_OK << 16);
1559                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1560                 return 0;
1561         }
1562
1563         /* Now read firmware cache setting for this unit */
1564         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1565         if (command_packet == NULL) {
1566                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet virtual address.\n");
1567                 return 1;
1568         }
1569
1570         /* Setup the command packet */
1571         memset(command_packet, 0, sizeof(TW_Sector));
1572         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1573         command_packet->size = 4;
1574         command_packet->request_id = request_id;
1575         command_packet->status = 0;
1576         command_packet->flags = 0;
1577         command_packet->byte6.parameter_count = 1;
1578
1579         /* Setup the param */
1580         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1581                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment virtual address.\n");
1582                 return 1;
1583         }
1584
1585         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1586         memset(param, 0, sizeof(TW_Sector));
1587         param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + tw_dev->srb[request_id]->device->id;
1588         param->parameter_id = 7; /* unit flags */
1589         param->parameter_size_bytes = 1;
1590         param_value = tw_dev->alignment_physical_address[request_id];
1591         if (param_value == 0) {
1592                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment physical address.\n");
1593                 return 1;
1594         }
1595
1596         command_packet->byte8.param.sgl[0].address = param_value;
1597         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1598         command_que_value = tw_dev->command_packet_physical_address[request_id];
1599         if (command_que_value == 0) {
1600                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet physical address.\n");
1601                 return 1;
1602         }
1603
1604         /* Now try to post the command packet */
1605         tw_post_command_packet(tw_dev, request_id);
1606
1607         return 0;
1608 } /* End tw_scsiop_mode_sense() */
1609
1610 /* This function is called by the isr to complete a mode sense command */
1611 static int tw_scsiop_mode_sense_complete(TW_Device_Extension *tw_dev, int request_id)
1612 {
1613         TW_Param *param;
1614         unsigned char *flags;
1615         unsigned char *request_buffer;
1616
1617         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense_complete()\n");
1618
1619         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1620         if (param == NULL) {
1621                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense_complete(): Bad alignment virtual address.\n");
1622                 return 1;
1623         }
1624         flags = (char *)&(param->data[0]);
1625         request_buffer = tw_dev->srb[request_id]->buffer;
1626         memset(request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
1627
1628         request_buffer[0] = 0xf;        /* mode data length */
1629         request_buffer[1] = 0;          /* default medium type */
1630         request_buffer[2] = 0x10;       /* dpo/fua support on */
1631         request_buffer[3] = 0;          /* no block descriptors */
1632         request_buffer[4] = 0x8;        /* caching page */
1633         request_buffer[5] = 0xa;        /* page length */
1634         if (*flags & 0x1)
1635                 request_buffer[6] = 0x4;        /* WCE on */
1636         else
1637                 request_buffer[6] = 0x0;        /* WCE off */
1638
1639         return 0;
1640 } /* End tw_scsiop_mode_sense_complete() */
1641
1642 /* This function handles scsi read_capacity commands */
1643 static int tw_scsiop_read_capacity(TW_Device_Extension *tw_dev, int request_id)
1644 {
1645         TW_Param *param;
1646         TW_Command *command_packet;
1647         unsigned long command_que_value;
1648         unsigned long param_value;
1649
1650         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity()\n");
1651
1652         /* Initialize command packet */
1653         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1654
1655         if (command_packet == NULL) {
1656                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet virtual address.\n");
1657                 return 1;
1658         }
1659         memset(command_packet, 0, sizeof(TW_Sector));
1660         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1661         command_packet->size = 4;
1662         command_packet->request_id = request_id;
1663         command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id);
1664         command_packet->status = 0;
1665         command_packet->flags = 0;
1666         command_packet->byte6.block_count = 1;
1667
1668         /* Now setup the param */
1669         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1670                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment virtual address.\n");
1671                 return 1;
1672         }
1673         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1674         memset(param, 0, sizeof(TW_Sector));
1675         param->table_id = TW_UNIT_INFORMATION_TABLE_BASE +
1676         tw_dev->srb[request_id]->device->id;
1677         param->parameter_id = 4;        /* unitcapacity parameter */
1678         param->parameter_size_bytes = 4;
1679         param_value = tw_dev->alignment_physical_address[request_id];
1680         if (param_value == 0) {
1681                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment physical address.\n");
1682                 return 1;
1683         }
1684
1685         command_packet->byte8.param.sgl[0].address = param_value;
1686         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1687         command_que_value = tw_dev->command_packet_physical_address[request_id];
1688         if (command_que_value == 0) {
1689                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet physical address.\n");
1690                 return 1;
1691         }
1692
1693         /* Now try to post the command to the board */
1694         tw_post_command_packet(tw_dev, request_id);
1695
1696         return 0;
1697 } /* End tw_scsiop_read_capacity() */
1698
1699 /* This function is called by the isr to complete a readcapacity command */
1700 static int tw_scsiop_read_capacity_complete(TW_Device_Extension *tw_dev, int request_id)
1701 {
1702         unsigned char *param_data;
1703         u32 capacity;
1704         char *buff;
1705         TW_Param *param;
1706
1707         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete()\n");
1708
1709         buff = tw_dev->srb[request_id]->request_buffer;
1710         if (buff == NULL) {
1711                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Request buffer NULL.\n");
1712                 return 1;
1713         }
1714         memset(buff, 0, tw_dev->srb[request_id]->request_bufflen);
1715         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1716         if (param == NULL) {
1717                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Bad alignment virtual address.\n");
1718                 return 1;
1719         }
1720         param_data = &(param->data[0]);
1721
1722         capacity = (param_data[3] << 24) | (param_data[2] << 16) |
1723                    (param_data[1] << 8) | param_data[0];
1724
1725         /* Subtract one sector to fix get last sector ioctl */
1726         capacity -= 1;
1727
1728         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete(): Capacity = 0x%x.\n", capacity);
1729
1730         /* Number of LBA's */
1731         buff[0] = (capacity >> 24);
1732         buff[1] = (capacity >> 16) & 0xff;
1733         buff[2] = (capacity >> 8) & 0xff;
1734         buff[3] = capacity & 0xff;
1735
1736         /* Block size in bytes (512) */
1737         buff[4] = (TW_BLOCK_SIZE >> 24);
1738         buff[5] = (TW_BLOCK_SIZE >> 16) & 0xff;
1739         buff[6] = (TW_BLOCK_SIZE >> 8) & 0xff;
1740         buff[7] = TW_BLOCK_SIZE & 0xff;
1741
1742         return 0;
1743 } /* End tw_scsiop_read_capacity_complete() */
1744
1745 /* This function handles scsi read or write commands */
1746 static int tw_scsiop_read_write(TW_Device_Extension *tw_dev, int request_id)
1747 {
1748         TW_Command *command_packet;
1749         unsigned long command_que_value;
1750         u32 lba = 0x0, num_sectors = 0x0, buffaddr = 0x0;
1751         int i, use_sg;
1752         struct scsi_cmnd *srb;
1753         struct scatterlist *sglist;
1754
1755         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write()\n");
1756
1757         if (tw_dev->srb[request_id]->request_buffer == NULL) {
1758                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Request buffer NULL.\n");
1759                 return 1;
1760         }
1761         sglist = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
1762         srb = tw_dev->srb[request_id];
1763
1764         /* Initialize command packet */
1765         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1766         if (command_packet == NULL) {
1767                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): Bad command packet virtual address.\n");
1768                 return 1;
1769         }
1770
1771         if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == READ_10) {
1772                 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_READ);
1773         } else {
1774                 command_packet->opcode__sgloffset = TW_OPSGL_IN(3, TW_OP_WRITE);
1775         }
1776
1777         command_packet->size = 3;
1778         command_packet->request_id = request_id;
1779         command_packet->unit__hostid = TW_UNITHOST_IN(0, srb->device->id);
1780         command_packet->status = 0;
1781         command_packet->flags = 0;
1782
1783         if (srb->cmnd[0] == WRITE_10) {
1784                 if ((srb->cmnd[1] & 0x8) || (srb->cmnd[1] & 0x10))
1785                         command_packet->flags = 1;
1786         }
1787
1788         if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) {
1789                 lba = ((u32)srb->cmnd[1] << 16) | ((u32)srb->cmnd[2] << 8) | (u32)srb->cmnd[3];
1790                 num_sectors = (u32)srb->cmnd[4];
1791         } else {
1792                 lba = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) | ((u32)srb->cmnd[4] << 8) | (u32)srb->cmnd[5];
1793                 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1794         }
1795
1796         /* Update sector statistic */
1797         tw_dev->sector_count = num_sectors;
1798         if (tw_dev->sector_count > tw_dev->max_sector_count)
1799                 tw_dev->max_sector_count = tw_dev->sector_count;
1800
1801         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): lba = 0x%x num_sectors = 0x%x\n", lba, num_sectors);
1802         command_packet->byte8.io.lba = lba;
1803         command_packet->byte6.block_count = num_sectors;
1804
1805         /* Do this if there are no sg list entries */
1806         if (tw_dev->srb[request_id]->use_sg == 0) {
1807                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): SG = 0\n");
1808                 buffaddr = tw_map_scsi_single_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
1809                 if (buffaddr == 0)
1810                         return 1;
1811
1812                 command_packet->byte8.io.sgl[0].address = buffaddr;
1813                 command_packet->byte8.io.sgl[0].length = tw_dev->srb[request_id]->request_bufflen;
1814                 command_packet->size+=2;
1815         }
1816
1817         /* Do this if we have multiple sg list entries */
1818         if (tw_dev->srb[request_id]->use_sg > 0) {
1819                 use_sg = tw_map_scsi_sg_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
1820                 if (use_sg == 0)
1821                         return 1;
1822
1823                 for (i=0;i<use_sg; i++) {
1824                         command_packet->byte8.io.sgl[i].address = sg_dma_address(&sglist[i]);
1825                         command_packet->byte8.io.sgl[i].length = sg_dma_len(&sglist[i]);
1826                         command_packet->size+=2;
1827                 }
1828         }
1829
1830         /* Update SG statistics */
1831         tw_dev->sgl_entries = tw_dev->srb[request_id]->use_sg;
1832         if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1833                 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1834
1835         command_que_value = tw_dev->command_packet_physical_address[request_id];
1836         if (command_que_value == 0) {
1837                 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Bad command packet physical address.\n");
1838                 return 1;
1839         }
1840
1841         /* Now try to post the command to the board */
1842         tw_post_command_packet(tw_dev, request_id);
1843
1844         return 0;
1845 } /* End tw_scsiop_read_write() */
1846
1847 /* This function will handle the request sense scsi command */
1848 static int tw_scsiop_request_sense(TW_Device_Extension *tw_dev, int request_id)
1849 {
1850         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_request_sense()\n");
1851
1852         /* For now we just zero the request buffer */
1853         memset(tw_dev->srb[request_id]->request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
1854         tw_dev->state[request_id] = TW_S_COMPLETED;
1855         tw_state_request_finish(tw_dev, request_id);
1856
1857         /* If we got a request_sense, we probably want a reset, return error */
1858         tw_dev->srb[request_id]->result = (DID_ERROR << 16);
1859         tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1860
1861         return 0;
1862 } /* End tw_scsiop_request_sense() */
1863
1864 /* This function will handle synchronize cache scsi command */
1865 static int tw_scsiop_synchronize_cache(TW_Device_Extension *tw_dev, int request_id)
1866 {
1867         TW_Command *command_packet;
1868         unsigned long command_que_value;
1869
1870         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_synchronize_cache()\n");
1871
1872         /* Send firmware flush command for this unit */
1873         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1874         if (command_packet == NULL) {
1875                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet virtual address.\n");
1876                 return 1;
1877         }
1878
1879         /* Setup the command packet */
1880         memset(command_packet, 0, sizeof(TW_Sector));
1881         command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_FLUSH_CACHE);
1882         command_packet->size = 2;
1883         command_packet->request_id = request_id;
1884         command_packet->unit__hostid = TW_UNITHOST_IN(0, tw_dev->srb[request_id]->device->id);
1885         command_packet->status = 0;
1886         command_packet->flags = 0;
1887         command_packet->byte6.parameter_count = 1;
1888         command_que_value = tw_dev->command_packet_physical_address[request_id];
1889         if (command_que_value == 0) {
1890                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet physical address.\n");
1891                 return 1;
1892         }
1893
1894         /* Now try to post the command packet */
1895         tw_post_command_packet(tw_dev, request_id);
1896
1897         return 0;
1898 } /* End tw_scsiop_synchronize_cache() */
1899
1900 /* This function will handle test unit ready scsi command */
1901 static int tw_scsiop_test_unit_ready(TW_Device_Extension *tw_dev, int request_id)
1902 {
1903         TW_Param *param;
1904         TW_Command *command_packet;
1905         unsigned long command_que_value;
1906         unsigned long param_value;
1907
1908         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_test_unit_ready()\n");
1909
1910         /* Initialize command packet */
1911         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1912         if (command_packet == NULL) {
1913                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet virtual address.\n");
1914                 return 1;
1915         }
1916         memset(command_packet, 0, sizeof(TW_Sector));
1917         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1918         command_packet->size = 4;
1919         command_packet->request_id = request_id;
1920         command_packet->status = 0;
1921         command_packet->flags = 0;
1922         command_packet->byte6.parameter_count = 1;
1923
1924         /* Now setup the param */
1925         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1926                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment virtual address.\n");
1927                 return 1;
1928         }
1929         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1930         memset(param, 0, sizeof(TW_Sector));
1931         param->table_id = 3;     /* unit summary table */
1932         param->parameter_id = 3; /* unitsstatus parameter */
1933         param->parameter_size_bytes = TW_MAX_UNITS;
1934         param_value = tw_dev->alignment_physical_address[request_id];
1935         if (param_value == 0) {
1936                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment physical address.\n");
1937                 return 1;
1938         }
1939
1940         command_packet->byte8.param.sgl[0].address = param_value;
1941         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1942         command_que_value = tw_dev->command_packet_physical_address[request_id];
1943         if (command_que_value == 0) {
1944                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet physical address.\n");
1945                 return 1;
1946         }
1947
1948         /* Now try to post the command packet */
1949         tw_post_command_packet(tw_dev, request_id);
1950
1951         return 0;
1952 } /* End tw_scsiop_test_unit_ready() */
1953
1954 /* This function is called by the isr to complete a testunitready command */
1955 static int tw_scsiop_test_unit_ready_complete(TW_Device_Extension *tw_dev, int request_id)
1956 {
1957         unsigned char *is_unit_present;
1958         TW_Param *param;
1959
1960         dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete()\n");
1961
1962         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1963         if (param == NULL) {
1964                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete(): Bad alignment virtual address.\n");
1965                 return 1;
1966         }
1967         is_unit_present = &(param->data[0]);
1968
1969         if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
1970                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 1;
1971         } else {
1972                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = 0;
1973                 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
1974                 return TW_ISR_DONT_RESULT;
1975         }
1976
1977         return 0;
1978 } /* End tw_scsiop_test_unit_ready_complete() */
1979
1980 /* This is the main scsi queue function to handle scsi opcodes */
1981 static int tw_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1982 {
1983         unsigned char *command = SCpnt->cmnd;
1984         int request_id = 0;
1985         int retval = 1;
1986         TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1987
1988         /* Save done function into Scsi_Cmnd struct */
1989         SCpnt->scsi_done = done;
1990
1991         /* Queue the command and get a request id */
1992         tw_state_request_start(tw_dev, &request_id);
1993
1994         /* Save the scsi command for use by the ISR */
1995         tw_dev->srb[request_id] = SCpnt;
1996
1997         /* Initialize phase to zero */
1998         SCpnt->SCp.phase = TW_PHASE_INITIAL;
1999
2000         switch (*command) {
2001                 case READ_10:
2002                 case READ_6:
2003                 case WRITE_10:
2004                 case WRITE_6:
2005                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ/WRITE.\n");
2006                         retval = tw_scsiop_read_write(tw_dev, request_id);
2007                         break;
2008                 case TEST_UNIT_READY:
2009                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TEST_UNIT_READY.\n");
2010                         retval = tw_scsiop_test_unit_ready(tw_dev, request_id);
2011                         break;
2012                 case INQUIRY:
2013                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught INQUIRY.\n");
2014                         retval = tw_scsiop_inquiry(tw_dev, request_id);
2015                         break;
2016                 case READ_CAPACITY:
2017                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ_CAPACITY.\n");
2018                         retval = tw_scsiop_read_capacity(tw_dev, request_id);
2019                         break;
2020                 case REQUEST_SENSE:
2021                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught REQUEST_SENSE.\n");
2022                         retval = tw_scsiop_request_sense(tw_dev, request_id);
2023                         break;
2024                 case MODE_SENSE:
2025                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught MODE_SENSE.\n");
2026                         retval = tw_scsiop_mode_sense(tw_dev, request_id);
2027                         break;
2028                 case SYNCHRONIZE_CACHE:
2029                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught SYNCHRONIZE_CACHE.\n");
2030                         retval = tw_scsiop_synchronize_cache(tw_dev, request_id);
2031                         break;
2032                 case TW_IOCTL:
2033                         printk(KERN_WARNING "3w-xxxx: SCSI_IOCTL_SEND_COMMAND deprecated, please update your 3ware tools.\n");
2034                         break;
2035                 default:
2036                         printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command);
2037                         tw_dev->state[request_id] = TW_S_COMPLETED;
2038                         tw_state_request_finish(tw_dev, request_id);
2039                         SCpnt->result = (DID_BAD_TARGET << 16);
2040                         done(SCpnt);
2041                         retval = 0;
2042         }
2043         if (retval) {
2044                 tw_dev->state[request_id] = TW_S_COMPLETED;
2045                 tw_state_request_finish(tw_dev, request_id);
2046                 SCpnt->result = (DID_ERROR << 16);
2047                 done(SCpnt);
2048                 retval = 0;
2049         }
2050         return retval;
2051 } /* End tw_scsi_queue() */
2052
2053 /* This function is the interrupt service routine */
2054 static irqreturn_t tw_interrupt(int irq, void *dev_instance,
2055                      struct pt_regs *regs)
2056 {
2057         int request_id;
2058         u32 status_reg_value;
2059         TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
2060         TW_Response_Queue response_que;
2061         int error = 0, retval = 0;
2062         TW_Command *command_packet;
2063         int handled = 0;
2064
2065         /* Get the host lock for io completions */
2066         spin_lock(tw_dev->host->host_lock);
2067
2068         /* Read the registers */
2069         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2070
2071         /* Check if this is our interrupt, otherwise bail */
2072         if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
2073                 goto tw_interrupt_bail;
2074
2075         handled = 1;
2076
2077         /* Check controller for errors */
2078         if (tw_check_bits(status_reg_value)) {
2079                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2080                 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2081                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2082                         goto tw_interrupt_bail;
2083                 }
2084         }
2085
2086         /* Handle host interrupt */
2087         if (status_reg_value & TW_STATUS_HOST_INTERRUPT) {
2088                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received host interrupt.\n");
2089                 TW_CLEAR_HOST_INTERRUPT(tw_dev);
2090         }
2091
2092         /* Handle attention interrupt */
2093         if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
2094                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received attention interrupt.\n");
2095                 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
2096                 tw_state_request_start(tw_dev, &request_id);
2097                 error = tw_aen_read_queue(tw_dev, request_id);
2098                 if (error) {
2099                         printk(KERN_WARNING "3w-xxxx: scsi%d: Error reading aen queue.\n", tw_dev->host->host_no);
2100                         tw_dev->state[request_id] = TW_S_COMPLETED;
2101                         tw_state_request_finish(tw_dev, request_id);
2102                 }
2103         }
2104
2105         /* Handle command interrupt */
2106         if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
2107                 /* Drain as many pending commands as we can */
2108                 while (tw_dev->pending_request_count > 0) {
2109                         request_id = tw_dev->pending_queue[tw_dev->pending_head];
2110                         if (tw_dev->state[request_id] != TW_S_PENDING) {
2111                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Found request id that wasn't pending.\n", tw_dev->host->host_no);
2112                                 break;
2113                         }
2114                         if (tw_post_command_packet(tw_dev, request_id)==0) {
2115                                 if (tw_dev->pending_head == TW_Q_LENGTH-1) {
2116                                         tw_dev->pending_head = TW_Q_START;
2117                                 } else {
2118                                         tw_dev->pending_head = tw_dev->pending_head + 1;
2119                                 }
2120                                 tw_dev->pending_request_count--;
2121                         } else {
2122                                 /* If we get here, we will continue re-posting on the next command interrupt */
2123                                 break;
2124                         }
2125                 }
2126                 /* If there are no more pending requests, we mask command interrupt */
2127                 if (tw_dev->pending_request_count == 0)
2128                         TW_MASK_COMMAND_INTERRUPT(tw_dev);
2129         }
2130
2131         /* Handle response interrupt */
2132         if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
2133                 /* Drain the response queue from the board */
2134                 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
2135                         /* Read response queue register */
2136                         response_que.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
2137                         request_id = TW_RESID_OUT(response_que.response_id);
2138                         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2139                         error = 0;
2140
2141                         /* Check for bad response */
2142                         if (command_packet->status != 0) {
2143                                 /* If internal command, don't error, don't fill sense */
2144                                 if (tw_dev->srb[request_id] == NULL) {
2145                                         tw_decode_sense(tw_dev, request_id, 0);
2146                                 } else {
2147                                         error = tw_decode_sense(tw_dev, request_id, 1);
2148                                 }
2149                         }
2150
2151                         /* Check for correct state */
2152                         if (tw_dev->state[request_id] != TW_S_POSTED) {
2153                                 if (tw_dev->srb[request_id] != NULL) {
2154                                         printk(KERN_WARNING "3w-xxxx: scsi%d: Received a request id that wasn't posted.\n", tw_dev->host->host_no);
2155                                         error = 1;
2156                                 }
2157                         }
2158
2159                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Response queue request id: %d.\n", request_id);
2160
2161                         /* Check for internal command completion */
2162                         if (tw_dev->srb[request_id] == NULL) {
2163                                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Found internally posted command.\n");
2164                                 /* Check for chrdev ioctl completion */
2165                                 if (request_id != tw_dev->chrdev_request_id) {
2166                                         retval = tw_aen_complete(tw_dev, request_id);
2167                                         if (retval) {
2168                                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing aen.\n", tw_dev->host->host_no);
2169                                         }
2170                                 } else {
2171                                         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
2172                                         wake_up(&tw_dev->ioctl_wqueue);
2173                                 }
2174                         } else {
2175                                 switch (tw_dev->srb[request_id]->cmnd[0]) {
2176                                 case READ_10:
2177                                 case READ_6:
2178                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_10/READ_6\n");
2179                                         break;
2180                                 case WRITE_10:
2181                                 case WRITE_6:
2182                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught WRITE_10/WRITE_6\n");
2183                                         break;
2184                                 case TEST_UNIT_READY:
2185                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TEST_UNIT_READY\n");
2186                                         error = tw_scsiop_test_unit_ready_complete(tw_dev, request_id);
2187                                         break;
2188                                 case INQUIRY:
2189                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught INQUIRY\n");
2190                                         error = tw_scsiop_inquiry_complete(tw_dev, request_id);
2191                                         break;
2192                                 case READ_CAPACITY:
2193                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_CAPACITY\n");
2194                                         error = tw_scsiop_read_capacity_complete(tw_dev, request_id);
2195                                         break;
2196                                 case MODE_SENSE:
2197                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught MODE_SENSE\n");
2198                                         error = tw_scsiop_mode_sense_complete(tw_dev, request_id);
2199                                         break;
2200                                 case SYNCHRONIZE_CACHE:
2201                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught SYNCHRONIZE_CACHE\n");
2202                                         break;
2203                                 default:
2204                                         printk(KERN_WARNING "3w-xxxx: case slip in tw_interrupt()\n");
2205                                         error = 1;
2206                                 }
2207
2208                                 /* If no error command was a success */
2209                                 if (error == 0) {
2210                                         tw_dev->srb[request_id]->result = (DID_OK << 16);
2211                                 }
2212
2213                                 /* If error, command failed */
2214                                 if (error == 1) {
2215                                         /* Ask for a host reset */
2216                                         tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
2217                                 }
2218
2219                                 /* Now complete the io */
2220                                 if ((error != TW_ISR_DONT_COMPLETE)) {
2221                                         tw_dev->state[request_id] = TW_S_COMPLETED;
2222                                         tw_state_request_finish(tw_dev, request_id);
2223                                         tw_dev->posted_request_count--;
2224                                         tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2225
2226                                         tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
2227                                 }
2228                         }
2229
2230                         /* Check for valid status after each drain */
2231                         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2232                         if (tw_check_bits(status_reg_value)) {
2233                                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2234                                 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2235                                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2236                                         goto tw_interrupt_bail;
2237                                 }
2238                         }
2239                 }
2240         }
2241
2242 tw_interrupt_bail:
2243         spin_unlock(tw_dev->host->host_lock);
2244         return IRQ_RETVAL(handled);
2245 } /* End tw_interrupt() */
2246
2247 /* This function tells the controller to shut down */
2248 static void __tw_shutdown(TW_Device_Extension *tw_dev)
2249 {
2250         /* Disable interrupts */
2251         TW_DISABLE_INTERRUPTS(tw_dev);
2252
2253         printk(KERN_WARNING "3w-xxxx: Shutting down host %d.\n", tw_dev->host->host_no);
2254
2255         /* Tell the card we are shutting down */
2256         if (tw_initconnection(tw_dev, 1)) {
2257                 printk(KERN_WARNING "3w-xxxx: Connection shutdown failed.\n");
2258         } else {
2259                 printk(KERN_WARNING "3w-xxxx: Shutdown complete.\n");
2260         }
2261
2262         /* Clear all interrupts just before exit */
2263         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2264 } /* End __tw_shutdown() */
2265
2266 /* Wrapper for __tw_shutdown */
2267 static void tw_shutdown(struct device *dev)
2268 {
2269         struct Scsi_Host *host = pci_get_drvdata(to_pci_dev(dev));
2270         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2271
2272         __tw_shutdown(tw_dev);
2273 } /* End tw_shutdown() */
2274
2275 static struct scsi_host_template driver_template = {
2276         .module                 = THIS_MODULE,
2277         .name                   = "3ware Storage Controller",
2278         .queuecommand           = tw_scsi_queue,
2279         .eh_host_reset_handler  = tw_scsi_eh_reset,
2280         .bios_param             = tw_scsi_biosparam,
2281         .change_queue_depth     = tw_change_queue_depth,
2282         .can_queue              = TW_Q_LENGTH-2,
2283         .this_id                = -1,
2284         .sg_tablesize           = TW_MAX_SGL_LENGTH,
2285         .max_sectors            = TW_MAX_SECTORS,
2286         .cmd_per_lun            = TW_MAX_CMDS_PER_LUN,
2287         .use_clustering         = ENABLE_CLUSTERING,
2288         .shost_attrs            = tw_host_attrs,
2289         .emulated               = 1
2290 };
2291
2292 /* This function will probe and initialize a card */
2293 static int __devinit tw_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2294 {
2295         struct Scsi_Host *host = NULL;
2296         TW_Device_Extension *tw_dev;
2297         int retval = -ENODEV;
2298
2299         retval = pci_enable_device(pdev);
2300         if (retval) {
2301                 printk(KERN_WARNING "3w-xxxx: Failed to enable pci device.");
2302                 goto out_disable_device;
2303         }
2304
2305         pci_set_master(pdev);
2306
2307         retval = pci_set_dma_mask(pdev, TW_DMA_MASK);
2308         if (retval) {
2309                 printk(KERN_WARNING "3w-xxxx: Failed to set dma mask.");
2310                 goto out_disable_device;
2311         }
2312
2313         host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2314         if (!host) {
2315                 printk(KERN_WARNING "3w-xxxx: Failed to allocate memory for device extension.");
2316                 retval = -ENOMEM;
2317                 goto out_disable_device;
2318         }
2319         tw_dev = (TW_Device_Extension *)host->hostdata;
2320
2321         memset(tw_dev, 0, sizeof(TW_Device_Extension));
2322
2323         /* Save values to device extension */
2324         tw_dev->host = host;
2325         tw_dev->tw_pci_dev = pdev;
2326
2327         if (tw_initialize_device_extension(tw_dev)) {
2328                 printk(KERN_WARNING "3w-xxxx: Failed to initialize device extension.");
2329                 goto out_free_device_extension;
2330         }
2331
2332         /* Request IO regions */
2333         retval = pci_request_regions(pdev, "3w-xxxx");
2334         if (retval) {
2335                 printk(KERN_WARNING "3w-xxxx: Failed to get mem region.");
2336                 goto out_free_device_extension;
2337         }
2338
2339         /* Save base address */
2340         tw_dev->base_addr = pci_resource_start(pdev, 0);
2341         if (!tw_dev->base_addr) {
2342                 printk(KERN_WARNING "3w-xxxx: Failed to get io address.");
2343                 goto out_release_mem_region;
2344         }
2345
2346         /* Disable interrupts on the card */
2347         TW_DISABLE_INTERRUPTS(tw_dev);
2348
2349         /* Initialize the card */
2350         if (tw_reset_sequence(tw_dev))
2351                 goto out_release_mem_region;
2352
2353         /* Set host specific parameters */
2354         host->max_id = TW_MAX_UNITS;
2355         host->max_cmd_len = TW_MAX_CDB_LEN;
2356
2357         /* Luns and channels aren't supported by adapter */
2358         host->max_lun = 0;
2359         host->max_channel = 0;
2360
2361         /* Register the card with the kernel SCSI layer */
2362         retval = scsi_add_host(host, &pdev->dev);
2363         if (retval) {
2364                 printk(KERN_WARNING "3w-xxxx: scsi add host failed");
2365                 goto out_release_mem_region;
2366         }
2367
2368         pci_set_drvdata(pdev, host);
2369
2370         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);
2371
2372         /* Now setup the interrupt handler */
2373         retval = request_irq(pdev->irq, tw_interrupt, SA_SHIRQ, "3w-xxxx", tw_dev);
2374         if (retval) {
2375                 printk(KERN_WARNING "3w-xxxx: Error requesting IRQ.");
2376                 goto out_remove_host;
2377         }
2378
2379         tw_device_extension_list[tw_device_extension_count] = tw_dev;
2380         tw_device_extension_count++;
2381
2382         /* Re-enable interrupts on the card */
2383         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2384
2385         /* Finally, scan the host */
2386         scsi_scan_host(host);
2387
2388         if (twe_major == -1) {
2389                 if ((twe_major = register_chrdev (0, "twe", &tw_fops)) < 0)
2390                         printk(KERN_WARNING "3w-xxxx: Failed to register character device.");
2391         }
2392         return 0;
2393
2394 out_remove_host:
2395         scsi_remove_host(host);
2396 out_release_mem_region:
2397         pci_release_regions(pdev);
2398 out_free_device_extension:
2399         tw_free_device_extension(tw_dev);
2400         scsi_host_put(host);
2401 out_disable_device:
2402         pci_disable_device(pdev);
2403
2404         return retval;
2405 } /* End tw_probe() */
2406
2407 /* This function is called to remove a device */
2408 static void tw_remove(struct pci_dev *pdev)
2409 {
2410         struct Scsi_Host *host = pci_get_drvdata(pdev);
2411         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2412
2413         scsi_remove_host(tw_dev->host);
2414
2415         /* Unregister character device */
2416         if (twe_major >= 0) {
2417                 unregister_chrdev(twe_major, "twe");
2418                 twe_major = -1;
2419         }
2420
2421         /* Free up the IRQ */
2422         free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2423
2424         /* Shutdown the card */
2425         __tw_shutdown(tw_dev);
2426
2427         /* Free up the mem region */
2428         pci_release_regions(pdev);
2429
2430         /* Free up device extension resources */
2431         tw_free_device_extension(tw_dev);
2432
2433         scsi_host_put(tw_dev->host);
2434         pci_disable_device(pdev);
2435         tw_device_extension_count--;
2436 } /* End tw_remove() */
2437
2438 /* PCI Devices supported by this driver */
2439 static struct pci_device_id tw_pci_tbl[] __devinitdata = {
2440         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_1000,
2441           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2442         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_7000,
2443           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2444         { }
2445 };
2446 MODULE_DEVICE_TABLE(pci, tw_pci_tbl);
2447
2448 /* pci_driver initializer */
2449 static struct pci_driver tw_driver = {
2450         .name           = "3w-xxxx",
2451         .id_table       = tw_pci_tbl,
2452         .probe          = tw_probe,
2453         .remove         = tw_remove,
2454         .driver         = {
2455                 .shutdown = tw_shutdown
2456         }
2457 };
2458
2459 /* This function is called on driver initialization */
2460 static int __init tw_init(void)
2461 {
2462         printk(KERN_WARNING "3ware Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2463
2464         return pci_module_init(&tw_driver);
2465 } /* End tw_init() */
2466
2467 /* This function is called on driver exit */
2468 static void __exit tw_exit(void)
2469 {
2470         pci_unregister_driver(&tw_driver);
2471 } /* End tw_exit() */
2472
2473 module_init(tw_init);
2474 module_exit(tw_exit);
2475