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