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