1 /* 2 * linux/drivers/message/fusion/mptsas.c 3 * For use with LSI Logic PCI chip/adapter(s) 4 * running LSI Logic Fusion MPT (Message Passing Technology) firmware. 5 * 6 * Copyright (c) 1999-2005 LSI Logic Corporation 7 * (mailto:mpt_linux_developer@lsil.com) 8 * Copyright (c) 2005-2006 Dell 9 */ 10 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 11 /* 12 This program is free software; you can redistribute it and/or modify 13 it under the terms of the GNU General Public License as published by 14 the Free Software Foundation; version 2 of the License. 15 16 This program 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 19 GNU General Public License for more details. 20 21 NO WARRANTY 22 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 23 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 24 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 25 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 26 solely responsible for determining the appropriateness of using and 27 distributing the Program and assumes all risks associated with its 28 exercise of rights under this Agreement, including but not limited to 29 the risks and costs of program errors, damage to or loss of data, 30 programs or equipment, and unavailability or interruption of operations. 31 32 DISCLAIMER OF LIABILITY 33 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 34 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 35 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 36 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 37 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 38 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 39 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 40 41 You should have received a copy of the GNU General Public License 42 along with this program; if not, write to the Free Software 43 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 44 */ 45 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 46 47 #include <linux/module.h> 48 #include <linux/kernel.h> 49 #include <linux/init.h> 50 #include <linux/errno.h> 51 #include <linux/sched.h> 52 #include <linux/workqueue.h> 53 54 #include <scsi/scsi_cmnd.h> 55 #include <scsi/scsi_device.h> 56 #include <scsi/scsi_host.h> 57 #include <scsi/scsi_transport_sas.h> 58 59 #include "mptbase.h" 60 #include "mptscsih.h" 61 62 63 #define my_NAME "Fusion MPT SAS Host driver" 64 #define my_VERSION MPT_LINUX_VERSION_COMMON 65 #define MYNAM "mptsas" 66 67 MODULE_AUTHOR(MODULEAUTHOR); 68 MODULE_DESCRIPTION(my_NAME); 69 MODULE_LICENSE("GPL"); 70 71 static int mpt_pq_filter; 72 module_param(mpt_pq_filter, int, 0); 73 MODULE_PARM_DESC(mpt_pq_filter, 74 "Enable peripheral qualifier filter: enable=1 " 75 "(default=0)"); 76 77 static int mpt_pt_clear; 78 module_param(mpt_pt_clear, int, 0); 79 MODULE_PARM_DESC(mpt_pt_clear, 80 "Clear persistency table: enable=1 " 81 "(default=MPTSCSIH_PT_CLEAR=0)"); 82 83 static int mptsasDoneCtx = -1; 84 static int mptsasTaskCtx = -1; 85 static int mptsasInternalCtx = -1; /* Used only for internal commands */ 86 static int mptsasMgmtCtx = -1; 87 88 89 enum mptsas_hotplug_action { 90 MPTSAS_ADD_DEVICE, 91 MPTSAS_DEL_DEVICE, 92 MPTSAS_ADD_RAID, 93 MPTSAS_DEL_RAID, 94 MPTSAS_IGNORE_EVENT, 95 }; 96 97 struct mptsas_hotplug_event { 98 struct work_struct work; 99 MPT_ADAPTER *ioc; 100 enum mptsas_hotplug_action event_type; 101 u64 sas_address; 102 u32 channel; 103 u32 id; 104 u32 device_info; 105 u16 handle; 106 u16 parent_handle; 107 u8 phy_id; 108 u8 phys_disk_num; 109 u8 phys_disk_num_valid; 110 }; 111 112 struct mptsas_discovery_event { 113 struct work_struct work; 114 MPT_ADAPTER *ioc; 115 }; 116 117 /* 118 * SAS topology structures 119 * 120 * The MPT Fusion firmware interface spreads information about the 121 * SAS topology over many manufacture pages, thus we need some data 122 * structure to collect it and process it for the SAS transport class. 123 */ 124 125 struct mptsas_devinfo { 126 u16 handle; /* unique id to address this device */ 127 u16 handle_parent; /* unique id to address parent device */ 128 u16 handle_enclosure; /* enclosure identifier of the enclosure */ 129 u16 slot; /* physical slot in enclosure */ 130 u8 phy_id; /* phy number of parent device */ 131 u8 port_id; /* sas physical port this device 132 is assoc'd with */ 133 u8 id; /* logical target id of this device */ 134 u8 channel; /* logical bus number of this device */ 135 u64 sas_address; /* WWN of this device, 136 SATA is assigned by HBA,expander */ 137 u32 device_info; /* bitfield detailed info about this device */ 138 }; 139 140 struct mptsas_phyinfo { 141 u8 phy_id; /* phy index */ 142 u8 port_id; /* port number this phy is part of */ 143 u8 negotiated_link_rate; /* nego'd link rate for this phy */ 144 u8 hw_link_rate; /* hardware max/min phys link rate */ 145 u8 programmed_link_rate; /* programmed max/min phy link rate */ 146 struct mptsas_devinfo identify; /* point to phy device info */ 147 struct mptsas_devinfo attached; /* point to attached device info */ 148 struct sas_phy *phy; 149 struct sas_rphy *rphy; 150 struct scsi_target *starget; 151 }; 152 153 struct mptsas_portinfo { 154 struct list_head list; 155 u16 handle; /* unique id to address this */ 156 u8 num_phys; /* number of phys */ 157 struct mptsas_phyinfo *phy_info; 158 }; 159 160 struct mptsas_enclosure { 161 u64 enclosure_logical_id; /* The WWN for the enclosure */ 162 u16 enclosure_handle; /* unique id to address this */ 163 u16 flags; /* details enclosure management */ 164 u16 num_slot; /* num slots */ 165 u16 start_slot; /* first slot */ 166 u8 start_id; /* starting logical target id */ 167 u8 start_channel; /* starting logical channel id */ 168 u8 sep_id; /* SEP device logical target id */ 169 u8 sep_channel; /* SEP channel logical channel id */ 170 }; 171 172 #ifdef SASDEBUG 173 static void mptsas_print_phy_data(MPI_SAS_IO_UNIT0_PHY_DATA *phy_data) 174 { 175 printk("---- IO UNIT PAGE 0 ------------\n"); 176 printk("Handle=0x%X\n", 177 le16_to_cpu(phy_data->AttachedDeviceHandle)); 178 printk("Controller Handle=0x%X\n", 179 le16_to_cpu(phy_data->ControllerDevHandle)); 180 printk("Port=0x%X\n", phy_data->Port); 181 printk("Port Flags=0x%X\n", phy_data->PortFlags); 182 printk("PHY Flags=0x%X\n", phy_data->PhyFlags); 183 printk("Negotiated Link Rate=0x%X\n", phy_data->NegotiatedLinkRate); 184 printk("Controller PHY Device Info=0x%X\n", 185 le32_to_cpu(phy_data->ControllerPhyDeviceInfo)); 186 printk("DiscoveryStatus=0x%X\n", 187 le32_to_cpu(phy_data->DiscoveryStatus)); 188 printk("\n"); 189 } 190 191 static void mptsas_print_phy_pg0(SasPhyPage0_t *pg0) 192 { 193 __le64 sas_address; 194 195 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64)); 196 197 printk("---- SAS PHY PAGE 0 ------------\n"); 198 printk("Attached Device Handle=0x%X\n", 199 le16_to_cpu(pg0->AttachedDevHandle)); 200 printk("SAS Address=0x%llX\n", 201 (unsigned long long)le64_to_cpu(sas_address)); 202 printk("Attached PHY Identifier=0x%X\n", pg0->AttachedPhyIdentifier); 203 printk("Attached Device Info=0x%X\n", 204 le32_to_cpu(pg0->AttachedDeviceInfo)); 205 printk("Programmed Link Rate=0x%X\n", pg0->ProgrammedLinkRate); 206 printk("Change Count=0x%X\n", pg0->ChangeCount); 207 printk("PHY Info=0x%X\n", le32_to_cpu(pg0->PhyInfo)); 208 printk("\n"); 209 } 210 211 static void mptsas_print_phy_pg1(SasPhyPage1_t *pg1) 212 { 213 printk("---- SAS PHY PAGE 1 ------------\n"); 214 printk("Invalid Dword Count=0x%x\n", pg1->InvalidDwordCount); 215 printk("Running Disparity Error Count=0x%x\n", 216 pg1->RunningDisparityErrorCount); 217 printk("Loss Dword Synch Count=0x%x\n", pg1->LossDwordSynchCount); 218 printk("PHY Reset Problem Count=0x%x\n", pg1->PhyResetProblemCount); 219 printk("\n"); 220 } 221 222 static void mptsas_print_device_pg0(SasDevicePage0_t *pg0) 223 { 224 __le64 sas_address; 225 226 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64)); 227 228 printk("---- SAS DEVICE PAGE 0 ---------\n"); 229 printk("Handle=0x%X\n" ,le16_to_cpu(pg0->DevHandle)); 230 printk("Parent Handle=0x%X\n" ,le16_to_cpu(pg0->ParentDevHandle)); 231 printk("Enclosure Handle=0x%X\n", le16_to_cpu(pg0->EnclosureHandle)); 232 printk("Slot=0x%X\n", le16_to_cpu(pg0->Slot)); 233 printk("SAS Address=0x%llX\n", le64_to_cpu(sas_address)); 234 printk("Target ID=0x%X\n", pg0->TargetID); 235 printk("Bus=0x%X\n", pg0->Bus); 236 /* The PhyNum field specifies the PHY number of the parent 237 * device this device is linked to 238 */ 239 printk("Parent Phy Num=0x%X\n", pg0->PhyNum); 240 printk("Access Status=0x%X\n", le16_to_cpu(pg0->AccessStatus)); 241 printk("Device Info=0x%X\n", le32_to_cpu(pg0->DeviceInfo)); 242 printk("Flags=0x%X\n", le16_to_cpu(pg0->Flags)); 243 printk("Physical Port=0x%X\n", pg0->PhysicalPort); 244 printk("\n"); 245 } 246 247 static void mptsas_print_expander_pg1(SasExpanderPage1_t *pg1) 248 { 249 printk("---- SAS EXPANDER PAGE 1 ------------\n"); 250 251 printk("Physical Port=0x%X\n", pg1->PhysicalPort); 252 printk("PHY Identifier=0x%X\n", pg1->PhyIdentifier); 253 printk("Negotiated Link Rate=0x%X\n", pg1->NegotiatedLinkRate); 254 printk("Programmed Link Rate=0x%X\n", pg1->ProgrammedLinkRate); 255 printk("Hardware Link Rate=0x%X\n", pg1->HwLinkRate); 256 printk("Owner Device Handle=0x%X\n", 257 le16_to_cpu(pg1->OwnerDevHandle)); 258 printk("Attached Device Handle=0x%X\n", 259 le16_to_cpu(pg1->AttachedDevHandle)); 260 } 261 #else 262 #define mptsas_print_phy_data(phy_data) do { } while (0) 263 #define mptsas_print_phy_pg0(pg0) do { } while (0) 264 #define mptsas_print_phy_pg1(pg1) do { } while (0) 265 #define mptsas_print_device_pg0(pg0) do { } while (0) 266 #define mptsas_print_expander_pg1(pg1) do { } while (0) 267 #endif 268 269 static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy) 270 { 271 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 272 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc; 273 } 274 275 static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy) 276 { 277 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent); 278 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc; 279 } 280 281 /* 282 * mptsas_find_portinfo_by_handle 283 * 284 * This function should be called with the sas_topology_mutex already held 285 */ 286 static struct mptsas_portinfo * 287 mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle) 288 { 289 struct mptsas_portinfo *port_info, *rc=NULL; 290 int i; 291 292 list_for_each_entry(port_info, &ioc->sas_topology, list) 293 for (i = 0; i < port_info->num_phys; i++) 294 if (port_info->phy_info[i].identify.handle == handle) { 295 rc = port_info; 296 goto out; 297 } 298 out: 299 return rc; 300 } 301 302 /* 303 * Returns true if there is a scsi end device 304 */ 305 static inline int 306 mptsas_is_end_device(struct mptsas_devinfo * attached) 307 { 308 if ((attached->handle) && 309 (attached->device_info & 310 MPI_SAS_DEVICE_INFO_END_DEVICE) && 311 ((attached->device_info & 312 MPI_SAS_DEVICE_INFO_SSP_TARGET) | 313 (attached->device_info & 314 MPI_SAS_DEVICE_INFO_STP_TARGET) | 315 (attached->device_info & 316 MPI_SAS_DEVICE_INFO_SATA_DEVICE))) 317 return 1; 318 else 319 return 0; 320 } 321 322 static int 323 mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure, 324 u32 form, u32 form_specific) 325 { 326 ConfigExtendedPageHeader_t hdr; 327 CONFIGPARMS cfg; 328 SasEnclosurePage0_t *buffer; 329 dma_addr_t dma_handle; 330 int error; 331 __le64 le_identifier; 332 333 memset(&hdr, 0, sizeof(hdr)); 334 hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION; 335 hdr.PageNumber = 0; 336 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 337 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE; 338 339 cfg.cfghdr.ehdr = &hdr; 340 cfg.physAddr = -1; 341 cfg.pageAddr = form + form_specific; 342 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 343 cfg.dir = 0; /* read */ 344 cfg.timeout = 10; 345 346 error = mpt_config(ioc, &cfg); 347 if (error) 348 goto out; 349 if (!hdr.ExtPageLength) { 350 error = -ENXIO; 351 goto out; 352 } 353 354 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 355 &dma_handle); 356 if (!buffer) { 357 error = -ENOMEM; 358 goto out; 359 } 360 361 cfg.physAddr = dma_handle; 362 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 363 364 error = mpt_config(ioc, &cfg); 365 if (error) 366 goto out_free_consistent; 367 368 /* save config data */ 369 memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64)); 370 enclosure->enclosure_logical_id = le64_to_cpu(le_identifier); 371 enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle); 372 enclosure->flags = le16_to_cpu(buffer->Flags); 373 enclosure->num_slot = le16_to_cpu(buffer->NumSlots); 374 enclosure->start_slot = le16_to_cpu(buffer->StartSlot); 375 enclosure->start_id = buffer->StartTargetID; 376 enclosure->start_channel = buffer->StartBus; 377 enclosure->sep_id = buffer->SEPTargetID; 378 enclosure->sep_channel = buffer->SEPBus; 379 380 out_free_consistent: 381 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 382 buffer, dma_handle); 383 out: 384 return error; 385 } 386 387 static int 388 mptsas_slave_configure(struct scsi_device *sdev) 389 { 390 struct Scsi_Host *host = sdev->host; 391 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; 392 393 /* 394 * RAID volumes placed beyond the last expected port. 395 * Ignore sending sas mode pages in that case.. 396 */ 397 if (sdev->channel < hd->ioc->num_ports) 398 sas_read_port_mode_page(sdev); 399 400 return mptscsih_slave_configure(sdev); 401 } 402 403 /* 404 * This is pretty ugly. We will be able to seriously clean it up 405 * once the DV code in mptscsih goes away and we can properly 406 * implement ->target_alloc. 407 */ 408 static int 409 mptsas_slave_alloc(struct scsi_device *sdev) 410 { 411 struct Scsi_Host *host = sdev->host; 412 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; 413 struct sas_rphy *rphy; 414 struct mptsas_portinfo *p; 415 VirtTarget *vtarget; 416 VirtDevice *vdev; 417 struct scsi_target *starget; 418 u32 target_id; 419 int i; 420 421 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL); 422 if (!vdev) { 423 printk(MYIOC_s_ERR_FMT "slave_alloc kmalloc(%zd) FAILED!\n", 424 hd->ioc->name, sizeof(VirtDevice)); 425 return -ENOMEM; 426 } 427 sdev->hostdata = vdev; 428 starget = scsi_target(sdev); 429 vtarget = starget->hostdata; 430 vtarget->ioc_id = hd->ioc->id; 431 vdev->vtarget = vtarget; 432 if (vtarget->num_luns == 0) { 433 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES|MPT_TARGET_FLAGS_VALID_INQUIRY; 434 hd->Targets[sdev->id] = vtarget; 435 } 436 437 /* 438 RAID volumes placed beyond the last expected port. 439 */ 440 if (sdev->channel == hd->ioc->num_ports) { 441 target_id = sdev->id; 442 vtarget->bus_id = 0; 443 vdev->lun = 0; 444 goto out; 445 } 446 447 rphy = dev_to_rphy(sdev->sdev_target->dev.parent); 448 mutex_lock(&hd->ioc->sas_topology_mutex); 449 list_for_each_entry(p, &hd->ioc->sas_topology, list) { 450 for (i = 0; i < p->num_phys; i++) { 451 if (p->phy_info[i].attached.sas_address == 452 rphy->identify.sas_address) { 453 target_id = p->phy_info[i].attached.id; 454 vtarget->bus_id = p->phy_info[i].attached.channel; 455 vdev->lun = sdev->lun; 456 p->phy_info[i].starget = sdev->sdev_target; 457 /* 458 * Exposing hidden disk (RAID) 459 */ 460 if (mptscsih_is_phys_disk(hd->ioc, target_id)) { 461 target_id = mptscsih_raid_id_to_num(hd, 462 target_id); 463 vdev->vtarget->tflags |= 464 MPT_TARGET_FLAGS_RAID_COMPONENT; 465 sdev->no_uld_attach = 1; 466 } 467 mutex_unlock(&hd->ioc->sas_topology_mutex); 468 goto out; 469 } 470 } 471 } 472 mutex_unlock(&hd->ioc->sas_topology_mutex); 473 474 kfree(vdev); 475 return -ENXIO; 476 477 out: 478 vtarget->target_id = target_id; 479 vtarget->num_luns++; 480 return 0; 481 } 482 483 static void 484 mptsas_slave_destroy(struct scsi_device *sdev) 485 { 486 struct Scsi_Host *host = sdev->host; 487 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; 488 VirtDevice *vdev; 489 490 /* 491 * Issue target reset to flush firmware outstanding commands. 492 */ 493 vdev = sdev->hostdata; 494 if (vdev->configured_lun){ 495 if (mptscsih_TMHandler(hd, 496 MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 497 vdev->vtarget->bus_id, 498 vdev->vtarget->target_id, 499 0, 0, 5 /* 5 second timeout */) 500 < 0){ 501 502 /* The TM request failed! 503 * Fatal error case. 504 */ 505 printk(MYIOC_s_WARN_FMT 506 "Error processing TaskMgmt id=%d TARGET_RESET\n", 507 hd->ioc->name, 508 vdev->vtarget->target_id); 509 510 hd->tmPending = 0; 511 hd->tmState = TM_STATE_NONE; 512 } 513 } 514 mptscsih_slave_destroy(sdev); 515 } 516 517 static struct scsi_host_template mptsas_driver_template = { 518 .module = THIS_MODULE, 519 .proc_name = "mptsas", 520 .proc_info = mptscsih_proc_info, 521 .name = "MPT SPI Host", 522 .info = mptscsih_info, 523 .queuecommand = mptscsih_qcmd, 524 .target_alloc = mptscsih_target_alloc, 525 .slave_alloc = mptsas_slave_alloc, 526 .slave_configure = mptsas_slave_configure, 527 .target_destroy = mptscsih_target_destroy, 528 .slave_destroy = mptsas_slave_destroy, 529 .change_queue_depth = mptscsih_change_queue_depth, 530 .eh_abort_handler = mptscsih_abort, 531 .eh_device_reset_handler = mptscsih_dev_reset, 532 .eh_bus_reset_handler = mptscsih_bus_reset, 533 .eh_host_reset_handler = mptscsih_host_reset, 534 .bios_param = mptscsih_bios_param, 535 .can_queue = MPT_FC_CAN_QUEUE, 536 .this_id = -1, 537 .sg_tablesize = MPT_SCSI_SG_DEPTH, 538 .max_sectors = 8192, 539 .cmd_per_lun = 7, 540 .use_clustering = ENABLE_CLUSTERING, 541 }; 542 543 static int mptsas_get_linkerrors(struct sas_phy *phy) 544 { 545 MPT_ADAPTER *ioc = phy_to_ioc(phy); 546 ConfigExtendedPageHeader_t hdr; 547 CONFIGPARMS cfg; 548 SasPhyPage1_t *buffer; 549 dma_addr_t dma_handle; 550 int error; 551 552 hdr.PageVersion = MPI_SASPHY1_PAGEVERSION; 553 hdr.ExtPageLength = 0; 554 hdr.PageNumber = 1 /* page number 1*/; 555 hdr.Reserved1 = 0; 556 hdr.Reserved2 = 0; 557 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 558 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY; 559 560 cfg.cfghdr.ehdr = &hdr; 561 cfg.physAddr = -1; 562 cfg.pageAddr = phy->identify.phy_identifier; 563 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 564 cfg.dir = 0; /* read */ 565 cfg.timeout = 10; 566 567 error = mpt_config(ioc, &cfg); 568 if (error) 569 return error; 570 if (!hdr.ExtPageLength) 571 return -ENXIO; 572 573 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 574 &dma_handle); 575 if (!buffer) 576 return -ENOMEM; 577 578 cfg.physAddr = dma_handle; 579 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 580 581 error = mpt_config(ioc, &cfg); 582 if (error) 583 goto out_free_consistent; 584 585 mptsas_print_phy_pg1(buffer); 586 587 phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount); 588 phy->running_disparity_error_count = 589 le32_to_cpu(buffer->RunningDisparityErrorCount); 590 phy->loss_of_dword_sync_count = 591 le32_to_cpu(buffer->LossDwordSynchCount); 592 phy->phy_reset_problem_count = 593 le32_to_cpu(buffer->PhyResetProblemCount); 594 595 out_free_consistent: 596 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 597 buffer, dma_handle); 598 return error; 599 } 600 601 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, 602 MPT_FRAME_HDR *reply) 603 { 604 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_COMMAND_GOOD; 605 if (reply != NULL) { 606 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_RF_VALID; 607 memcpy(ioc->sas_mgmt.reply, reply, 608 min(ioc->reply_sz, 4 * reply->u.reply.MsgLength)); 609 } 610 complete(&ioc->sas_mgmt.done); 611 return 1; 612 } 613 614 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset) 615 { 616 MPT_ADAPTER *ioc = phy_to_ioc(phy); 617 SasIoUnitControlRequest_t *req; 618 SasIoUnitControlReply_t *reply; 619 MPT_FRAME_HDR *mf; 620 MPIHeader_t *hdr; 621 unsigned long timeleft; 622 int error = -ERESTARTSYS; 623 624 /* not implemented for expanders */ 625 if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP) 626 return -ENXIO; 627 628 if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex)) 629 goto out; 630 631 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc); 632 if (!mf) { 633 error = -ENOMEM; 634 goto out_unlock; 635 } 636 637 hdr = (MPIHeader_t *) mf; 638 req = (SasIoUnitControlRequest_t *)mf; 639 memset(req, 0, sizeof(SasIoUnitControlRequest_t)); 640 req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL; 641 req->MsgContext = hdr->MsgContext; 642 req->Operation = hard_reset ? 643 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET; 644 req->PhyNum = phy->identify.phy_identifier; 645 646 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf); 647 648 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 649 10 * HZ); 650 if (!timeleft) { 651 /* On timeout reset the board */ 652 mpt_free_msg_frame(ioc, mf); 653 mpt_HardResetHandler(ioc, CAN_SLEEP); 654 error = -ETIMEDOUT; 655 goto out_unlock; 656 } 657 658 /* a reply frame is expected */ 659 if ((ioc->sas_mgmt.status & 660 MPT_IOCTL_STATUS_RF_VALID) == 0) { 661 error = -ENXIO; 662 goto out_unlock; 663 } 664 665 /* process the completed Reply Message Frame */ 666 reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply; 667 if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) { 668 printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n", 669 __FUNCTION__, 670 reply->IOCStatus, 671 reply->IOCLogInfo); 672 error = -ENXIO; 673 goto out_unlock; 674 } 675 676 error = 0; 677 678 out_unlock: 679 mutex_unlock(&ioc->sas_mgmt.mutex); 680 out: 681 return error; 682 } 683 684 static int 685 mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier) 686 { 687 MPT_ADAPTER *ioc = rphy_to_ioc(rphy); 688 int i, error; 689 struct mptsas_portinfo *p; 690 struct mptsas_enclosure enclosure_info; 691 u64 enclosure_handle; 692 693 mutex_lock(&ioc->sas_topology_mutex); 694 list_for_each_entry(p, &ioc->sas_topology, list) { 695 for (i = 0; i < p->num_phys; i++) { 696 if (p->phy_info[i].attached.sas_address == 697 rphy->identify.sas_address) { 698 enclosure_handle = p->phy_info[i]. 699 attached.handle_enclosure; 700 goto found_info; 701 } 702 } 703 } 704 mutex_unlock(&ioc->sas_topology_mutex); 705 return -ENXIO; 706 707 found_info: 708 mutex_unlock(&ioc->sas_topology_mutex); 709 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure)); 710 error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info, 711 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE << 712 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle); 713 if (!error) 714 *identifier = enclosure_info.enclosure_logical_id; 715 return error; 716 } 717 718 static int 719 mptsas_get_bay_identifier(struct sas_rphy *rphy) 720 { 721 MPT_ADAPTER *ioc = rphy_to_ioc(rphy); 722 struct mptsas_portinfo *p; 723 int i, rc; 724 725 mutex_lock(&ioc->sas_topology_mutex); 726 list_for_each_entry(p, &ioc->sas_topology, list) { 727 for (i = 0; i < p->num_phys; i++) { 728 if (p->phy_info[i].attached.sas_address == 729 rphy->identify.sas_address) { 730 rc = p->phy_info[i].attached.slot; 731 goto out; 732 } 733 } 734 } 735 rc = -ENXIO; 736 out: 737 mutex_unlock(&ioc->sas_topology_mutex); 738 return rc; 739 } 740 741 static struct sas_function_template mptsas_transport_functions = { 742 .get_linkerrors = mptsas_get_linkerrors, 743 .get_enclosure_identifier = mptsas_get_enclosure_identifier, 744 .get_bay_identifier = mptsas_get_bay_identifier, 745 .phy_reset = mptsas_phy_reset, 746 }; 747 748 static struct scsi_transport_template *mptsas_transport_template; 749 750 static int 751 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info) 752 { 753 ConfigExtendedPageHeader_t hdr; 754 CONFIGPARMS cfg; 755 SasIOUnitPage0_t *buffer; 756 dma_addr_t dma_handle; 757 int error, i; 758 759 hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION; 760 hdr.ExtPageLength = 0; 761 hdr.PageNumber = 0; 762 hdr.Reserved1 = 0; 763 hdr.Reserved2 = 0; 764 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 765 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT; 766 767 cfg.cfghdr.ehdr = &hdr; 768 cfg.physAddr = -1; 769 cfg.pageAddr = 0; 770 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 771 cfg.dir = 0; /* read */ 772 cfg.timeout = 10; 773 774 error = mpt_config(ioc, &cfg); 775 if (error) 776 goto out; 777 if (!hdr.ExtPageLength) { 778 error = -ENXIO; 779 goto out; 780 } 781 782 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 783 &dma_handle); 784 if (!buffer) { 785 error = -ENOMEM; 786 goto out; 787 } 788 789 cfg.physAddr = dma_handle; 790 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 791 792 error = mpt_config(ioc, &cfg); 793 if (error) 794 goto out_free_consistent; 795 796 port_info->num_phys = buffer->NumPhys; 797 port_info->phy_info = kcalloc(port_info->num_phys, 798 sizeof(struct mptsas_phyinfo),GFP_KERNEL); 799 if (!port_info->phy_info) { 800 error = -ENOMEM; 801 goto out_free_consistent; 802 } 803 804 if (port_info->num_phys) 805 port_info->handle = 806 le16_to_cpu(buffer->PhyData[0].ControllerDevHandle); 807 for (i = 0; i < port_info->num_phys; i++) { 808 mptsas_print_phy_data(&buffer->PhyData[i]); 809 port_info->phy_info[i].phy_id = i; 810 port_info->phy_info[i].port_id = 811 buffer->PhyData[i].Port; 812 port_info->phy_info[i].negotiated_link_rate = 813 buffer->PhyData[i].NegotiatedLinkRate; 814 } 815 816 out_free_consistent: 817 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 818 buffer, dma_handle); 819 out: 820 return error; 821 } 822 823 static int 824 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, 825 u32 form, u32 form_specific) 826 { 827 ConfigExtendedPageHeader_t hdr; 828 CONFIGPARMS cfg; 829 SasPhyPage0_t *buffer; 830 dma_addr_t dma_handle; 831 int error; 832 833 hdr.PageVersion = MPI_SASPHY0_PAGEVERSION; 834 hdr.ExtPageLength = 0; 835 hdr.PageNumber = 0; 836 hdr.Reserved1 = 0; 837 hdr.Reserved2 = 0; 838 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 839 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY; 840 841 cfg.cfghdr.ehdr = &hdr; 842 cfg.dir = 0; /* read */ 843 cfg.timeout = 10; 844 845 /* Get Phy Pg 0 for each Phy. */ 846 cfg.physAddr = -1; 847 cfg.pageAddr = form + form_specific; 848 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 849 850 error = mpt_config(ioc, &cfg); 851 if (error) 852 goto out; 853 854 if (!hdr.ExtPageLength) { 855 error = -ENXIO; 856 goto out; 857 } 858 859 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 860 &dma_handle); 861 if (!buffer) { 862 error = -ENOMEM; 863 goto out; 864 } 865 866 cfg.physAddr = dma_handle; 867 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 868 869 error = mpt_config(ioc, &cfg); 870 if (error) 871 goto out_free_consistent; 872 873 mptsas_print_phy_pg0(buffer); 874 875 phy_info->hw_link_rate = buffer->HwLinkRate; 876 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate; 877 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle); 878 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle); 879 880 out_free_consistent: 881 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 882 buffer, dma_handle); 883 out: 884 return error; 885 } 886 887 static int 888 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info, 889 u32 form, u32 form_specific) 890 { 891 ConfigExtendedPageHeader_t hdr; 892 CONFIGPARMS cfg; 893 SasDevicePage0_t *buffer; 894 dma_addr_t dma_handle; 895 __le64 sas_address; 896 int error=0; 897 898 if (ioc->sas_discovery_runtime && 899 mptsas_is_end_device(device_info)) 900 goto out; 901 902 hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION; 903 hdr.ExtPageLength = 0; 904 hdr.PageNumber = 0; 905 hdr.Reserved1 = 0; 906 hdr.Reserved2 = 0; 907 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 908 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE; 909 910 cfg.cfghdr.ehdr = &hdr; 911 cfg.pageAddr = form + form_specific; 912 cfg.physAddr = -1; 913 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 914 cfg.dir = 0; /* read */ 915 cfg.timeout = 10; 916 917 memset(device_info, 0, sizeof(struct mptsas_devinfo)); 918 error = mpt_config(ioc, &cfg); 919 if (error) 920 goto out; 921 if (!hdr.ExtPageLength) { 922 error = -ENXIO; 923 goto out; 924 } 925 926 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 927 &dma_handle); 928 if (!buffer) { 929 error = -ENOMEM; 930 goto out; 931 } 932 933 cfg.physAddr = dma_handle; 934 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 935 936 error = mpt_config(ioc, &cfg); 937 if (error) 938 goto out_free_consistent; 939 940 mptsas_print_device_pg0(buffer); 941 942 device_info->handle = le16_to_cpu(buffer->DevHandle); 943 device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle); 944 device_info->handle_enclosure = 945 le16_to_cpu(buffer->EnclosureHandle); 946 device_info->slot = le16_to_cpu(buffer->Slot); 947 device_info->phy_id = buffer->PhyNum; 948 device_info->port_id = buffer->PhysicalPort; 949 device_info->id = buffer->TargetID; 950 device_info->channel = buffer->Bus; 951 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64)); 952 device_info->sas_address = le64_to_cpu(sas_address); 953 device_info->device_info = 954 le32_to_cpu(buffer->DeviceInfo); 955 956 out_free_consistent: 957 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 958 buffer, dma_handle); 959 out: 960 return error; 961 } 962 963 static int 964 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info, 965 u32 form, u32 form_specific) 966 { 967 ConfigExtendedPageHeader_t hdr; 968 CONFIGPARMS cfg; 969 SasExpanderPage0_t *buffer; 970 dma_addr_t dma_handle; 971 int error; 972 973 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION; 974 hdr.ExtPageLength = 0; 975 hdr.PageNumber = 0; 976 hdr.Reserved1 = 0; 977 hdr.Reserved2 = 0; 978 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 979 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER; 980 981 cfg.cfghdr.ehdr = &hdr; 982 cfg.physAddr = -1; 983 cfg.pageAddr = form + form_specific; 984 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 985 cfg.dir = 0; /* read */ 986 cfg.timeout = 10; 987 988 memset(port_info, 0, sizeof(struct mptsas_portinfo)); 989 error = mpt_config(ioc, &cfg); 990 if (error) 991 goto out; 992 993 if (!hdr.ExtPageLength) { 994 error = -ENXIO; 995 goto out; 996 } 997 998 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 999 &dma_handle); 1000 if (!buffer) { 1001 error = -ENOMEM; 1002 goto out; 1003 } 1004 1005 cfg.physAddr = dma_handle; 1006 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 1007 1008 error = mpt_config(ioc, &cfg); 1009 if (error) 1010 goto out_free_consistent; 1011 1012 /* save config data */ 1013 port_info->num_phys = buffer->NumPhys; 1014 port_info->handle = le16_to_cpu(buffer->DevHandle); 1015 port_info->phy_info = kcalloc(port_info->num_phys, 1016 sizeof(struct mptsas_phyinfo),GFP_KERNEL); 1017 if (!port_info->phy_info) { 1018 error = -ENOMEM; 1019 goto out_free_consistent; 1020 } 1021 1022 out_free_consistent: 1023 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1024 buffer, dma_handle); 1025 out: 1026 return error; 1027 } 1028 1029 static int 1030 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, 1031 u32 form, u32 form_specific) 1032 { 1033 ConfigExtendedPageHeader_t hdr; 1034 CONFIGPARMS cfg; 1035 SasExpanderPage1_t *buffer; 1036 dma_addr_t dma_handle; 1037 int error=0; 1038 1039 if (ioc->sas_discovery_runtime && 1040 mptsas_is_end_device(&phy_info->attached)) 1041 goto out; 1042 1043 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION; 1044 hdr.ExtPageLength = 0; 1045 hdr.PageNumber = 1; 1046 hdr.Reserved1 = 0; 1047 hdr.Reserved2 = 0; 1048 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 1049 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER; 1050 1051 cfg.cfghdr.ehdr = &hdr; 1052 cfg.physAddr = -1; 1053 cfg.pageAddr = form + form_specific; 1054 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 1055 cfg.dir = 0; /* read */ 1056 cfg.timeout = 10; 1057 1058 error = mpt_config(ioc, &cfg); 1059 if (error) 1060 goto out; 1061 1062 if (!hdr.ExtPageLength) { 1063 error = -ENXIO; 1064 goto out; 1065 } 1066 1067 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1068 &dma_handle); 1069 if (!buffer) { 1070 error = -ENOMEM; 1071 goto out; 1072 } 1073 1074 cfg.physAddr = dma_handle; 1075 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 1076 1077 error = mpt_config(ioc, &cfg); 1078 if (error) 1079 goto out_free_consistent; 1080 1081 1082 mptsas_print_expander_pg1(buffer); 1083 1084 /* save config data */ 1085 phy_info->phy_id = buffer->PhyIdentifier; 1086 phy_info->port_id = buffer->PhysicalPort; 1087 phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate; 1088 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate; 1089 phy_info->hw_link_rate = buffer->HwLinkRate; 1090 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle); 1091 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle); 1092 1093 out_free_consistent: 1094 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1095 buffer, dma_handle); 1096 out: 1097 return error; 1098 } 1099 1100 static void 1101 mptsas_parse_device_info(struct sas_identify *identify, 1102 struct mptsas_devinfo *device_info) 1103 { 1104 u16 protocols; 1105 1106 identify->sas_address = device_info->sas_address; 1107 identify->phy_identifier = device_info->phy_id; 1108 1109 /* 1110 * Fill in Phy Initiator Port Protocol. 1111 * Bits 6:3, more than one bit can be set, fall through cases. 1112 */ 1113 protocols = device_info->device_info & 0x78; 1114 identify->initiator_port_protocols = 0; 1115 if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR) 1116 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP; 1117 if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR) 1118 identify->initiator_port_protocols |= SAS_PROTOCOL_STP; 1119 if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR) 1120 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP; 1121 if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST) 1122 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA; 1123 1124 /* 1125 * Fill in Phy Target Port Protocol. 1126 * Bits 10:7, more than one bit can be set, fall through cases. 1127 */ 1128 protocols = device_info->device_info & 0x780; 1129 identify->target_port_protocols = 0; 1130 if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET) 1131 identify->target_port_protocols |= SAS_PROTOCOL_SSP; 1132 if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET) 1133 identify->target_port_protocols |= SAS_PROTOCOL_STP; 1134 if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET) 1135 identify->target_port_protocols |= SAS_PROTOCOL_SMP; 1136 if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE) 1137 identify->target_port_protocols |= SAS_PROTOCOL_SATA; 1138 1139 /* 1140 * Fill in Attached device type. 1141 */ 1142 switch (device_info->device_info & 1143 MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) { 1144 case MPI_SAS_DEVICE_INFO_NO_DEVICE: 1145 identify->device_type = SAS_PHY_UNUSED; 1146 break; 1147 case MPI_SAS_DEVICE_INFO_END_DEVICE: 1148 identify->device_type = SAS_END_DEVICE; 1149 break; 1150 case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER: 1151 identify->device_type = SAS_EDGE_EXPANDER_DEVICE; 1152 break; 1153 case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER: 1154 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE; 1155 break; 1156 } 1157 } 1158 1159 static int mptsas_probe_one_phy(struct device *dev, 1160 struct mptsas_phyinfo *phy_info, int index, int local) 1161 { 1162 MPT_ADAPTER *ioc; 1163 struct sas_phy *phy; 1164 int error; 1165 1166 if (!dev) 1167 return -ENODEV; 1168 1169 if (!phy_info->phy) { 1170 phy = sas_phy_alloc(dev, index); 1171 if (!phy) 1172 return -ENOMEM; 1173 } else 1174 phy = phy_info->phy; 1175 1176 phy->port_identifier = phy_info->port_id; 1177 mptsas_parse_device_info(&phy->identify, &phy_info->identify); 1178 1179 /* 1180 * Set Negotiated link rate. 1181 */ 1182 switch (phy_info->negotiated_link_rate) { 1183 case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED: 1184 phy->negotiated_linkrate = SAS_PHY_DISABLED; 1185 break; 1186 case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION: 1187 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED; 1188 break; 1189 case MPI_SAS_IOUNIT0_RATE_1_5: 1190 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS; 1191 break; 1192 case MPI_SAS_IOUNIT0_RATE_3_0: 1193 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS; 1194 break; 1195 case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE: 1196 case MPI_SAS_IOUNIT0_RATE_UNKNOWN: 1197 default: 1198 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN; 1199 break; 1200 } 1201 1202 /* 1203 * Set Max hardware link rate. 1204 */ 1205 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) { 1206 case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5: 1207 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS; 1208 break; 1209 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0: 1210 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS; 1211 break; 1212 default: 1213 break; 1214 } 1215 1216 /* 1217 * Set Max programmed link rate. 1218 */ 1219 switch (phy_info->programmed_link_rate & 1220 MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) { 1221 case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5: 1222 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS; 1223 break; 1224 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0: 1225 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS; 1226 break; 1227 default: 1228 break; 1229 } 1230 1231 /* 1232 * Set Min hardware link rate. 1233 */ 1234 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) { 1235 case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5: 1236 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS; 1237 break; 1238 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0: 1239 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS; 1240 break; 1241 default: 1242 break; 1243 } 1244 1245 /* 1246 * Set Min programmed link rate. 1247 */ 1248 switch (phy_info->programmed_link_rate & 1249 MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) { 1250 case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5: 1251 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS; 1252 break; 1253 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0: 1254 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS; 1255 break; 1256 default: 1257 break; 1258 } 1259 1260 if (!phy_info->phy) { 1261 1262 if (local) 1263 phy->local_attached = 1; 1264 1265 error = sas_phy_add(phy); 1266 if (error) { 1267 sas_phy_free(phy); 1268 return error; 1269 } 1270 phy_info->phy = phy; 1271 } 1272 1273 if ((phy_info->attached.handle) && 1274 (!phy_info->rphy)) { 1275 1276 struct sas_rphy *rphy; 1277 struct sas_identify identify; 1278 1279 ioc = phy_to_ioc(phy_info->phy); 1280 1281 /* 1282 * Let the hotplug_work thread handle processing 1283 * the adding/removing of devices that occur 1284 * after start of day. 1285 */ 1286 if (ioc->sas_discovery_runtime && 1287 mptsas_is_end_device(&phy_info->attached)) 1288 return 0; 1289 1290 mptsas_parse_device_info(&identify, &phy_info->attached); 1291 switch (identify.device_type) { 1292 case SAS_END_DEVICE: 1293 rphy = sas_end_device_alloc(phy); 1294 break; 1295 case SAS_EDGE_EXPANDER_DEVICE: 1296 case SAS_FANOUT_EXPANDER_DEVICE: 1297 rphy = sas_expander_alloc(phy, identify.device_type); 1298 break; 1299 default: 1300 rphy = NULL; 1301 break; 1302 } 1303 if (!rphy) 1304 return 0; /* non-fatal: an rphy can be added later */ 1305 1306 rphy->identify = identify; 1307 1308 error = sas_rphy_add(rphy); 1309 if (error) { 1310 sas_rphy_free(rphy); 1311 return error; 1312 } 1313 1314 phy_info->rphy = rphy; 1315 } 1316 1317 return 0; 1318 } 1319 1320 static int 1321 mptsas_probe_hba_phys(MPT_ADAPTER *ioc) 1322 { 1323 struct mptsas_portinfo *port_info, *hba; 1324 u32 handle = 0xFFFF; 1325 int error = -ENOMEM, i; 1326 1327 hba = kzalloc(sizeof(*port_info), GFP_KERNEL); 1328 if (! hba) 1329 goto out; 1330 1331 error = mptsas_sas_io_unit_pg0(ioc, hba); 1332 if (error) 1333 goto out_free_port_info; 1334 1335 mutex_lock(&ioc->sas_topology_mutex); 1336 port_info = mptsas_find_portinfo_by_handle(ioc, hba->handle); 1337 if (!port_info) { 1338 port_info = hba; 1339 list_add_tail(&port_info->list, &ioc->sas_topology); 1340 } else { 1341 port_info->handle = hba->handle; 1342 for (i = 0; i < hba->num_phys; i++) 1343 port_info->phy_info[i].negotiated_link_rate = 1344 hba->phy_info[i].negotiated_link_rate; 1345 if (hba->phy_info) 1346 kfree(hba->phy_info); 1347 kfree(hba); 1348 hba = NULL; 1349 } 1350 mutex_unlock(&ioc->sas_topology_mutex); 1351 ioc->num_ports = port_info->num_phys; 1352 1353 for (i = 0; i < port_info->num_phys; i++) { 1354 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i], 1355 (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER << 1356 MPI_SAS_PHY_PGAD_FORM_SHIFT), i); 1357 1358 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify, 1359 (MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE << 1360 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), handle); 1361 port_info->phy_info[i].identify.phy_id = 1362 port_info->phy_info[i].phy_id; 1363 handle = port_info->phy_info[i].identify.handle; 1364 1365 if (port_info->phy_info[i].attached.handle) { 1366 mptsas_sas_device_pg0(ioc, 1367 &port_info->phy_info[i].attached, 1368 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 1369 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 1370 port_info->phy_info[i].attached.handle); 1371 } 1372 1373 mptsas_probe_one_phy(&ioc->sh->shost_gendev, 1374 &port_info->phy_info[i], ioc->sas_index, 1); 1375 ioc->sas_index++; 1376 } 1377 1378 return 0; 1379 1380 out_free_port_info: 1381 kfree(hba); 1382 out: 1383 return error; 1384 } 1385 1386 static int 1387 mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle) 1388 { 1389 struct mptsas_portinfo *port_info, *p, *ex; 1390 int error = -ENOMEM, i, j; 1391 1392 ex = kzalloc(sizeof(*port_info), GFP_KERNEL); 1393 if (!ex) 1394 goto out; 1395 1396 error = mptsas_sas_expander_pg0(ioc, ex, 1397 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE << 1398 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), *handle); 1399 if (error) 1400 goto out_free_port_info; 1401 1402 *handle = ex->handle; 1403 1404 mutex_lock(&ioc->sas_topology_mutex); 1405 port_info = mptsas_find_portinfo_by_handle(ioc, *handle); 1406 if (!port_info) { 1407 port_info = ex; 1408 list_add_tail(&port_info->list, &ioc->sas_topology); 1409 } else { 1410 port_info->handle = ex->handle; 1411 if (ex->phy_info) 1412 kfree(ex->phy_info); 1413 kfree(ex); 1414 ex = NULL; 1415 } 1416 mutex_unlock(&ioc->sas_topology_mutex); 1417 1418 for (i = 0; i < port_info->num_phys; i++) { 1419 struct device *parent; 1420 1421 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i], 1422 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM << 1423 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + *handle); 1424 1425 if (port_info->phy_info[i].identify.handle) { 1426 mptsas_sas_device_pg0(ioc, 1427 &port_info->phy_info[i].identify, 1428 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 1429 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 1430 port_info->phy_info[i].identify.handle); 1431 port_info->phy_info[i].identify.phy_id = 1432 port_info->phy_info[i].phy_id; 1433 } 1434 1435 if (port_info->phy_info[i].attached.handle) { 1436 mptsas_sas_device_pg0(ioc, 1437 &port_info->phy_info[i].attached, 1438 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 1439 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 1440 port_info->phy_info[i].attached.handle); 1441 port_info->phy_info[i].attached.phy_id = 1442 port_info->phy_info[i].phy_id; 1443 } 1444 1445 /* 1446 * If we find a parent port handle this expander is 1447 * attached to another expander, else it hangs of the 1448 * HBA phys. 1449 */ 1450 parent = &ioc->sh->shost_gendev; 1451 mutex_lock(&ioc->sas_topology_mutex); 1452 list_for_each_entry(p, &ioc->sas_topology, list) { 1453 for (j = 0; j < p->num_phys; j++) { 1454 if (port_info->phy_info[i].identify.handle == 1455 p->phy_info[j].attached.handle) 1456 parent = &p->phy_info[j].rphy->dev; 1457 } 1458 } 1459 mutex_unlock(&ioc->sas_topology_mutex); 1460 1461 mptsas_probe_one_phy(parent, &port_info->phy_info[i], 1462 ioc->sas_index, 0); 1463 ioc->sas_index++; 1464 } 1465 1466 return 0; 1467 1468 out_free_port_info: 1469 if (ex) { 1470 if (ex->phy_info) 1471 kfree(ex->phy_info); 1472 kfree(ex); 1473 } 1474 out: 1475 return error; 1476 } 1477 1478 /* 1479 * mptsas_delete_expander_phys 1480 * 1481 * 1482 * This will traverse topology, and remove expanders 1483 * that are no longer present 1484 */ 1485 static void 1486 mptsas_delete_expander_phys(MPT_ADAPTER *ioc) 1487 { 1488 struct mptsas_portinfo buffer; 1489 struct mptsas_portinfo *port_info, *n, *parent; 1490 int i; 1491 1492 mutex_lock(&ioc->sas_topology_mutex); 1493 list_for_each_entry_safe(port_info, n, &ioc->sas_topology, list) { 1494 1495 if (port_info->phy_info && 1496 (!(port_info->phy_info[0].identify.device_info & 1497 MPI_SAS_DEVICE_INFO_SMP_TARGET))) 1498 continue; 1499 1500 if (mptsas_sas_expander_pg0(ioc, &buffer, 1501 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE << 1502 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), port_info->handle)) { 1503 1504 /* 1505 * Obtain the port_info instance to the parent port 1506 */ 1507 parent = mptsas_find_portinfo_by_handle(ioc, 1508 port_info->phy_info[0].identify.handle_parent); 1509 1510 if (!parent) 1511 goto next_port; 1512 1513 /* 1514 * Delete rphys in the parent that point 1515 * to this expander. The transport layer will 1516 * cleanup all the children. 1517 */ 1518 for (i = 0; i < parent->num_phys; i++) { 1519 if ((!parent->phy_info[i].rphy) || 1520 (parent->phy_info[i].attached.sas_address != 1521 port_info->phy_info[i].identify.sas_address)) 1522 continue; 1523 sas_rphy_delete(parent->phy_info[i].rphy); 1524 memset(&parent->phy_info[i].attached, 0, 1525 sizeof(struct mptsas_devinfo)); 1526 parent->phy_info[i].rphy = NULL; 1527 parent->phy_info[i].starget = NULL; 1528 } 1529 next_port: 1530 list_del(&port_info->list); 1531 if (port_info->phy_info) 1532 kfree(port_info->phy_info); 1533 kfree(port_info); 1534 } 1535 /* 1536 * Free this memory allocated from inside 1537 * mptsas_sas_expander_pg0 1538 */ 1539 if (buffer.phy_info) 1540 kfree(buffer.phy_info); 1541 } 1542 mutex_unlock(&ioc->sas_topology_mutex); 1543 } 1544 1545 /* 1546 * Start of day discovery 1547 */ 1548 static void 1549 mptsas_scan_sas_topology(MPT_ADAPTER *ioc) 1550 { 1551 u32 handle = 0xFFFF; 1552 int i; 1553 1554 mutex_lock(&ioc->sas_discovery_mutex); 1555 mptsas_probe_hba_phys(ioc); 1556 while (!mptsas_probe_expander_phys(ioc, &handle)) 1557 ; 1558 /* 1559 Reporting RAID volumes. 1560 */ 1561 if (!ioc->raid_data.pIocPg2) 1562 goto out; 1563 if (!ioc->raid_data.pIocPg2->NumActiveVolumes) 1564 goto out; 1565 for (i=0; i<ioc->raid_data.pIocPg2->NumActiveVolumes; i++) { 1566 scsi_add_device(ioc->sh, ioc->num_ports, 1567 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0); 1568 } 1569 out: 1570 mutex_unlock(&ioc->sas_discovery_mutex); 1571 } 1572 1573 /* 1574 * Work queue thread to handle Runtime discovery 1575 * Mere purpose is the hot add/delete of expanders 1576 */ 1577 static void 1578 mptscsih_discovery_work(void * arg) 1579 { 1580 struct mptsas_discovery_event *ev = arg; 1581 MPT_ADAPTER *ioc = ev->ioc; 1582 u32 handle = 0xFFFF; 1583 1584 mutex_lock(&ioc->sas_discovery_mutex); 1585 ioc->sas_discovery_runtime=1; 1586 mptsas_delete_expander_phys(ioc); 1587 mptsas_probe_hba_phys(ioc); 1588 while (!mptsas_probe_expander_phys(ioc, &handle)) 1589 ; 1590 kfree(ev); 1591 ioc->sas_discovery_runtime=0; 1592 mutex_unlock(&ioc->sas_discovery_mutex); 1593 } 1594 1595 static struct mptsas_phyinfo * 1596 mptsas_find_phyinfo_by_parent(MPT_ADAPTER *ioc, u16 parent_handle, u8 phy_id) 1597 { 1598 struct mptsas_portinfo *port_info; 1599 struct mptsas_devinfo device_info; 1600 struct mptsas_phyinfo *phy_info = NULL; 1601 int i, error; 1602 1603 /* 1604 * Retrieve the parent sas_address 1605 */ 1606 error = mptsas_sas_device_pg0(ioc, &device_info, 1607 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 1608 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 1609 parent_handle); 1610 if (error) 1611 return NULL; 1612 1613 /* 1614 * The phy_info structures are never deallocated during lifetime of 1615 * a host, so the code below is safe without additional refcounting. 1616 */ 1617 mutex_lock(&ioc->sas_topology_mutex); 1618 list_for_each_entry(port_info, &ioc->sas_topology, list) { 1619 for (i = 0; i < port_info->num_phys; i++) { 1620 if (port_info->phy_info[i].identify.sas_address == 1621 device_info.sas_address && 1622 port_info->phy_info[i].phy_id == phy_id) { 1623 phy_info = &port_info->phy_info[i]; 1624 break; 1625 } 1626 } 1627 } 1628 mutex_unlock(&ioc->sas_topology_mutex); 1629 1630 return phy_info; 1631 } 1632 1633 static struct mptsas_phyinfo * 1634 mptsas_find_phyinfo_by_target(MPT_ADAPTER *ioc, u32 id) 1635 { 1636 struct mptsas_portinfo *port_info; 1637 struct mptsas_phyinfo *phy_info = NULL; 1638 int i; 1639 1640 /* 1641 * The phy_info structures are never deallocated during lifetime of 1642 * a host, so the code below is safe without additional refcounting. 1643 */ 1644 mutex_lock(&ioc->sas_topology_mutex); 1645 list_for_each_entry(port_info, &ioc->sas_topology, list) { 1646 for (i = 0; i < port_info->num_phys; i++) 1647 if (mptsas_is_end_device(&port_info->phy_info[i].attached)) 1648 if (port_info->phy_info[i].attached.id == id) { 1649 phy_info = &port_info->phy_info[i]; 1650 break; 1651 } 1652 } 1653 mutex_unlock(&ioc->sas_topology_mutex); 1654 1655 return phy_info; 1656 } 1657 1658 /* 1659 * Work queue thread to clear the persitency table 1660 */ 1661 static void 1662 mptscsih_sas_persist_clear_table(void * arg) 1663 { 1664 MPT_ADAPTER *ioc = (MPT_ADAPTER *)arg; 1665 1666 mptbase_sas_persist_operation(ioc, MPI_SAS_OP_CLEAR_NOT_PRESENT); 1667 } 1668 1669 static void 1670 mptsas_reprobe_lun(struct scsi_device *sdev, void *data) 1671 { 1672 sdev->no_uld_attach = data ? 1 : 0; 1673 scsi_device_reprobe(sdev); 1674 } 1675 1676 static void 1677 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach) 1678 { 1679 starget_for_each_device(starget, uld_attach ? (void *)1 : NULL, 1680 mptsas_reprobe_lun); 1681 } 1682 1683 1684 /* 1685 * Work queue thread to handle SAS hotplug events 1686 */ 1687 static void 1688 mptsas_hotplug_work(void *arg) 1689 { 1690 struct mptsas_hotplug_event *ev = arg; 1691 MPT_ADAPTER *ioc = ev->ioc; 1692 struct mptsas_phyinfo *phy_info; 1693 struct sas_rphy *rphy; 1694 struct scsi_device *sdev; 1695 struct sas_identify identify; 1696 char *ds = NULL; 1697 struct mptsas_devinfo sas_device; 1698 VirtTarget *vtarget; 1699 1700 mutex_lock(&ioc->sas_discovery_mutex); 1701 1702 switch (ev->event_type) { 1703 case MPTSAS_DEL_DEVICE: 1704 1705 phy_info = mptsas_find_phyinfo_by_target(ioc, ev->id); 1706 1707 /* 1708 * Sanity checks, for non-existing phys and remote rphys. 1709 */ 1710 if (!phy_info) 1711 break; 1712 if (!phy_info->rphy) 1713 break; 1714 if (phy_info->starget) { 1715 vtarget = phy_info->starget->hostdata; 1716 1717 if (!vtarget) 1718 break; 1719 /* 1720 * Handling RAID components 1721 */ 1722 if (ev->phys_disk_num_valid) { 1723 vtarget->target_id = ev->phys_disk_num; 1724 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT; 1725 mptsas_reprobe_target(vtarget->starget, 1); 1726 break; 1727 } 1728 } 1729 1730 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SSP_TARGET) 1731 ds = "ssp"; 1732 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_STP_TARGET) 1733 ds = "stp"; 1734 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SATA_DEVICE) 1735 ds = "sata"; 1736 1737 printk(MYIOC_s_INFO_FMT 1738 "removing %s device, channel %d, id %d, phy %d\n", 1739 ioc->name, ds, ev->channel, ev->id, phy_info->phy_id); 1740 1741 sas_rphy_delete(phy_info->rphy); 1742 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo)); 1743 phy_info->rphy = NULL; 1744 phy_info->starget = NULL; 1745 break; 1746 case MPTSAS_ADD_DEVICE: 1747 1748 if (ev->phys_disk_num_valid) 1749 mpt_findImVolumes(ioc); 1750 1751 /* 1752 * Refresh sas device pg0 data 1753 */ 1754 if (mptsas_sas_device_pg0(ioc, &sas_device, 1755 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 1756 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), ev->id)) 1757 break; 1758 1759 phy_info = mptsas_find_phyinfo_by_parent(ioc, 1760 sas_device.handle_parent, sas_device.phy_id); 1761 1762 if (!phy_info) { 1763 u32 handle = 0xFFFF; 1764 1765 /* 1766 * Its possible when an expander has been hot added 1767 * containing attached devices, the sas firmware 1768 * may send a RC_ADDED event prior to the 1769 * DISCOVERY STOP event. If that occurs, our 1770 * view of the topology in the driver in respect to this 1771 * expander might of not been setup, and we hit this 1772 * condition. 1773 * Therefore, this code kicks off discovery to 1774 * refresh the data. 1775 * Then again, we check whether the parent phy has 1776 * been created. 1777 */ 1778 ioc->sas_discovery_runtime=1; 1779 mptsas_delete_expander_phys(ioc); 1780 mptsas_probe_hba_phys(ioc); 1781 while (!mptsas_probe_expander_phys(ioc, &handle)) 1782 ; 1783 ioc->sas_discovery_runtime=0; 1784 1785 phy_info = mptsas_find_phyinfo_by_parent(ioc, 1786 sas_device.handle_parent, sas_device.phy_id); 1787 if (!phy_info) 1788 break; 1789 } 1790 1791 if (phy_info->starget) { 1792 vtarget = phy_info->starget->hostdata; 1793 1794 if (!vtarget) 1795 break; 1796 /* 1797 * Handling RAID components 1798 */ 1799 if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) { 1800 vtarget->tflags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT; 1801 vtarget->target_id = ev->id; 1802 mptsas_reprobe_target(phy_info->starget, 0); 1803 } 1804 break; 1805 } 1806 1807 if (phy_info->rphy) 1808 break; 1809 1810 memcpy(&phy_info->attached, &sas_device, 1811 sizeof(struct mptsas_devinfo)); 1812 1813 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SSP_TARGET) 1814 ds = "ssp"; 1815 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_STP_TARGET) 1816 ds = "stp"; 1817 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SATA_DEVICE) 1818 ds = "sata"; 1819 1820 printk(MYIOC_s_INFO_FMT 1821 "attaching %s device, channel %d, id %d, phy %d\n", 1822 ioc->name, ds, ev->channel, ev->id, ev->phy_id); 1823 1824 mptsas_parse_device_info(&identify, &phy_info->attached); 1825 switch (identify.device_type) { 1826 case SAS_END_DEVICE: 1827 rphy = sas_end_device_alloc(phy_info->phy); 1828 break; 1829 case SAS_EDGE_EXPANDER_DEVICE: 1830 case SAS_FANOUT_EXPANDER_DEVICE: 1831 rphy = sas_expander_alloc(phy_info->phy, identify.device_type); 1832 break; 1833 default: 1834 rphy = NULL; 1835 break; 1836 } 1837 if (!rphy) 1838 break; /* non-fatal: an rphy can be added later */ 1839 1840 rphy->identify = identify; 1841 if (sas_rphy_add(rphy)) { 1842 sas_rphy_free(rphy); 1843 break; 1844 } 1845 1846 phy_info->rphy = rphy; 1847 break; 1848 case MPTSAS_ADD_RAID: 1849 sdev = scsi_device_lookup( 1850 ioc->sh, 1851 ioc->num_ports, 1852 ev->id, 1853 0); 1854 if (sdev) { 1855 scsi_device_put(sdev); 1856 break; 1857 } 1858 printk(MYIOC_s_INFO_FMT 1859 "attaching raid volume, channel %d, id %d\n", 1860 ioc->name, ioc->num_ports, ev->id); 1861 scsi_add_device(ioc->sh, 1862 ioc->num_ports, 1863 ev->id, 1864 0); 1865 mpt_findImVolumes(ioc); 1866 break; 1867 case MPTSAS_DEL_RAID: 1868 sdev = scsi_device_lookup( 1869 ioc->sh, 1870 ioc->num_ports, 1871 ev->id, 1872 0); 1873 if (!sdev) 1874 break; 1875 printk(MYIOC_s_INFO_FMT 1876 "removing raid volume, channel %d, id %d\n", 1877 ioc->name, ioc->num_ports, ev->id); 1878 scsi_remove_device(sdev); 1879 scsi_device_put(sdev); 1880 mpt_findImVolumes(ioc); 1881 break; 1882 case MPTSAS_IGNORE_EVENT: 1883 default: 1884 break; 1885 } 1886 1887 kfree(ev); 1888 mutex_unlock(&ioc->sas_discovery_mutex); 1889 } 1890 1891 static void 1892 mptscsih_send_sas_event(MPT_ADAPTER *ioc, 1893 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data) 1894 { 1895 struct mptsas_hotplug_event *ev; 1896 u32 device_info = le32_to_cpu(sas_event_data->DeviceInfo); 1897 __le64 sas_address; 1898 1899 if ((device_info & 1900 (MPI_SAS_DEVICE_INFO_SSP_TARGET | 1901 MPI_SAS_DEVICE_INFO_STP_TARGET | 1902 MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0) 1903 return; 1904 1905 switch (sas_event_data->ReasonCode) { 1906 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED: 1907 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING: 1908 ev = kmalloc(sizeof(*ev), GFP_ATOMIC); 1909 if (!ev) { 1910 printk(KERN_WARNING "mptsas: lost hotplug event\n"); 1911 break; 1912 } 1913 1914 INIT_WORK(&ev->work, mptsas_hotplug_work, ev); 1915 ev->ioc = ioc; 1916 ev->handle = le16_to_cpu(sas_event_data->DevHandle); 1917 ev->parent_handle = 1918 le16_to_cpu(sas_event_data->ParentDevHandle); 1919 ev->channel = sas_event_data->Bus; 1920 ev->id = sas_event_data->TargetID; 1921 ev->phy_id = sas_event_data->PhyNum; 1922 memcpy(&sas_address, &sas_event_data->SASAddress, 1923 sizeof(__le64)); 1924 ev->sas_address = le64_to_cpu(sas_address); 1925 ev->device_info = device_info; 1926 1927 if (sas_event_data->ReasonCode & 1928 MPI_EVENT_SAS_DEV_STAT_RC_ADDED) 1929 ev->event_type = MPTSAS_ADD_DEVICE; 1930 else 1931 ev->event_type = MPTSAS_DEL_DEVICE; 1932 schedule_work(&ev->work); 1933 break; 1934 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED: 1935 /* 1936 * Persistent table is full. 1937 */ 1938 INIT_WORK(&ioc->mptscsih_persistTask, 1939 mptscsih_sas_persist_clear_table, 1940 (void *)ioc); 1941 schedule_work(&ioc->mptscsih_persistTask); 1942 break; 1943 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA: 1944 /* TODO */ 1945 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET: 1946 /* TODO */ 1947 default: 1948 break; 1949 } 1950 } 1951 1952 static void 1953 mptscsih_send_raid_event(MPT_ADAPTER *ioc, 1954 EVENT_DATA_RAID *raid_event_data) 1955 { 1956 struct mptsas_hotplug_event *ev; 1957 int status = le32_to_cpu(raid_event_data->SettingsStatus); 1958 int state = (status >> 8) & 0xff; 1959 1960 if (ioc->bus_type != SAS) 1961 return; 1962 1963 ev = kmalloc(sizeof(*ev), GFP_ATOMIC); 1964 if (!ev) { 1965 printk(KERN_WARNING "mptsas: lost hotplug event\n"); 1966 return; 1967 } 1968 1969 memset(ev,0,sizeof(struct mptsas_hotplug_event)); 1970 INIT_WORK(&ev->work, mptsas_hotplug_work, ev); 1971 ev->ioc = ioc; 1972 ev->id = raid_event_data->VolumeID; 1973 ev->event_type = MPTSAS_IGNORE_EVENT; 1974 1975 switch (raid_event_data->ReasonCode) { 1976 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED: 1977 ev->event_type = MPTSAS_ADD_DEVICE; 1978 break; 1979 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED: 1980 ioc->raid_data.isRaid = 1; 1981 ev->phys_disk_num_valid = 1; 1982 ev->phys_disk_num = raid_event_data->PhysDiskNum; 1983 ev->event_type = MPTSAS_DEL_DEVICE; 1984 break; 1985 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED: 1986 switch (state) { 1987 case MPI_PD_STATE_ONLINE: 1988 ioc->raid_data.isRaid = 1; 1989 ev->phys_disk_num_valid = 1; 1990 ev->phys_disk_num = raid_event_data->PhysDiskNum; 1991 ev->event_type = MPTSAS_ADD_DEVICE; 1992 break; 1993 case MPI_PD_STATE_MISSING: 1994 case MPI_PD_STATE_NOT_COMPATIBLE: 1995 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST: 1996 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST: 1997 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON: 1998 ev->event_type = MPTSAS_DEL_DEVICE; 1999 break; 2000 default: 2001 break; 2002 } 2003 break; 2004 case MPI_EVENT_RAID_RC_VOLUME_DELETED: 2005 ev->event_type = MPTSAS_DEL_RAID; 2006 break; 2007 case MPI_EVENT_RAID_RC_VOLUME_CREATED: 2008 ev->event_type = MPTSAS_ADD_RAID; 2009 break; 2010 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED: 2011 switch (state) { 2012 case MPI_RAIDVOL0_STATUS_STATE_FAILED: 2013 case MPI_RAIDVOL0_STATUS_STATE_MISSING: 2014 ev->event_type = MPTSAS_DEL_RAID; 2015 break; 2016 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL: 2017 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED: 2018 ev->event_type = MPTSAS_ADD_RAID; 2019 break; 2020 default: 2021 break; 2022 } 2023 break; 2024 default: 2025 break; 2026 } 2027 schedule_work(&ev->work); 2028 } 2029 2030 static void 2031 mptscsih_send_discovery(MPT_ADAPTER *ioc, 2032 EVENT_DATA_SAS_DISCOVERY *discovery_data) 2033 { 2034 struct mptsas_discovery_event *ev; 2035 2036 /* 2037 * DiscoveryStatus 2038 * 2039 * This flag will be non-zero when firmware 2040 * kicks off discovery, and return to zero 2041 * once its completed. 2042 */ 2043 if (discovery_data->DiscoveryStatus) 2044 return; 2045 2046 ev = kmalloc(sizeof(*ev), GFP_ATOMIC); 2047 if (!ev) 2048 return; 2049 memset(ev,0,sizeof(struct mptsas_discovery_event)); 2050 INIT_WORK(&ev->work, mptscsih_discovery_work, ev); 2051 ev->ioc = ioc; 2052 schedule_work(&ev->work); 2053 }; 2054 2055 2056 static int 2057 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply) 2058 { 2059 int rc=1; 2060 u8 event = le32_to_cpu(reply->Event) & 0xFF; 2061 2062 if (!ioc->sh) 2063 goto out; 2064 2065 /* 2066 * sas_discovery_ignore_events 2067 * 2068 * This flag is to prevent anymore processing of 2069 * sas events once mptsas_remove function is called. 2070 */ 2071 if (ioc->sas_discovery_ignore_events) { 2072 rc = mptscsih_event_process(ioc, reply); 2073 goto out; 2074 } 2075 2076 switch (event) { 2077 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE: 2078 mptscsih_send_sas_event(ioc, 2079 (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data); 2080 break; 2081 case MPI_EVENT_INTEGRATED_RAID: 2082 mptscsih_send_raid_event(ioc, 2083 (EVENT_DATA_RAID *)reply->Data); 2084 break; 2085 case MPI_EVENT_PERSISTENT_TABLE_FULL: 2086 INIT_WORK(&ioc->mptscsih_persistTask, 2087 mptscsih_sas_persist_clear_table, 2088 (void *)ioc); 2089 schedule_work(&ioc->mptscsih_persistTask); 2090 break; 2091 case MPI_EVENT_SAS_DISCOVERY: 2092 mptscsih_send_discovery(ioc, 2093 (EVENT_DATA_SAS_DISCOVERY *)reply->Data); 2094 break; 2095 default: 2096 rc = mptscsih_event_process(ioc, reply); 2097 break; 2098 } 2099 out: 2100 2101 return rc; 2102 } 2103 2104 static int 2105 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id) 2106 { 2107 struct Scsi_Host *sh; 2108 MPT_SCSI_HOST *hd; 2109 MPT_ADAPTER *ioc; 2110 unsigned long flags; 2111 int ii; 2112 int numSGE = 0; 2113 int scale; 2114 int ioc_cap; 2115 int error=0; 2116 int r; 2117 2118 r = mpt_attach(pdev,id); 2119 if (r) 2120 return r; 2121 2122 ioc = pci_get_drvdata(pdev); 2123 ioc->DoneCtx = mptsasDoneCtx; 2124 ioc->TaskCtx = mptsasTaskCtx; 2125 ioc->InternalCtx = mptsasInternalCtx; 2126 2127 /* Added sanity check on readiness of the MPT adapter. 2128 */ 2129 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) { 2130 printk(MYIOC_s_WARN_FMT 2131 "Skipping because it's not operational!\n", 2132 ioc->name); 2133 error = -ENODEV; 2134 goto out_mptsas_probe; 2135 } 2136 2137 if (!ioc->active) { 2138 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n", 2139 ioc->name); 2140 error = -ENODEV; 2141 goto out_mptsas_probe; 2142 } 2143 2144 /* Sanity check - ensure at least 1 port is INITIATOR capable 2145 */ 2146 ioc_cap = 0; 2147 for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) { 2148 if (ioc->pfacts[ii].ProtocolFlags & 2149 MPI_PORTFACTS_PROTOCOL_INITIATOR) 2150 ioc_cap++; 2151 } 2152 2153 if (!ioc_cap) { 2154 printk(MYIOC_s_WARN_FMT 2155 "Skipping ioc=%p because SCSI Initiator mode " 2156 "is NOT enabled!\n", ioc->name, ioc); 2157 return 0; 2158 } 2159 2160 sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST)); 2161 if (!sh) { 2162 printk(MYIOC_s_WARN_FMT 2163 "Unable to register controller with SCSI subsystem\n", 2164 ioc->name); 2165 error = -1; 2166 goto out_mptsas_probe; 2167 } 2168 2169 spin_lock_irqsave(&ioc->FreeQlock, flags); 2170 2171 /* Attach the SCSI Host to the IOC structure 2172 */ 2173 ioc->sh = sh; 2174 2175 sh->io_port = 0; 2176 sh->n_io_port = 0; 2177 sh->irq = 0; 2178 2179 /* set 16 byte cdb's */ 2180 sh->max_cmd_len = 16; 2181 2182 sh->max_id = ioc->pfacts->MaxDevices + 1; 2183 2184 sh->transportt = mptsas_transport_template; 2185 2186 sh->max_lun = MPT_LAST_LUN + 1; 2187 sh->max_channel = 0; 2188 sh->this_id = ioc->pfacts[0].PortSCSIID; 2189 2190 /* Required entry. 2191 */ 2192 sh->unique_id = ioc->id; 2193 2194 INIT_LIST_HEAD(&ioc->sas_topology); 2195 mutex_init(&ioc->sas_topology_mutex); 2196 mutex_init(&ioc->sas_discovery_mutex); 2197 mutex_init(&ioc->sas_mgmt.mutex); 2198 init_completion(&ioc->sas_mgmt.done); 2199 2200 /* Verify that we won't exceed the maximum 2201 * number of chain buffers 2202 * We can optimize: ZZ = req_sz/sizeof(SGE) 2203 * For 32bit SGE's: 2204 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ 2205 * + (req_sz - 64)/sizeof(SGE) 2206 * A slightly different algorithm is required for 2207 * 64bit SGEs. 2208 */ 2209 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32)); 2210 if (sizeof(dma_addr_t) == sizeof(u64)) { 2211 numSGE = (scale - 1) * 2212 (ioc->facts.MaxChainDepth-1) + scale + 2213 (ioc->req_sz - 60) / (sizeof(dma_addr_t) + 2214 sizeof(u32)); 2215 } else { 2216 numSGE = 1 + (scale - 1) * 2217 (ioc->facts.MaxChainDepth-1) + scale + 2218 (ioc->req_sz - 64) / (sizeof(dma_addr_t) + 2219 sizeof(u32)); 2220 } 2221 2222 if (numSGE < sh->sg_tablesize) { 2223 /* Reset this value */ 2224 dprintk((MYIOC_s_INFO_FMT 2225 "Resetting sg_tablesize to %d from %d\n", 2226 ioc->name, numSGE, sh->sg_tablesize)); 2227 sh->sg_tablesize = numSGE; 2228 } 2229 2230 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 2231 2232 hd = (MPT_SCSI_HOST *) sh->hostdata; 2233 hd->ioc = ioc; 2234 2235 /* SCSI needs scsi_cmnd lookup table! 2236 * (with size equal to req_depth*PtrSz!) 2237 */ 2238 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC); 2239 if (!hd->ScsiLookup) { 2240 error = -ENOMEM; 2241 goto out_mptsas_probe; 2242 } 2243 2244 dprintk((MYIOC_s_INFO_FMT "ScsiLookup @ %p\n", 2245 ioc->name, hd->ScsiLookup)); 2246 2247 /* Allocate memory for the device structures. 2248 * A non-Null pointer at an offset 2249 * indicates a device exists. 2250 * max_id = 1 + maximum id (hosts.h) 2251 */ 2252 hd->Targets = kcalloc(sh->max_id, sizeof(void *), GFP_ATOMIC); 2253 if (!hd->Targets) { 2254 error = -ENOMEM; 2255 goto out_mptsas_probe; 2256 } 2257 2258 dprintk((KERN_INFO " vtarget @ %p\n", hd->Targets)); 2259 2260 /* Clear the TM flags 2261 */ 2262 hd->tmPending = 0; 2263 hd->tmState = TM_STATE_NONE; 2264 hd->resetPending = 0; 2265 hd->abortSCpnt = NULL; 2266 2267 /* Clear the pointer used to store 2268 * single-threaded commands, i.e., those 2269 * issued during a bus scan, dv and 2270 * configuration pages. 2271 */ 2272 hd->cmdPtr = NULL; 2273 2274 /* Initialize this SCSI Hosts' timers 2275 * To use, set the timer expires field 2276 * and add_timer 2277 */ 2278 init_timer(&hd->timer); 2279 hd->timer.data = (unsigned long) hd; 2280 hd->timer.function = mptscsih_timer_expired; 2281 2282 hd->mpt_pq_filter = mpt_pq_filter; 2283 ioc->sas_data.ptClear = mpt_pt_clear; 2284 2285 if (ioc->sas_data.ptClear==1) { 2286 mptbase_sas_persist_operation( 2287 ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT); 2288 } 2289 2290 ddvprintk((MYIOC_s_INFO_FMT 2291 "mpt_pq_filter %x mpt_pq_filter %x\n", 2292 ioc->name, 2293 mpt_pq_filter, 2294 mpt_pq_filter)); 2295 2296 init_waitqueue_head(&hd->scandv_waitq); 2297 hd->scandv_wait_done = 0; 2298 hd->last_queue_full = 0; 2299 2300 error = scsi_add_host(sh, &ioc->pcidev->dev); 2301 if (error) { 2302 dprintk((KERN_ERR MYNAM 2303 "scsi_add_host failed\n")); 2304 goto out_mptsas_probe; 2305 } 2306 2307 mptsas_scan_sas_topology(ioc); 2308 2309 return 0; 2310 2311 out_mptsas_probe: 2312 2313 mptscsih_remove(pdev); 2314 return error; 2315 } 2316 2317 static void __devexit mptsas_remove(struct pci_dev *pdev) 2318 { 2319 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 2320 struct mptsas_portinfo *p, *n; 2321 2322 ioc->sas_discovery_ignore_events=1; 2323 sas_remove_host(ioc->sh); 2324 2325 mutex_lock(&ioc->sas_topology_mutex); 2326 list_for_each_entry_safe(p, n, &ioc->sas_topology, list) { 2327 list_del(&p->list); 2328 if (p->phy_info) 2329 kfree(p->phy_info); 2330 kfree(p); 2331 } 2332 mutex_unlock(&ioc->sas_topology_mutex); 2333 2334 mptscsih_remove(pdev); 2335 } 2336 2337 static struct pci_device_id mptsas_pci_table[] = { 2338 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064, 2339 PCI_ANY_ID, PCI_ANY_ID }, 2340 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1066, 2341 PCI_ANY_ID, PCI_ANY_ID }, 2342 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1068, 2343 PCI_ANY_ID, PCI_ANY_ID }, 2344 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064E, 2345 PCI_ANY_ID, PCI_ANY_ID }, 2346 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1066E, 2347 PCI_ANY_ID, PCI_ANY_ID }, 2348 { PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1068E, 2349 PCI_ANY_ID, PCI_ANY_ID }, 2350 {0} /* Terminating entry */ 2351 }; 2352 MODULE_DEVICE_TABLE(pci, mptsas_pci_table); 2353 2354 2355 static struct pci_driver mptsas_driver = { 2356 .name = "mptsas", 2357 .id_table = mptsas_pci_table, 2358 .probe = mptsas_probe, 2359 .remove = __devexit_p(mptsas_remove), 2360 .shutdown = mptscsih_shutdown, 2361 #ifdef CONFIG_PM 2362 .suspend = mptscsih_suspend, 2363 .resume = mptscsih_resume, 2364 #endif 2365 }; 2366 2367 static int __init 2368 mptsas_init(void) 2369 { 2370 show_mptmod_ver(my_NAME, my_VERSION); 2371 2372 mptsas_transport_template = 2373 sas_attach_transport(&mptsas_transport_functions); 2374 if (!mptsas_transport_template) 2375 return -ENODEV; 2376 2377 mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER); 2378 mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER); 2379 mptsasInternalCtx = 2380 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER); 2381 mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER); 2382 2383 if (mpt_event_register(mptsasDoneCtx, mptsas_event_process) == 0) { 2384 devtverboseprintk((KERN_INFO MYNAM 2385 ": Registered for IOC event notifications\n")); 2386 } 2387 2388 if (mpt_reset_register(mptsasDoneCtx, mptscsih_ioc_reset) == 0) { 2389 dprintk((KERN_INFO MYNAM 2390 ": Registered for IOC reset notifications\n")); 2391 } 2392 2393 return pci_register_driver(&mptsas_driver); 2394 } 2395 2396 static void __exit 2397 mptsas_exit(void) 2398 { 2399 pci_unregister_driver(&mptsas_driver); 2400 sas_release_transport(mptsas_transport_template); 2401 2402 mpt_reset_deregister(mptsasDoneCtx); 2403 mpt_event_deregister(mptsasDoneCtx); 2404 2405 mpt_deregister(mptsasMgmtCtx); 2406 mpt_deregister(mptsasInternalCtx); 2407 mpt_deregister(mptsasTaskCtx); 2408 mpt_deregister(mptsasDoneCtx); 2409 } 2410 2411 module_init(mptsas_init); 2412 module_exit(mptsas_exit); 2413