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