kernel/drivers/scsi/esas2r/esas2r_main.c

   1 /*
   2  *  linux/drivers/scsi/esas2r/esas2r_main.c
   3  *      For use with ATTO ExpressSAS R6xx SAS/SATA RAID controllers
   4  *
   5  *  Copyright (c) 2001-2013 ATTO Technology, Inc.
   6  *  (mailto:linuxdrivers@attotech.com)
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License
  10  * as published by the Free Software Foundation; either version 2
  11  * of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * NO WARRANTY
  19  * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
  20  * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT
  21  * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,
  22  * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is
  23  * solely responsible for determining the appropriateness of using and
  24  * distributing the Program and assumes all risks associated with its
  25  * exercise of rights under this Agreement, including but not limited to
  26  * the risks and costs of program errors, damage to or loss of data,
  27  * programs or equipment, and unavailability or interruption of operations.
  28  *
  29  * DISCLAIMER OF LIABILITY
  30  * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
  31  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  32  * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND
  33  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  34  * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  35  * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
  36  * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES
  37  *
  38  * You should have received a copy of the GNU General Public License
  39  * along with this program; if not, write to the Free Software
  40  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301,
  41  * USA.
  42  */
  43
  44 #include "esas2r.h"
  45
  46 MODULE_DESCRIPTION(ESAS2R_DRVR_NAME ": " ESAS2R_LONGNAME " driver");
  47 MODULE_AUTHOR("ATTO Technology, Inc.");
  48 MODULE_LICENSE("GPL");
  49 MODULE_VERSION(ESAS2R_VERSION_STR);
  50
  51 /* global definitions */
  52
  53 static int found_adapters;
  54 struct esas2r_adapter *esas2r_adapters[MAX_ADAPTERS];
  55
  56 #define ESAS2R_VDA_EVENT_PORT1       54414
  57 #define ESAS2R_VDA_EVENT_PORT2       54415
  58 #define ESAS2R_VDA_EVENT_SOCK_COUNT  2
  59
  60 static struct esas2r_adapter *esas2r_adapter_from_kobj(struct kobject *kobj)
  61 {
  62         struct device *dev = container_of(kobj, struct device, kobj);
  63         struct Scsi_Host *host = class_to_shost(dev);
  64
  65         return (struct esas2r_adapter *)host->hostdata;
  66 }
  67
  68 static ssize_t read_fw(struct file *file, struct kobject *kobj,
  69                        struct bin_attribute *attr,
  70                        char *buf, loff_t off, size_t count)
  71 {
  72         struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
  73
  74         return esas2r_read_fw(a, buf, off, count);
  75 }
  76
  77 static ssize_t write_fw(struct file *file, struct kobject *kobj,
  78                         struct bin_attribute *attr,
  79                         char *buf, loff_t off, size_t count)
  80 {
  81         struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
  82
  83         return esas2r_write_fw(a, buf, off, count);
  84 }
  85
  86 static ssize_t read_fs(struct file *file, struct kobject *kobj,
  87                        struct bin_attribute *attr,
  88                        char *buf, loff_t off, size_t count)
  89 {
  90         struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
  91
  92         return esas2r_read_fs(a, buf, off, count);
  93 }
  94
  95 static ssize_t write_fs(struct file *file, struct kobject *kobj,
  96                         struct bin_attribute *attr,
  97                         char *buf, loff_t off, size_t count)
  98 {
  99         struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
 100         int length = min(sizeof(struct esas2r_ioctl_fs), count);
 101         int result = 0;
 102
 103         result = esas2r_write_fs(a, buf, off, count);
 104
 105         if (result < 0)
 106                 result = 0;
 107
 108         return length;
 109 }
 110
 111 static ssize_t read_vda(struct file *file, struct kobject *kobj,
 112                         struct bin_attribute *attr,
 113                         char *buf, loff_t off, size_t count)
 114 {
 115         struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
 116
 117         return esas2r_read_vda(a, buf, off, count);
 118 }
 119
 120 static ssize_t write_vda(struct file *file, struct kobject *kobj,
 121                          struct bin_attribute *attr,
 122                          char *buf, loff_t off, size_t count)
 123 {
 124         struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
 125
 126         return esas2r_write_vda(a, buf, off, count);
 127 }
 128
 129 static ssize_t read_live_nvram(struct file *file, struct kobject *kobj,
 130                                struct bin_attribute *attr,
 131                                char *buf, loff_t off, size_t count)
 132 {
 133         struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
 134         int length = min_t(size_t, sizeof(struct esas2r_sas_nvram), PAGE_SIZE);
 135
 136         memcpy(buf, a->nvram, length);
 137         return length;
 138 }
 139
 140 static ssize_t write_live_nvram(struct file *file, struct kobject *kobj,
 141                                 struct bin_attribute *attr,
 142                                 char *buf, loff_t off, size_t count)
 143 {
 144         struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
 145         struct esas2r_request *rq;
 146         int result = -EFAULT;
 147
 148         rq = esas2r_alloc_request(a);
 149         if (rq == NULL)
 150                 return -ENOMEM;
 151
 152         if (esas2r_write_params(a, rq, (struct esas2r_sas_nvram *)buf))
 153                 result = count;
 154
 155         esas2r_free_request(a, rq);
 156
 157         return result;
 158 }
 159
 160 static ssize_t read_default_nvram(struct file *file, struct kobject *kobj,
 161                                   struct bin_attribute *attr,
 162                                   char *buf, loff_t off, size_t count)
 163 {
 164         struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
 165
 166         esas2r_nvram_get_defaults(a, (struct esas2r_sas_nvram *)buf);
 167
 168         return sizeof(struct esas2r_sas_nvram);
 169 }
 170
 171 static ssize_t read_hw(struct file *file, struct kobject *kobj,
 172                        struct bin_attribute *attr,
 173                        char *buf, loff_t off, size_t count)
 174 {
 175         struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
 176         int length = min_t(size_t, sizeof(struct atto_ioctl), PAGE_SIZE);
 177
 178         if (!a->local_atto_ioctl)
 179                 return -ENOMEM;
 180
 181         if (handle_hba_ioctl(a, a->local_atto_ioctl) != IOCTL_SUCCESS)
 182                 return -ENOMEM;
 183
 184         memcpy(buf, a->local_atto_ioctl, length);
 185
 186         return length;
 187 }
 188
 189 static ssize_t write_hw(struct file *file, struct kobject *kobj,
 190                         struct bin_attribute *attr,
 191                         char *buf, loff_t off, size_t count)
 192 {
 193         struct esas2r_adapter *a = esas2r_adapter_from_kobj(kobj);
 194         int length = min(sizeof(struct atto_ioctl), count);
 195
 196         if (!a->local_atto_ioctl) {
 197                 a->local_atto_ioctl = kzalloc(sizeof(struct atto_ioctl),
 198                                               GFP_KERNEL);
 199                 if (a->local_atto_ioctl == NULL) {
 200                         esas2r_log(ESAS2R_LOG_WARN,
 201                                    "write_hw kzalloc failed for %d bytes",
 202                                    sizeof(struct atto_ioctl));
 203                         return -ENOMEM;
 204                 }
 205         }
 206
 207         memset(a->local_atto_ioctl, 0, sizeof(struct atto_ioctl));
 208         memcpy(a->local_atto_ioctl, buf, length);
 209
 210         return length;
 211 }
 212
 213 #define ESAS2R_RW_BIN_ATTR(_name) \
 214         struct bin_attribute bin_attr_ ## _name = { \
 215                 .attr   = \
 216                 { .name = __stringify(_name), .mode  = S_IRUSR | S_IWUSR }, \
 217                 .size   = 0, \
 218                 .read   = read_ ## _name, \
 219                 .write  = write_ ## _name }
 220
 221 ESAS2R_RW_BIN_ATTR(fw);
 222 ESAS2R_RW_BIN_ATTR(fs);
 223 ESAS2R_RW_BIN_ATTR(vda);
 224 ESAS2R_RW_BIN_ATTR(hw);
 225 ESAS2R_RW_BIN_ATTR(live_nvram);
 226
 227 struct bin_attribute bin_attr_default_nvram = {
 228         .attr   = { .name = "default_nvram", .mode = S_IRUGO },
 229         .size   = 0,
 230         .read   = read_default_nvram,
 231         .write  = NULL
 232 };
 233
 234 static struct scsi_host_template driver_template = {
 235         .module                         = THIS_MODULE,
 236         .show_info                      = esas2r_show_info,
 237         .name                           = ESAS2R_LONGNAME,
 238         .release                        = esas2r_release,
 239         .info                           = esas2r_info,
 240         .ioctl                          = esas2r_ioctl,
 241         .queuecommand                   = esas2r_queuecommand,
 242         .eh_abort_handler               = esas2r_eh_abort,
 243         .eh_device_reset_handler        = esas2r_device_reset,
 244         .eh_bus_reset_handler           = esas2r_bus_reset,
 245         .eh_host_reset_handler          = esas2r_host_reset,
 246         .eh_target_reset_handler        = esas2r_target_reset,
 247         .can_queue                      = 128,
 248         .this_id                        = -1,
 249         .sg_tablesize                   = SCSI_MAX_SG_SEGMENTS,
 250         .cmd_per_lun                    =
 251                 ESAS2R_DEFAULT_CMD_PER_LUN,
 252         .present                        = 0,
 253         .unchecked_isa_dma              = 0,
 254         .use_clustering                 = ENABLE_CLUSTERING,
 255         .emulated                       = 0,
 256         .proc_name                      = ESAS2R_DRVR_NAME,
 257         .change_queue_depth             = scsi_change_queue_depth,
 258         .max_sectors                    = 0xFFFF,
 259 };
 260
 261 int sgl_page_size = 512;
 262 module_param(sgl_page_size, int, 0);
 263 MODULE_PARM_DESC(sgl_page_size,
 264                  "Scatter/gather list (SGL) page size in number of S/G "
 265                  "entries.  If your application is doing a lot of very large "
 266                  "transfers, you may want to increase the SGL page size.  "
 267                  "Default 512.");
 268
 269 int num_sg_lists = 1024;
 270 module_param(num_sg_lists, int, 0);
 271 MODULE_PARM_DESC(num_sg_lists,
 272                  "Number of scatter/gather lists.  Default 1024.");
 273
 274 int sg_tablesize = SCSI_MAX_SG_SEGMENTS;
 275 module_param(sg_tablesize, int, 0);
 276 MODULE_PARM_DESC(sg_tablesize,
 277                  "Maximum number of entries in a scatter/gather table.");
 278
 279 int num_requests = 256;
 280 module_param(num_requests, int, 0);
 281 MODULE_PARM_DESC(num_requests,
 282                  "Number of requests.  Default 256.");
 283
 284 int num_ae_requests = 4;
 285 module_param(num_ae_requests, int, 0);
 286 MODULE_PARM_DESC(num_ae_requests,
 287                  "Number of VDA asynchromous event requests.  Default 4.");
 288
 289 int cmd_per_lun = ESAS2R_DEFAULT_CMD_PER_LUN;
 290 module_param(cmd_per_lun, int, 0);
 291 MODULE_PARM_DESC(cmd_per_lun,
 292                  "Maximum number of commands per LUN.  Default "
 293                  DEFINED_NUM_TO_STR(ESAS2R_DEFAULT_CMD_PER_LUN) ".");
 294
 295 int can_queue = 128;
 296 module_param(can_queue, int, 0);
 297 MODULE_PARM_DESC(can_queue,
 298                  "Maximum number of commands per adapter.  Default 128.");
 299
 300 int esas2r_max_sectors = 0xFFFF;
 301 module_param(esas2r_max_sectors, int, 0);
 302 MODULE_PARM_DESC(esas2r_max_sectors,
 303                  "Maximum number of disk sectors in a single data transfer.  "
 304                  "Default 65535 (largest possible setting).");
 305
 306 int interrupt_mode = 1;
 307 module_param(interrupt_mode, int, 0);
 308 MODULE_PARM_DESC(interrupt_mode,
 309                  "Defines the interrupt mode to use.  0 for legacy"
 310                  ", 1 for MSI.  Default is MSI (1).");
 311
 312 static struct pci_device_id
 313         esas2r_pci_table[] = {
 314         { ATTO_VENDOR_ID, 0x0049,         ATTO_VENDOR_ID, 0x0049,
 315           0,
 316           0, 0 },
 317         { ATTO_VENDOR_ID, 0x0049,         ATTO_VENDOR_ID, 0x004A,
 318           0,
 319           0, 0 },
 320         { ATTO_VENDOR_ID, 0x0049,         ATTO_VENDOR_ID, 0x004B,
 321           0,
 322           0, 0 },
 323         { ATTO_VENDOR_ID, 0x0049,         ATTO_VENDOR_ID, 0x004C,
 324           0,
 325           0, 0 },
 326         { ATTO_VENDOR_ID, 0x0049,         ATTO_VENDOR_ID, 0x004D,
 327           0,
 328           0, 0 },
 329         { ATTO_VENDOR_ID, 0x0049,         ATTO_VENDOR_ID, 0x004E,
 330           0,
 331           0, 0 },
 332         { 0,              0,              0,              0,
 333           0,
 334           0, 0 }
 335 };
 336
 337 MODULE_DEVICE_TABLE(pci, esas2r_pci_table);
 338
 339 static int
 340 esas2r_probe(struct pci_dev *pcid, const struct pci_device_id *id);
 341
 342 static void
 343 esas2r_remove(struct pci_dev *pcid);
 344
 345 static struct pci_driver
 346         esas2r_pci_driver = {
 347         .name           = ESAS2R_DRVR_NAME,
 348         .id_table       = esas2r_pci_table,
 349         .probe          = esas2r_probe,
 350         .remove         = esas2r_remove,
 351         .suspend        = esas2r_suspend,
 352         .resume         = esas2r_resume,
 353 };
 354
 355 static int esas2r_probe(struct pci_dev *pcid,
 356                         const struct pci_device_id *id)
 357 {
 358         struct Scsi_Host *host = NULL;
 359         struct esas2r_adapter *a;
 360         int err;
 361
 362         size_t host_alloc_size = sizeof(struct esas2r_adapter)
 363                                  + ((num_requests) +
 364                                     1) * sizeof(struct esas2r_request);
 365
 366         esas2r_log_dev(ESAS2R_LOG_DEBG, &(pcid->dev),
 367                        "esas2r_probe() 0x%02x 0x%02x 0x%02x 0x%02x",
 368                        pcid->vendor,
 369                        pcid->device,
 370                        pcid->subsystem_vendor,
 371                        pcid->subsystem_device);
 372
 373         esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev),
 374                        "before pci_enable_device() "
 375                        "enable_cnt: %d",
 376                        pcid->enable_cnt.counter);
 377
 378         err = pci_enable_device(pcid);
 379         if (err != 0) {
 380                 esas2r_log_dev(ESAS2R_LOG_CRIT, &(pcid->dev),
 381                                "pci_enable_device() FAIL (%d)",
 382                                err);
 383                 return -ENODEV;
 384         }
 385
 386         esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev),
 387                        "pci_enable_device() OK");
 388         esas2r_log_dev(ESAS2R_LOG_INFO, &(pcid->dev),
 389                        "after pci_enable_device() enable_cnt: %d",
 390                        pcid->enable_cnt.counter);
 391
 392         host = scsi_host_alloc(&driver_template, host_alloc_size);
 393         if (host == NULL) {
 394                 esas2r_log(ESAS2R_LOG_CRIT, "scsi_host_alloc() FAIL");
 395                 return -ENODEV;
 396         }
 397
 398         memset(host->hostdata, 0, host_alloc_size);
 399
 400         a = (struct esas2r_adapter *)host->hostdata;
 401
 402         esas2r_log(ESAS2R_LOG_INFO, "scsi_host_alloc() OK host: %p", host);
 403
 404         /* override max LUN and max target id */
 405
 406         host->max_id = ESAS2R_MAX_ID + 1;
 407         host->max_lun = 255;
 408
 409         /* we can handle 16-byte CDbs */
 410
 411         host->max_cmd_len = 16;
 412
 413         host->can_queue = can_queue;
 414         host->cmd_per_lun = cmd_per_lun;
 415         host->this_id = host->max_id + 1;
 416         host->max_channel = 0;
 417         host->unique_id = found_adapters;
 418         host->sg_tablesize = sg_tablesize;
 419         host->max_sectors = esas2r_max_sectors;
 420
 421         /* set to bus master for BIOses that don't do it for us */
 422
 423         esas2r_log(ESAS2R_LOG_INFO, "pci_set_master() called");
 424
 425         pci_set_master(pcid);
 426
 427         if (!esas2r_init_adapter(host, pcid, found_adapters)) {
 428                 esas2r_log(ESAS2R_LOG_CRIT,
 429                            "unable to initialize device at PCI bus %x:%x",
 430                            pcid->bus->number,
 431                            pcid->devfn);
 432
 433                 esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
 434                                "scsi_host_put() called");
 435
 436                 scsi_host_put(host);
 437
 438                 return 0;
 439
 440         }
 441
 442         esas2r_log(ESAS2R_LOG_INFO, "pci_set_drvdata(%p, %p) called", pcid,
 443                    host->hostdata);
 444
 445         pci_set_drvdata(pcid, host);
 446
 447         esas2r_log(ESAS2R_LOG_INFO, "scsi_add_host() called");
 448
 449         err = scsi_add_host(host, &pcid->dev);
 450
 451         if (err) {
 452                 esas2r_log(ESAS2R_LOG_CRIT, "scsi_add_host returned %d", err);
 453                 esas2r_log_dev(ESAS2R_LOG_CRIT, &(host->shost_gendev),
 454                                "scsi_add_host() FAIL");
 455
 456                 esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
 457                                "scsi_host_put() called");
 458
 459                 scsi_host_put(host);
 460
 461                 esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
 462                                "pci_set_drvdata(%p, NULL) called",
 463                                pcid);
 464
 465                 pci_set_drvdata(pcid, NULL);
 466
 467                 return -ENODEV;
 468         }
 469
 470
 471         esas2r_fw_event_on(a);
 472
 473         esas2r_log_dev(ESAS2R_LOG_INFO, &(host->shost_gendev),
 474                        "scsi_scan_host() called");
 475
 476         scsi_scan_host(host);
 477
 478         /* Add sysfs binary files */
 479         if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_fw))
 480                 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
 481                                "Failed to create sysfs binary file: fw");
 482         else
 483                 a->sysfs_fw_created = 1;
 484
 485         if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_fs))
 486                 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
 487                                "Failed to create sysfs binary file: fs");
 488         else
 489                 a->sysfs_fs_created = 1;
 490
 491         if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_vda))
 492                 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
 493                                "Failed to create sysfs binary file: vda");
 494         else
 495                 a->sysfs_vda_created = 1;
 496
 497         if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_hw))
 498                 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
 499                                "Failed to create sysfs binary file: hw");
 500         else
 501                 a->sysfs_hw_created = 1;
 502
 503         if (sysfs_create_bin_file(&host->shost_dev.kobj, &bin_attr_live_nvram))
 504                 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
 505                                "Failed to create sysfs binary file: live_nvram");
 506         else
 507                 a->sysfs_live_nvram_created = 1;
 508
 509         if (sysfs_create_bin_file(&host->shost_dev.kobj,
 510                                   &bin_attr_default_nvram))
 511                 esas2r_log_dev(ESAS2R_LOG_WARN, &(host->shost_gendev),
 512                                "Failed to create sysfs binary file: default_nvram");
 513         else
 514                 a->sysfs_default_nvram_created = 1;
 515
 516         found_adapters++;
 517
 518         return 0;
 519 }
 520
 521 static void esas2r_remove(struct pci_dev *pdev)
 522 {
 523         struct Scsi_Host *host;
 524         int index;
 525
 526         if (pdev == NULL) {
 527                 esas2r_log(ESAS2R_LOG_WARN, "esas2r_remove pdev==NULL");
 528                 return;
 529         }
 530
 531         host = pci_get_drvdata(pdev);
 532
 533         if (host == NULL) {
 534                 /*
 535                  * this can happen if pci_set_drvdata was already called
 536                  * to clear the host pointer.  if this is the case, we
 537                  * are okay; this channel has already been cleaned up.
 538                  */
 539
 540                 return;
 541         }
 542
 543         esas2r_log_dev(ESAS2R_LOG_INFO, &(pdev->dev),
 544                        "esas2r_remove(%p) called; "
 545                        "host:%p", pdev,
 546                        host);
 547
 548         index = esas2r_cleanup(host);
 549
 550         if (index < 0)
 551                 esas2r_log_dev(ESAS2R_LOG_WARN, &(pdev->dev),
 552                                "unknown host in %s",
 553                                __func__);
 554
 555         found_adapters--;
 556
 557         /* if this was the last adapter, clean up the rest of the driver */
 558
 559         if (found_adapters == 0)
 560                 esas2r_cleanup(NULL);
 561 }
 562
 563 static int __init esas2r_init(void)
 564 {
 565         int i;
 566
 567         esas2r_log(ESAS2R_LOG_INFO, "%s called", __func__);
 568
 569         /* verify valid parameters */
 570
 571         if (can_queue < 1) {
 572                 esas2r_log(ESAS2R_LOG_WARN,
 573                            "warning: can_queue must be at least 1, value "
 574                            "forced.");
 575                 can_queue = 1;
 576         } else if (can_queue > 2048) {
 577                 esas2r_log(ESAS2R_LOG_WARN,
 578                            "warning: can_queue must be no larger than 2048, "
 579                            "value forced.");
 580                 can_queue = 2048;
 581         }
 582
 583         if (cmd_per_lun < 1) {
 584                 esas2r_log(ESAS2R_LOG_WARN,
 585                            "warning: cmd_per_lun must be at least 1, value "
 586                            "forced.");
 587                 cmd_per_lun = 1;
 588         } else if (cmd_per_lun > 2048) {
 589                 esas2r_log(ESAS2R_LOG_WARN,
 590                            "warning: cmd_per_lun must be no larger than "
 591                            "2048, value forced.");
 592                 cmd_per_lun = 2048;
 593         }
 594
 595         if (sg_tablesize < 32) {
 596                 esas2r_log(ESAS2R_LOG_WARN,
 597                            "warning: sg_tablesize must be at least 32, "
 598                            "value forced.");
 599                 sg_tablesize = 32;
 600         }
 601
 602         if (esas2r_max_sectors < 1) {
 603                 esas2r_log(ESAS2R_LOG_WARN,
 604                            "warning: esas2r_max_sectors must be at least "
 605                            "1, value forced.");
 606                 esas2r_max_sectors = 1;
 607         } else if (esas2r_max_sectors > 0xffff) {
 608                 esas2r_log(ESAS2R_LOG_WARN,
 609                            "warning: esas2r_max_sectors must be no larger "
 610                            "than 0xffff, value forced.");
 611                 esas2r_max_sectors = 0xffff;
 612         }
 613
 614         sgl_page_size &= ~(ESAS2R_SGL_ALIGN - 1);
 615
 616         if (sgl_page_size < SGL_PG_SZ_MIN)
 617                 sgl_page_size = SGL_PG_SZ_MIN;
 618         else if (sgl_page_size > SGL_PG_SZ_MAX)
 619                 sgl_page_size = SGL_PG_SZ_MAX;
 620
 621         if (num_sg_lists < NUM_SGL_MIN)
 622                 num_sg_lists = NUM_SGL_MIN;
 623         else if (num_sg_lists > NUM_SGL_MAX)
 624                 num_sg_lists = NUM_SGL_MAX;
 625
 626         if (num_requests < NUM_REQ_MIN)
 627                 num_requests = NUM_REQ_MIN;
 628         else if (num_requests > NUM_REQ_MAX)
 629                 num_requests = NUM_REQ_MAX;
 630
 631         if (num_ae_requests < NUM_AE_MIN)
 632                 num_ae_requests = NUM_AE_MIN;
 633         else if (num_ae_requests > NUM_AE_MAX)
 634                 num_ae_requests = NUM_AE_MAX;
 635
 636         /* set up other globals */
 637
 638         for (i = 0; i < MAX_ADAPTERS; i++)
 639                 esas2r_adapters[i] = NULL;
 640
 641         /* initialize */
 642
 643         driver_template.module = THIS_MODULE;
 644
 645         if (pci_register_driver(&esas2r_pci_driver) != 0)
 646                 esas2r_log(ESAS2R_LOG_CRIT, "pci_register_driver FAILED");
 647         else
 648                 esas2r_log(ESAS2R_LOG_INFO, "pci_register_driver() OK");
 649
 650         if (!found_adapters) {
 651                 pci_unregister_driver(&esas2r_pci_driver);
 652                 esas2r_cleanup(NULL);
 653
 654                 esas2r_log(ESAS2R_LOG_CRIT,
 655                            "driver will not be loaded because no ATTO "
 656                            "%s devices were found",
 657                            ESAS2R_DRVR_NAME);
 658                 return -1;
 659         } else {
 660                 esas2r_log(ESAS2R_LOG_INFO, "found %d adapters",
 661                            found_adapters);
 662         }
 663
 664         return 0;
 665 }
 666
 667 /* Handle ioctl calls to "/proc/scsi/esas2r/ATTOnode" */
 668 static const struct file_operations esas2r_proc_fops = {
 669         .compat_ioctl   = esas2r_proc_ioctl,
 670         .unlocked_ioctl = esas2r_proc_ioctl,
 671 };
 672
 673 static struct Scsi_Host *esas2r_proc_host;
 674 static int esas2r_proc_major;
 675
 676 long esas2r_proc_ioctl(struct file *fp, unsigned int cmd, unsigned long arg)
 677 {
 678         return esas2r_ioctl_handler(esas2r_proc_host->hostdata,
 679                                     (int)cmd, (void __user *)arg);
 680 }
 681
 682 static void __exit esas2r_exit(void)
 683 {
 684         esas2r_log(ESAS2R_LOG_INFO, "%s called", __func__);
 685
 686         if (esas2r_proc_major > 0) {
 687                 esas2r_log(ESAS2R_LOG_INFO, "unregister proc");
 688
 689                 remove_proc_entry(ATTONODE_NAME,
 690                                   esas2r_proc_host->hostt->proc_dir);
 691                 unregister_chrdev(esas2r_proc_major, ESAS2R_DRVR_NAME);
 692
 693                 esas2r_proc_major = 0;
 694         }
 695
 696         esas2r_log(ESAS2R_LOG_INFO, "pci_unregister_driver() called");
 697
 698         pci_unregister_driver(&esas2r_pci_driver);
 699 }
 700
 701 int esas2r_show_info(struct seq_file *m, struct Scsi_Host *sh)
 702 {
 703         struct esas2r_adapter *a = (struct esas2r_adapter *)sh->hostdata;
 704
 705         struct esas2r_target *t;
 706         int dev_count = 0;
 707
 708         esas2r_log(ESAS2R_LOG_DEBG, "esas2r_show_info (%p,%d)", m, sh->host_no);
 709
 710         seq_printf(m, ESAS2R_LONGNAME "\n"
 711                    "Driver version: "ESAS2R_VERSION_STR "\n"
 712                    "Flash version: %s\n"
 713                    "Firmware version: %s\n"
 714                    "Copyright "ESAS2R_COPYRIGHT_YEARS "\n"
 715                    "http://www.attotech.com\n"
 716                    "\n",
 717                    a->flash_rev,
 718                    a->fw_rev[0] ? a->fw_rev : "(none)");
 719
 720
 721         seq_printf(m, "Adapter information:\n"
 722                    "--------------------\n"
 723                    "Model: %s\n"
 724                    "SAS address: %02X%02X%02X%02X:%02X%02X%02X%02X\n",
 725                    esas2r_get_model_name(a),
 726                    a->nvram->sas_addr[0],
 727                    a->nvram->sas_addr[1],
 728                    a->nvram->sas_addr[2],
 729                    a->nvram->sas_addr[3],
 730                    a->nvram->sas_addr[4],
 731                    a->nvram->sas_addr[5],
 732                    a->nvram->sas_addr[6],
 733                    a->nvram->sas_addr[7]);
 734
 735         seq_puts(m, "\n"
 736                    "Discovered devices:\n"
 737                    "\n"
 738                    "   #  Target ID\n"
 739                    "---------------\n");
 740
 741         for (t = a->targetdb; t < a->targetdb_end; t++)
 742                 if (t->buffered_target_state == TS_PRESENT) {
 743                         seq_printf(m, " %3d   %3d\n",
 744                                    ++dev_count,
 745                                    (u16)(uintptr_t)(t - a->targetdb));
 746                 }
 747
 748         if (dev_count == 0)
 749                 seq_puts(m, "none\n");
 750
 751         seq_putc(m, '\n');
 752         return 0;
 753
 754 }
 755
 756 int esas2r_release(struct Scsi_Host *sh)
 757 {
 758         esas2r_log_dev(ESAS2R_LOG_INFO, &(sh->shost_gendev),
 759                        "esas2r_release() called");
 760
 761         esas2r_cleanup(sh);
 762         if (sh->irq)
 763                 free_irq(sh->irq, NULL);
 764         scsi_unregister(sh);
 765         return 0;
 766 }
 767
 768 const char *esas2r_info(struct Scsi_Host *sh)
 769 {
 770         struct esas2r_adapter *a = (struct esas2r_adapter *)sh->hostdata;
 771         static char esas2r_info_str[512];
 772
 773         esas2r_log_dev(ESAS2R_LOG_INFO, &(sh->shost_gendev),
 774                        "esas2r_info() called");
 775
 776         /*
 777          * if we haven't done so already, register as a char driver
 778          * and stick a node under "/proc/scsi/esas2r/ATTOnode"
 779          */
 780
 781         if (esas2r_proc_major <= 0) {
 782                 esas2r_proc_host = sh;
 783
 784                 esas2r_proc_major = register_chrdev(0, ESAS2R_DRVR_NAME,
 785                                                     &esas2r_proc_fops);
 786
 787                 esas2r_log_dev(ESAS2R_LOG_DEBG, &(sh->shost_gendev),
 788                                "register_chrdev (major %d)",
 789                                esas2r_proc_major);
 790
 791                 if (esas2r_proc_major > 0) {
 792                         struct proc_dir_entry *pde;
 793
 794                         pde = proc_create(ATTONODE_NAME, 0,
 795                                           sh->hostt->proc_dir,
 796                                           &esas2r_proc_fops);
 797
 798                         if (!pde) {
 799                                 esas2r_log_dev(ESAS2R_LOG_WARN,
 800                                                &(sh->shost_gendev),
 801                                                "failed to create_proc_entry");
 802                                 esas2r_proc_major = -1;
 803                         }
 804                 }
 805         }
 806
 807         sprintf(esas2r_info_str,
 808                 ESAS2R_LONGNAME " (bus 0x%02X, device 0x%02X, IRQ 0x%02X)"
 809                 " driver version: "ESAS2R_VERSION_STR "  firmware version: "
 810                 "%s\n",
 811                 a->pcid->bus->number, a->pcid->devfn, a->pcid->irq,
 812                 a->fw_rev[0] ? a->fw_rev : "(none)");
 813
 814         return esas2r_info_str;
 815 }
 816
 817 /* Callback for building a request scatter/gather list */
 818 static u32 get_physaddr_from_sgc(struct esas2r_sg_context *sgc, u64 *addr)
 819 {
 820         u32 len;
 821
 822         if (likely(sgc->cur_offset == sgc->exp_offset)) {
 823                 /*
 824                  * the normal case: caller used all bytes from previous call, so
 825                  * expected offset is the same as the current offset.
 826                  */
 827
 828                 if (sgc->sgel_count < sgc->num_sgel) {
 829                         /* retrieve next segment, except for first time */
 830                         if (sgc->exp_offset > (u8 *)0) {
 831                                 /* advance current segment */
 832                                 sgc->cur_sgel = sg_next(sgc->cur_sgel);
 833                                 ++(sgc->sgel_count);
 834                         }
 835
 836
 837                         len = sg_dma_len(sgc->cur_sgel);
 838                         (*addr) = sg_dma_address(sgc->cur_sgel);
 839
 840                         /* save the total # bytes returned to caller so far */
 841                         sgc->exp_offset += len;
 842
 843                 } else {
 844                         len = 0;
 845                 }
 846         } else if (sgc->cur_offset < sgc->exp_offset) {
 847                 /*
 848                  * caller did not use all bytes from previous call. need to
 849                  * compute the address based on current segment.
 850                  */
 851
 852                 len = sg_dma_len(sgc->cur_sgel);
 853                 (*addr) = sg_dma_address(sgc->cur_sgel);
 854
 855                 sgc->exp_offset -= len;
 856
 857                 /* calculate PA based on prev segment address and offsets */
 858                 *addr = *addr +
 859                         (sgc->cur_offset - sgc->exp_offset);
 860
 861                 sgc->exp_offset += len;
 862
 863                 /* re-calculate length based on offset */
 864                 len = lower_32_bits(
 865                         sgc->exp_offset - sgc->cur_offset);
 866         } else {   /* if ( sgc->cur_offset > sgc->exp_offset ) */
 867                    /*
 868                     * we don't expect the caller to skip ahead.
 869                     * cur_offset will never exceed the len we return
 870                     */
 871                 len = 0;
 872         }
 873
 874         return len;
 875 }
 876
 877 int esas2r_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd)
 878 {
 879         struct esas2r_adapter *a =
 880                 (struct esas2r_adapter *)cmd->device->host->hostdata;
 881         struct esas2r_request *rq;
 882         struct esas2r_sg_context sgc;
 883         unsigned bufflen;
 884
 885         /* Assume success, if it fails we will fix the result later. */
 886         cmd->result = DID_OK << 16;
 887
 888         if (unlikely(test_bit(AF_DEGRADED_MODE, &a->flags))) {
 889                 cmd->result = DID_NO_CONNECT << 16;
 890                 cmd->scsi_done(cmd);
 891                 return 0;
 892         }
 893
 894         rq = esas2r_alloc_request(a);
 895         if (unlikely(rq == NULL)) {
 896                 esas2r_debug("esas2r_alloc_request failed");
 897                 return SCSI_MLQUEUE_HOST_BUSY;
 898         }
 899
 900         rq->cmd = cmd;
 901         bufflen = scsi_bufflen(cmd);
 902
 903         if (likely(bufflen != 0)) {
 904                 if (cmd->sc_data_direction == DMA_TO_DEVICE)
 905                         rq->vrq->scsi.flags |= cpu_to_le32(FCP_CMND_WRD);
 906                 else if (cmd->sc_data_direction == DMA_FROM_DEVICE)
 907                         rq->vrq->scsi.flags |= cpu_to_le32(FCP_CMND_RDD);
 908         }
 909
 910         memcpy(rq->vrq->scsi.cdb, cmd->cmnd, cmd->cmd_len);
 911         rq->vrq->scsi.length = cpu_to_le32(bufflen);
 912         rq->target_id = cmd->device->id;
 913         rq->vrq->scsi.flags |= cpu_to_le32(cmd->device->lun);
 914         rq->sense_buf = cmd->sense_buffer;
 915         rq->sense_len = SCSI_SENSE_BUFFERSIZE;
 916
 917         esas2r_sgc_init(&sgc, a, rq, NULL);
 918
 919         sgc.length = bufflen;
 920         sgc.cur_offset = NULL;
 921
 922         sgc.cur_sgel = scsi_sglist(cmd);
 923         sgc.exp_offset = NULL;
 924         sgc.num_sgel = scsi_dma_map(cmd);
 925         sgc.sgel_count = 0;
 926
 927         if (unlikely(sgc.num_sgel < 0)) {
 928                 esas2r_free_request(a, rq);
 929                 return SCSI_MLQUEUE_HOST_BUSY;
 930         }
 931
 932         sgc.get_phys_addr = (PGETPHYSADDR)get_physaddr_from_sgc;
 933
 934         if (unlikely(!esas2r_build_sg_list(a, rq, &sgc))) {
 935                 scsi_dma_unmap(cmd);
 936                 esas2r_free_request(a, rq);
 937                 return SCSI_MLQUEUE_HOST_BUSY;
 938         }
 939
 940         esas2r_debug("start request %p to %d:%d\n", rq, (int)cmd->device->id,
 941                      (int)cmd->device->lun);
 942
 943         esas2r_start_request(a, rq);
 944
 945         return 0;
 946 }
 947
 948 static void complete_task_management_request(struct esas2r_adapter *a,
 949                                              struct esas2r_request *rq)
 950 {
 951         (*rq->task_management_status_ptr) = rq->req_stat;
 952         esas2r_free_request(a, rq);
 953 }
 954
 955 /**
 956  * Searches the specified queue for the specified queue for the command
 957  * to abort.
 958  *
 959  * @param [in] a
 960  * @param [in] abort_request
 961  * @param [in] cmd
 962  * t
 963  * @return 0 on failure, 1 if command was not found, 2 if command was found
 964  */
 965 static int esas2r_check_active_queue(struct esas2r_adapter *a,
 966                                      struct esas2r_request **abort_request,
 967                                      struct scsi_cmnd *cmd,
 968                                      struct list_head *queue)
 969 {
 970         bool found = false;
 971         struct esas2r_request *ar = *abort_request;
 972         struct esas2r_request *rq;
 973         struct list_head *element, *next;
 974
 975         list_for_each_safe(element, next, queue) {
 976
 977                 rq = list_entry(element, struct esas2r_request, req_list);
 978
 979                 if (rq->cmd == cmd) {
 980
 981                         /* Found the request.  See what to do with it. */
 982                         if (queue == &a->active_list) {
 983                                 /*
 984                                  * We are searching the active queue, which
 985                                  * means that we need to send an abort request
 986                                  * to the firmware.
 987                                  */
 988                                 ar = esas2r_alloc_request(a);
 989                                 if (ar == NULL) {
 990                                         esas2r_log_dev(ESAS2R_LOG_WARN,
 991                                                        &(a->host->shost_gendev),
 992                                                        "unable to allocate an abort request for cmd %p",
 993                                                        cmd);
 994                                         return 0; /* Failure */
 995                                 }
 996
 997                                 /*
 998                                  * Task management request must be formatted
 999                                  * with a lock held.
1000                                  */
1001                                 ar->sense_len = 0;
1002                                 ar->vrq->scsi.length = 0;
1003                                 ar->target_id = rq->target_id;
1004                                 ar->vrq->scsi.flags |= cpu_to_le32(
1005                                         (u8)le32_to_cpu(rq->vrq->scsi.flags));
1006
1007                                 memset(ar->vrq->scsi.cdb, 0,
1008                                        sizeof(ar->vrq->scsi.cdb));
1009
1010                                 ar->vrq->scsi.flags |= cpu_to_le32(
1011                                         FCP_CMND_TRM);
1012                                 ar->vrq->scsi.u.abort_handle =
1013                                         rq->vrq->scsi.handle;
1014                         } else {
1015                                 /*
1016                                  * The request is pending but not active on
1017                                  * the firmware.  Just free it now and we'll
1018                                  * report the successful abort below.
1019                                  */
1020                                 list_del_init(&rq->req_list);
1021                                 esas2r_free_request(a, rq);
1022                         }
1023
1024                         found = true;
1025                         break;
1026                 }
1027
1028         }
1029
1030         if (!found)
1031                 return 1;       /* Not found */
1032
1033         return 2;               /* found */
1034
1035
1036 }
1037
1038 int esas2r_eh_abort(struct scsi_cmnd *cmd)
1039 {
1040         struct esas2r_adapter *a =
1041                 (struct esas2r_adapter *)cmd->device->host->hostdata;
1042         struct esas2r_request *abort_request = NULL;
1043         unsigned long flags;
1044         struct list_head *queue;
1045         int result;
1046
1047         esas2r_log(ESAS2R_LOG_INFO, "eh_abort (%p)", cmd);
1048
1049         if (test_bit(AF_DEGRADED_MODE, &a->flags)) {
1050                 cmd->result = DID_ABORT << 16;
1051
1052                 scsi_set_resid(cmd, 0);
1053
1054                 cmd->scsi_done(cmd);
1055
1056                 return SUCCESS;
1057         }
1058
1059         spin_lock_irqsave(&a->queue_lock, flags);
1060
1061         /*
1062          * Run through the defer and active queues looking for the request
1063          * to abort.
1064          */
1065
1066         queue = &a->defer_list;
1067
1068 check_active_queue:
1069
1070         result = esas2r_check_active_queue(a, &abort_request, cmd, queue);
1071
1072         if (!result) {
1073                 spin_unlock_irqrestore(&a->queue_lock, flags);
1074                 return FAILED;
1075         } else if (result == 2 && (queue == &a->defer_list)) {
1076                 queue = &a->active_list;
1077                 goto check_active_queue;
1078         }
1079
1080         spin_unlock_irqrestore(&a->queue_lock, flags);
1081
1082         if (abort_request) {
1083                 u8 task_management_status = RS_PENDING;
1084
1085                 /*
1086                  * the request is already active, so we need to tell
1087                  * the firmware to abort it and wait for the response.
1088                  */
1089
1090                 abort_request->comp_cb = complete_task_management_request;
1091                 abort_request->task_management_status_ptr =
1092                         &task_management_status;
1093
1094                 esas2r_start_request(a, abort_request);
1095
1096                 if (atomic_read(&a->disable_cnt) == 0)
1097                         esas2r_do_deferred_processes(a);
1098
1099                 while (task_management_status == RS_PENDING)
1100                         msleep(10);
1101
1102                 /*
1103                  * Once we get here, the original request will have been
1104                  * completed by the firmware and the abort request will have
1105                  * been cleaned up.  we're done!
1106                  */
1107
1108                 return SUCCESS;
1109         }
1110
1111         /*
1112          * If we get here, either we found the inactive request and
1113          * freed it, or we didn't find it at all.  Either way, success!
1114          */
1115
1116         cmd->result = DID_ABORT << 16;
1117
1118         scsi_set_resid(cmd, 0);
1119
1120         cmd->scsi_done(cmd);
1121
1122         return SUCCESS;
1123 }
1124
1125 static int esas2r_host_bus_reset(struct scsi_cmnd *cmd, bool host_reset)
1126 {
1127         struct esas2r_adapter *a =
1128                 (struct esas2r_adapter *)cmd->device->host->hostdata;
1129
1130         if (test_bit(AF_DEGRADED_MODE, &a->flags))
1131                 return FAILED;
1132
1133         if (host_reset)
1134                 esas2r_reset_adapter(a);
1135         else
1136                 esas2r_reset_bus(a);
1137
1138         /* above call sets the AF_OS_RESET flag.  wait for it to clear. */
1139
1140         while (test_bit(AF_OS_RESET, &a->flags)) {
1141                 msleep(10);
1142
1143                 if (test_bit(AF_DEGRADED_MODE, &a->flags))
1144                         return FAILED;
1145         }
1146
1147         if (test_bit(AF_DEGRADED_MODE, &a->flags))
1148                 return FAILED;
1149
1150         return SUCCESS;
1151 }
1152
1153 int esas2r_host_reset(struct scsi_cmnd *cmd)
1154 {
1155         esas2r_log(ESAS2R_LOG_INFO, "host_reset (%p)", cmd);
1156
1157         return esas2r_host_bus_reset(cmd, true);
1158 }
1159
1160 int esas2r_bus_reset(struct scsi_cmnd *cmd)
1161 {
1162         esas2r_log(ESAS2R_LOG_INFO, "bus_reset (%p)", cmd);
1163
1164         return esas2r_host_bus_reset(cmd, false);
1165 }
1166
1167 static int esas2r_dev_targ_reset(struct scsi_cmnd *cmd, bool target_reset)
1168 {
1169         struct esas2r_adapter *a =
1170                 (struct esas2r_adapter *)cmd->device->host->hostdata;
1171         struct esas2r_request *rq;
1172         u8 task_management_status = RS_PENDING;
1173         bool completed;
1174
1175         if (test_bit(AF_DEGRADED_MODE, &a->flags))
1176                 return FAILED;
1177
1178 retry:
1179         rq = esas2r_alloc_request(a);
1180         if (rq == NULL) {
1181                 if (target_reset) {
1182                         esas2r_log(ESAS2R_LOG_CRIT,
1183                                    "unable to allocate a request for a "
1184                                    "target reset (%d)!",
1185                                    cmd->device->id);
1186                 } else {
1187                         esas2r_log(ESAS2R_LOG_CRIT,
1188                                    "unable to allocate a request for a "
1189                                    "device reset (%d:%d)!",
1190                                    cmd->device->id,
1191                                    cmd->device->lun);
1192                 }
1193
1194
1195                 return FAILED;
1196         }
1197
1198         rq->target_id = cmd->device->id;
1199         rq->vrq->scsi.flags |= cpu_to_le32(cmd->device->lun);
1200         rq->req_stat = RS_PENDING;
1201
1202         rq->comp_cb = complete_task_management_request;
1203         rq->task_management_status_ptr = &task_management_status;
1204
1205         if (target_reset) {
1206                 esas2r_debug("issuing target reset (%p) to id %d", rq,
1207                              cmd->device->id);
1208                 completed = esas2r_send_task_mgmt(a, rq, 0x20);
1209         } else {
1210                 esas2r_debug("issuing device reset (%p) to id %d lun %d", rq,
1211                              cmd->device->id, cmd->device->lun);
1212                 completed = esas2r_send_task_mgmt(a, rq, 0x10);
1213         }
1214
1215         if (completed) {
1216                 /* Task management cmd completed right away, need to free it. */
1217
1218                 esas2r_free_request(a, rq);
1219         } else {
1220                 /*
1221                  * Wait for firmware to complete the request.  Completion
1222                  * callback will free it.
1223                  */
1224                 while (task_management_status == RS_PENDING)
1225                         msleep(10);
1226         }
1227
1228         if (test_bit(AF_DEGRADED_MODE, &a->flags))
1229                 return FAILED;
1230
1231         if (task_management_status == RS_BUSY) {
1232                 /*
1233                  * Busy, probably because we are flashing.  Wait a bit and
1234                  * try again.
1235                  */
1236                 msleep(100);
1237                 goto retry;
1238         }
1239
1240         return SUCCESS;
1241 }
1242
1243 int esas2r_device_reset(struct scsi_cmnd *cmd)
1244 {
1245         esas2r_log(ESAS2R_LOG_INFO, "device_reset (%p)", cmd);
1246
1247         return esas2r_dev_targ_reset(cmd, false);
1248
1249 }
1250
1251 int esas2r_target_reset(struct scsi_cmnd *cmd)
1252 {
1253         esas2r_log(ESAS2R_LOG_INFO, "target_reset (%p)", cmd);
1254
1255         return esas2r_dev_targ_reset(cmd, true);
1256 }
1257
1258 void esas2r_log_request_failure(struct esas2r_adapter *a,
1259                                 struct esas2r_request *rq)
1260 {
1261         u8 reqstatus = rq->req_stat;
1262
1263         if (reqstatus == RS_SUCCESS)
1264                 return;
1265
1266         if (rq->vrq->scsi.function == VDA_FUNC_SCSI) {
1267                 if (reqstatus == RS_SCSI_ERROR) {
1268                         if (rq->func_rsp.scsi_rsp.sense_len >= 13) {
1269                                 esas2r_log(ESAS2R_LOG_WARN,
1270                                            "request failure - SCSI error %x ASC:%x ASCQ:%x CDB:%x",
1271                                            rq->sense_buf[2], rq->sense_buf[12],
1272                                            rq->sense_buf[13],
1273                                            rq->vrq->scsi.cdb[0]);
1274                         } else {
1275                                 esas2r_log(ESAS2R_LOG_WARN,
1276                                            "request failure - SCSI error CDB:%x\n",
1277                                            rq->vrq->scsi.cdb[0]);
1278                         }
1279                 } else if ((rq->vrq->scsi.cdb[0] != INQUIRY
1280                             && rq->vrq->scsi.cdb[0] != REPORT_LUNS)
1281                            || (reqstatus != RS_SEL
1282                                && reqstatus != RS_SEL2)) {
1283                         if ((reqstatus == RS_UNDERRUN) &&
1284                             (rq->vrq->scsi.cdb[0] == INQUIRY)) {
1285                                 /* Don't log inquiry underruns */
1286                         } else {
1287                                 esas2r_log(ESAS2R_LOG_WARN,
1288                                            "request failure - cdb:%x reqstatus:%d target:%d",
1289                                            rq->vrq->scsi.cdb[0], reqstatus,
1290                                            rq->target_id);
1291                         }
1292                 }
1293         }
1294 }
1295
1296 void esas2r_wait_request(struct esas2r_adapter *a, struct esas2r_request *rq)
1297 {
1298         u32 starttime;
1299         u32 timeout;
1300
1301         starttime = jiffies_to_msecs(jiffies);
1302         timeout = rq->timeout ? rq->timeout : 5000;
1303
1304         while (true) {
1305                 esas2r_polled_interrupt(a);
1306
1307                 if (rq->req_stat != RS_STARTED)
1308                         break;
1309
1310                 schedule_timeout_interruptible(msecs_to_jiffies(100));
1311
1312                 if ((jiffies_to_msecs(jiffies) - starttime) > timeout) {
1313                         esas2r_hdebug("request TMO");
1314                         esas2r_bugon();
1315
1316                         rq->req_stat = RS_TIMEOUT;
1317
1318                         esas2r_local_reset_adapter(a);
1319                         return;
1320                 }
1321         }
1322 }
1323
1324 u32 esas2r_map_data_window(struct esas2r_adapter *a, u32 addr_lo)
1325 {
1326         u32 offset = addr_lo & (MW_DATA_WINDOW_SIZE - 1);
1327         u32 base = addr_lo & -(signed int)MW_DATA_WINDOW_SIZE;
1328
1329         if (a->window_base != base) {
1330                 esas2r_write_register_dword(a, MVR_PCI_WIN1_REMAP,
1331                                             base | MVRPW1R_ENABLE);
1332                 esas2r_flush_register_dword(a, MVR_PCI_WIN1_REMAP);
1333                 a->window_base = base;
1334         }
1335
1336         return offset;
1337 }
1338
1339 /* Read a block of data from chip memory */
1340 bool esas2r_read_mem_block(struct esas2r_adapter *a,
1341                            void *to,
1342                            u32 from,
1343                            u32 size)
1344 {
1345         u8 *end = (u8 *)to;
1346
1347         while (size) {
1348                 u32 len;
1349                 u32 offset;
1350                 u32 iatvr;
1351
1352                 iatvr = (from & -(signed int)MW_DATA_WINDOW_SIZE);
1353
1354                 esas2r_map_data_window(a, iatvr);
1355
1356                 offset = from & (MW_DATA_WINDOW_SIZE - 1);
1357                 len = size;
1358
1359                 if (len > MW_DATA_WINDOW_SIZE - offset)
1360                         len = MW_DATA_WINDOW_SIZE - offset;
1361
1362                 from += len;
1363                 size -= len;
1364
1365                 while (len--) {
1366                         *end++ = esas2r_read_data_byte(a, offset);
1367                         offset++;
1368                 }
1369         }
1370
1371         return true;
1372 }
1373
1374 void esas2r_nuxi_mgt_data(u8 function, void *data)
1375 {
1376         struct atto_vda_grp_info *g;
1377         struct atto_vda_devinfo *d;
1378         struct atto_vdapart_info *p;
1379         struct atto_vda_dh_info *h;
1380         struct atto_vda_metrics_info *m;
1381         struct atto_vda_schedule_info *s;
1382         struct atto_vda_buzzer_info *b;
1383         u8 i;
1384
1385         switch (function) {
1386         case VDAMGT_BUZZER_INFO:
1387         case VDAMGT_BUZZER_SET:
1388
1389                 b = (struct atto_vda_buzzer_info *)data;
1390
1391                 b->duration = le32_to_cpu(b->duration);
1392                 break;
1393
1394         case VDAMGT_SCHEDULE_INFO:
1395         case VDAMGT_SCHEDULE_EVENT:
1396
1397                 s = (struct atto_vda_schedule_info *)data;
1398
1399                 s->id = le32_to_cpu(s->id);
1400
1401                 break;
1402
1403         case VDAMGT_DEV_INFO:
1404         case VDAMGT_DEV_CLEAN:
1405         case VDAMGT_DEV_PT_INFO:
1406         case VDAMGT_DEV_FEATURES:
1407         case VDAMGT_DEV_PT_FEATURES:
1408         case VDAMGT_DEV_OPERATION:
1409
1410                 d = (struct atto_vda_devinfo *)data;
1411
1412                 d->capacity = le64_to_cpu(d->capacity);
1413                 d->block_size = le32_to_cpu(d->block_size);
1414                 d->ses_dev_index = le16_to_cpu(d->ses_dev_index);
1415                 d->target_id = le16_to_cpu(d->target_id);
1416                 d->lun = le16_to_cpu(d->lun);
1417                 d->features = le16_to_cpu(d->features);
1418                 break;
1419
1420         case VDAMGT_GRP_INFO:
1421         case VDAMGT_GRP_CREATE:
1422         case VDAMGT_GRP_DELETE:
1423         case VDAMGT_ADD_STORAGE:
1424         case VDAMGT_MEMBER_ADD:
1425         case VDAMGT_GRP_COMMIT:
1426         case VDAMGT_GRP_REBUILD:
1427         case VDAMGT_GRP_COMMIT_INIT:
1428         case VDAMGT_QUICK_RAID:
1429         case VDAMGT_GRP_FEATURES:
1430         case VDAMGT_GRP_COMMIT_INIT_AUTOMAP:
1431         case VDAMGT_QUICK_RAID_INIT_AUTOMAP:
1432         case VDAMGT_SPARE_LIST:
1433         case VDAMGT_SPARE_ADD:
1434         case VDAMGT_SPARE_REMOVE:
1435         case VDAMGT_LOCAL_SPARE_ADD:
1436         case VDAMGT_GRP_OPERATION:
1437
1438                 g = (struct atto_vda_grp_info *)data;
1439
1440                 g->capacity = le64_to_cpu(g->capacity);
1441                 g->block_size = le32_to_cpu(g->block_size);
1442                 g->interleave = le32_to_cpu(g->interleave);
1443                 g->features = le16_to_cpu(g->features);
1444
1445                 for (i = 0; i < 32; i++)
1446                         g->members[i] = le16_to_cpu(g->members[i]);
1447
1448                 break;
1449
1450         case VDAMGT_PART_INFO:
1451         case VDAMGT_PART_MAP:
1452         case VDAMGT_PART_UNMAP:
1453         case VDAMGT_PART_AUTOMAP:
1454         case VDAMGT_PART_SPLIT:
1455         case VDAMGT_PART_MERGE:
1456
1457                 p = (struct atto_vdapart_info *)data;
1458
1459                 p->part_size = le64_to_cpu(p->part_size);
1460                 p->start_lba = le32_to_cpu(p->start_lba);
1461                 p->block_size = le32_to_cpu(p->block_size);
1462                 p->target_id = le16_to_cpu(p->target_id);
1463                 break;
1464
1465         case VDAMGT_DEV_HEALTH_REQ:
1466
1467                 h = (struct atto_vda_dh_info *)data;
1468
1469                 h->med_defect_cnt = le32_to_cpu(h->med_defect_cnt);
1470                 h->info_exc_cnt = le32_to_cpu(h->info_exc_cnt);
1471                 break;
1472
1473         case VDAMGT_DEV_METRICS:
1474
1475                 m = (struct atto_vda_metrics_info *)data;
1476
1477                 for (i = 0; i < 32; i++)
1478                         m->dev_indexes[i] = le16_to_cpu(m->dev_indexes[i]);
1479
1480                 break;
1481
1482         default:
1483                 break;
1484         }
1485 }
1486
1487 void esas2r_nuxi_cfg_data(u8 function, void *data)
1488 {
1489         struct atto_vda_cfg_init *ci;
1490
1491         switch (function) {
1492         case VDA_CFG_INIT:
1493         case VDA_CFG_GET_INIT:
1494         case VDA_CFG_GET_INIT2:
1495
1496                 ci = (struct atto_vda_cfg_init *)data;
1497
1498                 ci->date_time.year = le16_to_cpu(ci->date_time.year);
1499                 ci->sgl_page_size = le32_to_cpu(ci->sgl_page_size);
1500                 ci->vda_version = le32_to_cpu(ci->vda_version);
1501                 ci->epoch_time = le32_to_cpu(ci->epoch_time);
1502                 ci->ioctl_tunnel = le32_to_cpu(ci->ioctl_tunnel);
1503                 ci->num_targets_backend = le32_to_cpu(ci->num_targets_backend);
1504                 break;
1505
1506         default:
1507                 break;
1508         }
1509 }
1510
1511 void esas2r_nuxi_ae_data(union atto_vda_ae *ae)
1512 {
1513         struct atto_vda_ae_raid *r = &ae->raid;
1514         struct atto_vda_ae_lu *l = &ae->lu;
1515
1516         switch (ae->hdr.bytype) {
1517         case VDAAE_HDR_TYPE_RAID:
1518
1519                 r->dwflags = le32_to_cpu(r->dwflags);
1520                 break;
1521
1522         case VDAAE_HDR_TYPE_LU:
1523
1524                 l->dwevent = le32_to_cpu(l->dwevent);
1525                 l->wphys_target_id = le16_to_cpu(l->wphys_target_id);
1526                 l->id.tgtlun.wtarget_id = le16_to_cpu(l->id.tgtlun.wtarget_id);
1527
1528                 if (l->hdr.bylength >= offsetof(struct atto_vda_ae_lu, id)
1529                     + sizeof(struct atto_vda_ae_lu_tgt_lun_raid)) {
1530                         l->id.tgtlun_raid.dwinterleave
1531                                 = le32_to_cpu(l->id.tgtlun_raid.dwinterleave);
1532                         l->id.tgtlun_raid.dwblock_size
1533                                 = le32_to_cpu(l->id.tgtlun_raid.dwblock_size);
1534                 }
1535
1536                 break;
1537
1538         case VDAAE_HDR_TYPE_DISK:
1539         default:
1540                 break;
1541         }
1542 }
1543
1544 void esas2r_free_request(struct esas2r_adapter *a, struct esas2r_request *rq)
1545 {
1546         unsigned long flags;
1547
1548         esas2r_rq_destroy_request(rq, a);
1549         spin_lock_irqsave(&a->request_lock, flags);
1550         list_add(&rq->comp_list, &a->avail_request);
1551         spin_unlock_irqrestore(&a->request_lock, flags);
1552 }
1553
1554 struct esas2r_request *esas2r_alloc_request(struct esas2r_adapter *a)
1555 {
1556         struct esas2r_request *rq;
1557         unsigned long flags;
1558
1559         spin_lock_irqsave(&a->request_lock, flags);
1560
1561         if (unlikely(list_empty(&a->avail_request))) {
1562                 spin_unlock_irqrestore(&a->request_lock, flags);
1563                 return NULL;
1564         }
1565
1566         rq = list_first_entry(&a->avail_request, struct esas2r_request,
1567                               comp_list);
1568         list_del(&rq->comp_list);
1569         spin_unlock_irqrestore(&a->request_lock, flags);
1570         esas2r_rq_init_request(rq, a);
1571
1572         return rq;
1573
1574 }
1575
1576 void esas2r_complete_request_cb(struct esas2r_adapter *a,
1577                                 struct esas2r_request *rq)
1578 {
1579         esas2r_debug("completing request %p\n", rq);
1580
1581         scsi_dma_unmap(rq->cmd);
1582
1583         if (unlikely(rq->req_stat != RS_SUCCESS)) {
1584                 esas2r_debug("[%x STATUS %x:%x (%x)]", rq->target_id,
1585                              rq->req_stat,
1586                              rq->func_rsp.scsi_rsp.scsi_stat,
1587                              rq->cmd);
1588
1589                 rq->cmd->result =
1590                         ((esas2r_req_status_to_error(rq->req_stat) << 16)
1591                          | (rq->func_rsp.scsi_rsp.scsi_stat & STATUS_MASK));
1592
1593                 if (rq->req_stat == RS_UNDERRUN)
1594                         scsi_set_resid(rq->cmd,
1595                                        le32_to_cpu(rq->func_rsp.scsi_rsp.
1596                                                    residual_length));
1597                 else
1598                         scsi_set_resid(rq->cmd, 0);
1599         }
1600
1601         rq->cmd->scsi_done(rq->cmd);
1602
1603         esas2r_free_request(a, rq);
1604 }
1605
1606 /* Run tasklet to handle stuff outside of interrupt context. */
1607 void esas2r_adapter_tasklet(unsigned long context)
1608 {
1609         struct esas2r_adapter *a = (struct esas2r_adapter *)context;
1610
1611         if (unlikely(test_bit(AF2_TIMER_TICK, &a->flags2))) {
1612                 clear_bit(AF2_TIMER_TICK, &a->flags2);
1613                 esas2r_timer_tick(a);
1614         }
1615
1616         if (likely(test_bit(AF2_INT_PENDING, &a->flags2))) {
1617                 clear_bit(AF2_INT_PENDING, &a->flags2);
1618                 esas2r_adapter_interrupt(a);
1619         }
1620
1621         if (esas2r_is_tasklet_pending(a))
1622                 esas2r_do_tasklet_tasks(a);
1623
1624         if (esas2r_is_tasklet_pending(a)
1625             || (test_bit(AF2_INT_PENDING, &a->flags2))
1626             || (test_bit(AF2_TIMER_TICK, &a->flags2))) {
1627                 clear_bit(AF_TASKLET_SCHEDULED, &a->flags);
1628                 esas2r_schedule_tasklet(a);
1629         } else {
1630                 clear_bit(AF_TASKLET_SCHEDULED, &a->flags);
1631         }
1632 }
1633
1634 static void esas2r_timer_callback(unsigned long context);
1635
1636 void esas2r_kickoff_timer(struct esas2r_adapter *a)
1637 {
1638         init_timer(&a->timer);
1639
1640         a->timer.function = esas2r_timer_callback;
1641         a->timer.data = (unsigned long)a;
1642         a->timer.expires = jiffies +
1643                            msecs_to_jiffies(100);
1644
1645         add_timer(&a->timer);
1646 }
1647
1648 static void esas2r_timer_callback(unsigned long context)
1649 {
1650         struct esas2r_adapter *a = (struct esas2r_adapter *)context;
1651
1652         set_bit(AF2_TIMER_TICK, &a->flags2);
1653
1654         esas2r_schedule_tasklet(a);
1655
1656         esas2r_kickoff_timer(a);
1657 }
1658
1659 /*
1660  * Firmware events need to be handled outside of interrupt context
1661  * so we schedule a delayed_work to handle them.
1662  */
1663
1664 static void
1665 esas2r_free_fw_event(struct esas2r_fw_event_work *fw_event)
1666 {
1667         unsigned long flags;
1668         struct esas2r_adapter *a = fw_event->a;
1669
1670         spin_lock_irqsave(&a->fw_event_lock, flags);
1671         list_del(&fw_event->list);
1672         kfree(fw_event);
1673         spin_unlock_irqrestore(&a->fw_event_lock, flags);
1674 }
1675
1676 void
1677 esas2r_fw_event_off(struct esas2r_adapter *a)
1678 {
1679         unsigned long flags;
1680
1681         spin_lock_irqsave(&a->fw_event_lock, flags);
1682         a->fw_events_off = 1;
1683         spin_unlock_irqrestore(&a->fw_event_lock, flags);
1684 }
1685
1686 void
1687 esas2r_fw_event_on(struct esas2r_adapter *a)
1688 {
1689         unsigned long flags;
1690
1691         spin_lock_irqsave(&a->fw_event_lock, flags);
1692         a->fw_events_off = 0;
1693         spin_unlock_irqrestore(&a->fw_event_lock, flags);
1694 }
1695
1696 static void esas2r_add_device(struct esas2r_adapter *a, u16 target_id)
1697 {
1698         int ret;
1699         struct scsi_device *scsi_dev;
1700
1701         scsi_dev = scsi_device_lookup(a->host, 0, target_id, 0);
1702
1703         if (scsi_dev) {
1704                 esas2r_log_dev(
1705                         ESAS2R_LOG_WARN,
1706                         &(scsi_dev->
1707                           sdev_gendev),
1708                         "scsi device already exists at id %d", target_id);
1709
1710                 scsi_device_put(scsi_dev);
1711         } else {
1712                 esas2r_log_dev(
1713                         ESAS2R_LOG_INFO,
1714                         &(a->host->
1715                           shost_gendev),
1716                         "scsi_add_device() called for 0:%d:0",
1717                         target_id);
1718
1719                 ret = scsi_add_device(a->host, 0, target_id, 0);
1720                 if (ret) {
1721                         esas2r_log_dev(
1722                                 ESAS2R_LOG_CRIT,
1723                                 &(a->host->
1724                                   shost_gendev),
1725                                 "scsi_add_device failed with %d for id %d",
1726                                 ret, target_id);
1727                 }
1728         }
1729 }
1730
1731 static void esas2r_remove_device(struct esas2r_adapter *a, u16 target_id)
1732 {
1733         struct scsi_device *scsi_dev;
1734
1735         scsi_dev = scsi_device_lookup(a->host, 0, target_id, 0);
1736
1737         if (scsi_dev) {
1738                 scsi_device_set_state(scsi_dev, SDEV_OFFLINE);
1739
1740                 esas2r_log_dev(
1741                         ESAS2R_LOG_INFO,
1742                         &(scsi_dev->
1743                           sdev_gendev),
1744                         "scsi_remove_device() called for 0:%d:0",
1745                         target_id);
1746
1747                 scsi_remove_device(scsi_dev);
1748
1749                 esas2r_log_dev(
1750                         ESAS2R_LOG_INFO,
1751                         &(scsi_dev->
1752                           sdev_gendev),
1753                         "scsi_device_put() called");
1754
1755                 scsi_device_put(scsi_dev);
1756         } else {
1757                 esas2r_log_dev(
1758                         ESAS2R_LOG_WARN,
1759                         &(a->host->shost_gendev),
1760                         "no target found at id %d",
1761                         target_id);
1762         }
1763 }
1764
1765 /*
1766  * Sends a firmware asynchronous event to anyone who happens to be
1767  * listening on the defined ATTO VDA event ports.
1768  */
1769 static void esas2r_send_ae_event(struct esas2r_fw_event_work *fw_event)
1770 {
1771         struct esas2r_vda_ae *ae = (struct esas2r_vda_ae *)fw_event->data;
1772         char *type;
1773
1774         switch (ae->vda_ae.hdr.bytype) {
1775         case VDAAE_HDR_TYPE_RAID:
1776                 type = "RAID group state change";
1777                 break;
1778
1779         case VDAAE_HDR_TYPE_LU:
1780                 type = "Mapped destination LU change";
1781                 break;
1782
1783         case VDAAE_HDR_TYPE_DISK:
1784                 type = "Physical disk inventory change";
1785                 break;
1786
1787         case VDAAE_HDR_TYPE_RESET:
1788                 type = "Firmware reset";
1789                 break;
1790
1791         case VDAAE_HDR_TYPE_LOG_INFO:
1792                 type = "Event Log message (INFO level)";
1793                 break;
1794
1795         case VDAAE_HDR_TYPE_LOG_WARN:
1796                 type = "Event Log message (WARN level)";
1797                 break;
1798
1799         case VDAAE_HDR_TYPE_LOG_CRIT:
1800                 type = "Event Log message (CRIT level)";
1801                 break;
1802
1803         case VDAAE_HDR_TYPE_LOG_FAIL:
1804                 type = "Event Log message (FAIL level)";
1805                 break;
1806
1807         case VDAAE_HDR_TYPE_NVC:
1808                 type = "NVCache change";
1809                 break;
1810
1811         case VDAAE_HDR_TYPE_TLG_INFO:
1812                 type = "Time stamped log message (INFO level)";
1813                 break;
1814
1815         case VDAAE_HDR_TYPE_TLG_WARN:
1816                 type = "Time stamped log message (WARN level)";
1817                 break;
1818
1819         case VDAAE_HDR_TYPE_TLG_CRIT:
1820                 type = "Time stamped log message (CRIT level)";
1821                 break;
1822
1823         case VDAAE_HDR_TYPE_PWRMGT:
1824                 type = "Power management";
1825                 break;
1826
1827         case VDAAE_HDR_TYPE_MUTE:
1828                 type = "Mute button pressed";
1829                 break;
1830
1831         case VDAAE_HDR_TYPE_DEV:
1832                 type = "Device attribute change";
1833                 break;
1834
1835         default:
1836                 type = "Unknown";
1837                 break;
1838         }
1839
1840         esas2r_log(ESAS2R_LOG_WARN,
1841                    "An async event of type \"%s\" was received from the firmware.  The event contents are:",
1842                    type);
1843         esas2r_log_hexdump(ESAS2R_LOG_WARN, &ae->vda_ae,
1844                            ae->vda_ae.hdr.bylength);
1845
1846 }
1847
1848 static void
1849 esas2r_firmware_event_work(struct work_struct *work)
1850 {
1851         struct esas2r_fw_event_work *fw_event =
1852                 container_of(work, struct esas2r_fw_event_work, work.work);
1853
1854         struct esas2r_adapter *a = fw_event->a;
1855
1856         u16 target_id = *(u16 *)&fw_event->data[0];
1857
1858         if (a->fw_events_off)
1859                 goto done;
1860
1861         switch (fw_event->type) {
1862         case fw_event_null:
1863                 break; /* do nothing */
1864
1865         case fw_event_lun_change:
1866                 esas2r_remove_device(a, target_id);
1867                 esas2r_add_device(a, target_id);
1868                 break;
1869
1870         case fw_event_present:
1871                 esas2r_add_device(a, target_id);
1872                 break;
1873
1874         case fw_event_not_present:
1875                 esas2r_remove_device(a, target_id);
1876                 break;
1877
1878         case fw_event_vda_ae:
1879                 esas2r_send_ae_event(fw_event);
1880                 break;
1881         }
1882
1883 done:
1884         esas2r_free_fw_event(fw_event);
1885 }
1886
1887 void esas2r_queue_fw_event(struct esas2r_adapter *a,
1888                            enum fw_event_type type,
1889                            void *data,
1890                            int data_sz)
1891 {
1892         struct esas2r_fw_event_work *fw_event;
1893         unsigned long flags;
1894
1895         fw_event = kzalloc(sizeof(struct esas2r_fw_event_work), GFP_ATOMIC);
1896         if (!fw_event) {
1897                 esas2r_log(ESAS2R_LOG_WARN,
1898                            "esas2r_queue_fw_event failed to alloc");
1899                 return;
1900         }
1901
1902         if (type == fw_event_vda_ae) {
1903                 struct esas2r_vda_ae *ae =
1904                         (struct esas2r_vda_ae *)fw_event->data;
1905
1906                 ae->signature = ESAS2R_VDA_EVENT_SIG;
1907                 ae->bus_number = a->pcid->bus->number;
1908                 ae->devfn = a->pcid->devfn;
1909                 memcpy(&ae->vda_ae, data, sizeof(ae->vda_ae));
1910         } else {
1911                 memcpy(fw_event->data, data, data_sz);
1912         }
1913
1914         fw_event->type = type;
1915         fw_event->a = a;
1916
1917         spin_lock_irqsave(&a->fw_event_lock, flags);
1918         list_add_tail(&fw_event->list, &a->fw_event_list);
1919         INIT_DELAYED_WORK(&fw_event->work, esas2r_firmware_event_work);
1920         queue_delayed_work_on(
1921                 smp_processor_id(), a->fw_event_q, &fw_event->work,
1922                 msecs_to_jiffies(1));
1923         spin_unlock_irqrestore(&a->fw_event_lock, flags);
1924 }
1925
1926 void esas2r_target_state_changed(struct esas2r_adapter *a, u16 targ_id,
1927                                  u8 state)
1928 {
1929         if (state == TS_LUN_CHANGE)
1930                 esas2r_queue_fw_event(a, fw_event_lun_change, &targ_id,
1931                                       sizeof(targ_id));
1932         else if (state == TS_PRESENT)
1933                 esas2r_queue_fw_event(a, fw_event_present, &targ_id,
1934                                       sizeof(targ_id));
1935         else if (state == TS_NOT_PRESENT)
1936                 esas2r_queue_fw_event(a, fw_event_not_present, &targ_id,
1937                                       sizeof(targ_id));
1938 }
1939
1940 /* Translate status to a Linux SCSI mid-layer error code */
1941 int esas2r_req_status_to_error(u8 req_stat)
1942 {
1943         switch (req_stat) {
1944         case RS_OVERRUN:
1945         case RS_UNDERRUN:
1946         case RS_SUCCESS:
1947         /*
1948          * NOTE: SCSI mid-layer wants a good status for a SCSI error, because
1949          *       it will check the scsi_stat value in the completion anyway.
1950          */
1951         case RS_SCSI_ERROR:
1952                 return DID_OK;
1953
1954         case RS_SEL:
1955         case RS_SEL2:
1956                 return DID_NO_CONNECT;
1957
1958         case RS_RESET:
1959                 return DID_RESET;
1960
1961         case RS_ABORTED:
1962                 return DID_ABORT;
1963
1964         case RS_BUSY:
1965                 return DID_BUS_BUSY;
1966         }
1967
1968         /* everything else is just an error. */
1969
1970         return DID_ERROR;
1971 }
1972
1973 module_init(esas2r_init);
1974 module_exit(esas2r_exit);