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