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