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