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