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 <asm/io.h>
  77 #include <asm/irq.h>
  78 #include <asm/uaccess.h>
  79 #include <scsi/scsi.h>
  80 #include <scsi/scsi_host.h>
  81 #include <scsi/scsi_tcq.h>
  82 #include <scsi/scsi_cmnd.h>
  83 #include "3w-9xxx.h"
  84
  85 /* Globals */
  86 #define TW_DRIVER_VERSION "2.26.02.004"
  87 static TW_Device_Extension *twa_device_extension_list[TW_MAX_SLOT];
  88 static unsigned int twa_device_extension_count;
  89 static int twa_major = -1;
  90 extern struct timezone sys_tz;
  91
  92 /* Module parameters */
  93 MODULE_AUTHOR ("AMCC");
  94 MODULE_DESCRIPTION ("3ware 9000 Storage Controller Linux Driver");
  95 MODULE_LICENSE("GPL");
  96 MODULE_VERSION(TW_DRIVER_VERSION);
  97
  98 /* Function prototypes */
  99 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header);
 100 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id);
 101 static char *twa_aen_severity_lookup(unsigned char severity_code);
 102 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id);
 103 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg);
 104 static int twa_chrdev_open(struct inode *inode, struct file *file);
 105 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host);
 106 static void twa_free_request_id(TW_Device_Extension *tw_dev,int request_id);
 107 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id);
 108 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
 109                               u32 set_features, unsigned short current_fw_srl,
 110                               unsigned short current_fw_arch_id,
 111                               unsigned short current_fw_branch,
 112                               unsigned short current_fw_build,
 113                               unsigned short *fw_on_ctlr_srl,
 114                               unsigned short *fw_on_ctlr_arch_id,
 115                               unsigned short *fw_on_ctlr_branch,
 116                               unsigned short *fw_on_ctlr_build,
 117                               u32 *init_connect_result);
 118 static void twa_load_sgl(TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length);
 119 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds);
 120 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds);
 121 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal);
 122 static int twa_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset);
 123 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset);
 124 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg);
 125 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id);
 126 static char *twa_string_lookup(twa_message_type *table, unsigned int aen_code);
 127 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id);
 128
 129 /* Functions */
 130
 131 /* Show some statistics about the card */
 132 static ssize_t twa_show_stats(struct class_device *class_dev, char *buf)
 133 {
 134         struct Scsi_Host *host = class_to_shost(class_dev);
 135         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
 136         unsigned long flags = 0;
 137         ssize_t len;
 138
 139         spin_lock_irqsave(tw_dev->host->host_lock, flags);
 140         len = snprintf(buf, PAGE_SIZE, "3w-9xxx Driver version: %s\n"
 141                        "Current commands posted:   %4d\n"
 142                        "Max commands posted:       %4d\n"
 143                        "Current pending commands:  %4d\n"
 144                        "Max pending commands:      %4d\n"
 145                        "Last sgl length:           %4d\n"
 146                        "Max sgl length:            %4d\n"
 147                        "Last sector count:         %4d\n"
 148                        "Max sector count:          %4d\n"
 149                        "SCSI Host Resets:          %4d\n"
 150                        "AEN's:                     %4d\n",
 151                        TW_DRIVER_VERSION,
 152                        tw_dev->posted_request_count,
 153                        tw_dev->max_posted_request_count,
 154                        tw_dev->pending_request_count,
 155                        tw_dev->max_pending_request_count,
 156                        tw_dev->sgl_entries,
 157                        tw_dev->max_sgl_entries,
 158                        tw_dev->sector_count,
 159                        tw_dev->max_sector_count,
 160                        tw_dev->num_resets,
 161                        tw_dev->aen_count);
 162         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 163         return len;
 164 } /* End twa_show_stats() */
 165
 166 /* This function will set a devices queue depth */
 167 static int twa_change_queue_depth(struct scsi_device *sdev, int queue_depth)
 168 {
 169         if (queue_depth > TW_Q_LENGTH-2)
 170                 queue_depth = TW_Q_LENGTH-2;
 171         scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, queue_depth);
 172         return queue_depth;
 173 } /* End twa_change_queue_depth() */
 174
 175 /* Create sysfs 'stats' entry */
 176 static struct class_device_attribute twa_host_stats_attr = {
 177         .attr = {
 178                 .name =         "stats",
 179                 .mode =         S_IRUGO,
 180         },
 181         .show = twa_show_stats
 182 };
 183
 184 /* Host attributes initializer */
 185 static struct class_device_attribute *twa_host_attrs[] = {
 186         &twa_host_stats_attr,
 187         NULL,
 188 };
 189
 190 /* File operations struct for character device */
 191 static struct file_operations twa_fops = {
 192         .owner          = THIS_MODULE,
 193         .ioctl          = twa_chrdev_ioctl,
 194         .open           = twa_chrdev_open,
 195         .release        = NULL
 196 };
 197
 198 /* This function will complete an aen request from the isr */
 199 static int twa_aen_complete(TW_Device_Extension *tw_dev, int request_id)
 200 {
 201         TW_Command_Full *full_command_packet;
 202         TW_Command *command_packet;
 203         TW_Command_Apache_Header *header;
 204         unsigned short aen;
 205         int retval = 1;
 206
 207         header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
 208         tw_dev->posted_request_count--;
 209         aen = header->status_block.error;
 210         full_command_packet = tw_dev->command_packet_virt[request_id];
 211         command_packet = &full_command_packet->command.oldcommand;
 212
 213         /* First check for internal completion of set param for time sync */
 214         if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
 215                 /* Keep reading the queue in case there are more aen's */
 216                 if (twa_aen_read_queue(tw_dev, request_id))
 217                         goto out2;
 218                 else {
 219                         retval = 0;
 220                         goto out;
 221                 }
 222         }
 223
 224         switch (aen) {
 225         case TW_AEN_QUEUE_EMPTY:
 226                 /* Quit reading the queue if this is the last one */
 227                 break;
 228         case TW_AEN_SYNC_TIME_WITH_HOST:
 229                 twa_aen_sync_time(tw_dev, request_id);
 230                 retval = 0;
 231                 goto out;
 232         default:
 233                 twa_aen_queue_event(tw_dev, header);
 234
 235                 /* If there are more aen's, keep reading the queue */
 236                 if (twa_aen_read_queue(tw_dev, request_id))
 237                         goto out2;
 238                 else {
 239                         retval = 0;
 240                         goto out;
 241                 }
 242         }
 243         retval = 0;
 244 out2:
 245         tw_dev->state[request_id] = TW_S_COMPLETED;
 246         twa_free_request_id(tw_dev, request_id);
 247         clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
 248 out:
 249         return retval;
 250 } /* End twa_aen_complete() */
 251
 252 /* This function will drain aen queue */
 253 static int twa_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
 254 {
 255         int request_id = 0;
 256         char cdb[TW_MAX_CDB_LEN];
 257         TW_SG_Entry sglist[1];
 258         int finished = 0, count = 0;
 259         TW_Command_Full *full_command_packet;
 260         TW_Command_Apache_Header *header;
 261         unsigned short aen;
 262         int first_reset = 0, queue = 0, retval = 1;
 263
 264         if (no_check_reset)
 265                 first_reset = 0;
 266         else
 267                 first_reset = 1;
 268
 269         full_command_packet = tw_dev->command_packet_virt[request_id];
 270         memset(full_command_packet, 0, sizeof(TW_Command_Full));
 271
 272         /* Initialize cdb */
 273         memset(&cdb, 0, TW_MAX_CDB_LEN);
 274         cdb[0] = REQUEST_SENSE; /* opcode */
 275         cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
 276
 277         /* Initialize sglist */
 278         memset(&sglist, 0, sizeof(TW_SG_Entry));
 279         sglist[0].length = TW_SECTOR_SIZE;
 280         sglist[0].address = tw_dev->generic_buffer_phys[request_id];
 281
 282         if (sglist[0].address & TW_ALIGNMENT_9000_SGL) {
 283                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1, "Found unaligned address during AEN drain");
 284                 goto out;
 285         }
 286
 287         /* Mark internal command */
 288         tw_dev->srb[request_id] = NULL;
 289
 290         do {
 291                 /* Send command to the board */
 292                 if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
 293                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Error posting request sense");
 294                         goto out;
 295                 }
 296
 297                 /* Now poll for completion */
 298                 if (twa_poll_response(tw_dev, request_id, 30)) {
 299                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "No valid response while draining AEN queue");
 300                         tw_dev->posted_request_count--;
 301                         goto out;
 302                 }
 303
 304                 tw_dev->posted_request_count--;
 305                 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
 306                 aen = header->status_block.error;
 307                 queue = 0;
 308                 count++;
 309
 310                 switch (aen) {
 311                 case TW_AEN_QUEUE_EMPTY:
 312                         if (first_reset != 1)
 313                                 goto out;
 314                         else
 315                                 finished = 1;
 316                         break;
 317                 case TW_AEN_SOFT_RESET:
 318                         if (first_reset == 0)
 319                                 first_reset = 1;
 320                         else
 321                                 queue = 1;
 322                         break;
 323                 case TW_AEN_SYNC_TIME_WITH_HOST:
 324                         break;
 325                 default:
 326                         queue = 1;
 327                 }
 328
 329                 /* Now queue an event info */
 330                 if (queue)
 331                         twa_aen_queue_event(tw_dev, header);
 332         } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
 333
 334         if (count == TW_MAX_AEN_DRAIN)
 335                 goto out;
 336
 337         retval = 0;
 338 out:
 339         tw_dev->state[request_id] = TW_S_INITIAL;
 340         return retval;
 341 } /* End twa_aen_drain_queue() */
 342
 343 /* This function will queue an event */
 344 static void twa_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
 345 {
 346         u32 local_time;
 347         struct timeval time;
 348         TW_Event *event;
 349         unsigned short aen;
 350         char host[16];
 351         char *error_str;
 352
 353         tw_dev->aen_count++;
 354
 355         /* Fill out event info */
 356         event = tw_dev->event_queue[tw_dev->error_index];
 357
 358         /* Check for clobber */
 359         host[0] = '\0';
 360         if (tw_dev->host) {
 361                 sprintf(host, " scsi%d:", tw_dev->host->host_no);
 362                 if (event->retrieved == TW_AEN_NOT_RETRIEVED)
 363                         tw_dev->aen_clobber = 1;
 364         }
 365
 366         aen = header->status_block.error;
 367         memset(event, 0, sizeof(TW_Event));
 368
 369         event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
 370         do_gettimeofday(&time);
 371         local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
 372         event->time_stamp_sec = local_time;
 373         event->aen_code = aen;
 374         event->retrieved = TW_AEN_NOT_RETRIEVED;
 375         event->sequence_id = tw_dev->error_sequence_id;
 376         tw_dev->error_sequence_id++;
 377
 378         /* Check for embedded error string */
 379         error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
 380
 381         header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
 382         event->parameter_len = strlen(header->err_specific_desc);
 383         memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len);
 384         if (event->severity != TW_AEN_SEVERITY_DEBUG)
 385                 printk(KERN_WARNING "3w-9xxx:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
 386                        host,
 387                        twa_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
 388                        TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen,
 389                        error_str[0] == '\0' ? twa_string_lookup(twa_aen_table, aen) : error_str,
 390                        header->err_specific_desc);
 391         else
 392                 tw_dev->aen_count--;
 393
 394         if ((tw_dev->error_index + 1) == TW_Q_LENGTH)
 395                 tw_dev->event_queue_wrapped = 1;
 396         tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
 397 } /* End twa_aen_queue_event() */
 398
 399 /* This function will read the aen queue from the isr */
 400 static int twa_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
 401 {
 402         char cdb[TW_MAX_CDB_LEN];
 403         TW_SG_Entry sglist[1];
 404         TW_Command_Full *full_command_packet;
 405         int retval = 1;
 406
 407         full_command_packet = tw_dev->command_packet_virt[request_id];
 408         memset(full_command_packet, 0, sizeof(TW_Command_Full));
 409
 410         /* Initialize cdb */
 411         memset(&cdb, 0, TW_MAX_CDB_LEN);
 412         cdb[0] = REQUEST_SENSE; /* opcode */
 413         cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
 414
 415         /* Initialize sglist */
 416         memset(&sglist, 0, sizeof(TW_SG_Entry));
 417         sglist[0].length = TW_SECTOR_SIZE;
 418         sglist[0].address = tw_dev->generic_buffer_phys[request_id];
 419
 420         /* Mark internal command */
 421         tw_dev->srb[request_id] = NULL;
 422
 423         /* Now post the command packet */
 424         if (twa_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
 425                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "Post failed while reading AEN queue");
 426                 goto out;
 427         }
 428         retval = 0;
 429 out:
 430         return retval;
 431 } /* End twa_aen_read_queue() */
 432
 433 /* This function will look up an AEN severity string */
 434 static char *twa_aen_severity_lookup(unsigned char severity_code)
 435 {
 436         char *retval = NULL;
 437
 438         if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
 439             (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
 440                 goto out;
 441
 442         retval = twa_aen_severity_table[severity_code];
 443 out:
 444         return retval;
 445 } /* End twa_aen_severity_lookup() */
 446
 447 /* This function will sync firmware time with the host time */
 448 static void twa_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
 449 {
 450         u32 schedulertime;
 451         struct timeval utc;
 452         TW_Command_Full *full_command_packet;
 453         TW_Command *command_packet;
 454         TW_Param_Apache *param;
 455         u32 local_time;
 456
 457         /* Fill out the command packet */
 458         full_command_packet = tw_dev->command_packet_virt[request_id];
 459         memset(full_command_packet, 0, sizeof(TW_Command_Full));
 460         command_packet = &full_command_packet->command.oldcommand;
 461         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
 462         command_packet->request_id = request_id;
 463         command_packet->byte8_offset.param.sgl[0].address = tw_dev->generic_buffer_phys[request_id];
 464         command_packet->byte8_offset.param.sgl[0].length = TW_SECTOR_SIZE;
 465         command_packet->size = TW_COMMAND_SIZE;
 466         command_packet->byte6_offset.parameter_count = 1;
 467
 468         /* Setup the param */
 469         param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
 470         memset(param, 0, TW_SECTOR_SIZE);
 471         param->table_id = TW_TIMEKEEP_TABLE | 0x8000; /* Controller time keep table */
 472         param->parameter_id = 0x3; /* SchedulerTime */
 473         param->parameter_size_bytes = 4;
 474
 475         /* Convert system time in UTC to local time seconds since last
 476            Sunday 12:00AM */
 477         do_gettimeofday(&utc);
 478         local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
 479         schedulertime = local_time - (3 * 86400);
 480         schedulertime = schedulertime % 604800;
 481
 482         memcpy(param->data, &schedulertime, sizeof(u32));
 483
 484         /* Mark internal command */
 485         tw_dev->srb[request_id] = NULL;
 486
 487         /* Now post the command */
 488         twa_post_command_packet(tw_dev, request_id, 1);
 489 } /* End twa_aen_sync_time() */
 490
 491 /* This function will allocate memory and check if it is correctly aligned */
 492 static int twa_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
 493 {
 494         int i;
 495         dma_addr_t dma_handle;
 496         unsigned long *cpu_addr;
 497         int retval = 1;
 498
 499         cpu_addr = pci_alloc_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, &dma_handle);
 500         if (!cpu_addr) {
 501                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
 502                 goto out;
 503         }
 504
 505         if ((unsigned long)cpu_addr % (TW_ALIGNMENT_9000)) {
 506                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x6, "Failed to allocate correctly aligned memory");
 507                 pci_free_consistent(tw_dev->tw_pci_dev, size*TW_Q_LENGTH, cpu_addr, dma_handle);
 508                 goto out;
 509         }
 510
 511         memset(cpu_addr, 0, size*TW_Q_LENGTH);
 512
 513         for (i = 0; i < TW_Q_LENGTH; i++) {
 514                 switch(which) {
 515                 case 0:
 516                         tw_dev->command_packet_phys[i] = dma_handle+(i*size);
 517                         tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
 518                         break;
 519                 case 1:
 520                         tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
 521                         tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
 522                         break;
 523                 }
 524         }
 525         retval = 0;
 526 out:
 527         return retval;
 528 } /* End twa_allocate_memory() */
 529
 530 /* This function will check the status register for unexpected bits */
 531 static int twa_check_bits(u32 status_reg_value)
 532 {
 533         int retval = 1;
 534
 535         if ((status_reg_value & TW_STATUS_EXPECTED_BITS) != TW_STATUS_EXPECTED_BITS)
 536                 goto out;
 537         if ((status_reg_value & TW_STATUS_UNEXPECTED_BITS) != 0)
 538                 goto out;
 539
 540         retval = 0;
 541 out:
 542         return retval;
 543 } /* End twa_check_bits() */
 544
 545 /* This function will check the srl and decide if we are compatible  */
 546 static int twa_check_srl(TW_Device_Extension *tw_dev, int *flashed)
 547 {
 548         int retval = 1;
 549         unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
 550         unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
 551         u32 init_connect_result = 0;
 552
 553         if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
 554                                TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
 555                                TW_9000_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
 556                                TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
 557                                &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
 558                                &fw_on_ctlr_build, &init_connect_result)) {
 559                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "Initconnection failed while checking SRL");
 560                 goto out;
 561         }
 562
 563         tw_dev->working_srl = fw_on_ctlr_srl;
 564         tw_dev->working_branch = fw_on_ctlr_branch;
 565         tw_dev->working_build = fw_on_ctlr_build;
 566
 567         /* Try base mode compatibility */
 568         if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
 569                 if (twa_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
 570                                        TW_EXTENDED_INIT_CONNECT,
 571                                        TW_BASE_FW_SRL, TW_9000_ARCH_ID,
 572                                        TW_BASE_FW_BRANCH, TW_BASE_FW_BUILD,
 573                                        &fw_on_ctlr_srl, &fw_on_ctlr_arch_id,
 574                                        &fw_on_ctlr_branch, &fw_on_ctlr_build,
 575                                        &init_connect_result)) {
 576                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Initconnection (base mode) failed while checking SRL");
 577                         goto out;
 578                 }
 579                 if (!(init_connect_result & TW_CTLR_FW_COMPATIBLE)) {
 580                         if (TW_CURRENT_DRIVER_SRL > fw_on_ctlr_srl) {
 581                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x32, "Firmware and driver incompatibility: please upgrade firmware");
 582                         } else {
 583                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x33, "Firmware and driver incompatibility: please upgrade driver");
 584                         }
 585                         goto out;
 586                 }
 587                 tw_dev->working_srl = TW_BASE_FW_SRL;
 588                 tw_dev->working_branch = TW_BASE_FW_BRANCH;
 589                 tw_dev->working_build = TW_BASE_FW_BUILD;
 590         }
 591         retval = 0;
 592 out:
 593         return retval;
 594 } /* End twa_check_srl() */
 595
 596 /* This function handles ioctl for the character device */
 597 static int twa_chrdev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
 598 {
 599         long timeout;
 600         unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
 601         dma_addr_t dma_handle;
 602         int request_id = 0;
 603         unsigned int sequence_id = 0;
 604         unsigned char event_index, start_index;
 605         TW_Ioctl_Driver_Command driver_command;
 606         TW_Ioctl_Buf_Apache *tw_ioctl;
 607         TW_Lock *tw_lock;
 608         TW_Command_Full *full_command_packet;
 609         TW_Compatibility_Info *tw_compat_info;
 610         TW_Event *event;
 611         struct timeval current_time;
 612         u32 current_time_ms;
 613         TW_Device_Extension *tw_dev = twa_device_extension_list[iminor(inode)];
 614         int retval = TW_IOCTL_ERROR_OS_EFAULT;
 615         void __user *argp = (void __user *)arg;
 616
 617         /* Only let one of these through at a time */
 618         if (down_interruptible(&tw_dev->ioctl_sem)) {
 619                 retval = TW_IOCTL_ERROR_OS_EINTR;
 620                 goto out;
 621         }
 622
 623         /* First copy down the driver command */
 624         if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
 625                 goto out2;
 626
 627         /* Check data buffer size */
 628         if (driver_command.buffer_length > TW_MAX_SECTORS * 512) {
 629                 retval = TW_IOCTL_ERROR_OS_EINVAL;
 630                 goto out2;
 631         }
 632
 633         /* Hardware can only do multiple of 512 byte transfers */
 634         data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
 635
 636         /* Now allocate ioctl buf memory */
 637         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);
 638         if (!cpu_addr) {
 639                 retval = TW_IOCTL_ERROR_OS_ENOMEM;
 640                 goto out2;
 641         }
 642
 643         tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
 644
 645         /* Now copy down the entire ioctl */
 646         if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
 647                 goto out3;
 648
 649         /* See which ioctl we are doing */
 650         switch (cmd) {
 651         case TW_IOCTL_FIRMWARE_PASS_THROUGH:
 652                 spin_lock_irqsave(tw_dev->host->host_lock, flags);
 653                 twa_get_request_id(tw_dev, &request_id);
 654
 655                 /* Flag internal command */
 656                 tw_dev->srb[request_id] = NULL;
 657
 658                 /* Flag chrdev ioctl */
 659                 tw_dev->chrdev_request_id = request_id;
 660
 661                 full_command_packet = &tw_ioctl->firmware_command;
 662
 663                 /* Load request id and sglist for both command types */
 664                 twa_load_sgl(full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
 665
 666                 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
 667
 668                 /* Now post the command packet to the controller */
 669                 twa_post_command_packet(tw_dev, request_id, 1);
 670                 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 671
 672                 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
 673
 674                 /* Now wait for command to complete */
 675                 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
 676
 677                 /* See if we reset while waiting for the ioctl to complete */
 678                 if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
 679                         clear_bit(TW_IN_RESET, &tw_dev->flags);
 680                         retval = TW_IOCTL_ERROR_OS_ERESTARTSYS;
 681                         goto out3;
 682                 }
 683
 684                 /* We timed out, and didn't get an interrupt */
 685                 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
 686                         /* Now we need to reset the board */
 687                         printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
 688                                tw_dev->host->host_no, TW_DRIVER, 0xc,
 689                                cmd);
 690                         retval = TW_IOCTL_ERROR_OS_EIO;
 691                         spin_lock_irqsave(tw_dev->host->host_lock, flags);
 692                         tw_dev->state[request_id] = TW_S_COMPLETED;
 693                         twa_free_request_id(tw_dev, request_id);
 694                         tw_dev->posted_request_count--;
 695                         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 696                         twa_reset_device_extension(tw_dev, 1);
 697                         goto out3;
 698                 }
 699
 700                 /* Now copy in the command packet response */
 701                 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
 702
 703                 /* Now complete the io */
 704                 spin_lock_irqsave(tw_dev->host->host_lock, flags);
 705                 tw_dev->posted_request_count--;
 706                 tw_dev->state[request_id] = TW_S_COMPLETED;
 707                 twa_free_request_id(tw_dev, request_id);
 708                 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 709                 break;
 710         case TW_IOCTL_GET_COMPATIBILITY_INFO:
 711                 tw_ioctl->driver_command.status = 0;
 712                 /* Copy compatiblity struct into ioctl data buffer */
 713                 tw_compat_info = (TW_Compatibility_Info *)tw_ioctl->data_buffer;
 714                 strncpy(tw_compat_info->driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
 715                 tw_compat_info->working_srl = tw_dev->working_srl;
 716                 tw_compat_info->working_branch = tw_dev->working_branch;
 717                 tw_compat_info->working_build = tw_dev->working_build;
 718                 tw_compat_info->driver_srl_high = TW_CURRENT_DRIVER_SRL;
 719                 tw_compat_info->driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
 720                 tw_compat_info->driver_build_high = TW_CURRENT_DRIVER_BUILD;
 721                 tw_compat_info->driver_srl_low = TW_BASE_FW_SRL;
 722                 tw_compat_info->driver_branch_low = TW_BASE_FW_BRANCH;
 723                 tw_compat_info->driver_build_low = TW_BASE_FW_BUILD;
 724                 break;
 725         case TW_IOCTL_GET_LAST_EVENT:
 726                 if (tw_dev->event_queue_wrapped) {
 727                         if (tw_dev->aen_clobber) {
 728                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
 729                                 tw_dev->aen_clobber = 0;
 730                         } else
 731                                 tw_ioctl->driver_command.status = 0;
 732                 } else {
 733                         if (!tw_dev->error_index) {
 734                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 735                                 break;
 736                         }
 737                         tw_ioctl->driver_command.status = 0;
 738                 }
 739                 event_index = (tw_dev->error_index - 1 + TW_Q_LENGTH) % TW_Q_LENGTH;
 740                 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 741                 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 742                 break;
 743         case TW_IOCTL_GET_FIRST_EVENT:
 744                 if (tw_dev->event_queue_wrapped) {
 745                         if (tw_dev->aen_clobber) {
 746                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
 747                                 tw_dev->aen_clobber = 0;
 748                         } else
 749                                 tw_ioctl->driver_command.status = 0;
 750                         event_index = tw_dev->error_index;
 751                 } else {
 752                         if (!tw_dev->error_index) {
 753                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 754                                 break;
 755                         }
 756                         tw_ioctl->driver_command.status = 0;
 757                         event_index = 0;
 758                 }
 759                 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 760                 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 761                 break;
 762         case TW_IOCTL_GET_NEXT_EVENT:
 763                 event = (TW_Event *)tw_ioctl->data_buffer;
 764                 sequence_id = event->sequence_id;
 765                 tw_ioctl->driver_command.status = 0;
 766
 767                 if (tw_dev->event_queue_wrapped) {
 768                         if (tw_dev->aen_clobber) {
 769                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
 770                                 tw_dev->aen_clobber = 0;
 771                         }
 772                         start_index = tw_dev->error_index;
 773                 } else {
 774                         if (!tw_dev->error_index) {
 775                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 776                                 break;
 777                         }
 778                         start_index = 0;
 779                 }
 780                 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id + 1) % TW_Q_LENGTH;
 781
 782                 if (!(tw_dev->event_queue[event_index]->sequence_id > sequence_id)) {
 783                         if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
 784                                 tw_dev->aen_clobber = 1;
 785                         tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 786                         break;
 787                 }
 788                 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 789                 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 790                 break;
 791         case TW_IOCTL_GET_PREVIOUS_EVENT:
 792                 event = (TW_Event *)tw_ioctl->data_buffer;
 793                 sequence_id = event->sequence_id;
 794                 tw_ioctl->driver_command.status = 0;
 795
 796                 if (tw_dev->event_queue_wrapped) {
 797                         if (tw_dev->aen_clobber) {
 798                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_AEN_CLOBBER;
 799                                 tw_dev->aen_clobber = 0;
 800                         }
 801                         start_index = tw_dev->error_index;
 802                 } else {
 803                         if (!tw_dev->error_index) {
 804                                 tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 805                                 break;
 806                         }
 807                         start_index = 0;
 808                 }
 809                 event_index = (start_index + sequence_id - tw_dev->event_queue[start_index]->sequence_id - 1) % TW_Q_LENGTH;
 810
 811                 if (!(tw_dev->event_queue[event_index]->sequence_id < sequence_id)) {
 812                         if (tw_ioctl->driver_command.status == TW_IOCTL_ERROR_STATUS_AEN_CLOBBER)
 813                                 tw_dev->aen_clobber = 1;
 814                         tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NO_MORE_EVENTS;
 815                         break;
 816                 }
 817                 memcpy(tw_ioctl->data_buffer, tw_dev->event_queue[event_index], sizeof(TW_Event));
 818                 tw_dev->event_queue[event_index]->retrieved = TW_AEN_RETRIEVED;
 819                 break;
 820         case TW_IOCTL_GET_LOCK:
 821                 tw_lock = (TW_Lock *)tw_ioctl->data_buffer;
 822                 do_gettimeofday(&current_time);
 823                 current_time_ms = (current_time.tv_sec * 1000) + (current_time.tv_usec / 1000);
 824
 825                 if ((tw_lock->force_flag == 1) || (tw_dev->ioctl_sem_lock == 0) || (current_time_ms >= tw_dev->ioctl_msec)) {
 826                         tw_dev->ioctl_sem_lock = 1;
 827                         tw_dev->ioctl_msec = current_time_ms + tw_lock->timeout_msec;
 828                         tw_ioctl->driver_command.status = 0;
 829                         tw_lock->time_remaining_msec = tw_lock->timeout_msec;
 830                 } else {
 831                         tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_LOCKED;
 832                         tw_lock->time_remaining_msec = tw_dev->ioctl_msec - current_time_ms;
 833                 }
 834                 break;
 835         case TW_IOCTL_RELEASE_LOCK:
 836                 if (tw_dev->ioctl_sem_lock == 1) {
 837                         tw_dev->ioctl_sem_lock = 0;
 838                         tw_ioctl->driver_command.status = 0;
 839                 } else {
 840                         tw_ioctl->driver_command.status = TW_IOCTL_ERROR_STATUS_NOT_LOCKED;
 841                 }
 842                 break;
 843         default:
 844                 retval = TW_IOCTL_ERROR_OS_ENOTTY;
 845                 goto out3;
 846         }
 847
 848         /* Now copy the entire response to userspace */
 849         if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
 850                 retval = 0;
 851 out3:
 852         /* Now free ioctl buf memory */
 853         dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
 854 out2:
 855         up(&tw_dev->ioctl_sem);
 856 out:
 857         return retval;
 858 } /* End twa_chrdev_ioctl() */
 859
 860 /* This function handles open for the character device */
 861 static int twa_chrdev_open(struct inode *inode, struct file *file)
 862 {
 863         unsigned int minor_number;
 864         int retval = TW_IOCTL_ERROR_OS_ENODEV;
 865
 866         minor_number = iminor(inode);
 867         if (minor_number >= twa_device_extension_count)
 868                 goto out;
 869         retval = 0;
 870 out:
 871         return retval;
 872 } /* End twa_chrdev_open() */
 873
 874 /* This function will print readable messages from status register errors */
 875 static int twa_decode_bits(TW_Device_Extension *tw_dev, u32 status_reg_value)
 876 {
 877         int retval = 1;
 878
 879         /* Check for various error conditions and handle them appropriately */
 880         if (status_reg_value & TW_STATUS_PCI_PARITY_ERROR) {
 881                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "PCI Parity Error: clearing");
 882                 writel(TW_CONTROL_CLEAR_PARITY_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
 883         }
 884
 885         if (status_reg_value & TW_STATUS_PCI_ABORT) {
 886                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "PCI Abort: clearing");
 887                 writel(TW_CONTROL_CLEAR_PCI_ABORT, TW_CONTROL_REG_ADDR(tw_dev));
 888                 pci_write_config_word(tw_dev->tw_pci_dev, PCI_STATUS, TW_PCI_CLEAR_PCI_ABORT);
 889         }
 890
 891         if (status_reg_value & TW_STATUS_QUEUE_ERROR) {
 892                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Controller Queue Error: clearing");
 893                 writel(TW_CONTROL_CLEAR_QUEUE_ERROR, TW_CONTROL_REG_ADDR(tw_dev));
 894         }
 895
 896         if (status_reg_value & TW_STATUS_MICROCONTROLLER_ERROR) {
 897                 if (tw_dev->reset_print == 0) {
 898                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Microcontroller Error: clearing");
 899                         tw_dev->reset_print = 1;
 900                 }
 901                 goto out;
 902         }
 903         retval = 0;
 904 out:
 905         return retval;
 906 } /* End twa_decode_bits() */
 907
 908 /* This function will empty the response queue */
 909 static int twa_empty_response_queue(TW_Device_Extension *tw_dev)
 910 {
 911         u32 status_reg_value, response_que_value;
 912         int count = 0, retval = 1;
 913
 914         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
 915
 916         while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
 917                 response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
 918                 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
 919                 count++;
 920         }
 921         if (count == TW_MAX_RESPONSE_DRAIN)
 922                 goto out;
 923
 924         retval = 0;
 925 out:
 926         return retval;
 927 } /* End twa_empty_response_queue() */
 928
 929 /* This function will clear the pchip/response queue on 9550SX */
 930 static int twa_empty_response_queue_large(TW_Device_Extension *tw_dev)
 931 {
 932         u32 status_reg_value, response_que_value;
 933         int count = 0, retval = 1;
 934
 935         if (tw_dev->tw_pci_dev->device == PCI_DEVICE_ID_3WARE_9550SX) {
 936                 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
 937
 938                 while (((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) && (count < TW_MAX_RESPONSE_DRAIN)) {
 939                         response_que_value = readl(TW_RESPONSE_QUEUE_REG_ADDR_LARGE(tw_dev));
 940                         if ((response_que_value & TW_9550SX_DRAIN_COMPLETED) == TW_9550SX_DRAIN_COMPLETED) {
 941                                 /* P-chip settle time */
 942                                 msleep(500);
 943                                 retval = 0;
 944                                 goto out;
 945                         }
 946                         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
 947                         count++;
 948                 }
 949                 if (count == TW_MAX_RESPONSE_DRAIN)
 950                         goto out;
 951
 952                 retval = 0;
 953         } else
 954                 retval = 0;
 955 out:
 956         return retval;
 957 } /* End twa_empty_response_queue_large() */
 958
 959 /* This function passes sense keys from firmware to scsi layer */
 960 static int twa_fill_sense(TW_Device_Extension *tw_dev, int request_id, int copy_sense, int print_host)
 961 {
 962         TW_Command_Full *full_command_packet;
 963         unsigned short error;
 964         int retval = 1;
 965         char *error_str;
 966
 967         full_command_packet = tw_dev->command_packet_virt[request_id];
 968
 969         /* Check for embedded error string */
 970         error_str = &(full_command_packet->header.err_specific_desc[strlen(full_command_packet->header.err_specific_desc) + 1]);
 971
 972         /* Don't print error for Logical unit not supported during rollcall */
 973         error = full_command_packet->header.status_block.error;
 974         if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE)) {
 975                 if (print_host)
 976                         printk(KERN_WARNING "3w-9xxx: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
 977                                tw_dev->host->host_no,
 978                                TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
 979                                full_command_packet->header.status_block.error,
 980                                error_str[0] == '\0' ?
 981                                twa_string_lookup(twa_error_table,
 982                                                  full_command_packet->header.status_block.error) : error_str,
 983                                full_command_packet->header.err_specific_desc);
 984                 else
 985                         printk(KERN_WARNING "3w-9xxx: ERROR: (0x%02X:0x%04X): %s:%s.\n",
 986                                TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
 987                                full_command_packet->header.status_block.error,
 988                                error_str[0] == '\0' ?
 989                                twa_string_lookup(twa_error_table,
 990                                                  full_command_packet->header.status_block.error) : error_str,
 991                                full_command_packet->header.err_specific_desc);
 992         }
 993
 994         if (copy_sense) {
 995                 memcpy(tw_dev->srb[request_id]->sense_buffer, full_command_packet->header.sense_data, TW_SENSE_DATA_LENGTH);
 996                 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
 997                 retval = TW_ISR_DONT_RESULT;
 998                 goto out;
 999         }
