drivers/scsi/mpi3mr/mpi3mr_os.c

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