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