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