drivers/scsi/3w-xxxx.c

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