drivers/scsi/3w-9xxx.c

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