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