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