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