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