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