1000         retval = 0;
1001 out:
1002         return retval;
1003 } /* End twa_fill_sense() */
1004
1005 /* This function will free up device extension resources */
1006 static void twa_free_device_extension(TW_Device_Extension *tw_dev)
1007 {
1008         if (tw_dev->command_packet_virt[0])
1009                 pci_free_consistent(tw_dev->tw_pci_dev,
1010                                     sizeof(TW_Command_Full)*TW_Q_LENGTH,
1011                                     tw_dev->command_packet_virt[0],
1012                                     tw_dev->command_packet_phys[0]);
1013
1014         if (tw_dev->generic_buffer_virt[0])
1015                 pci_free_consistent(tw_dev->tw_pci_dev,
1016                                     TW_SECTOR_SIZE*TW_Q_LENGTH,
1017                                     tw_dev->generic_buffer_virt[0],
1018                                     tw_dev->generic_buffer_phys[0]);
1019
1020         if (tw_dev->event_queue[0])
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         init_MUTEX(&tw_dev->ioctl_sem);
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         printk(KERN_WARNING "3w-9xxx: scsi%d: WARNING: (0x%02X:0x%04X): Unit #%d: Command (0x%x) timed out, resetting card.\n", tw_dev->host->host_no, TW_DRIVER, 0x2c, SCpnt->device->id, SCpnt->cmnd[0]);
1736
1737         /* Now reset the card and some of the device extension data */
1738         if (twa_reset_device_extension(tw_dev, 0)) {
1739                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset");
1740                 goto out;
1741         }
1742
1743         retval = SUCCESS;
1744 out:
1745         return retval;
1746 } /* End twa_scsi_eh_reset() */
1747
1748 /* This is the main scsi queue function to handle scsi opcodes */
1749 static int twa_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1750 {
1751         int request_id, retval;
1752         TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1753
1754         /* Check if this FW supports luns */
1755         if ((SCpnt->device->lun != 0) && (tw_dev->working_srl < TW_FW_SRL_LUNS_SUPPORTED)) {
1756                 SCpnt->result = (DID_BAD_TARGET << 16);
1757                 done(SCpnt);
1758                 retval = 0;
1759                 goto out;
1760         }
1761
1762         /* Save done function into scsi_cmnd struct */
1763         SCpnt->scsi_done = done;
1764
1765         /* Get a free request id */
1766         twa_get_request_id(tw_dev, &request_id);
1767
1768         /* Save the scsi command for use by the ISR */
1769         tw_dev->srb[request_id] = SCpnt;
1770
1771         /* Initialize phase to zero */
1772         SCpnt->SCp.phase = TW_PHASE_INITIAL;
1773
1774         retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1775         switch (retval) {
1776         case SCSI_MLQUEUE_HOST_BUSY:
1777                 twa_free_request_id(tw_dev, request_id);
1778                 break;
1779         case 1:
1780                 tw_dev->state[request_id] = TW_S_COMPLETED;
1781                 twa_free_request_id(tw_dev, request_id);
1782                 SCpnt->result = (DID_ERROR << 16);
1783                 done(SCpnt);
1784                 retval = 0;
1785         }
1786 out:
1787         return retval;
1788 } /* End twa_scsi_queue() */
1789
1790 /* This function hands scsi cdb's to the firmware */
1791 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg)
1792 {
1793         TW_Command_Full *full_command_packet;
1794         TW_Command_Apache *command_packet;
1795         u32 num_sectors = 0x0;
1796         int i, sg_count;
1797         struct scsi_cmnd *srb = NULL;
1798         struct scatterlist *sglist = NULL;
1799         u32 buffaddr = 0x0;
1800         int retval = 1;
1801
1802         if (tw_dev->srb[request_id]) {
1803                 if (tw_dev->srb[request_id]->request_buffer) {
1804                         sglist = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
1805                 }
1806                 srb = tw_dev->srb[request_id];
1807         }
1808
1809         /* Initialize command packet */
1810         full_command_packet = tw_dev->command_packet_virt[request_id];
1811         full_command_packet->header.header_desc.size_header = 128;
1812         full_command_packet->header.status_block.error = 0;
1813         full_command_packet->header.status_block.severity__reserved = 0;
1814
1815         command_packet = &full_command_packet->command.newcommand;
1816         command_packet->status = 0;
1817         command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
1818
1819         /* We forced 16 byte cdb use earlier */
1820         if (!cdb)
1821                 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
1822         else
1823                 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
1824
1825         if (srb) {
1826                 command_packet->unit = srb->device->id;
1827                 command_packet->request_id__lunl =
1828                         TW_REQ_LUN_IN(srb->device->lun, request_id);
1829         } else {
1830                 command_packet->request_id__lunl =
1831                         TW_REQ_LUN_IN(0, request_id);
1832                 command_packet->unit = 0;
1833         }
1834
1835         command_packet->sgl_offset = 16;
1836
1837         if (!sglistarg) {
1838                 /* Map sglist from scsi layer to cmd packet */
1839                 if (tw_dev->srb[request_id]->use_sg == 0) {
1840                         if (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH) {
1841                                 command_packet->sg_list[0].address = tw_dev->generic_buffer_phys[request_id];
1842                                 command_packet->sg_list[0].length = TW_MIN_SGL_LENGTH;
1843                                 if (tw_dev->srb[request_id]->sc_data_direction == DMA_TO_DEVICE || tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL)
1844                                         memcpy(tw_dev->generic_buffer_virt[request_id], tw_dev->srb[request_id]->request_buffer, tw_dev->srb[request_id]->request_bufflen);
1845                         } else {
1846                                 buffaddr = twa_map_scsi_single_data(tw_dev, request_id);
1847                                 if (buffaddr == 0)
1848                                         goto out;
1849
1850                                 command_packet->sg_list[0].address = buffaddr;
1851                                 command_packet->sg_list[0].length = tw_dev->srb[request_id]->request_bufflen;
1852                         }
1853                         command_packet->sgl_entries__lunh = TW_REQ_LUN_IN((srb->device->lun >> 4), 1);
1854
1855                         if (command_packet->sg_list[0].address & TW_ALIGNMENT_9000_SGL) {
1856                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2d, "Found unaligned address during execute scsi");
1857                                 goto out;
1858                         }
1859                 }
1860
1861                 if (tw_dev->srb[request_id]->use_sg > 0) {
1862                         if ((tw_dev->srb[request_id]->use_sg == 1) && (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH)) {
1863                                 if (tw_dev->srb[request_id]->sc_data_direction == DMA_TO_DEVICE || tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL) {
1864                                         struct scatterlist *sg = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
1865                                         char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1866                                         memcpy(tw_dev->generic_buffer_virt[request_id], buf, sg->length);
1867                                         kunmap_atomic(buf - sg->offset, KM_IRQ0);
1868                                 }
1869                                 command_packet->sg_list[0].address = tw_dev->generic_buffer_phys[request_id];
1870                                 command_packet->sg_list[0].length = TW_MIN_SGL_LENGTH;
1871                         } else {
1872                                 sg_count = twa_map_scsi_sg_data(tw_dev, request_id);
1873                                 if (sg_count == 0)
1874                                         goto out;
1875
1876                                 for (i = 0; i < sg_count; i++) {
1877                                         command_packet->sg_list[i].address = sg_dma_address(&sglist[i]);
1878                                         command_packet->sg_list[i].length = sg_dma_len(&sglist[i]);
1879                                         if (command_packet->sg_list[i].address & TW_ALIGNMENT_9000_SGL) {
1880                                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi");
1881                                                 goto out;
1882                                         }
1883                                 }
1884                         }
1885                         command_packet->sgl_entries__lunh = TW_REQ_LUN_IN((srb->device->lun >> 4), tw_dev->srb[request_id]->use_sg);
1886                 }
1887         } else {
1888                 /* Internal cdb post */
1889                 for (i = 0; i < use_sg; i++) {
1890                         command_packet->sg_list[i].address = sglistarg[i].address;
1891                         command_packet->sg_list[i].length = sglistarg[i].length;
1892                         if (command_packet->sg_list[i].address & TW_ALIGNMENT_9000_SGL) {
1893                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post");
1894                                 goto out;
1895                         }
1896                 }
1897                 command_packet->sgl_entries__lunh = TW_REQ_LUN_IN(0, use_sg);
1898         }
1899
1900         if (srb) {
1901                 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6)
1902                         num_sectors = (u32)srb->cmnd[4];
1903
1904                 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10)
1905                         num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1906         }
1907
1908         /* Update sector statistic */
1909         tw_dev->sector_count = num_sectors;
1910         if (tw_dev->sector_count > tw_dev->max_sector_count)
1911                 tw_dev->max_sector_count = tw_dev->sector_count;
1912
1913         /* Update SG statistics */
1914         if (srb) {
1915                 tw_dev->sgl_entries = tw_dev->srb[request_id]->use_sg;
1916                 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1917                         tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1918         }
1919
1920         /* Now post the command to the board */
1921         if (srb) {
1922                 retval = twa_post_command_packet(tw_dev, request_id, 0);
1923         } else {
1924                 twa_post_command_packet(tw_dev, request_id, 1);
1925                 retval = 0;
1926         }
1927 out:
1928         return retval;
1929 } /* End twa_scsiop_execute_scsi() */
1930
1931 /* This function completes an execute scsi operation */
1932 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id)
1933 {
1934         if (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH &&
1935             (tw_dev->srb[request_id]->sc_data_direction == DMA_FROM_DEVICE ||
1936              tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL)) {
1937                 if (tw_dev->srb[request_id]->use_sg == 0) {
1938                         memcpy(tw_dev->srb[request_id]->request_buffer,
1939                                tw_dev->generic_buffer_virt[request_id],
1940                                tw_dev->srb[request_id]->request_bufflen);
1941                 }
1942                 if (tw_dev->srb[request_id]->use_sg == 1) {
1943                         struct scatterlist *sg = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
1944                         char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1945                         memcpy(buf, tw_dev->generic_buffer_virt[request_id], sg->length);
1946                         kunmap_atomic(buf - sg->offset, KM_IRQ0);
1947                 }
1948         }
1949 } /* End twa_scsiop_execute_scsi_complete() */
1950
1951 /* This function tells the controller to shut down */
1952 static void __twa_shutdown(TW_Device_Extension *tw_dev)
1953 {
1954         /* Disable interrupts */
1955         TW_DISABLE_INTERRUPTS(tw_dev);
1956
1957         printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no);
1958
1959         /* Tell the card we are shutting down */
1960         if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1961                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed");
1962         } else {
1963                 printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n");
1964         }
1965
1966         /* Clear all interrupts just before exit */
1967         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1968 } /* End __twa_shutdown() */
1969
1970 /* Wrapper for __twa_shutdown */
1971 static void twa_shutdown(struct pci_dev *pdev)
1972 {
1973         struct Scsi_Host *host = pci_get_drvdata(pdev);
1974         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1975
1976         __twa_shutdown(tw_dev);
1977 } /* End twa_shutdown() */
1978
1979 /* This function will look up a string */
1980 static char *twa_string_lookup(twa_message_type *table, unsigned int code)
1981 {
1982         int index;
1983
1984         for (index = 0; ((code != table[index].code) &&
1985                       (table[index].text != (char *)0)); index++);
1986         return(table[index].text);
1987 } /* End twa_string_lookup() */
1988
1989 /* This function will perform a pci-dma unmap */
1990 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
1991 {
1992         struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1993         struct pci_dev *pdev = tw_dev->tw_pci_dev;
1994
1995         switch(cmd->SCp.phase) {
1996         case TW_PHASE_SINGLE:
1997                 pci_unmap_single(pdev, cmd->SCp.have_data_in, cmd->request_bufflen, DMA_BIDIRECTIONAL);
1998                 break;
1999         case TW_PHASE_SGLIST:
2000                 pci_unmap_sg(pdev, cmd->request_buffer, cmd->use_sg, DMA_BIDIRECTIONAL);
2001                 break;
2002         }
2003 } /* End twa_unmap_scsi_data() */
2004
2005 /* scsi_host_template initializer */
2006 static struct scsi_host_template driver_template = {
2007         .module                 = THIS_MODULE,
2008         .name                   = "3ware 9000 Storage Controller",
2009         .queuecommand           = twa_scsi_queue,
2010         .eh_host_reset_handler  = twa_scsi_eh_reset,
2011         .bios_param             = twa_scsi_biosparam,
2012         .change_queue_depth     = twa_change_queue_depth,
2013         .can_queue              = TW_Q_LENGTH-2,
2014         .this_id                = -1,
2015         .sg_tablesize           = TW_APACHE_MAX_SGL_LENGTH,
2016         .max_sectors            = TW_MAX_SECTORS,
2017         .cmd_per_lun            = TW_MAX_CMDS_PER_LUN,
2018         .use_clustering         = ENABLE_CLUSTERING,
2019         .shost_attrs            = twa_host_attrs,
2020         .emulated               = 1
2021 };
2022
2023 /* This function will probe and initialize a card */
2024 static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2025 {
2026         struct Scsi_Host *host = NULL;
2027         TW_Device_Extension *tw_dev;
2028         u32 mem_addr;
2029         int retval = -ENODEV;
2030
2031         retval = pci_enable_device(pdev);
2032         if (retval) {
2033                 TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device");
2034                 goto out_disable_device;
2035         }
2036
2037         pci_set_master(pdev);
2038
2039         retval = pci_set_dma_mask(pdev, sizeof(dma_addr_t) > 4 ? DMA_64BIT_MASK : DMA_32BIT_MASK);
2040         if (retval) {
2041                 TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");
2042                 goto out_disable_device;
2043         }
2044
2045         host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2046         if (!host) {
2047                 TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension");
2048                 retval = -ENOMEM;
2049                 goto out_disable_device;
2050         }
2051         tw_dev = (TW_Device_Extension *)host->hostdata;
2052
2053         memset(tw_dev, 0, sizeof(TW_Device_Extension));
2054
2055         /* Save values to device extension */
2056         tw_dev->host = host;
2057         tw_dev->tw_pci_dev = pdev;
2058
2059         if (twa_initialize_device_extension(tw_dev)) {
2060                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2061                 goto out_free_device_extension;
2062         }
2063
2064         /* Request IO regions */
2065         retval = pci_request_regions(pdev, "3w-9xxx");
2066         if (retval) {
2067                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2068                 goto out_free_device_extension;
2069         }
2070
2071         if (pdev->device == PCI_DEVICE_ID_3WARE_9000)
2072                 mem_addr = pci_resource_start(pdev, 1);
2073         else
2074                 mem_addr = pci_resource_start(pdev, 2);
2075
2076         /* Save base address */
2077         tw_dev->base_addr = ioremap(mem_addr, PAGE_SIZE);
2078         if (!tw_dev->base_addr) {
2079                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2080                 goto out_release_mem_region;
2081         }
2082
2083         /* Disable interrupts on the card */
2084         TW_DISABLE_INTERRUPTS(tw_dev);
2085
2086         /* Initialize the card */
2087         if (twa_reset_sequence(tw_dev, 0))
2088                 goto out_release_mem_region;
2089
2090         /* Set host specific parameters */
2091         host->max_id = TW_MAX_UNITS;
2092         host->max_cmd_len = TW_MAX_CDB_LEN;
2093
2094         /* Channels aren't supported by adapter */
2095         host->max_lun = TW_MAX_LUNS(tw_dev->working_srl);
2096         host->max_channel = 0;
2097
2098         /* Register the card with the kernel SCSI layer */
2099         retval = scsi_add_host(host, &pdev->dev);
2100         if (retval) {
2101                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
2102                 goto out_release_mem_region;
2103         }
2104
2105         pci_set_drvdata(pdev, host);
2106
2107         printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%x, IRQ: %d.\n",
2108                host->host_no, mem_addr, pdev->irq);
2109         printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2110                host->host_no,
2111                (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2112                                      TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2113                (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2114                                      TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
2115                *(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2116                                      TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH));
2117
2118         /* Now setup the interrupt handler */
2119         retval = request_irq(pdev->irq, twa_interrupt, SA_SHIRQ, "3w-9xxx", tw_dev);
2120         if (retval) {
2121                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2122                 goto out_remove_host;
2123         }
2124
2125         twa_device_extension_list[twa_device_extension_count] = tw_dev;
2126         twa_device_extension_count++;
2127
2128         /* Re-enable interrupts on the card */
2129         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2130
2131         /* Finally, scan the host */
2132         scsi_scan_host(host);
2133
2134         if (twa_major == -1) {
2135                 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2136                         TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2137         }
2138         return 0;
2139
2140 out_remove_host:
2141         scsi_remove_host(host);
2142 out_release_mem_region:
2143         pci_release_regions(pdev);
2144 out_free_device_extension:
2145         twa_free_device_extension(tw_dev);
2146         scsi_host_put(host);
2147 out_disable_device:
2148         pci_disable_device(pdev);
2149
2150         return retval;
2151 } /* End twa_probe() */
2152
2153 /* This function is called to remove a device */
2154 static void twa_remove(struct pci_dev *pdev)
2155 {
2156         struct Scsi_Host *host = pci_get_drvdata(pdev);
2157         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2158
2159         scsi_remove_host(tw_dev->host);
2160
2161         /* Unregister character device */
2162         if (twa_major >= 0) {
2163                 unregister_chrdev(twa_major, "twa");
2164                 twa_major = -1;
2165         }
2166
2167         /* Free up the IRQ */
2168         free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2169
2170         /* Shutdown the card */
2171         __twa_shutdown(tw_dev);
2172
2173         /* Free up the mem region */
2174         pci_release_regions(pdev);
2175
2176         /* Free up device extension resources */
2177         twa_free_device_extension(tw_dev);
2178
2179         scsi_host_put(tw_dev->host);
2180         pci_disable_device(pdev);
2181         twa_device_extension_count--;
2182 } /* End twa_remove() */
2183
2184 /* PCI Devices supported by this driver */
2185 static struct pci_device_id twa_pci_tbl[] __devinitdata = {
2186         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2187           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2188         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2189           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2190         { }
2191 };
2192 MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2193
2194 /* pci_driver initializer */
2195 static struct pci_driver twa_driver = {
2196         .name           = "3w-9xxx",
2197         .id_table       = twa_pci_tbl,
2198         .probe          = twa_probe,
2199         .remove         = twa_remove,
2200         .shutdown       = twa_shutdown
2201 };
2202
2203 /* This function is called on driver initialization */
2204 static int __init twa_init(void)
2205 {
2206         printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2207
2208         return pci_module_init(&twa_driver);
2209 } /* End twa_init() */
2210
2211 /* This function is called on driver exit */
2212 static void __exit twa_exit(void)
2213 {
2214         pci_unregister_driver(&twa_driver);
2215 } /* End twa_exit() */
2216
2217 module_init(twa_init);
2218 module_exit(twa_exit);
2219