1 /* 2 * Scsi Host Layer for MPT (Message Passing Technology) based controllers 3 * 4 * This code is based on drivers/scsi/mpt3sas/mpt3sas_scsih.c 5 * Copyright (C) 2012-2014 LSI Corporation 6 * Copyright (C) 2013-2014 Avago Technologies 7 * (mailto: MPT-FusionLinux.pdl@avagotech.com) 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License 11 * as published by the Free Software Foundation; either version 2 12 * of the License, or (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * NO WARRANTY 20 * THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR 21 * CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT 22 * LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, 23 * MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is 24 * solely responsible for determining the appropriateness of using and 25 * distributing the Program and assumes all risks associated with its 26 * exercise of rights under this Agreement, including but not limited to 27 * the risks and costs of program errors, damage to or loss of data, 28 * programs or equipment, and unavailability or interruption of operations. 29 30 * DISCLAIMER OF LIABILITY 31 * NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY 32 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 33 * DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND 34 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR 35 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE 36 * USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED 37 * HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES 38 39 * You should have received a copy of the GNU General Public License 40 * along with this program; if not, write to the Free Software 41 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 42 * USA. 43 */ 44 45 #include <linux/module.h> 46 #include <linux/kernel.h> 47 #include <linux/init.h> 48 #include <linux/errno.h> 49 #include <linux/blkdev.h> 50 #include <linux/sched.h> 51 #include <linux/workqueue.h> 52 #include <linux/delay.h> 53 #include <linux/pci.h> 54 #include <linux/interrupt.h> 55 #include <linux/raid_class.h> 56 #include <linux/unaligned.h> 57 58 #include "mpt3sas_base.h" 59 60 #define RAID_CHANNEL 1 61 62 #define PCIE_CHANNEL 2 63 64 /* forward proto's */ 65 static void _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc, 66 struct _sas_node *sas_expander); 67 static void _firmware_event_work(struct work_struct *work); 68 69 static void _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc, 70 struct _sas_device *sas_device); 71 static int _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, 72 u8 retry_count, u8 is_pd); 73 static int _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle); 74 static void _scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc, 75 struct _pcie_device *pcie_device); 76 static void 77 _scsih_pcie_check_device(struct MPT3SAS_ADAPTER *ioc, u16 handle); 78 static u8 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid); 79 static void _scsih_complete_devices_scanning(struct MPT3SAS_ADAPTER *ioc); 80 81 /* global parameters */ 82 LIST_HEAD(mpt3sas_ioc_list); 83 /* global ioc lock for list operations */ 84 DEFINE_SPINLOCK(gioc_lock); 85 86 MODULE_AUTHOR(MPT3SAS_AUTHOR); 87 MODULE_DESCRIPTION(MPT3SAS_DESCRIPTION); 88 MODULE_LICENSE("GPL"); 89 MODULE_VERSION(MPT3SAS_DRIVER_VERSION); 90 MODULE_ALIAS("mpt2sas"); 91 92 /* local parameters */ 93 static u8 scsi_io_cb_idx = -1; 94 static u8 tm_cb_idx = -1; 95 static u8 ctl_cb_idx = -1; 96 static u8 base_cb_idx = -1; 97 static u8 port_enable_cb_idx = -1; 98 static u8 transport_cb_idx = -1; 99 static u8 scsih_cb_idx = -1; 100 static u8 config_cb_idx = -1; 101 static int mpt2_ids; 102 static int mpt3_ids; 103 104 static u8 tm_tr_cb_idx = -1 ; 105 static u8 tm_tr_volume_cb_idx = -1 ; 106 static u8 tm_sas_control_cb_idx = -1; 107 108 /* command line options */ 109 static u32 logging_level; 110 MODULE_PARM_DESC(logging_level, 111 " bits for enabling additional logging info (default=0)"); 112 113 114 static ushort max_sectors = 0xFFFF; 115 module_param(max_sectors, ushort, 0444); 116 MODULE_PARM_DESC(max_sectors, "max sectors, range 64 to 32767 default=32767"); 117 118 119 static int missing_delay[2] = {-1, -1}; 120 module_param_array(missing_delay, int, NULL, 0444); 121 MODULE_PARM_DESC(missing_delay, " device missing delay , io missing delay"); 122 123 /* scsi-mid layer global parmeter is max_report_luns, which is 511 */ 124 #define MPT3SAS_MAX_LUN (16895) 125 static u64 max_lun = MPT3SAS_MAX_LUN; 126 module_param(max_lun, ullong, 0444); 127 MODULE_PARM_DESC(max_lun, " max lun, default=16895 "); 128 129 static ushort hbas_to_enumerate; 130 module_param(hbas_to_enumerate, ushort, 0444); 131 MODULE_PARM_DESC(hbas_to_enumerate, 132 " 0 - enumerates both SAS 2.0 & SAS 3.0 generation HBAs\n \ 133 1 - enumerates only SAS 2.0 generation HBAs\n \ 134 2 - enumerates only SAS 3.0 generation HBAs (default=0)"); 135 136 /* diag_buffer_enable is bitwise 137 * bit 0 set = TRACE 138 * bit 1 set = SNAPSHOT 139 * bit 2 set = EXTENDED 140 * 141 * Either bit can be set, or both 142 */ 143 static int diag_buffer_enable = -1; 144 module_param(diag_buffer_enable, int, 0444); 145 MODULE_PARM_DESC(diag_buffer_enable, 146 " post diag buffers (TRACE=1/SNAPSHOT=2/EXTENDED=4/default=0)"); 147 static int disable_discovery = -1; 148 module_param(disable_discovery, int, 0444); 149 MODULE_PARM_DESC(disable_discovery, " disable discovery "); 150 151 152 /* permit overriding the host protection capabilities mask (EEDP/T10 PI) */ 153 static int prot_mask = -1; 154 module_param(prot_mask, int, 0444); 155 MODULE_PARM_DESC(prot_mask, " host protection capabilities mask, def=7 "); 156 157 static bool enable_sdev_max_qd; 158 module_param(enable_sdev_max_qd, bool, 0444); 159 MODULE_PARM_DESC(enable_sdev_max_qd, 160 "Enable sdev max qd as can_queue, def=disabled(0)"); 161 162 static int multipath_on_hba = -1; 163 module_param(multipath_on_hba, int, 0); 164 MODULE_PARM_DESC(multipath_on_hba, 165 "Multipath support to add same target device\n\t\t" 166 "as many times as it is visible to HBA from various paths\n\t\t" 167 "(by default:\n\t\t" 168 "\t SAS 2.0 & SAS 3.0 HBA - This will be disabled,\n\t\t" 169 "\t SAS 3.5 HBA - This will be enabled)"); 170 171 static int host_tagset_enable = 1; 172 module_param(host_tagset_enable, int, 0444); 173 MODULE_PARM_DESC(host_tagset_enable, 174 "Shared host tagset enable/disable Default: enable(1)"); 175 176 /* raid transport support */ 177 static struct raid_template *mpt3sas_raid_template; 178 static struct raid_template *mpt2sas_raid_template; 179 180 181 /** 182 * struct sense_info - common structure for obtaining sense keys 183 * @skey: sense key 184 * @asc: additional sense code 185 * @ascq: additional sense code qualifier 186 */ 187 struct sense_info { 188 u8 skey; 189 u8 asc; 190 u8 ascq; 191 }; 192 193 #define MPT3SAS_PROCESS_TRIGGER_DIAG (0xFFFB) 194 #define MPT3SAS_TURN_ON_PFA_LED (0xFFFC) 195 #define MPT3SAS_PORT_ENABLE_COMPLETE (0xFFFD) 196 #define MPT3SAS_ABRT_TASK_SET (0xFFFE) 197 #define MPT3SAS_REMOVE_UNRESPONDING_DEVICES (0xFFFF) 198 /** 199 * struct fw_event_work - firmware event struct 200 * @list: link list framework 201 * @work: work object (ioc->fault_reset_work_q) 202 * @ioc: per adapter object 203 * @device_handle: device handle 204 * @VF_ID: virtual function id 205 * @VP_ID: virtual port id 206 * @ignore: flag meaning this event has been marked to ignore 207 * @event: firmware event MPI2_EVENT_XXX defined in mpi2_ioc.h 208 * @refcount: kref for this event 209 * @event_data: reply event data payload follows 210 * 211 * This object stored on ioc->fw_event_list. 212 */ 213 struct fw_event_work { 214 struct list_head list; 215 struct work_struct work; 216 217 struct MPT3SAS_ADAPTER *ioc; 218 u16 device_handle; 219 u8 VF_ID; 220 u8 VP_ID; 221 u8 ignore; 222 u16 event; 223 struct kref refcount; 224 char event_data[] __aligned(4); 225 }; 226 227 static void fw_event_work_free(struct kref *r) 228 { 229 kfree(container_of(r, struct fw_event_work, refcount)); 230 } 231 232 static void fw_event_work_get(struct fw_event_work *fw_work) 233 { 234 kref_get(&fw_work->refcount); 235 } 236 237 static void fw_event_work_put(struct fw_event_work *fw_work) 238 { 239 kref_put(&fw_work->refcount, fw_event_work_free); 240 } 241 242 static struct fw_event_work *alloc_fw_event_work(int len) 243 { 244 struct fw_event_work *fw_event; 245 246 fw_event = kzalloc(sizeof(*fw_event) + len, GFP_ATOMIC); 247 if (!fw_event) 248 return NULL; 249 250 kref_init(&fw_event->refcount); 251 return fw_event; 252 } 253 254 /** 255 * struct _scsi_io_transfer - scsi io transfer 256 * @handle: sas device handle (assigned by firmware) 257 * @is_raid: flag set for hidden raid components 258 * @dir: DMA_TO_DEVICE, DMA_FROM_DEVICE, 259 * @data_length: data transfer length 260 * @data_dma: dma pointer to data 261 * @sense: sense data 262 * @lun: lun number 263 * @cdb_length: cdb length 264 * @cdb: cdb contents 265 * @timeout: timeout for this command 266 * @VF_ID: virtual function id 267 * @VP_ID: virtual port id 268 * @valid_reply: flag set for reply message 269 * @sense_length: sense length 270 * @ioc_status: ioc status 271 * @scsi_state: scsi state 272 * @scsi_status: scsi staus 273 * @log_info: log information 274 * @transfer_length: data length transfer when there is a reply message 275 * 276 * Used for sending internal scsi commands to devices within this module. 277 * Refer to _scsi_send_scsi_io(). 278 */ 279 struct _scsi_io_transfer { 280 u16 handle; 281 u8 is_raid; 282 enum dma_data_direction dir; 283 u32 data_length; 284 dma_addr_t data_dma; 285 u8 sense[SCSI_SENSE_BUFFERSIZE]; 286 u32 lun; 287 u8 cdb_length; 288 u8 cdb[32]; 289 u8 timeout; 290 u8 VF_ID; 291 u8 VP_ID; 292 u8 valid_reply; 293 /* the following bits are only valid when 'valid_reply = 1' */ 294 u32 sense_length; 295 u16 ioc_status; 296 u8 scsi_state; 297 u8 scsi_status; 298 u32 log_info; 299 u32 transfer_length; 300 }; 301 302 /** 303 * _scsih_set_debug_level - global setting of ioc->logging_level. 304 * @val: value of the parameter to be set 305 * @kp: pointer to kernel_param structure 306 * 307 * Note: The logging levels are defined in mpt3sas_debug.h. 308 */ 309 static int 310 _scsih_set_debug_level(const char *val, const struct kernel_param *kp) 311 { 312 int ret = param_set_int(val, kp); 313 struct MPT3SAS_ADAPTER *ioc; 314 315 if (ret) 316 return ret; 317 318 pr_info("setting logging_level(0x%08x)\n", logging_level); 319 spin_lock(&gioc_lock); 320 list_for_each_entry(ioc, &mpt3sas_ioc_list, list) 321 ioc->logging_level = logging_level; 322 spin_unlock(&gioc_lock); 323 return 0; 324 } 325 module_param_call(logging_level, _scsih_set_debug_level, param_get_int, 326 &logging_level, 0644); 327 328 /** 329 * _scsih_srch_boot_sas_address - search based on sas_address 330 * @sas_address: sas address 331 * @boot_device: boot device object from bios page 2 332 * 333 * Return: 1 when there's a match, 0 means no match. 334 */ 335 static inline int 336 _scsih_srch_boot_sas_address(u64 sas_address, 337 Mpi2BootDeviceSasWwid_t *boot_device) 338 { 339 return (sas_address == le64_to_cpu(boot_device->SASAddress)) ? 1 : 0; 340 } 341 342 /** 343 * _scsih_srch_boot_device_name - search based on device name 344 * @device_name: device name specified in INDENTIFY fram 345 * @boot_device: boot device object from bios page 2 346 * 347 * Return: 1 when there's a match, 0 means no match. 348 */ 349 static inline int 350 _scsih_srch_boot_device_name(u64 device_name, 351 Mpi2BootDeviceDeviceName_t *boot_device) 352 { 353 return (device_name == le64_to_cpu(boot_device->DeviceName)) ? 1 : 0; 354 } 355 356 /** 357 * _scsih_srch_boot_encl_slot - search based on enclosure_logical_id/slot 358 * @enclosure_logical_id: enclosure logical id 359 * @slot_number: slot number 360 * @boot_device: boot device object from bios page 2 361 * 362 * Return: 1 when there's a match, 0 means no match. 363 */ 364 static inline int 365 _scsih_srch_boot_encl_slot(u64 enclosure_logical_id, u16 slot_number, 366 Mpi2BootDeviceEnclosureSlot_t *boot_device) 367 { 368 return (enclosure_logical_id == le64_to_cpu(boot_device-> 369 EnclosureLogicalID) && slot_number == le16_to_cpu(boot_device-> 370 SlotNumber)) ? 1 : 0; 371 } 372 373 /** 374 * mpt3sas_get_port_by_id - get hba port entry corresponding to provided 375 * port number from port list 376 * @ioc: per adapter object 377 * @port_id: port number 378 * @bypass_dirty_port_flag: when set look the matching hba port entry even 379 * if hba port entry is marked as dirty. 380 * 381 * Search for hba port entry corresponding to provided port number, 382 * if available return port object otherwise return NULL. 383 */ 384 struct hba_port * 385 mpt3sas_get_port_by_id(struct MPT3SAS_ADAPTER *ioc, 386 u8 port_id, u8 bypass_dirty_port_flag) 387 { 388 struct hba_port *port, *port_next; 389 390 /* 391 * When multipath_on_hba is disabled then 392 * search the hba_port entry using default 393 * port id i.e. 255 394 */ 395 if (!ioc->multipath_on_hba) 396 port_id = MULTIPATH_DISABLED_PORT_ID; 397 398 list_for_each_entry_safe(port, port_next, 399 &ioc->port_table_list, list) { 400 if (port->port_id != port_id) 401 continue; 402 if (bypass_dirty_port_flag) 403 return port; 404 if (port->flags & HBA_PORT_FLAG_DIRTY_PORT) 405 continue; 406 return port; 407 } 408 409 /* 410 * Allocate hba_port object for default port id (i.e. 255) 411 * when multipath_on_hba is disabled for the HBA. 412 * And add this object to port_table_list. 413 */ 414 if (!ioc->multipath_on_hba) { 415 port = kzalloc(sizeof(struct hba_port), GFP_ATOMIC); 416 if (!port) 417 return NULL; 418 419 port->port_id = port_id; 420 ioc_info(ioc, 421 "hba_port entry: %p, port: %d is added to hba_port list\n", 422 port, port->port_id); 423 list_add_tail(&port->list, 424 &ioc->port_table_list); 425 return port; 426 } 427 return NULL; 428 } 429 430 /** 431 * mpt3sas_get_vphy_by_phy - get virtual_phy object corresponding to phy number 432 * @ioc: per adapter object 433 * @port: hba_port object 434 * @phy: phy number 435 * 436 * Return virtual_phy object corresponding to phy number. 437 */ 438 struct virtual_phy * 439 mpt3sas_get_vphy_by_phy(struct MPT3SAS_ADAPTER *ioc, 440 struct hba_port *port, u32 phy) 441 { 442 struct virtual_phy *vphy, *vphy_next; 443 444 if (!port->vphys_mask) 445 return NULL; 446 447 list_for_each_entry_safe(vphy, vphy_next, &port->vphys_list, list) { 448 if (vphy->phy_mask & (1 << phy)) 449 return vphy; 450 } 451 return NULL; 452 } 453 454 /** 455 * _scsih_is_boot_device - search for matching boot device. 456 * @sas_address: sas address 457 * @device_name: device name specified in INDENTIFY fram 458 * @enclosure_logical_id: enclosure logical id 459 * @slot: slot number 460 * @form: specifies boot device form 461 * @boot_device: boot device object from bios page 2 462 * 463 * Return: 1 when there's a match, 0 means no match. 464 */ 465 static int 466 _scsih_is_boot_device(u64 sas_address, u64 device_name, 467 u64 enclosure_logical_id, u16 slot, u8 form, 468 Mpi2BiosPage2BootDevice_t *boot_device) 469 { 470 int rc = 0; 471 472 switch (form) { 473 case MPI2_BIOSPAGE2_FORM_SAS_WWID: 474 if (!sas_address) 475 break; 476 rc = _scsih_srch_boot_sas_address( 477 sas_address, &boot_device->SasWwid); 478 break; 479 case MPI2_BIOSPAGE2_FORM_ENCLOSURE_SLOT: 480 if (!enclosure_logical_id) 481 break; 482 rc = _scsih_srch_boot_encl_slot( 483 enclosure_logical_id, 484 slot, &boot_device->EnclosureSlot); 485 break; 486 case MPI2_BIOSPAGE2_FORM_DEVICE_NAME: 487 if (!device_name) 488 break; 489 rc = _scsih_srch_boot_device_name( 490 device_name, &boot_device->DeviceName); 491 break; 492 case MPI2_BIOSPAGE2_FORM_NO_DEVICE_SPECIFIED: 493 break; 494 } 495 496 return rc; 497 } 498 499 /** 500 * _scsih_get_sas_address - set the sas_address for given device handle 501 * @ioc: ? 502 * @handle: device handle 503 * @sas_address: sas address 504 * 505 * Return: 0 success, non-zero when failure 506 */ 507 static int 508 _scsih_get_sas_address(struct MPT3SAS_ADAPTER *ioc, u16 handle, 509 u64 *sas_address) 510 { 511 Mpi2SasDevicePage0_t sas_device_pg0; 512 Mpi2ConfigReply_t mpi_reply; 513 u32 ioc_status; 514 515 *sas_address = 0; 516 517 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 518 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) { 519 ioc_err(ioc, "failure at %s:%d/%s()!\n", 520 __FILE__, __LINE__, __func__); 521 return -ENXIO; 522 } 523 524 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 525 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 526 /* For HBA, vSES doesn't return HBA SAS address. Instead return 527 * vSES's sas address. 528 */ 529 if ((handle <= ioc->sas_hba.num_phys) && 530 (!(le32_to_cpu(sas_device_pg0.DeviceInfo) & 531 MPI2_SAS_DEVICE_INFO_SEP))) 532 *sas_address = ioc->sas_hba.sas_address; 533 else 534 *sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 535 return 0; 536 } 537 538 /* we hit this because the given parent handle doesn't exist */ 539 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE) 540 return -ENXIO; 541 542 /* else error case */ 543 ioc_err(ioc, "handle(0x%04x), ioc_status(0x%04x), failure at %s:%d/%s()!\n", 544 handle, ioc_status, __FILE__, __LINE__, __func__); 545 return -EIO; 546 } 547 548 /** 549 * _scsih_determine_boot_device - determine boot device. 550 * @ioc: per adapter object 551 * @device: sas_device or pcie_device object 552 * @channel: SAS or PCIe channel 553 * 554 * Determines whether this device should be first reported device to 555 * to scsi-ml or sas transport, this purpose is for persistent boot device. 556 * There are primary, alternate, and current entries in bios page 2. The order 557 * priority is primary, alternate, then current. This routine saves 558 * the corresponding device object. 559 * The saved data to be used later in _scsih_probe_boot_devices(). 560 */ 561 static void 562 _scsih_determine_boot_device(struct MPT3SAS_ADAPTER *ioc, void *device, 563 u32 channel) 564 { 565 struct _sas_device *sas_device; 566 struct _pcie_device *pcie_device; 567 struct _raid_device *raid_device; 568 u64 sas_address; 569 u64 device_name; 570 u64 enclosure_logical_id; 571 u16 slot; 572 573 /* only process this function when driver loads */ 574 if (!ioc->is_driver_loading) 575 return; 576 577 /* no Bios, return immediately */ 578 if (!ioc->bios_pg3.BiosVersion) 579 return; 580 581 if (channel == RAID_CHANNEL) { 582 raid_device = device; 583 sas_address = raid_device->wwid; 584 device_name = 0; 585 enclosure_logical_id = 0; 586 slot = 0; 587 } else if (channel == PCIE_CHANNEL) { 588 pcie_device = device; 589 sas_address = pcie_device->wwid; 590 device_name = 0; 591 enclosure_logical_id = 0; 592 slot = 0; 593 } else { 594 sas_device = device; 595 sas_address = sas_device->sas_address; 596 device_name = sas_device->device_name; 597 enclosure_logical_id = sas_device->enclosure_logical_id; 598 slot = sas_device->slot; 599 } 600 601 if (!ioc->req_boot_device.device) { 602 if (_scsih_is_boot_device(sas_address, device_name, 603 enclosure_logical_id, slot, 604 (ioc->bios_pg2.ReqBootDeviceForm & 605 MPI2_BIOSPAGE2_FORM_MASK), 606 &ioc->bios_pg2.RequestedBootDevice)) { 607 dinitprintk(ioc, 608 ioc_info(ioc, "%s: req_boot_device(0x%016llx)\n", 609 __func__, (u64)sas_address)); 610 ioc->req_boot_device.device = device; 611 ioc->req_boot_device.channel = channel; 612 } 613 } 614 615 if (!ioc->req_alt_boot_device.device) { 616 if (_scsih_is_boot_device(sas_address, device_name, 617 enclosure_logical_id, slot, 618 (ioc->bios_pg2.ReqAltBootDeviceForm & 619 MPI2_BIOSPAGE2_FORM_MASK), 620 &ioc->bios_pg2.RequestedAltBootDevice)) { 621 dinitprintk(ioc, 622 ioc_info(ioc, "%s: req_alt_boot_device(0x%016llx)\n", 623 __func__, (u64)sas_address)); 624 ioc->req_alt_boot_device.device = device; 625 ioc->req_alt_boot_device.channel = channel; 626 } 627 } 628 629 if (!ioc->current_boot_device.device) { 630 if (_scsih_is_boot_device(sas_address, device_name, 631 enclosure_logical_id, slot, 632 (ioc->bios_pg2.CurrentBootDeviceForm & 633 MPI2_BIOSPAGE2_FORM_MASK), 634 &ioc->bios_pg2.CurrentBootDevice)) { 635 dinitprintk(ioc, 636 ioc_info(ioc, "%s: current_boot_device(0x%016llx)\n", 637 __func__, (u64)sas_address)); 638 ioc->current_boot_device.device = device; 639 ioc->current_boot_device.channel = channel; 640 } 641 } 642 } 643 644 static struct _sas_device * 645 __mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc, 646 struct MPT3SAS_TARGET *tgt_priv) 647 { 648 struct _sas_device *ret; 649 650 assert_spin_locked(&ioc->sas_device_lock); 651 652 ret = tgt_priv->sas_dev; 653 if (ret) 654 sas_device_get(ret); 655 656 return ret; 657 } 658 659 static struct _sas_device * 660 mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc, 661 struct MPT3SAS_TARGET *tgt_priv) 662 { 663 struct _sas_device *ret; 664 unsigned long flags; 665 666 spin_lock_irqsave(&ioc->sas_device_lock, flags); 667 ret = __mpt3sas_get_sdev_from_target(ioc, tgt_priv); 668 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 669 670 return ret; 671 } 672 673 static struct _pcie_device * 674 __mpt3sas_get_pdev_from_target(struct MPT3SAS_ADAPTER *ioc, 675 struct MPT3SAS_TARGET *tgt_priv) 676 { 677 struct _pcie_device *ret; 678 679 assert_spin_locked(&ioc->pcie_device_lock); 680 681 ret = tgt_priv->pcie_dev; 682 if (ret) 683 pcie_device_get(ret); 684 685 return ret; 686 } 687 688 /** 689 * mpt3sas_get_pdev_from_target - pcie device search 690 * @ioc: per adapter object 691 * @tgt_priv: starget private object 692 * 693 * Context: This function will acquire ioc->pcie_device_lock and will release 694 * before returning the pcie_device object. 695 * 696 * This searches for pcie_device from target, then return pcie_device object. 697 */ 698 static struct _pcie_device * 699 mpt3sas_get_pdev_from_target(struct MPT3SAS_ADAPTER *ioc, 700 struct MPT3SAS_TARGET *tgt_priv) 701 { 702 struct _pcie_device *ret; 703 unsigned long flags; 704 705 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 706 ret = __mpt3sas_get_pdev_from_target(ioc, tgt_priv); 707 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 708 709 return ret; 710 } 711 712 713 /** 714 * __mpt3sas_get_sdev_by_rphy - sas device search 715 * @ioc: per adapter object 716 * @rphy: sas_rphy pointer 717 * 718 * Context: This function will acquire ioc->sas_device_lock and will release 719 * before returning the sas_device object. 720 * 721 * This searches for sas_device from rphy object 722 * then return sas_device object. 723 */ 724 struct _sas_device * 725 __mpt3sas_get_sdev_by_rphy(struct MPT3SAS_ADAPTER *ioc, 726 struct sas_rphy *rphy) 727 { 728 struct _sas_device *sas_device; 729 730 assert_spin_locked(&ioc->sas_device_lock); 731 732 list_for_each_entry(sas_device, &ioc->sas_device_list, list) { 733 if (sas_device->rphy != rphy) 734 continue; 735 sas_device_get(sas_device); 736 return sas_device; 737 } 738 739 sas_device = NULL; 740 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list) { 741 if (sas_device->rphy != rphy) 742 continue; 743 sas_device_get(sas_device); 744 return sas_device; 745 } 746 747 return NULL; 748 } 749 750 /** 751 * __mpt3sas_get_sdev_by_addr - get _sas_device object corresponding to provided 752 * sas address from sas_device_list list 753 * @ioc: per adapter object 754 * @sas_address: device sas address 755 * @port: port number 756 * 757 * Search for _sas_device object corresponding to provided sas address, 758 * if available return _sas_device object address otherwise return NULL. 759 */ 760 struct _sas_device * 761 __mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc, 762 u64 sas_address, struct hba_port *port) 763 { 764 struct _sas_device *sas_device; 765 766 if (!port) 767 return NULL; 768 769 assert_spin_locked(&ioc->sas_device_lock); 770 771 list_for_each_entry(sas_device, &ioc->sas_device_list, list) { 772 if (sas_device->sas_address != sas_address) 773 continue; 774 if (sas_device->port != port) 775 continue; 776 sas_device_get(sas_device); 777 return sas_device; 778 } 779 780 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list) { 781 if (sas_device->sas_address != sas_address) 782 continue; 783 if (sas_device->port != port) 784 continue; 785 sas_device_get(sas_device); 786 return sas_device; 787 } 788 789 return NULL; 790 } 791 792 /** 793 * mpt3sas_get_sdev_by_addr - sas device search 794 * @ioc: per adapter object 795 * @sas_address: sas address 796 * @port: hba port entry 797 * Context: Calling function should acquire ioc->sas_device_lock 798 * 799 * This searches for sas_device based on sas_address & port number, 800 * then return sas_device object. 801 */ 802 struct _sas_device * 803 mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc, 804 u64 sas_address, struct hba_port *port) 805 { 806 struct _sas_device *sas_device; 807 unsigned long flags; 808 809 spin_lock_irqsave(&ioc->sas_device_lock, flags); 810 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 811 sas_address, port); 812 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 813 814 return sas_device; 815 } 816 817 static struct _sas_device * 818 __mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 819 { 820 struct _sas_device *sas_device; 821 822 assert_spin_locked(&ioc->sas_device_lock); 823 824 list_for_each_entry(sas_device, &ioc->sas_device_list, list) 825 if (sas_device->handle == handle) 826 goto found_device; 827 828 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list) 829 if (sas_device->handle == handle) 830 goto found_device; 831 832 return NULL; 833 834 found_device: 835 sas_device_get(sas_device); 836 return sas_device; 837 } 838 839 /** 840 * mpt3sas_get_sdev_by_handle - sas device search 841 * @ioc: per adapter object 842 * @handle: sas device handle (assigned by firmware) 843 * Context: Calling function should acquire ioc->sas_device_lock 844 * 845 * This searches for sas_device based on sas_address, then return sas_device 846 * object. 847 */ 848 struct _sas_device * 849 mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 850 { 851 struct _sas_device *sas_device; 852 unsigned long flags; 853 854 spin_lock_irqsave(&ioc->sas_device_lock, flags); 855 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 856 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 857 858 return sas_device; 859 } 860 861 /** 862 * _scsih_display_enclosure_chassis_info - display device location info 863 * @ioc: per adapter object 864 * @sas_device: per sas device object 865 * @sdev: scsi device struct 866 * @starget: scsi target struct 867 */ 868 static void 869 _scsih_display_enclosure_chassis_info(struct MPT3SAS_ADAPTER *ioc, 870 struct _sas_device *sas_device, struct scsi_device *sdev, 871 struct scsi_target *starget) 872 { 873 if (sdev) { 874 if (sas_device->enclosure_handle != 0) 875 sdev_printk(KERN_INFO, sdev, 876 "enclosure logical id (0x%016llx), slot(%d) \n", 877 (unsigned long long) 878 sas_device->enclosure_logical_id, 879 sas_device->slot); 880 if (sas_device->connector_name[0] != '\0') 881 sdev_printk(KERN_INFO, sdev, 882 "enclosure level(0x%04x), connector name( %s)\n", 883 sas_device->enclosure_level, 884 sas_device->connector_name); 885 if (sas_device->is_chassis_slot_valid) 886 sdev_printk(KERN_INFO, sdev, "chassis slot(0x%04x)\n", 887 sas_device->chassis_slot); 888 } else if (starget) { 889 if (sas_device->enclosure_handle != 0) 890 starget_printk(KERN_INFO, starget, 891 "enclosure logical id(0x%016llx), slot(%d) \n", 892 (unsigned long long) 893 sas_device->enclosure_logical_id, 894 sas_device->slot); 895 if (sas_device->connector_name[0] != '\0') 896 starget_printk(KERN_INFO, starget, 897 "enclosure level(0x%04x), connector name( %s)\n", 898 sas_device->enclosure_level, 899 sas_device->connector_name); 900 if (sas_device->is_chassis_slot_valid) 901 starget_printk(KERN_INFO, starget, 902 "chassis slot(0x%04x)\n", 903 sas_device->chassis_slot); 904 } else { 905 if (sas_device->enclosure_handle != 0) 906 ioc_info(ioc, "enclosure logical id(0x%016llx), slot(%d)\n", 907 (u64)sas_device->enclosure_logical_id, 908 sas_device->slot); 909 if (sas_device->connector_name[0] != '\0') 910 ioc_info(ioc, "enclosure level(0x%04x), connector name( %s)\n", 911 sas_device->enclosure_level, 912 sas_device->connector_name); 913 if (sas_device->is_chassis_slot_valid) 914 ioc_info(ioc, "chassis slot(0x%04x)\n", 915 sas_device->chassis_slot); 916 } 917 } 918 919 /** 920 * _scsih_sas_device_remove - remove sas_device from list. 921 * @ioc: per adapter object 922 * @sas_device: the sas_device object 923 * Context: This function will acquire ioc->sas_device_lock. 924 * 925 * If sas_device is on the list, remove it and decrement its reference count. 926 */ 927 static void 928 _scsih_sas_device_remove(struct MPT3SAS_ADAPTER *ioc, 929 struct _sas_device *sas_device) 930 { 931 unsigned long flags; 932 933 if (!sas_device) 934 return; 935 ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n", 936 sas_device->handle, (u64)sas_device->sas_address); 937 938 _scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL); 939 940 /* 941 * The lock serializes access to the list, but we still need to verify 942 * that nobody removed the entry while we were waiting on the lock. 943 */ 944 spin_lock_irqsave(&ioc->sas_device_lock, flags); 945 if (!list_empty(&sas_device->list)) { 946 list_del_init(&sas_device->list); 947 sas_device_put(sas_device); 948 } 949 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 950 } 951 952 /** 953 * _scsih_device_remove_by_handle - removing device object by handle 954 * @ioc: per adapter object 955 * @handle: device handle 956 */ 957 static void 958 _scsih_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 959 { 960 struct _sas_device *sas_device; 961 unsigned long flags; 962 963 if (ioc->shost_recovery) 964 return; 965 966 spin_lock_irqsave(&ioc->sas_device_lock, flags); 967 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 968 if (sas_device) { 969 list_del_init(&sas_device->list); 970 sas_device_put(sas_device); 971 } 972 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 973 if (sas_device) { 974 _scsih_remove_device(ioc, sas_device); 975 sas_device_put(sas_device); 976 } 977 } 978 979 /** 980 * mpt3sas_device_remove_by_sas_address - removing device object by 981 * sas address & port number 982 * @ioc: per adapter object 983 * @sas_address: device sas_address 984 * @port: hba port entry 985 * 986 * Return nothing. 987 */ 988 void 989 mpt3sas_device_remove_by_sas_address(struct MPT3SAS_ADAPTER *ioc, 990 u64 sas_address, struct hba_port *port) 991 { 992 struct _sas_device *sas_device; 993 unsigned long flags; 994 995 if (ioc->shost_recovery) 996 return; 997 998 spin_lock_irqsave(&ioc->sas_device_lock, flags); 999 sas_device = __mpt3sas_get_sdev_by_addr(ioc, sas_address, port); 1000 if (sas_device) { 1001 list_del_init(&sas_device->list); 1002 sas_device_put(sas_device); 1003 } 1004 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1005 if (sas_device) { 1006 _scsih_remove_device(ioc, sas_device); 1007 sas_device_put(sas_device); 1008 } 1009 } 1010 1011 /** 1012 * _scsih_sas_device_add - insert sas_device to the list. 1013 * @ioc: per adapter object 1014 * @sas_device: the sas_device object 1015 * Context: This function will acquire ioc->sas_device_lock. 1016 * 1017 * Adding new object to the ioc->sas_device_list. 1018 */ 1019 static void 1020 _scsih_sas_device_add(struct MPT3SAS_ADAPTER *ioc, 1021 struct _sas_device *sas_device) 1022 { 1023 unsigned long flags; 1024 1025 dewtprintk(ioc, 1026 ioc_info(ioc, "%s: handle(0x%04x), sas_addr(0x%016llx)\n", 1027 __func__, sas_device->handle, 1028 (u64)sas_device->sas_address)); 1029 1030 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device, 1031 NULL, NULL)); 1032 1033 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1034 sas_device_get(sas_device); 1035 list_add_tail(&sas_device->list, &ioc->sas_device_list); 1036 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1037 1038 if (ioc->hide_drives) { 1039 clear_bit(sas_device->handle, ioc->pend_os_device_add); 1040 return; 1041 } 1042 1043 if (!mpt3sas_transport_port_add(ioc, sas_device->handle, 1044 sas_device->sas_address_parent, sas_device->port)) { 1045 _scsih_sas_device_remove(ioc, sas_device); 1046 } else if (!sas_device->starget) { 1047 /* 1048 * When asyn scanning is enabled, its not possible to remove 1049 * devices while scanning is turned on due to an oops in 1050 * scsi_sysfs_add_sdev()->add_device()->sysfs_addrm_start() 1051 */ 1052 if (!ioc->is_driver_loading) { 1053 mpt3sas_transport_port_remove(ioc, 1054 sas_device->sas_address, 1055 sas_device->sas_address_parent, 1056 sas_device->port); 1057 _scsih_sas_device_remove(ioc, sas_device); 1058 } 1059 } else 1060 clear_bit(sas_device->handle, ioc->pend_os_device_add); 1061 } 1062 1063 /** 1064 * _scsih_sas_device_init_add - insert sas_device to the list. 1065 * @ioc: per adapter object 1066 * @sas_device: the sas_device object 1067 * Context: This function will acquire ioc->sas_device_lock. 1068 * 1069 * Adding new object at driver load time to the ioc->sas_device_init_list. 1070 */ 1071 static void 1072 _scsih_sas_device_init_add(struct MPT3SAS_ADAPTER *ioc, 1073 struct _sas_device *sas_device) 1074 { 1075 unsigned long flags; 1076 1077 dewtprintk(ioc, 1078 ioc_info(ioc, "%s: handle(0x%04x), sas_addr(0x%016llx)\n", 1079 __func__, sas_device->handle, 1080 (u64)sas_device->sas_address)); 1081 1082 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device, 1083 NULL, NULL)); 1084 1085 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1086 sas_device_get(sas_device); 1087 list_add_tail(&sas_device->list, &ioc->sas_device_init_list); 1088 _scsih_determine_boot_device(ioc, sas_device, 0); 1089 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1090 } 1091 1092 1093 static struct _pcie_device * 1094 __mpt3sas_get_pdev_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid) 1095 { 1096 struct _pcie_device *pcie_device; 1097 1098 assert_spin_locked(&ioc->pcie_device_lock); 1099 1100 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) 1101 if (pcie_device->wwid == wwid) 1102 goto found_device; 1103 1104 list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list) 1105 if (pcie_device->wwid == wwid) 1106 goto found_device; 1107 1108 return NULL; 1109 1110 found_device: 1111 pcie_device_get(pcie_device); 1112 return pcie_device; 1113 } 1114 1115 1116 /** 1117 * mpt3sas_get_pdev_by_wwid - pcie device search 1118 * @ioc: per adapter object 1119 * @wwid: wwid 1120 * 1121 * Context: This function will acquire ioc->pcie_device_lock and will release 1122 * before returning the pcie_device object. 1123 * 1124 * This searches for pcie_device based on wwid, then return pcie_device object. 1125 */ 1126 static struct _pcie_device * 1127 mpt3sas_get_pdev_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid) 1128 { 1129 struct _pcie_device *pcie_device; 1130 unsigned long flags; 1131 1132 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 1133 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid); 1134 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 1135 1136 return pcie_device; 1137 } 1138 1139 1140 static struct _pcie_device * 1141 __mpt3sas_get_pdev_by_idchannel(struct MPT3SAS_ADAPTER *ioc, int id, 1142 int channel) 1143 { 1144 struct _pcie_device *pcie_device; 1145 1146 assert_spin_locked(&ioc->pcie_device_lock); 1147 1148 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) 1149 if (pcie_device->id == id && pcie_device->channel == channel) 1150 goto found_device; 1151 1152 list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list) 1153 if (pcie_device->id == id && pcie_device->channel == channel) 1154 goto found_device; 1155 1156 return NULL; 1157 1158 found_device: 1159 pcie_device_get(pcie_device); 1160 return pcie_device; 1161 } 1162 1163 static struct _pcie_device * 1164 __mpt3sas_get_pdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 1165 { 1166 struct _pcie_device *pcie_device; 1167 1168 assert_spin_locked(&ioc->pcie_device_lock); 1169 1170 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) 1171 if (pcie_device->handle == handle) 1172 goto found_device; 1173 1174 list_for_each_entry(pcie_device, &ioc->pcie_device_init_list, list) 1175 if (pcie_device->handle == handle) 1176 goto found_device; 1177 1178 return NULL; 1179 1180 found_device: 1181 pcie_device_get(pcie_device); 1182 return pcie_device; 1183 } 1184 1185 1186 /** 1187 * mpt3sas_get_pdev_by_handle - pcie device search 1188 * @ioc: per adapter object 1189 * @handle: Firmware device handle 1190 * 1191 * Context: This function will acquire ioc->pcie_device_lock and will release 1192 * before returning the pcie_device object. 1193 * 1194 * This searches for pcie_device based on handle, then return pcie_device 1195 * object. 1196 */ 1197 struct _pcie_device * 1198 mpt3sas_get_pdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 1199 { 1200 struct _pcie_device *pcie_device; 1201 unsigned long flags; 1202 1203 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 1204 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle); 1205 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 1206 1207 return pcie_device; 1208 } 1209 1210 /** 1211 * _scsih_set_nvme_max_shutdown_latency - Update max_shutdown_latency. 1212 * @ioc: per adapter object 1213 * Context: This function will acquire ioc->pcie_device_lock 1214 * 1215 * Update ioc->max_shutdown_latency to that NVMe drives RTD3 Entry Latency 1216 * which has reported maximum among all available NVMe drives. 1217 * Minimum max_shutdown_latency will be six seconds. 1218 */ 1219 static void 1220 _scsih_set_nvme_max_shutdown_latency(struct MPT3SAS_ADAPTER *ioc) 1221 { 1222 struct _pcie_device *pcie_device; 1223 unsigned long flags; 1224 u16 shutdown_latency = IO_UNIT_CONTROL_SHUTDOWN_TIMEOUT; 1225 1226 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 1227 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) { 1228 if (pcie_device->shutdown_latency) { 1229 if (shutdown_latency < pcie_device->shutdown_latency) 1230 shutdown_latency = 1231 pcie_device->shutdown_latency; 1232 } 1233 } 1234 ioc->max_shutdown_latency = shutdown_latency; 1235 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 1236 } 1237 1238 /** 1239 * _scsih_pcie_device_remove - remove pcie_device from list. 1240 * @ioc: per adapter object 1241 * @pcie_device: the pcie_device object 1242 * Context: This function will acquire ioc->pcie_device_lock. 1243 * 1244 * If pcie_device is on the list, remove it and decrement its reference count. 1245 */ 1246 static void 1247 _scsih_pcie_device_remove(struct MPT3SAS_ADAPTER *ioc, 1248 struct _pcie_device *pcie_device) 1249 { 1250 unsigned long flags; 1251 int was_on_pcie_device_list = 0; 1252 u8 update_latency = 0; 1253 1254 if (!pcie_device) 1255 return; 1256 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n", 1257 pcie_device->handle, (u64)pcie_device->wwid); 1258 if (pcie_device->enclosure_handle != 0) 1259 ioc_info(ioc, "removing enclosure logical id(0x%016llx), slot(%d)\n", 1260 (u64)pcie_device->enclosure_logical_id, 1261 pcie_device->slot); 1262 if (pcie_device->connector_name[0] != '\0') 1263 ioc_info(ioc, "removing enclosure level(0x%04x), connector name( %s)\n", 1264 pcie_device->enclosure_level, 1265 pcie_device->connector_name); 1266 1267 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 1268 if (!list_empty(&pcie_device->list)) { 1269 list_del_init(&pcie_device->list); 1270 was_on_pcie_device_list = 1; 1271 } 1272 if (pcie_device->shutdown_latency == ioc->max_shutdown_latency) 1273 update_latency = 1; 1274 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 1275 if (was_on_pcie_device_list) { 1276 kfree(pcie_device->serial_number); 1277 pcie_device_put(pcie_device); 1278 } 1279 1280 /* 1281 * This device's RTD3 Entry Latency matches IOC's 1282 * max_shutdown_latency. Recalculate IOC's max_shutdown_latency 1283 * from the available drives as current drive is getting removed. 1284 */ 1285 if (update_latency) 1286 _scsih_set_nvme_max_shutdown_latency(ioc); 1287 } 1288 1289 1290 /** 1291 * _scsih_pcie_device_remove_by_handle - removing pcie device object by handle 1292 * @ioc: per adapter object 1293 * @handle: device handle 1294 */ 1295 static void 1296 _scsih_pcie_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 1297 { 1298 struct _pcie_device *pcie_device; 1299 unsigned long flags; 1300 int was_on_pcie_device_list = 0; 1301 u8 update_latency = 0; 1302 1303 if (ioc->shost_recovery) 1304 return; 1305 1306 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 1307 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle); 1308 if (pcie_device) { 1309 if (!list_empty(&pcie_device->list)) { 1310 list_del_init(&pcie_device->list); 1311 was_on_pcie_device_list = 1; 1312 pcie_device_put(pcie_device); 1313 } 1314 if (pcie_device->shutdown_latency == ioc->max_shutdown_latency) 1315 update_latency = 1; 1316 } 1317 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 1318 if (was_on_pcie_device_list) { 1319 _scsih_pcie_device_remove_from_sml(ioc, pcie_device); 1320 pcie_device_put(pcie_device); 1321 } 1322 1323 /* 1324 * This device's RTD3 Entry Latency matches IOC's 1325 * max_shutdown_latency. Recalculate IOC's max_shutdown_latency 1326 * from the available drives as current drive is getting removed. 1327 */ 1328 if (update_latency) 1329 _scsih_set_nvme_max_shutdown_latency(ioc); 1330 } 1331 1332 /** 1333 * _scsih_pcie_device_add - add pcie_device object 1334 * @ioc: per adapter object 1335 * @pcie_device: pcie_device object 1336 * 1337 * This is added to the pcie_device_list link list. 1338 */ 1339 static void 1340 _scsih_pcie_device_add(struct MPT3SAS_ADAPTER *ioc, 1341 struct _pcie_device *pcie_device) 1342 { 1343 unsigned long flags; 1344 1345 dewtprintk(ioc, 1346 ioc_info(ioc, "%s: handle (0x%04x), wwid(0x%016llx)\n", 1347 __func__, 1348 pcie_device->handle, (u64)pcie_device->wwid)); 1349 if (pcie_device->enclosure_handle != 0) 1350 dewtprintk(ioc, 1351 ioc_info(ioc, "%s: enclosure logical id(0x%016llx), slot( %d)\n", 1352 __func__, 1353 (u64)pcie_device->enclosure_logical_id, 1354 pcie_device->slot)); 1355 if (pcie_device->connector_name[0] != '\0') 1356 dewtprintk(ioc, 1357 ioc_info(ioc, "%s: enclosure level(0x%04x), connector name( %s)\n", 1358 __func__, pcie_device->enclosure_level, 1359 pcie_device->connector_name)); 1360 1361 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 1362 pcie_device_get(pcie_device); 1363 list_add_tail(&pcie_device->list, &ioc->pcie_device_list); 1364 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 1365 1366 if (pcie_device->access_status == 1367 MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED) { 1368 clear_bit(pcie_device->handle, ioc->pend_os_device_add); 1369 return; 1370 } 1371 if (scsi_add_device(ioc->shost, PCIE_CHANNEL, pcie_device->id, 0)) { 1372 _scsih_pcie_device_remove(ioc, pcie_device); 1373 } else if (!pcie_device->starget) { 1374 if (!ioc->is_driver_loading) { 1375 /*TODO-- Need to find out whether this condition will occur or not*/ 1376 clear_bit(pcie_device->handle, ioc->pend_os_device_add); 1377 } 1378 } else 1379 clear_bit(pcie_device->handle, ioc->pend_os_device_add); 1380 } 1381 1382 /* 1383 * _scsih_pcie_device_init_add - insert pcie_device to the init list. 1384 * @ioc: per adapter object 1385 * @pcie_device: the pcie_device object 1386 * Context: This function will acquire ioc->pcie_device_lock. 1387 * 1388 * Adding new object at driver load time to the ioc->pcie_device_init_list. 1389 */ 1390 static void 1391 _scsih_pcie_device_init_add(struct MPT3SAS_ADAPTER *ioc, 1392 struct _pcie_device *pcie_device) 1393 { 1394 unsigned long flags; 1395 1396 dewtprintk(ioc, 1397 ioc_info(ioc, "%s: handle (0x%04x), wwid(0x%016llx)\n", 1398 __func__, 1399 pcie_device->handle, (u64)pcie_device->wwid)); 1400 if (pcie_device->enclosure_handle != 0) 1401 dewtprintk(ioc, 1402 ioc_info(ioc, "%s: enclosure logical id(0x%016llx), slot( %d)\n", 1403 __func__, 1404 (u64)pcie_device->enclosure_logical_id, 1405 pcie_device->slot)); 1406 if (pcie_device->connector_name[0] != '\0') 1407 dewtprintk(ioc, 1408 ioc_info(ioc, "%s: enclosure level(0x%04x), connector name( %s)\n", 1409 __func__, pcie_device->enclosure_level, 1410 pcie_device->connector_name)); 1411 1412 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 1413 pcie_device_get(pcie_device); 1414 list_add_tail(&pcie_device->list, &ioc->pcie_device_init_list); 1415 if (pcie_device->access_status != 1416 MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED) 1417 _scsih_determine_boot_device(ioc, pcie_device, PCIE_CHANNEL); 1418 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 1419 } 1420 /** 1421 * _scsih_raid_device_find_by_id - raid device search 1422 * @ioc: per adapter object 1423 * @id: sas device target id 1424 * @channel: sas device channel 1425 * Context: Calling function should acquire ioc->raid_device_lock 1426 * 1427 * This searches for raid_device based on target id, then return raid_device 1428 * object. 1429 */ 1430 static struct _raid_device * 1431 _scsih_raid_device_find_by_id(struct MPT3SAS_ADAPTER *ioc, int id, int channel) 1432 { 1433 struct _raid_device *raid_device, *r; 1434 1435 r = NULL; 1436 list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 1437 if (raid_device->id == id && raid_device->channel == channel) { 1438 r = raid_device; 1439 goto out; 1440 } 1441 } 1442 1443 out: 1444 return r; 1445 } 1446 1447 /** 1448 * mpt3sas_raid_device_find_by_handle - raid device search 1449 * @ioc: per adapter object 1450 * @handle: sas device handle (assigned by firmware) 1451 * Context: Calling function should acquire ioc->raid_device_lock 1452 * 1453 * This searches for raid_device based on handle, then return raid_device 1454 * object. 1455 */ 1456 struct _raid_device * 1457 mpt3sas_raid_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 1458 { 1459 struct _raid_device *raid_device, *r; 1460 1461 r = NULL; 1462 list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 1463 if (raid_device->handle != handle) 1464 continue; 1465 r = raid_device; 1466 goto out; 1467 } 1468 1469 out: 1470 return r; 1471 } 1472 1473 /** 1474 * _scsih_raid_device_find_by_wwid - raid device search 1475 * @ioc: per adapter object 1476 * @wwid: ? 1477 * Context: Calling function should acquire ioc->raid_device_lock 1478 * 1479 * This searches for raid_device based on wwid, then return raid_device 1480 * object. 1481 */ 1482 static struct _raid_device * 1483 _scsih_raid_device_find_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid) 1484 { 1485 struct _raid_device *raid_device, *r; 1486 1487 r = NULL; 1488 list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 1489 if (raid_device->wwid != wwid) 1490 continue; 1491 r = raid_device; 1492 goto out; 1493 } 1494 1495 out: 1496 return r; 1497 } 1498 1499 /** 1500 * _scsih_raid_device_add - add raid_device object 1501 * @ioc: per adapter object 1502 * @raid_device: raid_device object 1503 * 1504 * This is added to the raid_device_list link list. 1505 */ 1506 static void 1507 _scsih_raid_device_add(struct MPT3SAS_ADAPTER *ioc, 1508 struct _raid_device *raid_device) 1509 { 1510 unsigned long flags; 1511 1512 dewtprintk(ioc, 1513 ioc_info(ioc, "%s: handle(0x%04x), wwid(0x%016llx)\n", 1514 __func__, 1515 raid_device->handle, (u64)raid_device->wwid)); 1516 1517 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1518 list_add_tail(&raid_device->list, &ioc->raid_device_list); 1519 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1520 } 1521 1522 /** 1523 * _scsih_raid_device_remove - delete raid_device object 1524 * @ioc: per adapter object 1525 * @raid_device: raid_device object 1526 * 1527 */ 1528 static void 1529 _scsih_raid_device_remove(struct MPT3SAS_ADAPTER *ioc, 1530 struct _raid_device *raid_device) 1531 { 1532 unsigned long flags; 1533 1534 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1535 list_del(&raid_device->list); 1536 kfree(raid_device); 1537 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1538 } 1539 1540 /** 1541 * mpt3sas_scsih_expander_find_by_handle - expander device search 1542 * @ioc: per adapter object 1543 * @handle: expander handle (assigned by firmware) 1544 * Context: Calling function should acquire ioc->sas_device_lock 1545 * 1546 * This searches for expander device based on handle, then returns the 1547 * sas_node object. 1548 */ 1549 struct _sas_node * 1550 mpt3sas_scsih_expander_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 1551 { 1552 struct _sas_node *sas_expander, *r; 1553 1554 r = NULL; 1555 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) { 1556 if (sas_expander->handle != handle) 1557 continue; 1558 r = sas_expander; 1559 goto out; 1560 } 1561 out: 1562 return r; 1563 } 1564 1565 /** 1566 * mpt3sas_scsih_enclosure_find_by_handle - exclosure device search 1567 * @ioc: per adapter object 1568 * @handle: enclosure handle (assigned by firmware) 1569 * Context: Calling function should acquire ioc->sas_device_lock 1570 * 1571 * This searches for enclosure device based on handle, then returns the 1572 * enclosure object. 1573 */ 1574 static struct _enclosure_node * 1575 mpt3sas_scsih_enclosure_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 1576 { 1577 struct _enclosure_node *enclosure_dev, *r; 1578 1579 r = NULL; 1580 list_for_each_entry(enclosure_dev, &ioc->enclosure_list, list) { 1581 if (le16_to_cpu(enclosure_dev->pg0.EnclosureHandle) != handle) 1582 continue; 1583 r = enclosure_dev; 1584 goto out; 1585 } 1586 out: 1587 return r; 1588 } 1589 /** 1590 * mpt3sas_scsih_expander_find_by_sas_address - expander device search 1591 * @ioc: per adapter object 1592 * @sas_address: sas address 1593 * @port: hba port entry 1594 * Context: Calling function should acquire ioc->sas_node_lock. 1595 * 1596 * This searches for expander device based on sas_address & port number, 1597 * then returns the sas_node object. 1598 */ 1599 struct _sas_node * 1600 mpt3sas_scsih_expander_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc, 1601 u64 sas_address, struct hba_port *port) 1602 { 1603 struct _sas_node *sas_expander, *r = NULL; 1604 1605 if (!port) 1606 return r; 1607 1608 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) { 1609 if (sas_expander->sas_address != sas_address) 1610 continue; 1611 if (sas_expander->port != port) 1612 continue; 1613 r = sas_expander; 1614 goto out; 1615 } 1616 out: 1617 return r; 1618 } 1619 1620 /** 1621 * _scsih_expander_node_add - insert expander device to the list. 1622 * @ioc: per adapter object 1623 * @sas_expander: the sas_device object 1624 * Context: This function will acquire ioc->sas_node_lock. 1625 * 1626 * Adding new object to the ioc->sas_expander_list. 1627 */ 1628 static void 1629 _scsih_expander_node_add(struct MPT3SAS_ADAPTER *ioc, 1630 struct _sas_node *sas_expander) 1631 { 1632 unsigned long flags; 1633 1634 spin_lock_irqsave(&ioc->sas_node_lock, flags); 1635 list_add_tail(&sas_expander->list, &ioc->sas_expander_list); 1636 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 1637 } 1638 1639 /** 1640 * _scsih_is_end_device - determines if device is an end device 1641 * @device_info: bitfield providing information about the device. 1642 * Context: none 1643 * 1644 * Return: 1 if end device. 1645 */ 1646 static int 1647 _scsih_is_end_device(u32 device_info) 1648 { 1649 if (device_info & MPI2_SAS_DEVICE_INFO_END_DEVICE && 1650 ((device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) | 1651 (device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET) | 1652 (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE))) 1653 return 1; 1654 else 1655 return 0; 1656 } 1657 1658 /** 1659 * _scsih_is_nvme_pciescsi_device - determines if 1660 * device is an pcie nvme/scsi device 1661 * @device_info: bitfield providing information about the device. 1662 * Context: none 1663 * 1664 * Returns 1 if device is pcie device type nvme/scsi. 1665 */ 1666 static int 1667 _scsih_is_nvme_pciescsi_device(u32 device_info) 1668 { 1669 if (((device_info & MPI26_PCIE_DEVINFO_MASK_DEVICE_TYPE) 1670 == MPI26_PCIE_DEVINFO_NVME) || 1671 ((device_info & MPI26_PCIE_DEVINFO_MASK_DEVICE_TYPE) 1672 == MPI26_PCIE_DEVINFO_SCSI)) 1673 return 1; 1674 else 1675 return 0; 1676 } 1677 1678 /** 1679 * _scsih_scsi_lookup_find_by_target - search for matching channel:id 1680 * @ioc: per adapter object 1681 * @id: target id 1682 * @channel: channel 1683 * Context: This function will acquire ioc->scsi_lookup_lock. 1684 * 1685 * This will search for a matching channel:id in the scsi_lookup array, 1686 * returning 1 if found. 1687 */ 1688 static u8 1689 _scsih_scsi_lookup_find_by_target(struct MPT3SAS_ADAPTER *ioc, int id, 1690 int channel) 1691 { 1692 int smid; 1693 struct scsi_cmnd *scmd; 1694 1695 for (smid = 1; 1696 smid <= ioc->shost->can_queue; smid++) { 1697 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid); 1698 if (!scmd) 1699 continue; 1700 if (scmd->device->id == id && 1701 scmd->device->channel == channel) 1702 return 1; 1703 } 1704 return 0; 1705 } 1706 1707 /** 1708 * _scsih_scsi_lookup_find_by_lun - search for matching channel:id:lun 1709 * @ioc: per adapter object 1710 * @id: target id 1711 * @lun: lun number 1712 * @channel: channel 1713 * Context: This function will acquire ioc->scsi_lookup_lock. 1714 * 1715 * This will search for a matching channel:id:lun in the scsi_lookup array, 1716 * returning 1 if found. 1717 */ 1718 static u8 1719 _scsih_scsi_lookup_find_by_lun(struct MPT3SAS_ADAPTER *ioc, int id, 1720 unsigned int lun, int channel) 1721 { 1722 int smid; 1723 struct scsi_cmnd *scmd; 1724 1725 for (smid = 1; smid <= ioc->shost->can_queue; smid++) { 1726 1727 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid); 1728 if (!scmd) 1729 continue; 1730 if (scmd->device->id == id && 1731 scmd->device->channel == channel && 1732 scmd->device->lun == lun) 1733 return 1; 1734 } 1735 return 0; 1736 } 1737 1738 /** 1739 * mpt3sas_scsih_scsi_lookup_get - returns scmd entry 1740 * @ioc: per adapter object 1741 * @smid: system request message index 1742 * 1743 * Return: the smid stored scmd pointer. 1744 * Then will dereference the stored scmd pointer. 1745 */ 1746 struct scsi_cmnd * 1747 mpt3sas_scsih_scsi_lookup_get(struct MPT3SAS_ADAPTER *ioc, u16 smid) 1748 { 1749 struct scsi_cmnd *scmd = NULL; 1750 struct scsiio_tracker *st; 1751 Mpi25SCSIIORequest_t *mpi_request; 1752 u16 tag = smid - 1; 1753 1754 if (smid > 0 && 1755 smid <= ioc->scsiio_depth - INTERNAL_SCSIIO_CMDS_COUNT) { 1756 u32 unique_tag = 1757 ioc->io_queue_num[tag] << BLK_MQ_UNIQUE_TAG_BITS | tag; 1758 1759 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 1760 1761 /* 1762 * If SCSI IO request is outstanding at driver level then 1763 * DevHandle filed must be non-zero. If DevHandle is zero 1764 * then it means that this smid is free at driver level, 1765 * so return NULL. 1766 */ 1767 if (!mpi_request->DevHandle) 1768 return scmd; 1769 1770 scmd = scsi_host_find_tag(ioc->shost, unique_tag); 1771 if (scmd) { 1772 st = scsi_cmd_priv(scmd); 1773 if (st->cb_idx == 0xFF || st->smid == 0) 1774 scmd = NULL; 1775 } 1776 } 1777 return scmd; 1778 } 1779 1780 /** 1781 * scsih_change_queue_depth - setting device queue depth 1782 * @sdev: scsi device struct 1783 * @qdepth: requested queue depth 1784 * 1785 * Return: queue depth. 1786 */ 1787 static int 1788 scsih_change_queue_depth(struct scsi_device *sdev, int qdepth) 1789 { 1790 struct Scsi_Host *shost = sdev->host; 1791 int max_depth; 1792 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 1793 struct MPT3SAS_DEVICE *sas_device_priv_data; 1794 struct MPT3SAS_TARGET *sas_target_priv_data; 1795 struct _sas_device *sas_device; 1796 unsigned long flags; 1797 1798 max_depth = shost->can_queue; 1799 1800 /* 1801 * limit max device queue for SATA to 32 if enable_sdev_max_qd 1802 * is disabled. 1803 */ 1804 if (ioc->enable_sdev_max_qd || ioc->is_gen35_ioc) 1805 goto not_sata; 1806 1807 sas_device_priv_data = sdev->hostdata; 1808 if (!sas_device_priv_data) 1809 goto not_sata; 1810 sas_target_priv_data = sas_device_priv_data->sas_target; 1811 if (!sas_target_priv_data) 1812 goto not_sata; 1813 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) 1814 goto not_sata; 1815 1816 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1817 sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data); 1818 if (sas_device) { 1819 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE) 1820 max_depth = MPT3SAS_SATA_QUEUE_DEPTH; 1821 1822 sas_device_put(sas_device); 1823 } 1824 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1825 1826 not_sata: 1827 1828 if (!sdev->tagged_supported) 1829 max_depth = 1; 1830 if (qdepth > max_depth) 1831 qdepth = max_depth; 1832 scsi_change_queue_depth(sdev, qdepth); 1833 sdev_printk(KERN_INFO, sdev, 1834 "qdepth(%d), tagged(%d), scsi_level(%d), cmd_que(%d)\n", 1835 sdev->queue_depth, sdev->tagged_supported, 1836 sdev->scsi_level, ((sdev->inquiry[7] & 2) >> 1)); 1837 return sdev->queue_depth; 1838 } 1839 1840 /** 1841 * mpt3sas_scsih_change_queue_depth - setting device queue depth 1842 * @sdev: scsi device struct 1843 * @qdepth: requested queue depth 1844 * 1845 * Returns nothing. 1846 */ 1847 void 1848 mpt3sas_scsih_change_queue_depth(struct scsi_device *sdev, int qdepth) 1849 { 1850 struct Scsi_Host *shost = sdev->host; 1851 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 1852 1853 if (ioc->enable_sdev_max_qd) 1854 qdepth = shost->can_queue; 1855 1856 scsih_change_queue_depth(sdev, qdepth); 1857 } 1858 1859 /** 1860 * scsih_target_alloc - target add routine 1861 * @starget: scsi target struct 1862 * 1863 * Return: 0 if ok. Any other return is assumed to be an error and 1864 * the device is ignored. 1865 */ 1866 static int 1867 scsih_target_alloc(struct scsi_target *starget) 1868 { 1869 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 1870 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 1871 struct MPT3SAS_TARGET *sas_target_priv_data; 1872 struct _sas_device *sas_device; 1873 struct _raid_device *raid_device; 1874 struct _pcie_device *pcie_device; 1875 unsigned long flags; 1876 struct sas_rphy *rphy; 1877 1878 sas_target_priv_data = kzalloc(sizeof(*sas_target_priv_data), 1879 GFP_KERNEL); 1880 if (!sas_target_priv_data) 1881 return -ENOMEM; 1882 1883 starget->hostdata = sas_target_priv_data; 1884 sas_target_priv_data->starget = starget; 1885 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE; 1886 1887 /* RAID volumes */ 1888 if (starget->channel == RAID_CHANNEL) { 1889 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1890 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id, 1891 starget->channel); 1892 if (raid_device) { 1893 sas_target_priv_data->handle = raid_device->handle; 1894 sas_target_priv_data->sas_address = raid_device->wwid; 1895 sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME; 1896 if (ioc->is_warpdrive) 1897 sas_target_priv_data->raid_device = raid_device; 1898 raid_device->starget = starget; 1899 } 1900 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1901 return 0; 1902 } 1903 1904 /* PCIe devices */ 1905 if (starget->channel == PCIE_CHANNEL) { 1906 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 1907 pcie_device = __mpt3sas_get_pdev_by_idchannel(ioc, starget->id, 1908 starget->channel); 1909 if (pcie_device) { 1910 sas_target_priv_data->handle = pcie_device->handle; 1911 sas_target_priv_data->sas_address = pcie_device->wwid; 1912 sas_target_priv_data->port = NULL; 1913 sas_target_priv_data->pcie_dev = pcie_device; 1914 pcie_device->starget = starget; 1915 pcie_device->id = starget->id; 1916 pcie_device->channel = starget->channel; 1917 sas_target_priv_data->flags |= 1918 MPT_TARGET_FLAGS_PCIE_DEVICE; 1919 if (pcie_device->fast_path) 1920 sas_target_priv_data->flags |= 1921 MPT_TARGET_FASTPATH_IO; 1922 } 1923 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 1924 return 0; 1925 } 1926 1927 /* sas/sata devices */ 1928 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1929 rphy = dev_to_rphy(starget->dev.parent); 1930 sas_device = __mpt3sas_get_sdev_by_rphy(ioc, rphy); 1931 1932 if (sas_device) { 1933 sas_target_priv_data->handle = sas_device->handle; 1934 sas_target_priv_data->sas_address = sas_device->sas_address; 1935 sas_target_priv_data->port = sas_device->port; 1936 sas_target_priv_data->sas_dev = sas_device; 1937 sas_device->starget = starget; 1938 sas_device->id = starget->id; 1939 sas_device->channel = starget->channel; 1940 if (test_bit(sas_device->handle, ioc->pd_handles)) 1941 sas_target_priv_data->flags |= 1942 MPT_TARGET_FLAGS_RAID_COMPONENT; 1943 if (sas_device->fast_path) 1944 sas_target_priv_data->flags |= 1945 MPT_TARGET_FASTPATH_IO; 1946 } 1947 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1948 1949 return 0; 1950 } 1951 1952 /** 1953 * scsih_target_destroy - target destroy routine 1954 * @starget: scsi target struct 1955 */ 1956 static void 1957 scsih_target_destroy(struct scsi_target *starget) 1958 { 1959 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 1960 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 1961 struct MPT3SAS_TARGET *sas_target_priv_data; 1962 struct _sas_device *sas_device; 1963 struct _raid_device *raid_device; 1964 struct _pcie_device *pcie_device; 1965 unsigned long flags; 1966 1967 sas_target_priv_data = starget->hostdata; 1968 if (!sas_target_priv_data) 1969 return; 1970 1971 if (starget->channel == RAID_CHANNEL) { 1972 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1973 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id, 1974 starget->channel); 1975 if (raid_device) { 1976 raid_device->starget = NULL; 1977 raid_device->sdev = NULL; 1978 } 1979 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1980 goto out; 1981 } 1982 1983 if (starget->channel == PCIE_CHANNEL) { 1984 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 1985 pcie_device = __mpt3sas_get_pdev_from_target(ioc, 1986 sas_target_priv_data); 1987 if (pcie_device && (pcie_device->starget == starget) && 1988 (pcie_device->id == starget->id) && 1989 (pcie_device->channel == starget->channel)) 1990 pcie_device->starget = NULL; 1991 1992 if (pcie_device) { 1993 /* 1994 * Corresponding get() is in _scsih_target_alloc() 1995 */ 1996 sas_target_priv_data->pcie_dev = NULL; 1997 pcie_device_put(pcie_device); 1998 pcie_device_put(pcie_device); 1999 } 2000 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 2001 goto out; 2002 } 2003 2004 spin_lock_irqsave(&ioc->sas_device_lock, flags); 2005 sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data); 2006 if (sas_device && (sas_device->starget == starget) && 2007 (sas_device->id == starget->id) && 2008 (sas_device->channel == starget->channel)) 2009 sas_device->starget = NULL; 2010 2011 if (sas_device) { 2012 /* 2013 * Corresponding get() is in _scsih_target_alloc() 2014 */ 2015 sas_target_priv_data->sas_dev = NULL; 2016 sas_device_put(sas_device); 2017 2018 sas_device_put(sas_device); 2019 } 2020 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 2021 2022 out: 2023 kfree(sas_target_priv_data); 2024 starget->hostdata = NULL; 2025 } 2026 2027 /** 2028 * scsih_slave_alloc - device add routine 2029 * @sdev: scsi device struct 2030 * 2031 * Return: 0 if ok. Any other return is assumed to be an error and 2032 * the device is ignored. 2033 */ 2034 static int 2035 scsih_slave_alloc(struct scsi_device *sdev) 2036 { 2037 struct Scsi_Host *shost; 2038 struct MPT3SAS_ADAPTER *ioc; 2039 struct MPT3SAS_TARGET *sas_target_priv_data; 2040 struct MPT3SAS_DEVICE *sas_device_priv_data; 2041 struct scsi_target *starget; 2042 struct _raid_device *raid_device; 2043 struct _sas_device *sas_device; 2044 struct _pcie_device *pcie_device; 2045 unsigned long flags; 2046 2047 sas_device_priv_data = kzalloc(sizeof(*sas_device_priv_data), 2048 GFP_KERNEL); 2049 if (!sas_device_priv_data) 2050 return -ENOMEM; 2051 2052 sas_device_priv_data->lun = sdev->lun; 2053 sas_device_priv_data->flags = MPT_DEVICE_FLAGS_INIT; 2054 2055 starget = scsi_target(sdev); 2056 sas_target_priv_data = starget->hostdata; 2057 sas_target_priv_data->num_luns++; 2058 sas_device_priv_data->sas_target = sas_target_priv_data; 2059 sdev->hostdata = sas_device_priv_data; 2060 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT)) 2061 sdev->no_uld_attach = 1; 2062 2063 shost = dev_to_shost(&starget->dev); 2064 ioc = shost_priv(shost); 2065 if (starget->channel == RAID_CHANNEL) { 2066 spin_lock_irqsave(&ioc->raid_device_lock, flags); 2067 raid_device = _scsih_raid_device_find_by_id(ioc, 2068 starget->id, starget->channel); 2069 if (raid_device) 2070 raid_device->sdev = sdev; /* raid is single lun */ 2071 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 2072 } 2073 if (starget->channel == PCIE_CHANNEL) { 2074 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 2075 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, 2076 sas_target_priv_data->sas_address); 2077 if (pcie_device && (pcie_device->starget == NULL)) { 2078 sdev_printk(KERN_INFO, sdev, 2079 "%s : pcie_device->starget set to starget @ %d\n", 2080 __func__, __LINE__); 2081 pcie_device->starget = starget; 2082 } 2083 2084 if (pcie_device) 2085 pcie_device_put(pcie_device); 2086 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 2087 2088 } else if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) { 2089 spin_lock_irqsave(&ioc->sas_device_lock, flags); 2090 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 2091 sas_target_priv_data->sas_address, 2092 sas_target_priv_data->port); 2093 if (sas_device && (sas_device->starget == NULL)) { 2094 sdev_printk(KERN_INFO, sdev, 2095 "%s : sas_device->starget set to starget @ %d\n", 2096 __func__, __LINE__); 2097 sas_device->starget = starget; 2098 } 2099 2100 if (sas_device) 2101 sas_device_put(sas_device); 2102 2103 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 2104 } 2105 2106 return 0; 2107 } 2108 2109 /** 2110 * scsih_slave_destroy - device destroy routine 2111 * @sdev: scsi device struct 2112 */ 2113 static void 2114 scsih_slave_destroy(struct scsi_device *sdev) 2115 { 2116 struct MPT3SAS_TARGET *sas_target_priv_data; 2117 struct scsi_target *starget; 2118 struct Scsi_Host *shost; 2119 struct MPT3SAS_ADAPTER *ioc; 2120 struct _sas_device *sas_device; 2121 struct _pcie_device *pcie_device; 2122 unsigned long flags; 2123 2124 if (!sdev->hostdata) 2125 return; 2126 2127 starget = scsi_target(sdev); 2128 sas_target_priv_data = starget->hostdata; 2129 sas_target_priv_data->num_luns--; 2130 2131 shost = dev_to_shost(&starget->dev); 2132 ioc = shost_priv(shost); 2133 2134 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) { 2135 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 2136 pcie_device = __mpt3sas_get_pdev_from_target(ioc, 2137 sas_target_priv_data); 2138 if (pcie_device && !sas_target_priv_data->num_luns) 2139 pcie_device->starget = NULL; 2140 2141 if (pcie_device) 2142 pcie_device_put(pcie_device); 2143 2144 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 2145 2146 } else if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) { 2147 spin_lock_irqsave(&ioc->sas_device_lock, flags); 2148 sas_device = __mpt3sas_get_sdev_from_target(ioc, 2149 sas_target_priv_data); 2150 if (sas_device && !sas_target_priv_data->num_luns) 2151 sas_device->starget = NULL; 2152 2153 if (sas_device) 2154 sas_device_put(sas_device); 2155 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 2156 } 2157 2158 kfree(sdev->hostdata); 2159 sdev->hostdata = NULL; 2160 } 2161 2162 /** 2163 * _scsih_display_sata_capabilities - sata capabilities 2164 * @ioc: per adapter object 2165 * @handle: device handle 2166 * @sdev: scsi device struct 2167 */ 2168 static void 2169 _scsih_display_sata_capabilities(struct MPT3SAS_ADAPTER *ioc, 2170 u16 handle, struct scsi_device *sdev) 2171 { 2172 Mpi2ConfigReply_t mpi_reply; 2173 Mpi2SasDevicePage0_t sas_device_pg0; 2174 u32 ioc_status; 2175 u16 flags; 2176 u32 device_info; 2177 2178 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 2179 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) { 2180 ioc_err(ioc, "failure at %s:%d/%s()!\n", 2181 __FILE__, __LINE__, __func__); 2182 return; 2183 } 2184 2185 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 2186 MPI2_IOCSTATUS_MASK; 2187 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 2188 ioc_err(ioc, "failure at %s:%d/%s()!\n", 2189 __FILE__, __LINE__, __func__); 2190 return; 2191 } 2192 2193 flags = le16_to_cpu(sas_device_pg0.Flags); 2194 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 2195 2196 sdev_printk(KERN_INFO, sdev, 2197 "atapi(%s), ncq(%s), asyn_notify(%s), smart(%s), fua(%s), " 2198 "sw_preserve(%s)\n", 2199 (device_info & MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? "y" : "n", 2200 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_NCQ_SUPPORTED) ? "y" : "n", 2201 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_ASYNCHRONOUS_NOTIFY) ? "y" : 2202 "n", 2203 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SMART_SUPPORTED) ? "y" : "n", 2204 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_FUA_SUPPORTED) ? "y" : "n", 2205 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SW_PRESERVE) ? "y" : "n"); 2206 } 2207 2208 /* 2209 * raid transport support - 2210 * Enabled for SLES11 and newer, in older kernels the driver will panic when 2211 * unloading the driver followed by a load - I believe that the subroutine 2212 * raid_class_release() is not cleaning up properly. 2213 */ 2214 2215 /** 2216 * scsih_is_raid - return boolean indicating device is raid volume 2217 * @dev: the device struct object 2218 */ 2219 static int 2220 scsih_is_raid(struct device *dev) 2221 { 2222 struct scsi_device *sdev = to_scsi_device(dev); 2223 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host); 2224 2225 if (ioc->is_warpdrive) 2226 return 0; 2227 return (sdev->channel == RAID_CHANNEL) ? 1 : 0; 2228 } 2229 2230 static int 2231 scsih_is_nvme(struct device *dev) 2232 { 2233 struct scsi_device *sdev = to_scsi_device(dev); 2234 2235 return (sdev->channel == PCIE_CHANNEL) ? 1 : 0; 2236 } 2237 2238 /** 2239 * scsih_get_resync - get raid volume resync percent complete 2240 * @dev: the device struct object 2241 */ 2242 static void 2243 scsih_get_resync(struct device *dev) 2244 { 2245 struct scsi_device *sdev = to_scsi_device(dev); 2246 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host); 2247 static struct _raid_device *raid_device; 2248 unsigned long flags; 2249 Mpi2RaidVolPage0_t vol_pg0; 2250 Mpi2ConfigReply_t mpi_reply; 2251 u32 volume_status_flags; 2252 u8 percent_complete; 2253 u16 handle; 2254 2255 percent_complete = 0; 2256 handle = 0; 2257 if (ioc->is_warpdrive) 2258 goto out; 2259 2260 spin_lock_irqsave(&ioc->raid_device_lock, flags); 2261 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id, 2262 sdev->channel); 2263 if (raid_device) { 2264 handle = raid_device->handle; 2265 percent_complete = raid_device->percent_complete; 2266 } 2267 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 2268 2269 if (!handle) 2270 goto out; 2271 2272 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0, 2273 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle, 2274 sizeof(Mpi2RaidVolPage0_t))) { 2275 ioc_err(ioc, "failure at %s:%d/%s()!\n", 2276 __FILE__, __LINE__, __func__); 2277 percent_complete = 0; 2278 goto out; 2279 } 2280 2281 volume_status_flags = le32_to_cpu(vol_pg0.VolumeStatusFlags); 2282 if (!(volume_status_flags & 2283 MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS)) 2284 percent_complete = 0; 2285 2286 out: 2287 2288 switch (ioc->hba_mpi_version_belonged) { 2289 case MPI2_VERSION: 2290 raid_set_resync(mpt2sas_raid_template, dev, percent_complete); 2291 break; 2292 case MPI25_VERSION: 2293 case MPI26_VERSION: 2294 raid_set_resync(mpt3sas_raid_template, dev, percent_complete); 2295 break; 2296 } 2297 } 2298 2299 /** 2300 * scsih_get_state - get raid volume level 2301 * @dev: the device struct object 2302 */ 2303 static void 2304 scsih_get_state(struct device *dev) 2305 { 2306 struct scsi_device *sdev = to_scsi_device(dev); 2307 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host); 2308 static struct _raid_device *raid_device; 2309 unsigned long flags; 2310 Mpi2RaidVolPage0_t vol_pg0; 2311 Mpi2ConfigReply_t mpi_reply; 2312 u32 volstate; 2313 enum raid_state state = RAID_STATE_UNKNOWN; 2314 u16 handle = 0; 2315 2316 spin_lock_irqsave(&ioc->raid_device_lock, flags); 2317 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id, 2318 sdev->channel); 2319 if (raid_device) 2320 handle = raid_device->handle; 2321 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 2322 2323 if (!raid_device) 2324 goto out; 2325 2326 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0, 2327 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle, 2328 sizeof(Mpi2RaidVolPage0_t))) { 2329 ioc_err(ioc, "failure at %s:%d/%s()!\n", 2330 __FILE__, __LINE__, __func__); 2331 goto out; 2332 } 2333 2334 volstate = le32_to_cpu(vol_pg0.VolumeStatusFlags); 2335 if (volstate & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) { 2336 state = RAID_STATE_RESYNCING; 2337 goto out; 2338 } 2339 2340 switch (vol_pg0.VolumeState) { 2341 case MPI2_RAID_VOL_STATE_OPTIMAL: 2342 case MPI2_RAID_VOL_STATE_ONLINE: 2343 state = RAID_STATE_ACTIVE; 2344 break; 2345 case MPI2_RAID_VOL_STATE_DEGRADED: 2346 state = RAID_STATE_DEGRADED; 2347 break; 2348 case MPI2_RAID_VOL_STATE_FAILED: 2349 case MPI2_RAID_VOL_STATE_MISSING: 2350 state = RAID_STATE_OFFLINE; 2351 break; 2352 } 2353 out: 2354 switch (ioc->hba_mpi_version_belonged) { 2355 case MPI2_VERSION: 2356 raid_set_state(mpt2sas_raid_template, dev, state); 2357 break; 2358 case MPI25_VERSION: 2359 case MPI26_VERSION: 2360 raid_set_state(mpt3sas_raid_template, dev, state); 2361 break; 2362 } 2363 } 2364 2365 /** 2366 * _scsih_set_level - set raid level 2367 * @ioc: ? 2368 * @sdev: scsi device struct 2369 * @volume_type: volume type 2370 */ 2371 static void 2372 _scsih_set_level(struct MPT3SAS_ADAPTER *ioc, 2373 struct scsi_device *sdev, u8 volume_type) 2374 { 2375 enum raid_level level = RAID_LEVEL_UNKNOWN; 2376 2377 switch (volume_type) { 2378 case MPI2_RAID_VOL_TYPE_RAID0: 2379 level = RAID_LEVEL_0; 2380 break; 2381 case MPI2_RAID_VOL_TYPE_RAID10: 2382 level = RAID_LEVEL_10; 2383 break; 2384 case MPI2_RAID_VOL_TYPE_RAID1E: 2385 level = RAID_LEVEL_1E; 2386 break; 2387 case MPI2_RAID_VOL_TYPE_RAID1: 2388 level = RAID_LEVEL_1; 2389 break; 2390 } 2391 2392 switch (ioc->hba_mpi_version_belonged) { 2393 case MPI2_VERSION: 2394 raid_set_level(mpt2sas_raid_template, 2395 &sdev->sdev_gendev, level); 2396 break; 2397 case MPI25_VERSION: 2398 case MPI26_VERSION: 2399 raid_set_level(mpt3sas_raid_template, 2400 &sdev->sdev_gendev, level); 2401 break; 2402 } 2403 } 2404 2405 2406 /** 2407 * _scsih_get_volume_capabilities - volume capabilities 2408 * @ioc: per adapter object 2409 * @raid_device: the raid_device object 2410 * 2411 * Return: 0 for success, else 1 2412 */ 2413 static int 2414 _scsih_get_volume_capabilities(struct MPT3SAS_ADAPTER *ioc, 2415 struct _raid_device *raid_device) 2416 { 2417 Mpi2RaidVolPage0_t *vol_pg0; 2418 Mpi2RaidPhysDiskPage0_t pd_pg0; 2419 Mpi2SasDevicePage0_t sas_device_pg0; 2420 Mpi2ConfigReply_t mpi_reply; 2421 u16 sz; 2422 u8 num_pds; 2423 2424 if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle, 2425 &num_pds)) || !num_pds) { 2426 dfailprintk(ioc, 2427 ioc_warn(ioc, "failure at %s:%d/%s()!\n", 2428 __FILE__, __LINE__, __func__)); 2429 return 1; 2430 } 2431 2432 raid_device->num_pds = num_pds; 2433 sz = struct_size(vol_pg0, PhysDisk, num_pds); 2434 vol_pg0 = kzalloc(sz, GFP_KERNEL); 2435 if (!vol_pg0) { 2436 dfailprintk(ioc, 2437 ioc_warn(ioc, "failure at %s:%d/%s()!\n", 2438 __FILE__, __LINE__, __func__)); 2439 return 1; 2440 } 2441 2442 if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0, 2443 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) { 2444 dfailprintk(ioc, 2445 ioc_warn(ioc, "failure at %s:%d/%s()!\n", 2446 __FILE__, __LINE__, __func__)); 2447 kfree(vol_pg0); 2448 return 1; 2449 } 2450 2451 raid_device->volume_type = vol_pg0->VolumeType; 2452 2453 /* figure out what the underlying devices are by 2454 * obtaining the device_info bits for the 1st device 2455 */ 2456 if (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply, 2457 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM, 2458 vol_pg0->PhysDisk[0].PhysDiskNum))) { 2459 if (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 2460 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, 2461 le16_to_cpu(pd_pg0.DevHandle)))) { 2462 raid_device->device_info = 2463 le32_to_cpu(sas_device_pg0.DeviceInfo); 2464 } 2465 } 2466 2467 kfree(vol_pg0); 2468 return 0; 2469 } 2470 2471 /** 2472 * _scsih_enable_tlr - setting TLR flags 2473 * @ioc: per adapter object 2474 * @sdev: scsi device struct 2475 * 2476 * Enabling Transaction Layer Retries for tape devices when 2477 * vpd page 0x90 is present 2478 * 2479 */ 2480 static void 2481 _scsih_enable_tlr(struct MPT3SAS_ADAPTER *ioc, struct scsi_device *sdev) 2482 { 2483 2484 /* only for TAPE */ 2485 if (sdev->type != TYPE_TAPE) 2486 return; 2487 2488 if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR)) 2489 return; 2490 2491 sas_enable_tlr(sdev); 2492 sdev_printk(KERN_INFO, sdev, "TLR %s\n", 2493 sas_is_tlr_enabled(sdev) ? "Enabled" : "Disabled"); 2494 return; 2495 2496 } 2497 2498 /** 2499 * scsih_device_configure - device configure routine. 2500 * @sdev: scsi device struct 2501 * @lim: queue limits 2502 * 2503 * Return: 0 if ok. Any other return is assumed to be an error and 2504 * the device is ignored. 2505 */ 2506 static int 2507 scsih_device_configure(struct scsi_device *sdev, struct queue_limits *lim) 2508 { 2509 struct Scsi_Host *shost = sdev->host; 2510 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 2511 struct MPT3SAS_DEVICE *sas_device_priv_data; 2512 struct MPT3SAS_TARGET *sas_target_priv_data; 2513 struct _sas_device *sas_device; 2514 struct _pcie_device *pcie_device; 2515 struct _raid_device *raid_device; 2516 unsigned long flags; 2517 int qdepth; 2518 u8 ssp_target = 0; 2519 char *ds = ""; 2520 char *r_level = ""; 2521 u16 handle, volume_handle = 0; 2522 u64 volume_wwid = 0; 2523 2524 qdepth = 1; 2525 sas_device_priv_data = sdev->hostdata; 2526 sas_device_priv_data->configured_lun = 1; 2527 sas_device_priv_data->flags &= ~MPT_DEVICE_FLAGS_INIT; 2528 sas_target_priv_data = sas_device_priv_data->sas_target; 2529 handle = sas_target_priv_data->handle; 2530 2531 /* raid volume handling */ 2532 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME) { 2533 2534 spin_lock_irqsave(&ioc->raid_device_lock, flags); 2535 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 2536 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 2537 if (!raid_device) { 2538 dfailprintk(ioc, 2539 ioc_warn(ioc, "failure at %s:%d/%s()!\n", 2540 __FILE__, __LINE__, __func__)); 2541 return 1; 2542 } 2543 2544 if (_scsih_get_volume_capabilities(ioc, raid_device)) { 2545 dfailprintk(ioc, 2546 ioc_warn(ioc, "failure at %s:%d/%s()!\n", 2547 __FILE__, __LINE__, __func__)); 2548 return 1; 2549 } 2550 2551 /* 2552 * WARPDRIVE: Initialize the required data for Direct IO 2553 */ 2554 mpt3sas_init_warpdrive_properties(ioc, raid_device); 2555 2556 /* RAID Queue Depth Support 2557 * IS volume = underlying qdepth of drive type, either 2558 * MPT3SAS_SAS_QUEUE_DEPTH or MPT3SAS_SATA_QUEUE_DEPTH 2559 * IM/IME/R10 = 128 (MPT3SAS_RAID_QUEUE_DEPTH) 2560 */ 2561 if (raid_device->device_info & 2562 MPI2_SAS_DEVICE_INFO_SSP_TARGET) { 2563 qdepth = MPT3SAS_SAS_QUEUE_DEPTH; 2564 ds = "SSP"; 2565 } else { 2566 qdepth = MPT3SAS_SATA_QUEUE_DEPTH; 2567 if (raid_device->device_info & 2568 MPI2_SAS_DEVICE_INFO_SATA_DEVICE) 2569 ds = "SATA"; 2570 else 2571 ds = "STP"; 2572 } 2573 2574 switch (raid_device->volume_type) { 2575 case MPI2_RAID_VOL_TYPE_RAID0: 2576 r_level = "RAID0"; 2577 break; 2578 case MPI2_RAID_VOL_TYPE_RAID1E: 2579 qdepth = MPT3SAS_RAID_QUEUE_DEPTH; 2580 if (ioc->manu_pg10.OEMIdentifier && 2581 (le32_to_cpu(ioc->manu_pg10.GenericFlags0) & 2582 MFG10_GF0_R10_DISPLAY) && 2583 !(raid_device->num_pds % 2)) 2584 r_level = "RAID10"; 2585 else 2586 r_level = "RAID1E"; 2587 break; 2588 case MPI2_RAID_VOL_TYPE_RAID1: 2589 qdepth = MPT3SAS_RAID_QUEUE_DEPTH; 2590 r_level = "RAID1"; 2591 break; 2592 case MPI2_RAID_VOL_TYPE_RAID10: 2593 qdepth = MPT3SAS_RAID_QUEUE_DEPTH; 2594 r_level = "RAID10"; 2595 break; 2596 case MPI2_RAID_VOL_TYPE_UNKNOWN: 2597 default: 2598 qdepth = MPT3SAS_RAID_QUEUE_DEPTH; 2599 r_level = "RAIDX"; 2600 break; 2601 } 2602 2603 if (!ioc->hide_ir_msg) 2604 sdev_printk(KERN_INFO, sdev, 2605 "%s: handle(0x%04x), wwid(0x%016llx)," 2606 " pd_count(%d), type(%s)\n", 2607 r_level, raid_device->handle, 2608 (unsigned long long)raid_device->wwid, 2609 raid_device->num_pds, ds); 2610 2611 if (shost->max_sectors > MPT3SAS_RAID_MAX_SECTORS) { 2612 lim->max_hw_sectors = MPT3SAS_RAID_MAX_SECTORS; 2613 sdev_printk(KERN_INFO, sdev, 2614 "Set queue's max_sector to: %u\n", 2615 MPT3SAS_RAID_MAX_SECTORS); 2616 } 2617 2618 mpt3sas_scsih_change_queue_depth(sdev, qdepth); 2619 2620 /* raid transport support */ 2621 if (!ioc->is_warpdrive) 2622 _scsih_set_level(ioc, sdev, raid_device->volume_type); 2623 return 0; 2624 } 2625 2626 /* non-raid handling */ 2627 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) { 2628 if (mpt3sas_config_get_volume_handle(ioc, handle, 2629 &volume_handle)) { 2630 dfailprintk(ioc, 2631 ioc_warn(ioc, "failure at %s:%d/%s()!\n", 2632 __FILE__, __LINE__, __func__)); 2633 return 1; 2634 } 2635 if (volume_handle && mpt3sas_config_get_volume_wwid(ioc, 2636 volume_handle, &volume_wwid)) { 2637 dfailprintk(ioc, 2638 ioc_warn(ioc, "failure at %s:%d/%s()!\n", 2639 __FILE__, __LINE__, __func__)); 2640 return 1; 2641 } 2642 } 2643 2644 /* PCIe handling */ 2645 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) { 2646 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 2647 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, 2648 sas_device_priv_data->sas_target->sas_address); 2649 if (!pcie_device) { 2650 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 2651 dfailprintk(ioc, 2652 ioc_warn(ioc, "failure at %s:%d/%s()!\n", 2653 __FILE__, __LINE__, __func__)); 2654 return 1; 2655 } 2656 2657 qdepth = ioc->max_nvme_qd; 2658 ds = "NVMe"; 2659 sdev_printk(KERN_INFO, sdev, 2660 "%s: handle(0x%04x), wwid(0x%016llx), port(%d)\n", 2661 ds, handle, (unsigned long long)pcie_device->wwid, 2662 pcie_device->port_num); 2663 if (pcie_device->enclosure_handle != 0) 2664 sdev_printk(KERN_INFO, sdev, 2665 "%s: enclosure logical id(0x%016llx), slot(%d)\n", 2666 ds, 2667 (unsigned long long)pcie_device->enclosure_logical_id, 2668 pcie_device->slot); 2669 if (pcie_device->connector_name[0] != '\0') 2670 sdev_printk(KERN_INFO, sdev, 2671 "%s: enclosure level(0x%04x)," 2672 "connector name( %s)\n", ds, 2673 pcie_device->enclosure_level, 2674 pcie_device->connector_name); 2675 2676 if (pcie_device->nvme_mdts) 2677 lim->max_hw_sectors = pcie_device->nvme_mdts / 512; 2678 2679 pcie_device_put(pcie_device); 2680 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 2681 mpt3sas_scsih_change_queue_depth(sdev, qdepth); 2682 lim->virt_boundary_mask = ioc->page_size - 1; 2683 return 0; 2684 } 2685 2686 spin_lock_irqsave(&ioc->sas_device_lock, flags); 2687 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 2688 sas_device_priv_data->sas_target->sas_address, 2689 sas_device_priv_data->sas_target->port); 2690 if (!sas_device) { 2691 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 2692 dfailprintk(ioc, 2693 ioc_warn(ioc, "failure at %s:%d/%s()!\n", 2694 __FILE__, __LINE__, __func__)); 2695 return 1; 2696 } 2697 2698 sas_device->volume_handle = volume_handle; 2699 sas_device->volume_wwid = volume_wwid; 2700 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) { 2701 qdepth = (sas_device->port_type > 1) ? 2702 ioc->max_wideport_qd : ioc->max_narrowport_qd; 2703 ssp_target = 1; 2704 if (sas_device->device_info & 2705 MPI2_SAS_DEVICE_INFO_SEP) { 2706 sdev_printk(KERN_WARNING, sdev, 2707 "set ignore_delay_remove for handle(0x%04x)\n", 2708 sas_device_priv_data->sas_target->handle); 2709 sas_device_priv_data->ignore_delay_remove = 1; 2710 ds = "SES"; 2711 } else 2712 ds = "SSP"; 2713 } else { 2714 qdepth = ioc->max_sata_qd; 2715 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET) 2716 ds = "STP"; 2717 else if (sas_device->device_info & 2718 MPI2_SAS_DEVICE_INFO_SATA_DEVICE) 2719 ds = "SATA"; 2720 } 2721 2722 sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), " \ 2723 "sas_addr(0x%016llx), phy(%d), device_name(0x%016llx)\n", 2724 ds, handle, (unsigned long long)sas_device->sas_address, 2725 sas_device->phy, (unsigned long long)sas_device->device_name); 2726 2727 _scsih_display_enclosure_chassis_info(NULL, sas_device, sdev, NULL); 2728 2729 sas_device_put(sas_device); 2730 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 2731 2732 if (!ssp_target) 2733 _scsih_display_sata_capabilities(ioc, handle, sdev); 2734 2735 2736 mpt3sas_scsih_change_queue_depth(sdev, qdepth); 2737 2738 if (ssp_target) { 2739 sas_read_port_mode_page(sdev); 2740 _scsih_enable_tlr(ioc, sdev); 2741 } 2742 2743 return 0; 2744 } 2745 2746 /** 2747 * scsih_bios_param - fetch head, sector, cylinder info for a disk 2748 * @sdev: scsi device struct 2749 * @bdev: pointer to block device context 2750 * @capacity: device size (in 512 byte sectors) 2751 * @params: three element array to place output: 2752 * params[0] number of heads (max 255) 2753 * params[1] number of sectors (max 63) 2754 * params[2] number of cylinders 2755 */ 2756 static int 2757 scsih_bios_param(struct scsi_device *sdev, struct block_device *bdev, 2758 sector_t capacity, int params[]) 2759 { 2760 int heads; 2761 int sectors; 2762 sector_t cylinders; 2763 ulong dummy; 2764 2765 heads = 64; 2766 sectors = 32; 2767 2768 dummy = heads * sectors; 2769 cylinders = capacity; 2770 sector_div(cylinders, dummy); 2771 2772 /* 2773 * Handle extended translation size for logical drives 2774 * > 1Gb 2775 */ 2776 if ((ulong)capacity >= 0x200000) { 2777 heads = 255; 2778 sectors = 63; 2779 dummy = heads * sectors; 2780 cylinders = capacity; 2781 sector_div(cylinders, dummy); 2782 } 2783 2784 /* return result */ 2785 params[0] = heads; 2786 params[1] = sectors; 2787 params[2] = cylinders; 2788 2789 return 0; 2790 } 2791 2792 /** 2793 * _scsih_response_code - translation of device response code 2794 * @ioc: per adapter object 2795 * @response_code: response code returned by the device 2796 */ 2797 static void 2798 _scsih_response_code(struct MPT3SAS_ADAPTER *ioc, u8 response_code) 2799 { 2800 char *desc; 2801 2802 switch (response_code) { 2803 case MPI2_SCSITASKMGMT_RSP_TM_COMPLETE: 2804 desc = "task management request completed"; 2805 break; 2806 case MPI2_SCSITASKMGMT_RSP_INVALID_FRAME: 2807 desc = "invalid frame"; 2808 break; 2809 case MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED: 2810 desc = "task management request not supported"; 2811 break; 2812 case MPI2_SCSITASKMGMT_RSP_TM_FAILED: 2813 desc = "task management request failed"; 2814 break; 2815 case MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED: 2816 desc = "task management request succeeded"; 2817 break; 2818 case MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN: 2819 desc = "invalid lun"; 2820 break; 2821 case 0xA: 2822 desc = "overlapped tag attempted"; 2823 break; 2824 case MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC: 2825 desc = "task queued, however not sent to target"; 2826 break; 2827 default: 2828 desc = "unknown"; 2829 break; 2830 } 2831 ioc_warn(ioc, "response_code(0x%01x): %s\n", response_code, desc); 2832 } 2833 2834 /** 2835 * _scsih_tm_done - tm completion routine 2836 * @ioc: per adapter object 2837 * @smid: system request message index 2838 * @msix_index: MSIX table index supplied by the OS 2839 * @reply: reply message frame(lower 32bit addr) 2840 * Context: none. 2841 * 2842 * The callback handler when using scsih_issue_tm. 2843 * 2844 * Return: 1 meaning mf should be freed from _base_interrupt 2845 * 0 means the mf is freed from this function. 2846 */ 2847 static u8 2848 _scsih_tm_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply) 2849 { 2850 MPI2DefaultReply_t *mpi_reply; 2851 2852 if (ioc->tm_cmds.status == MPT3_CMD_NOT_USED) 2853 return 1; 2854 if (ioc->tm_cmds.smid != smid) 2855 return 1; 2856 ioc->tm_cmds.status |= MPT3_CMD_COMPLETE; 2857 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 2858 if (mpi_reply) { 2859 memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4); 2860 ioc->tm_cmds.status |= MPT3_CMD_REPLY_VALID; 2861 } 2862 ioc->tm_cmds.status &= ~MPT3_CMD_PENDING; 2863 complete(&ioc->tm_cmds.done); 2864 return 1; 2865 } 2866 2867 /** 2868 * mpt3sas_scsih_set_tm_flag - set per target tm_busy 2869 * @ioc: per adapter object 2870 * @handle: device handle 2871 * 2872 * During taskmangement request, we need to freeze the device queue. 2873 */ 2874 void 2875 mpt3sas_scsih_set_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle) 2876 { 2877 struct MPT3SAS_DEVICE *sas_device_priv_data; 2878 struct scsi_device *sdev; 2879 u8 skip = 0; 2880 2881 shost_for_each_device(sdev, ioc->shost) { 2882 if (skip) 2883 continue; 2884 sas_device_priv_data = sdev->hostdata; 2885 if (!sas_device_priv_data) 2886 continue; 2887 if (sas_device_priv_data->sas_target->handle == handle) { 2888 sas_device_priv_data->sas_target->tm_busy = 1; 2889 skip = 1; 2890 ioc->ignore_loginfos = 1; 2891 } 2892 } 2893 } 2894 2895 /** 2896 * mpt3sas_scsih_clear_tm_flag - clear per target tm_busy 2897 * @ioc: per adapter object 2898 * @handle: device handle 2899 * 2900 * During taskmangement request, we need to freeze the device queue. 2901 */ 2902 void 2903 mpt3sas_scsih_clear_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle) 2904 { 2905 struct MPT3SAS_DEVICE *sas_device_priv_data; 2906 struct scsi_device *sdev; 2907 u8 skip = 0; 2908 2909 shost_for_each_device(sdev, ioc->shost) { 2910 if (skip) 2911 continue; 2912 sas_device_priv_data = sdev->hostdata; 2913 if (!sas_device_priv_data) 2914 continue; 2915 if (sas_device_priv_data->sas_target->handle == handle) { 2916 sas_device_priv_data->sas_target->tm_busy = 0; 2917 skip = 1; 2918 ioc->ignore_loginfos = 0; 2919 } 2920 } 2921 } 2922 2923 /** 2924 * scsih_tm_cmd_map_status - map the target reset & LUN reset TM status 2925 * @ioc: per adapter object 2926 * @channel: the channel assigned by the OS 2927 * @id: the id assigned by the OS 2928 * @lun: lun number 2929 * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in mpi2_init.h) 2930 * @smid_task: smid assigned to the task 2931 * 2932 * Look whether TM has aborted the timed out SCSI command, if 2933 * TM has aborted the IO then return SUCCESS else return FAILED. 2934 */ 2935 static int 2936 scsih_tm_cmd_map_status(struct MPT3SAS_ADAPTER *ioc, uint channel, 2937 uint id, uint lun, u8 type, u16 smid_task) 2938 { 2939 2940 if (smid_task <= ioc->shost->can_queue) { 2941 switch (type) { 2942 case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET: 2943 if (!(_scsih_scsi_lookup_find_by_target(ioc, 2944 id, channel))) 2945 return SUCCESS; 2946 break; 2947 case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET: 2948 case MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET: 2949 if (!(_scsih_scsi_lookup_find_by_lun(ioc, id, 2950 lun, channel))) 2951 return SUCCESS; 2952 break; 2953 default: 2954 return SUCCESS; 2955 } 2956 } else if (smid_task == ioc->scsih_cmds.smid) { 2957 if ((ioc->scsih_cmds.status & MPT3_CMD_COMPLETE) || 2958 (ioc->scsih_cmds.status & MPT3_CMD_NOT_USED)) 2959 return SUCCESS; 2960 } else if (smid_task == ioc->ctl_cmds.smid) { 2961 if ((ioc->ctl_cmds.status & MPT3_CMD_COMPLETE) || 2962 (ioc->ctl_cmds.status & MPT3_CMD_NOT_USED)) 2963 return SUCCESS; 2964 } 2965 2966 return FAILED; 2967 } 2968 2969 /** 2970 * scsih_tm_post_processing - post processing of target & LUN reset 2971 * @ioc: per adapter object 2972 * @handle: device handle 2973 * @channel: the channel assigned by the OS 2974 * @id: the id assigned by the OS 2975 * @lun: lun number 2976 * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in mpi2_init.h) 2977 * @smid_task: smid assigned to the task 2978 * 2979 * Post processing of target & LUN reset. Due to interrupt latency 2980 * issue it possible that interrupt for aborted IO might not be 2981 * received yet. So before returning failure status, poll the 2982 * reply descriptor pools for the reply of timed out SCSI command. 2983 * Return FAILED status if reply for timed out is not received 2984 * otherwise return SUCCESS. 2985 */ 2986 static int 2987 scsih_tm_post_processing(struct MPT3SAS_ADAPTER *ioc, u16 handle, 2988 uint channel, uint id, uint lun, u8 type, u16 smid_task) 2989 { 2990 int rc; 2991 2992 rc = scsih_tm_cmd_map_status(ioc, channel, id, lun, type, smid_task); 2993 if (rc == SUCCESS) 2994 return rc; 2995 2996 ioc_info(ioc, 2997 "Poll ReplyDescriptor queues for completion of" 2998 " smid(%d), task_type(0x%02x), handle(0x%04x)\n", 2999 smid_task, type, handle); 3000 3001 /* 3002 * Due to interrupt latency issues, driver may receive interrupt for 3003 * TM first and then for aborted SCSI IO command. So, poll all the 3004 * ReplyDescriptor pools before returning the FAILED status to SML. 3005 */ 3006 mpt3sas_base_mask_interrupts(ioc); 3007 mpt3sas_base_sync_reply_irqs(ioc, 1); 3008 mpt3sas_base_unmask_interrupts(ioc); 3009 3010 return scsih_tm_cmd_map_status(ioc, channel, id, lun, type, smid_task); 3011 } 3012 3013 /** 3014 * mpt3sas_scsih_issue_tm - main routine for sending tm requests 3015 * @ioc: per adapter struct 3016 * @handle: device handle 3017 * @channel: the channel assigned by the OS 3018 * @id: the id assigned by the OS 3019 * @lun: lun number 3020 * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in mpi2_init.h) 3021 * @smid_task: smid assigned to the task 3022 * @msix_task: MSIX table index supplied by the OS 3023 * @timeout: timeout in seconds 3024 * @tr_method: Target Reset Method 3025 * Context: user 3026 * 3027 * A generic API for sending task management requests to firmware. 3028 * 3029 * The callback index is set inside `ioc->tm_cb_idx`. 3030 * The caller is responsible to check for outstanding commands. 3031 * 3032 * Return: SUCCESS or FAILED. 3033 */ 3034 int 3035 mpt3sas_scsih_issue_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle, uint channel, 3036 uint id, u64 lun, u8 type, u16 smid_task, u16 msix_task, 3037 u8 timeout, u8 tr_method) 3038 { 3039 Mpi2SCSITaskManagementRequest_t *mpi_request; 3040 Mpi2SCSITaskManagementReply_t *mpi_reply; 3041 Mpi25SCSIIORequest_t *request; 3042 u16 smid = 0; 3043 u32 ioc_state; 3044 int rc; 3045 u8 issue_reset = 0; 3046 3047 lockdep_assert_held(&ioc->tm_cmds.mutex); 3048 3049 if (ioc->tm_cmds.status != MPT3_CMD_NOT_USED) { 3050 ioc_info(ioc, "%s: tm_cmd busy!!!\n", __func__); 3051 return FAILED; 3052 } 3053 3054 if (ioc->shost_recovery || ioc->remove_host || 3055 ioc->pci_error_recovery) { 3056 ioc_info(ioc, "%s: host reset in progress!\n", __func__); 3057 return FAILED; 3058 } 3059 3060 ioc_state = mpt3sas_base_get_iocstate(ioc, 0); 3061 if (ioc_state & MPI2_DOORBELL_USED) { 3062 dhsprintk(ioc, ioc_info(ioc, "unexpected doorbell active!\n")); 3063 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 3064 return (!rc) ? SUCCESS : FAILED; 3065 } 3066 3067 if ((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT) { 3068 mpt3sas_print_fault_code(ioc, ioc_state & 3069 MPI2_DOORBELL_DATA_MASK); 3070 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 3071 return (!rc) ? SUCCESS : FAILED; 3072 } else if ((ioc_state & MPI2_IOC_STATE_MASK) == 3073 MPI2_IOC_STATE_COREDUMP) { 3074 mpt3sas_print_coredump_info(ioc, ioc_state & 3075 MPI2_DOORBELL_DATA_MASK); 3076 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 3077 return (!rc) ? SUCCESS : FAILED; 3078 } 3079 3080 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx); 3081 if (!smid) { 3082 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__); 3083 return FAILED; 3084 } 3085 3086 dtmprintk(ioc, 3087 ioc_info(ioc, "sending tm: handle(0x%04x), task_type(0x%02x), smid(%d), timeout(%d), tr_method(0x%x)\n", 3088 handle, type, smid_task, timeout, tr_method)); 3089 ioc->tm_cmds.status = MPT3_CMD_PENDING; 3090 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 3091 ioc->tm_cmds.smid = smid; 3092 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t)); 3093 memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t)); 3094 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 3095 mpi_request->DevHandle = cpu_to_le16(handle); 3096 mpi_request->TaskType = type; 3097 if (type == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK || 3098 type == MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK) 3099 mpi_request->MsgFlags = tr_method; 3100 mpi_request->TaskMID = cpu_to_le16(smid_task); 3101 int_to_scsilun(lun, (struct scsi_lun *)mpi_request->LUN); 3102 mpt3sas_scsih_set_tm_flag(ioc, handle); 3103 init_completion(&ioc->tm_cmds.done); 3104 ioc->put_smid_hi_priority(ioc, smid, msix_task); 3105 wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ); 3106 if (!(ioc->tm_cmds.status & MPT3_CMD_COMPLETE)) { 3107 mpt3sas_check_cmd_timeout(ioc, 3108 ioc->tm_cmds.status, mpi_request, 3109 sizeof(Mpi2SCSITaskManagementRequest_t)/4, issue_reset); 3110 if (issue_reset) { 3111 rc = mpt3sas_base_hard_reset_handler(ioc, 3112 FORCE_BIG_HAMMER); 3113 rc = (!rc) ? SUCCESS : FAILED; 3114 goto out; 3115 } 3116 } 3117 3118 /* sync IRQs in case those were busy during flush. */ 3119 mpt3sas_base_sync_reply_irqs(ioc, 0); 3120 3121 if (ioc->tm_cmds.status & MPT3_CMD_REPLY_VALID) { 3122 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT); 3123 mpi_reply = ioc->tm_cmds.reply; 3124 dtmprintk(ioc, 3125 ioc_info(ioc, "complete tm: ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n", 3126 le16_to_cpu(mpi_reply->IOCStatus), 3127 le32_to_cpu(mpi_reply->IOCLogInfo), 3128 le32_to_cpu(mpi_reply->TerminationCount))); 3129 if (ioc->logging_level & MPT_DEBUG_TM) { 3130 _scsih_response_code(ioc, mpi_reply->ResponseCode); 3131 if (mpi_reply->IOCStatus) 3132 _debug_dump_mf(mpi_request, 3133 sizeof(Mpi2SCSITaskManagementRequest_t)/4); 3134 } 3135 } 3136 3137 switch (type) { 3138 case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK: 3139 rc = SUCCESS; 3140 /* 3141 * If DevHandle filed in smid_task's entry of request pool 3142 * doesn't match with device handle on which this task abort 3143 * TM is received then it means that TM has successfully 3144 * aborted the timed out command. Since smid_task's entry in 3145 * request pool will be memset to zero once the timed out 3146 * command is returned to the SML. If the command is not 3147 * aborted then smid_task’s entry won’t be cleared and it 3148 * will have same DevHandle value on which this task abort TM 3149 * is received and driver will return the TM status as FAILED. 3150 */ 3151 request = mpt3sas_base_get_msg_frame(ioc, smid_task); 3152 if (le16_to_cpu(request->DevHandle) != handle) 3153 break; 3154 3155 ioc_info(ioc, "Task abort tm failed: handle(0x%04x)," 3156 "timeout(%d) tr_method(0x%x) smid(%d) msix_index(%d)\n", 3157 handle, timeout, tr_method, smid_task, msix_task); 3158 rc = FAILED; 3159 break; 3160 3161 case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET: 3162 case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET: 3163 case MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET: 3164 rc = scsih_tm_post_processing(ioc, handle, channel, id, lun, 3165 type, smid_task); 3166 break; 3167 case MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK: 3168 rc = SUCCESS; 3169 break; 3170 default: 3171 rc = FAILED; 3172 break; 3173 } 3174 3175 out: 3176 mpt3sas_scsih_clear_tm_flag(ioc, handle); 3177 ioc->tm_cmds.status = MPT3_CMD_NOT_USED; 3178 return rc; 3179 } 3180 3181 int mpt3sas_scsih_issue_locked_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle, 3182 uint channel, uint id, u64 lun, u8 type, u16 smid_task, 3183 u16 msix_task, u8 timeout, u8 tr_method) 3184 { 3185 int ret; 3186 3187 mutex_lock(&ioc->tm_cmds.mutex); 3188 ret = mpt3sas_scsih_issue_tm(ioc, handle, channel, id, lun, type, 3189 smid_task, msix_task, timeout, tr_method); 3190 mutex_unlock(&ioc->tm_cmds.mutex); 3191 3192 return ret; 3193 } 3194 3195 /** 3196 * _scsih_tm_display_info - displays info about the device 3197 * @ioc: per adapter struct 3198 * @scmd: pointer to scsi command object 3199 * 3200 * Called by task management callback handlers. 3201 */ 3202 static void 3203 _scsih_tm_display_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd) 3204 { 3205 struct scsi_target *starget = scmd->device->sdev_target; 3206 struct MPT3SAS_TARGET *priv_target = starget->hostdata; 3207 struct _sas_device *sas_device = NULL; 3208 struct _pcie_device *pcie_device = NULL; 3209 unsigned long flags; 3210 char *device_str = NULL; 3211 3212 if (!priv_target) 3213 return; 3214 if (ioc->hide_ir_msg) 3215 device_str = "WarpDrive"; 3216 else 3217 device_str = "volume"; 3218 3219 scsi_print_command(scmd); 3220 if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) { 3221 starget_printk(KERN_INFO, starget, 3222 "%s handle(0x%04x), %s wwid(0x%016llx)\n", 3223 device_str, priv_target->handle, 3224 device_str, (unsigned long long)priv_target->sas_address); 3225 3226 } else if (priv_target->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) { 3227 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 3228 pcie_device = __mpt3sas_get_pdev_from_target(ioc, priv_target); 3229 if (pcie_device) { 3230 starget_printk(KERN_INFO, starget, 3231 "handle(0x%04x), wwid(0x%016llx), port(%d)\n", 3232 pcie_device->handle, 3233 (unsigned long long)pcie_device->wwid, 3234 pcie_device->port_num); 3235 if (pcie_device->enclosure_handle != 0) 3236 starget_printk(KERN_INFO, starget, 3237 "enclosure logical id(0x%016llx), slot(%d)\n", 3238 (unsigned long long) 3239 pcie_device->enclosure_logical_id, 3240 pcie_device->slot); 3241 if (pcie_device->connector_name[0] != '\0') 3242 starget_printk(KERN_INFO, starget, 3243 "enclosure level(0x%04x), connector name( %s)\n", 3244 pcie_device->enclosure_level, 3245 pcie_device->connector_name); 3246 pcie_device_put(pcie_device); 3247 } 3248 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 3249 3250 } else { 3251 spin_lock_irqsave(&ioc->sas_device_lock, flags); 3252 sas_device = __mpt3sas_get_sdev_from_target(ioc, priv_target); 3253 if (sas_device) { 3254 if (priv_target->flags & 3255 MPT_TARGET_FLAGS_RAID_COMPONENT) { 3256 starget_printk(KERN_INFO, starget, 3257 "volume handle(0x%04x), " 3258 "volume wwid(0x%016llx)\n", 3259 sas_device->volume_handle, 3260 (unsigned long long)sas_device->volume_wwid); 3261 } 3262 starget_printk(KERN_INFO, starget, 3263 "handle(0x%04x), sas_address(0x%016llx), phy(%d)\n", 3264 sas_device->handle, 3265 (unsigned long long)sas_device->sas_address, 3266 sas_device->phy); 3267 3268 _scsih_display_enclosure_chassis_info(NULL, sas_device, 3269 NULL, starget); 3270 3271 sas_device_put(sas_device); 3272 } 3273 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 3274 } 3275 } 3276 3277 /** 3278 * scsih_abort - eh threads main abort routine 3279 * @scmd: pointer to scsi command object 3280 * 3281 * Return: SUCCESS if command aborted else FAILED 3282 */ 3283 static int 3284 scsih_abort(struct scsi_cmnd *scmd) 3285 { 3286 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host); 3287 struct MPT3SAS_DEVICE *sas_device_priv_data; 3288 struct scsiio_tracker *st = scsi_cmd_priv(scmd); 3289 u16 handle; 3290 int r; 3291 3292 u8 timeout = 30; 3293 struct _pcie_device *pcie_device = NULL; 3294 sdev_printk(KERN_INFO, scmd->device, "attempting task abort!" 3295 "scmd(0x%p), outstanding for %u ms & timeout %u ms\n", 3296 scmd, jiffies_to_msecs(jiffies - scmd->jiffies_at_alloc), 3297 (scsi_cmd_to_rq(scmd)->timeout / HZ) * 1000); 3298 _scsih_tm_display_info(ioc, scmd); 3299 3300 sas_device_priv_data = scmd->device->hostdata; 3301 if (!sas_device_priv_data || !sas_device_priv_data->sas_target || 3302 ioc->remove_host) { 3303 sdev_printk(KERN_INFO, scmd->device, 3304 "device been deleted! scmd(0x%p)\n", scmd); 3305 scmd->result = DID_NO_CONNECT << 16; 3306 scsi_done(scmd); 3307 r = SUCCESS; 3308 goto out; 3309 } 3310 3311 /* check for completed command */ 3312 if (st == NULL || st->cb_idx == 0xFF) { 3313 sdev_printk(KERN_INFO, scmd->device, "No reference found at " 3314 "driver, assuming scmd(0x%p) might have completed\n", scmd); 3315 scmd->result = DID_RESET << 16; 3316 r = SUCCESS; 3317 goto out; 3318 } 3319 3320 /* for hidden raid components and volumes this is not supported */ 3321 if (sas_device_priv_data->sas_target->flags & 3322 MPT_TARGET_FLAGS_RAID_COMPONENT || 3323 sas_device_priv_data->sas_target->flags & MPT_TARGET_FLAGS_VOLUME) { 3324 scmd->result = DID_RESET << 16; 3325 r = FAILED; 3326 goto out; 3327 } 3328 3329 mpt3sas_halt_firmware(ioc); 3330 3331 handle = sas_device_priv_data->sas_target->handle; 3332 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle); 3333 if (pcie_device && (!ioc->tm_custom_handling) && 3334 (!(mpt3sas_scsih_is_pcie_scsi_device(pcie_device->device_info)))) 3335 timeout = ioc->nvme_abort_timeout; 3336 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->channel, 3337 scmd->device->id, scmd->device->lun, 3338 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, 3339 st->smid, st->msix_io, timeout, 0); 3340 /* Command must be cleared after abort */ 3341 if (r == SUCCESS && st->cb_idx != 0xFF) 3342 r = FAILED; 3343 out: 3344 sdev_printk(KERN_INFO, scmd->device, "task abort: %s scmd(0x%p)\n", 3345 ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd); 3346 if (pcie_device) 3347 pcie_device_put(pcie_device); 3348 return r; 3349 } 3350 3351 /** 3352 * scsih_dev_reset - eh threads main device reset routine 3353 * @scmd: pointer to scsi command object 3354 * 3355 * Return: SUCCESS if command aborted else FAILED 3356 */ 3357 static int 3358 scsih_dev_reset(struct scsi_cmnd *scmd) 3359 { 3360 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host); 3361 struct MPT3SAS_DEVICE *sas_device_priv_data; 3362 struct _sas_device *sas_device = NULL; 3363 struct _pcie_device *pcie_device = NULL; 3364 u16 handle; 3365 u8 tr_method = 0; 3366 u8 tr_timeout = 30; 3367 int r; 3368 3369 struct scsi_target *starget = scmd->device->sdev_target; 3370 struct MPT3SAS_TARGET *target_priv_data = starget->hostdata; 3371 3372 sdev_printk(KERN_INFO, scmd->device, 3373 "attempting device reset! scmd(0x%p)\n", scmd); 3374 _scsih_tm_display_info(ioc, scmd); 3375 3376 sas_device_priv_data = scmd->device->hostdata; 3377 if (!sas_device_priv_data || !sas_device_priv_data->sas_target || 3378 ioc->remove_host) { 3379 sdev_printk(KERN_INFO, scmd->device, 3380 "device been deleted! scmd(0x%p)\n", scmd); 3381 scmd->result = DID_NO_CONNECT << 16; 3382 scsi_done(scmd); 3383 r = SUCCESS; 3384 goto out; 3385 } 3386 3387 /* for hidden raid components obtain the volume_handle */ 3388 handle = 0; 3389 if (sas_device_priv_data->sas_target->flags & 3390 MPT_TARGET_FLAGS_RAID_COMPONENT) { 3391 sas_device = mpt3sas_get_sdev_from_target(ioc, 3392 target_priv_data); 3393 if (sas_device) 3394 handle = sas_device->volume_handle; 3395 } else 3396 handle = sas_device_priv_data->sas_target->handle; 3397 3398 if (!handle) { 3399 scmd->result = DID_RESET << 16; 3400 r = FAILED; 3401 goto out; 3402 } 3403 3404 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle); 3405 3406 if (pcie_device && (!ioc->tm_custom_handling) && 3407 (!(mpt3sas_scsih_is_pcie_scsi_device(pcie_device->device_info)))) { 3408 tr_timeout = pcie_device->reset_timeout; 3409 tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE; 3410 } else 3411 tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET; 3412 3413 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->channel, 3414 scmd->device->id, scmd->device->lun, 3415 MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET, 0, 0, 3416 tr_timeout, tr_method); 3417 /* Check for busy commands after reset */ 3418 if (r == SUCCESS && scsi_device_busy(scmd->device)) 3419 r = FAILED; 3420 out: 3421 sdev_printk(KERN_INFO, scmd->device, "device reset: %s scmd(0x%p)\n", 3422 ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd); 3423 3424 if (sas_device) 3425 sas_device_put(sas_device); 3426 if (pcie_device) 3427 pcie_device_put(pcie_device); 3428 3429 return r; 3430 } 3431 3432 /** 3433 * scsih_target_reset - eh threads main target reset routine 3434 * @scmd: pointer to scsi command object 3435 * 3436 * Return: SUCCESS if command aborted else FAILED 3437 */ 3438 static int 3439 scsih_target_reset(struct scsi_cmnd *scmd) 3440 { 3441 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host); 3442 struct MPT3SAS_DEVICE *sas_device_priv_data; 3443 struct _sas_device *sas_device = NULL; 3444 struct _pcie_device *pcie_device = NULL; 3445 u16 handle; 3446 u8 tr_method = 0; 3447 u8 tr_timeout = 30; 3448 int r; 3449 struct scsi_target *starget = scmd->device->sdev_target; 3450 struct MPT3SAS_TARGET *target_priv_data = starget->hostdata; 3451 3452 starget_printk(KERN_INFO, starget, 3453 "attempting target reset! scmd(0x%p)\n", scmd); 3454 _scsih_tm_display_info(ioc, scmd); 3455 3456 sas_device_priv_data = scmd->device->hostdata; 3457 if (!sas_device_priv_data || !sas_device_priv_data->sas_target || 3458 ioc->remove_host) { 3459 starget_printk(KERN_INFO, starget, 3460 "target been deleted! scmd(0x%p)\n", scmd); 3461 scmd->result = DID_NO_CONNECT << 16; 3462 scsi_done(scmd); 3463 r = SUCCESS; 3464 goto out; 3465 } 3466 3467 /* for hidden raid components obtain the volume_handle */ 3468 handle = 0; 3469 if (sas_device_priv_data->sas_target->flags & 3470 MPT_TARGET_FLAGS_RAID_COMPONENT) { 3471 sas_device = mpt3sas_get_sdev_from_target(ioc, 3472 target_priv_data); 3473 if (sas_device) 3474 handle = sas_device->volume_handle; 3475 } else 3476 handle = sas_device_priv_data->sas_target->handle; 3477 3478 if (!handle) { 3479 scmd->result = DID_RESET << 16; 3480 r = FAILED; 3481 goto out; 3482 } 3483 3484 pcie_device = mpt3sas_get_pdev_by_handle(ioc, handle); 3485 3486 if (pcie_device && (!ioc->tm_custom_handling) && 3487 (!(mpt3sas_scsih_is_pcie_scsi_device(pcie_device->device_info)))) { 3488 tr_timeout = pcie_device->reset_timeout; 3489 tr_method = MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE; 3490 } else 3491 tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET; 3492 r = mpt3sas_scsih_issue_locked_tm(ioc, handle, scmd->device->channel, 3493 scmd->device->id, 0, 3494 MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 0, 3495 tr_timeout, tr_method); 3496 /* Check for busy commands after reset */ 3497 if (r == SUCCESS && atomic_read(&starget->target_busy)) 3498 r = FAILED; 3499 out: 3500 starget_printk(KERN_INFO, starget, "target reset: %s scmd(0x%p)\n", 3501 ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd); 3502 3503 if (sas_device) 3504 sas_device_put(sas_device); 3505 if (pcie_device) 3506 pcie_device_put(pcie_device); 3507 return r; 3508 } 3509 3510 3511 /** 3512 * scsih_host_reset - eh threads main host reset routine 3513 * @scmd: pointer to scsi command object 3514 * 3515 * Return: SUCCESS if command aborted else FAILED 3516 */ 3517 static int 3518 scsih_host_reset(struct scsi_cmnd *scmd) 3519 { 3520 struct MPT3SAS_ADAPTER *ioc = shost_priv(scmd->device->host); 3521 int r, retval; 3522 3523 ioc_info(ioc, "attempting host reset! scmd(0x%p)\n", scmd); 3524 scsi_print_command(scmd); 3525 3526 if (ioc->is_driver_loading || ioc->remove_host) { 3527 ioc_info(ioc, "Blocking the host reset\n"); 3528 r = FAILED; 3529 goto out; 3530 } 3531 3532 retval = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 3533 r = (retval < 0) ? FAILED : SUCCESS; 3534 out: 3535 ioc_info(ioc, "host reset: %s scmd(0x%p)\n", 3536 r == SUCCESS ? "SUCCESS" : "FAILED", scmd); 3537 3538 return r; 3539 } 3540 3541 /** 3542 * _scsih_fw_event_add - insert and queue up fw_event 3543 * @ioc: per adapter object 3544 * @fw_event: object describing the event 3545 * Context: This function will acquire ioc->fw_event_lock. 3546 * 3547 * This adds the firmware event object into link list, then queues it up to 3548 * be processed from user context. 3549 */ 3550 static void 3551 _scsih_fw_event_add(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event) 3552 { 3553 unsigned long flags; 3554 3555 if (ioc->firmware_event_thread == NULL) 3556 return; 3557 3558 spin_lock_irqsave(&ioc->fw_event_lock, flags); 3559 fw_event_work_get(fw_event); 3560 INIT_LIST_HEAD(&fw_event->list); 3561 list_add_tail(&fw_event->list, &ioc->fw_event_list); 3562 INIT_WORK(&fw_event->work, _firmware_event_work); 3563 fw_event_work_get(fw_event); 3564 queue_work(ioc->firmware_event_thread, &fw_event->work); 3565 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 3566 } 3567 3568 /** 3569 * _scsih_fw_event_del_from_list - delete fw_event from the list 3570 * @ioc: per adapter object 3571 * @fw_event: object describing the event 3572 * Context: This function will acquire ioc->fw_event_lock. 3573 * 3574 * If the fw_event is on the fw_event_list, remove it and do a put. 3575 */ 3576 static void 3577 _scsih_fw_event_del_from_list(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work 3578 *fw_event) 3579 { 3580 unsigned long flags; 3581 3582 spin_lock_irqsave(&ioc->fw_event_lock, flags); 3583 if (!list_empty(&fw_event->list)) { 3584 list_del_init(&fw_event->list); 3585 fw_event_work_put(fw_event); 3586 } 3587 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 3588 } 3589 3590 3591 /** 3592 * mpt3sas_send_trigger_data_event - send event for processing trigger data 3593 * @ioc: per adapter object 3594 * @event_data: trigger event data 3595 */ 3596 void 3597 mpt3sas_send_trigger_data_event(struct MPT3SAS_ADAPTER *ioc, 3598 struct SL_WH_TRIGGERS_EVENT_DATA_T *event_data) 3599 { 3600 struct fw_event_work *fw_event; 3601 u16 sz; 3602 3603 if (ioc->is_driver_loading) 3604 return; 3605 sz = sizeof(*event_data); 3606 fw_event = alloc_fw_event_work(sz); 3607 if (!fw_event) 3608 return; 3609 fw_event->event = MPT3SAS_PROCESS_TRIGGER_DIAG; 3610 fw_event->ioc = ioc; 3611 memcpy(fw_event->event_data, event_data, sizeof(*event_data)); 3612 _scsih_fw_event_add(ioc, fw_event); 3613 fw_event_work_put(fw_event); 3614 } 3615 3616 /** 3617 * _scsih_error_recovery_delete_devices - remove devices not responding 3618 * @ioc: per adapter object 3619 */ 3620 static void 3621 _scsih_error_recovery_delete_devices(struct MPT3SAS_ADAPTER *ioc) 3622 { 3623 struct fw_event_work *fw_event; 3624 3625 fw_event = alloc_fw_event_work(0); 3626 if (!fw_event) 3627 return; 3628 fw_event->event = MPT3SAS_REMOVE_UNRESPONDING_DEVICES; 3629 fw_event->ioc = ioc; 3630 _scsih_fw_event_add(ioc, fw_event); 3631 fw_event_work_put(fw_event); 3632 } 3633 3634 /** 3635 * mpt3sas_port_enable_complete - port enable completed (fake event) 3636 * @ioc: per adapter object 3637 */ 3638 void 3639 mpt3sas_port_enable_complete(struct MPT3SAS_ADAPTER *ioc) 3640 { 3641 struct fw_event_work *fw_event; 3642 3643 fw_event = alloc_fw_event_work(0); 3644 if (!fw_event) 3645 return; 3646 fw_event->event = MPT3SAS_PORT_ENABLE_COMPLETE; 3647 fw_event->ioc = ioc; 3648 _scsih_fw_event_add(ioc, fw_event); 3649 fw_event_work_put(fw_event); 3650 } 3651 3652 static struct fw_event_work *dequeue_next_fw_event(struct MPT3SAS_ADAPTER *ioc) 3653 { 3654 unsigned long flags; 3655 struct fw_event_work *fw_event = NULL; 3656 3657 spin_lock_irqsave(&ioc->fw_event_lock, flags); 3658 if (!list_empty(&ioc->fw_event_list)) { 3659 fw_event = list_first_entry(&ioc->fw_event_list, 3660 struct fw_event_work, list); 3661 list_del_init(&fw_event->list); 3662 fw_event_work_put(fw_event); 3663 } 3664 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 3665 3666 return fw_event; 3667 } 3668 3669 /** 3670 * _scsih_fw_event_cleanup_queue - cleanup event queue 3671 * @ioc: per adapter object 3672 * 3673 * Walk the firmware event queue, either killing timers, or waiting 3674 * for outstanding events to complete 3675 * 3676 * Context: task, can sleep 3677 */ 3678 static void 3679 _scsih_fw_event_cleanup_queue(struct MPT3SAS_ADAPTER *ioc) 3680 { 3681 struct fw_event_work *fw_event; 3682 3683 if ((list_empty(&ioc->fw_event_list) && !ioc->current_event) || 3684 !ioc->firmware_event_thread) 3685 return; 3686 /* 3687 * Set current running event as ignore, so that 3688 * current running event will exit quickly. 3689 * As diag reset has occurred it is of no use 3690 * to process remaining stale event data entries. 3691 */ 3692 if (ioc->shost_recovery && ioc->current_event) 3693 ioc->current_event->ignore = 1; 3694 3695 ioc->fw_events_cleanup = 1; 3696 while ((fw_event = dequeue_next_fw_event(ioc)) || 3697 (fw_event = ioc->current_event)) { 3698 3699 /* 3700 * Don't call cancel_work_sync() for current_event 3701 * other than MPT3SAS_REMOVE_UNRESPONDING_DEVICES; 3702 * otherwise we may observe deadlock if current 3703 * hard reset issued as part of processing the current_event. 3704 * 3705 * Orginal logic of cleaning the current_event is added 3706 * for handling the back to back host reset issued by the user. 3707 * i.e. during back to back host reset, driver use to process 3708 * the two instances of MPT3SAS_REMOVE_UNRESPONDING_DEVICES 3709 * event back to back and this made the drives to unregister 3710 * the devices from SML. 3711 */ 3712 3713 if (fw_event == ioc->current_event && 3714 ioc->current_event->event != 3715 MPT3SAS_REMOVE_UNRESPONDING_DEVICES) { 3716 ioc->current_event = NULL; 3717 continue; 3718 } 3719 3720 /* 3721 * Driver has to clear ioc->start_scan flag when 3722 * it is cleaning up MPT3SAS_PORT_ENABLE_COMPLETE, 3723 * otherwise scsi_scan_host() API waits for the 3724 * 5 minute timer to expire. If we exit from 3725 * scsi_scan_host() early then we can issue the 3726 * new port enable request as part of current diag reset. 3727 */ 3728 if (fw_event->event == MPT3SAS_PORT_ENABLE_COMPLETE) { 3729 ioc->port_enable_cmds.status |= MPT3_CMD_RESET; 3730 ioc->start_scan = 0; 3731 } 3732 3733 /* 3734 * Wait on the fw_event to complete. If this returns 1, then 3735 * the event was never executed, and we need a put for the 3736 * reference the work had on the fw_event. 3737 * 3738 * If it did execute, we wait for it to finish, and the put will 3739 * happen from _firmware_event_work() 3740 */ 3741 if (cancel_work_sync(&fw_event->work)) 3742 fw_event_work_put(fw_event); 3743 3744 } 3745 ioc->fw_events_cleanup = 0; 3746 } 3747 3748 /** 3749 * _scsih_internal_device_block - block the sdev device 3750 * @sdev: per device object 3751 * @sas_device_priv_data : per device driver private data 3752 * 3753 * make sure device is blocked without error, if not 3754 * print an error 3755 */ 3756 static void 3757 _scsih_internal_device_block(struct scsi_device *sdev, 3758 struct MPT3SAS_DEVICE *sas_device_priv_data) 3759 { 3760 int r = 0; 3761 3762 sdev_printk(KERN_INFO, sdev, "device_block, handle(0x%04x)\n", 3763 sas_device_priv_data->sas_target->handle); 3764 sas_device_priv_data->block = 1; 3765 3766 r = scsi_internal_device_block_nowait(sdev); 3767 if (r == -EINVAL) 3768 sdev_printk(KERN_WARNING, sdev, 3769 "device_block failed with return(%d) for handle(0x%04x)\n", 3770 r, sas_device_priv_data->sas_target->handle); 3771 } 3772 3773 /** 3774 * _scsih_internal_device_unblock - unblock the sdev device 3775 * @sdev: per device object 3776 * @sas_device_priv_data : per device driver private data 3777 * make sure device is unblocked without error, if not retry 3778 * by blocking and then unblocking 3779 */ 3780 3781 static void 3782 _scsih_internal_device_unblock(struct scsi_device *sdev, 3783 struct MPT3SAS_DEVICE *sas_device_priv_data) 3784 { 3785 int r = 0; 3786 3787 sdev_printk(KERN_WARNING, sdev, "device_unblock and setting to running, " 3788 "handle(0x%04x)\n", sas_device_priv_data->sas_target->handle); 3789 sas_device_priv_data->block = 0; 3790 r = scsi_internal_device_unblock_nowait(sdev, SDEV_RUNNING); 3791 if (r == -EINVAL) { 3792 /* The device has been set to SDEV_RUNNING by SD layer during 3793 * device addition but the request queue is still stopped by 3794 * our earlier block call. We need to perform a block again 3795 * to get the device to SDEV_BLOCK and then to SDEV_RUNNING */ 3796 3797 sdev_printk(KERN_WARNING, sdev, 3798 "device_unblock failed with return(%d) for handle(0x%04x) " 3799 "performing a block followed by an unblock\n", 3800 r, sas_device_priv_data->sas_target->handle); 3801 sas_device_priv_data->block = 1; 3802 r = scsi_internal_device_block_nowait(sdev); 3803 if (r) 3804 sdev_printk(KERN_WARNING, sdev, "retried device_block " 3805 "failed with return(%d) for handle(0x%04x)\n", 3806 r, sas_device_priv_data->sas_target->handle); 3807 3808 sas_device_priv_data->block = 0; 3809 r = scsi_internal_device_unblock_nowait(sdev, SDEV_RUNNING); 3810 if (r) 3811 sdev_printk(KERN_WARNING, sdev, "retried device_unblock" 3812 " failed with return(%d) for handle(0x%04x)\n", 3813 r, sas_device_priv_data->sas_target->handle); 3814 } 3815 } 3816 3817 /** 3818 * _scsih_ublock_io_all_device - unblock every device 3819 * @ioc: per adapter object 3820 * 3821 * change the device state from block to running 3822 */ 3823 static void 3824 _scsih_ublock_io_all_device(struct MPT3SAS_ADAPTER *ioc) 3825 { 3826 struct MPT3SAS_DEVICE *sas_device_priv_data; 3827 struct scsi_device *sdev; 3828 3829 shost_for_each_device(sdev, ioc->shost) { 3830 sas_device_priv_data = sdev->hostdata; 3831 if (!sas_device_priv_data) 3832 continue; 3833 if (!sas_device_priv_data->block) 3834 continue; 3835 3836 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev, 3837 "device_running, handle(0x%04x)\n", 3838 sas_device_priv_data->sas_target->handle)); 3839 _scsih_internal_device_unblock(sdev, sas_device_priv_data); 3840 } 3841 } 3842 3843 3844 /** 3845 * _scsih_ublock_io_device - prepare device to be deleted 3846 * @ioc: per adapter object 3847 * @sas_address: sas address 3848 * @port: hba port entry 3849 * 3850 * unblock then put device in offline state 3851 */ 3852 static void 3853 _scsih_ublock_io_device(struct MPT3SAS_ADAPTER *ioc, 3854 u64 sas_address, struct hba_port *port) 3855 { 3856 struct MPT3SAS_DEVICE *sas_device_priv_data; 3857 struct scsi_device *sdev; 3858 3859 shost_for_each_device(sdev, ioc->shost) { 3860 sas_device_priv_data = sdev->hostdata; 3861 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) 3862 continue; 3863 if (sas_device_priv_data->sas_target->sas_address 3864 != sas_address) 3865 continue; 3866 if (sas_device_priv_data->sas_target->port != port) 3867 continue; 3868 if (sas_device_priv_data->block) 3869 _scsih_internal_device_unblock(sdev, 3870 sas_device_priv_data); 3871 } 3872 } 3873 3874 /** 3875 * _scsih_block_io_all_device - set the device state to SDEV_BLOCK 3876 * @ioc: per adapter object 3877 * 3878 * During device pull we need to appropriately set the sdev state. 3879 */ 3880 static void 3881 _scsih_block_io_all_device(struct MPT3SAS_ADAPTER *ioc) 3882 { 3883 struct MPT3SAS_DEVICE *sas_device_priv_data; 3884 struct scsi_device *sdev; 3885 3886 shost_for_each_device(sdev, ioc->shost) { 3887 sas_device_priv_data = sdev->hostdata; 3888 if (!sas_device_priv_data) 3889 continue; 3890 if (sas_device_priv_data->block) 3891 continue; 3892 if (sas_device_priv_data->ignore_delay_remove) { 3893 sdev_printk(KERN_INFO, sdev, 3894 "%s skip device_block for SES handle(0x%04x)\n", 3895 __func__, sas_device_priv_data->sas_target->handle); 3896 continue; 3897 } 3898 _scsih_internal_device_block(sdev, sas_device_priv_data); 3899 } 3900 } 3901 3902 /** 3903 * _scsih_block_io_device - set the device state to SDEV_BLOCK 3904 * @ioc: per adapter object 3905 * @handle: device handle 3906 * 3907 * During device pull we need to appropriately set the sdev state. 3908 */ 3909 static void 3910 _scsih_block_io_device(struct MPT3SAS_ADAPTER *ioc, u16 handle) 3911 { 3912 struct MPT3SAS_DEVICE *sas_device_priv_data; 3913 struct scsi_device *sdev; 3914 struct _sas_device *sas_device; 3915 3916 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 3917 3918 shost_for_each_device(sdev, ioc->shost) { 3919 sas_device_priv_data = sdev->hostdata; 3920 if (!sas_device_priv_data) 3921 continue; 3922 if (sas_device_priv_data->sas_target->handle != handle) 3923 continue; 3924 if (sas_device_priv_data->block) 3925 continue; 3926 if (sas_device && sas_device->pend_sas_rphy_add) 3927 continue; 3928 if (sas_device_priv_data->ignore_delay_remove) { 3929 sdev_printk(KERN_INFO, sdev, 3930 "%s skip device_block for SES handle(0x%04x)\n", 3931 __func__, sas_device_priv_data->sas_target->handle); 3932 continue; 3933 } 3934 _scsih_internal_device_block(sdev, sas_device_priv_data); 3935 } 3936 3937 if (sas_device) 3938 sas_device_put(sas_device); 3939 } 3940 3941 /** 3942 * _scsih_block_io_to_children_attached_to_ex 3943 * @ioc: per adapter object 3944 * @sas_expander: the sas_device object 3945 * 3946 * This routine set sdev state to SDEV_BLOCK for all devices 3947 * attached to this expander. This function called when expander is 3948 * pulled. 3949 */ 3950 static void 3951 _scsih_block_io_to_children_attached_to_ex(struct MPT3SAS_ADAPTER *ioc, 3952 struct _sas_node *sas_expander) 3953 { 3954 struct _sas_port *mpt3sas_port; 3955 struct _sas_device *sas_device; 3956 struct _sas_node *expander_sibling; 3957 unsigned long flags; 3958 3959 if (!sas_expander) 3960 return; 3961 3962 list_for_each_entry(mpt3sas_port, 3963 &sas_expander->sas_port_list, port_list) { 3964 if (mpt3sas_port->remote_identify.device_type == 3965 SAS_END_DEVICE) { 3966 spin_lock_irqsave(&ioc->sas_device_lock, flags); 3967 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 3968 mpt3sas_port->remote_identify.sas_address, 3969 mpt3sas_port->hba_port); 3970 if (sas_device) { 3971 set_bit(sas_device->handle, 3972 ioc->blocking_handles); 3973 sas_device_put(sas_device); 3974 } 3975 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 3976 } 3977 } 3978 3979 list_for_each_entry(mpt3sas_port, 3980 &sas_expander->sas_port_list, port_list) { 3981 3982 if (mpt3sas_port->remote_identify.device_type == 3983 SAS_EDGE_EXPANDER_DEVICE || 3984 mpt3sas_port->remote_identify.device_type == 3985 SAS_FANOUT_EXPANDER_DEVICE) { 3986 expander_sibling = 3987 mpt3sas_scsih_expander_find_by_sas_address( 3988 ioc, mpt3sas_port->remote_identify.sas_address, 3989 mpt3sas_port->hba_port); 3990 _scsih_block_io_to_children_attached_to_ex(ioc, 3991 expander_sibling); 3992 } 3993 } 3994 } 3995 3996 /** 3997 * _scsih_block_io_to_children_attached_directly 3998 * @ioc: per adapter object 3999 * @event_data: topology change event data 4000 * 4001 * This routine set sdev state to SDEV_BLOCK for all devices 4002 * direct attached during device pull. 4003 */ 4004 static void 4005 _scsih_block_io_to_children_attached_directly(struct MPT3SAS_ADAPTER *ioc, 4006 Mpi2EventDataSasTopologyChangeList_t *event_data) 4007 { 4008 int i; 4009 u16 handle; 4010 u16 reason_code; 4011 4012 for (i = 0; i < event_data->NumEntries; i++) { 4013 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 4014 if (!handle) 4015 continue; 4016 reason_code = event_data->PHY[i].PhyStatus & 4017 MPI2_EVENT_SAS_TOPO_RC_MASK; 4018 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING) 4019 _scsih_block_io_device(ioc, handle); 4020 } 4021 } 4022 4023 /** 4024 * _scsih_block_io_to_pcie_children_attached_directly 4025 * @ioc: per adapter object 4026 * @event_data: topology change event data 4027 * 4028 * This routine set sdev state to SDEV_BLOCK for all devices 4029 * direct attached during device pull/reconnect. 4030 */ 4031 static void 4032 _scsih_block_io_to_pcie_children_attached_directly(struct MPT3SAS_ADAPTER *ioc, 4033 Mpi26EventDataPCIeTopologyChangeList_t *event_data) 4034 { 4035 int i; 4036 u16 handle; 4037 u16 reason_code; 4038 4039 for (i = 0; i < event_data->NumEntries; i++) { 4040 handle = 4041 le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle); 4042 if (!handle) 4043 continue; 4044 reason_code = event_data->PortEntry[i].PortStatus; 4045 if (reason_code == 4046 MPI26_EVENT_PCIE_TOPO_PS_DELAY_NOT_RESPONDING) 4047 _scsih_block_io_device(ioc, handle); 4048 } 4049 } 4050 /** 4051 * _scsih_tm_tr_send - send task management request 4052 * @ioc: per adapter object 4053 * @handle: device handle 4054 * Context: interrupt time. 4055 * 4056 * This code is to initiate the device removal handshake protocol 4057 * with controller firmware. This function will issue target reset 4058 * using high priority request queue. It will send a sas iounit 4059 * control request (MPI2_SAS_OP_REMOVE_DEVICE) from this completion. 4060 * 4061 * This is designed to send muliple task management request at the same 4062 * time to the fifo. If the fifo is full, we will append the request, 4063 * and process it in a future completion. 4064 */ 4065 static void 4066 _scsih_tm_tr_send(struct MPT3SAS_ADAPTER *ioc, u16 handle) 4067 { 4068 Mpi2SCSITaskManagementRequest_t *mpi_request; 4069 u16 smid; 4070 struct _sas_device *sas_device = NULL; 4071 struct _pcie_device *pcie_device = NULL; 4072 struct MPT3SAS_TARGET *sas_target_priv_data = NULL; 4073 u64 sas_address = 0; 4074 unsigned long flags; 4075 struct _tr_list *delayed_tr; 4076 u32 ioc_state; 4077 u8 tr_method = 0; 4078 struct hba_port *port = NULL; 4079 4080 if (ioc->pci_error_recovery) { 4081 dewtprintk(ioc, 4082 ioc_info(ioc, "%s: host in pci error recovery: handle(0x%04x)\n", 4083 __func__, handle)); 4084 return; 4085 } 4086 ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 4087 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 4088 dewtprintk(ioc, 4089 ioc_info(ioc, "%s: host is not operational: handle(0x%04x)\n", 4090 __func__, handle)); 4091 return; 4092 } 4093 4094 /* if PD, then return */ 4095 if (test_bit(handle, ioc->pd_handles)) 4096 return; 4097 4098 clear_bit(handle, ioc->pend_os_device_add); 4099 4100 spin_lock_irqsave(&ioc->sas_device_lock, flags); 4101 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 4102 if (sas_device && sas_device->starget && 4103 sas_device->starget->hostdata) { 4104 sas_target_priv_data = sas_device->starget->hostdata; 4105 sas_target_priv_data->deleted = 1; 4106 sas_address = sas_device->sas_address; 4107 port = sas_device->port; 4108 } 4109 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 4110 if (!sas_device) { 4111 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 4112 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle); 4113 if (pcie_device && pcie_device->starget && 4114 pcie_device->starget->hostdata) { 4115 sas_target_priv_data = pcie_device->starget->hostdata; 4116 sas_target_priv_data->deleted = 1; 4117 sas_address = pcie_device->wwid; 4118 } 4119 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 4120 if (pcie_device && (!ioc->tm_custom_handling) && 4121 (!(mpt3sas_scsih_is_pcie_scsi_device( 4122 pcie_device->device_info)))) 4123 tr_method = 4124 MPI26_SCSITASKMGMT_MSGFLAGS_PROTOCOL_LVL_RST_PCIE; 4125 else 4126 tr_method = MPI2_SCSITASKMGMT_MSGFLAGS_LINK_RESET; 4127 } 4128 if (sas_target_priv_data) { 4129 dewtprintk(ioc, 4130 ioc_info(ioc, "setting delete flag: handle(0x%04x), sas_addr(0x%016llx)\n", 4131 handle, (u64)sas_address)); 4132 if (sas_device) { 4133 if (sas_device->enclosure_handle != 0) 4134 dewtprintk(ioc, 4135 ioc_info(ioc, "setting delete flag:enclosure logical id(0x%016llx), slot(%d)\n", 4136 (u64)sas_device->enclosure_logical_id, 4137 sas_device->slot)); 4138 if (sas_device->connector_name[0] != '\0') 4139 dewtprintk(ioc, 4140 ioc_info(ioc, "setting delete flag: enclosure level(0x%04x), connector name( %s)\n", 4141 sas_device->enclosure_level, 4142 sas_device->connector_name)); 4143 } else if (pcie_device) { 4144 if (pcie_device->enclosure_handle != 0) 4145 dewtprintk(ioc, 4146 ioc_info(ioc, "setting delete flag: logical id(0x%016llx), slot(%d)\n", 4147 (u64)pcie_device->enclosure_logical_id, 4148 pcie_device->slot)); 4149 if (pcie_device->connector_name[0] != '\0') 4150 dewtprintk(ioc, 4151 ioc_info(ioc, "setting delete flag:, enclosure level(0x%04x), connector name( %s)\n", 4152 pcie_device->enclosure_level, 4153 pcie_device->connector_name)); 4154 } 4155 _scsih_ublock_io_device(ioc, sas_address, port); 4156 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE; 4157 } 4158 4159 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx); 4160 if (!smid) { 4161 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC); 4162 if (!delayed_tr) 4163 goto out; 4164 INIT_LIST_HEAD(&delayed_tr->list); 4165 delayed_tr->handle = handle; 4166 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list); 4167 dewtprintk(ioc, 4168 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n", 4169 handle)); 4170 goto out; 4171 } 4172 4173 dewtprintk(ioc, 4174 ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n", 4175 handle, smid, ioc->tm_tr_cb_idx)); 4176 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 4177 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t)); 4178 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 4179 mpi_request->DevHandle = cpu_to_le16(handle); 4180 mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET; 4181 mpi_request->MsgFlags = tr_method; 4182 set_bit(handle, ioc->device_remove_in_progress); 4183 ioc->put_smid_hi_priority(ioc, smid, 0); 4184 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_DEVICE_REMOVAL); 4185 4186 out: 4187 if (sas_device) 4188 sas_device_put(sas_device); 4189 if (pcie_device) 4190 pcie_device_put(pcie_device); 4191 } 4192 4193 /** 4194 * _scsih_tm_tr_complete - 4195 * @ioc: per adapter object 4196 * @smid: system request message index 4197 * @msix_index: MSIX table index supplied by the OS 4198 * @reply: reply message frame(lower 32bit addr) 4199 * Context: interrupt time. 4200 * 4201 * This is the target reset completion routine. 4202 * This code is part of the code to initiate the device removal 4203 * handshake protocol with controller firmware. 4204 * It will send a sas iounit control request (MPI2_SAS_OP_REMOVE_DEVICE) 4205 * 4206 * Return: 1 meaning mf should be freed from _base_interrupt 4207 * 0 means the mf is freed from this function. 4208 */ 4209 static u8 4210 _scsih_tm_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, 4211 u32 reply) 4212 { 4213 u16 handle; 4214 Mpi2SCSITaskManagementRequest_t *mpi_request_tm; 4215 Mpi2SCSITaskManagementReply_t *mpi_reply = 4216 mpt3sas_base_get_reply_virt_addr(ioc, reply); 4217 Mpi2SasIoUnitControlRequest_t *mpi_request; 4218 u16 smid_sas_ctrl; 4219 u32 ioc_state; 4220 struct _sc_list *delayed_sc; 4221 4222 if (ioc->pci_error_recovery) { 4223 dewtprintk(ioc, 4224 ioc_info(ioc, "%s: host in pci error recovery\n", 4225 __func__)); 4226 return 1; 4227 } 4228 ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 4229 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 4230 dewtprintk(ioc, 4231 ioc_info(ioc, "%s: host is not operational\n", 4232 __func__)); 4233 return 1; 4234 } 4235 if (unlikely(!mpi_reply)) { 4236 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n", 4237 __FILE__, __LINE__, __func__); 4238 return 1; 4239 } 4240 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid); 4241 handle = le16_to_cpu(mpi_request_tm->DevHandle); 4242 if (handle != le16_to_cpu(mpi_reply->DevHandle)) { 4243 dewtprintk(ioc, 4244 ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n", 4245 handle, 4246 le16_to_cpu(mpi_reply->DevHandle), smid)); 4247 return 0; 4248 } 4249 4250 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT); 4251 dewtprintk(ioc, 4252 ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n", 4253 handle, smid, le16_to_cpu(mpi_reply->IOCStatus), 4254 le32_to_cpu(mpi_reply->IOCLogInfo), 4255 le32_to_cpu(mpi_reply->TerminationCount))); 4256 4257 smid_sas_ctrl = mpt3sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx); 4258 if (!smid_sas_ctrl) { 4259 delayed_sc = kzalloc(sizeof(*delayed_sc), GFP_ATOMIC); 4260 if (!delayed_sc) 4261 return _scsih_check_for_pending_tm(ioc, smid); 4262 INIT_LIST_HEAD(&delayed_sc->list); 4263 delayed_sc->handle = le16_to_cpu(mpi_request_tm->DevHandle); 4264 list_add_tail(&delayed_sc->list, &ioc->delayed_sc_list); 4265 dewtprintk(ioc, 4266 ioc_info(ioc, "DELAYED:sc:handle(0x%04x), (open)\n", 4267 handle)); 4268 return _scsih_check_for_pending_tm(ioc, smid); 4269 } 4270 4271 dewtprintk(ioc, 4272 ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n", 4273 handle, smid_sas_ctrl, ioc->tm_sas_control_cb_idx)); 4274 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid_sas_ctrl); 4275 memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t)); 4276 mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL; 4277 mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE; 4278 mpi_request->DevHandle = mpi_request_tm->DevHandle; 4279 ioc->put_smid_default(ioc, smid_sas_ctrl); 4280 4281 return _scsih_check_for_pending_tm(ioc, smid); 4282 } 4283 4284 /** _scsih_allow_scmd_to_device - check whether scmd needs to 4285 * issue to IOC or not. 4286 * @ioc: per adapter object 4287 * @scmd: pointer to scsi command object 4288 * 4289 * Returns true if scmd can be issued to IOC otherwise returns false. 4290 */ 4291 inline bool _scsih_allow_scmd_to_device(struct MPT3SAS_ADAPTER *ioc, 4292 struct scsi_cmnd *scmd) 4293 { 4294 4295 if (ioc->pci_error_recovery) 4296 return false; 4297 4298 if (ioc->hba_mpi_version_belonged == MPI2_VERSION) { 4299 if (ioc->remove_host) 4300 return false; 4301 4302 return true; 4303 } 4304 4305 if (ioc->remove_host) { 4306 4307 switch (scmd->cmnd[0]) { 4308 case SYNCHRONIZE_CACHE: 4309 case START_STOP: 4310 return true; 4311 default: 4312 return false; 4313 } 4314 } 4315 4316 return true; 4317 } 4318 4319 /** 4320 * _scsih_sas_control_complete - completion routine 4321 * @ioc: per adapter object 4322 * @smid: system request message index 4323 * @msix_index: MSIX table index supplied by the OS 4324 * @reply: reply message frame(lower 32bit addr) 4325 * Context: interrupt time. 4326 * 4327 * This is the sas iounit control completion routine. 4328 * This code is part of the code to initiate the device removal 4329 * handshake protocol with controller firmware. 4330 * 4331 * Return: 1 meaning mf should be freed from _base_interrupt 4332 * 0 means the mf is freed from this function. 4333 */ 4334 static u8 4335 _scsih_sas_control_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, 4336 u8 msix_index, u32 reply) 4337 { 4338 Mpi2SasIoUnitControlReply_t *mpi_reply = 4339 mpt3sas_base_get_reply_virt_addr(ioc, reply); 4340 4341 if (likely(mpi_reply)) { 4342 dewtprintk(ioc, 4343 ioc_info(ioc, "sc_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n", 4344 le16_to_cpu(mpi_reply->DevHandle), smid, 4345 le16_to_cpu(mpi_reply->IOCStatus), 4346 le32_to_cpu(mpi_reply->IOCLogInfo))); 4347 if (le16_to_cpu(mpi_reply->IOCStatus) == 4348 MPI2_IOCSTATUS_SUCCESS) { 4349 clear_bit(le16_to_cpu(mpi_reply->DevHandle), 4350 ioc->device_remove_in_progress); 4351 } 4352 } else { 4353 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n", 4354 __FILE__, __LINE__, __func__); 4355 } 4356 return mpt3sas_check_for_pending_internal_cmds(ioc, smid); 4357 } 4358 4359 /** 4360 * _scsih_tm_tr_volume_send - send target reset request for volumes 4361 * @ioc: per adapter object 4362 * @handle: device handle 4363 * Context: interrupt time. 4364 * 4365 * This is designed to send muliple task management request at the same 4366 * time to the fifo. If the fifo is full, we will append the request, 4367 * and process it in a future completion. 4368 */ 4369 static void 4370 _scsih_tm_tr_volume_send(struct MPT3SAS_ADAPTER *ioc, u16 handle) 4371 { 4372 Mpi2SCSITaskManagementRequest_t *mpi_request; 4373 u16 smid; 4374 struct _tr_list *delayed_tr; 4375 4376 if (ioc->pci_error_recovery) { 4377 dewtprintk(ioc, 4378 ioc_info(ioc, "%s: host reset in progress!\n", 4379 __func__)); 4380 return; 4381 } 4382 4383 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx); 4384 if (!smid) { 4385 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC); 4386 if (!delayed_tr) 4387 return; 4388 INIT_LIST_HEAD(&delayed_tr->list); 4389 delayed_tr->handle = handle; 4390 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list); 4391 dewtprintk(ioc, 4392 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n", 4393 handle)); 4394 return; 4395 } 4396 4397 dewtprintk(ioc, 4398 ioc_info(ioc, "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n", 4399 handle, smid, ioc->tm_tr_volume_cb_idx)); 4400 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 4401 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t)); 4402 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 4403 mpi_request->DevHandle = cpu_to_le16(handle); 4404 mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET; 4405 ioc->put_smid_hi_priority(ioc, smid, 0); 4406 } 4407 4408 /** 4409 * _scsih_tm_volume_tr_complete - target reset completion 4410 * @ioc: per adapter object 4411 * @smid: system request message index 4412 * @msix_index: MSIX table index supplied by the OS 4413 * @reply: reply message frame(lower 32bit addr) 4414 * Context: interrupt time. 4415 * 4416 * Return: 1 meaning mf should be freed from _base_interrupt 4417 * 0 means the mf is freed from this function. 4418 */ 4419 static u8 4420 _scsih_tm_volume_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, 4421 u8 msix_index, u32 reply) 4422 { 4423 u16 handle; 4424 Mpi2SCSITaskManagementRequest_t *mpi_request_tm; 4425 Mpi2SCSITaskManagementReply_t *mpi_reply = 4426 mpt3sas_base_get_reply_virt_addr(ioc, reply); 4427 4428 if (ioc->shost_recovery || ioc->pci_error_recovery) { 4429 dewtprintk(ioc, 4430 ioc_info(ioc, "%s: host reset in progress!\n", 4431 __func__)); 4432 return 1; 4433 } 4434 if (unlikely(!mpi_reply)) { 4435 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n", 4436 __FILE__, __LINE__, __func__); 4437 return 1; 4438 } 4439 4440 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid); 4441 handle = le16_to_cpu(mpi_request_tm->DevHandle); 4442 if (handle != le16_to_cpu(mpi_reply->DevHandle)) { 4443 dewtprintk(ioc, 4444 ioc_err(ioc, "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n", 4445 handle, le16_to_cpu(mpi_reply->DevHandle), 4446 smid)); 4447 return 0; 4448 } 4449 4450 dewtprintk(ioc, 4451 ioc_info(ioc, "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), loginfo(0x%08x), completed(%d)\n", 4452 handle, smid, le16_to_cpu(mpi_reply->IOCStatus), 4453 le32_to_cpu(mpi_reply->IOCLogInfo), 4454 le32_to_cpu(mpi_reply->TerminationCount))); 4455 4456 return _scsih_check_for_pending_tm(ioc, smid); 4457 } 4458 4459 /** 4460 * _scsih_issue_delayed_event_ack - issue delayed Event ACK messages 4461 * @ioc: per adapter object 4462 * @smid: system request message index 4463 * @event: Event ID 4464 * @event_context: used to track events uniquely 4465 * 4466 * Context - processed in interrupt context. 4467 */ 4468 static void 4469 _scsih_issue_delayed_event_ack(struct MPT3SAS_ADAPTER *ioc, u16 smid, U16 event, 4470 U32 event_context) 4471 { 4472 Mpi2EventAckRequest_t *ack_request; 4473 int i = smid - ioc->internal_smid; 4474 unsigned long flags; 4475 4476 /* Without releasing the smid just update the 4477 * call back index and reuse the same smid for 4478 * processing this delayed request 4479 */ 4480 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 4481 ioc->internal_lookup[i].cb_idx = ioc->base_cb_idx; 4482 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 4483 4484 dewtprintk(ioc, 4485 ioc_info(ioc, "EVENT ACK: event(0x%04x), smid(%d), cb(%d)\n", 4486 le16_to_cpu(event), smid, ioc->base_cb_idx)); 4487 ack_request = mpt3sas_base_get_msg_frame(ioc, smid); 4488 memset(ack_request, 0, sizeof(Mpi2EventAckRequest_t)); 4489 ack_request->Function = MPI2_FUNCTION_EVENT_ACK; 4490 ack_request->Event = event; 4491 ack_request->EventContext = event_context; 4492 ack_request->VF_ID = 0; /* TODO */ 4493 ack_request->VP_ID = 0; 4494 ioc->put_smid_default(ioc, smid); 4495 } 4496 4497 /** 4498 * _scsih_issue_delayed_sas_io_unit_ctrl - issue delayed 4499 * sas_io_unit_ctrl messages 4500 * @ioc: per adapter object 4501 * @smid: system request message index 4502 * @handle: device handle 4503 * 4504 * Context - processed in interrupt context. 4505 */ 4506 static void 4507 _scsih_issue_delayed_sas_io_unit_ctrl(struct MPT3SAS_ADAPTER *ioc, 4508 u16 smid, u16 handle) 4509 { 4510 Mpi2SasIoUnitControlRequest_t *mpi_request; 4511 u32 ioc_state; 4512 int i = smid - ioc->internal_smid; 4513 unsigned long flags; 4514 4515 if (ioc->remove_host) { 4516 dewtprintk(ioc, 4517 ioc_info(ioc, "%s: host has been removed\n", 4518 __func__)); 4519 return; 4520 } else if (ioc->pci_error_recovery) { 4521 dewtprintk(ioc, 4522 ioc_info(ioc, "%s: host in pci error recovery\n", 4523 __func__)); 4524 return; 4525 } 4526 ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 4527 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 4528 dewtprintk(ioc, 4529 ioc_info(ioc, "%s: host is not operational\n", 4530 __func__)); 4531 return; 4532 } 4533 4534 /* Without releasing the smid just update the 4535 * call back index and reuse the same smid for 4536 * processing this delayed request 4537 */ 4538 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 4539 ioc->internal_lookup[i].cb_idx = ioc->tm_sas_control_cb_idx; 4540 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 4541 4542 dewtprintk(ioc, 4543 ioc_info(ioc, "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n", 4544 handle, smid, ioc->tm_sas_control_cb_idx)); 4545 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 4546 memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t)); 4547 mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL; 4548 mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE; 4549 mpi_request->DevHandle = cpu_to_le16(handle); 4550 ioc->put_smid_default(ioc, smid); 4551 } 4552 4553 /** 4554 * mpt3sas_check_for_pending_internal_cmds - check for pending internal messages 4555 * @ioc: per adapter object 4556 * @smid: system request message index 4557 * 4558 * Context: Executed in interrupt context 4559 * 4560 * This will check delayed internal messages list, and process the 4561 * next request. 4562 * 4563 * Return: 1 meaning mf should be freed from _base_interrupt 4564 * 0 means the mf is freed from this function. 4565 */ 4566 u8 4567 mpt3sas_check_for_pending_internal_cmds(struct MPT3SAS_ADAPTER *ioc, u16 smid) 4568 { 4569 struct _sc_list *delayed_sc; 4570 struct _event_ack_list *delayed_event_ack; 4571 4572 if (!list_empty(&ioc->delayed_event_ack_list)) { 4573 delayed_event_ack = list_entry(ioc->delayed_event_ack_list.next, 4574 struct _event_ack_list, list); 4575 _scsih_issue_delayed_event_ack(ioc, smid, 4576 delayed_event_ack->Event, delayed_event_ack->EventContext); 4577 list_del(&delayed_event_ack->list); 4578 kfree(delayed_event_ack); 4579 return 0; 4580 } 4581 4582 if (!list_empty(&ioc->delayed_sc_list)) { 4583 delayed_sc = list_entry(ioc->delayed_sc_list.next, 4584 struct _sc_list, list); 4585 _scsih_issue_delayed_sas_io_unit_ctrl(ioc, smid, 4586 delayed_sc->handle); 4587 list_del(&delayed_sc->list); 4588 kfree(delayed_sc); 4589 return 0; 4590 } 4591 return 1; 4592 } 4593 4594 /** 4595 * _scsih_check_for_pending_tm - check for pending task management 4596 * @ioc: per adapter object 4597 * @smid: system request message index 4598 * 4599 * This will check delayed target reset list, and feed the 4600 * next reqeust. 4601 * 4602 * Return: 1 meaning mf should be freed from _base_interrupt 4603 * 0 means the mf is freed from this function. 4604 */ 4605 static u8 4606 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid) 4607 { 4608 struct _tr_list *delayed_tr; 4609 4610 if (!list_empty(&ioc->delayed_tr_volume_list)) { 4611 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next, 4612 struct _tr_list, list); 4613 mpt3sas_base_free_smid(ioc, smid); 4614 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle); 4615 list_del(&delayed_tr->list); 4616 kfree(delayed_tr); 4617 return 0; 4618 } 4619 4620 if (!list_empty(&ioc->delayed_tr_list)) { 4621 delayed_tr = list_entry(ioc->delayed_tr_list.next, 4622 struct _tr_list, list); 4623 mpt3sas_base_free_smid(ioc, smid); 4624 _scsih_tm_tr_send(ioc, delayed_tr->handle); 4625 list_del(&delayed_tr->list); 4626 kfree(delayed_tr); 4627 return 0; 4628 } 4629 4630 return 1; 4631 } 4632 4633 /** 4634 * _scsih_check_topo_delete_events - sanity check on topo events 4635 * @ioc: per adapter object 4636 * @event_data: the event data payload 4637 * 4638 * This routine added to better handle cable breaker. 4639 * 4640 * This handles the case where driver receives multiple expander 4641 * add and delete events in a single shot. When there is a delete event 4642 * the routine will void any pending add events waiting in the event queue. 4643 */ 4644 static void 4645 _scsih_check_topo_delete_events(struct MPT3SAS_ADAPTER *ioc, 4646 Mpi2EventDataSasTopologyChangeList_t *event_data) 4647 { 4648 struct fw_event_work *fw_event; 4649 Mpi2EventDataSasTopologyChangeList_t *local_event_data; 4650 u16 expander_handle; 4651 struct _sas_node *sas_expander; 4652 unsigned long flags; 4653 int i, reason_code; 4654 u16 handle; 4655 4656 for (i = 0 ; i < event_data->NumEntries; i++) { 4657 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 4658 if (!handle) 4659 continue; 4660 reason_code = event_data->PHY[i].PhyStatus & 4661 MPI2_EVENT_SAS_TOPO_RC_MASK; 4662 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING) 4663 _scsih_tm_tr_send(ioc, handle); 4664 } 4665 4666 expander_handle = le16_to_cpu(event_data->ExpanderDevHandle); 4667 if (expander_handle < ioc->sas_hba.num_phys) { 4668 _scsih_block_io_to_children_attached_directly(ioc, event_data); 4669 return; 4670 } 4671 if (event_data->ExpStatus == 4672 MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING) { 4673 /* put expander attached devices into blocking state */ 4674 spin_lock_irqsave(&ioc->sas_node_lock, flags); 4675 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc, 4676 expander_handle); 4677 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander); 4678 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 4679 do { 4680 handle = find_first_bit(ioc->blocking_handles, 4681 ioc->facts.MaxDevHandle); 4682 if (handle < ioc->facts.MaxDevHandle) 4683 _scsih_block_io_device(ioc, handle); 4684 } while (test_and_clear_bit(handle, ioc->blocking_handles)); 4685 } else if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_RESPONDING) 4686 _scsih_block_io_to_children_attached_directly(ioc, event_data); 4687 4688 if (event_data->ExpStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING) 4689 return; 4690 4691 /* mark ignore flag for pending events */ 4692 spin_lock_irqsave(&ioc->fw_event_lock, flags); 4693 list_for_each_entry(fw_event, &ioc->fw_event_list, list) { 4694 if (fw_event->event != MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST || 4695 fw_event->ignore) 4696 continue; 4697 local_event_data = (Mpi2EventDataSasTopologyChangeList_t *) 4698 fw_event->event_data; 4699 if (local_event_data->ExpStatus == 4700 MPI2_EVENT_SAS_TOPO_ES_ADDED || 4701 local_event_data->ExpStatus == 4702 MPI2_EVENT_SAS_TOPO_ES_RESPONDING) { 4703 if (le16_to_cpu(local_event_data->ExpanderDevHandle) == 4704 expander_handle) { 4705 dewtprintk(ioc, 4706 ioc_info(ioc, "setting ignoring flag\n")); 4707 fw_event->ignore = 1; 4708 } 4709 } 4710 } 4711 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 4712 } 4713 4714 /** 4715 * _scsih_check_pcie_topo_remove_events - sanity check on topo 4716 * events 4717 * @ioc: per adapter object 4718 * @event_data: the event data payload 4719 * 4720 * This handles the case where driver receives multiple switch 4721 * or device add and delete events in a single shot. When there 4722 * is a delete event the routine will void any pending add 4723 * events waiting in the event queue. 4724 */ 4725 static void 4726 _scsih_check_pcie_topo_remove_events(struct MPT3SAS_ADAPTER *ioc, 4727 Mpi26EventDataPCIeTopologyChangeList_t *event_data) 4728 { 4729 struct fw_event_work *fw_event; 4730 Mpi26EventDataPCIeTopologyChangeList_t *local_event_data; 4731 unsigned long flags; 4732 int i, reason_code; 4733 u16 handle, switch_handle; 4734 4735 for (i = 0; i < event_data->NumEntries; i++) { 4736 handle = 4737 le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle); 4738 if (!handle) 4739 continue; 4740 reason_code = event_data->PortEntry[i].PortStatus; 4741 if (reason_code == MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING) 4742 _scsih_tm_tr_send(ioc, handle); 4743 } 4744 4745 switch_handle = le16_to_cpu(event_data->SwitchDevHandle); 4746 if (!switch_handle) { 4747 _scsih_block_io_to_pcie_children_attached_directly( 4748 ioc, event_data); 4749 return; 4750 } 4751 /* TODO We are not supporting cascaded PCIe Switch removal yet*/ 4752 if ((event_data->SwitchStatus 4753 == MPI26_EVENT_PCIE_TOPO_SS_DELAY_NOT_RESPONDING) || 4754 (event_data->SwitchStatus == 4755 MPI26_EVENT_PCIE_TOPO_SS_RESPONDING)) 4756 _scsih_block_io_to_pcie_children_attached_directly( 4757 ioc, event_data); 4758 4759 if (event_data->SwitchStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING) 4760 return; 4761 4762 /* mark ignore flag for pending events */ 4763 spin_lock_irqsave(&ioc->fw_event_lock, flags); 4764 list_for_each_entry(fw_event, &ioc->fw_event_list, list) { 4765 if (fw_event->event != MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST || 4766 fw_event->ignore) 4767 continue; 4768 local_event_data = 4769 (Mpi26EventDataPCIeTopologyChangeList_t *) 4770 fw_event->event_data; 4771 if (local_event_data->SwitchStatus == 4772 MPI2_EVENT_SAS_TOPO_ES_ADDED || 4773 local_event_data->SwitchStatus == 4774 MPI2_EVENT_SAS_TOPO_ES_RESPONDING) { 4775 if (le16_to_cpu(local_event_data->SwitchDevHandle) == 4776 switch_handle) { 4777 dewtprintk(ioc, 4778 ioc_info(ioc, "setting ignoring flag for switch event\n")); 4779 fw_event->ignore = 1; 4780 } 4781 } 4782 } 4783 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 4784 } 4785 4786 /** 4787 * _scsih_set_volume_delete_flag - setting volume delete flag 4788 * @ioc: per adapter object 4789 * @handle: device handle 4790 * 4791 * This returns nothing. 4792 */ 4793 static void 4794 _scsih_set_volume_delete_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle) 4795 { 4796 struct _raid_device *raid_device; 4797 struct MPT3SAS_TARGET *sas_target_priv_data; 4798 unsigned long flags; 4799 4800 spin_lock_irqsave(&ioc->raid_device_lock, flags); 4801 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 4802 if (raid_device && raid_device->starget && 4803 raid_device->starget->hostdata) { 4804 sas_target_priv_data = 4805 raid_device->starget->hostdata; 4806 sas_target_priv_data->deleted = 1; 4807 dewtprintk(ioc, 4808 ioc_info(ioc, "setting delete flag: handle(0x%04x), wwid(0x%016llx)\n", 4809 handle, (u64)raid_device->wwid)); 4810 } 4811 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 4812 } 4813 4814 /** 4815 * _scsih_set_volume_handle_for_tr - set handle for target reset to volume 4816 * @handle: input handle 4817 * @a: handle for volume a 4818 * @b: handle for volume b 4819 * 4820 * IR firmware only supports two raid volumes. The purpose of this 4821 * routine is to set the volume handle in either a or b. When the given 4822 * input handle is non-zero, or when a and b have not been set before. 4823 */ 4824 static void 4825 _scsih_set_volume_handle_for_tr(u16 handle, u16 *a, u16 *b) 4826 { 4827 if (!handle || handle == *a || handle == *b) 4828 return; 4829 if (!*a) 4830 *a = handle; 4831 else if (!*b) 4832 *b = handle; 4833 } 4834 4835 /** 4836 * _scsih_check_ir_config_unhide_events - check for UNHIDE events 4837 * @ioc: per adapter object 4838 * @event_data: the event data payload 4839 * Context: interrupt time. 4840 * 4841 * This routine will send target reset to volume, followed by target 4842 * resets to the PDs. This is called when a PD has been removed, or 4843 * volume has been deleted or removed. When the target reset is sent 4844 * to volume, the PD target resets need to be queued to start upon 4845 * completion of the volume target reset. 4846 */ 4847 static void 4848 _scsih_check_ir_config_unhide_events(struct MPT3SAS_ADAPTER *ioc, 4849 Mpi2EventDataIrConfigChangeList_t *event_data) 4850 { 4851 Mpi2EventIrConfigElement_t *element; 4852 int i; 4853 u16 handle, volume_handle, a, b; 4854 struct _tr_list *delayed_tr; 4855 4856 a = 0; 4857 b = 0; 4858 4859 if (ioc->is_warpdrive) 4860 return; 4861 4862 /* Volume Resets for Deleted or Removed */ 4863 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 4864 for (i = 0; i < event_data->NumElements; i++, element++) { 4865 if (le32_to_cpu(event_data->Flags) & 4866 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) 4867 continue; 4868 if (element->ReasonCode == 4869 MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED || 4870 element->ReasonCode == 4871 MPI2_EVENT_IR_CHANGE_RC_REMOVED) { 4872 volume_handle = le16_to_cpu(element->VolDevHandle); 4873 _scsih_set_volume_delete_flag(ioc, volume_handle); 4874 _scsih_set_volume_handle_for_tr(volume_handle, &a, &b); 4875 } 4876 } 4877 4878 /* Volume Resets for UNHIDE events */ 4879 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 4880 for (i = 0; i < event_data->NumElements; i++, element++) { 4881 if (le32_to_cpu(event_data->Flags) & 4882 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) 4883 continue; 4884 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_UNHIDE) { 4885 volume_handle = le16_to_cpu(element->VolDevHandle); 4886 _scsih_set_volume_handle_for_tr(volume_handle, &a, &b); 4887 } 4888 } 4889 4890 if (a) 4891 _scsih_tm_tr_volume_send(ioc, a); 4892 if (b) 4893 _scsih_tm_tr_volume_send(ioc, b); 4894 4895 /* PD target resets */ 4896 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 4897 for (i = 0; i < event_data->NumElements; i++, element++) { 4898 if (element->ReasonCode != MPI2_EVENT_IR_CHANGE_RC_UNHIDE) 4899 continue; 4900 handle = le16_to_cpu(element->PhysDiskDevHandle); 4901 volume_handle = le16_to_cpu(element->VolDevHandle); 4902 clear_bit(handle, ioc->pd_handles); 4903 if (!volume_handle) 4904 _scsih_tm_tr_send(ioc, handle); 4905 else if (volume_handle == a || volume_handle == b) { 4906 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC); 4907 BUG_ON(!delayed_tr); 4908 INIT_LIST_HEAD(&delayed_tr->list); 4909 delayed_tr->handle = handle; 4910 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list); 4911 dewtprintk(ioc, 4912 ioc_info(ioc, "DELAYED:tr:handle(0x%04x), (open)\n", 4913 handle)); 4914 } else 4915 _scsih_tm_tr_send(ioc, handle); 4916 } 4917 } 4918 4919 4920 /** 4921 * _scsih_check_volume_delete_events - set delete flag for volumes 4922 * @ioc: per adapter object 4923 * @event_data: the event data payload 4924 * Context: interrupt time. 4925 * 4926 * This will handle the case when the cable connected to entire volume is 4927 * pulled. We will take care of setting the deleted flag so normal IO will 4928 * not be sent. 4929 */ 4930 static void 4931 _scsih_check_volume_delete_events(struct MPT3SAS_ADAPTER *ioc, 4932 Mpi2EventDataIrVolume_t *event_data) 4933 { 4934 u32 state; 4935 4936 if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED) 4937 return; 4938 state = le32_to_cpu(event_data->NewValue); 4939 if (state == MPI2_RAID_VOL_STATE_MISSING || state == 4940 MPI2_RAID_VOL_STATE_FAILED) 4941 _scsih_set_volume_delete_flag(ioc, 4942 le16_to_cpu(event_data->VolDevHandle)); 4943 } 4944 4945 /** 4946 * _scsih_temp_threshold_events - display temperature threshold exceeded events 4947 * @ioc: per adapter object 4948 * @event_data: the temp threshold event data 4949 * Context: interrupt time. 4950 */ 4951 static void 4952 _scsih_temp_threshold_events(struct MPT3SAS_ADAPTER *ioc, 4953 Mpi2EventDataTemperature_t *event_data) 4954 { 4955 u32 doorbell; 4956 if (ioc->temp_sensors_count >= event_data->SensorNum) { 4957 ioc_err(ioc, "Temperature Threshold flags %s%s%s%s exceeded for Sensor: %d !!!\n", 4958 le16_to_cpu(event_data->Status) & 0x1 ? "0 " : " ", 4959 le16_to_cpu(event_data->Status) & 0x2 ? "1 " : " ", 4960 le16_to_cpu(event_data->Status) & 0x4 ? "2 " : " ", 4961 le16_to_cpu(event_data->Status) & 0x8 ? "3 " : " ", 4962 event_data->SensorNum); 4963 ioc_err(ioc, "Current Temp In Celsius: %d\n", 4964 event_data->CurrentTemperature); 4965 if (ioc->hba_mpi_version_belonged != MPI2_VERSION) { 4966 doorbell = mpt3sas_base_get_iocstate(ioc, 0); 4967 if ((doorbell & MPI2_IOC_STATE_MASK) == 4968 MPI2_IOC_STATE_FAULT) { 4969 mpt3sas_print_fault_code(ioc, 4970 doorbell & MPI2_DOORBELL_DATA_MASK); 4971 } else if ((doorbell & MPI2_IOC_STATE_MASK) == 4972 MPI2_IOC_STATE_COREDUMP) { 4973 mpt3sas_print_coredump_info(ioc, 4974 doorbell & MPI2_DOORBELL_DATA_MASK); 4975 } 4976 } 4977 } 4978 } 4979 4980 static int _scsih_set_satl_pending(struct scsi_cmnd *scmd, bool pending) 4981 { 4982 struct MPT3SAS_DEVICE *priv = scmd->device->hostdata; 4983 4984 if (scmd->cmnd[0] != ATA_12 && scmd->cmnd[0] != ATA_16) 4985 return 0; 4986 4987 if (pending) 4988 return test_and_set_bit(0, &priv->ata_command_pending); 4989 4990 clear_bit(0, &priv->ata_command_pending); 4991 return 0; 4992 } 4993 4994 /** 4995 * _scsih_flush_running_cmds - completing outstanding commands. 4996 * @ioc: per adapter object 4997 * 4998 * The flushing out of all pending scmd commands following host reset, 4999 * where all IO is dropped to the floor. 5000 */ 5001 static void 5002 _scsih_flush_running_cmds(struct MPT3SAS_ADAPTER *ioc) 5003 { 5004 struct scsi_cmnd *scmd; 5005 struct scsiio_tracker *st; 5006 u16 smid; 5007 int count = 0; 5008 5009 for (smid = 1; smid <= ioc->scsiio_depth; smid++) { 5010 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid); 5011 if (!scmd) 5012 continue; 5013 count++; 5014 _scsih_set_satl_pending(scmd, false); 5015 st = scsi_cmd_priv(scmd); 5016 mpt3sas_base_clear_st(ioc, st); 5017 scsi_dma_unmap(scmd); 5018 if (ioc->pci_error_recovery || ioc->remove_host) 5019 scmd->result = DID_NO_CONNECT << 16; 5020 else 5021 scmd->result = DID_RESET << 16; 5022 scsi_done(scmd); 5023 } 5024 dtmprintk(ioc, ioc_info(ioc, "completing %d cmds\n", count)); 5025 } 5026 5027 /** 5028 * _scsih_setup_eedp - setup MPI request for EEDP transfer 5029 * @ioc: per adapter object 5030 * @scmd: pointer to scsi command object 5031 * @mpi_request: pointer to the SCSI_IO request message frame 5032 * 5033 * Supporting protection 1 and 3. 5034 */ 5035 static void 5036 _scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd, 5037 Mpi25SCSIIORequest_t *mpi_request) 5038 { 5039 u16 eedp_flags; 5040 Mpi25SCSIIORequest_t *mpi_request_3v = 5041 (Mpi25SCSIIORequest_t *)mpi_request; 5042 5043 switch (scsi_get_prot_op(scmd)) { 5044 case SCSI_PROT_READ_STRIP: 5045 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP; 5046 break; 5047 case SCSI_PROT_WRITE_INSERT: 5048 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_INSERT_OP; 5049 break; 5050 default: 5051 return; 5052 } 5053 5054 if (scmd->prot_flags & SCSI_PROT_GUARD_CHECK) 5055 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD; 5056 5057 if (scmd->prot_flags & SCSI_PROT_REF_CHECK) 5058 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG; 5059 5060 if (scmd->prot_flags & SCSI_PROT_REF_INCREMENT) { 5061 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG; 5062 5063 mpi_request->CDB.EEDP32.PrimaryReferenceTag = 5064 cpu_to_be32(scsi_prot_ref_tag(scmd)); 5065 } 5066 5067 mpi_request_3v->EEDPBlockSize = cpu_to_le16(scsi_prot_interval(scmd)); 5068 5069 if (ioc->is_gen35_ioc) 5070 eedp_flags |= MPI25_SCSIIO_EEDPFLAGS_APPTAG_DISABLE_MODE; 5071 mpi_request->EEDPFlags = cpu_to_le16(eedp_flags); 5072 } 5073 5074 /** 5075 * _scsih_eedp_error_handling - return sense code for EEDP errors 5076 * @scmd: pointer to scsi command object 5077 * @ioc_status: ioc status 5078 */ 5079 static void 5080 _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status) 5081 { 5082 u8 ascq; 5083 5084 switch (ioc_status) { 5085 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR: 5086 ascq = 0x01; 5087 break; 5088 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR: 5089 ascq = 0x02; 5090 break; 5091 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR: 5092 ascq = 0x03; 5093 break; 5094 default: 5095 ascq = 0x00; 5096 break; 5097 } 5098 scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x10, ascq); 5099 set_host_byte(scmd, DID_ABORT); 5100 } 5101 5102 /** 5103 * scsih_qcmd - main scsi request entry point 5104 * @shost: SCSI host pointer 5105 * @scmd: pointer to scsi command object 5106 * 5107 * The callback index is set inside `ioc->scsi_io_cb_idx`. 5108 * 5109 * Return: 0 on success. If there's a failure, return either: 5110 * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or 5111 * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full 5112 */ 5113 static int 5114 scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd) 5115 { 5116 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 5117 struct MPT3SAS_DEVICE *sas_device_priv_data; 5118 struct MPT3SAS_TARGET *sas_target_priv_data; 5119 struct _raid_device *raid_device; 5120 struct request *rq = scsi_cmd_to_rq(scmd); 5121 int class; 5122 Mpi25SCSIIORequest_t *mpi_request; 5123 struct _pcie_device *pcie_device = NULL; 5124 u32 mpi_control; 5125 u16 smid; 5126 u16 handle; 5127 5128 if (ioc->logging_level & MPT_DEBUG_SCSI) 5129 scsi_print_command(scmd); 5130 5131 sas_device_priv_data = scmd->device->hostdata; 5132 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) { 5133 scmd->result = DID_NO_CONNECT << 16; 5134 scsi_done(scmd); 5135 return 0; 5136 } 5137 5138 if (!(_scsih_allow_scmd_to_device(ioc, scmd))) { 5139 scmd->result = DID_NO_CONNECT << 16; 5140 scsi_done(scmd); 5141 return 0; 5142 } 5143 5144 sas_target_priv_data = sas_device_priv_data->sas_target; 5145 5146 /* invalid device handle */ 5147 handle = sas_target_priv_data->handle; 5148 5149 /* 5150 * Avoid error handling escallation when device is disconnected 5151 */ 5152 if (handle == MPT3SAS_INVALID_DEVICE_HANDLE || sas_device_priv_data->block) { 5153 if (scmd->device->host->shost_state == SHOST_RECOVERY && 5154 scmd->cmnd[0] == TEST_UNIT_READY) { 5155 scsi_build_sense(scmd, 0, UNIT_ATTENTION, 0x29, 0x07); 5156 scsi_done(scmd); 5157 return 0; 5158 } 5159 } 5160 5161 if (handle == MPT3SAS_INVALID_DEVICE_HANDLE) { 5162 scmd->result = DID_NO_CONNECT << 16; 5163 scsi_done(scmd); 5164 return 0; 5165 } 5166 5167 5168 if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress) { 5169 /* host recovery or link resets sent via IOCTLs */ 5170 return SCSI_MLQUEUE_HOST_BUSY; 5171 } else if (sas_target_priv_data->deleted) { 5172 /* device has been deleted */ 5173 scmd->result = DID_NO_CONNECT << 16; 5174 scsi_done(scmd); 5175 return 0; 5176 } else if (sas_target_priv_data->tm_busy || 5177 sas_device_priv_data->block) { 5178 /* device busy with task management */ 5179 return SCSI_MLQUEUE_DEVICE_BUSY; 5180 } 5181 5182 /* 5183 * Bug work around for firmware SATL handling. The loop 5184 * is based on atomic operations and ensures consistency 5185 * since we're lockless at this point 5186 */ 5187 do { 5188 if (test_bit(0, &sas_device_priv_data->ata_command_pending)) 5189 return SCSI_MLQUEUE_DEVICE_BUSY; 5190 } while (_scsih_set_satl_pending(scmd, true)); 5191 5192 if (scmd->sc_data_direction == DMA_FROM_DEVICE) 5193 mpi_control = MPI2_SCSIIO_CONTROL_READ; 5194 else if (scmd->sc_data_direction == DMA_TO_DEVICE) 5195 mpi_control = MPI2_SCSIIO_CONTROL_WRITE; 5196 else 5197 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER; 5198 5199 /* set tags */ 5200 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ; 5201 /* NCQ Prio supported, make sure control indicated high priority */ 5202 if (sas_device_priv_data->ncq_prio_enable) { 5203 class = IOPRIO_PRIO_CLASS(req_get_ioprio(rq)); 5204 if (class == IOPRIO_CLASS_RT) 5205 mpi_control |= 1 << MPI2_SCSIIO_CONTROL_CMDPRI_SHIFT; 5206 } 5207 /* Make sure Device is not raid volume. 5208 * We do not expose raid functionality to upper layer for warpdrive. 5209 */ 5210 if (((!ioc->is_warpdrive && !scsih_is_raid(&scmd->device->sdev_gendev)) 5211 && !scsih_is_nvme(&scmd->device->sdev_gendev)) 5212 && sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32) 5213 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON; 5214 5215 smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd); 5216 if (!smid) { 5217 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__); 5218 _scsih_set_satl_pending(scmd, false); 5219 goto out; 5220 } 5221 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 5222 memset(mpi_request, 0, ioc->request_sz); 5223 _scsih_setup_eedp(ioc, scmd, mpi_request); 5224 5225 if (scmd->cmd_len == 32) 5226 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT; 5227 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST; 5228 if (sas_device_priv_data->sas_target->flags & 5229 MPT_TARGET_FLAGS_RAID_COMPONENT) 5230 mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH; 5231 else 5232 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST; 5233 mpi_request->DevHandle = cpu_to_le16(handle); 5234 mpi_request->DataLength = cpu_to_le32(scsi_bufflen(scmd)); 5235 mpi_request->Control = cpu_to_le32(mpi_control); 5236 mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len); 5237 mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR; 5238 mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE; 5239 mpi_request->SenseBufferLowAddress = 5240 mpt3sas_base_get_sense_buffer_dma(ioc, smid); 5241 mpi_request->SGLOffset0 = offsetof(Mpi25SCSIIORequest_t, SGL) / 4; 5242 int_to_scsilun(sas_device_priv_data->lun, (struct scsi_lun *) 5243 mpi_request->LUN); 5244 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len); 5245 5246 if (mpi_request->DataLength) { 5247 pcie_device = sas_target_priv_data->pcie_dev; 5248 if (ioc->build_sg_scmd(ioc, scmd, smid, pcie_device)) { 5249 mpt3sas_base_free_smid(ioc, smid); 5250 _scsih_set_satl_pending(scmd, false); 5251 goto out; 5252 } 5253 } else 5254 ioc->build_zero_len_sge(ioc, &mpi_request->SGL); 5255 5256 raid_device = sas_target_priv_data->raid_device; 5257 if (raid_device && raid_device->direct_io_enabled) 5258 mpt3sas_setup_direct_io(ioc, scmd, 5259 raid_device, mpi_request); 5260 5261 if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)) { 5262 if (sas_target_priv_data->flags & MPT_TARGET_FASTPATH_IO) { 5263 mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len | 5264 MPI25_SCSIIO_IOFLAGS_FAST_PATH); 5265 ioc->put_smid_fast_path(ioc, smid, handle); 5266 } else 5267 ioc->put_smid_scsi_io(ioc, smid, 5268 le16_to_cpu(mpi_request->DevHandle)); 5269 } else 5270 ioc->put_smid_default(ioc, smid); 5271 return 0; 5272 5273 out: 5274 return SCSI_MLQUEUE_HOST_BUSY; 5275 } 5276 5277 /** 5278 * _scsih_normalize_sense - normalize descriptor and fixed format sense data 5279 * @sense_buffer: sense data returned by target 5280 * @data: normalized skey/asc/ascq 5281 */ 5282 static void 5283 _scsih_normalize_sense(char *sense_buffer, struct sense_info *data) 5284 { 5285 if ((sense_buffer[0] & 0x7F) >= 0x72) { 5286 /* descriptor format */ 5287 data->skey = sense_buffer[1] & 0x0F; 5288 data->asc = sense_buffer[2]; 5289 data->ascq = sense_buffer[3]; 5290 } else { 5291 /* fixed format */ 5292 data->skey = sense_buffer[2] & 0x0F; 5293 data->asc = sense_buffer[12]; 5294 data->ascq = sense_buffer[13]; 5295 } 5296 } 5297 5298 /** 5299 * _scsih_scsi_ioc_info - translated non-successful SCSI_IO request 5300 * @ioc: per adapter object 5301 * @scmd: pointer to scsi command object 5302 * @mpi_reply: reply mf payload returned from firmware 5303 * @smid: ? 5304 * 5305 * scsi_status - SCSI Status code returned from target device 5306 * scsi_state - state info associated with SCSI_IO determined by ioc 5307 * ioc_status - ioc supplied status info 5308 */ 5309 static void 5310 _scsih_scsi_ioc_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd, 5311 Mpi2SCSIIOReply_t *mpi_reply, u16 smid) 5312 { 5313 u32 response_info; 5314 u8 *response_bytes; 5315 u16 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & 5316 MPI2_IOCSTATUS_MASK; 5317 u8 scsi_state = mpi_reply->SCSIState; 5318 u8 scsi_status = mpi_reply->SCSIStatus; 5319 char *desc_ioc_state = NULL; 5320 char *desc_scsi_status = NULL; 5321 char *desc_scsi_state = ioc->tmp_string; 5322 u32 log_info = le32_to_cpu(mpi_reply->IOCLogInfo); 5323 struct _sas_device *sas_device = NULL; 5324 struct _pcie_device *pcie_device = NULL; 5325 struct scsi_target *starget = scmd->device->sdev_target; 5326 struct MPT3SAS_TARGET *priv_target = starget->hostdata; 5327 char *device_str = NULL; 5328 5329 if (!priv_target) 5330 return; 5331 if (ioc->hide_ir_msg) 5332 device_str = "WarpDrive"; 5333 else 5334 device_str = "volume"; 5335 5336 if (log_info == 0x31170000) 5337 return; 5338 5339 switch (ioc_status) { 5340 case MPI2_IOCSTATUS_SUCCESS: 5341 desc_ioc_state = "success"; 5342 break; 5343 case MPI2_IOCSTATUS_INVALID_FUNCTION: 5344 desc_ioc_state = "invalid function"; 5345 break; 5346 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR: 5347 desc_ioc_state = "scsi recovered error"; 5348 break; 5349 case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE: 5350 desc_ioc_state = "scsi invalid dev handle"; 5351 break; 5352 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE: 5353 desc_ioc_state = "scsi device not there"; 5354 break; 5355 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN: 5356 desc_ioc_state = "scsi data overrun"; 5357 break; 5358 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN: 5359 desc_ioc_state = "scsi data underrun"; 5360 break; 5361 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR: 5362 desc_ioc_state = "scsi io data error"; 5363 break; 5364 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR: 5365 desc_ioc_state = "scsi protocol error"; 5366 break; 5367 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED: 5368 desc_ioc_state = "scsi task terminated"; 5369 break; 5370 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: 5371 desc_ioc_state = "scsi residual mismatch"; 5372 break; 5373 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED: 5374 desc_ioc_state = "scsi task mgmt failed"; 5375 break; 5376 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED: 5377 desc_ioc_state = "scsi ioc terminated"; 5378 break; 5379 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED: 5380 desc_ioc_state = "scsi ext terminated"; 5381 break; 5382 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR: 5383 desc_ioc_state = "eedp guard error"; 5384 break; 5385 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR: 5386 desc_ioc_state = "eedp ref tag error"; 5387 break; 5388 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR: 5389 desc_ioc_state = "eedp app tag error"; 5390 break; 5391 case MPI2_IOCSTATUS_INSUFFICIENT_POWER: 5392 desc_ioc_state = "insufficient power"; 5393 break; 5394 default: 5395 desc_ioc_state = "unknown"; 5396 break; 5397 } 5398 5399 switch (scsi_status) { 5400 case MPI2_SCSI_STATUS_GOOD: 5401 desc_scsi_status = "good"; 5402 break; 5403 case MPI2_SCSI_STATUS_CHECK_CONDITION: 5404 desc_scsi_status = "check condition"; 5405 break; 5406 case MPI2_SCSI_STATUS_CONDITION_MET: 5407 desc_scsi_status = "condition met"; 5408 break; 5409 case MPI2_SCSI_STATUS_BUSY: 5410 desc_scsi_status = "busy"; 5411 break; 5412 case MPI2_SCSI_STATUS_INTERMEDIATE: 5413 desc_scsi_status = "intermediate"; 5414 break; 5415 case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET: 5416 desc_scsi_status = "intermediate condmet"; 5417 break; 5418 case MPI2_SCSI_STATUS_RESERVATION_CONFLICT: 5419 desc_scsi_status = "reservation conflict"; 5420 break; 5421 case MPI2_SCSI_STATUS_COMMAND_TERMINATED: 5422 desc_scsi_status = "command terminated"; 5423 break; 5424 case MPI2_SCSI_STATUS_TASK_SET_FULL: 5425 desc_scsi_status = "task set full"; 5426 break; 5427 case MPI2_SCSI_STATUS_ACA_ACTIVE: 5428 desc_scsi_status = "aca active"; 5429 break; 5430 case MPI2_SCSI_STATUS_TASK_ABORTED: 5431 desc_scsi_status = "task aborted"; 5432 break; 5433 default: 5434 desc_scsi_status = "unknown"; 5435 break; 5436 } 5437 5438 desc_scsi_state[0] = '\0'; 5439 if (!scsi_state) 5440 desc_scsi_state = " "; 5441 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) 5442 strcat(desc_scsi_state, "response info "); 5443 if (scsi_state & MPI2_SCSI_STATE_TERMINATED) 5444 strcat(desc_scsi_state, "state terminated "); 5445 if (scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS) 5446 strcat(desc_scsi_state, "no status "); 5447 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED) 5448 strcat(desc_scsi_state, "autosense failed "); 5449 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) 5450 strcat(desc_scsi_state, "autosense valid "); 5451 5452 scsi_print_command(scmd); 5453 5454 if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) { 5455 ioc_warn(ioc, "\t%s wwid(0x%016llx)\n", 5456 device_str, (u64)priv_target->sas_address); 5457 } else if (priv_target->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) { 5458 pcie_device = mpt3sas_get_pdev_from_target(ioc, priv_target); 5459 if (pcie_device) { 5460 ioc_info(ioc, "\twwid(0x%016llx), port(%d)\n", 5461 (u64)pcie_device->wwid, pcie_device->port_num); 5462 if (pcie_device->enclosure_handle != 0) 5463 ioc_info(ioc, "\tenclosure logical id(0x%016llx), slot(%d)\n", 5464 (u64)pcie_device->enclosure_logical_id, 5465 pcie_device->slot); 5466 if (pcie_device->connector_name[0]) 5467 ioc_info(ioc, "\tenclosure level(0x%04x), connector name( %s)\n", 5468 pcie_device->enclosure_level, 5469 pcie_device->connector_name); 5470 pcie_device_put(pcie_device); 5471 } 5472 } else { 5473 sas_device = mpt3sas_get_sdev_from_target(ioc, priv_target); 5474 if (sas_device) { 5475 ioc_warn(ioc, "\tsas_address(0x%016llx), phy(%d)\n", 5476 (u64)sas_device->sas_address, sas_device->phy); 5477 5478 _scsih_display_enclosure_chassis_info(ioc, sas_device, 5479 NULL, NULL); 5480 5481 sas_device_put(sas_device); 5482 } 5483 } 5484 5485 ioc_warn(ioc, "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n", 5486 le16_to_cpu(mpi_reply->DevHandle), 5487 desc_ioc_state, ioc_status, smid); 5488 ioc_warn(ioc, "\trequest_len(%d), underflow(%d), resid(%d)\n", 5489 scsi_bufflen(scmd), scmd->underflow, scsi_get_resid(scmd)); 5490 ioc_warn(ioc, "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n", 5491 le16_to_cpu(mpi_reply->TaskTag), 5492 le32_to_cpu(mpi_reply->TransferCount), scmd->result); 5493 ioc_warn(ioc, "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n", 5494 desc_scsi_status, scsi_status, desc_scsi_state, scsi_state); 5495 5496 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) { 5497 struct sense_info data; 5498 _scsih_normalize_sense(scmd->sense_buffer, &data); 5499 ioc_warn(ioc, "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n", 5500 data.skey, data.asc, data.ascq, 5501 le32_to_cpu(mpi_reply->SenseCount)); 5502 } 5503 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) { 5504 response_info = le32_to_cpu(mpi_reply->ResponseInfo); 5505 response_bytes = (u8 *)&response_info; 5506 _scsih_response_code(ioc, response_bytes[0]); 5507 } 5508 } 5509 5510 /** 5511 * _scsih_turn_on_pfa_led - illuminate PFA LED 5512 * @ioc: per adapter object 5513 * @handle: device handle 5514 * Context: process 5515 */ 5516 static void 5517 _scsih_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle) 5518 { 5519 Mpi2SepReply_t mpi_reply; 5520 Mpi2SepRequest_t mpi_request; 5521 struct _sas_device *sas_device; 5522 5523 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 5524 if (!sas_device) 5525 return; 5526 5527 memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t)); 5528 mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR; 5529 mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS; 5530 mpi_request.SlotStatus = 5531 cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT); 5532 mpi_request.DevHandle = cpu_to_le16(handle); 5533 mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS; 5534 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply, 5535 &mpi_request)) != 0) { 5536 ioc_err(ioc, "failure at %s:%d/%s()!\n", 5537 __FILE__, __LINE__, __func__); 5538 goto out; 5539 } 5540 sas_device->pfa_led_on = 1; 5541 5542 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) { 5543 dewtprintk(ioc, 5544 ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n", 5545 le16_to_cpu(mpi_reply.IOCStatus), 5546 le32_to_cpu(mpi_reply.IOCLogInfo))); 5547 goto out; 5548 } 5549 out: 5550 sas_device_put(sas_device); 5551 } 5552 5553 /** 5554 * _scsih_turn_off_pfa_led - turn off Fault LED 5555 * @ioc: per adapter object 5556 * @sas_device: sas device whose PFA LED has to turned off 5557 * Context: process 5558 */ 5559 static void 5560 _scsih_turn_off_pfa_led(struct MPT3SAS_ADAPTER *ioc, 5561 struct _sas_device *sas_device) 5562 { 5563 Mpi2SepReply_t mpi_reply; 5564 Mpi2SepRequest_t mpi_request; 5565 5566 memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t)); 5567 mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR; 5568 mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS; 5569 mpi_request.SlotStatus = 0; 5570 mpi_request.Slot = cpu_to_le16(sas_device->slot); 5571 mpi_request.DevHandle = 0; 5572 mpi_request.EnclosureHandle = cpu_to_le16(sas_device->enclosure_handle); 5573 mpi_request.Flags = MPI2_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS; 5574 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply, 5575 &mpi_request)) != 0) { 5576 ioc_err(ioc, "failure at %s:%d/%s()!\n", 5577 __FILE__, __LINE__, __func__); 5578 return; 5579 } 5580 5581 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) { 5582 dewtprintk(ioc, 5583 ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n", 5584 le16_to_cpu(mpi_reply.IOCStatus), 5585 le32_to_cpu(mpi_reply.IOCLogInfo))); 5586 return; 5587 } 5588 } 5589 5590 /** 5591 * _scsih_send_event_to_turn_on_pfa_led - fire delayed event 5592 * @ioc: per adapter object 5593 * @handle: device handle 5594 * Context: interrupt. 5595 */ 5596 static void 5597 _scsih_send_event_to_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle) 5598 { 5599 struct fw_event_work *fw_event; 5600 5601 fw_event = alloc_fw_event_work(0); 5602 if (!fw_event) 5603 return; 5604 fw_event->event = MPT3SAS_TURN_ON_PFA_LED; 5605 fw_event->device_handle = handle; 5606 fw_event->ioc = ioc; 5607 _scsih_fw_event_add(ioc, fw_event); 5608 fw_event_work_put(fw_event); 5609 } 5610 5611 /** 5612 * _scsih_smart_predicted_fault - process smart errors 5613 * @ioc: per adapter object 5614 * @handle: device handle 5615 * Context: interrupt. 5616 */ 5617 static void 5618 _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle) 5619 { 5620 struct scsi_target *starget; 5621 struct MPT3SAS_TARGET *sas_target_priv_data; 5622 Mpi2EventNotificationReply_t *event_reply; 5623 Mpi2EventDataSasDeviceStatusChange_t *event_data; 5624 struct _sas_device *sas_device; 5625 ssize_t sz; 5626 unsigned long flags; 5627 5628 /* only handle non-raid devices */ 5629 spin_lock_irqsave(&ioc->sas_device_lock, flags); 5630 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 5631 if (!sas_device) 5632 goto out_unlock; 5633 5634 starget = sas_device->starget; 5635 sas_target_priv_data = starget->hostdata; 5636 5637 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) || 5638 ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))) 5639 goto out_unlock; 5640 5641 _scsih_display_enclosure_chassis_info(NULL, sas_device, NULL, starget); 5642 5643 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 5644 5645 if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) 5646 _scsih_send_event_to_turn_on_pfa_led(ioc, handle); 5647 5648 /* insert into event log */ 5649 sz = offsetof(Mpi2EventNotificationReply_t, EventData) + 5650 sizeof(Mpi2EventDataSasDeviceStatusChange_t); 5651 event_reply = kzalloc(sz, GFP_ATOMIC); 5652 if (!event_reply) { 5653 ioc_err(ioc, "failure at %s:%d/%s()!\n", 5654 __FILE__, __LINE__, __func__); 5655 goto out; 5656 } 5657 5658 event_reply->Function = MPI2_FUNCTION_EVENT_NOTIFICATION; 5659 event_reply->Event = 5660 cpu_to_le16(MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE); 5661 event_reply->MsgLength = sz/4; 5662 event_reply->EventDataLength = 5663 cpu_to_le16(sizeof(Mpi2EventDataSasDeviceStatusChange_t)/4); 5664 event_data = (Mpi2EventDataSasDeviceStatusChange_t *) 5665 event_reply->EventData; 5666 event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA; 5667 event_data->ASC = 0x5D; 5668 event_data->DevHandle = cpu_to_le16(handle); 5669 event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address); 5670 mpt3sas_ctl_add_to_event_log(ioc, event_reply); 5671 kfree(event_reply); 5672 out: 5673 if (sas_device) 5674 sas_device_put(sas_device); 5675 return; 5676 5677 out_unlock: 5678 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 5679 goto out; 5680 } 5681 5682 /** 5683 * _scsih_io_done - scsi request callback 5684 * @ioc: per adapter object 5685 * @smid: system request message index 5686 * @msix_index: MSIX table index supplied by the OS 5687 * @reply: reply message frame(lower 32bit addr) 5688 * 5689 * Callback handler when using _scsih_qcmd. 5690 * 5691 * Return: 1 meaning mf should be freed from _base_interrupt 5692 * 0 means the mf is freed from this function. 5693 */ 5694 static u8 5695 _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply) 5696 { 5697 Mpi25SCSIIORequest_t *mpi_request; 5698 Mpi2SCSIIOReply_t *mpi_reply; 5699 struct scsi_cmnd *scmd; 5700 struct scsiio_tracker *st; 5701 u16 ioc_status; 5702 u32 xfer_cnt; 5703 u8 scsi_state; 5704 u8 scsi_status; 5705 u32 log_info; 5706 struct MPT3SAS_DEVICE *sas_device_priv_data; 5707 u32 response_code = 0; 5708 5709 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 5710 5711 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid); 5712 if (scmd == NULL) 5713 return 1; 5714 5715 _scsih_set_satl_pending(scmd, false); 5716 5717 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 5718 5719 if (mpi_reply == NULL) { 5720 scmd->result = DID_OK << 16; 5721 goto out; 5722 } 5723 5724 sas_device_priv_data = scmd->device->hostdata; 5725 if (!sas_device_priv_data || !sas_device_priv_data->sas_target || 5726 sas_device_priv_data->sas_target->deleted) { 5727 scmd->result = DID_NO_CONNECT << 16; 5728 goto out; 5729 } 5730 ioc_status = le16_to_cpu(mpi_reply->IOCStatus); 5731 5732 /* 5733 * WARPDRIVE: If direct_io is set then it is directIO, 5734 * the failed direct I/O should be redirected to volume 5735 */ 5736 st = scsi_cmd_priv(scmd); 5737 if (st->direct_io && 5738 ((ioc_status & MPI2_IOCSTATUS_MASK) 5739 != MPI2_IOCSTATUS_SCSI_TASK_TERMINATED)) { 5740 st->direct_io = 0; 5741 st->scmd = scmd; 5742 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len); 5743 mpi_request->DevHandle = 5744 cpu_to_le16(sas_device_priv_data->sas_target->handle); 5745 ioc->put_smid_scsi_io(ioc, smid, 5746 sas_device_priv_data->sas_target->handle); 5747 return 0; 5748 } 5749 /* turning off TLR */ 5750 scsi_state = mpi_reply->SCSIState; 5751 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) 5752 response_code = 5753 le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF; 5754 if (!sas_device_priv_data->tlr_snoop_check) { 5755 sas_device_priv_data->tlr_snoop_check++; 5756 if ((!ioc->is_warpdrive && 5757 !scsih_is_raid(&scmd->device->sdev_gendev) && 5758 !scsih_is_nvme(&scmd->device->sdev_gendev)) 5759 && sas_is_tlr_enabled(scmd->device) && 5760 response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) { 5761 sas_disable_tlr(scmd->device); 5762 sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n"); 5763 } 5764 } 5765 5766 xfer_cnt = le32_to_cpu(mpi_reply->TransferCount); 5767 scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt); 5768 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) 5769 log_info = le32_to_cpu(mpi_reply->IOCLogInfo); 5770 else 5771 log_info = 0; 5772 ioc_status &= MPI2_IOCSTATUS_MASK; 5773 scsi_status = mpi_reply->SCSIStatus; 5774 5775 if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 && 5776 (scsi_status == MPI2_SCSI_STATUS_BUSY || 5777 scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT || 5778 scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) { 5779 ioc_status = MPI2_IOCSTATUS_SUCCESS; 5780 } 5781 5782 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) { 5783 struct sense_info data; 5784 const void *sense_data = mpt3sas_base_get_sense_buffer(ioc, 5785 smid); 5786 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE, 5787 le32_to_cpu(mpi_reply->SenseCount)); 5788 memcpy(scmd->sense_buffer, sense_data, sz); 5789 _scsih_normalize_sense(scmd->sense_buffer, &data); 5790 /* failure prediction threshold exceeded */ 5791 if (data.asc == 0x5D) 5792 _scsih_smart_predicted_fault(ioc, 5793 le16_to_cpu(mpi_reply->DevHandle)); 5794 mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq); 5795 5796 if ((ioc->logging_level & MPT_DEBUG_REPLY) && 5797 ((scmd->sense_buffer[2] == UNIT_ATTENTION) || 5798 (scmd->sense_buffer[2] == MEDIUM_ERROR) || 5799 (scmd->sense_buffer[2] == HARDWARE_ERROR))) 5800 _scsih_scsi_ioc_info(ioc, scmd, mpi_reply, smid); 5801 } 5802 switch (ioc_status) { 5803 case MPI2_IOCSTATUS_BUSY: 5804 case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES: 5805 scmd->result = SAM_STAT_BUSY; 5806 break; 5807 5808 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE: 5809 scmd->result = DID_NO_CONNECT << 16; 5810 break; 5811 5812 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED: 5813 if (sas_device_priv_data->block) { 5814 scmd->result = DID_TRANSPORT_DISRUPTED << 16; 5815 goto out; 5816 } 5817 if (log_info == 0x31110630) { 5818 if (scmd->retries > 2) { 5819 scmd->result = DID_NO_CONNECT << 16; 5820 scsi_device_set_state(scmd->device, 5821 SDEV_OFFLINE); 5822 } else { 5823 scmd->result = DID_SOFT_ERROR << 16; 5824 scmd->device->expecting_cc_ua = 1; 5825 } 5826 break; 5827 } else if (log_info == VIRTUAL_IO_FAILED_RETRY) { 5828 scmd->result = DID_RESET << 16; 5829 break; 5830 } else if ((scmd->device->channel == RAID_CHANNEL) && 5831 (scsi_state == (MPI2_SCSI_STATE_TERMINATED | 5832 MPI2_SCSI_STATE_NO_SCSI_STATUS))) { 5833 scmd->result = DID_RESET << 16; 5834 break; 5835 } 5836 scmd->result = DID_SOFT_ERROR << 16; 5837 break; 5838 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED: 5839 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED: 5840 scmd->result = DID_RESET << 16; 5841 break; 5842 5843 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: 5844 if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt)) 5845 scmd->result = DID_SOFT_ERROR << 16; 5846 else 5847 scmd->result = (DID_OK << 16) | scsi_status; 5848 break; 5849 5850 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN: 5851 scmd->result = (DID_OK << 16) | scsi_status; 5852 5853 if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)) 5854 break; 5855 5856 if (xfer_cnt < scmd->underflow) { 5857 if (scsi_status == SAM_STAT_BUSY) 5858 scmd->result = SAM_STAT_BUSY; 5859 else 5860 scmd->result = DID_SOFT_ERROR << 16; 5861 } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED | 5862 MPI2_SCSI_STATE_NO_SCSI_STATUS)) 5863 scmd->result = DID_SOFT_ERROR << 16; 5864 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED) 5865 scmd->result = DID_RESET << 16; 5866 else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) { 5867 mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID; 5868 mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION; 5869 scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 5870 0x20, 0); 5871 } 5872 break; 5873 5874 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN: 5875 scsi_set_resid(scmd, 0); 5876 fallthrough; 5877 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR: 5878 case MPI2_IOCSTATUS_SUCCESS: 5879 scmd->result = (DID_OK << 16) | scsi_status; 5880 if (response_code == 5881 MPI2_SCSITASKMGMT_RSP_INVALID_FRAME || 5882 (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED | 5883 MPI2_SCSI_STATE_NO_SCSI_STATUS))) 5884 scmd->result = DID_SOFT_ERROR << 16; 5885 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED) 5886 scmd->result = DID_RESET << 16; 5887 break; 5888 5889 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR: 5890 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR: 5891 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR: 5892 _scsih_eedp_error_handling(scmd, ioc_status); 5893 break; 5894 5895 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR: 5896 case MPI2_IOCSTATUS_INVALID_FUNCTION: 5897 case MPI2_IOCSTATUS_INVALID_SGL: 5898 case MPI2_IOCSTATUS_INTERNAL_ERROR: 5899 case MPI2_IOCSTATUS_INVALID_FIELD: 5900 case MPI2_IOCSTATUS_INVALID_STATE: 5901 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR: 5902 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED: 5903 case MPI2_IOCSTATUS_INSUFFICIENT_POWER: 5904 default: 5905 scmd->result = DID_SOFT_ERROR << 16; 5906 break; 5907 5908 } 5909 5910 if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY)) 5911 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid); 5912 5913 out: 5914 5915 scsi_dma_unmap(scmd); 5916 mpt3sas_base_free_smid(ioc, smid); 5917 scsi_done(scmd); 5918 return 0; 5919 } 5920 5921 /** 5922 * _scsih_update_vphys_after_reset - update the Port's 5923 * vphys_list after reset 5924 * @ioc: per adapter object 5925 * 5926 * Returns nothing. 5927 */ 5928 static void 5929 _scsih_update_vphys_after_reset(struct MPT3SAS_ADAPTER *ioc) 5930 { 5931 u16 sz, ioc_status; 5932 int i; 5933 Mpi2ConfigReply_t mpi_reply; 5934 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 5935 u16 attached_handle; 5936 u64 attached_sas_addr; 5937 u8 found = 0, port_id; 5938 Mpi2SasPhyPage0_t phy_pg0; 5939 struct hba_port *port, *port_next, *mport; 5940 struct virtual_phy *vphy, *vphy_next; 5941 struct _sas_device *sas_device; 5942 5943 /* 5944 * Mark all the vphys objects as dirty. 5945 */ 5946 list_for_each_entry_safe(port, port_next, 5947 &ioc->port_table_list, list) { 5948 if (!port->vphys_mask) 5949 continue; 5950 list_for_each_entry_safe(vphy, vphy_next, 5951 &port->vphys_list, list) { 5952 vphy->flags |= MPT_VPHY_FLAG_DIRTY_PHY; 5953 } 5954 } 5955 5956 /* 5957 * Read SASIOUnitPage0 to get each HBA Phy's data. 5958 */ 5959 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys); 5960 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 5961 if (!sas_iounit_pg0) { 5962 ioc_err(ioc, "failure at %s:%d/%s()!\n", 5963 __FILE__, __LINE__, __func__); 5964 return; 5965 } 5966 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 5967 sas_iounit_pg0, sz)) != 0) 5968 goto out; 5969 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 5970 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 5971 goto out; 5972 /* 5973 * Loop over each HBA Phy. 5974 */ 5975 for (i = 0; i < ioc->sas_hba.num_phys; i++) { 5976 /* 5977 * Check whether Phy's Negotiation Link Rate is > 1.5G or not. 5978 */ 5979 if ((sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4) < 5980 MPI2_SAS_NEG_LINK_RATE_1_5) 5981 continue; 5982 /* 5983 * Check whether Phy is connected to SEP device or not, 5984 * if it is SEP device then read the Phy's SASPHYPage0 data to 5985 * determine whether Phy is a virtual Phy or not. if it is 5986 * virtual phy then it is conformed that the attached remote 5987 * device is a HBA's vSES device. 5988 */ 5989 if (!(le32_to_cpu( 5990 sas_iounit_pg0->PhyData[i].ControllerPhyDeviceInfo) & 5991 MPI2_SAS_DEVICE_INFO_SEP)) 5992 continue; 5993 5994 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0, 5995 i))) { 5996 ioc_err(ioc, "failure at %s:%d/%s()!\n", 5997 __FILE__, __LINE__, __func__); 5998 continue; 5999 } 6000 6001 if (!(le32_to_cpu(phy_pg0.PhyInfo) & 6002 MPI2_SAS_PHYINFO_VIRTUAL_PHY)) 6003 continue; 6004 /* 6005 * Get the vSES device's SAS Address. 6006 */ 6007 attached_handle = le16_to_cpu( 6008 sas_iounit_pg0->PhyData[i].AttachedDevHandle); 6009 if (_scsih_get_sas_address(ioc, attached_handle, 6010 &attached_sas_addr) != 0) { 6011 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6012 __FILE__, __LINE__, __func__); 6013 continue; 6014 } 6015 6016 found = 0; 6017 port = port_next = NULL; 6018 /* 6019 * Loop over each virtual_phy object from 6020 * each port's vphys_list. 6021 */ 6022 list_for_each_entry_safe(port, 6023 port_next, &ioc->port_table_list, list) { 6024 if (!port->vphys_mask) 6025 continue; 6026 list_for_each_entry_safe(vphy, vphy_next, 6027 &port->vphys_list, list) { 6028 /* 6029 * Continue with next virtual_phy object 6030 * if the object is not marked as dirty. 6031 */ 6032 if (!(vphy->flags & MPT_VPHY_FLAG_DIRTY_PHY)) 6033 continue; 6034 6035 /* 6036 * Continue with next virtual_phy object 6037 * if the object's SAS Address is not equals 6038 * to current Phy's vSES device SAS Address. 6039 */ 6040 if (vphy->sas_address != attached_sas_addr) 6041 continue; 6042 /* 6043 * Enable current Phy number bit in object's 6044 * phy_mask field. 6045 */ 6046 if (!(vphy->phy_mask & (1 << i))) 6047 vphy->phy_mask = (1 << i); 6048 /* 6049 * Get hba_port object from hba_port table 6050 * corresponding to current phy's Port ID. 6051 * if there is no hba_port object corresponding 6052 * to Phy's Port ID then create a new hba_port 6053 * object & add to hba_port table. 6054 */ 6055 port_id = sas_iounit_pg0->PhyData[i].Port; 6056 mport = mpt3sas_get_port_by_id(ioc, port_id, 1); 6057 if (!mport) { 6058 mport = kzalloc( 6059 sizeof(struct hba_port), GFP_KERNEL); 6060 if (!mport) 6061 break; 6062 mport->port_id = port_id; 6063 ioc_info(ioc, 6064 "%s: hba_port entry: %p, port: %d is added to hba_port list\n", 6065 __func__, mport, mport->port_id); 6066 list_add_tail(&mport->list, 6067 &ioc->port_table_list); 6068 } 6069 /* 6070 * If mport & port pointers are not pointing to 6071 * same hba_port object then it means that vSES 6072 * device's Port ID got changed after reset and 6073 * hence move current virtual_phy object from 6074 * port's vphys_list to mport's vphys_list. 6075 */ 6076 if (port != mport) { 6077 if (!mport->vphys_mask) 6078 INIT_LIST_HEAD( 6079 &mport->vphys_list); 6080 mport->vphys_mask |= (1 << i); 6081 port->vphys_mask &= ~(1 << i); 6082 list_move(&vphy->list, 6083 &mport->vphys_list); 6084 sas_device = mpt3sas_get_sdev_by_addr( 6085 ioc, attached_sas_addr, port); 6086 if (sas_device) 6087 sas_device->port = mport; 6088 } 6089 /* 6090 * Earlier while updating the hba_port table, 6091 * it is determined that there is no other 6092 * direct attached device with mport's Port ID, 6093 * Hence mport was marked as dirty. Only vSES 6094 * device has this Port ID, so unmark the mport 6095 * as dirt. 6096 */ 6097 if (mport->flags & HBA_PORT_FLAG_DIRTY_PORT) { 6098 mport->sas_address = 0; 6099 mport->phy_mask = 0; 6100 mport->flags &= 6101 ~HBA_PORT_FLAG_DIRTY_PORT; 6102 } 6103 /* 6104 * Unmark current virtual_phy object as dirty. 6105 */ 6106 vphy->flags &= ~MPT_VPHY_FLAG_DIRTY_PHY; 6107 found = 1; 6108 break; 6109 } 6110 if (found) 6111 break; 6112 } 6113 } 6114 out: 6115 kfree(sas_iounit_pg0); 6116 } 6117 6118 /** 6119 * _scsih_get_port_table_after_reset - Construct temporary port table 6120 * @ioc: per adapter object 6121 * @port_table: address where port table needs to be constructed 6122 * 6123 * return number of HBA port entries available after reset. 6124 */ 6125 static int 6126 _scsih_get_port_table_after_reset(struct MPT3SAS_ADAPTER *ioc, 6127 struct hba_port *port_table) 6128 { 6129 u16 sz, ioc_status; 6130 int i, j; 6131 Mpi2ConfigReply_t mpi_reply; 6132 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 6133 u16 attached_handle; 6134 u64 attached_sas_addr; 6135 u8 found = 0, port_count = 0, port_id; 6136 6137 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys); 6138 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 6139 if (!sas_iounit_pg0) { 6140 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6141 __FILE__, __LINE__, __func__); 6142 return port_count; 6143 } 6144 6145 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 6146 sas_iounit_pg0, sz)) != 0) 6147 goto out; 6148 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 6149 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 6150 goto out; 6151 for (i = 0; i < ioc->sas_hba.num_phys; i++) { 6152 found = 0; 6153 if ((sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4) < 6154 MPI2_SAS_NEG_LINK_RATE_1_5) 6155 continue; 6156 attached_handle = 6157 le16_to_cpu(sas_iounit_pg0->PhyData[i].AttachedDevHandle); 6158 if (_scsih_get_sas_address( 6159 ioc, attached_handle, &attached_sas_addr) != 0) { 6160 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6161 __FILE__, __LINE__, __func__); 6162 continue; 6163 } 6164 6165 for (j = 0; j < port_count; j++) { 6166 port_id = sas_iounit_pg0->PhyData[i].Port; 6167 if (port_table[j].port_id == port_id && 6168 port_table[j].sas_address == attached_sas_addr) { 6169 port_table[j].phy_mask |= (1 << i); 6170 found = 1; 6171 break; 6172 } 6173 } 6174 6175 if (found) 6176 continue; 6177 6178 port_id = sas_iounit_pg0->PhyData[i].Port; 6179 port_table[port_count].port_id = port_id; 6180 port_table[port_count].phy_mask = (1 << i); 6181 port_table[port_count].sas_address = attached_sas_addr; 6182 port_count++; 6183 } 6184 out: 6185 kfree(sas_iounit_pg0); 6186 return port_count; 6187 } 6188 6189 enum hba_port_matched_codes { 6190 NOT_MATCHED = 0, 6191 MATCHED_WITH_ADDR_AND_PHYMASK, 6192 MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT, 6193 MATCHED_WITH_ADDR_AND_SUBPHYMASK, 6194 MATCHED_WITH_ADDR, 6195 }; 6196 6197 /** 6198 * _scsih_look_and_get_matched_port_entry - Get matched hba port entry 6199 * from HBA port table 6200 * @ioc: per adapter object 6201 * @port_entry: hba port entry from temporary port table which needs to be 6202 * searched for matched entry in the HBA port table 6203 * @matched_port_entry: save matched hba port entry here 6204 * @count: count of matched entries 6205 * 6206 * return type of matched entry found. 6207 */ 6208 static enum hba_port_matched_codes 6209 _scsih_look_and_get_matched_port_entry(struct MPT3SAS_ADAPTER *ioc, 6210 struct hba_port *port_entry, 6211 struct hba_port **matched_port_entry, int *count) 6212 { 6213 struct hba_port *port_table_entry, *matched_port = NULL; 6214 enum hba_port_matched_codes matched_code = NOT_MATCHED; 6215 int lcount = 0; 6216 *matched_port_entry = NULL; 6217 6218 list_for_each_entry(port_table_entry, &ioc->port_table_list, list) { 6219 if (!(port_table_entry->flags & HBA_PORT_FLAG_DIRTY_PORT)) 6220 continue; 6221 6222 if ((port_table_entry->sas_address == port_entry->sas_address) 6223 && (port_table_entry->phy_mask == port_entry->phy_mask)) { 6224 matched_code = MATCHED_WITH_ADDR_AND_PHYMASK; 6225 matched_port = port_table_entry; 6226 break; 6227 } 6228 6229 if ((port_table_entry->sas_address == port_entry->sas_address) 6230 && (port_table_entry->phy_mask & port_entry->phy_mask) 6231 && (port_table_entry->port_id == port_entry->port_id)) { 6232 matched_code = MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT; 6233 matched_port = port_table_entry; 6234 continue; 6235 } 6236 6237 if ((port_table_entry->sas_address == port_entry->sas_address) 6238 && (port_table_entry->phy_mask & port_entry->phy_mask)) { 6239 if (matched_code == 6240 MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT) 6241 continue; 6242 matched_code = MATCHED_WITH_ADDR_AND_SUBPHYMASK; 6243 matched_port = port_table_entry; 6244 continue; 6245 } 6246 6247 if (port_table_entry->sas_address == port_entry->sas_address) { 6248 if (matched_code == 6249 MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT) 6250 continue; 6251 if (matched_code == MATCHED_WITH_ADDR_AND_SUBPHYMASK) 6252 continue; 6253 matched_code = MATCHED_WITH_ADDR; 6254 matched_port = port_table_entry; 6255 lcount++; 6256 } 6257 } 6258 6259 *matched_port_entry = matched_port; 6260 if (matched_code == MATCHED_WITH_ADDR) 6261 *count = lcount; 6262 return matched_code; 6263 } 6264 6265 /** 6266 * _scsih_del_phy_part_of_anther_port - remove phy if it 6267 * is a part of anther port 6268 *@ioc: per adapter object 6269 *@port_table: port table after reset 6270 *@index: hba port entry index 6271 *@port_count: number of ports available after host reset 6272 *@offset: HBA phy bit offset 6273 * 6274 */ 6275 static void 6276 _scsih_del_phy_part_of_anther_port(struct MPT3SAS_ADAPTER *ioc, 6277 struct hba_port *port_table, 6278 int index, u8 port_count, int offset) 6279 { 6280 struct _sas_node *sas_node = &ioc->sas_hba; 6281 u32 i, found = 0; 6282 6283 for (i = 0; i < port_count; i++) { 6284 if (i == index) 6285 continue; 6286 6287 if (port_table[i].phy_mask & (1 << offset)) { 6288 mpt3sas_transport_del_phy_from_an_existing_port( 6289 ioc, sas_node, &sas_node->phy[offset]); 6290 found = 1; 6291 break; 6292 } 6293 } 6294 if (!found) 6295 port_table[index].phy_mask |= (1 << offset); 6296 } 6297 6298 /** 6299 * _scsih_add_or_del_phys_from_existing_port - add/remove phy to/from 6300 * right port 6301 *@ioc: per adapter object 6302 *@hba_port_entry: hba port table entry 6303 *@port_table: temporary port table 6304 *@index: hba port entry index 6305 *@port_count: number of ports available after host reset 6306 * 6307 */ 6308 static void 6309 _scsih_add_or_del_phys_from_existing_port(struct MPT3SAS_ADAPTER *ioc, 6310 struct hba_port *hba_port_entry, struct hba_port *port_table, 6311 int index, int port_count) 6312 { 6313 u32 phy_mask, offset = 0; 6314 struct _sas_node *sas_node = &ioc->sas_hba; 6315 6316 phy_mask = hba_port_entry->phy_mask ^ port_table[index].phy_mask; 6317 6318 for (offset = 0; offset < ioc->sas_hba.num_phys; offset++) { 6319 if (phy_mask & (1 << offset)) { 6320 if (!(port_table[index].phy_mask & (1 << offset))) { 6321 _scsih_del_phy_part_of_anther_port( 6322 ioc, port_table, index, port_count, 6323 offset); 6324 continue; 6325 } 6326 if (sas_node->phy[offset].phy_belongs_to_port) 6327 mpt3sas_transport_del_phy_from_an_existing_port( 6328 ioc, sas_node, &sas_node->phy[offset]); 6329 mpt3sas_transport_add_phy_to_an_existing_port( 6330 ioc, sas_node, &sas_node->phy[offset], 6331 hba_port_entry->sas_address, 6332 hba_port_entry); 6333 } 6334 } 6335 } 6336 6337 /** 6338 * _scsih_del_dirty_vphy - delete virtual_phy objects marked as dirty. 6339 * @ioc: per adapter object 6340 * 6341 * Returns nothing. 6342 */ 6343 static void 6344 _scsih_del_dirty_vphy(struct MPT3SAS_ADAPTER *ioc) 6345 { 6346 struct hba_port *port, *port_next; 6347 struct virtual_phy *vphy, *vphy_next; 6348 6349 list_for_each_entry_safe(port, port_next, 6350 &ioc->port_table_list, list) { 6351 if (!port->vphys_mask) 6352 continue; 6353 list_for_each_entry_safe(vphy, vphy_next, 6354 &port->vphys_list, list) { 6355 if (vphy->flags & MPT_VPHY_FLAG_DIRTY_PHY) { 6356 drsprintk(ioc, ioc_info(ioc, 6357 "Deleting vphy %p entry from port id: %d\t, Phy_mask 0x%08x\n", 6358 vphy, port->port_id, 6359 vphy->phy_mask)); 6360 port->vphys_mask &= ~vphy->phy_mask; 6361 list_del(&vphy->list); 6362 kfree(vphy); 6363 } 6364 } 6365 if (!port->vphys_mask && !port->sas_address) 6366 port->flags |= HBA_PORT_FLAG_DIRTY_PORT; 6367 } 6368 } 6369 6370 /** 6371 * _scsih_del_dirty_port_entries - delete dirty port entries from port list 6372 * after host reset 6373 *@ioc: per adapter object 6374 * 6375 */ 6376 static void 6377 _scsih_del_dirty_port_entries(struct MPT3SAS_ADAPTER *ioc) 6378 { 6379 struct hba_port *port, *port_next; 6380 6381 list_for_each_entry_safe(port, port_next, 6382 &ioc->port_table_list, list) { 6383 if (!(port->flags & HBA_PORT_FLAG_DIRTY_PORT) || 6384 port->flags & HBA_PORT_FLAG_NEW_PORT) 6385 continue; 6386 6387 drsprintk(ioc, ioc_info(ioc, 6388 "Deleting port table entry %p having Port: %d\t Phy_mask 0x%08x\n", 6389 port, port->port_id, port->phy_mask)); 6390 list_del(&port->list); 6391 kfree(port); 6392 } 6393 } 6394 6395 /** 6396 * _scsih_sas_port_refresh - Update HBA port table after host reset 6397 * @ioc: per adapter object 6398 */ 6399 static void 6400 _scsih_sas_port_refresh(struct MPT3SAS_ADAPTER *ioc) 6401 { 6402 u32 port_count = 0; 6403 struct hba_port *port_table; 6404 struct hba_port *port_table_entry; 6405 struct hba_port *port_entry = NULL; 6406 int i, j, count = 0, lcount = 0; 6407 int ret; 6408 u64 sas_addr; 6409 u8 num_phys; 6410 6411 drsprintk(ioc, ioc_info(ioc, 6412 "updating ports for sas_host(0x%016llx)\n", 6413 (unsigned long long)ioc->sas_hba.sas_address)); 6414 6415 mpt3sas_config_get_number_hba_phys(ioc, &num_phys); 6416 if (!num_phys) { 6417 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6418 __FILE__, __LINE__, __func__); 6419 return; 6420 } 6421 6422 if (num_phys > ioc->sas_hba.nr_phys_allocated) { 6423 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6424 __FILE__, __LINE__, __func__); 6425 return; 6426 } 6427 ioc->sas_hba.num_phys = num_phys; 6428 6429 port_table = kcalloc(ioc->sas_hba.num_phys, 6430 sizeof(struct hba_port), GFP_KERNEL); 6431 if (!port_table) 6432 return; 6433 6434 port_count = _scsih_get_port_table_after_reset(ioc, port_table); 6435 if (!port_count) 6436 return; 6437 6438 drsprintk(ioc, ioc_info(ioc, "New Port table\n")); 6439 for (j = 0; j < port_count; j++) 6440 drsprintk(ioc, ioc_info(ioc, 6441 "Port: %d\t Phy_mask 0x%08x\t sas_addr(0x%016llx)\n", 6442 port_table[j].port_id, 6443 port_table[j].phy_mask, port_table[j].sas_address)); 6444 6445 list_for_each_entry(port_table_entry, &ioc->port_table_list, list) 6446 port_table_entry->flags |= HBA_PORT_FLAG_DIRTY_PORT; 6447 6448 drsprintk(ioc, ioc_info(ioc, "Old Port table\n")); 6449 port_table_entry = NULL; 6450 list_for_each_entry(port_table_entry, &ioc->port_table_list, list) { 6451 drsprintk(ioc, ioc_info(ioc, 6452 "Port: %d\t Phy_mask 0x%08x\t sas_addr(0x%016llx)\n", 6453 port_table_entry->port_id, 6454 port_table_entry->phy_mask, 6455 port_table_entry->sas_address)); 6456 } 6457 6458 for (j = 0; j < port_count; j++) { 6459 ret = _scsih_look_and_get_matched_port_entry(ioc, 6460 &port_table[j], &port_entry, &count); 6461 if (!port_entry) { 6462 drsprintk(ioc, ioc_info(ioc, 6463 "No Matched entry for sas_addr(0x%16llx), Port:%d\n", 6464 port_table[j].sas_address, 6465 port_table[j].port_id)); 6466 continue; 6467 } 6468 6469 switch (ret) { 6470 case MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT: 6471 case MATCHED_WITH_ADDR_AND_SUBPHYMASK: 6472 _scsih_add_or_del_phys_from_existing_port(ioc, 6473 port_entry, port_table, j, port_count); 6474 break; 6475 case MATCHED_WITH_ADDR: 6476 sas_addr = port_table[j].sas_address; 6477 for (i = 0; i < port_count; i++) { 6478 if (port_table[i].sas_address == sas_addr) 6479 lcount++; 6480 } 6481 6482 if (count > 1 || lcount > 1) 6483 port_entry = NULL; 6484 else 6485 _scsih_add_or_del_phys_from_existing_port(ioc, 6486 port_entry, port_table, j, port_count); 6487 } 6488 6489 if (!port_entry) 6490 continue; 6491 6492 if (port_entry->port_id != port_table[j].port_id) 6493 port_entry->port_id = port_table[j].port_id; 6494 port_entry->flags &= ~HBA_PORT_FLAG_DIRTY_PORT; 6495 port_entry->phy_mask = port_table[j].phy_mask; 6496 } 6497 6498 port_table_entry = NULL; 6499 } 6500 6501 /** 6502 * _scsih_alloc_vphy - allocate virtual_phy object 6503 * @ioc: per adapter object 6504 * @port_id: Port ID number 6505 * @phy_num: HBA Phy number 6506 * 6507 * Returns allocated virtual_phy object. 6508 */ 6509 static struct virtual_phy * 6510 _scsih_alloc_vphy(struct MPT3SAS_ADAPTER *ioc, u8 port_id, u8 phy_num) 6511 { 6512 struct virtual_phy *vphy; 6513 struct hba_port *port; 6514 6515 port = mpt3sas_get_port_by_id(ioc, port_id, 0); 6516 if (!port) 6517 return NULL; 6518 6519 vphy = mpt3sas_get_vphy_by_phy(ioc, port, phy_num); 6520 if (!vphy) { 6521 vphy = kzalloc(sizeof(struct virtual_phy), GFP_KERNEL); 6522 if (!vphy) 6523 return NULL; 6524 6525 if (!port->vphys_mask) 6526 INIT_LIST_HEAD(&port->vphys_list); 6527 6528 /* 6529 * Enable bit corresponding to HBA phy number on its 6530 * parent hba_port object's vphys_mask field. 6531 */ 6532 port->vphys_mask |= (1 << phy_num); 6533 vphy->phy_mask |= (1 << phy_num); 6534 6535 list_add_tail(&vphy->list, &port->vphys_list); 6536 6537 ioc_info(ioc, 6538 "vphy entry: %p, port id: %d, phy:%d is added to port's vphys_list\n", 6539 vphy, port->port_id, phy_num); 6540 } 6541 return vphy; 6542 } 6543 6544 /** 6545 * _scsih_sas_host_refresh - refreshing sas host object contents 6546 * @ioc: per adapter object 6547 * Context: user 6548 * 6549 * During port enable, fw will send topology events for every device. Its 6550 * possible that the handles may change from the previous setting, so this 6551 * code keeping handles updating if changed. 6552 */ 6553 static void 6554 _scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc) 6555 { 6556 u16 sz; 6557 u16 ioc_status; 6558 int i; 6559 Mpi2ConfigReply_t mpi_reply; 6560 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 6561 u16 attached_handle; 6562 u8 link_rate, port_id; 6563 struct hba_port *port; 6564 Mpi2SasPhyPage0_t phy_pg0; 6565 6566 dtmprintk(ioc, 6567 ioc_info(ioc, "updating handles for sas_host(0x%016llx)\n", 6568 (u64)ioc->sas_hba.sas_address)); 6569 6570 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys); 6571 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 6572 if (!sas_iounit_pg0) { 6573 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6574 __FILE__, __LINE__, __func__); 6575 return; 6576 } 6577 6578 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 6579 sas_iounit_pg0, sz)) != 0) 6580 goto out; 6581 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 6582 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 6583 goto out; 6584 for (i = 0; i < ioc->sas_hba.num_phys ; i++) { 6585 link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4; 6586 if (i == 0) 6587 ioc->sas_hba.handle = le16_to_cpu( 6588 sas_iounit_pg0->PhyData[0].ControllerDevHandle); 6589 port_id = sas_iounit_pg0->PhyData[i].Port; 6590 if (!(mpt3sas_get_port_by_id(ioc, port_id, 0))) { 6591 port = kzalloc(sizeof(struct hba_port), GFP_KERNEL); 6592 if (!port) 6593 goto out; 6594 6595 port->port_id = port_id; 6596 ioc_info(ioc, 6597 "hba_port entry: %p, port: %d is added to hba_port list\n", 6598 port, port->port_id); 6599 if (ioc->shost_recovery) 6600 port->flags = HBA_PORT_FLAG_NEW_PORT; 6601 list_add_tail(&port->list, &ioc->port_table_list); 6602 } 6603 /* 6604 * Check whether current Phy belongs to HBA vSES device or not. 6605 */ 6606 if (le32_to_cpu(sas_iounit_pg0->PhyData[i].ControllerPhyDeviceInfo) & 6607 MPI2_SAS_DEVICE_INFO_SEP && 6608 (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5)) { 6609 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, 6610 &phy_pg0, i))) { 6611 ioc_err(ioc, 6612 "failure at %s:%d/%s()!\n", 6613 __FILE__, __LINE__, __func__); 6614 goto out; 6615 } 6616 if (!(le32_to_cpu(phy_pg0.PhyInfo) & 6617 MPI2_SAS_PHYINFO_VIRTUAL_PHY)) 6618 continue; 6619 /* 6620 * Allocate a virtual_phy object for vSES device, if 6621 * this vSES device is hot added. 6622 */ 6623 if (!_scsih_alloc_vphy(ioc, port_id, i)) 6624 goto out; 6625 ioc->sas_hba.phy[i].hba_vphy = 1; 6626 } 6627 6628 /* 6629 * Add new HBA phys to STL if these new phys got added as part 6630 * of HBA Firmware upgrade/downgrade operation. 6631 */ 6632 if (!ioc->sas_hba.phy[i].phy) { 6633 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, 6634 &phy_pg0, i))) { 6635 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6636 __FILE__, __LINE__, __func__); 6637 continue; 6638 } 6639 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 6640 MPI2_IOCSTATUS_MASK; 6641 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6642 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6643 __FILE__, __LINE__, __func__); 6644 continue; 6645 } 6646 ioc->sas_hba.phy[i].phy_id = i; 6647 mpt3sas_transport_add_host_phy(ioc, 6648 &ioc->sas_hba.phy[i], phy_pg0, 6649 ioc->sas_hba.parent_dev); 6650 continue; 6651 } 6652 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle; 6653 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i]. 6654 AttachedDevHandle); 6655 if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5) 6656 link_rate = MPI2_SAS_NEG_LINK_RATE_1_5; 6657 ioc->sas_hba.phy[i].port = 6658 mpt3sas_get_port_by_id(ioc, port_id, 0); 6659 mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address, 6660 attached_handle, i, link_rate, 6661 ioc->sas_hba.phy[i].port); 6662 } 6663 /* 6664 * Clear the phy details if this phy got disabled as part of 6665 * HBA Firmware upgrade/downgrade operation. 6666 */ 6667 for (i = ioc->sas_hba.num_phys; 6668 i < ioc->sas_hba.nr_phys_allocated; i++) { 6669 if (ioc->sas_hba.phy[i].phy && 6670 ioc->sas_hba.phy[i].phy->negotiated_linkrate >= 6671 SAS_LINK_RATE_1_5_GBPS) 6672 mpt3sas_transport_update_links(ioc, 6673 ioc->sas_hba.sas_address, 0, i, 6674 MPI2_SAS_NEG_LINK_RATE_PHY_DISABLED, NULL); 6675 } 6676 out: 6677 kfree(sas_iounit_pg0); 6678 } 6679 6680 /** 6681 * _scsih_sas_host_add - create sas host object 6682 * @ioc: per adapter object 6683 * 6684 * Creating host side data object, stored in ioc->sas_hba 6685 */ 6686 static void 6687 _scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc) 6688 { 6689 int i; 6690 Mpi2ConfigReply_t mpi_reply; 6691 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 6692 Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL; 6693 Mpi2SasPhyPage0_t phy_pg0; 6694 Mpi2SasDevicePage0_t sas_device_pg0; 6695 Mpi2SasEnclosurePage0_t enclosure_pg0; 6696 u16 ioc_status; 6697 u16 sz; 6698 u8 device_missing_delay; 6699 u8 num_phys, port_id; 6700 struct hba_port *port; 6701 6702 mpt3sas_config_get_number_hba_phys(ioc, &num_phys); 6703 if (!num_phys) { 6704 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6705 __FILE__, __LINE__, __func__); 6706 return; 6707 } 6708 6709 ioc->sas_hba.nr_phys_allocated = max_t(u8, 6710 MPT_MAX_HBA_NUM_PHYS, num_phys); 6711 ioc->sas_hba.phy = kcalloc(ioc->sas_hba.nr_phys_allocated, 6712 sizeof(struct _sas_phy), GFP_KERNEL); 6713 if (!ioc->sas_hba.phy) { 6714 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6715 __FILE__, __LINE__, __func__); 6716 goto out; 6717 } 6718 ioc->sas_hba.num_phys = num_phys; 6719 6720 /* sas_iounit page 0 */ 6721 sz = struct_size(sas_iounit_pg0, PhyData, ioc->sas_hba.num_phys); 6722 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 6723 if (!sas_iounit_pg0) { 6724 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6725 __FILE__, __LINE__, __func__); 6726 return; 6727 } 6728 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 6729 sas_iounit_pg0, sz))) { 6730 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6731 __FILE__, __LINE__, __func__); 6732 goto out; 6733 } 6734 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 6735 MPI2_IOCSTATUS_MASK; 6736 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6737 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6738 __FILE__, __LINE__, __func__); 6739 goto out; 6740 } 6741 6742 /* sas_iounit page 1 */ 6743 sz = struct_size(sas_iounit_pg1, PhyData, ioc->sas_hba.num_phys); 6744 sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL); 6745 if (!sas_iounit_pg1) { 6746 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6747 __FILE__, __LINE__, __func__); 6748 goto out; 6749 } 6750 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply, 6751 sas_iounit_pg1, sz))) { 6752 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6753 __FILE__, __LINE__, __func__); 6754 goto out; 6755 } 6756 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 6757 MPI2_IOCSTATUS_MASK; 6758 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6759 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6760 __FILE__, __LINE__, __func__); 6761 goto out; 6762 } 6763 6764 ioc->io_missing_delay = 6765 sas_iounit_pg1->IODeviceMissingDelay; 6766 device_missing_delay = 6767 sas_iounit_pg1->ReportDeviceMissingDelay; 6768 if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16) 6769 ioc->device_missing_delay = (device_missing_delay & 6770 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16; 6771 else 6772 ioc->device_missing_delay = device_missing_delay & 6773 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK; 6774 6775 ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev; 6776 for (i = 0; i < ioc->sas_hba.num_phys ; i++) { 6777 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0, 6778 i))) { 6779 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6780 __FILE__, __LINE__, __func__); 6781 goto out; 6782 } 6783 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 6784 MPI2_IOCSTATUS_MASK; 6785 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6786 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6787 __FILE__, __LINE__, __func__); 6788 goto out; 6789 } 6790 6791 if (i == 0) 6792 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0-> 6793 PhyData[0].ControllerDevHandle); 6794 6795 port_id = sas_iounit_pg0->PhyData[i].Port; 6796 if (!(mpt3sas_get_port_by_id(ioc, port_id, 0))) { 6797 port = kzalloc(sizeof(struct hba_port), GFP_KERNEL); 6798 if (!port) 6799 goto out; 6800 6801 port->port_id = port_id; 6802 ioc_info(ioc, 6803 "hba_port entry: %p, port: %d is added to hba_port list\n", 6804 port, port->port_id); 6805 list_add_tail(&port->list, 6806 &ioc->port_table_list); 6807 } 6808 6809 /* 6810 * Check whether current Phy belongs to HBA vSES device or not. 6811 */ 6812 if ((le32_to_cpu(phy_pg0.PhyInfo) & 6813 MPI2_SAS_PHYINFO_VIRTUAL_PHY) && 6814 (phy_pg0.NegotiatedLinkRate >> 4) >= 6815 MPI2_SAS_NEG_LINK_RATE_1_5) { 6816 /* 6817 * Allocate a virtual_phy object for vSES device. 6818 */ 6819 if (!_scsih_alloc_vphy(ioc, port_id, i)) 6820 goto out; 6821 ioc->sas_hba.phy[i].hba_vphy = 1; 6822 } 6823 6824 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle; 6825 ioc->sas_hba.phy[i].phy_id = i; 6826 ioc->sas_hba.phy[i].port = 6827 mpt3sas_get_port_by_id(ioc, port_id, 0); 6828 mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i], 6829 phy_pg0, ioc->sas_hba.parent_dev); 6830 } 6831 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 6832 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) { 6833 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6834 __FILE__, __LINE__, __func__); 6835 goto out; 6836 } 6837 ioc->sas_hba.enclosure_handle = 6838 le16_to_cpu(sas_device_pg0.EnclosureHandle); 6839 ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 6840 ioc_info(ioc, "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n", 6841 ioc->sas_hba.handle, 6842 (u64)ioc->sas_hba.sas_address, 6843 ioc->sas_hba.num_phys); 6844 6845 if (ioc->sas_hba.enclosure_handle) { 6846 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply, 6847 &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE, 6848 ioc->sas_hba.enclosure_handle))) 6849 ioc->sas_hba.enclosure_logical_id = 6850 le64_to_cpu(enclosure_pg0.EnclosureLogicalID); 6851 } 6852 6853 out: 6854 kfree(sas_iounit_pg1); 6855 kfree(sas_iounit_pg0); 6856 } 6857 6858 /** 6859 * _scsih_expander_add - creating expander object 6860 * @ioc: per adapter object 6861 * @handle: expander handle 6862 * 6863 * Creating expander object, stored in ioc->sas_expander_list. 6864 * 6865 * Return: 0 for success, else error. 6866 */ 6867 static int 6868 _scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle) 6869 { 6870 struct _sas_node *sas_expander; 6871 struct _enclosure_node *enclosure_dev; 6872 Mpi2ConfigReply_t mpi_reply; 6873 Mpi2ExpanderPage0_t expander_pg0; 6874 Mpi2ExpanderPage1_t expander_pg1; 6875 u32 ioc_status; 6876 u16 parent_handle; 6877 u64 sas_address, sas_address_parent = 0; 6878 int i; 6879 unsigned long flags; 6880 struct _sas_port *mpt3sas_port = NULL; 6881 u8 port_id; 6882 6883 int rc = 0; 6884 6885 if (!handle) 6886 return -1; 6887 6888 if (ioc->shost_recovery || ioc->pci_error_recovery) 6889 return -1; 6890 6891 if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0, 6892 MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) { 6893 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6894 __FILE__, __LINE__, __func__); 6895 return -1; 6896 } 6897 6898 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 6899 MPI2_IOCSTATUS_MASK; 6900 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6901 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6902 __FILE__, __LINE__, __func__); 6903 return -1; 6904 } 6905 6906 /* handle out of order topology events */ 6907 parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle); 6908 if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent) 6909 != 0) { 6910 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6911 __FILE__, __LINE__, __func__); 6912 return -1; 6913 } 6914 6915 port_id = expander_pg0.PhysicalPort; 6916 if (sas_address_parent != ioc->sas_hba.sas_address) { 6917 spin_lock_irqsave(&ioc->sas_node_lock, flags); 6918 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 6919 sas_address_parent, 6920 mpt3sas_get_port_by_id(ioc, port_id, 0)); 6921 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 6922 if (!sas_expander) { 6923 rc = _scsih_expander_add(ioc, parent_handle); 6924 if (rc != 0) 6925 return rc; 6926 } 6927 } 6928 6929 spin_lock_irqsave(&ioc->sas_node_lock, flags); 6930 sas_address = le64_to_cpu(expander_pg0.SASAddress); 6931 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 6932 sas_address, mpt3sas_get_port_by_id(ioc, port_id, 0)); 6933 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 6934 6935 if (sas_expander) 6936 return 0; 6937 6938 sas_expander = kzalloc(sizeof(struct _sas_node), 6939 GFP_KERNEL); 6940 if (!sas_expander) { 6941 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6942 __FILE__, __LINE__, __func__); 6943 return -1; 6944 } 6945 6946 sas_expander->handle = handle; 6947 sas_expander->num_phys = expander_pg0.NumPhys; 6948 sas_expander->sas_address_parent = sas_address_parent; 6949 sas_expander->sas_address = sas_address; 6950 sas_expander->port = mpt3sas_get_port_by_id(ioc, port_id, 0); 6951 if (!sas_expander->port) { 6952 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6953 __FILE__, __LINE__, __func__); 6954 rc = -1; 6955 goto out_fail; 6956 } 6957 6958 ioc_info(ioc, "expander_add: handle(0x%04x), parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", 6959 handle, parent_handle, 6960 (u64)sas_expander->sas_address, sas_expander->num_phys); 6961 6962 if (!sas_expander->num_phys) { 6963 rc = -1; 6964 goto out_fail; 6965 } 6966 sas_expander->phy = kcalloc(sas_expander->num_phys, 6967 sizeof(struct _sas_phy), GFP_KERNEL); 6968 if (!sas_expander->phy) { 6969 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6970 __FILE__, __LINE__, __func__); 6971 rc = -1; 6972 goto out_fail; 6973 } 6974 6975 INIT_LIST_HEAD(&sas_expander->sas_port_list); 6976 mpt3sas_port = mpt3sas_transport_port_add(ioc, handle, 6977 sas_address_parent, sas_expander->port); 6978 if (!mpt3sas_port) { 6979 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6980 __FILE__, __LINE__, __func__); 6981 rc = -1; 6982 goto out_fail; 6983 } 6984 sas_expander->parent_dev = &mpt3sas_port->rphy->dev; 6985 sas_expander->rphy = mpt3sas_port->rphy; 6986 6987 for (i = 0 ; i < sas_expander->num_phys ; i++) { 6988 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply, 6989 &expander_pg1, i, handle))) { 6990 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6991 __FILE__, __LINE__, __func__); 6992 rc = -1; 6993 goto out_fail; 6994 } 6995 sas_expander->phy[i].handle = handle; 6996 sas_expander->phy[i].phy_id = i; 6997 sas_expander->phy[i].port = 6998 mpt3sas_get_port_by_id(ioc, port_id, 0); 6999 7000 if ((mpt3sas_transport_add_expander_phy(ioc, 7001 &sas_expander->phy[i], expander_pg1, 7002 sas_expander->parent_dev))) { 7003 ioc_err(ioc, "failure at %s:%d/%s()!\n", 7004 __FILE__, __LINE__, __func__); 7005 rc = -1; 7006 goto out_fail; 7007 } 7008 } 7009 7010 if (sas_expander->enclosure_handle) { 7011 enclosure_dev = 7012 mpt3sas_scsih_enclosure_find_by_handle(ioc, 7013 sas_expander->enclosure_handle); 7014 if (enclosure_dev) 7015 sas_expander->enclosure_logical_id = 7016 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID); 7017 } 7018 7019 _scsih_expander_node_add(ioc, sas_expander); 7020 return 0; 7021 7022 out_fail: 7023 7024 if (mpt3sas_port) 7025 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address, 7026 sas_address_parent, sas_expander->port); 7027 kfree(sas_expander); 7028 return rc; 7029 } 7030 7031 /** 7032 * mpt3sas_expander_remove - removing expander object 7033 * @ioc: per adapter object 7034 * @sas_address: expander sas_address 7035 * @port: hba port entry 7036 */ 7037 void 7038 mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address, 7039 struct hba_port *port) 7040 { 7041 struct _sas_node *sas_expander; 7042 unsigned long flags; 7043 7044 if (ioc->shost_recovery) 7045 return; 7046 7047 if (!port) 7048 return; 7049 7050 spin_lock_irqsave(&ioc->sas_node_lock, flags); 7051 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 7052 sas_address, port); 7053 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 7054 if (sas_expander) 7055 _scsih_expander_node_remove(ioc, sas_expander); 7056 } 7057 7058 /** 7059 * _scsih_done - internal SCSI_IO callback handler. 7060 * @ioc: per adapter object 7061 * @smid: system request message index 7062 * @msix_index: MSIX table index supplied by the OS 7063 * @reply: reply message frame(lower 32bit addr) 7064 * 7065 * Callback handler when sending internal generated SCSI_IO. 7066 * The callback index passed is `ioc->scsih_cb_idx` 7067 * 7068 * Return: 1 meaning mf should be freed from _base_interrupt 7069 * 0 means the mf is freed from this function. 7070 */ 7071 static u8 7072 _scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply) 7073 { 7074 MPI2DefaultReply_t *mpi_reply; 7075 7076 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 7077 if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED) 7078 return 1; 7079 if (ioc->scsih_cmds.smid != smid) 7080 return 1; 7081 ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE; 7082 if (mpi_reply) { 7083 memcpy(ioc->scsih_cmds.reply, mpi_reply, 7084 mpi_reply->MsgLength*4); 7085 ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID; 7086 } 7087 ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING; 7088 complete(&ioc->scsih_cmds.done); 7089 return 1; 7090 } 7091 7092 7093 7094 7095 #define MPT3_MAX_LUNS (255) 7096 7097 7098 /** 7099 * _scsih_check_access_status - check access flags 7100 * @ioc: per adapter object 7101 * @sas_address: sas address 7102 * @handle: sas device handle 7103 * @access_status: errors returned during discovery of the device 7104 * 7105 * Return: 0 for success, else failure 7106 */ 7107 static u8 7108 _scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address, 7109 u16 handle, u8 access_status) 7110 { 7111 u8 rc = 1; 7112 char *desc = NULL; 7113 7114 switch (access_status) { 7115 case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS: 7116 case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION: 7117 rc = 0; 7118 break; 7119 case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED: 7120 desc = "sata capability failed"; 7121 break; 7122 case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT: 7123 desc = "sata affiliation conflict"; 7124 break; 7125 case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE: 7126 desc = "route not addressable"; 7127 break; 7128 case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE: 7129 desc = "smp error not addressable"; 7130 break; 7131 case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED: 7132 desc = "device blocked"; 7133 break; 7134 case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED: 7135 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN: 7136 case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT: 7137 case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG: 7138 case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION: 7139 case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER: 7140 case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN: 7141 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN: 7142 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN: 7143 case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION: 7144 case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE: 7145 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX: 7146 desc = "sata initialization failed"; 7147 break; 7148 default: 7149 desc = "unknown"; 7150 break; 7151 } 7152 7153 if (!rc) 7154 return 0; 7155 7156 ioc_err(ioc, "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n", 7157 desc, (u64)sas_address, handle); 7158 return rc; 7159 } 7160 7161 /** 7162 * _scsih_check_device - checking device responsiveness 7163 * @ioc: per adapter object 7164 * @parent_sas_address: sas address of parent expander or sas host 7165 * @handle: attached device handle 7166 * @phy_number: phy number 7167 * @link_rate: new link rate 7168 */ 7169 static void 7170 _scsih_check_device(struct MPT3SAS_ADAPTER *ioc, 7171 u64 parent_sas_address, u16 handle, u8 phy_number, u8 link_rate) 7172 { 7173 Mpi2ConfigReply_t mpi_reply; 7174 Mpi2SasDevicePage0_t sas_device_pg0; 7175 struct _sas_device *sas_device = NULL; 7176 struct _enclosure_node *enclosure_dev = NULL; 7177 u32 ioc_status; 7178 unsigned long flags; 7179 u64 sas_address; 7180 struct scsi_target *starget; 7181 struct MPT3SAS_TARGET *sas_target_priv_data; 7182 u32 device_info; 7183 struct hba_port *port; 7184 7185 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 7186 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) 7187 return; 7188 7189 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 7190 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 7191 return; 7192 7193 /* wide port handling ~ we need only handle device once for the phy that 7194 * is matched in sas device page zero 7195 */ 7196 if (phy_number != sas_device_pg0.PhyNum) 7197 return; 7198 7199 /* check if this is end device */ 7200 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 7201 if (!(_scsih_is_end_device(device_info))) 7202 return; 7203 7204 spin_lock_irqsave(&ioc->sas_device_lock, flags); 7205 sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 7206 port = mpt3sas_get_port_by_id(ioc, sas_device_pg0.PhysicalPort, 0); 7207 if (!port) 7208 goto out_unlock; 7209 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 7210 sas_address, port); 7211 7212 if (!sas_device) 7213 goto out_unlock; 7214 7215 if (unlikely(sas_device->handle != handle)) { 7216 starget = sas_device->starget; 7217 sas_target_priv_data = starget->hostdata; 7218 starget_printk(KERN_INFO, starget, 7219 "handle changed from(0x%04x) to (0x%04x)!!!\n", 7220 sas_device->handle, handle); 7221 sas_target_priv_data->handle = handle; 7222 sas_device->handle = handle; 7223 if (le16_to_cpu(sas_device_pg0.Flags) & 7224 MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) { 7225 sas_device->enclosure_level = 7226 sas_device_pg0.EnclosureLevel; 7227 memcpy(sas_device->connector_name, 7228 sas_device_pg0.ConnectorName, 4); 7229 sas_device->connector_name[4] = '\0'; 7230 } else { 7231 sas_device->enclosure_level = 0; 7232 sas_device->connector_name[0] = '\0'; 7233 } 7234 7235 sas_device->enclosure_handle = 7236 le16_to_cpu(sas_device_pg0.EnclosureHandle); 7237 sas_device->is_chassis_slot_valid = 0; 7238 enclosure_dev = mpt3sas_scsih_enclosure_find_by_handle(ioc, 7239 sas_device->enclosure_handle); 7240 if (enclosure_dev) { 7241 sas_device->enclosure_logical_id = 7242 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID); 7243 if (le16_to_cpu(enclosure_dev->pg0.Flags) & 7244 MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) { 7245 sas_device->is_chassis_slot_valid = 1; 7246 sas_device->chassis_slot = 7247 enclosure_dev->pg0.ChassisSlot; 7248 } 7249 } 7250 } 7251 7252 /* check if device is present */ 7253 if (!(le16_to_cpu(sas_device_pg0.Flags) & 7254 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) { 7255 ioc_err(ioc, "device is not present handle(0x%04x), flags!!!\n", 7256 handle); 7257 goto out_unlock; 7258 } 7259 7260 /* check if there were any issues with discovery */ 7261 if (_scsih_check_access_status(ioc, sas_address, handle, 7262 sas_device_pg0.AccessStatus)) 7263 goto out_unlock; 7264 7265 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 7266 _scsih_ublock_io_device(ioc, sas_address, port); 7267 7268 if (sas_device) 7269 sas_device_put(sas_device); 7270 return; 7271 7272 out_unlock: 7273 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 7274 if (sas_device) 7275 sas_device_put(sas_device); 7276 } 7277 7278 /** 7279 * _scsih_add_device - creating sas device object 7280 * @ioc: per adapter object 7281 * @handle: sas device handle 7282 * @phy_num: phy number end device attached to 7283 * @is_pd: is this hidden raid component 7284 * 7285 * Creating end device object, stored in ioc->sas_device_list. 7286 * 7287 * Return: 0 for success, non-zero for failure. 7288 */ 7289 static int 7290 _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num, 7291 u8 is_pd) 7292 { 7293 Mpi2ConfigReply_t mpi_reply; 7294 Mpi2SasDevicePage0_t sas_device_pg0; 7295 struct _sas_device *sas_device; 7296 struct _enclosure_node *enclosure_dev = NULL; 7297 u32 ioc_status; 7298 u64 sas_address; 7299 u32 device_info; 7300 u8 port_id; 7301 7302 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 7303 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) { 7304 ioc_err(ioc, "failure at %s:%d/%s()!\n", 7305 __FILE__, __LINE__, __func__); 7306 return -1; 7307 } 7308 7309 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7310 MPI2_IOCSTATUS_MASK; 7311 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 7312 ioc_err(ioc, "failure at %s:%d/%s()!\n", 7313 __FILE__, __LINE__, __func__); 7314 return -1; 7315 } 7316 7317 /* check if this is end device */ 7318 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 7319 if (!(_scsih_is_end_device(device_info))) 7320 return -1; 7321 set_bit(handle, ioc->pend_os_device_add); 7322 sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 7323 7324 /* check if device is present */ 7325 if (!(le16_to_cpu(sas_device_pg0.Flags) & 7326 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) { 7327 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n", 7328 handle); 7329 return -1; 7330 } 7331 7332 /* check if there were any issues with discovery */ 7333 if (_scsih_check_access_status(ioc, sas_address, handle, 7334 sas_device_pg0.AccessStatus)) 7335 return -1; 7336 7337 port_id = sas_device_pg0.PhysicalPort; 7338 sas_device = mpt3sas_get_sdev_by_addr(ioc, 7339 sas_address, mpt3sas_get_port_by_id(ioc, port_id, 0)); 7340 if (sas_device) { 7341 clear_bit(handle, ioc->pend_os_device_add); 7342 sas_device_put(sas_device); 7343 return -1; 7344 } 7345 7346 if (sas_device_pg0.EnclosureHandle) { 7347 enclosure_dev = 7348 mpt3sas_scsih_enclosure_find_by_handle(ioc, 7349 le16_to_cpu(sas_device_pg0.EnclosureHandle)); 7350 if (enclosure_dev == NULL) 7351 ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n", 7352 sas_device_pg0.EnclosureHandle); 7353 } 7354 7355 sas_device = kzalloc(sizeof(struct _sas_device), 7356 GFP_KERNEL); 7357 if (!sas_device) { 7358 ioc_err(ioc, "failure at %s:%d/%s()!\n", 7359 __FILE__, __LINE__, __func__); 7360 return 0; 7361 } 7362 7363 kref_init(&sas_device->refcount); 7364 sas_device->handle = handle; 7365 if (_scsih_get_sas_address(ioc, 7366 le16_to_cpu(sas_device_pg0.ParentDevHandle), 7367 &sas_device->sas_address_parent) != 0) 7368 ioc_err(ioc, "failure at %s:%d/%s()!\n", 7369 __FILE__, __LINE__, __func__); 7370 sas_device->enclosure_handle = 7371 le16_to_cpu(sas_device_pg0.EnclosureHandle); 7372 if (sas_device->enclosure_handle != 0) 7373 sas_device->slot = 7374 le16_to_cpu(sas_device_pg0.Slot); 7375 sas_device->device_info = device_info; 7376 sas_device->sas_address = sas_address; 7377 sas_device->phy = sas_device_pg0.PhyNum; 7378 sas_device->fast_path = (le16_to_cpu(sas_device_pg0.Flags) & 7379 MPI25_SAS_DEVICE0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0; 7380 sas_device->port = mpt3sas_get_port_by_id(ioc, port_id, 0); 7381 if (!sas_device->port) { 7382 ioc_err(ioc, "failure at %s:%d/%s()!\n", 7383 __FILE__, __LINE__, __func__); 7384 goto out; 7385 } 7386 7387 if (le16_to_cpu(sas_device_pg0.Flags) 7388 & MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) { 7389 sas_device->enclosure_level = 7390 sas_device_pg0.EnclosureLevel; 7391 memcpy(sas_device->connector_name, 7392 sas_device_pg0.ConnectorName, 4); 7393 sas_device->connector_name[4] = '\0'; 7394 } else { 7395 sas_device->enclosure_level = 0; 7396 sas_device->connector_name[0] = '\0'; 7397 } 7398 /* get enclosure_logical_id & chassis_slot*/ 7399 sas_device->is_chassis_slot_valid = 0; 7400 if (enclosure_dev) { 7401 sas_device->enclosure_logical_id = 7402 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID); 7403 if (le16_to_cpu(enclosure_dev->pg0.Flags) & 7404 MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) { 7405 sas_device->is_chassis_slot_valid = 1; 7406 sas_device->chassis_slot = 7407 enclosure_dev->pg0.ChassisSlot; 7408 } 7409 } 7410 7411 /* get device name */ 7412 sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName); 7413 sas_device->port_type = sas_device_pg0.MaxPortConnections; 7414 ioc_info(ioc, 7415 "handle(0x%0x) sas_address(0x%016llx) port_type(0x%0x)\n", 7416 handle, sas_device->sas_address, sas_device->port_type); 7417 7418 if (ioc->wait_for_discovery_to_complete) 7419 _scsih_sas_device_init_add(ioc, sas_device); 7420 else 7421 _scsih_sas_device_add(ioc, sas_device); 7422 7423 out: 7424 sas_device_put(sas_device); 7425 return 0; 7426 } 7427 7428 /** 7429 * _scsih_remove_device - removing sas device object 7430 * @ioc: per adapter object 7431 * @sas_device: the sas_device object 7432 */ 7433 static void 7434 _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc, 7435 struct _sas_device *sas_device) 7436 { 7437 struct MPT3SAS_TARGET *sas_target_priv_data; 7438 7439 if ((ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) && 7440 (sas_device->pfa_led_on)) { 7441 _scsih_turn_off_pfa_led(ioc, sas_device); 7442 sas_device->pfa_led_on = 0; 7443 } 7444 7445 dewtprintk(ioc, 7446 ioc_info(ioc, "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n", 7447 __func__, 7448 sas_device->handle, (u64)sas_device->sas_address)); 7449 7450 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device, 7451 NULL, NULL)); 7452 7453 if (sas_device->starget && sas_device->starget->hostdata) { 7454 sas_target_priv_data = sas_device->starget->hostdata; 7455 sas_target_priv_data->deleted = 1; 7456 _scsih_ublock_io_device(ioc, sas_device->sas_address, 7457 sas_device->port); 7458 sas_target_priv_data->handle = 7459 MPT3SAS_INVALID_DEVICE_HANDLE; 7460 } 7461 7462 if (!ioc->hide_drives) 7463 mpt3sas_transport_port_remove(ioc, 7464 sas_device->sas_address, 7465 sas_device->sas_address_parent, 7466 sas_device->port); 7467 7468 ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n", 7469 sas_device->handle, (u64)sas_device->sas_address); 7470 7471 _scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL); 7472 7473 dewtprintk(ioc, 7474 ioc_info(ioc, "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n", 7475 __func__, 7476 sas_device->handle, (u64)sas_device->sas_address)); 7477 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device, 7478 NULL, NULL)); 7479 } 7480 7481 /** 7482 * _scsih_sas_topology_change_event_debug - debug for topology event 7483 * @ioc: per adapter object 7484 * @event_data: event data payload 7485 * Context: user. 7486 */ 7487 static void 7488 _scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 7489 Mpi2EventDataSasTopologyChangeList_t *event_data) 7490 { 7491 int i; 7492 u16 handle; 7493 u16 reason_code; 7494 u8 phy_number; 7495 char *status_str = NULL; 7496 u8 link_rate, prev_link_rate; 7497 7498 switch (event_data->ExpStatus) { 7499 case MPI2_EVENT_SAS_TOPO_ES_ADDED: 7500 status_str = "add"; 7501 break; 7502 case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING: 7503 status_str = "remove"; 7504 break; 7505 case MPI2_EVENT_SAS_TOPO_ES_RESPONDING: 7506 case 0: 7507 status_str = "responding"; 7508 break; 7509 case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING: 7510 status_str = "remove delay"; 7511 break; 7512 default: 7513 status_str = "unknown status"; 7514 break; 7515 } 7516 ioc_info(ioc, "sas topology change: (%s)\n", status_str); 7517 pr_info("\thandle(0x%04x), enclosure_handle(0x%04x) " \ 7518 "start_phy(%02d), count(%d)\n", 7519 le16_to_cpu(event_data->ExpanderDevHandle), 7520 le16_to_cpu(event_data->EnclosureHandle), 7521 event_data->StartPhyNum, event_data->NumEntries); 7522 for (i = 0; i < event_data->NumEntries; i++) { 7523 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 7524 if (!handle) 7525 continue; 7526 phy_number = event_data->StartPhyNum + i; 7527 reason_code = event_data->PHY[i].PhyStatus & 7528 MPI2_EVENT_SAS_TOPO_RC_MASK; 7529 switch (reason_code) { 7530 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED: 7531 status_str = "target add"; 7532 break; 7533 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING: 7534 status_str = "target remove"; 7535 break; 7536 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING: 7537 status_str = "delay target remove"; 7538 break; 7539 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED: 7540 status_str = "link rate change"; 7541 break; 7542 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE: 7543 status_str = "target responding"; 7544 break; 7545 default: 7546 status_str = "unknown"; 7547 break; 7548 } 7549 link_rate = event_data->PHY[i].LinkRate >> 4; 7550 prev_link_rate = event_data->PHY[i].LinkRate & 0xF; 7551 pr_info("\tphy(%02d), attached_handle(0x%04x): %s:" \ 7552 " link rate: new(0x%02x), old(0x%02x)\n", phy_number, 7553 handle, status_str, link_rate, prev_link_rate); 7554 7555 } 7556 } 7557 7558 /** 7559 * _scsih_sas_topology_change_event - handle topology changes 7560 * @ioc: per adapter object 7561 * @fw_event: The fw_event_work object 7562 * Context: user. 7563 * 7564 */ 7565 static int 7566 _scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc, 7567 struct fw_event_work *fw_event) 7568 { 7569 int i; 7570 u16 parent_handle, handle; 7571 u16 reason_code; 7572 u8 phy_number, max_phys; 7573 struct _sas_node *sas_expander; 7574 u64 sas_address; 7575 unsigned long flags; 7576 u8 link_rate, prev_link_rate; 7577 struct hba_port *port; 7578 Mpi2EventDataSasTopologyChangeList_t *event_data = 7579 (Mpi2EventDataSasTopologyChangeList_t *) 7580 fw_event->event_data; 7581 7582 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 7583 _scsih_sas_topology_change_event_debug(ioc, event_data); 7584 7585 if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery) 7586 return 0; 7587 7588 if (!ioc->sas_hba.num_phys) 7589 _scsih_sas_host_add(ioc); 7590 else 7591 _scsih_sas_host_refresh(ioc); 7592 7593 if (fw_event->ignore) { 7594 dewtprintk(ioc, ioc_info(ioc, "ignoring expander event\n")); 7595 return 0; 7596 } 7597 7598 parent_handle = le16_to_cpu(event_data->ExpanderDevHandle); 7599 port = mpt3sas_get_port_by_id(ioc, event_data->PhysicalPort, 0); 7600 7601 /* handle expander add */ 7602 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED) 7603 if (_scsih_expander_add(ioc, parent_handle) != 0) 7604 return 0; 7605 7606 spin_lock_irqsave(&ioc->sas_node_lock, flags); 7607 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc, 7608 parent_handle); 7609 if (sas_expander) { 7610 sas_address = sas_expander->sas_address; 7611 max_phys = sas_expander->num_phys; 7612 port = sas_expander->port; 7613 } else if (parent_handle < ioc->sas_hba.num_phys) { 7614 sas_address = ioc->sas_hba.sas_address; 7615 max_phys = ioc->sas_hba.num_phys; 7616 } else { 7617 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 7618 return 0; 7619 } 7620 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 7621 7622 /* handle siblings events */ 7623 for (i = 0; i < event_data->NumEntries; i++) { 7624 if (fw_event->ignore) { 7625 dewtprintk(ioc, 7626 ioc_info(ioc, "ignoring expander event\n")); 7627 return 0; 7628 } 7629 if (ioc->remove_host || ioc->pci_error_recovery) 7630 return 0; 7631 phy_number = event_data->StartPhyNum + i; 7632 if (phy_number >= max_phys) 7633 continue; 7634 reason_code = event_data->PHY[i].PhyStatus & 7635 MPI2_EVENT_SAS_TOPO_RC_MASK; 7636 if ((event_data->PHY[i].PhyStatus & 7637 MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code != 7638 MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)) 7639 continue; 7640 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 7641 if (!handle) 7642 continue; 7643 link_rate = event_data->PHY[i].LinkRate >> 4; 7644 prev_link_rate = event_data->PHY[i].LinkRate & 0xF; 7645 switch (reason_code) { 7646 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED: 7647 7648 if (ioc->shost_recovery) 7649 break; 7650 7651 if (link_rate == prev_link_rate) 7652 break; 7653 7654 mpt3sas_transport_update_links(ioc, sas_address, 7655 handle, phy_number, link_rate, port); 7656 7657 if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5) 7658 break; 7659 7660 _scsih_check_device(ioc, sas_address, handle, 7661 phy_number, link_rate); 7662 7663 if (!test_bit(handle, ioc->pend_os_device_add)) 7664 break; 7665 7666 fallthrough; 7667 7668 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED: 7669 7670 if (ioc->shost_recovery) 7671 break; 7672 7673 mpt3sas_transport_update_links(ioc, sas_address, 7674 handle, phy_number, link_rate, port); 7675 7676 _scsih_add_device(ioc, handle, phy_number, 0); 7677 7678 break; 7679 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING: 7680 7681 _scsih_device_remove_by_handle(ioc, handle); 7682 break; 7683 } 7684 } 7685 7686 /* handle expander removal */ 7687 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING && 7688 sas_expander) 7689 mpt3sas_expander_remove(ioc, sas_address, port); 7690 7691 return 0; 7692 } 7693 7694 /** 7695 * _scsih_sas_device_status_change_event_debug - debug for device event 7696 * @ioc: ? 7697 * @event_data: event data payload 7698 * Context: user. 7699 */ 7700 static void 7701 _scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 7702 Mpi2EventDataSasDeviceStatusChange_t *event_data) 7703 { 7704 char *reason_str = NULL; 7705 7706 switch (event_data->ReasonCode) { 7707 case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA: 7708 reason_str = "smart data"; 7709 break; 7710 case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED: 7711 reason_str = "unsupported device discovered"; 7712 break; 7713 case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET: 7714 reason_str = "internal device reset"; 7715 break; 7716 case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL: 7717 reason_str = "internal task abort"; 7718 break; 7719 case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL: 7720 reason_str = "internal task abort set"; 7721 break; 7722 case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL: 7723 reason_str = "internal clear task set"; 7724 break; 7725 case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL: 7726 reason_str = "internal query task"; 7727 break; 7728 case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE: 7729 reason_str = "sata init failure"; 7730 break; 7731 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET: 7732 reason_str = "internal device reset complete"; 7733 break; 7734 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL: 7735 reason_str = "internal task abort complete"; 7736 break; 7737 case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION: 7738 reason_str = "internal async notification"; 7739 break; 7740 case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY: 7741 reason_str = "expander reduced functionality"; 7742 break; 7743 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY: 7744 reason_str = "expander reduced functionality complete"; 7745 break; 7746 default: 7747 reason_str = "unknown reason"; 7748 break; 7749 } 7750 ioc_info(ioc, "device status change: (%s)\thandle(0x%04x), sas address(0x%016llx), tag(%d)", 7751 reason_str, le16_to_cpu(event_data->DevHandle), 7752 (u64)le64_to_cpu(event_data->SASAddress), 7753 le16_to_cpu(event_data->TaskTag)); 7754 if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA) 7755 pr_cont(", ASC(0x%x), ASCQ(0x%x)\n", 7756 event_data->ASC, event_data->ASCQ); 7757 pr_cont("\n"); 7758 } 7759 7760 /** 7761 * _scsih_sas_device_status_change_event - handle device status change 7762 * @ioc: per adapter object 7763 * @event_data: The fw event 7764 * Context: user. 7765 */ 7766 static void 7767 _scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc, 7768 Mpi2EventDataSasDeviceStatusChange_t *event_data) 7769 { 7770 struct MPT3SAS_TARGET *target_priv_data; 7771 struct _sas_device *sas_device; 7772 u64 sas_address; 7773 unsigned long flags; 7774 7775 /* In MPI Revision K (0xC), the internal device reset complete was 7776 * implemented, so avoid setting tm_busy flag for older firmware. 7777 */ 7778 if ((ioc->facts.HeaderVersion >> 8) < 0xC) 7779 return; 7780 7781 if (event_data->ReasonCode != 7782 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET && 7783 event_data->ReasonCode != 7784 MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET) 7785 return; 7786 7787 spin_lock_irqsave(&ioc->sas_device_lock, flags); 7788 sas_address = le64_to_cpu(event_data->SASAddress); 7789 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 7790 sas_address, 7791 mpt3sas_get_port_by_id(ioc, event_data->PhysicalPort, 0)); 7792 7793 if (!sas_device || !sas_device->starget) 7794 goto out; 7795 7796 target_priv_data = sas_device->starget->hostdata; 7797 if (!target_priv_data) 7798 goto out; 7799 7800 if (event_data->ReasonCode == 7801 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET) 7802 target_priv_data->tm_busy = 1; 7803 else 7804 target_priv_data->tm_busy = 0; 7805 7806 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 7807 ioc_info(ioc, 7808 "%s tm_busy flag for handle(0x%04x)\n", 7809 (target_priv_data->tm_busy == 1) ? "Enable" : "Disable", 7810 target_priv_data->handle); 7811 7812 out: 7813 if (sas_device) 7814 sas_device_put(sas_device); 7815 7816 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 7817 } 7818 7819 7820 /** 7821 * _scsih_check_pcie_access_status - check access flags 7822 * @ioc: per adapter object 7823 * @wwid: wwid 7824 * @handle: sas device handle 7825 * @access_status: errors returned during discovery of the device 7826 * 7827 * Return: 0 for success, else failure 7828 */ 7829 static u8 7830 _scsih_check_pcie_access_status(struct MPT3SAS_ADAPTER *ioc, u64 wwid, 7831 u16 handle, u8 access_status) 7832 { 7833 u8 rc = 1; 7834 char *desc = NULL; 7835 7836 switch (access_status) { 7837 case MPI26_PCIEDEV0_ASTATUS_NO_ERRORS: 7838 case MPI26_PCIEDEV0_ASTATUS_NEEDS_INITIALIZATION: 7839 rc = 0; 7840 break; 7841 case MPI26_PCIEDEV0_ASTATUS_CAPABILITY_FAILED: 7842 desc = "PCIe device capability failed"; 7843 break; 7844 case MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED: 7845 desc = "PCIe device blocked"; 7846 ioc_info(ioc, 7847 "Device with Access Status (%s): wwid(0x%016llx), " 7848 "handle(0x%04x)\n ll only be added to the internal list", 7849 desc, (u64)wwid, handle); 7850 rc = 0; 7851 break; 7852 case MPI26_PCIEDEV0_ASTATUS_MEMORY_SPACE_ACCESS_FAILED: 7853 desc = "PCIe device mem space access failed"; 7854 break; 7855 case MPI26_PCIEDEV0_ASTATUS_UNSUPPORTED_DEVICE: 7856 desc = "PCIe device unsupported"; 7857 break; 7858 case MPI26_PCIEDEV0_ASTATUS_MSIX_REQUIRED: 7859 desc = "PCIe device MSIx Required"; 7860 break; 7861 case MPI26_PCIEDEV0_ASTATUS_INIT_FAIL_MAX: 7862 desc = "PCIe device init fail max"; 7863 break; 7864 case MPI26_PCIEDEV0_ASTATUS_UNKNOWN: 7865 desc = "PCIe device status unknown"; 7866 break; 7867 case MPI26_PCIEDEV0_ASTATUS_NVME_READY_TIMEOUT: 7868 desc = "nvme ready timeout"; 7869 break; 7870 case MPI26_PCIEDEV0_ASTATUS_NVME_DEVCFG_UNSUPPORTED: 7871 desc = "nvme device configuration unsupported"; 7872 break; 7873 case MPI26_PCIEDEV0_ASTATUS_NVME_IDENTIFY_FAILED: 7874 desc = "nvme identify failed"; 7875 break; 7876 case MPI26_PCIEDEV0_ASTATUS_NVME_QCONFIG_FAILED: 7877 desc = "nvme qconfig failed"; 7878 break; 7879 case MPI26_PCIEDEV0_ASTATUS_NVME_QCREATION_FAILED: 7880 desc = "nvme qcreation failed"; 7881 break; 7882 case MPI26_PCIEDEV0_ASTATUS_NVME_EVENTCFG_FAILED: 7883 desc = "nvme eventcfg failed"; 7884 break; 7885 case MPI26_PCIEDEV0_ASTATUS_NVME_GET_FEATURE_STAT_FAILED: 7886 desc = "nvme get feature stat failed"; 7887 break; 7888 case MPI26_PCIEDEV0_ASTATUS_NVME_IDLE_TIMEOUT: 7889 desc = "nvme idle timeout"; 7890 break; 7891 case MPI26_PCIEDEV0_ASTATUS_NVME_FAILURE_STATUS: 7892 desc = "nvme failure status"; 7893 break; 7894 default: 7895 ioc_err(ioc, "NVMe discovery error(0x%02x): wwid(0x%016llx), handle(0x%04x)\n", 7896 access_status, (u64)wwid, handle); 7897 return rc; 7898 } 7899 7900 if (!rc) 7901 return rc; 7902 7903 ioc_info(ioc, "NVMe discovery error(%s): wwid(0x%016llx), handle(0x%04x)\n", 7904 desc, (u64)wwid, handle); 7905 return rc; 7906 } 7907 7908 /** 7909 * _scsih_pcie_device_remove_from_sml - removing pcie device 7910 * from SML and free up associated memory 7911 * @ioc: per adapter object 7912 * @pcie_device: the pcie_device object 7913 */ 7914 static void 7915 _scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc, 7916 struct _pcie_device *pcie_device) 7917 { 7918 struct MPT3SAS_TARGET *sas_target_priv_data; 7919 7920 dewtprintk(ioc, 7921 ioc_info(ioc, "%s: enter: handle(0x%04x), wwid(0x%016llx)\n", 7922 __func__, 7923 pcie_device->handle, (u64)pcie_device->wwid)); 7924 if (pcie_device->enclosure_handle != 0) 7925 dewtprintk(ioc, 7926 ioc_info(ioc, "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n", 7927 __func__, 7928 (u64)pcie_device->enclosure_logical_id, 7929 pcie_device->slot)); 7930 if (pcie_device->connector_name[0] != '\0') 7931 dewtprintk(ioc, 7932 ioc_info(ioc, "%s: enter: enclosure level(0x%04x), connector name(%s)\n", 7933 __func__, 7934 pcie_device->enclosure_level, 7935 pcie_device->connector_name)); 7936 7937 if (pcie_device->starget && pcie_device->starget->hostdata) { 7938 sas_target_priv_data = pcie_device->starget->hostdata; 7939 sas_target_priv_data->deleted = 1; 7940 _scsih_ublock_io_device(ioc, pcie_device->wwid, NULL); 7941 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE; 7942 } 7943 7944 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n", 7945 pcie_device->handle, (u64)pcie_device->wwid); 7946 if (pcie_device->enclosure_handle != 0) 7947 ioc_info(ioc, "removing : enclosure logical id(0x%016llx), slot(%d)\n", 7948 (u64)pcie_device->enclosure_logical_id, 7949 pcie_device->slot); 7950 if (pcie_device->connector_name[0] != '\0') 7951 ioc_info(ioc, "removing: enclosure level(0x%04x), connector name( %s)\n", 7952 pcie_device->enclosure_level, 7953 pcie_device->connector_name); 7954 7955 if (pcie_device->starget && (pcie_device->access_status != 7956 MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED)) 7957 scsi_remove_target(&pcie_device->starget->dev); 7958 dewtprintk(ioc, 7959 ioc_info(ioc, "%s: exit: handle(0x%04x), wwid(0x%016llx)\n", 7960 __func__, 7961 pcie_device->handle, (u64)pcie_device->wwid)); 7962 if (pcie_device->enclosure_handle != 0) 7963 dewtprintk(ioc, 7964 ioc_info(ioc, "%s: exit: enclosure logical id(0x%016llx), slot(%d)\n", 7965 __func__, 7966 (u64)pcie_device->enclosure_logical_id, 7967 pcie_device->slot)); 7968 if (pcie_device->connector_name[0] != '\0') 7969 dewtprintk(ioc, 7970 ioc_info(ioc, "%s: exit: enclosure level(0x%04x), connector name( %s)\n", 7971 __func__, 7972 pcie_device->enclosure_level, 7973 pcie_device->connector_name)); 7974 7975 kfree(pcie_device->serial_number); 7976 } 7977 7978 7979 /** 7980 * _scsih_pcie_check_device - checking device responsiveness 7981 * @ioc: per adapter object 7982 * @handle: attached device handle 7983 */ 7984 static void 7985 _scsih_pcie_check_device(struct MPT3SAS_ADAPTER *ioc, u16 handle) 7986 { 7987 Mpi2ConfigReply_t mpi_reply; 7988 Mpi26PCIeDevicePage0_t pcie_device_pg0; 7989 u32 ioc_status; 7990 struct _pcie_device *pcie_device; 7991 u64 wwid; 7992 unsigned long flags; 7993 struct scsi_target *starget; 7994 struct MPT3SAS_TARGET *sas_target_priv_data; 7995 u32 device_info; 7996 7997 if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply, 7998 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE, handle))) 7999 return; 8000 8001 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 8002 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 8003 return; 8004 8005 /* check if this is end device */ 8006 device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo); 8007 if (!(_scsih_is_nvme_pciescsi_device(device_info))) 8008 return; 8009 8010 wwid = le64_to_cpu(pcie_device_pg0.WWID); 8011 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 8012 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid); 8013 8014 if (!pcie_device) { 8015 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 8016 return; 8017 } 8018 8019 if (unlikely(pcie_device->handle != handle)) { 8020 starget = pcie_device->starget; 8021 sas_target_priv_data = starget->hostdata; 8022 pcie_device->access_status = pcie_device_pg0.AccessStatus; 8023 starget_printk(KERN_INFO, starget, 8024 "handle changed from(0x%04x) to (0x%04x)!!!\n", 8025 pcie_device->handle, handle); 8026 sas_target_priv_data->handle = handle; 8027 pcie_device->handle = handle; 8028 8029 if (le32_to_cpu(pcie_device_pg0.Flags) & 8030 MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) { 8031 pcie_device->enclosure_level = 8032 pcie_device_pg0.EnclosureLevel; 8033 memcpy(&pcie_device->connector_name[0], 8034 &pcie_device_pg0.ConnectorName[0], 4); 8035 } else { 8036 pcie_device->enclosure_level = 0; 8037 pcie_device->connector_name[0] = '\0'; 8038 } 8039 } 8040 8041 /* check if device is present */ 8042 if (!(le32_to_cpu(pcie_device_pg0.Flags) & 8043 MPI26_PCIEDEV0_FLAGS_DEVICE_PRESENT)) { 8044 ioc_info(ioc, "device is not present handle(0x%04x), flags!!!\n", 8045 handle); 8046 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 8047 pcie_device_put(pcie_device); 8048 return; 8049 } 8050 8051 /* check if there were any issues with discovery */ 8052 if (_scsih_check_pcie_access_status(ioc, wwid, handle, 8053 pcie_device_pg0.AccessStatus)) { 8054 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 8055 pcie_device_put(pcie_device); 8056 return; 8057 } 8058 8059 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 8060 pcie_device_put(pcie_device); 8061 8062 _scsih_ublock_io_device(ioc, wwid, NULL); 8063 8064 return; 8065 } 8066 8067 /** 8068 * _scsih_pcie_add_device - creating pcie device object 8069 * @ioc: per adapter object 8070 * @handle: pcie device handle 8071 * 8072 * Creating end device object, stored in ioc->pcie_device_list. 8073 * 8074 * Return: 1 means queue the event later, 0 means complete the event 8075 */ 8076 static int 8077 _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle) 8078 { 8079 Mpi26PCIeDevicePage0_t pcie_device_pg0; 8080 Mpi26PCIeDevicePage2_t pcie_device_pg2; 8081 Mpi2ConfigReply_t mpi_reply; 8082 struct _pcie_device *pcie_device; 8083 struct _enclosure_node *enclosure_dev; 8084 u32 ioc_status; 8085 u64 wwid; 8086 8087 if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply, 8088 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE, handle))) { 8089 ioc_err(ioc, "failure at %s:%d/%s()!\n", 8090 __FILE__, __LINE__, __func__); 8091 return 0; 8092 } 8093 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 8094 MPI2_IOCSTATUS_MASK; 8095 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 8096 ioc_err(ioc, "failure at %s:%d/%s()!\n", 8097 __FILE__, __LINE__, __func__); 8098 return 0; 8099 } 8100 8101 set_bit(handle, ioc->pend_os_device_add); 8102 wwid = le64_to_cpu(pcie_device_pg0.WWID); 8103 8104 /* check if device is present */ 8105 if (!(le32_to_cpu(pcie_device_pg0.Flags) & 8106 MPI26_PCIEDEV0_FLAGS_DEVICE_PRESENT)) { 8107 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n", 8108 handle); 8109 return 0; 8110 } 8111 8112 /* check if there were any issues with discovery */ 8113 if (_scsih_check_pcie_access_status(ioc, wwid, handle, 8114 pcie_device_pg0.AccessStatus)) 8115 return 0; 8116 8117 if (!(_scsih_is_nvme_pciescsi_device(le32_to_cpu 8118 (pcie_device_pg0.DeviceInfo)))) 8119 return 0; 8120 8121 pcie_device = mpt3sas_get_pdev_by_wwid(ioc, wwid); 8122 if (pcie_device) { 8123 clear_bit(handle, ioc->pend_os_device_add); 8124 pcie_device_put(pcie_device); 8125 return 0; 8126 } 8127 8128 /* PCIe Device Page 2 contains read-only information about a 8129 * specific NVMe device; therefore, this page is only 8130 * valid for NVMe devices and skip for pcie devices of type scsi. 8131 */ 8132 if (!(mpt3sas_scsih_is_pcie_scsi_device( 8133 le32_to_cpu(pcie_device_pg0.DeviceInfo)))) { 8134 if (mpt3sas_config_get_pcie_device_pg2(ioc, &mpi_reply, 8135 &pcie_device_pg2, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, 8136 handle)) { 8137 ioc_err(ioc, 8138 "failure at %s:%d/%s()!\n", __FILE__, 8139 __LINE__, __func__); 8140 return 0; 8141 } 8142 8143 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 8144 MPI2_IOCSTATUS_MASK; 8145 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 8146 ioc_err(ioc, 8147 "failure at %s:%d/%s()!\n", __FILE__, 8148 __LINE__, __func__); 8149 return 0; 8150 } 8151 } 8152 8153 pcie_device = kzalloc(sizeof(struct _pcie_device), GFP_KERNEL); 8154 if (!pcie_device) { 8155 ioc_err(ioc, "failure at %s:%d/%s()!\n", 8156 __FILE__, __LINE__, __func__); 8157 return 0; 8158 } 8159 8160 kref_init(&pcie_device->refcount); 8161 pcie_device->id = ioc->pcie_target_id++; 8162 pcie_device->channel = PCIE_CHANNEL; 8163 pcie_device->handle = handle; 8164 pcie_device->access_status = pcie_device_pg0.AccessStatus; 8165 pcie_device->device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo); 8166 pcie_device->wwid = wwid; 8167 pcie_device->port_num = pcie_device_pg0.PortNum; 8168 pcie_device->fast_path = (le32_to_cpu(pcie_device_pg0.Flags) & 8169 MPI26_PCIEDEV0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0; 8170 8171 pcie_device->enclosure_handle = 8172 le16_to_cpu(pcie_device_pg0.EnclosureHandle); 8173 if (pcie_device->enclosure_handle != 0) 8174 pcie_device->slot = le16_to_cpu(pcie_device_pg0.Slot); 8175 8176 if (le32_to_cpu(pcie_device_pg0.Flags) & 8177 MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) { 8178 pcie_device->enclosure_level = pcie_device_pg0.EnclosureLevel; 8179 memcpy(&pcie_device->connector_name[0], 8180 &pcie_device_pg0.ConnectorName[0], 4); 8181 } else { 8182 pcie_device->enclosure_level = 0; 8183 pcie_device->connector_name[0] = '\0'; 8184 } 8185 8186 /* get enclosure_logical_id */ 8187 if (pcie_device->enclosure_handle) { 8188 enclosure_dev = 8189 mpt3sas_scsih_enclosure_find_by_handle(ioc, 8190 pcie_device->enclosure_handle); 8191 if (enclosure_dev) 8192 pcie_device->enclosure_logical_id = 8193 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID); 8194 } 8195 /* TODO -- Add device name once FW supports it */ 8196 if (!(mpt3sas_scsih_is_pcie_scsi_device( 8197 le32_to_cpu(pcie_device_pg0.DeviceInfo)))) { 8198 pcie_device->nvme_mdts = 8199 le32_to_cpu(pcie_device_pg2.MaximumDataTransferSize); 8200 pcie_device->shutdown_latency = 8201 le16_to_cpu(pcie_device_pg2.ShutdownLatency); 8202 /* 8203 * Set IOC's max_shutdown_latency to drive's RTD3 Entry Latency 8204 * if drive's RTD3 Entry Latency is greater then IOC's 8205 * max_shutdown_latency. 8206 */ 8207 if (pcie_device->shutdown_latency > ioc->max_shutdown_latency) 8208 ioc->max_shutdown_latency = 8209 pcie_device->shutdown_latency; 8210 if (pcie_device_pg2.ControllerResetTO) 8211 pcie_device->reset_timeout = 8212 pcie_device_pg2.ControllerResetTO; 8213 else 8214 pcie_device->reset_timeout = 30; 8215 } else 8216 pcie_device->reset_timeout = 30; 8217 8218 if (ioc->wait_for_discovery_to_complete) 8219 _scsih_pcie_device_init_add(ioc, pcie_device); 8220 else 8221 _scsih_pcie_device_add(ioc, pcie_device); 8222 8223 pcie_device_put(pcie_device); 8224 return 0; 8225 } 8226 8227 /** 8228 * _scsih_pcie_topology_change_event_debug - debug for topology 8229 * event 8230 * @ioc: per adapter object 8231 * @event_data: event data payload 8232 * Context: user. 8233 */ 8234 static void 8235 _scsih_pcie_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 8236 Mpi26EventDataPCIeTopologyChangeList_t *event_data) 8237 { 8238 int i; 8239 u16 handle; 8240 u16 reason_code; 8241 u8 port_number; 8242 char *status_str = NULL; 8243 u8 link_rate, prev_link_rate; 8244 8245 switch (event_data->SwitchStatus) { 8246 case MPI26_EVENT_PCIE_TOPO_SS_ADDED: 8247 status_str = "add"; 8248 break; 8249 case MPI26_EVENT_PCIE_TOPO_SS_NOT_RESPONDING: 8250 status_str = "remove"; 8251 break; 8252 case MPI26_EVENT_PCIE_TOPO_SS_RESPONDING: 8253 case 0: 8254 status_str = "responding"; 8255 break; 8256 case MPI26_EVENT_PCIE_TOPO_SS_DELAY_NOT_RESPONDING: 8257 status_str = "remove delay"; 8258 break; 8259 default: 8260 status_str = "unknown status"; 8261 break; 8262 } 8263 ioc_info(ioc, "pcie topology change: (%s)\n", status_str); 8264 pr_info("\tswitch_handle(0x%04x), enclosure_handle(0x%04x)" 8265 "start_port(%02d), count(%d)\n", 8266 le16_to_cpu(event_data->SwitchDevHandle), 8267 le16_to_cpu(event_data->EnclosureHandle), 8268 event_data->StartPortNum, event_data->NumEntries); 8269 for (i = 0; i < event_data->NumEntries; i++) { 8270 handle = 8271 le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle); 8272 if (!handle) 8273 continue; 8274 port_number = event_data->StartPortNum + i; 8275 reason_code = event_data->PortEntry[i].PortStatus; 8276 switch (reason_code) { 8277 case MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED: 8278 status_str = "target add"; 8279 break; 8280 case MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING: 8281 status_str = "target remove"; 8282 break; 8283 case MPI26_EVENT_PCIE_TOPO_PS_DELAY_NOT_RESPONDING: 8284 status_str = "delay target remove"; 8285 break; 8286 case MPI26_EVENT_PCIE_TOPO_PS_PORT_CHANGED: 8287 status_str = "link rate change"; 8288 break; 8289 case MPI26_EVENT_PCIE_TOPO_PS_NO_CHANGE: 8290 status_str = "target responding"; 8291 break; 8292 default: 8293 status_str = "unknown"; 8294 break; 8295 } 8296 link_rate = event_data->PortEntry[i].CurrentPortInfo & 8297 MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK; 8298 prev_link_rate = event_data->PortEntry[i].PreviousPortInfo & 8299 MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK; 8300 pr_info("\tport(%02d), attached_handle(0x%04x): %s:" 8301 " link rate: new(0x%02x), old(0x%02x)\n", port_number, 8302 handle, status_str, link_rate, prev_link_rate); 8303 } 8304 } 8305 8306 /** 8307 * _scsih_pcie_topology_change_event - handle PCIe topology 8308 * changes 8309 * @ioc: per adapter object 8310 * @fw_event: The fw_event_work object 8311 * Context: user. 8312 * 8313 */ 8314 static void 8315 _scsih_pcie_topology_change_event(struct MPT3SAS_ADAPTER *ioc, 8316 struct fw_event_work *fw_event) 8317 { 8318 int i; 8319 u16 handle; 8320 u16 reason_code; 8321 u8 link_rate, prev_link_rate; 8322 unsigned long flags; 8323 int rc; 8324 Mpi26EventDataPCIeTopologyChangeList_t *event_data = 8325 (Mpi26EventDataPCIeTopologyChangeList_t *) fw_event->event_data; 8326 struct _pcie_device *pcie_device; 8327 8328 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 8329 _scsih_pcie_topology_change_event_debug(ioc, event_data); 8330 8331 if (ioc->shost_recovery || ioc->remove_host || 8332 ioc->pci_error_recovery) 8333 return; 8334 8335 if (fw_event->ignore) { 8336 dewtprintk(ioc, ioc_info(ioc, "ignoring switch event\n")); 8337 return; 8338 } 8339 8340 /* handle siblings events */ 8341 for (i = 0; i < event_data->NumEntries; i++) { 8342 if (fw_event->ignore) { 8343 dewtprintk(ioc, 8344 ioc_info(ioc, "ignoring switch event\n")); 8345 return; 8346 } 8347 if (ioc->remove_host || ioc->pci_error_recovery) 8348 return; 8349 reason_code = event_data->PortEntry[i].PortStatus; 8350 handle = 8351 le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle); 8352 if (!handle) 8353 continue; 8354 8355 link_rate = event_data->PortEntry[i].CurrentPortInfo 8356 & MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK; 8357 prev_link_rate = event_data->PortEntry[i].PreviousPortInfo 8358 & MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK; 8359 8360 switch (reason_code) { 8361 case MPI26_EVENT_PCIE_TOPO_PS_PORT_CHANGED: 8362 if (ioc->shost_recovery) 8363 break; 8364 if (link_rate == prev_link_rate) 8365 break; 8366 if (link_rate < MPI26_EVENT_PCIE_TOPO_PI_RATE_2_5) 8367 break; 8368 8369 _scsih_pcie_check_device(ioc, handle); 8370 8371 /* This code after this point handles the test case 8372 * where a device has been added, however its returning 8373 * BUSY for sometime. Then before the Device Missing 8374 * Delay expires and the device becomes READY, the 8375 * device is removed and added back. 8376 */ 8377 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 8378 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle); 8379 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 8380 8381 if (pcie_device) { 8382 pcie_device_put(pcie_device); 8383 break; 8384 } 8385 8386 if (!test_bit(handle, ioc->pend_os_device_add)) 8387 break; 8388 8389 dewtprintk(ioc, 8390 ioc_info(ioc, "handle(0x%04x) device not found: convert event to a device add\n", 8391 handle)); 8392 event_data->PortEntry[i].PortStatus &= 0xF0; 8393 event_data->PortEntry[i].PortStatus |= 8394 MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED; 8395 fallthrough; 8396 case MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED: 8397 if (ioc->shost_recovery) 8398 break; 8399 if (link_rate < MPI26_EVENT_PCIE_TOPO_PI_RATE_2_5) 8400 break; 8401 8402 rc = _scsih_pcie_add_device(ioc, handle); 8403 if (!rc) { 8404 /* mark entry vacant */ 8405 /* TODO This needs to be reviewed and fixed, 8406 * we dont have an entry 8407 * to make an event void like vacant 8408 */ 8409 event_data->PortEntry[i].PortStatus |= 8410 MPI26_EVENT_PCIE_TOPO_PS_NO_CHANGE; 8411 } 8412 break; 8413 case MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING: 8414 _scsih_pcie_device_remove_by_handle(ioc, handle); 8415 break; 8416 } 8417 } 8418 } 8419 8420 /** 8421 * _scsih_pcie_device_status_change_event_debug - debug for device event 8422 * @ioc: ? 8423 * @event_data: event data payload 8424 * Context: user. 8425 */ 8426 static void 8427 _scsih_pcie_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 8428 Mpi26EventDataPCIeDeviceStatusChange_t *event_data) 8429 { 8430 char *reason_str = NULL; 8431 8432 switch (event_data->ReasonCode) { 8433 case MPI26_EVENT_PCIDEV_STAT_RC_SMART_DATA: 8434 reason_str = "smart data"; 8435 break; 8436 case MPI26_EVENT_PCIDEV_STAT_RC_UNSUPPORTED: 8437 reason_str = "unsupported device discovered"; 8438 break; 8439 case MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET: 8440 reason_str = "internal device reset"; 8441 break; 8442 case MPI26_EVENT_PCIDEV_STAT_RC_TASK_ABORT_INTERNAL: 8443 reason_str = "internal task abort"; 8444 break; 8445 case MPI26_EVENT_PCIDEV_STAT_RC_ABORT_TASK_SET_INTERNAL: 8446 reason_str = "internal task abort set"; 8447 break; 8448 case MPI26_EVENT_PCIDEV_STAT_RC_CLEAR_TASK_SET_INTERNAL: 8449 reason_str = "internal clear task set"; 8450 break; 8451 case MPI26_EVENT_PCIDEV_STAT_RC_QUERY_TASK_INTERNAL: 8452 reason_str = "internal query task"; 8453 break; 8454 case MPI26_EVENT_PCIDEV_STAT_RC_DEV_INIT_FAILURE: 8455 reason_str = "device init failure"; 8456 break; 8457 case MPI26_EVENT_PCIDEV_STAT_RC_CMP_INTERNAL_DEV_RESET: 8458 reason_str = "internal device reset complete"; 8459 break; 8460 case MPI26_EVENT_PCIDEV_STAT_RC_CMP_TASK_ABORT_INTERNAL: 8461 reason_str = "internal task abort complete"; 8462 break; 8463 case MPI26_EVENT_PCIDEV_STAT_RC_ASYNC_NOTIFICATION: 8464 reason_str = "internal async notification"; 8465 break; 8466 case MPI26_EVENT_PCIDEV_STAT_RC_PCIE_HOT_RESET_FAILED: 8467 reason_str = "pcie hot reset failed"; 8468 break; 8469 default: 8470 reason_str = "unknown reason"; 8471 break; 8472 } 8473 8474 ioc_info(ioc, "PCIE device status change: (%s)\n" 8475 "\thandle(0x%04x), WWID(0x%016llx), tag(%d)", 8476 reason_str, le16_to_cpu(event_data->DevHandle), 8477 (u64)le64_to_cpu(event_data->WWID), 8478 le16_to_cpu(event_data->TaskTag)); 8479 if (event_data->ReasonCode == MPI26_EVENT_PCIDEV_STAT_RC_SMART_DATA) 8480 pr_cont(", ASC(0x%x), ASCQ(0x%x)\n", 8481 event_data->ASC, event_data->ASCQ); 8482 pr_cont("\n"); 8483 } 8484 8485 /** 8486 * _scsih_pcie_device_status_change_event - handle device status 8487 * change 8488 * @ioc: per adapter object 8489 * @fw_event: The fw_event_work object 8490 * Context: user. 8491 */ 8492 static void 8493 _scsih_pcie_device_status_change_event(struct MPT3SAS_ADAPTER *ioc, 8494 struct fw_event_work *fw_event) 8495 { 8496 struct MPT3SAS_TARGET *target_priv_data; 8497 struct _pcie_device *pcie_device; 8498 u64 wwid; 8499 unsigned long flags; 8500 Mpi26EventDataPCIeDeviceStatusChange_t *event_data = 8501 (Mpi26EventDataPCIeDeviceStatusChange_t *)fw_event->event_data; 8502 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 8503 _scsih_pcie_device_status_change_event_debug(ioc, 8504 event_data); 8505 8506 if (event_data->ReasonCode != 8507 MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET && 8508 event_data->ReasonCode != 8509 MPI26_EVENT_PCIDEV_STAT_RC_CMP_INTERNAL_DEV_RESET) 8510 return; 8511 8512 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 8513 wwid = le64_to_cpu(event_data->WWID); 8514 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid); 8515 8516 if (!pcie_device || !pcie_device->starget) 8517 goto out; 8518 8519 target_priv_data = pcie_device->starget->hostdata; 8520 if (!target_priv_data) 8521 goto out; 8522 8523 if (event_data->ReasonCode == 8524 MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET) 8525 target_priv_data->tm_busy = 1; 8526 else 8527 target_priv_data->tm_busy = 0; 8528 out: 8529 if (pcie_device) 8530 pcie_device_put(pcie_device); 8531 8532 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 8533 } 8534 8535 /** 8536 * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure 8537 * event 8538 * @ioc: per adapter object 8539 * @event_data: event data payload 8540 * Context: user. 8541 */ 8542 static void 8543 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 8544 Mpi2EventDataSasEnclDevStatusChange_t *event_data) 8545 { 8546 char *reason_str = NULL; 8547 8548 switch (event_data->ReasonCode) { 8549 case MPI2_EVENT_SAS_ENCL_RC_ADDED: 8550 reason_str = "enclosure add"; 8551 break; 8552 case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING: 8553 reason_str = "enclosure remove"; 8554 break; 8555 default: 8556 reason_str = "unknown reason"; 8557 break; 8558 } 8559 8560 ioc_info(ioc, "enclosure status change: (%s)\n" 8561 "\thandle(0x%04x), enclosure logical id(0x%016llx) number slots(%d)\n", 8562 reason_str, 8563 le16_to_cpu(event_data->EnclosureHandle), 8564 (u64)le64_to_cpu(event_data->EnclosureLogicalID), 8565 le16_to_cpu(event_data->StartSlot)); 8566 } 8567 8568 /** 8569 * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events 8570 * @ioc: per adapter object 8571 * @fw_event: The fw_event_work object 8572 * Context: user. 8573 */ 8574 static void 8575 _scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc, 8576 struct fw_event_work *fw_event) 8577 { 8578 Mpi2ConfigReply_t mpi_reply; 8579 struct _enclosure_node *enclosure_dev = NULL; 8580 Mpi2EventDataSasEnclDevStatusChange_t *event_data = 8581 (Mpi2EventDataSasEnclDevStatusChange_t *)fw_event->event_data; 8582 int rc; 8583 u16 enclosure_handle = le16_to_cpu(event_data->EnclosureHandle); 8584 8585 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 8586 _scsih_sas_enclosure_dev_status_change_event_debug(ioc, 8587 (Mpi2EventDataSasEnclDevStatusChange_t *) 8588 fw_event->event_data); 8589 if (ioc->shost_recovery) 8590 return; 8591 8592 if (enclosure_handle) 8593 enclosure_dev = 8594 mpt3sas_scsih_enclosure_find_by_handle(ioc, 8595 enclosure_handle); 8596 switch (event_data->ReasonCode) { 8597 case MPI2_EVENT_SAS_ENCL_RC_ADDED: 8598 if (!enclosure_dev) { 8599 enclosure_dev = 8600 kzalloc(sizeof(struct _enclosure_node), 8601 GFP_KERNEL); 8602 if (!enclosure_dev) { 8603 ioc_info(ioc, "failure at %s:%d/%s()!\n", 8604 __FILE__, __LINE__, __func__); 8605 return; 8606 } 8607 rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply, 8608 &enclosure_dev->pg0, 8609 MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE, 8610 enclosure_handle); 8611 8612 if (rc || (le16_to_cpu(mpi_reply.IOCStatus) & 8613 MPI2_IOCSTATUS_MASK)) { 8614 kfree(enclosure_dev); 8615 return; 8616 } 8617 8618 list_add_tail(&enclosure_dev->list, 8619 &ioc->enclosure_list); 8620 } 8621 break; 8622 case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING: 8623 if (enclosure_dev) { 8624 list_del(&enclosure_dev->list); 8625 kfree(enclosure_dev); 8626 } 8627 break; 8628 default: 8629 break; 8630 } 8631 } 8632 8633 /** 8634 * _scsih_sas_broadcast_primitive_event - handle broadcast events 8635 * @ioc: per adapter object 8636 * @fw_event: The fw_event_work object 8637 * Context: user. 8638 */ 8639 static void 8640 _scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc, 8641 struct fw_event_work *fw_event) 8642 { 8643 struct scsi_cmnd *scmd; 8644 struct scsi_device *sdev; 8645 struct scsiio_tracker *st; 8646 u16 smid, handle; 8647 u32 lun; 8648 struct MPT3SAS_DEVICE *sas_device_priv_data; 8649 u32 termination_count; 8650 u32 query_count; 8651 Mpi2SCSITaskManagementReply_t *mpi_reply; 8652 Mpi2EventDataSasBroadcastPrimitive_t *event_data = 8653 (Mpi2EventDataSasBroadcastPrimitive_t *) 8654 fw_event->event_data; 8655 u16 ioc_status; 8656 unsigned long flags; 8657 int r; 8658 u8 max_retries = 0; 8659 u8 task_abort_retries; 8660 8661 mutex_lock(&ioc->tm_cmds.mutex); 8662 ioc_info(ioc, "%s: enter: phy number(%d), width(%d)\n", 8663 __func__, event_data->PhyNum, event_data->PortWidth); 8664 8665 _scsih_block_io_all_device(ioc); 8666 8667 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8668 mpi_reply = ioc->tm_cmds.reply; 8669 broadcast_aen_retry: 8670 8671 /* sanity checks for retrying this loop */ 8672 if (max_retries++ == 5) { 8673 dewtprintk(ioc, ioc_info(ioc, "%s: giving up\n", __func__)); 8674 goto out; 8675 } else if (max_retries > 1) 8676 dewtprintk(ioc, 8677 ioc_info(ioc, "%s: %d retry\n", 8678 __func__, max_retries - 1)); 8679 8680 termination_count = 0; 8681 query_count = 0; 8682 for (smid = 1; smid <= ioc->scsiio_depth; smid++) { 8683 if (ioc->shost_recovery) 8684 goto out; 8685 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid); 8686 if (!scmd) 8687 continue; 8688 st = scsi_cmd_priv(scmd); 8689 sdev = scmd->device; 8690 sas_device_priv_data = sdev->hostdata; 8691 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) 8692 continue; 8693 /* skip hidden raid components */ 8694 if (sas_device_priv_data->sas_target->flags & 8695 MPT_TARGET_FLAGS_RAID_COMPONENT) 8696 continue; 8697 /* skip volumes */ 8698 if (sas_device_priv_data->sas_target->flags & 8699 MPT_TARGET_FLAGS_VOLUME) 8700 continue; 8701 /* skip PCIe devices */ 8702 if (sas_device_priv_data->sas_target->flags & 8703 MPT_TARGET_FLAGS_PCIE_DEVICE) 8704 continue; 8705 8706 handle = sas_device_priv_data->sas_target->handle; 8707 lun = sas_device_priv_data->lun; 8708 query_count++; 8709 8710 if (ioc->shost_recovery) 8711 goto out; 8712 8713 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 8714 r = mpt3sas_scsih_issue_tm(ioc, handle, 0, 0, lun, 8715 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, st->smid, 8716 st->msix_io, 30, 0); 8717 if (r == FAILED) { 8718 sdev_printk(KERN_WARNING, sdev, 8719 "mpt3sas_scsih_issue_tm: FAILED when sending " 8720 "QUERY_TASK: scmd(%p)\n", scmd); 8721 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8722 goto broadcast_aen_retry; 8723 } 8724 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) 8725 & MPI2_IOCSTATUS_MASK; 8726 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 8727 sdev_printk(KERN_WARNING, sdev, 8728 "query task: FAILED with IOCSTATUS(0x%04x), scmd(%p)\n", 8729 ioc_status, scmd); 8730 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8731 goto broadcast_aen_retry; 8732 } 8733 8734 /* see if IO is still owned by IOC and target */ 8735 if (mpi_reply->ResponseCode == 8736 MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED || 8737 mpi_reply->ResponseCode == 8738 MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) { 8739 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8740 continue; 8741 } 8742 task_abort_retries = 0; 8743 tm_retry: 8744 if (task_abort_retries++ == 60) { 8745 dewtprintk(ioc, 8746 ioc_info(ioc, "%s: ABORT_TASK: giving up\n", 8747 __func__)); 8748 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8749 goto broadcast_aen_retry; 8750 } 8751 8752 if (ioc->shost_recovery) 8753 goto out_no_lock; 8754 8755 r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id, 8756 sdev->lun, MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, 8757 st->smid, st->msix_io, 30, 0); 8758 if (r == FAILED || st->cb_idx != 0xFF) { 8759 sdev_printk(KERN_WARNING, sdev, 8760 "mpt3sas_scsih_issue_tm: ABORT_TASK: FAILED : " 8761 "scmd(%p)\n", scmd); 8762 goto tm_retry; 8763 } 8764 8765 if (task_abort_retries > 1) 8766 sdev_printk(KERN_WARNING, sdev, 8767 "mpt3sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):" 8768 " scmd(%p)\n", 8769 task_abort_retries - 1, scmd); 8770 8771 termination_count += le32_to_cpu(mpi_reply->TerminationCount); 8772 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8773 } 8774 8775 if (ioc->broadcast_aen_pending) { 8776 dewtprintk(ioc, 8777 ioc_info(ioc, 8778 "%s: loop back due to pending AEN\n", 8779 __func__)); 8780 ioc->broadcast_aen_pending = 0; 8781 goto broadcast_aen_retry; 8782 } 8783 8784 out: 8785 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 8786 out_no_lock: 8787 8788 dewtprintk(ioc, 8789 ioc_info(ioc, "%s - exit, query_count = %d termination_count = %d\n", 8790 __func__, query_count, termination_count)); 8791 8792 ioc->broadcast_aen_busy = 0; 8793 if (!ioc->shost_recovery) 8794 _scsih_ublock_io_all_device(ioc); 8795 mutex_unlock(&ioc->tm_cmds.mutex); 8796 } 8797 8798 /** 8799 * _scsih_sas_discovery_event - handle discovery events 8800 * @ioc: per adapter object 8801 * @fw_event: The fw_event_work object 8802 * Context: user. 8803 */ 8804 static void 8805 _scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc, 8806 struct fw_event_work *fw_event) 8807 { 8808 Mpi2EventDataSasDiscovery_t *event_data = 8809 (Mpi2EventDataSasDiscovery_t *) fw_event->event_data; 8810 8811 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) { 8812 ioc_info(ioc, "discovery event: (%s)", 8813 event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED ? 8814 "start" : "stop"); 8815 if (event_data->DiscoveryStatus) 8816 pr_cont("discovery_status(0x%08x)", 8817 le32_to_cpu(event_data->DiscoveryStatus)); 8818 pr_cont("\n"); 8819 } 8820 8821 if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED && 8822 !ioc->sas_hba.num_phys) { 8823 if (disable_discovery > 0 && ioc->shost_recovery) { 8824 /* Wait for the reset to complete */ 8825 while (ioc->shost_recovery) 8826 ssleep(1); 8827 } 8828 _scsih_sas_host_add(ioc); 8829 } 8830 } 8831 8832 /** 8833 * _scsih_sas_device_discovery_error_event - display SAS device discovery error 8834 * events 8835 * @ioc: per adapter object 8836 * @fw_event: The fw_event_work object 8837 * Context: user. 8838 */ 8839 static void 8840 _scsih_sas_device_discovery_error_event(struct MPT3SAS_ADAPTER *ioc, 8841 struct fw_event_work *fw_event) 8842 { 8843 Mpi25EventDataSasDeviceDiscoveryError_t *event_data = 8844 (Mpi25EventDataSasDeviceDiscoveryError_t *)fw_event->event_data; 8845 8846 switch (event_data->ReasonCode) { 8847 case MPI25_EVENT_SAS_DISC_ERR_SMP_FAILED: 8848 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has failed\n", 8849 le16_to_cpu(event_data->DevHandle), 8850 (u64)le64_to_cpu(event_data->SASAddress), 8851 event_data->PhysicalPort); 8852 break; 8853 case MPI25_EVENT_SAS_DISC_ERR_SMP_TIMEOUT: 8854 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has timed out\n", 8855 le16_to_cpu(event_data->DevHandle), 8856 (u64)le64_to_cpu(event_data->SASAddress), 8857 event_data->PhysicalPort); 8858 break; 8859 default: 8860 break; 8861 } 8862 } 8863 8864 /** 8865 * _scsih_pcie_enumeration_event - handle enumeration events 8866 * @ioc: per adapter object 8867 * @fw_event: The fw_event_work object 8868 * Context: user. 8869 */ 8870 static void 8871 _scsih_pcie_enumeration_event(struct MPT3SAS_ADAPTER *ioc, 8872 struct fw_event_work *fw_event) 8873 { 8874 Mpi26EventDataPCIeEnumeration_t *event_data = 8875 (Mpi26EventDataPCIeEnumeration_t *)fw_event->event_data; 8876 8877 if (!(ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)) 8878 return; 8879 8880 ioc_info(ioc, "pcie enumeration event: (%s) Flag 0x%02x", 8881 (event_data->ReasonCode == MPI26_EVENT_PCIE_ENUM_RC_STARTED) ? 8882 "started" : "completed", 8883 event_data->Flags); 8884 if (event_data->EnumerationStatus) 8885 pr_cont("enumeration_status(0x%08x)", 8886 le32_to_cpu(event_data->EnumerationStatus)); 8887 pr_cont("\n"); 8888 } 8889 8890 /** 8891 * _scsih_ir_fastpath - turn on fastpath for IR physdisk 8892 * @ioc: per adapter object 8893 * @handle: device handle for physical disk 8894 * @phys_disk_num: physical disk number 8895 * 8896 * Return: 0 for success, else failure. 8897 */ 8898 static int 8899 _scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num) 8900 { 8901 Mpi2RaidActionRequest_t *mpi_request; 8902 Mpi2RaidActionReply_t *mpi_reply; 8903 u16 smid; 8904 u8 issue_reset = 0; 8905 int rc = 0; 8906 u16 ioc_status; 8907 u32 log_info; 8908 8909 if (ioc->hba_mpi_version_belonged == MPI2_VERSION) 8910 return rc; 8911 8912 mutex_lock(&ioc->scsih_cmds.mutex); 8913 8914 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) { 8915 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__); 8916 rc = -EAGAIN; 8917 goto out; 8918 } 8919 ioc->scsih_cmds.status = MPT3_CMD_PENDING; 8920 8921 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx); 8922 if (!smid) { 8923 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__); 8924 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 8925 rc = -EAGAIN; 8926 goto out; 8927 } 8928 8929 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 8930 ioc->scsih_cmds.smid = smid; 8931 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t)); 8932 8933 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION; 8934 mpi_request->Action = MPI2_RAID_ACTION_PHYSDISK_HIDDEN; 8935 mpi_request->PhysDiskNum = phys_disk_num; 8936 8937 dewtprintk(ioc, 8938 ioc_info(ioc, "IR RAID_ACTION: turning fast path on for handle(0x%04x), phys_disk_num (0x%02x)\n", 8939 handle, phys_disk_num)); 8940 8941 init_completion(&ioc->scsih_cmds.done); 8942 ioc->put_smid_default(ioc, smid); 8943 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ); 8944 8945 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) { 8946 mpt3sas_check_cmd_timeout(ioc, 8947 ioc->scsih_cmds.status, mpi_request, 8948 sizeof(Mpi2RaidActionRequest_t)/4, issue_reset); 8949 rc = -EFAULT; 8950 goto out; 8951 } 8952 8953 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) { 8954 8955 mpi_reply = ioc->scsih_cmds.reply; 8956 ioc_status = le16_to_cpu(mpi_reply->IOCStatus); 8957 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) 8958 log_info = le32_to_cpu(mpi_reply->IOCLogInfo); 8959 else 8960 log_info = 0; 8961 ioc_status &= MPI2_IOCSTATUS_MASK; 8962 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 8963 dewtprintk(ioc, 8964 ioc_info(ioc, "IR RAID_ACTION: failed: ioc_status(0x%04x), loginfo(0x%08x)!!!\n", 8965 ioc_status, log_info)); 8966 rc = -EFAULT; 8967 } else 8968 dewtprintk(ioc, 8969 ioc_info(ioc, "IR RAID_ACTION: completed successfully\n")); 8970 } 8971 8972 out: 8973 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 8974 mutex_unlock(&ioc->scsih_cmds.mutex); 8975 8976 if (issue_reset) 8977 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 8978 return rc; 8979 } 8980 8981 /** 8982 * _scsih_reprobe_lun - reprobing lun 8983 * @sdev: scsi device struct 8984 * @no_uld_attach: sdev->no_uld_attach flag setting 8985 * 8986 **/ 8987 static void 8988 _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach) 8989 { 8990 sdev->no_uld_attach = no_uld_attach ? 1 : 0; 8991 sdev_printk(KERN_INFO, sdev, "%s raid component\n", 8992 sdev->no_uld_attach ? "hiding" : "exposing"); 8993 WARN_ON(scsi_device_reprobe(sdev)); 8994 } 8995 8996 /** 8997 * _scsih_sas_volume_add - add new volume 8998 * @ioc: per adapter object 8999 * @element: IR config element data 9000 * Context: user. 9001 */ 9002 static void 9003 _scsih_sas_volume_add(struct MPT3SAS_ADAPTER *ioc, 9004 Mpi2EventIrConfigElement_t *element) 9005 { 9006 struct _raid_device *raid_device; 9007 unsigned long flags; 9008 u64 wwid; 9009 u16 handle = le16_to_cpu(element->VolDevHandle); 9010 int rc; 9011 9012 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid); 9013 if (!wwid) { 9014 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9015 __FILE__, __LINE__, __func__); 9016 return; 9017 } 9018 9019 spin_lock_irqsave(&ioc->raid_device_lock, flags); 9020 raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid); 9021 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 9022 9023 if (raid_device) 9024 return; 9025 9026 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL); 9027 if (!raid_device) { 9028 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9029 __FILE__, __LINE__, __func__); 9030 return; 9031 } 9032 9033 raid_device->id = ioc->sas_id++; 9034 raid_device->channel = RAID_CHANNEL; 9035 raid_device->handle = handle; 9036 raid_device->wwid = wwid; 9037 _scsih_raid_device_add(ioc, raid_device); 9038 if (!ioc->wait_for_discovery_to_complete) { 9039 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 9040 raid_device->id, 0); 9041 if (rc) 9042 _scsih_raid_device_remove(ioc, raid_device); 9043 } else { 9044 spin_lock_irqsave(&ioc->raid_device_lock, flags); 9045 _scsih_determine_boot_device(ioc, raid_device, 1); 9046 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 9047 } 9048 } 9049 9050 /** 9051 * _scsih_sas_volume_delete - delete volume 9052 * @ioc: per adapter object 9053 * @handle: volume device handle 9054 * Context: user. 9055 */ 9056 static void 9057 _scsih_sas_volume_delete(struct MPT3SAS_ADAPTER *ioc, u16 handle) 9058 { 9059 struct _raid_device *raid_device; 9060 unsigned long flags; 9061 struct MPT3SAS_TARGET *sas_target_priv_data; 9062 struct scsi_target *starget = NULL; 9063 9064 spin_lock_irqsave(&ioc->raid_device_lock, flags); 9065 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 9066 if (raid_device) { 9067 if (raid_device->starget) { 9068 starget = raid_device->starget; 9069 sas_target_priv_data = starget->hostdata; 9070 sas_target_priv_data->deleted = 1; 9071 } 9072 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n", 9073 raid_device->handle, (u64)raid_device->wwid); 9074 list_del(&raid_device->list); 9075 kfree(raid_device); 9076 } 9077 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 9078 if (starget) 9079 scsi_remove_target(&starget->dev); 9080 } 9081 9082 /** 9083 * _scsih_sas_pd_expose - expose pd component to /dev/sdX 9084 * @ioc: per adapter object 9085 * @element: IR config element data 9086 * Context: user. 9087 */ 9088 static void 9089 _scsih_sas_pd_expose(struct MPT3SAS_ADAPTER *ioc, 9090 Mpi2EventIrConfigElement_t *element) 9091 { 9092 struct _sas_device *sas_device; 9093 struct scsi_target *starget = NULL; 9094 struct MPT3SAS_TARGET *sas_target_priv_data; 9095 unsigned long flags; 9096 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 9097 9098 spin_lock_irqsave(&ioc->sas_device_lock, flags); 9099 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 9100 if (sas_device) { 9101 sas_device->volume_handle = 0; 9102 sas_device->volume_wwid = 0; 9103 clear_bit(handle, ioc->pd_handles); 9104 if (sas_device->starget && sas_device->starget->hostdata) { 9105 starget = sas_device->starget; 9106 sas_target_priv_data = starget->hostdata; 9107 sas_target_priv_data->flags &= 9108 ~MPT_TARGET_FLAGS_RAID_COMPONENT; 9109 } 9110 } 9111 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 9112 if (!sas_device) 9113 return; 9114 9115 /* exposing raid component */ 9116 if (starget) 9117 starget_for_each_device(starget, NULL, _scsih_reprobe_lun); 9118 9119 sas_device_put(sas_device); 9120 } 9121 9122 /** 9123 * _scsih_sas_pd_hide - hide pd component from /dev/sdX 9124 * @ioc: per adapter object 9125 * @element: IR config element data 9126 * Context: user. 9127 */ 9128 static void 9129 _scsih_sas_pd_hide(struct MPT3SAS_ADAPTER *ioc, 9130 Mpi2EventIrConfigElement_t *element) 9131 { 9132 struct _sas_device *sas_device; 9133 struct scsi_target *starget = NULL; 9134 struct MPT3SAS_TARGET *sas_target_priv_data; 9135 unsigned long flags; 9136 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 9137 u16 volume_handle = 0; 9138 u64 volume_wwid = 0; 9139 9140 mpt3sas_config_get_volume_handle(ioc, handle, &volume_handle); 9141 if (volume_handle) 9142 mpt3sas_config_get_volume_wwid(ioc, volume_handle, 9143 &volume_wwid); 9144 9145 spin_lock_irqsave(&ioc->sas_device_lock, flags); 9146 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 9147 if (sas_device) { 9148 set_bit(handle, ioc->pd_handles); 9149 if (sas_device->starget && sas_device->starget->hostdata) { 9150 starget = sas_device->starget; 9151 sas_target_priv_data = starget->hostdata; 9152 sas_target_priv_data->flags |= 9153 MPT_TARGET_FLAGS_RAID_COMPONENT; 9154 sas_device->volume_handle = volume_handle; 9155 sas_device->volume_wwid = volume_wwid; 9156 } 9157 } 9158 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 9159 if (!sas_device) 9160 return; 9161 9162 /* hiding raid component */ 9163 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum); 9164 9165 if (starget) 9166 starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun); 9167 9168 sas_device_put(sas_device); 9169 } 9170 9171 /** 9172 * _scsih_sas_pd_delete - delete pd component 9173 * @ioc: per adapter object 9174 * @element: IR config element data 9175 * Context: user. 9176 */ 9177 static void 9178 _scsih_sas_pd_delete(struct MPT3SAS_ADAPTER *ioc, 9179 Mpi2EventIrConfigElement_t *element) 9180 { 9181 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 9182 9183 _scsih_device_remove_by_handle(ioc, handle); 9184 } 9185 9186 /** 9187 * _scsih_sas_pd_add - remove pd component 9188 * @ioc: per adapter object 9189 * @element: IR config element data 9190 * Context: user. 9191 */ 9192 static void 9193 _scsih_sas_pd_add(struct MPT3SAS_ADAPTER *ioc, 9194 Mpi2EventIrConfigElement_t *element) 9195 { 9196 struct _sas_device *sas_device; 9197 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 9198 Mpi2ConfigReply_t mpi_reply; 9199 Mpi2SasDevicePage0_t sas_device_pg0; 9200 u32 ioc_status; 9201 u64 sas_address; 9202 u16 parent_handle; 9203 9204 set_bit(handle, ioc->pd_handles); 9205 9206 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 9207 if (sas_device) { 9208 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum); 9209 sas_device_put(sas_device); 9210 return; 9211 } 9212 9213 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 9214 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) { 9215 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9216 __FILE__, __LINE__, __func__); 9217 return; 9218 } 9219 9220 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 9221 MPI2_IOCSTATUS_MASK; 9222 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 9223 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9224 __FILE__, __LINE__, __func__); 9225 return; 9226 } 9227 9228 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 9229 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) 9230 mpt3sas_transport_update_links(ioc, sas_address, handle, 9231 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5, 9232 mpt3sas_get_port_by_id(ioc, 9233 sas_device_pg0.PhysicalPort, 0)); 9234 9235 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum); 9236 _scsih_add_device(ioc, handle, 0, 1); 9237 } 9238 9239 /** 9240 * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events 9241 * @ioc: per adapter object 9242 * @event_data: event data payload 9243 * Context: user. 9244 */ 9245 static void 9246 _scsih_sas_ir_config_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 9247 Mpi2EventDataIrConfigChangeList_t *event_data) 9248 { 9249 Mpi2EventIrConfigElement_t *element; 9250 u8 element_type; 9251 int i; 9252 char *reason_str = NULL, *element_str = NULL; 9253 9254 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 9255 9256 ioc_info(ioc, "raid config change: (%s), elements(%d)\n", 9257 le32_to_cpu(event_data->Flags) & MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG ? 9258 "foreign" : "native", 9259 event_data->NumElements); 9260 for (i = 0; i < event_data->NumElements; i++, element++) { 9261 switch (element->ReasonCode) { 9262 case MPI2_EVENT_IR_CHANGE_RC_ADDED: 9263 reason_str = "add"; 9264 break; 9265 case MPI2_EVENT_IR_CHANGE_RC_REMOVED: 9266 reason_str = "remove"; 9267 break; 9268 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE: 9269 reason_str = "no change"; 9270 break; 9271 case MPI2_EVENT_IR_CHANGE_RC_HIDE: 9272 reason_str = "hide"; 9273 break; 9274 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE: 9275 reason_str = "unhide"; 9276 break; 9277 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED: 9278 reason_str = "volume_created"; 9279 break; 9280 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED: 9281 reason_str = "volume_deleted"; 9282 break; 9283 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED: 9284 reason_str = "pd_created"; 9285 break; 9286 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED: 9287 reason_str = "pd_deleted"; 9288 break; 9289 default: 9290 reason_str = "unknown reason"; 9291 break; 9292 } 9293 element_type = le16_to_cpu(element->ElementFlags) & 9294 MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK; 9295 switch (element_type) { 9296 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT: 9297 element_str = "volume"; 9298 break; 9299 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT: 9300 element_str = "phys disk"; 9301 break; 9302 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT: 9303 element_str = "hot spare"; 9304 break; 9305 default: 9306 element_str = "unknown element"; 9307 break; 9308 } 9309 pr_info("\t(%s:%s), vol handle(0x%04x), " \ 9310 "pd handle(0x%04x), pd num(0x%02x)\n", element_str, 9311 reason_str, le16_to_cpu(element->VolDevHandle), 9312 le16_to_cpu(element->PhysDiskDevHandle), 9313 element->PhysDiskNum); 9314 } 9315 } 9316 9317 /** 9318 * _scsih_sas_ir_config_change_event - handle ir configuration change events 9319 * @ioc: per adapter object 9320 * @fw_event: The fw_event_work object 9321 * Context: user. 9322 */ 9323 static void 9324 _scsih_sas_ir_config_change_event(struct MPT3SAS_ADAPTER *ioc, 9325 struct fw_event_work *fw_event) 9326 { 9327 Mpi2EventIrConfigElement_t *element; 9328 int i; 9329 u8 foreign_config; 9330 Mpi2EventDataIrConfigChangeList_t *event_data = 9331 (Mpi2EventDataIrConfigChangeList_t *) 9332 fw_event->event_data; 9333 9334 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) && 9335 (!ioc->hide_ir_msg)) 9336 _scsih_sas_ir_config_change_event_debug(ioc, event_data); 9337 9338 foreign_config = (le32_to_cpu(event_data->Flags) & 9339 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0; 9340 9341 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 9342 if (ioc->shost_recovery && 9343 ioc->hba_mpi_version_belonged != MPI2_VERSION) { 9344 for (i = 0; i < event_data->NumElements; i++, element++) { 9345 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_HIDE) 9346 _scsih_ir_fastpath(ioc, 9347 le16_to_cpu(element->PhysDiskDevHandle), 9348 element->PhysDiskNum); 9349 } 9350 return; 9351 } 9352 9353 for (i = 0; i < event_data->NumElements; i++, element++) { 9354 9355 switch (element->ReasonCode) { 9356 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED: 9357 case MPI2_EVENT_IR_CHANGE_RC_ADDED: 9358 if (!foreign_config) 9359 _scsih_sas_volume_add(ioc, element); 9360 break; 9361 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED: 9362 case MPI2_EVENT_IR_CHANGE_RC_REMOVED: 9363 if (!foreign_config) 9364 _scsih_sas_volume_delete(ioc, 9365 le16_to_cpu(element->VolDevHandle)); 9366 break; 9367 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED: 9368 if (!ioc->is_warpdrive) 9369 _scsih_sas_pd_hide(ioc, element); 9370 break; 9371 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED: 9372 if (!ioc->is_warpdrive) 9373 _scsih_sas_pd_expose(ioc, element); 9374 break; 9375 case MPI2_EVENT_IR_CHANGE_RC_HIDE: 9376 if (!ioc->is_warpdrive) 9377 _scsih_sas_pd_add(ioc, element); 9378 break; 9379 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE: 9380 if (!ioc->is_warpdrive) 9381 _scsih_sas_pd_delete(ioc, element); 9382 break; 9383 } 9384 } 9385 } 9386 9387 /** 9388 * _scsih_sas_ir_volume_event - IR volume event 9389 * @ioc: per adapter object 9390 * @fw_event: The fw_event_work object 9391 * Context: user. 9392 */ 9393 static void 9394 _scsih_sas_ir_volume_event(struct MPT3SAS_ADAPTER *ioc, 9395 struct fw_event_work *fw_event) 9396 { 9397 u64 wwid; 9398 unsigned long flags; 9399 struct _raid_device *raid_device; 9400 u16 handle; 9401 u32 state; 9402 int rc; 9403 Mpi2EventDataIrVolume_t *event_data = 9404 (Mpi2EventDataIrVolume_t *) fw_event->event_data; 9405 9406 if (ioc->shost_recovery) 9407 return; 9408 9409 if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED) 9410 return; 9411 9412 handle = le16_to_cpu(event_data->VolDevHandle); 9413 state = le32_to_cpu(event_data->NewValue); 9414 if (!ioc->hide_ir_msg) 9415 dewtprintk(ioc, 9416 ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n", 9417 __func__, handle, 9418 le32_to_cpu(event_data->PreviousValue), 9419 state)); 9420 switch (state) { 9421 case MPI2_RAID_VOL_STATE_MISSING: 9422 case MPI2_RAID_VOL_STATE_FAILED: 9423 _scsih_sas_volume_delete(ioc, handle); 9424 break; 9425 9426 case MPI2_RAID_VOL_STATE_ONLINE: 9427 case MPI2_RAID_VOL_STATE_DEGRADED: 9428 case MPI2_RAID_VOL_STATE_OPTIMAL: 9429 9430 spin_lock_irqsave(&ioc->raid_device_lock, flags); 9431 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 9432 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 9433 9434 if (raid_device) 9435 break; 9436 9437 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid); 9438 if (!wwid) { 9439 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9440 __FILE__, __LINE__, __func__); 9441 break; 9442 } 9443 9444 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL); 9445 if (!raid_device) { 9446 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9447 __FILE__, __LINE__, __func__); 9448 break; 9449 } 9450 9451 raid_device->id = ioc->sas_id++; 9452 raid_device->channel = RAID_CHANNEL; 9453 raid_device->handle = handle; 9454 raid_device->wwid = wwid; 9455 _scsih_raid_device_add(ioc, raid_device); 9456 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 9457 raid_device->id, 0); 9458 if (rc) 9459 _scsih_raid_device_remove(ioc, raid_device); 9460 break; 9461 9462 case MPI2_RAID_VOL_STATE_INITIALIZING: 9463 default: 9464 break; 9465 } 9466 } 9467 9468 /** 9469 * _scsih_sas_ir_physical_disk_event - PD event 9470 * @ioc: per adapter object 9471 * @fw_event: The fw_event_work object 9472 * Context: user. 9473 */ 9474 static void 9475 _scsih_sas_ir_physical_disk_event(struct MPT3SAS_ADAPTER *ioc, 9476 struct fw_event_work *fw_event) 9477 { 9478 u16 handle, parent_handle; 9479 u32 state; 9480 struct _sas_device *sas_device; 9481 Mpi2ConfigReply_t mpi_reply; 9482 Mpi2SasDevicePage0_t sas_device_pg0; 9483 u32 ioc_status; 9484 Mpi2EventDataIrPhysicalDisk_t *event_data = 9485 (Mpi2EventDataIrPhysicalDisk_t *) fw_event->event_data; 9486 u64 sas_address; 9487 9488 if (ioc->shost_recovery) 9489 return; 9490 9491 if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED) 9492 return; 9493 9494 handle = le16_to_cpu(event_data->PhysDiskDevHandle); 9495 state = le32_to_cpu(event_data->NewValue); 9496 9497 if (!ioc->hide_ir_msg) 9498 dewtprintk(ioc, 9499 ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n", 9500 __func__, handle, 9501 le32_to_cpu(event_data->PreviousValue), 9502 state)); 9503 9504 switch (state) { 9505 case MPI2_RAID_PD_STATE_ONLINE: 9506 case MPI2_RAID_PD_STATE_DEGRADED: 9507 case MPI2_RAID_PD_STATE_REBUILDING: 9508 case MPI2_RAID_PD_STATE_OPTIMAL: 9509 case MPI2_RAID_PD_STATE_HOT_SPARE: 9510 9511 if (!ioc->is_warpdrive) 9512 set_bit(handle, ioc->pd_handles); 9513 9514 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 9515 if (sas_device) { 9516 sas_device_put(sas_device); 9517 return; 9518 } 9519 9520 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 9521 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, 9522 handle))) { 9523 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9524 __FILE__, __LINE__, __func__); 9525 return; 9526 } 9527 9528 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 9529 MPI2_IOCSTATUS_MASK; 9530 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 9531 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9532 __FILE__, __LINE__, __func__); 9533 return; 9534 } 9535 9536 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 9537 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) 9538 mpt3sas_transport_update_links(ioc, sas_address, handle, 9539 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5, 9540 mpt3sas_get_port_by_id(ioc, 9541 sas_device_pg0.PhysicalPort, 0)); 9542 9543 _scsih_add_device(ioc, handle, 0, 1); 9544 9545 break; 9546 9547 case MPI2_RAID_PD_STATE_OFFLINE: 9548 case MPI2_RAID_PD_STATE_NOT_CONFIGURED: 9549 case MPI2_RAID_PD_STATE_NOT_COMPATIBLE: 9550 default: 9551 break; 9552 } 9553 } 9554 9555 /** 9556 * _scsih_sas_ir_operation_status_event_debug - debug for IR op event 9557 * @ioc: per adapter object 9558 * @event_data: event data payload 9559 * Context: user. 9560 */ 9561 static void 9562 _scsih_sas_ir_operation_status_event_debug(struct MPT3SAS_ADAPTER *ioc, 9563 Mpi2EventDataIrOperationStatus_t *event_data) 9564 { 9565 char *reason_str = NULL; 9566 9567 switch (event_data->RAIDOperation) { 9568 case MPI2_EVENT_IR_RAIDOP_RESYNC: 9569 reason_str = "resync"; 9570 break; 9571 case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION: 9572 reason_str = "online capacity expansion"; 9573 break; 9574 case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK: 9575 reason_str = "consistency check"; 9576 break; 9577 case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT: 9578 reason_str = "background init"; 9579 break; 9580 case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT: 9581 reason_str = "make data consistent"; 9582 break; 9583 } 9584 9585 if (!reason_str) 9586 return; 9587 9588 ioc_info(ioc, "raid operational status: (%s)\thandle(0x%04x), percent complete(%d)\n", 9589 reason_str, 9590 le16_to_cpu(event_data->VolDevHandle), 9591 event_data->PercentComplete); 9592 } 9593 9594 /** 9595 * _scsih_sas_ir_operation_status_event - handle RAID operation events 9596 * @ioc: per adapter object 9597 * @fw_event: The fw_event_work object 9598 * Context: user. 9599 */ 9600 static void 9601 _scsih_sas_ir_operation_status_event(struct MPT3SAS_ADAPTER *ioc, 9602 struct fw_event_work *fw_event) 9603 { 9604 Mpi2EventDataIrOperationStatus_t *event_data = 9605 (Mpi2EventDataIrOperationStatus_t *) 9606 fw_event->event_data; 9607 static struct _raid_device *raid_device; 9608 unsigned long flags; 9609 u16 handle; 9610 9611 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) && 9612 (!ioc->hide_ir_msg)) 9613 _scsih_sas_ir_operation_status_event_debug(ioc, 9614 event_data); 9615 9616 /* code added for raid transport support */ 9617 if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) { 9618 9619 spin_lock_irqsave(&ioc->raid_device_lock, flags); 9620 handle = le16_to_cpu(event_data->VolDevHandle); 9621 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 9622 if (raid_device) 9623 raid_device->percent_complete = 9624 event_data->PercentComplete; 9625 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 9626 } 9627 } 9628 9629 /** 9630 * _scsih_prep_device_scan - initialize parameters prior to device scan 9631 * @ioc: per adapter object 9632 * 9633 * Set the deleted flag prior to device scan. If the device is found during 9634 * the scan, then we clear the deleted flag. 9635 */ 9636 static void 9637 _scsih_prep_device_scan(struct MPT3SAS_ADAPTER *ioc) 9638 { 9639 struct MPT3SAS_DEVICE *sas_device_priv_data; 9640 struct scsi_device *sdev; 9641 9642 shost_for_each_device(sdev, ioc->shost) { 9643 sas_device_priv_data = sdev->hostdata; 9644 if (sas_device_priv_data && sas_device_priv_data->sas_target) 9645 sas_device_priv_data->sas_target->deleted = 1; 9646 } 9647 } 9648 9649 /** 9650 * _scsih_update_device_qdepth - Update QD during Reset. 9651 * @ioc: per adapter object 9652 * 9653 */ 9654 static void 9655 _scsih_update_device_qdepth(struct MPT3SAS_ADAPTER *ioc) 9656 { 9657 struct MPT3SAS_DEVICE *sas_device_priv_data; 9658 struct MPT3SAS_TARGET *sas_target_priv_data; 9659 struct _sas_device *sas_device; 9660 struct scsi_device *sdev; 9661 u16 qdepth; 9662 9663 ioc_info(ioc, "Update devices with firmware reported queue depth\n"); 9664 shost_for_each_device(sdev, ioc->shost) { 9665 sas_device_priv_data = sdev->hostdata; 9666 if (sas_device_priv_data && sas_device_priv_data->sas_target) { 9667 sas_target_priv_data = sas_device_priv_data->sas_target; 9668 sas_device = sas_device_priv_data->sas_target->sas_dev; 9669 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) 9670 qdepth = ioc->max_nvme_qd; 9671 else if (sas_device && 9672 sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) 9673 qdepth = (sas_device->port_type > 1) ? 9674 ioc->max_wideport_qd : ioc->max_narrowport_qd; 9675 else if (sas_device && 9676 sas_device->device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE) 9677 qdepth = ioc->max_sata_qd; 9678 else 9679 continue; 9680 mpt3sas_scsih_change_queue_depth(sdev, qdepth); 9681 } 9682 } 9683 } 9684 9685 /** 9686 * _scsih_mark_responding_sas_device - mark a sas_devices as responding 9687 * @ioc: per adapter object 9688 * @sas_device_pg0: SAS Device page 0 9689 * 9690 * After host reset, find out whether devices are still responding. 9691 * Used in _scsih_remove_unresponsive_sas_devices. 9692 */ 9693 static void 9694 _scsih_mark_responding_sas_device(struct MPT3SAS_ADAPTER *ioc, 9695 Mpi2SasDevicePage0_t *sas_device_pg0) 9696 { 9697 struct MPT3SAS_TARGET *sas_target_priv_data = NULL; 9698 struct scsi_target *starget; 9699 struct _sas_device *sas_device = NULL; 9700 struct _enclosure_node *enclosure_dev = NULL; 9701 unsigned long flags; 9702 struct hba_port *port = mpt3sas_get_port_by_id( 9703 ioc, sas_device_pg0->PhysicalPort, 0); 9704 9705 if (sas_device_pg0->EnclosureHandle) { 9706 enclosure_dev = 9707 mpt3sas_scsih_enclosure_find_by_handle(ioc, 9708 le16_to_cpu(sas_device_pg0->EnclosureHandle)); 9709 if (enclosure_dev == NULL) 9710 ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n", 9711 sas_device_pg0->EnclosureHandle); 9712 } 9713 spin_lock_irqsave(&ioc->sas_device_lock, flags); 9714 list_for_each_entry(sas_device, &ioc->sas_device_list, list) { 9715 if (sas_device->sas_address != le64_to_cpu( 9716 sas_device_pg0->SASAddress)) 9717 continue; 9718 if (sas_device->slot != le16_to_cpu(sas_device_pg0->Slot)) 9719 continue; 9720 if (sas_device->port != port) 9721 continue; 9722 sas_device->responding = 1; 9723 starget = sas_device->starget; 9724 if (starget && starget->hostdata) { 9725 sas_target_priv_data = starget->hostdata; 9726 sas_target_priv_data->tm_busy = 0; 9727 sas_target_priv_data->deleted = 0; 9728 } else 9729 sas_target_priv_data = NULL; 9730 if (starget) { 9731 starget_printk(KERN_INFO, starget, 9732 "handle(0x%04x), sas_addr(0x%016llx)\n", 9733 le16_to_cpu(sas_device_pg0->DevHandle), 9734 (unsigned long long) 9735 sas_device->sas_address); 9736 9737 if (sas_device->enclosure_handle != 0) 9738 starget_printk(KERN_INFO, starget, 9739 "enclosure logical id(0x%016llx), slot(%d)\n", 9740 (unsigned long long) 9741 sas_device->enclosure_logical_id, 9742 sas_device->slot); 9743 } 9744 if (le16_to_cpu(sas_device_pg0->Flags) & 9745 MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) { 9746 sas_device->enclosure_level = 9747 sas_device_pg0->EnclosureLevel; 9748 memcpy(&sas_device->connector_name[0], 9749 &sas_device_pg0->ConnectorName[0], 4); 9750 } else { 9751 sas_device->enclosure_level = 0; 9752 sas_device->connector_name[0] = '\0'; 9753 } 9754 9755 sas_device->enclosure_handle = 9756 le16_to_cpu(sas_device_pg0->EnclosureHandle); 9757 sas_device->is_chassis_slot_valid = 0; 9758 if (enclosure_dev) { 9759 sas_device->enclosure_logical_id = le64_to_cpu( 9760 enclosure_dev->pg0.EnclosureLogicalID); 9761 if (le16_to_cpu(enclosure_dev->pg0.Flags) & 9762 MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) { 9763 sas_device->is_chassis_slot_valid = 1; 9764 sas_device->chassis_slot = 9765 enclosure_dev->pg0.ChassisSlot; 9766 } 9767 } 9768 9769 if (sas_device->handle == le16_to_cpu( 9770 sas_device_pg0->DevHandle)) 9771 goto out; 9772 pr_info("\thandle changed from(0x%04x)!!!\n", 9773 sas_device->handle); 9774 sas_device->handle = le16_to_cpu( 9775 sas_device_pg0->DevHandle); 9776 if (sas_target_priv_data) 9777 sas_target_priv_data->handle = 9778 le16_to_cpu(sas_device_pg0->DevHandle); 9779 goto out; 9780 } 9781 out: 9782 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 9783 } 9784 9785 /** 9786 * _scsih_create_enclosure_list_after_reset - Free Existing list, 9787 * And create enclosure list by scanning all Enclosure Page(0)s 9788 * @ioc: per adapter object 9789 */ 9790 static void 9791 _scsih_create_enclosure_list_after_reset(struct MPT3SAS_ADAPTER *ioc) 9792 { 9793 struct _enclosure_node *enclosure_dev; 9794 Mpi2ConfigReply_t mpi_reply; 9795 u16 enclosure_handle; 9796 int rc; 9797 9798 /* Free existing enclosure list */ 9799 mpt3sas_free_enclosure_list(ioc); 9800 9801 /* Re constructing enclosure list after reset*/ 9802 enclosure_handle = 0xFFFF; 9803 do { 9804 enclosure_dev = 9805 kzalloc(sizeof(struct _enclosure_node), GFP_KERNEL); 9806 if (!enclosure_dev) { 9807 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9808 __FILE__, __LINE__, __func__); 9809 return; 9810 } 9811 rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply, 9812 &enclosure_dev->pg0, 9813 MPI2_SAS_ENCLOS_PGAD_FORM_GET_NEXT_HANDLE, 9814 enclosure_handle); 9815 9816 if (rc || (le16_to_cpu(mpi_reply.IOCStatus) & 9817 MPI2_IOCSTATUS_MASK)) { 9818 kfree(enclosure_dev); 9819 return; 9820 } 9821 list_add_tail(&enclosure_dev->list, 9822 &ioc->enclosure_list); 9823 enclosure_handle = 9824 le16_to_cpu(enclosure_dev->pg0.EnclosureHandle); 9825 } while (1); 9826 } 9827 9828 /** 9829 * _scsih_search_responding_sas_devices - 9830 * @ioc: per adapter object 9831 * 9832 * After host reset, find out whether devices are still responding. 9833 * If not remove. 9834 */ 9835 static void 9836 _scsih_search_responding_sas_devices(struct MPT3SAS_ADAPTER *ioc) 9837 { 9838 Mpi2SasDevicePage0_t sas_device_pg0; 9839 Mpi2ConfigReply_t mpi_reply; 9840 u16 ioc_status; 9841 u16 handle; 9842 u32 device_info; 9843 9844 ioc_info(ioc, "search for end-devices: start\n"); 9845 9846 if (list_empty(&ioc->sas_device_list)) 9847 goto out; 9848 9849 handle = 0xFFFF; 9850 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 9851 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, 9852 handle))) { 9853 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 9854 MPI2_IOCSTATUS_MASK; 9855 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 9856 break; 9857 handle = le16_to_cpu(sas_device_pg0.DevHandle); 9858 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 9859 if (!(_scsih_is_end_device(device_info))) 9860 continue; 9861 _scsih_mark_responding_sas_device(ioc, &sas_device_pg0); 9862 } 9863 9864 out: 9865 ioc_info(ioc, "search for end-devices: complete\n"); 9866 } 9867 9868 /** 9869 * _scsih_mark_responding_pcie_device - mark a pcie_device as responding 9870 * @ioc: per adapter object 9871 * @pcie_device_pg0: PCIe Device page 0 9872 * 9873 * After host reset, find out whether devices are still responding. 9874 * Used in _scsih_remove_unresponding_devices. 9875 */ 9876 static void 9877 _scsih_mark_responding_pcie_device(struct MPT3SAS_ADAPTER *ioc, 9878 Mpi26PCIeDevicePage0_t *pcie_device_pg0) 9879 { 9880 struct MPT3SAS_TARGET *sas_target_priv_data = NULL; 9881 struct scsi_target *starget; 9882 struct _pcie_device *pcie_device; 9883 unsigned long flags; 9884 9885 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 9886 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) { 9887 if ((pcie_device->wwid == le64_to_cpu(pcie_device_pg0->WWID)) 9888 && (pcie_device->slot == le16_to_cpu( 9889 pcie_device_pg0->Slot))) { 9890 pcie_device->access_status = 9891 pcie_device_pg0->AccessStatus; 9892 pcie_device->responding = 1; 9893 starget = pcie_device->starget; 9894 if (starget && starget->hostdata) { 9895 sas_target_priv_data = starget->hostdata; 9896 sas_target_priv_data->tm_busy = 0; 9897 sas_target_priv_data->deleted = 0; 9898 } else 9899 sas_target_priv_data = NULL; 9900 if (starget) { 9901 starget_printk(KERN_INFO, starget, 9902 "handle(0x%04x), wwid(0x%016llx) ", 9903 pcie_device->handle, 9904 (unsigned long long)pcie_device->wwid); 9905 if (pcie_device->enclosure_handle != 0) 9906 starget_printk(KERN_INFO, starget, 9907 "enclosure logical id(0x%016llx), " 9908 "slot(%d)\n", 9909 (unsigned long long) 9910 pcie_device->enclosure_logical_id, 9911 pcie_device->slot); 9912 } 9913 9914 if (((le32_to_cpu(pcie_device_pg0->Flags)) & 9915 MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) && 9916 (ioc->hba_mpi_version_belonged != MPI2_VERSION)) { 9917 pcie_device->enclosure_level = 9918 pcie_device_pg0->EnclosureLevel; 9919 memcpy(&pcie_device->connector_name[0], 9920 &pcie_device_pg0->ConnectorName[0], 4); 9921 } else { 9922 pcie_device->enclosure_level = 0; 9923 pcie_device->connector_name[0] = '\0'; 9924 } 9925 9926 if (pcie_device->handle == le16_to_cpu( 9927 pcie_device_pg0->DevHandle)) 9928 goto out; 9929 pr_info("\thandle changed from(0x%04x)!!!\n", 9930 pcie_device->handle); 9931 pcie_device->handle = le16_to_cpu( 9932 pcie_device_pg0->DevHandle); 9933 if (sas_target_priv_data) 9934 sas_target_priv_data->handle = 9935 le16_to_cpu(pcie_device_pg0->DevHandle); 9936 goto out; 9937 } 9938 } 9939 9940 out: 9941 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 9942 } 9943 9944 /** 9945 * _scsih_search_responding_pcie_devices - 9946 * @ioc: per adapter object 9947 * 9948 * After host reset, find out whether devices are still responding. 9949 * If not remove. 9950 */ 9951 static void 9952 _scsih_search_responding_pcie_devices(struct MPT3SAS_ADAPTER *ioc) 9953 { 9954 Mpi26PCIeDevicePage0_t pcie_device_pg0; 9955 Mpi2ConfigReply_t mpi_reply; 9956 u16 ioc_status; 9957 u16 handle; 9958 u32 device_info; 9959 9960 ioc_info(ioc, "search for end-devices: start\n"); 9961 9962 if (list_empty(&ioc->pcie_device_list)) 9963 goto out; 9964 9965 handle = 0xFFFF; 9966 while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply, 9967 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, 9968 handle))) { 9969 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 9970 MPI2_IOCSTATUS_MASK; 9971 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 9972 ioc_info(ioc, "\tbreak from %s: ioc_status(0x%04x), loginfo(0x%08x)\n", 9973 __func__, ioc_status, 9974 le32_to_cpu(mpi_reply.IOCLogInfo)); 9975 break; 9976 } 9977 handle = le16_to_cpu(pcie_device_pg0.DevHandle); 9978 device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo); 9979 if (!(_scsih_is_nvme_pciescsi_device(device_info))) 9980 continue; 9981 _scsih_mark_responding_pcie_device(ioc, &pcie_device_pg0); 9982 } 9983 out: 9984 ioc_info(ioc, "search for PCIe end-devices: complete\n"); 9985 } 9986 9987 /** 9988 * _scsih_mark_responding_raid_device - mark a raid_device as responding 9989 * @ioc: per adapter object 9990 * @wwid: world wide identifier for raid volume 9991 * @handle: device handle 9992 * 9993 * After host reset, find out whether devices are still responding. 9994 * Used in _scsih_remove_unresponsive_raid_devices. 9995 */ 9996 static void 9997 _scsih_mark_responding_raid_device(struct MPT3SAS_ADAPTER *ioc, u64 wwid, 9998 u16 handle) 9999 { 10000 struct MPT3SAS_TARGET *sas_target_priv_data = NULL; 10001 struct scsi_target *starget; 10002 struct _raid_device *raid_device; 10003 unsigned long flags; 10004 10005 spin_lock_irqsave(&ioc->raid_device_lock, flags); 10006 list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 10007 if (raid_device->wwid == wwid && raid_device->starget) { 10008 starget = raid_device->starget; 10009 if (starget && starget->hostdata) { 10010 sas_target_priv_data = starget->hostdata; 10011 sas_target_priv_data->deleted = 0; 10012 } else 10013 sas_target_priv_data = NULL; 10014 raid_device->responding = 1; 10015 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 10016 starget_printk(KERN_INFO, raid_device->starget, 10017 "handle(0x%04x), wwid(0x%016llx)\n", handle, 10018 (unsigned long long)raid_device->wwid); 10019 10020 /* 10021 * WARPDRIVE: The handles of the PDs might have changed 10022 * across the host reset so re-initialize the 10023 * required data for Direct IO 10024 */ 10025 mpt3sas_init_warpdrive_properties(ioc, raid_device); 10026 spin_lock_irqsave(&ioc->raid_device_lock, flags); 10027 if (raid_device->handle == handle) { 10028 spin_unlock_irqrestore(&ioc->raid_device_lock, 10029 flags); 10030 return; 10031 } 10032 pr_info("\thandle changed from(0x%04x)!!!\n", 10033 raid_device->handle); 10034 raid_device->handle = handle; 10035 if (sas_target_priv_data) 10036 sas_target_priv_data->handle = handle; 10037 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 10038 return; 10039 } 10040 } 10041 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 10042 } 10043 10044 /** 10045 * _scsih_search_responding_raid_devices - 10046 * @ioc: per adapter object 10047 * 10048 * After host reset, find out whether devices are still responding. 10049 * If not remove. 10050 */ 10051 static void 10052 _scsih_search_responding_raid_devices(struct MPT3SAS_ADAPTER *ioc) 10053 { 10054 Mpi2RaidVolPage1_t volume_pg1; 10055 Mpi2RaidVolPage0_t volume_pg0; 10056 Mpi2RaidPhysDiskPage0_t pd_pg0; 10057 Mpi2ConfigReply_t mpi_reply; 10058 u16 ioc_status; 10059 u16 handle; 10060 u8 phys_disk_num; 10061 10062 if (!ioc->ir_firmware) 10063 return; 10064 10065 ioc_info(ioc, "search for raid volumes: start\n"); 10066 10067 if (list_empty(&ioc->raid_device_list)) 10068 goto out; 10069 10070 handle = 0xFFFF; 10071 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply, 10072 &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) { 10073 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10074 MPI2_IOCSTATUS_MASK; 10075 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 10076 break; 10077 handle = le16_to_cpu(volume_pg1.DevHandle); 10078 10079 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, 10080 &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle, 10081 sizeof(Mpi2RaidVolPage0_t))) 10082 continue; 10083 10084 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL || 10085 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE || 10086 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) 10087 _scsih_mark_responding_raid_device(ioc, 10088 le64_to_cpu(volume_pg1.WWID), handle); 10089 } 10090 10091 /* refresh the pd_handles */ 10092 if (!ioc->is_warpdrive) { 10093 phys_disk_num = 0xFF; 10094 memset(ioc->pd_handles, 0, ioc->pd_handles_sz); 10095 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply, 10096 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM, 10097 phys_disk_num))) { 10098 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10099 MPI2_IOCSTATUS_MASK; 10100 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 10101 break; 10102 phys_disk_num = pd_pg0.PhysDiskNum; 10103 handle = le16_to_cpu(pd_pg0.DevHandle); 10104 set_bit(handle, ioc->pd_handles); 10105 } 10106 } 10107 out: 10108 ioc_info(ioc, "search for responding raid volumes: complete\n"); 10109 } 10110 10111 /** 10112 * _scsih_mark_responding_expander - mark a expander as responding 10113 * @ioc: per adapter object 10114 * @expander_pg0:SAS Expander Config Page0 10115 * 10116 * After host reset, find out whether devices are still responding. 10117 * Used in _scsih_remove_unresponsive_expanders. 10118 */ 10119 static void 10120 _scsih_mark_responding_expander(struct MPT3SAS_ADAPTER *ioc, 10121 Mpi2ExpanderPage0_t *expander_pg0) 10122 { 10123 struct _sas_node *sas_expander = NULL; 10124 unsigned long flags; 10125 int i; 10126 struct _enclosure_node *enclosure_dev = NULL; 10127 u16 handle = le16_to_cpu(expander_pg0->DevHandle); 10128 u16 enclosure_handle = le16_to_cpu(expander_pg0->EnclosureHandle); 10129 u64 sas_address = le64_to_cpu(expander_pg0->SASAddress); 10130 struct hba_port *port = mpt3sas_get_port_by_id( 10131 ioc, expander_pg0->PhysicalPort, 0); 10132 10133 if (enclosure_handle) 10134 enclosure_dev = 10135 mpt3sas_scsih_enclosure_find_by_handle(ioc, 10136 enclosure_handle); 10137 10138 spin_lock_irqsave(&ioc->sas_node_lock, flags); 10139 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) { 10140 if (sas_expander->sas_address != sas_address) 10141 continue; 10142 if (sas_expander->port != port) 10143 continue; 10144 sas_expander->responding = 1; 10145 10146 if (enclosure_dev) { 10147 sas_expander->enclosure_logical_id = 10148 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID); 10149 sas_expander->enclosure_handle = 10150 le16_to_cpu(expander_pg0->EnclosureHandle); 10151 } 10152 10153 if (sas_expander->handle == handle) 10154 goto out; 10155 pr_info("\texpander(0x%016llx): handle changed" \ 10156 " from(0x%04x) to (0x%04x)!!!\n", 10157 (unsigned long long)sas_expander->sas_address, 10158 sas_expander->handle, handle); 10159 sas_expander->handle = handle; 10160 for (i = 0 ; i < sas_expander->num_phys ; i++) 10161 sas_expander->phy[i].handle = handle; 10162 goto out; 10163 } 10164 out: 10165 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 10166 } 10167 10168 /** 10169 * _scsih_search_responding_expanders - 10170 * @ioc: per adapter object 10171 * 10172 * After host reset, find out whether devices are still responding. 10173 * If not remove. 10174 */ 10175 static void 10176 _scsih_search_responding_expanders(struct MPT3SAS_ADAPTER *ioc) 10177 { 10178 Mpi2ExpanderPage0_t expander_pg0; 10179 Mpi2ConfigReply_t mpi_reply; 10180 u16 ioc_status; 10181 u64 sas_address; 10182 u16 handle; 10183 u8 port; 10184 10185 ioc_info(ioc, "search for expanders: start\n"); 10186 10187 if (list_empty(&ioc->sas_expander_list)) 10188 goto out; 10189 10190 handle = 0xFFFF; 10191 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0, 10192 MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) { 10193 10194 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10195 MPI2_IOCSTATUS_MASK; 10196 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 10197 break; 10198 10199 handle = le16_to_cpu(expander_pg0.DevHandle); 10200 sas_address = le64_to_cpu(expander_pg0.SASAddress); 10201 port = expander_pg0.PhysicalPort; 10202 pr_info( 10203 "\texpander present: handle(0x%04x), sas_addr(0x%016llx), port:%d\n", 10204 handle, (unsigned long long)sas_address, 10205 (ioc->multipath_on_hba ? 10206 port : MULTIPATH_DISABLED_PORT_ID)); 10207 _scsih_mark_responding_expander(ioc, &expander_pg0); 10208 } 10209 10210 out: 10211 ioc_info(ioc, "search for expanders: complete\n"); 10212 } 10213 10214 /** 10215 * _scsih_remove_unresponding_devices - removing unresponding devices 10216 * @ioc: per adapter object 10217 */ 10218 static void 10219 _scsih_remove_unresponding_devices(struct MPT3SAS_ADAPTER *ioc) 10220 { 10221 struct _sas_device *sas_device, *sas_device_next; 10222 struct _sas_node *sas_expander, *sas_expander_next; 10223 struct _raid_device *raid_device, *raid_device_next; 10224 struct _pcie_device *pcie_device, *pcie_device_next; 10225 struct list_head tmp_list; 10226 unsigned long flags; 10227 LIST_HEAD(head); 10228 10229 ioc_info(ioc, "removing unresponding devices: start\n"); 10230 10231 /* removing unresponding end devices */ 10232 ioc_info(ioc, "removing unresponding devices: end-devices\n"); 10233 /* 10234 * Iterate, pulling off devices marked as non-responding. We become the 10235 * owner for the reference the list had on any object we prune. 10236 */ 10237 spin_lock_irqsave(&ioc->sas_device_lock, flags); 10238 10239 /* 10240 * Clean up the sas_device_init_list list as 10241 * driver goes for fresh scan as part of diag reset. 10242 */ 10243 list_for_each_entry_safe(sas_device, sas_device_next, 10244 &ioc->sas_device_init_list, list) { 10245 list_del_init(&sas_device->list); 10246 sas_device_put(sas_device); 10247 } 10248 10249 list_for_each_entry_safe(sas_device, sas_device_next, 10250 &ioc->sas_device_list, list) { 10251 if (!sas_device->responding) 10252 list_move_tail(&sas_device->list, &head); 10253 else 10254 sas_device->responding = 0; 10255 } 10256 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 10257 10258 /* 10259 * Now, uninitialize and remove the unresponding devices we pruned. 10260 */ 10261 list_for_each_entry_safe(sas_device, sas_device_next, &head, list) { 10262 _scsih_remove_device(ioc, sas_device); 10263 list_del_init(&sas_device->list); 10264 sas_device_put(sas_device); 10265 } 10266 10267 ioc_info(ioc, "Removing unresponding devices: pcie end-devices\n"); 10268 INIT_LIST_HEAD(&head); 10269 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 10270 /* 10271 * Clean up the pcie_device_init_list list as 10272 * driver goes for fresh scan as part of diag reset. 10273 */ 10274 list_for_each_entry_safe(pcie_device, pcie_device_next, 10275 &ioc->pcie_device_init_list, list) { 10276 list_del_init(&pcie_device->list); 10277 pcie_device_put(pcie_device); 10278 } 10279 10280 list_for_each_entry_safe(pcie_device, pcie_device_next, 10281 &ioc->pcie_device_list, list) { 10282 if (!pcie_device->responding) 10283 list_move_tail(&pcie_device->list, &head); 10284 else 10285 pcie_device->responding = 0; 10286 } 10287 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 10288 10289 list_for_each_entry_safe(pcie_device, pcie_device_next, &head, list) { 10290 _scsih_pcie_device_remove_from_sml(ioc, pcie_device); 10291 list_del_init(&pcie_device->list); 10292 pcie_device_put(pcie_device); 10293 } 10294 10295 /* removing unresponding volumes */ 10296 if (ioc->ir_firmware) { 10297 ioc_info(ioc, "removing unresponding devices: volumes\n"); 10298 list_for_each_entry_safe(raid_device, raid_device_next, 10299 &ioc->raid_device_list, list) { 10300 if (!raid_device->responding) 10301 _scsih_sas_volume_delete(ioc, 10302 raid_device->handle); 10303 else 10304 raid_device->responding = 0; 10305 } 10306 } 10307 10308 /* removing unresponding expanders */ 10309 ioc_info(ioc, "removing unresponding devices: expanders\n"); 10310 spin_lock_irqsave(&ioc->sas_node_lock, flags); 10311 INIT_LIST_HEAD(&tmp_list); 10312 list_for_each_entry_safe(sas_expander, sas_expander_next, 10313 &ioc->sas_expander_list, list) { 10314 if (!sas_expander->responding) 10315 list_move_tail(&sas_expander->list, &tmp_list); 10316 else 10317 sas_expander->responding = 0; 10318 } 10319 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 10320 list_for_each_entry_safe(sas_expander, sas_expander_next, &tmp_list, 10321 list) { 10322 _scsih_expander_node_remove(ioc, sas_expander); 10323 } 10324 10325 ioc_info(ioc, "removing unresponding devices: complete\n"); 10326 10327 /* unblock devices */ 10328 _scsih_ublock_io_all_device(ioc); 10329 } 10330 10331 static void 10332 _scsih_refresh_expander_links(struct MPT3SAS_ADAPTER *ioc, 10333 struct _sas_node *sas_expander, u16 handle) 10334 { 10335 Mpi2ExpanderPage1_t expander_pg1; 10336 Mpi2ConfigReply_t mpi_reply; 10337 int i; 10338 10339 for (i = 0 ; i < sas_expander->num_phys ; i++) { 10340 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply, 10341 &expander_pg1, i, handle))) { 10342 ioc_err(ioc, "failure at %s:%d/%s()!\n", 10343 __FILE__, __LINE__, __func__); 10344 return; 10345 } 10346 10347 mpt3sas_transport_update_links(ioc, sas_expander->sas_address, 10348 le16_to_cpu(expander_pg1.AttachedDevHandle), i, 10349 expander_pg1.NegotiatedLinkRate >> 4, 10350 sas_expander->port); 10351 } 10352 } 10353 10354 /** 10355 * _scsih_scan_for_devices_after_reset - scan for devices after host reset 10356 * @ioc: per adapter object 10357 */ 10358 static void 10359 _scsih_scan_for_devices_after_reset(struct MPT3SAS_ADAPTER *ioc) 10360 { 10361 Mpi2ExpanderPage0_t expander_pg0; 10362 Mpi2SasDevicePage0_t sas_device_pg0; 10363 Mpi26PCIeDevicePage0_t pcie_device_pg0; 10364 Mpi2RaidVolPage1_t volume_pg1; 10365 Mpi2RaidVolPage0_t volume_pg0; 10366 Mpi2RaidPhysDiskPage0_t pd_pg0; 10367 Mpi2EventIrConfigElement_t element; 10368 Mpi2ConfigReply_t mpi_reply; 10369 u8 phys_disk_num, port_id; 10370 u16 ioc_status; 10371 u16 handle, parent_handle; 10372 u64 sas_address; 10373 struct _sas_device *sas_device; 10374 struct _pcie_device *pcie_device; 10375 struct _sas_node *expander_device; 10376 static struct _raid_device *raid_device; 10377 u8 retry_count; 10378 unsigned long flags; 10379 10380 ioc_info(ioc, "scan devices: start\n"); 10381 10382 _scsih_sas_host_refresh(ioc); 10383 10384 ioc_info(ioc, "\tscan devices: expanders start\n"); 10385 10386 /* expanders */ 10387 handle = 0xFFFF; 10388 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0, 10389 MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) { 10390 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10391 MPI2_IOCSTATUS_MASK; 10392 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10393 ioc_info(ioc, "\tbreak from expander scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10394 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10395 break; 10396 } 10397 handle = le16_to_cpu(expander_pg0.DevHandle); 10398 spin_lock_irqsave(&ioc->sas_node_lock, flags); 10399 port_id = expander_pg0.PhysicalPort; 10400 expander_device = mpt3sas_scsih_expander_find_by_sas_address( 10401 ioc, le64_to_cpu(expander_pg0.SASAddress), 10402 mpt3sas_get_port_by_id(ioc, port_id, 0)); 10403 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 10404 if (expander_device) 10405 _scsih_refresh_expander_links(ioc, expander_device, 10406 handle); 10407 else { 10408 ioc_info(ioc, "\tBEFORE adding expander: handle (0x%04x), sas_addr(0x%016llx)\n", 10409 handle, 10410 (u64)le64_to_cpu(expander_pg0.SASAddress)); 10411 _scsih_expander_add(ioc, handle); 10412 ioc_info(ioc, "\tAFTER adding expander: handle (0x%04x), sas_addr(0x%016llx)\n", 10413 handle, 10414 (u64)le64_to_cpu(expander_pg0.SASAddress)); 10415 } 10416 } 10417 10418 ioc_info(ioc, "\tscan devices: expanders complete\n"); 10419 10420 if (!ioc->ir_firmware) 10421 goto skip_to_sas; 10422 10423 ioc_info(ioc, "\tscan devices: phys disk start\n"); 10424 10425 /* phys disk */ 10426 phys_disk_num = 0xFF; 10427 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply, 10428 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM, 10429 phys_disk_num))) { 10430 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10431 MPI2_IOCSTATUS_MASK; 10432 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10433 ioc_info(ioc, "\tbreak from phys disk scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10434 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10435 break; 10436 } 10437 phys_disk_num = pd_pg0.PhysDiskNum; 10438 handle = le16_to_cpu(pd_pg0.DevHandle); 10439 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 10440 if (sas_device) { 10441 sas_device_put(sas_device); 10442 continue; 10443 } 10444 if (mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 10445 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, 10446 handle) != 0) 10447 continue; 10448 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10449 MPI2_IOCSTATUS_MASK; 10450 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10451 ioc_info(ioc, "\tbreak from phys disk scan ioc_status(0x%04x), loginfo(0x%08x)\n", 10452 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10453 break; 10454 } 10455 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 10456 if (!_scsih_get_sas_address(ioc, parent_handle, 10457 &sas_address)) { 10458 ioc_info(ioc, "\tBEFORE adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n", 10459 handle, 10460 (u64)le64_to_cpu(sas_device_pg0.SASAddress)); 10461 port_id = sas_device_pg0.PhysicalPort; 10462 mpt3sas_transport_update_links(ioc, sas_address, 10463 handle, sas_device_pg0.PhyNum, 10464 MPI2_SAS_NEG_LINK_RATE_1_5, 10465 mpt3sas_get_port_by_id(ioc, port_id, 0)); 10466 set_bit(handle, ioc->pd_handles); 10467 retry_count = 0; 10468 /* This will retry adding the end device. 10469 * _scsih_add_device() will decide on retries and 10470 * return "1" when it should be retried 10471 */ 10472 while (_scsih_add_device(ioc, handle, retry_count++, 10473 1)) { 10474 ssleep(1); 10475 } 10476 ioc_info(ioc, "\tAFTER adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n", 10477 handle, 10478 (u64)le64_to_cpu(sas_device_pg0.SASAddress)); 10479 } 10480 } 10481 10482 ioc_info(ioc, "\tscan devices: phys disk complete\n"); 10483 10484 ioc_info(ioc, "\tscan devices: volumes start\n"); 10485 10486 /* volumes */ 10487 handle = 0xFFFF; 10488 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply, 10489 &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) { 10490 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10491 MPI2_IOCSTATUS_MASK; 10492 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10493 ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10494 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10495 break; 10496 } 10497 handle = le16_to_cpu(volume_pg1.DevHandle); 10498 spin_lock_irqsave(&ioc->raid_device_lock, flags); 10499 raid_device = _scsih_raid_device_find_by_wwid(ioc, 10500 le64_to_cpu(volume_pg1.WWID)); 10501 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 10502 if (raid_device) 10503 continue; 10504 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, 10505 &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle, 10506 sizeof(Mpi2RaidVolPage0_t))) 10507 continue; 10508 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10509 MPI2_IOCSTATUS_MASK; 10510 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10511 ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10512 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10513 break; 10514 } 10515 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL || 10516 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE || 10517 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) { 10518 memset(&element, 0, sizeof(Mpi2EventIrConfigElement_t)); 10519 element.ReasonCode = MPI2_EVENT_IR_CHANGE_RC_ADDED; 10520 element.VolDevHandle = volume_pg1.DevHandle; 10521 ioc_info(ioc, "\tBEFORE adding volume: handle (0x%04x)\n", 10522 volume_pg1.DevHandle); 10523 _scsih_sas_volume_add(ioc, &element); 10524 ioc_info(ioc, "\tAFTER adding volume: handle (0x%04x)\n", 10525 volume_pg1.DevHandle); 10526 } 10527 } 10528 10529 ioc_info(ioc, "\tscan devices: volumes complete\n"); 10530 10531 skip_to_sas: 10532 10533 ioc_info(ioc, "\tscan devices: end devices start\n"); 10534 10535 /* sas devices */ 10536 handle = 0xFFFF; 10537 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 10538 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, 10539 handle))) { 10540 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10541 MPI2_IOCSTATUS_MASK; 10542 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10543 ioc_info(ioc, "\tbreak from end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10544 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10545 break; 10546 } 10547 handle = le16_to_cpu(sas_device_pg0.DevHandle); 10548 if (!(_scsih_is_end_device( 10549 le32_to_cpu(sas_device_pg0.DeviceInfo)))) 10550 continue; 10551 port_id = sas_device_pg0.PhysicalPort; 10552 sas_device = mpt3sas_get_sdev_by_addr(ioc, 10553 le64_to_cpu(sas_device_pg0.SASAddress), 10554 mpt3sas_get_port_by_id(ioc, port_id, 0)); 10555 if (sas_device) { 10556 sas_device_put(sas_device); 10557 continue; 10558 } 10559 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 10560 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) { 10561 ioc_info(ioc, "\tBEFORE adding end device: handle (0x%04x), sas_addr(0x%016llx)\n", 10562 handle, 10563 (u64)le64_to_cpu(sas_device_pg0.SASAddress)); 10564 mpt3sas_transport_update_links(ioc, sas_address, handle, 10565 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5, 10566 mpt3sas_get_port_by_id(ioc, port_id, 0)); 10567 retry_count = 0; 10568 /* This will retry adding the end device. 10569 * _scsih_add_device() will decide on retries and 10570 * return "1" when it should be retried 10571 */ 10572 while (_scsih_add_device(ioc, handle, retry_count++, 10573 0)) { 10574 ssleep(1); 10575 } 10576 ioc_info(ioc, "\tAFTER adding end device: handle (0x%04x), sas_addr(0x%016llx)\n", 10577 handle, 10578 (u64)le64_to_cpu(sas_device_pg0.SASAddress)); 10579 } 10580 } 10581 ioc_info(ioc, "\tscan devices: end devices complete\n"); 10582 ioc_info(ioc, "\tscan devices: pcie end devices start\n"); 10583 10584 /* pcie devices */ 10585 handle = 0xFFFF; 10586 while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply, 10587 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, 10588 handle))) { 10589 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) 10590 & MPI2_IOCSTATUS_MASK; 10591 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10592 ioc_info(ioc, "\tbreak from pcie end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10593 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10594 break; 10595 } 10596 handle = le16_to_cpu(pcie_device_pg0.DevHandle); 10597 if (!(_scsih_is_nvme_pciescsi_device( 10598 le32_to_cpu(pcie_device_pg0.DeviceInfo)))) 10599 continue; 10600 pcie_device = mpt3sas_get_pdev_by_wwid(ioc, 10601 le64_to_cpu(pcie_device_pg0.WWID)); 10602 if (pcie_device) { 10603 pcie_device_put(pcie_device); 10604 continue; 10605 } 10606 retry_count = 0; 10607 parent_handle = le16_to_cpu(pcie_device_pg0.ParentDevHandle); 10608 _scsih_pcie_add_device(ioc, handle); 10609 10610 ioc_info(ioc, "\tAFTER adding pcie end device: handle (0x%04x), wwid(0x%016llx)\n", 10611 handle, (u64)le64_to_cpu(pcie_device_pg0.WWID)); 10612 } 10613 10614 ioc_info(ioc, "\tpcie devices: pcie end devices complete\n"); 10615 ioc_info(ioc, "scan devices: complete\n"); 10616 } 10617 10618 /** 10619 * mpt3sas_scsih_pre_reset_handler - reset callback handler (for scsih) 10620 * @ioc: per adapter object 10621 * 10622 * The handler for doing any required cleanup or initialization. 10623 */ 10624 void mpt3sas_scsih_pre_reset_handler(struct MPT3SAS_ADAPTER *ioc) 10625 { 10626 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__)); 10627 } 10628 10629 /** 10630 * mpt3sas_scsih_clear_outstanding_scsi_tm_commands - clears outstanding 10631 * scsi & tm cmds. 10632 * @ioc: per adapter object 10633 * 10634 * The handler for doing any required cleanup or initialization. 10635 */ 10636 void 10637 mpt3sas_scsih_clear_outstanding_scsi_tm_commands(struct MPT3SAS_ADAPTER *ioc) 10638 { 10639 dtmprintk(ioc, 10640 ioc_info(ioc, "%s: clear outstanding scsi & tm cmds\n", __func__)); 10641 if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) { 10642 ioc->scsih_cmds.status |= MPT3_CMD_RESET; 10643 mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid); 10644 complete(&ioc->scsih_cmds.done); 10645 } 10646 if (ioc->tm_cmds.status & MPT3_CMD_PENDING) { 10647 ioc->tm_cmds.status |= MPT3_CMD_RESET; 10648 mpt3sas_base_free_smid(ioc, ioc->tm_cmds.smid); 10649 complete(&ioc->tm_cmds.done); 10650 } 10651 10652 memset(ioc->pend_os_device_add, 0, ioc->pend_os_device_add_sz); 10653 memset(ioc->device_remove_in_progress, 0, 10654 ioc->device_remove_in_progress_sz); 10655 _scsih_fw_event_cleanup_queue(ioc); 10656 _scsih_flush_running_cmds(ioc); 10657 } 10658 10659 /** 10660 * mpt3sas_scsih_reset_done_handler - reset callback handler (for scsih) 10661 * @ioc: per adapter object 10662 * 10663 * The handler for doing any required cleanup or initialization. 10664 */ 10665 void 10666 mpt3sas_scsih_reset_done_handler(struct MPT3SAS_ADAPTER *ioc) 10667 { 10668 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_DONE_RESET\n", __func__)); 10669 if (!(disable_discovery > 0 && !ioc->sas_hba.num_phys)) { 10670 if (ioc->multipath_on_hba) { 10671 _scsih_sas_port_refresh(ioc); 10672 _scsih_update_vphys_after_reset(ioc); 10673 } 10674 _scsih_prep_device_scan(ioc); 10675 _scsih_create_enclosure_list_after_reset(ioc); 10676 _scsih_search_responding_sas_devices(ioc); 10677 _scsih_search_responding_pcie_devices(ioc); 10678 _scsih_search_responding_raid_devices(ioc); 10679 _scsih_search_responding_expanders(ioc); 10680 _scsih_error_recovery_delete_devices(ioc); 10681 } 10682 } 10683 10684 /** 10685 * _mpt3sas_fw_work - delayed task for processing firmware events 10686 * @ioc: per adapter object 10687 * @fw_event: The fw_event_work object 10688 * Context: user. 10689 */ 10690 static void 10691 _mpt3sas_fw_work(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event) 10692 { 10693 ioc->current_event = fw_event; 10694 _scsih_fw_event_del_from_list(ioc, fw_event); 10695 10696 /* the queue is being flushed so ignore this event */ 10697 if (ioc->remove_host || ioc->pci_error_recovery) { 10698 fw_event_work_put(fw_event); 10699 ioc->current_event = NULL; 10700 return; 10701 } 10702 10703 switch (fw_event->event) { 10704 case MPT3SAS_PROCESS_TRIGGER_DIAG: 10705 mpt3sas_process_trigger_data(ioc, 10706 (struct SL_WH_TRIGGERS_EVENT_DATA_T *) 10707 fw_event->event_data); 10708 break; 10709 case MPT3SAS_REMOVE_UNRESPONDING_DEVICES: 10710 while (scsi_host_in_recovery(ioc->shost) || 10711 ioc->shost_recovery) { 10712 /* 10713 * If we're unloading or cancelling the work, bail. 10714 * Otherwise, this can become an infinite loop. 10715 */ 10716 if (ioc->remove_host || ioc->fw_events_cleanup) 10717 goto out; 10718 ssleep(1); 10719 } 10720 _scsih_remove_unresponding_devices(ioc); 10721 _scsih_del_dirty_vphy(ioc); 10722 _scsih_del_dirty_port_entries(ioc); 10723 if (ioc->is_gen35_ioc) 10724 _scsih_update_device_qdepth(ioc); 10725 _scsih_scan_for_devices_after_reset(ioc); 10726 /* 10727 * If diag reset has occurred during the driver load 10728 * then driver has to complete the driver load operation 10729 * by executing the following items: 10730 *- Register the devices from sas_device_init_list to SML 10731 *- clear is_driver_loading flag, 10732 *- start the watchdog thread. 10733 * In happy driver load path, above things are taken care of when 10734 * driver executes scsih_scan_finished(). 10735 */ 10736 if (ioc->is_driver_loading) 10737 _scsih_complete_devices_scanning(ioc); 10738 _scsih_set_nvme_max_shutdown_latency(ioc); 10739 break; 10740 case MPT3SAS_PORT_ENABLE_COMPLETE: 10741 ioc->start_scan = 0; 10742 if (missing_delay[0] != -1 && missing_delay[1] != -1) 10743 mpt3sas_base_update_missing_delay(ioc, missing_delay[0], 10744 missing_delay[1]); 10745 dewtprintk(ioc, 10746 ioc_info(ioc, "port enable: complete from worker thread\n")); 10747 break; 10748 case MPT3SAS_TURN_ON_PFA_LED: 10749 _scsih_turn_on_pfa_led(ioc, fw_event->device_handle); 10750 break; 10751 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST: 10752 _scsih_sas_topology_change_event(ioc, fw_event); 10753 break; 10754 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE: 10755 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 10756 _scsih_sas_device_status_change_event_debug(ioc, 10757 (Mpi2EventDataSasDeviceStatusChange_t *) 10758 fw_event->event_data); 10759 break; 10760 case MPI2_EVENT_SAS_DISCOVERY: 10761 _scsih_sas_discovery_event(ioc, fw_event); 10762 break; 10763 case MPI2_EVENT_SAS_DEVICE_DISCOVERY_ERROR: 10764 _scsih_sas_device_discovery_error_event(ioc, fw_event); 10765 break; 10766 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE: 10767 _scsih_sas_broadcast_primitive_event(ioc, fw_event); 10768 break; 10769 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE: 10770 _scsih_sas_enclosure_dev_status_change_event(ioc, 10771 fw_event); 10772 break; 10773 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST: 10774 _scsih_sas_ir_config_change_event(ioc, fw_event); 10775 break; 10776 case MPI2_EVENT_IR_VOLUME: 10777 _scsih_sas_ir_volume_event(ioc, fw_event); 10778 break; 10779 case MPI2_EVENT_IR_PHYSICAL_DISK: 10780 _scsih_sas_ir_physical_disk_event(ioc, fw_event); 10781 break; 10782 case MPI2_EVENT_IR_OPERATION_STATUS: 10783 _scsih_sas_ir_operation_status_event(ioc, fw_event); 10784 break; 10785 case MPI2_EVENT_PCIE_DEVICE_STATUS_CHANGE: 10786 _scsih_pcie_device_status_change_event(ioc, fw_event); 10787 break; 10788 case MPI2_EVENT_PCIE_ENUMERATION: 10789 _scsih_pcie_enumeration_event(ioc, fw_event); 10790 break; 10791 case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST: 10792 _scsih_pcie_topology_change_event(ioc, fw_event); 10793 ioc->current_event = NULL; 10794 return; 10795 } 10796 out: 10797 fw_event_work_put(fw_event); 10798 ioc->current_event = NULL; 10799 } 10800 10801 /** 10802 * _firmware_event_work 10803 * @work: The fw_event_work object 10804 * Context: user. 10805 * 10806 * wrappers for the work thread handling firmware events 10807 */ 10808 10809 static void 10810 _firmware_event_work(struct work_struct *work) 10811 { 10812 struct fw_event_work *fw_event = container_of(work, 10813 struct fw_event_work, work); 10814 10815 _mpt3sas_fw_work(fw_event->ioc, fw_event); 10816 } 10817 10818 /** 10819 * mpt3sas_scsih_event_callback - firmware event handler (called at ISR time) 10820 * @ioc: per adapter object 10821 * @msix_index: MSIX table index supplied by the OS 10822 * @reply: reply message frame(lower 32bit addr) 10823 * Context: interrupt. 10824 * 10825 * This function merely adds a new work task into ioc->firmware_event_thread. 10826 * The tasks are worked from _firmware_event_work in user context. 10827 * 10828 * Return: 1 meaning mf should be freed from _base_interrupt 10829 * 0 means the mf is freed from this function. 10830 */ 10831 u8 10832 mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index, 10833 u32 reply) 10834 { 10835 struct fw_event_work *fw_event; 10836 Mpi2EventNotificationReply_t *mpi_reply; 10837 u16 event; 10838 u16 sz; 10839 Mpi26EventDataActiveCableExcept_t *ActiveCableEventData; 10840 10841 /* events turned off due to host reset */ 10842 if (ioc->pci_error_recovery) 10843 return 1; 10844 10845 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 10846 10847 if (unlikely(!mpi_reply)) { 10848 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n", 10849 __FILE__, __LINE__, __func__); 10850 return 1; 10851 } 10852 10853 event = le16_to_cpu(mpi_reply->Event); 10854 10855 if (event != MPI2_EVENT_LOG_ENTRY_ADDED) 10856 mpt3sas_trigger_event(ioc, event, 0); 10857 10858 switch (event) { 10859 /* handle these */ 10860 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE: 10861 { 10862 Mpi2EventDataSasBroadcastPrimitive_t *baen_data = 10863 (Mpi2EventDataSasBroadcastPrimitive_t *) 10864 mpi_reply->EventData; 10865 10866 if (baen_data->Primitive != 10867 MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT) 10868 return 1; 10869 10870 if (ioc->broadcast_aen_busy) { 10871 ioc->broadcast_aen_pending++; 10872 return 1; 10873 } else 10874 ioc->broadcast_aen_busy = 1; 10875 break; 10876 } 10877 10878 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST: 10879 _scsih_check_topo_delete_events(ioc, 10880 (Mpi2EventDataSasTopologyChangeList_t *) 10881 mpi_reply->EventData); 10882 /* 10883 * No need to add the topology change list 10884 * event to fw event work queue when 10885 * diag reset is going on. Since during diag 10886 * reset driver scan the devices by reading 10887 * sas device page0's not by processing the 10888 * events. 10889 */ 10890 if (ioc->shost_recovery) 10891 return 1; 10892 break; 10893 case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST: 10894 _scsih_check_pcie_topo_remove_events(ioc, 10895 (Mpi26EventDataPCIeTopologyChangeList_t *) 10896 mpi_reply->EventData); 10897 if (ioc->shost_recovery) 10898 return 1; 10899 break; 10900 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST: 10901 _scsih_check_ir_config_unhide_events(ioc, 10902 (Mpi2EventDataIrConfigChangeList_t *) 10903 mpi_reply->EventData); 10904 break; 10905 case MPI2_EVENT_IR_VOLUME: 10906 _scsih_check_volume_delete_events(ioc, 10907 (Mpi2EventDataIrVolume_t *) 10908 mpi_reply->EventData); 10909 break; 10910 case MPI2_EVENT_LOG_ENTRY_ADDED: 10911 { 10912 Mpi2EventDataLogEntryAdded_t *log_entry; 10913 u32 log_code; 10914 10915 if (!ioc->is_warpdrive) 10916 break; 10917 10918 log_entry = (Mpi2EventDataLogEntryAdded_t *) 10919 mpi_reply->EventData; 10920 log_code = le32_to_cpu(*(__le32 *)log_entry->LogData); 10921 10922 if (le16_to_cpu(log_entry->LogEntryQualifier) 10923 != MPT2_WARPDRIVE_LOGENTRY) 10924 break; 10925 10926 switch (log_code) { 10927 case MPT2_WARPDRIVE_LC_SSDT: 10928 ioc_warn(ioc, "WarpDrive Warning: IO Throttling has occurred in the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n"); 10929 break; 10930 case MPT2_WARPDRIVE_LC_SSDLW: 10931 ioc_warn(ioc, "WarpDrive Warning: Program/Erase Cycles for the WarpDrive subsystem in degraded range. Check WarpDrive documentation for additional details.\n"); 10932 break; 10933 case MPT2_WARPDRIVE_LC_SSDLF: 10934 ioc_err(ioc, "WarpDrive Fatal Error: There are no Program/Erase Cycles for the WarpDrive subsystem. The storage device will be in read-only mode. Check WarpDrive documentation for additional details.\n"); 10935 break; 10936 case MPT2_WARPDRIVE_LC_BRMF: 10937 ioc_err(ioc, "WarpDrive Fatal Error: The Backup Rail Monitor has failed on the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n"); 10938 break; 10939 } 10940 10941 break; 10942 } 10943 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE: 10944 _scsih_sas_device_status_change_event(ioc, 10945 (Mpi2EventDataSasDeviceStatusChange_t *) 10946 mpi_reply->EventData); 10947 break; 10948 case MPI2_EVENT_IR_OPERATION_STATUS: 10949 case MPI2_EVENT_SAS_DISCOVERY: 10950 case MPI2_EVENT_SAS_DEVICE_DISCOVERY_ERROR: 10951 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE: 10952 case MPI2_EVENT_IR_PHYSICAL_DISK: 10953 case MPI2_EVENT_PCIE_ENUMERATION: 10954 case MPI2_EVENT_PCIE_DEVICE_STATUS_CHANGE: 10955 break; 10956 10957 case MPI2_EVENT_TEMP_THRESHOLD: 10958 _scsih_temp_threshold_events(ioc, 10959 (Mpi2EventDataTemperature_t *) 10960 mpi_reply->EventData); 10961 break; 10962 case MPI2_EVENT_ACTIVE_CABLE_EXCEPTION: 10963 ActiveCableEventData = 10964 (Mpi26EventDataActiveCableExcept_t *) mpi_reply->EventData; 10965 switch (ActiveCableEventData->ReasonCode) { 10966 case MPI26_EVENT_ACTIVE_CABLE_INSUFFICIENT_POWER: 10967 ioc_notice(ioc, "Currently an active cable with ReceptacleID %d\n", 10968 ActiveCableEventData->ReceptacleID); 10969 pr_notice("cannot be powered and devices connected\n"); 10970 pr_notice("to this active cable will not be seen\n"); 10971 pr_notice("This active cable requires %d mW of power\n", 10972 le32_to_cpu( 10973 ActiveCableEventData->ActiveCablePowerRequirement)); 10974 break; 10975 10976 case MPI26_EVENT_ACTIVE_CABLE_DEGRADED: 10977 ioc_notice(ioc, "Currently a cable with ReceptacleID %d\n", 10978 ActiveCableEventData->ReceptacleID); 10979 pr_notice( 10980 "is not running at optimal speed(12 Gb/s rate)\n"); 10981 break; 10982 } 10983 10984 break; 10985 10986 default: /* ignore the rest */ 10987 return 1; 10988 } 10989 10990 sz = le16_to_cpu(mpi_reply->EventDataLength) * 4; 10991 fw_event = alloc_fw_event_work(sz); 10992 if (!fw_event) { 10993 ioc_err(ioc, "failure at %s:%d/%s()!\n", 10994 __FILE__, __LINE__, __func__); 10995 return 1; 10996 } 10997 10998 memcpy(fw_event->event_data, mpi_reply->EventData, sz); 10999 fw_event->ioc = ioc; 11000 fw_event->VF_ID = mpi_reply->VF_ID; 11001 fw_event->VP_ID = mpi_reply->VP_ID; 11002 fw_event->event = event; 11003 _scsih_fw_event_add(ioc, fw_event); 11004 fw_event_work_put(fw_event); 11005 return 1; 11006 } 11007 11008 /** 11009 * _scsih_expander_node_remove - removing expander device from list. 11010 * @ioc: per adapter object 11011 * @sas_expander: the sas_device object 11012 * 11013 * Removing object and freeing associated memory from the 11014 * ioc->sas_expander_list. 11015 */ 11016 static void 11017 _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc, 11018 struct _sas_node *sas_expander) 11019 { 11020 struct _sas_port *mpt3sas_port, *next; 11021 unsigned long flags; 11022 int port_id; 11023 11024 /* remove sibling ports attached to this expander */ 11025 list_for_each_entry_safe(mpt3sas_port, next, 11026 &sas_expander->sas_port_list, port_list) { 11027 if (ioc->shost_recovery) 11028 return; 11029 if (mpt3sas_port->remote_identify.device_type == 11030 SAS_END_DEVICE) 11031 mpt3sas_device_remove_by_sas_address(ioc, 11032 mpt3sas_port->remote_identify.sas_address, 11033 mpt3sas_port->hba_port); 11034 else if (mpt3sas_port->remote_identify.device_type == 11035 SAS_EDGE_EXPANDER_DEVICE || 11036 mpt3sas_port->remote_identify.device_type == 11037 SAS_FANOUT_EXPANDER_DEVICE) 11038 mpt3sas_expander_remove(ioc, 11039 mpt3sas_port->remote_identify.sas_address, 11040 mpt3sas_port->hba_port); 11041 } 11042 11043 port_id = sas_expander->port->port_id; 11044 11045 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address, 11046 sas_expander->sas_address_parent, sas_expander->port); 11047 11048 ioc_info(ioc, 11049 "expander_remove: handle(0x%04x), sas_addr(0x%016llx), port:%d\n", 11050 sas_expander->handle, (unsigned long long) 11051 sas_expander->sas_address, 11052 port_id); 11053 11054 spin_lock_irqsave(&ioc->sas_node_lock, flags); 11055 list_del(&sas_expander->list); 11056 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 11057 11058 kfree(sas_expander->phy); 11059 kfree(sas_expander); 11060 } 11061 11062 /** 11063 * _scsih_nvme_shutdown - NVMe shutdown notification 11064 * @ioc: per adapter object 11065 * 11066 * Sending IoUnitControl request with shutdown operation code to alert IOC that 11067 * the host system is shutting down so that IOC can issue NVMe shutdown to 11068 * NVMe drives attached to it. 11069 */ 11070 static void 11071 _scsih_nvme_shutdown(struct MPT3SAS_ADAPTER *ioc) 11072 { 11073 Mpi26IoUnitControlRequest_t *mpi_request; 11074 Mpi26IoUnitControlReply_t *mpi_reply; 11075 u16 smid; 11076 11077 /* are there any NVMe devices ? */ 11078 if (list_empty(&ioc->pcie_device_list)) 11079 return; 11080 11081 mutex_lock(&ioc->scsih_cmds.mutex); 11082 11083 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) { 11084 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__); 11085 goto out; 11086 } 11087 11088 ioc->scsih_cmds.status = MPT3_CMD_PENDING; 11089 11090 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx); 11091 if (!smid) { 11092 ioc_err(ioc, 11093 "%s: failed obtaining a smid\n", __func__); 11094 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 11095 goto out; 11096 } 11097 11098 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 11099 ioc->scsih_cmds.smid = smid; 11100 memset(mpi_request, 0, sizeof(Mpi26IoUnitControlRequest_t)); 11101 mpi_request->Function = MPI2_FUNCTION_IO_UNIT_CONTROL; 11102 mpi_request->Operation = MPI26_CTRL_OP_SHUTDOWN; 11103 11104 init_completion(&ioc->scsih_cmds.done); 11105 ioc->put_smid_default(ioc, smid); 11106 /* Wait for max_shutdown_latency seconds */ 11107 ioc_info(ioc, 11108 "Io Unit Control shutdown (sending), Shutdown latency %d sec\n", 11109 ioc->max_shutdown_latency); 11110 wait_for_completion_timeout(&ioc->scsih_cmds.done, 11111 ioc->max_shutdown_latency*HZ); 11112 11113 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) { 11114 ioc_err(ioc, "%s: timeout\n", __func__); 11115 goto out; 11116 } 11117 11118 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) { 11119 mpi_reply = ioc->scsih_cmds.reply; 11120 ioc_info(ioc, "Io Unit Control shutdown (complete):" 11121 "ioc_status(0x%04x), loginfo(0x%08x)\n", 11122 le16_to_cpu(mpi_reply->IOCStatus), 11123 le32_to_cpu(mpi_reply->IOCLogInfo)); 11124 } 11125 out: 11126 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 11127 mutex_unlock(&ioc->scsih_cmds.mutex); 11128 } 11129 11130 11131 /** 11132 * _scsih_ir_shutdown - IR shutdown notification 11133 * @ioc: per adapter object 11134 * 11135 * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that 11136 * the host system is shutting down. 11137 */ 11138 static void 11139 _scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc) 11140 { 11141 Mpi2RaidActionRequest_t *mpi_request; 11142 Mpi2RaidActionReply_t *mpi_reply; 11143 u16 smid; 11144 11145 /* is IR firmware build loaded ? */ 11146 if (!ioc->ir_firmware) 11147 return; 11148 11149 /* are there any volumes ? */ 11150 if (list_empty(&ioc->raid_device_list)) 11151 return; 11152 11153 mutex_lock(&ioc->scsih_cmds.mutex); 11154 11155 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) { 11156 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__); 11157 goto out; 11158 } 11159 ioc->scsih_cmds.status = MPT3_CMD_PENDING; 11160 11161 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx); 11162 if (!smid) { 11163 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__); 11164 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 11165 goto out; 11166 } 11167 11168 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 11169 ioc->scsih_cmds.smid = smid; 11170 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t)); 11171 11172 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION; 11173 mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED; 11174 11175 if (!ioc->hide_ir_msg) 11176 ioc_info(ioc, "IR shutdown (sending)\n"); 11177 init_completion(&ioc->scsih_cmds.done); 11178 ioc->put_smid_default(ioc, smid); 11179 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ); 11180 11181 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) { 11182 ioc_err(ioc, "%s: timeout\n", __func__); 11183 goto out; 11184 } 11185 11186 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) { 11187 mpi_reply = ioc->scsih_cmds.reply; 11188 if (!ioc->hide_ir_msg) 11189 ioc_info(ioc, "IR shutdown (complete): ioc_status(0x%04x), loginfo(0x%08x)\n", 11190 le16_to_cpu(mpi_reply->IOCStatus), 11191 le32_to_cpu(mpi_reply->IOCLogInfo)); 11192 } 11193 11194 out: 11195 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 11196 mutex_unlock(&ioc->scsih_cmds.mutex); 11197 } 11198 11199 /** 11200 * _scsih_get_shost_and_ioc - get shost and ioc 11201 * and verify whether they are NULL or not 11202 * @pdev: PCI device struct 11203 * @shost: address of scsi host pointer 11204 * @ioc: address of HBA adapter pointer 11205 * 11206 * Return zero if *shost and *ioc are not NULL otherwise return error number. 11207 */ 11208 static int 11209 _scsih_get_shost_and_ioc(struct pci_dev *pdev, 11210 struct Scsi_Host **shost, struct MPT3SAS_ADAPTER **ioc) 11211 { 11212 *shost = pci_get_drvdata(pdev); 11213 if (*shost == NULL) { 11214 dev_err(&pdev->dev, "pdev's driver data is null\n"); 11215 return -ENXIO; 11216 } 11217 11218 *ioc = shost_priv(*shost); 11219 if (*ioc == NULL) { 11220 dev_err(&pdev->dev, "shost's private data is null\n"); 11221 return -ENXIO; 11222 } 11223 11224 return 0; 11225 } 11226 11227 /** 11228 * scsih_remove - detach and remove add host 11229 * @pdev: PCI device struct 11230 * 11231 * Routine called when unloading the driver. 11232 */ 11233 static void scsih_remove(struct pci_dev *pdev) 11234 { 11235 struct Scsi_Host *shost; 11236 struct MPT3SAS_ADAPTER *ioc; 11237 struct _sas_port *mpt3sas_port, *next_port; 11238 struct _raid_device *raid_device, *next; 11239 struct MPT3SAS_TARGET *sas_target_priv_data; 11240 struct _pcie_device *pcie_device, *pcienext; 11241 struct workqueue_struct *wq; 11242 unsigned long flags; 11243 Mpi2ConfigReply_t mpi_reply; 11244 struct hba_port *port, *port_next; 11245 11246 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 11247 return; 11248 11249 ioc->remove_host = 1; 11250 11251 if (!pci_device_is_present(pdev)) { 11252 mpt3sas_base_pause_mq_polling(ioc); 11253 _scsih_flush_running_cmds(ioc); 11254 } 11255 11256 _scsih_fw_event_cleanup_queue(ioc); 11257 11258 spin_lock_irqsave(&ioc->fw_event_lock, flags); 11259 wq = ioc->firmware_event_thread; 11260 ioc->firmware_event_thread = NULL; 11261 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 11262 if (wq) 11263 destroy_workqueue(wq); 11264 /* 11265 * Copy back the unmodified ioc page1. so that on next driver load, 11266 * current modified changes on ioc page1 won't take effect. 11267 */ 11268 if (ioc->is_aero_ioc) 11269 mpt3sas_config_set_ioc_pg1(ioc, &mpi_reply, 11270 &ioc->ioc_pg1_copy); 11271 /* release all the volumes */ 11272 _scsih_ir_shutdown(ioc); 11273 mpt3sas_destroy_debugfs(ioc); 11274 sas_remove_host(shost); 11275 list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list, 11276 list) { 11277 if (raid_device->starget) { 11278 sas_target_priv_data = 11279 raid_device->starget->hostdata; 11280 sas_target_priv_data->deleted = 1; 11281 scsi_remove_target(&raid_device->starget->dev); 11282 } 11283 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n", 11284 raid_device->handle, (u64)raid_device->wwid); 11285 _scsih_raid_device_remove(ioc, raid_device); 11286 } 11287 list_for_each_entry_safe(pcie_device, pcienext, &ioc->pcie_device_list, 11288 list) { 11289 _scsih_pcie_device_remove_from_sml(ioc, pcie_device); 11290 list_del_init(&pcie_device->list); 11291 pcie_device_put(pcie_device); 11292 } 11293 11294 /* free ports attached to the sas_host */ 11295 list_for_each_entry_safe(mpt3sas_port, next_port, 11296 &ioc->sas_hba.sas_port_list, port_list) { 11297 if (mpt3sas_port->remote_identify.device_type == 11298 SAS_END_DEVICE) 11299 mpt3sas_device_remove_by_sas_address(ioc, 11300 mpt3sas_port->remote_identify.sas_address, 11301 mpt3sas_port->hba_port); 11302 else if (mpt3sas_port->remote_identify.device_type == 11303 SAS_EDGE_EXPANDER_DEVICE || 11304 mpt3sas_port->remote_identify.device_type == 11305 SAS_FANOUT_EXPANDER_DEVICE) 11306 mpt3sas_expander_remove(ioc, 11307 mpt3sas_port->remote_identify.sas_address, 11308 mpt3sas_port->hba_port); 11309 } 11310 11311 list_for_each_entry_safe(port, port_next, 11312 &ioc->port_table_list, list) { 11313 list_del(&port->list); 11314 kfree(port); 11315 } 11316 11317 /* free phys attached to the sas_host */ 11318 if (ioc->sas_hba.num_phys) { 11319 kfree(ioc->sas_hba.phy); 11320 ioc->sas_hba.phy = NULL; 11321 ioc->sas_hba.num_phys = 0; 11322 } 11323 11324 mpt3sas_base_detach(ioc); 11325 mpt3sas_ctl_release(ioc); 11326 spin_lock(&gioc_lock); 11327 list_del(&ioc->list); 11328 spin_unlock(&gioc_lock); 11329 scsi_host_put(shost); 11330 } 11331 11332 /** 11333 * scsih_shutdown - routine call during system shutdown 11334 * @pdev: PCI device struct 11335 */ 11336 static void 11337 scsih_shutdown(struct pci_dev *pdev) 11338 { 11339 struct Scsi_Host *shost; 11340 struct MPT3SAS_ADAPTER *ioc; 11341 struct workqueue_struct *wq; 11342 unsigned long flags; 11343 Mpi2ConfigReply_t mpi_reply; 11344 11345 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 11346 return; 11347 11348 ioc->remove_host = 1; 11349 11350 if (!pci_device_is_present(pdev)) { 11351 mpt3sas_base_pause_mq_polling(ioc); 11352 _scsih_flush_running_cmds(ioc); 11353 } 11354 11355 _scsih_fw_event_cleanup_queue(ioc); 11356 11357 spin_lock_irqsave(&ioc->fw_event_lock, flags); 11358 wq = ioc->firmware_event_thread; 11359 ioc->firmware_event_thread = NULL; 11360 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 11361 if (wq) 11362 destroy_workqueue(wq); 11363 /* 11364 * Copy back the unmodified ioc page1 so that on next driver load, 11365 * current modified changes on ioc page1 won't take effect. 11366 */ 11367 if (ioc->is_aero_ioc) 11368 mpt3sas_config_set_ioc_pg1(ioc, &mpi_reply, 11369 &ioc->ioc_pg1_copy); 11370 11371 _scsih_ir_shutdown(ioc); 11372 _scsih_nvme_shutdown(ioc); 11373 mpt3sas_base_mask_interrupts(ioc); 11374 mpt3sas_base_stop_watchdog(ioc); 11375 ioc->shost_recovery = 1; 11376 mpt3sas_base_make_ioc_ready(ioc, SOFT_RESET); 11377 ioc->shost_recovery = 0; 11378 mpt3sas_base_free_irq(ioc); 11379 mpt3sas_base_disable_msix(ioc); 11380 } 11381 11382 11383 /** 11384 * _scsih_probe_boot_devices - reports 1st device 11385 * @ioc: per adapter object 11386 * 11387 * If specified in bios page 2, this routine reports the 1st 11388 * device scsi-ml or sas transport for persistent boot device 11389 * purposes. Please refer to function _scsih_determine_boot_device() 11390 */ 11391 static void 11392 _scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc) 11393 { 11394 u32 channel; 11395 void *device; 11396 struct _sas_device *sas_device; 11397 struct _raid_device *raid_device; 11398 struct _pcie_device *pcie_device; 11399 u16 handle; 11400 u64 sas_address_parent; 11401 u64 sas_address; 11402 unsigned long flags; 11403 int rc; 11404 int tid; 11405 struct hba_port *port; 11406 11407 /* no Bios, return immediately */ 11408 if (!ioc->bios_pg3.BiosVersion) 11409 return; 11410 11411 device = NULL; 11412 if (ioc->req_boot_device.device) { 11413 device = ioc->req_boot_device.device; 11414 channel = ioc->req_boot_device.channel; 11415 } else if (ioc->req_alt_boot_device.device) { 11416 device = ioc->req_alt_boot_device.device; 11417 channel = ioc->req_alt_boot_device.channel; 11418 } else if (ioc->current_boot_device.device) { 11419 device = ioc->current_boot_device.device; 11420 channel = ioc->current_boot_device.channel; 11421 } 11422 11423 if (!device) 11424 return; 11425 11426 if (channel == RAID_CHANNEL) { 11427 raid_device = device; 11428 /* 11429 * If this boot vd is already registered with SML then 11430 * no need to register it again as part of device scanning 11431 * after diag reset during driver load operation. 11432 */ 11433 if (raid_device->starget) 11434 return; 11435 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 11436 raid_device->id, 0); 11437 if (rc) 11438 _scsih_raid_device_remove(ioc, raid_device); 11439 } else if (channel == PCIE_CHANNEL) { 11440 pcie_device = device; 11441 /* 11442 * If this boot NVMe device is already registered with SML then 11443 * no need to register it again as part of device scanning 11444 * after diag reset during driver load operation. 11445 */ 11446 if (pcie_device->starget) 11447 return; 11448 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 11449 tid = pcie_device->id; 11450 list_move_tail(&pcie_device->list, &ioc->pcie_device_list); 11451 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 11452 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL, tid, 0); 11453 if (rc) 11454 _scsih_pcie_device_remove(ioc, pcie_device); 11455 } else { 11456 sas_device = device; 11457 /* 11458 * If this boot sas/sata device is already registered with SML 11459 * then no need to register it again as part of device scanning 11460 * after diag reset during driver load operation. 11461 */ 11462 if (sas_device->starget) 11463 return; 11464 spin_lock_irqsave(&ioc->sas_device_lock, flags); 11465 handle = sas_device->handle; 11466 sas_address_parent = sas_device->sas_address_parent; 11467 sas_address = sas_device->sas_address; 11468 port = sas_device->port; 11469 list_move_tail(&sas_device->list, &ioc->sas_device_list); 11470 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 11471 11472 if (ioc->hide_drives) 11473 return; 11474 11475 if (!port) 11476 return; 11477 11478 if (!mpt3sas_transport_port_add(ioc, handle, 11479 sas_address_parent, port)) { 11480 _scsih_sas_device_remove(ioc, sas_device); 11481 } else if (!sas_device->starget) { 11482 if (!ioc->is_driver_loading) { 11483 mpt3sas_transport_port_remove(ioc, 11484 sas_address, 11485 sas_address_parent, port); 11486 _scsih_sas_device_remove(ioc, sas_device); 11487 } 11488 } 11489 } 11490 } 11491 11492 /** 11493 * _scsih_probe_raid - reporting raid volumes to scsi-ml 11494 * @ioc: per adapter object 11495 * 11496 * Called during initial loading of the driver. 11497 */ 11498 static void 11499 _scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc) 11500 { 11501 struct _raid_device *raid_device, *raid_next; 11502 int rc; 11503 11504 list_for_each_entry_safe(raid_device, raid_next, 11505 &ioc->raid_device_list, list) { 11506 if (raid_device->starget) 11507 continue; 11508 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 11509 raid_device->id, 0); 11510 if (rc) 11511 _scsih_raid_device_remove(ioc, raid_device); 11512 } 11513 } 11514 11515 static struct _sas_device *get_next_sas_device(struct MPT3SAS_ADAPTER *ioc) 11516 { 11517 struct _sas_device *sas_device = NULL; 11518 unsigned long flags; 11519 11520 spin_lock_irqsave(&ioc->sas_device_lock, flags); 11521 if (!list_empty(&ioc->sas_device_init_list)) { 11522 sas_device = list_first_entry(&ioc->sas_device_init_list, 11523 struct _sas_device, list); 11524 sas_device_get(sas_device); 11525 } 11526 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 11527 11528 return sas_device; 11529 } 11530 11531 static void sas_device_make_active(struct MPT3SAS_ADAPTER *ioc, 11532 struct _sas_device *sas_device) 11533 { 11534 unsigned long flags; 11535 11536 spin_lock_irqsave(&ioc->sas_device_lock, flags); 11537 11538 /* 11539 * Since we dropped the lock during the call to port_add(), we need to 11540 * be careful here that somebody else didn't move or delete this item 11541 * while we were busy with other things. 11542 * 11543 * If it was on the list, we need a put() for the reference the list 11544 * had. Either way, we need a get() for the destination list. 11545 */ 11546 if (!list_empty(&sas_device->list)) { 11547 list_del_init(&sas_device->list); 11548 sas_device_put(sas_device); 11549 } 11550 11551 sas_device_get(sas_device); 11552 list_add_tail(&sas_device->list, &ioc->sas_device_list); 11553 11554 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 11555 } 11556 11557 /** 11558 * _scsih_probe_sas - reporting sas devices to sas transport 11559 * @ioc: per adapter object 11560 * 11561 * Called during initial loading of the driver. 11562 */ 11563 static void 11564 _scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc) 11565 { 11566 struct _sas_device *sas_device; 11567 11568 if (ioc->hide_drives) 11569 return; 11570 11571 while ((sas_device = get_next_sas_device(ioc))) { 11572 if (!mpt3sas_transport_port_add(ioc, sas_device->handle, 11573 sas_device->sas_address_parent, sas_device->port)) { 11574 _scsih_sas_device_remove(ioc, sas_device); 11575 sas_device_put(sas_device); 11576 continue; 11577 } else if (!sas_device->starget) { 11578 /* 11579 * When asyn scanning is enabled, its not possible to 11580 * remove devices while scanning is turned on due to an 11581 * oops in scsi_sysfs_add_sdev()->add_device()-> 11582 * sysfs_addrm_start() 11583 */ 11584 if (!ioc->is_driver_loading) { 11585 mpt3sas_transport_port_remove(ioc, 11586 sas_device->sas_address, 11587 sas_device->sas_address_parent, 11588 sas_device->port); 11589 _scsih_sas_device_remove(ioc, sas_device); 11590 sas_device_put(sas_device); 11591 continue; 11592 } 11593 } 11594 sas_device_make_active(ioc, sas_device); 11595 sas_device_put(sas_device); 11596 } 11597 } 11598 11599 /** 11600 * get_next_pcie_device - Get the next pcie device 11601 * @ioc: per adapter object 11602 * 11603 * Get the next pcie device from pcie_device_init_list list. 11604 * 11605 * Return: pcie device structure if pcie_device_init_list list is not empty 11606 * otherwise returns NULL 11607 */ 11608 static struct _pcie_device *get_next_pcie_device(struct MPT3SAS_ADAPTER *ioc) 11609 { 11610 struct _pcie_device *pcie_device = NULL; 11611 unsigned long flags; 11612 11613 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 11614 if (!list_empty(&ioc->pcie_device_init_list)) { 11615 pcie_device = list_first_entry(&ioc->pcie_device_init_list, 11616 struct _pcie_device, list); 11617 pcie_device_get(pcie_device); 11618 } 11619 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 11620 11621 return pcie_device; 11622 } 11623 11624 /** 11625 * pcie_device_make_active - Add pcie device to pcie_device_list list 11626 * @ioc: per adapter object 11627 * @pcie_device: pcie device object 11628 * 11629 * Add the pcie device which has registered with SCSI Transport Later to 11630 * pcie_device_list list 11631 */ 11632 static void pcie_device_make_active(struct MPT3SAS_ADAPTER *ioc, 11633 struct _pcie_device *pcie_device) 11634 { 11635 unsigned long flags; 11636 11637 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 11638 11639 if (!list_empty(&pcie_device->list)) { 11640 list_del_init(&pcie_device->list); 11641 pcie_device_put(pcie_device); 11642 } 11643 pcie_device_get(pcie_device); 11644 list_add_tail(&pcie_device->list, &ioc->pcie_device_list); 11645 11646 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 11647 } 11648 11649 /** 11650 * _scsih_probe_pcie - reporting PCIe devices to scsi-ml 11651 * @ioc: per adapter object 11652 * 11653 * Called during initial loading of the driver. 11654 */ 11655 static void 11656 _scsih_probe_pcie(struct MPT3SAS_ADAPTER *ioc) 11657 { 11658 struct _pcie_device *pcie_device; 11659 int rc; 11660 11661 /* PCIe Device List */ 11662 while ((pcie_device = get_next_pcie_device(ioc))) { 11663 if (pcie_device->starget) { 11664 pcie_device_put(pcie_device); 11665 continue; 11666 } 11667 if (pcie_device->access_status == 11668 MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED) { 11669 pcie_device_make_active(ioc, pcie_device); 11670 pcie_device_put(pcie_device); 11671 continue; 11672 } 11673 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL, 11674 pcie_device->id, 0); 11675 if (rc) { 11676 _scsih_pcie_device_remove(ioc, pcie_device); 11677 pcie_device_put(pcie_device); 11678 continue; 11679 } else if (!pcie_device->starget) { 11680 /* 11681 * When async scanning is enabled, its not possible to 11682 * remove devices while scanning is turned on due to an 11683 * oops in scsi_sysfs_add_sdev()->add_device()-> 11684 * sysfs_addrm_start() 11685 */ 11686 if (!ioc->is_driver_loading) { 11687 /* TODO-- Need to find out whether this condition will 11688 * occur or not 11689 */ 11690 _scsih_pcie_device_remove(ioc, pcie_device); 11691 pcie_device_put(pcie_device); 11692 continue; 11693 } 11694 } 11695 pcie_device_make_active(ioc, pcie_device); 11696 pcie_device_put(pcie_device); 11697 } 11698 } 11699 11700 /** 11701 * _scsih_probe_devices - probing for devices 11702 * @ioc: per adapter object 11703 * 11704 * Called during initial loading of the driver. 11705 */ 11706 static void 11707 _scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc) 11708 { 11709 u16 volume_mapping_flags; 11710 11711 if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR)) 11712 return; /* return when IOC doesn't support initiator mode */ 11713 11714 _scsih_probe_boot_devices(ioc); 11715 11716 if (ioc->ir_firmware) { 11717 volume_mapping_flags = 11718 le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) & 11719 MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE; 11720 if (volume_mapping_flags == 11721 MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) { 11722 _scsih_probe_raid(ioc); 11723 _scsih_probe_sas(ioc); 11724 } else { 11725 _scsih_probe_sas(ioc); 11726 _scsih_probe_raid(ioc); 11727 } 11728 } else { 11729 _scsih_probe_sas(ioc); 11730 _scsih_probe_pcie(ioc); 11731 } 11732 } 11733 11734 /** 11735 * scsih_scan_start - scsi lld callback for .scan_start 11736 * @shost: SCSI host pointer 11737 * 11738 * The shost has the ability to discover targets on its own instead 11739 * of scanning the entire bus. In our implemention, we will kick off 11740 * firmware discovery. 11741 */ 11742 static void 11743 scsih_scan_start(struct Scsi_Host *shost) 11744 { 11745 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 11746 int rc; 11747 if (diag_buffer_enable != -1 && diag_buffer_enable != 0) 11748 mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable); 11749 else if (ioc->manu_pg11.HostTraceBufferMaxSizeKB != 0) 11750 mpt3sas_enable_diag_buffer(ioc, 1); 11751 11752 if (disable_discovery > 0) 11753 return; 11754 11755 ioc->start_scan = 1; 11756 rc = mpt3sas_port_enable(ioc); 11757 11758 if (rc != 0) 11759 ioc_info(ioc, "port enable: FAILED\n"); 11760 } 11761 11762 /** 11763 * _scsih_complete_devices_scanning - add the devices to sml and 11764 * complete ioc initialization. 11765 * @ioc: per adapter object 11766 * 11767 * Return nothing. 11768 */ 11769 static void _scsih_complete_devices_scanning(struct MPT3SAS_ADAPTER *ioc) 11770 { 11771 11772 if (ioc->wait_for_discovery_to_complete) { 11773 ioc->wait_for_discovery_to_complete = 0; 11774 _scsih_probe_devices(ioc); 11775 } 11776 11777 mpt3sas_base_start_watchdog(ioc); 11778 ioc->is_driver_loading = 0; 11779 } 11780 11781 /** 11782 * scsih_scan_finished - scsi lld callback for .scan_finished 11783 * @shost: SCSI host pointer 11784 * @time: elapsed time of the scan in jiffies 11785 * 11786 * This function will be called periodicallyn until it returns 1 with the 11787 * scsi_host and the elapsed time of the scan in jiffies. In our implemention, 11788 * we wait for firmware discovery to complete, then return 1. 11789 */ 11790 static int 11791 scsih_scan_finished(struct Scsi_Host *shost, unsigned long time) 11792 { 11793 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 11794 u32 ioc_state; 11795 int issue_hard_reset = 0; 11796 11797 if (disable_discovery > 0) { 11798 ioc->is_driver_loading = 0; 11799 ioc->wait_for_discovery_to_complete = 0; 11800 return 1; 11801 } 11802 11803 if (time >= (300 * HZ)) { 11804 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED; 11805 ioc_info(ioc, "port enable: FAILED with timeout (timeout=300s)\n"); 11806 ioc->is_driver_loading = 0; 11807 return 1; 11808 } 11809 11810 if (ioc->start_scan) { 11811 ioc_state = mpt3sas_base_get_iocstate(ioc, 0); 11812 if ((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT) { 11813 mpt3sas_print_fault_code(ioc, ioc_state & 11814 MPI2_DOORBELL_DATA_MASK); 11815 issue_hard_reset = 1; 11816 goto out; 11817 } else if ((ioc_state & MPI2_IOC_STATE_MASK) == 11818 MPI2_IOC_STATE_COREDUMP) { 11819 mpt3sas_base_coredump_info(ioc, ioc_state & 11820 MPI2_DOORBELL_DATA_MASK); 11821 mpt3sas_base_wait_for_coredump_completion(ioc, __func__); 11822 issue_hard_reset = 1; 11823 goto out; 11824 } 11825 return 0; 11826 } 11827 11828 if (ioc->port_enable_cmds.status & MPT3_CMD_RESET) { 11829 ioc_info(ioc, 11830 "port enable: aborted due to diag reset\n"); 11831 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED; 11832 goto out; 11833 } 11834 if (ioc->start_scan_failed) { 11835 ioc_info(ioc, "port enable: FAILED with (ioc_status=0x%08x)\n", 11836 ioc->start_scan_failed); 11837 ioc->is_driver_loading = 0; 11838 ioc->wait_for_discovery_to_complete = 0; 11839 ioc->remove_host = 1; 11840 return 1; 11841 } 11842 11843 ioc_info(ioc, "port enable: SUCCESS\n"); 11844 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED; 11845 _scsih_complete_devices_scanning(ioc); 11846 11847 out: 11848 if (issue_hard_reset) { 11849 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED; 11850 if (mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET)) 11851 ioc->is_driver_loading = 0; 11852 } 11853 return 1; 11854 } 11855 11856 /** 11857 * scsih_map_queues - map reply queues with request queues 11858 * @shost: SCSI host pointer 11859 */ 11860 static void scsih_map_queues(struct Scsi_Host *shost) 11861 { 11862 struct MPT3SAS_ADAPTER *ioc = 11863 (struct MPT3SAS_ADAPTER *)shost->hostdata; 11864 struct blk_mq_queue_map *map; 11865 int i, qoff, offset; 11866 int nr_msix_vectors = ioc->iopoll_q_start_index; 11867 int iopoll_q_count = ioc->reply_queue_count - nr_msix_vectors; 11868 11869 if (shost->nr_hw_queues == 1) 11870 return; 11871 11872 for (i = 0, qoff = 0; i < shost->nr_maps; i++) { 11873 map = &shost->tag_set.map[i]; 11874 map->nr_queues = 0; 11875 offset = 0; 11876 if (i == HCTX_TYPE_DEFAULT) { 11877 map->nr_queues = 11878 nr_msix_vectors - ioc->high_iops_queues; 11879 offset = ioc->high_iops_queues; 11880 } else if (i == HCTX_TYPE_POLL) 11881 map->nr_queues = iopoll_q_count; 11882 11883 if (!map->nr_queues) 11884 BUG_ON(i == HCTX_TYPE_DEFAULT); 11885 11886 /* 11887 * The poll queue(s) doesn't have an IRQ (and hence IRQ 11888 * affinity), so use the regular blk-mq cpu mapping 11889 */ 11890 map->queue_offset = qoff; 11891 if (i != HCTX_TYPE_POLL) 11892 blk_mq_map_hw_queues(map, &ioc->pdev->dev, offset); 11893 else 11894 blk_mq_map_queues(map); 11895 11896 qoff += map->nr_queues; 11897 } 11898 } 11899 11900 /* shost template for SAS 2.0 HBA devices */ 11901 static const struct scsi_host_template mpt2sas_driver_template = { 11902 .module = THIS_MODULE, 11903 .name = "Fusion MPT SAS Host", 11904 .proc_name = MPT2SAS_DRIVER_NAME, 11905 .queuecommand = scsih_qcmd, 11906 .target_alloc = scsih_target_alloc, 11907 .slave_alloc = scsih_slave_alloc, 11908 .device_configure = scsih_device_configure, 11909 .target_destroy = scsih_target_destroy, 11910 .slave_destroy = scsih_slave_destroy, 11911 .scan_finished = scsih_scan_finished, 11912 .scan_start = scsih_scan_start, 11913 .change_queue_depth = scsih_change_queue_depth, 11914 .eh_abort_handler = scsih_abort, 11915 .eh_device_reset_handler = scsih_dev_reset, 11916 .eh_target_reset_handler = scsih_target_reset, 11917 .eh_host_reset_handler = scsih_host_reset, 11918 .bios_param = scsih_bios_param, 11919 .can_queue = 1, 11920 .this_id = -1, 11921 .sg_tablesize = MPT2SAS_SG_DEPTH, 11922 .max_sectors = 32767, 11923 .cmd_per_lun = 7, 11924 .shost_groups = mpt3sas_host_groups, 11925 .sdev_groups = mpt3sas_dev_groups, 11926 .track_queue_depth = 1, 11927 .cmd_size = sizeof(struct scsiio_tracker), 11928 }; 11929 11930 /* raid transport support for SAS 2.0 HBA devices */ 11931 static struct raid_function_template mpt2sas_raid_functions = { 11932 .cookie = &mpt2sas_driver_template, 11933 .is_raid = scsih_is_raid, 11934 .get_resync = scsih_get_resync, 11935 .get_state = scsih_get_state, 11936 }; 11937 11938 /* shost template for SAS 3.0 HBA devices */ 11939 static const struct scsi_host_template mpt3sas_driver_template = { 11940 .module = THIS_MODULE, 11941 .name = "Fusion MPT SAS Host", 11942 .proc_name = MPT3SAS_DRIVER_NAME, 11943 .queuecommand = scsih_qcmd, 11944 .target_alloc = scsih_target_alloc, 11945 .slave_alloc = scsih_slave_alloc, 11946 .device_configure = scsih_device_configure, 11947 .target_destroy = scsih_target_destroy, 11948 .slave_destroy = scsih_slave_destroy, 11949 .scan_finished = scsih_scan_finished, 11950 .scan_start = scsih_scan_start, 11951 .change_queue_depth = scsih_change_queue_depth, 11952 .eh_abort_handler = scsih_abort, 11953 .eh_device_reset_handler = scsih_dev_reset, 11954 .eh_target_reset_handler = scsih_target_reset, 11955 .eh_host_reset_handler = scsih_host_reset, 11956 .bios_param = scsih_bios_param, 11957 .can_queue = 1, 11958 .this_id = -1, 11959 .sg_tablesize = MPT3SAS_SG_DEPTH, 11960 .max_sectors = 32767, 11961 .max_segment_size = 0xffffffff, 11962 .cmd_per_lun = 128, 11963 .shost_groups = mpt3sas_host_groups, 11964 .sdev_groups = mpt3sas_dev_groups, 11965 .track_queue_depth = 1, 11966 .cmd_size = sizeof(struct scsiio_tracker), 11967 .map_queues = scsih_map_queues, 11968 .mq_poll = mpt3sas_blk_mq_poll, 11969 }; 11970 11971 /* raid transport support for SAS 3.0 HBA devices */ 11972 static struct raid_function_template mpt3sas_raid_functions = { 11973 .cookie = &mpt3sas_driver_template, 11974 .is_raid = scsih_is_raid, 11975 .get_resync = scsih_get_resync, 11976 .get_state = scsih_get_state, 11977 }; 11978 11979 /** 11980 * _scsih_determine_hba_mpi_version - determine in which MPI version class 11981 * this device belongs to. 11982 * @pdev: PCI device struct 11983 * 11984 * return MPI2_VERSION for SAS 2.0 HBA devices, 11985 * MPI25_VERSION for SAS 3.0 HBA devices, and 11986 * MPI26 VERSION for Cutlass & Invader SAS 3.0 HBA devices 11987 */ 11988 static u16 11989 _scsih_determine_hba_mpi_version(struct pci_dev *pdev) 11990 { 11991 11992 switch (pdev->device) { 11993 case MPI2_MFGPAGE_DEVID_SSS6200: 11994 case MPI2_MFGPAGE_DEVID_SAS2004: 11995 case MPI2_MFGPAGE_DEVID_SAS2008: 11996 case MPI2_MFGPAGE_DEVID_SAS2108_1: 11997 case MPI2_MFGPAGE_DEVID_SAS2108_2: 11998 case MPI2_MFGPAGE_DEVID_SAS2108_3: 11999 case MPI2_MFGPAGE_DEVID_SAS2116_1: 12000 case MPI2_MFGPAGE_DEVID_SAS2116_2: 12001 case MPI2_MFGPAGE_DEVID_SAS2208_1: 12002 case MPI2_MFGPAGE_DEVID_SAS2208_2: 12003 case MPI2_MFGPAGE_DEVID_SAS2208_3: 12004 case MPI2_MFGPAGE_DEVID_SAS2208_4: 12005 case MPI2_MFGPAGE_DEVID_SAS2208_5: 12006 case MPI2_MFGPAGE_DEVID_SAS2208_6: 12007 case MPI2_MFGPAGE_DEVID_SAS2308_1: 12008 case MPI2_MFGPAGE_DEVID_SAS2308_2: 12009 case MPI2_MFGPAGE_DEVID_SAS2308_3: 12010 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP: 12011 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1: 12012 return MPI2_VERSION; 12013 case MPI25_MFGPAGE_DEVID_SAS3004: 12014 case MPI25_MFGPAGE_DEVID_SAS3008: 12015 case MPI25_MFGPAGE_DEVID_SAS3108_1: 12016 case MPI25_MFGPAGE_DEVID_SAS3108_2: 12017 case MPI25_MFGPAGE_DEVID_SAS3108_5: 12018 case MPI25_MFGPAGE_DEVID_SAS3108_6: 12019 return MPI25_VERSION; 12020 case MPI26_MFGPAGE_DEVID_SAS3216: 12021 case MPI26_MFGPAGE_DEVID_SAS3224: 12022 case MPI26_MFGPAGE_DEVID_SAS3316_1: 12023 case MPI26_MFGPAGE_DEVID_SAS3316_2: 12024 case MPI26_MFGPAGE_DEVID_SAS3316_3: 12025 case MPI26_MFGPAGE_DEVID_SAS3316_4: 12026 case MPI26_MFGPAGE_DEVID_SAS3324_1: 12027 case MPI26_MFGPAGE_DEVID_SAS3324_2: 12028 case MPI26_MFGPAGE_DEVID_SAS3324_3: 12029 case MPI26_MFGPAGE_DEVID_SAS3324_4: 12030 case MPI26_MFGPAGE_DEVID_SAS3508: 12031 case MPI26_MFGPAGE_DEVID_SAS3508_1: 12032 case MPI26_MFGPAGE_DEVID_SAS3408: 12033 case MPI26_MFGPAGE_DEVID_SAS3516: 12034 case MPI26_MFGPAGE_DEVID_SAS3516_1: 12035 case MPI26_MFGPAGE_DEVID_SAS3416: 12036 case MPI26_MFGPAGE_DEVID_SAS3616: 12037 case MPI26_ATLAS_PCIe_SWITCH_DEVID: 12038 case MPI26_MFGPAGE_DEVID_CFG_SEC_3916: 12039 case MPI26_MFGPAGE_DEVID_HARD_SEC_3916: 12040 case MPI26_MFGPAGE_DEVID_CFG_SEC_3816: 12041 case MPI26_MFGPAGE_DEVID_HARD_SEC_3816: 12042 case MPI26_MFGPAGE_DEVID_INVALID0_3916: 12043 case MPI26_MFGPAGE_DEVID_INVALID1_3916: 12044 case MPI26_MFGPAGE_DEVID_INVALID0_3816: 12045 case MPI26_MFGPAGE_DEVID_INVALID1_3816: 12046 return MPI26_VERSION; 12047 } 12048 return 0; 12049 } 12050 12051 /** 12052 * _scsih_probe - attach and add scsi host 12053 * @pdev: PCI device struct 12054 * @id: pci device id 12055 * 12056 * Return: 0 success, anything else error. 12057 */ 12058 static int 12059 _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id) 12060 { 12061 struct MPT3SAS_ADAPTER *ioc; 12062 struct Scsi_Host *shost = NULL; 12063 int rv; 12064 u16 hba_mpi_version; 12065 int iopoll_q_count = 0; 12066 12067 /* Determine in which MPI version class this pci device belongs */ 12068 hba_mpi_version = _scsih_determine_hba_mpi_version(pdev); 12069 if (hba_mpi_version == 0) 12070 return -ENODEV; 12071 12072 /* Enumerate only SAS 2.0 HBA's if hbas_to_enumerate is one, 12073 * for other generation HBA's return with -ENODEV 12074 */ 12075 if ((hbas_to_enumerate == 1) && (hba_mpi_version != MPI2_VERSION)) 12076 return -ENODEV; 12077 12078 /* Enumerate only SAS 3.0 HBA's if hbas_to_enumerate is two, 12079 * for other generation HBA's return with -ENODEV 12080 */ 12081 if ((hbas_to_enumerate == 2) && (!(hba_mpi_version == MPI25_VERSION 12082 || hba_mpi_version == MPI26_VERSION))) 12083 return -ENODEV; 12084 12085 switch (hba_mpi_version) { 12086 case MPI2_VERSION: 12087 pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | 12088 PCIE_LINK_STATE_L1 | PCIE_LINK_STATE_CLKPM); 12089 /* Use mpt2sas driver host template for SAS 2.0 HBA's */ 12090 shost = scsi_host_alloc(&mpt2sas_driver_template, 12091 sizeof(struct MPT3SAS_ADAPTER)); 12092 if (!shost) 12093 return -ENODEV; 12094 ioc = shost_priv(shost); 12095 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER)); 12096 ioc->hba_mpi_version_belonged = hba_mpi_version; 12097 ioc->id = mpt2_ids++; 12098 sprintf(ioc->driver_name, "%s", MPT2SAS_DRIVER_NAME); 12099 switch (pdev->device) { 12100 case MPI2_MFGPAGE_DEVID_SSS6200: 12101 ioc->is_warpdrive = 1; 12102 ioc->hide_ir_msg = 1; 12103 break; 12104 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP: 12105 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1: 12106 ioc->is_mcpu_endpoint = 1; 12107 break; 12108 default: 12109 ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS; 12110 break; 12111 } 12112 12113 if (multipath_on_hba == -1 || multipath_on_hba == 0) 12114 ioc->multipath_on_hba = 0; 12115 else 12116 ioc->multipath_on_hba = 1; 12117 12118 break; 12119 case MPI25_VERSION: 12120 case MPI26_VERSION: 12121 /* Use mpt3sas driver host template for SAS 3.0 HBA's */ 12122 shost = scsi_host_alloc(&mpt3sas_driver_template, 12123 sizeof(struct MPT3SAS_ADAPTER)); 12124 if (!shost) 12125 return -ENODEV; 12126 ioc = shost_priv(shost); 12127 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER)); 12128 ioc->hba_mpi_version_belonged = hba_mpi_version; 12129 ioc->id = mpt3_ids++; 12130 sprintf(ioc->driver_name, "%s", MPT3SAS_DRIVER_NAME); 12131 switch (pdev->device) { 12132 case MPI26_MFGPAGE_DEVID_SAS3508: 12133 case MPI26_MFGPAGE_DEVID_SAS3508_1: 12134 case MPI26_MFGPAGE_DEVID_SAS3408: 12135 case MPI26_MFGPAGE_DEVID_SAS3516: 12136 case MPI26_MFGPAGE_DEVID_SAS3516_1: 12137 case MPI26_MFGPAGE_DEVID_SAS3416: 12138 case MPI26_MFGPAGE_DEVID_SAS3616: 12139 case MPI26_ATLAS_PCIe_SWITCH_DEVID: 12140 ioc->is_gen35_ioc = 1; 12141 break; 12142 case MPI26_MFGPAGE_DEVID_INVALID0_3816: 12143 case MPI26_MFGPAGE_DEVID_INVALID0_3916: 12144 dev_err(&pdev->dev, 12145 "HBA with DeviceId 0x%04x, sub VendorId 0x%04x, sub DeviceId 0x%04x is Invalid", 12146 pdev->device, pdev->subsystem_vendor, 12147 pdev->subsystem_device); 12148 return 1; 12149 case MPI26_MFGPAGE_DEVID_INVALID1_3816: 12150 case MPI26_MFGPAGE_DEVID_INVALID1_3916: 12151 dev_err(&pdev->dev, 12152 "HBA with DeviceId 0x%04x, sub VendorId 0x%04x, sub DeviceId 0x%04x is Tampered", 12153 pdev->device, pdev->subsystem_vendor, 12154 pdev->subsystem_device); 12155 return 1; 12156 case MPI26_MFGPAGE_DEVID_CFG_SEC_3816: 12157 case MPI26_MFGPAGE_DEVID_CFG_SEC_3916: 12158 dev_info(&pdev->dev, 12159 "HBA is in Configurable Secure mode\n"); 12160 fallthrough; 12161 case MPI26_MFGPAGE_DEVID_HARD_SEC_3816: 12162 case MPI26_MFGPAGE_DEVID_HARD_SEC_3916: 12163 ioc->is_aero_ioc = ioc->is_gen35_ioc = 1; 12164 break; 12165 default: 12166 ioc->is_gen35_ioc = ioc->is_aero_ioc = 0; 12167 } 12168 if ((ioc->hba_mpi_version_belonged == MPI25_VERSION && 12169 pdev->revision >= SAS3_PCI_DEVICE_C0_REVISION) || 12170 (ioc->hba_mpi_version_belonged == MPI26_VERSION)) { 12171 ioc->combined_reply_queue = 1; 12172 if (ioc->is_gen35_ioc) 12173 ioc->combined_reply_index_count = 12174 MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G35; 12175 else 12176 ioc->combined_reply_index_count = 12177 MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G3; 12178 } 12179 12180 switch (ioc->is_gen35_ioc) { 12181 case 0: 12182 if (multipath_on_hba == -1 || multipath_on_hba == 0) 12183 ioc->multipath_on_hba = 0; 12184 else 12185 ioc->multipath_on_hba = 1; 12186 break; 12187 case 1: 12188 if (multipath_on_hba == -1 || multipath_on_hba > 0) 12189 ioc->multipath_on_hba = 1; 12190 else 12191 ioc->multipath_on_hba = 0; 12192 break; 12193 default: 12194 break; 12195 } 12196 12197 break; 12198 default: 12199 return -ENODEV; 12200 } 12201 12202 INIT_LIST_HEAD(&ioc->list); 12203 spin_lock(&gioc_lock); 12204 list_add_tail(&ioc->list, &mpt3sas_ioc_list); 12205 spin_unlock(&gioc_lock); 12206 ioc->shost = shost; 12207 ioc->pdev = pdev; 12208 ioc->scsi_io_cb_idx = scsi_io_cb_idx; 12209 ioc->tm_cb_idx = tm_cb_idx; 12210 ioc->ctl_cb_idx = ctl_cb_idx; 12211 ioc->base_cb_idx = base_cb_idx; 12212 ioc->port_enable_cb_idx = port_enable_cb_idx; 12213 ioc->transport_cb_idx = transport_cb_idx; 12214 ioc->scsih_cb_idx = scsih_cb_idx; 12215 ioc->config_cb_idx = config_cb_idx; 12216 ioc->tm_tr_cb_idx = tm_tr_cb_idx; 12217 ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx; 12218 ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx; 12219 ioc->logging_level = logging_level; 12220 ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds; 12221 /* Host waits for minimum of six seconds */ 12222 ioc->max_shutdown_latency = IO_UNIT_CONTROL_SHUTDOWN_TIMEOUT; 12223 /* 12224 * Enable MEMORY MOVE support flag. 12225 */ 12226 ioc->drv_support_bitmap |= MPT_DRV_SUPPORT_BITMAP_MEMMOVE; 12227 /* Enable ADDITIONAL QUERY support flag. */ 12228 ioc->drv_support_bitmap |= MPT_DRV_SUPPORT_BITMAP_ADDNLQUERY; 12229 12230 ioc->enable_sdev_max_qd = enable_sdev_max_qd; 12231 12232 /* misc semaphores and spin locks */ 12233 mutex_init(&ioc->reset_in_progress_mutex); 12234 mutex_init(&ioc->hostdiag_unlock_mutex); 12235 /* initializing pci_access_mutex lock */ 12236 mutex_init(&ioc->pci_access_mutex); 12237 spin_lock_init(&ioc->ioc_reset_in_progress_lock); 12238 spin_lock_init(&ioc->scsi_lookup_lock); 12239 spin_lock_init(&ioc->sas_device_lock); 12240 spin_lock_init(&ioc->sas_node_lock); 12241 spin_lock_init(&ioc->fw_event_lock); 12242 spin_lock_init(&ioc->raid_device_lock); 12243 spin_lock_init(&ioc->pcie_device_lock); 12244 spin_lock_init(&ioc->diag_trigger_lock); 12245 12246 INIT_LIST_HEAD(&ioc->sas_device_list); 12247 INIT_LIST_HEAD(&ioc->sas_device_init_list); 12248 INIT_LIST_HEAD(&ioc->sas_expander_list); 12249 INIT_LIST_HEAD(&ioc->enclosure_list); 12250 INIT_LIST_HEAD(&ioc->pcie_device_list); 12251 INIT_LIST_HEAD(&ioc->pcie_device_init_list); 12252 INIT_LIST_HEAD(&ioc->fw_event_list); 12253 INIT_LIST_HEAD(&ioc->raid_device_list); 12254 INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list); 12255 INIT_LIST_HEAD(&ioc->delayed_tr_list); 12256 INIT_LIST_HEAD(&ioc->delayed_sc_list); 12257 INIT_LIST_HEAD(&ioc->delayed_event_ack_list); 12258 INIT_LIST_HEAD(&ioc->delayed_tr_volume_list); 12259 INIT_LIST_HEAD(&ioc->reply_queue_list); 12260 INIT_LIST_HEAD(&ioc->port_table_list); 12261 12262 sprintf(ioc->name, "%s_cm%d", ioc->driver_name, ioc->id); 12263 12264 /* init shost parameters */ 12265 shost->max_cmd_len = 32; 12266 shost->max_lun = max_lun; 12267 shost->transportt = mpt3sas_transport_template; 12268 shost->unique_id = ioc->id; 12269 12270 if (ioc->is_mcpu_endpoint) { 12271 /* mCPU MPI support 64K max IO */ 12272 shost->max_sectors = 128; 12273 ioc_info(ioc, "The max_sectors value is set to %d\n", 12274 shost->max_sectors); 12275 } else { 12276 if (max_sectors != 0xFFFF) { 12277 if (max_sectors < 64) { 12278 shost->max_sectors = 64; 12279 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767. Assigning value of 64.\n", 12280 max_sectors); 12281 } else if (max_sectors > 32767) { 12282 shost->max_sectors = 32767; 12283 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767.Assigning default value of 32767.\n", 12284 max_sectors); 12285 } else { 12286 shost->max_sectors = max_sectors & 0xFFFE; 12287 ioc_info(ioc, "The max_sectors value is set to %d\n", 12288 shost->max_sectors); 12289 } 12290 } 12291 } 12292 /* register EEDP capabilities with SCSI layer */ 12293 if (prot_mask >= 0) 12294 scsi_host_set_prot(shost, (prot_mask & 0x07)); 12295 else 12296 scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION 12297 | SHOST_DIF_TYPE2_PROTECTION 12298 | SHOST_DIF_TYPE3_PROTECTION); 12299 12300 scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC); 12301 12302 /* event thread */ 12303 ioc->firmware_event_thread = alloc_ordered_workqueue( 12304 "fw_event_%s%d", 0, ioc->driver_name, ioc->id); 12305 if (!ioc->firmware_event_thread) { 12306 ioc_err(ioc, "failure at %s:%d/%s()!\n", 12307 __FILE__, __LINE__, __func__); 12308 rv = -ENODEV; 12309 goto out_thread_fail; 12310 } 12311 12312 shost->host_tagset = 0; 12313 12314 if (ioc->is_gen35_ioc && host_tagset_enable) 12315 shost->host_tagset = 1; 12316 12317 ioc->is_driver_loading = 1; 12318 if ((mpt3sas_base_attach(ioc))) { 12319 ioc_err(ioc, "failure at %s:%d/%s()!\n", 12320 __FILE__, __LINE__, __func__); 12321 rv = -ENODEV; 12322 goto out_attach_fail; 12323 } 12324 12325 if (ioc->is_warpdrive) { 12326 if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_EXPOSE_ALL_DISKS) 12327 ioc->hide_drives = 0; 12328 else if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_HIDE_ALL_DISKS) 12329 ioc->hide_drives = 1; 12330 else { 12331 if (mpt3sas_get_num_volumes(ioc)) 12332 ioc->hide_drives = 1; 12333 else 12334 ioc->hide_drives = 0; 12335 } 12336 } else 12337 ioc->hide_drives = 0; 12338 12339 shost->nr_hw_queues = 1; 12340 12341 if (shost->host_tagset) { 12342 shost->nr_hw_queues = 12343 ioc->reply_queue_count - ioc->high_iops_queues; 12344 12345 iopoll_q_count = 12346 ioc->reply_queue_count - ioc->iopoll_q_start_index; 12347 12348 shost->nr_maps = iopoll_q_count ? 3 : 1; 12349 12350 dev_info(&ioc->pdev->dev, 12351 "Max SCSIIO MPT commands: %d shared with nr_hw_queues = %d\n", 12352 shost->can_queue, shost->nr_hw_queues); 12353 } 12354 12355 rv = scsi_add_host(shost, &pdev->dev); 12356 if (rv) { 12357 ioc_err(ioc, "failure at %s:%d/%s()!\n", 12358 __FILE__, __LINE__, __func__); 12359 goto out_add_shost_fail; 12360 } 12361 12362 scsi_scan_host(shost); 12363 mpt3sas_setup_debugfs(ioc); 12364 return 0; 12365 out_add_shost_fail: 12366 mpt3sas_base_detach(ioc); 12367 out_attach_fail: 12368 destroy_workqueue(ioc->firmware_event_thread); 12369 out_thread_fail: 12370 spin_lock(&gioc_lock); 12371 list_del(&ioc->list); 12372 spin_unlock(&gioc_lock); 12373 scsi_host_put(shost); 12374 return rv; 12375 } 12376 12377 /** 12378 * scsih_suspend - power management suspend main entry point 12379 * @dev: Device struct 12380 * 12381 * Return: 0 success, anything else error. 12382 */ 12383 static int __maybe_unused 12384 scsih_suspend(struct device *dev) 12385 { 12386 struct pci_dev *pdev = to_pci_dev(dev); 12387 struct Scsi_Host *shost; 12388 struct MPT3SAS_ADAPTER *ioc; 12389 int rc; 12390 12391 rc = _scsih_get_shost_and_ioc(pdev, &shost, &ioc); 12392 if (rc) 12393 return rc; 12394 12395 mpt3sas_base_stop_watchdog(ioc); 12396 scsi_block_requests(shost); 12397 _scsih_nvme_shutdown(ioc); 12398 ioc_info(ioc, "pdev=0x%p, slot=%s, entering operating state\n", 12399 pdev, pci_name(pdev)); 12400 12401 mpt3sas_base_free_resources(ioc); 12402 return 0; 12403 } 12404 12405 /** 12406 * scsih_resume - power management resume main entry point 12407 * @dev: Device struct 12408 * 12409 * Return: 0 success, anything else error. 12410 */ 12411 static int __maybe_unused 12412 scsih_resume(struct device *dev) 12413 { 12414 struct pci_dev *pdev = to_pci_dev(dev); 12415 struct Scsi_Host *shost; 12416 struct MPT3SAS_ADAPTER *ioc; 12417 pci_power_t device_state = pdev->current_state; 12418 int r; 12419 12420 r = _scsih_get_shost_and_ioc(pdev, &shost, &ioc); 12421 if (r) 12422 return r; 12423 12424 ioc_info(ioc, "pdev=0x%p, slot=%s, previous operating state [D%d]\n", 12425 pdev, pci_name(pdev), device_state); 12426 12427 ioc->pdev = pdev; 12428 r = mpt3sas_base_map_resources(ioc); 12429 if (r) 12430 return r; 12431 ioc_info(ioc, "Issuing Hard Reset as part of OS Resume\n"); 12432 mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET); 12433 scsi_unblock_requests(shost); 12434 mpt3sas_base_start_watchdog(ioc); 12435 return 0; 12436 } 12437 12438 /** 12439 * scsih_pci_error_detected - Called when a PCI error is detected. 12440 * @pdev: PCI device struct 12441 * @state: PCI channel state 12442 * 12443 * Description: Called when a PCI error is detected. 12444 * 12445 * Return: PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT. 12446 */ 12447 static pci_ers_result_t 12448 scsih_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state) 12449 { 12450 struct Scsi_Host *shost; 12451 struct MPT3SAS_ADAPTER *ioc; 12452 12453 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 12454 return PCI_ERS_RESULT_DISCONNECT; 12455 12456 ioc_info(ioc, "PCI error: detected callback, state(%d)!!\n", state); 12457 12458 switch (state) { 12459 case pci_channel_io_normal: 12460 return PCI_ERS_RESULT_CAN_RECOVER; 12461 case pci_channel_io_frozen: 12462 /* Fatal error, prepare for slot reset */ 12463 ioc->pci_error_recovery = 1; 12464 scsi_block_requests(ioc->shost); 12465 mpt3sas_base_stop_watchdog(ioc); 12466 mpt3sas_base_free_resources(ioc); 12467 return PCI_ERS_RESULT_NEED_RESET; 12468 case pci_channel_io_perm_failure: 12469 /* Permanent error, prepare for device removal */ 12470 ioc->pci_error_recovery = 1; 12471 mpt3sas_base_stop_watchdog(ioc); 12472 mpt3sas_base_pause_mq_polling(ioc); 12473 _scsih_flush_running_cmds(ioc); 12474 return PCI_ERS_RESULT_DISCONNECT; 12475 } 12476 return PCI_ERS_RESULT_NEED_RESET; 12477 } 12478 12479 /** 12480 * scsih_pci_slot_reset - Called when PCI slot has been reset. 12481 * @pdev: PCI device struct 12482 * 12483 * Description: This routine is called by the pci error recovery 12484 * code after the PCI slot has been reset, just before we 12485 * should resume normal operations. 12486 */ 12487 static pci_ers_result_t 12488 scsih_pci_slot_reset(struct pci_dev *pdev) 12489 { 12490 struct Scsi_Host *shost; 12491 struct MPT3SAS_ADAPTER *ioc; 12492 int rc; 12493 12494 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 12495 return PCI_ERS_RESULT_DISCONNECT; 12496 12497 ioc_info(ioc, "PCI error: slot reset callback!!\n"); 12498 12499 ioc->pci_error_recovery = 0; 12500 ioc->pdev = pdev; 12501 pci_restore_state(pdev); 12502 rc = mpt3sas_base_map_resources(ioc); 12503 if (rc) 12504 return PCI_ERS_RESULT_DISCONNECT; 12505 12506 ioc_info(ioc, "Issuing Hard Reset as part of PCI Slot Reset\n"); 12507 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 12508 12509 ioc_warn(ioc, "hard reset: %s\n", 12510 (rc == 0) ? "success" : "failed"); 12511 12512 if (!rc) 12513 return PCI_ERS_RESULT_RECOVERED; 12514 else 12515 return PCI_ERS_RESULT_DISCONNECT; 12516 } 12517 12518 /** 12519 * scsih_pci_resume() - resume normal ops after PCI reset 12520 * @pdev: pointer to PCI device 12521 * 12522 * Called when the error recovery driver tells us that its 12523 * OK to resume normal operation. Use completion to allow 12524 * halted scsi ops to resume. 12525 */ 12526 static void 12527 scsih_pci_resume(struct pci_dev *pdev) 12528 { 12529 struct Scsi_Host *shost; 12530 struct MPT3SAS_ADAPTER *ioc; 12531 12532 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 12533 return; 12534 12535 ioc_info(ioc, "PCI error: resume callback!!\n"); 12536 12537 mpt3sas_base_start_watchdog(ioc); 12538 scsi_unblock_requests(ioc->shost); 12539 } 12540 12541 /** 12542 * scsih_pci_mmio_enabled - Enable MMIO and dump debug registers 12543 * @pdev: pointer to PCI device 12544 */ 12545 static pci_ers_result_t 12546 scsih_pci_mmio_enabled(struct pci_dev *pdev) 12547 { 12548 struct Scsi_Host *shost; 12549 struct MPT3SAS_ADAPTER *ioc; 12550 12551 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 12552 return PCI_ERS_RESULT_DISCONNECT; 12553 12554 ioc_info(ioc, "PCI error: mmio enabled callback!!\n"); 12555 12556 /* TODO - dump whatever for debugging purposes */ 12557 12558 /* This called only if scsih_pci_error_detected returns 12559 * PCI_ERS_RESULT_CAN_RECOVER. Read/write to the device still 12560 * works, no need to reset slot. 12561 */ 12562 return PCI_ERS_RESULT_RECOVERED; 12563 } 12564 12565 /* 12566 * The pci device ids are defined in mpi/mpi2_cnfg.h. 12567 */ 12568 static const struct pci_device_id mpt3sas_pci_table[] = { 12569 /* Spitfire ~ 2004 */ 12570 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2004, 12571 PCI_ANY_ID, PCI_ANY_ID }, 12572 /* Falcon ~ 2008 */ 12573 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2008, 12574 PCI_ANY_ID, PCI_ANY_ID }, 12575 /* Liberator ~ 2108 */ 12576 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_1, 12577 PCI_ANY_ID, PCI_ANY_ID }, 12578 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_2, 12579 PCI_ANY_ID, PCI_ANY_ID }, 12580 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_3, 12581 PCI_ANY_ID, PCI_ANY_ID }, 12582 /* Meteor ~ 2116 */ 12583 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_1, 12584 PCI_ANY_ID, PCI_ANY_ID }, 12585 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_2, 12586 PCI_ANY_ID, PCI_ANY_ID }, 12587 /* Thunderbolt ~ 2208 */ 12588 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_1, 12589 PCI_ANY_ID, PCI_ANY_ID }, 12590 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_2, 12591 PCI_ANY_ID, PCI_ANY_ID }, 12592 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_3, 12593 PCI_ANY_ID, PCI_ANY_ID }, 12594 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_4, 12595 PCI_ANY_ID, PCI_ANY_ID }, 12596 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_5, 12597 PCI_ANY_ID, PCI_ANY_ID }, 12598 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_6, 12599 PCI_ANY_ID, PCI_ANY_ID }, 12600 /* Mustang ~ 2308 */ 12601 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_1, 12602 PCI_ANY_ID, PCI_ANY_ID }, 12603 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_2, 12604 PCI_ANY_ID, PCI_ANY_ID }, 12605 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_3, 12606 PCI_ANY_ID, PCI_ANY_ID }, 12607 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP, 12608 PCI_ANY_ID, PCI_ANY_ID }, 12609 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1, 12610 PCI_ANY_ID, PCI_ANY_ID }, 12611 /* SSS6200 */ 12612 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SSS6200, 12613 PCI_ANY_ID, PCI_ANY_ID }, 12614 /* Fury ~ 3004 and 3008 */ 12615 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3004, 12616 PCI_ANY_ID, PCI_ANY_ID }, 12617 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3008, 12618 PCI_ANY_ID, PCI_ANY_ID }, 12619 /* Invader ~ 3108 */ 12620 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_1, 12621 PCI_ANY_ID, PCI_ANY_ID }, 12622 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_2, 12623 PCI_ANY_ID, PCI_ANY_ID }, 12624 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_5, 12625 PCI_ANY_ID, PCI_ANY_ID }, 12626 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_6, 12627 PCI_ANY_ID, PCI_ANY_ID }, 12628 /* Cutlass ~ 3216 and 3224 */ 12629 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3216, 12630 PCI_ANY_ID, PCI_ANY_ID }, 12631 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3224, 12632 PCI_ANY_ID, PCI_ANY_ID }, 12633 /* Intruder ~ 3316 and 3324 */ 12634 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_1, 12635 PCI_ANY_ID, PCI_ANY_ID }, 12636 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_2, 12637 PCI_ANY_ID, PCI_ANY_ID }, 12638 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_3, 12639 PCI_ANY_ID, PCI_ANY_ID }, 12640 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_4, 12641 PCI_ANY_ID, PCI_ANY_ID }, 12642 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_1, 12643 PCI_ANY_ID, PCI_ANY_ID }, 12644 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_2, 12645 PCI_ANY_ID, PCI_ANY_ID }, 12646 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_3, 12647 PCI_ANY_ID, PCI_ANY_ID }, 12648 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_4, 12649 PCI_ANY_ID, PCI_ANY_ID }, 12650 /* Ventura, Crusader, Harpoon & Tomcat ~ 3516, 3416, 3508 & 3408*/ 12651 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508, 12652 PCI_ANY_ID, PCI_ANY_ID }, 12653 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508_1, 12654 PCI_ANY_ID, PCI_ANY_ID }, 12655 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3408, 12656 PCI_ANY_ID, PCI_ANY_ID }, 12657 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516, 12658 PCI_ANY_ID, PCI_ANY_ID }, 12659 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516_1, 12660 PCI_ANY_ID, PCI_ANY_ID }, 12661 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3416, 12662 PCI_ANY_ID, PCI_ANY_ID }, 12663 /* Mercator ~ 3616*/ 12664 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3616, 12665 PCI_ANY_ID, PCI_ANY_ID }, 12666 12667 /* Aero SI 0x00E1 Configurable Secure 12668 * 0x00E2 Hard Secure 12669 */ 12670 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_CFG_SEC_3916, 12671 PCI_ANY_ID, PCI_ANY_ID }, 12672 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_HARD_SEC_3916, 12673 PCI_ANY_ID, PCI_ANY_ID }, 12674 12675 /* 12676 * Aero SI –> 0x00E0 Invalid, 0x00E3 Tampered 12677 */ 12678 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_INVALID0_3916, 12679 PCI_ANY_ID, PCI_ANY_ID }, 12680 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_INVALID1_3916, 12681 PCI_ANY_ID, PCI_ANY_ID }, 12682 12683 /* Atlas PCIe Switch Management Port */ 12684 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_ATLAS_PCIe_SWITCH_DEVID, 12685 PCI_ANY_ID, PCI_ANY_ID }, 12686 12687 /* Sea SI 0x00E5 Configurable Secure 12688 * 0x00E6 Hard Secure 12689 */ 12690 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_CFG_SEC_3816, 12691 PCI_ANY_ID, PCI_ANY_ID }, 12692 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_HARD_SEC_3816, 12693 PCI_ANY_ID, PCI_ANY_ID }, 12694 12695 /* 12696 * ATTO Branded ExpressSAS H12xx GT 12697 */ 12698 { MPI2_MFGPAGE_VENDORID_ATTO, MPI26_MFGPAGE_DEVID_HARD_SEC_3816, 12699 PCI_ANY_ID, PCI_ANY_ID }, 12700 12701 /* 12702 * Sea SI –> 0x00E4 Invalid, 0x00E7 Tampered 12703 */ 12704 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_INVALID0_3816, 12705 PCI_ANY_ID, PCI_ANY_ID }, 12706 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_INVALID1_3816, 12707 PCI_ANY_ID, PCI_ANY_ID }, 12708 12709 {0} /* Terminating entry */ 12710 }; 12711 MODULE_DEVICE_TABLE(pci, mpt3sas_pci_table); 12712 12713 static struct pci_error_handlers _mpt3sas_err_handler = { 12714 .error_detected = scsih_pci_error_detected, 12715 .mmio_enabled = scsih_pci_mmio_enabled, 12716 .slot_reset = scsih_pci_slot_reset, 12717 .resume = scsih_pci_resume, 12718 }; 12719 12720 static SIMPLE_DEV_PM_OPS(scsih_pm_ops, scsih_suspend, scsih_resume); 12721 12722 static struct pci_driver mpt3sas_driver = { 12723 .name = MPT3SAS_DRIVER_NAME, 12724 .id_table = mpt3sas_pci_table, 12725 .probe = _scsih_probe, 12726 .remove = scsih_remove, 12727 .shutdown = scsih_shutdown, 12728 .err_handler = &_mpt3sas_err_handler, 12729 .driver.pm = &scsih_pm_ops, 12730 }; 12731 12732 /** 12733 * scsih_init - main entry point for this driver. 12734 * 12735 * Return: 0 success, anything else error. 12736 */ 12737 static int 12738 scsih_init(void) 12739 { 12740 mpt2_ids = 0; 12741 mpt3_ids = 0; 12742 12743 mpt3sas_base_initialize_callback_handler(); 12744 12745 /* queuecommand callback hander */ 12746 scsi_io_cb_idx = mpt3sas_base_register_callback_handler(_scsih_io_done); 12747 12748 /* task management callback handler */ 12749 tm_cb_idx = mpt3sas_base_register_callback_handler(_scsih_tm_done); 12750 12751 /* base internal commands callback handler */ 12752 base_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_base_done); 12753 port_enable_cb_idx = mpt3sas_base_register_callback_handler( 12754 mpt3sas_port_enable_done); 12755 12756 /* transport internal commands callback handler */ 12757 transport_cb_idx = mpt3sas_base_register_callback_handler( 12758 mpt3sas_transport_done); 12759 12760 /* scsih internal commands callback handler */ 12761 scsih_cb_idx = mpt3sas_base_register_callback_handler(_scsih_done); 12762 12763 /* configuration page API internal commands callback handler */ 12764 config_cb_idx = mpt3sas_base_register_callback_handler( 12765 mpt3sas_config_done); 12766 12767 /* ctl module callback handler */ 12768 ctl_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_ctl_done); 12769 12770 tm_tr_cb_idx = mpt3sas_base_register_callback_handler( 12771 _scsih_tm_tr_complete); 12772 12773 tm_tr_volume_cb_idx = mpt3sas_base_register_callback_handler( 12774 _scsih_tm_volume_tr_complete); 12775 12776 tm_sas_control_cb_idx = mpt3sas_base_register_callback_handler( 12777 _scsih_sas_control_complete); 12778 12779 mpt3sas_init_debugfs(); 12780 return 0; 12781 } 12782 12783 /** 12784 * scsih_exit - exit point for this driver (when it is a module). 12785 * 12786 * Return: 0 success, anything else error. 12787 */ 12788 static void 12789 scsih_exit(void) 12790 { 12791 12792 mpt3sas_base_release_callback_handler(scsi_io_cb_idx); 12793 mpt3sas_base_release_callback_handler(tm_cb_idx); 12794 mpt3sas_base_release_callback_handler(base_cb_idx); 12795 mpt3sas_base_release_callback_handler(port_enable_cb_idx); 12796 mpt3sas_base_release_callback_handler(transport_cb_idx); 12797 mpt3sas_base_release_callback_handler(scsih_cb_idx); 12798 mpt3sas_base_release_callback_handler(config_cb_idx); 12799 mpt3sas_base_release_callback_handler(ctl_cb_idx); 12800 12801 mpt3sas_base_release_callback_handler(tm_tr_cb_idx); 12802 mpt3sas_base_release_callback_handler(tm_tr_volume_cb_idx); 12803 mpt3sas_base_release_callback_handler(tm_sas_control_cb_idx); 12804 12805 /* raid transport support */ 12806 if (hbas_to_enumerate != 1) 12807 raid_class_release(mpt3sas_raid_template); 12808 if (hbas_to_enumerate != 2) 12809 raid_class_release(mpt2sas_raid_template); 12810 sas_release_transport(mpt3sas_transport_template); 12811 mpt3sas_exit_debugfs(); 12812 } 12813 12814 /** 12815 * _mpt3sas_init - main entry point for this driver. 12816 * 12817 * Return: 0 success, anything else error. 12818 */ 12819 static int __init 12820 _mpt3sas_init(void) 12821 { 12822 int error; 12823 12824 pr_info("%s version %s loaded\n", MPT3SAS_DRIVER_NAME, 12825 MPT3SAS_DRIVER_VERSION); 12826 12827 mpt3sas_transport_template = 12828 sas_attach_transport(&mpt3sas_transport_functions); 12829 if (!mpt3sas_transport_template) 12830 return -ENODEV; 12831 12832 /* No need attach mpt3sas raid functions template 12833 * if hbas_to_enumarate value is one. 12834 */ 12835 if (hbas_to_enumerate != 1) { 12836 mpt3sas_raid_template = 12837 raid_class_attach(&mpt3sas_raid_functions); 12838 if (!mpt3sas_raid_template) { 12839 sas_release_transport(mpt3sas_transport_template); 12840 return -ENODEV; 12841 } 12842 } 12843 12844 /* No need to attach mpt2sas raid functions template 12845 * if hbas_to_enumarate value is two 12846 */ 12847 if (hbas_to_enumerate != 2) { 12848 mpt2sas_raid_template = 12849 raid_class_attach(&mpt2sas_raid_functions); 12850 if (!mpt2sas_raid_template) { 12851 sas_release_transport(mpt3sas_transport_template); 12852 return -ENODEV; 12853 } 12854 } 12855 12856 error = scsih_init(); 12857 if (error) { 12858 scsih_exit(); 12859 return error; 12860 } 12861 12862 mpt3sas_ctl_init(hbas_to_enumerate); 12863 12864 error = pci_register_driver(&mpt3sas_driver); 12865 if (error) { 12866 mpt3sas_ctl_exit(hbas_to_enumerate); 12867 scsih_exit(); 12868 } 12869 12870 return error; 12871 } 12872 12873 /** 12874 * _mpt3sas_exit - exit point for this driver (when it is a module). 12875 * 12876 */ 12877 static void __exit 12878 _mpt3sas_exit(void) 12879 { 12880 pr_info("mpt3sas version %s unloading\n", 12881 MPT3SAS_DRIVER_VERSION); 12882 12883 pci_unregister_driver(&mpt3sas_driver); 12884 12885 mpt3sas_ctl_exit(hbas_to_enumerate); 12886 12887 scsih_exit(); 12888 } 12889 12890 module_init(_mpt3sas_init); 12891 module_exit(_mpt3sas_exit); 12892