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