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