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