drivers/scsi/3w-xxxx.c

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