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