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) | SAM_STAT_CHECK_CONDITION;
 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;
 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                 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 attribute *tw_host_attrs[] = {
 536         &tw_host_stats_attr.attr,
 537         NULL,
 538 };
 539
 540 ATTRIBUTE_GROUPS(tw_host);
 541
 542 /* This function will read the aen queue from the isr */
 543 static int tw_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
 544 {
 545         TW_Command *command_packet;
 546         TW_Param *param;
 547         unsigned long command_que_value;
 548         u32 status_reg_value;
 549         unsigned long param_value = 0;
 550
 551         dprintk(KERN_NOTICE "3w-xxxx: tw_aen_read_queue()\n");
 552
 553         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
 554         if (tw_check_bits(status_reg_value)) {
 555                 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Unexpected bits.\n");
 556                 tw_decode_bits(tw_dev, status_reg_value, 1);
 557                 return 1;
 558         }
 559         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
 560                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet virtual address.\n");
 561                 return 1;
 562         }
 563         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
 564         memset(command_packet, 0, sizeof(TW_Sector));
 565         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
 566         command_packet->size = 4;
 567         command_packet->request_id = request_id;
 568         command_packet->status = 0;
 569         command_packet->flags = 0;
 570         command_packet->byte6.parameter_count = 1;
 571         command_que_value = tw_dev->command_packet_physical_address[request_id];
 572         if (command_que_value == 0) {
 573                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet physical address.\n");
 574                 return 1;
 575         }
 576         /* Now setup the param */
 577         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
 578                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment virtual address.\n");
 579                 return 1;
 580         }
 581         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
 582         memset(param, 0, sizeof(TW_Sector));
 583         param->table_id = 0x401; /* AEN table */
 584         param->parameter_id = 2; /* Unit code */
 585         param->parameter_size_bytes = 2;
 586         param_value = tw_dev->alignment_physical_address[request_id];
 587         if (param_value == 0) {
 588                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment physical address.\n");
 589                 return 1;
 590         }
 591         command_packet->byte8.param.sgl[0].address = param_value;
 592         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
 593
 594         /* Now post the command packet */
 595         if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) {
 596                 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post succeeded.\n");
 597                 tw_dev->srb[request_id] = NULL; /* Flag internal command */
 598                 tw_dev->state[request_id] = TW_S_POSTED;
 599                 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
 600         } else {
 601                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post failed, will retry.\n");
 602                 return 1;
 603         }
 604
 605         return 0;
 606 } /* End tw_aen_read_queue() */
 607
 608 /* This function will complete an aen request from the isr */
 609 static int tw_aen_complete(TW_Device_Extension *tw_dev, int request_id)
 610 {
 611         TW_Param *param;
 612         unsigned short aen;
 613         int error = 0, table_max = 0;
 614
 615         dprintk(KERN_WARNING "3w-xxxx: tw_aen_complete()\n");
 616         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
 617                 printk(KERN_WARNING "3w-xxxx: tw_aen_complete(): Bad alignment virtual address.\n");
 618                 return 1;
 619         }
 620         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
 621         aen = *(unsigned short *)(param->data);
 622         dprintk(KERN_NOTICE "3w-xxxx: tw_aen_complete(): Queue'd code 0x%x\n", aen);
 623
 624         /* Print some useful info when certain aen codes come out */
 625         if (aen == 0x0ff) {
 626                 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: INFO: AEN queue overflow.\n", tw_dev->host->host_no);
 627         } else {
 628                 table_max = ARRAY_SIZE(tw_aen_string);
 629                 if ((aen & 0x0ff) < table_max) {
 630                         if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
 631                                 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s%d.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff], aen >> 8);
 632                         } else {
 633                                 if (aen != 0x0)
 634                                         printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff]);
 635                         }
 636                 } else {
 637                         printk(KERN_WARNING "3w-xxxx: scsi%d: Received AEN %d.\n", tw_dev->host->host_no, aen);
 638                 }
 639         }
 640         if (aen != TW_AEN_QUEUE_EMPTY) {
 641                 tw_dev->aen_count++;
 642
 643                 /* Now queue the code */
 644                 tw_dev->aen_queue[tw_dev->aen_tail] = aen;
 645                 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
 646                         tw_dev->aen_tail = TW_Q_START;
 647                 } else {
 648                         tw_dev->aen_tail = tw_dev->aen_tail + 1;
 649                 }
 650                 if (tw_dev->aen_head == tw_dev->aen_tail) {
 651                         if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
 652                                 tw_dev->aen_head = TW_Q_START;
 653                         } else {
 654                                 tw_dev->aen_head = tw_dev->aen_head + 1;
 655                         }
 656                 }
 657
 658                 error = tw_aen_read_queue(tw_dev, request_id);
 659                 if (error) {
 660                         printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing AEN.\n", tw_dev->host->host_no);
 661                         tw_dev->state[request_id] = TW_S_COMPLETED;
 662                         tw_state_request_finish(tw_dev, request_id);
 663                 }
 664         } else {
 665                 tw_dev->state[request_id] = TW_S_COMPLETED;
 666                 tw_state_request_finish(tw_dev, request_id);
 667         }
 668
 669         return 0;
 670 } /* End tw_aen_complete() */
 671
 672 /* This function will drain the aen queue after a soft reset */
 673 static int tw_aen_drain_queue(TW_Device_Extension *tw_dev)
 674 {
 675         TW_Command *command_packet;
 676         TW_Param *param;
 677         int request_id = 0;
 678         unsigned long command_que_value;
 679         unsigned long param_value;
 680         TW_Response_Queue response_queue;
 681         unsigned short aen;
 682         unsigned short aen_code;
 683         int finished = 0;
 684         int first_reset = 0;
 685         int queue = 0;
 686         int found = 0, table_max = 0;
 687
 688         dprintk(KERN_NOTICE "3w-xxxx: tw_aen_drain_queue()\n");
 689
 690         if (tw_poll_status(tw_dev, TW_STATUS_ATTENTION_INTERRUPT | TW_STATUS_MICROCONTROLLER_READY, 30)) {
 691                 dprintk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): No attention interrupt for card %d.\n", tw_device_extension_count);
 692                 return 1;
 693         }
 694         TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
 695
 696         /* Empty response queue */
 697         tw_empty_response_que(tw_dev);
 698
 699         /* Initialize command packet */
 700         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
 701                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet virtual address.\n");
 702                 return 1;
 703         }
 704         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
 705         memset(command_packet, 0, sizeof(TW_Sector));
 706         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
 707         command_packet->size = 4;
 708         command_packet->request_id = request_id;
 709         command_packet->status = 0;
 710         command_packet->flags = 0;
 711         command_packet->byte6.parameter_count = 1;
 712         command_que_value = tw_dev->command_packet_physical_address[request_id];
 713         if (command_que_value == 0) {
 714                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet physical address.\n");
 715                 return 1;
 716         }
 717
 718         /* Now setup the param */
 719         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
 720                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment virtual address.\n");
 721                 return 1;
 722         }
 723         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
 724         memset(param, 0, sizeof(TW_Sector));
 725         param->table_id = 0x401; /* AEN table */
 726         param->parameter_id = 2; /* Unit code */
 727         param->parameter_size_bytes = 2;
 728         param_value = tw_dev->alignment_physical_address[request_id];
 729         if (param_value == 0) {
 730                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment physical address.\n");
 731                 return 1;
 732         }
 733         command_packet->byte8.param.sgl[0].address = param_value;
 734         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
 735
 736         /* Now drain the controller's aen queue */
 737         do {
 738                 /* Post command packet */
 739                 outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
 740
 741                 /* Now poll for completion */
 742                 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
 743                         response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
 744                         request_id = TW_RESID_OUT(response_queue.response_id);
 745
 746                         if (request_id != 0) {
 747                                 /* Unexpected request id */
 748                                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Unexpected request id.\n");
 749                                 return 1;
 750                         }
 751
 752                         if (command_packet->status != 0) {
 753                                 if (command_packet->flags != TW_AEN_TABLE_UNDEFINED) {
 754                                         /* Bad response */
 755                                         tw_decode_sense(tw_dev, request_id, 0);
 756                                         return 1;
 757                                 } else {
 758                                         /* We know this is a 3w-1x00, and doesn't support aen's */
 759                                         return 0;
 760                                 }
 761                         }
 762
 763                         /* Now check the aen */
 764                         aen = *(unsigned short *)(param->data);
 765                         aen_code = (aen & 0x0ff);
 766                         queue = 0;
 767                         switch (aen_code) {
 768                                 case TW_AEN_QUEUE_EMPTY:
 769                                         dprintk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
 770                                         if (first_reset != 1) {
 771                                                 return 1;
 772                                         } else {
 773                                                 finished = 1;
 774                                         }
 775                                         break;
 776                                 case TW_AEN_SOFT_RESET:
 777                                         if (first_reset == 0) {
 778                                                 first_reset = 1;
 779                                         } else {
 780                                                 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
 781                                                 tw_dev->aen_count++;
 782                                                 queue = 1;
 783                                         }
 784                                         break;
 785                                 default:
 786                                         if (aen == 0x0ff) {
 787                                                 printk(KERN_WARNING "3w-xxxx: AEN: INFO: AEN queue overflow.\n");
 788                                         } else {
 789                                                 table_max = ARRAY_SIZE(tw_aen_string);
 790                                                 if ((aen & 0x0ff) < table_max) {
 791                                                         if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
 792                                                                 printk(KERN_WARNING "3w-xxxx: AEN: %s%d.\n", tw_aen_string[aen & 0xff], aen >> 8);
 793                                                         } else {
 794                                                                 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
 795                                                         }
 796                                                 } else
 797                                                         printk(KERN_WARNING "3w-xxxx: Received AEN %d.\n", aen);
 798                                         }
 799                                         tw_dev->aen_count++;
 800                                         queue = 1;
 801                         }
 802
 803                         /* Now put the aen on the aen_queue */
 804                         if (queue == 1) {
 805                                 tw_dev->aen_queue[tw_dev->aen_tail] = aen;
 806                                 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
 807                                         tw_dev->aen_tail = TW_Q_START;
 808                                 } else {
 809                                         tw_dev->aen_tail = tw_dev->aen_tail + 1;
 810                                 }
 811                                 if (tw_dev->aen_head == tw_dev->aen_tail) {
 812                                         if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
 813                                                 tw_dev->aen_head = TW_Q_START;
 814                                         } else {
 815                                                 tw_dev->aen_head = tw_dev->aen_head + 1;
 816                                         }
 817                                 }
 818                         }
 819                         found = 1;
 820                 }
 821                 if (found == 0) {
 822                         printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Response never received.\n");
 823                         return 1;
 824                 }
 825         } while (finished == 0);
 826
 827         return 0;
 828 } /* End tw_aen_drain_queue() */
 829
 830 /* This function will allocate memory */
 831 static int tw_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
 832 {
 833         int i;
 834         dma_addr_t dma_handle;
 835         unsigned long *cpu_addr = NULL;
 836
 837         dprintk(KERN_NOTICE "3w-xxxx: tw_allocate_memory()\n");
 838
 839         cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev,
 840                         size * TW_Q_LENGTH, &dma_handle, GFP_KERNEL);
 841         if (cpu_addr == NULL) {
 842                 printk(KERN_WARNING "3w-xxxx: dma_alloc_coherent() failed.\n");
 843                 return 1;
 844         }
 845
 846         if ((unsigned long)cpu_addr % (tw_dev->tw_pci_dev->device == TW_DEVICE_ID ? TW_ALIGNMENT_6000 : TW_ALIGNMENT_7000)) {
 847                 printk(KERN_WARNING "3w-xxxx: Couldn't allocate correctly aligned memory.\n");
 848                 dma_free_coherent(&tw_dev->tw_pci_dev->dev, size * TW_Q_LENGTH,
 849                                 cpu_addr, dma_handle);
 850                 return 1;
 851         }
 852
 853         memset(cpu_addr, 0, size*TW_Q_LENGTH);
 854
 855         for (i=0;i<TW_Q_LENGTH;i++) {
 856                 switch(which) {
 857                 case 0:
 858                         tw_dev->command_packet_physical_address[i] = dma_handle+(i*size);
 859                         tw_dev->command_packet_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
 860                         break;
 861                 case 1:
 862                         tw_dev->alignment_physical_address[i] = dma_handle+(i*size);
 863                         tw_dev->alignment_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
 864                         break;
 865                 default:
 866                         printk(KERN_WARNING "3w-xxxx: tw_allocate_memory(): case slip in tw_allocate_memory()\n");
 867                         return 1;
 868                 }
 869         }
 870
 871         return 0;
 872 } /* End tw_allocate_memory() */
 873
 874 /* This function handles ioctl for the character device */
 875 static long tw_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 876 {
 877         int request_id;
 878         dma_addr_t dma_handle;
 879         unsigned short tw_aen_code;
 880         unsigned long flags;
 881         unsigned int data_buffer_length = 0;
 882         unsigned long data_buffer_length_adjusted = 0;
 883         struct inode *inode = file_inode(file);
 884         unsigned long *cpu_addr;
 885         long timeout;
 886         TW_New_Ioctl *tw_ioctl;
 887         TW_Passthru *passthru;
 888         TW_Device_Extension *tw_dev = tw_device_extension_list[iminor(inode)];
 889         int retval = -EFAULT;
 890         void __user *argp = (void __user *)arg;
 891
 892         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n");
 893
 894         mutex_lock(&tw_mutex);
 895         /* Only let one of these through at a time */
 896         if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
 897                 mutex_unlock(&tw_mutex);
 898                 return -EINTR;
 899         }
 900
 901         /* First copy down the buffer length */
 902         if (copy_from_user(&data_buffer_length, argp, sizeof(unsigned int)))
 903                 goto out;
 904
 905         /* Check size */
 906         if (data_buffer_length > TW_MAX_IOCTL_SECTORS * 512) {
 907                 retval = -EINVAL;
 908                 goto out;
 909         }
 910
 911         /* Hardware can only do multiple of 512 byte transfers */
 912         data_buffer_length_adjusted = (data_buffer_length + 511) & ~511;
 913
 914         /* Now allocate ioctl buf memory */
 915         cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, &dma_handle, GFP_KERNEL);
 916         if (cpu_addr == NULL) {
 917                 retval = -ENOMEM;
 918                 goto out;
 919         }
 920
 921         tw_ioctl = (TW_New_Ioctl *)cpu_addr;
 922
 923         /* Now copy down the entire ioctl */
 924         if (copy_from_user(tw_ioctl, argp, data_buffer_length + sizeof(TW_New_Ioctl) - 1))
 925                 goto out2;
 926
 927         passthru = (TW_Passthru *)&tw_ioctl->firmware_command;
 928
 929         /* See which ioctl we are doing */
 930         switch (cmd) {
 931                 case TW_OP_NOP:
 932                         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_OP_NOP.\n");
 933                         break;
 934                 case TW_OP_AEN_LISTEN:
 935                         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_AEN_LISTEN.\n");
 936                         memset(tw_ioctl->data_buffer, 0, data_buffer_length);
 937
 938                         spin_lock_irqsave(tw_dev->host->host_lock, flags);
 939                         if (tw_dev->aen_head == tw_dev->aen_tail) {
 940                                 tw_aen_code = TW_AEN_QUEUE_EMPTY;
 941                         } else {
 942                                 tw_aen_code = tw_dev->aen_queue[tw_dev->aen_head];
 943                                 if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
 944                                         tw_dev->aen_head = TW_Q_START;
 945                                 } else {
 946                                         tw_dev->aen_head = tw_dev->aen_head + 1;
 947                                 }
 948                         }
 949                         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 950                         memcpy(tw_ioctl->data_buffer, &tw_aen_code, sizeof(tw_aen_code));
 951                         break;
 952                 case TW_CMD_PACKET_WITH_DATA:
 953                         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n");
 954                         spin_lock_irqsave(tw_dev->host->host_lock, flags);
 955
 956                         tw_state_request_start(tw_dev, &request_id);
 957
 958                         /* Flag internal command */
 959                         tw_dev->srb[request_id] = NULL;
 960
 961                         /* Flag chrdev ioctl */
 962                         tw_dev->chrdev_request_id = request_id;
 963
 964                         tw_ioctl->firmware_command.request_id = request_id;
 965
 966                         /* Load the sg list */
 967                         switch (TW_SGL_OUT(tw_ioctl->firmware_command.opcode__sgloffset)) {
 968                         case 2:
 969                                 tw_ioctl->firmware_command.byte8.param.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
 970                                 tw_ioctl->firmware_command.byte8.param.sgl[0].length = data_buffer_length_adjusted;
 971                                 break;
 972                         case 3:
 973                                 tw_ioctl->firmware_command.byte8.io.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
 974                                 tw_ioctl->firmware_command.byte8.io.sgl[0].length = data_buffer_length_adjusted;
 975                                 break;
 976                         case 5:
 977                                 passthru->sg_list[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
 978                                 passthru->sg_list[0].length = data_buffer_length_adjusted;
 979                                 break;
 980                         }
 981
 982                         memcpy(tw_dev->command_packet_virtual_address[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command));
 983
 984                         /* Now post the command packet to the controller */
 985                         tw_post_command_packet(tw_dev, request_id);
 986                         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 987
 988                         timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
 989
 990                         /* Now wait for the command to complete */
 991                         timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
 992
 993                         /* We timed out, and didn't get an interrupt */
 994                         if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
 995                                 /* Now we need to reset the board */
 996                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Character ioctl (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, cmd);
 997                                 retval = -EIO;
 998                                 if (tw_reset_device_extension(tw_dev)) {
 999                                         printk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): Reset failed for card %d.\n", tw_dev->host->host_no);
1000                                 }
1001                                 goto out2;
1002                         }
1003
1004                         /* Now copy in the command packet response */
1005                         memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command));
1006
1007                         /* Now complete the io */
1008                         spin_lock_irqsave(tw_dev->host->host_lock, flags);
1009                         tw_dev->posted_request_count--;
1010                         tw_dev->state[request_id] = TW_S_COMPLETED;
1011                         tw_state_request_finish(tw_dev, request_id);
1012                         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1013                         break;
1014                 default:
1015                         retval = -ENOTTY;
1016                         goto out2;
1017         }
1018
1019         /* Now copy the response to userspace */
1020         if (copy_to_user(argp, tw_ioctl, sizeof(TW_New_Ioctl) + data_buffer_length - 1))
1021                 goto out2;
1022         retval = 0;
1023 out2:
1024         /* Now free ioctl buf memory */
1025         dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, cpu_addr, dma_handle);
1026 out:
1027         mutex_unlock(&tw_dev->ioctl_lock);
1028         mutex_unlock(&tw_mutex);
1029         return retval;
1030 } /* End tw_chrdev_ioctl() */
1031
1032 /* This function handles open for the character device */
1033 /* NOTE that this function races with remove. */
1034 static int tw_chrdev_open(struct inode *inode, struct file *file)
1035 {
1036         unsigned int minor_number;
1037
1038         dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_open()\n");
1039
1040         if (!capable(CAP_SYS_ADMIN))
1041                 return -EACCES;
1042
1043         minor_number = iminor(inode);
1044         if (minor_number >= tw_device_extension_count)
1045                 return -ENODEV;
1046
1047         return 0;
1048 } /* End tw_chrdev_open() */
1049
1050 /* File operations struct for character device */
1051 static const struct file_operations tw_fops = {
1052         .owner          = THIS_MODULE,
1053         .unlocked_ioctl = tw_chrdev_ioctl,
1054         .compat_ioctl   = compat_ptr_ioctl,
1055         .open           = tw_chrdev_open,
1056         .release        = NULL,
1057         .llseek         = noop_llseek,
1058 };
1059
1060 /* This function will free up device extension resources */
1061 static void tw_free_device_extension(TW_Device_Extension *tw_dev)
1062 {
1063         dprintk(KERN_NOTICE "3w-xxxx: tw_free_device_extension()\n");
1064
1065         /* Free command packet and generic buffer memory */
1066         if (tw_dev->command_packet_virtual_address[0])
1067                 dma_free_coherent(&tw_dev->tw_pci_dev->dev,
1068                                 sizeof(TW_Command) * TW_Q_LENGTH,
1069                                 tw_dev->command_packet_virtual_address[0],
1070                                 tw_dev->command_packet_physical_address[0]);
1071
1072         if (tw_dev->alignment_virtual_address[0])
1073                 dma_free_coherent(&tw_dev->tw_pci_dev->dev,
1074                                 sizeof(TW_Sector) * TW_Q_LENGTH,
1075                                 tw_dev->alignment_virtual_address[0],
1076                                 tw_dev->alignment_physical_address[0]);
1077 } /* End tw_free_device_extension() */
1078
1079 /* This function will send an initconnection command to controller */
1080 static int tw_initconnection(TW_Device_Extension *tw_dev, int message_credits)
1081 {
1082         unsigned long command_que_value;
1083         TW_Command  *command_packet;
1084         TW_Response_Queue response_queue;
1085         int request_id = 0;
1086
1087         dprintk(KERN_NOTICE "3w-xxxx: tw_initconnection()\n");
1088
1089         /* Initialize InitConnection command packet */
1090         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1091                 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet virtual address.\n");
1092                 return 1;
1093         }
1094
1095         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1096         memset(command_packet, 0, sizeof(TW_Sector));
1097         command_packet->opcode__sgloffset = TW_OPSGL_IN(0, TW_OP_INIT_CONNECTION);
1098         command_packet->size = TW_INIT_COMMAND_PACKET_SIZE;
1099         command_packet->request_id = request_id;
1100         command_packet->status = 0x0;
1101         command_packet->flags = 0x0;
1102         command_packet->byte6.message_credits = message_credits;
1103         command_packet->byte8.init_connection.response_queue_pointer = 0x0;
1104         command_que_value = tw_dev->command_packet_physical_address[request_id];
1105
1106         if (command_que_value == 0) {
1107                 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet physical address.\n");
1108                 return 1;
1109         }
1110
1111         /* Send command packet to the board */
1112         outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1113
1114         /* Poll for completion */
1115         if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1116                 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1117                 request_id = TW_RESID_OUT(response_queue.response_id);
1118
1119                 if (request_id != 0) {
1120                         /* unexpected request id */
1121                         printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Unexpected request id.\n");
1122                         return 1;
1123                 }
1124                 if (command_packet->status != 0) {
1125                         /* bad response */
1126                         tw_decode_sense(tw_dev, request_id, 0);
1127                         return 1;
1128                 }
1129         }
1130         return 0;
1131 } /* End tw_initconnection() */
1132
1133 /* Set a value in the features table */
1134 static int tw_setfeature(TW_Device_Extension *tw_dev, int parm, int param_size,
1135                          unsigned char *val)
1136 {
1137         TW_Param *param;
1138         TW_Command  *command_packet;
1139         TW_Response_Queue response_queue;
1140         int request_id = 0;
1141         unsigned long command_que_value;
1142         unsigned long param_value;
1143
1144         /* Initialize SetParam command packet */
1145         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1146                 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet virtual address.\n");
1147                 return 1;
1148         }
1149         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1150         memset(command_packet, 0, sizeof(TW_Sector));
1151         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1152
1153         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
1154         param->table_id = 0x404;  /* Features table */
1155         param->parameter_id = parm;
1156         param->parameter_size_bytes = param_size;
1157         memcpy(param->data, val, param_size);
1158
1159         param_value = tw_dev->alignment_physical_address[request_id];
1160         if (param_value == 0) {
1161                 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad alignment physical address.\n");
1162                 tw_dev->state[request_id] = TW_S_COMPLETED;
1163                 tw_state_request_finish(tw_dev, request_id);
1164                 tw_dev->srb[request_id]->result = (DID_OK << 16);
1165                 scsi_done(tw_dev->srb[request_id]);
1166         }
1167         command_packet->byte8.param.sgl[0].address = param_value;
1168         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1169
1170         command_packet->size = 4;
1171         command_packet->request_id = request_id;
1172         command_packet->byte6.parameter_count = 1;
1173
1174         command_que_value = tw_dev->command_packet_physical_address[request_id];
1175         if (command_que_value == 0) {
1176                 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet physical address.\n");
1177                 return 1;
1178         }
1179
1180         /* Send command packet to the board */
1181         outl(command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1182
1183         /* Poll for completion */
1184         if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1185                 response_queue.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1186                 request_id = TW_RESID_OUT(response_queue.response_id);
1187
1188                 if (request_id != 0) {
1189                         /* unexpected request id */
1190                         printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Unexpected request id.\n");
1191                         return 1;
1192                 }
1193                 if (command_packet->status != 0) {
1194                         /* bad response */
1195                         tw_decode_sense(tw_dev, request_id, 0);
1196                         return 1;
1197                 }
1198         }
1199
1200         return 0;
1201 } /* End tw_setfeature() */
1202
1203 /* This function will reset a controller */
1204 static int tw_reset_sequence(TW_Device_Extension *tw_dev)
1205 {
1206         int error = 0;
1207         int tries = 0;
1208         unsigned char c = 1;
1209
1210         /* Reset the board */
1211         while (tries < TW_MAX_RESET_TRIES) {
1212                 TW_SOFT_RESET(tw_dev);
1213
1214                 error = tw_aen_drain_queue(tw_dev);
1215                 if (error) {
1216                         printk(KERN_WARNING "3w-xxxx: scsi%d: AEN drain failed, retrying.\n", tw_dev->host->host_no);
1217                         tries++;
1218                         continue;
1219                 }
1220
1221                 /* Check for controller errors */
1222                 if (tw_check_errors(tw_dev)) {
1223                         printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors found, retrying.\n", tw_dev->host->host_no);
1224                         tries++;
1225                         continue;
1226                 }
1227
1228                 /* Now the controller is in a good state */
1229                 break;
1230         }
1231
1232         if (tries >= TW_MAX_RESET_TRIES) {
1233                 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors, card not responding, check all cabling.\n", tw_dev->host->host_no);
1234                 return 1;
1235         }
1236
1237         error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS);
1238         if (error) {
1239                 printk(KERN_WARNING "3w-xxxx: scsi%d: Connection initialization failed.\n", tw_dev->host->host_no);
1240                 return 1;
1241         }
1242
1243         error = tw_setfeature(tw_dev, 2, 1, &c);
1244         if (error) {
1245                 printk(KERN_WARNING "3w-xxxx: Unable to set features for card, probable old firmware or card.\n");
1246         }
1247
1248         return 0;
1249 } /* End tw_reset_sequence() */
1250
1251 /* This function will initialize the fields of a device extension */
1252 static int tw_initialize_device_extension(TW_Device_Extension *tw_dev)
1253 {
1254         int i, error=0;
1255
1256         dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_device_extension()\n");
1257
1258         /* Initialize command packet buffers */
1259         error = tw_allocate_memory(tw_dev, sizeof(TW_Command), 0);
1260         if (error) {
1261                 printk(KERN_WARNING "3w-xxxx: Command packet memory allocation failed.\n");
1262                 return 1;
1263         }
1264
1265         /* Initialize generic buffer */
1266         error = tw_allocate_memory(tw_dev, sizeof(TW_Sector), 1);
1267         if (error) {
1268                 printk(KERN_WARNING "3w-xxxx: Generic memory allocation failed.\n");
1269                 return 1;
1270         }
1271
1272         for (i=0;i<TW_Q_LENGTH;i++) {
1273                 tw_dev->free_queue[i] = i;
1274                 tw_dev->state[i] = TW_S_INITIAL;
1275         }
1276
1277         tw_dev->pending_head = TW_Q_START;
1278         tw_dev->pending_tail = TW_Q_START;
1279         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1280
1281         mutex_init(&tw_dev->ioctl_lock);
1282         init_waitqueue_head(&tw_dev->ioctl_wqueue);
1283
1284         return 0;
1285 } /* End tw_initialize_device_extension() */
1286
1287 /* This function will reset a device extension */
1288 static int tw_reset_device_extension(TW_Device_Extension *tw_dev)
1289 {
1290         int i = 0;
1291         struct scsi_cmnd *srb;
1292         unsigned long flags = 0;
1293
1294         dprintk(KERN_NOTICE "3w-xxxx: tw_reset_device_extension()\n");
1295
1296         set_bit(TW_IN_RESET, &tw_dev->flags);
1297         TW_DISABLE_INTERRUPTS(tw_dev);
1298         TW_MASK_COMMAND_INTERRUPT(tw_dev);
1299         spin_lock_irqsave(tw_dev->host->host_lock, flags);
1300
1301         /* Abort all requests that are in progress */
1302         for (i=0;i<TW_Q_LENGTH;i++) {
1303                 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1304                     (tw_dev->state[i] != TW_S_INITIAL) &&
1305                     (tw_dev->state[i] != TW_S_COMPLETED)) {
1306                         srb = tw_dev->srb[i];
1307                         if (srb != NULL) {
1308                                 srb->result = (DID_RESET << 16);
1309                                 scsi_dma_unmap(srb);
1310                                 scsi_done(srb);
1311                         }
1312                 }
1313         }
1314
1315         /* Reset queues and counts */
1316         for (i=0;i<TW_Q_LENGTH;i++) {
1317                 tw_dev->free_queue[i] = i;
1318                 tw_dev->state[i] = TW_S_INITIAL;
1319         }
1320         tw_dev->free_head = TW_Q_START;
1321         tw_dev->free_tail = TW_Q_START;
1322         tw_dev->posted_request_count = 0;
1323         tw_dev->pending_request_count = 0;
1324         tw_dev->pending_head = TW_Q_START;
1325         tw_dev->pending_tail = TW_Q_START;
1326         tw_dev->reset_print = 0;
1327
1328         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1329
1330         if (tw_reset_sequence(tw_dev)) {
1331                 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset sequence failed.\n", tw_dev->host->host_no);
1332                 return 1;
1333         }
1334
1335         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1336         clear_bit(TW_IN_RESET, &tw_dev->flags);
1337         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1338
1339         return 0;
1340 } /* End tw_reset_device_extension() */
1341
1342 /* This funciton returns unit geometry in cylinders/heads/sectors */
1343 static int tw_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1344                              sector_t capacity, int geom[])
1345 {
1346         int heads, sectors, cylinders;
1347
1348         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam()\n");
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                 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         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)
1924 {
1925         void (*done)(struct scsi_cmnd *) = scsi_done;
1926         unsigned char *command = SCpnt->cmnd;
1927         int request_id = 0;
1928         int retval = 1;
1929         TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1930
1931         /* If we are resetting due to timed out ioctl, report as busy */
1932         if (test_bit(TW_IN_RESET, &tw_dev->flags))
1933                 return SCSI_MLQUEUE_HOST_BUSY;
1934
1935         /* Queue the command and get a request id */
1936         tw_state_request_start(tw_dev, &request_id);
1937
1938         /* Save the scsi command for use by the ISR */
1939         tw_dev->srb[request_id] = SCpnt;
1940
1941         switch (*command) {
1942         case READ_10:
1943         case READ_6:
1944         case WRITE_10:
1945         case WRITE_6:
1946                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ/WRITE.\n");
1947                 retval = tw_scsiop_read_write(tw_dev, request_id);
1948                 break;
1949         case TEST_UNIT_READY:
1950                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TEST_UNIT_READY.\n");
1951                 retval = tw_scsiop_test_unit_ready(tw_dev, request_id);
1952                 break;
1953         case INQUIRY:
1954                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught INQUIRY.\n");
1955                 retval = tw_scsiop_inquiry(tw_dev, request_id);
1956                 break;
1957         case READ_CAPACITY:
1958                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ_CAPACITY.\n");
1959                 retval = tw_scsiop_read_capacity(tw_dev, request_id);
1960                 break;
1961         case REQUEST_SENSE:
1962                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught REQUEST_SENSE.\n");
1963                 retval = tw_scsiop_request_sense(tw_dev, request_id);
1964                 break;
1965         case MODE_SENSE:
1966                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught MODE_SENSE.\n");
1967                 retval = tw_scsiop_mode_sense(tw_dev, request_id);
1968                 break;
1969         case SYNCHRONIZE_CACHE:
1970                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught SYNCHRONIZE_CACHE.\n");
1971                 retval = tw_scsiop_synchronize_cache(tw_dev, request_id);
1972                 break;
1973         case TW_IOCTL:
1974                 printk(KERN_WARNING "3w-xxxx: SCSI_IOCTL_SEND_COMMAND deprecated, please update your 3ware tools.\n");
1975                 break;
1976         default:
1977                 printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command);
1978                 tw_dev->state[request_id] = TW_S_COMPLETED;
1979                 tw_state_request_finish(tw_dev, request_id);
1980                 scsi_build_sense(SCpnt, 1, ILLEGAL_REQUEST, 0x20, 0);
1981                 done(SCpnt);
1982                 retval = 0;
1983         }
1984         if (retval) {
1985                 tw_dev->state[request_id] = TW_S_COMPLETED;
1986                 tw_state_request_finish(tw_dev, request_id);
1987                 SCpnt->result = (DID_ERROR << 16);
1988                 done(SCpnt);
1989                 retval = 0;
1990         }
1991         return retval;
1992 } /* End tw_scsi_queue() */
1993
1994 static DEF_SCSI_QCMD(tw_scsi_queue)
1995
1996 /* This function is the interrupt service routine */
1997 static irqreturn_t tw_interrupt(int irq, void *dev_instance)
1998 {
1999         int request_id;
2000         u32 status_reg_value;
2001         TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
2002         TW_Response_Queue response_que;
2003         int error = 0, retval = 0;
2004         TW_Command *command_packet;
2005         int handled = 0;
2006
2007         /* Get the host lock for io completions */
2008         spin_lock(tw_dev->host->host_lock);
2009
2010         /* Read the registers */
2011         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2012
2013         /* Check if this is our interrupt, otherwise bail */
2014         if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
2015                 goto tw_interrupt_bail;
2016
2017         handled = 1;
2018
2019         /* If we are resetting, bail */
2020         if (test_bit(TW_IN_RESET, &tw_dev->flags))
2021                 goto tw_interrupt_bail;
2022
2023         /* Check controller for errors */
2024         if (tw_check_bits(status_reg_value)) {
2025                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2026                 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2027                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2028                         goto tw_interrupt_bail;
2029                 }
2030         }
2031
2032         /* Handle host interrupt */
2033         if (status_reg_value & TW_STATUS_HOST_INTERRUPT) {
2034                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received host interrupt.\n");
2035                 TW_CLEAR_HOST_INTERRUPT(tw_dev);
2036         }
2037
2038         /* Handle attention interrupt */
2039         if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
2040                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received attention interrupt.\n");
2041                 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
2042                 tw_state_request_start(tw_dev, &request_id);
2043                 error = tw_aen_read_queue(tw_dev, request_id);
2044                 if (error) {
2045                         printk(KERN_WARNING "3w-xxxx: scsi%d: Error reading aen queue.\n", tw_dev->host->host_no);
2046                         tw_dev->state[request_id] = TW_S_COMPLETED;
2047                         tw_state_request_finish(tw_dev, request_id);
2048                 }
2049         }
2050
2051         /* Handle command interrupt */
2052         if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
2053                 /* Drain as many pending commands as we can */
2054                 while (tw_dev->pending_request_count > 0) {
2055                         request_id = tw_dev->pending_queue[tw_dev->pending_head];
2056                         if (tw_dev->state[request_id] != TW_S_PENDING) {
2057                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Found request id that wasn't pending.\n", tw_dev->host->host_no);
2058                                 break;
2059                         }
2060                         if (tw_post_command_packet(tw_dev, request_id)==0) {
2061                                 if (tw_dev->pending_head == TW_Q_LENGTH-1) {
2062                                         tw_dev->pending_head = TW_Q_START;
2063                                 } else {
2064                                         tw_dev->pending_head = tw_dev->pending_head + 1;
2065                                 }
2066                                 tw_dev->pending_request_count--;
2067                         } else {
2068                                 /* If we get here, we will continue re-posting on the next command interrupt */
2069                                 break;
2070                         }
2071                 }
2072                 /* If there are no more pending requests, we mask command interrupt */
2073                 if (tw_dev->pending_request_count == 0)
2074                         TW_MASK_COMMAND_INTERRUPT(tw_dev);
2075         }
2076
2077         /* Handle response interrupt */
2078         if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
2079                 /* Drain the response queue from the board */
2080                 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
2081                         /* Read response queue register */
2082                         response_que.value = inl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
2083                         request_id = TW_RESID_OUT(response_que.response_id);
2084                         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2085                         error = 0;
2086
2087                         /* Check for bad response */
2088                         if (command_packet->status != 0) {
2089                                 /* If internal command, don't error, don't fill sense */
2090                                 if (tw_dev->srb[request_id] == NULL) {
2091                                         tw_decode_sense(tw_dev, request_id, 0);
2092                                 } else {
2093                                         error = tw_decode_sense(tw_dev, request_id, 1);
2094                                 }
2095                         }
2096
2097                         /* Check for correct state */
2098                         if (tw_dev->state[request_id] != TW_S_POSTED) {
2099                                 if (tw_dev->srb[request_id] != NULL) {
2100                                         printk(KERN_WARNING "3w-xxxx: scsi%d: Received a request id that wasn't posted.\n", tw_dev->host->host_no);
2101                                         error = 1;
2102                                 }
2103                         }
2104
2105                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Response queue request id: %d.\n", request_id);
2106
2107                         /* Check for internal command completion */
2108                         if (tw_dev->srb[request_id] == NULL) {
2109                                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Found internally posted command.\n");
2110                                 /* Check for chrdev ioctl completion */
2111                                 if (request_id != tw_dev->chrdev_request_id) {
2112                                         retval = tw_aen_complete(tw_dev, request_id);
2113                                         if (retval) {
2114                                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing aen.\n", tw_dev->host->host_no);
2115                                         }
2116                                 } else {
2117                                         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
2118                                         wake_up(&tw_dev->ioctl_wqueue);
2119                                 }
2120                         } else {
2121                                 switch (tw_dev->srb[request_id]->cmnd[0]) {
2122                                 case READ_10:
2123                                 case READ_6:
2124                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_10/READ_6\n");
2125                                         break;
2126                                 case WRITE_10:
2127                                 case WRITE_6:
2128                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught WRITE_10/WRITE_6\n");
2129                                         break;
2130                                 case TEST_UNIT_READY:
2131                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TEST_UNIT_READY\n");
2132                                         error = tw_scsiop_test_unit_ready_complete(tw_dev, request_id);
2133                                         break;
2134                                 case INQUIRY:
2135                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught INQUIRY\n");
2136                                         error = tw_scsiop_inquiry_complete(tw_dev, request_id);
2137                                         break;
2138                                 case READ_CAPACITY:
2139                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_CAPACITY\n");
2140                                         error = tw_scsiop_read_capacity_complete(tw_dev, request_id);
2141                                         break;
2142                                 case MODE_SENSE:
2143                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught MODE_SENSE\n");
2144                                         error = tw_scsiop_mode_sense_complete(tw_dev, request_id);
2145                                         break;
2146                                 case SYNCHRONIZE_CACHE:
2147                                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught SYNCHRONIZE_CACHE\n");
2148                                         break;
2149                                 default:
2150                                         printk(KERN_WARNING "3w-xxxx: case slip in tw_interrupt()\n");
2151                                         error = 1;
2152                                 }
2153
2154                                 /* If no error command was a success */
2155                                 if (error == 0) {
2156                                         tw_dev->srb[request_id]->result = (DID_OK << 16);
2157                                 }
2158
2159                                 /* If error, command failed */
2160                                 if (error == 1) {
2161                                         /* Ask for a host reset */
2162                                         tw_dev->srb[request_id]->result = (DID_OK << 16) | SAM_STAT_CHECK_CONDITION;
2163                                 }
2164
2165                                 /* Now complete the io */
2166                                 if ((error != TW_ISR_DONT_COMPLETE)) {
2167                                         scsi_dma_unmap(tw_dev->srb[request_id]);
2168                                         scsi_done(tw_dev->srb[request_id]);
2169                                         tw_dev->state[request_id] = TW_S_COMPLETED;
2170                                         tw_state_request_finish(tw_dev, request_id);
2171                                         tw_dev->posted_request_count--;
2172                                 }
2173                         }
2174
2175                         /* Check for valid status after each drain */
2176                         status_reg_value = inl(TW_STATUS_REG_ADDR(tw_dev));
2177                         if (tw_check_bits(status_reg_value)) {
2178                                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
2179                                 if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
2180                                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
2181                                         goto tw_interrupt_bail;
2182                                 }
2183                         }
2184                 }
2185         }
2186
2187 tw_interrupt_bail:
2188         spin_unlock(tw_dev->host->host_lock);
2189         return IRQ_RETVAL(handled);
2190 } /* End tw_interrupt() */
2191
2192 /* This function tells the controller to shut down */
2193 static void __tw_shutdown(TW_Device_Extension *tw_dev)
2194 {
2195         /* Disable interrupts */
2196         TW_DISABLE_INTERRUPTS(tw_dev);
2197
2198         /* Free up the IRQ */
2199         free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2200
2201         printk(KERN_WARNING "3w-xxxx: Shutting down host %d.\n", tw_dev->host->host_no);
2202
2203         /* Tell the card we are shutting down */
2204         if (tw_initconnection(tw_dev, 1)) {
2205                 printk(KERN_WARNING "3w-xxxx: Connection shutdown failed.\n");
2206         } else {
2207                 printk(KERN_WARNING "3w-xxxx: Shutdown complete.\n");
2208         }
2209
2210         /* Clear all interrupts just before exit */
2211         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2212 } /* End __tw_shutdown() */
2213
2214 /* Wrapper for __tw_shutdown */
2215 static void tw_shutdown(struct pci_dev *pdev)
2216 {
2217         struct Scsi_Host *host = pci_get_drvdata(pdev);
2218         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2219
2220         __tw_shutdown(tw_dev);
2221 } /* End tw_shutdown() */
2222
2223 /* This function gets called when a disk is coming online */
2224 static int tw_slave_configure(struct scsi_device *sdev)
2225 {
2226         /* Force 60 second timeout */
2227         blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
2228
2229         return 0;
2230 } /* End tw_slave_configure() */
2231
2232 static struct scsi_host_template driver_template = {
2233         .module                 = THIS_MODULE,
2234         .name                   = "3ware Storage Controller",
2235         .queuecommand           = tw_scsi_queue,
2236         .eh_host_reset_handler  = tw_scsi_eh_reset,
2237         .bios_param             = tw_scsi_biosparam,
2238         .change_queue_depth     = scsi_change_queue_depth,
2239         .can_queue              = TW_Q_LENGTH-2,
2240         .slave_configure        = tw_slave_configure,
2241         .this_id                = -1,
2242         .sg_tablesize           = TW_MAX_SGL_LENGTH,
2243         .max_sectors            = TW_MAX_SECTORS,
2244         .cmd_per_lun            = TW_MAX_CMDS_PER_LUN,
2245         .shost_groups           = tw_host_groups,
2246         .emulated               = 1,
2247         .no_write_same          = 1,
2248 };
2249
2250 /* This function will probe and initialize a card */
2251 static int tw_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2252 {
2253         struct Scsi_Host *host = NULL;
2254         TW_Device_Extension *tw_dev;
2255         int retval;
2256
2257         retval = pci_enable_device(pdev);
2258         if (retval) {
2259                 printk(KERN_WARNING "3w-xxxx: Failed to enable pci device.");
2260                 goto out_disable_device;
2261         }
2262
2263         pci_set_master(pdev);
2264
2265         retval = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
2266         if (retval) {
2267                 printk(KERN_WARNING "3w-xxxx: Failed to set dma mask.");
2268                 goto out_disable_device;
2269         }
2270
2271         host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2272         if (!host) {
2273                 printk(KERN_WARNING "3w-xxxx: Failed to allocate memory for device extension.");
2274                 retval = -ENOMEM;
2275                 goto out_disable_device;
2276         }
2277         tw_dev = (TW_Device_Extension *)host->hostdata;
2278
2279         /* Save values to device extension */
2280         tw_dev->host = host;
2281         tw_dev->tw_pci_dev = pdev;
2282
2283         if (tw_initialize_device_extension(tw_dev)) {
2284                 printk(KERN_WARNING "3w-xxxx: Failed to initialize device extension.");
2285                 retval = -ENOMEM;
2286                 goto out_free_device_extension;
2287         }
2288
2289         /* Request IO regions */
2290         retval = pci_request_regions(pdev, "3w-xxxx");
2291         if (retval) {
2292                 printk(KERN_WARNING "3w-xxxx: Failed to get mem region.");
2293                 goto out_free_device_extension;
2294         }
2295
2296         /* Save base address */
2297         tw_dev->base_addr = pci_resource_start(pdev, 0);
2298         if (!tw_dev->base_addr) {
2299                 printk(KERN_WARNING "3w-xxxx: Failed to get io address.");
2300                 retval = -ENOMEM;
2301                 goto out_release_mem_region;
2302         }
2303
2304         /* Disable interrupts on the card */
2305         TW_DISABLE_INTERRUPTS(tw_dev);
2306
2307         /* Initialize the card */
2308         if (tw_reset_sequence(tw_dev))
2309                 goto out_release_mem_region;
2310
2311         /* Set host specific parameters */
2312         host->max_id = TW_MAX_UNITS;
2313         host->max_cmd_len = TW_MAX_CDB_LEN;
2314
2315         /* Luns and channels aren't supported by adapter */
2316         host->max_lun = 0;
2317         host->max_channel = 0;
2318
2319         /* Register the card with the kernel SCSI layer */
2320         retval = scsi_add_host(host, &pdev->dev);
2321         if (retval) {
2322                 printk(KERN_WARNING "3w-xxxx: scsi add host failed");
2323                 goto out_release_mem_region;
2324         }
2325
2326         pci_set_drvdata(pdev, host);
2327
2328         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);
2329
2330         /* Now setup the interrupt handler */
2331         retval = request_irq(pdev->irq, tw_interrupt, IRQF_SHARED, "3w-xxxx", tw_dev);
2332         if (retval) {
2333                 printk(KERN_WARNING "3w-xxxx: Error requesting IRQ.");
2334                 goto out_remove_host;
2335         }
2336
2337         tw_device_extension_list[tw_device_extension_count] = tw_dev;
2338         tw_device_extension_count++;
2339
2340         /* Re-enable interrupts on the card */
2341         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2342
2343         /* Finally, scan the host */
2344         scsi_scan_host(host);
2345
2346         if (twe_major == -1) {
2347                 if ((twe_major = register_chrdev (0, "twe", &tw_fops)) < 0)
2348                         printk(KERN_WARNING "3w-xxxx: Failed to register character device.");
2349         }
2350         return 0;
2351
2352 out_remove_host:
2353         scsi_remove_host(host);
2354 out_release_mem_region:
2355         pci_release_regions(pdev);
2356 out_free_device_extension:
2357         tw_free_device_extension(tw_dev);
2358         scsi_host_put(host);
2359 out_disable_device:
2360         pci_disable_device(pdev);
2361
2362         return retval;
2363 } /* End tw_probe() */
2364
2365 /* This function is called to remove a device */
2366 static void tw_remove(struct pci_dev *pdev)
2367 {
2368         struct Scsi_Host *host = pci_get_drvdata(pdev);
2369         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2370
2371         scsi_remove_host(tw_dev->host);
2372
2373         /* Unregister character device */
2374         if (twe_major >= 0) {
2375                 unregister_chrdev(twe_major, "twe");
2376                 twe_major = -1;
2377         }
2378
2379         /* Shutdown the card */
2380         __tw_shutdown(tw_dev);
2381
2382         /* Free up the mem region */
2383         pci_release_regions(pdev);
2384
2385         /* Free up device extension resources */
2386         tw_free_device_extension(tw_dev);
2387
2388         scsi_host_put(tw_dev->host);
2389         pci_disable_device(pdev);
2390         tw_device_extension_count--;
2391 } /* End tw_remove() */
2392
2393 /* PCI Devices supported by this driver */
2394 static struct pci_device_id tw_pci_tbl[] = {
2395         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_1000,
2396           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2397         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_7000,
2398           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2399         { }
2400 };
2401 MODULE_DEVICE_TABLE(pci, tw_pci_tbl);
2402
2403 /* pci_driver initializer */
2404 static struct pci_driver tw_driver = {
2405         .name           = "3w-xxxx",
2406         .id_table       = tw_pci_tbl,
2407         .probe          = tw_probe,
2408         .remove         = tw_remove,
2409         .shutdown       = tw_shutdown,
2410 };
2411
2412 /* This function is called on driver initialization */
2413 static int __init tw_init(void)
2414 {
2415         printk(KERN_WARNING "3ware Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2416
2417         return pci_register_driver(&tw_driver);
2418 } /* End tw_init() */
2419
2420 /* This function is called on driver exit */
2421 static void __exit tw_exit(void)
2422 {
2423         pci_unregister_driver(&tw_driver);
2424 } /* End tw_exit() */
2425
2426 module_init(tw_init);
2427 module_exit(tw_exit);
2428