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