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