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