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_CHECK_REFTAG; 5070 5071 if (scmd->prot_flags & SCSI_PROT_REF_INCREMENT) { 5072 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG; 5073 5074 mpi_request->CDB.EEDP32.PrimaryReferenceTag = 5075 cpu_to_be32(scsi_prot_ref_tag(scmd)); 5076 } 5077 5078 mpi_request_3v->EEDPBlockSize = cpu_to_le16(scsi_prot_interval(scmd)); 5079 5080 if (ioc->is_gen35_ioc) 5081 eedp_flags |= MPI25_SCSIIO_EEDPFLAGS_APPTAG_DISABLE_MODE; 5082 mpi_request->EEDPFlags = cpu_to_le16(eedp_flags); 5083 } 5084 5085 /** 5086 * _scsih_eedp_error_handling - return sense code for EEDP errors 5087 * @scmd: pointer to scsi command object 5088 * @ioc_status: ioc status 5089 */ 5090 static void 5091 _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status) 5092 { 5093 u8 ascq; 5094 5095 switch (ioc_status) { 5096 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR: 5097 ascq = 0x01; 5098 break; 5099 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR: 5100 ascq = 0x02; 5101 break; 5102 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR: 5103 ascq = 0x03; 5104 break; 5105 default: 5106 ascq = 0x00; 5107 break; 5108 } 5109 scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 0x10, ascq); 5110 set_host_byte(scmd, DID_ABORT); 5111 } 5112 5113 /** 5114 * scsih_qcmd - main scsi request entry point 5115 * @shost: SCSI host pointer 5116 * @scmd: pointer to scsi command object 5117 * 5118 * The callback index is set inside `ioc->scsi_io_cb_idx`. 5119 * 5120 * Return: 0 on success. If there's a failure, return either: 5121 * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or 5122 * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full 5123 */ 5124 static int 5125 scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd) 5126 { 5127 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 5128 struct MPT3SAS_DEVICE *sas_device_priv_data; 5129 struct MPT3SAS_TARGET *sas_target_priv_data; 5130 struct _raid_device *raid_device; 5131 struct request *rq = scsi_cmd_to_rq(scmd); 5132 int class; 5133 Mpi25SCSIIORequest_t *mpi_request; 5134 struct _pcie_device *pcie_device = NULL; 5135 u32 mpi_control; 5136 u16 smid; 5137 u16 handle; 5138 5139 if (ioc->logging_level & MPT_DEBUG_SCSI) 5140 scsi_print_command(scmd); 5141 5142 sas_device_priv_data = scmd->device->hostdata; 5143 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) { 5144 scmd->result = DID_NO_CONNECT << 16; 5145 scsi_done(scmd); 5146 return 0; 5147 } 5148 5149 if (!(_scsih_allow_scmd_to_device(ioc, scmd))) { 5150 scmd->result = DID_NO_CONNECT << 16; 5151 scsi_done(scmd); 5152 return 0; 5153 } 5154 5155 sas_target_priv_data = sas_device_priv_data->sas_target; 5156 5157 /* invalid device handle */ 5158 handle = sas_target_priv_data->handle; 5159 if (handle == MPT3SAS_INVALID_DEVICE_HANDLE) { 5160 scmd->result = DID_NO_CONNECT << 16; 5161 scsi_done(scmd); 5162 return 0; 5163 } 5164 5165 5166 if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress) { 5167 /* host recovery or link resets sent via IOCTLs */ 5168 return SCSI_MLQUEUE_HOST_BUSY; 5169 } else if (sas_target_priv_data->deleted) { 5170 /* device has been deleted */ 5171 scmd->result = DID_NO_CONNECT << 16; 5172 scsi_done(scmd); 5173 return 0; 5174 } else if (sas_target_priv_data->tm_busy || 5175 sas_device_priv_data->block) { 5176 /* device busy with task management */ 5177 return SCSI_MLQUEUE_DEVICE_BUSY; 5178 } 5179 5180 /* 5181 * Bug work around for firmware SATL handling. The loop 5182 * is based on atomic operations and ensures consistency 5183 * since we're lockless at this point 5184 */ 5185 do { 5186 if (test_bit(0, &sas_device_priv_data->ata_command_pending)) 5187 return SCSI_MLQUEUE_DEVICE_BUSY; 5188 } while (_scsih_set_satl_pending(scmd, true)); 5189 5190 if (scmd->sc_data_direction == DMA_FROM_DEVICE) 5191 mpi_control = MPI2_SCSIIO_CONTROL_READ; 5192 else if (scmd->sc_data_direction == DMA_TO_DEVICE) 5193 mpi_control = MPI2_SCSIIO_CONTROL_WRITE; 5194 else 5195 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER; 5196 5197 /* set tags */ 5198 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ; 5199 /* NCQ Prio supported, make sure control indicated high priority */ 5200 if (sas_device_priv_data->ncq_prio_enable) { 5201 class = IOPRIO_PRIO_CLASS(req_get_ioprio(rq)); 5202 if (class == IOPRIO_CLASS_RT) 5203 mpi_control |= 1 << MPI2_SCSIIO_CONTROL_CMDPRI_SHIFT; 5204 } 5205 /* Make sure Device is not raid volume. 5206 * We do not expose raid functionality to upper layer for warpdrive. 5207 */ 5208 if (((!ioc->is_warpdrive && !scsih_is_raid(&scmd->device->sdev_gendev)) 5209 && !scsih_is_nvme(&scmd->device->sdev_gendev)) 5210 && sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32) 5211 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON; 5212 5213 smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd); 5214 if (!smid) { 5215 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__); 5216 _scsih_set_satl_pending(scmd, false); 5217 goto out; 5218 } 5219 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 5220 memset(mpi_request, 0, ioc->request_sz); 5221 _scsih_setup_eedp(ioc, scmd, mpi_request); 5222 5223 if (scmd->cmd_len == 32) 5224 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT; 5225 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST; 5226 if (sas_device_priv_data->sas_target->flags & 5227 MPT_TARGET_FLAGS_RAID_COMPONENT) 5228 mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH; 5229 else 5230 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST; 5231 mpi_request->DevHandle = cpu_to_le16(handle); 5232 mpi_request->DataLength = cpu_to_le32(scsi_bufflen(scmd)); 5233 mpi_request->Control = cpu_to_le32(mpi_control); 5234 mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len); 5235 mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR; 5236 mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE; 5237 mpi_request->SenseBufferLowAddress = 5238 mpt3sas_base_get_sense_buffer_dma(ioc, smid); 5239 mpi_request->SGLOffset0 = offsetof(Mpi25SCSIIORequest_t, SGL) / 4; 5240 int_to_scsilun(sas_device_priv_data->lun, (struct scsi_lun *) 5241 mpi_request->LUN); 5242 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len); 5243 5244 if (mpi_request->DataLength) { 5245 pcie_device = sas_target_priv_data->pcie_dev; 5246 if (ioc->build_sg_scmd(ioc, scmd, smid, pcie_device)) { 5247 mpt3sas_base_free_smid(ioc, smid); 5248 _scsih_set_satl_pending(scmd, false); 5249 goto out; 5250 } 5251 } else 5252 ioc->build_zero_len_sge(ioc, &mpi_request->SGL); 5253 5254 raid_device = sas_target_priv_data->raid_device; 5255 if (raid_device && raid_device->direct_io_enabled) 5256 mpt3sas_setup_direct_io(ioc, scmd, 5257 raid_device, mpi_request); 5258 5259 if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)) { 5260 if (sas_target_priv_data->flags & MPT_TARGET_FASTPATH_IO) { 5261 mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len | 5262 MPI25_SCSIIO_IOFLAGS_FAST_PATH); 5263 ioc->put_smid_fast_path(ioc, smid, handle); 5264 } else 5265 ioc->put_smid_scsi_io(ioc, smid, 5266 le16_to_cpu(mpi_request->DevHandle)); 5267 } else 5268 ioc->put_smid_default(ioc, smid); 5269 return 0; 5270 5271 out: 5272 return SCSI_MLQUEUE_HOST_BUSY; 5273 } 5274 5275 /** 5276 * _scsih_normalize_sense - normalize descriptor and fixed format sense data 5277 * @sense_buffer: sense data returned by target 5278 * @data: normalized skey/asc/ascq 5279 */ 5280 static void 5281 _scsih_normalize_sense(char *sense_buffer, struct sense_info *data) 5282 { 5283 if ((sense_buffer[0] & 0x7F) >= 0x72) { 5284 /* descriptor format */ 5285 data->skey = sense_buffer[1] & 0x0F; 5286 data->asc = sense_buffer[2]; 5287 data->ascq = sense_buffer[3]; 5288 } else { 5289 /* fixed format */ 5290 data->skey = sense_buffer[2] & 0x0F; 5291 data->asc = sense_buffer[12]; 5292 data->ascq = sense_buffer[13]; 5293 } 5294 } 5295 5296 /** 5297 * _scsih_scsi_ioc_info - translated non-succesfull SCSI_IO request 5298 * @ioc: per adapter object 5299 * @scmd: pointer to scsi command object 5300 * @mpi_reply: reply mf payload returned from firmware 5301 * @smid: ? 5302 * 5303 * scsi_status - SCSI Status code returned from target device 5304 * scsi_state - state info associated with SCSI_IO determined by ioc 5305 * ioc_status - ioc supplied status info 5306 */ 5307 static void 5308 _scsih_scsi_ioc_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd, 5309 Mpi2SCSIIOReply_t *mpi_reply, u16 smid) 5310 { 5311 u32 response_info; 5312 u8 *response_bytes; 5313 u16 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & 5314 MPI2_IOCSTATUS_MASK; 5315 u8 scsi_state = mpi_reply->SCSIState; 5316 u8 scsi_status = mpi_reply->SCSIStatus; 5317 char *desc_ioc_state = NULL; 5318 char *desc_scsi_status = NULL; 5319 char *desc_scsi_state = ioc->tmp_string; 5320 u32 log_info = le32_to_cpu(mpi_reply->IOCLogInfo); 5321 struct _sas_device *sas_device = NULL; 5322 struct _pcie_device *pcie_device = NULL; 5323 struct scsi_target *starget = scmd->device->sdev_target; 5324 struct MPT3SAS_TARGET *priv_target = starget->hostdata; 5325 char *device_str = NULL; 5326 5327 if (!priv_target) 5328 return; 5329 if (ioc->hide_ir_msg) 5330 device_str = "WarpDrive"; 5331 else 5332 device_str = "volume"; 5333 5334 if (log_info == 0x31170000) 5335 return; 5336 5337 switch (ioc_status) { 5338 case MPI2_IOCSTATUS_SUCCESS: 5339 desc_ioc_state = "success"; 5340 break; 5341 case MPI2_IOCSTATUS_INVALID_FUNCTION: 5342 desc_ioc_state = "invalid function"; 5343 break; 5344 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR: 5345 desc_ioc_state = "scsi recovered error"; 5346 break; 5347 case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE: 5348 desc_ioc_state = "scsi invalid dev handle"; 5349 break; 5350 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE: 5351 desc_ioc_state = "scsi device not there"; 5352 break; 5353 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN: 5354 desc_ioc_state = "scsi data overrun"; 5355 break; 5356 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN: 5357 desc_ioc_state = "scsi data underrun"; 5358 break; 5359 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR: 5360 desc_ioc_state = "scsi io data error"; 5361 break; 5362 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR: 5363 desc_ioc_state = "scsi protocol error"; 5364 break; 5365 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED: 5366 desc_ioc_state = "scsi task terminated"; 5367 break; 5368 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: 5369 desc_ioc_state = "scsi residual mismatch"; 5370 break; 5371 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED: 5372 desc_ioc_state = "scsi task mgmt failed"; 5373 break; 5374 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED: 5375 desc_ioc_state = "scsi ioc terminated"; 5376 break; 5377 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED: 5378 desc_ioc_state = "scsi ext terminated"; 5379 break; 5380 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR: 5381 desc_ioc_state = "eedp guard error"; 5382 break; 5383 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR: 5384 desc_ioc_state = "eedp ref tag error"; 5385 break; 5386 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR: 5387 desc_ioc_state = "eedp app tag error"; 5388 break; 5389 case MPI2_IOCSTATUS_INSUFFICIENT_POWER: 5390 desc_ioc_state = "insufficient power"; 5391 break; 5392 default: 5393 desc_ioc_state = "unknown"; 5394 break; 5395 } 5396 5397 switch (scsi_status) { 5398 case MPI2_SCSI_STATUS_GOOD: 5399 desc_scsi_status = "good"; 5400 break; 5401 case MPI2_SCSI_STATUS_CHECK_CONDITION: 5402 desc_scsi_status = "check condition"; 5403 break; 5404 case MPI2_SCSI_STATUS_CONDITION_MET: 5405 desc_scsi_status = "condition met"; 5406 break; 5407 case MPI2_SCSI_STATUS_BUSY: 5408 desc_scsi_status = "busy"; 5409 break; 5410 case MPI2_SCSI_STATUS_INTERMEDIATE: 5411 desc_scsi_status = "intermediate"; 5412 break; 5413 case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET: 5414 desc_scsi_status = "intermediate condmet"; 5415 break; 5416 case MPI2_SCSI_STATUS_RESERVATION_CONFLICT: 5417 desc_scsi_status = "reservation conflict"; 5418 break; 5419 case MPI2_SCSI_STATUS_COMMAND_TERMINATED: 5420 desc_scsi_status = "command terminated"; 5421 break; 5422 case MPI2_SCSI_STATUS_TASK_SET_FULL: 5423 desc_scsi_status = "task set full"; 5424 break; 5425 case MPI2_SCSI_STATUS_ACA_ACTIVE: 5426 desc_scsi_status = "aca active"; 5427 break; 5428 case MPI2_SCSI_STATUS_TASK_ABORTED: 5429 desc_scsi_status = "task aborted"; 5430 break; 5431 default: 5432 desc_scsi_status = "unknown"; 5433 break; 5434 } 5435 5436 desc_scsi_state[0] = '\0'; 5437 if (!scsi_state) 5438 desc_scsi_state = " "; 5439 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) 5440 strcat(desc_scsi_state, "response info "); 5441 if (scsi_state & MPI2_SCSI_STATE_TERMINATED) 5442 strcat(desc_scsi_state, "state terminated "); 5443 if (scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS) 5444 strcat(desc_scsi_state, "no status "); 5445 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED) 5446 strcat(desc_scsi_state, "autosense failed "); 5447 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) 5448 strcat(desc_scsi_state, "autosense valid "); 5449 5450 scsi_print_command(scmd); 5451 5452 if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) { 5453 ioc_warn(ioc, "\t%s wwid(0x%016llx)\n", 5454 device_str, (u64)priv_target->sas_address); 5455 } else if (priv_target->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) { 5456 pcie_device = mpt3sas_get_pdev_from_target(ioc, priv_target); 5457 if (pcie_device) { 5458 ioc_info(ioc, "\twwid(0x%016llx), port(%d)\n", 5459 (u64)pcie_device->wwid, pcie_device->port_num); 5460 if (pcie_device->enclosure_handle != 0) 5461 ioc_info(ioc, "\tenclosure logical id(0x%016llx), slot(%d)\n", 5462 (u64)pcie_device->enclosure_logical_id, 5463 pcie_device->slot); 5464 if (pcie_device->connector_name[0]) 5465 ioc_info(ioc, "\tenclosure level(0x%04x), connector name( %s)\n", 5466 pcie_device->enclosure_level, 5467 pcie_device->connector_name); 5468 pcie_device_put(pcie_device); 5469 } 5470 } else { 5471 sas_device = mpt3sas_get_sdev_from_target(ioc, priv_target); 5472 if (sas_device) { 5473 ioc_warn(ioc, "\tsas_address(0x%016llx), phy(%d)\n", 5474 (u64)sas_device->sas_address, sas_device->phy); 5475 5476 _scsih_display_enclosure_chassis_info(ioc, sas_device, 5477 NULL, NULL); 5478 5479 sas_device_put(sas_device); 5480 } 5481 } 5482 5483 ioc_warn(ioc, "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n", 5484 le16_to_cpu(mpi_reply->DevHandle), 5485 desc_ioc_state, ioc_status, smid); 5486 ioc_warn(ioc, "\trequest_len(%d), underflow(%d), resid(%d)\n", 5487 scsi_bufflen(scmd), scmd->underflow, scsi_get_resid(scmd)); 5488 ioc_warn(ioc, "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n", 5489 le16_to_cpu(mpi_reply->TaskTag), 5490 le32_to_cpu(mpi_reply->TransferCount), scmd->result); 5491 ioc_warn(ioc, "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n", 5492 desc_scsi_status, scsi_status, desc_scsi_state, scsi_state); 5493 5494 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) { 5495 struct sense_info data; 5496 _scsih_normalize_sense(scmd->sense_buffer, &data); 5497 ioc_warn(ioc, "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n", 5498 data.skey, data.asc, data.ascq, 5499 le32_to_cpu(mpi_reply->SenseCount)); 5500 } 5501 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) { 5502 response_info = le32_to_cpu(mpi_reply->ResponseInfo); 5503 response_bytes = (u8 *)&response_info; 5504 _scsih_response_code(ioc, response_bytes[0]); 5505 } 5506 } 5507 5508 /** 5509 * _scsih_turn_on_pfa_led - illuminate PFA LED 5510 * @ioc: per adapter object 5511 * @handle: device handle 5512 * Context: process 5513 */ 5514 static void 5515 _scsih_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle) 5516 { 5517 Mpi2SepReply_t mpi_reply; 5518 Mpi2SepRequest_t mpi_request; 5519 struct _sas_device *sas_device; 5520 5521 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 5522 if (!sas_device) 5523 return; 5524 5525 memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t)); 5526 mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR; 5527 mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS; 5528 mpi_request.SlotStatus = 5529 cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT); 5530 mpi_request.DevHandle = cpu_to_le16(handle); 5531 mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS; 5532 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply, 5533 &mpi_request)) != 0) { 5534 ioc_err(ioc, "failure at %s:%d/%s()!\n", 5535 __FILE__, __LINE__, __func__); 5536 goto out; 5537 } 5538 sas_device->pfa_led_on = 1; 5539 5540 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) { 5541 dewtprintk(ioc, 5542 ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n", 5543 le16_to_cpu(mpi_reply.IOCStatus), 5544 le32_to_cpu(mpi_reply.IOCLogInfo))); 5545 goto out; 5546 } 5547 out: 5548 sas_device_put(sas_device); 5549 } 5550 5551 /** 5552 * _scsih_turn_off_pfa_led - turn off Fault LED 5553 * @ioc: per adapter object 5554 * @sas_device: sas device whose PFA LED has to turned off 5555 * Context: process 5556 */ 5557 static void 5558 _scsih_turn_off_pfa_led(struct MPT3SAS_ADAPTER *ioc, 5559 struct _sas_device *sas_device) 5560 { 5561 Mpi2SepReply_t mpi_reply; 5562 Mpi2SepRequest_t mpi_request; 5563 5564 memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t)); 5565 mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR; 5566 mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS; 5567 mpi_request.SlotStatus = 0; 5568 mpi_request.Slot = cpu_to_le16(sas_device->slot); 5569 mpi_request.DevHandle = 0; 5570 mpi_request.EnclosureHandle = cpu_to_le16(sas_device->enclosure_handle); 5571 mpi_request.Flags = MPI2_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS; 5572 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply, 5573 &mpi_request)) != 0) { 5574 ioc_err(ioc, "failure at %s:%d/%s()!\n", 5575 __FILE__, __LINE__, __func__); 5576 return; 5577 } 5578 5579 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) { 5580 dewtprintk(ioc, 5581 ioc_info(ioc, "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n", 5582 le16_to_cpu(mpi_reply.IOCStatus), 5583 le32_to_cpu(mpi_reply.IOCLogInfo))); 5584 return; 5585 } 5586 } 5587 5588 /** 5589 * _scsih_send_event_to_turn_on_pfa_led - fire delayed event 5590 * @ioc: per adapter object 5591 * @handle: device handle 5592 * Context: interrupt. 5593 */ 5594 static void 5595 _scsih_send_event_to_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle) 5596 { 5597 struct fw_event_work *fw_event; 5598 5599 fw_event = alloc_fw_event_work(0); 5600 if (!fw_event) 5601 return; 5602 fw_event->event = MPT3SAS_TURN_ON_PFA_LED; 5603 fw_event->device_handle = handle; 5604 fw_event->ioc = ioc; 5605 _scsih_fw_event_add(ioc, fw_event); 5606 fw_event_work_put(fw_event); 5607 } 5608 5609 /** 5610 * _scsih_smart_predicted_fault - process smart errors 5611 * @ioc: per adapter object 5612 * @handle: device handle 5613 * Context: interrupt. 5614 */ 5615 static void 5616 _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle) 5617 { 5618 struct scsi_target *starget; 5619 struct MPT3SAS_TARGET *sas_target_priv_data; 5620 Mpi2EventNotificationReply_t *event_reply; 5621 Mpi2EventDataSasDeviceStatusChange_t *event_data; 5622 struct _sas_device *sas_device; 5623 ssize_t sz; 5624 unsigned long flags; 5625 5626 /* only handle non-raid devices */ 5627 spin_lock_irqsave(&ioc->sas_device_lock, flags); 5628 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 5629 if (!sas_device) 5630 goto out_unlock; 5631 5632 starget = sas_device->starget; 5633 sas_target_priv_data = starget->hostdata; 5634 5635 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) || 5636 ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))) 5637 goto out_unlock; 5638 5639 _scsih_display_enclosure_chassis_info(NULL, sas_device, NULL, starget); 5640 5641 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 5642 5643 if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) 5644 _scsih_send_event_to_turn_on_pfa_led(ioc, handle); 5645 5646 /* insert into event log */ 5647 sz = offsetof(Mpi2EventNotificationReply_t, EventData) + 5648 sizeof(Mpi2EventDataSasDeviceStatusChange_t); 5649 event_reply = kzalloc(sz, GFP_ATOMIC); 5650 if (!event_reply) { 5651 ioc_err(ioc, "failure at %s:%d/%s()!\n", 5652 __FILE__, __LINE__, __func__); 5653 goto out; 5654 } 5655 5656 event_reply->Function = MPI2_FUNCTION_EVENT_NOTIFICATION; 5657 event_reply->Event = 5658 cpu_to_le16(MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE); 5659 event_reply->MsgLength = sz/4; 5660 event_reply->EventDataLength = 5661 cpu_to_le16(sizeof(Mpi2EventDataSasDeviceStatusChange_t)/4); 5662 event_data = (Mpi2EventDataSasDeviceStatusChange_t *) 5663 event_reply->EventData; 5664 event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA; 5665 event_data->ASC = 0x5D; 5666 event_data->DevHandle = cpu_to_le16(handle); 5667 event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address); 5668 mpt3sas_ctl_add_to_event_log(ioc, event_reply); 5669 kfree(event_reply); 5670 out: 5671 if (sas_device) 5672 sas_device_put(sas_device); 5673 return; 5674 5675 out_unlock: 5676 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 5677 goto out; 5678 } 5679 5680 /** 5681 * _scsih_io_done - scsi request callback 5682 * @ioc: per adapter object 5683 * @smid: system request message index 5684 * @msix_index: MSIX table index supplied by the OS 5685 * @reply: reply message frame(lower 32bit addr) 5686 * 5687 * Callback handler when using _scsih_qcmd. 5688 * 5689 * Return: 1 meaning mf should be freed from _base_interrupt 5690 * 0 means the mf is freed from this function. 5691 */ 5692 static u8 5693 _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply) 5694 { 5695 Mpi25SCSIIORequest_t *mpi_request; 5696 Mpi2SCSIIOReply_t *mpi_reply; 5697 struct scsi_cmnd *scmd; 5698 struct scsiio_tracker *st; 5699 u16 ioc_status; 5700 u32 xfer_cnt; 5701 u8 scsi_state; 5702 u8 scsi_status; 5703 u32 log_info; 5704 struct MPT3SAS_DEVICE *sas_device_priv_data; 5705 u32 response_code = 0; 5706 5707 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 5708 5709 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid); 5710 if (scmd == NULL) 5711 return 1; 5712 5713 _scsih_set_satl_pending(scmd, false); 5714 5715 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 5716 5717 if (mpi_reply == NULL) { 5718 scmd->result = DID_OK << 16; 5719 goto out; 5720 } 5721 5722 sas_device_priv_data = scmd->device->hostdata; 5723 if (!sas_device_priv_data || !sas_device_priv_data->sas_target || 5724 sas_device_priv_data->sas_target->deleted) { 5725 scmd->result = DID_NO_CONNECT << 16; 5726 goto out; 5727 } 5728 ioc_status = le16_to_cpu(mpi_reply->IOCStatus); 5729 5730 /* 5731 * WARPDRIVE: If direct_io is set then it is directIO, 5732 * the failed direct I/O should be redirected to volume 5733 */ 5734 st = scsi_cmd_priv(scmd); 5735 if (st->direct_io && 5736 ((ioc_status & MPI2_IOCSTATUS_MASK) 5737 != MPI2_IOCSTATUS_SCSI_TASK_TERMINATED)) { 5738 st->direct_io = 0; 5739 st->scmd = scmd; 5740 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len); 5741 mpi_request->DevHandle = 5742 cpu_to_le16(sas_device_priv_data->sas_target->handle); 5743 ioc->put_smid_scsi_io(ioc, smid, 5744 sas_device_priv_data->sas_target->handle); 5745 return 0; 5746 } 5747 /* turning off TLR */ 5748 scsi_state = mpi_reply->SCSIState; 5749 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) 5750 response_code = 5751 le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF; 5752 if (!sas_device_priv_data->tlr_snoop_check) { 5753 sas_device_priv_data->tlr_snoop_check++; 5754 if ((!ioc->is_warpdrive && 5755 !scsih_is_raid(&scmd->device->sdev_gendev) && 5756 !scsih_is_nvme(&scmd->device->sdev_gendev)) 5757 && sas_is_tlr_enabled(scmd->device) && 5758 response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) { 5759 sas_disable_tlr(scmd->device); 5760 sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n"); 5761 } 5762 } 5763 5764 xfer_cnt = le32_to_cpu(mpi_reply->TransferCount); 5765 scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt); 5766 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) 5767 log_info = le32_to_cpu(mpi_reply->IOCLogInfo); 5768 else 5769 log_info = 0; 5770 ioc_status &= MPI2_IOCSTATUS_MASK; 5771 scsi_status = mpi_reply->SCSIStatus; 5772 5773 if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 && 5774 (scsi_status == MPI2_SCSI_STATUS_BUSY || 5775 scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT || 5776 scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) { 5777 ioc_status = MPI2_IOCSTATUS_SUCCESS; 5778 } 5779 5780 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) { 5781 struct sense_info data; 5782 const void *sense_data = mpt3sas_base_get_sense_buffer(ioc, 5783 smid); 5784 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE, 5785 le32_to_cpu(mpi_reply->SenseCount)); 5786 memcpy(scmd->sense_buffer, sense_data, sz); 5787 _scsih_normalize_sense(scmd->sense_buffer, &data); 5788 /* failure prediction threshold exceeded */ 5789 if (data.asc == 0x5D) 5790 _scsih_smart_predicted_fault(ioc, 5791 le16_to_cpu(mpi_reply->DevHandle)); 5792 mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq); 5793 5794 if ((ioc->logging_level & MPT_DEBUG_REPLY) && 5795 ((scmd->sense_buffer[2] == UNIT_ATTENTION) || 5796 (scmd->sense_buffer[2] == MEDIUM_ERROR) || 5797 (scmd->sense_buffer[2] == HARDWARE_ERROR))) 5798 _scsih_scsi_ioc_info(ioc, scmd, mpi_reply, smid); 5799 } 5800 switch (ioc_status) { 5801 case MPI2_IOCSTATUS_BUSY: 5802 case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES: 5803 scmd->result = SAM_STAT_BUSY; 5804 break; 5805 5806 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE: 5807 scmd->result = DID_NO_CONNECT << 16; 5808 break; 5809 5810 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED: 5811 if (sas_device_priv_data->block) { 5812 scmd->result = DID_TRANSPORT_DISRUPTED << 16; 5813 goto out; 5814 } 5815 if (log_info == 0x31110630) { 5816 if (scmd->retries > 2) { 5817 scmd->result = DID_NO_CONNECT << 16; 5818 scsi_device_set_state(scmd->device, 5819 SDEV_OFFLINE); 5820 } else { 5821 scmd->result = DID_SOFT_ERROR << 16; 5822 scmd->device->expecting_cc_ua = 1; 5823 } 5824 break; 5825 } else if (log_info == VIRTUAL_IO_FAILED_RETRY) { 5826 scmd->result = DID_RESET << 16; 5827 break; 5828 } else if ((scmd->device->channel == RAID_CHANNEL) && 5829 (scsi_state == (MPI2_SCSI_STATE_TERMINATED | 5830 MPI2_SCSI_STATE_NO_SCSI_STATUS))) { 5831 scmd->result = DID_RESET << 16; 5832 break; 5833 } 5834 scmd->result = DID_SOFT_ERROR << 16; 5835 break; 5836 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED: 5837 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED: 5838 scmd->result = DID_RESET << 16; 5839 break; 5840 5841 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: 5842 if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt)) 5843 scmd->result = DID_SOFT_ERROR << 16; 5844 else 5845 scmd->result = (DID_OK << 16) | scsi_status; 5846 break; 5847 5848 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN: 5849 scmd->result = (DID_OK << 16) | scsi_status; 5850 5851 if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)) 5852 break; 5853 5854 if (xfer_cnt < scmd->underflow) { 5855 if (scsi_status == SAM_STAT_BUSY) 5856 scmd->result = SAM_STAT_BUSY; 5857 else 5858 scmd->result = DID_SOFT_ERROR << 16; 5859 } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED | 5860 MPI2_SCSI_STATE_NO_SCSI_STATUS)) 5861 scmd->result = DID_SOFT_ERROR << 16; 5862 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED) 5863 scmd->result = DID_RESET << 16; 5864 else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) { 5865 mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID; 5866 mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION; 5867 scsi_build_sense(scmd, 0, ILLEGAL_REQUEST, 5868 0x20, 0); 5869 } 5870 break; 5871 5872 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN: 5873 scsi_set_resid(scmd, 0); 5874 fallthrough; 5875 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR: 5876 case MPI2_IOCSTATUS_SUCCESS: 5877 scmd->result = (DID_OK << 16) | scsi_status; 5878 if (response_code == 5879 MPI2_SCSITASKMGMT_RSP_INVALID_FRAME || 5880 (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED | 5881 MPI2_SCSI_STATE_NO_SCSI_STATUS))) 5882 scmd->result = DID_SOFT_ERROR << 16; 5883 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED) 5884 scmd->result = DID_RESET << 16; 5885 break; 5886 5887 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR: 5888 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR: 5889 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR: 5890 _scsih_eedp_error_handling(scmd, ioc_status); 5891 break; 5892 5893 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR: 5894 case MPI2_IOCSTATUS_INVALID_FUNCTION: 5895 case MPI2_IOCSTATUS_INVALID_SGL: 5896 case MPI2_IOCSTATUS_INTERNAL_ERROR: 5897 case MPI2_IOCSTATUS_INVALID_FIELD: 5898 case MPI2_IOCSTATUS_INVALID_STATE: 5899 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR: 5900 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED: 5901 case MPI2_IOCSTATUS_INSUFFICIENT_POWER: 5902 default: 5903 scmd->result = DID_SOFT_ERROR << 16; 5904 break; 5905 5906 } 5907 5908 if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY)) 5909 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid); 5910 5911 out: 5912 5913 scsi_dma_unmap(scmd); 5914 mpt3sas_base_free_smid(ioc, smid); 5915 scsi_done(scmd); 5916 return 0; 5917 } 5918 5919 /** 5920 * _scsih_update_vphys_after_reset - update the Port's 5921 * vphys_list after reset 5922 * @ioc: per adapter object 5923 * 5924 * Returns nothing. 5925 */ 5926 static void 5927 _scsih_update_vphys_after_reset(struct MPT3SAS_ADAPTER *ioc) 5928 { 5929 u16 sz, ioc_status; 5930 int i; 5931 Mpi2ConfigReply_t mpi_reply; 5932 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 5933 u16 attached_handle; 5934 u64 attached_sas_addr; 5935 u8 found = 0, port_id; 5936 Mpi2SasPhyPage0_t phy_pg0; 5937 struct hba_port *port, *port_next, *mport; 5938 struct virtual_phy *vphy, *vphy_next; 5939 struct _sas_device *sas_device; 5940 5941 /* 5942 * Mark all the vphys objects as dirty. 5943 */ 5944 list_for_each_entry_safe(port, port_next, 5945 &ioc->port_table_list, list) { 5946 if (!port->vphys_mask) 5947 continue; 5948 list_for_each_entry_safe(vphy, vphy_next, 5949 &port->vphys_list, list) { 5950 vphy->flags |= MPT_VPHY_FLAG_DIRTY_PHY; 5951 } 5952 } 5953 5954 /* 5955 * Read SASIOUnitPage0 to get each HBA Phy's data. 5956 */ 5957 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + 5958 (ioc->sas_hba.num_phys * sizeof(Mpi2SasIOUnit0PhyData_t)); 5959 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 5960 if (!sas_iounit_pg0) { 5961 ioc_err(ioc, "failure at %s:%d/%s()!\n", 5962 __FILE__, __LINE__, __func__); 5963 return; 5964 } 5965 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 5966 sas_iounit_pg0, sz)) != 0) 5967 goto out; 5968 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 5969 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 5970 goto out; 5971 /* 5972 * Loop over each HBA Phy. 5973 */ 5974 for (i = 0; i < ioc->sas_hba.num_phys; i++) { 5975 /* 5976 * Check whether Phy's Negotiation Link Rate is > 1.5G or not. 5977 */ 5978 if ((sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4) < 5979 MPI2_SAS_NEG_LINK_RATE_1_5) 5980 continue; 5981 /* 5982 * Check whether Phy is connected to SEP device or not, 5983 * if it is SEP device then read the Phy's SASPHYPage0 data to 5984 * determine whether Phy is a virtual Phy or not. if it is 5985 * virtual phy then it is conformed that the attached remote 5986 * device is a HBA's vSES device. 5987 */ 5988 if (!(le32_to_cpu( 5989 sas_iounit_pg0->PhyData[i].ControllerPhyDeviceInfo) & 5990 MPI2_SAS_DEVICE_INFO_SEP)) 5991 continue; 5992 5993 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0, 5994 i))) { 5995 ioc_err(ioc, "failure at %s:%d/%s()!\n", 5996 __FILE__, __LINE__, __func__); 5997 continue; 5998 } 5999 6000 if (!(le32_to_cpu(phy_pg0.PhyInfo) & 6001 MPI2_SAS_PHYINFO_VIRTUAL_PHY)) 6002 continue; 6003 /* 6004 * Get the vSES device's SAS Address. 6005 */ 6006 attached_handle = le16_to_cpu( 6007 sas_iounit_pg0->PhyData[i].AttachedDevHandle); 6008 if (_scsih_get_sas_address(ioc, attached_handle, 6009 &attached_sas_addr) != 0) { 6010 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6011 __FILE__, __LINE__, __func__); 6012 continue; 6013 } 6014 6015 found = 0; 6016 port = port_next = NULL; 6017 /* 6018 * Loop over each virtual_phy object from 6019 * each port's vphys_list. 6020 */ 6021 list_for_each_entry_safe(port, 6022 port_next, &ioc->port_table_list, list) { 6023 if (!port->vphys_mask) 6024 continue; 6025 list_for_each_entry_safe(vphy, vphy_next, 6026 &port->vphys_list, list) { 6027 /* 6028 * Continue with next virtual_phy object 6029 * if the object is not marked as dirty. 6030 */ 6031 if (!(vphy->flags & MPT_VPHY_FLAG_DIRTY_PHY)) 6032 continue; 6033 6034 /* 6035 * Continue with next virtual_phy object 6036 * if the object's SAS Address is not equals 6037 * to current Phy's vSES device SAS Address. 6038 */ 6039 if (vphy->sas_address != attached_sas_addr) 6040 continue; 6041 /* 6042 * Enable current Phy number bit in object's 6043 * phy_mask field. 6044 */ 6045 if (!(vphy->phy_mask & (1 << i))) 6046 vphy->phy_mask = (1 << i); 6047 /* 6048 * Get hba_port object from hba_port table 6049 * corresponding to current phy's Port ID. 6050 * if there is no hba_port object corresponding 6051 * to Phy's Port ID then create a new hba_port 6052 * object & add to hba_port table. 6053 */ 6054 port_id = sas_iounit_pg0->PhyData[i].Port; 6055 mport = mpt3sas_get_port_by_id(ioc, port_id, 1); 6056 if (!mport) { 6057 mport = kzalloc( 6058 sizeof(struct hba_port), GFP_KERNEL); 6059 if (!mport) 6060 break; 6061 mport->port_id = port_id; 6062 ioc_info(ioc, 6063 "%s: hba_port entry: %p, port: %d is added to hba_port list\n", 6064 __func__, mport, mport->port_id); 6065 list_add_tail(&mport->list, 6066 &ioc->port_table_list); 6067 } 6068 /* 6069 * If mport & port pointers are not pointing to 6070 * same hba_port object then it means that vSES 6071 * device's Port ID got changed after reset and 6072 * hence move current virtual_phy object from 6073 * port's vphys_list to mport's vphys_list. 6074 */ 6075 if (port != mport) { 6076 if (!mport->vphys_mask) 6077 INIT_LIST_HEAD( 6078 &mport->vphys_list); 6079 mport->vphys_mask |= (1 << i); 6080 port->vphys_mask &= ~(1 << i); 6081 list_move(&vphy->list, 6082 &mport->vphys_list); 6083 sas_device = mpt3sas_get_sdev_by_addr( 6084 ioc, attached_sas_addr, port); 6085 if (sas_device) 6086 sas_device->port = mport; 6087 } 6088 /* 6089 * Earlier while updating the hba_port table, 6090 * it is determined that there is no other 6091 * direct attached device with mport's Port ID, 6092 * Hence mport was marked as dirty. Only vSES 6093 * device has this Port ID, so unmark the mport 6094 * as dirt. 6095 */ 6096 if (mport->flags & HBA_PORT_FLAG_DIRTY_PORT) { 6097 mport->sas_address = 0; 6098 mport->phy_mask = 0; 6099 mport->flags &= 6100 ~HBA_PORT_FLAG_DIRTY_PORT; 6101 } 6102 /* 6103 * Unmark current virtual_phy object as dirty. 6104 */ 6105 vphy->flags &= ~MPT_VPHY_FLAG_DIRTY_PHY; 6106 found = 1; 6107 break; 6108 } 6109 if (found) 6110 break; 6111 } 6112 } 6113 out: 6114 kfree(sas_iounit_pg0); 6115 } 6116 6117 /** 6118 * _scsih_get_port_table_after_reset - Construct temporary port table 6119 * @ioc: per adapter object 6120 * @port_table: address where port table needs to be constructed 6121 * 6122 * return number of HBA port entries available after reset. 6123 */ 6124 static int 6125 _scsih_get_port_table_after_reset(struct MPT3SAS_ADAPTER *ioc, 6126 struct hba_port *port_table) 6127 { 6128 u16 sz, ioc_status; 6129 int i, j; 6130 Mpi2ConfigReply_t mpi_reply; 6131 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 6132 u16 attached_handle; 6133 u64 attached_sas_addr; 6134 u8 found = 0, port_count = 0, port_id; 6135 6136 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys 6137 * sizeof(Mpi2SasIOUnit0PhyData_t)); 6138 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 6139 if (!sas_iounit_pg0) { 6140 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6141 __FILE__, __LINE__, __func__); 6142 return port_count; 6143 } 6144 6145 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 6146 sas_iounit_pg0, sz)) != 0) 6147 goto out; 6148 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 6149 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 6150 goto out; 6151 for (i = 0; i < ioc->sas_hba.num_phys; i++) { 6152 found = 0; 6153 if ((sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4) < 6154 MPI2_SAS_NEG_LINK_RATE_1_5) 6155 continue; 6156 attached_handle = 6157 le16_to_cpu(sas_iounit_pg0->PhyData[i].AttachedDevHandle); 6158 if (_scsih_get_sas_address( 6159 ioc, attached_handle, &attached_sas_addr) != 0) { 6160 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6161 __FILE__, __LINE__, __func__); 6162 continue; 6163 } 6164 6165 for (j = 0; j < port_count; j++) { 6166 port_id = sas_iounit_pg0->PhyData[i].Port; 6167 if (port_table[j].port_id == port_id && 6168 port_table[j].sas_address == attached_sas_addr) { 6169 port_table[j].phy_mask |= (1 << i); 6170 found = 1; 6171 break; 6172 } 6173 } 6174 6175 if (found) 6176 continue; 6177 6178 port_id = sas_iounit_pg0->PhyData[i].Port; 6179 port_table[port_count].port_id = port_id; 6180 port_table[port_count].phy_mask = (1 << i); 6181 port_table[port_count].sas_address = attached_sas_addr; 6182 port_count++; 6183 } 6184 out: 6185 kfree(sas_iounit_pg0); 6186 return port_count; 6187 } 6188 6189 enum hba_port_matched_codes { 6190 NOT_MATCHED = 0, 6191 MATCHED_WITH_ADDR_AND_PHYMASK, 6192 MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT, 6193 MATCHED_WITH_ADDR_AND_SUBPHYMASK, 6194 MATCHED_WITH_ADDR, 6195 }; 6196 6197 /** 6198 * _scsih_look_and_get_matched_port_entry - Get matched hba port entry 6199 * from HBA port table 6200 * @ioc: per adapter object 6201 * @port_entry: hba port entry from temporary port table which needs to be 6202 * searched for matched entry in the HBA port table 6203 * @matched_port_entry: save matched hba port entry here 6204 * @count: count of matched entries 6205 * 6206 * return type of matched entry found. 6207 */ 6208 static enum hba_port_matched_codes 6209 _scsih_look_and_get_matched_port_entry(struct MPT3SAS_ADAPTER *ioc, 6210 struct hba_port *port_entry, 6211 struct hba_port **matched_port_entry, int *count) 6212 { 6213 struct hba_port *port_table_entry, *matched_port = NULL; 6214 enum hba_port_matched_codes matched_code = NOT_MATCHED; 6215 int lcount = 0; 6216 *matched_port_entry = NULL; 6217 6218 list_for_each_entry(port_table_entry, &ioc->port_table_list, list) { 6219 if (!(port_table_entry->flags & HBA_PORT_FLAG_DIRTY_PORT)) 6220 continue; 6221 6222 if ((port_table_entry->sas_address == port_entry->sas_address) 6223 && (port_table_entry->phy_mask == port_entry->phy_mask)) { 6224 matched_code = MATCHED_WITH_ADDR_AND_PHYMASK; 6225 matched_port = port_table_entry; 6226 break; 6227 } 6228 6229 if ((port_table_entry->sas_address == port_entry->sas_address) 6230 && (port_table_entry->phy_mask & port_entry->phy_mask) 6231 && (port_table_entry->port_id == port_entry->port_id)) { 6232 matched_code = MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT; 6233 matched_port = port_table_entry; 6234 continue; 6235 } 6236 6237 if ((port_table_entry->sas_address == port_entry->sas_address) 6238 && (port_table_entry->phy_mask & port_entry->phy_mask)) { 6239 if (matched_code == 6240 MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT) 6241 continue; 6242 matched_code = MATCHED_WITH_ADDR_AND_SUBPHYMASK; 6243 matched_port = port_table_entry; 6244 continue; 6245 } 6246 6247 if (port_table_entry->sas_address == port_entry->sas_address) { 6248 if (matched_code == 6249 MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT) 6250 continue; 6251 if (matched_code == MATCHED_WITH_ADDR_AND_SUBPHYMASK) 6252 continue; 6253 matched_code = MATCHED_WITH_ADDR; 6254 matched_port = port_table_entry; 6255 lcount++; 6256 } 6257 } 6258 6259 *matched_port_entry = matched_port; 6260 if (matched_code == MATCHED_WITH_ADDR) 6261 *count = lcount; 6262 return matched_code; 6263 } 6264 6265 /** 6266 * _scsih_del_phy_part_of_anther_port - remove phy if it 6267 * is a part of anther port 6268 *@ioc: per adapter object 6269 *@port_table: port table after reset 6270 *@index: hba port entry index 6271 *@port_count: number of ports available after host reset 6272 *@offset: HBA phy bit offset 6273 * 6274 */ 6275 static void 6276 _scsih_del_phy_part_of_anther_port(struct MPT3SAS_ADAPTER *ioc, 6277 struct hba_port *port_table, 6278 int index, u8 port_count, int offset) 6279 { 6280 struct _sas_node *sas_node = &ioc->sas_hba; 6281 u32 i, found = 0; 6282 6283 for (i = 0; i < port_count; i++) { 6284 if (i == index) 6285 continue; 6286 6287 if (port_table[i].phy_mask & (1 << offset)) { 6288 mpt3sas_transport_del_phy_from_an_existing_port( 6289 ioc, sas_node, &sas_node->phy[offset]); 6290 found = 1; 6291 break; 6292 } 6293 } 6294 if (!found) 6295 port_table[index].phy_mask |= (1 << offset); 6296 } 6297 6298 /** 6299 * _scsih_add_or_del_phys_from_existing_port - add/remove phy to/from 6300 * right port 6301 *@ioc: per adapter object 6302 *@hba_port_entry: hba port table entry 6303 *@port_table: temporary port table 6304 *@index: hba port entry index 6305 *@port_count: number of ports available after host reset 6306 * 6307 */ 6308 static void 6309 _scsih_add_or_del_phys_from_existing_port(struct MPT3SAS_ADAPTER *ioc, 6310 struct hba_port *hba_port_entry, struct hba_port *port_table, 6311 int index, int port_count) 6312 { 6313 u32 phy_mask, offset = 0; 6314 struct _sas_node *sas_node = &ioc->sas_hba; 6315 6316 phy_mask = hba_port_entry->phy_mask ^ port_table[index].phy_mask; 6317 6318 for (offset = 0; offset < ioc->sas_hba.num_phys; offset++) { 6319 if (phy_mask & (1 << offset)) { 6320 if (!(port_table[index].phy_mask & (1 << offset))) { 6321 _scsih_del_phy_part_of_anther_port( 6322 ioc, port_table, index, port_count, 6323 offset); 6324 continue; 6325 } 6326 if (sas_node->phy[offset].phy_belongs_to_port) 6327 mpt3sas_transport_del_phy_from_an_existing_port( 6328 ioc, sas_node, &sas_node->phy[offset]); 6329 mpt3sas_transport_add_phy_to_an_existing_port( 6330 ioc, sas_node, &sas_node->phy[offset], 6331 hba_port_entry->sas_address, 6332 hba_port_entry); 6333 } 6334 } 6335 } 6336 6337 /** 6338 * _scsih_del_dirty_vphy - delete virtual_phy objects marked as dirty. 6339 * @ioc: per adapter object 6340 * 6341 * Returns nothing. 6342 */ 6343 static void 6344 _scsih_del_dirty_vphy(struct MPT3SAS_ADAPTER *ioc) 6345 { 6346 struct hba_port *port, *port_next; 6347 struct virtual_phy *vphy, *vphy_next; 6348 6349 list_for_each_entry_safe(port, port_next, 6350 &ioc->port_table_list, list) { 6351 if (!port->vphys_mask) 6352 continue; 6353 list_for_each_entry_safe(vphy, vphy_next, 6354 &port->vphys_list, list) { 6355 if (vphy->flags & MPT_VPHY_FLAG_DIRTY_PHY) { 6356 drsprintk(ioc, ioc_info(ioc, 6357 "Deleting vphy %p entry from port id: %d\t, Phy_mask 0x%08x\n", 6358 vphy, port->port_id, 6359 vphy->phy_mask)); 6360 port->vphys_mask &= ~vphy->phy_mask; 6361 list_del(&vphy->list); 6362 kfree(vphy); 6363 } 6364 } 6365 if (!port->vphys_mask && !port->sas_address) 6366 port->flags |= HBA_PORT_FLAG_DIRTY_PORT; 6367 } 6368 } 6369 6370 /** 6371 * _scsih_del_dirty_port_entries - delete dirty port entries from port list 6372 * after host reset 6373 *@ioc: per adapter object 6374 * 6375 */ 6376 static void 6377 _scsih_del_dirty_port_entries(struct MPT3SAS_ADAPTER *ioc) 6378 { 6379 struct hba_port *port, *port_next; 6380 6381 list_for_each_entry_safe(port, port_next, 6382 &ioc->port_table_list, list) { 6383 if (!(port->flags & HBA_PORT_FLAG_DIRTY_PORT) || 6384 port->flags & HBA_PORT_FLAG_NEW_PORT) 6385 continue; 6386 6387 drsprintk(ioc, ioc_info(ioc, 6388 "Deleting port table entry %p having Port: %d\t Phy_mask 0x%08x\n", 6389 port, port->port_id, port->phy_mask)); 6390 list_del(&port->list); 6391 kfree(port); 6392 } 6393 } 6394 6395 /** 6396 * _scsih_sas_port_refresh - Update HBA port table after host reset 6397 * @ioc: per adapter object 6398 */ 6399 static void 6400 _scsih_sas_port_refresh(struct MPT3SAS_ADAPTER *ioc) 6401 { 6402 u32 port_count = 0; 6403 struct hba_port *port_table; 6404 struct hba_port *port_table_entry; 6405 struct hba_port *port_entry = NULL; 6406 int i, j, count = 0, lcount = 0; 6407 int ret; 6408 u64 sas_addr; 6409 6410 drsprintk(ioc, ioc_info(ioc, 6411 "updating ports for sas_host(0x%016llx)\n", 6412 (unsigned long long)ioc->sas_hba.sas_address)); 6413 6414 port_table = kcalloc(ioc->sas_hba.num_phys, 6415 sizeof(struct hba_port), GFP_KERNEL); 6416 if (!port_table) 6417 return; 6418 6419 port_count = _scsih_get_port_table_after_reset(ioc, port_table); 6420 if (!port_count) 6421 return; 6422 6423 drsprintk(ioc, ioc_info(ioc, "New Port table\n")); 6424 for (j = 0; j < port_count; j++) 6425 drsprintk(ioc, ioc_info(ioc, 6426 "Port: %d\t Phy_mask 0x%08x\t sas_addr(0x%016llx)\n", 6427 port_table[j].port_id, 6428 port_table[j].phy_mask, port_table[j].sas_address)); 6429 6430 list_for_each_entry(port_table_entry, &ioc->port_table_list, list) 6431 port_table_entry->flags |= HBA_PORT_FLAG_DIRTY_PORT; 6432 6433 drsprintk(ioc, ioc_info(ioc, "Old Port table\n")); 6434 port_table_entry = NULL; 6435 list_for_each_entry(port_table_entry, &ioc->port_table_list, list) { 6436 drsprintk(ioc, ioc_info(ioc, 6437 "Port: %d\t Phy_mask 0x%08x\t sas_addr(0x%016llx)\n", 6438 port_table_entry->port_id, 6439 port_table_entry->phy_mask, 6440 port_table_entry->sas_address)); 6441 } 6442 6443 for (j = 0; j < port_count; j++) { 6444 ret = _scsih_look_and_get_matched_port_entry(ioc, 6445 &port_table[j], &port_entry, &count); 6446 if (!port_entry) { 6447 drsprintk(ioc, ioc_info(ioc, 6448 "No Matched entry for sas_addr(0x%16llx), Port:%d\n", 6449 port_table[j].sas_address, 6450 port_table[j].port_id)); 6451 continue; 6452 } 6453 6454 switch (ret) { 6455 case MATCHED_WITH_ADDR_SUBPHYMASK_AND_PORT: 6456 case MATCHED_WITH_ADDR_AND_SUBPHYMASK: 6457 _scsih_add_or_del_phys_from_existing_port(ioc, 6458 port_entry, port_table, j, port_count); 6459 break; 6460 case MATCHED_WITH_ADDR: 6461 sas_addr = port_table[j].sas_address; 6462 for (i = 0; i < port_count; i++) { 6463 if (port_table[i].sas_address == sas_addr) 6464 lcount++; 6465 } 6466 6467 if (count > 1 || lcount > 1) 6468 port_entry = NULL; 6469 else 6470 _scsih_add_or_del_phys_from_existing_port(ioc, 6471 port_entry, port_table, j, port_count); 6472 } 6473 6474 if (!port_entry) 6475 continue; 6476 6477 if (port_entry->port_id != port_table[j].port_id) 6478 port_entry->port_id = port_table[j].port_id; 6479 port_entry->flags &= ~HBA_PORT_FLAG_DIRTY_PORT; 6480 port_entry->phy_mask = port_table[j].phy_mask; 6481 } 6482 6483 port_table_entry = NULL; 6484 } 6485 6486 /** 6487 * _scsih_alloc_vphy - allocate virtual_phy object 6488 * @ioc: per adapter object 6489 * @port_id: Port ID number 6490 * @phy_num: HBA Phy number 6491 * 6492 * Returns allocated virtual_phy object. 6493 */ 6494 static struct virtual_phy * 6495 _scsih_alloc_vphy(struct MPT3SAS_ADAPTER *ioc, u8 port_id, u8 phy_num) 6496 { 6497 struct virtual_phy *vphy; 6498 struct hba_port *port; 6499 6500 port = mpt3sas_get_port_by_id(ioc, port_id, 0); 6501 if (!port) 6502 return NULL; 6503 6504 vphy = mpt3sas_get_vphy_by_phy(ioc, port, phy_num); 6505 if (!vphy) { 6506 vphy = kzalloc(sizeof(struct virtual_phy), GFP_KERNEL); 6507 if (!vphy) 6508 return NULL; 6509 6510 if (!port->vphys_mask) 6511 INIT_LIST_HEAD(&port->vphys_list); 6512 6513 /* 6514 * Enable bit corresponding to HBA phy number on its 6515 * parent hba_port object's vphys_mask field. 6516 */ 6517 port->vphys_mask |= (1 << phy_num); 6518 vphy->phy_mask |= (1 << phy_num); 6519 6520 list_add_tail(&vphy->list, &port->vphys_list); 6521 6522 ioc_info(ioc, 6523 "vphy entry: %p, port id: %d, phy:%d is added to port's vphys_list\n", 6524 vphy, port->port_id, phy_num); 6525 } 6526 return vphy; 6527 } 6528 6529 /** 6530 * _scsih_sas_host_refresh - refreshing sas host object contents 6531 * @ioc: per adapter object 6532 * Context: user 6533 * 6534 * During port enable, fw will send topology events for every device. Its 6535 * possible that the handles may change from the previous setting, so this 6536 * code keeping handles updating if changed. 6537 */ 6538 static void 6539 _scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc) 6540 { 6541 u16 sz; 6542 u16 ioc_status; 6543 int i; 6544 Mpi2ConfigReply_t mpi_reply; 6545 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 6546 u16 attached_handle; 6547 u8 link_rate, port_id; 6548 struct hba_port *port; 6549 Mpi2SasPhyPage0_t phy_pg0; 6550 6551 dtmprintk(ioc, 6552 ioc_info(ioc, "updating handles for sas_host(0x%016llx)\n", 6553 (u64)ioc->sas_hba.sas_address)); 6554 6555 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys 6556 * sizeof(Mpi2SasIOUnit0PhyData_t)); 6557 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 6558 if (!sas_iounit_pg0) { 6559 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6560 __FILE__, __LINE__, __func__); 6561 return; 6562 } 6563 6564 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 6565 sas_iounit_pg0, sz)) != 0) 6566 goto out; 6567 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 6568 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 6569 goto out; 6570 for (i = 0; i < ioc->sas_hba.num_phys ; i++) { 6571 link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4; 6572 if (i == 0) 6573 ioc->sas_hba.handle = le16_to_cpu( 6574 sas_iounit_pg0->PhyData[0].ControllerDevHandle); 6575 port_id = sas_iounit_pg0->PhyData[i].Port; 6576 if (!(mpt3sas_get_port_by_id(ioc, port_id, 0))) { 6577 port = kzalloc(sizeof(struct hba_port), GFP_KERNEL); 6578 if (!port) 6579 goto out; 6580 6581 port->port_id = port_id; 6582 ioc_info(ioc, 6583 "hba_port entry: %p, port: %d is added to hba_port list\n", 6584 port, port->port_id); 6585 if (ioc->shost_recovery) 6586 port->flags = HBA_PORT_FLAG_NEW_PORT; 6587 list_add_tail(&port->list, &ioc->port_table_list); 6588 } 6589 /* 6590 * Check whether current Phy belongs to HBA vSES device or not. 6591 */ 6592 if (le32_to_cpu(sas_iounit_pg0->PhyData[i].ControllerPhyDeviceInfo) & 6593 MPI2_SAS_DEVICE_INFO_SEP && 6594 (link_rate >= MPI2_SAS_NEG_LINK_RATE_1_5)) { 6595 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, 6596 &phy_pg0, i))) { 6597 ioc_err(ioc, 6598 "failure at %s:%d/%s()!\n", 6599 __FILE__, __LINE__, __func__); 6600 goto out; 6601 } 6602 if (!(le32_to_cpu(phy_pg0.PhyInfo) & 6603 MPI2_SAS_PHYINFO_VIRTUAL_PHY)) 6604 continue; 6605 /* 6606 * Allocate a virtual_phy object for vSES device, if 6607 * this vSES device is hot added. 6608 */ 6609 if (!_scsih_alloc_vphy(ioc, port_id, i)) 6610 goto out; 6611 ioc->sas_hba.phy[i].hba_vphy = 1; 6612 } 6613 6614 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle; 6615 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i]. 6616 AttachedDevHandle); 6617 if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5) 6618 link_rate = MPI2_SAS_NEG_LINK_RATE_1_5; 6619 ioc->sas_hba.phy[i].port = 6620 mpt3sas_get_port_by_id(ioc, port_id, 0); 6621 mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address, 6622 attached_handle, i, link_rate, 6623 ioc->sas_hba.phy[i].port); 6624 } 6625 out: 6626 kfree(sas_iounit_pg0); 6627 } 6628 6629 /** 6630 * _scsih_sas_host_add - create sas host object 6631 * @ioc: per adapter object 6632 * 6633 * Creating host side data object, stored in ioc->sas_hba 6634 */ 6635 static void 6636 _scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc) 6637 { 6638 int i; 6639 Mpi2ConfigReply_t mpi_reply; 6640 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 6641 Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL; 6642 Mpi2SasPhyPage0_t phy_pg0; 6643 Mpi2SasDevicePage0_t sas_device_pg0; 6644 Mpi2SasEnclosurePage0_t enclosure_pg0; 6645 u16 ioc_status; 6646 u16 sz; 6647 u8 device_missing_delay; 6648 u8 num_phys, port_id; 6649 struct hba_port *port; 6650 6651 mpt3sas_config_get_number_hba_phys(ioc, &num_phys); 6652 if (!num_phys) { 6653 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6654 __FILE__, __LINE__, __func__); 6655 return; 6656 } 6657 ioc->sas_hba.phy = kcalloc(num_phys, 6658 sizeof(struct _sas_phy), GFP_KERNEL); 6659 if (!ioc->sas_hba.phy) { 6660 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6661 __FILE__, __LINE__, __func__); 6662 goto out; 6663 } 6664 ioc->sas_hba.num_phys = num_phys; 6665 6666 /* sas_iounit page 0 */ 6667 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys * 6668 sizeof(Mpi2SasIOUnit0PhyData_t)); 6669 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 6670 if (!sas_iounit_pg0) { 6671 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6672 __FILE__, __LINE__, __func__); 6673 return; 6674 } 6675 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 6676 sas_iounit_pg0, sz))) { 6677 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6678 __FILE__, __LINE__, __func__); 6679 goto out; 6680 } 6681 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 6682 MPI2_IOCSTATUS_MASK; 6683 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6684 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6685 __FILE__, __LINE__, __func__); 6686 goto out; 6687 } 6688 6689 /* sas_iounit page 1 */ 6690 sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys * 6691 sizeof(Mpi2SasIOUnit1PhyData_t)); 6692 sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL); 6693 if (!sas_iounit_pg1) { 6694 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6695 __FILE__, __LINE__, __func__); 6696 goto out; 6697 } 6698 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply, 6699 sas_iounit_pg1, sz))) { 6700 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6701 __FILE__, __LINE__, __func__); 6702 goto out; 6703 } 6704 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 6705 MPI2_IOCSTATUS_MASK; 6706 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6707 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6708 __FILE__, __LINE__, __func__); 6709 goto out; 6710 } 6711 6712 ioc->io_missing_delay = 6713 sas_iounit_pg1->IODeviceMissingDelay; 6714 device_missing_delay = 6715 sas_iounit_pg1->ReportDeviceMissingDelay; 6716 if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16) 6717 ioc->device_missing_delay = (device_missing_delay & 6718 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16; 6719 else 6720 ioc->device_missing_delay = device_missing_delay & 6721 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK; 6722 6723 ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev; 6724 for (i = 0; i < ioc->sas_hba.num_phys ; i++) { 6725 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0, 6726 i))) { 6727 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6728 __FILE__, __LINE__, __func__); 6729 goto out; 6730 } 6731 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 6732 MPI2_IOCSTATUS_MASK; 6733 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6734 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6735 __FILE__, __LINE__, __func__); 6736 goto out; 6737 } 6738 6739 if (i == 0) 6740 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0-> 6741 PhyData[0].ControllerDevHandle); 6742 6743 port_id = sas_iounit_pg0->PhyData[i].Port; 6744 if (!(mpt3sas_get_port_by_id(ioc, port_id, 0))) { 6745 port = kzalloc(sizeof(struct hba_port), GFP_KERNEL); 6746 if (!port) 6747 goto out; 6748 6749 port->port_id = port_id; 6750 ioc_info(ioc, 6751 "hba_port entry: %p, port: %d is added to hba_port list\n", 6752 port, port->port_id); 6753 list_add_tail(&port->list, 6754 &ioc->port_table_list); 6755 } 6756 6757 /* 6758 * Check whether current Phy belongs to HBA vSES device or not. 6759 */ 6760 if ((le32_to_cpu(phy_pg0.PhyInfo) & 6761 MPI2_SAS_PHYINFO_VIRTUAL_PHY) && 6762 (phy_pg0.NegotiatedLinkRate >> 4) >= 6763 MPI2_SAS_NEG_LINK_RATE_1_5) { 6764 /* 6765 * Allocate a virtual_phy object for vSES device. 6766 */ 6767 if (!_scsih_alloc_vphy(ioc, port_id, i)) 6768 goto out; 6769 ioc->sas_hba.phy[i].hba_vphy = 1; 6770 } 6771 6772 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle; 6773 ioc->sas_hba.phy[i].phy_id = i; 6774 ioc->sas_hba.phy[i].port = 6775 mpt3sas_get_port_by_id(ioc, port_id, 0); 6776 mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i], 6777 phy_pg0, ioc->sas_hba.parent_dev); 6778 } 6779 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 6780 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) { 6781 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6782 __FILE__, __LINE__, __func__); 6783 goto out; 6784 } 6785 ioc->sas_hba.enclosure_handle = 6786 le16_to_cpu(sas_device_pg0.EnclosureHandle); 6787 ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 6788 ioc_info(ioc, "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n", 6789 ioc->sas_hba.handle, 6790 (u64)ioc->sas_hba.sas_address, 6791 ioc->sas_hba.num_phys); 6792 6793 if (ioc->sas_hba.enclosure_handle) { 6794 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply, 6795 &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE, 6796 ioc->sas_hba.enclosure_handle))) 6797 ioc->sas_hba.enclosure_logical_id = 6798 le64_to_cpu(enclosure_pg0.EnclosureLogicalID); 6799 } 6800 6801 out: 6802 kfree(sas_iounit_pg1); 6803 kfree(sas_iounit_pg0); 6804 } 6805 6806 /** 6807 * _scsih_expander_add - creating expander object 6808 * @ioc: per adapter object 6809 * @handle: expander handle 6810 * 6811 * Creating expander object, stored in ioc->sas_expander_list. 6812 * 6813 * Return: 0 for success, else error. 6814 */ 6815 static int 6816 _scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle) 6817 { 6818 struct _sas_node *sas_expander; 6819 struct _enclosure_node *enclosure_dev; 6820 Mpi2ConfigReply_t mpi_reply; 6821 Mpi2ExpanderPage0_t expander_pg0; 6822 Mpi2ExpanderPage1_t expander_pg1; 6823 u32 ioc_status; 6824 u16 parent_handle; 6825 u64 sas_address, sas_address_parent = 0; 6826 int i; 6827 unsigned long flags; 6828 struct _sas_port *mpt3sas_port = NULL; 6829 u8 port_id; 6830 6831 int rc = 0; 6832 6833 if (!handle) 6834 return -1; 6835 6836 if (ioc->shost_recovery || ioc->pci_error_recovery) 6837 return -1; 6838 6839 if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0, 6840 MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) { 6841 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6842 __FILE__, __LINE__, __func__); 6843 return -1; 6844 } 6845 6846 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 6847 MPI2_IOCSTATUS_MASK; 6848 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6849 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6850 __FILE__, __LINE__, __func__); 6851 return -1; 6852 } 6853 6854 /* handle out of order topology events */ 6855 parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle); 6856 if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent) 6857 != 0) { 6858 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6859 __FILE__, __LINE__, __func__); 6860 return -1; 6861 } 6862 6863 port_id = expander_pg0.PhysicalPort; 6864 if (sas_address_parent != ioc->sas_hba.sas_address) { 6865 spin_lock_irqsave(&ioc->sas_node_lock, flags); 6866 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 6867 sas_address_parent, 6868 mpt3sas_get_port_by_id(ioc, port_id, 0)); 6869 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 6870 if (!sas_expander) { 6871 rc = _scsih_expander_add(ioc, parent_handle); 6872 if (rc != 0) 6873 return rc; 6874 } 6875 } 6876 6877 spin_lock_irqsave(&ioc->sas_node_lock, flags); 6878 sas_address = le64_to_cpu(expander_pg0.SASAddress); 6879 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 6880 sas_address, mpt3sas_get_port_by_id(ioc, port_id, 0)); 6881 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 6882 6883 if (sas_expander) 6884 return 0; 6885 6886 sas_expander = kzalloc(sizeof(struct _sas_node), 6887 GFP_KERNEL); 6888 if (!sas_expander) { 6889 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6890 __FILE__, __LINE__, __func__); 6891 return -1; 6892 } 6893 6894 sas_expander->handle = handle; 6895 sas_expander->num_phys = expander_pg0.NumPhys; 6896 sas_expander->sas_address_parent = sas_address_parent; 6897 sas_expander->sas_address = sas_address; 6898 sas_expander->port = mpt3sas_get_port_by_id(ioc, port_id, 0); 6899 if (!sas_expander->port) { 6900 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6901 __FILE__, __LINE__, __func__); 6902 rc = -1; 6903 goto out_fail; 6904 } 6905 6906 ioc_info(ioc, "expander_add: handle(0x%04x), parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", 6907 handle, parent_handle, 6908 (u64)sas_expander->sas_address, sas_expander->num_phys); 6909 6910 if (!sas_expander->num_phys) { 6911 rc = -1; 6912 goto out_fail; 6913 } 6914 sas_expander->phy = kcalloc(sas_expander->num_phys, 6915 sizeof(struct _sas_phy), GFP_KERNEL); 6916 if (!sas_expander->phy) { 6917 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6918 __FILE__, __LINE__, __func__); 6919 rc = -1; 6920 goto out_fail; 6921 } 6922 6923 INIT_LIST_HEAD(&sas_expander->sas_port_list); 6924 mpt3sas_port = mpt3sas_transport_port_add(ioc, handle, 6925 sas_address_parent, sas_expander->port); 6926 if (!mpt3sas_port) { 6927 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6928 __FILE__, __LINE__, __func__); 6929 rc = -1; 6930 goto out_fail; 6931 } 6932 sas_expander->parent_dev = &mpt3sas_port->rphy->dev; 6933 sas_expander->rphy = mpt3sas_port->rphy; 6934 6935 for (i = 0 ; i < sas_expander->num_phys ; i++) { 6936 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply, 6937 &expander_pg1, i, handle))) { 6938 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6939 __FILE__, __LINE__, __func__); 6940 rc = -1; 6941 goto out_fail; 6942 } 6943 sas_expander->phy[i].handle = handle; 6944 sas_expander->phy[i].phy_id = i; 6945 sas_expander->phy[i].port = 6946 mpt3sas_get_port_by_id(ioc, port_id, 0); 6947 6948 if ((mpt3sas_transport_add_expander_phy(ioc, 6949 &sas_expander->phy[i], expander_pg1, 6950 sas_expander->parent_dev))) { 6951 ioc_err(ioc, "failure at %s:%d/%s()!\n", 6952 __FILE__, __LINE__, __func__); 6953 rc = -1; 6954 goto out_fail; 6955 } 6956 } 6957 6958 if (sas_expander->enclosure_handle) { 6959 enclosure_dev = 6960 mpt3sas_scsih_enclosure_find_by_handle(ioc, 6961 sas_expander->enclosure_handle); 6962 if (enclosure_dev) 6963 sas_expander->enclosure_logical_id = 6964 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID); 6965 } 6966 6967 _scsih_expander_node_add(ioc, sas_expander); 6968 return 0; 6969 6970 out_fail: 6971 6972 if (mpt3sas_port) 6973 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address, 6974 sas_address_parent, sas_expander->port); 6975 kfree(sas_expander); 6976 return rc; 6977 } 6978 6979 /** 6980 * mpt3sas_expander_remove - removing expander object 6981 * @ioc: per adapter object 6982 * @sas_address: expander sas_address 6983 * @port: hba port entry 6984 */ 6985 void 6986 mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address, 6987 struct hba_port *port) 6988 { 6989 struct _sas_node *sas_expander; 6990 unsigned long flags; 6991 6992 if (ioc->shost_recovery) 6993 return; 6994 6995 if (!port) 6996 return; 6997 6998 spin_lock_irqsave(&ioc->sas_node_lock, flags); 6999 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 7000 sas_address, port); 7001 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 7002 if (sas_expander) 7003 _scsih_expander_node_remove(ioc, sas_expander); 7004 } 7005 7006 /** 7007 * _scsih_done - internal SCSI_IO callback handler. 7008 * @ioc: per adapter object 7009 * @smid: system request message index 7010 * @msix_index: MSIX table index supplied by the OS 7011 * @reply: reply message frame(lower 32bit addr) 7012 * 7013 * Callback handler when sending internal generated SCSI_IO. 7014 * The callback index passed is `ioc->scsih_cb_idx` 7015 * 7016 * Return: 1 meaning mf should be freed from _base_interrupt 7017 * 0 means the mf is freed from this function. 7018 */ 7019 static u8 7020 _scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply) 7021 { 7022 MPI2DefaultReply_t *mpi_reply; 7023 7024 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 7025 if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED) 7026 return 1; 7027 if (ioc->scsih_cmds.smid != smid) 7028 return 1; 7029 ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE; 7030 if (mpi_reply) { 7031 memcpy(ioc->scsih_cmds.reply, mpi_reply, 7032 mpi_reply->MsgLength*4); 7033 ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID; 7034 } 7035 ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING; 7036 complete(&ioc->scsih_cmds.done); 7037 return 1; 7038 } 7039 7040 7041 7042 7043 #define MPT3_MAX_LUNS (255) 7044 7045 7046 /** 7047 * _scsih_check_access_status - check access flags 7048 * @ioc: per adapter object 7049 * @sas_address: sas address 7050 * @handle: sas device handle 7051 * @access_status: errors returned during discovery of the device 7052 * 7053 * Return: 0 for success, else failure 7054 */ 7055 static u8 7056 _scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address, 7057 u16 handle, u8 access_status) 7058 { 7059 u8 rc = 1; 7060 char *desc = NULL; 7061 7062 switch (access_status) { 7063 case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS: 7064 case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION: 7065 rc = 0; 7066 break; 7067 case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED: 7068 desc = "sata capability failed"; 7069 break; 7070 case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT: 7071 desc = "sata affiliation conflict"; 7072 break; 7073 case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE: 7074 desc = "route not addressable"; 7075 break; 7076 case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE: 7077 desc = "smp error not addressable"; 7078 break; 7079 case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED: 7080 desc = "device blocked"; 7081 break; 7082 case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED: 7083 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN: 7084 case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT: 7085 case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG: 7086 case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION: 7087 case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER: 7088 case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN: 7089 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN: 7090 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN: 7091 case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION: 7092 case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE: 7093 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX: 7094 desc = "sata initialization failed"; 7095 break; 7096 default: 7097 desc = "unknown"; 7098 break; 7099 } 7100 7101 if (!rc) 7102 return 0; 7103 7104 ioc_err(ioc, "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n", 7105 desc, (u64)sas_address, handle); 7106 return rc; 7107 } 7108 7109 /** 7110 * _scsih_check_device - checking device responsiveness 7111 * @ioc: per adapter object 7112 * @parent_sas_address: sas address of parent expander or sas host 7113 * @handle: attached device handle 7114 * @phy_number: phy number 7115 * @link_rate: new link rate 7116 */ 7117 static void 7118 _scsih_check_device(struct MPT3SAS_ADAPTER *ioc, 7119 u64 parent_sas_address, u16 handle, u8 phy_number, u8 link_rate) 7120 { 7121 Mpi2ConfigReply_t mpi_reply; 7122 Mpi2SasDevicePage0_t sas_device_pg0; 7123 struct _sas_device *sas_device = NULL; 7124 struct _enclosure_node *enclosure_dev = NULL; 7125 u32 ioc_status; 7126 unsigned long flags; 7127 u64 sas_address; 7128 struct scsi_target *starget; 7129 struct MPT3SAS_TARGET *sas_target_priv_data; 7130 u32 device_info; 7131 struct hba_port *port; 7132 7133 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 7134 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) 7135 return; 7136 7137 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 7138 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 7139 return; 7140 7141 /* wide port handling ~ we need only handle device once for the phy that 7142 * is matched in sas device page zero 7143 */ 7144 if (phy_number != sas_device_pg0.PhyNum) 7145 return; 7146 7147 /* check if this is end device */ 7148 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 7149 if (!(_scsih_is_end_device(device_info))) 7150 return; 7151 7152 spin_lock_irqsave(&ioc->sas_device_lock, flags); 7153 sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 7154 port = mpt3sas_get_port_by_id(ioc, sas_device_pg0.PhysicalPort, 0); 7155 if (!port) 7156 goto out_unlock; 7157 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 7158 sas_address, port); 7159 7160 if (!sas_device) 7161 goto out_unlock; 7162 7163 if (unlikely(sas_device->handle != handle)) { 7164 starget = sas_device->starget; 7165 sas_target_priv_data = starget->hostdata; 7166 starget_printk(KERN_INFO, starget, 7167 "handle changed from(0x%04x) to (0x%04x)!!!\n", 7168 sas_device->handle, handle); 7169 sas_target_priv_data->handle = handle; 7170 sas_device->handle = handle; 7171 if (le16_to_cpu(sas_device_pg0.Flags) & 7172 MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) { 7173 sas_device->enclosure_level = 7174 sas_device_pg0.EnclosureLevel; 7175 memcpy(sas_device->connector_name, 7176 sas_device_pg0.ConnectorName, 4); 7177 sas_device->connector_name[4] = '\0'; 7178 } else { 7179 sas_device->enclosure_level = 0; 7180 sas_device->connector_name[0] = '\0'; 7181 } 7182 7183 sas_device->enclosure_handle = 7184 le16_to_cpu(sas_device_pg0.EnclosureHandle); 7185 sas_device->is_chassis_slot_valid = 0; 7186 enclosure_dev = mpt3sas_scsih_enclosure_find_by_handle(ioc, 7187 sas_device->enclosure_handle); 7188 if (enclosure_dev) { 7189 sas_device->enclosure_logical_id = 7190 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID); 7191 if (le16_to_cpu(enclosure_dev->pg0.Flags) & 7192 MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) { 7193 sas_device->is_chassis_slot_valid = 1; 7194 sas_device->chassis_slot = 7195 enclosure_dev->pg0.ChassisSlot; 7196 } 7197 } 7198 } 7199 7200 /* check if device is present */ 7201 if (!(le16_to_cpu(sas_device_pg0.Flags) & 7202 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) { 7203 ioc_err(ioc, "device is not present handle(0x%04x), flags!!!\n", 7204 handle); 7205 goto out_unlock; 7206 } 7207 7208 /* check if there were any issues with discovery */ 7209 if (_scsih_check_access_status(ioc, sas_address, handle, 7210 sas_device_pg0.AccessStatus)) 7211 goto out_unlock; 7212 7213 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 7214 _scsih_ublock_io_device(ioc, sas_address, port); 7215 7216 if (sas_device) 7217 sas_device_put(sas_device); 7218 return; 7219 7220 out_unlock: 7221 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 7222 if (sas_device) 7223 sas_device_put(sas_device); 7224 } 7225 7226 /** 7227 * _scsih_add_device - creating sas device object 7228 * @ioc: per adapter object 7229 * @handle: sas device handle 7230 * @phy_num: phy number end device attached to 7231 * @is_pd: is this hidden raid component 7232 * 7233 * Creating end device object, stored in ioc->sas_device_list. 7234 * 7235 * Return: 0 for success, non-zero for failure. 7236 */ 7237 static int 7238 _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num, 7239 u8 is_pd) 7240 { 7241 Mpi2ConfigReply_t mpi_reply; 7242 Mpi2SasDevicePage0_t sas_device_pg0; 7243 struct _sas_device *sas_device; 7244 struct _enclosure_node *enclosure_dev = NULL; 7245 u32 ioc_status; 7246 u64 sas_address; 7247 u32 device_info; 7248 u8 port_id; 7249 7250 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 7251 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) { 7252 ioc_err(ioc, "failure at %s:%d/%s()!\n", 7253 __FILE__, __LINE__, __func__); 7254 return -1; 7255 } 7256 7257 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7258 MPI2_IOCSTATUS_MASK; 7259 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 7260 ioc_err(ioc, "failure at %s:%d/%s()!\n", 7261 __FILE__, __LINE__, __func__); 7262 return -1; 7263 } 7264 7265 /* check if this is end device */ 7266 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 7267 if (!(_scsih_is_end_device(device_info))) 7268 return -1; 7269 set_bit(handle, ioc->pend_os_device_add); 7270 sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 7271 7272 /* check if device is present */ 7273 if (!(le16_to_cpu(sas_device_pg0.Flags) & 7274 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) { 7275 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n", 7276 handle); 7277 return -1; 7278 } 7279 7280 /* check if there were any issues with discovery */ 7281 if (_scsih_check_access_status(ioc, sas_address, handle, 7282 sas_device_pg0.AccessStatus)) 7283 return -1; 7284 7285 port_id = sas_device_pg0.PhysicalPort; 7286 sas_device = mpt3sas_get_sdev_by_addr(ioc, 7287 sas_address, mpt3sas_get_port_by_id(ioc, port_id, 0)); 7288 if (sas_device) { 7289 clear_bit(handle, ioc->pend_os_device_add); 7290 sas_device_put(sas_device); 7291 return -1; 7292 } 7293 7294 if (sas_device_pg0.EnclosureHandle) { 7295 enclosure_dev = 7296 mpt3sas_scsih_enclosure_find_by_handle(ioc, 7297 le16_to_cpu(sas_device_pg0.EnclosureHandle)); 7298 if (enclosure_dev == NULL) 7299 ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n", 7300 sas_device_pg0.EnclosureHandle); 7301 } 7302 7303 sas_device = kzalloc(sizeof(struct _sas_device), 7304 GFP_KERNEL); 7305 if (!sas_device) { 7306 ioc_err(ioc, "failure at %s:%d/%s()!\n", 7307 __FILE__, __LINE__, __func__); 7308 return 0; 7309 } 7310 7311 kref_init(&sas_device->refcount); 7312 sas_device->handle = handle; 7313 if (_scsih_get_sas_address(ioc, 7314 le16_to_cpu(sas_device_pg0.ParentDevHandle), 7315 &sas_device->sas_address_parent) != 0) 7316 ioc_err(ioc, "failure at %s:%d/%s()!\n", 7317 __FILE__, __LINE__, __func__); 7318 sas_device->enclosure_handle = 7319 le16_to_cpu(sas_device_pg0.EnclosureHandle); 7320 if (sas_device->enclosure_handle != 0) 7321 sas_device->slot = 7322 le16_to_cpu(sas_device_pg0.Slot); 7323 sas_device->device_info = device_info; 7324 sas_device->sas_address = sas_address; 7325 sas_device->phy = sas_device_pg0.PhyNum; 7326 sas_device->fast_path = (le16_to_cpu(sas_device_pg0.Flags) & 7327 MPI25_SAS_DEVICE0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0; 7328 sas_device->port = mpt3sas_get_port_by_id(ioc, port_id, 0); 7329 if (!sas_device->port) { 7330 ioc_err(ioc, "failure at %s:%d/%s()!\n", 7331 __FILE__, __LINE__, __func__); 7332 goto out; 7333 } 7334 7335 if (le16_to_cpu(sas_device_pg0.Flags) 7336 & MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) { 7337 sas_device->enclosure_level = 7338 sas_device_pg0.EnclosureLevel; 7339 memcpy(sas_device->connector_name, 7340 sas_device_pg0.ConnectorName, 4); 7341 sas_device->connector_name[4] = '\0'; 7342 } else { 7343 sas_device->enclosure_level = 0; 7344 sas_device->connector_name[0] = '\0'; 7345 } 7346 /* get enclosure_logical_id & chassis_slot*/ 7347 sas_device->is_chassis_slot_valid = 0; 7348 if (enclosure_dev) { 7349 sas_device->enclosure_logical_id = 7350 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID); 7351 if (le16_to_cpu(enclosure_dev->pg0.Flags) & 7352 MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) { 7353 sas_device->is_chassis_slot_valid = 1; 7354 sas_device->chassis_slot = 7355 enclosure_dev->pg0.ChassisSlot; 7356 } 7357 } 7358 7359 /* get device name */ 7360 sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName); 7361 sas_device->port_type = sas_device_pg0.MaxPortConnections; 7362 ioc_info(ioc, 7363 "handle(0x%0x) sas_address(0x%016llx) port_type(0x%0x)\n", 7364 handle, sas_device->sas_address, sas_device->port_type); 7365 7366 if (ioc->wait_for_discovery_to_complete) 7367 _scsih_sas_device_init_add(ioc, sas_device); 7368 else 7369 _scsih_sas_device_add(ioc, sas_device); 7370 7371 out: 7372 sas_device_put(sas_device); 7373 return 0; 7374 } 7375 7376 /** 7377 * _scsih_remove_device - removing sas device object 7378 * @ioc: per adapter object 7379 * @sas_device: the sas_device object 7380 */ 7381 static void 7382 _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc, 7383 struct _sas_device *sas_device) 7384 { 7385 struct MPT3SAS_TARGET *sas_target_priv_data; 7386 7387 if ((ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) && 7388 (sas_device->pfa_led_on)) { 7389 _scsih_turn_off_pfa_led(ioc, sas_device); 7390 sas_device->pfa_led_on = 0; 7391 } 7392 7393 dewtprintk(ioc, 7394 ioc_info(ioc, "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n", 7395 __func__, 7396 sas_device->handle, (u64)sas_device->sas_address)); 7397 7398 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device, 7399 NULL, NULL)); 7400 7401 if (sas_device->starget && sas_device->starget->hostdata) { 7402 sas_target_priv_data = sas_device->starget->hostdata; 7403 sas_target_priv_data->deleted = 1; 7404 _scsih_ublock_io_device(ioc, sas_device->sas_address, 7405 sas_device->port); 7406 sas_target_priv_data->handle = 7407 MPT3SAS_INVALID_DEVICE_HANDLE; 7408 } 7409 7410 if (!ioc->hide_drives) 7411 mpt3sas_transport_port_remove(ioc, 7412 sas_device->sas_address, 7413 sas_device->sas_address_parent, 7414 sas_device->port); 7415 7416 ioc_info(ioc, "removing handle(0x%04x), sas_addr(0x%016llx)\n", 7417 sas_device->handle, (u64)sas_device->sas_address); 7418 7419 _scsih_display_enclosure_chassis_info(ioc, sas_device, NULL, NULL); 7420 7421 dewtprintk(ioc, 7422 ioc_info(ioc, "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n", 7423 __func__, 7424 sas_device->handle, (u64)sas_device->sas_address)); 7425 dewtprintk(ioc, _scsih_display_enclosure_chassis_info(ioc, sas_device, 7426 NULL, NULL)); 7427 } 7428 7429 /** 7430 * _scsih_sas_topology_change_event_debug - debug for topology event 7431 * @ioc: per adapter object 7432 * @event_data: event data payload 7433 * Context: user. 7434 */ 7435 static void 7436 _scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 7437 Mpi2EventDataSasTopologyChangeList_t *event_data) 7438 { 7439 int i; 7440 u16 handle; 7441 u16 reason_code; 7442 u8 phy_number; 7443 char *status_str = NULL; 7444 u8 link_rate, prev_link_rate; 7445 7446 switch (event_data->ExpStatus) { 7447 case MPI2_EVENT_SAS_TOPO_ES_ADDED: 7448 status_str = "add"; 7449 break; 7450 case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING: 7451 status_str = "remove"; 7452 break; 7453 case MPI2_EVENT_SAS_TOPO_ES_RESPONDING: 7454 case 0: 7455 status_str = "responding"; 7456 break; 7457 case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING: 7458 status_str = "remove delay"; 7459 break; 7460 default: 7461 status_str = "unknown status"; 7462 break; 7463 } 7464 ioc_info(ioc, "sas topology change: (%s)\n", status_str); 7465 pr_info("\thandle(0x%04x), enclosure_handle(0x%04x) " \ 7466 "start_phy(%02d), count(%d)\n", 7467 le16_to_cpu(event_data->ExpanderDevHandle), 7468 le16_to_cpu(event_data->EnclosureHandle), 7469 event_data->StartPhyNum, event_data->NumEntries); 7470 for (i = 0; i < event_data->NumEntries; i++) { 7471 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 7472 if (!handle) 7473 continue; 7474 phy_number = event_data->StartPhyNum + i; 7475 reason_code = event_data->PHY[i].PhyStatus & 7476 MPI2_EVENT_SAS_TOPO_RC_MASK; 7477 switch (reason_code) { 7478 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED: 7479 status_str = "target add"; 7480 break; 7481 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING: 7482 status_str = "target remove"; 7483 break; 7484 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING: 7485 status_str = "delay target remove"; 7486 break; 7487 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED: 7488 status_str = "link rate change"; 7489 break; 7490 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE: 7491 status_str = "target responding"; 7492 break; 7493 default: 7494 status_str = "unknown"; 7495 break; 7496 } 7497 link_rate = event_data->PHY[i].LinkRate >> 4; 7498 prev_link_rate = event_data->PHY[i].LinkRate & 0xF; 7499 pr_info("\tphy(%02d), attached_handle(0x%04x): %s:" \ 7500 " link rate: new(0x%02x), old(0x%02x)\n", phy_number, 7501 handle, status_str, link_rate, prev_link_rate); 7502 7503 } 7504 } 7505 7506 /** 7507 * _scsih_sas_topology_change_event - handle topology changes 7508 * @ioc: per adapter object 7509 * @fw_event: The fw_event_work object 7510 * Context: user. 7511 * 7512 */ 7513 static int 7514 _scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc, 7515 struct fw_event_work *fw_event) 7516 { 7517 int i; 7518 u16 parent_handle, handle; 7519 u16 reason_code; 7520 u8 phy_number, max_phys; 7521 struct _sas_node *sas_expander; 7522 u64 sas_address; 7523 unsigned long flags; 7524 u8 link_rate, prev_link_rate; 7525 struct hba_port *port; 7526 Mpi2EventDataSasTopologyChangeList_t *event_data = 7527 (Mpi2EventDataSasTopologyChangeList_t *) 7528 fw_event->event_data; 7529 7530 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 7531 _scsih_sas_topology_change_event_debug(ioc, event_data); 7532 7533 if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery) 7534 return 0; 7535 7536 if (!ioc->sas_hba.num_phys) 7537 _scsih_sas_host_add(ioc); 7538 else 7539 _scsih_sas_host_refresh(ioc); 7540 7541 if (fw_event->ignore) { 7542 dewtprintk(ioc, ioc_info(ioc, "ignoring expander event\n")); 7543 return 0; 7544 } 7545 7546 parent_handle = le16_to_cpu(event_data->ExpanderDevHandle); 7547 port = mpt3sas_get_port_by_id(ioc, event_data->PhysicalPort, 0); 7548 7549 /* handle expander add */ 7550 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED) 7551 if (_scsih_expander_add(ioc, parent_handle) != 0) 7552 return 0; 7553 7554 spin_lock_irqsave(&ioc->sas_node_lock, flags); 7555 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc, 7556 parent_handle); 7557 if (sas_expander) { 7558 sas_address = sas_expander->sas_address; 7559 max_phys = sas_expander->num_phys; 7560 port = sas_expander->port; 7561 } else if (parent_handle < ioc->sas_hba.num_phys) { 7562 sas_address = ioc->sas_hba.sas_address; 7563 max_phys = ioc->sas_hba.num_phys; 7564 } else { 7565 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 7566 return 0; 7567 } 7568 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 7569 7570 /* handle siblings events */ 7571 for (i = 0; i < event_data->NumEntries; i++) { 7572 if (fw_event->ignore) { 7573 dewtprintk(ioc, 7574 ioc_info(ioc, "ignoring expander event\n")); 7575 return 0; 7576 } 7577 if (ioc->remove_host || ioc->pci_error_recovery) 7578 return 0; 7579 phy_number = event_data->StartPhyNum + i; 7580 if (phy_number >= max_phys) 7581 continue; 7582 reason_code = event_data->PHY[i].PhyStatus & 7583 MPI2_EVENT_SAS_TOPO_RC_MASK; 7584 if ((event_data->PHY[i].PhyStatus & 7585 MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code != 7586 MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)) 7587 continue; 7588 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 7589 if (!handle) 7590 continue; 7591 link_rate = event_data->PHY[i].LinkRate >> 4; 7592 prev_link_rate = event_data->PHY[i].LinkRate & 0xF; 7593 switch (reason_code) { 7594 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED: 7595 7596 if (ioc->shost_recovery) 7597 break; 7598 7599 if (link_rate == prev_link_rate) 7600 break; 7601 7602 mpt3sas_transport_update_links(ioc, sas_address, 7603 handle, phy_number, link_rate, port); 7604 7605 if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5) 7606 break; 7607 7608 _scsih_check_device(ioc, sas_address, handle, 7609 phy_number, link_rate); 7610 7611 if (!test_bit(handle, ioc->pend_os_device_add)) 7612 break; 7613 7614 fallthrough; 7615 7616 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED: 7617 7618 if (ioc->shost_recovery) 7619 break; 7620 7621 mpt3sas_transport_update_links(ioc, sas_address, 7622 handle, phy_number, link_rate, port); 7623 7624 _scsih_add_device(ioc, handle, phy_number, 0); 7625 7626 break; 7627 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING: 7628 7629 _scsih_device_remove_by_handle(ioc, handle); 7630 break; 7631 } 7632 } 7633 7634 /* handle expander removal */ 7635 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING && 7636 sas_expander) 7637 mpt3sas_expander_remove(ioc, sas_address, port); 7638 7639 return 0; 7640 } 7641 7642 /** 7643 * _scsih_sas_device_status_change_event_debug - debug for device event 7644 * @ioc: ? 7645 * @event_data: event data payload 7646 * Context: user. 7647 */ 7648 static void 7649 _scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 7650 Mpi2EventDataSasDeviceStatusChange_t *event_data) 7651 { 7652 char *reason_str = NULL; 7653 7654 switch (event_data->ReasonCode) { 7655 case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA: 7656 reason_str = "smart data"; 7657 break; 7658 case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED: 7659 reason_str = "unsupported device discovered"; 7660 break; 7661 case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET: 7662 reason_str = "internal device reset"; 7663 break; 7664 case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL: 7665 reason_str = "internal task abort"; 7666 break; 7667 case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL: 7668 reason_str = "internal task abort set"; 7669 break; 7670 case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL: 7671 reason_str = "internal clear task set"; 7672 break; 7673 case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL: 7674 reason_str = "internal query task"; 7675 break; 7676 case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE: 7677 reason_str = "sata init failure"; 7678 break; 7679 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET: 7680 reason_str = "internal device reset complete"; 7681 break; 7682 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL: 7683 reason_str = "internal task abort complete"; 7684 break; 7685 case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION: 7686 reason_str = "internal async notification"; 7687 break; 7688 case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY: 7689 reason_str = "expander reduced functionality"; 7690 break; 7691 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY: 7692 reason_str = "expander reduced functionality complete"; 7693 break; 7694 default: 7695 reason_str = "unknown reason"; 7696 break; 7697 } 7698 ioc_info(ioc, "device status change: (%s)\thandle(0x%04x), sas address(0x%016llx), tag(%d)", 7699 reason_str, le16_to_cpu(event_data->DevHandle), 7700 (u64)le64_to_cpu(event_data->SASAddress), 7701 le16_to_cpu(event_data->TaskTag)); 7702 if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA) 7703 pr_cont(", ASC(0x%x), ASCQ(0x%x)\n", 7704 event_data->ASC, event_data->ASCQ); 7705 pr_cont("\n"); 7706 } 7707 7708 /** 7709 * _scsih_sas_device_status_change_event - handle device status change 7710 * @ioc: per adapter object 7711 * @event_data: The fw event 7712 * Context: user. 7713 */ 7714 static void 7715 _scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc, 7716 Mpi2EventDataSasDeviceStatusChange_t *event_data) 7717 { 7718 struct MPT3SAS_TARGET *target_priv_data; 7719 struct _sas_device *sas_device; 7720 u64 sas_address; 7721 unsigned long flags; 7722 7723 /* In MPI Revision K (0xC), the internal device reset complete was 7724 * implemented, so avoid setting tm_busy flag for older firmware. 7725 */ 7726 if ((ioc->facts.HeaderVersion >> 8) < 0xC) 7727 return; 7728 7729 if (event_data->ReasonCode != 7730 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET && 7731 event_data->ReasonCode != 7732 MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET) 7733 return; 7734 7735 spin_lock_irqsave(&ioc->sas_device_lock, flags); 7736 sas_address = le64_to_cpu(event_data->SASAddress); 7737 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 7738 sas_address, 7739 mpt3sas_get_port_by_id(ioc, event_data->PhysicalPort, 0)); 7740 7741 if (!sas_device || !sas_device->starget) 7742 goto out; 7743 7744 target_priv_data = sas_device->starget->hostdata; 7745 if (!target_priv_data) 7746 goto out; 7747 7748 if (event_data->ReasonCode == 7749 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET) 7750 target_priv_data->tm_busy = 1; 7751 else 7752 target_priv_data->tm_busy = 0; 7753 7754 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 7755 ioc_info(ioc, 7756 "%s tm_busy flag for handle(0x%04x)\n", 7757 (target_priv_data->tm_busy == 1) ? "Enable" : "Disable", 7758 target_priv_data->handle); 7759 7760 out: 7761 if (sas_device) 7762 sas_device_put(sas_device); 7763 7764 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 7765 } 7766 7767 7768 /** 7769 * _scsih_check_pcie_access_status - check access flags 7770 * @ioc: per adapter object 7771 * @wwid: wwid 7772 * @handle: sas device handle 7773 * @access_status: errors returned during discovery of the device 7774 * 7775 * Return: 0 for success, else failure 7776 */ 7777 static u8 7778 _scsih_check_pcie_access_status(struct MPT3SAS_ADAPTER *ioc, u64 wwid, 7779 u16 handle, u8 access_status) 7780 { 7781 u8 rc = 1; 7782 char *desc = NULL; 7783 7784 switch (access_status) { 7785 case MPI26_PCIEDEV0_ASTATUS_NO_ERRORS: 7786 case MPI26_PCIEDEV0_ASTATUS_NEEDS_INITIALIZATION: 7787 rc = 0; 7788 break; 7789 case MPI26_PCIEDEV0_ASTATUS_CAPABILITY_FAILED: 7790 desc = "PCIe device capability failed"; 7791 break; 7792 case MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED: 7793 desc = "PCIe device blocked"; 7794 ioc_info(ioc, 7795 "Device with Access Status (%s): wwid(0x%016llx), " 7796 "handle(0x%04x)\n ll only be added to the internal list", 7797 desc, (u64)wwid, handle); 7798 rc = 0; 7799 break; 7800 case MPI26_PCIEDEV0_ASTATUS_MEMORY_SPACE_ACCESS_FAILED: 7801 desc = "PCIe device mem space access failed"; 7802 break; 7803 case MPI26_PCIEDEV0_ASTATUS_UNSUPPORTED_DEVICE: 7804 desc = "PCIe device unsupported"; 7805 break; 7806 case MPI26_PCIEDEV0_ASTATUS_MSIX_REQUIRED: 7807 desc = "PCIe device MSIx Required"; 7808 break; 7809 case MPI26_PCIEDEV0_ASTATUS_INIT_FAIL_MAX: 7810 desc = "PCIe device init fail max"; 7811 break; 7812 case MPI26_PCIEDEV0_ASTATUS_UNKNOWN: 7813 desc = "PCIe device status unknown"; 7814 break; 7815 case MPI26_PCIEDEV0_ASTATUS_NVME_READY_TIMEOUT: 7816 desc = "nvme ready timeout"; 7817 break; 7818 case MPI26_PCIEDEV0_ASTATUS_NVME_DEVCFG_UNSUPPORTED: 7819 desc = "nvme device configuration unsupported"; 7820 break; 7821 case MPI26_PCIEDEV0_ASTATUS_NVME_IDENTIFY_FAILED: 7822 desc = "nvme identify failed"; 7823 break; 7824 case MPI26_PCIEDEV0_ASTATUS_NVME_QCONFIG_FAILED: 7825 desc = "nvme qconfig failed"; 7826 break; 7827 case MPI26_PCIEDEV0_ASTATUS_NVME_QCREATION_FAILED: 7828 desc = "nvme qcreation failed"; 7829 break; 7830 case MPI26_PCIEDEV0_ASTATUS_NVME_EVENTCFG_FAILED: 7831 desc = "nvme eventcfg failed"; 7832 break; 7833 case MPI26_PCIEDEV0_ASTATUS_NVME_GET_FEATURE_STAT_FAILED: 7834 desc = "nvme get feature stat failed"; 7835 break; 7836 case MPI26_PCIEDEV0_ASTATUS_NVME_IDLE_TIMEOUT: 7837 desc = "nvme idle timeout"; 7838 break; 7839 case MPI26_PCIEDEV0_ASTATUS_NVME_FAILURE_STATUS: 7840 desc = "nvme failure status"; 7841 break; 7842 default: 7843 ioc_err(ioc, "NVMe discovery error(0x%02x): wwid(0x%016llx), handle(0x%04x)\n", 7844 access_status, (u64)wwid, handle); 7845 return rc; 7846 } 7847 7848 if (!rc) 7849 return rc; 7850 7851 ioc_info(ioc, "NVMe discovery error(%s): wwid(0x%016llx), handle(0x%04x)\n", 7852 desc, (u64)wwid, handle); 7853 return rc; 7854 } 7855 7856 /** 7857 * _scsih_pcie_device_remove_from_sml - removing pcie device 7858 * from SML and free up associated memory 7859 * @ioc: per adapter object 7860 * @pcie_device: the pcie_device object 7861 */ 7862 static void 7863 _scsih_pcie_device_remove_from_sml(struct MPT3SAS_ADAPTER *ioc, 7864 struct _pcie_device *pcie_device) 7865 { 7866 struct MPT3SAS_TARGET *sas_target_priv_data; 7867 7868 dewtprintk(ioc, 7869 ioc_info(ioc, "%s: enter: handle(0x%04x), wwid(0x%016llx)\n", 7870 __func__, 7871 pcie_device->handle, (u64)pcie_device->wwid)); 7872 if (pcie_device->enclosure_handle != 0) 7873 dewtprintk(ioc, 7874 ioc_info(ioc, "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n", 7875 __func__, 7876 (u64)pcie_device->enclosure_logical_id, 7877 pcie_device->slot)); 7878 if (pcie_device->connector_name[0] != '\0') 7879 dewtprintk(ioc, 7880 ioc_info(ioc, "%s: enter: enclosure level(0x%04x), connector name(%s)\n", 7881 __func__, 7882 pcie_device->enclosure_level, 7883 pcie_device->connector_name)); 7884 7885 if (pcie_device->starget && pcie_device->starget->hostdata) { 7886 sas_target_priv_data = pcie_device->starget->hostdata; 7887 sas_target_priv_data->deleted = 1; 7888 _scsih_ublock_io_device(ioc, pcie_device->wwid, NULL); 7889 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE; 7890 } 7891 7892 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n", 7893 pcie_device->handle, (u64)pcie_device->wwid); 7894 if (pcie_device->enclosure_handle != 0) 7895 ioc_info(ioc, "removing : enclosure logical id(0x%016llx), slot(%d)\n", 7896 (u64)pcie_device->enclosure_logical_id, 7897 pcie_device->slot); 7898 if (pcie_device->connector_name[0] != '\0') 7899 ioc_info(ioc, "removing: enclosure level(0x%04x), connector name( %s)\n", 7900 pcie_device->enclosure_level, 7901 pcie_device->connector_name); 7902 7903 if (pcie_device->starget && (pcie_device->access_status != 7904 MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED)) 7905 scsi_remove_target(&pcie_device->starget->dev); 7906 dewtprintk(ioc, 7907 ioc_info(ioc, "%s: exit: handle(0x%04x), wwid(0x%016llx)\n", 7908 __func__, 7909 pcie_device->handle, (u64)pcie_device->wwid)); 7910 if (pcie_device->enclosure_handle != 0) 7911 dewtprintk(ioc, 7912 ioc_info(ioc, "%s: exit: enclosure logical id(0x%016llx), slot(%d)\n", 7913 __func__, 7914 (u64)pcie_device->enclosure_logical_id, 7915 pcie_device->slot)); 7916 if (pcie_device->connector_name[0] != '\0') 7917 dewtprintk(ioc, 7918 ioc_info(ioc, "%s: exit: enclosure level(0x%04x), connector name( %s)\n", 7919 __func__, 7920 pcie_device->enclosure_level, 7921 pcie_device->connector_name)); 7922 7923 kfree(pcie_device->serial_number); 7924 } 7925 7926 7927 /** 7928 * _scsih_pcie_check_device - checking device responsiveness 7929 * @ioc: per adapter object 7930 * @handle: attached device handle 7931 */ 7932 static void 7933 _scsih_pcie_check_device(struct MPT3SAS_ADAPTER *ioc, u16 handle) 7934 { 7935 Mpi2ConfigReply_t mpi_reply; 7936 Mpi26PCIeDevicePage0_t pcie_device_pg0; 7937 u32 ioc_status; 7938 struct _pcie_device *pcie_device; 7939 u64 wwid; 7940 unsigned long flags; 7941 struct scsi_target *starget; 7942 struct MPT3SAS_TARGET *sas_target_priv_data; 7943 u32 device_info; 7944 7945 if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply, 7946 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE, handle))) 7947 return; 7948 7949 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 7950 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 7951 return; 7952 7953 /* check if this is end device */ 7954 device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo); 7955 if (!(_scsih_is_nvme_pciescsi_device(device_info))) 7956 return; 7957 7958 wwid = le64_to_cpu(pcie_device_pg0.WWID); 7959 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 7960 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid); 7961 7962 if (!pcie_device) { 7963 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 7964 return; 7965 } 7966 7967 if (unlikely(pcie_device->handle != handle)) { 7968 starget = pcie_device->starget; 7969 sas_target_priv_data = starget->hostdata; 7970 pcie_device->access_status = pcie_device_pg0.AccessStatus; 7971 starget_printk(KERN_INFO, starget, 7972 "handle changed from(0x%04x) to (0x%04x)!!!\n", 7973 pcie_device->handle, handle); 7974 sas_target_priv_data->handle = handle; 7975 pcie_device->handle = handle; 7976 7977 if (le32_to_cpu(pcie_device_pg0.Flags) & 7978 MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) { 7979 pcie_device->enclosure_level = 7980 pcie_device_pg0.EnclosureLevel; 7981 memcpy(&pcie_device->connector_name[0], 7982 &pcie_device_pg0.ConnectorName[0], 4); 7983 } else { 7984 pcie_device->enclosure_level = 0; 7985 pcie_device->connector_name[0] = '\0'; 7986 } 7987 } 7988 7989 /* check if device is present */ 7990 if (!(le32_to_cpu(pcie_device_pg0.Flags) & 7991 MPI26_PCIEDEV0_FLAGS_DEVICE_PRESENT)) { 7992 ioc_info(ioc, "device is not present handle(0x%04x), flags!!!\n", 7993 handle); 7994 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 7995 pcie_device_put(pcie_device); 7996 return; 7997 } 7998 7999 /* check if there were any issues with discovery */ 8000 if (_scsih_check_pcie_access_status(ioc, wwid, handle, 8001 pcie_device_pg0.AccessStatus)) { 8002 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 8003 pcie_device_put(pcie_device); 8004 return; 8005 } 8006 8007 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 8008 pcie_device_put(pcie_device); 8009 8010 _scsih_ublock_io_device(ioc, wwid, NULL); 8011 8012 return; 8013 } 8014 8015 /** 8016 * _scsih_pcie_add_device - creating pcie device object 8017 * @ioc: per adapter object 8018 * @handle: pcie device handle 8019 * 8020 * Creating end device object, stored in ioc->pcie_device_list. 8021 * 8022 * Return: 1 means queue the event later, 0 means complete the event 8023 */ 8024 static int 8025 _scsih_pcie_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle) 8026 { 8027 Mpi26PCIeDevicePage0_t pcie_device_pg0; 8028 Mpi26PCIeDevicePage2_t pcie_device_pg2; 8029 Mpi2ConfigReply_t mpi_reply; 8030 struct _pcie_device *pcie_device; 8031 struct _enclosure_node *enclosure_dev; 8032 u32 ioc_status; 8033 u64 wwid; 8034 8035 if ((mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply, 8036 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_HANDLE, handle))) { 8037 ioc_err(ioc, "failure at %s:%d/%s()!\n", 8038 __FILE__, __LINE__, __func__); 8039 return 0; 8040 } 8041 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 8042 MPI2_IOCSTATUS_MASK; 8043 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 8044 ioc_err(ioc, "failure at %s:%d/%s()!\n", 8045 __FILE__, __LINE__, __func__); 8046 return 0; 8047 } 8048 8049 set_bit(handle, ioc->pend_os_device_add); 8050 wwid = le64_to_cpu(pcie_device_pg0.WWID); 8051 8052 /* check if device is present */ 8053 if (!(le32_to_cpu(pcie_device_pg0.Flags) & 8054 MPI26_PCIEDEV0_FLAGS_DEVICE_PRESENT)) { 8055 ioc_err(ioc, "device is not present handle(0x04%x)!!!\n", 8056 handle); 8057 return 0; 8058 } 8059 8060 /* check if there were any issues with discovery */ 8061 if (_scsih_check_pcie_access_status(ioc, wwid, handle, 8062 pcie_device_pg0.AccessStatus)) 8063 return 0; 8064 8065 if (!(_scsih_is_nvme_pciescsi_device(le32_to_cpu 8066 (pcie_device_pg0.DeviceInfo)))) 8067 return 0; 8068 8069 pcie_device = mpt3sas_get_pdev_by_wwid(ioc, wwid); 8070 if (pcie_device) { 8071 clear_bit(handle, ioc->pend_os_device_add); 8072 pcie_device_put(pcie_device); 8073 return 0; 8074 } 8075 8076 /* PCIe Device Page 2 contains read-only information about a 8077 * specific NVMe device; therefore, this page is only 8078 * valid for NVMe devices and skip for pcie devices of type scsi. 8079 */ 8080 if (!(mpt3sas_scsih_is_pcie_scsi_device( 8081 le32_to_cpu(pcie_device_pg0.DeviceInfo)))) { 8082 if (mpt3sas_config_get_pcie_device_pg2(ioc, &mpi_reply, 8083 &pcie_device_pg2, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, 8084 handle)) { 8085 ioc_err(ioc, 8086 "failure at %s:%d/%s()!\n", __FILE__, 8087 __LINE__, __func__); 8088 return 0; 8089 } 8090 8091 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 8092 MPI2_IOCSTATUS_MASK; 8093 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 8094 ioc_err(ioc, 8095 "failure at %s:%d/%s()!\n", __FILE__, 8096 __LINE__, __func__); 8097 return 0; 8098 } 8099 } 8100 8101 pcie_device = kzalloc(sizeof(struct _pcie_device), GFP_KERNEL); 8102 if (!pcie_device) { 8103 ioc_err(ioc, "failure at %s:%d/%s()!\n", 8104 __FILE__, __LINE__, __func__); 8105 return 0; 8106 } 8107 8108 kref_init(&pcie_device->refcount); 8109 pcie_device->id = ioc->pcie_target_id++; 8110 pcie_device->channel = PCIE_CHANNEL; 8111 pcie_device->handle = handle; 8112 pcie_device->access_status = pcie_device_pg0.AccessStatus; 8113 pcie_device->device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo); 8114 pcie_device->wwid = wwid; 8115 pcie_device->port_num = pcie_device_pg0.PortNum; 8116 pcie_device->fast_path = (le32_to_cpu(pcie_device_pg0.Flags) & 8117 MPI26_PCIEDEV0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0; 8118 8119 pcie_device->enclosure_handle = 8120 le16_to_cpu(pcie_device_pg0.EnclosureHandle); 8121 if (pcie_device->enclosure_handle != 0) 8122 pcie_device->slot = le16_to_cpu(pcie_device_pg0.Slot); 8123 8124 if (le32_to_cpu(pcie_device_pg0.Flags) & 8125 MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) { 8126 pcie_device->enclosure_level = pcie_device_pg0.EnclosureLevel; 8127 memcpy(&pcie_device->connector_name[0], 8128 &pcie_device_pg0.ConnectorName[0], 4); 8129 } else { 8130 pcie_device->enclosure_level = 0; 8131 pcie_device->connector_name[0] = '\0'; 8132 } 8133 8134 /* get enclosure_logical_id */ 8135 if (pcie_device->enclosure_handle) { 8136 enclosure_dev = 8137 mpt3sas_scsih_enclosure_find_by_handle(ioc, 8138 pcie_device->enclosure_handle); 8139 if (enclosure_dev) 8140 pcie_device->enclosure_logical_id = 8141 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID); 8142 } 8143 /* TODO -- Add device name once FW supports it */ 8144 if (!(mpt3sas_scsih_is_pcie_scsi_device( 8145 le32_to_cpu(pcie_device_pg0.DeviceInfo)))) { 8146 pcie_device->nvme_mdts = 8147 le32_to_cpu(pcie_device_pg2.MaximumDataTransferSize); 8148 pcie_device->shutdown_latency = 8149 le16_to_cpu(pcie_device_pg2.ShutdownLatency); 8150 /* 8151 * Set IOC's max_shutdown_latency to drive's RTD3 Entry Latency 8152 * if drive's RTD3 Entry Latency is greater then IOC's 8153 * max_shutdown_latency. 8154 */ 8155 if (pcie_device->shutdown_latency > ioc->max_shutdown_latency) 8156 ioc->max_shutdown_latency = 8157 pcie_device->shutdown_latency; 8158 if (pcie_device_pg2.ControllerResetTO) 8159 pcie_device->reset_timeout = 8160 pcie_device_pg2.ControllerResetTO; 8161 else 8162 pcie_device->reset_timeout = 30; 8163 } else 8164 pcie_device->reset_timeout = 30; 8165 8166 if (ioc->wait_for_discovery_to_complete) 8167 _scsih_pcie_device_init_add(ioc, pcie_device); 8168 else 8169 _scsih_pcie_device_add(ioc, pcie_device); 8170 8171 pcie_device_put(pcie_device); 8172 return 0; 8173 } 8174 8175 /** 8176 * _scsih_pcie_topology_change_event_debug - debug for topology 8177 * event 8178 * @ioc: per adapter object 8179 * @event_data: event data payload 8180 * Context: user. 8181 */ 8182 static void 8183 _scsih_pcie_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 8184 Mpi26EventDataPCIeTopologyChangeList_t *event_data) 8185 { 8186 int i; 8187 u16 handle; 8188 u16 reason_code; 8189 u8 port_number; 8190 char *status_str = NULL; 8191 u8 link_rate, prev_link_rate; 8192 8193 switch (event_data->SwitchStatus) { 8194 case MPI26_EVENT_PCIE_TOPO_SS_ADDED: 8195 status_str = "add"; 8196 break; 8197 case MPI26_EVENT_PCIE_TOPO_SS_NOT_RESPONDING: 8198 status_str = "remove"; 8199 break; 8200 case MPI26_EVENT_PCIE_TOPO_SS_RESPONDING: 8201 case 0: 8202 status_str = "responding"; 8203 break; 8204 case MPI26_EVENT_PCIE_TOPO_SS_DELAY_NOT_RESPONDING: 8205 status_str = "remove delay"; 8206 break; 8207 default: 8208 status_str = "unknown status"; 8209 break; 8210 } 8211 ioc_info(ioc, "pcie topology change: (%s)\n", status_str); 8212 pr_info("\tswitch_handle(0x%04x), enclosure_handle(0x%04x)" 8213 "start_port(%02d), count(%d)\n", 8214 le16_to_cpu(event_data->SwitchDevHandle), 8215 le16_to_cpu(event_data->EnclosureHandle), 8216 event_data->StartPortNum, event_data->NumEntries); 8217 for (i = 0; i < event_data->NumEntries; i++) { 8218 handle = 8219 le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle); 8220 if (!handle) 8221 continue; 8222 port_number = event_data->StartPortNum + i; 8223 reason_code = event_data->PortEntry[i].PortStatus; 8224 switch (reason_code) { 8225 case MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED: 8226 status_str = "target add"; 8227 break; 8228 case MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING: 8229 status_str = "target remove"; 8230 break; 8231 case MPI26_EVENT_PCIE_TOPO_PS_DELAY_NOT_RESPONDING: 8232 status_str = "delay target remove"; 8233 break; 8234 case MPI26_EVENT_PCIE_TOPO_PS_PORT_CHANGED: 8235 status_str = "link rate change"; 8236 break; 8237 case MPI26_EVENT_PCIE_TOPO_PS_NO_CHANGE: 8238 status_str = "target responding"; 8239 break; 8240 default: 8241 status_str = "unknown"; 8242 break; 8243 } 8244 link_rate = event_data->PortEntry[i].CurrentPortInfo & 8245 MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK; 8246 prev_link_rate = event_data->PortEntry[i].PreviousPortInfo & 8247 MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK; 8248 pr_info("\tport(%02d), attached_handle(0x%04x): %s:" 8249 " link rate: new(0x%02x), old(0x%02x)\n", port_number, 8250 handle, status_str, link_rate, prev_link_rate); 8251 } 8252 } 8253 8254 /** 8255 * _scsih_pcie_topology_change_event - handle PCIe topology 8256 * changes 8257 * @ioc: per adapter object 8258 * @fw_event: The fw_event_work object 8259 * Context: user. 8260 * 8261 */ 8262 static void 8263 _scsih_pcie_topology_change_event(struct MPT3SAS_ADAPTER *ioc, 8264 struct fw_event_work *fw_event) 8265 { 8266 int i; 8267 u16 handle; 8268 u16 reason_code; 8269 u8 link_rate, prev_link_rate; 8270 unsigned long flags; 8271 int rc; 8272 Mpi26EventDataPCIeTopologyChangeList_t *event_data = 8273 (Mpi26EventDataPCIeTopologyChangeList_t *) fw_event->event_data; 8274 struct _pcie_device *pcie_device; 8275 8276 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 8277 _scsih_pcie_topology_change_event_debug(ioc, event_data); 8278 8279 if (ioc->shost_recovery || ioc->remove_host || 8280 ioc->pci_error_recovery) 8281 return; 8282 8283 if (fw_event->ignore) { 8284 dewtprintk(ioc, ioc_info(ioc, "ignoring switch event\n")); 8285 return; 8286 } 8287 8288 /* handle siblings events */ 8289 for (i = 0; i < event_data->NumEntries; i++) { 8290 if (fw_event->ignore) { 8291 dewtprintk(ioc, 8292 ioc_info(ioc, "ignoring switch event\n")); 8293 return; 8294 } 8295 if (ioc->remove_host || ioc->pci_error_recovery) 8296 return; 8297 reason_code = event_data->PortEntry[i].PortStatus; 8298 handle = 8299 le16_to_cpu(event_data->PortEntry[i].AttachedDevHandle); 8300 if (!handle) 8301 continue; 8302 8303 link_rate = event_data->PortEntry[i].CurrentPortInfo 8304 & MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK; 8305 prev_link_rate = event_data->PortEntry[i].PreviousPortInfo 8306 & MPI26_EVENT_PCIE_TOPO_PI_RATE_MASK; 8307 8308 switch (reason_code) { 8309 case MPI26_EVENT_PCIE_TOPO_PS_PORT_CHANGED: 8310 if (ioc->shost_recovery) 8311 break; 8312 if (link_rate == prev_link_rate) 8313 break; 8314 if (link_rate < MPI26_EVENT_PCIE_TOPO_PI_RATE_2_5) 8315 break; 8316 8317 _scsih_pcie_check_device(ioc, handle); 8318 8319 /* This code after this point handles the test case 8320 * where a device has been added, however its returning 8321 * BUSY for sometime. Then before the Device Missing 8322 * Delay expires and the device becomes READY, the 8323 * device is removed and added back. 8324 */ 8325 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 8326 pcie_device = __mpt3sas_get_pdev_by_handle(ioc, handle); 8327 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 8328 8329 if (pcie_device) { 8330 pcie_device_put(pcie_device); 8331 break; 8332 } 8333 8334 if (!test_bit(handle, ioc->pend_os_device_add)) 8335 break; 8336 8337 dewtprintk(ioc, 8338 ioc_info(ioc, "handle(0x%04x) device not found: convert event to a device add\n", 8339 handle)); 8340 event_data->PortEntry[i].PortStatus &= 0xF0; 8341 event_data->PortEntry[i].PortStatus |= 8342 MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED; 8343 fallthrough; 8344 case MPI26_EVENT_PCIE_TOPO_PS_DEV_ADDED: 8345 if (ioc->shost_recovery) 8346 break; 8347 if (link_rate < MPI26_EVENT_PCIE_TOPO_PI_RATE_2_5) 8348 break; 8349 8350 rc = _scsih_pcie_add_device(ioc, handle); 8351 if (!rc) { 8352 /* mark entry vacant */ 8353 /* TODO This needs to be reviewed and fixed, 8354 * we dont have an entry 8355 * to make an event void like vacant 8356 */ 8357 event_data->PortEntry[i].PortStatus |= 8358 MPI26_EVENT_PCIE_TOPO_PS_NO_CHANGE; 8359 } 8360 break; 8361 case MPI26_EVENT_PCIE_TOPO_PS_NOT_RESPONDING: 8362 _scsih_pcie_device_remove_by_handle(ioc, handle); 8363 break; 8364 } 8365 } 8366 } 8367 8368 /** 8369 * _scsih_pcie_device_status_change_event_debug - debug for device event 8370 * @ioc: ? 8371 * @event_data: event data payload 8372 * Context: user. 8373 */ 8374 static void 8375 _scsih_pcie_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 8376 Mpi26EventDataPCIeDeviceStatusChange_t *event_data) 8377 { 8378 char *reason_str = NULL; 8379 8380 switch (event_data->ReasonCode) { 8381 case MPI26_EVENT_PCIDEV_STAT_RC_SMART_DATA: 8382 reason_str = "smart data"; 8383 break; 8384 case MPI26_EVENT_PCIDEV_STAT_RC_UNSUPPORTED: 8385 reason_str = "unsupported device discovered"; 8386 break; 8387 case MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET: 8388 reason_str = "internal device reset"; 8389 break; 8390 case MPI26_EVENT_PCIDEV_STAT_RC_TASK_ABORT_INTERNAL: 8391 reason_str = "internal task abort"; 8392 break; 8393 case MPI26_EVENT_PCIDEV_STAT_RC_ABORT_TASK_SET_INTERNAL: 8394 reason_str = "internal task abort set"; 8395 break; 8396 case MPI26_EVENT_PCIDEV_STAT_RC_CLEAR_TASK_SET_INTERNAL: 8397 reason_str = "internal clear task set"; 8398 break; 8399 case MPI26_EVENT_PCIDEV_STAT_RC_QUERY_TASK_INTERNAL: 8400 reason_str = "internal query task"; 8401 break; 8402 case MPI26_EVENT_PCIDEV_STAT_RC_DEV_INIT_FAILURE: 8403 reason_str = "device init failure"; 8404 break; 8405 case MPI26_EVENT_PCIDEV_STAT_RC_CMP_INTERNAL_DEV_RESET: 8406 reason_str = "internal device reset complete"; 8407 break; 8408 case MPI26_EVENT_PCIDEV_STAT_RC_CMP_TASK_ABORT_INTERNAL: 8409 reason_str = "internal task abort complete"; 8410 break; 8411 case MPI26_EVENT_PCIDEV_STAT_RC_ASYNC_NOTIFICATION: 8412 reason_str = "internal async notification"; 8413 break; 8414 case MPI26_EVENT_PCIDEV_STAT_RC_PCIE_HOT_RESET_FAILED: 8415 reason_str = "pcie hot reset failed"; 8416 break; 8417 default: 8418 reason_str = "unknown reason"; 8419 break; 8420 } 8421 8422 ioc_info(ioc, "PCIE device status change: (%s)\n" 8423 "\thandle(0x%04x), WWID(0x%016llx), tag(%d)", 8424 reason_str, le16_to_cpu(event_data->DevHandle), 8425 (u64)le64_to_cpu(event_data->WWID), 8426 le16_to_cpu(event_data->TaskTag)); 8427 if (event_data->ReasonCode == MPI26_EVENT_PCIDEV_STAT_RC_SMART_DATA) 8428 pr_cont(", ASC(0x%x), ASCQ(0x%x)\n", 8429 event_data->ASC, event_data->ASCQ); 8430 pr_cont("\n"); 8431 } 8432 8433 /** 8434 * _scsih_pcie_device_status_change_event - handle device status 8435 * change 8436 * @ioc: per adapter object 8437 * @fw_event: The fw_event_work object 8438 * Context: user. 8439 */ 8440 static void 8441 _scsih_pcie_device_status_change_event(struct MPT3SAS_ADAPTER *ioc, 8442 struct fw_event_work *fw_event) 8443 { 8444 struct MPT3SAS_TARGET *target_priv_data; 8445 struct _pcie_device *pcie_device; 8446 u64 wwid; 8447 unsigned long flags; 8448 Mpi26EventDataPCIeDeviceStatusChange_t *event_data = 8449 (Mpi26EventDataPCIeDeviceStatusChange_t *)fw_event->event_data; 8450 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 8451 _scsih_pcie_device_status_change_event_debug(ioc, 8452 event_data); 8453 8454 if (event_data->ReasonCode != 8455 MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET && 8456 event_data->ReasonCode != 8457 MPI26_EVENT_PCIDEV_STAT_RC_CMP_INTERNAL_DEV_RESET) 8458 return; 8459 8460 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 8461 wwid = le64_to_cpu(event_data->WWID); 8462 pcie_device = __mpt3sas_get_pdev_by_wwid(ioc, wwid); 8463 8464 if (!pcie_device || !pcie_device->starget) 8465 goto out; 8466 8467 target_priv_data = pcie_device->starget->hostdata; 8468 if (!target_priv_data) 8469 goto out; 8470 8471 if (event_data->ReasonCode == 8472 MPI26_EVENT_PCIDEV_STAT_RC_INTERNAL_DEVICE_RESET) 8473 target_priv_data->tm_busy = 1; 8474 else 8475 target_priv_data->tm_busy = 0; 8476 out: 8477 if (pcie_device) 8478 pcie_device_put(pcie_device); 8479 8480 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 8481 } 8482 8483 /** 8484 * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure 8485 * event 8486 * @ioc: per adapter object 8487 * @event_data: event data payload 8488 * Context: user. 8489 */ 8490 static void 8491 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 8492 Mpi2EventDataSasEnclDevStatusChange_t *event_data) 8493 { 8494 char *reason_str = NULL; 8495 8496 switch (event_data->ReasonCode) { 8497 case MPI2_EVENT_SAS_ENCL_RC_ADDED: 8498 reason_str = "enclosure add"; 8499 break; 8500 case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING: 8501 reason_str = "enclosure remove"; 8502 break; 8503 default: 8504 reason_str = "unknown reason"; 8505 break; 8506 } 8507 8508 ioc_info(ioc, "enclosure status change: (%s)\n" 8509 "\thandle(0x%04x), enclosure logical id(0x%016llx) number slots(%d)\n", 8510 reason_str, 8511 le16_to_cpu(event_data->EnclosureHandle), 8512 (u64)le64_to_cpu(event_data->EnclosureLogicalID), 8513 le16_to_cpu(event_data->StartSlot)); 8514 } 8515 8516 /** 8517 * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events 8518 * @ioc: per adapter object 8519 * @fw_event: The fw_event_work object 8520 * Context: user. 8521 */ 8522 static void 8523 _scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc, 8524 struct fw_event_work *fw_event) 8525 { 8526 Mpi2ConfigReply_t mpi_reply; 8527 struct _enclosure_node *enclosure_dev = NULL; 8528 Mpi2EventDataSasEnclDevStatusChange_t *event_data = 8529 (Mpi2EventDataSasEnclDevStatusChange_t *)fw_event->event_data; 8530 int rc; 8531 u16 enclosure_handle = le16_to_cpu(event_data->EnclosureHandle); 8532 8533 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 8534 _scsih_sas_enclosure_dev_status_change_event_debug(ioc, 8535 (Mpi2EventDataSasEnclDevStatusChange_t *) 8536 fw_event->event_data); 8537 if (ioc->shost_recovery) 8538 return; 8539 8540 if (enclosure_handle) 8541 enclosure_dev = 8542 mpt3sas_scsih_enclosure_find_by_handle(ioc, 8543 enclosure_handle); 8544 switch (event_data->ReasonCode) { 8545 case MPI2_EVENT_SAS_ENCL_RC_ADDED: 8546 if (!enclosure_dev) { 8547 enclosure_dev = 8548 kzalloc(sizeof(struct _enclosure_node), 8549 GFP_KERNEL); 8550 if (!enclosure_dev) { 8551 ioc_info(ioc, "failure at %s:%d/%s()!\n", 8552 __FILE__, __LINE__, __func__); 8553 return; 8554 } 8555 rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply, 8556 &enclosure_dev->pg0, 8557 MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE, 8558 enclosure_handle); 8559 8560 if (rc || (le16_to_cpu(mpi_reply.IOCStatus) & 8561 MPI2_IOCSTATUS_MASK)) { 8562 kfree(enclosure_dev); 8563 return; 8564 } 8565 8566 list_add_tail(&enclosure_dev->list, 8567 &ioc->enclosure_list); 8568 } 8569 break; 8570 case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING: 8571 if (enclosure_dev) { 8572 list_del(&enclosure_dev->list); 8573 kfree(enclosure_dev); 8574 } 8575 break; 8576 default: 8577 break; 8578 } 8579 } 8580 8581 /** 8582 * _scsih_sas_broadcast_primitive_event - handle broadcast events 8583 * @ioc: per adapter object 8584 * @fw_event: The fw_event_work object 8585 * Context: user. 8586 */ 8587 static void 8588 _scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc, 8589 struct fw_event_work *fw_event) 8590 { 8591 struct scsi_cmnd *scmd; 8592 struct scsi_device *sdev; 8593 struct scsiio_tracker *st; 8594 u16 smid, handle; 8595 u32 lun; 8596 struct MPT3SAS_DEVICE *sas_device_priv_data; 8597 u32 termination_count; 8598 u32 query_count; 8599 Mpi2SCSITaskManagementReply_t *mpi_reply; 8600 Mpi2EventDataSasBroadcastPrimitive_t *event_data = 8601 (Mpi2EventDataSasBroadcastPrimitive_t *) 8602 fw_event->event_data; 8603 u16 ioc_status; 8604 unsigned long flags; 8605 int r; 8606 u8 max_retries = 0; 8607 u8 task_abort_retries; 8608 8609 mutex_lock(&ioc->tm_cmds.mutex); 8610 ioc_info(ioc, "%s: enter: phy number(%d), width(%d)\n", 8611 __func__, event_data->PhyNum, event_data->PortWidth); 8612 8613 _scsih_block_io_all_device(ioc); 8614 8615 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8616 mpi_reply = ioc->tm_cmds.reply; 8617 broadcast_aen_retry: 8618 8619 /* sanity checks for retrying this loop */ 8620 if (max_retries++ == 5) { 8621 dewtprintk(ioc, ioc_info(ioc, "%s: giving up\n", __func__)); 8622 goto out; 8623 } else if (max_retries > 1) 8624 dewtprintk(ioc, 8625 ioc_info(ioc, "%s: %d retry\n", 8626 __func__, max_retries - 1)); 8627 8628 termination_count = 0; 8629 query_count = 0; 8630 for (smid = 1; smid <= ioc->scsiio_depth; smid++) { 8631 if (ioc->shost_recovery) 8632 goto out; 8633 scmd = mpt3sas_scsih_scsi_lookup_get(ioc, smid); 8634 if (!scmd) 8635 continue; 8636 st = scsi_cmd_priv(scmd); 8637 sdev = scmd->device; 8638 sas_device_priv_data = sdev->hostdata; 8639 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) 8640 continue; 8641 /* skip hidden raid components */ 8642 if (sas_device_priv_data->sas_target->flags & 8643 MPT_TARGET_FLAGS_RAID_COMPONENT) 8644 continue; 8645 /* skip volumes */ 8646 if (sas_device_priv_data->sas_target->flags & 8647 MPT_TARGET_FLAGS_VOLUME) 8648 continue; 8649 /* skip PCIe devices */ 8650 if (sas_device_priv_data->sas_target->flags & 8651 MPT_TARGET_FLAGS_PCIE_DEVICE) 8652 continue; 8653 8654 handle = sas_device_priv_data->sas_target->handle; 8655 lun = sas_device_priv_data->lun; 8656 query_count++; 8657 8658 if (ioc->shost_recovery) 8659 goto out; 8660 8661 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 8662 r = mpt3sas_scsih_issue_tm(ioc, handle, 0, 0, lun, 8663 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, st->smid, 8664 st->msix_io, 30, 0); 8665 if (r == FAILED) { 8666 sdev_printk(KERN_WARNING, sdev, 8667 "mpt3sas_scsih_issue_tm: FAILED when sending " 8668 "QUERY_TASK: scmd(%p)\n", scmd); 8669 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8670 goto broadcast_aen_retry; 8671 } 8672 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) 8673 & MPI2_IOCSTATUS_MASK; 8674 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 8675 sdev_printk(KERN_WARNING, sdev, 8676 "query task: FAILED with IOCSTATUS(0x%04x), scmd(%p)\n", 8677 ioc_status, scmd); 8678 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8679 goto broadcast_aen_retry; 8680 } 8681 8682 /* see if IO is still owned by IOC and target */ 8683 if (mpi_reply->ResponseCode == 8684 MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED || 8685 mpi_reply->ResponseCode == 8686 MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) { 8687 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8688 continue; 8689 } 8690 task_abort_retries = 0; 8691 tm_retry: 8692 if (task_abort_retries++ == 60) { 8693 dewtprintk(ioc, 8694 ioc_info(ioc, "%s: ABORT_TASK: giving up\n", 8695 __func__)); 8696 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8697 goto broadcast_aen_retry; 8698 } 8699 8700 if (ioc->shost_recovery) 8701 goto out_no_lock; 8702 8703 r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id, 8704 sdev->lun, MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, 8705 st->smid, st->msix_io, 30, 0); 8706 if (r == FAILED || st->cb_idx != 0xFF) { 8707 sdev_printk(KERN_WARNING, sdev, 8708 "mpt3sas_scsih_issue_tm: ABORT_TASK: FAILED : " 8709 "scmd(%p)\n", scmd); 8710 goto tm_retry; 8711 } 8712 8713 if (task_abort_retries > 1) 8714 sdev_printk(KERN_WARNING, sdev, 8715 "mpt3sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):" 8716 " scmd(%p)\n", 8717 task_abort_retries - 1, scmd); 8718 8719 termination_count += le32_to_cpu(mpi_reply->TerminationCount); 8720 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 8721 } 8722 8723 if (ioc->broadcast_aen_pending) { 8724 dewtprintk(ioc, 8725 ioc_info(ioc, 8726 "%s: loop back due to pending AEN\n", 8727 __func__)); 8728 ioc->broadcast_aen_pending = 0; 8729 goto broadcast_aen_retry; 8730 } 8731 8732 out: 8733 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 8734 out_no_lock: 8735 8736 dewtprintk(ioc, 8737 ioc_info(ioc, "%s - exit, query_count = %d termination_count = %d\n", 8738 __func__, query_count, termination_count)); 8739 8740 ioc->broadcast_aen_busy = 0; 8741 if (!ioc->shost_recovery) 8742 _scsih_ublock_io_all_device(ioc); 8743 mutex_unlock(&ioc->tm_cmds.mutex); 8744 } 8745 8746 /** 8747 * _scsih_sas_discovery_event - handle discovery events 8748 * @ioc: per adapter object 8749 * @fw_event: The fw_event_work object 8750 * Context: user. 8751 */ 8752 static void 8753 _scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc, 8754 struct fw_event_work *fw_event) 8755 { 8756 Mpi2EventDataSasDiscovery_t *event_data = 8757 (Mpi2EventDataSasDiscovery_t *) fw_event->event_data; 8758 8759 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) { 8760 ioc_info(ioc, "discovery event: (%s)", 8761 event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED ? 8762 "start" : "stop"); 8763 if (event_data->DiscoveryStatus) 8764 pr_cont("discovery_status(0x%08x)", 8765 le32_to_cpu(event_data->DiscoveryStatus)); 8766 pr_cont("\n"); 8767 } 8768 8769 if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED && 8770 !ioc->sas_hba.num_phys) { 8771 if (disable_discovery > 0 && ioc->shost_recovery) { 8772 /* Wait for the reset to complete */ 8773 while (ioc->shost_recovery) 8774 ssleep(1); 8775 } 8776 _scsih_sas_host_add(ioc); 8777 } 8778 } 8779 8780 /** 8781 * _scsih_sas_device_discovery_error_event - display SAS device discovery error 8782 * events 8783 * @ioc: per adapter object 8784 * @fw_event: The fw_event_work object 8785 * Context: user. 8786 */ 8787 static void 8788 _scsih_sas_device_discovery_error_event(struct MPT3SAS_ADAPTER *ioc, 8789 struct fw_event_work *fw_event) 8790 { 8791 Mpi25EventDataSasDeviceDiscoveryError_t *event_data = 8792 (Mpi25EventDataSasDeviceDiscoveryError_t *)fw_event->event_data; 8793 8794 switch (event_data->ReasonCode) { 8795 case MPI25_EVENT_SAS_DISC_ERR_SMP_FAILED: 8796 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has failed\n", 8797 le16_to_cpu(event_data->DevHandle), 8798 (u64)le64_to_cpu(event_data->SASAddress), 8799 event_data->PhysicalPort); 8800 break; 8801 case MPI25_EVENT_SAS_DISC_ERR_SMP_TIMEOUT: 8802 ioc_warn(ioc, "SMP command sent to the expander (handle:0x%04x, sas_address:0x%016llx, physical_port:0x%02x) has timed out\n", 8803 le16_to_cpu(event_data->DevHandle), 8804 (u64)le64_to_cpu(event_data->SASAddress), 8805 event_data->PhysicalPort); 8806 break; 8807 default: 8808 break; 8809 } 8810 } 8811 8812 /** 8813 * _scsih_pcie_enumeration_event - handle enumeration events 8814 * @ioc: per adapter object 8815 * @fw_event: The fw_event_work object 8816 * Context: user. 8817 */ 8818 static void 8819 _scsih_pcie_enumeration_event(struct MPT3SAS_ADAPTER *ioc, 8820 struct fw_event_work *fw_event) 8821 { 8822 Mpi26EventDataPCIeEnumeration_t *event_data = 8823 (Mpi26EventDataPCIeEnumeration_t *)fw_event->event_data; 8824 8825 if (!(ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK)) 8826 return; 8827 8828 ioc_info(ioc, "pcie enumeration event: (%s) Flag 0x%02x", 8829 (event_data->ReasonCode == MPI26_EVENT_PCIE_ENUM_RC_STARTED) ? 8830 "started" : "completed", 8831 event_data->Flags); 8832 if (event_data->EnumerationStatus) 8833 pr_cont("enumeration_status(0x%08x)", 8834 le32_to_cpu(event_data->EnumerationStatus)); 8835 pr_cont("\n"); 8836 } 8837 8838 /** 8839 * _scsih_ir_fastpath - turn on fastpath for IR physdisk 8840 * @ioc: per adapter object 8841 * @handle: device handle for physical disk 8842 * @phys_disk_num: physical disk number 8843 * 8844 * Return: 0 for success, else failure. 8845 */ 8846 static int 8847 _scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num) 8848 { 8849 Mpi2RaidActionRequest_t *mpi_request; 8850 Mpi2RaidActionReply_t *mpi_reply; 8851 u16 smid; 8852 u8 issue_reset = 0; 8853 int rc = 0; 8854 u16 ioc_status; 8855 u32 log_info; 8856 8857 if (ioc->hba_mpi_version_belonged == MPI2_VERSION) 8858 return rc; 8859 8860 mutex_lock(&ioc->scsih_cmds.mutex); 8861 8862 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) { 8863 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__); 8864 rc = -EAGAIN; 8865 goto out; 8866 } 8867 ioc->scsih_cmds.status = MPT3_CMD_PENDING; 8868 8869 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx); 8870 if (!smid) { 8871 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__); 8872 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 8873 rc = -EAGAIN; 8874 goto out; 8875 } 8876 8877 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 8878 ioc->scsih_cmds.smid = smid; 8879 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t)); 8880 8881 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION; 8882 mpi_request->Action = MPI2_RAID_ACTION_PHYSDISK_HIDDEN; 8883 mpi_request->PhysDiskNum = phys_disk_num; 8884 8885 dewtprintk(ioc, 8886 ioc_info(ioc, "IR RAID_ACTION: turning fast path on for handle(0x%04x), phys_disk_num (0x%02x)\n", 8887 handle, phys_disk_num)); 8888 8889 init_completion(&ioc->scsih_cmds.done); 8890 ioc->put_smid_default(ioc, smid); 8891 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ); 8892 8893 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) { 8894 mpt3sas_check_cmd_timeout(ioc, 8895 ioc->scsih_cmds.status, mpi_request, 8896 sizeof(Mpi2RaidActionRequest_t)/4, issue_reset); 8897 rc = -EFAULT; 8898 goto out; 8899 } 8900 8901 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) { 8902 8903 mpi_reply = ioc->scsih_cmds.reply; 8904 ioc_status = le16_to_cpu(mpi_reply->IOCStatus); 8905 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) 8906 log_info = le32_to_cpu(mpi_reply->IOCLogInfo); 8907 else 8908 log_info = 0; 8909 ioc_status &= MPI2_IOCSTATUS_MASK; 8910 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 8911 dewtprintk(ioc, 8912 ioc_info(ioc, "IR RAID_ACTION: failed: ioc_status(0x%04x), loginfo(0x%08x)!!!\n", 8913 ioc_status, log_info)); 8914 rc = -EFAULT; 8915 } else 8916 dewtprintk(ioc, 8917 ioc_info(ioc, "IR RAID_ACTION: completed successfully\n")); 8918 } 8919 8920 out: 8921 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 8922 mutex_unlock(&ioc->scsih_cmds.mutex); 8923 8924 if (issue_reset) 8925 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 8926 return rc; 8927 } 8928 8929 /** 8930 * _scsih_reprobe_lun - reprobing lun 8931 * @sdev: scsi device struct 8932 * @no_uld_attach: sdev->no_uld_attach flag setting 8933 * 8934 **/ 8935 static void 8936 _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach) 8937 { 8938 sdev->no_uld_attach = no_uld_attach ? 1 : 0; 8939 sdev_printk(KERN_INFO, sdev, "%s raid component\n", 8940 sdev->no_uld_attach ? "hiding" : "exposing"); 8941 WARN_ON(scsi_device_reprobe(sdev)); 8942 } 8943 8944 /** 8945 * _scsih_sas_volume_add - add new volume 8946 * @ioc: per adapter object 8947 * @element: IR config element data 8948 * Context: user. 8949 */ 8950 static void 8951 _scsih_sas_volume_add(struct MPT3SAS_ADAPTER *ioc, 8952 Mpi2EventIrConfigElement_t *element) 8953 { 8954 struct _raid_device *raid_device; 8955 unsigned long flags; 8956 u64 wwid; 8957 u16 handle = le16_to_cpu(element->VolDevHandle); 8958 int rc; 8959 8960 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid); 8961 if (!wwid) { 8962 ioc_err(ioc, "failure at %s:%d/%s()!\n", 8963 __FILE__, __LINE__, __func__); 8964 return; 8965 } 8966 8967 spin_lock_irqsave(&ioc->raid_device_lock, flags); 8968 raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid); 8969 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 8970 8971 if (raid_device) 8972 return; 8973 8974 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL); 8975 if (!raid_device) { 8976 ioc_err(ioc, "failure at %s:%d/%s()!\n", 8977 __FILE__, __LINE__, __func__); 8978 return; 8979 } 8980 8981 raid_device->id = ioc->sas_id++; 8982 raid_device->channel = RAID_CHANNEL; 8983 raid_device->handle = handle; 8984 raid_device->wwid = wwid; 8985 _scsih_raid_device_add(ioc, raid_device); 8986 if (!ioc->wait_for_discovery_to_complete) { 8987 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 8988 raid_device->id, 0); 8989 if (rc) 8990 _scsih_raid_device_remove(ioc, raid_device); 8991 } else { 8992 spin_lock_irqsave(&ioc->raid_device_lock, flags); 8993 _scsih_determine_boot_device(ioc, raid_device, 1); 8994 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 8995 } 8996 } 8997 8998 /** 8999 * _scsih_sas_volume_delete - delete volume 9000 * @ioc: per adapter object 9001 * @handle: volume device handle 9002 * Context: user. 9003 */ 9004 static void 9005 _scsih_sas_volume_delete(struct MPT3SAS_ADAPTER *ioc, u16 handle) 9006 { 9007 struct _raid_device *raid_device; 9008 unsigned long flags; 9009 struct MPT3SAS_TARGET *sas_target_priv_data; 9010 struct scsi_target *starget = NULL; 9011 9012 spin_lock_irqsave(&ioc->raid_device_lock, flags); 9013 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 9014 if (raid_device) { 9015 if (raid_device->starget) { 9016 starget = raid_device->starget; 9017 sas_target_priv_data = starget->hostdata; 9018 sas_target_priv_data->deleted = 1; 9019 } 9020 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n", 9021 raid_device->handle, (u64)raid_device->wwid); 9022 list_del(&raid_device->list); 9023 kfree(raid_device); 9024 } 9025 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 9026 if (starget) 9027 scsi_remove_target(&starget->dev); 9028 } 9029 9030 /** 9031 * _scsih_sas_pd_expose - expose pd component to /dev/sdX 9032 * @ioc: per adapter object 9033 * @element: IR config element data 9034 * Context: user. 9035 */ 9036 static void 9037 _scsih_sas_pd_expose(struct MPT3SAS_ADAPTER *ioc, 9038 Mpi2EventIrConfigElement_t *element) 9039 { 9040 struct _sas_device *sas_device; 9041 struct scsi_target *starget = NULL; 9042 struct MPT3SAS_TARGET *sas_target_priv_data; 9043 unsigned long flags; 9044 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 9045 9046 spin_lock_irqsave(&ioc->sas_device_lock, flags); 9047 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 9048 if (sas_device) { 9049 sas_device->volume_handle = 0; 9050 sas_device->volume_wwid = 0; 9051 clear_bit(handle, ioc->pd_handles); 9052 if (sas_device->starget && sas_device->starget->hostdata) { 9053 starget = sas_device->starget; 9054 sas_target_priv_data = starget->hostdata; 9055 sas_target_priv_data->flags &= 9056 ~MPT_TARGET_FLAGS_RAID_COMPONENT; 9057 } 9058 } 9059 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 9060 if (!sas_device) 9061 return; 9062 9063 /* exposing raid component */ 9064 if (starget) 9065 starget_for_each_device(starget, NULL, _scsih_reprobe_lun); 9066 9067 sas_device_put(sas_device); 9068 } 9069 9070 /** 9071 * _scsih_sas_pd_hide - hide pd component from /dev/sdX 9072 * @ioc: per adapter object 9073 * @element: IR config element data 9074 * Context: user. 9075 */ 9076 static void 9077 _scsih_sas_pd_hide(struct MPT3SAS_ADAPTER *ioc, 9078 Mpi2EventIrConfigElement_t *element) 9079 { 9080 struct _sas_device *sas_device; 9081 struct scsi_target *starget = NULL; 9082 struct MPT3SAS_TARGET *sas_target_priv_data; 9083 unsigned long flags; 9084 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 9085 u16 volume_handle = 0; 9086 u64 volume_wwid = 0; 9087 9088 mpt3sas_config_get_volume_handle(ioc, handle, &volume_handle); 9089 if (volume_handle) 9090 mpt3sas_config_get_volume_wwid(ioc, volume_handle, 9091 &volume_wwid); 9092 9093 spin_lock_irqsave(&ioc->sas_device_lock, flags); 9094 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 9095 if (sas_device) { 9096 set_bit(handle, ioc->pd_handles); 9097 if (sas_device->starget && sas_device->starget->hostdata) { 9098 starget = sas_device->starget; 9099 sas_target_priv_data = starget->hostdata; 9100 sas_target_priv_data->flags |= 9101 MPT_TARGET_FLAGS_RAID_COMPONENT; 9102 sas_device->volume_handle = volume_handle; 9103 sas_device->volume_wwid = volume_wwid; 9104 } 9105 } 9106 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 9107 if (!sas_device) 9108 return; 9109 9110 /* hiding raid component */ 9111 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum); 9112 9113 if (starget) 9114 starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun); 9115 9116 sas_device_put(sas_device); 9117 } 9118 9119 /** 9120 * _scsih_sas_pd_delete - delete pd component 9121 * @ioc: per adapter object 9122 * @element: IR config element data 9123 * Context: user. 9124 */ 9125 static void 9126 _scsih_sas_pd_delete(struct MPT3SAS_ADAPTER *ioc, 9127 Mpi2EventIrConfigElement_t *element) 9128 { 9129 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 9130 9131 _scsih_device_remove_by_handle(ioc, handle); 9132 } 9133 9134 /** 9135 * _scsih_sas_pd_add - remove pd component 9136 * @ioc: per adapter object 9137 * @element: IR config element data 9138 * Context: user. 9139 */ 9140 static void 9141 _scsih_sas_pd_add(struct MPT3SAS_ADAPTER *ioc, 9142 Mpi2EventIrConfigElement_t *element) 9143 { 9144 struct _sas_device *sas_device; 9145 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 9146 Mpi2ConfigReply_t mpi_reply; 9147 Mpi2SasDevicePage0_t sas_device_pg0; 9148 u32 ioc_status; 9149 u64 sas_address; 9150 u16 parent_handle; 9151 9152 set_bit(handle, ioc->pd_handles); 9153 9154 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 9155 if (sas_device) { 9156 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum); 9157 sas_device_put(sas_device); 9158 return; 9159 } 9160 9161 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 9162 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) { 9163 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9164 __FILE__, __LINE__, __func__); 9165 return; 9166 } 9167 9168 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 9169 MPI2_IOCSTATUS_MASK; 9170 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 9171 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9172 __FILE__, __LINE__, __func__); 9173 return; 9174 } 9175 9176 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 9177 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) 9178 mpt3sas_transport_update_links(ioc, sas_address, handle, 9179 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5, 9180 mpt3sas_get_port_by_id(ioc, 9181 sas_device_pg0.PhysicalPort, 0)); 9182 9183 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum); 9184 _scsih_add_device(ioc, handle, 0, 1); 9185 } 9186 9187 /** 9188 * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events 9189 * @ioc: per adapter object 9190 * @event_data: event data payload 9191 * Context: user. 9192 */ 9193 static void 9194 _scsih_sas_ir_config_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 9195 Mpi2EventDataIrConfigChangeList_t *event_data) 9196 { 9197 Mpi2EventIrConfigElement_t *element; 9198 u8 element_type; 9199 int i; 9200 char *reason_str = NULL, *element_str = NULL; 9201 9202 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 9203 9204 ioc_info(ioc, "raid config change: (%s), elements(%d)\n", 9205 le32_to_cpu(event_data->Flags) & MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG ? 9206 "foreign" : "native", 9207 event_data->NumElements); 9208 for (i = 0; i < event_data->NumElements; i++, element++) { 9209 switch (element->ReasonCode) { 9210 case MPI2_EVENT_IR_CHANGE_RC_ADDED: 9211 reason_str = "add"; 9212 break; 9213 case MPI2_EVENT_IR_CHANGE_RC_REMOVED: 9214 reason_str = "remove"; 9215 break; 9216 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE: 9217 reason_str = "no change"; 9218 break; 9219 case MPI2_EVENT_IR_CHANGE_RC_HIDE: 9220 reason_str = "hide"; 9221 break; 9222 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE: 9223 reason_str = "unhide"; 9224 break; 9225 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED: 9226 reason_str = "volume_created"; 9227 break; 9228 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED: 9229 reason_str = "volume_deleted"; 9230 break; 9231 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED: 9232 reason_str = "pd_created"; 9233 break; 9234 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED: 9235 reason_str = "pd_deleted"; 9236 break; 9237 default: 9238 reason_str = "unknown reason"; 9239 break; 9240 } 9241 element_type = le16_to_cpu(element->ElementFlags) & 9242 MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK; 9243 switch (element_type) { 9244 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT: 9245 element_str = "volume"; 9246 break; 9247 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT: 9248 element_str = "phys disk"; 9249 break; 9250 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT: 9251 element_str = "hot spare"; 9252 break; 9253 default: 9254 element_str = "unknown element"; 9255 break; 9256 } 9257 pr_info("\t(%s:%s), vol handle(0x%04x), " \ 9258 "pd handle(0x%04x), pd num(0x%02x)\n", element_str, 9259 reason_str, le16_to_cpu(element->VolDevHandle), 9260 le16_to_cpu(element->PhysDiskDevHandle), 9261 element->PhysDiskNum); 9262 } 9263 } 9264 9265 /** 9266 * _scsih_sas_ir_config_change_event - handle ir configuration change events 9267 * @ioc: per adapter object 9268 * @fw_event: The fw_event_work object 9269 * Context: user. 9270 */ 9271 static void 9272 _scsih_sas_ir_config_change_event(struct MPT3SAS_ADAPTER *ioc, 9273 struct fw_event_work *fw_event) 9274 { 9275 Mpi2EventIrConfigElement_t *element; 9276 int i; 9277 u8 foreign_config; 9278 Mpi2EventDataIrConfigChangeList_t *event_data = 9279 (Mpi2EventDataIrConfigChangeList_t *) 9280 fw_event->event_data; 9281 9282 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) && 9283 (!ioc->hide_ir_msg)) 9284 _scsih_sas_ir_config_change_event_debug(ioc, event_data); 9285 9286 foreign_config = (le32_to_cpu(event_data->Flags) & 9287 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0; 9288 9289 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 9290 if (ioc->shost_recovery && 9291 ioc->hba_mpi_version_belonged != MPI2_VERSION) { 9292 for (i = 0; i < event_data->NumElements; i++, element++) { 9293 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_HIDE) 9294 _scsih_ir_fastpath(ioc, 9295 le16_to_cpu(element->PhysDiskDevHandle), 9296 element->PhysDiskNum); 9297 } 9298 return; 9299 } 9300 9301 for (i = 0; i < event_data->NumElements; i++, element++) { 9302 9303 switch (element->ReasonCode) { 9304 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED: 9305 case MPI2_EVENT_IR_CHANGE_RC_ADDED: 9306 if (!foreign_config) 9307 _scsih_sas_volume_add(ioc, element); 9308 break; 9309 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED: 9310 case MPI2_EVENT_IR_CHANGE_RC_REMOVED: 9311 if (!foreign_config) 9312 _scsih_sas_volume_delete(ioc, 9313 le16_to_cpu(element->VolDevHandle)); 9314 break; 9315 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED: 9316 if (!ioc->is_warpdrive) 9317 _scsih_sas_pd_hide(ioc, element); 9318 break; 9319 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED: 9320 if (!ioc->is_warpdrive) 9321 _scsih_sas_pd_expose(ioc, element); 9322 break; 9323 case MPI2_EVENT_IR_CHANGE_RC_HIDE: 9324 if (!ioc->is_warpdrive) 9325 _scsih_sas_pd_add(ioc, element); 9326 break; 9327 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE: 9328 if (!ioc->is_warpdrive) 9329 _scsih_sas_pd_delete(ioc, element); 9330 break; 9331 } 9332 } 9333 } 9334 9335 /** 9336 * _scsih_sas_ir_volume_event - IR volume event 9337 * @ioc: per adapter object 9338 * @fw_event: The fw_event_work object 9339 * Context: user. 9340 */ 9341 static void 9342 _scsih_sas_ir_volume_event(struct MPT3SAS_ADAPTER *ioc, 9343 struct fw_event_work *fw_event) 9344 { 9345 u64 wwid; 9346 unsigned long flags; 9347 struct _raid_device *raid_device; 9348 u16 handle; 9349 u32 state; 9350 int rc; 9351 Mpi2EventDataIrVolume_t *event_data = 9352 (Mpi2EventDataIrVolume_t *) fw_event->event_data; 9353 9354 if (ioc->shost_recovery) 9355 return; 9356 9357 if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED) 9358 return; 9359 9360 handle = le16_to_cpu(event_data->VolDevHandle); 9361 state = le32_to_cpu(event_data->NewValue); 9362 if (!ioc->hide_ir_msg) 9363 dewtprintk(ioc, 9364 ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n", 9365 __func__, handle, 9366 le32_to_cpu(event_data->PreviousValue), 9367 state)); 9368 switch (state) { 9369 case MPI2_RAID_VOL_STATE_MISSING: 9370 case MPI2_RAID_VOL_STATE_FAILED: 9371 _scsih_sas_volume_delete(ioc, handle); 9372 break; 9373 9374 case MPI2_RAID_VOL_STATE_ONLINE: 9375 case MPI2_RAID_VOL_STATE_DEGRADED: 9376 case MPI2_RAID_VOL_STATE_OPTIMAL: 9377 9378 spin_lock_irqsave(&ioc->raid_device_lock, flags); 9379 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 9380 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 9381 9382 if (raid_device) 9383 break; 9384 9385 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid); 9386 if (!wwid) { 9387 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9388 __FILE__, __LINE__, __func__); 9389 break; 9390 } 9391 9392 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL); 9393 if (!raid_device) { 9394 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9395 __FILE__, __LINE__, __func__); 9396 break; 9397 } 9398 9399 raid_device->id = ioc->sas_id++; 9400 raid_device->channel = RAID_CHANNEL; 9401 raid_device->handle = handle; 9402 raid_device->wwid = wwid; 9403 _scsih_raid_device_add(ioc, raid_device); 9404 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 9405 raid_device->id, 0); 9406 if (rc) 9407 _scsih_raid_device_remove(ioc, raid_device); 9408 break; 9409 9410 case MPI2_RAID_VOL_STATE_INITIALIZING: 9411 default: 9412 break; 9413 } 9414 } 9415 9416 /** 9417 * _scsih_sas_ir_physical_disk_event - PD event 9418 * @ioc: per adapter object 9419 * @fw_event: The fw_event_work object 9420 * Context: user. 9421 */ 9422 static void 9423 _scsih_sas_ir_physical_disk_event(struct MPT3SAS_ADAPTER *ioc, 9424 struct fw_event_work *fw_event) 9425 { 9426 u16 handle, parent_handle; 9427 u32 state; 9428 struct _sas_device *sas_device; 9429 Mpi2ConfigReply_t mpi_reply; 9430 Mpi2SasDevicePage0_t sas_device_pg0; 9431 u32 ioc_status; 9432 Mpi2EventDataIrPhysicalDisk_t *event_data = 9433 (Mpi2EventDataIrPhysicalDisk_t *) fw_event->event_data; 9434 u64 sas_address; 9435 9436 if (ioc->shost_recovery) 9437 return; 9438 9439 if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED) 9440 return; 9441 9442 handle = le16_to_cpu(event_data->PhysDiskDevHandle); 9443 state = le32_to_cpu(event_data->NewValue); 9444 9445 if (!ioc->hide_ir_msg) 9446 dewtprintk(ioc, 9447 ioc_info(ioc, "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n", 9448 __func__, handle, 9449 le32_to_cpu(event_data->PreviousValue), 9450 state)); 9451 9452 switch (state) { 9453 case MPI2_RAID_PD_STATE_ONLINE: 9454 case MPI2_RAID_PD_STATE_DEGRADED: 9455 case MPI2_RAID_PD_STATE_REBUILDING: 9456 case MPI2_RAID_PD_STATE_OPTIMAL: 9457 case MPI2_RAID_PD_STATE_HOT_SPARE: 9458 9459 if (!ioc->is_warpdrive) 9460 set_bit(handle, ioc->pd_handles); 9461 9462 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 9463 if (sas_device) { 9464 sas_device_put(sas_device); 9465 return; 9466 } 9467 9468 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 9469 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, 9470 handle))) { 9471 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9472 __FILE__, __LINE__, __func__); 9473 return; 9474 } 9475 9476 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 9477 MPI2_IOCSTATUS_MASK; 9478 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 9479 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9480 __FILE__, __LINE__, __func__); 9481 return; 9482 } 9483 9484 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 9485 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) 9486 mpt3sas_transport_update_links(ioc, sas_address, handle, 9487 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5, 9488 mpt3sas_get_port_by_id(ioc, 9489 sas_device_pg0.PhysicalPort, 0)); 9490 9491 _scsih_add_device(ioc, handle, 0, 1); 9492 9493 break; 9494 9495 case MPI2_RAID_PD_STATE_OFFLINE: 9496 case MPI2_RAID_PD_STATE_NOT_CONFIGURED: 9497 case MPI2_RAID_PD_STATE_NOT_COMPATIBLE: 9498 default: 9499 break; 9500 } 9501 } 9502 9503 /** 9504 * _scsih_sas_ir_operation_status_event_debug - debug for IR op event 9505 * @ioc: per adapter object 9506 * @event_data: event data payload 9507 * Context: user. 9508 */ 9509 static void 9510 _scsih_sas_ir_operation_status_event_debug(struct MPT3SAS_ADAPTER *ioc, 9511 Mpi2EventDataIrOperationStatus_t *event_data) 9512 { 9513 char *reason_str = NULL; 9514 9515 switch (event_data->RAIDOperation) { 9516 case MPI2_EVENT_IR_RAIDOP_RESYNC: 9517 reason_str = "resync"; 9518 break; 9519 case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION: 9520 reason_str = "online capacity expansion"; 9521 break; 9522 case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK: 9523 reason_str = "consistency check"; 9524 break; 9525 case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT: 9526 reason_str = "background init"; 9527 break; 9528 case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT: 9529 reason_str = "make data consistent"; 9530 break; 9531 } 9532 9533 if (!reason_str) 9534 return; 9535 9536 ioc_info(ioc, "raid operational status: (%s)\thandle(0x%04x), percent complete(%d)\n", 9537 reason_str, 9538 le16_to_cpu(event_data->VolDevHandle), 9539 event_data->PercentComplete); 9540 } 9541 9542 /** 9543 * _scsih_sas_ir_operation_status_event - handle RAID operation events 9544 * @ioc: per adapter object 9545 * @fw_event: The fw_event_work object 9546 * Context: user. 9547 */ 9548 static void 9549 _scsih_sas_ir_operation_status_event(struct MPT3SAS_ADAPTER *ioc, 9550 struct fw_event_work *fw_event) 9551 { 9552 Mpi2EventDataIrOperationStatus_t *event_data = 9553 (Mpi2EventDataIrOperationStatus_t *) 9554 fw_event->event_data; 9555 static struct _raid_device *raid_device; 9556 unsigned long flags; 9557 u16 handle; 9558 9559 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) && 9560 (!ioc->hide_ir_msg)) 9561 _scsih_sas_ir_operation_status_event_debug(ioc, 9562 event_data); 9563 9564 /* code added for raid transport support */ 9565 if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) { 9566 9567 spin_lock_irqsave(&ioc->raid_device_lock, flags); 9568 handle = le16_to_cpu(event_data->VolDevHandle); 9569 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 9570 if (raid_device) 9571 raid_device->percent_complete = 9572 event_data->PercentComplete; 9573 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 9574 } 9575 } 9576 9577 /** 9578 * _scsih_prep_device_scan - initialize parameters prior to device scan 9579 * @ioc: per adapter object 9580 * 9581 * Set the deleted flag prior to device scan. If the device is found during 9582 * the scan, then we clear the deleted flag. 9583 */ 9584 static void 9585 _scsih_prep_device_scan(struct MPT3SAS_ADAPTER *ioc) 9586 { 9587 struct MPT3SAS_DEVICE *sas_device_priv_data; 9588 struct scsi_device *sdev; 9589 9590 shost_for_each_device(sdev, ioc->shost) { 9591 sas_device_priv_data = sdev->hostdata; 9592 if (sas_device_priv_data && sas_device_priv_data->sas_target) 9593 sas_device_priv_data->sas_target->deleted = 1; 9594 } 9595 } 9596 9597 /** 9598 * _scsih_update_device_qdepth - Update QD during Reset. 9599 * @ioc: per adapter object 9600 * 9601 */ 9602 static void 9603 _scsih_update_device_qdepth(struct MPT3SAS_ADAPTER *ioc) 9604 { 9605 struct MPT3SAS_DEVICE *sas_device_priv_data; 9606 struct MPT3SAS_TARGET *sas_target_priv_data; 9607 struct _sas_device *sas_device; 9608 struct scsi_device *sdev; 9609 u16 qdepth; 9610 9611 ioc_info(ioc, "Update devices with firmware reported queue depth\n"); 9612 shost_for_each_device(sdev, ioc->shost) { 9613 sas_device_priv_data = sdev->hostdata; 9614 if (sas_device_priv_data && sas_device_priv_data->sas_target) { 9615 sas_target_priv_data = sas_device_priv_data->sas_target; 9616 sas_device = sas_device_priv_data->sas_target->sas_dev; 9617 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_PCIE_DEVICE) 9618 qdepth = ioc->max_nvme_qd; 9619 else if (sas_device && 9620 sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) 9621 qdepth = (sas_device->port_type > 1) ? 9622 ioc->max_wideport_qd : ioc->max_narrowport_qd; 9623 else if (sas_device && 9624 sas_device->device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE) 9625 qdepth = ioc->max_sata_qd; 9626 else 9627 continue; 9628 mpt3sas_scsih_change_queue_depth(sdev, qdepth); 9629 } 9630 } 9631 } 9632 9633 /** 9634 * _scsih_mark_responding_sas_device - mark a sas_devices as responding 9635 * @ioc: per adapter object 9636 * @sas_device_pg0: SAS Device page 0 9637 * 9638 * After host reset, find out whether devices are still responding. 9639 * Used in _scsih_remove_unresponsive_sas_devices. 9640 */ 9641 static void 9642 _scsih_mark_responding_sas_device(struct MPT3SAS_ADAPTER *ioc, 9643 Mpi2SasDevicePage0_t *sas_device_pg0) 9644 { 9645 struct MPT3SAS_TARGET *sas_target_priv_data = NULL; 9646 struct scsi_target *starget; 9647 struct _sas_device *sas_device = NULL; 9648 struct _enclosure_node *enclosure_dev = NULL; 9649 unsigned long flags; 9650 struct hba_port *port = mpt3sas_get_port_by_id( 9651 ioc, sas_device_pg0->PhysicalPort, 0); 9652 9653 if (sas_device_pg0->EnclosureHandle) { 9654 enclosure_dev = 9655 mpt3sas_scsih_enclosure_find_by_handle(ioc, 9656 le16_to_cpu(sas_device_pg0->EnclosureHandle)); 9657 if (enclosure_dev == NULL) 9658 ioc_info(ioc, "Enclosure handle(0x%04x) doesn't match with enclosure device!\n", 9659 sas_device_pg0->EnclosureHandle); 9660 } 9661 spin_lock_irqsave(&ioc->sas_device_lock, flags); 9662 list_for_each_entry(sas_device, &ioc->sas_device_list, list) { 9663 if (sas_device->sas_address != le64_to_cpu( 9664 sas_device_pg0->SASAddress)) 9665 continue; 9666 if (sas_device->slot != le16_to_cpu(sas_device_pg0->Slot)) 9667 continue; 9668 if (sas_device->port != port) 9669 continue; 9670 sas_device->responding = 1; 9671 starget = sas_device->starget; 9672 if (starget && starget->hostdata) { 9673 sas_target_priv_data = starget->hostdata; 9674 sas_target_priv_data->tm_busy = 0; 9675 sas_target_priv_data->deleted = 0; 9676 } else 9677 sas_target_priv_data = NULL; 9678 if (starget) { 9679 starget_printk(KERN_INFO, starget, 9680 "handle(0x%04x), sas_addr(0x%016llx)\n", 9681 le16_to_cpu(sas_device_pg0->DevHandle), 9682 (unsigned long long) 9683 sas_device->sas_address); 9684 9685 if (sas_device->enclosure_handle != 0) 9686 starget_printk(KERN_INFO, starget, 9687 "enclosure logical id(0x%016llx), slot(%d)\n", 9688 (unsigned long long) 9689 sas_device->enclosure_logical_id, 9690 sas_device->slot); 9691 } 9692 if (le16_to_cpu(sas_device_pg0->Flags) & 9693 MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) { 9694 sas_device->enclosure_level = 9695 sas_device_pg0->EnclosureLevel; 9696 memcpy(&sas_device->connector_name[0], 9697 &sas_device_pg0->ConnectorName[0], 4); 9698 } else { 9699 sas_device->enclosure_level = 0; 9700 sas_device->connector_name[0] = '\0'; 9701 } 9702 9703 sas_device->enclosure_handle = 9704 le16_to_cpu(sas_device_pg0->EnclosureHandle); 9705 sas_device->is_chassis_slot_valid = 0; 9706 if (enclosure_dev) { 9707 sas_device->enclosure_logical_id = le64_to_cpu( 9708 enclosure_dev->pg0.EnclosureLogicalID); 9709 if (le16_to_cpu(enclosure_dev->pg0.Flags) & 9710 MPI2_SAS_ENCLS0_FLAGS_CHASSIS_SLOT_VALID) { 9711 sas_device->is_chassis_slot_valid = 1; 9712 sas_device->chassis_slot = 9713 enclosure_dev->pg0.ChassisSlot; 9714 } 9715 } 9716 9717 if (sas_device->handle == le16_to_cpu( 9718 sas_device_pg0->DevHandle)) 9719 goto out; 9720 pr_info("\thandle changed from(0x%04x)!!!\n", 9721 sas_device->handle); 9722 sas_device->handle = le16_to_cpu( 9723 sas_device_pg0->DevHandle); 9724 if (sas_target_priv_data) 9725 sas_target_priv_data->handle = 9726 le16_to_cpu(sas_device_pg0->DevHandle); 9727 goto out; 9728 } 9729 out: 9730 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 9731 } 9732 9733 /** 9734 * _scsih_create_enclosure_list_after_reset - Free Existing list, 9735 * And create enclosure list by scanning all Enclosure Page(0)s 9736 * @ioc: per adapter object 9737 */ 9738 static void 9739 _scsih_create_enclosure_list_after_reset(struct MPT3SAS_ADAPTER *ioc) 9740 { 9741 struct _enclosure_node *enclosure_dev; 9742 Mpi2ConfigReply_t mpi_reply; 9743 u16 enclosure_handle; 9744 int rc; 9745 9746 /* Free existing enclosure list */ 9747 mpt3sas_free_enclosure_list(ioc); 9748 9749 /* Re constructing enclosure list after reset*/ 9750 enclosure_handle = 0xFFFF; 9751 do { 9752 enclosure_dev = 9753 kzalloc(sizeof(struct _enclosure_node), GFP_KERNEL); 9754 if (!enclosure_dev) { 9755 ioc_err(ioc, "failure at %s:%d/%s()!\n", 9756 __FILE__, __LINE__, __func__); 9757 return; 9758 } 9759 rc = mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply, 9760 &enclosure_dev->pg0, 9761 MPI2_SAS_ENCLOS_PGAD_FORM_GET_NEXT_HANDLE, 9762 enclosure_handle); 9763 9764 if (rc || (le16_to_cpu(mpi_reply.IOCStatus) & 9765 MPI2_IOCSTATUS_MASK)) { 9766 kfree(enclosure_dev); 9767 return; 9768 } 9769 list_add_tail(&enclosure_dev->list, 9770 &ioc->enclosure_list); 9771 enclosure_handle = 9772 le16_to_cpu(enclosure_dev->pg0.EnclosureHandle); 9773 } while (1); 9774 } 9775 9776 /** 9777 * _scsih_search_responding_sas_devices - 9778 * @ioc: per adapter object 9779 * 9780 * After host reset, find out whether devices are still responding. 9781 * If not remove. 9782 */ 9783 static void 9784 _scsih_search_responding_sas_devices(struct MPT3SAS_ADAPTER *ioc) 9785 { 9786 Mpi2SasDevicePage0_t sas_device_pg0; 9787 Mpi2ConfigReply_t mpi_reply; 9788 u16 ioc_status; 9789 u16 handle; 9790 u32 device_info; 9791 9792 ioc_info(ioc, "search for end-devices: start\n"); 9793 9794 if (list_empty(&ioc->sas_device_list)) 9795 goto out; 9796 9797 handle = 0xFFFF; 9798 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 9799 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, 9800 handle))) { 9801 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 9802 MPI2_IOCSTATUS_MASK; 9803 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 9804 break; 9805 handle = le16_to_cpu(sas_device_pg0.DevHandle); 9806 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 9807 if (!(_scsih_is_end_device(device_info))) 9808 continue; 9809 _scsih_mark_responding_sas_device(ioc, &sas_device_pg0); 9810 } 9811 9812 out: 9813 ioc_info(ioc, "search for end-devices: complete\n"); 9814 } 9815 9816 /** 9817 * _scsih_mark_responding_pcie_device - mark a pcie_device as responding 9818 * @ioc: per adapter object 9819 * @pcie_device_pg0: PCIe Device page 0 9820 * 9821 * After host reset, find out whether devices are still responding. 9822 * Used in _scsih_remove_unresponding_devices. 9823 */ 9824 static void 9825 _scsih_mark_responding_pcie_device(struct MPT3SAS_ADAPTER *ioc, 9826 Mpi26PCIeDevicePage0_t *pcie_device_pg0) 9827 { 9828 struct MPT3SAS_TARGET *sas_target_priv_data = NULL; 9829 struct scsi_target *starget; 9830 struct _pcie_device *pcie_device; 9831 unsigned long flags; 9832 9833 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 9834 list_for_each_entry(pcie_device, &ioc->pcie_device_list, list) { 9835 if ((pcie_device->wwid == le64_to_cpu(pcie_device_pg0->WWID)) 9836 && (pcie_device->slot == le16_to_cpu( 9837 pcie_device_pg0->Slot))) { 9838 pcie_device->access_status = 9839 pcie_device_pg0->AccessStatus; 9840 pcie_device->responding = 1; 9841 starget = pcie_device->starget; 9842 if (starget && starget->hostdata) { 9843 sas_target_priv_data = starget->hostdata; 9844 sas_target_priv_data->tm_busy = 0; 9845 sas_target_priv_data->deleted = 0; 9846 } else 9847 sas_target_priv_data = NULL; 9848 if (starget) { 9849 starget_printk(KERN_INFO, starget, 9850 "handle(0x%04x), wwid(0x%016llx) ", 9851 pcie_device->handle, 9852 (unsigned long long)pcie_device->wwid); 9853 if (pcie_device->enclosure_handle != 0) 9854 starget_printk(KERN_INFO, starget, 9855 "enclosure logical id(0x%016llx), " 9856 "slot(%d)\n", 9857 (unsigned long long) 9858 pcie_device->enclosure_logical_id, 9859 pcie_device->slot); 9860 } 9861 9862 if (((le32_to_cpu(pcie_device_pg0->Flags)) & 9863 MPI26_PCIEDEV0_FLAGS_ENCL_LEVEL_VALID) && 9864 (ioc->hba_mpi_version_belonged != MPI2_VERSION)) { 9865 pcie_device->enclosure_level = 9866 pcie_device_pg0->EnclosureLevel; 9867 memcpy(&pcie_device->connector_name[0], 9868 &pcie_device_pg0->ConnectorName[0], 4); 9869 } else { 9870 pcie_device->enclosure_level = 0; 9871 pcie_device->connector_name[0] = '\0'; 9872 } 9873 9874 if (pcie_device->handle == le16_to_cpu( 9875 pcie_device_pg0->DevHandle)) 9876 goto out; 9877 pr_info("\thandle changed from(0x%04x)!!!\n", 9878 pcie_device->handle); 9879 pcie_device->handle = le16_to_cpu( 9880 pcie_device_pg0->DevHandle); 9881 if (sas_target_priv_data) 9882 sas_target_priv_data->handle = 9883 le16_to_cpu(pcie_device_pg0->DevHandle); 9884 goto out; 9885 } 9886 } 9887 9888 out: 9889 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 9890 } 9891 9892 /** 9893 * _scsih_search_responding_pcie_devices - 9894 * @ioc: per adapter object 9895 * 9896 * After host reset, find out whether devices are still responding. 9897 * If not remove. 9898 */ 9899 static void 9900 _scsih_search_responding_pcie_devices(struct MPT3SAS_ADAPTER *ioc) 9901 { 9902 Mpi26PCIeDevicePage0_t pcie_device_pg0; 9903 Mpi2ConfigReply_t mpi_reply; 9904 u16 ioc_status; 9905 u16 handle; 9906 u32 device_info; 9907 9908 ioc_info(ioc, "search for end-devices: start\n"); 9909 9910 if (list_empty(&ioc->pcie_device_list)) 9911 goto out; 9912 9913 handle = 0xFFFF; 9914 while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply, 9915 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, 9916 handle))) { 9917 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 9918 MPI2_IOCSTATUS_MASK; 9919 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 9920 ioc_info(ioc, "\tbreak from %s: ioc_status(0x%04x), loginfo(0x%08x)\n", 9921 __func__, ioc_status, 9922 le32_to_cpu(mpi_reply.IOCLogInfo)); 9923 break; 9924 } 9925 handle = le16_to_cpu(pcie_device_pg0.DevHandle); 9926 device_info = le32_to_cpu(pcie_device_pg0.DeviceInfo); 9927 if (!(_scsih_is_nvme_pciescsi_device(device_info))) 9928 continue; 9929 _scsih_mark_responding_pcie_device(ioc, &pcie_device_pg0); 9930 } 9931 out: 9932 ioc_info(ioc, "search for PCIe end-devices: complete\n"); 9933 } 9934 9935 /** 9936 * _scsih_mark_responding_raid_device - mark a raid_device as responding 9937 * @ioc: per adapter object 9938 * @wwid: world wide identifier for raid volume 9939 * @handle: device handle 9940 * 9941 * After host reset, find out whether devices are still responding. 9942 * Used in _scsih_remove_unresponsive_raid_devices. 9943 */ 9944 static void 9945 _scsih_mark_responding_raid_device(struct MPT3SAS_ADAPTER *ioc, u64 wwid, 9946 u16 handle) 9947 { 9948 struct MPT3SAS_TARGET *sas_target_priv_data = NULL; 9949 struct scsi_target *starget; 9950 struct _raid_device *raid_device; 9951 unsigned long flags; 9952 9953 spin_lock_irqsave(&ioc->raid_device_lock, flags); 9954 list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 9955 if (raid_device->wwid == wwid && raid_device->starget) { 9956 starget = raid_device->starget; 9957 if (starget && starget->hostdata) { 9958 sas_target_priv_data = starget->hostdata; 9959 sas_target_priv_data->deleted = 0; 9960 } else 9961 sas_target_priv_data = NULL; 9962 raid_device->responding = 1; 9963 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 9964 starget_printk(KERN_INFO, raid_device->starget, 9965 "handle(0x%04x), wwid(0x%016llx)\n", handle, 9966 (unsigned long long)raid_device->wwid); 9967 9968 /* 9969 * WARPDRIVE: The handles of the PDs might have changed 9970 * across the host reset so re-initialize the 9971 * required data for Direct IO 9972 */ 9973 mpt3sas_init_warpdrive_properties(ioc, raid_device); 9974 spin_lock_irqsave(&ioc->raid_device_lock, flags); 9975 if (raid_device->handle == handle) { 9976 spin_unlock_irqrestore(&ioc->raid_device_lock, 9977 flags); 9978 return; 9979 } 9980 pr_info("\thandle changed from(0x%04x)!!!\n", 9981 raid_device->handle); 9982 raid_device->handle = handle; 9983 if (sas_target_priv_data) 9984 sas_target_priv_data->handle = handle; 9985 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 9986 return; 9987 } 9988 } 9989 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 9990 } 9991 9992 /** 9993 * _scsih_search_responding_raid_devices - 9994 * @ioc: per adapter object 9995 * 9996 * After host reset, find out whether devices are still responding. 9997 * If not remove. 9998 */ 9999 static void 10000 _scsih_search_responding_raid_devices(struct MPT3SAS_ADAPTER *ioc) 10001 { 10002 Mpi2RaidVolPage1_t volume_pg1; 10003 Mpi2RaidVolPage0_t volume_pg0; 10004 Mpi2RaidPhysDiskPage0_t pd_pg0; 10005 Mpi2ConfigReply_t mpi_reply; 10006 u16 ioc_status; 10007 u16 handle; 10008 u8 phys_disk_num; 10009 10010 if (!ioc->ir_firmware) 10011 return; 10012 10013 ioc_info(ioc, "search for raid volumes: start\n"); 10014 10015 if (list_empty(&ioc->raid_device_list)) 10016 goto out; 10017 10018 handle = 0xFFFF; 10019 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply, 10020 &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) { 10021 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10022 MPI2_IOCSTATUS_MASK; 10023 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 10024 break; 10025 handle = le16_to_cpu(volume_pg1.DevHandle); 10026 10027 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, 10028 &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle, 10029 sizeof(Mpi2RaidVolPage0_t))) 10030 continue; 10031 10032 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL || 10033 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE || 10034 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) 10035 _scsih_mark_responding_raid_device(ioc, 10036 le64_to_cpu(volume_pg1.WWID), handle); 10037 } 10038 10039 /* refresh the pd_handles */ 10040 if (!ioc->is_warpdrive) { 10041 phys_disk_num = 0xFF; 10042 memset(ioc->pd_handles, 0, ioc->pd_handles_sz); 10043 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply, 10044 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM, 10045 phys_disk_num))) { 10046 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10047 MPI2_IOCSTATUS_MASK; 10048 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 10049 break; 10050 phys_disk_num = pd_pg0.PhysDiskNum; 10051 handle = le16_to_cpu(pd_pg0.DevHandle); 10052 set_bit(handle, ioc->pd_handles); 10053 } 10054 } 10055 out: 10056 ioc_info(ioc, "search for responding raid volumes: complete\n"); 10057 } 10058 10059 /** 10060 * _scsih_mark_responding_expander - mark a expander as responding 10061 * @ioc: per adapter object 10062 * @expander_pg0:SAS Expander Config Page0 10063 * 10064 * After host reset, find out whether devices are still responding. 10065 * Used in _scsih_remove_unresponsive_expanders. 10066 */ 10067 static void 10068 _scsih_mark_responding_expander(struct MPT3SAS_ADAPTER *ioc, 10069 Mpi2ExpanderPage0_t *expander_pg0) 10070 { 10071 struct _sas_node *sas_expander = NULL; 10072 unsigned long flags; 10073 int i; 10074 struct _enclosure_node *enclosure_dev = NULL; 10075 u16 handle = le16_to_cpu(expander_pg0->DevHandle); 10076 u16 enclosure_handle = le16_to_cpu(expander_pg0->EnclosureHandle); 10077 u64 sas_address = le64_to_cpu(expander_pg0->SASAddress); 10078 struct hba_port *port = mpt3sas_get_port_by_id( 10079 ioc, expander_pg0->PhysicalPort, 0); 10080 10081 if (enclosure_handle) 10082 enclosure_dev = 10083 mpt3sas_scsih_enclosure_find_by_handle(ioc, 10084 enclosure_handle); 10085 10086 spin_lock_irqsave(&ioc->sas_node_lock, flags); 10087 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) { 10088 if (sas_expander->sas_address != sas_address) 10089 continue; 10090 if (sas_expander->port != port) 10091 continue; 10092 sas_expander->responding = 1; 10093 10094 if (enclosure_dev) { 10095 sas_expander->enclosure_logical_id = 10096 le64_to_cpu(enclosure_dev->pg0.EnclosureLogicalID); 10097 sas_expander->enclosure_handle = 10098 le16_to_cpu(expander_pg0->EnclosureHandle); 10099 } 10100 10101 if (sas_expander->handle == handle) 10102 goto out; 10103 pr_info("\texpander(0x%016llx): handle changed" \ 10104 " from(0x%04x) to (0x%04x)!!!\n", 10105 (unsigned long long)sas_expander->sas_address, 10106 sas_expander->handle, handle); 10107 sas_expander->handle = handle; 10108 for (i = 0 ; i < sas_expander->num_phys ; i++) 10109 sas_expander->phy[i].handle = handle; 10110 goto out; 10111 } 10112 out: 10113 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 10114 } 10115 10116 /** 10117 * _scsih_search_responding_expanders - 10118 * @ioc: per adapter object 10119 * 10120 * After host reset, find out whether devices are still responding. 10121 * If not remove. 10122 */ 10123 static void 10124 _scsih_search_responding_expanders(struct MPT3SAS_ADAPTER *ioc) 10125 { 10126 Mpi2ExpanderPage0_t expander_pg0; 10127 Mpi2ConfigReply_t mpi_reply; 10128 u16 ioc_status; 10129 u64 sas_address; 10130 u16 handle; 10131 u8 port; 10132 10133 ioc_info(ioc, "search for expanders: start\n"); 10134 10135 if (list_empty(&ioc->sas_expander_list)) 10136 goto out; 10137 10138 handle = 0xFFFF; 10139 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0, 10140 MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) { 10141 10142 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10143 MPI2_IOCSTATUS_MASK; 10144 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 10145 break; 10146 10147 handle = le16_to_cpu(expander_pg0.DevHandle); 10148 sas_address = le64_to_cpu(expander_pg0.SASAddress); 10149 port = expander_pg0.PhysicalPort; 10150 pr_info( 10151 "\texpander present: handle(0x%04x), sas_addr(0x%016llx), port:%d\n", 10152 handle, (unsigned long long)sas_address, 10153 (ioc->multipath_on_hba ? 10154 port : MULTIPATH_DISABLED_PORT_ID)); 10155 _scsih_mark_responding_expander(ioc, &expander_pg0); 10156 } 10157 10158 out: 10159 ioc_info(ioc, "search for expanders: complete\n"); 10160 } 10161 10162 /** 10163 * _scsih_remove_unresponding_devices - removing unresponding devices 10164 * @ioc: per adapter object 10165 */ 10166 static void 10167 _scsih_remove_unresponding_devices(struct MPT3SAS_ADAPTER *ioc) 10168 { 10169 struct _sas_device *sas_device, *sas_device_next; 10170 struct _sas_node *sas_expander, *sas_expander_next; 10171 struct _raid_device *raid_device, *raid_device_next; 10172 struct _pcie_device *pcie_device, *pcie_device_next; 10173 struct list_head tmp_list; 10174 unsigned long flags; 10175 LIST_HEAD(head); 10176 10177 ioc_info(ioc, "removing unresponding devices: start\n"); 10178 10179 /* removing unresponding end devices */ 10180 ioc_info(ioc, "removing unresponding devices: end-devices\n"); 10181 /* 10182 * Iterate, pulling off devices marked as non-responding. We become the 10183 * owner for the reference the list had on any object we prune. 10184 */ 10185 spin_lock_irqsave(&ioc->sas_device_lock, flags); 10186 10187 /* 10188 * Clean up the sas_device_init_list list as 10189 * driver goes for fresh scan as part of diag reset. 10190 */ 10191 list_for_each_entry_safe(sas_device, sas_device_next, 10192 &ioc->sas_device_init_list, list) { 10193 list_del_init(&sas_device->list); 10194 sas_device_put(sas_device); 10195 } 10196 10197 list_for_each_entry_safe(sas_device, sas_device_next, 10198 &ioc->sas_device_list, list) { 10199 if (!sas_device->responding) 10200 list_move_tail(&sas_device->list, &head); 10201 else 10202 sas_device->responding = 0; 10203 } 10204 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 10205 10206 /* 10207 * Now, uninitialize and remove the unresponding devices we pruned. 10208 */ 10209 list_for_each_entry_safe(sas_device, sas_device_next, &head, list) { 10210 _scsih_remove_device(ioc, sas_device); 10211 list_del_init(&sas_device->list); 10212 sas_device_put(sas_device); 10213 } 10214 10215 ioc_info(ioc, "Removing unresponding devices: pcie end-devices\n"); 10216 INIT_LIST_HEAD(&head); 10217 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 10218 /* 10219 * Clean up the pcie_device_init_list list as 10220 * driver goes for fresh scan as part of diag reset. 10221 */ 10222 list_for_each_entry_safe(pcie_device, pcie_device_next, 10223 &ioc->pcie_device_init_list, list) { 10224 list_del_init(&pcie_device->list); 10225 pcie_device_put(pcie_device); 10226 } 10227 10228 list_for_each_entry_safe(pcie_device, pcie_device_next, 10229 &ioc->pcie_device_list, list) { 10230 if (!pcie_device->responding) 10231 list_move_tail(&pcie_device->list, &head); 10232 else 10233 pcie_device->responding = 0; 10234 } 10235 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 10236 10237 list_for_each_entry_safe(pcie_device, pcie_device_next, &head, list) { 10238 _scsih_pcie_device_remove_from_sml(ioc, pcie_device); 10239 list_del_init(&pcie_device->list); 10240 pcie_device_put(pcie_device); 10241 } 10242 10243 /* removing unresponding volumes */ 10244 if (ioc->ir_firmware) { 10245 ioc_info(ioc, "removing unresponding devices: volumes\n"); 10246 list_for_each_entry_safe(raid_device, raid_device_next, 10247 &ioc->raid_device_list, list) { 10248 if (!raid_device->responding) 10249 _scsih_sas_volume_delete(ioc, 10250 raid_device->handle); 10251 else 10252 raid_device->responding = 0; 10253 } 10254 } 10255 10256 /* removing unresponding expanders */ 10257 ioc_info(ioc, "removing unresponding devices: expanders\n"); 10258 spin_lock_irqsave(&ioc->sas_node_lock, flags); 10259 INIT_LIST_HEAD(&tmp_list); 10260 list_for_each_entry_safe(sas_expander, sas_expander_next, 10261 &ioc->sas_expander_list, list) { 10262 if (!sas_expander->responding) 10263 list_move_tail(&sas_expander->list, &tmp_list); 10264 else 10265 sas_expander->responding = 0; 10266 } 10267 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 10268 list_for_each_entry_safe(sas_expander, sas_expander_next, &tmp_list, 10269 list) { 10270 _scsih_expander_node_remove(ioc, sas_expander); 10271 } 10272 10273 ioc_info(ioc, "removing unresponding devices: complete\n"); 10274 10275 /* unblock devices */ 10276 _scsih_ublock_io_all_device(ioc); 10277 } 10278 10279 static void 10280 _scsih_refresh_expander_links(struct MPT3SAS_ADAPTER *ioc, 10281 struct _sas_node *sas_expander, u16 handle) 10282 { 10283 Mpi2ExpanderPage1_t expander_pg1; 10284 Mpi2ConfigReply_t mpi_reply; 10285 int i; 10286 10287 for (i = 0 ; i < sas_expander->num_phys ; i++) { 10288 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply, 10289 &expander_pg1, i, handle))) { 10290 ioc_err(ioc, "failure at %s:%d/%s()!\n", 10291 __FILE__, __LINE__, __func__); 10292 return; 10293 } 10294 10295 mpt3sas_transport_update_links(ioc, sas_expander->sas_address, 10296 le16_to_cpu(expander_pg1.AttachedDevHandle), i, 10297 expander_pg1.NegotiatedLinkRate >> 4, 10298 sas_expander->port); 10299 } 10300 } 10301 10302 /** 10303 * _scsih_scan_for_devices_after_reset - scan for devices after host reset 10304 * @ioc: per adapter object 10305 */ 10306 static void 10307 _scsih_scan_for_devices_after_reset(struct MPT3SAS_ADAPTER *ioc) 10308 { 10309 Mpi2ExpanderPage0_t expander_pg0; 10310 Mpi2SasDevicePage0_t sas_device_pg0; 10311 Mpi26PCIeDevicePage0_t pcie_device_pg0; 10312 Mpi2RaidVolPage1_t *volume_pg1; 10313 Mpi2RaidVolPage0_t *volume_pg0; 10314 Mpi2RaidPhysDiskPage0_t pd_pg0; 10315 Mpi2EventIrConfigElement_t element; 10316 Mpi2ConfigReply_t mpi_reply; 10317 u8 phys_disk_num, port_id; 10318 u16 ioc_status; 10319 u16 handle, parent_handle; 10320 u64 sas_address; 10321 struct _sas_device *sas_device; 10322 struct _pcie_device *pcie_device; 10323 struct _sas_node *expander_device; 10324 static struct _raid_device *raid_device; 10325 u8 retry_count; 10326 unsigned long flags; 10327 10328 volume_pg0 = kzalloc(sizeof(*volume_pg0), GFP_KERNEL); 10329 if (!volume_pg0) 10330 return; 10331 10332 volume_pg1 = kzalloc(sizeof(*volume_pg1), GFP_KERNEL); 10333 if (!volume_pg1) { 10334 kfree(volume_pg0); 10335 return; 10336 } 10337 10338 ioc_info(ioc, "scan devices: start\n"); 10339 10340 _scsih_sas_host_refresh(ioc); 10341 10342 ioc_info(ioc, "\tscan devices: expanders start\n"); 10343 10344 /* expanders */ 10345 handle = 0xFFFF; 10346 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0, 10347 MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) { 10348 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10349 MPI2_IOCSTATUS_MASK; 10350 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10351 ioc_info(ioc, "\tbreak from expander scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10352 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10353 break; 10354 } 10355 handle = le16_to_cpu(expander_pg0.DevHandle); 10356 spin_lock_irqsave(&ioc->sas_node_lock, flags); 10357 port_id = expander_pg0.PhysicalPort; 10358 expander_device = mpt3sas_scsih_expander_find_by_sas_address( 10359 ioc, le64_to_cpu(expander_pg0.SASAddress), 10360 mpt3sas_get_port_by_id(ioc, port_id, 0)); 10361 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 10362 if (expander_device) 10363 _scsih_refresh_expander_links(ioc, expander_device, 10364 handle); 10365 else { 10366 ioc_info(ioc, "\tBEFORE adding expander: handle (0x%04x), sas_addr(0x%016llx)\n", 10367 handle, 10368 (u64)le64_to_cpu(expander_pg0.SASAddress)); 10369 _scsih_expander_add(ioc, handle); 10370 ioc_info(ioc, "\tAFTER adding expander: handle (0x%04x), sas_addr(0x%016llx)\n", 10371 handle, 10372 (u64)le64_to_cpu(expander_pg0.SASAddress)); 10373 } 10374 } 10375 10376 ioc_info(ioc, "\tscan devices: expanders complete\n"); 10377 10378 if (!ioc->ir_firmware) 10379 goto skip_to_sas; 10380 10381 ioc_info(ioc, "\tscan devices: phys disk start\n"); 10382 10383 /* phys disk */ 10384 phys_disk_num = 0xFF; 10385 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply, 10386 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM, 10387 phys_disk_num))) { 10388 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10389 MPI2_IOCSTATUS_MASK; 10390 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10391 ioc_info(ioc, "\tbreak from phys disk scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10392 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10393 break; 10394 } 10395 phys_disk_num = pd_pg0.PhysDiskNum; 10396 handle = le16_to_cpu(pd_pg0.DevHandle); 10397 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 10398 if (sas_device) { 10399 sas_device_put(sas_device); 10400 continue; 10401 } 10402 if (mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 10403 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, 10404 handle) != 0) 10405 continue; 10406 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10407 MPI2_IOCSTATUS_MASK; 10408 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10409 ioc_info(ioc, "\tbreak from phys disk scan ioc_status(0x%04x), loginfo(0x%08x)\n", 10410 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10411 break; 10412 } 10413 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 10414 if (!_scsih_get_sas_address(ioc, parent_handle, 10415 &sas_address)) { 10416 ioc_info(ioc, "\tBEFORE adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n", 10417 handle, 10418 (u64)le64_to_cpu(sas_device_pg0.SASAddress)); 10419 port_id = sas_device_pg0.PhysicalPort; 10420 mpt3sas_transport_update_links(ioc, sas_address, 10421 handle, sas_device_pg0.PhyNum, 10422 MPI2_SAS_NEG_LINK_RATE_1_5, 10423 mpt3sas_get_port_by_id(ioc, port_id, 0)); 10424 set_bit(handle, ioc->pd_handles); 10425 retry_count = 0; 10426 /* This will retry adding the end device. 10427 * _scsih_add_device() will decide on retries and 10428 * return "1" when it should be retried 10429 */ 10430 while (_scsih_add_device(ioc, handle, retry_count++, 10431 1)) { 10432 ssleep(1); 10433 } 10434 ioc_info(ioc, "\tAFTER adding phys disk: handle (0x%04x), sas_addr(0x%016llx)\n", 10435 handle, 10436 (u64)le64_to_cpu(sas_device_pg0.SASAddress)); 10437 } 10438 } 10439 10440 ioc_info(ioc, "\tscan devices: phys disk complete\n"); 10441 10442 ioc_info(ioc, "\tscan devices: volumes start\n"); 10443 10444 /* volumes */ 10445 handle = 0xFFFF; 10446 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply, 10447 volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) { 10448 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10449 MPI2_IOCSTATUS_MASK; 10450 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10451 ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10452 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10453 break; 10454 } 10455 handle = le16_to_cpu(volume_pg1->DevHandle); 10456 spin_lock_irqsave(&ioc->raid_device_lock, flags); 10457 raid_device = _scsih_raid_device_find_by_wwid(ioc, 10458 le64_to_cpu(volume_pg1->WWID)); 10459 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 10460 if (raid_device) 10461 continue; 10462 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, 10463 volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle, 10464 sizeof(Mpi2RaidVolPage0_t))) 10465 continue; 10466 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10467 MPI2_IOCSTATUS_MASK; 10468 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10469 ioc_info(ioc, "\tbreak from volume scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10470 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10471 break; 10472 } 10473 if (volume_pg0->VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL || 10474 volume_pg0->VolumeState == MPI2_RAID_VOL_STATE_ONLINE || 10475 volume_pg0->VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) { 10476 memset(&element, 0, sizeof(Mpi2EventIrConfigElement_t)); 10477 element.ReasonCode = MPI2_EVENT_IR_CHANGE_RC_ADDED; 10478 element.VolDevHandle = volume_pg1->DevHandle; 10479 ioc_info(ioc, "\tBEFORE adding volume: handle (0x%04x)\n", 10480 volume_pg1->DevHandle); 10481 _scsih_sas_volume_add(ioc, &element); 10482 ioc_info(ioc, "\tAFTER adding volume: handle (0x%04x)\n", 10483 volume_pg1->DevHandle); 10484 } 10485 } 10486 10487 ioc_info(ioc, "\tscan devices: volumes complete\n"); 10488 10489 skip_to_sas: 10490 10491 ioc_info(ioc, "\tscan devices: end devices start\n"); 10492 10493 /* sas devices */ 10494 handle = 0xFFFF; 10495 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 10496 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, 10497 handle))) { 10498 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 10499 MPI2_IOCSTATUS_MASK; 10500 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10501 ioc_info(ioc, "\tbreak from end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10502 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10503 break; 10504 } 10505 handle = le16_to_cpu(sas_device_pg0.DevHandle); 10506 if (!(_scsih_is_end_device( 10507 le32_to_cpu(sas_device_pg0.DeviceInfo)))) 10508 continue; 10509 port_id = sas_device_pg0.PhysicalPort; 10510 sas_device = mpt3sas_get_sdev_by_addr(ioc, 10511 le64_to_cpu(sas_device_pg0.SASAddress), 10512 mpt3sas_get_port_by_id(ioc, port_id, 0)); 10513 if (sas_device) { 10514 sas_device_put(sas_device); 10515 continue; 10516 } 10517 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 10518 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) { 10519 ioc_info(ioc, "\tBEFORE adding end device: handle (0x%04x), sas_addr(0x%016llx)\n", 10520 handle, 10521 (u64)le64_to_cpu(sas_device_pg0.SASAddress)); 10522 mpt3sas_transport_update_links(ioc, sas_address, handle, 10523 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5, 10524 mpt3sas_get_port_by_id(ioc, port_id, 0)); 10525 retry_count = 0; 10526 /* This will retry adding the end device. 10527 * _scsih_add_device() will decide on retries and 10528 * return "1" when it should be retried 10529 */ 10530 while (_scsih_add_device(ioc, handle, retry_count++, 10531 0)) { 10532 ssleep(1); 10533 } 10534 ioc_info(ioc, "\tAFTER adding end device: handle (0x%04x), sas_addr(0x%016llx)\n", 10535 handle, 10536 (u64)le64_to_cpu(sas_device_pg0.SASAddress)); 10537 } 10538 } 10539 ioc_info(ioc, "\tscan devices: end devices complete\n"); 10540 ioc_info(ioc, "\tscan devices: pcie end devices start\n"); 10541 10542 /* pcie devices */ 10543 handle = 0xFFFF; 10544 while (!(mpt3sas_config_get_pcie_device_pg0(ioc, &mpi_reply, 10545 &pcie_device_pg0, MPI26_PCIE_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, 10546 handle))) { 10547 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) 10548 & MPI2_IOCSTATUS_MASK; 10549 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 10550 ioc_info(ioc, "\tbreak from pcie end device scan: ioc_status(0x%04x), loginfo(0x%08x)\n", 10551 ioc_status, le32_to_cpu(mpi_reply.IOCLogInfo)); 10552 break; 10553 } 10554 handle = le16_to_cpu(pcie_device_pg0.DevHandle); 10555 if (!(_scsih_is_nvme_pciescsi_device( 10556 le32_to_cpu(pcie_device_pg0.DeviceInfo)))) 10557 continue; 10558 pcie_device = mpt3sas_get_pdev_by_wwid(ioc, 10559 le64_to_cpu(pcie_device_pg0.WWID)); 10560 if (pcie_device) { 10561 pcie_device_put(pcie_device); 10562 continue; 10563 } 10564 retry_count = 0; 10565 parent_handle = le16_to_cpu(pcie_device_pg0.ParentDevHandle); 10566 _scsih_pcie_add_device(ioc, handle); 10567 10568 ioc_info(ioc, "\tAFTER adding pcie end device: handle (0x%04x), wwid(0x%016llx)\n", 10569 handle, (u64)le64_to_cpu(pcie_device_pg0.WWID)); 10570 } 10571 10572 kfree(volume_pg0); 10573 kfree(volume_pg1); 10574 10575 ioc_info(ioc, "\tpcie devices: pcie end devices complete\n"); 10576 ioc_info(ioc, "scan devices: complete\n"); 10577 } 10578 10579 /** 10580 * mpt3sas_scsih_pre_reset_handler - reset callback handler (for scsih) 10581 * @ioc: per adapter object 10582 * 10583 * The handler for doing any required cleanup or initialization. 10584 */ 10585 void mpt3sas_scsih_pre_reset_handler(struct MPT3SAS_ADAPTER *ioc) 10586 { 10587 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_PRE_RESET\n", __func__)); 10588 } 10589 10590 /** 10591 * mpt3sas_scsih_clear_outstanding_scsi_tm_commands - clears outstanding 10592 * scsi & tm cmds. 10593 * @ioc: per adapter object 10594 * 10595 * The handler for doing any required cleanup or initialization. 10596 */ 10597 void 10598 mpt3sas_scsih_clear_outstanding_scsi_tm_commands(struct MPT3SAS_ADAPTER *ioc) 10599 { 10600 dtmprintk(ioc, 10601 ioc_info(ioc, "%s: clear outstanding scsi & tm cmds\n", __func__)); 10602 if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) { 10603 ioc->scsih_cmds.status |= MPT3_CMD_RESET; 10604 mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid); 10605 complete(&ioc->scsih_cmds.done); 10606 } 10607 if (ioc->tm_cmds.status & MPT3_CMD_PENDING) { 10608 ioc->tm_cmds.status |= MPT3_CMD_RESET; 10609 mpt3sas_base_free_smid(ioc, ioc->tm_cmds.smid); 10610 complete(&ioc->tm_cmds.done); 10611 } 10612 10613 memset(ioc->pend_os_device_add, 0, ioc->pend_os_device_add_sz); 10614 memset(ioc->device_remove_in_progress, 0, 10615 ioc->device_remove_in_progress_sz); 10616 _scsih_fw_event_cleanup_queue(ioc); 10617 _scsih_flush_running_cmds(ioc); 10618 } 10619 10620 /** 10621 * mpt3sas_scsih_reset_done_handler - reset callback handler (for scsih) 10622 * @ioc: per adapter object 10623 * 10624 * The handler for doing any required cleanup or initialization. 10625 */ 10626 void 10627 mpt3sas_scsih_reset_done_handler(struct MPT3SAS_ADAPTER *ioc) 10628 { 10629 dtmprintk(ioc, ioc_info(ioc, "%s: MPT3_IOC_DONE_RESET\n", __func__)); 10630 if (!(disable_discovery > 0 && !ioc->sas_hba.num_phys)) { 10631 if (ioc->multipath_on_hba) { 10632 _scsih_sas_port_refresh(ioc); 10633 _scsih_update_vphys_after_reset(ioc); 10634 } 10635 _scsih_prep_device_scan(ioc); 10636 _scsih_create_enclosure_list_after_reset(ioc); 10637 _scsih_search_responding_sas_devices(ioc); 10638 _scsih_search_responding_pcie_devices(ioc); 10639 _scsih_search_responding_raid_devices(ioc); 10640 _scsih_search_responding_expanders(ioc); 10641 _scsih_error_recovery_delete_devices(ioc); 10642 } 10643 } 10644 10645 /** 10646 * _mpt3sas_fw_work - delayed task for processing firmware events 10647 * @ioc: per adapter object 10648 * @fw_event: The fw_event_work object 10649 * Context: user. 10650 */ 10651 static void 10652 _mpt3sas_fw_work(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event) 10653 { 10654 ioc->current_event = fw_event; 10655 _scsih_fw_event_del_from_list(ioc, fw_event); 10656 10657 /* the queue is being flushed so ignore this event */ 10658 if (ioc->remove_host || ioc->pci_error_recovery) { 10659 fw_event_work_put(fw_event); 10660 ioc->current_event = NULL; 10661 return; 10662 } 10663 10664 switch (fw_event->event) { 10665 case MPT3SAS_PROCESS_TRIGGER_DIAG: 10666 mpt3sas_process_trigger_data(ioc, 10667 (struct SL_WH_TRIGGERS_EVENT_DATA_T *) 10668 fw_event->event_data); 10669 break; 10670 case MPT3SAS_REMOVE_UNRESPONDING_DEVICES: 10671 while (scsi_host_in_recovery(ioc->shost) || 10672 ioc->shost_recovery) { 10673 /* 10674 * If we're unloading or cancelling the work, bail. 10675 * Otherwise, this can become an infinite loop. 10676 */ 10677 if (ioc->remove_host || ioc->fw_events_cleanup) 10678 goto out; 10679 ssleep(1); 10680 } 10681 _scsih_remove_unresponding_devices(ioc); 10682 _scsih_del_dirty_vphy(ioc); 10683 _scsih_del_dirty_port_entries(ioc); 10684 if (ioc->is_gen35_ioc) 10685 _scsih_update_device_qdepth(ioc); 10686 _scsih_scan_for_devices_after_reset(ioc); 10687 /* 10688 * If diag reset has occurred during the driver load 10689 * then driver has to complete the driver load operation 10690 * by executing the following items: 10691 *- Register the devices from sas_device_init_list to SML 10692 *- clear is_driver_loading flag, 10693 *- start the watchdog thread. 10694 * In happy driver load path, above things are taken care of when 10695 * driver executes scsih_scan_finished(). 10696 */ 10697 if (ioc->is_driver_loading) 10698 _scsih_complete_devices_scanning(ioc); 10699 _scsih_set_nvme_max_shutdown_latency(ioc); 10700 break; 10701 case MPT3SAS_PORT_ENABLE_COMPLETE: 10702 ioc->start_scan = 0; 10703 if (missing_delay[0] != -1 && missing_delay[1] != -1) 10704 mpt3sas_base_update_missing_delay(ioc, missing_delay[0], 10705 missing_delay[1]); 10706 dewtprintk(ioc, 10707 ioc_info(ioc, "port enable: complete from worker thread\n")); 10708 break; 10709 case MPT3SAS_TURN_ON_PFA_LED: 10710 _scsih_turn_on_pfa_led(ioc, fw_event->device_handle); 10711 break; 10712 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST: 10713 _scsih_sas_topology_change_event(ioc, fw_event); 10714 break; 10715 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE: 10716 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 10717 _scsih_sas_device_status_change_event_debug(ioc, 10718 (Mpi2EventDataSasDeviceStatusChange_t *) 10719 fw_event->event_data); 10720 break; 10721 case MPI2_EVENT_SAS_DISCOVERY: 10722 _scsih_sas_discovery_event(ioc, fw_event); 10723 break; 10724 case MPI2_EVENT_SAS_DEVICE_DISCOVERY_ERROR: 10725 _scsih_sas_device_discovery_error_event(ioc, fw_event); 10726 break; 10727 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE: 10728 _scsih_sas_broadcast_primitive_event(ioc, fw_event); 10729 break; 10730 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE: 10731 _scsih_sas_enclosure_dev_status_change_event(ioc, 10732 fw_event); 10733 break; 10734 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST: 10735 _scsih_sas_ir_config_change_event(ioc, fw_event); 10736 break; 10737 case MPI2_EVENT_IR_VOLUME: 10738 _scsih_sas_ir_volume_event(ioc, fw_event); 10739 break; 10740 case MPI2_EVENT_IR_PHYSICAL_DISK: 10741 _scsih_sas_ir_physical_disk_event(ioc, fw_event); 10742 break; 10743 case MPI2_EVENT_IR_OPERATION_STATUS: 10744 _scsih_sas_ir_operation_status_event(ioc, fw_event); 10745 break; 10746 case MPI2_EVENT_PCIE_DEVICE_STATUS_CHANGE: 10747 _scsih_pcie_device_status_change_event(ioc, fw_event); 10748 break; 10749 case MPI2_EVENT_PCIE_ENUMERATION: 10750 _scsih_pcie_enumeration_event(ioc, fw_event); 10751 break; 10752 case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST: 10753 _scsih_pcie_topology_change_event(ioc, fw_event); 10754 ioc->current_event = NULL; 10755 return; 10756 } 10757 out: 10758 fw_event_work_put(fw_event); 10759 ioc->current_event = NULL; 10760 } 10761 10762 /** 10763 * _firmware_event_work 10764 * @work: The fw_event_work object 10765 * Context: user. 10766 * 10767 * wrappers for the work thread handling firmware events 10768 */ 10769 10770 static void 10771 _firmware_event_work(struct work_struct *work) 10772 { 10773 struct fw_event_work *fw_event = container_of(work, 10774 struct fw_event_work, work); 10775 10776 _mpt3sas_fw_work(fw_event->ioc, fw_event); 10777 } 10778 10779 /** 10780 * mpt3sas_scsih_event_callback - firmware event handler (called at ISR time) 10781 * @ioc: per adapter object 10782 * @msix_index: MSIX table index supplied by the OS 10783 * @reply: reply message frame(lower 32bit addr) 10784 * Context: interrupt. 10785 * 10786 * This function merely adds a new work task into ioc->firmware_event_thread. 10787 * The tasks are worked from _firmware_event_work in user context. 10788 * 10789 * Return: 1 meaning mf should be freed from _base_interrupt 10790 * 0 means the mf is freed from this function. 10791 */ 10792 u8 10793 mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index, 10794 u32 reply) 10795 { 10796 struct fw_event_work *fw_event; 10797 Mpi2EventNotificationReply_t *mpi_reply; 10798 u16 event; 10799 u16 sz; 10800 Mpi26EventDataActiveCableExcept_t *ActiveCableEventData; 10801 10802 /* events turned off due to host reset */ 10803 if (ioc->pci_error_recovery) 10804 return 1; 10805 10806 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 10807 10808 if (unlikely(!mpi_reply)) { 10809 ioc_err(ioc, "mpi_reply not valid at %s:%d/%s()!\n", 10810 __FILE__, __LINE__, __func__); 10811 return 1; 10812 } 10813 10814 event = le16_to_cpu(mpi_reply->Event); 10815 10816 if (event != MPI2_EVENT_LOG_ENTRY_ADDED) 10817 mpt3sas_trigger_event(ioc, event, 0); 10818 10819 switch (event) { 10820 /* handle these */ 10821 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE: 10822 { 10823 Mpi2EventDataSasBroadcastPrimitive_t *baen_data = 10824 (Mpi2EventDataSasBroadcastPrimitive_t *) 10825 mpi_reply->EventData; 10826 10827 if (baen_data->Primitive != 10828 MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT) 10829 return 1; 10830 10831 if (ioc->broadcast_aen_busy) { 10832 ioc->broadcast_aen_pending++; 10833 return 1; 10834 } else 10835 ioc->broadcast_aen_busy = 1; 10836 break; 10837 } 10838 10839 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST: 10840 _scsih_check_topo_delete_events(ioc, 10841 (Mpi2EventDataSasTopologyChangeList_t *) 10842 mpi_reply->EventData); 10843 /* 10844 * No need to add the topology change list 10845 * event to fw event work queue when 10846 * diag reset is going on. Since during diag 10847 * reset driver scan the devices by reading 10848 * sas device page0's not by processing the 10849 * events. 10850 */ 10851 if (ioc->shost_recovery) 10852 return 1; 10853 break; 10854 case MPI2_EVENT_PCIE_TOPOLOGY_CHANGE_LIST: 10855 _scsih_check_pcie_topo_remove_events(ioc, 10856 (Mpi26EventDataPCIeTopologyChangeList_t *) 10857 mpi_reply->EventData); 10858 if (ioc->shost_recovery) 10859 return 1; 10860 break; 10861 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST: 10862 _scsih_check_ir_config_unhide_events(ioc, 10863 (Mpi2EventDataIrConfigChangeList_t *) 10864 mpi_reply->EventData); 10865 break; 10866 case MPI2_EVENT_IR_VOLUME: 10867 _scsih_check_volume_delete_events(ioc, 10868 (Mpi2EventDataIrVolume_t *) 10869 mpi_reply->EventData); 10870 break; 10871 case MPI2_EVENT_LOG_ENTRY_ADDED: 10872 { 10873 Mpi2EventDataLogEntryAdded_t *log_entry; 10874 u32 *log_code; 10875 10876 if (!ioc->is_warpdrive) 10877 break; 10878 10879 log_entry = (Mpi2EventDataLogEntryAdded_t *) 10880 mpi_reply->EventData; 10881 log_code = (u32 *)log_entry->LogData; 10882 10883 if (le16_to_cpu(log_entry->LogEntryQualifier) 10884 != MPT2_WARPDRIVE_LOGENTRY) 10885 break; 10886 10887 switch (le32_to_cpu(*log_code)) { 10888 case MPT2_WARPDRIVE_LC_SSDT: 10889 ioc_warn(ioc, "WarpDrive Warning: IO Throttling has occurred in the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n"); 10890 break; 10891 case MPT2_WARPDRIVE_LC_SSDLW: 10892 ioc_warn(ioc, "WarpDrive Warning: Program/Erase Cycles for the WarpDrive subsystem in degraded range. Check WarpDrive documentation for additional details.\n"); 10893 break; 10894 case MPT2_WARPDRIVE_LC_SSDLF: 10895 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"); 10896 break; 10897 case MPT2_WARPDRIVE_LC_BRMF: 10898 ioc_err(ioc, "WarpDrive Fatal Error: The Backup Rail Monitor has failed on the WarpDrive subsystem. Check WarpDrive documentation for additional details.\n"); 10899 break; 10900 } 10901 10902 break; 10903 } 10904 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE: 10905 _scsih_sas_device_status_change_event(ioc, 10906 (Mpi2EventDataSasDeviceStatusChange_t *) 10907 mpi_reply->EventData); 10908 break; 10909 case MPI2_EVENT_IR_OPERATION_STATUS: 10910 case MPI2_EVENT_SAS_DISCOVERY: 10911 case MPI2_EVENT_SAS_DEVICE_DISCOVERY_ERROR: 10912 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE: 10913 case MPI2_EVENT_IR_PHYSICAL_DISK: 10914 case MPI2_EVENT_PCIE_ENUMERATION: 10915 case MPI2_EVENT_PCIE_DEVICE_STATUS_CHANGE: 10916 break; 10917 10918 case MPI2_EVENT_TEMP_THRESHOLD: 10919 _scsih_temp_threshold_events(ioc, 10920 (Mpi2EventDataTemperature_t *) 10921 mpi_reply->EventData); 10922 break; 10923 case MPI2_EVENT_ACTIVE_CABLE_EXCEPTION: 10924 ActiveCableEventData = 10925 (Mpi26EventDataActiveCableExcept_t *) mpi_reply->EventData; 10926 switch (ActiveCableEventData->ReasonCode) { 10927 case MPI26_EVENT_ACTIVE_CABLE_INSUFFICIENT_POWER: 10928 ioc_notice(ioc, "Currently an active cable with ReceptacleID %d\n", 10929 ActiveCableEventData->ReceptacleID); 10930 pr_notice("cannot be powered and devices connected\n"); 10931 pr_notice("to this active cable will not be seen\n"); 10932 pr_notice("This active cable requires %d mW of power\n", 10933 le32_to_cpu( 10934 ActiveCableEventData->ActiveCablePowerRequirement)); 10935 break; 10936 10937 case MPI26_EVENT_ACTIVE_CABLE_DEGRADED: 10938 ioc_notice(ioc, "Currently a cable with ReceptacleID %d\n", 10939 ActiveCableEventData->ReceptacleID); 10940 pr_notice( 10941 "is not running at optimal speed(12 Gb/s rate)\n"); 10942 break; 10943 } 10944 10945 break; 10946 10947 default: /* ignore the rest */ 10948 return 1; 10949 } 10950 10951 sz = le16_to_cpu(mpi_reply->EventDataLength) * 4; 10952 fw_event = alloc_fw_event_work(sz); 10953 if (!fw_event) { 10954 ioc_err(ioc, "failure at %s:%d/%s()!\n", 10955 __FILE__, __LINE__, __func__); 10956 return 1; 10957 } 10958 10959 memcpy(fw_event->event_data, mpi_reply->EventData, sz); 10960 fw_event->ioc = ioc; 10961 fw_event->VF_ID = mpi_reply->VF_ID; 10962 fw_event->VP_ID = mpi_reply->VP_ID; 10963 fw_event->event = event; 10964 _scsih_fw_event_add(ioc, fw_event); 10965 fw_event_work_put(fw_event); 10966 return 1; 10967 } 10968 10969 /** 10970 * _scsih_expander_node_remove - removing expander device from list. 10971 * @ioc: per adapter object 10972 * @sas_expander: the sas_device object 10973 * 10974 * Removing object and freeing associated memory from the 10975 * ioc->sas_expander_list. 10976 */ 10977 static void 10978 _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc, 10979 struct _sas_node *sas_expander) 10980 { 10981 struct _sas_port *mpt3sas_port, *next; 10982 unsigned long flags; 10983 10984 /* remove sibling ports attached to this expander */ 10985 list_for_each_entry_safe(mpt3sas_port, next, 10986 &sas_expander->sas_port_list, port_list) { 10987 if (ioc->shost_recovery) 10988 return; 10989 if (mpt3sas_port->remote_identify.device_type == 10990 SAS_END_DEVICE) 10991 mpt3sas_device_remove_by_sas_address(ioc, 10992 mpt3sas_port->remote_identify.sas_address, 10993 mpt3sas_port->hba_port); 10994 else if (mpt3sas_port->remote_identify.device_type == 10995 SAS_EDGE_EXPANDER_DEVICE || 10996 mpt3sas_port->remote_identify.device_type == 10997 SAS_FANOUT_EXPANDER_DEVICE) 10998 mpt3sas_expander_remove(ioc, 10999 mpt3sas_port->remote_identify.sas_address, 11000 mpt3sas_port->hba_port); 11001 } 11002 11003 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address, 11004 sas_expander->sas_address_parent, sas_expander->port); 11005 11006 ioc_info(ioc, 11007 "expander_remove: handle(0x%04x), sas_addr(0x%016llx), port:%d\n", 11008 sas_expander->handle, (unsigned long long) 11009 sas_expander->sas_address, 11010 sas_expander->port->port_id); 11011 11012 spin_lock_irqsave(&ioc->sas_node_lock, flags); 11013 list_del(&sas_expander->list); 11014 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 11015 11016 kfree(sas_expander->phy); 11017 kfree(sas_expander); 11018 } 11019 11020 /** 11021 * _scsih_nvme_shutdown - NVMe shutdown notification 11022 * @ioc: per adapter object 11023 * 11024 * Sending IoUnitControl request with shutdown operation code to alert IOC that 11025 * the host system is shutting down so that IOC can issue NVMe shutdown to 11026 * NVMe drives attached to it. 11027 */ 11028 static void 11029 _scsih_nvme_shutdown(struct MPT3SAS_ADAPTER *ioc) 11030 { 11031 Mpi26IoUnitControlRequest_t *mpi_request; 11032 Mpi26IoUnitControlReply_t *mpi_reply; 11033 u16 smid; 11034 11035 /* are there any NVMe devices ? */ 11036 if (list_empty(&ioc->pcie_device_list)) 11037 return; 11038 11039 mutex_lock(&ioc->scsih_cmds.mutex); 11040 11041 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) { 11042 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__); 11043 goto out; 11044 } 11045 11046 ioc->scsih_cmds.status = MPT3_CMD_PENDING; 11047 11048 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx); 11049 if (!smid) { 11050 ioc_err(ioc, 11051 "%s: failed obtaining a smid\n", __func__); 11052 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 11053 goto out; 11054 } 11055 11056 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 11057 ioc->scsih_cmds.smid = smid; 11058 memset(mpi_request, 0, sizeof(Mpi26IoUnitControlRequest_t)); 11059 mpi_request->Function = MPI2_FUNCTION_IO_UNIT_CONTROL; 11060 mpi_request->Operation = MPI26_CTRL_OP_SHUTDOWN; 11061 11062 init_completion(&ioc->scsih_cmds.done); 11063 ioc->put_smid_default(ioc, smid); 11064 /* Wait for max_shutdown_latency seconds */ 11065 ioc_info(ioc, 11066 "Io Unit Control shutdown (sending), Shutdown latency %d sec\n", 11067 ioc->max_shutdown_latency); 11068 wait_for_completion_timeout(&ioc->scsih_cmds.done, 11069 ioc->max_shutdown_latency*HZ); 11070 11071 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) { 11072 ioc_err(ioc, "%s: timeout\n", __func__); 11073 goto out; 11074 } 11075 11076 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) { 11077 mpi_reply = ioc->scsih_cmds.reply; 11078 ioc_info(ioc, "Io Unit Control shutdown (complete):" 11079 "ioc_status(0x%04x), loginfo(0x%08x)\n", 11080 le16_to_cpu(mpi_reply->IOCStatus), 11081 le32_to_cpu(mpi_reply->IOCLogInfo)); 11082 } 11083 out: 11084 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 11085 mutex_unlock(&ioc->scsih_cmds.mutex); 11086 } 11087 11088 11089 /** 11090 * _scsih_ir_shutdown - IR shutdown notification 11091 * @ioc: per adapter object 11092 * 11093 * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that 11094 * the host system is shutting down. 11095 */ 11096 static void 11097 _scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc) 11098 { 11099 Mpi2RaidActionRequest_t *mpi_request; 11100 Mpi2RaidActionReply_t *mpi_reply; 11101 u16 smid; 11102 11103 /* is IR firmware build loaded ? */ 11104 if (!ioc->ir_firmware) 11105 return; 11106 11107 /* are there any volumes ? */ 11108 if (list_empty(&ioc->raid_device_list)) 11109 return; 11110 11111 mutex_lock(&ioc->scsih_cmds.mutex); 11112 11113 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) { 11114 ioc_err(ioc, "%s: scsih_cmd in use\n", __func__); 11115 goto out; 11116 } 11117 ioc->scsih_cmds.status = MPT3_CMD_PENDING; 11118 11119 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx); 11120 if (!smid) { 11121 ioc_err(ioc, "%s: failed obtaining a smid\n", __func__); 11122 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 11123 goto out; 11124 } 11125 11126 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 11127 ioc->scsih_cmds.smid = smid; 11128 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t)); 11129 11130 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION; 11131 mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED; 11132 11133 if (!ioc->hide_ir_msg) 11134 ioc_info(ioc, "IR shutdown (sending)\n"); 11135 init_completion(&ioc->scsih_cmds.done); 11136 ioc->put_smid_default(ioc, smid); 11137 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ); 11138 11139 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) { 11140 ioc_err(ioc, "%s: timeout\n", __func__); 11141 goto out; 11142 } 11143 11144 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) { 11145 mpi_reply = ioc->scsih_cmds.reply; 11146 if (!ioc->hide_ir_msg) 11147 ioc_info(ioc, "IR shutdown (complete): ioc_status(0x%04x), loginfo(0x%08x)\n", 11148 le16_to_cpu(mpi_reply->IOCStatus), 11149 le32_to_cpu(mpi_reply->IOCLogInfo)); 11150 } 11151 11152 out: 11153 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 11154 mutex_unlock(&ioc->scsih_cmds.mutex); 11155 } 11156 11157 /** 11158 * _scsih_get_shost_and_ioc - get shost and ioc 11159 * and verify whether they are NULL or not 11160 * @pdev: PCI device struct 11161 * @shost: address of scsi host pointer 11162 * @ioc: address of HBA adapter pointer 11163 * 11164 * Return zero if *shost and *ioc are not NULL otherwise return error number. 11165 */ 11166 static int 11167 _scsih_get_shost_and_ioc(struct pci_dev *pdev, 11168 struct Scsi_Host **shost, struct MPT3SAS_ADAPTER **ioc) 11169 { 11170 *shost = pci_get_drvdata(pdev); 11171 if (*shost == NULL) { 11172 dev_err(&pdev->dev, "pdev's driver data is null\n"); 11173 return -ENXIO; 11174 } 11175 11176 *ioc = shost_priv(*shost); 11177 if (*ioc == NULL) { 11178 dev_err(&pdev->dev, "shost's private data is null\n"); 11179 return -ENXIO; 11180 } 11181 11182 return 0; 11183 } 11184 11185 /** 11186 * scsih_remove - detach and remove add host 11187 * @pdev: PCI device struct 11188 * 11189 * Routine called when unloading the driver. 11190 */ 11191 static void scsih_remove(struct pci_dev *pdev) 11192 { 11193 struct Scsi_Host *shost; 11194 struct MPT3SAS_ADAPTER *ioc; 11195 struct _sas_port *mpt3sas_port, *next_port; 11196 struct _raid_device *raid_device, *next; 11197 struct MPT3SAS_TARGET *sas_target_priv_data; 11198 struct _pcie_device *pcie_device, *pcienext; 11199 struct workqueue_struct *wq; 11200 unsigned long flags; 11201 Mpi2ConfigReply_t mpi_reply; 11202 struct hba_port *port, *port_next; 11203 11204 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 11205 return; 11206 11207 ioc->remove_host = 1; 11208 11209 if (!pci_device_is_present(pdev)) { 11210 mpt3sas_base_pause_mq_polling(ioc); 11211 _scsih_flush_running_cmds(ioc); 11212 } 11213 11214 _scsih_fw_event_cleanup_queue(ioc); 11215 11216 spin_lock_irqsave(&ioc->fw_event_lock, flags); 11217 wq = ioc->firmware_event_thread; 11218 ioc->firmware_event_thread = NULL; 11219 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 11220 if (wq) 11221 destroy_workqueue(wq); 11222 /* 11223 * Copy back the unmodified ioc page1. so that on next driver load, 11224 * current modified changes on ioc page1 won't take effect. 11225 */ 11226 if (ioc->is_aero_ioc) 11227 mpt3sas_config_set_ioc_pg1(ioc, &mpi_reply, 11228 &ioc->ioc_pg1_copy); 11229 /* release all the volumes */ 11230 _scsih_ir_shutdown(ioc); 11231 mpt3sas_destroy_debugfs(ioc); 11232 sas_remove_host(shost); 11233 list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list, 11234 list) { 11235 if (raid_device->starget) { 11236 sas_target_priv_data = 11237 raid_device->starget->hostdata; 11238 sas_target_priv_data->deleted = 1; 11239 scsi_remove_target(&raid_device->starget->dev); 11240 } 11241 ioc_info(ioc, "removing handle(0x%04x), wwid(0x%016llx)\n", 11242 raid_device->handle, (u64)raid_device->wwid); 11243 _scsih_raid_device_remove(ioc, raid_device); 11244 } 11245 list_for_each_entry_safe(pcie_device, pcienext, &ioc->pcie_device_list, 11246 list) { 11247 _scsih_pcie_device_remove_from_sml(ioc, pcie_device); 11248 list_del_init(&pcie_device->list); 11249 pcie_device_put(pcie_device); 11250 } 11251 11252 /* free ports attached to the sas_host */ 11253 list_for_each_entry_safe(mpt3sas_port, next_port, 11254 &ioc->sas_hba.sas_port_list, port_list) { 11255 if (mpt3sas_port->remote_identify.device_type == 11256 SAS_END_DEVICE) 11257 mpt3sas_device_remove_by_sas_address(ioc, 11258 mpt3sas_port->remote_identify.sas_address, 11259 mpt3sas_port->hba_port); 11260 else if (mpt3sas_port->remote_identify.device_type == 11261 SAS_EDGE_EXPANDER_DEVICE || 11262 mpt3sas_port->remote_identify.device_type == 11263 SAS_FANOUT_EXPANDER_DEVICE) 11264 mpt3sas_expander_remove(ioc, 11265 mpt3sas_port->remote_identify.sas_address, 11266 mpt3sas_port->hba_port); 11267 } 11268 11269 list_for_each_entry_safe(port, port_next, 11270 &ioc->port_table_list, list) { 11271 list_del(&port->list); 11272 kfree(port); 11273 } 11274 11275 /* free phys attached to the sas_host */ 11276 if (ioc->sas_hba.num_phys) { 11277 kfree(ioc->sas_hba.phy); 11278 ioc->sas_hba.phy = NULL; 11279 ioc->sas_hba.num_phys = 0; 11280 } 11281 11282 mpt3sas_base_detach(ioc); 11283 spin_lock(&gioc_lock); 11284 list_del(&ioc->list); 11285 spin_unlock(&gioc_lock); 11286 scsi_host_put(shost); 11287 } 11288 11289 /** 11290 * scsih_shutdown - routine call during system shutdown 11291 * @pdev: PCI device struct 11292 */ 11293 static void 11294 scsih_shutdown(struct pci_dev *pdev) 11295 { 11296 struct Scsi_Host *shost; 11297 struct MPT3SAS_ADAPTER *ioc; 11298 struct workqueue_struct *wq; 11299 unsigned long flags; 11300 Mpi2ConfigReply_t mpi_reply; 11301 11302 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 11303 return; 11304 11305 ioc->remove_host = 1; 11306 11307 if (!pci_device_is_present(pdev)) { 11308 mpt3sas_base_pause_mq_polling(ioc); 11309 _scsih_flush_running_cmds(ioc); 11310 } 11311 11312 _scsih_fw_event_cleanup_queue(ioc); 11313 11314 spin_lock_irqsave(&ioc->fw_event_lock, flags); 11315 wq = ioc->firmware_event_thread; 11316 ioc->firmware_event_thread = NULL; 11317 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 11318 if (wq) 11319 destroy_workqueue(wq); 11320 /* 11321 * Copy back the unmodified ioc page1 so that on next driver load, 11322 * current modified changes on ioc page1 won't take effect. 11323 */ 11324 if (ioc->is_aero_ioc) 11325 mpt3sas_config_set_ioc_pg1(ioc, &mpi_reply, 11326 &ioc->ioc_pg1_copy); 11327 11328 _scsih_ir_shutdown(ioc); 11329 _scsih_nvme_shutdown(ioc); 11330 mpt3sas_base_mask_interrupts(ioc); 11331 ioc->shost_recovery = 1; 11332 mpt3sas_base_make_ioc_ready(ioc, SOFT_RESET); 11333 ioc->shost_recovery = 0; 11334 mpt3sas_base_free_irq(ioc); 11335 mpt3sas_base_disable_msix(ioc); 11336 } 11337 11338 11339 /** 11340 * _scsih_probe_boot_devices - reports 1st device 11341 * @ioc: per adapter object 11342 * 11343 * If specified in bios page 2, this routine reports the 1st 11344 * device scsi-ml or sas transport for persistent boot device 11345 * purposes. Please refer to function _scsih_determine_boot_device() 11346 */ 11347 static void 11348 _scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc) 11349 { 11350 u32 channel; 11351 void *device; 11352 struct _sas_device *sas_device; 11353 struct _raid_device *raid_device; 11354 struct _pcie_device *pcie_device; 11355 u16 handle; 11356 u64 sas_address_parent; 11357 u64 sas_address; 11358 unsigned long flags; 11359 int rc; 11360 int tid; 11361 struct hba_port *port; 11362 11363 /* no Bios, return immediately */ 11364 if (!ioc->bios_pg3.BiosVersion) 11365 return; 11366 11367 device = NULL; 11368 if (ioc->req_boot_device.device) { 11369 device = ioc->req_boot_device.device; 11370 channel = ioc->req_boot_device.channel; 11371 } else if (ioc->req_alt_boot_device.device) { 11372 device = ioc->req_alt_boot_device.device; 11373 channel = ioc->req_alt_boot_device.channel; 11374 } else if (ioc->current_boot_device.device) { 11375 device = ioc->current_boot_device.device; 11376 channel = ioc->current_boot_device.channel; 11377 } 11378 11379 if (!device) 11380 return; 11381 11382 if (channel == RAID_CHANNEL) { 11383 raid_device = device; 11384 /* 11385 * If this boot vd is already registered with SML then 11386 * no need to register it again as part of device scanning 11387 * after diag reset during driver load operation. 11388 */ 11389 if (raid_device->starget) 11390 return; 11391 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 11392 raid_device->id, 0); 11393 if (rc) 11394 _scsih_raid_device_remove(ioc, raid_device); 11395 } else if (channel == PCIE_CHANNEL) { 11396 pcie_device = device; 11397 /* 11398 * If this boot NVMe device is already registered with SML then 11399 * no need to register it again as part of device scanning 11400 * after diag reset during driver load operation. 11401 */ 11402 if (pcie_device->starget) 11403 return; 11404 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 11405 tid = pcie_device->id; 11406 list_move_tail(&pcie_device->list, &ioc->pcie_device_list); 11407 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 11408 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL, tid, 0); 11409 if (rc) 11410 _scsih_pcie_device_remove(ioc, pcie_device); 11411 } else { 11412 sas_device = device; 11413 /* 11414 * If this boot sas/sata device is already registered with SML 11415 * then no need to register it again as part of device scanning 11416 * after diag reset during driver load operation. 11417 */ 11418 if (sas_device->starget) 11419 return; 11420 spin_lock_irqsave(&ioc->sas_device_lock, flags); 11421 handle = sas_device->handle; 11422 sas_address_parent = sas_device->sas_address_parent; 11423 sas_address = sas_device->sas_address; 11424 port = sas_device->port; 11425 list_move_tail(&sas_device->list, &ioc->sas_device_list); 11426 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 11427 11428 if (ioc->hide_drives) 11429 return; 11430 11431 if (!port) 11432 return; 11433 11434 if (!mpt3sas_transport_port_add(ioc, handle, 11435 sas_address_parent, port)) { 11436 _scsih_sas_device_remove(ioc, sas_device); 11437 } else if (!sas_device->starget) { 11438 if (!ioc->is_driver_loading) { 11439 mpt3sas_transport_port_remove(ioc, 11440 sas_address, 11441 sas_address_parent, port); 11442 _scsih_sas_device_remove(ioc, sas_device); 11443 } 11444 } 11445 } 11446 } 11447 11448 /** 11449 * _scsih_probe_raid - reporting raid volumes to scsi-ml 11450 * @ioc: per adapter object 11451 * 11452 * Called during initial loading of the driver. 11453 */ 11454 static void 11455 _scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc) 11456 { 11457 struct _raid_device *raid_device, *raid_next; 11458 int rc; 11459 11460 list_for_each_entry_safe(raid_device, raid_next, 11461 &ioc->raid_device_list, list) { 11462 if (raid_device->starget) 11463 continue; 11464 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 11465 raid_device->id, 0); 11466 if (rc) 11467 _scsih_raid_device_remove(ioc, raid_device); 11468 } 11469 } 11470 11471 static struct _sas_device *get_next_sas_device(struct MPT3SAS_ADAPTER *ioc) 11472 { 11473 struct _sas_device *sas_device = NULL; 11474 unsigned long flags; 11475 11476 spin_lock_irqsave(&ioc->sas_device_lock, flags); 11477 if (!list_empty(&ioc->sas_device_init_list)) { 11478 sas_device = list_first_entry(&ioc->sas_device_init_list, 11479 struct _sas_device, list); 11480 sas_device_get(sas_device); 11481 } 11482 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 11483 11484 return sas_device; 11485 } 11486 11487 static void sas_device_make_active(struct MPT3SAS_ADAPTER *ioc, 11488 struct _sas_device *sas_device) 11489 { 11490 unsigned long flags; 11491 11492 spin_lock_irqsave(&ioc->sas_device_lock, flags); 11493 11494 /* 11495 * Since we dropped the lock during the call to port_add(), we need to 11496 * be careful here that somebody else didn't move or delete this item 11497 * while we were busy with other things. 11498 * 11499 * If it was on the list, we need a put() for the reference the list 11500 * had. Either way, we need a get() for the destination list. 11501 */ 11502 if (!list_empty(&sas_device->list)) { 11503 list_del_init(&sas_device->list); 11504 sas_device_put(sas_device); 11505 } 11506 11507 sas_device_get(sas_device); 11508 list_add_tail(&sas_device->list, &ioc->sas_device_list); 11509 11510 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 11511 } 11512 11513 /** 11514 * _scsih_probe_sas - reporting sas devices to sas transport 11515 * @ioc: per adapter object 11516 * 11517 * Called during initial loading of the driver. 11518 */ 11519 static void 11520 _scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc) 11521 { 11522 struct _sas_device *sas_device; 11523 11524 if (ioc->hide_drives) 11525 return; 11526 11527 while ((sas_device = get_next_sas_device(ioc))) { 11528 if (!mpt3sas_transport_port_add(ioc, sas_device->handle, 11529 sas_device->sas_address_parent, sas_device->port)) { 11530 _scsih_sas_device_remove(ioc, sas_device); 11531 sas_device_put(sas_device); 11532 continue; 11533 } else if (!sas_device->starget) { 11534 /* 11535 * When asyn scanning is enabled, its not possible to 11536 * remove devices while scanning is turned on due to an 11537 * oops in scsi_sysfs_add_sdev()->add_device()-> 11538 * sysfs_addrm_start() 11539 */ 11540 if (!ioc->is_driver_loading) { 11541 mpt3sas_transport_port_remove(ioc, 11542 sas_device->sas_address, 11543 sas_device->sas_address_parent, 11544 sas_device->port); 11545 _scsih_sas_device_remove(ioc, sas_device); 11546 sas_device_put(sas_device); 11547 continue; 11548 } 11549 } 11550 sas_device_make_active(ioc, sas_device); 11551 sas_device_put(sas_device); 11552 } 11553 } 11554 11555 /** 11556 * get_next_pcie_device - Get the next pcie device 11557 * @ioc: per adapter object 11558 * 11559 * Get the next pcie device from pcie_device_init_list list. 11560 * 11561 * Return: pcie device structure if pcie_device_init_list list is not empty 11562 * otherwise returns NULL 11563 */ 11564 static struct _pcie_device *get_next_pcie_device(struct MPT3SAS_ADAPTER *ioc) 11565 { 11566 struct _pcie_device *pcie_device = NULL; 11567 unsigned long flags; 11568 11569 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 11570 if (!list_empty(&ioc->pcie_device_init_list)) { 11571 pcie_device = list_first_entry(&ioc->pcie_device_init_list, 11572 struct _pcie_device, list); 11573 pcie_device_get(pcie_device); 11574 } 11575 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 11576 11577 return pcie_device; 11578 } 11579 11580 /** 11581 * pcie_device_make_active - Add pcie device to pcie_device_list list 11582 * @ioc: per adapter object 11583 * @pcie_device: pcie device object 11584 * 11585 * Add the pcie device which has registered with SCSI Transport Later to 11586 * pcie_device_list list 11587 */ 11588 static void pcie_device_make_active(struct MPT3SAS_ADAPTER *ioc, 11589 struct _pcie_device *pcie_device) 11590 { 11591 unsigned long flags; 11592 11593 spin_lock_irqsave(&ioc->pcie_device_lock, flags); 11594 11595 if (!list_empty(&pcie_device->list)) { 11596 list_del_init(&pcie_device->list); 11597 pcie_device_put(pcie_device); 11598 } 11599 pcie_device_get(pcie_device); 11600 list_add_tail(&pcie_device->list, &ioc->pcie_device_list); 11601 11602 spin_unlock_irqrestore(&ioc->pcie_device_lock, flags); 11603 } 11604 11605 /** 11606 * _scsih_probe_pcie - reporting PCIe devices to scsi-ml 11607 * @ioc: per adapter object 11608 * 11609 * Called during initial loading of the driver. 11610 */ 11611 static void 11612 _scsih_probe_pcie(struct MPT3SAS_ADAPTER *ioc) 11613 { 11614 struct _pcie_device *pcie_device; 11615 int rc; 11616 11617 /* PCIe Device List */ 11618 while ((pcie_device = get_next_pcie_device(ioc))) { 11619 if (pcie_device->starget) { 11620 pcie_device_put(pcie_device); 11621 continue; 11622 } 11623 if (pcie_device->access_status == 11624 MPI26_PCIEDEV0_ASTATUS_DEVICE_BLOCKED) { 11625 pcie_device_make_active(ioc, pcie_device); 11626 pcie_device_put(pcie_device); 11627 continue; 11628 } 11629 rc = scsi_add_device(ioc->shost, PCIE_CHANNEL, 11630 pcie_device->id, 0); 11631 if (rc) { 11632 _scsih_pcie_device_remove(ioc, pcie_device); 11633 pcie_device_put(pcie_device); 11634 continue; 11635 } else if (!pcie_device->starget) { 11636 /* 11637 * When async scanning is enabled, its not possible to 11638 * remove devices while scanning is turned on due to an 11639 * oops in scsi_sysfs_add_sdev()->add_device()-> 11640 * sysfs_addrm_start() 11641 */ 11642 if (!ioc->is_driver_loading) { 11643 /* TODO-- Need to find out whether this condition will 11644 * occur or not 11645 */ 11646 _scsih_pcie_device_remove(ioc, pcie_device); 11647 pcie_device_put(pcie_device); 11648 continue; 11649 } 11650 } 11651 pcie_device_make_active(ioc, pcie_device); 11652 pcie_device_put(pcie_device); 11653 } 11654 } 11655 11656 /** 11657 * _scsih_probe_devices - probing for devices 11658 * @ioc: per adapter object 11659 * 11660 * Called during initial loading of the driver. 11661 */ 11662 static void 11663 _scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc) 11664 { 11665 u16 volume_mapping_flags; 11666 11667 if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR)) 11668 return; /* return when IOC doesn't support initiator mode */ 11669 11670 _scsih_probe_boot_devices(ioc); 11671 11672 if (ioc->ir_firmware) { 11673 volume_mapping_flags = 11674 le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) & 11675 MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE; 11676 if (volume_mapping_flags == 11677 MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) { 11678 _scsih_probe_raid(ioc); 11679 _scsih_probe_sas(ioc); 11680 } else { 11681 _scsih_probe_sas(ioc); 11682 _scsih_probe_raid(ioc); 11683 } 11684 } else { 11685 _scsih_probe_sas(ioc); 11686 _scsih_probe_pcie(ioc); 11687 } 11688 } 11689 11690 /** 11691 * scsih_scan_start - scsi lld callback for .scan_start 11692 * @shost: SCSI host pointer 11693 * 11694 * The shost has the ability to discover targets on its own instead 11695 * of scanning the entire bus. In our implemention, we will kick off 11696 * firmware discovery. 11697 */ 11698 static void 11699 scsih_scan_start(struct Scsi_Host *shost) 11700 { 11701 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 11702 int rc; 11703 if (diag_buffer_enable != -1 && diag_buffer_enable != 0) 11704 mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable); 11705 else if (ioc->manu_pg11.HostTraceBufferMaxSizeKB != 0) 11706 mpt3sas_enable_diag_buffer(ioc, 1); 11707 11708 if (disable_discovery > 0) 11709 return; 11710 11711 ioc->start_scan = 1; 11712 rc = mpt3sas_port_enable(ioc); 11713 11714 if (rc != 0) 11715 ioc_info(ioc, "port enable: FAILED\n"); 11716 } 11717 11718 /** 11719 * _scsih_complete_devices_scanning - add the devices to sml and 11720 * complete ioc initialization. 11721 * @ioc: per adapter object 11722 * 11723 * Return nothing. 11724 */ 11725 static void _scsih_complete_devices_scanning(struct MPT3SAS_ADAPTER *ioc) 11726 { 11727 11728 if (ioc->wait_for_discovery_to_complete) { 11729 ioc->wait_for_discovery_to_complete = 0; 11730 _scsih_probe_devices(ioc); 11731 } 11732 11733 mpt3sas_base_start_watchdog(ioc); 11734 ioc->is_driver_loading = 0; 11735 } 11736 11737 /** 11738 * scsih_scan_finished - scsi lld callback for .scan_finished 11739 * @shost: SCSI host pointer 11740 * @time: elapsed time of the scan in jiffies 11741 * 11742 * This function will be called periodicallyn until it returns 1 with the 11743 * scsi_host and the elapsed time of the scan in jiffies. In our implemention, 11744 * we wait for firmware discovery to complete, then return 1. 11745 */ 11746 static int 11747 scsih_scan_finished(struct Scsi_Host *shost, unsigned long time) 11748 { 11749 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 11750 u32 ioc_state; 11751 int issue_hard_reset = 0; 11752 11753 if (disable_discovery > 0) { 11754 ioc->is_driver_loading = 0; 11755 ioc->wait_for_discovery_to_complete = 0; 11756 return 1; 11757 } 11758 11759 if (time >= (300 * HZ)) { 11760 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED; 11761 ioc_info(ioc, "port enable: FAILED with timeout (timeout=300s)\n"); 11762 ioc->is_driver_loading = 0; 11763 return 1; 11764 } 11765 11766 if (ioc->start_scan) { 11767 ioc_state = mpt3sas_base_get_iocstate(ioc, 0); 11768 if ((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT) { 11769 mpt3sas_print_fault_code(ioc, ioc_state & 11770 MPI2_DOORBELL_DATA_MASK); 11771 issue_hard_reset = 1; 11772 goto out; 11773 } else if ((ioc_state & MPI2_IOC_STATE_MASK) == 11774 MPI2_IOC_STATE_COREDUMP) { 11775 mpt3sas_base_coredump_info(ioc, ioc_state & 11776 MPI2_DOORBELL_DATA_MASK); 11777 mpt3sas_base_wait_for_coredump_completion(ioc, __func__); 11778 issue_hard_reset = 1; 11779 goto out; 11780 } 11781 return 0; 11782 } 11783 11784 if (ioc->port_enable_cmds.status & MPT3_CMD_RESET) { 11785 ioc_info(ioc, 11786 "port enable: aborted due to diag reset\n"); 11787 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED; 11788 goto out; 11789 } 11790 if (ioc->start_scan_failed) { 11791 ioc_info(ioc, "port enable: FAILED with (ioc_status=0x%08x)\n", 11792 ioc->start_scan_failed); 11793 ioc->is_driver_loading = 0; 11794 ioc->wait_for_discovery_to_complete = 0; 11795 ioc->remove_host = 1; 11796 return 1; 11797 } 11798 11799 ioc_info(ioc, "port enable: SUCCESS\n"); 11800 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED; 11801 _scsih_complete_devices_scanning(ioc); 11802 11803 out: 11804 if (issue_hard_reset) { 11805 ioc->port_enable_cmds.status = MPT3_CMD_NOT_USED; 11806 if (mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET)) 11807 ioc->is_driver_loading = 0; 11808 } 11809 return 1; 11810 } 11811 11812 /** 11813 * scsih_map_queues - map reply queues with request queues 11814 * @shost: SCSI host pointer 11815 */ 11816 static int scsih_map_queues(struct Scsi_Host *shost) 11817 { 11818 struct MPT3SAS_ADAPTER *ioc = 11819 (struct MPT3SAS_ADAPTER *)shost->hostdata; 11820 struct blk_mq_queue_map *map; 11821 int i, qoff, offset; 11822 int nr_msix_vectors = ioc->iopoll_q_start_index; 11823 int iopoll_q_count = ioc->reply_queue_count - nr_msix_vectors; 11824 11825 if (shost->nr_hw_queues == 1) 11826 return 0; 11827 11828 for (i = 0, qoff = 0; i < shost->nr_maps; i++) { 11829 map = &shost->tag_set.map[i]; 11830 map->nr_queues = 0; 11831 offset = 0; 11832 if (i == HCTX_TYPE_DEFAULT) { 11833 map->nr_queues = 11834 nr_msix_vectors - ioc->high_iops_queues; 11835 offset = ioc->high_iops_queues; 11836 } else if (i == HCTX_TYPE_POLL) 11837 map->nr_queues = iopoll_q_count; 11838 11839 if (!map->nr_queues) 11840 BUG_ON(i == HCTX_TYPE_DEFAULT); 11841 11842 /* 11843 * The poll queue(s) doesn't have an IRQ (and hence IRQ 11844 * affinity), so use the regular blk-mq cpu mapping 11845 */ 11846 map->queue_offset = qoff; 11847 if (i != HCTX_TYPE_POLL) 11848 blk_mq_pci_map_queues(map, ioc->pdev, offset); 11849 else 11850 blk_mq_map_queues(map); 11851 11852 qoff += map->nr_queues; 11853 } 11854 return 0; 11855 } 11856 11857 /* shost template for SAS 2.0 HBA devices */ 11858 static struct scsi_host_template mpt2sas_driver_template = { 11859 .module = THIS_MODULE, 11860 .name = "Fusion MPT SAS Host", 11861 .proc_name = MPT2SAS_DRIVER_NAME, 11862 .queuecommand = scsih_qcmd, 11863 .target_alloc = scsih_target_alloc, 11864 .slave_alloc = scsih_slave_alloc, 11865 .slave_configure = scsih_slave_configure, 11866 .target_destroy = scsih_target_destroy, 11867 .slave_destroy = scsih_slave_destroy, 11868 .scan_finished = scsih_scan_finished, 11869 .scan_start = scsih_scan_start, 11870 .change_queue_depth = scsih_change_queue_depth, 11871 .eh_abort_handler = scsih_abort, 11872 .eh_device_reset_handler = scsih_dev_reset, 11873 .eh_target_reset_handler = scsih_target_reset, 11874 .eh_host_reset_handler = scsih_host_reset, 11875 .bios_param = scsih_bios_param, 11876 .can_queue = 1, 11877 .this_id = -1, 11878 .sg_tablesize = MPT2SAS_SG_DEPTH, 11879 .max_sectors = 32767, 11880 .cmd_per_lun = 7, 11881 .shost_groups = mpt3sas_host_groups, 11882 .sdev_groups = mpt3sas_dev_groups, 11883 .track_queue_depth = 1, 11884 .cmd_size = sizeof(struct scsiio_tracker), 11885 }; 11886 11887 /* raid transport support for SAS 2.0 HBA devices */ 11888 static struct raid_function_template mpt2sas_raid_functions = { 11889 .cookie = &mpt2sas_driver_template, 11890 .is_raid = scsih_is_raid, 11891 .get_resync = scsih_get_resync, 11892 .get_state = scsih_get_state, 11893 }; 11894 11895 /* shost template for SAS 3.0 HBA devices */ 11896 static struct scsi_host_template mpt3sas_driver_template = { 11897 .module = THIS_MODULE, 11898 .name = "Fusion MPT SAS Host", 11899 .proc_name = MPT3SAS_DRIVER_NAME, 11900 .queuecommand = scsih_qcmd, 11901 .target_alloc = scsih_target_alloc, 11902 .slave_alloc = scsih_slave_alloc, 11903 .slave_configure = scsih_slave_configure, 11904 .target_destroy = scsih_target_destroy, 11905 .slave_destroy = scsih_slave_destroy, 11906 .scan_finished = scsih_scan_finished, 11907 .scan_start = scsih_scan_start, 11908 .change_queue_depth = scsih_change_queue_depth, 11909 .eh_abort_handler = scsih_abort, 11910 .eh_device_reset_handler = scsih_dev_reset, 11911 .eh_target_reset_handler = scsih_target_reset, 11912 .eh_host_reset_handler = scsih_host_reset, 11913 .bios_param = scsih_bios_param, 11914 .can_queue = 1, 11915 .this_id = -1, 11916 .sg_tablesize = MPT3SAS_SG_DEPTH, 11917 .max_sectors = 32767, 11918 .max_segment_size = 0xffffffff, 11919 .cmd_per_lun = 7, 11920 .shost_groups = mpt3sas_host_groups, 11921 .sdev_groups = mpt3sas_dev_groups, 11922 .track_queue_depth = 1, 11923 .cmd_size = sizeof(struct scsiio_tracker), 11924 .map_queues = scsih_map_queues, 11925 .mq_poll = mpt3sas_blk_mq_poll, 11926 }; 11927 11928 /* raid transport support for SAS 3.0 HBA devices */ 11929 static struct raid_function_template mpt3sas_raid_functions = { 11930 .cookie = &mpt3sas_driver_template, 11931 .is_raid = scsih_is_raid, 11932 .get_resync = scsih_get_resync, 11933 .get_state = scsih_get_state, 11934 }; 11935 11936 /** 11937 * _scsih_determine_hba_mpi_version - determine in which MPI version class 11938 * this device belongs to. 11939 * @pdev: PCI device struct 11940 * 11941 * return MPI2_VERSION for SAS 2.0 HBA devices, 11942 * MPI25_VERSION for SAS 3.0 HBA devices, and 11943 * MPI26 VERSION for Cutlass & Invader SAS 3.0 HBA devices 11944 */ 11945 static u16 11946 _scsih_determine_hba_mpi_version(struct pci_dev *pdev) 11947 { 11948 11949 switch (pdev->device) { 11950 case MPI2_MFGPAGE_DEVID_SSS6200: 11951 case MPI2_MFGPAGE_DEVID_SAS2004: 11952 case MPI2_MFGPAGE_DEVID_SAS2008: 11953 case MPI2_MFGPAGE_DEVID_SAS2108_1: 11954 case MPI2_MFGPAGE_DEVID_SAS2108_2: 11955 case MPI2_MFGPAGE_DEVID_SAS2108_3: 11956 case MPI2_MFGPAGE_DEVID_SAS2116_1: 11957 case MPI2_MFGPAGE_DEVID_SAS2116_2: 11958 case MPI2_MFGPAGE_DEVID_SAS2208_1: 11959 case MPI2_MFGPAGE_DEVID_SAS2208_2: 11960 case MPI2_MFGPAGE_DEVID_SAS2208_3: 11961 case MPI2_MFGPAGE_DEVID_SAS2208_4: 11962 case MPI2_MFGPAGE_DEVID_SAS2208_5: 11963 case MPI2_MFGPAGE_DEVID_SAS2208_6: 11964 case MPI2_MFGPAGE_DEVID_SAS2308_1: 11965 case MPI2_MFGPAGE_DEVID_SAS2308_2: 11966 case MPI2_MFGPAGE_DEVID_SAS2308_3: 11967 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP: 11968 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1: 11969 return MPI2_VERSION; 11970 case MPI25_MFGPAGE_DEVID_SAS3004: 11971 case MPI25_MFGPAGE_DEVID_SAS3008: 11972 case MPI25_MFGPAGE_DEVID_SAS3108_1: 11973 case MPI25_MFGPAGE_DEVID_SAS3108_2: 11974 case MPI25_MFGPAGE_DEVID_SAS3108_5: 11975 case MPI25_MFGPAGE_DEVID_SAS3108_6: 11976 return MPI25_VERSION; 11977 case MPI26_MFGPAGE_DEVID_SAS3216: 11978 case MPI26_MFGPAGE_DEVID_SAS3224: 11979 case MPI26_MFGPAGE_DEVID_SAS3316_1: 11980 case MPI26_MFGPAGE_DEVID_SAS3316_2: 11981 case MPI26_MFGPAGE_DEVID_SAS3316_3: 11982 case MPI26_MFGPAGE_DEVID_SAS3316_4: 11983 case MPI26_MFGPAGE_DEVID_SAS3324_1: 11984 case MPI26_MFGPAGE_DEVID_SAS3324_2: 11985 case MPI26_MFGPAGE_DEVID_SAS3324_3: 11986 case MPI26_MFGPAGE_DEVID_SAS3324_4: 11987 case MPI26_MFGPAGE_DEVID_SAS3508: 11988 case MPI26_MFGPAGE_DEVID_SAS3508_1: 11989 case MPI26_MFGPAGE_DEVID_SAS3408: 11990 case MPI26_MFGPAGE_DEVID_SAS3516: 11991 case MPI26_MFGPAGE_DEVID_SAS3516_1: 11992 case MPI26_MFGPAGE_DEVID_SAS3416: 11993 case MPI26_MFGPAGE_DEVID_SAS3616: 11994 case MPI26_ATLAS_PCIe_SWITCH_DEVID: 11995 case MPI26_MFGPAGE_DEVID_CFG_SEC_3916: 11996 case MPI26_MFGPAGE_DEVID_HARD_SEC_3916: 11997 case MPI26_MFGPAGE_DEVID_CFG_SEC_3816: 11998 case MPI26_MFGPAGE_DEVID_HARD_SEC_3816: 11999 case MPI26_MFGPAGE_DEVID_INVALID0_3916: 12000 case MPI26_MFGPAGE_DEVID_INVALID1_3916: 12001 case MPI26_MFGPAGE_DEVID_INVALID0_3816: 12002 case MPI26_MFGPAGE_DEVID_INVALID1_3816: 12003 return MPI26_VERSION; 12004 } 12005 return 0; 12006 } 12007 12008 /** 12009 * _scsih_probe - attach and add scsi host 12010 * @pdev: PCI device struct 12011 * @id: pci device id 12012 * 12013 * Return: 0 success, anything else error. 12014 */ 12015 static int 12016 _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id) 12017 { 12018 struct MPT3SAS_ADAPTER *ioc; 12019 struct Scsi_Host *shost = NULL; 12020 int rv; 12021 u16 hba_mpi_version; 12022 int iopoll_q_count = 0; 12023 12024 /* Determine in which MPI version class this pci device belongs */ 12025 hba_mpi_version = _scsih_determine_hba_mpi_version(pdev); 12026 if (hba_mpi_version == 0) 12027 return -ENODEV; 12028 12029 /* Enumerate only SAS 2.0 HBA's if hbas_to_enumerate is one, 12030 * for other generation HBA's return with -ENODEV 12031 */ 12032 if ((hbas_to_enumerate == 1) && (hba_mpi_version != MPI2_VERSION)) 12033 return -ENODEV; 12034 12035 /* Enumerate only SAS 3.0 HBA's if hbas_to_enumerate is two, 12036 * for other generation HBA's return with -ENODEV 12037 */ 12038 if ((hbas_to_enumerate == 2) && (!(hba_mpi_version == MPI25_VERSION 12039 || hba_mpi_version == MPI26_VERSION))) 12040 return -ENODEV; 12041 12042 switch (hba_mpi_version) { 12043 case MPI2_VERSION: 12044 pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | 12045 PCIE_LINK_STATE_L1 | PCIE_LINK_STATE_CLKPM); 12046 /* Use mpt2sas driver host template for SAS 2.0 HBA's */ 12047 shost = scsi_host_alloc(&mpt2sas_driver_template, 12048 sizeof(struct MPT3SAS_ADAPTER)); 12049 if (!shost) 12050 return -ENODEV; 12051 ioc = shost_priv(shost); 12052 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER)); 12053 ioc->hba_mpi_version_belonged = hba_mpi_version; 12054 ioc->id = mpt2_ids++; 12055 sprintf(ioc->driver_name, "%s", MPT2SAS_DRIVER_NAME); 12056 switch (pdev->device) { 12057 case MPI2_MFGPAGE_DEVID_SSS6200: 12058 ioc->is_warpdrive = 1; 12059 ioc->hide_ir_msg = 1; 12060 break; 12061 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP: 12062 case MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1: 12063 ioc->is_mcpu_endpoint = 1; 12064 break; 12065 default: 12066 ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS; 12067 break; 12068 } 12069 12070 if (multipath_on_hba == -1 || multipath_on_hba == 0) 12071 ioc->multipath_on_hba = 0; 12072 else 12073 ioc->multipath_on_hba = 1; 12074 12075 break; 12076 case MPI25_VERSION: 12077 case MPI26_VERSION: 12078 /* Use mpt3sas driver host template for SAS 3.0 HBA's */ 12079 shost = scsi_host_alloc(&mpt3sas_driver_template, 12080 sizeof(struct MPT3SAS_ADAPTER)); 12081 if (!shost) 12082 return -ENODEV; 12083 ioc = shost_priv(shost); 12084 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER)); 12085 ioc->hba_mpi_version_belonged = hba_mpi_version; 12086 ioc->id = mpt3_ids++; 12087 sprintf(ioc->driver_name, "%s", MPT3SAS_DRIVER_NAME); 12088 switch (pdev->device) { 12089 case MPI26_MFGPAGE_DEVID_SAS3508: 12090 case MPI26_MFGPAGE_DEVID_SAS3508_1: 12091 case MPI26_MFGPAGE_DEVID_SAS3408: 12092 case MPI26_MFGPAGE_DEVID_SAS3516: 12093 case MPI26_MFGPAGE_DEVID_SAS3516_1: 12094 case MPI26_MFGPAGE_DEVID_SAS3416: 12095 case MPI26_MFGPAGE_DEVID_SAS3616: 12096 case MPI26_ATLAS_PCIe_SWITCH_DEVID: 12097 ioc->is_gen35_ioc = 1; 12098 break; 12099 case MPI26_MFGPAGE_DEVID_INVALID0_3816: 12100 case MPI26_MFGPAGE_DEVID_INVALID0_3916: 12101 dev_err(&pdev->dev, 12102 "HBA with DeviceId 0x%04x, sub VendorId 0x%04x, sub DeviceId 0x%04x is Invalid", 12103 pdev->device, pdev->subsystem_vendor, 12104 pdev->subsystem_device); 12105 return 1; 12106 case MPI26_MFGPAGE_DEVID_INVALID1_3816: 12107 case MPI26_MFGPAGE_DEVID_INVALID1_3916: 12108 dev_err(&pdev->dev, 12109 "HBA with DeviceId 0x%04x, sub VendorId 0x%04x, sub DeviceId 0x%04x is Tampered", 12110 pdev->device, pdev->subsystem_vendor, 12111 pdev->subsystem_device); 12112 return 1; 12113 case MPI26_MFGPAGE_DEVID_CFG_SEC_3816: 12114 case MPI26_MFGPAGE_DEVID_CFG_SEC_3916: 12115 dev_info(&pdev->dev, 12116 "HBA is in Configurable Secure mode\n"); 12117 fallthrough; 12118 case MPI26_MFGPAGE_DEVID_HARD_SEC_3816: 12119 case MPI26_MFGPAGE_DEVID_HARD_SEC_3916: 12120 ioc->is_aero_ioc = ioc->is_gen35_ioc = 1; 12121 break; 12122 default: 12123 ioc->is_gen35_ioc = ioc->is_aero_ioc = 0; 12124 } 12125 if ((ioc->hba_mpi_version_belonged == MPI25_VERSION && 12126 pdev->revision >= SAS3_PCI_DEVICE_C0_REVISION) || 12127 (ioc->hba_mpi_version_belonged == MPI26_VERSION)) { 12128 ioc->combined_reply_queue = 1; 12129 if (ioc->is_gen35_ioc) 12130 ioc->combined_reply_index_count = 12131 MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G35; 12132 else 12133 ioc->combined_reply_index_count = 12134 MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G3; 12135 } 12136 12137 switch (ioc->is_gen35_ioc) { 12138 case 0: 12139 if (multipath_on_hba == -1 || multipath_on_hba == 0) 12140 ioc->multipath_on_hba = 0; 12141 else 12142 ioc->multipath_on_hba = 1; 12143 break; 12144 case 1: 12145 if (multipath_on_hba == -1 || multipath_on_hba > 0) 12146 ioc->multipath_on_hba = 1; 12147 else 12148 ioc->multipath_on_hba = 0; 12149 break; 12150 default: 12151 break; 12152 } 12153 12154 break; 12155 default: 12156 return -ENODEV; 12157 } 12158 12159 INIT_LIST_HEAD(&ioc->list); 12160 spin_lock(&gioc_lock); 12161 list_add_tail(&ioc->list, &mpt3sas_ioc_list); 12162 spin_unlock(&gioc_lock); 12163 ioc->shost = shost; 12164 ioc->pdev = pdev; 12165 ioc->scsi_io_cb_idx = scsi_io_cb_idx; 12166 ioc->tm_cb_idx = tm_cb_idx; 12167 ioc->ctl_cb_idx = ctl_cb_idx; 12168 ioc->base_cb_idx = base_cb_idx; 12169 ioc->port_enable_cb_idx = port_enable_cb_idx; 12170 ioc->transport_cb_idx = transport_cb_idx; 12171 ioc->scsih_cb_idx = scsih_cb_idx; 12172 ioc->config_cb_idx = config_cb_idx; 12173 ioc->tm_tr_cb_idx = tm_tr_cb_idx; 12174 ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx; 12175 ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx; 12176 ioc->logging_level = logging_level; 12177 ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds; 12178 /* Host waits for minimum of six seconds */ 12179 ioc->max_shutdown_latency = IO_UNIT_CONTROL_SHUTDOWN_TIMEOUT; 12180 /* 12181 * Enable MEMORY MOVE support flag. 12182 */ 12183 ioc->drv_support_bitmap |= MPT_DRV_SUPPORT_BITMAP_MEMMOVE; 12184 /* Enable ADDITIONAL QUERY support flag. */ 12185 ioc->drv_support_bitmap |= MPT_DRV_SUPPORT_BITMAP_ADDNLQUERY; 12186 12187 ioc->enable_sdev_max_qd = enable_sdev_max_qd; 12188 12189 /* misc semaphores and spin locks */ 12190 mutex_init(&ioc->reset_in_progress_mutex); 12191 /* initializing pci_access_mutex lock */ 12192 mutex_init(&ioc->pci_access_mutex); 12193 spin_lock_init(&ioc->ioc_reset_in_progress_lock); 12194 spin_lock_init(&ioc->scsi_lookup_lock); 12195 spin_lock_init(&ioc->sas_device_lock); 12196 spin_lock_init(&ioc->sas_node_lock); 12197 spin_lock_init(&ioc->fw_event_lock); 12198 spin_lock_init(&ioc->raid_device_lock); 12199 spin_lock_init(&ioc->pcie_device_lock); 12200 spin_lock_init(&ioc->diag_trigger_lock); 12201 12202 INIT_LIST_HEAD(&ioc->sas_device_list); 12203 INIT_LIST_HEAD(&ioc->sas_device_init_list); 12204 INIT_LIST_HEAD(&ioc->sas_expander_list); 12205 INIT_LIST_HEAD(&ioc->enclosure_list); 12206 INIT_LIST_HEAD(&ioc->pcie_device_list); 12207 INIT_LIST_HEAD(&ioc->pcie_device_init_list); 12208 INIT_LIST_HEAD(&ioc->fw_event_list); 12209 INIT_LIST_HEAD(&ioc->raid_device_list); 12210 INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list); 12211 INIT_LIST_HEAD(&ioc->delayed_tr_list); 12212 INIT_LIST_HEAD(&ioc->delayed_sc_list); 12213 INIT_LIST_HEAD(&ioc->delayed_event_ack_list); 12214 INIT_LIST_HEAD(&ioc->delayed_tr_volume_list); 12215 INIT_LIST_HEAD(&ioc->reply_queue_list); 12216 INIT_LIST_HEAD(&ioc->port_table_list); 12217 12218 sprintf(ioc->name, "%s_cm%d", ioc->driver_name, ioc->id); 12219 12220 /* init shost parameters */ 12221 shost->max_cmd_len = 32; 12222 shost->max_lun = max_lun; 12223 shost->transportt = mpt3sas_transport_template; 12224 shost->unique_id = ioc->id; 12225 12226 if (ioc->is_mcpu_endpoint) { 12227 /* mCPU MPI support 64K max IO */ 12228 shost->max_sectors = 128; 12229 ioc_info(ioc, "The max_sectors value is set to %d\n", 12230 shost->max_sectors); 12231 } else { 12232 if (max_sectors != 0xFFFF) { 12233 if (max_sectors < 64) { 12234 shost->max_sectors = 64; 12235 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767. Assigning value of 64.\n", 12236 max_sectors); 12237 } else if (max_sectors > 32767) { 12238 shost->max_sectors = 32767; 12239 ioc_warn(ioc, "Invalid value %d passed for max_sectors, range is 64 to 32767.Assigning default value of 32767.\n", 12240 max_sectors); 12241 } else { 12242 shost->max_sectors = max_sectors & 0xFFFE; 12243 ioc_info(ioc, "The max_sectors value is set to %d\n", 12244 shost->max_sectors); 12245 } 12246 } 12247 } 12248 /* register EEDP capabilities with SCSI layer */ 12249 if (prot_mask >= 0) 12250 scsi_host_set_prot(shost, (prot_mask & 0x07)); 12251 else 12252 scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION 12253 | SHOST_DIF_TYPE2_PROTECTION 12254 | SHOST_DIF_TYPE3_PROTECTION); 12255 12256 scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC); 12257 12258 /* event thread */ 12259 snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name), 12260 "fw_event_%s%d", ioc->driver_name, ioc->id); 12261 ioc->firmware_event_thread = alloc_ordered_workqueue( 12262 ioc->firmware_event_name, 0); 12263 if (!ioc->firmware_event_thread) { 12264 ioc_err(ioc, "failure at %s:%d/%s()!\n", 12265 __FILE__, __LINE__, __func__); 12266 rv = -ENODEV; 12267 goto out_thread_fail; 12268 } 12269 12270 shost->host_tagset = 0; 12271 12272 if (ioc->is_gen35_ioc && host_tagset_enable) 12273 shost->host_tagset = 1; 12274 12275 ioc->is_driver_loading = 1; 12276 if ((mpt3sas_base_attach(ioc))) { 12277 ioc_err(ioc, "failure at %s:%d/%s()!\n", 12278 __FILE__, __LINE__, __func__); 12279 rv = -ENODEV; 12280 goto out_attach_fail; 12281 } 12282 12283 if (ioc->is_warpdrive) { 12284 if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_EXPOSE_ALL_DISKS) 12285 ioc->hide_drives = 0; 12286 else if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_HIDE_ALL_DISKS) 12287 ioc->hide_drives = 1; 12288 else { 12289 if (mpt3sas_get_num_volumes(ioc)) 12290 ioc->hide_drives = 1; 12291 else 12292 ioc->hide_drives = 0; 12293 } 12294 } else 12295 ioc->hide_drives = 0; 12296 12297 shost->nr_hw_queues = 1; 12298 12299 if (shost->host_tagset) { 12300 shost->nr_hw_queues = 12301 ioc->reply_queue_count - ioc->high_iops_queues; 12302 12303 iopoll_q_count = 12304 ioc->reply_queue_count - ioc->iopoll_q_start_index; 12305 12306 shost->nr_maps = iopoll_q_count ? 3 : 1; 12307 12308 dev_info(&ioc->pdev->dev, 12309 "Max SCSIIO MPT commands: %d shared with nr_hw_queues = %d\n", 12310 shost->can_queue, shost->nr_hw_queues); 12311 } 12312 12313 rv = scsi_add_host(shost, &pdev->dev); 12314 if (rv) { 12315 ioc_err(ioc, "failure at %s:%d/%s()!\n", 12316 __FILE__, __LINE__, __func__); 12317 goto out_add_shost_fail; 12318 } 12319 12320 scsi_scan_host(shost); 12321 mpt3sas_setup_debugfs(ioc); 12322 return 0; 12323 out_add_shost_fail: 12324 mpt3sas_base_detach(ioc); 12325 out_attach_fail: 12326 destroy_workqueue(ioc->firmware_event_thread); 12327 out_thread_fail: 12328 spin_lock(&gioc_lock); 12329 list_del(&ioc->list); 12330 spin_unlock(&gioc_lock); 12331 scsi_host_put(shost); 12332 return rv; 12333 } 12334 12335 /** 12336 * scsih_suspend - power management suspend main entry point 12337 * @dev: Device struct 12338 * 12339 * Return: 0 success, anything else error. 12340 */ 12341 static int __maybe_unused 12342 scsih_suspend(struct device *dev) 12343 { 12344 struct pci_dev *pdev = to_pci_dev(dev); 12345 struct Scsi_Host *shost; 12346 struct MPT3SAS_ADAPTER *ioc; 12347 int rc; 12348 12349 rc = _scsih_get_shost_and_ioc(pdev, &shost, &ioc); 12350 if (rc) 12351 return rc; 12352 12353 mpt3sas_base_stop_watchdog(ioc); 12354 flush_scheduled_work(); 12355 scsi_block_requests(shost); 12356 _scsih_nvme_shutdown(ioc); 12357 ioc_info(ioc, "pdev=0x%p, slot=%s, entering operating state\n", 12358 pdev, pci_name(pdev)); 12359 12360 mpt3sas_base_free_resources(ioc); 12361 return 0; 12362 } 12363 12364 /** 12365 * scsih_resume - power management resume main entry point 12366 * @dev: Device struct 12367 * 12368 * Return: 0 success, anything else error. 12369 */ 12370 static int __maybe_unused 12371 scsih_resume(struct device *dev) 12372 { 12373 struct pci_dev *pdev = to_pci_dev(dev); 12374 struct Scsi_Host *shost; 12375 struct MPT3SAS_ADAPTER *ioc; 12376 pci_power_t device_state = pdev->current_state; 12377 int r; 12378 12379 r = _scsih_get_shost_and_ioc(pdev, &shost, &ioc); 12380 if (r) 12381 return r; 12382 12383 ioc_info(ioc, "pdev=0x%p, slot=%s, previous operating state [D%d]\n", 12384 pdev, pci_name(pdev), device_state); 12385 12386 ioc->pdev = pdev; 12387 r = mpt3sas_base_map_resources(ioc); 12388 if (r) 12389 return r; 12390 ioc_info(ioc, "Issuing Hard Reset as part of OS Resume\n"); 12391 mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET); 12392 scsi_unblock_requests(shost); 12393 mpt3sas_base_start_watchdog(ioc); 12394 return 0; 12395 } 12396 12397 /** 12398 * scsih_pci_error_detected - Called when a PCI error is detected. 12399 * @pdev: PCI device struct 12400 * @state: PCI channel state 12401 * 12402 * Description: Called when a PCI error is detected. 12403 * 12404 * Return: PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT. 12405 */ 12406 static pci_ers_result_t 12407 scsih_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state) 12408 { 12409 struct Scsi_Host *shost; 12410 struct MPT3SAS_ADAPTER *ioc; 12411 12412 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 12413 return PCI_ERS_RESULT_DISCONNECT; 12414 12415 ioc_info(ioc, "PCI error: detected callback, state(%d)!!\n", state); 12416 12417 switch (state) { 12418 case pci_channel_io_normal: 12419 return PCI_ERS_RESULT_CAN_RECOVER; 12420 case pci_channel_io_frozen: 12421 /* Fatal error, prepare for slot reset */ 12422 ioc->pci_error_recovery = 1; 12423 scsi_block_requests(ioc->shost); 12424 mpt3sas_base_stop_watchdog(ioc); 12425 mpt3sas_base_free_resources(ioc); 12426 return PCI_ERS_RESULT_NEED_RESET; 12427 case pci_channel_io_perm_failure: 12428 /* Permanent error, prepare for device removal */ 12429 ioc->pci_error_recovery = 1; 12430 mpt3sas_base_stop_watchdog(ioc); 12431 mpt3sas_base_pause_mq_polling(ioc); 12432 _scsih_flush_running_cmds(ioc); 12433 return PCI_ERS_RESULT_DISCONNECT; 12434 } 12435 return PCI_ERS_RESULT_NEED_RESET; 12436 } 12437 12438 /** 12439 * scsih_pci_slot_reset - Called when PCI slot has been reset. 12440 * @pdev: PCI device struct 12441 * 12442 * Description: This routine is called by the pci error recovery 12443 * code after the PCI slot has been reset, just before we 12444 * should resume normal operations. 12445 */ 12446 static pci_ers_result_t 12447 scsih_pci_slot_reset(struct pci_dev *pdev) 12448 { 12449 struct Scsi_Host *shost; 12450 struct MPT3SAS_ADAPTER *ioc; 12451 int rc; 12452 12453 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 12454 return PCI_ERS_RESULT_DISCONNECT; 12455 12456 ioc_info(ioc, "PCI error: slot reset callback!!\n"); 12457 12458 ioc->pci_error_recovery = 0; 12459 ioc->pdev = pdev; 12460 pci_restore_state(pdev); 12461 rc = mpt3sas_base_map_resources(ioc); 12462 if (rc) 12463 return PCI_ERS_RESULT_DISCONNECT; 12464 12465 ioc_info(ioc, "Issuing Hard Reset as part of PCI Slot Reset\n"); 12466 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 12467 12468 ioc_warn(ioc, "hard reset: %s\n", 12469 (rc == 0) ? "success" : "failed"); 12470 12471 if (!rc) 12472 return PCI_ERS_RESULT_RECOVERED; 12473 else 12474 return PCI_ERS_RESULT_DISCONNECT; 12475 } 12476 12477 /** 12478 * scsih_pci_resume() - resume normal ops after PCI reset 12479 * @pdev: pointer to PCI device 12480 * 12481 * Called when the error recovery driver tells us that its 12482 * OK to resume normal operation. Use completion to allow 12483 * halted scsi ops to resume. 12484 */ 12485 static void 12486 scsih_pci_resume(struct pci_dev *pdev) 12487 { 12488 struct Scsi_Host *shost; 12489 struct MPT3SAS_ADAPTER *ioc; 12490 12491 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 12492 return; 12493 12494 ioc_info(ioc, "PCI error: resume callback!!\n"); 12495 12496 mpt3sas_base_start_watchdog(ioc); 12497 scsi_unblock_requests(ioc->shost); 12498 } 12499 12500 /** 12501 * scsih_pci_mmio_enabled - Enable MMIO and dump debug registers 12502 * @pdev: pointer to PCI device 12503 */ 12504 static pci_ers_result_t 12505 scsih_pci_mmio_enabled(struct pci_dev *pdev) 12506 { 12507 struct Scsi_Host *shost; 12508 struct MPT3SAS_ADAPTER *ioc; 12509 12510 if (_scsih_get_shost_and_ioc(pdev, &shost, &ioc)) 12511 return PCI_ERS_RESULT_DISCONNECT; 12512 12513 ioc_info(ioc, "PCI error: mmio enabled callback!!\n"); 12514 12515 /* TODO - dump whatever for debugging purposes */ 12516 12517 /* This called only if scsih_pci_error_detected returns 12518 * PCI_ERS_RESULT_CAN_RECOVER. Read/write to the device still 12519 * works, no need to reset slot. 12520 */ 12521 return PCI_ERS_RESULT_RECOVERED; 12522 } 12523 12524 /** 12525 * scsih_ncq_prio_supp - Check for NCQ command priority support 12526 * @sdev: scsi device struct 12527 * 12528 * This is called when a user indicates they would like to enable 12529 * ncq command priorities. This works only on SATA devices. 12530 */ 12531 bool scsih_ncq_prio_supp(struct scsi_device *sdev) 12532 { 12533 unsigned char *buf; 12534 bool ncq_prio_supp = false; 12535 12536 if (!scsi_device_supports_vpd(sdev)) 12537 return ncq_prio_supp; 12538 12539 buf = kmalloc(SCSI_VPD_PG_LEN, GFP_KERNEL); 12540 if (!buf) 12541 return ncq_prio_supp; 12542 12543 if (!scsi_get_vpd_page(sdev, 0x89, buf, SCSI_VPD_PG_LEN)) 12544 ncq_prio_supp = (buf[213] >> 4) & 1; 12545 12546 kfree(buf); 12547 return ncq_prio_supp; 12548 } 12549 /* 12550 * The pci device ids are defined in mpi/mpi2_cnfg.h. 12551 */ 12552 static const struct pci_device_id mpt3sas_pci_table[] = { 12553 /* Spitfire ~ 2004 */ 12554 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2004, 12555 PCI_ANY_ID, PCI_ANY_ID }, 12556 /* Falcon ~ 2008 */ 12557 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2008, 12558 PCI_ANY_ID, PCI_ANY_ID }, 12559 /* Liberator ~ 2108 */ 12560 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_1, 12561 PCI_ANY_ID, PCI_ANY_ID }, 12562 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_2, 12563 PCI_ANY_ID, PCI_ANY_ID }, 12564 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_3, 12565 PCI_ANY_ID, PCI_ANY_ID }, 12566 /* Meteor ~ 2116 */ 12567 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_1, 12568 PCI_ANY_ID, PCI_ANY_ID }, 12569 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_2, 12570 PCI_ANY_ID, PCI_ANY_ID }, 12571 /* Thunderbolt ~ 2208 */ 12572 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_1, 12573 PCI_ANY_ID, PCI_ANY_ID }, 12574 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_2, 12575 PCI_ANY_ID, PCI_ANY_ID }, 12576 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_3, 12577 PCI_ANY_ID, PCI_ANY_ID }, 12578 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_4, 12579 PCI_ANY_ID, PCI_ANY_ID }, 12580 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_5, 12581 PCI_ANY_ID, PCI_ANY_ID }, 12582 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_6, 12583 PCI_ANY_ID, PCI_ANY_ID }, 12584 /* Mustang ~ 2308 */ 12585 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_1, 12586 PCI_ANY_ID, PCI_ANY_ID }, 12587 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_2, 12588 PCI_ANY_ID, PCI_ANY_ID }, 12589 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_3, 12590 PCI_ANY_ID, PCI_ANY_ID }, 12591 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP, 12592 PCI_ANY_ID, PCI_ANY_ID }, 12593 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SWITCH_MPI_EP_1, 12594 PCI_ANY_ID, PCI_ANY_ID }, 12595 /* SSS6200 */ 12596 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SSS6200, 12597 PCI_ANY_ID, PCI_ANY_ID }, 12598 /* Fury ~ 3004 and 3008 */ 12599 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3004, 12600 PCI_ANY_ID, PCI_ANY_ID }, 12601 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3008, 12602 PCI_ANY_ID, PCI_ANY_ID }, 12603 /* Invader ~ 3108 */ 12604 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_1, 12605 PCI_ANY_ID, PCI_ANY_ID }, 12606 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_2, 12607 PCI_ANY_ID, PCI_ANY_ID }, 12608 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_5, 12609 PCI_ANY_ID, PCI_ANY_ID }, 12610 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_6, 12611 PCI_ANY_ID, PCI_ANY_ID }, 12612 /* Cutlass ~ 3216 and 3224 */ 12613 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3216, 12614 PCI_ANY_ID, PCI_ANY_ID }, 12615 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3224, 12616 PCI_ANY_ID, PCI_ANY_ID }, 12617 /* Intruder ~ 3316 and 3324 */ 12618 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_1, 12619 PCI_ANY_ID, PCI_ANY_ID }, 12620 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_2, 12621 PCI_ANY_ID, PCI_ANY_ID }, 12622 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_3, 12623 PCI_ANY_ID, PCI_ANY_ID }, 12624 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_4, 12625 PCI_ANY_ID, PCI_ANY_ID }, 12626 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_1, 12627 PCI_ANY_ID, PCI_ANY_ID }, 12628 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_2, 12629 PCI_ANY_ID, PCI_ANY_ID }, 12630 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_3, 12631 PCI_ANY_ID, PCI_ANY_ID }, 12632 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_4, 12633 PCI_ANY_ID, PCI_ANY_ID }, 12634 /* Ventura, Crusader, Harpoon & Tomcat ~ 3516, 3416, 3508 & 3408*/ 12635 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508, 12636 PCI_ANY_ID, PCI_ANY_ID }, 12637 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508_1, 12638 PCI_ANY_ID, PCI_ANY_ID }, 12639 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3408, 12640 PCI_ANY_ID, PCI_ANY_ID }, 12641 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516, 12642 PCI_ANY_ID, PCI_ANY_ID }, 12643 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516_1, 12644 PCI_ANY_ID, PCI_ANY_ID }, 12645 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3416, 12646 PCI_ANY_ID, PCI_ANY_ID }, 12647 /* Mercator ~ 3616*/ 12648 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3616, 12649 PCI_ANY_ID, PCI_ANY_ID }, 12650 12651 /* Aero SI 0x00E1 Configurable Secure 12652 * 0x00E2 Hard Secure 12653 */ 12654 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_CFG_SEC_3916, 12655 PCI_ANY_ID, PCI_ANY_ID }, 12656 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_HARD_SEC_3916, 12657 PCI_ANY_ID, PCI_ANY_ID }, 12658 12659 /* 12660 * Aero SI –> 0x00E0 Invalid, 0x00E3 Tampered 12661 */ 12662 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_INVALID0_3916, 12663 PCI_ANY_ID, PCI_ANY_ID }, 12664 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_INVALID1_3916, 12665 PCI_ANY_ID, PCI_ANY_ID }, 12666 12667 /* Atlas PCIe Switch Management Port */ 12668 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_ATLAS_PCIe_SWITCH_DEVID, 12669 PCI_ANY_ID, PCI_ANY_ID }, 12670 12671 /* Sea SI 0x00E5 Configurable Secure 12672 * 0x00E6 Hard Secure 12673 */ 12674 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_CFG_SEC_3816, 12675 PCI_ANY_ID, PCI_ANY_ID }, 12676 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_HARD_SEC_3816, 12677 PCI_ANY_ID, PCI_ANY_ID }, 12678 12679 /* 12680 * Sea SI –> 0x00E4 Invalid, 0x00E7 Tampered 12681 */ 12682 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_INVALID0_3816, 12683 PCI_ANY_ID, PCI_ANY_ID }, 12684 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_INVALID1_3816, 12685 PCI_ANY_ID, PCI_ANY_ID }, 12686 12687 {0} /* Terminating entry */ 12688 }; 12689 MODULE_DEVICE_TABLE(pci, mpt3sas_pci_table); 12690 12691 static struct pci_error_handlers _mpt3sas_err_handler = { 12692 .error_detected = scsih_pci_error_detected, 12693 .mmio_enabled = scsih_pci_mmio_enabled, 12694 .slot_reset = scsih_pci_slot_reset, 12695 .resume = scsih_pci_resume, 12696 }; 12697 12698 static SIMPLE_DEV_PM_OPS(scsih_pm_ops, scsih_suspend, scsih_resume); 12699 12700 static struct pci_driver mpt3sas_driver = { 12701 .name = MPT3SAS_DRIVER_NAME, 12702 .id_table = mpt3sas_pci_table, 12703 .probe = _scsih_probe, 12704 .remove = scsih_remove, 12705 .shutdown = scsih_shutdown, 12706 .err_handler = &_mpt3sas_err_handler, 12707 .driver.pm = &scsih_pm_ops, 12708 }; 12709 12710 /** 12711 * scsih_init - main entry point for this driver. 12712 * 12713 * Return: 0 success, anything else error. 12714 */ 12715 static int 12716 scsih_init(void) 12717 { 12718 mpt2_ids = 0; 12719 mpt3_ids = 0; 12720 12721 mpt3sas_base_initialize_callback_handler(); 12722 12723 /* queuecommand callback hander */ 12724 scsi_io_cb_idx = mpt3sas_base_register_callback_handler(_scsih_io_done); 12725 12726 /* task management callback handler */ 12727 tm_cb_idx = mpt3sas_base_register_callback_handler(_scsih_tm_done); 12728 12729 /* base internal commands callback handler */ 12730 base_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_base_done); 12731 port_enable_cb_idx = mpt3sas_base_register_callback_handler( 12732 mpt3sas_port_enable_done); 12733 12734 /* transport internal commands callback handler */ 12735 transport_cb_idx = mpt3sas_base_register_callback_handler( 12736 mpt3sas_transport_done); 12737 12738 /* scsih internal commands callback handler */ 12739 scsih_cb_idx = mpt3sas_base_register_callback_handler(_scsih_done); 12740 12741 /* configuration page API internal commands callback handler */ 12742 config_cb_idx = mpt3sas_base_register_callback_handler( 12743 mpt3sas_config_done); 12744 12745 /* ctl module callback handler */ 12746 ctl_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_ctl_done); 12747 12748 tm_tr_cb_idx = mpt3sas_base_register_callback_handler( 12749 _scsih_tm_tr_complete); 12750 12751 tm_tr_volume_cb_idx = mpt3sas_base_register_callback_handler( 12752 _scsih_tm_volume_tr_complete); 12753 12754 tm_sas_control_cb_idx = mpt3sas_base_register_callback_handler( 12755 _scsih_sas_control_complete); 12756 12757 mpt3sas_init_debugfs(); 12758 return 0; 12759 } 12760 12761 /** 12762 * scsih_exit - exit point for this driver (when it is a module). 12763 * 12764 * Return: 0 success, anything else error. 12765 */ 12766 static void 12767 scsih_exit(void) 12768 { 12769 12770 mpt3sas_base_release_callback_handler(scsi_io_cb_idx); 12771 mpt3sas_base_release_callback_handler(tm_cb_idx); 12772 mpt3sas_base_release_callback_handler(base_cb_idx); 12773 mpt3sas_base_release_callback_handler(port_enable_cb_idx); 12774 mpt3sas_base_release_callback_handler(transport_cb_idx); 12775 mpt3sas_base_release_callback_handler(scsih_cb_idx); 12776 mpt3sas_base_release_callback_handler(config_cb_idx); 12777 mpt3sas_base_release_callback_handler(ctl_cb_idx); 12778 12779 mpt3sas_base_release_callback_handler(tm_tr_cb_idx); 12780 mpt3sas_base_release_callback_handler(tm_tr_volume_cb_idx); 12781 mpt3sas_base_release_callback_handler(tm_sas_control_cb_idx); 12782 12783 /* raid transport support */ 12784 if (hbas_to_enumerate != 1) 12785 raid_class_release(mpt3sas_raid_template); 12786 if (hbas_to_enumerate != 2) 12787 raid_class_release(mpt2sas_raid_template); 12788 sas_release_transport(mpt3sas_transport_template); 12789 mpt3sas_exit_debugfs(); 12790 } 12791 12792 /** 12793 * _mpt3sas_init - main entry point for this driver. 12794 * 12795 * Return: 0 success, anything else error. 12796 */ 12797 static int __init 12798 _mpt3sas_init(void) 12799 { 12800 int error; 12801 12802 pr_info("%s version %s loaded\n", MPT3SAS_DRIVER_NAME, 12803 MPT3SAS_DRIVER_VERSION); 12804 12805 mpt3sas_transport_template = 12806 sas_attach_transport(&mpt3sas_transport_functions); 12807 if (!mpt3sas_transport_template) 12808 return -ENODEV; 12809 12810 /* No need attach mpt3sas raid functions template 12811 * if hbas_to_enumarate value is one. 12812 */ 12813 if (hbas_to_enumerate != 1) { 12814 mpt3sas_raid_template = 12815 raid_class_attach(&mpt3sas_raid_functions); 12816 if (!mpt3sas_raid_template) { 12817 sas_release_transport(mpt3sas_transport_template); 12818 return -ENODEV; 12819 } 12820 } 12821 12822 /* No need to attach mpt2sas raid functions template 12823 * if hbas_to_enumarate value is two 12824 */ 12825 if (hbas_to_enumerate != 2) { 12826 mpt2sas_raid_template = 12827 raid_class_attach(&mpt2sas_raid_functions); 12828 if (!mpt2sas_raid_template) { 12829 sas_release_transport(mpt3sas_transport_template); 12830 return -ENODEV; 12831 } 12832 } 12833 12834 error = scsih_init(); 12835 if (error) { 12836 scsih_exit(); 12837 return error; 12838 } 12839 12840 mpt3sas_ctl_init(hbas_to_enumerate); 12841 12842 error = pci_register_driver(&mpt3sas_driver); 12843 if (error) 12844 scsih_exit(); 12845 12846 return error; 12847 } 12848 12849 /** 12850 * _mpt3sas_exit - exit point for this driver (when it is a module). 12851 * 12852 */ 12853 static void __exit 12854 _mpt3sas_exit(void) 12855 { 12856 pr_info("mpt3sas version %s unloading\n", 12857 MPT3SAS_DRIVER_VERSION); 12858 12859 mpt3sas_ctl_exit(hbas_to_enumerate); 12860 12861 pci_unregister_driver(&mpt3sas_driver); 12862 12863 scsih_exit(); 12864 } 12865 12866 module_init(_mpt3sas_init); 12867 module_exit(_mpt3sas_exit); 12868