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