1 /* 2 * This file is provided under a dual BSD/GPLv2 license. When using or 3 * redistributing this file, you may do so under either license. 4 * 5 * GPL LICENSE SUMMARY 6 * 7 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of version 2 of the GNU General Public License as 11 * published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. 21 * The full GNU General Public License is included in this distribution 22 * in the file called LICENSE.GPL. 23 * 24 * BSD LICENSE 25 * 26 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. 27 * All rights reserved. 28 * 29 * Redistribution and use in source and binary forms, with or without 30 * modification, are permitted provided that the following conditions 31 * are met: 32 * 33 * * Redistributions of source code must retain the above copyright 34 * notice, this list of conditions and the following disclaimer. 35 * * Redistributions in binary form must reproduce the above copyright 36 * notice, this list of conditions and the following disclaimer in 37 * the documentation and/or other materials provided with the 38 * distribution. 39 * * Neither the name of Intel Corporation nor the names of its 40 * contributors may be used to endorse or promote products derived 41 * from this software without specific prior written permission. 42 * 43 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 44 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 45 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 46 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 47 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 48 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 49 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 50 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 51 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 52 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 53 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 54 */ 55 56 #include <linux/kernel.h> 57 #include <linux/init.h> 58 #include <linux/module.h> 59 #include <linux/firmware.h> 60 #include <linux/efi.h> 61 #include <asm/string.h> 62 #include "isci.h" 63 #include "task.h" 64 #include "probe_roms.h" 65 66 static struct scsi_transport_template *isci_transport_template; 67 68 static DEFINE_PCI_DEVICE_TABLE(isci_id_table) = { 69 { PCI_VDEVICE(INTEL, 0x1D61),}, 70 { PCI_VDEVICE(INTEL, 0x1D63),}, 71 { PCI_VDEVICE(INTEL, 0x1D65),}, 72 { PCI_VDEVICE(INTEL, 0x1D67),}, 73 { PCI_VDEVICE(INTEL, 0x1D69),}, 74 { PCI_VDEVICE(INTEL, 0x1D6B),}, 75 { PCI_VDEVICE(INTEL, 0x1D60),}, 76 { PCI_VDEVICE(INTEL, 0x1D62),}, 77 { PCI_VDEVICE(INTEL, 0x1D64),}, 78 { PCI_VDEVICE(INTEL, 0x1D66),}, 79 { PCI_VDEVICE(INTEL, 0x1D68),}, 80 { PCI_VDEVICE(INTEL, 0x1D6A),}, 81 {} 82 }; 83 84 MODULE_DEVICE_TABLE(pci, isci_id_table); 85 86 /* linux isci specific settings */ 87 88 int isci_si_rev = ISCI_SI_REVA2; 89 module_param(isci_si_rev, int, 0); 90 MODULE_PARM_DESC(isci_si_rev, "(deprecated) override default si rev (0: A0 1: A2 2: B0)"); 91 92 unsigned char no_outbound_task_to = 20; 93 module_param(no_outbound_task_to, byte, 0); 94 MODULE_PARM_DESC(no_outbound_task_to, "No Outbound Task Timeout (1us incr)"); 95 96 u16 ssp_max_occ_to = 20; 97 module_param(ssp_max_occ_to, ushort, 0); 98 MODULE_PARM_DESC(ssp_max_occ_to, "SSP Max occupancy timeout (100us incr)"); 99 100 u16 stp_max_occ_to = 5; 101 module_param(stp_max_occ_to, ushort, 0); 102 MODULE_PARM_DESC(stp_max_occ_to, "STP Max occupancy timeout (100us incr)"); 103 104 u16 ssp_inactive_to = 5; 105 module_param(ssp_inactive_to, ushort, 0); 106 MODULE_PARM_DESC(ssp_inactive_to, "SSP inactivity timeout (100us incr)"); 107 108 u16 stp_inactive_to = 5; 109 module_param(stp_inactive_to, ushort, 0); 110 MODULE_PARM_DESC(stp_inactive_to, "STP inactivity timeout (100us incr)"); 111 112 unsigned char phy_gen = 3; 113 module_param(phy_gen, byte, 0); 114 MODULE_PARM_DESC(phy_gen, "PHY generation (1: 1.5Gbps 2: 3.0Gbps 3: 6.0Gbps)"); 115 116 unsigned char max_concurr_spinup = 1; 117 module_param(max_concurr_spinup, byte, 0); 118 MODULE_PARM_DESC(max_concurr_spinup, "Max concurrent device spinup"); 119 120 static struct scsi_host_template isci_sht = { 121 122 .module = THIS_MODULE, 123 .name = DRV_NAME, 124 .proc_name = DRV_NAME, 125 .queuecommand = sas_queuecommand, 126 .target_alloc = sas_target_alloc, 127 .slave_configure = sas_slave_configure, 128 .slave_destroy = sas_slave_destroy, 129 .scan_finished = isci_host_scan_finished, 130 .scan_start = isci_host_scan_start, 131 .change_queue_depth = sas_change_queue_depth, 132 .change_queue_type = sas_change_queue_type, 133 .bios_param = sas_bios_param, 134 .can_queue = ISCI_CAN_QUEUE_VAL, 135 .cmd_per_lun = 1, 136 .this_id = -1, 137 .sg_tablesize = SG_ALL, 138 .max_sectors = SCSI_DEFAULT_MAX_SECTORS, 139 .use_clustering = ENABLE_CLUSTERING, 140 .eh_device_reset_handler = sas_eh_device_reset_handler, 141 .eh_bus_reset_handler = isci_bus_reset_handler, 142 .slave_alloc = sas_slave_alloc, 143 .target_destroy = sas_target_destroy, 144 .ioctl = sas_ioctl, 145 }; 146 147 static struct sas_domain_function_template isci_transport_ops = { 148 149 /* The class calls these to notify the LLDD of an event. */ 150 .lldd_port_formed = isci_port_formed, 151 .lldd_port_deformed = isci_port_deformed, 152 153 /* The class calls these when a device is found or gone. */ 154 .lldd_dev_found = isci_remote_device_found, 155 .lldd_dev_gone = isci_remote_device_gone, 156 157 .lldd_execute_task = isci_task_execute_task, 158 /* Task Management Functions. Must be called from process context. */ 159 .lldd_abort_task = isci_task_abort_task, 160 .lldd_abort_task_set = isci_task_abort_task_set, 161 .lldd_clear_aca = isci_task_clear_aca, 162 .lldd_clear_task_set = isci_task_clear_task_set, 163 .lldd_I_T_nexus_reset = isci_task_I_T_nexus_reset, 164 .lldd_lu_reset = isci_task_lu_reset, 165 .lldd_query_task = isci_task_query_task, 166 167 /* Port and Adapter management */ 168 .lldd_clear_nexus_port = isci_task_clear_nexus_port, 169 .lldd_clear_nexus_ha = isci_task_clear_nexus_ha, 170 171 /* Phy management */ 172 .lldd_control_phy = isci_phy_control, 173 }; 174 175 176 /****************************************************************************** 177 * P R O T E C T E D M E T H O D S 178 ******************************************************************************/ 179 180 181 182 /** 183 * isci_register_sas_ha() - This method initializes various lldd 184 * specific members of the sas_ha struct and calls the libsas 185 * sas_register_ha() function. 186 * @isci_host: This parameter specifies the lldd specific wrapper for the 187 * libsas sas_ha struct. 188 * 189 * This method returns an error code indicating sucess or failure. The user 190 * should check for possible memory allocation error return otherwise, a zero 191 * indicates success. 192 */ 193 static int isci_register_sas_ha(struct isci_host *isci_host) 194 { 195 int i; 196 struct sas_ha_struct *sas_ha = &(isci_host->sas_ha); 197 struct asd_sas_phy **sas_phys; 198 struct asd_sas_port **sas_ports; 199 200 sas_phys = devm_kzalloc(&isci_host->pdev->dev, 201 SCI_MAX_PHYS * sizeof(void *), 202 GFP_KERNEL); 203 if (!sas_phys) 204 return -ENOMEM; 205 206 sas_ports = devm_kzalloc(&isci_host->pdev->dev, 207 SCI_MAX_PORTS * sizeof(void *), 208 GFP_KERNEL); 209 if (!sas_ports) 210 return -ENOMEM; 211 212 /*----------------- Libsas Initialization Stuff---------------------- 213 * Set various fields in the sas_ha struct: 214 */ 215 216 sas_ha->sas_ha_name = DRV_NAME; 217 sas_ha->lldd_module = THIS_MODULE; 218 sas_ha->sas_addr = &isci_host->phys[0].sas_addr[0]; 219 220 /* set the array of phy and port structs. */ 221 for (i = 0; i < SCI_MAX_PHYS; i++) { 222 sas_phys[i] = &isci_host->phys[i].sas_phy; 223 sas_ports[i] = &isci_host->ports[i].sas_port; 224 } 225 226 sas_ha->sas_phy = sas_phys; 227 sas_ha->sas_port = sas_ports; 228 sas_ha->num_phys = SCI_MAX_PHYS; 229 230 sas_ha->lldd_queue_size = ISCI_CAN_QUEUE_VAL; 231 sas_ha->lldd_max_execute_num = 1; 232 sas_ha->strict_wide_ports = 1; 233 234 sas_register_ha(sas_ha); 235 236 return 0; 237 } 238 239 static ssize_t isci_show_id(struct device *dev, struct device_attribute *attr, char *buf) 240 { 241 struct Scsi_Host *shost = container_of(dev, typeof(*shost), shost_dev); 242 struct sas_ha_struct *sas_ha = SHOST_TO_SAS_HA(shost); 243 struct isci_host *ihost = container_of(sas_ha, typeof(*ihost), sas_ha); 244 245 return snprintf(buf, PAGE_SIZE, "%d\n", ihost->id); 246 } 247 248 static DEVICE_ATTR(isci_id, S_IRUGO, isci_show_id, NULL); 249 250 static void isci_unregister(struct isci_host *isci_host) 251 { 252 struct Scsi_Host *shost; 253 254 if (!isci_host) 255 return; 256 257 shost = isci_host->shost; 258 device_remove_file(&shost->shost_dev, &dev_attr_isci_id); 259 260 sas_unregister_ha(&isci_host->sas_ha); 261 262 sas_remove_host(isci_host->shost); 263 scsi_remove_host(isci_host->shost); 264 scsi_host_put(isci_host->shost); 265 } 266 267 static int __devinit isci_pci_init(struct pci_dev *pdev) 268 { 269 int err, bar_num, bar_mask = 0; 270 void __iomem * const *iomap; 271 272 err = pcim_enable_device(pdev); 273 if (err) { 274 dev_err(&pdev->dev, 275 "failed enable PCI device %s!\n", 276 pci_name(pdev)); 277 return err; 278 } 279 280 for (bar_num = 0; bar_num < SCI_PCI_BAR_COUNT; bar_num++) 281 bar_mask |= 1 << (bar_num * 2); 282 283 err = pcim_iomap_regions(pdev, bar_mask, DRV_NAME); 284 if (err) 285 return err; 286 287 iomap = pcim_iomap_table(pdev); 288 if (!iomap) 289 return -ENOMEM; 290 291 pci_set_master(pdev); 292 293 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64)); 294 if (err) { 295 err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)); 296 if (err) 297 return err; 298 } 299 300 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)); 301 if (err) { 302 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)); 303 if (err) 304 return err; 305 } 306 307 return 0; 308 } 309 310 static int num_controllers(struct pci_dev *pdev) 311 { 312 /* bar size alone can tell us if we are running with a dual controller 313 * part, no need to trust revision ids that might be under broken firmware 314 * control 315 */ 316 resource_size_t scu_bar_size = pci_resource_len(pdev, SCI_SCU_BAR*2); 317 resource_size_t smu_bar_size = pci_resource_len(pdev, SCI_SMU_BAR*2); 318 319 if (scu_bar_size >= SCI_SCU_BAR_SIZE*SCI_MAX_CONTROLLERS && 320 smu_bar_size >= SCI_SMU_BAR_SIZE*SCI_MAX_CONTROLLERS) 321 return SCI_MAX_CONTROLLERS; 322 else 323 return 1; 324 } 325 326 static int isci_setup_interrupts(struct pci_dev *pdev) 327 { 328 int err, i, num_msix; 329 struct isci_host *ihost; 330 struct isci_pci_info *pci_info = to_pci_info(pdev); 331 332 /* 333 * Determine the number of vectors associated with this 334 * PCI function. 335 */ 336 num_msix = num_controllers(pdev) * SCI_NUM_MSI_X_INT; 337 338 for (i = 0; i < num_msix; i++) 339 pci_info->msix_entries[i].entry = i; 340 341 err = pci_enable_msix(pdev, pci_info->msix_entries, num_msix); 342 if (err) 343 goto intx; 344 345 for (i = 0; i < num_msix; i++) { 346 int id = i / SCI_NUM_MSI_X_INT; 347 struct msix_entry *msix = &pci_info->msix_entries[i]; 348 irq_handler_t isr; 349 350 ihost = pci_info->hosts[id]; 351 /* odd numbered vectors are error interrupts */ 352 if (i & 1) 353 isr = isci_error_isr; 354 else 355 isr = isci_msix_isr; 356 357 err = devm_request_irq(&pdev->dev, msix->vector, isr, 0, 358 DRV_NAME"-msix", ihost); 359 if (!err) 360 continue; 361 362 dev_info(&pdev->dev, "msix setup failed falling back to intx\n"); 363 while (i--) { 364 id = i / SCI_NUM_MSI_X_INT; 365 ihost = pci_info->hosts[id]; 366 msix = &pci_info->msix_entries[i]; 367 devm_free_irq(&pdev->dev, msix->vector, ihost); 368 } 369 pci_disable_msix(pdev); 370 goto intx; 371 } 372 return 0; 373 374 intx: 375 for_each_isci_host(i, ihost, pdev) { 376 err = devm_request_irq(&pdev->dev, pdev->irq, isci_intx_isr, 377 IRQF_SHARED, DRV_NAME"-intx", ihost); 378 if (err) 379 break; 380 } 381 return err; 382 } 383 384 static struct isci_host *isci_host_alloc(struct pci_dev *pdev, int id) 385 { 386 struct isci_host *isci_host; 387 struct Scsi_Host *shost; 388 int err; 389 390 isci_host = devm_kzalloc(&pdev->dev, sizeof(*isci_host), GFP_KERNEL); 391 if (!isci_host) 392 return NULL; 393 394 isci_host->pdev = pdev; 395 isci_host->id = id; 396 397 shost = scsi_host_alloc(&isci_sht, sizeof(void *)); 398 if (!shost) 399 return NULL; 400 isci_host->shost = shost; 401 402 err = isci_host_init(isci_host); 403 if (err) 404 goto err_shost; 405 406 SHOST_TO_SAS_HA(shost) = &isci_host->sas_ha; 407 isci_host->sas_ha.core.shost = shost; 408 shost->transportt = isci_transport_template; 409 410 shost->max_id = ~0; 411 shost->max_lun = ~0; 412 shost->max_cmd_len = MAX_COMMAND_SIZE; 413 414 err = scsi_add_host(shost, &pdev->dev); 415 if (err) 416 goto err_shost; 417 418 err = isci_register_sas_ha(isci_host); 419 if (err) 420 goto err_shost_remove; 421 422 err = device_create_file(&shost->shost_dev, &dev_attr_isci_id); 423 if (err) 424 goto err_unregister_ha; 425 426 return isci_host; 427 428 err_unregister_ha: 429 sas_unregister_ha(&(isci_host->sas_ha)); 430 err_shost_remove: 431 scsi_remove_host(shost); 432 err_shost: 433 scsi_host_put(shost); 434 435 return NULL; 436 } 437 438 static void check_si_rev(struct pci_dev *pdev) 439 { 440 switch (pdev->revision) { 441 case 0: 442 case 1: 443 /* if the id is ambiguous don't update isci_si_rev */ 444 break; 445 case 3: 446 isci_si_rev = ISCI_SI_REVA2; 447 break; 448 case 4: 449 isci_si_rev = ISCI_SI_REVB0; 450 break; 451 default: 452 case 5: 453 isci_si_rev = ISCI_SI_REVC0; 454 break; 455 } 456 457 dev_info(&pdev->dev, "driver configured for %s silicon (rev: %d)\n", 458 isci_si_rev == ISCI_SI_REVA0 ? "A0" : 459 isci_si_rev == ISCI_SI_REVA2 ? "A2" : 460 isci_si_rev == ISCI_SI_REVB0 ? "B0" : "C0", pdev->revision); 461 462 } 463 464 static int __devinit isci_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id) 465 { 466 struct isci_pci_info *pci_info; 467 int err, i; 468 struct isci_host *isci_host; 469 const struct firmware *fw = NULL; 470 struct isci_orom *orom = NULL; 471 char *source = "(platform)"; 472 473 check_si_rev(pdev); 474 475 pci_info = devm_kzalloc(&pdev->dev, sizeof(*pci_info), GFP_KERNEL); 476 if (!pci_info) 477 return -ENOMEM; 478 pci_set_drvdata(pdev, pci_info); 479 480 if (efi_enabled) 481 orom = isci_get_efi_var(pdev); 482 483 if (!orom) 484 orom = isci_request_oprom(pdev); 485 486 for (i = 0; orom && i < ARRAY_SIZE(orom->ctrl); i++) { 487 if (sci_oem_parameters_validate(&orom->ctrl[i])) { 488 dev_warn(&pdev->dev, 489 "[%d]: invalid oem parameters detected, falling back to firmware\n", i); 490 devm_kfree(&pdev->dev, orom); 491 orom = NULL; 492 break; 493 } 494 } 495 496 if (!orom) { 497 source = "(firmware)"; 498 orom = isci_request_firmware(pdev, fw); 499 if (!orom) { 500 /* TODO convert this to WARN_TAINT_ONCE once the 501 * orom/efi parameter support is widely available 502 */ 503 dev_warn(&pdev->dev, 504 "Loading user firmware failed, using default " 505 "values\n"); 506 dev_warn(&pdev->dev, 507 "Default OEM configuration being used: 4 " 508 "narrow ports, and default SAS Addresses\n"); 509 } 510 } 511 512 if (orom) 513 dev_info(&pdev->dev, 514 "OEM SAS parameters (version: %u.%u) loaded %s\n", 515 (orom->hdr.version & 0xf0) >> 4, 516 (orom->hdr.version & 0xf), source); 517 518 pci_info->orom = orom; 519 520 err = isci_pci_init(pdev); 521 if (err) 522 return err; 523 524 for (i = 0; i < num_controllers(pdev); i++) { 525 struct isci_host *h = isci_host_alloc(pdev, i); 526 527 if (!h) { 528 err = -ENOMEM; 529 goto err_host_alloc; 530 } 531 pci_info->hosts[i] = h; 532 } 533 534 err = isci_setup_interrupts(pdev); 535 if (err) 536 goto err_host_alloc; 537 538 for_each_isci_host(i, isci_host, pdev) 539 scsi_scan_host(isci_host->shost); 540 541 return 0; 542 543 err_host_alloc: 544 for_each_isci_host(i, isci_host, pdev) 545 isci_unregister(isci_host); 546 return err; 547 } 548 549 static void __devexit isci_pci_remove(struct pci_dev *pdev) 550 { 551 struct isci_host *ihost; 552 int i; 553 554 for_each_isci_host(i, ihost, pdev) { 555 isci_unregister(ihost); 556 isci_host_deinit(ihost); 557 sci_controller_disable_interrupts(ihost); 558 } 559 } 560 561 static struct pci_driver isci_pci_driver = { 562 .name = DRV_NAME, 563 .id_table = isci_id_table, 564 .probe = isci_pci_probe, 565 .remove = __devexit_p(isci_pci_remove), 566 }; 567 568 static __init int isci_init(void) 569 { 570 int err; 571 572 pr_info("%s: Intel(R) C600 SAS Controller Driver\n", DRV_NAME); 573 574 isci_transport_template = sas_domain_attach_transport(&isci_transport_ops); 575 if (!isci_transport_template) 576 return -ENOMEM; 577 578 err = pci_register_driver(&isci_pci_driver); 579 if (err) 580 sas_release_transport(isci_transport_template); 581 582 return err; 583 } 584 585 static __exit void isci_exit(void) 586 { 587 pci_unregister_driver(&isci_pci_driver); 588 sas_release_transport(isci_transport_template); 589 } 590 591 MODULE_LICENSE("Dual BSD/GPL"); 592 MODULE_FIRMWARE(ISCI_FW_NAME); 593 module_init(isci_init); 594 module_exit(isci_exit); 595