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