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 * @cancel_pending_work: flag set during reset handling 178 * @ioc: per adapter object 179 * @device_handle: device handle 180 * @VF_ID: virtual function id 181 * @VP_ID: virtual port id 182 * @ignore: flag meaning this event has been marked to ignore 183 * @event: firmware event MPI2_EVENT_XXX defined in mpt2_ioc.h 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 u8 cancel_pending_work; 192 struct delayed_work delayed_work; 193 194 struct MPT3SAS_ADAPTER *ioc; 195 u16 device_handle; 196 u8 VF_ID; 197 u8 VP_ID; 198 u8 ignore; 199 u16 event; 200 struct kref refcount; 201 char event_data[0] __aligned(4); 202 }; 203 204 static void fw_event_work_free(struct kref *r) 205 { 206 kfree(container_of(r, struct fw_event_work, refcount)); 207 } 208 209 static void fw_event_work_get(struct fw_event_work *fw_work) 210 { 211 kref_get(&fw_work->refcount); 212 } 213 214 static void fw_event_work_put(struct fw_event_work *fw_work) 215 { 216 kref_put(&fw_work->refcount, fw_event_work_free); 217 } 218 219 static struct fw_event_work *alloc_fw_event_work(int len) 220 { 221 struct fw_event_work *fw_event; 222 223 fw_event = kzalloc(sizeof(*fw_event) + len, GFP_ATOMIC); 224 if (!fw_event) 225 return NULL; 226 227 kref_init(&fw_event->refcount); 228 return fw_event; 229 } 230 231 /** 232 * struct _scsi_io_transfer - scsi io transfer 233 * @handle: sas device handle (assigned by firmware) 234 * @is_raid: flag set for hidden raid components 235 * @dir: DMA_TO_DEVICE, DMA_FROM_DEVICE, 236 * @data_length: data transfer length 237 * @data_dma: dma pointer to data 238 * @sense: sense data 239 * @lun: lun number 240 * @cdb_length: cdb length 241 * @cdb: cdb contents 242 * @timeout: timeout for this command 243 * @VF_ID: virtual function id 244 * @VP_ID: virtual port id 245 * @valid_reply: flag set for reply message 246 * @sense_length: sense length 247 * @ioc_status: ioc status 248 * @scsi_state: scsi state 249 * @scsi_status: scsi staus 250 * @log_info: log information 251 * @transfer_length: data length transfer when there is a reply message 252 * 253 * Used for sending internal scsi commands to devices within this module. 254 * Refer to _scsi_send_scsi_io(). 255 */ 256 struct _scsi_io_transfer { 257 u16 handle; 258 u8 is_raid; 259 enum dma_data_direction dir; 260 u32 data_length; 261 dma_addr_t data_dma; 262 u8 sense[SCSI_SENSE_BUFFERSIZE]; 263 u32 lun; 264 u8 cdb_length; 265 u8 cdb[32]; 266 u8 timeout; 267 u8 VF_ID; 268 u8 VP_ID; 269 u8 valid_reply; 270 /* the following bits are only valid when 'valid_reply = 1' */ 271 u32 sense_length; 272 u16 ioc_status; 273 u8 scsi_state; 274 u8 scsi_status; 275 u32 log_info; 276 u32 transfer_length; 277 }; 278 279 /** 280 * _scsih_set_debug_level - global setting of ioc->logging_level. 281 * 282 * Note: The logging levels are defined in mpt3sas_debug.h. 283 */ 284 static int 285 _scsih_set_debug_level(const char *val, struct kernel_param *kp) 286 { 287 int ret = param_set_int(val, kp); 288 struct MPT3SAS_ADAPTER *ioc; 289 290 if (ret) 291 return ret; 292 293 pr_info("setting logging_level(0x%08x)\n", logging_level); 294 spin_lock(&gioc_lock); 295 list_for_each_entry(ioc, &mpt3sas_ioc_list, list) 296 ioc->logging_level = logging_level; 297 spin_unlock(&gioc_lock); 298 return 0; 299 } 300 module_param_call(logging_level, _scsih_set_debug_level, param_get_int, 301 &logging_level, 0644); 302 303 /** 304 * _scsih_srch_boot_sas_address - search based on sas_address 305 * @sas_address: sas address 306 * @boot_device: boot device object from bios page 2 307 * 308 * Returns 1 when there's a match, 0 means no match. 309 */ 310 static inline int 311 _scsih_srch_boot_sas_address(u64 sas_address, 312 Mpi2BootDeviceSasWwid_t *boot_device) 313 { 314 return (sas_address == le64_to_cpu(boot_device->SASAddress)) ? 1 : 0; 315 } 316 317 /** 318 * _scsih_srch_boot_device_name - search based on device name 319 * @device_name: device name specified in INDENTIFY fram 320 * @boot_device: boot device object from bios page 2 321 * 322 * Returns 1 when there's a match, 0 means no match. 323 */ 324 static inline int 325 _scsih_srch_boot_device_name(u64 device_name, 326 Mpi2BootDeviceDeviceName_t *boot_device) 327 { 328 return (device_name == le64_to_cpu(boot_device->DeviceName)) ? 1 : 0; 329 } 330 331 /** 332 * _scsih_srch_boot_encl_slot - search based on enclosure_logical_id/slot 333 * @enclosure_logical_id: enclosure logical id 334 * @slot_number: slot number 335 * @boot_device: boot device object from bios page 2 336 * 337 * Returns 1 when there's a match, 0 means no match. 338 */ 339 static inline int 340 _scsih_srch_boot_encl_slot(u64 enclosure_logical_id, u16 slot_number, 341 Mpi2BootDeviceEnclosureSlot_t *boot_device) 342 { 343 return (enclosure_logical_id == le64_to_cpu(boot_device-> 344 EnclosureLogicalID) && slot_number == le16_to_cpu(boot_device-> 345 SlotNumber)) ? 1 : 0; 346 } 347 348 /** 349 * _scsih_is_boot_device - search for matching boot device. 350 * @sas_address: sas address 351 * @device_name: device name specified in INDENTIFY fram 352 * @enclosure_logical_id: enclosure logical id 353 * @slot_number: slot number 354 * @form: specifies boot device form 355 * @boot_device: boot device object from bios page 2 356 * 357 * Returns 1 when there's a match, 0 means no match. 358 */ 359 static int 360 _scsih_is_boot_device(u64 sas_address, u64 device_name, 361 u64 enclosure_logical_id, u16 slot, u8 form, 362 Mpi2BiosPage2BootDevice_t *boot_device) 363 { 364 int rc = 0; 365 366 switch (form) { 367 case MPI2_BIOSPAGE2_FORM_SAS_WWID: 368 if (!sas_address) 369 break; 370 rc = _scsih_srch_boot_sas_address( 371 sas_address, &boot_device->SasWwid); 372 break; 373 case MPI2_BIOSPAGE2_FORM_ENCLOSURE_SLOT: 374 if (!enclosure_logical_id) 375 break; 376 rc = _scsih_srch_boot_encl_slot( 377 enclosure_logical_id, 378 slot, &boot_device->EnclosureSlot); 379 break; 380 case MPI2_BIOSPAGE2_FORM_DEVICE_NAME: 381 if (!device_name) 382 break; 383 rc = _scsih_srch_boot_device_name( 384 device_name, &boot_device->DeviceName); 385 break; 386 case MPI2_BIOSPAGE2_FORM_NO_DEVICE_SPECIFIED: 387 break; 388 } 389 390 return rc; 391 } 392 393 /** 394 * _scsih_get_sas_address - set the sas_address for given device handle 395 * @handle: device handle 396 * @sas_address: sas address 397 * 398 * Returns 0 success, non-zero when failure 399 */ 400 static int 401 _scsih_get_sas_address(struct MPT3SAS_ADAPTER *ioc, u16 handle, 402 u64 *sas_address) 403 { 404 Mpi2SasDevicePage0_t sas_device_pg0; 405 Mpi2ConfigReply_t mpi_reply; 406 u32 ioc_status; 407 408 *sas_address = 0; 409 410 if (handle <= ioc->sas_hba.num_phys) { 411 *sas_address = ioc->sas_hba.sas_address; 412 return 0; 413 } 414 415 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 416 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) { 417 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name, 418 __FILE__, __LINE__, __func__); 419 return -ENXIO; 420 } 421 422 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 423 if (ioc_status == MPI2_IOCSTATUS_SUCCESS) { 424 *sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 425 return 0; 426 } 427 428 /* we hit this becuase the given parent handle doesn't exist */ 429 if (ioc_status == MPI2_IOCSTATUS_CONFIG_INVALID_PAGE) 430 return -ENXIO; 431 432 /* else error case */ 433 pr_err(MPT3SAS_FMT 434 "handle(0x%04x), ioc_status(0x%04x), failure at %s:%d/%s()!\n", 435 ioc->name, handle, ioc_status, 436 __FILE__, __LINE__, __func__); 437 return -EIO; 438 } 439 440 /** 441 * _scsih_determine_boot_device - determine boot device. 442 * @ioc: per adapter object 443 * @device: either sas_device or raid_device object 444 * @is_raid: [flag] 1 = raid object, 0 = sas object 445 * 446 * Determines whether this device should be first reported device to 447 * to scsi-ml or sas transport, this purpose is for persistent boot device. 448 * There are primary, alternate, and current entries in bios page 2. The order 449 * priority is primary, alternate, then current. This routine saves 450 * the corresponding device object and is_raid flag in the ioc object. 451 * The saved data to be used later in _scsih_probe_boot_devices(). 452 */ 453 static void 454 _scsih_determine_boot_device(struct MPT3SAS_ADAPTER *ioc, 455 void *device, u8 is_raid) 456 { 457 struct _sas_device *sas_device; 458 struct _raid_device *raid_device; 459 u64 sas_address; 460 u64 device_name; 461 u64 enclosure_logical_id; 462 u16 slot; 463 464 /* only process this function when driver loads */ 465 if (!ioc->is_driver_loading) 466 return; 467 468 /* no Bios, return immediately */ 469 if (!ioc->bios_pg3.BiosVersion) 470 return; 471 472 if (!is_raid) { 473 sas_device = device; 474 sas_address = sas_device->sas_address; 475 device_name = sas_device->device_name; 476 enclosure_logical_id = sas_device->enclosure_logical_id; 477 slot = sas_device->slot; 478 } else { 479 raid_device = device; 480 sas_address = raid_device->wwid; 481 device_name = 0; 482 enclosure_logical_id = 0; 483 slot = 0; 484 } 485 486 if (!ioc->req_boot_device.device) { 487 if (_scsih_is_boot_device(sas_address, device_name, 488 enclosure_logical_id, slot, 489 (ioc->bios_pg2.ReqBootDeviceForm & 490 MPI2_BIOSPAGE2_FORM_MASK), 491 &ioc->bios_pg2.RequestedBootDevice)) { 492 dinitprintk(ioc, pr_info(MPT3SAS_FMT 493 "%s: req_boot_device(0x%016llx)\n", 494 ioc->name, __func__, 495 (unsigned long long)sas_address)); 496 ioc->req_boot_device.device = device; 497 ioc->req_boot_device.is_raid = is_raid; 498 } 499 } 500 501 if (!ioc->req_alt_boot_device.device) { 502 if (_scsih_is_boot_device(sas_address, device_name, 503 enclosure_logical_id, slot, 504 (ioc->bios_pg2.ReqAltBootDeviceForm & 505 MPI2_BIOSPAGE2_FORM_MASK), 506 &ioc->bios_pg2.RequestedAltBootDevice)) { 507 dinitprintk(ioc, pr_info(MPT3SAS_FMT 508 "%s: req_alt_boot_device(0x%016llx)\n", 509 ioc->name, __func__, 510 (unsigned long long)sas_address)); 511 ioc->req_alt_boot_device.device = device; 512 ioc->req_alt_boot_device.is_raid = is_raid; 513 } 514 } 515 516 if (!ioc->current_boot_device.device) { 517 if (_scsih_is_boot_device(sas_address, device_name, 518 enclosure_logical_id, slot, 519 (ioc->bios_pg2.CurrentBootDeviceForm & 520 MPI2_BIOSPAGE2_FORM_MASK), 521 &ioc->bios_pg2.CurrentBootDevice)) { 522 dinitprintk(ioc, pr_info(MPT3SAS_FMT 523 "%s: current_boot_device(0x%016llx)\n", 524 ioc->name, __func__, 525 (unsigned long long)sas_address)); 526 ioc->current_boot_device.device = device; 527 ioc->current_boot_device.is_raid = is_raid; 528 } 529 } 530 } 531 532 static struct _sas_device * 533 __mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc, 534 struct MPT3SAS_TARGET *tgt_priv) 535 { 536 struct _sas_device *ret; 537 538 assert_spin_locked(&ioc->sas_device_lock); 539 540 ret = tgt_priv->sdev; 541 if (ret) 542 sas_device_get(ret); 543 544 return ret; 545 } 546 547 static struct _sas_device * 548 mpt3sas_get_sdev_from_target(struct MPT3SAS_ADAPTER *ioc, 549 struct MPT3SAS_TARGET *tgt_priv) 550 { 551 struct _sas_device *ret; 552 unsigned long flags; 553 554 spin_lock_irqsave(&ioc->sas_device_lock, flags); 555 ret = __mpt3sas_get_sdev_from_target(ioc, tgt_priv); 556 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 557 558 return ret; 559 } 560 561 562 struct _sas_device * 563 __mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc, 564 u64 sas_address) 565 { 566 struct _sas_device *sas_device; 567 568 assert_spin_locked(&ioc->sas_device_lock); 569 570 list_for_each_entry(sas_device, &ioc->sas_device_list, list) 571 if (sas_device->sas_address == sas_address) 572 goto found_device; 573 574 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list) 575 if (sas_device->sas_address == sas_address) 576 goto found_device; 577 578 return NULL; 579 580 found_device: 581 sas_device_get(sas_device); 582 return sas_device; 583 } 584 585 /** 586 * mpt3sas_get_sdev_by_addr - sas device search 587 * @ioc: per adapter object 588 * @sas_address: sas address 589 * Context: Calling function should acquire ioc->sas_device_lock 590 * 591 * This searches for sas_device based on sas_address, then return sas_device 592 * object. 593 */ 594 struct _sas_device * 595 mpt3sas_get_sdev_by_addr(struct MPT3SAS_ADAPTER *ioc, 596 u64 sas_address) 597 { 598 struct _sas_device *sas_device; 599 unsigned long flags; 600 601 spin_lock_irqsave(&ioc->sas_device_lock, flags); 602 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 603 sas_address); 604 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 605 606 return sas_device; 607 } 608 609 static struct _sas_device * 610 __mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 611 { 612 struct _sas_device *sas_device; 613 614 assert_spin_locked(&ioc->sas_device_lock); 615 616 list_for_each_entry(sas_device, &ioc->sas_device_list, list) 617 if (sas_device->handle == handle) 618 goto found_device; 619 620 list_for_each_entry(sas_device, &ioc->sas_device_init_list, list) 621 if (sas_device->handle == handle) 622 goto found_device; 623 624 return NULL; 625 626 found_device: 627 sas_device_get(sas_device); 628 return sas_device; 629 } 630 631 /** 632 * mpt3sas_get_sdev_by_handle - sas device search 633 * @ioc: per adapter object 634 * @handle: sas device handle (assigned by firmware) 635 * Context: Calling function should acquire ioc->sas_device_lock 636 * 637 * This searches for sas_device based on sas_address, then return sas_device 638 * object. 639 */ 640 static struct _sas_device * 641 mpt3sas_get_sdev_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 642 { 643 struct _sas_device *sas_device; 644 unsigned long flags; 645 646 spin_lock_irqsave(&ioc->sas_device_lock, flags); 647 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 648 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 649 650 return sas_device; 651 } 652 653 /** 654 * _scsih_sas_device_remove - remove sas_device from list. 655 * @ioc: per adapter object 656 * @sas_device: the sas_device object 657 * Context: This function will acquire ioc->sas_device_lock. 658 * 659 * If sas_device is on the list, remove it and decrement its reference count. 660 */ 661 static void 662 _scsih_sas_device_remove(struct MPT3SAS_ADAPTER *ioc, 663 struct _sas_device *sas_device) 664 { 665 unsigned long flags; 666 667 if (!sas_device) 668 return; 669 pr_info(MPT3SAS_FMT 670 "removing handle(0x%04x), sas_addr(0x%016llx)\n", 671 ioc->name, sas_device->handle, 672 (unsigned long long) sas_device->sas_address); 673 674 if (sas_device->enclosure_handle != 0) 675 pr_info(MPT3SAS_FMT 676 "removing enclosure logical id(0x%016llx), slot(%d)\n", 677 ioc->name, (unsigned long long) 678 sas_device->enclosure_logical_id, sas_device->slot); 679 680 if (sas_device->connector_name[0] != '\0') 681 pr_info(MPT3SAS_FMT 682 "removing enclosure level(0x%04x), connector name( %s)\n", 683 ioc->name, sas_device->enclosure_level, 684 sas_device->connector_name); 685 686 /* 687 * The lock serializes access to the list, but we still need to verify 688 * that nobody removed the entry while we were waiting on the lock. 689 */ 690 spin_lock_irqsave(&ioc->sas_device_lock, flags); 691 if (!list_empty(&sas_device->list)) { 692 list_del_init(&sas_device->list); 693 sas_device_put(sas_device); 694 } 695 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 696 } 697 698 /** 699 * _scsih_device_remove_by_handle - removing device object by handle 700 * @ioc: per adapter object 701 * @handle: device handle 702 * 703 * Return nothing. 704 */ 705 static void 706 _scsih_device_remove_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 707 { 708 struct _sas_device *sas_device; 709 unsigned long flags; 710 711 if (ioc->shost_recovery) 712 return; 713 714 spin_lock_irqsave(&ioc->sas_device_lock, flags); 715 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 716 if (sas_device) { 717 list_del_init(&sas_device->list); 718 sas_device_put(sas_device); 719 } 720 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 721 if (sas_device) { 722 _scsih_remove_device(ioc, sas_device); 723 sas_device_put(sas_device); 724 } 725 } 726 727 /** 728 * mpt3sas_device_remove_by_sas_address - removing device object by sas address 729 * @ioc: per adapter object 730 * @sas_address: device sas_address 731 * 732 * Return nothing. 733 */ 734 void 735 mpt3sas_device_remove_by_sas_address(struct MPT3SAS_ADAPTER *ioc, 736 u64 sas_address) 737 { 738 struct _sas_device *sas_device; 739 unsigned long flags; 740 741 if (ioc->shost_recovery) 742 return; 743 744 spin_lock_irqsave(&ioc->sas_device_lock, flags); 745 sas_device = __mpt3sas_get_sdev_by_addr(ioc, sas_address); 746 if (sas_device) { 747 list_del_init(&sas_device->list); 748 sas_device_put(sas_device); 749 } 750 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 751 if (sas_device) { 752 _scsih_remove_device(ioc, sas_device); 753 sas_device_put(sas_device); 754 } 755 } 756 757 /** 758 * _scsih_sas_device_add - insert sas_device to the list. 759 * @ioc: per adapter object 760 * @sas_device: the sas_device object 761 * Context: This function will acquire ioc->sas_device_lock. 762 * 763 * Adding new object to the ioc->sas_device_list. 764 */ 765 static void 766 _scsih_sas_device_add(struct MPT3SAS_ADAPTER *ioc, 767 struct _sas_device *sas_device) 768 { 769 unsigned long flags; 770 771 dewtprintk(ioc, pr_info(MPT3SAS_FMT 772 "%s: handle(0x%04x), sas_addr(0x%016llx)\n", 773 ioc->name, __func__, sas_device->handle, 774 (unsigned long long)sas_device->sas_address)); 775 776 if (sas_device->enclosure_handle != 0) 777 dewtprintk(ioc, pr_info(MPT3SAS_FMT 778 "%s: enclosure logical id(0x%016llx), slot( %d)\n", 779 ioc->name, __func__, (unsigned long long) 780 sas_device->enclosure_logical_id, sas_device->slot)); 781 782 if (sas_device->connector_name[0] != '\0') 783 dewtprintk(ioc, pr_info(MPT3SAS_FMT 784 "%s: enclosure level(0x%04x), connector name( %s)\n", 785 ioc->name, __func__, 786 sas_device->enclosure_level, sas_device->connector_name)); 787 788 spin_lock_irqsave(&ioc->sas_device_lock, flags); 789 sas_device_get(sas_device); 790 list_add_tail(&sas_device->list, &ioc->sas_device_list); 791 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 792 793 if (!mpt3sas_transport_port_add(ioc, sas_device->handle, 794 sas_device->sas_address_parent)) { 795 _scsih_sas_device_remove(ioc, sas_device); 796 } else if (!sas_device->starget) { 797 /* 798 * When asyn scanning is enabled, its not possible to remove 799 * devices while scanning is turned on due to an oops in 800 * scsi_sysfs_add_sdev()->add_device()->sysfs_addrm_start() 801 */ 802 if (!ioc->is_driver_loading) { 803 mpt3sas_transport_port_remove(ioc, 804 sas_device->sas_address, 805 sas_device->sas_address_parent); 806 _scsih_sas_device_remove(ioc, sas_device); 807 } 808 } 809 } 810 811 /** 812 * _scsih_sas_device_init_add - insert sas_device to the list. 813 * @ioc: per adapter object 814 * @sas_device: the sas_device object 815 * Context: This function will acquire ioc->sas_device_lock. 816 * 817 * Adding new object at driver load time to the ioc->sas_device_init_list. 818 */ 819 static void 820 _scsih_sas_device_init_add(struct MPT3SAS_ADAPTER *ioc, 821 struct _sas_device *sas_device) 822 { 823 unsigned long flags; 824 825 dewtprintk(ioc, pr_info(MPT3SAS_FMT 826 "%s: handle(0x%04x), sas_addr(0x%016llx)\n", ioc->name, 827 __func__, sas_device->handle, 828 (unsigned long long)sas_device->sas_address)); 829 830 if (sas_device->enclosure_handle != 0) 831 dewtprintk(ioc, pr_info(MPT3SAS_FMT 832 "%s: enclosure logical id(0x%016llx), slot( %d)\n", 833 ioc->name, __func__, (unsigned long long) 834 sas_device->enclosure_logical_id, sas_device->slot)); 835 836 if (sas_device->connector_name[0] != '\0') 837 dewtprintk(ioc, pr_info(MPT3SAS_FMT 838 "%s: enclosure level(0x%04x), connector name( %s)\n", 839 ioc->name, __func__, sas_device->enclosure_level, 840 sas_device->connector_name)); 841 842 spin_lock_irqsave(&ioc->sas_device_lock, flags); 843 sas_device_get(sas_device); 844 list_add_tail(&sas_device->list, &ioc->sas_device_init_list); 845 _scsih_determine_boot_device(ioc, sas_device, 0); 846 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 847 } 848 849 /** 850 * _scsih_raid_device_find_by_id - raid device search 851 * @ioc: per adapter object 852 * @id: sas device target id 853 * @channel: sas device channel 854 * Context: Calling function should acquire ioc->raid_device_lock 855 * 856 * This searches for raid_device based on target id, then return raid_device 857 * object. 858 */ 859 static struct _raid_device * 860 _scsih_raid_device_find_by_id(struct MPT3SAS_ADAPTER *ioc, int id, int channel) 861 { 862 struct _raid_device *raid_device, *r; 863 864 r = NULL; 865 list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 866 if (raid_device->id == id && raid_device->channel == channel) { 867 r = raid_device; 868 goto out; 869 } 870 } 871 872 out: 873 return r; 874 } 875 876 /** 877 * mpt3sas_raid_device_find_by_handle - raid device search 878 * @ioc: per adapter object 879 * @handle: sas device handle (assigned by firmware) 880 * Context: Calling function should acquire ioc->raid_device_lock 881 * 882 * This searches for raid_device based on handle, then return raid_device 883 * object. 884 */ 885 struct _raid_device * 886 mpt3sas_raid_device_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 887 { 888 struct _raid_device *raid_device, *r; 889 890 r = NULL; 891 list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 892 if (raid_device->handle != handle) 893 continue; 894 r = raid_device; 895 goto out; 896 } 897 898 out: 899 return r; 900 } 901 902 /** 903 * _scsih_raid_device_find_by_wwid - raid device search 904 * @ioc: per adapter object 905 * @handle: sas device handle (assigned by firmware) 906 * Context: Calling function should acquire ioc->raid_device_lock 907 * 908 * This searches for raid_device based on wwid, then return raid_device 909 * object. 910 */ 911 static struct _raid_device * 912 _scsih_raid_device_find_by_wwid(struct MPT3SAS_ADAPTER *ioc, u64 wwid) 913 { 914 struct _raid_device *raid_device, *r; 915 916 r = NULL; 917 list_for_each_entry(raid_device, &ioc->raid_device_list, list) { 918 if (raid_device->wwid != wwid) 919 continue; 920 r = raid_device; 921 goto out; 922 } 923 924 out: 925 return r; 926 } 927 928 /** 929 * _scsih_raid_device_add - add raid_device object 930 * @ioc: per adapter object 931 * @raid_device: raid_device object 932 * 933 * This is added to the raid_device_list link list. 934 */ 935 static void 936 _scsih_raid_device_add(struct MPT3SAS_ADAPTER *ioc, 937 struct _raid_device *raid_device) 938 { 939 unsigned long flags; 940 941 dewtprintk(ioc, pr_info(MPT3SAS_FMT 942 "%s: handle(0x%04x), wwid(0x%016llx)\n", ioc->name, __func__, 943 raid_device->handle, (unsigned long long)raid_device->wwid)); 944 945 spin_lock_irqsave(&ioc->raid_device_lock, flags); 946 list_add_tail(&raid_device->list, &ioc->raid_device_list); 947 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 948 } 949 950 /** 951 * _scsih_raid_device_remove - delete raid_device object 952 * @ioc: per adapter object 953 * @raid_device: raid_device object 954 * 955 */ 956 static void 957 _scsih_raid_device_remove(struct MPT3SAS_ADAPTER *ioc, 958 struct _raid_device *raid_device) 959 { 960 unsigned long flags; 961 962 spin_lock_irqsave(&ioc->raid_device_lock, flags); 963 list_del(&raid_device->list); 964 kfree(raid_device); 965 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 966 } 967 968 /** 969 * mpt3sas_scsih_expander_find_by_handle - expander device search 970 * @ioc: per adapter object 971 * @handle: expander handle (assigned by firmware) 972 * Context: Calling function should acquire ioc->sas_device_lock 973 * 974 * This searches for expander device based on handle, then returns the 975 * sas_node object. 976 */ 977 struct _sas_node * 978 mpt3sas_scsih_expander_find_by_handle(struct MPT3SAS_ADAPTER *ioc, u16 handle) 979 { 980 struct _sas_node *sas_expander, *r; 981 982 r = NULL; 983 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) { 984 if (sas_expander->handle != handle) 985 continue; 986 r = sas_expander; 987 goto out; 988 } 989 out: 990 return r; 991 } 992 993 /** 994 * mpt3sas_scsih_expander_find_by_sas_address - expander device search 995 * @ioc: per adapter object 996 * @sas_address: sas address 997 * Context: Calling function should acquire ioc->sas_node_lock. 998 * 999 * This searches for expander device based on sas_address, then returns the 1000 * sas_node object. 1001 */ 1002 struct _sas_node * 1003 mpt3sas_scsih_expander_find_by_sas_address(struct MPT3SAS_ADAPTER *ioc, 1004 u64 sas_address) 1005 { 1006 struct _sas_node *sas_expander, *r; 1007 1008 r = NULL; 1009 list_for_each_entry(sas_expander, &ioc->sas_expander_list, list) { 1010 if (sas_expander->sas_address != sas_address) 1011 continue; 1012 r = sas_expander; 1013 goto out; 1014 } 1015 out: 1016 return r; 1017 } 1018 1019 /** 1020 * _scsih_expander_node_add - insert expander device to the list. 1021 * @ioc: per adapter object 1022 * @sas_expander: the sas_device object 1023 * Context: This function will acquire ioc->sas_node_lock. 1024 * 1025 * Adding new object to the ioc->sas_expander_list. 1026 * 1027 * Return nothing. 1028 */ 1029 static void 1030 _scsih_expander_node_add(struct MPT3SAS_ADAPTER *ioc, 1031 struct _sas_node *sas_expander) 1032 { 1033 unsigned long flags; 1034 1035 spin_lock_irqsave(&ioc->sas_node_lock, flags); 1036 list_add_tail(&sas_expander->list, &ioc->sas_expander_list); 1037 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 1038 } 1039 1040 /** 1041 * _scsih_is_end_device - determines if device is an end device 1042 * @device_info: bitfield providing information about the device. 1043 * Context: none 1044 * 1045 * Returns 1 if end device. 1046 */ 1047 static int 1048 _scsih_is_end_device(u32 device_info) 1049 { 1050 if (device_info & MPI2_SAS_DEVICE_INFO_END_DEVICE && 1051 ((device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) | 1052 (device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET) | 1053 (device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE))) 1054 return 1; 1055 else 1056 return 0; 1057 } 1058 1059 /** 1060 * _scsih_scsi_lookup_get - returns scmd entry 1061 * @ioc: per adapter object 1062 * @smid: system request message index 1063 * 1064 * Returns the smid stored scmd pointer. 1065 */ 1066 static struct scsi_cmnd * 1067 _scsih_scsi_lookup_get(struct MPT3SAS_ADAPTER *ioc, u16 smid) 1068 { 1069 return ioc->scsi_lookup[smid - 1].scmd; 1070 } 1071 1072 /** 1073 * _scsih_scsi_lookup_get_clear - returns scmd entry 1074 * @ioc: per adapter object 1075 * @smid: system request message index 1076 * 1077 * Returns the smid stored scmd pointer. 1078 * Then will derefrence the stored scmd pointer. 1079 */ 1080 static inline struct scsi_cmnd * 1081 _scsih_scsi_lookup_get_clear(struct MPT3SAS_ADAPTER *ioc, u16 smid) 1082 { 1083 unsigned long flags; 1084 struct scsi_cmnd *scmd; 1085 1086 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 1087 scmd = ioc->scsi_lookup[smid - 1].scmd; 1088 ioc->scsi_lookup[smid - 1].scmd = NULL; 1089 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 1090 1091 return scmd; 1092 } 1093 1094 /** 1095 * _scsih_scsi_lookup_find_by_scmd - scmd lookup 1096 * @ioc: per adapter object 1097 * @smid: system request message index 1098 * @scmd: pointer to scsi command object 1099 * Context: This function will acquire ioc->scsi_lookup_lock. 1100 * 1101 * This will search for a scmd pointer in the scsi_lookup array, 1102 * returning the revelent smid. A returned value of zero means invalid. 1103 */ 1104 static u16 1105 _scsih_scsi_lookup_find_by_scmd(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd 1106 *scmd) 1107 { 1108 u16 smid; 1109 unsigned long flags; 1110 int i; 1111 1112 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 1113 smid = 0; 1114 for (i = 0; i < ioc->scsiio_depth; i++) { 1115 if (ioc->scsi_lookup[i].scmd == scmd) { 1116 smid = ioc->scsi_lookup[i].smid; 1117 goto out; 1118 } 1119 } 1120 out: 1121 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 1122 return smid; 1123 } 1124 1125 /** 1126 * _scsih_scsi_lookup_find_by_target - search for matching channel:id 1127 * @ioc: per adapter object 1128 * @id: target id 1129 * @channel: channel 1130 * Context: This function will acquire ioc->scsi_lookup_lock. 1131 * 1132 * This will search for a matching channel:id in the scsi_lookup array, 1133 * returning 1 if found. 1134 */ 1135 static u8 1136 _scsih_scsi_lookup_find_by_target(struct MPT3SAS_ADAPTER *ioc, int id, 1137 int channel) 1138 { 1139 u8 found; 1140 unsigned long flags; 1141 int i; 1142 1143 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 1144 found = 0; 1145 for (i = 0 ; i < ioc->scsiio_depth; i++) { 1146 if (ioc->scsi_lookup[i].scmd && 1147 (ioc->scsi_lookup[i].scmd->device->id == id && 1148 ioc->scsi_lookup[i].scmd->device->channel == channel)) { 1149 found = 1; 1150 goto out; 1151 } 1152 } 1153 out: 1154 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 1155 return found; 1156 } 1157 1158 /** 1159 * _scsih_scsi_lookup_find_by_lun - search for matching channel:id:lun 1160 * @ioc: per adapter object 1161 * @id: target id 1162 * @lun: lun number 1163 * @channel: channel 1164 * Context: This function will acquire ioc->scsi_lookup_lock. 1165 * 1166 * This will search for a matching channel:id:lun in the scsi_lookup array, 1167 * returning 1 if found. 1168 */ 1169 static u8 1170 _scsih_scsi_lookup_find_by_lun(struct MPT3SAS_ADAPTER *ioc, int id, 1171 unsigned int lun, int channel) 1172 { 1173 u8 found; 1174 unsigned long flags; 1175 int i; 1176 1177 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 1178 found = 0; 1179 for (i = 0 ; i < ioc->scsiio_depth; i++) { 1180 if (ioc->scsi_lookup[i].scmd && 1181 (ioc->scsi_lookup[i].scmd->device->id == id && 1182 ioc->scsi_lookup[i].scmd->device->channel == channel && 1183 ioc->scsi_lookup[i].scmd->device->lun == lun)) { 1184 found = 1; 1185 goto out; 1186 } 1187 } 1188 out: 1189 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 1190 return found; 1191 } 1192 1193 /** 1194 * scsih_change_queue_depth - setting device queue depth 1195 * @sdev: scsi device struct 1196 * @qdepth: requested queue depth 1197 * 1198 * Returns queue depth. 1199 */ 1200 int 1201 scsih_change_queue_depth(struct scsi_device *sdev, int qdepth) 1202 { 1203 struct Scsi_Host *shost = sdev->host; 1204 int max_depth; 1205 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 1206 struct MPT3SAS_DEVICE *sas_device_priv_data; 1207 struct MPT3SAS_TARGET *sas_target_priv_data; 1208 struct _sas_device *sas_device; 1209 unsigned long flags; 1210 1211 max_depth = shost->can_queue; 1212 1213 /* limit max device queue for SATA to 32 */ 1214 sas_device_priv_data = sdev->hostdata; 1215 if (!sas_device_priv_data) 1216 goto not_sata; 1217 sas_target_priv_data = sas_device_priv_data->sas_target; 1218 if (!sas_target_priv_data) 1219 goto not_sata; 1220 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) 1221 goto not_sata; 1222 1223 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1224 sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data); 1225 if (sas_device) { 1226 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SATA_DEVICE) 1227 max_depth = MPT3SAS_SATA_QUEUE_DEPTH; 1228 1229 sas_device_put(sas_device); 1230 } 1231 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1232 1233 not_sata: 1234 1235 if (!sdev->tagged_supported) 1236 max_depth = 1; 1237 if (qdepth > max_depth) 1238 qdepth = max_depth; 1239 return scsi_change_queue_depth(sdev, qdepth); 1240 } 1241 1242 /** 1243 * scsih_target_alloc - target add routine 1244 * @starget: scsi target struct 1245 * 1246 * Returns 0 if ok. Any other return is assumed to be an error and 1247 * the device is ignored. 1248 */ 1249 int 1250 scsih_target_alloc(struct scsi_target *starget) 1251 { 1252 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 1253 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 1254 struct MPT3SAS_TARGET *sas_target_priv_data; 1255 struct _sas_device *sas_device; 1256 struct _raid_device *raid_device; 1257 unsigned long flags; 1258 struct sas_rphy *rphy; 1259 1260 sas_target_priv_data = kzalloc(sizeof(*sas_target_priv_data), 1261 GFP_KERNEL); 1262 if (!sas_target_priv_data) 1263 return -ENOMEM; 1264 1265 starget->hostdata = sas_target_priv_data; 1266 sas_target_priv_data->starget = starget; 1267 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE; 1268 1269 /* RAID volumes */ 1270 if (starget->channel == RAID_CHANNEL) { 1271 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1272 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id, 1273 starget->channel); 1274 if (raid_device) { 1275 sas_target_priv_data->handle = raid_device->handle; 1276 sas_target_priv_data->sas_address = raid_device->wwid; 1277 sas_target_priv_data->flags |= MPT_TARGET_FLAGS_VOLUME; 1278 sas_target_priv_data->raid_device = raid_device; 1279 if (ioc->is_warpdrive) 1280 raid_device->starget = starget; 1281 } 1282 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1283 return 0; 1284 } 1285 1286 /* sas/sata devices */ 1287 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1288 rphy = dev_to_rphy(starget->dev.parent); 1289 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 1290 rphy->identify.sas_address); 1291 1292 if (sas_device) { 1293 sas_target_priv_data->handle = sas_device->handle; 1294 sas_target_priv_data->sas_address = sas_device->sas_address; 1295 sas_target_priv_data->sdev = sas_device; 1296 sas_device->starget = starget; 1297 sas_device->id = starget->id; 1298 sas_device->channel = starget->channel; 1299 if (test_bit(sas_device->handle, ioc->pd_handles)) 1300 sas_target_priv_data->flags |= 1301 MPT_TARGET_FLAGS_RAID_COMPONENT; 1302 if (sas_device->fast_path) 1303 sas_target_priv_data->flags |= MPT_TARGET_FASTPATH_IO; 1304 } 1305 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1306 1307 return 0; 1308 } 1309 1310 /** 1311 * scsih_target_destroy - target destroy routine 1312 * @starget: scsi target struct 1313 * 1314 * Returns nothing. 1315 */ 1316 void 1317 scsih_target_destroy(struct scsi_target *starget) 1318 { 1319 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 1320 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 1321 struct MPT3SAS_TARGET *sas_target_priv_data; 1322 struct _sas_device *sas_device; 1323 struct _raid_device *raid_device; 1324 unsigned long flags; 1325 struct sas_rphy *rphy; 1326 1327 sas_target_priv_data = starget->hostdata; 1328 if (!sas_target_priv_data) 1329 return; 1330 1331 if (starget->channel == RAID_CHANNEL) { 1332 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1333 raid_device = _scsih_raid_device_find_by_id(ioc, starget->id, 1334 starget->channel); 1335 if (raid_device) { 1336 raid_device->starget = NULL; 1337 raid_device->sdev = NULL; 1338 } 1339 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1340 goto out; 1341 } 1342 1343 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1344 rphy = dev_to_rphy(starget->dev.parent); 1345 sas_device = __mpt3sas_get_sdev_from_target(ioc, sas_target_priv_data); 1346 if (sas_device && (sas_device->starget == starget) && 1347 (sas_device->id == starget->id) && 1348 (sas_device->channel == starget->channel)) 1349 sas_device->starget = NULL; 1350 1351 if (sas_device) { 1352 /* 1353 * Corresponding get() is in _scsih_target_alloc() 1354 */ 1355 sas_target_priv_data->sdev = NULL; 1356 sas_device_put(sas_device); 1357 1358 sas_device_put(sas_device); 1359 } 1360 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1361 1362 out: 1363 kfree(sas_target_priv_data); 1364 starget->hostdata = NULL; 1365 } 1366 1367 /** 1368 * scsih_slave_alloc - device add routine 1369 * @sdev: scsi device struct 1370 * 1371 * Returns 0 if ok. Any other return is assumed to be an error and 1372 * the device is ignored. 1373 */ 1374 int 1375 scsih_slave_alloc(struct scsi_device *sdev) 1376 { 1377 struct Scsi_Host *shost; 1378 struct MPT3SAS_ADAPTER *ioc; 1379 struct MPT3SAS_TARGET *sas_target_priv_data; 1380 struct MPT3SAS_DEVICE *sas_device_priv_data; 1381 struct scsi_target *starget; 1382 struct _raid_device *raid_device; 1383 struct _sas_device *sas_device; 1384 unsigned long flags; 1385 1386 sas_device_priv_data = kzalloc(sizeof(*sas_device_priv_data), 1387 GFP_KERNEL); 1388 if (!sas_device_priv_data) 1389 return -ENOMEM; 1390 1391 sas_device_priv_data->lun = sdev->lun; 1392 sas_device_priv_data->flags = MPT_DEVICE_FLAGS_INIT; 1393 1394 starget = scsi_target(sdev); 1395 sas_target_priv_data = starget->hostdata; 1396 sas_target_priv_data->num_luns++; 1397 sas_device_priv_data->sas_target = sas_target_priv_data; 1398 sdev->hostdata = sas_device_priv_data; 1399 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT)) 1400 sdev->no_uld_attach = 1; 1401 1402 shost = dev_to_shost(&starget->dev); 1403 ioc = shost_priv(shost); 1404 if (starget->channel == RAID_CHANNEL) { 1405 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1406 raid_device = _scsih_raid_device_find_by_id(ioc, 1407 starget->id, starget->channel); 1408 if (raid_device) 1409 raid_device->sdev = sdev; /* raid is single lun */ 1410 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1411 } 1412 1413 if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) { 1414 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1415 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 1416 sas_target_priv_data->sas_address); 1417 if (sas_device && (sas_device->starget == NULL)) { 1418 sdev_printk(KERN_INFO, sdev, 1419 "%s : sas_device->starget set to starget @ %d\n", 1420 __func__, __LINE__); 1421 sas_device->starget = starget; 1422 } 1423 1424 if (sas_device) 1425 sas_device_put(sas_device); 1426 1427 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1428 } 1429 1430 return 0; 1431 } 1432 1433 /** 1434 * scsih_slave_destroy - device destroy routine 1435 * @sdev: scsi device struct 1436 * 1437 * Returns nothing. 1438 */ 1439 void 1440 scsih_slave_destroy(struct scsi_device *sdev) 1441 { 1442 struct MPT3SAS_TARGET *sas_target_priv_data; 1443 struct scsi_target *starget; 1444 struct Scsi_Host *shost; 1445 struct MPT3SAS_ADAPTER *ioc; 1446 struct _sas_device *sas_device; 1447 unsigned long flags; 1448 1449 if (!sdev->hostdata) 1450 return; 1451 1452 starget = scsi_target(sdev); 1453 sas_target_priv_data = starget->hostdata; 1454 sas_target_priv_data->num_luns--; 1455 1456 shost = dev_to_shost(&starget->dev); 1457 ioc = shost_priv(shost); 1458 1459 if (!(sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME)) { 1460 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1461 sas_device = __mpt3sas_get_sdev_from_target(ioc, 1462 sas_target_priv_data); 1463 if (sas_device && !sas_target_priv_data->num_luns) 1464 sas_device->starget = NULL; 1465 1466 if (sas_device) 1467 sas_device_put(sas_device); 1468 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1469 } 1470 1471 kfree(sdev->hostdata); 1472 sdev->hostdata = NULL; 1473 } 1474 1475 /** 1476 * _scsih_display_sata_capabilities - sata capabilities 1477 * @ioc: per adapter object 1478 * @handle: device handle 1479 * @sdev: scsi device struct 1480 */ 1481 static void 1482 _scsih_display_sata_capabilities(struct MPT3SAS_ADAPTER *ioc, 1483 u16 handle, struct scsi_device *sdev) 1484 { 1485 Mpi2ConfigReply_t mpi_reply; 1486 Mpi2SasDevicePage0_t sas_device_pg0; 1487 u32 ioc_status; 1488 u16 flags; 1489 u32 device_info; 1490 1491 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 1492 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) { 1493 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 1494 ioc->name, __FILE__, __LINE__, __func__); 1495 return; 1496 } 1497 1498 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 1499 MPI2_IOCSTATUS_MASK; 1500 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 1501 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 1502 ioc->name, __FILE__, __LINE__, __func__); 1503 return; 1504 } 1505 1506 flags = le16_to_cpu(sas_device_pg0.Flags); 1507 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 1508 1509 sdev_printk(KERN_INFO, sdev, 1510 "atapi(%s), ncq(%s), asyn_notify(%s), smart(%s), fua(%s), " 1511 "sw_preserve(%s)\n", 1512 (device_info & MPI2_SAS_DEVICE_INFO_ATAPI_DEVICE) ? "y" : "n", 1513 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_NCQ_SUPPORTED) ? "y" : "n", 1514 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_ASYNCHRONOUS_NOTIFY) ? "y" : 1515 "n", 1516 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SMART_SUPPORTED) ? "y" : "n", 1517 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_FUA_SUPPORTED) ? "y" : "n", 1518 (flags & MPI2_SAS_DEVICE0_FLAGS_SATA_SW_PRESERVE) ? "y" : "n"); 1519 } 1520 1521 /* 1522 * raid transport support - 1523 * Enabled for SLES11 and newer, in older kernels the driver will panic when 1524 * unloading the driver followed by a load - I beleive that the subroutine 1525 * raid_class_release() is not cleaning up properly. 1526 */ 1527 1528 /** 1529 * scsih_is_raid - return boolean indicating device is raid volume 1530 * @dev the device struct object 1531 */ 1532 int 1533 scsih_is_raid(struct device *dev) 1534 { 1535 struct scsi_device *sdev = to_scsi_device(dev); 1536 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host); 1537 1538 if (ioc->is_warpdrive) 1539 return 0; 1540 return (sdev->channel == RAID_CHANNEL) ? 1 : 0; 1541 } 1542 1543 /** 1544 * scsih_get_resync - get raid volume resync percent complete 1545 * @dev the device struct object 1546 */ 1547 void 1548 scsih_get_resync(struct device *dev) 1549 { 1550 struct scsi_device *sdev = to_scsi_device(dev); 1551 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host); 1552 static struct _raid_device *raid_device; 1553 unsigned long flags; 1554 Mpi2RaidVolPage0_t vol_pg0; 1555 Mpi2ConfigReply_t mpi_reply; 1556 u32 volume_status_flags; 1557 u8 percent_complete; 1558 u16 handle; 1559 1560 percent_complete = 0; 1561 handle = 0; 1562 if (ioc->is_warpdrive) 1563 goto out; 1564 1565 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1566 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id, 1567 sdev->channel); 1568 if (raid_device) { 1569 handle = raid_device->handle; 1570 percent_complete = raid_device->percent_complete; 1571 } 1572 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1573 1574 if (!handle) 1575 goto out; 1576 1577 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0, 1578 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle, 1579 sizeof(Mpi2RaidVolPage0_t))) { 1580 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 1581 ioc->name, __FILE__, __LINE__, __func__); 1582 percent_complete = 0; 1583 goto out; 1584 } 1585 1586 volume_status_flags = le32_to_cpu(vol_pg0.VolumeStatusFlags); 1587 if (!(volume_status_flags & 1588 MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS)) 1589 percent_complete = 0; 1590 1591 out: 1592 1593 switch (ioc->hba_mpi_version_belonged) { 1594 case MPI2_VERSION: 1595 raid_set_resync(mpt2sas_raid_template, dev, percent_complete); 1596 break; 1597 case MPI25_VERSION: 1598 case MPI26_VERSION: 1599 raid_set_resync(mpt3sas_raid_template, dev, percent_complete); 1600 break; 1601 } 1602 } 1603 1604 /** 1605 * scsih_get_state - get raid volume level 1606 * @dev the device struct object 1607 */ 1608 void 1609 scsih_get_state(struct device *dev) 1610 { 1611 struct scsi_device *sdev = to_scsi_device(dev); 1612 struct MPT3SAS_ADAPTER *ioc = shost_priv(sdev->host); 1613 static struct _raid_device *raid_device; 1614 unsigned long flags; 1615 Mpi2RaidVolPage0_t vol_pg0; 1616 Mpi2ConfigReply_t mpi_reply; 1617 u32 volstate; 1618 enum raid_state state = RAID_STATE_UNKNOWN; 1619 u16 handle = 0; 1620 1621 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1622 raid_device = _scsih_raid_device_find_by_id(ioc, sdev->id, 1623 sdev->channel); 1624 if (raid_device) 1625 handle = raid_device->handle; 1626 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1627 1628 if (!raid_device) 1629 goto out; 1630 1631 if (mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, &vol_pg0, 1632 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, handle, 1633 sizeof(Mpi2RaidVolPage0_t))) { 1634 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 1635 ioc->name, __FILE__, __LINE__, __func__); 1636 goto out; 1637 } 1638 1639 volstate = le32_to_cpu(vol_pg0.VolumeStatusFlags); 1640 if (volstate & MPI2_RAIDVOL0_STATUS_FLAG_RESYNC_IN_PROGRESS) { 1641 state = RAID_STATE_RESYNCING; 1642 goto out; 1643 } 1644 1645 switch (vol_pg0.VolumeState) { 1646 case MPI2_RAID_VOL_STATE_OPTIMAL: 1647 case MPI2_RAID_VOL_STATE_ONLINE: 1648 state = RAID_STATE_ACTIVE; 1649 break; 1650 case MPI2_RAID_VOL_STATE_DEGRADED: 1651 state = RAID_STATE_DEGRADED; 1652 break; 1653 case MPI2_RAID_VOL_STATE_FAILED: 1654 case MPI2_RAID_VOL_STATE_MISSING: 1655 state = RAID_STATE_OFFLINE; 1656 break; 1657 } 1658 out: 1659 switch (ioc->hba_mpi_version_belonged) { 1660 case MPI2_VERSION: 1661 raid_set_state(mpt2sas_raid_template, dev, state); 1662 break; 1663 case MPI25_VERSION: 1664 case MPI26_VERSION: 1665 raid_set_state(mpt3sas_raid_template, dev, state); 1666 break; 1667 } 1668 } 1669 1670 /** 1671 * _scsih_set_level - set raid level 1672 * @sdev: scsi device struct 1673 * @volume_type: volume type 1674 */ 1675 static void 1676 _scsih_set_level(struct MPT3SAS_ADAPTER *ioc, 1677 struct scsi_device *sdev, u8 volume_type) 1678 { 1679 enum raid_level level = RAID_LEVEL_UNKNOWN; 1680 1681 switch (volume_type) { 1682 case MPI2_RAID_VOL_TYPE_RAID0: 1683 level = RAID_LEVEL_0; 1684 break; 1685 case MPI2_RAID_VOL_TYPE_RAID10: 1686 level = RAID_LEVEL_10; 1687 break; 1688 case MPI2_RAID_VOL_TYPE_RAID1E: 1689 level = RAID_LEVEL_1E; 1690 break; 1691 case MPI2_RAID_VOL_TYPE_RAID1: 1692 level = RAID_LEVEL_1; 1693 break; 1694 } 1695 1696 switch (ioc->hba_mpi_version_belonged) { 1697 case MPI2_VERSION: 1698 raid_set_level(mpt2sas_raid_template, 1699 &sdev->sdev_gendev, level); 1700 break; 1701 case MPI25_VERSION: 1702 case MPI26_VERSION: 1703 raid_set_level(mpt3sas_raid_template, 1704 &sdev->sdev_gendev, level); 1705 break; 1706 } 1707 } 1708 1709 1710 /** 1711 * _scsih_get_volume_capabilities - volume capabilities 1712 * @ioc: per adapter object 1713 * @sas_device: the raid_device object 1714 * 1715 * Returns 0 for success, else 1 1716 */ 1717 static int 1718 _scsih_get_volume_capabilities(struct MPT3SAS_ADAPTER *ioc, 1719 struct _raid_device *raid_device) 1720 { 1721 Mpi2RaidVolPage0_t *vol_pg0; 1722 Mpi2RaidPhysDiskPage0_t pd_pg0; 1723 Mpi2SasDevicePage0_t sas_device_pg0; 1724 Mpi2ConfigReply_t mpi_reply; 1725 u16 sz; 1726 u8 num_pds; 1727 1728 if ((mpt3sas_config_get_number_pds(ioc, raid_device->handle, 1729 &num_pds)) || !num_pds) { 1730 dfailprintk(ioc, pr_warn(MPT3SAS_FMT 1731 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__, 1732 __func__)); 1733 return 1; 1734 } 1735 1736 raid_device->num_pds = num_pds; 1737 sz = offsetof(Mpi2RaidVolPage0_t, PhysDisk) + (num_pds * 1738 sizeof(Mpi2RaidVol0PhysDisk_t)); 1739 vol_pg0 = kzalloc(sz, GFP_KERNEL); 1740 if (!vol_pg0) { 1741 dfailprintk(ioc, pr_warn(MPT3SAS_FMT 1742 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__, 1743 __func__)); 1744 return 1; 1745 } 1746 1747 if ((mpt3sas_config_get_raid_volume_pg0(ioc, &mpi_reply, vol_pg0, 1748 MPI2_RAID_VOLUME_PGAD_FORM_HANDLE, raid_device->handle, sz))) { 1749 dfailprintk(ioc, pr_warn(MPT3SAS_FMT 1750 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__, 1751 __func__)); 1752 kfree(vol_pg0); 1753 return 1; 1754 } 1755 1756 raid_device->volume_type = vol_pg0->VolumeType; 1757 1758 /* figure out what the underlying devices are by 1759 * obtaining the device_info bits for the 1st device 1760 */ 1761 if (!(mpt3sas_config_get_phys_disk_pg0(ioc, &mpi_reply, 1762 &pd_pg0, MPI2_PHYSDISK_PGAD_FORM_PHYSDISKNUM, 1763 vol_pg0->PhysDisk[0].PhysDiskNum))) { 1764 if (!(mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, 1765 &sas_device_pg0, MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, 1766 le16_to_cpu(pd_pg0.DevHandle)))) { 1767 raid_device->device_info = 1768 le32_to_cpu(sas_device_pg0.DeviceInfo); 1769 } 1770 } 1771 1772 kfree(vol_pg0); 1773 return 0; 1774 } 1775 1776 /** 1777 * _scsih_enable_tlr - setting TLR flags 1778 * @ioc: per adapter object 1779 * @sdev: scsi device struct 1780 * 1781 * Enabling Transaction Layer Retries for tape devices when 1782 * vpd page 0x90 is present 1783 * 1784 */ 1785 static void 1786 _scsih_enable_tlr(struct MPT3SAS_ADAPTER *ioc, struct scsi_device *sdev) 1787 { 1788 1789 /* only for TAPE */ 1790 if (sdev->type != TYPE_TAPE) 1791 return; 1792 1793 if (!(ioc->facts.IOCCapabilities & MPI2_IOCFACTS_CAPABILITY_TLR)) 1794 return; 1795 1796 sas_enable_tlr(sdev); 1797 sdev_printk(KERN_INFO, sdev, "TLR %s\n", 1798 sas_is_tlr_enabled(sdev) ? "Enabled" : "Disabled"); 1799 return; 1800 1801 } 1802 1803 /** 1804 * scsih_slave_configure - device configure routine. 1805 * @sdev: scsi device struct 1806 * 1807 * Returns 0 if ok. Any other return is assumed to be an error and 1808 * the device is ignored. 1809 */ 1810 int 1811 scsih_slave_configure(struct scsi_device *sdev) 1812 { 1813 struct Scsi_Host *shost = sdev->host; 1814 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 1815 struct MPT3SAS_DEVICE *sas_device_priv_data; 1816 struct MPT3SAS_TARGET *sas_target_priv_data; 1817 struct _sas_device *sas_device; 1818 struct _raid_device *raid_device; 1819 unsigned long flags; 1820 int qdepth; 1821 u8 ssp_target = 0; 1822 char *ds = ""; 1823 char *r_level = ""; 1824 u16 handle, volume_handle = 0; 1825 u64 volume_wwid = 0; 1826 1827 qdepth = 1; 1828 sas_device_priv_data = sdev->hostdata; 1829 sas_device_priv_data->configured_lun = 1; 1830 sas_device_priv_data->flags &= ~MPT_DEVICE_FLAGS_INIT; 1831 sas_target_priv_data = sas_device_priv_data->sas_target; 1832 handle = sas_target_priv_data->handle; 1833 1834 /* raid volume handling */ 1835 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME) { 1836 1837 spin_lock_irqsave(&ioc->raid_device_lock, flags); 1838 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 1839 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 1840 if (!raid_device) { 1841 dfailprintk(ioc, pr_warn(MPT3SAS_FMT 1842 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, 1843 __LINE__, __func__)); 1844 return 1; 1845 } 1846 1847 if (_scsih_get_volume_capabilities(ioc, raid_device)) { 1848 dfailprintk(ioc, pr_warn(MPT3SAS_FMT 1849 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, 1850 __LINE__, __func__)); 1851 return 1; 1852 } 1853 1854 /* 1855 * WARPDRIVE: Initialize the required data for Direct IO 1856 */ 1857 mpt3sas_init_warpdrive_properties(ioc, raid_device); 1858 1859 /* RAID Queue Depth Support 1860 * IS volume = underlying qdepth of drive type, either 1861 * MPT3SAS_SAS_QUEUE_DEPTH or MPT3SAS_SATA_QUEUE_DEPTH 1862 * IM/IME/R10 = 128 (MPT3SAS_RAID_QUEUE_DEPTH) 1863 */ 1864 if (raid_device->device_info & 1865 MPI2_SAS_DEVICE_INFO_SSP_TARGET) { 1866 qdepth = MPT3SAS_SAS_QUEUE_DEPTH; 1867 ds = "SSP"; 1868 } else { 1869 qdepth = MPT3SAS_SATA_QUEUE_DEPTH; 1870 if (raid_device->device_info & 1871 MPI2_SAS_DEVICE_INFO_SATA_DEVICE) 1872 ds = "SATA"; 1873 else 1874 ds = "STP"; 1875 } 1876 1877 switch (raid_device->volume_type) { 1878 case MPI2_RAID_VOL_TYPE_RAID0: 1879 r_level = "RAID0"; 1880 break; 1881 case MPI2_RAID_VOL_TYPE_RAID1E: 1882 qdepth = MPT3SAS_RAID_QUEUE_DEPTH; 1883 if (ioc->manu_pg10.OEMIdentifier && 1884 (le32_to_cpu(ioc->manu_pg10.GenericFlags0) & 1885 MFG10_GF0_R10_DISPLAY) && 1886 !(raid_device->num_pds % 2)) 1887 r_level = "RAID10"; 1888 else 1889 r_level = "RAID1E"; 1890 break; 1891 case MPI2_RAID_VOL_TYPE_RAID1: 1892 qdepth = MPT3SAS_RAID_QUEUE_DEPTH; 1893 r_level = "RAID1"; 1894 break; 1895 case MPI2_RAID_VOL_TYPE_RAID10: 1896 qdepth = MPT3SAS_RAID_QUEUE_DEPTH; 1897 r_level = "RAID10"; 1898 break; 1899 case MPI2_RAID_VOL_TYPE_UNKNOWN: 1900 default: 1901 qdepth = MPT3SAS_RAID_QUEUE_DEPTH; 1902 r_level = "RAIDX"; 1903 break; 1904 } 1905 1906 if (!ioc->hide_ir_msg) 1907 sdev_printk(KERN_INFO, sdev, 1908 "%s: handle(0x%04x), wwid(0x%016llx)," 1909 " pd_count(%d), type(%s)\n", 1910 r_level, raid_device->handle, 1911 (unsigned long long)raid_device->wwid, 1912 raid_device->num_pds, ds); 1913 1914 scsih_change_queue_depth(sdev, qdepth); 1915 1916 /* raid transport support */ 1917 if (!ioc->is_warpdrive) 1918 _scsih_set_level(ioc, sdev, raid_device->volume_type); 1919 return 0; 1920 } 1921 1922 /* non-raid handling */ 1923 if (sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) { 1924 if (mpt3sas_config_get_volume_handle(ioc, handle, 1925 &volume_handle)) { 1926 dfailprintk(ioc, pr_warn(MPT3SAS_FMT 1927 "failure at %s:%d/%s()!\n", ioc->name, 1928 __FILE__, __LINE__, __func__)); 1929 return 1; 1930 } 1931 if (volume_handle && mpt3sas_config_get_volume_wwid(ioc, 1932 volume_handle, &volume_wwid)) { 1933 dfailprintk(ioc, pr_warn(MPT3SAS_FMT 1934 "failure at %s:%d/%s()!\n", ioc->name, 1935 __FILE__, __LINE__, __func__)); 1936 return 1; 1937 } 1938 } 1939 1940 spin_lock_irqsave(&ioc->sas_device_lock, flags); 1941 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 1942 sas_device_priv_data->sas_target->sas_address); 1943 if (!sas_device) { 1944 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1945 dfailprintk(ioc, pr_warn(MPT3SAS_FMT 1946 "failure at %s:%d/%s()!\n", ioc->name, __FILE__, __LINE__, 1947 __func__)); 1948 return 1; 1949 } 1950 1951 sas_device->volume_handle = volume_handle; 1952 sas_device->volume_wwid = volume_wwid; 1953 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_SSP_TARGET) { 1954 qdepth = MPT3SAS_SAS_QUEUE_DEPTH; 1955 ssp_target = 1; 1956 if (sas_device->device_info & 1957 MPI2_SAS_DEVICE_INFO_SEP) { 1958 sdev_printk(KERN_WARNING, sdev, 1959 "set ignore_delay_remove for handle(0x%04x)\n", 1960 sas_device_priv_data->sas_target->handle); 1961 sas_device_priv_data->ignore_delay_remove = 1; 1962 ds = "SES"; 1963 } else 1964 ds = "SSP"; 1965 } else { 1966 qdepth = MPT3SAS_SATA_QUEUE_DEPTH; 1967 if (sas_device->device_info & MPI2_SAS_DEVICE_INFO_STP_TARGET) 1968 ds = "STP"; 1969 else if (sas_device->device_info & 1970 MPI2_SAS_DEVICE_INFO_SATA_DEVICE) 1971 ds = "SATA"; 1972 } 1973 1974 sdev_printk(KERN_INFO, sdev, "%s: handle(0x%04x), " \ 1975 "sas_addr(0x%016llx), phy(%d), device_name(0x%016llx)\n", 1976 ds, handle, (unsigned long long)sas_device->sas_address, 1977 sas_device->phy, (unsigned long long)sas_device->device_name); 1978 if (sas_device->enclosure_handle != 0) 1979 sdev_printk(KERN_INFO, sdev, 1980 "%s: enclosure_logical_id(0x%016llx), slot(%d)\n", 1981 ds, (unsigned long long) 1982 sas_device->enclosure_logical_id, sas_device->slot); 1983 if (sas_device->connector_name[0] != '\0') 1984 sdev_printk(KERN_INFO, sdev, 1985 "%s: enclosure level(0x%04x), connector name( %s)\n", 1986 ds, sas_device->enclosure_level, 1987 sas_device->connector_name); 1988 1989 sas_device_put(sas_device); 1990 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 1991 1992 if (!ssp_target) 1993 _scsih_display_sata_capabilities(ioc, handle, sdev); 1994 1995 1996 scsih_change_queue_depth(sdev, qdepth); 1997 1998 if (ssp_target) { 1999 sas_read_port_mode_page(sdev); 2000 _scsih_enable_tlr(ioc, sdev); 2001 } 2002 2003 return 0; 2004 } 2005 2006 /** 2007 * scsih_bios_param - fetch head, sector, cylinder info for a disk 2008 * @sdev: scsi device struct 2009 * @bdev: pointer to block device context 2010 * @capacity: device size (in 512 byte sectors) 2011 * @params: three element array to place output: 2012 * params[0] number of heads (max 255) 2013 * params[1] number of sectors (max 63) 2014 * params[2] number of cylinders 2015 * 2016 * Return nothing. 2017 */ 2018 int 2019 scsih_bios_param(struct scsi_device *sdev, struct block_device *bdev, 2020 sector_t capacity, int params[]) 2021 { 2022 int heads; 2023 int sectors; 2024 sector_t cylinders; 2025 ulong dummy; 2026 2027 heads = 64; 2028 sectors = 32; 2029 2030 dummy = heads * sectors; 2031 cylinders = capacity; 2032 sector_div(cylinders, dummy); 2033 2034 /* 2035 * Handle extended translation size for logical drives 2036 * > 1Gb 2037 */ 2038 if ((ulong)capacity >= 0x200000) { 2039 heads = 255; 2040 sectors = 63; 2041 dummy = heads * sectors; 2042 cylinders = capacity; 2043 sector_div(cylinders, dummy); 2044 } 2045 2046 /* return result */ 2047 params[0] = heads; 2048 params[1] = sectors; 2049 params[2] = cylinders; 2050 2051 return 0; 2052 } 2053 2054 /** 2055 * _scsih_response_code - translation of device response code 2056 * @ioc: per adapter object 2057 * @response_code: response code returned by the device 2058 * 2059 * Return nothing. 2060 */ 2061 static void 2062 _scsih_response_code(struct MPT3SAS_ADAPTER *ioc, u8 response_code) 2063 { 2064 char *desc; 2065 2066 switch (response_code) { 2067 case MPI2_SCSITASKMGMT_RSP_TM_COMPLETE: 2068 desc = "task management request completed"; 2069 break; 2070 case MPI2_SCSITASKMGMT_RSP_INVALID_FRAME: 2071 desc = "invalid frame"; 2072 break; 2073 case MPI2_SCSITASKMGMT_RSP_TM_NOT_SUPPORTED: 2074 desc = "task management request not supported"; 2075 break; 2076 case MPI2_SCSITASKMGMT_RSP_TM_FAILED: 2077 desc = "task management request failed"; 2078 break; 2079 case MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED: 2080 desc = "task management request succeeded"; 2081 break; 2082 case MPI2_SCSITASKMGMT_RSP_TM_INVALID_LUN: 2083 desc = "invalid lun"; 2084 break; 2085 case 0xA: 2086 desc = "overlapped tag attempted"; 2087 break; 2088 case MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC: 2089 desc = "task queued, however not sent to target"; 2090 break; 2091 default: 2092 desc = "unknown"; 2093 break; 2094 } 2095 pr_warn(MPT3SAS_FMT "response_code(0x%01x): %s\n", 2096 ioc->name, response_code, desc); 2097 } 2098 2099 /** 2100 * _scsih_tm_done - tm completion routine 2101 * @ioc: per adapter object 2102 * @smid: system request message index 2103 * @msix_index: MSIX table index supplied by the OS 2104 * @reply: reply message frame(lower 32bit addr) 2105 * Context: none. 2106 * 2107 * The callback handler when using scsih_issue_tm. 2108 * 2109 * Return 1 meaning mf should be freed from _base_interrupt 2110 * 0 means the mf is freed from this function. 2111 */ 2112 static u8 2113 _scsih_tm_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply) 2114 { 2115 MPI2DefaultReply_t *mpi_reply; 2116 2117 if (ioc->tm_cmds.status == MPT3_CMD_NOT_USED) 2118 return 1; 2119 if (ioc->tm_cmds.smid != smid) 2120 return 1; 2121 mpt3sas_base_flush_reply_queues(ioc); 2122 ioc->tm_cmds.status |= MPT3_CMD_COMPLETE; 2123 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 2124 if (mpi_reply) { 2125 memcpy(ioc->tm_cmds.reply, mpi_reply, mpi_reply->MsgLength*4); 2126 ioc->tm_cmds.status |= MPT3_CMD_REPLY_VALID; 2127 } 2128 ioc->tm_cmds.status &= ~MPT3_CMD_PENDING; 2129 complete(&ioc->tm_cmds.done); 2130 return 1; 2131 } 2132 2133 /** 2134 * mpt3sas_scsih_set_tm_flag - set per target tm_busy 2135 * @ioc: per adapter object 2136 * @handle: device handle 2137 * 2138 * During taskmangement request, we need to freeze the device queue. 2139 */ 2140 void 2141 mpt3sas_scsih_set_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle) 2142 { 2143 struct MPT3SAS_DEVICE *sas_device_priv_data; 2144 struct scsi_device *sdev; 2145 u8 skip = 0; 2146 2147 shost_for_each_device(sdev, ioc->shost) { 2148 if (skip) 2149 continue; 2150 sas_device_priv_data = sdev->hostdata; 2151 if (!sas_device_priv_data) 2152 continue; 2153 if (sas_device_priv_data->sas_target->handle == handle) { 2154 sas_device_priv_data->sas_target->tm_busy = 1; 2155 skip = 1; 2156 ioc->ignore_loginfos = 1; 2157 } 2158 } 2159 } 2160 2161 /** 2162 * mpt3sas_scsih_clear_tm_flag - clear per target tm_busy 2163 * @ioc: per adapter object 2164 * @handle: device handle 2165 * 2166 * During taskmangement request, we need to freeze the device queue. 2167 */ 2168 void 2169 mpt3sas_scsih_clear_tm_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle) 2170 { 2171 struct MPT3SAS_DEVICE *sas_device_priv_data; 2172 struct scsi_device *sdev; 2173 u8 skip = 0; 2174 2175 shost_for_each_device(sdev, ioc->shost) { 2176 if (skip) 2177 continue; 2178 sas_device_priv_data = sdev->hostdata; 2179 if (!sas_device_priv_data) 2180 continue; 2181 if (sas_device_priv_data->sas_target->handle == handle) { 2182 sas_device_priv_data->sas_target->tm_busy = 0; 2183 skip = 1; 2184 ioc->ignore_loginfos = 0; 2185 } 2186 } 2187 } 2188 2189 /** 2190 * mpt3sas_scsih_issue_tm - main routine for sending tm requests 2191 * @ioc: per adapter struct 2192 * @device_handle: device handle 2193 * @channel: the channel assigned by the OS 2194 * @id: the id assigned by the OS 2195 * @lun: lun number 2196 * @type: MPI2_SCSITASKMGMT_TASKTYPE__XXX (defined in mpi2_init.h) 2197 * @smid_task: smid assigned to the task 2198 * @timeout: timeout in seconds 2199 * @m_type: TM_MUTEX_ON or TM_MUTEX_OFF 2200 * Context: user 2201 * 2202 * A generic API for sending task management requests to firmware. 2203 * 2204 * The callback index is set inside `ioc->tm_cb_idx`. 2205 * 2206 * Return SUCCESS or FAILED. 2207 */ 2208 int 2209 mpt3sas_scsih_issue_tm(struct MPT3SAS_ADAPTER *ioc, u16 handle, uint channel, 2210 uint id, uint lun, u8 type, u16 smid_task, ulong timeout, 2211 enum mutex_type m_type) 2212 { 2213 Mpi2SCSITaskManagementRequest_t *mpi_request; 2214 Mpi2SCSITaskManagementReply_t *mpi_reply; 2215 u16 smid = 0; 2216 u32 ioc_state; 2217 unsigned long timeleft; 2218 struct scsiio_tracker *scsi_lookup = NULL; 2219 int rc; 2220 u16 msix_task = 0; 2221 2222 if (m_type == TM_MUTEX_ON) 2223 mutex_lock(&ioc->tm_cmds.mutex); 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 rc = FAILED; 2228 goto err_out; 2229 } 2230 2231 if (ioc->shost_recovery || ioc->remove_host || 2232 ioc->pci_error_recovery) { 2233 pr_info(MPT3SAS_FMT "%s: host reset in progress!\n", 2234 __func__, ioc->name); 2235 rc = FAILED; 2236 goto err_out; 2237 } 2238 2239 ioc_state = mpt3sas_base_get_iocstate(ioc, 0); 2240 if (ioc_state & MPI2_DOORBELL_USED) { 2241 dhsprintk(ioc, pr_info(MPT3SAS_FMT 2242 "unexpected doorbell active!\n", ioc->name)); 2243 rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, 2244 FORCE_BIG_HAMMER); 2245 rc = (!rc) ? SUCCESS : FAILED; 2246 goto err_out; 2247 } 2248 2249 if ((ioc_state & MPI2_IOC_STATE_MASK) == MPI2_IOC_STATE_FAULT) { 2250 mpt3sas_base_fault_info(ioc, ioc_state & 2251 MPI2_DOORBELL_DATA_MASK); 2252 rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, 2253 FORCE_BIG_HAMMER); 2254 rc = (!rc) ? SUCCESS : FAILED; 2255 goto err_out; 2256 } 2257 2258 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_cb_idx); 2259 if (!smid) { 2260 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 2261 ioc->name, __func__); 2262 rc = FAILED; 2263 goto err_out; 2264 } 2265 2266 if (type == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK) 2267 scsi_lookup = &ioc->scsi_lookup[smid_task - 1]; 2268 2269 dtmprintk(ioc, pr_info(MPT3SAS_FMT 2270 "sending tm: handle(0x%04x), task_type(0x%02x), smid(%d)\n", 2271 ioc->name, handle, type, smid_task)); 2272 ioc->tm_cmds.status = MPT3_CMD_PENDING; 2273 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 2274 ioc->tm_cmds.smid = smid; 2275 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t)); 2276 memset(ioc->tm_cmds.reply, 0, sizeof(Mpi2SCSITaskManagementReply_t)); 2277 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 2278 mpi_request->DevHandle = cpu_to_le16(handle); 2279 mpi_request->TaskType = type; 2280 mpi_request->TaskMID = cpu_to_le16(smid_task); 2281 int_to_scsilun(lun, (struct scsi_lun *)mpi_request->LUN); 2282 mpt3sas_scsih_set_tm_flag(ioc, handle); 2283 init_completion(&ioc->tm_cmds.done); 2284 if ((type == MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK) && 2285 (scsi_lookup->msix_io < ioc->reply_queue_count)) 2286 msix_task = scsi_lookup->msix_io; 2287 else 2288 msix_task = 0; 2289 mpt3sas_base_put_smid_hi_priority(ioc, smid, msix_task); 2290 timeleft = wait_for_completion_timeout(&ioc->tm_cmds.done, timeout*HZ); 2291 if (!(ioc->tm_cmds.status & MPT3_CMD_COMPLETE)) { 2292 pr_err(MPT3SAS_FMT "%s: timeout\n", 2293 ioc->name, __func__); 2294 _debug_dump_mf(mpi_request, 2295 sizeof(Mpi2SCSITaskManagementRequest_t)/4); 2296 if (!(ioc->tm_cmds.status & MPT3_CMD_RESET)) { 2297 rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, 2298 FORCE_BIG_HAMMER); 2299 rc = (!rc) ? SUCCESS : FAILED; 2300 ioc->tm_cmds.status = MPT3_CMD_NOT_USED; 2301 mpt3sas_scsih_clear_tm_flag(ioc, handle); 2302 goto err_out; 2303 } 2304 } 2305 2306 if (ioc->tm_cmds.status & MPT3_CMD_REPLY_VALID) { 2307 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT); 2308 mpi_reply = ioc->tm_cmds.reply; 2309 dtmprintk(ioc, pr_info(MPT3SAS_FMT "complete tm: " \ 2310 "ioc_status(0x%04x), loginfo(0x%08x), term_count(0x%08x)\n", 2311 ioc->name, le16_to_cpu(mpi_reply->IOCStatus), 2312 le32_to_cpu(mpi_reply->IOCLogInfo), 2313 le32_to_cpu(mpi_reply->TerminationCount))); 2314 if (ioc->logging_level & MPT_DEBUG_TM) { 2315 _scsih_response_code(ioc, mpi_reply->ResponseCode); 2316 if (mpi_reply->IOCStatus) 2317 _debug_dump_mf(mpi_request, 2318 sizeof(Mpi2SCSITaskManagementRequest_t)/4); 2319 } 2320 } 2321 2322 switch (type) { 2323 case MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK: 2324 rc = SUCCESS; 2325 if (scsi_lookup->scmd == NULL) 2326 break; 2327 rc = FAILED; 2328 break; 2329 2330 case MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET: 2331 if (_scsih_scsi_lookup_find_by_target(ioc, id, channel)) 2332 rc = FAILED; 2333 else 2334 rc = SUCCESS; 2335 break; 2336 case MPI2_SCSITASKMGMT_TASKTYPE_ABRT_TASK_SET: 2337 case MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET: 2338 if (_scsih_scsi_lookup_find_by_lun(ioc, id, lun, channel)) 2339 rc = FAILED; 2340 else 2341 rc = SUCCESS; 2342 break; 2343 case MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK: 2344 rc = SUCCESS; 2345 break; 2346 default: 2347 rc = FAILED; 2348 break; 2349 } 2350 2351 mpt3sas_scsih_clear_tm_flag(ioc, handle); 2352 ioc->tm_cmds.status = MPT3_CMD_NOT_USED; 2353 if (m_type == TM_MUTEX_ON) 2354 mutex_unlock(&ioc->tm_cmds.mutex); 2355 2356 return rc; 2357 2358 err_out: 2359 if (m_type == TM_MUTEX_ON) 2360 mutex_unlock(&ioc->tm_cmds.mutex); 2361 return rc; 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 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_tm(ioc, handle, scmd->device->channel, 2478 scmd->device->id, scmd->device->lun, 2479 MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30, TM_MUTEX_ON); 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 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_tm(ioc, handle, scmd->device->channel, 2537 scmd->device->id, scmd->device->lun, 2538 MPI2_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET, 0, 30, TM_MUTEX_ON); 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 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_tm(ioc, handle, scmd->device->channel, 2599 scmd->device->id, 0, MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET, 0, 2600 30, TM_MUTEX_ON); 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 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, CAN_SLEEP, 2637 FORCE_BIG_HAMMER); 2638 r = (retval < 0) ? FAILED : SUCCESS; 2639 out: 2640 pr_info(MPT3SAS_FMT "host reset: %s scmd(%p)\n", 2641 ioc->name, ((r == SUCCESS) ? "SUCCESS" : "FAILED"), scmd); 2642 2643 return r; 2644 } 2645 2646 /** 2647 * _scsih_fw_event_add - insert and queue up fw_event 2648 * @ioc: per adapter object 2649 * @fw_event: object describing the event 2650 * Context: This function will acquire ioc->fw_event_lock. 2651 * 2652 * This adds the firmware event object into link list, then queues it up to 2653 * be processed from user context. 2654 * 2655 * Return nothing. 2656 */ 2657 static void 2658 _scsih_fw_event_add(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work *fw_event) 2659 { 2660 unsigned long flags; 2661 2662 if (ioc->firmware_event_thread == NULL) 2663 return; 2664 2665 spin_lock_irqsave(&ioc->fw_event_lock, flags); 2666 fw_event_work_get(fw_event); 2667 INIT_LIST_HEAD(&fw_event->list); 2668 list_add_tail(&fw_event->list, &ioc->fw_event_list); 2669 INIT_WORK(&fw_event->work, _firmware_event_work); 2670 fw_event_work_get(fw_event); 2671 queue_work(ioc->firmware_event_thread, &fw_event->work); 2672 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 2673 } 2674 2675 /** 2676 * _scsih_fw_event_del_from_list - delete fw_event from the list 2677 * @ioc: per adapter object 2678 * @fw_event: object describing the event 2679 * Context: This function will acquire ioc->fw_event_lock. 2680 * 2681 * If the fw_event is on the fw_event_list, remove it and do a put. 2682 * 2683 * Return nothing. 2684 */ 2685 static void 2686 _scsih_fw_event_del_from_list(struct MPT3SAS_ADAPTER *ioc, struct fw_event_work 2687 *fw_event) 2688 { 2689 unsigned long flags; 2690 2691 spin_lock_irqsave(&ioc->fw_event_lock, flags); 2692 if (!list_empty(&fw_event->list)) { 2693 list_del_init(&fw_event->list); 2694 fw_event_work_put(fw_event); 2695 } 2696 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 2697 } 2698 2699 2700 /** 2701 * mpt3sas_send_trigger_data_event - send event for processing trigger data 2702 * @ioc: per adapter object 2703 * @event_data: trigger event data 2704 * 2705 * Return nothing. 2706 */ 2707 void 2708 mpt3sas_send_trigger_data_event(struct MPT3SAS_ADAPTER *ioc, 2709 struct SL_WH_TRIGGERS_EVENT_DATA_T *event_data) 2710 { 2711 struct fw_event_work *fw_event; 2712 u16 sz; 2713 2714 if (ioc->is_driver_loading) 2715 return; 2716 sz = sizeof(*event_data); 2717 fw_event = alloc_fw_event_work(sz); 2718 if (!fw_event) 2719 return; 2720 fw_event->event = MPT3SAS_PROCESS_TRIGGER_DIAG; 2721 fw_event->ioc = ioc; 2722 memcpy(fw_event->event_data, event_data, sizeof(*event_data)); 2723 _scsih_fw_event_add(ioc, fw_event); 2724 fw_event_work_put(fw_event); 2725 } 2726 2727 /** 2728 * _scsih_error_recovery_delete_devices - remove devices not responding 2729 * @ioc: per adapter object 2730 * 2731 * Return nothing. 2732 */ 2733 static void 2734 _scsih_error_recovery_delete_devices(struct MPT3SAS_ADAPTER *ioc) 2735 { 2736 struct fw_event_work *fw_event; 2737 2738 if (ioc->is_driver_loading) 2739 return; 2740 fw_event = alloc_fw_event_work(0); 2741 if (!fw_event) 2742 return; 2743 fw_event->event = MPT3SAS_REMOVE_UNRESPONDING_DEVICES; 2744 fw_event->ioc = ioc; 2745 _scsih_fw_event_add(ioc, fw_event); 2746 fw_event_work_put(fw_event); 2747 } 2748 2749 /** 2750 * mpt3sas_port_enable_complete - port enable completed (fake event) 2751 * @ioc: per adapter object 2752 * 2753 * Return nothing. 2754 */ 2755 void 2756 mpt3sas_port_enable_complete(struct MPT3SAS_ADAPTER *ioc) 2757 { 2758 struct fw_event_work *fw_event; 2759 2760 fw_event = alloc_fw_event_work(0); 2761 if (!fw_event) 2762 return; 2763 fw_event->event = MPT3SAS_PORT_ENABLE_COMPLETE; 2764 fw_event->ioc = ioc; 2765 _scsih_fw_event_add(ioc, fw_event); 2766 fw_event_work_put(fw_event); 2767 } 2768 2769 static struct fw_event_work *dequeue_next_fw_event(struct MPT3SAS_ADAPTER *ioc) 2770 { 2771 unsigned long flags; 2772 struct fw_event_work *fw_event = NULL; 2773 2774 spin_lock_irqsave(&ioc->fw_event_lock, flags); 2775 if (!list_empty(&ioc->fw_event_list)) { 2776 fw_event = list_first_entry(&ioc->fw_event_list, 2777 struct fw_event_work, list); 2778 list_del_init(&fw_event->list); 2779 } 2780 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 2781 2782 return fw_event; 2783 } 2784 2785 /** 2786 * _scsih_fw_event_cleanup_queue - cleanup event queue 2787 * @ioc: per adapter object 2788 * 2789 * Walk the firmware event queue, either killing timers, or waiting 2790 * for outstanding events to complete 2791 * 2792 * Return nothing. 2793 */ 2794 static void 2795 _scsih_fw_event_cleanup_queue(struct MPT3SAS_ADAPTER *ioc) 2796 { 2797 struct fw_event_work *fw_event; 2798 2799 if (list_empty(&ioc->fw_event_list) || 2800 !ioc->firmware_event_thread || in_interrupt()) 2801 return; 2802 2803 while ((fw_event = dequeue_next_fw_event(ioc))) { 2804 /* 2805 * Wait on the fw_event to complete. If this returns 1, then 2806 * the event was never executed, and we need a put for the 2807 * reference the delayed_work had on the fw_event. 2808 * 2809 * If it did execute, we wait for it to finish, and the put will 2810 * happen from _firmware_event_work() 2811 */ 2812 if (cancel_delayed_work_sync(&fw_event->delayed_work)) 2813 fw_event_work_put(fw_event); 2814 2815 fw_event_work_put(fw_event); 2816 } 2817 } 2818 2819 /** 2820 * _scsih_internal_device_block - block the sdev device 2821 * @sdev: per device object 2822 * @sas_device_priv_data : per device driver private data 2823 * 2824 * make sure device is blocked without error, if not 2825 * print an error 2826 */ 2827 static void 2828 _scsih_internal_device_block(struct scsi_device *sdev, 2829 struct MPT3SAS_DEVICE *sas_device_priv_data) 2830 { 2831 int r = 0; 2832 2833 sdev_printk(KERN_INFO, sdev, "device_block, handle(0x%04x)\n", 2834 sas_device_priv_data->sas_target->handle); 2835 sas_device_priv_data->block = 1; 2836 2837 r = scsi_internal_device_block(sdev); 2838 if (r == -EINVAL) 2839 sdev_printk(KERN_WARNING, sdev, 2840 "device_block failed with return(%d) for handle(0x%04x)\n", 2841 sas_device_priv_data->sas_target->handle, r); 2842 } 2843 2844 /** 2845 * _scsih_internal_device_unblock - unblock the sdev device 2846 * @sdev: per device object 2847 * @sas_device_priv_data : per device driver private data 2848 * make sure device is unblocked without error, if not retry 2849 * by blocking and then unblocking 2850 */ 2851 2852 static void 2853 _scsih_internal_device_unblock(struct scsi_device *sdev, 2854 struct MPT3SAS_DEVICE *sas_device_priv_data) 2855 { 2856 int r = 0; 2857 2858 sdev_printk(KERN_WARNING, sdev, "device_unblock and setting to running, " 2859 "handle(0x%04x)\n", sas_device_priv_data->sas_target->handle); 2860 sas_device_priv_data->block = 0; 2861 r = scsi_internal_device_unblock(sdev, SDEV_RUNNING); 2862 if (r == -EINVAL) { 2863 /* The device has been set to SDEV_RUNNING by SD layer during 2864 * device addition but the request queue is still stopped by 2865 * our earlier block call. We need to perform a block again 2866 * to get the device to SDEV_BLOCK and then to SDEV_RUNNING */ 2867 2868 sdev_printk(KERN_WARNING, sdev, 2869 "device_unblock failed with return(%d) for handle(0x%04x) " 2870 "performing a block followed by an unblock\n", 2871 sas_device_priv_data->sas_target->handle, r); 2872 sas_device_priv_data->block = 1; 2873 r = scsi_internal_device_block(sdev); 2874 if (r) 2875 sdev_printk(KERN_WARNING, sdev, "retried device_block " 2876 "failed with return(%d) for handle(0x%04x)\n", 2877 sas_device_priv_data->sas_target->handle, r); 2878 2879 sas_device_priv_data->block = 0; 2880 r = scsi_internal_device_unblock(sdev, SDEV_RUNNING); 2881 if (r) 2882 sdev_printk(KERN_WARNING, sdev, "retried device_unblock" 2883 " failed with return(%d) for handle(0x%04x)\n", 2884 sas_device_priv_data->sas_target->handle, r); 2885 } 2886 } 2887 2888 /** 2889 * _scsih_ublock_io_all_device - unblock every device 2890 * @ioc: per adapter object 2891 * 2892 * change the device state from block to running 2893 */ 2894 static void 2895 _scsih_ublock_io_all_device(struct MPT3SAS_ADAPTER *ioc) 2896 { 2897 struct MPT3SAS_DEVICE *sas_device_priv_data; 2898 struct scsi_device *sdev; 2899 2900 shost_for_each_device(sdev, ioc->shost) { 2901 sas_device_priv_data = sdev->hostdata; 2902 if (!sas_device_priv_data) 2903 continue; 2904 if (!sas_device_priv_data->block) 2905 continue; 2906 2907 dewtprintk(ioc, sdev_printk(KERN_INFO, sdev, 2908 "device_running, handle(0x%04x)\n", 2909 sas_device_priv_data->sas_target->handle)); 2910 _scsih_internal_device_unblock(sdev, sas_device_priv_data); 2911 } 2912 } 2913 2914 2915 /** 2916 * _scsih_ublock_io_device - prepare device to be deleted 2917 * @ioc: per adapter object 2918 * @sas_addr: sas address 2919 * 2920 * unblock then put device in offline state 2921 */ 2922 static void 2923 _scsih_ublock_io_device(struct MPT3SAS_ADAPTER *ioc, u64 sas_address) 2924 { 2925 struct MPT3SAS_DEVICE *sas_device_priv_data; 2926 struct scsi_device *sdev; 2927 2928 shost_for_each_device(sdev, ioc->shost) { 2929 sas_device_priv_data = sdev->hostdata; 2930 if (!sas_device_priv_data) 2931 continue; 2932 if (sas_device_priv_data->sas_target->sas_address 2933 != sas_address) 2934 continue; 2935 if (sas_device_priv_data->block) 2936 _scsih_internal_device_unblock(sdev, 2937 sas_device_priv_data); 2938 } 2939 } 2940 2941 /** 2942 * _scsih_block_io_all_device - set the device state to SDEV_BLOCK 2943 * @ioc: per adapter object 2944 * @handle: device handle 2945 * 2946 * During device pull we need to appropiately set the sdev state. 2947 */ 2948 static void 2949 _scsih_block_io_all_device(struct MPT3SAS_ADAPTER *ioc) 2950 { 2951 struct MPT3SAS_DEVICE *sas_device_priv_data; 2952 struct scsi_device *sdev; 2953 2954 shost_for_each_device(sdev, ioc->shost) { 2955 sas_device_priv_data = sdev->hostdata; 2956 if (!sas_device_priv_data) 2957 continue; 2958 if (sas_device_priv_data->block) 2959 continue; 2960 if (sas_device_priv_data->ignore_delay_remove) { 2961 sdev_printk(KERN_INFO, sdev, 2962 "%s skip device_block for SES handle(0x%04x)\n", 2963 __func__, sas_device_priv_data->sas_target->handle); 2964 continue; 2965 } 2966 _scsih_internal_device_block(sdev, sas_device_priv_data); 2967 } 2968 } 2969 2970 /** 2971 * _scsih_block_io_device - set the device state to SDEV_BLOCK 2972 * @ioc: per adapter object 2973 * @handle: device handle 2974 * 2975 * During device pull we need to appropiately set the sdev state. 2976 */ 2977 static void 2978 _scsih_block_io_device(struct MPT3SAS_ADAPTER *ioc, u16 handle) 2979 { 2980 struct MPT3SAS_DEVICE *sas_device_priv_data; 2981 struct scsi_device *sdev; 2982 struct _sas_device *sas_device; 2983 2984 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 2985 if (!sas_device) 2986 return; 2987 2988 shost_for_each_device(sdev, ioc->shost) { 2989 sas_device_priv_data = sdev->hostdata; 2990 if (!sas_device_priv_data) 2991 continue; 2992 if (sas_device_priv_data->sas_target->handle != handle) 2993 continue; 2994 if (sas_device_priv_data->block) 2995 continue; 2996 if (sas_device->pend_sas_rphy_add) 2997 continue; 2998 if (sas_device_priv_data->ignore_delay_remove) { 2999 sdev_printk(KERN_INFO, sdev, 3000 "%s skip device_block for SES handle(0x%04x)\n", 3001 __func__, sas_device_priv_data->sas_target->handle); 3002 continue; 3003 } 3004 _scsih_internal_device_block(sdev, sas_device_priv_data); 3005 } 3006 3007 sas_device_put(sas_device); 3008 } 3009 3010 /** 3011 * _scsih_block_io_to_children_attached_to_ex 3012 * @ioc: per adapter object 3013 * @sas_expander: the sas_device object 3014 * 3015 * This routine set sdev state to SDEV_BLOCK for all devices 3016 * attached to this expander. This function called when expander is 3017 * pulled. 3018 */ 3019 static void 3020 _scsih_block_io_to_children_attached_to_ex(struct MPT3SAS_ADAPTER *ioc, 3021 struct _sas_node *sas_expander) 3022 { 3023 struct _sas_port *mpt3sas_port; 3024 struct _sas_device *sas_device; 3025 struct _sas_node *expander_sibling; 3026 unsigned long flags; 3027 3028 if (!sas_expander) 3029 return; 3030 3031 list_for_each_entry(mpt3sas_port, 3032 &sas_expander->sas_port_list, port_list) { 3033 if (mpt3sas_port->remote_identify.device_type == 3034 SAS_END_DEVICE) { 3035 spin_lock_irqsave(&ioc->sas_device_lock, flags); 3036 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 3037 mpt3sas_port->remote_identify.sas_address); 3038 if (sas_device) { 3039 set_bit(sas_device->handle, 3040 ioc->blocking_handles); 3041 sas_device_put(sas_device); 3042 } 3043 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 3044 } 3045 } 3046 3047 list_for_each_entry(mpt3sas_port, 3048 &sas_expander->sas_port_list, port_list) { 3049 3050 if (mpt3sas_port->remote_identify.device_type == 3051 SAS_EDGE_EXPANDER_DEVICE || 3052 mpt3sas_port->remote_identify.device_type == 3053 SAS_FANOUT_EXPANDER_DEVICE) { 3054 expander_sibling = 3055 mpt3sas_scsih_expander_find_by_sas_address( 3056 ioc, mpt3sas_port->remote_identify.sas_address); 3057 _scsih_block_io_to_children_attached_to_ex(ioc, 3058 expander_sibling); 3059 } 3060 } 3061 } 3062 3063 /** 3064 * _scsih_block_io_to_children_attached_directly 3065 * @ioc: per adapter object 3066 * @event_data: topology change event data 3067 * 3068 * This routine set sdev state to SDEV_BLOCK for all devices 3069 * direct attached during device pull. 3070 */ 3071 static void 3072 _scsih_block_io_to_children_attached_directly(struct MPT3SAS_ADAPTER *ioc, 3073 Mpi2EventDataSasTopologyChangeList_t *event_data) 3074 { 3075 int i; 3076 u16 handle; 3077 u16 reason_code; 3078 3079 for (i = 0; i < event_data->NumEntries; i++) { 3080 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 3081 if (!handle) 3082 continue; 3083 reason_code = event_data->PHY[i].PhyStatus & 3084 MPI2_EVENT_SAS_TOPO_RC_MASK; 3085 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING) 3086 _scsih_block_io_device(ioc, handle); 3087 } 3088 } 3089 3090 /** 3091 * _scsih_tm_tr_send - send task management request 3092 * @ioc: per adapter object 3093 * @handle: device handle 3094 * Context: interrupt time. 3095 * 3096 * This code is to initiate the device removal handshake protocol 3097 * with controller firmware. This function will issue target reset 3098 * using high priority request queue. It will send a sas iounit 3099 * control request (MPI2_SAS_OP_REMOVE_DEVICE) from this completion. 3100 * 3101 * This is designed to send muliple task management request at the same 3102 * time to the fifo. If the fifo is full, we will append the request, 3103 * and process it in a future completion. 3104 */ 3105 static void 3106 _scsih_tm_tr_send(struct MPT3SAS_ADAPTER *ioc, u16 handle) 3107 { 3108 Mpi2SCSITaskManagementRequest_t *mpi_request; 3109 u16 smid; 3110 struct _sas_device *sas_device = NULL; 3111 struct MPT3SAS_TARGET *sas_target_priv_data = NULL; 3112 u64 sas_address = 0; 3113 unsigned long flags; 3114 struct _tr_list *delayed_tr; 3115 u32 ioc_state; 3116 3117 if (ioc->remove_host) { 3118 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3119 "%s: host has been removed: handle(0x%04x)\n", 3120 __func__, ioc->name, handle)); 3121 return; 3122 } else if (ioc->pci_error_recovery) { 3123 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3124 "%s: host in pci error recovery: handle(0x%04x)\n", 3125 __func__, ioc->name, 3126 handle)); 3127 return; 3128 } 3129 ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 3130 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 3131 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3132 "%s: host is not operational: handle(0x%04x)\n", 3133 __func__, ioc->name, 3134 handle)); 3135 return; 3136 } 3137 3138 /* if PD, then return */ 3139 if (test_bit(handle, ioc->pd_handles)) 3140 return; 3141 3142 spin_lock_irqsave(&ioc->sas_device_lock, flags); 3143 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 3144 if (sas_device && sas_device->starget && 3145 sas_device->starget->hostdata) { 3146 sas_target_priv_data = sas_device->starget->hostdata; 3147 sas_target_priv_data->deleted = 1; 3148 sas_address = sas_device->sas_address; 3149 } 3150 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 3151 3152 if (sas_target_priv_data) { 3153 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3154 "setting delete flag: handle(0x%04x), sas_addr(0x%016llx)\n", 3155 ioc->name, handle, 3156 (unsigned long long)sas_address)); 3157 if (sas_device->enclosure_handle != 0) 3158 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3159 "setting delete flag:enclosure logical id(0x%016llx)," 3160 " slot(%d)\n", ioc->name, (unsigned long long) 3161 sas_device->enclosure_logical_id, 3162 sas_device->slot)); 3163 if (sas_device->connector_name[0] != '\0') 3164 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3165 "setting delete flag: enclosure level(0x%04x)," 3166 " connector name( %s)\n", ioc->name, 3167 sas_device->enclosure_level, 3168 sas_device->connector_name)); 3169 _scsih_ublock_io_device(ioc, sas_address); 3170 sas_target_priv_data->handle = MPT3SAS_INVALID_DEVICE_HANDLE; 3171 } 3172 3173 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_cb_idx); 3174 if (!smid) { 3175 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC); 3176 if (!delayed_tr) 3177 goto out; 3178 INIT_LIST_HEAD(&delayed_tr->list); 3179 delayed_tr->handle = handle; 3180 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list); 3181 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3182 "DELAYED:tr:handle(0x%04x), (open)\n", 3183 ioc->name, handle)); 3184 goto out; 3185 } 3186 3187 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3188 "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n", 3189 ioc->name, handle, smid, 3190 ioc->tm_tr_cb_idx)); 3191 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 3192 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t)); 3193 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 3194 mpi_request->DevHandle = cpu_to_le16(handle); 3195 mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET; 3196 mpt3sas_base_put_smid_hi_priority(ioc, smid, 0); 3197 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_DEVICE_REMOVAL); 3198 3199 out: 3200 if (sas_device) 3201 sas_device_put(sas_device); 3202 } 3203 3204 /** 3205 * _scsih_tm_tr_complete - 3206 * @ioc: per adapter object 3207 * @smid: system request message index 3208 * @msix_index: MSIX table index supplied by the OS 3209 * @reply: reply message frame(lower 32bit addr) 3210 * Context: interrupt time. 3211 * 3212 * This is the target reset completion routine. 3213 * This code is part of the code to initiate the device removal 3214 * handshake protocol with controller firmware. 3215 * It will send a sas iounit control request (MPI2_SAS_OP_REMOVE_DEVICE) 3216 * 3217 * Return 1 meaning mf should be freed from _base_interrupt 3218 * 0 means the mf is freed from this function. 3219 */ 3220 static u8 3221 _scsih_tm_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, 3222 u32 reply) 3223 { 3224 u16 handle; 3225 Mpi2SCSITaskManagementRequest_t *mpi_request_tm; 3226 Mpi2SCSITaskManagementReply_t *mpi_reply = 3227 mpt3sas_base_get_reply_virt_addr(ioc, reply); 3228 Mpi2SasIoUnitControlRequest_t *mpi_request; 3229 u16 smid_sas_ctrl; 3230 u32 ioc_state; 3231 struct _sc_list *delayed_sc; 3232 3233 if (ioc->remove_host) { 3234 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3235 "%s: host has been removed\n", __func__, ioc->name)); 3236 return 1; 3237 } else if (ioc->pci_error_recovery) { 3238 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3239 "%s: host in pci error recovery\n", __func__, 3240 ioc->name)); 3241 return 1; 3242 } 3243 ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 3244 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 3245 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3246 "%s: host is not operational\n", __func__, ioc->name)); 3247 return 1; 3248 } 3249 if (unlikely(!mpi_reply)) { 3250 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n", 3251 ioc->name, __FILE__, __LINE__, __func__); 3252 return 1; 3253 } 3254 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid); 3255 handle = le16_to_cpu(mpi_request_tm->DevHandle); 3256 if (handle != le16_to_cpu(mpi_reply->DevHandle)) { 3257 dewtprintk(ioc, pr_err(MPT3SAS_FMT 3258 "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n", 3259 ioc->name, handle, 3260 le16_to_cpu(mpi_reply->DevHandle), smid)); 3261 return 0; 3262 } 3263 3264 mpt3sas_trigger_master(ioc, MASTER_TRIGGER_TASK_MANAGMENT); 3265 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3266 "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), " 3267 "loginfo(0x%08x), completed(%d)\n", ioc->name, 3268 handle, smid, le16_to_cpu(mpi_reply->IOCStatus), 3269 le32_to_cpu(mpi_reply->IOCLogInfo), 3270 le32_to_cpu(mpi_reply->TerminationCount))); 3271 3272 smid_sas_ctrl = mpt3sas_base_get_smid(ioc, ioc->tm_sas_control_cb_idx); 3273 if (!smid_sas_ctrl) { 3274 delayed_sc = kzalloc(sizeof(*delayed_sc), GFP_ATOMIC); 3275 if (!delayed_sc) 3276 return _scsih_check_for_pending_tm(ioc, smid); 3277 INIT_LIST_HEAD(&delayed_sc->list); 3278 delayed_sc->handle = mpi_request_tm->DevHandle; 3279 list_add_tail(&delayed_sc->list, &ioc->delayed_sc_list); 3280 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3281 "DELAYED:sc:handle(0x%04x), (open)\n", 3282 ioc->name, handle)); 3283 return _scsih_check_for_pending_tm(ioc, smid); 3284 } 3285 3286 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3287 "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n", 3288 ioc->name, handle, smid_sas_ctrl, 3289 ioc->tm_sas_control_cb_idx)); 3290 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid_sas_ctrl); 3291 memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t)); 3292 mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL; 3293 mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE; 3294 mpi_request->DevHandle = mpi_request_tm->DevHandle; 3295 mpt3sas_base_put_smid_default(ioc, smid_sas_ctrl); 3296 3297 return _scsih_check_for_pending_tm(ioc, smid); 3298 } 3299 3300 3301 /** 3302 * _scsih_sas_control_complete - completion routine 3303 * @ioc: per adapter object 3304 * @smid: system request message index 3305 * @msix_index: MSIX table index supplied by the OS 3306 * @reply: reply message frame(lower 32bit addr) 3307 * Context: interrupt time. 3308 * 3309 * This is the sas iounit control completion routine. 3310 * This code is part of the code to initiate the device removal 3311 * handshake protocol with controller firmware. 3312 * 3313 * Return 1 meaning mf should be freed from _base_interrupt 3314 * 0 means the mf is freed from this function. 3315 */ 3316 static u8 3317 _scsih_sas_control_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, 3318 u8 msix_index, u32 reply) 3319 { 3320 Mpi2SasIoUnitControlReply_t *mpi_reply = 3321 mpt3sas_base_get_reply_virt_addr(ioc, reply); 3322 3323 if (likely(mpi_reply)) { 3324 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3325 "sc_complete:handle(0x%04x), (open) " 3326 "smid(%d), ioc_status(0x%04x), loginfo(0x%08x)\n", 3327 ioc->name, le16_to_cpu(mpi_reply->DevHandle), smid, 3328 le16_to_cpu(mpi_reply->IOCStatus), 3329 le32_to_cpu(mpi_reply->IOCLogInfo))); 3330 } else { 3331 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n", 3332 ioc->name, __FILE__, __LINE__, __func__); 3333 } 3334 return mpt3sas_check_for_pending_internal_cmds(ioc, smid); 3335 } 3336 3337 /** 3338 * _scsih_tm_tr_volume_send - send target reset request for volumes 3339 * @ioc: per adapter object 3340 * @handle: device handle 3341 * Context: interrupt time. 3342 * 3343 * This is designed to send muliple task management request at the same 3344 * time to the fifo. If the fifo is full, we will append the request, 3345 * and process it in a future completion. 3346 */ 3347 static void 3348 _scsih_tm_tr_volume_send(struct MPT3SAS_ADAPTER *ioc, u16 handle) 3349 { 3350 Mpi2SCSITaskManagementRequest_t *mpi_request; 3351 u16 smid; 3352 struct _tr_list *delayed_tr; 3353 3354 if (ioc->shost_recovery || ioc->remove_host || 3355 ioc->pci_error_recovery) { 3356 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3357 "%s: host reset in progress!\n", 3358 __func__, ioc->name)); 3359 return; 3360 } 3361 3362 smid = mpt3sas_base_get_smid_hpr(ioc, ioc->tm_tr_volume_cb_idx); 3363 if (!smid) { 3364 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC); 3365 if (!delayed_tr) 3366 return; 3367 INIT_LIST_HEAD(&delayed_tr->list); 3368 delayed_tr->handle = handle; 3369 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_volume_list); 3370 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3371 "DELAYED:tr:handle(0x%04x), (open)\n", 3372 ioc->name, handle)); 3373 return; 3374 } 3375 3376 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3377 "tr_send:handle(0x%04x), (open), smid(%d), cb(%d)\n", 3378 ioc->name, handle, smid, 3379 ioc->tm_tr_volume_cb_idx)); 3380 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 3381 memset(mpi_request, 0, sizeof(Mpi2SCSITaskManagementRequest_t)); 3382 mpi_request->Function = MPI2_FUNCTION_SCSI_TASK_MGMT; 3383 mpi_request->DevHandle = cpu_to_le16(handle); 3384 mpi_request->TaskType = MPI2_SCSITASKMGMT_TASKTYPE_TARGET_RESET; 3385 mpt3sas_base_put_smid_hi_priority(ioc, smid, 0); 3386 } 3387 3388 /** 3389 * _scsih_tm_volume_tr_complete - target reset completion 3390 * @ioc: per adapter object 3391 * @smid: system request message index 3392 * @msix_index: MSIX table index supplied by the OS 3393 * @reply: reply message frame(lower 32bit addr) 3394 * Context: interrupt time. 3395 * 3396 * Return 1 meaning mf should be freed from _base_interrupt 3397 * 0 means the mf is freed from this function. 3398 */ 3399 static u8 3400 _scsih_tm_volume_tr_complete(struct MPT3SAS_ADAPTER *ioc, u16 smid, 3401 u8 msix_index, u32 reply) 3402 { 3403 u16 handle; 3404 Mpi2SCSITaskManagementRequest_t *mpi_request_tm; 3405 Mpi2SCSITaskManagementReply_t *mpi_reply = 3406 mpt3sas_base_get_reply_virt_addr(ioc, reply); 3407 3408 if (ioc->shost_recovery || ioc->remove_host || 3409 ioc->pci_error_recovery) { 3410 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3411 "%s: host reset in progress!\n", 3412 __func__, ioc->name)); 3413 return 1; 3414 } 3415 if (unlikely(!mpi_reply)) { 3416 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n", 3417 ioc->name, __FILE__, __LINE__, __func__); 3418 return 1; 3419 } 3420 3421 mpi_request_tm = mpt3sas_base_get_msg_frame(ioc, smid); 3422 handle = le16_to_cpu(mpi_request_tm->DevHandle); 3423 if (handle != le16_to_cpu(mpi_reply->DevHandle)) { 3424 dewtprintk(ioc, pr_err(MPT3SAS_FMT 3425 "spurious interrupt: handle(0x%04x:0x%04x), smid(%d)!!!\n", 3426 ioc->name, handle, 3427 le16_to_cpu(mpi_reply->DevHandle), smid)); 3428 return 0; 3429 } 3430 3431 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3432 "tr_complete:handle(0x%04x), (open) smid(%d), ioc_status(0x%04x), " 3433 "loginfo(0x%08x), completed(%d)\n", ioc->name, 3434 handle, smid, le16_to_cpu(mpi_reply->IOCStatus), 3435 le32_to_cpu(mpi_reply->IOCLogInfo), 3436 le32_to_cpu(mpi_reply->TerminationCount))); 3437 3438 return _scsih_check_for_pending_tm(ioc, smid); 3439 } 3440 3441 /** 3442 * _scsih_issue_delayed_event_ack - issue delayed Event ACK messages 3443 * @ioc: per adapter object 3444 * @smid: system request message index 3445 * @event: Event ID 3446 * @event_context: used to track events uniquely 3447 * 3448 * Context - processed in interrupt context. 3449 */ 3450 void 3451 _scsih_issue_delayed_event_ack(struct MPT3SAS_ADAPTER *ioc, u16 smid, u16 event, 3452 u32 event_context) 3453 { 3454 Mpi2EventAckRequest_t *ack_request; 3455 int i = smid - ioc->internal_smid; 3456 unsigned long flags; 3457 3458 /* Without releasing the smid just update the 3459 * call back index and reuse the same smid for 3460 * processing this delayed request 3461 */ 3462 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 3463 ioc->internal_lookup[i].cb_idx = ioc->base_cb_idx; 3464 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 3465 3466 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3467 "EVENT ACK: event(0x%04x), smid(%d), cb(%d)\n", 3468 ioc->name, le16_to_cpu(event), smid, 3469 ioc->base_cb_idx)); 3470 ack_request = mpt3sas_base_get_msg_frame(ioc, smid); 3471 memset(ack_request, 0, sizeof(Mpi2EventAckRequest_t)); 3472 ack_request->Function = MPI2_FUNCTION_EVENT_ACK; 3473 ack_request->Event = event; 3474 ack_request->EventContext = event_context; 3475 ack_request->VF_ID = 0; /* TODO */ 3476 ack_request->VP_ID = 0; 3477 mpt3sas_base_put_smid_default(ioc, smid); 3478 } 3479 3480 /** 3481 * _scsih_issue_delayed_sas_io_unit_ctrl - issue delayed 3482 * sas_io_unit_ctrl messages 3483 * @ioc: per adapter object 3484 * @smid: system request message index 3485 * @handle: device handle 3486 * 3487 * Context - processed in interrupt context. 3488 */ 3489 void 3490 _scsih_issue_delayed_sas_io_unit_ctrl(struct MPT3SAS_ADAPTER *ioc, 3491 u16 smid, u16 handle) 3492 { 3493 Mpi2SasIoUnitControlRequest_t *mpi_request; 3494 u32 ioc_state; 3495 int i = smid - ioc->internal_smid; 3496 unsigned long flags; 3497 3498 if (ioc->remove_host) { 3499 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3500 "%s: host has been removed\n", 3501 __func__, ioc->name)); 3502 return; 3503 } else if (ioc->pci_error_recovery) { 3504 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3505 "%s: host in pci error recovery\n", 3506 __func__, ioc->name)); 3507 return; 3508 } 3509 ioc_state = mpt3sas_base_get_iocstate(ioc, 1); 3510 if (ioc_state != MPI2_IOC_STATE_OPERATIONAL) { 3511 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3512 "%s: host is not operational\n", 3513 __func__, ioc->name)); 3514 return; 3515 } 3516 3517 /* Without releasing the smid just update the 3518 * call back index and reuse the same smid for 3519 * processing this delayed request 3520 */ 3521 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 3522 ioc->internal_lookup[i].cb_idx = ioc->tm_sas_control_cb_idx; 3523 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 3524 3525 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3526 "sc_send:handle(0x%04x), (open), smid(%d), cb(%d)\n", 3527 ioc->name, le16_to_cpu(handle), smid, 3528 ioc->tm_sas_control_cb_idx)); 3529 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 3530 memset(mpi_request, 0, sizeof(Mpi2SasIoUnitControlRequest_t)); 3531 mpi_request->Function = MPI2_FUNCTION_SAS_IO_UNIT_CONTROL; 3532 mpi_request->Operation = MPI2_SAS_OP_REMOVE_DEVICE; 3533 mpi_request->DevHandle = handle; 3534 mpt3sas_base_put_smid_default(ioc, smid); 3535 } 3536 3537 /** 3538 * _scsih_check_for_pending_internal_cmds - check for pending internal messages 3539 * @ioc: per adapter object 3540 * @smid: system request message index 3541 * 3542 * Context: Executed in interrupt context 3543 * 3544 * This will check delayed internal messages list, and process the 3545 * next request. 3546 * 3547 * Return 1 meaning mf should be freed from _base_interrupt 3548 * 0 means the mf is freed from this function. 3549 */ 3550 u8 3551 mpt3sas_check_for_pending_internal_cmds(struct MPT3SAS_ADAPTER *ioc, u16 smid) 3552 { 3553 struct _sc_list *delayed_sc; 3554 struct _event_ack_list *delayed_event_ack; 3555 3556 if (!list_empty(&ioc->delayed_event_ack_list)) { 3557 delayed_event_ack = list_entry(ioc->delayed_event_ack_list.next, 3558 struct _event_ack_list, list); 3559 _scsih_issue_delayed_event_ack(ioc, smid, 3560 delayed_event_ack->Event, delayed_event_ack->EventContext); 3561 list_del(&delayed_event_ack->list); 3562 kfree(delayed_event_ack); 3563 return 0; 3564 } 3565 3566 if (!list_empty(&ioc->delayed_sc_list)) { 3567 delayed_sc = list_entry(ioc->delayed_sc_list.next, 3568 struct _sc_list, list); 3569 _scsih_issue_delayed_sas_io_unit_ctrl(ioc, smid, 3570 delayed_sc->handle); 3571 list_del(&delayed_sc->list); 3572 kfree(delayed_sc); 3573 return 0; 3574 } 3575 return 1; 3576 } 3577 3578 /** 3579 * _scsih_check_for_pending_tm - check for pending task management 3580 * @ioc: per adapter object 3581 * @smid: system request message index 3582 * 3583 * This will check delayed target reset list, and feed the 3584 * next reqeust. 3585 * 3586 * Return 1 meaning mf should be freed from _base_interrupt 3587 * 0 means the mf is freed from this function. 3588 */ 3589 static u8 3590 _scsih_check_for_pending_tm(struct MPT3SAS_ADAPTER *ioc, u16 smid) 3591 { 3592 struct _tr_list *delayed_tr; 3593 3594 if (!list_empty(&ioc->delayed_tr_volume_list)) { 3595 delayed_tr = list_entry(ioc->delayed_tr_volume_list.next, 3596 struct _tr_list, list); 3597 mpt3sas_base_free_smid(ioc, smid); 3598 _scsih_tm_tr_volume_send(ioc, delayed_tr->handle); 3599 list_del(&delayed_tr->list); 3600 kfree(delayed_tr); 3601 return 0; 3602 } 3603 3604 if (!list_empty(&ioc->delayed_tr_list)) { 3605 delayed_tr = list_entry(ioc->delayed_tr_list.next, 3606 struct _tr_list, list); 3607 mpt3sas_base_free_smid(ioc, smid); 3608 _scsih_tm_tr_send(ioc, delayed_tr->handle); 3609 list_del(&delayed_tr->list); 3610 kfree(delayed_tr); 3611 return 0; 3612 } 3613 3614 return 1; 3615 } 3616 3617 /** 3618 * _scsih_check_topo_delete_events - sanity check on topo events 3619 * @ioc: per adapter object 3620 * @event_data: the event data payload 3621 * 3622 * This routine added to better handle cable breaker. 3623 * 3624 * This handles the case where driver receives multiple expander 3625 * add and delete events in a single shot. When there is a delete event 3626 * the routine will void any pending add events waiting in the event queue. 3627 * 3628 * Return nothing. 3629 */ 3630 static void 3631 _scsih_check_topo_delete_events(struct MPT3SAS_ADAPTER *ioc, 3632 Mpi2EventDataSasTopologyChangeList_t *event_data) 3633 { 3634 struct fw_event_work *fw_event; 3635 Mpi2EventDataSasTopologyChangeList_t *local_event_data; 3636 u16 expander_handle; 3637 struct _sas_node *sas_expander; 3638 unsigned long flags; 3639 int i, reason_code; 3640 u16 handle; 3641 3642 for (i = 0 ; i < event_data->NumEntries; i++) { 3643 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 3644 if (!handle) 3645 continue; 3646 reason_code = event_data->PHY[i].PhyStatus & 3647 MPI2_EVENT_SAS_TOPO_RC_MASK; 3648 if (reason_code == MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING) 3649 _scsih_tm_tr_send(ioc, handle); 3650 } 3651 3652 expander_handle = le16_to_cpu(event_data->ExpanderDevHandle); 3653 if (expander_handle < ioc->sas_hba.num_phys) { 3654 _scsih_block_io_to_children_attached_directly(ioc, event_data); 3655 return; 3656 } 3657 if (event_data->ExpStatus == 3658 MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING) { 3659 /* put expander attached devices into blocking state */ 3660 spin_lock_irqsave(&ioc->sas_node_lock, flags); 3661 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc, 3662 expander_handle); 3663 _scsih_block_io_to_children_attached_to_ex(ioc, sas_expander); 3664 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 3665 do { 3666 handle = find_first_bit(ioc->blocking_handles, 3667 ioc->facts.MaxDevHandle); 3668 if (handle < ioc->facts.MaxDevHandle) 3669 _scsih_block_io_device(ioc, handle); 3670 } while (test_and_clear_bit(handle, ioc->blocking_handles)); 3671 } else if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_RESPONDING) 3672 _scsih_block_io_to_children_attached_directly(ioc, event_data); 3673 3674 if (event_data->ExpStatus != MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING) 3675 return; 3676 3677 /* mark ignore flag for pending events */ 3678 spin_lock_irqsave(&ioc->fw_event_lock, flags); 3679 list_for_each_entry(fw_event, &ioc->fw_event_list, list) { 3680 if (fw_event->event != MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST || 3681 fw_event->ignore) 3682 continue; 3683 local_event_data = (Mpi2EventDataSasTopologyChangeList_t *) 3684 fw_event->event_data; 3685 if (local_event_data->ExpStatus == 3686 MPI2_EVENT_SAS_TOPO_ES_ADDED || 3687 local_event_data->ExpStatus == 3688 MPI2_EVENT_SAS_TOPO_ES_RESPONDING) { 3689 if (le16_to_cpu(local_event_data->ExpanderDevHandle) == 3690 expander_handle) { 3691 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3692 "setting ignoring flag\n", ioc->name)); 3693 fw_event->ignore = 1; 3694 } 3695 } 3696 } 3697 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 3698 } 3699 3700 /** 3701 * _scsih_set_volume_delete_flag - setting volume delete flag 3702 * @ioc: per adapter object 3703 * @handle: device handle 3704 * 3705 * This returns nothing. 3706 */ 3707 static void 3708 _scsih_set_volume_delete_flag(struct MPT3SAS_ADAPTER *ioc, u16 handle) 3709 { 3710 struct _raid_device *raid_device; 3711 struct MPT3SAS_TARGET *sas_target_priv_data; 3712 unsigned long flags; 3713 3714 spin_lock_irqsave(&ioc->raid_device_lock, flags); 3715 raid_device = mpt3sas_raid_device_find_by_handle(ioc, handle); 3716 if (raid_device && raid_device->starget && 3717 raid_device->starget->hostdata) { 3718 sas_target_priv_data = 3719 raid_device->starget->hostdata; 3720 sas_target_priv_data->deleted = 1; 3721 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3722 "setting delete flag: handle(0x%04x), " 3723 "wwid(0x%016llx)\n", ioc->name, handle, 3724 (unsigned long long) raid_device->wwid)); 3725 } 3726 spin_unlock_irqrestore(&ioc->raid_device_lock, flags); 3727 } 3728 3729 /** 3730 * _scsih_set_volume_handle_for_tr - set handle for target reset to volume 3731 * @handle: input handle 3732 * @a: handle for volume a 3733 * @b: handle for volume b 3734 * 3735 * IR firmware only supports two raid volumes. The purpose of this 3736 * routine is to set the volume handle in either a or b. When the given 3737 * input handle is non-zero, or when a and b have not been set before. 3738 */ 3739 static void 3740 _scsih_set_volume_handle_for_tr(u16 handle, u16 *a, u16 *b) 3741 { 3742 if (!handle || handle == *a || handle == *b) 3743 return; 3744 if (!*a) 3745 *a = handle; 3746 else if (!*b) 3747 *b = handle; 3748 } 3749 3750 /** 3751 * _scsih_check_ir_config_unhide_events - check for UNHIDE events 3752 * @ioc: per adapter object 3753 * @event_data: the event data payload 3754 * Context: interrupt time. 3755 * 3756 * This routine will send target reset to volume, followed by target 3757 * resets to the PDs. This is called when a PD has been removed, or 3758 * volume has been deleted or removed. When the target reset is sent 3759 * to volume, the PD target resets need to be queued to start upon 3760 * completion of the volume target reset. 3761 * 3762 * Return nothing. 3763 */ 3764 static void 3765 _scsih_check_ir_config_unhide_events(struct MPT3SAS_ADAPTER *ioc, 3766 Mpi2EventDataIrConfigChangeList_t *event_data) 3767 { 3768 Mpi2EventIrConfigElement_t *element; 3769 int i; 3770 u16 handle, volume_handle, a, b; 3771 struct _tr_list *delayed_tr; 3772 3773 a = 0; 3774 b = 0; 3775 3776 if (ioc->is_warpdrive) 3777 return; 3778 3779 /* Volume Resets for Deleted or Removed */ 3780 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 3781 for (i = 0; i < event_data->NumElements; i++, element++) { 3782 if (le32_to_cpu(event_data->Flags) & 3783 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) 3784 continue; 3785 if (element->ReasonCode == 3786 MPI2_EVENT_IR_CHANGE_RC_VOLUME_DELETED || 3787 element->ReasonCode == 3788 MPI2_EVENT_IR_CHANGE_RC_REMOVED) { 3789 volume_handle = le16_to_cpu(element->VolDevHandle); 3790 _scsih_set_volume_delete_flag(ioc, volume_handle); 3791 _scsih_set_volume_handle_for_tr(volume_handle, &a, &b); 3792 } 3793 } 3794 3795 /* Volume Resets for UNHIDE events */ 3796 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 3797 for (i = 0; i < event_data->NumElements; i++, element++) { 3798 if (le32_to_cpu(event_data->Flags) & 3799 MPI2_EVENT_IR_CHANGE_FLAGS_FOREIGN_CONFIG) 3800 continue; 3801 if (element->ReasonCode == MPI2_EVENT_IR_CHANGE_RC_UNHIDE) { 3802 volume_handle = le16_to_cpu(element->VolDevHandle); 3803 _scsih_set_volume_handle_for_tr(volume_handle, &a, &b); 3804 } 3805 } 3806 3807 if (a) 3808 _scsih_tm_tr_volume_send(ioc, a); 3809 if (b) 3810 _scsih_tm_tr_volume_send(ioc, b); 3811 3812 /* PD target resets */ 3813 element = (Mpi2EventIrConfigElement_t *)&event_data->ConfigElement[0]; 3814 for (i = 0; i < event_data->NumElements; i++, element++) { 3815 if (element->ReasonCode != MPI2_EVENT_IR_CHANGE_RC_UNHIDE) 3816 continue; 3817 handle = le16_to_cpu(element->PhysDiskDevHandle); 3818 volume_handle = le16_to_cpu(element->VolDevHandle); 3819 clear_bit(handle, ioc->pd_handles); 3820 if (!volume_handle) 3821 _scsih_tm_tr_send(ioc, handle); 3822 else if (volume_handle == a || volume_handle == b) { 3823 delayed_tr = kzalloc(sizeof(*delayed_tr), GFP_ATOMIC); 3824 BUG_ON(!delayed_tr); 3825 INIT_LIST_HEAD(&delayed_tr->list); 3826 delayed_tr->handle = handle; 3827 list_add_tail(&delayed_tr->list, &ioc->delayed_tr_list); 3828 dewtprintk(ioc, pr_info(MPT3SAS_FMT 3829 "DELAYED:tr:handle(0x%04x), (open)\n", ioc->name, 3830 handle)); 3831 } else 3832 _scsih_tm_tr_send(ioc, handle); 3833 } 3834 } 3835 3836 3837 /** 3838 * _scsih_check_volume_delete_events - set delete flag for volumes 3839 * @ioc: per adapter object 3840 * @event_data: the event data payload 3841 * Context: interrupt time. 3842 * 3843 * This will handle the case when the cable connected to entire volume is 3844 * pulled. We will take care of setting the deleted flag so normal IO will 3845 * not be sent. 3846 * 3847 * Return nothing. 3848 */ 3849 static void 3850 _scsih_check_volume_delete_events(struct MPT3SAS_ADAPTER *ioc, 3851 Mpi2EventDataIrVolume_t *event_data) 3852 { 3853 u32 state; 3854 3855 if (event_data->ReasonCode != MPI2_EVENT_IR_VOLUME_RC_STATE_CHANGED) 3856 return; 3857 state = le32_to_cpu(event_data->NewValue); 3858 if (state == MPI2_RAID_VOL_STATE_MISSING || state == 3859 MPI2_RAID_VOL_STATE_FAILED) 3860 _scsih_set_volume_delete_flag(ioc, 3861 le16_to_cpu(event_data->VolDevHandle)); 3862 } 3863 3864 /** 3865 * _scsih_temp_threshold_events - display temperature threshold exceeded events 3866 * @ioc: per adapter object 3867 * @event_data: the temp threshold event data 3868 * Context: interrupt time. 3869 * 3870 * Return nothing. 3871 */ 3872 static void 3873 _scsih_temp_threshold_events(struct MPT3SAS_ADAPTER *ioc, 3874 Mpi2EventDataTemperature_t *event_data) 3875 { 3876 if (ioc->temp_sensors_count >= event_data->SensorNum) { 3877 pr_err(MPT3SAS_FMT "Temperature Threshold flags %s%s%s%s" 3878 " exceeded for Sensor: %d !!!\n", ioc->name, 3879 ((le16_to_cpu(event_data->Status) & 0x1) == 1) ? "0 " : " ", 3880 ((le16_to_cpu(event_data->Status) & 0x2) == 2) ? "1 " : " ", 3881 ((le16_to_cpu(event_data->Status) & 0x4) == 4) ? "2 " : " ", 3882 ((le16_to_cpu(event_data->Status) & 0x8) == 8) ? "3 " : " ", 3883 event_data->SensorNum); 3884 pr_err(MPT3SAS_FMT "Current Temp In Celsius: %d\n", 3885 ioc->name, event_data->CurrentTemperature); 3886 } 3887 } 3888 3889 /** 3890 * _scsih_flush_running_cmds - completing outstanding commands. 3891 * @ioc: per adapter object 3892 * 3893 * The flushing out of all pending scmd commands following host reset, 3894 * where all IO is dropped to the floor. 3895 * 3896 * Return nothing. 3897 */ 3898 static void 3899 _scsih_flush_running_cmds(struct MPT3SAS_ADAPTER *ioc) 3900 { 3901 struct scsi_cmnd *scmd; 3902 u16 smid; 3903 u16 count = 0; 3904 3905 for (smid = 1; smid <= ioc->scsiio_depth; smid++) { 3906 scmd = _scsih_scsi_lookup_get_clear(ioc, smid); 3907 if (!scmd) 3908 continue; 3909 count++; 3910 mpt3sas_base_free_smid(ioc, smid); 3911 scsi_dma_unmap(scmd); 3912 if (ioc->pci_error_recovery) 3913 scmd->result = DID_NO_CONNECT << 16; 3914 else 3915 scmd->result = DID_RESET << 16; 3916 scmd->scsi_done(scmd); 3917 } 3918 dtmprintk(ioc, pr_info(MPT3SAS_FMT "completing %d cmds\n", 3919 ioc->name, count)); 3920 } 3921 3922 /** 3923 * _scsih_setup_eedp - setup MPI request for EEDP transfer 3924 * @ioc: per adapter object 3925 * @scmd: pointer to scsi command object 3926 * @mpi_request: pointer to the SCSI_IO reqest message frame 3927 * 3928 * Supporting protection 1 and 3. 3929 * 3930 * Returns nothing 3931 */ 3932 static void 3933 _scsih_setup_eedp(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd, 3934 Mpi2SCSIIORequest_t *mpi_request) 3935 { 3936 u16 eedp_flags; 3937 unsigned char prot_op = scsi_get_prot_op(scmd); 3938 unsigned char prot_type = scsi_get_prot_type(scmd); 3939 Mpi25SCSIIORequest_t *mpi_request_3v = 3940 (Mpi25SCSIIORequest_t *)mpi_request; 3941 3942 if (prot_type == SCSI_PROT_DIF_TYPE0 || prot_op == SCSI_PROT_NORMAL) 3943 return; 3944 3945 if (prot_op == SCSI_PROT_READ_STRIP) 3946 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_CHECK_REMOVE_OP; 3947 else if (prot_op == SCSI_PROT_WRITE_INSERT) 3948 eedp_flags = MPI2_SCSIIO_EEDPFLAGS_INSERT_OP; 3949 else 3950 return; 3951 3952 switch (prot_type) { 3953 case SCSI_PROT_DIF_TYPE1: 3954 case SCSI_PROT_DIF_TYPE2: 3955 3956 /* 3957 * enable ref/guard checking 3958 * auto increment ref tag 3959 */ 3960 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_INC_PRI_REFTAG | 3961 MPI2_SCSIIO_EEDPFLAGS_CHECK_REFTAG | 3962 MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD; 3963 mpi_request->CDB.EEDP32.PrimaryReferenceTag = 3964 cpu_to_be32(scsi_get_lba(scmd)); 3965 break; 3966 3967 case SCSI_PROT_DIF_TYPE3: 3968 3969 /* 3970 * enable guard checking 3971 */ 3972 eedp_flags |= MPI2_SCSIIO_EEDPFLAGS_CHECK_GUARD; 3973 3974 break; 3975 } 3976 3977 mpi_request_3v->EEDPBlockSize = 3978 cpu_to_le16(scmd->device->sector_size); 3979 mpi_request->EEDPFlags = cpu_to_le16(eedp_flags); 3980 } 3981 3982 /** 3983 * _scsih_eedp_error_handling - return sense code for EEDP errors 3984 * @scmd: pointer to scsi command object 3985 * @ioc_status: ioc status 3986 * 3987 * Returns nothing 3988 */ 3989 static void 3990 _scsih_eedp_error_handling(struct scsi_cmnd *scmd, u16 ioc_status) 3991 { 3992 u8 ascq; 3993 3994 switch (ioc_status) { 3995 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR: 3996 ascq = 0x01; 3997 break; 3998 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR: 3999 ascq = 0x02; 4000 break; 4001 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR: 4002 ascq = 0x03; 4003 break; 4004 default: 4005 ascq = 0x00; 4006 break; 4007 } 4008 scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 0x10, 4009 ascq); 4010 scmd->result = DRIVER_SENSE << 24 | (DID_ABORT << 16) | 4011 SAM_STAT_CHECK_CONDITION; 4012 } 4013 4014 4015 4016 /** 4017 * scsih_qcmd - main scsi request entry point 4018 * @scmd: pointer to scsi command object 4019 * @done: function pointer to be invoked on completion 4020 * 4021 * The callback index is set inside `ioc->scsi_io_cb_idx`. 4022 * 4023 * Returns 0 on success. If there's a failure, return either: 4024 * SCSI_MLQUEUE_DEVICE_BUSY if the device queue is full, or 4025 * SCSI_MLQUEUE_HOST_BUSY if the entire host queue is full 4026 */ 4027 int 4028 scsih_qcmd(struct Scsi_Host *shost, struct scsi_cmnd *scmd) 4029 { 4030 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 4031 struct MPT3SAS_DEVICE *sas_device_priv_data; 4032 struct MPT3SAS_TARGET *sas_target_priv_data; 4033 struct _raid_device *raid_device; 4034 Mpi2SCSIIORequest_t *mpi_request; 4035 u32 mpi_control; 4036 u16 smid; 4037 u16 handle; 4038 4039 if (ioc->logging_level & MPT_DEBUG_SCSI) 4040 scsi_print_command(scmd); 4041 4042 sas_device_priv_data = scmd->device->hostdata; 4043 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) { 4044 scmd->result = DID_NO_CONNECT << 16; 4045 scmd->scsi_done(scmd); 4046 return 0; 4047 } 4048 4049 if (ioc->pci_error_recovery || ioc->remove_host) { 4050 scmd->result = DID_NO_CONNECT << 16; 4051 scmd->scsi_done(scmd); 4052 return 0; 4053 } 4054 4055 sas_target_priv_data = sas_device_priv_data->sas_target; 4056 4057 /* invalid device handle */ 4058 handle = sas_target_priv_data->handle; 4059 if (handle == MPT3SAS_INVALID_DEVICE_HANDLE) { 4060 scmd->result = DID_NO_CONNECT << 16; 4061 scmd->scsi_done(scmd); 4062 return 0; 4063 } 4064 4065 4066 /* host recovery or link resets sent via IOCTLs */ 4067 if (ioc->shost_recovery || ioc->ioc_link_reset_in_progress) 4068 return SCSI_MLQUEUE_HOST_BUSY; 4069 4070 /* device has been deleted */ 4071 else if (sas_target_priv_data->deleted) { 4072 scmd->result = DID_NO_CONNECT << 16; 4073 scmd->scsi_done(scmd); 4074 return 0; 4075 /* device busy with task managment */ 4076 } else if (sas_target_priv_data->tm_busy || 4077 sas_device_priv_data->block) 4078 return SCSI_MLQUEUE_DEVICE_BUSY; 4079 4080 if (scmd->sc_data_direction == DMA_FROM_DEVICE) 4081 mpi_control = MPI2_SCSIIO_CONTROL_READ; 4082 else if (scmd->sc_data_direction == DMA_TO_DEVICE) 4083 mpi_control = MPI2_SCSIIO_CONTROL_WRITE; 4084 else 4085 mpi_control = MPI2_SCSIIO_CONTROL_NODATATRANSFER; 4086 4087 /* set tags */ 4088 mpi_control |= MPI2_SCSIIO_CONTROL_SIMPLEQ; 4089 4090 /* Make sure Device is not raid volume. 4091 * We do not expose raid functionality to upper layer for warpdrive. 4092 */ 4093 if (!ioc->is_warpdrive && !scsih_is_raid(&scmd->device->sdev_gendev) 4094 && sas_is_tlr_enabled(scmd->device) && scmd->cmd_len != 32) 4095 mpi_control |= MPI2_SCSIIO_CONTROL_TLR_ON; 4096 4097 smid = mpt3sas_base_get_smid_scsiio(ioc, ioc->scsi_io_cb_idx, scmd); 4098 if (!smid) { 4099 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 4100 ioc->name, __func__); 4101 goto out; 4102 } 4103 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 4104 memset(mpi_request, 0, sizeof(Mpi2SCSIIORequest_t)); 4105 _scsih_setup_eedp(ioc, scmd, mpi_request); 4106 4107 if (scmd->cmd_len == 32) 4108 mpi_control |= 4 << MPI2_SCSIIO_CONTROL_ADDCDBLEN_SHIFT; 4109 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST; 4110 if (sas_device_priv_data->sas_target->flags & 4111 MPT_TARGET_FLAGS_RAID_COMPONENT) 4112 mpi_request->Function = MPI2_FUNCTION_RAID_SCSI_IO_PASSTHROUGH; 4113 else 4114 mpi_request->Function = MPI2_FUNCTION_SCSI_IO_REQUEST; 4115 mpi_request->DevHandle = cpu_to_le16(handle); 4116 mpi_request->DataLength = cpu_to_le32(scsi_bufflen(scmd)); 4117 mpi_request->Control = cpu_to_le32(mpi_control); 4118 mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len); 4119 mpi_request->MsgFlags = MPI2_SCSIIO_MSGFLAGS_SYSTEM_SENSE_ADDR; 4120 mpi_request->SenseBufferLength = SCSI_SENSE_BUFFERSIZE; 4121 mpi_request->SenseBufferLowAddress = 4122 mpt3sas_base_get_sense_buffer_dma(ioc, smid); 4123 mpi_request->SGLOffset0 = offsetof(Mpi2SCSIIORequest_t, SGL) / 4; 4124 int_to_scsilun(sas_device_priv_data->lun, (struct scsi_lun *) 4125 mpi_request->LUN); 4126 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len); 4127 4128 if (mpi_request->DataLength) { 4129 if (ioc->build_sg_scmd(ioc, scmd, smid)) { 4130 mpt3sas_base_free_smid(ioc, smid); 4131 goto out; 4132 } 4133 } else 4134 ioc->build_zero_len_sge(ioc, &mpi_request->SGL); 4135 4136 raid_device = sas_target_priv_data->raid_device; 4137 if (raid_device && raid_device->direct_io_enabled) 4138 mpt3sas_setup_direct_io(ioc, scmd, raid_device, mpi_request, 4139 smid); 4140 4141 if (likely(mpi_request->Function == MPI2_FUNCTION_SCSI_IO_REQUEST)) { 4142 if (sas_target_priv_data->flags & MPT_TARGET_FASTPATH_IO) { 4143 mpi_request->IoFlags = cpu_to_le16(scmd->cmd_len | 4144 MPI25_SCSIIO_IOFLAGS_FAST_PATH); 4145 mpt3sas_base_put_smid_fast_path(ioc, smid, handle); 4146 } else 4147 mpt3sas_base_put_smid_scsi_io(ioc, smid, 4148 le16_to_cpu(mpi_request->DevHandle)); 4149 } else 4150 mpt3sas_base_put_smid_default(ioc, smid); 4151 return 0; 4152 4153 out: 4154 return SCSI_MLQUEUE_HOST_BUSY; 4155 } 4156 4157 /** 4158 * _scsih_normalize_sense - normalize descriptor and fixed format sense data 4159 * @sense_buffer: sense data returned by target 4160 * @data: normalized skey/asc/ascq 4161 * 4162 * Return nothing. 4163 */ 4164 static void 4165 _scsih_normalize_sense(char *sense_buffer, struct sense_info *data) 4166 { 4167 if ((sense_buffer[0] & 0x7F) >= 0x72) { 4168 /* descriptor format */ 4169 data->skey = sense_buffer[1] & 0x0F; 4170 data->asc = sense_buffer[2]; 4171 data->ascq = sense_buffer[3]; 4172 } else { 4173 /* fixed format */ 4174 data->skey = sense_buffer[2] & 0x0F; 4175 data->asc = sense_buffer[12]; 4176 data->ascq = sense_buffer[13]; 4177 } 4178 } 4179 4180 /** 4181 * _scsih_scsi_ioc_info - translated non-succesfull SCSI_IO request 4182 * @ioc: per adapter object 4183 * @scmd: pointer to scsi command object 4184 * @mpi_reply: reply mf payload returned from firmware 4185 * 4186 * scsi_status - SCSI Status code returned from target device 4187 * scsi_state - state info associated with SCSI_IO determined by ioc 4188 * ioc_status - ioc supplied status info 4189 * 4190 * Return nothing. 4191 */ 4192 static void 4193 _scsih_scsi_ioc_info(struct MPT3SAS_ADAPTER *ioc, struct scsi_cmnd *scmd, 4194 Mpi2SCSIIOReply_t *mpi_reply, u16 smid) 4195 { 4196 u32 response_info; 4197 u8 *response_bytes; 4198 u16 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) & 4199 MPI2_IOCSTATUS_MASK; 4200 u8 scsi_state = mpi_reply->SCSIState; 4201 u8 scsi_status = mpi_reply->SCSIStatus; 4202 char *desc_ioc_state = NULL; 4203 char *desc_scsi_status = NULL; 4204 char *desc_scsi_state = ioc->tmp_string; 4205 u32 log_info = le32_to_cpu(mpi_reply->IOCLogInfo); 4206 struct _sas_device *sas_device = NULL; 4207 struct scsi_target *starget = scmd->device->sdev_target; 4208 struct MPT3SAS_TARGET *priv_target = starget->hostdata; 4209 char *device_str = NULL; 4210 4211 if (!priv_target) 4212 return; 4213 if (ioc->hide_ir_msg) 4214 device_str = "WarpDrive"; 4215 else 4216 device_str = "volume"; 4217 4218 if (log_info == 0x31170000) 4219 return; 4220 4221 switch (ioc_status) { 4222 case MPI2_IOCSTATUS_SUCCESS: 4223 desc_ioc_state = "success"; 4224 break; 4225 case MPI2_IOCSTATUS_INVALID_FUNCTION: 4226 desc_ioc_state = "invalid function"; 4227 break; 4228 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR: 4229 desc_ioc_state = "scsi recovered error"; 4230 break; 4231 case MPI2_IOCSTATUS_SCSI_INVALID_DEVHANDLE: 4232 desc_ioc_state = "scsi invalid dev handle"; 4233 break; 4234 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE: 4235 desc_ioc_state = "scsi device not there"; 4236 break; 4237 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN: 4238 desc_ioc_state = "scsi data overrun"; 4239 break; 4240 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN: 4241 desc_ioc_state = "scsi data underrun"; 4242 break; 4243 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR: 4244 desc_ioc_state = "scsi io data error"; 4245 break; 4246 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR: 4247 desc_ioc_state = "scsi protocol error"; 4248 break; 4249 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED: 4250 desc_ioc_state = "scsi task terminated"; 4251 break; 4252 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: 4253 desc_ioc_state = "scsi residual mismatch"; 4254 break; 4255 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED: 4256 desc_ioc_state = "scsi task mgmt failed"; 4257 break; 4258 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED: 4259 desc_ioc_state = "scsi ioc terminated"; 4260 break; 4261 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED: 4262 desc_ioc_state = "scsi ext terminated"; 4263 break; 4264 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR: 4265 desc_ioc_state = "eedp guard error"; 4266 break; 4267 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR: 4268 desc_ioc_state = "eedp ref tag error"; 4269 break; 4270 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR: 4271 desc_ioc_state = "eedp app tag error"; 4272 break; 4273 case MPI2_IOCSTATUS_INSUFFICIENT_POWER: 4274 desc_ioc_state = "insufficient power"; 4275 break; 4276 default: 4277 desc_ioc_state = "unknown"; 4278 break; 4279 } 4280 4281 switch (scsi_status) { 4282 case MPI2_SCSI_STATUS_GOOD: 4283 desc_scsi_status = "good"; 4284 break; 4285 case MPI2_SCSI_STATUS_CHECK_CONDITION: 4286 desc_scsi_status = "check condition"; 4287 break; 4288 case MPI2_SCSI_STATUS_CONDITION_MET: 4289 desc_scsi_status = "condition met"; 4290 break; 4291 case MPI2_SCSI_STATUS_BUSY: 4292 desc_scsi_status = "busy"; 4293 break; 4294 case MPI2_SCSI_STATUS_INTERMEDIATE: 4295 desc_scsi_status = "intermediate"; 4296 break; 4297 case MPI2_SCSI_STATUS_INTERMEDIATE_CONDMET: 4298 desc_scsi_status = "intermediate condmet"; 4299 break; 4300 case MPI2_SCSI_STATUS_RESERVATION_CONFLICT: 4301 desc_scsi_status = "reservation conflict"; 4302 break; 4303 case MPI2_SCSI_STATUS_COMMAND_TERMINATED: 4304 desc_scsi_status = "command terminated"; 4305 break; 4306 case MPI2_SCSI_STATUS_TASK_SET_FULL: 4307 desc_scsi_status = "task set full"; 4308 break; 4309 case MPI2_SCSI_STATUS_ACA_ACTIVE: 4310 desc_scsi_status = "aca active"; 4311 break; 4312 case MPI2_SCSI_STATUS_TASK_ABORTED: 4313 desc_scsi_status = "task aborted"; 4314 break; 4315 default: 4316 desc_scsi_status = "unknown"; 4317 break; 4318 } 4319 4320 desc_scsi_state[0] = '\0'; 4321 if (!scsi_state) 4322 desc_scsi_state = " "; 4323 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) 4324 strcat(desc_scsi_state, "response info "); 4325 if (scsi_state & MPI2_SCSI_STATE_TERMINATED) 4326 strcat(desc_scsi_state, "state terminated "); 4327 if (scsi_state & MPI2_SCSI_STATE_NO_SCSI_STATUS) 4328 strcat(desc_scsi_state, "no status "); 4329 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_FAILED) 4330 strcat(desc_scsi_state, "autosense failed "); 4331 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) 4332 strcat(desc_scsi_state, "autosense valid "); 4333 4334 scsi_print_command(scmd); 4335 4336 if (priv_target->flags & MPT_TARGET_FLAGS_VOLUME) { 4337 pr_warn(MPT3SAS_FMT "\t%s wwid(0x%016llx)\n", ioc->name, 4338 device_str, (unsigned long long)priv_target->sas_address); 4339 } else { 4340 sas_device = mpt3sas_get_sdev_from_target(ioc, priv_target); 4341 if (sas_device) { 4342 pr_warn(MPT3SAS_FMT 4343 "\tsas_address(0x%016llx), phy(%d)\n", 4344 ioc->name, (unsigned long long) 4345 sas_device->sas_address, sas_device->phy); 4346 if (sas_device->enclosure_handle != 0) 4347 pr_warn(MPT3SAS_FMT 4348 "\tenclosure_logical_id(0x%016llx)," 4349 "slot(%d)\n", ioc->name, 4350 (unsigned long long) 4351 sas_device->enclosure_logical_id, 4352 sas_device->slot); 4353 if (sas_device->connector_name[0]) 4354 pr_warn(MPT3SAS_FMT 4355 "\tenclosure level(0x%04x)," 4356 " connector name( %s)\n", ioc->name, 4357 sas_device->enclosure_level, 4358 sas_device->connector_name); 4359 4360 sas_device_put(sas_device); 4361 } 4362 } 4363 4364 pr_warn(MPT3SAS_FMT 4365 "\thandle(0x%04x), ioc_status(%s)(0x%04x), smid(%d)\n", 4366 ioc->name, le16_to_cpu(mpi_reply->DevHandle), 4367 desc_ioc_state, ioc_status, smid); 4368 pr_warn(MPT3SAS_FMT 4369 "\trequest_len(%d), underflow(%d), resid(%d)\n", 4370 ioc->name, scsi_bufflen(scmd), scmd->underflow, 4371 scsi_get_resid(scmd)); 4372 pr_warn(MPT3SAS_FMT 4373 "\ttag(%d), transfer_count(%d), sc->result(0x%08x)\n", 4374 ioc->name, le16_to_cpu(mpi_reply->TaskTag), 4375 le32_to_cpu(mpi_reply->TransferCount), scmd->result); 4376 pr_warn(MPT3SAS_FMT 4377 "\tscsi_status(%s)(0x%02x), scsi_state(%s)(0x%02x)\n", 4378 ioc->name, desc_scsi_status, 4379 scsi_status, desc_scsi_state, scsi_state); 4380 4381 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) { 4382 struct sense_info data; 4383 _scsih_normalize_sense(scmd->sense_buffer, &data); 4384 pr_warn(MPT3SAS_FMT 4385 "\t[sense_key,asc,ascq]: [0x%02x,0x%02x,0x%02x], count(%d)\n", 4386 ioc->name, data.skey, 4387 data.asc, data.ascq, le32_to_cpu(mpi_reply->SenseCount)); 4388 } 4389 4390 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) { 4391 response_info = le32_to_cpu(mpi_reply->ResponseInfo); 4392 response_bytes = (u8 *)&response_info; 4393 _scsih_response_code(ioc, response_bytes[0]); 4394 } 4395 } 4396 4397 /** 4398 * _scsih_turn_on_pfa_led - illuminate PFA LED 4399 * @ioc: per adapter object 4400 * @handle: device handle 4401 * Context: process 4402 * 4403 * Return nothing. 4404 */ 4405 static void 4406 _scsih_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle) 4407 { 4408 Mpi2SepReply_t mpi_reply; 4409 Mpi2SepRequest_t mpi_request; 4410 struct _sas_device *sas_device; 4411 4412 sas_device = mpt3sas_get_sdev_by_handle(ioc, handle); 4413 if (!sas_device) 4414 return; 4415 4416 memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t)); 4417 mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR; 4418 mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS; 4419 mpi_request.SlotStatus = 4420 cpu_to_le32(MPI2_SEP_REQ_SLOTSTATUS_PREDICTED_FAULT); 4421 mpi_request.DevHandle = cpu_to_le16(handle); 4422 mpi_request.Flags = MPI2_SEP_REQ_FLAGS_DEVHANDLE_ADDRESS; 4423 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply, 4424 &mpi_request)) != 0) { 4425 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name, 4426 __FILE__, __LINE__, __func__); 4427 goto out; 4428 } 4429 sas_device->pfa_led_on = 1; 4430 4431 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) { 4432 dewtprintk(ioc, pr_info(MPT3SAS_FMT 4433 "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n", 4434 ioc->name, le16_to_cpu(mpi_reply.IOCStatus), 4435 le32_to_cpu(mpi_reply.IOCLogInfo))); 4436 goto out; 4437 } 4438 out: 4439 sas_device_put(sas_device); 4440 } 4441 4442 /** 4443 * _scsih_turn_off_pfa_led - turn off Fault LED 4444 * @ioc: per adapter object 4445 * @sas_device: sas device whose PFA LED has to turned off 4446 * Context: process 4447 * 4448 * Return nothing. 4449 */ 4450 static void 4451 _scsih_turn_off_pfa_led(struct MPT3SAS_ADAPTER *ioc, 4452 struct _sas_device *sas_device) 4453 { 4454 Mpi2SepReply_t mpi_reply; 4455 Mpi2SepRequest_t mpi_request; 4456 4457 memset(&mpi_request, 0, sizeof(Mpi2SepRequest_t)); 4458 mpi_request.Function = MPI2_FUNCTION_SCSI_ENCLOSURE_PROCESSOR; 4459 mpi_request.Action = MPI2_SEP_REQ_ACTION_WRITE_STATUS; 4460 mpi_request.SlotStatus = 0; 4461 mpi_request.Slot = cpu_to_le16(sas_device->slot); 4462 mpi_request.DevHandle = 0; 4463 mpi_request.EnclosureHandle = cpu_to_le16(sas_device->enclosure_handle); 4464 mpi_request.Flags = MPI2_SEP_REQ_FLAGS_ENCLOSURE_SLOT_ADDRESS; 4465 if ((mpt3sas_base_scsi_enclosure_processor(ioc, &mpi_reply, 4466 &mpi_request)) != 0) { 4467 printk(MPT3SAS_FMT "failure at %s:%d/%s()!\n", ioc->name, 4468 __FILE__, __LINE__, __func__); 4469 return; 4470 } 4471 4472 if (mpi_reply.IOCStatus || mpi_reply.IOCLogInfo) { 4473 dewtprintk(ioc, printk(MPT3SAS_FMT 4474 "enclosure_processor: ioc_status (0x%04x), loginfo(0x%08x)\n", 4475 ioc->name, le16_to_cpu(mpi_reply.IOCStatus), 4476 le32_to_cpu(mpi_reply.IOCLogInfo))); 4477 return; 4478 } 4479 } 4480 4481 /** 4482 * _scsih_send_event_to_turn_on_pfa_led - fire delayed event 4483 * @ioc: per adapter object 4484 * @handle: device handle 4485 * Context: interrupt. 4486 * 4487 * Return nothing. 4488 */ 4489 static void 4490 _scsih_send_event_to_turn_on_pfa_led(struct MPT3SAS_ADAPTER *ioc, u16 handle) 4491 { 4492 struct fw_event_work *fw_event; 4493 4494 fw_event = alloc_fw_event_work(0); 4495 if (!fw_event) 4496 return; 4497 fw_event->event = MPT3SAS_TURN_ON_PFA_LED; 4498 fw_event->device_handle = handle; 4499 fw_event->ioc = ioc; 4500 _scsih_fw_event_add(ioc, fw_event); 4501 fw_event_work_put(fw_event); 4502 } 4503 4504 /** 4505 * _scsih_smart_predicted_fault - process smart errors 4506 * @ioc: per adapter object 4507 * @handle: device handle 4508 * Context: interrupt. 4509 * 4510 * Return nothing. 4511 */ 4512 static void 4513 _scsih_smart_predicted_fault(struct MPT3SAS_ADAPTER *ioc, u16 handle) 4514 { 4515 struct scsi_target *starget; 4516 struct MPT3SAS_TARGET *sas_target_priv_data; 4517 Mpi2EventNotificationReply_t *event_reply; 4518 Mpi2EventDataSasDeviceStatusChange_t *event_data; 4519 struct _sas_device *sas_device; 4520 ssize_t sz; 4521 unsigned long flags; 4522 4523 /* only handle non-raid devices */ 4524 spin_lock_irqsave(&ioc->sas_device_lock, flags); 4525 sas_device = __mpt3sas_get_sdev_by_handle(ioc, handle); 4526 if (!sas_device) 4527 goto out_unlock; 4528 4529 starget = sas_device->starget; 4530 sas_target_priv_data = starget->hostdata; 4531 4532 if ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_RAID_COMPONENT) || 4533 ((sas_target_priv_data->flags & MPT_TARGET_FLAGS_VOLUME))) 4534 goto out_unlock; 4535 4536 if (sas_device->enclosure_handle != 0) 4537 starget_printk(KERN_INFO, starget, "predicted fault, " 4538 "enclosure logical id(0x%016llx), slot(%d)\n", 4539 (unsigned long long)sas_device->enclosure_logical_id, 4540 sas_device->slot); 4541 if (sas_device->connector_name[0] != '\0') 4542 starget_printk(KERN_WARNING, starget, "predicted fault, " 4543 "enclosure level(0x%04x), connector name( %s)\n", 4544 sas_device->enclosure_level, 4545 sas_device->connector_name); 4546 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 4547 4548 if (ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) 4549 _scsih_send_event_to_turn_on_pfa_led(ioc, handle); 4550 4551 /* insert into event log */ 4552 sz = offsetof(Mpi2EventNotificationReply_t, EventData) + 4553 sizeof(Mpi2EventDataSasDeviceStatusChange_t); 4554 event_reply = kzalloc(sz, GFP_KERNEL); 4555 if (!event_reply) { 4556 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4557 ioc->name, __FILE__, __LINE__, __func__); 4558 goto out; 4559 } 4560 4561 event_reply->Function = MPI2_FUNCTION_EVENT_NOTIFICATION; 4562 event_reply->Event = 4563 cpu_to_le16(MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE); 4564 event_reply->MsgLength = sz/4; 4565 event_reply->EventDataLength = 4566 cpu_to_le16(sizeof(Mpi2EventDataSasDeviceStatusChange_t)/4); 4567 event_data = (Mpi2EventDataSasDeviceStatusChange_t *) 4568 event_reply->EventData; 4569 event_data->ReasonCode = MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA; 4570 event_data->ASC = 0x5D; 4571 event_data->DevHandle = cpu_to_le16(handle); 4572 event_data->SASAddress = cpu_to_le64(sas_target_priv_data->sas_address); 4573 mpt3sas_ctl_add_to_event_log(ioc, event_reply); 4574 kfree(event_reply); 4575 out: 4576 if (sas_device) 4577 sas_device_put(sas_device); 4578 return; 4579 4580 out_unlock: 4581 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 4582 goto out; 4583 } 4584 4585 /** 4586 * _scsih_io_done - scsi request callback 4587 * @ioc: per adapter object 4588 * @smid: system request message index 4589 * @msix_index: MSIX table index supplied by the OS 4590 * @reply: reply message frame(lower 32bit addr) 4591 * 4592 * Callback handler when using _scsih_qcmd. 4593 * 4594 * Return 1 meaning mf should be freed from _base_interrupt 4595 * 0 means the mf is freed from this function. 4596 */ 4597 static u8 4598 _scsih_io_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply) 4599 { 4600 Mpi2SCSIIORequest_t *mpi_request; 4601 Mpi2SCSIIOReply_t *mpi_reply; 4602 struct scsi_cmnd *scmd; 4603 u16 ioc_status; 4604 u32 xfer_cnt; 4605 u8 scsi_state; 4606 u8 scsi_status; 4607 u32 log_info; 4608 struct MPT3SAS_DEVICE *sas_device_priv_data; 4609 u32 response_code = 0; 4610 unsigned long flags; 4611 4612 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 4613 scmd = _scsih_scsi_lookup_get_clear(ioc, smid); 4614 if (scmd == NULL) 4615 return 1; 4616 4617 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 4618 4619 if (mpi_reply == NULL) { 4620 scmd->result = DID_OK << 16; 4621 goto out; 4622 } 4623 4624 sas_device_priv_data = scmd->device->hostdata; 4625 if (!sas_device_priv_data || !sas_device_priv_data->sas_target || 4626 sas_device_priv_data->sas_target->deleted) { 4627 scmd->result = DID_NO_CONNECT << 16; 4628 goto out; 4629 } 4630 ioc_status = le16_to_cpu(mpi_reply->IOCStatus); 4631 4632 /* 4633 * WARPDRIVE: If direct_io is set then it is directIO, 4634 * the failed direct I/O should be redirected to volume 4635 */ 4636 if (mpt3sas_scsi_direct_io_get(ioc, smid) && 4637 ((ioc_status & MPI2_IOCSTATUS_MASK) 4638 != MPI2_IOCSTATUS_SCSI_TASK_TERMINATED)) { 4639 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 4640 ioc->scsi_lookup[smid - 1].scmd = scmd; 4641 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 4642 mpt3sas_scsi_direct_io_set(ioc, smid, 0); 4643 memcpy(mpi_request->CDB.CDB32, scmd->cmnd, scmd->cmd_len); 4644 mpi_request->DevHandle = 4645 cpu_to_le16(sas_device_priv_data->sas_target->handle); 4646 mpt3sas_base_put_smid_scsi_io(ioc, smid, 4647 sas_device_priv_data->sas_target->handle); 4648 return 0; 4649 } 4650 /* turning off TLR */ 4651 scsi_state = mpi_reply->SCSIState; 4652 if (scsi_state & MPI2_SCSI_STATE_RESPONSE_INFO_VALID) 4653 response_code = 4654 le32_to_cpu(mpi_reply->ResponseInfo) & 0xFF; 4655 if (!sas_device_priv_data->tlr_snoop_check) { 4656 sas_device_priv_data->tlr_snoop_check++; 4657 if (!ioc->is_warpdrive && 4658 !scsih_is_raid(&scmd->device->sdev_gendev) && 4659 sas_is_tlr_enabled(scmd->device) && 4660 response_code == MPI2_SCSITASKMGMT_RSP_INVALID_FRAME) { 4661 sas_disable_tlr(scmd->device); 4662 sdev_printk(KERN_INFO, scmd->device, "TLR disabled\n"); 4663 } 4664 } 4665 4666 xfer_cnt = le32_to_cpu(mpi_reply->TransferCount); 4667 scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_cnt); 4668 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) 4669 log_info = le32_to_cpu(mpi_reply->IOCLogInfo); 4670 else 4671 log_info = 0; 4672 ioc_status &= MPI2_IOCSTATUS_MASK; 4673 scsi_status = mpi_reply->SCSIStatus; 4674 4675 if (ioc_status == MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN && xfer_cnt == 0 && 4676 (scsi_status == MPI2_SCSI_STATUS_BUSY || 4677 scsi_status == MPI2_SCSI_STATUS_RESERVATION_CONFLICT || 4678 scsi_status == MPI2_SCSI_STATUS_TASK_SET_FULL)) { 4679 ioc_status = MPI2_IOCSTATUS_SUCCESS; 4680 } 4681 4682 if (scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID) { 4683 struct sense_info data; 4684 const void *sense_data = mpt3sas_base_get_sense_buffer(ioc, 4685 smid); 4686 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE, 4687 le32_to_cpu(mpi_reply->SenseCount)); 4688 memcpy(scmd->sense_buffer, sense_data, sz); 4689 _scsih_normalize_sense(scmd->sense_buffer, &data); 4690 /* failure prediction threshold exceeded */ 4691 if (data.asc == 0x5D) 4692 _scsih_smart_predicted_fault(ioc, 4693 le16_to_cpu(mpi_reply->DevHandle)); 4694 mpt3sas_trigger_scsi(ioc, data.skey, data.asc, data.ascq); 4695 4696 if (!(ioc->logging_level & MPT_DEBUG_REPLY) && 4697 ((scmd->sense_buffer[2] == UNIT_ATTENTION) || 4698 (scmd->sense_buffer[2] == MEDIUM_ERROR) || 4699 (scmd->sense_buffer[2] == HARDWARE_ERROR))) 4700 _scsih_scsi_ioc_info(ioc, scmd, mpi_reply, smid); 4701 } 4702 switch (ioc_status) { 4703 case MPI2_IOCSTATUS_BUSY: 4704 case MPI2_IOCSTATUS_INSUFFICIENT_RESOURCES: 4705 scmd->result = SAM_STAT_BUSY; 4706 break; 4707 4708 case MPI2_IOCSTATUS_SCSI_DEVICE_NOT_THERE: 4709 scmd->result = DID_NO_CONNECT << 16; 4710 break; 4711 4712 case MPI2_IOCSTATUS_SCSI_IOC_TERMINATED: 4713 if (sas_device_priv_data->block) { 4714 scmd->result = DID_TRANSPORT_DISRUPTED << 16; 4715 goto out; 4716 } 4717 if (log_info == 0x31110630) { 4718 if (scmd->retries > 2) { 4719 scmd->result = DID_NO_CONNECT << 16; 4720 scsi_device_set_state(scmd->device, 4721 SDEV_OFFLINE); 4722 } else { 4723 scmd->result = DID_SOFT_ERROR << 16; 4724 scmd->device->expecting_cc_ua = 1; 4725 } 4726 break; 4727 } else if (log_info == VIRTUAL_IO_FAILED_RETRY) { 4728 scmd->result = DID_RESET << 16; 4729 break; 4730 } 4731 scmd->result = DID_SOFT_ERROR << 16; 4732 break; 4733 case MPI2_IOCSTATUS_SCSI_TASK_TERMINATED: 4734 case MPI2_IOCSTATUS_SCSI_EXT_TERMINATED: 4735 scmd->result = DID_RESET << 16; 4736 break; 4737 4738 case MPI2_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: 4739 if ((xfer_cnt == 0) || (scmd->underflow > xfer_cnt)) 4740 scmd->result = DID_SOFT_ERROR << 16; 4741 else 4742 scmd->result = (DID_OK << 16) | scsi_status; 4743 break; 4744 4745 case MPI2_IOCSTATUS_SCSI_DATA_UNDERRUN: 4746 scmd->result = (DID_OK << 16) | scsi_status; 4747 4748 if ((scsi_state & MPI2_SCSI_STATE_AUTOSENSE_VALID)) 4749 break; 4750 4751 if (xfer_cnt < scmd->underflow) { 4752 if (scsi_status == SAM_STAT_BUSY) 4753 scmd->result = SAM_STAT_BUSY; 4754 else 4755 scmd->result = DID_SOFT_ERROR << 16; 4756 } else if (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED | 4757 MPI2_SCSI_STATE_NO_SCSI_STATUS)) 4758 scmd->result = DID_SOFT_ERROR << 16; 4759 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED) 4760 scmd->result = DID_RESET << 16; 4761 else if (!xfer_cnt && scmd->cmnd[0] == REPORT_LUNS) { 4762 mpi_reply->SCSIState = MPI2_SCSI_STATE_AUTOSENSE_VALID; 4763 mpi_reply->SCSIStatus = SAM_STAT_CHECK_CONDITION; 4764 scmd->result = (DRIVER_SENSE << 24) | 4765 SAM_STAT_CHECK_CONDITION; 4766 scmd->sense_buffer[0] = 0x70; 4767 scmd->sense_buffer[2] = ILLEGAL_REQUEST; 4768 scmd->sense_buffer[12] = 0x20; 4769 scmd->sense_buffer[13] = 0; 4770 } 4771 break; 4772 4773 case MPI2_IOCSTATUS_SCSI_DATA_OVERRUN: 4774 scsi_set_resid(scmd, 0); 4775 case MPI2_IOCSTATUS_SCSI_RECOVERED_ERROR: 4776 case MPI2_IOCSTATUS_SUCCESS: 4777 scmd->result = (DID_OK << 16) | scsi_status; 4778 if (response_code == 4779 MPI2_SCSITASKMGMT_RSP_INVALID_FRAME || 4780 (scsi_state & (MPI2_SCSI_STATE_AUTOSENSE_FAILED | 4781 MPI2_SCSI_STATE_NO_SCSI_STATUS))) 4782 scmd->result = DID_SOFT_ERROR << 16; 4783 else if (scsi_state & MPI2_SCSI_STATE_TERMINATED) 4784 scmd->result = DID_RESET << 16; 4785 break; 4786 4787 case MPI2_IOCSTATUS_EEDP_GUARD_ERROR: 4788 case MPI2_IOCSTATUS_EEDP_REF_TAG_ERROR: 4789 case MPI2_IOCSTATUS_EEDP_APP_TAG_ERROR: 4790 _scsih_eedp_error_handling(scmd, ioc_status); 4791 break; 4792 4793 case MPI2_IOCSTATUS_SCSI_PROTOCOL_ERROR: 4794 case MPI2_IOCSTATUS_INVALID_FUNCTION: 4795 case MPI2_IOCSTATUS_INVALID_SGL: 4796 case MPI2_IOCSTATUS_INTERNAL_ERROR: 4797 case MPI2_IOCSTATUS_INVALID_FIELD: 4798 case MPI2_IOCSTATUS_INVALID_STATE: 4799 case MPI2_IOCSTATUS_SCSI_IO_DATA_ERROR: 4800 case MPI2_IOCSTATUS_SCSI_TASK_MGMT_FAILED: 4801 case MPI2_IOCSTATUS_INSUFFICIENT_POWER: 4802 default: 4803 scmd->result = DID_SOFT_ERROR << 16; 4804 break; 4805 4806 } 4807 4808 if (scmd->result && (ioc->logging_level & MPT_DEBUG_REPLY)) 4809 _scsih_scsi_ioc_info(ioc , scmd, mpi_reply, smid); 4810 4811 out: 4812 4813 scsi_dma_unmap(scmd); 4814 4815 scmd->scsi_done(scmd); 4816 return 1; 4817 } 4818 4819 /** 4820 * _scsih_sas_host_refresh - refreshing sas host object contents 4821 * @ioc: per adapter object 4822 * Context: user 4823 * 4824 * During port enable, fw will send topology events for every device. Its 4825 * possible that the handles may change from the previous setting, so this 4826 * code keeping handles updating if changed. 4827 * 4828 * Return nothing. 4829 */ 4830 static void 4831 _scsih_sas_host_refresh(struct MPT3SAS_ADAPTER *ioc) 4832 { 4833 u16 sz; 4834 u16 ioc_status; 4835 int i; 4836 Mpi2ConfigReply_t mpi_reply; 4837 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 4838 u16 attached_handle; 4839 u8 link_rate; 4840 4841 dtmprintk(ioc, pr_info(MPT3SAS_FMT 4842 "updating handles for sas_host(0x%016llx)\n", 4843 ioc->name, (unsigned long long)ioc->sas_hba.sas_address)); 4844 4845 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys 4846 * sizeof(Mpi2SasIOUnit0PhyData_t)); 4847 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 4848 if (!sas_iounit_pg0) { 4849 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4850 ioc->name, __FILE__, __LINE__, __func__); 4851 return; 4852 } 4853 4854 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 4855 sas_iounit_pg0, sz)) != 0) 4856 goto out; 4857 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 4858 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 4859 goto out; 4860 for (i = 0; i < ioc->sas_hba.num_phys ; i++) { 4861 link_rate = sas_iounit_pg0->PhyData[i].NegotiatedLinkRate >> 4; 4862 if (i == 0) 4863 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0-> 4864 PhyData[0].ControllerDevHandle); 4865 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle; 4866 attached_handle = le16_to_cpu(sas_iounit_pg0->PhyData[i]. 4867 AttachedDevHandle); 4868 if (attached_handle && link_rate < MPI2_SAS_NEG_LINK_RATE_1_5) 4869 link_rate = MPI2_SAS_NEG_LINK_RATE_1_5; 4870 mpt3sas_transport_update_links(ioc, ioc->sas_hba.sas_address, 4871 attached_handle, i, link_rate); 4872 } 4873 out: 4874 kfree(sas_iounit_pg0); 4875 } 4876 4877 /** 4878 * _scsih_sas_host_add - create sas host object 4879 * @ioc: per adapter object 4880 * 4881 * Creating host side data object, stored in ioc->sas_hba 4882 * 4883 * Return nothing. 4884 */ 4885 static void 4886 _scsih_sas_host_add(struct MPT3SAS_ADAPTER *ioc) 4887 { 4888 int i; 4889 Mpi2ConfigReply_t mpi_reply; 4890 Mpi2SasIOUnitPage0_t *sas_iounit_pg0 = NULL; 4891 Mpi2SasIOUnitPage1_t *sas_iounit_pg1 = NULL; 4892 Mpi2SasPhyPage0_t phy_pg0; 4893 Mpi2SasDevicePage0_t sas_device_pg0; 4894 Mpi2SasEnclosurePage0_t enclosure_pg0; 4895 u16 ioc_status; 4896 u16 sz; 4897 u8 device_missing_delay; 4898 4899 mpt3sas_config_get_number_hba_phys(ioc, &ioc->sas_hba.num_phys); 4900 if (!ioc->sas_hba.num_phys) { 4901 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4902 ioc->name, __FILE__, __LINE__, __func__); 4903 return; 4904 } 4905 4906 /* sas_iounit page 0 */ 4907 sz = offsetof(Mpi2SasIOUnitPage0_t, PhyData) + (ioc->sas_hba.num_phys * 4908 sizeof(Mpi2SasIOUnit0PhyData_t)); 4909 sas_iounit_pg0 = kzalloc(sz, GFP_KERNEL); 4910 if (!sas_iounit_pg0) { 4911 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4912 ioc->name, __FILE__, __LINE__, __func__); 4913 return; 4914 } 4915 if ((mpt3sas_config_get_sas_iounit_pg0(ioc, &mpi_reply, 4916 sas_iounit_pg0, sz))) { 4917 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4918 ioc->name, __FILE__, __LINE__, __func__); 4919 goto out; 4920 } 4921 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 4922 MPI2_IOCSTATUS_MASK; 4923 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 4924 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4925 ioc->name, __FILE__, __LINE__, __func__); 4926 goto out; 4927 } 4928 4929 /* sas_iounit page 1 */ 4930 sz = offsetof(Mpi2SasIOUnitPage1_t, PhyData) + (ioc->sas_hba.num_phys * 4931 sizeof(Mpi2SasIOUnit1PhyData_t)); 4932 sas_iounit_pg1 = kzalloc(sz, GFP_KERNEL); 4933 if (!sas_iounit_pg1) { 4934 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4935 ioc->name, __FILE__, __LINE__, __func__); 4936 goto out; 4937 } 4938 if ((mpt3sas_config_get_sas_iounit_pg1(ioc, &mpi_reply, 4939 sas_iounit_pg1, sz))) { 4940 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4941 ioc->name, __FILE__, __LINE__, __func__); 4942 goto out; 4943 } 4944 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 4945 MPI2_IOCSTATUS_MASK; 4946 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 4947 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4948 ioc->name, __FILE__, __LINE__, __func__); 4949 goto out; 4950 } 4951 4952 ioc->io_missing_delay = 4953 sas_iounit_pg1->IODeviceMissingDelay; 4954 device_missing_delay = 4955 sas_iounit_pg1->ReportDeviceMissingDelay; 4956 if (device_missing_delay & MPI2_SASIOUNIT1_REPORT_MISSING_UNIT_16) 4957 ioc->device_missing_delay = (device_missing_delay & 4958 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK) * 16; 4959 else 4960 ioc->device_missing_delay = device_missing_delay & 4961 MPI2_SASIOUNIT1_REPORT_MISSING_TIMEOUT_MASK; 4962 4963 ioc->sas_hba.parent_dev = &ioc->shost->shost_gendev; 4964 ioc->sas_hba.phy = kcalloc(ioc->sas_hba.num_phys, 4965 sizeof(struct _sas_phy), GFP_KERNEL); 4966 if (!ioc->sas_hba.phy) { 4967 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4968 ioc->name, __FILE__, __LINE__, __func__); 4969 goto out; 4970 } 4971 for (i = 0; i < ioc->sas_hba.num_phys ; i++) { 4972 if ((mpt3sas_config_get_phy_pg0(ioc, &mpi_reply, &phy_pg0, 4973 i))) { 4974 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4975 ioc->name, __FILE__, __LINE__, __func__); 4976 goto out; 4977 } 4978 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 4979 MPI2_IOCSTATUS_MASK; 4980 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 4981 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4982 ioc->name, __FILE__, __LINE__, __func__); 4983 goto out; 4984 } 4985 4986 if (i == 0) 4987 ioc->sas_hba.handle = le16_to_cpu(sas_iounit_pg0-> 4988 PhyData[0].ControllerDevHandle); 4989 ioc->sas_hba.phy[i].handle = ioc->sas_hba.handle; 4990 ioc->sas_hba.phy[i].phy_id = i; 4991 mpt3sas_transport_add_host_phy(ioc, &ioc->sas_hba.phy[i], 4992 phy_pg0, ioc->sas_hba.parent_dev); 4993 } 4994 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 4995 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, ioc->sas_hba.handle))) { 4996 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 4997 ioc->name, __FILE__, __LINE__, __func__); 4998 goto out; 4999 } 5000 ioc->sas_hba.enclosure_handle = 5001 le16_to_cpu(sas_device_pg0.EnclosureHandle); 5002 ioc->sas_hba.sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 5003 pr_info(MPT3SAS_FMT 5004 "host_add: handle(0x%04x), sas_addr(0x%016llx), phys(%d)\n", 5005 ioc->name, ioc->sas_hba.handle, 5006 (unsigned long long) ioc->sas_hba.sas_address, 5007 ioc->sas_hba.num_phys) ; 5008 5009 if (ioc->sas_hba.enclosure_handle) { 5010 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply, 5011 &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE, 5012 ioc->sas_hba.enclosure_handle))) 5013 ioc->sas_hba.enclosure_logical_id = 5014 le64_to_cpu(enclosure_pg0.EnclosureLogicalID); 5015 } 5016 5017 out: 5018 kfree(sas_iounit_pg1); 5019 kfree(sas_iounit_pg0); 5020 } 5021 5022 /** 5023 * _scsih_expander_add - creating expander object 5024 * @ioc: per adapter object 5025 * @handle: expander handle 5026 * 5027 * Creating expander object, stored in ioc->sas_expander_list. 5028 * 5029 * Return 0 for success, else error. 5030 */ 5031 static int 5032 _scsih_expander_add(struct MPT3SAS_ADAPTER *ioc, u16 handle) 5033 { 5034 struct _sas_node *sas_expander; 5035 Mpi2ConfigReply_t mpi_reply; 5036 Mpi2ExpanderPage0_t expander_pg0; 5037 Mpi2ExpanderPage1_t expander_pg1; 5038 Mpi2SasEnclosurePage0_t enclosure_pg0; 5039 u32 ioc_status; 5040 u16 parent_handle; 5041 u64 sas_address, sas_address_parent = 0; 5042 int i; 5043 unsigned long flags; 5044 struct _sas_port *mpt3sas_port = NULL; 5045 5046 int rc = 0; 5047 5048 if (!handle) 5049 return -1; 5050 5051 if (ioc->shost_recovery || ioc->pci_error_recovery) 5052 return -1; 5053 5054 if ((mpt3sas_config_get_expander_pg0(ioc, &mpi_reply, &expander_pg0, 5055 MPI2_SAS_EXPAND_PGAD_FORM_HNDL, handle))) { 5056 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5057 ioc->name, __FILE__, __LINE__, __func__); 5058 return -1; 5059 } 5060 5061 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 5062 MPI2_IOCSTATUS_MASK; 5063 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 5064 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5065 ioc->name, __FILE__, __LINE__, __func__); 5066 return -1; 5067 } 5068 5069 /* handle out of order topology events */ 5070 parent_handle = le16_to_cpu(expander_pg0.ParentDevHandle); 5071 if (_scsih_get_sas_address(ioc, parent_handle, &sas_address_parent) 5072 != 0) { 5073 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5074 ioc->name, __FILE__, __LINE__, __func__); 5075 return -1; 5076 } 5077 if (sas_address_parent != ioc->sas_hba.sas_address) { 5078 spin_lock_irqsave(&ioc->sas_node_lock, flags); 5079 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 5080 sas_address_parent); 5081 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 5082 if (!sas_expander) { 5083 rc = _scsih_expander_add(ioc, parent_handle); 5084 if (rc != 0) 5085 return rc; 5086 } 5087 } 5088 5089 spin_lock_irqsave(&ioc->sas_node_lock, flags); 5090 sas_address = le64_to_cpu(expander_pg0.SASAddress); 5091 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 5092 sas_address); 5093 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 5094 5095 if (sas_expander) 5096 return 0; 5097 5098 sas_expander = kzalloc(sizeof(struct _sas_node), 5099 GFP_KERNEL); 5100 if (!sas_expander) { 5101 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5102 ioc->name, __FILE__, __LINE__, __func__); 5103 return -1; 5104 } 5105 5106 sas_expander->handle = handle; 5107 sas_expander->num_phys = expander_pg0.NumPhys; 5108 sas_expander->sas_address_parent = sas_address_parent; 5109 sas_expander->sas_address = sas_address; 5110 5111 pr_info(MPT3SAS_FMT "expander_add: handle(0x%04x)," \ 5112 " parent(0x%04x), sas_addr(0x%016llx), phys(%d)\n", ioc->name, 5113 handle, parent_handle, (unsigned long long) 5114 sas_expander->sas_address, sas_expander->num_phys); 5115 5116 if (!sas_expander->num_phys) 5117 goto out_fail; 5118 sas_expander->phy = kcalloc(sas_expander->num_phys, 5119 sizeof(struct _sas_phy), GFP_KERNEL); 5120 if (!sas_expander->phy) { 5121 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5122 ioc->name, __FILE__, __LINE__, __func__); 5123 rc = -1; 5124 goto out_fail; 5125 } 5126 5127 INIT_LIST_HEAD(&sas_expander->sas_port_list); 5128 mpt3sas_port = mpt3sas_transport_port_add(ioc, handle, 5129 sas_address_parent); 5130 if (!mpt3sas_port) { 5131 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5132 ioc->name, __FILE__, __LINE__, __func__); 5133 rc = -1; 5134 goto out_fail; 5135 } 5136 sas_expander->parent_dev = &mpt3sas_port->rphy->dev; 5137 5138 for (i = 0 ; i < sas_expander->num_phys ; i++) { 5139 if ((mpt3sas_config_get_expander_pg1(ioc, &mpi_reply, 5140 &expander_pg1, i, handle))) { 5141 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5142 ioc->name, __FILE__, __LINE__, __func__); 5143 rc = -1; 5144 goto out_fail; 5145 } 5146 sas_expander->phy[i].handle = handle; 5147 sas_expander->phy[i].phy_id = i; 5148 5149 if ((mpt3sas_transport_add_expander_phy(ioc, 5150 &sas_expander->phy[i], expander_pg1, 5151 sas_expander->parent_dev))) { 5152 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5153 ioc->name, __FILE__, __LINE__, __func__); 5154 rc = -1; 5155 goto out_fail; 5156 } 5157 } 5158 5159 if (sas_expander->enclosure_handle) { 5160 if (!(mpt3sas_config_get_enclosure_pg0(ioc, &mpi_reply, 5161 &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE, 5162 sas_expander->enclosure_handle))) 5163 sas_expander->enclosure_logical_id = 5164 le64_to_cpu(enclosure_pg0.EnclosureLogicalID); 5165 } 5166 5167 _scsih_expander_node_add(ioc, sas_expander); 5168 return 0; 5169 5170 out_fail: 5171 5172 if (mpt3sas_port) 5173 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address, 5174 sas_address_parent); 5175 kfree(sas_expander); 5176 return rc; 5177 } 5178 5179 /** 5180 * mpt3sas_expander_remove - removing expander object 5181 * @ioc: per adapter object 5182 * @sas_address: expander sas_address 5183 * 5184 * Return nothing. 5185 */ 5186 void 5187 mpt3sas_expander_remove(struct MPT3SAS_ADAPTER *ioc, u64 sas_address) 5188 { 5189 struct _sas_node *sas_expander; 5190 unsigned long flags; 5191 5192 if (ioc->shost_recovery) 5193 return; 5194 5195 spin_lock_irqsave(&ioc->sas_node_lock, flags); 5196 sas_expander = mpt3sas_scsih_expander_find_by_sas_address(ioc, 5197 sas_address); 5198 if (sas_expander) 5199 list_del(&sas_expander->list); 5200 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 5201 if (sas_expander) 5202 _scsih_expander_node_remove(ioc, sas_expander); 5203 } 5204 5205 /** 5206 * _scsih_done - internal SCSI_IO callback handler. 5207 * @ioc: per adapter object 5208 * @smid: system request message index 5209 * @msix_index: MSIX table index supplied by the OS 5210 * @reply: reply message frame(lower 32bit addr) 5211 * 5212 * Callback handler when sending internal generated SCSI_IO. 5213 * The callback index passed is `ioc->scsih_cb_idx` 5214 * 5215 * Return 1 meaning mf should be freed from _base_interrupt 5216 * 0 means the mf is freed from this function. 5217 */ 5218 static u8 5219 _scsih_done(struct MPT3SAS_ADAPTER *ioc, u16 smid, u8 msix_index, u32 reply) 5220 { 5221 MPI2DefaultReply_t *mpi_reply; 5222 5223 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 5224 if (ioc->scsih_cmds.status == MPT3_CMD_NOT_USED) 5225 return 1; 5226 if (ioc->scsih_cmds.smid != smid) 5227 return 1; 5228 ioc->scsih_cmds.status |= MPT3_CMD_COMPLETE; 5229 if (mpi_reply) { 5230 memcpy(ioc->scsih_cmds.reply, mpi_reply, 5231 mpi_reply->MsgLength*4); 5232 ioc->scsih_cmds.status |= MPT3_CMD_REPLY_VALID; 5233 } 5234 ioc->scsih_cmds.status &= ~MPT3_CMD_PENDING; 5235 complete(&ioc->scsih_cmds.done); 5236 return 1; 5237 } 5238 5239 5240 5241 5242 #define MPT3_MAX_LUNS (255) 5243 5244 5245 /** 5246 * _scsih_check_access_status - check access flags 5247 * @ioc: per adapter object 5248 * @sas_address: sas address 5249 * @handle: sas device handle 5250 * @access_flags: errors returned during discovery of the device 5251 * 5252 * Return 0 for success, else failure 5253 */ 5254 static u8 5255 _scsih_check_access_status(struct MPT3SAS_ADAPTER *ioc, u64 sas_address, 5256 u16 handle, u8 access_status) 5257 { 5258 u8 rc = 1; 5259 char *desc = NULL; 5260 5261 switch (access_status) { 5262 case MPI2_SAS_DEVICE0_ASTATUS_NO_ERRORS: 5263 case MPI2_SAS_DEVICE0_ASTATUS_SATA_NEEDS_INITIALIZATION: 5264 rc = 0; 5265 break; 5266 case MPI2_SAS_DEVICE0_ASTATUS_SATA_CAPABILITY_FAILED: 5267 desc = "sata capability failed"; 5268 break; 5269 case MPI2_SAS_DEVICE0_ASTATUS_SATA_AFFILIATION_CONFLICT: 5270 desc = "sata affiliation conflict"; 5271 break; 5272 case MPI2_SAS_DEVICE0_ASTATUS_ROUTE_NOT_ADDRESSABLE: 5273 desc = "route not addressable"; 5274 break; 5275 case MPI2_SAS_DEVICE0_ASTATUS_SMP_ERROR_NOT_ADDRESSABLE: 5276 desc = "smp error not addressable"; 5277 break; 5278 case MPI2_SAS_DEVICE0_ASTATUS_DEVICE_BLOCKED: 5279 desc = "device blocked"; 5280 break; 5281 case MPI2_SAS_DEVICE0_ASTATUS_SATA_INIT_FAILED: 5282 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UNKNOWN: 5283 case MPI2_SAS_DEVICE0_ASTATUS_SIF_AFFILIATION_CONFLICT: 5284 case MPI2_SAS_DEVICE0_ASTATUS_SIF_DIAG: 5285 case MPI2_SAS_DEVICE0_ASTATUS_SIF_IDENTIFICATION: 5286 case MPI2_SAS_DEVICE0_ASTATUS_SIF_CHECK_POWER: 5287 case MPI2_SAS_DEVICE0_ASTATUS_SIF_PIO_SN: 5288 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MDMA_SN: 5289 case MPI2_SAS_DEVICE0_ASTATUS_SIF_UDMA_SN: 5290 case MPI2_SAS_DEVICE0_ASTATUS_SIF_ZONING_VIOLATION: 5291 case MPI2_SAS_DEVICE0_ASTATUS_SIF_NOT_ADDRESSABLE: 5292 case MPI2_SAS_DEVICE0_ASTATUS_SIF_MAX: 5293 desc = "sata initialization failed"; 5294 break; 5295 default: 5296 desc = "unknown"; 5297 break; 5298 } 5299 5300 if (!rc) 5301 return 0; 5302 5303 pr_err(MPT3SAS_FMT 5304 "discovery errors(%s): sas_address(0x%016llx), handle(0x%04x)\n", 5305 ioc->name, desc, (unsigned long long)sas_address, handle); 5306 return rc; 5307 } 5308 5309 /** 5310 * _scsih_check_device - checking device responsiveness 5311 * @ioc: per adapter object 5312 * @parent_sas_address: sas address of parent expander or sas host 5313 * @handle: attached device handle 5314 * @phy_numberv: phy number 5315 * @link_rate: new link rate 5316 * 5317 * Returns nothing. 5318 */ 5319 static void 5320 _scsih_check_device(struct MPT3SAS_ADAPTER *ioc, 5321 u64 parent_sas_address, u16 handle, u8 phy_number, u8 link_rate) 5322 { 5323 Mpi2ConfigReply_t mpi_reply; 5324 Mpi2SasDevicePage0_t sas_device_pg0; 5325 struct _sas_device *sas_device; 5326 u32 ioc_status; 5327 unsigned long flags; 5328 u64 sas_address; 5329 struct scsi_target *starget; 5330 struct MPT3SAS_TARGET *sas_target_priv_data; 5331 u32 device_info; 5332 5333 5334 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 5335 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) 5336 return; 5337 5338 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & MPI2_IOCSTATUS_MASK; 5339 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) 5340 return; 5341 5342 /* wide port handling ~ we need only handle device once for the phy that 5343 * is matched in sas device page zero 5344 */ 5345 if (phy_number != sas_device_pg0.PhyNum) 5346 return; 5347 5348 /* check if this is end device */ 5349 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 5350 if (!(_scsih_is_end_device(device_info))) 5351 return; 5352 5353 spin_lock_irqsave(&ioc->sas_device_lock, flags); 5354 sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 5355 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 5356 sas_address); 5357 5358 if (!sas_device) 5359 goto out_unlock; 5360 5361 if (unlikely(sas_device->handle != handle)) { 5362 starget = sas_device->starget; 5363 sas_target_priv_data = starget->hostdata; 5364 starget_printk(KERN_INFO, starget, 5365 "handle changed from(0x%04x) to (0x%04x)!!!\n", 5366 sas_device->handle, handle); 5367 sas_target_priv_data->handle = handle; 5368 sas_device->handle = handle; 5369 if (sas_device_pg0.Flags & 5370 MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) { 5371 sas_device->enclosure_level = 5372 le16_to_cpu(sas_device_pg0.EnclosureLevel); 5373 memcpy(&sas_device->connector_name[0], 5374 &sas_device_pg0.ConnectorName[0], 4); 5375 } else { 5376 sas_device->enclosure_level = 0; 5377 sas_device->connector_name[0] = '\0'; 5378 } 5379 } 5380 5381 /* check if device is present */ 5382 if (!(le16_to_cpu(sas_device_pg0.Flags) & 5383 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) { 5384 pr_err(MPT3SAS_FMT 5385 "device is not present handle(0x%04x), flags!!!\n", 5386 ioc->name, handle); 5387 goto out_unlock; 5388 } 5389 5390 /* check if there were any issues with discovery */ 5391 if (_scsih_check_access_status(ioc, sas_address, handle, 5392 sas_device_pg0.AccessStatus)) 5393 goto out_unlock; 5394 5395 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 5396 _scsih_ublock_io_device(ioc, sas_address); 5397 5398 if (sas_device) 5399 sas_device_put(sas_device); 5400 return; 5401 5402 out_unlock: 5403 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 5404 if (sas_device) 5405 sas_device_put(sas_device); 5406 } 5407 5408 /** 5409 * _scsih_add_device - creating sas device object 5410 * @ioc: per adapter object 5411 * @handle: sas device handle 5412 * @phy_num: phy number end device attached to 5413 * @is_pd: is this hidden raid component 5414 * 5415 * Creating end device object, stored in ioc->sas_device_list. 5416 * 5417 * Returns 0 for success, non-zero for failure. 5418 */ 5419 static int 5420 _scsih_add_device(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phy_num, 5421 u8 is_pd) 5422 { 5423 Mpi2ConfigReply_t mpi_reply; 5424 Mpi2SasDevicePage0_t sas_device_pg0; 5425 Mpi2SasEnclosurePage0_t enclosure_pg0; 5426 struct _sas_device *sas_device; 5427 u32 ioc_status; 5428 u64 sas_address; 5429 u32 device_info; 5430 5431 if ((mpt3sas_config_get_sas_device_pg0(ioc, &mpi_reply, &sas_device_pg0, 5432 MPI2_SAS_DEVICE_PGAD_FORM_HANDLE, handle))) { 5433 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5434 ioc->name, __FILE__, __LINE__, __func__); 5435 return -1; 5436 } 5437 5438 ioc_status = le16_to_cpu(mpi_reply.IOCStatus) & 5439 MPI2_IOCSTATUS_MASK; 5440 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 5441 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5442 ioc->name, __FILE__, __LINE__, __func__); 5443 return -1; 5444 } 5445 5446 /* check if this is end device */ 5447 device_info = le32_to_cpu(sas_device_pg0.DeviceInfo); 5448 if (!(_scsih_is_end_device(device_info))) 5449 return -1; 5450 sas_address = le64_to_cpu(sas_device_pg0.SASAddress); 5451 5452 /* check if device is present */ 5453 if (!(le16_to_cpu(sas_device_pg0.Flags) & 5454 MPI2_SAS_DEVICE0_FLAGS_DEVICE_PRESENT)) { 5455 pr_err(MPT3SAS_FMT "device is not present handle(0x04%x)!!!\n", 5456 ioc->name, handle); 5457 return -1; 5458 } 5459 5460 /* check if there were any issues with discovery */ 5461 if (_scsih_check_access_status(ioc, sas_address, handle, 5462 sas_device_pg0.AccessStatus)) 5463 return -1; 5464 5465 sas_device = mpt3sas_get_sdev_by_addr(ioc, 5466 sas_address); 5467 if (sas_device) { 5468 sas_device_put(sas_device); 5469 return -1; 5470 } 5471 5472 sas_device = kzalloc(sizeof(struct _sas_device), 5473 GFP_KERNEL); 5474 if (!sas_device) { 5475 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5476 ioc->name, __FILE__, __LINE__, __func__); 5477 return 0; 5478 } 5479 5480 kref_init(&sas_device->refcount); 5481 sas_device->handle = handle; 5482 if (_scsih_get_sas_address(ioc, 5483 le16_to_cpu(sas_device_pg0.ParentDevHandle), 5484 &sas_device->sas_address_parent) != 0) 5485 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 5486 ioc->name, __FILE__, __LINE__, __func__); 5487 sas_device->enclosure_handle = 5488 le16_to_cpu(sas_device_pg0.EnclosureHandle); 5489 if (sas_device->enclosure_handle != 0) 5490 sas_device->slot = 5491 le16_to_cpu(sas_device_pg0.Slot); 5492 sas_device->device_info = device_info; 5493 sas_device->sas_address = sas_address; 5494 sas_device->phy = sas_device_pg0.PhyNum; 5495 sas_device->fast_path = (le16_to_cpu(sas_device_pg0.Flags) & 5496 MPI25_SAS_DEVICE0_FLAGS_FAST_PATH_CAPABLE) ? 1 : 0; 5497 5498 if (sas_device_pg0.Flags & MPI2_SAS_DEVICE0_FLAGS_ENCL_LEVEL_VALID) { 5499 sas_device->enclosure_level = 5500 le16_to_cpu(sas_device_pg0.EnclosureLevel); 5501 memcpy(&sas_device->connector_name[0], 5502 &sas_device_pg0.ConnectorName[0], 4); 5503 } else { 5504 sas_device->enclosure_level = 0; 5505 sas_device->connector_name[0] = '\0'; 5506 } 5507 /* get enclosure_logical_id */ 5508 if (sas_device->enclosure_handle && !(mpt3sas_config_get_enclosure_pg0( 5509 ioc, &mpi_reply, &enclosure_pg0, MPI2_SAS_ENCLOS_PGAD_FORM_HANDLE, 5510 sas_device->enclosure_handle))) 5511 sas_device->enclosure_logical_id = 5512 le64_to_cpu(enclosure_pg0.EnclosureLogicalID); 5513 5514 /* get device name */ 5515 sas_device->device_name = le64_to_cpu(sas_device_pg0.DeviceName); 5516 5517 if (ioc->wait_for_discovery_to_complete) 5518 _scsih_sas_device_init_add(ioc, sas_device); 5519 else 5520 _scsih_sas_device_add(ioc, sas_device); 5521 5522 sas_device_put(sas_device); 5523 return 0; 5524 } 5525 5526 /** 5527 * _scsih_remove_device - removing sas device object 5528 * @ioc: per adapter object 5529 * @sas_device_delete: the sas_device object 5530 * 5531 * Return nothing. 5532 */ 5533 static void 5534 _scsih_remove_device(struct MPT3SAS_ADAPTER *ioc, 5535 struct _sas_device *sas_device) 5536 { 5537 struct MPT3SAS_TARGET *sas_target_priv_data; 5538 5539 if ((ioc->pdev->subsystem_vendor == PCI_VENDOR_ID_IBM) && 5540 (sas_device->pfa_led_on)) { 5541 _scsih_turn_off_pfa_led(ioc, sas_device); 5542 sas_device->pfa_led_on = 0; 5543 } 5544 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5545 "%s: enter: handle(0x%04x), sas_addr(0x%016llx)\n", 5546 ioc->name, __func__, 5547 sas_device->handle, (unsigned long long) 5548 sas_device->sas_address)); 5549 if (sas_device->enclosure_handle != 0) 5550 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5551 "%s: enter: enclosure logical id(0x%016llx), slot(%d)\n", 5552 ioc->name, __func__, 5553 (unsigned long long)sas_device->enclosure_logical_id, 5554 sas_device->slot)); 5555 if (sas_device->connector_name[0] != '\0') 5556 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5557 "%s: enter: enclosure level(0x%04x), connector name( %s)\n", 5558 ioc->name, __func__, 5559 sas_device->enclosure_level, 5560 sas_device->connector_name)); 5561 5562 if (sas_device->starget && sas_device->starget->hostdata) { 5563 sas_target_priv_data = sas_device->starget->hostdata; 5564 sas_target_priv_data->deleted = 1; 5565 _scsih_ublock_io_device(ioc, sas_device->sas_address); 5566 sas_target_priv_data->handle = 5567 MPT3SAS_INVALID_DEVICE_HANDLE; 5568 } 5569 5570 if (!ioc->hide_drives) 5571 mpt3sas_transport_port_remove(ioc, 5572 sas_device->sas_address, 5573 sas_device->sas_address_parent); 5574 5575 pr_info(MPT3SAS_FMT 5576 "removing handle(0x%04x), sas_addr(0x%016llx)\n", 5577 ioc->name, sas_device->handle, 5578 (unsigned long long) sas_device->sas_address); 5579 if (sas_device->enclosure_handle != 0) 5580 pr_info(MPT3SAS_FMT 5581 "removing : enclosure logical id(0x%016llx), slot(%d)\n", 5582 ioc->name, 5583 (unsigned long long)sas_device->enclosure_logical_id, 5584 sas_device->slot); 5585 if (sas_device->connector_name[0] != '\0') 5586 pr_info(MPT3SAS_FMT 5587 "removing enclosure level(0x%04x), connector name( %s)\n", 5588 ioc->name, sas_device->enclosure_level, 5589 sas_device->connector_name); 5590 5591 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5592 "%s: exit: handle(0x%04x), sas_addr(0x%016llx)\n", 5593 ioc->name, __func__, 5594 sas_device->handle, (unsigned long long) 5595 sas_device->sas_address)); 5596 if (sas_device->enclosure_handle != 0) 5597 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5598 "%s: exit: enclosure logical id(0x%016llx), slot(%d)\n", 5599 ioc->name, __func__, 5600 (unsigned long long)sas_device->enclosure_logical_id, 5601 sas_device->slot)); 5602 if (sas_device->connector_name[0] != '\0') 5603 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5604 "%s: exit: enclosure level(0x%04x), connector name(%s)\n", 5605 ioc->name, __func__, sas_device->enclosure_level, 5606 sas_device->connector_name)); 5607 } 5608 5609 /** 5610 * _scsih_sas_topology_change_event_debug - debug for topology event 5611 * @ioc: per adapter object 5612 * @event_data: event data payload 5613 * Context: user. 5614 */ 5615 static void 5616 _scsih_sas_topology_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 5617 Mpi2EventDataSasTopologyChangeList_t *event_data) 5618 { 5619 int i; 5620 u16 handle; 5621 u16 reason_code; 5622 u8 phy_number; 5623 char *status_str = NULL; 5624 u8 link_rate, prev_link_rate; 5625 5626 switch (event_data->ExpStatus) { 5627 case MPI2_EVENT_SAS_TOPO_ES_ADDED: 5628 status_str = "add"; 5629 break; 5630 case MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING: 5631 status_str = "remove"; 5632 break; 5633 case MPI2_EVENT_SAS_TOPO_ES_RESPONDING: 5634 case 0: 5635 status_str = "responding"; 5636 break; 5637 case MPI2_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING: 5638 status_str = "remove delay"; 5639 break; 5640 default: 5641 status_str = "unknown status"; 5642 break; 5643 } 5644 pr_info(MPT3SAS_FMT "sas topology change: (%s)\n", 5645 ioc->name, status_str); 5646 pr_info("\thandle(0x%04x), enclosure_handle(0x%04x) " \ 5647 "start_phy(%02d), count(%d)\n", 5648 le16_to_cpu(event_data->ExpanderDevHandle), 5649 le16_to_cpu(event_data->EnclosureHandle), 5650 event_data->StartPhyNum, event_data->NumEntries); 5651 for (i = 0; i < event_data->NumEntries; i++) { 5652 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 5653 if (!handle) 5654 continue; 5655 phy_number = event_data->StartPhyNum + i; 5656 reason_code = event_data->PHY[i].PhyStatus & 5657 MPI2_EVENT_SAS_TOPO_RC_MASK; 5658 switch (reason_code) { 5659 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED: 5660 status_str = "target add"; 5661 break; 5662 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING: 5663 status_str = "target remove"; 5664 break; 5665 case MPI2_EVENT_SAS_TOPO_RC_DELAY_NOT_RESPONDING: 5666 status_str = "delay target remove"; 5667 break; 5668 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED: 5669 status_str = "link rate change"; 5670 break; 5671 case MPI2_EVENT_SAS_TOPO_RC_NO_CHANGE: 5672 status_str = "target responding"; 5673 break; 5674 default: 5675 status_str = "unknown"; 5676 break; 5677 } 5678 link_rate = event_data->PHY[i].LinkRate >> 4; 5679 prev_link_rate = event_data->PHY[i].LinkRate & 0xF; 5680 pr_info("\tphy(%02d), attached_handle(0x%04x): %s:" \ 5681 " link rate: new(0x%02x), old(0x%02x)\n", phy_number, 5682 handle, status_str, link_rate, prev_link_rate); 5683 5684 } 5685 } 5686 5687 /** 5688 * _scsih_sas_topology_change_event - handle topology changes 5689 * @ioc: per adapter object 5690 * @fw_event: The fw_event_work object 5691 * Context: user. 5692 * 5693 */ 5694 static int 5695 _scsih_sas_topology_change_event(struct MPT3SAS_ADAPTER *ioc, 5696 struct fw_event_work *fw_event) 5697 { 5698 int i; 5699 u16 parent_handle, handle; 5700 u16 reason_code; 5701 u8 phy_number, max_phys; 5702 struct _sas_node *sas_expander; 5703 u64 sas_address; 5704 unsigned long flags; 5705 u8 link_rate, prev_link_rate; 5706 Mpi2EventDataSasTopologyChangeList_t *event_data = 5707 (Mpi2EventDataSasTopologyChangeList_t *) 5708 fw_event->event_data; 5709 5710 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 5711 _scsih_sas_topology_change_event_debug(ioc, event_data); 5712 5713 if (ioc->shost_recovery || ioc->remove_host || ioc->pci_error_recovery) 5714 return 0; 5715 5716 if (!ioc->sas_hba.num_phys) 5717 _scsih_sas_host_add(ioc); 5718 else 5719 _scsih_sas_host_refresh(ioc); 5720 5721 if (fw_event->ignore) { 5722 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5723 "ignoring expander event\n", ioc->name)); 5724 return 0; 5725 } 5726 5727 parent_handle = le16_to_cpu(event_data->ExpanderDevHandle); 5728 5729 /* handle expander add */ 5730 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_ADDED) 5731 if (_scsih_expander_add(ioc, parent_handle) != 0) 5732 return 0; 5733 5734 spin_lock_irqsave(&ioc->sas_node_lock, flags); 5735 sas_expander = mpt3sas_scsih_expander_find_by_handle(ioc, 5736 parent_handle); 5737 if (sas_expander) { 5738 sas_address = sas_expander->sas_address; 5739 max_phys = sas_expander->num_phys; 5740 } else if (parent_handle < ioc->sas_hba.num_phys) { 5741 sas_address = ioc->sas_hba.sas_address; 5742 max_phys = ioc->sas_hba.num_phys; 5743 } else { 5744 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 5745 return 0; 5746 } 5747 spin_unlock_irqrestore(&ioc->sas_node_lock, flags); 5748 5749 /* handle siblings events */ 5750 for (i = 0; i < event_data->NumEntries; i++) { 5751 if (fw_event->ignore) { 5752 dewtprintk(ioc, pr_info(MPT3SAS_FMT 5753 "ignoring expander event\n", ioc->name)); 5754 return 0; 5755 } 5756 if (ioc->remove_host || ioc->pci_error_recovery) 5757 return 0; 5758 phy_number = event_data->StartPhyNum + i; 5759 if (phy_number >= max_phys) 5760 continue; 5761 reason_code = event_data->PHY[i].PhyStatus & 5762 MPI2_EVENT_SAS_TOPO_RC_MASK; 5763 if ((event_data->PHY[i].PhyStatus & 5764 MPI2_EVENT_SAS_TOPO_PHYSTATUS_VACANT) && (reason_code != 5765 MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING)) 5766 continue; 5767 handle = le16_to_cpu(event_data->PHY[i].AttachedDevHandle); 5768 if (!handle) 5769 continue; 5770 link_rate = event_data->PHY[i].LinkRate >> 4; 5771 prev_link_rate = event_data->PHY[i].LinkRate & 0xF; 5772 switch (reason_code) { 5773 case MPI2_EVENT_SAS_TOPO_RC_PHY_CHANGED: 5774 5775 if (ioc->shost_recovery) 5776 break; 5777 5778 if (link_rate == prev_link_rate) 5779 break; 5780 5781 mpt3sas_transport_update_links(ioc, sas_address, 5782 handle, phy_number, link_rate); 5783 5784 if (link_rate < MPI2_SAS_NEG_LINK_RATE_1_5) 5785 break; 5786 5787 _scsih_check_device(ioc, sas_address, handle, 5788 phy_number, link_rate); 5789 5790 5791 case MPI2_EVENT_SAS_TOPO_RC_TARG_ADDED: 5792 5793 if (ioc->shost_recovery) 5794 break; 5795 5796 mpt3sas_transport_update_links(ioc, sas_address, 5797 handle, phy_number, link_rate); 5798 5799 _scsih_add_device(ioc, handle, phy_number, 0); 5800 5801 break; 5802 case MPI2_EVENT_SAS_TOPO_RC_TARG_NOT_RESPONDING: 5803 5804 _scsih_device_remove_by_handle(ioc, handle); 5805 break; 5806 } 5807 } 5808 5809 /* handle expander removal */ 5810 if (event_data->ExpStatus == MPI2_EVENT_SAS_TOPO_ES_NOT_RESPONDING && 5811 sas_expander) 5812 mpt3sas_expander_remove(ioc, sas_address); 5813 5814 return 0; 5815 } 5816 5817 /** 5818 * _scsih_sas_device_status_change_event_debug - debug for device event 5819 * @event_data: event data payload 5820 * Context: user. 5821 * 5822 * Return nothing. 5823 */ 5824 static void 5825 _scsih_sas_device_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 5826 Mpi2EventDataSasDeviceStatusChange_t *event_data) 5827 { 5828 char *reason_str = NULL; 5829 5830 switch (event_data->ReasonCode) { 5831 case MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA: 5832 reason_str = "smart data"; 5833 break; 5834 case MPI2_EVENT_SAS_DEV_STAT_RC_UNSUPPORTED: 5835 reason_str = "unsupported device discovered"; 5836 break; 5837 case MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET: 5838 reason_str = "internal device reset"; 5839 break; 5840 case MPI2_EVENT_SAS_DEV_STAT_RC_TASK_ABORT_INTERNAL: 5841 reason_str = "internal task abort"; 5842 break; 5843 case MPI2_EVENT_SAS_DEV_STAT_RC_ABORT_TASK_SET_INTERNAL: 5844 reason_str = "internal task abort set"; 5845 break; 5846 case MPI2_EVENT_SAS_DEV_STAT_RC_CLEAR_TASK_SET_INTERNAL: 5847 reason_str = "internal clear task set"; 5848 break; 5849 case MPI2_EVENT_SAS_DEV_STAT_RC_QUERY_TASK_INTERNAL: 5850 reason_str = "internal query task"; 5851 break; 5852 case MPI2_EVENT_SAS_DEV_STAT_RC_SATA_INIT_FAILURE: 5853 reason_str = "sata init failure"; 5854 break; 5855 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET: 5856 reason_str = "internal device reset complete"; 5857 break; 5858 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_TASK_ABORT_INTERNAL: 5859 reason_str = "internal task abort complete"; 5860 break; 5861 case MPI2_EVENT_SAS_DEV_STAT_RC_ASYNC_NOTIFICATION: 5862 reason_str = "internal async notification"; 5863 break; 5864 case MPI2_EVENT_SAS_DEV_STAT_RC_EXPANDER_REDUCED_FUNCTIONALITY: 5865 reason_str = "expander reduced functionality"; 5866 break; 5867 case MPI2_EVENT_SAS_DEV_STAT_RC_CMP_EXPANDER_REDUCED_FUNCTIONALITY: 5868 reason_str = "expander reduced functionality complete"; 5869 break; 5870 default: 5871 reason_str = "unknown reason"; 5872 break; 5873 } 5874 pr_info(MPT3SAS_FMT "device status change: (%s)\n" 5875 "\thandle(0x%04x), sas address(0x%016llx), tag(%d)", 5876 ioc->name, reason_str, le16_to_cpu(event_data->DevHandle), 5877 (unsigned long long)le64_to_cpu(event_data->SASAddress), 5878 le16_to_cpu(event_data->TaskTag)); 5879 if (event_data->ReasonCode == MPI2_EVENT_SAS_DEV_STAT_RC_SMART_DATA) 5880 pr_info(MPT3SAS_FMT ", ASC(0x%x), ASCQ(0x%x)\n", ioc->name, 5881 event_data->ASC, event_data->ASCQ); 5882 pr_info("\n"); 5883 } 5884 5885 /** 5886 * _scsih_sas_device_status_change_event - handle device status change 5887 * @ioc: per adapter object 5888 * @fw_event: The fw_event_work object 5889 * Context: user. 5890 * 5891 * Return nothing. 5892 */ 5893 static void 5894 _scsih_sas_device_status_change_event(struct MPT3SAS_ADAPTER *ioc, 5895 struct fw_event_work *fw_event) 5896 { 5897 struct MPT3SAS_TARGET *target_priv_data; 5898 struct _sas_device *sas_device; 5899 u64 sas_address; 5900 unsigned long flags; 5901 Mpi2EventDataSasDeviceStatusChange_t *event_data = 5902 (Mpi2EventDataSasDeviceStatusChange_t *) 5903 fw_event->event_data; 5904 5905 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 5906 _scsih_sas_device_status_change_event_debug(ioc, 5907 event_data); 5908 5909 /* In MPI Revision K (0xC), the internal device reset complete was 5910 * implemented, so avoid setting tm_busy flag for older firmware. 5911 */ 5912 if ((ioc->facts.HeaderVersion >> 8) < 0xC) 5913 return; 5914 5915 if (event_data->ReasonCode != 5916 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET && 5917 event_data->ReasonCode != 5918 MPI2_EVENT_SAS_DEV_STAT_RC_CMP_INTERNAL_DEV_RESET) 5919 return; 5920 5921 spin_lock_irqsave(&ioc->sas_device_lock, flags); 5922 sas_address = le64_to_cpu(event_data->SASAddress); 5923 sas_device = __mpt3sas_get_sdev_by_addr(ioc, 5924 sas_address); 5925 5926 if (!sas_device || !sas_device->starget) 5927 goto out; 5928 5929 target_priv_data = sas_device->starget->hostdata; 5930 if (!target_priv_data) 5931 goto out; 5932 5933 if (event_data->ReasonCode == 5934 MPI2_EVENT_SAS_DEV_STAT_RC_INTERNAL_DEVICE_RESET) 5935 target_priv_data->tm_busy = 1; 5936 else 5937 target_priv_data->tm_busy = 0; 5938 5939 out: 5940 if (sas_device) 5941 sas_device_put(sas_device); 5942 5943 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 5944 5945 } 5946 5947 /** 5948 * _scsih_sas_enclosure_dev_status_change_event_debug - debug for enclosure 5949 * event 5950 * @ioc: per adapter object 5951 * @event_data: event data payload 5952 * Context: user. 5953 * 5954 * Return nothing. 5955 */ 5956 static void 5957 _scsih_sas_enclosure_dev_status_change_event_debug(struct MPT3SAS_ADAPTER *ioc, 5958 Mpi2EventDataSasEnclDevStatusChange_t *event_data) 5959 { 5960 char *reason_str = NULL; 5961 5962 switch (event_data->ReasonCode) { 5963 case MPI2_EVENT_SAS_ENCL_RC_ADDED: 5964 reason_str = "enclosure add"; 5965 break; 5966 case MPI2_EVENT_SAS_ENCL_RC_NOT_RESPONDING: 5967 reason_str = "enclosure remove"; 5968 break; 5969 default: 5970 reason_str = "unknown reason"; 5971 break; 5972 } 5973 5974 pr_info(MPT3SAS_FMT "enclosure status change: (%s)\n" 5975 "\thandle(0x%04x), enclosure logical id(0x%016llx)" 5976 " number slots(%d)\n", ioc->name, reason_str, 5977 le16_to_cpu(event_data->EnclosureHandle), 5978 (unsigned long long)le64_to_cpu(event_data->EnclosureLogicalID), 5979 le16_to_cpu(event_data->StartSlot)); 5980 } 5981 5982 /** 5983 * _scsih_sas_enclosure_dev_status_change_event - handle enclosure events 5984 * @ioc: per adapter object 5985 * @fw_event: The fw_event_work object 5986 * Context: user. 5987 * 5988 * Return nothing. 5989 */ 5990 static void 5991 _scsih_sas_enclosure_dev_status_change_event(struct MPT3SAS_ADAPTER *ioc, 5992 struct fw_event_work *fw_event) 5993 { 5994 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) 5995 _scsih_sas_enclosure_dev_status_change_event_debug(ioc, 5996 (Mpi2EventDataSasEnclDevStatusChange_t *) 5997 fw_event->event_data); 5998 } 5999 6000 /** 6001 * _scsih_sas_broadcast_primitive_event - handle broadcast events 6002 * @ioc: per adapter object 6003 * @fw_event: The fw_event_work object 6004 * Context: user. 6005 * 6006 * Return nothing. 6007 */ 6008 static void 6009 _scsih_sas_broadcast_primitive_event(struct MPT3SAS_ADAPTER *ioc, 6010 struct fw_event_work *fw_event) 6011 { 6012 struct scsi_cmnd *scmd; 6013 struct scsi_device *sdev; 6014 u16 smid, handle; 6015 u32 lun; 6016 struct MPT3SAS_DEVICE *sas_device_priv_data; 6017 u32 termination_count; 6018 u32 query_count; 6019 Mpi2SCSITaskManagementReply_t *mpi_reply; 6020 Mpi2EventDataSasBroadcastPrimitive_t *event_data = 6021 (Mpi2EventDataSasBroadcastPrimitive_t *) 6022 fw_event->event_data; 6023 u16 ioc_status; 6024 unsigned long flags; 6025 int r; 6026 u8 max_retries = 0; 6027 u8 task_abort_retries; 6028 6029 mutex_lock(&ioc->tm_cmds.mutex); 6030 pr_info(MPT3SAS_FMT 6031 "%s: enter: phy number(%d), width(%d)\n", 6032 ioc->name, __func__, event_data->PhyNum, 6033 event_data->PortWidth); 6034 6035 _scsih_block_io_all_device(ioc); 6036 6037 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6038 mpi_reply = ioc->tm_cmds.reply; 6039 broadcast_aen_retry: 6040 6041 /* sanity checks for retrying this loop */ 6042 if (max_retries++ == 5) { 6043 dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: giving up\n", 6044 ioc->name, __func__)); 6045 goto out; 6046 } else if (max_retries > 1) 6047 dewtprintk(ioc, pr_info(MPT3SAS_FMT "%s: %d retry\n", 6048 ioc->name, __func__, max_retries - 1)); 6049 6050 termination_count = 0; 6051 query_count = 0; 6052 for (smid = 1; smid <= ioc->scsiio_depth; smid++) { 6053 if (ioc->shost_recovery) 6054 goto out; 6055 scmd = _scsih_scsi_lookup_get(ioc, smid); 6056 if (!scmd) 6057 continue; 6058 sdev = scmd->device; 6059 sas_device_priv_data = sdev->hostdata; 6060 if (!sas_device_priv_data || !sas_device_priv_data->sas_target) 6061 continue; 6062 /* skip hidden raid components */ 6063 if (sas_device_priv_data->sas_target->flags & 6064 MPT_TARGET_FLAGS_RAID_COMPONENT) 6065 continue; 6066 /* skip volumes */ 6067 if (sas_device_priv_data->sas_target->flags & 6068 MPT_TARGET_FLAGS_VOLUME) 6069 continue; 6070 6071 handle = sas_device_priv_data->sas_target->handle; 6072 lun = sas_device_priv_data->lun; 6073 query_count++; 6074 6075 if (ioc->shost_recovery) 6076 goto out; 6077 6078 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 6079 r = mpt3sas_scsih_issue_tm(ioc, handle, 0, 0, lun, 6080 MPI2_SCSITASKMGMT_TASKTYPE_QUERY_TASK, smid, 30, 6081 TM_MUTEX_OFF); 6082 if (r == FAILED) { 6083 sdev_printk(KERN_WARNING, sdev, 6084 "mpt3sas_scsih_issue_tm: FAILED when sending " 6085 "QUERY_TASK: scmd(%p)\n", scmd); 6086 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6087 goto broadcast_aen_retry; 6088 } 6089 ioc_status = le16_to_cpu(mpi_reply->IOCStatus) 6090 & MPI2_IOCSTATUS_MASK; 6091 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6092 sdev_printk(KERN_WARNING, sdev, 6093 "query task: FAILED with IOCSTATUS(0x%04x), scmd(%p)\n", 6094 ioc_status, scmd); 6095 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6096 goto broadcast_aen_retry; 6097 } 6098 6099 /* see if IO is still owned by IOC and target */ 6100 if (mpi_reply->ResponseCode == 6101 MPI2_SCSITASKMGMT_RSP_TM_SUCCEEDED || 6102 mpi_reply->ResponseCode == 6103 MPI2_SCSITASKMGMT_RSP_IO_QUEUED_ON_IOC) { 6104 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6105 continue; 6106 } 6107 task_abort_retries = 0; 6108 tm_retry: 6109 if (task_abort_retries++ == 60) { 6110 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6111 "%s: ABORT_TASK: giving up\n", ioc->name, 6112 __func__)); 6113 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6114 goto broadcast_aen_retry; 6115 } 6116 6117 if (ioc->shost_recovery) 6118 goto out_no_lock; 6119 6120 r = mpt3sas_scsih_issue_tm(ioc, handle, sdev->channel, sdev->id, 6121 sdev->lun, MPI2_SCSITASKMGMT_TASKTYPE_ABORT_TASK, smid, 30, 6122 TM_MUTEX_OFF); 6123 if (r == FAILED) { 6124 sdev_printk(KERN_WARNING, sdev, 6125 "mpt3sas_scsih_issue_tm: ABORT_TASK: FAILED : " 6126 "scmd(%p)\n", scmd); 6127 goto tm_retry; 6128 } 6129 6130 if (task_abort_retries > 1) 6131 sdev_printk(KERN_WARNING, sdev, 6132 "mpt3sas_scsih_issue_tm: ABORT_TASK: RETRIES (%d):" 6133 " scmd(%p)\n", 6134 task_abort_retries - 1, scmd); 6135 6136 termination_count += le32_to_cpu(mpi_reply->TerminationCount); 6137 spin_lock_irqsave(&ioc->scsi_lookup_lock, flags); 6138 } 6139 6140 if (ioc->broadcast_aen_pending) { 6141 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6142 "%s: loop back due to pending AEN\n", 6143 ioc->name, __func__)); 6144 ioc->broadcast_aen_pending = 0; 6145 goto broadcast_aen_retry; 6146 } 6147 6148 out: 6149 spin_unlock_irqrestore(&ioc->scsi_lookup_lock, flags); 6150 out_no_lock: 6151 6152 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6153 "%s - exit, query_count = %d termination_count = %d\n", 6154 ioc->name, __func__, query_count, termination_count)); 6155 6156 ioc->broadcast_aen_busy = 0; 6157 if (!ioc->shost_recovery) 6158 _scsih_ublock_io_all_device(ioc); 6159 mutex_unlock(&ioc->tm_cmds.mutex); 6160 } 6161 6162 /** 6163 * _scsih_sas_discovery_event - handle discovery events 6164 * @ioc: per adapter object 6165 * @fw_event: The fw_event_work object 6166 * Context: user. 6167 * 6168 * Return nothing. 6169 */ 6170 static void 6171 _scsih_sas_discovery_event(struct MPT3SAS_ADAPTER *ioc, 6172 struct fw_event_work *fw_event) 6173 { 6174 Mpi2EventDataSasDiscovery_t *event_data = 6175 (Mpi2EventDataSasDiscovery_t *) fw_event->event_data; 6176 6177 if (ioc->logging_level & MPT_DEBUG_EVENT_WORK_TASK) { 6178 pr_info(MPT3SAS_FMT "discovery event: (%s)", ioc->name, 6179 (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED) ? 6180 "start" : "stop"); 6181 if (event_data->DiscoveryStatus) 6182 pr_info("discovery_status(0x%08x)", 6183 le32_to_cpu(event_data->DiscoveryStatus)); 6184 pr_info("\n"); 6185 } 6186 6187 if (event_data->ReasonCode == MPI2_EVENT_SAS_DISC_RC_STARTED && 6188 !ioc->sas_hba.num_phys) { 6189 if (disable_discovery > 0 && ioc->shost_recovery) { 6190 /* Wait for the reset to complete */ 6191 while (ioc->shost_recovery) 6192 ssleep(1); 6193 } 6194 _scsih_sas_host_add(ioc); 6195 } 6196 } 6197 6198 /** 6199 * _scsih_ir_fastpath - turn on fastpath for IR physdisk 6200 * @ioc: per adapter object 6201 * @handle: device handle for physical disk 6202 * @phys_disk_num: physical disk number 6203 * 6204 * Return 0 for success, else failure. 6205 */ 6206 static int 6207 _scsih_ir_fastpath(struct MPT3SAS_ADAPTER *ioc, u16 handle, u8 phys_disk_num) 6208 { 6209 Mpi2RaidActionRequest_t *mpi_request; 6210 Mpi2RaidActionReply_t *mpi_reply; 6211 u16 smid; 6212 u8 issue_reset = 0; 6213 int rc = 0; 6214 u16 ioc_status; 6215 u32 log_info; 6216 6217 if (ioc->hba_mpi_version_belonged == MPI2_VERSION) 6218 return rc; 6219 6220 mutex_lock(&ioc->scsih_cmds.mutex); 6221 6222 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) { 6223 pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n", 6224 ioc->name, __func__); 6225 rc = -EAGAIN; 6226 goto out; 6227 } 6228 ioc->scsih_cmds.status = MPT3_CMD_PENDING; 6229 6230 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx); 6231 if (!smid) { 6232 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 6233 ioc->name, __func__); 6234 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 6235 rc = -EAGAIN; 6236 goto out; 6237 } 6238 6239 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 6240 ioc->scsih_cmds.smid = smid; 6241 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t)); 6242 6243 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION; 6244 mpi_request->Action = MPI2_RAID_ACTION_PHYSDISK_HIDDEN; 6245 mpi_request->PhysDiskNum = phys_disk_num; 6246 6247 dewtprintk(ioc, pr_info(MPT3SAS_FMT "IR RAID_ACTION: turning fast "\ 6248 "path on for handle(0x%04x), phys_disk_num (0x%02x)\n", ioc->name, 6249 handle, phys_disk_num)); 6250 6251 init_completion(&ioc->scsih_cmds.done); 6252 mpt3sas_base_put_smid_default(ioc, smid); 6253 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ); 6254 6255 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) { 6256 pr_err(MPT3SAS_FMT "%s: timeout\n", 6257 ioc->name, __func__); 6258 if (!(ioc->scsih_cmds.status & MPT3_CMD_RESET)) 6259 issue_reset = 1; 6260 rc = -EFAULT; 6261 goto out; 6262 } 6263 6264 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) { 6265 6266 mpi_reply = ioc->scsih_cmds.reply; 6267 ioc_status = le16_to_cpu(mpi_reply->IOCStatus); 6268 if (ioc_status & MPI2_IOCSTATUS_FLAG_LOG_INFO_AVAILABLE) 6269 log_info = le32_to_cpu(mpi_reply->IOCLogInfo); 6270 else 6271 log_info = 0; 6272 ioc_status &= MPI2_IOCSTATUS_MASK; 6273 if (ioc_status != MPI2_IOCSTATUS_SUCCESS) { 6274 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6275 "IR RAID_ACTION: failed: ioc_status(0x%04x), " 6276 "loginfo(0x%08x)!!!\n", ioc->name, ioc_status, 6277 log_info)); 6278 rc = -EFAULT; 6279 } else 6280 dewtprintk(ioc, pr_info(MPT3SAS_FMT 6281 "IR RAID_ACTION: completed successfully\n", 6282 ioc->name)); 6283 } 6284 6285 out: 6286 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 6287 mutex_unlock(&ioc->scsih_cmds.mutex); 6288 6289 if (issue_reset) 6290 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, 6291 FORCE_BIG_HAMMER); 6292 return rc; 6293 } 6294 6295 /** 6296 * _scsih_reprobe_lun - reprobing lun 6297 * @sdev: scsi device struct 6298 * @no_uld_attach: sdev->no_uld_attach flag setting 6299 * 6300 **/ 6301 static void 6302 _scsih_reprobe_lun(struct scsi_device *sdev, void *no_uld_attach) 6303 { 6304 int rc; 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 rc = 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 7854 /* events turned off due to host reset or driver unloading */ 7855 if (ioc->remove_host || ioc->pci_error_recovery) 7856 return 1; 7857 7858 mpi_reply = mpt3sas_base_get_reply_virt_addr(ioc, reply); 7859 7860 if (unlikely(!mpi_reply)) { 7861 pr_err(MPT3SAS_FMT "mpi_reply not valid at %s:%d/%s()!\n", 7862 ioc->name, __FILE__, __LINE__, __func__); 7863 return 1; 7864 } 7865 7866 event = le16_to_cpu(mpi_reply->Event); 7867 7868 if (event != MPI2_EVENT_LOG_ENTRY_ADDED) 7869 mpt3sas_trigger_event(ioc, event, 0); 7870 7871 switch (event) { 7872 /* handle these */ 7873 case MPI2_EVENT_SAS_BROADCAST_PRIMITIVE: 7874 { 7875 Mpi2EventDataSasBroadcastPrimitive_t *baen_data = 7876 (Mpi2EventDataSasBroadcastPrimitive_t *) 7877 mpi_reply->EventData; 7878 7879 if (baen_data->Primitive != 7880 MPI2_EVENT_PRIMITIVE_ASYNCHRONOUS_EVENT) 7881 return 1; 7882 7883 if (ioc->broadcast_aen_busy) { 7884 ioc->broadcast_aen_pending++; 7885 return 1; 7886 } else 7887 ioc->broadcast_aen_busy = 1; 7888 break; 7889 } 7890 7891 case MPI2_EVENT_SAS_TOPOLOGY_CHANGE_LIST: 7892 _scsih_check_topo_delete_events(ioc, 7893 (Mpi2EventDataSasTopologyChangeList_t *) 7894 mpi_reply->EventData); 7895 break; 7896 case MPI2_EVENT_IR_CONFIGURATION_CHANGE_LIST: 7897 _scsih_check_ir_config_unhide_events(ioc, 7898 (Mpi2EventDataIrConfigChangeList_t *) 7899 mpi_reply->EventData); 7900 break; 7901 case MPI2_EVENT_IR_VOLUME: 7902 _scsih_check_volume_delete_events(ioc, 7903 (Mpi2EventDataIrVolume_t *) 7904 mpi_reply->EventData); 7905 break; 7906 case MPI2_EVENT_LOG_ENTRY_ADDED: 7907 { 7908 Mpi2EventDataLogEntryAdded_t *log_entry; 7909 u32 *log_code; 7910 7911 if (!ioc->is_warpdrive) 7912 break; 7913 7914 log_entry = (Mpi2EventDataLogEntryAdded_t *) 7915 mpi_reply->EventData; 7916 log_code = (u32 *)log_entry->LogData; 7917 7918 if (le16_to_cpu(log_entry->LogEntryQualifier) 7919 != MPT2_WARPDRIVE_LOGENTRY) 7920 break; 7921 7922 switch (le32_to_cpu(*log_code)) { 7923 case MPT2_WARPDRIVE_LC_SSDT: 7924 pr_warn(MPT3SAS_FMT "WarpDrive Warning: " 7925 "IO Throttling has occurred in the WarpDrive " 7926 "subsystem. Check WarpDrive documentation for " 7927 "additional details.\n", ioc->name); 7928 break; 7929 case MPT2_WARPDRIVE_LC_SSDLW: 7930 pr_warn(MPT3SAS_FMT "WarpDrive Warning: " 7931 "Program/Erase Cycles for the WarpDrive subsystem " 7932 "in degraded range. Check WarpDrive documentation " 7933 "for additional details.\n", ioc->name); 7934 break; 7935 case MPT2_WARPDRIVE_LC_SSDLF: 7936 pr_err(MPT3SAS_FMT "WarpDrive Fatal Error: " 7937 "There are no Program/Erase Cycles for the " 7938 "WarpDrive subsystem. The storage device will be " 7939 "in read-only mode. Check WarpDrive documentation " 7940 "for additional details.\n", ioc->name); 7941 break; 7942 case MPT2_WARPDRIVE_LC_BRMF: 7943 pr_err(MPT3SAS_FMT "WarpDrive Fatal Error: " 7944 "The Backup Rail Monitor has failed on the " 7945 "WarpDrive subsystem. Check WarpDrive " 7946 "documentation for additional details.\n", 7947 ioc->name); 7948 break; 7949 } 7950 7951 break; 7952 } 7953 case MPI2_EVENT_SAS_DEVICE_STATUS_CHANGE: 7954 case MPI2_EVENT_IR_OPERATION_STATUS: 7955 case MPI2_EVENT_SAS_DISCOVERY: 7956 case MPI2_EVENT_SAS_ENCL_DEVICE_STATUS_CHANGE: 7957 case MPI2_EVENT_IR_PHYSICAL_DISK: 7958 break; 7959 7960 case MPI2_EVENT_TEMP_THRESHOLD: 7961 _scsih_temp_threshold_events(ioc, 7962 (Mpi2EventDataTemperature_t *) 7963 mpi_reply->EventData); 7964 break; 7965 7966 default: /* ignore the rest */ 7967 return 1; 7968 } 7969 7970 sz = le16_to_cpu(mpi_reply->EventDataLength) * 4; 7971 fw_event = alloc_fw_event_work(sz); 7972 if (!fw_event) { 7973 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 7974 ioc->name, __FILE__, __LINE__, __func__); 7975 return 1; 7976 } 7977 7978 memcpy(fw_event->event_data, mpi_reply->EventData, sz); 7979 fw_event->ioc = ioc; 7980 fw_event->VF_ID = mpi_reply->VF_ID; 7981 fw_event->VP_ID = mpi_reply->VP_ID; 7982 fw_event->event = event; 7983 _scsih_fw_event_add(ioc, fw_event); 7984 fw_event_work_put(fw_event); 7985 return 1; 7986 } 7987 7988 /** 7989 * _scsih_expander_node_remove - removing expander device from list. 7990 * @ioc: per adapter object 7991 * @sas_expander: the sas_device object 7992 * Context: Calling function should acquire ioc->sas_node_lock. 7993 * 7994 * Removing object and freeing associated memory from the 7995 * ioc->sas_expander_list. 7996 * 7997 * Return nothing. 7998 */ 7999 static void 8000 _scsih_expander_node_remove(struct MPT3SAS_ADAPTER *ioc, 8001 struct _sas_node *sas_expander) 8002 { 8003 struct _sas_port *mpt3sas_port, *next; 8004 8005 /* remove sibling ports attached to this expander */ 8006 list_for_each_entry_safe(mpt3sas_port, next, 8007 &sas_expander->sas_port_list, port_list) { 8008 if (ioc->shost_recovery) 8009 return; 8010 if (mpt3sas_port->remote_identify.device_type == 8011 SAS_END_DEVICE) 8012 mpt3sas_device_remove_by_sas_address(ioc, 8013 mpt3sas_port->remote_identify.sas_address); 8014 else if (mpt3sas_port->remote_identify.device_type == 8015 SAS_EDGE_EXPANDER_DEVICE || 8016 mpt3sas_port->remote_identify.device_type == 8017 SAS_FANOUT_EXPANDER_DEVICE) 8018 mpt3sas_expander_remove(ioc, 8019 mpt3sas_port->remote_identify.sas_address); 8020 } 8021 8022 mpt3sas_transport_port_remove(ioc, sas_expander->sas_address, 8023 sas_expander->sas_address_parent); 8024 8025 pr_info(MPT3SAS_FMT 8026 "expander_remove: handle(0x%04x), sas_addr(0x%016llx)\n", 8027 ioc->name, 8028 sas_expander->handle, (unsigned long long) 8029 sas_expander->sas_address); 8030 8031 kfree(sas_expander->phy); 8032 kfree(sas_expander); 8033 } 8034 8035 /** 8036 * _scsih_ir_shutdown - IR shutdown notification 8037 * @ioc: per adapter object 8038 * 8039 * Sending RAID Action to alert the Integrated RAID subsystem of the IOC that 8040 * the host system is shutting down. 8041 * 8042 * Return nothing. 8043 */ 8044 static void 8045 _scsih_ir_shutdown(struct MPT3SAS_ADAPTER *ioc) 8046 { 8047 Mpi2RaidActionRequest_t *mpi_request; 8048 Mpi2RaidActionReply_t *mpi_reply; 8049 u16 smid; 8050 8051 /* is IR firmware build loaded ? */ 8052 if (!ioc->ir_firmware) 8053 return; 8054 8055 /* are there any volumes ? */ 8056 if (list_empty(&ioc->raid_device_list)) 8057 return; 8058 8059 mutex_lock(&ioc->scsih_cmds.mutex); 8060 8061 if (ioc->scsih_cmds.status != MPT3_CMD_NOT_USED) { 8062 pr_err(MPT3SAS_FMT "%s: scsih_cmd in use\n", 8063 ioc->name, __func__); 8064 goto out; 8065 } 8066 ioc->scsih_cmds.status = MPT3_CMD_PENDING; 8067 8068 smid = mpt3sas_base_get_smid(ioc, ioc->scsih_cb_idx); 8069 if (!smid) { 8070 pr_err(MPT3SAS_FMT "%s: failed obtaining a smid\n", 8071 ioc->name, __func__); 8072 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 8073 goto out; 8074 } 8075 8076 mpi_request = mpt3sas_base_get_msg_frame(ioc, smid); 8077 ioc->scsih_cmds.smid = smid; 8078 memset(mpi_request, 0, sizeof(Mpi2RaidActionRequest_t)); 8079 8080 mpi_request->Function = MPI2_FUNCTION_RAID_ACTION; 8081 mpi_request->Action = MPI2_RAID_ACTION_SYSTEM_SHUTDOWN_INITIATED; 8082 8083 if (!ioc->hide_ir_msg) 8084 pr_info(MPT3SAS_FMT "IR shutdown (sending)\n", ioc->name); 8085 init_completion(&ioc->scsih_cmds.done); 8086 mpt3sas_base_put_smid_default(ioc, smid); 8087 wait_for_completion_timeout(&ioc->scsih_cmds.done, 10*HZ); 8088 8089 if (!(ioc->scsih_cmds.status & MPT3_CMD_COMPLETE)) { 8090 pr_err(MPT3SAS_FMT "%s: timeout\n", 8091 ioc->name, __func__); 8092 goto out; 8093 } 8094 8095 if (ioc->scsih_cmds.status & MPT3_CMD_REPLY_VALID) { 8096 mpi_reply = ioc->scsih_cmds.reply; 8097 if (!ioc->hide_ir_msg) 8098 pr_info(MPT3SAS_FMT "IR shutdown " 8099 "(complete): ioc_status(0x%04x), loginfo(0x%08x)\n", 8100 ioc->name, le16_to_cpu(mpi_reply->IOCStatus), 8101 le32_to_cpu(mpi_reply->IOCLogInfo)); 8102 } 8103 8104 out: 8105 ioc->scsih_cmds.status = MPT3_CMD_NOT_USED; 8106 mutex_unlock(&ioc->scsih_cmds.mutex); 8107 } 8108 8109 /** 8110 * scsih_remove - detach and remove add host 8111 * @pdev: PCI device struct 8112 * 8113 * Routine called when unloading the driver. 8114 * Return nothing. 8115 */ 8116 void scsih_remove(struct pci_dev *pdev) 8117 { 8118 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8119 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8120 struct _sas_port *mpt3sas_port, *next_port; 8121 struct _raid_device *raid_device, *next; 8122 struct MPT3SAS_TARGET *sas_target_priv_data; 8123 struct workqueue_struct *wq; 8124 unsigned long flags; 8125 8126 ioc->remove_host = 1; 8127 _scsih_fw_event_cleanup_queue(ioc); 8128 8129 spin_lock_irqsave(&ioc->fw_event_lock, flags); 8130 wq = ioc->firmware_event_thread; 8131 ioc->firmware_event_thread = NULL; 8132 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 8133 if (wq) 8134 destroy_workqueue(wq); 8135 8136 /* release all the volumes */ 8137 _scsih_ir_shutdown(ioc); 8138 list_for_each_entry_safe(raid_device, next, &ioc->raid_device_list, 8139 list) { 8140 if (raid_device->starget) { 8141 sas_target_priv_data = 8142 raid_device->starget->hostdata; 8143 sas_target_priv_data->deleted = 1; 8144 scsi_remove_target(&raid_device->starget->dev); 8145 } 8146 pr_info(MPT3SAS_FMT "removing handle(0x%04x), wwid(0x%016llx)\n", 8147 ioc->name, raid_device->handle, 8148 (unsigned long long) raid_device->wwid); 8149 _scsih_raid_device_remove(ioc, raid_device); 8150 } 8151 8152 /* free ports attached to the sas_host */ 8153 list_for_each_entry_safe(mpt3sas_port, next_port, 8154 &ioc->sas_hba.sas_port_list, port_list) { 8155 if (mpt3sas_port->remote_identify.device_type == 8156 SAS_END_DEVICE) 8157 mpt3sas_device_remove_by_sas_address(ioc, 8158 mpt3sas_port->remote_identify.sas_address); 8159 else if (mpt3sas_port->remote_identify.device_type == 8160 SAS_EDGE_EXPANDER_DEVICE || 8161 mpt3sas_port->remote_identify.device_type == 8162 SAS_FANOUT_EXPANDER_DEVICE) 8163 mpt3sas_expander_remove(ioc, 8164 mpt3sas_port->remote_identify.sas_address); 8165 } 8166 8167 /* free phys attached to the sas_host */ 8168 if (ioc->sas_hba.num_phys) { 8169 kfree(ioc->sas_hba.phy); 8170 ioc->sas_hba.phy = NULL; 8171 ioc->sas_hba.num_phys = 0; 8172 } 8173 8174 sas_remove_host(shost); 8175 scsi_remove_host(shost); 8176 mpt3sas_base_detach(ioc); 8177 spin_lock(&gioc_lock); 8178 list_del(&ioc->list); 8179 spin_unlock(&gioc_lock); 8180 scsi_host_put(shost); 8181 } 8182 8183 /** 8184 * scsih_shutdown - routine call during system shutdown 8185 * @pdev: PCI device struct 8186 * 8187 * Return nothing. 8188 */ 8189 void 8190 scsih_shutdown(struct pci_dev *pdev) 8191 { 8192 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8193 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8194 struct workqueue_struct *wq; 8195 unsigned long flags; 8196 8197 ioc->remove_host = 1; 8198 _scsih_fw_event_cleanup_queue(ioc); 8199 8200 spin_lock_irqsave(&ioc->fw_event_lock, flags); 8201 wq = ioc->firmware_event_thread; 8202 ioc->firmware_event_thread = NULL; 8203 spin_unlock_irqrestore(&ioc->fw_event_lock, flags); 8204 if (wq) 8205 destroy_workqueue(wq); 8206 8207 _scsih_ir_shutdown(ioc); 8208 mpt3sas_base_detach(ioc); 8209 } 8210 8211 8212 /** 8213 * _scsih_probe_boot_devices - reports 1st device 8214 * @ioc: per adapter object 8215 * 8216 * If specified in bios page 2, this routine reports the 1st 8217 * device scsi-ml or sas transport for persistent boot device 8218 * purposes. Please refer to function _scsih_determine_boot_device() 8219 */ 8220 static void 8221 _scsih_probe_boot_devices(struct MPT3SAS_ADAPTER *ioc) 8222 { 8223 u8 is_raid; 8224 void *device; 8225 struct _sas_device *sas_device; 8226 struct _raid_device *raid_device; 8227 u16 handle; 8228 u64 sas_address_parent; 8229 u64 sas_address; 8230 unsigned long flags; 8231 int rc; 8232 8233 /* no Bios, return immediately */ 8234 if (!ioc->bios_pg3.BiosVersion) 8235 return; 8236 8237 device = NULL; 8238 is_raid = 0; 8239 if (ioc->req_boot_device.device) { 8240 device = ioc->req_boot_device.device; 8241 is_raid = ioc->req_boot_device.is_raid; 8242 } else if (ioc->req_alt_boot_device.device) { 8243 device = ioc->req_alt_boot_device.device; 8244 is_raid = ioc->req_alt_boot_device.is_raid; 8245 } else if (ioc->current_boot_device.device) { 8246 device = ioc->current_boot_device.device; 8247 is_raid = ioc->current_boot_device.is_raid; 8248 } 8249 8250 if (!device) 8251 return; 8252 8253 if (is_raid) { 8254 raid_device = device; 8255 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 8256 raid_device->id, 0); 8257 if (rc) 8258 _scsih_raid_device_remove(ioc, raid_device); 8259 } else { 8260 spin_lock_irqsave(&ioc->sas_device_lock, flags); 8261 sas_device = device; 8262 handle = sas_device->handle; 8263 sas_address_parent = sas_device->sas_address_parent; 8264 sas_address = sas_device->sas_address; 8265 list_move_tail(&sas_device->list, &ioc->sas_device_list); 8266 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 8267 8268 if (ioc->hide_drives) 8269 return; 8270 if (!mpt3sas_transport_port_add(ioc, handle, 8271 sas_address_parent)) { 8272 _scsih_sas_device_remove(ioc, sas_device); 8273 } else if (!sas_device->starget) { 8274 if (!ioc->is_driver_loading) { 8275 mpt3sas_transport_port_remove(ioc, 8276 sas_address, 8277 sas_address_parent); 8278 _scsih_sas_device_remove(ioc, sas_device); 8279 } 8280 } 8281 } 8282 } 8283 8284 /** 8285 * _scsih_probe_raid - reporting raid volumes to scsi-ml 8286 * @ioc: per adapter object 8287 * 8288 * Called during initial loading of the driver. 8289 */ 8290 static void 8291 _scsih_probe_raid(struct MPT3SAS_ADAPTER *ioc) 8292 { 8293 struct _raid_device *raid_device, *raid_next; 8294 int rc; 8295 8296 list_for_each_entry_safe(raid_device, raid_next, 8297 &ioc->raid_device_list, list) { 8298 if (raid_device->starget) 8299 continue; 8300 rc = scsi_add_device(ioc->shost, RAID_CHANNEL, 8301 raid_device->id, 0); 8302 if (rc) 8303 _scsih_raid_device_remove(ioc, raid_device); 8304 } 8305 } 8306 8307 static struct _sas_device *get_next_sas_device(struct MPT3SAS_ADAPTER *ioc) 8308 { 8309 struct _sas_device *sas_device = NULL; 8310 unsigned long flags; 8311 8312 spin_lock_irqsave(&ioc->sas_device_lock, flags); 8313 if (!list_empty(&ioc->sas_device_init_list)) { 8314 sas_device = list_first_entry(&ioc->sas_device_init_list, 8315 struct _sas_device, list); 8316 sas_device_get(sas_device); 8317 } 8318 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 8319 8320 return sas_device; 8321 } 8322 8323 static void sas_device_make_active(struct MPT3SAS_ADAPTER *ioc, 8324 struct _sas_device *sas_device) 8325 { 8326 unsigned long flags; 8327 8328 spin_lock_irqsave(&ioc->sas_device_lock, flags); 8329 8330 /* 8331 * Since we dropped the lock during the call to port_add(), we need to 8332 * be careful here that somebody else didn't move or delete this item 8333 * while we were busy with other things. 8334 * 8335 * If it was on the list, we need a put() for the reference the list 8336 * had. Either way, we need a get() for the destination list. 8337 */ 8338 if (!list_empty(&sas_device->list)) { 8339 list_del_init(&sas_device->list); 8340 sas_device_put(sas_device); 8341 } 8342 8343 sas_device_get(sas_device); 8344 list_add_tail(&sas_device->list, &ioc->sas_device_list); 8345 8346 spin_unlock_irqrestore(&ioc->sas_device_lock, flags); 8347 } 8348 8349 /** 8350 * _scsih_probe_sas - reporting sas devices to sas transport 8351 * @ioc: per adapter object 8352 * 8353 * Called during initial loading of the driver. 8354 */ 8355 static void 8356 _scsih_probe_sas(struct MPT3SAS_ADAPTER *ioc) 8357 { 8358 struct _sas_device *sas_device; 8359 8360 if (ioc->hide_drives) 8361 return; 8362 8363 while ((sas_device = get_next_sas_device(ioc))) { 8364 if (!mpt3sas_transport_port_add(ioc, sas_device->handle, 8365 sas_device->sas_address_parent)) { 8366 _scsih_sas_device_remove(ioc, sas_device); 8367 sas_device_put(sas_device); 8368 continue; 8369 } else if (!sas_device->starget) { 8370 /* 8371 * When asyn scanning is enabled, its not possible to 8372 * remove devices while scanning is turned on due to an 8373 * oops in scsi_sysfs_add_sdev()->add_device()-> 8374 * sysfs_addrm_start() 8375 */ 8376 if (!ioc->is_driver_loading) { 8377 mpt3sas_transport_port_remove(ioc, 8378 sas_device->sas_address, 8379 sas_device->sas_address_parent); 8380 _scsih_sas_device_remove(ioc, sas_device); 8381 sas_device_put(sas_device); 8382 continue; 8383 } 8384 } 8385 sas_device_make_active(ioc, sas_device); 8386 sas_device_put(sas_device); 8387 } 8388 } 8389 8390 /** 8391 * _scsih_probe_devices - probing for devices 8392 * @ioc: per adapter object 8393 * 8394 * Called during initial loading of the driver. 8395 */ 8396 static void 8397 _scsih_probe_devices(struct MPT3SAS_ADAPTER *ioc) 8398 { 8399 u16 volume_mapping_flags; 8400 8401 if (!(ioc->facts.ProtocolFlags & MPI2_IOCFACTS_PROTOCOL_SCSI_INITIATOR)) 8402 return; /* return when IOC doesn't support initiator mode */ 8403 8404 _scsih_probe_boot_devices(ioc); 8405 8406 if (ioc->ir_firmware) { 8407 volume_mapping_flags = 8408 le16_to_cpu(ioc->ioc_pg8.IRVolumeMappingFlags) & 8409 MPI2_IOCPAGE8_IRFLAGS_MASK_VOLUME_MAPPING_MODE; 8410 if (volume_mapping_flags == 8411 MPI2_IOCPAGE8_IRFLAGS_LOW_VOLUME_MAPPING) { 8412 _scsih_probe_raid(ioc); 8413 _scsih_probe_sas(ioc); 8414 } else { 8415 _scsih_probe_sas(ioc); 8416 _scsih_probe_raid(ioc); 8417 } 8418 } else 8419 _scsih_probe_sas(ioc); 8420 } 8421 8422 /** 8423 * scsih_scan_start - scsi lld callback for .scan_start 8424 * @shost: SCSI host pointer 8425 * 8426 * The shost has the ability to discover targets on its own instead 8427 * of scanning the entire bus. In our implemention, we will kick off 8428 * firmware discovery. 8429 */ 8430 void 8431 scsih_scan_start(struct Scsi_Host *shost) 8432 { 8433 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8434 int rc; 8435 if (diag_buffer_enable != -1 && diag_buffer_enable != 0) 8436 mpt3sas_enable_diag_buffer(ioc, diag_buffer_enable); 8437 8438 if (disable_discovery > 0) 8439 return; 8440 8441 ioc->start_scan = 1; 8442 rc = mpt3sas_port_enable(ioc); 8443 8444 if (rc != 0) 8445 pr_info(MPT3SAS_FMT "port enable: FAILED\n", ioc->name); 8446 } 8447 8448 /** 8449 * scsih_scan_finished - scsi lld callback for .scan_finished 8450 * @shost: SCSI host pointer 8451 * @time: elapsed time of the scan in jiffies 8452 * 8453 * This function will be called periodicallyn until it returns 1 with the 8454 * scsi_host and the elapsed time of the scan in jiffies. In our implemention, 8455 * we wait for firmware discovery to complete, then return 1. 8456 */ 8457 int 8458 scsih_scan_finished(struct Scsi_Host *shost, unsigned long time) 8459 { 8460 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8461 8462 if (disable_discovery > 0) { 8463 ioc->is_driver_loading = 0; 8464 ioc->wait_for_discovery_to_complete = 0; 8465 return 1; 8466 } 8467 8468 if (time >= (300 * HZ)) { 8469 ioc->base_cmds.status = MPT3_CMD_NOT_USED; 8470 pr_info(MPT3SAS_FMT 8471 "port enable: FAILED with timeout (timeout=300s)\n", 8472 ioc->name); 8473 ioc->is_driver_loading = 0; 8474 return 1; 8475 } 8476 8477 if (ioc->start_scan) 8478 return 0; 8479 8480 if (ioc->start_scan_failed) { 8481 pr_info(MPT3SAS_FMT 8482 "port enable: FAILED with (ioc_status=0x%08x)\n", 8483 ioc->name, ioc->start_scan_failed); 8484 ioc->is_driver_loading = 0; 8485 ioc->wait_for_discovery_to_complete = 0; 8486 ioc->remove_host = 1; 8487 return 1; 8488 } 8489 8490 pr_info(MPT3SAS_FMT "port enable: SUCCESS\n", ioc->name); 8491 ioc->base_cmds.status = MPT3_CMD_NOT_USED; 8492 8493 if (ioc->wait_for_discovery_to_complete) { 8494 ioc->wait_for_discovery_to_complete = 0; 8495 _scsih_probe_devices(ioc); 8496 } 8497 mpt3sas_base_start_watchdog(ioc); 8498 ioc->is_driver_loading = 0; 8499 return 1; 8500 } 8501 8502 /* shost template for SAS 2.0 HBA devices */ 8503 static struct scsi_host_template mpt2sas_driver_template = { 8504 .module = THIS_MODULE, 8505 .name = "Fusion MPT SAS Host", 8506 .proc_name = MPT2SAS_DRIVER_NAME, 8507 .queuecommand = scsih_qcmd, 8508 .target_alloc = scsih_target_alloc, 8509 .slave_alloc = scsih_slave_alloc, 8510 .slave_configure = scsih_slave_configure, 8511 .target_destroy = scsih_target_destroy, 8512 .slave_destroy = scsih_slave_destroy, 8513 .scan_finished = scsih_scan_finished, 8514 .scan_start = scsih_scan_start, 8515 .change_queue_depth = scsih_change_queue_depth, 8516 .eh_abort_handler = scsih_abort, 8517 .eh_device_reset_handler = scsih_dev_reset, 8518 .eh_target_reset_handler = scsih_target_reset, 8519 .eh_host_reset_handler = scsih_host_reset, 8520 .bios_param = scsih_bios_param, 8521 .can_queue = 1, 8522 .this_id = -1, 8523 .sg_tablesize = MPT2SAS_SG_DEPTH, 8524 .max_sectors = 32767, 8525 .cmd_per_lun = 7, 8526 .use_clustering = ENABLE_CLUSTERING, 8527 .shost_attrs = mpt3sas_host_attrs, 8528 .sdev_attrs = mpt3sas_dev_attrs, 8529 .track_queue_depth = 1, 8530 }; 8531 8532 /* raid transport support for SAS 2.0 HBA devices */ 8533 static struct raid_function_template mpt2sas_raid_functions = { 8534 .cookie = &mpt2sas_driver_template, 8535 .is_raid = scsih_is_raid, 8536 .get_resync = scsih_get_resync, 8537 .get_state = scsih_get_state, 8538 }; 8539 8540 /* shost template for SAS 3.0 HBA devices */ 8541 static struct scsi_host_template mpt3sas_driver_template = { 8542 .module = THIS_MODULE, 8543 .name = "Fusion MPT SAS Host", 8544 .proc_name = MPT3SAS_DRIVER_NAME, 8545 .queuecommand = scsih_qcmd, 8546 .target_alloc = scsih_target_alloc, 8547 .slave_alloc = scsih_slave_alloc, 8548 .slave_configure = scsih_slave_configure, 8549 .target_destroy = scsih_target_destroy, 8550 .slave_destroy = scsih_slave_destroy, 8551 .scan_finished = scsih_scan_finished, 8552 .scan_start = scsih_scan_start, 8553 .change_queue_depth = scsih_change_queue_depth, 8554 .eh_abort_handler = scsih_abort, 8555 .eh_device_reset_handler = scsih_dev_reset, 8556 .eh_target_reset_handler = scsih_target_reset, 8557 .eh_host_reset_handler = scsih_host_reset, 8558 .bios_param = scsih_bios_param, 8559 .can_queue = 1, 8560 .this_id = -1, 8561 .sg_tablesize = MPT3SAS_SG_DEPTH, 8562 .max_sectors = 32767, 8563 .cmd_per_lun = 7, 8564 .use_clustering = ENABLE_CLUSTERING, 8565 .shost_attrs = mpt3sas_host_attrs, 8566 .sdev_attrs = mpt3sas_dev_attrs, 8567 .track_queue_depth = 1, 8568 }; 8569 8570 /* raid transport support for SAS 3.0 HBA devices */ 8571 static struct raid_function_template mpt3sas_raid_functions = { 8572 .cookie = &mpt3sas_driver_template, 8573 .is_raid = scsih_is_raid, 8574 .get_resync = scsih_get_resync, 8575 .get_state = scsih_get_state, 8576 }; 8577 8578 /** 8579 * _scsih_determine_hba_mpi_version - determine in which MPI version class 8580 * this device belongs to. 8581 * @pdev: PCI device struct 8582 * 8583 * return MPI2_VERSION for SAS 2.0 HBA devices, 8584 * MPI25_VERSION for SAS 3.0 HBA devices, and 8585 * MPI26 VERSION for Cutlass & Invader SAS 3.0 HBA devices 8586 */ 8587 u16 8588 _scsih_determine_hba_mpi_version(struct pci_dev *pdev) 8589 { 8590 8591 switch (pdev->device) { 8592 case MPI2_MFGPAGE_DEVID_SSS6200: 8593 case MPI2_MFGPAGE_DEVID_SAS2004: 8594 case MPI2_MFGPAGE_DEVID_SAS2008: 8595 case MPI2_MFGPAGE_DEVID_SAS2108_1: 8596 case MPI2_MFGPAGE_DEVID_SAS2108_2: 8597 case MPI2_MFGPAGE_DEVID_SAS2108_3: 8598 case MPI2_MFGPAGE_DEVID_SAS2116_1: 8599 case MPI2_MFGPAGE_DEVID_SAS2116_2: 8600 case MPI2_MFGPAGE_DEVID_SAS2208_1: 8601 case MPI2_MFGPAGE_DEVID_SAS2208_2: 8602 case MPI2_MFGPAGE_DEVID_SAS2208_3: 8603 case MPI2_MFGPAGE_DEVID_SAS2208_4: 8604 case MPI2_MFGPAGE_DEVID_SAS2208_5: 8605 case MPI2_MFGPAGE_DEVID_SAS2208_6: 8606 case MPI2_MFGPAGE_DEVID_SAS2308_1: 8607 case MPI2_MFGPAGE_DEVID_SAS2308_2: 8608 case MPI2_MFGPAGE_DEVID_SAS2308_3: 8609 return MPI2_VERSION; 8610 case MPI25_MFGPAGE_DEVID_SAS3004: 8611 case MPI25_MFGPAGE_DEVID_SAS3008: 8612 case MPI25_MFGPAGE_DEVID_SAS3108_1: 8613 case MPI25_MFGPAGE_DEVID_SAS3108_2: 8614 case MPI25_MFGPAGE_DEVID_SAS3108_5: 8615 case MPI25_MFGPAGE_DEVID_SAS3108_6: 8616 return MPI25_VERSION; 8617 case MPI26_MFGPAGE_DEVID_SAS3216: 8618 case MPI26_MFGPAGE_DEVID_SAS3224: 8619 case MPI26_MFGPAGE_DEVID_SAS3316_1: 8620 case MPI26_MFGPAGE_DEVID_SAS3316_2: 8621 case MPI26_MFGPAGE_DEVID_SAS3316_3: 8622 case MPI26_MFGPAGE_DEVID_SAS3316_4: 8623 case MPI26_MFGPAGE_DEVID_SAS3324_1: 8624 case MPI26_MFGPAGE_DEVID_SAS3324_2: 8625 case MPI26_MFGPAGE_DEVID_SAS3324_3: 8626 case MPI26_MFGPAGE_DEVID_SAS3324_4: 8627 return MPI26_VERSION; 8628 } 8629 return 0; 8630 } 8631 8632 /** 8633 * _scsih_probe - attach and add scsi host 8634 * @pdev: PCI device struct 8635 * @id: pci device id 8636 * 8637 * Returns 0 success, anything else error. 8638 */ 8639 int 8640 _scsih_probe(struct pci_dev *pdev, const struct pci_device_id *id) 8641 { 8642 struct MPT3SAS_ADAPTER *ioc; 8643 struct Scsi_Host *shost = NULL; 8644 int rv; 8645 u16 hba_mpi_version; 8646 8647 /* Determine in which MPI version class this pci device belongs */ 8648 hba_mpi_version = _scsih_determine_hba_mpi_version(pdev); 8649 if (hba_mpi_version == 0) 8650 return -ENODEV; 8651 8652 /* Enumerate only SAS 2.0 HBA's if hbas_to_enumerate is one, 8653 * for other generation HBA's return with -ENODEV 8654 */ 8655 if ((hbas_to_enumerate == 1) && (hba_mpi_version != MPI2_VERSION)) 8656 return -ENODEV; 8657 8658 /* Enumerate only SAS 3.0 HBA's if hbas_to_enumerate is two, 8659 * for other generation HBA's return with -ENODEV 8660 */ 8661 if ((hbas_to_enumerate == 2) && (!(hba_mpi_version == MPI25_VERSION 8662 || hba_mpi_version == MPI26_VERSION))) 8663 return -ENODEV; 8664 8665 switch (hba_mpi_version) { 8666 case MPI2_VERSION: 8667 /* Use mpt2sas driver host template for SAS 2.0 HBA's */ 8668 shost = scsi_host_alloc(&mpt2sas_driver_template, 8669 sizeof(struct MPT3SAS_ADAPTER)); 8670 if (!shost) 8671 return -ENODEV; 8672 ioc = shost_priv(shost); 8673 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER)); 8674 ioc->hba_mpi_version_belonged = hba_mpi_version; 8675 ioc->id = mpt2_ids++; 8676 sprintf(ioc->driver_name, "%s", MPT2SAS_DRIVER_NAME); 8677 if (pdev->device == MPI2_MFGPAGE_DEVID_SSS6200) { 8678 ioc->is_warpdrive = 1; 8679 ioc->hide_ir_msg = 1; 8680 } else 8681 ioc->mfg_pg10_hide_flag = MFG_PAGE10_EXPOSE_ALL_DISKS; 8682 break; 8683 case MPI25_VERSION: 8684 case MPI26_VERSION: 8685 /* Use mpt3sas driver host template for SAS 3.0 HBA's */ 8686 shost = scsi_host_alloc(&mpt3sas_driver_template, 8687 sizeof(struct MPT3SAS_ADAPTER)); 8688 if (!shost) 8689 return -ENODEV; 8690 ioc = shost_priv(shost); 8691 memset(ioc, 0, sizeof(struct MPT3SAS_ADAPTER)); 8692 ioc->hba_mpi_version_belonged = hba_mpi_version; 8693 ioc->id = mpt3_ids++; 8694 sprintf(ioc->driver_name, "%s", MPT3SAS_DRIVER_NAME); 8695 if ((ioc->hba_mpi_version_belonged == MPI25_VERSION && 8696 pdev->revision >= SAS3_PCI_DEVICE_C0_REVISION) || 8697 (ioc->hba_mpi_version_belonged == MPI26_VERSION)) 8698 ioc->msix96_vector = 1; 8699 break; 8700 default: 8701 return -ENODEV; 8702 } 8703 8704 INIT_LIST_HEAD(&ioc->list); 8705 spin_lock(&gioc_lock); 8706 list_add_tail(&ioc->list, &mpt3sas_ioc_list); 8707 spin_unlock(&gioc_lock); 8708 ioc->shost = shost; 8709 ioc->pdev = pdev; 8710 ioc->scsi_io_cb_idx = scsi_io_cb_idx; 8711 ioc->tm_cb_idx = tm_cb_idx; 8712 ioc->ctl_cb_idx = ctl_cb_idx; 8713 ioc->base_cb_idx = base_cb_idx; 8714 ioc->port_enable_cb_idx = port_enable_cb_idx; 8715 ioc->transport_cb_idx = transport_cb_idx; 8716 ioc->scsih_cb_idx = scsih_cb_idx; 8717 ioc->config_cb_idx = config_cb_idx; 8718 ioc->tm_tr_cb_idx = tm_tr_cb_idx; 8719 ioc->tm_tr_volume_cb_idx = tm_tr_volume_cb_idx; 8720 ioc->tm_sas_control_cb_idx = tm_sas_control_cb_idx; 8721 ioc->logging_level = logging_level; 8722 ioc->schedule_dead_ioc_flush_running_cmds = &_scsih_flush_running_cmds; 8723 /* misc semaphores and spin locks */ 8724 mutex_init(&ioc->reset_in_progress_mutex); 8725 /* initializing pci_access_mutex lock */ 8726 mutex_init(&ioc->pci_access_mutex); 8727 spin_lock_init(&ioc->ioc_reset_in_progress_lock); 8728 spin_lock_init(&ioc->scsi_lookup_lock); 8729 spin_lock_init(&ioc->sas_device_lock); 8730 spin_lock_init(&ioc->sas_node_lock); 8731 spin_lock_init(&ioc->fw_event_lock); 8732 spin_lock_init(&ioc->raid_device_lock); 8733 spin_lock_init(&ioc->diag_trigger_lock); 8734 8735 INIT_LIST_HEAD(&ioc->sas_device_list); 8736 INIT_LIST_HEAD(&ioc->sas_device_init_list); 8737 INIT_LIST_HEAD(&ioc->sas_expander_list); 8738 INIT_LIST_HEAD(&ioc->fw_event_list); 8739 INIT_LIST_HEAD(&ioc->raid_device_list); 8740 INIT_LIST_HEAD(&ioc->sas_hba.sas_port_list); 8741 INIT_LIST_HEAD(&ioc->delayed_tr_list); 8742 INIT_LIST_HEAD(&ioc->delayed_sc_list); 8743 INIT_LIST_HEAD(&ioc->delayed_event_ack_list); 8744 INIT_LIST_HEAD(&ioc->delayed_tr_volume_list); 8745 INIT_LIST_HEAD(&ioc->reply_queue_list); 8746 8747 sprintf(ioc->name, "%s_cm%d", ioc->driver_name, ioc->id); 8748 8749 /* init shost parameters */ 8750 shost->max_cmd_len = 32; 8751 shost->max_lun = max_lun; 8752 shost->transportt = mpt3sas_transport_template; 8753 shost->unique_id = ioc->id; 8754 8755 if (max_sectors != 0xFFFF) { 8756 if (max_sectors < 64) { 8757 shost->max_sectors = 64; 8758 pr_warn(MPT3SAS_FMT "Invalid value %d passed " \ 8759 "for max_sectors, range is 64 to 32767. Assigning " 8760 "value of 64.\n", ioc->name, max_sectors); 8761 } else if (max_sectors > 32767) { 8762 shost->max_sectors = 32767; 8763 pr_warn(MPT3SAS_FMT "Invalid value %d passed " \ 8764 "for max_sectors, range is 64 to 32767. Assigning " 8765 "default value of 32767.\n", ioc->name, 8766 max_sectors); 8767 } else { 8768 shost->max_sectors = max_sectors & 0xFFFE; 8769 pr_info(MPT3SAS_FMT 8770 "The max_sectors value is set to %d\n", 8771 ioc->name, shost->max_sectors); 8772 } 8773 } 8774 8775 /* register EEDP capabilities with SCSI layer */ 8776 if (prot_mask > 0) 8777 scsi_host_set_prot(shost, prot_mask); 8778 else 8779 scsi_host_set_prot(shost, SHOST_DIF_TYPE1_PROTECTION 8780 | SHOST_DIF_TYPE2_PROTECTION 8781 | SHOST_DIF_TYPE3_PROTECTION); 8782 8783 scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC); 8784 8785 /* event thread */ 8786 snprintf(ioc->firmware_event_name, sizeof(ioc->firmware_event_name), 8787 "fw_event_%s%d", ioc->driver_name, ioc->id); 8788 ioc->firmware_event_thread = alloc_ordered_workqueue( 8789 ioc->firmware_event_name, WQ_MEM_RECLAIM); 8790 if (!ioc->firmware_event_thread) { 8791 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 8792 ioc->name, __FILE__, __LINE__, __func__); 8793 rv = -ENODEV; 8794 goto out_thread_fail; 8795 } 8796 8797 ioc->is_driver_loading = 1; 8798 if ((mpt3sas_base_attach(ioc))) { 8799 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 8800 ioc->name, __FILE__, __LINE__, __func__); 8801 rv = -ENODEV; 8802 goto out_attach_fail; 8803 } 8804 8805 if (ioc->is_warpdrive) { 8806 if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_EXPOSE_ALL_DISKS) 8807 ioc->hide_drives = 0; 8808 else if (ioc->mfg_pg10_hide_flag == MFG_PAGE10_HIDE_ALL_DISKS) 8809 ioc->hide_drives = 1; 8810 else { 8811 if (mpt3sas_get_num_volumes(ioc)) 8812 ioc->hide_drives = 1; 8813 else 8814 ioc->hide_drives = 0; 8815 } 8816 } else 8817 ioc->hide_drives = 0; 8818 8819 rv = scsi_add_host(shost, &pdev->dev); 8820 if (rv) { 8821 pr_err(MPT3SAS_FMT "failure at %s:%d/%s()!\n", 8822 ioc->name, __FILE__, __LINE__, __func__); 8823 goto out_add_shost_fail; 8824 } 8825 8826 scsi_scan_host(shost); 8827 return 0; 8828 out_add_shost_fail: 8829 mpt3sas_base_detach(ioc); 8830 out_attach_fail: 8831 destroy_workqueue(ioc->firmware_event_thread); 8832 out_thread_fail: 8833 spin_lock(&gioc_lock); 8834 list_del(&ioc->list); 8835 spin_unlock(&gioc_lock); 8836 scsi_host_put(shost); 8837 return rv; 8838 } 8839 8840 #ifdef CONFIG_PM 8841 /** 8842 * scsih_suspend - power management suspend main entry point 8843 * @pdev: PCI device struct 8844 * @state: PM state change to (usually PCI_D3) 8845 * 8846 * Returns 0 success, anything else error. 8847 */ 8848 int 8849 scsih_suspend(struct pci_dev *pdev, pm_message_t state) 8850 { 8851 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8852 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8853 pci_power_t device_state; 8854 8855 mpt3sas_base_stop_watchdog(ioc); 8856 flush_scheduled_work(); 8857 scsi_block_requests(shost); 8858 device_state = pci_choose_state(pdev, state); 8859 pr_info(MPT3SAS_FMT 8860 "pdev=0x%p, slot=%s, entering operating state [D%d]\n", 8861 ioc->name, pdev, pci_name(pdev), device_state); 8862 8863 pci_save_state(pdev); 8864 mpt3sas_base_free_resources(ioc); 8865 pci_set_power_state(pdev, device_state); 8866 return 0; 8867 } 8868 8869 /** 8870 * scsih_resume - power management resume main entry point 8871 * @pdev: PCI device struct 8872 * 8873 * Returns 0 success, anything else error. 8874 */ 8875 int 8876 scsih_resume(struct pci_dev *pdev) 8877 { 8878 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8879 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8880 pci_power_t device_state = pdev->current_state; 8881 int r; 8882 8883 pr_info(MPT3SAS_FMT 8884 "pdev=0x%p, slot=%s, previous operating state [D%d]\n", 8885 ioc->name, pdev, pci_name(pdev), device_state); 8886 8887 pci_set_power_state(pdev, PCI_D0); 8888 pci_enable_wake(pdev, PCI_D0, 0); 8889 pci_restore_state(pdev); 8890 ioc->pdev = pdev; 8891 r = mpt3sas_base_map_resources(ioc); 8892 if (r) 8893 return r; 8894 8895 mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, SOFT_RESET); 8896 scsi_unblock_requests(shost); 8897 mpt3sas_base_start_watchdog(ioc); 8898 return 0; 8899 } 8900 #endif /* CONFIG_PM */ 8901 8902 /** 8903 * scsih_pci_error_detected - Called when a PCI error is detected. 8904 * @pdev: PCI device struct 8905 * @state: PCI channel state 8906 * 8907 * Description: Called when a PCI error is detected. 8908 * 8909 * Return value: 8910 * PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT 8911 */ 8912 pci_ers_result_t 8913 scsih_pci_error_detected(struct pci_dev *pdev, pci_channel_state_t state) 8914 { 8915 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8916 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8917 8918 pr_info(MPT3SAS_FMT "PCI error: detected callback, state(%d)!!\n", 8919 ioc->name, state); 8920 8921 switch (state) { 8922 case pci_channel_io_normal: 8923 return PCI_ERS_RESULT_CAN_RECOVER; 8924 case pci_channel_io_frozen: 8925 /* Fatal error, prepare for slot reset */ 8926 ioc->pci_error_recovery = 1; 8927 scsi_block_requests(ioc->shost); 8928 mpt3sas_base_stop_watchdog(ioc); 8929 mpt3sas_base_free_resources(ioc); 8930 return PCI_ERS_RESULT_NEED_RESET; 8931 case pci_channel_io_perm_failure: 8932 /* Permanent error, prepare for device removal */ 8933 ioc->pci_error_recovery = 1; 8934 mpt3sas_base_stop_watchdog(ioc); 8935 _scsih_flush_running_cmds(ioc); 8936 return PCI_ERS_RESULT_DISCONNECT; 8937 } 8938 return PCI_ERS_RESULT_NEED_RESET; 8939 } 8940 8941 /** 8942 * scsih_pci_slot_reset - Called when PCI slot has been reset. 8943 * @pdev: PCI device struct 8944 * 8945 * Description: This routine is called by the pci error recovery 8946 * code after the PCI slot has been reset, just before we 8947 * should resume normal operations. 8948 */ 8949 pci_ers_result_t 8950 scsih_pci_slot_reset(struct pci_dev *pdev) 8951 { 8952 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8953 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8954 int rc; 8955 8956 pr_info(MPT3SAS_FMT "PCI error: slot reset callback!!\n", 8957 ioc->name); 8958 8959 ioc->pci_error_recovery = 0; 8960 ioc->pdev = pdev; 8961 pci_restore_state(pdev); 8962 rc = mpt3sas_base_map_resources(ioc); 8963 if (rc) 8964 return PCI_ERS_RESULT_DISCONNECT; 8965 8966 rc = mpt3sas_base_hard_reset_handler(ioc, CAN_SLEEP, 8967 FORCE_BIG_HAMMER); 8968 8969 pr_warn(MPT3SAS_FMT "hard reset: %s\n", ioc->name, 8970 (rc == 0) ? "success" : "failed"); 8971 8972 if (!rc) 8973 return PCI_ERS_RESULT_RECOVERED; 8974 else 8975 return PCI_ERS_RESULT_DISCONNECT; 8976 } 8977 8978 /** 8979 * scsih_pci_resume() - resume normal ops after PCI reset 8980 * @pdev: pointer to PCI device 8981 * 8982 * Called when the error recovery driver tells us that its 8983 * OK to resume normal operation. Use completion to allow 8984 * halted scsi ops to resume. 8985 */ 8986 void 8987 scsih_pci_resume(struct pci_dev *pdev) 8988 { 8989 struct Scsi_Host *shost = pci_get_drvdata(pdev); 8990 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 8991 8992 pr_info(MPT3SAS_FMT "PCI error: resume callback!!\n", ioc->name); 8993 8994 pci_cleanup_aer_uncorrect_error_status(pdev); 8995 mpt3sas_base_start_watchdog(ioc); 8996 scsi_unblock_requests(ioc->shost); 8997 } 8998 8999 /** 9000 * scsih_pci_mmio_enabled - Enable MMIO and dump debug registers 9001 * @pdev: pointer to PCI device 9002 */ 9003 pci_ers_result_t 9004 scsih_pci_mmio_enabled(struct pci_dev *pdev) 9005 { 9006 struct Scsi_Host *shost = pci_get_drvdata(pdev); 9007 struct MPT3SAS_ADAPTER *ioc = shost_priv(shost); 9008 9009 pr_info(MPT3SAS_FMT "PCI error: mmio enabled callback!!\n", 9010 ioc->name); 9011 9012 /* TODO - dump whatever for debugging purposes */ 9013 9014 /* Request a slot reset. */ 9015 return PCI_ERS_RESULT_NEED_RESET; 9016 } 9017 9018 /* 9019 * The pci device ids are defined in mpi/mpi2_cnfg.h. 9020 */ 9021 static const struct pci_device_id mpt3sas_pci_table[] = { 9022 /* Spitfire ~ 2004 */ 9023 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2004, 9024 PCI_ANY_ID, PCI_ANY_ID }, 9025 /* Falcon ~ 2008 */ 9026 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2008, 9027 PCI_ANY_ID, PCI_ANY_ID }, 9028 /* Liberator ~ 2108 */ 9029 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_1, 9030 PCI_ANY_ID, PCI_ANY_ID }, 9031 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_2, 9032 PCI_ANY_ID, PCI_ANY_ID }, 9033 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2108_3, 9034 PCI_ANY_ID, PCI_ANY_ID }, 9035 /* Meteor ~ 2116 */ 9036 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_1, 9037 PCI_ANY_ID, PCI_ANY_ID }, 9038 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2116_2, 9039 PCI_ANY_ID, PCI_ANY_ID }, 9040 /* Thunderbolt ~ 2208 */ 9041 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_1, 9042 PCI_ANY_ID, PCI_ANY_ID }, 9043 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_2, 9044 PCI_ANY_ID, PCI_ANY_ID }, 9045 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_3, 9046 PCI_ANY_ID, PCI_ANY_ID }, 9047 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_4, 9048 PCI_ANY_ID, PCI_ANY_ID }, 9049 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_5, 9050 PCI_ANY_ID, PCI_ANY_ID }, 9051 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2208_6, 9052 PCI_ANY_ID, PCI_ANY_ID }, 9053 /* Mustang ~ 2308 */ 9054 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_1, 9055 PCI_ANY_ID, PCI_ANY_ID }, 9056 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_2, 9057 PCI_ANY_ID, PCI_ANY_ID }, 9058 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SAS2308_3, 9059 PCI_ANY_ID, PCI_ANY_ID }, 9060 /* SSS6200 */ 9061 { MPI2_MFGPAGE_VENDORID_LSI, MPI2_MFGPAGE_DEVID_SSS6200, 9062 PCI_ANY_ID, PCI_ANY_ID }, 9063 /* Fury ~ 3004 and 3008 */ 9064 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3004, 9065 PCI_ANY_ID, PCI_ANY_ID }, 9066 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3008, 9067 PCI_ANY_ID, PCI_ANY_ID }, 9068 /* Invader ~ 3108 */ 9069 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_1, 9070 PCI_ANY_ID, PCI_ANY_ID }, 9071 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_2, 9072 PCI_ANY_ID, PCI_ANY_ID }, 9073 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_5, 9074 PCI_ANY_ID, PCI_ANY_ID }, 9075 { MPI2_MFGPAGE_VENDORID_LSI, MPI25_MFGPAGE_DEVID_SAS3108_6, 9076 PCI_ANY_ID, PCI_ANY_ID }, 9077 /* Cutlass ~ 3216 and 3224 */ 9078 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3216, 9079 PCI_ANY_ID, PCI_ANY_ID }, 9080 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3224, 9081 PCI_ANY_ID, PCI_ANY_ID }, 9082 /* Intruder ~ 3316 and 3324 */ 9083 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_1, 9084 PCI_ANY_ID, PCI_ANY_ID }, 9085 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_2, 9086 PCI_ANY_ID, PCI_ANY_ID }, 9087 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_3, 9088 PCI_ANY_ID, PCI_ANY_ID }, 9089 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3316_4, 9090 PCI_ANY_ID, PCI_ANY_ID }, 9091 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_1, 9092 PCI_ANY_ID, PCI_ANY_ID }, 9093 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_2, 9094 PCI_ANY_ID, PCI_ANY_ID }, 9095 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_3, 9096 PCI_ANY_ID, PCI_ANY_ID }, 9097 { MPI2_MFGPAGE_VENDORID_LSI, MPI26_MFGPAGE_DEVID_SAS3324_4, 9098 PCI_ANY_ID, PCI_ANY_ID }, 9099 {0} /* Terminating entry */ 9100 }; 9101 MODULE_DEVICE_TABLE(pci, mpt3sas_pci_table); 9102 9103 static struct pci_error_handlers _mpt3sas_err_handler = { 9104 .error_detected = scsih_pci_error_detected, 9105 .mmio_enabled = scsih_pci_mmio_enabled, 9106 .slot_reset = scsih_pci_slot_reset, 9107 .resume = scsih_pci_resume, 9108 }; 9109 9110 static struct pci_driver mpt3sas_driver = { 9111 .name = MPT3SAS_DRIVER_NAME, 9112 .id_table = mpt3sas_pci_table, 9113 .probe = _scsih_probe, 9114 .remove = scsih_remove, 9115 .shutdown = scsih_shutdown, 9116 .err_handler = &_mpt3sas_err_handler, 9117 #ifdef CONFIG_PM 9118 .suspend = scsih_suspend, 9119 .resume = scsih_resume, 9120 #endif 9121 }; 9122 9123 /** 9124 * scsih_init - main entry point for this driver. 9125 * 9126 * Returns 0 success, anything else error. 9127 */ 9128 int 9129 scsih_init(void) 9130 { 9131 mpt2_ids = 0; 9132 mpt3_ids = 0; 9133 9134 mpt3sas_base_initialize_callback_handler(); 9135 9136 /* queuecommand callback hander */ 9137 scsi_io_cb_idx = mpt3sas_base_register_callback_handler(_scsih_io_done); 9138 9139 /* task managment callback handler */ 9140 tm_cb_idx = mpt3sas_base_register_callback_handler(_scsih_tm_done); 9141 9142 /* base internal commands callback handler */ 9143 base_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_base_done); 9144 port_enable_cb_idx = mpt3sas_base_register_callback_handler( 9145 mpt3sas_port_enable_done); 9146 9147 /* transport internal commands callback handler */ 9148 transport_cb_idx = mpt3sas_base_register_callback_handler( 9149 mpt3sas_transport_done); 9150 9151 /* scsih internal commands callback handler */ 9152 scsih_cb_idx = mpt3sas_base_register_callback_handler(_scsih_done); 9153 9154 /* configuration page API internal commands callback handler */ 9155 config_cb_idx = mpt3sas_base_register_callback_handler( 9156 mpt3sas_config_done); 9157 9158 /* ctl module callback handler */ 9159 ctl_cb_idx = mpt3sas_base_register_callback_handler(mpt3sas_ctl_done); 9160 9161 tm_tr_cb_idx = mpt3sas_base_register_callback_handler( 9162 _scsih_tm_tr_complete); 9163 9164 tm_tr_volume_cb_idx = mpt3sas_base_register_callback_handler( 9165 _scsih_tm_volume_tr_complete); 9166 9167 tm_sas_control_cb_idx = mpt3sas_base_register_callback_handler( 9168 _scsih_sas_control_complete); 9169 9170 return 0; 9171 } 9172 9173 /** 9174 * scsih_exit - exit point for this driver (when it is a module). 9175 * 9176 * Returns 0 success, anything else error. 9177 */ 9178 void 9179 scsih_exit(void) 9180 { 9181 9182 mpt3sas_base_release_callback_handler(scsi_io_cb_idx); 9183 mpt3sas_base_release_callback_handler(tm_cb_idx); 9184 mpt3sas_base_release_callback_handler(base_cb_idx); 9185 mpt3sas_base_release_callback_handler(port_enable_cb_idx); 9186 mpt3sas_base_release_callback_handler(transport_cb_idx); 9187 mpt3sas_base_release_callback_handler(scsih_cb_idx); 9188 mpt3sas_base_release_callback_handler(config_cb_idx); 9189 mpt3sas_base_release_callback_handler(ctl_cb_idx); 9190 9191 mpt3sas_base_release_callback_handler(tm_tr_cb_idx); 9192 mpt3sas_base_release_callback_handler(tm_tr_volume_cb_idx); 9193 mpt3sas_base_release_callback_handler(tm_sas_control_cb_idx); 9194 9195 /* raid transport support */ 9196 if (hbas_to_enumerate != 1) 9197 raid_class_release(mpt3sas_raid_template); 9198 if (hbas_to_enumerate != 2) 9199 raid_class_release(mpt2sas_raid_template); 9200 sas_release_transport(mpt3sas_transport_template); 9201 } 9202 9203 /** 9204 * _mpt3sas_init - main entry point for this driver. 9205 * 9206 * Returns 0 success, anything else error. 9207 */ 9208 static int __init 9209 _mpt3sas_init(void) 9210 { 9211 int error; 9212 9213 pr_info("%s version %s loaded\n", MPT3SAS_DRIVER_NAME, 9214 MPT3SAS_DRIVER_VERSION); 9215 9216 mpt3sas_transport_template = 9217 sas_attach_transport(&mpt3sas_transport_functions); 9218 if (!mpt3sas_transport_template) 9219 return -ENODEV; 9220 9221 /* No need attach mpt3sas raid functions template 9222 * if hbas_to_enumarate value is one. 9223 */ 9224 if (hbas_to_enumerate != 1) { 9225 mpt3sas_raid_template = 9226 raid_class_attach(&mpt3sas_raid_functions); 9227 if (!mpt3sas_raid_template) { 9228 sas_release_transport(mpt3sas_transport_template); 9229 return -ENODEV; 9230 } 9231 } 9232 9233 /* No need to attach mpt2sas raid functions template 9234 * if hbas_to_enumarate value is two 9235 */ 9236 if (hbas_to_enumerate != 2) { 9237 mpt2sas_raid_template = 9238 raid_class_attach(&mpt2sas_raid_functions); 9239 if (!mpt2sas_raid_template) { 9240 sas_release_transport(mpt3sas_transport_template); 9241 return -ENODEV; 9242 } 9243 } 9244 9245 error = scsih_init(); 9246 if (error) { 9247 scsih_exit(); 9248 return error; 9249 } 9250 9251 mpt3sas_ctl_init(hbas_to_enumerate); 9252 9253 error = pci_register_driver(&mpt3sas_driver); 9254 if (error) 9255 scsih_exit(); 9256 9257 return error; 9258 } 9259 9260 /** 9261 * _mpt3sas_exit - exit point for this driver (when it is a module). 9262 * 9263 */ 9264 static void __exit 9265 _mpt3sas_exit(void) 9266 { 9267 pr_info("mpt3sas version %s unloading\n", 9268 MPT3SAS_DRIVER_VERSION); 9269 9270 pci_unregister_driver(&mpt3sas_driver); 9271 9272 mpt3sas_ctl_exit(hbas_to_enumerate); 9273 9274 scsih_exit(); 9275 } 9276 9277 module_init(_mpt3sas_init); 9278 module_exit(_mpt3sas_exit); 9279