1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Aic94xx SAS/SATA driver initialization. 4 * 5 * Copyright (C) 2005 Adaptec, Inc. All rights reserved. 6 * Copyright (C) 2005 Luben Tuikov <luben_tuikov@adaptec.com> 7 */ 8 9 #include <linux/module.h> 10 #include <linux/init.h> 11 #include <linux/kernel.h> 12 #include <linux/pci.h> 13 #include <linux/delay.h> 14 #include <linux/firmware.h> 15 #include <linux/slab.h> 16 17 #include <scsi/scsi_host.h> 18 19 #include "aic94xx.h" 20 #include "aic94xx_reg.h" 21 #include "aic94xx_hwi.h" 22 #include "aic94xx_seq.h" 23 #include "aic94xx_sds.h" 24 25 /* The format is "version.release.patchlevel" */ 26 #define ASD_DRIVER_VERSION "1.0.3" 27 28 static int use_msi = 0; 29 module_param_named(use_msi, use_msi, int, S_IRUGO); 30 MODULE_PARM_DESC(use_msi, "\n" 31 "\tEnable(1) or disable(0) using PCI MSI.\n" 32 "\tDefault: 0"); 33 34 static struct scsi_transport_template *aic94xx_transport_template; 35 static int asd_scan_finished(struct Scsi_Host *, unsigned long); 36 static void asd_scan_start(struct Scsi_Host *); 37 38 static struct scsi_host_template aic94xx_sht = { 39 .module = THIS_MODULE, 40 /* .name is initialized */ 41 .name = "aic94xx", 42 .queuecommand = sas_queuecommand, 43 .target_alloc = sas_target_alloc, 44 .slave_configure = sas_slave_configure, 45 .scan_finished = asd_scan_finished, 46 .scan_start = asd_scan_start, 47 .change_queue_depth = sas_change_queue_depth, 48 .bios_param = sas_bios_param, 49 .can_queue = 1, 50 .this_id = -1, 51 .sg_tablesize = SG_ALL, 52 .max_sectors = SCSI_DEFAULT_MAX_SECTORS, 53 .eh_device_reset_handler = sas_eh_device_reset_handler, 54 .eh_target_reset_handler = sas_eh_target_reset_handler, 55 .target_destroy = sas_target_destroy, 56 .ioctl = sas_ioctl, 57 #ifdef CONFIG_COMPAT 58 .compat_ioctl = sas_ioctl, 59 #endif 60 .track_queue_depth = 1, 61 }; 62 63 static int asd_map_memio(struct asd_ha_struct *asd_ha) 64 { 65 int err, i; 66 struct asd_ha_addrspace *io_handle; 67 68 asd_ha->iospace = 0; 69 for (i = 0; i < 3; i += 2) { 70 io_handle = &asd_ha->io_handle[i==0?0:1]; 71 io_handle->start = pci_resource_start(asd_ha->pcidev, i); 72 io_handle->len = pci_resource_len(asd_ha->pcidev, i); 73 io_handle->flags = pci_resource_flags(asd_ha->pcidev, i); 74 err = -ENODEV; 75 if (!io_handle->start || !io_handle->len) { 76 asd_printk("MBAR%d start or length for %s is 0.\n", 77 i==0?0:1, pci_name(asd_ha->pcidev)); 78 goto Err; 79 } 80 err = pci_request_region(asd_ha->pcidev, i, ASD_DRIVER_NAME); 81 if (err) { 82 asd_printk("couldn't reserve memory region for %s\n", 83 pci_name(asd_ha->pcidev)); 84 goto Err; 85 } 86 io_handle->addr = ioremap(io_handle->start, io_handle->len); 87 if (!io_handle->addr) { 88 asd_printk("couldn't map MBAR%d of %s\n", i==0?0:1, 89 pci_name(asd_ha->pcidev)); 90 err = -ENOMEM; 91 goto Err_unreq; 92 } 93 } 94 95 return 0; 96 Err_unreq: 97 pci_release_region(asd_ha->pcidev, i); 98 Err: 99 if (i > 0) { 100 io_handle = &asd_ha->io_handle[0]; 101 iounmap(io_handle->addr); 102 pci_release_region(asd_ha->pcidev, 0); 103 } 104 return err; 105 } 106 107 static void asd_unmap_memio(struct asd_ha_struct *asd_ha) 108 { 109 struct asd_ha_addrspace *io_handle; 110 111 io_handle = &asd_ha->io_handle[1]; 112 iounmap(io_handle->addr); 113 pci_release_region(asd_ha->pcidev, 2); 114 115 io_handle = &asd_ha->io_handle[0]; 116 iounmap(io_handle->addr); 117 pci_release_region(asd_ha->pcidev, 0); 118 } 119 120 static int asd_map_ioport(struct asd_ha_struct *asd_ha) 121 { 122 int i = PCI_IOBAR_OFFSET, err; 123 struct asd_ha_addrspace *io_handle = &asd_ha->io_handle[0]; 124 125 asd_ha->iospace = 1; 126 io_handle->start = pci_resource_start(asd_ha->pcidev, i); 127 io_handle->len = pci_resource_len(asd_ha->pcidev, i); 128 io_handle->flags = pci_resource_flags(asd_ha->pcidev, i); 129 io_handle->addr = (void __iomem *) io_handle->start; 130 if (!io_handle->start || !io_handle->len) { 131 asd_printk("couldn't get IO ports for %s\n", 132 pci_name(asd_ha->pcidev)); 133 return -ENODEV; 134 } 135 err = pci_request_region(asd_ha->pcidev, i, ASD_DRIVER_NAME); 136 if (err) { 137 asd_printk("couldn't reserve io space for %s\n", 138 pci_name(asd_ha->pcidev)); 139 } 140 141 return err; 142 } 143 144 static void asd_unmap_ioport(struct asd_ha_struct *asd_ha) 145 { 146 pci_release_region(asd_ha->pcidev, PCI_IOBAR_OFFSET); 147 } 148 149 static int asd_map_ha(struct asd_ha_struct *asd_ha) 150 { 151 int err; 152 u16 cmd_reg; 153 154 err = pci_read_config_word(asd_ha->pcidev, PCI_COMMAND, &cmd_reg); 155 if (err) { 156 asd_printk("couldn't read command register of %s\n", 157 pci_name(asd_ha->pcidev)); 158 goto Err; 159 } 160 161 err = -ENODEV; 162 if (cmd_reg & PCI_COMMAND_MEMORY) { 163 if ((err = asd_map_memio(asd_ha))) 164 goto Err; 165 } else if (cmd_reg & PCI_COMMAND_IO) { 166 if ((err = asd_map_ioport(asd_ha))) 167 goto Err; 168 asd_printk("%s ioport mapped -- upgrade your hardware\n", 169 pci_name(asd_ha->pcidev)); 170 } else { 171 asd_printk("no proper device access to %s\n", 172 pci_name(asd_ha->pcidev)); 173 goto Err; 174 } 175 176 return 0; 177 Err: 178 return err; 179 } 180 181 static void asd_unmap_ha(struct asd_ha_struct *asd_ha) 182 { 183 if (asd_ha->iospace) 184 asd_unmap_ioport(asd_ha); 185 else 186 asd_unmap_memio(asd_ha); 187 } 188 189 static const char *asd_dev_rev[30] = { 190 [0] = "A0", 191 [1] = "A1", 192 [8] = "B0", 193 }; 194 195 static int asd_common_setup(struct asd_ha_struct *asd_ha) 196 { 197 int err, i; 198 199 asd_ha->revision_id = asd_ha->pcidev->revision; 200 201 err = -ENODEV; 202 if (asd_ha->revision_id < AIC9410_DEV_REV_B0) { 203 asd_printk("%s is revision %s (%X), which is not supported\n", 204 pci_name(asd_ha->pcidev), 205 asd_dev_rev[asd_ha->revision_id], 206 asd_ha->revision_id); 207 goto Err; 208 } 209 /* Provide some sane default values. */ 210 asd_ha->hw_prof.max_scbs = 512; 211 asd_ha->hw_prof.max_ddbs = ASD_MAX_DDBS; 212 asd_ha->hw_prof.num_phys = ASD_MAX_PHYS; 213 /* All phys are enabled, by default. */ 214 asd_ha->hw_prof.enabled_phys = 0xFF; 215 for (i = 0; i < ASD_MAX_PHYS; i++) { 216 asd_ha->hw_prof.phy_desc[i].max_sas_lrate = 217 SAS_LINK_RATE_3_0_GBPS; 218 asd_ha->hw_prof.phy_desc[i].min_sas_lrate = 219 SAS_LINK_RATE_1_5_GBPS; 220 asd_ha->hw_prof.phy_desc[i].max_sata_lrate = 221 SAS_LINK_RATE_1_5_GBPS; 222 asd_ha->hw_prof.phy_desc[i].min_sata_lrate = 223 SAS_LINK_RATE_1_5_GBPS; 224 } 225 226 return 0; 227 Err: 228 return err; 229 } 230 231 static int asd_aic9410_setup(struct asd_ha_struct *asd_ha) 232 { 233 int err = asd_common_setup(asd_ha); 234 235 if (err) 236 return err; 237 238 asd_ha->hw_prof.addr_range = 8; 239 asd_ha->hw_prof.port_name_base = 0; 240 asd_ha->hw_prof.dev_name_base = 8; 241 asd_ha->hw_prof.sata_name_base = 16; 242 243 return 0; 244 } 245 246 static int asd_aic9405_setup(struct asd_ha_struct *asd_ha) 247 { 248 int err = asd_common_setup(asd_ha); 249 250 if (err) 251 return err; 252 253 asd_ha->hw_prof.addr_range = 4; 254 asd_ha->hw_prof.port_name_base = 0; 255 asd_ha->hw_prof.dev_name_base = 4; 256 asd_ha->hw_prof.sata_name_base = 8; 257 258 return 0; 259 } 260 261 static ssize_t asd_show_dev_rev(struct device *dev, 262 struct device_attribute *attr, char *buf) 263 { 264 struct asd_ha_struct *asd_ha = dev_to_asd_ha(dev); 265 return snprintf(buf, PAGE_SIZE, "%s\n", 266 asd_dev_rev[asd_ha->revision_id]); 267 } 268 static DEVICE_ATTR(aic_revision, S_IRUGO, asd_show_dev_rev, NULL); 269 270 static ssize_t asd_show_dev_bios_build(struct device *dev, 271 struct device_attribute *attr,char *buf) 272 { 273 struct asd_ha_struct *asd_ha = dev_to_asd_ha(dev); 274 return snprintf(buf, PAGE_SIZE, "%d\n", asd_ha->hw_prof.bios.bld); 275 } 276 static DEVICE_ATTR(bios_build, S_IRUGO, asd_show_dev_bios_build, NULL); 277 278 static ssize_t asd_show_dev_pcba_sn(struct device *dev, 279 struct device_attribute *attr, char *buf) 280 { 281 struct asd_ha_struct *asd_ha = dev_to_asd_ha(dev); 282 return snprintf(buf, PAGE_SIZE, "%s\n", asd_ha->hw_prof.pcba_sn); 283 } 284 static DEVICE_ATTR(pcba_sn, S_IRUGO, asd_show_dev_pcba_sn, NULL); 285 286 #define FLASH_CMD_NONE 0x00 287 #define FLASH_CMD_UPDATE 0x01 288 #define FLASH_CMD_VERIFY 0x02 289 290 struct flash_command { 291 u8 command[8]; 292 int code; 293 }; 294 295 static struct flash_command flash_command_table[] = 296 { 297 {"verify", FLASH_CMD_VERIFY}, 298 {"update", FLASH_CMD_UPDATE}, 299 {"", FLASH_CMD_NONE} /* Last entry should be NULL. */ 300 }; 301 302 struct error_bios { 303 char *reason; 304 int err_code; 305 }; 306 307 static struct error_bios flash_error_table[] = 308 { 309 {"Failed to open bios image file", FAIL_OPEN_BIOS_FILE}, 310 {"PCI ID mismatch", FAIL_CHECK_PCI_ID}, 311 {"Checksum mismatch", FAIL_CHECK_SUM}, 312 {"Unknown Error", FAIL_UNKNOWN}, 313 {"Failed to verify.", FAIL_VERIFY}, 314 {"Failed to reset flash chip.", FAIL_RESET_FLASH}, 315 {"Failed to find flash chip type.", FAIL_FIND_FLASH_ID}, 316 {"Failed to erash flash chip.", FAIL_ERASE_FLASH}, 317 {"Failed to program flash chip.", FAIL_WRITE_FLASH}, 318 {"Flash in progress", FLASH_IN_PROGRESS}, 319 {"Image file size Error", FAIL_FILE_SIZE}, 320 {"Input parameter error", FAIL_PARAMETERS}, 321 {"Out of memory", FAIL_OUT_MEMORY}, 322 {"OK", 0} /* Last entry err_code = 0. */ 323 }; 324 325 static ssize_t asd_store_update_bios(struct device *dev, 326 struct device_attribute *attr, 327 const char *buf, size_t count) 328 { 329 struct asd_ha_struct *asd_ha = dev_to_asd_ha(dev); 330 char *cmd_ptr, *filename_ptr; 331 struct bios_file_header header, *hdr_ptr; 332 int res, i; 333 u32 csum = 0; 334 int flash_command = FLASH_CMD_NONE; 335 int err = 0; 336 337 cmd_ptr = kcalloc(count, 2, GFP_KERNEL); 338 339 if (!cmd_ptr) { 340 err = FAIL_OUT_MEMORY; 341 goto out; 342 } 343 344 filename_ptr = cmd_ptr + count; 345 res = sscanf(buf, "%s %s", cmd_ptr, filename_ptr); 346 if (res != 2) { 347 err = FAIL_PARAMETERS; 348 goto out1; 349 } 350 351 for (i = 0; flash_command_table[i].code != FLASH_CMD_NONE; i++) { 352 if (!memcmp(flash_command_table[i].command, 353 cmd_ptr, strlen(cmd_ptr))) { 354 flash_command = flash_command_table[i].code; 355 break; 356 } 357 } 358 if (flash_command == FLASH_CMD_NONE) { 359 err = FAIL_PARAMETERS; 360 goto out1; 361 } 362 363 if (asd_ha->bios_status == FLASH_IN_PROGRESS) { 364 err = FLASH_IN_PROGRESS; 365 goto out1; 366 } 367 err = request_firmware(&asd_ha->bios_image, 368 filename_ptr, 369 &asd_ha->pcidev->dev); 370 if (err) { 371 asd_printk("Failed to load bios image file %s, error %d\n", 372 filename_ptr, err); 373 err = FAIL_OPEN_BIOS_FILE; 374 goto out1; 375 } 376 377 hdr_ptr = (struct bios_file_header *)asd_ha->bios_image->data; 378 379 if ((hdr_ptr->contrl_id.vendor != asd_ha->pcidev->vendor || 380 hdr_ptr->contrl_id.device != asd_ha->pcidev->device) && 381 (hdr_ptr->contrl_id.sub_vendor != asd_ha->pcidev->vendor || 382 hdr_ptr->contrl_id.sub_device != asd_ha->pcidev->device)) { 383 384 ASD_DPRINTK("The PCI vendor or device id does not match\n"); 385 ASD_DPRINTK("vendor=%x dev=%x sub_vendor=%x sub_dev=%x" 386 " pci vendor=%x pci dev=%x\n", 387 hdr_ptr->contrl_id.vendor, 388 hdr_ptr->contrl_id.device, 389 hdr_ptr->contrl_id.sub_vendor, 390 hdr_ptr->contrl_id.sub_device, 391 asd_ha->pcidev->vendor, 392 asd_ha->pcidev->device); 393 err = FAIL_CHECK_PCI_ID; 394 goto out2; 395 } 396 397 if (hdr_ptr->filelen != asd_ha->bios_image->size) { 398 err = FAIL_FILE_SIZE; 399 goto out2; 400 } 401 402 /* calculate checksum */ 403 for (i = 0; i < hdr_ptr->filelen; i++) 404 csum += asd_ha->bios_image->data[i]; 405 406 if ((csum & 0x0000ffff) != hdr_ptr->checksum) { 407 ASD_DPRINTK("BIOS file checksum mismatch\n"); 408 err = FAIL_CHECK_SUM; 409 goto out2; 410 } 411 if (flash_command == FLASH_CMD_UPDATE) { 412 asd_ha->bios_status = FLASH_IN_PROGRESS; 413 err = asd_write_flash_seg(asd_ha, 414 &asd_ha->bios_image->data[sizeof(*hdr_ptr)], 415 0, hdr_ptr->filelen-sizeof(*hdr_ptr)); 416 if (!err) 417 err = asd_verify_flash_seg(asd_ha, 418 &asd_ha->bios_image->data[sizeof(*hdr_ptr)], 419 0, hdr_ptr->filelen-sizeof(*hdr_ptr)); 420 } else { 421 asd_ha->bios_status = FLASH_IN_PROGRESS; 422 err = asd_verify_flash_seg(asd_ha, 423 &asd_ha->bios_image->data[sizeof(header)], 424 0, hdr_ptr->filelen-sizeof(header)); 425 } 426 427 out2: 428 release_firmware(asd_ha->bios_image); 429 out1: 430 kfree(cmd_ptr); 431 out: 432 asd_ha->bios_status = err; 433 434 if (!err) 435 return count; 436 else 437 return -err; 438 } 439 440 static ssize_t asd_show_update_bios(struct device *dev, 441 struct device_attribute *attr, char *buf) 442 { 443 int i; 444 struct asd_ha_struct *asd_ha = dev_to_asd_ha(dev); 445 446 for (i = 0; flash_error_table[i].err_code != 0; i++) { 447 if (flash_error_table[i].err_code == asd_ha->bios_status) 448 break; 449 } 450 if (asd_ha->bios_status != FLASH_IN_PROGRESS) 451 asd_ha->bios_status = FLASH_OK; 452 453 return snprintf(buf, PAGE_SIZE, "status=%x %s\n", 454 flash_error_table[i].err_code, 455 flash_error_table[i].reason); 456 } 457 458 static DEVICE_ATTR(update_bios, S_IRUGO|S_IWUSR, 459 asd_show_update_bios, asd_store_update_bios); 460 461 static int asd_create_dev_attrs(struct asd_ha_struct *asd_ha) 462 { 463 int err; 464 465 err = device_create_file(&asd_ha->pcidev->dev, &dev_attr_aic_revision); 466 if (err) 467 return err; 468 469 err = device_create_file(&asd_ha->pcidev->dev, &dev_attr_bios_build); 470 if (err) 471 goto err_rev; 472 473 err = device_create_file(&asd_ha->pcidev->dev, &dev_attr_pcba_sn); 474 if (err) 475 goto err_biosb; 476 err = device_create_file(&asd_ha->pcidev->dev, &dev_attr_update_bios); 477 if (err) 478 goto err_update_bios; 479 480 return 0; 481 482 err_update_bios: 483 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_pcba_sn); 484 err_biosb: 485 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_bios_build); 486 err_rev: 487 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_aic_revision); 488 return err; 489 } 490 491 static void asd_remove_dev_attrs(struct asd_ha_struct *asd_ha) 492 { 493 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_aic_revision); 494 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_bios_build); 495 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_pcba_sn); 496 device_remove_file(&asd_ha->pcidev->dev, &dev_attr_update_bios); 497 } 498 499 /* The first entry, 0, is used for dynamic ids, the rest for devices 500 * we know about. 501 */ 502 static const struct asd_pcidev_struct { 503 const char * name; 504 int (*setup)(struct asd_ha_struct *asd_ha); 505 } asd_pcidev_data[] = { 506 /* Id 0 is used for dynamic ids. */ 507 { .name = "Adaptec AIC-94xx SAS/SATA Host Adapter", 508 .setup = asd_aic9410_setup 509 }, 510 { .name = "Adaptec AIC-9410W SAS/SATA Host Adapter", 511 .setup = asd_aic9410_setup 512 }, 513 { .name = "Adaptec AIC-9405W SAS/SATA Host Adapter", 514 .setup = asd_aic9405_setup 515 }, 516 }; 517 518 static int asd_create_ha_caches(struct asd_ha_struct *asd_ha) 519 { 520 asd_ha->scb_pool = dma_pool_create(ASD_DRIVER_NAME "_scb_pool", 521 &asd_ha->pcidev->dev, 522 sizeof(struct scb), 523 8, 0); 524 if (!asd_ha->scb_pool) { 525 asd_printk("couldn't create scb pool\n"); 526 return -ENOMEM; 527 } 528 529 return 0; 530 } 531 532 /** 533 * asd_free_edbs -- free empty data buffers 534 * asd_ha: pointer to host adapter structure 535 */ 536 static void asd_free_edbs(struct asd_ha_struct *asd_ha) 537 { 538 struct asd_seq_data *seq = &asd_ha->seq; 539 int i; 540 541 for (i = 0; i < seq->num_edbs; i++) 542 asd_free_coherent(asd_ha, seq->edb_arr[i]); 543 kfree(seq->edb_arr); 544 seq->edb_arr = NULL; 545 } 546 547 static void asd_free_escbs(struct asd_ha_struct *asd_ha) 548 { 549 struct asd_seq_data *seq = &asd_ha->seq; 550 int i; 551 552 for (i = 0; i < seq->num_escbs; i++) { 553 if (!list_empty(&seq->escb_arr[i]->list)) 554 list_del_init(&seq->escb_arr[i]->list); 555 556 asd_ascb_free(seq->escb_arr[i]); 557 } 558 kfree(seq->escb_arr); 559 seq->escb_arr = NULL; 560 } 561 562 static void asd_destroy_ha_caches(struct asd_ha_struct *asd_ha) 563 { 564 int i; 565 566 if (asd_ha->hw_prof.ddb_ext) 567 asd_free_coherent(asd_ha, asd_ha->hw_prof.ddb_ext); 568 if (asd_ha->hw_prof.scb_ext) 569 asd_free_coherent(asd_ha, asd_ha->hw_prof.scb_ext); 570 571 kfree(asd_ha->hw_prof.ddb_bitmap); 572 asd_ha->hw_prof.ddb_bitmap = NULL; 573 574 for (i = 0; i < ASD_MAX_PHYS; i++) { 575 struct asd_phy *phy = &asd_ha->phys[i]; 576 577 asd_free_coherent(asd_ha, phy->id_frm_tok); 578 } 579 if (asd_ha->seq.escb_arr) 580 asd_free_escbs(asd_ha); 581 if (asd_ha->seq.edb_arr) 582 asd_free_edbs(asd_ha); 583 if (asd_ha->hw_prof.ue.area) { 584 kfree(asd_ha->hw_prof.ue.area); 585 asd_ha->hw_prof.ue.area = NULL; 586 } 587 if (asd_ha->seq.tc_index_array) { 588 kfree(asd_ha->seq.tc_index_array); 589 kfree(asd_ha->seq.tc_index_bitmap); 590 asd_ha->seq.tc_index_array = NULL; 591 asd_ha->seq.tc_index_bitmap = NULL; 592 } 593 if (asd_ha->seq.actual_dl) { 594 asd_free_coherent(asd_ha, asd_ha->seq.actual_dl); 595 asd_ha->seq.actual_dl = NULL; 596 asd_ha->seq.dl = NULL; 597 } 598 if (asd_ha->seq.next_scb.vaddr) { 599 dma_pool_free(asd_ha->scb_pool, asd_ha->seq.next_scb.vaddr, 600 asd_ha->seq.next_scb.dma_handle); 601 asd_ha->seq.next_scb.vaddr = NULL; 602 } 603 dma_pool_destroy(asd_ha->scb_pool); 604 asd_ha->scb_pool = NULL; 605 } 606 607 struct kmem_cache *asd_dma_token_cache; 608 struct kmem_cache *asd_ascb_cache; 609 610 static int asd_create_global_caches(void) 611 { 612 if (!asd_dma_token_cache) { 613 asd_dma_token_cache 614 = kmem_cache_create(ASD_DRIVER_NAME "_dma_token", 615 sizeof(struct asd_dma_tok), 616 0, 617 SLAB_HWCACHE_ALIGN, 618 NULL); 619 if (!asd_dma_token_cache) { 620 asd_printk("couldn't create dma token cache\n"); 621 return -ENOMEM; 622 } 623 } 624 625 if (!asd_ascb_cache) { 626 asd_ascb_cache = kmem_cache_create(ASD_DRIVER_NAME "_ascb", 627 sizeof(struct asd_ascb), 628 0, 629 SLAB_HWCACHE_ALIGN, 630 NULL); 631 if (!asd_ascb_cache) { 632 asd_printk("couldn't create ascb cache\n"); 633 goto Err; 634 } 635 } 636 637 return 0; 638 Err: 639 kmem_cache_destroy(asd_dma_token_cache); 640 asd_dma_token_cache = NULL; 641 return -ENOMEM; 642 } 643 644 static void asd_destroy_global_caches(void) 645 { 646 kmem_cache_destroy(asd_dma_token_cache); 647 asd_dma_token_cache = NULL; 648 649 kmem_cache_destroy(asd_ascb_cache); 650 asd_ascb_cache = NULL; 651 } 652 653 static int asd_register_sas_ha(struct asd_ha_struct *asd_ha) 654 { 655 int i; 656 struct asd_sas_phy **sas_phys = 657 kcalloc(ASD_MAX_PHYS, sizeof(*sas_phys), GFP_KERNEL); 658 struct asd_sas_port **sas_ports = 659 kcalloc(ASD_MAX_PHYS, sizeof(*sas_ports), GFP_KERNEL); 660 661 if (!sas_phys || !sas_ports) { 662 kfree(sas_phys); 663 kfree(sas_ports); 664 return -ENOMEM; 665 } 666 667 asd_ha->sas_ha.sas_ha_name = (char *) asd_ha->name; 668 asd_ha->sas_ha.lldd_module = THIS_MODULE; 669 asd_ha->sas_ha.sas_addr = &asd_ha->hw_prof.sas_addr[0]; 670 671 for (i = 0; i < ASD_MAX_PHYS; i++) { 672 sas_phys[i] = &asd_ha->phys[i].sas_phy; 673 sas_ports[i] = &asd_ha->ports[i]; 674 } 675 676 asd_ha->sas_ha.sas_phy = sas_phys; 677 asd_ha->sas_ha.sas_port= sas_ports; 678 asd_ha->sas_ha.num_phys= ASD_MAX_PHYS; 679 680 return sas_register_ha(&asd_ha->sas_ha); 681 } 682 683 static int asd_unregister_sas_ha(struct asd_ha_struct *asd_ha) 684 { 685 int err; 686 687 err = sas_unregister_ha(&asd_ha->sas_ha); 688 689 sas_remove_host(asd_ha->sas_ha.core.shost); 690 scsi_host_put(asd_ha->sas_ha.core.shost); 691 692 kfree(asd_ha->sas_ha.sas_phy); 693 kfree(asd_ha->sas_ha.sas_port); 694 695 return err; 696 } 697 698 static int asd_pci_probe(struct pci_dev *dev, const struct pci_device_id *id) 699 { 700 const struct asd_pcidev_struct *asd_dev; 701 unsigned asd_id = (unsigned) id->driver_data; 702 struct asd_ha_struct *asd_ha; 703 struct Scsi_Host *shost; 704 int err; 705 706 if (asd_id >= ARRAY_SIZE(asd_pcidev_data)) { 707 asd_printk("wrong driver_data in PCI table\n"); 708 return -ENODEV; 709 } 710 711 if ((err = pci_enable_device(dev))) { 712 asd_printk("couldn't enable device %s\n", pci_name(dev)); 713 return err; 714 } 715 716 pci_set_master(dev); 717 718 err = -ENOMEM; 719 720 shost = scsi_host_alloc(&aic94xx_sht, sizeof(void *)); 721 if (!shost) 722 goto Err; 723 724 asd_dev = &asd_pcidev_data[asd_id]; 725 726 asd_ha = kzalloc(sizeof(*asd_ha), GFP_KERNEL); 727 if (!asd_ha) { 728 asd_printk("out of memory\n"); 729 goto Err_put; 730 } 731 asd_ha->pcidev = dev; 732 asd_ha->sas_ha.dev = &asd_ha->pcidev->dev; 733 asd_ha->sas_ha.lldd_ha = asd_ha; 734 735 asd_ha->bios_status = FLASH_OK; 736 asd_ha->name = asd_dev->name; 737 asd_printk("found %s, device %s\n", asd_ha->name, pci_name(dev)); 738 739 SHOST_TO_SAS_HA(shost) = &asd_ha->sas_ha; 740 asd_ha->sas_ha.core.shost = shost; 741 shost->transportt = aic94xx_transport_template; 742 shost->max_id = ~0; 743 shost->max_lun = ~0; 744 shost->max_cmd_len = 16; 745 746 err = scsi_add_host(shost, &dev->dev); 747 if (err) 748 goto Err_free; 749 750 err = asd_dev->setup(asd_ha); 751 if (err) 752 goto Err_remove; 753 754 err = dma_set_mask_and_coherent(&dev->dev, DMA_BIT_MASK(64)); 755 if (err) 756 err = dma_set_mask_and_coherent(&dev->dev, DMA_BIT_MASK(32)); 757 if (err) { 758 err = -ENODEV; 759 asd_printk("no suitable DMA mask for %s\n", pci_name(dev)); 760 goto Err_remove; 761 } 762 763 pci_set_drvdata(dev, asd_ha); 764 765 err = asd_map_ha(asd_ha); 766 if (err) 767 goto Err_remove; 768 769 err = asd_create_ha_caches(asd_ha); 770 if (err) 771 goto Err_unmap; 772 773 err = asd_init_hw(asd_ha); 774 if (err) 775 goto Err_free_cache; 776 777 asd_printk("device %s: SAS addr %llx, PCBA SN %s, %d phys, %d enabled " 778 "phys, flash %s, BIOS %s%d\n", 779 pci_name(dev), SAS_ADDR(asd_ha->hw_prof.sas_addr), 780 asd_ha->hw_prof.pcba_sn, asd_ha->hw_prof.max_phys, 781 asd_ha->hw_prof.num_phys, 782 asd_ha->hw_prof.flash.present ? "present" : "not present", 783 asd_ha->hw_prof.bios.present ? "build " : "not present", 784 asd_ha->hw_prof.bios.bld); 785 786 shost->can_queue = asd_ha->seq.can_queue; 787 788 if (use_msi) 789 pci_enable_msi(asd_ha->pcidev); 790 791 err = request_irq(asd_ha->pcidev->irq, asd_hw_isr, IRQF_SHARED, 792 ASD_DRIVER_NAME, asd_ha); 793 if (err) { 794 asd_printk("couldn't get irq %d for %s\n", 795 asd_ha->pcidev->irq, pci_name(asd_ha->pcidev)); 796 goto Err_irq; 797 } 798 asd_enable_ints(asd_ha); 799 800 err = asd_init_post_escbs(asd_ha); 801 if (err) { 802 asd_printk("couldn't post escbs for %s\n", 803 pci_name(asd_ha->pcidev)); 804 goto Err_escbs; 805 } 806 ASD_DPRINTK("escbs posted\n"); 807 808 err = asd_create_dev_attrs(asd_ha); 809 if (err) 810 goto Err_dev_attrs; 811 812 err = asd_register_sas_ha(asd_ha); 813 if (err) 814 goto Err_reg_sas; 815 816 scsi_scan_host(shost); 817 818 return 0; 819 820 Err_reg_sas: 821 asd_remove_dev_attrs(asd_ha); 822 Err_dev_attrs: 823 Err_escbs: 824 asd_disable_ints(asd_ha); 825 free_irq(dev->irq, asd_ha); 826 Err_irq: 827 if (use_msi) 828 pci_disable_msi(dev); 829 asd_chip_hardrst(asd_ha); 830 Err_free_cache: 831 asd_destroy_ha_caches(asd_ha); 832 Err_unmap: 833 asd_unmap_ha(asd_ha); 834 Err_remove: 835 scsi_remove_host(shost); 836 Err_free: 837 kfree(asd_ha); 838 Err_put: 839 scsi_host_put(shost); 840 Err: 841 pci_disable_device(dev); 842 return err; 843 } 844 845 static void asd_free_queues(struct asd_ha_struct *asd_ha) 846 { 847 unsigned long flags; 848 LIST_HEAD(pending); 849 struct list_head *n, *pos; 850 851 spin_lock_irqsave(&asd_ha->seq.pend_q_lock, flags); 852 asd_ha->seq.pending = 0; 853 list_splice_init(&asd_ha->seq.pend_q, &pending); 854 spin_unlock_irqrestore(&asd_ha->seq.pend_q_lock, flags); 855 856 if (!list_empty(&pending)) 857 ASD_DPRINTK("Uh-oh! Pending is not empty!\n"); 858 859 list_for_each_safe(pos, n, &pending) { 860 struct asd_ascb *ascb = list_entry(pos, struct asd_ascb, list); 861 /* 862 * Delete unexpired ascb timers. This may happen if we issue 863 * a CONTROL PHY scb to an adapter and rmmod before the scb 864 * times out. Apparently we don't wait for the CONTROL PHY 865 * to complete, so it doesn't matter if we kill the timer. 866 */ 867 del_timer_sync(&ascb->timer); 868 WARN_ON(ascb->scb->header.opcode != CONTROL_PHY); 869 870 list_del_init(pos); 871 ASD_DPRINTK("freeing from pending\n"); 872 asd_ascb_free(ascb); 873 } 874 } 875 876 static void asd_turn_off_leds(struct asd_ha_struct *asd_ha) 877 { 878 u8 phy_mask = asd_ha->hw_prof.enabled_phys; 879 u8 i; 880 881 for_each_phy(phy_mask, phy_mask, i) { 882 asd_turn_led(asd_ha, i, 0); 883 asd_control_led(asd_ha, i, 0); 884 } 885 } 886 887 static void asd_pci_remove(struct pci_dev *dev) 888 { 889 struct asd_ha_struct *asd_ha = pci_get_drvdata(dev); 890 891 if (!asd_ha) 892 return; 893 894 asd_unregister_sas_ha(asd_ha); 895 896 asd_disable_ints(asd_ha); 897 898 asd_remove_dev_attrs(asd_ha); 899 900 /* XXX more here as needed */ 901 902 free_irq(dev->irq, asd_ha); 903 if (use_msi) 904 pci_disable_msi(asd_ha->pcidev); 905 asd_turn_off_leds(asd_ha); 906 asd_chip_hardrst(asd_ha); 907 asd_free_queues(asd_ha); 908 asd_destroy_ha_caches(asd_ha); 909 asd_unmap_ha(asd_ha); 910 kfree(asd_ha); 911 pci_disable_device(dev); 912 return; 913 } 914 915 static void asd_scan_start(struct Scsi_Host *shost) 916 { 917 struct asd_ha_struct *asd_ha; 918 int err; 919 920 asd_ha = SHOST_TO_SAS_HA(shost)->lldd_ha; 921 err = asd_enable_phys(asd_ha, asd_ha->hw_prof.enabled_phys); 922 if (err) 923 asd_printk("Couldn't enable phys, err:%d\n", err); 924 } 925 926 static int asd_scan_finished(struct Scsi_Host *shost, unsigned long time) 927 { 928 /* give the phy enabling interrupt event time to come in (1s 929 * is empirically about all it takes) */ 930 if (time < HZ) 931 return 0; 932 /* Wait for discovery to finish */ 933 sas_drain_work(SHOST_TO_SAS_HA(shost)); 934 return 1; 935 } 936 937 static ssize_t version_show(struct device_driver *driver, char *buf) 938 { 939 return snprintf(buf, PAGE_SIZE, "%s\n", ASD_DRIVER_VERSION); 940 } 941 static DRIVER_ATTR_RO(version); 942 943 static int asd_create_driver_attrs(struct device_driver *driver) 944 { 945 return driver_create_file(driver, &driver_attr_version); 946 } 947 948 static void asd_remove_driver_attrs(struct device_driver *driver) 949 { 950 driver_remove_file(driver, &driver_attr_version); 951 } 952 953 static struct sas_domain_function_template aic94xx_transport_functions = { 954 .lldd_dev_found = asd_dev_found, 955 .lldd_dev_gone = asd_dev_gone, 956 957 .lldd_execute_task = asd_execute_task, 958 959 .lldd_abort_task = asd_abort_task, 960 .lldd_abort_task_set = asd_abort_task_set, 961 .lldd_clear_aca = asd_clear_aca, 962 .lldd_clear_task_set = asd_clear_task_set, 963 .lldd_I_T_nexus_reset = asd_I_T_nexus_reset, 964 .lldd_lu_reset = asd_lu_reset, 965 .lldd_query_task = asd_query_task, 966 967 .lldd_clear_nexus_port = asd_clear_nexus_port, 968 .lldd_clear_nexus_ha = asd_clear_nexus_ha, 969 970 .lldd_control_phy = asd_control_phy, 971 972 .lldd_ata_set_dmamode = asd_set_dmamode, 973 }; 974 975 static const struct pci_device_id aic94xx_pci_table[] = { 976 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x410),0, 0, 1}, 977 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x412),0, 0, 1}, 978 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x416),0, 0, 1}, 979 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x41E),0, 0, 1}, 980 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x41F),0, 0, 1}, 981 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x430),0, 0, 2}, 982 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x432),0, 0, 2}, 983 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x43E),0, 0, 2}, 984 {PCI_DEVICE(PCI_VENDOR_ID_ADAPTEC2, 0x43F),0, 0, 2}, 985 {} 986 }; 987 988 MODULE_DEVICE_TABLE(pci, aic94xx_pci_table); 989 990 static struct pci_driver aic94xx_pci_driver = { 991 .name = ASD_DRIVER_NAME, 992 .id_table = aic94xx_pci_table, 993 .probe = asd_pci_probe, 994 .remove = asd_pci_remove, 995 }; 996 997 static int __init aic94xx_init(void) 998 { 999 int err; 1000 1001 1002 asd_printk("%s version %s loaded\n", ASD_DRIVER_DESCRIPTION, 1003 ASD_DRIVER_VERSION); 1004 1005 err = asd_create_global_caches(); 1006 if (err) 1007 return err; 1008 1009 aic94xx_transport_template = 1010 sas_domain_attach_transport(&aic94xx_transport_functions); 1011 if (!aic94xx_transport_template) { 1012 err = -ENOMEM; 1013 goto out_destroy_caches; 1014 } 1015 1016 err = pci_register_driver(&aic94xx_pci_driver); 1017 if (err) 1018 goto out_release_transport; 1019 1020 err = asd_create_driver_attrs(&aic94xx_pci_driver.driver); 1021 if (err) 1022 goto out_unregister_pcidrv; 1023 1024 return err; 1025 1026 out_unregister_pcidrv: 1027 pci_unregister_driver(&aic94xx_pci_driver); 1028 out_release_transport: 1029 sas_release_transport(aic94xx_transport_template); 1030 out_destroy_caches: 1031 asd_destroy_global_caches(); 1032 1033 return err; 1034 } 1035 1036 static void __exit aic94xx_exit(void) 1037 { 1038 asd_remove_driver_attrs(&aic94xx_pci_driver.driver); 1039 pci_unregister_driver(&aic94xx_pci_driver); 1040 sas_release_transport(aic94xx_transport_template); 1041 asd_release_firmware(); 1042 asd_destroy_global_caches(); 1043 asd_printk("%s version %s unloaded\n", ASD_DRIVER_DESCRIPTION, 1044 ASD_DRIVER_VERSION); 1045 } 1046 1047 module_init(aic94xx_init); 1048 module_exit(aic94xx_exit); 1049 1050 MODULE_AUTHOR("Luben Tuikov <luben_tuikov@adaptec.com>"); 1051 MODULE_DESCRIPTION(ASD_DRIVER_DESCRIPTION); 1052 MODULE_LICENSE("GPL v2"); 1053 MODULE_VERSION(ASD_DRIVER_VERSION); 1054