git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/3w-9xxx.c

   1 /*
   2    3w-9xxx.c -- 3ware 9000 Storage Controller device driver for Linux.
   3
   4    Written By: Adam Radford <linuxraid@amcc.com>
   5    Modifications By: Tom Couch <linuxraid@amcc.com>
   6
   7    Copyright (C) 2004-2007 Applied Micro Circuits Corporation.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; version 2 of the License.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    NO WARRANTY
  19    THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  20    CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  21    LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  22    MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  23    solely responsible for determining the appropriateness of using and
  24    distributing the Program and assumes all risks associated with its
  25    exercise of rights under this Agreement, including but not limited to
  26    the risks and costs of program errors, damage to or loss of data,
  27    programs or equipment, and unavailability or interruption of operations.
  28
  29    DISCLAIMER OF LIABILITY
  30    NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  31    DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32    DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  33    ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  34    TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  35    USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  36    HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  37
  38    You should have received a copy of the GNU General Public License
  39    along with this program; if not, write to the Free Software
  40    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  41
  42    Bugs/Comments/Suggestions should be mailed to:
  43    linuxraid@amcc.com
  44
  45    For more information, goto:
  46    http://www.amcc.com
  47
  48    Note: This version of the driver does not contain a bundled firmware
  49          image.
  50
  51    History
  52    -------
  53    2.26.02.000 - Driver cleanup for kernel submission.
  54    2.26.02.001 - Replace schedule_timeout() calls with msleep().
  55    2.26.02.002 - Add support for PAE mode.
  56                  Add lun support.
  57                  Fix twa_remove() to free irq handler/unregister_chrdev()
  58                  before shutting down card.
  59                  Change to new 'change_queue_depth' api.
  60                  Fix 'handled=1' ISR usage, remove bogus IRQ check.
  61                  Remove un-needed eh_abort handler.
  62                  Add support for embedded firmware error strings.
  63    2.26.02.003 - Correctly handle single sgl's with use_sg=1.
  64    2.26.02.004 - Add support for 9550SX controllers.
  65    2.26.02.005 - Fix use_sg == 0 mapping on systems with 4GB or higher.
  66    2.26.02.006 - Fix 9550SX pchip reset timeout.
  67                  Add big endian support.
  68    2.26.02.007 - Disable local interrupts during kmap/unmap_atomic().
  69    2.26.02.008 - Free irq handler in __twa_shutdown().
  70                  Serialize reset code.
  71                  Add support for 9650SE controllers.
  72    2.26.02.009 - Fix dma mask setting to fallback to 32-bit if 64-bit fails.
  73    2.26.02.010 - Add support for 9690SA controllers.
  74 */
  75
  76 #include <linux/module.h>
  77 #include <linux/reboot.h>
  78 #include <linux/spinlock.h>
  79 #include <linux/interrupt.h>
  80 #include <linux/moduleparam.h>
  81 #include <linux/errno.h>
  82 #include <linux/types.h>
  83 #include <linux/delay.h>
  84 #include <linux/pci.h>
  85 #include <linux/time.h>
  86 #include <linux/mutex.h>
  87 #include <asm/io.h>
  88 #include <asm/irq.h>
  89 #include <asm/uaccess.h>
  90 #include <scsi/scsi.h>
  91 #include <scsi/scsi_host.h>
  92 #include <scsi/scsi_tcq.h>
  93 #include <scsi/scsi_cmnd.h>
  94 #include "3w-9xxx.h"
  95
  96 /* Globals */
  97 #define TW_DRIVER_VERSION "2.26.02.010"
  98 static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT];
  99 static unsigned int twa_device_extension_count;
 100 static int twa_major = -1;
 101 extern struct timezone sys_tz;
 102
 103 /* Module parameters */
 104 MODULE_AUTHOR ("AMCC");
 105 MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver");
 106 MODULE_LICENSE("GPL");
 107 MODULE_VERSION(TW_DRIVER_VERSION);
 108
 109 /* Function prototypes */
 110 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header);
 111 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id);
 112 static char *twa_aen_severity_lookup(unsigned char severity_code);
 113 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id);
 114 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
 115 static int twa_chrdev_open(struct inode *inode, struct file *file);
 116 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host);
 117 static void twa_free_request_id(TW_Device_Extension *tw_dev,int request_id);
 118 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id);
 119 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
 120                               u32 set_features, unsigned short current_fw_srl,
 121                               unsigned short current_fw_arch_id,
 122                               unsigned short current_fw_branch,
 123                               unsigned short current_fw_build,
 124                               unsigned short *fw_on_ctlr_srl,
 125                               unsigned short *fw_on_ctlr_arch_id,
 126                               unsigned short *fw_on_ctlr_branch,
 127                               unsigned short *fw_on_ctlr_build,
 128                               u32 *init_connect_result);
 129 static void twa_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length);
 130 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds);
 131 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds);
 132 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal);
 133 static int twa_reset_device_extension(TW_Device_Extension *tw_dev);
 134 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset);
 135 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg);
 136 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id);
 137 static char *twa_string_lookup(twa_message_type *table, unsigned int aen_code);
 138 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id);
 139
 140 /* Functions */
 141
 142 /* Show some statistics about the card */
 143 static ssize_t twa_show_stats(struct class_device *class_dev, char *buf)
 144 {
 145         struct Scsi_Host *host = class_to_shost(class_dev);
 146         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
 147         unsigned long flags = 0;
 148         ssize_t len;
 149
 150         spin_lock_irqsave(tw_dev->host->host_lock, flags);
 151         len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n"
 152                        "Current commands posted:   %4d\n"
 153                        "Max commands posted:       %4d\n"
 154                        "Current pending commands:  %4d\n"
 155                        "Max pending commands:      %4d\n"
 156                        "Last sgl length:           %4d\n"
 157                        "Max sgl length:            %4d\n"
 158                        "Last sector count:         %4d\n"
 159                        "Max sector count:          %4d\n"
 160                        "SCSI Host Resets:          %4d\n"
 161                        "AEN's:                     %4d\n",
 162                        TW_DRIVER_VERSION,
 163                        tw_dev->posted_request_count,
 164                        tw_dev->max_posted_request_count,
 165                        tw_dev->pending_request_count,
 166                        tw_dev->max_pending_request_count,
 167                        tw_dev->sgl_entries,
 168                        tw_dev->max_sgl_entries,
 169                        tw_dev->sector_count,
 170                        tw_dev->max_sector_count,
 171                        tw_dev->num_resets,
 172                        tw_dev->aen_count);
 173         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 174         return len;
 175 } /* End twa_show_stats() */
 176
 177 /* This function will set a devices queue depth */
 178 static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth)
 179 {
 180         if (queue_depth > TW_Q_LENGTH-2)
 181                 queue_depth = TW_Q_LENGTH-2;
 182         scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
 183         return queue_depth;
 184 } /* End twa_change_queue_depth() */
 185
 186 /* Create sysfs 'stats' entry */
 187 static struct class_device_attribute twa_host_stats_attr = {
 188         .attr = {
 189                 .name =         "stats",
 190                 .mode =         S_IRUGO,
 191         },
 192         .show = twa_show_stats
 193 };
 194
 195 /* Host attributes initializer */
 196 static struct class_device_attribute *twa_host_attrs[] = {
 197         &twa_host_stats_attr,
 198         NULL,
 199 };
 200
 201 /* File operations struct for character device */
 202 static const struct file_operations twa_fops = {
 203         .owner          = THIS_MODULE,
 204         .ioctl          = twa_chrdev_ioctl,
 205         .open           = twa_chrdev_open,
 206         .release        = NULL
 207 };
 208
 209 /* This function will complete an aen request from the isr */
 210 static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id)
 211 {
 212         TW_Command_Full *full_command_packet;
 213         TW_Command *command_packet;
 214         TW_Command_Apache_Header *header;
 215         unsigned short aen;
 216         int retval = 1;
 217
 218         header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
 219         tw_dev->posted_request_count--;
 220         aen = le16_to_cpu(header->status_block.error);
 221         full_command_packet = tw_dev->command_packet_virt[request_id];
 222         command_packet = &full_command_packet->command.oldcommand;
 223
 224         /* First check for internal completion of set param for time sync */
 225         if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
 226                 /* Keep reading the queue in case there are more aen's */
 227                 if (twa_aen_read_queue(tw_dev, request_id))
 228                         goto out2;
 229                 else {
 230                         retval = 0;
 231                         goto out;
 232                 }
 233         }
 234
 235         switch (aen) {
 236         case TW_AEN_QUEUE_EMPTY:
 237                 /* Quit reading the queue if this is the last one */
 238                 break;
 239         case TW_AEN_SYNC_TIME_WITH_HOST:
 240                 twa_aen_sync_time(tw_dev, request_id);
 241                 retval = 0;
 242                 goto out;
 243         default:
 244                 twa_aen_queue_event(tw_dev, header);
 245
 246                 /* If there are more aen's, keep reading the queue */
 247                 if (twa_aen_read_queue(tw_dev, request_id))
 248                         goto out2;
 249                 else {
 250                         retval = 0;
 251                         goto out;
 252                 }
 253         }
 254         retval = 0;
 255 out2:
 256         tw_dev->state[request_id] = TW_S_COMPLETED;
 257         twa_free_request_id(tw_dev, request_id);
 258         clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
 259 out:
 260         return retval;
 261 } /* End twa_aen_complete() */
 262
 263 /* This function will drain aen queue */
 264 static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
 265 {
 266         int request_id = 0;
 267         char cdb[TW_MAX_CDB_LEN];
 268         TW_SG_Entry sglist[1];
 269         int finished = 0, count = 0;
 270         TW_Command_Full *full_command_packet;
 271         TW_Command_Apache_Header *header;
 272         unsigned short aen;
 273         int first_reset = 0, queue = 0, retval = 1;
 274
 275         if (no_check_reset)
 276                 first_reset = 0;
 277         else
 278                 first_reset = 1;
 279
 280         full_command_packet = tw_dev->command_packet_virt[request_id];
 281         memset(full_command_packet, 0, sizeof(TW_Command_Full));
 282
 283         /* Initialize cdb */
 284         memset(&cdb, 0, TW_MAX_CDB_LEN);
 285         cdb[0] = REQUEST_SENSE; /* opcode */
 286         cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
 287
 288         /* Initialize sglist */
 289         memset(&sglist, 0, sizeof(TW_SG_Entry));
 290         sglist[0].length = TW_SECTOR_SIZE;
 291         sglist[0].address = tw_dev->generic_buffer_phys[request_id];
 292
 293         if (sglist[0].address & TW_ALIGNMENT_9000_SGL) {
 294                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain");
 295                 goto out;
 296         }
 297
 298         /* Mark internal command */
 299         tw_dev->srb[request_id] = NULL;
 300
 301         do {
 302                 /* Send command to the board */
 303                 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
 304                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense");
 305                         goto out;
 306                 }
 307
 308                 /* Now poll for completion */
 309                 if (twa_poll_response(tw_dev, request_id, 30)) {
 310                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue");
 311                         tw_dev->posted_request_count--;
 312                         goto out;
 313                 }
 314
 315                 tw_dev->posted_request_count--;
 316                 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
 317                 aen = le16_to_cpu(header->status_block.error);
 318                 queue = 0;
 319                 count++;
 320
 321                 switch (aen) {
 322                 case TW_AEN_QUEUE_EMPTY:
 323                         if (first_reset != 1)
 324                                 goto out;
 325                         else
 326                                 finished = 1;
 327                         break;
 328                 case TW_AEN_SOFT_RESET:
 329                         if (first_reset == 0)
 330                                 first_reset = 1;
 331                         else
 332                                 queue = 1;
 333                         break;
 334                 case TW_AEN_SYNC_TIME_WITH_HOST:
 335                         break;
 336                 default:
 337                         queue = 1;
 338                 }
 339
 340                 /* Now queue an event info */
 341                 if (queue)
 342                         twa_aen_queue_event(tw_dev, header);
 343         } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
 344
 345         if (count == TW_MAX_AEN_DRAIN)
 346                 goto out;
 347
 348         retval = 0;
 349 out:
 350         tw_dev->state[request_id] = TW_S_INITIAL;
 351         return retval;
 352 } /* End twa_aen_drain_queue() */
 353
 354 /* This function will queue an event */
 355 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
 356 {
 357         u32 local_time;
 358         struct timeval time;
 359         TW_Event *event;
 360         unsigned short aen;
 361         char host[16];
 362         char *error_str;
 363
 364         tw_dev->aen_count++;
 365
 366         /* Fill out event info */
 367         event = tw_dev->event_queue[tw_dev->error_index];
 368
 369         /* Check for clobber */
 370         host[0] = '\0';
 371         if (tw_dev->host) {
 372                 sprintf(host, " scsi%d:", tw_dev->host->host_no);
 373                 if (event->retrieved == TW_AEN_NOT_RETRIEVED)
 374                         tw_dev->aen_clobber = 1;
 375         }
 376
 377         aen = le16_to_cpu(header->status_block.error);
 378         memset(event, 0, sizeof(TW_Event));
 379
 380         event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
 381         do_gettimeofday(&time);
 382         local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
 383         event->time_stamp_sec = local_time;
 384         event->aen_code = aen;
 385         event->retrieved = TW_AEN_NOT_RETRIEVED;
 386         event->sequence_id = tw_dev->error_sequence_id;
 387         tw_dev->error_sequence_id++;
 388
 389         /* Check for embedded error string */
 390         error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
 391
 392         header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
 393         event->parameter_len = strlen(header->err_specific_desc);
 394         memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + (error_str[0] == '\0' ? 0 : (1 + strlen(error_str))));
 395         if (event->severity != TW_AEN_SEVERITY_DEBUG)
 396                 printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
 397                        host,
 398                        twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
 399                        TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen,
 400                        error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str,
 401                        header->err_specific_desc);
 402         else
 403                 tw_dev->aen_count--;
 404
 405         if ((tw_dev->error_index + 1) == TW_Q_LENGTH)
 406                 tw_dev->event_queue_wrapped = 1;
 407         tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
 408 } /* End twa_aen_queue_event() */
 409
 410 /* This function will read the aen queue from the isr */
 411 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
 412 {
 413         char cdb[TW_MAX_CDB_LEN];
 414         TW_SG_Entry sglist[1];
 415         TW_Command_Full *full_command_packet;
 416         int retval = 1;
 417
 418         full_command_packet = tw_dev->command_packet_virt[request_id];
 419         memset(full_command_packet, 0, sizeof(TW_Command_Full));
 420
 421         /* Initialize cdb */
 422         memset(&cdb, 0, TW_MAX_CDB_LEN);
 423         cdb[0] = REQUEST_SENSE; /* opcode */
 424         cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
 425
 426         /* Initialize sglist */
 427         memset(&sglist, 0, sizeof(TW_SG_Entry));
 428         sglist[0].length = TW_SECTOR_SIZE;
 429         sglist[0].address = tw_dev->generic_buffer_phys[request_id];
 430
 431         /* Mark internal command */
 432         tw_dev->srb[request_id] = NULL;
 433
 434         /* Now post the command packet */
 435         if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
 436                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue");
 437                 goto out;
 438         }
 439         retval = 0;
 440 out:
 441         return retval;
 442 } /* End twa_aen_read_queue() */
 443
 444 /* This function will look up an AEN severity string */
 445 static char *twa_aen_severity_lookup(unsigned char severity_code)
 446 {
 447         char *retval = NULL;
 448
 449         if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
 450             (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
 451                 goto out;
 452
 453         retval = twa_aen_severity_table[severity_code];
 454 out:
 455         return retval;
 456 } /* End twa_aen_severity_lookup() */
 457
 458 /* This function will sync firmware time with the host time */
 459 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
 460 {
 461         u32 schedulertime;
 462         struct timeval utc;
 463         TW_Command_Full *full_command_packet;
 464         TW_Command *command_packet;
 465         TW_Param_Apache *param;
 466         u32 local_time;
 467
 468         /* Fill out the command packet */
 469         full_command_packet = tw_dev->command_packet_virt[request_id];
 470         memset(full_command_packet, 0, sizeof(TW_Command_Full));
 471         command_packet = &full_command_packet->command.oldcommand;
 472         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
 473         command_packet->request_id = request_id;
 474         command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
 475         command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
 476         command_packet->size = TW_COMMAND_SIZE;
 477         command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
 478
 479         /* Setup the param */
 480         param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
 481         memset(param, 0, TW_SECTOR_SIZE);
 482         param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
 483         param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
 484         param->parameter_size_bytes = cpu_to_le16(4);
 485
 486         /* Convert system time in UTC to local time seconds since last
 487            Sunday 12:00AM */
 488         do_gettimeofday(&utc);
 489         local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
 490         schedulertime = local_time - (3 * 86400);
 491         schedulertime = cpu_to_le32(schedulertime % 604800);
 492
 493         memcpy(param->data, &schedulertime, sizeof(u32));
 494
 495         /* Mark internal command */
 496         tw_dev->srb[request_id] = NULL;
 497
 498         /* Now post the command */
 499         twa_post_command_packet(tw_dev, request_id, 1);
 500 } /* End twa_aen_sync_time() */
 501
 502 /* This function will allocate memory and check if it is correctly aligned */
 503 static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
 504 {
 505         int i;
 506         dma_addr_t dma_handle;
 507         unsigned long *cpu_addr;
 508         int retval = 1;
 509
 510         cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
 511         if (!cpu_addr) {
 512                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
 513                 goto out;
 514         }
 515
 516         if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {
 517                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");
 518                 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
 519                 goto out;
 520         }
 521
 522         memset(cpu_addr, 0, size*TW_Q_LENGTH);
 523
 524         for (i = 0; i < TW_Q_LENGTH; i++) {
 525                 switch(which) {
 526                 case 0:
 527                         tw_dev->command_packet_phys[i] = dma_handle+(i*size);
 528                         tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
 529                         break;
 530                 case 1:
 531                         tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
 532                         tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
 533                         break;
 534                 }
 535         }
 536         retval = 0;
 537 out:
 538         return retval;
 539 } /* End twa_allocate_memory() */
 540
 541 /* This function will check the status register for unexpected bits */
 542 static int twa_check_bits(u32 status_reg_value)
 543 {
 544         int retval = 1;
 545
 546         if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS)
 547                 goto out;
 548         if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0)
 549                 goto out;
 550
 551         retval = 0;
 552 out:
 553         return retval;
 554 } /* End twa_check_bits() */
 555
 556 /* This function will check the srl and decide if we are compatible  */
 557 static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed)
 558 {
 559         int retval = 1;
 560         unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
 561         unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
 562         u32 init_connect_result = 0;
 563
 564         if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
 565                                TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
 566                                TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
 567                                TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
 568                                &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
 569                                &fw_on_ctlr_build, &init_connect_result)) {
 570                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL");
 571                 goto out;
 572         }
 573
 574         tw_dev->tw_compat_info.working_srl = fw_on_ctlr_srl;
 575         tw_dev->tw_compat_info.working_branch = fw_on_ctlr_branch;
 576         tw_dev->tw_compat_info.working_build = fw_on_ctlr_build;
 577
 578         /* Try base mode compatibility */
 579         if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
 580                 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
 581                                        TW_EXTENDED_INIT_CONNECT,
 582                                        TW_BASE_FW_SRL, TW_9000_ARCH_ID,
 583                                        TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD,
 584                                        &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
 585                                        &fw_on_ctlr_branch, &fw_on_ctlr_build,
 586                                        &init_connect_result)) {
 587                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL");
 588                         goto out;
 589                 }
 590                 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
 591                         if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) {
 592                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware");
 593                         } else {
 594                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver");
 595                         }
 596                         goto out;
 597                 }
 598                 tw_dev->tw_compat_info.working_srl = TW_BASE_FW_SRL;
 599                 tw_dev->tw_compat_info.working_branch = TW_BASE_FW_BRANCH;
 600                 tw_dev->tw_compat_info.working_build = TW_BASE_FW_BUILD;
 601         }
 602
 603         /* Load rest of compatibility struct */
 604         strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
 605         tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
 606         tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
 607         tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
 608         tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
 609         tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
 610         tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
 611         tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
 612         tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
 613         tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
 614
 615         retval = 0;
 616 out:
 617         return retval;
 618 } /* End twa_check_srl() */
 619
 620 /* This function handles ioctl for the character device */
 621 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 622 {
 623         long timeout;
 624         unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
 625         dma_addr_t dma_handle;
 626         int request_id = 0;
 627         unsigned int sequence_id = 0;
 628         unsigned char event_index, start_index;
 629         TW_Ioctl_Driver_Command driver_command;
 630         TW_Ioctl_Buf_Apache *tw_ioctl;
 631         TW_Lock *tw_lock;
 632         TW_Command_Full *full_command_packet;
 633         TW_Compatibility_Info *tw_compat_info;
 634         TW_Event *event;
 635         struct timeval current_time;
 636         u32 current_time_ms;
 637         TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)];
 638         int retval = TW_IOCTL_ERROR_OS_EFAULT;
 639         void __user *argp = (void __user *)arg;
 640
 641         /* Only let one of these through at a time */
 642         if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
 643                 retval = TW_IOCTL_ERROR_OS_EINTR;
 644                 goto out;
 645         }
 646
 647         /* First copy down the driver command */
 648         if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
 649                 goto out2;
 650
 651         /* Check data buffer size */
 652         if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
 653                 retval = TW_IOCTL_ERROR_OS_EINVAL;
 654                 goto out2;
 655         }
 656
 657         /* Hardware can only do multiple of 512 byte transfers */
 658         data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
 659
 660         /* Now allocate ioctl buf memory */
 661         cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, &dma_handle, GFP_KERNEL);
 662         if (!cpu_addr) {
 663                 retval = TW_IOCTL_ERROR_OS_ENOMEM;
 664                 goto out2;
 665         }
 666
 667         tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
 668
 669         /* Now copy down the entire ioctl */
 670         if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
 671                 goto out3;
 672
 673         /* See which ioctl we are doing */
 674         switch (cmd) {
 675         case TW_IOCTL_FIRMWARE_PASS_THROUGH:
 676                 spin_lock_irqsave(tw_dev->host->host_lock, flags);
 677                 twa_get_request_id(tw_dev, &request_id);
 678
 679                 /* Flag internal command */
 680                 tw_dev->srb[request_id] = NULL;
 681
 682                 /* Flag chrdev ioctl */
 683                 tw_dev->chrdev_request_id = request_id;
 684
 685                 full_command_packet = &tw_ioctl->firmware_command;
 686
 687                 /* Load request id and sglist for both command types */
 688                 twa_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
 689
 690                 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
 691
 692                 /* Now post the command packet to the controller */
 693                 twa_post_command_packet(tw_dev, request_id, 1);
 694                 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 695
 696                 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
 697
 698                 /* Now wait for command to complete */
 699                 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
 700
 701                 /* We timed out, and didn't get an interrupt */
 702                 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
 703                         /* Now we need to reset the board */
 704                         printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
 705                                tw_dev->host->host_no, TW_DRIVER, 0x37,
 706                                cmd);
 707                         retval = TW_IOCTL_ERROR_OS_EIO;
 708                         twa_reset_device_extension(tw_dev);
 709                         goto out3;
 710                 }
 711
 712                 /* Now copy in the command packet response */
 713                 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
 714
 715                 /* Now complete the io */
 716                 spin_lock_irqsave(tw_dev->host->host_lock, flags);
 717                 tw_dev->posted_request_count--;
 718                 tw_dev->state[request_id] = TW_S_COMPLETED;
 719                 twa_free_request_id(tw_dev, request_id);
 720                 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 721                 break;
 722         case TW_IOCTL_GET_COMPATIBILITY_INFO:
 723                 tw_ioctl->driver_command.status = 0;
 724                 /* Copy compatiblity struct into ioctl data buffer */
 725                 tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
 726                 memcpy(tw_compat_info, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
 727                 break;
 728         case TW_IOCTL_GET_LAST_EVENT:
 729                 if (tw_dev->event_queue_wrapped) {
 730                         if (tw_dev->aen_clobber) {
 731                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
 732                                 tw_dev->aen_clobber = 0;
 733                         } else
 734                                 tw_ioctl->driver_command.status = 0;
 735                 } else {
 736                         if (!tw_dev->error_index) {
 737                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 738                                 break;
 739                         }
 740                         tw_ioctl->driver_command.status = 0;
 741                 }
 742                 event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH;
 743                 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 744                 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 745                 break;
 746         case TW_IOCTL_GET_FIRST_EVENT:
 747                 if (tw_dev->event_queue_wrapped) {
 748                         if (tw_dev->aen_clobber) {
 749                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
 750                                 tw_dev->aen_clobber = 0;
 751                         } else
 752                                 tw_ioctl->driver_command.status = 0;
 753                         event_index = tw_dev->error_index;
 754                 } else {
 755                         if (!tw_dev->error_index) {
 756                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 757                                 break;
 758                         }
 759                         tw_ioctl->driver_command.status = 0;
 760                         event_index = 0;
 761                 }
 762                 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 763                 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 764                 break;
 765         case TW_IOCTL_GET_NEXT_EVENT:
 766                 event = (TW_Event *)tw_ioctl->data_buffer;
 767                 sequence_id = event->sequence_id;
 768                 tw_ioctl->driver_command.status = 0;
 769
 770                 if (tw_dev->event_queue_wrapped) {
 771                         if (tw_dev->aen_clobber) {
 772                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
 773                                 tw_dev->aen_clobber = 0;
 774                         }
 775                         start_index = tw_dev->error_index;
 776                 } else {
 777                         if (!tw_dev->error_index) {
 778                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 779                                 break;
 780                         }
 781                         start_index = 0;
 782                 }
 783                 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH;
 784
 785                 if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) {
 786                         if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
 787                                 tw_dev->aen_clobber = 1;
 788                         tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 789                         break;
 790                 }
 791                 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 792                 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 793                 break;
 794         case TW_IOCTL_GET_PREVIOUS_EVENT:
 795                 event = (TW_Event *)tw_ioctl->data_buffer;
 796                 sequence_id = event->sequence_id;
 797                 tw_ioctl->driver_command.status = 0;
 798
 799                 if (tw_dev->event_queue_wrapped) {
 800                         if (tw_dev->aen_clobber) {
 801                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
 802                                 tw_dev->aen_clobber = 0;
 803                         }
 804                         start_index = tw_dev->error_index;
 805                 } else {
 806                         if (!tw_dev->error_index) {
 807                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 808                                 break;
 809                         }
 810                         start_index = 0;
 811                 }
 812                 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH;
 813
 814                 if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) {
 815                         if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
 816                                 tw_dev->aen_clobber = 1;
 817                         tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 818                         break;
 819                 }
 820                 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 821                 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 822                 break;
 823         case TW_IOCTL_GET_LOCK:
 824                 tw_lock = (TW_Lock *)tw_ioctl->data_buffer;
 825                 do_gettimeofday(&current_time);
 826                 current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000);
 827
 828                 if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) {
 829                         tw_dev->ioctl_sem_lock = 1;
 830                         tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec;
 831                         tw_ioctl->driver_command.status = 0;
 832                         tw_lock->time_remaining_msec = tw_lock->timeout_msec;
 833                 } else {
 834                         tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED;
 835                         tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms;
 836                 }
 837                 break;
 838         case TW_IOCTL_RELEASE_LOCK:
 839                 if (tw_dev->ioctl_sem_lock == 1) {
 840                         tw_dev->ioctl_sem_lock = 0;
 841                         tw_ioctl->driver_command.status = 0;
 842                 } else {
 843                         tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED;
 844                 }
 845                 break;
 846         default:
 847                 retval = TW_IOCTL_ERROR_OS_ENOTTY;
 848                 goto out3;
 849         }
 850
 851         /* Now copy the entire response to userspace */
 852         if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
 853                 retval = 0;
 854 out3:
 855         /* Now free ioctl buf memory */
 856         dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
 857 out2:
 858         mutex_unlock(&tw_dev->ioctl_lock);
 859 out:
 860         return retval;
 861 } /* End twa_chrdev_ioctl() */
 862
 863 /* This function handles open for the character device */
 864 static int twa_chrdev_open(struct inode *inode, struct file *file)
 865 {
 866         unsigned int minor_number;
 867         int retval = TW_IOCTL_ERROR_OS_ENODEV;
 868
 869         minor_number = iminor(inode);
 870         if (minor_number >= twa_device_extension_count)
 871                 goto out;
 872         retval = 0;
 873 out:
 874         return retval;
 875 } /* End twa_chrdev_open() */
 876
 877 /* This function will print readable messages from status register errors */
 878 static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
 879 {
 880         int retval = 1;
 881
 882         /* Check for various error conditions and handle them appropriately */
 883         if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
 884                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
 885                 writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
 886         }
 887
 888         if (status_reg_value & TW_STATUS_PCI_ABORT) {
 889                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
 890                 writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
 891                 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
 892         }
 893
 894         if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
 895                 if (((tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9650SE) &&
 896                      (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9690SA)) ||
 897                     (!test_bit(TW_IN_RESET, &tw_dev->flags)))
 898                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
 899                 writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
 900         }
 901
 902         if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
 903                 if (tw_dev->reset_print == 0) {
 904                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
 905                         tw_dev->reset_print = 1;
 906                 }
 907                 goto out;
 908         }
 909         retval = 0;
 910 out:
 911         return retval;
 912 } /* End twa_decode_bits() */
 913
 914 /* This function will empty the response queue */
 915 static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
 916 {
 917         u32 status_reg_value, response_que_value;
 918         int count = 0, retval = 1;
 919
 920         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
 921
 922         while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
 923                 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
 924                 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
 925                 count++;
 926         }
 927         if (count == TW_MAX_RESPONSE_DRAIN)
 928                 goto out;
 929
 930         retval = 0;
 931 out:
 932         return retval;
 933 } /* End twa_empty_response_queue() */
 934
 935 /* This function will clear the pchip/response queue on 9550SX */
 936 static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
 937 {
 938         u32 response_que_value = 0;
 939         unsigned long before;
 940         int retval = 1;
 941
 942         if (tw_dev->tw_pci_dev->device != PCI_DEVICE_ID_3WARE_9000) {
 943                 before = jiffies;
 944                 while ((response_que_value & TW_9550SX_DRAIN_COMPLETED) != TW_9550SX_DRAIN_COMPLETED) {
 945                         response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
 946                         msleep(1);
 947                         if (time_after(jiffies, before + HZ * 30))
 948                                 goto out;
 949                 }
 950                 /* P-chip settle time */
 951                 msleep(500);
 952                 retval = 0;
 953         } else
 954                 retval = 0;
 955 out:
 956         return retval;
 957 } /* End twa_empty_response_queue_large() */
 958
 959 /* This function passes sense keys from firmware to scsi layer */
 960 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
 961 {
 962         TW_Command_Full *full_command_packet;
 963         unsigned short error;
 964         int retval = 1;
 965         char *error_str;
 966
 967         full_command_packet = tw_dev->command_packet_virt[request_id];
 968
 969         /* Check for embedded error string */
 970         error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
 971
 972         /* Don't print error for Logical unit not supported during rollcall */
 973         error = le16_to_cpu(full_command_packet->header.status_block.error);
 974         if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
 975                 if (print_host)
 976                         printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
 977                                tw_dev->host->host_no,
 978                                TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
 979                                full_command_packet->header.status_block.error,
 980                                error_str[0] == '\0' ?
 981                                twa_string_lookup(twa_error_table,
 982                                                  full_command_packet->header.status_block.error) : error_str,
 983                                full_command_packet->header.err_specific_desc);
 984                 else
 985                         printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
 986                                TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
 987                                full_command_packet->header.status_block.error,
 988                                error_str[0] == '\0' ?
 989                                twa_string_lookup(twa_error_table,
 990                                                  full_command_packet->header.status_block.error) : error_str,
 991                                full_command_packet->header.err_specific_desc);
 992         }
 993
 994         if (copy_sense) {
 995                 memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
 996                 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
 997                 retval = TW_ISR_DONT_RESULT;
 998                 goto out;
 999         }
