1 /* 2 * linux/drivers/message/fusion/mptsas.c 3 * For use with LSI PCI chip/adapter(s) 4 * running LSI Fusion MPT (Message Passing Technology) firmware. 5 * 6 * Copyright (c) 1999-2008 LSI Corporation 7 * (mailto:DL-MPTFusionLinux@lsi.com) 8 */ 9 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 10 /* 11 This program is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; version 2 of the License. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 NO WARRANTY 21 THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 22 CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 23 LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 24 MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 25 solely responsible for determining the appropriateness of using and 26 distributing the Program and assumes all risks associated with its 27 exercise of rights under this Agreement, including but not limited to 28 the risks and costs of program errors, damage to or loss of data, 29 programs or equipment, and unavailability or interruption of operations. 30 31 DISCLAIMER OF LIABILITY 32 NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 33 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 34 DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 35 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 36 TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 37 USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 38 HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 39 40 You should have received a copy of the GNU General Public License 41 along with this program; if not, write to the Free Software 42 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 43 */ 44 /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ 45 46 #include <linux/module.h> 47 #include <linux/kernel.h> 48 #include <linux/slab.h> 49 #include <linux/init.h> 50 #include <linux/errno.h> 51 #include <linux/jiffies.h> 52 #include <linux/workqueue.h> 53 #include <linux/delay.h> /* for mdelay */ 54 55 #include <scsi/scsi.h> 56 #include <scsi/scsi_cmnd.h> 57 #include <scsi/scsi_device.h> 58 #include <scsi/scsi_host.h> 59 #include <scsi/scsi_transport_sas.h> 60 #include <scsi/scsi_dbg.h> 61 62 #include "mptbase.h" 63 #include "mptscsih.h" 64 #include "mptsas.h" 65 66 67 #define my_NAME "Fusion MPT SAS Host driver" 68 #define my_VERSION MPT_LINUX_VERSION_COMMON 69 #define MYNAM "mptsas" 70 71 /* 72 * Reserved channel for integrated raid 73 */ 74 #define MPTSAS_RAID_CHANNEL 1 75 76 #define SAS_CONFIG_PAGE_TIMEOUT 30 77 MODULE_AUTHOR(MODULEAUTHOR); 78 MODULE_DESCRIPTION(my_NAME); 79 MODULE_LICENSE("GPL"); 80 MODULE_VERSION(my_VERSION); 81 82 static int mpt_pt_clear; 83 module_param(mpt_pt_clear, int, 0); 84 MODULE_PARM_DESC(mpt_pt_clear, 85 " Clear persistency table: enable=1 " 86 "(default=MPTSCSIH_PT_CLEAR=0)"); 87 88 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */ 89 #define MPTSAS_MAX_LUN (16895) 90 static int max_lun = MPTSAS_MAX_LUN; 91 module_param(max_lun, int, 0); 92 MODULE_PARM_DESC(max_lun, " max lun, default=16895 "); 93 94 static u8 mptsasDoneCtx = MPT_MAX_PROTOCOL_DRIVERS; 95 static u8 mptsasTaskCtx = MPT_MAX_PROTOCOL_DRIVERS; 96 static u8 mptsasInternalCtx = MPT_MAX_PROTOCOL_DRIVERS; /* Used only for internal commands */ 97 static u8 mptsasMgmtCtx = MPT_MAX_PROTOCOL_DRIVERS; 98 static u8 mptsasDeviceResetCtx = MPT_MAX_PROTOCOL_DRIVERS; 99 100 static void mptsas_firmware_event_work(struct work_struct *work); 101 static void mptsas_send_sas_event(struct fw_event_work *fw_event); 102 static void mptsas_send_raid_event(struct fw_event_work *fw_event); 103 static void mptsas_send_ir2_event(struct fw_event_work *fw_event); 104 static void mptsas_parse_device_info(struct sas_identify *identify, 105 struct mptsas_devinfo *device_info); 106 static inline void mptsas_set_rphy(MPT_ADAPTER *ioc, 107 struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy); 108 static struct mptsas_phyinfo *mptsas_find_phyinfo_by_sas_address 109 (MPT_ADAPTER *ioc, u64 sas_address); 110 static int mptsas_sas_device_pg0(MPT_ADAPTER *ioc, 111 struct mptsas_devinfo *device_info, u32 form, u32 form_specific); 112 static int mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, 113 struct mptsas_enclosure *enclosure, u32 form, u32 form_specific); 114 static int mptsas_add_end_device(MPT_ADAPTER *ioc, 115 struct mptsas_phyinfo *phy_info); 116 static void mptsas_del_end_device(MPT_ADAPTER *ioc, 117 struct mptsas_phyinfo *phy_info); 118 static void mptsas_send_link_status_event(struct fw_event_work *fw_event); 119 static struct mptsas_portinfo *mptsas_find_portinfo_by_sas_address 120 (MPT_ADAPTER *ioc, u64 sas_address); 121 static void mptsas_expander_delete(MPT_ADAPTER *ioc, 122 struct mptsas_portinfo *port_info, u8 force); 123 static void mptsas_send_expander_event(struct fw_event_work *fw_event); 124 static void mptsas_not_responding_devices(MPT_ADAPTER *ioc); 125 static void mptsas_scan_sas_topology(MPT_ADAPTER *ioc); 126 static void mptsas_broadcast_primative_work(struct fw_event_work *fw_event); 127 static void mptsas_handle_queue_full_event(struct fw_event_work *fw_event); 128 static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id); 129 130 static void mptsas_print_phy_data(MPT_ADAPTER *ioc, 131 MPI_SAS_IO_UNIT0_PHY_DATA *phy_data) 132 { 133 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 134 "---- IO UNIT PAGE 0 ------------\n", ioc->name)); 135 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n", 136 ioc->name, le16_to_cpu(phy_data->AttachedDeviceHandle))); 137 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Controller Handle=0x%X\n", 138 ioc->name, le16_to_cpu(phy_data->ControllerDevHandle))); 139 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port=0x%X\n", 140 ioc->name, phy_data->Port)); 141 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Port Flags=0x%X\n", 142 ioc->name, phy_data->PortFlags)); 143 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Flags=0x%X\n", 144 ioc->name, phy_data->PhyFlags)); 145 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n", 146 ioc->name, phy_data->NegotiatedLinkRate)); 147 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 148 "Controller PHY Device Info=0x%X\n", ioc->name, 149 le32_to_cpu(phy_data->ControllerPhyDeviceInfo))); 150 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "DiscoveryStatus=0x%X\n\n", 151 ioc->name, le32_to_cpu(phy_data->DiscoveryStatus))); 152 } 153 154 static void mptsas_print_phy_pg0(MPT_ADAPTER *ioc, SasPhyPage0_t *pg0) 155 { 156 __le64 sas_address; 157 158 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64)); 159 160 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 161 "---- SAS PHY PAGE 0 ------------\n", ioc->name)); 162 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 163 "Attached Device Handle=0x%X\n", ioc->name, 164 le16_to_cpu(pg0->AttachedDevHandle))); 165 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n", 166 ioc->name, (unsigned long long)le64_to_cpu(sas_address))); 167 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 168 "Attached PHY Identifier=0x%X\n", ioc->name, 169 pg0->AttachedPhyIdentifier)); 170 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Attached Device Info=0x%X\n", 171 ioc->name, le32_to_cpu(pg0->AttachedDeviceInfo))); 172 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n", 173 ioc->name, pg0->ProgrammedLinkRate)); 174 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Change Count=0x%X\n", 175 ioc->name, pg0->ChangeCount)); 176 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Info=0x%X\n\n", 177 ioc->name, le32_to_cpu(pg0->PhyInfo))); 178 } 179 180 static void mptsas_print_phy_pg1(MPT_ADAPTER *ioc, SasPhyPage1_t *pg1) 181 { 182 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 183 "---- SAS PHY PAGE 1 ------------\n", ioc->name)); 184 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Invalid Dword Count=0x%x\n", 185 ioc->name, pg1->InvalidDwordCount)); 186 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 187 "Running Disparity Error Count=0x%x\n", ioc->name, 188 pg1->RunningDisparityErrorCount)); 189 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 190 "Loss Dword Synch Count=0x%x\n", ioc->name, 191 pg1->LossDwordSynchCount)); 192 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 193 "PHY Reset Problem Count=0x%x\n\n", ioc->name, 194 pg1->PhyResetProblemCount)); 195 } 196 197 static void mptsas_print_device_pg0(MPT_ADAPTER *ioc, SasDevicePage0_t *pg0) 198 { 199 __le64 sas_address; 200 201 memcpy(&sas_address, &pg0->SASAddress, sizeof(__le64)); 202 203 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 204 "---- SAS DEVICE PAGE 0 ---------\n", ioc->name)); 205 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Handle=0x%X\n", 206 ioc->name, le16_to_cpu(pg0->DevHandle))); 207 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Handle=0x%X\n", 208 ioc->name, le16_to_cpu(pg0->ParentDevHandle))); 209 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Enclosure Handle=0x%X\n", 210 ioc->name, le16_to_cpu(pg0->EnclosureHandle))); 211 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Slot=0x%X\n", 212 ioc->name, le16_to_cpu(pg0->Slot))); 213 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "SAS Address=0x%llX\n", 214 ioc->name, (unsigned long long)le64_to_cpu(sas_address))); 215 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Target ID=0x%X\n", 216 ioc->name, pg0->TargetID)); 217 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Bus=0x%X\n", 218 ioc->name, pg0->Bus)); 219 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Parent Phy Num=0x%X\n", 220 ioc->name, pg0->PhyNum)); 221 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Access Status=0x%X\n", 222 ioc->name, le16_to_cpu(pg0->AccessStatus))); 223 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Device Info=0x%X\n", 224 ioc->name, le32_to_cpu(pg0->DeviceInfo))); 225 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Flags=0x%X\n", 226 ioc->name, le16_to_cpu(pg0->Flags))); 227 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n\n", 228 ioc->name, pg0->PhysicalPort)); 229 } 230 231 static void mptsas_print_expander_pg1(MPT_ADAPTER *ioc, SasExpanderPage1_t *pg1) 232 { 233 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 234 "---- SAS EXPANDER PAGE 1 ------------\n", ioc->name)); 235 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Physical Port=0x%X\n", 236 ioc->name, pg1->PhysicalPort)); 237 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "PHY Identifier=0x%X\n", 238 ioc->name, pg1->PhyIdentifier)); 239 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Negotiated Link Rate=0x%X\n", 240 ioc->name, pg1->NegotiatedLinkRate)); 241 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Programmed Link Rate=0x%X\n", 242 ioc->name, pg1->ProgrammedLinkRate)); 243 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Hardware Link Rate=0x%X\n", 244 ioc->name, pg1->HwLinkRate)); 245 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Owner Device Handle=0x%X\n", 246 ioc->name, le16_to_cpu(pg1->OwnerDevHandle))); 247 dsasprintk(ioc, printk(MYIOC_s_DEBUG_FMT 248 "Attached Device Handle=0x%X\n\n", ioc->name, 249 le16_to_cpu(pg1->AttachedDevHandle))); 250 } 251 252 /* inhibit sas firmware event handling */ 253 static void 254 mptsas_fw_event_off(MPT_ADAPTER *ioc) 255 { 256 unsigned long flags; 257 258 spin_lock_irqsave(&ioc->fw_event_lock, flags); 259 ioc->fw_events_off = 1; 260 ioc->sas_discovery_quiesce_io = 0; 261 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 262 263 } 264 265 /* enable sas firmware event handling */ 266 static void 267 mptsas_fw_event_on(MPT_ADAPTER *ioc) 268 { 269 unsigned long flags; 270 271 spin_lock_irqsave(&ioc->fw_event_lock, flags); 272 ioc->fw_events_off = 0; 273 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 274 } 275 276 /* queue a sas firmware event */ 277 static void 278 mptsas_add_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event, 279 unsigned long delay) 280 { 281 unsigned long flags; 282 283 spin_lock_irqsave(&ioc->fw_event_lock, flags); 284 list_add_tail(&fw_event->list, &ioc->fw_event_list); 285 INIT_DELAYED_WORK(&fw_event->work, mptsas_firmware_event_work); 286 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: add (fw_event=0x%p)\n", 287 ioc->name, __func__, fw_event)); 288 queue_delayed_work(ioc->fw_event_q, &fw_event->work, 289 delay); 290 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 291 } 292 293 /* requeue a sas firmware event */ 294 static void 295 mptsas_requeue_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event, 296 unsigned long delay) 297 { 298 unsigned long flags; 299 spin_lock_irqsave(&ioc->fw_event_lock, flags); 300 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: reschedule task " 301 "(fw_event=0x%p)\n", ioc->name, __func__, fw_event)); 302 fw_event->retries++; 303 queue_delayed_work(ioc->fw_event_q, &fw_event->work, 304 msecs_to_jiffies(delay)); 305 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 306 } 307 308 /* free memory assoicated to a sas firmware event */ 309 static void 310 mptsas_free_fw_event(MPT_ADAPTER *ioc, struct fw_event_work *fw_event) 311 { 312 unsigned long flags; 313 314 spin_lock_irqsave(&ioc->fw_event_lock, flags); 315 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: kfree (fw_event=0x%p)\n", 316 ioc->name, __func__, fw_event)); 317 list_del(&fw_event->list); 318 kfree(fw_event); 319 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 320 } 321 322 /* walk the firmware event queue, and either stop or wait for 323 * outstanding events to complete */ 324 static void 325 mptsas_cleanup_fw_event_q(MPT_ADAPTER *ioc) 326 { 327 struct fw_event_work *fw_event, *next; 328 struct mptsas_target_reset_event *target_reset_list, *n; 329 MPT_SCSI_HOST *hd = shost_priv(ioc->sh); 330 331 /* flush the target_reset_list */ 332 if (!list_empty(&hd->target_reset_list)) { 333 list_for_each_entry_safe(target_reset_list, n, 334 &hd->target_reset_list, list) { 335 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 336 "%s: removing target reset for id=%d\n", 337 ioc->name, __func__, 338 target_reset_list->sas_event_data.TargetID)); 339 list_del(&target_reset_list->list); 340 kfree(target_reset_list); 341 } 342 } 343 344 if (list_empty(&ioc->fw_event_list) || 345 !ioc->fw_event_q || in_interrupt()) 346 return; 347 348 list_for_each_entry_safe(fw_event, next, &ioc->fw_event_list, list) { 349 if (cancel_delayed_work(&fw_event->work)) 350 mptsas_free_fw_event(ioc, fw_event); 351 } 352 } 353 354 355 static inline MPT_ADAPTER *phy_to_ioc(struct sas_phy *phy) 356 { 357 struct Scsi_Host *shost = dev_to_shost(phy->dev.parent); 358 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc; 359 } 360 361 static inline MPT_ADAPTER *rphy_to_ioc(struct sas_rphy *rphy) 362 { 363 struct Scsi_Host *shost = dev_to_shost(rphy->dev.parent->parent); 364 return ((MPT_SCSI_HOST *)shost->hostdata)->ioc; 365 } 366 367 /* 368 * mptsas_find_portinfo_by_handle 369 * 370 * This function should be called with the sas_topology_mutex already held 371 */ 372 static struct mptsas_portinfo * 373 mptsas_find_portinfo_by_handle(MPT_ADAPTER *ioc, u16 handle) 374 { 375 struct mptsas_portinfo *port_info, *rc=NULL; 376 int i; 377 378 list_for_each_entry(port_info, &ioc->sas_topology, list) 379 for (i = 0; i < port_info->num_phys; i++) 380 if (port_info->phy_info[i].identify.handle == handle) { 381 rc = port_info; 382 goto out; 383 } 384 out: 385 return rc; 386 } 387 388 /** 389 * mptsas_find_portinfo_by_sas_address - 390 * @ioc: Pointer to MPT_ADAPTER structure 391 * @handle: 392 * 393 * This function should be called with the sas_topology_mutex already held 394 * 395 **/ 396 static struct mptsas_portinfo * 397 mptsas_find_portinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address) 398 { 399 struct mptsas_portinfo *port_info, *rc = NULL; 400 int i; 401 402 if (sas_address >= ioc->hba_port_sas_addr && 403 sas_address < (ioc->hba_port_sas_addr + 404 ioc->hba_port_num_phy)) 405 return ioc->hba_port_info; 406 407 mutex_lock(&ioc->sas_topology_mutex); 408 list_for_each_entry(port_info, &ioc->sas_topology, list) 409 for (i = 0; i < port_info->num_phys; i++) 410 if (port_info->phy_info[i].identify.sas_address == 411 sas_address) { 412 rc = port_info; 413 goto out; 414 } 415 out: 416 mutex_unlock(&ioc->sas_topology_mutex); 417 return rc; 418 } 419 420 /* 421 * Returns true if there is a scsi end device 422 */ 423 static inline int 424 mptsas_is_end_device(struct mptsas_devinfo * attached) 425 { 426 if ((attached->sas_address) && 427 (attached->device_info & 428 MPI_SAS_DEVICE_INFO_END_DEVICE) && 429 ((attached->device_info & 430 MPI_SAS_DEVICE_INFO_SSP_TARGET) | 431 (attached->device_info & 432 MPI_SAS_DEVICE_INFO_STP_TARGET) | 433 (attached->device_info & 434 MPI_SAS_DEVICE_INFO_SATA_DEVICE))) 435 return 1; 436 else 437 return 0; 438 } 439 440 /* no mutex */ 441 static void 442 mptsas_port_delete(MPT_ADAPTER *ioc, struct mptsas_portinfo_details * port_details) 443 { 444 struct mptsas_portinfo *port_info; 445 struct mptsas_phyinfo *phy_info; 446 u8 i; 447 448 if (!port_details) 449 return; 450 451 port_info = port_details->port_info; 452 phy_info = port_info->phy_info; 453 454 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: [%p]: num_phys=%02d " 455 "bitmask=0x%016llX\n", ioc->name, __func__, port_details, 456 port_details->num_phys, (unsigned long long) 457 port_details->phy_bitmask)); 458 459 for (i = 0; i < port_info->num_phys; i++, phy_info++) { 460 if(phy_info->port_details != port_details) 461 continue; 462 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo)); 463 mptsas_set_rphy(ioc, phy_info, NULL); 464 phy_info->port_details = NULL; 465 } 466 kfree(port_details); 467 } 468 469 static inline struct sas_rphy * 470 mptsas_get_rphy(struct mptsas_phyinfo *phy_info) 471 { 472 if (phy_info->port_details) 473 return phy_info->port_details->rphy; 474 else 475 return NULL; 476 } 477 478 static inline void 479 mptsas_set_rphy(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_rphy *rphy) 480 { 481 if (phy_info->port_details) { 482 phy_info->port_details->rphy = rphy; 483 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "sas_rphy_add: rphy=%p\n", 484 ioc->name, rphy)); 485 } 486 487 if (rphy) { 488 dsaswideprintk(ioc, dev_printk(KERN_DEBUG, 489 &rphy->dev, MYIOC_s_FMT "add:", ioc->name)); 490 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "rphy=%p release=%p\n", 491 ioc->name, rphy, rphy->dev.release)); 492 } 493 } 494 495 static inline struct sas_port * 496 mptsas_get_port(struct mptsas_phyinfo *phy_info) 497 { 498 if (phy_info->port_details) 499 return phy_info->port_details->port; 500 else 501 return NULL; 502 } 503 504 static inline void 505 mptsas_set_port(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, struct sas_port *port) 506 { 507 if (phy_info->port_details) 508 phy_info->port_details->port = port; 509 510 if (port) { 511 dsaswideprintk(ioc, dev_printk(KERN_DEBUG, 512 &port->dev, MYIOC_s_FMT "add:", ioc->name)); 513 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "port=%p release=%p\n", 514 ioc->name, port, port->dev.release)); 515 } 516 } 517 518 static inline struct scsi_target * 519 mptsas_get_starget(struct mptsas_phyinfo *phy_info) 520 { 521 if (phy_info->port_details) 522 return phy_info->port_details->starget; 523 else 524 return NULL; 525 } 526 527 static inline void 528 mptsas_set_starget(struct mptsas_phyinfo *phy_info, struct scsi_target * 529 starget) 530 { 531 if (phy_info->port_details) 532 phy_info->port_details->starget = starget; 533 } 534 535 /** 536 * mptsas_add_device_component - 537 * @ioc: Pointer to MPT_ADAPTER structure 538 * @channel: fw mapped id's 539 * @id: 540 * @sas_address: 541 * @device_info: 542 * 543 **/ 544 static void 545 mptsas_add_device_component(MPT_ADAPTER *ioc, u8 channel, u8 id, 546 u64 sas_address, u32 device_info, u16 slot, u64 enclosure_logical_id) 547 { 548 struct mptsas_device_info *sas_info, *next; 549 struct scsi_device *sdev; 550 struct scsi_target *starget; 551 struct sas_rphy *rphy; 552 553 /* 554 * Delete all matching devices out of the list 555 */ 556 mutex_lock(&ioc->sas_device_info_mutex); 557 list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list, 558 list) { 559 if (!sas_info->is_logical_volume && 560 (sas_info->sas_address == sas_address || 561 (sas_info->fw.channel == channel && 562 sas_info->fw.id == id))) { 563 list_del(&sas_info->list); 564 kfree(sas_info); 565 } 566 } 567 568 sas_info = kzalloc(sizeof(struct mptsas_device_info), GFP_KERNEL); 569 if (!sas_info) 570 goto out; 571 572 /* 573 * Set Firmware mapping 574 */ 575 sas_info->fw.id = id; 576 sas_info->fw.channel = channel; 577 578 sas_info->sas_address = sas_address; 579 sas_info->device_info = device_info; 580 sas_info->slot = slot; 581 sas_info->enclosure_logical_id = enclosure_logical_id; 582 INIT_LIST_HEAD(&sas_info->list); 583 list_add_tail(&sas_info->list, &ioc->sas_device_info_list); 584 585 /* 586 * Set OS mapping 587 */ 588 shost_for_each_device(sdev, ioc->sh) { 589 starget = scsi_target(sdev); 590 rphy = dev_to_rphy(starget->dev.parent); 591 if (rphy->identify.sas_address == sas_address) { 592 sas_info->os.id = starget->id; 593 sas_info->os.channel = starget->channel; 594 } 595 } 596 597 out: 598 mutex_unlock(&ioc->sas_device_info_mutex); 599 return; 600 } 601 602 /** 603 * mptsas_add_device_component_by_fw - 604 * @ioc: Pointer to MPT_ADAPTER structure 605 * @channel: fw mapped id's 606 * @id: 607 * 608 **/ 609 static void 610 mptsas_add_device_component_by_fw(MPT_ADAPTER *ioc, u8 channel, u8 id) 611 { 612 struct mptsas_devinfo sas_device; 613 struct mptsas_enclosure enclosure_info; 614 int rc; 615 616 rc = mptsas_sas_device_pg0(ioc, &sas_device, 617 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 618 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 619 (channel << 8) + id); 620 if (rc) 621 return; 622 623 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure)); 624 mptsas_sas_enclosure_pg0(ioc, &enclosure_info, 625 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE << 626 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), 627 sas_device.handle_enclosure); 628 629 mptsas_add_device_component(ioc, sas_device.channel, 630 sas_device.id, sas_device.sas_address, sas_device.device_info, 631 sas_device.slot, enclosure_info.enclosure_logical_id); 632 } 633 634 /** 635 * mptsas_add_device_component_starget_ir - Handle Integrated RAID, adding each individual device to list 636 * @ioc: Pointer to MPT_ADAPTER structure 637 * @channel: fw mapped id's 638 * @id: 639 * 640 **/ 641 static void 642 mptsas_add_device_component_starget_ir(MPT_ADAPTER *ioc, 643 struct scsi_target *starget) 644 { 645 CONFIGPARMS cfg; 646 ConfigPageHeader_t hdr; 647 dma_addr_t dma_handle; 648 pRaidVolumePage0_t buffer = NULL; 649 int i; 650 RaidPhysDiskPage0_t phys_disk; 651 struct mptsas_device_info *sas_info, *next; 652 653 memset(&cfg, 0 , sizeof(CONFIGPARMS)); 654 memset(&hdr, 0 , sizeof(ConfigPageHeader_t)); 655 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME; 656 /* assumption that all volumes on channel = 0 */ 657 cfg.pageAddr = starget->id; 658 cfg.cfghdr.hdr = &hdr; 659 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 660 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 661 662 if (mpt_config(ioc, &cfg) != 0) 663 goto out; 664 665 if (!hdr.PageLength) 666 goto out; 667 668 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, 669 &dma_handle); 670 671 if (!buffer) 672 goto out; 673 674 cfg.physAddr = dma_handle; 675 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 676 677 if (mpt_config(ioc, &cfg) != 0) 678 goto out; 679 680 if (!buffer->NumPhysDisks) 681 goto out; 682 683 /* 684 * Adding entry for hidden components 685 */ 686 for (i = 0; i < buffer->NumPhysDisks; i++) { 687 688 if (mpt_raid_phys_disk_pg0(ioc, 689 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0) 690 continue; 691 692 mptsas_add_device_component_by_fw(ioc, phys_disk.PhysDiskBus, 693 phys_disk.PhysDiskID); 694 695 mutex_lock(&ioc->sas_device_info_mutex); 696 list_for_each_entry(sas_info, &ioc->sas_device_info_list, 697 list) { 698 if (!sas_info->is_logical_volume && 699 (sas_info->fw.channel == phys_disk.PhysDiskBus && 700 sas_info->fw.id == phys_disk.PhysDiskID)) { 701 sas_info->is_hidden_raid_component = 1; 702 sas_info->volume_id = starget->id; 703 } 704 } 705 mutex_unlock(&ioc->sas_device_info_mutex); 706 707 } 708 709 /* 710 * Delete all matching devices out of the list 711 */ 712 mutex_lock(&ioc->sas_device_info_mutex); 713 list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list, 714 list) { 715 if (sas_info->is_logical_volume && sas_info->fw.id == 716 starget->id) { 717 list_del(&sas_info->list); 718 kfree(sas_info); 719 } 720 } 721 722 sas_info = kzalloc(sizeof(struct mptsas_device_info), GFP_KERNEL); 723 if (sas_info) { 724 sas_info->fw.id = starget->id; 725 sas_info->os.id = starget->id; 726 sas_info->os.channel = starget->channel; 727 sas_info->is_logical_volume = 1; 728 INIT_LIST_HEAD(&sas_info->list); 729 list_add_tail(&sas_info->list, &ioc->sas_device_info_list); 730 } 731 mutex_unlock(&ioc->sas_device_info_mutex); 732 733 out: 734 if (buffer) 735 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer, 736 dma_handle); 737 } 738 739 /** 740 * mptsas_add_device_component_starget - 741 * @ioc: Pointer to MPT_ADAPTER structure 742 * @starget: 743 * 744 **/ 745 static void 746 mptsas_add_device_component_starget(MPT_ADAPTER *ioc, 747 struct scsi_target *starget) 748 { 749 VirtTarget *vtarget; 750 struct sas_rphy *rphy; 751 struct mptsas_phyinfo *phy_info = NULL; 752 struct mptsas_enclosure enclosure_info; 753 754 rphy = dev_to_rphy(starget->dev.parent); 755 vtarget = starget->hostdata; 756 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 757 rphy->identify.sas_address); 758 if (!phy_info) 759 return; 760 761 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure)); 762 mptsas_sas_enclosure_pg0(ioc, &enclosure_info, 763 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE << 764 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), 765 phy_info->attached.handle_enclosure); 766 767 mptsas_add_device_component(ioc, phy_info->attached.channel, 768 phy_info->attached.id, phy_info->attached.sas_address, 769 phy_info->attached.device_info, 770 phy_info->attached.slot, enclosure_info.enclosure_logical_id); 771 } 772 773 /** 774 * mptsas_del_device_component_by_os - Once a device has been removed, we mark the entry in the list as being cached 775 * @ioc: Pointer to MPT_ADAPTER structure 776 * @channel: os mapped id's 777 * @id: 778 * 779 **/ 780 static void 781 mptsas_del_device_component_by_os(MPT_ADAPTER *ioc, u8 channel, u8 id) 782 { 783 struct mptsas_device_info *sas_info, *next; 784 785 /* 786 * Set is_cached flag 787 */ 788 list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list, 789 list) { 790 if (sas_info->os.channel == channel && sas_info->os.id == id) 791 sas_info->is_cached = 1; 792 } 793 } 794 795 /** 796 * mptsas_del_device_components - Cleaning the list 797 * @ioc: Pointer to MPT_ADAPTER structure 798 * 799 **/ 800 static void 801 mptsas_del_device_components(MPT_ADAPTER *ioc) 802 { 803 struct mptsas_device_info *sas_info, *next; 804 805 mutex_lock(&ioc->sas_device_info_mutex); 806 list_for_each_entry_safe(sas_info, next, &ioc->sas_device_info_list, 807 list) { 808 list_del(&sas_info->list); 809 kfree(sas_info); 810 } 811 mutex_unlock(&ioc->sas_device_info_mutex); 812 } 813 814 815 /* 816 * mptsas_setup_wide_ports 817 * 818 * Updates for new and existing narrow/wide port configuration 819 * in the sas_topology 820 */ 821 static void 822 mptsas_setup_wide_ports(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info) 823 { 824 struct mptsas_portinfo_details * port_details; 825 struct mptsas_phyinfo *phy_info, *phy_info_cmp; 826 u64 sas_address; 827 int i, j; 828 829 mutex_lock(&ioc->sas_topology_mutex); 830 831 phy_info = port_info->phy_info; 832 for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) { 833 if (phy_info->attached.handle) 834 continue; 835 port_details = phy_info->port_details; 836 if (!port_details) 837 continue; 838 if (port_details->num_phys < 2) 839 continue; 840 /* 841 * Removing a phy from a port, letting the last 842 * phy be removed by firmware events. 843 */ 844 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT 845 "%s: [%p]: deleting phy = %d\n", 846 ioc->name, __func__, port_details, i)); 847 port_details->num_phys--; 848 port_details->phy_bitmask &= ~ (1 << phy_info->phy_id); 849 memset(&phy_info->attached, 0, sizeof(struct mptsas_devinfo)); 850 if (phy_info->phy) { 851 devtprintk(ioc, dev_printk(KERN_DEBUG, 852 &phy_info->phy->dev, MYIOC_s_FMT 853 "delete phy %d, phy-obj (0x%p)\n", ioc->name, 854 phy_info->phy_id, phy_info->phy)); 855 sas_port_delete_phy(port_details->port, phy_info->phy); 856 } 857 phy_info->port_details = NULL; 858 } 859 860 /* 861 * Populate and refresh the tree 862 */ 863 phy_info = port_info->phy_info; 864 for (i = 0 ; i < port_info->num_phys ; i++, phy_info++) { 865 sas_address = phy_info->attached.sas_address; 866 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "phy_id=%d sas_address=0x%018llX\n", 867 ioc->name, i, (unsigned long long)sas_address)); 868 if (!sas_address) 869 continue; 870 port_details = phy_info->port_details; 871 /* 872 * Forming a port 873 */ 874 if (!port_details) { 875 port_details = kzalloc(sizeof(struct 876 mptsas_portinfo_details), GFP_KERNEL); 877 if (!port_details) 878 goto out; 879 port_details->num_phys = 1; 880 port_details->port_info = port_info; 881 if (phy_info->phy_id < 64 ) 882 port_details->phy_bitmask |= 883 (1 << phy_info->phy_id); 884 phy_info->sas_port_add_phy=1; 885 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tForming port\n\t\t" 886 "phy_id=%d sas_address=0x%018llX\n", 887 ioc->name, i, (unsigned long long)sas_address)); 888 phy_info->port_details = port_details; 889 } 890 891 if (i == port_info->num_phys - 1) 892 continue; 893 phy_info_cmp = &port_info->phy_info[i + 1]; 894 for (j = i + 1 ; j < port_info->num_phys ; j++, 895 phy_info_cmp++) { 896 if (!phy_info_cmp->attached.sas_address) 897 continue; 898 if (sas_address != phy_info_cmp->attached.sas_address) 899 continue; 900 if (phy_info_cmp->port_details == port_details ) 901 continue; 902 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT 903 "\t\tphy_id=%d sas_address=0x%018llX\n", 904 ioc->name, j, (unsigned long long) 905 phy_info_cmp->attached.sas_address)); 906 if (phy_info_cmp->port_details) { 907 port_details->rphy = 908 mptsas_get_rphy(phy_info_cmp); 909 port_details->port = 910 mptsas_get_port(phy_info_cmp); 911 port_details->starget = 912 mptsas_get_starget(phy_info_cmp); 913 port_details->num_phys = 914 phy_info_cmp->port_details->num_phys; 915 if (!phy_info_cmp->port_details->num_phys) 916 kfree(phy_info_cmp->port_details); 917 } else 918 phy_info_cmp->sas_port_add_phy=1; 919 /* 920 * Adding a phy to a port 921 */ 922 phy_info_cmp->port_details = port_details; 923 if (phy_info_cmp->phy_id < 64 ) 924 port_details->phy_bitmask |= 925 (1 << phy_info_cmp->phy_id); 926 port_details->num_phys++; 927 } 928 } 929 930 out: 931 932 for (i = 0; i < port_info->num_phys; i++) { 933 port_details = port_info->phy_info[i].port_details; 934 if (!port_details) 935 continue; 936 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT 937 "%s: [%p]: phy_id=%02d num_phys=%02d " 938 "bitmask=0x%016llX\n", ioc->name, __func__, 939 port_details, i, port_details->num_phys, 940 (unsigned long long)port_details->phy_bitmask)); 941 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT "\t\tport = %p rphy=%p\n", 942 ioc->name, port_details->port, port_details->rphy)); 943 } 944 dsaswideprintk(ioc, printk("\n")); 945 mutex_unlock(&ioc->sas_topology_mutex); 946 } 947 948 /** 949 * csmisas_find_vtarget 950 * 951 * @ioc 952 * @volume_id 953 * @volume_bus 954 * 955 **/ 956 static VirtTarget * 957 mptsas_find_vtarget(MPT_ADAPTER *ioc, u8 channel, u8 id) 958 { 959 struct scsi_device *sdev; 960 VirtDevice *vdevice; 961 VirtTarget *vtarget = NULL; 962 963 shost_for_each_device(sdev, ioc->sh) { 964 vdevice = sdev->hostdata; 965 if ((vdevice == NULL) || 966 (vdevice->vtarget == NULL)) 967 continue; 968 if ((vdevice->vtarget->tflags & 969 MPT_TARGET_FLAGS_RAID_COMPONENT || 970 vdevice->vtarget->raidVolume)) 971 continue; 972 if (vdevice->vtarget->id == id && 973 vdevice->vtarget->channel == channel) 974 vtarget = vdevice->vtarget; 975 } 976 return vtarget; 977 } 978 979 static void 980 mptsas_queue_device_delete(MPT_ADAPTER *ioc, 981 MpiEventDataSasDeviceStatusChange_t *sas_event_data) 982 { 983 struct fw_event_work *fw_event; 984 int sz; 985 986 sz = offsetof(struct fw_event_work, event_data) + 987 sizeof(MpiEventDataSasDeviceStatusChange_t); 988 fw_event = kzalloc(sz, GFP_ATOMIC); 989 if (!fw_event) { 990 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", 991 ioc->name, __func__, __LINE__); 992 return; 993 } 994 memcpy(fw_event->event_data, sas_event_data, 995 sizeof(MpiEventDataSasDeviceStatusChange_t)); 996 fw_event->event = MPI_EVENT_SAS_DEVICE_STATUS_CHANGE; 997 fw_event->ioc = ioc; 998 mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1)); 999 } 1000 1001 static void 1002 mptsas_queue_rescan(MPT_ADAPTER *ioc) 1003 { 1004 struct fw_event_work *fw_event; 1005 int sz; 1006 1007 sz = offsetof(struct fw_event_work, event_data); 1008 fw_event = kzalloc(sz, GFP_ATOMIC); 1009 if (!fw_event) { 1010 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", 1011 ioc->name, __func__, __LINE__); 1012 return; 1013 } 1014 fw_event->event = -1; 1015 fw_event->ioc = ioc; 1016 mptsas_add_fw_event(ioc, fw_event, msecs_to_jiffies(1)); 1017 } 1018 1019 1020 /** 1021 * mptsas_target_reset 1022 * 1023 * Issues TARGET_RESET to end device using handshaking method 1024 * 1025 * @ioc 1026 * @channel 1027 * @id 1028 * 1029 * Returns (1) success 1030 * (0) failure 1031 * 1032 **/ 1033 static int 1034 mptsas_target_reset(MPT_ADAPTER *ioc, u8 channel, u8 id) 1035 { 1036 MPT_FRAME_HDR *mf; 1037 SCSITaskMgmt_t *pScsiTm; 1038 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) 1039 return 0; 1040 1041 1042 mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc); 1043 if (mf == NULL) { 1044 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT 1045 "%s, no msg frames @%d!!\n", ioc->name, 1046 __func__, __LINE__)); 1047 goto out_fail; 1048 } 1049 1050 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request (mf=%p)\n", 1051 ioc->name, mf)); 1052 1053 /* Format the Request 1054 */ 1055 pScsiTm = (SCSITaskMgmt_t *) mf; 1056 memset (pScsiTm, 0, sizeof(SCSITaskMgmt_t)); 1057 pScsiTm->TargetID = id; 1058 pScsiTm->Bus = channel; 1059 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT; 1060 pScsiTm->TaskType = MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET; 1061 pScsiTm->MsgFlags = MPI_SCSITASKMGMT_MSGFLAGS_LIPRESET_RESET_OPTION; 1062 1063 DBG_DUMP_TM_REQUEST_FRAME(ioc, (u32 *)mf); 1064 1065 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1066 "TaskMgmt type=%d (sas device delete) fw_channel = %d fw_id = %d)\n", 1067 ioc->name, MPI_SCSITASKMGMT_TASKTYPE_TARGET_RESET, channel, id)); 1068 1069 mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf); 1070 1071 return 1; 1072 1073 out_fail: 1074 1075 mpt_clear_taskmgmt_in_progress_flag(ioc); 1076 return 0; 1077 } 1078 1079 static void 1080 mptsas_block_io_sdev(struct scsi_device *sdev, void *data) 1081 { 1082 scsi_device_set_state(sdev, SDEV_BLOCK); 1083 } 1084 1085 static void 1086 mptsas_block_io_starget(struct scsi_target *starget) 1087 { 1088 if (starget) 1089 starget_for_each_device(starget, NULL, mptsas_block_io_sdev); 1090 } 1091 1092 /** 1093 * mptsas_target_reset_queue 1094 * 1095 * Receive request for TARGET_RESET after recieving an firmware 1096 * event NOT_RESPONDING_EVENT, then put command in link list 1097 * and queue if task_queue already in use. 1098 * 1099 * @ioc 1100 * @sas_event_data 1101 * 1102 **/ 1103 static void 1104 mptsas_target_reset_queue(MPT_ADAPTER *ioc, 1105 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data) 1106 { 1107 MPT_SCSI_HOST *hd = shost_priv(ioc->sh); 1108 VirtTarget *vtarget = NULL; 1109 struct mptsas_target_reset_event *target_reset_list; 1110 u8 id, channel; 1111 1112 id = sas_event_data->TargetID; 1113 channel = sas_event_data->Bus; 1114 1115 vtarget = mptsas_find_vtarget(ioc, channel, id); 1116 if (vtarget) { 1117 mptsas_block_io_starget(vtarget->starget); 1118 vtarget->deleted = 1; /* block IO */ 1119 } 1120 1121 target_reset_list = kzalloc(sizeof(struct mptsas_target_reset_event), 1122 GFP_ATOMIC); 1123 if (!target_reset_list) { 1124 dfailprintk(ioc, printk(MYIOC_s_WARN_FMT 1125 "%s, failed to allocate mem @%d..!!\n", 1126 ioc->name, __func__, __LINE__)); 1127 return; 1128 } 1129 1130 memcpy(&target_reset_list->sas_event_data, sas_event_data, 1131 sizeof(*sas_event_data)); 1132 list_add_tail(&target_reset_list->list, &hd->target_reset_list); 1133 1134 target_reset_list->time_count = jiffies; 1135 1136 if (mptsas_target_reset(ioc, channel, id)) { 1137 target_reset_list->target_reset_issued = 1; 1138 } 1139 } 1140 1141 /** 1142 * mptsas_taskmgmt_complete - complete SAS task management function 1143 * @ioc: Pointer to MPT_ADAPTER structure 1144 * 1145 * Completion for TARGET_RESET after NOT_RESPONDING_EVENT, enable work 1146 * queue to finish off removing device from upper layers. then send next 1147 * TARGET_RESET in the queue. 1148 **/ 1149 static int 1150 mptsas_taskmgmt_complete(MPT_ADAPTER *ioc, MPT_FRAME_HDR *mf, MPT_FRAME_HDR *mr) 1151 { 1152 MPT_SCSI_HOST *hd = shost_priv(ioc->sh); 1153 struct list_head *head = &hd->target_reset_list; 1154 u8 id, channel; 1155 struct mptsas_target_reset_event *target_reset_list; 1156 SCSITaskMgmtReply_t *pScsiTmReply; 1157 1158 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt completed: " 1159 "(mf = %p, mr = %p)\n", ioc->name, mf, mr)); 1160 1161 pScsiTmReply = (SCSITaskMgmtReply_t *)mr; 1162 if (pScsiTmReply) { 1163 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1164 "\tTaskMgmt completed: fw_channel = %d, fw_id = %d,\n" 1165 "\ttask_type = 0x%02X, iocstatus = 0x%04X " 1166 "loginfo = 0x%08X,\n\tresponse_code = 0x%02X, " 1167 "term_cmnds = %d\n", ioc->name, 1168 pScsiTmReply->Bus, pScsiTmReply->TargetID, 1169 pScsiTmReply->TaskType, 1170 le16_to_cpu(pScsiTmReply->IOCStatus), 1171 le32_to_cpu(pScsiTmReply->IOCLogInfo), 1172 pScsiTmReply->ResponseCode, 1173 le32_to_cpu(pScsiTmReply->TerminationCount))); 1174 1175 if (pScsiTmReply->ResponseCode) 1176 mptscsih_taskmgmt_response_code(ioc, 1177 pScsiTmReply->ResponseCode); 1178 } 1179 1180 if (pScsiTmReply && (pScsiTmReply->TaskType == 1181 MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK || pScsiTmReply->TaskType == 1182 MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET)) { 1183 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_COMMAND_GOOD; 1184 ioc->taskmgmt_cmds.status |= MPT_MGMT_STATUS_RF_VALID; 1185 memcpy(ioc->taskmgmt_cmds.reply, mr, 1186 min(MPT_DEFAULT_FRAME_SIZE, 4 * mr->u.reply.MsgLength)); 1187 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_PENDING) { 1188 ioc->taskmgmt_cmds.status &= ~MPT_MGMT_STATUS_PENDING; 1189 complete(&ioc->taskmgmt_cmds.done); 1190 return 1; 1191 } 1192 return 0; 1193 } 1194 1195 mpt_clear_taskmgmt_in_progress_flag(ioc); 1196 1197 if (list_empty(head)) 1198 return 1; 1199 1200 target_reset_list = list_entry(head->next, 1201 struct mptsas_target_reset_event, list); 1202 1203 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1204 "TaskMgmt: completed (%d seconds)\n", 1205 ioc->name, jiffies_to_msecs(jiffies - 1206 target_reset_list->time_count)/1000)); 1207 1208 id = pScsiTmReply->TargetID; 1209 channel = pScsiTmReply->Bus; 1210 target_reset_list->time_count = jiffies; 1211 1212 /* 1213 * retry target reset 1214 */ 1215 if (!target_reset_list->target_reset_issued) { 1216 if (mptsas_target_reset(ioc, channel, id)) 1217 target_reset_list->target_reset_issued = 1; 1218 return 1; 1219 } 1220 1221 /* 1222 * enable work queue to remove device from upper layers 1223 */ 1224 list_del(&target_reset_list->list); 1225 if ((mptsas_find_vtarget(ioc, channel, id)) && !ioc->fw_events_off) 1226 mptsas_queue_device_delete(ioc, 1227 &target_reset_list->sas_event_data); 1228 1229 1230 /* 1231 * issue target reset to next device in the queue 1232 */ 1233 1234 head = &hd->target_reset_list; 1235 if (list_empty(head)) 1236 return 1; 1237 1238 target_reset_list = list_entry(head->next, struct mptsas_target_reset_event, 1239 list); 1240 1241 id = target_reset_list->sas_event_data.TargetID; 1242 channel = target_reset_list->sas_event_data.Bus; 1243 target_reset_list->time_count = jiffies; 1244 1245 if (mptsas_target_reset(ioc, channel, id)) 1246 target_reset_list->target_reset_issued = 1; 1247 1248 return 1; 1249 } 1250 1251 /** 1252 * mptscsih_ioc_reset 1253 * 1254 * @ioc 1255 * @reset_phase 1256 * 1257 **/ 1258 static int 1259 mptsas_ioc_reset(MPT_ADAPTER *ioc, int reset_phase) 1260 { 1261 MPT_SCSI_HOST *hd; 1262 int rc; 1263 1264 rc = mptscsih_ioc_reset(ioc, reset_phase); 1265 if ((ioc->bus_type != SAS) || (!rc)) 1266 return rc; 1267 1268 hd = shost_priv(ioc->sh); 1269 if (!hd->ioc) 1270 goto out; 1271 1272 switch (reset_phase) { 1273 case MPT_IOC_SETUP_RESET: 1274 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1275 "%s: MPT_IOC_SETUP_RESET\n", ioc->name, __func__)); 1276 mptsas_fw_event_off(ioc); 1277 break; 1278 case MPT_IOC_PRE_RESET: 1279 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1280 "%s: MPT_IOC_PRE_RESET\n", ioc->name, __func__)); 1281 break; 1282 case MPT_IOC_POST_RESET: 1283 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1284 "%s: MPT_IOC_POST_RESET\n", ioc->name, __func__)); 1285 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) { 1286 ioc->sas_mgmt.status |= MPT_MGMT_STATUS_DID_IOCRESET; 1287 complete(&ioc->sas_mgmt.done); 1288 } 1289 mptsas_cleanup_fw_event_q(ioc); 1290 mptsas_queue_rescan(ioc); 1291 break; 1292 default: 1293 break; 1294 } 1295 1296 out: 1297 return rc; 1298 } 1299 1300 1301 /** 1302 * enum device_state - 1303 * @DEVICE_RETRY: need to retry the TUR 1304 * @DEVICE_ERROR: TUR return error, don't add device 1305 * @DEVICE_READY: device can be added 1306 * 1307 */ 1308 enum device_state{ 1309 DEVICE_RETRY, 1310 DEVICE_ERROR, 1311 DEVICE_READY, 1312 }; 1313 1314 static int 1315 mptsas_sas_enclosure_pg0(MPT_ADAPTER *ioc, struct mptsas_enclosure *enclosure, 1316 u32 form, u32 form_specific) 1317 { 1318 ConfigExtendedPageHeader_t hdr; 1319 CONFIGPARMS cfg; 1320 SasEnclosurePage0_t *buffer; 1321 dma_addr_t dma_handle; 1322 int error; 1323 __le64 le_identifier; 1324 1325 memset(&hdr, 0, sizeof(hdr)); 1326 hdr.PageVersion = MPI_SASENCLOSURE0_PAGEVERSION; 1327 hdr.PageNumber = 0; 1328 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 1329 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_ENCLOSURE; 1330 1331 cfg.cfghdr.ehdr = &hdr; 1332 cfg.physAddr = -1; 1333 cfg.pageAddr = form + form_specific; 1334 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 1335 cfg.dir = 0; /* read */ 1336 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 1337 1338 error = mpt_config(ioc, &cfg); 1339 if (error) 1340 goto out; 1341 if (!hdr.ExtPageLength) { 1342 error = -ENXIO; 1343 goto out; 1344 } 1345 1346 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1347 &dma_handle); 1348 if (!buffer) { 1349 error = -ENOMEM; 1350 goto out; 1351 } 1352 1353 cfg.physAddr = dma_handle; 1354 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 1355 1356 error = mpt_config(ioc, &cfg); 1357 if (error) 1358 goto out_free_consistent; 1359 1360 /* save config data */ 1361 memcpy(&le_identifier, &buffer->EnclosureLogicalID, sizeof(__le64)); 1362 enclosure->enclosure_logical_id = le64_to_cpu(le_identifier); 1363 enclosure->enclosure_handle = le16_to_cpu(buffer->EnclosureHandle); 1364 enclosure->flags = le16_to_cpu(buffer->Flags); 1365 enclosure->num_slot = le16_to_cpu(buffer->NumSlots); 1366 enclosure->start_slot = le16_to_cpu(buffer->StartSlot); 1367 enclosure->start_id = buffer->StartTargetID; 1368 enclosure->start_channel = buffer->StartBus; 1369 enclosure->sep_id = buffer->SEPTargetID; 1370 enclosure->sep_channel = buffer->SEPBus; 1371 1372 out_free_consistent: 1373 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1374 buffer, dma_handle); 1375 out: 1376 return error; 1377 } 1378 1379 /** 1380 * mptsas_add_end_device - report a new end device to sas transport layer 1381 * @ioc: Pointer to MPT_ADAPTER structure 1382 * @phy_info: decribes attached device 1383 * 1384 * return (0) success (1) failure 1385 * 1386 **/ 1387 static int 1388 mptsas_add_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info) 1389 { 1390 struct sas_rphy *rphy; 1391 struct sas_port *port; 1392 struct sas_identify identify; 1393 char *ds = NULL; 1394 u8 fw_id; 1395 1396 if (!phy_info) { 1397 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 1398 "%s: exit at line=%d\n", ioc->name, 1399 __func__, __LINE__)); 1400 return 1; 1401 } 1402 1403 fw_id = phy_info->attached.id; 1404 1405 if (mptsas_get_rphy(phy_info)) { 1406 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 1407 "%s: fw_id=%d exit at line=%d\n", ioc->name, 1408 __func__, fw_id, __LINE__)); 1409 return 2; 1410 } 1411 1412 port = mptsas_get_port(phy_info); 1413 if (!port) { 1414 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 1415 "%s: fw_id=%d exit at line=%d\n", ioc->name, 1416 __func__, fw_id, __LINE__)); 1417 return 3; 1418 } 1419 1420 if (phy_info->attached.device_info & 1421 MPI_SAS_DEVICE_INFO_SSP_TARGET) 1422 ds = "ssp"; 1423 if (phy_info->attached.device_info & 1424 MPI_SAS_DEVICE_INFO_STP_TARGET) 1425 ds = "stp"; 1426 if (phy_info->attached.device_info & 1427 MPI_SAS_DEVICE_INFO_SATA_DEVICE) 1428 ds = "sata"; 1429 1430 printk(MYIOC_s_INFO_FMT "attaching %s device: fw_channel %d, fw_id %d," 1431 " phy %d, sas_addr 0x%llx\n", ioc->name, ds, 1432 phy_info->attached.channel, phy_info->attached.id, 1433 phy_info->attached.phy_id, (unsigned long long) 1434 phy_info->attached.sas_address); 1435 1436 mptsas_parse_device_info(&identify, &phy_info->attached); 1437 rphy = sas_end_device_alloc(port); 1438 if (!rphy) { 1439 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 1440 "%s: fw_id=%d exit at line=%d\n", ioc->name, 1441 __func__, fw_id, __LINE__)); 1442 return 5; /* non-fatal: an rphy can be added later */ 1443 } 1444 1445 rphy->identify = identify; 1446 if (sas_rphy_add(rphy)) { 1447 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 1448 "%s: fw_id=%d exit at line=%d\n", ioc->name, 1449 __func__, fw_id, __LINE__)); 1450 sas_rphy_free(rphy); 1451 return 6; 1452 } 1453 mptsas_set_rphy(ioc, phy_info, rphy); 1454 return 0; 1455 } 1456 1457 /** 1458 * mptsas_del_end_device - report a deleted end device to sas transport layer 1459 * @ioc: Pointer to MPT_ADAPTER structure 1460 * @phy_info: decribes attached device 1461 * 1462 **/ 1463 static void 1464 mptsas_del_end_device(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info) 1465 { 1466 struct sas_rphy *rphy; 1467 struct sas_port *port; 1468 struct mptsas_portinfo *port_info; 1469 struct mptsas_phyinfo *phy_info_parent; 1470 int i; 1471 char *ds = NULL; 1472 u8 fw_id; 1473 u64 sas_address; 1474 1475 if (!phy_info) 1476 return; 1477 1478 fw_id = phy_info->attached.id; 1479 sas_address = phy_info->attached.sas_address; 1480 1481 if (!phy_info->port_details) { 1482 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 1483 "%s: fw_id=%d exit at line=%d\n", ioc->name, 1484 __func__, fw_id, __LINE__)); 1485 return; 1486 } 1487 rphy = mptsas_get_rphy(phy_info); 1488 if (!rphy) { 1489 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 1490 "%s: fw_id=%d exit at line=%d\n", ioc->name, 1491 __func__, fw_id, __LINE__)); 1492 return; 1493 } 1494 1495 if (phy_info->attached.device_info & MPI_SAS_DEVICE_INFO_SSP_INITIATOR 1496 || phy_info->attached.device_info 1497 & MPI_SAS_DEVICE_INFO_SMP_INITIATOR 1498 || phy_info->attached.device_info 1499 & MPI_SAS_DEVICE_INFO_STP_INITIATOR) 1500 ds = "initiator"; 1501 if (phy_info->attached.device_info & 1502 MPI_SAS_DEVICE_INFO_SSP_TARGET) 1503 ds = "ssp"; 1504 if (phy_info->attached.device_info & 1505 MPI_SAS_DEVICE_INFO_STP_TARGET) 1506 ds = "stp"; 1507 if (phy_info->attached.device_info & 1508 MPI_SAS_DEVICE_INFO_SATA_DEVICE) 1509 ds = "sata"; 1510 1511 dev_printk(KERN_DEBUG, &rphy->dev, MYIOC_s_FMT 1512 "removing %s device: fw_channel %d, fw_id %d, phy %d," 1513 "sas_addr 0x%llx\n", ioc->name, ds, phy_info->attached.channel, 1514 phy_info->attached.id, phy_info->attached.phy_id, 1515 (unsigned long long) sas_address); 1516 1517 port = mptsas_get_port(phy_info); 1518 if (!port) { 1519 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 1520 "%s: fw_id=%d exit at line=%d\n", ioc->name, 1521 __func__, fw_id, __LINE__)); 1522 return; 1523 } 1524 port_info = phy_info->portinfo; 1525 phy_info_parent = port_info->phy_info; 1526 for (i = 0; i < port_info->num_phys; i++, phy_info_parent++) { 1527 if (!phy_info_parent->phy) 1528 continue; 1529 if (phy_info_parent->attached.sas_address != 1530 sas_address) 1531 continue; 1532 dev_printk(KERN_DEBUG, &phy_info_parent->phy->dev, 1533 MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", 1534 ioc->name, phy_info_parent->phy_id, 1535 phy_info_parent->phy); 1536 sas_port_delete_phy(port, phy_info_parent->phy); 1537 } 1538 1539 dev_printk(KERN_DEBUG, &port->dev, MYIOC_s_FMT 1540 "delete port %d, sas_addr (0x%llx)\n", ioc->name, 1541 port->port_identifier, (unsigned long long)sas_address); 1542 sas_port_delete(port); 1543 mptsas_set_port(ioc, phy_info, NULL); 1544 mptsas_port_delete(ioc, phy_info->port_details); 1545 } 1546 1547 struct mptsas_phyinfo * 1548 mptsas_refreshing_device_handles(MPT_ADAPTER *ioc, 1549 struct mptsas_devinfo *sas_device) 1550 { 1551 struct mptsas_phyinfo *phy_info; 1552 struct mptsas_portinfo *port_info; 1553 int i; 1554 1555 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 1556 sas_device->sas_address); 1557 if (!phy_info) 1558 goto out; 1559 port_info = phy_info->portinfo; 1560 if (!port_info) 1561 goto out; 1562 mutex_lock(&ioc->sas_topology_mutex); 1563 for (i = 0; i < port_info->num_phys; i++) { 1564 if (port_info->phy_info[i].attached.sas_address != 1565 sas_device->sas_address) 1566 continue; 1567 port_info->phy_info[i].attached.channel = sas_device->channel; 1568 port_info->phy_info[i].attached.id = sas_device->id; 1569 port_info->phy_info[i].attached.sas_address = 1570 sas_device->sas_address; 1571 port_info->phy_info[i].attached.handle = sas_device->handle; 1572 port_info->phy_info[i].attached.handle_parent = 1573 sas_device->handle_parent; 1574 port_info->phy_info[i].attached.handle_enclosure = 1575 sas_device->handle_enclosure; 1576 } 1577 mutex_unlock(&ioc->sas_topology_mutex); 1578 out: 1579 return phy_info; 1580 } 1581 1582 /** 1583 * mptsas_firmware_event_work - work thread for processing fw events 1584 * @work: work queue payload containing info describing the event 1585 * Context: user 1586 * 1587 */ 1588 static void 1589 mptsas_firmware_event_work(struct work_struct *work) 1590 { 1591 struct fw_event_work *fw_event = 1592 container_of(work, struct fw_event_work, work.work); 1593 MPT_ADAPTER *ioc = fw_event->ioc; 1594 1595 /* special rescan topology handling */ 1596 if (fw_event->event == -1) { 1597 if (ioc->in_rescan) { 1598 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 1599 "%s: rescan ignored as it is in progress\n", 1600 ioc->name, __func__)); 1601 return; 1602 } 1603 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: rescan after " 1604 "reset\n", ioc->name, __func__)); 1605 ioc->in_rescan = 1; 1606 mptsas_not_responding_devices(ioc); 1607 mptsas_scan_sas_topology(ioc); 1608 ioc->in_rescan = 0; 1609 mptsas_free_fw_event(ioc, fw_event); 1610 mptsas_fw_event_on(ioc); 1611 return; 1612 } 1613 1614 /* events handling turned off during host reset */ 1615 if (ioc->fw_events_off) { 1616 mptsas_free_fw_event(ioc, fw_event); 1617 return; 1618 } 1619 1620 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "%s: fw_event=(0x%p), " 1621 "event = (0x%02x)\n", ioc->name, __func__, fw_event, 1622 (fw_event->event & 0xFF))); 1623 1624 switch (fw_event->event) { 1625 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE: 1626 mptsas_send_sas_event(fw_event); 1627 break; 1628 case MPI_EVENT_INTEGRATED_RAID: 1629 mptsas_send_raid_event(fw_event); 1630 break; 1631 case MPI_EVENT_IR2: 1632 mptsas_send_ir2_event(fw_event); 1633 break; 1634 case MPI_EVENT_PERSISTENT_TABLE_FULL: 1635 mptbase_sas_persist_operation(ioc, 1636 MPI_SAS_OP_CLEAR_NOT_PRESENT); 1637 mptsas_free_fw_event(ioc, fw_event); 1638 break; 1639 case MPI_EVENT_SAS_BROADCAST_PRIMITIVE: 1640 mptsas_broadcast_primative_work(fw_event); 1641 break; 1642 case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE: 1643 mptsas_send_expander_event(fw_event); 1644 break; 1645 case MPI_EVENT_SAS_PHY_LINK_STATUS: 1646 mptsas_send_link_status_event(fw_event); 1647 break; 1648 case MPI_EVENT_QUEUE_FULL: 1649 mptsas_handle_queue_full_event(fw_event); 1650 break; 1651 } 1652 } 1653 1654 1655 1656 static int 1657 mptsas_slave_configure(struct scsi_device *sdev) 1658 { 1659 struct Scsi_Host *host = sdev->host; 1660 MPT_SCSI_HOST *hd = shost_priv(host); 1661 MPT_ADAPTER *ioc = hd->ioc; 1662 VirtDevice *vdevice = sdev->hostdata; 1663 1664 if (vdevice->vtarget->deleted) { 1665 sdev_printk(KERN_INFO, sdev, "clearing deleted flag\n"); 1666 vdevice->vtarget->deleted = 0; 1667 } 1668 1669 /* 1670 * RAID volumes placed beyond the last expected port. 1671 * Ignore sending sas mode pages in that case.. 1672 */ 1673 if (sdev->channel == MPTSAS_RAID_CHANNEL) { 1674 mptsas_add_device_component_starget_ir(ioc, scsi_target(sdev)); 1675 goto out; 1676 } 1677 1678 sas_read_port_mode_page(sdev); 1679 1680 mptsas_add_device_component_starget(ioc, scsi_target(sdev)); 1681 1682 out: 1683 return mptscsih_slave_configure(sdev); 1684 } 1685 1686 static int 1687 mptsas_target_alloc(struct scsi_target *starget) 1688 { 1689 struct Scsi_Host *host = dev_to_shost(&starget->dev); 1690 MPT_SCSI_HOST *hd = shost_priv(host); 1691 VirtTarget *vtarget; 1692 u8 id, channel; 1693 struct sas_rphy *rphy; 1694 struct mptsas_portinfo *p; 1695 int i; 1696 MPT_ADAPTER *ioc = hd->ioc; 1697 1698 vtarget = kzalloc(sizeof(VirtTarget), GFP_KERNEL); 1699 if (!vtarget) 1700 return -ENOMEM; 1701 1702 vtarget->starget = starget; 1703 vtarget->ioc_id = ioc->id; 1704 vtarget->tflags = MPT_TARGET_FLAGS_Q_YES; 1705 id = starget->id; 1706 channel = 0; 1707 1708 /* 1709 * RAID volumes placed beyond the last expected port. 1710 */ 1711 if (starget->channel == MPTSAS_RAID_CHANNEL) { 1712 if (!ioc->raid_data.pIocPg2) { 1713 kfree(vtarget); 1714 return -ENXIO; 1715 } 1716 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) { 1717 if (id == ioc->raid_data.pIocPg2-> 1718 RaidVolume[i].VolumeID) { 1719 channel = ioc->raid_data.pIocPg2-> 1720 RaidVolume[i].VolumeBus; 1721 } 1722 } 1723 vtarget->raidVolume = 1; 1724 goto out; 1725 } 1726 1727 rphy = dev_to_rphy(starget->dev.parent); 1728 mutex_lock(&ioc->sas_topology_mutex); 1729 list_for_each_entry(p, &ioc->sas_topology, list) { 1730 for (i = 0; i < p->num_phys; i++) { 1731 if (p->phy_info[i].attached.sas_address != 1732 rphy->identify.sas_address) 1733 continue; 1734 id = p->phy_info[i].attached.id; 1735 channel = p->phy_info[i].attached.channel; 1736 mptsas_set_starget(&p->phy_info[i], starget); 1737 1738 /* 1739 * Exposing hidden raid components 1740 */ 1741 if (mptscsih_is_phys_disk(ioc, channel, id)) { 1742 id = mptscsih_raid_id_to_num(ioc, 1743 channel, id); 1744 vtarget->tflags |= 1745 MPT_TARGET_FLAGS_RAID_COMPONENT; 1746 p->phy_info[i].attached.phys_disk_num = id; 1747 } 1748 mutex_unlock(&ioc->sas_topology_mutex); 1749 goto out; 1750 } 1751 } 1752 mutex_unlock(&ioc->sas_topology_mutex); 1753 1754 kfree(vtarget); 1755 return -ENXIO; 1756 1757 out: 1758 vtarget->id = id; 1759 vtarget->channel = channel; 1760 starget->hostdata = vtarget; 1761 return 0; 1762 } 1763 1764 static void 1765 mptsas_target_destroy(struct scsi_target *starget) 1766 { 1767 struct Scsi_Host *host = dev_to_shost(&starget->dev); 1768 MPT_SCSI_HOST *hd = shost_priv(host); 1769 struct sas_rphy *rphy; 1770 struct mptsas_portinfo *p; 1771 int i; 1772 MPT_ADAPTER *ioc = hd->ioc; 1773 VirtTarget *vtarget; 1774 1775 if (!starget->hostdata) 1776 return; 1777 1778 vtarget = starget->hostdata; 1779 1780 mptsas_del_device_component_by_os(ioc, starget->channel, 1781 starget->id); 1782 1783 1784 if (starget->channel == MPTSAS_RAID_CHANNEL) 1785 goto out; 1786 1787 rphy = dev_to_rphy(starget->dev.parent); 1788 list_for_each_entry(p, &ioc->sas_topology, list) { 1789 for (i = 0; i < p->num_phys; i++) { 1790 if (p->phy_info[i].attached.sas_address != 1791 rphy->identify.sas_address) 1792 continue; 1793 1794 starget_printk(KERN_INFO, starget, MYIOC_s_FMT 1795 "delete device: fw_channel %d, fw_id %d, phy %d, " 1796 "sas_addr 0x%llx\n", ioc->name, 1797 p->phy_info[i].attached.channel, 1798 p->phy_info[i].attached.id, 1799 p->phy_info[i].attached.phy_id, (unsigned long long) 1800 p->phy_info[i].attached.sas_address); 1801 1802 mptsas_set_starget(&p->phy_info[i], NULL); 1803 } 1804 } 1805 1806 out: 1807 vtarget->starget = NULL; 1808 kfree(starget->hostdata); 1809 starget->hostdata = NULL; 1810 } 1811 1812 1813 static int 1814 mptsas_slave_alloc(struct scsi_device *sdev) 1815 { 1816 struct Scsi_Host *host = sdev->host; 1817 MPT_SCSI_HOST *hd = shost_priv(host); 1818 struct sas_rphy *rphy; 1819 struct mptsas_portinfo *p; 1820 VirtDevice *vdevice; 1821 struct scsi_target *starget; 1822 int i; 1823 MPT_ADAPTER *ioc = hd->ioc; 1824 1825 vdevice = kzalloc(sizeof(VirtDevice), GFP_KERNEL); 1826 if (!vdevice) { 1827 printk(MYIOC_s_ERR_FMT "slave_alloc kzalloc(%zd) FAILED!\n", 1828 ioc->name, sizeof(VirtDevice)); 1829 return -ENOMEM; 1830 } 1831 starget = scsi_target(sdev); 1832 vdevice->vtarget = starget->hostdata; 1833 1834 if (sdev->channel == MPTSAS_RAID_CHANNEL) 1835 goto out; 1836 1837 rphy = dev_to_rphy(sdev->sdev_target->dev.parent); 1838 mutex_lock(&ioc->sas_topology_mutex); 1839 list_for_each_entry(p, &ioc->sas_topology, list) { 1840 for (i = 0; i < p->num_phys; i++) { 1841 if (p->phy_info[i].attached.sas_address != 1842 rphy->identify.sas_address) 1843 continue; 1844 vdevice->lun = sdev->lun; 1845 /* 1846 * Exposing hidden raid components 1847 */ 1848 if (mptscsih_is_phys_disk(ioc, 1849 p->phy_info[i].attached.channel, 1850 p->phy_info[i].attached.id)) 1851 sdev->no_uld_attach = 1; 1852 mutex_unlock(&ioc->sas_topology_mutex); 1853 goto out; 1854 } 1855 } 1856 mutex_unlock(&ioc->sas_topology_mutex); 1857 1858 kfree(vdevice); 1859 return -ENXIO; 1860 1861 out: 1862 vdevice->vtarget->num_luns++; 1863 sdev->hostdata = vdevice; 1864 return 0; 1865 } 1866 1867 static int 1868 mptsas_qcmd(struct scsi_cmnd *SCpnt, void (*done)(struct scsi_cmnd *)) 1869 { 1870 MPT_SCSI_HOST *hd; 1871 MPT_ADAPTER *ioc; 1872 VirtDevice *vdevice = SCpnt->device->hostdata; 1873 1874 if (!vdevice || !vdevice->vtarget || vdevice->vtarget->deleted) { 1875 SCpnt->result = DID_NO_CONNECT << 16; 1876 done(SCpnt); 1877 return 0; 1878 } 1879 1880 hd = shost_priv(SCpnt->device->host); 1881 ioc = hd->ioc; 1882 1883 if (ioc->sas_discovery_quiesce_io) 1884 return SCSI_MLQUEUE_HOST_BUSY; 1885 1886 if (ioc->debug_level & MPT_DEBUG_SCSI) 1887 scsi_print_command(SCpnt); 1888 1889 return mptscsih_qcmd(SCpnt,done); 1890 } 1891 1892 1893 static struct scsi_host_template mptsas_driver_template = { 1894 .module = THIS_MODULE, 1895 .proc_name = "mptsas", 1896 .proc_info = mptscsih_proc_info, 1897 .name = "MPT SPI Host", 1898 .info = mptscsih_info, 1899 .queuecommand = mptsas_qcmd, 1900 .target_alloc = mptsas_target_alloc, 1901 .slave_alloc = mptsas_slave_alloc, 1902 .slave_configure = mptsas_slave_configure, 1903 .target_destroy = mptsas_target_destroy, 1904 .slave_destroy = mptscsih_slave_destroy, 1905 .change_queue_depth = mptscsih_change_queue_depth, 1906 .eh_abort_handler = mptscsih_abort, 1907 .eh_device_reset_handler = mptscsih_dev_reset, 1908 .eh_bus_reset_handler = mptscsih_bus_reset, 1909 .eh_host_reset_handler = mptscsih_host_reset, 1910 .bios_param = mptscsih_bios_param, 1911 .can_queue = MPT_SAS_CAN_QUEUE, 1912 .this_id = -1, 1913 .sg_tablesize = MPT_SCSI_SG_DEPTH, 1914 .max_sectors = 8192, 1915 .cmd_per_lun = 7, 1916 .use_clustering = ENABLE_CLUSTERING, 1917 .shost_attrs = mptscsih_host_attrs, 1918 }; 1919 1920 static int mptsas_get_linkerrors(struct sas_phy *phy) 1921 { 1922 MPT_ADAPTER *ioc = phy_to_ioc(phy); 1923 ConfigExtendedPageHeader_t hdr; 1924 CONFIGPARMS cfg; 1925 SasPhyPage1_t *buffer; 1926 dma_addr_t dma_handle; 1927 int error; 1928 1929 /* FIXME: only have link errors on local phys */ 1930 if (!scsi_is_sas_phy_local(phy)) 1931 return -EINVAL; 1932 1933 hdr.PageVersion = MPI_SASPHY1_PAGEVERSION; 1934 hdr.ExtPageLength = 0; 1935 hdr.PageNumber = 1 /* page number 1*/; 1936 hdr.Reserved1 = 0; 1937 hdr.Reserved2 = 0; 1938 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 1939 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY; 1940 1941 cfg.cfghdr.ehdr = &hdr; 1942 cfg.physAddr = -1; 1943 cfg.pageAddr = phy->identify.phy_identifier; 1944 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 1945 cfg.dir = 0; /* read */ 1946 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 1947 1948 error = mpt_config(ioc, &cfg); 1949 if (error) 1950 return error; 1951 if (!hdr.ExtPageLength) 1952 return -ENXIO; 1953 1954 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1955 &dma_handle); 1956 if (!buffer) 1957 return -ENOMEM; 1958 1959 cfg.physAddr = dma_handle; 1960 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 1961 1962 error = mpt_config(ioc, &cfg); 1963 if (error) 1964 goto out_free_consistent; 1965 1966 mptsas_print_phy_pg1(ioc, buffer); 1967 1968 phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount); 1969 phy->running_disparity_error_count = 1970 le32_to_cpu(buffer->RunningDisparityErrorCount); 1971 phy->loss_of_dword_sync_count = 1972 le32_to_cpu(buffer->LossDwordSynchCount); 1973 phy->phy_reset_problem_count = 1974 le32_to_cpu(buffer->PhyResetProblemCount); 1975 1976 out_free_consistent: 1977 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 1978 buffer, dma_handle); 1979 return error; 1980 } 1981 1982 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, 1983 MPT_FRAME_HDR *reply) 1984 { 1985 ioc->sas_mgmt.status |= MPT_MGMT_STATUS_COMMAND_GOOD; 1986 if (reply != NULL) { 1987 ioc->sas_mgmt.status |= MPT_MGMT_STATUS_RF_VALID; 1988 memcpy(ioc->sas_mgmt.reply, reply, 1989 min(ioc->reply_sz, 4 * reply->u.reply.MsgLength)); 1990 } 1991 1992 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) { 1993 ioc->sas_mgmt.status &= ~MPT_MGMT_STATUS_PENDING; 1994 complete(&ioc->sas_mgmt.done); 1995 return 1; 1996 } 1997 return 0; 1998 } 1999 2000 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset) 2001 { 2002 MPT_ADAPTER *ioc = phy_to_ioc(phy); 2003 SasIoUnitControlRequest_t *req; 2004 SasIoUnitControlReply_t *reply; 2005 MPT_FRAME_HDR *mf; 2006 MPIHeader_t *hdr; 2007 unsigned long timeleft; 2008 int error = -ERESTARTSYS; 2009 2010 /* FIXME: fusion doesn't allow non-local phy reset */ 2011 if (!scsi_is_sas_phy_local(phy)) 2012 return -EINVAL; 2013 2014 /* not implemented for expanders */ 2015 if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP) 2016 return -ENXIO; 2017 2018 if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex)) 2019 goto out; 2020 2021 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc); 2022 if (!mf) { 2023 error = -ENOMEM; 2024 goto out_unlock; 2025 } 2026 2027 hdr = (MPIHeader_t *) mf; 2028 req = (SasIoUnitControlRequest_t *)mf; 2029 memset(req, 0, sizeof(SasIoUnitControlRequest_t)); 2030 req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL; 2031 req->MsgContext = hdr->MsgContext; 2032 req->Operation = hard_reset ? 2033 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET; 2034 req->PhyNum = phy->identify.phy_identifier; 2035 2036 INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status) 2037 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf); 2038 2039 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 2040 10 * HZ); 2041 if (!timeleft) { 2042 /* On timeout reset the board */ 2043 mpt_free_msg_frame(ioc, mf); 2044 mpt_HardResetHandler(ioc, CAN_SLEEP); 2045 error = -ETIMEDOUT; 2046 goto out_unlock; 2047 } 2048 2049 /* a reply frame is expected */ 2050 if ((ioc->sas_mgmt.status & 2051 MPT_MGMT_STATUS_RF_VALID) == 0) { 2052 error = -ENXIO; 2053 goto out_unlock; 2054 } 2055 2056 /* process the completed Reply Message Frame */ 2057 reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply; 2058 if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) { 2059 printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n", 2060 ioc->name, __func__, reply->IOCStatus, reply->IOCLogInfo); 2061 error = -ENXIO; 2062 goto out_unlock; 2063 } 2064 2065 error = 0; 2066 2067 out_unlock: 2068 CLEAR_MGMT_STATUS(ioc->sas_mgmt.status) 2069 mutex_unlock(&ioc->sas_mgmt.mutex); 2070 out: 2071 return error; 2072 } 2073 2074 static int 2075 mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier) 2076 { 2077 MPT_ADAPTER *ioc = rphy_to_ioc(rphy); 2078 int i, error; 2079 struct mptsas_portinfo *p; 2080 struct mptsas_enclosure enclosure_info; 2081 u64 enclosure_handle; 2082 2083 mutex_lock(&ioc->sas_topology_mutex); 2084 list_for_each_entry(p, &ioc->sas_topology, list) { 2085 for (i = 0; i < p->num_phys; i++) { 2086 if (p->phy_info[i].attached.sas_address == 2087 rphy->identify.sas_address) { 2088 enclosure_handle = p->phy_info[i]. 2089 attached.handle_enclosure; 2090 goto found_info; 2091 } 2092 } 2093 } 2094 mutex_unlock(&ioc->sas_topology_mutex); 2095 return -ENXIO; 2096 2097 found_info: 2098 mutex_unlock(&ioc->sas_topology_mutex); 2099 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure)); 2100 error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info, 2101 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE << 2102 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle); 2103 if (!error) 2104 *identifier = enclosure_info.enclosure_logical_id; 2105 return error; 2106 } 2107 2108 static int 2109 mptsas_get_bay_identifier(struct sas_rphy *rphy) 2110 { 2111 MPT_ADAPTER *ioc = rphy_to_ioc(rphy); 2112 struct mptsas_portinfo *p; 2113 int i, rc; 2114 2115 mutex_lock(&ioc->sas_topology_mutex); 2116 list_for_each_entry(p, &ioc->sas_topology, list) { 2117 for (i = 0; i < p->num_phys; i++) { 2118 if (p->phy_info[i].attached.sas_address == 2119 rphy->identify.sas_address) { 2120 rc = p->phy_info[i].attached.slot; 2121 goto out; 2122 } 2123 } 2124 } 2125 rc = -ENXIO; 2126 out: 2127 mutex_unlock(&ioc->sas_topology_mutex); 2128 return rc; 2129 } 2130 2131 static int mptsas_smp_handler(struct Scsi_Host *shost, struct sas_rphy *rphy, 2132 struct request *req) 2133 { 2134 MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc; 2135 MPT_FRAME_HDR *mf; 2136 SmpPassthroughRequest_t *smpreq; 2137 struct request *rsp = req->next_rq; 2138 int ret; 2139 int flagsLength; 2140 unsigned long timeleft; 2141 char *psge; 2142 dma_addr_t dma_addr_in = 0; 2143 dma_addr_t dma_addr_out = 0; 2144 u64 sas_address = 0; 2145 2146 if (!rsp) { 2147 printk(MYIOC_s_ERR_FMT "%s: the smp response space is missing\n", 2148 ioc->name, __func__); 2149 return -EINVAL; 2150 } 2151 2152 /* do we need to support multiple segments? */ 2153 if (req->bio->bi_vcnt > 1 || rsp->bio->bi_vcnt > 1) { 2154 printk(MYIOC_s_ERR_FMT "%s: multiple segments req %u %u, rsp %u %u\n", 2155 ioc->name, __func__, req->bio->bi_vcnt, blk_rq_bytes(req), 2156 rsp->bio->bi_vcnt, blk_rq_bytes(rsp)); 2157 return -EINVAL; 2158 } 2159 2160 ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex); 2161 if (ret) 2162 goto out; 2163 2164 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc); 2165 if (!mf) { 2166 ret = -ENOMEM; 2167 goto out_unlock; 2168 } 2169 2170 smpreq = (SmpPassthroughRequest_t *)mf; 2171 memset(smpreq, 0, sizeof(*smpreq)); 2172 2173 smpreq->RequestDataLength = cpu_to_le16(blk_rq_bytes(req) - 4); 2174 smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH; 2175 2176 if (rphy) 2177 sas_address = rphy->identify.sas_address; 2178 else { 2179 struct mptsas_portinfo *port_info; 2180 2181 mutex_lock(&ioc->sas_topology_mutex); 2182 port_info = ioc->hba_port_info; 2183 if (port_info && port_info->phy_info) 2184 sas_address = 2185 port_info->phy_info[0].phy->identify.sas_address; 2186 mutex_unlock(&ioc->sas_topology_mutex); 2187 } 2188 2189 *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address); 2190 2191 psge = (char *) 2192 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4)); 2193 2194 /* request */ 2195 flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT | 2196 MPI_SGE_FLAGS_END_OF_BUFFER | 2197 MPI_SGE_FLAGS_DIRECTION) 2198 << MPI_SGE_FLAGS_SHIFT; 2199 flagsLength |= (blk_rq_bytes(req) - 4); 2200 2201 dma_addr_out = pci_map_single(ioc->pcidev, bio_data(req->bio), 2202 blk_rq_bytes(req), PCI_DMA_BIDIRECTIONAL); 2203 if (!dma_addr_out) 2204 goto put_mf; 2205 ioc->add_sge(psge, flagsLength, dma_addr_out); 2206 psge += ioc->SGE_size; 2207 2208 /* response */ 2209 flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT | 2210 MPI_SGE_FLAGS_SYSTEM_ADDRESS | 2211 MPI_SGE_FLAGS_IOC_TO_HOST | 2212 MPI_SGE_FLAGS_END_OF_BUFFER; 2213 2214 flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT; 2215 flagsLength |= blk_rq_bytes(rsp) + 4; 2216 dma_addr_in = pci_map_single(ioc->pcidev, bio_data(rsp->bio), 2217 blk_rq_bytes(rsp), PCI_DMA_BIDIRECTIONAL); 2218 if (!dma_addr_in) 2219 goto unmap; 2220 ioc->add_sge(psge, flagsLength, dma_addr_in); 2221 2222 INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status) 2223 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf); 2224 2225 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ); 2226 if (!timeleft) { 2227 printk(MYIOC_s_ERR_FMT "%s: smp timeout!\n", ioc->name, __func__); 2228 /* On timeout reset the board */ 2229 mpt_HardResetHandler(ioc, CAN_SLEEP); 2230 ret = -ETIMEDOUT; 2231 goto unmap; 2232 } 2233 mf = NULL; 2234 2235 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) { 2236 SmpPassthroughReply_t *smprep; 2237 2238 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply; 2239 memcpy(req->sense, smprep, sizeof(*smprep)); 2240 req->sense_len = sizeof(*smprep); 2241 req->resid_len = 0; 2242 rsp->resid_len -= smprep->ResponseDataLength; 2243 } else { 2244 printk(MYIOC_s_ERR_FMT 2245 "%s: smp passthru reply failed to be returned\n", 2246 ioc->name, __func__); 2247 ret = -ENXIO; 2248 } 2249 unmap: 2250 if (dma_addr_out) 2251 pci_unmap_single(ioc->pcidev, dma_addr_out, blk_rq_bytes(req), 2252 PCI_DMA_BIDIRECTIONAL); 2253 if (dma_addr_in) 2254 pci_unmap_single(ioc->pcidev, dma_addr_in, blk_rq_bytes(rsp), 2255 PCI_DMA_BIDIRECTIONAL); 2256 put_mf: 2257 if (mf) 2258 mpt_free_msg_frame(ioc, mf); 2259 out_unlock: 2260 CLEAR_MGMT_STATUS(ioc->sas_mgmt.status) 2261 mutex_unlock(&ioc->sas_mgmt.mutex); 2262 out: 2263 return ret; 2264 } 2265 2266 static struct sas_function_template mptsas_transport_functions = { 2267 .get_linkerrors = mptsas_get_linkerrors, 2268 .get_enclosure_identifier = mptsas_get_enclosure_identifier, 2269 .get_bay_identifier = mptsas_get_bay_identifier, 2270 .phy_reset = mptsas_phy_reset, 2271 .smp_handler = mptsas_smp_handler, 2272 }; 2273 2274 static struct scsi_transport_template *mptsas_transport_template; 2275 2276 static int 2277 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info) 2278 { 2279 ConfigExtendedPageHeader_t hdr; 2280 CONFIGPARMS cfg; 2281 SasIOUnitPage0_t *buffer; 2282 dma_addr_t dma_handle; 2283 int error, i; 2284 2285 hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION; 2286 hdr.ExtPageLength = 0; 2287 hdr.PageNumber = 0; 2288 hdr.Reserved1 = 0; 2289 hdr.Reserved2 = 0; 2290 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2291 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT; 2292 2293 cfg.cfghdr.ehdr = &hdr; 2294 cfg.physAddr = -1; 2295 cfg.pageAddr = 0; 2296 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2297 cfg.dir = 0; /* read */ 2298 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2299 2300 error = mpt_config(ioc, &cfg); 2301 if (error) 2302 goto out; 2303 if (!hdr.ExtPageLength) { 2304 error = -ENXIO; 2305 goto out; 2306 } 2307 2308 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2309 &dma_handle); 2310 if (!buffer) { 2311 error = -ENOMEM; 2312 goto out; 2313 } 2314 2315 cfg.physAddr = dma_handle; 2316 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2317 2318 error = mpt_config(ioc, &cfg); 2319 if (error) 2320 goto out_free_consistent; 2321 2322 port_info->num_phys = buffer->NumPhys; 2323 port_info->phy_info = kcalloc(port_info->num_phys, 2324 sizeof(struct mptsas_phyinfo), GFP_KERNEL); 2325 if (!port_info->phy_info) { 2326 error = -ENOMEM; 2327 goto out_free_consistent; 2328 } 2329 2330 ioc->nvdata_version_persistent = 2331 le16_to_cpu(buffer->NvdataVersionPersistent); 2332 ioc->nvdata_version_default = 2333 le16_to_cpu(buffer->NvdataVersionDefault); 2334 2335 for (i = 0; i < port_info->num_phys; i++) { 2336 mptsas_print_phy_data(ioc, &buffer->PhyData[i]); 2337 port_info->phy_info[i].phy_id = i; 2338 port_info->phy_info[i].port_id = 2339 buffer->PhyData[i].Port; 2340 port_info->phy_info[i].negotiated_link_rate = 2341 buffer->PhyData[i].NegotiatedLinkRate; 2342 port_info->phy_info[i].portinfo = port_info; 2343 port_info->phy_info[i].handle = 2344 le16_to_cpu(buffer->PhyData[i].ControllerDevHandle); 2345 } 2346 2347 out_free_consistent: 2348 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2349 buffer, dma_handle); 2350 out: 2351 return error; 2352 } 2353 2354 static int 2355 mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc) 2356 { 2357 ConfigExtendedPageHeader_t hdr; 2358 CONFIGPARMS cfg; 2359 SasIOUnitPage1_t *buffer; 2360 dma_addr_t dma_handle; 2361 int error; 2362 u16 device_missing_delay; 2363 2364 memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t)); 2365 memset(&cfg, 0, sizeof(CONFIGPARMS)); 2366 2367 cfg.cfghdr.ehdr = &hdr; 2368 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2369 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2370 cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2371 cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT; 2372 cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION; 2373 cfg.cfghdr.ehdr->PageNumber = 1; 2374 2375 error = mpt_config(ioc, &cfg); 2376 if (error) 2377 goto out; 2378 if (!hdr.ExtPageLength) { 2379 error = -ENXIO; 2380 goto out; 2381 } 2382 2383 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2384 &dma_handle); 2385 if (!buffer) { 2386 error = -ENOMEM; 2387 goto out; 2388 } 2389 2390 cfg.physAddr = dma_handle; 2391 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2392 2393 error = mpt_config(ioc, &cfg); 2394 if (error) 2395 goto out_free_consistent; 2396 2397 ioc->io_missing_delay = 2398 le16_to_cpu(buffer->IODeviceMissingDelay); 2399 device_missing_delay = le16_to_cpu(buffer->ReportDeviceMissingDelay); 2400 ioc->device_missing_delay = (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_UNIT_16) ? 2401 (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16 : 2402 device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK; 2403 2404 out_free_consistent: 2405 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2406 buffer, dma_handle); 2407 out: 2408 return error; 2409 } 2410 2411 static int 2412 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, 2413 u32 form, u32 form_specific) 2414 { 2415 ConfigExtendedPageHeader_t hdr; 2416 CONFIGPARMS cfg; 2417 SasPhyPage0_t *buffer; 2418 dma_addr_t dma_handle; 2419 int error; 2420 2421 hdr.PageVersion = MPI_SASPHY0_PAGEVERSION; 2422 hdr.ExtPageLength = 0; 2423 hdr.PageNumber = 0; 2424 hdr.Reserved1 = 0; 2425 hdr.Reserved2 = 0; 2426 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2427 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY; 2428 2429 cfg.cfghdr.ehdr = &hdr; 2430 cfg.dir = 0; /* read */ 2431 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2432 2433 /* Get Phy Pg 0 for each Phy. */ 2434 cfg.physAddr = -1; 2435 cfg.pageAddr = form + form_specific; 2436 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2437 2438 error = mpt_config(ioc, &cfg); 2439 if (error) 2440 goto out; 2441 2442 if (!hdr.ExtPageLength) { 2443 error = -ENXIO; 2444 goto out; 2445 } 2446 2447 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2448 &dma_handle); 2449 if (!buffer) { 2450 error = -ENOMEM; 2451 goto out; 2452 } 2453 2454 cfg.physAddr = dma_handle; 2455 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2456 2457 error = mpt_config(ioc, &cfg); 2458 if (error) 2459 goto out_free_consistent; 2460 2461 mptsas_print_phy_pg0(ioc, buffer); 2462 2463 phy_info->hw_link_rate = buffer->HwLinkRate; 2464 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate; 2465 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle); 2466 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle); 2467 2468 out_free_consistent: 2469 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2470 buffer, dma_handle); 2471 out: 2472 return error; 2473 } 2474 2475 static int 2476 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info, 2477 u32 form, u32 form_specific) 2478 { 2479 ConfigExtendedPageHeader_t hdr; 2480 CONFIGPARMS cfg; 2481 SasDevicePage0_t *buffer; 2482 dma_addr_t dma_handle; 2483 __le64 sas_address; 2484 int error=0; 2485 2486 hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION; 2487 hdr.ExtPageLength = 0; 2488 hdr.PageNumber = 0; 2489 hdr.Reserved1 = 0; 2490 hdr.Reserved2 = 0; 2491 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2492 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE; 2493 2494 cfg.cfghdr.ehdr = &hdr; 2495 cfg.pageAddr = form + form_specific; 2496 cfg.physAddr = -1; 2497 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2498 cfg.dir = 0; /* read */ 2499 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2500 2501 memset(device_info, 0, sizeof(struct mptsas_devinfo)); 2502 error = mpt_config(ioc, &cfg); 2503 if (error) 2504 goto out; 2505 if (!hdr.ExtPageLength) { 2506 error = -ENXIO; 2507 goto out; 2508 } 2509 2510 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2511 &dma_handle); 2512 if (!buffer) { 2513 error = -ENOMEM; 2514 goto out; 2515 } 2516 2517 cfg.physAddr = dma_handle; 2518 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2519 2520 error = mpt_config(ioc, &cfg); 2521 if (error) 2522 goto out_free_consistent; 2523 2524 mptsas_print_device_pg0(ioc, buffer); 2525 2526 memset(device_info, 0, sizeof(struct mptsas_devinfo)); 2527 device_info->handle = le16_to_cpu(buffer->DevHandle); 2528 device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle); 2529 device_info->handle_enclosure = 2530 le16_to_cpu(buffer->EnclosureHandle); 2531 device_info->slot = le16_to_cpu(buffer->Slot); 2532 device_info->phy_id = buffer->PhyNum; 2533 device_info->port_id = buffer->PhysicalPort; 2534 device_info->id = buffer->TargetID; 2535 device_info->phys_disk_num = ~0; 2536 device_info->channel = buffer->Bus; 2537 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64)); 2538 device_info->sas_address = le64_to_cpu(sas_address); 2539 device_info->device_info = 2540 le32_to_cpu(buffer->DeviceInfo); 2541 2542 out_free_consistent: 2543 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2544 buffer, dma_handle); 2545 out: 2546 return error; 2547 } 2548 2549 static int 2550 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info, 2551 u32 form, u32 form_specific) 2552 { 2553 ConfigExtendedPageHeader_t hdr; 2554 CONFIGPARMS cfg; 2555 SasExpanderPage0_t *buffer; 2556 dma_addr_t dma_handle; 2557 int i, error; 2558 __le64 sas_address; 2559 2560 memset(port_info, 0, sizeof(struct mptsas_portinfo)); 2561 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION; 2562 hdr.ExtPageLength = 0; 2563 hdr.PageNumber = 0; 2564 hdr.Reserved1 = 0; 2565 hdr.Reserved2 = 0; 2566 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2567 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER; 2568 2569 cfg.cfghdr.ehdr = &hdr; 2570 cfg.physAddr = -1; 2571 cfg.pageAddr = form + form_specific; 2572 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2573 cfg.dir = 0; /* read */ 2574 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2575 2576 memset(port_info, 0, sizeof(struct mptsas_portinfo)); 2577 error = mpt_config(ioc, &cfg); 2578 if (error) 2579 goto out; 2580 2581 if (!hdr.ExtPageLength) { 2582 error = -ENXIO; 2583 goto out; 2584 } 2585 2586 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2587 &dma_handle); 2588 if (!buffer) { 2589 error = -ENOMEM; 2590 goto out; 2591 } 2592 2593 cfg.physAddr = dma_handle; 2594 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2595 2596 error = mpt_config(ioc, &cfg); 2597 if (error) 2598 goto out_free_consistent; 2599 2600 if (!buffer->NumPhys) { 2601 error = -ENODEV; 2602 goto out_free_consistent; 2603 } 2604 2605 /* save config data */ 2606 port_info->num_phys = (buffer->NumPhys) ? buffer->NumPhys : 1; 2607 port_info->phy_info = kcalloc(port_info->num_phys, 2608 sizeof(struct mptsas_phyinfo), GFP_KERNEL); 2609 if (!port_info->phy_info) { 2610 error = -ENOMEM; 2611 goto out_free_consistent; 2612 } 2613 2614 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64)); 2615 for (i = 0; i < port_info->num_phys; i++) { 2616 port_info->phy_info[i].portinfo = port_info; 2617 port_info->phy_info[i].handle = 2618 le16_to_cpu(buffer->DevHandle); 2619 port_info->phy_info[i].identify.sas_address = 2620 le64_to_cpu(sas_address); 2621 port_info->phy_info[i].identify.handle_parent = 2622 le16_to_cpu(buffer->ParentDevHandle); 2623 } 2624 2625 out_free_consistent: 2626 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2627 buffer, dma_handle); 2628 out: 2629 return error; 2630 } 2631 2632 static int 2633 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, 2634 u32 form, u32 form_specific) 2635 { 2636 ConfigExtendedPageHeader_t hdr; 2637 CONFIGPARMS cfg; 2638 SasExpanderPage1_t *buffer; 2639 dma_addr_t dma_handle; 2640 int error=0; 2641 2642 hdr.PageVersion = MPI_SASEXPANDER1_PAGEVERSION; 2643 hdr.ExtPageLength = 0; 2644 hdr.PageNumber = 1; 2645 hdr.Reserved1 = 0; 2646 hdr.Reserved2 = 0; 2647 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2648 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER; 2649 2650 cfg.cfghdr.ehdr = &hdr; 2651 cfg.physAddr = -1; 2652 cfg.pageAddr = form + form_specific; 2653 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2654 cfg.dir = 0; /* read */ 2655 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2656 2657 error = mpt_config(ioc, &cfg); 2658 if (error) 2659 goto out; 2660 2661 if (!hdr.ExtPageLength) { 2662 error = -ENXIO; 2663 goto out; 2664 } 2665 2666 buffer = pci_alloc_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2667 &dma_handle); 2668 if (!buffer) { 2669 error = -ENOMEM; 2670 goto out; 2671 } 2672 2673 cfg.physAddr = dma_handle; 2674 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2675 2676 error = mpt_config(ioc, &cfg); 2677 2678 if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) { 2679 error = -ENODEV; 2680 goto out; 2681 } 2682 2683 if (error) 2684 goto out_free_consistent; 2685 2686 2687 mptsas_print_expander_pg1(ioc, buffer); 2688 2689 /* save config data */ 2690 phy_info->phy_id = buffer->PhyIdentifier; 2691 phy_info->port_id = buffer->PhysicalPort; 2692 phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate; 2693 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate; 2694 phy_info->hw_link_rate = buffer->HwLinkRate; 2695 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle); 2696 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle); 2697 2698 out_free_consistent: 2699 pci_free_consistent(ioc->pcidev, hdr.ExtPageLength * 4, 2700 buffer, dma_handle); 2701 out: 2702 return error; 2703 } 2704 2705 struct rep_manu_request{ 2706 u8 smp_frame_type; 2707 u8 function; 2708 u8 reserved; 2709 u8 request_length; 2710 }; 2711 2712 struct rep_manu_reply{ 2713 u8 smp_frame_type; /* 0x41 */ 2714 u8 function; /* 0x01 */ 2715 u8 function_result; 2716 u8 response_length; 2717 u16 expander_change_count; 2718 u8 reserved0[2]; 2719 u8 sas_format:1; 2720 u8 reserved1:7; 2721 u8 reserved2[3]; 2722 u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN]; 2723 u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN]; 2724 u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN]; 2725 u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN]; 2726 u16 component_id; 2727 u8 component_revision_id; 2728 u8 reserved3; 2729 u8 vendor_specific[8]; 2730 }; 2731 2732 /** 2733 * mptsas_exp_repmanufacture_info - 2734 * @ioc: per adapter object 2735 * @sas_address: expander sas address 2736 * @edev: the sas_expander_device object 2737 * 2738 * Fills in the sas_expander_device object when SMP port is created. 2739 * 2740 * Returns 0 for success, non-zero for failure. 2741 */ 2742 static int 2743 mptsas_exp_repmanufacture_info(MPT_ADAPTER *ioc, 2744 u64 sas_address, struct sas_expander_device *edev) 2745 { 2746 MPT_FRAME_HDR *mf; 2747 SmpPassthroughRequest_t *smpreq; 2748 SmpPassthroughReply_t *smprep; 2749 struct rep_manu_reply *manufacture_reply; 2750 struct rep_manu_request *manufacture_request; 2751 int ret; 2752 int flagsLength; 2753 unsigned long timeleft; 2754 char *psge; 2755 unsigned long flags; 2756 void *data_out = NULL; 2757 dma_addr_t data_out_dma = 0; 2758 u32 sz; 2759 2760 spin_lock_irqsave(&ioc->taskmgmt_lock, flags); 2761 if (ioc->ioc_reset_in_progress) { 2762 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags); 2763 printk(MYIOC_s_INFO_FMT "%s: host reset in progress!\n", 2764 __func__, ioc->name); 2765 return -EFAULT; 2766 } 2767 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags); 2768 2769 ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex); 2770 if (ret) 2771 goto out; 2772 2773 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc); 2774 if (!mf) { 2775 ret = -ENOMEM; 2776 goto out_unlock; 2777 } 2778 2779 smpreq = (SmpPassthroughRequest_t *)mf; 2780 memset(smpreq, 0, sizeof(*smpreq)); 2781 2782 sz = sizeof(struct rep_manu_request) + sizeof(struct rep_manu_reply); 2783 2784 data_out = pci_alloc_consistent(ioc->pcidev, sz, &data_out_dma); 2785 if (!data_out) { 2786 printk(KERN_ERR "Memory allocation failure at %s:%d/%s()!\n", 2787 __FILE__, __LINE__, __func__); 2788 ret = -ENOMEM; 2789 goto put_mf; 2790 } 2791 2792 manufacture_request = data_out; 2793 manufacture_request->smp_frame_type = 0x40; 2794 manufacture_request->function = 1; 2795 manufacture_request->reserved = 0; 2796 manufacture_request->request_length = 0; 2797 2798 smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH; 2799 smpreq->PhysicalPort = 0xFF; 2800 *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address); 2801 smpreq->RequestDataLength = sizeof(struct rep_manu_request); 2802 2803 psge = (char *) 2804 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4)); 2805 2806 flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT | 2807 MPI_SGE_FLAGS_SYSTEM_ADDRESS | 2808 MPI_SGE_FLAGS_HOST_TO_IOC | 2809 MPI_SGE_FLAGS_END_OF_BUFFER; 2810 flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT; 2811 flagsLength |= sizeof(struct rep_manu_request); 2812 2813 ioc->add_sge(psge, flagsLength, data_out_dma); 2814 psge += ioc->SGE_size; 2815 2816 flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT | 2817 MPI_SGE_FLAGS_SYSTEM_ADDRESS | 2818 MPI_SGE_FLAGS_IOC_TO_HOST | 2819 MPI_SGE_FLAGS_END_OF_BUFFER; 2820 flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT; 2821 flagsLength |= sizeof(struct rep_manu_reply); 2822 ioc->add_sge(psge, flagsLength, data_out_dma + 2823 sizeof(struct rep_manu_request)); 2824 2825 INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status) 2826 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf); 2827 2828 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ); 2829 if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) { 2830 ret = -ETIME; 2831 mpt_free_msg_frame(ioc, mf); 2832 mf = NULL; 2833 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET) 2834 goto out_free; 2835 if (!timeleft) 2836 mpt_HardResetHandler(ioc, CAN_SLEEP); 2837 goto out_free; 2838 } 2839 2840 mf = NULL; 2841 2842 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) { 2843 u8 *tmp; 2844 2845 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply; 2846 if (le16_to_cpu(smprep->ResponseDataLength) != 2847 sizeof(struct rep_manu_reply)) 2848 goto out_free; 2849 2850 manufacture_reply = data_out + sizeof(struct rep_manu_request); 2851 strncpy(edev->vendor_id, manufacture_reply->vendor_id, 2852 SAS_EXPANDER_VENDOR_ID_LEN); 2853 strncpy(edev->product_id, manufacture_reply->product_id, 2854 SAS_EXPANDER_PRODUCT_ID_LEN); 2855 strncpy(edev->product_rev, manufacture_reply->product_rev, 2856 SAS_EXPANDER_PRODUCT_REV_LEN); 2857 edev->level = manufacture_reply->sas_format; 2858 if (manufacture_reply->sas_format) { 2859 strncpy(edev->component_vendor_id, 2860 manufacture_reply->component_vendor_id, 2861 SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN); 2862 tmp = (u8 *)&manufacture_reply->component_id; 2863 edev->component_id = tmp[0] << 8 | tmp[1]; 2864 edev->component_revision_id = 2865 manufacture_reply->component_revision_id; 2866 } 2867 } else { 2868 printk(MYIOC_s_ERR_FMT 2869 "%s: smp passthru reply failed to be returned\n", 2870 ioc->name, __func__); 2871 ret = -ENXIO; 2872 } 2873 out_free: 2874 if (data_out_dma) 2875 pci_free_consistent(ioc->pcidev, sz, data_out, data_out_dma); 2876 put_mf: 2877 if (mf) 2878 mpt_free_msg_frame(ioc, mf); 2879 out_unlock: 2880 CLEAR_MGMT_STATUS(ioc->sas_mgmt.status) 2881 mutex_unlock(&ioc->sas_mgmt.mutex); 2882 out: 2883 return ret; 2884 } 2885 2886 static void 2887 mptsas_parse_device_info(struct sas_identify *identify, 2888 struct mptsas_devinfo *device_info) 2889 { 2890 u16 protocols; 2891 2892 identify->sas_address = device_info->sas_address; 2893 identify->phy_identifier = device_info->phy_id; 2894 2895 /* 2896 * Fill in Phy Initiator Port Protocol. 2897 * Bits 6:3, more than one bit can be set, fall through cases. 2898 */ 2899 protocols = device_info->device_info & 0x78; 2900 identify->initiator_port_protocols = 0; 2901 if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR) 2902 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP; 2903 if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR) 2904 identify->initiator_port_protocols |= SAS_PROTOCOL_STP; 2905 if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR) 2906 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP; 2907 if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST) 2908 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA; 2909 2910 /* 2911 * Fill in Phy Target Port Protocol. 2912 * Bits 10:7, more than one bit can be set, fall through cases. 2913 */ 2914 protocols = device_info->device_info & 0x780; 2915 identify->target_port_protocols = 0; 2916 if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET) 2917 identify->target_port_protocols |= SAS_PROTOCOL_SSP; 2918 if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET) 2919 identify->target_port_protocols |= SAS_PROTOCOL_STP; 2920 if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET) 2921 identify->target_port_protocols |= SAS_PROTOCOL_SMP; 2922 if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE) 2923 identify->target_port_protocols |= SAS_PROTOCOL_SATA; 2924 2925 /* 2926 * Fill in Attached device type. 2927 */ 2928 switch (device_info->device_info & 2929 MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) { 2930 case MPI_SAS_DEVICE_INFO_NO_DEVICE: 2931 identify->device_type = SAS_PHY_UNUSED; 2932 break; 2933 case MPI_SAS_DEVICE_INFO_END_DEVICE: 2934 identify->device_type = SAS_END_DEVICE; 2935 break; 2936 case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER: 2937 identify->device_type = SAS_EDGE_EXPANDER_DEVICE; 2938 break; 2939 case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER: 2940 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE; 2941 break; 2942 } 2943 } 2944 2945 static int mptsas_probe_one_phy(struct device *dev, 2946 struct mptsas_phyinfo *phy_info, int index, int local) 2947 { 2948 MPT_ADAPTER *ioc; 2949 struct sas_phy *phy; 2950 struct sas_port *port; 2951 int error = 0; 2952 2953 if (!dev) { 2954 error = -ENODEV; 2955 goto out; 2956 } 2957 2958 if (!phy_info->phy) { 2959 phy = sas_phy_alloc(dev, index); 2960 if (!phy) { 2961 error = -ENOMEM; 2962 goto out; 2963 } 2964 } else 2965 phy = phy_info->phy; 2966 2967 mptsas_parse_device_info(&phy->identify, &phy_info->identify); 2968 2969 /* 2970 * Set Negotiated link rate. 2971 */ 2972 switch (phy_info->negotiated_link_rate) { 2973 case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED: 2974 phy->negotiated_linkrate = SAS_PHY_DISABLED; 2975 break; 2976 case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION: 2977 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED; 2978 break; 2979 case MPI_SAS_IOUNIT0_RATE_1_5: 2980 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS; 2981 break; 2982 case MPI_SAS_IOUNIT0_RATE_3_0: 2983 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS; 2984 break; 2985 case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE: 2986 case MPI_SAS_IOUNIT0_RATE_UNKNOWN: 2987 default: 2988 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN; 2989 break; 2990 } 2991 2992 /* 2993 * Set Max hardware link rate. 2994 */ 2995 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) { 2996 case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5: 2997 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS; 2998 break; 2999 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0: 3000 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS; 3001 break; 3002 default: 3003 break; 3004 } 3005 3006 /* 3007 * Set Max programmed link rate. 3008 */ 3009 switch (phy_info->programmed_link_rate & 3010 MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) { 3011 case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5: 3012 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS; 3013 break; 3014 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0: 3015 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS; 3016 break; 3017 default: 3018 break; 3019 } 3020 3021 /* 3022 * Set Min hardware link rate. 3023 */ 3024 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) { 3025 case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5: 3026 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS; 3027 break; 3028 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0: 3029 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS; 3030 break; 3031 default: 3032 break; 3033 } 3034 3035 /* 3036 * Set Min programmed link rate. 3037 */ 3038 switch (phy_info->programmed_link_rate & 3039 MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) { 3040 case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5: 3041 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS; 3042 break; 3043 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0: 3044 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS; 3045 break; 3046 default: 3047 break; 3048 } 3049 3050 if (!phy_info->phy) { 3051 3052 error = sas_phy_add(phy); 3053 if (error) { 3054 sas_phy_free(phy); 3055 goto out; 3056 } 3057 phy_info->phy = phy; 3058 } 3059 3060 if (!phy_info->attached.handle || 3061 !phy_info->port_details) 3062 goto out; 3063 3064 port = mptsas_get_port(phy_info); 3065 ioc = phy_to_ioc(phy_info->phy); 3066 3067 if (phy_info->sas_port_add_phy) { 3068 3069 if (!port) { 3070 port = sas_port_alloc_num(dev); 3071 if (!port) { 3072 error = -ENOMEM; 3073 goto out; 3074 } 3075 error = sas_port_add(port); 3076 if (error) { 3077 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 3078 "%s: exit at line=%d\n", ioc->name, 3079 __func__, __LINE__)); 3080 goto out; 3081 } 3082 mptsas_set_port(ioc, phy_info, port); 3083 devtprintk(ioc, dev_printk(KERN_DEBUG, &port->dev, 3084 MYIOC_s_FMT "add port %d, sas_addr (0x%llx)\n", 3085 ioc->name, port->port_identifier, 3086 (unsigned long long)phy_info-> 3087 attached.sas_address)); 3088 } 3089 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT 3090 "sas_port_add_phy: phy_id=%d\n", 3091 ioc->name, phy_info->phy_id)); 3092 sas_port_add_phy(port, phy_info->phy); 3093 phy_info->sas_port_add_phy = 0; 3094 devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev, 3095 MYIOC_s_FMT "add phy %d, phy-obj (0x%p)\n", ioc->name, 3096 phy_info->phy_id, phy_info->phy)); 3097 } 3098 if (!mptsas_get_rphy(phy_info) && port && !port->rphy) { 3099 3100 struct sas_rphy *rphy; 3101 struct device *parent; 3102 struct sas_identify identify; 3103 3104 parent = dev->parent->parent; 3105 /* 3106 * Let the hotplug_work thread handle processing 3107 * the adding/removing of devices that occur 3108 * after start of day. 3109 */ 3110 if (mptsas_is_end_device(&phy_info->attached) && 3111 phy_info->attached.handle_parent) { 3112 goto out; 3113 } 3114 3115 mptsas_parse_device_info(&identify, &phy_info->attached); 3116 if (scsi_is_host_device(parent)) { 3117 struct mptsas_portinfo *port_info; 3118 int i; 3119 3120 port_info = ioc->hba_port_info; 3121 3122 for (i = 0; i < port_info->num_phys; i++) 3123 if (port_info->phy_info[i].identify.sas_address == 3124 identify.sas_address) { 3125 sas_port_mark_backlink(port); 3126 goto out; 3127 } 3128 3129 } else if (scsi_is_sas_rphy(parent)) { 3130 struct sas_rphy *parent_rphy = dev_to_rphy(parent); 3131 if (identify.sas_address == 3132 parent_rphy->identify.sas_address) { 3133 sas_port_mark_backlink(port); 3134 goto out; 3135 } 3136 } 3137 3138 switch (identify.device_type) { 3139 case SAS_END_DEVICE: 3140 rphy = sas_end_device_alloc(port); 3141 break; 3142 case SAS_EDGE_EXPANDER_DEVICE: 3143 case SAS_FANOUT_EXPANDER_DEVICE: 3144 rphy = sas_expander_alloc(port, identify.device_type); 3145 break; 3146 default: 3147 rphy = NULL; 3148 break; 3149 } 3150 if (!rphy) { 3151 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 3152 "%s: exit at line=%d\n", ioc->name, 3153 __func__, __LINE__)); 3154 goto out; 3155 } 3156 3157 rphy->identify = identify; 3158 error = sas_rphy_add(rphy); 3159 if (error) { 3160 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 3161 "%s: exit at line=%d\n", ioc->name, 3162 __func__, __LINE__)); 3163 sas_rphy_free(rphy); 3164 goto out; 3165 } 3166 mptsas_set_rphy(ioc, phy_info, rphy); 3167 if (identify.device_type == SAS_EDGE_EXPANDER_DEVICE || 3168 identify.device_type == SAS_FANOUT_EXPANDER_DEVICE) 3169 mptsas_exp_repmanufacture_info(ioc, 3170 identify.sas_address, 3171 rphy_to_expander_device(rphy)); 3172 } 3173 3174 out: 3175 return error; 3176 } 3177 3178 static int 3179 mptsas_probe_hba_phys(MPT_ADAPTER *ioc) 3180 { 3181 struct mptsas_portinfo *port_info, *hba; 3182 int error = -ENOMEM, i; 3183 3184 hba = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL); 3185 if (! hba) 3186 goto out; 3187 3188 error = mptsas_sas_io_unit_pg0(ioc, hba); 3189 if (error) 3190 goto out_free_port_info; 3191 3192 mptsas_sas_io_unit_pg1(ioc); 3193 mutex_lock(&ioc->sas_topology_mutex); 3194 port_info = ioc->hba_port_info; 3195 if (!port_info) { 3196 ioc->hba_port_info = port_info = hba; 3197 ioc->hba_port_num_phy = port_info->num_phys; 3198 list_add_tail(&port_info->list, &ioc->sas_topology); 3199 } else { 3200 for (i = 0; i < hba->num_phys; i++) { 3201 port_info->phy_info[i].negotiated_link_rate = 3202 hba->phy_info[i].negotiated_link_rate; 3203 port_info->phy_info[i].handle = 3204 hba->phy_info[i].handle; 3205 port_info->phy_info[i].port_id = 3206 hba->phy_info[i].port_id; 3207 } 3208 kfree(hba->phy_info); 3209 kfree(hba); 3210 hba = NULL; 3211 } 3212 mutex_unlock(&ioc->sas_topology_mutex); 3213 #if defined(CPQ_CIM) 3214 ioc->num_ports = port_info->num_phys; 3215 #endif 3216 for (i = 0; i < port_info->num_phys; i++) { 3217 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i], 3218 (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER << 3219 MPI_SAS_PHY_PGAD_FORM_SHIFT), i); 3220 port_info->phy_info[i].identify.handle = 3221 port_info->phy_info[i].handle; 3222 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify, 3223 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 3224 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 3225 port_info->phy_info[i].identify.handle); 3226 if (!ioc->hba_port_sas_addr) 3227 ioc->hba_port_sas_addr = 3228 port_info->phy_info[i].identify.sas_address; 3229 port_info->phy_info[i].identify.phy_id = 3230 port_info->phy_info[i].phy_id = i; 3231 if (port_info->phy_info[i].attached.handle) 3232 mptsas_sas_device_pg0(ioc, 3233 &port_info->phy_info[i].attached, 3234 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 3235 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 3236 port_info->phy_info[i].attached.handle); 3237 } 3238 3239 mptsas_setup_wide_ports(ioc, port_info); 3240 3241 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++) 3242 mptsas_probe_one_phy(&ioc->sh->shost_gendev, 3243 &port_info->phy_info[i], ioc->sas_index, 1); 3244 3245 return 0; 3246 3247 out_free_port_info: 3248 kfree(hba); 3249 out: 3250 return error; 3251 } 3252 3253 static void 3254 mptsas_expander_refresh(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info) 3255 { 3256 struct mptsas_portinfo *parent; 3257 struct device *parent_dev; 3258 struct sas_rphy *rphy; 3259 int i; 3260 u64 sas_address; /* expander sas address */ 3261 u32 handle; 3262 3263 handle = port_info->phy_info[0].handle; 3264 sas_address = port_info->phy_info[0].identify.sas_address; 3265 for (i = 0; i < port_info->num_phys; i++) { 3266 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i], 3267 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM << 3268 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + handle); 3269 3270 mptsas_sas_device_pg0(ioc, 3271 &port_info->phy_info[i].identify, 3272 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 3273 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 3274 port_info->phy_info[i].identify.handle); 3275 port_info->phy_info[i].identify.phy_id = 3276 port_info->phy_info[i].phy_id; 3277 3278 if (port_info->phy_info[i].attached.handle) { 3279 mptsas_sas_device_pg0(ioc, 3280 &port_info->phy_info[i].attached, 3281 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 3282 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 3283 port_info->phy_info[i].attached.handle); 3284 port_info->phy_info[i].attached.phy_id = 3285 port_info->phy_info[i].phy_id; 3286 } 3287 } 3288 3289 mutex_lock(&ioc->sas_topology_mutex); 3290 parent = mptsas_find_portinfo_by_handle(ioc, 3291 port_info->phy_info[0].identify.handle_parent); 3292 if (!parent) { 3293 mutex_unlock(&ioc->sas_topology_mutex); 3294 return; 3295 } 3296 for (i = 0, parent_dev = NULL; i < parent->num_phys && !parent_dev; 3297 i++) { 3298 if (parent->phy_info[i].attached.sas_address == sas_address) { 3299 rphy = mptsas_get_rphy(&parent->phy_info[i]); 3300 parent_dev = &rphy->dev; 3301 } 3302 } 3303 mutex_unlock(&ioc->sas_topology_mutex); 3304 3305 mptsas_setup_wide_ports(ioc, port_info); 3306 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++) 3307 mptsas_probe_one_phy(parent_dev, &port_info->phy_info[i], 3308 ioc->sas_index, 0); 3309 } 3310 3311 static void 3312 mptsas_expander_event_add(MPT_ADAPTER *ioc, 3313 MpiEventDataSasExpanderStatusChange_t *expander_data) 3314 { 3315 struct mptsas_portinfo *port_info; 3316 int i; 3317 __le64 sas_address; 3318 3319 port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL); 3320 if (!port_info) 3321 BUG(); 3322 port_info->num_phys = (expander_data->NumPhys) ? 3323 expander_data->NumPhys : 1; 3324 port_info->phy_info = kcalloc(port_info->num_phys, 3325 sizeof(struct mptsas_phyinfo), GFP_KERNEL); 3326 if (!port_info->phy_info) 3327 BUG(); 3328 memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64)); 3329 for (i = 0; i < port_info->num_phys; i++) { 3330 port_info->phy_info[i].portinfo = port_info; 3331 port_info->phy_info[i].handle = 3332 le16_to_cpu(expander_data->DevHandle); 3333 port_info->phy_info[i].identify.sas_address = 3334 le64_to_cpu(sas_address); 3335 port_info->phy_info[i].identify.handle_parent = 3336 le16_to_cpu(expander_data->ParentDevHandle); 3337 } 3338 3339 mutex_lock(&ioc->sas_topology_mutex); 3340 list_add_tail(&port_info->list, &ioc->sas_topology); 3341 mutex_unlock(&ioc->sas_topology_mutex); 3342 3343 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, " 3344 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys, 3345 (unsigned long long)sas_address); 3346 3347 mptsas_expander_refresh(ioc, port_info); 3348 } 3349 3350 /** 3351 * mptsas_delete_expander_siblings - remove siblings attached to expander 3352 * @ioc: Pointer to MPT_ADAPTER structure 3353 * @parent: the parent port_info object 3354 * @expander: the expander port_info object 3355 **/ 3356 static void 3357 mptsas_delete_expander_siblings(MPT_ADAPTER *ioc, struct mptsas_portinfo 3358 *parent, struct mptsas_portinfo *expander) 3359 { 3360 struct mptsas_phyinfo *phy_info; 3361 struct mptsas_portinfo *port_info; 3362 struct sas_rphy *rphy; 3363 int i; 3364 3365 phy_info = expander->phy_info; 3366 for (i = 0; i < expander->num_phys; i++, phy_info++) { 3367 rphy = mptsas_get_rphy(phy_info); 3368 if (!rphy) 3369 continue; 3370 if (rphy->identify.device_type == SAS_END_DEVICE) 3371 mptsas_del_end_device(ioc, phy_info); 3372 } 3373 3374 phy_info = expander->phy_info; 3375 for (i = 0; i < expander->num_phys; i++, phy_info++) { 3376 rphy = mptsas_get_rphy(phy_info); 3377 if (!rphy) 3378 continue; 3379 if (rphy->identify.device_type == 3380 MPI_SAS_DEVICE_INFO_EDGE_EXPANDER || 3381 rphy->identify.device_type == 3382 MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER) { 3383 port_info = mptsas_find_portinfo_by_sas_address(ioc, 3384 rphy->identify.sas_address); 3385 if (!port_info) 3386 continue; 3387 if (port_info == parent) /* backlink rphy */ 3388 continue; 3389 /* 3390 Delete this expander even if the expdevpage is exists 3391 because the parent expander is already deleted 3392 */ 3393 mptsas_expander_delete(ioc, port_info, 1); 3394 } 3395 } 3396 } 3397 3398 3399 /** 3400 * mptsas_expander_delete - remove this expander 3401 * @ioc: Pointer to MPT_ADAPTER structure 3402 * @port_info: expander port_info struct 3403 * @force: Flag to forcefully delete the expander 3404 * 3405 **/ 3406 3407 static void mptsas_expander_delete(MPT_ADAPTER *ioc, 3408 struct mptsas_portinfo *port_info, u8 force) 3409 { 3410 3411 struct mptsas_portinfo *parent; 3412 int i; 3413 u64 expander_sas_address; 3414 struct mptsas_phyinfo *phy_info; 3415 struct mptsas_portinfo buffer; 3416 struct mptsas_portinfo_details *port_details; 3417 struct sas_port *port; 3418 3419 if (!port_info) 3420 return; 3421 3422 /* see if expander is still there before deleting */ 3423 mptsas_sas_expander_pg0(ioc, &buffer, 3424 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE << 3425 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), 3426 port_info->phy_info[0].identify.handle); 3427 3428 if (buffer.num_phys) { 3429 kfree(buffer.phy_info); 3430 if (!force) 3431 return; 3432 } 3433 3434 3435 /* 3436 * Obtain the port_info instance to the parent port 3437 */ 3438 port_details = NULL; 3439 expander_sas_address = 3440 port_info->phy_info[0].identify.sas_address; 3441 parent = mptsas_find_portinfo_by_handle(ioc, 3442 port_info->phy_info[0].identify.handle_parent); 3443 mptsas_delete_expander_siblings(ioc, parent, port_info); 3444 if (!parent) 3445 goto out; 3446 3447 /* 3448 * Delete rphys in the parent that point 3449 * to this expander. 3450 */ 3451 phy_info = parent->phy_info; 3452 port = NULL; 3453 for (i = 0; i < parent->num_phys; i++, phy_info++) { 3454 if (!phy_info->phy) 3455 continue; 3456 if (phy_info->attached.sas_address != 3457 expander_sas_address) 3458 continue; 3459 if (!port) { 3460 port = mptsas_get_port(phy_info); 3461 port_details = phy_info->port_details; 3462 } 3463 dev_printk(KERN_DEBUG, &phy_info->phy->dev, 3464 MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name, 3465 phy_info->phy_id, phy_info->phy); 3466 sas_port_delete_phy(port, phy_info->phy); 3467 } 3468 if (port) { 3469 dev_printk(KERN_DEBUG, &port->dev, 3470 MYIOC_s_FMT "delete port %d, sas_addr (0x%llx)\n", 3471 ioc->name, port->port_identifier, 3472 (unsigned long long)expander_sas_address); 3473 sas_port_delete(port); 3474 mptsas_port_delete(ioc, port_details); 3475 } 3476 out: 3477 3478 printk(MYIOC_s_INFO_FMT "delete expander: num_phys %d, " 3479 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys, 3480 (unsigned long long)expander_sas_address); 3481 3482 /* 3483 * free link 3484 */ 3485 list_del(&port_info->list); 3486 kfree(port_info->phy_info); 3487 kfree(port_info); 3488 } 3489 3490 3491 /** 3492 * mptsas_send_expander_event - expanders events 3493 * @ioc: Pointer to MPT_ADAPTER structure 3494 * @expander_data: event data 3495 * 3496 * 3497 * This function handles adding, removing, and refreshing 3498 * device handles within the expander objects. 3499 */ 3500 static void 3501 mptsas_send_expander_event(struct fw_event_work *fw_event) 3502 { 3503 MPT_ADAPTER *ioc; 3504 MpiEventDataSasExpanderStatusChange_t *expander_data; 3505 struct mptsas_portinfo *port_info; 3506 __le64 sas_address; 3507 int i; 3508 3509 ioc = fw_event->ioc; 3510 expander_data = (MpiEventDataSasExpanderStatusChange_t *) 3511 fw_event->event_data; 3512 memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64)); 3513 sas_address = le64_to_cpu(sas_address); 3514 port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address); 3515 3516 if (expander_data->ReasonCode == MPI_EVENT_SAS_EXP_RC_ADDED) { 3517 if (port_info) { 3518 for (i = 0; i < port_info->num_phys; i++) { 3519 port_info->phy_info[i].portinfo = port_info; 3520 port_info->phy_info[i].handle = 3521 le16_to_cpu(expander_data->DevHandle); 3522 port_info->phy_info[i].identify.sas_address = 3523 le64_to_cpu(sas_address); 3524 port_info->phy_info[i].identify.handle_parent = 3525 le16_to_cpu(expander_data->ParentDevHandle); 3526 } 3527 mptsas_expander_refresh(ioc, port_info); 3528 } else if (!port_info && expander_data->NumPhys) 3529 mptsas_expander_event_add(ioc, expander_data); 3530 } else if (expander_data->ReasonCode == 3531 MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING) 3532 mptsas_expander_delete(ioc, port_info, 0); 3533 3534 mptsas_free_fw_event(ioc, fw_event); 3535 } 3536 3537 3538 /** 3539 * mptsas_expander_add - 3540 * @ioc: Pointer to MPT_ADAPTER structure 3541 * @handle: 3542 * 3543 */ 3544 struct mptsas_portinfo * 3545 mptsas_expander_add(MPT_ADAPTER *ioc, u16 handle) 3546 { 3547 struct mptsas_portinfo buffer, *port_info; 3548 int i; 3549 3550 if ((mptsas_sas_expander_pg0(ioc, &buffer, 3551 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE << 3552 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle))) 3553 return NULL; 3554 3555 port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_ATOMIC); 3556 if (!port_info) { 3557 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 3558 "%s: exit at line=%d\n", ioc->name, 3559 __func__, __LINE__)); 3560 return NULL; 3561 } 3562 port_info->num_phys = buffer.num_phys; 3563 port_info->phy_info = buffer.phy_info; 3564 for (i = 0; i < port_info->num_phys; i++) 3565 port_info->phy_info[i].portinfo = port_info; 3566 mutex_lock(&ioc->sas_topology_mutex); 3567 list_add_tail(&port_info->list, &ioc->sas_topology); 3568 mutex_unlock(&ioc->sas_topology_mutex); 3569 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, " 3570 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys, 3571 (unsigned long long)buffer.phy_info[0].identify.sas_address); 3572 mptsas_expander_refresh(ioc, port_info); 3573 return port_info; 3574 } 3575 3576 static void 3577 mptsas_send_link_status_event(struct fw_event_work *fw_event) 3578 { 3579 MPT_ADAPTER *ioc; 3580 MpiEventDataSasPhyLinkStatus_t *link_data; 3581 struct mptsas_portinfo *port_info; 3582 struct mptsas_phyinfo *phy_info = NULL; 3583 __le64 sas_address; 3584 u8 phy_num; 3585 u8 link_rate; 3586 3587 ioc = fw_event->ioc; 3588 link_data = (MpiEventDataSasPhyLinkStatus_t *)fw_event->event_data; 3589 3590 memcpy(&sas_address, &link_data->SASAddress, sizeof(__le64)); 3591 sas_address = le64_to_cpu(sas_address); 3592 link_rate = link_data->LinkRates >> 4; 3593 phy_num = link_data->PhyNum; 3594 3595 port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address); 3596 if (port_info) { 3597 phy_info = &port_info->phy_info[phy_num]; 3598 if (phy_info) 3599 phy_info->negotiated_link_rate = link_rate; 3600 } 3601 3602 if (link_rate == MPI_SAS_IOUNIT0_RATE_1_5 || 3603 link_rate == MPI_SAS_IOUNIT0_RATE_3_0) { 3604 3605 if (!port_info) { 3606 if (ioc->old_sas_discovery_protocal) { 3607 port_info = mptsas_expander_add(ioc, 3608 le16_to_cpu(link_data->DevHandle)); 3609 if (port_info) 3610 goto out; 3611 } 3612 goto out; 3613 } 3614 3615 if (port_info == ioc->hba_port_info) 3616 mptsas_probe_hba_phys(ioc); 3617 else 3618 mptsas_expander_refresh(ioc, port_info); 3619 } else if (phy_info && phy_info->phy) { 3620 if (link_rate == MPI_SAS_IOUNIT0_RATE_PHY_DISABLED) 3621 phy_info->phy->negotiated_linkrate = 3622 SAS_PHY_DISABLED; 3623 else if (link_rate == 3624 MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION) 3625 phy_info->phy->negotiated_linkrate = 3626 SAS_LINK_RATE_FAILED; 3627 else 3628 phy_info->phy->negotiated_linkrate = 3629 SAS_LINK_RATE_UNKNOWN; 3630 } 3631 out: 3632 mptsas_free_fw_event(ioc, fw_event); 3633 } 3634 3635 static void 3636 mptsas_not_responding_devices(MPT_ADAPTER *ioc) 3637 { 3638 struct mptsas_portinfo buffer, *port_info; 3639 struct mptsas_device_info *sas_info; 3640 struct mptsas_devinfo sas_device; 3641 u32 handle; 3642 VirtTarget *vtarget = NULL; 3643 struct mptsas_phyinfo *phy_info; 3644 u8 found_expander; 3645 int retval, retry_count; 3646 unsigned long flags; 3647 3648 mpt_findImVolumes(ioc); 3649 3650 spin_lock_irqsave(&ioc->taskmgmt_lock, flags); 3651 if (ioc->ioc_reset_in_progress) { 3652 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT 3653 "%s: exiting due to a parallel reset \n", ioc->name, 3654 __func__)); 3655 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags); 3656 return; 3657 } 3658 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags); 3659 3660 /* devices, logical volumes */ 3661 mutex_lock(&ioc->sas_device_info_mutex); 3662 redo_device_scan: 3663 list_for_each_entry(sas_info, &ioc->sas_device_info_list, list) { 3664 if (sas_info->is_cached) 3665 continue; 3666 if (!sas_info->is_logical_volume) { 3667 sas_device.handle = 0; 3668 retry_count = 0; 3669 retry_page: 3670 retval = mptsas_sas_device_pg0(ioc, &sas_device, 3671 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID 3672 << MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 3673 (sas_info->fw.channel << 8) + 3674 sas_info->fw.id); 3675 3676 if (sas_device.handle) 3677 continue; 3678 if (retval == -EBUSY) { 3679 spin_lock_irqsave(&ioc->taskmgmt_lock, flags); 3680 if (ioc->ioc_reset_in_progress) { 3681 dfailprintk(ioc, 3682 printk(MYIOC_s_DEBUG_FMT 3683 "%s: exiting due to reset\n", 3684 ioc->name, __func__)); 3685 spin_unlock_irqrestore 3686 (&ioc->taskmgmt_lock, flags); 3687 mutex_unlock(&ioc-> 3688 sas_device_info_mutex); 3689 return; 3690 } 3691 spin_unlock_irqrestore(&ioc->taskmgmt_lock, 3692 flags); 3693 } 3694 3695 if (retval && (retval != -ENODEV)) { 3696 if (retry_count < 10) { 3697 retry_count++; 3698 goto retry_page; 3699 } else { 3700 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 3701 "%s: Config page retry exceeded retry " 3702 "count deleting device 0x%llx\n", 3703 ioc->name, __func__, 3704 sas_info->sas_address)); 3705 } 3706 } 3707 3708 /* delete device */ 3709 vtarget = mptsas_find_vtarget(ioc, 3710 sas_info->fw.channel, sas_info->fw.id); 3711 3712 if (vtarget) 3713 vtarget->deleted = 1; 3714 3715 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 3716 sas_info->sas_address); 3717 3718 if (phy_info) { 3719 mptsas_del_end_device(ioc, phy_info); 3720 goto redo_device_scan; 3721 } 3722 } else 3723 mptsas_volume_delete(ioc, sas_info->fw.id); 3724 } 3725 mutex_unlock(&ioc->sas_device_info_mutex); 3726 3727 /* expanders */ 3728 mutex_lock(&ioc->sas_topology_mutex); 3729 redo_expander_scan: 3730 list_for_each_entry(port_info, &ioc->sas_topology, list) { 3731 3732 if (port_info->phy_info && 3733 (!(port_info->phy_info[0].identify.device_info & 3734 MPI_SAS_DEVICE_INFO_SMP_TARGET))) 3735 continue; 3736 found_expander = 0; 3737 handle = 0xFFFF; 3738 while (!mptsas_sas_expander_pg0(ioc, &buffer, 3739 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE << 3740 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle) && 3741 !found_expander) { 3742 3743 handle = buffer.phy_info[0].handle; 3744 if (buffer.phy_info[0].identify.sas_address == 3745 port_info->phy_info[0].identify.sas_address) { 3746 found_expander = 1; 3747 } 3748 kfree(buffer.phy_info); 3749 } 3750 3751 if (!found_expander) { 3752 mptsas_expander_delete(ioc, port_info, 0); 3753 goto redo_expander_scan; 3754 } 3755 } 3756 mutex_unlock(&ioc->sas_topology_mutex); 3757 } 3758 3759 /** 3760 * mptsas_probe_expanders - adding expanders 3761 * @ioc: Pointer to MPT_ADAPTER structure 3762 * 3763 **/ 3764 static void 3765 mptsas_probe_expanders(MPT_ADAPTER *ioc) 3766 { 3767 struct mptsas_portinfo buffer, *port_info; 3768 u32 handle; 3769 int i; 3770 3771 handle = 0xFFFF; 3772 while (!mptsas_sas_expander_pg0(ioc, &buffer, 3773 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE << 3774 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)) { 3775 3776 handle = buffer.phy_info[0].handle; 3777 port_info = mptsas_find_portinfo_by_sas_address(ioc, 3778 buffer.phy_info[0].identify.sas_address); 3779 3780 if (port_info) { 3781 /* refreshing handles */ 3782 for (i = 0; i < buffer.num_phys; i++) { 3783 port_info->phy_info[i].handle = handle; 3784 port_info->phy_info[i].identify.handle_parent = 3785 buffer.phy_info[0].identify.handle_parent; 3786 } 3787 mptsas_expander_refresh(ioc, port_info); 3788 kfree(buffer.phy_info); 3789 continue; 3790 } 3791 3792 port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL); 3793 if (!port_info) { 3794 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 3795 "%s: exit at line=%d\n", ioc->name, 3796 __func__, __LINE__)); 3797 return; 3798 } 3799 port_info->num_phys = buffer.num_phys; 3800 port_info->phy_info = buffer.phy_info; 3801 for (i = 0; i < port_info->num_phys; i++) 3802 port_info->phy_info[i].portinfo = port_info; 3803 mutex_lock(&ioc->sas_topology_mutex); 3804 list_add_tail(&port_info->list, &ioc->sas_topology); 3805 mutex_unlock(&ioc->sas_topology_mutex); 3806 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, " 3807 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys, 3808 (unsigned long long)buffer.phy_info[0].identify.sas_address); 3809 mptsas_expander_refresh(ioc, port_info); 3810 } 3811 } 3812 3813 static void 3814 mptsas_probe_devices(MPT_ADAPTER *ioc) 3815 { 3816 u16 handle; 3817 struct mptsas_devinfo sas_device; 3818 struct mptsas_phyinfo *phy_info; 3819 3820 handle = 0xFFFF; 3821 while (!(mptsas_sas_device_pg0(ioc, &sas_device, 3822 MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, handle))) { 3823 3824 handle = sas_device.handle; 3825 3826 if ((sas_device.device_info & 3827 (MPI_SAS_DEVICE_INFO_SSP_TARGET | 3828 MPI_SAS_DEVICE_INFO_STP_TARGET | 3829 MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0) 3830 continue; 3831 3832 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device); 3833 if (!phy_info) 3834 continue; 3835 3836 if (mptsas_get_rphy(phy_info)) 3837 continue; 3838 3839 mptsas_add_end_device(ioc, phy_info); 3840 } 3841 } 3842 3843 /** 3844 * mptsas_scan_sas_topology - 3845 * @ioc: Pointer to MPT_ADAPTER structure 3846 * @sas_address: 3847 * 3848 **/ 3849 static void 3850 mptsas_scan_sas_topology(MPT_ADAPTER *ioc) 3851 { 3852 struct scsi_device *sdev; 3853 int i; 3854 3855 mptsas_probe_hba_phys(ioc); 3856 mptsas_probe_expanders(ioc); 3857 mptsas_probe_devices(ioc); 3858 3859 /* 3860 Reporting RAID volumes. 3861 */ 3862 if (!ioc->ir_firmware || !ioc->raid_data.pIocPg2 || 3863 !ioc->raid_data.pIocPg2->NumActiveVolumes) 3864 return; 3865 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) { 3866 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, 3867 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0); 3868 if (sdev) { 3869 scsi_device_put(sdev); 3870 continue; 3871 } 3872 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, " 3873 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, 3874 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID); 3875 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, 3876 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0); 3877 } 3878 } 3879 3880 3881 static void 3882 mptsas_handle_queue_full_event(struct fw_event_work *fw_event) 3883 { 3884 MPT_ADAPTER *ioc; 3885 EventDataQueueFull_t *qfull_data; 3886 struct mptsas_device_info *sas_info; 3887 struct scsi_device *sdev; 3888 int depth; 3889 int id = -1; 3890 int channel = -1; 3891 int fw_id, fw_channel; 3892 u16 current_depth; 3893 3894 3895 ioc = fw_event->ioc; 3896 qfull_data = (EventDataQueueFull_t *)fw_event->event_data; 3897 fw_id = qfull_data->TargetID; 3898 fw_channel = qfull_data->Bus; 3899 current_depth = le16_to_cpu(qfull_data->CurrentDepth); 3900 3901 /* if hidden raid component, look for the volume id */ 3902 mutex_lock(&ioc->sas_device_info_mutex); 3903 if (mptscsih_is_phys_disk(ioc, fw_channel, fw_id)) { 3904 list_for_each_entry(sas_info, &ioc->sas_device_info_list, 3905 list) { 3906 if (sas_info->is_cached || 3907 sas_info->is_logical_volume) 3908 continue; 3909 if (sas_info->is_hidden_raid_component && 3910 (sas_info->fw.channel == fw_channel && 3911 sas_info->fw.id == fw_id)) { 3912 id = sas_info->volume_id; 3913 channel = MPTSAS_RAID_CHANNEL; 3914 goto out; 3915 } 3916 } 3917 } else { 3918 list_for_each_entry(sas_info, &ioc->sas_device_info_list, 3919 list) { 3920 if (sas_info->is_cached || 3921 sas_info->is_hidden_raid_component || 3922 sas_info->is_logical_volume) 3923 continue; 3924 if (sas_info->fw.channel == fw_channel && 3925 sas_info->fw.id == fw_id) { 3926 id = sas_info->os.id; 3927 channel = sas_info->os.channel; 3928 goto out; 3929 } 3930 } 3931 3932 } 3933 3934 out: 3935 mutex_unlock(&ioc->sas_device_info_mutex); 3936 3937 if (id != -1) { 3938 shost_for_each_device(sdev, ioc->sh) { 3939 if (sdev->id == id && sdev->channel == channel) { 3940 if (current_depth > sdev->queue_depth) { 3941 sdev_printk(KERN_INFO, sdev, 3942 "strange observation, the queue " 3943 "depth is (%d) meanwhile fw queue " 3944 "depth (%d)\n", sdev->queue_depth, 3945 current_depth); 3946 continue; 3947 } 3948 depth = scsi_track_queue_full(sdev, 3949 current_depth - 1); 3950 if (depth > 0) 3951 sdev_printk(KERN_INFO, sdev, 3952 "Queue depth reduced to (%d)\n", 3953 depth); 3954 else if (depth < 0) 3955 sdev_printk(KERN_INFO, sdev, 3956 "Tagged Command Queueing is being " 3957 "disabled\n"); 3958 else if (depth == 0) 3959 sdev_printk(KERN_INFO, sdev, 3960 "Queue depth not changed yet\n"); 3961 } 3962 } 3963 } 3964 3965 mptsas_free_fw_event(ioc, fw_event); 3966 } 3967 3968 3969 static struct mptsas_phyinfo * 3970 mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address) 3971 { 3972 struct mptsas_portinfo *port_info; 3973 struct mptsas_phyinfo *phy_info = NULL; 3974 int i; 3975 3976 mutex_lock(&ioc->sas_topology_mutex); 3977 list_for_each_entry(port_info, &ioc->sas_topology, list) { 3978 for (i = 0; i < port_info->num_phys; i++) { 3979 if (!mptsas_is_end_device( 3980 &port_info->phy_info[i].attached)) 3981 continue; 3982 if (port_info->phy_info[i].attached.sas_address 3983 != sas_address) 3984 continue; 3985 phy_info = &port_info->phy_info[i]; 3986 break; 3987 } 3988 } 3989 mutex_unlock(&ioc->sas_topology_mutex); 3990 return phy_info; 3991 } 3992 3993 /** 3994 * mptsas_find_phyinfo_by_phys_disk_num - 3995 * @ioc: Pointer to MPT_ADAPTER structure 3996 * @phys_disk_num: 3997 * @channel: 3998 * @id: 3999 * 4000 **/ 4001 static struct mptsas_phyinfo * 4002 mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 phys_disk_num, 4003 u8 channel, u8 id) 4004 { 4005 struct mptsas_phyinfo *phy_info = NULL; 4006 struct mptsas_portinfo *port_info; 4007 RaidPhysDiskPage1_t *phys_disk = NULL; 4008 int num_paths; 4009 u64 sas_address = 0; 4010 int i; 4011 4012 phy_info = NULL; 4013 if (!ioc->raid_data.pIocPg3) 4014 return NULL; 4015 /* dual port support */ 4016 num_paths = mpt_raid_phys_disk_get_num_paths(ioc, phys_disk_num); 4017 if (!num_paths) 4018 goto out; 4019 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) + 4020 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL); 4021 if (!phys_disk) 4022 goto out; 4023 mpt_raid_phys_disk_pg1(ioc, phys_disk_num, phys_disk); 4024 for (i = 0; i < num_paths; i++) { 4025 if ((phys_disk->Path[i].Flags & 1) != 0) 4026 /* entry no longer valid */ 4027 continue; 4028 if ((id == phys_disk->Path[i].PhysDiskID) && 4029 (channel == phys_disk->Path[i].PhysDiskBus)) { 4030 memcpy(&sas_address, &phys_disk->Path[i].WWID, 4031 sizeof(u64)); 4032 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 4033 sas_address); 4034 goto out; 4035 } 4036 } 4037 4038 out: 4039 kfree(phys_disk); 4040 if (phy_info) 4041 return phy_info; 4042 4043 /* 4044 * Extra code to handle RAID0 case, where the sas_address is not updated 4045 * in phys_disk_page_1 when hotswapped 4046 */ 4047 mutex_lock(&ioc->sas_topology_mutex); 4048 list_for_each_entry(port_info, &ioc->sas_topology, list) { 4049 for (i = 0; i < port_info->num_phys && !phy_info; i++) { 4050 if (!mptsas_is_end_device( 4051 &port_info->phy_info[i].attached)) 4052 continue; 4053 if (port_info->phy_info[i].attached.phys_disk_num == ~0) 4054 continue; 4055 if ((port_info->phy_info[i].attached.phys_disk_num == 4056 phys_disk_num) && 4057 (port_info->phy_info[i].attached.id == id) && 4058 (port_info->phy_info[i].attached.channel == 4059 channel)) 4060 phy_info = &port_info->phy_info[i]; 4061 } 4062 } 4063 mutex_unlock(&ioc->sas_topology_mutex); 4064 return phy_info; 4065 } 4066 4067 static void 4068 mptsas_reprobe_lun(struct scsi_device *sdev, void *data) 4069 { 4070 int rc; 4071 4072 sdev->no_uld_attach = data ? 1 : 0; 4073 rc = scsi_device_reprobe(sdev); 4074 } 4075 4076 static void 4077 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach) 4078 { 4079 starget_for_each_device(starget, uld_attach ? (void *)1 : NULL, 4080 mptsas_reprobe_lun); 4081 } 4082 4083 static void 4084 mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id) 4085 { 4086 CONFIGPARMS cfg; 4087 ConfigPageHeader_t hdr; 4088 dma_addr_t dma_handle; 4089 pRaidVolumePage0_t buffer = NULL; 4090 RaidPhysDiskPage0_t phys_disk; 4091 int i; 4092 struct mptsas_phyinfo *phy_info; 4093 struct mptsas_devinfo sas_device; 4094 4095 memset(&cfg, 0 , sizeof(CONFIGPARMS)); 4096 memset(&hdr, 0 , sizeof(ConfigPageHeader_t)); 4097 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME; 4098 cfg.pageAddr = (channel << 8) + id; 4099 cfg.cfghdr.hdr = &hdr; 4100 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 4101 4102 if (mpt_config(ioc, &cfg) != 0) 4103 goto out; 4104 4105 if (!hdr.PageLength) 4106 goto out; 4107 4108 buffer = pci_alloc_consistent(ioc->pcidev, hdr.PageLength * 4, 4109 &dma_handle); 4110 4111 if (!buffer) 4112 goto out; 4113 4114 cfg.physAddr = dma_handle; 4115 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 4116 4117 if (mpt_config(ioc, &cfg) != 0) 4118 goto out; 4119 4120 if (!(buffer->VolumeStatus.Flags & 4121 MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE)) 4122 goto out; 4123 4124 if (!buffer->NumPhysDisks) 4125 goto out; 4126 4127 for (i = 0; i < buffer->NumPhysDisks; i++) { 4128 4129 if (mpt_raid_phys_disk_pg0(ioc, 4130 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0) 4131 continue; 4132 4133 if (mptsas_sas_device_pg0(ioc, &sas_device, 4134 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 4135 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 4136 (phys_disk.PhysDiskBus << 8) + 4137 phys_disk.PhysDiskID)) 4138 continue; 4139 4140 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 4141 sas_device.sas_address); 4142 mptsas_add_end_device(ioc, phy_info); 4143 } 4144 4145 out: 4146 if (buffer) 4147 pci_free_consistent(ioc->pcidev, hdr.PageLength * 4, buffer, 4148 dma_handle); 4149 } 4150 /* 4151 * Work queue thread to handle SAS hotplug events 4152 */ 4153 static void 4154 mptsas_hotplug_work(MPT_ADAPTER *ioc, struct fw_event_work *fw_event, 4155 struct mptsas_hotplug_event *hot_plug_info) 4156 { 4157 struct mptsas_phyinfo *phy_info; 4158 struct scsi_target * starget; 4159 struct mptsas_devinfo sas_device; 4160 VirtTarget *vtarget; 4161 int i; 4162 4163 switch (hot_plug_info->event_type) { 4164 4165 case MPTSAS_ADD_PHYSDISK: 4166 4167 if (!ioc->raid_data.pIocPg2) 4168 break; 4169 4170 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) { 4171 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == 4172 hot_plug_info->id) { 4173 printk(MYIOC_s_WARN_FMT "firmware bug: unable " 4174 "to add hidden disk - target_id matchs " 4175 "volume_id\n", ioc->name); 4176 mptsas_free_fw_event(ioc, fw_event); 4177 return; 4178 } 4179 } 4180 mpt_findImVolumes(ioc); 4181 4182 case MPTSAS_ADD_DEVICE: 4183 memset(&sas_device, 0, sizeof(struct mptsas_devinfo)); 4184 mptsas_sas_device_pg0(ioc, &sas_device, 4185 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 4186 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 4187 (hot_plug_info->channel << 8) + 4188 hot_plug_info->id); 4189 4190 if (!sas_device.handle) 4191 return; 4192 4193 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device); 4194 if (!phy_info) 4195 break; 4196 4197 if (mptsas_get_rphy(phy_info)) 4198 break; 4199 4200 mptsas_add_end_device(ioc, phy_info); 4201 break; 4202 4203 case MPTSAS_DEL_DEVICE: 4204 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 4205 hot_plug_info->sas_address); 4206 mptsas_del_end_device(ioc, phy_info); 4207 break; 4208 4209 case MPTSAS_DEL_PHYSDISK: 4210 4211 mpt_findImVolumes(ioc); 4212 4213 phy_info = mptsas_find_phyinfo_by_phys_disk_num( 4214 ioc, hot_plug_info->phys_disk_num, 4215 hot_plug_info->channel, 4216 hot_plug_info->id); 4217 mptsas_del_end_device(ioc, phy_info); 4218 break; 4219 4220 case MPTSAS_ADD_PHYSDISK_REPROBE: 4221 4222 if (mptsas_sas_device_pg0(ioc, &sas_device, 4223 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 4224 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 4225 (hot_plug_info->channel << 8) + hot_plug_info->id)) { 4226 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4227 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4228 __func__, hot_plug_info->id, __LINE__)); 4229 break; 4230 } 4231 4232 phy_info = mptsas_find_phyinfo_by_sas_address( 4233 ioc, sas_device.sas_address); 4234 4235 if (!phy_info) { 4236 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4237 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4238 __func__, hot_plug_info->id, __LINE__)); 4239 break; 4240 } 4241 4242 starget = mptsas_get_starget(phy_info); 4243 if (!starget) { 4244 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4245 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4246 __func__, hot_plug_info->id, __LINE__)); 4247 break; 4248 } 4249 4250 vtarget = starget->hostdata; 4251 if (!vtarget) { 4252 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4253 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4254 __func__, hot_plug_info->id, __LINE__)); 4255 break; 4256 } 4257 4258 mpt_findImVolumes(ioc); 4259 4260 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Hidding: " 4261 "fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n", 4262 ioc->name, hot_plug_info->channel, hot_plug_info->id, 4263 hot_plug_info->phys_disk_num, (unsigned long long) 4264 sas_device.sas_address); 4265 4266 vtarget->id = hot_plug_info->phys_disk_num; 4267 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT; 4268 phy_info->attached.phys_disk_num = hot_plug_info->phys_disk_num; 4269 mptsas_reprobe_target(starget, 1); 4270 break; 4271 4272 case MPTSAS_DEL_PHYSDISK_REPROBE: 4273 4274 if (mptsas_sas_device_pg0(ioc, &sas_device, 4275 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 4276 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 4277 (hot_plug_info->channel << 8) + hot_plug_info->id)) { 4278 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4279 "%s: fw_id=%d exit at line=%d\n", 4280 ioc->name, __func__, 4281 hot_plug_info->id, __LINE__)); 4282 break; 4283 } 4284 4285 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 4286 sas_device.sas_address); 4287 if (!phy_info) { 4288 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4289 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4290 __func__, hot_plug_info->id, __LINE__)); 4291 break; 4292 } 4293 4294 starget = mptsas_get_starget(phy_info); 4295 if (!starget) { 4296 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4297 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4298 __func__, hot_plug_info->id, __LINE__)); 4299 break; 4300 } 4301 4302 vtarget = starget->hostdata; 4303 if (!vtarget) { 4304 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4305 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4306 __func__, hot_plug_info->id, __LINE__)); 4307 break; 4308 } 4309 4310 if (!(vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)) { 4311 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4312 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4313 __func__, hot_plug_info->id, __LINE__)); 4314 break; 4315 } 4316 4317 mpt_findImVolumes(ioc); 4318 4319 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Exposing:" 4320 " fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n", 4321 ioc->name, hot_plug_info->channel, hot_plug_info->id, 4322 hot_plug_info->phys_disk_num, (unsigned long long) 4323 sas_device.sas_address); 4324 4325 vtarget->tflags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT; 4326 vtarget->id = hot_plug_info->id; 4327 phy_info->attached.phys_disk_num = ~0; 4328 mptsas_reprobe_target(starget, 0); 4329 mptsas_add_device_component_by_fw(ioc, 4330 hot_plug_info->channel, hot_plug_info->id); 4331 break; 4332 4333 case MPTSAS_ADD_RAID: 4334 4335 mpt_findImVolumes(ioc); 4336 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, " 4337 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, 4338 hot_plug_info->id); 4339 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, 4340 hot_plug_info->id, 0); 4341 break; 4342 4343 case MPTSAS_DEL_RAID: 4344 4345 mpt_findImVolumes(ioc); 4346 printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, " 4347 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, 4348 hot_plug_info->id); 4349 scsi_remove_device(hot_plug_info->sdev); 4350 scsi_device_put(hot_plug_info->sdev); 4351 break; 4352 4353 case MPTSAS_ADD_INACTIVE_VOLUME: 4354 4355 mpt_findImVolumes(ioc); 4356 mptsas_adding_inactive_raid_components(ioc, 4357 hot_plug_info->channel, hot_plug_info->id); 4358 break; 4359 4360 default: 4361 break; 4362 } 4363 4364 mptsas_free_fw_event(ioc, fw_event); 4365 } 4366 4367 static void 4368 mptsas_send_sas_event(struct fw_event_work *fw_event) 4369 { 4370 MPT_ADAPTER *ioc; 4371 struct mptsas_hotplug_event hot_plug_info; 4372 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data; 4373 u32 device_info; 4374 u64 sas_address; 4375 4376 ioc = fw_event->ioc; 4377 sas_event_data = (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *) 4378 fw_event->event_data; 4379 device_info = le32_to_cpu(sas_event_data->DeviceInfo); 4380 4381 if ((device_info & 4382 (MPI_SAS_DEVICE_INFO_SSP_TARGET | 4383 MPI_SAS_DEVICE_INFO_STP_TARGET | 4384 MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0) { 4385 mptsas_free_fw_event(ioc, fw_event); 4386 return; 4387 } 4388 4389 if (sas_event_data->ReasonCode == 4390 MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED) { 4391 mptbase_sas_persist_operation(ioc, 4392 MPI_SAS_OP_CLEAR_NOT_PRESENT); 4393 mptsas_free_fw_event(ioc, fw_event); 4394 return; 4395 } 4396 4397 switch (sas_event_data->ReasonCode) { 4398 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING: 4399 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED: 4400 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event)); 4401 hot_plug_info.handle = le16_to_cpu(sas_event_data->DevHandle); 4402 hot_plug_info.channel = sas_event_data->Bus; 4403 hot_plug_info.id = sas_event_data->TargetID; 4404 hot_plug_info.phy_id = sas_event_data->PhyNum; 4405 memcpy(&sas_address, &sas_event_data->SASAddress, 4406 sizeof(u64)); 4407 hot_plug_info.sas_address = le64_to_cpu(sas_address); 4408 hot_plug_info.device_info = device_info; 4409 if (sas_event_data->ReasonCode & 4410 MPI_EVENT_SAS_DEV_STAT_RC_ADDED) 4411 hot_plug_info.event_type = MPTSAS_ADD_DEVICE; 4412 else 4413 hot_plug_info.event_type = MPTSAS_DEL_DEVICE; 4414 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info); 4415 break; 4416 4417 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED: 4418 mptbase_sas_persist_operation(ioc, 4419 MPI_SAS_OP_CLEAR_NOT_PRESENT); 4420 mptsas_free_fw_event(ioc, fw_event); 4421 break; 4422 4423 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA: 4424 /* TODO */ 4425 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET: 4426 /* TODO */ 4427 default: 4428 mptsas_free_fw_event(ioc, fw_event); 4429 break; 4430 } 4431 } 4432 4433 static void 4434 mptsas_send_raid_event(struct fw_event_work *fw_event) 4435 { 4436 MPT_ADAPTER *ioc; 4437 EVENT_DATA_RAID *raid_event_data; 4438 struct mptsas_hotplug_event hot_plug_info; 4439 int status; 4440 int state; 4441 struct scsi_device *sdev = NULL; 4442 VirtDevice *vdevice = NULL; 4443 RaidPhysDiskPage0_t phys_disk; 4444 4445 ioc = fw_event->ioc; 4446 raid_event_data = (EVENT_DATA_RAID *)fw_event->event_data; 4447 status = le32_to_cpu(raid_event_data->SettingsStatus); 4448 state = (status >> 8) & 0xff; 4449 4450 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event)); 4451 hot_plug_info.id = raid_event_data->VolumeID; 4452 hot_plug_info.channel = raid_event_data->VolumeBus; 4453 hot_plug_info.phys_disk_num = raid_event_data->PhysDiskNum; 4454 4455 if (raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_DELETED || 4456 raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_CREATED || 4457 raid_event_data->ReasonCode == 4458 MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED) { 4459 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, 4460 hot_plug_info.id, 0); 4461 hot_plug_info.sdev = sdev; 4462 if (sdev) 4463 vdevice = sdev->hostdata; 4464 } 4465 4466 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: " 4467 "ReasonCode=%02x\n", ioc->name, __func__, 4468 raid_event_data->ReasonCode)); 4469 4470 switch (raid_event_data->ReasonCode) { 4471 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED: 4472 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK_REPROBE; 4473 break; 4474 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED: 4475 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK_REPROBE; 4476 break; 4477 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED: 4478 switch (state) { 4479 case MPI_PD_STATE_ONLINE: 4480 case MPI_PD_STATE_NOT_COMPATIBLE: 4481 mpt_raid_phys_disk_pg0(ioc, 4482 raid_event_data->PhysDiskNum, &phys_disk); 4483 hot_plug_info.id = phys_disk.PhysDiskID; 4484 hot_plug_info.channel = phys_disk.PhysDiskBus; 4485 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK; 4486 break; 4487 case MPI_PD_STATE_FAILED: 4488 case MPI_PD_STATE_MISSING: 4489 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST: 4490 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST: 4491 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON: 4492 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK; 4493 break; 4494 default: 4495 break; 4496 } 4497 break; 4498 case MPI_EVENT_RAID_RC_VOLUME_DELETED: 4499 if (!sdev) 4500 break; 4501 vdevice->vtarget->deleted = 1; /* block IO */ 4502 hot_plug_info.event_type = MPTSAS_DEL_RAID; 4503 break; 4504 case MPI_EVENT_RAID_RC_VOLUME_CREATED: 4505 if (sdev) { 4506 scsi_device_put(sdev); 4507 break; 4508 } 4509 hot_plug_info.event_type = MPTSAS_ADD_RAID; 4510 break; 4511 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED: 4512 if (!(status & MPI_RAIDVOL0_STATUS_FLAG_ENABLED)) { 4513 if (!sdev) 4514 break; 4515 vdevice->vtarget->deleted = 1; /* block IO */ 4516 hot_plug_info.event_type = MPTSAS_DEL_RAID; 4517 break; 4518 } 4519 switch (state) { 4520 case MPI_RAIDVOL0_STATUS_STATE_FAILED: 4521 case MPI_RAIDVOL0_STATUS_STATE_MISSING: 4522 if (!sdev) 4523 break; 4524 vdevice->vtarget->deleted = 1; /* block IO */ 4525 hot_plug_info.event_type = MPTSAS_DEL_RAID; 4526 break; 4527 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL: 4528 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED: 4529 if (sdev) { 4530 scsi_device_put(sdev); 4531 break; 4532 } 4533 hot_plug_info.event_type = MPTSAS_ADD_RAID; 4534 break; 4535 default: 4536 break; 4537 } 4538 break; 4539 default: 4540 break; 4541 } 4542 4543 if (hot_plug_info.event_type != MPTSAS_IGNORE_EVENT) 4544 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info); 4545 else 4546 mptsas_free_fw_event(ioc, fw_event); 4547 } 4548 4549 /** 4550 * mptsas_issue_tm - send mptsas internal tm request 4551 * @ioc: Pointer to MPT_ADAPTER structure 4552 * @type: Task Management type 4553 * @channel: channel number for task management 4554 * @id: Logical Target ID for reset (if appropriate) 4555 * @lun: Logical unit for reset (if appropriate) 4556 * @task_context: Context for the task to be aborted 4557 * @timeout: timeout for task management control 4558 * 4559 * return 0 on success and -1 on failure: 4560 * 4561 */ 4562 static int 4563 mptsas_issue_tm(MPT_ADAPTER *ioc, u8 type, u8 channel, u8 id, u64 lun, 4564 int task_context, ulong timeout, u8 *issue_reset) 4565 { 4566 MPT_FRAME_HDR *mf; 4567 SCSITaskMgmt_t *pScsiTm; 4568 int retval; 4569 unsigned long timeleft; 4570 4571 *issue_reset = 0; 4572 mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc); 4573 if (mf == NULL) { 4574 retval = -1; /* return failure */ 4575 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt request: no " 4576 "msg frames!!\n", ioc->name)); 4577 goto out; 4578 } 4579 4580 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request: mr = %p, " 4581 "task_type = 0x%02X,\n\t timeout = %ld, fw_channel = %d, " 4582 "fw_id = %d, lun = %lld,\n\t task_context = 0x%x\n", ioc->name, mf, 4583 type, timeout, channel, id, (unsigned long long)lun, 4584 task_context)); 4585 4586 pScsiTm = (SCSITaskMgmt_t *) mf; 4587 memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t)); 4588 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT; 4589 pScsiTm->TaskType = type; 4590 pScsiTm->MsgFlags = 0; 4591 pScsiTm->TargetID = id; 4592 pScsiTm->Bus = channel; 4593 pScsiTm->ChainOffset = 0; 4594 pScsiTm->Reserved = 0; 4595 pScsiTm->Reserved1 = 0; 4596 pScsiTm->TaskMsgContext = task_context; 4597 int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN); 4598 4599 INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status) 4600 CLEAR_MGMT_STATUS(ioc->internal_cmds.status) 4601 retval = 0; 4602 mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf); 4603 4604 /* Now wait for the command to complete */ 4605 timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, 4606 timeout*HZ); 4607 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) { 4608 retval = -1; /* return failure */ 4609 dtmprintk(ioc, printk(MYIOC_s_ERR_FMT 4610 "TaskMgmt request: TIMED OUT!(mr=%p)\n", ioc->name, mf)); 4611 mpt_free_msg_frame(ioc, mf); 4612 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) 4613 goto out; 4614 *issue_reset = 1; 4615 goto out; 4616 } 4617 4618 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) { 4619 retval = -1; /* return failure */ 4620 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 4621 "TaskMgmt request: failed with no reply\n", ioc->name)); 4622 goto out; 4623 } 4624 4625 out: 4626 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status) 4627 return retval; 4628 } 4629 4630 /** 4631 * mptsas_broadcast_primative_work - Handle broadcast primitives 4632 * @work: work queue payload containing info describing the event 4633 * 4634 * this will be handled in workqueue context. 4635 */ 4636 static void 4637 mptsas_broadcast_primative_work(struct fw_event_work *fw_event) 4638 { 4639 MPT_ADAPTER *ioc = fw_event->ioc; 4640 MPT_FRAME_HDR *mf; 4641 VirtDevice *vdevice; 4642 int ii; 4643 struct scsi_cmnd *sc; 4644 SCSITaskMgmtReply_t *pScsiTmReply; 4645 u8 issue_reset; 4646 int task_context; 4647 u8 channel, id; 4648 int lun; 4649 u32 termination_count; 4650 u32 query_count; 4651 4652 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 4653 "%s - enter\n", ioc->name, __func__)); 4654 4655 mutex_lock(&ioc->taskmgmt_cmds.mutex); 4656 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) { 4657 mutex_unlock(&ioc->taskmgmt_cmds.mutex); 4658 mptsas_requeue_fw_event(ioc, fw_event, 1000); 4659 return; 4660 } 4661 4662 issue_reset = 0; 4663 termination_count = 0; 4664 query_count = 0; 4665 mpt_findImVolumes(ioc); 4666 pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply; 4667 4668 for (ii = 0; ii < ioc->req_depth; ii++) { 4669 if (ioc->fw_events_off) 4670 goto out; 4671 sc = mptscsih_get_scsi_lookup(ioc, ii); 4672 if (!sc) 4673 continue; 4674 mf = MPT_INDEX_2_MFPTR(ioc, ii); 4675 if (!mf) 4676 continue; 4677 task_context = mf->u.frame.hwhdr.msgctxu.MsgContext; 4678 vdevice = sc->device->hostdata; 4679 if (!vdevice || !vdevice->vtarget) 4680 continue; 4681 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) 4682 continue; /* skip hidden raid components */ 4683 if (vdevice->vtarget->raidVolume) 4684 continue; /* skip hidden raid components */ 4685 channel = vdevice->vtarget->channel; 4686 id = vdevice->vtarget->id; 4687 lun = vdevice->lun; 4688 if (mptsas_issue_tm(ioc, MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK, 4689 channel, id, (u64)lun, task_context, 30, &issue_reset)) 4690 goto out; 4691 query_count++; 4692 termination_count += 4693 le32_to_cpu(pScsiTmReply->TerminationCount); 4694 if ((pScsiTmReply->IOCStatus == MPI_IOCSTATUS_SUCCESS) && 4695 (pScsiTmReply->ResponseCode == 4696 MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED || 4697 pScsiTmReply->ResponseCode == 4698 MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC)) 4699 continue; 4700 if (mptsas_issue_tm(ioc, 4701 MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET, 4702 channel, id, (u64)lun, 0, 30, &issue_reset)) 4703 goto out; 4704 termination_count += 4705 le32_to_cpu(pScsiTmReply->TerminationCount); 4706 } 4707 4708 out: 4709 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 4710 "%s - exit, query_count = %d termination_count = %d\n", 4711 ioc->name, __func__, query_count, termination_count)); 4712 4713 ioc->broadcast_aen_busy = 0; 4714 mpt_clear_taskmgmt_in_progress_flag(ioc); 4715 mutex_unlock(&ioc->taskmgmt_cmds.mutex); 4716 4717 if (issue_reset) { 4718 printk(MYIOC_s_WARN_FMT "Issuing Reset from %s!!\n", 4719 ioc->name, __func__); 4720 mpt_HardResetHandler(ioc, CAN_SLEEP); 4721 } 4722 mptsas_free_fw_event(ioc, fw_event); 4723 } 4724 4725 /* 4726 * mptsas_send_ir2_event - handle exposing hidden disk when 4727 * an inactive raid volume is added 4728 * 4729 * @ioc: Pointer to MPT_ADAPTER structure 4730 * @ir2_data 4731 * 4732 */ 4733 static void 4734 mptsas_send_ir2_event(struct fw_event_work *fw_event) 4735 { 4736 MPT_ADAPTER *ioc; 4737 struct mptsas_hotplug_event hot_plug_info; 4738 MPI_EVENT_DATA_IR2 *ir2_data; 4739 u8 reasonCode; 4740 RaidPhysDiskPage0_t phys_disk; 4741 4742 ioc = fw_event->ioc; 4743 ir2_data = (MPI_EVENT_DATA_IR2 *)fw_event->event_data; 4744 reasonCode = ir2_data->ReasonCode; 4745 4746 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: " 4747 "ReasonCode=%02x\n", ioc->name, __func__, reasonCode)); 4748 4749 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event)); 4750 hot_plug_info.id = ir2_data->TargetID; 4751 hot_plug_info.channel = ir2_data->Bus; 4752 switch (reasonCode) { 4753 case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED: 4754 hot_plug_info.event_type = MPTSAS_ADD_INACTIVE_VOLUME; 4755 break; 4756 case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED: 4757 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum; 4758 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK; 4759 break; 4760 case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED: 4761 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum; 4762 mpt_raid_phys_disk_pg0(ioc, 4763 ir2_data->PhysDiskNum, &phys_disk); 4764 hot_plug_info.id = phys_disk.PhysDiskID; 4765 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK; 4766 break; 4767 default: 4768 mptsas_free_fw_event(ioc, fw_event); 4769 return; 4770 } 4771 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info); 4772 } 4773 4774 static int 4775 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply) 4776 { 4777 u32 event = le32_to_cpu(reply->Event); 4778 int sz, event_data_sz; 4779 struct fw_event_work *fw_event; 4780 unsigned long delay; 4781 4782 /* events turned off due to host reset or driver unloading */ 4783 if (ioc->fw_events_off) 4784 return 0; 4785 4786 delay = msecs_to_jiffies(1); 4787 switch (event) { 4788 case MPI_EVENT_SAS_BROADCAST_PRIMITIVE: 4789 { 4790 EVENT_DATA_SAS_BROADCAST_PRIMITIVE *broadcast_event_data = 4791 (EVENT_DATA_SAS_BROADCAST_PRIMITIVE *)reply->Data; 4792 if (broadcast_event_data->Primitive != 4793 MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT) 4794 return 0; 4795 if (ioc->broadcast_aen_busy) 4796 return 0; 4797 ioc->broadcast_aen_busy = 1; 4798 break; 4799 } 4800 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE: 4801 { 4802 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data = 4803 (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data; 4804 4805 if (sas_event_data->ReasonCode == 4806 MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING) { 4807 mptsas_target_reset_queue(ioc, sas_event_data); 4808 return 0; 4809 } 4810 break; 4811 } 4812 case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE: 4813 { 4814 MpiEventDataSasExpanderStatusChange_t *expander_data = 4815 (MpiEventDataSasExpanderStatusChange_t *)reply->Data; 4816 4817 if (ioc->old_sas_discovery_protocal) 4818 return 0; 4819 4820 if (expander_data->ReasonCode == 4821 MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING && 4822 ioc->device_missing_delay) 4823 delay = HZ * ioc->device_missing_delay; 4824 break; 4825 } 4826 case MPI_EVENT_SAS_DISCOVERY: 4827 { 4828 u32 discovery_status; 4829 EventDataSasDiscovery_t *discovery_data = 4830 (EventDataSasDiscovery_t *)reply->Data; 4831 4832 discovery_status = le32_to_cpu(discovery_data->DiscoveryStatus); 4833 ioc->sas_discovery_quiesce_io = discovery_status ? 1 : 0; 4834 if (ioc->old_sas_discovery_protocal && !discovery_status) 4835 mptsas_queue_rescan(ioc); 4836 return 0; 4837 } 4838 case MPI_EVENT_INTEGRATED_RAID: 4839 case MPI_EVENT_PERSISTENT_TABLE_FULL: 4840 case MPI_EVENT_IR2: 4841 case MPI_EVENT_SAS_PHY_LINK_STATUS: 4842 case MPI_EVENT_QUEUE_FULL: 4843 break; 4844 default: 4845 return 0; 4846 } 4847 4848 event_data_sz = ((reply->MsgLength * 4) - 4849 offsetof(EventNotificationReply_t, Data)); 4850 sz = offsetof(struct fw_event_work, event_data) + event_data_sz; 4851 fw_event = kzalloc(sz, GFP_ATOMIC); 4852 if (!fw_event) { 4853 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", ioc->name, 4854 __func__, __LINE__); 4855 return 0; 4856 } 4857 memcpy(fw_event->event_data, reply->Data, event_data_sz); 4858 fw_event->event = event; 4859 fw_event->ioc = ioc; 4860 mptsas_add_fw_event(ioc, fw_event, delay); 4861 return 0; 4862 } 4863 4864 /* Delete a volume when no longer listed in ioc pg2 4865 */ 4866 static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id) 4867 { 4868 struct scsi_device *sdev; 4869 int i; 4870 4871 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, id, 0); 4872 if (!sdev) 4873 return; 4874 if (!ioc->raid_data.pIocPg2) 4875 goto out; 4876 if (!ioc->raid_data.pIocPg2->NumActiveVolumes) 4877 goto out; 4878 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) 4879 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) 4880 goto release_sdev; 4881 out: 4882 printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, " 4883 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, id); 4884 scsi_remove_device(sdev); 4885 release_sdev: 4886 scsi_device_put(sdev); 4887 } 4888 4889 static int 4890 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id) 4891 { 4892 struct Scsi_Host *sh; 4893 MPT_SCSI_HOST *hd; 4894 MPT_ADAPTER *ioc; 4895 unsigned long flags; 4896 int ii; 4897 int numSGE = 0; 4898 int scale; 4899 int ioc_cap; 4900 int error=0; 4901 int r; 4902 4903 r = mpt_attach(pdev,id); 4904 if (r) 4905 return r; 4906 4907 ioc = pci_get_drvdata(pdev); 4908 mptsas_fw_event_off(ioc); 4909 ioc->DoneCtx = mptsasDoneCtx; 4910 ioc->TaskCtx = mptsasTaskCtx; 4911 ioc->InternalCtx = mptsasInternalCtx; 4912 4913 /* Added sanity check on readiness of the MPT adapter. 4914 */ 4915 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) { 4916 printk(MYIOC_s_WARN_FMT 4917 "Skipping because it's not operational!\n", 4918 ioc->name); 4919 error = -ENODEV; 4920 goto out_mptsas_probe; 4921 } 4922 4923 if (!ioc->active) { 4924 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n", 4925 ioc->name); 4926 error = -ENODEV; 4927 goto out_mptsas_probe; 4928 } 4929 4930 /* Sanity check - ensure at least 1 port is INITIATOR capable 4931 */ 4932 ioc_cap = 0; 4933 for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) { 4934 if (ioc->pfacts[ii].ProtocolFlags & 4935 MPI_PORTFACTS_PROTOCOL_INITIATOR) 4936 ioc_cap++; 4937 } 4938 4939 if (!ioc_cap) { 4940 printk(MYIOC_s_WARN_FMT 4941 "Skipping ioc=%p because SCSI Initiator mode " 4942 "is NOT enabled!\n", ioc->name, ioc); 4943 return 0; 4944 } 4945 4946 sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST)); 4947 if (!sh) { 4948 printk(MYIOC_s_WARN_FMT 4949 "Unable to register controller with SCSI subsystem\n", 4950 ioc->name); 4951 error = -1; 4952 goto out_mptsas_probe; 4953 } 4954 4955 spin_lock_irqsave(&ioc->FreeQlock, flags); 4956 4957 /* Attach the SCSI Host to the IOC structure 4958 */ 4959 ioc->sh = sh; 4960 4961 sh->io_port = 0; 4962 sh->n_io_port = 0; 4963 sh->irq = 0; 4964 4965 /* set 16 byte cdb's */ 4966 sh->max_cmd_len = 16; 4967 sh->can_queue = min_t(int, ioc->req_depth - 10, sh->can_queue); 4968 sh->max_id = -1; 4969 sh->max_lun = max_lun; 4970 sh->transportt = mptsas_transport_template; 4971 4972 /* Required entry. 4973 */ 4974 sh->unique_id = ioc->id; 4975 4976 INIT_LIST_HEAD(&ioc->sas_topology); 4977 mutex_init(&ioc->sas_topology_mutex); 4978 mutex_init(&ioc->sas_discovery_mutex); 4979 mutex_init(&ioc->sas_mgmt.mutex); 4980 init_completion(&ioc->sas_mgmt.done); 4981 4982 /* Verify that we won't exceed the maximum 4983 * number of chain buffers 4984 * We can optimize: ZZ = req_sz/sizeof(SGE) 4985 * For 32bit SGE's: 4986 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ 4987 * + (req_sz - 64)/sizeof(SGE) 4988 * A slightly different algorithm is required for 4989 * 64bit SGEs. 4990 */ 4991 scale = ioc->req_sz/ioc->SGE_size; 4992 if (ioc->sg_addr_size == sizeof(u64)) { 4993 numSGE = (scale - 1) * 4994 (ioc->facts.MaxChainDepth-1) + scale + 4995 (ioc->req_sz - 60) / ioc->SGE_size; 4996 } else { 4997 numSGE = 1 + (scale - 1) * 4998 (ioc->facts.MaxChainDepth-1) + scale + 4999 (ioc->req_sz - 64) / ioc->SGE_size; 5000 } 5001 5002 if (numSGE < sh->sg_tablesize) { 5003 /* Reset this value */ 5004 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT 5005 "Resetting sg_tablesize to %d from %d\n", 5006 ioc->name, numSGE, sh->sg_tablesize)); 5007 sh->sg_tablesize = numSGE; 5008 } 5009 5010 hd = shost_priv(sh); 5011 hd->ioc = ioc; 5012 5013 /* SCSI needs scsi_cmnd lookup table! 5014 * (with size equal to req_depth*PtrSz!) 5015 */ 5016 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC); 5017 if (!ioc->ScsiLookup) { 5018 error = -ENOMEM; 5019 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 5020 goto out_mptsas_probe; 5021 } 5022 spin_lock_init(&ioc->scsi_lookup_lock); 5023 5024 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n", 5025 ioc->name, ioc->ScsiLookup)); 5026 5027 ioc->sas_data.ptClear = mpt_pt_clear; 5028 5029 hd->last_queue_full = 0; 5030 INIT_LIST_HEAD(&hd->target_reset_list); 5031 INIT_LIST_HEAD(&ioc->sas_device_info_list); 5032 mutex_init(&ioc->sas_device_info_mutex); 5033 5034 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 5035 5036 if (ioc->sas_data.ptClear==1) { 5037 mptbase_sas_persist_operation( 5038 ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT); 5039 } 5040 5041 error = scsi_add_host(sh, &ioc->pcidev->dev); 5042 if (error) { 5043 dprintk(ioc, printk(MYIOC_s_ERR_FMT 5044 "scsi_add_host failed\n", ioc->name)); 5045 goto out_mptsas_probe; 5046 } 5047 5048 /* older firmware doesn't support expander events */ 5049 if ((ioc->facts.HeaderVersion >> 8) < 0xE) 5050 ioc->old_sas_discovery_protocal = 1; 5051 mptsas_scan_sas_topology(ioc); 5052 mptsas_fw_event_on(ioc); 5053 return 0; 5054 5055 out_mptsas_probe: 5056 5057 mptscsih_remove(pdev); 5058 return error; 5059 } 5060 5061 void 5062 mptsas_shutdown(struct pci_dev *pdev) 5063 { 5064 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 5065 5066 mptsas_fw_event_off(ioc); 5067 mptsas_cleanup_fw_event_q(ioc); 5068 } 5069 5070 static void __devexit mptsas_remove(struct pci_dev *pdev) 5071 { 5072 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 5073 struct mptsas_portinfo *p, *n; 5074 int i; 5075 5076 mptsas_shutdown(pdev); 5077 5078 mptsas_del_device_components(ioc); 5079 5080 ioc->sas_discovery_ignore_events = 1; 5081 sas_remove_host(ioc->sh); 5082 5083 mutex_lock(&ioc->sas_topology_mutex); 5084 list_for_each_entry_safe(p, n, &ioc->sas_topology, list) { 5085 list_del(&p->list); 5086 for (i = 0 ; i < p->num_phys ; i++) 5087 mptsas_port_delete(ioc, p->phy_info[i].port_details); 5088 5089 kfree(p->phy_info); 5090 kfree(p); 5091 } 5092 mutex_unlock(&ioc->sas_topology_mutex); 5093 ioc->hba_port_info = NULL; 5094 mptscsih_remove(pdev); 5095 } 5096 5097 static struct pci_device_id mptsas_pci_table[] = { 5098 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064, 5099 PCI_ANY_ID, PCI_ANY_ID }, 5100 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068, 5101 PCI_ANY_ID, PCI_ANY_ID }, 5102 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E, 5103 PCI_ANY_ID, PCI_ANY_ID }, 5104 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E, 5105 PCI_ANY_ID, PCI_ANY_ID }, 5106 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078, 5107 PCI_ANY_ID, PCI_ANY_ID }, 5108 {0} /* Terminating entry */ 5109 }; 5110 MODULE_DEVICE_TABLE(pci, mptsas_pci_table); 5111 5112 5113 static struct pci_driver mptsas_driver = { 5114 .name = "mptsas", 5115 .id_table = mptsas_pci_table, 5116 .probe = mptsas_probe, 5117 .remove = __devexit_p(mptsas_remove), 5118 .shutdown = mptsas_shutdown, 5119 #ifdef CONFIG_PM 5120 .suspend = mptscsih_suspend, 5121 .resume = mptscsih_resume, 5122 #endif 5123 }; 5124 5125 static int __init 5126 mptsas_init(void) 5127 { 5128 int error; 5129 5130 show_mptmod_ver(my_NAME, my_VERSION); 5131 5132 mptsas_transport_template = 5133 sas_attach_transport(&mptsas_transport_functions); 5134 if (!mptsas_transport_template) 5135 return -ENODEV; 5136 5137 mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER); 5138 mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER); 5139 mptsasInternalCtx = 5140 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER); 5141 mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER); 5142 mptsasDeviceResetCtx = 5143 mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER); 5144 5145 mpt_event_register(mptsasDoneCtx, mptsas_event_process); 5146 mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset); 5147 5148 error = pci_register_driver(&mptsas_driver); 5149 if (error) 5150 sas_release_transport(mptsas_transport_template); 5151 5152 return error; 5153 } 5154 5155 static void __exit 5156 mptsas_exit(void) 5157 { 5158 pci_unregister_driver(&mptsas_driver); 5159 sas_release_transport(mptsas_transport_template); 5160 5161 mpt_reset_deregister(mptsasDoneCtx); 5162 mpt_event_deregister(mptsasDoneCtx); 5163 5164 mpt_deregister(mptsasMgmtCtx); 5165 mpt_deregister(mptsasInternalCtx); 5166 mpt_deregister(mptsasTaskCtx); 5167 mpt_deregister(mptsasDoneCtx); 5168 mpt_deregister(mptsasDeviceResetCtx); 5169 } 5170 5171 module_init(mptsas_init); 5172 module_exit(mptsas_exit); 5173