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