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 if (asd_ha->hw_prof.ddb_bitmap) 569 kfree(asd_ha->hw_prof.ddb_bitmap); 570 asd_ha->hw_prof.ddb_bitmap = NULL; 571 572 for (i = 0; i < ASD_MAX_PHYS; i++) { 573 struct asd_phy *phy = &asd_ha->phys[i]; 574 575 asd_free_coherent(asd_ha, phy->id_frm_tok); 576 } 577 if (asd_ha->seq.escb_arr) 578 asd_free_escbs(asd_ha); 579 if (asd_ha->seq.edb_arr) 580 asd_free_edbs(asd_ha); 581 if (asd_ha->hw_prof.ue.area) { 582 kfree(asd_ha->hw_prof.ue.area); 583 asd_ha->hw_prof.ue.area = NULL; 584 } 585 if (asd_ha->seq.tc_index_array) { 586 kfree(asd_ha->seq.tc_index_array); 587 kfree(asd_ha->seq.tc_index_bitmap); 588 asd_ha->seq.tc_index_array = NULL; 589 asd_ha->seq.tc_index_bitmap = NULL; 590 } 591 if (asd_ha->seq.actual_dl) { 592 asd_free_coherent(asd_ha, asd_ha->seq.actual_dl); 593 asd_ha->seq.actual_dl = NULL; 594 asd_ha->seq.dl = NULL; 595 } 596 if (asd_ha->seq.next_scb.vaddr) { 597 dma_pool_free(asd_ha->scb_pool, asd_ha->seq.next_scb.vaddr, 598 asd_ha->seq.next_scb.dma_handle); 599 asd_ha->seq.next_scb.vaddr = NULL; 600 } 601 dma_pool_destroy(asd_ha->scb_pool); 602 asd_ha->scb_pool = NULL; 603 } 604 605 struct kmem_cache *asd_dma_token_cache; 606 struct kmem_cache *asd_ascb_cache; 607 608 static int asd_create_global_caches(void) 609 { 610 if (!asd_dma_token_cache) { 611 asd_dma_token_cache 612 = kmem_cache_create(ASD_DRIVER_NAME "_dma_token", 613 sizeof(struct asd_dma_tok), 614 0, 615 SLAB_HWCACHE_ALIGN, 616 NULL); 617 if (!asd_dma_token_cache) { 618 asd_printk("couldn't create dma token cache\n"); 619 return -ENOMEM; 620 } 621 } 622 623 if (!asd_ascb_cache) { 624 asd_ascb_cache = kmem_cache_create(ASD_DRIVER_NAME "_ascb", 625 sizeof(struct asd_ascb), 626 0, 627 SLAB_HWCACHE_ALIGN, 628 NULL); 629 if (!asd_ascb_cache) { 630 asd_printk("couldn't create ascb cache\n"); 631 goto Err; 632 } 633 } 634 635 return 0; 636 Err: 637 kmem_cache_destroy(asd_dma_token_cache); 638 asd_dma_token_cache = NULL; 639 return -ENOMEM; 640 } 641 642 static void asd_destroy_global_caches(void) 643 { 644 if (asd_dma_token_cache) 645 kmem_cache_destroy(asd_dma_token_cache); 646 asd_dma_token_cache = NULL; 647 648 if (asd_ascb_cache) 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