drivers/scsi/3w-xxxx.c

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