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