drivers/scsi/3w-sas.c

   1 /*
   2    3w-sas.c -- LSI 3ware SAS/SATA-RAID Controller device driver for Linux.
   3
   4    Written By: Adam Radford <linuxraid@lsi.com>
   5
   6    Copyright (C) 2009 LSI 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    Controllers supported by this driver:
  42
  43    LSI 3ware 9750 6Gb/s SAS/SATA-RAID
  44
  45    Bugs/Comments/Suggestions should be mailed to:
  46    linuxraid@lsi.com
  47
  48    For more information, goto:
  49    http://www.lsi.com
  50
  51    History
  52    -------
  53    3.26.02.000 - Initial driver release.
  54 */
  55
  56 #include <linux/module.h>
  57 #include <linux/reboot.h>
  58 #include <linux/spinlock.h>
  59 #include <linux/interrupt.h>
  60 #include <linux/moduleparam.h>
  61 #include <linux/errno.h>
  62 #include <linux/types.h>
  63 #include <linux/delay.h>
  64 #include <linux/pci.h>
  65 #include <linux/time.h>
  66 #include <linux/mutex.h>
  67 #include <linux/slab.h>
  68 #include <asm/io.h>
  69 #include <asm/irq.h>
  70 #include <asm/uaccess.h>
  71 #include <scsi/scsi.h>
  72 #include <scsi/scsi_host.h>
  73 #include <scsi/scsi_tcq.h>
  74 #include <scsi/scsi_cmnd.h>
  75 #include "3w-sas.h"
  76
  77 /* Globals */
  78 #define TW_DRIVER_VERSION "3.26.02.000"
  79 static DEFINE_MUTEX(twl_chrdev_mutex);
  80 static TW_Device_Extension *twl_device_extension_list[TW_MAX_SLOT];
  81 static unsigned int twl_device_extension_count;
  82 static int twl_major = -1;
  83 extern struct timezone sys_tz;
  84
  85 /* Module parameters */
  86 MODULE_AUTHOR ("LSI");
  87 MODULE_DESCRIPTION ("LSI 3ware SAS/SATA-RAID Linux Driver");
  88 MODULE_LICENSE("GPL");
  89 MODULE_VERSION(TW_DRIVER_VERSION);
  90
  91 static int use_msi;
  92 module_param(use_msi, int, S_IRUGO);
  93 MODULE_PARM_DESC(use_msi, "Use Message Signaled Interrupts. Default: 0");
  94
  95 /* Function prototypes */
  96 static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset);
  97
  98 /* Functions */
  99
 100 /* This function returns AENs through sysfs */
 101 static ssize_t twl_sysfs_aen_read(struct file *filp, struct kobject *kobj,
 102                                   struct bin_attribute *bin_attr,
 103                                   char *outbuf, loff_t offset, size_t count)
 104 {
 105         struct device *dev = container_of(kobj, struct device, kobj);
 106         struct Scsi_Host *shost = class_to_shost(dev);
 107         TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata;
 108         unsigned long flags = 0;
 109         ssize_t ret;
 110
 111         if (!capable(CAP_SYS_ADMIN))
 112                 return -EACCES;
 113
 114         spin_lock_irqsave(tw_dev->host->host_lock, flags);
 115         ret = memory_read_from_buffer(outbuf, count, &offset, tw_dev->event_queue[0], sizeof(TW_Event) * TW_Q_LENGTH);
 116         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 117
 118         return ret;
 119 } /* End twl_sysfs_aen_read() */
 120
 121 /* aen_read sysfs attribute initializer */
 122 static struct bin_attribute twl_sysfs_aen_read_attr = {
 123         .attr = {
 124                 .name = "3ware_aen_read",
 125                 .mode = S_IRUSR,
 126         },
 127         .size = 0,
 128         .read = twl_sysfs_aen_read
 129 };
 130
 131 /* This function returns driver compatibility info through sysfs */
 132 static ssize_t twl_sysfs_compat_info(struct file *filp, struct kobject *kobj,
 133                                      struct bin_attribute *bin_attr,
 134                                      char *outbuf, loff_t offset, size_t count)
 135 {
 136         struct device *dev = container_of(kobj, struct device, kobj);
 137         struct Scsi_Host *shost = class_to_shost(dev);
 138         TW_Device_Extension *tw_dev = (TW_Device_Extension *)shost->hostdata;
 139         unsigned long flags = 0;
 140         ssize_t ret;
 141
 142         if (!capable(CAP_SYS_ADMIN))
 143                 return -EACCES;
 144
 145         spin_lock_irqsave(tw_dev->host->host_lock, flags);
 146         ret = memory_read_from_buffer(outbuf, count, &offset, &tw_dev->tw_compat_info, sizeof(TW_Compatibility_Info));
 147         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 148
 149         return ret;
 150 } /* End twl_sysfs_compat_info() */
 151
 152 /* compat_info sysfs attribute initializer */
 153 static struct bin_attribute twl_sysfs_compat_info_attr = {
 154         .attr = {
 155                 .name = "3ware_compat_info",
 156                 .mode = S_IRUSR,
 157         },
 158         .size = 0,
 159         .read = twl_sysfs_compat_info
 160 };
 161
 162 /* Show some statistics about the card */
 163 static ssize_t twl_show_stats(struct device *dev,
 164                               struct device_attribute *attr, char *buf)
 165 {
 166         struct Scsi_Host *host = class_to_shost(dev);
 167         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
 168         unsigned long flags = 0;
 169         ssize_t len;
 170
 171         spin_lock_irqsave(tw_dev->host->host_lock, flags);
 172         len = snprintf(buf, PAGE_SIZE, "3w-sas Driver version: %s\n"
 173                        "Current commands posted:   %4d\n"
 174                        "Max commands posted:       %4d\n"
 175                        "Last sgl length:           %4d\n"
 176                        "Max sgl length:            %4d\n"
 177                        "Last sector count:         %4d\n"
 178                        "Max sector count:          %4d\n"
 179                        "SCSI Host Resets:          %4d\n"
 180                        "AEN's:                     %4d\n",
 181                        TW_DRIVER_VERSION,
 182                        tw_dev->posted_request_count,
 183                        tw_dev->max_posted_request_count,
 184                        tw_dev->sgl_entries,
 185                        tw_dev->max_sgl_entries,
 186                        tw_dev->sector_count,
 187                        tw_dev->max_sector_count,
 188                        tw_dev->num_resets,
 189                        tw_dev->aen_count);
 190         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 191         return len;
 192 } /* End twl_show_stats() */
 193
 194 /* stats sysfs attribute initializer */
 195 static struct device_attribute twl_host_stats_attr = {
 196         .attr = {
 197                 .name =         "3ware_stats",
 198                 .mode =         S_IRUGO,
 199         },
 200         .show = twl_show_stats
 201 };
 202
 203 /* Host attributes initializer */
 204 static struct device_attribute *twl_host_attrs[] = {
 205         &twl_host_stats_attr,
 206         NULL,
 207 };
 208
 209 /* This function will look up an AEN severity string */
 210 static char *twl_aen_severity_lookup(unsigned char severity_code)
 211 {
 212         char *retval = NULL;
 213
 214         if ((severity_code < (unsigned char) TW_AEN_SEVERITY_ERROR) ||
 215             (severity_code > (unsigned char) TW_AEN_SEVERITY_DEBUG))
 216                 goto out;
 217
 218         retval = twl_aen_severity_table[severity_code];
 219 out:
 220         return retval;
 221 } /* End twl_aen_severity_lookup() */
 222
 223 /* This function will queue an event */
 224 static void twl_aen_queue_event(TW_Device_Extension *tw_dev, TW_Command_Apache_Header *header)
 225 {
 226         u32 local_time;
 227         struct timeval time;
 228         TW_Event *event;
 229         unsigned short aen;
 230         char host[16];
 231         char *error_str;
 232
 233         tw_dev->aen_count++;
 234
 235         /* Fill out event info */
 236         event = tw_dev->event_queue[tw_dev->error_index];
 237
 238         host[0] = '\0';
 239         if (tw_dev->host)
 240                 sprintf(host, " scsi%d:", tw_dev->host->host_no);
 241
 242         aen = le16_to_cpu(header->status_block.error);
 243         memset(event, 0, sizeof(TW_Event));
 244
 245         event->severity = TW_SEV_OUT(header->status_block.severity__reserved);
 246         do_gettimeofday(&time);
 247         local_time = (u32)(time.tv_sec - (sys_tz.tz_minuteswest * 60));
 248         event->time_stamp_sec = local_time;
 249         event->aen_code = aen;
 250         event->retrieved = TW_AEN_NOT_RETRIEVED;
 251         event->sequence_id = tw_dev->error_sequence_id;
 252         tw_dev->error_sequence_id++;
 253
 254         /* Check for embedded error string */
 255         error_str = &(header->err_specific_desc[strlen(header->err_specific_desc)+1]);
 256
 257         header->err_specific_desc[sizeof(header->err_specific_desc) - 1] = '\0';
 258         event->parameter_len = strlen(header->err_specific_desc);
 259         memcpy(event->parameter_data, header->err_specific_desc, event->parameter_len + 1 + strlen(error_str));
 260         if (event->severity != TW_AEN_SEVERITY_DEBUG)
 261                 printk(KERN_WARNING "3w-sas:%s AEN: %s (0x%02X:0x%04X): %s:%s.\n",
 262                        host,
 263                        twl_aen_severity_lookup(TW_SEV_OUT(header->status_block.severity__reserved)),
 264                        TW_MESSAGE_SOURCE_CONTROLLER_EVENT, aen, error_str,
 265                        header->err_specific_desc);
 266         else
 267                 tw_dev->aen_count--;
 268
 269         tw_dev->error_index = (tw_dev->error_index + 1 ) % TW_Q_LENGTH;
 270 } /* End twl_aen_queue_event() */
 271
 272 /* This function will attempt to post a command packet to the board */
 273 static int twl_post_command_packet(TW_Device_Extension *tw_dev, int request_id)
 274 {
 275         dma_addr_t command_que_value;
 276
 277         command_que_value = tw_dev->command_packet_phys[request_id];
 278         command_que_value += TW_COMMAND_OFFSET;
 279
 280         /* First write upper 4 bytes */
 281         writel((u32)((u64)command_que_value >> 32), TWL_HIBQPH_REG_ADDR(tw_dev));
 282         /* Then the lower 4 bytes */
 283         writel((u32)(command_que_value | TWL_PULL_MODE), TWL_HIBQPL_REG_ADDR(tw_dev));
 284
 285         tw_dev->state[request_id] = TW_S_POSTED;
 286         tw_dev->posted_request_count++;
 287         if (tw_dev->posted_request_count > tw_dev->max_posted_request_count)
 288                 tw_dev->max_posted_request_count = tw_dev->posted_request_count;
 289
 290         return 0;
 291 } /* End twl_post_command_packet() */
 292
 293 /* This function hands scsi cdb's to the firmware */
 294 static int twl_scsiop_execute_scsi(TW_Device_Extension *tw_dev, int request_id, char *cdb, int use_sg, TW_SG_Entry_ISO *sglistarg)
 295 {
 296         TW_Command_Full *full_command_packet;
 297         TW_Command_Apache *command_packet;
 298         int i, sg_count;
 299         struct scsi_cmnd *srb = NULL;
 300         struct scatterlist *sglist = NULL, *sg;
 301         int retval = 1;
 302
 303         if (tw_dev->srb[request_id]) {
 304                 srb = tw_dev->srb[request_id];
 305                 if (scsi_sglist(srb))
 306                         sglist = scsi_sglist(srb);
 307         }
 308
 309         /* Initialize command packet */
 310         full_command_packet = tw_dev->command_packet_virt[request_id];
 311         full_command_packet->header.header_desc.size_header = 128;
 312         full_command_packet->header.status_block.error = 0;
 313         full_command_packet->header.status_block.severity__reserved = 0;
 314
 315         command_packet = &full_command_packet->command.newcommand;
 316         command_packet->status = 0;
 317         command_packet->opcode__reserved = TW_OPRES_IN(0, TW_OP_EXECUTE_SCSI);
 318
 319         /* We forced 16 byte cdb use earlier */
 320         if (!cdb)
 321                 memcpy(command_packet->cdb, srb->cmnd, TW_MAX_CDB_LEN);
 322         else
 323                 memcpy(command_packet->cdb, cdb, TW_MAX_CDB_LEN);
 324
 325         if (srb) {
 326                 command_packet->unit = srb->device->id;
 327                 command_packet->request_id__lunl =
 328                         cpu_to_le16(TW_REQ_LUN_IN(srb->device->lun, request_id));
 329         } else {
 330                 command_packet->request_id__lunl =
 331                         cpu_to_le16(TW_REQ_LUN_IN(0, request_id));
 332                 command_packet->unit = 0;
 333         }
 334
 335         command_packet->sgl_offset = 16;
 336
 337         if (!sglistarg) {
 338                 /* Map sglist from scsi layer to cmd packet */
 339                 if (scsi_sg_count(srb)) {
 340                         sg_count = scsi_dma_map(srb);
 341                         if (sg_count <= 0)
 342                                 goto out;
 343
 344                         scsi_for_each_sg(srb, sg, sg_count, i) {
 345                                 command_packet->sg_list[i].address = TW_CPU_TO_SGL(sg_dma_address(sg));
 346                                 command_packet->sg_list[i].length = TW_CPU_TO_SGL(sg_dma_len(sg));
 347                         }
 348                         command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN((srb->device->lun >> 4), scsi_sg_count(tw_dev->srb[request_id])));
 349                 }
 350         } else {
 351                 /* Internal cdb post */
 352                 for (i = 0; i < use_sg; i++) {
 353                         command_packet->sg_list[i].address = TW_CPU_TO_SGL(sglistarg[i].address);
 354                         command_packet->sg_list[i].length = TW_CPU_TO_SGL(sglistarg[i].length);
 355                 }
 356                 command_packet->sgl_entries__lunh = cpu_to_le16(TW_REQ_LUN_IN(0, use_sg));
 357         }
 358
 359         /* Update some stats */
 360         if (srb) {
 361                 tw_dev->sector_count = scsi_bufflen(srb) / 512;
 362                 if (tw_dev->sector_count > tw_dev->max_sector_count)
 363                         tw_dev->max_sector_count = tw_dev->sector_count;
 364                 tw_dev->sgl_entries = scsi_sg_count(srb);
 365                 if (tw_dev->sgl_entries > tw_dev->max_sgl_entries)
 366                         tw_dev->max_sgl_entries = tw_dev->sgl_entries;
 367         }
 368
 369         /* Now post the command to the board */
 370         retval = twl_post_command_packet(tw_dev, request_id);
 371
 372 out:
 373         return retval;
 374 } /* End twl_scsiop_execute_scsi() */
 375
 376 /* This function will read the aen queue from the isr */
 377 static int twl_aen_read_queue(TW_Device_Extension *tw_dev, int request_id)
 378 {
 379         char cdb[TW_MAX_CDB_LEN];
 380         TW_SG_Entry_ISO sglist[1];
 381         TW_Command_Full *full_command_packet;
 382         int retval = 1;
 383
 384         full_command_packet = tw_dev->command_packet_virt[request_id];
 385         memset(full_command_packet, 0, sizeof(TW_Command_Full));
 386
 387         /* Initialize cdb */
 388         memset(&cdb, 0, TW_MAX_CDB_LEN);
 389         cdb[0] = REQUEST_SENSE; /* opcode */
 390         cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
 391
 392         /* Initialize sglist */
 393         memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
 394         sglist[0].length = TW_SECTOR_SIZE;
 395         sglist[0].address = tw_dev->generic_buffer_phys[request_id];
 396
 397         /* Mark internal command */
 398         tw_dev->srb[request_id] = NULL;
 399
 400         /* Now post the command packet */
 401         if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
 402                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x2, "Post failed while reading AEN queue");
 403                 goto out;
 404         }
 405         retval = 0;
 406 out:
 407         return retval;
 408 } /* End twl_aen_read_queue() */
 409
 410 /* This function will sync firmware time with the host time */
 411 static void twl_aen_sync_time(TW_Device_Extension *tw_dev, int request_id)
 412 {
 413         u32 schedulertime;
 414         struct timeval utc;
 415         TW_Command_Full *full_command_packet;
 416         TW_Command *command_packet;
 417         TW_Param_Apache *param;
 418         u32 local_time;
 419
 420         /* Fill out the command packet */
 421         full_command_packet = tw_dev->command_packet_virt[request_id];
 422         memset(full_command_packet, 0, sizeof(TW_Command_Full));
 423         command_packet = &full_command_packet->command.oldcommand;
 424         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_SET_PARAM);
 425         command_packet->request_id = request_id;
 426         command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
 427         command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
 428         command_packet->size = TW_COMMAND_SIZE;
 429         command_packet->byte6_offset.parameter_count = cpu_to_le16(1);
 430
 431         /* Setup the param */
 432         param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
 433         memset(param, 0, TW_SECTOR_SIZE);
 434         param->table_id = cpu_to_le16(TW_TIMEKEEP_TABLE | 0x8000); /* Controller time keep table */
 435         param->parameter_id = cpu_to_le16(0x3); /* SchedulerTime */
 436         param->parameter_size_bytes = cpu_to_le16(4);
 437
 438         /* Convert system time in UTC to local time seconds since last
 439            Sunday 12:00AM */
 440         do_gettimeofday(&utc);
 441         local_time = (u32)(utc.tv_sec - (sys_tz.tz_minuteswest * 60));
 442         schedulertime = local_time - (3 * 86400);
 443         schedulertime = cpu_to_le32(schedulertime % 604800);
 444
 445         memcpy(param->data, &schedulertime, sizeof(u32));
 446
 447         /* Mark internal command */
 448         tw_dev->srb[request_id] = NULL;
 449
 450         /* Now post the command */
 451         twl_post_command_packet(tw_dev, request_id);
 452 } /* End twl_aen_sync_time() */
 453
 454 /* This function will assign an available request id */
 455 static void twl_get_request_id(TW_Device_Extension *tw_dev, int *request_id)
 456 {
 457         *request_id = tw_dev->free_queue[tw_dev->free_head];
 458         tw_dev->free_head = (tw_dev->free_head + 1) % TW_Q_LENGTH;
 459         tw_dev->state[*request_id] = TW_S_STARTED;
 460 } /* End twl_get_request_id() */
 461
 462 /* This function will free a request id */
 463 static void twl_free_request_id(TW_Device_Extension *tw_dev, int request_id)
 464 {
 465         tw_dev->free_queue[tw_dev->free_tail] = request_id;
 466         tw_dev->state[request_id] = TW_S_FINISHED;
 467         tw_dev->free_tail = (tw_dev->free_tail + 1) % TW_Q_LENGTH;
 468 } /* End twl_free_request_id() */
 469
 470 /* This function will complete an aen request from the isr */
 471 static int twl_aen_complete(TW_Device_Extension *tw_dev, int request_id)
 472 {
 473         TW_Command_Full *full_command_packet;
 474         TW_Command *command_packet;
 475         TW_Command_Apache_Header *header;
 476         unsigned short aen;
 477         int retval = 1;
 478
 479         header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
 480         tw_dev->posted_request_count--;
 481         aen = le16_to_cpu(header->status_block.error);
 482         full_command_packet = tw_dev->command_packet_virt[request_id];
 483         command_packet = &full_command_packet->command.oldcommand;
 484
 485         /* First check for internal completion of set param for time sync */
 486         if (TW_OP_OUT(command_packet->opcode__sgloffset) == TW_OP_SET_PARAM) {
 487                 /* Keep reading the queue in case there are more aen's */
 488                 if (twl_aen_read_queue(tw_dev, request_id))
 489                         goto out2;
 490                 else {
 491                         retval = 0;
 492                         goto out;
 493                 }
 494         }
 495
 496         switch (aen) {
 497         case TW_AEN_QUEUE_EMPTY:
 498                 /* Quit reading the queue if this is the last one */
 499                 break;
 500         case TW_AEN_SYNC_TIME_WITH_HOST:
 501                 twl_aen_sync_time(tw_dev, request_id);
 502                 retval = 0;
 503                 goto out;
 504         default:
 505                 twl_aen_queue_event(tw_dev, header);
 506
 507                 /* If there are more aen's, keep reading the queue */
 508                 if (twl_aen_read_queue(tw_dev, request_id))
 509                         goto out2;
 510                 else {
 511                         retval = 0;
 512                         goto out;
 513                 }
 514         }
 515         retval = 0;
 516 out2:
 517         tw_dev->state[request_id] = TW_S_COMPLETED;
 518         twl_free_request_id(tw_dev, request_id);
 519         clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
 520 out:
 521         return retval;
 522 } /* End twl_aen_complete() */
 523
 524 /* This function will poll for a response */
 525 static int twl_poll_response(TW_Device_Extension *tw_dev, int request_id, int seconds)
 526 {
 527         unsigned long before;
 528         dma_addr_t mfa;
 529         u32 regh, regl;
 530         u32 response;
 531         int retval = 1;
 532         int found = 0;
 533
 534         before = jiffies;
 535
 536         while (!found) {
 537                 if (sizeof(dma_addr_t) > 4) {
 538                         regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
 539                         regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
 540                         mfa = ((u64)regh << 32) | regl;
 541                 } else
 542                         mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
 543
 544                 response = (u32)mfa;
 545
 546                 if (TW_RESID_OUT(response) == request_id)
 547                         found = 1;
 548
 549                 if (time_after(jiffies, before + HZ * seconds))
 550                         goto out;
 551
 552                 msleep(50);
 553         }
 554         retval = 0;
 555 out:
 556         return retval;
 557 } /* End twl_poll_response() */
 558
 559 /* This function will drain the aen queue */
 560 static int twl_aen_drain_queue(TW_Device_Extension *tw_dev, int no_check_reset)
 561 {
 562         int request_id = 0;
 563         char cdb[TW_MAX_CDB_LEN];
 564         TW_SG_Entry_ISO sglist[1];
 565         int finished = 0, count = 0;
 566         TW_Command_Full *full_command_packet;
 567         TW_Command_Apache_Header *header;
 568         unsigned short aen;
 569         int first_reset = 0, queue = 0, retval = 1;
 570
 571         if (no_check_reset)
 572                 first_reset = 0;
 573         else
 574                 first_reset = 1;
 575
 576         full_command_packet = tw_dev->command_packet_virt[request_id];
 577         memset(full_command_packet, 0, sizeof(TW_Command_Full));
 578
 579         /* Initialize cdb */
 580         memset(&cdb, 0, TW_MAX_CDB_LEN);
 581         cdb[0] = REQUEST_SENSE; /* opcode */
 582         cdb[4] = TW_ALLOCATION_LENGTH; /* allocation length */
 583
 584         /* Initialize sglist */
 585         memset(&sglist, 0, sizeof(TW_SG_Entry_ISO));
 586         sglist[0].length = TW_SECTOR_SIZE;
 587         sglist[0].address = tw_dev->generic_buffer_phys[request_id];
 588
 589         /* Mark internal command */
 590         tw_dev->srb[request_id] = NULL;
 591
 592         do {
 593                 /* Send command to the board */
 594                 if (twl_scsiop_execute_scsi(tw_dev, request_id, cdb, 1, sglist)) {
 595                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x3, "Error posting request sense");
 596                         goto out;
 597                 }
 598
 599                 /* Now poll for completion */
 600                 if (twl_poll_response(tw_dev, request_id, 30)) {
 601                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x4, "No valid response while draining AEN queue");
 602                         tw_dev->posted_request_count--;
 603                         goto out;
 604                 }
 605
 606                 tw_dev->posted_request_count--;
 607                 header = (TW_Command_Apache_Header *)tw_dev->generic_buffer_virt[request_id];
 608                 aen = le16_to_cpu(header->status_block.error);
 609                 queue = 0;
 610                 count++;
 611
 612                 switch (aen) {
 613                 case TW_AEN_QUEUE_EMPTY:
 614                         if (first_reset != 1)
 615                                 goto out;
 616                         else
 617                                 finished = 1;
 618                         break;
 619                 case TW_AEN_SOFT_RESET:
 620                         if (first_reset == 0)
 621                                 first_reset = 1;
 622                         else
 623                                 queue = 1;
 624                         break;
 625                 case TW_AEN_SYNC_TIME_WITH_HOST:
 626                         break;
 627                 default:
 628                         queue = 1;
 629                 }
 630
 631                 /* Now queue an event info */
 632                 if (queue)
 633                         twl_aen_queue_event(tw_dev, header);
 634         } while ((finished == 0) && (count < TW_MAX_AEN_DRAIN));
 635
 636         if (count == TW_MAX_AEN_DRAIN)
 637                 goto out;
 638
 639         retval = 0;
 640 out:
 641         tw_dev->state[request_id] = TW_S_INITIAL;
 642         return retval;
 643 } /* End twl_aen_drain_queue() */
 644
 645 /* This function will allocate memory and check if it is correctly aligned */
 646 static int twl_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
 647 {
 648         int i;
 649         dma_addr_t dma_handle;
 650         unsigned long *cpu_addr;
 651         int retval = 1;
 652
 653         cpu_addr = pci_zalloc_consistent(tw_dev->tw_pci_dev, size * TW_Q_LENGTH,
 654                                          &dma_handle);
 655         if (!cpu_addr) {
 656                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
 657                 goto out;
 658         }
 659
 660         for (i = 0; i < TW_Q_LENGTH; i++) {
 661                 switch(which) {
 662                 case 0:
 663                         tw_dev->command_packet_phys[i] = dma_handle+(i*size);
 664                         tw_dev->command_packet_virt[i] = (TW_Command_Full *)((unsigned char *)cpu_addr + (i*size));
 665                         break;
 666                 case 1:
 667                         tw_dev->generic_buffer_phys[i] = dma_handle+(i*size);
 668                         tw_dev->generic_buffer_virt[i] = (unsigned long *)((unsigned char *)cpu_addr + (i*size));
 669                         break;
 670                 case 2:
 671                         tw_dev->sense_buffer_phys[i] = dma_handle+(i*size);
 672                         tw_dev->sense_buffer_virt[i] = (TW_Command_Apache_Header *)((unsigned char *)cpu_addr + (i*size));
 673                         break;
 674                 }
 675         }
 676         retval = 0;
 677 out:
 678         return retval;
 679 } /* End twl_allocate_memory() */
 680
 681 /* This function will load the request id and various sgls for ioctls */
 682 static void twl_load_sgl(TW_Device_Extension *tw_dev, TW_Command_Full *full_command_packet, int request_id, dma_addr_t dma_handle, int length)
 683 {
 684         TW_Command *oldcommand;
 685         TW_Command_Apache *newcommand;
 686         TW_SG_Entry_ISO *sgl;
 687         unsigned int pae = 0;
 688
 689         if ((sizeof(long) < 8) && (sizeof(dma_addr_t) > 4))
 690                 pae = 1;
 691
 692         if (TW_OP_OUT(full_command_packet->command.newcommand.opcode__reserved) == TW_OP_EXECUTE_SCSI) {
 693                 newcommand = &full_command_packet->command.newcommand;
 694                 newcommand->request_id__lunl =
 695                         cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->request_id__lunl), request_id));
 696                 if (length) {
 697                         newcommand->sg_list[0].address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
 698                         newcommand->sg_list[0].length = TW_CPU_TO_SGL(length);
 699                 }
 700                 newcommand->sgl_entries__lunh =
 701                         cpu_to_le16(TW_REQ_LUN_IN(TW_LUN_OUT(newcommand->sgl_entries__lunh), length ? 1 : 0));
 702         } else {
 703                 oldcommand = &full_command_packet->command.oldcommand;
 704                 oldcommand->request_id = request_id;
 705
 706                 if (TW_SGL_OUT(oldcommand->opcode__sgloffset)) {
 707                         /* Load the sg list */
 708                         sgl = (TW_SG_Entry_ISO *)((u32 *)oldcommand+oldcommand->size - (sizeof(TW_SG_Entry_ISO)/4) + pae + (sizeof(dma_addr_t) > 4 ? 1 : 0));
 709                         sgl->address = TW_CPU_TO_SGL(dma_handle + sizeof(TW_Ioctl_Buf_Apache) - 1);
 710                         sgl->length = TW_CPU_TO_SGL(length);
 711                         oldcommand->size += pae;
 712                         oldcommand->size += sizeof(dma_addr_t) > 4 ? 1 : 0;
 713                 }
 714         }
 715 } /* End twl_load_sgl() */
 716
 717 /* This function handles ioctl for the character device
 718    This interface is used by smartmontools open source software */
 719 static long twl_chrdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 720 {
 721         long timeout;
 722         unsigned long *cpu_addr, data_buffer_length_adjusted = 0, flags = 0;
 723         dma_addr_t dma_handle;
 724         int request_id = 0;
 725         TW_Ioctl_Driver_Command driver_command;
 726         struct inode *inode = file_inode(file);
 727         TW_Ioctl_Buf_Apache *tw_ioctl;
 728         TW_Command_Full *full_command_packet;
 729         TW_Device_Extension *tw_dev = twl_device_extension_list[iminor(inode)];
 730         int retval = -EFAULT;
 731         void __user *argp = (void __user *)arg;
 732
 733         mutex_lock(&twl_chrdev_mutex);
 734
 735         /* Only let one of these through at a time */
 736         if (mutex_lock_interruptible(&tw_dev->ioctl_lock)) {
 737                 retval = -EINTR;
 738                 goto out;
 739         }
 740
 741         /* First copy down the driver command */
 742         if (copy_from_user(&driver_command, argp, sizeof(TW_Ioctl_Driver_Command)))
 743                 goto out2;
 744
 745         /* Check data buffer size */
 746         if (driver_command.buffer_length > TW_MAX_SECTORS * 2048) {
 747                 retval = -EINVAL;
 748                 goto out2;
 749         }
 750
 751         /* Hardware can only do multiple of 512 byte transfers */
 752         data_buffer_length_adjusted = (driver_command.buffer_length + 511) & ~511;
 753
 754         /* Now allocate ioctl buf memory */
 755         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);
 756         if (!cpu_addr) {
 757                 retval = -ENOMEM;
 758                 goto out2;
 759         }
 760
 761         tw_ioctl = (TW_Ioctl_Buf_Apache *)cpu_addr;
 762
 763         /* Now copy down the entire ioctl */
 764         if (copy_from_user(tw_ioctl, argp, driver_command.buffer_length + sizeof(TW_Ioctl_Buf_Apache) - 1))
 765                 goto out3;
 766
 767         /* See which ioctl we are doing */
 768         switch (cmd) {
 769         case TW_IOCTL_FIRMWARE_PASS_THROUGH:
 770                 spin_lock_irqsave(tw_dev->host->host_lock, flags);
 771                 twl_get_request_id(tw_dev, &request_id);
 772
 773                 /* Flag internal command */
 774                 tw_dev->srb[request_id] = NULL;
 775
 776                 /* Flag chrdev ioctl */
 777                 tw_dev->chrdev_request_id = request_id;
 778
 779                 full_command_packet = (TW_Command_Full *)&tw_ioctl->firmware_command;
 780
 781                 /* Load request id and sglist for both command types */
 782                 twl_load_sgl(tw_dev, full_command_packet, request_id, dma_handle, data_buffer_length_adjusted);
 783
 784                 memcpy(tw_dev->command_packet_virt[request_id], &(tw_ioctl->firmware_command), sizeof(TW_Command_Full));
 785
 786                 /* Now post the command packet to the controller */
 787                 twl_post_command_packet(tw_dev, request_id);
 788                 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 789
 790                 timeout = TW_IOCTL_CHRDEV_TIMEOUT*HZ;
 791
 792                 /* Now wait for command to complete */
 793                 timeout = wait_event_timeout(tw_dev->ioctl_wqueue, tw_dev->chrdev_request_id == TW_IOCTL_CHRDEV_FREE, timeout);
 794
 795                 /* We timed out, and didn't get an interrupt */
 796                 if (tw_dev->chrdev_request_id != TW_IOCTL_CHRDEV_FREE) {
 797                         /* Now we need to reset the board */
 798                         printk(KERN_WARNING "3w-sas: scsi%d: WARNING: (0x%02X:0x%04X): Character ioctl (0x%x) timed out, resetting card.\n",
 799                                tw_dev->host->host_no, TW_DRIVER, 0x6,
 800                                cmd);
 801                         retval = -EIO;
 802                         twl_reset_device_extension(tw_dev, 1);
 803                         goto out3;
 804                 }
 805
 806                 /* Now copy in the command packet response */
 807                 memcpy(&(tw_ioctl->firmware_command), tw_dev->command_packet_virt[request_id], sizeof(TW_Command_Full));
 808
 809                 /* Now complete the io */
 810                 spin_lock_irqsave(tw_dev->host->host_lock, flags);
 811                 tw_dev->posted_request_count--;
 812                 tw_dev->state[request_id] = TW_S_COMPLETED;
 813                 twl_free_request_id(tw_dev, request_id);
 814                 spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
 815                 break;
 816         default:
 817                 retval = -ENOTTY;
 818                 goto out3;
 819         }
 820
 821         /* Now copy the entire response to userspace */
 822         if (copy_to_user(argp, tw_ioctl, sizeof(TW_Ioctl_Buf_Apache) + driver_command.buffer_length - 1) == 0)
 823                 retval = 0;
 824 out3:
 825         /* Now free ioctl buf memory */
 826         dma_free_coherent(&tw_dev->tw_pci_dev->dev, data_buffer_length_adjusted+sizeof(TW_Ioctl_Buf_Apache) - 1, cpu_addr, dma_handle);
 827 out2:
 828         mutex_unlock(&tw_dev->ioctl_lock);
 829 out:
 830         mutex_unlock(&twl_chrdev_mutex);
 831         return retval;
 832 } /* End twl_chrdev_ioctl() */
 833
 834 /* This function handles open for the character device */
 835 static int twl_chrdev_open(struct inode *inode, struct file *file)
 836 {
 837         unsigned int minor_number;
 838         int retval = -ENODEV;
 839
 840         if (!capable(CAP_SYS_ADMIN)) {
 841                 retval = -EACCES;
 842                 goto out;
 843         }
 844
 845         minor_number = iminor(inode);
 846         if (minor_number >= twl_device_extension_count)
 847                 goto out;
 848         retval = 0;
 849 out:
 850         return retval;
 851 } /* End twl_chrdev_open() */
 852
 853 /* File operations struct for character device */
 854 static const struct file_operations twl_fops = {
 855         .owner          = THIS_MODULE,
 856         .unlocked_ioctl = twl_chrdev_ioctl,
 857         .open           = twl_chrdev_open,
 858         .release        = NULL,
 859         .llseek         = noop_llseek,
 860 };
 861
 862 /* This function passes sense data from firmware to scsi layer */
 863 static int twl_fill_sense(TW_Device_Extension *tw_dev, int i, int request_id, int copy_sense, int print_host)
 864 {
 865         TW_Command_Apache_Header *header;
 866         TW_Command_Full *full_command_packet;
 867         unsigned short error;
 868         char *error_str;
 869         int retval = 1;
 870
 871         header = tw_dev->sense_buffer_virt[i];
 872         full_command_packet = tw_dev->command_packet_virt[request_id];
 873
 874         /* Get embedded firmware error string */
 875         error_str = &(header->err_specific_desc[strlen(header->err_specific_desc) + 1]);
 876
 877         /* Don't print error for Logical unit not supported during rollcall */
 878         error = le16_to_cpu(header->status_block.error);
 879         if ((error != TW_ERROR_LOGICAL_UNIT_NOT_SUPPORTED) && (error != TW_ERROR_UNIT_OFFLINE) && (error != TW_ERROR_INVALID_FIELD_IN_CDB)) {
 880                 if (print_host)
 881                         printk(KERN_WARNING "3w-sas: scsi%d: ERROR: (0x%02X:0x%04X): %s:%s.\n",
 882                                tw_dev->host->host_no,
 883                                TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
 884                                header->status_block.error,
 885                                error_str,
 886                                header->err_specific_desc);
 887                 else
 888                         printk(KERN_WARNING "3w-sas: ERROR: (0x%02X:0x%04X): %s:%s.\n",
 889                                TW_MESSAGE_SOURCE_CONTROLLER_ERROR,
 890                                header->status_block.error,
 891                                error_str,
 892                                header->err_specific_desc);
 893         }
 894
 895         if (copy_sense) {
 896                 memcpy(tw_dev->srb[request_id]->sense_buffer, header->sense_data, TW_SENSE_DATA_LENGTH);
 897                 tw_dev->srb[request_id]->result = (full_command_packet->command.newcommand.status << 1);
 898                 goto out;
 899         }
 900 out:
 901         return retval;
 902 } /* End twl_fill_sense() */
 903
 904 /* This function will free up device extension resources */
 905 static void twl_free_device_extension(TW_Device_Extension *tw_dev)
 906 {
 907         if (tw_dev->command_packet_virt[0])
 908                 pci_free_consistent(tw_dev->tw_pci_dev,
 909                                     sizeof(TW_Command_Full)*TW_Q_LENGTH,
 910                                     tw_dev->command_packet_virt[0],
 911                                     tw_dev->command_packet_phys[0]);
 912
 913         if (tw_dev->generic_buffer_virt[0])
 914                 pci_free_consistent(tw_dev->tw_pci_dev,
 915                                     TW_SECTOR_SIZE*TW_Q_LENGTH,
 916                                     tw_dev->generic_buffer_virt[0],
 917                                     tw_dev->generic_buffer_phys[0]);
 918
 919         if (tw_dev->sense_buffer_virt[0])
 920                 pci_free_consistent(tw_dev->tw_pci_dev,
 921                                     sizeof(TW_Command_Apache_Header)*
 922                                     TW_Q_LENGTH,
 923                                     tw_dev->sense_buffer_virt[0],
 924                                     tw_dev->sense_buffer_phys[0]);
 925
 926         kfree(tw_dev->event_queue[0]);
 927 } /* End twl_free_device_extension() */
 928
 929 /* This function will get parameter table entries from the firmware */
 930 static void *twl_get_param(TW_Device_Extension *tw_dev, int request_id, int table_id, int parameter_id, int parameter_size_bytes)
 931 {
 932         TW_Command_Full *full_command_packet;
 933         TW_Command *command_packet;
 934         TW_Param_Apache *param;
 935         void *retval = NULL;
 936
 937         /* Setup the command packet */
 938         full_command_packet = tw_dev->command_packet_virt[request_id];
 939         memset(full_command_packet, 0, sizeof(TW_Command_Full));
 940         command_packet = &full_command_packet->command.oldcommand;
 941
 942         command_packet->opcode__sgloffset = TW_OPSGL_IN(2, TW_OP_GET_PARAM);
 943         command_packet->size              = TW_COMMAND_SIZE;
 944         command_packet->request_id        = request_id;
 945         command_packet->byte6_offset.block_count = cpu_to_le16(1);
 946
 947         /* Now setup the param */
 948         param = (TW_Param_Apache *)tw_dev->generic_buffer_virt[request_id];
 949         memset(param, 0, TW_SECTOR_SIZE);
 950         param->table_id = cpu_to_le16(table_id | 0x8000);
 951         param->parameter_id = cpu_to_le16(parameter_id);
 952         param->parameter_size_bytes = cpu_to_le16(parameter_size_bytes);
 953
 954         command_packet->byte8_offset.param.sgl[0].address = TW_CPU_TO_SGL(tw_dev->generic_buffer_phys[request_id]);
 955         command_packet->byte8_offset.param.sgl[0].length = TW_CPU_TO_SGL(TW_SECTOR_SIZE);
 956
 957         /* Post the command packet to the board */
 958         twl_post_command_packet(tw_dev, request_id);
 959
 960         /* Poll for completion */
 961         if (twl_poll_response(tw_dev, request_id, 30))
 962                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x7, "No valid response during get param")
 963         else
 964                 retval = (void *)&(param->data[0]);
 965
 966         tw_dev->posted_request_count--;
 967         tw_dev->state[request_id] = TW_S_INITIAL;
 968
 969         return retval;
 970 } /* End twl_get_param() */
 971
 972 /* This function will send an initconnection command to controller */
 973 static int twl_initconnection(TW_Device_Extension *tw_dev, int message_credits,
 974                               u32 set_features, unsigned short current_fw_srl,
 975                               unsigned short current_fw_arch_id,
 976                               unsigned short current_fw_branch,
 977                               unsigned short current_fw_build,
 978                               unsigned short *fw_on_ctlr_srl,
 979                               unsigned short *fw_on_ctlr_arch_id,
 980                               unsigned short *fw_on_ctlr_branch,
 981                               unsigned short *fw_on_ctlr_build,
 982                               u32 *init_connect_result)
 983 {
 984         TW_Command_Full *full_command_packet;
 985         TW_Initconnect *tw_initconnect;
 986         int request_id = 0, retval = 1;
 987
 988         /* Initialize InitConnection command packet */
 989         full_command_packet = tw_dev->command_packet_virt[request_id];
 990         memset(full_command_packet, 0, sizeof(TW_Command_Full));
 991         full_command_packet->header.header_desc.size_header = 128;
 992
 993         tw_initconnect = (TW_Initconnect *)&full_command_packet->command.oldcommand;
 994         tw_initconnect->opcode__reserved = TW_OPRES_IN(0, TW_OP_INIT_CONNECTION);
 995         tw_initconnect->request_id = request_id;
 996         tw_initconnect->message_credits = cpu_to_le16(message_credits);
 997         tw_initconnect->features = set_features;
 998
 999         /* Turn on 64-bit sgl support if we need to */
1000         tw_initconnect->features |= sizeof(dma_addr_t) > 4 ? 1 : 0;
1001
1002         tw_initconnect->features = cpu_to_le32(tw_initconnect->features);
1003
1004         if (set_features & TW_EXTENDED_INIT_CONNECT) {
1005                 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE_EXTENDED;
1006                 tw_initconnect->fw_srl = cpu_to_le16(current_fw_srl);
1007                 tw_initconnect->fw_arch_id = cpu_to_le16(current_fw_arch_id);
1008                 tw_initconnect->fw_branch = cpu_to_le16(current_fw_branch);
1009                 tw_initconnect->fw_build = cpu_to_le16(current_fw_build);
1010         } else
1011                 tw_initconnect->size = TW_INIT_COMMAND_PACKET_SIZE;
1012
1013         /* Send command packet to the board */
1014         twl_post_command_packet(tw_dev, request_id);
1015
1016         /* Poll for completion */
1017         if (twl_poll_response(tw_dev, request_id, 30)) {
1018                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x8, "No valid response during init connection");
1019         } else {
1020                 if (set_features & TW_EXTENDED_INIT_CONNECT) {
1021                         *fw_on_ctlr_srl = le16_to_cpu(tw_initconnect->fw_srl);
1022                         *fw_on_ctlr_arch_id = le16_to_cpu(tw_initconnect->fw_arch_id);
1023                         *fw_on_ctlr_branch = le16_to_cpu(tw_initconnect->fw_branch);
1024                         *fw_on_ctlr_build = le16_to_cpu(tw_initconnect->fw_build);
1025                         *init_connect_result = le32_to_cpu(tw_initconnect->result);
1026                 }
1027                 retval = 0;
1028         }
1029
1030         tw_dev->posted_request_count--;
1031         tw_dev->state[request_id] = TW_S_INITIAL;
1032
1033         return retval;
1034 } /* End twl_initconnection() */
1035
1036 /* This function will initialize the fields of a device extension */
1037 static int twl_initialize_device_extension(TW_Device_Extension *tw_dev)
1038 {
1039         int i, retval = 1;
1040
1041         /* Initialize command packet buffers */
1042         if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Full), 0)) {
1043                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x9, "Command packet memory allocation failed");
1044                 goto out;
1045         }
1046
1047         /* Initialize generic buffer */
1048         if (twl_allocate_memory(tw_dev, TW_SECTOR_SIZE, 1)) {
1049                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xa, "Generic memory allocation failed");
1050                 goto out;
1051         }
1052
1053         /* Allocate sense buffers */
1054         if (twl_allocate_memory(tw_dev, sizeof(TW_Command_Apache_Header), 2)) {
1055                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xb, "Sense buffer allocation failed");
1056                 goto out;
1057         }
1058
1059         /* Allocate event info space */
1060         tw_dev->event_queue[0] = kcalloc(TW_Q_LENGTH, sizeof(TW_Event), GFP_KERNEL);
1061         if (!tw_dev->event_queue[0]) {
1062                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xc, "Event info memory allocation failed");
1063                 goto out;
1064         }
1065
1066         for (i = 0; i < TW_Q_LENGTH; i++) {
1067                 tw_dev->event_queue[i] = (TW_Event *)((unsigned char *)tw_dev->event_queue[0] + (i * sizeof(TW_Event)));
1068                 tw_dev->free_queue[i] = i;
1069                 tw_dev->state[i] = TW_S_INITIAL;
1070         }
1071
1072         tw_dev->free_head = TW_Q_START;
1073         tw_dev->free_tail = TW_Q_START;
1074         tw_dev->error_sequence_id = 1;
1075         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1076
1077         mutex_init(&tw_dev->ioctl_lock);
1078         init_waitqueue_head(&tw_dev->ioctl_wqueue);
1079
1080         retval = 0;
1081 out:
1082         return retval;
1083 } /* End twl_initialize_device_extension() */
1084
1085 /* This function will handle attention interrupts */
1086 static int twl_handle_attention_interrupt(TW_Device_Extension *tw_dev)
1087 {
1088         int retval = 1;
1089         u32 request_id, doorbell;
1090
1091         /* Read doorbell status */
1092         doorbell = readl(TWL_HOBDB_REG_ADDR(tw_dev));
1093
1094         /* Check for controller errors */
1095         if (doorbell & TWL_DOORBELL_CONTROLLER_ERROR) {
1096                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xd, "Microcontroller Error: clearing");
1097                 goto out;
1098         }
1099
1100         /* Check if we need to perform an AEN drain */
1101         if (doorbell & TWL_DOORBELL_ATTENTION_INTERRUPT) {
1102                 if (!(test_and_set_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags))) {
1103                         twl_get_request_id(tw_dev, &request_id);
1104                         if (twl_aen_read_queue(tw_dev, request_id)) {
1105                                 tw_dev->state[request_id] = TW_S_COMPLETED;
1106                                 twl_free_request_id(tw_dev, request_id);
1107                                 clear_bit(TW_IN_ATTENTION_LOOP, &tw_dev->flags);
1108                         }
1109                 }
1110         }
1111
1112         retval = 0;
1113 out:
1114         /* Clear doorbell interrupt */
1115         TWL_CLEAR_DB_INTERRUPT(tw_dev);
1116
1117         /* Make sure the clear was flushed by reading it back */
1118         readl(TWL_HOBDBC_REG_ADDR(tw_dev));
1119
1120         return retval;
1121 } /* End twl_handle_attention_interrupt() */
1122
1123 /* Interrupt service routine */
1124 static irqreturn_t twl_interrupt(int irq, void *dev_instance)
1125 {
1126         TW_Device_Extension *tw_dev = (TW_Device_Extension *)dev_instance;
1127         int i, handled = 0, error = 0;
1128         dma_addr_t mfa = 0;
1129         u32 reg, regl, regh, response, request_id = 0;
1130         struct scsi_cmnd *cmd;
1131         TW_Command_Full *full_command_packet;
1132
1133         spin_lock(tw_dev->host->host_lock);
1134
1135         /* Read host interrupt status */
1136         reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
1137
1138         /* Check if this is our interrupt, otherwise bail */
1139         if (!(reg & TWL_HISTATUS_VALID_INTERRUPT))
1140                 goto twl_interrupt_bail;
1141
1142         handled = 1;
1143
1144         /* If we are resetting, bail */
1145         if (test_bit(TW_IN_RESET, &tw_dev->flags))
1146                 goto twl_interrupt_bail;
1147
1148         /* Attention interrupt */
1149         if (reg & TWL_HISTATUS_ATTENTION_INTERRUPT) {
1150                 if (twl_handle_attention_interrupt(tw_dev)) {
1151                         TWL_MASK_INTERRUPTS(tw_dev);
1152                         goto twl_interrupt_bail;
1153                 }
1154         }
1155
1156         /* Response interrupt */
1157         while (reg & TWL_HISTATUS_RESPONSE_INTERRUPT) {
1158                 if (sizeof(dma_addr_t) > 4) {
1159                         regh = readl(TWL_HOBQPH_REG_ADDR(tw_dev));
1160                         regl = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
1161                         mfa = ((u64)regh << 32) | regl;
1162                 } else
1163                         mfa = readl(TWL_HOBQPL_REG_ADDR(tw_dev));
1164
1165                 error = 0;
1166                 response = (u32)mfa;
1167
1168                 /* Check for command packet error */
1169                 if (!TW_NOTMFA_OUT(response)) {
1170                         for (i=0;i<TW_Q_LENGTH;i++) {
1171                                 if (tw_dev->sense_buffer_phys[i] == mfa) {
1172                                         request_id = le16_to_cpu(tw_dev->sense_buffer_virt[i]->header_desc.request_id);
1173                                         if (tw_dev->srb[request_id] != NULL)
1174                                                 error = twl_fill_sense(tw_dev, i, request_id, 1, 1);
1175                                         else {
1176                                                 /* Skip ioctl error prints */
1177                                                 if (request_id != tw_dev->chrdev_request_id)
1178                                                         error = twl_fill_sense(tw_dev, i, request_id, 0, 1);
1179                                                 else
1180                                                         memcpy(tw_dev->command_packet_virt[request_id], tw_dev->sense_buffer_virt[i], sizeof(TW_Command_Apache_Header));
1181                                         }
1182
1183                                         /* Now re-post the sense buffer */
1184                                         writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
1185                                         writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
1186                                         break;
1187                                 }
1188                         }
1189                 } else
1190                         request_id = TW_RESID_OUT(response);
1191
1192                 full_command_packet = tw_dev->command_packet_virt[request_id];
1193
1194                 /* Check for correct state */
1195                 if (tw_dev->state[request_id] != TW_S_POSTED) {
1196                         if (tw_dev->srb[request_id] != NULL) {
1197                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0xe, "Received a request id that wasn't posted");
1198                                 TWL_MASK_INTERRUPTS(tw_dev);
1199                                 goto twl_interrupt_bail;
1200                         }
1201                 }
1202
1203                 /* Check for internal command completion */
1204                 if (tw_dev->srb[request_id] == NULL) {
1205                         if (request_id != tw_dev->chrdev_request_id) {
1206                                 if (twl_aen_complete(tw_dev, request_id))
1207                                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0xf, "Error completing AEN during attention interrupt");
1208                         } else {
1209                                 tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1210                                 wake_up(&tw_dev->ioctl_wqueue);
1211                         }
1212                 } else {
1213                         cmd = tw_dev->srb[request_id];
1214
1215                         if (!error)
1216                                 cmd->result = (DID_OK << 16);
1217
1218                         /* Report residual bytes for single sgl */
1219                         if ((scsi_sg_count(cmd) <= 1) && (full_command_packet->command.newcommand.status == 0)) {
1220                                 if (full_command_packet->command.newcommand.sg_list[0].length < scsi_bufflen(tw_dev->srb[request_id]))
1221                                         scsi_set_resid(cmd, scsi_bufflen(cmd) - full_command_packet->command.newcommand.sg_list[0].length);
1222                         }
1223
1224                         /* Now complete the io */
1225                         scsi_dma_unmap(cmd);
1226                         cmd->scsi_done(cmd);
1227                         tw_dev->state[request_id] = TW_S_COMPLETED;
1228                         twl_free_request_id(tw_dev, request_id);
1229                         tw_dev->posted_request_count--;
1230                 }
1231
1232                 /* Check for another response interrupt */
1233                 reg = readl(TWL_HISTAT_REG_ADDR(tw_dev));
1234         }
1235
1236 twl_interrupt_bail:
1237         spin_unlock(tw_dev->host->host_lock);
1238         return IRQ_RETVAL(handled);
1239 } /* End twl_interrupt() */
1240
1241 /* This function will poll for a register change */
1242 static int twl_poll_register(TW_Device_Extension *tw_dev, void *reg, u32 value, u32 result, int seconds)
1243 {
1244         unsigned long before;
1245         int retval = 1;
1246         u32 reg_value;
1247
1248         reg_value = readl(reg);
1249         before = jiffies;
1250
1251         while ((reg_value & value) != result) {
1252                 reg_value = readl(reg);
1253                 if (time_after(jiffies, before + HZ * seconds))
1254                         goto out;
1255                 msleep(50);
1256         }
1257         retval = 0;
1258 out:
1259         return retval;
1260 } /* End twl_poll_register() */
1261
1262 /* This function will reset a controller */
1263 static int twl_reset_sequence(TW_Device_Extension *tw_dev, int soft_reset)
1264 {
1265         int retval = 1;
1266         int i = 0;
1267         u32 status = 0;
1268         unsigned short fw_on_ctlr_srl = 0, fw_on_ctlr_arch_id = 0;
1269         unsigned short fw_on_ctlr_branch = 0, fw_on_ctlr_build = 0;
1270         u32 init_connect_result = 0;
1271         int tries = 0;
1272         int do_soft_reset = soft_reset;
1273
1274         while (tries < TW_MAX_RESET_TRIES) {
1275                 /* Do a soft reset if one is needed */
1276                 if (do_soft_reset) {
1277                         TWL_SOFT_RESET(tw_dev);
1278
1279                         /* Make sure controller is in a good state */
1280                         if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, 0x0, 30)) {
1281                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x10, "Controller never went non-ready during reset sequence");
1282                                 tries++;
1283                                 continue;
1284                         }
1285                         if (twl_poll_register(tw_dev, TWL_SCRPD3_REG_ADDR(tw_dev), TWL_CONTROLLER_READY, TWL_CONTROLLER_READY, 60)) {
1286                                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x11, "Controller not ready during reset sequence");
1287                                 tries++;
1288                                 continue;
1289                         }
1290                 }
1291
1292                 /* Initconnect */
1293                 if (twl_initconnection(tw_dev, TW_INIT_MESSAGE_CREDITS,
1294                                        TW_EXTENDED_INIT_CONNECT, TW_CURRENT_DRIVER_SRL,
1295                                        TW_9750_ARCH_ID, TW_CURRENT_DRIVER_BRANCH,
1296                                        TW_CURRENT_DRIVER_BUILD, &fw_on_ctlr_srl,
1297                                        &fw_on_ctlr_arch_id, &fw_on_ctlr_branch,
1298                                        &fw_on_ctlr_build, &init_connect_result)) {
1299                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x12, "Initconnection failed while checking SRL");
1300                         do_soft_reset = 1;
1301                         tries++;
1302                         continue;
1303                 }
1304
1305                 /* Load sense buffers */
1306                 while (i < TW_Q_LENGTH) {
1307                         writel((u32)((u64)tw_dev->sense_buffer_phys[i] >> 32), TWL_HOBQPH_REG_ADDR(tw_dev));
1308                         writel((u32)tw_dev->sense_buffer_phys[i], TWL_HOBQPL_REG_ADDR(tw_dev));
1309
1310                         /* Check status for over-run after each write */
1311                         status = readl(TWL_STATUS_REG_ADDR(tw_dev));
1312                         if (!(status & TWL_STATUS_OVERRUN_SUBMIT))
1313                             i++;
1314                 }
1315
1316                 /* Now check status */
1317                 status = readl(TWL_STATUS_REG_ADDR(tw_dev));
1318                 if (status) {
1319                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x13, "Bad controller status after loading sense buffers");
1320                         do_soft_reset = 1;
1321                         tries++;
1322                         continue;
1323                 }
1324
1325                 /* Drain the AEN queue */
1326                 if (twl_aen_drain_queue(tw_dev, soft_reset)) {
1327                         TW_PRINTK(tw_dev->host, TW_DRIVER, 0x14, "AEN drain failed during reset sequence");
1328                         do_soft_reset = 1;
1329                         tries++;
1330                         continue;
1331                 }
1332
1333                 /* Load rest of compatibility struct */
1334                 strncpy(tw_dev->tw_compat_info.driver_version, TW_DRIVER_VERSION, strlen(TW_DRIVER_VERSION));
1335                 tw_dev->tw_compat_info.driver_srl_high = TW_CURRENT_DRIVER_SRL;
1336                 tw_dev->tw_compat_info.driver_branch_high = TW_CURRENT_DRIVER_BRANCH;
1337                 tw_dev->tw_compat_info.driver_build_high = TW_CURRENT_DRIVER_BUILD;
1338                 tw_dev->tw_compat_info.driver_srl_low = TW_BASE_FW_SRL;
1339                 tw_dev->tw_compat_info.driver_branch_low = TW_BASE_FW_BRANCH;
1340                 tw_dev->tw_compat_info.driver_build_low = TW_BASE_FW_BUILD;
1341                 tw_dev->tw_compat_info.fw_on_ctlr_srl = fw_on_ctlr_srl;
1342                 tw_dev->tw_compat_info.fw_on_ctlr_branch = fw_on_ctlr_branch;
1343                 tw_dev->tw_compat_info.fw_on_ctlr_build = fw_on_ctlr_build;
1344
1345                 /* If we got here, controller is in a good state */
1346                 retval = 0;
1347                 goto out;
1348         }
1349 out:
1350         return retval;
1351 } /* End twl_reset_sequence() */
1352
1353 /* This function will reset a device extension */
1354 static int twl_reset_device_extension(TW_Device_Extension *tw_dev, int ioctl_reset)
1355 {
1356         int i = 0, retval = 1;
1357         unsigned long flags = 0;
1358
1359         /* Block SCSI requests while we are resetting */
1360         if (ioctl_reset)
1361                 scsi_block_requests(tw_dev->host);
1362
1363         set_bit(TW_IN_RESET, &tw_dev->flags);
1364         TWL_MASK_INTERRUPTS(tw_dev);
1365         TWL_CLEAR_DB_INTERRUPT(tw_dev);
1366
1367         spin_lock_irqsave(tw_dev->host->host_lock, flags);
1368
1369         /* Abort all requests that are in progress */
1370         for (i = 0; i < TW_Q_LENGTH; i++) {
1371                 if ((tw_dev->state[i] != TW_S_FINISHED) &&
1372                     (tw_dev->state[i] != TW_S_INITIAL) &&
1373                     (tw_dev->state[i] != TW_S_COMPLETED)) {
1374                         struct scsi_cmnd *cmd = tw_dev->srb[i];
1375
1376                         if (cmd) {
1377                                 cmd->result = (DID_RESET << 16);
1378                                 scsi_dma_unmap(cmd);
1379                                 cmd->scsi_done(cmd);
1380                         }
1381                 }
1382         }
1383
1384         /* Reset queues and counts */
1385         for (i = 0; i < TW_Q_LENGTH; i++) {
1386                 tw_dev->free_queue[i] = i;
1387                 tw_dev->state[i] = TW_S_INITIAL;
1388         }
1389         tw_dev->free_head = TW_Q_START;
1390         tw_dev->free_tail = TW_Q_START;
1391         tw_dev->posted_request_count = 0;
1392
1393         spin_unlock_irqrestore(tw_dev->host->host_lock, flags);
1394
1395         if (twl_reset_sequence(tw_dev, 1))
1396                 goto out;
1397
1398         TWL_UNMASK_INTERRUPTS(tw_dev);
1399
1400         clear_bit(TW_IN_RESET, &tw_dev->flags);
1401         tw_dev->chrdev_request_id = TW_IOCTL_CHRDEV_FREE;
1402
1403         retval = 0;
1404 out:
1405         if (ioctl_reset)
1406                 scsi_unblock_requests(tw_dev->host);
1407         return retval;
1408 } /* End twl_reset_device_extension() */
1409
1410 /* This funciton returns unit geometry in cylinders/heads/sectors */
1411 static int twl_scsi_biosparam(struct scsi_device *sdev, struct block_device *bdev, sector_t capacity, int geom[])
1412 {
1413         int heads, sectors;
1414         TW_Device_Extension *tw_dev;
1415
1416         tw_dev = (TW_Device_Extension *)sdev->host->hostdata;
1417
1418         if (capacity >= 0x200000) {
1419                 heads = 255;
1420                 sectors = 63;
1421         } else {
1422                 heads = 64;
1423                 sectors = 32;
1424         }
1425
1426         geom[0] = heads;
1427         geom[1] = sectors;
1428         geom[2] = sector_div(capacity, heads * sectors); /* cylinders */
1429
1430         return 0;
1431 } /* End twl_scsi_biosparam() */
1432
1433 /* This is the new scsi eh reset function */
1434 static int twl_scsi_eh_reset(struct scsi_cmnd *SCpnt)
1435 {
1436         TW_Device_Extension *tw_dev = NULL;
1437         int retval = FAILED;
1438
1439         tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1440
1441         tw_dev->num_resets++;
1442
1443         sdev_printk(KERN_WARNING, SCpnt->device,
1444                 "WARNING: (0x%02X:0x%04X): Command (0x%x) timed out, resetting card.\n",
1445                 TW_DRIVER, 0x2c, SCpnt->cmnd[0]);
1446
1447         /* Make sure we are not issuing an ioctl or resetting from ioctl */
1448         mutex_lock(&tw_dev->ioctl_lock);
1449
1450         /* Now reset the card and some of the device extension data */
1451         if (twl_reset_device_extension(tw_dev, 0)) {
1452                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x15, "Controller reset failed during scsi host reset");
1453                 goto out;
1454         }
1455
1456         retval = SUCCESS;
1457 out:
1458         mutex_unlock(&tw_dev->ioctl_lock);
1459         return retval;
1460 } /* End twl_scsi_eh_reset() */
1461
1462 /* This is the main scsi queue function to handle scsi opcodes */
1463 static int twl_scsi_queue_lck(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *))
1464 {
1465         int request_id, retval;
1466         TW_Device_Extension *tw_dev = (TW_Device_Extension *)SCpnt->device->host->hostdata;
1467
1468         /* If we are resetting due to timed out ioctl, report as busy */
1469         if (test_bit(TW_IN_RESET, &tw_dev->flags)) {
1470                 retval = SCSI_MLQUEUE_HOST_BUSY;
1471                 goto out;
1472         }
1473
1474         /* Save done function into scsi_cmnd struct */
1475         SCpnt->scsi_done = done;
1476
1477         /* Get a free request id */
1478         twl_get_request_id(tw_dev, &request_id);
1479
1480         /* Save the scsi command for use by the ISR */
1481         tw_dev->srb[request_id] = SCpnt;
1482
1483         retval = twl_scsiop_execute_scsi(tw_dev, request_id, NULL, 0, NULL);
1484         if (retval) {
1485                 tw_dev->state[request_id] = TW_S_COMPLETED;
1486                 twl_free_request_id(tw_dev, request_id);
1487                 SCpnt->result = (DID_ERROR << 16);
1488                 done(SCpnt);
1489                 retval = 0;
1490         }
1491 out:
1492         return retval;
1493 } /* End twl_scsi_queue() */
1494
1495 static DEF_SCSI_QCMD(twl_scsi_queue)
1496
1497 /* This function tells the controller to shut down */
1498 static void __twl_shutdown(TW_Device_Extension *tw_dev)
1499 {
1500         /* Disable interrupts */
1501         TWL_MASK_INTERRUPTS(tw_dev);
1502
1503         /* Free up the IRQ */
1504         free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1505
1506         printk(KERN_WARNING "3w-sas: Shutting down host %d.\n", tw_dev->host->host_no);
1507
1508         /* Tell the card we are shutting down */
1509         if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1510                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x16, "Connection shutdown failed");
1511         } else {
1512                 printk(KERN_WARNING "3w-sas: Shutdown complete.\n");
1513         }
1514
1515         /* Clear doorbell interrupt just before exit */
1516         TWL_CLEAR_DB_INTERRUPT(tw_dev);
1517 } /* End __twl_shutdown() */
1518
1519 /* Wrapper for __twl_shutdown */
1520 static void twl_shutdown(struct pci_dev *pdev)
1521 {
1522         struct Scsi_Host *host = pci_get_drvdata(pdev);
1523         TW_Device_Extension *tw_dev;
1524
1525         if (!host)
1526                 return;
1527
1528         tw_dev = (TW_Device_Extension *)host->hostdata;
1529
1530         if (tw_dev->online)
1531                 __twl_shutdown(tw_dev);
1532 } /* End twl_shutdown() */
1533
1534 /* This function configures unit settings when a unit is coming on-line */
1535 static int twl_slave_configure(struct scsi_device *sdev)
1536 {
1537         /* Force 60 second timeout */
1538         blk_queue_rq_timeout(sdev->request_queue, 60 * HZ);
1539
1540         return 0;
1541 } /* End twl_slave_configure() */
1542
1543 /* scsi_host_template initializer */
1544 static struct scsi_host_template driver_template = {
1545         .module                 = THIS_MODULE,
1546         .name                   = "3w-sas",
1547         .queuecommand           = twl_scsi_queue,
1548         .eh_host_reset_handler  = twl_scsi_eh_reset,
1549         .bios_param             = twl_scsi_biosparam,
1550         .change_queue_depth     = scsi_change_queue_depth,
1551         .can_queue              = TW_Q_LENGTH-2,
1552         .slave_configure        = twl_slave_configure,
1553         .this_id                = -1,
1554         .sg_tablesize           = TW_LIBERATOR_MAX_SGL_LENGTH,
1555         .max_sectors            = TW_MAX_SECTORS,
1556         .cmd_per_lun            = TW_MAX_CMDS_PER_LUN,
1557         .use_clustering         = ENABLE_CLUSTERING,
1558         .shost_attrs            = twl_host_attrs,
1559         .emulated               = 1,
1560         .no_write_same          = 1,
1561 };
1562
1563 /* This function will probe and initialize a card */
1564 static int twl_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
1565 {
1566         struct Scsi_Host *host = NULL;
1567         TW_Device_Extension *tw_dev;
1568         int retval = -ENODEV;
1569         int *ptr_phycount, phycount=0;
1570
1571         retval = pci_enable_device(pdev);
1572         if (retval) {
1573                 TW_PRINTK(host, TW_DRIVER, 0x17, "Failed to enable pci device");
1574                 goto out_disable_device;
1575         }
1576
1577         pci_set_master(pdev);
1578         pci_try_set_mwi(pdev);
1579
1580         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
1581             || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1582                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
1583                     || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
1584                         TW_PRINTK(host, TW_DRIVER, 0x18, "Failed to set dma mask");
1585                         retval = -ENODEV;
1586                         goto out_disable_device;
1587                 }
1588
1589         host = scsi_host_alloc(&driver_template, sizeof(TW_Device_Extension));
1590         if (!host) {
1591                 TW_PRINTK(host, TW_DRIVER, 0x19, "Failed to allocate memory for device extension");
1592                 retval = -ENOMEM;
1593                 goto out_disable_device;
1594         }
1595         tw_dev = shost_priv(host);
1596
1597         /* Save values to device extension */
1598         tw_dev->host = host;
1599         tw_dev->tw_pci_dev = pdev;
1600
1601         if (twl_initialize_device_extension(tw_dev)) {
1602                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1a, "Failed to initialize device extension");
1603                 goto out_free_device_extension;
1604         }
1605
1606         /* Request IO regions */
1607         retval = pci_request_regions(pdev, "3w-sas");
1608         if (retval) {
1609                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1b, "Failed to get mem region");
1610                 goto out_free_device_extension;
1611         }
1612
1613         /* Save base address, use region 1 */
1614         tw_dev->base_addr = pci_iomap(pdev, 1, 0);
1615         if (!tw_dev->base_addr) {
1616                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1c, "Failed to ioremap");
1617                 goto out_release_mem_region;
1618         }
1619
1620         /* Disable interrupts on the card */
1621         TWL_MASK_INTERRUPTS(tw_dev);
1622
1623         /* Initialize the card */
1624         if (twl_reset_sequence(tw_dev, 0)) {
1625                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1d, "Controller reset failed during probe");
1626                 goto out_iounmap;
1627         }
1628
1629         /* Set host specific parameters */
1630         host->max_id = TW_MAX_UNITS;
1631         host->max_cmd_len = TW_MAX_CDB_LEN;
1632         host->max_lun = TW_MAX_LUNS;
1633         host->max_channel = 0;
1634
1635         /* Register the card with the kernel SCSI layer */
1636         retval = scsi_add_host(host, &pdev->dev);
1637         if (retval) {
1638                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1e, "scsi add host failed");
1639                 goto out_iounmap;
1640         }
1641
1642         pci_set_drvdata(pdev, host);
1643
1644         printk(KERN_WARNING "3w-sas: scsi%d: Found an LSI 3ware %s Controller at 0x%llx, IRQ: %d.\n",
1645                host->host_no,
1646                (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1647                                      TW_PARAM_MODEL, TW_PARAM_MODEL_LENGTH),
1648                (u64)pci_resource_start(pdev, 1), pdev->irq);
1649
1650         ptr_phycount = twl_get_param(tw_dev, 2, TW_PARAM_PHY_SUMMARY_TABLE,
1651                                      TW_PARAM_PHYCOUNT, TW_PARAM_PHYCOUNT_LENGTH);
1652         if (ptr_phycount)
1653                 phycount = le32_to_cpu(*(int *)ptr_phycount);
1654
1655         printk(KERN_WARNING "3w-sas: scsi%d: Firmware %s, BIOS %s, Phys: %d.\n",
1656                host->host_no,
1657                (char *)twl_get_param(tw_dev, 1, TW_VERSION_TABLE,
1658                                      TW_PARAM_FWVER, TW_PARAM_FWVER_LENGTH),
1659                (char *)twl_get_param(tw_dev, 2, TW_VERSION_TABLE,
1660                                      TW_PARAM_BIOSVER, TW_PARAM_BIOSVER_LENGTH),
1661                phycount);
1662
1663         /* Try to enable MSI */
1664         if (use_msi && !pci_enable_msi(pdev))
1665                 set_bit(TW_USING_MSI, &tw_dev->flags);
1666
1667         /* Now setup the interrupt handler */
1668         retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1669         if (retval) {
1670                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x1f, "Error requesting IRQ");
1671                 goto out_remove_host;
1672         }
1673
1674         twl_device_extension_list[twl_device_extension_count] = tw_dev;
1675         twl_device_extension_count++;
1676
1677         /* Re-enable interrupts on the card */
1678         TWL_UNMASK_INTERRUPTS(tw_dev);
1679
1680         /* Finally, scan the host */
1681         scsi_scan_host(host);
1682
1683         /* Add sysfs binary files */
1684         if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr))
1685                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x20, "Failed to create sysfs binary file: 3ware_aen_read");
1686         if (sysfs_create_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr))
1687                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x21, "Failed to create sysfs binary file: 3ware_compat_info");
1688
1689         if (twl_major == -1) {
1690                 if ((twl_major = register_chrdev (0, "twl", &twl_fops)) < 0)
1691                         TW_PRINTK(host, TW_DRIVER, 0x22, "Failed to register character device");
1692         }
1693         tw_dev->online = 1;
1694         return 0;
1695
1696 out_remove_host:
1697         if (test_bit(TW_USING_MSI, &tw_dev->flags))
1698                 pci_disable_msi(pdev);
1699         scsi_remove_host(host);
1700 out_iounmap:
1701         iounmap(tw_dev->base_addr);
1702 out_release_mem_region:
1703         pci_release_regions(pdev);
1704 out_free_device_extension:
1705         twl_free_device_extension(tw_dev);
1706         scsi_host_put(host);
1707 out_disable_device:
1708         pci_disable_device(pdev);
1709
1710         return retval;
1711 } /* End twl_probe() */
1712
1713 /* This function is called to remove a device */
1714 static void twl_remove(struct pci_dev *pdev)
1715 {
1716         struct Scsi_Host *host = pci_get_drvdata(pdev);
1717         TW_Device_Extension *tw_dev;
1718
1719         if (!host)
1720                 return;
1721
1722         tw_dev = (TW_Device_Extension *)host->hostdata;
1723
1724         if (!tw_dev->online)
1725                 return;
1726
1727         /* Remove sysfs binary files */
1728         sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_aen_read_attr);
1729         sysfs_remove_bin_file(&host->shost_dev.kobj, &twl_sysfs_compat_info_attr);
1730
1731         scsi_remove_host(tw_dev->host);
1732
1733         /* Unregister character device */
1734         if (twl_major >= 0) {
1735                 unregister_chrdev(twl_major, "twl");
1736                 twl_major = -1;
1737         }
1738
1739         /* Shutdown the card */
1740         __twl_shutdown(tw_dev);
1741
1742         /* Disable MSI if enabled */
1743         if (test_bit(TW_USING_MSI, &tw_dev->flags))
1744                 pci_disable_msi(pdev);
1745
1746         /* Free IO remapping */
1747         iounmap(tw_dev->base_addr);
1748
1749         /* Free up the mem region */
1750         pci_release_regions(pdev);
1751
1752         /* Free up device extension resources */
1753         twl_free_device_extension(tw_dev);
1754
1755         scsi_host_put(tw_dev->host);
1756         pci_disable_device(pdev);
1757         twl_device_extension_count--;
1758 } /* End twl_remove() */
1759
1760 #ifdef CONFIG_PM
1761 /* This function is called on PCI suspend */
1762 static int twl_suspend(struct pci_dev *pdev, pm_message_t state)
1763 {
1764         struct Scsi_Host *host = pci_get_drvdata(pdev);
1765         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1766
1767         printk(KERN_WARNING "3w-sas: Suspending host %d.\n", tw_dev->host->host_no);
1768         /* Disable interrupts */
1769         TWL_MASK_INTERRUPTS(tw_dev);
1770
1771         free_irq(tw_dev->tw_pci_dev->irq, tw_dev);
1772
1773         /* Tell the card we are shutting down */
1774         if (twl_initconnection(tw_dev, 1, 0, 0, 0, 0, 0, NULL, NULL, NULL, NULL, NULL)) {
1775                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x23, "Connection shutdown failed during suspend");
1776         } else {
1777                 printk(KERN_WARNING "3w-sas: Suspend complete.\n");
1778         }
1779
1780         /* Clear doorbell interrupt */
1781         TWL_CLEAR_DB_INTERRUPT(tw_dev);
1782
1783         pci_save_state(pdev);
1784         pci_disable_device(pdev);
1785         pci_set_power_state(pdev, pci_choose_state(pdev, state));
1786
1787         return 0;
1788 } /* End twl_suspend() */
1789
1790 /* This function is called on PCI resume */
1791 static int twl_resume(struct pci_dev *pdev)
1792 {
1793         int retval = 0;
1794         struct Scsi_Host *host = pci_get_drvdata(pdev);
1795         TW_Device_Extension *tw_dev = (TW_Device_Extension *)host->hostdata;
1796
1797         printk(KERN_WARNING "3w-sas: Resuming host %d.\n", tw_dev->host->host_no);
1798         pci_set_power_state(pdev, PCI_D0);
1799         pci_enable_wake(pdev, PCI_D0, 0);
1800         pci_restore_state(pdev);
1801
1802         retval = pci_enable_device(pdev);
1803         if (retval) {
1804                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x24, "Enable device failed during resume");
1805                 return retval;
1806         }
1807
1808         pci_set_master(pdev);
1809         pci_try_set_mwi(pdev);
1810
1811         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64))
1812             || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))
1813                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))
1814                     || pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32))) {
1815                         TW_PRINTK(host, TW_DRIVER, 0x25, "Failed to set dma mask during resume");
1816                         retval = -ENODEV;
1817                         goto out_disable_device;
1818                 }
1819
1820         /* Initialize the card */
1821         if (twl_reset_sequence(tw_dev, 0)) {
1822                 retval = -ENODEV;
1823                 goto out_disable_device;
1824         }
1825
1826         /* Now setup the interrupt handler */
1827         retval = request_irq(pdev->irq, twl_interrupt, IRQF_SHARED, "3w-sas", tw_dev);
1828         if (retval) {
1829                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x26, "Error requesting IRQ during resume");
1830                 retval = -ENODEV;
1831                 goto out_disable_device;
1832         }
1833
1834         /* Now enable MSI if enabled */
1835         if (test_bit(TW_USING_MSI, &tw_dev->flags))
1836                 pci_enable_msi(pdev);
1837
1838         /* Re-enable interrupts on the card */
1839         TWL_UNMASK_INTERRUPTS(tw_dev);
1840
1841         printk(KERN_WARNING "3w-sas: Resume complete.\n");
1842         return 0;
1843
1844 out_disable_device:
1845         scsi_remove_host(host);
1846         pci_disable_device(pdev);
1847
1848         return retval;
1849 } /* End twl_resume() */
1850 #endif
1851
1852 /* PCI Devices supported by this driver */
1853 static struct pci_device_id twl_pci_tbl[] = {
1854         { PCI_VDEVICE(3WARE, PCI_DEVICE_ID_3WARE_9750) },
1855         { }
1856 };
1857 MODULE_DEVICE_TABLE(pci, twl_pci_tbl);
1858
1859 /* pci_driver initializer */
1860 static struct pci_driver twl_driver = {
1861         .name           = "3w-sas",
1862         .id_table       = twl_pci_tbl,
1863         .probe          = twl_probe,
1864         .remove         = twl_remove,
1865 #ifdef CONFIG_PM
1866         .suspend        = twl_suspend,
1867         .resume         = twl_resume,
1868 #endif
1869         .shutdown       = twl_shutdown
1870 };
1871
1872 /* This function is called on driver initialization */
1873 static int __init twl_init(void)
1874 {
1875         printk(KERN_INFO "LSI 3ware SAS/SATA-RAID Controller device driver for Linux v%s.\n", TW_DRIVER_VERSION);
1876
1877         return pci_register_driver(&twl_driver);
1878 } /* End twl_init() */
1879
1880 /* This function is called on driver exit */
1881 static void __exit twl_exit(void)
1882 {
1883         pci_unregister_driver(&twl_driver);
1884 } /* End twl_exit() */
1885
1886 module_init(twl_init);
1887 module_exit(twl_exit);
1888