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