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