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