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