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