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