drivers/scsi/3w-xxxx.c

   1 /*
   2    3w-xxxx.c -- 3ware Storage Controller device driver for Linux.
   3
   4    Written By: Adam Radford <linux@3ware.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-2003 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    linux@3ware.com
  51
  52    For more information, goto:
  53    http://www.3ware.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 */
 183
 184 #include <linux/module.h>
 185
 186 MODULE_AUTHOR ("3ware Inc.");
 187 #ifdef CONFIG_SMP
 188 MODULE_DESCRIPTION ("3ware Storage Controller Linux Driver (SMP)");
 189 #else
 190 MODULE_DESCRIPTION ("3ware Storage Controller Linux Driver");
 191 #endif
 192 MODULE_LICENSE("GPL");
 193
 194 #include <linux/kernel.h>
 195 #include <linux/pci.h>
 196 #include <linux/time.h>
 197 #include <linux/proc_fs.h>
 198 #include <linux/sched.h>
 199 #include <linux/ioport.h>
 200 #include <linux/blkdev.h>
 201 #include <linux/hdreg.h>
 202 #include <linux/string.h>
 203 #include <linux/delay.h>
 204 #include <linux/smp.h>
 205 #include <linux/reboot.h>
 206 #include <linux/spinlock.h>
 207 #include <linux/interrupt.h>
 208
 209 #include <asm/errno.h>
 210 #include <asm/io.h>
 211 #include <asm/irq.h>
 212 #include <asm/uaccess.h>
 213
 214 #define __3W_C                  /* let 3w-xxxx.h know it is use */
 215
 216 #include "scsi.h"
 217 #include "hosts.h"
 218
 219 #include "3w-xxxx.h"
 220
 221 static int tw_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
 222 static int tw_chrdev_open(struct inode *inode, struct file *file);
 223 static int tw_chrdev_release(struct inode *inode, struct file *file);
 224 static int tw_copy_info(TW_Info *info, char *fmt, ...);
 225 static void tw_copy_mem_info(TW_Info *info, char *data, int len);
 226 static int tw_halt(struct notifier_block *nb, ulong event, void *buf);
 227 static int tw_map_scsi_sg_data(struct pci_dev *pdev, Scsi_Cmnd *cmd);
 228 static u32 tw_map_scsi_single_data(struct pci_dev *pdev, Scsi_Cmnd *cmd);
 229 static void tw_unmap_scsi_data(struct pci_dev *pdev, Scsi_Cmnd *cmd);
 230
 231 /* Notifier block to get a notify on system shutdown/halt/reboot */
 232 static struct notifier_block tw_notifier = {
 233         tw_halt, NULL, 0
 234 };
 235
 236 /* File operations struct for character device */
 237 static struct file_operations tw_fops = {
 238         .owner          = THIS_MODULE,
 239         .ioctl          = tw_chrdev_ioctl,
 240         .open           = tw_chrdev_open,
 241         .release        = tw_chrdev_release
 242 };
 243
 244 /* Globals */
 245 char *tw_driver_version="1.02.00.037";
 246 TW_Device_Extension *tw_device_extension_list[TW_MAX_SLOT];
 247 int tw_device_extension_count = 0;
 248 static int twe_major = -1;
 249
 250 /* Functions */
 251
 252 /* This function will complete an aen request from the isr */
 253 int tw_aen_complete(TW_Device_Extension *tw_dev, int request_id)
 254 {
 255         TW_Param *param;
 256         unsigned short aen;
 257         int error = 0, table_max = 0;
 258
 259         dprintk(KERN_WARNING "3w-xxxx: tw_aen_complete()\n");
 260         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
 261                 printk(KERN_WARNING "3w-xxxx: tw_aen_complete(): Bad alignment virtual address.\n");
 262                 return 1;
 263         }
 264         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
 265         aen = *(unsigned short *)(param->data);
 266         dprintk(KERN_NOTICE "3w-xxxx: tw_aen_complete(): Queue'd code 0x%x\n", aen);
 267
 268         /* Print some useful info when certain aen codes come out */
 269         if (aen == 0x0ff) {
 270                 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: INFO: AEN queue overflow.\n", tw_dev->host->host_no);
 271         } else {
 272                 table_max = sizeof(tw_aen_string)/sizeof(char *);
 273                 if ((aen & 0x0ff) < table_max) {
 274                         if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
 275                                 printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s%d.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff], aen >> 8);
 276                         } else {
 277                                 if (aen != 0x0)
 278                                         printk(KERN_WARNING "3w-xxxx: scsi%d: AEN: %s.\n", tw_dev->host->host_no, tw_aen_string[aen & 0xff]);
 279                         }
 280                 } else {
 281                         printk(KERN_WARNING "3w-xxxx: scsi%d: Received AEN %d.\n", tw_dev->host->host_no, aen);
 282                 }
 283         }
 284         if (aen != TW_AEN_QUEUE_EMPTY) {
 285                 tw_dev->aen_count++;
 286
 287                 /* Now queue the code */
 288                 tw_dev->aen_queue[tw_dev->aen_tail] = aen;
 289                 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
 290                         tw_dev->aen_tail = TW_Q_START;
 291                 } else {
 292                         tw_dev->aen_tail = tw_dev->aen_tail + 1;
 293                 }
 294                 if (tw_dev->aen_head == tw_dev->aen_tail) {
 295                         if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
 296                                 tw_dev->aen_head = TW_Q_START;
 297                         } else {
 298                                 tw_dev->aen_head = tw_dev->aen_head + 1;
 299                         }
 300                 }
 301
 302                 error = tw_aen_read_queue(tw_dev, request_id);
 303                 if (error) {
 304                         printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing AEN.\n", tw_dev->host->host_no);
 305                         tw_dev->state[request_id] = TW_S_COMPLETED;
 306                         tw_state_request_finish(tw_dev, request_id);
 307                 }
 308         } else {
 309                 tw_dev->state[request_id] = TW_S_COMPLETED;
 310                 tw_state_request_finish(tw_dev, request_id);
 311         }
 312
 313         return 0;
 314 } /* End tw_aen_complete() */
 315
 316 /* This function will drain the aen queue after a soft reset */
 317 int tw_aen_drain_queue(TW_Device_Extension *tw_dev)
 318 {
 319         TW_Command *command_packet;
 320         TW_Param *param;
 321         int request_id = 0;
 322         u32 command_que_addr;
 323         unsigned long command_que_value;
 324         unsigned long param_value;
 325         TW_Response_Queue response_queue;
 326         u32 response_que_addr;
 327         unsigned short aen;
 328         unsigned short aen_code;
 329         int finished = 0;
 330         int first_reset = 0;
 331         int queue = 0;
 332         int found = 0, table_max = 0;
 333
 334         dprintk(KERN_NOTICE "3w-xxxx: tw_aen_drain_queue()\n");
 335
 336         command_que_addr = tw_dev->registers.command_que_addr;
 337         response_que_addr = tw_dev->registers.response_que_addr;
 338
 339         if (tw_poll_status(tw_dev, TW_STATUS_ATTENTION_INTERRUPT | TW_STATUS_MICROCONTROLLER_READY, 30)) {
 340                 dprintk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): No attention interrupt for card %d.\n", tw_device_extension_count);
 341                 return 1;
 342         }
 343         tw_clear_attention_interrupt(tw_dev);
 344
 345         /* Empty response queue */
 346         tw_empty_response_que(tw_dev);
 347
 348         /* Initialize command packet */
 349         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
 350                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet virtual address.\n");
 351                 return 1;
 352         }
 353         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
 354         memset(command_packet, 0, sizeof(TW_Sector));
 355         command_packet->byte0.opcode = TW_OP_GET_PARAM;
 356         command_packet->byte0.sgl_offset = 2;
 357         command_packet->size = 4;
 358         command_packet->request_id = request_id;
 359         command_packet->byte3.unit = 0;
 360         command_packet->byte3.host_id = 0;
 361         command_packet->status = 0;
 362         command_packet->flags = 0;
 363         command_packet->byte6.parameter_count = 1;
 364         command_que_value = tw_dev->command_packet_physical_address[request_id];
 365         if (command_que_value == 0) {
 366                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad command packet physical address.\n");
 367                 return 1;
 368         }
 369
 370         /* Now setup the param */
 371         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
 372                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment virtual address.\n");
 373                 return 1;
 374         }
 375         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
 376         memset(param, 0, sizeof(TW_Sector));
 377         param->table_id = 0x401; /* AEN table */
 378         param->parameter_id = 2; /* Unit code */
 379         param->parameter_size_bytes = 2;
 380         param_value = tw_dev->alignment_physical_address[request_id];
 381         if (param_value == 0) {
 382                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Bad alignment physical address.\n");
 383                 return 1;
 384         }
 385         command_packet->byte8.param.sgl[0].address = param_value;
 386         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
 387
 388         /* Now drain the controller's aen queue */
 389         do {
 390                 /* Post command packet */
 391                 outl(command_que_value, command_que_addr);
 392
 393                 /* Now poll for completion */
 394                 if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
 395                         response_queue.value = inl(response_que_addr);
 396                         request_id = (unsigned char)response_queue.u.response_id;
 397
 398                         if (request_id != 0) {
 399                                 /* Unexpected request id */
 400                                 printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Unexpected request id.\n");
 401                                 return 1;
 402                         }
 403
 404                         if (command_packet->status != 0) {
 405                                 if (command_packet->flags != TW_AEN_TABLE_UNDEFINED) {
 406                                         /* Bad response */
 407                                         tw_decode_sense(tw_dev, request_id, 0);
 408                                         return 1;
 409                                 } else {
 410                                         /* We know this is a 3w-1x00, and doesn't support aen's */
 411                                         return 0;
 412                                 }
 413                         }
 414
 415                         /* Now check the aen */
 416                         aen = *(unsigned short *)(param->data);
 417                         aen_code = (aen & 0x0ff);
 418                         queue = 0;
 419                         switch (aen_code) {
 420                                 case TW_AEN_QUEUE_EMPTY:
 421                                         dprintk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
 422                                         if (first_reset != 1) {
 423                                                 return 1;
 424                                         } else {
 425                                                 finished = 1;
 426                                         }
 427                                         break;
 428                                 case TW_AEN_SOFT_RESET:
 429                                         if (first_reset == 0) {
 430                                                 first_reset = 1;
 431                                         } else {
 432                                                 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
 433                                                 tw_dev->aen_count++;
 434                                                 queue = 1;
 435                                         }
 436                                         break;
 437                                 default:
 438                                         if (aen == 0x0ff) {
 439                                                 printk(KERN_WARNING "3w-xxxx: AEN: INFO: AEN queue overflow.\n");
 440                                         } else {
 441                                                 table_max = sizeof(tw_aen_string)/sizeof(char *);
 442                                                 if ((aen & 0x0ff) < table_max) {
 443                                                         if ((tw_aen_string[aen & 0xff][strlen(tw_aen_string[aen & 0xff])-1]) == '#') {
 444                                                                 printk(KERN_WARNING "3w-xxxx: AEN: %s%d.\n", tw_aen_string[aen & 0xff], aen >> 8);
 445                                                         } else {
 446                                                                 printk(KERN_WARNING "3w-xxxx: AEN: %s.\n", tw_aen_string[aen & 0xff]);
 447                                                         }
 448                                                 } else
 449                                                         printk(KERN_WARNING "3w-xxxx: Received AEN %d.\n", aen);
 450                                         }
 451                                         tw_dev->aen_count++;
 452                                         queue = 1;
 453                         }
 454
 455                         /* Now put the aen on the aen_queue */
 456                         if (queue == 1) {
 457                                 tw_dev->aen_queue[tw_dev->aen_tail] = aen;
 458                                 if (tw_dev->aen_tail == TW_Q_LENGTH - 1) {
 459                                         tw_dev->aen_tail = TW_Q_START;
 460                                 } else {
 461                                         tw_dev->aen_tail = tw_dev->aen_tail + 1;
 462                                 }
 463                                 if (tw_dev->aen_head == tw_dev->aen_tail) {
 464                                         if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
 465                                                 tw_dev->aen_head = TW_Q_START;
 466                                         } else {
 467                                                 tw_dev->aen_head = tw_dev->aen_head + 1;
 468                                         }
 469                                 }
 470                         }
 471                         found = 1;
 472                 }
 473                 if (found == 0) {
 474                         printk(KERN_WARNING "3w-xxxx: tw_aen_drain_queue(): Response never received.\n");
 475                         return 1;
 476                 }
 477         } while (finished == 0);
 478
 479         return 0;
 480 } /* End tw_aen_drain_queue() */
 481
 482 /* This function will read the aen queue from the isr */
 483 int tw_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
 484 {
 485         TW_Command *command_packet;
 486         TW_Param *param;
 487         u32 command_que_addr;
 488         unsigned long command_que_value;
 489         u32 status_reg_value = 0, status_reg_addr;
 490         unsigned long param_value = 0;
 491
 492         dprintk(KERN_NOTICE "3w-xxxx: tw_aen_read_queue()\n");
 493         command_que_addr = tw_dev->registers.command_que_addr;
 494         status_reg_addr = tw_dev->registers.status_reg_addr;
 495
 496         status_reg_value = inl(status_reg_addr);
 497         if (tw_check_bits(status_reg_value)) {
 498                 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Unexpected bits.\n");
 499                 tw_decode_bits(tw_dev, status_reg_value, 1);
 500                 return 1;
 501         }
 502         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
 503                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet virtual address.\n");
 504                 return 1;
 505         }
 506         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
 507         memset(command_packet, 0, sizeof(TW_Sector));
 508         command_packet->byte0.opcode = TW_OP_GET_PARAM;
 509         command_packet->byte0.sgl_offset = 2;
 510         command_packet->size = 4;
 511         command_packet->request_id = request_id;
 512         command_packet->byte3.unit = 0;
 513         command_packet->byte3.host_id = 0;
 514         command_packet->status = 0;
 515         command_packet->flags = 0;
 516         command_packet->byte6.parameter_count = 1;
 517         command_que_value = tw_dev->command_packet_physical_address[request_id];
 518         if (command_que_value == 0) {
 519                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad command packet physical address.\n");
 520                 return 1;
 521         }
 522         /* Now setup the param */
 523         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
 524                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment virtual address.\n");
 525                 return 1;
 526         }
 527         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
 528         memset(param, 0, sizeof(TW_Sector));
 529         param->table_id = 0x401; /* AEN table */
 530         param->parameter_id = 2; /* Unit code */
 531         param->parameter_size_bytes = 2;
 532         param_value = tw_dev->alignment_physical_address[request_id];
 533         if (param_value == 0) {
 534                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Bad alignment physical address.\n");
 535                 return 1;
 536         }
 537         command_packet->byte8.param.sgl[0].address = param_value;
 538         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
 539
 540         /* Now post the command packet */
 541         if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) {
 542                 dprintk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post succeeded.\n");
 543                 tw_dev->srb[request_id] = 0; /* Flag internal command */
 544                 tw_dev->state[request_id] = TW_S_POSTED;
 545                 outl(command_que_value, command_que_addr);
 546         } else {
 547                 printk(KERN_WARNING "3w-xxxx: tw_aen_read_queue(): Post failed, will retry.\n");
 548                 return 1;
 549         }
 550
 551         return 0;
 552 } /* End tw_aen_read_queue() */
 553
 554 /* This function will allocate memory */
 555 int tw_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
 556 {
 557         int i;
 558         dma_addr_t dma_handle;
 559         unsigned long *cpu_addr = NULL;
 560
 561         dprintk(KERN_NOTICE "3w-xxxx: tw_allocate_memory()\n");
 562
 563         cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
 564         if (cpu_addr == NULL) {
 565                 printk(KERN_WARNING "3w-xxxx: pci_alloc_consistent() failed.\n");
 566                 return 1;
 567         }
 568
 569         if ((unsigned long)cpu_addr % (tw_dev->tw_pci_dev->device == TW_DEVICE_ID ? TW_ALIGNMENT_6000 : TW_ALIGNMENT_7000)) {
 570                 printk(KERN_WARNING "3w-xxxx: Couldn't allocate correctly aligned memory.\n");
 571                 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
 572                 return 1;
 573         }
 574
 575         memset(cpu_addr, 0, size*TW_Q_LENGTH);
 576
 577         for (i=0;i<TW_Q_LENGTH;i++) {
 578                 switch(which) {
 579                 case 0:
 580                         tw_dev->command_packet_physical_address[i] = dma_handle+(i*size);
 581                         tw_dev->command_packet_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
 582                         break;
 583                 case 1:
 584                         tw_dev->alignment_physical_address[i] = dma_handle+(i*size);
 585                         tw_dev->alignment_virtual_address[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
 586                         break;
 587                 default:
 588                         printk(KERN_WARNING "3w-xxxx: tw_allocate_memory(): case slip in tw_allocate_memory()\n");
 589                         return 1;
 590                 }
 591         }
 592
 593         return 0;
 594 } /* End tw_allocate_memory() */
 595
 596 /* This function will check the status register for unexpected bits */
 597 int tw_check_bits(u32 status_reg_value)
 598 {
 599         if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS) {
 600                 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): No expected bits (0x%x).\n", status_reg_value);
 601                 return 1;
 602         }
 603         if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0) {
 604                 dprintk(KERN_WARNING "3w-xxxx: tw_check_bits(): Found unexpected bits (0x%x).\n", status_reg_value);
 605                 return 1;
 606         }
 607
 608         return 0;
 609 } /* End tw_check_bits() */
 610
 611 /* This function will report controller error status */
 612 int tw_check_errors(TW_Device_Extension *tw_dev)
 613 {
 614         u32 status_reg_addr, status_reg_value;
 615
 616         status_reg_addr = tw_dev->registers.status_reg_addr;
 617         status_reg_value = inl(status_reg_addr);
 618
 619         if (TW_STATUS_ERRORS(status_reg_value) || tw_check_bits(status_reg_value)) {
 620                 tw_decode_bits(tw_dev, status_reg_value, 0);
 621                 return 1;
 622         }
 623
 624         return 0;
 625 } /* End tw_check_errors() */
 626
 627 /* This function handles ioctl for the character device */
 628 static int tw_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 629 {
 630         int error, request_id;
 631         dma_addr_t dma_handle;
 632         unsigned short tw_aen_code;
 633         unsigned long flags;
 634         unsigned int data_buffer_length = 0;
 635         unsigned long data_buffer_length_adjusted = 0;
 636         unsigned long *cpu_addr;
 637         long timeout;
 638         TW_New_Ioctl *tw_ioctl;
 639         TW_Passthru *passthru;
 640         TW_Device_Extension *tw_dev = tw_device_extension_list[iminor(inode)];
 641         int retval = -EFAULT;
 642
 643         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl()\n");
 644
 645         /* Only let one of these through at a time */
 646         if (down_interruptible(&tw_dev->ioctl_sem))
 647                 return -EINTR;
 648
 649         /* First copy down the buffer length */
 650         error = copy_from_user(&data_buffer_length, (void *)arg, sizeof(unsigned int));
 651         if (error)
 652                 goto out;
 653
 654         /* Check size */
 655         if (data_buffer_length > TW_MAX_SECTORS * 512) {
 656                 retval = -EINVAL;
 657                 goto out;
 658         }
 659
 660         /* Hardware can only do multiple of 512 byte transfers */
 661         data_buffer_length_adjusted = (data_buffer_length + 511) & ~511;
 662
 663         /* Now allocate ioctl buf memory */
 664         cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, &dma_handle);
 665         if (cpu_addr == NULL) {
 666                 retval = -ENOMEM;
 667                 goto out;
 668         }
 669
 670         tw_ioctl = (TW_New_Ioctl *)cpu_addr;
 671
 672         /* Now copy down the entire ioctl */
 673         error = copy_from_user(tw_ioctl, (void *)arg, data_buffer_length + sizeof(TW_New_Ioctl) - 1);
 674         if (error)
 675                 goto out2;
 676
 677         passthru = (TW_Passthru *)&tw_ioctl->firmware_command;
 678
 679         /* See which ioctl we are doing */
 680         switch (cmd) {
 681                 case TW_OP_NOP:
 682                         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_OP_NOP.\n");
 683                         break;
 684                 case TW_OP_AEN_LISTEN:
 685                         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_AEN_LISTEN.\n");
 686                         memset(tw_ioctl->data_buffer, 0, tw_ioctl->data_buffer_length);
 687
 688                         spin_lock_irqsave(tw_dev->host->host_lock, flags);
 689                         if (tw_dev->aen_head == tw_dev->aen_tail) {
 690                                 tw_aen_code = TW_AEN_QUEUE_EMPTY;
 691                         } else {
 692                                 tw_aen_code = tw_dev->aen_queue[tw_dev->aen_head];
 693                                 if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
 694                                         tw_dev->aen_head = TW_Q_START;
 695                                 } else {
 696                                         tw_dev->aen_head = tw_dev->aen_head + 1;
 697                                 }
 698                         }
 699                         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 700                         memcpy(tw_ioctl->data_buffer, &tw_aen_code, sizeof(tw_aen_code));
 701                         break;
 702                 case TW_CMD_PACKET_WITH_DATA:
 703                         dprintk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n");
 704                         spin_lock_irqsave(&tw_dev->tw_lock, flags);
 705
 706                         tw_state_request_start(tw_dev, &request_id);
 707
 708                         /* Flag internal command */
 709                         tw_dev->srb[request_id] = 0;
 710
 711                         /* Flag chrdev ioctl */
 712                         tw_dev->chrdev_request_id = request_id;
 713
 714                         tw_ioctl->firmware_command.request_id = request_id;
 715
 716                         /* Load the sg list */
 717                         switch (tw_ioctl->firmware_command.byte0.sgl_offset) {
 718                         case 2:
 719                                 tw_ioctl->firmware_command.byte8.param.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
 720                                 tw_ioctl->firmware_command.byte8.param.sgl[0].length = data_buffer_length_adjusted;
 721                                 break;
 722                         case 3:
 723                                 tw_ioctl->firmware_command.byte8.io.sgl[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
 724                                 tw_ioctl->firmware_command.byte8.io.sgl[0].length = data_buffer_length_adjusted;
 725                                 break;
 726                         case 5:
 727                                 passthru->sg_list[0].address = dma_handle + sizeof(TW_New_Ioctl) - 1;
 728                                 passthru->sg_list[0].length = data_buffer_length_adjusted;
 729                                 break;
 730                         }
 731
 732                         memcpy(tw_dev->command_packet_virtual_address[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command));
 733
 734                         /* Now post the command packet to the controller */
 735                         tw_post_command_packet(tw_dev, request_id);
 736                         spin_unlock_irqrestore(&tw_dev->tw_lock, flags);
 737
 738                         timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
 739
 740                         /* Now wait for the command to complete */
 741                         wait_event_interruptible_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
 742
 743                         /* Check if we timed out, got a signal, or didn't get
 744                            an interrupt */
 745                         if ((timeout <= 0) && (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE)) {
 746                                 /* Now we need to reset the board */
 747                                 if (timeout == -ERESTARTSYS) {
 748                                         retval = timeout;
 749                                 } else {
 750                                         printk(KERN_WARNING "3w-xxxx: scsi%d: Character ioctl (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, cmd);
 751                                         retval = -EIO;
 752                                 }
 753                                 spin_lock_irqsave(&tw_dev->tw_lock, flags);
 754                                 tw_dev->state[request_id] = TW_S_COMPLETED;
 755                                 tw_state_request_finish(tw_dev, request_id);
 756                                 tw_dev->posted_request_count--;
 757                                 if (tw_reset_device_extension(tw_dev)) {
 758                                         printk(KERN_WARNING "3w-xxxx: tw_chrdev_ioctl(): Reset failed for card %d.\n", tw_dev->host->host_no);
 759                                 }
 760                                 spin_unlock_irqrestore(&tw_dev->tw_lock, flags);
 761                                 goto out2;
 762                         }
 763
 764                         /* Now copy in the command packet response */
 765                         memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command));
 766
 767                         /* Now complete the io */
 768                         spin_lock_irqsave(&tw_dev->tw_lock, flags);
 769                         tw_dev->posted_request_count--;
 770                         tw_dev->state[request_id] = TW_S_COMPLETED;
 771                         tw_state_request_finish(tw_dev, request_id);
 772                         spin_unlock_irqrestore(&tw_dev->tw_lock, flags);
 773                         break;
 774                 default:
 775                         retval = -ENOTTY;
 776                         goto out2;
 777         }
 778
 779         /* Now copy the response to userspace */
 780         error = copy_to_user((void *)arg, tw_ioctl, sizeof(TW_New_Ioctl) + tw_ioctl->data_buffer_length - 1);
 781         if (error == 0)
 782                 retval = 0;
 783 out2:
 784         /* Now free ioctl buf memory */
 785         pci_free_consistent(tw_dev->tw_pci_dev, data_buffer_length_adjusted+sizeof(TW_New_Ioctl) - 1, cpu_addr, dma_handle);
 786 out:
 787         up(&tw_dev->ioctl_sem);
 788         return retval;
 789 } /* End tw_chrdev_ioctl() */
 790
 791 /* This function handles open for the character device */
 792 static int tw_chrdev_open(struct inode *inode, struct file *file)
 793 {
 794         unsigned int minor_number;
 795
 796         dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_open()\n");
 797
 798         minor_number = iminor(inode);
 799         if (minor_number >= tw_device_extension_count)
 800                 return -ENODEV;
 801
 802         return 0;
 803 } /* End tw_chrdev_open() */
 804
 805 /* This function handles close for the character device */
 806 static int tw_chrdev_release(struct inode *inode, struct file *file)
 807 {
 808         dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_release()\n");
 809
 810         return 0;
 811 } /* End tw_chrdev_release() */
 812
 813 /* This function will clear all interrupts on the controller */
 814 void tw_clear_all_interrupts(TW_Device_Extension *tw_dev)
 815 {
 816         u32 control_reg_addr, control_reg_value;
 817
 818         control_reg_addr = tw_dev->registers.control_reg_addr;
 819         control_reg_value = TW_STATUS_VALID_INTERRUPT;
 820         outl(control_reg_value, control_reg_addr);
 821 } /* End tw_clear_all_interrupts() */
 822
 823 /* This function will clear the attention interrupt */
 824 void tw_clear_attention_interrupt(TW_Device_Extension *tw_dev)
 825 {
 826         u32 control_reg_addr, control_reg_value;
 827
 828         control_reg_addr = tw_dev->registers.control_reg_addr;
 829         control_reg_value = TW_CONTROL_CLEAR_ATTENTION_INTERRUPT;
 830         outl(control_reg_value, control_reg_addr);
 831 } /* End tw_clear_attention_interrupt() */
 832
 833 /* This function will clear the host interrupt */
 834 void tw_clear_host_interrupt(TW_Device_Extension *tw_dev)
 835 {
 836         u32 control_reg_addr, control_reg_value;
 837
 838         control_reg_addr = tw_dev->registers.control_reg_addr;
 839         control_reg_value = TW_CONTROL_CLEAR_HOST_INTERRUPT;
 840         outl(control_reg_value, control_reg_addr);
 841 } /* End tw_clear_host_interrupt() */
 842
 843 /* This function is called by tw_scsi_proc_info */
 844 static int tw_copy_info(TW_Info *info, char *fmt, ...)
 845 {
 846         va_list args;
 847         char buf[81];
 848         int len;
 849
 850         va_start(args, fmt);
 851         len = vsprintf(buf, fmt, args);
 852         va_end(args);
 853         tw_copy_mem_info(info, buf, len);
 854         return len;
 855 } /* End tw_copy_info() */
 856
 857 /* This function is called by tw_scsi_proc_info */
 858 static void tw_copy_mem_info(TW_Info *info, char *data, int len)
 859 {
 860         if (info->position + len > info->length)
 861                 len = info->length - info->position;
 862
 863         if (info->position + len < info->offset) {
 864                 info->position += len;
 865                 return;
 866         }
 867         if (info->position < info->offset) {
 868                 data += (info->offset - info->position);
 869                 len  -= (info->offset - info->position);
 870         }
 871         if (len > 0) {
 872                 memcpy(info->buffer + info->position, data, len);
 873                 info->position += len;
 874         }
 875 } /* End tw_copy_mem_info() */
 876
 877 /* This function will print readable messages from status register errors */
 878 int tw_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value, int print_host)
 879 {
 880         char host[16];
 881
 882         dprintk(KERN_WARNING "3w-xxxx: tw_decode_bits()\n");
 883
 884         if (print_host)
 885                 sprintf(host, " scsi%d:", tw_dev->host->host_no);
 886         else
 887                 host[0] = '\0';
 888
 889         if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
 890                 printk(KERN_WARNING "3w-xxxx:%s PCI Parity Error: clearing.\n", host);
 891                 outl(TW_CONTROL_CLEAR_PARITY_ERROR, tw_dev->registers.control_reg_addr);
 892         }
 893
 894         if (status_reg_value & TW_STATUS_PCI_ABORT) {
 895                 printk(KERN_WARNING "3w-xxxx:%s PCI Abort: clearing.\n", host);
 896                 outl(TW_CONTROL_CLEAR_PCI_ABORT, tw_dev->registers.control_reg_addr);
 897                 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
 898         }
 899
 900         if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
 901                 printk(KERN_WARNING "3w-xxxx:%s Controller Queue Error: clearing.\n", host);
 902                 outl(TW_CONTROL_CLEAR_QUEUE_ERROR, tw_dev->registers.control_reg_addr);
 903         }
 904
 905         if (status_reg_value & TW_STATUS_SBUF_WRITE_ERROR) {
 906                 printk(KERN_WARNING "3w-xxxx:%s SBUF Write Error: clearing.\n", host);
 907                 outl(TW_CONTROL_CLEAR_SBUF_WRITE_ERROR, tw_dev->registers.control_reg_addr);
 908         }
 909
 910         if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
 911                 if (tw_dev->reset_print == 0) {
 912                         printk(KERN_WARNING "3w-xxxx:%s Microcontroller Error: clearing.\n", host);
 913                         tw_dev->reset_print = 1;
 914                 }
 915                 return 1;
 916         }
 917
 918         return 0;
 919 } /* End tw_decode_bits() */
 920
 921 /* This function will return valid sense buffer information for failed cmds */
 922 int tw_decode_sense(TW_Device_Extension *tw_dev, int request_id, int fill_sense)
 923 {
 924         int i;
 925         TW_Command *command;
 926
 927         dprintk(KERN_WARNING "3w-xxxx: tw_decode_sense()\n");
 928         command = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
 929
 930         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, command->byte3.unit);
 931
 932         /* Attempt to return intelligent sense information */
 933         if (fill_sense) {
 934                 if ((command->status == 0xc7) || (command->status == 0xcb)) {
 935                         for (i=0;i<(sizeof(tw_sense_table)/sizeof(tw_sense_table[0]));i++) {
 936                                 if (command->flags == tw_sense_table[i][0]) {
 937
 938                                         /* Valid bit and 'current errors' */
 939                                         tw_dev->srb[request_id]->sense_buffer[0] = (0x1 << 7 | 0x70);
 940
 941                                         /* Sense key */
 942                                         tw_dev->srb[request_id]->sense_buffer[2] = tw_sense_table[i][1];
 943
 944                                         /* Additional sense length */
 945                                         tw_dev->srb[request_id]->sense_buffer[7] = 0xa; /* 10 bytes */
 946
 947                                         /* Additional sense code */
 948                                         tw_dev->srb[request_id]->sense_buffer[12] = tw_sense_table[i][2];
 949
 950                                         /* Additional sense code qualifier */
 951                                         tw_dev->srb[request_id]->sense_buffer[13] = tw_sense_table[i][3];
 952
 953                                         tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
 954                                         return TW_ISR_DONT_RESULT; /* Special case for isr to not over-write result */
 955                                 }
 956                         }
 957                 }
 958
 959                 /* If no table match, error so we get a reset */
 960                 return 1;
 961         }
 962
 963         return 0;
 964 } /* End tw_decode_sense() */
 965
 966 /* This function will disable interrupts on the controller */
 967 void tw_disable_interrupts(TW_Device_Extension *tw_dev)
 968 {
 969         u32 control_reg_value, control_reg_addr;
 970
 971         control_reg_addr = tw_dev->registers.control_reg_addr;
 972         control_reg_value = TW_CONTROL_DISABLE_INTERRUPTS;
 973         outl(control_reg_value, control_reg_addr);
 974 } /* End tw_disable_interrupts() */
 975
 976 /* This function will empty the response que */
 977 void tw_empty_response_que(TW_Device_Extension *tw_dev)
 978 {
 979         u32 status_reg_addr, status_reg_value;
 980         u32 response_que_addr, response_que_value;
 981
 982         status_reg_addr = tw_dev->registers.status_reg_addr;
 983         response_que_addr = tw_dev->registers.response_que_addr;
 984
 985         status_reg_value = inl(status_reg_addr);
 986
 987         while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
 988                 response_que_value = inl(response_que_addr);
 989                 status_reg_value = inl(status_reg_addr);
 990         }
 991 } /* End tw_empty_response_que() */
 992
 993 /* This function will enable interrupts on the controller */
 994 void tw_enable_interrupts(TW_Device_Extension *tw_dev)
 995 {
 996         u32 control_reg_value, control_reg_addr;
 997
 998         control_reg_addr = tw_dev->registers.control_reg_addr;
 999         control_reg_value = (TW_CONTROL_ENABLE_INTERRUPTS |
1000                              TW_CONTROL_UNMASK_RESPONSE_INTERRUPT);
1001         outl(control_reg_value, control_reg_addr);
1002 } /* End tw_enable_interrupts() */
1003
1004 /* This function will enable interrupts on the controller */
1005 void tw_enable_and_clear_interrupts(TW_Device_Extension *tw_dev)
1006 {
1007         u32 control_reg_value, control_reg_addr;
1008
1009         control_reg_addr = tw_dev->registers.control_reg_addr;
1010         control_reg_value = (TW_CONTROL_CLEAR_ATTENTION_INTERRUPT |
1011                              TW_CONTROL_UNMASK_RESPONSE_INTERRUPT |
1012                              TW_CONTROL_ENABLE_INTERRUPTS);
1013         outl(control_reg_value, control_reg_addr);
1014 } /* End tw_enable_and_clear_interrupts() */
1015
1016 /* This function will find and initialize all cards */
1017 int tw_findcards(Scsi_Host_Template *tw_host)
1018 {
1019         int numcards = 0, tries = 0, error = 0;
1020         struct Scsi_Host *host;
1021         TW_Device_Extension *tw_dev;
1022         TW_Device_Extension *tw_dev2;
1023         struct pci_dev *tw_pci_dev = NULL;
1024         u32 status_reg_value;
1025         unsigned char c = 1;
1026         int i, j = -1;
1027         u16 device[TW_NUMDEVICES] = { TW_DEVICE_ID, TW_DEVICE_ID2 };
1028
1029         dprintk(KERN_NOTICE "3w-xxxx: tw_findcards()\n");
1030
1031         for (i=0;i<TW_NUMDEVICES;i++) {
1032                 while ((tw_pci_dev = pci_find_device(TW_VENDOR_ID, device[i], tw_pci_dev))) {
1033                         j++;
1034                         if (pci_enable_device(tw_pci_dev))
1035                                 continue;
1036
1037                         /* We only need 32-bit addressing for 5,6,7xxx cards */
1038                         if (pci_set_dma_mask(tw_pci_dev, 0xffffffff)) {
1039                                 printk(KERN_WARNING "3w-xxxx: No suitable DMA available.\n");
1040                                 continue;
1041                         }
1042
1043                         /* Prepare temporary device extension */
1044                         tw_dev=(TW_Device_Extension *)kmalloc(sizeof(TW_Device_Extension), GFP_ATOMIC);
1045                         if (tw_dev == NULL) {
1046                                 printk(KERN_WARNING "3w-xxxx: tw_findcards(): kmalloc() failed for card %d.\n", j);
1047                                 continue;
1048                         }
1049                         memset(tw_dev, 0, sizeof(TW_Device_Extension));
1050
1051                         /* Save pci_dev struct to device extension */
1052                         tw_dev->tw_pci_dev = tw_pci_dev;
1053
1054                         error = tw_initialize_device_extension(tw_dev);
1055                         if (error) {
1056                                 printk(KERN_WARNING "3w-xxxx: tw_findcards(): Couldn't initialize device extension for card %d.\n", j);
1057                                 tw_free_device_extension(tw_dev);
1058                                 kfree(tw_dev);
1059                                 continue;
1060                         }
1061
1062                         /* Calculate the cards register addresses */
1063                         tw_dev->registers.base_addr = pci_resource_start(tw_pci_dev, 0);
1064                         tw_dev->registers.control_reg_addr = pci_resource_start(tw_pci_dev, 0);
1065                         tw_dev->registers.status_reg_addr = pci_resource_start(tw_pci_dev, 0) + 0x4;
1066                         tw_dev->registers.command_que_addr = pci_resource_start(tw_pci_dev, 0) + 0x8;
1067                         tw_dev->registers.response_que_addr = pci_resource_start(tw_pci_dev, 0) + 0xC;
1068
1069                         /* Check for errors and clear them */
1070                         status_reg_value = inl(tw_dev->registers.status_reg_addr);
1071                         if (TW_STATUS_ERRORS(status_reg_value))
1072                                 tw_decode_bits(tw_dev, status_reg_value, 0);
1073
1074                         /* Poll status register for 60 secs for 'Controller Ready' flag */
1075                         if (tw_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY, 60)) {
1076                                 printk(KERN_WARNING "3w-xxxx: tw_findcards(): Microcontroller not ready for card %d.\n", j);
1077                                 tw_free_device_extension(tw_dev);
1078                                 kfree(tw_dev);
1079                                 continue;
1080                         }
1081
1082                         /* Disable interrupts on the card */
1083                         tw_disable_interrupts(tw_dev);
1084
1085                         tries = 0;
1086
1087                         while (tries < TW_MAX_RESET_TRIES) {
1088                                 /* Do soft reset */
1089                                 tw_soft_reset(tw_dev);
1090
1091                                 error = tw_aen_drain_queue(tw_dev);
1092                                 if (error) {
1093                                         printk(KERN_WARNING "3w-xxxx: AEN drain failed for card %d.\n", j);
1094                                         tries++;
1095                                         continue;
1096                                 }
1097
1098                                 /* Check for controller errors */
1099                                 if (tw_check_errors(tw_dev)) {
1100                                         printk(KERN_WARNING "3w-xxxx: Controller errors found, retrying for card %d.\n", j);
1101                                         tries++;
1102                                         continue;
1103                                 }
1104
1105                                 /* Now the controller is in a good state */
1106                                 break;
1107                         }
1108
1109                         if (tries >= TW_MAX_RESET_TRIES) {
1110                                 printk(KERN_WARNING "3w-xxxx: Controller errors, card not responding, check all cabling for card %d.\n", j);
1111                                 tw_free_device_extension(tw_dev);
1112                                 kfree(tw_dev);
1113                                 continue;
1114                         }
1115
1116                         /* Reserve the io address space */
1117                         if (!request_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE, TW_DEVICE_NAME)) {
1118                                 printk(KERN_WARNING "3w-xxxx: tw_findcards(): Couldn't get io range 0x%lx-0x%lx for card %d.\n",
1119                                        (tw_dev->tw_pci_dev->resource[0].start),
1120                                        (tw_dev->tw_pci_dev->resource[0].start) +
1121                                        TW_IO_ADDRESS_RANGE, j);
1122                                 tw_free_device_extension(tw_dev);
1123                                 kfree(tw_dev);
1124                                 continue;
1125                         }
1126
1127                         error = tw_initialize_units(tw_dev);
1128                         if (error) {
1129                                 printk(KERN_WARNING "3w-xxxx: No valid units for for card %d.\n", j);
1130                         }
1131
1132                         error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS);
1133                         if (error) {
1134                                 printk(KERN_WARNING "3w-xxxx: Connection initialization failed for card %d.\n", j);
1135                                 release_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE);
1136                                 tw_free_device_extension(tw_dev);
1137                                 kfree(tw_dev);
1138                                 continue;
1139                         }
1140
1141                         /* Set card status as online */
1142                         tw_dev->online = 1;
1143
1144 #ifdef CONFIG_3W_XXXX_CMD_PER_LUN
1145                         tw_host->cmd_per_lun = CONFIG_3W_XXXX_CMD_PER_LUN;
1146                         if (tw_host->cmd_per_lun > TW_MAX_CMDS_PER_LUN)
1147                                 tw_host->cmd_per_lun = TW_MAX_CMDS_PER_LUN;
1148 #else
1149                         /* Use SHT cmd_per_lun here */
1150                         tw_host->cmd_per_lun = TW_MAX_CMDS_PER_LUN;
1151 #endif
1152                         tw_dev->free_head = TW_Q_START;
1153                         tw_dev->free_tail = TW_Q_START;
1154                         tw_dev->free_wrap = TW_Q_LENGTH - 1;
1155
1156                         /* Register the card with the kernel SCSI layer */
1157                         host = scsi_register(tw_host, sizeof(TW_Device_Extension));
1158                         if (host == NULL) {
1159                                 printk(KERN_WARNING "3w-xxxx: tw_findcards(): scsi_register() failed for card %d.\n", j);
1160                                 release_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE);
1161                                 tw_free_device_extension(tw_dev);
1162                                 kfree(tw_dev);
1163                                 continue;
1164                         }
1165
1166                         /* Set max target id's */
1167                         host->max_id = TW_MAX_UNITS;
1168
1169                         /* Set max cdb size in bytes */
1170                         host->max_cmd_len = 16;
1171
1172                         /* Set max sectors per io */
1173 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,7)
1174                         host->max_sectors = TW_MAX_SECTORS;
1175 #endif
1176
1177 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)
1178                         scsi_set_device(host, &tw_pci_dev->dev);
1179 #elif LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,4)
1180                         scsi_set_pci_device(host, tw_pci_dev);
1181 #endif
1182
1183                         status_reg_value = inl(tw_dev->registers.status_reg_addr);
1184
1185                         printk(KERN_NOTICE "scsi%d : Found a 3ware Storage Controller at 0x%x, IRQ: %d, P-chip: %d.%d\n", host->host_no,
1186                                 (u32)(tw_pci_dev->resource[0].start), tw_pci_dev->irq,
1187                                 (status_reg_value & TW_STATUS_MAJOR_VERSION_MASK) >> 28,
1188                                 (status_reg_value & TW_STATUS_MINOR_VERSION_MASK) >> 24);
1189
1190                         if (host->hostdata) {
1191                                 tw_dev2 = (TW_Device_Extension *)host->hostdata;
1192                                 memcpy(tw_dev2, tw_dev, sizeof(TW_Device_Extension));
1193                                 /* Need to init the sem/wqueue after the copy */
1194                                 init_MUTEX(&tw_dev2->ioctl_sem);
1195                                 init_waitqueue_head(&tw_dev2->ioctl_wqueue);
1196
1197                                 tw_device_extension_list[tw_device_extension_count] = tw_dev2;
1198                                 numcards++;
1199                                 tw_device_extension_count = numcards;
1200                                 tw_dev2->host = host;
1201                         } else {
1202                                 printk(KERN_WARNING "3w-xxxx: tw_findcards(): Bad scsi host data for card %d.\n", j);
1203                                 scsi_unregister(host);
1204                                 release_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE);
1205                                 tw_free_device_extension(tw_dev);
1206                                 kfree(tw_dev);
1207                                 continue;
1208                         }
1209
1210                         /* Tell the firmware we support shutdown notification*/
1211                         error = tw_setfeature(tw_dev2, 2, 1, &c);
1212                         if (error) {
1213                                 printk(KERN_WARNING "3w-xxxx: Unable to set features for card %d, old firmware or card.\n", j);
1214                         }
1215
1216                         /* Now setup the interrupt handler */
1217                         error = tw_setup_irq(tw_dev2);
1218                         if (error) {
1219                                 printk(KERN_WARNING "3w-xxxx: tw_findcards(): Error requesting irq for card %d.\n", j);
1220                                 scsi_unregister(host);
1221                                 release_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE);
1222
1223                                 tw_free_device_extension(tw_dev);
1224                                 kfree(tw_dev);
1225                                 numcards--;
1226                                 continue;
1227                         }
1228
1229                         /* Re-enable interrupts on the card */
1230                         tw_enable_interrupts(tw_dev2);
1231
1232                         /* Free the temporary device extension */
1233                         if (tw_dev)
1234                                 kfree(tw_dev);
1235                 }
1236         }
1237
1238         if (numcards == 0) {
1239                 printk(KERN_WARNING "3w-xxxx: No cards found.\n");
1240         } else {
1241                 register_reboot_notifier(&tw_notifier);
1242                 if ((twe_major = register_chrdev (0, "twe", &tw_fops)) < 0) {
1243                         printk(KERN_WARNING "3w-xxxx: Unable to register \"twe\" character device, error = %d.\n", twe_major);
1244                 }
1245         }
1246
1247         return numcards;
1248 } /* End tw_findcards() */
1249
1250 /* This function will free up device extension resources */
1251 void tw_free_device_extension(TW_Device_Extension *tw_dev)
1252 {
1253         dprintk(KERN_NOTICE "3w-xxxx: tw_free_device_extension()\n");
1254
1255         /* Free command packet and generic buffer memory */
1256         if (tw_dev->command_packet_virtual_address[0])
1257                 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]);
1258
1259         if (tw_dev->alignment_virtual_address[0])
1260                 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]);
1261 } /* End tw_free_device_extension() */
1262
1263 /* Clean shutdown routine */
1264 static int tw_halt(struct notifier_block *nb, ulong event, void *buf)
1265 {
1266         int i;
1267
1268         for (i=0;i<tw_device_extension_count;i++) {
1269                 if (tw_device_extension_list[i]->online == 1) {
1270                         printk(KERN_NOTICE "3w-xxxx: Shutting down card %d.\n", i);
1271                         tw_shutdown_device(tw_device_extension_list[i]);
1272                         tw_device_extension_list[i]->online = 0;
1273                 }
1274         }
1275         unregister_reboot_notifier(&tw_notifier);
1276
1277         return NOTIFY_OK;
1278 } /* End tw_halt() */
1279
1280 /* This function will send an initconnection command to controller */
1281 int tw_initconnection(TW_Device_Extension *tw_dev, int message_credits)
1282 {
1283         unsigned long command_que_value;
1284         u32 command_que_addr;
1285         u32 response_que_addr;
1286         TW_Command  *command_packet;
1287         TW_Response_Queue response_queue;
1288         int request_id = 0;
1289
1290         dprintk(KERN_NOTICE "3w-xxxx: tw_initconnection()\n");
1291         command_que_addr = tw_dev->registers.command_que_addr;
1292         response_que_addr = tw_dev->registers.response_que_addr;
1293
1294         /* Initialize InitConnection command packet */
1295         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
1296                 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet virtual address.\n");
1297                 return 1;
1298         }
1299
1300         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1301         memset(command_packet, 0, sizeof(TW_Sector));
1302         command_packet->byte0.opcode = TW_OP_INIT_CONNECTION;
1303         command_packet->byte0.sgl_offset = 0x0;
1304         command_packet->size = TW_INIT_COMMAND_PACKET_SIZE;
1305         command_packet->request_id = request_id;
1306         command_packet->byte3.unit = 0x0;
1307         command_packet->byte3.host_id = 0x0;
1308         command_packet->status = 0x0;
1309         command_packet->flags = 0x0;
1310         command_packet->byte6.message_credits = message_credits;
1311         command_packet->byte8.init_connection.response_queue_pointer = 0x0;
1312         command_que_value = tw_dev->command_packet_physical_address[request_id];
1313
1314         if (command_que_value == 0) {
1315                 printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Bad command packet physical address.\n");
1316                 return 1;
1317         }
1318
1319         /* Send command packet to the board */
1320         outl(command_que_value, command_que_addr);
1321
1322         /* Poll for completion */
1323         if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1324                 response_queue.value = inl(response_que_addr);
1325                 request_id = (unsigned char)response_queue.u.response_id;
1326                 if (request_id != 0) {
1327                         /* unexpected request id */
1328                         printk(KERN_WARNING "3w-xxxx: tw_initconnection(): Unexpected request id.\n");
1329                         return 1;
1330                 }
1331                 if (command_packet->status != 0) {
1332                         /* bad response */
1333                         tw_decode_sense(tw_dev, request_id, 0);
1334                         return 1;
1335                 }
1336         }
1337         return 0;
1338 } /* End tw_initconnection() */
1339
1340 /* This function will initialize the fields of a device extension */
1341 int tw_initialize_device_extension(TW_Device_Extension *tw_dev)
1342 {
1343         int i, error=0;
1344
1345         dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_device_extension()\n");
1346
1347         /* Initialize command packet buffers */
1348         error = tw_allocate_memory(tw_dev, sizeof(TW_Command), 0);
1349         if (error) {
1350                 printk(KERN_WARNING "3w-xxxx: Command packet memory allocation failed.\n");
1351                 return 1;
1352         }
1353
1354         /* Initialize generic buffer */
1355         error = tw_allocate_memory(tw_dev, sizeof(TW_Sector), 1);
1356         if (error) {
1357                 printk(KERN_WARNING "3w-xxxx: Generic memory allocation failed.\n");
1358                 return 1;
1359         }
1360
1361         for (i=0;i<TW_Q_LENGTH;i++) {
1362                 tw_dev->free_queue[i] = i;
1363                 tw_dev->state[i] = TW_S_INITIAL;
1364         }
1365
1366         tw_dev->pending_head = TW_Q_START;
1367         tw_dev->pending_tail = TW_Q_START;
1368         spin_lock_init(&tw_dev->tw_lock);
1369         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1370
1371         return 0;
1372 } /* End tw_initialize_device_extension() */
1373
1374 /* This function will get unit info from the controller */
1375 int tw_initialize_units(TW_Device_Extension *tw_dev)
1376 {
1377         int found = 0;
1378         unsigned char request_id = 0;
1379         TW_Command *command_packet;
1380         TW_Param *param;
1381         int i, imax, num_units = 0;
1382         unsigned long command_que_value;
1383         u32 command_que_addr;
1384         u32 response_que_addr;
1385         TW_Response_Queue response_queue;
1386         unsigned long param_value;
1387         unsigned char *is_unit_present;
1388
1389         dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_units()\n");
1390
1391         command_que_addr = tw_dev->registers.command_que_addr;
1392         response_que_addr = tw_dev->registers.response_que_addr;
1393
1394         /* Setup the command packet */
1395         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1396         if (command_packet == NULL) {
1397                 printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): Bad command packet virtual address.\n");
1398                 return 1;
1399         }
1400         memset(command_packet, 0, sizeof(TW_Sector));
1401         command_packet->byte0.opcode      = TW_OP_GET_PARAM;
1402         command_packet->byte0.sgl_offset  = 2;
1403         command_packet->size              = 4;
1404         command_packet->request_id        = request_id;
1405         command_packet->byte3.unit        = 0;
1406         command_packet->byte3.host_id     = 0;
1407         command_packet->status            = 0;
1408         command_packet->flags             = 0;
1409         command_packet->byte6.block_count = 1;
1410
1411         /* Now setup the param */
1412         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1413                 printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): Bad alignment virtual address.\n");
1414                 return 1;
1415         }
1416         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1417         memset(param, 0, sizeof(TW_Sector));
1418         param->table_id = 3;       /* unit summary table */
1419         param->parameter_id = 3;   /* unitstatus parameter */
1420         param->parameter_size_bytes = TW_MAX_UNITS;
1421         param_value = tw_dev->alignment_physical_address[request_id];
1422         if (param_value == 0) {
1423                 printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): Bad alignment physical address.\n");
1424                 return 1;
1425         }
1426
1427         command_packet->byte8.param.sgl[0].address = param_value;
1428         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
1429
1430         /* Post the command packet to the board */
1431         command_que_value = tw_dev->command_packet_physical_address[request_id];
1432         if (command_que_value == 0) {
1433                 printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): Bad command packet physical address.\n");
1434                 return 1;
1435         }
1436         outl(command_que_value, command_que_addr);
1437
1438         /* Poll for completion */
1439         if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
1440                 response_queue.value = inl(response_que_addr);
1441                 request_id = (unsigned char)response_queue.u.response_id;
1442                 if (request_id != 0) {
1443                         /* unexpected request id */
1444                         printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): Unexpected request id.\n");
1445                         return 1;
1446                 }
1447                 if (command_packet->status != 0) {
1448                         /* bad response */
1449                         tw_decode_sense(tw_dev, request_id, 0);
1450                         return 1;
1451                 }
1452                 found = 1;
1453         }
1454         if (found == 0) {
1455                 /* response never received */
1456                 printk(KERN_WARNING "3w-xxxx: tw_initialize_units(): No response.\n");
1457                 return 1;
1458         }
1459
1460         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1461         is_unit_present = (unsigned char *)&(param->data[0]);
1462
1463         /* Show all units present */
1464         imax = TW_MAX_UNITS;
1465         for(i=0; i<imax; i++) {
1466                 if (is_unit_present[i] == 0) {
1467                         tw_dev->is_unit_present[i] = FALSE;
1468                 } else {
1469                   if (is_unit_present[i] & TW_UNIT_ONLINE) {
1470                         dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_units(): Unit %d found.\n", i);
1471                         tw_dev->is_unit_present[i] = TRUE;
1472                         num_units++;
1473                   }
1474                 }
1475         }
1476         tw_dev->num_units = num_units;
1477
1478         if (num_units == 0) {
1479                 dprintk(KERN_NOTICE "3w-xxxx: tw_initialize_units(): No units found.\n");
1480                 return 1;
1481         }
1482
1483         return 0;
1484 } /* End tw_initialize_units() */
1485
1486 /* This function is the interrupt service routine */
1487 static irqreturn_t tw_interrupt(int irq, void *dev_instance,
1488                                         struct pt_regs *regs)
1489 {
1490         int request_id;
1491         u32 status_reg_addr, status_reg_value;
1492         u32 response_que_addr;
1493         TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1494         TW_Response_Queue response_que;
1495         int error = 0, retval = 0;
1496         unsigned long flags = 0;
1497         TW_Command *command_packet;
1498         int handled = 0;
1499
1500         dprintk(KERN_WARNING "3w-xxxx: tw_interrupt()\n");
1501
1502         /* See if we are already running on another processor */
1503         if (test_and_set_bit(TW_IN_INTR, &tw_dev->flags))
1504                 return IRQ_NONE;
1505
1506         /* Get the host lock for io completions */
1507         spin_lock_irqsave(tw_dev->host->host_lock, flags);
1508
1509         /* See if the interrupt matches this instance */
1510         if (tw_dev->tw_pci_dev->irq == irq) {
1511
1512                 handled = 1;
1513                 /* Make sure io isn't queueing */
1514                 spin_lock(&tw_dev->tw_lock);
1515
1516                 /* Read the registers */
1517                 status_reg_addr = tw_dev->registers.status_reg_addr;
1518                 response_que_addr = tw_dev->registers.response_que_addr;
1519                 status_reg_value = inl(status_reg_addr);
1520
1521                 /* Check if this is our interrupt, otherwise bail */
1522                 if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1523                         goto tw_interrupt_bail;
1524
1525                 /* Check controller for errors */
1526                 if (tw_check_bits(status_reg_value)) {
1527                         dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
1528                         if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
1529                                 tw_clear_all_interrupts(tw_dev);
1530                                 goto tw_interrupt_bail;
1531                         }
1532                 }
1533
1534                 /* Handle host interrupt */
1535                 if (status_reg_value & TW_STATUS_HOST_INTERRUPT) {
1536                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received host interrupt.\n");
1537                         tw_clear_host_interrupt(tw_dev);
1538                 }
1539
1540                 /* Handle attention interrupt */
1541                 if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1542                         dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Received attention interrupt.\n");
1543                         tw_clear_attention_interrupt(tw_dev);
1544                         tw_state_request_start(tw_dev, &request_id);
1545                         error = tw_aen_read_queue(tw_dev, request_id);
1546                         if (error) {
1547                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Error reading aen queue.\n", tw_dev->host->host_no);
1548                                 tw_dev->state[request_id] = TW_S_COMPLETED;
1549                                 tw_state_request_finish(tw_dev, request_id);
1550                         }
1551                 }
1552
1553                 /* Handle command interrupt */
1554                 if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1555                         /* Drain as many pending commands as we can */
1556                         while (tw_dev->pending_request_count > 0) {
1557                                 request_id = tw_dev->pending_queue[tw_dev->pending_head];
1558                                 if (tw_dev->state[request_id] != TW_S_PENDING) {
1559                                         printk(KERN_WARNING "3w-xxxx: scsi%d: Found request id that wasn't pending.\n", tw_dev->host->host_no);
1560                                         break;
1561                                 }
1562                                 if (tw_post_command_packet(tw_dev, request_id)==0) {
1563                                         if (tw_dev->pending_head == TW_Q_LENGTH-1) {
1564                                                 tw_dev->pending_head = TW_Q_START;
1565                                         } else {
1566                                                 tw_dev->pending_head = tw_dev->pending_head + 1;
1567                                         }
1568                                         tw_dev->pending_request_count--;
1569                                 } else {
1570                                         /* If we get here, we will continue re-posting on the next command interrupt */
1571                                         break;
1572                                 }
1573                         }
1574                         /* If there are no more pending requests, we mask command interrupt */
1575                         if (tw_dev->pending_request_count == 0)
1576                                 tw_mask_command_interrupt(tw_dev);
1577                 }
1578
1579                 /* Handle response interrupt */
1580                 if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1581                         /* Drain the response queue from the board */
1582                         while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1583                                 /* Read response queue register */
1584                                 response_que.value = inl(response_que_addr);
1585                                 request_id = response_que.u.response_id;
1586                                 command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1587                                 error = 0;
1588
1589                                 /* Check for bad response */
1590                                 if (command_packet->status != 0) {
1591                                         /* If internal command, don't error, don't fill sense */
1592                                         if (tw_dev->srb[request_id] == 0) {
1593                                                 tw_decode_sense(tw_dev, request_id, 0);
1594                                         } else {
1595                                                 error = tw_decode_sense(tw_dev, request_id, 1);
1596                                         }
1597                                 }
1598
1599                                 /* Check for correct state */
1600                                 if (tw_dev->state[request_id] != TW_S_POSTED) {
1601                                         /* Handle timed out ioctl's */
1602                                         if (tw_dev->srb[request_id] != 0) {
1603                                                 if (tw_dev->srb[request_id]->cmnd[0] != TW_IOCTL) {
1604                                                         printk(KERN_WARNING "3w-xxxx: scsi%d: Received a request id (%d) (opcode = 0x%x) that wasn't posted.\n", tw_dev->host->host_no, request_id, command_packet->byte0.opcode);
1605                                                         error = 1;
1606                                                 }
1607                                         }
1608                                 }
1609
1610                                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): Response queue request id: %d.\n", request_id);
1611
1612                                 /* Check for internal command completion */
1613                                 if (tw_dev->srb[request_id] == 0) {
1614                                         dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Found internally posted command.\n");
1615                                         /* Check for chrdev ioctl completion */
1616                                         if (request_id != tw_dev->chrdev_request_id) {
1617                                                 retval = tw_aen_complete(tw_dev, request_id);
1618                                                 if (retval) {
1619                                                         printk(KERN_WARNING "3w-xxxx: scsi%d: Error completing aen.\n", tw_dev->host->host_no);
1620                                                 }
1621                                         } else {
1622                                                 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1623                                                 wake_up(&tw_dev->ioctl_wqueue);
1624                                         }
1625                                 } else {
1626                                 switch (tw_dev->srb[request_id]->cmnd[0]) {
1627                                         case READ_10:
1628                                         case READ_6:
1629                                                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_10/READ_6\n");
1630                                                 break;
1631                                         case WRITE_10:
1632                                         case WRITE_6:
1633                                                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught WRITE_10/WRITE_6\n");
1634                                                 break;
1635                                         case TEST_UNIT_READY:
1636                                                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TEST_UNIT_READY\n");
1637                                                 error = tw_scsiop_test_unit_ready_complete(tw_dev, request_id);
1638                                                 break;
1639                                         case INQUIRY:
1640                                                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught INQUIRY\n");
1641                                                 error = tw_scsiop_inquiry_complete(tw_dev, request_id);
1642                                                 break;
1643                                         case READ_CAPACITY:
1644                                                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught READ_CAPACITY\n");
1645                                                 error = tw_scsiop_read_capacity_complete(tw_dev, request_id);
1646                                                 break;
1647                                         case MODE_SENSE:
1648                                                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught MODE_SENSE\n");
1649                                                 error = tw_scsiop_mode_sense_complete(tw_dev, request_id);
1650                                                 break;
1651                                         case SYNCHRONIZE_CACHE:
1652                                                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught SYNCHRONIZE_CACHE\n");
1653                                                 break;
1654                                         case TW_IOCTL:
1655                                                 dprintk(KERN_NOTICE "3w-xxxx: tw_interrupt(): caught TW_IOCTL\n");
1656                                                 error = tw_ioctl_complete(tw_dev, request_id);
1657                                                 break;
1658                                         default:
1659                                                 printk(KERN_WARNING "3w-xxxx: case slip in tw_interrupt()\n");
1660                                                 error = 1;
1661                                         }
1662
1663                                         /* If no error command was a success */
1664                                         if (error == 0) {
1665                                                 tw_dev->srb[request_id]->result = (DID_OK << 16);
1666                                         }
1667
1668                                         /* If error, command failed */
1669                                         if (error == 1) {
1670                                                 /* Ask for a host reset */
1671                                                 tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
1672                                         }
1673
1674                                         /* Now complete the io */
1675                                         if ((error != TW_ISR_DONT_COMPLETE)) {
1676                                                 tw_dev->state[request_id] = TW_S_COMPLETED;
1677                                                 tw_state_request_finish(tw_dev, request_id);
1678                                                 tw_dev->posted_request_count--;
1679                                                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1680
1681                                                 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
1682                                         }
1683                                 }
1684
1685                                 /* Check for valid status after each drain */
1686                                 status_reg_value = inl(status_reg_addr);
1687                                 if (tw_check_bits(status_reg_value)) {
1688                                         dprintk(KERN_WARNING "3w-xxxx: tw_interrupt(): Unexpected bits.\n");
1689                                         if (tw_decode_bits(tw_dev, status_reg_value, 1)) {
1690                                                 tw_clear_all_interrupts(tw_dev);
1691                                                 goto tw_interrupt_bail;
1692                                         }
1693                                 }
1694                         }
1695                 }
1696 tw_interrupt_bail:
1697                 spin_unlock(&tw_dev->tw_lock);
1698         } else
1699                 dprintk(KERN_WARNING "3w-xxxx: tw_interrupt() called for wrong instance.\n");
1700
1701         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1702         clear_bit(TW_IN_INTR, &tw_dev->flags);
1703         return IRQ_RETVAL(handled);
1704 } /* End tw_interrupt() */
1705
1706 /* This function handles ioctls from userspace to the driver */
1707 int tw_ioctl(TW_Device_Extension *tw_dev, int request_id)
1708 {
1709         unsigned char opcode;
1710         int bufflen, error = 0;
1711         TW_Param *param;
1712         TW_Command *command_packet, *command_save;
1713         unsigned long param_value;
1714         TW_Ioctl *ioctl = NULL;
1715         TW_Passthru *passthru = NULL;
1716         int tw_aen_code, i, use_sg;
1717         unsigned long *data_ptr;
1718         int total_bytes = 0, posted = 0;
1719         dma_addr_t dma_handle;
1720         struct timeval before, timeout;
1721
1722         ioctl = (TW_Ioctl *)tw_dev->srb[request_id]->request_buffer;
1723         if (ioctl == NULL) {
1724                 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Request buffer NULL.\n");
1725                 tw_dev->state[request_id] = TW_S_COMPLETED;
1726                 tw_state_request_finish(tw_dev, request_id);
1727                 tw_dev->srb[request_id]->result = (DID_OK << 16);
1728                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1729                 return 0;
1730         }
1731         bufflen = tw_dev->srb[request_id]->request_bufflen;
1732
1733         /* Initialize command packet */
1734         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
1735         if (command_packet == NULL) {
1736                 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Bad command packet virtual address.\n");
1737                 tw_dev->state[request_id] = TW_S_COMPLETED;
1738                 tw_state_request_finish(tw_dev, request_id);
1739                 tw_dev->srb[request_id]->result = (DID_OK << 16);
1740                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1741                 return 0;
1742         }
1743         memset(command_packet, 0, sizeof(TW_Sector));
1744
1745         /* Initialize param */
1746         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
1747                 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Bad alignment virtual address.\n");
1748                 tw_dev->state[request_id] = TW_S_COMPLETED;
1749                 tw_state_request_finish(tw_dev, request_id);
1750                 tw_dev->srb[request_id]->result = (DID_OK << 16);
1751                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1752                 return 0;
1753         }
1754         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
1755         memset(param, 0, sizeof(TW_Sector));
1756
1757         dprintk(KERN_NOTICE "opcode = %d table_id = %d parameter_id = %d parameter_size_bytes = %d\n", ioctl->opcode, ioctl->table_id, ioctl->parameter_id, ioctl->parameter_size_bytes);
1758         opcode = ioctl->opcode;
1759
1760         switch (opcode) {
1761                 case TW_OP_NOP:
1762                         dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): caught TW_OP_NOP.\n");
1763                         command_packet->byte0.opcode = TW_OP_NOP;
1764                         break;
1765                 case TW_OP_GET_PARAM:
1766                         dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): caught TW_OP_GET_PARAM.\n");
1767                         command_packet->byte0.opcode = TW_OP_GET_PARAM;
1768                         command_packet->byte3.unit = ioctl->unit_index;
1769                         param->table_id = ioctl->table_id;
1770                         param->parameter_id = ioctl->parameter_id;
1771                         param->parameter_size_bytes = ioctl->parameter_size_bytes;
1772                         tw_dev->ioctl_size[request_id] = ioctl->parameter_size_bytes;
1773                         dprintk(KERN_NOTICE "table_id = %d parameter_id = %d parameter_size_bytes %d\n", param->table_id, param->parameter_id, param->parameter_size_bytes);
1774                         break;
1775                 case TW_OP_SET_PARAM:
1776                         dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): caught TW_OP_SET_PARAM: table_id = %d, parameter_id = %d, parameter_size_bytes = %d.\n",
1777                         ioctl->table_id, ioctl->parameter_id, ioctl->parameter_size_bytes);
1778                         if (ioctl->data != NULL) {
1779                                 command_packet->byte0.opcode = TW_OP_SET_PARAM;
1780                                 param->table_id = ioctl->table_id;
1781                                 param->parameter_id = ioctl->parameter_id;
1782                                 param->parameter_size_bytes = ioctl->parameter_size_bytes;
1783                                 memcpy(param->data, ioctl->data, ioctl->parameter_size_bytes);
1784                                 break;
1785                         } else {
1786                                 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): ioctl->data NULL.\n");
1787                                 return 1;
1788                         }
1789                 case TW_OP_AEN_LISTEN:
1790                         dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): caught TW_OP_AEN_LISTEN.\n");
1791                         if (tw_dev->aen_head == tw_dev->aen_tail) {
1792                                 /* aen queue empty */
1793                                 dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): Aen queue empty.\n");
1794                                 tw_aen_code = TW_AEN_QUEUE_EMPTY;
1795                                 memcpy(tw_dev->srb[request_id]->request_buffer, &tw_aen_code, ioctl->parameter_size_bytes);
1796                         } else {
1797                                 /* Copy aen queue entry to request buffer */
1798                                 dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl(): Returning aen 0x%x\n", tw_dev->aen_queue[tw_dev->aen_head]);
1799                                 tw_aen_code = tw_dev->aen_queue[tw_dev->aen_head];
1800                                 memcpy(tw_dev->srb[request_id]->request_buffer, &tw_aen_code, ioctl->parameter_size_bytes);
1801                                 if (tw_dev->aen_head == TW_Q_LENGTH - 1) {
1802                                         tw_dev->aen_head = TW_Q_START;
1803                                 } else {
1804                                         tw_dev->aen_head = tw_dev->aen_head + 1;
1805                                 }
1806                         }
1807                         tw_dev->state[request_id] = TW_S_COMPLETED;
1808                         tw_state_request_finish(tw_dev, request_id);
1809                         tw_dev->srb[request_id]->result = (DID_OK << 16);
1810                         tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1811                         return 0;
1812                 case TW_ATA_PASSTHRU:
1813                         if (ioctl->data != NULL) {
1814                                 memcpy(command_packet, ioctl->data, sizeof(TW_Command));
1815                                 command_packet->request_id = request_id;
1816                         } else {
1817                                 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): ioctl->data NULL.\n");
1818                                 return 1;
1819                         }
1820
1821                         passthru = (TW_Passthru *)tw_dev->command_packet_virtual_address[request_id];
1822                         /* Don't load sg_list for non-data ATA cmds */
1823                         if ((passthru->param != 0) && (passthru->param != 0x8)) {
1824                                 passthru->sg_list[0].length = passthru->sector_count*512;
1825                                 if (passthru->sg_list[0].length > TW_MAX_PASSTHRU_BYTES) {
1826                                         printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Passthru size (%d) too big.\n", passthru->sg_list[0].length);
1827                                         return 1;
1828                                 }
1829                                 passthru->sg_list[0].address = tw_dev->alignment_physical_address[request_id];
1830                         }
1831                         tw_post_command_packet(tw_dev, request_id);
1832                         return 0;
1833                 case TW_CMD_PACKET:
1834                         dprintk(KERN_WARNING "3w-xxxx: tw_ioctl(): caught TW_CMD_PACKET.\n");
1835                         if (ioctl->data != NULL) {
1836                                 memcpy(command_packet, ioctl->data, sizeof(TW_Command));
1837                                 command_packet->request_id = request_id;
1838                                 tw_post_command_packet(tw_dev, request_id);
1839                                 return 0;
1840                         } else {
1841                                 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): ioctl->data NULL.\n");
1842                                 return 1;
1843                         }
1844                 case TW_CMD_PACKET_WITH_DATA:
1845                         dprintk(KERN_WARNING "3w-xxxx: tw_ioctl(): caught TW_CMD_PACKET_WITH_DATA.\n");
1846                         command_save = (TW_Command *)tw_dev->alignment_virtual_address[request_id];
1847                         if (command_save == NULL) {
1848                                 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Bad alignment virtual address.\n", tw_dev->host->host_no);
1849                                 return 1;
1850                         }
1851                         if (ioctl->data != NULL) {
1852                                 /* Copy down the command packet */
1853                                 memcpy(command_packet, ioctl->data, sizeof(TW_Command));
1854                                 memcpy(command_save, ioctl->data, sizeof(TW_Command));
1855                                 command_packet->request_id = request_id;
1856
1857                                 /* Now deal with the two possible sglists */
1858                                 if (command_packet->byte0.sgl_offset == 2) {
1859                                         use_sg = command_packet->size - 3;
1860                                         for (i=0;i<use_sg;i++)
1861                                                 total_bytes+=command_packet->byte8.param.sgl[i].length;
1862                                         tw_dev->ioctl_data[request_id] = pci_alloc_consistent(tw_dev->tw_pci_dev, total_bytes, &dma_handle);
1863
1864                                         if (!tw_dev->ioctl_data[request_id]) {
1865                                                 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): pci_alloc_consistent() failed for request_id %d.\n", tw_dev->host->host_no, request_id);
1866                                                 return 1;
1867                                         }
1868
1869                                         /* Copy param sglist into the kernel */
1870                                         data_ptr = tw_dev->ioctl_data[request_id];
1871                                         for (i=0;i<use_sg;i++) {
1872                                                 if (command_packet->byte8.param.sgl[i].address != 0) {
1873                                                         error = copy_from_user(data_ptr, (void *)(unsigned long)command_packet->byte8.param.sgl[i].address, command_packet->byte8.param.sgl[i].length);
1874                                                         if (error) {
1875                                                                 dprintk(KERN_WARNING "3w-xxxx: scsi%d: Error copying param sglist from userspace.\n", tw_dev->host->host_no);
1876                                                                 goto tw_ioctl_bail;
1877                                                         }
1878                                                 } else {
1879                                                         printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Bad param sgl address.\n", tw_dev->host->host_no);
1880                                                         tw_dev->srb[request_id]->result = (DID_RESET << 16);
1881                                                         goto tw_ioctl_bail;
1882                                                 }
1883                                                 data_ptr+=command_packet->byte8.param.sgl[i].length;
1884                                         }
1885                                         command_packet->size = 4;
1886                                         command_packet->byte8.param.sgl[0].address = dma_handle;
1887                                         command_packet->byte8.param.sgl[0].length = total_bytes;
1888                                 }
1889                                 if (command_packet->byte0.sgl_offset == 3) {
1890                                         use_sg = command_packet->size - 4;
1891                                         for (i=0;i<use_sg;i++)
1892                                                 total_bytes+=command_packet->byte8.io.sgl[i].length;
1893                                         tw_dev->ioctl_data[request_id] = pci_alloc_consistent(tw_dev->tw_pci_dev, total_bytes, &dma_handle);
1894
1895                                         if (!tw_dev->ioctl_data[request_id]) {
1896                                                 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): pci_alloc_consistent() failed for request_id %d.\n", tw_dev->host->host_no, request_id);
1897                                                 return 1;
1898                                         }
1899                                         if (command_packet->byte0.opcode == TW_OP_WRITE) {
1900                                                 /* Copy io sglist into the kernel */
1901                                                 data_ptr = tw_dev->ioctl_data[request_id];
1902                                                 for (i=0;i<use_sg;i++) {
1903                                                         if (command_packet->byte8.io.sgl[i].address != 0) {
1904                                                                 error = copy_from_user(data_ptr, (void *)(unsigned long)command_packet->byte8.io.sgl[i].address, command_packet->byte8.io.sgl[i].length);
1905                                                                 if (error) {
1906                                                                         dprintk(KERN_WARNING "3w-xxxx: scsi%d: Error copying io sglist from userspace.\n", tw_dev->host->host_no);
1907                                                                         goto tw_ioctl_bail;
1908                                                                 }
1909                                                         } else {
1910                                                                 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Bad io sgl address.\n", tw_dev->host->host_no);
1911                                                                 tw_dev->srb[request_id]->result = (DID_RESET << 16);
1912                                                                 goto tw_ioctl_bail;
1913                                                         }
1914                                                         data_ptr+=command_packet->byte8.io.sgl[i].length;
1915                                                 }
1916                                         }
1917                                         command_packet->size = 5;
1918                                         command_packet->byte8.io.sgl[0].address = dma_handle;
1919                                         command_packet->byte8.io.sgl[0].length = total_bytes;
1920                                 }
1921
1922                                 spin_unlock(&tw_dev->tw_lock);
1923                                 spin_unlock_irq(tw_dev->host->host_lock);
1924
1925                                 set_bit(TW_IN_IOCTL, &tw_dev->flags);
1926
1927                                 /* Finally post the command packet */
1928                                 tw_post_command_packet(tw_dev, request_id);
1929                                 posted = 1;
1930                                 do_gettimeofday(&before);
1931
1932                         tw_ioctl_retry:
1933                                 mdelay(TW_IOCTL_WAIT_TIME);
1934                                 if (test_bit(TW_IN_IOCTL, &tw_dev->flags)) {
1935                                         do_gettimeofday(&timeout);
1936                                         if (before.tv_sec + TW_IOCTL_TIMEOUT < timeout.tv_sec) {
1937                                                 spin_lock_irq(tw_dev->host->host_lock);
1938                                                 spin_lock(&tw_dev->tw_lock);
1939                                                 goto tw_ioctl_bail;
1940                                         } else {
1941                                                 goto tw_ioctl_retry;
1942                                         }
1943                                 }
1944
1945                                 spin_lock_irq(tw_dev->host->host_lock);
1946                                 spin_lock(&tw_dev->tw_lock);
1947
1948                                 if (signal_pending(current)) {
1949                                         dprintk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Signal pending, aborting ioctl().\n", tw_dev->host->host_no);
1950                                         tw_dev->srb[request_id]->result = (DID_OK << 16);
1951                                         goto tw_ioctl_bail;
1952                                 }
1953
1954                                 tw_dev->srb[request_id]->result = (DID_OK << 16);
1955                                 /* Now copy up the param or io sglist to userspace */
1956                                 if (command_packet->byte0.sgl_offset == 2) {
1957                                         use_sg = command_save->size - 3;
1958                                         data_ptr = tw_dev->ioctl_data[request_id];
1959                                         for (i=0;i<use_sg;i++) {
1960                                                 if (command_save->byte8.param.sgl[i].address != 0) {
1961                                                         error = copy_to_user((void *)(unsigned long)command_save->byte8.param.sgl[i].address, data_ptr, command_save->byte8.param.sgl[i].length);
1962                                                         if (error) {
1963                                                                 dprintk(KERN_WARNING "3w-xxxx: scsi%d: Error copying param sglist to userspace.\n", tw_dev->host->host_no);
1964                                                                 goto tw_ioctl_bail;
1965                                                         }
1966                                                         dprintk(KERN_WARNING "3w-xxxx: scsi%d: Copied %ld bytes to pid %d.\n", tw_dev->host->host_no, command_save->byte8.param.sgl[i].length, current->pid);
1967                                                         data_ptr+=command_save->byte8.param.sgl[i].length;
1968                                                 } else {
1969                                                         printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Bad param sgl address.\n", tw_dev->host->host_no);
1970                                                         tw_dev->srb[request_id]->result = (DID_RESET << 16);
1971                                                         goto tw_ioctl_bail;
1972                                                 }
1973                                         }
1974                                 }
1975                                 if (command_packet->byte0.sgl_offset == 3) {
1976                                         use_sg = command_save->size - 4;
1977                                         if (command_packet->byte0.opcode == TW_OP_READ) {
1978                                                 data_ptr = tw_dev->ioctl_data[request_id];
1979                                                 for(i=0;i<use_sg;i++) {
1980                                                         if (command_save->byte8.io.sgl[i].address != 0) {
1981                                                                 error = copy_to_user((void *)(unsigned long)command_save->byte8.io.sgl[i].address, data_ptr, command_save->byte8.io.sgl[i].length);
1982                                                                 if (error) {
1983                                                                         dprintk(KERN_WARNING "3w-xxxx: scsi%d: Error copying io sglist to userspace.\n", tw_dev->host->host_no);
1984                                                                         goto tw_ioctl_bail;
1985                                                                 }
1986                                                                 dprintk(KERN_WARNING "3w-xxxx: scsi%d: Copied %ld bytes to pid %d.\n", tw_dev->host->host_no, command_save->byte8.io.sgl[i].length, current->pid);
1987                                                                 data_ptr+=command_save->byte8.io.sgl[i].length;
1988                                                         } else {
1989                                                                 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Bad io sgl address.\n", tw_dev->host->host_no);
1990                                                                 tw_dev->srb[request_id]->result = (DID_RESET << 16);
1991                                                                 goto tw_ioctl_bail;
1992                                                         }
1993                                                 }
1994                                         }
1995                                 }
1996
1997                         tw_ioctl_bail:
1998
1999                                 /* Free up sglist memory */
2000                                 if (tw_dev->ioctl_data[request_id])
2001                                         pci_free_consistent(tw_dev->tw_pci_dev, total_bytes, tw_dev->ioctl_data[request_id], dma_handle);
2002                                 else
2003                                         printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl(): Error freeing ioctl data.\n", tw_dev->host->host_no);
2004
2005                                 /* Now complete the io */
2006                                 tw_dev->state[request_id] = TW_S_COMPLETED;
2007                                 tw_state_request_finish(tw_dev, request_id);
2008                                 if (posted)
2009                                         tw_dev->posted_request_count--;
2010                                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2011                                 return 0;
2012                         } else {
2013                                 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): ioctl->data NULL.\n");
2014                                 return 1;
2015                         }
2016                 default:
2017                         dprintk(KERN_WARNING "3w-xxxx: Unknown ioctl 0x%x.\n", opcode);
2018                         tw_dev->state[request_id] = TW_S_COMPLETED;
2019                         tw_state_request_finish(tw_dev, request_id);
2020                         tw_dev->srb[request_id]->result = (DID_OK << 16);
2021                         tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2022                         return 0;
2023         }
2024
2025         param_value = tw_dev->alignment_physical_address[request_id];
2026         if (param_value == 0) {
2027                 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Bad alignment physical address.\n");
2028                 tw_dev->state[request_id] = TW_S_COMPLETED;
2029                 tw_state_request_finish(tw_dev, request_id);
2030                 tw_dev->srb[request_id]->result = (DID_OK << 16);
2031                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2032         }
2033
2034         command_packet->byte8.param.sgl[0].address = param_value;
2035         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
2036
2037         command_packet->byte0.sgl_offset = 2;
2038         command_packet->size = 4;
2039         command_packet->request_id = request_id;
2040         command_packet->byte3.host_id = 0;
2041         command_packet->status = 0;
2042         command_packet->flags = 0;
2043         command_packet->byte6.parameter_count = 1;
2044
2045         /* Now try to post the command to the board */
2046         tw_post_command_packet(tw_dev, request_id);
2047
2048         return 0;
2049 } /* End tw_ioctl() */
2050
2051 /* This function is called by the isr to complete ioctl requests */
2052 int tw_ioctl_complete(TW_Device_Extension *tw_dev, int request_id)
2053 {
2054         unsigned char *param_data;
2055         unsigned char *buff;
2056         TW_Param *param;
2057         TW_Ioctl *ioctl = NULL;
2058         TW_Passthru *passthru = NULL;
2059         TW_Command *command_packet;
2060
2061         ioctl = (TW_Ioctl *)tw_dev->srb[request_id]->request_buffer;
2062         dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl_complete()\n");
2063         buff = tw_dev->srb[request_id]->request_buffer;
2064         if (buff == NULL) {
2065                 printk(KERN_WARNING "3w-xxxx: tw_ioctl_complete(): Request buffer NULL.\n");
2066                 return 1;
2067         }
2068
2069         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2070         if (command_packet == NULL) {
2071                 printk(KERN_WARNING "3w-xxxx: scsi%d: tw_ioctl_complete(): Bad command packet virtual address.\n", tw_dev->host->host_no);
2072                 return 1;
2073         }
2074
2075         dprintk(KERN_NOTICE "3w-xxxx: tw_ioctl_complete(): Request_bufflen = %d\n", tw_dev->srb[request_id]->request_bufflen);
2076
2077         ioctl = (TW_Ioctl *)buff;
2078         switch (ioctl->opcode) {
2079                 case TW_ATA_PASSTHRU:
2080                         passthru = (TW_Passthru *)ioctl->data;
2081                         /* Don't return data for non-data ATA cmds */
2082                         if ((passthru->param != 0) && (passthru->param != 0x8))
2083                                 memcpy(buff, tw_dev->alignment_virtual_address[request_id], passthru->sector_count * 512);
2084                         else {
2085                                 /* For non-data cmds, return cmd pkt */
2086                                 if (tw_dev->srb[request_id]->request_bufflen >= sizeof(TW_Command))
2087                                         memcpy(buff, tw_dev->command_packet_virtual_address[request_id], sizeof(TW_Command));
2088                         }
2089                         break;
2090                 case TW_CMD_PACKET_WITH_DATA:
2091                         dprintk(KERN_WARNING "3w-xxxx: tw_ioctl_complete(): caught TW_CMD_PACKET_WITH_DATA.\n");
2092                         clear_bit(TW_IN_IOCTL, &tw_dev->flags);
2093                         return TW_ISR_DONT_COMPLETE; /* Special case for isr to not complete io */
2094                 default:
2095                         memset(buff, 0, tw_dev->srb[request_id]->request_bufflen);
2096                         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2097                         if (param == NULL) {
2098                                 printk(KERN_WARNING "3w-xxxx: tw_ioctl_complete(): Bad alignment virtual address.\n");
2099                                 return 1;
2100                         }
2101                         param_data = &(param->data[0]);
2102                         memcpy(buff, param_data, tw_dev->ioctl_size[request_id]);
2103         }
2104         return 0;
2105 } /* End tw_ioctl_complete() */
2106
2107 static int tw_map_scsi_sg_data(struct pci_dev *pdev, Scsi_Cmnd *cmd)
2108 {
2109         int use_sg;
2110         int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
2111
2112         dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data()\n");
2113
2114         if (cmd->use_sg == 0)
2115                 return 0;
2116
2117         use_sg = pci_map_sg(pdev, cmd->buffer, cmd->use_sg, dma_dir);
2118
2119         if (use_sg == 0) {
2120                 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_sg_data(): pci_map_sg() failed.\n");
2121                 return 0;
2122         }
2123
2124         cmd->SCp.phase = 2;
2125         cmd->SCp.have_data_in = use_sg;
2126
2127         return use_sg;
2128 } /* End tw_map_scsi_sg_data() */
2129
2130 static u32 tw_map_scsi_single_data(struct pci_dev *pdev, Scsi_Cmnd *cmd)
2131 {
2132         dma_addr_t mapping;
2133         int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
2134
2135         dprintk(KERN_WARNING "3w-xxxx: tw_map_scsi_single_data()\n");
2136
2137         if (cmd->request_bufflen == 0)
2138                 return 0;
2139
2140         mapping = pci_map_page(pdev, virt_to_page(cmd->request_buffer), offset_in_page(cmd->request_buffer), cmd->request_bufflen, dma_dir);
2141
2142         if (mapping == 0) {
2143                 printk(KERN_WARNING "3w-xxxx: tw_map_scsi_single_data(): pci_map_page() failed.\n");
2144                 return 0;
2145         }
2146
2147         cmd->SCp.phase = 1;
2148         cmd->SCp.have_data_in = mapping;
2149
2150         return mapping;
2151 } /* End tw_map_scsi_single_data() */
2152
2153 /* This function will mask the command interrupt */
2154 void tw_mask_command_interrupt(TW_Device_Extension *tw_dev)
2155 {
2156         u32 control_reg_addr, control_reg_value;
2157
2158         control_reg_addr = tw_dev->registers.control_reg_addr;
2159         control_reg_value = TW_CONTROL_MASK_COMMAND_INTERRUPT;
2160         outl(control_reg_value, control_reg_addr);
2161 } /* End tw_mask_command_interrupt() */
2162
2163 /* This function will poll the status register for a flag */
2164 int tw_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
2165 {
2166         u32 status_reg_addr, status_reg_value;
2167         struct timeval before, timeout;
2168
2169         status_reg_addr = tw_dev->registers.status_reg_addr;
2170         do_gettimeofday(&before);
2171         status_reg_value = inl(status_reg_addr);
2172
2173         if (tw_check_bits(status_reg_value)) {
2174                 dprintk(KERN_WARNING "3w-xxxx: tw_poll_status(): Unexpected bits.\n");
2175                 tw_decode_bits(tw_dev, status_reg_value, 0);
2176         }
2177
2178         while ((status_reg_value & flag) != flag) {
2179                 status_reg_value = inl(status_reg_addr);
2180
2181                 if (tw_check_bits(status_reg_value)) {
2182                         dprintk(KERN_WARNING "3w-xxxx: tw_poll_status(): Unexpected bits.\n");
2183                         tw_decode_bits(tw_dev, status_reg_value, 0);
2184                 }
2185
2186                 do_gettimeofday(&timeout);
2187                 if (before.tv_sec + seconds < timeout.tv_sec) {
2188                         dprintk(KERN_WARNING "3w-xxxx: tw_poll_status(): Flag 0x%x not found.\n", flag);
2189                         return 1;
2190                 }
2191                 mdelay(5);
2192         }
2193         return 0;
2194 } /* End tw_poll_status() */
2195
2196 /* This function will poll the status register for disappearance of a flag */
2197 int tw_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
2198 {
2199         u32 status_reg_addr, status_reg_value;
2200         struct timeval before, timeout;
2201
2202         status_reg_addr = tw_dev->registers.status_reg_addr;
2203         do_gettimeofday(&before);
2204         status_reg_value = inl(status_reg_addr);
2205
2206         if (tw_check_bits(status_reg_value)) {
2207                 dprintk(KERN_WARNING "3w-xxxx: tw_poll_status_gone(): Unexpected bits.\n");
2208                 tw_decode_bits(tw_dev, status_reg_value, 0);
2209         }
2210
2211         while ((status_reg_value & flag) != 0) {
2212                 status_reg_value = inl(status_reg_addr);
2213
2214                 if (tw_check_bits(status_reg_value)) {
2215                         dprintk(KERN_WARNING "3w-xxxx: tw_poll_status_gone(): Unexpected bits.\n");
2216                         tw_decode_bits(tw_dev, status_reg_value, 0);
2217                 }
2218
2219                 do_gettimeofday(&timeout);
2220                 if (before.tv_sec + seconds < timeout.tv_sec) {
2221                         dprintk(KERN_WARNING "3w-xxxx: tw_poll_status_gone(): Flag 0x%x never disappeared.\n", flag);
2222                         return 1;
2223                 }
2224                 mdelay(5);
2225         }
2226         return 0;
2227 } /* End tw_poll_status_gone() */
2228
2229 /* This function will attempt to post a command packet to the board */
2230 int tw_post_command_packet(TW_Device_Extension *tw_dev, int request_id)
2231 {
2232         u32 status_reg_addr, status_reg_value;
2233         unsigned long command_que_value;
2234         u32 command_que_addr;
2235
2236         dprintk(KERN_NOTICE "3w-xxxx: tw_post_command_packet()\n");
2237         command_que_addr = tw_dev->registers.command_que_addr;
2238         command_que_value = tw_dev->command_packet_physical_address[request_id];
2239         status_reg_addr = tw_dev->registers.status_reg_addr;
2240         status_reg_value = inl(status_reg_addr);
2241
2242         if (tw_check_bits(status_reg_value)) {
2243                 dprintk(KERN_WARNING "3w-xxxx: tw_post_command_packet(): Unexpected bits.\n");
2244                 tw_decode_bits(tw_dev, status_reg_value, 1);
2245         }
2246
2247         if ((status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL) == 0) {
2248                 /* We successfully posted the command packet */
2249                 outl(command_que_value, command_que_addr);
2250                 tw_dev->state[request_id] = TW_S_POSTED;
2251                 tw_dev->posted_request_count++;
2252                 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
2253                         tw_dev->max_posted_request_count = tw_dev->posted_request_count;
2254                 }
2255         } else {
2256                 /* Couldn't post the command packet, so we do it in the isr */
2257                 if (tw_dev->state[request_id] != TW_S_PENDING) {
2258                         tw_dev->state[request_id] = TW_S_PENDING;
2259                         tw_dev->pending_request_count++;
2260                         if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
2261                                 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
2262                         }
2263                         tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
2264                         if (tw_dev->pending_tail == TW_Q_LENGTH-1) {
2265                                 tw_dev->pending_tail = TW_Q_START;
2266                         } else {
2267                                 tw_dev->pending_tail = tw_dev->pending_tail + 1;
2268                         }
2269                 }
2270                 tw_unmask_command_interrupt(tw_dev);
2271                 return 1;
2272         }
2273         return 0;
2274 } /* End tw_post_command_packet() */
2275
2276 /* This function will reset a device extension */
2277 int tw_reset_device_extension(TW_Device_Extension *tw_dev)
2278 {
2279         int imax = 0;
2280         int i = 0;
2281         Scsi_Cmnd *srb;
2282
2283         dprintk(KERN_NOTICE "3w-xxxx: tw_reset_device_extension()\n");
2284         imax = TW_Q_LENGTH;
2285
2286         if (tw_reset_sequence(tw_dev)) {
2287                 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset sequence failed.\n", tw_dev->host->host_no);
2288                 return 1;
2289         }
2290
2291         /* Abort all requests that are in progress */
2292         for (i=0;i<imax;i++) {
2293                 if ((tw_dev->state[i] != TW_S_FINISHED) &&
2294                     (tw_dev->state[i] != TW_S_INITIAL) &&
2295                     (tw_dev->state[i] != TW_S_COMPLETED)) {
2296                         srb = tw_dev->srb[i];
2297                         if (srb != NULL) {
2298                                 srb->result = (DID_RESET << 16);
2299                                 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
2300                                 tw_unmap_scsi_data(tw_dev->tw_pci_dev, tw_dev->srb[i]);
2301                         }
2302                 }
2303         }
2304
2305         /* Reset queues and counts */
2306         for (i=0;i<imax;i++) {
2307                 tw_dev->free_queue[i] = i;
2308                 tw_dev->state[i] = TW_S_INITIAL;
2309         }
2310         tw_dev->free_head = TW_Q_START;
2311         tw_dev->free_tail = TW_Q_START;
2312         tw_dev->posted_request_count = 0;
2313         tw_dev->pending_request_count = 0;
2314         tw_dev->pending_head = TW_Q_START;
2315         tw_dev->pending_tail = TW_Q_START;
2316         tw_dev->reset_print = 0;
2317         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
2318
2319         return 0;
2320 } /* End tw_reset_device_extension() */
2321
2322 /* This function will reset a controller */
2323 int tw_reset_sequence(TW_Device_Extension *tw_dev)
2324 {
2325         int error = 0;
2326         int tries = 0;
2327
2328         /* Disable interrupts */
2329         tw_disable_interrupts(tw_dev);
2330
2331         /* Reset the board */
2332         while (tries < TW_MAX_RESET_TRIES) {
2333                 tw_soft_reset(tw_dev);
2334
2335                 error = tw_aen_drain_queue(tw_dev);
2336                 if (error) {
2337                         printk(KERN_WARNING "3w-xxxx: scsi%d: AEN drain failed, retrying.\n", tw_dev->host->host_no);
2338                         tries++;
2339                         continue;
2340                 }
2341
2342                 /* Check for controller errors */
2343                 if (tw_check_errors(tw_dev)) {
2344                         printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors found, retrying.\n", tw_dev->host->host_no);
2345                         tries++;
2346                         continue;
2347                 }
2348
2349                 /* Now the controller is in a good state */
2350                 break;
2351         }
2352
2353         if (tries >= TW_MAX_RESET_TRIES) {
2354                 printk(KERN_WARNING "3w-xxxx: scsi%d: Controller errors, card not responding, check all cabling.\n", tw_dev->host->host_no);
2355                 return 1;
2356         }
2357
2358         error = tw_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS);
2359         if (error) {
2360                 printk(KERN_WARNING "3w-xxxx: scsi%d: Connection initialization failed.\n", tw_dev->host->host_no);
2361                 return 1;
2362         }
2363
2364         /* Re-enable interrupts */
2365         tw_enable_and_clear_interrupts(tw_dev);
2366
2367         return 0;
2368 } /* End tw_reset_sequence() */
2369
2370 /* This funciton returns unit geometry in cylinders/heads/sectors */
2371 int tw_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev,
2372                 sector_t capacity, int geom[])
2373 {
2374         int heads, sectors, cylinders;
2375         TW_Device_Extension *tw_dev;
2376
2377         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam()\n");
2378         tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
2379
2380         heads = 64;
2381         sectors = 32;
2382         cylinders = (unsigned long)capacity / (heads * sectors);
2383
2384         if (capacity >= 0x200000) {
2385                 heads = 255;
2386                 sectors = 63;
2387                 cylinders = (unsigned long)capacity / (heads * sectors);
2388         }
2389
2390         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_biosparam(): heads = %d, sectors = %d, cylinders = %d\n", heads, sectors, cylinders);
2391         geom[0] = heads;
2392         geom[1] = sectors;
2393         geom[2] = cylinders;
2394
2395         return 0;
2396 } /* End tw_scsi_biosparam() */
2397
2398 /* This function will find and initialize any cards */
2399 int tw_scsi_detect(Scsi_Host_Template *tw_host)
2400 {
2401         int ret;
2402
2403         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_detect()\n");
2404
2405         printk(KERN_WARNING "3ware Storage Controller device driver for Linux v%s.\n", tw_driver_version);
2406
2407         ret = tw_findcards(tw_host);
2408
2409         return ret;
2410 } /* End tw_scsi_detect() */
2411
2412 /* This is the new scsi eh abort function */
2413 int tw_scsi_eh_abort(Scsi_Cmnd *SCpnt)
2414 {
2415         TW_Device_Extension *tw_dev=NULL;
2416         int i = 0;
2417
2418         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_eh_abort()\n");
2419
2420         if (!SCpnt) {
2421                 printk(KERN_WARNING "3w-xxxx: tw_scsi_eh_abort(): Invalid Scsi_Cmnd.\n");
2422                 return (FAILED);
2423         }
2424
2425         tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
2426         if (tw_dev == NULL) {
2427                 printk(KERN_WARNING "3w-xxxx: tw_scsi_eh_abort(): Invalid device extension.\n");
2428                 return (FAILED);
2429         }
2430
2431         spin_lock(&tw_dev->tw_lock);
2432         tw_dev->num_aborts++;
2433
2434         /* If the command hasn't been posted yet, we can do the abort */
2435         for (i=0;i<TW_Q_LENGTH;i++) {
2436                 if (tw_dev->srb[i] == SCpnt) {
2437                         if (tw_dev->state[i] == TW_S_STARTED) {
2438                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Unit #%d: Command (%p) timed out.\n", tw_dev->host->host_no, tw_dev->srb[i]==0 ? 0 : tw_dev->srb[i]->device->id, SCpnt);
2439                                 tw_dev->state[i] = TW_S_COMPLETED;
2440                                 tw_state_request_finish(tw_dev, i);
2441                                 spin_unlock(&tw_dev->tw_lock);
2442                                 return (SUCCESS);
2443                         }
2444                         if (tw_dev->state[i] == TW_S_PENDING) {
2445                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Unit #%d: Command (%p) timed out.\n", tw_dev->host->host_no, tw_dev->srb[i]==0 ? 0 : tw_dev->srb[i]->device->id, SCpnt);
2446                                 if (tw_dev->pending_head == TW_Q_LENGTH-1) {
2447                                         tw_dev->pending_head = TW_Q_START;
2448                                 } else {
2449                                         tw_dev->pending_head = tw_dev->pending_head + 1;
2450                                 }
2451                                 tw_dev->pending_request_count--;
2452                                 tw_dev->state[i] = TW_S_COMPLETED;
2453                                 tw_state_request_finish(tw_dev, i);
2454                                 spin_unlock(&tw_dev->tw_lock);
2455                                 return (SUCCESS);
2456                         }
2457                         if (tw_dev->state[i] == TW_S_POSTED) {
2458                                 /* If the command has already been posted, we have to reset the card */
2459                                 printk(KERN_WARNING "3w-xxxx: scsi%d: Unit #%d: Command (%p) timed out, resetting card.\n", tw_dev->host->host_no, tw_dev->srb[i]==0 ? 0 : tw_dev->srb[i]->device->id, SCpnt);
2460                                 /* We have to let AEN requests through before the reset */
2461                                 spin_unlock(&tw_dev->tw_lock);
2462                                 spin_unlock_irq(tw_dev->host->host_lock);
2463                                 mdelay(TW_AEN_WAIT_TIME);
2464                                 spin_lock_irq(tw_dev->host->host_lock);
2465                                 spin_lock(&tw_dev->tw_lock);
2466
2467                                 if (tw_reset_device_extension(tw_dev)) {
2468                                         dprintk(KERN_WARNING "3w-xxxx: tw_scsi_eh_abort(): Reset failed for card %d.\n", tw_dev->host->host_no);
2469                                         spin_unlock(&tw_dev->tw_lock);
2470                                         return (FAILED);
2471                                 }
2472                         }
2473                 }
2474         }
2475
2476         spin_unlock(&tw_dev->tw_lock);
2477         return (SUCCESS);
2478 } /* End tw_scsi_eh_abort() */
2479
2480 /* This is the new scsi eh reset function */
2481 int tw_scsi_eh_reset(Scsi_Cmnd *SCpnt)
2482 {
2483         TW_Device_Extension *tw_dev=NULL;
2484
2485         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_eh_reset()\n");
2486
2487         if (!SCpnt) {
2488                 printk(KERN_WARNING "3w-xxxx: tw_scsi_eh_reset(): Invalid Scsi_Cmnd.\n");
2489                 return (FAILED);
2490         }
2491
2492         tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
2493         if (tw_dev == NULL) {
2494                 printk(KERN_WARNING "3w-xxxx: tw_scsi_eh_reset(): Invalid device extension.\n");
2495                 return (FAILED);
2496         }
2497
2498         /* We have to let AEN requests through before the reset */
2499         spin_unlock_irq(tw_dev->host->host_lock);
2500         mdelay(TW_AEN_WAIT_TIME);
2501         spin_lock_irq(tw_dev->host->host_lock);
2502
2503         spin_lock(&tw_dev->tw_lock);
2504         tw_dev->num_resets++;
2505
2506         /* Now reset the card and some of the device extension data */
2507         if (tw_reset_device_extension(tw_dev)) {
2508                 printk(KERN_WARNING "3w-xxxx: scsi%d: Reset failed.\n", tw_dev->host->host_no);
2509                 spin_unlock(&tw_dev->tw_lock);
2510                 return (FAILED);
2511         }
2512         printk(KERN_WARNING "3w-xxxx: scsi%d: Reset succeeded.\n", tw_dev->host->host_no);
2513         spin_unlock(&tw_dev->tw_lock);
2514
2515         return (SUCCESS);
2516 } /* End tw_scsi_eh_reset() */
2517
2518 /* This function handles input and output from /proc/scsi/3w-xxxx/x */
2519 int tw_scsi_proc_info(struct Scsi_Host *shost, char *buffer, char **start,
2520                       off_t offset, int length, int inout)
2521 {
2522         TW_Device_Extension *tw_dev = NULL;
2523         TW_Info info;
2524         int i;
2525         int j;
2526
2527         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_proc_info()\n");
2528
2529         /* Find the correct device extension */
2530         for (i=0;i<tw_device_extension_count;i++)
2531                 if (tw_device_extension_list[i]->host->host_no == shost->host_no)
2532                         tw_dev = tw_device_extension_list[i];
2533         if (tw_dev == NULL) {
2534                 printk(KERN_WARNING "3w-xxxx: tw_scsi_proc_info(): Couldn't locate device extension.\n");
2535                 return (-EINVAL);
2536         }
2537
2538         info.buffer = buffer;
2539         info.length = length;
2540         info.offset = offset;
2541         info.position = 0;
2542
2543         if (inout) {
2544                 /* Write */
2545                 if (strncmp(buffer, "debug", 5) == 0) {
2546                         printk(KERN_INFO "3w-xxxx: Posted commands:\n");
2547                         for (j=0;j<TW_Q_LENGTH;j++) {
2548                                 if (tw_dev->state[j] == TW_S_POSTED) {
2549                                         TW_Command *command = (TW_Command *)tw_dev->command_packet_virtual_address[j];
2550                                         printk(KERN_INFO "3w-xxxx: Request_id: %d\n", j);
2551                                         printk(KERN_INFO "Opcode: 0x%x\n", command->byte0.opcode);
2552                                         printk(KERN_INFO "Block_count: 0x%x\n", command->byte6.block_count);
2553                                         printk(KERN_INFO "LBA: 0x%x\n", command->byte8.io.lba);
2554                                         printk(KERN_INFO "Physical command packet addr: 0x%lx\n", tw_dev->command_packet_physical_address[j]);
2555                                         printk(KERN_INFO "Scsi_Cmnd: %p\n", tw_dev->srb[j]);
2556                                 }
2557                         }
2558                         printk(KERN_INFO "3w-xxxx: Free_head: %3d\n", tw_dev->free_head);
2559                         printk(KERN_INFO "3w-xxxx: Free_tail: %3d\n", tw_dev->free_tail);
2560                 }
2561                 return length;
2562         } else {
2563                 /* Read */
2564                 if (start) {
2565                         *start = buffer;
2566                 }
2567                 tw_copy_info(&info, "scsi%d: 3ware Storage Controller\n", shost->host_no);
2568                 tw_copy_info(&info, "Driver version: %s\n", tw_driver_version);
2569                 tw_copy_info(&info, "Current commands posted:       %3d\n", tw_dev->posted_request_count);
2570                 tw_copy_info(&info, "Max commands posted:           %3d\n", tw_dev->max_posted_request_count);
2571                 tw_copy_info(&info, "Current pending commands:      %3d\n", tw_dev->pending_request_count);
2572                 tw_copy_info(&info, "Max pending commands:          %3d\n", tw_dev->max_pending_request_count);
2573                 tw_copy_info(&info, "Last sgl length:               %3d\n", tw_dev->sgl_entries);
2574                 tw_copy_info(&info, "Max sgl length:                %3d\n", tw_dev->max_sgl_entries);
2575                 tw_copy_info(&info, "Last sector count:             %3d\n", tw_dev->sector_count);
2576                 tw_copy_info(&info, "Max sector count:              %3d\n", tw_dev->max_sector_count);
2577                 tw_copy_info(&info, "Resets:                        %3d\n", tw_dev->num_resets);
2578                 tw_copy_info(&info, "Aborts:                        %3d\n", tw_dev->num_aborts);
2579                 tw_copy_info(&info, "AEN's:                         %3d\n", tw_dev->aen_count);
2580         }
2581         if (info.position > info.offset) {
2582                 return (info.position - info.offset);
2583         } else {
2584                 return 0;
2585         }
2586 } /* End tw_scsi_proc_info() */
2587
2588 /* This is the main scsi queue function to handle scsi opcodes */
2589 int tw_scsi_queue(Scsi_Cmnd *SCpnt, void (*done)(Scsi_Cmnd *))
2590 {
2591         unsigned char *command = SCpnt->cmnd;
2592         int request_id = 0;
2593         int error = 0;
2594         TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
2595
2596         if (tw_dev == NULL) {
2597                 printk(KERN_WARNING "3w-xxxx: tw_scsi_queue(): Invalid device extension.\n");
2598                 SCpnt->result = (DID_ERROR << 16);
2599                 done(SCpnt);
2600                 return 0;
2601         }
2602
2603         spin_lock(&tw_dev->tw_lock);
2604         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue()\n");
2605
2606         /* Skip scsi command if it isn't for us */
2607         if ((SCpnt->device->channel != 0) || (SCpnt->device->lun != 0)) {
2608                 SCpnt->result = (DID_BAD_TARGET << 16);
2609                 done(SCpnt);
2610                 spin_unlock(&tw_dev->tw_lock);
2611                 return 0;
2612         }
2613
2614         /* Save done function into Scsi_Cmnd struct */
2615         SCpnt->scsi_done = done;
2616
2617         /* Queue the command and get a request id */
2618         tw_state_request_start(tw_dev, &request_id);
2619
2620         /* Save the scsi command for use by the ISR */
2621         tw_dev->srb[request_id] = SCpnt;
2622
2623         /* Initialize phase to zero */
2624         SCpnt->SCp.phase = 0;
2625
2626         switch (*command) {
2627                 case READ_10:
2628                 case READ_6:
2629                 case WRITE_10:
2630                 case WRITE_6:
2631                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ/WRITE.\n");
2632                         error = tw_scsiop_read_write(tw_dev, request_id);
2633                         break;
2634                 case TEST_UNIT_READY:
2635                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TEST_UNIT_READY.\n");
2636                         error = tw_scsiop_test_unit_ready(tw_dev, request_id);
2637                         break;
2638                 case INQUIRY:
2639                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught INQUIRY.\n");
2640                         error = tw_scsiop_inquiry(tw_dev, request_id);
2641                         break;
2642                 case READ_CAPACITY:
2643                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught READ_CAPACITY.\n");
2644                         error = tw_scsiop_read_capacity(tw_dev, request_id);
2645                         break;
2646                 case REQUEST_SENSE:
2647                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught REQUEST_SENSE.\n");
2648                         error = tw_scsiop_request_sense(tw_dev, request_id);
2649                         break;
2650                 case MODE_SENSE:
2651                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught MODE_SENSE.\n");
2652                         error = tw_scsiop_mode_sense(tw_dev, request_id);
2653                         break;
2654                 case SYNCHRONIZE_CACHE:
2655                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught SYNCHRONIZE_CACHE.\n");
2656                         error = tw_scsiop_synchronize_cache(tw_dev, request_id);
2657                         break;
2658                 case TW_IOCTL:
2659                         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_queue(): caught TW_SCSI_IOCTL.\n");
2660                         error = tw_ioctl(tw_dev, request_id);
2661                         break;
2662                 default:
2663                         printk(KERN_NOTICE "3w-xxxx: scsi%d: Unknown scsi opcode: 0x%x\n", tw_dev->host->host_no, *command);
2664                         tw_dev->state[request_id] = TW_S_COMPLETED;
2665                         tw_state_request_finish(tw_dev, request_id);
2666                         SCpnt->result = (DID_BAD_TARGET << 16);
2667                         done(SCpnt);
2668         }
2669         if (error) {
2670                 tw_dev->state[request_id] = TW_S_COMPLETED;
2671                 tw_state_request_finish(tw_dev, request_id);
2672                 SCpnt->result = (DID_ERROR << 16);
2673                 done(SCpnt);
2674         }
2675         spin_unlock(&tw_dev->tw_lock);
2676
2677         return 0;
2678 } /* End tw_scsi_queue() */
2679
2680 /* This function will release the resources on an rmmod call */
2681 int tw_scsi_release(struct Scsi_Host *tw_host)
2682 {
2683         TW_Device_Extension *tw_dev;
2684         tw_dev = (TW_Device_Extension *)tw_host->hostdata;
2685
2686         dprintk(KERN_NOTICE "3w-xxxx: tw_scsi_release()\n");
2687
2688         /* Fake like we just shut down, so notify the card that
2689          * we "shut down cleanly".
2690          */
2691         tw_halt(0, 0, 0);  // parameters aren't actually used
2692
2693         /* Free up the IO region */
2694         release_region((tw_dev->tw_pci_dev->resource[0].start), TW_IO_ADDRESS_RANGE);
2695
2696         /* Free up the IRQ */
2697         free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2698
2699         /* Unregister character device */
2700         if (twe_major >= 0) {
2701                 unregister_chrdev(twe_major, "twe");
2702                 twe_major = -1;
2703         }
2704
2705         /* Free up device extension resources */
2706         tw_free_device_extension(tw_dev);
2707
2708         /* Tell kernel scsi-layer we are gone */
2709         scsi_unregister(tw_host);
2710
2711         return 0;
2712 } /* End tw_scsi_release() */
2713
2714 /* This function handles scsi inquiry commands */
2715 int tw_scsiop_inquiry(TW_Device_Extension *tw_dev, int request_id)
2716 {
2717         TW_Param *param;
2718         TW_Command *command_packet;
2719         unsigned long command_que_value;
2720         u32 command_que_addr;
2721         unsigned long param_value;
2722
2723         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry()\n");
2724
2725         /* Initialize command packet */
2726         command_que_addr = tw_dev->registers.command_que_addr;
2727         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2728         if (command_packet == NULL) {
2729                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet virtual address.\n");
2730                 return 1;
2731         }
2732         memset(command_packet, 0, sizeof(TW_Sector));
2733         command_packet->byte0.opcode = TW_OP_GET_PARAM;
2734         command_packet->byte0.sgl_offset = 2;
2735         command_packet->size = 4;
2736         command_packet->request_id = request_id;
2737         command_packet->byte3.unit = 0;
2738         command_packet->byte3.host_id = 0;
2739         command_packet->status = 0;
2740         command_packet->flags = 0;
2741         command_packet->byte6.parameter_count = 1;
2742
2743         /* Now setup the param */
2744         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
2745                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment virtual address.\n");
2746                 return 1;
2747         }
2748         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2749         memset(param, 0, sizeof(TW_Sector));
2750         param->table_id = 3;     /* unit summary table */
2751         param->parameter_id = 3; /* unitsstatus parameter */
2752         param->parameter_size_bytes = TW_MAX_UNITS;
2753         param_value = tw_dev->alignment_physical_address[request_id];
2754         if (param_value == 0) {
2755                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad alignment physical address.\n");
2756                 return 1;
2757         }
2758
2759         command_packet->byte8.param.sgl[0].address = param_value;
2760         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
2761         command_que_value = tw_dev->command_packet_physical_address[request_id];
2762         if (command_que_value == 0) {
2763                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry(): Bad command packet physical address.\n");
2764                 return 1;
2765         }
2766
2767         /* Now try to post the command packet */
2768         tw_post_command_packet(tw_dev, request_id);
2769
2770         return 0;
2771 } /* End tw_scsiop_inquiry() */
2772
2773 /* This function is called by the isr to complete an inquiry command */
2774 int tw_scsiop_inquiry_complete(TW_Device_Extension *tw_dev, int request_id)
2775 {
2776         unsigned char *is_unit_present;
2777         unsigned char *request_buffer;
2778         TW_Param *param;
2779
2780         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_inquiry_complete()\n");
2781
2782         /* Fill request buffer */
2783         if (tw_dev->srb[request_id]->request_buffer == NULL) {
2784                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Request buffer NULL.\n");
2785                 return 1;
2786         }
2787         request_buffer = tw_dev->srb[request_id]->request_buffer;
2788         memset(request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
2789         request_buffer[0] = TYPE_DISK; /* Peripheral device type */
2790         request_buffer[1] = 0;         /* Device type modifier */
2791         request_buffer[2] = 0;         /* No ansi/iso compliance */
2792         request_buffer[4] = 31;        /* Additional length */
2793         memcpy(&request_buffer[8], "3ware   ", 8);       /* Vendor ID */
2794         sprintf(&request_buffer[16], "Logical Disk %-2d ", tw_dev->srb[request_id]->device->id);
2795         memcpy(&request_buffer[32], tw_driver_version, 3);
2796
2797         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2798         if (param == NULL) {
2799                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_inquiry_complete(): Bad alignment virtual address.\n");
2800                 return 1;
2801         }
2802         is_unit_present = &(param->data[0]);
2803
2804         if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
2805                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = TRUE;
2806         } else {
2807                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = FALSE;
2808                 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
2809                 return TW_ISR_DONT_RESULT;
2810         }
2811
2812         return 0;
2813 } /* End tw_scsiop_inquiry_complete() */
2814
2815 /* This function handles scsi mode_sense commands */
2816 int tw_scsiop_mode_sense(TW_Device_Extension *tw_dev, int request_id)
2817 {
2818         TW_Param *param;
2819         TW_Command *command_packet;
2820         unsigned long command_que_value;
2821         unsigned long param_value;
2822
2823         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense()\n");
2824
2825         /* Only page control = 0, page code = 0x8 (cache page) supported */
2826         if (tw_dev->srb[request_id]->cmnd[2] != 0x8) {
2827                 tw_dev->state[request_id] = TW_S_COMPLETED;
2828                 tw_state_request_finish(tw_dev, request_id);
2829                 tw_dev->srb[request_id]->result = (DID_OK << 16);
2830                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
2831                 return 0;
2832         }
2833
2834         /* Now read firmware cache setting for this unit */
2835         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2836         if (command_packet == NULL) {
2837                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet virtual address.\n");
2838                 return 1;
2839         }
2840
2841         /* Setup the command packet */
2842         memset(command_packet, 0, sizeof(TW_Sector));
2843         command_packet->byte0.opcode = TW_OP_GET_PARAM;
2844         command_packet->byte0.sgl_offset = 2;
2845         command_packet->size = 4;
2846         command_packet->request_id = request_id;
2847         command_packet->byte3.unit = 0;
2848         command_packet->byte3.host_id = 0;
2849         command_packet->status = 0;
2850         command_packet->flags = 0;
2851         command_packet->byte6.parameter_count = 1;
2852
2853         /* Setup the param */
2854         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
2855                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment virtual address.\n");
2856                 return 1;
2857         }
2858
2859         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2860         memset(param, 0, sizeof(TW_Sector));
2861         param->table_id = TW_UNIT_INFORMATION_TABLE_BASE + tw_dev->srb[request_id]->device->id;
2862         param->parameter_id = 7; /* unit flags */
2863         param->parameter_size_bytes = 1;
2864         param_value = tw_dev->alignment_physical_address[request_id];
2865         if (param_value == 0) {
2866                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad alignment physical address.\n");
2867                 return 1;
2868         }
2869
2870         command_packet->byte8.param.sgl[0].address = param_value;
2871         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
2872         command_que_value = tw_dev->command_packet_physical_address[request_id];
2873         if (command_que_value == 0) {
2874                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense(): Bad command packet physical address.\n");
2875                 return 1;
2876         }
2877
2878         /* Now try to post the command packet */
2879         tw_post_command_packet(tw_dev, request_id);
2880
2881         return 0;
2882 } /* End tw_scsiop_mode_sense() */
2883
2884 /* This function is called by the isr to complete a mode sense command */
2885 int tw_scsiop_mode_sense_complete(TW_Device_Extension *tw_dev, int request_id)
2886 {
2887         TW_Param *param;
2888         unsigned char *flags;
2889         unsigned char *request_buffer;
2890
2891         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_mode_sense_complete()\n");
2892
2893         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2894         if (param == NULL) {
2895                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_mode_sense_complete(): Bad alignment virtual address.\n");
2896                 return 1;
2897         }
2898         flags = (char *)&(param->data[0]);
2899         request_buffer = tw_dev->srb[request_id]->buffer;
2900         memset(request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
2901
2902         request_buffer[0] = 0xf;        /* mode data length */
2903         request_buffer[1] = 0;          /* default medium type */
2904         request_buffer[2] = 0x10;       /* dpo/fua support on */
2905         request_buffer[3] = 0;          /* no block descriptors */
2906         request_buffer[4] = 0x8;        /* caching page */
2907         request_buffer[5] = 0xa;        /* page length */
2908         if (*flags & 0x1)
2909                 request_buffer[6] = 0x4;        /* WCE on */
2910         else
2911                 request_buffer[6] = 0x0;        /* WCE off */
2912
2913         return 0;
2914 } /* End tw_scsiop_mode_sense_complete() */
2915
2916 /* This function handles scsi read_capacity commands */
2917 int tw_scsiop_read_capacity(TW_Device_Extension *tw_dev, int request_id)
2918 {
2919         TW_Param *param;
2920         TW_Command *command_packet;
2921         unsigned long command_que_value;
2922         u32 command_que_addr;
2923         unsigned long param_value;
2924
2925         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity()\n");
2926
2927         /* Initialize command packet */
2928         command_que_addr = tw_dev->registers.command_que_addr;
2929         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
2930
2931         if (command_packet == NULL) {
2932                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet virtual address.\n");
2933                 return 1;
2934         }
2935         memset(command_packet, 0, sizeof(TW_Sector));
2936         command_packet->byte0.opcode = TW_OP_GET_PARAM;
2937         command_packet->byte0.sgl_offset = 2;
2938         command_packet->size = 4;
2939         command_packet->request_id = request_id;
2940         command_packet->byte3.unit = tw_dev->srb[request_id]->device->id;
2941         command_packet->byte3.host_id = 0;
2942         command_packet->status = 0;
2943         command_packet->flags = 0;
2944         command_packet->byte6.block_count = 1;
2945
2946         /* Now setup the param */
2947         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
2948                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment virtual address.\n");
2949                 return 1;
2950         }
2951         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2952         memset(param, 0, sizeof(TW_Sector));
2953         param->table_id = TW_UNIT_INFORMATION_TABLE_BASE +
2954         tw_dev->srb[request_id]->device->id;
2955         param->parameter_id = 4;        /* unitcapacity parameter */
2956         param->parameter_size_bytes = 4;
2957         param_value = tw_dev->alignment_physical_address[request_id];
2958         if (param_value == 0) {
2959                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad alignment physical address.\n");
2960                 return 1;
2961         }
2962
2963         command_packet->byte8.param.sgl[0].address = param_value;
2964         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
2965         command_que_value = tw_dev->command_packet_physical_address[request_id];
2966         if (command_que_value == 0) {
2967                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity(): Bad command packet physical address.\n");
2968                 return 1;
2969         }
2970
2971         /* Now try to post the command to the board */
2972         tw_post_command_packet(tw_dev, request_id);
2973
2974         return 0;
2975 } /* End tw_scsiop_read_capacity() */
2976
2977 /* This function is called by the isr to complete a readcapacity command */
2978 int tw_scsiop_read_capacity_complete(TW_Device_Extension *tw_dev, int request_id)
2979 {
2980         unsigned char *param_data;
2981         u32 capacity;
2982         char *buff;
2983         TW_Param *param;
2984
2985         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete()\n");
2986
2987         buff = tw_dev->srb[request_id]->request_buffer;
2988         if (buff == NULL) {
2989                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Request buffer NULL.\n");
2990                 return 1;
2991         }
2992         memset(buff, 0, tw_dev->srb[request_id]->request_bufflen);
2993         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
2994         if (param == NULL) {
2995                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_capacity_complete(): Bad alignment virtual address.\n");
2996                 return 1;
2997         }
2998         param_data = &(param->data[0]);
2999
3000         capacity = (param_data[3] << 24) | (param_data[2] << 16) |
3001                    (param_data[1] << 8) | param_data[0];
3002
3003         /* Subtract one sector to fix get last sector ioctl */
3004         capacity -= 1;
3005
3006         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_capacity_complete(): Capacity = 0x%x.\n", capacity);
3007
3008         /* Number of LBA's */
3009         buff[0] = (capacity >> 24);
3010         buff[1] = (capacity >> 16) & 0xff;
3011         buff[2] = (capacity >> 8) & 0xff;
3012         buff[3] = capacity & 0xff;
3013
3014         /* Block size in bytes (512) */
3015         buff[4] = (TW_BLOCK_SIZE >> 24);
3016         buff[5] = (TW_BLOCK_SIZE >> 16) & 0xff;
3017         buff[6] = (TW_BLOCK_SIZE >> 8) & 0xff;
3018         buff[7] = TW_BLOCK_SIZE & 0xff;
3019
3020         return 0;
3021 } /* End tw_scsiop_read_capacity_complete() */
3022
3023 /* This function handles scsi read or write commands */
3024 int tw_scsiop_read_write(TW_Device_Extension *tw_dev, int request_id)
3025 {
3026         TW_Command *command_packet;
3027         unsigned long command_que_value;
3028         u32 command_que_addr = 0x0;
3029         u32 lba = 0x0, num_sectors = 0x0, buffaddr = 0x0;
3030         int i, use_sg;
3031         Scsi_Cmnd *srb;
3032         struct scatterlist *sglist;
3033
3034         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write()\n");
3035
3036         if (tw_dev->srb[request_id]->request_buffer == NULL) {
3037                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Request buffer NULL.\n");
3038                 return 1;
3039         }
3040         sglist = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
3041         srb = tw_dev->srb[request_id];
3042
3043         /* Initialize command packet */
3044         command_que_addr = tw_dev->registers.command_que_addr;
3045         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
3046         if (command_packet == NULL) {
3047                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): Bad command packet virtual address.\n");
3048                 return 1;
3049         }
3050
3051         if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == READ_10) {
3052                 command_packet->byte0.opcode = TW_OP_READ;
3053         } else {
3054                 command_packet->byte0.opcode = TW_OP_WRITE;
3055         }
3056
3057         command_packet->byte0.sgl_offset = 3;
3058         command_packet->size = 3;
3059         command_packet->request_id = request_id;
3060         command_packet->byte3.unit = srb->device->id;
3061         command_packet->byte3.host_id = 0;
3062         command_packet->status = 0;
3063         command_packet->flags = 0;
3064
3065         if (srb->cmnd[0] == WRITE_10) {
3066                 if ((srb->cmnd[1] & 0x8) || (srb->cmnd[1] & 0x10))
3067                         command_packet->flags = 1;
3068         }
3069
3070         if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6) {
3071                 lba = ((u32)srb->cmnd[1] << 16) | ((u32)srb->cmnd[2] << 8) | (u32)srb->cmnd[3];
3072                 num_sectors = (u32)srb->cmnd[4];
3073         } else {
3074                 lba = ((u32)srb->cmnd[2] << 24) | ((u32)srb->cmnd[3] << 16) | ((u32)srb->cmnd[4] << 8) | (u32)srb->cmnd[5];
3075                 num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
3076         }
3077
3078         /* Update sector statistic */
3079         tw_dev->sector_count = num_sectors;
3080         if (tw_dev->sector_count > tw_dev->max_sector_count)
3081                 tw_dev->max_sector_count = tw_dev->sector_count;
3082
3083         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): lba = 0x%x num_sectors = 0x%x\n", lba, num_sectors);
3084         command_packet->byte8.io.lba = lba;
3085         command_packet->byte6.block_count = num_sectors;
3086
3087         /* Do this if there are no sg list entries */
3088         if (tw_dev->srb[request_id]->use_sg == 0) {
3089                 dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_read_write(): SG = 0\n");
3090                 buffaddr = tw_map_scsi_single_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
3091                 if (buffaddr == 0)
3092                         return 1;
3093
3094                 command_packet->byte8.io.sgl[0].address = buffaddr;
3095                 command_packet->byte8.io.sgl[0].length = tw_dev->srb[request_id]->request_bufflen;
3096                 command_packet->size+=2;
3097         }
3098
3099         /* Do this if we have multiple sg list entries */
3100         if (tw_dev->srb[request_id]->use_sg > 0) {
3101                 use_sg = tw_map_scsi_sg_data(tw_dev->tw_pci_dev, tw_dev->srb[request_id]);
3102                 if (use_sg == 0)
3103                         return 1;
3104
3105                 for (i=0;i<use_sg; i++) {
3106                         command_packet->byte8.io.sgl[i].address = sg_dma_address(&sglist[i]);
3107                         command_packet->byte8.io.sgl[i].length = sg_dma_len(&sglist[i]);
3108                         command_packet->size+=2;
3109                 }
3110         }
3111
3112         /* Update SG statistics */
3113         tw_dev->sgl_entries = tw_dev->srb[request_id]->use_sg;
3114         if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
3115                 tw_dev->max_sgl_entries = tw_dev->sgl_entries;
3116
3117         command_que_value = tw_dev->command_packet_physical_address[request_id];
3118         if (command_que_value == 0) {
3119                 dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_read_write(): Bad command packet physical address.\n");
3120                 return 1;
3121         }
3122
3123         /* Now try to post the command to the board */
3124         tw_post_command_packet(tw_dev, request_id);
3125
3126         return 0;
3127 } /* End tw_scsiop_read_write() */
3128
3129 /* This function will handle the request sense scsi command */
3130 int tw_scsiop_request_sense(TW_Device_Extension *tw_dev, int request_id)
3131 {
3132         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_request_sense()\n");
3133
3134         /* For now we just zero the request buffer */
3135         memset(tw_dev->srb[request_id]->request_buffer, 0, tw_dev->srb[request_id]->request_bufflen);
3136         tw_dev->state[request_id] = TW_S_COMPLETED;
3137         tw_state_request_finish(tw_dev, request_id);
3138
3139         /* If we got a request_sense, we probably want a reset, return error */
3140         tw_dev->srb[request_id]->result = (DID_ERROR << 16);
3141         tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
3142
3143         return 0;
3144 } /* End tw_scsiop_request_sense() */
3145
3146 /* This function will handle synchronize cache scsi command */
3147 int tw_scsiop_synchronize_cache(TW_Device_Extension *tw_dev, int request_id)
3148 {
3149         TW_Command *command_packet;
3150         unsigned long command_que_value;
3151
3152         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_synchronize_cache()\n");
3153
3154         /* Send firmware flush command for this unit */
3155         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
3156         if (command_packet == NULL) {
3157                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet virtual address.\n");
3158                 return 1;
3159         }
3160
3161         /* Setup the command packet */
3162         memset(command_packet, 0, sizeof(TW_Sector));
3163         command_packet->byte0.opcode = TW_OP_FLUSH_CACHE;
3164         command_packet->byte0.sgl_offset = 0;
3165         command_packet->size = 2;
3166         command_packet->request_id = request_id;
3167         command_packet->byte3.unit = tw_dev->srb[request_id]->device->id;
3168         command_packet->byte3.host_id = 0;
3169         command_packet->status = 0;
3170         command_packet->flags = 0;
3171         command_packet->byte6.parameter_count = 1;
3172         command_que_value = tw_dev->command_packet_physical_address[request_id];
3173         if (command_que_value == 0) {
3174                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_synchronize_cache(): Bad command packet physical address.\n");
3175                 return 1;
3176         }
3177
3178         /* Now try to post the command packet */
3179         tw_post_command_packet(tw_dev, request_id);
3180
3181         return 0;
3182 } /* End tw_scsiop_synchronize_cache() */
3183
3184 /* This function will handle test unit ready scsi command */
3185 int tw_scsiop_test_unit_ready(TW_Device_Extension *tw_dev, int request_id)
3186 {
3187         TW_Param *param;
3188         TW_Command *command_packet;
3189         unsigned long command_que_value;
3190         u32 command_que_addr;
3191         unsigned long param_value;
3192
3193         dprintk(KERN_NOTICE "3w-xxxx: tw_scsiop_test_unit_ready()\n");
3194
3195         /* Initialize command packet */
3196         command_que_addr = tw_dev->registers.command_que_addr;
3197         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
3198         if (command_packet == NULL) {
3199                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet virtual address.\n");
3200                 return 1;
3201         }
3202         memset(command_packet, 0, sizeof(TW_Sector));
3203         command_packet->byte0.opcode = TW_OP_GET_PARAM;
3204         command_packet->byte0.sgl_offset = 2;
3205         command_packet->size = 4;
3206         command_packet->request_id = request_id;
3207         command_packet->byte3.unit = 0;
3208         command_packet->byte3.host_id = 0;
3209         command_packet->status = 0;
3210         command_packet->flags = 0;
3211         command_packet->byte6.parameter_count = 1;
3212
3213         /* Now setup the param */
3214         if (tw_dev->alignment_virtual_address[request_id] == NULL) {
3215                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment virtual address.\n");
3216                 return 1;
3217         }
3218         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
3219         memset(param, 0, sizeof(TW_Sector));
3220         param->table_id = 3;     /* unit summary table */
3221         param->parameter_id = 3; /* unitsstatus parameter */
3222         param->parameter_size_bytes = TW_MAX_UNITS;
3223         param_value = tw_dev->alignment_physical_address[request_id];
3224         if (param_value == 0) {
3225                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad alignment physical address.\n");
3226                 return 1;
3227         }
3228
3229         command_packet->byte8.param.sgl[0].address = param_value;
3230         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
3231         command_que_value = tw_dev->command_packet_physical_address[request_id];
3232         if (command_que_value == 0) {
3233                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready(): Bad command packet physical address.\n");
3234                 return 1;
3235         }
3236
3237         /* Now try to post the command packet */
3238         tw_post_command_packet(tw_dev, request_id);
3239
3240         return 0;
3241 } /* End tw_scsiop_test_unit_ready() */
3242
3243 /* This function is called by the isr to complete a testunitready command */
3244 int tw_scsiop_test_unit_ready_complete(TW_Device_Extension *tw_dev, int request_id)
3245 {
3246         unsigned char *is_unit_present;
3247         TW_Param *param;
3248
3249         dprintk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete()\n");
3250
3251         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
3252         if (param == NULL) {
3253                 printk(KERN_WARNING "3w-xxxx: tw_scsiop_test_unit_ready_complete(): Bad alignment virtual address.\n");
3254                 return 1;
3255         }
3256         is_unit_present = &(param->data[0]);
3257
3258         if (is_unit_present[tw_dev->srb[request_id]->device->id] & TW_UNIT_ONLINE) {
3259                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = TRUE;
3260         } else {
3261                 tw_dev->is_unit_present[tw_dev->srb[request_id]->device->id] = FALSE;
3262                 tw_dev->srb[request_id]->result = (DID_BAD_TARGET << 16);
3263                 return TW_ISR_DONT_RESULT;
3264         }
3265
3266         return 0;
3267 } /* End tw_scsiop_test_unit_ready_complete() */
3268
3269 /* Set a value in the features table */
3270 int tw_setfeature(TW_Device_Extension *tw_dev, int parm, int param_size,
3271                   unsigned char *val)
3272 {
3273         TW_Param *param;
3274         TW_Command  *command_packet;
3275         TW_Response_Queue response_queue;
3276         int request_id = 0;
3277         unsigned long command_que_value;
3278         u32 command_que_addr;
3279         u32 response_que_addr;
3280         unsigned long param_value;
3281
3282         /* Initialize SetParam command packet */
3283         if (tw_dev->command_packet_virtual_address[request_id] == NULL) {
3284                 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet virtual address.\n");
3285                 return 1;
3286         }
3287         command_packet = (TW_Command *)tw_dev->command_packet_virtual_address[request_id];
3288         memset(command_packet, 0, sizeof(TW_Sector));
3289         param = (TW_Param *)tw_dev->alignment_virtual_address[request_id];
3290
3291         command_packet->byte0.opcode = TW_OP_SET_PARAM;
3292         command_packet->byte0.sgl_offset  = 2;
3293         param->table_id = 0x404;  /* Features table */
3294         param->parameter_id = parm;
3295         param->parameter_size_bytes = param_size;
3296         memcpy(param->data, val, param_size);
3297
3298         param_value = tw_dev->alignment_physical_address[request_id];
3299         if (param_value == 0) {
3300                 printk(KERN_WARNING "3w-xxxx: tw_ioctl(): Bad alignment physical address.\n");
3301                 tw_dev->state[request_id] = TW_S_COMPLETED;
3302                 tw_state_request_finish(tw_dev, request_id);
3303                 tw_dev->srb[request_id]->result = (DID_OK << 16);
3304                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
3305         }
3306         command_packet->byte8.param.sgl[0].address = param_value;
3307         command_packet->byte8.param.sgl[0].length = sizeof(TW_Sector);
3308
3309         command_packet->size = 4;
3310         command_packet->request_id = request_id;
3311         command_packet->byte6.parameter_count = 1;
3312
3313         command_que_value = tw_dev->command_packet_physical_address[request_id];
3314         if (command_que_value == 0) {
3315                 printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Bad command packet physical address.\n");
3316         return 1;
3317         }
3318         command_que_addr = tw_dev->registers.command_que_addr;
3319         response_que_addr = tw_dev->registers.response_que_addr;
3320
3321         /* Send command packet to the board */
3322         outl(command_que_value, command_que_addr);
3323
3324         /* Poll for completion */
3325         if (tw_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, 30) == 0) {
3326                 response_queue.value = inl(response_que_addr);
3327                 request_id = (unsigned char)response_queue.u.response_id;
3328                 if (request_id != 0) {
3329                         /* unexpected request id */
3330                         printk(KERN_WARNING "3w-xxxx: tw_setfeature(): Unexpected request id.\n");
3331                         return 1;
3332                 }
3333                 if (command_packet->status != 0) {
3334                         /* bad response */
3335                         tw_decode_sense(tw_dev, request_id, 0);
3336                         return 1;
3337                 }
3338         }
3339
3340         return 0;
3341 } /* End tw_setfeature() */
3342
3343 /* This function will setup the interrupt handler */
3344 int tw_setup_irq(TW_Device_Extension *tw_dev)
3345 {
3346         char *device = TW_DEVICE_NAME;
3347         int error;
3348
3349         dprintk(KERN_NOTICE "3w-xxxx: tw_setup_irq()\n");
3350         error = request_irq(tw_dev->tw_pci_dev->irq, tw_interrupt, SA_SHIRQ, device, tw_dev);
3351
3352         if (error < 0) {
3353                 printk(KERN_WARNING "3w-xxxx: scsi%d: Error requesting IRQ: %d.\n", tw_dev->host->host_no, tw_dev->tw_pci_dev->irq);
3354                 return 1;
3355         }
3356         return 0;
3357 } /* End tw_setup_irq() */
3358
3359 /* This function will tell the controller we're shutting down by sending
3360    initconnection with a 1 */
3361 int tw_shutdown_device(TW_Device_Extension *tw_dev)
3362 {
3363         int error;
3364
3365         /* Disable interrupts */
3366         tw_disable_interrupts(tw_dev);
3367
3368         /* poke the board */
3369         error = tw_initconnection(tw_dev, 1);
3370         if (error) {
3371                 printk(KERN_WARNING "3w-xxxx: scsi%d: Connection shutdown failed.\n", tw_dev->host->host_no);
3372         } else {
3373                 printk(KERN_NOTICE "3w-xxxx: Shutdown complete.\n");
3374         }
3375
3376         /* Re-enable interrupts */
3377         tw_enable_and_clear_interrupts(tw_dev);
3378
3379         return 0;
3380 } /* End tw_shutdown_device() */
3381
3382 /* This function will configure individual target parameters */
3383 int tw_slave_configure(Scsi_Device *SDptr)
3384 {
3385         int max_cmds;
3386
3387         dprintk(KERN_WARNING "3w-xxxx: tw_slave_configure()\n");
3388
3389 #ifdef CONFIG_3W_XXXX_CMD_PER_LUN
3390         max_cmds = CONFIG_3W_XXXX_CMD_PER_LUN;
3391         if (max_cmds > TW_MAX_CMDS_PER_LUN)
3392                 max_cmds = TW_MAX_CMDS_PER_LUN;
3393 #else
3394         max_cmds = TW_MAX_CMDS_PER_LUN;
3395 #endif
3396         scsi_adjust_queue_depth(SDptr, MSG_ORDERED_TAG, max_cmds);
3397
3398         return 0;
3399 } /* End tw_slave_configure() */
3400
3401 /* This function will soft reset the controller */
3402 void tw_soft_reset(TW_Device_Extension *tw_dev)
3403 {
3404         u32 control_reg_addr, control_reg_value;
3405
3406         control_reg_addr = tw_dev->registers.control_reg_addr;
3407         control_reg_value = (   TW_CONTROL_ISSUE_SOFT_RESET |
3408                                 TW_CONTROL_CLEAR_HOST_INTERRUPT |
3409                                 TW_CONTROL_CLEAR_ATTENTION_INTERRUPT |
3410                                 TW_CONTROL_MASK_COMMAND_INTERRUPT |
3411                                 TW_CONTROL_MASK_RESPONSE_INTERRUPT |
3412                                 TW_CONTROL_CLEAR_ERROR_STATUS |
3413                                 TW_CONTROL_DISABLE_INTERRUPTS);
3414         outl(control_reg_value, control_reg_addr);
3415 } /* End tw_soft_reset() */
3416
3417 /* This function will free a request_id */
3418 int tw_state_request_finish(TW_Device_Extension *tw_dev, int request_id)
3419 {
3420         dprintk(KERN_NOTICE "3w-xxxx: tw_state_request_finish()\n");
3421
3422         tw_dev->free_queue[tw_dev->free_tail] = request_id;
3423         tw_dev->state[request_id] = TW_S_FINISHED;
3424         if (tw_dev->free_tail == tw_dev->free_wrap)
3425                 tw_dev->free_tail = TW_Q_START;
3426         else
3427                 tw_dev->free_tail++;
3428
3429         dprintk(KERN_NOTICE "3w-xxxx: tw_state_request_finish(): Freeing request_id %d\n", request_id);
3430
3431         return 0;
3432 } /* End tw_state_request_finish() */
3433
3434 /* This function will assign an available request_id */
3435 int tw_state_request_start(TW_Device_Extension *tw_dev, int *request_id)
3436 {
3437         int id = 0;
3438
3439         dprintk(KERN_NOTICE "3w-xxxx: tw_state_request_start()\n");
3440
3441         /* Obtain next free request_id */
3442         id = tw_dev->free_queue[tw_dev->free_head];
3443         if (tw_dev->free_head == tw_dev->free_wrap)
3444                 tw_dev->free_head = TW_Q_START;
3445         else
3446                 tw_dev->free_head++;
3447
3448         *request_id = id;
3449         tw_dev->state[id] = TW_S_STARTED;
3450
3451         dprintk(KERN_NOTICE "3w-xxxx: tw_state_request_start(): id = %d.\n", id);
3452         return 0;
3453 } /* End tw_state_request_start() */
3454
3455 static void tw_unmap_scsi_data(struct pci_dev *pdev, Scsi_Cmnd *cmd)
3456 {
3457         int dma_dir = scsi_to_pci_dma_dir(cmd->sc_data_direction);
3458
3459         dprintk(KERN_WARNING "3w-xxxx: tw_unmap_scsi_data()\n");
3460
3461         switch(cmd->SCp.phase) {
3462                 case 1:
3463                         pci_unmap_page(pdev, cmd->SCp.have_data_in, cmd->request_bufflen, dma_dir);
3464                         break;
3465                 case 2:
3466                         pci_unmap_sg(pdev, cmd->request_buffer, cmd->use_sg, dma_dir);
3467                         break;
3468         }
3469 } /* End tw_unmap_scsi_data() */
3470
3471 /* This function will unmask the command interrupt on the controller */
3472 void tw_unmask_command_interrupt(TW_Device_Extension *tw_dev)
3473 {
3474         u32 control_reg_addr, control_reg_value;
3475
3476         control_reg_addr = tw_dev->registers.control_reg_addr;
3477         control_reg_value = TW_CONTROL_UNMASK_COMMAND_INTERRUPT;
3478         outl(control_reg_value, control_reg_addr);
3479 } /* End tw_unmask_command_interrupt() */
3480
3481 static Scsi_Host_Template driver_template = {
3482         .proc_name              = "3w-xxxx",
3483         .proc_info              = tw_scsi_proc_info,
3484         .name                   = "3ware Storage Controller",
3485         .detect                 = tw_scsi_detect,
3486         .release                = tw_scsi_release,
3487         .queuecommand           = tw_scsi_queue,
3488         .eh_abort_handler       = tw_scsi_eh_abort,
3489         .eh_host_reset_handler  = tw_scsi_eh_reset,
3490         .bios_param             = tw_scsi_biosparam,
3491         .can_queue              = TW_Q_LENGTH-2,
3492         .this_id                = -1,
3493         .sg_tablesize           = TW_MAX_SGL_LENGTH,
3494         .max_sectors            = TW_MAX_SECTORS,
3495         .cmd_per_lun            = TW_MAX_CMDS_PER_LUN,
3496         .use_clustering         = ENABLE_CLUSTERING,
3497         .emulated               = 1
3498 };
3499 #include "scsi_module.c"
3500