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 const 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 .dma_alignment = 511, 2024 .shost_groups = mptscsih_host_attr_groups, 2025 .no_write_same = 1, 2026 }; 2027 2028 static int mptsas_get_linkerrors(struct sas_phy *phy) 2029 { 2030 MPT_ADAPTER *ioc = phy_to_ioc(phy); 2031 ConfigExtendedPageHeader_t hdr; 2032 CONFIGPARMS cfg; 2033 SasPhyPage1_t *buffer; 2034 dma_addr_t dma_handle; 2035 int error; 2036 2037 /* FIXME: only have link errors on local phys */ 2038 if (!scsi_is_sas_phy_local(phy)) 2039 return -EINVAL; 2040 2041 hdr.PageVersion = MPI_SASPHY1_PAGEVERSION; 2042 hdr.ExtPageLength = 0; 2043 hdr.PageNumber = 1 /* page number 1*/; 2044 hdr.Reserved1 = 0; 2045 hdr.Reserved2 = 0; 2046 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2047 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY; 2048 2049 cfg.cfghdr.ehdr = &hdr; 2050 cfg.physAddr = -1; 2051 cfg.pageAddr = phy->identify.phy_identifier; 2052 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2053 cfg.dir = 0; /* read */ 2054 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2055 2056 error = mpt_config(ioc, &cfg); 2057 if (error) 2058 return error; 2059 if (!hdr.ExtPageLength) 2060 return -ENXIO; 2061 2062 buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, 2063 &dma_handle, GFP_KERNEL); 2064 if (!buffer) 2065 return -ENOMEM; 2066 2067 cfg.physAddr = dma_handle; 2068 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2069 2070 error = mpt_config(ioc, &cfg); 2071 if (error) 2072 goto out_free_consistent; 2073 2074 mptsas_print_phy_pg1(ioc, buffer); 2075 2076 phy->invalid_dword_count = le32_to_cpu(buffer->InvalidDwordCount); 2077 phy->running_disparity_error_count = 2078 le32_to_cpu(buffer->RunningDisparityErrorCount); 2079 phy->loss_of_dword_sync_count = 2080 le32_to_cpu(buffer->LossDwordSynchCount); 2081 phy->phy_reset_problem_count = 2082 le32_to_cpu(buffer->PhyResetProblemCount); 2083 2084 out_free_consistent: 2085 dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer, 2086 dma_handle); 2087 return error; 2088 } 2089 2090 static int mptsas_mgmt_done(MPT_ADAPTER *ioc, MPT_FRAME_HDR *req, 2091 MPT_FRAME_HDR *reply) 2092 { 2093 ioc->sas_mgmt.status |= MPT_MGMT_STATUS_COMMAND_GOOD; 2094 if (reply != NULL) { 2095 ioc->sas_mgmt.status |= MPT_MGMT_STATUS_RF_VALID; 2096 memcpy(ioc->sas_mgmt.reply, reply, 2097 min(ioc->reply_sz, 4 * reply->u.reply.MsgLength)); 2098 } 2099 2100 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_PENDING) { 2101 ioc->sas_mgmt.status &= ~MPT_MGMT_STATUS_PENDING; 2102 complete(&ioc->sas_mgmt.done); 2103 return 1; 2104 } 2105 return 0; 2106 } 2107 2108 static int mptsas_phy_reset(struct sas_phy *phy, int hard_reset) 2109 { 2110 MPT_ADAPTER *ioc = phy_to_ioc(phy); 2111 SasIoUnitControlRequest_t *req; 2112 SasIoUnitControlReply_t *reply; 2113 MPT_FRAME_HDR *mf; 2114 MPIHeader_t *hdr; 2115 unsigned long timeleft; 2116 int error = -ERESTARTSYS; 2117 2118 /* FIXME: fusion doesn't allow non-local phy reset */ 2119 if (!scsi_is_sas_phy_local(phy)) 2120 return -EINVAL; 2121 2122 /* not implemented for expanders */ 2123 if (phy->identify.target_port_protocols & SAS_PROTOCOL_SMP) 2124 return -ENXIO; 2125 2126 if (mutex_lock_interruptible(&ioc->sas_mgmt.mutex)) 2127 goto out; 2128 2129 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc); 2130 if (!mf) { 2131 error = -ENOMEM; 2132 goto out_unlock; 2133 } 2134 2135 hdr = (MPIHeader_t *) mf; 2136 req = (SasIoUnitControlRequest_t *)mf; 2137 memset(req, 0, sizeof(SasIoUnitControlRequest_t)); 2138 req->Function = MPI_FUNCTION_SAS_IO_UNIT_CONTROL; 2139 req->MsgContext = hdr->MsgContext; 2140 req->Operation = hard_reset ? 2141 MPI_SAS_OP_PHY_HARD_RESET : MPI_SAS_OP_PHY_LINK_RESET; 2142 req->PhyNum = phy->identify.phy_identifier; 2143 2144 INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status) 2145 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf); 2146 2147 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 2148 10 * HZ); 2149 if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) { 2150 error = -ETIME; 2151 mpt_free_msg_frame(ioc, mf); 2152 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET) 2153 goto out_unlock; 2154 if (!timeleft) 2155 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP); 2156 goto out_unlock; 2157 } 2158 2159 /* a reply frame is expected */ 2160 if ((ioc->sas_mgmt.status & 2161 MPT_MGMT_STATUS_RF_VALID) == 0) { 2162 error = -ENXIO; 2163 goto out_unlock; 2164 } 2165 2166 /* process the completed Reply Message Frame */ 2167 reply = (SasIoUnitControlReply_t *)ioc->sas_mgmt.reply; 2168 if (reply->IOCStatus != MPI_IOCSTATUS_SUCCESS) { 2169 printk(MYIOC_s_INFO_FMT "%s: IOCStatus=0x%X IOCLogInfo=0x%X\n", 2170 ioc->name, __func__, reply->IOCStatus, reply->IOCLogInfo); 2171 error = -ENXIO; 2172 goto out_unlock; 2173 } 2174 2175 error = 0; 2176 2177 out_unlock: 2178 CLEAR_MGMT_STATUS(ioc->sas_mgmt.status) 2179 mutex_unlock(&ioc->sas_mgmt.mutex); 2180 out: 2181 return error; 2182 } 2183 2184 static int 2185 mptsas_get_enclosure_identifier(struct sas_rphy *rphy, u64 *identifier) 2186 { 2187 MPT_ADAPTER *ioc = rphy_to_ioc(rphy); 2188 int i, error; 2189 struct mptsas_portinfo *p; 2190 struct mptsas_enclosure enclosure_info; 2191 u64 enclosure_handle; 2192 2193 mutex_lock(&ioc->sas_topology_mutex); 2194 list_for_each_entry(p, &ioc->sas_topology, list) { 2195 for (i = 0; i < p->num_phys; i++) { 2196 if (p->phy_info[i].attached.sas_address == 2197 rphy->identify.sas_address) { 2198 enclosure_handle = p->phy_info[i]. 2199 attached.handle_enclosure; 2200 goto found_info; 2201 } 2202 } 2203 } 2204 mutex_unlock(&ioc->sas_topology_mutex); 2205 return -ENXIO; 2206 2207 found_info: 2208 mutex_unlock(&ioc->sas_topology_mutex); 2209 memset(&enclosure_info, 0, sizeof(struct mptsas_enclosure)); 2210 error = mptsas_sas_enclosure_pg0(ioc, &enclosure_info, 2211 (MPI_SAS_ENCLOS_PGAD_FORM_HANDLE << 2212 MPI_SAS_ENCLOS_PGAD_FORM_SHIFT), enclosure_handle); 2213 if (!error) 2214 *identifier = enclosure_info.enclosure_logical_id; 2215 return error; 2216 } 2217 2218 static int 2219 mptsas_get_bay_identifier(struct sas_rphy *rphy) 2220 { 2221 MPT_ADAPTER *ioc = rphy_to_ioc(rphy); 2222 struct mptsas_portinfo *p; 2223 int i, rc; 2224 2225 mutex_lock(&ioc->sas_topology_mutex); 2226 list_for_each_entry(p, &ioc->sas_topology, list) { 2227 for (i = 0; i < p->num_phys; i++) { 2228 if (p->phy_info[i].attached.sas_address == 2229 rphy->identify.sas_address) { 2230 rc = p->phy_info[i].attached.slot; 2231 goto out; 2232 } 2233 } 2234 } 2235 rc = -ENXIO; 2236 out: 2237 mutex_unlock(&ioc->sas_topology_mutex); 2238 return rc; 2239 } 2240 2241 static void mptsas_smp_handler(struct bsg_job *job, struct Scsi_Host *shost, 2242 struct sas_rphy *rphy) 2243 { 2244 MPT_ADAPTER *ioc = ((MPT_SCSI_HOST *) shost->hostdata)->ioc; 2245 MPT_FRAME_HDR *mf; 2246 SmpPassthroughRequest_t *smpreq; 2247 int flagsLength; 2248 unsigned long timeleft; 2249 char *psge; 2250 u64 sas_address = 0; 2251 unsigned int reslen = 0; 2252 int ret = -EINVAL; 2253 2254 /* do we need to support multiple segments? */ 2255 if (job->request_payload.sg_cnt > 1 || 2256 job->reply_payload.sg_cnt > 1) { 2257 printk(MYIOC_s_ERR_FMT "%s: multiple segments req %u, rsp %u\n", 2258 ioc->name, __func__, job->request_payload.payload_len, 2259 job->reply_payload.payload_len); 2260 goto out; 2261 } 2262 2263 ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex); 2264 if (ret) 2265 goto out; 2266 2267 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc); 2268 if (!mf) { 2269 ret = -ENOMEM; 2270 goto out_unlock; 2271 } 2272 2273 smpreq = (SmpPassthroughRequest_t *)mf; 2274 memset(smpreq, 0, sizeof(*smpreq)); 2275 2276 smpreq->RequestDataLength = 2277 cpu_to_le16(job->request_payload.payload_len - 4); 2278 smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH; 2279 2280 if (rphy) 2281 sas_address = rphy->identify.sas_address; 2282 else { 2283 struct mptsas_portinfo *port_info; 2284 2285 mutex_lock(&ioc->sas_topology_mutex); 2286 port_info = ioc->hba_port_info; 2287 if (port_info && port_info->phy_info) 2288 sas_address = 2289 port_info->phy_info[0].phy->identify.sas_address; 2290 mutex_unlock(&ioc->sas_topology_mutex); 2291 } 2292 2293 *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address); 2294 2295 psge = (char *) 2296 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4)); 2297 2298 /* request */ 2299 flagsLength = (MPI_SGE_FLAGS_SIMPLE_ELEMENT | 2300 MPI_SGE_FLAGS_END_OF_BUFFER | 2301 MPI_SGE_FLAGS_DIRECTION) 2302 << MPI_SGE_FLAGS_SHIFT; 2303 2304 if (!dma_map_sg(&ioc->pcidev->dev, job->request_payload.sg_list, 2305 1, DMA_BIDIRECTIONAL)) 2306 goto put_mf; 2307 2308 flagsLength |= (sg_dma_len(job->request_payload.sg_list) - 4); 2309 ioc->add_sge(psge, flagsLength, 2310 sg_dma_address(job->request_payload.sg_list)); 2311 psge += ioc->SGE_size; 2312 2313 /* response */ 2314 flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT | 2315 MPI_SGE_FLAGS_SYSTEM_ADDRESS | 2316 MPI_SGE_FLAGS_IOC_TO_HOST | 2317 MPI_SGE_FLAGS_END_OF_BUFFER; 2318 2319 flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT; 2320 2321 if (!dma_map_sg(&ioc->pcidev->dev, job->reply_payload.sg_list, 2322 1, DMA_BIDIRECTIONAL)) 2323 goto unmap_out; 2324 flagsLength |= sg_dma_len(job->reply_payload.sg_list) + 4; 2325 ioc->add_sge(psge, flagsLength, 2326 sg_dma_address(job->reply_payload.sg_list)); 2327 2328 INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status) 2329 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf); 2330 2331 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ); 2332 if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) { 2333 ret = -ETIME; 2334 mpt_free_msg_frame(ioc, mf); 2335 mf = NULL; 2336 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET) 2337 goto unmap_in; 2338 if (!timeleft) 2339 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP); 2340 goto unmap_in; 2341 } 2342 mf = NULL; 2343 2344 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) { 2345 SmpPassthroughReply_t *smprep; 2346 2347 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply; 2348 memcpy(job->reply, smprep, sizeof(*smprep)); 2349 job->reply_len = sizeof(*smprep); 2350 reslen = smprep->ResponseDataLength; 2351 } else { 2352 printk(MYIOC_s_ERR_FMT 2353 "%s: smp passthru reply failed to be returned\n", 2354 ioc->name, __func__); 2355 ret = -ENXIO; 2356 } 2357 2358 unmap_in: 2359 dma_unmap_sg(&ioc->pcidev->dev, job->reply_payload.sg_list, 1, 2360 DMA_BIDIRECTIONAL); 2361 unmap_out: 2362 dma_unmap_sg(&ioc->pcidev->dev, job->request_payload.sg_list, 1, 2363 DMA_BIDIRECTIONAL); 2364 put_mf: 2365 if (mf) 2366 mpt_free_msg_frame(ioc, mf); 2367 out_unlock: 2368 CLEAR_MGMT_STATUS(ioc->sas_mgmt.status) 2369 mutex_unlock(&ioc->sas_mgmt.mutex); 2370 out: 2371 bsg_job_done(job, ret, reslen); 2372 } 2373 2374 static struct sas_function_template mptsas_transport_functions = { 2375 .get_linkerrors = mptsas_get_linkerrors, 2376 .get_enclosure_identifier = mptsas_get_enclosure_identifier, 2377 .get_bay_identifier = mptsas_get_bay_identifier, 2378 .phy_reset = mptsas_phy_reset, 2379 .smp_handler = mptsas_smp_handler, 2380 }; 2381 2382 static struct scsi_transport_template *mptsas_transport_template; 2383 2384 static int 2385 mptsas_sas_io_unit_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info) 2386 { 2387 ConfigExtendedPageHeader_t hdr; 2388 CONFIGPARMS cfg; 2389 SasIOUnitPage0_t *buffer; 2390 dma_addr_t dma_handle; 2391 int error, i; 2392 2393 hdr.PageVersion = MPI_SASIOUNITPAGE0_PAGEVERSION; 2394 hdr.ExtPageLength = 0; 2395 hdr.PageNumber = 0; 2396 hdr.Reserved1 = 0; 2397 hdr.Reserved2 = 0; 2398 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2399 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT; 2400 2401 cfg.cfghdr.ehdr = &hdr; 2402 cfg.physAddr = -1; 2403 cfg.pageAddr = 0; 2404 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2405 cfg.dir = 0; /* read */ 2406 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2407 2408 error = mpt_config(ioc, &cfg); 2409 if (error) 2410 goto out; 2411 if (!hdr.ExtPageLength) { 2412 error = -ENXIO; 2413 goto out; 2414 } 2415 2416 buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, 2417 &dma_handle, GFP_KERNEL); 2418 if (!buffer) { 2419 error = -ENOMEM; 2420 goto out; 2421 } 2422 2423 cfg.physAddr = dma_handle; 2424 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2425 2426 error = mpt_config(ioc, &cfg); 2427 if (error) 2428 goto out_free_consistent; 2429 2430 port_info->num_phys = buffer->NumPhys; 2431 port_info->phy_info = kcalloc(port_info->num_phys, 2432 sizeof(struct mptsas_phyinfo), GFP_KERNEL); 2433 if (!port_info->phy_info) { 2434 error = -ENOMEM; 2435 goto out_free_consistent; 2436 } 2437 2438 ioc->nvdata_version_persistent = 2439 le16_to_cpu(buffer->NvdataVersionPersistent); 2440 ioc->nvdata_version_default = 2441 le16_to_cpu(buffer->NvdataVersionDefault); 2442 2443 for (i = 0; i < port_info->num_phys; i++) { 2444 mptsas_print_phy_data(ioc, &buffer->PhyData[i]); 2445 port_info->phy_info[i].phy_id = i; 2446 port_info->phy_info[i].port_id = 2447 buffer->PhyData[i].Port; 2448 port_info->phy_info[i].negotiated_link_rate = 2449 buffer->PhyData[i].NegotiatedLinkRate; 2450 port_info->phy_info[i].portinfo = port_info; 2451 port_info->phy_info[i].handle = 2452 le16_to_cpu(buffer->PhyData[i].ControllerDevHandle); 2453 } 2454 2455 out_free_consistent: 2456 dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer, 2457 dma_handle); 2458 out: 2459 return error; 2460 } 2461 2462 static int 2463 mptsas_sas_io_unit_pg1(MPT_ADAPTER *ioc) 2464 { 2465 ConfigExtendedPageHeader_t hdr; 2466 CONFIGPARMS cfg; 2467 SasIOUnitPage1_t *buffer; 2468 dma_addr_t dma_handle; 2469 int error; 2470 u8 device_missing_delay; 2471 2472 memset(&hdr, 0, sizeof(ConfigExtendedPageHeader_t)); 2473 memset(&cfg, 0, sizeof(CONFIGPARMS)); 2474 2475 cfg.cfghdr.ehdr = &hdr; 2476 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2477 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2478 cfg.cfghdr.ehdr->PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2479 cfg.cfghdr.ehdr->ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_IO_UNIT; 2480 cfg.cfghdr.ehdr->PageVersion = MPI_SASIOUNITPAGE1_PAGEVERSION; 2481 cfg.cfghdr.ehdr->PageNumber = 1; 2482 2483 error = mpt_config(ioc, &cfg); 2484 if (error) 2485 goto out; 2486 if (!hdr.ExtPageLength) { 2487 error = -ENXIO; 2488 goto out; 2489 } 2490 2491 buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, 2492 &dma_handle, GFP_KERNEL); 2493 if (!buffer) { 2494 error = -ENOMEM; 2495 goto out; 2496 } 2497 2498 cfg.physAddr = dma_handle; 2499 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2500 2501 error = mpt_config(ioc, &cfg); 2502 if (error) 2503 goto out_free_consistent; 2504 2505 ioc->io_missing_delay = 2506 le16_to_cpu(buffer->IODeviceMissingDelay); 2507 device_missing_delay = buffer->ReportDeviceMissingDelay; 2508 ioc->device_missing_delay = (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_UNIT_16) ? 2509 (device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16 : 2510 device_missing_delay & MPI_SAS_IOUNIT1_REPORT_MISSING_TIMEOUT_MASK; 2511 2512 out_free_consistent: 2513 dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer, 2514 dma_handle); 2515 out: 2516 return error; 2517 } 2518 2519 static int 2520 mptsas_sas_phy_pg0(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, 2521 u32 form, u32 form_specific) 2522 { 2523 ConfigExtendedPageHeader_t hdr; 2524 CONFIGPARMS cfg; 2525 SasPhyPage0_t *buffer; 2526 dma_addr_t dma_handle; 2527 int error; 2528 2529 hdr.PageVersion = MPI_SASPHY0_PAGEVERSION; 2530 hdr.ExtPageLength = 0; 2531 hdr.PageNumber = 0; 2532 hdr.Reserved1 = 0; 2533 hdr.Reserved2 = 0; 2534 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2535 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_PHY; 2536 2537 cfg.cfghdr.ehdr = &hdr; 2538 cfg.dir = 0; /* read */ 2539 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2540 2541 /* Get Phy Pg 0 for each Phy. */ 2542 cfg.physAddr = -1; 2543 cfg.pageAddr = form + form_specific; 2544 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2545 2546 error = mpt_config(ioc, &cfg); 2547 if (error) 2548 goto out; 2549 2550 if (!hdr.ExtPageLength) { 2551 error = -ENXIO; 2552 goto out; 2553 } 2554 2555 buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, 2556 &dma_handle, GFP_KERNEL); 2557 if (!buffer) { 2558 error = -ENOMEM; 2559 goto out; 2560 } 2561 2562 cfg.physAddr = dma_handle; 2563 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2564 2565 error = mpt_config(ioc, &cfg); 2566 if (error) 2567 goto out_free_consistent; 2568 2569 mptsas_print_phy_pg0(ioc, buffer); 2570 2571 phy_info->hw_link_rate = buffer->HwLinkRate; 2572 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate; 2573 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle); 2574 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle); 2575 2576 out_free_consistent: 2577 dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer, 2578 dma_handle); 2579 out: 2580 return error; 2581 } 2582 2583 static int 2584 mptsas_sas_device_pg0(MPT_ADAPTER *ioc, struct mptsas_devinfo *device_info, 2585 u32 form, u32 form_specific) 2586 { 2587 ConfigExtendedPageHeader_t hdr; 2588 CONFIGPARMS cfg; 2589 SasDevicePage0_t *buffer; 2590 dma_addr_t dma_handle; 2591 __le64 sas_address; 2592 int error=0; 2593 2594 hdr.PageVersion = MPI_SASDEVICE0_PAGEVERSION; 2595 hdr.ExtPageLength = 0; 2596 hdr.PageNumber = 0; 2597 hdr.Reserved1 = 0; 2598 hdr.Reserved2 = 0; 2599 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2600 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_DEVICE; 2601 2602 cfg.cfghdr.ehdr = &hdr; 2603 cfg.pageAddr = form + form_specific; 2604 cfg.physAddr = -1; 2605 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2606 cfg.dir = 0; /* read */ 2607 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2608 2609 memset(device_info, 0, sizeof(struct mptsas_devinfo)); 2610 error = mpt_config(ioc, &cfg); 2611 if (error) 2612 goto out; 2613 if (!hdr.ExtPageLength) { 2614 error = -ENXIO; 2615 goto out; 2616 } 2617 2618 buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, 2619 &dma_handle, GFP_KERNEL); 2620 if (!buffer) { 2621 error = -ENOMEM; 2622 goto out; 2623 } 2624 2625 cfg.physAddr = dma_handle; 2626 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2627 2628 error = mpt_config(ioc, &cfg); 2629 2630 if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) { 2631 error = -ENODEV; 2632 goto out_free_consistent; 2633 } 2634 2635 if (error) 2636 goto out_free_consistent; 2637 2638 mptsas_print_device_pg0(ioc, buffer); 2639 2640 memset(device_info, 0, sizeof(struct mptsas_devinfo)); 2641 device_info->handle = le16_to_cpu(buffer->DevHandle); 2642 device_info->handle_parent = le16_to_cpu(buffer->ParentDevHandle); 2643 device_info->handle_enclosure = 2644 le16_to_cpu(buffer->EnclosureHandle); 2645 device_info->slot = le16_to_cpu(buffer->Slot); 2646 device_info->phy_id = buffer->PhyNum; 2647 device_info->port_id = buffer->PhysicalPort; 2648 device_info->id = buffer->TargetID; 2649 device_info->phys_disk_num = ~0; 2650 device_info->channel = buffer->Bus; 2651 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64)); 2652 device_info->sas_address = le64_to_cpu(sas_address); 2653 device_info->device_info = 2654 le32_to_cpu(buffer->DeviceInfo); 2655 device_info->flags = le16_to_cpu(buffer->Flags); 2656 2657 out_free_consistent: 2658 dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer, 2659 dma_handle); 2660 out: 2661 return error; 2662 } 2663 2664 static int 2665 mptsas_sas_expander_pg0(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info, 2666 u32 form, u32 form_specific) 2667 { 2668 ConfigExtendedPageHeader_t hdr; 2669 CONFIGPARMS cfg; 2670 SasExpanderPage0_t *buffer; 2671 dma_addr_t dma_handle; 2672 int i, error; 2673 __le64 sas_address; 2674 2675 memset(port_info, 0, sizeof(struct mptsas_portinfo)); 2676 hdr.PageVersion = MPI_SASEXPANDER0_PAGEVERSION; 2677 hdr.ExtPageLength = 0; 2678 hdr.PageNumber = 0; 2679 hdr.Reserved1 = 0; 2680 hdr.Reserved2 = 0; 2681 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2682 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER; 2683 2684 cfg.cfghdr.ehdr = &hdr; 2685 cfg.physAddr = -1; 2686 cfg.pageAddr = form + form_specific; 2687 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2688 cfg.dir = 0; /* read */ 2689 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2690 2691 memset(port_info, 0, sizeof(struct mptsas_portinfo)); 2692 error = mpt_config(ioc, &cfg); 2693 if (error) 2694 goto out; 2695 2696 if (!hdr.ExtPageLength) { 2697 error = -ENXIO; 2698 goto out; 2699 } 2700 2701 buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, 2702 &dma_handle, GFP_KERNEL); 2703 if (!buffer) { 2704 error = -ENOMEM; 2705 goto out; 2706 } 2707 2708 cfg.physAddr = dma_handle; 2709 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2710 2711 error = mpt_config(ioc, &cfg); 2712 if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) { 2713 error = -ENODEV; 2714 goto out_free_consistent; 2715 } 2716 2717 if (error) 2718 goto out_free_consistent; 2719 2720 /* save config data */ 2721 port_info->num_phys = (buffer->NumPhys) ? buffer->NumPhys : 1; 2722 port_info->phy_info = kcalloc(port_info->num_phys, 2723 sizeof(struct mptsas_phyinfo), GFP_KERNEL); 2724 if (!port_info->phy_info) { 2725 error = -ENOMEM; 2726 goto out_free_consistent; 2727 } 2728 2729 memcpy(&sas_address, &buffer->SASAddress, sizeof(__le64)); 2730 for (i = 0; i < port_info->num_phys; i++) { 2731 port_info->phy_info[i].portinfo = port_info; 2732 port_info->phy_info[i].handle = 2733 le16_to_cpu(buffer->DevHandle); 2734 port_info->phy_info[i].identify.sas_address = 2735 le64_to_cpu(sas_address); 2736 port_info->phy_info[i].identify.handle_parent = 2737 le16_to_cpu(buffer->ParentDevHandle); 2738 } 2739 2740 out_free_consistent: 2741 dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer, 2742 dma_handle); 2743 out: 2744 return error; 2745 } 2746 2747 static int 2748 mptsas_sas_expander_pg1(MPT_ADAPTER *ioc, struct mptsas_phyinfo *phy_info, 2749 u32 form, u32 form_specific) 2750 { 2751 ConfigExtendedPageHeader_t hdr; 2752 CONFIGPARMS cfg; 2753 SasExpanderPage1_t *buffer; 2754 dma_addr_t dma_handle; 2755 int error=0; 2756 2757 hdr.PageVersion = MPI_SASEXPANDER1_PAGEVERSION; 2758 hdr.ExtPageLength = 0; 2759 hdr.PageNumber = 1; 2760 hdr.Reserved1 = 0; 2761 hdr.Reserved2 = 0; 2762 hdr.PageType = MPI_CONFIG_PAGETYPE_EXTENDED; 2763 hdr.ExtPageType = MPI_CONFIG_EXTPAGETYPE_SAS_EXPANDER; 2764 2765 cfg.cfghdr.ehdr = &hdr; 2766 cfg.physAddr = -1; 2767 cfg.pageAddr = form + form_specific; 2768 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 2769 cfg.dir = 0; /* read */ 2770 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 2771 2772 error = mpt_config(ioc, &cfg); 2773 if (error) 2774 goto out; 2775 2776 if (!hdr.ExtPageLength) { 2777 error = -ENXIO; 2778 goto out; 2779 } 2780 2781 buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, 2782 &dma_handle, GFP_KERNEL); 2783 if (!buffer) { 2784 error = -ENOMEM; 2785 goto out; 2786 } 2787 2788 cfg.physAddr = dma_handle; 2789 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 2790 2791 error = mpt_config(ioc, &cfg); 2792 2793 if (error == MPI_IOCSTATUS_CONFIG_INVALID_PAGE) { 2794 error = -ENODEV; 2795 goto out_free_consistent; 2796 } 2797 2798 if (error) 2799 goto out_free_consistent; 2800 2801 2802 mptsas_print_expander_pg1(ioc, buffer); 2803 2804 /* save config data */ 2805 phy_info->phy_id = buffer->PhyIdentifier; 2806 phy_info->port_id = buffer->PhysicalPort; 2807 phy_info->negotiated_link_rate = buffer->NegotiatedLinkRate; 2808 phy_info->programmed_link_rate = buffer->ProgrammedLinkRate; 2809 phy_info->hw_link_rate = buffer->HwLinkRate; 2810 phy_info->identify.handle = le16_to_cpu(buffer->OwnerDevHandle); 2811 phy_info->attached.handle = le16_to_cpu(buffer->AttachedDevHandle); 2812 2813 out_free_consistent: 2814 dma_free_coherent(&ioc->pcidev->dev, hdr.ExtPageLength * 4, buffer, 2815 dma_handle); 2816 out: 2817 return error; 2818 } 2819 2820 struct rep_manu_request{ 2821 u8 smp_frame_type; 2822 u8 function; 2823 u8 reserved; 2824 u8 request_length; 2825 }; 2826 2827 struct rep_manu_reply{ 2828 u8 smp_frame_type; /* 0x41 */ 2829 u8 function; /* 0x01 */ 2830 u8 function_result; 2831 u8 response_length; 2832 u16 expander_change_count; 2833 u8 reserved0[2]; 2834 u8 sas_format:1; 2835 u8 reserved1:7; 2836 u8 reserved2[3]; 2837 u8 vendor_id[SAS_EXPANDER_VENDOR_ID_LEN]; 2838 u8 product_id[SAS_EXPANDER_PRODUCT_ID_LEN]; 2839 u8 product_rev[SAS_EXPANDER_PRODUCT_REV_LEN]; 2840 u8 component_vendor_id[SAS_EXPANDER_COMPONENT_VENDOR_ID_LEN]; 2841 u16 component_id; 2842 u8 component_revision_id; 2843 u8 reserved3; 2844 u8 vendor_specific[8]; 2845 }; 2846 2847 /** 2848 * mptsas_exp_repmanufacture_info - sets expander manufacturer info 2849 * @ioc: per adapter object 2850 * @sas_address: expander sas address 2851 * @edev: the sas_expander_device object 2852 * 2853 * For an edge expander or a fanout expander: 2854 * fills in the sas_expander_device object when SMP port is created. 2855 * 2856 * Return: 0 for success, non-zero for failure. 2857 */ 2858 static int 2859 mptsas_exp_repmanufacture_info(MPT_ADAPTER *ioc, 2860 u64 sas_address, struct sas_expander_device *edev) 2861 { 2862 MPT_FRAME_HDR *mf; 2863 SmpPassthroughRequest_t *smpreq; 2864 SmpPassthroughReply_t *smprep; 2865 struct rep_manu_reply *manufacture_reply; 2866 struct rep_manu_request *manufacture_request; 2867 int ret; 2868 int flagsLength; 2869 unsigned long timeleft; 2870 char *psge; 2871 unsigned long flags; 2872 void *data_out = NULL; 2873 dma_addr_t data_out_dma = 0; 2874 u32 sz; 2875 2876 spin_lock_irqsave(&ioc->taskmgmt_lock, flags); 2877 if (ioc->ioc_reset_in_progress) { 2878 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags); 2879 printk(MYIOC_s_INFO_FMT "%s: host reset in progress!\n", 2880 __func__, ioc->name); 2881 return -EFAULT; 2882 } 2883 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags); 2884 2885 ret = mutex_lock_interruptible(&ioc->sas_mgmt.mutex); 2886 if (ret) 2887 goto out; 2888 2889 mf = mpt_get_msg_frame(mptsasMgmtCtx, ioc); 2890 if (!mf) { 2891 ret = -ENOMEM; 2892 goto out_unlock; 2893 } 2894 2895 smpreq = (SmpPassthroughRequest_t *)mf; 2896 memset(smpreq, 0, sizeof(*smpreq)); 2897 2898 sz = sizeof(struct rep_manu_request) + sizeof(struct rep_manu_reply); 2899 2900 data_out = dma_alloc_coherent(&ioc->pcidev->dev, sz, &data_out_dma, 2901 GFP_KERNEL); 2902 if (!data_out) { 2903 printk(KERN_ERR "Memory allocation failure at %s:%d/%s()!\n", 2904 __FILE__, __LINE__, __func__); 2905 ret = -ENOMEM; 2906 goto put_mf; 2907 } 2908 2909 manufacture_request = data_out; 2910 manufacture_request->smp_frame_type = 0x40; 2911 manufacture_request->function = 1; 2912 manufacture_request->reserved = 0; 2913 manufacture_request->request_length = 0; 2914 2915 smpreq->Function = MPI_FUNCTION_SMP_PASSTHROUGH; 2916 smpreq->PhysicalPort = 0xFF; 2917 *((u64 *)&smpreq->SASAddress) = cpu_to_le64(sas_address); 2918 smpreq->RequestDataLength = sizeof(struct rep_manu_request); 2919 2920 psge = (char *) 2921 (((int *) mf) + (offsetof(SmpPassthroughRequest_t, SGL) / 4)); 2922 2923 flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT | 2924 MPI_SGE_FLAGS_SYSTEM_ADDRESS | 2925 MPI_SGE_FLAGS_HOST_TO_IOC | 2926 MPI_SGE_FLAGS_END_OF_BUFFER; 2927 flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT; 2928 flagsLength |= sizeof(struct rep_manu_request); 2929 2930 ioc->add_sge(psge, flagsLength, data_out_dma); 2931 psge += ioc->SGE_size; 2932 2933 flagsLength = MPI_SGE_FLAGS_SIMPLE_ELEMENT | 2934 MPI_SGE_FLAGS_SYSTEM_ADDRESS | 2935 MPI_SGE_FLAGS_IOC_TO_HOST | 2936 MPI_SGE_FLAGS_END_OF_BUFFER; 2937 flagsLength = flagsLength << MPI_SGE_FLAGS_SHIFT; 2938 flagsLength |= sizeof(struct rep_manu_reply); 2939 ioc->add_sge(psge, flagsLength, data_out_dma + 2940 sizeof(struct rep_manu_request)); 2941 2942 INITIALIZE_MGMT_STATUS(ioc->sas_mgmt.status) 2943 mpt_put_msg_frame(mptsasMgmtCtx, ioc, mf); 2944 2945 timeleft = wait_for_completion_timeout(&ioc->sas_mgmt.done, 10 * HZ); 2946 if (!(ioc->sas_mgmt.status & MPT_MGMT_STATUS_COMMAND_GOOD)) { 2947 ret = -ETIME; 2948 mpt_free_msg_frame(ioc, mf); 2949 mf = NULL; 2950 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_DID_IOCRESET) 2951 goto out_free; 2952 if (!timeleft) 2953 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP); 2954 goto out_free; 2955 } 2956 2957 mf = NULL; 2958 2959 if (ioc->sas_mgmt.status & MPT_MGMT_STATUS_RF_VALID) { 2960 u8 *tmp; 2961 2962 smprep = (SmpPassthroughReply_t *)ioc->sas_mgmt.reply; 2963 if (le16_to_cpu(smprep->ResponseDataLength) != 2964 sizeof(struct rep_manu_reply)) 2965 goto out_free; 2966 2967 manufacture_reply = data_out + sizeof(struct rep_manu_request); 2968 strscpy(edev->vendor_id, manufacture_reply->vendor_id, 2969 sizeof(edev->vendor_id)); 2970 strscpy(edev->product_id, manufacture_reply->product_id, 2971 sizeof(edev->product_id)); 2972 strscpy(edev->product_rev, manufacture_reply->product_rev, 2973 sizeof(edev->product_rev)); 2974 edev->level = manufacture_reply->sas_format; 2975 if (manufacture_reply->sas_format) { 2976 strscpy(edev->component_vendor_id, 2977 manufacture_reply->component_vendor_id, 2978 sizeof(edev->component_vendor_id)); 2979 tmp = (u8 *)&manufacture_reply->component_id; 2980 edev->component_id = tmp[0] << 8 | tmp[1]; 2981 edev->component_revision_id = 2982 manufacture_reply->component_revision_id; 2983 } 2984 } else { 2985 printk(MYIOC_s_ERR_FMT 2986 "%s: smp passthru reply failed to be returned\n", 2987 ioc->name, __func__); 2988 ret = -ENXIO; 2989 } 2990 out_free: 2991 if (data_out_dma) 2992 dma_free_coherent(&ioc->pcidev->dev, sz, data_out, 2993 data_out_dma); 2994 put_mf: 2995 if (mf) 2996 mpt_free_msg_frame(ioc, mf); 2997 out_unlock: 2998 CLEAR_MGMT_STATUS(ioc->sas_mgmt.status) 2999 mutex_unlock(&ioc->sas_mgmt.mutex); 3000 out: 3001 return ret; 3002 } 3003 3004 static void 3005 mptsas_parse_device_info(struct sas_identify *identify, 3006 struct mptsas_devinfo *device_info) 3007 { 3008 u16 protocols; 3009 3010 identify->sas_address = device_info->sas_address; 3011 identify->phy_identifier = device_info->phy_id; 3012 3013 /* 3014 * Fill in Phy Initiator Port Protocol. 3015 * Bits 6:3, more than one bit can be set, fall through cases. 3016 */ 3017 protocols = device_info->device_info & 0x78; 3018 identify->initiator_port_protocols = 0; 3019 if (protocols & MPI_SAS_DEVICE_INFO_SSP_INITIATOR) 3020 identify->initiator_port_protocols |= SAS_PROTOCOL_SSP; 3021 if (protocols & MPI_SAS_DEVICE_INFO_STP_INITIATOR) 3022 identify->initiator_port_protocols |= SAS_PROTOCOL_STP; 3023 if (protocols & MPI_SAS_DEVICE_INFO_SMP_INITIATOR) 3024 identify->initiator_port_protocols |= SAS_PROTOCOL_SMP; 3025 if (protocols & MPI_SAS_DEVICE_INFO_SATA_HOST) 3026 identify->initiator_port_protocols |= SAS_PROTOCOL_SATA; 3027 3028 /* 3029 * Fill in Phy Target Port Protocol. 3030 * Bits 10:7, more than one bit can be set, fall through cases. 3031 */ 3032 protocols = device_info->device_info & 0x780; 3033 identify->target_port_protocols = 0; 3034 if (protocols & MPI_SAS_DEVICE_INFO_SSP_TARGET) 3035 identify->target_port_protocols |= SAS_PROTOCOL_SSP; 3036 if (protocols & MPI_SAS_DEVICE_INFO_STP_TARGET) 3037 identify->target_port_protocols |= SAS_PROTOCOL_STP; 3038 if (protocols & MPI_SAS_DEVICE_INFO_SMP_TARGET) 3039 identify->target_port_protocols |= SAS_PROTOCOL_SMP; 3040 if (protocols & MPI_SAS_DEVICE_INFO_SATA_DEVICE) 3041 identify->target_port_protocols |= SAS_PROTOCOL_SATA; 3042 3043 /* 3044 * Fill in Attached device type. 3045 */ 3046 switch (device_info->device_info & 3047 MPI_SAS_DEVICE_INFO_MASK_DEVICE_TYPE) { 3048 case MPI_SAS_DEVICE_INFO_NO_DEVICE: 3049 identify->device_type = SAS_PHY_UNUSED; 3050 break; 3051 case MPI_SAS_DEVICE_INFO_END_DEVICE: 3052 identify->device_type = SAS_END_DEVICE; 3053 break; 3054 case MPI_SAS_DEVICE_INFO_EDGE_EXPANDER: 3055 identify->device_type = SAS_EDGE_EXPANDER_DEVICE; 3056 break; 3057 case MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER: 3058 identify->device_type = SAS_FANOUT_EXPANDER_DEVICE; 3059 break; 3060 } 3061 } 3062 3063 static int mptsas_probe_one_phy(struct device *dev, 3064 struct mptsas_phyinfo *phy_info, int index, int local) 3065 { 3066 MPT_ADAPTER *ioc; 3067 struct sas_phy *phy; 3068 struct sas_port *port; 3069 int error = 0; 3070 VirtTarget *vtarget; 3071 3072 if (!dev) { 3073 error = -ENODEV; 3074 goto out; 3075 } 3076 3077 if (!phy_info->phy) { 3078 phy = sas_phy_alloc(dev, index); 3079 if (!phy) { 3080 error = -ENOMEM; 3081 goto out; 3082 } 3083 } else 3084 phy = phy_info->phy; 3085 3086 mptsas_parse_device_info(&phy->identify, &phy_info->identify); 3087 3088 /* 3089 * Set Negotiated link rate. 3090 */ 3091 switch (phy_info->negotiated_link_rate) { 3092 case MPI_SAS_IOUNIT0_RATE_PHY_DISABLED: 3093 phy->negotiated_linkrate = SAS_PHY_DISABLED; 3094 break; 3095 case MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION: 3096 phy->negotiated_linkrate = SAS_LINK_RATE_FAILED; 3097 break; 3098 case MPI_SAS_IOUNIT0_RATE_1_5: 3099 phy->negotiated_linkrate = SAS_LINK_RATE_1_5_GBPS; 3100 break; 3101 case MPI_SAS_IOUNIT0_RATE_3_0: 3102 phy->negotiated_linkrate = SAS_LINK_RATE_3_0_GBPS; 3103 break; 3104 case MPI_SAS_IOUNIT0_RATE_6_0: 3105 phy->negotiated_linkrate = SAS_LINK_RATE_6_0_GBPS; 3106 break; 3107 case MPI_SAS_IOUNIT0_RATE_SATA_OOB_COMPLETE: 3108 case MPI_SAS_IOUNIT0_RATE_UNKNOWN: 3109 default: 3110 phy->negotiated_linkrate = SAS_LINK_RATE_UNKNOWN; 3111 break; 3112 } 3113 3114 /* 3115 * Set Max hardware link rate. 3116 */ 3117 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) { 3118 case MPI_SAS_PHY0_HWRATE_MAX_RATE_1_5: 3119 phy->maximum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS; 3120 break; 3121 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0: 3122 phy->maximum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS; 3123 break; 3124 default: 3125 break; 3126 } 3127 3128 /* 3129 * Set Max programmed link rate. 3130 */ 3131 switch (phy_info->programmed_link_rate & 3132 MPI_SAS_PHY0_PRATE_MAX_RATE_MASK) { 3133 case MPI_SAS_PHY0_PRATE_MAX_RATE_1_5: 3134 phy->maximum_linkrate = SAS_LINK_RATE_1_5_GBPS; 3135 break; 3136 case MPI_SAS_PHY0_PRATE_MAX_RATE_3_0: 3137 phy->maximum_linkrate = SAS_LINK_RATE_3_0_GBPS; 3138 break; 3139 default: 3140 break; 3141 } 3142 3143 /* 3144 * Set Min hardware link rate. 3145 */ 3146 switch (phy_info->hw_link_rate & MPI_SAS_PHY0_HWRATE_MIN_RATE_MASK) { 3147 case MPI_SAS_PHY0_HWRATE_MIN_RATE_1_5: 3148 phy->minimum_linkrate_hw = SAS_LINK_RATE_1_5_GBPS; 3149 break; 3150 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0: 3151 phy->minimum_linkrate_hw = SAS_LINK_RATE_3_0_GBPS; 3152 break; 3153 default: 3154 break; 3155 } 3156 3157 /* 3158 * Set Min programmed link rate. 3159 */ 3160 switch (phy_info->programmed_link_rate & 3161 MPI_SAS_PHY0_PRATE_MIN_RATE_MASK) { 3162 case MPI_SAS_PHY0_PRATE_MIN_RATE_1_5: 3163 phy->minimum_linkrate = SAS_LINK_RATE_1_5_GBPS; 3164 break; 3165 case MPI_SAS_PHY0_PRATE_MIN_RATE_3_0: 3166 phy->minimum_linkrate = SAS_LINK_RATE_3_0_GBPS; 3167 break; 3168 default: 3169 break; 3170 } 3171 3172 if (!phy_info->phy) { 3173 3174 error = sas_phy_add(phy); 3175 if (error) { 3176 sas_phy_free(phy); 3177 goto out; 3178 } 3179 phy_info->phy = phy; 3180 } 3181 3182 if (!phy_info->attached.handle || 3183 !phy_info->port_details) 3184 goto out; 3185 3186 port = mptsas_get_port(phy_info); 3187 ioc = phy_to_ioc(phy_info->phy); 3188 3189 if (phy_info->sas_port_add_phy) { 3190 3191 if (!port) { 3192 port = sas_port_alloc_num(dev); 3193 if (!port) { 3194 error = -ENOMEM; 3195 goto out; 3196 } 3197 error = sas_port_add(port); 3198 if (error) { 3199 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 3200 "%s: exit at line=%d\n", ioc->name, 3201 __func__, __LINE__)); 3202 goto out; 3203 } 3204 mptsas_set_port(ioc, phy_info, port); 3205 devtprintk(ioc, dev_printk(KERN_DEBUG, &port->dev, 3206 MYIOC_s_FMT "add port %d, sas_addr (0x%llx)\n", 3207 ioc->name, port->port_identifier, 3208 (unsigned long long)phy_info-> 3209 attached.sas_address)); 3210 } 3211 dsaswideprintk(ioc, printk(MYIOC_s_DEBUG_FMT 3212 "sas_port_add_phy: phy_id=%d\n", 3213 ioc->name, phy_info->phy_id)); 3214 sas_port_add_phy(port, phy_info->phy); 3215 phy_info->sas_port_add_phy = 0; 3216 devtprintk(ioc, dev_printk(KERN_DEBUG, &phy_info->phy->dev, 3217 MYIOC_s_FMT "add phy %d, phy-obj (0x%p)\n", ioc->name, 3218 phy_info->phy_id, phy_info->phy)); 3219 } 3220 if (!mptsas_get_rphy(phy_info) && port && !port->rphy) { 3221 3222 struct sas_rphy *rphy; 3223 struct device *parent; 3224 struct sas_identify identify; 3225 3226 parent = dev->parent->parent; 3227 /* 3228 * Let the hotplug_work thread handle processing 3229 * the adding/removing of devices that occur 3230 * after start of day. 3231 */ 3232 if (mptsas_is_end_device(&phy_info->attached) && 3233 phy_info->attached.handle_parent) { 3234 goto out; 3235 } 3236 3237 mptsas_parse_device_info(&identify, &phy_info->attached); 3238 if (scsi_is_host_device(parent)) { 3239 struct mptsas_portinfo *port_info; 3240 int i; 3241 3242 port_info = ioc->hba_port_info; 3243 3244 for (i = 0; i < port_info->num_phys; i++) 3245 if (port_info->phy_info[i].identify.sas_address == 3246 identify.sas_address) { 3247 sas_port_mark_backlink(port); 3248 goto out; 3249 } 3250 3251 } else if (scsi_is_sas_rphy(parent)) { 3252 struct sas_rphy *parent_rphy = dev_to_rphy(parent); 3253 if (identify.sas_address == 3254 parent_rphy->identify.sas_address) { 3255 sas_port_mark_backlink(port); 3256 goto out; 3257 } 3258 } 3259 3260 switch (identify.device_type) { 3261 case SAS_END_DEVICE: 3262 rphy = sas_end_device_alloc(port); 3263 break; 3264 case SAS_EDGE_EXPANDER_DEVICE: 3265 case SAS_FANOUT_EXPANDER_DEVICE: 3266 rphy = sas_expander_alloc(port, identify.device_type); 3267 break; 3268 default: 3269 rphy = NULL; 3270 break; 3271 } 3272 if (!rphy) { 3273 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 3274 "%s: exit at line=%d\n", ioc->name, 3275 __func__, __LINE__)); 3276 goto out; 3277 } 3278 3279 rphy->identify = identify; 3280 error = sas_rphy_add(rphy); 3281 if (error) { 3282 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 3283 "%s: exit at line=%d\n", ioc->name, 3284 __func__, __LINE__)); 3285 sas_rphy_free(rphy); 3286 goto out; 3287 } 3288 mptsas_set_rphy(ioc, phy_info, rphy); 3289 if (identify.device_type == SAS_EDGE_EXPANDER_DEVICE || 3290 identify.device_type == SAS_FANOUT_EXPANDER_DEVICE) 3291 mptsas_exp_repmanufacture_info(ioc, 3292 identify.sas_address, 3293 rphy_to_expander_device(rphy)); 3294 } 3295 3296 /* If the device exists, verify it wasn't previously flagged 3297 as a missing device. If so, clear it */ 3298 vtarget = mptsas_find_vtarget(ioc, 3299 phy_info->attached.channel, 3300 phy_info->attached.id); 3301 if (vtarget && vtarget->inDMD) { 3302 printk(KERN_INFO "Device returned, unsetting inDMD\n"); 3303 vtarget->inDMD = 0; 3304 } 3305 3306 out: 3307 return error; 3308 } 3309 3310 static int 3311 mptsas_probe_hba_phys(MPT_ADAPTER *ioc) 3312 { 3313 struct mptsas_portinfo *port_info, *hba; 3314 int error = -ENOMEM, i; 3315 3316 hba = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL); 3317 if (! hba) 3318 goto out; 3319 3320 error = mptsas_sas_io_unit_pg0(ioc, hba); 3321 if (error) 3322 goto out_free_port_info; 3323 3324 mptsas_sas_io_unit_pg1(ioc); 3325 mutex_lock(&ioc->sas_topology_mutex); 3326 port_info = ioc->hba_port_info; 3327 if (!port_info) { 3328 ioc->hba_port_info = port_info = hba; 3329 ioc->hba_port_num_phy = port_info->num_phys; 3330 list_add_tail(&port_info->list, &ioc->sas_topology); 3331 } else { 3332 for (i = 0; i < hba->num_phys; i++) { 3333 port_info->phy_info[i].negotiated_link_rate = 3334 hba->phy_info[i].negotiated_link_rate; 3335 port_info->phy_info[i].handle = 3336 hba->phy_info[i].handle; 3337 port_info->phy_info[i].port_id = 3338 hba->phy_info[i].port_id; 3339 } 3340 kfree(hba->phy_info); 3341 kfree(hba); 3342 hba = NULL; 3343 } 3344 mutex_unlock(&ioc->sas_topology_mutex); 3345 #if defined(CPQ_CIM) 3346 ioc->num_ports = port_info->num_phys; 3347 #endif 3348 for (i = 0; i < port_info->num_phys; i++) { 3349 mptsas_sas_phy_pg0(ioc, &port_info->phy_info[i], 3350 (MPI_SAS_PHY_PGAD_FORM_PHY_NUMBER << 3351 MPI_SAS_PHY_PGAD_FORM_SHIFT), i); 3352 port_info->phy_info[i].identify.handle = 3353 port_info->phy_info[i].handle; 3354 mptsas_sas_device_pg0(ioc, &port_info->phy_info[i].identify, 3355 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 3356 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 3357 port_info->phy_info[i].identify.handle); 3358 if (!ioc->hba_port_sas_addr) 3359 ioc->hba_port_sas_addr = 3360 port_info->phy_info[i].identify.sas_address; 3361 port_info->phy_info[i].identify.phy_id = 3362 port_info->phy_info[i].phy_id = i; 3363 if (port_info->phy_info[i].attached.handle) 3364 mptsas_sas_device_pg0(ioc, 3365 &port_info->phy_info[i].attached, 3366 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 3367 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 3368 port_info->phy_info[i].attached.handle); 3369 } 3370 3371 mptsas_setup_wide_ports(ioc, port_info); 3372 3373 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++) 3374 mptsas_probe_one_phy(&ioc->sh->shost_gendev, 3375 &port_info->phy_info[i], ioc->sas_index, 1); 3376 3377 return 0; 3378 3379 out_free_port_info: 3380 kfree(hba); 3381 out: 3382 return error; 3383 } 3384 3385 static void 3386 mptsas_expander_refresh(MPT_ADAPTER *ioc, struct mptsas_portinfo *port_info) 3387 { 3388 struct mptsas_portinfo *parent; 3389 struct device *parent_dev; 3390 struct sas_rphy *rphy; 3391 int i; 3392 u64 sas_address; /* expander sas address */ 3393 u32 handle; 3394 3395 handle = port_info->phy_info[0].handle; 3396 sas_address = port_info->phy_info[0].identify.sas_address; 3397 for (i = 0; i < port_info->num_phys; i++) { 3398 mptsas_sas_expander_pg1(ioc, &port_info->phy_info[i], 3399 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE_PHY_NUM << 3400 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), (i << 16) + handle); 3401 3402 mptsas_sas_device_pg0(ioc, 3403 &port_info->phy_info[i].identify, 3404 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 3405 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 3406 port_info->phy_info[i].identify.handle); 3407 port_info->phy_info[i].identify.phy_id = 3408 port_info->phy_info[i].phy_id; 3409 3410 if (port_info->phy_info[i].attached.handle) { 3411 mptsas_sas_device_pg0(ioc, 3412 &port_info->phy_info[i].attached, 3413 (MPI_SAS_DEVICE_PGAD_FORM_HANDLE << 3414 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 3415 port_info->phy_info[i].attached.handle); 3416 port_info->phy_info[i].attached.phy_id = 3417 port_info->phy_info[i].phy_id; 3418 } 3419 } 3420 3421 mutex_lock(&ioc->sas_topology_mutex); 3422 parent = mptsas_find_portinfo_by_handle(ioc, 3423 port_info->phy_info[0].identify.handle_parent); 3424 if (!parent) { 3425 mutex_unlock(&ioc->sas_topology_mutex); 3426 return; 3427 } 3428 for (i = 0, parent_dev = NULL; i < parent->num_phys && !parent_dev; 3429 i++) { 3430 if (parent->phy_info[i].attached.sas_address == sas_address) { 3431 rphy = mptsas_get_rphy(&parent->phy_info[i]); 3432 parent_dev = &rphy->dev; 3433 } 3434 } 3435 mutex_unlock(&ioc->sas_topology_mutex); 3436 3437 mptsas_setup_wide_ports(ioc, port_info); 3438 for (i = 0; i < port_info->num_phys; i++, ioc->sas_index++) 3439 mptsas_probe_one_phy(parent_dev, &port_info->phy_info[i], 3440 ioc->sas_index, 0); 3441 } 3442 3443 static void 3444 mptsas_expander_event_add(MPT_ADAPTER *ioc, 3445 MpiEventDataSasExpanderStatusChange_t *expander_data) 3446 { 3447 struct mptsas_portinfo *port_info; 3448 int i; 3449 __le64 sas_address; 3450 3451 port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL); 3452 BUG_ON(!port_info); 3453 port_info->num_phys = (expander_data->NumPhys) ? 3454 expander_data->NumPhys : 1; 3455 port_info->phy_info = kcalloc(port_info->num_phys, 3456 sizeof(struct mptsas_phyinfo), GFP_KERNEL); 3457 BUG_ON(!port_info->phy_info); 3458 memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64)); 3459 for (i = 0; i < port_info->num_phys; i++) { 3460 port_info->phy_info[i].portinfo = port_info; 3461 port_info->phy_info[i].handle = 3462 le16_to_cpu(expander_data->DevHandle); 3463 port_info->phy_info[i].identify.sas_address = 3464 le64_to_cpu(sas_address); 3465 port_info->phy_info[i].identify.handle_parent = 3466 le16_to_cpu(expander_data->ParentDevHandle); 3467 } 3468 3469 mutex_lock(&ioc->sas_topology_mutex); 3470 list_add_tail(&port_info->list, &ioc->sas_topology); 3471 mutex_unlock(&ioc->sas_topology_mutex); 3472 3473 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, " 3474 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys, 3475 (unsigned long long)sas_address); 3476 3477 mptsas_expander_refresh(ioc, port_info); 3478 } 3479 3480 /** 3481 * mptsas_delete_expander_siblings - remove siblings attached to expander 3482 * @ioc: Pointer to MPT_ADAPTER structure 3483 * @parent: the parent port_info object 3484 * @expander: the expander port_info object 3485 **/ 3486 static void 3487 mptsas_delete_expander_siblings(MPT_ADAPTER *ioc, struct mptsas_portinfo 3488 *parent, struct mptsas_portinfo *expander) 3489 { 3490 struct mptsas_phyinfo *phy_info; 3491 struct mptsas_portinfo *port_info; 3492 struct sas_rphy *rphy; 3493 int i; 3494 3495 phy_info = expander->phy_info; 3496 for (i = 0; i < expander->num_phys; i++, phy_info++) { 3497 rphy = mptsas_get_rphy(phy_info); 3498 if (!rphy) 3499 continue; 3500 if (rphy->identify.device_type == SAS_END_DEVICE) 3501 mptsas_del_end_device(ioc, phy_info); 3502 } 3503 3504 phy_info = expander->phy_info; 3505 for (i = 0; i < expander->num_phys; i++, phy_info++) { 3506 rphy = mptsas_get_rphy(phy_info); 3507 if (!rphy) 3508 continue; 3509 if (rphy->identify.device_type == 3510 MPI_SAS_DEVICE_INFO_EDGE_EXPANDER || 3511 rphy->identify.device_type == 3512 MPI_SAS_DEVICE_INFO_FANOUT_EXPANDER) { 3513 port_info = mptsas_find_portinfo_by_sas_address(ioc, 3514 rphy->identify.sas_address); 3515 if (!port_info) 3516 continue; 3517 if (port_info == parent) /* backlink rphy */ 3518 continue; 3519 /* 3520 Delete this expander even if the expdevpage is exists 3521 because the parent expander is already deleted 3522 */ 3523 mptsas_expander_delete(ioc, port_info, 1); 3524 } 3525 } 3526 } 3527 3528 3529 /** 3530 * mptsas_expander_delete - remove this expander 3531 * @ioc: Pointer to MPT_ADAPTER structure 3532 * @port_info: expander port_info struct 3533 * @force: Flag to forcefully delete the expander 3534 * 3535 **/ 3536 3537 static void mptsas_expander_delete(MPT_ADAPTER *ioc, 3538 struct mptsas_portinfo *port_info, u8 force) 3539 { 3540 3541 struct mptsas_portinfo *parent; 3542 int i; 3543 u64 expander_sas_address; 3544 struct mptsas_phyinfo *phy_info; 3545 struct mptsas_portinfo buffer; 3546 struct mptsas_portinfo_details *port_details; 3547 struct sas_port *port; 3548 3549 if (!port_info) 3550 return; 3551 3552 /* see if expander is still there before deleting */ 3553 mptsas_sas_expander_pg0(ioc, &buffer, 3554 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE << 3555 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), 3556 port_info->phy_info[0].identify.handle); 3557 3558 if (buffer.num_phys) { 3559 kfree(buffer.phy_info); 3560 if (!force) 3561 return; 3562 } 3563 3564 3565 /* 3566 * Obtain the port_info instance to the parent port 3567 */ 3568 port_details = NULL; 3569 expander_sas_address = 3570 port_info->phy_info[0].identify.sas_address; 3571 parent = mptsas_find_portinfo_by_handle(ioc, 3572 port_info->phy_info[0].identify.handle_parent); 3573 mptsas_delete_expander_siblings(ioc, parent, port_info); 3574 if (!parent) 3575 goto out; 3576 3577 /* 3578 * Delete rphys in the parent that point 3579 * to this expander. 3580 */ 3581 phy_info = parent->phy_info; 3582 port = NULL; 3583 for (i = 0; i < parent->num_phys; i++, phy_info++) { 3584 if (!phy_info->phy) 3585 continue; 3586 if (phy_info->attached.sas_address != 3587 expander_sas_address) 3588 continue; 3589 if (!port) { 3590 port = mptsas_get_port(phy_info); 3591 port_details = phy_info->port_details; 3592 } 3593 dev_printk(KERN_DEBUG, &phy_info->phy->dev, 3594 MYIOC_s_FMT "delete phy %d, phy-obj (0x%p)\n", ioc->name, 3595 phy_info->phy_id, phy_info->phy); 3596 sas_port_delete_phy(port, phy_info->phy); 3597 } 3598 if (port) { 3599 dev_printk(KERN_DEBUG, &port->dev, 3600 MYIOC_s_FMT "delete port %d, sas_addr (0x%llx)\n", 3601 ioc->name, port->port_identifier, 3602 (unsigned long long)expander_sas_address); 3603 sas_port_delete(port); 3604 mptsas_port_delete(ioc, port_details); 3605 } 3606 out: 3607 3608 printk(MYIOC_s_INFO_FMT "delete expander: num_phys %d, " 3609 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys, 3610 (unsigned long long)expander_sas_address); 3611 3612 /* 3613 * free link 3614 */ 3615 list_del(&port_info->list); 3616 kfree(port_info->phy_info); 3617 kfree(port_info); 3618 } 3619 3620 3621 /** 3622 * mptsas_send_expander_event - expanders events 3623 * @fw_event: event data 3624 * 3625 * 3626 * This function handles adding, removing, and refreshing 3627 * device handles within the expander objects. 3628 */ 3629 static void 3630 mptsas_send_expander_event(struct fw_event_work *fw_event) 3631 { 3632 MPT_ADAPTER *ioc; 3633 MpiEventDataSasExpanderStatusChange_t *expander_data; 3634 struct mptsas_portinfo *port_info; 3635 __le64 sas_address; 3636 int i; 3637 3638 ioc = fw_event->ioc; 3639 expander_data = (MpiEventDataSasExpanderStatusChange_t *) 3640 fw_event->event_data; 3641 memcpy(&sas_address, &expander_data->SASAddress, sizeof(__le64)); 3642 sas_address = le64_to_cpu(sas_address); 3643 port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address); 3644 3645 if (expander_data->ReasonCode == MPI_EVENT_SAS_EXP_RC_ADDED) { 3646 if (port_info) { 3647 for (i = 0; i < port_info->num_phys; i++) { 3648 port_info->phy_info[i].portinfo = port_info; 3649 port_info->phy_info[i].handle = 3650 le16_to_cpu(expander_data->DevHandle); 3651 port_info->phy_info[i].identify.sas_address = 3652 le64_to_cpu(sas_address); 3653 port_info->phy_info[i].identify.handle_parent = 3654 le16_to_cpu(expander_data->ParentDevHandle); 3655 } 3656 mptsas_expander_refresh(ioc, port_info); 3657 } else if (!port_info && expander_data->NumPhys) 3658 mptsas_expander_event_add(ioc, expander_data); 3659 } else if (expander_data->ReasonCode == 3660 MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING) 3661 mptsas_expander_delete(ioc, port_info, 0); 3662 3663 mptsas_free_fw_event(ioc, fw_event); 3664 } 3665 3666 3667 /** 3668 * mptsas_expander_add - adds a newly discovered expander 3669 * @ioc: Pointer to MPT_ADAPTER structure 3670 * @handle: device handle 3671 * 3672 */ 3673 static struct mptsas_portinfo * 3674 mptsas_expander_add(MPT_ADAPTER *ioc, u16 handle) 3675 { 3676 struct mptsas_portinfo buffer, *port_info; 3677 int i; 3678 3679 if ((mptsas_sas_expander_pg0(ioc, &buffer, 3680 (MPI_SAS_EXPAND_PGAD_FORM_HANDLE << 3681 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle))) 3682 return NULL; 3683 3684 port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL); 3685 if (!port_info) { 3686 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 3687 "%s: exit at line=%d\n", ioc->name, 3688 __func__, __LINE__)); 3689 return NULL; 3690 } 3691 port_info->num_phys = buffer.num_phys; 3692 port_info->phy_info = buffer.phy_info; 3693 for (i = 0; i < port_info->num_phys; i++) 3694 port_info->phy_info[i].portinfo = port_info; 3695 mutex_lock(&ioc->sas_topology_mutex); 3696 list_add_tail(&port_info->list, &ioc->sas_topology); 3697 mutex_unlock(&ioc->sas_topology_mutex); 3698 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, " 3699 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys, 3700 (unsigned long long)buffer.phy_info[0].identify.sas_address); 3701 mptsas_expander_refresh(ioc, port_info); 3702 return port_info; 3703 } 3704 3705 static void 3706 mptsas_send_link_status_event(struct fw_event_work *fw_event) 3707 { 3708 MPT_ADAPTER *ioc; 3709 MpiEventDataSasPhyLinkStatus_t *link_data; 3710 struct mptsas_portinfo *port_info; 3711 struct mptsas_phyinfo *phy_info = NULL; 3712 __le64 sas_address; 3713 u8 phy_num; 3714 u8 link_rate; 3715 3716 ioc = fw_event->ioc; 3717 link_data = (MpiEventDataSasPhyLinkStatus_t *)fw_event->event_data; 3718 3719 memcpy(&sas_address, &link_data->SASAddress, sizeof(__le64)); 3720 sas_address = le64_to_cpu(sas_address); 3721 link_rate = link_data->LinkRates >> 4; 3722 phy_num = link_data->PhyNum; 3723 3724 port_info = mptsas_find_portinfo_by_sas_address(ioc, sas_address); 3725 if (port_info) { 3726 phy_info = &port_info->phy_info[phy_num]; 3727 if (phy_info) 3728 phy_info->negotiated_link_rate = link_rate; 3729 } 3730 3731 if (link_rate == MPI_SAS_IOUNIT0_RATE_1_5 || 3732 link_rate == MPI_SAS_IOUNIT0_RATE_3_0 || 3733 link_rate == MPI_SAS_IOUNIT0_RATE_6_0) { 3734 3735 if (!port_info) { 3736 if (ioc->old_sas_discovery_protocal) { 3737 port_info = mptsas_expander_add(ioc, 3738 le16_to_cpu(link_data->DevHandle)); 3739 if (port_info) 3740 goto out; 3741 } 3742 goto out; 3743 } 3744 3745 if (port_info == ioc->hba_port_info) 3746 mptsas_probe_hba_phys(ioc); 3747 else 3748 mptsas_expander_refresh(ioc, port_info); 3749 } else if (phy_info && phy_info->phy) { 3750 if (link_rate == MPI_SAS_IOUNIT0_RATE_PHY_DISABLED) 3751 phy_info->phy->negotiated_linkrate = 3752 SAS_PHY_DISABLED; 3753 else if (link_rate == 3754 MPI_SAS_IOUNIT0_RATE_FAILED_SPEED_NEGOTIATION) 3755 phy_info->phy->negotiated_linkrate = 3756 SAS_LINK_RATE_FAILED; 3757 else { 3758 phy_info->phy->negotiated_linkrate = 3759 SAS_LINK_RATE_UNKNOWN; 3760 if (ioc->device_missing_delay && 3761 mptsas_is_end_device(&phy_info->attached)) { 3762 struct scsi_device *sdev; 3763 VirtDevice *vdevice; 3764 u8 channel, id; 3765 id = phy_info->attached.id; 3766 channel = phy_info->attached.channel; 3767 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 3768 "Link down for fw_id %d:fw_channel %d\n", 3769 ioc->name, phy_info->attached.id, 3770 phy_info->attached.channel)); 3771 3772 shost_for_each_device(sdev, ioc->sh) { 3773 vdevice = sdev->hostdata; 3774 if ((vdevice == NULL) || 3775 (vdevice->vtarget == NULL)) 3776 continue; 3777 if ((vdevice->vtarget->tflags & 3778 MPT_TARGET_FLAGS_RAID_COMPONENT || 3779 vdevice->vtarget->raidVolume)) 3780 continue; 3781 if (vdevice->vtarget->id == id && 3782 vdevice->vtarget->channel == 3783 channel) 3784 devtprintk(ioc, 3785 printk(MYIOC_s_DEBUG_FMT 3786 "SDEV OUTSTANDING CMDS" 3787 "%d\n", ioc->name, 3788 scsi_device_busy(sdev))); 3789 } 3790 3791 } 3792 } 3793 } 3794 out: 3795 mptsas_free_fw_event(ioc, fw_event); 3796 } 3797 3798 static void 3799 mptsas_not_responding_devices(MPT_ADAPTER *ioc) 3800 { 3801 struct mptsas_portinfo buffer, *port_info; 3802 struct mptsas_device_info *sas_info; 3803 struct mptsas_devinfo sas_device; 3804 u32 handle; 3805 VirtTarget *vtarget = NULL; 3806 struct mptsas_phyinfo *phy_info; 3807 u8 found_expander; 3808 int retval, retry_count; 3809 unsigned long flags; 3810 3811 mpt_findImVolumes(ioc); 3812 3813 spin_lock_irqsave(&ioc->taskmgmt_lock, flags); 3814 if (ioc->ioc_reset_in_progress) { 3815 dfailprintk(ioc, printk(MYIOC_s_DEBUG_FMT 3816 "%s: exiting due to a parallel reset \n", ioc->name, 3817 __func__)); 3818 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags); 3819 return; 3820 } 3821 spin_unlock_irqrestore(&ioc->taskmgmt_lock, flags); 3822 3823 /* devices, logical volumes */ 3824 mutex_lock(&ioc->sas_device_info_mutex); 3825 redo_device_scan: 3826 list_for_each_entry(sas_info, &ioc->sas_device_info_list, list) { 3827 if (sas_info->is_cached) 3828 continue; 3829 if (!sas_info->is_logical_volume) { 3830 sas_device.handle = 0; 3831 retry_count = 0; 3832 retry_page: 3833 retval = mptsas_sas_device_pg0(ioc, &sas_device, 3834 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID 3835 << MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 3836 (sas_info->fw.channel << 8) + 3837 sas_info->fw.id); 3838 3839 if (sas_device.handle) 3840 continue; 3841 if (retval == -EBUSY) { 3842 spin_lock_irqsave(&ioc->taskmgmt_lock, flags); 3843 if (ioc->ioc_reset_in_progress) { 3844 dfailprintk(ioc, 3845 printk(MYIOC_s_DEBUG_FMT 3846 "%s: exiting due to reset\n", 3847 ioc->name, __func__)); 3848 spin_unlock_irqrestore 3849 (&ioc->taskmgmt_lock, flags); 3850 mutex_unlock(&ioc-> 3851 sas_device_info_mutex); 3852 return; 3853 } 3854 spin_unlock_irqrestore(&ioc->taskmgmt_lock, 3855 flags); 3856 } 3857 3858 if (retval && (retval != -ENODEV)) { 3859 if (retry_count < 10) { 3860 retry_count++; 3861 goto retry_page; 3862 } else { 3863 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 3864 "%s: Config page retry exceeded retry " 3865 "count deleting device 0x%llx\n", 3866 ioc->name, __func__, 3867 sas_info->sas_address)); 3868 } 3869 } 3870 3871 /* delete device */ 3872 vtarget = mptsas_find_vtarget(ioc, 3873 sas_info->fw.channel, sas_info->fw.id); 3874 3875 if (vtarget) 3876 vtarget->deleted = 1; 3877 3878 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 3879 sas_info->sas_address); 3880 3881 mptsas_del_end_device(ioc, phy_info); 3882 goto redo_device_scan; 3883 } else 3884 mptsas_volume_delete(ioc, sas_info->fw.id); 3885 } 3886 mutex_unlock(&ioc->sas_device_info_mutex); 3887 3888 /* expanders */ 3889 mutex_lock(&ioc->sas_topology_mutex); 3890 redo_expander_scan: 3891 list_for_each_entry(port_info, &ioc->sas_topology, list) { 3892 3893 if (!(port_info->phy_info[0].identify.device_info & 3894 MPI_SAS_DEVICE_INFO_SMP_TARGET)) 3895 continue; 3896 found_expander = 0; 3897 handle = 0xFFFF; 3898 while (!mptsas_sas_expander_pg0(ioc, &buffer, 3899 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE << 3900 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle) && 3901 !found_expander) { 3902 3903 handle = buffer.phy_info[0].handle; 3904 if (buffer.phy_info[0].identify.sas_address == 3905 port_info->phy_info[0].identify.sas_address) { 3906 found_expander = 1; 3907 } 3908 kfree(buffer.phy_info); 3909 } 3910 3911 if (!found_expander) { 3912 mptsas_expander_delete(ioc, port_info, 0); 3913 goto redo_expander_scan; 3914 } 3915 } 3916 mutex_unlock(&ioc->sas_topology_mutex); 3917 } 3918 3919 /** 3920 * mptsas_probe_expanders - adding expanders 3921 * @ioc: Pointer to MPT_ADAPTER structure 3922 * 3923 **/ 3924 static void 3925 mptsas_probe_expanders(MPT_ADAPTER *ioc) 3926 { 3927 struct mptsas_portinfo buffer, *port_info; 3928 u32 handle; 3929 int i; 3930 3931 handle = 0xFFFF; 3932 while (!mptsas_sas_expander_pg0(ioc, &buffer, 3933 (MPI_SAS_EXPAND_PGAD_FORM_GET_NEXT_HANDLE << 3934 MPI_SAS_EXPAND_PGAD_FORM_SHIFT), handle)) { 3935 3936 handle = buffer.phy_info[0].handle; 3937 port_info = mptsas_find_portinfo_by_sas_address(ioc, 3938 buffer.phy_info[0].identify.sas_address); 3939 3940 if (port_info) { 3941 /* refreshing handles */ 3942 for (i = 0; i < buffer.num_phys; i++) { 3943 port_info->phy_info[i].handle = handle; 3944 port_info->phy_info[i].identify.handle_parent = 3945 buffer.phy_info[0].identify.handle_parent; 3946 } 3947 mptsas_expander_refresh(ioc, port_info); 3948 kfree(buffer.phy_info); 3949 continue; 3950 } 3951 3952 port_info = kzalloc(sizeof(struct mptsas_portinfo), GFP_KERNEL); 3953 if (!port_info) { 3954 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 3955 "%s: exit at line=%d\n", ioc->name, 3956 __func__, __LINE__)); 3957 return; 3958 } 3959 port_info->num_phys = buffer.num_phys; 3960 port_info->phy_info = buffer.phy_info; 3961 for (i = 0; i < port_info->num_phys; i++) 3962 port_info->phy_info[i].portinfo = port_info; 3963 mutex_lock(&ioc->sas_topology_mutex); 3964 list_add_tail(&port_info->list, &ioc->sas_topology); 3965 mutex_unlock(&ioc->sas_topology_mutex); 3966 printk(MYIOC_s_INFO_FMT "add expander: num_phys %d, " 3967 "sas_addr (0x%llx)\n", ioc->name, port_info->num_phys, 3968 (unsigned long long)buffer.phy_info[0].identify.sas_address); 3969 mptsas_expander_refresh(ioc, port_info); 3970 } 3971 } 3972 3973 static void 3974 mptsas_probe_devices(MPT_ADAPTER *ioc) 3975 { 3976 u16 handle; 3977 struct mptsas_devinfo sas_device; 3978 struct mptsas_phyinfo *phy_info; 3979 3980 handle = 0xFFFF; 3981 while (!(mptsas_sas_device_pg0(ioc, &sas_device, 3982 MPI_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, handle))) { 3983 3984 handle = sas_device.handle; 3985 3986 if ((sas_device.device_info & 3987 (MPI_SAS_DEVICE_INFO_SSP_TARGET | 3988 MPI_SAS_DEVICE_INFO_STP_TARGET | 3989 MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0) 3990 continue; 3991 3992 /* If there is no FW B_T mapping for this device then continue 3993 * */ 3994 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT) 3995 || !(sas_device.flags & 3996 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED)) 3997 continue; 3998 3999 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device); 4000 if (!phy_info) 4001 continue; 4002 4003 if (mptsas_get_rphy(phy_info)) 4004 continue; 4005 4006 mptsas_add_end_device(ioc, phy_info); 4007 } 4008 } 4009 4010 /** 4011 * mptsas_scan_sas_topology - scans new SAS topology 4012 * (part of probe or rescan) 4013 * @ioc: Pointer to MPT_ADAPTER structure 4014 * 4015 **/ 4016 static void 4017 mptsas_scan_sas_topology(MPT_ADAPTER *ioc) 4018 { 4019 struct scsi_device *sdev; 4020 int i; 4021 4022 mptsas_probe_hba_phys(ioc); 4023 mptsas_probe_expanders(ioc); 4024 mptsas_probe_devices(ioc); 4025 4026 /* 4027 Reporting RAID volumes. 4028 */ 4029 if (!ioc->ir_firmware || !ioc->raid_data.pIocPg2 || 4030 !ioc->raid_data.pIocPg2->NumActiveVolumes) 4031 return; 4032 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) { 4033 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, 4034 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0); 4035 if (sdev) { 4036 scsi_device_put(sdev); 4037 continue; 4038 } 4039 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, " 4040 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, 4041 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID); 4042 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, 4043 ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID, 0); 4044 } 4045 } 4046 4047 4048 static void 4049 mptsas_handle_queue_full_event(struct fw_event_work *fw_event) 4050 { 4051 MPT_ADAPTER *ioc; 4052 EventDataQueueFull_t *qfull_data; 4053 struct mptsas_device_info *sas_info; 4054 struct scsi_device *sdev; 4055 int depth; 4056 int id = -1; 4057 int channel = -1; 4058 int fw_id, fw_channel; 4059 u16 current_depth; 4060 4061 4062 ioc = fw_event->ioc; 4063 qfull_data = (EventDataQueueFull_t *)fw_event->event_data; 4064 fw_id = qfull_data->TargetID; 4065 fw_channel = qfull_data->Bus; 4066 current_depth = le16_to_cpu(qfull_data->CurrentDepth); 4067 4068 /* if hidden raid component, look for the volume id */ 4069 mutex_lock(&ioc->sas_device_info_mutex); 4070 if (mptscsih_is_phys_disk(ioc, fw_channel, fw_id)) { 4071 list_for_each_entry(sas_info, &ioc->sas_device_info_list, 4072 list) { 4073 if (sas_info->is_cached || 4074 sas_info->is_logical_volume) 4075 continue; 4076 if (sas_info->is_hidden_raid_component && 4077 (sas_info->fw.channel == fw_channel && 4078 sas_info->fw.id == fw_id)) { 4079 id = sas_info->volume_id; 4080 channel = MPTSAS_RAID_CHANNEL; 4081 goto out; 4082 } 4083 } 4084 } else { 4085 list_for_each_entry(sas_info, &ioc->sas_device_info_list, 4086 list) { 4087 if (sas_info->is_cached || 4088 sas_info->is_hidden_raid_component || 4089 sas_info->is_logical_volume) 4090 continue; 4091 if (sas_info->fw.channel == fw_channel && 4092 sas_info->fw.id == fw_id) { 4093 id = sas_info->os.id; 4094 channel = sas_info->os.channel; 4095 goto out; 4096 } 4097 } 4098 4099 } 4100 4101 out: 4102 mutex_unlock(&ioc->sas_device_info_mutex); 4103 4104 if (id != -1) { 4105 shost_for_each_device(sdev, ioc->sh) { 4106 if (sdev->id == id && sdev->channel == channel) { 4107 if (current_depth > sdev->queue_depth) { 4108 sdev_printk(KERN_INFO, sdev, 4109 "strange observation, the queue " 4110 "depth is (%d) meanwhile fw queue " 4111 "depth (%d)\n", sdev->queue_depth, 4112 current_depth); 4113 continue; 4114 } 4115 depth = scsi_track_queue_full(sdev, 4116 sdev->queue_depth - 1); 4117 if (depth > 0) 4118 sdev_printk(KERN_INFO, sdev, 4119 "Queue depth reduced to (%d)\n", 4120 depth); 4121 else if (depth < 0) 4122 sdev_printk(KERN_INFO, sdev, 4123 "Tagged Command Queueing is being " 4124 "disabled\n"); 4125 else if (depth == 0) 4126 sdev_printk(KERN_DEBUG, sdev, 4127 "Queue depth not changed yet\n"); 4128 } 4129 } 4130 } 4131 4132 mptsas_free_fw_event(ioc, fw_event); 4133 } 4134 4135 4136 static struct mptsas_phyinfo * 4137 mptsas_find_phyinfo_by_sas_address(MPT_ADAPTER *ioc, u64 sas_address) 4138 { 4139 struct mptsas_portinfo *port_info; 4140 struct mptsas_phyinfo *phy_info = NULL; 4141 int i; 4142 4143 mutex_lock(&ioc->sas_topology_mutex); 4144 list_for_each_entry(port_info, &ioc->sas_topology, list) { 4145 for (i = 0; i < port_info->num_phys; i++) { 4146 if (!mptsas_is_end_device( 4147 &port_info->phy_info[i].attached)) 4148 continue; 4149 if (port_info->phy_info[i].attached.sas_address 4150 != sas_address) 4151 continue; 4152 phy_info = &port_info->phy_info[i]; 4153 break; 4154 } 4155 } 4156 mutex_unlock(&ioc->sas_topology_mutex); 4157 return phy_info; 4158 } 4159 4160 /** 4161 * mptsas_find_phyinfo_by_phys_disk_num - find phyinfo for the 4162 * specified @phys_disk_num 4163 * @ioc: Pointer to MPT_ADAPTER structure 4164 * @phys_disk_num: (hot plug) physical disk number (for RAID support) 4165 * @channel: channel number 4166 * @id: Logical Target ID 4167 * 4168 **/ 4169 static struct mptsas_phyinfo * 4170 mptsas_find_phyinfo_by_phys_disk_num(MPT_ADAPTER *ioc, u8 phys_disk_num, 4171 u8 channel, u8 id) 4172 { 4173 struct mptsas_phyinfo *phy_info = NULL; 4174 struct mptsas_portinfo *port_info; 4175 RaidPhysDiskPage1_t *phys_disk = NULL; 4176 int num_paths; 4177 u64 sas_address = 0; 4178 int i; 4179 4180 phy_info = NULL; 4181 if (!ioc->raid_data.pIocPg3) 4182 return NULL; 4183 /* dual port support */ 4184 num_paths = mpt_raid_phys_disk_get_num_paths(ioc, phys_disk_num); 4185 if (!num_paths) 4186 goto out; 4187 phys_disk = kzalloc(offsetof(RaidPhysDiskPage1_t, Path) + 4188 (num_paths * sizeof(RAID_PHYS_DISK1_PATH)), GFP_KERNEL); 4189 if (!phys_disk) 4190 goto out; 4191 mpt_raid_phys_disk_pg1(ioc, phys_disk_num, phys_disk); 4192 for (i = 0; i < num_paths; i++) { 4193 if ((phys_disk->Path[i].Flags & 1) != 0) 4194 /* entry no longer valid */ 4195 continue; 4196 if ((id == phys_disk->Path[i].PhysDiskID) && 4197 (channel == phys_disk->Path[i].PhysDiskBus)) { 4198 memcpy(&sas_address, &phys_disk->Path[i].WWID, 4199 sizeof(u64)); 4200 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 4201 sas_address); 4202 goto out; 4203 } 4204 } 4205 4206 out: 4207 kfree(phys_disk); 4208 if (phy_info) 4209 return phy_info; 4210 4211 /* 4212 * Extra code to handle RAID0 case, where the sas_address is not updated 4213 * in phys_disk_page_1 when hotswapped 4214 */ 4215 mutex_lock(&ioc->sas_topology_mutex); 4216 list_for_each_entry(port_info, &ioc->sas_topology, list) { 4217 for (i = 0; i < port_info->num_phys && !phy_info; i++) { 4218 if (!mptsas_is_end_device( 4219 &port_info->phy_info[i].attached)) 4220 continue; 4221 if (port_info->phy_info[i].attached.phys_disk_num == ~0) 4222 continue; 4223 if ((port_info->phy_info[i].attached.phys_disk_num == 4224 phys_disk_num) && 4225 (port_info->phy_info[i].attached.id == id) && 4226 (port_info->phy_info[i].attached.channel == 4227 channel)) 4228 phy_info = &port_info->phy_info[i]; 4229 } 4230 } 4231 mutex_unlock(&ioc->sas_topology_mutex); 4232 return phy_info; 4233 } 4234 4235 static void 4236 mptsas_reprobe_lun(struct scsi_device *sdev, void *data) 4237 { 4238 int rc; 4239 4240 sdev->no_uld_attach = data ? 1 : 0; 4241 rc = scsi_device_reprobe(sdev); 4242 } 4243 4244 static void 4245 mptsas_reprobe_target(struct scsi_target *starget, int uld_attach) 4246 { 4247 starget_for_each_device(starget, uld_attach ? (void *)1 : NULL, 4248 mptsas_reprobe_lun); 4249 } 4250 4251 static void 4252 mptsas_adding_inactive_raid_components(MPT_ADAPTER *ioc, u8 channel, u8 id) 4253 { 4254 CONFIGPARMS cfg; 4255 ConfigPageHeader_t hdr; 4256 dma_addr_t dma_handle; 4257 pRaidVolumePage0_t buffer = NULL; 4258 RaidPhysDiskPage0_t phys_disk; 4259 int i; 4260 struct mptsas_phyinfo *phy_info; 4261 struct mptsas_devinfo sas_device; 4262 4263 memset(&cfg, 0 , sizeof(CONFIGPARMS)); 4264 memset(&hdr, 0 , sizeof(ConfigPageHeader_t)); 4265 hdr.PageType = MPI_CONFIG_PAGETYPE_RAID_VOLUME; 4266 cfg.pageAddr = (channel << 8) + id; 4267 cfg.cfghdr.hdr = &hdr; 4268 cfg.action = MPI_CONFIG_ACTION_PAGE_HEADER; 4269 cfg.timeout = SAS_CONFIG_PAGE_TIMEOUT; 4270 4271 if (mpt_config(ioc, &cfg) != 0) 4272 goto out; 4273 4274 if (!hdr.PageLength) 4275 goto out; 4276 4277 buffer = dma_alloc_coherent(&ioc->pcidev->dev, hdr.PageLength * 4, 4278 &dma_handle, GFP_KERNEL); 4279 4280 if (!buffer) 4281 goto out; 4282 4283 cfg.physAddr = dma_handle; 4284 cfg.action = MPI_CONFIG_ACTION_PAGE_READ_CURRENT; 4285 4286 if (mpt_config(ioc, &cfg) != 0) 4287 goto out; 4288 4289 if (!(buffer->VolumeStatus.Flags & 4290 MPI_RAIDVOL0_STATUS_FLAG_VOLUME_INACTIVE)) 4291 goto out; 4292 4293 if (!buffer->NumPhysDisks) 4294 goto out; 4295 4296 for (i = 0; i < buffer->NumPhysDisks; i++) { 4297 4298 if (mpt_raid_phys_disk_pg0(ioc, 4299 buffer->PhysDisk[i].PhysDiskNum, &phys_disk) != 0) 4300 continue; 4301 4302 if (mptsas_sas_device_pg0(ioc, &sas_device, 4303 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 4304 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 4305 (phys_disk.PhysDiskBus << 8) + 4306 phys_disk.PhysDiskID)) 4307 continue; 4308 4309 /* If there is no FW B_T mapping for this device then continue 4310 * */ 4311 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT) 4312 || !(sas_device.flags & 4313 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED)) 4314 continue; 4315 4316 4317 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 4318 sas_device.sas_address); 4319 mptsas_add_end_device(ioc, phy_info); 4320 } 4321 4322 out: 4323 if (buffer) 4324 dma_free_coherent(&ioc->pcidev->dev, hdr.PageLength * 4, 4325 buffer, dma_handle); 4326 } 4327 /* 4328 * Work queue thread to handle SAS hotplug events 4329 */ 4330 static void 4331 mptsas_hotplug_work(MPT_ADAPTER *ioc, struct fw_event_work *fw_event, 4332 struct mptsas_hotplug_event *hot_plug_info) 4333 { 4334 struct mptsas_phyinfo *phy_info; 4335 struct scsi_target * starget; 4336 struct mptsas_devinfo sas_device; 4337 VirtTarget *vtarget; 4338 int i; 4339 struct mptsas_portinfo *port_info; 4340 4341 switch (hot_plug_info->event_type) { 4342 4343 case MPTSAS_ADD_PHYSDISK: 4344 4345 if (!ioc->raid_data.pIocPg2) 4346 break; 4347 4348 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) { 4349 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == 4350 hot_plug_info->id) { 4351 printk(MYIOC_s_WARN_FMT "firmware bug: unable " 4352 "to add hidden disk - target_id matches " 4353 "volume_id\n", ioc->name); 4354 mptsas_free_fw_event(ioc, fw_event); 4355 return; 4356 } 4357 } 4358 mpt_findImVolumes(ioc); 4359 fallthrough; 4360 4361 case MPTSAS_ADD_DEVICE: 4362 memset(&sas_device, 0, sizeof(struct mptsas_devinfo)); 4363 mptsas_sas_device_pg0(ioc, &sas_device, 4364 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 4365 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 4366 (hot_plug_info->channel << 8) + 4367 hot_plug_info->id); 4368 4369 /* If there is no FW B_T mapping for this device then break 4370 * */ 4371 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT) 4372 || !(sas_device.flags & 4373 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED)) 4374 break; 4375 4376 if (!sas_device.handle) 4377 return; 4378 4379 phy_info = mptsas_refreshing_device_handles(ioc, &sas_device); 4380 /* Device hot plug */ 4381 if (!phy_info) { 4382 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 4383 "%s %d HOT PLUG: " 4384 "parent handle of device %x\n", ioc->name, 4385 __func__, __LINE__, sas_device.handle_parent)); 4386 port_info = mptsas_find_portinfo_by_handle(ioc, 4387 sas_device.handle_parent); 4388 4389 if (port_info == ioc->hba_port_info) 4390 mptsas_probe_hba_phys(ioc); 4391 else if (port_info) 4392 mptsas_expander_refresh(ioc, port_info); 4393 else { 4394 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4395 "%s %d port info is NULL\n", 4396 ioc->name, __func__, __LINE__)); 4397 break; 4398 } 4399 phy_info = mptsas_refreshing_device_handles 4400 (ioc, &sas_device); 4401 } 4402 4403 if (!phy_info) { 4404 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4405 "%s %d phy info is NULL\n", 4406 ioc->name, __func__, __LINE__)); 4407 break; 4408 } 4409 4410 if (mptsas_get_rphy(phy_info)) 4411 break; 4412 4413 mptsas_add_end_device(ioc, phy_info); 4414 break; 4415 4416 case MPTSAS_DEL_DEVICE: 4417 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 4418 hot_plug_info->sas_address); 4419 mptsas_del_end_device(ioc, phy_info); 4420 break; 4421 4422 case MPTSAS_DEL_PHYSDISK: 4423 4424 mpt_findImVolumes(ioc); 4425 4426 phy_info = mptsas_find_phyinfo_by_phys_disk_num( 4427 ioc, hot_plug_info->phys_disk_num, 4428 hot_plug_info->channel, 4429 hot_plug_info->id); 4430 mptsas_del_end_device(ioc, phy_info); 4431 break; 4432 4433 case MPTSAS_ADD_PHYSDISK_REPROBE: 4434 4435 if (mptsas_sas_device_pg0(ioc, &sas_device, 4436 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 4437 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 4438 (hot_plug_info->channel << 8) + hot_plug_info->id)) { 4439 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4440 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4441 __func__, hot_plug_info->id, __LINE__)); 4442 break; 4443 } 4444 4445 /* If there is no FW B_T mapping for this device then break 4446 * */ 4447 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT) 4448 || !(sas_device.flags & 4449 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED)) 4450 break; 4451 4452 phy_info = mptsas_find_phyinfo_by_sas_address( 4453 ioc, sas_device.sas_address); 4454 4455 if (!phy_info) { 4456 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4457 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4458 __func__, hot_plug_info->id, __LINE__)); 4459 break; 4460 } 4461 4462 starget = mptsas_get_starget(phy_info); 4463 if (!starget) { 4464 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4465 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4466 __func__, hot_plug_info->id, __LINE__)); 4467 break; 4468 } 4469 4470 vtarget = starget->hostdata; 4471 if (!vtarget) { 4472 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4473 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4474 __func__, hot_plug_info->id, __LINE__)); 4475 break; 4476 } 4477 4478 mpt_findImVolumes(ioc); 4479 4480 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Hidding: " 4481 "fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n", 4482 ioc->name, hot_plug_info->channel, hot_plug_info->id, 4483 hot_plug_info->phys_disk_num, (unsigned long long) 4484 sas_device.sas_address); 4485 4486 vtarget->id = hot_plug_info->phys_disk_num; 4487 vtarget->tflags |= MPT_TARGET_FLAGS_RAID_COMPONENT; 4488 phy_info->attached.phys_disk_num = hot_plug_info->phys_disk_num; 4489 mptsas_reprobe_target(starget, 1); 4490 break; 4491 4492 case MPTSAS_DEL_PHYSDISK_REPROBE: 4493 4494 if (mptsas_sas_device_pg0(ioc, &sas_device, 4495 (MPI_SAS_DEVICE_PGAD_FORM_BUS_TARGET_ID << 4496 MPI_SAS_DEVICE_PGAD_FORM_SHIFT), 4497 (hot_plug_info->channel << 8) + hot_plug_info->id)) { 4498 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4499 "%s: fw_id=%d exit at line=%d\n", 4500 ioc->name, __func__, 4501 hot_plug_info->id, __LINE__)); 4502 break; 4503 } 4504 4505 /* If there is no FW B_T mapping for this device then break 4506 * */ 4507 if (!(sas_device.flags & MPI_SAS_DEVICE0_FLAGS_DEVICE_PRESENT) 4508 || !(sas_device.flags & 4509 MPI_SAS_DEVICE0_FLAGS_DEVICE_MAPPED)) 4510 break; 4511 4512 phy_info = mptsas_find_phyinfo_by_sas_address(ioc, 4513 sas_device.sas_address); 4514 if (!phy_info) { 4515 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4516 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4517 __func__, hot_plug_info->id, __LINE__)); 4518 break; 4519 } 4520 4521 starget = mptsas_get_starget(phy_info); 4522 if (!starget) { 4523 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4524 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4525 __func__, hot_plug_info->id, __LINE__)); 4526 break; 4527 } 4528 4529 vtarget = starget->hostdata; 4530 if (!vtarget) { 4531 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4532 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4533 __func__, hot_plug_info->id, __LINE__)); 4534 break; 4535 } 4536 4537 if (!(vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT)) { 4538 dfailprintk(ioc, printk(MYIOC_s_ERR_FMT 4539 "%s: fw_id=%d exit at line=%d\n", ioc->name, 4540 __func__, hot_plug_info->id, __LINE__)); 4541 break; 4542 } 4543 4544 mpt_findImVolumes(ioc); 4545 4546 starget_printk(KERN_INFO, starget, MYIOC_s_FMT "RAID Exposing:" 4547 " fw_channel=%d, fw_id=%d, physdsk %d, sas_addr 0x%llx\n", 4548 ioc->name, hot_plug_info->channel, hot_plug_info->id, 4549 hot_plug_info->phys_disk_num, (unsigned long long) 4550 sas_device.sas_address); 4551 4552 vtarget->tflags &= ~MPT_TARGET_FLAGS_RAID_COMPONENT; 4553 vtarget->id = hot_plug_info->id; 4554 phy_info->attached.phys_disk_num = ~0; 4555 mptsas_reprobe_target(starget, 0); 4556 mptsas_add_device_component_by_fw(ioc, 4557 hot_plug_info->channel, hot_plug_info->id); 4558 break; 4559 4560 case MPTSAS_ADD_RAID: 4561 4562 mpt_findImVolumes(ioc); 4563 printk(MYIOC_s_INFO_FMT "attaching raid volume, channel %d, " 4564 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, 4565 hot_plug_info->id); 4566 scsi_add_device(ioc->sh, MPTSAS_RAID_CHANNEL, 4567 hot_plug_info->id, 0); 4568 break; 4569 4570 case MPTSAS_DEL_RAID: 4571 4572 mpt_findImVolumes(ioc); 4573 printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, " 4574 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, 4575 hot_plug_info->id); 4576 scsi_remove_device(hot_plug_info->sdev); 4577 scsi_device_put(hot_plug_info->sdev); 4578 break; 4579 4580 case MPTSAS_ADD_INACTIVE_VOLUME: 4581 4582 mpt_findImVolumes(ioc); 4583 mptsas_adding_inactive_raid_components(ioc, 4584 hot_plug_info->channel, hot_plug_info->id); 4585 break; 4586 4587 default: 4588 break; 4589 } 4590 4591 mptsas_free_fw_event(ioc, fw_event); 4592 } 4593 4594 static void 4595 mptsas_send_sas_event(struct fw_event_work *fw_event) 4596 { 4597 MPT_ADAPTER *ioc; 4598 struct mptsas_hotplug_event hot_plug_info; 4599 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data; 4600 u32 device_info; 4601 u64 sas_address; 4602 4603 ioc = fw_event->ioc; 4604 sas_event_data = (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *) 4605 fw_event->event_data; 4606 device_info = le32_to_cpu(sas_event_data->DeviceInfo); 4607 4608 if ((device_info & 4609 (MPI_SAS_DEVICE_INFO_SSP_TARGET | 4610 MPI_SAS_DEVICE_INFO_STP_TARGET | 4611 MPI_SAS_DEVICE_INFO_SATA_DEVICE)) == 0) { 4612 mptsas_free_fw_event(ioc, fw_event); 4613 return; 4614 } 4615 4616 if (sas_event_data->ReasonCode == 4617 MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED) { 4618 mptbase_sas_persist_operation(ioc, 4619 MPI_SAS_OP_CLEAR_NOT_PRESENT); 4620 mptsas_free_fw_event(ioc, fw_event); 4621 return; 4622 } 4623 4624 switch (sas_event_data->ReasonCode) { 4625 case MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING: 4626 case MPI_EVENT_SAS_DEV_STAT_RC_ADDED: 4627 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event)); 4628 hot_plug_info.handle = le16_to_cpu(sas_event_data->DevHandle); 4629 hot_plug_info.channel = sas_event_data->Bus; 4630 hot_plug_info.id = sas_event_data->TargetID; 4631 hot_plug_info.phy_id = sas_event_data->PhyNum; 4632 memcpy(&sas_address, &sas_event_data->SASAddress, 4633 sizeof(u64)); 4634 hot_plug_info.sas_address = le64_to_cpu(sas_address); 4635 hot_plug_info.device_info = device_info; 4636 if (sas_event_data->ReasonCode & 4637 MPI_EVENT_SAS_DEV_STAT_RC_ADDED) 4638 hot_plug_info.event_type = MPTSAS_ADD_DEVICE; 4639 else 4640 hot_plug_info.event_type = MPTSAS_DEL_DEVICE; 4641 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info); 4642 break; 4643 4644 case MPI_EVENT_SAS_DEV_STAT_RC_NO_PERSIST_ADDED: 4645 mptbase_sas_persist_operation(ioc, 4646 MPI_SAS_OP_CLEAR_NOT_PRESENT); 4647 mptsas_free_fw_event(ioc, fw_event); 4648 break; 4649 4650 case MPI_EVENT_SAS_DEV_STAT_RC_SMART_DATA: 4651 /* TODO */ 4652 case MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET: 4653 /* TODO */ 4654 default: 4655 mptsas_free_fw_event(ioc, fw_event); 4656 break; 4657 } 4658 } 4659 4660 static void 4661 mptsas_send_raid_event(struct fw_event_work *fw_event) 4662 { 4663 MPT_ADAPTER *ioc; 4664 EVENT_DATA_RAID *raid_event_data; 4665 struct mptsas_hotplug_event hot_plug_info; 4666 int status; 4667 int state; 4668 struct scsi_device *sdev = NULL; 4669 VirtDevice *vdevice = NULL; 4670 RaidPhysDiskPage0_t phys_disk; 4671 4672 ioc = fw_event->ioc; 4673 raid_event_data = (EVENT_DATA_RAID *)fw_event->event_data; 4674 status = le32_to_cpu(raid_event_data->SettingsStatus); 4675 state = (status >> 8) & 0xff; 4676 4677 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event)); 4678 hot_plug_info.id = raid_event_data->VolumeID; 4679 hot_plug_info.channel = raid_event_data->VolumeBus; 4680 hot_plug_info.phys_disk_num = raid_event_data->PhysDiskNum; 4681 4682 if (raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_DELETED || 4683 raid_event_data->ReasonCode == MPI_EVENT_RAID_RC_VOLUME_CREATED || 4684 raid_event_data->ReasonCode == 4685 MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED) { 4686 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, 4687 hot_plug_info.id, 0); 4688 hot_plug_info.sdev = sdev; 4689 if (sdev) 4690 vdevice = sdev->hostdata; 4691 } 4692 4693 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: " 4694 "ReasonCode=%02x\n", ioc->name, __func__, 4695 raid_event_data->ReasonCode)); 4696 4697 switch (raid_event_data->ReasonCode) { 4698 case MPI_EVENT_RAID_RC_PHYSDISK_DELETED: 4699 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK_REPROBE; 4700 break; 4701 case MPI_EVENT_RAID_RC_PHYSDISK_CREATED: 4702 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK_REPROBE; 4703 break; 4704 case MPI_EVENT_RAID_RC_PHYSDISK_STATUS_CHANGED: 4705 switch (state) { 4706 case MPI_PD_STATE_ONLINE: 4707 case MPI_PD_STATE_NOT_COMPATIBLE: 4708 mpt_raid_phys_disk_pg0(ioc, 4709 raid_event_data->PhysDiskNum, &phys_disk); 4710 hot_plug_info.id = phys_disk.PhysDiskID; 4711 hot_plug_info.channel = phys_disk.PhysDiskBus; 4712 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK; 4713 break; 4714 case MPI_PD_STATE_FAILED: 4715 case MPI_PD_STATE_MISSING: 4716 case MPI_PD_STATE_OFFLINE_AT_HOST_REQUEST: 4717 case MPI_PD_STATE_FAILED_AT_HOST_REQUEST: 4718 case MPI_PD_STATE_OFFLINE_FOR_ANOTHER_REASON: 4719 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK; 4720 break; 4721 default: 4722 break; 4723 } 4724 break; 4725 case MPI_EVENT_RAID_RC_VOLUME_DELETED: 4726 if (!sdev) 4727 break; 4728 vdevice->vtarget->deleted = 1; /* block IO */ 4729 hot_plug_info.event_type = MPTSAS_DEL_RAID; 4730 break; 4731 case MPI_EVENT_RAID_RC_VOLUME_CREATED: 4732 if (sdev) { 4733 scsi_device_put(sdev); 4734 break; 4735 } 4736 hot_plug_info.event_type = MPTSAS_ADD_RAID; 4737 break; 4738 case MPI_EVENT_RAID_RC_VOLUME_STATUS_CHANGED: 4739 if (!(status & MPI_RAIDVOL0_STATUS_FLAG_ENABLED)) { 4740 if (!sdev) 4741 break; 4742 vdevice->vtarget->deleted = 1; /* block IO */ 4743 hot_plug_info.event_type = MPTSAS_DEL_RAID; 4744 break; 4745 } 4746 switch (state) { 4747 case MPI_RAIDVOL0_STATUS_STATE_FAILED: 4748 case MPI_RAIDVOL0_STATUS_STATE_MISSING: 4749 if (!sdev) 4750 break; 4751 vdevice->vtarget->deleted = 1; /* block IO */ 4752 hot_plug_info.event_type = MPTSAS_DEL_RAID; 4753 break; 4754 case MPI_RAIDVOL0_STATUS_STATE_OPTIMAL: 4755 case MPI_RAIDVOL0_STATUS_STATE_DEGRADED: 4756 if (sdev) { 4757 scsi_device_put(sdev); 4758 break; 4759 } 4760 hot_plug_info.event_type = MPTSAS_ADD_RAID; 4761 break; 4762 default: 4763 break; 4764 } 4765 break; 4766 default: 4767 break; 4768 } 4769 4770 if (hot_plug_info.event_type != MPTSAS_IGNORE_EVENT) 4771 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info); 4772 else 4773 mptsas_free_fw_event(ioc, fw_event); 4774 } 4775 4776 /** 4777 * mptsas_issue_tm - send mptsas internal tm request 4778 * @ioc: Pointer to MPT_ADAPTER structure 4779 * @type: Task Management type 4780 * @channel: channel number for task management 4781 * @id: Logical Target ID for reset (if appropriate) 4782 * @lun: Logical unit for reset (if appropriate) 4783 * @task_context: Context for the task to be aborted 4784 * @timeout: timeout for task management control 4785 * @issue_reset: set to 1 on return if reset is needed, else 0 4786 * 4787 * Return: 0 on success or -1 on failure. 4788 * 4789 */ 4790 static int 4791 mptsas_issue_tm(MPT_ADAPTER *ioc, u8 type, u8 channel, u8 id, u64 lun, 4792 int task_context, ulong timeout, u8 *issue_reset) 4793 { 4794 MPT_FRAME_HDR *mf; 4795 SCSITaskMgmt_t *pScsiTm; 4796 int retval; 4797 unsigned long timeleft; 4798 4799 *issue_reset = 0; 4800 mf = mpt_get_msg_frame(mptsasDeviceResetCtx, ioc); 4801 if (mf == NULL) { 4802 retval = -1; /* return failure */ 4803 dtmprintk(ioc, printk(MYIOC_s_WARN_FMT "TaskMgmt request: no " 4804 "msg frames!!\n", ioc->name)); 4805 goto out; 4806 } 4807 4808 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT "TaskMgmt request: mr = %p, " 4809 "task_type = 0x%02X,\n\t timeout = %ld, fw_channel = %d, " 4810 "fw_id = %d, lun = %lld,\n\t task_context = 0x%x\n", ioc->name, mf, 4811 type, timeout, channel, id, (unsigned long long)lun, 4812 task_context)); 4813 4814 pScsiTm = (SCSITaskMgmt_t *) mf; 4815 memset(pScsiTm, 0, sizeof(SCSITaskMgmt_t)); 4816 pScsiTm->Function = MPI_FUNCTION_SCSI_TASK_MGMT; 4817 pScsiTm->TaskType = type; 4818 pScsiTm->MsgFlags = 0; 4819 pScsiTm->TargetID = id; 4820 pScsiTm->Bus = channel; 4821 pScsiTm->ChainOffset = 0; 4822 pScsiTm->Reserved = 0; 4823 pScsiTm->Reserved1 = 0; 4824 pScsiTm->TaskMsgContext = task_context; 4825 int_to_scsilun(lun, (struct scsi_lun *)pScsiTm->LUN); 4826 4827 INITIALIZE_MGMT_STATUS(ioc->taskmgmt_cmds.status) 4828 CLEAR_MGMT_STATUS(ioc->internal_cmds.status) 4829 retval = 0; 4830 mpt_put_msg_frame_hi_pri(mptsasDeviceResetCtx, ioc, mf); 4831 4832 /* Now wait for the command to complete */ 4833 timeleft = wait_for_completion_timeout(&ioc->taskmgmt_cmds.done, 4834 timeout*HZ); 4835 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_COMMAND_GOOD)) { 4836 retval = -1; /* return failure */ 4837 dtmprintk(ioc, printk(MYIOC_s_ERR_FMT 4838 "TaskMgmt request: TIMED OUT!(mr=%p)\n", ioc->name, mf)); 4839 mpt_free_msg_frame(ioc, mf); 4840 if (ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_DID_IOCRESET) 4841 goto out; 4842 *issue_reset = 1; 4843 goto out; 4844 } 4845 4846 if (!(ioc->taskmgmt_cmds.status & MPT_MGMT_STATUS_RF_VALID)) { 4847 retval = -1; /* return failure */ 4848 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 4849 "TaskMgmt request: failed with no reply\n", ioc->name)); 4850 goto out; 4851 } 4852 4853 out: 4854 CLEAR_MGMT_STATUS(ioc->taskmgmt_cmds.status) 4855 return retval; 4856 } 4857 4858 /** 4859 * mptsas_broadcast_primitive_work - Handle broadcast primitives 4860 * @fw_event: work queue payload containing info describing the event 4861 * 4862 * This will be handled in workqueue context. 4863 */ 4864 static void 4865 mptsas_broadcast_primitive_work(struct fw_event_work *fw_event) 4866 { 4867 MPT_ADAPTER *ioc = fw_event->ioc; 4868 MPT_FRAME_HDR *mf; 4869 VirtDevice *vdevice; 4870 int ii; 4871 struct scsi_cmnd *sc; 4872 SCSITaskMgmtReply_t *pScsiTmReply; 4873 u8 issue_reset; 4874 int task_context; 4875 u8 channel, id; 4876 int lun; 4877 u32 termination_count; 4878 u32 query_count; 4879 4880 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 4881 "%s - enter\n", ioc->name, __func__)); 4882 4883 mutex_lock(&ioc->taskmgmt_cmds.mutex); 4884 if (mpt_set_taskmgmt_in_progress_flag(ioc) != 0) { 4885 mutex_unlock(&ioc->taskmgmt_cmds.mutex); 4886 mptsas_requeue_fw_event(ioc, fw_event, 1000); 4887 return; 4888 } 4889 4890 issue_reset = 0; 4891 termination_count = 0; 4892 query_count = 0; 4893 mpt_findImVolumes(ioc); 4894 pScsiTmReply = (SCSITaskMgmtReply_t *) ioc->taskmgmt_cmds.reply; 4895 4896 for (ii = 0; ii < ioc->req_depth; ii++) { 4897 if (ioc->fw_events_off) 4898 goto out; 4899 sc = mptscsih_get_scsi_lookup(ioc, ii); 4900 if (!sc) 4901 continue; 4902 mf = MPT_INDEX_2_MFPTR(ioc, ii); 4903 if (!mf) 4904 continue; 4905 task_context = mf->u.frame.hwhdr.msgctxu.MsgContext; 4906 vdevice = sc->device->hostdata; 4907 if (!vdevice || !vdevice->vtarget) 4908 continue; 4909 if (vdevice->vtarget->tflags & MPT_TARGET_FLAGS_RAID_COMPONENT) 4910 continue; /* skip hidden raid components */ 4911 if (vdevice->vtarget->raidVolume) 4912 continue; /* skip hidden raid components */ 4913 channel = vdevice->vtarget->channel; 4914 id = vdevice->vtarget->id; 4915 lun = vdevice->lun; 4916 if (mptsas_issue_tm(ioc, MPI_SCSITASKMGMT_TASKTYPE_QUERY_TASK, 4917 channel, id, (u64)lun, task_context, 30, &issue_reset)) 4918 goto out; 4919 query_count++; 4920 termination_count += 4921 le32_to_cpu(pScsiTmReply->TerminationCount); 4922 if ((pScsiTmReply->IOCStatus == MPI_IOCSTATUS_SUCCESS) && 4923 (pScsiTmReply->ResponseCode == 4924 MPI_SCSITASKMGMT_RSP_TM_SUCCEEDED || 4925 pScsiTmReply->ResponseCode == 4926 MPI_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC)) 4927 continue; 4928 if (mptsas_issue_tm(ioc, 4929 MPI_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET, 4930 channel, id, (u64)lun, 0, 30, &issue_reset)) 4931 goto out; 4932 termination_count += 4933 le32_to_cpu(pScsiTmReply->TerminationCount); 4934 } 4935 4936 out: 4937 dtmprintk(ioc, printk(MYIOC_s_DEBUG_FMT 4938 "%s - exit, query_count = %d termination_count = %d\n", 4939 ioc->name, __func__, query_count, termination_count)); 4940 4941 ioc->broadcast_aen_busy = 0; 4942 mpt_clear_taskmgmt_in_progress_flag(ioc); 4943 mutex_unlock(&ioc->taskmgmt_cmds.mutex); 4944 4945 if (issue_reset) { 4946 printk(MYIOC_s_WARN_FMT 4947 "Issuing Reset from %s!! doorbell=0x%08x\n", 4948 ioc->name, __func__, mpt_GetIocState(ioc, 0)); 4949 mpt_Soft_Hard_ResetHandler(ioc, CAN_SLEEP); 4950 } 4951 mptsas_free_fw_event(ioc, fw_event); 4952 } 4953 4954 /* 4955 * mptsas_send_ir2_event - handle exposing hidden disk when 4956 * an inactive raid volume is added 4957 * 4958 * @ioc: Pointer to MPT_ADAPTER structure 4959 * @ir2_data 4960 * 4961 */ 4962 static void 4963 mptsas_send_ir2_event(struct fw_event_work *fw_event) 4964 { 4965 MPT_ADAPTER *ioc; 4966 struct mptsas_hotplug_event hot_plug_info; 4967 MPI_EVENT_DATA_IR2 *ir2_data; 4968 u8 reasonCode; 4969 RaidPhysDiskPage0_t phys_disk; 4970 4971 ioc = fw_event->ioc; 4972 ir2_data = (MPI_EVENT_DATA_IR2 *)fw_event->event_data; 4973 reasonCode = ir2_data->ReasonCode; 4974 4975 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT "Entering %s: " 4976 "ReasonCode=%02x\n", ioc->name, __func__, reasonCode)); 4977 4978 memset(&hot_plug_info, 0, sizeof(struct mptsas_hotplug_event)); 4979 hot_plug_info.id = ir2_data->TargetID; 4980 hot_plug_info.channel = ir2_data->Bus; 4981 switch (reasonCode) { 4982 case MPI_EVENT_IR2_RC_FOREIGN_CFG_DETECTED: 4983 hot_plug_info.event_type = MPTSAS_ADD_INACTIVE_VOLUME; 4984 break; 4985 case MPI_EVENT_IR2_RC_DUAL_PORT_REMOVED: 4986 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum; 4987 hot_plug_info.event_type = MPTSAS_DEL_PHYSDISK; 4988 break; 4989 case MPI_EVENT_IR2_RC_DUAL_PORT_ADDED: 4990 hot_plug_info.phys_disk_num = ir2_data->PhysDiskNum; 4991 mpt_raid_phys_disk_pg0(ioc, 4992 ir2_data->PhysDiskNum, &phys_disk); 4993 hot_plug_info.id = phys_disk.PhysDiskID; 4994 hot_plug_info.event_type = MPTSAS_ADD_PHYSDISK; 4995 break; 4996 default: 4997 mptsas_free_fw_event(ioc, fw_event); 4998 return; 4999 } 5000 mptsas_hotplug_work(ioc, fw_event, &hot_plug_info); 5001 } 5002 5003 static int 5004 mptsas_event_process(MPT_ADAPTER *ioc, EventNotificationReply_t *reply) 5005 { 5006 u32 event = le32_to_cpu(reply->Event); 5007 int event_data_sz; 5008 struct fw_event_work *fw_event; 5009 unsigned long delay; 5010 5011 if (ioc->bus_type != SAS) 5012 return 0; 5013 5014 /* events turned off due to host reset or driver unloading */ 5015 if (ioc->fw_events_off) 5016 return 0; 5017 5018 delay = msecs_to_jiffies(1); 5019 switch (event) { 5020 case MPI_EVENT_SAS_BROADCAST_PRIMITIVE: 5021 { 5022 EVENT_DATA_SAS_BROADCAST_PRIMITIVE *broadcast_event_data = 5023 (EVENT_DATA_SAS_BROADCAST_PRIMITIVE *)reply->Data; 5024 if (broadcast_event_data->Primitive != 5025 MPI_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT) 5026 return 0; 5027 if (ioc->broadcast_aen_busy) 5028 return 0; 5029 ioc->broadcast_aen_busy = 1; 5030 break; 5031 } 5032 case MPI_EVENT_SAS_DEVICE_STATUS_CHANGE: 5033 { 5034 EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *sas_event_data = 5035 (EVENT_DATA_SAS_DEVICE_STATUS_CHANGE *)reply->Data; 5036 u16 ioc_stat; 5037 ioc_stat = le16_to_cpu(reply->IOCStatus); 5038 5039 if (sas_event_data->ReasonCode == 5040 MPI_EVENT_SAS_DEV_STAT_RC_NOT_RESPONDING) { 5041 mptsas_target_reset_queue(ioc, sas_event_data); 5042 return 0; 5043 } 5044 if (sas_event_data->ReasonCode == 5045 MPI_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET && 5046 ioc->device_missing_delay && 5047 (ioc_stat & MPI_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE)) { 5048 VirtTarget *vtarget = NULL; 5049 u8 id, channel; 5050 5051 id = sas_event_data->TargetID; 5052 channel = sas_event_data->Bus; 5053 5054 vtarget = mptsas_find_vtarget(ioc, channel, id); 5055 if (vtarget) { 5056 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 5057 "LogInfo (0x%x) available for " 5058 "INTERNAL_DEVICE_RESET" 5059 "fw_id %d fw_channel %d\n", ioc->name, 5060 le32_to_cpu(reply->IOCLogInfo), 5061 id, channel)); 5062 if (vtarget->raidVolume) { 5063 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 5064 "Skipping Raid Volume for inDMD\n", 5065 ioc->name)); 5066 } else { 5067 devtprintk(ioc, printk(MYIOC_s_DEBUG_FMT 5068 "Setting device flag inDMD\n", 5069 ioc->name)); 5070 vtarget->inDMD = 1; 5071 } 5072 5073 } 5074 5075 } 5076 5077 break; 5078 } 5079 case MPI_EVENT_SAS_EXPANDER_STATUS_CHANGE: 5080 { 5081 MpiEventDataSasExpanderStatusChange_t *expander_data = 5082 (MpiEventDataSasExpanderStatusChange_t *)reply->Data; 5083 5084 if (ioc->old_sas_discovery_protocal) 5085 return 0; 5086 5087 if (expander_data->ReasonCode == 5088 MPI_EVENT_SAS_EXP_RC_NOT_RESPONDING && 5089 ioc->device_missing_delay) 5090 delay = HZ * ioc->device_missing_delay; 5091 break; 5092 } 5093 case MPI_EVENT_SAS_DISCOVERY: 5094 { 5095 u32 discovery_status; 5096 EventDataSasDiscovery_t *discovery_data = 5097 (EventDataSasDiscovery_t *)reply->Data; 5098 5099 discovery_status = le32_to_cpu(discovery_data->DiscoveryStatus); 5100 ioc->sas_discovery_quiesce_io = discovery_status ? 1 : 0; 5101 if (ioc->old_sas_discovery_protocal && !discovery_status) 5102 mptsas_queue_rescan(ioc); 5103 return 0; 5104 } 5105 case MPI_EVENT_INTEGRATED_RAID: 5106 case MPI_EVENT_PERSISTENT_TABLE_FULL: 5107 case MPI_EVENT_IR2: 5108 case MPI_EVENT_SAS_PHY_LINK_STATUS: 5109 case MPI_EVENT_QUEUE_FULL: 5110 break; 5111 default: 5112 return 0; 5113 } 5114 5115 event_data_sz = ((reply->MsgLength * 4) - 5116 offsetof(EventNotificationReply_t, Data)); 5117 fw_event = kzalloc(sizeof(*fw_event) + event_data_sz, GFP_ATOMIC); 5118 if (!fw_event) { 5119 printk(MYIOC_s_WARN_FMT "%s: failed at (line=%d)\n", ioc->name, 5120 __func__, __LINE__); 5121 return 0; 5122 } 5123 memcpy(fw_event->event_data, reply->Data, event_data_sz); 5124 fw_event->event = event; 5125 fw_event->ioc = ioc; 5126 mptsas_add_fw_event(ioc, fw_event, delay); 5127 return 0; 5128 } 5129 5130 /* Delete a volume when no longer listed in ioc pg2 5131 */ 5132 static void mptsas_volume_delete(MPT_ADAPTER *ioc, u8 id) 5133 { 5134 struct scsi_device *sdev; 5135 int i; 5136 5137 sdev = scsi_device_lookup(ioc->sh, MPTSAS_RAID_CHANNEL, id, 0); 5138 if (!sdev) 5139 return; 5140 if (!ioc->raid_data.pIocPg2) 5141 goto out; 5142 if (!ioc->raid_data.pIocPg2->NumActiveVolumes) 5143 goto out; 5144 for (i = 0; i < ioc->raid_data.pIocPg2->NumActiveVolumes; i++) 5145 if (ioc->raid_data.pIocPg2->RaidVolume[i].VolumeID == id) 5146 goto release_sdev; 5147 out: 5148 printk(MYIOC_s_INFO_FMT "removing raid volume, channel %d, " 5149 "id %d\n", ioc->name, MPTSAS_RAID_CHANNEL, id); 5150 scsi_remove_device(sdev); 5151 release_sdev: 5152 scsi_device_put(sdev); 5153 } 5154 5155 static int 5156 mptsas_probe(struct pci_dev *pdev, const struct pci_device_id *id) 5157 { 5158 struct Scsi_Host *sh; 5159 MPT_SCSI_HOST *hd; 5160 MPT_ADAPTER *ioc; 5161 unsigned long flags; 5162 int ii; 5163 int numSGE = 0; 5164 int scale; 5165 int ioc_cap; 5166 int error=0; 5167 int r; 5168 5169 r = mpt_attach(pdev,id); 5170 if (r) 5171 return r; 5172 5173 ioc = pci_get_drvdata(pdev); 5174 mptsas_fw_event_off(ioc); 5175 ioc->DoneCtx = mptsasDoneCtx; 5176 ioc->TaskCtx = mptsasTaskCtx; 5177 ioc->InternalCtx = mptsasInternalCtx; 5178 ioc->schedule_target_reset = &mptsas_schedule_target_reset; 5179 ioc->schedule_dead_ioc_flush_running_cmds = 5180 &mptscsih_flush_running_cmds; 5181 /* Added sanity check on readiness of the MPT adapter. 5182 */ 5183 if (ioc->last_state != MPI_IOC_STATE_OPERATIONAL) { 5184 printk(MYIOC_s_WARN_FMT 5185 "Skipping because it's not operational!\n", 5186 ioc->name); 5187 error = -ENODEV; 5188 goto out_mptsas_probe; 5189 } 5190 5191 if (!ioc->active) { 5192 printk(MYIOC_s_WARN_FMT "Skipping because it's disabled!\n", 5193 ioc->name); 5194 error = -ENODEV; 5195 goto out_mptsas_probe; 5196 } 5197 5198 /* Sanity check - ensure at least 1 port is INITIATOR capable 5199 */ 5200 ioc_cap = 0; 5201 for (ii = 0; ii < ioc->facts.NumberOfPorts; ii++) { 5202 if (ioc->pfacts[ii].ProtocolFlags & 5203 MPI_PORTFACTS_PROTOCOL_INITIATOR) 5204 ioc_cap++; 5205 } 5206 5207 if (!ioc_cap) { 5208 printk(MYIOC_s_WARN_FMT 5209 "Skipping ioc=%p because SCSI Initiator mode " 5210 "is NOT enabled!\n", ioc->name, ioc); 5211 return 0; 5212 } 5213 5214 sh = scsi_host_alloc(&mptsas_driver_template, sizeof(MPT_SCSI_HOST)); 5215 if (!sh) { 5216 printk(MYIOC_s_WARN_FMT 5217 "Unable to register controller with SCSI subsystem\n", 5218 ioc->name); 5219 error = -1; 5220 goto out_mptsas_probe; 5221 } 5222 5223 spin_lock_irqsave(&ioc->FreeQlock, flags); 5224 5225 /* Attach the SCSI Host to the IOC structure 5226 */ 5227 ioc->sh = sh; 5228 5229 sh->io_port = 0; 5230 sh->n_io_port = 0; 5231 sh->irq = 0; 5232 5233 /* set 16 byte cdb's */ 5234 sh->max_cmd_len = 16; 5235 sh->can_queue = min_t(int, ioc->req_depth - 10, sh->can_queue); 5236 sh->max_id = -1; 5237 sh->max_lun = max_lun; 5238 sh->transportt = mptsas_transport_template; 5239 5240 /* Required entry. 5241 */ 5242 sh->unique_id = ioc->id; 5243 5244 INIT_LIST_HEAD(&ioc->sas_topology); 5245 mutex_init(&ioc->sas_topology_mutex); 5246 mutex_init(&ioc->sas_discovery_mutex); 5247 mutex_init(&ioc->sas_mgmt.mutex); 5248 init_completion(&ioc->sas_mgmt.done); 5249 5250 /* Verify that we won't exceed the maximum 5251 * number of chain buffers 5252 * We can optimize: ZZ = req_sz/sizeof(SGE) 5253 * For 32bit SGE's: 5254 * numSGE = 1 + (ZZ-1)*(maxChain -1) + ZZ 5255 * + (req_sz - 64)/sizeof(SGE) 5256 * A slightly different algorithm is required for 5257 * 64bit SGEs. 5258 */ 5259 scale = ioc->req_sz/ioc->SGE_size; 5260 if (ioc->sg_addr_size == sizeof(u64)) { 5261 numSGE = (scale - 1) * 5262 (ioc->facts.MaxChainDepth-1) + scale + 5263 (ioc->req_sz - 60) / ioc->SGE_size; 5264 } else { 5265 numSGE = 1 + (scale - 1) * 5266 (ioc->facts.MaxChainDepth-1) + scale + 5267 (ioc->req_sz - 64) / ioc->SGE_size; 5268 } 5269 5270 if (numSGE < sh->sg_tablesize) { 5271 /* Reset this value */ 5272 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT 5273 "Resetting sg_tablesize to %d from %d\n", 5274 ioc->name, numSGE, sh->sg_tablesize)); 5275 sh->sg_tablesize = numSGE; 5276 } 5277 5278 if (mpt_loadtime_max_sectors) { 5279 if (mpt_loadtime_max_sectors < 64 || 5280 mpt_loadtime_max_sectors > 8192) { 5281 printk(MYIOC_s_INFO_FMT "Invalid value passed for" 5282 "mpt_loadtime_max_sectors %d." 5283 "Range from 64 to 8192\n", ioc->name, 5284 mpt_loadtime_max_sectors); 5285 } 5286 mpt_loadtime_max_sectors &= 0xFFFFFFFE; 5287 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT 5288 "Resetting max sector to %d from %d\n", 5289 ioc->name, mpt_loadtime_max_sectors, sh->max_sectors)); 5290 sh->max_sectors = mpt_loadtime_max_sectors; 5291 } 5292 5293 hd = shost_priv(sh); 5294 hd->ioc = ioc; 5295 5296 /* SCSI needs scsi_cmnd lookup table! 5297 * (with size equal to req_depth*PtrSz!) 5298 */ 5299 ioc->ScsiLookup = kcalloc(ioc->req_depth, sizeof(void *), GFP_ATOMIC); 5300 if (!ioc->ScsiLookup) { 5301 error = -ENOMEM; 5302 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 5303 goto out_mptsas_probe; 5304 } 5305 spin_lock_init(&ioc->scsi_lookup_lock); 5306 5307 dprintk(ioc, printk(MYIOC_s_DEBUG_FMT "ScsiLookup @ %p\n", 5308 ioc->name, ioc->ScsiLookup)); 5309 5310 ioc->sas_data.ptClear = mpt_pt_clear; 5311 5312 hd->last_queue_full = 0; 5313 INIT_LIST_HEAD(&hd->target_reset_list); 5314 INIT_LIST_HEAD(&ioc->sas_device_info_list); 5315 mutex_init(&ioc->sas_device_info_mutex); 5316 5317 spin_unlock_irqrestore(&ioc->FreeQlock, flags); 5318 5319 if (ioc->sas_data.ptClear==1) { 5320 mptbase_sas_persist_operation( 5321 ioc, MPI_SAS_OP_CLEAR_ALL_PERSISTENT); 5322 } 5323 5324 error = scsi_add_host(sh, &ioc->pcidev->dev); 5325 if (error) { 5326 dprintk(ioc, printk(MYIOC_s_ERR_FMT 5327 "scsi_add_host failed\n", ioc->name)); 5328 goto out_mptsas_probe; 5329 } 5330 5331 /* older firmware doesn't support expander events */ 5332 if ((ioc->facts.HeaderVersion >> 8) < 0xE) 5333 ioc->old_sas_discovery_protocal = 1; 5334 mptsas_scan_sas_topology(ioc); 5335 mptsas_fw_event_on(ioc); 5336 return 0; 5337 5338 out_mptsas_probe: 5339 5340 mptscsih_remove(pdev); 5341 return error; 5342 } 5343 5344 static void 5345 mptsas_shutdown(struct pci_dev *pdev) 5346 { 5347 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 5348 5349 mptsas_fw_event_off(ioc); 5350 mptsas_cleanup_fw_event_q(ioc); 5351 } 5352 5353 static void mptsas_remove(struct pci_dev *pdev) 5354 { 5355 MPT_ADAPTER *ioc = pci_get_drvdata(pdev); 5356 struct mptsas_portinfo *p, *n; 5357 int i; 5358 5359 if (!ioc->sh) { 5360 printk(MYIOC_s_INFO_FMT "IOC is in Target mode\n", ioc->name); 5361 mpt_detach(pdev); 5362 return; 5363 } 5364 5365 mptsas_shutdown(pdev); 5366 5367 mptsas_del_device_components(ioc); 5368 5369 ioc->sas_discovery_ignore_events = 1; 5370 sas_remove_host(ioc->sh); 5371 5372 mutex_lock(&ioc->sas_topology_mutex); 5373 list_for_each_entry_safe(p, n, &ioc->sas_topology, list) { 5374 list_del(&p->list); 5375 for (i = 0 ; i < p->num_phys ; i++) 5376 mptsas_port_delete(ioc, p->phy_info[i].port_details); 5377 5378 kfree(p->phy_info); 5379 kfree(p); 5380 } 5381 mutex_unlock(&ioc->sas_topology_mutex); 5382 ioc->hba_port_info = NULL; 5383 mptscsih_remove(pdev); 5384 } 5385 5386 static struct pci_device_id mptsas_pci_table[] = { 5387 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064, 5388 PCI_ANY_ID, PCI_ANY_ID }, 5389 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068, 5390 PCI_ANY_ID, PCI_ANY_ID }, 5391 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1064E, 5392 PCI_ANY_ID, PCI_ANY_ID }, 5393 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068E, 5394 PCI_ANY_ID, PCI_ANY_ID }, 5395 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1078, 5396 PCI_ANY_ID, PCI_ANY_ID }, 5397 { PCI_VENDOR_ID_LSI_LOGIC, MPI_MANUFACTPAGE_DEVID_SAS1068_820XELP, 5398 PCI_ANY_ID, PCI_ANY_ID }, 5399 {0} /* Terminating entry */ 5400 }; 5401 MODULE_DEVICE_TABLE(pci, mptsas_pci_table); 5402 5403 5404 static struct pci_driver mptsas_driver = { 5405 .name = "mptsas", 5406 .id_table = mptsas_pci_table, 5407 .probe = mptsas_probe, 5408 .remove = mptsas_remove, 5409 .shutdown = mptsas_shutdown, 5410 #ifdef CONFIG_PM 5411 .suspend = mptscsih_suspend, 5412 .resume = mptscsih_resume, 5413 #endif 5414 }; 5415 5416 static int __init 5417 mptsas_init(void) 5418 { 5419 int error; 5420 5421 show_mptmod_ver(my_NAME, my_VERSION); 5422 5423 mptsas_transport_template = 5424 sas_attach_transport(&mptsas_transport_functions); 5425 if (!mptsas_transport_template) 5426 return -ENODEV; 5427 5428 mptsasDoneCtx = mpt_register(mptscsih_io_done, MPTSAS_DRIVER, 5429 "mptscsih_io_done"); 5430 mptsasTaskCtx = mpt_register(mptscsih_taskmgmt_complete, MPTSAS_DRIVER, 5431 "mptscsih_taskmgmt_complete"); 5432 mptsasInternalCtx = 5433 mpt_register(mptscsih_scandv_complete, MPTSAS_DRIVER, 5434 "mptscsih_scandv_complete"); 5435 mptsasMgmtCtx = mpt_register(mptsas_mgmt_done, MPTSAS_DRIVER, 5436 "mptsas_mgmt_done"); 5437 mptsasDeviceResetCtx = 5438 mpt_register(mptsas_taskmgmt_complete, MPTSAS_DRIVER, 5439 "mptsas_taskmgmt_complete"); 5440 5441 mpt_event_register(mptsasDoneCtx, mptsas_event_process); 5442 mpt_reset_register(mptsasDoneCtx, mptsas_ioc_reset); 5443 5444 error = pci_register_driver(&mptsas_driver); 5445 if (error) 5446 sas_release_transport(mptsas_transport_template); 5447 5448 return error; 5449 } 5450 5451 static void __exit 5452 mptsas_exit(void) 5453 { 5454 pci_unregister_driver(&mptsas_driver); 5455 sas_release_transport(mptsas_transport_template); 5456 5457 mpt_reset_deregister(mptsasDoneCtx); 5458 mpt_event_deregister(mptsasDoneCtx); 5459 5460 mpt_deregister(mptsasMgmtCtx); 5461 mpt_deregister(mptsasInternalCtx); 5462 mpt_deregister(mptsasTaskCtx); 5463 mpt_deregister(mptsasDoneCtx); 5464 mpt_deregister(mptsasDeviceResetCtx); 5465 } 5466 5467 module_init(mptsas_init); 5468 module_exit(mptsas_exit); 5469