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