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-2007 LSI Logic Corporation 7 * (mailto:DL-MPTFusionLinux@lsi.com) 8 * Copyright (c) 2005-2007 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/jiffies.h> 52 #include <linux/workqueue.h> 53 #include <linux/delay.h> /* for mdelay */ 54 55 #include <scsi/scsi.h> 56 #include <scsi/scsi_cmnd.h> 57 #include <scsi/scsi_device.h> 58 #include <scsi/scsi_host.h> 59 #include <scsi/scsi_transport_sas.h> 60 #include <scsi/scsi_dbg.h> 61 62 #include "mptbase.h" 63 #include "mptscsih.h" 64 #include "mptsas.h" 65 66 67 #define my_NAME "Fusion MPT SAS Host driver" 68 #define my_VERSION MPT_LINUX_VERSION_COMMON 69 #define MYNAM "mptsas" 70 71 /* 72 * Reserved channel for integrated raid 73 */ 74 #define MPTSAS_RAID_CHANNEL 1 75 76 MODULE_AUTHOR(MODULEAUTHOR); 77 MODULE_DESCRIPTION(my_NAME); 78 MODULE_LICENSE("GPL"); 79 MODULE_VERSION(my_VERSION); 80 81 static int mpt_pt_clear; 82 module_param(mpt_pt_clear, int, 0); 83 MODULE_PARM_DESC(mpt_pt_clear, 84 " Clear persistency table: enable=1 " 85 "(default=MPTSCSIH_PT_CLEAR=0)"); 86 87 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */ 88 #define MPTSAS_MAX_LUN (16895) 89 static int max_lun = MPTSAS_MAX_LUN; 90 module_param(max_lun, int, 0); 91 MODULE_PARM_DESC(max_lun, " max lun, default=16895 "); 92 93 static u8 mptsasDoneCtx = MPT_MAX_PROTOCOL_DRIVERS; 94 static u8 mptsasTaskCtx = MPT_MAX_PROTOCOL_DRIVERS; 95 static u8 mptsasInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */ 96 static u8 mptsasMgmtCtx = MPT_MAX_PROTOCOL_DRIVERS; 97 98 static void mptsas_hotplug_work(struct work_struct *work); 99 100 static void mptsas_print_phy_data(MPT_ADAPTER *ioc, 101 MPI_SAS_IO_UNIT0_PHY_DATA *phy_data) 102 { 103 dsasprintk(ioc, printk(KERN_DEBUG "---- IO UNIT PAGE 0 ------------\n")); 104 dsasprintk(ioc, printk(KERN_DEBUG "Handle=0x%X\n", 105 le16_to_cpu(phy_data->AttachedDeviceHandle))); 106 dsasprintk(ioc, printk(KERN_DEBUG "Controller Handle=0x%X\n", 107 le16_to_cpu(phy_data->ControllerDevHandle))); 108 dsasprintk(ioc, printk(KERN_DEBUG "Port=0x%X\n", phy_data->Port)); 109 dsasprintk(ioc, printk(KERN_DEBUG "Port Flags=0x%X\n", phy_data->PortFlags)); 110 dsasprintk(ioc, printk(KERN_DEBUG "PHY Flags=0x%X\n", phy_data->PhyFlags)); 111 dsasprintk(ioc, printk(KERN_DEBUG "Negotiated Link Rate=0x%X\n", phy_data->NegotiatedLinkRate)); 112 dsasprintk(ioc, printk(KERN_DEBUG "Controller PHY Device Info=0x%X\n", 113 le32_to_cpu(phy_data->ControllerPhyDeviceInfo))); 114 dsasprintk(ioc, printk(KERN_DEBUG "DiscoveryStatus=0x%X\n\n", 115 le32_to_cpu(phy_data->DiscoveryStatus))); 116 } 117 118 static void mptsas_print_phy_pg0(MPT_ADAPTER *ioc, SasPhyPage0_t *pg0) 119 { 120 __le64 sas_address; 121 122 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64)); 123 124 dsasprintk(ioc, printk(KERN_DEBUG "---- SAS PHY PAGE 0 ------------\n")); 125 dsasprintk(ioc, printk(KERN_DEBUG "Attached Device Handle=0x%X\n", 126 le16_to_cpu(pg0->AttachedDevHandle))); 127 dsasprintk(ioc, printk(KERN_DEBUG "SAS Address=0x%llX\n", 128 (unsigned long long)le64_to_cpu(sas_address))); 129 dsasprintk(ioc, printk(KERN_DEBUG "Attached PHY Identifier=0x%X\n", pg0->AttachedPhyIdentifier)); 130 dsasprintk(ioc, printk(KERN_DEBUG "Attached Device Info=0x%X\n", 131 le32_to_cpu(pg0->AttachedDeviceInfo))); 132 dsasprintk(ioc, printk(KERN_DEBUG "Programmed Link Rate=0x%X\n", pg0->ProgrammedLinkRate)); 133 dsasprintk(ioc, printk(KERN_DEBUG "Change Count=0x%X\n", pg0->ChangeCount)); 134 dsasprintk(ioc, printk(KERN_DEBUG "PHY Info=0x%X\n\n", le32_to_cpu(pg0->PhyInfo))); 135 } 136 137 static void mptsas_print_phy_pg1(MPT_ADAPTER *ioc, SasPhyPage1_t *pg1) 138 { 139 dsasprintk(ioc, printk(KERN_DEBUG "---- SAS PHY PAGE 1 ------------\n")); 140 dsasprintk(ioc, printk(KERN_DEBUG "Invalid Dword Count=0x%x\n", pg1->InvalidDwordCount)); 141 dsasprintk(ioc, printk(KERN_DEBUG "Running Disparity Error Count=0x%x\n", 142 pg1->RunningDisparityErrorCount)); 143 dsasprintk(ioc, printk(KERN_DEBUG "Loss Dword Synch Count=0x%x\n", pg1->LossDwordSynchCount)); 144 dsasprintk(ioc, printk(KERN_DEBUG "PHY Reset Problem Count=0x%x\n\n", pg1->PhyResetProblemCount)); 145 } 146 147 static void mptsas_print_device_pg0(MPT_ADAPTER *ioc, SasDevicePage0_t *pg0) 148 { 149 __le64 sas_address; 150 151 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64)); 152 153 dsasprintk(ioc, printk(KERN_DEBUG "---- SAS DEVICE PAGE 0 ---------\n")); 154 dsasprintk(ioc, printk(KERN_DEBUG "Handle=0x%X\n" ,le16_to_cpu(pg0->DevHandle))); 155 dsasprintk(ioc, printk(KERN_DEBUG "Parent Handle=0x%X\n" ,le16_to_cpu(pg0->ParentDevHandle))); 156 dsasprintk(ioc, printk(KERN_DEBUG "Enclosure Handle=0x%X\n", le16_to_cpu(pg0->EnclosureHandle))); 157 dsasprintk(ioc, printk(KERN_DEBUG "Slot=0x%X\n", le16_to_cpu(pg0->Slot))); 158 dsasprintk(ioc, printk(KERN_DEBUG "SAS Address=0x%llX\n", (unsigned long long) 159 le64_to_cpu(sas_address))); 160 dsasprintk(ioc, printk(KERN_DEBUG "Target ID=0x%X\n", pg0->TargetID)); 161 dsasprintk(ioc, printk(KERN_DEBUG "Bus=0x%X\n", pg0->Bus)); 162 /* The PhyNum field specifies the PHY number of the parent 163 * device this device is linked to 164 */ 165 dsasprintk(ioc, printk(KERN_DEBUG "Parent Phy Num=0x%X\n", pg0->PhyNum)); 166 dsasprintk(ioc, printk(KERN_DEBUG "Access Status=0x%X\n", le16_to_cpu(pg0->AccessStatus))); 167 dsasprintk(ioc, printk(KERN_DEBUG "Device Info=0x%X\n", le32_to_cpu(pg0->DeviceInfo))); 168 dsasprintk(ioc, printk(KERN_DEBUG "Flags=0x%X\n", le16_to_cpu(pg0->Flags))); 169 dsasprintk(ioc, printk(KERN_DEBUG "Physical Port=0x%X\n\n", pg0->PhysicalPort)); 170 } 171 172 static void mptsas_print_expander_pg1(MPT_ADAPTER *ioc, SasExpanderPage1_t *pg1) 173 { 174 dsasprintk(ioc, printk(KERN_DEBUG "---- SAS EXPANDER PAGE 1 ------------\n")); 175 dsasprintk(ioc, printk(KERN_DEBUG "Physical Port=0x%X\n", pg1->PhysicalPort)); 176 dsasprintk(ioc, printk(KERN_DEBUG "PHY Identifier=0x%X\n", pg1->PhyIdentifier)); 177 dsasprintk(ioc, printk(KERN_DEBUG "Negotiated Link Rate=0x%X\n", pg1->NegotiatedLinkRate)); 178 dsasprintk(ioc, printk(KERN_DEBUG "Programmed Link Rate=0x%X\n", pg1->ProgrammedLinkRate)); 179 dsasprintk(ioc, printk(KERN_DEBUG "Hardware Link Rate=0x%X\n", pg1->HwLinkRate)); 180 dsasprintk(ioc, printk(KERN_DEBUG "Owner Device Handle=0x%X\n", 181 le16_to_cpu(pg1->OwnerDevHandle))); 182 dsasprintk(ioc, printk(KERN_DEBUG "Attached Device Handle=0x%X\n\n", 183 le16_to_cpu(pg1->AttachedDevHandle))); 184 } 185 186 static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy) 187 { 188 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 189 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc; 190 } 191 192 static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy) 193 { 194 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent); 195 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc; 196 } 197 198 /* 199 * mptsas_find_portinfo_by_handle 200 * 201 * This function should be called with the sas_topology_mutex already held 202 */ 203 static struct mptsas_portinfo * 204 mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle) 205 { 206 struct mptsas_portinfo *port_info, *rc=NULL; 207 int i; 208 209 list_for_each_entry(port_info, &ioc->sas_topology, list) 210 for (i = 0; i < port_info->num_phys; i++) 211 if (port_info->phy_info[i].identify.handle == handle) { 212 rc = port_info; 213 goto out; 214 } 215 out: 216 return rc; 217 } 218 219 /* 220 * Returns true if there is a scsi end device 221 */ 222 static inline int 223 mptsas_is_end_device(struct mptsas_devinfo * attached) 224 { 225 if ((attached->sas_address) && 226 (attached->device_info & 227 MPI_SAS_DEVICE_INFO_END_DEVICE) && 228 ((attached->device_info & 229 MPI_SAS_DEVICE_INFO_SSP_TARGET) | 230 (attached->device_info & 231 MPI_SAS_DEVICE_INFO_STP_TARGET) | 232 (attached->device_info & 233 MPI_SAS_DEVICE_INFO_SATA_DEVICE))) 234 return 1; 235 else 236 return 0; 237 } 238 239 /* no mutex */ 240 static void 241 mptsas_port_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo_details * port_details) 242 { 243 struct mptsas_portinfo *port_info; 244 struct mptsas_phyinfo *phy_info; 245 u8 i; 246 247 if (!port_details) 248 return; 249 250 port_info = port_details->port_info; 251 phy_info = port_info->phy_info; 252 253 dsaswideprintk(ioc, printk(KERN_DEBUG "%s: [%p]: num_phys=%02d " 254 "bitmask=0x%016llX\n", __FUNCTION__, port_details, 255 port_details->num_phys, (unsigned long long) 256 port_details->phy_bitmask)); 257 258 for (i = 0; i < port_info->num_phys; i++, phy_info++) { 259 if(phy_info->port_details != port_details) 260 continue; 261 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo)); 262 phy_info->port_details = NULL; 263 } 264 kfree(port_details); 265 } 266 267 static inline struct sas_rphy * 268 mptsas_get_rphy(struct mptsas_phyinfo *phy_info) 269 { 270 if (phy_info->port_details) 271 return phy_info->port_details->rphy; 272 else 273 return NULL; 274 } 275 276 static inline void 277 mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy) 278 { 279 if (phy_info->port_details) { 280 phy_info->port_details->rphy = rphy; 281 dsaswideprintk(ioc, printk(KERN_DEBUG "sas_rphy_add: rphy=%p\n", rphy)); 282 } 283 284 if (rphy) { 285 dsaswideprintk(ioc, dev_printk(KERN_DEBUG, 286 &rphy->dev, "add:")); 287 dsaswideprintk(ioc, printk(KERN_DEBUG "rphy=%p release=%p\n", 288 rphy, rphy->dev.release)); 289 } 290 } 291 292 static inline struct sas_port * 293 mptsas_get_port(struct mptsas_phyinfo *phy_info) 294 { 295 if (phy_info->port_details) 296 return phy_info->port_details->port; 297 else 298 return NULL; 299 } 300 301 static inline void 302 mptsas_set_port(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_port *port) 303 { 304 if (phy_info->port_details) 305 phy_info->port_details->port = port; 306 307 if (port) { 308 dsaswideprintk(ioc, dev_printk(KERN_DEBUG, 309 &port->dev, "add:")); 310 dsaswideprintk(ioc, printk(KERN_DEBUG "port=%p release=%p\n", 311 port, port->dev.release)); 312 } 313 } 314 315 static inline struct scsi_target * 316 mptsas_get_starget(struct mptsas_phyinfo *phy_info) 317 { 318 if (phy_info->port_details) 319 return phy_info->port_details->starget; 320 else 321 return NULL; 322 } 323 324 static inline void 325 mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target * 326 starget) 327 { 328 if (phy_info->port_details) 329 phy_info->port_details->starget = starget; 330 } 331 332 333 /* 334 * mptsas_setup_wide_ports 335 * 336 * Updates for new and existing narrow/wide port configuration 337 * in the sas_topology 338 */ 339 static void 340 mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info) 341 { 342 struct mptsas_portinfo_details * port_details; 343 struct mptsas_phyinfo *phy_info, *phy_info_cmp; 344 u64 sas_address; 345 int i, j; 346 347 mutex_lock(&ioc->sas_topology_mutex); 348 349 phy_info = port_info->phy_info; 350 for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) { 351 if (phy_info->attached.handle) 352 continue; 353 port_details = phy_info->port_details; 354 if (!port_details) 355 continue; 356 if (port_details->num_phys < 2) 357 continue; 358 /* 359 * Removing a phy from a port, letting the last 360 * phy be removed by firmware events. 361 */ 362 dsaswideprintk(ioc, printk(KERN_DEBUG 363 "%s: [%p]: deleting phy = %d\n", 364 __FUNCTION__, port_details, i)); 365 port_details->num_phys--; 366 port_details->phy_bitmask &= ~ (1 << phy_info->phy_id); 367 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo)); 368 sas_port_delete_phy(port_details->port, phy_info->phy); 369 phy_info->port_details = NULL; 370 } 371 372 /* 373 * Populate and refresh the tree 374 */ 375 phy_info = port_info->phy_info; 376 for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) { 377 sas_address = phy_info->attached.sas_address; 378 dsaswideprintk(ioc, printk(KERN_DEBUG "phy_id=%d sas_address=0x%018llX\n", 379 i, (unsigned long long)sas_address)); 380 if (!sas_address) 381 continue; 382 port_details = phy_info->port_details; 383 /* 384 * Forming a port 385 */ 386 if (!port_details) { 387 port_details = kzalloc(sizeof(*port_details), 388 GFP_KERNEL); 389 if (!port_details) 390 goto out; 391 port_details->num_phys = 1; 392 port_details->port_info = port_info; 393 if (phy_info->phy_id < 64 ) 394 port_details->phy_bitmask |= 395 (1 << phy_info->phy_id); 396 phy_info->sas_port_add_phy=1; 397 dsaswideprintk(ioc, printk(KERN_DEBUG "\t\tForming port\n\t\t" 398 "phy_id=%d sas_address=0x%018llX\n", 399 i, (unsigned long long)sas_address)); 400 phy_info->port_details = port_details; 401 } 402 403 if (i == port_info->num_phys - 1) 404 continue; 405 phy_info_cmp = &port_info->phy_info[i + 1]; 406 for (j = i + 1 ; j < port_info->num_phys ; j++, 407 phy_info_cmp++) { 408 if (!phy_info_cmp->attached.sas_address) 409 continue; 410 if (sas_address != phy_info_cmp->attached.sas_address) 411 continue; 412 if (phy_info_cmp->port_details == port_details ) 413 continue; 414 dsaswideprintk(ioc, printk(KERN_DEBUG 415 "\t\tphy_id=%d sas_address=0x%018llX\n", 416 j, (unsigned long long) 417 phy_info_cmp->attached.sas_address)); 418 if (phy_info_cmp->port_details) { 419 port_details->rphy = 420 mptsas_get_rphy(phy_info_cmp); 421 port_details->port = 422 mptsas_get_port(phy_info_cmp); 423 port_details->starget = 424 mptsas_get_starget(phy_info_cmp); 425 port_details->num_phys = 426 phy_info_cmp->port_details->num_phys; 427 if (!phy_info_cmp->port_details->num_phys) 428 kfree(phy_info_cmp->port_details); 429 } else 430 phy_info_cmp->sas_port_add_phy=1; 431 /* 432 * Adding a phy to a port 433 */ 434 phy_info_cmp->port_details = port_details; 435 if (phy_info_cmp->phy_id < 64 ) 436 port_details->phy_bitmask |= 437 (1 << phy_info_cmp->phy_id); 438 port_details->num_phys++; 439 } 440 } 441 442 out: 443 444 for (i = 0; i < port_info->num_phys; i++) { 445 port_details = port_info->phy_info[i].port_details; 446 if (!port_details) 447 continue; 448 dsaswideprintk(ioc, printk(KERN_DEBUG 449 "%s: [%p]: phy_id=%02d num_phys=%02d " 450 "bitmask=0x%016llX\n", __FUNCTION__, 451 port_details, i, port_details->num_phys, 452 (unsigned long long)port_details->phy_bitmask)); 453 dsaswideprintk(ioc, printk(KERN_DEBUG"\t\tport = %p rphy=%p\n", 454 port_details->port, port_details->rphy)); 455 } 456 dsaswideprintk(ioc, printk(KERN_DEBUG"\n")); 457 mutex_unlock(&ioc->sas_topology_mutex); 458 } 459 460 /** 461 * csmisas_find_vtarget 462 * 463 * @ioc 464 * @volume_id 465 * @volume_bus 466 * 467 **/ 468 static VirtTarget * 469 mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id) 470 { 471 struct scsi_device *sdev; 472 VirtDevice *vdev; 473 VirtTarget *vtarget = NULL; 474 475 shost_for_each_device(sdev, ioc->sh) { 476 if ((vdev = sdev->hostdata) == NULL) 477 continue; 478 if (vdev->vtarget->id == id && 479 vdev->vtarget->channel == channel) 480 vtarget = vdev->vtarget; 481 } 482 return vtarget; 483 } 484 485 /** 486 * mptsas_target_reset 487 * 488 * Issues TARGET_RESET to end device using handshaking method 489 * 490 * @ioc 491 * @channel 492 * @id 493 * 494 * Returns (1) success 495 * (0) failure 496 * 497 **/ 498 static int 499 mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id) 500 { 501 MPT_FRAME_HDR *mf; 502 SCSITaskMgmt_t *pScsiTm; 503 504 if ((mf = mpt_get_msg_frame(ioc->TaskCtx, ioc)) == NULL) { 505 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, no msg frames @%d!!\n", 506 ioc->name,__FUNCTION__, __LINE__)); 507 return 0; 508 } 509 510 /* Format the Request 511 */ 512 pScsiTm = (SCSITaskMgmt_t *) mf; 513 memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t)); 514 pScsiTm->TargetID = id; 515 pScsiTm->Bus = channel; 516 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT; 517 pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET; 518 pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION; 519 520 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf); 521 522 mpt_put_msg_frame_hi_pri(ioc->TaskCtx, ioc, mf); 523 524 return 1; 525 } 526 527 /** 528 * mptsas_target_reset_queue 529 * 530 * Receive request for TARGET_RESET after recieving an firmware 531 * event NOT_RESPONDING_EVENT, then put command in link list 532 * and queue if task_queue already in use. 533 * 534 * @ioc 535 * @sas_event_data 536 * 537 **/ 538 static void 539 mptsas_target_reset_queue(MPT_ADAPTER *ioc, 540 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data) 541 { 542 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata; 543 VirtTarget *vtarget = NULL; 544 struct mptsas_target_reset_event *target_reset_list; 545 u8 id, channel; 546 547 id = sas_event_data->TargetID; 548 channel = sas_event_data->Bus; 549 550 if (!(vtarget = mptsas_find_vtarget(ioc, channel, id))) 551 return; 552 553 vtarget->deleted = 1; /* block IO */ 554 555 target_reset_list = kzalloc(sizeof(*target_reset_list), 556 GFP_ATOMIC); 557 if (!target_reset_list) { 558 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n", 559 ioc->name,__FUNCTION__, __LINE__)); 560 return; 561 } 562 563 memcpy(&target_reset_list->sas_event_data, sas_event_data, 564 sizeof(*sas_event_data)); 565 list_add_tail(&target_reset_list->list, &hd->target_reset_list); 566 567 if (hd->resetPending) 568 return; 569 570 if (mptsas_target_reset(ioc, channel, id)) { 571 target_reset_list->target_reset_issued = 1; 572 hd->resetPending = 1; 573 } 574 } 575 576 /** 577 * mptsas_dev_reset_complete 578 * 579 * Completion for TARGET_RESET after NOT_RESPONDING_EVENT, 580 * enable work queue to finish off removing device from upper layers. 581 * then send next TARGET_RESET in the queue. 582 * 583 * @ioc 584 * 585 **/ 586 static void 587 mptsas_dev_reset_complete(MPT_ADAPTER *ioc) 588 { 589 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)ioc->sh->hostdata; 590 struct list_head *head = &hd->target_reset_list; 591 struct mptsas_target_reset_event *target_reset_list; 592 struct mptsas_hotplug_event *ev; 593 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data; 594 u8 id, channel; 595 __le64 sas_address; 596 597 if (list_empty(head)) 598 return; 599 600 target_reset_list = list_entry(head->next, struct mptsas_target_reset_event, list); 601 602 sas_event_data = &target_reset_list->sas_event_data; 603 id = sas_event_data->TargetID; 604 channel = sas_event_data->Bus; 605 hd->resetPending = 0; 606 607 /* 608 * retry target reset 609 */ 610 if (!target_reset_list->target_reset_issued) { 611 if (mptsas_target_reset(ioc, channel, id)) { 612 target_reset_list->target_reset_issued = 1; 613 hd->resetPending = 1; 614 } 615 return; 616 } 617 618 /* 619 * enable work queue to remove device from upper layers 620 */ 621 list_del(&target_reset_list->list); 622 623 ev = kzalloc(sizeof(*ev), GFP_ATOMIC); 624 if (!ev) { 625 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT "%s, failed to allocate mem @%d..!!\n", 626 ioc->name,__FUNCTION__, __LINE__)); 627 return; 628 } 629 630 INIT_WORK(&ev->work, mptsas_hotplug_work); 631 ev->ioc = ioc; 632 ev->handle = le16_to_cpu(sas_event_data->DevHandle); 633 ev->parent_handle = 634 le16_to_cpu(sas_event_data->ParentDevHandle); 635 ev->channel = channel; 636 ev->id =id; 637 ev->phy_id = sas_event_data->PhyNum; 638 memcpy(&sas_address, &sas_event_data->SASAddress, 639 sizeof(__le64)); 640 ev->sas_address = le64_to_cpu(sas_address); 641 ev->device_info = le32_to_cpu(sas_event_data->DeviceInfo); 642 ev->event_type = MPTSAS_DEL_DEVICE; 643 schedule_work(&ev->work); 644 kfree(target_reset_list); 645 646 /* 647 * issue target reset to next device in the queue 648 */ 649 650 head = &hd->target_reset_list; 651 if (list_empty(head)) 652 return; 653 654 target_reset_list = list_entry(head->next, struct mptsas_target_reset_event, 655 list); 656 657 sas_event_data = &target_reset_list->sas_event_data; 658 id = sas_event_data->TargetID; 659 channel = sas_event_data->Bus; 660 661 if (mptsas_target_reset(ioc, channel, id)) { 662 target_reset_list->target_reset_issued = 1; 663 hd->resetPending = 1; 664 } 665 } 666 667 /** 668 * mptsas_taskmgmt_complete 669 * 670 * @ioc 671 * @mf 672 * @mr 673 * 674 **/ 675 static int 676 mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr) 677 { 678 mptsas_dev_reset_complete(ioc); 679 return mptscsih_taskmgmt_complete(ioc, mf, mr); 680 } 681 682 /** 683 * mptscsih_ioc_reset 684 * 685 * @ioc 686 * @reset_phase 687 * 688 **/ 689 static int 690 mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) 691 { 692 MPT_SCSI_HOST *hd; 693 struct mptsas_target_reset_event *target_reset_list, *n; 694 int rc; 695 696 rc = mptscsih_ioc_reset(ioc, reset_phase); 697 698 if (ioc->bus_type != SAS) 699 goto out; 700 701 if (reset_phase != MPT_IOC_POST_RESET) 702 goto out; 703 704 if (!ioc->sh || !ioc->sh->hostdata) 705 goto out; 706 hd = (MPT_SCSI_HOST *)ioc->sh->hostdata; 707 if (!hd->ioc) 708 goto out; 709 710 if (list_empty(&hd->target_reset_list)) 711 goto out; 712 713 /* flush the target_reset_list */ 714 list_for_each_entry_safe(target_reset_list, n, 715 &hd->target_reset_list, list) { 716 list_del(&target_reset_list->list); 717 kfree(target_reset_list); 718 } 719 720 out: 721 return rc; 722 } 723 724 static int 725 mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure, 726 u32 form, u32 form_specific) 727 { 728 ConfigExtendedPageHeader_t hdr; 729 CONFIGPARMS cfg; 730 SasEnclosurePage0_t *buffer; 731 dma_addr_t dma_handle; 732 int error; 733 __le64 le_identifier; 734 735 memset(&hdr, 0, sizeof(hdr)); 736 hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION; 737 hdr.PageNumber = 0; 738 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 739 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE; 740 741 cfg.cfghdr.ehdr = &hdr; 742 cfg.physAddr = -1; 743 cfg.pageAddr = form + form_specific; 744 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 745 cfg.dir = 0; /* read */ 746 cfg.timeout = 10; 747 748 error = mpt_config(ioc, &cfg); 749 if (error) 750 goto out; 751 if (!hdr.ExtPageLength) { 752 error = -ENXIO; 753 goto out; 754 } 755 756 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 757 &dma_handle); 758 if (!buffer) { 759 error = -ENOMEM; 760 goto out; 761 } 762 763 cfg.physAddr = dma_handle; 764 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 765 766 error = mpt_config(ioc, &cfg); 767 if (error) 768 goto out_free_consistent; 769 770 /* save config data */ 771 memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64)); 772 enclosure->enclosure_logical_id = le64_to_cpu(le_identifier); 773 enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle); 774 enclosure->flags = le16_to_cpu(buffer->Flags); 775 enclosure->num_slot = le16_to_cpu(buffer->NumSlots); 776 enclosure->start_slot = le16_to_cpu(buffer->StartSlot); 777 enclosure->start_id = buffer->StartTargetID; 778 enclosure->start_channel = buffer->StartBus; 779 enclosure->sep_id = buffer->SEPTargetID; 780 enclosure->sep_channel = buffer->SEPBus; 781 782 out_free_consistent: 783 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 784 buffer, dma_handle); 785 out: 786 return error; 787 } 788 789 static int 790 mptsas_slave_configure(struct scsi_device *sdev) 791 { 792 793 if (sdev->channel == MPTSAS_RAID_CHANNEL) 794 goto out; 795 796 sas_read_port_mode_page(sdev); 797 798 out: 799 return mptscsih_slave_configure(sdev); 800 } 801 802 static int 803 mptsas_target_alloc(struct scsi_target *starget) 804 { 805 struct Scsi_Host *host = dev_to_shost(&starget->dev); 806 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; 807 VirtTarget *vtarget; 808 u8 id, channel; 809 struct sas_rphy *rphy; 810 struct mptsas_portinfo *p; 811 int i; 812 813 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL); 814 if (!vtarget) 815 return -ENOMEM; 816 817 vtarget->starget = starget; 818 vtarget->ioc_id = hd->ioc->id; 819 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES; 820 id = starget->id; 821 channel = 0; 822 823 /* 824 * RAID volumes placed beyond the last expected port. 825 */ 826 if (starget->channel == MPTSAS_RAID_CHANNEL) { 827 for (i=0; i < hd->ioc->raid_data.pIocPg2->NumActiveVolumes; i++) 828 if (id == hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID) 829 channel = hd->ioc->raid_data.pIocPg2->RaidVolume[i].VolumeBus; 830 goto out; 831 } 832 833 rphy = dev_to_rphy(starget->dev.parent); 834 mutex_lock(&hd->ioc->sas_topology_mutex); 835 list_for_each_entry(p, &hd->ioc->sas_topology, list) { 836 for (i = 0; i < p->num_phys; i++) { 837 if (p->phy_info[i].attached.sas_address != 838 rphy->identify.sas_address) 839 continue; 840 id = p->phy_info[i].attached.id; 841 channel = p->phy_info[i].attached.channel; 842 mptsas_set_starget(&p->phy_info[i], starget); 843 844 /* 845 * Exposing hidden raid components 846 */ 847 if (mptscsih_is_phys_disk(hd->ioc, channel, id)) { 848 id = mptscsih_raid_id_to_num(hd->ioc, 849 channel, id); 850 vtarget->tflags |= 851 MPT_TARGET_FLAGS_RAID_COMPONENT; 852 p->phy_info[i].attached.phys_disk_num = id; 853 } 854 mutex_unlock(&hd->ioc->sas_topology_mutex); 855 goto out; 856 } 857 } 858 mutex_unlock(&hd->ioc->sas_topology_mutex); 859 860 kfree(vtarget); 861 return -ENXIO; 862 863 out: 864 vtarget->id = id; 865 vtarget->channel = channel; 866 starget->hostdata = vtarget; 867 return 0; 868 } 869 870 static void 871 mptsas_target_destroy(struct scsi_target *starget) 872 { 873 struct Scsi_Host *host = dev_to_shost(&starget->dev); 874 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; 875 struct sas_rphy *rphy; 876 struct mptsas_portinfo *p; 877 int i; 878 879 if (!starget->hostdata) 880 return; 881 882 if (starget->channel == MPTSAS_RAID_CHANNEL) 883 goto out; 884 885 rphy = dev_to_rphy(starget->dev.parent); 886 list_for_each_entry(p, &hd->ioc->sas_topology, list) { 887 for (i = 0; i < p->num_phys; i++) { 888 if (p->phy_info[i].attached.sas_address != 889 rphy->identify.sas_address) 890 continue; 891 mptsas_set_starget(&p->phy_info[i], NULL); 892 goto out; 893 } 894 } 895 896 out: 897 kfree(starget->hostdata); 898 starget->hostdata = NULL; 899 } 900 901 902 static int 903 mptsas_slave_alloc(struct scsi_device *sdev) 904 { 905 struct Scsi_Host *host = sdev->host; 906 MPT_SCSI_HOST *hd = (MPT_SCSI_HOST *)host->hostdata; 907 struct sas_rphy *rphy; 908 struct mptsas_portinfo *p; 909 VirtDevice *vdev; 910 struct scsi_target *starget; 911 int i; 912 913 vdev = kzalloc(sizeof(VirtDevice), GFP_KERNEL); 914 if (!vdev) { 915 printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n", 916 hd->ioc->name, sizeof(VirtDevice)); 917 return -ENOMEM; 918 } 919 starget = scsi_target(sdev); 920 vdev->vtarget = starget->hostdata; 921 922 if (sdev->channel == MPTSAS_RAID_CHANNEL) 923 goto out; 924 925 rphy = dev_to_rphy(sdev->sdev_target->dev.parent); 926 mutex_lock(&hd->ioc->sas_topology_mutex); 927 list_for_each_entry(p, &hd->ioc->sas_topology, list) { 928 for (i = 0; i < p->num_phys; i++) { 929 if (p->phy_info[i].attached.sas_address != 930 rphy->identify.sas_address) 931 continue; 932 vdev->lun = sdev->lun; 933 /* 934 * Exposing hidden raid components 935 */ 936 if (mptscsih_is_phys_disk(hd->ioc, 937 p->phy_info[i].attached.channel, 938 p->phy_info[i].attached.id)) 939 sdev->no_uld_attach = 1; 940 mutex_unlock(&hd->ioc->sas_topology_mutex); 941 goto out; 942 } 943 } 944 mutex_unlock(&hd->ioc->sas_topology_mutex); 945 946 kfree(vdev); 947 return -ENXIO; 948 949 out: 950 vdev->vtarget->num_luns++; 951 sdev->hostdata = vdev; 952 return 0; 953 } 954 955 static int 956 mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 957 { 958 VirtDevice *vdev = SCpnt->device->hostdata; 959 960 if (!vdev || !vdev->vtarget || vdev->vtarget->deleted) { 961 SCpnt->result = DID_NO_CONNECT << 16; 962 done(SCpnt); 963 return 0; 964 } 965 966 // scsi_print_command(SCpnt); 967 968 return mptscsih_qcmd(SCpnt,done); 969 } 970 971 972 static struct scsi_host_template mptsas_driver_template = { 973 .module = THIS_MODULE, 974 .proc_name = "mptsas", 975 .proc_info = mptscsih_proc_info, 976 .name = "MPT SPI Host", 977 .info = mptscsih_info, 978 .queuecommand = mptsas_qcmd, 979 .target_alloc = mptsas_target_alloc, 980 .slave_alloc = mptsas_slave_alloc, 981 .slave_configure = mptsas_slave_configure, 982 .target_destroy = mptsas_target_destroy, 983 .slave_destroy = mptscsih_slave_destroy, 984 .change_queue_depth = mptscsih_change_queue_depth, 985 .eh_abort_handler = mptscsih_abort, 986 .eh_device_reset_handler = mptscsih_dev_reset, 987 .eh_bus_reset_handler = mptscsih_bus_reset, 988 .eh_host_reset_handler = mptscsih_host_reset, 989 .bios_param = mptscsih_bios_param, 990 .can_queue = MPT_FC_CAN_QUEUE, 991 .this_id = -1, 992 .sg_tablesize = MPT_SCSI_SG_DEPTH, 993 .max_sectors = 8192, 994 .cmd_per_lun = 7, 995 .use_clustering = ENABLE_CLUSTERING, 996 .shost_attrs = mptscsih_host_attrs, 997 }; 998 999 static int mptsas_get_linkerrors(struct sas_phy *phy) 1000 { 1001 MPT_ADAPTER *ioc = phy_to_ioc(phy); 1002 ConfigExtendedPageHeader_t hdr; 1003 CONFIGPARMS cfg; 1004 SasPhyPage1_t *buffer; 1005 dma_addr_t dma_handle; 1006 int error; 1007 1008 /* FIXME: only have link errors on local phys */ 1009 if (!scsi_is_sas_phy_local(phy)) 1010 return -EINVAL; 1011 1012 hdr.PageVersion = MPI_SASPHY1_PAGEVERSION; 1013 hdr.ExtPageLength = 0; 1014 hdr.PageNumber = 1 /* page number 1*/; 1015 hdr.Reserved1 = 0; 1016 hdr.Reserved2 = 0; 1017 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 1018 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY; 1019 1020 cfg.cfghdr.ehdr = &hdr; 1021 cfg.physAddr = -1; 1022 cfg.pageAddr = phy->identify.phy_identifier; 1023 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 1024 cfg.dir = 0; /* read */ 1025 cfg.timeout = 10; 1026 1027 error = mpt_config(ioc, &cfg); 1028 if (error) 1029 return error; 1030 if (!hdr.ExtPageLength) 1031 return -ENXIO; 1032 1033 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1034 &dma_handle); 1035 if (!buffer) 1036 return -ENOMEM; 1037 1038 cfg.physAddr = dma_handle; 1039 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 1040 1041 error = mpt_config(ioc, &cfg); 1042 if (error) 1043 goto out_free_consistent; 1044 1045 mptsas_print_phy_pg1(ioc, buffer); 1046 1047 phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount); 1048 phy->running_disparity_error_count = 1049 le32_to_cpu(buffer->RunningDisparityErrorCount); 1050 phy->loss_of_dword_sync_count = 1051 le32_to_cpu(buffer->LossDwordSynchCount); 1052 phy->phy_reset_problem_count = 1053 le32_to_cpu(buffer->PhyResetProblemCount); 1054 1055 out_free_consistent: 1056 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1057 buffer, dma_handle); 1058 return error; 1059 } 1060 1061 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, 1062 MPT_FRAME_HDR *reply) 1063 { 1064 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_COMMAND_GOOD; 1065 if (reply != NULL) { 1066 ioc->sas_mgmt.status |= MPT_SAS_MGMT_STATUS_RF_VALID; 1067 memcpy(ioc->sas_mgmt.reply, reply, 1068 min(ioc->reply_sz, 4 * reply->u.reply.MsgLength)); 1069 } 1070 complete(&ioc->sas_mgmt.done); 1071 return 1; 1072 } 1073 1074 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset) 1075 { 1076 MPT_ADAPTER *ioc = phy_to_ioc(phy); 1077 SasIoUnitControlRequest_t *req; 1078 SasIoUnitControlReply_t *reply; 1079 MPT_FRAME_HDR *mf; 1080 MPIHeader_t *hdr; 1081 unsigned long timeleft; 1082 int error = -ERESTARTSYS; 1083 1084 /* FIXME: fusion doesn't allow non-local phy reset */ 1085 if (!scsi_is_sas_phy_local(phy)) 1086 return -EINVAL; 1087 1088 /* not implemented for expanders */ 1089 if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP) 1090 return -ENXIO; 1091 1092 if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex)) 1093 goto out; 1094 1095 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc); 1096 if (!mf) { 1097 error = -ENOMEM; 1098 goto out_unlock; 1099 } 1100 1101 hdr = (MPIHeader_t *) mf; 1102 req = (SasIoUnitControlRequest_t *)mf; 1103 memset(req, 0, sizeof(SasIoUnitControlRequest_t)); 1104 req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL; 1105 req->MsgContext = hdr->MsgContext; 1106 req->Operation = hard_reset ? 1107 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET; 1108 req->PhyNum = phy->identify.phy_identifier; 1109 1110 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf); 1111 1112 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 1113 10 * HZ); 1114 if (!timeleft) { 1115 /* On timeout reset the board */ 1116 mpt_free_msg_frame(ioc, mf); 1117 mpt_HardResetHandler(ioc, CAN_SLEEP); 1118 error = -ETIMEDOUT; 1119 goto out_unlock; 1120 } 1121 1122 /* a reply frame is expected */ 1123 if ((ioc->sas_mgmt.status & 1124 MPT_IOCTL_STATUS_RF_VALID) == 0) { 1125 error = -ENXIO; 1126 goto out_unlock; 1127 } 1128 1129 /* process the completed Reply Message Frame */ 1130 reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply; 1131 if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) { 1132 printk("%s: IOCStatus=0x%X IOCLogInfo=0x%X\n", 1133 __FUNCTION__, 1134 reply->IOCStatus, 1135 reply->IOCLogInfo); 1136 error = -ENXIO; 1137 goto out_unlock; 1138 } 1139 1140 error = 0; 1141 1142 out_unlock: 1143 mutex_unlock(&ioc->sas_mgmt.mutex); 1144 out: 1145 return error; 1146 } 1147 1148 static int 1149 mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier) 1150 { 1151 MPT_ADAPTER *ioc = rphy_to_ioc(rphy); 1152 int i, error; 1153 struct mptsas_portinfo *p; 1154 struct mptsas_enclosure enclosure_info; 1155 u64 enclosure_handle; 1156 1157 mutex_lock(&ioc->sas_topology_mutex); 1158 list_for_each_entry(p, &ioc->sas_topology, list) { 1159 for (i = 0; i < p->num_phys; i++) { 1160 if (p->phy_info[i].attached.sas_address == 1161 rphy->identify.sas_address) { 1162 enclosure_handle = p->phy_info[i]. 1163 attached.handle_enclosure; 1164 goto found_info; 1165 } 1166 } 1167 } 1168 mutex_unlock(&ioc->sas_topology_mutex); 1169 return -ENXIO; 1170 1171 found_info: 1172 mutex_unlock(&ioc->sas_topology_mutex); 1173 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure)); 1174 error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info, 1175 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE << 1176 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle); 1177 if (!error) 1178 *identifier = enclosure_info.enclosure_logical_id; 1179 return error; 1180 } 1181 1182 static int 1183 mptsas_get_bay_identifier(struct sas_rphy *rphy) 1184 { 1185 MPT_ADAPTER *ioc = rphy_to_ioc(rphy); 1186 struct mptsas_portinfo *p; 1187 int i, rc; 1188 1189 mutex_lock(&ioc->sas_topology_mutex); 1190 list_for_each_entry(p, &ioc->sas_topology, list) { 1191 for (i = 0; i < p->num_phys; i++) { 1192 if (p->phy_info[i].attached.sas_address == 1193 rphy->identify.sas_address) { 1194 rc = p->phy_info[i].attached.slot; 1195 goto out; 1196 } 1197 } 1198 } 1199 rc = -ENXIO; 1200 out: 1201 mutex_unlock(&ioc->sas_topology_mutex); 1202 return rc; 1203 } 1204 1205 static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy, 1206 struct request *req) 1207 { 1208 MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc; 1209 MPT_FRAME_HDR *mf; 1210 SmpPassthroughRequest_t *smpreq; 1211 struct request *rsp = req->next_rq; 1212 int ret; 1213 int flagsLength; 1214 unsigned long timeleft; 1215 char *psge; 1216 dma_addr_t dma_addr_in = 0; 1217 dma_addr_t dma_addr_out = 0; 1218 u64 sas_address = 0; 1219 1220 if (!rsp) { 1221 printk(KERN_ERR "%s: the smp response space is missing\n", 1222 __FUNCTION__); 1223 return -EINVAL; 1224 } 1225 1226 /* do we need to support multiple segments? */ 1227 if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) { 1228 printk(KERN_ERR "%s: multiple segments req %u %u, rsp %u %u\n", 1229 __FUNCTION__, req->bio->bi_vcnt, req->data_len, 1230 rsp->bio->bi_vcnt, rsp->data_len); 1231 return -EINVAL; 1232 } 1233 1234 ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex); 1235 if (ret) 1236 goto out; 1237 1238 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc); 1239 if (!mf) { 1240 ret = -ENOMEM; 1241 goto out_unlock; 1242 } 1243 1244 smpreq = (SmpPassthroughRequest_t *)mf; 1245 memset(smpreq, 0, sizeof(*smpreq)); 1246 1247 smpreq->RequestDataLength = cpu_to_le16(req->data_len - 4); 1248 smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH; 1249 1250 if (rphy) 1251 sas_address = rphy->identify.sas_address; 1252 else { 1253 struct mptsas_portinfo *port_info; 1254 1255 mutex_lock(&ioc->sas_topology_mutex); 1256 port_info = mptsas_find_portinfo_by_handle(ioc, ioc->handle); 1257 if (port_info && port_info->phy_info) 1258 sas_address = 1259 port_info->phy_info[0].phy->identify.sas_address; 1260 mutex_unlock(&ioc->sas_topology_mutex); 1261 } 1262 1263 *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address); 1264 1265 psge = (char *) 1266 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4)); 1267 1268 /* request */ 1269 flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT | 1270 MPI_SGE_FLAGS_END_OF_BUFFER | 1271 MPI_SGE_FLAGS_DIRECTION | 1272 mpt_addr_size()) << MPI_SGE_FLAGS_SHIFT; 1273 flagsLength |= (req->data_len - 4); 1274 1275 dma_addr_out = pci_map_single(ioc->pcidev, bio_data(req->bio), 1276 req->data_len, PCI_DMA_BIDIRECTIONAL); 1277 if (!dma_addr_out) 1278 goto put_mf; 1279 mpt_add_sge(psge, flagsLength, dma_addr_out); 1280 psge += (sizeof(u32) + sizeof(dma_addr_t)); 1281 1282 /* response */ 1283 flagsLength = MPT_SGE_FLAGS_SSIMPLE_READ; 1284 flagsLength |= rsp->data_len + 4; 1285 dma_addr_in = pci_map_single(ioc->pcidev, bio_data(rsp->bio), 1286 rsp->data_len, PCI_DMA_BIDIRECTIONAL); 1287 if (!dma_addr_in) 1288 goto unmap; 1289 mpt_add_sge(psge, flagsLength, dma_addr_in); 1290 1291 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf); 1292 1293 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ); 1294 if (!timeleft) { 1295 printk(KERN_ERR "%s: smp timeout!\n", __FUNCTION__); 1296 /* On timeout reset the board */ 1297 mpt_HardResetHandler(ioc, CAN_SLEEP); 1298 ret = -ETIMEDOUT; 1299 goto unmap; 1300 } 1301 mf = NULL; 1302 1303 if (ioc->sas_mgmt.status & MPT_IOCTL_STATUS_RF_VALID) { 1304 SmpPassthroughReply_t *smprep; 1305 1306 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply; 1307 memcpy(req->sense, smprep, sizeof(*smprep)); 1308 req->sense_len = sizeof(*smprep); 1309 } else { 1310 printk(KERN_ERR "%s: smp passthru reply failed to be returned\n", 1311 __FUNCTION__); 1312 ret = -ENXIO; 1313 } 1314 unmap: 1315 if (dma_addr_out) 1316 pci_unmap_single(ioc->pcidev, dma_addr_out, req->data_len, 1317 PCI_DMA_BIDIRECTIONAL); 1318 if (dma_addr_in) 1319 pci_unmap_single(ioc->pcidev, dma_addr_in, rsp->data_len, 1320 PCI_DMA_BIDIRECTIONAL); 1321 put_mf: 1322 if (mf) 1323 mpt_free_msg_frame(ioc, mf); 1324 out_unlock: 1325 mutex_unlock(&ioc->sas_mgmt.mutex); 1326 out: 1327 return ret; 1328 } 1329 1330 static struct sas_function_template mptsas_transport_functions = { 1331 .get_linkerrors = mptsas_get_linkerrors, 1332 .get_enclosure_identifier = mptsas_get_enclosure_identifier, 1333 .get_bay_identifier = mptsas_get_bay_identifier, 1334 .phy_reset = mptsas_phy_reset, 1335 .smp_handler = mptsas_smp_handler, 1336 }; 1337 1338 static struct scsi_transport_template *mptsas_transport_template; 1339 1340 static int 1341 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info) 1342 { 1343 ConfigExtendedPageHeader_t hdr; 1344 CONFIGPARMS cfg; 1345 SasIOUnitPage0_t *buffer; 1346 dma_addr_t dma_handle; 1347 int error, i; 1348 1349 hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION; 1350 hdr.ExtPageLength = 0; 1351 hdr.PageNumber = 0; 1352 hdr.Reserved1 = 0; 1353 hdr.Reserved2 = 0; 1354 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 1355 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT; 1356 1357 cfg.cfghdr.ehdr = &hdr; 1358 cfg.physAddr = -1; 1359 cfg.pageAddr = 0; 1360 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 1361 cfg.dir = 0; /* read */ 1362 cfg.timeout = 10; 1363 1364 error = mpt_config(ioc, &cfg); 1365 if (error) 1366 goto out; 1367 if (!hdr.ExtPageLength) { 1368 error = -ENXIO; 1369 goto out; 1370 } 1371 1372 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1373 &dma_handle); 1374 if (!buffer) { 1375 error = -ENOMEM; 1376 goto out; 1377 } 1378 1379 cfg.physAddr = dma_handle; 1380 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 1381 1382 error = mpt_config(ioc, &cfg); 1383 if (error) 1384 goto out_free_consistent; 1385 1386 port_info->num_phys = buffer->NumPhys; 1387 port_info->phy_info = kcalloc(port_info->num_phys, 1388 sizeof(*port_info->phy_info),GFP_KERNEL); 1389 if (!port_info->phy_info) { 1390 error = -ENOMEM; 1391 goto out_free_consistent; 1392 } 1393 1394 ioc->nvdata_version_persistent = 1395 le16_to_cpu(buffer->NvdataVersionPersistent); 1396 ioc->nvdata_version_default = 1397 le16_to_cpu(buffer->NvdataVersionDefault); 1398 1399 for (i = 0; i < port_info->num_phys; i++) { 1400 mptsas_print_phy_data(ioc, &buffer->PhyData[i]); 1401 port_info->phy_info[i].phy_id = i; 1402 port_info->phy_info[i].port_id = 1403 buffer->PhyData[i].Port; 1404 port_info->phy_info[i].negotiated_link_rate = 1405 buffer->PhyData[i].NegotiatedLinkRate; 1406 port_info->phy_info[i].portinfo = port_info; 1407 port_info->phy_info[i].handle = 1408 le16_to_cpu(buffer->PhyData[i].ControllerDevHandle); 1409 } 1410 1411 out_free_consistent: 1412 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1413 buffer, dma_handle); 1414 out: 1415 return error; 1416 } 1417 1418 static int 1419 mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc) 1420 { 1421 ConfigExtendedPageHeader_t hdr; 1422 CONFIGPARMS cfg; 1423 SasIOUnitPage1_t *buffer; 1424 dma_addr_t dma_handle; 1425 int error; 1426 u16 device_missing_delay; 1427 1428 memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t)); 1429 memset(&cfg, 0, sizeof(CONFIGPARMS)); 1430 1431 cfg.cfghdr.ehdr = &hdr; 1432 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 1433 cfg.timeout = 10; 1434 cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 1435 cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT; 1436 cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION; 1437 cfg.cfghdr.ehdr->PageNumber = 1; 1438 1439 error = mpt_config(ioc, &cfg); 1440 if (error) 1441 goto out; 1442 if (!hdr.ExtPageLength) { 1443 error = -ENXIO; 1444 goto out; 1445 } 1446 1447 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1448 &dma_handle); 1449 if (!buffer) { 1450 error = -ENOMEM; 1451 goto out; 1452 } 1453 1454 cfg.physAddr = dma_handle; 1455 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 1456 1457 error = mpt_config(ioc, &cfg); 1458 if (error) 1459 goto out_free_consistent; 1460 1461 ioc->io_missing_delay = 1462 le16_to_cpu(buffer->IODeviceMissingDelay); 1463 device_missing_delay = le16_to_cpu(buffer->ReportDeviceMissingDelay); 1464 ioc->device_missing_delay = (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_UNIT_16) ? 1465 (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16 : 1466 device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK; 1467 1468 out_free_consistent: 1469 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1470 buffer, dma_handle); 1471 out: 1472 return error; 1473 } 1474 1475 static int 1476 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, 1477 u32 form, u32 form_specific) 1478 { 1479 ConfigExtendedPageHeader_t hdr; 1480 CONFIGPARMS cfg; 1481 SasPhyPage0_t *buffer; 1482 dma_addr_t dma_handle; 1483 int error; 1484 1485 hdr.PageVersion = MPI_SASPHY0_PAGEVERSION; 1486 hdr.ExtPageLength = 0; 1487 hdr.PageNumber = 0; 1488 hdr.Reserved1 = 0; 1489 hdr.Reserved2 = 0; 1490 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 1491 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY; 1492 1493 cfg.cfghdr.ehdr = &hdr; 1494 cfg.dir = 0; /* read */ 1495 cfg.timeout = 10; 1496 1497 /* Get Phy Pg 0 for each Phy. */ 1498 cfg.physAddr = -1; 1499 cfg.pageAddr = form + form_specific; 1500 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 1501 1502 error = mpt_config(ioc, &cfg); 1503 if (error) 1504 goto out; 1505 1506 if (!hdr.ExtPageLength) { 1507 error = -ENXIO; 1508 goto out; 1509 } 1510 1511 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1512 &dma_handle); 1513 if (!buffer) { 1514 error = -ENOMEM; 1515 goto out; 1516 } 1517 1518 cfg.physAddr = dma_handle; 1519 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 1520 1521 error = mpt_config(ioc, &cfg); 1522 if (error) 1523 goto out_free_consistent; 1524 1525 mptsas_print_phy_pg0(ioc, buffer); 1526 1527 phy_info->hw_link_rate = buffer->HwLinkRate; 1528 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate; 1529 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle); 1530 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle); 1531 1532 out_free_consistent: 1533 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1534 buffer, dma_handle); 1535 out: 1536 return error; 1537 } 1538 1539 static int 1540 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info, 1541 u32 form, u32 form_specific) 1542 { 1543 ConfigExtendedPageHeader_t hdr; 1544 CONFIGPARMS cfg; 1545 SasDevicePage0_t *buffer; 1546 dma_addr_t dma_handle; 1547 __le64 sas_address; 1548 int error=0; 1549 1550 if (ioc->sas_discovery_runtime && 1551 mptsas_is_end_device(device_info)) 1552 goto out; 1553 1554 hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION; 1555 hdr.ExtPageLength = 0; 1556 hdr.PageNumber = 0; 1557 hdr.Reserved1 = 0; 1558 hdr.Reserved2 = 0; 1559 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 1560 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE; 1561 1562 cfg.cfghdr.ehdr = &hdr; 1563 cfg.pageAddr = form + form_specific; 1564 cfg.physAddr = -1; 1565 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 1566 cfg.dir = 0; /* read */ 1567 cfg.timeout = 10; 1568 1569 memset(device_info, 0, sizeof(struct mptsas_devinfo)); 1570 error = mpt_config(ioc, &cfg); 1571 if (error) 1572 goto out; 1573 if (!hdr.ExtPageLength) { 1574 error = -ENXIO; 1575 goto out; 1576 } 1577 1578 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1579 &dma_handle); 1580 if (!buffer) { 1581 error = -ENOMEM; 1582 goto out; 1583 } 1584 1585 cfg.physAddr = dma_handle; 1586 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 1587 1588 error = mpt_config(ioc, &cfg); 1589 if (error) 1590 goto out_free_consistent; 1591 1592 mptsas_print_device_pg0(ioc, buffer); 1593 1594 device_info->handle = le16_to_cpu(buffer->DevHandle); 1595 device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle); 1596 device_info->handle_enclosure = 1597 le16_to_cpu(buffer->EnclosureHandle); 1598 device_info->slot = le16_to_cpu(buffer->Slot); 1599 device_info->phy_id = buffer->PhyNum; 1600 device_info->port_id = buffer->PhysicalPort; 1601 device_info->id = buffer->TargetID; 1602 device_info->phys_disk_num = ~0; 1603 device_info->channel = buffer->Bus; 1604 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64)); 1605 device_info->sas_address = le64_to_cpu(sas_address); 1606 device_info->device_info = 1607 le32_to_cpu(buffer->DeviceInfo); 1608 1609 out_free_consistent: 1610 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1611 buffer, dma_handle); 1612 out: 1613 return error; 1614 } 1615 1616 static int 1617 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info, 1618 u32 form, u32 form_specific) 1619 { 1620 ConfigExtendedPageHeader_t hdr; 1621 CONFIGPARMS cfg; 1622 SasExpanderPage0_t *buffer; 1623 dma_addr_t dma_handle; 1624 int i, error; 1625 1626 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION; 1627 hdr.ExtPageLength = 0; 1628 hdr.PageNumber = 0; 1629 hdr.Reserved1 = 0; 1630 hdr.Reserved2 = 0; 1631 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 1632 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER; 1633 1634 cfg.cfghdr.ehdr = &hdr; 1635 cfg.physAddr = -1; 1636 cfg.pageAddr = form + form_specific; 1637 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 1638 cfg.dir = 0; /* read */ 1639 cfg.timeout = 10; 1640 1641 memset(port_info, 0, sizeof(struct mptsas_portinfo)); 1642 error = mpt_config(ioc, &cfg); 1643 if (error) 1644 goto out; 1645 1646 if (!hdr.ExtPageLength) { 1647 error = -ENXIO; 1648 goto out; 1649 } 1650 1651 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1652 &dma_handle); 1653 if (!buffer) { 1654 error = -ENOMEM; 1655 goto out; 1656 } 1657 1658 cfg.physAddr = dma_handle; 1659 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 1660 1661 error = mpt_config(ioc, &cfg); 1662 if (error) 1663 goto out_free_consistent; 1664 1665 /* save config data */ 1666 port_info->num_phys = buffer->NumPhys; 1667 port_info->phy_info = kcalloc(port_info->num_phys, 1668 sizeof(*port_info->phy_info),GFP_KERNEL); 1669 if (!port_info->phy_info) { 1670 error = -ENOMEM; 1671 goto out_free_consistent; 1672 } 1673 1674 for (i = 0; i < port_info->num_phys; i++) { 1675 port_info->phy_info[i].portinfo = port_info; 1676 port_info->phy_info[i].handle = 1677 le16_to_cpu(buffer->DevHandle); 1678 } 1679 1680 out_free_consistent: 1681 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1682 buffer, dma_handle); 1683 out: 1684 return error; 1685 } 1686 1687 static int 1688 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, 1689 u32 form, u32 form_specific) 1690 { 1691 ConfigExtendedPageHeader_t hdr; 1692 CONFIGPARMS cfg; 1693 SasExpanderPage1_t *buffer; 1694 dma_addr_t dma_handle; 1695 int error=0; 1696 1697 if (ioc->sas_discovery_runtime && 1698 mptsas_is_end_device(&phy_info->attached)) 1699 goto out; 1700 1701 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION; 1702 hdr.ExtPageLength = 0; 1703 hdr.PageNumber = 1; 1704 hdr.Reserved1 = 0; 1705 hdr.Reserved2 = 0; 1706 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 1707 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER; 1708 1709 cfg.cfghdr.ehdr = &hdr; 1710 cfg.physAddr = -1; 1711 cfg.pageAddr = form + form_specific; 1712 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 1713 cfg.dir = 0; /* read */ 1714 cfg.timeout = 10; 1715 1716 error = mpt_config(ioc, &cfg); 1717 if (error) 1718 goto out; 1719 1720 if (!hdr.ExtPageLength) { 1721 error = -ENXIO; 1722 goto out; 1723 } 1724 1725 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1726 &dma_handle); 1727 if (!buffer) { 1728 error = -ENOMEM; 1729 goto out; 1730 } 1731 1732 cfg.physAddr = dma_handle; 1733 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 1734 1735 error = mpt_config(ioc, &cfg); 1736 if (error) 1737 goto out_free_consistent; 1738 1739 1740 mptsas_print_expander_pg1(ioc, buffer); 1741 1742 /* save config data */ 1743 phy_info->phy_id = buffer->PhyIdentifier; 1744 phy_info->port_id = buffer->PhysicalPort; 1745 phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate; 1746 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate; 1747 phy_info->hw_link_rate = buffer->HwLinkRate; 1748 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle); 1749 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle); 1750 1751 out_free_consistent: 1752 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1753 buffer, dma_handle); 1754 out: 1755 return error; 1756 } 1757 1758 static void 1759 mptsas_parse_device_info(struct sas_identify *identify, 1760 struct mptsas_devinfo *device_info) 1761 { 1762 u16 protocols; 1763 1764 identify->sas_address = device_info->sas_address; 1765 identify->phy_identifier = device_info->phy_id; 1766 1767 /* 1768 * Fill in Phy Initiator Port Protocol. 1769 * Bits 6:3, more than one bit can be set, fall through cases. 1770 */ 1771 protocols = device_info->device_info & 0x78; 1772 identify->initiator_port_protocols = 0; 1773 if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR) 1774 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP; 1775 if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR) 1776 identify->initiator_port_protocols |= SAS_PROTOCOL_STP; 1777 if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR) 1778 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP; 1779 if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST) 1780 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA; 1781 1782 /* 1783 * Fill in Phy Target Port Protocol. 1784 * Bits 10:7, more than one bit can be set, fall through cases. 1785 */ 1786 protocols = device_info->device_info & 0x780; 1787 identify->target_port_protocols = 0; 1788 if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET) 1789 identify->target_port_protocols |= SAS_PROTOCOL_SSP; 1790 if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET) 1791 identify->target_port_protocols |= SAS_PROTOCOL_STP; 1792 if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET) 1793 identify->target_port_protocols |= SAS_PROTOCOL_SMP; 1794 if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE) 1795 identify->target_port_protocols |= SAS_PROTOCOL_SATA; 1796 1797 /* 1798 * Fill in Attached device type. 1799 */ 1800 switch (device_info->device_info & 1801 MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) { 1802 case MPI_SAS_DEVICE_INFO_NO_DEVICE: 1803 identify->device_type = SAS_PHY_UNUSED; 1804 break; 1805 case MPI_SAS_DEVICE_INFO_END_DEVICE: 1806 identify->device_type = SAS_END_DEVICE; 1807 break; 1808 case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER: 1809 identify->device_type = SAS_EDGE_EXPANDER_DEVICE; 1810 break; 1811 case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER: 1812 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE; 1813 break; 1814 } 1815 } 1816 1817 static int mptsas_probe_one_phy(struct device *dev, 1818 struct mptsas_phyinfo *phy_info, int index, int local) 1819 { 1820 MPT_ADAPTER *ioc; 1821 struct sas_phy *phy; 1822 struct sas_port *port; 1823 int error = 0; 1824 1825 if (!dev) { 1826 error = -ENODEV; 1827 goto out; 1828 } 1829 1830 if (!phy_info->phy) { 1831 phy = sas_phy_alloc(dev, index); 1832 if (!phy) { 1833 error = -ENOMEM; 1834 goto out; 1835 } 1836 } else 1837 phy = phy_info->phy; 1838 1839 mptsas_parse_device_info(&phy->identify, &phy_info->identify); 1840 1841 /* 1842 * Set Negotiated link rate. 1843 */ 1844 switch (phy_info->negotiated_link_rate) { 1845 case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED: 1846 phy->negotiated_linkrate = SAS_PHY_DISABLED; 1847 break; 1848 case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION: 1849 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED; 1850 break; 1851 case MPI_SAS_IOUNIT0_RATE_1_5: 1852 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS; 1853 break; 1854 case MPI_SAS_IOUNIT0_RATE_3_0: 1855 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS; 1856 break; 1857 case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE: 1858 case MPI_SAS_IOUNIT0_RATE_UNKNOWN: 1859 default: 1860 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN; 1861 break; 1862 } 1863 1864 /* 1865 * Set Max hardware link rate. 1866 */ 1867 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) { 1868 case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5: 1869 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS; 1870 break; 1871 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0: 1872 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS; 1873 break; 1874 default: 1875 break; 1876 } 1877 1878 /* 1879 * Set Max programmed link rate. 1880 */ 1881 switch (phy_info->programmed_link_rate & 1882 MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) { 1883 case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5: 1884 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS; 1885 break; 1886 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0: 1887 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS; 1888 break; 1889 default: 1890 break; 1891 } 1892 1893 /* 1894 * Set Min hardware link rate. 1895 */ 1896 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) { 1897 case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5: 1898 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS; 1899 break; 1900 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0: 1901 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS; 1902 break; 1903 default: 1904 break; 1905 } 1906 1907 /* 1908 * Set Min programmed link rate. 1909 */ 1910 switch (phy_info->programmed_link_rate & 1911 MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) { 1912 case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5: 1913 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS; 1914 break; 1915 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0: 1916 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS; 1917 break; 1918 default: 1919 break; 1920 } 1921 1922 if (!phy_info->phy) { 1923 1924 error = sas_phy_add(phy); 1925 if (error) { 1926 sas_phy_free(phy); 1927 goto out; 1928 } 1929 phy_info->phy = phy; 1930 } 1931 1932 if (!phy_info->attached.handle || 1933 !phy_info->port_details) 1934 goto out; 1935 1936 port = mptsas_get_port(phy_info); 1937 ioc = phy_to_ioc(phy_info->phy); 1938 1939 if (phy_info->sas_port_add_phy) { 1940 1941 if (!port) { 1942 port = sas_port_alloc_num(dev); 1943 if (!port) { 1944 error = -ENOMEM; 1945 goto out; 1946 } 1947 error = sas_port_add(port); 1948 if (error) { 1949 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 1950 "%s: exit at line=%d\n", ioc->name, 1951 __FUNCTION__, __LINE__)); 1952 goto out; 1953 } 1954 mptsas_set_port(ioc, phy_info, port); 1955 dsaswideprintk(ioc, printk(KERN_DEBUG 1956 "sas_port_alloc: port=%p dev=%p port_id=%d\n", 1957 port, dev, port->port_identifier)); 1958 } 1959 dsaswideprintk(ioc, printk(KERN_DEBUG "sas_port_add_phy: phy_id=%d\n", 1960 phy_info->phy_id)); 1961 sas_port_add_phy(port, phy_info->phy); 1962 phy_info->sas_port_add_phy = 0; 1963 } 1964 1965 if (!mptsas_get_rphy(phy_info) && port && !port->rphy) { 1966 1967 struct sas_rphy *rphy; 1968 struct device *parent; 1969 struct sas_identify identify; 1970 1971 parent = dev->parent->parent; 1972 /* 1973 * Let the hotplug_work thread handle processing 1974 * the adding/removing of devices that occur 1975 * after start of day. 1976 */ 1977 if (ioc->sas_discovery_runtime && 1978 mptsas_is_end_device(&phy_info->attached)) 1979 goto out; 1980 1981 mptsas_parse_device_info(&identify, &phy_info->attached); 1982 if (scsi_is_host_device(parent)) { 1983 struct mptsas_portinfo *port_info; 1984 int i; 1985 1986 mutex_lock(&ioc->sas_topology_mutex); 1987 port_info = mptsas_find_portinfo_by_handle(ioc, 1988 ioc->handle); 1989 mutex_unlock(&ioc->sas_topology_mutex); 1990 1991 for (i = 0; i < port_info->num_phys; i++) 1992 if (port_info->phy_info[i].identify.sas_address == 1993 identify.sas_address) { 1994 sas_port_mark_backlink(port); 1995 goto out; 1996 } 1997 1998 } else if (scsi_is_sas_rphy(parent)) { 1999 struct sas_rphy *parent_rphy = dev_to_rphy(parent); 2000 if (identify.sas_address == 2001 parent_rphy->identify.sas_address) { 2002 sas_port_mark_backlink(port); 2003 goto out; 2004 } 2005 } 2006 2007 switch (identify.device_type) { 2008 case SAS_END_DEVICE: 2009 rphy = sas_end_device_alloc(port); 2010 break; 2011 case SAS_EDGE_EXPANDER_DEVICE: 2012 case SAS_FANOUT_EXPANDER_DEVICE: 2013 rphy = sas_expander_alloc(port, identify.device_type); 2014 break; 2015 default: 2016 rphy = NULL; 2017 break; 2018 } 2019 if (!rphy) { 2020 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2021 "%s: exit at line=%d\n", ioc->name, 2022 __FUNCTION__, __LINE__)); 2023 goto out; 2024 } 2025 2026 rphy->identify = identify; 2027 error = sas_rphy_add(rphy); 2028 if (error) { 2029 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2030 "%s: exit at line=%d\n", ioc->name, 2031 __FUNCTION__, __LINE__)); 2032 sas_rphy_free(rphy); 2033 goto out; 2034 } 2035 mptsas_set_rphy(ioc, phy_info, rphy); 2036 } 2037 2038 out: 2039 return error; 2040 } 2041 2042 static int 2043 mptsas_probe_hba_phys(MPT_ADAPTER *ioc) 2044 { 2045 struct mptsas_portinfo *port_info, *hba; 2046 int error = -ENOMEM, i; 2047 2048 hba = kzalloc(sizeof(*port_info), GFP_KERNEL); 2049 if (! hba) 2050 goto out; 2051 2052 error = mptsas_sas_io_unit_pg0(ioc, hba); 2053 if (error) 2054 goto out_free_port_info; 2055 2056 mptsas_sas_io_unit_pg1(ioc); 2057 mutex_lock(&ioc->sas_topology_mutex); 2058 ioc->handle = hba->phy_info[0].handle; 2059 port_info = mptsas_find_portinfo_by_handle(ioc, ioc->handle); 2060 if (!port_info) { 2061 port_info = hba; 2062 list_add_tail(&port_info->list, &ioc->sas_topology); 2063 } else { 2064 for (i = 0; i < hba->num_phys; i++) { 2065 port_info->phy_info[i].negotiated_link_rate = 2066 hba->phy_info[i].negotiated_link_rate; 2067 port_info->phy_info[i].handle = 2068 hba->phy_info[i].handle; 2069 port_info->phy_info[i].port_id = 2070 hba->phy_info[i].port_id; 2071 } 2072 kfree(hba->phy_info); 2073 kfree(hba); 2074 hba = NULL; 2075 } 2076 mutex_unlock(&ioc->sas_topology_mutex); 2077 for (i = 0; i < port_info->num_phys; i++) { 2078 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i], 2079 (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER << 2080 MPI_SAS_PHY_PGAD_FORM_SHIFT), i); 2081 2082 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify, 2083 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 2084 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 2085 port_info->phy_info[i].handle); 2086 port_info->phy_info[i].identify.phy_id = 2087 port_info->phy_info[i].phy_id = i; 2088 if (port_info->phy_info[i].attached.handle) 2089 mptsas_sas_device_pg0(ioc, 2090 &port_info->phy_info[i].attached, 2091 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 2092 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 2093 port_info->phy_info[i].attached.handle); 2094 } 2095 2096 mptsas_setup_wide_ports(ioc, port_info); 2097 2098 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++) 2099 mptsas_probe_one_phy(&ioc->sh->shost_gendev, 2100 &port_info->phy_info[i], ioc->sas_index, 1); 2101 2102 return 0; 2103 2104 out_free_port_info: 2105 kfree(hba); 2106 out: 2107 return error; 2108 } 2109 2110 static int 2111 mptsas_probe_expander_phys(MPT_ADAPTER *ioc, u32 *handle) 2112 { 2113 struct mptsas_portinfo *port_info, *p, *ex; 2114 struct device *parent; 2115 struct sas_rphy *rphy; 2116 int error = -ENOMEM, i, j; 2117 2118 ex = kzalloc(sizeof(*port_info), GFP_KERNEL); 2119 if (!ex) 2120 goto out; 2121 2122 error = mptsas_sas_expander_pg0(ioc, ex, 2123 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE << 2124 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), *handle); 2125 if (error) 2126 goto out_free_port_info; 2127 2128 *handle = ex->phy_info[0].handle; 2129 2130 mutex_lock(&ioc->sas_topology_mutex); 2131 port_info = mptsas_find_portinfo_by_handle(ioc, *handle); 2132 if (!port_info) { 2133 port_info = ex; 2134 list_add_tail(&port_info->list, &ioc->sas_topology); 2135 } else { 2136 for (i = 0; i < ex->num_phys; i++) { 2137 port_info->phy_info[i].handle = 2138 ex->phy_info[i].handle; 2139 port_info->phy_info[i].port_id = 2140 ex->phy_info[i].port_id; 2141 } 2142 kfree(ex->phy_info); 2143 kfree(ex); 2144 ex = NULL; 2145 } 2146 mutex_unlock(&ioc->sas_topology_mutex); 2147 2148 for (i = 0; i < port_info->num_phys; i++) { 2149 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i], 2150 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM << 2151 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + *handle); 2152 2153 if (port_info->phy_info[i].identify.handle) { 2154 mptsas_sas_device_pg0(ioc, 2155 &port_info->phy_info[i].identify, 2156 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 2157 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 2158 port_info->phy_info[i].identify.handle); 2159 port_info->phy_info[i].identify.phy_id = 2160 port_info->phy_info[i].phy_id; 2161 } 2162 2163 if (port_info->phy_info[i].attached.handle) { 2164 mptsas_sas_device_pg0(ioc, 2165 &port_info->phy_info[i].attached, 2166 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 2167 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 2168 port_info->phy_info[i].attached.handle); 2169 port_info->phy_info[i].attached.phy_id = 2170 port_info->phy_info[i].phy_id; 2171 } 2172 } 2173 2174 parent = &ioc->sh->shost_gendev; 2175 for (i = 0; i < port_info->num_phys; i++) { 2176 mutex_lock(&ioc->sas_topology_mutex); 2177 list_for_each_entry(p, &ioc->sas_topology, list) { 2178 for (j = 0; j < p->num_phys; j++) { 2179 if (port_info->phy_info[i].identify.handle != 2180 p->phy_info[j].attached.handle) 2181 continue; 2182 rphy = mptsas_get_rphy(&p->phy_info[j]); 2183 parent = &rphy->dev; 2184 } 2185 } 2186 mutex_unlock(&ioc->sas_topology_mutex); 2187 } 2188 2189 mptsas_setup_wide_ports(ioc, port_info); 2190 2191 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++) 2192 mptsas_probe_one_phy(parent, &port_info->phy_info[i], 2193 ioc->sas_index, 0); 2194 2195 return 0; 2196 2197 out_free_port_info: 2198 if (ex) { 2199 kfree(ex->phy_info); 2200 kfree(ex); 2201 } 2202 out: 2203 return error; 2204 } 2205 2206 /* 2207 * mptsas_delete_expander_phys 2208 * 2209 * 2210 * This will traverse topology, and remove expanders 2211 * that are no longer present 2212 */ 2213 static void 2214 mptsas_delete_expander_phys(MPT_ADAPTER *ioc) 2215 { 2216 struct mptsas_portinfo buffer; 2217 struct mptsas_portinfo *port_info, *n, *parent; 2218 struct mptsas_phyinfo *phy_info; 2219 struct sas_port * port; 2220 int i; 2221 u64 expander_sas_address; 2222 2223 mutex_lock(&ioc->sas_topology_mutex); 2224 list_for_each_entry_safe(port_info, n, &ioc->sas_topology, list) { 2225 2226 if (port_info->phy_info && 2227 (!(port_info->phy_info[0].identify.device_info & 2228 MPI_SAS_DEVICE_INFO_SMP_TARGET))) 2229 continue; 2230 2231 if (mptsas_sas_expander_pg0(ioc, &buffer, 2232 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE << 2233 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), 2234 port_info->phy_info[0].handle)) { 2235 2236 /* 2237 * Obtain the port_info instance to the parent port 2238 */ 2239 parent = mptsas_find_portinfo_by_handle(ioc, 2240 port_info->phy_info[0].identify.handle_parent); 2241 2242 if (!parent) 2243 goto next_port; 2244 2245 expander_sas_address = 2246 port_info->phy_info[0].identify.sas_address; 2247 2248 /* 2249 * Delete rphys in the parent that point 2250 * to this expander. The transport layer will 2251 * cleanup all the children. 2252 */ 2253 phy_info = parent->phy_info; 2254 for (i = 0; i < parent->num_phys; i++, phy_info++) { 2255 port = mptsas_get_port(phy_info); 2256 if (!port) 2257 continue; 2258 if (phy_info->attached.sas_address != 2259 expander_sas_address) 2260 continue; 2261 dsaswideprintk(ioc, 2262 dev_printk(KERN_DEBUG, &port->dev, 2263 "delete port (%d)\n", port->port_identifier)); 2264 sas_port_delete(port); 2265 mptsas_port_delete(ioc, phy_info->port_details); 2266 } 2267 next_port: 2268 2269 phy_info = port_info->phy_info; 2270 for (i = 0; i < port_info->num_phys; i++, phy_info++) 2271 mptsas_port_delete(ioc, phy_info->port_details); 2272 2273 list_del(&port_info->list); 2274 kfree(port_info->phy_info); 2275 kfree(port_info); 2276 } 2277 /* 2278 * Free this memory allocated from inside 2279 * mptsas_sas_expander_pg0 2280 */ 2281 kfree(buffer.phy_info); 2282 } 2283 mutex_unlock(&ioc->sas_topology_mutex); 2284 } 2285 2286 /* 2287 * Start of day discovery 2288 */ 2289 static void 2290 mptsas_scan_sas_topology(MPT_ADAPTER *ioc) 2291 { 2292 u32 handle = 0xFFFF; 2293 int i; 2294 2295 mutex_lock(&ioc->sas_discovery_mutex); 2296 mptsas_probe_hba_phys(ioc); 2297 while (!mptsas_probe_expander_phys(ioc, &handle)) 2298 ; 2299 /* 2300 Reporting RAID volumes. 2301 */ 2302 if (!ioc->ir_firmware) 2303 goto out; 2304 if (!ioc->raid_data.pIocPg2) 2305 goto out; 2306 if (!ioc->raid_data.pIocPg2->NumActiveVolumes) 2307 goto out; 2308 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) { 2309 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, 2310 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0); 2311 } 2312 out: 2313 mutex_unlock(&ioc->sas_discovery_mutex); 2314 } 2315 2316 /* 2317 * Work queue thread to handle Runtime discovery 2318 * Mere purpose is the hot add/delete of expanders 2319 *(Mutex UNLOCKED) 2320 */ 2321 static void 2322 __mptsas_discovery_work(MPT_ADAPTER *ioc) 2323 { 2324 u32 handle = 0xFFFF; 2325 2326 ioc->sas_discovery_runtime=1; 2327 mptsas_delete_expander_phys(ioc); 2328 mptsas_probe_hba_phys(ioc); 2329 while (!mptsas_probe_expander_phys(ioc, &handle)) 2330 ; 2331 ioc->sas_discovery_runtime=0; 2332 } 2333 2334 /* 2335 * Work queue thread to handle Runtime discovery 2336 * Mere purpose is the hot add/delete of expanders 2337 *(Mutex LOCKED) 2338 */ 2339 static void 2340 mptsas_discovery_work(struct work_struct *work) 2341 { 2342 struct mptsas_discovery_event *ev = 2343 container_of(work, struct mptsas_discovery_event, work); 2344 MPT_ADAPTER *ioc = ev->ioc; 2345 2346 mutex_lock(&ioc->sas_discovery_mutex); 2347 __mptsas_discovery_work(ioc); 2348 mutex_unlock(&ioc->sas_discovery_mutex); 2349 kfree(ev); 2350 } 2351 2352 static struct mptsas_phyinfo * 2353 mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address) 2354 { 2355 struct mptsas_portinfo *port_info; 2356 struct mptsas_phyinfo *phy_info = NULL; 2357 int i; 2358 2359 mutex_lock(&ioc->sas_topology_mutex); 2360 list_for_each_entry(port_info, &ioc->sas_topology, list) { 2361 for (i = 0; i < port_info->num_phys; i++) { 2362 if (!mptsas_is_end_device( 2363 &port_info->phy_info[i].attached)) 2364 continue; 2365 if (port_info->phy_info[i].attached.sas_address 2366 != sas_address) 2367 continue; 2368 phy_info = &port_info->phy_info[i]; 2369 break; 2370 } 2371 } 2372 mutex_unlock(&ioc->sas_topology_mutex); 2373 return phy_info; 2374 } 2375 2376 static struct mptsas_phyinfo * 2377 mptsas_find_phyinfo_by_target(MPT_ADAPTER *ioc, u8 channel, u8 id) 2378 { 2379 struct mptsas_portinfo *port_info; 2380 struct mptsas_phyinfo *phy_info = NULL; 2381 int i; 2382 2383 mutex_lock(&ioc->sas_topology_mutex); 2384 list_for_each_entry(port_info, &ioc->sas_topology, list) { 2385 for (i = 0; i < port_info->num_phys; i++) { 2386 if (!mptsas_is_end_device( 2387 &port_info->phy_info[i].attached)) 2388 continue; 2389 if (port_info->phy_info[i].attached.id != id) 2390 continue; 2391 if (port_info->phy_info[i].attached.channel != channel) 2392 continue; 2393 phy_info = &port_info->phy_info[i]; 2394 break; 2395 } 2396 } 2397 mutex_unlock(&ioc->sas_topology_mutex); 2398 return phy_info; 2399 } 2400 2401 static struct mptsas_phyinfo * 2402 mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 channel, u8 id) 2403 { 2404 struct mptsas_portinfo *port_info; 2405 struct mptsas_phyinfo *phy_info = NULL; 2406 int i; 2407 2408 mutex_lock(&ioc->sas_topology_mutex); 2409 list_for_each_entry(port_info, &ioc->sas_topology, list) { 2410 for (i = 0; i < port_info->num_phys; i++) { 2411 if (!mptsas_is_end_device( 2412 &port_info->phy_info[i].attached)) 2413 continue; 2414 if (port_info->phy_info[i].attached.phys_disk_num == ~0) 2415 continue; 2416 if (port_info->phy_info[i].attached.phys_disk_num != id) 2417 continue; 2418 if (port_info->phy_info[i].attached.channel != channel) 2419 continue; 2420 phy_info = &port_info->phy_info[i]; 2421 break; 2422 } 2423 } 2424 mutex_unlock(&ioc->sas_topology_mutex); 2425 return phy_info; 2426 } 2427 2428 /* 2429 * Work queue thread to clear the persitency table 2430 */ 2431 static void 2432 mptsas_persist_clear_table(struct work_struct *work) 2433 { 2434 MPT_ADAPTER *ioc = container_of(work, MPT_ADAPTER, sas_persist_task); 2435 2436 mptbase_sas_persist_operation(ioc, MPI_SAS_OP_CLEAR_NOT_PRESENT); 2437 } 2438 2439 static void 2440 mptsas_reprobe_lun(struct scsi_device *sdev, void *data) 2441 { 2442 int rc; 2443 2444 sdev->no_uld_attach = data ? 1 : 0; 2445 rc = scsi_device_reprobe(sdev); 2446 } 2447 2448 static void 2449 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach) 2450 { 2451 starget_for_each_device(starget, uld_attach ? (void *)1 : NULL, 2452 mptsas_reprobe_lun); 2453 } 2454 2455 static void 2456 mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id) 2457 { 2458 CONFIGPARMS cfg; 2459 ConfigPageHeader_t hdr; 2460 dma_addr_t dma_handle; 2461 pRaidVolumePage0_t buffer = NULL; 2462 RaidPhysDiskPage0_t phys_disk; 2463 int i; 2464 struct mptsas_hotplug_event *ev; 2465 2466 memset(&cfg, 0 , sizeof(CONFIGPARMS)); 2467 memset(&hdr, 0 , sizeof(ConfigPageHeader_t)); 2468 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME; 2469 cfg.pageAddr = (channel << 8) + id; 2470 cfg.cfghdr.hdr = &hdr; 2471 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2472 2473 if (mpt_config(ioc, &cfg) != 0) 2474 goto out; 2475 2476 if (!hdr.PageLength) 2477 goto out; 2478 2479 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, 2480 &dma_handle); 2481 2482 if (!buffer) 2483 goto out; 2484 2485 cfg.physAddr = dma_handle; 2486 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2487 2488 if (mpt_config(ioc, &cfg) != 0) 2489 goto out; 2490 2491 if (!(buffer->VolumeStatus.Flags & 2492 MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE)) 2493 goto out; 2494 2495 if (!buffer->NumPhysDisks) 2496 goto out; 2497 2498 for (i = 0; i < buffer->NumPhysDisks; i++) { 2499 2500 if (mpt_raid_phys_disk_pg0(ioc, 2501 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0) 2502 continue; 2503 2504 ev = kzalloc(sizeof(*ev), GFP_ATOMIC); 2505 if (!ev) { 2506 printk(KERN_WARNING "mptsas: lost hotplug event\n"); 2507 goto out; 2508 } 2509 2510 INIT_WORK(&ev->work, mptsas_hotplug_work); 2511 ev->ioc = ioc; 2512 ev->id = phys_disk.PhysDiskID; 2513 ev->channel = phys_disk.PhysDiskBus; 2514 ev->phys_disk_num_valid = 1; 2515 ev->phys_disk_num = phys_disk.PhysDiskNum; 2516 ev->event_type = MPTSAS_ADD_DEVICE; 2517 schedule_work(&ev->work); 2518 } 2519 2520 out: 2521 if (buffer) 2522 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer, 2523 dma_handle); 2524 } 2525 /* 2526 * Work queue thread to handle SAS hotplug events 2527 */ 2528 static void 2529 mptsas_hotplug_work(struct work_struct *work) 2530 { 2531 struct mptsas_hotplug_event *ev = 2532 container_of(work, struct mptsas_hotplug_event, work); 2533 2534 MPT_ADAPTER *ioc = ev->ioc; 2535 struct mptsas_phyinfo *phy_info; 2536 struct sas_rphy *rphy; 2537 struct sas_port *port; 2538 struct scsi_device *sdev; 2539 struct scsi_target * starget; 2540 struct sas_identify identify; 2541 char *ds = NULL; 2542 struct mptsas_devinfo sas_device; 2543 VirtTarget *vtarget; 2544 VirtDevice *vdevice; 2545 2546 mutex_lock(&ioc->sas_discovery_mutex); 2547 switch (ev->event_type) { 2548 case MPTSAS_DEL_DEVICE: 2549 2550 phy_info = NULL; 2551 if (ev->phys_disk_num_valid) { 2552 if (ev->hidden_raid_component){ 2553 if (mptsas_sas_device_pg0(ioc, &sas_device, 2554 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 2555 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 2556 (ev->channel << 8) + ev->id)) { 2557 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2558 "%s: exit at line=%d\n", ioc->name, 2559 __FUNCTION__, __LINE__)); 2560 break; 2561 } 2562 phy_info = mptsas_find_phyinfo_by_sas_address( 2563 ioc, sas_device.sas_address); 2564 }else 2565 phy_info = mptsas_find_phyinfo_by_phys_disk_num( 2566 ioc, ev->channel, ev->phys_disk_num); 2567 } 2568 2569 if (!phy_info) 2570 phy_info = mptsas_find_phyinfo_by_target(ioc, 2571 ev->channel, ev->id); 2572 2573 /* 2574 * Sanity checks, for non-existing phys and remote rphys. 2575 */ 2576 if (!phy_info){ 2577 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2578 "%s: exit at line=%d\n", ioc->name, 2579 __FUNCTION__, __LINE__)); 2580 break; 2581 } 2582 if (!phy_info->port_details) { 2583 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2584 "%s: exit at line=%d\n", ioc->name, 2585 __FUNCTION__, __LINE__)); 2586 break; 2587 } 2588 rphy = mptsas_get_rphy(phy_info); 2589 if (!rphy) { 2590 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2591 "%s: exit at line=%d\n", ioc->name, 2592 __FUNCTION__, __LINE__)); 2593 break; 2594 } 2595 2596 port = mptsas_get_port(phy_info); 2597 if (!port) { 2598 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2599 "%s: exit at line=%d\n", ioc->name, 2600 __FUNCTION__, __LINE__)); 2601 break; 2602 } 2603 2604 starget = mptsas_get_starget(phy_info); 2605 if (starget) { 2606 vtarget = starget->hostdata; 2607 2608 if (!vtarget) { 2609 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2610 "%s: exit at line=%d\n", ioc->name, 2611 __FUNCTION__, __LINE__)); 2612 break; 2613 } 2614 2615 /* 2616 * Handling RAID components 2617 */ 2618 if (ev->phys_disk_num_valid && 2619 ev->hidden_raid_component) { 2620 printk(MYIOC_s_INFO_FMT 2621 "RAID Hidding: channel=%d, id=%d, " 2622 "physdsk %d \n", ioc->name, ev->channel, 2623 ev->id, ev->phys_disk_num); 2624 vtarget->id = ev->phys_disk_num; 2625 vtarget->tflags |= 2626 MPT_TARGET_FLAGS_RAID_COMPONENT; 2627 mptsas_reprobe_target(starget, 1); 2628 phy_info->attached.phys_disk_num = 2629 ev->phys_disk_num; 2630 break; 2631 } 2632 } 2633 2634 if (phy_info->attached.device_info & 2635 MPI_SAS_DEVICE_INFO_SSP_TARGET) 2636 ds = "ssp"; 2637 if (phy_info->attached.device_info & 2638 MPI_SAS_DEVICE_INFO_STP_TARGET) 2639 ds = "stp"; 2640 if (phy_info->attached.device_info & 2641 MPI_SAS_DEVICE_INFO_SATA_DEVICE) 2642 ds = "sata"; 2643 2644 printk(MYIOC_s_INFO_FMT 2645 "removing %s device, channel %d, id %d, phy %d\n", 2646 ioc->name, ds, ev->channel, ev->id, phy_info->phy_id); 2647 dev_printk(KERN_DEBUG, &port->dev, 2648 "delete port (%d)\n", port->port_identifier); 2649 sas_port_delete(port); 2650 mptsas_port_delete(ioc, phy_info->port_details); 2651 break; 2652 case MPTSAS_ADD_DEVICE: 2653 2654 if (ev->phys_disk_num_valid) 2655 mpt_findImVolumes(ioc); 2656 2657 /* 2658 * Refresh sas device pg0 data 2659 */ 2660 if (mptsas_sas_device_pg0(ioc, &sas_device, 2661 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 2662 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 2663 (ev->channel << 8) + ev->id)) { 2664 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2665 "%s: exit at line=%d\n", ioc->name, 2666 __FUNCTION__, __LINE__)); 2667 break; 2668 } 2669 2670 __mptsas_discovery_work(ioc); 2671 2672 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 2673 sas_device.sas_address); 2674 2675 if (!phy_info || !phy_info->port_details) { 2676 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2677 "%s: exit at line=%d\n", ioc->name, 2678 __FUNCTION__, __LINE__)); 2679 break; 2680 } 2681 2682 starget = mptsas_get_starget(phy_info); 2683 if (starget && (!ev->hidden_raid_component)){ 2684 2685 vtarget = starget->hostdata; 2686 2687 if (!vtarget) { 2688 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2689 "%s: exit at line=%d\n", ioc->name, 2690 __FUNCTION__, __LINE__)); 2691 break; 2692 } 2693 /* 2694 * Handling RAID components 2695 */ 2696 if (vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) { 2697 printk(MYIOC_s_INFO_FMT 2698 "RAID Exposing: channel=%d, id=%d, " 2699 "physdsk %d \n", ioc->name, ev->channel, 2700 ev->id, ev->phys_disk_num); 2701 vtarget->tflags &= 2702 ~MPT_TARGET_FLAGS_RAID_COMPONENT; 2703 vtarget->id = ev->id; 2704 mptsas_reprobe_target(starget, 0); 2705 phy_info->attached.phys_disk_num = ~0; 2706 } 2707 break; 2708 } 2709 2710 if (mptsas_get_rphy(phy_info)) { 2711 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2712 "%s: exit at line=%d\n", ioc->name, 2713 __FUNCTION__, __LINE__)); 2714 if (ev->channel) printk("%d\n", __LINE__); 2715 break; 2716 } 2717 2718 port = mptsas_get_port(phy_info); 2719 if (!port) { 2720 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2721 "%s: exit at line=%d\n", ioc->name, 2722 __FUNCTION__, __LINE__)); 2723 break; 2724 } 2725 memcpy(&phy_info->attached, &sas_device, 2726 sizeof(struct mptsas_devinfo)); 2727 2728 if (phy_info->attached.device_info & 2729 MPI_SAS_DEVICE_INFO_SSP_TARGET) 2730 ds = "ssp"; 2731 if (phy_info->attached.device_info & 2732 MPI_SAS_DEVICE_INFO_STP_TARGET) 2733 ds = "stp"; 2734 if (phy_info->attached.device_info & 2735 MPI_SAS_DEVICE_INFO_SATA_DEVICE) 2736 ds = "sata"; 2737 2738 printk(MYIOC_s_INFO_FMT 2739 "attaching %s device, channel %d, id %d, phy %d\n", 2740 ioc->name, ds, ev->channel, ev->id, ev->phy_id); 2741 2742 mptsas_parse_device_info(&identify, &phy_info->attached); 2743 rphy = sas_end_device_alloc(port); 2744 if (!rphy) { 2745 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2746 "%s: exit at line=%d\n", ioc->name, 2747 __FUNCTION__, __LINE__)); 2748 break; /* non-fatal: an rphy can be added later */ 2749 } 2750 2751 rphy->identify = identify; 2752 if (sas_rphy_add(rphy)) { 2753 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 2754 "%s: exit at line=%d\n", ioc->name, 2755 __FUNCTION__, __LINE__)); 2756 sas_rphy_free(rphy); 2757 break; 2758 } 2759 mptsas_set_rphy(ioc, phy_info, rphy); 2760 break; 2761 case MPTSAS_ADD_RAID: 2762 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, 2763 ev->id, 0); 2764 if (sdev) { 2765 scsi_device_put(sdev); 2766 break; 2767 } 2768 printk(MYIOC_s_INFO_FMT 2769 "attaching raid volume, channel %d, id %d\n", 2770 ioc->name, MPTSAS_RAID_CHANNEL, ev->id); 2771 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, ev->id, 0); 2772 mpt_findImVolumes(ioc); 2773 break; 2774 case MPTSAS_DEL_RAID: 2775 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, 2776 ev->id, 0); 2777 if (!sdev) 2778 break; 2779 printk(MYIOC_s_INFO_FMT 2780 "removing raid volume, channel %d, id %d\n", 2781 ioc->name, MPTSAS_RAID_CHANNEL, ev->id); 2782 vdevice = sdev->hostdata; 2783 scsi_remove_device(sdev); 2784 scsi_device_put(sdev); 2785 mpt_findImVolumes(ioc); 2786 break; 2787 case MPTSAS_ADD_INACTIVE_VOLUME: 2788 mptsas_adding_inactive_raid_components(ioc, 2789 ev->channel, ev->id); 2790 break; 2791 case MPTSAS_IGNORE_EVENT: 2792 default: 2793 break; 2794 } 2795 2796 mutex_unlock(&ioc->sas_discovery_mutex); 2797 kfree(ev); 2798 } 2799 2800 static void 2801 mptsas_send_sas_event(MPT_ADAPTER *ioc, 2802 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data) 2803 { 2804 struct mptsas_hotplug_event *ev; 2805 u32 device_info = le32_to_cpu(sas_event_data->DeviceInfo); 2806 __le64 sas_address; 2807 2808 if ((device_info & 2809 (MPI_SAS_DEVICE_INFO_SSP_TARGET | 2810 MPI_SAS_DEVICE_INFO_STP_TARGET | 2811 MPI_SAS_DEVICE_INFO_SATA_DEVICE )) == 0) 2812 return; 2813 2814 switch (sas_event_data->ReasonCode) { 2815 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING: 2816 2817 mptsas_target_reset_queue(ioc, sas_event_data); 2818 break; 2819 2820 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED: 2821 ev = kzalloc(sizeof(*ev), GFP_ATOMIC); 2822 if (!ev) { 2823 printk(KERN_WARNING "mptsas: lost hotplug event\n"); 2824 break; 2825 } 2826 2827 INIT_WORK(&ev->work, mptsas_hotplug_work); 2828 ev->ioc = ioc; 2829 ev->handle = le16_to_cpu(sas_event_data->DevHandle); 2830 ev->parent_handle = 2831 le16_to_cpu(sas_event_data->ParentDevHandle); 2832 ev->channel = sas_event_data->Bus; 2833 ev->id = sas_event_data->TargetID; 2834 ev->phy_id = sas_event_data->PhyNum; 2835 memcpy(&sas_address, &sas_event_data->SASAddress, 2836 sizeof(__le64)); 2837 ev->sas_address = le64_to_cpu(sas_address); 2838 ev->device_info = device_info; 2839 2840 if (sas_event_data->ReasonCode & 2841 MPI_EVENT_SAS_DEV_STAT_RC_ADDED) 2842 ev->event_type = MPTSAS_ADD_DEVICE; 2843 else 2844 ev->event_type = MPTSAS_DEL_DEVICE; 2845 schedule_work(&ev->work); 2846 break; 2847 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED: 2848 /* 2849 * Persistent table is full. 2850 */ 2851 INIT_WORK(&ioc->sas_persist_task, 2852 mptsas_persist_clear_table); 2853 schedule_work(&ioc->sas_persist_task); 2854 break; 2855 /* 2856 * TODO, handle other events 2857 */ 2858 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA: 2859 case MPI_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED: 2860 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET: 2861 case MPI_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL: 2862 case MPI_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL: 2863 case MPI_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL: 2864 case MPI_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL: 2865 default: 2866 break; 2867 } 2868 } 2869 static void 2870 mptsas_send_raid_event(MPT_ADAPTER *ioc, 2871 EVENT_DATA_RAID *raid_event_data) 2872 { 2873 struct mptsas_hotplug_event *ev; 2874 int status = le32_to_cpu(raid_event_data->SettingsStatus); 2875 int state = (status >> 8) & 0xff; 2876 2877 if (ioc->bus_type != SAS) 2878 return; 2879 2880 ev = kzalloc(sizeof(*ev), GFP_ATOMIC); 2881 if (!ev) { 2882 printk(KERN_WARNING "mptsas: lost hotplug event\n"); 2883 return; 2884 } 2885 2886 INIT_WORK(&ev->work, mptsas_hotplug_work); 2887 ev->ioc = ioc; 2888 ev->id = raid_event_data->VolumeID; 2889 ev->channel = raid_event_data->VolumeBus; 2890 ev->event_type = MPTSAS_IGNORE_EVENT; 2891 2892 switch (raid_event_data->ReasonCode) { 2893 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED: 2894 ev->phys_disk_num_valid = 1; 2895 ev->phys_disk_num = raid_event_data->PhysDiskNum; 2896 ev->event_type = MPTSAS_ADD_DEVICE; 2897 break; 2898 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED: 2899 ev->phys_disk_num_valid = 1; 2900 ev->phys_disk_num = raid_event_data->PhysDiskNum; 2901 ev->hidden_raid_component = 1; 2902 ev->event_type = MPTSAS_DEL_DEVICE; 2903 break; 2904 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED: 2905 switch (state) { 2906 case MPI_PD_STATE_ONLINE: 2907 case MPI_PD_STATE_NOT_COMPATIBLE: 2908 ev->phys_disk_num_valid = 1; 2909 ev->phys_disk_num = raid_event_data->PhysDiskNum; 2910 ev->hidden_raid_component = 1; 2911 ev->event_type = MPTSAS_ADD_DEVICE; 2912 break; 2913 case MPI_PD_STATE_MISSING: 2914 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST: 2915 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST: 2916 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON: 2917 ev->phys_disk_num_valid = 1; 2918 ev->phys_disk_num = raid_event_data->PhysDiskNum; 2919 ev->event_type = MPTSAS_DEL_DEVICE; 2920 break; 2921 default: 2922 break; 2923 } 2924 break; 2925 case MPI_EVENT_RAID_RC_VOLUME_DELETED: 2926 ev->event_type = MPTSAS_DEL_RAID; 2927 break; 2928 case MPI_EVENT_RAID_RC_VOLUME_CREATED: 2929 ev->event_type = MPTSAS_ADD_RAID; 2930 break; 2931 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED: 2932 switch (state) { 2933 case MPI_RAIDVOL0_STATUS_STATE_FAILED: 2934 case MPI_RAIDVOL0_STATUS_STATE_MISSING: 2935 ev->event_type = MPTSAS_DEL_RAID; 2936 break; 2937 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL: 2938 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED: 2939 ev->event_type = MPTSAS_ADD_RAID; 2940 break; 2941 default: 2942 break; 2943 } 2944 break; 2945 default: 2946 break; 2947 } 2948 schedule_work(&ev->work); 2949 } 2950 2951 static void 2952 mptsas_send_discovery_event(MPT_ADAPTER *ioc, 2953 EVENT_DATA_SAS_DISCOVERY *discovery_data) 2954 { 2955 struct mptsas_discovery_event *ev; 2956 2957 /* 2958 * DiscoveryStatus 2959 * 2960 * This flag will be non-zero when firmware 2961 * kicks off discovery, and return to zero 2962 * once its completed. 2963 */ 2964 if (discovery_data->DiscoveryStatus) 2965 return; 2966 2967 ev = kzalloc(sizeof(*ev), GFP_ATOMIC); 2968 if (!ev) 2969 return; 2970 INIT_WORK(&ev->work, mptsas_discovery_work); 2971 ev->ioc = ioc; 2972 schedule_work(&ev->work); 2973 }; 2974 2975 /* 2976 * mptsas_send_ir2_event - handle exposing hidden disk when 2977 * an inactive raid volume is added 2978 * 2979 * @ioc: Pointer to MPT_ADAPTER structure 2980 * @ir2_data 2981 * 2982 */ 2983 static void 2984 mptsas_send_ir2_event(MPT_ADAPTER *ioc, PTR_MPI_EVENT_DATA_IR2 ir2_data) 2985 { 2986 struct mptsas_hotplug_event *ev; 2987 2988 if (ir2_data->ReasonCode != 2989 MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED) 2990 return; 2991 2992 ev = kzalloc(sizeof(*ev), GFP_ATOMIC); 2993 if (!ev) 2994 return; 2995 2996 INIT_WORK(&ev->work, mptsas_hotplug_work); 2997 ev->ioc = ioc; 2998 ev->id = ir2_data->TargetID; 2999 ev->channel = ir2_data->Bus; 3000 ev->event_type = MPTSAS_ADD_INACTIVE_VOLUME; 3001 3002 schedule_work(&ev->work); 3003 }; 3004 3005 static int 3006 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply) 3007 { 3008 int rc=1; 3009 u8 event = le32_to_cpu(reply->Event) & 0xFF; 3010 3011 if (!ioc->sh) 3012 goto out; 3013 3014 /* 3015 * sas_discovery_ignore_events 3016 * 3017 * This flag is to prevent anymore processing of 3018 * sas events once mptsas_remove function is called. 3019 */ 3020 if (ioc->sas_discovery_ignore_events) { 3021 rc = mptscsih_event_process(ioc, reply); 3022 goto out; 3023 } 3024 3025 switch (event) { 3026 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE: 3027 mptsas_send_sas_event(ioc, 3028 (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data); 3029 break; 3030 case MPI_EVENT_INTEGRATED_RAID: 3031 mptsas_send_raid_event(ioc, 3032 (EVENT_DATA_RAID *)reply->Data); 3033 break; 3034 case MPI_EVENT_PERSISTENT_TABLE_FULL: 3035 INIT_WORK(&ioc->sas_persist_task, 3036 mptsas_persist_clear_table); 3037 schedule_work(&ioc->sas_persist_task); 3038 break; 3039 case MPI_EVENT_SAS_DISCOVERY: 3040 mptsas_send_discovery_event(ioc, 3041 (EVENT_DATA_SAS_DISCOVERY *)reply->Data); 3042 break; 3043 case MPI_EVENT_IR2: 3044 mptsas_send_ir2_event(ioc, 3045 (PTR_MPI_EVENT_DATA_IR2)reply->Data); 3046 break; 3047 default: 3048 rc = mptscsih_event_process(ioc, reply); 3049 break; 3050 } 3051 out: 3052 3053 return rc; 3054 } 3055 3056 static int 3057 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id) 3058 { 3059 struct Scsi_Host *sh; 3060 MPT_SCSI_HOST *hd; 3061 MPT_ADAPTER *ioc; 3062 unsigned long flags; 3063 int ii; 3064 int numSGE = 0; 3065 int scale; 3066 int ioc_cap; 3067 int error=0; 3068 int r; 3069 3070 r = mpt_attach(pdev,id); 3071 if (r) 3072 return r; 3073 3074 ioc = pci_get_drvdata(pdev); 3075 ioc->DoneCtx = mptsasDoneCtx; 3076 ioc->TaskCtx = mptsasTaskCtx; 3077 ioc->InternalCtx = mptsasInternalCtx; 3078 3079 /* Added sanity check on readiness of the MPT adapter. 3080 */ 3081 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) { 3082 printk(MYIOC_s_WARN_FMT 3083 "Skipping because it's not operational!\n", 3084 ioc->name); 3085 error = -ENODEV; 3086 goto out_mptsas_probe; 3087 } 3088 3089 if (!ioc->active) { 3090 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n", 3091 ioc->name); 3092 error = -ENODEV; 3093 goto out_mptsas_probe; 3094 } 3095 3096 /* Sanity check - ensure at least 1 port is INITIATOR capable 3097 */ 3098 ioc_cap = 0; 3099 for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) { 3100 if (ioc->pfacts[ii].ProtocolFlags & 3101 MPI_PORTFACTS_PROTOCOL_INITIATOR) 3102 ioc_cap++; 3103 } 3104 3105 if (!ioc_cap) { 3106 printk(MYIOC_s_WARN_FMT 3107 "Skipping ioc=%p because SCSI Initiator mode " 3108 "is NOT enabled!\n", ioc->name, ioc); 3109 return 0; 3110 } 3111 3112 sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST)); 3113 if (!sh) { 3114 printk(MYIOC_s_WARN_FMT 3115 "Unable to register controller with SCSI subsystem\n", 3116 ioc->name); 3117 error = -1; 3118 goto out_mptsas_probe; 3119 } 3120 3121 spin_lock_irqsave(&ioc->FreeQlock, flags); 3122 3123 /* Attach the SCSI Host to the IOC structure 3124 */ 3125 ioc->sh = sh; 3126 3127 sh->io_port = 0; 3128 sh->n_io_port = 0; 3129 sh->irq = 0; 3130 3131 /* set 16 byte cdb's */ 3132 sh->max_cmd_len = 16; 3133 3134 sh->max_id = ioc->pfacts[0].PortSCSIID; 3135 sh->max_lun = max_lun; 3136 3137 sh->transportt = mptsas_transport_template; 3138 3139 sh->this_id = ioc->pfacts[0].PortSCSIID; 3140 3141 /* Required entry. 3142 */ 3143 sh->unique_id = ioc->id; 3144 3145 INIT_LIST_HEAD(&ioc->sas_topology); 3146 mutex_init(&ioc->sas_topology_mutex); 3147 mutex_init(&ioc->sas_discovery_mutex); 3148 mutex_init(&ioc->sas_mgmt.mutex); 3149 init_completion(&ioc->sas_mgmt.done); 3150 3151 /* Verify that we won't exceed the maximum 3152 * number of chain buffers 3153 * We can optimize: ZZ = req_sz/sizeof(SGE) 3154 * For 32bit SGE's: 3155 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ 3156 * + (req_sz - 64)/sizeof(SGE) 3157 * A slightly different algorithm is required for 3158 * 64bit SGEs. 3159 */ 3160 scale = ioc->req_sz/(sizeof(dma_addr_t) + sizeof(u32)); 3161 if (sizeof(dma_addr_t) == sizeof(u64)) { 3162 numSGE = (scale - 1) * 3163 (ioc->facts.MaxChainDepth-1) + scale + 3164 (ioc->req_sz - 60) / (sizeof(dma_addr_t) + 3165 sizeof(u32)); 3166 } else { 3167 numSGE = 1 + (scale - 1) * 3168 (ioc->facts.MaxChainDepth-1) + scale + 3169 (ioc->req_sz - 64) / (sizeof(dma_addr_t) + 3170 sizeof(u32)); 3171 } 3172 3173 if (numSGE < sh->sg_tablesize) { 3174 /* Reset this value */ 3175 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT 3176 "Resetting sg_tablesize to %d from %d\n", 3177 ioc->name, numSGE, sh->sg_tablesize)); 3178 sh->sg_tablesize = numSGE; 3179 } 3180 3181 hd = (MPT_SCSI_HOST *) sh->hostdata; 3182 hd->ioc = ioc; 3183 3184 /* SCSI needs scsi_cmnd lookup table! 3185 * (with size equal to req_depth*PtrSz!) 3186 */ 3187 hd->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC); 3188 if (!hd->ScsiLookup) { 3189 error = -ENOMEM; 3190 goto out_mptsas_probe; 3191 } 3192 3193 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n", 3194 ioc->name, hd->ScsiLookup)); 3195 3196 /* Clear the TM flags 3197 */ 3198 hd->tmPending = 0; 3199 hd->tmState = TM_STATE_NONE; 3200 hd->resetPending = 0; 3201 hd->abortSCpnt = NULL; 3202 3203 /* Clear the pointer used to store 3204 * single-threaded commands, i.e., those 3205 * issued during a bus scan, dv and 3206 * configuration pages. 3207 */ 3208 hd->cmdPtr = NULL; 3209 3210 /* Initialize this SCSI Hosts' timers 3211 * To use, set the timer expires field 3212 * and add_timer 3213 */ 3214 init_timer(&hd->timer); 3215 hd->timer.data = (unsigned long) hd; 3216 hd->timer.function = mptscsih_timer_expired; 3217 3218 ioc->sas_data.ptClear = mpt_pt_clear; 3219 3220 init_waitqueue_head(&hd->scandv_waitq); 3221 hd->scandv_wait_done = 0; 3222 hd->last_queue_full = 0; 3223 INIT_LIST_HEAD(&hd->target_reset_list); 3224 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 3225 3226 if (ioc->sas_data.ptClear==1) { 3227 mptbase_sas_persist_operation( 3228 ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT); 3229 } 3230 3231 error = scsi_add_host(sh, &ioc->pcidev->dev); 3232 if (error) { 3233 dprintk(ioc, printk(KERN_ERR MYNAM 3234 "scsi_add_host failed\n")); 3235 goto out_mptsas_probe; 3236 } 3237 3238 mptsas_scan_sas_topology(ioc); 3239 3240 return 0; 3241 3242 out_mptsas_probe: 3243 3244 mptscsih_remove(pdev); 3245 return error; 3246 } 3247 3248 static void __devexit mptsas_remove(struct pci_dev *pdev) 3249 { 3250 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 3251 struct mptsas_portinfo *p, *n; 3252 int i; 3253 3254 ioc->sas_discovery_ignore_events = 1; 3255 sas_remove_host(ioc->sh); 3256 3257 mutex_lock(&ioc->sas_topology_mutex); 3258 list_for_each_entry_safe(p, n, &ioc->sas_topology, list) { 3259 list_del(&p->list); 3260 for (i = 0 ; i < p->num_phys ; i++) 3261 mptsas_port_delete(ioc, p->phy_info[i].port_details); 3262 kfree(p->phy_info); 3263 kfree(p); 3264 } 3265 mutex_unlock(&ioc->sas_topology_mutex); 3266 3267 mptscsih_remove(pdev); 3268 } 3269 3270 static struct pci_device_id mptsas_pci_table[] = { 3271 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064, 3272 PCI_ANY_ID, PCI_ANY_ID }, 3273 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068, 3274 PCI_ANY_ID, PCI_ANY_ID }, 3275 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E, 3276 PCI_ANY_ID, PCI_ANY_ID }, 3277 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E, 3278 PCI_ANY_ID, PCI_ANY_ID }, 3279 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078, 3280 PCI_ANY_ID, PCI_ANY_ID }, 3281 {0} /* Terminating entry */ 3282 }; 3283 MODULE_DEVICE_TABLE(pci, mptsas_pci_table); 3284 3285 3286 static struct pci_driver mptsas_driver = { 3287 .name = "mptsas", 3288 .id_table = mptsas_pci_table, 3289 .probe = mptsas_probe, 3290 .remove = __devexit_p(mptsas_remove), 3291 .shutdown = mptscsih_shutdown, 3292 #ifdef CONFIG_PM 3293 .suspend = mptscsih_suspend, 3294 .resume = mptscsih_resume, 3295 #endif 3296 }; 3297 3298 static int __init 3299 mptsas_init(void) 3300 { 3301 int error; 3302 3303 show_mptmod_ver(my_NAME, my_VERSION); 3304 3305 mptsas_transport_template = 3306 sas_attach_transport(&mptsas_transport_functions); 3307 if (!mptsas_transport_template) 3308 return -ENODEV; 3309 3310 mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER); 3311 mptsasTaskCtx = mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER); 3312 mptsasInternalCtx = 3313 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER); 3314 mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER); 3315 3316 mpt_event_register(mptsasDoneCtx, mptsas_event_process); 3317 mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset); 3318 3319 error = pci_register_driver(&mptsas_driver); 3320 if (error) 3321 sas_release_transport(mptsas_transport_template); 3322 3323 return error; 3324 } 3325 3326 static void __exit 3327 mptsas_exit(void) 3328 { 3329 pci_unregister_driver(&mptsas_driver); 3330 sas_release_transport(mptsas_transport_template); 3331 3332 mpt_reset_deregister(mptsasDoneCtx); 3333 mpt_event_deregister(mptsasDoneCtx); 3334 3335 mpt_deregister(mptsasMgmtCtx); 3336 mpt_deregister(mptsasInternalCtx); 3337 mpt_deregister(mptsasTaskCtx); 3338 mpt_deregister(mptsasDoneCtx); 3339 } 3340 3341 module_init(mptsas_init); 3342 module_exit(mptsas_exit); 3343