1000         retval = 0;
1001 out:
1002         return retval;
1003 } /* End twa_fill_sense() */
1004
1005 /* This function will free up device extension resources */
1006 static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1007 {
1008         if (tw_dev->command_packet_virt[0])
1009                 pci_free_consistent(tw_dev->tw_pci_dev,
1010                                     sizeof(TW_Command_Full)*TW_Q_LENGTH,
1011                                     tw_dev->command_packet_virt[0],
1012                                     tw_dev->command_packet_phys[0]);
1013
1014         if (tw_dev->generic_buffer_virt[0])
1015                 pci_free_consistent(tw_dev->tw_pci_dev,
1016                                     TW_SECTOR_SIZE*TW_Q_LENGTH,
1017                                     tw_dev->generic_buffer_virt[0],
1018                                     tw_dev->generic_buffer_phys[0]);
1019
1020         kfree(tw_dev->event_queue[0]);
1021 } /* End twa_free_device_extension() */
1022
1023 /* This function will free a request id */
1024 static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
1025 {
1026         tw_dev->free_queue[tw_dev->free_tail] = request_id;
1027         tw_dev->state[request_id] = TW_S_FINISHED;
1028         tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
1029 } /* End twa_free_request_id() */
1030
1031 /* This function will get parameter table entries from the firmware */
1032 static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
1033 {
1034         TW_Command_Full *full_command_packet;
1035         TW_Command *command_packet;
1036         TW_Param_Apache *param;
1037         unsigned long param_value;
1038         void *retval = NULL;
1039
1040         /* Setup the command packet */
1041         full_command_packet = tw_dev->command_packet_virt[request_id];
1042         memset(full_command_packet, 0, sizeof(TW_Command_Full));
1043         command_packet = &full_command_packet->command.oldcommand;
1044
1045         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1046         command_packet->size              = TW_COMMAND_SIZE;
1047         command_packet->request_id        = request_id;
1048         command_packet->byte6_offset.block_count = cpu_to_le16(1);
1049
1050         /* Now setup the param */
1051         param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
1052         memset(param, 0, TW_SECTOR_SIZE);
1053         param->table_id = cpu_to_le16(table_id | 0x8000);
1054         param->parameter_id = cpu_to_le16(parameter_id);
1055         param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
1056         param_value = tw_dev->generic_buffer_phys[request_id];
1057
1058         command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(param_value);
1059         command_packet->byte8_offset.param.sgl[0].length = cpu_to_le32(TW_SECTOR_SIZE);
1060
1061         /* Post the command packet to the board */
1062         twa_post_command_packet(tw_dev, request_id, 1);
1063
1064         /* Poll for completion */
1065         if (twa_poll_response(tw_dev, request_id, 30))
1066                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param")
1067         else
1068                 retval = (void *)&(param->data[0]);
1069
1070         tw_dev->posted_request_count--;
1071         tw_dev->state[request_id] = TW_S_INITIAL;
1072
1073         return retval;
1074 } /* End twa_get_param() */
1075
1076 /* This function will assign an available request id */
1077 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
1078 {
1079         *request_id = tw_dev->free_queue[tw_dev->free_head];
1080         tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
1081         tw_dev->state[*request_id] = TW_S_STARTED;
1082 } /* End twa_get_request_id() */
1083
1084 /* This function will send an initconnection command to controller */
1085 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1086                               u32 set_features, unsigned short current_fw_srl,
1087                               unsigned short current_fw_arch_id,
1088                               unsigned short current_fw_branch,
1089                               unsigned short current_fw_build,
1090                               unsigned short *fw_on_ctlr_srl,
1091                               unsigned short *fw_on_ctlr_arch_id,
1092                               unsigned short *fw_on_ctlr_branch,
1093                               unsigned short *fw_on_ctlr_build,
1094                               u32 *init_connect_result)
1095 {
1096         TW_Command_Full *full_command_packet;
1097         TW_Initconnect *tw_initconnect;
1098         int request_id = 0, retval = 1;
1099
1100         /* Initialize InitConnection command packet */
1101         full_command_packet = tw_dev->command_packet_virt[request_id];
1102         memset(full_command_packet, 0, sizeof(TW_Command_Full));
1103         full_command_packet->header.header_desc.size_header = 128;
1104
1105         tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1106         tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1107         tw_initconnect->request_id = request_id;
1108         tw_initconnect->message_credits = cpu_to_le16(message_credits);
1109         tw_initconnect->features = set_features;
1110
1111         /* Turn on 64-bit sgl support if we need to */
1112         tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1113
1114         tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1115
1116         if (set_features & TW_EXTENDED_INIT_CONNECT) {
1117                 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1118                 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1119                 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1120                 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1121                 tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1122         } else
1123                 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1124
1125         /* Send command packet to the board */
1126         twa_post_command_packet(tw_dev, request_id, 1);
1127
1128         /* Poll for completion */
1129         if (twa_poll_response(tw_dev, request_id, 30)) {
1130                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection");
1131         } else {
1132                 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1133                         *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1134                         *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1135                         *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1136                         *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1137                         *init_connect_result = le32_to_cpu(tw_initconnect->result);
1138                 }
1139                 retval = 0;
1140         }
1141
1142         tw_dev->posted_request_count--;
1143         tw_dev->state[request_id] = TW_S_INITIAL;
1144
1145         return retval;
1146 } /* End twa_initconnection() */
1147
1148 /* This function will initialize the fields of a device extension */
1149 static int twa_initialize_device_extension(TW_Device_Extension *tw_dev)
1150 {
1151         int i, retval = 1;
1152
1153         /* Initialize command packet buffers */
1154         if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1155                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed");
1156                 goto out;
1157         }
1158
1159         /* Initialize generic buffer */
1160         if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1161                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed");
1162                 goto out;
1163         }
1164
1165         /* Allocate event info space */
1166         tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
1167         if (!tw_dev->event_queue[0]) {
1168                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed");
1169                 goto out;
1170         }
1171
1172
1173         for (i = 0; i < TW_Q_LENGTH; i++) {
1174                 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1175                 tw_dev->free_queue[i] = i;
1176                 tw_dev->state[i] = TW_S_INITIAL;
1177         }
1178
1179         tw_dev->pending_head = TW_Q_START;
1180         tw_dev->pending_tail = TW_Q_START;
1181         tw_dev->free_head = TW_Q_START;
1182         tw_dev->free_tail = TW_Q_START;
1183         tw_dev->error_sequence_id = 1;
1184         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1185
1186         mutex_init(&tw_dev->ioctl_lock);
1187         init_waitqueue_head(&tw_dev->ioctl_wqueue);
1188
1189         retval = 0;
1190 out:
1191         return retval;
1192 } /* End twa_initialize_device_extension() */
1193
1194 /* This function is the interrupt service routine */
1195 static irqreturn_t twa_interrupt(int irq, void *dev_instance)
1196 {
1197         int request_id, error = 0;
1198         u32 status_reg_value;
1199         TW_Response_Queue response_que;
1200         TW_Command_Full *full_command_packet;
1201         TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1202         int handled = 0;
1203
1204         /* Get the per adapter lock */
1205         spin_lock(tw_dev->host->host_lock);
1206
1207         /* Read the registers */
1208         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1209
1210         /* Check if this is our interrupt, otherwise bail */
1211         if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1212                 goto twa_interrupt_bail;
1213
1214         handled = 1;
1215
1216         /* If we are resetting, bail */
1217         if (test_bit(TW_IN_RESET, &tw_dev->flags))
1218                 goto twa_interrupt_bail;
1219
1220         /* Check controller for errors */
1221         if (twa_check_bits(status_reg_value)) {
1222                 if (twa_decode_bits(tw_dev, status_reg_value)) {
1223                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1224                         goto twa_interrupt_bail;
1225                 }
1226         }
1227
1228         /* Handle host interrupt */
1229         if (status_reg_value & TW_STATUS_HOST_INTERRUPT)
1230                 TW_CLEAR_HOST_INTERRUPT(tw_dev);
1231
1232         /* Handle attention interrupt */
1233         if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1234                 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
1235                 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1236                         twa_get_request_id(tw_dev, &request_id);
1237
1238                         error = twa_aen_read_queue(tw_dev, request_id);
1239                         if (error) {
1240                                 tw_dev->state[request_id] = TW_S_COMPLETED;
1241                                 twa_free_request_id(tw_dev, request_id);
1242                                 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1243                         }
1244                 }
1245         }
1246
1247         /* Handle command interrupt */
1248         if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1249                 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1250                 /* Drain as many pending commands as we can */
1251                 while (tw_dev->pending_request_count > 0) {
1252                         request_id = tw_dev->pending_queue[tw_dev->pending_head];
1253                         if (tw_dev->state[request_id] != TW_S_PENDING) {
1254                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending");
1255                                 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1256                                 goto twa_interrupt_bail;
1257                         }
1258                         if (twa_post_command_packet(tw_dev, request_id, 1)==0) {
1259                                 tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH;
1260                                 tw_dev->pending_request_count--;
1261                         } else {
1262                                 /* If we get here, we will continue re-posting on the next command interrupt */
1263                                 break;
1264                         }
1265                 }
1266         }
1267
1268         /* Handle response interrupt */
1269         if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1270
1271                 /* Drain the response queue from the board */
1272                 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1273                         /* Complete the response */
1274                         response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1275                         request_id = TW_RESID_OUT(response_que.response_id);
1276                         full_command_packet = tw_dev->command_packet_virt[request_id];
1277                         error = 0;
1278                         /* Check for command packet errors */
1279                         if (full_command_packet->command.newcommand.status != 0) {
1280                                 if (tw_dev->srb[request_id] != 0) {
1281                                         error = twa_fill_sense(tw_dev, request_id, 1, 1);
1282                                 } else {
1283                                         /* Skip ioctl error prints */
1284                                         if (request_id != tw_dev->chrdev_request_id) {
1285                                                 error = twa_fill_sense(tw_dev, request_id, 0, 1);
1286                                         }
1287                                 }
1288                         }
1289
1290                         /* Check for correct state */
1291                         if (tw_dev->state[request_id] != TW_S_POSTED) {
1292                                 if (tw_dev->srb[request_id] != 0) {
1293                                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted");
1294                                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1295                                         goto twa_interrupt_bail;
1296                                 }
1297                         }
1298
1299                         /* Check for internal command completion */
1300                         if (tw_dev->srb[request_id] == 0) {
1301                                 if (request_id != tw_dev->chrdev_request_id) {
1302                                         if (twa_aen_complete(tw_dev, request_id))
1303                                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt");
1304                                 } else {
1305                                         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1306                                         wake_up(&tw_dev->ioctl_wqueue);
1307                                 }
1308                         } else {
1309                                 struct scsi_cmnd *cmd;
1310
1311                                 cmd = tw_dev->srb[request_id];
1312
1313                                 twa_scsiop_execute_scsi_complete(tw_dev, request_id);
1314                                 /* If no error command was a success */
1315                                 if (error == 0) {
1316                                         cmd->result = (DID_OK << 16);
1317                                 }
1318
1319                                 /* If error, command failed */
1320                                 if (error == 1) {
1321                                         /* Ask for a host reset */
1322                                         cmd->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
1323                                 }
1324
1325                                 /* Report residual bytes for single sgl */
1326                                 if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1327                                         if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1328                                                 scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1329                                 }
1330
1331                                 /* Now complete the io */
1332                                 tw_dev->state[request_id] = TW_S_COMPLETED;
1333                                 twa_free_request_id(tw_dev, request_id);
1334                                 tw_dev->posted_request_count--;
1335                                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1336                                 twa_unmap_scsi_data(tw_dev, request_id);
1337                         }
1338
1339                         /* Check for valid status after each drain */
1340                         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1341                         if (twa_check_bits(status_reg_value)) {
1342                                 if (twa_decode_bits(tw_dev, status_reg_value)) {
1343                                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1344                                         goto twa_interrupt_bail;
1345                                 }
1346                         }
1347                 }
1348         }
1349
1350 twa_interrupt_bail:
1351         spin_unlock(tw_dev->host->host_lock);
1352         return IRQ_RETVAL(handled);
1353 } /* End twa_interrupt() */
1354
1355 /* This function will load the request id and various sgls for ioctls */
1356 static void twa_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length)
1357 {
1358         TW_Command *oldcommand;
1359         TW_Command_Apache *newcommand;
1360         TW_SG_Entry *sgl;
1361         unsigned int pae = 0;
1362
1363         if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
1364                 pae = 1;
1365
1366         if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1367                 newcommand = &full_command_packet->command.newcommand;
1368                 newcommand->request_id__lunl =
1369                         cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
1370                 newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1371                 newcommand->sg_list[0].length = cpu_to_le32(length);
1372                 newcommand->sgl_entries__lunh =
1373                         cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), 1));
1374         } else {
1375                 oldcommand = &full_command_packet->command.oldcommand;
1376                 oldcommand->request_id = request_id;
1377
1378                 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
1379                         /* Load the sg list */
1380                         if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)
1381                                 sgl = (TW_SG_Entry *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry)/4) + pae);
1382                         else
1383                                 sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset));
1384                         sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
1385                         sgl->length = cpu_to_le32(length);
1386
1387                         oldcommand->size += pae;
1388                 }
1389         }
1390 } /* End twa_load_sgl() */
1391
1392 /* This function will perform a pci-dma mapping for a scatter gather list */
1393 static int twa_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id)
1394 {
1395         int use_sg;
1396         struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1397
1398         use_sg = scsi_dma_map(cmd);
1399         if (!use_sg)
1400                 return 0;
1401         else if (use_sg < 0) {
1402                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to map scatter gather list");
1403                 return 0;
1404         }
1405
1406         cmd->SCp.phase = TW_PHASE_SGLIST;
1407         cmd->SCp.have_data_in = use_sg;
1408
1409         return use_sg;
1410 } /* End twa_map_scsi_sg_data() */
1411
1412 /* This function will poll for a response interrupt of a request */
1413 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
1414 {
1415         int retval = 1, found = 0, response_request_id;
1416         TW_Response_Queue response_queue;
1417         TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id];
1418
1419         if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) {
1420                 response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1421                 response_request_id = TW_RESID_OUT(response_queue.response_id);
1422                 if (request_id != response_request_id) {
1423                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response");
1424                         goto out;
1425                 }
1426                 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1427                         if (full_command_packet->command.newcommand.status != 0) {
1428                                 /* bad response */
1429                                 twa_fill_sense(tw_dev, request_id, 0, 0);
1430                                 goto out;
1431                         }
1432                         found = 1;
1433                 } else {
1434                         if (full_command_packet->command.oldcommand.status != 0) {
1435                                 /* bad response */
1436                                 twa_fill_sense(tw_dev, request_id, 0, 0);
1437                                 goto out;
1438                         }
1439                         found = 1;
1440                 }
1441         }
1442
1443         if (found)
1444                 retval = 0;
1445 out:
1446         return retval;
1447 } /* End twa_poll_response() */
1448
1449 /* This function will poll the status register for a flag */
1450 static int twa_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1451 {
1452         u32 status_reg_value;
1453         unsigned long before;
1454         int retval = 1;
1455
1456         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1457         before = jiffies;
1458
1459         if (twa_check_bits(status_reg_value))
1460                 twa_decode_bits(tw_dev, status_reg_value);
1461
1462         while ((status_reg_value & flag) != flag) {
1463                 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1464
1465                 if (twa_check_bits(status_reg_value))
1466                         twa_decode_bits(tw_dev, status_reg_value);
1467
1468                 if (time_after(jiffies, before + HZ * seconds))
1469                         goto out;
1470
1471                 msleep(50);
1472         }
1473         retval = 0;
1474 out:
1475         return retval;
1476 } /* End twa_poll_status() */
1477
1478 /* This function will poll the status register for disappearance of a flag */
1479 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1480 {
1481         u32 status_reg_value;
1482         unsigned long before;
1483         int retval = 1;
1484
1485         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1486         before = jiffies;
1487
1488         if (twa_check_bits(status_reg_value))
1489                 twa_decode_bits(tw_dev, status_reg_value);
1490
1491         while ((status_reg_value & flag) != 0) {
1492                 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1493                 if (twa_check_bits(status_reg_value))
1494                         twa_decode_bits(tw_dev, status_reg_value);
1495
1496                 if (time_after(jiffies, before + HZ * seconds))
1497                         goto out;
1498
1499                 msleep(50);
1500         }
1501         retval = 0;
1502 out:
1503         return retval;
1504 } /* End twa_poll_status_gone() */
1505
1506 /* This function will attempt to post a command packet to the board */
1507 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal)
1508 {
1509         u32 status_reg_value;
1510         dma_addr_t command_que_value;
1511         int retval = 1;
1512
1513         command_que_value = tw_dev->command_packet_phys[request_id];
1514
1515         /* For 9650SE write low 4 bytes first */
1516         if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1517             (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
1518                 command_que_value += TW_COMMAND_OFFSET;
1519                 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev));
1520         }
1521
1522         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1523
1524         if (twa_check_bits(status_reg_value))
1525                 twa_decode_bits(tw_dev, status_reg_value);
1526
1527         if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) {
1528
1529                 /* Only pend internal driver commands */
1530                 if (!internal) {
1531                         retval = SCSI_MLQUEUE_HOST_BUSY;
1532                         goto out;
1533                 }
1534
1535                 /* Couldn't post the command packet, so we do it later */
1536                 if (tw_dev->state[request_id] != TW_S_PENDING) {
1537                         tw_dev->state[request_id] = TW_S_PENDING;
1538                         tw_dev->pending_request_count++;
1539                         if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
1540                                 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
1541                         }
1542                         tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
1543                         tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH;
1544                 }
1545                 TW_UNMASK_COMMAND_INTERRUPT(tw_dev);
1546                 goto out;
1547         } else {
1548                 if ((tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
1549                     (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9690SA)) {
1550                         /* Now write upper 4 bytes */
1551                         writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR_LARGE(tw_dev) + 0x4);
1552                 } else {
1553                         if (sizeof(dma_addr_t) > 4) {
1554                                 command_que_value += TW_COMMAND_OFFSET;
1555                                 writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1556                                 writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4);
1557                         } else {
1558                                 writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1559                         }
1560                 }
1561                 tw_dev->state[request_id] = TW_S_POSTED;
1562                 tw_dev->posted_request_count++;
1563                 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
1564                         tw_dev->max_posted_request_count = tw_dev->posted_request_count;
1565                 }
1566         }
1567         retval = 0;
1568 out:
1569         return retval;
1570 } /* End twa_post_command_packet() */
1571
1572 /* This function will reset a device extension */
1573 static int twa_reset_device_extension(TW_Device_Extension *tw_dev)
1574 {
1575         int i = 0;
1576         int retval = 1;
1577         unsigned long flags = 0;
1578
1579         set_bit(TW_IN_RESET, &tw_dev->flags);
1580         TW_DISABLE_INTERRUPTS(tw_dev);
1581         TW_MASK_COMMAND_INTERRUPT(tw_dev);
1582         spin_lock_irqsave(tw_dev->host->host_lock, flags);
1583
1584         /* Abort all requests that are in progress */
1585         for (i = 0; i < TW_Q_LENGTH; i++) {
1586                 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1587                     (tw_dev->state[i] != TW_S_INITIAL) &&
1588                     (tw_dev->state[i] != TW_S_COMPLETED)) {
1589                         if (tw_dev->srb[i]) {
1590                                 tw_dev->srb[i]->result = (DID_RESET << 16);
1591                                 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1592                                 twa_unmap_scsi_data(tw_dev, i);
1593                         }
1594                 }
1595         }
1596
1597         /* Reset queues and counts */
1598         for (i = 0; i < TW_Q_LENGTH; i++) {
1599                 tw_dev->free_queue[i] = i;
1600                 tw_dev->state[i] = TW_S_INITIAL;
1601         }
1602         tw_dev->free_head = TW_Q_START;
1603         tw_dev->free_tail = TW_Q_START;
1604         tw_dev->posted_request_count = 0;
1605         tw_dev->pending_request_count = 0;
1606         tw_dev->pending_head = TW_Q_START;
1607         tw_dev->pending_tail = TW_Q_START;
1608         tw_dev->reset_print = 0;
1609
1610         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1611
1612         if (twa_reset_sequence(tw_dev, 1))
1613                 goto out;
1614
1615         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1616         clear_bit(TW_IN_RESET, &tw_dev->flags);
1617         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1618
1619         retval = 0;
1620 out:
1621         return retval;
1622 } /* End twa_reset_device_extension() */
1623
1624 /* This function will reset a controller */
1625 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1626 {
1627         int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset;
1628
1629         while (tries < TW_MAX_RESET_TRIES) {
1630                 if (do_soft_reset) {
1631                         TW_SOFT_RESET(tw_dev);
1632                         /* Clear pchip/response queue on 9550SX */
1633                         if (twa_empty_response_queue_large(tw_dev)) {
1634                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence");
1635                                 do_soft_reset = 1;
1636                                 tries++;
1637                                 continue;
1638                         }
1639                 }
1640
1641                 /* Make sure controller is in a good state */
1642                 if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) {
1643                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence");
1644                         do_soft_reset = 1;
1645                         tries++;
1646                         continue;
1647                 }
1648
1649                 /* Empty response queue */
1650                 if (twa_empty_response_queue(tw_dev)) {
1651                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence");
1652                         do_soft_reset = 1;
1653                         tries++;
1654                         continue;
1655                 }
1656
1657                 flashed = 0;
1658
1659                 /* Check for compatibility/flash */
1660                 if (twa_check_srl(tw_dev, &flashed)) {
1661                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence");
1662                         do_soft_reset = 1;
1663                         tries++;
1664                         continue;
1665                 } else {
1666                         if (flashed) {
1667                                 tries++;
1668                                 continue;
1669                         }
1670                 }
1671
1672                 /* Drain the AEN queue */
1673                 if (twa_aen_drain_queue(tw_dev, soft_reset)) {
1674                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence");
1675                         do_soft_reset = 1;
1676                         tries++;
1677                         continue;
1678                 }
1679
1680                 /* If we got here, controller is in a good state */
1681                 retval = 0;
1682                 goto out;
1683         }
1684 out:
1685         return retval;
1686 } /* End twa_reset_sequence() */
1687
1688 /* This funciton returns unit geometry in cylinders/heads/sectors */
1689 static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1690 {
1691         int heads, sectors, cylinders;
1692         TW_Device_Extension *tw_dev;
1693
1694         tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1695
1696         if (capacity >= 0x200000) {
1697                 heads = 255;
1698                 sectors = 63;
1699                 cylinders = sector_div(capacity, heads * sectors);
1700         } else {
1701                 heads = 64;
1702                 sectors = 32;
1703                 cylinders = sector_div(capacity, heads * sectors);
1704         }
1705
1706         geom[0] = heads;
1707         geom[1] = sectors;
1708         geom[2] = cylinders;
1709
1710         return 0;
1711 } /* End twa_scsi_biosparam() */
1712
1713 /* This is the new scsi eh reset function */
1714 static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1715 {
1716         TW_Device_Extension *tw_dev = NULL;
1717         int retval = FAILED;
1718
1719         tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1720
1721         tw_dev->num_resets++;
1722
1723         sdev_printk(KERN_WARNING, SCpnt->device,
1724                 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1725                 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1726
1727         /* Make sure we are not issuing an ioctl or resetting from ioctl */
1728         mutex_lock(&tw_dev->ioctl_lock);
1729
1730         /* Now reset the card and some of the device extension data */
1731         if (twa_reset_device_extension(tw_dev)) {
1732                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset");
1733                 goto out;
1734         }
1735
1736         retval = SUCCESS;
1737 out:
1738         mutex_unlock(&tw_dev->ioctl_lock);
1739         return retval;
1740 } /* End twa_scsi_eh_reset() */
1741
1742 /* This is the main scsi queue function to handle scsi opcodes */
1743 static int twa_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1744 {
1745         int request_id, retval;
1746         TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1747
1748         /* If we are resetting due to timed out ioctl, report as busy */
1749         if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1750                 retval = SCSI_MLQUEUE_HOST_BUSY;
1751                 goto out;
1752         }
1753
1754         /* Check if this FW supports luns */
1755         if ((SCpnt->device->lun != 0) && (tw_dev->tw_compat_info.working_srl < TW_FW_SRL_LUNS_SUPPORTED)) {
1756                 SCpnt->result = (DID_BAD_TARGET << 16);
1757                 done(SCpnt);
1758                 retval = 0;
1759                 goto out;
1760         }
1761
1762         /* Save done function into scsi_cmnd struct */
1763         SCpnt->scsi_done = done;
1764
1765         /* Get a free request id */
1766         twa_get_request_id(tw_dev, &request_id);
1767
1768         /* Save the scsi command for use by the ISR */
1769         tw_dev->srb[request_id] = SCpnt;
1770
1771         /* Initialize phase to zero */
1772         SCpnt->SCp.phase = TW_PHASE_INITIAL;
1773
1774         retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1775         switch (retval) {
1776         case SCSI_MLQUEUE_HOST_BUSY:
1777                 twa_free_request_id(tw_dev, request_id);
1778                 break;
1779         case 1:
1780                 tw_dev->state[request_id] = TW_S_COMPLETED;
1781                 twa_free_request_id(tw_dev, request_id);
1782                 SCpnt->result = (DID_ERROR << 16);
1783                 done(SCpnt);
1784                 retval = 0;
1785         }
1786 out:
1787         return retval;
1788 } /* End twa_scsi_queue() */
1789
1790 /* This function hands scsi cdb's to the firmware */
1791 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg)
1792 {
1793         TW_Command_Full *full_command_packet;
1794         TW_Command_Apache *command_packet;
1795         u32 num_sectors = 0x0;
1796         int i, sg_count;
1797         struct scsi_cmnd *srb = NULL;
1798         struct scatterlist *sglist = NULL, *sg;
1799         int retval = 1;
1800
1801         if (tw_dev->srb[request_id]) {
1802                 srb = tw_dev->srb[request_id];
1803                 if (scsi_sglist(srb))
1804                         sglist = scsi_sglist(srb);
1805         }
1806
1807         /* Initialize command packet */
1808         full_command_packet = tw_dev->command_packet_virt[request_id];
1809         full_command_packet->header.header_desc.size_header = 128;
1810         full_command_packet->header.status_block.error = 0;
1811         full_command_packet->header.status_block.severity__reserved = 0;
1812
1813         command_packet = &full_command_packet->command.newcommand;
1814         command_packet->status = 0;
1815         command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
1816
1817         /* We forced 16 byte cdb use earlier */
1818         if (!cdb)
1819                 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
1820         else
1821                 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
1822
1823         if (srb) {
1824                 command_packet->unit = srb->device->id;
1825                 command_packet->request_id__lunl =
1826                         cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
1827         } else {
1828                 command_packet->request_id__lunl =
1829                         cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
1830                 command_packet->unit = 0;
1831         }
1832
1833         command_packet->sgl_offset = 16;
1834
1835         if (!sglistarg) {
1836                 /* Map sglist from scsi layer to cmd packet */
1837
1838                 if (scsi_sg_count(srb)) {
1839                         if ((scsi_sg_count(srb) == 1) &&
1840                             (scsi_bufflen(srb) < TW_MIN_SGL_LENGTH)) {
1841                                 if (srb->sc_data_direction == DMA_TO_DEVICE || srb->sc_data_direction == DMA_BIDIRECTIONAL) {
1842                                         struct scatterlist *sg = scsi_sglist(srb);
1843                                         char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1844                                         memcpy(tw_dev->generic_buffer_virt[request_id], buf, sg->length);
1845                                         kunmap_atomic(buf - sg->offset, KM_IRQ0);
1846                                 }
1847                                 command_packet->sg_list[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
1848                                 command_packet->sg_list[0].length = cpu_to_le32(TW_MIN_SGL_LENGTH);
1849                         } else {
1850                                 sg_count = twa_map_scsi_sg_data(tw_dev, request_id);
1851                                 if (sg_count == 0)
1852                                         goto out;
1853
1854                                 scsi_for_each_sg(srb, sg, sg_count, i) {
1855                                         command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
1856                                         command_packet->sg_list[i].length = cpu_to_le32(sg_dma_len(sg));
1857                                         if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1858                                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi");
1859                                                 goto out;
1860                                         }
1861                                 }
1862                         }
1863                         command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
1864                 }
1865         } else {
1866                 /* Internal cdb post */
1867                 for (i = 0; i < use_sg; i++) {
1868                         command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
1869                         command_packet->sg_list[i].length = cpu_to_le32(sglistarg[i].length);
1870                         if (command_packet->sg_list[i].address & TW_CPU_TO_SGL(TW_ALIGNMENT_9000_SGL)) {
1871                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post");
1872                                 goto out;
1873                         }
1874                 }
1875                 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
1876         }
1877
1878         if (srb) {
1879                 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6)
1880                         num_sectors = (u32)srb->cmnd[4];
1881
1882                 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10)
1883                         num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1884         }
1885
1886         /* Update sector statistic */
1887         tw_dev->sector_count = num_sectors;
1888         if (tw_dev->sector_count > tw_dev->max_sector_count)
1889                 tw_dev->max_sector_count = tw_dev->sector_count;
1890
1891         /* Update SG statistics */
1892         if (srb) {
1893                 tw_dev->sgl_entries = scsi_sg_count(tw_dev->srb[request_id]);
1894                 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1895                         tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1896         }
1897
1898         /* Now post the command to the board */
1899         if (srb) {
1900                 retval = twa_post_command_packet(tw_dev, request_id, 0);
1901         } else {
1902                 twa_post_command_packet(tw_dev, request_id, 1);
1903                 retval = 0;
1904         }
1905 out:
1906         return retval;
1907 } /* End twa_scsiop_execute_scsi() */
1908
1909 /* This function completes an execute scsi operation */
1910 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id)
1911 {
1912         struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1913
1914         if (scsi_bufflen(cmd) < TW_MIN_SGL_LENGTH &&
1915             (cmd->sc_data_direction == DMA_FROM_DEVICE ||
1916              cmd->sc_data_direction == DMA_BIDIRECTIONAL)) {
1917                 if (scsi_sg_count(cmd) == 1) {
1918                         struct scatterlist *sg = scsi_sglist(tw_dev->srb[request_id]);
1919                         char *buf;
1920                         unsigned long flags = 0;
1921                         local_irq_save(flags);
1922                         buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1923                         memcpy(buf, tw_dev->generic_buffer_virt[request_id], sg->length);
1924                         kunmap_atomic(buf - sg->offset, KM_IRQ0);
1925                         local_irq_restore(flags);
1926                 }
1927         }
1928 } /* End twa_scsiop_execute_scsi_complete() */
1929
1930 /* This function tells the controller to shut down */
1931 static void __twa_shutdown(TW_Device_Extension *tw_dev)
1932 {
1933         /* Disable interrupts */
1934         TW_DISABLE_INTERRUPTS(tw_dev);
1935
1936         /* Free up the IRQ */
1937         free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1938
1939         printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no);
1940
1941         /* Tell the card we are shutting down */
1942         if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1943                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed");
1944         } else {
1945                 printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n");
1946         }
1947
1948         /* Clear all interrupts just before exit */
1949         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1950 } /* End __twa_shutdown() */
1951
1952 /* Wrapper for __twa_shutdown */
1953 static void twa_shutdown(struct pci_dev *pdev)
1954 {
1955         struct Scsi_Host *host = pci_get_drvdata(pdev);
1956         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1957
1958         __twa_shutdown(tw_dev);
1959 } /* End twa_shutdown() */
1960
1961 /* This function will look up a string */
1962 static char *twa_string_lookup(twa_message_type *table, unsigned int code)
1963 {
1964         int index;
1965
1966         for (index = 0; ((code != table[index].code) &&
1967                       (table[index].text != (char *)0)); index++);
1968         return(table[index].text);
1969 } /* End twa_string_lookup() */
1970
1971 /* This function will perform a pci-dma unmap */
1972 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
1973 {
1974         struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1975
1976         scsi_dma_unmap(cmd);
1977 } /* End twa_unmap_scsi_data() */
1978
1979 /* scsi_host_template initializer */
1980 static struct scsi_host_template driver_template = {
1981         .module                 = THIS_MODULE,
1982         .name                   = "3ware 9000 Storage Controller",
1983         .queuecommand           = twa_scsi_queue,
1984         .eh_host_reset_handler  = twa_scsi_eh_reset,
1985         .bios_param             = twa_scsi_biosparam,
1986         .change_queue_depth     = twa_change_queue_depth,
1987         .can_queue              = TW_Q_LENGTH-2,
1988         .this_id                = -1,
1989         .sg_tablesize           = TW_APACHE_MAX_SGL_LENGTH,
1990         .max_sectors            = TW_MAX_SECTORS,
1991         .cmd_per_lun            = TW_MAX_CMDS_PER_LUN,
1992         .use_clustering         = ENABLE_CLUSTERING,
1993         .shost_attrs            = twa_host_attrs,
1994         .emulated               = 1
1995 };
1996
1997 /* This function will probe and initialize a card */
1998 static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
1999 {
2000         struct Scsi_Host *host = NULL;
2001         TW_Device_Extension *tw_dev;
2002         u32 mem_addr;
2003         int retval = -ENODEV;
2004
2005         retval = pci_enable_device(pdev);
2006         if (retval) {
2007                 TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device");
2008                 goto out_disable_device;
2009         }
2010
2011         pci_set_master(pdev);
2012
2013         if (pci_set_dma_mask(pdev, DMA_64BIT_MASK)
2014             || pci_set_consistent_dma_mask(pdev, DMA_64BIT_MASK))
2015                 if (pci_set_dma_mask(pdev, DMA_32BIT_MASK)
2016                     || pci_set_consistent_dma_mask(pdev, DMA_32BIT_MASK)) {
2017                         TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");
2018                         retval = -ENODEV;
2019                         goto out_disable_device;
2020                 }
2021
2022         host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2023         if (!host) {
2024                 TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension");
2025                 retval = -ENOMEM;
2026                 goto out_disable_device;
2027         }
2028         tw_dev = (TW_Device_Extension *)host->hostdata;
2029
2030         memset(tw_dev, 0, sizeof(TW_Device_Extension));
2031
2032         /* Save values to device extension */
2033         tw_dev->host = host;
2034         tw_dev->tw_pci_dev = pdev;
2035
2036         if (twa_initialize_device_extension(tw_dev)) {
2037                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2038                 goto out_free_device_extension;
2039         }
2040
2041         /* Request IO regions */
2042         retval = pci_request_regions(pdev, "3w-9xxx");
2043         if (retval) {
2044                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2045                 goto out_free_device_extension;
2046         }
2047
2048         if (pdev->device == PCI_DEVICE_ID_3WARE_9000)
2049                 mem_addr = pci_resource_start(pdev, 1);
2050         else
2051                 mem_addr = pci_resource_start(pdev, 2);
2052
2053         /* Save base address */
2054         tw_dev->base_addr = ioremap(mem_addr, PAGE_SIZE);
2055         if (!tw_dev->base_addr) {
2056                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2057                 goto out_release_mem_region;
2058         }
2059
2060         /* Disable interrupts on the card */
2061         TW_DISABLE_INTERRUPTS(tw_dev);
2062
2063         /* Initialize the card */
2064         if (twa_reset_sequence(tw_dev, 0))
2065                 goto out_iounmap;
2066
2067         /* Set host specific parameters */
2068         if ((pdev->device == PCI_DEVICE_ID_3WARE_9650SE) ||
2069             (pdev->device == PCI_DEVICE_ID_3WARE_9690SA))
2070                 host->max_id = TW_MAX_UNITS_9650SE;
2071         else
2072                 host->max_id = TW_MAX_UNITS;
2073
2074         host->max_cmd_len = TW_MAX_CDB_LEN;
2075
2076         /* Channels aren't supported by adapter */
2077         host->max_lun = TW_MAX_LUNS(tw_dev->tw_compat_info.working_srl);
2078         host->max_channel = 0;
2079
2080         /* Register the card with the kernel SCSI layer */
2081         retval = scsi_add_host(host, &pdev->dev);
2082         if (retval) {
2083                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
2084                 goto out_iounmap;
2085         }
2086
2087         pci_set_drvdata(pdev, host);
2088
2089         printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%x, IRQ: %d.\n",
2090                host->host_no, mem_addr, pdev->irq);
2091         printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2092                host->host_no,
2093                (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2094                                      TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2095                (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2096                                      TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
2097                le32_to_cpu(*(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2098                                      TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH)));
2099
2100         /* Now setup the interrupt handler */
2101         retval = request_irq(pdev->irq, twa_interrupt, IRQF_SHARED, "3w-9xxx", tw_dev);
2102         if (retval) {
2103                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2104                 goto out_remove_host;
2105         }
2106
2107         twa_device_extension_list[twa_device_extension_count] = tw_dev;
2108         twa_device_extension_count++;
2109
2110         /* Re-enable interrupts on the card */
2111         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2112
2113         /* Finally, scan the host */
2114         scsi_scan_host(host);
2115
2116         if (twa_major == -1) {
2117                 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2118                         TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2119         }
2120         return 0;
2121
2122 out_remove_host:
2123         scsi_remove_host(host);
2124 out_iounmap:
2125         iounmap(tw_dev->base_addr);
2126 out_release_mem_region:
2127         pci_release_regions(pdev);
2128 out_free_device_extension:
2129         twa_free_device_extension(tw_dev);
2130         scsi_host_put(host);
2131 out_disable_device:
2132         pci_disable_device(pdev);
2133
2134         return retval;
2135 } /* End twa_probe() */
2136
2137 /* This function is called to remove a device */
2138 static void twa_remove(struct pci_dev *pdev)
2139 {
2140         struct Scsi_Host *host = pci_get_drvdata(pdev);
2141         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2142
2143         scsi_remove_host(tw_dev->host);
2144
2145         /* Unregister character device */
2146         if (twa_major >= 0) {
2147                 unregister_chrdev(twa_major, "twa");
2148                 twa_major = -1;
2149         }
2150
2151         /* Shutdown the card */
2152         __twa_shutdown(tw_dev);
2153
2154         /* Free IO remapping */
2155         iounmap(tw_dev->base_addr);
2156
2157         /* Free up the mem region */
2158         pci_release_regions(pdev);
2159
2160         /* Free up device extension resources */
2161         twa_free_device_extension(tw_dev);
2162
2163         scsi_host_put(tw_dev->host);
2164         pci_disable_device(pdev);
2165         twa_device_extension_count--;
2166 } /* End twa_remove() */
2167
2168 /* PCI Devices supported by this driver */
2169 static struct pci_device_id twa_pci_tbl[] __devinitdata = {
2170         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2171           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2172         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2173           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2174         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9650SE,
2175           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2176         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9690SA,
2177           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2178         { }
2179 };
2180 MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2181
2182 /* pci_driver initializer */
2183 static struct pci_driver twa_driver = {
2184         .name           = "3w-9xxx",
2185         .id_table       = twa_pci_tbl,
2186         .probe          = twa_probe,
2187         .remove         = twa_remove,
2188         .shutdown       = twa_shutdown
2189 };
2190
2191 /* This function is called on driver initialization */
2192 static int __init twa_init(void)
2193 {
2194         printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2195
2196         return pci_register_driver(&twa_driver);
2197 } /* End twa_init() */
2198
2199 /* This function is called on driver exit */
2200 static void __exit twa_exit(void)
2201 {
2202         pci_unregister_driver(&twa_driver);
2203 } /* End twa_exit() */
2204
2205 module_init(twa_init);
2206 module_exit(twa_exit);
2207