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