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