1// SPDX-License-Identifier: GPL-2.0-or-later 2/* 3 * Driver for Broadcom MPI3 Storage Controllers 4 * 5 * Copyright (C) 2017-2023 Broadcom Inc. 6 * (mailto: mpi3mr-linuxdrv.pdl@broadcom.com) 7 * 8 */ 9 10#include "mpi3mr.h" 11#include <linux/idr.h> 12 13/* global driver scop variables */ 14LIST_HEAD(mrioc_list); 15DEFINE_SPINLOCK(mrioc_list_lock); 16static DEFINE_IDA(mrioc_ida); 17static int warn_non_secure_ctlr; 18atomic64_t event_counter; 19 20MODULE_AUTHOR(MPI3MR_DRIVER_AUTHOR); 21MODULE_DESCRIPTION(MPI3MR_DRIVER_DESC); 22MODULE_LICENSE(MPI3MR_DRIVER_LICENSE); 23MODULE_VERSION(MPI3MR_DRIVER_VERSION); 24 25/* Module parameters*/ 26int prot_mask = -1; 27module_param(prot_mask, int, 0); 28MODULE_PARM_DESC(prot_mask, "Host protection capabilities mask, def=0x07"); 29 30static int prot_guard_mask = 3; 31module_param(prot_guard_mask, int, 0); 32MODULE_PARM_DESC(prot_guard_mask, " Host protection guard mask, def=3"); 33static int logging_level; 34module_param(logging_level, int, 0); 35MODULE_PARM_DESC(logging_level, 36 " bits for enabling additional logging info (default=0)"); 37static int max_sgl_entries = MPI3MR_DEFAULT_SGL_ENTRIES; 38module_param(max_sgl_entries, int, 0444); 39MODULE_PARM_DESC(max_sgl_entries, 40 "Preferred max number of SG entries to be used for a single I/O\n" 41 "The actual value will be determined by the driver\n" 42 "(Minimum=256, Maximum=2048, default=256)"); 43 44/* Forward declarations*/ 45static void mpi3mr_send_event_ack(struct mpi3mr_ioc *mrioc, u8 event, 46 struct mpi3mr_drv_cmd *cmdparam, u32 event_ctx); 47 48#define MPI3MR_DRIVER_EVENT_TG_QD_REDUCTION (0xFFFF) 49 50#define MPI3_EVENT_WAIT_FOR_DEVICES_TO_REFRESH (0xFFFE) 51 52/** 53 * mpi3mr_host_tag_for_scmd - Get host tag for a scmd 54 * @mrioc: Adapter instance reference 55 * @scmd: SCSI command reference 56 * 57 * Calculate the host tag based on block tag for a given scmd. 58 * 59 * Return: Valid host tag or MPI3MR_HOSTTAG_INVALID. 60 */ 61static u16 mpi3mr_host_tag_for_scmd(struct mpi3mr_ioc *mrioc, 62 struct scsi_cmnd *scmd) 63{ 64 struct scmd_priv *priv = NULL; 65 u32 unique_tag; 66 u16 host_tag, hw_queue; 67 68 unique_tag = blk_mq_unique_tag(scsi_cmd_to_rq(scmd)); 69 70 hw_queue = blk_mq_unique_tag_to_hwq(unique_tag); 71 if (hw_queue >= mrioc->num_op_reply_q) 72 return MPI3MR_HOSTTAG_INVALID; 73 host_tag = blk_mq_unique_tag_to_tag(unique_tag); 74 75 if (WARN_ON(host_tag >= mrioc->max_host_ios)) 76 return MPI3MR_HOSTTAG_INVALID; 77 78 priv = scsi_cmd_priv(scmd); 79 /*host_tag 0 is invalid hence incrementing by 1*/ 80 priv->host_tag = host_tag + 1; 81 priv->scmd = scmd; 82 priv->in_lld_scope = 1; 83 priv->req_q_idx = hw_queue; 84 priv->meta_chain_idx = -1; 85 priv->chain_idx = -1; 86 priv->meta_sg_valid = 0; 87 return priv->host_tag; 88} 89 90/** 91 * mpi3mr_scmd_from_host_tag - Get SCSI command from host tag 92 * @mrioc: Adapter instance reference 93 * @host_tag: Host tag 94 * @qidx: Operational queue index 95 * 96 * Identify the block tag from the host tag and queue index and 97 * retrieve associated scsi command using scsi_host_find_tag(). 98 * 99 * Return: SCSI command reference or NULL. 100 */ 101static struct scsi_cmnd *mpi3mr_scmd_from_host_tag( 102 struct mpi3mr_ioc *mrioc, u16 host_tag, u16 qidx) 103{ 104 struct scsi_cmnd *scmd = NULL; 105 struct scmd_priv *priv = NULL; 106 u32 unique_tag = host_tag - 1; 107 108 if (WARN_ON(host_tag > mrioc->max_host_ios)) 109 goto out; 110 111 unique_tag |= (qidx << BLK_MQ_UNIQUE_TAG_BITS); 112 113 scmd = scsi_host_find_tag(mrioc->shost, unique_tag); 114 if (scmd) { 115 priv = scsi_cmd_priv(scmd); 116 if (!priv->in_lld_scope) 117 scmd = NULL; 118 } 119out: 120 return scmd; 121} 122 123/** 124 * mpi3mr_clear_scmd_priv - Cleanup SCSI command private date 125 * @mrioc: Adapter instance reference 126 * @scmd: SCSI command reference 127 * 128 * Invalidate the SCSI command private data to mark the command 129 * is not in LLD scope anymore. 130 * 131 * Return: Nothing. 132 */ 133static void mpi3mr_clear_scmd_priv(struct mpi3mr_ioc *mrioc, 134 struct scsi_cmnd *scmd) 135{ 136 struct scmd_priv *priv = NULL; 137 138 priv = scsi_cmd_priv(scmd); 139 140 if (WARN_ON(priv->in_lld_scope == 0)) 141 return; 142 priv->host_tag = MPI3MR_HOSTTAG_INVALID; 143 priv->req_q_idx = 0xFFFF; 144 priv->scmd = NULL; 145 priv->in_lld_scope = 0; 146 priv->meta_sg_valid = 0; 147 if (priv->chain_idx >= 0) { 148 clear_bit(priv->chain_idx, mrioc->chain_bitmap); 149 priv->chain_idx = -1; 150 } 151 if (priv->meta_chain_idx >= 0) { 152 clear_bit(priv->meta_chain_idx, mrioc->chain_bitmap); 153 priv->meta_chain_idx = -1; 154 } 155} 156 157static void mpi3mr_dev_rmhs_send_tm(struct mpi3mr_ioc *mrioc, u16 handle, 158 struct mpi3mr_drv_cmd *cmdparam, u8 iou_rc); 159static void mpi3mr_fwevt_worker(struct work_struct *work); 160 161/** 162 * mpi3mr_fwevt_free - firmware event memory dealloctor 163 * @r: k reference pointer of the firmware event 164 * 165 * Free firmware event memory when no reference. 166 */ 167static void mpi3mr_fwevt_free(struct kref *r) 168{ 169 kfree(container_of(r, struct mpi3mr_fwevt, ref_count)); 170} 171 172/** 173 * mpi3mr_fwevt_get - k reference incrementor 174 * @fwevt: Firmware event reference 175 * 176 * Increment firmware event reference count. 177 */ 178static void mpi3mr_fwevt_get(struct mpi3mr_fwevt *fwevt) 179{ 180 kref_get(&fwevt->ref_count); 181} 182 183/** 184 * mpi3mr_fwevt_put - k reference decrementor 185 * @fwevt: Firmware event reference 186 * 187 * decrement firmware event reference count. 188 */ 189static void mpi3mr_fwevt_put(struct mpi3mr_fwevt *fwevt) 190{ 191 kref_put(&fwevt->ref_count, mpi3mr_fwevt_free); 192} 193 194/** 195 * mpi3mr_alloc_fwevt - Allocate firmware event 196 * @len: length of firmware event data to allocate 197 * 198 * Allocate firmware event with required length and initialize 199 * the reference counter. 200 * 201 * Return: firmware event reference. 202 */ 203static struct mpi3mr_fwevt *mpi3mr_alloc_fwevt(int len) 204{ 205 struct mpi3mr_fwevt *fwevt; 206 207 fwevt = kzalloc(sizeof(*fwevt) + len, GFP_ATOMIC); 208 if (!fwevt) 209 return NULL; 210 211 kref_init(&fwevt->ref_count); 212 return fwevt; 213} 214 215/** 216 * mpi3mr_fwevt_add_to_list - Add firmware event to the list 217 * @mrioc: Adapter instance reference 218 * @fwevt: Firmware event reference 219 * 220 * Add the given firmware event to the firmware event list. 221 * 222 * Return: Nothing. 223 */ 224static void mpi3mr_fwevt_add_to_list(struct mpi3mr_ioc *mrioc, 225 struct mpi3mr_fwevt *fwevt) 226{ 227 unsigned long flags; 228 229 if (!mrioc->fwevt_worker_thread) 230 return; 231 232 spin_lock_irqsave(&mrioc->fwevt_lock, flags); 233 /* get fwevt reference count while adding it to fwevt_list */ 234 mpi3mr_fwevt_get(fwevt); 235 INIT_LIST_HEAD(&fwevt->list); 236 list_add_tail(&fwevt->list, &mrioc->fwevt_list); 237 INIT_WORK(&fwevt->work, mpi3mr_fwevt_worker); 238 /* get fwevt reference count while enqueueing it to worker queue */ 239 mpi3mr_fwevt_get(fwevt); 240 queue_work(mrioc->fwevt_worker_thread, &fwevt->work); 241 spin_unlock_irqrestore(&mrioc->fwevt_lock, flags); 242} 243 244/** 245 * mpi3mr_fwevt_del_from_list - Delete firmware event from list 246 * @mrioc: Adapter instance reference 247 * @fwevt: Firmware event reference 248 * 249 * Delete the given firmware event from the firmware event list. 250 * 251 * Return: Nothing. 252 */ 253static void mpi3mr_fwevt_del_from_list(struct mpi3mr_ioc *mrioc, 254 struct mpi3mr_fwevt *fwevt) 255{ 256 unsigned long flags; 257 258 spin_lock_irqsave(&mrioc->fwevt_lock, flags); 259 if (!list_empty(&fwevt->list)) { 260 list_del_init(&fwevt->list); 261 /* 262 * Put fwevt reference count after 263 * removing it from fwevt_list 264 */ 265 mpi3mr_fwevt_put(fwevt); 266 } 267 spin_unlock_irqrestore(&mrioc->fwevt_lock, flags); 268} 269 270/** 271 * mpi3mr_dequeue_fwevt - Dequeue firmware event from the list 272 * @mrioc: Adapter instance reference 273 * 274 * Dequeue a firmware event from the firmware event list. 275 * 276 * Return: firmware event. 277 */ 278static struct mpi3mr_fwevt *mpi3mr_dequeue_fwevt( 279 struct mpi3mr_ioc *mrioc) 280{ 281 unsigned long flags; 282 struct mpi3mr_fwevt *fwevt = NULL; 283 284 spin_lock_irqsave(&mrioc->fwevt_lock, flags); 285 if (!list_empty(&mrioc->fwevt_list)) { 286 fwevt = list_first_entry(&mrioc->fwevt_list, 287 struct mpi3mr_fwevt, list); 288 list_del_init(&fwevt->list); 289 /* 290 * Put fwevt reference count after 291 * removing it from fwevt_list 292 */ 293 mpi3mr_fwevt_put(fwevt); 294 } 295 spin_unlock_irqrestore(&mrioc->fwevt_lock, flags); 296 297 return fwevt; 298} 299 300/** 301 * mpi3mr_cancel_work - cancel firmware event 302 * @fwevt: fwevt object which needs to be canceled 303 * 304 * Return: Nothing. 305 */ 306static void mpi3mr_cancel_work(struct mpi3mr_fwevt *fwevt) 307{ 308 /* 309 * Wait on the fwevt to complete. If this returns 1, then 310 * the event was never executed. 311 * 312 * If it did execute, we wait for it to finish, and the put will 313 * happen from mpi3mr_process_fwevt() 314 */ 315 if (cancel_work_sync(&fwevt->work)) { 316 /* 317 * Put fwevt reference count after 318 * dequeuing it from worker queue 319 */ 320 mpi3mr_fwevt_put(fwevt); 321 /* 322 * Put fwevt reference count to neutralize 323 * kref_init increment 324 */ 325 mpi3mr_fwevt_put(fwevt); 326 } 327} 328 329/** 330 * mpi3mr_cleanup_fwevt_list - Cleanup firmware event list 331 * @mrioc: Adapter instance reference 332 * 333 * Flush all pending firmware events from the firmware event 334 * list. 335 * 336 * Return: Nothing. 337 */ 338void mpi3mr_cleanup_fwevt_list(struct mpi3mr_ioc *mrioc) 339{ 340 struct mpi3mr_fwevt *fwevt = NULL; 341 342 if ((list_empty(&mrioc->fwevt_list) && !mrioc->current_event) || 343 !mrioc->fwevt_worker_thread) 344 return; 345 346 while ((fwevt = mpi3mr_dequeue_fwevt(mrioc))) 347 mpi3mr_cancel_work(fwevt); 348 349 if (mrioc->current_event) { 350 fwevt = mrioc->current_event; 351 /* 352 * Don't call cancel_work_sync() API for the 353 * fwevt work if the controller reset is 354 * get called as part of processing the 355 * same fwevt work (or) when worker thread is 356 * waiting for device add/remove APIs to complete. 357 * Otherwise we will see deadlock. 358 */ 359 if (current_work() == &fwevt->work || fwevt->pending_at_sml) { 360 fwevt->discard = 1; 361 return; 362 } 363 364 mpi3mr_cancel_work(fwevt); 365 } 366} 367 368/** 369 * mpi3mr_queue_qd_reduction_event - Queue TG QD reduction event 370 * @mrioc: Adapter instance reference 371 * @tg: Throttle group information pointer 372 * 373 * Accessor to queue on synthetically generated driver event to 374 * the event worker thread, the driver event will be used to 375 * reduce the QD of all VDs in the TG from the worker thread. 376 * 377 * Return: None. 378 */ 379static void mpi3mr_queue_qd_reduction_event(struct mpi3mr_ioc *mrioc, 380 struct mpi3mr_throttle_group_info *tg) 381{ 382 struct mpi3mr_fwevt *fwevt; 383 u16 sz = sizeof(struct mpi3mr_throttle_group_info *); 384 385 /* 386 * If the QD reduction event is already queued due to throttle and if 387 * the QD is not restored through device info change event 388 * then dont queue further reduction events 389 */ 390 if (tg->fw_qd != tg->modified_qd) 391 return; 392 393 fwevt = mpi3mr_alloc_fwevt(sz); 394 if (!fwevt) { 395 ioc_warn(mrioc, "failed to queue TG QD reduction event\n"); 396 return; 397 } 398 *(struct mpi3mr_throttle_group_info **)fwevt->event_data = tg; 399 fwevt->mrioc = mrioc; 400 fwevt->event_id = MPI3MR_DRIVER_EVENT_TG_QD_REDUCTION; 401 fwevt->send_ack = 0; 402 fwevt->process_evt = 1; 403 fwevt->evt_ctx = 0; 404 fwevt->event_data_size = sz; 405 tg->modified_qd = max_t(u16, (tg->fw_qd * tg->qd_reduction) / 10, 8); 406 407 dprint_event_bh(mrioc, "qd reduction event queued for tg_id(%d)\n", 408 tg->id); 409 mpi3mr_fwevt_add_to_list(mrioc, fwevt); 410} 411 412/** 413 * mpi3mr_invalidate_devhandles -Invalidate device handles 414 * @mrioc: Adapter instance reference 415 * 416 * Invalidate the device handles in the target device structures 417 * . Called post reset prior to reinitializing the controller. 418 * 419 * Return: Nothing. 420 */ 421void mpi3mr_invalidate_devhandles(struct mpi3mr_ioc *mrioc) 422{ 423 struct mpi3mr_tgt_dev *tgtdev; 424 struct mpi3mr_stgt_priv_data *tgt_priv; 425 426 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) { 427 tgtdev->dev_handle = MPI3MR_INVALID_DEV_HANDLE; 428 if (tgtdev->starget && tgtdev->starget->hostdata) { 429 tgt_priv = tgtdev->starget->hostdata; 430 tgt_priv->dev_handle = MPI3MR_INVALID_DEV_HANDLE; 431 tgt_priv->io_throttle_enabled = 0; 432 tgt_priv->io_divert = 0; 433 tgt_priv->throttle_group = NULL; 434 tgt_priv->wslen = 0; 435 if (tgtdev->host_exposed) 436 atomic_set(&tgt_priv->block_io, 1); 437 } 438 } 439} 440 441/** 442 * mpi3mr_print_scmd - print individual SCSI command 443 * @rq: Block request 444 * @data: Adapter instance reference 445 * 446 * Print the SCSI command details if it is in LLD scope. 447 * 448 * Return: true always. 449 */ 450static bool mpi3mr_print_scmd(struct request *rq, void *data) 451{ 452 struct mpi3mr_ioc *mrioc = (struct mpi3mr_ioc *)data; 453 struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq); 454 struct scmd_priv *priv = NULL; 455 456 if (scmd) { 457 priv = scsi_cmd_priv(scmd); 458 if (!priv->in_lld_scope) 459 goto out; 460 461 ioc_info(mrioc, "%s :Host Tag = %d, qid = %d\n", 462 __func__, priv->host_tag, priv->req_q_idx + 1); 463 scsi_print_command(scmd); 464 } 465 466out: 467 return(true); 468} 469 470/** 471 * mpi3mr_flush_scmd - Flush individual SCSI command 472 * @rq: Block request 473 * @data: Adapter instance reference 474 * 475 * Return the SCSI command to the upper layers if it is in LLD 476 * scope. 477 * 478 * Return: true always. 479 */ 480 481static bool mpi3mr_flush_scmd(struct request *rq, void *data) 482{ 483 struct mpi3mr_ioc *mrioc = (struct mpi3mr_ioc *)data; 484 struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq); 485 struct scmd_priv *priv = NULL; 486 487 if (scmd) { 488 priv = scsi_cmd_priv(scmd); 489 if (!priv->in_lld_scope) 490 goto out; 491 492 if (priv->meta_sg_valid) 493 dma_unmap_sg(&mrioc->pdev->dev, scsi_prot_sglist(scmd), 494 scsi_prot_sg_count(scmd), scmd->sc_data_direction); 495 mpi3mr_clear_scmd_priv(mrioc, scmd); 496 scsi_dma_unmap(scmd); 497 scmd->result = DID_RESET << 16; 498 scsi_print_command(scmd); 499 scsi_done(scmd); 500 mrioc->flush_io_count++; 501 } 502 503out: 504 return(true); 505} 506 507/** 508 * mpi3mr_count_dev_pending - Count commands pending for a lun 509 * @rq: Block request 510 * @data: SCSI device reference 511 * 512 * This is an iterator function called for each SCSI command in 513 * a host and if the command is pending in the LLD for the 514 * specific device(lun) then device specific pending I/O counter 515 * is updated in the device structure. 516 * 517 * Return: true always. 518 */ 519 520static bool mpi3mr_count_dev_pending(struct request *rq, void *data) 521{ 522 struct scsi_device *sdev = (struct scsi_device *)data; 523 struct mpi3mr_sdev_priv_data *sdev_priv_data = sdev->hostdata; 524 struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq); 525 struct scmd_priv *priv; 526 527 if (scmd) { 528 priv = scsi_cmd_priv(scmd); 529 if (!priv->in_lld_scope) 530 goto out; 531 if (scmd->device == sdev) 532 sdev_priv_data->pend_count++; 533 } 534 535out: 536 return true; 537} 538 539/** 540 * mpi3mr_count_tgt_pending - Count commands pending for target 541 * @rq: Block request 542 * @data: SCSI target reference 543 * 544 * This is an iterator function called for each SCSI command in 545 * a host and if the command is pending in the LLD for the 546 * specific target then target specific pending I/O counter is 547 * updated in the target structure. 548 * 549 * Return: true always. 550 */ 551 552static bool mpi3mr_count_tgt_pending(struct request *rq, void *data) 553{ 554 struct scsi_target *starget = (struct scsi_target *)data; 555 struct mpi3mr_stgt_priv_data *stgt_priv_data = starget->hostdata; 556 struct scsi_cmnd *scmd = blk_mq_rq_to_pdu(rq); 557 struct scmd_priv *priv; 558 559 if (scmd) { 560 priv = scsi_cmd_priv(scmd); 561 if (!priv->in_lld_scope) 562 goto out; 563 if (scmd->device && (scsi_target(scmd->device) == starget)) 564 stgt_priv_data->pend_count++; 565 } 566 567out: 568 return true; 569} 570 571/** 572 * mpi3mr_flush_host_io - Flush host I/Os 573 * @mrioc: Adapter instance reference 574 * 575 * Flush all of the pending I/Os by calling 576 * blk_mq_tagset_busy_iter() for each possible tag. This is 577 * executed post controller reset 578 * 579 * Return: Nothing. 580 */ 581void mpi3mr_flush_host_io(struct mpi3mr_ioc *mrioc) 582{ 583 struct Scsi_Host *shost = mrioc->shost; 584 585 mrioc->flush_io_count = 0; 586 ioc_info(mrioc, "%s :Flushing Host I/O cmds post reset\n", __func__); 587 blk_mq_tagset_busy_iter(&shost->tag_set, 588 mpi3mr_flush_scmd, (void *)mrioc); 589 ioc_info(mrioc, "%s :Flushed %d Host I/O cmds\n", __func__, 590 mrioc->flush_io_count); 591} 592 593/** 594 * mpi3mr_flush_cmds_for_unrecovered_controller - Flush all pending cmds 595 * @mrioc: Adapter instance reference 596 * 597 * This function waits for currently running IO poll threads to 598 * exit and then flushes all host I/Os and any internal pending 599 * cmds. This is executed after controller is marked as 600 * unrecoverable. 601 * 602 * Return: Nothing. 603 */ 604void mpi3mr_flush_cmds_for_unrecovered_controller(struct mpi3mr_ioc *mrioc) 605{ 606 struct Scsi_Host *shost = mrioc->shost; 607 int i; 608 609 if (!mrioc->unrecoverable) 610 return; 611 612 if (mrioc->op_reply_qinfo) { 613 for (i = 0; i < mrioc->num_queues; i++) { 614 while (atomic_read(&mrioc->op_reply_qinfo[i].in_use)) 615 udelay(500); 616 atomic_set(&mrioc->op_reply_qinfo[i].pend_ios, 0); 617 } 618 } 619 mrioc->flush_io_count = 0; 620 blk_mq_tagset_busy_iter(&shost->tag_set, 621 mpi3mr_flush_scmd, (void *)mrioc); 622 mpi3mr_flush_delayed_cmd_lists(mrioc); 623 mpi3mr_flush_drv_cmds(mrioc); 624} 625 626/** 627 * mpi3mr_alloc_tgtdev - target device allocator 628 * 629 * Allocate target device instance and initialize the reference 630 * count 631 * 632 * Return: target device instance. 633 */ 634static struct mpi3mr_tgt_dev *mpi3mr_alloc_tgtdev(void) 635{ 636 struct mpi3mr_tgt_dev *tgtdev; 637 638 tgtdev = kzalloc(sizeof(*tgtdev), GFP_ATOMIC); 639 if (!tgtdev) 640 return NULL; 641 kref_init(&tgtdev->ref_count); 642 return tgtdev; 643} 644 645/** 646 * mpi3mr_tgtdev_add_to_list -Add tgtdevice to the list 647 * @mrioc: Adapter instance reference 648 * @tgtdev: Target device 649 * 650 * Add the target device to the target device list 651 * 652 * Return: Nothing. 653 */ 654static void mpi3mr_tgtdev_add_to_list(struct mpi3mr_ioc *mrioc, 655 struct mpi3mr_tgt_dev *tgtdev) 656{ 657 unsigned long flags; 658 659 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 660 mpi3mr_tgtdev_get(tgtdev); 661 INIT_LIST_HEAD(&tgtdev->list); 662 list_add_tail(&tgtdev->list, &mrioc->tgtdev_list); 663 tgtdev->state = MPI3MR_DEV_CREATED; 664 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 665} 666 667/** 668 * mpi3mr_tgtdev_del_from_list -Delete tgtdevice from the list 669 * @mrioc: Adapter instance reference 670 * @tgtdev: Target device 671 * @must_delete: Must delete the target device from the list irrespective 672 * of the device state. 673 * 674 * Remove the target device from the target device list 675 * 676 * Return: Nothing. 677 */ 678static void mpi3mr_tgtdev_del_from_list(struct mpi3mr_ioc *mrioc, 679 struct mpi3mr_tgt_dev *tgtdev, bool must_delete) 680{ 681 unsigned long flags; 682 683 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 684 if ((tgtdev->state == MPI3MR_DEV_REMOVE_HS_STARTED) || (must_delete == true)) { 685 if (!list_empty(&tgtdev->list)) { 686 list_del_init(&tgtdev->list); 687 tgtdev->state = MPI3MR_DEV_DELETED; 688 mpi3mr_tgtdev_put(tgtdev); 689 } 690 } 691 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 692} 693 694/** 695 * __mpi3mr_get_tgtdev_by_handle -Get tgtdev from device handle 696 * @mrioc: Adapter instance reference 697 * @handle: Device handle 698 * 699 * Accessor to retrieve target device from the device handle. 700 * Non Lock version 701 * 702 * Return: Target device reference. 703 */ 704static struct mpi3mr_tgt_dev *__mpi3mr_get_tgtdev_by_handle( 705 struct mpi3mr_ioc *mrioc, u16 handle) 706{ 707 struct mpi3mr_tgt_dev *tgtdev; 708 709 assert_spin_locked(&mrioc->tgtdev_lock); 710 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) 711 if (tgtdev->dev_handle == handle) 712 goto found_tgtdev; 713 return NULL; 714 715found_tgtdev: 716 mpi3mr_tgtdev_get(tgtdev); 717 return tgtdev; 718} 719 720/** 721 * mpi3mr_get_tgtdev_by_handle -Get tgtdev from device handle 722 * @mrioc: Adapter instance reference 723 * @handle: Device handle 724 * 725 * Accessor to retrieve target device from the device handle. 726 * Lock version 727 * 728 * Return: Target device reference. 729 */ 730struct mpi3mr_tgt_dev *mpi3mr_get_tgtdev_by_handle( 731 struct mpi3mr_ioc *mrioc, u16 handle) 732{ 733 struct mpi3mr_tgt_dev *tgtdev; 734 unsigned long flags; 735 736 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 737 tgtdev = __mpi3mr_get_tgtdev_by_handle(mrioc, handle); 738 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 739 return tgtdev; 740} 741 742/** 743 * __mpi3mr_get_tgtdev_by_perst_id -Get tgtdev from persist ID 744 * @mrioc: Adapter instance reference 745 * @persist_id: Persistent ID 746 * 747 * Accessor to retrieve target device from the Persistent ID. 748 * Non Lock version 749 * 750 * Return: Target device reference. 751 */ 752static struct mpi3mr_tgt_dev *__mpi3mr_get_tgtdev_by_perst_id( 753 struct mpi3mr_ioc *mrioc, u16 persist_id) 754{ 755 struct mpi3mr_tgt_dev *tgtdev; 756 757 assert_spin_locked(&mrioc->tgtdev_lock); 758 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) 759 if (tgtdev->perst_id == persist_id) 760 goto found_tgtdev; 761 return NULL; 762 763found_tgtdev: 764 mpi3mr_tgtdev_get(tgtdev); 765 return tgtdev; 766} 767 768/** 769 * mpi3mr_get_tgtdev_by_perst_id -Get tgtdev from persistent ID 770 * @mrioc: Adapter instance reference 771 * @persist_id: Persistent ID 772 * 773 * Accessor to retrieve target device from the Persistent ID. 774 * Lock version 775 * 776 * Return: Target device reference. 777 */ 778static struct mpi3mr_tgt_dev *mpi3mr_get_tgtdev_by_perst_id( 779 struct mpi3mr_ioc *mrioc, u16 persist_id) 780{ 781 struct mpi3mr_tgt_dev *tgtdev; 782 unsigned long flags; 783 784 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 785 tgtdev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, persist_id); 786 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 787 return tgtdev; 788} 789 790/** 791 * __mpi3mr_get_tgtdev_from_tgtpriv -Get tgtdev from tgt private 792 * @mrioc: Adapter instance reference 793 * @tgt_priv: Target private data 794 * 795 * Accessor to return target device from the target private 796 * data. Non Lock version 797 * 798 * Return: Target device reference. 799 */ 800static struct mpi3mr_tgt_dev *__mpi3mr_get_tgtdev_from_tgtpriv( 801 struct mpi3mr_ioc *mrioc, struct mpi3mr_stgt_priv_data *tgt_priv) 802{ 803 struct mpi3mr_tgt_dev *tgtdev; 804 805 assert_spin_locked(&mrioc->tgtdev_lock); 806 tgtdev = tgt_priv->tgt_dev; 807 if (tgtdev) 808 mpi3mr_tgtdev_get(tgtdev); 809 return tgtdev; 810} 811 812/** 813 * mpi3mr_set_io_divert_for_all_vd_in_tg -set divert for TG VDs 814 * @mrioc: Adapter instance reference 815 * @tg: Throttle group information pointer 816 * @divert_value: 1 or 0 817 * 818 * Accessor to set io_divert flag for each device associated 819 * with the given throttle group with the given value. 820 * 821 * Return: None. 822 */ 823static void mpi3mr_set_io_divert_for_all_vd_in_tg(struct mpi3mr_ioc *mrioc, 824 struct mpi3mr_throttle_group_info *tg, u8 divert_value) 825{ 826 unsigned long flags; 827 struct mpi3mr_tgt_dev *tgtdev; 828 struct mpi3mr_stgt_priv_data *tgt_priv; 829 830 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 831 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) { 832 if (tgtdev->starget && tgtdev->starget->hostdata) { 833 tgt_priv = tgtdev->starget->hostdata; 834 if (tgt_priv->throttle_group == tg) 835 tgt_priv->io_divert = divert_value; 836 } 837 } 838 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 839} 840 841/** 842 * mpi3mr_print_device_event_notice - print notice related to post processing of 843 * device event after controller reset. 844 * 845 * @mrioc: Adapter instance reference 846 * @device_add: true for device add event and false for device removal event 847 * 848 * Return: None. 849 */ 850void mpi3mr_print_device_event_notice(struct mpi3mr_ioc *mrioc, 851 bool device_add) 852{ 853 ioc_notice(mrioc, "Device %s was in progress before the reset and\n", 854 (device_add ? "addition" : "removal")); 855 ioc_notice(mrioc, "completed after reset, verify whether the exposed devices\n"); 856 ioc_notice(mrioc, "are matched with attached devices for correctness\n"); 857} 858 859/** 860 * mpi3mr_remove_tgtdev_from_host - Remove dev from upper layers 861 * @mrioc: Adapter instance reference 862 * @tgtdev: Target device structure 863 * 864 * Checks whether the device is exposed to upper layers and if it 865 * is then remove the device from upper layers by calling 866 * scsi_remove_target(). 867 * 868 * Return: 0 on success, non zero on failure. 869 */ 870void mpi3mr_remove_tgtdev_from_host(struct mpi3mr_ioc *mrioc, 871 struct mpi3mr_tgt_dev *tgtdev) 872{ 873 struct mpi3mr_stgt_priv_data *tgt_priv; 874 875 ioc_info(mrioc, "%s :Removing handle(0x%04x), wwid(0x%016llx)\n", 876 __func__, tgtdev->dev_handle, (unsigned long long)tgtdev->wwid); 877 if (tgtdev->starget && tgtdev->starget->hostdata) { 878 tgt_priv = tgtdev->starget->hostdata; 879 atomic_set(&tgt_priv->block_io, 0); 880 tgt_priv->dev_handle = MPI3MR_INVALID_DEV_HANDLE; 881 } 882 883 if (!mrioc->sas_transport_enabled || (tgtdev->dev_type != 884 MPI3_DEVICE_DEVFORM_SAS_SATA) || tgtdev->non_stl) { 885 if (tgtdev->starget) { 886 if (mrioc->current_event) 887 mrioc->current_event->pending_at_sml = 1; 888 scsi_remove_target(&tgtdev->starget->dev); 889 tgtdev->host_exposed = 0; 890 if (mrioc->current_event) { 891 mrioc->current_event->pending_at_sml = 0; 892 if (mrioc->current_event->discard) { 893 mpi3mr_print_device_event_notice(mrioc, 894 false); 895 return; 896 } 897 } 898 } 899 } else 900 mpi3mr_remove_tgtdev_from_sas_transport(mrioc, tgtdev); 901 902 ioc_info(mrioc, "%s :Removed handle(0x%04x), wwid(0x%016llx)\n", 903 __func__, tgtdev->dev_handle, (unsigned long long)tgtdev->wwid); 904} 905 906/** 907 * mpi3mr_report_tgtdev_to_host - Expose device to upper layers 908 * @mrioc: Adapter instance reference 909 * @perst_id: Persistent ID of the device 910 * 911 * Checks whether the device can be exposed to upper layers and 912 * if it is not then expose the device to upper layers by 913 * calling scsi_scan_target(). 914 * 915 * Return: 0 on success, non zero on failure. 916 */ 917static int mpi3mr_report_tgtdev_to_host(struct mpi3mr_ioc *mrioc, 918 u16 perst_id) 919{ 920 int retval = 0; 921 struct mpi3mr_tgt_dev *tgtdev; 922 923 if (mrioc->reset_in_progress) 924 return -1; 925 926 tgtdev = mpi3mr_get_tgtdev_by_perst_id(mrioc, perst_id); 927 if (!tgtdev) { 928 retval = -1; 929 goto out; 930 } 931 if (tgtdev->is_hidden || tgtdev->host_exposed) { 932 retval = -1; 933 goto out; 934 } 935 if (!mrioc->sas_transport_enabled || (tgtdev->dev_type != 936 MPI3_DEVICE_DEVFORM_SAS_SATA) || tgtdev->non_stl){ 937 tgtdev->host_exposed = 1; 938 if (mrioc->current_event) 939 mrioc->current_event->pending_at_sml = 1; 940 scsi_scan_target(&mrioc->shost->shost_gendev, 941 mrioc->scsi_device_channel, tgtdev->perst_id, 942 SCAN_WILD_CARD, SCSI_SCAN_INITIAL); 943 if (!tgtdev->starget) 944 tgtdev->host_exposed = 0; 945 if (mrioc->current_event) { 946 mrioc->current_event->pending_at_sml = 0; 947 if (mrioc->current_event->discard) { 948 mpi3mr_print_device_event_notice(mrioc, true); 949 goto out; 950 } 951 } 952 } else 953 mpi3mr_report_tgtdev_to_sas_transport(mrioc, tgtdev); 954out: 955 if (tgtdev) 956 mpi3mr_tgtdev_put(tgtdev); 957 958 return retval; 959} 960 961/** 962 * mpi3mr_change_queue_depth- Change QD callback handler 963 * @sdev: SCSI device reference 964 * @q_depth: Queue depth 965 * 966 * Validate and limit QD and call scsi_change_queue_depth. 967 * 968 * Return: return value of scsi_change_queue_depth 969 */ 970static int mpi3mr_change_queue_depth(struct scsi_device *sdev, 971 int q_depth) 972{ 973 struct scsi_target *starget = scsi_target(sdev); 974 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 975 int retval = 0; 976 977 if (!sdev->tagged_supported) 978 q_depth = 1; 979 if (q_depth > shost->can_queue) 980 q_depth = shost->can_queue; 981 else if (!q_depth) 982 q_depth = MPI3MR_DEFAULT_SDEV_QD; 983 retval = scsi_change_queue_depth(sdev, q_depth); 984 sdev->max_queue_depth = sdev->queue_depth; 985 986 return retval; 987} 988 989/** 990 * mpi3mr_update_sdev - Update SCSI device information 991 * @sdev: SCSI device reference 992 * @data: target device reference 993 * 994 * This is an iterator function called for each SCSI device in a 995 * target to update the target specific information into each 996 * SCSI device. 997 * 998 * Return: Nothing. 999 */ 1000static void 1001mpi3mr_update_sdev(struct scsi_device *sdev, void *data) 1002{ 1003 struct mpi3mr_tgt_dev *tgtdev; 1004 1005 tgtdev = (struct mpi3mr_tgt_dev *)data; 1006 if (!tgtdev) 1007 return; 1008 1009 mpi3mr_change_queue_depth(sdev, tgtdev->q_depth); 1010 switch (tgtdev->dev_type) { 1011 case MPI3_DEVICE_DEVFORM_PCIE: 1012 /*The block layer hw sector size = 512*/ 1013 if ((tgtdev->dev_spec.pcie_inf.dev_info & 1014 MPI3_DEVICE0_PCIE_DEVICE_INFO_TYPE_MASK) == 1015 MPI3_DEVICE0_PCIE_DEVICE_INFO_TYPE_NVME_DEVICE) { 1016 blk_queue_max_hw_sectors(sdev->request_queue, 1017 tgtdev->dev_spec.pcie_inf.mdts / 512); 1018 if (tgtdev->dev_spec.pcie_inf.pgsz == 0) 1019 blk_queue_virt_boundary(sdev->request_queue, 1020 ((1 << MPI3MR_DEFAULT_PGSZEXP) - 1)); 1021 else 1022 blk_queue_virt_boundary(sdev->request_queue, 1023 ((1 << tgtdev->dev_spec.pcie_inf.pgsz) - 1)); 1024 } 1025 break; 1026 default: 1027 break; 1028 } 1029} 1030 1031/** 1032 * mpi3mr_rfresh_tgtdevs - Refresh target device exposure 1033 * @mrioc: Adapter instance reference 1034 * 1035 * This is executed post controller reset to identify any 1036 * missing devices during reset and remove from the upper layers 1037 * or expose any newly detected device to the upper layers. 1038 * 1039 * Return: Nothing. 1040 */ 1041 1042void mpi3mr_rfresh_tgtdevs(struct mpi3mr_ioc *mrioc) 1043{ 1044 struct mpi3mr_tgt_dev *tgtdev, *tgtdev_next; 1045 struct mpi3mr_stgt_priv_data *tgt_priv; 1046 1047 dprint_reset(mrioc, "refresh target devices: check for removals\n"); 1048 list_for_each_entry_safe(tgtdev, tgtdev_next, &mrioc->tgtdev_list, 1049 list) { 1050 if ((tgtdev->dev_handle == MPI3MR_INVALID_DEV_HANDLE) && 1051 tgtdev->is_hidden && 1052 tgtdev->host_exposed && tgtdev->starget && 1053 tgtdev->starget->hostdata) { 1054 tgt_priv = tgtdev->starget->hostdata; 1055 tgt_priv->dev_removed = 1; 1056 atomic_set(&tgt_priv->block_io, 0); 1057 } 1058 } 1059 1060 list_for_each_entry_safe(tgtdev, tgtdev_next, &mrioc->tgtdev_list, 1061 list) { 1062 if (tgtdev->dev_handle == MPI3MR_INVALID_DEV_HANDLE) { 1063 dprint_reset(mrioc, "removing target device with perst_id(%d)\n", 1064 tgtdev->perst_id); 1065 if (tgtdev->host_exposed) 1066 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev); 1067 mpi3mr_tgtdev_del_from_list(mrioc, tgtdev, true); 1068 mpi3mr_tgtdev_put(tgtdev); 1069 } else if (tgtdev->is_hidden & tgtdev->host_exposed) { 1070 dprint_reset(mrioc, "hiding target device with perst_id(%d)\n", 1071 tgtdev->perst_id); 1072 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev); 1073 } 1074 } 1075 1076 tgtdev = NULL; 1077 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) { 1078 if ((tgtdev->dev_handle != MPI3MR_INVALID_DEV_HANDLE) && 1079 !tgtdev->is_hidden) { 1080 if (!tgtdev->host_exposed) 1081 mpi3mr_report_tgtdev_to_host(mrioc, 1082 tgtdev->perst_id); 1083 else if (tgtdev->starget) 1084 starget_for_each_device(tgtdev->starget, 1085 (void *)tgtdev, mpi3mr_update_sdev); 1086 } 1087 } 1088} 1089 1090/** 1091 * mpi3mr_update_tgtdev - DevStatusChange evt bottomhalf 1092 * @mrioc: Adapter instance reference 1093 * @tgtdev: Target device internal structure 1094 * @dev_pg0: New device page0 1095 * @is_added: Flag to indicate the device is just added 1096 * 1097 * Update the information from the device page0 into the driver 1098 * cached target device structure. 1099 * 1100 * Return: Nothing. 1101 */ 1102static void mpi3mr_update_tgtdev(struct mpi3mr_ioc *mrioc, 1103 struct mpi3mr_tgt_dev *tgtdev, struct mpi3_device_page0 *dev_pg0, 1104 bool is_added) 1105{ 1106 u16 flags = 0; 1107 struct mpi3mr_stgt_priv_data *scsi_tgt_priv_data = NULL; 1108 struct mpi3mr_enclosure_node *enclosure_dev = NULL; 1109 u8 prot_mask = 0; 1110 1111 tgtdev->perst_id = le16_to_cpu(dev_pg0->persistent_id); 1112 tgtdev->dev_handle = le16_to_cpu(dev_pg0->dev_handle); 1113 tgtdev->dev_type = dev_pg0->device_form; 1114 tgtdev->io_unit_port = dev_pg0->io_unit_port; 1115 tgtdev->encl_handle = le16_to_cpu(dev_pg0->enclosure_handle); 1116 tgtdev->parent_handle = le16_to_cpu(dev_pg0->parent_dev_handle); 1117 tgtdev->slot = le16_to_cpu(dev_pg0->slot); 1118 tgtdev->q_depth = le16_to_cpu(dev_pg0->queue_depth); 1119 tgtdev->wwid = le64_to_cpu(dev_pg0->wwid); 1120 tgtdev->devpg0_flag = le16_to_cpu(dev_pg0->flags); 1121 1122 if (tgtdev->encl_handle) 1123 enclosure_dev = mpi3mr_enclosure_find_by_handle(mrioc, 1124 tgtdev->encl_handle); 1125 if (enclosure_dev) 1126 tgtdev->enclosure_logical_id = le64_to_cpu( 1127 enclosure_dev->pg0.enclosure_logical_id); 1128 1129 flags = tgtdev->devpg0_flag; 1130 1131 tgtdev->is_hidden = (flags & MPI3_DEVICE0_FLAGS_HIDDEN); 1132 1133 if (is_added == true) 1134 tgtdev->io_throttle_enabled = 1135 (flags & MPI3_DEVICE0_FLAGS_IO_THROTTLING_REQUIRED) ? 1 : 0; 1136 1137 switch (flags & MPI3_DEVICE0_FLAGS_MAX_WRITE_SAME_MASK) { 1138 case MPI3_DEVICE0_FLAGS_MAX_WRITE_SAME_256_LB: 1139 tgtdev->wslen = MPI3MR_WRITE_SAME_MAX_LEN_256_BLKS; 1140 break; 1141 case MPI3_DEVICE0_FLAGS_MAX_WRITE_SAME_2048_LB: 1142 tgtdev->wslen = MPI3MR_WRITE_SAME_MAX_LEN_2048_BLKS; 1143 break; 1144 case MPI3_DEVICE0_FLAGS_MAX_WRITE_SAME_NO_LIMIT: 1145 default: 1146 tgtdev->wslen = 0; 1147 break; 1148 } 1149 1150 if (tgtdev->starget && tgtdev->starget->hostdata) { 1151 scsi_tgt_priv_data = (struct mpi3mr_stgt_priv_data *) 1152 tgtdev->starget->hostdata; 1153 scsi_tgt_priv_data->perst_id = tgtdev->perst_id; 1154 scsi_tgt_priv_data->dev_handle = tgtdev->dev_handle; 1155 scsi_tgt_priv_data->dev_type = tgtdev->dev_type; 1156 scsi_tgt_priv_data->io_throttle_enabled = 1157 tgtdev->io_throttle_enabled; 1158 if (is_added == true) 1159 atomic_set(&scsi_tgt_priv_data->block_io, 0); 1160 scsi_tgt_priv_data->wslen = tgtdev->wslen; 1161 } 1162 1163 switch (dev_pg0->access_status) { 1164 case MPI3_DEVICE0_ASTATUS_NO_ERRORS: 1165 case MPI3_DEVICE0_ASTATUS_PREPARE: 1166 case MPI3_DEVICE0_ASTATUS_NEEDS_INITIALIZATION: 1167 case MPI3_DEVICE0_ASTATUS_DEVICE_MISSING_DELAY: 1168 break; 1169 default: 1170 tgtdev->is_hidden = 1; 1171 break; 1172 } 1173 1174 switch (tgtdev->dev_type) { 1175 case MPI3_DEVICE_DEVFORM_SAS_SATA: 1176 { 1177 struct mpi3_device0_sas_sata_format *sasinf = 1178 &dev_pg0->device_specific.sas_sata_format; 1179 u16 dev_info = le16_to_cpu(sasinf->device_info); 1180 1181 tgtdev->dev_spec.sas_sata_inf.dev_info = dev_info; 1182 tgtdev->dev_spec.sas_sata_inf.sas_address = 1183 le64_to_cpu(sasinf->sas_address); 1184 tgtdev->dev_spec.sas_sata_inf.phy_id = sasinf->phy_num; 1185 tgtdev->dev_spec.sas_sata_inf.attached_phy_id = 1186 sasinf->attached_phy_identifier; 1187 if ((dev_info & MPI3_SAS_DEVICE_INFO_DEVICE_TYPE_MASK) != 1188 MPI3_SAS_DEVICE_INFO_DEVICE_TYPE_END_DEVICE) 1189 tgtdev->is_hidden = 1; 1190 else if (!(dev_info & (MPI3_SAS_DEVICE_INFO_STP_SATA_TARGET | 1191 MPI3_SAS_DEVICE_INFO_SSP_TARGET))) 1192 tgtdev->is_hidden = 1; 1193 1194 if (((tgtdev->devpg0_flag & 1195 MPI3_DEVICE0_FLAGS_ATT_METHOD_DIR_ATTACHED) 1196 && (tgtdev->devpg0_flag & 1197 MPI3_DEVICE0_FLAGS_ATT_METHOD_VIRTUAL)) || 1198 (tgtdev->parent_handle == 0xFFFF)) 1199 tgtdev->non_stl = 1; 1200 if (tgtdev->dev_spec.sas_sata_inf.hba_port) 1201 tgtdev->dev_spec.sas_sata_inf.hba_port->port_id = 1202 dev_pg0->io_unit_port; 1203 break; 1204 } 1205 case MPI3_DEVICE_DEVFORM_PCIE: 1206 { 1207 struct mpi3_device0_pcie_format *pcieinf = 1208 &dev_pg0->device_specific.pcie_format; 1209 u16 dev_info = le16_to_cpu(pcieinf->device_info); 1210 1211 tgtdev->dev_spec.pcie_inf.dev_info = dev_info; 1212 tgtdev->dev_spec.pcie_inf.capb = 1213 le32_to_cpu(pcieinf->capabilities); 1214 tgtdev->dev_spec.pcie_inf.mdts = MPI3MR_DEFAULT_MDTS; 1215 /* 2^12 = 4096 */ 1216 tgtdev->dev_spec.pcie_inf.pgsz = 12; 1217 if (dev_pg0->access_status == MPI3_DEVICE0_ASTATUS_NO_ERRORS) { 1218 tgtdev->dev_spec.pcie_inf.mdts = 1219 le32_to_cpu(pcieinf->maximum_data_transfer_size); 1220 tgtdev->dev_spec.pcie_inf.pgsz = pcieinf->page_size; 1221 tgtdev->dev_spec.pcie_inf.reset_to = 1222 max_t(u8, pcieinf->controller_reset_to, 1223 MPI3MR_INTADMCMD_TIMEOUT); 1224 tgtdev->dev_spec.pcie_inf.abort_to = 1225 max_t(u8, pcieinf->nvme_abort_to, 1226 MPI3MR_INTADMCMD_TIMEOUT); 1227 } 1228 if (tgtdev->dev_spec.pcie_inf.mdts > (1024 * 1024)) 1229 tgtdev->dev_spec.pcie_inf.mdts = (1024 * 1024); 1230 if (((dev_info & MPI3_DEVICE0_PCIE_DEVICE_INFO_TYPE_MASK) != 1231 MPI3_DEVICE0_PCIE_DEVICE_INFO_TYPE_NVME_DEVICE) && 1232 ((dev_info & MPI3_DEVICE0_PCIE_DEVICE_INFO_TYPE_MASK) != 1233 MPI3_DEVICE0_PCIE_DEVICE_INFO_TYPE_SCSI_DEVICE)) 1234 tgtdev->is_hidden = 1; 1235 tgtdev->non_stl = 1; 1236 if (!mrioc->shost) 1237 break; 1238 prot_mask = scsi_host_get_prot(mrioc->shost); 1239 if (prot_mask & SHOST_DIX_TYPE0_PROTECTION) { 1240 scsi_host_set_prot(mrioc->shost, prot_mask & 0x77); 1241 ioc_info(mrioc, 1242 "%s : Disabling DIX0 prot capability\n", __func__); 1243 ioc_info(mrioc, 1244 "because HBA does not support DIX0 operation on NVME drives\n"); 1245 } 1246 break; 1247 } 1248 case MPI3_DEVICE_DEVFORM_VD: 1249 { 1250 struct mpi3_device0_vd_format *vdinf = 1251 &dev_pg0->device_specific.vd_format; 1252 struct mpi3mr_throttle_group_info *tg = NULL; 1253 u16 vdinf_io_throttle_group = 1254 le16_to_cpu(vdinf->io_throttle_group); 1255 1256 tgtdev->dev_spec.vd_inf.state = vdinf->vd_state; 1257 if (vdinf->vd_state == MPI3_DEVICE0_VD_STATE_OFFLINE) 1258 tgtdev->is_hidden = 1; 1259 tgtdev->non_stl = 1; 1260 tgtdev->dev_spec.vd_inf.tg_id = vdinf_io_throttle_group; 1261 tgtdev->dev_spec.vd_inf.tg_high = 1262 le16_to_cpu(vdinf->io_throttle_group_high) * 2048; 1263 tgtdev->dev_spec.vd_inf.tg_low = 1264 le16_to_cpu(vdinf->io_throttle_group_low) * 2048; 1265 if (vdinf_io_throttle_group < mrioc->num_io_throttle_group) { 1266 tg = mrioc->throttle_groups + vdinf_io_throttle_group; 1267 tg->id = vdinf_io_throttle_group; 1268 tg->high = tgtdev->dev_spec.vd_inf.tg_high; 1269 tg->low = tgtdev->dev_spec.vd_inf.tg_low; 1270 tg->qd_reduction = 1271 tgtdev->dev_spec.vd_inf.tg_qd_reduction; 1272 if (is_added == true) 1273 tg->fw_qd = tgtdev->q_depth; 1274 tg->modified_qd = tgtdev->q_depth; 1275 } 1276 tgtdev->dev_spec.vd_inf.tg = tg; 1277 if (scsi_tgt_priv_data) 1278 scsi_tgt_priv_data->throttle_group = tg; 1279 break; 1280 } 1281 default: 1282 break; 1283 } 1284} 1285 1286/** 1287 * mpi3mr_devstatuschg_evt_bh - DevStatusChange evt bottomhalf 1288 * @mrioc: Adapter instance reference 1289 * @fwevt: Firmware event information. 1290 * 1291 * Process Device status Change event and based on device's new 1292 * information, either expose the device to the upper layers, or 1293 * remove the device from upper layers. 1294 * 1295 * Return: Nothing. 1296 */ 1297static void mpi3mr_devstatuschg_evt_bh(struct mpi3mr_ioc *mrioc, 1298 struct mpi3mr_fwevt *fwevt) 1299{ 1300 u16 dev_handle = 0; 1301 u8 uhide = 0, delete = 0, cleanup = 0; 1302 struct mpi3mr_tgt_dev *tgtdev = NULL; 1303 struct mpi3_event_data_device_status_change *evtdata = 1304 (struct mpi3_event_data_device_status_change *)fwevt->event_data; 1305 1306 dev_handle = le16_to_cpu(evtdata->dev_handle); 1307 ioc_info(mrioc, 1308 "%s :device status change: handle(0x%04x): reason code(0x%x)\n", 1309 __func__, dev_handle, evtdata->reason_code); 1310 switch (evtdata->reason_code) { 1311 case MPI3_EVENT_DEV_STAT_RC_HIDDEN: 1312 delete = 1; 1313 break; 1314 case MPI3_EVENT_DEV_STAT_RC_NOT_HIDDEN: 1315 uhide = 1; 1316 break; 1317 case MPI3_EVENT_DEV_STAT_RC_VD_NOT_RESPONDING: 1318 delete = 1; 1319 cleanup = 1; 1320 break; 1321 default: 1322 ioc_info(mrioc, "%s :Unhandled reason code(0x%x)\n", __func__, 1323 evtdata->reason_code); 1324 break; 1325 } 1326 1327 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle); 1328 if (!tgtdev) 1329 goto out; 1330 if (uhide) { 1331 tgtdev->is_hidden = 0; 1332 if (!tgtdev->host_exposed) 1333 mpi3mr_report_tgtdev_to_host(mrioc, tgtdev->perst_id); 1334 } 1335 1336 if (delete) 1337 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev); 1338 1339 if (cleanup) { 1340 mpi3mr_tgtdev_del_from_list(mrioc, tgtdev, false); 1341 mpi3mr_tgtdev_put(tgtdev); 1342 } 1343 1344out: 1345 if (tgtdev) 1346 mpi3mr_tgtdev_put(tgtdev); 1347} 1348 1349/** 1350 * mpi3mr_devinfochg_evt_bh - DeviceInfoChange evt bottomhalf 1351 * @mrioc: Adapter instance reference 1352 * @dev_pg0: New device page0 1353 * 1354 * Process Device Info Change event and based on device's new 1355 * information, either expose the device to the upper layers, or 1356 * remove the device from upper layers or update the details of 1357 * the device. 1358 * 1359 * Return: Nothing. 1360 */ 1361static void mpi3mr_devinfochg_evt_bh(struct mpi3mr_ioc *mrioc, 1362 struct mpi3_device_page0 *dev_pg0) 1363{ 1364 struct mpi3mr_tgt_dev *tgtdev = NULL; 1365 u16 dev_handle = 0, perst_id = 0; 1366 1367 perst_id = le16_to_cpu(dev_pg0->persistent_id); 1368 dev_handle = le16_to_cpu(dev_pg0->dev_handle); 1369 ioc_info(mrioc, 1370 "%s :Device info change: handle(0x%04x): persist_id(0x%x)\n", 1371 __func__, dev_handle, perst_id); 1372 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle); 1373 if (!tgtdev) 1374 goto out; 1375 mpi3mr_update_tgtdev(mrioc, tgtdev, dev_pg0, false); 1376 if (!tgtdev->is_hidden && !tgtdev->host_exposed) 1377 mpi3mr_report_tgtdev_to_host(mrioc, perst_id); 1378 if (tgtdev->is_hidden && tgtdev->host_exposed) 1379 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev); 1380 if (!tgtdev->is_hidden && tgtdev->host_exposed && tgtdev->starget) 1381 starget_for_each_device(tgtdev->starget, (void *)tgtdev, 1382 mpi3mr_update_sdev); 1383out: 1384 if (tgtdev) 1385 mpi3mr_tgtdev_put(tgtdev); 1386} 1387 1388/** 1389 * mpi3mr_free_enclosure_list - release enclosures 1390 * @mrioc: Adapter instance reference 1391 * 1392 * Free memory allocated during encloure add. 1393 * 1394 * Return nothing. 1395 */ 1396void mpi3mr_free_enclosure_list(struct mpi3mr_ioc *mrioc) 1397{ 1398 struct mpi3mr_enclosure_node *enclosure_dev, *enclosure_dev_next; 1399 1400 list_for_each_entry_safe(enclosure_dev, 1401 enclosure_dev_next, &mrioc->enclosure_list, list) { 1402 list_del(&enclosure_dev->list); 1403 kfree(enclosure_dev); 1404 } 1405} 1406 1407/** 1408 * mpi3mr_enclosure_find_by_handle - enclosure search by handle 1409 * @mrioc: Adapter instance reference 1410 * @handle: Firmware device handle of the enclosure 1411 * 1412 * This searches for enclosure device based on handle, then returns the 1413 * enclosure object. 1414 * 1415 * Return: Enclosure object reference or NULL 1416 */ 1417struct mpi3mr_enclosure_node *mpi3mr_enclosure_find_by_handle( 1418 struct mpi3mr_ioc *mrioc, u16 handle) 1419{ 1420 struct mpi3mr_enclosure_node *enclosure_dev, *r = NULL; 1421 1422 list_for_each_entry(enclosure_dev, &mrioc->enclosure_list, list) { 1423 if (le16_to_cpu(enclosure_dev->pg0.enclosure_handle) != handle) 1424 continue; 1425 r = enclosure_dev; 1426 goto out; 1427 } 1428out: 1429 return r; 1430} 1431 1432/** 1433 * mpi3mr_encldev_add_chg_evt_debug - debug for enclosure event 1434 * @mrioc: Adapter instance reference 1435 * @encl_pg0: Enclosure page 0. 1436 * @is_added: Added event or not 1437 * 1438 * Return nothing. 1439 */ 1440static void mpi3mr_encldev_add_chg_evt_debug(struct mpi3mr_ioc *mrioc, 1441 struct mpi3_enclosure_page0 *encl_pg0, u8 is_added) 1442{ 1443 char *reason_str = NULL; 1444 1445 if (!(mrioc->logging_level & MPI3_DEBUG_EVENT_WORK_TASK)) 1446 return; 1447 1448 if (is_added) 1449 reason_str = "enclosure added"; 1450 else 1451 reason_str = "enclosure dev status changed"; 1452 1453 ioc_info(mrioc, 1454 "%s: handle(0x%04x), enclosure logical id(0x%016llx)\n", 1455 reason_str, le16_to_cpu(encl_pg0->enclosure_handle), 1456 (unsigned long long)le64_to_cpu(encl_pg0->enclosure_logical_id)); 1457 ioc_info(mrioc, 1458 "number of slots(%d), port(%d), flags(0x%04x), present(%d)\n", 1459 le16_to_cpu(encl_pg0->num_slots), encl_pg0->io_unit_port, 1460 le16_to_cpu(encl_pg0->flags), 1461 ((le16_to_cpu(encl_pg0->flags) & 1462 MPI3_ENCLS0_FLAGS_ENCL_DEV_PRESENT_MASK) >> 4)); 1463} 1464 1465/** 1466 * mpi3mr_encldev_add_chg_evt_bh - Enclosure evt bottomhalf 1467 * @mrioc: Adapter instance reference 1468 * @fwevt: Firmware event reference 1469 * 1470 * Prints information about the Enclosure device status or 1471 * Enclosure add events if logging is enabled and add or remove 1472 * the enclosure from the controller's internal list of 1473 * enclosures. 1474 * 1475 * Return: Nothing. 1476 */ 1477static void mpi3mr_encldev_add_chg_evt_bh(struct mpi3mr_ioc *mrioc, 1478 struct mpi3mr_fwevt *fwevt) 1479{ 1480 struct mpi3mr_enclosure_node *enclosure_dev = NULL; 1481 struct mpi3_enclosure_page0 *encl_pg0; 1482 u16 encl_handle; 1483 u8 added, present; 1484 1485 encl_pg0 = (struct mpi3_enclosure_page0 *) fwevt->event_data; 1486 added = (fwevt->event_id == MPI3_EVENT_ENCL_DEVICE_ADDED) ? 1 : 0; 1487 mpi3mr_encldev_add_chg_evt_debug(mrioc, encl_pg0, added); 1488 1489 1490 encl_handle = le16_to_cpu(encl_pg0->enclosure_handle); 1491 present = ((le16_to_cpu(encl_pg0->flags) & 1492 MPI3_ENCLS0_FLAGS_ENCL_DEV_PRESENT_MASK) >> 4); 1493 1494 if (encl_handle) 1495 enclosure_dev = mpi3mr_enclosure_find_by_handle(mrioc, 1496 encl_handle); 1497 if (!enclosure_dev && present) { 1498 enclosure_dev = 1499 kzalloc(sizeof(struct mpi3mr_enclosure_node), 1500 GFP_KERNEL); 1501 if (!enclosure_dev) 1502 return; 1503 list_add_tail(&enclosure_dev->list, 1504 &mrioc->enclosure_list); 1505 } 1506 if (enclosure_dev) { 1507 if (!present) { 1508 list_del(&enclosure_dev->list); 1509 kfree(enclosure_dev); 1510 } else 1511 memcpy(&enclosure_dev->pg0, encl_pg0, 1512 sizeof(enclosure_dev->pg0)); 1513 1514 } 1515} 1516 1517/** 1518 * mpi3mr_sastopochg_evt_debug - SASTopoChange details 1519 * @mrioc: Adapter instance reference 1520 * @event_data: SAS topology change list event data 1521 * 1522 * Prints information about the SAS topology change event. 1523 * 1524 * Return: Nothing. 1525 */ 1526static void 1527mpi3mr_sastopochg_evt_debug(struct mpi3mr_ioc *mrioc, 1528 struct mpi3_event_data_sas_topology_change_list *event_data) 1529{ 1530 int i; 1531 u16 handle; 1532 u8 reason_code, phy_number; 1533 char *status_str = NULL; 1534 u8 link_rate, prev_link_rate; 1535 1536 switch (event_data->exp_status) { 1537 case MPI3_EVENT_SAS_TOPO_ES_NOT_RESPONDING: 1538 status_str = "remove"; 1539 break; 1540 case MPI3_EVENT_SAS_TOPO_ES_RESPONDING: 1541 status_str = "responding"; 1542 break; 1543 case MPI3_EVENT_SAS_TOPO_ES_DELAY_NOT_RESPONDING: 1544 status_str = "remove delay"; 1545 break; 1546 case MPI3_EVENT_SAS_TOPO_ES_NO_EXPANDER: 1547 status_str = "direct attached"; 1548 break; 1549 default: 1550 status_str = "unknown status"; 1551 break; 1552 } 1553 ioc_info(mrioc, "%s :sas topology change: (%s)\n", 1554 __func__, status_str); 1555 ioc_info(mrioc, 1556 "%s :\texpander_handle(0x%04x), port(%d), enclosure_handle(0x%04x) start_phy(%02d), num_entries(%d)\n", 1557 __func__, le16_to_cpu(event_data->expander_dev_handle), 1558 event_data->io_unit_port, 1559 le16_to_cpu(event_data->enclosure_handle), 1560 event_data->start_phy_num, event_data->num_entries); 1561 for (i = 0; i < event_data->num_entries; i++) { 1562 handle = le16_to_cpu(event_data->phy_entry[i].attached_dev_handle); 1563 if (!handle) 1564 continue; 1565 phy_number = event_data->start_phy_num + i; 1566 reason_code = event_data->phy_entry[i].status & 1567 MPI3_EVENT_SAS_TOPO_PHY_RC_MASK; 1568 switch (reason_code) { 1569 case MPI3_EVENT_SAS_TOPO_PHY_RC_TARG_NOT_RESPONDING: 1570 status_str = "target remove"; 1571 break; 1572 case MPI3_EVENT_SAS_TOPO_PHY_RC_DELAY_NOT_RESPONDING: 1573 status_str = "delay target remove"; 1574 break; 1575 case MPI3_EVENT_SAS_TOPO_PHY_RC_PHY_CHANGED: 1576 status_str = "link status change"; 1577 break; 1578 case MPI3_EVENT_SAS_TOPO_PHY_RC_NO_CHANGE: 1579 status_str = "link status no change"; 1580 break; 1581 case MPI3_EVENT_SAS_TOPO_PHY_RC_RESPONDING: 1582 status_str = "target responding"; 1583 break; 1584 default: 1585 status_str = "unknown"; 1586 break; 1587 } 1588 link_rate = event_data->phy_entry[i].link_rate >> 4; 1589 prev_link_rate = event_data->phy_entry[i].link_rate & 0xF; 1590 ioc_info(mrioc, 1591 "%s :\tphy(%02d), attached_handle(0x%04x): %s: link rate: new(0x%02x), old(0x%02x)\n", 1592 __func__, phy_number, handle, status_str, link_rate, 1593 prev_link_rate); 1594 } 1595} 1596 1597/** 1598 * mpi3mr_sastopochg_evt_bh - SASTopologyChange evt bottomhalf 1599 * @mrioc: Adapter instance reference 1600 * @fwevt: Firmware event reference 1601 * 1602 * Prints information about the SAS topology change event and 1603 * for "not responding" event code, removes the device from the 1604 * upper layers. 1605 * 1606 * Return: Nothing. 1607 */ 1608static void mpi3mr_sastopochg_evt_bh(struct mpi3mr_ioc *mrioc, 1609 struct mpi3mr_fwevt *fwevt) 1610{ 1611 struct mpi3_event_data_sas_topology_change_list *event_data = 1612 (struct mpi3_event_data_sas_topology_change_list *)fwevt->event_data; 1613 int i; 1614 u16 handle; 1615 u8 reason_code; 1616 u64 exp_sas_address = 0, parent_sas_address = 0; 1617 struct mpi3mr_hba_port *hba_port = NULL; 1618 struct mpi3mr_tgt_dev *tgtdev = NULL; 1619 struct mpi3mr_sas_node *sas_expander = NULL; 1620 unsigned long flags; 1621 u8 link_rate, prev_link_rate, parent_phy_number; 1622 1623 mpi3mr_sastopochg_evt_debug(mrioc, event_data); 1624 if (mrioc->sas_transport_enabled) { 1625 hba_port = mpi3mr_get_hba_port_by_id(mrioc, 1626 event_data->io_unit_port); 1627 if (le16_to_cpu(event_data->expander_dev_handle)) { 1628 spin_lock_irqsave(&mrioc->sas_node_lock, flags); 1629 sas_expander = __mpi3mr_expander_find_by_handle(mrioc, 1630 le16_to_cpu(event_data->expander_dev_handle)); 1631 if (sas_expander) { 1632 exp_sas_address = sas_expander->sas_address; 1633 hba_port = sas_expander->hba_port; 1634 } 1635 spin_unlock_irqrestore(&mrioc->sas_node_lock, flags); 1636 parent_sas_address = exp_sas_address; 1637 } else 1638 parent_sas_address = mrioc->sas_hba.sas_address; 1639 } 1640 1641 for (i = 0; i < event_data->num_entries; i++) { 1642 if (fwevt->discard) 1643 return; 1644 handle = le16_to_cpu(event_data->phy_entry[i].attached_dev_handle); 1645 if (!handle) 1646 continue; 1647 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, handle); 1648 if (!tgtdev) 1649 continue; 1650 1651 reason_code = event_data->phy_entry[i].status & 1652 MPI3_EVENT_SAS_TOPO_PHY_RC_MASK; 1653 1654 switch (reason_code) { 1655 case MPI3_EVENT_SAS_TOPO_PHY_RC_TARG_NOT_RESPONDING: 1656 if (tgtdev->host_exposed) 1657 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev); 1658 mpi3mr_tgtdev_del_from_list(mrioc, tgtdev, false); 1659 mpi3mr_tgtdev_put(tgtdev); 1660 break; 1661 case MPI3_EVENT_SAS_TOPO_PHY_RC_RESPONDING: 1662 case MPI3_EVENT_SAS_TOPO_PHY_RC_PHY_CHANGED: 1663 case MPI3_EVENT_SAS_TOPO_PHY_RC_NO_CHANGE: 1664 { 1665 if (!mrioc->sas_transport_enabled || tgtdev->non_stl 1666 || tgtdev->is_hidden) 1667 break; 1668 link_rate = event_data->phy_entry[i].link_rate >> 4; 1669 prev_link_rate = event_data->phy_entry[i].link_rate & 0xF; 1670 if (link_rate == prev_link_rate) 1671 break; 1672 if (!parent_sas_address) 1673 break; 1674 parent_phy_number = event_data->start_phy_num + i; 1675 mpi3mr_update_links(mrioc, parent_sas_address, handle, 1676 parent_phy_number, link_rate, hba_port); 1677 break; 1678 } 1679 default: 1680 break; 1681 } 1682 if (tgtdev) 1683 mpi3mr_tgtdev_put(tgtdev); 1684 } 1685 1686 if (mrioc->sas_transport_enabled && (event_data->exp_status == 1687 MPI3_EVENT_SAS_TOPO_ES_NOT_RESPONDING)) { 1688 if (sas_expander) 1689 mpi3mr_expander_remove(mrioc, exp_sas_address, 1690 hba_port); 1691 } 1692} 1693 1694/** 1695 * mpi3mr_pcietopochg_evt_debug - PCIeTopoChange details 1696 * @mrioc: Adapter instance reference 1697 * @event_data: PCIe topology change list event data 1698 * 1699 * Prints information about the PCIe topology change event. 1700 * 1701 * Return: Nothing. 1702 */ 1703static void 1704mpi3mr_pcietopochg_evt_debug(struct mpi3mr_ioc *mrioc, 1705 struct mpi3_event_data_pcie_topology_change_list *event_data) 1706{ 1707 int i; 1708 u16 handle; 1709 u16 reason_code; 1710 u8 port_number; 1711 char *status_str = NULL; 1712 u8 link_rate, prev_link_rate; 1713 1714 switch (event_data->switch_status) { 1715 case MPI3_EVENT_PCIE_TOPO_SS_NOT_RESPONDING: 1716 status_str = "remove"; 1717 break; 1718 case MPI3_EVENT_PCIE_TOPO_SS_RESPONDING: 1719 status_str = "responding"; 1720 break; 1721 case MPI3_EVENT_PCIE_TOPO_SS_DELAY_NOT_RESPONDING: 1722 status_str = "remove delay"; 1723 break; 1724 case MPI3_EVENT_PCIE_TOPO_SS_NO_PCIE_SWITCH: 1725 status_str = "direct attached"; 1726 break; 1727 default: 1728 status_str = "unknown status"; 1729 break; 1730 } 1731 ioc_info(mrioc, "%s :pcie topology change: (%s)\n", 1732 __func__, status_str); 1733 ioc_info(mrioc, 1734 "%s :\tswitch_handle(0x%04x), enclosure_handle(0x%04x) start_port(%02d), num_entries(%d)\n", 1735 __func__, le16_to_cpu(event_data->switch_dev_handle), 1736 le16_to_cpu(event_data->enclosure_handle), 1737 event_data->start_port_num, event_data->num_entries); 1738 for (i = 0; i < event_data->num_entries; i++) { 1739 handle = 1740 le16_to_cpu(event_data->port_entry[i].attached_dev_handle); 1741 if (!handle) 1742 continue; 1743 port_number = event_data->start_port_num + i; 1744 reason_code = event_data->port_entry[i].port_status; 1745 switch (reason_code) { 1746 case MPI3_EVENT_PCIE_TOPO_PS_NOT_RESPONDING: 1747 status_str = "target remove"; 1748 break; 1749 case MPI3_EVENT_PCIE_TOPO_PS_DELAY_NOT_RESPONDING: 1750 status_str = "delay target remove"; 1751 break; 1752 case MPI3_EVENT_PCIE_TOPO_PS_PORT_CHANGED: 1753 status_str = "link status change"; 1754 break; 1755 case MPI3_EVENT_PCIE_TOPO_PS_NO_CHANGE: 1756 status_str = "link status no change"; 1757 break; 1758 case MPI3_EVENT_PCIE_TOPO_PS_RESPONDING: 1759 status_str = "target responding"; 1760 break; 1761 default: 1762 status_str = "unknown"; 1763 break; 1764 } 1765 link_rate = event_data->port_entry[i].current_port_info & 1766 MPI3_EVENT_PCIE_TOPO_PI_RATE_MASK; 1767 prev_link_rate = event_data->port_entry[i].previous_port_info & 1768 MPI3_EVENT_PCIE_TOPO_PI_RATE_MASK; 1769 ioc_info(mrioc, 1770 "%s :\tport(%02d), attached_handle(0x%04x): %s: link rate: new(0x%02x), old(0x%02x)\n", 1771 __func__, port_number, handle, status_str, link_rate, 1772 prev_link_rate); 1773 } 1774} 1775 1776/** 1777 * mpi3mr_pcietopochg_evt_bh - PCIeTopologyChange evt bottomhalf 1778 * @mrioc: Adapter instance reference 1779 * @fwevt: Firmware event reference 1780 * 1781 * Prints information about the PCIe topology change event and 1782 * for "not responding" event code, removes the device from the 1783 * upper layers. 1784 * 1785 * Return: Nothing. 1786 */ 1787static void mpi3mr_pcietopochg_evt_bh(struct mpi3mr_ioc *mrioc, 1788 struct mpi3mr_fwevt *fwevt) 1789{ 1790 struct mpi3_event_data_pcie_topology_change_list *event_data = 1791 (struct mpi3_event_data_pcie_topology_change_list *)fwevt->event_data; 1792 int i; 1793 u16 handle; 1794 u8 reason_code; 1795 struct mpi3mr_tgt_dev *tgtdev = NULL; 1796 1797 mpi3mr_pcietopochg_evt_debug(mrioc, event_data); 1798 1799 for (i = 0; i < event_data->num_entries; i++) { 1800 if (fwevt->discard) 1801 return; 1802 handle = 1803 le16_to_cpu(event_data->port_entry[i].attached_dev_handle); 1804 if (!handle) 1805 continue; 1806 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, handle); 1807 if (!tgtdev) 1808 continue; 1809 1810 reason_code = event_data->port_entry[i].port_status; 1811 1812 switch (reason_code) { 1813 case MPI3_EVENT_PCIE_TOPO_PS_NOT_RESPONDING: 1814 if (tgtdev->host_exposed) 1815 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev); 1816 mpi3mr_tgtdev_del_from_list(mrioc, tgtdev, false); 1817 mpi3mr_tgtdev_put(tgtdev); 1818 break; 1819 default: 1820 break; 1821 } 1822 if (tgtdev) 1823 mpi3mr_tgtdev_put(tgtdev); 1824 } 1825} 1826 1827/** 1828 * mpi3mr_logdata_evt_bh - Log data event bottomhalf 1829 * @mrioc: Adapter instance reference 1830 * @fwevt: Firmware event reference 1831 * 1832 * Extracts the event data and calls application interfacing 1833 * function to process the event further. 1834 * 1835 * Return: Nothing. 1836 */ 1837static void mpi3mr_logdata_evt_bh(struct mpi3mr_ioc *mrioc, 1838 struct mpi3mr_fwevt *fwevt) 1839{ 1840 mpi3mr_app_save_logdata(mrioc, fwevt->event_data, 1841 fwevt->event_data_size); 1842} 1843 1844/** 1845 * mpi3mr_update_sdev_qd - Update SCSI device queue depath 1846 * @sdev: SCSI device reference 1847 * @data: Queue depth reference 1848 * 1849 * This is an iterator function called for each SCSI device in a 1850 * target to update the QD of each SCSI device. 1851 * 1852 * Return: Nothing. 1853 */ 1854static void mpi3mr_update_sdev_qd(struct scsi_device *sdev, void *data) 1855{ 1856 u16 *q_depth = (u16 *)data; 1857 1858 scsi_change_queue_depth(sdev, (int)*q_depth); 1859 sdev->max_queue_depth = sdev->queue_depth; 1860} 1861 1862/** 1863 * mpi3mr_set_qd_for_all_vd_in_tg -set QD for TG VDs 1864 * @mrioc: Adapter instance reference 1865 * @tg: Throttle group information pointer 1866 * 1867 * Accessor to reduce QD for each device associated with the 1868 * given throttle group. 1869 * 1870 * Return: None. 1871 */ 1872static void mpi3mr_set_qd_for_all_vd_in_tg(struct mpi3mr_ioc *mrioc, 1873 struct mpi3mr_throttle_group_info *tg) 1874{ 1875 unsigned long flags; 1876 struct mpi3mr_tgt_dev *tgtdev; 1877 struct mpi3mr_stgt_priv_data *tgt_priv; 1878 1879 1880 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 1881 list_for_each_entry(tgtdev, &mrioc->tgtdev_list, list) { 1882 if (tgtdev->starget && tgtdev->starget->hostdata) { 1883 tgt_priv = tgtdev->starget->hostdata; 1884 if (tgt_priv->throttle_group == tg) { 1885 dprint_event_bh(mrioc, 1886 "updating qd due to throttling for persist_id(%d) original_qd(%d), reduced_qd (%d)\n", 1887 tgt_priv->perst_id, tgtdev->q_depth, 1888 tg->modified_qd); 1889 starget_for_each_device(tgtdev->starget, 1890 (void *)&tg->modified_qd, 1891 mpi3mr_update_sdev_qd); 1892 } 1893 } 1894 } 1895 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 1896} 1897 1898/** 1899 * mpi3mr_fwevt_bh - Firmware event bottomhalf handler 1900 * @mrioc: Adapter instance reference 1901 * @fwevt: Firmware event reference 1902 * 1903 * Identifies the firmware event and calls corresponding bottomg 1904 * half handler and sends event acknowledgment if required. 1905 * 1906 * Return: Nothing. 1907 */ 1908static void mpi3mr_fwevt_bh(struct mpi3mr_ioc *mrioc, 1909 struct mpi3mr_fwevt *fwevt) 1910{ 1911 struct mpi3_device_page0 *dev_pg0 = NULL; 1912 u16 perst_id, handle, dev_info; 1913 struct mpi3_device0_sas_sata_format *sasinf = NULL; 1914 1915 mpi3mr_fwevt_del_from_list(mrioc, fwevt); 1916 mrioc->current_event = fwevt; 1917 1918 if (mrioc->stop_drv_processing) 1919 goto out; 1920 1921 if (mrioc->unrecoverable) { 1922 dprint_event_bh(mrioc, 1923 "ignoring event(0x%02x) in bottom half handler due to unrecoverable controller\n", 1924 fwevt->event_id); 1925 goto out; 1926 } 1927 1928 if (!fwevt->process_evt) 1929 goto evt_ack; 1930 1931 switch (fwevt->event_id) { 1932 case MPI3_EVENT_DEVICE_ADDED: 1933 { 1934 dev_pg0 = (struct mpi3_device_page0 *)fwevt->event_data; 1935 perst_id = le16_to_cpu(dev_pg0->persistent_id); 1936 handle = le16_to_cpu(dev_pg0->dev_handle); 1937 if (perst_id != MPI3_DEVICE0_PERSISTENTID_INVALID) 1938 mpi3mr_report_tgtdev_to_host(mrioc, perst_id); 1939 else if (mrioc->sas_transport_enabled && 1940 (dev_pg0->device_form == MPI3_DEVICE_DEVFORM_SAS_SATA)) { 1941 sasinf = &dev_pg0->device_specific.sas_sata_format; 1942 dev_info = le16_to_cpu(sasinf->device_info); 1943 if (!mrioc->sas_hba.num_phys) 1944 mpi3mr_sas_host_add(mrioc); 1945 else 1946 mpi3mr_sas_host_refresh(mrioc); 1947 1948 if (mpi3mr_is_expander_device(dev_info)) 1949 mpi3mr_expander_add(mrioc, handle); 1950 } 1951 break; 1952 } 1953 case MPI3_EVENT_DEVICE_INFO_CHANGED: 1954 { 1955 dev_pg0 = (struct mpi3_device_page0 *)fwevt->event_data; 1956 perst_id = le16_to_cpu(dev_pg0->persistent_id); 1957 if (perst_id != MPI3_DEVICE0_PERSISTENTID_INVALID) 1958 mpi3mr_devinfochg_evt_bh(mrioc, dev_pg0); 1959 break; 1960 } 1961 case MPI3_EVENT_DEVICE_STATUS_CHANGE: 1962 { 1963 mpi3mr_devstatuschg_evt_bh(mrioc, fwevt); 1964 break; 1965 } 1966 case MPI3_EVENT_ENCL_DEVICE_ADDED: 1967 case MPI3_EVENT_ENCL_DEVICE_STATUS_CHANGE: 1968 { 1969 mpi3mr_encldev_add_chg_evt_bh(mrioc, fwevt); 1970 break; 1971 } 1972 1973 case MPI3_EVENT_SAS_TOPOLOGY_CHANGE_LIST: 1974 { 1975 mpi3mr_sastopochg_evt_bh(mrioc, fwevt); 1976 break; 1977 } 1978 case MPI3_EVENT_PCIE_TOPOLOGY_CHANGE_LIST: 1979 { 1980 mpi3mr_pcietopochg_evt_bh(mrioc, fwevt); 1981 break; 1982 } 1983 case MPI3_EVENT_LOG_DATA: 1984 { 1985 mpi3mr_logdata_evt_bh(mrioc, fwevt); 1986 break; 1987 } 1988 case MPI3MR_DRIVER_EVENT_TG_QD_REDUCTION: 1989 { 1990 struct mpi3mr_throttle_group_info *tg; 1991 1992 tg = *(struct mpi3mr_throttle_group_info **)fwevt->event_data; 1993 dprint_event_bh(mrioc, 1994 "qd reduction event processed for tg_id(%d) reduction_needed(%d)\n", 1995 tg->id, tg->need_qd_reduction); 1996 if (tg->need_qd_reduction) { 1997 mpi3mr_set_qd_for_all_vd_in_tg(mrioc, tg); 1998 tg->need_qd_reduction = 0; 1999 } 2000 break; 2001 } 2002 case MPI3_EVENT_WAIT_FOR_DEVICES_TO_REFRESH: 2003 { 2004 while (mrioc->device_refresh_on) 2005 msleep(500); 2006 2007 dprint_event_bh(mrioc, 2008 "scan for non responding and newly added devices after soft reset started\n"); 2009 if (mrioc->sas_transport_enabled) { 2010 mpi3mr_refresh_sas_ports(mrioc); 2011 mpi3mr_refresh_expanders(mrioc); 2012 } 2013 mpi3mr_rfresh_tgtdevs(mrioc); 2014 ioc_info(mrioc, 2015 "scan for non responding and newly added devices after soft reset completed\n"); 2016 break; 2017 } 2018 default: 2019 break; 2020 } 2021 2022evt_ack: 2023 if (fwevt->send_ack) 2024 mpi3mr_process_event_ack(mrioc, fwevt->event_id, 2025 fwevt->evt_ctx); 2026out: 2027 /* Put fwevt reference count to neutralize kref_init increment */ 2028 mpi3mr_fwevt_put(fwevt); 2029 mrioc->current_event = NULL; 2030} 2031 2032/** 2033 * mpi3mr_fwevt_worker - Firmware event worker 2034 * @work: Work struct containing firmware event 2035 * 2036 * Extracts the firmware event and calls mpi3mr_fwevt_bh. 2037 * 2038 * Return: Nothing. 2039 */ 2040static void mpi3mr_fwevt_worker(struct work_struct *work) 2041{ 2042 struct mpi3mr_fwevt *fwevt = container_of(work, struct mpi3mr_fwevt, 2043 work); 2044 mpi3mr_fwevt_bh(fwevt->mrioc, fwevt); 2045 /* 2046 * Put fwevt reference count after 2047 * dequeuing it from worker queue 2048 */ 2049 mpi3mr_fwevt_put(fwevt); 2050} 2051 2052/** 2053 * mpi3mr_create_tgtdev - Create and add a target device 2054 * @mrioc: Adapter instance reference 2055 * @dev_pg0: Device Page 0 data 2056 * 2057 * If the device specified by the device page 0 data is not 2058 * present in the driver's internal list, allocate the memory 2059 * for the device, populate the data and add to the list, else 2060 * update the device data. The key is persistent ID. 2061 * 2062 * Return: 0 on success, -ENOMEM on memory allocation failure 2063 */ 2064static int mpi3mr_create_tgtdev(struct mpi3mr_ioc *mrioc, 2065 struct mpi3_device_page0 *dev_pg0) 2066{ 2067 int retval = 0; 2068 struct mpi3mr_tgt_dev *tgtdev = NULL; 2069 u16 perst_id = 0; 2070 unsigned long flags; 2071 2072 perst_id = le16_to_cpu(dev_pg0->persistent_id); 2073 if (perst_id == MPI3_DEVICE0_PERSISTENTID_INVALID) 2074 return retval; 2075 2076 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 2077 tgtdev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, perst_id); 2078 if (tgtdev) 2079 tgtdev->state = MPI3MR_DEV_CREATED; 2080 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 2081 2082 if (tgtdev) { 2083 mpi3mr_update_tgtdev(mrioc, tgtdev, dev_pg0, true); 2084 mpi3mr_tgtdev_put(tgtdev); 2085 } else { 2086 tgtdev = mpi3mr_alloc_tgtdev(); 2087 if (!tgtdev) 2088 return -ENOMEM; 2089 mpi3mr_update_tgtdev(mrioc, tgtdev, dev_pg0, true); 2090 mpi3mr_tgtdev_add_to_list(mrioc, tgtdev); 2091 } 2092 2093 return retval; 2094} 2095 2096/** 2097 * mpi3mr_flush_delayed_cmd_lists - Flush pending commands 2098 * @mrioc: Adapter instance reference 2099 * 2100 * Flush pending commands in the delayed lists due to a 2101 * controller reset or driver removal as a cleanup. 2102 * 2103 * Return: Nothing 2104 */ 2105void mpi3mr_flush_delayed_cmd_lists(struct mpi3mr_ioc *mrioc) 2106{ 2107 struct delayed_dev_rmhs_node *_rmhs_node; 2108 struct delayed_evt_ack_node *_evtack_node; 2109 2110 dprint_reset(mrioc, "flushing delayed dev_remove_hs commands\n"); 2111 while (!list_empty(&mrioc->delayed_rmhs_list)) { 2112 _rmhs_node = list_entry(mrioc->delayed_rmhs_list.next, 2113 struct delayed_dev_rmhs_node, list); 2114 list_del(&_rmhs_node->list); 2115 kfree(_rmhs_node); 2116 } 2117 dprint_reset(mrioc, "flushing delayed event ack commands\n"); 2118 while (!list_empty(&mrioc->delayed_evtack_cmds_list)) { 2119 _evtack_node = list_entry(mrioc->delayed_evtack_cmds_list.next, 2120 struct delayed_evt_ack_node, list); 2121 list_del(&_evtack_node->list); 2122 kfree(_evtack_node); 2123 } 2124} 2125 2126/** 2127 * mpi3mr_dev_rmhs_complete_iou - Device removal IOUC completion 2128 * @mrioc: Adapter instance reference 2129 * @drv_cmd: Internal command tracker 2130 * 2131 * Issues a target reset TM to the firmware from the device 2132 * removal TM pend list or retry the removal handshake sequence 2133 * based on the IOU control request IOC status. 2134 * 2135 * Return: Nothing 2136 */ 2137static void mpi3mr_dev_rmhs_complete_iou(struct mpi3mr_ioc *mrioc, 2138 struct mpi3mr_drv_cmd *drv_cmd) 2139{ 2140 u16 cmd_idx = drv_cmd->host_tag - MPI3MR_HOSTTAG_DEVRMCMD_MIN; 2141 struct delayed_dev_rmhs_node *delayed_dev_rmhs = NULL; 2142 2143 if (drv_cmd->state & MPI3MR_CMD_RESET) 2144 goto clear_drv_cmd; 2145 2146 ioc_info(mrioc, 2147 "%s :dev_rmhs_iouctrl_complete:handle(0x%04x), ioc_status(0x%04x), loginfo(0x%08x)\n", 2148 __func__, drv_cmd->dev_handle, drv_cmd->ioc_status, 2149 drv_cmd->ioc_loginfo); 2150 if (drv_cmd->ioc_status != MPI3_IOCSTATUS_SUCCESS) { 2151 if (drv_cmd->retry_count < MPI3MR_DEV_RMHS_RETRY_COUNT) { 2152 drv_cmd->retry_count++; 2153 ioc_info(mrioc, 2154 "%s :dev_rmhs_iouctrl_complete: handle(0x%04x)retrying handshake retry=%d\n", 2155 __func__, drv_cmd->dev_handle, 2156 drv_cmd->retry_count); 2157 mpi3mr_dev_rmhs_send_tm(mrioc, drv_cmd->dev_handle, 2158 drv_cmd, drv_cmd->iou_rc); 2159 return; 2160 } 2161 ioc_err(mrioc, 2162 "%s :dev removal handshake failed after all retries: handle(0x%04x)\n", 2163 __func__, drv_cmd->dev_handle); 2164 } else { 2165 ioc_info(mrioc, 2166 "%s :dev removal handshake completed successfully: handle(0x%04x)\n", 2167 __func__, drv_cmd->dev_handle); 2168 clear_bit(drv_cmd->dev_handle, mrioc->removepend_bitmap); 2169 } 2170 2171 if (!list_empty(&mrioc->delayed_rmhs_list)) { 2172 delayed_dev_rmhs = list_entry(mrioc->delayed_rmhs_list.next, 2173 struct delayed_dev_rmhs_node, list); 2174 drv_cmd->dev_handle = delayed_dev_rmhs->handle; 2175 drv_cmd->retry_count = 0; 2176 drv_cmd->iou_rc = delayed_dev_rmhs->iou_rc; 2177 ioc_info(mrioc, 2178 "%s :dev_rmhs_iouctrl_complete: processing delayed TM: handle(0x%04x)\n", 2179 __func__, drv_cmd->dev_handle); 2180 mpi3mr_dev_rmhs_send_tm(mrioc, drv_cmd->dev_handle, drv_cmd, 2181 drv_cmd->iou_rc); 2182 list_del(&delayed_dev_rmhs->list); 2183 kfree(delayed_dev_rmhs); 2184 return; 2185 } 2186 2187clear_drv_cmd: 2188 drv_cmd->state = MPI3MR_CMD_NOTUSED; 2189 drv_cmd->callback = NULL; 2190 drv_cmd->retry_count = 0; 2191 drv_cmd->dev_handle = MPI3MR_INVALID_DEV_HANDLE; 2192 clear_bit(cmd_idx, mrioc->devrem_bitmap); 2193} 2194 2195/** 2196 * mpi3mr_dev_rmhs_complete_tm - Device removal TM completion 2197 * @mrioc: Adapter instance reference 2198 * @drv_cmd: Internal command tracker 2199 * 2200 * Issues a target reset TM to the firmware from the device 2201 * removal TM pend list or issue IO unit control request as 2202 * part of device removal or hidden acknowledgment handshake. 2203 * 2204 * Return: Nothing 2205 */ 2206static void mpi3mr_dev_rmhs_complete_tm(struct mpi3mr_ioc *mrioc, 2207 struct mpi3mr_drv_cmd *drv_cmd) 2208{ 2209 struct mpi3_iounit_control_request iou_ctrl; 2210 u16 cmd_idx = drv_cmd->host_tag - MPI3MR_HOSTTAG_DEVRMCMD_MIN; 2211 struct mpi3_scsi_task_mgmt_reply *tm_reply = NULL; 2212 int retval; 2213 2214 if (drv_cmd->state & MPI3MR_CMD_RESET) 2215 goto clear_drv_cmd; 2216 2217 if (drv_cmd->state & MPI3MR_CMD_REPLY_VALID) 2218 tm_reply = (struct mpi3_scsi_task_mgmt_reply *)drv_cmd->reply; 2219 2220 if (tm_reply) 2221 pr_info(IOCNAME 2222 "dev_rmhs_tr_complete:handle(0x%04x), ioc_status(0x%04x), loginfo(0x%08x), term_count(%d)\n", 2223 mrioc->name, drv_cmd->dev_handle, drv_cmd->ioc_status, 2224 drv_cmd->ioc_loginfo, 2225 le32_to_cpu(tm_reply->termination_count)); 2226 2227 pr_info(IOCNAME "Issuing IOU CTL: handle(0x%04x) dev_rmhs idx(%d)\n", 2228 mrioc->name, drv_cmd->dev_handle, cmd_idx); 2229 2230 memset(&iou_ctrl, 0, sizeof(iou_ctrl)); 2231 2232 drv_cmd->state = MPI3MR_CMD_PENDING; 2233 drv_cmd->is_waiting = 0; 2234 drv_cmd->callback = mpi3mr_dev_rmhs_complete_iou; 2235 iou_ctrl.operation = drv_cmd->iou_rc; 2236 iou_ctrl.param16[0] = cpu_to_le16(drv_cmd->dev_handle); 2237 iou_ctrl.host_tag = cpu_to_le16(drv_cmd->host_tag); 2238 iou_ctrl.function = MPI3_FUNCTION_IO_UNIT_CONTROL; 2239 2240 retval = mpi3mr_admin_request_post(mrioc, &iou_ctrl, sizeof(iou_ctrl), 2241 1); 2242 if (retval) { 2243 pr_err(IOCNAME "Issue DevRmHsTMIOUCTL: Admin post failed\n", 2244 mrioc->name); 2245 goto clear_drv_cmd; 2246 } 2247 2248 return; 2249clear_drv_cmd: 2250 drv_cmd->state = MPI3MR_CMD_NOTUSED; 2251 drv_cmd->callback = NULL; 2252 drv_cmd->dev_handle = MPI3MR_INVALID_DEV_HANDLE; 2253 drv_cmd->retry_count = 0; 2254 clear_bit(cmd_idx, mrioc->devrem_bitmap); 2255} 2256 2257/** 2258 * mpi3mr_dev_rmhs_send_tm - Issue TM for device removal 2259 * @mrioc: Adapter instance reference 2260 * @handle: Device handle 2261 * @cmdparam: Internal command tracker 2262 * @iou_rc: IO unit reason code 2263 * 2264 * Issues a target reset TM to the firmware or add it to a pend 2265 * list as part of device removal or hidden acknowledgment 2266 * handshake. 2267 * 2268 * Return: Nothing 2269 */ 2270static void mpi3mr_dev_rmhs_send_tm(struct mpi3mr_ioc *mrioc, u16 handle, 2271 struct mpi3mr_drv_cmd *cmdparam, u8 iou_rc) 2272{ 2273 struct mpi3_scsi_task_mgmt_request tm_req; 2274 int retval = 0; 2275 u16 cmd_idx = MPI3MR_NUM_DEVRMCMD; 2276 u8 retrycount = 5; 2277 struct mpi3mr_drv_cmd *drv_cmd = cmdparam; 2278 struct delayed_dev_rmhs_node *delayed_dev_rmhs = NULL; 2279 struct mpi3mr_tgt_dev *tgtdev = NULL; 2280 unsigned long flags; 2281 2282 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 2283 tgtdev = __mpi3mr_get_tgtdev_by_handle(mrioc, handle); 2284 if (tgtdev && (iou_rc == MPI3_CTRL_OP_REMOVE_DEVICE)) 2285 tgtdev->state = MPI3MR_DEV_REMOVE_HS_STARTED; 2286 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 2287 2288 if (drv_cmd) 2289 goto issue_cmd; 2290 do { 2291 cmd_idx = find_first_zero_bit(mrioc->devrem_bitmap, 2292 MPI3MR_NUM_DEVRMCMD); 2293 if (cmd_idx < MPI3MR_NUM_DEVRMCMD) { 2294 if (!test_and_set_bit(cmd_idx, mrioc->devrem_bitmap)) 2295 break; 2296 cmd_idx = MPI3MR_NUM_DEVRMCMD; 2297 } 2298 } while (retrycount--); 2299 2300 if (cmd_idx >= MPI3MR_NUM_DEVRMCMD) { 2301 delayed_dev_rmhs = kzalloc(sizeof(*delayed_dev_rmhs), 2302 GFP_ATOMIC); 2303 if (!delayed_dev_rmhs) 2304 return; 2305 INIT_LIST_HEAD(&delayed_dev_rmhs->list); 2306 delayed_dev_rmhs->handle = handle; 2307 delayed_dev_rmhs->iou_rc = iou_rc; 2308 list_add_tail(&delayed_dev_rmhs->list, 2309 &mrioc->delayed_rmhs_list); 2310 ioc_info(mrioc, "%s :DevRmHs: tr:handle(0x%04x) is postponed\n", 2311 __func__, handle); 2312 return; 2313 } 2314 drv_cmd = &mrioc->dev_rmhs_cmds[cmd_idx]; 2315 2316issue_cmd: 2317 cmd_idx = drv_cmd->host_tag - MPI3MR_HOSTTAG_DEVRMCMD_MIN; 2318 ioc_info(mrioc, 2319 "%s :Issuing TR TM: for devhandle 0x%04x with dev_rmhs %d\n", 2320 __func__, handle, cmd_idx); 2321 2322 memset(&tm_req, 0, sizeof(tm_req)); 2323 if (drv_cmd->state & MPI3MR_CMD_PENDING) { 2324 ioc_err(mrioc, "%s :Issue TM: Command is in use\n", __func__); 2325 goto out; 2326 } 2327 drv_cmd->state = MPI3MR_CMD_PENDING; 2328 drv_cmd->is_waiting = 0; 2329 drv_cmd->callback = mpi3mr_dev_rmhs_complete_tm; 2330 drv_cmd->dev_handle = handle; 2331 drv_cmd->iou_rc = iou_rc; 2332 tm_req.dev_handle = cpu_to_le16(handle); 2333 tm_req.task_type = MPI3_SCSITASKMGMT_TASKTYPE_TARGET_RESET; 2334 tm_req.host_tag = cpu_to_le16(drv_cmd->host_tag); 2335 tm_req.task_host_tag = cpu_to_le16(MPI3MR_HOSTTAG_INVALID); 2336 tm_req.function = MPI3_FUNCTION_SCSI_TASK_MGMT; 2337 2338 set_bit(handle, mrioc->removepend_bitmap); 2339 retval = mpi3mr_admin_request_post(mrioc, &tm_req, sizeof(tm_req), 1); 2340 if (retval) { 2341 ioc_err(mrioc, "%s :Issue DevRmHsTM: Admin Post failed\n", 2342 __func__); 2343 goto out_failed; 2344 } 2345out: 2346 return; 2347out_failed: 2348 drv_cmd->state = MPI3MR_CMD_NOTUSED; 2349 drv_cmd->callback = NULL; 2350 drv_cmd->dev_handle = MPI3MR_INVALID_DEV_HANDLE; 2351 drv_cmd->retry_count = 0; 2352 clear_bit(cmd_idx, mrioc->devrem_bitmap); 2353} 2354 2355/** 2356 * mpi3mr_complete_evt_ack - event ack request completion 2357 * @mrioc: Adapter instance reference 2358 * @drv_cmd: Internal command tracker 2359 * 2360 * This is the completion handler for non blocking event 2361 * acknowledgment sent to the firmware and this will issue any 2362 * pending event acknowledgment request. 2363 * 2364 * Return: Nothing 2365 */ 2366static void mpi3mr_complete_evt_ack(struct mpi3mr_ioc *mrioc, 2367 struct mpi3mr_drv_cmd *drv_cmd) 2368{ 2369 u16 cmd_idx = drv_cmd->host_tag - MPI3MR_HOSTTAG_EVTACKCMD_MIN; 2370 struct delayed_evt_ack_node *delayed_evtack = NULL; 2371 2372 if (drv_cmd->state & MPI3MR_CMD_RESET) 2373 goto clear_drv_cmd; 2374 2375 if (drv_cmd->ioc_status != MPI3_IOCSTATUS_SUCCESS) { 2376 dprint_event_th(mrioc, 2377 "immediate event ack failed with ioc_status(0x%04x) log_info(0x%08x)\n", 2378 (drv_cmd->ioc_status & MPI3_IOCSTATUS_STATUS_MASK), 2379 drv_cmd->ioc_loginfo); 2380 } 2381 2382 if (!list_empty(&mrioc->delayed_evtack_cmds_list)) { 2383 delayed_evtack = 2384 list_entry(mrioc->delayed_evtack_cmds_list.next, 2385 struct delayed_evt_ack_node, list); 2386 mpi3mr_send_event_ack(mrioc, delayed_evtack->event, drv_cmd, 2387 delayed_evtack->event_ctx); 2388 list_del(&delayed_evtack->list); 2389 kfree(delayed_evtack); 2390 return; 2391 } 2392clear_drv_cmd: 2393 drv_cmd->state = MPI3MR_CMD_NOTUSED; 2394 drv_cmd->callback = NULL; 2395 clear_bit(cmd_idx, mrioc->evtack_cmds_bitmap); 2396} 2397 2398/** 2399 * mpi3mr_send_event_ack - Issue event acknwoledgment request 2400 * @mrioc: Adapter instance reference 2401 * @event: MPI3 event id 2402 * @cmdparam: Internal command tracker 2403 * @event_ctx: event context 2404 * 2405 * Issues event acknowledgment request to the firmware if there 2406 * is a free command to send the event ack else it to a pend 2407 * list so that it will be processed on a completion of a prior 2408 * event acknowledgment . 2409 * 2410 * Return: Nothing 2411 */ 2412static void mpi3mr_send_event_ack(struct mpi3mr_ioc *mrioc, u8 event, 2413 struct mpi3mr_drv_cmd *cmdparam, u32 event_ctx) 2414{ 2415 struct mpi3_event_ack_request evtack_req; 2416 int retval = 0; 2417 u8 retrycount = 5; 2418 u16 cmd_idx = MPI3MR_NUM_EVTACKCMD; 2419 struct mpi3mr_drv_cmd *drv_cmd = cmdparam; 2420 struct delayed_evt_ack_node *delayed_evtack = NULL; 2421 2422 if (drv_cmd) { 2423 dprint_event_th(mrioc, 2424 "sending delayed event ack in the top half for event(0x%02x), event_ctx(0x%08x)\n", 2425 event, event_ctx); 2426 goto issue_cmd; 2427 } 2428 dprint_event_th(mrioc, 2429 "sending event ack in the top half for event(0x%02x), event_ctx(0x%08x)\n", 2430 event, event_ctx); 2431 do { 2432 cmd_idx = find_first_zero_bit(mrioc->evtack_cmds_bitmap, 2433 MPI3MR_NUM_EVTACKCMD); 2434 if (cmd_idx < MPI3MR_NUM_EVTACKCMD) { 2435 if (!test_and_set_bit(cmd_idx, 2436 mrioc->evtack_cmds_bitmap)) 2437 break; 2438 cmd_idx = MPI3MR_NUM_EVTACKCMD; 2439 } 2440 } while (retrycount--); 2441 2442 if (cmd_idx >= MPI3MR_NUM_EVTACKCMD) { 2443 delayed_evtack = kzalloc(sizeof(*delayed_evtack), 2444 GFP_ATOMIC); 2445 if (!delayed_evtack) 2446 return; 2447 INIT_LIST_HEAD(&delayed_evtack->list); 2448 delayed_evtack->event = event; 2449 delayed_evtack->event_ctx = event_ctx; 2450 list_add_tail(&delayed_evtack->list, 2451 &mrioc->delayed_evtack_cmds_list); 2452 dprint_event_th(mrioc, 2453 "event ack in the top half for event(0x%02x), event_ctx(0x%08x) is postponed\n", 2454 event, event_ctx); 2455 return; 2456 } 2457 drv_cmd = &mrioc->evtack_cmds[cmd_idx]; 2458 2459issue_cmd: 2460 cmd_idx = drv_cmd->host_tag - MPI3MR_HOSTTAG_EVTACKCMD_MIN; 2461 2462 memset(&evtack_req, 0, sizeof(evtack_req)); 2463 if (drv_cmd->state & MPI3MR_CMD_PENDING) { 2464 dprint_event_th(mrioc, 2465 "sending event ack failed due to command in use\n"); 2466 goto out; 2467 } 2468 drv_cmd->state = MPI3MR_CMD_PENDING; 2469 drv_cmd->is_waiting = 0; 2470 drv_cmd->callback = mpi3mr_complete_evt_ack; 2471 evtack_req.host_tag = cpu_to_le16(drv_cmd->host_tag); 2472 evtack_req.function = MPI3_FUNCTION_EVENT_ACK; 2473 evtack_req.event = event; 2474 evtack_req.event_context = cpu_to_le32(event_ctx); 2475 retval = mpi3mr_admin_request_post(mrioc, &evtack_req, 2476 sizeof(evtack_req), 1); 2477 if (retval) { 2478 dprint_event_th(mrioc, 2479 "posting event ack request is failed\n"); 2480 goto out_failed; 2481 } 2482 2483 dprint_event_th(mrioc, 2484 "event ack in the top half for event(0x%02x), event_ctx(0x%08x) is posted\n", 2485 event, event_ctx); 2486out: 2487 return; 2488out_failed: 2489 drv_cmd->state = MPI3MR_CMD_NOTUSED; 2490 drv_cmd->callback = NULL; 2491 clear_bit(cmd_idx, mrioc->evtack_cmds_bitmap); 2492} 2493 2494/** 2495 * mpi3mr_pcietopochg_evt_th - PCIETopologyChange evt tophalf 2496 * @mrioc: Adapter instance reference 2497 * @event_reply: event data 2498 * 2499 * Checks for the reason code and based on that either block I/O 2500 * to device, or unblock I/O to the device, or start the device 2501 * removal handshake with reason as remove with the firmware for 2502 * PCIe devices. 2503 * 2504 * Return: Nothing 2505 */ 2506static void mpi3mr_pcietopochg_evt_th(struct mpi3mr_ioc *mrioc, 2507 struct mpi3_event_notification_reply *event_reply) 2508{ 2509 struct mpi3_event_data_pcie_topology_change_list *topo_evt = 2510 (struct mpi3_event_data_pcie_topology_change_list *)event_reply->event_data; 2511 int i; 2512 u16 handle; 2513 u8 reason_code; 2514 struct mpi3mr_tgt_dev *tgtdev = NULL; 2515 struct mpi3mr_stgt_priv_data *scsi_tgt_priv_data = NULL; 2516 2517 for (i = 0; i < topo_evt->num_entries; i++) { 2518 handle = le16_to_cpu(topo_evt->port_entry[i].attached_dev_handle); 2519 if (!handle) 2520 continue; 2521 reason_code = topo_evt->port_entry[i].port_status; 2522 scsi_tgt_priv_data = NULL; 2523 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, handle); 2524 if (tgtdev && tgtdev->starget && tgtdev->starget->hostdata) 2525 scsi_tgt_priv_data = (struct mpi3mr_stgt_priv_data *) 2526 tgtdev->starget->hostdata; 2527 switch (reason_code) { 2528 case MPI3_EVENT_PCIE_TOPO_PS_NOT_RESPONDING: 2529 if (scsi_tgt_priv_data) { 2530 scsi_tgt_priv_data->dev_removed = 1; 2531 scsi_tgt_priv_data->dev_removedelay = 0; 2532 atomic_set(&scsi_tgt_priv_data->block_io, 0); 2533 } 2534 mpi3mr_dev_rmhs_send_tm(mrioc, handle, NULL, 2535 MPI3_CTRL_OP_REMOVE_DEVICE); 2536 break; 2537 case MPI3_EVENT_PCIE_TOPO_PS_DELAY_NOT_RESPONDING: 2538 if (scsi_tgt_priv_data) { 2539 scsi_tgt_priv_data->dev_removedelay = 1; 2540 atomic_inc(&scsi_tgt_priv_data->block_io); 2541 } 2542 break; 2543 case MPI3_EVENT_PCIE_TOPO_PS_RESPONDING: 2544 if (scsi_tgt_priv_data && 2545 scsi_tgt_priv_data->dev_removedelay) { 2546 scsi_tgt_priv_data->dev_removedelay = 0; 2547 atomic_dec_if_positive 2548 (&scsi_tgt_priv_data->block_io); 2549 } 2550 break; 2551 case MPI3_EVENT_PCIE_TOPO_PS_PORT_CHANGED: 2552 default: 2553 break; 2554 } 2555 if (tgtdev) 2556 mpi3mr_tgtdev_put(tgtdev); 2557 } 2558} 2559 2560/** 2561 * mpi3mr_sastopochg_evt_th - SASTopologyChange evt tophalf 2562 * @mrioc: Adapter instance reference 2563 * @event_reply: event data 2564 * 2565 * Checks for the reason code and based on that either block I/O 2566 * to device, or unblock I/O to the device, or start the device 2567 * removal handshake with reason as remove with the firmware for 2568 * SAS/SATA devices. 2569 * 2570 * Return: Nothing 2571 */ 2572static void mpi3mr_sastopochg_evt_th(struct mpi3mr_ioc *mrioc, 2573 struct mpi3_event_notification_reply *event_reply) 2574{ 2575 struct mpi3_event_data_sas_topology_change_list *topo_evt = 2576 (struct mpi3_event_data_sas_topology_change_list *)event_reply->event_data; 2577 int i; 2578 u16 handle; 2579 u8 reason_code; 2580 struct mpi3mr_tgt_dev *tgtdev = NULL; 2581 struct mpi3mr_stgt_priv_data *scsi_tgt_priv_data = NULL; 2582 2583 for (i = 0; i < topo_evt->num_entries; i++) { 2584 handle = le16_to_cpu(topo_evt->phy_entry[i].attached_dev_handle); 2585 if (!handle) 2586 continue; 2587 reason_code = topo_evt->phy_entry[i].status & 2588 MPI3_EVENT_SAS_TOPO_PHY_RC_MASK; 2589 scsi_tgt_priv_data = NULL; 2590 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, handle); 2591 if (tgtdev && tgtdev->starget && tgtdev->starget->hostdata) 2592 scsi_tgt_priv_data = (struct mpi3mr_stgt_priv_data *) 2593 tgtdev->starget->hostdata; 2594 switch (reason_code) { 2595 case MPI3_EVENT_SAS_TOPO_PHY_RC_TARG_NOT_RESPONDING: 2596 if (scsi_tgt_priv_data) { 2597 scsi_tgt_priv_data->dev_removed = 1; 2598 scsi_tgt_priv_data->dev_removedelay = 0; 2599 atomic_set(&scsi_tgt_priv_data->block_io, 0); 2600 } 2601 mpi3mr_dev_rmhs_send_tm(mrioc, handle, NULL, 2602 MPI3_CTRL_OP_REMOVE_DEVICE); 2603 break; 2604 case MPI3_EVENT_SAS_TOPO_PHY_RC_DELAY_NOT_RESPONDING: 2605 if (scsi_tgt_priv_data) { 2606 scsi_tgt_priv_data->dev_removedelay = 1; 2607 atomic_inc(&scsi_tgt_priv_data->block_io); 2608 } 2609 break; 2610 case MPI3_EVENT_SAS_TOPO_PHY_RC_RESPONDING: 2611 if (scsi_tgt_priv_data && 2612 scsi_tgt_priv_data->dev_removedelay) { 2613 scsi_tgt_priv_data->dev_removedelay = 0; 2614 atomic_dec_if_positive 2615 (&scsi_tgt_priv_data->block_io); 2616 } 2617 break; 2618 case MPI3_EVENT_SAS_TOPO_PHY_RC_PHY_CHANGED: 2619 default: 2620 break; 2621 } 2622 if (tgtdev) 2623 mpi3mr_tgtdev_put(tgtdev); 2624 } 2625} 2626 2627/** 2628 * mpi3mr_devstatuschg_evt_th - DeviceStatusChange evt tophalf 2629 * @mrioc: Adapter instance reference 2630 * @event_reply: event data 2631 * 2632 * Checks for the reason code and based on that either block I/O 2633 * to device, or unblock I/O to the device, or start the device 2634 * removal handshake with reason as remove/hide acknowledgment 2635 * with the firmware. 2636 * 2637 * Return: Nothing 2638 */ 2639static void mpi3mr_devstatuschg_evt_th(struct mpi3mr_ioc *mrioc, 2640 struct mpi3_event_notification_reply *event_reply) 2641{ 2642 u16 dev_handle = 0; 2643 u8 ublock = 0, block = 0, hide = 0, delete = 0, remove = 0; 2644 struct mpi3mr_tgt_dev *tgtdev = NULL; 2645 struct mpi3mr_stgt_priv_data *scsi_tgt_priv_data = NULL; 2646 struct mpi3_event_data_device_status_change *evtdata = 2647 (struct mpi3_event_data_device_status_change *)event_reply->event_data; 2648 2649 if (mrioc->stop_drv_processing) 2650 goto out; 2651 2652 dev_handle = le16_to_cpu(evtdata->dev_handle); 2653 2654 switch (evtdata->reason_code) { 2655 case MPI3_EVENT_DEV_STAT_RC_INT_DEVICE_RESET_STRT: 2656 case MPI3_EVENT_DEV_STAT_RC_INT_IT_NEXUS_RESET_STRT: 2657 block = 1; 2658 break; 2659 case MPI3_EVENT_DEV_STAT_RC_HIDDEN: 2660 delete = 1; 2661 hide = 1; 2662 break; 2663 case MPI3_EVENT_DEV_STAT_RC_VD_NOT_RESPONDING: 2664 delete = 1; 2665 remove = 1; 2666 break; 2667 case MPI3_EVENT_DEV_STAT_RC_INT_DEVICE_RESET_CMP: 2668 case MPI3_EVENT_DEV_STAT_RC_INT_IT_NEXUS_RESET_CMP: 2669 ublock = 1; 2670 break; 2671 default: 2672 break; 2673 } 2674 2675 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, dev_handle); 2676 if (!tgtdev) 2677 goto out; 2678 if (hide) 2679 tgtdev->is_hidden = hide; 2680 if (tgtdev->starget && tgtdev->starget->hostdata) { 2681 scsi_tgt_priv_data = (struct mpi3mr_stgt_priv_data *) 2682 tgtdev->starget->hostdata; 2683 if (block) 2684 atomic_inc(&scsi_tgt_priv_data->block_io); 2685 if (delete) 2686 scsi_tgt_priv_data->dev_removed = 1; 2687 if (ublock) 2688 atomic_dec_if_positive(&scsi_tgt_priv_data->block_io); 2689 } 2690 if (remove) 2691 mpi3mr_dev_rmhs_send_tm(mrioc, dev_handle, NULL, 2692 MPI3_CTRL_OP_REMOVE_DEVICE); 2693 if (hide) 2694 mpi3mr_dev_rmhs_send_tm(mrioc, dev_handle, NULL, 2695 MPI3_CTRL_OP_HIDDEN_ACK); 2696 2697out: 2698 if (tgtdev) 2699 mpi3mr_tgtdev_put(tgtdev); 2700} 2701 2702/** 2703 * mpi3mr_preparereset_evt_th - Prepare for reset event tophalf 2704 * @mrioc: Adapter instance reference 2705 * @event_reply: event data 2706 * 2707 * Blocks and unblocks host level I/O based on the reason code 2708 * 2709 * Return: Nothing 2710 */ 2711static void mpi3mr_preparereset_evt_th(struct mpi3mr_ioc *mrioc, 2712 struct mpi3_event_notification_reply *event_reply) 2713{ 2714 struct mpi3_event_data_prepare_for_reset *evtdata = 2715 (struct mpi3_event_data_prepare_for_reset *)event_reply->event_data; 2716 2717 if (evtdata->reason_code == MPI3_EVENT_PREPARE_RESET_RC_START) { 2718 dprint_event_th(mrioc, 2719 "prepare for reset event top half with rc=start\n"); 2720 if (mrioc->prepare_for_reset) 2721 return; 2722 mrioc->prepare_for_reset = 1; 2723 mrioc->prepare_for_reset_timeout_counter = 0; 2724 } else if (evtdata->reason_code == MPI3_EVENT_PREPARE_RESET_RC_ABORT) { 2725 dprint_event_th(mrioc, 2726 "prepare for reset top half with rc=abort\n"); 2727 mrioc->prepare_for_reset = 0; 2728 mrioc->prepare_for_reset_timeout_counter = 0; 2729 } 2730 if ((event_reply->msg_flags & MPI3_EVENT_NOTIFY_MSGFLAGS_ACK_MASK) 2731 == MPI3_EVENT_NOTIFY_MSGFLAGS_ACK_REQUIRED) 2732 mpi3mr_send_event_ack(mrioc, event_reply->event, NULL, 2733 le32_to_cpu(event_reply->event_context)); 2734} 2735 2736/** 2737 * mpi3mr_energypackchg_evt_th - Energy pack change evt tophalf 2738 * @mrioc: Adapter instance reference 2739 * @event_reply: event data 2740 * 2741 * Identifies the new shutdown timeout value and update. 2742 * 2743 * Return: Nothing 2744 */ 2745static void mpi3mr_energypackchg_evt_th(struct mpi3mr_ioc *mrioc, 2746 struct mpi3_event_notification_reply *event_reply) 2747{ 2748 struct mpi3_event_data_energy_pack_change *evtdata = 2749 (struct mpi3_event_data_energy_pack_change *)event_reply->event_data; 2750 u16 shutdown_timeout = le16_to_cpu(evtdata->shutdown_timeout); 2751 2752 if (shutdown_timeout <= 0) { 2753 ioc_warn(mrioc, 2754 "%s :Invalid Shutdown Timeout received = %d\n", 2755 __func__, shutdown_timeout); 2756 return; 2757 } 2758 2759 ioc_info(mrioc, 2760 "%s :Previous Shutdown Timeout Value = %d New Shutdown Timeout Value = %d\n", 2761 __func__, mrioc->facts.shutdown_timeout, shutdown_timeout); 2762 mrioc->facts.shutdown_timeout = shutdown_timeout; 2763} 2764 2765/** 2766 * mpi3mr_cablemgmt_evt_th - Cable management event tophalf 2767 * @mrioc: Adapter instance reference 2768 * @event_reply: event data 2769 * 2770 * Displays Cable manegemt event details. 2771 * 2772 * Return: Nothing 2773 */ 2774static void mpi3mr_cablemgmt_evt_th(struct mpi3mr_ioc *mrioc, 2775 struct mpi3_event_notification_reply *event_reply) 2776{ 2777 struct mpi3_event_data_cable_management *evtdata = 2778 (struct mpi3_event_data_cable_management *)event_reply->event_data; 2779 2780 switch (evtdata->status) { 2781 case MPI3_EVENT_CABLE_MGMT_STATUS_INSUFFICIENT_POWER: 2782 { 2783 ioc_info(mrioc, "An active cable with receptacle_id %d cannot be powered.\n" 2784 "Devices connected to this cable are not detected.\n" 2785 "This cable requires %d mW of power.\n", 2786 evtdata->receptacle_id, 2787 le32_to_cpu(evtdata->active_cable_power_requirement)); 2788 break; 2789 } 2790 case MPI3_EVENT_CABLE_MGMT_STATUS_DEGRADED: 2791 { 2792 ioc_info(mrioc, "A cable with receptacle_id %d is not running at optimal speed\n", 2793 evtdata->receptacle_id); 2794 break; 2795 } 2796 default: 2797 break; 2798 } 2799} 2800 2801/** 2802 * mpi3mr_add_event_wait_for_device_refresh - Add Wait for Device Refresh Event 2803 * @mrioc: Adapter instance reference 2804 * 2805 * Add driver specific event to make sure that the driver won't process the 2806 * events until all the devices are refreshed during soft reset. 2807 * 2808 * Return: Nothing 2809 */ 2810void mpi3mr_add_event_wait_for_device_refresh(struct mpi3mr_ioc *mrioc) 2811{ 2812 struct mpi3mr_fwevt *fwevt = NULL; 2813 2814 fwevt = mpi3mr_alloc_fwevt(0); 2815 if (!fwevt) { 2816 dprint_event_th(mrioc, 2817 "failed to schedule bottom half handler for event(0x%02x)\n", 2818 MPI3_EVENT_WAIT_FOR_DEVICES_TO_REFRESH); 2819 return; 2820 } 2821 fwevt->mrioc = mrioc; 2822 fwevt->event_id = MPI3_EVENT_WAIT_FOR_DEVICES_TO_REFRESH; 2823 fwevt->send_ack = 0; 2824 fwevt->process_evt = 1; 2825 fwevt->evt_ctx = 0; 2826 fwevt->event_data_size = 0; 2827 mpi3mr_fwevt_add_to_list(mrioc, fwevt); 2828} 2829 2830/** 2831 * mpi3mr_os_handle_events - Firmware event handler 2832 * @mrioc: Adapter instance reference 2833 * @event_reply: event data 2834 * 2835 * Identify whteher the event has to handled and acknowledged 2836 * and either process the event in the tophalf and/or schedule a 2837 * bottom half through mpi3mr_fwevt_worker. 2838 * 2839 * Return: Nothing 2840 */ 2841void mpi3mr_os_handle_events(struct mpi3mr_ioc *mrioc, 2842 struct mpi3_event_notification_reply *event_reply) 2843{ 2844 u16 evt_type, sz; 2845 struct mpi3mr_fwevt *fwevt = NULL; 2846 bool ack_req = 0, process_evt_bh = 0; 2847 2848 if (mrioc->stop_drv_processing) 2849 return; 2850 2851 if ((event_reply->msg_flags & MPI3_EVENT_NOTIFY_MSGFLAGS_ACK_MASK) 2852 == MPI3_EVENT_NOTIFY_MSGFLAGS_ACK_REQUIRED) 2853 ack_req = 1; 2854 2855 evt_type = event_reply->event; 2856 2857 switch (evt_type) { 2858 case MPI3_EVENT_DEVICE_ADDED: 2859 { 2860 struct mpi3_device_page0 *dev_pg0 = 2861 (struct mpi3_device_page0 *)event_reply->event_data; 2862 if (mpi3mr_create_tgtdev(mrioc, dev_pg0)) 2863 ioc_err(mrioc, 2864 "%s :Failed to add device in the device add event\n", 2865 __func__); 2866 else 2867 process_evt_bh = 1; 2868 break; 2869 } 2870 case MPI3_EVENT_DEVICE_STATUS_CHANGE: 2871 { 2872 process_evt_bh = 1; 2873 mpi3mr_devstatuschg_evt_th(mrioc, event_reply); 2874 break; 2875 } 2876 case MPI3_EVENT_SAS_TOPOLOGY_CHANGE_LIST: 2877 { 2878 process_evt_bh = 1; 2879 mpi3mr_sastopochg_evt_th(mrioc, event_reply); 2880 break; 2881 } 2882 case MPI3_EVENT_PCIE_TOPOLOGY_CHANGE_LIST: 2883 { 2884 process_evt_bh = 1; 2885 mpi3mr_pcietopochg_evt_th(mrioc, event_reply); 2886 break; 2887 } 2888 case MPI3_EVENT_PREPARE_FOR_RESET: 2889 { 2890 mpi3mr_preparereset_evt_th(mrioc, event_reply); 2891 ack_req = 0; 2892 break; 2893 } 2894 case MPI3_EVENT_DEVICE_INFO_CHANGED: 2895 case MPI3_EVENT_LOG_DATA: 2896 case MPI3_EVENT_ENCL_DEVICE_STATUS_CHANGE: 2897 case MPI3_EVENT_ENCL_DEVICE_ADDED: 2898 { 2899 process_evt_bh = 1; 2900 break; 2901 } 2902 case MPI3_EVENT_ENERGY_PACK_CHANGE: 2903 { 2904 mpi3mr_energypackchg_evt_th(mrioc, event_reply); 2905 break; 2906 } 2907 case MPI3_EVENT_CABLE_MGMT: 2908 { 2909 mpi3mr_cablemgmt_evt_th(mrioc, event_reply); 2910 break; 2911 } 2912 case MPI3_EVENT_SAS_DISCOVERY: 2913 case MPI3_EVENT_SAS_DEVICE_DISCOVERY_ERROR: 2914 case MPI3_EVENT_SAS_BROADCAST_PRIMITIVE: 2915 case MPI3_EVENT_PCIE_ENUMERATION: 2916 break; 2917 default: 2918 ioc_info(mrioc, "%s :event 0x%02x is not handled\n", 2919 __func__, evt_type); 2920 break; 2921 } 2922 if (process_evt_bh || ack_req) { 2923 sz = event_reply->event_data_length * 4; 2924 fwevt = mpi3mr_alloc_fwevt(sz); 2925 if (!fwevt) { 2926 ioc_info(mrioc, "%s :failure at %s:%d/%s()!\n", 2927 __func__, __FILE__, __LINE__, __func__); 2928 return; 2929 } 2930 2931 memcpy(fwevt->event_data, event_reply->event_data, sz); 2932 fwevt->mrioc = mrioc; 2933 fwevt->event_id = evt_type; 2934 fwevt->send_ack = ack_req; 2935 fwevt->process_evt = process_evt_bh; 2936 fwevt->evt_ctx = le32_to_cpu(event_reply->event_context); 2937 mpi3mr_fwevt_add_to_list(mrioc, fwevt); 2938 } 2939} 2940 2941/** 2942 * mpi3mr_setup_eedp - Setup EEDP information in MPI3 SCSI IO 2943 * @mrioc: Adapter instance reference 2944 * @scmd: SCSI command reference 2945 * @scsiio_req: MPI3 SCSI IO request 2946 * 2947 * Identifies the protection information flags from the SCSI 2948 * command and set appropriate flags in the MPI3 SCSI IO 2949 * request. 2950 * 2951 * Return: Nothing 2952 */ 2953static void mpi3mr_setup_eedp(struct mpi3mr_ioc *mrioc, 2954 struct scsi_cmnd *scmd, struct mpi3_scsi_io_request *scsiio_req) 2955{ 2956 u16 eedp_flags = 0; 2957 unsigned char prot_op = scsi_get_prot_op(scmd); 2958 2959 switch (prot_op) { 2960 case SCSI_PROT_NORMAL: 2961 return; 2962 case SCSI_PROT_READ_STRIP: 2963 eedp_flags = MPI3_EEDPFLAGS_EEDP_OP_CHECK_REMOVE; 2964 break; 2965 case SCSI_PROT_WRITE_INSERT: 2966 eedp_flags = MPI3_EEDPFLAGS_EEDP_OP_INSERT; 2967 break; 2968 case SCSI_PROT_READ_INSERT: 2969 eedp_flags = MPI3_EEDPFLAGS_EEDP_OP_INSERT; 2970 scsiio_req->msg_flags |= MPI3_SCSIIO_MSGFLAGS_METASGL_VALID; 2971 break; 2972 case SCSI_PROT_WRITE_STRIP: 2973 eedp_flags = MPI3_EEDPFLAGS_EEDP_OP_CHECK_REMOVE; 2974 scsiio_req->msg_flags |= MPI3_SCSIIO_MSGFLAGS_METASGL_VALID; 2975 break; 2976 case SCSI_PROT_READ_PASS: 2977 eedp_flags = MPI3_EEDPFLAGS_EEDP_OP_CHECK; 2978 scsiio_req->msg_flags |= MPI3_SCSIIO_MSGFLAGS_METASGL_VALID; 2979 break; 2980 case SCSI_PROT_WRITE_PASS: 2981 if (scmd->prot_flags & SCSI_PROT_IP_CHECKSUM) { 2982 eedp_flags = MPI3_EEDPFLAGS_EEDP_OP_CHECK_REGEN; 2983 scsiio_req->sgl[0].eedp.application_tag_translation_mask = 2984 0xffff; 2985 } else 2986 eedp_flags = MPI3_EEDPFLAGS_EEDP_OP_CHECK; 2987 2988 scsiio_req->msg_flags |= MPI3_SCSIIO_MSGFLAGS_METASGL_VALID; 2989 break; 2990 default: 2991 return; 2992 } 2993 2994 if (scmd->prot_flags & SCSI_PROT_GUARD_CHECK) 2995 eedp_flags |= MPI3_EEDPFLAGS_CHK_GUARD; 2996 2997 if (scmd->prot_flags & SCSI_PROT_IP_CHECKSUM) 2998 eedp_flags |= MPI3_EEDPFLAGS_HOST_GUARD_IP_CHKSUM; 2999 3000 if (scmd->prot_flags & SCSI_PROT_REF_CHECK) { 3001 eedp_flags |= MPI3_EEDPFLAGS_CHK_REF_TAG | 3002 MPI3_EEDPFLAGS_INCR_PRI_REF_TAG; 3003 scsiio_req->cdb.eedp32.primary_reference_tag = 3004 cpu_to_be32(scsi_prot_ref_tag(scmd)); 3005 } 3006 3007 if (scmd->prot_flags & SCSI_PROT_REF_INCREMENT) 3008 eedp_flags |= MPI3_EEDPFLAGS_INCR_PRI_REF_TAG; 3009 3010 eedp_flags |= MPI3_EEDPFLAGS_ESC_MODE_APPTAG_DISABLE; 3011 3012 switch (scsi_prot_interval(scmd)) { 3013 case 512: 3014 scsiio_req->sgl[0].eedp.user_data_size = MPI3_EEDP_UDS_512; 3015 break; 3016 case 520: 3017 scsiio_req->sgl[0].eedp.user_data_size = MPI3_EEDP_UDS_520; 3018 break; 3019 case 4080: 3020 scsiio_req->sgl[0].eedp.user_data_size = MPI3_EEDP_UDS_4080; 3021 break; 3022 case 4088: 3023 scsiio_req->sgl[0].eedp.user_data_size = MPI3_EEDP_UDS_4088; 3024 break; 3025 case 4096: 3026 scsiio_req->sgl[0].eedp.user_data_size = MPI3_EEDP_UDS_4096; 3027 break; 3028 case 4104: 3029 scsiio_req->sgl[0].eedp.user_data_size = MPI3_EEDP_UDS_4104; 3030 break; 3031 case 4160: 3032 scsiio_req->sgl[0].eedp.user_data_size = MPI3_EEDP_UDS_4160; 3033 break; 3034 default: 3035 break; 3036 } 3037 3038 scsiio_req->sgl[0].eedp.eedp_flags = cpu_to_le16(eedp_flags); 3039 scsiio_req->sgl[0].eedp.flags = MPI3_SGE_FLAGS_ELEMENT_TYPE_EXTENDED; 3040} 3041 3042/** 3043 * mpi3mr_build_sense_buffer - Map sense information 3044 * @desc: Sense type 3045 * @buf: Sense buffer to populate 3046 * @key: Sense key 3047 * @asc: Additional sense code 3048 * @ascq: Additional sense code qualifier 3049 * 3050 * Maps the given sense information into either descriptor or 3051 * fixed format sense data. 3052 * 3053 * Return: Nothing 3054 */ 3055static inline void mpi3mr_build_sense_buffer(int desc, u8 *buf, u8 key, 3056 u8 asc, u8 ascq) 3057{ 3058 if (desc) { 3059 buf[0] = 0x72; /* descriptor, current */ 3060 buf[1] = key; 3061 buf[2] = asc; 3062 buf[3] = ascq; 3063 buf[7] = 0; 3064 } else { 3065 buf[0] = 0x70; /* fixed, current */ 3066 buf[2] = key; 3067 buf[7] = 0xa; 3068 buf[12] = asc; 3069 buf[13] = ascq; 3070 } 3071} 3072 3073/** 3074 * mpi3mr_map_eedp_error - Map EEDP errors from IOC status 3075 * @scmd: SCSI command reference 3076 * @ioc_status: status of MPI3 request 3077 * 3078 * Maps the EEDP error status of the SCSI IO request to sense 3079 * data. 3080 * 3081 * Return: Nothing 3082 */ 3083static void mpi3mr_map_eedp_error(struct scsi_cmnd *scmd, 3084 u16 ioc_status) 3085{ 3086 u8 ascq = 0; 3087 3088 switch (ioc_status) { 3089 case MPI3_IOCSTATUS_EEDP_GUARD_ERROR: 3090 ascq = 0x01; 3091 break; 3092 case MPI3_IOCSTATUS_EEDP_APP_TAG_ERROR: 3093 ascq = 0x02; 3094 break; 3095 case MPI3_IOCSTATUS_EEDP_REF_TAG_ERROR: 3096 ascq = 0x03; 3097 break; 3098 default: 3099 ascq = 0x00; 3100 break; 3101 } 3102 3103 mpi3mr_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 3104 0x10, ascq); 3105 scmd->result = (DID_ABORT << 16) | SAM_STAT_CHECK_CONDITION; 3106} 3107 3108/** 3109 * mpi3mr_process_op_reply_desc - reply descriptor handler 3110 * @mrioc: Adapter instance reference 3111 * @reply_desc: Operational reply descriptor 3112 * @reply_dma: place holder for reply DMA address 3113 * @qidx: Operational queue index 3114 * 3115 * Process the operational reply descriptor and identifies the 3116 * descriptor type. Based on the descriptor map the MPI3 request 3117 * status to a SCSI command status and calls scsi_done call 3118 * back. 3119 * 3120 * Return: Nothing 3121 */ 3122void mpi3mr_process_op_reply_desc(struct mpi3mr_ioc *mrioc, 3123 struct mpi3_default_reply_descriptor *reply_desc, u64 *reply_dma, u16 qidx) 3124{ 3125 u16 reply_desc_type, host_tag = 0; 3126 u16 ioc_status = MPI3_IOCSTATUS_SUCCESS; 3127 u32 ioc_loginfo = 0; 3128 struct mpi3_status_reply_descriptor *status_desc = NULL; 3129 struct mpi3_address_reply_descriptor *addr_desc = NULL; 3130 struct mpi3_success_reply_descriptor *success_desc = NULL; 3131 struct mpi3_scsi_io_reply *scsi_reply = NULL; 3132 struct scsi_cmnd *scmd = NULL; 3133 struct scmd_priv *priv = NULL; 3134 u8 *sense_buf = NULL; 3135 u8 scsi_state = 0, scsi_status = 0, sense_state = 0; 3136 u32 xfer_count = 0, sense_count = 0, resp_data = 0; 3137 u16 dev_handle = 0xFFFF; 3138 struct scsi_sense_hdr sshdr; 3139 struct mpi3mr_stgt_priv_data *stgt_priv_data = NULL; 3140 struct mpi3mr_sdev_priv_data *sdev_priv_data = NULL; 3141 u32 ioc_pend_data_len = 0, tg_pend_data_len = 0, data_len_blks = 0; 3142 struct mpi3mr_throttle_group_info *tg = NULL; 3143 u8 throttle_enabled_dev = 0; 3144 3145 *reply_dma = 0; 3146 reply_desc_type = le16_to_cpu(reply_desc->reply_flags) & 3147 MPI3_REPLY_DESCRIPT_FLAGS_TYPE_MASK; 3148 switch (reply_desc_type) { 3149 case MPI3_REPLY_DESCRIPT_FLAGS_TYPE_STATUS: 3150 status_desc = (struct mpi3_status_reply_descriptor *)reply_desc; 3151 host_tag = le16_to_cpu(status_desc->host_tag); 3152 ioc_status = le16_to_cpu(status_desc->ioc_status); 3153 if (ioc_status & 3154 MPI3_REPLY_DESCRIPT_STATUS_IOCSTATUS_LOGINFOAVAIL) 3155 ioc_loginfo = le32_to_cpu(status_desc->ioc_log_info); 3156 ioc_status &= MPI3_REPLY_DESCRIPT_STATUS_IOCSTATUS_STATUS_MASK; 3157 break; 3158 case MPI3_REPLY_DESCRIPT_FLAGS_TYPE_ADDRESS_REPLY: 3159 addr_desc = (struct mpi3_address_reply_descriptor *)reply_desc; 3160 *reply_dma = le64_to_cpu(addr_desc->reply_frame_address); 3161 scsi_reply = mpi3mr_get_reply_virt_addr(mrioc, 3162 *reply_dma); 3163 if (!scsi_reply) { 3164 panic("%s: scsi_reply is NULL, this shouldn't happen\n", 3165 mrioc->name); 3166 goto out; 3167 } 3168 host_tag = le16_to_cpu(scsi_reply->host_tag); 3169 ioc_status = le16_to_cpu(scsi_reply->ioc_status); 3170 scsi_status = scsi_reply->scsi_status; 3171 scsi_state = scsi_reply->scsi_state; 3172 dev_handle = le16_to_cpu(scsi_reply->dev_handle); 3173 sense_state = (scsi_state & MPI3_SCSI_STATE_SENSE_MASK); 3174 xfer_count = le32_to_cpu(scsi_reply->transfer_count); 3175 sense_count = le32_to_cpu(scsi_reply->sense_count); 3176 resp_data = le32_to_cpu(scsi_reply->response_data); 3177 sense_buf = mpi3mr_get_sensebuf_virt_addr(mrioc, 3178 le64_to_cpu(scsi_reply->sense_data_buffer_address)); 3179 if (ioc_status & 3180 MPI3_REPLY_DESCRIPT_STATUS_IOCSTATUS_LOGINFOAVAIL) 3181 ioc_loginfo = le32_to_cpu(scsi_reply->ioc_log_info); 3182 ioc_status &= MPI3_REPLY_DESCRIPT_STATUS_IOCSTATUS_STATUS_MASK; 3183 if (sense_state == MPI3_SCSI_STATE_SENSE_BUFF_Q_EMPTY) 3184 panic("%s: Ran out of sense buffers\n", mrioc->name); 3185 break; 3186 case MPI3_REPLY_DESCRIPT_FLAGS_TYPE_SUCCESS: 3187 success_desc = (struct mpi3_success_reply_descriptor *)reply_desc; 3188 host_tag = le16_to_cpu(success_desc->host_tag); 3189 break; 3190 default: 3191 break; 3192 } 3193 scmd = mpi3mr_scmd_from_host_tag(mrioc, host_tag, qidx); 3194 if (!scmd) { 3195 panic("%s: Cannot Identify scmd for host_tag 0x%x\n", 3196 mrioc->name, host_tag); 3197 goto out; 3198 } 3199 priv = scsi_cmd_priv(scmd); 3200 3201 data_len_blks = scsi_bufflen(scmd) >> 9; 3202 sdev_priv_data = scmd->device->hostdata; 3203 if (sdev_priv_data) { 3204 stgt_priv_data = sdev_priv_data->tgt_priv_data; 3205 if (stgt_priv_data) { 3206 tg = stgt_priv_data->throttle_group; 3207 throttle_enabled_dev = 3208 stgt_priv_data->io_throttle_enabled; 3209 dev_handle = stgt_priv_data->dev_handle; 3210 } 3211 } 3212 if (unlikely((data_len_blks >= mrioc->io_throttle_data_length) && 3213 throttle_enabled_dev)) { 3214 ioc_pend_data_len = atomic_sub_return(data_len_blks, 3215 &mrioc->pend_large_data_sz); 3216 if (tg) { 3217 tg_pend_data_len = atomic_sub_return(data_len_blks, 3218 &tg->pend_large_data_sz); 3219 if (tg->io_divert && ((ioc_pend_data_len <= 3220 mrioc->io_throttle_low) && 3221 (tg_pend_data_len <= tg->low))) { 3222 tg->io_divert = 0; 3223 mpi3mr_set_io_divert_for_all_vd_in_tg( 3224 mrioc, tg, 0); 3225 } 3226 } else { 3227 if (ioc_pend_data_len <= mrioc->io_throttle_low) 3228 stgt_priv_data->io_divert = 0; 3229 } 3230 } else if (unlikely((stgt_priv_data && stgt_priv_data->io_divert))) { 3231 ioc_pend_data_len = atomic_read(&mrioc->pend_large_data_sz); 3232 if (!tg) { 3233 if (ioc_pend_data_len <= mrioc->io_throttle_low) 3234 stgt_priv_data->io_divert = 0; 3235 3236 } else if (ioc_pend_data_len <= mrioc->io_throttle_low) { 3237 tg_pend_data_len = atomic_read(&tg->pend_large_data_sz); 3238 if (tg->io_divert && (tg_pend_data_len <= tg->low)) { 3239 tg->io_divert = 0; 3240 mpi3mr_set_io_divert_for_all_vd_in_tg( 3241 mrioc, tg, 0); 3242 } 3243 } 3244 } 3245 3246 if (success_desc) { 3247 scmd->result = DID_OK << 16; 3248 goto out_success; 3249 } 3250 3251 scsi_set_resid(scmd, scsi_bufflen(scmd) - xfer_count); 3252 if (ioc_status == MPI3_IOCSTATUS_SCSI_DATA_UNDERRUN && 3253 xfer_count == 0 && (scsi_status == MPI3_SCSI_STATUS_BUSY || 3254 scsi_status == MPI3_SCSI_STATUS_RESERVATION_CONFLICT || 3255 scsi_status == MPI3_SCSI_STATUS_TASK_SET_FULL)) 3256 ioc_status = MPI3_IOCSTATUS_SUCCESS; 3257 3258 if ((sense_state == MPI3_SCSI_STATE_SENSE_VALID) && sense_count && 3259 sense_buf) { 3260 u32 sz = min_t(u32, SCSI_SENSE_BUFFERSIZE, sense_count); 3261 3262 memcpy(scmd->sense_buffer, sense_buf, sz); 3263 } 3264 3265 switch (ioc_status) { 3266 case MPI3_IOCSTATUS_BUSY: 3267 case MPI3_IOCSTATUS_INSUFFICIENT_RESOURCES: 3268 scmd->result = SAM_STAT_BUSY; 3269 break; 3270 case MPI3_IOCSTATUS_SCSI_DEVICE_NOT_THERE: 3271 scmd->result = DID_NO_CONNECT << 16; 3272 break; 3273 case MPI3_IOCSTATUS_SCSI_IOC_TERMINATED: 3274 scmd->result = DID_SOFT_ERROR << 16; 3275 break; 3276 case MPI3_IOCSTATUS_SCSI_TASK_TERMINATED: 3277 case MPI3_IOCSTATUS_SCSI_EXT_TERMINATED: 3278 scmd->result = DID_RESET << 16; 3279 break; 3280 case MPI3_IOCSTATUS_SCSI_RESIDUAL_MISMATCH: 3281 if ((xfer_count == 0) || (scmd->underflow > xfer_count)) 3282 scmd->result = DID_SOFT_ERROR << 16; 3283 else 3284 scmd->result = (DID_OK << 16) | scsi_status; 3285 break; 3286 case MPI3_IOCSTATUS_SCSI_DATA_UNDERRUN: 3287 scmd->result = (DID_OK << 16) | scsi_status; 3288 if (sense_state == MPI3_SCSI_STATE_SENSE_VALID) 3289 break; 3290 if (xfer_count < scmd->underflow) { 3291 if (scsi_status == SAM_STAT_BUSY) 3292 scmd->result = SAM_STAT_BUSY; 3293 else 3294 scmd->result = DID_SOFT_ERROR << 16; 3295 } else if ((scsi_state & (MPI3_SCSI_STATE_NO_SCSI_STATUS)) || 3296 (sense_state != MPI3_SCSI_STATE_SENSE_NOT_AVAILABLE)) 3297 scmd->result = DID_SOFT_ERROR << 16; 3298 else if (scsi_state & MPI3_SCSI_STATE_TERMINATED) 3299 scmd->result = DID_RESET << 16; 3300 break; 3301 case MPI3_IOCSTATUS_SCSI_DATA_OVERRUN: 3302 scsi_set_resid(scmd, 0); 3303 fallthrough; 3304 case MPI3_IOCSTATUS_SCSI_RECOVERED_ERROR: 3305 case MPI3_IOCSTATUS_SUCCESS: 3306 scmd->result = (DID_OK << 16) | scsi_status; 3307 if ((scsi_state & (MPI3_SCSI_STATE_NO_SCSI_STATUS)) || 3308 (sense_state == MPI3_SCSI_STATE_SENSE_FAILED) || 3309 (sense_state == MPI3_SCSI_STATE_SENSE_BUFF_Q_EMPTY)) 3310 scmd->result = DID_SOFT_ERROR << 16; 3311 else if (scsi_state & MPI3_SCSI_STATE_TERMINATED) 3312 scmd->result = DID_RESET << 16; 3313 break; 3314 case MPI3_IOCSTATUS_EEDP_GUARD_ERROR: 3315 case MPI3_IOCSTATUS_EEDP_REF_TAG_ERROR: 3316 case MPI3_IOCSTATUS_EEDP_APP_TAG_ERROR: 3317 mpi3mr_map_eedp_error(scmd, ioc_status); 3318 break; 3319 case MPI3_IOCSTATUS_SCSI_PROTOCOL_ERROR: 3320 case MPI3_IOCSTATUS_INVALID_FUNCTION: 3321 case MPI3_IOCSTATUS_INVALID_SGL: 3322 case MPI3_IOCSTATUS_INTERNAL_ERROR: 3323 case MPI3_IOCSTATUS_INVALID_FIELD: 3324 case MPI3_IOCSTATUS_INVALID_STATE: 3325 case MPI3_IOCSTATUS_SCSI_IO_DATA_ERROR: 3326 case MPI3_IOCSTATUS_SCSI_TASK_MGMT_FAILED: 3327 case MPI3_IOCSTATUS_INSUFFICIENT_POWER: 3328 default: 3329 scmd->result = DID_SOFT_ERROR << 16; 3330 break; 3331 } 3332 3333 if (scmd->result != (DID_OK << 16) && (scmd->cmnd[0] != ATA_12) && 3334 (scmd->cmnd[0] != ATA_16) && 3335 mrioc->logging_level & MPI3_DEBUG_SCSI_ERROR) { 3336 ioc_info(mrioc, "%s :scmd->result 0x%x\n", __func__, 3337 scmd->result); 3338 scsi_print_command(scmd); 3339 ioc_info(mrioc, 3340 "%s :Command issued to handle 0x%02x returned with error 0x%04x loginfo 0x%08x, qid %d\n", 3341 __func__, dev_handle, ioc_status, ioc_loginfo, 3342 priv->req_q_idx + 1); 3343 ioc_info(mrioc, 3344 " host_tag %d scsi_state 0x%02x scsi_status 0x%02x, xfer_cnt %d resp_data 0x%x\n", 3345 host_tag, scsi_state, scsi_status, xfer_count, resp_data); 3346 if (sense_buf) { 3347 scsi_normalize_sense(sense_buf, sense_count, &sshdr); 3348 ioc_info(mrioc, 3349 "%s :sense_count 0x%x, sense_key 0x%x ASC 0x%x, ASCQ 0x%x\n", 3350 __func__, sense_count, sshdr.sense_key, 3351 sshdr.asc, sshdr.ascq); 3352 } 3353 } 3354out_success: 3355 if (priv->meta_sg_valid) { 3356 dma_unmap_sg(&mrioc->pdev->dev, scsi_prot_sglist(scmd), 3357 scsi_prot_sg_count(scmd), scmd->sc_data_direction); 3358 } 3359 mpi3mr_clear_scmd_priv(mrioc, scmd); 3360 scsi_dma_unmap(scmd); 3361 scsi_done(scmd); 3362out: 3363 if (sense_buf) 3364 mpi3mr_repost_sense_buf(mrioc, 3365 le64_to_cpu(scsi_reply->sense_data_buffer_address)); 3366} 3367 3368/** 3369 * mpi3mr_get_chain_idx - get free chain buffer index 3370 * @mrioc: Adapter instance reference 3371 * 3372 * Try to get a free chain buffer index from the free pool. 3373 * 3374 * Return: -1 on failure or the free chain buffer index 3375 */ 3376static int mpi3mr_get_chain_idx(struct mpi3mr_ioc *mrioc) 3377{ 3378 u8 retry_count = 5; 3379 int cmd_idx = -1; 3380 unsigned long flags; 3381 3382 spin_lock_irqsave(&mrioc->chain_buf_lock, flags); 3383 do { 3384 cmd_idx = find_first_zero_bit(mrioc->chain_bitmap, 3385 mrioc->chain_buf_count); 3386 if (cmd_idx < mrioc->chain_buf_count) { 3387 set_bit(cmd_idx, mrioc->chain_bitmap); 3388 break; 3389 } 3390 cmd_idx = -1; 3391 } while (retry_count--); 3392 spin_unlock_irqrestore(&mrioc->chain_buf_lock, flags); 3393 return cmd_idx; 3394} 3395 3396/** 3397 * mpi3mr_prepare_sg_scmd - build scatter gather list 3398 * @mrioc: Adapter instance reference 3399 * @scmd: SCSI command reference 3400 * @scsiio_req: MPI3 SCSI IO request 3401 * 3402 * This function maps SCSI command's data and protection SGEs to 3403 * MPI request SGEs. If required additional 4K chain buffer is 3404 * used to send the SGEs. 3405 * 3406 * Return: 0 on success, -ENOMEM on dma_map_sg failure 3407 */ 3408static int mpi3mr_prepare_sg_scmd(struct mpi3mr_ioc *mrioc, 3409 struct scsi_cmnd *scmd, struct mpi3_scsi_io_request *scsiio_req) 3410{ 3411 dma_addr_t chain_dma; 3412 struct scatterlist *sg_scmd; 3413 void *sg_local, *chain; 3414 u32 chain_length; 3415 int sges_left, chain_idx; 3416 u32 sges_in_segment; 3417 u8 simple_sgl_flags; 3418 u8 simple_sgl_flags_last; 3419 u8 last_chain_sgl_flags; 3420 struct chain_element *chain_req; 3421 struct scmd_priv *priv = NULL; 3422 u32 meta_sg = le32_to_cpu(scsiio_req->flags) & 3423 MPI3_SCSIIO_FLAGS_DMAOPERATION_HOST_PI; 3424 3425 priv = scsi_cmd_priv(scmd); 3426 3427 simple_sgl_flags = MPI3_SGE_FLAGS_ELEMENT_TYPE_SIMPLE | 3428 MPI3_SGE_FLAGS_DLAS_SYSTEM; 3429 simple_sgl_flags_last = simple_sgl_flags | 3430 MPI3_SGE_FLAGS_END_OF_LIST; 3431 last_chain_sgl_flags = MPI3_SGE_FLAGS_ELEMENT_TYPE_LAST_CHAIN | 3432 MPI3_SGE_FLAGS_DLAS_SYSTEM; 3433 3434 if (meta_sg) 3435 sg_local = &scsiio_req->sgl[MPI3_SCSIIO_METASGL_INDEX]; 3436 else 3437 sg_local = &scsiio_req->sgl; 3438 3439 if (!scsiio_req->data_length && !meta_sg) { 3440 mpi3mr_build_zero_len_sge(sg_local); 3441 return 0; 3442 } 3443 3444 if (meta_sg) { 3445 sg_scmd = scsi_prot_sglist(scmd); 3446 sges_left = dma_map_sg(&mrioc->pdev->dev, 3447 scsi_prot_sglist(scmd), 3448 scsi_prot_sg_count(scmd), 3449 scmd->sc_data_direction); 3450 priv->meta_sg_valid = 1; /* To unmap meta sg DMA */ 3451 } else { 3452 sg_scmd = scsi_sglist(scmd); 3453 sges_left = scsi_dma_map(scmd); 3454 } 3455 3456 if (sges_left < 0) { 3457 sdev_printk(KERN_ERR, scmd->device, 3458 "scsi_dma_map failed: request for %d bytes!\n", 3459 scsi_bufflen(scmd)); 3460 return -ENOMEM; 3461 } 3462 if (sges_left > mrioc->max_sgl_entries) { 3463 sdev_printk(KERN_ERR, scmd->device, 3464 "scsi_dma_map returned unsupported sge count %d!\n", 3465 sges_left); 3466 return -ENOMEM; 3467 } 3468 3469 sges_in_segment = (mrioc->facts.op_req_sz - 3470 offsetof(struct mpi3_scsi_io_request, sgl)) / sizeof(struct mpi3_sge_common); 3471 3472 if (scsiio_req->sgl[0].eedp.flags == 3473 MPI3_SGE_FLAGS_ELEMENT_TYPE_EXTENDED && !meta_sg) { 3474 sg_local += sizeof(struct mpi3_sge_common); 3475 sges_in_segment--; 3476 /* Reserve 1st segment (scsiio_req->sgl[0]) for eedp */ 3477 } 3478 3479 if (scsiio_req->msg_flags == 3480 MPI3_SCSIIO_MSGFLAGS_METASGL_VALID && !meta_sg) { 3481 sges_in_segment--; 3482 /* Reserve last segment (scsiio_req->sgl[3]) for meta sg */ 3483 } 3484 3485 if (meta_sg) 3486 sges_in_segment = 1; 3487 3488 if (sges_left <= sges_in_segment) 3489 goto fill_in_last_segment; 3490 3491 /* fill in main message segment when there is a chain following */ 3492 while (sges_in_segment > 1) { 3493 mpi3mr_add_sg_single(sg_local, simple_sgl_flags, 3494 sg_dma_len(sg_scmd), sg_dma_address(sg_scmd)); 3495 sg_scmd = sg_next(sg_scmd); 3496 sg_local += sizeof(struct mpi3_sge_common); 3497 sges_left--; 3498 sges_in_segment--; 3499 } 3500 3501 chain_idx = mpi3mr_get_chain_idx(mrioc); 3502 if (chain_idx < 0) 3503 return -1; 3504 chain_req = &mrioc->chain_sgl_list[chain_idx]; 3505 if (meta_sg) 3506 priv->meta_chain_idx = chain_idx; 3507 else 3508 priv->chain_idx = chain_idx; 3509 3510 chain = chain_req->addr; 3511 chain_dma = chain_req->dma_addr; 3512 sges_in_segment = sges_left; 3513 chain_length = sges_in_segment * sizeof(struct mpi3_sge_common); 3514 3515 mpi3mr_add_sg_single(sg_local, last_chain_sgl_flags, 3516 chain_length, chain_dma); 3517 3518 sg_local = chain; 3519 3520fill_in_last_segment: 3521 while (sges_left > 0) { 3522 if (sges_left == 1) 3523 mpi3mr_add_sg_single(sg_local, 3524 simple_sgl_flags_last, sg_dma_len(sg_scmd), 3525 sg_dma_address(sg_scmd)); 3526 else 3527 mpi3mr_add_sg_single(sg_local, simple_sgl_flags, 3528 sg_dma_len(sg_scmd), sg_dma_address(sg_scmd)); 3529 sg_scmd = sg_next(sg_scmd); 3530 sg_local += sizeof(struct mpi3_sge_common); 3531 sges_left--; 3532 } 3533 3534 return 0; 3535} 3536 3537/** 3538 * mpi3mr_build_sg_scmd - build scatter gather list for SCSI IO 3539 * @mrioc: Adapter instance reference 3540 * @scmd: SCSI command reference 3541 * @scsiio_req: MPI3 SCSI IO request 3542 * 3543 * This function calls mpi3mr_prepare_sg_scmd for constructing 3544 * both data SGEs and protection information SGEs in the MPI 3545 * format from the SCSI Command as appropriate . 3546 * 3547 * Return: return value of mpi3mr_prepare_sg_scmd. 3548 */ 3549static int mpi3mr_build_sg_scmd(struct mpi3mr_ioc *mrioc, 3550 struct scsi_cmnd *scmd, struct mpi3_scsi_io_request *scsiio_req) 3551{ 3552 int ret; 3553 3554 ret = mpi3mr_prepare_sg_scmd(mrioc, scmd, scsiio_req); 3555 if (ret) 3556 return ret; 3557 3558 if (scsiio_req->msg_flags == MPI3_SCSIIO_MSGFLAGS_METASGL_VALID) { 3559 /* There is a valid meta sg */ 3560 scsiio_req->flags |= 3561 cpu_to_le32(MPI3_SCSIIO_FLAGS_DMAOPERATION_HOST_PI); 3562 ret = mpi3mr_prepare_sg_scmd(mrioc, scmd, scsiio_req); 3563 } 3564 3565 return ret; 3566} 3567 3568/** 3569 * mpi3mr_tm_response_name - get TM response as a string 3570 * @resp_code: TM response code 3571 * 3572 * Convert known task management response code as a readable 3573 * string. 3574 * 3575 * Return: response code string. 3576 */ 3577static const char *mpi3mr_tm_response_name(u8 resp_code) 3578{ 3579 char *desc; 3580 3581 switch (resp_code) { 3582 case MPI3_SCSITASKMGMT_RSPCODE_TM_COMPLETE: 3583 desc = "task management request completed"; 3584 break; 3585 case MPI3_SCSITASKMGMT_RSPCODE_INVALID_FRAME: 3586 desc = "invalid frame"; 3587 break; 3588 case MPI3_SCSITASKMGMT_RSPCODE_TM_FUNCTION_NOT_SUPPORTED: 3589 desc = "task management request not supported"; 3590 break; 3591 case MPI3_SCSITASKMGMT_RSPCODE_TM_FAILED: 3592 desc = "task management request failed"; 3593 break; 3594 case MPI3_SCSITASKMGMT_RSPCODE_TM_SUCCEEDED: 3595 desc = "task management request succeeded"; 3596 break; 3597 case MPI3_SCSITASKMGMT_RSPCODE_TM_INVALID_LUN: 3598 desc = "invalid LUN"; 3599 break; 3600 case MPI3_SCSITASKMGMT_RSPCODE_TM_OVERLAPPED_TAG: 3601 desc = "overlapped tag attempted"; 3602 break; 3603 case MPI3_SCSITASKMGMT_RSPCODE_IO_QUEUED_ON_IOC: 3604 desc = "task queued, however not sent to target"; 3605 break; 3606 case MPI3_SCSITASKMGMT_RSPCODE_TM_NVME_DENIED: 3607 desc = "task management request denied by NVMe device"; 3608 break; 3609 default: 3610 desc = "unknown"; 3611 break; 3612 } 3613 3614 return desc; 3615} 3616 3617inline void mpi3mr_poll_pend_io_completions(struct mpi3mr_ioc *mrioc) 3618{ 3619 int i; 3620 int num_of_reply_queues = 3621 mrioc->num_op_reply_q + mrioc->op_reply_q_offset; 3622 3623 for (i = mrioc->op_reply_q_offset; i < num_of_reply_queues; i++) 3624 mpi3mr_process_op_reply_q(mrioc, 3625 mrioc->intr_info[i].op_reply_q); 3626} 3627 3628/** 3629 * mpi3mr_issue_tm - Issue Task Management request 3630 * @mrioc: Adapter instance reference 3631 * @tm_type: Task Management type 3632 * @handle: Device handle 3633 * @lun: lun ID 3634 * @htag: Host tag of the TM request 3635 * @timeout: TM timeout value 3636 * @drv_cmd: Internal command tracker 3637 * @resp_code: Response code place holder 3638 * @scmd: SCSI command 3639 * 3640 * Issues a Task Management Request to the controller for a 3641 * specified target, lun and command and wait for its completion 3642 * and check TM response. Recover the TM if it timed out by 3643 * issuing controller reset. 3644 * 3645 * Return: 0 on success, non-zero on errors 3646 */ 3647int mpi3mr_issue_tm(struct mpi3mr_ioc *mrioc, u8 tm_type, 3648 u16 handle, uint lun, u16 htag, ulong timeout, 3649 struct mpi3mr_drv_cmd *drv_cmd, 3650 u8 *resp_code, struct scsi_cmnd *scmd) 3651{ 3652 struct mpi3_scsi_task_mgmt_request tm_req; 3653 struct mpi3_scsi_task_mgmt_reply *tm_reply = NULL; 3654 int retval = 0; 3655 struct mpi3mr_tgt_dev *tgtdev = NULL; 3656 struct mpi3mr_stgt_priv_data *scsi_tgt_priv_data = NULL; 3657 struct scmd_priv *cmd_priv = NULL; 3658 struct scsi_device *sdev = NULL; 3659 struct mpi3mr_sdev_priv_data *sdev_priv_data = NULL; 3660 3661 ioc_info(mrioc, "%s :Issue TM: TM type (0x%x) for devhandle 0x%04x\n", 3662 __func__, tm_type, handle); 3663 if (mrioc->unrecoverable) { 3664 retval = -1; 3665 ioc_err(mrioc, "%s :Issue TM: Unrecoverable controller\n", 3666 __func__); 3667 goto out; 3668 } 3669 3670 memset(&tm_req, 0, sizeof(tm_req)); 3671 mutex_lock(&drv_cmd->mutex); 3672 if (drv_cmd->state & MPI3MR_CMD_PENDING) { 3673 retval = -1; 3674 ioc_err(mrioc, "%s :Issue TM: Command is in use\n", __func__); 3675 mutex_unlock(&drv_cmd->mutex); 3676 goto out; 3677 } 3678 if (mrioc->reset_in_progress) { 3679 retval = -1; 3680 ioc_err(mrioc, "%s :Issue TM: Reset in progress\n", __func__); 3681 mutex_unlock(&drv_cmd->mutex); 3682 goto out; 3683 } 3684 3685 drv_cmd->state = MPI3MR_CMD_PENDING; 3686 drv_cmd->is_waiting = 1; 3687 drv_cmd->callback = NULL; 3688 tm_req.dev_handle = cpu_to_le16(handle); 3689 tm_req.task_type = tm_type; 3690 tm_req.host_tag = cpu_to_le16(htag); 3691 3692 int_to_scsilun(lun, (struct scsi_lun *)tm_req.lun); 3693 tm_req.function = MPI3_FUNCTION_SCSI_TASK_MGMT; 3694 3695 tgtdev = mpi3mr_get_tgtdev_by_handle(mrioc, handle); 3696 3697 if (scmd) { 3698 sdev = scmd->device; 3699 sdev_priv_data = sdev->hostdata; 3700 scsi_tgt_priv_data = ((sdev_priv_data) ? 3701 sdev_priv_data->tgt_priv_data : NULL); 3702 } else { 3703 if (tgtdev && tgtdev->starget && tgtdev->starget->hostdata) 3704 scsi_tgt_priv_data = (struct mpi3mr_stgt_priv_data *) 3705 tgtdev->starget->hostdata; 3706 } 3707 3708 if (scsi_tgt_priv_data) 3709 atomic_inc(&scsi_tgt_priv_data->block_io); 3710 3711 if (tgtdev && (tgtdev->dev_type == MPI3_DEVICE_DEVFORM_PCIE)) { 3712 if (cmd_priv && tgtdev->dev_spec.pcie_inf.abort_to) 3713 timeout = tgtdev->dev_spec.pcie_inf.abort_to; 3714 else if (!cmd_priv && tgtdev->dev_spec.pcie_inf.reset_to) 3715 timeout = tgtdev->dev_spec.pcie_inf.reset_to; 3716 } 3717 3718 init_completion(&drv_cmd->done); 3719 retval = mpi3mr_admin_request_post(mrioc, &tm_req, sizeof(tm_req), 1); 3720 if (retval) { 3721 ioc_err(mrioc, "%s :Issue TM: Admin Post failed\n", __func__); 3722 goto out_unlock; 3723 } 3724 wait_for_completion_timeout(&drv_cmd->done, (timeout * HZ)); 3725 3726 if (!(drv_cmd->state & MPI3MR_CMD_COMPLETE)) { 3727 drv_cmd->is_waiting = 0; 3728 retval = -1; 3729 if (!(drv_cmd->state & MPI3MR_CMD_RESET)) { 3730 dprint_tm(mrioc, 3731 "task management request timed out after %ld seconds\n", 3732 timeout); 3733 if (mrioc->logging_level & MPI3_DEBUG_TM) 3734 dprint_dump_req(&tm_req, sizeof(tm_req)/4); 3735 mpi3mr_soft_reset_handler(mrioc, 3736 MPI3MR_RESET_FROM_TM_TIMEOUT, 1); 3737 } 3738 goto out_unlock; 3739 } 3740 3741 if (!(drv_cmd->state & MPI3MR_CMD_REPLY_VALID)) { 3742 dprint_tm(mrioc, "invalid task management reply message\n"); 3743 retval = -1; 3744 goto out_unlock; 3745 } 3746 3747 tm_reply = (struct mpi3_scsi_task_mgmt_reply *)drv_cmd->reply; 3748 3749 switch (drv_cmd->ioc_status) { 3750 case MPI3_IOCSTATUS_SUCCESS: 3751 *resp_code = le32_to_cpu(tm_reply->response_data) & 3752 MPI3MR_RI_MASK_RESPCODE; 3753 break; 3754 case MPI3_IOCSTATUS_SCSI_IOC_TERMINATED: 3755 *resp_code = MPI3_SCSITASKMGMT_RSPCODE_TM_COMPLETE; 3756 break; 3757 default: 3758 dprint_tm(mrioc, 3759 "task management request to handle(0x%04x) is failed with ioc_status(0x%04x) log_info(0x%08x)\n", 3760 handle, drv_cmd->ioc_status, drv_cmd->ioc_loginfo); 3761 retval = -1; 3762 goto out_unlock; 3763 } 3764 3765 switch (*resp_code) { 3766 case MPI3_SCSITASKMGMT_RSPCODE_TM_SUCCEEDED: 3767 case MPI3_SCSITASKMGMT_RSPCODE_TM_COMPLETE: 3768 break; 3769 case MPI3_SCSITASKMGMT_RSPCODE_IO_QUEUED_ON_IOC: 3770 if (tm_type != MPI3_SCSITASKMGMT_TASKTYPE_QUERY_TASK) 3771 retval = -1; 3772 break; 3773 default: 3774 retval = -1; 3775 break; 3776 } 3777 3778 dprint_tm(mrioc, 3779 "task management request type(%d) completed for handle(0x%04x) with ioc_status(0x%04x), log_info(0x%08x), termination_count(%d), response:%s(0x%x)\n", 3780 tm_type, handle, drv_cmd->ioc_status, drv_cmd->ioc_loginfo, 3781 le32_to_cpu(tm_reply->termination_count), 3782 mpi3mr_tm_response_name(*resp_code), *resp_code); 3783 3784 if (!retval) { 3785 mpi3mr_ioc_disable_intr(mrioc); 3786 mpi3mr_poll_pend_io_completions(mrioc); 3787 mpi3mr_ioc_enable_intr(mrioc); 3788 mpi3mr_poll_pend_io_completions(mrioc); 3789 mpi3mr_process_admin_reply_q(mrioc); 3790 } 3791 switch (tm_type) { 3792 case MPI3_SCSITASKMGMT_TASKTYPE_TARGET_RESET: 3793 if (!scsi_tgt_priv_data) 3794 break; 3795 scsi_tgt_priv_data->pend_count = 0; 3796 blk_mq_tagset_busy_iter(&mrioc->shost->tag_set, 3797 mpi3mr_count_tgt_pending, 3798 (void *)scsi_tgt_priv_data->starget); 3799 break; 3800 case MPI3_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET: 3801 if (!sdev_priv_data) 3802 break; 3803 sdev_priv_data->pend_count = 0; 3804 blk_mq_tagset_busy_iter(&mrioc->shost->tag_set, 3805 mpi3mr_count_dev_pending, (void *)sdev); 3806 break; 3807 default: 3808 break; 3809 } 3810 3811out_unlock: 3812 drv_cmd->state = MPI3MR_CMD_NOTUSED; 3813 mutex_unlock(&drv_cmd->mutex); 3814 if (scsi_tgt_priv_data) 3815 atomic_dec_if_positive(&scsi_tgt_priv_data->block_io); 3816 if (tgtdev) 3817 mpi3mr_tgtdev_put(tgtdev); 3818out: 3819 return retval; 3820} 3821 3822/** 3823 * mpi3mr_bios_param - BIOS param callback 3824 * @sdev: SCSI device reference 3825 * @bdev: Block device reference 3826 * @capacity: Capacity in logical sectors 3827 * @params: Parameter array 3828 * 3829 * Just the parameters with heads/secots/cylinders. 3830 * 3831 * Return: 0 always 3832 */ 3833static int mpi3mr_bios_param(struct scsi_device *sdev, 3834 struct block_device *bdev, sector_t capacity, int params[]) 3835{ 3836 int heads; 3837 int sectors; 3838 sector_t cylinders; 3839 ulong dummy; 3840 3841 heads = 64; 3842 sectors = 32; 3843 3844 dummy = heads * sectors; 3845 cylinders = capacity; 3846 sector_div(cylinders, dummy); 3847 3848 if ((ulong)capacity >= 0x200000) { 3849 heads = 255; 3850 sectors = 63; 3851 dummy = heads * sectors; 3852 cylinders = capacity; 3853 sector_div(cylinders, dummy); 3854 } 3855 3856 params[0] = heads; 3857 params[1] = sectors; 3858 params[2] = cylinders; 3859 return 0; 3860} 3861 3862/** 3863 * mpi3mr_map_queues - Map queues callback handler 3864 * @shost: SCSI host reference 3865 * 3866 * Maps default and poll queues. 3867 * 3868 * Return: return zero. 3869 */ 3870static void mpi3mr_map_queues(struct Scsi_Host *shost) 3871{ 3872 struct mpi3mr_ioc *mrioc = shost_priv(shost); 3873 int i, qoff, offset; 3874 struct blk_mq_queue_map *map = NULL; 3875 3876 offset = mrioc->op_reply_q_offset; 3877 3878 for (i = 0, qoff = 0; i < HCTX_MAX_TYPES; i++) { 3879 map = &shost->tag_set.map[i]; 3880 3881 map->nr_queues = 0; 3882 3883 if (i == HCTX_TYPE_DEFAULT) 3884 map->nr_queues = mrioc->default_qcount; 3885 else if (i == HCTX_TYPE_POLL) 3886 map->nr_queues = mrioc->active_poll_qcount; 3887 3888 if (!map->nr_queues) { 3889 BUG_ON(i == HCTX_TYPE_DEFAULT); 3890 continue; 3891 } 3892 3893 /* 3894 * The poll queue(s) doesn't have an IRQ (and hence IRQ 3895 * affinity), so use the regular blk-mq cpu mapping 3896 */ 3897 map->queue_offset = qoff; 3898 if (i != HCTX_TYPE_POLL) 3899 blk_mq_pci_map_queues(map, mrioc->pdev, offset); 3900 else 3901 blk_mq_map_queues(map); 3902 3903 qoff += map->nr_queues; 3904 offset += map->nr_queues; 3905 } 3906} 3907 3908/** 3909 * mpi3mr_get_fw_pending_ios - Calculate pending I/O count 3910 * @mrioc: Adapter instance reference 3911 * 3912 * Calculate the pending I/Os for the controller and return. 3913 * 3914 * Return: Number of pending I/Os 3915 */ 3916static inline int mpi3mr_get_fw_pending_ios(struct mpi3mr_ioc *mrioc) 3917{ 3918 u16 i; 3919 uint pend_ios = 0; 3920 3921 for (i = 0; i < mrioc->num_op_reply_q; i++) 3922 pend_ios += atomic_read(&mrioc->op_reply_qinfo[i].pend_ios); 3923 return pend_ios; 3924} 3925 3926/** 3927 * mpi3mr_print_pending_host_io - print pending I/Os 3928 * @mrioc: Adapter instance reference 3929 * 3930 * Print number of pending I/Os and each I/O details prior to 3931 * reset for debug purpose. 3932 * 3933 * Return: Nothing 3934 */ 3935static void mpi3mr_print_pending_host_io(struct mpi3mr_ioc *mrioc) 3936{ 3937 struct Scsi_Host *shost = mrioc->shost; 3938 3939 ioc_info(mrioc, "%s :Pending commands prior to reset: %d\n", 3940 __func__, mpi3mr_get_fw_pending_ios(mrioc)); 3941 blk_mq_tagset_busy_iter(&shost->tag_set, 3942 mpi3mr_print_scmd, (void *)mrioc); 3943} 3944 3945/** 3946 * mpi3mr_wait_for_host_io - block for I/Os to complete 3947 * @mrioc: Adapter instance reference 3948 * @timeout: time out in seconds 3949 * Waits for pending I/Os for the given adapter to complete or 3950 * to hit the timeout. 3951 * 3952 * Return: Nothing 3953 */ 3954void mpi3mr_wait_for_host_io(struct mpi3mr_ioc *mrioc, u32 timeout) 3955{ 3956 enum mpi3mr_iocstate iocstate; 3957 int i = 0; 3958 3959 iocstate = mpi3mr_get_iocstate(mrioc); 3960 if (iocstate != MRIOC_STATE_READY) 3961 return; 3962 3963 if (!mpi3mr_get_fw_pending_ios(mrioc)) 3964 return; 3965 ioc_info(mrioc, 3966 "%s :Waiting for %d seconds prior to reset for %d I/O\n", 3967 __func__, timeout, mpi3mr_get_fw_pending_ios(mrioc)); 3968 3969 for (i = 0; i < timeout; i++) { 3970 if (!mpi3mr_get_fw_pending_ios(mrioc)) 3971 break; 3972 iocstate = mpi3mr_get_iocstate(mrioc); 3973 if (iocstate != MRIOC_STATE_READY) 3974 break; 3975 msleep(1000); 3976 } 3977 3978 ioc_info(mrioc, "%s :Pending I/Os after wait is: %d\n", __func__, 3979 mpi3mr_get_fw_pending_ios(mrioc)); 3980} 3981 3982/** 3983 * mpi3mr_setup_divert_ws - Setup Divert IO flag for write same 3984 * @mrioc: Adapter instance reference 3985 * @scmd: SCSI command reference 3986 * @scsiio_req: MPI3 SCSI IO request 3987 * @scsiio_flags: Pointer to MPI3 SCSI IO Flags 3988 * @wslen: write same max length 3989 * 3990 * Gets values of unmap, ndob and number of blocks from write 3991 * same scsi io and based on these values it sets divert IO flag 3992 * and reason for diverting IO to firmware. 3993 * 3994 * Return: Nothing 3995 */ 3996static inline void mpi3mr_setup_divert_ws(struct mpi3mr_ioc *mrioc, 3997 struct scsi_cmnd *scmd, struct mpi3_scsi_io_request *scsiio_req, 3998 u32 *scsiio_flags, u16 wslen) 3999{ 4000 u8 unmap = 0, ndob = 0; 4001 u8 opcode = scmd->cmnd[0]; 4002 u32 num_blocks = 0; 4003 u16 sa = (scmd->cmnd[8] << 8) | (scmd->cmnd[9]); 4004 4005 if (opcode == WRITE_SAME_16) { 4006 unmap = scmd->cmnd[1] & 0x08; 4007 ndob = scmd->cmnd[1] & 0x01; 4008 num_blocks = get_unaligned_be32(scmd->cmnd + 10); 4009 } else if ((opcode == VARIABLE_LENGTH_CMD) && (sa == WRITE_SAME_32)) { 4010 unmap = scmd->cmnd[10] & 0x08; 4011 ndob = scmd->cmnd[10] & 0x01; 4012 num_blocks = get_unaligned_be32(scmd->cmnd + 28); 4013 } else 4014 return; 4015 4016 if ((unmap) && (ndob) && (num_blocks > wslen)) { 4017 scsiio_req->msg_flags |= 4018 MPI3_SCSIIO_MSGFLAGS_DIVERT_TO_FIRMWARE; 4019 *scsiio_flags |= 4020 MPI3_SCSIIO_FLAGS_DIVERT_REASON_WRITE_SAME_TOO_LARGE; 4021 } 4022} 4023 4024/** 4025 * mpi3mr_eh_host_reset - Host reset error handling callback 4026 * @scmd: SCSI command reference 4027 * 4028 * Issue controller reset 4029 * 4030 * Return: SUCCESS of successful reset else FAILED 4031 */ 4032static int mpi3mr_eh_host_reset(struct scsi_cmnd *scmd) 4033{ 4034 struct mpi3mr_ioc *mrioc = shost_priv(scmd->device->host); 4035 int retval = FAILED, ret; 4036 4037 ret = mpi3mr_soft_reset_handler(mrioc, 4038 MPI3MR_RESET_FROM_EH_HOS, 1); 4039 if (ret) 4040 goto out; 4041 4042 retval = SUCCESS; 4043out: 4044 sdev_printk(KERN_INFO, scmd->device, 4045 "Host reset is %s for scmd(%p)\n", 4046 ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), scmd); 4047 4048 return retval; 4049} 4050 4051/** 4052 * mpi3mr_eh_bus_reset - Bus reset error handling callback 4053 * @scmd: SCSI command reference 4054 * 4055 * Checks whether pending I/Os are present for the RAID volume; 4056 * if not there's no need to reset the adapter. 4057 * 4058 * Return: SUCCESS of successful reset else FAILED 4059 */ 4060static int mpi3mr_eh_bus_reset(struct scsi_cmnd *scmd) 4061{ 4062 struct mpi3mr_ioc *mrioc = shost_priv(scmd->device->host); 4063 struct mpi3mr_stgt_priv_data *stgt_priv_data; 4064 struct mpi3mr_sdev_priv_data *sdev_priv_data; 4065 u8 dev_type = MPI3_DEVICE_DEVFORM_VD; 4066 int retval = FAILED; 4067 4068 sdev_priv_data = scmd->device->hostdata; 4069 if (sdev_priv_data && sdev_priv_data->tgt_priv_data) { 4070 stgt_priv_data = sdev_priv_data->tgt_priv_data; 4071 dev_type = stgt_priv_data->dev_type; 4072 } 4073 4074 if (dev_type == MPI3_DEVICE_DEVFORM_VD) { 4075 mpi3mr_wait_for_host_io(mrioc, 4076 MPI3MR_RAID_ERRREC_RESET_TIMEOUT); 4077 if (!mpi3mr_get_fw_pending_ios(mrioc)) 4078 retval = SUCCESS; 4079 } 4080 if (retval == FAILED) 4081 mpi3mr_print_pending_host_io(mrioc); 4082 4083 sdev_printk(KERN_INFO, scmd->device, 4084 "Bus reset is %s for scmd(%p)\n", 4085 ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), scmd); 4086 return retval; 4087} 4088 4089/** 4090 * mpi3mr_eh_target_reset - Target reset error handling callback 4091 * @scmd: SCSI command reference 4092 * 4093 * Issue Target reset Task Management and verify the scmd is 4094 * terminated successfully and return status accordingly. 4095 * 4096 * Return: SUCCESS of successful termination of the scmd else 4097 * FAILED 4098 */ 4099static int mpi3mr_eh_target_reset(struct scsi_cmnd *scmd) 4100{ 4101 struct mpi3mr_ioc *mrioc = shost_priv(scmd->device->host); 4102 struct mpi3mr_stgt_priv_data *stgt_priv_data; 4103 struct mpi3mr_sdev_priv_data *sdev_priv_data; 4104 u16 dev_handle; 4105 u8 resp_code = 0; 4106 int retval = FAILED, ret = 0; 4107 4108 sdev_printk(KERN_INFO, scmd->device, 4109 "Attempting Target Reset! scmd(%p)\n", scmd); 4110 scsi_print_command(scmd); 4111 4112 sdev_priv_data = scmd->device->hostdata; 4113 if (!sdev_priv_data || !sdev_priv_data->tgt_priv_data) { 4114 sdev_printk(KERN_INFO, scmd->device, 4115 "SCSI device is not available\n"); 4116 retval = SUCCESS; 4117 goto out; 4118 } 4119 4120 stgt_priv_data = sdev_priv_data->tgt_priv_data; 4121 dev_handle = stgt_priv_data->dev_handle; 4122 if (stgt_priv_data->dev_removed) { 4123 struct scmd_priv *cmd_priv = scsi_cmd_priv(scmd); 4124 sdev_printk(KERN_INFO, scmd->device, 4125 "%s:target(handle = 0x%04x) is removed, target reset is not issued\n", 4126 mrioc->name, dev_handle); 4127 if (!cmd_priv->in_lld_scope || cmd_priv->host_tag == MPI3MR_HOSTTAG_INVALID) 4128 retval = SUCCESS; 4129 else 4130 retval = FAILED; 4131 goto out; 4132 } 4133 sdev_printk(KERN_INFO, scmd->device, 4134 "Target Reset is issued to handle(0x%04x)\n", 4135 dev_handle); 4136 4137 ret = mpi3mr_issue_tm(mrioc, 4138 MPI3_SCSITASKMGMT_TASKTYPE_TARGET_RESET, dev_handle, 4139 sdev_priv_data->lun_id, MPI3MR_HOSTTAG_BLK_TMS, 4140 MPI3MR_RESETTM_TIMEOUT, &mrioc->host_tm_cmds, &resp_code, scmd); 4141 4142 if (ret) 4143 goto out; 4144 4145 if (stgt_priv_data->pend_count) { 4146 sdev_printk(KERN_INFO, scmd->device, 4147 "%s: target has %d pending commands, target reset is failed\n", 4148 mrioc->name, stgt_priv_data->pend_count); 4149 goto out; 4150 } 4151 4152 retval = SUCCESS; 4153out: 4154 sdev_printk(KERN_INFO, scmd->device, 4155 "%s: target reset is %s for scmd(%p)\n", mrioc->name, 4156 ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), scmd); 4157 4158 return retval; 4159} 4160 4161/** 4162 * mpi3mr_eh_dev_reset- Device reset error handling callback 4163 * @scmd: SCSI command reference 4164 * 4165 * Issue lun reset Task Management and verify the scmd is 4166 * terminated successfully and return status accordingly. 4167 * 4168 * Return: SUCCESS of successful termination of the scmd else 4169 * FAILED 4170 */ 4171static int mpi3mr_eh_dev_reset(struct scsi_cmnd *scmd) 4172{ 4173 struct mpi3mr_ioc *mrioc = shost_priv(scmd->device->host); 4174 struct mpi3mr_stgt_priv_data *stgt_priv_data; 4175 struct mpi3mr_sdev_priv_data *sdev_priv_data; 4176 u16 dev_handle; 4177 u8 resp_code = 0; 4178 int retval = FAILED, ret = 0; 4179 4180 sdev_printk(KERN_INFO, scmd->device, 4181 "Attempting Device(lun) Reset! scmd(%p)\n", scmd); 4182 scsi_print_command(scmd); 4183 4184 sdev_priv_data = scmd->device->hostdata; 4185 if (!sdev_priv_data || !sdev_priv_data->tgt_priv_data) { 4186 sdev_printk(KERN_INFO, scmd->device, 4187 "SCSI device is not available\n"); 4188 retval = SUCCESS; 4189 goto out; 4190 } 4191 4192 stgt_priv_data = sdev_priv_data->tgt_priv_data; 4193 dev_handle = stgt_priv_data->dev_handle; 4194 if (stgt_priv_data->dev_removed) { 4195 struct scmd_priv *cmd_priv = scsi_cmd_priv(scmd); 4196 sdev_printk(KERN_INFO, scmd->device, 4197 "%s: device(handle = 0x%04x) is removed, device(LUN) reset is not issued\n", 4198 mrioc->name, dev_handle); 4199 if (!cmd_priv->in_lld_scope || cmd_priv->host_tag == MPI3MR_HOSTTAG_INVALID) 4200 retval = SUCCESS; 4201 else 4202 retval = FAILED; 4203 goto out; 4204 } 4205 sdev_printk(KERN_INFO, scmd->device, 4206 "Device(lun) Reset is issued to handle(0x%04x)\n", dev_handle); 4207 4208 ret = mpi3mr_issue_tm(mrioc, 4209 MPI3_SCSITASKMGMT_TASKTYPE_LOGICAL_UNIT_RESET, dev_handle, 4210 sdev_priv_data->lun_id, MPI3MR_HOSTTAG_BLK_TMS, 4211 MPI3MR_RESETTM_TIMEOUT, &mrioc->host_tm_cmds, &resp_code, scmd); 4212 4213 if (ret) 4214 goto out; 4215 4216 if (sdev_priv_data->pend_count) { 4217 sdev_printk(KERN_INFO, scmd->device, 4218 "%s: device has %d pending commands, device(LUN) reset is failed\n", 4219 mrioc->name, sdev_priv_data->pend_count); 4220 goto out; 4221 } 4222 retval = SUCCESS; 4223out: 4224 sdev_printk(KERN_INFO, scmd->device, 4225 "%s: device(LUN) reset is %s for scmd(%p)\n", mrioc->name, 4226 ((retval == SUCCESS) ? "SUCCESS" : "FAILED"), scmd); 4227 4228 return retval; 4229} 4230 4231/** 4232 * mpi3mr_scan_start - Scan start callback handler 4233 * @shost: SCSI host reference 4234 * 4235 * Issue port enable request asynchronously. 4236 * 4237 * Return: Nothing 4238 */ 4239static void mpi3mr_scan_start(struct Scsi_Host *shost) 4240{ 4241 struct mpi3mr_ioc *mrioc = shost_priv(shost); 4242 4243 mrioc->scan_started = 1; 4244 ioc_info(mrioc, "%s :Issuing Port Enable\n", __func__); 4245 if (mpi3mr_issue_port_enable(mrioc, 1)) { 4246 ioc_err(mrioc, "%s :Issuing port enable failed\n", __func__); 4247 mrioc->scan_started = 0; 4248 mrioc->scan_failed = MPI3_IOCSTATUS_INTERNAL_ERROR; 4249 } 4250} 4251 4252/** 4253 * mpi3mr_scan_finished - Scan finished callback handler 4254 * @shost: SCSI host reference 4255 * @time: Jiffies from the scan start 4256 * 4257 * Checks whether the port enable is completed or timedout or 4258 * failed and set the scan status accordingly after taking any 4259 * recovery if required. 4260 * 4261 * Return: 1 on scan finished or timed out, 0 for in progress 4262 */ 4263static int mpi3mr_scan_finished(struct Scsi_Host *shost, 4264 unsigned long time) 4265{ 4266 struct mpi3mr_ioc *mrioc = shost_priv(shost); 4267 u32 pe_timeout = MPI3MR_PORTENABLE_TIMEOUT; 4268 u32 ioc_status = readl(&mrioc->sysif_regs->ioc_status); 4269 4270 if ((ioc_status & MPI3_SYSIF_IOC_STATUS_RESET_HISTORY) || 4271 (ioc_status & MPI3_SYSIF_IOC_STATUS_FAULT)) { 4272 ioc_err(mrioc, "port enable failed due to fault or reset\n"); 4273 mpi3mr_print_fault_info(mrioc); 4274 mrioc->scan_failed = MPI3_IOCSTATUS_INTERNAL_ERROR; 4275 mrioc->scan_started = 0; 4276 mrioc->init_cmds.is_waiting = 0; 4277 mrioc->init_cmds.callback = NULL; 4278 mrioc->init_cmds.state = MPI3MR_CMD_NOTUSED; 4279 } 4280 4281 if (time >= (pe_timeout * HZ)) { 4282 ioc_err(mrioc, "port enable failed due to time out\n"); 4283 mpi3mr_check_rh_fault_ioc(mrioc, 4284 MPI3MR_RESET_FROM_PE_TIMEOUT); 4285 mrioc->scan_failed = MPI3_IOCSTATUS_INTERNAL_ERROR; 4286 mrioc->scan_started = 0; 4287 mrioc->init_cmds.is_waiting = 0; 4288 mrioc->init_cmds.callback = NULL; 4289 mrioc->init_cmds.state = MPI3MR_CMD_NOTUSED; 4290 } 4291 4292 if (mrioc->scan_started) 4293 return 0; 4294 4295 if (mrioc->scan_failed) { 4296 ioc_err(mrioc, 4297 "port enable failed with status=0x%04x\n", 4298 mrioc->scan_failed); 4299 } else 4300 ioc_info(mrioc, "port enable is successfully completed\n"); 4301 4302 mpi3mr_start_watchdog(mrioc); 4303 mrioc->is_driver_loading = 0; 4304 mrioc->stop_bsgs = 0; 4305 return 1; 4306} 4307 4308/** 4309 * mpi3mr_slave_destroy - Slave destroy callback handler 4310 * @sdev: SCSI device reference 4311 * 4312 * Cleanup and free per device(lun) private data. 4313 * 4314 * Return: Nothing. 4315 */ 4316static void mpi3mr_slave_destroy(struct scsi_device *sdev) 4317{ 4318 struct Scsi_Host *shost; 4319 struct mpi3mr_ioc *mrioc; 4320 struct mpi3mr_stgt_priv_data *scsi_tgt_priv_data; 4321 struct mpi3mr_tgt_dev *tgt_dev = NULL; 4322 unsigned long flags; 4323 struct scsi_target *starget; 4324 struct sas_rphy *rphy = NULL; 4325 4326 if (!sdev->hostdata) 4327 return; 4328 4329 starget = scsi_target(sdev); 4330 shost = dev_to_shost(&starget->dev); 4331 mrioc = shost_priv(shost); 4332 scsi_tgt_priv_data = starget->hostdata; 4333 4334 scsi_tgt_priv_data->num_luns--; 4335 4336 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 4337 if (starget->channel == mrioc->scsi_device_channel) 4338 tgt_dev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, starget->id); 4339 else if (mrioc->sas_transport_enabled && !starget->channel) { 4340 rphy = dev_to_rphy(starget->dev.parent); 4341 tgt_dev = __mpi3mr_get_tgtdev_by_addr_and_rphy(mrioc, 4342 rphy->identify.sas_address, rphy); 4343 } 4344 4345 if (tgt_dev && (!scsi_tgt_priv_data->num_luns)) 4346 tgt_dev->starget = NULL; 4347 if (tgt_dev) 4348 mpi3mr_tgtdev_put(tgt_dev); 4349 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 4350 4351 kfree(sdev->hostdata); 4352 sdev->hostdata = NULL; 4353} 4354 4355/** 4356 * mpi3mr_target_destroy - Target destroy callback handler 4357 * @starget: SCSI target reference 4358 * 4359 * Cleanup and free per target private data. 4360 * 4361 * Return: Nothing. 4362 */ 4363static void mpi3mr_target_destroy(struct scsi_target *starget) 4364{ 4365 struct Scsi_Host *shost; 4366 struct mpi3mr_ioc *mrioc; 4367 struct mpi3mr_stgt_priv_data *scsi_tgt_priv_data; 4368 struct mpi3mr_tgt_dev *tgt_dev; 4369 unsigned long flags; 4370 4371 if (!starget->hostdata) 4372 return; 4373 4374 shost = dev_to_shost(&starget->dev); 4375 mrioc = shost_priv(shost); 4376 scsi_tgt_priv_data = starget->hostdata; 4377 4378 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 4379 tgt_dev = __mpi3mr_get_tgtdev_from_tgtpriv(mrioc, scsi_tgt_priv_data); 4380 if (tgt_dev && (tgt_dev->starget == starget) && 4381 (tgt_dev->perst_id == starget->id)) 4382 tgt_dev->starget = NULL; 4383 if (tgt_dev) { 4384 scsi_tgt_priv_data->tgt_dev = NULL; 4385 scsi_tgt_priv_data->perst_id = 0; 4386 mpi3mr_tgtdev_put(tgt_dev); 4387 mpi3mr_tgtdev_put(tgt_dev); 4388 } 4389 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 4390 4391 kfree(starget->hostdata); 4392 starget->hostdata = NULL; 4393} 4394 4395/** 4396 * mpi3mr_slave_configure - Slave configure callback handler 4397 * @sdev: SCSI device reference 4398 * 4399 * Configure queue depth, max hardware sectors and virt boundary 4400 * as required 4401 * 4402 * Return: 0 always. 4403 */ 4404static int mpi3mr_slave_configure(struct scsi_device *sdev) 4405{ 4406 struct scsi_target *starget; 4407 struct Scsi_Host *shost; 4408 struct mpi3mr_ioc *mrioc; 4409 struct mpi3mr_tgt_dev *tgt_dev = NULL; 4410 unsigned long flags; 4411 int retval = 0; 4412 struct sas_rphy *rphy = NULL; 4413 4414 starget = scsi_target(sdev); 4415 shost = dev_to_shost(&starget->dev); 4416 mrioc = shost_priv(shost); 4417 4418 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 4419 if (starget->channel == mrioc->scsi_device_channel) 4420 tgt_dev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, starget->id); 4421 else if (mrioc->sas_transport_enabled && !starget->channel) { 4422 rphy = dev_to_rphy(starget->dev.parent); 4423 tgt_dev = __mpi3mr_get_tgtdev_by_addr_and_rphy(mrioc, 4424 rphy->identify.sas_address, rphy); 4425 } 4426 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 4427 if (!tgt_dev) 4428 return -ENXIO; 4429 4430 mpi3mr_change_queue_depth(sdev, tgt_dev->q_depth); 4431 4432 sdev->eh_timeout = MPI3MR_EH_SCMD_TIMEOUT; 4433 blk_queue_rq_timeout(sdev->request_queue, MPI3MR_SCMD_TIMEOUT); 4434 4435 switch (tgt_dev->dev_type) { 4436 case MPI3_DEVICE_DEVFORM_PCIE: 4437 /*The block layer hw sector size = 512*/ 4438 if ((tgt_dev->dev_spec.pcie_inf.dev_info & 4439 MPI3_DEVICE0_PCIE_DEVICE_INFO_TYPE_MASK) == 4440 MPI3_DEVICE0_PCIE_DEVICE_INFO_TYPE_NVME_DEVICE) { 4441 blk_queue_max_hw_sectors(sdev->request_queue, 4442 tgt_dev->dev_spec.pcie_inf.mdts / 512); 4443 if (tgt_dev->dev_spec.pcie_inf.pgsz == 0) 4444 blk_queue_virt_boundary(sdev->request_queue, 4445 ((1 << MPI3MR_DEFAULT_PGSZEXP) - 1)); 4446 else 4447 blk_queue_virt_boundary(sdev->request_queue, 4448 ((1 << tgt_dev->dev_spec.pcie_inf.pgsz) - 1)); 4449 } 4450 break; 4451 default: 4452 break; 4453 } 4454 4455 mpi3mr_tgtdev_put(tgt_dev); 4456 4457 return retval; 4458} 4459 4460/** 4461 * mpi3mr_slave_alloc -Slave alloc callback handler 4462 * @sdev: SCSI device reference 4463 * 4464 * Allocate per device(lun) private data and initialize it. 4465 * 4466 * Return: 0 on success -ENOMEM on memory allocation failure. 4467 */ 4468static int mpi3mr_slave_alloc(struct scsi_device *sdev) 4469{ 4470 struct Scsi_Host *shost; 4471 struct mpi3mr_ioc *mrioc; 4472 struct mpi3mr_stgt_priv_data *scsi_tgt_priv_data; 4473 struct mpi3mr_tgt_dev *tgt_dev = NULL; 4474 struct mpi3mr_sdev_priv_data *scsi_dev_priv_data; 4475 unsigned long flags; 4476 struct scsi_target *starget; 4477 int retval = 0; 4478 struct sas_rphy *rphy = NULL; 4479 4480 starget = scsi_target(sdev); 4481 shost = dev_to_shost(&starget->dev); 4482 mrioc = shost_priv(shost); 4483 scsi_tgt_priv_data = starget->hostdata; 4484 4485 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 4486 4487 if (starget->channel == mrioc->scsi_device_channel) 4488 tgt_dev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, starget->id); 4489 else if (mrioc->sas_transport_enabled && !starget->channel) { 4490 rphy = dev_to_rphy(starget->dev.parent); 4491 tgt_dev = __mpi3mr_get_tgtdev_by_addr_and_rphy(mrioc, 4492 rphy->identify.sas_address, rphy); 4493 } 4494 4495 if (tgt_dev) { 4496 if (tgt_dev->starget == NULL) 4497 tgt_dev->starget = starget; 4498 mpi3mr_tgtdev_put(tgt_dev); 4499 retval = 0; 4500 } else { 4501 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 4502 return -ENXIO; 4503 } 4504 4505 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 4506 4507 scsi_dev_priv_data = kzalloc(sizeof(*scsi_dev_priv_data), GFP_KERNEL); 4508 if (!scsi_dev_priv_data) 4509 return -ENOMEM; 4510 4511 scsi_dev_priv_data->lun_id = sdev->lun; 4512 scsi_dev_priv_data->tgt_priv_data = scsi_tgt_priv_data; 4513 sdev->hostdata = scsi_dev_priv_data; 4514 4515 scsi_tgt_priv_data->num_luns++; 4516 4517 return retval; 4518} 4519 4520/** 4521 * mpi3mr_target_alloc - Target alloc callback handler 4522 * @starget: SCSI target reference 4523 * 4524 * Allocate per target private data and initialize it. 4525 * 4526 * Return: 0 on success -ENOMEM on memory allocation failure. 4527 */ 4528static int mpi3mr_target_alloc(struct scsi_target *starget) 4529{ 4530 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 4531 struct mpi3mr_ioc *mrioc = shost_priv(shost); 4532 struct mpi3mr_stgt_priv_data *scsi_tgt_priv_data; 4533 struct mpi3mr_tgt_dev *tgt_dev; 4534 unsigned long flags; 4535 int retval = 0; 4536 struct sas_rphy *rphy = NULL; 4537 4538 scsi_tgt_priv_data = kzalloc(sizeof(*scsi_tgt_priv_data), GFP_KERNEL); 4539 if (!scsi_tgt_priv_data) 4540 return -ENOMEM; 4541 4542 starget->hostdata = scsi_tgt_priv_data; 4543 4544 spin_lock_irqsave(&mrioc->tgtdev_lock, flags); 4545 if (starget->channel == mrioc->scsi_device_channel) { 4546 tgt_dev = __mpi3mr_get_tgtdev_by_perst_id(mrioc, starget->id); 4547 if (tgt_dev && !tgt_dev->is_hidden) { 4548 scsi_tgt_priv_data->starget = starget; 4549 scsi_tgt_priv_data->dev_handle = tgt_dev->dev_handle; 4550 scsi_tgt_priv_data->perst_id = tgt_dev->perst_id; 4551 scsi_tgt_priv_data->dev_type = tgt_dev->dev_type; 4552 scsi_tgt_priv_data->tgt_dev = tgt_dev; 4553 tgt_dev->starget = starget; 4554 atomic_set(&scsi_tgt_priv_data->block_io, 0); 4555 retval = 0; 4556 if ((tgt_dev->dev_type == MPI3_DEVICE_DEVFORM_PCIE) && 4557 ((tgt_dev->dev_spec.pcie_inf.dev_info & 4558 MPI3_DEVICE0_PCIE_DEVICE_INFO_TYPE_MASK) == 4559 MPI3_DEVICE0_PCIE_DEVICE_INFO_TYPE_NVME_DEVICE) && 4560 ((tgt_dev->dev_spec.pcie_inf.dev_info & 4561 MPI3_DEVICE0_PCIE_DEVICE_INFO_PITYPE_MASK) != 4562 MPI3_DEVICE0_PCIE_DEVICE_INFO_PITYPE_0)) 4563 scsi_tgt_priv_data->dev_nvme_dif = 1; 4564 scsi_tgt_priv_data->io_throttle_enabled = tgt_dev->io_throttle_enabled; 4565 scsi_tgt_priv_data->wslen = tgt_dev->wslen; 4566 if (tgt_dev->dev_type == MPI3_DEVICE_DEVFORM_VD) 4567 scsi_tgt_priv_data->throttle_group = tgt_dev->dev_spec.vd_inf.tg; 4568 } else 4569 retval = -ENXIO; 4570 } else if (mrioc->sas_transport_enabled && !starget->channel) { 4571 rphy = dev_to_rphy(starget->dev.parent); 4572 tgt_dev = __mpi3mr_get_tgtdev_by_addr_and_rphy(mrioc, 4573 rphy->identify.sas_address, rphy); 4574 if (tgt_dev && !tgt_dev->is_hidden && !tgt_dev->non_stl && 4575 (tgt_dev->dev_type == MPI3_DEVICE_DEVFORM_SAS_SATA)) { 4576 scsi_tgt_priv_data->starget = starget; 4577 scsi_tgt_priv_data->dev_handle = tgt_dev->dev_handle; 4578 scsi_tgt_priv_data->perst_id = tgt_dev->perst_id; 4579 scsi_tgt_priv_data->dev_type = tgt_dev->dev_type; 4580 scsi_tgt_priv_data->tgt_dev = tgt_dev; 4581 scsi_tgt_priv_data->io_throttle_enabled = tgt_dev->io_throttle_enabled; 4582 scsi_tgt_priv_data->wslen = tgt_dev->wslen; 4583 tgt_dev->starget = starget; 4584 atomic_set(&scsi_tgt_priv_data->block_io, 0); 4585 retval = 0; 4586 } else 4587 retval = -ENXIO; 4588 } 4589 spin_unlock_irqrestore(&mrioc->tgtdev_lock, flags); 4590 4591 return retval; 4592} 4593 4594/** 4595 * mpi3mr_check_return_unmap - Whether an unmap is allowed 4596 * @mrioc: Adapter instance reference 4597 * @scmd: SCSI Command reference 4598 * 4599 * The controller hardware cannot handle certain unmap commands 4600 * for NVMe drives, this routine checks those and return true 4601 * and completes the SCSI command with proper status and sense 4602 * data. 4603 * 4604 * Return: TRUE for not allowed unmap, FALSE otherwise. 4605 */ 4606static bool mpi3mr_check_return_unmap(struct mpi3mr_ioc *mrioc, 4607 struct scsi_cmnd *scmd) 4608{ 4609 unsigned char *buf; 4610 u16 param_len, desc_len, trunc_param_len; 4611 4612 trunc_param_len = param_len = get_unaligned_be16(scmd->cmnd + 7); 4613 4614 if (mrioc->pdev->revision) { 4615 if ((param_len > 24) && ((param_len - 8) & 0xF)) { 4616 trunc_param_len -= (param_len - 8) & 0xF; 4617 dprint_scsi_command(mrioc, scmd, MPI3_DEBUG_SCSI_ERROR); 4618 dprint_scsi_err(mrioc, 4619 "truncating param_len from (%d) to (%d)\n", 4620 param_len, trunc_param_len); 4621 put_unaligned_be16(trunc_param_len, scmd->cmnd + 7); 4622 dprint_scsi_command(mrioc, scmd, MPI3_DEBUG_SCSI_ERROR); 4623 } 4624 return false; 4625 } 4626 4627 if (!param_len) { 4628 ioc_warn(mrioc, 4629 "%s: cdb received with zero parameter length\n", 4630 __func__); 4631 scsi_print_command(scmd); 4632 scmd->result = DID_OK << 16; 4633 scsi_done(scmd); 4634 return true; 4635 } 4636 4637 if (param_len < 24) { 4638 ioc_warn(mrioc, 4639 "%s: cdb received with invalid param_len: %d\n", 4640 __func__, param_len); 4641 scsi_print_command(scmd); 4642 scmd->result = SAM_STAT_CHECK_CONDITION; 4643 scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 4644 0x1A, 0); 4645 scsi_done(scmd); 4646 return true; 4647 } 4648 if (param_len != scsi_bufflen(scmd)) { 4649 ioc_warn(mrioc, 4650 "%s: cdb received with param_len: %d bufflen: %d\n", 4651 __func__, param_len, scsi_bufflen(scmd)); 4652 scsi_print_command(scmd); 4653 scmd->result = SAM_STAT_CHECK_CONDITION; 4654 scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 4655 0x1A, 0); 4656 scsi_done(scmd); 4657 return true; 4658 } 4659 buf = kzalloc(scsi_bufflen(scmd), GFP_ATOMIC); 4660 if (!buf) { 4661 scsi_print_command(scmd); 4662 scmd->result = SAM_STAT_CHECK_CONDITION; 4663 scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 4664 0x55, 0x03); 4665 scsi_done(scmd); 4666 return true; 4667 } 4668 scsi_sg_copy_to_buffer(scmd, buf, scsi_bufflen(scmd)); 4669 desc_len = get_unaligned_be16(&buf[2]); 4670 4671 if (desc_len < 16) { 4672 ioc_warn(mrioc, 4673 "%s: Invalid descriptor length in param list: %d\n", 4674 __func__, desc_len); 4675 scsi_print_command(scmd); 4676 scmd->result = SAM_STAT_CHECK_CONDITION; 4677 scsi_build_sense_buffer(0, scmd->sense_buffer, ILLEGAL_REQUEST, 4678 0x26, 0); 4679 scsi_done(scmd); 4680 kfree(buf); 4681 return true; 4682 } 4683 4684 if (param_len > (desc_len + 8)) { 4685 trunc_param_len = desc_len + 8; 4686 scsi_print_command(scmd); 4687 dprint_scsi_err(mrioc, 4688 "truncating param_len(%d) to desc_len+8(%d)\n", 4689 param_len, trunc_param_len); 4690 put_unaligned_be16(trunc_param_len, scmd->cmnd + 7); 4691 scsi_print_command(scmd); 4692 } 4693 4694 kfree(buf); 4695 return false; 4696} 4697 4698/** 4699 * mpi3mr_allow_scmd_to_fw - Command is allowed during shutdown 4700 * @scmd: SCSI Command reference 4701 * 4702 * Checks whether a cdb is allowed during shutdown or not. 4703 * 4704 * Return: TRUE for allowed commands, FALSE otherwise. 4705 */ 4706 4707inline bool mpi3mr_allow_scmd_to_fw(struct scsi_cmnd *scmd) 4708{ 4709 switch (scmd->cmnd[0]) { 4710 case SYNCHRONIZE_CACHE: 4711 case START_STOP: 4712 return true; 4713 default: 4714 return false; 4715 } 4716} 4717 4718/** 4719 * mpi3mr_qcmd - I/O request despatcher 4720 * @shost: SCSI Host reference 4721 * @scmd: SCSI Command reference 4722 * 4723 * Issues the SCSI Command as an MPI3 request. 4724 * 4725 * Return: 0 on successful queueing of the request or if the 4726 * request is completed with failure. 4727 * SCSI_MLQUEUE_DEVICE_BUSY when the device is busy. 4728 * SCSI_MLQUEUE_HOST_BUSY when the host queue is full. 4729 */ 4730static int mpi3mr_qcmd(struct Scsi_Host *shost, 4731 struct scsi_cmnd *scmd) 4732{ 4733 struct mpi3mr_ioc *mrioc = shost_priv(shost); 4734 struct mpi3mr_stgt_priv_data *stgt_priv_data; 4735 struct mpi3mr_sdev_priv_data *sdev_priv_data; 4736 struct scmd_priv *scmd_priv_data = NULL; 4737 struct mpi3_scsi_io_request *scsiio_req = NULL; 4738 struct op_req_qinfo *op_req_q = NULL; 4739 int retval = 0; 4740 u16 dev_handle; 4741 u16 host_tag; 4742 u32 scsiio_flags = 0, data_len_blks = 0; 4743 struct request *rq = scsi_cmd_to_rq(scmd); 4744 int iprio_class; 4745 u8 is_pcie_dev = 0; 4746 u32 tracked_io_sz = 0; 4747 u32 ioc_pend_data_len = 0, tg_pend_data_len = 0; 4748 struct mpi3mr_throttle_group_info *tg = NULL; 4749 4750 if (mrioc->unrecoverable) { 4751 scmd->result = DID_ERROR << 16; 4752 scsi_done(scmd); 4753 goto out; 4754 } 4755 4756 sdev_priv_data = scmd->device->hostdata; 4757 if (!sdev_priv_data || !sdev_priv_data->tgt_priv_data) { 4758 scmd->result = DID_NO_CONNECT << 16; 4759 scsi_done(scmd); 4760 goto out; 4761 } 4762 4763 if (mrioc->stop_drv_processing && 4764 !(mpi3mr_allow_scmd_to_fw(scmd))) { 4765 scmd->result = DID_NO_CONNECT << 16; 4766 scsi_done(scmd); 4767 goto out; 4768 } 4769 4770 stgt_priv_data = sdev_priv_data->tgt_priv_data; 4771 dev_handle = stgt_priv_data->dev_handle; 4772 4773 /* Avoid error handling escalation when device is removed or blocked */ 4774 4775 if (scmd->device->host->shost_state == SHOST_RECOVERY && 4776 scmd->cmnd[0] == TEST_UNIT_READY && 4777 (stgt_priv_data->dev_removed || (dev_handle == MPI3MR_INVALID_DEV_HANDLE))) { 4778 scsi_build_sense(scmd, 0, UNIT_ATTENTION, 0x29, 0x07); 4779 scsi_done(scmd); 4780 goto out; 4781 } 4782 4783 if (mrioc->reset_in_progress) { 4784 retval = SCSI_MLQUEUE_HOST_BUSY; 4785 goto out; 4786 } 4787 4788 if (atomic_read(&stgt_priv_data->block_io)) { 4789 if (mrioc->stop_drv_processing) { 4790 scmd->result = DID_NO_CONNECT << 16; 4791 scsi_done(scmd); 4792 goto out; 4793 } 4794 retval = SCSI_MLQUEUE_DEVICE_BUSY; 4795 goto out; 4796 } 4797 4798 if (dev_handle == MPI3MR_INVALID_DEV_HANDLE) { 4799 scmd->result = DID_NO_CONNECT << 16; 4800 scsi_done(scmd); 4801 goto out; 4802 } 4803 if (stgt_priv_data->dev_removed) { 4804 scmd->result = DID_NO_CONNECT << 16; 4805 scsi_done(scmd); 4806 goto out; 4807 } 4808 4809 if (stgt_priv_data->dev_type == MPI3_DEVICE_DEVFORM_PCIE) 4810 is_pcie_dev = 1; 4811 if ((scmd->cmnd[0] == UNMAP) && is_pcie_dev && 4812 (mrioc->pdev->device == MPI3_MFGPAGE_DEVID_SAS4116) && 4813 mpi3mr_check_return_unmap(mrioc, scmd)) 4814 goto out; 4815 4816 host_tag = mpi3mr_host_tag_for_scmd(mrioc, scmd); 4817 if (host_tag == MPI3MR_HOSTTAG_INVALID) { 4818 scmd->result = DID_ERROR << 16; 4819 scsi_done(scmd); 4820 goto out; 4821 } 4822 4823 if (scmd->sc_data_direction == DMA_FROM_DEVICE) 4824 scsiio_flags = MPI3_SCSIIO_FLAGS_DATADIRECTION_READ; 4825 else if (scmd->sc_data_direction == DMA_TO_DEVICE) 4826 scsiio_flags = MPI3_SCSIIO_FLAGS_DATADIRECTION_WRITE; 4827 else 4828 scsiio_flags = MPI3_SCSIIO_FLAGS_DATADIRECTION_NO_DATA_TRANSFER; 4829 4830 scsiio_flags |= MPI3_SCSIIO_FLAGS_TASKATTRIBUTE_SIMPLEQ; 4831 4832 if (sdev_priv_data->ncq_prio_enable) { 4833 iprio_class = IOPRIO_PRIO_CLASS(req_get_ioprio(rq)); 4834 if (iprio_class == IOPRIO_CLASS_RT) 4835 scsiio_flags |= 1 << MPI3_SCSIIO_FLAGS_CMDPRI_SHIFT; 4836 } 4837 4838 if (scmd->cmd_len > 16) 4839 scsiio_flags |= MPI3_SCSIIO_FLAGS_CDB_GREATER_THAN_16; 4840 4841 scmd_priv_data = scsi_cmd_priv(scmd); 4842 memset(scmd_priv_data->mpi3mr_scsiio_req, 0, MPI3MR_ADMIN_REQ_FRAME_SZ); 4843 scsiio_req = (struct mpi3_scsi_io_request *)scmd_priv_data->mpi3mr_scsiio_req; 4844 scsiio_req->function = MPI3_FUNCTION_SCSI_IO; 4845 scsiio_req->host_tag = cpu_to_le16(host_tag); 4846 4847 mpi3mr_setup_eedp(mrioc, scmd, scsiio_req); 4848 4849 if (stgt_priv_data->wslen) 4850 mpi3mr_setup_divert_ws(mrioc, scmd, scsiio_req, &scsiio_flags, 4851 stgt_priv_data->wslen); 4852 4853 memcpy(scsiio_req->cdb.cdb32, scmd->cmnd, scmd->cmd_len); 4854 scsiio_req->data_length = cpu_to_le32(scsi_bufflen(scmd)); 4855 scsiio_req->dev_handle = cpu_to_le16(dev_handle); 4856 scsiio_req->flags = cpu_to_le32(scsiio_flags); 4857 int_to_scsilun(sdev_priv_data->lun_id, 4858 (struct scsi_lun *)scsiio_req->lun); 4859 4860 if (mpi3mr_build_sg_scmd(mrioc, scmd, scsiio_req)) { 4861 mpi3mr_clear_scmd_priv(mrioc, scmd); 4862 retval = SCSI_MLQUEUE_HOST_BUSY; 4863 goto out; 4864 } 4865 op_req_q = &mrioc->req_qinfo[scmd_priv_data->req_q_idx]; 4866 data_len_blks = scsi_bufflen(scmd) >> 9; 4867 if ((data_len_blks >= mrioc->io_throttle_data_length) && 4868 stgt_priv_data->io_throttle_enabled) { 4869 tracked_io_sz = data_len_blks; 4870 tg = stgt_priv_data->throttle_group; 4871 if (tg) { 4872 ioc_pend_data_len = atomic_add_return(data_len_blks, 4873 &mrioc->pend_large_data_sz); 4874 tg_pend_data_len = atomic_add_return(data_len_blks, 4875 &tg->pend_large_data_sz); 4876 if (!tg->io_divert && ((ioc_pend_data_len >= 4877 mrioc->io_throttle_high) || 4878 (tg_pend_data_len >= tg->high))) { 4879 tg->io_divert = 1; 4880 tg->need_qd_reduction = 1; 4881 mpi3mr_set_io_divert_for_all_vd_in_tg(mrioc, 4882 tg, 1); 4883 mpi3mr_queue_qd_reduction_event(mrioc, tg); 4884 } 4885 } else { 4886 ioc_pend_data_len = atomic_add_return(data_len_blks, 4887 &mrioc->pend_large_data_sz); 4888 if (ioc_pend_data_len >= mrioc->io_throttle_high) 4889 stgt_priv_data->io_divert = 1; 4890 } 4891 } 4892 4893 if (stgt_priv_data->io_divert) { 4894 scsiio_req->msg_flags |= 4895 MPI3_SCSIIO_MSGFLAGS_DIVERT_TO_FIRMWARE; 4896 scsiio_flags |= MPI3_SCSIIO_FLAGS_DIVERT_REASON_IO_THROTTLING; 4897 } 4898 scsiio_req->flags = cpu_to_le32(scsiio_flags); 4899 4900 if (mpi3mr_op_request_post(mrioc, op_req_q, 4901 scmd_priv_data->mpi3mr_scsiio_req)) { 4902 mpi3mr_clear_scmd_priv(mrioc, scmd); 4903 retval = SCSI_MLQUEUE_HOST_BUSY; 4904 if (tracked_io_sz) { 4905 atomic_sub(tracked_io_sz, &mrioc->pend_large_data_sz); 4906 if (tg) 4907 atomic_sub(tracked_io_sz, 4908 &tg->pend_large_data_sz); 4909 } 4910 goto out; 4911 } 4912 4913out: 4914 return retval; 4915} 4916 4917static const struct scsi_host_template mpi3mr_driver_template = { 4918 .module = THIS_MODULE, 4919 .name = "MPI3 Storage Controller", 4920 .proc_name = MPI3MR_DRIVER_NAME, 4921 .queuecommand = mpi3mr_qcmd, 4922 .target_alloc = mpi3mr_target_alloc, 4923 .slave_alloc = mpi3mr_slave_alloc, 4924 .slave_configure = mpi3mr_slave_configure, 4925 .target_destroy = mpi3mr_target_destroy, 4926 .slave_destroy = mpi3mr_slave_destroy, 4927 .scan_finished = mpi3mr_scan_finished, 4928 .scan_start = mpi3mr_scan_start, 4929 .change_queue_depth = mpi3mr_change_queue_depth, 4930 .eh_device_reset_handler = mpi3mr_eh_dev_reset, 4931 .eh_target_reset_handler = mpi3mr_eh_target_reset, 4932 .eh_bus_reset_handler = mpi3mr_eh_bus_reset, 4933 .eh_host_reset_handler = mpi3mr_eh_host_reset, 4934 .bios_param = mpi3mr_bios_param, 4935 .map_queues = mpi3mr_map_queues, 4936 .mq_poll = mpi3mr_blk_mq_poll, 4937 .no_write_same = 1, 4938 .can_queue = 1, 4939 .this_id = -1, 4940 .sg_tablesize = MPI3MR_DEFAULT_SGL_ENTRIES, 4941 /* max xfer supported is 1M (2K in 512 byte sized sectors) 4942 */ 4943 .max_sectors = (MPI3MR_DEFAULT_MAX_IO_SIZE / 512), 4944 .cmd_per_lun = MPI3MR_MAX_CMDS_LUN, 4945 .max_segment_size = 0xffffffff, 4946 .track_queue_depth = 1, 4947 .cmd_size = sizeof(struct scmd_priv), 4948 .shost_groups = mpi3mr_host_groups, 4949 .sdev_groups = mpi3mr_dev_groups, 4950}; 4951 4952/** 4953 * mpi3mr_init_drv_cmd - Initialize internal command tracker 4954 * @cmdptr: Internal command tracker 4955 * @host_tag: Host tag used for the specific command 4956 * 4957 * Initialize the internal command tracker structure with 4958 * specified host tag. 4959 * 4960 * Return: Nothing. 4961 */ 4962static inline void mpi3mr_init_drv_cmd(struct mpi3mr_drv_cmd *cmdptr, 4963 u16 host_tag) 4964{ 4965 mutex_init(&cmdptr->mutex); 4966 cmdptr->reply = NULL; 4967 cmdptr->state = MPI3MR_CMD_NOTUSED; 4968 cmdptr->dev_handle = MPI3MR_INVALID_DEV_HANDLE; 4969 cmdptr->host_tag = host_tag; 4970} 4971 4972/** 4973 * osintfc_mrioc_security_status -Check controller secure status 4974 * @pdev: PCI device instance 4975 * 4976 * Read the Device Serial Number capability from PCI config 4977 * space and decide whether the controller is secure or not. 4978 * 4979 * Return: 0 on success, non-zero on failure. 4980 */ 4981static int 4982osintfc_mrioc_security_status(struct pci_dev *pdev) 4983{ 4984 u32 cap_data; 4985 int base; 4986 u32 ctlr_status; 4987 u32 debug_status; 4988 int retval = 0; 4989 4990 base = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_DSN); 4991 if (!base) { 4992 dev_err(&pdev->dev, 4993 "%s: PCI_EXT_CAP_ID_DSN is not supported\n", __func__); 4994 return -1; 4995 } 4996 4997 pci_read_config_dword(pdev, base + 4, &cap_data); 4998 4999 debug_status = cap_data & MPI3MR_CTLR_SECURE_DBG_STATUS_MASK; 5000 ctlr_status = cap_data & MPI3MR_CTLR_SECURITY_STATUS_MASK; 5001 5002 switch (ctlr_status) { 5003 case MPI3MR_INVALID_DEVICE: 5004 dev_err(&pdev->dev, 5005 "%s: Non secure ctlr (Invalid) is detected: DID: 0x%x: SVID: 0x%x: SDID: 0x%x\n", 5006 __func__, pdev->device, pdev->subsystem_vendor, 5007 pdev->subsystem_device); 5008 retval = -1; 5009 break; 5010 case MPI3MR_CONFIG_SECURE_DEVICE: 5011 if (!debug_status) 5012 dev_info(&pdev->dev, 5013 "%s: Config secure ctlr is detected\n", 5014 __func__); 5015 break; 5016 case MPI3MR_HARD_SECURE_DEVICE: 5017 break; 5018 case MPI3MR_TAMPERED_DEVICE: 5019 dev_err(&pdev->dev, 5020 "%s: Non secure ctlr (Tampered) is detected: DID: 0x%x: SVID: 0x%x: SDID: 0x%x\n", 5021 __func__, pdev->device, pdev->subsystem_vendor, 5022 pdev->subsystem_device); 5023 retval = -1; 5024 break; 5025 default: 5026 retval = -1; 5027 break; 5028 } 5029 5030 if (!retval && debug_status) { 5031 dev_err(&pdev->dev, 5032 "%s: Non secure ctlr (Secure Dbg) is detected: DID: 0x%x: SVID: 0x%x: SDID: 0x%x\n", 5033 __func__, pdev->device, pdev->subsystem_vendor, 5034 pdev->subsystem_device); 5035 retval = -1; 5036 } 5037 5038 return retval; 5039} 5040 5041/** 5042 * mpi3mr_probe - PCI probe callback 5043 * @pdev: PCI device instance 5044 * @id: PCI device ID details 5045 * 5046 * controller initialization routine. Checks the security status 5047 * of the controller and if it is invalid or tampered return the 5048 * probe without initializing the controller. Otherwise, 5049 * allocate per adapter instance through shost_priv and 5050 * initialize controller specific data structures, initializae 5051 * the controller hardware, add shost to the SCSI subsystem. 5052 * 5053 * Return: 0 on success, non-zero on failure. 5054 */ 5055 5056static int 5057mpi3mr_probe(struct pci_dev *pdev, const struct pci_device_id *id) 5058{ 5059 struct mpi3mr_ioc *mrioc = NULL; 5060 struct Scsi_Host *shost = NULL; 5061 int retval = 0, i; 5062 5063 if (osintfc_mrioc_security_status(pdev)) { 5064 warn_non_secure_ctlr = 1; 5065 return 1; /* For Invalid and Tampered device */ 5066 } 5067 5068 shost = scsi_host_alloc(&mpi3mr_driver_template, 5069 sizeof(struct mpi3mr_ioc)); 5070 if (!shost) { 5071 retval = -ENODEV; 5072 goto shost_failed; 5073 } 5074 5075 mrioc = shost_priv(shost); 5076 retval = ida_alloc_range(&mrioc_ida, 1, U8_MAX, GFP_KERNEL); 5077 if (retval < 0) 5078 goto id_alloc_failed; 5079 mrioc->id = (u8)retval; 5080 sprintf(mrioc->driver_name, "%s", MPI3MR_DRIVER_NAME); 5081 sprintf(mrioc->name, "%s%d", mrioc->driver_name, mrioc->id); 5082 INIT_LIST_HEAD(&mrioc->list); 5083 spin_lock(&mrioc_list_lock); 5084 list_add_tail(&mrioc->list, &mrioc_list); 5085 spin_unlock(&mrioc_list_lock); 5086 5087 spin_lock_init(&mrioc->admin_req_lock); 5088 spin_lock_init(&mrioc->reply_free_queue_lock); 5089 spin_lock_init(&mrioc->sbq_lock); 5090 spin_lock_init(&mrioc->fwevt_lock); 5091 spin_lock_init(&mrioc->tgtdev_lock); 5092 spin_lock_init(&mrioc->watchdog_lock); 5093 spin_lock_init(&mrioc->chain_buf_lock); 5094 spin_lock_init(&mrioc->sas_node_lock); 5095 5096 INIT_LIST_HEAD(&mrioc->fwevt_list); 5097 INIT_LIST_HEAD(&mrioc->tgtdev_list); 5098 INIT_LIST_HEAD(&mrioc->delayed_rmhs_list); 5099 INIT_LIST_HEAD(&mrioc->delayed_evtack_cmds_list); 5100 INIT_LIST_HEAD(&mrioc->sas_expander_list); 5101 INIT_LIST_HEAD(&mrioc->hba_port_table_list); 5102 INIT_LIST_HEAD(&mrioc->enclosure_list); 5103 5104 mutex_init(&mrioc->reset_mutex); 5105 mpi3mr_init_drv_cmd(&mrioc->init_cmds, MPI3MR_HOSTTAG_INITCMDS); 5106 mpi3mr_init_drv_cmd(&mrioc->host_tm_cmds, MPI3MR_HOSTTAG_BLK_TMS); 5107 mpi3mr_init_drv_cmd(&mrioc->bsg_cmds, MPI3MR_HOSTTAG_BSG_CMDS); 5108 mpi3mr_init_drv_cmd(&mrioc->cfg_cmds, MPI3MR_HOSTTAG_CFG_CMDS); 5109 mpi3mr_init_drv_cmd(&mrioc->transport_cmds, 5110 MPI3MR_HOSTTAG_TRANSPORT_CMDS); 5111 5112 for (i = 0; i < MPI3MR_NUM_DEVRMCMD; i++) 5113 mpi3mr_init_drv_cmd(&mrioc->dev_rmhs_cmds[i], 5114 MPI3MR_HOSTTAG_DEVRMCMD_MIN + i); 5115 5116 for (i = 0; i < MPI3MR_NUM_EVTACKCMD; i++) 5117 mpi3mr_init_drv_cmd(&mrioc->evtack_cmds[i], 5118 MPI3MR_HOSTTAG_EVTACKCMD_MIN + i); 5119 5120 if ((pdev->device == MPI3_MFGPAGE_DEVID_SAS4116) && 5121 !pdev->revision) 5122 mrioc->enable_segqueue = false; 5123 else 5124 mrioc->enable_segqueue = true; 5125 5126 init_waitqueue_head(&mrioc->reset_waitq); 5127 mrioc->logging_level = logging_level; 5128 mrioc->shost = shost; 5129 mrioc->pdev = pdev; 5130 mrioc->stop_bsgs = 1; 5131 5132 mrioc->max_sgl_entries = max_sgl_entries; 5133 if (max_sgl_entries > MPI3MR_MAX_SGL_ENTRIES) 5134 mrioc->max_sgl_entries = MPI3MR_MAX_SGL_ENTRIES; 5135 else if (max_sgl_entries < MPI3MR_DEFAULT_SGL_ENTRIES) 5136 mrioc->max_sgl_entries = MPI3MR_DEFAULT_SGL_ENTRIES; 5137 else { 5138 mrioc->max_sgl_entries /= MPI3MR_DEFAULT_SGL_ENTRIES; 5139 mrioc->max_sgl_entries *= MPI3MR_DEFAULT_SGL_ENTRIES; 5140 } 5141 5142 /* init shost parameters */ 5143 shost->max_cmd_len = MPI3MR_MAX_CDB_LENGTH; 5144 shost->max_lun = -1; 5145 shost->unique_id = mrioc->id; 5146 5147 shost->max_channel = 0; 5148 shost->max_id = 0xFFFFFFFF; 5149 5150 shost->host_tagset = 1; 5151 5152 if (prot_mask >= 0) 5153 scsi_host_set_prot(shost, prot_mask); 5154 else { 5155 prot_mask = SHOST_DIF_TYPE1_PROTECTION 5156 | SHOST_DIF_TYPE2_PROTECTION 5157 | SHOST_DIF_TYPE3_PROTECTION; 5158 scsi_host_set_prot(shost, prot_mask); 5159 } 5160 5161 ioc_info(mrioc, 5162 "%s :host protection capabilities enabled %s%s%s%s%s%s%s\n", 5163 __func__, 5164 (prot_mask & SHOST_DIF_TYPE1_PROTECTION) ? " DIF1" : "", 5165 (prot_mask & SHOST_DIF_TYPE2_PROTECTION) ? " DIF2" : "", 5166 (prot_mask & SHOST_DIF_TYPE3_PROTECTION) ? " DIF3" : "", 5167 (prot_mask & SHOST_DIX_TYPE0_PROTECTION) ? " DIX0" : "", 5168 (prot_mask & SHOST_DIX_TYPE1_PROTECTION) ? " DIX1" : "", 5169 (prot_mask & SHOST_DIX_TYPE2_PROTECTION) ? " DIX2" : "", 5170 (prot_mask & SHOST_DIX_TYPE3_PROTECTION) ? " DIX3" : ""); 5171 5172 if (prot_guard_mask) 5173 scsi_host_set_guard(shost, (prot_guard_mask & 3)); 5174 else 5175 scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC); 5176 5177 snprintf(mrioc->fwevt_worker_name, sizeof(mrioc->fwevt_worker_name), 5178 "%s%d_fwevt_wrkr", mrioc->driver_name, mrioc->id); 5179 mrioc->fwevt_worker_thread = alloc_ordered_workqueue( 5180 mrioc->fwevt_worker_name, 0); 5181 if (!mrioc->fwevt_worker_thread) { 5182 ioc_err(mrioc, "failure at %s:%d/%s()!\n", 5183 __FILE__, __LINE__, __func__); 5184 retval = -ENODEV; 5185 goto fwevtthread_failed; 5186 } 5187 5188 mrioc->is_driver_loading = 1; 5189 mrioc->cpu_count = num_online_cpus(); 5190 if (mpi3mr_setup_resources(mrioc)) { 5191 ioc_err(mrioc, "setup resources failed\n"); 5192 retval = -ENODEV; 5193 goto resource_alloc_failed; 5194 } 5195 if (mpi3mr_init_ioc(mrioc)) { 5196 ioc_err(mrioc, "initializing IOC failed\n"); 5197 retval = -ENODEV; 5198 goto init_ioc_failed; 5199 } 5200 5201 shost->nr_hw_queues = mrioc->num_op_reply_q; 5202 if (mrioc->active_poll_qcount) 5203 shost->nr_maps = 3; 5204 5205 shost->can_queue = mrioc->max_host_ios; 5206 shost->sg_tablesize = mrioc->max_sgl_entries; 5207 shost->max_id = mrioc->facts.max_perids + 1; 5208 5209 retval = scsi_add_host(shost, &pdev->dev); 5210 if (retval) { 5211 ioc_err(mrioc, "failure at %s:%d/%s()!\n", 5212 __FILE__, __LINE__, __func__); 5213 goto addhost_failed; 5214 } 5215 5216 scsi_scan_host(shost); 5217 mpi3mr_bsg_init(mrioc); 5218 return retval; 5219 5220addhost_failed: 5221 mpi3mr_stop_watchdog(mrioc); 5222 mpi3mr_cleanup_ioc(mrioc); 5223init_ioc_failed: 5224 mpi3mr_free_mem(mrioc); 5225 mpi3mr_cleanup_resources(mrioc); 5226resource_alloc_failed: 5227 destroy_workqueue(mrioc->fwevt_worker_thread); 5228fwevtthread_failed: 5229 ida_free(&mrioc_ida, mrioc->id); 5230 spin_lock(&mrioc_list_lock); 5231 list_del(&mrioc->list); 5232 spin_unlock(&mrioc_list_lock); 5233id_alloc_failed: 5234 scsi_host_put(shost); 5235shost_failed: 5236 return retval; 5237} 5238 5239/** 5240 * mpi3mr_remove - PCI remove callback 5241 * @pdev: PCI device instance 5242 * 5243 * Cleanup the IOC by issuing MUR and shutdown notification. 5244 * Free up all memory and resources associated with the 5245 * controllerand target devices, unregister the shost. 5246 * 5247 * Return: Nothing. 5248 */ 5249static void mpi3mr_remove(struct pci_dev *pdev) 5250{ 5251 struct Scsi_Host *shost = pci_get_drvdata(pdev); 5252 struct mpi3mr_ioc *mrioc; 5253 struct workqueue_struct *wq; 5254 unsigned long flags; 5255 struct mpi3mr_tgt_dev *tgtdev, *tgtdev_next; 5256 struct mpi3mr_hba_port *port, *hba_port_next; 5257 struct mpi3mr_sas_node *sas_expander, *sas_expander_next; 5258 5259 if (!shost) 5260 return; 5261 5262 mrioc = shost_priv(shost); 5263 while (mrioc->reset_in_progress || mrioc->is_driver_loading) 5264 ssleep(1); 5265 5266 if (!pci_device_is_present(mrioc->pdev)) { 5267 mrioc->unrecoverable = 1; 5268 mpi3mr_flush_cmds_for_unrecovered_controller(mrioc); 5269 } 5270 5271 mpi3mr_bsg_exit(mrioc); 5272 mrioc->stop_drv_processing = 1; 5273 mpi3mr_cleanup_fwevt_list(mrioc); 5274 spin_lock_irqsave(&mrioc->fwevt_lock, flags); 5275 wq = mrioc->fwevt_worker_thread; 5276 mrioc->fwevt_worker_thread = NULL; 5277 spin_unlock_irqrestore(&mrioc->fwevt_lock, flags); 5278 if (wq) 5279 destroy_workqueue(wq); 5280 5281 if (mrioc->sas_transport_enabled) 5282 sas_remove_host(shost); 5283 else 5284 scsi_remove_host(shost); 5285 5286 list_for_each_entry_safe(tgtdev, tgtdev_next, &mrioc->tgtdev_list, 5287 list) { 5288 mpi3mr_remove_tgtdev_from_host(mrioc, tgtdev); 5289 mpi3mr_tgtdev_del_from_list(mrioc, tgtdev, true); 5290 mpi3mr_tgtdev_put(tgtdev); 5291 } 5292 mpi3mr_stop_watchdog(mrioc); 5293 mpi3mr_cleanup_ioc(mrioc); 5294 mpi3mr_free_mem(mrioc); 5295 mpi3mr_cleanup_resources(mrioc); 5296 5297 spin_lock_irqsave(&mrioc->sas_node_lock, flags); 5298 list_for_each_entry_safe_reverse(sas_expander, sas_expander_next, 5299 &mrioc->sas_expander_list, list) { 5300 spin_unlock_irqrestore(&mrioc->sas_node_lock, flags); 5301 mpi3mr_expander_node_remove(mrioc, sas_expander); 5302 spin_lock_irqsave(&mrioc->sas_node_lock, flags); 5303 } 5304 list_for_each_entry_safe(port, hba_port_next, &mrioc->hba_port_table_list, list) { 5305 ioc_info(mrioc, 5306 "removing hba_port entry: %p port: %d from hba_port list\n", 5307 port, port->port_id); 5308 list_del(&port->list); 5309 kfree(port); 5310 } 5311 spin_unlock_irqrestore(&mrioc->sas_node_lock, flags); 5312 5313 if (mrioc->sas_hba.num_phys) { 5314 kfree(mrioc->sas_hba.phy); 5315 mrioc->sas_hba.phy = NULL; 5316 mrioc->sas_hba.num_phys = 0; 5317 } 5318 5319 ida_free(&mrioc_ida, mrioc->id); 5320 spin_lock(&mrioc_list_lock); 5321 list_del(&mrioc->list); 5322 spin_unlock(&mrioc_list_lock); 5323 5324 scsi_host_put(shost); 5325} 5326 5327/** 5328 * mpi3mr_shutdown - PCI shutdown callback 5329 * @pdev: PCI device instance 5330 * 5331 * Free up all memory and resources associated with the 5332 * controller 5333 * 5334 * Return: Nothing. 5335 */ 5336static void mpi3mr_shutdown(struct pci_dev *pdev) 5337{ 5338 struct Scsi_Host *shost = pci_get_drvdata(pdev); 5339 struct mpi3mr_ioc *mrioc; 5340 struct workqueue_struct *wq; 5341 unsigned long flags; 5342 5343 if (!shost) 5344 return; 5345 5346 mrioc = shost_priv(shost); 5347 while (mrioc->reset_in_progress || mrioc->is_driver_loading) 5348 ssleep(1); 5349 5350 mrioc->stop_drv_processing = 1; 5351 mpi3mr_cleanup_fwevt_list(mrioc); 5352 spin_lock_irqsave(&mrioc->fwevt_lock, flags); 5353 wq = mrioc->fwevt_worker_thread; 5354 mrioc->fwevt_worker_thread = NULL; 5355 spin_unlock_irqrestore(&mrioc->fwevt_lock, flags); 5356 if (wq) 5357 destroy_workqueue(wq); 5358 5359 mpi3mr_stop_watchdog(mrioc); 5360 mpi3mr_cleanup_ioc(mrioc); 5361 mpi3mr_cleanup_resources(mrioc); 5362} 5363 5364/** 5365 * mpi3mr_suspend - PCI power management suspend callback 5366 * @dev: Device struct 5367 * 5368 * Change the power state to the given value and cleanup the IOC 5369 * by issuing MUR and shutdown notification 5370 * 5371 * Return: 0 always. 5372 */ 5373static int __maybe_unused 5374mpi3mr_suspend(struct device *dev) 5375{ 5376 struct pci_dev *pdev = to_pci_dev(dev); 5377 struct Scsi_Host *shost = pci_get_drvdata(pdev); 5378 struct mpi3mr_ioc *mrioc; 5379 5380 if (!shost) 5381 return 0; 5382 5383 mrioc = shost_priv(shost); 5384 while (mrioc->reset_in_progress || mrioc->is_driver_loading) 5385 ssleep(1); 5386 mrioc->stop_drv_processing = 1; 5387 mpi3mr_cleanup_fwevt_list(mrioc); 5388 scsi_block_requests(shost); 5389 mpi3mr_stop_watchdog(mrioc); 5390 mpi3mr_cleanup_ioc(mrioc); 5391 5392 ioc_info(mrioc, "pdev=0x%p, slot=%s, entering operating state\n", 5393 pdev, pci_name(pdev)); 5394 mpi3mr_cleanup_resources(mrioc); 5395 5396 return 0; 5397} 5398 5399/** 5400 * mpi3mr_resume - PCI power management resume callback 5401 * @dev: Device struct 5402 * 5403 * Restore the power state to D0 and reinitialize the controller 5404 * and resume I/O operations to the target devices 5405 * 5406 * Return: 0 on success, non-zero on failure 5407 */ 5408static int __maybe_unused 5409mpi3mr_resume(struct device *dev) 5410{ 5411 struct pci_dev *pdev = to_pci_dev(dev); 5412 struct Scsi_Host *shost = pci_get_drvdata(pdev); 5413 struct mpi3mr_ioc *mrioc; 5414 pci_power_t device_state = pdev->current_state; 5415 int r; 5416 5417 if (!shost) 5418 return 0; 5419 5420 mrioc = shost_priv(shost); 5421 5422 ioc_info(mrioc, "pdev=0x%p, slot=%s, previous operating state [D%d]\n", 5423 pdev, pci_name(pdev), device_state); 5424 mrioc->pdev = pdev; 5425 mrioc->cpu_count = num_online_cpus(); 5426 r = mpi3mr_setup_resources(mrioc); 5427 if (r) { 5428 ioc_info(mrioc, "%s: Setup resources failed[%d]\n", 5429 __func__, r); 5430 return r; 5431 } 5432 5433 mrioc->stop_drv_processing = 0; 5434 mpi3mr_invalidate_devhandles(mrioc); 5435 mpi3mr_free_enclosure_list(mrioc); 5436 mpi3mr_memset_buffers(mrioc); 5437 r = mpi3mr_reinit_ioc(mrioc, 1); 5438 if (r) { 5439 ioc_err(mrioc, "resuming controller failed[%d]\n", r); 5440 return r; 5441 } 5442 ssleep(MPI3MR_RESET_TOPOLOGY_SETTLE_TIME); 5443 scsi_unblock_requests(shost); 5444 mrioc->device_refresh_on = 0; 5445 mpi3mr_start_watchdog(mrioc); 5446 5447 return 0; 5448} 5449 5450static const struct pci_device_id mpi3mr_pci_id_table[] = { 5451 { 5452 PCI_DEVICE_SUB(MPI3_MFGPAGE_VENDORID_BROADCOM, 5453 MPI3_MFGPAGE_DEVID_SAS4116, PCI_ANY_ID, PCI_ANY_ID) 5454 }, 5455 { 5456 PCI_DEVICE_SUB(MPI3_MFGPAGE_VENDORID_BROADCOM, 5457 MPI3_MFGPAGE_DEVID_SAS5116_MPI, PCI_ANY_ID, PCI_ANY_ID) 5458 }, 5459 { 5460 PCI_DEVICE_SUB(MPI3_MFGPAGE_VENDORID_BROADCOM, 5461 MPI3_MFGPAGE_DEVID_SAS5116_MPI_MGMT, PCI_ANY_ID, PCI_ANY_ID) 5462 }, 5463 { 0 } 5464}; 5465MODULE_DEVICE_TABLE(pci, mpi3mr_pci_id_table); 5466 5467static SIMPLE_DEV_PM_OPS(mpi3mr_pm_ops, mpi3mr_suspend, mpi3mr_resume); 5468 5469static struct pci_driver mpi3mr_pci_driver = { 5470 .name = MPI3MR_DRIVER_NAME, 5471 .id_table = mpi3mr_pci_id_table, 5472 .probe = mpi3mr_probe, 5473 .remove = mpi3mr_remove, 5474 .shutdown = mpi3mr_shutdown, 5475 .driver.pm = &mpi3mr_pm_ops, 5476}; 5477 5478static ssize_t event_counter_show(struct device_driver *dd, char *buf) 5479{ 5480 return sprintf(buf, "%llu\n", atomic64_read(&event_counter)); 5481} 5482static DRIVER_ATTR_RO(event_counter); 5483 5484static int __init mpi3mr_init(void) 5485{ 5486 int ret_val; 5487 5488 pr_info("Loading %s version %s\n", MPI3MR_DRIVER_NAME, 5489 MPI3MR_DRIVER_VERSION); 5490 5491 mpi3mr_transport_template = 5492 sas_attach_transport(&mpi3mr_transport_functions); 5493 if (!mpi3mr_transport_template) { 5494 pr_err("%s failed to load due to sas transport attach failure\n", 5495 MPI3MR_DRIVER_NAME); 5496 return -ENODEV; 5497 } 5498 5499 ret_val = pci_register_driver(&mpi3mr_pci_driver); 5500 if (ret_val) { 5501 pr_err("%s failed to load due to pci register driver failure\n", 5502 MPI3MR_DRIVER_NAME); 5503 goto err_pci_reg_fail; 5504 } 5505 5506 ret_val = driver_create_file(&mpi3mr_pci_driver.driver, 5507 &driver_attr_event_counter); 5508 if (ret_val) 5509 goto err_event_counter; 5510 5511 return ret_val; 5512 5513err_event_counter: 5514 pci_unregister_driver(&mpi3mr_pci_driver); 5515 5516err_pci_reg_fail: 5517 sas_release_transport(mpi3mr_transport_template); 5518 return ret_val; 5519} 5520 5521static void __exit mpi3mr_exit(void) 5522{ 5523 if (warn_non_secure_ctlr) 5524 pr_warn( 5525 "Unloading %s version %s while managing a non secure controller\n", 5526 MPI3MR_DRIVER_NAME, MPI3MR_DRIVER_VERSION); 5527 else 5528 pr_info("Unloading %s version %s\n", MPI3MR_DRIVER_NAME, 5529 MPI3MR_DRIVER_VERSION); 5530 5531 driver_remove_file(&mpi3mr_pci_driver.driver, 5532 &driver_attr_event_counter); 5533 pci_unregister_driver(&mpi3mr_pci_driver); 5534 sas_release_transport(mpi3mr_transport_template); 5535 ida_destroy(&mrioc_ida); 5536} 5537 5538module_init(mpi3mr_init); 5539module_exit(mpi3mr_exit); 5540