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_nowait(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_nowait(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_nowait(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_nowait(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 4681 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 4682 4683 if (ioc->broadcast_aen_busy || ioc->pci_error_recovery || 4684 ioc->got_task_abort_from_ioctl) 4685 scmd = _scsih_scsi_lookup_get_clear(ioc, smid); 4686 else 4687 scmd = __scsih_scsi_lookup_get_clear(ioc, smid); 4688 4689 if (scmd == NULL) 4690 return 1; 4691 4692 _scsih_set_satl_pending(scmd, false); 4693 4694 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 4695 4696 if (mpi_reply == NULL) { 4697 scmd->result = DID_OK << 16; 4698 goto out; 4699 } 4700 4701 sas_device_priv_data = scmd->device->hostdata; 4702 if (!sas_device_priv_data || !sas_device_priv_data->sas_target || 4703 sas_device_priv_data->sas_target->deleted) { 4704 scmd->result = DID_NO_CONNECT << 16; 4705 goto out; 4706 } 4707 ioc_status = le16_to_cpu(mpi_reply->IOCStatus); 4708 4709 /* 4710 * WARPDRIVE: If direct_io is set then it is directIO, 4711 * the failed direct I/O should be redirected to volume 4712 */ 4713 if (mpt3sas_scsi_direct_io_get(ioc, smid) && 4714 ((ioc_status & MPI2_IOCSTATUS_MASK) 4715 != MPI2_IOCSTATUS_SCSI_TASK_TERMINATED)) { 4716 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 4717 ioc->scsi_lookup[smid - 1].scmd = scmd; 4718 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 4719 mpt3sas_scsi_direct_io_set(ioc, smid, 0); 4720 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len); 4721 mpi_request->DevHandle = 4722 cpu_to_le16(sas_device_priv_data->sas_target->handle); 4723 ioc->put_smid_scsi_io(ioc, smid, 4724 sas_device_priv_data->sas_target->handle); 4725 return 0; 4726 } 4727 /* turning off TLR */ 4728 scsi_state = mpi_reply->SCSIState; 4729 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) 4730 response_code = 4731 le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF; 4732 if (!sas_device_priv_data->tlr_snoop_check) { 4733 sas_device_priv_data->tlr_snoop_check++; 4734 if (!ioc->is_warpdrive && 4735 !scsih_is_raid(&scmd->device->sdev_gendev) && 4736 sas_is_tlr_enabled(scmd->device) && 4737 response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) { 4738 sas_disable_tlr(scmd->device); 4739 sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n"); 4740 } 4741 } 4742 4743 xfer_cnt = le32_to_cpu(mpi_reply->TransferCount); 4744 scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt); 4745 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) 4746 log_info = le32_to_cpu(mpi_reply->IOCLogInfo); 4747 else 4748 log_info = 0; 4749 ioc_status &= MPI2_IOCSTATUS_MASK; 4750 scsi_status = mpi_reply->SCSIStatus; 4751 4752 if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 && 4753 (scsi_status == MPI2_SCSI_STATUS_BUSY || 4754 scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT || 4755 scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) { 4756 ioc_status = MPI2_IOCSTATUS_SUCCESS; 4757 } 4758 4759 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) { 4760 struct sense_info data; 4761 const void *sense_data = mpt3sas_base_get_sense_buffer(ioc, 4762 smid); 4763 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE, 4764 le32_to_cpu(mpi_reply->SenseCount)); 4765 memcpy(scmd->sense_buffer, sense_data, sz); 4766 _scsih_normalize_sense(scmd->sense_buffer, &data); 4767 /* failure prediction threshold exceeded */ 4768 if (data.asc == 0x5D) 4769 _scsih_smart_predicted_fault(ioc, 4770 le16_to_cpu(mpi_reply->DevHandle)); 4771 mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq); 4772 4773 if ((ioc->logging_level & MPT_DEBUG_REPLY) && 4774 ((scmd->sense_buffer[2] == UNIT_ATTENTION) || 4775 (scmd->sense_buffer[2] == MEDIUM_ERROR) || 4776 (scmd->sense_buffer[2] == HARDWARE_ERROR))) 4777 _scsih_scsi_ioc_info(ioc, scmd, mpi_reply, smid); 4778 } 4779 switch (ioc_status) { 4780 case MPI2_IOCSTATUS_BUSY: 4781 case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES: 4782 scmd->result = SAM_STAT_BUSY; 4783 break; 4784 4785 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE: 4786 scmd->result = DID_NO_CONNECT << 16; 4787 break; 4788 4789 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED: 4790 if (sas_device_priv_data->block) { 4791 scmd->result = DID_TRANSPORT_DISRUPTED << 16; 4792 goto out; 4793 } 4794 if (log_info == 0x31110630) { 4795 if (scmd->retries > 2) { 4796 scmd->result = DID_NO_CONNECT << 16; 4797 scsi_device_set_state(scmd->device, 4798 SDEV_OFFLINE); 4799 } else { 4800 scmd->result = DID_SOFT_ERROR << 16; 4801 scmd->device->expecting_cc_ua = 1; 4802 } 4803 break; 4804 } else if (log_info == VIRTUAL_IO_FAILED_RETRY) { 4805 scmd->result = DID_RESET << 16; 4806 break; 4807 } 4808 scmd->result = DID_SOFT_ERROR << 16; 4809 break; 4810 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED: 4811 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED: 4812 scmd->result = DID_RESET << 16; 4813 break; 4814 4815 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: 4816 if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt)) 4817 scmd->result = DID_SOFT_ERROR << 16; 4818 else 4819 scmd->result = (DID_OK << 16) | scsi_status; 4820 break; 4821 4822 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN: 4823 scmd->result = (DID_OK << 16) | scsi_status; 4824 4825 if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)) 4826 break; 4827 4828 if (xfer_cnt < scmd->underflow) { 4829 if (scsi_status == SAM_STAT_BUSY) 4830 scmd->result = SAM_STAT_BUSY; 4831 else 4832 scmd->result = DID_SOFT_ERROR << 16; 4833 } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED | 4834 MPI2_SCSI_STATE_NO_SCSI_STATUS)) 4835 scmd->result = DID_SOFT_ERROR << 16; 4836 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED) 4837 scmd->result = DID_RESET << 16; 4838 else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) { 4839 mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID; 4840 mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION; 4841 scmd->result = (DRIVER_SENSE << 24) | 4842 SAM_STAT_CHECK_CONDITION; 4843 scmd->sense_buffer[0] = 0x70; 4844 scmd->sense_buffer[2] = ILLEGAL_REQUEST; 4845 scmd->sense_buffer[12] = 0x20; 4846 scmd->sense_buffer[13] = 0; 4847 } 4848 break; 4849 4850 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN: 4851 scsi_set_resid(scmd, 0); 4852 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR: 4853 case MPI2_IOCSTATUS_SUCCESS: 4854 scmd->result = (DID_OK << 16) | scsi_status; 4855 if (response_code == 4856 MPI2_SCSITASKMGMT_RSP_INVALID_FRAME || 4857 (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED | 4858 MPI2_SCSI_STATE_NO_SCSI_STATUS))) 4859 scmd->result = DID_SOFT_ERROR << 16; 4860 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED) 4861 scmd->result = DID_RESET << 16; 4862 break; 4863 4864 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR: 4865 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR: 4866 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR: 4867 _scsih_eedp_error_handling(scmd, ioc_status); 4868 break; 4869 4870 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR: 4871 case MPI2_IOCSTATUS_INVALID_FUNCTION: 4872 case MPI2_IOCSTATUS_INVALID_SGL: 4873 case MPI2_IOCSTATUS_INTERNAL_ERROR: 4874 case MPI2_IOCSTATUS_INVALID_FIELD: 4875 case MPI2_IOCSTATUS_INVALID_STATE: 4876 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR: 4877 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED: 4878 case MPI2_IOCSTATUS_INSUFFICIENT_POWER: 4879 default: 4880 scmd->result = DID_SOFT_ERROR << 16; 4881 break; 4882 4883 } 4884 4885 if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY)) 4886 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid); 4887 4888 out: 4889 4890 scsi_dma_unmap(scmd); 4891 4892 scmd->scsi_done(scmd); 4893 return 1; 4894 } 4895 4896 /** 4897 * _scsih_sas_host_refresh - refreshing sas host object contents 4898 * @ioc: per adapter object 4899 * Context: user 4900 * 4901 * During port enable, fw will send topology events for every device. Its 4902 * possible that the handles may change from the previous setting, so this 4903 * code keeping handles updating if changed. 4904 * 4905 * Return nothing. 4906 */ 4907 static void 4908 _scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc) 4909 { 4910 u16 sz; 4911 u16 ioc_status; 4912 int i; 4913 Mpi2ConfigReply_t mpi_reply; 4914 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 4915 u16 attached_handle; 4916 u8 link_rate; 4917 4918 dtmprintk(ioc, pr_info(MPT3SAS_FMT 4919 "updating handles for sas_host(0x%016llx)\n", 4920 ioc->name, (unsigned long long)ioc->sas_hba.sas_address)); 4921 4922 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys 4923 * sizeof(Mpi2SasIOUnit0PhyData_t)); 4924 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 4925 if (!sas_iounit_pg0) { 4926 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4927 ioc->name, __FILE__, __LINE__, __func__); 4928 return; 4929 } 4930 4931 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 4932 sas_iounit_pg0, sz)) != 0) 4933 goto out; 4934 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 4935 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 4936 goto out; 4937 for (i = 0; i < ioc->sas_hba.num_phys ; i++) { 4938 link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4; 4939 if (i == 0) 4940 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0-> 4941 PhyData[0].ControllerDevHandle); 4942 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle; 4943 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i]. 4944 AttachedDevHandle); 4945 if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5) 4946 link_rate = MPI2_SAS_NEG_LINK_RATE_1_5; 4947 mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address, 4948 attached_handle, i, link_rate); 4949 } 4950 out: 4951 kfree(sas_iounit_pg0); 4952 } 4953 4954 /** 4955 * _scsih_sas_host_add - create sas host object 4956 * @ioc: per adapter object 4957 * 4958 * Creating host side data object, stored in ioc->sas_hba 4959 * 4960 * Return nothing. 4961 */ 4962 static void 4963 _scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc) 4964 { 4965 int i; 4966 Mpi2ConfigReply_t mpi_reply; 4967 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 4968 Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL; 4969 Mpi2SasPhyPage0_t phy_pg0; 4970 Mpi2SasDevicePage0_t sas_device_pg0; 4971 Mpi2SasEnclosurePage0_t enclosure_pg0; 4972 u16 ioc_status; 4973 u16 sz; 4974 u8 device_missing_delay; 4975 u8 num_phys; 4976 4977 mpt3sas_config_get_number_hba_phys(ioc, &num_phys); 4978 if (!num_phys) { 4979 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4980 ioc->name, __FILE__, __LINE__, __func__); 4981 return; 4982 } 4983 ioc->sas_hba.phy = kcalloc(num_phys, 4984 sizeof(struct _sas_phy), GFP_KERNEL); 4985 if (!ioc->sas_hba.phy) { 4986 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4987 ioc->name, __FILE__, __LINE__, __func__); 4988 goto out; 4989 } 4990 ioc->sas_hba.num_phys = num_phys; 4991 4992 /* sas_iounit page 0 */ 4993 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys * 4994 sizeof(Mpi2SasIOUnit0PhyData_t)); 4995 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 4996 if (!sas_iounit_pg0) { 4997 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4998 ioc->name, __FILE__, __LINE__, __func__); 4999 return; 5000 } 5001 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 5002 sas_iounit_pg0, sz))) { 5003 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5004 ioc->name, __FILE__, __LINE__, __func__); 5005 goto out; 5006 } 5007 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 5008 MPI2_IOCSTATUS_MASK; 5009 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 5010 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5011 ioc->name, __FILE__, __LINE__, __func__); 5012 goto out; 5013 } 5014 5015 /* sas_iounit page 1 */ 5016 sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys * 5017 sizeof(Mpi2SasIOUnit1PhyData_t)); 5018 sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL); 5019 if (!sas_iounit_pg1) { 5020 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5021 ioc->name, __FILE__, __LINE__, __func__); 5022 goto out; 5023 } 5024 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply, 5025 sas_iounit_pg1, sz))) { 5026 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5027 ioc->name, __FILE__, __LINE__, __func__); 5028 goto out; 5029 } 5030 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 5031 MPI2_IOCSTATUS_MASK; 5032 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 5033 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5034 ioc->name, __FILE__, __LINE__, __func__); 5035 goto out; 5036 } 5037 5038 ioc->io_missing_delay = 5039 sas_iounit_pg1->IODeviceMissingDelay; 5040 device_missing_delay = 5041 sas_iounit_pg1->ReportDeviceMissingDelay; 5042 if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16) 5043 ioc->device_missing_delay = (device_missing_delay & 5044 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16; 5045 else 5046 ioc->device_missing_delay = device_missing_delay & 5047 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK; 5048 5049 ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev; 5050 for (i = 0; i < ioc->sas_hba.num_phys ; i++) { 5051 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0, 5052 i))) { 5053 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5054 ioc->name, __FILE__, __LINE__, __func__); 5055 goto out; 5056 } 5057 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 5058 MPI2_IOCSTATUS_MASK; 5059 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 5060 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5061 ioc->name, __FILE__, __LINE__, __func__); 5062 goto out; 5063 } 5064 5065 if (i == 0) 5066 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0-> 5067 PhyData[0].ControllerDevHandle); 5068 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle; 5069 ioc->sas_hba.phy[i].phy_id = i; 5070 mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i], 5071 phy_pg0, ioc->sas_hba.parent_dev); 5072 } 5073 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 5074 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) { 5075 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5076 ioc->name, __FILE__, __LINE__, __func__); 5077 goto out; 5078 } 5079 ioc->sas_hba.enclosure_handle = 5080 le16_to_cpu(sas_device_pg0.EnclosureHandle); 5081 ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 5082 pr_info(MPT3SAS_FMT 5083 "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n", 5084 ioc->name, ioc->sas_hba.handle, 5085 (unsigned long long) ioc->sas_hba.sas_address, 5086 ioc->sas_hba.num_phys) ; 5087 5088 if (ioc->sas_hba.enclosure_handle) { 5089 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply, 5090 &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE, 5091 ioc->sas_hba.enclosure_handle))) 5092 ioc->sas_hba.enclosure_logical_id = 5093 le64_to_cpu(enclosure_pg0.EnclosureLogicalID); 5094 } 5095 5096 out: 5097 kfree(sas_iounit_pg1); 5098 kfree(sas_iounit_pg0); 5099 } 5100 5101 /** 5102 * _scsih_expander_add - creating expander object 5103 * @ioc: per adapter object 5104 * @handle: expander handle 5105 * 5106 * Creating expander object, stored in ioc->sas_expander_list. 5107 * 5108 * Return 0 for success, else error. 5109 */ 5110 static int 5111 _scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle) 5112 { 5113 struct _sas_node *sas_expander; 5114 Mpi2ConfigReply_t mpi_reply; 5115 Mpi2ExpanderPage0_t expander_pg0; 5116 Mpi2ExpanderPage1_t expander_pg1; 5117 Mpi2SasEnclosurePage0_t enclosure_pg0; 5118 u32 ioc_status; 5119 u16 parent_handle; 5120 u64 sas_address, sas_address_parent = 0; 5121 int i; 5122 unsigned long flags; 5123 struct _sas_port *mpt3sas_port = NULL; 5124 5125 int rc = 0; 5126 5127 if (!handle) 5128 return -1; 5129 5130 if (ioc->shost_recovery || ioc->pci_error_recovery) 5131 return -1; 5132 5133 if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0, 5134 MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) { 5135 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5136 ioc->name, __FILE__, __LINE__, __func__); 5137 return -1; 5138 } 5139 5140 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 5141 MPI2_IOCSTATUS_MASK; 5142 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 5143 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5144 ioc->name, __FILE__, __LINE__, __func__); 5145 return -1; 5146 } 5147 5148 /* handle out of order topology events */ 5149 parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle); 5150 if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent) 5151 != 0) { 5152 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5153 ioc->name, __FILE__, __LINE__, __func__); 5154 return -1; 5155 } 5156 if (sas_address_parent != ioc->sas_hba.sas_address) { 5157 spin_lock_irqsave(&ioc->sas_node_lock, flags); 5158 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 5159 sas_address_parent); 5160 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 5161 if (!sas_expander) { 5162 rc = _scsih_expander_add(ioc, parent_handle); 5163 if (rc != 0) 5164 return rc; 5165 } 5166 } 5167 5168 spin_lock_irqsave(&ioc->sas_node_lock, flags); 5169 sas_address = le64_to_cpu(expander_pg0.SASAddress); 5170 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 5171 sas_address); 5172 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 5173 5174 if (sas_expander) 5175 return 0; 5176 5177 sas_expander = kzalloc(sizeof(struct _sas_node), 5178 GFP_KERNEL); 5179 if (!sas_expander) { 5180 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5181 ioc->name, __FILE__, __LINE__, __func__); 5182 return -1; 5183 } 5184 5185 sas_expander->handle = handle; 5186 sas_expander->num_phys = expander_pg0.NumPhys; 5187 sas_expander->sas_address_parent = sas_address_parent; 5188 sas_expander->sas_address = sas_address; 5189 5190 pr_info(MPT3SAS_FMT "expander_add: handle(0x%04x)," \ 5191 " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name, 5192 handle, parent_handle, (unsigned long long) 5193 sas_expander->sas_address, sas_expander->num_phys); 5194 5195 if (!sas_expander->num_phys) 5196 goto out_fail; 5197 sas_expander->phy = kcalloc(sas_expander->num_phys, 5198 sizeof(struct _sas_phy), GFP_KERNEL); 5199 if (!sas_expander->phy) { 5200 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5201 ioc->name, __FILE__, __LINE__, __func__); 5202 rc = -1; 5203 goto out_fail; 5204 } 5205 5206 INIT_LIST_HEAD(&sas_expander->sas_port_list); 5207 mpt3sas_port = mpt3sas_transport_port_add(ioc, handle, 5208 sas_address_parent); 5209 if (!mpt3sas_port) { 5210 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5211 ioc->name, __FILE__, __LINE__, __func__); 5212 rc = -1; 5213 goto out_fail; 5214 } 5215 sas_expander->parent_dev = &mpt3sas_port->rphy->dev; 5216 5217 for (i = 0 ; i < sas_expander->num_phys ; i++) { 5218 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply, 5219 &expander_pg1, i, handle))) { 5220 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5221 ioc->name, __FILE__, __LINE__, __func__); 5222 rc = -1; 5223 goto out_fail; 5224 } 5225 sas_expander->phy[i].handle = handle; 5226 sas_expander->phy[i].phy_id = i; 5227 5228 if ((mpt3sas_transport_add_expander_phy(ioc, 5229 &sas_expander->phy[i], expander_pg1, 5230 sas_expander->parent_dev))) { 5231 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5232 ioc->name, __FILE__, __LINE__, __func__); 5233 rc = -1; 5234 goto out_fail; 5235 } 5236 } 5237 5238 if (sas_expander->enclosure_handle) { 5239 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply, 5240 &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE, 5241 sas_expander->enclosure_handle))) 5242 sas_expander->enclosure_logical_id = 5243 le64_to_cpu(enclosure_pg0.EnclosureLogicalID); 5244 } 5245 5246 _scsih_expander_node_add(ioc, sas_expander); 5247 return 0; 5248 5249 out_fail: 5250 5251 if (mpt3sas_port) 5252 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address, 5253 sas_address_parent); 5254 kfree(sas_expander); 5255 return rc; 5256 } 5257 5258 /** 5259 * mpt3sas_expander_remove - removing expander object 5260 * @ioc: per adapter object 5261 * @sas_address: expander sas_address 5262 * 5263 * Return nothing. 5264 */ 5265 void 5266 mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address) 5267 { 5268 struct _sas_node *sas_expander; 5269 unsigned long flags; 5270 5271 if (ioc->shost_recovery) 5272 return; 5273 5274 spin_lock_irqsave(&ioc->sas_node_lock, flags); 5275 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 5276 sas_address); 5277 if (sas_expander) 5278 list_del(&sas_expander->list); 5279 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 5280 if (sas_expander) 5281 _scsih_expander_node_remove(ioc, sas_expander); 5282 } 5283 5284 /** 5285 * _scsih_done - internal SCSI_IO callback handler. 5286 * @ioc: per adapter object 5287 * @smid: system request message index 5288 * @msix_index: MSIX table index supplied by the OS 5289 * @reply: reply message frame(lower 32bit addr) 5290 * 5291 * Callback handler when sending internal generated SCSI_IO. 5292 * The callback index passed is `ioc->scsih_cb_idx` 5293 * 5294 * Return 1 meaning mf should be freed from _base_interrupt 5295 * 0 means the mf is freed from this function. 5296 */ 5297 static u8 5298 _scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply) 5299 { 5300 MPI2DefaultReply_t *mpi_reply; 5301 5302 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 5303 if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED) 5304 return 1; 5305 if (ioc->scsih_cmds.smid != smid) 5306 return 1; 5307 ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE; 5308 if (mpi_reply) { 5309 memcpy(ioc->scsih_cmds.reply, mpi_reply, 5310 mpi_reply->MsgLength*4); 5311 ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID; 5312 } 5313 ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING; 5314 complete(&ioc->scsih_cmds.done); 5315 return 1; 5316 } 5317 5318 5319 5320 5321 #define MPT3_MAX_LUNS (255) 5322 5323 5324 /** 5325 * _scsih_check_access_status - check access flags 5326 * @ioc: per adapter object 5327 * @sas_address: sas address 5328 * @handle: sas device handle 5329 * @access_flags: errors returned during discovery of the device 5330 * 5331 * Return 0 for success, else failure 5332 */ 5333 static u8 5334 _scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address, 5335 u16 handle, u8 access_status) 5336 { 5337 u8 rc = 1; 5338 char *desc = NULL; 5339 5340 switch (access_status) { 5341 case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS: 5342 case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION: 5343 rc = 0; 5344 break; 5345 case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED: 5346 desc = "sata capability failed"; 5347 break; 5348 case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT: 5349 desc = "sata affiliation conflict"; 5350 break; 5351 case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE: 5352 desc = "route not addressable"; 5353 break; 5354 case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE: 5355 desc = "smp error not addressable"; 5356 break; 5357 case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED: 5358 desc = "device blocked"; 5359 break; 5360 case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED: 5361 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN: 5362 case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT: 5363 case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG: 5364 case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION: 5365 case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER: 5366 case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN: 5367 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN: 5368 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN: 5369 case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION: 5370 case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE: 5371 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX: 5372 desc = "sata initialization failed"; 5373 break; 5374 default: 5375 desc = "unknown"; 5376 break; 5377 } 5378 5379 if (!rc) 5380 return 0; 5381 5382 pr_err(MPT3SAS_FMT 5383 "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n", 5384 ioc->name, desc, (unsigned long long)sas_address, handle); 5385 return rc; 5386 } 5387 5388 /** 5389 * _scsih_check_device - checking device responsiveness 5390 * @ioc: per adapter object 5391 * @parent_sas_address: sas address of parent expander or sas host 5392 * @handle: attached device handle 5393 * @phy_numberv: phy number 5394 * @link_rate: new link rate 5395 * 5396 * Returns nothing. 5397 */ 5398 static void 5399 _scsih_check_device(struct MPT3SAS_ADAPTER *ioc, 5400 u64 parent_sas_address, u16 handle, u8 phy_number, u8 link_rate) 5401 { 5402 Mpi2ConfigReply_t mpi_reply; 5403 Mpi2SasDevicePage0_t sas_device_pg0; 5404 struct _sas_device *sas_device; 5405 u32 ioc_status; 5406 unsigned long flags; 5407 u64 sas_address; 5408 struct scsi_target *starget; 5409 struct MPT3SAS_TARGET *sas_target_priv_data; 5410 u32 device_info; 5411 5412 5413 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 5414 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) 5415 return; 5416 5417 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 5418 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 5419 return; 5420 5421 /* wide port handling ~ we need only handle device once for the phy that 5422 * is matched in sas device page zero 5423 */ 5424 if (phy_number != sas_device_pg0.PhyNum) 5425 return; 5426 5427 /* check if this is end device */ 5428 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 5429 if (!(_scsih_is_end_device(device_info))) 5430 return; 5431 5432 spin_lock_irqsave(&ioc->sas_device_lock, flags); 5433 sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 5434 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 5435 sas_address); 5436 5437 if (!sas_device) 5438 goto out_unlock; 5439 5440 if (unlikely(sas_device->handle != handle)) { 5441 starget = sas_device->starget; 5442 sas_target_priv_data = starget->hostdata; 5443 starget_printk(KERN_INFO, starget, 5444 "handle changed from(0x%04x) to (0x%04x)!!!\n", 5445 sas_device->handle, handle); 5446 sas_target_priv_data->handle = handle; 5447 sas_device->handle = handle; 5448 if (le16_to_cpu(sas_device_pg0.Flags) & 5449 MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) { 5450 sas_device->enclosure_level = 5451 sas_device_pg0.EnclosureLevel; 5452 memcpy(sas_device->connector_name, 5453 sas_device_pg0.ConnectorName, 4); 5454 sas_device->connector_name[4] = '\0'; 5455 } else { 5456 sas_device->enclosure_level = 0; 5457 sas_device->connector_name[0] = '\0'; 5458 } 5459 } 5460 5461 /* check if device is present */ 5462 if (!(le16_to_cpu(sas_device_pg0.Flags) & 5463 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) { 5464 pr_err(MPT3SAS_FMT 5465 "device is not present handle(0x%04x), flags!!!\n", 5466 ioc->name, handle); 5467 goto out_unlock; 5468 } 5469 5470 /* check if there were any issues with discovery */ 5471 if (_scsih_check_access_status(ioc, sas_address, handle, 5472 sas_device_pg0.AccessStatus)) 5473 goto out_unlock; 5474 5475 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 5476 _scsih_ublock_io_device(ioc, sas_address); 5477 5478 if (sas_device) 5479 sas_device_put(sas_device); 5480 return; 5481 5482 out_unlock: 5483 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 5484 if (sas_device) 5485 sas_device_put(sas_device); 5486 } 5487 5488 /** 5489 * _scsih_add_device - creating sas device object 5490 * @ioc: per adapter object 5491 * @handle: sas device handle 5492 * @phy_num: phy number end device attached to 5493 * @is_pd: is this hidden raid component 5494 * 5495 * Creating end device object, stored in ioc->sas_device_list. 5496 * 5497 * Returns 0 for success, non-zero for failure. 5498 */ 5499 static int 5500 _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num, 5501 u8 is_pd) 5502 { 5503 Mpi2ConfigReply_t mpi_reply; 5504 Mpi2SasDevicePage0_t sas_device_pg0; 5505 Mpi2SasEnclosurePage0_t enclosure_pg0; 5506 struct _sas_device *sas_device; 5507 u32 ioc_status; 5508 u64 sas_address; 5509 u32 device_info; 5510 5511 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 5512 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) { 5513 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5514 ioc->name, __FILE__, __LINE__, __func__); 5515 return -1; 5516 } 5517 5518 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 5519 MPI2_IOCSTATUS_MASK; 5520 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 5521 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5522 ioc->name, __FILE__, __LINE__, __func__); 5523 return -1; 5524 } 5525 5526 /* check if this is end device */ 5527 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 5528 if (!(_scsih_is_end_device(device_info))) 5529 return -1; 5530 set_bit(handle, ioc->pend_os_device_add); 5531 sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 5532 5533 /* check if device is present */ 5534 if (!(le16_to_cpu(sas_device_pg0.Flags) & 5535 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) { 5536 pr_err(MPT3SAS_FMT "device is not present handle(0x04%x)!!!\n", 5537 ioc->name, handle); 5538 return -1; 5539 } 5540 5541 /* check if there were any issues with discovery */ 5542 if (_scsih_check_access_status(ioc, sas_address, handle, 5543 sas_device_pg0.AccessStatus)) 5544 return -1; 5545 5546 sas_device = mpt3sas_get_sdev_by_addr(ioc, 5547 sas_address); 5548 if (sas_device) { 5549 clear_bit(handle, ioc->pend_os_device_add); 5550 sas_device_put(sas_device); 5551 return -1; 5552 } 5553 5554 sas_device = kzalloc(sizeof(struct _sas_device), 5555 GFP_KERNEL); 5556 if (!sas_device) { 5557 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5558 ioc->name, __FILE__, __LINE__, __func__); 5559 return 0; 5560 } 5561 5562 kref_init(&sas_device->refcount); 5563 sas_device->handle = handle; 5564 if (_scsih_get_sas_address(ioc, 5565 le16_to_cpu(sas_device_pg0.ParentDevHandle), 5566 &sas_device->sas_address_parent) != 0) 5567 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5568 ioc->name, __FILE__, __LINE__, __func__); 5569 sas_device->enclosure_handle = 5570 le16_to_cpu(sas_device_pg0.EnclosureHandle); 5571 if (sas_device->enclosure_handle != 0) 5572 sas_device->slot = 5573 le16_to_cpu(sas_device_pg0.Slot); 5574 sas_device->device_info = device_info; 5575 sas_device->sas_address = sas_address; 5576 sas_device->phy = sas_device_pg0.PhyNum; 5577 sas_device->fast_path = (le16_to_cpu(sas_device_pg0.Flags) & 5578 MPI25_SAS_DEVICE0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0; 5579 5580 if (le16_to_cpu(sas_device_pg0.Flags) 5581 & MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) { 5582 sas_device->enclosure_level = 5583 sas_device_pg0.EnclosureLevel; 5584 memcpy(sas_device->connector_name, 5585 sas_device_pg0.ConnectorName, 4); 5586 sas_device->connector_name[4] = '\0'; 5587 } else { 5588 sas_device->enclosure_level = 0; 5589 sas_device->connector_name[0] = '\0'; 5590 } 5591 /* get enclosure_logical_id */ 5592 if (sas_device->enclosure_handle && !(mpt3sas_config_get_enclosure_pg0( 5593 ioc, &mpi_reply, &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE, 5594 sas_device->enclosure_handle))) 5595 sas_device->enclosure_logical_id = 5596 le64_to_cpu(enclosure_pg0.EnclosureLogicalID); 5597 5598 /* get device name */ 5599 sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName); 5600 5601 if (ioc->wait_for_discovery_to_complete) 5602 _scsih_sas_device_init_add(ioc, sas_device); 5603 else 5604 _scsih_sas_device_add(ioc, sas_device); 5605 5606 sas_device_put(sas_device); 5607 return 0; 5608 } 5609 5610 /** 5611 * _scsih_remove_device - removing sas device object 5612 * @ioc: per adapter object 5613 * @sas_device_delete: the sas_device object 5614 * 5615 * Return nothing. 5616 */ 5617 static void 5618 _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc, 5619 struct _sas_device *sas_device) 5620 { 5621 struct MPT3SAS_TARGET *sas_target_priv_data; 5622 5623 if ((ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) && 5624 (sas_device->pfa_led_on)) { 5625 _scsih_turn_off_pfa_led(ioc, sas_device); 5626 sas_device->pfa_led_on = 0; 5627 } 5628 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5629 "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n", 5630 ioc->name, __func__, 5631 sas_device->handle, (unsigned long long) 5632 sas_device->sas_address)); 5633 if (sas_device->enclosure_handle != 0) 5634 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5635 "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n", 5636 ioc->name, __func__, 5637 (unsigned long long)sas_device->enclosure_logical_id, 5638 sas_device->slot)); 5639 if (sas_device->connector_name[0] != '\0') 5640 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5641 "%s: enter: enclosure level(0x%04x), connector name( %s)\n", 5642 ioc->name, __func__, 5643 sas_device->enclosure_level, 5644 sas_device->connector_name)); 5645 5646 if (sas_device->starget && sas_device->starget->hostdata) { 5647 sas_target_priv_data = sas_device->starget->hostdata; 5648 sas_target_priv_data->deleted = 1; 5649 _scsih_ublock_io_device(ioc, sas_device->sas_address); 5650 sas_target_priv_data->handle = 5651 MPT3SAS_INVALID_DEVICE_HANDLE; 5652 } 5653 5654 if (!ioc->hide_drives) 5655 mpt3sas_transport_port_remove(ioc, 5656 sas_device->sas_address, 5657 sas_device->sas_address_parent); 5658 5659 pr_info(MPT3SAS_FMT 5660 "removing handle(0x%04x), sas_addr(0x%016llx)\n", 5661 ioc->name, sas_device->handle, 5662 (unsigned long long) sas_device->sas_address); 5663 if (sas_device->enclosure_handle != 0) 5664 pr_info(MPT3SAS_FMT 5665 "removing : enclosure logical id(0x%016llx), slot(%d)\n", 5666 ioc->name, 5667 (unsigned long long)sas_device->enclosure_logical_id, 5668 sas_device->slot); 5669 if (sas_device->connector_name[0] != '\0') 5670 pr_info(MPT3SAS_FMT 5671 "removing enclosure level(0x%04x), connector name( %s)\n", 5672 ioc->name, sas_device->enclosure_level, 5673 sas_device->connector_name); 5674 5675 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5676 "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n", 5677 ioc->name, __func__, 5678 sas_device->handle, (unsigned long long) 5679 sas_device->sas_address)); 5680 if (sas_device->enclosure_handle != 0) 5681 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5682 "%s: exit: enclosure logical id(0x%016llx), slot(%d)\n", 5683 ioc->name, __func__, 5684 (unsigned long long)sas_device->enclosure_logical_id, 5685 sas_device->slot)); 5686 if (sas_device->connector_name[0] != '\0') 5687 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5688 "%s: exit: enclosure level(0x%04x), connector name(%s)\n", 5689 ioc->name, __func__, sas_device->enclosure_level, 5690 sas_device->connector_name)); 5691 } 5692 5693 /** 5694 * _scsih_sas_topology_change_event_debug - debug for topology event 5695 * @ioc: per adapter object 5696 * @event_data: event data payload 5697 * Context: user. 5698 */ 5699 static void 5700 _scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 5701 Mpi2EventDataSasTopologyChangeList_t *event_data) 5702 { 5703 int i; 5704 u16 handle; 5705 u16 reason_code; 5706 u8 phy_number; 5707 char *status_str = NULL; 5708 u8 link_rate, prev_link_rate; 5709 5710 switch (event_data->ExpStatus) { 5711 case MPI2_EVENT_SAS_TOPO_ES_ADDED: 5712 status_str = "add"; 5713 break; 5714 case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING: 5715 status_str = "remove"; 5716 break; 5717 case MPI2_EVENT_SAS_TOPO_ES_RESPONDING: 5718 case 0: 5719 status_str = "responding"; 5720 break; 5721 case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING: 5722 status_str = "remove delay"; 5723 break; 5724 default: 5725 status_str = "unknown status"; 5726 break; 5727 } 5728 pr_info(MPT3SAS_FMT "sas topology change: (%s)\n", 5729 ioc->name, status_str); 5730 pr_info("\thandle(0x%04x), enclosure_handle(0x%04x) " \ 5731 "start_phy(%02d), count(%d)\n", 5732 le16_to_cpu(event_data->ExpanderDevHandle), 5733 le16_to_cpu(event_data->EnclosureHandle), 5734 event_data->StartPhyNum, event_data->NumEntries); 5735 for (i = 0; i < event_data->NumEntries; i++) { 5736 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 5737 if (!handle) 5738 continue; 5739 phy_number = event_data->StartPhyNum + i; 5740 reason_code = event_data->PHY[i].PhyStatus & 5741 MPI2_EVENT_SAS_TOPO_RC_MASK; 5742 switch (reason_code) { 5743 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED: 5744 status_str = "target add"; 5745 break; 5746 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING: 5747 status_str = "target remove"; 5748 break; 5749 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING: 5750 status_str = "delay target remove"; 5751 break; 5752 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED: 5753 status_str = "link rate change"; 5754 break; 5755 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE: 5756 status_str = "target responding"; 5757 break; 5758 default: 5759 status_str = "unknown"; 5760 break; 5761 } 5762 link_rate = event_data->PHY[i].LinkRate >> 4; 5763 prev_link_rate = event_data->PHY[i].LinkRate & 0xF; 5764 pr_info("\tphy(%02d), attached_handle(0x%04x): %s:" \ 5765 " link rate: new(0x%02x), old(0x%02x)\n", phy_number, 5766 handle, status_str, link_rate, prev_link_rate); 5767 5768 } 5769 } 5770 5771 /** 5772 * _scsih_sas_topology_change_event - handle topology changes 5773 * @ioc: per adapter object 5774 * @fw_event: The fw_event_work object 5775 * Context: user. 5776 * 5777 */ 5778 static int 5779 _scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc, 5780 struct fw_event_work *fw_event) 5781 { 5782 int i; 5783 u16 parent_handle, handle; 5784 u16 reason_code; 5785 u8 phy_number, max_phys; 5786 struct _sas_node *sas_expander; 5787 u64 sas_address; 5788 unsigned long flags; 5789 u8 link_rate, prev_link_rate; 5790 Mpi2EventDataSasTopologyChangeList_t *event_data = 5791 (Mpi2EventDataSasTopologyChangeList_t *) 5792 fw_event->event_data; 5793 5794 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 5795 _scsih_sas_topology_change_event_debug(ioc, event_data); 5796 5797 if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery) 5798 return 0; 5799 5800 if (!ioc->sas_hba.num_phys) 5801 _scsih_sas_host_add(ioc); 5802 else 5803 _scsih_sas_host_refresh(ioc); 5804 5805 if (fw_event->ignore) { 5806 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5807 "ignoring expander event\n", ioc->name)); 5808 return 0; 5809 } 5810 5811 parent_handle = le16_to_cpu(event_data->ExpanderDevHandle); 5812 5813 /* handle expander add */ 5814 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED) 5815 if (_scsih_expander_add(ioc, parent_handle) != 0) 5816 return 0; 5817 5818 spin_lock_irqsave(&ioc->sas_node_lock, flags); 5819 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc, 5820 parent_handle); 5821 if (sas_expander) { 5822 sas_address = sas_expander->sas_address; 5823 max_phys = sas_expander->num_phys; 5824 } else if (parent_handle < ioc->sas_hba.num_phys) { 5825 sas_address = ioc->sas_hba.sas_address; 5826 max_phys = ioc->sas_hba.num_phys; 5827 } else { 5828 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 5829 return 0; 5830 } 5831 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 5832 5833 /* handle siblings events */ 5834 for (i = 0; i < event_data->NumEntries; i++) { 5835 if (fw_event->ignore) { 5836 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5837 "ignoring expander event\n", ioc->name)); 5838 return 0; 5839 } 5840 if (ioc->remove_host || ioc->pci_error_recovery) 5841 return 0; 5842 phy_number = event_data->StartPhyNum + i; 5843 if (phy_number >= max_phys) 5844 continue; 5845 reason_code = event_data->PHY[i].PhyStatus & 5846 MPI2_EVENT_SAS_TOPO_RC_MASK; 5847 if ((event_data->PHY[i].PhyStatus & 5848 MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code != 5849 MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)) 5850 continue; 5851 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 5852 if (!handle) 5853 continue; 5854 link_rate = event_data->PHY[i].LinkRate >> 4; 5855 prev_link_rate = event_data->PHY[i].LinkRate & 0xF; 5856 switch (reason_code) { 5857 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED: 5858 5859 if (ioc->shost_recovery) 5860 break; 5861 5862 if (link_rate == prev_link_rate) 5863 break; 5864 5865 mpt3sas_transport_update_links(ioc, sas_address, 5866 handle, phy_number, link_rate); 5867 5868 if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5) 5869 break; 5870 5871 _scsih_check_device(ioc, sas_address, handle, 5872 phy_number, link_rate); 5873 5874 if (!test_bit(handle, ioc->pend_os_device_add)) 5875 break; 5876 5877 5878 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED: 5879 5880 if (ioc->shost_recovery) 5881 break; 5882 5883 mpt3sas_transport_update_links(ioc, sas_address, 5884 handle, phy_number, link_rate); 5885 5886 _scsih_add_device(ioc, handle, phy_number, 0); 5887 5888 break; 5889 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING: 5890 5891 _scsih_device_remove_by_handle(ioc, handle); 5892 break; 5893 } 5894 } 5895 5896 /* handle expander removal */ 5897 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING && 5898 sas_expander) 5899 mpt3sas_expander_remove(ioc, sas_address); 5900 5901 return 0; 5902 } 5903 5904 /** 5905 * _scsih_sas_device_status_change_event_debug - debug for device event 5906 * @event_data: event data payload 5907 * Context: user. 5908 * 5909 * Return nothing. 5910 */ 5911 static void 5912 _scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 5913 Mpi2EventDataSasDeviceStatusChange_t *event_data) 5914 { 5915 char *reason_str = NULL; 5916 5917 switch (event_data->ReasonCode) { 5918 case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA: 5919 reason_str = "smart data"; 5920 break; 5921 case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED: 5922 reason_str = "unsupported device discovered"; 5923 break; 5924 case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET: 5925 reason_str = "internal device reset"; 5926 break; 5927 case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL: 5928 reason_str = "internal task abort"; 5929 break; 5930 case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL: 5931 reason_str = "internal task abort set"; 5932 break; 5933 case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL: 5934 reason_str = "internal clear task set"; 5935 break; 5936 case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL: 5937 reason_str = "internal query task"; 5938 break; 5939 case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE: 5940 reason_str = "sata init failure"; 5941 break; 5942 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET: 5943 reason_str = "internal device reset complete"; 5944 break; 5945 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL: 5946 reason_str = "internal task abort complete"; 5947 break; 5948 case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION: 5949 reason_str = "internal async notification"; 5950 break; 5951 case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY: 5952 reason_str = "expander reduced functionality"; 5953 break; 5954 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY: 5955 reason_str = "expander reduced functionality complete"; 5956 break; 5957 default: 5958 reason_str = "unknown reason"; 5959 break; 5960 } 5961 pr_info(MPT3SAS_FMT "device status change: (%s)\n" 5962 "\thandle(0x%04x), sas address(0x%016llx), tag(%d)", 5963 ioc->name, reason_str, le16_to_cpu(event_data->DevHandle), 5964 (unsigned long long)le64_to_cpu(event_data->SASAddress), 5965 le16_to_cpu(event_data->TaskTag)); 5966 if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA) 5967 pr_info(MPT3SAS_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name, 5968 event_data->ASC, event_data->ASCQ); 5969 pr_info("\n"); 5970 } 5971 5972 /** 5973 * _scsih_sas_device_status_change_event - handle device status change 5974 * @ioc: per adapter object 5975 * @fw_event: The fw_event_work object 5976 * Context: user. 5977 * 5978 * Return nothing. 5979 */ 5980 static void 5981 _scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc, 5982 struct fw_event_work *fw_event) 5983 { 5984 struct MPT3SAS_TARGET *target_priv_data; 5985 struct _sas_device *sas_device; 5986 u64 sas_address; 5987 unsigned long flags; 5988 Mpi2EventDataSasDeviceStatusChange_t *event_data = 5989 (Mpi2EventDataSasDeviceStatusChange_t *) 5990 fw_event->event_data; 5991 5992 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 5993 _scsih_sas_device_status_change_event_debug(ioc, 5994 event_data); 5995 5996 /* In MPI Revision K (0xC), the internal device reset complete was 5997 * implemented, so avoid setting tm_busy flag for older firmware. 5998 */ 5999 if ((ioc->facts.HeaderVersion >> 8) < 0xC) 6000 return; 6001 6002 if (event_data->ReasonCode != 6003 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET && 6004 event_data->ReasonCode != 6005 MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET) 6006 return; 6007 6008 spin_lock_irqsave(&ioc->sas_device_lock, flags); 6009 sas_address = le64_to_cpu(event_data->SASAddress); 6010 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 6011 sas_address); 6012 6013 if (!sas_device || !sas_device->starget) 6014 goto out; 6015 6016 target_priv_data = sas_device->starget->hostdata; 6017 if (!target_priv_data) 6018 goto out; 6019 6020 if (event_data->ReasonCode == 6021 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET) 6022 target_priv_data->tm_busy = 1; 6023 else 6024 target_priv_data->tm_busy = 0; 6025 6026 out: 6027 if (sas_device) 6028 sas_device_put(sas_device); 6029 6030 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 6031 6032 } 6033 6034 /** 6035 * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure 6036 * event 6037 * @ioc: per adapter object 6038 * @event_data: event data payload 6039 * Context: user. 6040 * 6041 * Return nothing. 6042 */ 6043 static void 6044 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 6045 Mpi2EventDataSasEnclDevStatusChange_t *event_data) 6046 { 6047 char *reason_str = NULL; 6048 6049 switch (event_data->ReasonCode) { 6050 case MPI2_EVENT_SAS_ENCL_RC_ADDED: 6051 reason_str = "enclosure add"; 6052 break; 6053 case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING: 6054 reason_str = "enclosure remove"; 6055 break; 6056 default: 6057 reason_str = "unknown reason"; 6058 break; 6059 } 6060 6061 pr_info(MPT3SAS_FMT "enclosure status change: (%s)\n" 6062 "\thandle(0x%04x), enclosure logical id(0x%016llx)" 6063 " number slots(%d)\n", ioc->name, reason_str, 6064 le16_to_cpu(event_data->EnclosureHandle), 6065 (unsigned long long)le64_to_cpu(event_data->EnclosureLogicalID), 6066 le16_to_cpu(event_data->StartSlot)); 6067 } 6068 6069 /** 6070 * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events 6071 * @ioc: per adapter object 6072 * @fw_event: The fw_event_work object 6073 * Context: user. 6074 * 6075 * Return nothing. 6076 */ 6077 static void 6078 _scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc, 6079 struct fw_event_work *fw_event) 6080 { 6081 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 6082 _scsih_sas_enclosure_dev_status_change_event_debug(ioc, 6083 (Mpi2EventDataSasEnclDevStatusChange_t *) 6084 fw_event->event_data); 6085 } 6086 6087 /** 6088 * _scsih_sas_broadcast_primitive_event - handle broadcast events 6089 * @ioc: per adapter object 6090 * @fw_event: The fw_event_work object 6091 * Context: user. 6092 * 6093 * Return nothing. 6094 */ 6095 static void 6096 _scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc, 6097 struct fw_event_work *fw_event) 6098 { 6099 struct scsi_cmnd *scmd; 6100 struct scsi_device *sdev; 6101 u16 smid, handle; 6102 u32 lun; 6103 struct MPT3SAS_DEVICE *sas_device_priv_data; 6104 u32 termination_count; 6105 u32 query_count; 6106 Mpi2SCSITaskManagementReply_t *mpi_reply; 6107 Mpi2EventDataSasBroadcastPrimitive_t *event_data = 6108 (Mpi2EventDataSasBroadcastPrimitive_t *) 6109 fw_event->event_data; 6110 u16 ioc_status; 6111 unsigned long flags; 6112 int r; 6113 u8 max_retries = 0; 6114 u8 task_abort_retries; 6115 6116 mutex_lock(&ioc->tm_cmds.mutex); 6117 pr_info(MPT3SAS_FMT 6118 "%s: enter: phy number(%d), width(%d)\n", 6119 ioc->name, __func__, event_data->PhyNum, 6120 event_data->PortWidth); 6121 6122 _scsih_block_io_all_device(ioc); 6123 6124 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6125 mpi_reply = ioc->tm_cmds.reply; 6126 broadcast_aen_retry: 6127 6128 /* sanity checks for retrying this loop */ 6129 if (max_retries++ == 5) { 6130 dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: giving up\n", 6131 ioc->name, __func__)); 6132 goto out; 6133 } else if (max_retries > 1) 6134 dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: %d retry\n", 6135 ioc->name, __func__, max_retries - 1)); 6136 6137 termination_count = 0; 6138 query_count = 0; 6139 for (smid = 1; smid <= ioc->scsiio_depth; smid++) { 6140 if (ioc->shost_recovery) 6141 goto out; 6142 scmd = _scsih_scsi_lookup_get(ioc, smid); 6143 if (!scmd) 6144 continue; 6145 sdev = scmd->device; 6146 sas_device_priv_data = sdev->hostdata; 6147 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) 6148 continue; 6149 /* skip hidden raid components */ 6150 if (sas_device_priv_data->sas_target->flags & 6151 MPT_TARGET_FLAGS_RAID_COMPONENT) 6152 continue; 6153 /* skip volumes */ 6154 if (sas_device_priv_data->sas_target->flags & 6155 MPT_TARGET_FLAGS_VOLUME) 6156 continue; 6157 6158 handle = sas_device_priv_data->sas_target->handle; 6159 lun = sas_device_priv_data->lun; 6160 query_count++; 6161 6162 if (ioc->shost_recovery) 6163 goto out; 6164 6165 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 6166 r = mpt3sas_scsih_issue_tm(ioc, handle, 0, 0, lun, 6167 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, smid, 30); 6168 if (r == FAILED) { 6169 sdev_printk(KERN_WARNING, sdev, 6170 "mpt3sas_scsih_issue_tm: FAILED when sending " 6171 "QUERY_TASK: scmd(%p)\n", scmd); 6172 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6173 goto broadcast_aen_retry; 6174 } 6175 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) 6176 & MPI2_IOCSTATUS_MASK; 6177 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6178 sdev_printk(KERN_WARNING, sdev, 6179 "query task: FAILED with IOCSTATUS(0x%04x), scmd(%p)\n", 6180 ioc_status, scmd); 6181 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6182 goto broadcast_aen_retry; 6183 } 6184 6185 /* see if IO is still owned by IOC and target */ 6186 if (mpi_reply->ResponseCode == 6187 MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED || 6188 mpi_reply->ResponseCode == 6189 MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) { 6190 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6191 continue; 6192 } 6193 task_abort_retries = 0; 6194 tm_retry: 6195 if (task_abort_retries++ == 60) { 6196 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6197 "%s: ABORT_TASK: giving up\n", ioc->name, 6198 __func__)); 6199 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6200 goto broadcast_aen_retry; 6201 } 6202 6203 if (ioc->shost_recovery) 6204 goto out_no_lock; 6205 6206 r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id, 6207 sdev->lun, MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 6208 30); 6209 if (r == FAILED) { 6210 sdev_printk(KERN_WARNING, sdev, 6211 "mpt3sas_scsih_issue_tm: ABORT_TASK: FAILED : " 6212 "scmd(%p)\n", scmd); 6213 goto tm_retry; 6214 } 6215 6216 if (task_abort_retries > 1) 6217 sdev_printk(KERN_WARNING, sdev, 6218 "mpt3sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):" 6219 " scmd(%p)\n", 6220 task_abort_retries - 1, scmd); 6221 6222 termination_count += le32_to_cpu(mpi_reply->TerminationCount); 6223 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6224 } 6225 6226 if (ioc->broadcast_aen_pending) { 6227 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6228 "%s: loop back due to pending AEN\n", 6229 ioc->name, __func__)); 6230 ioc->broadcast_aen_pending = 0; 6231 goto broadcast_aen_retry; 6232 } 6233 6234 out: 6235 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 6236 out_no_lock: 6237 6238 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6239 "%s - exit, query_count = %d termination_count = %d\n", 6240 ioc->name, __func__, query_count, termination_count)); 6241 6242 ioc->broadcast_aen_busy = 0; 6243 if (!ioc->shost_recovery) 6244 _scsih_ublock_io_all_device(ioc); 6245 mutex_unlock(&ioc->tm_cmds.mutex); 6246 } 6247 6248 /** 6249 * _scsih_sas_discovery_event - handle discovery events 6250 * @ioc: per adapter object 6251 * @fw_event: The fw_event_work object 6252 * Context: user. 6253 * 6254 * Return nothing. 6255 */ 6256 static void 6257 _scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc, 6258 struct fw_event_work *fw_event) 6259 { 6260 Mpi2EventDataSasDiscovery_t *event_data = 6261 (Mpi2EventDataSasDiscovery_t *) fw_event->event_data; 6262 6263 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) { 6264 pr_info(MPT3SAS_FMT "discovery event: (%s)", ioc->name, 6265 (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ? 6266 "start" : "stop"); 6267 if (event_data->DiscoveryStatus) 6268 pr_info("discovery_status(0x%08x)", 6269 le32_to_cpu(event_data->DiscoveryStatus)); 6270 pr_info("\n"); 6271 } 6272 6273 if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED && 6274 !ioc->sas_hba.num_phys) { 6275 if (disable_discovery > 0 && ioc->shost_recovery) { 6276 /* Wait for the reset to complete */ 6277 while (ioc->shost_recovery) 6278 ssleep(1); 6279 } 6280 _scsih_sas_host_add(ioc); 6281 } 6282 } 6283 6284 /** 6285 * _scsih_ir_fastpath - turn on fastpath for IR physdisk 6286 * @ioc: per adapter object 6287 * @handle: device handle for physical disk 6288 * @phys_disk_num: physical disk number 6289 * 6290 * Return 0 for success, else failure. 6291 */ 6292 static int 6293 _scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num) 6294 { 6295 Mpi2RaidActionRequest_t *mpi_request; 6296 Mpi2RaidActionReply_t *mpi_reply; 6297 u16 smid; 6298 u8 issue_reset = 0; 6299 int rc = 0; 6300 u16 ioc_status; 6301 u32 log_info; 6302 6303 if (ioc->hba_mpi_version_belonged == MPI2_VERSION) 6304 return rc; 6305 6306 mutex_lock(&ioc->scsih_cmds.mutex); 6307 6308 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) { 6309 pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n", 6310 ioc->name, __func__); 6311 rc = -EAGAIN; 6312 goto out; 6313 } 6314 ioc->scsih_cmds.status = MPT3_CMD_PENDING; 6315 6316 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx); 6317 if (!smid) { 6318 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 6319 ioc->name, __func__); 6320 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 6321 rc = -EAGAIN; 6322 goto out; 6323 } 6324 6325 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 6326 ioc->scsih_cmds.smid = smid; 6327 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t)); 6328 6329 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION; 6330 mpi_request->Action = MPI2_RAID_ACTION_PHYSDISK_HIDDEN; 6331 mpi_request->PhysDiskNum = phys_disk_num; 6332 6333 dewtprintk(ioc, pr_info(MPT3SAS_FMT "IR RAID_ACTION: turning fast "\ 6334 "path on for handle(0x%04x), phys_disk_num (0x%02x)\n", ioc->name, 6335 handle, phys_disk_num)); 6336 6337 init_completion(&ioc->scsih_cmds.done); 6338 ioc->put_smid_default(ioc, smid); 6339 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ); 6340 6341 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) { 6342 pr_err(MPT3SAS_FMT "%s: timeout\n", 6343 ioc->name, __func__); 6344 if (!(ioc->scsih_cmds.status & MPT3_CMD_RESET)) 6345 issue_reset = 1; 6346 rc = -EFAULT; 6347 goto out; 6348 } 6349 6350 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) { 6351 6352 mpi_reply = ioc->scsih_cmds.reply; 6353 ioc_status = le16_to_cpu(mpi_reply->IOCStatus); 6354 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) 6355 log_info = le32_to_cpu(mpi_reply->IOCLogInfo); 6356 else 6357 log_info = 0; 6358 ioc_status &= MPI2_IOCSTATUS_MASK; 6359 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6360 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6361 "IR RAID_ACTION: failed: ioc_status(0x%04x), " 6362 "loginfo(0x%08x)!!!\n", ioc->name, ioc_status, 6363 log_info)); 6364 rc = -EFAULT; 6365 } else 6366 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6367 "IR RAID_ACTION: completed successfully\n", 6368 ioc->name)); 6369 } 6370 6371 out: 6372 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 6373 mutex_unlock(&ioc->scsih_cmds.mutex); 6374 6375 if (issue_reset) 6376 mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 6377 return rc; 6378 } 6379 6380 /** 6381 * _scsih_reprobe_lun - reprobing lun 6382 * @sdev: scsi device struct 6383 * @no_uld_attach: sdev->no_uld_attach flag setting 6384 * 6385 **/ 6386 static void 6387 _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach) 6388 { 6389 sdev->no_uld_attach = no_uld_attach ? 1 : 0; 6390 sdev_printk(KERN_INFO, sdev, "%s raid component\n", 6391 sdev->no_uld_attach ? "hiding" : "exposing"); 6392 WARN_ON(scsi_device_reprobe(sdev)); 6393 } 6394 6395 /** 6396 * _scsih_sas_volume_add - add new volume 6397 * @ioc: per adapter object 6398 * @element: IR config element data 6399 * Context: user. 6400 * 6401 * Return nothing. 6402 */ 6403 static void 6404 _scsih_sas_volume_add(struct MPT3SAS_ADAPTER *ioc, 6405 Mpi2EventIrConfigElement_t *element) 6406 { 6407 struct _raid_device *raid_device; 6408 unsigned long flags; 6409 u64 wwid; 6410 u16 handle = le16_to_cpu(element->VolDevHandle); 6411 int rc; 6412 6413 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid); 6414 if (!wwid) { 6415 pr_err(MPT3SAS_FMT 6416 "failure at %s:%d/%s()!\n", ioc->name, 6417 __FILE__, __LINE__, __func__); 6418 return; 6419 } 6420 6421 spin_lock_irqsave(&ioc->raid_device_lock, flags); 6422 raid_device = _scsih_raid_device_find_by_wwid(ioc, wwid); 6423 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 6424 6425 if (raid_device) 6426 return; 6427 6428 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL); 6429 if (!raid_device) { 6430 pr_err(MPT3SAS_FMT 6431 "failure at %s:%d/%s()!\n", ioc->name, 6432 __FILE__, __LINE__, __func__); 6433 return; 6434 } 6435 6436 raid_device->id = ioc->sas_id++; 6437 raid_device->channel = RAID_CHANNEL; 6438 raid_device->handle = handle; 6439 raid_device->wwid = wwid; 6440 _scsih_raid_device_add(ioc, raid_device); 6441 if (!ioc->wait_for_discovery_to_complete) { 6442 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 6443 raid_device->id, 0); 6444 if (rc) 6445 _scsih_raid_device_remove(ioc, raid_device); 6446 } else { 6447 spin_lock_irqsave(&ioc->raid_device_lock, flags); 6448 _scsih_determine_boot_device(ioc, raid_device, 1); 6449 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 6450 } 6451 } 6452 6453 /** 6454 * _scsih_sas_volume_delete - delete volume 6455 * @ioc: per adapter object 6456 * @handle: volume device handle 6457 * Context: user. 6458 * 6459 * Return nothing. 6460 */ 6461 static void 6462 _scsih_sas_volume_delete(struct MPT3SAS_ADAPTER *ioc, u16 handle) 6463 { 6464 struct _raid_device *raid_device; 6465 unsigned long flags; 6466 struct MPT3SAS_TARGET *sas_target_priv_data; 6467 struct scsi_target *starget = NULL; 6468 6469 spin_lock_irqsave(&ioc->raid_device_lock, flags); 6470 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 6471 if (raid_device) { 6472 if (raid_device->starget) { 6473 starget = raid_device->starget; 6474 sas_target_priv_data = starget->hostdata; 6475 sas_target_priv_data->deleted = 1; 6476 } 6477 pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n", 6478 ioc->name, raid_device->handle, 6479 (unsigned long long) raid_device->wwid); 6480 list_del(&raid_device->list); 6481 kfree(raid_device); 6482 } 6483 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 6484 if (starget) 6485 scsi_remove_target(&starget->dev); 6486 } 6487 6488 /** 6489 * _scsih_sas_pd_expose - expose pd component to /dev/sdX 6490 * @ioc: per adapter object 6491 * @element: IR config element data 6492 * Context: user. 6493 * 6494 * Return nothing. 6495 */ 6496 static void 6497 _scsih_sas_pd_expose(struct MPT3SAS_ADAPTER *ioc, 6498 Mpi2EventIrConfigElement_t *element) 6499 { 6500 struct _sas_device *sas_device; 6501 struct scsi_target *starget = NULL; 6502 struct MPT3SAS_TARGET *sas_target_priv_data; 6503 unsigned long flags; 6504 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 6505 6506 spin_lock_irqsave(&ioc->sas_device_lock, flags); 6507 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 6508 if (sas_device) { 6509 sas_device->volume_handle = 0; 6510 sas_device->volume_wwid = 0; 6511 clear_bit(handle, ioc->pd_handles); 6512 if (sas_device->starget && sas_device->starget->hostdata) { 6513 starget = sas_device->starget; 6514 sas_target_priv_data = starget->hostdata; 6515 sas_target_priv_data->flags &= 6516 ~MPT_TARGET_FLAGS_RAID_COMPONENT; 6517 } 6518 } 6519 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 6520 if (!sas_device) 6521 return; 6522 6523 /* exposing raid component */ 6524 if (starget) 6525 starget_for_each_device(starget, NULL, _scsih_reprobe_lun); 6526 6527 sas_device_put(sas_device); 6528 } 6529 6530 /** 6531 * _scsih_sas_pd_hide - hide pd component from /dev/sdX 6532 * @ioc: per adapter object 6533 * @element: IR config element data 6534 * Context: user. 6535 * 6536 * Return nothing. 6537 */ 6538 static void 6539 _scsih_sas_pd_hide(struct MPT3SAS_ADAPTER *ioc, 6540 Mpi2EventIrConfigElement_t *element) 6541 { 6542 struct _sas_device *sas_device; 6543 struct scsi_target *starget = NULL; 6544 struct MPT3SAS_TARGET *sas_target_priv_data; 6545 unsigned long flags; 6546 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 6547 u16 volume_handle = 0; 6548 u64 volume_wwid = 0; 6549 6550 mpt3sas_config_get_volume_handle(ioc, handle, &volume_handle); 6551 if (volume_handle) 6552 mpt3sas_config_get_volume_wwid(ioc, volume_handle, 6553 &volume_wwid); 6554 6555 spin_lock_irqsave(&ioc->sas_device_lock, flags); 6556 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 6557 if (sas_device) { 6558 set_bit(handle, ioc->pd_handles); 6559 if (sas_device->starget && sas_device->starget->hostdata) { 6560 starget = sas_device->starget; 6561 sas_target_priv_data = starget->hostdata; 6562 sas_target_priv_data->flags |= 6563 MPT_TARGET_FLAGS_RAID_COMPONENT; 6564 sas_device->volume_handle = volume_handle; 6565 sas_device->volume_wwid = volume_wwid; 6566 } 6567 } 6568 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 6569 if (!sas_device) 6570 return; 6571 6572 /* hiding raid component */ 6573 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum); 6574 6575 if (starget) 6576 starget_for_each_device(starget, (void *)1, _scsih_reprobe_lun); 6577 6578 sas_device_put(sas_device); 6579 } 6580 6581 /** 6582 * _scsih_sas_pd_delete - delete pd component 6583 * @ioc: per adapter object 6584 * @element: IR config element data 6585 * Context: user. 6586 * 6587 * Return nothing. 6588 */ 6589 static void 6590 _scsih_sas_pd_delete(struct MPT3SAS_ADAPTER *ioc, 6591 Mpi2EventIrConfigElement_t *element) 6592 { 6593 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 6594 6595 _scsih_device_remove_by_handle(ioc, handle); 6596 } 6597 6598 /** 6599 * _scsih_sas_pd_add - remove pd component 6600 * @ioc: per adapter object 6601 * @element: IR config element data 6602 * Context: user. 6603 * 6604 * Return nothing. 6605 */ 6606 static void 6607 _scsih_sas_pd_add(struct MPT3SAS_ADAPTER *ioc, 6608 Mpi2EventIrConfigElement_t *element) 6609 { 6610 struct _sas_device *sas_device; 6611 u16 handle = le16_to_cpu(element->PhysDiskDevHandle); 6612 Mpi2ConfigReply_t mpi_reply; 6613 Mpi2SasDevicePage0_t sas_device_pg0; 6614 u32 ioc_status; 6615 u64 sas_address; 6616 u16 parent_handle; 6617 6618 set_bit(handle, ioc->pd_handles); 6619 6620 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 6621 if (sas_device) { 6622 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum); 6623 sas_device_put(sas_device); 6624 return; 6625 } 6626 6627 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 6628 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) { 6629 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 6630 ioc->name, __FILE__, __LINE__, __func__); 6631 return; 6632 } 6633 6634 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 6635 MPI2_IOCSTATUS_MASK; 6636 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6637 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 6638 ioc->name, __FILE__, __LINE__, __func__); 6639 return; 6640 } 6641 6642 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 6643 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) 6644 mpt3sas_transport_update_links(ioc, sas_address, handle, 6645 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5); 6646 6647 _scsih_ir_fastpath(ioc, handle, element->PhysDiskNum); 6648 _scsih_add_device(ioc, handle, 0, 1); 6649 } 6650 6651 /** 6652 * _scsih_sas_ir_config_change_event_debug - debug for IR Config Change events 6653 * @ioc: per adapter object 6654 * @event_data: event data payload 6655 * Context: user. 6656 * 6657 * Return nothing. 6658 */ 6659 static void 6660 _scsih_sas_ir_config_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 6661 Mpi2EventDataIrConfigChangeList_t *event_data) 6662 { 6663 Mpi2EventIrConfigElement_t *element; 6664 u8 element_type; 6665 int i; 6666 char *reason_str = NULL, *element_str = NULL; 6667 6668 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 6669 6670 pr_info(MPT3SAS_FMT "raid config change: (%s), elements(%d)\n", 6671 ioc->name, (le32_to_cpu(event_data->Flags) & 6672 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 6673 "foreign" : "native", event_data->NumElements); 6674 for (i = 0; i < event_data->NumElements; i++, element++) { 6675 switch (element->ReasonCode) { 6676 case MPI2_EVENT_IR_CHANGE_RC_ADDED: 6677 reason_str = "add"; 6678 break; 6679 case MPI2_EVENT_IR_CHANGE_RC_REMOVED: 6680 reason_str = "remove"; 6681 break; 6682 case MPI2_EVENT_IR_CHANGE_RC_NO_CHANGE: 6683 reason_str = "no change"; 6684 break; 6685 case MPI2_EVENT_IR_CHANGE_RC_HIDE: 6686 reason_str = "hide"; 6687 break; 6688 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE: 6689 reason_str = "unhide"; 6690 break; 6691 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED: 6692 reason_str = "volume_created"; 6693 break; 6694 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED: 6695 reason_str = "volume_deleted"; 6696 break; 6697 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED: 6698 reason_str = "pd_created"; 6699 break; 6700 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED: 6701 reason_str = "pd_deleted"; 6702 break; 6703 default: 6704 reason_str = "unknown reason"; 6705 break; 6706 } 6707 element_type = le16_to_cpu(element->ElementFlags) & 6708 MPI2_EVENT_IR_CHANGE_EFLAGS_ELEMENT_TYPE_MASK; 6709 switch (element_type) { 6710 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLUME_ELEMENT: 6711 element_str = "volume"; 6712 break; 6713 case MPI2_EVENT_IR_CHANGE_EFLAGS_VOLPHYSDISK_ELEMENT: 6714 element_str = "phys disk"; 6715 break; 6716 case MPI2_EVENT_IR_CHANGE_EFLAGS_HOTSPARE_ELEMENT: 6717 element_str = "hot spare"; 6718 break; 6719 default: 6720 element_str = "unknown element"; 6721 break; 6722 } 6723 pr_info("\t(%s:%s), vol handle(0x%04x), " \ 6724 "pd handle(0x%04x), pd num(0x%02x)\n", element_str, 6725 reason_str, le16_to_cpu(element->VolDevHandle), 6726 le16_to_cpu(element->PhysDiskDevHandle), 6727 element->PhysDiskNum); 6728 } 6729 } 6730 6731 /** 6732 * _scsih_sas_ir_config_change_event - handle ir configuration change events 6733 * @ioc: per adapter object 6734 * @fw_event: The fw_event_work object 6735 * Context: user. 6736 * 6737 * Return nothing. 6738 */ 6739 static void 6740 _scsih_sas_ir_config_change_event(struct MPT3SAS_ADAPTER *ioc, 6741 struct fw_event_work *fw_event) 6742 { 6743 Mpi2EventIrConfigElement_t *element; 6744 int i; 6745 u8 foreign_config; 6746 Mpi2EventDataIrConfigChangeList_t *event_data = 6747 (Mpi2EventDataIrConfigChangeList_t *) 6748 fw_event->event_data; 6749 6750 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) && 6751 (!ioc->hide_ir_msg)) 6752 _scsih_sas_ir_config_change_event_debug(ioc, event_data); 6753 6754 foreign_config = (le32_to_cpu(event_data->Flags) & 6755 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) ? 1 : 0; 6756 6757 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 6758 if (ioc->shost_recovery && 6759 ioc->hba_mpi_version_belonged != MPI2_VERSION) { 6760 for (i = 0; i < event_data->NumElements; i++, element++) { 6761 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_HIDE) 6762 _scsih_ir_fastpath(ioc, 6763 le16_to_cpu(element->PhysDiskDevHandle), 6764 element->PhysDiskNum); 6765 } 6766 return; 6767 } 6768 6769 for (i = 0; i < event_data->NumElements; i++, element++) { 6770 6771 switch (element->ReasonCode) { 6772 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_CREATED: 6773 case MPI2_EVENT_IR_CHANGE_RC_ADDED: 6774 if (!foreign_config) 6775 _scsih_sas_volume_add(ioc, element); 6776 break; 6777 case MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED: 6778 case MPI2_EVENT_IR_CHANGE_RC_REMOVED: 6779 if (!foreign_config) 6780 _scsih_sas_volume_delete(ioc, 6781 le16_to_cpu(element->VolDevHandle)); 6782 break; 6783 case MPI2_EVENT_IR_CHANGE_RC_PD_CREATED: 6784 if (!ioc->is_warpdrive) 6785 _scsih_sas_pd_hide(ioc, element); 6786 break; 6787 case MPI2_EVENT_IR_CHANGE_RC_PD_DELETED: 6788 if (!ioc->is_warpdrive) 6789 _scsih_sas_pd_expose(ioc, element); 6790 break; 6791 case MPI2_EVENT_IR_CHANGE_RC_HIDE: 6792 if (!ioc->is_warpdrive) 6793 _scsih_sas_pd_add(ioc, element); 6794 break; 6795 case MPI2_EVENT_IR_CHANGE_RC_UNHIDE: 6796 if (!ioc->is_warpdrive) 6797 _scsih_sas_pd_delete(ioc, element); 6798 break; 6799 } 6800 } 6801 } 6802 6803 /** 6804 * _scsih_sas_ir_volume_event - IR volume event 6805 * @ioc: per adapter object 6806 * @fw_event: The fw_event_work object 6807 * Context: user. 6808 * 6809 * Return nothing. 6810 */ 6811 static void 6812 _scsih_sas_ir_volume_event(struct MPT3SAS_ADAPTER *ioc, 6813 struct fw_event_work *fw_event) 6814 { 6815 u64 wwid; 6816 unsigned long flags; 6817 struct _raid_device *raid_device; 6818 u16 handle; 6819 u32 state; 6820 int rc; 6821 Mpi2EventDataIrVolume_t *event_data = 6822 (Mpi2EventDataIrVolume_t *) fw_event->event_data; 6823 6824 if (ioc->shost_recovery) 6825 return; 6826 6827 if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED) 6828 return; 6829 6830 handle = le16_to_cpu(event_data->VolDevHandle); 6831 state = le32_to_cpu(event_data->NewValue); 6832 if (!ioc->hide_ir_msg) 6833 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6834 "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n", 6835 ioc->name, __func__, handle, 6836 le32_to_cpu(event_data->PreviousValue), state)); 6837 switch (state) { 6838 case MPI2_RAID_VOL_STATE_MISSING: 6839 case MPI2_RAID_VOL_STATE_FAILED: 6840 _scsih_sas_volume_delete(ioc, handle); 6841 break; 6842 6843 case MPI2_RAID_VOL_STATE_ONLINE: 6844 case MPI2_RAID_VOL_STATE_DEGRADED: 6845 case MPI2_RAID_VOL_STATE_OPTIMAL: 6846 6847 spin_lock_irqsave(&ioc->raid_device_lock, flags); 6848 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 6849 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 6850 6851 if (raid_device) 6852 break; 6853 6854 mpt3sas_config_get_volume_wwid(ioc, handle, &wwid); 6855 if (!wwid) { 6856 pr_err(MPT3SAS_FMT 6857 "failure at %s:%d/%s()!\n", ioc->name, 6858 __FILE__, __LINE__, __func__); 6859 break; 6860 } 6861 6862 raid_device = kzalloc(sizeof(struct _raid_device), GFP_KERNEL); 6863 if (!raid_device) { 6864 pr_err(MPT3SAS_FMT 6865 "failure at %s:%d/%s()!\n", ioc->name, 6866 __FILE__, __LINE__, __func__); 6867 break; 6868 } 6869 6870 raid_device->id = ioc->sas_id++; 6871 raid_device->channel = RAID_CHANNEL; 6872 raid_device->handle = handle; 6873 raid_device->wwid = wwid; 6874 _scsih_raid_device_add(ioc, raid_device); 6875 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 6876 raid_device->id, 0); 6877 if (rc) 6878 _scsih_raid_device_remove(ioc, raid_device); 6879 break; 6880 6881 case MPI2_RAID_VOL_STATE_INITIALIZING: 6882 default: 6883 break; 6884 } 6885 } 6886 6887 /** 6888 * _scsih_sas_ir_physical_disk_event - PD event 6889 * @ioc: per adapter object 6890 * @fw_event: The fw_event_work object 6891 * Context: user. 6892 * 6893 * Return nothing. 6894 */ 6895 static void 6896 _scsih_sas_ir_physical_disk_event(struct MPT3SAS_ADAPTER *ioc, 6897 struct fw_event_work *fw_event) 6898 { 6899 u16 handle, parent_handle; 6900 u32 state; 6901 struct _sas_device *sas_device; 6902 Mpi2ConfigReply_t mpi_reply; 6903 Mpi2SasDevicePage0_t sas_device_pg0; 6904 u32 ioc_status; 6905 Mpi2EventDataIrPhysicalDisk_t *event_data = 6906 (Mpi2EventDataIrPhysicalDisk_t *) fw_event->event_data; 6907 u64 sas_address; 6908 6909 if (ioc->shost_recovery) 6910 return; 6911 6912 if (event_data->ReasonCode != MPI2_EVENT_IR_PHYSDISK_RC_STATE_CHANGED) 6913 return; 6914 6915 handle = le16_to_cpu(event_data->PhysDiskDevHandle); 6916 state = le32_to_cpu(event_data->NewValue); 6917 6918 if (!ioc->hide_ir_msg) 6919 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6920 "%s: handle(0x%04x), old(0x%08x), new(0x%08x)\n", 6921 ioc->name, __func__, handle, 6922 le32_to_cpu(event_data->PreviousValue), state)); 6923 6924 switch (state) { 6925 case MPI2_RAID_PD_STATE_ONLINE: 6926 case MPI2_RAID_PD_STATE_DEGRADED: 6927 case MPI2_RAID_PD_STATE_REBUILDING: 6928 case MPI2_RAID_PD_STATE_OPTIMAL: 6929 case MPI2_RAID_PD_STATE_HOT_SPARE: 6930 6931 if (!ioc->is_warpdrive) 6932 set_bit(handle, ioc->pd_handles); 6933 6934 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 6935 if (sas_device) { 6936 sas_device_put(sas_device); 6937 return; 6938 } 6939 6940 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 6941 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, 6942 handle))) { 6943 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 6944 ioc->name, __FILE__, __LINE__, __func__); 6945 return; 6946 } 6947 6948 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 6949 MPI2_IOCSTATUS_MASK; 6950 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6951 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 6952 ioc->name, __FILE__, __LINE__, __func__); 6953 return; 6954 } 6955 6956 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 6957 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) 6958 mpt3sas_transport_update_links(ioc, sas_address, handle, 6959 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5); 6960 6961 _scsih_add_device(ioc, handle, 0, 1); 6962 6963 break; 6964 6965 case MPI2_RAID_PD_STATE_OFFLINE: 6966 case MPI2_RAID_PD_STATE_NOT_CONFIGURED: 6967 case MPI2_RAID_PD_STATE_NOT_COMPATIBLE: 6968 default: 6969 break; 6970 } 6971 } 6972 6973 /** 6974 * _scsih_sas_ir_operation_status_event_debug - debug for IR op event 6975 * @ioc: per adapter object 6976 * @event_data: event data payload 6977 * Context: user. 6978 * 6979 * Return nothing. 6980 */ 6981 static void 6982 _scsih_sas_ir_operation_status_event_debug(struct MPT3SAS_ADAPTER *ioc, 6983 Mpi2EventDataIrOperationStatus_t *event_data) 6984 { 6985 char *reason_str = NULL; 6986 6987 switch (event_data->RAIDOperation) { 6988 case MPI2_EVENT_IR_RAIDOP_RESYNC: 6989 reason_str = "resync"; 6990 break; 6991 case MPI2_EVENT_IR_RAIDOP_ONLINE_CAP_EXPANSION: 6992 reason_str = "online capacity expansion"; 6993 break; 6994 case MPI2_EVENT_IR_RAIDOP_CONSISTENCY_CHECK: 6995 reason_str = "consistency check"; 6996 break; 6997 case MPI2_EVENT_IR_RAIDOP_BACKGROUND_INIT: 6998 reason_str = "background init"; 6999 break; 7000 case MPI2_EVENT_IR_RAIDOP_MAKE_DATA_CONSISTENT: 7001 reason_str = "make data consistent"; 7002 break; 7003 } 7004 7005 if (!reason_str) 7006 return; 7007 7008 pr_info(MPT3SAS_FMT "raid operational status: (%s)" \ 7009 "\thandle(0x%04x), percent complete(%d)\n", 7010 ioc->name, reason_str, 7011 le16_to_cpu(event_data->VolDevHandle), 7012 event_data->PercentComplete); 7013 } 7014 7015 /** 7016 * _scsih_sas_ir_operation_status_event - handle RAID operation events 7017 * @ioc: per adapter object 7018 * @fw_event: The fw_event_work object 7019 * Context: user. 7020 * 7021 * Return nothing. 7022 */ 7023 static void 7024 _scsih_sas_ir_operation_status_event(struct MPT3SAS_ADAPTER *ioc, 7025 struct fw_event_work *fw_event) 7026 { 7027 Mpi2EventDataIrOperationStatus_t *event_data = 7028 (Mpi2EventDataIrOperationStatus_t *) 7029 fw_event->event_data; 7030 static struct _raid_device *raid_device; 7031 unsigned long flags; 7032 u16 handle; 7033 7034 if ((ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) && 7035 (!ioc->hide_ir_msg)) 7036 _scsih_sas_ir_operation_status_event_debug(ioc, 7037 event_data); 7038 7039 /* code added for raid transport support */ 7040 if (event_data->RAIDOperation == MPI2_EVENT_IR_RAIDOP_RESYNC) { 7041 7042 spin_lock_irqsave(&ioc->raid_device_lock, flags); 7043 handle = le16_to_cpu(event_data->VolDevHandle); 7044 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 7045 if (raid_device) 7046 raid_device->percent_complete = 7047 event_data->PercentComplete; 7048 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 7049 } 7050 } 7051 7052 /** 7053 * _scsih_prep_device_scan - initialize parameters prior to device scan 7054 * @ioc: per adapter object 7055 * 7056 * Set the deleted flag prior to device scan. If the device is found during 7057 * the scan, then we clear the deleted flag. 7058 */ 7059 static void 7060 _scsih_prep_device_scan(struct MPT3SAS_ADAPTER *ioc) 7061 { 7062 struct MPT3SAS_DEVICE *sas_device_priv_data; 7063 struct scsi_device *sdev; 7064 7065 shost_for_each_device(sdev, ioc->shost) { 7066 sas_device_priv_data = sdev->hostdata; 7067 if (sas_device_priv_data && sas_device_priv_data->sas_target) 7068 sas_device_priv_data->sas_target->deleted = 1; 7069 } 7070 } 7071 7072 /** 7073 * _scsih_mark_responding_sas_device - mark a sas_devices as responding 7074 * @ioc: per adapter object 7075 * @sas_device_pg0: SAS Device page 0 7076 * 7077 * After host reset, find out whether devices are still responding. 7078 * Used in _scsih_remove_unresponsive_sas_devices. 7079 * 7080 * Return nothing. 7081 */ 7082 static void 7083 _scsih_mark_responding_sas_device(struct MPT3SAS_ADAPTER *ioc, 7084 Mpi2SasDevicePage0_t *sas_device_pg0) 7085 { 7086 struct MPT3SAS_TARGET *sas_target_priv_data = NULL; 7087 struct scsi_target *starget; 7088 struct _sas_device *sas_device; 7089 unsigned long flags; 7090 7091 spin_lock_irqsave(&ioc->sas_device_lock, flags); 7092 list_for_each_entry(sas_device, &ioc->sas_device_list, list) { 7093 if ((sas_device->sas_address == sas_device_pg0->SASAddress) && 7094 (sas_device->slot == sas_device_pg0->Slot)) { 7095 sas_device->responding = 1; 7096 starget = sas_device->starget; 7097 if (starget && starget->hostdata) { 7098 sas_target_priv_data = starget->hostdata; 7099 sas_target_priv_data->tm_busy = 0; 7100 sas_target_priv_data->deleted = 0; 7101 } else 7102 sas_target_priv_data = NULL; 7103 if (starget) { 7104 starget_printk(KERN_INFO, starget, 7105 "handle(0x%04x), sas_addr(0x%016llx)\n", 7106 sas_device_pg0->DevHandle, 7107 (unsigned long long) 7108 sas_device->sas_address); 7109 7110 if (sas_device->enclosure_handle != 0) 7111 starget_printk(KERN_INFO, starget, 7112 "enclosure logical id(0x%016llx)," 7113 " slot(%d)\n", 7114 (unsigned long long) 7115 sas_device->enclosure_logical_id, 7116 sas_device->slot); 7117 } 7118 if (sas_device_pg0->Flags & 7119 MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) { 7120 sas_device->enclosure_level = 7121 sas_device_pg0->EnclosureLevel; 7122 memcpy(&sas_device->connector_name[0], 7123 &sas_device_pg0->ConnectorName[0], 4); 7124 } else { 7125 sas_device->enclosure_level = 0; 7126 sas_device->connector_name[0] = '\0'; 7127 } 7128 7129 if (sas_device->handle == sas_device_pg0->DevHandle) 7130 goto out; 7131 pr_info("\thandle changed from(0x%04x)!!!\n", 7132 sas_device->handle); 7133 sas_device->handle = sas_device_pg0->DevHandle; 7134 if (sas_target_priv_data) 7135 sas_target_priv_data->handle = 7136 sas_device_pg0->DevHandle; 7137 goto out; 7138 } 7139 } 7140 out: 7141 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 7142 } 7143 7144 /** 7145 * _scsih_search_responding_sas_devices - 7146 * @ioc: per adapter object 7147 * 7148 * After host reset, find out whether devices are still responding. 7149 * If not remove. 7150 * 7151 * Return nothing. 7152 */ 7153 static void 7154 _scsih_search_responding_sas_devices(struct MPT3SAS_ADAPTER *ioc) 7155 { 7156 Mpi2SasDevicePage0_t sas_device_pg0; 7157 Mpi2ConfigReply_t mpi_reply; 7158 u16 ioc_status; 7159 u16 handle; 7160 u32 device_info; 7161 7162 pr_info(MPT3SAS_FMT "search for end-devices: start\n", ioc->name); 7163 7164 if (list_empty(&ioc->sas_device_list)) 7165 goto out; 7166 7167 handle = 0xFFFF; 7168 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 7169 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, 7170 handle))) { 7171 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7172 MPI2_IOCSTATUS_MASK; 7173 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 7174 break; 7175 handle = sas_device_pg0.DevHandle = 7176 le16_to_cpu(sas_device_pg0.DevHandle); 7177 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 7178 if (!(_scsih_is_end_device(device_info))) 7179 continue; 7180 sas_device_pg0.SASAddress = 7181 le64_to_cpu(sas_device_pg0.SASAddress); 7182 sas_device_pg0.Slot = le16_to_cpu(sas_device_pg0.Slot); 7183 sas_device_pg0.Flags = le16_to_cpu(sas_device_pg0.Flags); 7184 _scsih_mark_responding_sas_device(ioc, &sas_device_pg0); 7185 } 7186 7187 out: 7188 pr_info(MPT3SAS_FMT "search for end-devices: complete\n", 7189 ioc->name); 7190 } 7191 7192 /** 7193 * _scsih_mark_responding_raid_device - mark a raid_device as responding 7194 * @ioc: per adapter object 7195 * @wwid: world wide identifier for raid volume 7196 * @handle: device handle 7197 * 7198 * After host reset, find out whether devices are still responding. 7199 * Used in _scsih_remove_unresponsive_raid_devices. 7200 * 7201 * Return nothing. 7202 */ 7203 static void 7204 _scsih_mark_responding_raid_device(struct MPT3SAS_ADAPTER *ioc, u64 wwid, 7205 u16 handle) 7206 { 7207 struct MPT3SAS_TARGET *sas_target_priv_data = NULL; 7208 struct scsi_target *starget; 7209 struct _raid_device *raid_device; 7210 unsigned long flags; 7211 7212 spin_lock_irqsave(&ioc->raid_device_lock, flags); 7213 list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 7214 if (raid_device->wwid == wwid && raid_device->starget) { 7215 starget = raid_device->starget; 7216 if (starget && starget->hostdata) { 7217 sas_target_priv_data = starget->hostdata; 7218 sas_target_priv_data->deleted = 0; 7219 } else 7220 sas_target_priv_data = NULL; 7221 raid_device->responding = 1; 7222 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 7223 starget_printk(KERN_INFO, raid_device->starget, 7224 "handle(0x%04x), wwid(0x%016llx)\n", handle, 7225 (unsigned long long)raid_device->wwid); 7226 7227 /* 7228 * WARPDRIVE: The handles of the PDs might have changed 7229 * across the host reset so re-initialize the 7230 * required data for Direct IO 7231 */ 7232 mpt3sas_init_warpdrive_properties(ioc, raid_device); 7233 spin_lock_irqsave(&ioc->raid_device_lock, flags); 7234 if (raid_device->handle == handle) { 7235 spin_unlock_irqrestore(&ioc->raid_device_lock, 7236 flags); 7237 return; 7238 } 7239 pr_info("\thandle changed from(0x%04x)!!!\n", 7240 raid_device->handle); 7241 raid_device->handle = handle; 7242 if (sas_target_priv_data) 7243 sas_target_priv_data->handle = handle; 7244 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 7245 return; 7246 } 7247 } 7248 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 7249 } 7250 7251 /** 7252 * _scsih_search_responding_raid_devices - 7253 * @ioc: per adapter object 7254 * 7255 * After host reset, find out whether devices are still responding. 7256 * If not remove. 7257 * 7258 * Return nothing. 7259 */ 7260 static void 7261 _scsih_search_responding_raid_devices(struct MPT3SAS_ADAPTER *ioc) 7262 { 7263 Mpi2RaidVolPage1_t volume_pg1; 7264 Mpi2RaidVolPage0_t volume_pg0; 7265 Mpi2RaidPhysDiskPage0_t pd_pg0; 7266 Mpi2ConfigReply_t mpi_reply; 7267 u16 ioc_status; 7268 u16 handle; 7269 u8 phys_disk_num; 7270 7271 if (!ioc->ir_firmware) 7272 return; 7273 7274 pr_info(MPT3SAS_FMT "search for raid volumes: start\n", 7275 ioc->name); 7276 7277 if (list_empty(&ioc->raid_device_list)) 7278 goto out; 7279 7280 handle = 0xFFFF; 7281 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply, 7282 &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) { 7283 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7284 MPI2_IOCSTATUS_MASK; 7285 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 7286 break; 7287 handle = le16_to_cpu(volume_pg1.DevHandle); 7288 7289 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, 7290 &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle, 7291 sizeof(Mpi2RaidVolPage0_t))) 7292 continue; 7293 7294 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL || 7295 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE || 7296 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) 7297 _scsih_mark_responding_raid_device(ioc, 7298 le64_to_cpu(volume_pg1.WWID), handle); 7299 } 7300 7301 /* refresh the pd_handles */ 7302 if (!ioc->is_warpdrive) { 7303 phys_disk_num = 0xFF; 7304 memset(ioc->pd_handles, 0, ioc->pd_handles_sz); 7305 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply, 7306 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM, 7307 phys_disk_num))) { 7308 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7309 MPI2_IOCSTATUS_MASK; 7310 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 7311 break; 7312 phys_disk_num = pd_pg0.PhysDiskNum; 7313 handle = le16_to_cpu(pd_pg0.DevHandle); 7314 set_bit(handle, ioc->pd_handles); 7315 } 7316 } 7317 out: 7318 pr_info(MPT3SAS_FMT "search for responding raid volumes: complete\n", 7319 ioc->name); 7320 } 7321 7322 /** 7323 * _scsih_mark_responding_expander - mark a expander as responding 7324 * @ioc: per adapter object 7325 * @sas_address: sas address 7326 * @handle: 7327 * 7328 * After host reset, find out whether devices are still responding. 7329 * Used in _scsih_remove_unresponsive_expanders. 7330 * 7331 * Return nothing. 7332 */ 7333 static void 7334 _scsih_mark_responding_expander(struct MPT3SAS_ADAPTER *ioc, u64 sas_address, 7335 u16 handle) 7336 { 7337 struct _sas_node *sas_expander; 7338 unsigned long flags; 7339 int i; 7340 7341 spin_lock_irqsave(&ioc->sas_node_lock, flags); 7342 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) { 7343 if (sas_expander->sas_address != sas_address) 7344 continue; 7345 sas_expander->responding = 1; 7346 if (sas_expander->handle == handle) 7347 goto out; 7348 pr_info("\texpander(0x%016llx): handle changed" \ 7349 " from(0x%04x) to (0x%04x)!!!\n", 7350 (unsigned long long)sas_expander->sas_address, 7351 sas_expander->handle, handle); 7352 sas_expander->handle = handle; 7353 for (i = 0 ; i < sas_expander->num_phys ; i++) 7354 sas_expander->phy[i].handle = handle; 7355 goto out; 7356 } 7357 out: 7358 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 7359 } 7360 7361 /** 7362 * _scsih_search_responding_expanders - 7363 * @ioc: per adapter object 7364 * 7365 * After host reset, find out whether devices are still responding. 7366 * If not remove. 7367 * 7368 * Return nothing. 7369 */ 7370 static void 7371 _scsih_search_responding_expanders(struct MPT3SAS_ADAPTER *ioc) 7372 { 7373 Mpi2ExpanderPage0_t expander_pg0; 7374 Mpi2ConfigReply_t mpi_reply; 7375 u16 ioc_status; 7376 u64 sas_address; 7377 u16 handle; 7378 7379 pr_info(MPT3SAS_FMT "search for expanders: start\n", ioc->name); 7380 7381 if (list_empty(&ioc->sas_expander_list)) 7382 goto out; 7383 7384 handle = 0xFFFF; 7385 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0, 7386 MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) { 7387 7388 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7389 MPI2_IOCSTATUS_MASK; 7390 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 7391 break; 7392 7393 handle = le16_to_cpu(expander_pg0.DevHandle); 7394 sas_address = le64_to_cpu(expander_pg0.SASAddress); 7395 pr_info("\texpander present: handle(0x%04x), sas_addr(0x%016llx)\n", 7396 handle, 7397 (unsigned long long)sas_address); 7398 _scsih_mark_responding_expander(ioc, sas_address, handle); 7399 } 7400 7401 out: 7402 pr_info(MPT3SAS_FMT "search for expanders: complete\n", ioc->name); 7403 } 7404 7405 /** 7406 * _scsih_remove_unresponding_sas_devices - removing unresponding devices 7407 * @ioc: per adapter object 7408 * 7409 * Return nothing. 7410 */ 7411 static void 7412 _scsih_remove_unresponding_sas_devices(struct MPT3SAS_ADAPTER *ioc) 7413 { 7414 struct _sas_device *sas_device, *sas_device_next; 7415 struct _sas_node *sas_expander, *sas_expander_next; 7416 struct _raid_device *raid_device, *raid_device_next; 7417 struct list_head tmp_list; 7418 unsigned long flags; 7419 LIST_HEAD(head); 7420 7421 pr_info(MPT3SAS_FMT "removing unresponding devices: start\n", 7422 ioc->name); 7423 7424 /* removing unresponding end devices */ 7425 pr_info(MPT3SAS_FMT "removing unresponding devices: end-devices\n", 7426 ioc->name); 7427 /* 7428 * Iterate, pulling off devices marked as non-responding. We become the 7429 * owner for the reference the list had on any object we prune. 7430 */ 7431 spin_lock_irqsave(&ioc->sas_device_lock, flags); 7432 list_for_each_entry_safe(sas_device, sas_device_next, 7433 &ioc->sas_device_list, list) { 7434 if (!sas_device->responding) 7435 list_move_tail(&sas_device->list, &head); 7436 else 7437 sas_device->responding = 0; 7438 } 7439 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 7440 7441 /* 7442 * Now, uninitialize and remove the unresponding devices we pruned. 7443 */ 7444 list_for_each_entry_safe(sas_device, sas_device_next, &head, list) { 7445 _scsih_remove_device(ioc, sas_device); 7446 list_del_init(&sas_device->list); 7447 sas_device_put(sas_device); 7448 } 7449 7450 /* removing unresponding volumes */ 7451 if (ioc->ir_firmware) { 7452 pr_info(MPT3SAS_FMT "removing unresponding devices: volumes\n", 7453 ioc->name); 7454 list_for_each_entry_safe(raid_device, raid_device_next, 7455 &ioc->raid_device_list, list) { 7456 if (!raid_device->responding) 7457 _scsih_sas_volume_delete(ioc, 7458 raid_device->handle); 7459 else 7460 raid_device->responding = 0; 7461 } 7462 } 7463 7464 /* removing unresponding expanders */ 7465 pr_info(MPT3SAS_FMT "removing unresponding devices: expanders\n", 7466 ioc->name); 7467 spin_lock_irqsave(&ioc->sas_node_lock, flags); 7468 INIT_LIST_HEAD(&tmp_list); 7469 list_for_each_entry_safe(sas_expander, sas_expander_next, 7470 &ioc->sas_expander_list, list) { 7471 if (!sas_expander->responding) 7472 list_move_tail(&sas_expander->list, &tmp_list); 7473 else 7474 sas_expander->responding = 0; 7475 } 7476 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 7477 list_for_each_entry_safe(sas_expander, sas_expander_next, &tmp_list, 7478 list) { 7479 list_del(&sas_expander->list); 7480 _scsih_expander_node_remove(ioc, sas_expander); 7481 } 7482 7483 pr_info(MPT3SAS_FMT "removing unresponding devices: complete\n", 7484 ioc->name); 7485 7486 /* unblock devices */ 7487 _scsih_ublock_io_all_device(ioc); 7488 } 7489 7490 static void 7491 _scsih_refresh_expander_links(struct MPT3SAS_ADAPTER *ioc, 7492 struct _sas_node *sas_expander, u16 handle) 7493 { 7494 Mpi2ExpanderPage1_t expander_pg1; 7495 Mpi2ConfigReply_t mpi_reply; 7496 int i; 7497 7498 for (i = 0 ; i < sas_expander->num_phys ; i++) { 7499 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply, 7500 &expander_pg1, i, handle))) { 7501 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 7502 ioc->name, __FILE__, __LINE__, __func__); 7503 return; 7504 } 7505 7506 mpt3sas_transport_update_links(ioc, sas_expander->sas_address, 7507 le16_to_cpu(expander_pg1.AttachedDevHandle), i, 7508 expander_pg1.NegotiatedLinkRate >> 4); 7509 } 7510 } 7511 7512 /** 7513 * _scsih_scan_for_devices_after_reset - scan for devices after host reset 7514 * @ioc: per adapter object 7515 * 7516 * Return nothing. 7517 */ 7518 static void 7519 _scsih_scan_for_devices_after_reset(struct MPT3SAS_ADAPTER *ioc) 7520 { 7521 Mpi2ExpanderPage0_t expander_pg0; 7522 Mpi2SasDevicePage0_t sas_device_pg0; 7523 Mpi2RaidVolPage1_t volume_pg1; 7524 Mpi2RaidVolPage0_t volume_pg0; 7525 Mpi2RaidPhysDiskPage0_t pd_pg0; 7526 Mpi2EventIrConfigElement_t element; 7527 Mpi2ConfigReply_t mpi_reply; 7528 u8 phys_disk_num; 7529 u16 ioc_status; 7530 u16 handle, parent_handle; 7531 u64 sas_address; 7532 struct _sas_device *sas_device; 7533 struct _sas_node *expander_device; 7534 static struct _raid_device *raid_device; 7535 u8 retry_count; 7536 unsigned long flags; 7537 7538 pr_info(MPT3SAS_FMT "scan devices: start\n", ioc->name); 7539 7540 _scsih_sas_host_refresh(ioc); 7541 7542 pr_info(MPT3SAS_FMT "\tscan devices: expanders start\n", ioc->name); 7543 7544 /* expanders */ 7545 handle = 0xFFFF; 7546 while (!(mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0, 7547 MPI2_SAS_EXPAND_PGAD_FORM_GET_NEXT_HNDL, handle))) { 7548 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7549 MPI2_IOCSTATUS_MASK; 7550 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 7551 pr_info(MPT3SAS_FMT "\tbreak from expander scan: " \ 7552 "ioc_status(0x%04x), loginfo(0x%08x)\n", 7553 ioc->name, ioc_status, 7554 le32_to_cpu(mpi_reply.IOCLogInfo)); 7555 break; 7556 } 7557 handle = le16_to_cpu(expander_pg0.DevHandle); 7558 spin_lock_irqsave(&ioc->sas_node_lock, flags); 7559 expander_device = mpt3sas_scsih_expander_find_by_sas_address( 7560 ioc, le64_to_cpu(expander_pg0.SASAddress)); 7561 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 7562 if (expander_device) 7563 _scsih_refresh_expander_links(ioc, expander_device, 7564 handle); 7565 else { 7566 pr_info(MPT3SAS_FMT "\tBEFORE adding expander: " \ 7567 "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name, 7568 handle, (unsigned long long) 7569 le64_to_cpu(expander_pg0.SASAddress)); 7570 _scsih_expander_add(ioc, handle); 7571 pr_info(MPT3SAS_FMT "\tAFTER adding expander: " \ 7572 "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name, 7573 handle, (unsigned long long) 7574 le64_to_cpu(expander_pg0.SASAddress)); 7575 } 7576 } 7577 7578 pr_info(MPT3SAS_FMT "\tscan devices: expanders complete\n", 7579 ioc->name); 7580 7581 if (!ioc->ir_firmware) 7582 goto skip_to_sas; 7583 7584 pr_info(MPT3SAS_FMT "\tscan devices: phys disk start\n", ioc->name); 7585 7586 /* phys disk */ 7587 phys_disk_num = 0xFF; 7588 while (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply, 7589 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_GET_NEXT_PHYSDISKNUM, 7590 phys_disk_num))) { 7591 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7592 MPI2_IOCSTATUS_MASK; 7593 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 7594 pr_info(MPT3SAS_FMT "\tbreak from phys disk scan: "\ 7595 "ioc_status(0x%04x), loginfo(0x%08x)\n", 7596 ioc->name, ioc_status, 7597 le32_to_cpu(mpi_reply.IOCLogInfo)); 7598 break; 7599 } 7600 phys_disk_num = pd_pg0.PhysDiskNum; 7601 handle = le16_to_cpu(pd_pg0.DevHandle); 7602 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 7603 if (sas_device) { 7604 sas_device_put(sas_device); 7605 continue; 7606 } 7607 if (mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 7608 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, 7609 handle) != 0) 7610 continue; 7611 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7612 MPI2_IOCSTATUS_MASK; 7613 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 7614 pr_info(MPT3SAS_FMT "\tbreak from phys disk scan " \ 7615 "ioc_status(0x%04x), loginfo(0x%08x)\n", 7616 ioc->name, ioc_status, 7617 le32_to_cpu(mpi_reply.IOCLogInfo)); 7618 break; 7619 } 7620 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 7621 if (!_scsih_get_sas_address(ioc, parent_handle, 7622 &sas_address)) { 7623 pr_info(MPT3SAS_FMT "\tBEFORE adding phys disk: " \ 7624 " handle (0x%04x), sas_addr(0x%016llx)\n", 7625 ioc->name, handle, (unsigned long long) 7626 le64_to_cpu(sas_device_pg0.SASAddress)); 7627 mpt3sas_transport_update_links(ioc, sas_address, 7628 handle, sas_device_pg0.PhyNum, 7629 MPI2_SAS_NEG_LINK_RATE_1_5); 7630 set_bit(handle, ioc->pd_handles); 7631 retry_count = 0; 7632 /* This will retry adding the end device. 7633 * _scsih_add_device() will decide on retries and 7634 * return "1" when it should be retried 7635 */ 7636 while (_scsih_add_device(ioc, handle, retry_count++, 7637 1)) { 7638 ssleep(1); 7639 } 7640 pr_info(MPT3SAS_FMT "\tAFTER adding phys disk: " \ 7641 " handle (0x%04x), sas_addr(0x%016llx)\n", 7642 ioc->name, handle, (unsigned long long) 7643 le64_to_cpu(sas_device_pg0.SASAddress)); 7644 } 7645 } 7646 7647 pr_info(MPT3SAS_FMT "\tscan devices: phys disk complete\n", 7648 ioc->name); 7649 7650 pr_info(MPT3SAS_FMT "\tscan devices: volumes start\n", ioc->name); 7651 7652 /* volumes */ 7653 handle = 0xFFFF; 7654 while (!(mpt3sas_config_get_raid_volume_pg1(ioc, &mpi_reply, 7655 &volume_pg1, MPI2_RAID_VOLUME_PGAD_FORM_GET_NEXT_HANDLE, handle))) { 7656 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7657 MPI2_IOCSTATUS_MASK; 7658 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 7659 pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \ 7660 "ioc_status(0x%04x), loginfo(0x%08x)\n", 7661 ioc->name, ioc_status, 7662 le32_to_cpu(mpi_reply.IOCLogInfo)); 7663 break; 7664 } 7665 handle = le16_to_cpu(volume_pg1.DevHandle); 7666 spin_lock_irqsave(&ioc->raid_device_lock, flags); 7667 raid_device = _scsih_raid_device_find_by_wwid(ioc, 7668 le64_to_cpu(volume_pg1.WWID)); 7669 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 7670 if (raid_device) 7671 continue; 7672 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, 7673 &volume_pg0, MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle, 7674 sizeof(Mpi2RaidVolPage0_t))) 7675 continue; 7676 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7677 MPI2_IOCSTATUS_MASK; 7678 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 7679 pr_info(MPT3SAS_FMT "\tbreak from volume scan: " \ 7680 "ioc_status(0x%04x), loginfo(0x%08x)\n", 7681 ioc->name, ioc_status, 7682 le32_to_cpu(mpi_reply.IOCLogInfo)); 7683 break; 7684 } 7685 if (volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_OPTIMAL || 7686 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_ONLINE || 7687 volume_pg0.VolumeState == MPI2_RAID_VOL_STATE_DEGRADED) { 7688 memset(&element, 0, sizeof(Mpi2EventIrConfigElement_t)); 7689 element.ReasonCode = MPI2_EVENT_IR_CHANGE_RC_ADDED; 7690 element.VolDevHandle = volume_pg1.DevHandle; 7691 pr_info(MPT3SAS_FMT 7692 "\tBEFORE adding volume: handle (0x%04x)\n", 7693 ioc->name, volume_pg1.DevHandle); 7694 _scsih_sas_volume_add(ioc, &element); 7695 pr_info(MPT3SAS_FMT 7696 "\tAFTER adding volume: handle (0x%04x)\n", 7697 ioc->name, volume_pg1.DevHandle); 7698 } 7699 } 7700 7701 pr_info(MPT3SAS_FMT "\tscan devices: volumes complete\n", 7702 ioc->name); 7703 7704 skip_to_sas: 7705 7706 pr_info(MPT3SAS_FMT "\tscan devices: end devices start\n", 7707 ioc->name); 7708 7709 /* sas devices */ 7710 handle = 0xFFFF; 7711 while (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 7712 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_GET_NEXT_HANDLE, 7713 handle))) { 7714 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 7715 MPI2_IOCSTATUS_MASK; 7716 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 7717 pr_info(MPT3SAS_FMT "\tbreak from end device scan:"\ 7718 " ioc_status(0x%04x), loginfo(0x%08x)\n", 7719 ioc->name, ioc_status, 7720 le32_to_cpu(mpi_reply.IOCLogInfo)); 7721 break; 7722 } 7723 handle = le16_to_cpu(sas_device_pg0.DevHandle); 7724 if (!(_scsih_is_end_device( 7725 le32_to_cpu(sas_device_pg0.DeviceInfo)))) 7726 continue; 7727 sas_device = mpt3sas_get_sdev_by_addr(ioc, 7728 le64_to_cpu(sas_device_pg0.SASAddress)); 7729 if (sas_device) { 7730 sas_device_put(sas_device); 7731 continue; 7732 } 7733 parent_handle = le16_to_cpu(sas_device_pg0.ParentDevHandle); 7734 if (!_scsih_get_sas_address(ioc, parent_handle, &sas_address)) { 7735 pr_info(MPT3SAS_FMT "\tBEFORE adding end device: " \ 7736 "handle (0x%04x), sas_addr(0x%016llx)\n", ioc->name, 7737 handle, (unsigned long long) 7738 le64_to_cpu(sas_device_pg0.SASAddress)); 7739 mpt3sas_transport_update_links(ioc, sas_address, handle, 7740 sas_device_pg0.PhyNum, MPI2_SAS_NEG_LINK_RATE_1_5); 7741 retry_count = 0; 7742 /* This will retry adding the end device. 7743 * _scsih_add_device() will decide on retries and 7744 * return "1" when it should be retried 7745 */ 7746 while (_scsih_add_device(ioc, handle, retry_count++, 7747 0)) { 7748 ssleep(1); 7749 } 7750 pr_info(MPT3SAS_FMT "\tAFTER 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 } 7755 } 7756 pr_info(MPT3SAS_FMT "\tscan devices: end devices complete\n", 7757 ioc->name); 7758 7759 pr_info(MPT3SAS_FMT "scan devices: complete\n", ioc->name); 7760 } 7761 /** 7762 * mpt3sas_scsih_reset_handler - reset callback handler (for scsih) 7763 * @ioc: per adapter object 7764 * @reset_phase: phase 7765 * 7766 * The handler for doing any required cleanup or initialization. 7767 * 7768 * The reset phase can be MPT3_IOC_PRE_RESET, MPT3_IOC_AFTER_RESET, 7769 * MPT3_IOC_DONE_RESET 7770 * 7771 * Return nothing. 7772 */ 7773 void 7774 mpt3sas_scsih_reset_handler(struct MPT3SAS_ADAPTER *ioc, int reset_phase) 7775 { 7776 switch (reset_phase) { 7777 case MPT3_IOC_PRE_RESET: 7778 dtmprintk(ioc, pr_info(MPT3SAS_FMT 7779 "%s: MPT3_IOC_PRE_RESET\n", ioc->name, __func__)); 7780 break; 7781 case MPT3_IOC_AFTER_RESET: 7782 dtmprintk(ioc, pr_info(MPT3SAS_FMT 7783 "%s: MPT3_IOC_AFTER_RESET\n", ioc->name, __func__)); 7784 if (ioc->scsih_cmds.status & MPT3_CMD_PENDING) { 7785 ioc->scsih_cmds.status |= MPT3_CMD_RESET; 7786 mpt3sas_base_free_smid(ioc, ioc->scsih_cmds.smid); 7787 complete(&ioc->scsih_cmds.done); 7788 } 7789 if (ioc->tm_cmds.status & MPT3_CMD_PENDING) { 7790 ioc->tm_cmds.status |= MPT3_CMD_RESET; 7791 mpt3sas_base_free_smid(ioc, ioc->tm_cmds.smid); 7792 complete(&ioc->tm_cmds.done); 7793 } 7794 7795 memset(ioc->pend_os_device_add, 0, ioc->pend_os_device_add_sz); 7796 memset(ioc->device_remove_in_progress, 0, 7797 ioc->device_remove_in_progress_sz); 7798 _scsih_fw_event_cleanup_queue(ioc); 7799 _scsih_flush_running_cmds(ioc); 7800 break; 7801 case MPT3_IOC_DONE_RESET: 7802 dtmprintk(ioc, pr_info(MPT3SAS_FMT 7803 "%s: MPT3_IOC_DONE_RESET\n", ioc->name, __func__)); 7804 if ((!ioc->is_driver_loading) && !(disable_discovery > 0 && 7805 !ioc->sas_hba.num_phys)) { 7806 _scsih_prep_device_scan(ioc); 7807 _scsih_search_responding_sas_devices(ioc); 7808 _scsih_search_responding_raid_devices(ioc); 7809 _scsih_search_responding_expanders(ioc); 7810 _scsih_error_recovery_delete_devices(ioc); 7811 } 7812 break; 7813 } 7814 } 7815 7816 /** 7817 * _mpt3sas_fw_work - delayed task for processing firmware events 7818 * @ioc: per adapter object 7819 * @fw_event: The fw_event_work object 7820 * Context: user. 7821 * 7822 * Return nothing. 7823 */ 7824 static void 7825 _mpt3sas_fw_work(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event) 7826 { 7827 _scsih_fw_event_del_from_list(ioc, fw_event); 7828 7829 /* the queue is being flushed so ignore this event */ 7830 if (ioc->remove_host || ioc->pci_error_recovery) { 7831 fw_event_work_put(fw_event); 7832 return; 7833 } 7834 7835 switch (fw_event->event) { 7836 case MPT3SAS_PROCESS_TRIGGER_DIAG: 7837 mpt3sas_process_trigger_data(ioc, 7838 (struct SL_WH_TRIGGERS_EVENT_DATA_T *) 7839 fw_event->event_data); 7840 break; 7841 case MPT3SAS_REMOVE_UNRESPONDING_DEVICES: 7842 while (scsi_host_in_recovery(ioc->shost) || 7843 ioc->shost_recovery) { 7844 /* 7845 * If we're unloading, bail. Otherwise, this can become 7846 * an infinite loop. 7847 */ 7848 if (ioc->remove_host) 7849 goto out; 7850 ssleep(1); 7851 } 7852 _scsih_remove_unresponding_sas_devices(ioc); 7853 _scsih_scan_for_devices_after_reset(ioc); 7854 break; 7855 case MPT3SAS_PORT_ENABLE_COMPLETE: 7856 ioc->start_scan = 0; 7857 if (missing_delay[0] != -1 && missing_delay[1] != -1) 7858 mpt3sas_base_update_missing_delay(ioc, missing_delay[0], 7859 missing_delay[1]); 7860 dewtprintk(ioc, pr_info(MPT3SAS_FMT 7861 "port enable: complete from worker thread\n", 7862 ioc->name)); 7863 break; 7864 case MPT3SAS_TURN_ON_PFA_LED: 7865 _scsih_turn_on_pfa_led(ioc, fw_event->device_handle); 7866 break; 7867 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST: 7868 _scsih_sas_topology_change_event(ioc, fw_event); 7869 break; 7870 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE: 7871 _scsih_sas_device_status_change_event(ioc, fw_event); 7872 break; 7873 case MPI2_EVENT_SAS_DISCOVERY: 7874 _scsih_sas_discovery_event(ioc, fw_event); 7875 break; 7876 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE: 7877 _scsih_sas_broadcast_primitive_event(ioc, fw_event); 7878 break; 7879 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE: 7880 _scsih_sas_enclosure_dev_status_change_event(ioc, 7881 fw_event); 7882 break; 7883 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST: 7884 _scsih_sas_ir_config_change_event(ioc, fw_event); 7885 break; 7886 case MPI2_EVENT_IR_VOLUME: 7887 _scsih_sas_ir_volume_event(ioc, fw_event); 7888 break; 7889 case MPI2_EVENT_IR_PHYSICAL_DISK: 7890 _scsih_sas_ir_physical_disk_event(ioc, fw_event); 7891 break; 7892 case MPI2_EVENT_IR_OPERATION_STATUS: 7893 _scsih_sas_ir_operation_status_event(ioc, fw_event); 7894 break; 7895 } 7896 out: 7897 fw_event_work_put(fw_event); 7898 } 7899 7900 /** 7901 * _firmware_event_work 7902 * @ioc: per adapter object 7903 * @work: The fw_event_work object 7904 * Context: user. 7905 * 7906 * wrappers for the work thread handling firmware events 7907 * 7908 * Return nothing. 7909 */ 7910 7911 static void 7912 _firmware_event_work(struct work_struct *work) 7913 { 7914 struct fw_event_work *fw_event = container_of(work, 7915 struct fw_event_work, work); 7916 7917 _mpt3sas_fw_work(fw_event->ioc, fw_event); 7918 } 7919 7920 /** 7921 * mpt3sas_scsih_event_callback - firmware event handler (called at ISR time) 7922 * @ioc: per adapter object 7923 * @msix_index: MSIX table index supplied by the OS 7924 * @reply: reply message frame(lower 32bit addr) 7925 * Context: interrupt. 7926 * 7927 * This function merely adds a new work task into ioc->firmware_event_thread. 7928 * The tasks are worked from _firmware_event_work in user context. 7929 * 7930 * Return 1 meaning mf should be freed from _base_interrupt 7931 * 0 means the mf is freed from this function. 7932 */ 7933 u8 7934 mpt3sas_scsih_event_callback(struct MPT3SAS_ADAPTER *ioc, u8 msix_index, 7935 u32 reply) 7936 { 7937 struct fw_event_work *fw_event; 7938 Mpi2EventNotificationReply_t *mpi_reply; 7939 u16 event; 7940 u16 sz; 7941 Mpi26EventDataActiveCableExcept_t *ActiveCableEventData; 7942 7943 /* events turned off due to host reset or driver unloading */ 7944 if (ioc->remove_host || ioc->pci_error_recovery) 7945 return 1; 7946 7947 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 7948 7949 if (unlikely(!mpi_reply)) { 7950 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n", 7951 ioc->name, __FILE__, __LINE__, __func__); 7952 return 1; 7953 } 7954 7955 event = le16_to_cpu(mpi_reply->Event); 7956 7957 if (event != MPI2_EVENT_LOG_ENTRY_ADDED) 7958 mpt3sas_trigger_event(ioc, event, 0); 7959 7960 switch (event) { 7961 /* handle these */ 7962 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE: 7963 { 7964 Mpi2EventDataSasBroadcastPrimitive_t *baen_data = 7965 (Mpi2EventDataSasBroadcastPrimitive_t *) 7966 mpi_reply->EventData; 7967 7968 if (baen_data->Primitive != 7969 MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT) 7970 return 1; 7971 7972 if (ioc->broadcast_aen_busy) { 7973 ioc->broadcast_aen_pending++; 7974 return 1; 7975 } else 7976 ioc->broadcast_aen_busy = 1; 7977 break; 7978 } 7979 7980 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST: 7981 _scsih_check_topo_delete_events(ioc, 7982 (Mpi2EventDataSasTopologyChangeList_t *) 7983 mpi_reply->EventData); 7984 break; 7985 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST: 7986 _scsih_check_ir_config_unhide_events(ioc, 7987 (Mpi2EventDataIrConfigChangeList_t *) 7988 mpi_reply->EventData); 7989 break; 7990 case MPI2_EVENT_IR_VOLUME: 7991 _scsih_check_volume_delete_events(ioc, 7992 (Mpi2EventDataIrVolume_t *) 7993 mpi_reply->EventData); 7994 break; 7995 case MPI2_EVENT_LOG_ENTRY_ADDED: 7996 { 7997 Mpi2EventDataLogEntryAdded_t *log_entry; 7998 u32 *log_code; 7999 8000 if (!ioc->is_warpdrive) 8001 break; 8002 8003 log_entry = (Mpi2EventDataLogEntryAdded_t *) 8004 mpi_reply->EventData; 8005 log_code = (u32 *)log_entry->LogData; 8006 8007 if (le16_to_cpu(log_entry->LogEntryQualifier) 8008 != MPT2_WARPDRIVE_LOGENTRY) 8009 break; 8010 8011 switch (le32_to_cpu(*log_code)) { 8012 case MPT2_WARPDRIVE_LC_SSDT: 8013 pr_warn(MPT3SAS_FMT "WarpDrive Warning: " 8014 "IO Throttling has occurred in the WarpDrive " 8015 "subsystem. Check WarpDrive documentation for " 8016 "additional details.\n", ioc->name); 8017 break; 8018 case MPT2_WARPDRIVE_LC_SSDLW: 8019 pr_warn(MPT3SAS_FMT "WarpDrive Warning: " 8020 "Program/Erase Cycles for the WarpDrive subsystem " 8021 "in degraded range. Check WarpDrive documentation " 8022 "for additional details.\n", ioc->name); 8023 break; 8024 case MPT2_WARPDRIVE_LC_SSDLF: 8025 pr_err(MPT3SAS_FMT "WarpDrive Fatal Error: " 8026 "There are no Program/Erase Cycles for the " 8027 "WarpDrive subsystem. The storage device will be " 8028 "in read-only mode. Check WarpDrive documentation " 8029 "for additional details.\n", ioc->name); 8030 break; 8031 case MPT2_WARPDRIVE_LC_BRMF: 8032 pr_err(MPT3SAS_FMT "WarpDrive Fatal Error: " 8033 "The Backup Rail Monitor has failed on the " 8034 "WarpDrive subsystem. Check WarpDrive " 8035 "documentation for additional details.\n", 8036 ioc->name); 8037 break; 8038 } 8039 8040 break; 8041 } 8042 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE: 8043 case MPI2_EVENT_IR_OPERATION_STATUS: 8044 case MPI2_EVENT_SAS_DISCOVERY: 8045 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE: 8046 case MPI2_EVENT_IR_PHYSICAL_DISK: 8047 break; 8048 8049 case MPI2_EVENT_TEMP_THRESHOLD: 8050 _scsih_temp_threshold_events(ioc, 8051 (Mpi2EventDataTemperature_t *) 8052 mpi_reply->EventData); 8053 break; 8054 case MPI2_EVENT_ACTIVE_CABLE_EXCEPTION: 8055 ActiveCableEventData = 8056 (Mpi26EventDataActiveCableExcept_t *) mpi_reply->EventData; 8057 switch (ActiveCableEventData->ReasonCode) { 8058 case MPI26_EVENT_ACTIVE_CABLE_INSUFFICIENT_POWER: 8059 pr_notice(MPT3SAS_FMT "Receptacle ID %d: This active cable" 8060 " requires %d mW of power\n", ioc->name, 8061 ActiveCableEventData->ReceptacleID, 8062 ActiveCableEventData->ActiveCablePowerRequirement); 8063 pr_notice(MPT3SAS_FMT "Receptacle ID %d: Devices connected" 8064 " to this active cable will not be seen\n", 8065 ioc->name, ActiveCableEventData->ReceptacleID); 8066 break; 8067 8068 case MPI26_EVENT_ACTIVE_CABLE_DEGRADED: 8069 pr_notice(MPT3SAS_FMT "ReceptacleID %d: This cable", 8070 ioc->name, ActiveCableEventData->ReceptacleID); 8071 pr_notice(" is not running at an optimal speed(12 Gb/s)\n"); 8072 break; 8073 } 8074 8075 break; 8076 8077 default: /* ignore the rest */ 8078 return 1; 8079 } 8080 8081 sz = le16_to_cpu(mpi_reply->EventDataLength) * 4; 8082 fw_event = alloc_fw_event_work(sz); 8083 if (!fw_event) { 8084 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 8085 ioc->name, __FILE__, __LINE__, __func__); 8086 return 1; 8087 } 8088 8089 memcpy(fw_event->event_data, mpi_reply->EventData, sz); 8090 fw_event->ioc = ioc; 8091 fw_event->VF_ID = mpi_reply->VF_ID; 8092 fw_event->VP_ID = mpi_reply->VP_ID; 8093 fw_event->event = event; 8094 _scsih_fw_event_add(ioc, fw_event); 8095 fw_event_work_put(fw_event); 8096 return 1; 8097 } 8098 8099 /** 8100 * _scsih_expander_node_remove - removing expander device from list. 8101 * @ioc: per adapter object 8102 * @sas_expander: the sas_device object 8103 * Context: Calling function should acquire ioc->sas_node_lock. 8104 * 8105 * Removing object and freeing associated memory from the 8106 * ioc->sas_expander_list. 8107 * 8108 * Return nothing. 8109 */ 8110 static void 8111 _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc, 8112 struct _sas_node *sas_expander) 8113 { 8114 struct _sas_port *mpt3sas_port, *next; 8115 8116 /* remove sibling ports attached to this expander */ 8117 list_for_each_entry_safe(mpt3sas_port, next, 8118 &sas_expander->sas_port_list, port_list) { 8119 if (ioc->shost_recovery) 8120 return; 8121 if (mpt3sas_port->remote_identify.device_type == 8122 SAS_END_DEVICE) 8123 mpt3sas_device_remove_by_sas_address(ioc, 8124 mpt3sas_port->remote_identify.sas_address); 8125 else if (mpt3sas_port->remote_identify.device_type == 8126 SAS_EDGE_EXPANDER_DEVICE || 8127 mpt3sas_port->remote_identify.device_type == 8128 SAS_FANOUT_EXPANDER_DEVICE) 8129 mpt3sas_expander_remove(ioc, 8130 mpt3sas_port->remote_identify.sas_address); 8131 } 8132 8133 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address, 8134 sas_expander->sas_address_parent); 8135 8136 pr_info(MPT3SAS_FMT 8137 "expander_remove: handle(0x%04x), sas_addr(0x%016llx)\n", 8138 ioc->name, 8139 sas_expander->handle, (unsigned long long) 8140 sas_expander->sas_address); 8141 8142 kfree(sas_expander->phy); 8143 kfree(sas_expander); 8144 } 8145 8146 /** 8147 * _scsih_ir_shutdown - IR shutdown notification 8148 * @ioc: per adapter object 8149 * 8150 * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that 8151 * the host system is shutting down. 8152 * 8153 * Return nothing. 8154 */ 8155 static void 8156 _scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc) 8157 { 8158 Mpi2RaidActionRequest_t *mpi_request; 8159 Mpi2RaidActionReply_t *mpi_reply; 8160 u16 smid; 8161 8162 /* is IR firmware build loaded ? */ 8163 if (!ioc->ir_firmware) 8164 return; 8165 8166 /* are there any volumes ? */ 8167 if (list_empty(&ioc->raid_device_list)) 8168 return; 8169 8170 mutex_lock(&ioc->scsih_cmds.mutex); 8171 8172 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) { 8173 pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n", 8174 ioc->name, __func__); 8175 goto out; 8176 } 8177 ioc->scsih_cmds.status = MPT3_CMD_PENDING; 8178 8179 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx); 8180 if (!smid) { 8181 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 8182 ioc->name, __func__); 8183 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 8184 goto out; 8185 } 8186 8187 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 8188 ioc->scsih_cmds.smid = smid; 8189 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t)); 8190 8191 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION; 8192 mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED; 8193 8194 if (!ioc->hide_ir_msg) 8195 pr_info(MPT3SAS_FMT "IR shutdown (sending)\n", ioc->name); 8196 init_completion(&ioc->scsih_cmds.done); 8197 ioc->put_smid_default(ioc, smid); 8198 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ); 8199 8200 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) { 8201 pr_err(MPT3SAS_FMT "%s: timeout\n", 8202 ioc->name, __func__); 8203 goto out; 8204 } 8205 8206 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) { 8207 mpi_reply = ioc->scsih_cmds.reply; 8208 if (!ioc->hide_ir_msg) 8209 pr_info(MPT3SAS_FMT "IR shutdown " 8210 "(complete): ioc_status(0x%04x), loginfo(0x%08x)\n", 8211 ioc->name, le16_to_cpu(mpi_reply->IOCStatus), 8212 le32_to_cpu(mpi_reply->IOCLogInfo)); 8213 } 8214 8215 out: 8216 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 8217 mutex_unlock(&ioc->scsih_cmds.mutex); 8218 } 8219 8220 /** 8221 * scsih_remove - detach and remove add host 8222 * @pdev: PCI device struct 8223 * 8224 * Routine called when unloading the driver. 8225 * Return nothing. 8226 */ 8227 static void scsih_remove(struct pci_dev *pdev) 8228 { 8229 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8230 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8231 struct _sas_port *mpt3sas_port, *next_port; 8232 struct _raid_device *raid_device, *next; 8233 struct MPT3SAS_TARGET *sas_target_priv_data; 8234 struct workqueue_struct *wq; 8235 unsigned long flags; 8236 8237 ioc->remove_host = 1; 8238 _scsih_fw_event_cleanup_queue(ioc); 8239 8240 spin_lock_irqsave(&ioc->fw_event_lock, flags); 8241 wq = ioc->firmware_event_thread; 8242 ioc->firmware_event_thread = NULL; 8243 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 8244 if (wq) 8245 destroy_workqueue(wq); 8246 8247 /* release all the volumes */ 8248 _scsih_ir_shutdown(ioc); 8249 list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list, 8250 list) { 8251 if (raid_device->starget) { 8252 sas_target_priv_data = 8253 raid_device->starget->hostdata; 8254 sas_target_priv_data->deleted = 1; 8255 scsi_remove_target(&raid_device->starget->dev); 8256 } 8257 pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n", 8258 ioc->name, raid_device->handle, 8259 (unsigned long long) raid_device->wwid); 8260 _scsih_raid_device_remove(ioc, raid_device); 8261 } 8262 8263 /* free ports attached to the sas_host */ 8264 list_for_each_entry_safe(mpt3sas_port, next_port, 8265 &ioc->sas_hba.sas_port_list, port_list) { 8266 if (mpt3sas_port->remote_identify.device_type == 8267 SAS_END_DEVICE) 8268 mpt3sas_device_remove_by_sas_address(ioc, 8269 mpt3sas_port->remote_identify.sas_address); 8270 else if (mpt3sas_port->remote_identify.device_type == 8271 SAS_EDGE_EXPANDER_DEVICE || 8272 mpt3sas_port->remote_identify.device_type == 8273 SAS_FANOUT_EXPANDER_DEVICE) 8274 mpt3sas_expander_remove(ioc, 8275 mpt3sas_port->remote_identify.sas_address); 8276 } 8277 8278 /* free phys attached to the sas_host */ 8279 if (ioc->sas_hba.num_phys) { 8280 kfree(ioc->sas_hba.phy); 8281 ioc->sas_hba.phy = NULL; 8282 ioc->sas_hba.num_phys = 0; 8283 } 8284 8285 sas_remove_host(shost); 8286 mpt3sas_base_detach(ioc); 8287 spin_lock(&gioc_lock); 8288 list_del(&ioc->list); 8289 spin_unlock(&gioc_lock); 8290 scsi_host_put(shost); 8291 } 8292 8293 /** 8294 * scsih_shutdown - routine call during system shutdown 8295 * @pdev: PCI device struct 8296 * 8297 * Return nothing. 8298 */ 8299 static void 8300 scsih_shutdown(struct pci_dev *pdev) 8301 { 8302 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8303 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8304 struct workqueue_struct *wq; 8305 unsigned long flags; 8306 8307 ioc->remove_host = 1; 8308 _scsih_fw_event_cleanup_queue(ioc); 8309 8310 spin_lock_irqsave(&ioc->fw_event_lock, flags); 8311 wq = ioc->firmware_event_thread; 8312 ioc->firmware_event_thread = NULL; 8313 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 8314 if (wq) 8315 destroy_workqueue(wq); 8316 8317 _scsih_ir_shutdown(ioc); 8318 mpt3sas_base_detach(ioc); 8319 } 8320 8321 8322 /** 8323 * _scsih_probe_boot_devices - reports 1st device 8324 * @ioc: per adapter object 8325 * 8326 * If specified in bios page 2, this routine reports the 1st 8327 * device scsi-ml or sas transport for persistent boot device 8328 * purposes. Please refer to function _scsih_determine_boot_device() 8329 */ 8330 static void 8331 _scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc) 8332 { 8333 u8 is_raid; 8334 void *device; 8335 struct _sas_device *sas_device; 8336 struct _raid_device *raid_device; 8337 u16 handle; 8338 u64 sas_address_parent; 8339 u64 sas_address; 8340 unsigned long flags; 8341 int rc; 8342 8343 /* no Bios, return immediately */ 8344 if (!ioc->bios_pg3.BiosVersion) 8345 return; 8346 8347 device = NULL; 8348 is_raid = 0; 8349 if (ioc->req_boot_device.device) { 8350 device = ioc->req_boot_device.device; 8351 is_raid = ioc->req_boot_device.is_raid; 8352 } else if (ioc->req_alt_boot_device.device) { 8353 device = ioc->req_alt_boot_device.device; 8354 is_raid = ioc->req_alt_boot_device.is_raid; 8355 } else if (ioc->current_boot_device.device) { 8356 device = ioc->current_boot_device.device; 8357 is_raid = ioc->current_boot_device.is_raid; 8358 } 8359 8360 if (!device) 8361 return; 8362 8363 if (is_raid) { 8364 raid_device = device; 8365 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 8366 raid_device->id, 0); 8367 if (rc) 8368 _scsih_raid_device_remove(ioc, raid_device); 8369 } else { 8370 spin_lock_irqsave(&ioc->sas_device_lock, flags); 8371 sas_device = device; 8372 handle = sas_device->handle; 8373 sas_address_parent = sas_device->sas_address_parent; 8374 sas_address = sas_device->sas_address; 8375 list_move_tail(&sas_device->list, &ioc->sas_device_list); 8376 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 8377 8378 if (ioc->hide_drives) 8379 return; 8380 if (!mpt3sas_transport_port_add(ioc, handle, 8381 sas_address_parent)) { 8382 _scsih_sas_device_remove(ioc, sas_device); 8383 } else if (!sas_device->starget) { 8384 if (!ioc->is_driver_loading) { 8385 mpt3sas_transport_port_remove(ioc, 8386 sas_address, 8387 sas_address_parent); 8388 _scsih_sas_device_remove(ioc, sas_device); 8389 } 8390 } 8391 } 8392 } 8393 8394 /** 8395 * _scsih_probe_raid - reporting raid volumes to scsi-ml 8396 * @ioc: per adapter object 8397 * 8398 * Called during initial loading of the driver. 8399 */ 8400 static void 8401 _scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc) 8402 { 8403 struct _raid_device *raid_device, *raid_next; 8404 int rc; 8405 8406 list_for_each_entry_safe(raid_device, raid_next, 8407 &ioc->raid_device_list, list) { 8408 if (raid_device->starget) 8409 continue; 8410 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 8411 raid_device->id, 0); 8412 if (rc) 8413 _scsih_raid_device_remove(ioc, raid_device); 8414 } 8415 } 8416 8417 static struct _sas_device *get_next_sas_device(struct MPT3SAS_ADAPTER *ioc) 8418 { 8419 struct _sas_device *sas_device = NULL; 8420 unsigned long flags; 8421 8422 spin_lock_irqsave(&ioc->sas_device_lock, flags); 8423 if (!list_empty(&ioc->sas_device_init_list)) { 8424 sas_device = list_first_entry(&ioc->sas_device_init_list, 8425 struct _sas_device, list); 8426 sas_device_get(sas_device); 8427 } 8428 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 8429 8430 return sas_device; 8431 } 8432 8433 static void sas_device_make_active(struct MPT3SAS_ADAPTER *ioc, 8434 struct _sas_device *sas_device) 8435 { 8436 unsigned long flags; 8437 8438 spin_lock_irqsave(&ioc->sas_device_lock, flags); 8439 8440 /* 8441 * Since we dropped the lock during the call to port_add(), we need to 8442 * be careful here that somebody else didn't move or delete this item 8443 * while we were busy with other things. 8444 * 8445 * If it was on the list, we need a put() for the reference the list 8446 * had. Either way, we need a get() for the destination list. 8447 */ 8448 if (!list_empty(&sas_device->list)) { 8449 list_del_init(&sas_device->list); 8450 sas_device_put(sas_device); 8451 } 8452 8453 sas_device_get(sas_device); 8454 list_add_tail(&sas_device->list, &ioc->sas_device_list); 8455 8456 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 8457 } 8458 8459 /** 8460 * _scsih_probe_sas - reporting sas devices to sas transport 8461 * @ioc: per adapter object 8462 * 8463 * Called during initial loading of the driver. 8464 */ 8465 static void 8466 _scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc) 8467 { 8468 struct _sas_device *sas_device; 8469 8470 if (ioc->hide_drives) 8471 return; 8472 8473 while ((sas_device = get_next_sas_device(ioc))) { 8474 if (!mpt3sas_transport_port_add(ioc, sas_device->handle, 8475 sas_device->sas_address_parent)) { 8476 _scsih_sas_device_remove(ioc, sas_device); 8477 sas_device_put(sas_device); 8478 continue; 8479 } else if (!sas_device->starget) { 8480 /* 8481 * When asyn scanning is enabled, its not possible to 8482 * remove devices while scanning is turned on due to an 8483 * oops in scsi_sysfs_add_sdev()->add_device()-> 8484 * sysfs_addrm_start() 8485 */ 8486 if (!ioc->is_driver_loading) { 8487 mpt3sas_transport_port_remove(ioc, 8488 sas_device->sas_address, 8489 sas_device->sas_address_parent); 8490 _scsih_sas_device_remove(ioc, sas_device); 8491 sas_device_put(sas_device); 8492 continue; 8493 } 8494 } 8495 sas_device_make_active(ioc, sas_device); 8496 sas_device_put(sas_device); 8497 } 8498 } 8499 8500 /** 8501 * _scsih_probe_devices - probing for devices 8502 * @ioc: per adapter object 8503 * 8504 * Called during initial loading of the driver. 8505 */ 8506 static void 8507 _scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc) 8508 { 8509 u16 volume_mapping_flags; 8510 8511 if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR)) 8512 return; /* return when IOC doesn't support initiator mode */ 8513 8514 _scsih_probe_boot_devices(ioc); 8515 8516 if (ioc->ir_firmware) { 8517 volume_mapping_flags = 8518 le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) & 8519 MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE; 8520 if (volume_mapping_flags == 8521 MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) { 8522 _scsih_probe_raid(ioc); 8523 _scsih_probe_sas(ioc); 8524 } else { 8525 _scsih_probe_sas(ioc); 8526 _scsih_probe_raid(ioc); 8527 } 8528 } else 8529 _scsih_probe_sas(ioc); 8530 } 8531 8532 /** 8533 * scsih_scan_start - scsi lld callback for .scan_start 8534 * @shost: SCSI host pointer 8535 * 8536 * The shost has the ability to discover targets on its own instead 8537 * of scanning the entire bus. In our implemention, we will kick off 8538 * firmware discovery. 8539 */ 8540 static void 8541 scsih_scan_start(struct Scsi_Host *shost) 8542 { 8543 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8544 int rc; 8545 if (diag_buffer_enable != -1 && diag_buffer_enable != 0) 8546 mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable); 8547 8548 if (disable_discovery > 0) 8549 return; 8550 8551 ioc->start_scan = 1; 8552 rc = mpt3sas_port_enable(ioc); 8553 8554 if (rc != 0) 8555 pr_info(MPT3SAS_FMT "port enable: FAILED\n", ioc->name); 8556 } 8557 8558 /** 8559 * scsih_scan_finished - scsi lld callback for .scan_finished 8560 * @shost: SCSI host pointer 8561 * @time: elapsed time of the scan in jiffies 8562 * 8563 * This function will be called periodicallyn until it returns 1 with the 8564 * scsi_host and the elapsed time of the scan in jiffies. In our implemention, 8565 * we wait for firmware discovery to complete, then return 1. 8566 */ 8567 static int 8568 scsih_scan_finished(struct Scsi_Host *shost, unsigned long time) 8569 { 8570 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8571 8572 if (disable_discovery > 0) { 8573 ioc->is_driver_loading = 0; 8574 ioc->wait_for_discovery_to_complete = 0; 8575 return 1; 8576 } 8577 8578 if (time >= (300 * HZ)) { 8579 ioc->base_cmds.status = MPT3_CMD_NOT_USED; 8580 pr_info(MPT3SAS_FMT 8581 "port enable: FAILED with timeout (timeout=300s)\n", 8582 ioc->name); 8583 ioc->is_driver_loading = 0; 8584 return 1; 8585 } 8586 8587 if (ioc->start_scan) 8588 return 0; 8589 8590 if (ioc->start_scan_failed) { 8591 pr_info(MPT3SAS_FMT 8592 "port enable: FAILED with (ioc_status=0x%08x)\n", 8593 ioc->name, ioc->start_scan_failed); 8594 ioc->is_driver_loading = 0; 8595 ioc->wait_for_discovery_to_complete = 0; 8596 ioc->remove_host = 1; 8597 return 1; 8598 } 8599 8600 pr_info(MPT3SAS_FMT "port enable: SUCCESS\n", ioc->name); 8601 ioc->base_cmds.status = MPT3_CMD_NOT_USED; 8602 8603 if (ioc->wait_for_discovery_to_complete) { 8604 ioc->wait_for_discovery_to_complete = 0; 8605 _scsih_probe_devices(ioc); 8606 } 8607 mpt3sas_base_start_watchdog(ioc); 8608 ioc->is_driver_loading = 0; 8609 return 1; 8610 } 8611 8612 /* shost template for SAS 2.0 HBA devices */ 8613 static struct scsi_host_template mpt2sas_driver_template = { 8614 .module = THIS_MODULE, 8615 .name = "Fusion MPT SAS Host", 8616 .proc_name = MPT2SAS_DRIVER_NAME, 8617 .queuecommand = scsih_qcmd, 8618 .target_alloc = scsih_target_alloc, 8619 .slave_alloc = scsih_slave_alloc, 8620 .slave_configure = scsih_slave_configure, 8621 .target_destroy = scsih_target_destroy, 8622 .slave_destroy = scsih_slave_destroy, 8623 .scan_finished = scsih_scan_finished, 8624 .scan_start = scsih_scan_start, 8625 .change_queue_depth = scsih_change_queue_depth, 8626 .eh_abort_handler = scsih_abort, 8627 .eh_device_reset_handler = scsih_dev_reset, 8628 .eh_target_reset_handler = scsih_target_reset, 8629 .eh_host_reset_handler = scsih_host_reset, 8630 .bios_param = scsih_bios_param, 8631 .can_queue = 1, 8632 .this_id = -1, 8633 .sg_tablesize = MPT2SAS_SG_DEPTH, 8634 .max_sectors = 32767, 8635 .cmd_per_lun = 7, 8636 .use_clustering = ENABLE_CLUSTERING, 8637 .shost_attrs = mpt3sas_host_attrs, 8638 .sdev_attrs = mpt3sas_dev_attrs, 8639 .track_queue_depth = 1, 8640 }; 8641 8642 /* raid transport support for SAS 2.0 HBA devices */ 8643 static struct raid_function_template mpt2sas_raid_functions = { 8644 .cookie = &mpt2sas_driver_template, 8645 .is_raid = scsih_is_raid, 8646 .get_resync = scsih_get_resync, 8647 .get_state = scsih_get_state, 8648 }; 8649 8650 /* shost template for SAS 3.0 HBA devices */ 8651 static struct scsi_host_template mpt3sas_driver_template = { 8652 .module = THIS_MODULE, 8653 .name = "Fusion MPT SAS Host", 8654 .proc_name = MPT3SAS_DRIVER_NAME, 8655 .queuecommand = scsih_qcmd, 8656 .target_alloc = scsih_target_alloc, 8657 .slave_alloc = scsih_slave_alloc, 8658 .slave_configure = scsih_slave_configure, 8659 .target_destroy = scsih_target_destroy, 8660 .slave_destroy = scsih_slave_destroy, 8661 .scan_finished = scsih_scan_finished, 8662 .scan_start = scsih_scan_start, 8663 .change_queue_depth = scsih_change_queue_depth, 8664 .eh_abort_handler = scsih_abort, 8665 .eh_device_reset_handler = scsih_dev_reset, 8666 .eh_target_reset_handler = scsih_target_reset, 8667 .eh_host_reset_handler = scsih_host_reset, 8668 .bios_param = scsih_bios_param, 8669 .can_queue = 1, 8670 .this_id = -1, 8671 .sg_tablesize = MPT3SAS_SG_DEPTH, 8672 .max_sectors = 32767, 8673 .cmd_per_lun = 7, 8674 .use_clustering = ENABLE_CLUSTERING, 8675 .shost_attrs = mpt3sas_host_attrs, 8676 .sdev_attrs = mpt3sas_dev_attrs, 8677 .track_queue_depth = 1, 8678 }; 8679 8680 /* raid transport support for SAS 3.0 HBA devices */ 8681 static struct raid_function_template mpt3sas_raid_functions = { 8682 .cookie = &mpt3sas_driver_template, 8683 .is_raid = scsih_is_raid, 8684 .get_resync = scsih_get_resync, 8685 .get_state = scsih_get_state, 8686 }; 8687 8688 /** 8689 * _scsih_determine_hba_mpi_version - determine in which MPI version class 8690 * this device belongs to. 8691 * @pdev: PCI device struct 8692 * 8693 * return MPI2_VERSION for SAS 2.0 HBA devices, 8694 * MPI25_VERSION for SAS 3.0 HBA devices, and 8695 * MPI26 VERSION for Cutlass & Invader SAS 3.0 HBA devices 8696 */ 8697 static u16 8698 _scsih_determine_hba_mpi_version(struct pci_dev *pdev) 8699 { 8700 8701 switch (pdev->device) { 8702 case MPI2_MFGPAGE_DEVID_SSS6200: 8703 case MPI2_MFGPAGE_DEVID_SAS2004: 8704 case MPI2_MFGPAGE_DEVID_SAS2008: 8705 case MPI2_MFGPAGE_DEVID_SAS2108_1: 8706 case MPI2_MFGPAGE_DEVID_SAS2108_2: 8707 case MPI2_MFGPAGE_DEVID_SAS2108_3: 8708 case MPI2_MFGPAGE_DEVID_SAS2116_1: 8709 case MPI2_MFGPAGE_DEVID_SAS2116_2: 8710 case MPI2_MFGPAGE_DEVID_SAS2208_1: 8711 case MPI2_MFGPAGE_DEVID_SAS2208_2: 8712 case MPI2_MFGPAGE_DEVID_SAS2208_3: 8713 case MPI2_MFGPAGE_DEVID_SAS2208_4: 8714 case MPI2_MFGPAGE_DEVID_SAS2208_5: 8715 case MPI2_MFGPAGE_DEVID_SAS2208_6: 8716 case MPI2_MFGPAGE_DEVID_SAS2308_1: 8717 case MPI2_MFGPAGE_DEVID_SAS2308_2: 8718 case MPI2_MFGPAGE_DEVID_SAS2308_3: 8719 return MPI2_VERSION; 8720 case MPI25_MFGPAGE_DEVID_SAS3004: 8721 case MPI25_MFGPAGE_DEVID_SAS3008: 8722 case MPI25_MFGPAGE_DEVID_SAS3108_1: 8723 case MPI25_MFGPAGE_DEVID_SAS3108_2: 8724 case MPI25_MFGPAGE_DEVID_SAS3108_5: 8725 case MPI25_MFGPAGE_DEVID_SAS3108_6: 8726 return MPI25_VERSION; 8727 case MPI26_MFGPAGE_DEVID_SAS3216: 8728 case MPI26_MFGPAGE_DEVID_SAS3224: 8729 case MPI26_MFGPAGE_DEVID_SAS3316_1: 8730 case MPI26_MFGPAGE_DEVID_SAS3316_2: 8731 case MPI26_MFGPAGE_DEVID_SAS3316_3: 8732 case MPI26_MFGPAGE_DEVID_SAS3316_4: 8733 case MPI26_MFGPAGE_DEVID_SAS3324_1: 8734 case MPI26_MFGPAGE_DEVID_SAS3324_2: 8735 case MPI26_MFGPAGE_DEVID_SAS3324_3: 8736 case MPI26_MFGPAGE_DEVID_SAS3324_4: 8737 case MPI26_MFGPAGE_DEVID_SAS3508: 8738 case MPI26_MFGPAGE_DEVID_SAS3508_1: 8739 case MPI26_MFGPAGE_DEVID_SAS3408: 8740 case MPI26_MFGPAGE_DEVID_SAS3516: 8741 case MPI26_MFGPAGE_DEVID_SAS3516_1: 8742 case MPI26_MFGPAGE_DEVID_SAS3416: 8743 return MPI26_VERSION; 8744 } 8745 return 0; 8746 } 8747 8748 /** 8749 * _scsih_probe - attach and add scsi host 8750 * @pdev: PCI device struct 8751 * @id: pci device id 8752 * 8753 * Returns 0 success, anything else error. 8754 */ 8755 static int 8756 _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id) 8757 { 8758 struct MPT3SAS_ADAPTER *ioc; 8759 struct Scsi_Host *shost = NULL; 8760 int rv; 8761 u16 hba_mpi_version; 8762 8763 /* Determine in which MPI version class this pci device belongs */ 8764 hba_mpi_version = _scsih_determine_hba_mpi_version(pdev); 8765 if (hba_mpi_version == 0) 8766 return -ENODEV; 8767 8768 /* Enumerate only SAS 2.0 HBA's if hbas_to_enumerate is one, 8769 * for other generation HBA's return with -ENODEV 8770 */ 8771 if ((hbas_to_enumerate == 1) && (hba_mpi_version != MPI2_VERSION)) 8772 return -ENODEV; 8773 8774 /* Enumerate only SAS 3.0 HBA's if hbas_to_enumerate is two, 8775 * for other generation HBA's return with -ENODEV 8776 */ 8777 if ((hbas_to_enumerate == 2) && (!(hba_mpi_version == MPI25_VERSION 8778 || hba_mpi_version == MPI26_VERSION))) 8779 return -ENODEV; 8780 8781 switch (hba_mpi_version) { 8782 case MPI2_VERSION: 8783 pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S | 8784 PCIE_LINK_STATE_L1 | PCIE_LINK_STATE_CLKPM); 8785 /* Use mpt2sas driver host template for SAS 2.0 HBA's */ 8786 shost = scsi_host_alloc(&mpt2sas_driver_template, 8787 sizeof(struct MPT3SAS_ADAPTER)); 8788 if (!shost) 8789 return -ENODEV; 8790 ioc = shost_priv(shost); 8791 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER)); 8792 ioc->hba_mpi_version_belonged = hba_mpi_version; 8793 ioc->id = mpt2_ids++; 8794 sprintf(ioc->driver_name, "%s", MPT2SAS_DRIVER_NAME); 8795 if (pdev->device == MPI2_MFGPAGE_DEVID_SSS6200) { 8796 ioc->is_warpdrive = 1; 8797 ioc->hide_ir_msg = 1; 8798 } else 8799 ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS; 8800 break; 8801 case MPI25_VERSION: 8802 case MPI26_VERSION: 8803 /* Use mpt3sas driver host template for SAS 3.0 HBA's */ 8804 shost = scsi_host_alloc(&mpt3sas_driver_template, 8805 sizeof(struct MPT3SAS_ADAPTER)); 8806 if (!shost) 8807 return -ENODEV; 8808 ioc = shost_priv(shost); 8809 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER)); 8810 ioc->hba_mpi_version_belonged = hba_mpi_version; 8811 ioc->id = mpt3_ids++; 8812 sprintf(ioc->driver_name, "%s", MPT3SAS_DRIVER_NAME); 8813 switch (pdev->device) { 8814 case MPI26_MFGPAGE_DEVID_SAS3508: 8815 case MPI26_MFGPAGE_DEVID_SAS3508_1: 8816 case MPI26_MFGPAGE_DEVID_SAS3408: 8817 case MPI26_MFGPAGE_DEVID_SAS3516: 8818 case MPI26_MFGPAGE_DEVID_SAS3516_1: 8819 case MPI26_MFGPAGE_DEVID_SAS3416: 8820 ioc->is_gen35_ioc = 1; 8821 break; 8822 default: 8823 ioc->is_gen35_ioc = 0; 8824 } 8825 if ((ioc->hba_mpi_version_belonged == MPI25_VERSION && 8826 pdev->revision >= SAS3_PCI_DEVICE_C0_REVISION) || 8827 (ioc->hba_mpi_version_belonged == MPI26_VERSION)) { 8828 ioc->combined_reply_queue = 1; 8829 if (ioc->is_gen35_ioc) 8830 ioc->combined_reply_index_count = 8831 MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G35; 8832 else 8833 ioc->combined_reply_index_count = 8834 MPT3_SUP_REPLY_POST_HOST_INDEX_REG_COUNT_G3; 8835 } 8836 break; 8837 default: 8838 return -ENODEV; 8839 } 8840 8841 INIT_LIST_HEAD(&ioc->list); 8842 spin_lock(&gioc_lock); 8843 list_add_tail(&ioc->list, &mpt3sas_ioc_list); 8844 spin_unlock(&gioc_lock); 8845 ioc->shost = shost; 8846 ioc->pdev = pdev; 8847 ioc->scsi_io_cb_idx = scsi_io_cb_idx; 8848 ioc->tm_cb_idx = tm_cb_idx; 8849 ioc->ctl_cb_idx = ctl_cb_idx; 8850 ioc->base_cb_idx = base_cb_idx; 8851 ioc->port_enable_cb_idx = port_enable_cb_idx; 8852 ioc->transport_cb_idx = transport_cb_idx; 8853 ioc->scsih_cb_idx = scsih_cb_idx; 8854 ioc->config_cb_idx = config_cb_idx; 8855 ioc->tm_tr_cb_idx = tm_tr_cb_idx; 8856 ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx; 8857 ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx; 8858 ioc->logging_level = logging_level; 8859 ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds; 8860 /* misc semaphores and spin locks */ 8861 mutex_init(&ioc->reset_in_progress_mutex); 8862 /* initializing pci_access_mutex lock */ 8863 mutex_init(&ioc->pci_access_mutex); 8864 spin_lock_init(&ioc->ioc_reset_in_progress_lock); 8865 spin_lock_init(&ioc->scsi_lookup_lock); 8866 spin_lock_init(&ioc->sas_device_lock); 8867 spin_lock_init(&ioc->sas_node_lock); 8868 spin_lock_init(&ioc->fw_event_lock); 8869 spin_lock_init(&ioc->raid_device_lock); 8870 spin_lock_init(&ioc->diag_trigger_lock); 8871 8872 INIT_LIST_HEAD(&ioc->sas_device_list); 8873 INIT_LIST_HEAD(&ioc->sas_device_init_list); 8874 INIT_LIST_HEAD(&ioc->sas_expander_list); 8875 INIT_LIST_HEAD(&ioc->fw_event_list); 8876 INIT_LIST_HEAD(&ioc->raid_device_list); 8877 INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list); 8878 INIT_LIST_HEAD(&ioc->delayed_tr_list); 8879 INIT_LIST_HEAD(&ioc->delayed_sc_list); 8880 INIT_LIST_HEAD(&ioc->delayed_event_ack_list); 8881 INIT_LIST_HEAD(&ioc->delayed_tr_volume_list); 8882 INIT_LIST_HEAD(&ioc->reply_queue_list); 8883 8884 sprintf(ioc->name, "%s_cm%d", ioc->driver_name, ioc->id); 8885 8886 /* init shost parameters */ 8887 shost->max_cmd_len = 32; 8888 shost->max_lun = max_lun; 8889 shost->transportt = mpt3sas_transport_template; 8890 shost->unique_id = ioc->id; 8891 8892 if (max_sectors != 0xFFFF) { 8893 if (max_sectors < 64) { 8894 shost->max_sectors = 64; 8895 pr_warn(MPT3SAS_FMT "Invalid value %d passed " \ 8896 "for max_sectors, range is 64 to 32767. Assigning " 8897 "value of 64.\n", ioc->name, max_sectors); 8898 } else if (max_sectors > 32767) { 8899 shost->max_sectors = 32767; 8900 pr_warn(MPT3SAS_FMT "Invalid value %d passed " \ 8901 "for max_sectors, range is 64 to 32767. Assigning " 8902 "default value of 32767.\n", ioc->name, 8903 max_sectors); 8904 } else { 8905 shost->max_sectors = max_sectors & 0xFFFE; 8906 pr_info(MPT3SAS_FMT 8907 "The max_sectors value is set to %d\n", 8908 ioc->name, shost->max_sectors); 8909 } 8910 } 8911 8912 /* register EEDP capabilities with SCSI layer */ 8913 if (prot_mask > 0) 8914 scsi_host_set_prot(shost, prot_mask); 8915 else 8916 scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION 8917 | SHOST_DIF_TYPE2_PROTECTION 8918 | SHOST_DIF_TYPE3_PROTECTION); 8919 8920 scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC); 8921 8922 /* event thread */ 8923 snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name), 8924 "fw_event_%s%d", ioc->driver_name, ioc->id); 8925 ioc->firmware_event_thread = alloc_ordered_workqueue( 8926 ioc->firmware_event_name, WQ_MEM_RECLAIM); 8927 if (!ioc->firmware_event_thread) { 8928 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 8929 ioc->name, __FILE__, __LINE__, __func__); 8930 rv = -ENODEV; 8931 goto out_thread_fail; 8932 } 8933 8934 ioc->is_driver_loading = 1; 8935 if ((mpt3sas_base_attach(ioc))) { 8936 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 8937 ioc->name, __FILE__, __LINE__, __func__); 8938 rv = -ENODEV; 8939 goto out_attach_fail; 8940 } 8941 8942 if (ioc->is_warpdrive) { 8943 if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_EXPOSE_ALL_DISKS) 8944 ioc->hide_drives = 0; 8945 else if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_HIDE_ALL_DISKS) 8946 ioc->hide_drives = 1; 8947 else { 8948 if (mpt3sas_get_num_volumes(ioc)) 8949 ioc->hide_drives = 1; 8950 else 8951 ioc->hide_drives = 0; 8952 } 8953 } else 8954 ioc->hide_drives = 0; 8955 8956 rv = scsi_add_host(shost, &pdev->dev); 8957 if (rv) { 8958 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 8959 ioc->name, __FILE__, __LINE__, __func__); 8960 goto out_add_shost_fail; 8961 } 8962 8963 scsi_scan_host(shost); 8964 return 0; 8965 out_add_shost_fail: 8966 mpt3sas_base_detach(ioc); 8967 out_attach_fail: 8968 destroy_workqueue(ioc->firmware_event_thread); 8969 out_thread_fail: 8970 spin_lock(&gioc_lock); 8971 list_del(&ioc->list); 8972 spin_unlock(&gioc_lock); 8973 scsi_host_put(shost); 8974 return rv; 8975 } 8976 8977 #ifdef CONFIG_PM 8978 /** 8979 * scsih_suspend - power management suspend main entry point 8980 * @pdev: PCI device struct 8981 * @state: PM state change to (usually PCI_D3) 8982 * 8983 * Returns 0 success, anything else error. 8984 */ 8985 static int 8986 scsih_suspend(struct pci_dev *pdev, pm_message_t state) 8987 { 8988 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8989 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8990 pci_power_t device_state; 8991 8992 mpt3sas_base_stop_watchdog(ioc); 8993 flush_scheduled_work(); 8994 scsi_block_requests(shost); 8995 device_state = pci_choose_state(pdev, state); 8996 pr_info(MPT3SAS_FMT 8997 "pdev=0x%p, slot=%s, entering operating state [D%d]\n", 8998 ioc->name, pdev, pci_name(pdev), device_state); 8999 9000 pci_save_state(pdev); 9001 mpt3sas_base_free_resources(ioc); 9002 pci_set_power_state(pdev, device_state); 9003 return 0; 9004 } 9005 9006 /** 9007 * scsih_resume - power management resume main entry point 9008 * @pdev: PCI device struct 9009 * 9010 * Returns 0 success, anything else error. 9011 */ 9012 static int 9013 scsih_resume(struct pci_dev *pdev) 9014 { 9015 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9016 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 9017 pci_power_t device_state = pdev->current_state; 9018 int r; 9019 9020 pr_info(MPT3SAS_FMT 9021 "pdev=0x%p, slot=%s, previous operating state [D%d]\n", 9022 ioc->name, pdev, pci_name(pdev), device_state); 9023 9024 pci_set_power_state(pdev, PCI_D0); 9025 pci_enable_wake(pdev, PCI_D0, 0); 9026 pci_restore_state(pdev); 9027 ioc->pdev = pdev; 9028 r = mpt3sas_base_map_resources(ioc); 9029 if (r) 9030 return r; 9031 9032 mpt3sas_base_hard_reset_handler(ioc, SOFT_RESET); 9033 scsi_unblock_requests(shost); 9034 mpt3sas_base_start_watchdog(ioc); 9035 return 0; 9036 } 9037 #endif /* CONFIG_PM */ 9038 9039 /** 9040 * scsih_pci_error_detected - Called when a PCI error is detected. 9041 * @pdev: PCI device struct 9042 * @state: PCI channel state 9043 * 9044 * Description: Called when a PCI error is detected. 9045 * 9046 * Return value: 9047 * PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT 9048 */ 9049 static pci_ers_result_t 9050 scsih_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state) 9051 { 9052 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9053 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 9054 9055 pr_info(MPT3SAS_FMT "PCI error: detected callback, state(%d)!!\n", 9056 ioc->name, state); 9057 9058 switch (state) { 9059 case pci_channel_io_normal: 9060 return PCI_ERS_RESULT_CAN_RECOVER; 9061 case pci_channel_io_frozen: 9062 /* Fatal error, prepare for slot reset */ 9063 ioc->pci_error_recovery = 1; 9064 scsi_block_requests(ioc->shost); 9065 mpt3sas_base_stop_watchdog(ioc); 9066 mpt3sas_base_free_resources(ioc); 9067 return PCI_ERS_RESULT_NEED_RESET; 9068 case pci_channel_io_perm_failure: 9069 /* Permanent error, prepare for device removal */ 9070 ioc->pci_error_recovery = 1; 9071 mpt3sas_base_stop_watchdog(ioc); 9072 _scsih_flush_running_cmds(ioc); 9073 return PCI_ERS_RESULT_DISCONNECT; 9074 } 9075 return PCI_ERS_RESULT_NEED_RESET; 9076 } 9077 9078 /** 9079 * scsih_pci_slot_reset - Called when PCI slot has been reset. 9080 * @pdev: PCI device struct 9081 * 9082 * Description: This routine is called by the pci error recovery 9083 * code after the PCI slot has been reset, just before we 9084 * should resume normal operations. 9085 */ 9086 static pci_ers_result_t 9087 scsih_pci_slot_reset(struct pci_dev *pdev) 9088 { 9089 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9090 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 9091 int rc; 9092 9093 pr_info(MPT3SAS_FMT "PCI error: slot reset callback!!\n", 9094 ioc->name); 9095 9096 ioc->pci_error_recovery = 0; 9097 ioc->pdev = pdev; 9098 pci_restore_state(pdev); 9099 rc = mpt3sas_base_map_resources(ioc); 9100 if (rc) 9101 return PCI_ERS_RESULT_DISCONNECT; 9102 9103 rc = mpt3sas_base_hard_reset_handler(ioc, FORCE_BIG_HAMMER); 9104 9105 pr_warn(MPT3SAS_FMT "hard reset: %s\n", ioc->name, 9106 (rc == 0) ? "success" : "failed"); 9107 9108 if (!rc) 9109 return PCI_ERS_RESULT_RECOVERED; 9110 else 9111 return PCI_ERS_RESULT_DISCONNECT; 9112 } 9113 9114 /** 9115 * scsih_pci_resume() - resume normal ops after PCI reset 9116 * @pdev: pointer to PCI device 9117 * 9118 * Called when the error recovery driver tells us that its 9119 * OK to resume normal operation. Use completion to allow 9120 * halted scsi ops to resume. 9121 */ 9122 static void 9123 scsih_pci_resume(struct pci_dev *pdev) 9124 { 9125 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9126 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 9127 9128 pr_info(MPT3SAS_FMT "PCI error: resume callback!!\n", ioc->name); 9129 9130 pci_cleanup_aer_uncorrect_error_status(pdev); 9131 mpt3sas_base_start_watchdog(ioc); 9132 scsi_unblock_requests(ioc->shost); 9133 } 9134 9135 /** 9136 * scsih_pci_mmio_enabled - Enable MMIO and dump debug registers 9137 * @pdev: pointer to PCI device 9138 */ 9139 static pci_ers_result_t 9140 scsih_pci_mmio_enabled(struct pci_dev *pdev) 9141 { 9142 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9143 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 9144 9145 pr_info(MPT3SAS_FMT "PCI error: mmio enabled callback!!\n", 9146 ioc->name); 9147 9148 /* TODO - dump whatever for debugging purposes */ 9149 9150 /* This called only if scsih_pci_error_detected returns 9151 * PCI_ERS_RESULT_CAN_RECOVER. Read/write to the device still 9152 * works, no need to reset slot. 9153 */ 9154 return PCI_ERS_RESULT_RECOVERED; 9155 } 9156 9157 /** 9158 * scsih__ncq_prio_supp - Check for NCQ command priority support 9159 * @sdev: scsi device struct 9160 * 9161 * This is called when a user indicates they would like to enable 9162 * ncq command priorities. This works only on SATA devices. 9163 */ 9164 bool scsih_ncq_prio_supp(struct scsi_device *sdev) 9165 { 9166 unsigned char *buf; 9167 bool ncq_prio_supp = false; 9168 9169 if (!scsi_device_supports_vpd(sdev)) 9170 return ncq_prio_supp; 9171 9172 buf = kmalloc(SCSI_VPD_PG_LEN, GFP_KERNEL); 9173 if (!buf) 9174 return ncq_prio_supp; 9175 9176 if (!scsi_get_vpd_page(sdev, 0x89, buf, SCSI_VPD_PG_LEN)) 9177 ncq_prio_supp = (buf[213] >> 4) & 1; 9178 9179 kfree(buf); 9180 return ncq_prio_supp; 9181 } 9182 /* 9183 * The pci device ids are defined in mpi/mpi2_cnfg.h. 9184 */ 9185 static const struct pci_device_id mpt3sas_pci_table[] = { 9186 /* Spitfire ~ 2004 */ 9187 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2004, 9188 PCI_ANY_ID, PCI_ANY_ID }, 9189 /* Falcon ~ 2008 */ 9190 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2008, 9191 PCI_ANY_ID, PCI_ANY_ID }, 9192 /* Liberator ~ 2108 */ 9193 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_1, 9194 PCI_ANY_ID, PCI_ANY_ID }, 9195 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_2, 9196 PCI_ANY_ID, PCI_ANY_ID }, 9197 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_3, 9198 PCI_ANY_ID, PCI_ANY_ID }, 9199 /* Meteor ~ 2116 */ 9200 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_1, 9201 PCI_ANY_ID, PCI_ANY_ID }, 9202 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_2, 9203 PCI_ANY_ID, PCI_ANY_ID }, 9204 /* Thunderbolt ~ 2208 */ 9205 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_1, 9206 PCI_ANY_ID, PCI_ANY_ID }, 9207 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_2, 9208 PCI_ANY_ID, PCI_ANY_ID }, 9209 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_3, 9210 PCI_ANY_ID, PCI_ANY_ID }, 9211 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_4, 9212 PCI_ANY_ID, PCI_ANY_ID }, 9213 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_5, 9214 PCI_ANY_ID, PCI_ANY_ID }, 9215 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_6, 9216 PCI_ANY_ID, PCI_ANY_ID }, 9217 /* Mustang ~ 2308 */ 9218 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_1, 9219 PCI_ANY_ID, PCI_ANY_ID }, 9220 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_2, 9221 PCI_ANY_ID, PCI_ANY_ID }, 9222 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_3, 9223 PCI_ANY_ID, PCI_ANY_ID }, 9224 /* SSS6200 */ 9225 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SSS6200, 9226 PCI_ANY_ID, PCI_ANY_ID }, 9227 /* Fury ~ 3004 and 3008 */ 9228 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3004, 9229 PCI_ANY_ID, PCI_ANY_ID }, 9230 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3008, 9231 PCI_ANY_ID, PCI_ANY_ID }, 9232 /* Invader ~ 3108 */ 9233 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_1, 9234 PCI_ANY_ID, PCI_ANY_ID }, 9235 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_2, 9236 PCI_ANY_ID, PCI_ANY_ID }, 9237 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_5, 9238 PCI_ANY_ID, PCI_ANY_ID }, 9239 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_6, 9240 PCI_ANY_ID, PCI_ANY_ID }, 9241 /* Cutlass ~ 3216 and 3224 */ 9242 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3216, 9243 PCI_ANY_ID, PCI_ANY_ID }, 9244 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3224, 9245 PCI_ANY_ID, PCI_ANY_ID }, 9246 /* Intruder ~ 3316 and 3324 */ 9247 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_1, 9248 PCI_ANY_ID, PCI_ANY_ID }, 9249 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_2, 9250 PCI_ANY_ID, PCI_ANY_ID }, 9251 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_3, 9252 PCI_ANY_ID, PCI_ANY_ID }, 9253 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_4, 9254 PCI_ANY_ID, PCI_ANY_ID }, 9255 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_1, 9256 PCI_ANY_ID, PCI_ANY_ID }, 9257 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_2, 9258 PCI_ANY_ID, PCI_ANY_ID }, 9259 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_3, 9260 PCI_ANY_ID, PCI_ANY_ID }, 9261 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_4, 9262 PCI_ANY_ID, PCI_ANY_ID }, 9263 /* Ventura, Crusader, Harpoon & Tomcat ~ 3516, 3416, 3508 & 3408*/ 9264 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508, 9265 PCI_ANY_ID, PCI_ANY_ID }, 9266 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3508_1, 9267 PCI_ANY_ID, PCI_ANY_ID }, 9268 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3408, 9269 PCI_ANY_ID, PCI_ANY_ID }, 9270 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516, 9271 PCI_ANY_ID, PCI_ANY_ID }, 9272 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3516_1, 9273 PCI_ANY_ID, PCI_ANY_ID }, 9274 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3416, 9275 PCI_ANY_ID, PCI_ANY_ID }, 9276 {0} /* Terminating entry */ 9277 }; 9278 MODULE_DEVICE_TABLE(pci, mpt3sas_pci_table); 9279 9280 static struct pci_error_handlers _mpt3sas_err_handler = { 9281 .error_detected = scsih_pci_error_detected, 9282 .mmio_enabled = scsih_pci_mmio_enabled, 9283 .slot_reset = scsih_pci_slot_reset, 9284 .resume = scsih_pci_resume, 9285 }; 9286 9287 static struct pci_driver mpt3sas_driver = { 9288 .name = MPT3SAS_DRIVER_NAME, 9289 .id_table = mpt3sas_pci_table, 9290 .probe = _scsih_probe, 9291 .remove = scsih_remove, 9292 .shutdown = scsih_shutdown, 9293 .err_handler = &_mpt3sas_err_handler, 9294 #ifdef CONFIG_PM 9295 .suspend = scsih_suspend, 9296 .resume = scsih_resume, 9297 #endif 9298 }; 9299 9300 /** 9301 * scsih_init - main entry point for this driver. 9302 * 9303 * Returns 0 success, anything else error. 9304 */ 9305 static int 9306 scsih_init(void) 9307 { 9308 mpt2_ids = 0; 9309 mpt3_ids = 0; 9310 9311 mpt3sas_base_initialize_callback_handler(); 9312 9313 /* queuecommand callback hander */ 9314 scsi_io_cb_idx = mpt3sas_base_register_callback_handler(_scsih_io_done); 9315 9316 /* task management callback handler */ 9317 tm_cb_idx = mpt3sas_base_register_callback_handler(_scsih_tm_done); 9318 9319 /* base internal commands callback handler */ 9320 base_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_base_done); 9321 port_enable_cb_idx = mpt3sas_base_register_callback_handler( 9322 mpt3sas_port_enable_done); 9323 9324 /* transport internal commands callback handler */ 9325 transport_cb_idx = mpt3sas_base_register_callback_handler( 9326 mpt3sas_transport_done); 9327 9328 /* scsih internal commands callback handler */ 9329 scsih_cb_idx = mpt3sas_base_register_callback_handler(_scsih_done); 9330 9331 /* configuration page API internal commands callback handler */ 9332 config_cb_idx = mpt3sas_base_register_callback_handler( 9333 mpt3sas_config_done); 9334 9335 /* ctl module callback handler */ 9336 ctl_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_ctl_done); 9337 9338 tm_tr_cb_idx = mpt3sas_base_register_callback_handler( 9339 _scsih_tm_tr_complete); 9340 9341 tm_tr_volume_cb_idx = mpt3sas_base_register_callback_handler( 9342 _scsih_tm_volume_tr_complete); 9343 9344 tm_sas_control_cb_idx = mpt3sas_base_register_callback_handler( 9345 _scsih_sas_control_complete); 9346 9347 return 0; 9348 } 9349 9350 /** 9351 * scsih_exit - exit point for this driver (when it is a module). 9352 * 9353 * Returns 0 success, anything else error. 9354 */ 9355 static void 9356 scsih_exit(void) 9357 { 9358 9359 mpt3sas_base_release_callback_handler(scsi_io_cb_idx); 9360 mpt3sas_base_release_callback_handler(tm_cb_idx); 9361 mpt3sas_base_release_callback_handler(base_cb_idx); 9362 mpt3sas_base_release_callback_handler(port_enable_cb_idx); 9363 mpt3sas_base_release_callback_handler(transport_cb_idx); 9364 mpt3sas_base_release_callback_handler(scsih_cb_idx); 9365 mpt3sas_base_release_callback_handler(config_cb_idx); 9366 mpt3sas_base_release_callback_handler(ctl_cb_idx); 9367 9368 mpt3sas_base_release_callback_handler(tm_tr_cb_idx); 9369 mpt3sas_base_release_callback_handler(tm_tr_volume_cb_idx); 9370 mpt3sas_base_release_callback_handler(tm_sas_control_cb_idx); 9371 9372 /* raid transport support */ 9373 if (hbas_to_enumerate != 1) 9374 raid_class_release(mpt3sas_raid_template); 9375 if (hbas_to_enumerate != 2) 9376 raid_class_release(mpt2sas_raid_template); 9377 sas_release_transport(mpt3sas_transport_template); 9378 } 9379 9380 /** 9381 * _mpt3sas_init - main entry point for this driver. 9382 * 9383 * Returns 0 success, anything else error. 9384 */ 9385 static int __init 9386 _mpt3sas_init(void) 9387 { 9388 int error; 9389 9390 pr_info("%s version %s loaded\n", MPT3SAS_DRIVER_NAME, 9391 MPT3SAS_DRIVER_VERSION); 9392 9393 mpt3sas_transport_template = 9394 sas_attach_transport(&mpt3sas_transport_functions); 9395 if (!mpt3sas_transport_template) 9396 return -ENODEV; 9397 9398 /* No need attach mpt3sas raid functions template 9399 * if hbas_to_enumarate value is one. 9400 */ 9401 if (hbas_to_enumerate != 1) { 9402 mpt3sas_raid_template = 9403 raid_class_attach(&mpt3sas_raid_functions); 9404 if (!mpt3sas_raid_template) { 9405 sas_release_transport(mpt3sas_transport_template); 9406 return -ENODEV; 9407 } 9408 } 9409 9410 /* No need to attach mpt2sas raid functions template 9411 * if hbas_to_enumarate value is two 9412 */ 9413 if (hbas_to_enumerate != 2) { 9414 mpt2sas_raid_template = 9415 raid_class_attach(&mpt2sas_raid_functions); 9416 if (!mpt2sas_raid_template) { 9417 sas_release_transport(mpt3sas_transport_template); 9418 return -ENODEV; 9419 } 9420 } 9421 9422 error = scsih_init(); 9423 if (error) { 9424 scsih_exit(); 9425 return error; 9426 } 9427 9428 mpt3sas_ctl_init(hbas_to_enumerate); 9429 9430 error = pci_register_driver(&mpt3sas_driver); 9431 if (error) 9432 scsih_exit(); 9433 9434 return error; 9435 } 9436 9437 /** 9438 * _mpt3sas_exit - exit point for this driver (when it is a module). 9439 * 9440 */ 9441 static void __exit 9442 _mpt3sas_exit(void) 9443 { 9444 pr_info("mpt3sas version %s unloading\n", 9445 MPT3SAS_DRIVER_VERSION); 9446 9447 pci_unregister_driver(&mpt3sas_driver); 9448 9449 mpt3sas_ctl_exit(hbas_to_enumerate); 9450 9451 scsih_exit(); 9452 } 9453 9454 module_init(_mpt3sas_init); 9455 module_exit(_mpt3sas_exit); 9456