drivers/scsi/3w-xxxx.c

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

DEFINITIONS
