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