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