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