git.oblomov.eu Git - linux-2.6/blob - 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         kfree(tw_dev->event_queue[0]);
1021 } /* End twa_free_device_extension() */
1022
1023 /* This function will free a request id */
1024 static void twa_free_request_id(TW_Device_Extension *tw_dev, int request_id)
1025 {
1026         tw_dev->free_queue[tw_dev->free_tail] = request_id;
1027         tw_dev->state[request_id] = TW_S_FINISHED;
1028         tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
1029 } /* End twa_free_request_id() */
1030
1031 /* This function will get parameter table entires from the firmware */
1032 static void *twa_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
1033 {
1034         TW_Command_Full *full_command_packet;
1035         TW_Command *command_packet;
1036         TW_Param_Apache *param;
1037         unsigned long param_value;
1038         void *retval = NULL;
1039
1040         /* Setup the command packet */
1041         full_command_packet = tw_dev->command_packet_virt[request_id];
1042         memset(full_command_packet, 0, sizeof(TW_Command_Full));
1043         command_packet = &full_command_packet->command.oldcommand;
1044
1045         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
1046         command_packet->size              = TW_COMMAND_SIZE;
1047         command_packet->request_id        = request_id;
1048         command_packet->byte6_offset.block_count = 1;
1049
1050         /* Now setup the param */
1051         param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
1052         memset(param, 0, TW_SECTOR_SIZE);
1053         param->table_id = table_id | 0x8000;
1054         param->parameter_id = parameter_id;
1055         param->parameter_size_bytes = parameter_size_bytes;
1056         param_value = tw_dev->generic_buffer_phys[request_id];
1057
1058         command_packet->byte8_offset.param.sgl[0].address = param_value;
1059         command_packet->byte8_offset.param.sgl[0].length = TW_SECTOR_SIZE;
1060
1061         /* Post the command packet to the board */
1062         twa_post_command_packet(tw_dev, request_id, 1);
1063
1064         /* Poll for completion */
1065         if (twa_poll_response(tw_dev, request_id, 30))
1066                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "No valid response during get param")
1067         else
1068                 retval = (void *)&(param->data[0]);
1069
1070         tw_dev->posted_request_count--;
1071         tw_dev->state[request_id] = TW_S_INITIAL;
1072
1073         return retval;
1074 } /* End twa_get_param() */
1075
1076 /* This function will assign an available request id */
1077 static void twa_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
1078 {
1079         *request_id = tw_dev->free_queue[tw_dev->free_head];
1080         tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
1081         tw_dev->state[*request_id] = TW_S_STARTED;
1082 } /* End twa_get_request_id() */
1083
1084 /* This function will send an initconnection command to controller */
1085 static int twa_initconnection(TW_Device_Extension *tw_dev, int message_credits,
1086                               u32 set_features, unsigned short current_fw_srl,
1087                               unsigned short current_fw_arch_id,
1088                               unsigned short current_fw_branch,
1089                               unsigned short current_fw_build,
1090                               unsigned short *fw_on_ctlr_srl,
1091                               unsigned short *fw_on_ctlr_arch_id,
1092                               unsigned short *fw_on_ctlr_branch,
1093                               unsigned short *fw_on_ctlr_build,
1094                               u32 *init_connect_result)
1095 {
1096         TW_Command_Full *full_command_packet;
1097         TW_Initconnect *tw_initconnect;
1098         int request_id = 0, retval = 1;
1099
1100         /* Initialize InitConnection command packet */
1101         full_command_packet = tw_dev->command_packet_virt[request_id];
1102         memset(full_command_packet, 0, sizeof(TW_Command_Full));
1103         full_command_packet->header.header_desc.size_header = 128;
1104
1105         tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
1106         tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
1107         tw_initconnect->request_id = request_id;
1108         tw_initconnect->message_credits = message_credits;
1109         tw_initconnect->features = set_features;
1110
1111         /* Turn on 64-bit sgl support if we need to */
1112         tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1113
1114         if (set_features & TW_EXTENDED_INIT_CONNECT) {
1115                 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1116                 tw_initconnect->fw_srl = current_fw_srl;
1117                 tw_initconnect->fw_arch_id = current_fw_arch_id;
1118                 tw_initconnect->fw_branch = current_fw_branch;
1119                 tw_initconnect->fw_build = current_fw_build;
1120         } else
1121                 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1122
1123         /* Send command packet to the board */
1124         twa_post_command_packet(tw_dev, request_id, 1);
1125
1126         /* Poll for completion */
1127         if (twa_poll_response(tw_dev, request_id, 30)) {
1128                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "No valid response during init connection");
1129         } else {
1130                 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1131                         *fw_on_ctlr_srl = tw_initconnect->fw_srl;
1132                         *fw_on_ctlr_arch_id = tw_initconnect->fw_arch_id;
1133                         *fw_on_ctlr_branch = tw_initconnect->fw_branch;
1134                         *fw_on_ctlr_build = tw_initconnect->fw_build;
1135                         *init_connect_result = tw_initconnect->result;
1136                 }
1137                 retval = 0;
1138         }
1139
1140         tw_dev->posted_request_count--;
1141         tw_dev->state[request_id] = TW_S_INITIAL;
1142
1143         return retval;
1144 } /* End twa_initconnection() */
1145
1146 /* This function will initialize the fields of a device extension */
1147 static int twa_initialize_device_extension(TW_Device_Extension *tw_dev)
1148 {
1149         int i, retval = 1;
1150
1151         /* Initialize command packet buffers */
1152         if (twa_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1153                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Command packet memory allocation failed");
1154                 goto out;
1155         }
1156
1157         /* Initialize generic buffer */
1158         if (twa_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1159                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x17, "Generic memory allocation failed");
1160                 goto out;
1161         }
1162
1163         /* Allocate event info space */
1164         tw_dev->event_queue[0] = kmalloc(sizeof(TW_Event) * TW_Q_LENGTH, GFP_KERNEL);
1165         if (!tw_dev->event_queue[0]) {
1166                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x18, "Event info memory allocation failed");
1167                 goto out;
1168         }
1169
1170         memset(tw_dev->event_queue[0], 0, sizeof(TW_Event) * TW_Q_LENGTH);
1171
1172         for (i = 0; i < TW_Q_LENGTH; i++) {
1173                 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1174                 tw_dev->free_queue[i] = i;
1175                 tw_dev->state[i] = TW_S_INITIAL;
1176         }
1177
1178         tw_dev->pending_head = TW_Q_START;
1179         tw_dev->pending_tail = TW_Q_START;
1180         tw_dev->free_head = TW_Q_START;
1181         tw_dev->free_tail = TW_Q_START;
1182         tw_dev->error_sequence_id = 1;
1183         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1184
1185         init_MUTEX(&tw_dev->ioctl_sem);
1186         init_waitqueue_head(&tw_dev->ioctl_wqueue);
1187
1188         retval = 0;
1189 out:
1190         return retval;
1191 } /* End twa_initialize_device_extension() */
1192
1193 /* This function is the interrupt service routine */
1194 static irqreturn_t twa_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
1195 {
1196         int request_id, error = 0;
1197         u32 status_reg_value;
1198         TW_Response_Queue response_que;
1199         TW_Command_Full *full_command_packet;
1200         TW_Command *command_packet;
1201         TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1202         int handled = 0;
1203
1204         /* Get the per adapter lock */
1205         spin_lock(tw_dev->host->host_lock);
1206
1207         /* Read the registers */
1208         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1209
1210         /* Check if this is our interrupt, otherwise bail */
1211         if (!(status_reg_value & TW_STATUS_VALID_INTERRUPT))
1212                 goto twa_interrupt_bail;
1213
1214         handled = 1;
1215
1216         /* Check controller for errors */
1217         if (twa_check_bits(status_reg_value)) {
1218                 if (twa_decode_bits(tw_dev, status_reg_value)) {
1219                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1220                         goto twa_interrupt_bail;
1221                 }
1222         }
1223
1224         /* Handle host interrupt */
1225         if (status_reg_value & TW_STATUS_HOST_INTERRUPT)
1226                 TW_CLEAR_HOST_INTERRUPT(tw_dev);
1227
1228         /* Handle attention interrupt */
1229         if (status_reg_value & TW_STATUS_ATTENTION_INTERRUPT) {
1230                 TW_CLEAR_ATTENTION_INTERRUPT(tw_dev);
1231                 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1232                         twa_get_request_id(tw_dev, &request_id);
1233
1234                         error = twa_aen_read_queue(tw_dev, request_id);
1235                         if (error) {
1236                                 tw_dev->state[request_id] = TW_S_COMPLETED;
1237                                 twa_free_request_id(tw_dev, request_id);
1238                                 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1239                         }
1240                 }
1241         }
1242
1243         /* Handle command interrupt */
1244         if (status_reg_value & TW_STATUS_COMMAND_INTERRUPT) {
1245                 TW_MASK_COMMAND_INTERRUPT(tw_dev);
1246                 /* Drain as many pending commands as we can */
1247                 while (tw_dev->pending_request_count > 0) {
1248                         request_id = tw_dev->pending_queue[tw_dev->pending_head];
1249                         if (tw_dev->state[request_id] != TW_S_PENDING) {
1250                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x19, "Found request id that wasn't pending");
1251                                 TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1252                                 goto twa_interrupt_bail;
1253                         }
1254                         if (twa_post_command_packet(tw_dev, request_id, 1)==0) {
1255                                 tw_dev->pending_head = (tw_dev->pending_head + 1) % TW_Q_LENGTH;
1256                                 tw_dev->pending_request_count--;
1257                         } else {
1258                                 /* If we get here, we will continue re-posting on the next command interrupt */
1259                                 break;
1260                         }
1261                 }
1262         }
1263
1264         /* Handle response interrupt */
1265         if (status_reg_value & TW_STATUS_RESPONSE_INTERRUPT) {
1266
1267                 /* Drain the response queue from the board */
1268                 while ((status_reg_value & TW_STATUS_RESPONSE_QUEUE_EMPTY) == 0) {
1269                         /* Complete the response */
1270                         response_que.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1271                         request_id = TW_RESID_OUT(response_que.response_id);
1272                         full_command_packet = tw_dev->command_packet_virt[request_id];
1273                         error = 0;
1274                         command_packet = &full_command_packet->command.oldcommand;
1275                         /* Check for command packet errors */
1276                         if (full_command_packet->command.newcommand.status != 0) {
1277                                 if (tw_dev->srb[request_id] != 0) {
1278                                         error = twa_fill_sense(tw_dev, request_id, 1, 1);
1279                                 } else {
1280                                         /* Skip ioctl error prints */
1281                                         if (request_id != tw_dev->chrdev_request_id) {
1282                                                 error = twa_fill_sense(tw_dev, request_id, 0, 1);
1283                                         }
1284                                 }
1285                         }
1286
1287                         /* Check for correct state */
1288                         if (tw_dev->state[request_id] != TW_S_POSTED) {
1289                                 if (tw_dev->srb[request_id] != 0) {
1290                                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Received a request id that wasn't posted");
1291                                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1292                                         goto twa_interrupt_bail;
1293                                 }
1294                         }
1295
1296                         /* Check for internal command completion */
1297                         if (tw_dev->srb[request_id] == 0) {
1298                                 if (request_id != tw_dev->chrdev_request_id) {
1299                                         if (twa_aen_complete(tw_dev, request_id))
1300                                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Error completing AEN during attention interrupt");
1301                                 } else {
1302                                         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1303                                         wake_up(&tw_dev->ioctl_wqueue);
1304                                 }
1305                         } else {
1306                                 twa_scsiop_execute_scsi_complete(tw_dev, request_id);
1307                                 /* If no error command was a success */
1308                                 if (error == 0) {
1309                                         tw_dev->srb[request_id]->result = (DID_OK << 16);
1310                                 }
1311
1312                                 /* If error, command failed */
1313                                 if (error == 1) {
1314                                         /* Ask for a host reset */
1315                                         tw_dev->srb[request_id]->result = (DID_OK << 16) | (CHECK_CONDITION << 1);
1316                                 }
1317
1318                                 /* Report residual bytes for single sgl */
1319                                 if ((tw_dev->srb[request_id]->use_sg <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1320                                         if (full_command_packet->command.newcommand.sg_list[0].length < tw_dev->srb[request_id]->request_bufflen)
1321                                                 tw_dev->srb[request_id]->resid = tw_dev->srb[request_id]->request_bufflen - full_command_packet->command.newcommand.sg_list[0].length;
1322                                 }
1323
1324                                 /* Now complete the io */
1325                                 tw_dev->state[request_id] = TW_S_COMPLETED;
1326                                 twa_free_request_id(tw_dev, request_id);
1327                                 tw_dev->posted_request_count--;
1328                                 tw_dev->srb[request_id]->scsi_done(tw_dev->srb[request_id]);
1329                                 twa_unmap_scsi_data(tw_dev, request_id);
1330                         }
1331
1332                         /* Check for valid status after each drain */
1333                         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1334                         if (twa_check_bits(status_reg_value)) {
1335                                 if (twa_decode_bits(tw_dev, status_reg_value)) {
1336                                         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1337                                         goto twa_interrupt_bail;
1338                                 }
1339                         }
1340                 }
1341         }
1342
1343 twa_interrupt_bail:
1344         spin_unlock(tw_dev->host->host_lock);
1345         return IRQ_RETVAL(handled);
1346 } /* End twa_interrupt() */
1347
1348 /* This function will load the request id and various sgls for ioctls */
1349 static void twa_load_sgl(TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length)
1350 {
1351         TW_Command *oldcommand;
1352         TW_Command_Apache *newcommand;
1353         TW_SG_Entry *sgl;
1354
1355         if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1356                 newcommand = &full_command_packet->command.newcommand;
1357                 newcommand->request_id__lunl =
1358                         TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id);
1359                 newcommand->sg_list[0].address = dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1;
1360                 newcommand->sg_list[0].length = length;
1361                 newcommand->sgl_entries__lunh =
1362                         TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), 1);
1363         } else {
1364                 oldcommand = &full_command_packet->command.oldcommand;
1365                 oldcommand->request_id = request_id;
1366
1367                 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
1368                         /* Load the sg list */
1369                         sgl = (TW_SG_Entry *)((u32 *)oldcommand+TW_SGL_OUT(oldcommand->opcode__sgloffset));
1370                         sgl->address = dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1;
1371                         sgl->length = length;
1372
1373                         if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
1374                                 oldcommand->size += 1;
1375                 }
1376         }
1377 } /* End twa_load_sgl() */
1378
1379 /* This function will perform a pci-dma mapping for a scatter gather list */
1380 static int twa_map_scsi_sg_data(TW_Device_Extension *tw_dev, int request_id)
1381 {
1382         int use_sg;
1383         struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1384         struct pci_dev *pdev = tw_dev->tw_pci_dev;
1385         int retval = 0;
1386
1387         if (cmd->use_sg == 0)
1388                 goto out;
1389
1390         use_sg = pci_map_sg(pdev, cmd->buffer, cmd->use_sg, DMA_BIDIRECTIONAL);
1391
1392         if (use_sg == 0) {
1393                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to map scatter gather list");
1394                 goto out;
1395         }
1396
1397         cmd->SCp.phase = TW_PHASE_SGLIST;
1398         cmd->SCp.have_data_in = use_sg;
1399         retval = use_sg;
1400 out:
1401         return retval;
1402 } /* End twa_map_scsi_sg_data() */
1403
1404 /* This function will perform a pci-dma map for a single buffer */
1405 static dma_addr_t twa_map_scsi_single_data(TW_Device_Extension *tw_dev, int request_id)
1406 {
1407         dma_addr_t mapping;
1408         struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1409         struct pci_dev *pdev = tw_dev->tw_pci_dev;
1410         int retval = 0;
1411
1412         if (cmd->request_bufflen == 0) {
1413                 retval = 0;
1414                 goto out;
1415         }
1416
1417         mapping = pci_map_single(pdev, cmd->request_buffer, cmd->request_bufflen, DMA_BIDIRECTIONAL);
1418
1419         if (mapping == 0) {
1420                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1d, "Failed to map page");
1421                 goto out;
1422         }
1423
1424         cmd->SCp.phase = TW_PHASE_SINGLE;
1425         cmd->SCp.have_data_in = mapping;
1426         retval = mapping;
1427 out:
1428         return retval;
1429 } /* End twa_map_scsi_single_data() */
1430
1431 /* This function will poll for a response interrupt of a request */
1432 static int twa_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
1433 {
1434         int retval = 1, found = 0, response_request_id;
1435         TW_Response_Queue response_queue;
1436         TW_Command_Full *full_command_packet = tw_dev->command_packet_virt[request_id];
1437
1438         if (twa_poll_status_gone(tw_dev, TW_STATUS_RESPONSE_QUEUE_EMPTY, seconds) == 0) {
1439                 response_queue.value = readl(TW_RESPONSE_QUEUE_REG_ADDR(tw_dev));
1440                 response_request_id = TW_RESID_OUT(response_queue.response_id);
1441                 if (request_id != response_request_id) {
1442                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "Found unexpected request id while polling for response");
1443                         goto out;
1444                 }
1445                 if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
1446                         if (full_command_packet->command.newcommand.status != 0) {
1447                                 /* bad response */
1448                                 twa_fill_sense(tw_dev, request_id, 0, 0);
1449                                 goto out;
1450                         }
1451                         found = 1;
1452                 } else {
1453                         if (full_command_packet->command.oldcommand.status != 0) {
1454                                 /* bad response */
1455                                 twa_fill_sense(tw_dev, request_id, 0, 0);
1456                                 goto out;
1457                         }
1458                         found = 1;
1459                 }
1460         }
1461
1462         if (found)
1463                 retval = 0;
1464 out:
1465         return retval;
1466 } /* End twa_poll_response() */
1467
1468 /* This function will poll the status register for a flag */
1469 static int twa_poll_status(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1470 {
1471         u32 status_reg_value;
1472         unsigned long before;
1473         int retval = 1;
1474
1475         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1476         before = jiffies;
1477
1478         if (twa_check_bits(status_reg_value))
1479                 twa_decode_bits(tw_dev, status_reg_value);
1480
1481         while ((status_reg_value & flag) != flag) {
1482                 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1483
1484                 if (twa_check_bits(status_reg_value))
1485                         twa_decode_bits(tw_dev, status_reg_value);
1486
1487                 if (time_after(jiffies, before + HZ * seconds))
1488                         goto out;
1489
1490                 msleep(50);
1491         }
1492         retval = 0;
1493 out:
1494         return retval;
1495 } /* End twa_poll_status() */
1496
1497 /* This function will poll the status register for disappearance of a flag */
1498 static int twa_poll_status_gone(TW_Device_Extension *tw_dev, u32 flag, int seconds)
1499 {
1500         u32 status_reg_value;
1501         unsigned long before;
1502         int retval = 1;
1503
1504         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1505         before = jiffies;
1506
1507         if (twa_check_bits(status_reg_value))
1508                 twa_decode_bits(tw_dev, status_reg_value);
1509
1510         while ((status_reg_value & flag) != 0) {
1511                 status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1512                 if (twa_check_bits(status_reg_value))
1513                         twa_decode_bits(tw_dev, status_reg_value);
1514
1515                 if (time_after(jiffies, before + HZ * seconds))
1516                         goto out;
1517
1518                 msleep(50);
1519         }
1520         retval = 0;
1521 out:
1522         return retval;
1523 } /* End twa_poll_status_gone() */
1524
1525 /* This function will attempt to post a command packet to the board */
1526 static int twa_post_command_packet(TW_Device_Extension *tw_dev, int request_id, char internal)
1527 {
1528         u32 status_reg_value;
1529         dma_addr_t command_que_value;
1530         int retval = 1;
1531
1532         command_que_value = tw_dev->command_packet_phys[request_id];
1533         status_reg_value = readl(TW_STATUS_REG_ADDR(tw_dev));
1534
1535         if (twa_check_bits(status_reg_value))
1536                 twa_decode_bits(tw_dev, status_reg_value);
1537
1538         if (((tw_dev->pending_request_count > 0) && (tw_dev->state[request_id] != TW_S_PENDING)) || (status_reg_value & TW_STATUS_COMMAND_QUEUE_FULL)) {
1539
1540                 /* Only pend internal driver commands */
1541                 if (!internal) {
1542                         retval = SCSI_MLQUEUE_HOST_BUSY;
1543                         goto out;
1544                 }
1545
1546                 /* Couldn't post the command packet, so we do it later */
1547                 if (tw_dev->state[request_id] != TW_S_PENDING) {
1548                         tw_dev->state[request_id] = TW_S_PENDING;
1549                         tw_dev->pending_request_count++;
1550                         if (tw_dev->pending_request_count > tw_dev->max_pending_request_count) {
1551                                 tw_dev->max_pending_request_count = tw_dev->pending_request_count;
1552                         }
1553                         tw_dev->pending_queue[tw_dev->pending_tail] = request_id;
1554                         tw_dev->pending_tail = (tw_dev->pending_tail + 1) % TW_Q_LENGTH;
1555                 }
1556                 TW_UNMASK_COMMAND_INTERRUPT(tw_dev);
1557                 goto out;
1558         } else {
1559                 /* We successfully posted the command packet */
1560                 if (sizeof(dma_addr_t) > 4) {
1561                         command_que_value += TW_COMMAND_OFFSET;
1562                         writel((u32)command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1563                         writel((u32)((u64)command_que_value >> 32), TW_COMMAND_QUEUE_REG_ADDR(tw_dev) + 0x4);
1564                 } else {
1565                         writel(TW_COMMAND_OFFSET + command_que_value, TW_COMMAND_QUEUE_REG_ADDR(tw_dev));
1566                 }
1567                 tw_dev->state[request_id] = TW_S_POSTED;
1568                 tw_dev->posted_request_count++;
1569                 if (tw_dev->posted_request_count > tw_dev->max_posted_request_count) {
1570                         tw_dev->max_posted_request_count = tw_dev->posted_request_count;
1571                 }
1572         }
1573         retval = 0;
1574 out:
1575         return retval;
1576 } /* End twa_post_command_packet() */
1577
1578 /* This function will reset a device extension */
1579 static int twa_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset)
1580 {
1581         int i = 0;
1582         int retval = 1;
1583         unsigned long flags = 0;
1584
1585         set_bit(TW_IN_RESET, &tw_dev->flags);
1586         TW_DISABLE_INTERRUPTS(tw_dev);
1587         TW_MASK_COMMAND_INTERRUPT(tw_dev);
1588         spin_lock_irqsave(tw_dev->host->host_lock, flags);
1589
1590         /* Abort all requests that are in progress */
1591         for (i = 0; i < TW_Q_LENGTH; i++) {
1592                 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1593                     (tw_dev->state[i] != TW_S_INITIAL) &&
1594                     (tw_dev->state[i] != TW_S_COMPLETED)) {
1595                         if (tw_dev->srb[i]) {
1596                                 tw_dev->srb[i]->result = (DID_RESET << 16);
1597                                 tw_dev->srb[i]->scsi_done(tw_dev->srb[i]);
1598                                 twa_unmap_scsi_data(tw_dev, i);
1599                         }
1600                 }
1601         }
1602
1603         /* Reset queues and counts */
1604         for (i = 0; i < TW_Q_LENGTH; i++) {
1605                 tw_dev->free_queue[i] = i;
1606                 tw_dev->state[i] = TW_S_INITIAL;
1607         }
1608         tw_dev->free_head = TW_Q_START;
1609         tw_dev->free_tail = TW_Q_START;
1610         tw_dev->posted_request_count = 0;
1611         tw_dev->pending_request_count = 0;
1612         tw_dev->pending_head = TW_Q_START;
1613         tw_dev->pending_tail = TW_Q_START;
1614         tw_dev->reset_print = 0;
1615
1616         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1617
1618         if (twa_reset_sequence(tw_dev, 1))
1619                 goto out;
1620
1621         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
1622
1623         /* Wake up any ioctl that was pending before the reset */
1624         if ((tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE) || (ioctl_reset)) {
1625                 clear_bit(TW_IN_RESET, &tw_dev->flags);
1626         } else {
1627                 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1628                 wake_up(&tw_dev->ioctl_wqueue);
1629         }
1630         retval = 0;
1631 out:
1632         return retval;
1633 } /* End twa_reset_device_extension() */
1634
1635 /* This function will reset a controller */
1636 static int twa_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1637 {
1638         int tries = 0, retval = 1, flashed = 0, do_soft_reset = soft_reset;
1639
1640         while (tries < TW_MAX_RESET_TRIES) {
1641                 if (do_soft_reset) {
1642                         TW_SOFT_RESET(tw_dev);
1643                         /* Clear pchip/response queue on 9550SX */
1644                         if (twa_empty_response_queue_large(tw_dev)) {
1645                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x36, "Response queue (large) empty failed during reset sequence");
1646                                 do_soft_reset = 1;
1647                                 tries++;
1648                                 continue;
1649                         }
1650                 }
1651
1652                 /* Make sure controller is in a good state */
1653                 if (twa_poll_status(tw_dev, TW_STATUS_MICROCONTROLLER_READY | (do_soft_reset == 1 ? TW_STATUS_ATTENTION_INTERRUPT : 0), 60)) {
1654                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Microcontroller not ready during reset sequence");
1655                         do_soft_reset = 1;
1656                         tries++;
1657                         continue;
1658                 }
1659
1660                 /* Empty response queue */
1661                 if (twa_empty_response_queue(tw_dev)) {
1662                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Response queue empty failed during reset sequence");
1663                         do_soft_reset = 1;
1664                         tries++;
1665                         continue;
1666                 }
1667
1668                 flashed = 0;
1669
1670                 /* Check for compatibility/flash */
1671                 if (twa_check_srl(tw_dev, &flashed)) {
1672                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Compatibility check failed during reset sequence");
1673                         do_soft_reset = 1;
1674                         tries++;
1675                         continue;
1676                 } else {
1677                         if (flashed) {
1678                                 tries++;
1679                                 continue;
1680                         }
1681                 }
1682
1683                 /* Drain the AEN queue */
1684                 if (twa_aen_drain_queue(tw_dev, soft_reset)) {
1685                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x22, "AEN drain failed during reset sequence");
1686                         do_soft_reset = 1;
1687                         tries++;
1688                         continue;
1689                 }
1690
1691                 /* If we got here, controller is in a good state */
1692                 retval = 0;
1693                 goto out;
1694         }
1695 out:
1696         return retval;
1697 } /* End twa_reset_sequence() */
1698
1699 /* This funciton returns unit geometry in cylinders/heads/sectors */
1700 static int twa_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1701 {
1702         int heads, sectors, cylinders;
1703         TW_Device_Extension *tw_dev;
1704
1705         tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1706
1707         if (capacity >= 0x200000) {
1708                 heads = 255;
1709                 sectors = 63;
1710                 cylinders = sector_div(capacity, heads * sectors);
1711         } else {
1712                 heads = 64;
1713                 sectors = 32;
1714                 cylinders = sector_div(capacity, heads * sectors);
1715         }
1716
1717         geom[0] = heads;
1718         geom[1] = sectors;
1719         geom[2] = cylinders;
1720
1721         return 0;
1722 } /* End twa_scsi_biosparam() */
1723
1724 /* This is the new scsi eh reset function */
1725 static int twa_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1726 {
1727         TW_Device_Extension *tw_dev = NULL;
1728         int retval = FAILED;
1729
1730         tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1731
1732         tw_dev->num_resets++;
1733
1734         sdev_printk(KERN_WARNING, SCpnt->device,
1735                 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1736                 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1737
1738         /* Now reset the card and some of the device extension data */
1739         if (twa_reset_device_extension(tw_dev, 0)) {
1740                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2b, "Controller reset failed during scsi host reset");
1741                 goto out;
1742         }
1743
1744         retval = SUCCESS;
1745 out:
1746         return retval;
1747 } /* End twa_scsi_eh_reset() */
1748
1749 /* This is the main scsi queue function to handle scsi opcodes */
1750 static int twa_scsi_queue(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1751 {
1752         int request_id, retval;
1753         TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1754
1755         /* Check if this FW supports luns */
1756         if ((SCpnt->device->lun != 0) && (tw_dev->working_srl < TW_FW_SRL_LUNS_SUPPORTED)) {
1757                 SCpnt->result = (DID_BAD_TARGET << 16);
1758                 done(SCpnt);
1759                 retval = 0;
1760                 goto out;
1761         }
1762
1763         /* Save done function into scsi_cmnd struct */
1764         SCpnt->scsi_done = done;
1765
1766         /* Get a free request id */
1767         twa_get_request_id(tw_dev, &request_id);
1768
1769         /* Save the scsi command for use by the ISR */
1770         tw_dev->srb[request_id] = SCpnt;
1771
1772         /* Initialize phase to zero */
1773         SCpnt->SCp.phase = TW_PHASE_INITIAL;
1774
1775         retval = twa_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1776         switch (retval) {
1777         case SCSI_MLQUEUE_HOST_BUSY:
1778                 twa_free_request_id(tw_dev, request_id);
1779                 break;
1780         case 1:
1781                 tw_dev->state[request_id] = TW_S_COMPLETED;
1782                 twa_free_request_id(tw_dev, request_id);
1783                 SCpnt->result = (DID_ERROR << 16);
1784                 done(SCpnt);
1785                 retval = 0;
1786         }
1787 out:
1788         return retval;
1789 } /* End twa_scsi_queue() */
1790
1791 /* This function hands scsi cdb's to the firmware */
1792 static int twa_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry *sglistarg)
1793 {
1794         TW_Command_Full *full_command_packet;
1795         TW_Command_Apache *command_packet;
1796         u32 num_sectors = 0x0;
1797         int i, sg_count;
1798         struct scsi_cmnd *srb = NULL;
1799         struct scatterlist *sglist = NULL;
1800         u32 buffaddr = 0x0;
1801         int retval = 1;
1802
1803         if (tw_dev->srb[request_id]) {
1804                 if (tw_dev->srb[request_id]->request_buffer) {
1805                         sglist = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
1806                 }
1807                 srb = tw_dev->srb[request_id];
1808         }
1809
1810         /* Initialize command packet */
1811         full_command_packet = tw_dev->command_packet_virt[request_id];
1812         full_command_packet->header.header_desc.size_header = 128;
1813         full_command_packet->header.status_block.error = 0;
1814         full_command_packet->header.status_block.severity__reserved = 0;
1815
1816         command_packet = &full_command_packet->command.newcommand;
1817         command_packet->status = 0;
1818         command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
1819
1820         /* We forced 16 byte cdb use earlier */
1821         if (!cdb)
1822                 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
1823         else
1824                 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
1825
1826         if (srb) {
1827                 command_packet->unit = srb->device->id;
1828                 command_packet->request_id__lunl =
1829                         TW_REQ_LUN_IN(srb->device->lun, request_id);
1830         } else {
1831                 command_packet->request_id__lunl =
1832                         TW_REQ_LUN_IN(0, request_id);
1833                 command_packet->unit = 0;
1834         }
1835
1836         command_packet->sgl_offset = 16;
1837
1838         if (!sglistarg) {
1839                 /* Map sglist from scsi layer to cmd packet */
1840                 if (tw_dev->srb[request_id]->use_sg == 0) {
1841                         if (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH) {
1842                                 command_packet->sg_list[0].address = tw_dev->generic_buffer_phys[request_id];
1843                                 command_packet->sg_list[0].length = TW_MIN_SGL_LENGTH;
1844                                 if (tw_dev->srb[request_id]->sc_data_direction == DMA_TO_DEVICE || tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL)
1845                                         memcpy(tw_dev->generic_buffer_virt[request_id], tw_dev->srb[request_id]->request_buffer, tw_dev->srb[request_id]->request_bufflen);
1846                         } else {
1847                                 buffaddr = twa_map_scsi_single_data(tw_dev, request_id);
1848                                 if (buffaddr == 0)
1849                                         goto out;
1850
1851                                 command_packet->sg_list[0].address = buffaddr;
1852                                 command_packet->sg_list[0].length = tw_dev->srb[request_id]->request_bufflen;
1853                         }
1854                         command_packet->sgl_entries__lunh = TW_REQ_LUN_IN((srb->device->lun >> 4), 1);
1855
1856                         if (command_packet->sg_list[0].address & TW_ALIGNMENT_9000_SGL) {
1857                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2d, "Found unaligned address during execute scsi");
1858                                 goto out;
1859                         }
1860                 }
1861
1862                 if (tw_dev->srb[request_id]->use_sg > 0) {
1863                         if ((tw_dev->srb[request_id]->use_sg == 1) && (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH)) {
1864                                 if (tw_dev->srb[request_id]->sc_data_direction == DMA_TO_DEVICE || tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL) {
1865                                         struct scatterlist *sg = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
1866                                         char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1867                                         memcpy(tw_dev->generic_buffer_virt[request_id], buf, sg->length);
1868                                         kunmap_atomic(buf - sg->offset, KM_IRQ0);
1869                                 }
1870                                 command_packet->sg_list[0].address = tw_dev->generic_buffer_phys[request_id];
1871                                 command_packet->sg_list[0].length = TW_MIN_SGL_LENGTH;
1872                         } else {
1873                                 sg_count = twa_map_scsi_sg_data(tw_dev, request_id);
1874                                 if (sg_count == 0)
1875                                         goto out;
1876
1877                                 for (i = 0; i < sg_count; i++) {
1878                                         command_packet->sg_list[i].address = sg_dma_address(&sglist[i]);
1879                                         command_packet->sg_list[i].length = sg_dma_len(&sglist[i]);
1880                                         if (command_packet->sg_list[i].address & TW_ALIGNMENT_9000_SGL) {
1881                                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2e, "Found unaligned sgl address during execute scsi");
1882                                                 goto out;
1883                                         }
1884                                 }
1885                         }
1886                         command_packet->sgl_entries__lunh = TW_REQ_LUN_IN((srb->device->lun >> 4), tw_dev->srb[request_id]->use_sg);
1887                 }
1888         } else {
1889                 /* Internal cdb post */
1890                 for (i = 0; i < use_sg; i++) {
1891                         command_packet->sg_list[i].address = sglistarg[i].address;
1892                         command_packet->sg_list[i].length = sglistarg[i].length;
1893                         if (command_packet->sg_list[i].address & TW_ALIGNMENT_9000_SGL) {
1894                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2f, "Found unaligned sgl address during internal post");
1895                                 goto out;
1896                         }
1897                 }
1898                 command_packet->sgl_entries__lunh = TW_REQ_LUN_IN(0, use_sg);
1899         }
1900
1901         if (srb) {
1902                 if (srb->cmnd[0] == READ_6 || srb->cmnd[0] == WRITE_6)
1903                         num_sectors = (u32)srb->cmnd[4];
1904
1905                 if (srb->cmnd[0] == READ_10 || srb->cmnd[0] == WRITE_10)
1906                         num_sectors = (u32)srb->cmnd[8] | ((u32)srb->cmnd[7] << 8);
1907         }
1908
1909         /* Update sector statistic */
1910         tw_dev->sector_count = num_sectors;
1911         if (tw_dev->sector_count > tw_dev->max_sector_count)
1912                 tw_dev->max_sector_count = tw_dev->sector_count;
1913
1914         /* Update SG statistics */
1915         if (srb) {
1916                 tw_dev->sgl_entries = tw_dev->srb[request_id]->use_sg;
1917                 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
1918                         tw_dev->max_sgl_entries = tw_dev->sgl_entries;
1919         }
1920
1921         /* Now post the command to the board */
1922         if (srb) {
1923                 retval = twa_post_command_packet(tw_dev, request_id, 0);
1924         } else {
1925                 twa_post_command_packet(tw_dev, request_id, 1);
1926                 retval = 0;
1927         }
1928 out:
1929         return retval;
1930 } /* End twa_scsiop_execute_scsi() */
1931
1932 /* This function completes an execute scsi operation */
1933 static void twa_scsiop_execute_scsi_complete(TW_Device_Extension *tw_dev, int request_id)
1934 {
1935         if (tw_dev->srb[request_id]->request_bufflen < TW_MIN_SGL_LENGTH &&
1936             (tw_dev->srb[request_id]->sc_data_direction == DMA_FROM_DEVICE ||
1937              tw_dev->srb[request_id]->sc_data_direction == DMA_BIDIRECTIONAL)) {
1938                 if (tw_dev->srb[request_id]->use_sg == 0) {
1939                         memcpy(tw_dev->srb[request_id]->request_buffer,
1940                                tw_dev->generic_buffer_virt[request_id],
1941                                tw_dev->srb[request_id]->request_bufflen);
1942                 }
1943                 if (tw_dev->srb[request_id]->use_sg == 1) {
1944                         struct scatterlist *sg = (struct scatterlist *)tw_dev->srb[request_id]->request_buffer;
1945                         char *buf = kmap_atomic(sg->page, KM_IRQ0) + sg->offset;
1946                         memcpy(buf, tw_dev->generic_buffer_virt[request_id], sg->length);
1947                         kunmap_atomic(buf - sg->offset, KM_IRQ0);
1948                 }
1949         }
1950 } /* End twa_scsiop_execute_scsi_complete() */
1951
1952 /* This function tells the controller to shut down */
1953 static void __twa_shutdown(TW_Device_Extension *tw_dev)
1954 {
1955         /* Disable interrupts */
1956         TW_DISABLE_INTERRUPTS(tw_dev);
1957
1958         printk(KERN_WARNING "3w-9xxx: Shutting down host %d.\n", tw_dev->host->host_no);
1959
1960         /* Tell the card we are shutting down */
1961         if (twa_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1962                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x31, "Connection shutdown failed");
1963         } else {
1964                 printk(KERN_WARNING "3w-9xxx: Shutdown complete.\n");
1965         }
1966
1967         /* Clear all interrupts just before exit */
1968         TW_CLEAR_ALL_INTERRUPTS(tw_dev);
1969 } /* End __twa_shutdown() */
1970
1971 /* Wrapper for __twa_shutdown */
1972 static void twa_shutdown(struct pci_dev *pdev)
1973 {
1974         struct Scsi_Host *host = pci_get_drvdata(pdev);
1975         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1976
1977         __twa_shutdown(tw_dev);
1978 } /* End twa_shutdown() */
1979
1980 /* This function will look up a string */
1981 static char *twa_string_lookup(twa_message_type *table, unsigned int code)
1982 {
1983         int index;
1984
1985         for (index = 0; ((code != table[index].code) &&
1986                       (table[index].text != (char *)0)); index++);
1987         return(table[index].text);
1988 } /* End twa_string_lookup() */
1989
1990 /* This function will perform a pci-dma unmap */
1991 static void twa_unmap_scsi_data(TW_Device_Extension *tw_dev, int request_id)
1992 {
1993         struct scsi_cmnd *cmd = tw_dev->srb[request_id];
1994         struct pci_dev *pdev = tw_dev->tw_pci_dev;
1995
1996         switch(cmd->SCp.phase) {
1997         case TW_PHASE_SINGLE:
1998                 pci_unmap_single(pdev, cmd->SCp.have_data_in, cmd->request_bufflen, DMA_BIDIRECTIONAL);
1999                 break;
2000         case TW_PHASE_SGLIST:
2001                 pci_unmap_sg(pdev, cmd->request_buffer, cmd->use_sg, DMA_BIDIRECTIONAL);
2002                 break;
2003         }
2004 } /* End twa_unmap_scsi_data() */
2005
2006 /* scsi_host_template initializer */
2007 static struct scsi_host_template driver_template = {
2008         .module                 = THIS_MODULE,
2009         .name                   = "3ware 9000 Storage Controller",
2010         .queuecommand           = twa_scsi_queue,
2011         .eh_host_reset_handler  = twa_scsi_eh_reset,
2012         .bios_param             = twa_scsi_biosparam,
2013         .change_queue_depth     = twa_change_queue_depth,
2014         .can_queue              = TW_Q_LENGTH-2,
2015         .this_id                = -1,
2016         .sg_tablesize           = TW_APACHE_MAX_SGL_LENGTH,
2017         .max_sectors            = TW_MAX_SECTORS,
2018         .cmd_per_lun            = TW_MAX_CMDS_PER_LUN,
2019         .use_clustering         = ENABLE_CLUSTERING,
2020         .shost_attrs            = twa_host_attrs,
2021         .emulated               = 1
2022 };
2023
2024 /* This function will probe and initialize a card */
2025 static int __devinit twa_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
2026 {
2027         struct Scsi_Host *host = NULL;
2028         TW_Device_Extension *tw_dev;
2029         u32 mem_addr;
2030         int retval = -ENODEV;
2031
2032         retval = pci_enable_device(pdev);
2033         if (retval) {
2034                 TW_PRINTK(host, TW_DRIVER, 0x34, "Failed to enable pci device");
2035                 goto out_disable_device;
2036         }
2037
2038         pci_set_master(pdev);
2039
2040         retval = pci_set_dma_mask(pdev, sizeof(dma_addr_t) > 4 ? DMA_64BIT_MASK : DMA_32BIT_MASK);
2041         if (retval) {
2042                 TW_PRINTK(host, TW_DRIVER, 0x23, "Failed to set dma mask");
2043                 goto out_disable_device;
2044         }
2045
2046         host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
2047         if (!host) {
2048                 TW_PRINTK(host, TW_DRIVER, 0x24, "Failed to allocate memory for device extension");
2049                 retval = -ENOMEM;
2050                 goto out_disable_device;
2051         }
2052         tw_dev = (TW_Device_Extension *)host->hostdata;
2053
2054         memset(tw_dev, 0, sizeof(TW_Device_Extension));
2055
2056         /* Save values to device extension */
2057         tw_dev->host = host;
2058         tw_dev->tw_pci_dev = pdev;
2059
2060         if (twa_initialize_device_extension(tw_dev)) {
2061                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x25, "Failed to initialize device extension");
2062                 goto out_free_device_extension;
2063         }
2064
2065         /* Request IO regions */
2066         retval = pci_request_regions(pdev, "3w-9xxx");
2067         if (retval) {
2068                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Failed to get mem region");
2069                 goto out_free_device_extension;
2070         }
2071
2072         if (pdev->device == PCI_DEVICE_ID_3WARE_9000)
2073                 mem_addr = pci_resource_start(pdev, 1);
2074         else
2075                 mem_addr = pci_resource_start(pdev, 2);
2076
2077         /* Save base address */
2078         tw_dev->base_addr = ioremap(mem_addr, PAGE_SIZE);
2079         if (!tw_dev->base_addr) {
2080                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x35, "Failed to ioremap");
2081                 goto out_release_mem_region;
2082         }
2083
2084         /* Disable interrupts on the card */
2085         TW_DISABLE_INTERRUPTS(tw_dev);
2086
2087         /* Initialize the card */
2088         if (twa_reset_sequence(tw_dev, 0))
2089                 goto out_release_mem_region;
2090
2091         /* Set host specific parameters */
2092         host->max_id = TW_MAX_UNITS;
2093         host->max_cmd_len = TW_MAX_CDB_LEN;
2094
2095         /* Channels aren't supported by adapter */
2096         host->max_lun = TW_MAX_LUNS(tw_dev->working_srl);
2097         host->max_channel = 0;
2098
2099         /* Register the card with the kernel SCSI layer */
2100         retval = scsi_add_host(host, &pdev->dev);
2101         if (retval) {
2102                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x27, "scsi add host failed");
2103                 goto out_release_mem_region;
2104         }
2105
2106         pci_set_drvdata(pdev, host);
2107
2108         printk(KERN_WARNING "3w-9xxx: scsi%d: Found a 3ware 9000 Storage Controller at 0x%x, IRQ: %d.\n",
2109                host->host_no, mem_addr, pdev->irq);
2110         printk(KERN_WARNING "3w-9xxx: scsi%d: Firmware %s, BIOS %s, Ports: %d.\n",
2111                host->host_no,
2112                (char *)twa_get_param(tw_dev, 0, TW_VERSION_TABLE,
2113                                      TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
2114                (char *)twa_get_param(tw_dev, 1, TW_VERSION_TABLE,
2115                                      TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
2116                *(int *)twa_get_param(tw_dev, 2, TW_INFORMATION_TABLE,
2117                                      TW_PARAM_PORTCOUNT, TW_PARAM_PORTCOUNT_LENGTH));
2118
2119         /* Now setup the interrupt handler */
2120         retval = request_irq(pdev->irq, twa_interrupt, SA_SHIRQ, "3w-9xxx", tw_dev);
2121         if (retval) {
2122                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x30, "Error requesting IRQ");
2123                 goto out_remove_host;
2124         }
2125
2126         twa_device_extension_list[twa_device_extension_count] = tw_dev;
2127         twa_device_extension_count++;
2128
2129         /* Re-enable interrupts on the card */
2130         TW_ENABLE_AND_CLEAR_INTERRUPTS(tw_dev);
2131
2132         /* Finally, scan the host */
2133         scsi_scan_host(host);
2134
2135         if (twa_major == -1) {
2136                 if ((twa_major = register_chrdev (0, "twa", &twa_fops)) < 0)
2137                         TW_PRINTK(host, TW_DRIVER, 0x29, "Failed to register character device");
2138         }
2139         return 0;
2140
2141 out_remove_host:
2142         scsi_remove_host(host);
2143 out_release_mem_region:
2144         pci_release_regions(pdev);
2145 out_free_device_extension:
2146         twa_free_device_extension(tw_dev);
2147         scsi_host_put(host);
2148 out_disable_device:
2149         pci_disable_device(pdev);
2150
2151         return retval;
2152 } /* End twa_probe() */
2153
2154 /* This function is called to remove a device */
2155 static void twa_remove(struct pci_dev *pdev)
2156 {
2157         struct Scsi_Host *host = pci_get_drvdata(pdev);
2158         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
2159
2160         scsi_remove_host(tw_dev->host);
2161
2162         /* Unregister character device */
2163         if (twa_major >= 0) {
2164                 unregister_chrdev(twa_major, "twa");
2165                 twa_major = -1;
2166         }
2167
2168         /* Free up the IRQ */
2169         free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
2170
2171         /* Shutdown the card */
2172         __twa_shutdown(tw_dev);
2173
2174         /* Free up the mem region */
2175         pci_release_regions(pdev);
2176
2177         /* Free up device extension resources */
2178         twa_free_device_extension(tw_dev);
2179
2180         scsi_host_put(tw_dev->host);
2181         pci_disable_device(pdev);
2182         twa_device_extension_count--;
2183 } /* End twa_remove() */
2184
2185 /* PCI Devices supported by this driver */
2186 static struct pci_device_id twa_pci_tbl[] __devinitdata = {
2187         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9000,
2188           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2189         { PCI_VENDOR_ID_3WARE, PCI_DEVICE_ID_3WARE_9550SX,
2190           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
2191         { }
2192 };
2193 MODULE_DEVICE_TABLE(pci, twa_pci_tbl);
2194
2195 /* pci_driver initializer */
2196 static struct pci_driver twa_driver = {
2197         .name           = "3w-9xxx",
2198         .id_table       = twa_pci_tbl,
2199         .probe          = twa_probe,
2200         .remove         = twa_remove,
2201         .shutdown       = twa_shutdown
2202 };
2203
2204 /* This function is called on driver initialization */
2205 static int __init twa_init(void)
2206 {
2207         printk(KERN_WARNING "3ware 9000 Storage Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
2208
2209         return pci_module_init(&twa_driver);
2210 } /* End twa_init() */
2211
2212 /* This function is called on driver exit */
2213 static void __exit twa_exit(void)
2214 {
2215         pci_unregister_driver(&twa_driver);
2216 } /* End twa_exit() */
2217
2218 module_init(twa_init);
2219 module_exit(twa_exit);
2220