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