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