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