drivers/scsi/megaraid/megaraid_sas_base.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Linux MegaRAID driver for SAS based RAID controllers
   4  *
   5  *  Copyright (c) 2003-2013  LSI Corporation
   6  *  Copyright (c) 2013-2016  Avago Technologies
   7  *  Copyright (c) 2016-2018  Broadcom Inc.
   8  *
   9  *  Authors: Broadcom Inc.
  10  *           Sreenivas Bagalkote
  11  *           Sumant Patro
  12  *           Bo Yang
  13  *           Adam Radford
  14  *           Kashyap Desai <kashyap.desai@broadcom.com>
  15  *           Sumit Saxena <sumit.saxena@broadcom.com>
  16  *
  17  *  Send feedback to: megaraidlinux.pdl@broadcom.com
  18  */
  19
  20 #include <linux/kernel.h>
  21 #include <linux/types.h>
  22 #include <linux/pci.h>
  23 #include <linux/list.h>
  24 #include <linux/moduleparam.h>
  25 #include <linux/module.h>
  26 #include <linux/spinlock.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/delay.h>
  29 #include <linux/uio.h>
  30 #include <linux/slab.h>
  31 #include <linux/uaccess.h>
  32 #include <asm/unaligned.h>
  33 #include <linux/fs.h>
  34 #include <linux/compat.h>
  35 #include <linux/blkdev.h>
  36 #include <linux/mutex.h>
  37 #include <linux/poll.h>
  38 #include <linux/vmalloc.h>
  39 #include <linux/irq_poll.h>
  40
  41 #include <scsi/scsi.h>
  42 #include <scsi/scsi_cmnd.h>
  43 #include <scsi/scsi_device.h>
  44 #include <scsi/scsi_host.h>
  45 #include <scsi/scsi_tcq.h>
  46 #include <scsi/scsi_dbg.h>
  47 #include "megaraid_sas_fusion.h"
  48 #include "megaraid_sas.h"
  49
  50 /*
  51  * Number of sectors per IO command
  52  * Will be set in megasas_init_mfi if user does not provide
  53  */
  54 static unsigned int max_sectors;
  55 module_param_named(max_sectors, max_sectors, int, 0444);
  56 MODULE_PARM_DESC(max_sectors,
  57         "Maximum number of sectors per IO command");
  58
  59 static int msix_disable;
  60 module_param(msix_disable, int, 0444);
  61 MODULE_PARM_DESC(msix_disable, "Disable MSI-X interrupt handling. Default: 0");
  62
  63 static unsigned int msix_vectors;
  64 module_param(msix_vectors, int, 0444);
  65 MODULE_PARM_DESC(msix_vectors, "MSI-X max vector count. Default: Set by FW");
  66
  67 static int allow_vf_ioctls;
  68 module_param(allow_vf_ioctls, int, 0444);
  69 MODULE_PARM_DESC(allow_vf_ioctls, "Allow ioctls in SR-IOV VF mode. Default: 0");
  70
  71 static unsigned int throttlequeuedepth = MEGASAS_THROTTLE_QUEUE_DEPTH;
  72 module_param(throttlequeuedepth, int, 0444);
  73 MODULE_PARM_DESC(throttlequeuedepth,
  74         "Adapter queue depth when throttled due to I/O timeout. Default: 16");
  75
  76 unsigned int resetwaittime = MEGASAS_RESET_WAIT_TIME;
  77 module_param(resetwaittime, int, 0444);
  78 MODULE_PARM_DESC(resetwaittime, "Wait time in (1-180s) after I/O timeout before resetting adapter. Default: 180s");
  79
  80 int smp_affinity_enable = 1;
  81 module_param(smp_affinity_enable, int, 0444);
  82 MODULE_PARM_DESC(smp_affinity_enable, "SMP affinity feature enable/disable Default: enable(1)");
  83
  84 int rdpq_enable = 1;
  85 module_param(rdpq_enable, int, 0444);
  86 MODULE_PARM_DESC(rdpq_enable, "Allocate reply queue in chunks for large queue depth enable/disable Default: enable(1)");
  87
  88 unsigned int dual_qdepth_disable;
  89 module_param(dual_qdepth_disable, int, 0444);
  90 MODULE_PARM_DESC(dual_qdepth_disable, "Disable dual queue depth feature. Default: 0");
  91
  92 unsigned int scmd_timeout = MEGASAS_DEFAULT_CMD_TIMEOUT;
  93 module_param(scmd_timeout, int, 0444);
  94 MODULE_PARM_DESC(scmd_timeout, "scsi command timeout (10-90s), default 90s. See megasas_reset_timer.");
  95
  96 int perf_mode = -1;
  97 module_param(perf_mode, int, 0444);
  98 MODULE_PARM_DESC(perf_mode, "Performance mode (only for Aero adapters), options:\n\t\t"
  99                 "0 - balanced: High iops and low latency queues are allocated &\n\t\t"
 100                 "interrupt coalescing is enabled only on high iops queues\n\t\t"
 101                 "1 - iops: High iops queues are not allocated &\n\t\t"
 102                 "interrupt coalescing is enabled on all queues\n\t\t"
 103                 "2 - latency: High iops queues are not allocated &\n\t\t"
 104                 "interrupt coalescing is disabled on all queues\n\t\t"
 105                 "default mode is 'balanced'"
 106                 );
 107
 108 int event_log_level = MFI_EVT_CLASS_CRITICAL;
 109 module_param(event_log_level, int, 0644);
 110 MODULE_PARM_DESC(event_log_level, "Asynchronous event logging level- range is: -2(CLASS_DEBUG) to 4(CLASS_DEAD), Default: 2(CLASS_CRITICAL)");
 111
 112 unsigned int enable_sdev_max_qd;
 113 module_param(enable_sdev_max_qd, int, 0444);
 114 MODULE_PARM_DESC(enable_sdev_max_qd, "Enable sdev max qd as can_queue. Default: 0");
 115
 116 MODULE_LICENSE("GPL");
 117 MODULE_VERSION(MEGASAS_VERSION);
 118 MODULE_AUTHOR("megaraidlinux.pdl@broadcom.com");
 119 MODULE_DESCRIPTION("Broadcom MegaRAID SAS Driver");
 120
 121 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
 122 static int megasas_get_pd_list(struct megasas_instance *instance);
 123 static int megasas_ld_list_query(struct megasas_instance *instance,
 124                                  u8 query_type);
 125 static int megasas_issue_init_mfi(struct megasas_instance *instance);
 126 static int megasas_register_aen(struct megasas_instance *instance,
 127                                 u32 seq_num, u32 class_locale_word);
 128 static void megasas_get_pd_info(struct megasas_instance *instance,
 129                                 struct scsi_device *sdev);
 130
 131 /*
 132  * PCI ID table for all supported controllers
 133  */
 134 static struct pci_device_id megasas_pci_table[] = {
 135
 136         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064R)},
 137         /* xscale IOP */
 138         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078R)},
 139         /* ppc IOP */
 140         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078DE)},
 141         /* ppc IOP */
 142         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078GEN2)},
 143         /* gen2*/
 144         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0079GEN2)},
 145         /* gen2*/
 146         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0073SKINNY)},
 147         /* skinny*/
 148         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0071SKINNY)},
 149         /* skinny*/
 150         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)},
 151         /* xscale IOP, vega */
 152         {PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},
 153         /* xscale IOP */
 154         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FUSION)},
 155         /* Fusion */
 156         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_PLASMA)},
 157         /* Plasma */
 158         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INVADER)},
 159         /* Invader */
 160         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FURY)},
 161         /* Fury */
 162         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INTRUDER)},
 163         /* Intruder */
 164         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INTRUDER_24)},
 165         /* Intruder 24 port*/
 166         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_CUTLASS_52)},
 167         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_CUTLASS_53)},
 168         /* VENTURA */
 169         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VENTURA)},
 170         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_CRUSADER)},
 171         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_HARPOON)},
 172         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_TOMCAT)},
 173         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VENTURA_4PORT)},
 174         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_CRUSADER_4PORT)},
 175         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E1)},
 176         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E2)},
 177         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E5)},
 178         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E6)},
 179         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E0)},
 180         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E3)},
 181         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E4)},
 182         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_AERO_10E7)},
 183         {}
 184 };
 185
 186 MODULE_DEVICE_TABLE(pci, megasas_pci_table);
 187
 188 static int megasas_mgmt_majorno;
 189 struct megasas_mgmt_info megasas_mgmt_info;
 190 static struct fasync_struct *megasas_async_queue;
 191 static DEFINE_MUTEX(megasas_async_queue_mutex);
 192
 193 static int megasas_poll_wait_aen;
 194 static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait);
 195 static u32 support_poll_for_event;
 196 u32 megasas_dbg_lvl;
 197 static u32 support_device_change;
 198 static bool support_nvme_encapsulation;
 199 static bool support_pci_lane_margining;
 200
 201 /* define lock for aen poll */
 202 static spinlock_t poll_aen_lock;
 203
 204 extern struct dentry *megasas_debugfs_root;
 205 extern void megasas_init_debugfs(void);
 206 extern void megasas_exit_debugfs(void);
 207 extern void megasas_setup_debugfs(struct megasas_instance *instance);
 208 extern void megasas_destroy_debugfs(struct megasas_instance *instance);
 209
 210 void
 211 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
 212                      u8 alt_status);
 213 static u32
 214 megasas_read_fw_status_reg_gen2(struct megasas_instance *instance);
 215 static int
 216 megasas_adp_reset_gen2(struct megasas_instance *instance,
 217                        struct megasas_register_set __iomem *reg_set);
 218 static irqreturn_t megasas_isr(int irq, void *devp);
 219 static u32
 220 megasas_init_adapter_mfi(struct megasas_instance *instance);
 221 u32
 222 megasas_build_and_issue_cmd(struct megasas_instance *instance,
 223                             struct scsi_cmnd *scmd);
 224 static void megasas_complete_cmd_dpc(unsigned long instance_addr);
 225 int
 226 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd,
 227         int seconds);
 228 void megasas_fusion_ocr_wq(struct work_struct *work);
 229 static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
 230                                          int initial);
 231 static int
 232 megasas_set_dma_mask(struct megasas_instance *instance);
 233 static int
 234 megasas_alloc_ctrl_mem(struct megasas_instance *instance);
 235 static inline void
 236 megasas_free_ctrl_mem(struct megasas_instance *instance);
 237 static inline int
 238 megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance);
 239 static inline void
 240 megasas_free_ctrl_dma_buffers(struct megasas_instance *instance);
 241 static inline void
 242 megasas_init_ctrl_params(struct megasas_instance *instance);
 243
 244 u32 megasas_readl(struct megasas_instance *instance,
 245                   const volatile void __iomem *addr)
 246 {
 247         u32 i = 0, ret_val;
 248         /*
 249          * Due to a HW errata in Aero controllers, reads to certain
 250          * Fusion registers could intermittently return all zeroes.
 251          * This behavior is transient in nature and subsequent reads will
 252          * return valid value. As a workaround in driver, retry readl for
 253          * upto three times until a non-zero value is read.
 254          */
 255         if (instance->adapter_type == AERO_SERIES) {
 256                 do {
 257                         ret_val = readl(addr);
 258                         i++;
 259                 } while (ret_val == 0 && i < 3);
 260                 return ret_val;
 261         } else {
 262                 return readl(addr);
 263         }
 264 }
 265
 266 /**
 267  * megasas_set_dma_settings -   Populate DMA address, length and flags for DCMDs
 268  * @instance:                   Adapter soft state
 269  * @dcmd:                       DCMD frame inside MFI command
 270  * @dma_addr:                   DMA address of buffer to be passed to FW
 271  * @dma_len:                    Length of DMA buffer to be passed to FW
 272  * @return:                     void
 273  */
 274 void megasas_set_dma_settings(struct megasas_instance *instance,
 275                               struct megasas_dcmd_frame *dcmd,
 276                               dma_addr_t dma_addr, u32 dma_len)
 277 {
 278         if (instance->consistent_mask_64bit) {
 279                 dcmd->sgl.sge64[0].phys_addr = cpu_to_le64(dma_addr);
 280                 dcmd->sgl.sge64[0].length = cpu_to_le32(dma_len);
 281                 dcmd->flags = cpu_to_le16(dcmd->flags | MFI_FRAME_SGL64);
 282
 283         } else {
 284                 dcmd->sgl.sge32[0].phys_addr =
 285                                 cpu_to_le32(lower_32_bits(dma_addr));
 286                 dcmd->sgl.sge32[0].length = cpu_to_le32(dma_len);
 287                 dcmd->flags = cpu_to_le16(dcmd->flags);
 288         }
 289 }
 290
 291 static void
 292 megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
 293 {
 294         instance->instancet->fire_cmd(instance,
 295                 cmd->frame_phys_addr, 0, instance->reg_set);
 296         return;
 297 }
 298
 299 /**
 300  * megasas_get_cmd -    Get a command from the free pool
 301  * @instance:           Adapter soft state
 302  *
 303  * Returns a free command from the pool
 304  */
 305 struct megasas_cmd *megasas_get_cmd(struct megasas_instance
 306                                                   *instance)
 307 {
 308         unsigned long flags;
 309         struct megasas_cmd *cmd = NULL;
 310
 311         spin_lock_irqsave(&instance->mfi_pool_lock, flags);
 312
 313         if (!list_empty(&instance->cmd_pool)) {
 314                 cmd = list_entry((&instance->cmd_pool)->next,
 315                                  struct megasas_cmd, list);
 316                 list_del_init(&cmd->list);
 317         } else {
 318                 dev_err(&instance->pdev->dev, "Command pool empty!\n");
 319         }
 320
 321         spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
 322         return cmd;
 323 }
 324
 325 /**
 326  * megasas_return_cmd - Return a cmd to free command pool
 327  * @instance:           Adapter soft state
 328  * @cmd:                Command packet to be returned to free command pool
 329  */
 330 void
 331 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
 332 {
 333         unsigned long flags;
 334         u32 blk_tags;
 335         struct megasas_cmd_fusion *cmd_fusion;
 336         struct fusion_context *fusion = instance->ctrl_context;
 337
 338         /* This flag is used only for fusion adapter.
 339          * Wait for Interrupt for Polled mode DCMD
 340          */
 341         if (cmd->flags & DRV_DCMD_POLLED_MODE)
 342                 return;
 343
 344         spin_lock_irqsave(&instance->mfi_pool_lock, flags);
 345
 346         if (fusion) {
 347                 blk_tags = instance->max_scsi_cmds + cmd->index;
 348                 cmd_fusion = fusion->cmd_list[blk_tags];
 349                 megasas_return_cmd_fusion(instance, cmd_fusion);
 350         }
 351         cmd->scmd = NULL;
 352         cmd->frame_count = 0;
 353         cmd->flags = 0;
 354         memset(cmd->frame, 0, instance->mfi_frame_size);
 355         cmd->frame->io.context = cpu_to_le32(cmd->index);
 356         if (!fusion && reset_devices)
 357                 cmd->frame->hdr.cmd = MFI_CMD_INVALID;
 358         list_add(&cmd->list, (&instance->cmd_pool)->next);
 359
 360         spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
 361
 362 }
 363
 364 static const char *
 365 format_timestamp(uint32_t timestamp)
 366 {
 367         static char buffer[32];
 368
 369         if ((timestamp & 0xff000000) == 0xff000000)
 370                 snprintf(buffer, sizeof(buffer), "boot + %us", timestamp &
 371                 0x00ffffff);
 372         else
 373                 snprintf(buffer, sizeof(buffer), "%us", timestamp);
 374         return buffer;
 375 }
 376
 377 static const char *
 378 format_class(int8_t class)
 379 {
 380         static char buffer[6];
 381
 382         switch (class) {
 383         case MFI_EVT_CLASS_DEBUG:
 384                 return "debug";
 385         case MFI_EVT_CLASS_PROGRESS:
 386                 return "progress";
 387         case MFI_EVT_CLASS_INFO:
 388                 return "info";
 389         case MFI_EVT_CLASS_WARNING:
 390                 return "WARN";
 391         case MFI_EVT_CLASS_CRITICAL:
 392                 return "CRIT";
 393         case MFI_EVT_CLASS_FATAL:
 394                 return "FATAL";
 395         case MFI_EVT_CLASS_DEAD:
 396                 return "DEAD";
 397         default:
 398                 snprintf(buffer, sizeof(buffer), "%d", class);
 399                 return buffer;
 400         }
 401 }
 402
 403 /**
 404   * megasas_decode_evt: Decode FW AEN event and print critical event
 405   * for information.
 406   * @instance:                  Adapter soft state
 407   */
 408 static void
 409 megasas_decode_evt(struct megasas_instance *instance)
 410 {
 411         struct megasas_evt_detail *evt_detail = instance->evt_detail;
 412         union megasas_evt_class_locale class_locale;
 413         class_locale.word = le32_to_cpu(evt_detail->cl.word);
 414
 415         if ((event_log_level < MFI_EVT_CLASS_DEBUG) ||
 416             (event_log_level > MFI_EVT_CLASS_DEAD)) {
 417                 printk(KERN_WARNING "megaraid_sas: provided event log level is out of range, setting it to default 2(CLASS_CRITICAL), permissible range is: -2 to 4\n");
 418                 event_log_level = MFI_EVT_CLASS_CRITICAL;
 419         }
 420
 421         if (class_locale.members.class >= event_log_level)
 422                 dev_info(&instance->pdev->dev, "%d (%s/0x%04x/%s) - %s\n",
 423                         le32_to_cpu(evt_detail->seq_num),
 424                         format_timestamp(le32_to_cpu(evt_detail->time_stamp)),
 425                         (class_locale.members.locale),
 426                         format_class(class_locale.members.class),
 427                         evt_detail->description);
 428 }
 429
 430 /**
 431 *       The following functions are defined for xscale
 432 *       (deviceid : 1064R, PERC5) controllers
 433 */
 434
 435 /**
 436  * megasas_enable_intr_xscale - Enables interrupts
 437  * @regs:                       MFI register set
 438  */
 439 static inline void
 440 megasas_enable_intr_xscale(struct megasas_instance *instance)
 441 {
 442         struct megasas_register_set __iomem *regs;
 443
 444         regs = instance->reg_set;
 445         writel(0, &(regs)->outbound_intr_mask);
 446
 447         /* Dummy readl to force pci flush */
 448         readl(&regs->outbound_intr_mask);
 449 }
 450
 451 /**
 452  * megasas_disable_intr_xscale -Disables interrupt
 453  * @regs:                       MFI register set
 454  */
 455 static inline void
 456 megasas_disable_intr_xscale(struct megasas_instance *instance)
 457 {
 458         struct megasas_register_set __iomem *regs;
 459         u32 mask = 0x1f;
 460
 461         regs = instance->reg_set;
 462         writel(mask, &regs->outbound_intr_mask);
 463         /* Dummy readl to force pci flush */
 464         readl(&regs->outbound_intr_mask);
 465 }
 466
 467 /**
 468  * megasas_read_fw_status_reg_xscale - returns the current FW status value
 469  * @regs:                       MFI register set
 470  */
 471 static u32
 472 megasas_read_fw_status_reg_xscale(struct megasas_instance *instance)
 473 {
 474         return readl(&instance->reg_set->outbound_msg_0);
 475 }
 476 /**
 477  * megasas_clear_interrupt_xscale -     Check & clear interrupt
 478  * @regs:                               MFI register set
 479  */
 480 static int
 481 megasas_clear_intr_xscale(struct megasas_instance *instance)
 482 {
 483         u32 status;
 484         u32 mfiStatus = 0;
 485         struct megasas_register_set __iomem *regs;
 486         regs = instance->reg_set;
 487
 488         /*
 489          * Check if it is our interrupt
 490          */
 491         status = readl(&regs->outbound_intr_status);
 492
 493         if (status & MFI_OB_INTR_STATUS_MASK)
 494                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 495         if (status & MFI_XSCALE_OMR0_CHANGE_INTERRUPT)
 496                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 497
 498         /*
 499          * Clear the interrupt by writing back the same value
 500          */
 501         if (mfiStatus)
 502                 writel(status, &regs->outbound_intr_status);
 503
 504         /* Dummy readl to force pci flush */
 505         readl(&regs->outbound_intr_status);
 506
 507         return mfiStatus;
 508 }
 509
 510 /**
 511  * megasas_fire_cmd_xscale -    Sends command to the FW
 512  * @frame_phys_addr :           Physical address of cmd
 513  * @frame_count :               Number of frames for the command
 514  * @regs :                      MFI register set
 515  */
 516 static inline void
 517 megasas_fire_cmd_xscale(struct megasas_instance *instance,
 518                 dma_addr_t frame_phys_addr,
 519                 u32 frame_count,
 520                 struct megasas_register_set __iomem *regs)
 521 {
 522         unsigned long flags;
 523
 524         spin_lock_irqsave(&instance->hba_lock, flags);
 525         writel((frame_phys_addr >> 3)|(frame_count),
 526                &(regs)->inbound_queue_port);
 527         spin_unlock_irqrestore(&instance->hba_lock, flags);
 528 }
 529
 530 /**
 531  * megasas_adp_reset_xscale -  For controller reset
 532  * @regs:                              MFI register set
 533  */
 534 static int
 535 megasas_adp_reset_xscale(struct megasas_instance *instance,
 536         struct megasas_register_set __iomem *regs)
 537 {
 538         u32 i;
 539         u32 pcidata;
 540
 541         writel(MFI_ADP_RESET, &regs->inbound_doorbell);
 542
 543         for (i = 0; i < 3; i++)
 544                 msleep(1000); /* sleep for 3 secs */
 545         pcidata  = 0;
 546         pci_read_config_dword(instance->pdev, MFI_1068_PCSR_OFFSET, &pcidata);
 547         dev_notice(&instance->pdev->dev, "pcidata = %x\n", pcidata);
 548         if (pcidata & 0x2) {
 549                 dev_notice(&instance->pdev->dev, "mfi 1068 offset read=%x\n", pcidata);
 550                 pcidata &= ~0x2;
 551                 pci_write_config_dword(instance->pdev,
 552                                 MFI_1068_PCSR_OFFSET, pcidata);
 553
 554                 for (i = 0; i < 2; i++)
 555                         msleep(1000); /* need to wait 2 secs again */
 556
 557                 pcidata  = 0;
 558                 pci_read_config_dword(instance->pdev,
 559                                 MFI_1068_FW_HANDSHAKE_OFFSET, &pcidata);
 560                 dev_notice(&instance->pdev->dev, "1068 offset handshake read=%x\n", pcidata);
 561                 if ((pcidata & 0xffff0000) == MFI_1068_FW_READY) {
 562                         dev_notice(&instance->pdev->dev, "1068 offset pcidt=%x\n", pcidata);
 563                         pcidata = 0;
 564                         pci_write_config_dword(instance->pdev,
 565                                 MFI_1068_FW_HANDSHAKE_OFFSET, pcidata);
 566                 }
 567         }
 568         return 0;
 569 }
 570
 571 /**
 572  * megasas_check_reset_xscale - For controller reset check
 573  * @regs:                               MFI register set
 574  */
 575 static int
 576 megasas_check_reset_xscale(struct megasas_instance *instance,
 577                 struct megasas_register_set __iomem *regs)
 578 {
 579         if ((atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) &&
 580             (le32_to_cpu(*instance->consumer) ==
 581                 MEGASAS_ADPRESET_INPROG_SIGN))
 582                 return 1;
 583         return 0;
 584 }
 585
 586 static struct megasas_instance_template megasas_instance_template_xscale = {
 587
 588         .fire_cmd = megasas_fire_cmd_xscale,
 589         .enable_intr = megasas_enable_intr_xscale,
 590         .disable_intr = megasas_disable_intr_xscale,
 591         .clear_intr = megasas_clear_intr_xscale,
 592         .read_fw_status_reg = megasas_read_fw_status_reg_xscale,
 593         .adp_reset = megasas_adp_reset_xscale,
 594         .check_reset = megasas_check_reset_xscale,
 595         .service_isr = megasas_isr,
 596         .tasklet = megasas_complete_cmd_dpc,
 597         .init_adapter = megasas_init_adapter_mfi,
 598         .build_and_issue_cmd = megasas_build_and_issue_cmd,
 599         .issue_dcmd = megasas_issue_dcmd,
 600 };
 601
 602 /**
 603 *       This is the end of set of functions & definitions specific
 604 *       to xscale (deviceid : 1064R, PERC5) controllers
 605 */
 606
 607 /**
 608 *       The following functions are defined for ppc (deviceid : 0x60)
 609 *       controllers
 610 */
 611
 612 /**
 613  * megasas_enable_intr_ppc -    Enables interrupts
 614  * @regs:                       MFI register set
 615  */
 616 static inline void
 617 megasas_enable_intr_ppc(struct megasas_instance *instance)
 618 {
 619         struct megasas_register_set __iomem *regs;
 620
 621         regs = instance->reg_set;
 622         writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
 623
 624         writel(~0x80000000, &(regs)->outbound_intr_mask);
 625
 626         /* Dummy readl to force pci flush */
 627         readl(&regs->outbound_intr_mask);
 628 }
 629
 630 /**
 631  * megasas_disable_intr_ppc -   Disable interrupt
 632  * @regs:                       MFI register set
 633  */
 634 static inline void
 635 megasas_disable_intr_ppc(struct megasas_instance *instance)
 636 {
 637         struct megasas_register_set __iomem *regs;
 638         u32 mask = 0xFFFFFFFF;
 639
 640         regs = instance->reg_set;
 641         writel(mask, &regs->outbound_intr_mask);
 642         /* Dummy readl to force pci flush */
 643         readl(&regs->outbound_intr_mask);
 644 }
 645
 646 /**
 647  * megasas_read_fw_status_reg_ppc - returns the current FW status value
 648  * @regs:                       MFI register set
 649  */
 650 static u32
 651 megasas_read_fw_status_reg_ppc(struct megasas_instance *instance)
 652 {
 653         return readl(&instance->reg_set->outbound_scratch_pad_0);
 654 }
 655
 656 /**
 657  * megasas_clear_interrupt_ppc -        Check & clear interrupt
 658  * @regs:                               MFI register set
 659  */
 660 static int
 661 megasas_clear_intr_ppc(struct megasas_instance *instance)
 662 {
 663         u32 status, mfiStatus = 0;
 664         struct megasas_register_set __iomem *regs;
 665         regs = instance->reg_set;
 666
 667         /*
 668          * Check if it is our interrupt
 669          */
 670         status = readl(&regs->outbound_intr_status);
 671
 672         if (status & MFI_REPLY_1078_MESSAGE_INTERRUPT)
 673                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 674
 675         if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT)
 676                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 677
 678         /*
 679          * Clear the interrupt by writing back the same value
 680          */
 681         writel(status, &regs->outbound_doorbell_clear);
 682
 683         /* Dummy readl to force pci flush */
 684         readl(&regs->outbound_doorbell_clear);
 685
 686         return mfiStatus;
 687 }
 688
 689 /**
 690  * megasas_fire_cmd_ppc -       Sends command to the FW
 691  * @frame_phys_addr :           Physical address of cmd
 692  * @frame_count :               Number of frames for the command
 693  * @regs :                      MFI register set
 694  */
 695 static inline void
 696 megasas_fire_cmd_ppc(struct megasas_instance *instance,
 697                 dma_addr_t frame_phys_addr,
 698                 u32 frame_count,
 699                 struct megasas_register_set __iomem *regs)
 700 {
 701         unsigned long flags;
 702
 703         spin_lock_irqsave(&instance->hba_lock, flags);
 704         writel((frame_phys_addr | (frame_count<<1))|1,
 705                         &(regs)->inbound_queue_port);
 706         spin_unlock_irqrestore(&instance->hba_lock, flags);
 707 }
 708
 709 /**
 710  * megasas_check_reset_ppc -    For controller reset check
 711  * @regs:                               MFI register set
 712  */
 713 static int
 714 megasas_check_reset_ppc(struct megasas_instance *instance,
 715                         struct megasas_register_set __iomem *regs)
 716 {
 717         if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
 718                 return 1;
 719
 720         return 0;
 721 }
 722
 723 static struct megasas_instance_template megasas_instance_template_ppc = {
 724
 725         .fire_cmd = megasas_fire_cmd_ppc,
 726         .enable_intr = megasas_enable_intr_ppc,
 727         .disable_intr = megasas_disable_intr_ppc,
 728         .clear_intr = megasas_clear_intr_ppc,
 729         .read_fw_status_reg = megasas_read_fw_status_reg_ppc,
 730         .adp_reset = megasas_adp_reset_xscale,
 731         .check_reset = megasas_check_reset_ppc,
 732         .service_isr = megasas_isr,
 733         .tasklet = megasas_complete_cmd_dpc,
 734         .init_adapter = megasas_init_adapter_mfi,
 735         .build_and_issue_cmd = megasas_build_and_issue_cmd,
 736         .issue_dcmd = megasas_issue_dcmd,
 737 };
 738
 739 /**
 740  * megasas_enable_intr_skinny - Enables interrupts
 741  * @regs:                       MFI register set
 742  */
 743 static inline void
 744 megasas_enable_intr_skinny(struct megasas_instance *instance)
 745 {
 746         struct megasas_register_set __iomem *regs;
 747
 748         regs = instance->reg_set;
 749         writel(0xFFFFFFFF, &(regs)->outbound_intr_mask);
 750
 751         writel(~MFI_SKINNY_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
 752
 753         /* Dummy readl to force pci flush */
 754         readl(&regs->outbound_intr_mask);
 755 }
 756
 757 /**
 758  * megasas_disable_intr_skinny -        Disables interrupt
 759  * @regs:                       MFI register set
 760  */
 761 static inline void
 762 megasas_disable_intr_skinny(struct megasas_instance *instance)
 763 {
 764         struct megasas_register_set __iomem *regs;
 765         u32 mask = 0xFFFFFFFF;
 766
 767         regs = instance->reg_set;
 768         writel(mask, &regs->outbound_intr_mask);
 769         /* Dummy readl to force pci flush */
 770         readl(&regs->outbound_intr_mask);
 771 }
 772
 773 /**
 774  * megasas_read_fw_status_reg_skinny - returns the current FW status value
 775  * @regs:                       MFI register set
 776  */
 777 static u32
 778 megasas_read_fw_status_reg_skinny(struct megasas_instance *instance)
 779 {
 780         return readl(&instance->reg_set->outbound_scratch_pad_0);
 781 }
 782
 783 /**
 784  * megasas_clear_interrupt_skinny -     Check & clear interrupt
 785  * @regs:                               MFI register set
 786  */
 787 static int
 788 megasas_clear_intr_skinny(struct megasas_instance *instance)
 789 {
 790         u32 status;
 791         u32 mfiStatus = 0;
 792         struct megasas_register_set __iomem *regs;
 793         regs = instance->reg_set;
 794
 795         /*
 796          * Check if it is our interrupt
 797          */
 798         status = readl(&regs->outbound_intr_status);
 799
 800         if (!(status & MFI_SKINNY_ENABLE_INTERRUPT_MASK)) {
 801                 return 0;
 802         }
 803
 804         /*
 805          * Check if it is our interrupt
 806          */
 807         if ((megasas_read_fw_status_reg_skinny(instance) & MFI_STATE_MASK) ==
 808             MFI_STATE_FAULT) {
 809                 mfiStatus = MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 810         } else
 811                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 812
 813         /*
 814          * Clear the interrupt by writing back the same value
 815          */
 816         writel(status, &regs->outbound_intr_status);
 817
 818         /*
 819          * dummy read to flush PCI
 820          */
 821         readl(&regs->outbound_intr_status);
 822
 823         return mfiStatus;
 824 }
 825
 826 /**
 827  * megasas_fire_cmd_skinny -    Sends command to the FW
 828  * @frame_phys_addr :           Physical address of cmd
 829  * @frame_count :               Number of frames for the command
 830  * @regs :                      MFI register set
 831  */
 832 static inline void
 833 megasas_fire_cmd_skinny(struct megasas_instance *instance,
 834                         dma_addr_t frame_phys_addr,
 835                         u32 frame_count,
 836                         struct megasas_register_set __iomem *regs)
 837 {
 838         unsigned long flags;
 839
 840         spin_lock_irqsave(&instance->hba_lock, flags);
 841         writel(upper_32_bits(frame_phys_addr),
 842                &(regs)->inbound_high_queue_port);
 843         writel((lower_32_bits(frame_phys_addr) | (frame_count<<1))|1,
 844                &(regs)->inbound_low_queue_port);
 845         spin_unlock_irqrestore(&instance->hba_lock, flags);
 846 }
 847
 848 /**
 849  * megasas_check_reset_skinny - For controller reset check
 850  * @regs:                               MFI register set
 851  */
 852 static int
 853 megasas_check_reset_skinny(struct megasas_instance *instance,
 854                                 struct megasas_register_set __iomem *regs)
 855 {
 856         if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
 857                 return 1;
 858
 859         return 0;
 860 }
 861
 862 static struct megasas_instance_template megasas_instance_template_skinny = {
 863
 864         .fire_cmd = megasas_fire_cmd_skinny,
 865         .enable_intr = megasas_enable_intr_skinny,
 866         .disable_intr = megasas_disable_intr_skinny,
 867         .clear_intr = megasas_clear_intr_skinny,
 868         .read_fw_status_reg = megasas_read_fw_status_reg_skinny,
 869         .adp_reset = megasas_adp_reset_gen2,
 870         .check_reset = megasas_check_reset_skinny,
 871         .service_isr = megasas_isr,
 872         .tasklet = megasas_complete_cmd_dpc,
 873         .init_adapter = megasas_init_adapter_mfi,
 874         .build_and_issue_cmd = megasas_build_and_issue_cmd,
 875         .issue_dcmd = megasas_issue_dcmd,
 876 };
 877
 878
 879 /**
 880 *       The following functions are defined for gen2 (deviceid : 0x78 0x79)
 881 *       controllers
 882 */
 883
 884 /**
 885  * megasas_enable_intr_gen2 -  Enables interrupts
 886  * @regs:                      MFI register set
 887  */
 888 static inline void
 889 megasas_enable_intr_gen2(struct megasas_instance *instance)
 890 {
 891         struct megasas_register_set __iomem *regs;
 892
 893         regs = instance->reg_set;
 894         writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
 895
 896         /* write ~0x00000005 (4 & 1) to the intr mask*/
 897         writel(~MFI_GEN2_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
 898
 899         /* Dummy readl to force pci flush */
 900         readl(&regs->outbound_intr_mask);
 901 }
 902
 903 /**
 904  * megasas_disable_intr_gen2 - Disables interrupt
 905  * @regs:                      MFI register set
 906  */
 907 static inline void
 908 megasas_disable_intr_gen2(struct megasas_instance *instance)
 909 {
 910         struct megasas_register_set __iomem *regs;
 911         u32 mask = 0xFFFFFFFF;
 912
 913         regs = instance->reg_set;
 914         writel(mask, &regs->outbound_intr_mask);
 915         /* Dummy readl to force pci flush */
 916         readl(&regs->outbound_intr_mask);
 917 }
 918
 919 /**
 920  * megasas_read_fw_status_reg_gen2 - returns the current FW status value
 921  * @regs:                      MFI register set
 922  */
 923 static u32
 924 megasas_read_fw_status_reg_gen2(struct megasas_instance *instance)
 925 {
 926         return readl(&instance->reg_set->outbound_scratch_pad_0);
 927 }
 928
 929 /**
 930  * megasas_clear_interrupt_gen2 -      Check & clear interrupt
 931  * @regs:                              MFI register set
 932  */
 933 static int
 934 megasas_clear_intr_gen2(struct megasas_instance *instance)
 935 {
 936         u32 status;
 937         u32 mfiStatus = 0;
 938         struct megasas_register_set __iomem *regs;
 939         regs = instance->reg_set;
 940
 941         /*
 942          * Check if it is our interrupt
 943          */
 944         status = readl(&regs->outbound_intr_status);
 945
 946         if (status & MFI_INTR_FLAG_REPLY_MESSAGE) {
 947                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 948         }
 949         if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT) {
 950                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 951         }
 952
 953         /*
 954          * Clear the interrupt by writing back the same value
 955          */
 956         if (mfiStatus)
 957                 writel(status, &regs->outbound_doorbell_clear);
 958
 959         /* Dummy readl to force pci flush */
 960         readl(&regs->outbound_intr_status);
 961
 962         return mfiStatus;
 963 }
 964 /**
 965  * megasas_fire_cmd_gen2 -     Sends command to the FW
 966  * @frame_phys_addr :          Physical address of cmd
 967  * @frame_count :              Number of frames for the command
 968  * @regs :                     MFI register set
 969  */
 970 static inline void
 971 megasas_fire_cmd_gen2(struct megasas_instance *instance,
 972                         dma_addr_t frame_phys_addr,
 973                         u32 frame_count,
 974                         struct megasas_register_set __iomem *regs)
 975 {
 976         unsigned long flags;
 977
 978         spin_lock_irqsave(&instance->hba_lock, flags);
 979         writel((frame_phys_addr | (frame_count<<1))|1,
 980                         &(regs)->inbound_queue_port);
 981         spin_unlock_irqrestore(&instance->hba_lock, flags);
 982 }
 983
 984 /**
 985  * megasas_adp_reset_gen2 -     For controller reset
 986  * @regs:                               MFI register set
 987  */
 988 static int
 989 megasas_adp_reset_gen2(struct megasas_instance *instance,
 990                         struct megasas_register_set __iomem *reg_set)
 991 {
 992         u32 retry = 0 ;
 993         u32 HostDiag;
 994         u32 __iomem *seq_offset = &reg_set->seq_offset;
 995         u32 __iomem *hostdiag_offset = &reg_set->host_diag;
 996
 997         if (instance->instancet == &megasas_instance_template_skinny) {
 998                 seq_offset = &reg_set->fusion_seq_offset;
 999                 hostdiag_offset = &reg_set->fusion_host_diag;
1000         }
1001
1002         writel(0, seq_offset);
1003         writel(4, seq_offset);
1004         writel(0xb, seq_offset);
1005         writel(2, seq_offset);
1006         writel(7, seq_offset);
1007         writel(0xd, seq_offset);
1008
1009         msleep(1000);
1010
1011         HostDiag = (u32)readl(hostdiag_offset);
1012
1013         while (!(HostDiag & DIAG_WRITE_ENABLE)) {
1014                 msleep(100);
1015                 HostDiag = (u32)readl(hostdiag_offset);
1016                 dev_notice(&instance->pdev->dev, "RESETGEN2: retry=%x, hostdiag=%x\n",
1017                                         retry, HostDiag);
1018
1019                 if (retry++ >= 100)
1020                         return 1;
1021
1022         }
1023
1024         dev_notice(&instance->pdev->dev, "ADP_RESET_GEN2: HostDiag=%x\n", HostDiag);
1025
1026         writel((HostDiag | DIAG_RESET_ADAPTER), hostdiag_offset);
1027
1028         ssleep(10);
1029
1030         HostDiag = (u32)readl(hostdiag_offset);
1031         while (HostDiag & DIAG_RESET_ADAPTER) {
1032                 msleep(100);
1033                 HostDiag = (u32)readl(hostdiag_offset);
1034                 dev_notice(&instance->pdev->dev, "RESET_GEN2: retry=%x, hostdiag=%x\n",
1035                                 retry, HostDiag);
1036
1037                 if (retry++ >= 1000)
1038                         return 1;
1039
1040         }
1041         return 0;
1042 }
1043
1044 /**
1045  * megasas_check_reset_gen2 -   For controller reset check
1046  * @regs:                               MFI register set
1047  */
1048 static int
1049 megasas_check_reset_gen2(struct megasas_instance *instance,
1050                 struct megasas_register_set __iomem *regs)
1051 {
1052         if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
1053                 return 1;
1054
1055         return 0;
1056 }
1057
1058 static struct megasas_instance_template megasas_instance_template_gen2 = {
1059
1060         .fire_cmd = megasas_fire_cmd_gen2,
1061         .enable_intr = megasas_enable_intr_gen2,
1062         .disable_intr = megasas_disable_intr_gen2,
1063         .clear_intr = megasas_clear_intr_gen2,
1064         .read_fw_status_reg = megasas_read_fw_status_reg_gen2,
1065         .adp_reset = megasas_adp_reset_gen2,
1066         .check_reset = megasas_check_reset_gen2,
1067         .service_isr = megasas_isr,
1068         .tasklet = megasas_complete_cmd_dpc,
1069         .init_adapter = megasas_init_adapter_mfi,
1070         .build_and_issue_cmd = megasas_build_and_issue_cmd,
1071         .issue_dcmd = megasas_issue_dcmd,
1072 };
1073
1074 /**
1075 *       This is the end of set of functions & definitions
1076 *       specific to gen2 (deviceid : 0x78, 0x79) controllers
1077 */
1078
1079 /*
1080  * Template added for TB (Fusion)
1081  */
1082 extern struct megasas_instance_template megasas_instance_template_fusion;
1083
1084 /**
1085  * megasas_issue_polled -       Issues a polling command
1086  * @instance:                   Adapter soft state
1087  * @cmd:                        Command packet to be issued
1088  *
1089  * For polling, MFI requires the cmd_status to be set to MFI_STAT_INVALID_STATUS before posting.
1090  */
1091 int
1092 megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
1093 {
1094         struct megasas_header *frame_hdr = &cmd->frame->hdr;
1095
1096         frame_hdr->cmd_status = MFI_STAT_INVALID_STATUS;
1097         frame_hdr->flags |= cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE);
1098
1099         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1100                 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1101                         __func__, __LINE__);
1102                 return DCMD_INIT;
1103         }
1104
1105         instance->instancet->issue_dcmd(instance, cmd);
1106
1107         return wait_and_poll(instance, cmd, instance->requestorId ?
1108                         MEGASAS_ROUTINE_WAIT_TIME_VF : MFI_IO_TIMEOUT_SECS);
1109 }
1110
1111 /**
1112  * megasas_issue_blocked_cmd -  Synchronous wrapper around regular FW cmds
1113  * @instance:                   Adapter soft state
1114  * @cmd:                        Command to be issued
1115  * @timeout:                    Timeout in seconds
1116  *
1117  * This function waits on an event for the command to be returned from ISR.
1118  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
1119  * Used to issue ioctl commands.
1120  */
1121 int
1122 megasas_issue_blocked_cmd(struct megasas_instance *instance,
1123                           struct megasas_cmd *cmd, int timeout)
1124 {
1125         int ret = 0;
1126         cmd->cmd_status_drv = DCMD_INIT;
1127
1128         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1129                 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1130                         __func__, __LINE__);
1131                 return DCMD_INIT;
1132         }
1133
1134         instance->instancet->issue_dcmd(instance, cmd);
1135
1136         if (timeout) {
1137                 ret = wait_event_timeout(instance->int_cmd_wait_q,
1138                 cmd->cmd_status_drv != DCMD_INIT, timeout * HZ);
1139                 if (!ret) {
1140                         dev_err(&instance->pdev->dev,
1141                                 "DCMD(opcode: 0x%x) is timed out, func:%s\n",
1142                                 cmd->frame->dcmd.opcode, __func__);
1143                         return DCMD_TIMEOUT;
1144                 }
1145         } else
1146                 wait_event(instance->int_cmd_wait_q,
1147                                 cmd->cmd_status_drv != DCMD_INIT);
1148
1149         return cmd->cmd_status_drv;
1150 }
1151
1152 /**
1153  * megasas_issue_blocked_abort_cmd -    Aborts previously issued cmd
1154  * @instance:                           Adapter soft state
1155  * @cmd_to_abort:                       Previously issued cmd to be aborted
1156  * @timeout:                            Timeout in seconds
1157  *
1158  * MFI firmware can abort previously issued AEN comamnd (automatic event
1159  * notification). The megasas_issue_blocked_abort_cmd() issues such abort
1160  * cmd and waits for return status.
1161  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
1162  */
1163 static int
1164 megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
1165                                 struct megasas_cmd *cmd_to_abort, int timeout)
1166 {
1167         struct megasas_cmd *cmd;
1168         struct megasas_abort_frame *abort_fr;
1169         int ret = 0;
1170         u32 opcode;
1171
1172         cmd = megasas_get_cmd(instance);
1173
1174         if (!cmd)
1175                 return -1;
1176
1177         abort_fr = &cmd->frame->abort;
1178
1179         /*
1180          * Prepare and issue the abort frame
1181          */
1182         abort_fr->cmd = MFI_CMD_ABORT;
1183         abort_fr->cmd_status = MFI_STAT_INVALID_STATUS;
1184         abort_fr->flags = cpu_to_le16(0);
1185         abort_fr->abort_context = cpu_to_le32(cmd_to_abort->index);
1186         abort_fr->abort_mfi_phys_addr_lo =
1187                 cpu_to_le32(lower_32_bits(cmd_to_abort->frame_phys_addr));
1188         abort_fr->abort_mfi_phys_addr_hi =
1189                 cpu_to_le32(upper_32_bits(cmd_to_abort->frame_phys_addr));
1190
1191         cmd->sync_cmd = 1;
1192         cmd->cmd_status_drv = DCMD_INIT;
1193
1194         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1195                 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
1196                         __func__, __LINE__);
1197                 return DCMD_INIT;
1198         }
1199
1200         instance->instancet->issue_dcmd(instance, cmd);
1201
1202         if (timeout) {
1203                 ret = wait_event_timeout(instance->abort_cmd_wait_q,
1204                 cmd->cmd_status_drv != DCMD_INIT, timeout * HZ);
1205                 if (!ret) {
1206                         opcode = cmd_to_abort->frame->dcmd.opcode;
1207                         dev_err(&instance->pdev->dev,
1208                                 "Abort(to be aborted DCMD opcode: 0x%x) is timed out func:%s\n",
1209                                 opcode,  __func__);
1210                         return DCMD_TIMEOUT;
1211                 }
1212         } else
1213                 wait_event(instance->abort_cmd_wait_q,
1214                 cmd->cmd_status_drv != DCMD_INIT);
1215
1216         cmd->sync_cmd = 0;
1217
1218         megasas_return_cmd(instance, cmd);
1219         return cmd->cmd_status_drv;
1220 }
1221
1222 /**
1223  * megasas_make_sgl32 - Prepares 32-bit SGL
1224  * @instance:           Adapter soft state
1225  * @scp:                SCSI command from the mid-layer
1226  * @mfi_sgl:            SGL to be filled in
1227  *
1228  * If successful, this function returns the number of SG elements. Otherwise,
1229  * it returnes -1.
1230  */
1231 static int
1232 megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
1233                    union megasas_sgl *mfi_sgl)
1234 {
1235         int i;
1236         int sge_count;
1237         struct scatterlist *os_sgl;
1238
1239         sge_count = scsi_dma_map(scp);
1240         BUG_ON(sge_count < 0);
1241
1242         if (sge_count) {
1243                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1244                         mfi_sgl->sge32[i].length = cpu_to_le32(sg_dma_len(os_sgl));
1245                         mfi_sgl->sge32[i].phys_addr = cpu_to_le32(sg_dma_address(os_sgl));
1246                 }
1247         }
1248         return sge_count;
1249 }
1250
1251 /**
1252  * megasas_make_sgl64 - Prepares 64-bit SGL
1253  * @instance:           Adapter soft state
1254  * @scp:                SCSI command from the mid-layer
1255  * @mfi_sgl:            SGL to be filled in
1256  *
1257  * If successful, this function returns the number of SG elements. Otherwise,
1258  * it returnes -1.
1259  */
1260 static int
1261 megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
1262                    union megasas_sgl *mfi_sgl)
1263 {
1264         int i;
1265         int sge_count;
1266         struct scatterlist *os_sgl;
1267
1268         sge_count = scsi_dma_map(scp);
1269         BUG_ON(sge_count < 0);
1270
1271         if (sge_count) {
1272                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1273                         mfi_sgl->sge64[i].length = cpu_to_le32(sg_dma_len(os_sgl));
1274                         mfi_sgl->sge64[i].phys_addr = cpu_to_le64(sg_dma_address(os_sgl));
1275                 }
1276         }
1277         return sge_count;
1278 }
1279
1280 /**
1281  * megasas_make_sgl_skinny - Prepares IEEE SGL
1282  * @instance:           Adapter soft state
1283  * @scp:                SCSI command from the mid-layer
1284  * @mfi_sgl:            SGL to be filled in
1285  *
1286  * If successful, this function returns the number of SG elements. Otherwise,
1287  * it returnes -1.
1288  */
1289 static int
1290 megasas_make_sgl_skinny(struct megasas_instance *instance,
1291                 struct scsi_cmnd *scp, union megasas_sgl *mfi_sgl)
1292 {
1293         int i;
1294         int sge_count;
1295         struct scatterlist *os_sgl;
1296
1297         sge_count = scsi_dma_map(scp);
1298
1299         if (sge_count) {
1300                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1301                         mfi_sgl->sge_skinny[i].length =
1302                                 cpu_to_le32(sg_dma_len(os_sgl));
1303                         mfi_sgl->sge_skinny[i].phys_addr =
1304                                 cpu_to_le64(sg_dma_address(os_sgl));
1305                         mfi_sgl->sge_skinny[i].flag = cpu_to_le32(0);
1306                 }
1307         }
1308         return sge_count;
1309 }
1310
1311  /**
1312  * megasas_get_frame_count - Computes the number of frames
1313  * @frame_type          : type of frame- io or pthru frame
1314  * @sge_count           : number of sg elements
1315  *
1316  * Returns the number of frames required for numnber of sge's (sge_count)
1317  */
1318
1319 static u32 megasas_get_frame_count(struct megasas_instance *instance,
1320                         u8 sge_count, u8 frame_type)
1321 {
1322         int num_cnt;
1323         int sge_bytes;
1324         u32 sge_sz;
1325         u32 frame_count = 0;
1326
1327         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
1328             sizeof(struct megasas_sge32);
1329
1330         if (instance->flag_ieee) {
1331                 sge_sz = sizeof(struct megasas_sge_skinny);
1332         }
1333
1334         /*
1335          * Main frame can contain 2 SGEs for 64-bit SGLs and
1336          * 3 SGEs for 32-bit SGLs for ldio &
1337          * 1 SGEs for 64-bit SGLs and
1338          * 2 SGEs for 32-bit SGLs for pthru frame
1339          */
1340         if (unlikely(frame_type == PTHRU_FRAME)) {
1341                 if (instance->flag_ieee == 1) {
1342                         num_cnt = sge_count - 1;
1343                 } else if (IS_DMA64)
1344                         num_cnt = sge_count - 1;
1345                 else
1346                         num_cnt = sge_count - 2;
1347         } else {
1348                 if (instance->flag_ieee == 1) {
1349                         num_cnt = sge_count - 1;
1350                 } else if (IS_DMA64)
1351                         num_cnt = sge_count - 2;
1352                 else
1353                         num_cnt = sge_count - 3;
1354         }
1355
1356         if (num_cnt > 0) {
1357                 sge_bytes = sge_sz * num_cnt;
1358
1359                 frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
1360                     ((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) ;
1361         }
1362         /* Main frame */
1363         frame_count += 1;
1364
1365         if (frame_count > 7)
1366                 frame_count = 8;
1367         return frame_count;
1368 }
1369
1370 /**
1371  * megasas_build_dcdb - Prepares a direct cdb (DCDB) command
1372  * @instance:           Adapter soft state
1373  * @scp:                SCSI command
1374  * @cmd:                Command to be prepared in
1375  *
1376  * This function prepares CDB commands. These are typcially pass-through
1377  * commands to the devices.
1378  */
1379 static int
1380 megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
1381                    struct megasas_cmd *cmd)
1382 {
1383         u32 is_logical;
1384         u32 device_id;
1385         u16 flags = 0;
1386         struct megasas_pthru_frame *pthru;
1387
1388         is_logical = MEGASAS_IS_LOGICAL(scp->device);
1389         device_id = MEGASAS_DEV_INDEX(scp);
1390         pthru = (struct megasas_pthru_frame *)cmd->frame;
1391
1392         if (scp->sc_data_direction == DMA_TO_DEVICE)
1393                 flags = MFI_FRAME_DIR_WRITE;
1394         else if (scp->sc_data_direction == DMA_FROM_DEVICE)
1395                 flags = MFI_FRAME_DIR_READ;
1396         else if (scp->sc_data_direction == DMA_NONE)
1397                 flags = MFI_FRAME_DIR_NONE;
1398
1399         if (instance->flag_ieee == 1) {
1400                 flags |= MFI_FRAME_IEEE;
1401         }
1402
1403         /*
1404          * Prepare the DCDB frame
1405          */
1406         pthru->cmd = (is_logical) ? MFI_CMD_LD_SCSI_IO : MFI_CMD_PD_SCSI_IO;
1407         pthru->cmd_status = 0x0;
1408         pthru->scsi_status = 0x0;
1409         pthru->target_id = device_id;
1410         pthru->lun = scp->device->lun;
1411         pthru->cdb_len = scp->cmd_len;
1412         pthru->timeout = 0;
1413         pthru->pad_0 = 0;
1414         pthru->flags = cpu_to_le16(flags);
1415         pthru->data_xfer_len = cpu_to_le32(scsi_bufflen(scp));
1416
1417         memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
1418
1419         /*
1420          * If the command is for the tape device, set the
1421          * pthru timeout to the os layer timeout value.
1422          */
1423         if (scp->device->type == TYPE_TAPE) {
1424                 if ((scp->request->timeout / HZ) > 0xFFFF)
1425                         pthru->timeout = cpu_to_le16(0xFFFF);
1426                 else
1427                         pthru->timeout = cpu_to_le16(scp->request->timeout / HZ);
1428         }
1429
1430         /*
1431          * Construct SGL
1432          */
1433         if (instance->flag_ieee == 1) {
1434                 pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1435                 pthru->sge_count = megasas_make_sgl_skinny(instance, scp,
1436                                                       &pthru->sgl);
1437         } else if (IS_DMA64) {
1438                 pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1439                 pthru->sge_count = megasas_make_sgl64(instance, scp,
1440                                                       &pthru->sgl);
1441         } else
1442                 pthru->sge_count = megasas_make_sgl32(instance, scp,
1443                                                       &pthru->sgl);
1444
1445         if (pthru->sge_count > instance->max_num_sge) {
1446                 dev_err(&instance->pdev->dev, "DCDB too many SGE NUM=%x\n",
1447                         pthru->sge_count);
1448                 return 0;
1449         }
1450
1451         /*
1452          * Sense info specific
1453          */
1454         pthru->sense_len = SCSI_SENSE_BUFFERSIZE;
1455         pthru->sense_buf_phys_addr_hi =
1456                 cpu_to_le32(upper_32_bits(cmd->sense_phys_addr));
1457         pthru->sense_buf_phys_addr_lo =
1458                 cpu_to_le32(lower_32_bits(cmd->sense_phys_addr));
1459
1460         /*
1461          * Compute the total number of frames this command consumes. FW uses
1462          * this number to pull sufficient number of frames from host memory.
1463          */
1464         cmd->frame_count = megasas_get_frame_count(instance, pthru->sge_count,
1465                                                         PTHRU_FRAME);
1466
1467         return cmd->frame_count;
1468 }
1469
1470 /**
1471  * megasas_build_ldio - Prepares IOs to logical devices
1472  * @instance:           Adapter soft state
1473  * @scp:                SCSI command
1474  * @cmd:                Command to be prepared
1475  *
1476  * Frames (and accompanying SGLs) for regular SCSI IOs use this function.
1477  */
1478 static int
1479 megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
1480                    struct megasas_cmd *cmd)
1481 {
1482         u32 device_id;
1483         u8 sc = scp->cmnd[0];
1484         u16 flags = 0;
1485         struct megasas_io_frame *ldio;
1486
1487         device_id = MEGASAS_DEV_INDEX(scp);
1488         ldio = (struct megasas_io_frame *)cmd->frame;
1489
1490         if (scp->sc_data_direction == DMA_TO_DEVICE)
1491                 flags = MFI_FRAME_DIR_WRITE;
1492         else if (scp->sc_data_direction == DMA_FROM_DEVICE)
1493                 flags = MFI_FRAME_DIR_READ;
1494
1495         if (instance->flag_ieee == 1) {
1496                 flags |= MFI_FRAME_IEEE;
1497         }
1498
1499         /*
1500          * Prepare the Logical IO frame: 2nd bit is zero for all read cmds
1501          */
1502         ldio->cmd = (sc & 0x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ;
1503         ldio->cmd_status = 0x0;
1504         ldio->scsi_status = 0x0;
1505         ldio->target_id = device_id;
1506         ldio->timeout = 0;
1507         ldio->reserved_0 = 0;
1508         ldio->pad_0 = 0;
1509         ldio->flags = cpu_to_le16(flags);
1510         ldio->start_lba_hi = 0;
1511         ldio->access_byte = (scp->cmd_len != 6) ? scp->cmnd[1] : 0;
1512
1513         /*
1514          * 6-byte READ(0x08) or WRITE(0x0A) cdb
1515          */
1516         if (scp->cmd_len == 6) {
1517                 ldio->lba_count = cpu_to_le32((u32) scp->cmnd[4]);
1518                 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[1] << 16) |
1519                                                  ((u32) scp->cmnd[2] << 8) |
1520                                                  (u32) scp->cmnd[3]);
1521
1522                 ldio->start_lba_lo &= cpu_to_le32(0x1FFFFF);
1523         }
1524
1525         /*
1526          * 10-byte READ(0x28) or WRITE(0x2A) cdb
1527          */
1528         else if (scp->cmd_len == 10) {
1529                 ldio->lba_count = cpu_to_le32((u32) scp->cmnd[8] |
1530                                               ((u32) scp->cmnd[7] << 8));
1531                 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1532                                                  ((u32) scp->cmnd[3] << 16) |
1533                                                  ((u32) scp->cmnd[4] << 8) |
1534                                                  (u32) scp->cmnd[5]);
1535         }
1536
1537         /*
1538          * 12-byte READ(0xA8) or WRITE(0xAA) cdb
1539          */
1540         else if (scp->cmd_len == 12) {
1541                 ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[6] << 24) |
1542                                               ((u32) scp->cmnd[7] << 16) |
1543                                               ((u32) scp->cmnd[8] << 8) |
1544                                               (u32) scp->cmnd[9]);
1545
1546                 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1547                                                  ((u32) scp->cmnd[3] << 16) |
1548                                                  ((u32) scp->cmnd[4] << 8) |
1549                                                  (u32) scp->cmnd[5]);
1550         }
1551
1552         /*
1553          * 16-byte READ(0x88) or WRITE(0x8A) cdb
1554          */
1555         else if (scp->cmd_len == 16) {
1556                 ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[10] << 24) |
1557                                               ((u32) scp->cmnd[11] << 16) |
1558                                               ((u32) scp->cmnd[12] << 8) |
1559                                               (u32) scp->cmnd[13]);
1560
1561                 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[6] << 24) |
1562                                                  ((u32) scp->cmnd[7] << 16) |
1563                                                  ((u32) scp->cmnd[8] << 8) |
1564                                                  (u32) scp->cmnd[9]);
1565
1566                 ldio->start_lba_hi = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1567                                                  ((u32) scp->cmnd[3] << 16) |
1568                                                  ((u32) scp->cmnd[4] << 8) |
1569                                                  (u32) scp->cmnd[5]);
1570
1571         }
1572
1573         /*
1574          * Construct SGL
1575          */
1576         if (instance->flag_ieee) {
1577                 ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1578                 ldio->sge_count = megasas_make_sgl_skinny(instance, scp,
1579                                               &ldio->sgl);
1580         } else if (IS_DMA64) {
1581                 ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1582                 ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl);
1583         } else
1584                 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
1585
1586         if (ldio->sge_count > instance->max_num_sge) {
1587                 dev_err(&instance->pdev->dev, "build_ld_io: sge_count = %x\n",
1588                         ldio->sge_count);
1589                 return 0;
1590         }
1591
1592         /*
1593          * Sense info specific
1594          */
1595         ldio->sense_len = SCSI_SENSE_BUFFERSIZE;
1596         ldio->sense_buf_phys_addr_hi = 0;
1597         ldio->sense_buf_phys_addr_lo = cpu_to_le32(cmd->sense_phys_addr);
1598
1599         /*
1600          * Compute the total number of frames this command consumes. FW uses
1601          * this number to pull sufficient number of frames from host memory.
1602          */
1603         cmd->frame_count = megasas_get_frame_count(instance,
1604                         ldio->sge_count, IO_FRAME);
1605
1606         return cmd->frame_count;
1607 }
1608
1609 /**
1610  * megasas_cmd_type -           Checks if the cmd is for logical drive/sysPD
1611  *                              and whether it's RW or non RW
1612  * @scmd:                       SCSI command
1613  *
1614  */
1615 inline int megasas_cmd_type(struct scsi_cmnd *cmd)
1616 {
1617         int ret;
1618
1619         switch (cmd->cmnd[0]) {
1620         case READ_10:
1621         case WRITE_10:
1622         case READ_12:
1623         case WRITE_12:
1624         case READ_6:
1625         case WRITE_6:
1626         case READ_16:
1627         case WRITE_16:
1628                 ret = (MEGASAS_IS_LOGICAL(cmd->device)) ?
1629                         READ_WRITE_LDIO : READ_WRITE_SYSPDIO;
1630                 break;
1631         default:
1632                 ret = (MEGASAS_IS_LOGICAL(cmd->device)) ?
1633                         NON_READ_WRITE_LDIO : NON_READ_WRITE_SYSPDIO;
1634         }
1635         return ret;
1636 }
1637
1638  /**
1639  * megasas_dump_pending_frames -        Dumps the frame address of all pending cmds
1640  *                                      in FW
1641  * @instance:                           Adapter soft state
1642  */
1643 static inline void
1644 megasas_dump_pending_frames(struct megasas_instance *instance)
1645 {
1646         struct megasas_cmd *cmd;
1647         int i,n;
1648         union megasas_sgl *mfi_sgl;
1649         struct megasas_io_frame *ldio;
1650         struct megasas_pthru_frame *pthru;
1651         u32 sgcount;
1652         u16 max_cmd = instance->max_fw_cmds;
1653
1654         dev_err(&instance->pdev->dev, "[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no);
1655         dev_err(&instance->pdev->dev, "[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding));
1656         if (IS_DMA64)
1657                 dev_err(&instance->pdev->dev, "[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no);
1658         else
1659                 dev_err(&instance->pdev->dev, "[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no);
1660
1661         dev_err(&instance->pdev->dev, "[%d]: Pending OS cmds in FW : \n",instance->host->host_no);
1662         for (i = 0; i < max_cmd; i++) {
1663                 cmd = instance->cmd_list[i];
1664                 if (!cmd->scmd)
1665                         continue;
1666                 dev_err(&instance->pdev->dev, "[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
1667                 if (megasas_cmd_type(cmd->scmd) == READ_WRITE_LDIO) {
1668                         ldio = (struct megasas_io_frame *)cmd->frame;
1669                         mfi_sgl = &ldio->sgl;
1670                         sgcount = ldio->sge_count;
1671                         dev_err(&instance->pdev->dev, "[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x,"
1672                         " lba lo : 0x%x, lba_hi : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1673                         instance->host->host_no, cmd->frame_count, ldio->cmd, ldio->target_id,
1674                         le32_to_cpu(ldio->start_lba_lo), le32_to_cpu(ldio->start_lba_hi),
1675                         le32_to_cpu(ldio->sense_buf_phys_addr_lo), sgcount);
1676                 } else {
1677                         pthru = (struct megasas_pthru_frame *) cmd->frame;
1678                         mfi_sgl = &pthru->sgl;
1679                         sgcount = pthru->sge_count;
1680                         dev_err(&instance->pdev->dev, "[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, "
1681                         "lun : 0x%x, cdb_len : 0x%x, data xfer len : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1682                         instance->host->host_no, cmd->frame_count, pthru->cmd, pthru->target_id,
1683                         pthru->lun, pthru->cdb_len, le32_to_cpu(pthru->data_xfer_len),
1684                         le32_to_cpu(pthru->sense_buf_phys_addr_lo), sgcount);
1685                 }
1686                 if (megasas_dbg_lvl & MEGASAS_DBG_LVL) {
1687                         for (n = 0; n < sgcount; n++) {
1688                                 if (IS_DMA64)
1689                                         dev_err(&instance->pdev->dev, "sgl len : 0x%x, sgl addr : 0x%llx\n",
1690                                                 le32_to_cpu(mfi_sgl->sge64[n].length),
1691                                                 le64_to_cpu(mfi_sgl->sge64[n].phys_addr));
1692                                 else
1693                                         dev_err(&instance->pdev->dev, "sgl len : 0x%x, sgl addr : 0x%x\n",
1694                                                 le32_to_cpu(mfi_sgl->sge32[n].length),
1695                                                 le32_to_cpu(mfi_sgl->sge32[n].phys_addr));
1696                         }
1697                 }
1698         } /*for max_cmd*/
1699         dev_err(&instance->pdev->dev, "[%d]: Pending Internal cmds in FW : \n",instance->host->host_no);
1700         for (i = 0; i < max_cmd; i++) {
1701
1702                 cmd = instance->cmd_list[i];
1703
1704                 if (cmd->sync_cmd == 1)
1705                         dev_err(&instance->pdev->dev, "0x%08lx : ", (unsigned long)cmd->frame_phys_addr);
1706         }
1707         dev_err(&instance->pdev->dev, "[%d]: Dumping Done\n\n",instance->host->host_no);
1708 }
1709
1710 u32
1711 megasas_build_and_issue_cmd(struct megasas_instance *instance,
1712                             struct scsi_cmnd *scmd)
1713 {
1714         struct megasas_cmd *cmd;
1715         u32 frame_count;
1716
1717         cmd = megasas_get_cmd(instance);
1718         if (!cmd)
1719                 return SCSI_MLQUEUE_HOST_BUSY;
1720
1721         /*
1722          * Logical drive command
1723          */
1724         if (megasas_cmd_type(scmd) == READ_WRITE_LDIO)
1725                 frame_count = megasas_build_ldio(instance, scmd, cmd);
1726         else
1727                 frame_count = megasas_build_dcdb(instance, scmd, cmd);
1728
1729         if (!frame_count)
1730                 goto out_return_cmd;
1731
1732         cmd->scmd = scmd;
1733         scmd->SCp.ptr = (char *)cmd;
1734
1735         /*
1736          * Issue the command to the FW
1737          */
1738         atomic_inc(&instance->fw_outstanding);
1739
1740         instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
1741                                 cmd->frame_count-1, instance->reg_set);
1742
1743         return 0;
1744 out_return_cmd:
1745         megasas_return_cmd(instance, cmd);
1746         return SCSI_MLQUEUE_HOST_BUSY;
1747 }
1748
1749
1750 /**
1751  * megasas_queue_command -      Queue entry point
1752  * @scmd:                       SCSI command to be queued
1753  * @done:                       Callback entry point
1754  */
1755 static int
1756 megasas_queue_command(struct Scsi_Host *shost, struct scsi_cmnd *scmd)
1757 {
1758         struct megasas_instance *instance;
1759         struct MR_PRIV_DEVICE *mr_device_priv_data;
1760
1761         instance = (struct megasas_instance *)
1762             scmd->device->host->hostdata;
1763
1764         if (instance->unload == 1) {
1765                 scmd->result = DID_NO_CONNECT << 16;
1766                 scmd->scsi_done(scmd);
1767                 return 0;
1768         }
1769
1770         if (instance->issuepend_done == 0)
1771                 return SCSI_MLQUEUE_HOST_BUSY;
1772
1773
1774         /* Check for an mpio path and adjust behavior */
1775         if (atomic_read(&instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {
1776                 if (megasas_check_mpio_paths(instance, scmd) ==
1777                     (DID_REQUEUE << 16)) {
1778                         return SCSI_MLQUEUE_HOST_BUSY;
1779                 } else {
1780                         scmd->result = DID_NO_CONNECT << 16;
1781                         scmd->scsi_done(scmd);
1782                         return 0;
1783                 }
1784         }
1785
1786         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
1787                 scmd->result = DID_NO_CONNECT << 16;
1788                 scmd->scsi_done(scmd);
1789                 return 0;
1790         }
1791
1792         mr_device_priv_data = scmd->device->hostdata;
1793         if (!mr_device_priv_data) {
1794                 scmd->result = DID_NO_CONNECT << 16;
1795                 scmd->scsi_done(scmd);
1796                 return 0;
1797         }
1798
1799         if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL)
1800                 return SCSI_MLQUEUE_HOST_BUSY;
1801
1802         if (mr_device_priv_data->tm_busy)
1803                 return SCSI_MLQUEUE_DEVICE_BUSY;
1804
1805
1806         scmd->result = 0;
1807
1808         if (MEGASAS_IS_LOGICAL(scmd->device) &&
1809             (scmd->device->id >= instance->fw_supported_vd_count ||
1810                 scmd->device->lun)) {
1811                 scmd->result = DID_BAD_TARGET << 16;
1812                 goto out_done;
1813         }
1814
1815         if ((scmd->cmnd[0] == SYNCHRONIZE_CACHE) &&
1816             MEGASAS_IS_LOGICAL(scmd->device) &&
1817             (!instance->fw_sync_cache_support)) {
1818                 scmd->result = DID_OK << 16;
1819                 goto out_done;
1820         }
1821
1822         return instance->instancet->build_and_issue_cmd(instance, scmd);
1823
1824  out_done:
1825         scmd->scsi_done(scmd);
1826         return 0;
1827 }
1828
1829 static struct megasas_instance *megasas_lookup_instance(u16 host_no)
1830 {
1831         int i;
1832
1833         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
1834
1835                 if ((megasas_mgmt_info.instance[i]) &&
1836                     (megasas_mgmt_info.instance[i]->host->host_no == host_no))
1837                         return megasas_mgmt_info.instance[i];
1838         }
1839
1840         return NULL;
1841 }
1842
1843 /*
1844 * megasas_set_dynamic_target_properties -
1845 * Device property set by driver may not be static and it is required to be
1846 * updated after OCR
1847 *
1848 * set tm_capable.
1849 * set dma alignment (only for eedp protection enable vd).
1850 *
1851 * @sdev: OS provided scsi device
1852 *
1853 * Returns void
1854 */
1855 void megasas_set_dynamic_target_properties(struct scsi_device *sdev,
1856                                            bool is_target_prop)
1857 {
1858         u16 pd_index = 0, ld;
1859         u32 device_id;
1860         struct megasas_instance *instance;
1861         struct fusion_context *fusion;
1862         struct MR_PRIV_DEVICE *mr_device_priv_data;
1863         struct MR_PD_CFG_SEQ_NUM_SYNC *pd_sync;
1864         struct MR_LD_RAID *raid;
1865         struct MR_DRV_RAID_MAP_ALL *local_map_ptr;
1866
1867         instance = megasas_lookup_instance(sdev->host->host_no);
1868         fusion = instance->ctrl_context;
1869         mr_device_priv_data = sdev->hostdata;
1870
1871         if (!fusion || !mr_device_priv_data)
1872                 return;
1873
1874         if (MEGASAS_IS_LOGICAL(sdev)) {
1875                 device_id = ((sdev->channel % 2) * MEGASAS_MAX_DEV_PER_CHANNEL)
1876                                         + sdev->id;
1877                 local_map_ptr = fusion->ld_drv_map[(instance->map_id & 1)];
1878                 ld = MR_TargetIdToLdGet(device_id, local_map_ptr);
1879                 if (ld >= instance->fw_supported_vd_count)
1880                         return;
1881                 raid = MR_LdRaidGet(ld, local_map_ptr);
1882
1883                 if (raid->capability.ldPiMode == MR_PROT_INFO_TYPE_CONTROLLER)
1884                 blk_queue_update_dma_alignment(sdev->request_queue, 0x7);
1885
1886                 mr_device_priv_data->is_tm_capable =
1887                         raid->capability.tmCapable;
1888
1889                 if (!raid->flags.isEPD)
1890                         sdev->no_write_same = 1;
1891
1892         } else if (instance->use_seqnum_jbod_fp) {
1893                 pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
1894                         sdev->id;
1895                 pd_sync = (void *)fusion->pd_seq_sync
1896                                 [(instance->pd_seq_map_id - 1) & 1];
1897                 mr_device_priv_data->is_tm_capable =
1898                         pd_sync->seq[pd_index].capability.tmCapable;
1899         }
1900
1901         if (is_target_prop && instance->tgt_prop->reset_tmo) {
1902                 /*
1903                  * If FW provides a target reset timeout value, driver will use
1904                  * it. If not set, fallback to default values.
1905                  */
1906                 mr_device_priv_data->target_reset_tmo =
1907                         min_t(u8, instance->max_reset_tmo,
1908                               instance->tgt_prop->reset_tmo);
1909                 mr_device_priv_data->task_abort_tmo = instance->task_abort_tmo;
1910         } else {
1911                 mr_device_priv_data->target_reset_tmo =
1912                                                 MEGASAS_DEFAULT_TM_TIMEOUT;
1913                 mr_device_priv_data->task_abort_tmo =
1914                                                 MEGASAS_DEFAULT_TM_TIMEOUT;
1915         }
1916 }
1917
1918 /*
1919  * megasas_set_nvme_device_properties -
1920  * set nomerges=2
1921  * set virtual page boundary = 4K (current mr_nvme_pg_size is 4K).
1922  * set maximum io transfer = MDTS of NVME device provided by MR firmware.
1923  *
1924  * MR firmware provides value in KB. Caller of this function converts
1925  * kb into bytes.
1926  *
1927  * e.a MDTS=5 means 2^5 * nvme page size. (In case of 4K page size,
1928  * MR firmware provides value 128 as (32 * 4K) = 128K.
1929  *
1930  * @sdev:                               scsi device
1931  * @max_io_size:                                maximum io transfer size
1932  *
1933  */
1934 static inline void
1935 megasas_set_nvme_device_properties(struct scsi_device *sdev, u32 max_io_size)
1936 {
1937         struct megasas_instance *instance;
1938         u32 mr_nvme_pg_size;
1939
1940         instance = (struct megasas_instance *)sdev->host->hostdata;
1941         mr_nvme_pg_size = max_t(u32, instance->nvme_page_size,
1942                                 MR_DEFAULT_NVME_PAGE_SIZE);
1943
1944         blk_queue_max_hw_sectors(sdev->request_queue, (max_io_size / 512));
1945
1946         blk_queue_flag_set(QUEUE_FLAG_NOMERGES, sdev->request_queue);
1947         blk_queue_virt_boundary(sdev->request_queue, mr_nvme_pg_size - 1);
1948 }
1949
1950 /*
1951  * megasas_set_fw_assisted_qd -
1952  * set device queue depth to can_queue
1953  * set device queue depth to fw assisted qd
1954  *
1955  * @sdev:                               scsi device
1956  * @is_target_prop                      true, if fw provided target properties.
1957  */
1958 static void megasas_set_fw_assisted_qd(struct scsi_device *sdev,
1959                                                  bool is_target_prop)
1960 {
1961         u8 interface_type;
1962         u32 device_qd = MEGASAS_DEFAULT_CMD_PER_LUN;
1963         u32 tgt_device_qd;
1964         struct megasas_instance *instance;
1965         struct MR_PRIV_DEVICE *mr_device_priv_data;
1966
1967         instance = megasas_lookup_instance(sdev->host->host_no);
1968         mr_device_priv_data = sdev->hostdata;
1969         interface_type  = mr_device_priv_data->interface_type;
1970
1971         switch (interface_type) {
1972         case SAS_PD:
1973                 device_qd = MEGASAS_SAS_QD;
1974                 break;
1975         case SATA_PD:
1976                 device_qd = MEGASAS_SATA_QD;
1977                 break;
1978         case NVME_PD:
1979                 device_qd = MEGASAS_NVME_QD;
1980                 break;
1981         }
1982
1983         if (is_target_prop) {
1984                 tgt_device_qd = le32_to_cpu(instance->tgt_prop->device_qdepth);
1985                 if (tgt_device_qd &&
1986                     (tgt_device_qd <= instance->host->can_queue))
1987                         device_qd = tgt_device_qd;
1988         }
1989
1990         if (instance->enable_sdev_max_qd && interface_type != UNKNOWN_DRIVE)
1991                 device_qd = instance->host->can_queue;
1992
1993         scsi_change_queue_depth(sdev, device_qd);
1994 }
1995
1996 /*
1997  * megasas_set_static_target_properties -
1998  * Device property set by driver are static and it is not required to be
1999  * updated after OCR.
2000  *
2001  * set io timeout
2002  * set device queue depth
2003  * set nvme device properties. see - megasas_set_nvme_device_properties
2004  *
2005  * @sdev:                               scsi device
2006  * @is_target_prop                      true, if fw provided target properties.
2007  */
2008 static void megasas_set_static_target_properties(struct scsi_device *sdev,
2009                                                  bool is_target_prop)
2010 {
2011         u32 max_io_size_kb = MR_DEFAULT_NVME_MDTS_KB;
2012         struct megasas_instance *instance;
2013
2014         instance = megasas_lookup_instance(sdev->host->host_no);
2015
2016         /*
2017          * The RAID firmware may require extended timeouts.
2018          */
2019         blk_queue_rq_timeout(sdev->request_queue, scmd_timeout * HZ);
2020
2021         /* max_io_size_kb will be set to non zero for
2022          * nvme based vd and syspd.
2023          */
2024         if (is_target_prop)
2025                 max_io_size_kb = le32_to_cpu(instance->tgt_prop->max_io_size_kb);
2026
2027         if (instance->nvme_page_size && max_io_size_kb)
2028                 megasas_set_nvme_device_properties(sdev, (max_io_size_kb << 10));
2029
2030         megasas_set_fw_assisted_qd(sdev, is_target_prop);
2031 }
2032
2033
2034 static int megasas_slave_configure(struct scsi_device *sdev)
2035 {
2036         u16 pd_index = 0;
2037         struct megasas_instance *instance;
2038         int ret_target_prop = DCMD_FAILED;
2039         bool is_target_prop = false;
2040
2041         instance = megasas_lookup_instance(sdev->host->host_no);
2042         if (instance->pd_list_not_supported) {
2043                 if (!MEGASAS_IS_LOGICAL(sdev) && sdev->type == TYPE_DISK) {
2044                         pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
2045                                 sdev->id;
2046                         if (instance->pd_list[pd_index].driveState !=
2047                                 MR_PD_STATE_SYSTEM)
2048                                 return -ENXIO;
2049                 }
2050         }
2051
2052         mutex_lock(&instance->reset_mutex);
2053         /* Send DCMD to Firmware and cache the information */
2054         if ((instance->pd_info) && !MEGASAS_IS_LOGICAL(sdev))
2055                 megasas_get_pd_info(instance, sdev);
2056
2057         /* Some ventura firmware may not have instance->nvme_page_size set.
2058          * Do not send MR_DCMD_DRV_GET_TARGET_PROP
2059          */
2060         if ((instance->tgt_prop) && (instance->nvme_page_size))
2061                 ret_target_prop = megasas_get_target_prop(instance, sdev);
2062
2063         is_target_prop = (ret_target_prop == DCMD_SUCCESS) ? true : false;
2064         megasas_set_static_target_properties(sdev, is_target_prop);
2065
2066         /* This sdev property may change post OCR */
2067         megasas_set_dynamic_target_properties(sdev, is_target_prop);
2068
2069         mutex_unlock(&instance->reset_mutex);
2070
2071         return 0;
2072 }
2073
2074 static int megasas_slave_alloc(struct scsi_device *sdev)
2075 {
2076         u16 pd_index = 0;
2077         struct megasas_instance *instance ;
2078         struct MR_PRIV_DEVICE *mr_device_priv_data;
2079
2080         instance = megasas_lookup_instance(sdev->host->host_no);
2081         if (!MEGASAS_IS_LOGICAL(sdev)) {
2082                 /*
2083                  * Open the OS scan to the SYSTEM PD
2084                  */
2085                 pd_index =
2086                         (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
2087                         sdev->id;
2088                 if ((instance->pd_list_not_supported ||
2089                         instance->pd_list[pd_index].driveState ==
2090                         MR_PD_STATE_SYSTEM)) {
2091                         goto scan_target;
2092                 }
2093                 return -ENXIO;
2094         }
2095
2096 scan_target:
2097         mr_device_priv_data = kzalloc(sizeof(*mr_device_priv_data),
2098                                         GFP_KERNEL);
2099         if (!mr_device_priv_data)
2100                 return -ENOMEM;
2101         sdev->hostdata = mr_device_priv_data;
2102
2103         atomic_set(&mr_device_priv_data->r1_ldio_hint,
2104                    instance->r1_ldio_hint_default);
2105         return 0;
2106 }
2107
2108 static void megasas_slave_destroy(struct scsi_device *sdev)
2109 {
2110         kfree(sdev->hostdata);
2111         sdev->hostdata = NULL;
2112 }
2113
2114 /*
2115 * megasas_complete_outstanding_ioctls - Complete outstanding ioctls after a
2116 *                                       kill adapter
2117 * @instance:                            Adapter soft state
2118 *
2119 */
2120 static void megasas_complete_outstanding_ioctls(struct megasas_instance *instance)
2121 {
2122         int i;
2123         struct megasas_cmd *cmd_mfi;
2124         struct megasas_cmd_fusion *cmd_fusion;
2125         struct fusion_context *fusion = instance->ctrl_context;
2126
2127         /* Find all outstanding ioctls */
2128         if (fusion) {
2129                 for (i = 0; i < instance->max_fw_cmds; i++) {
2130                         cmd_fusion = fusion->cmd_list[i];
2131                         if (cmd_fusion->sync_cmd_idx != (u32)ULONG_MAX) {
2132                                 cmd_mfi = instance->cmd_list[cmd_fusion->sync_cmd_idx];
2133                                 if (cmd_mfi->sync_cmd &&
2134                                     (cmd_mfi->frame->hdr.cmd != MFI_CMD_ABORT)) {
2135                                         cmd_mfi->frame->hdr.cmd_status =
2136                                                         MFI_STAT_WRONG_STATE;
2137                                         megasas_complete_cmd(instance,
2138                                                              cmd_mfi, DID_OK);
2139                                 }
2140                         }
2141                 }
2142         } else {
2143                 for (i = 0; i < instance->max_fw_cmds; i++) {
2144                         cmd_mfi = instance->cmd_list[i];
2145                         if (cmd_mfi->sync_cmd && cmd_mfi->frame->hdr.cmd !=
2146                                 MFI_CMD_ABORT)
2147                                 megasas_complete_cmd(instance, cmd_mfi, DID_OK);
2148                 }
2149         }
2150 }
2151
2152
2153 void megaraid_sas_kill_hba(struct megasas_instance *instance)
2154 {
2155         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2156                 dev_warn(&instance->pdev->dev,
2157                          "Adapter already dead, skipping kill HBA\n");
2158                 return;
2159         }
2160
2161         /* Set critical error to block I/O & ioctls in case caller didn't */
2162         atomic_set(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
2163         /* Wait 1 second to ensure IO or ioctls in build have posted */
2164         msleep(1000);
2165         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2166                 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2167                 (instance->adapter_type != MFI_SERIES)) {
2168                 if (!instance->requestorId) {
2169                         writel(MFI_STOP_ADP, &instance->reg_set->doorbell);
2170                         /* Flush */
2171                         readl(&instance->reg_set->doorbell);
2172                 }
2173                 if (instance->requestorId && instance->peerIsPresent)
2174                         memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
2175         } else {
2176                 writel(MFI_STOP_ADP,
2177                         &instance->reg_set->inbound_doorbell);
2178         }
2179         /* Complete outstanding ioctls when adapter is killed */
2180         megasas_complete_outstanding_ioctls(instance);
2181 }
2182
2183  /**
2184   * megasas_check_and_restore_queue_depth - Check if queue depth needs to be
2185   *                                     restored to max value
2186   * @instance:                  Adapter soft state
2187   *
2188   */
2189 void
2190 megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
2191 {
2192         unsigned long flags;
2193
2194         if (instance->flag & MEGASAS_FW_BUSY
2195             && time_after(jiffies, instance->last_time + 5 * HZ)
2196             && atomic_read(&instance->fw_outstanding) <
2197             instance->throttlequeuedepth + 1) {
2198
2199                 spin_lock_irqsave(instance->host->host_lock, flags);
2200                 instance->flag &= ~MEGASAS_FW_BUSY;
2201
2202                 instance->host->can_queue = instance->cur_can_queue;
2203                 spin_unlock_irqrestore(instance->host->host_lock, flags);
2204         }
2205 }
2206
2207 /**
2208  * megasas_complete_cmd_dpc      -      Returns FW's controller structure
2209  * @instance_addr:                      Address of adapter soft state
2210  *
2211  * Tasklet to complete cmds
2212  */
2213 static void megasas_complete_cmd_dpc(unsigned long instance_addr)
2214 {
2215         u32 producer;
2216         u32 consumer;
2217         u32 context;
2218         struct megasas_cmd *cmd;
2219         struct megasas_instance *instance =
2220                                 (struct megasas_instance *)instance_addr;
2221         unsigned long flags;
2222
2223         /* If we have already declared adapter dead, donot complete cmds */
2224         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
2225                 return;
2226
2227         spin_lock_irqsave(&instance->completion_lock, flags);
2228
2229         producer = le32_to_cpu(*instance->producer);
2230         consumer = le32_to_cpu(*instance->consumer);
2231
2232         while (consumer != producer) {
2233                 context = le32_to_cpu(instance->reply_queue[consumer]);
2234                 if (context >= instance->max_fw_cmds) {
2235                         dev_err(&instance->pdev->dev, "Unexpected context value %x\n",
2236                                 context);
2237                         BUG();
2238                 }
2239
2240                 cmd = instance->cmd_list[context];
2241
2242                 megasas_complete_cmd(instance, cmd, DID_OK);
2243
2244                 consumer++;
2245                 if (consumer == (instance->max_fw_cmds + 1)) {
2246                         consumer = 0;
2247                 }
2248         }
2249
2250         *instance->consumer = cpu_to_le32(producer);
2251
2252         spin_unlock_irqrestore(&instance->completion_lock, flags);
2253
2254         /*
2255          * Check if we can restore can_queue
2256          */
2257         megasas_check_and_restore_queue_depth(instance);
2258 }
2259
2260 static void megasas_sriov_heartbeat_handler(struct timer_list *t);
2261
2262 /**
2263  * megasas_start_timer - Initializes sriov heartbeat timer object
2264  * @instance:           Adapter soft state
2265  *
2266  */
2267 void megasas_start_timer(struct megasas_instance *instance)
2268 {
2269         struct timer_list *timer = &instance->sriov_heartbeat_timer;
2270
2271         timer_setup(timer, megasas_sriov_heartbeat_handler, 0);
2272         timer->expires = jiffies + MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF;
2273         add_timer(timer);
2274 }
2275
2276 static void
2277 megasas_internal_reset_defer_cmds(struct megasas_instance *instance);
2278
2279 static void
2280 process_fw_state_change_wq(struct work_struct *work);
2281
2282 static void megasas_do_ocr(struct megasas_instance *instance)
2283 {
2284         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
2285         (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
2286         (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
2287                 *instance->consumer = cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
2288         }
2289         instance->instancet->disable_intr(instance);
2290         atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
2291         instance->issuepend_done = 0;
2292
2293         atomic_set(&instance->fw_outstanding, 0);
2294         megasas_internal_reset_defer_cmds(instance);
2295         process_fw_state_change_wq(&instance->work_init);
2296 }
2297
2298 static int megasas_get_ld_vf_affiliation_111(struct megasas_instance *instance,
2299                                             int initial)
2300 {
2301         struct megasas_cmd *cmd;
2302         struct megasas_dcmd_frame *dcmd;
2303         struct MR_LD_VF_AFFILIATION_111 *new_affiliation_111 = NULL;
2304         dma_addr_t new_affiliation_111_h;
2305         int ld, retval = 0;
2306         u8 thisVf;
2307
2308         cmd = megasas_get_cmd(instance);
2309
2310         if (!cmd) {
2311                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_vf_affiliation_111:"
2312                        "Failed to get cmd for scsi%d\n",
2313                         instance->host->host_no);
2314                 return -ENOMEM;
2315         }
2316
2317         dcmd = &cmd->frame->dcmd;
2318
2319         if (!instance->vf_affiliation_111) {
2320                 dev_warn(&instance->pdev->dev, "SR-IOV: Couldn't get LD/VF "
2321                        "affiliation for scsi%d\n", instance->host->host_no);
2322                 megasas_return_cmd(instance, cmd);
2323                 return -ENOMEM;
2324         }
2325
2326         if (initial)
2327                         memset(instance->vf_affiliation_111, 0,
2328                                sizeof(struct MR_LD_VF_AFFILIATION_111));
2329         else {
2330                 new_affiliation_111 =
2331                         dma_alloc_coherent(&instance->pdev->dev,
2332                                            sizeof(struct MR_LD_VF_AFFILIATION_111),
2333                                            &new_affiliation_111_h, GFP_KERNEL);
2334                 if (!new_affiliation_111) {
2335                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
2336                                "memory for new affiliation for scsi%d\n",
2337                                instance->host->host_no);
2338                         megasas_return_cmd(instance, cmd);
2339                         return -ENOMEM;
2340                 }
2341         }
2342
2343         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2344
2345         dcmd->cmd = MFI_CMD_DCMD;
2346         dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
2347         dcmd->sge_count = 1;
2348         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_BOTH);
2349         dcmd->timeout = 0;
2350         dcmd->pad_0 = 0;
2351         dcmd->data_xfer_len =
2352                 cpu_to_le32(sizeof(struct MR_LD_VF_AFFILIATION_111));
2353         dcmd->opcode = cpu_to_le32(MR_DCMD_LD_VF_MAP_GET_ALL_LDS_111);
2354
2355         if (initial)
2356                 dcmd->sgl.sge32[0].phys_addr =
2357                         cpu_to_le32(instance->vf_affiliation_111_h);
2358         else
2359                 dcmd->sgl.sge32[0].phys_addr =
2360                         cpu_to_le32(new_affiliation_111_h);
2361
2362         dcmd->sgl.sge32[0].length = cpu_to_le32(
2363                 sizeof(struct MR_LD_VF_AFFILIATION_111));
2364
2365         dev_warn(&instance->pdev->dev, "SR-IOV: Getting LD/VF affiliation for "
2366                "scsi%d\n", instance->host->host_no);
2367
2368         if (megasas_issue_blocked_cmd(instance, cmd, 0) != DCMD_SUCCESS) {
2369                 dev_warn(&instance->pdev->dev, "SR-IOV: LD/VF affiliation DCMD"
2370                        " failed with status 0x%x for scsi%d\n",
2371                        dcmd->cmd_status, instance->host->host_no);
2372                 retval = 1; /* Do a scan if we couldn't get affiliation */
2373                 goto out;
2374         }
2375
2376         if (!initial) {
2377                 thisVf = new_affiliation_111->thisVf;
2378                 for (ld = 0 ; ld < new_affiliation_111->vdCount; ld++)
2379                         if (instance->vf_affiliation_111->map[ld].policy[thisVf] !=
2380                             new_affiliation_111->map[ld].policy[thisVf]) {
2381                                 dev_warn(&instance->pdev->dev, "SR-IOV: "
2382                                        "Got new LD/VF affiliation for scsi%d\n",
2383                                        instance->host->host_no);
2384                                 memcpy(instance->vf_affiliation_111,
2385                                        new_affiliation_111,
2386                                        sizeof(struct MR_LD_VF_AFFILIATION_111));
2387                                 retval = 1;
2388                                 goto out;
2389                         }
2390         }
2391 out:
2392         if (new_affiliation_111) {
2393                 dma_free_coherent(&instance->pdev->dev,
2394                                     sizeof(struct MR_LD_VF_AFFILIATION_111),
2395                                     new_affiliation_111,
2396                                     new_affiliation_111_h);
2397         }
2398
2399         megasas_return_cmd(instance, cmd);
2400
2401         return retval;
2402 }
2403
2404 static int megasas_get_ld_vf_affiliation_12(struct megasas_instance *instance,
2405                                             int initial)
2406 {
2407         struct megasas_cmd *cmd;
2408         struct megasas_dcmd_frame *dcmd;
2409         struct MR_LD_VF_AFFILIATION *new_affiliation = NULL;
2410         struct MR_LD_VF_MAP *newmap = NULL, *savedmap = NULL;
2411         dma_addr_t new_affiliation_h;
2412         int i, j, retval = 0, found = 0, doscan = 0;
2413         u8 thisVf;
2414
2415         cmd = megasas_get_cmd(instance);
2416
2417         if (!cmd) {
2418                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_vf_affiliation12: "
2419                        "Failed to get cmd for scsi%d\n",
2420                        instance->host->host_no);
2421                 return -ENOMEM;
2422         }
2423
2424         dcmd = &cmd->frame->dcmd;
2425
2426         if (!instance->vf_affiliation) {
2427                 dev_warn(&instance->pdev->dev, "SR-IOV: Couldn't get LD/VF "
2428                        "affiliation for scsi%d\n", instance->host->host_no);
2429                 megasas_return_cmd(instance, cmd);
2430                 return -ENOMEM;
2431         }
2432
2433         if (initial)
2434                 memset(instance->vf_affiliation, 0, (MAX_LOGICAL_DRIVES + 1) *
2435                        sizeof(struct MR_LD_VF_AFFILIATION));
2436         else {
2437                 new_affiliation =
2438                         dma_alloc_coherent(&instance->pdev->dev,
2439                                            (MAX_LOGICAL_DRIVES + 1) * sizeof(struct MR_LD_VF_AFFILIATION),
2440                                            &new_affiliation_h, GFP_KERNEL);
2441                 if (!new_affiliation) {
2442                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
2443                                "memory for new affiliation for scsi%d\n",
2444                                instance->host->host_no);
2445                         megasas_return_cmd(instance, cmd);
2446                         return -ENOMEM;
2447                 }
2448         }
2449
2450         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2451
2452         dcmd->cmd = MFI_CMD_DCMD;
2453         dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
2454         dcmd->sge_count = 1;
2455         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_BOTH);
2456         dcmd->timeout = 0;
2457         dcmd->pad_0 = 0;
2458         dcmd->data_xfer_len = cpu_to_le32((MAX_LOGICAL_DRIVES + 1) *
2459                 sizeof(struct MR_LD_VF_AFFILIATION));
2460         dcmd->opcode = cpu_to_le32(MR_DCMD_LD_VF_MAP_GET_ALL_LDS);
2461
2462         if (initial)
2463                 dcmd->sgl.sge32[0].phys_addr =
2464                         cpu_to_le32(instance->vf_affiliation_h);
2465         else
2466                 dcmd->sgl.sge32[0].phys_addr =
2467                         cpu_to_le32(new_affiliation_h);
2468
2469         dcmd->sgl.sge32[0].length = cpu_to_le32((MAX_LOGICAL_DRIVES + 1) *
2470                 sizeof(struct MR_LD_VF_AFFILIATION));
2471
2472         dev_warn(&instance->pdev->dev, "SR-IOV: Getting LD/VF affiliation for "
2473                "scsi%d\n", instance->host->host_no);
2474
2475
2476         if (megasas_issue_blocked_cmd(instance, cmd, 0) != DCMD_SUCCESS) {
2477                 dev_warn(&instance->pdev->dev, "SR-IOV: LD/VF affiliation DCMD"
2478                        " failed with status 0x%x for scsi%d\n",
2479                        dcmd->cmd_status, instance->host->host_no);
2480                 retval = 1; /* Do a scan if we couldn't get affiliation */
2481                 goto out;
2482         }
2483
2484         if (!initial) {
2485                 if (!new_affiliation->ldCount) {
2486                         dev_warn(&instance->pdev->dev, "SR-IOV: Got new LD/VF "
2487                                "affiliation for passive path for scsi%d\n",
2488                                instance->host->host_no);
2489                         retval = 1;
2490                         goto out;
2491                 }
2492                 newmap = new_affiliation->map;
2493                 savedmap = instance->vf_affiliation->map;
2494                 thisVf = new_affiliation->thisVf;
2495                 for (i = 0 ; i < new_affiliation->ldCount; i++) {
2496                         found = 0;
2497                         for (j = 0; j < instance->vf_affiliation->ldCount;
2498                              j++) {
2499                                 if (newmap->ref.targetId ==
2500                                     savedmap->ref.targetId) {
2501                                         found = 1;
2502                                         if (newmap->policy[thisVf] !=
2503                                             savedmap->policy[thisVf]) {
2504                                                 doscan = 1;
2505                                                 goto out;
2506                                         }
2507                                 }
2508                                 savedmap = (struct MR_LD_VF_MAP *)
2509                                         ((unsigned char *)savedmap +
2510                                          savedmap->size);
2511                         }
2512                         if (!found && newmap->policy[thisVf] !=
2513                             MR_LD_ACCESS_HIDDEN) {
2514                                 doscan = 1;
2515                                 goto out;
2516                         }
2517                         newmap = (struct MR_LD_VF_MAP *)
2518                                 ((unsigned char *)newmap + newmap->size);
2519                 }
2520
2521                 newmap = new_affiliation->map;
2522                 savedmap = instance->vf_affiliation->map;
2523
2524                 for (i = 0 ; i < instance->vf_affiliation->ldCount; i++) {
2525                         found = 0;
2526                         for (j = 0 ; j < new_affiliation->ldCount; j++) {
2527                                 if (savedmap->ref.targetId ==
2528                                     newmap->ref.targetId) {
2529                                         found = 1;
2530                                         if (savedmap->policy[thisVf] !=
2531                                             newmap->policy[thisVf]) {
2532                                                 doscan = 1;
2533                                                 goto out;
2534                                         }
2535                                 }
2536                                 newmap = (struct MR_LD_VF_MAP *)
2537                                         ((unsigned char *)newmap +
2538                                          newmap->size);
2539                         }
2540                         if (!found && savedmap->policy[thisVf] !=
2541                             MR_LD_ACCESS_HIDDEN) {
2542                                 doscan = 1;
2543                                 goto out;
2544                         }
2545                         savedmap = (struct MR_LD_VF_MAP *)
2546                                 ((unsigned char *)savedmap +
2547                                  savedmap->size);
2548                 }
2549         }
2550 out:
2551         if (doscan) {
2552                 dev_warn(&instance->pdev->dev, "SR-IOV: Got new LD/VF "
2553                        "affiliation for scsi%d\n", instance->host->host_no);
2554                 memcpy(instance->vf_affiliation, new_affiliation,
2555                        new_affiliation->size);
2556                 retval = 1;
2557         }
2558
2559         if (new_affiliation)
2560                 dma_free_coherent(&instance->pdev->dev,
2561                                     (MAX_LOGICAL_DRIVES + 1) *
2562                                     sizeof(struct MR_LD_VF_AFFILIATION),
2563                                     new_affiliation, new_affiliation_h);
2564         megasas_return_cmd(instance, cmd);
2565
2566         return retval;
2567 }
2568
2569 /* This function will get the current SR-IOV LD/VF affiliation */
2570 static int megasas_get_ld_vf_affiliation(struct megasas_instance *instance,
2571         int initial)
2572 {
2573         int retval;
2574
2575         if (instance->PlasmaFW111)
2576                 retval = megasas_get_ld_vf_affiliation_111(instance, initial);
2577         else
2578                 retval = megasas_get_ld_vf_affiliation_12(instance, initial);
2579         return retval;
2580 }
2581
2582 /* This function will tell FW to start the SR-IOV heartbeat */
2583 int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
2584                                          int initial)
2585 {
2586         struct megasas_cmd *cmd;
2587         struct megasas_dcmd_frame *dcmd;
2588         int retval = 0;
2589
2590         cmd = megasas_get_cmd(instance);
2591
2592         if (!cmd) {
2593                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_sriov_start_heartbeat: "
2594                        "Failed to get cmd for scsi%d\n",
2595                        instance->host->host_no);
2596                 return -ENOMEM;
2597         }
2598
2599         dcmd = &cmd->frame->dcmd;
2600
2601         if (initial) {
2602                 instance->hb_host_mem =
2603                         dma_alloc_coherent(&instance->pdev->dev,
2604                                            sizeof(struct MR_CTRL_HB_HOST_MEM),
2605                                            &instance->hb_host_mem_h,
2606                                            GFP_KERNEL);
2607                 if (!instance->hb_host_mem) {
2608                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate"
2609                                " memory for heartbeat host memory for scsi%d\n",
2610                                instance->host->host_no);
2611                         retval = -ENOMEM;
2612                         goto out;
2613                 }
2614         }
2615
2616         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2617
2618         dcmd->mbox.s[0] = cpu_to_le16(sizeof(struct MR_CTRL_HB_HOST_MEM));
2619         dcmd->cmd = MFI_CMD_DCMD;
2620         dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
2621         dcmd->sge_count = 1;
2622         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_BOTH);
2623         dcmd->timeout = 0;
2624         dcmd->pad_0 = 0;
2625         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_CTRL_HB_HOST_MEM));
2626         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_SHARED_HOST_MEM_ALLOC);
2627
2628         megasas_set_dma_settings(instance, dcmd, instance->hb_host_mem_h,
2629                                  sizeof(struct MR_CTRL_HB_HOST_MEM));
2630
2631         dev_warn(&instance->pdev->dev, "SR-IOV: Starting heartbeat for scsi%d\n",
2632                instance->host->host_no);
2633
2634         if ((instance->adapter_type != MFI_SERIES) &&
2635             !instance->mask_interrupts)
2636                 retval = megasas_issue_blocked_cmd(instance, cmd,
2637                         MEGASAS_ROUTINE_WAIT_TIME_VF);
2638         else
2639                 retval = megasas_issue_polled(instance, cmd);
2640
2641         if (retval) {
2642                 dev_warn(&instance->pdev->dev, "SR-IOV: MR_DCMD_CTRL_SHARED_HOST"
2643                         "_MEM_ALLOC DCMD %s for scsi%d\n",
2644                         (dcmd->cmd_status == MFI_STAT_INVALID_STATUS) ?
2645                         "timed out" : "failed", instance->host->host_no);
2646                 retval = 1;
2647         }
2648
2649 out:
2650         megasas_return_cmd(instance, cmd);
2651
2652         return retval;
2653 }
2654
2655 /* Handler for SR-IOV heartbeat */
2656 static void megasas_sriov_heartbeat_handler(struct timer_list *t)
2657 {
2658         struct megasas_instance *instance =
2659                 from_timer(instance, t, sriov_heartbeat_timer);
2660
2661         if (instance->hb_host_mem->HB.fwCounter !=
2662             instance->hb_host_mem->HB.driverCounter) {
2663                 instance->hb_host_mem->HB.driverCounter =
2664                         instance->hb_host_mem->HB.fwCounter;
2665                 mod_timer(&instance->sriov_heartbeat_timer,
2666                           jiffies + MEGASAS_SRIOV_HEARTBEAT_INTERVAL_VF);
2667         } else {
2668                 dev_warn(&instance->pdev->dev, "SR-IOV: Heartbeat never "
2669                        "completed for scsi%d\n", instance->host->host_no);
2670                 schedule_work(&instance->work_init);
2671         }
2672 }
2673
2674 /**
2675  * megasas_wait_for_outstanding -       Wait for all outstanding cmds
2676  * @instance:                           Adapter soft state
2677  *
2678  * This function waits for up to MEGASAS_RESET_WAIT_TIME seconds for FW to
2679  * complete all its outstanding commands. Returns error if one or more IOs
2680  * are pending after this time period. It also marks the controller dead.
2681  */
2682 static int megasas_wait_for_outstanding(struct megasas_instance *instance)
2683 {
2684         int i, sl, outstanding;
2685         u32 reset_index;
2686         u32 wait_time = MEGASAS_RESET_WAIT_TIME;
2687         unsigned long flags;
2688         struct list_head clist_local;
2689         struct megasas_cmd *reset_cmd;
2690         u32 fw_state;
2691
2692         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2693                 dev_info(&instance->pdev->dev, "%s:%d HBA is killed.\n",
2694                 __func__, __LINE__);
2695                 return FAILED;
2696         }
2697
2698         if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
2699
2700                 INIT_LIST_HEAD(&clist_local);
2701                 spin_lock_irqsave(&instance->hba_lock, flags);
2702                 list_splice_init(&instance->internal_reset_pending_q,
2703                                 &clist_local);
2704                 spin_unlock_irqrestore(&instance->hba_lock, flags);
2705
2706                 dev_notice(&instance->pdev->dev, "HBA reset wait ...\n");
2707                 for (i = 0; i < wait_time; i++) {
2708                         msleep(1000);
2709                         if (atomic_read(&instance->adprecovery) == MEGASAS_HBA_OPERATIONAL)
2710                                 break;
2711                 }
2712
2713                 if (atomic_read(&instance->adprecovery) != MEGASAS_HBA_OPERATIONAL) {
2714                         dev_notice(&instance->pdev->dev, "reset: Stopping HBA.\n");
2715                         atomic_set(&instance->adprecovery, MEGASAS_HW_CRITICAL_ERROR);
2716                         return FAILED;
2717                 }
2718
2719                 reset_index = 0;
2720                 while (!list_empty(&clist_local)) {
2721                         reset_cmd = list_entry((&clist_local)->next,
2722                                                 struct megasas_cmd, list);
2723                         list_del_init(&reset_cmd->list);
2724                         if (reset_cmd->scmd) {
2725                                 reset_cmd->scmd->result = DID_REQUEUE << 16;
2726                                 dev_notice(&instance->pdev->dev, "%d:%p reset [%02x]\n",
2727                                         reset_index, reset_cmd,
2728                                         reset_cmd->scmd->cmnd[0]);
2729
2730                                 reset_cmd->scmd->scsi_done(reset_cmd->scmd);
2731                                 megasas_return_cmd(instance, reset_cmd);
2732                         } else if (reset_cmd->sync_cmd) {
2733                                 dev_notice(&instance->pdev->dev, "%p synch cmds"
2734                                                 "reset queue\n",
2735                                                 reset_cmd);
2736
2737                                 reset_cmd->cmd_status_drv = DCMD_INIT;
2738                                 instance->instancet->fire_cmd(instance,
2739                                                 reset_cmd->frame_phys_addr,
2740                                                 0, instance->reg_set);
2741                         } else {
2742                                 dev_notice(&instance->pdev->dev, "%p unexpected"
2743                                         "cmds lst\n",
2744                                         reset_cmd);
2745                         }
2746                         reset_index++;
2747                 }
2748
2749                 return SUCCESS;
2750         }
2751
2752         for (i = 0; i < resetwaittime; i++) {
2753                 outstanding = atomic_read(&instance->fw_outstanding);
2754
2755                 if (!outstanding)
2756                         break;
2757
2758                 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
2759                         dev_notice(&instance->pdev->dev, "[%2d]waiting for %d "
2760                                "commands to complete\n",i,outstanding);
2761                         /*
2762                          * Call cmd completion routine. Cmd to be
2763                          * be completed directly without depending on isr.
2764                          */
2765                         megasas_complete_cmd_dpc((unsigned long)instance);
2766                 }
2767
2768                 msleep(1000);
2769         }
2770
2771         i = 0;
2772         outstanding = atomic_read(&instance->fw_outstanding);
2773         fw_state = instance->instancet->read_fw_status_reg(instance) & MFI_STATE_MASK;
2774
2775         if ((!outstanding && (fw_state == MFI_STATE_OPERATIONAL)))
2776                 goto no_outstanding;
2777
2778         if (instance->disableOnlineCtrlReset)
2779                 goto kill_hba_and_failed;
2780         do {
2781                 if ((fw_state == MFI_STATE_FAULT) || atomic_read(&instance->fw_outstanding)) {
2782                         dev_info(&instance->pdev->dev,
2783                                 "%s:%d waiting_for_outstanding: before issue OCR. FW state = 0x%x, outstanding 0x%x\n",
2784                                 __func__, __LINE__, fw_state, atomic_read(&instance->fw_outstanding));
2785                         if (i == 3)
2786                                 goto kill_hba_and_failed;
2787                         megasas_do_ocr(instance);
2788
2789                         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2790                                 dev_info(&instance->pdev->dev, "%s:%d OCR failed and HBA is killed.\n",
2791                                 __func__, __LINE__);
2792                                 return FAILED;
2793                         }
2794                         dev_info(&instance->pdev->dev, "%s:%d waiting_for_outstanding: after issue OCR.\n",
2795                                 __func__, __LINE__);
2796
2797                         for (sl = 0; sl < 10; sl++)
2798                                 msleep(500);
2799
2800                         outstanding = atomic_read(&instance->fw_outstanding);
2801
2802                         fw_state = instance->instancet->read_fw_status_reg(instance) & MFI_STATE_MASK;
2803                         if ((!outstanding && (fw_state == MFI_STATE_OPERATIONAL)))
2804                                 goto no_outstanding;
2805                 }
2806                 i++;
2807         } while (i <= 3);
2808
2809 no_outstanding:
2810
2811         dev_info(&instance->pdev->dev, "%s:%d no more pending commands remain after reset handling.\n",
2812                 __func__, __LINE__);
2813         return SUCCESS;
2814
2815 kill_hba_and_failed:
2816
2817         /* Reset not supported, kill adapter */
2818         dev_info(&instance->pdev->dev, "%s:%d killing adapter scsi%d"
2819                 " disableOnlineCtrlReset %d fw_outstanding %d \n",
2820                 __func__, __LINE__, instance->host->host_no, instance->disableOnlineCtrlReset,
2821                 atomic_read(&instance->fw_outstanding));
2822         megasas_dump_pending_frames(instance);
2823         megaraid_sas_kill_hba(instance);
2824
2825         return FAILED;
2826 }
2827
2828 /**
2829  * megasas_generic_reset -      Generic reset routine
2830  * @scmd:                       Mid-layer SCSI command
2831  *
2832  * This routine implements a generic reset handler for device, bus and host
2833  * reset requests. Device, bus and host specific reset handlers can use this
2834  * function after they do their specific tasks.
2835  */
2836 static int megasas_generic_reset(struct scsi_cmnd *scmd)
2837 {
2838         int ret_val;
2839         struct megasas_instance *instance;
2840
2841         instance = (struct megasas_instance *)scmd->device->host->hostdata;
2842
2843         scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
2844                  scmd->cmnd[0], scmd->retries);
2845
2846         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
2847                 dev_err(&instance->pdev->dev, "cannot recover from previous reset failures\n");
2848                 return FAILED;
2849         }
2850
2851         ret_val = megasas_wait_for_outstanding(instance);
2852         if (ret_val == SUCCESS)
2853                 dev_notice(&instance->pdev->dev, "reset successful\n");
2854         else
2855                 dev_err(&instance->pdev->dev, "failed to do reset\n");
2856
2857         return ret_val;
2858 }
2859
2860 /**
2861  * megasas_reset_timer - quiesce the adapter if required
2862  * @scmd:               scsi cmnd
2863  *
2864  * Sets the FW busy flag and reduces the host->can_queue if the
2865  * cmd has not been completed within the timeout period.
2866  */
2867 static enum
2868 blk_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd)
2869 {
2870         struct megasas_instance *instance;
2871         unsigned long flags;
2872
2873         if (time_after(jiffies, scmd->jiffies_at_alloc +
2874                                 (scmd_timeout * 2) * HZ)) {
2875                 return BLK_EH_DONE;
2876         }
2877
2878         instance = (struct megasas_instance *)scmd->device->host->hostdata;
2879         if (!(instance->flag & MEGASAS_FW_BUSY)) {
2880                 /* FW is busy, throttle IO */
2881                 spin_lock_irqsave(instance->host->host_lock, flags);
2882
2883                 instance->host->can_queue = instance->throttlequeuedepth;
2884                 instance->last_time = jiffies;
2885                 instance->flag |= MEGASAS_FW_BUSY;
2886
2887                 spin_unlock_irqrestore(instance->host->host_lock, flags);
2888         }
2889         return BLK_EH_RESET_TIMER;
2890 }
2891
2892 /**
2893  * megasas_dump -       This function will print hexdump of provided buffer.
2894  * @buf:                Buffer to be dumped
2895  * @sz:         Size in bytes
2896  * @format:             Different formats of dumping e.g. format=n will
2897  *                      cause only 'n' 32 bit words to be dumped in a single
2898  *                      line.
2899  */
2900 inline void
2901 megasas_dump(void *buf, int sz, int format)
2902 {
2903         int i;
2904         __le32 *buf_loc = (__le32 *)buf;
2905
2906         for (i = 0; i < (sz / sizeof(__le32)); i++) {
2907                 if ((i % format) == 0) {
2908                         if (i != 0)
2909                                 printk(KERN_CONT "\n");
2910                         printk(KERN_CONT "%08x: ", (i * 4));
2911                 }
2912                 printk(KERN_CONT "%08x ", le32_to_cpu(buf_loc[i]));
2913         }
2914         printk(KERN_CONT "\n");
2915 }
2916
2917 /**
2918  * megasas_dump_reg_set -       This function will print hexdump of register set
2919  * @buf:                        Buffer to be dumped
2920  * @sz:                         Size in bytes
2921  * @format:                     Different formats of dumping e.g. format=n will
2922  *                              cause only 'n' 32 bit words to be dumped in a
2923  *                              single line.
2924  */
2925 inline void
2926 megasas_dump_reg_set(void __iomem *reg_set)
2927 {
2928         unsigned int i, sz = 256;
2929         u32 __iomem *reg = (u32 __iomem *)reg_set;
2930
2931         for (i = 0; i < (sz / sizeof(u32)); i++)
2932                 printk("%08x: %08x\n", (i * 4), readl(&reg[i]));
2933 }
2934
2935 /**
2936  * megasas_dump_fusion_io -     This function will print key details
2937  *                              of SCSI IO
2938  * @scmd:                       SCSI command pointer of SCSI IO
2939  */
2940 void
2941 megasas_dump_fusion_io(struct scsi_cmnd *scmd)
2942 {
2943         struct megasas_cmd_fusion *cmd;
2944         union MEGASAS_REQUEST_DESCRIPTOR_UNION *req_desc;
2945         struct megasas_instance *instance;
2946
2947         cmd = (struct megasas_cmd_fusion *)scmd->SCp.ptr;
2948         instance = (struct megasas_instance *)scmd->device->host->hostdata;
2949
2950         scmd_printk(KERN_INFO, scmd,
2951                     "scmd: (0x%p)  retries: 0x%x  allowed: 0x%x\n",
2952                     scmd, scmd->retries, scmd->allowed);
2953         scsi_print_command(scmd);
2954
2955         if (cmd) {
2956                 req_desc = (union MEGASAS_REQUEST_DESCRIPTOR_UNION *)cmd->request_desc;
2957                 scmd_printk(KERN_INFO, scmd, "Request descriptor details:\n");
2958                 scmd_printk(KERN_INFO, scmd,
2959                             "RequestFlags:0x%x  MSIxIndex:0x%x  SMID:0x%x  LMID:0x%x  DevHandle:0x%x\n",
2960                             req_desc->SCSIIO.RequestFlags,
2961                             req_desc->SCSIIO.MSIxIndex, req_desc->SCSIIO.SMID,
2962                             req_desc->SCSIIO.LMID, req_desc->SCSIIO.DevHandle);
2963
2964                 printk(KERN_INFO "IO request frame:\n");
2965                 megasas_dump(cmd->io_request,
2966                              MEGA_MPI2_RAID_DEFAULT_IO_FRAME_SIZE, 8);
2967                 printk(KERN_INFO "Chain frame:\n");
2968                 megasas_dump(cmd->sg_frame,
2969                              instance->max_chain_frame_sz, 8);
2970         }
2971
2972 }
2973
2974 /*
2975  * megasas_dump_sys_regs - This function will dump system registers through
2976  *                          sysfs.
2977  * @reg_set:                Pointer to System register set.
2978  * @buf:                    Buffer to which output is to be written.
2979  * @return:                 Number of bytes written to buffer.
2980  */
2981 static inline ssize_t
2982 megasas_dump_sys_regs(void __iomem *reg_set, char *buf)
2983 {
2984         unsigned int i, sz = 256;
2985         int bytes_wrote = 0;
2986         char *loc = (char *)buf;
2987         u32 __iomem *reg = (u32 __iomem *)reg_set;
2988
2989         for (i = 0; i < sz / sizeof(u32); i++) {
2990                 bytes_wrote += snprintf(loc + bytes_wrote, PAGE_SIZE,
2991                                         "%08x: %08x\n", (i * 4),
2992                                         readl(&reg[i]));
2993         }
2994         return bytes_wrote;
2995 }
2996
2997 /**
2998  * megasas_reset_bus_host -     Bus & host reset handler entry point
2999  */
3000 static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
3001 {
3002         int ret;
3003         struct megasas_instance *instance;
3004
3005         instance = (struct megasas_instance *)scmd->device->host->hostdata;
3006
3007         scmd_printk(KERN_INFO, scmd,
3008                 "OCR is requested due to IO timeout!!\n");
3009
3010         scmd_printk(KERN_INFO, scmd,
3011                 "SCSI host state: %d  SCSI host busy: %d  FW outstanding: %d\n",
3012                 scmd->device->host->shost_state,
3013                 scsi_host_busy(scmd->device->host),
3014                 atomic_read(&instance->fw_outstanding));
3015         /*
3016          * First wait for all commands to complete
3017          */
3018         if (instance->adapter_type == MFI_SERIES) {
3019                 ret = megasas_generic_reset(scmd);
3020         } else {
3021                 megasas_dump_fusion_io(scmd);
3022                 ret = megasas_reset_fusion(scmd->device->host,
3023                                 SCSIIO_TIMEOUT_OCR);
3024         }
3025
3026         return ret;
3027 }
3028
3029 /**
3030  * megasas_task_abort - Issues task abort request to firmware
3031  *                      (supported only for fusion adapters)
3032  * @scmd:               SCSI command pointer
3033  */
3034 static int megasas_task_abort(struct scsi_cmnd *scmd)
3035 {
3036         int ret;
3037         struct megasas_instance *instance;
3038
3039         instance = (struct megasas_instance *)scmd->device->host->hostdata;
3040
3041         if (instance->adapter_type != MFI_SERIES)
3042                 ret = megasas_task_abort_fusion(scmd);
3043         else {
3044                 sdev_printk(KERN_NOTICE, scmd->device, "TASK ABORT not supported\n");
3045                 ret = FAILED;
3046         }
3047
3048         return ret;
3049 }
3050
3051 /**
3052  * megasas_reset_target:  Issues target reset request to firmware
3053  *                        (supported only for fusion adapters)
3054  * @scmd:                 SCSI command pointer
3055  */
3056 static int megasas_reset_target(struct scsi_cmnd *scmd)
3057 {
3058         int ret;
3059         struct megasas_instance *instance;
3060
3061         instance = (struct megasas_instance *)scmd->device->host->hostdata;
3062
3063         if (instance->adapter_type != MFI_SERIES)
3064                 ret = megasas_reset_target_fusion(scmd);
3065         else {
3066                 sdev_printk(KERN_NOTICE, scmd->device, "TARGET RESET not supported\n");
3067                 ret = FAILED;
3068         }
3069
3070         return ret;
3071 }
3072
3073 /**
3074  * megasas_bios_param - Returns disk geometry for a disk
3075  * @sdev:               device handle
3076  * @bdev:               block device
3077  * @capacity:           drive capacity
3078  * @geom:               geometry parameters
3079  */
3080 static int
3081 megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
3082                  sector_t capacity, int geom[])
3083 {
3084         int heads;
3085         int sectors;
3086         sector_t cylinders;
3087         unsigned long tmp;
3088
3089         /* Default heads (64) & sectors (32) */
3090         heads = 64;
3091         sectors = 32;
3092
3093         tmp = heads * sectors;
3094         cylinders = capacity;
3095
3096         sector_div(cylinders, tmp);
3097
3098         /*
3099          * Handle extended translation size for logical drives > 1Gb
3100          */
3101
3102         if (capacity >= 0x200000) {
3103                 heads = 255;
3104                 sectors = 63;
3105                 tmp = heads*sectors;
3106                 cylinders = capacity;
3107                 sector_div(cylinders, tmp);
3108         }
3109
3110         geom[0] = heads;
3111         geom[1] = sectors;
3112         geom[2] = cylinders;
3113
3114         return 0;
3115 }
3116
3117 static void megasas_aen_polling(struct work_struct *work);
3118
3119 /**
3120  * megasas_service_aen -        Processes an event notification
3121  * @instance:                   Adapter soft state
3122  * @cmd:                        AEN command completed by the ISR
3123  *
3124  * For AEN, driver sends a command down to FW that is held by the FW till an
3125  * event occurs. When an event of interest occurs, FW completes the command
3126  * that it was previously holding.
3127  *
3128  * This routines sends SIGIO signal to processes that have registered with the
3129  * driver for AEN.
3130  */
3131 static void
3132 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
3133 {
3134         unsigned long flags;
3135
3136         /*
3137          * Don't signal app if it is just an aborted previously registered aen
3138          */
3139         if ((!cmd->abort_aen) && (instance->unload == 0)) {
3140                 spin_lock_irqsave(&poll_aen_lock, flags);
3141                 megasas_poll_wait_aen = 1;
3142                 spin_unlock_irqrestore(&poll_aen_lock, flags);
3143                 wake_up(&megasas_poll_wait);
3144                 kill_fasync(&megasas_async_queue, SIGIO, POLL_IN);
3145         }
3146         else
3147                 cmd->abort_aen = 0;
3148
3149         instance->aen_cmd = NULL;
3150
3151         megasas_return_cmd(instance, cmd);
3152
3153         if ((instance->unload == 0) &&
3154                 ((instance->issuepend_done == 1))) {
3155                 struct megasas_aen_event *ev;
3156
3157                 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
3158                 if (!ev) {
3159                         dev_err(&instance->pdev->dev, "megasas_service_aen: out of memory\n");
3160                 } else {
3161                         ev->instance = instance;
3162                         instance->ev = ev;
3163                         INIT_DELAYED_WORK(&ev->hotplug_work,
3164                                           megasas_aen_polling);
3165                         schedule_delayed_work(&ev->hotplug_work, 0);
3166                 }
3167         }
3168 }
3169
3170 static ssize_t
3171 fw_crash_buffer_store(struct device *cdev,
3172         struct device_attribute *attr, const char *buf, size_t count)
3173 {
3174         struct Scsi_Host *shost = class_to_shost(cdev);
3175         struct megasas_instance *instance =
3176                 (struct megasas_instance *) shost->hostdata;
3177         int val = 0;
3178         unsigned long flags;
3179
3180         if (kstrtoint(buf, 0, &val) != 0)
3181                 return -EINVAL;
3182
3183         spin_lock_irqsave(&instance->crashdump_lock, flags);
3184         instance->fw_crash_buffer_offset = val;
3185         spin_unlock_irqrestore(&instance->crashdump_lock, flags);
3186         return strlen(buf);
3187 }
3188
3189 static ssize_t
3190 fw_crash_buffer_show(struct device *cdev,
3191         struct device_attribute *attr, char *buf)
3192 {
3193         struct Scsi_Host *shost = class_to_shost(cdev);
3194         struct megasas_instance *instance =
3195                 (struct megasas_instance *) shost->hostdata;
3196         u32 size;
3197         unsigned long dmachunk = CRASH_DMA_BUF_SIZE;
3198         unsigned long chunk_left_bytes;
3199         unsigned long src_addr;
3200         unsigned long flags;
3201         u32 buff_offset;
3202
3203         spin_lock_irqsave(&instance->crashdump_lock, flags);
3204         buff_offset = instance->fw_crash_buffer_offset;
3205         if (!instance->crash_dump_buf &&
3206                 !((instance->fw_crash_state == AVAILABLE) ||
3207                 (instance->fw_crash_state == COPYING))) {
3208                 dev_err(&instance->pdev->dev,
3209                         "Firmware crash dump is not available\n");
3210                 spin_unlock_irqrestore(&instance->crashdump_lock, flags);
3211                 return -EINVAL;
3212         }
3213
3214         if (buff_offset > (instance->fw_crash_buffer_size * dmachunk)) {
3215                 dev_err(&instance->pdev->dev,
3216                         "Firmware crash dump offset is out of range\n");
3217                 spin_unlock_irqrestore(&instance->crashdump_lock, flags);
3218                 return 0;
3219         }
3220
3221         size = (instance->fw_crash_buffer_size * dmachunk) - buff_offset;
3222         chunk_left_bytes = dmachunk - (buff_offset % dmachunk);
3223         size = (size > chunk_left_bytes) ? chunk_left_bytes : size;
3224         size = (size >= PAGE_SIZE) ? (PAGE_SIZE - 1) : size;
3225
3226         src_addr = (unsigned long)instance->crash_buf[buff_offset / dmachunk] +
3227                 (buff_offset % dmachunk);
3228         memcpy(buf, (void *)src_addr, size);
3229         spin_unlock_irqrestore(&instance->crashdump_lock, flags);
3230
3231         return size;
3232 }
3233
3234 static ssize_t
3235 fw_crash_buffer_size_show(struct device *cdev,
3236         struct device_attribute *attr, char *buf)
3237 {
3238         struct Scsi_Host *shost = class_to_shost(cdev);
3239         struct megasas_instance *instance =
3240                 (struct megasas_instance *) shost->hostdata;
3241
3242         return snprintf(buf, PAGE_SIZE, "%ld\n", (unsigned long)
3243                 ((instance->fw_crash_buffer_size) * 1024 * 1024)/PAGE_SIZE);
3244 }
3245
3246 static ssize_t
3247 fw_crash_state_store(struct device *cdev,
3248         struct device_attribute *attr, const char *buf, size_t count)
3249 {
3250         struct Scsi_Host *shost = class_to_shost(cdev);
3251         struct megasas_instance *instance =
3252                 (struct megasas_instance *) shost->hostdata;
3253         int val = 0;
3254         unsigned long flags;
3255
3256         if (kstrtoint(buf, 0, &val) != 0)
3257                 return -EINVAL;
3258
3259         if ((val <= AVAILABLE || val > COPY_ERROR)) {
3260                 dev_err(&instance->pdev->dev, "application updates invalid "
3261                         "firmware crash state\n");
3262                 return -EINVAL;
3263         }
3264
3265         instance->fw_crash_state = val;
3266
3267         if ((val == COPIED) || (val == COPY_ERROR)) {
3268                 spin_lock_irqsave(&instance->crashdump_lock, flags);
3269                 megasas_free_host_crash_buffer(instance);
3270                 spin_unlock_irqrestore(&instance->crashdump_lock, flags);
3271                 if (val == COPY_ERROR)
3272                         dev_info(&instance->pdev->dev, "application failed to "
3273                                 "copy Firmware crash dump\n");
3274                 else
3275                         dev_info(&instance->pdev->dev, "Firmware crash dump "
3276                                 "copied successfully\n");
3277         }
3278         return strlen(buf);
3279 }
3280
3281 static ssize_t
3282 fw_crash_state_show(struct device *cdev,
3283         struct device_attribute *attr, char *buf)
3284 {
3285         struct Scsi_Host *shost = class_to_shost(cdev);
3286         struct megasas_instance *instance =
3287                 (struct megasas_instance *) shost->hostdata;
3288
3289         return snprintf(buf, PAGE_SIZE, "%d\n", instance->fw_crash_state);
3290 }
3291
3292 static ssize_t
3293 page_size_show(struct device *cdev,
3294         struct device_attribute *attr, char *buf)
3295 {
3296         return snprintf(buf, PAGE_SIZE, "%ld\n", (unsigned long)PAGE_SIZE - 1);
3297 }
3298
3299 static ssize_t
3300 ldio_outstanding_show(struct device *cdev, struct device_attribute *attr,
3301         char *buf)
3302 {
3303         struct Scsi_Host *shost = class_to_shost(cdev);
3304         struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3305
3306         return snprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&instance->ldio_outstanding));
3307 }
3308
3309 static ssize_t
3310 fw_cmds_outstanding_show(struct device *cdev,
3311                                  struct device_attribute *attr, char *buf)
3312 {
3313         struct Scsi_Host *shost = class_to_shost(cdev);
3314         struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3315
3316         return snprintf(buf, PAGE_SIZE, "%d\n", atomic_read(&instance->fw_outstanding));
3317 }
3318
3319 static ssize_t
3320 enable_sdev_max_qd_show(struct device *cdev,
3321         struct device_attribute *attr, char *buf)
3322 {
3323         struct Scsi_Host *shost = class_to_shost(cdev);
3324         struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3325
3326         return snprintf(buf, PAGE_SIZE, "%d\n", instance->enable_sdev_max_qd);
3327 }
3328
3329 static ssize_t
3330 enable_sdev_max_qd_store(struct device *cdev,
3331         struct device_attribute *attr, const char *buf, size_t count)
3332 {
3333         struct Scsi_Host *shost = class_to_shost(cdev);
3334         struct megasas_instance *instance = (struct megasas_instance *)shost->hostdata;
3335         u32 val = 0;
3336         bool is_target_prop;
3337         int ret_target_prop = DCMD_FAILED;
3338         struct scsi_device *sdev;
3339
3340         if (kstrtou32(buf, 0, &val) != 0) {
3341                 pr_err("megasas: could not set enable_sdev_max_qd\n");
3342                 return -EINVAL;
3343         }
3344
3345         mutex_lock(&instance->reset_mutex);
3346         if (val)
3347                 instance->enable_sdev_max_qd = true;
3348         else
3349                 instance->enable_sdev_max_qd = false;
3350
3351         shost_for_each_device(sdev, shost) {
3352                 ret_target_prop = megasas_get_target_prop(instance, sdev);
3353                 is_target_prop = (ret_target_prop == DCMD_SUCCESS) ? true : false;
3354                 megasas_set_fw_assisted_qd(sdev, is_target_prop);
3355         }
3356         mutex_unlock(&instance->reset_mutex);
3357
3358         return strlen(buf);
3359 }
3360
3361 static ssize_t
3362 dump_system_regs_show(struct device *cdev,
3363                                struct device_attribute *attr, char *buf)
3364 {
3365         struct Scsi_Host *shost = class_to_shost(cdev);
3366         struct megasas_instance *instance =
3367                         (struct megasas_instance *)shost->hostdata;
3368
3369         return megasas_dump_sys_regs(instance->reg_set, buf);
3370 }
3371
3372 static ssize_t
3373 raid_map_id_show(struct device *cdev, struct device_attribute *attr,
3374                           char *buf)
3375 {
3376         struct Scsi_Host *shost = class_to_shost(cdev);
3377         struct megasas_instance *instance =
3378                         (struct megasas_instance *)shost->hostdata;
3379
3380         return snprintf(buf, PAGE_SIZE, "%ld\n",
3381                         (unsigned long)instance->map_id);
3382 }
3383
3384 static DEVICE_ATTR_RW(fw_crash_buffer);
3385 static DEVICE_ATTR_RO(fw_crash_buffer_size);
3386 static DEVICE_ATTR_RW(fw_crash_state);
3387 static DEVICE_ATTR_RO(page_size);
3388 static DEVICE_ATTR_RO(ldio_outstanding);
3389 static DEVICE_ATTR_RO(fw_cmds_outstanding);
3390 static DEVICE_ATTR_RW(enable_sdev_max_qd);
3391 static DEVICE_ATTR_RO(dump_system_regs);
3392 static DEVICE_ATTR_RO(raid_map_id);
3393
3394 static struct device_attribute *megaraid_host_attrs[] = {
3395         &dev_attr_fw_crash_buffer_size,
3396         &dev_attr_fw_crash_buffer,
3397         &dev_attr_fw_crash_state,
3398         &dev_attr_page_size,
3399         &dev_attr_ldio_outstanding,
3400         &dev_attr_fw_cmds_outstanding,
3401         &dev_attr_enable_sdev_max_qd,
3402         &dev_attr_dump_system_regs,
3403         &dev_attr_raid_map_id,
3404         NULL,
3405 };
3406
3407 /*
3408  * Scsi host template for megaraid_sas driver
3409  */
3410 static struct scsi_host_template megasas_template = {
3411
3412         .module = THIS_MODULE,
3413         .name = "Avago SAS based MegaRAID driver",
3414         .proc_name = "megaraid_sas",
3415         .slave_configure = megasas_slave_configure,
3416         .slave_alloc = megasas_slave_alloc,
3417         .slave_destroy = megasas_slave_destroy,
3418         .queuecommand = megasas_queue_command,
3419         .eh_target_reset_handler = megasas_reset_target,
3420         .eh_abort_handler = megasas_task_abort,
3421         .eh_host_reset_handler = megasas_reset_bus_host,
3422         .eh_timed_out = megasas_reset_timer,
3423         .shost_attrs = megaraid_host_attrs,
3424         .bios_param = megasas_bios_param,
3425         .change_queue_depth = scsi_change_queue_depth,
3426         .max_segment_size = 0xffffffff,
3427 };
3428
3429 /**
3430  * megasas_complete_int_cmd -   Completes an internal command
3431  * @instance:                   Adapter soft state
3432  * @cmd:                        Command to be completed
3433  *
3434  * The megasas_issue_blocked_cmd() function waits for a command to complete
3435  * after it issues a command. This function wakes up that waiting routine by
3436  * calling wake_up() on the wait queue.
3437  */
3438 static void
3439 megasas_complete_int_cmd(struct megasas_instance *instance,
3440                          struct megasas_cmd *cmd)
3441 {
3442         if (cmd->cmd_status_drv == DCMD_INIT)
3443                 cmd->cmd_status_drv =
3444                 (cmd->frame->io.cmd_status == MFI_STAT_OK) ?
3445                 DCMD_SUCCESS : DCMD_FAILED;
3446
3447         wake_up(&instance->int_cmd_wait_q);
3448 }
3449
3450 /**
3451  * megasas_complete_abort -     Completes aborting a command
3452  * @instance:                   Adapter soft state
3453  * @cmd:                        Cmd that was issued to abort another cmd
3454  *
3455  * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
3456  * after it issues an abort on a previously issued command. This function
3457  * wakes up all functions waiting on the same wait queue.
3458  */
3459 static void
3460 megasas_complete_abort(struct megasas_instance *instance,
3461                        struct megasas_cmd *cmd)
3462 {
3463         if (cmd->sync_cmd) {
3464                 cmd->sync_cmd = 0;
3465                 cmd->cmd_status_drv = DCMD_SUCCESS;
3466                 wake_up(&instance->abort_cmd_wait_q);
3467         }
3468 }
3469
3470 /**
3471  * megasas_complete_cmd -       Completes a command
3472  * @instance:                   Adapter soft state
3473  * @cmd:                        Command to be completed
3474  * @alt_status:                 If non-zero, use this value as status to
3475  *                              SCSI mid-layer instead of the value returned
3476  *                              by the FW. This should be used if caller wants
3477  *                              an alternate status (as in the case of aborted
3478  *                              commands)
3479  */
3480 void
3481 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
3482                      u8 alt_status)
3483 {
3484         int exception = 0;
3485         struct megasas_header *hdr = &cmd->frame->hdr;
3486         unsigned long flags;
3487         struct fusion_context *fusion = instance->ctrl_context;
3488         u32 opcode, status;
3489
3490         /* flag for the retry reset */
3491         cmd->retry_for_fw_reset = 0;
3492
3493         if (cmd->scmd)
3494                 cmd->scmd->SCp.ptr = NULL;
3495
3496         switch (hdr->cmd) {
3497         case MFI_CMD_INVALID:
3498                 /* Some older 1068 controller FW may keep a pended
3499                    MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel
3500                    when booting the kdump kernel.  Ignore this command to
3501                    prevent a kernel panic on shutdown of the kdump kernel. */
3502                 dev_warn(&instance->pdev->dev, "MFI_CMD_INVALID command "
3503                        "completed\n");
3504                 dev_warn(&instance->pdev->dev, "If you have a controller "
3505                        "other than PERC5, please upgrade your firmware\n");
3506                 break;
3507         case MFI_CMD_PD_SCSI_IO:
3508         case MFI_CMD_LD_SCSI_IO:
3509
3510                 /*
3511                  * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
3512                  * issued either through an IO path or an IOCTL path. If it
3513                  * was via IOCTL, we will send it to internal completion.
3514                  */
3515                 if (cmd->sync_cmd) {
3516                         cmd->sync_cmd = 0;
3517                         megasas_complete_int_cmd(instance, cmd);
3518                         break;
3519                 }
3520                 /* fall through */
3521
3522         case MFI_CMD_LD_READ:
3523         case MFI_CMD_LD_WRITE:
3524
3525                 if (alt_status) {
3526                         cmd->scmd->result = alt_status << 16;
3527                         exception = 1;
3528                 }
3529
3530                 if (exception) {
3531
3532                         atomic_dec(&instance->fw_outstanding);
3533
3534                         scsi_dma_unmap(cmd->scmd);
3535                         cmd->scmd->scsi_done(cmd->scmd);
3536                         megasas_return_cmd(instance, cmd);
3537
3538                         break;
3539                 }
3540
3541                 switch (hdr->cmd_status) {
3542
3543                 case MFI_STAT_OK:
3544                         cmd->scmd->result = DID_OK << 16;
3545                         break;
3546
3547                 case MFI_STAT_SCSI_IO_FAILED:
3548                 case MFI_STAT_LD_INIT_IN_PROGRESS:
3549                         cmd->scmd->result =
3550                             (DID_ERROR << 16) | hdr->scsi_status;
3551                         break;
3552
3553                 case MFI_STAT_SCSI_DONE_WITH_ERROR:
3554
3555                         cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status;
3556
3557                         if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {
3558                                 memset(cmd->scmd->sense_buffer, 0,
3559                                        SCSI_SENSE_BUFFERSIZE);
3560                                 memcpy(cmd->scmd->sense_buffer, cmd->sense,
3561                                        hdr->sense_len);
3562
3563                                 cmd->scmd->result |= DRIVER_SENSE << 24;
3564                         }
3565
3566                         break;
3567
3568                 case MFI_STAT_LD_OFFLINE:
3569                 case MFI_STAT_DEVICE_NOT_FOUND:
3570                         cmd->scmd->result = DID_BAD_TARGET << 16;
3571                         break;
3572
3573                 default:
3574                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "MFI FW status %#x\n",
3575                                hdr->cmd_status);
3576                         cmd->scmd->result = DID_ERROR << 16;
3577                         break;
3578                 }
3579
3580                 atomic_dec(&instance->fw_outstanding);
3581
3582                 scsi_dma_unmap(cmd->scmd);
3583                 cmd->scmd->scsi_done(cmd->scmd);
3584                 megasas_return_cmd(instance, cmd);
3585
3586                 break;
3587
3588         case MFI_CMD_SMP:
3589         case MFI_CMD_STP:
3590         case MFI_CMD_NVME:
3591         case MFI_CMD_TOOLBOX:
3592                 megasas_complete_int_cmd(instance, cmd);
3593                 break;
3594
3595         case MFI_CMD_DCMD:
3596                 opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
3597                 /* Check for LD map update */
3598                 if ((opcode == MR_DCMD_LD_MAP_GET_INFO)
3599                         && (cmd->frame->dcmd.mbox.b[1] == 1)) {
3600                         fusion->fast_path_io = 0;
3601                         spin_lock_irqsave(instance->host->host_lock, flags);
3602                         status = cmd->frame->hdr.cmd_status;
3603                         instance->map_update_cmd = NULL;
3604                         if (status != MFI_STAT_OK) {
3605                                 if (status != MFI_STAT_NOT_FOUND)
3606                                         dev_warn(&instance->pdev->dev, "map syncfailed, status = 0x%x\n",
3607                                                cmd->frame->hdr.cmd_status);
3608                                 else {
3609                                         megasas_return_cmd(instance, cmd);
3610                                         spin_unlock_irqrestore(
3611                                                 instance->host->host_lock,
3612                                                 flags);
3613                                         break;
3614                                 }
3615                         }
3616
3617                         megasas_return_cmd(instance, cmd);
3618
3619                         /*
3620                          * Set fast path IO to ZERO.
3621                          * Validate Map will set proper value.
3622                          * Meanwhile all IOs will go as LD IO.
3623                          */
3624                         if (status == MFI_STAT_OK &&
3625                             (MR_ValidateMapInfo(instance, (instance->map_id + 1)))) {
3626                                 instance->map_id++;
3627                                 fusion->fast_path_io = 1;
3628                         } else {
3629                                 fusion->fast_path_io = 0;
3630                         }
3631
3632                         megasas_sync_map_info(instance);
3633                         spin_unlock_irqrestore(instance->host->host_lock,
3634                                                flags);
3635                         break;
3636                 }
3637                 if (opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
3638                     opcode == MR_DCMD_CTRL_EVENT_GET) {
3639                         spin_lock_irqsave(&poll_aen_lock, flags);
3640                         megasas_poll_wait_aen = 0;
3641                         spin_unlock_irqrestore(&poll_aen_lock, flags);
3642                 }
3643
3644                 /* FW has an updated PD sequence */
3645                 if ((opcode == MR_DCMD_SYSTEM_PD_MAP_GET_INFO) &&
3646                         (cmd->frame->dcmd.mbox.b[0] == 1)) {
3647
3648                         spin_lock_irqsave(instance->host->host_lock, flags);
3649                         status = cmd->frame->hdr.cmd_status;
3650                         instance->jbod_seq_cmd = NULL;
3651                         megasas_return_cmd(instance, cmd);
3652
3653                         if (status == MFI_STAT_OK) {
3654                                 instance->pd_seq_map_id++;
3655                                 /* Re-register a pd sync seq num cmd */
3656                                 if (megasas_sync_pd_seq_num(instance, true))
3657                                         instance->use_seqnum_jbod_fp = false;
3658                         } else
3659                                 instance->use_seqnum_jbod_fp = false;
3660
3661                         spin_unlock_irqrestore(instance->host->host_lock, flags);
3662                         break;
3663                 }
3664
3665                 /*
3666                  * See if got an event notification
3667                  */
3668                 if (opcode == MR_DCMD_CTRL_EVENT_WAIT)
3669                         megasas_service_aen(instance, cmd);
3670                 else
3671                         megasas_complete_int_cmd(instance, cmd);
3672
3673                 break;
3674
3675         case MFI_CMD_ABORT:
3676                 /*
3677                  * Cmd issued to abort another cmd returned
3678                  */
3679                 megasas_complete_abort(instance, cmd);
3680                 break;
3681
3682         default:
3683                 dev_info(&instance->pdev->dev, "Unknown command completed! [0x%X]\n",
3684                        hdr->cmd);
3685                 megasas_complete_int_cmd(instance, cmd);
3686                 break;
3687         }
3688 }
3689
3690 /**
3691  * megasas_issue_pending_cmds_again -   issue all pending cmds
3692  *                                      in FW again because of the fw reset
3693  * @instance:                           Adapter soft state
3694  */
3695 static inline void
3696 megasas_issue_pending_cmds_again(struct megasas_instance *instance)
3697 {
3698         struct megasas_cmd *cmd;
3699         struct list_head clist_local;
3700         union megasas_evt_class_locale class_locale;
3701         unsigned long flags;
3702         u32 seq_num;
3703
3704         INIT_LIST_HEAD(&clist_local);
3705         spin_lock_irqsave(&instance->hba_lock, flags);
3706         list_splice_init(&instance->internal_reset_pending_q, &clist_local);
3707         spin_unlock_irqrestore(&instance->hba_lock, flags);
3708
3709         while (!list_empty(&clist_local)) {
3710                 cmd = list_entry((&clist_local)->next,
3711                                         struct megasas_cmd, list);
3712                 list_del_init(&cmd->list);
3713
3714                 if (cmd->sync_cmd || cmd->scmd) {
3715                         dev_notice(&instance->pdev->dev, "command %p, %p:%d"
3716                                 "detected to be pending while HBA reset\n",
3717                                         cmd, cmd->scmd, cmd->sync_cmd);
3718
3719                         cmd->retry_for_fw_reset++;
3720
3721                         if (cmd->retry_for_fw_reset == 3) {
3722                                 dev_notice(&instance->pdev->dev, "cmd %p, %p:%d"
3723                                         "was tried multiple times during reset."
3724                                         "Shutting down the HBA\n",
3725                                         cmd, cmd->scmd, cmd->sync_cmd);
3726                                 instance->instancet->disable_intr(instance);
3727                                 atomic_set(&instance->fw_reset_no_pci_access, 1);
3728                                 megaraid_sas_kill_hba(instance);
3729                                 return;
3730                         }
3731                 }
3732
3733                 if (cmd->sync_cmd == 1) {
3734                         if (cmd->scmd) {
3735                                 dev_notice(&instance->pdev->dev, "unexpected"
3736                                         "cmd attached to internal command!\n");
3737                         }
3738                         dev_notice(&instance->pdev->dev, "%p synchronous cmd"
3739                                                 "on the internal reset queue,"
3740                                                 "issue it again.\n", cmd);
3741                         cmd->cmd_status_drv = DCMD_INIT;
3742                         instance->instancet->fire_cmd(instance,
3743                                                         cmd->frame_phys_addr,
3744                                                         0, instance->reg_set);
3745                 } else if (cmd->scmd) {
3746                         dev_notice(&instance->pdev->dev, "%p scsi cmd [%02x]"
3747                         "detected on the internal queue, issue again.\n",
3748                         cmd, cmd->scmd->cmnd[0]);
3749
3750                         atomic_inc(&instance->fw_outstanding);
3751                         instance->instancet->fire_cmd(instance,
3752                                         cmd->frame_phys_addr,
3753                                         cmd->frame_count-1, instance->reg_set);
3754                 } else {
3755                         dev_notice(&instance->pdev->dev, "%p unexpected cmd on the"
3756                                 "internal reset defer list while re-issue!!\n",
3757                                 cmd);
3758                 }
3759         }
3760
3761         if (instance->aen_cmd) {
3762                 dev_notice(&instance->pdev->dev, "aen_cmd in def process\n");
3763                 megasas_return_cmd(instance, instance->aen_cmd);
3764
3765                 instance->aen_cmd = NULL;
3766         }
3767
3768         /*
3769          * Initiate AEN (Asynchronous Event Notification)
3770          */
3771         seq_num = instance->last_seq_num;
3772         class_locale.members.reserved = 0;
3773         class_locale.members.locale = MR_EVT_LOCALE_ALL;
3774         class_locale.members.class = MR_EVT_CLASS_DEBUG;
3775
3776         megasas_register_aen(instance, seq_num, class_locale.word);
3777 }
3778
3779 /**
3780  * Move the internal reset pending commands to a deferred queue.
3781  *
3782  * We move the commands pending at internal reset time to a
3783  * pending queue. This queue would be flushed after successful
3784  * completion of the internal reset sequence. if the internal reset
3785  * did not complete in time, the kernel reset handler would flush
3786  * these commands.
3787  **/
3788 static void
3789 megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
3790 {
3791         struct megasas_cmd *cmd;
3792         int i;
3793         u16 max_cmd = instance->max_fw_cmds;
3794         u32 defer_index;
3795         unsigned long flags;
3796
3797         defer_index = 0;
3798         spin_lock_irqsave(&instance->mfi_pool_lock, flags);
3799         for (i = 0; i < max_cmd; i++) {
3800                 cmd = instance->cmd_list[i];
3801                 if (cmd->sync_cmd == 1 || cmd->scmd) {
3802                         dev_notice(&instance->pdev->dev, "moving cmd[%d]:%p:%d:%p"
3803                                         "on the defer queue as internal\n",
3804                                 defer_index, cmd, cmd->sync_cmd, cmd->scmd);
3805
3806                         if (!list_empty(&cmd->list)) {
3807                                 dev_notice(&instance->pdev->dev, "ERROR while"
3808                                         " moving this cmd:%p, %d %p, it was"
3809                                         "discovered on some list?\n",
3810                                         cmd, cmd->sync_cmd, cmd->scmd);
3811
3812                                 list_del_init(&cmd->list);
3813                         }
3814                         defer_index++;
3815                         list_add_tail(&cmd->list,
3816                                 &instance->internal_reset_pending_q);
3817                 }
3818         }
3819         spin_unlock_irqrestore(&instance->mfi_pool_lock, flags);
3820 }
3821
3822
3823 static void
3824 process_fw_state_change_wq(struct work_struct *work)
3825 {
3826         struct megasas_instance *instance =
3827                 container_of(work, struct megasas_instance, work_init);
3828         u32 wait;
3829         unsigned long flags;
3830
3831     if (atomic_read(&instance->adprecovery) != MEGASAS_ADPRESET_SM_INFAULT) {
3832                 dev_notice(&instance->pdev->dev, "error, recovery st %x\n",
3833                                 atomic_read(&instance->adprecovery));
3834                 return ;
3835         }
3836
3837         if (atomic_read(&instance->adprecovery) == MEGASAS_ADPRESET_SM_INFAULT) {
3838                 dev_notice(&instance->pdev->dev, "FW detected to be in fault"
3839                                         "state, restarting it...\n");
3840
3841                 instance->instancet->disable_intr(instance);
3842                 atomic_set(&instance->fw_outstanding, 0);
3843
3844                 atomic_set(&instance->fw_reset_no_pci_access, 1);
3845                 instance->instancet->adp_reset(instance, instance->reg_set);
3846                 atomic_set(&instance->fw_reset_no_pci_access, 0);
3847
3848                 dev_notice(&instance->pdev->dev, "FW restarted successfully,"
3849                                         "initiating next stage...\n");
3850
3851                 dev_notice(&instance->pdev->dev, "HBA recovery state machine,"
3852                                         "state 2 starting...\n");
3853
3854                 /* waiting for about 20 second before start the second init */
3855                 for (wait = 0; wait < 30; wait++) {
3856                         msleep(1000);
3857                 }
3858
3859                 if (megasas_transition_to_ready(instance, 1)) {
3860                         dev_notice(&instance->pdev->dev, "adapter not ready\n");
3861
3862                         atomic_set(&instance->fw_reset_no_pci_access, 1);
3863                         megaraid_sas_kill_hba(instance);
3864                         return ;
3865                 }
3866
3867                 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
3868                         (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
3869                         (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)
3870                         ) {
3871                         *instance->consumer = *instance->producer;
3872                 } else {
3873                         *instance->consumer = 0;
3874                         *instance->producer = 0;
3875                 }
3876
3877                 megasas_issue_init_mfi(instance);
3878
3879                 spin_lock_irqsave(&instance->hba_lock, flags);
3880                 atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
3881                 spin_unlock_irqrestore(&instance->hba_lock, flags);
3882                 instance->instancet->enable_intr(instance);
3883
3884                 megasas_issue_pending_cmds_again(instance);
3885                 instance->issuepend_done = 1;
3886         }
3887 }
3888
3889 /**
3890  * megasas_deplete_reply_queue -        Processes all completed commands
3891  * @instance:                           Adapter soft state
3892  * @alt_status:                         Alternate status to be returned to
3893  *                                      SCSI mid-layer instead of the status
3894  *                                      returned by the FW
3895  * Note: this must be called with hba lock held
3896  */
3897 static int
3898 megasas_deplete_reply_queue(struct megasas_instance *instance,
3899                                         u8 alt_status)
3900 {
3901         u32 mfiStatus;
3902         u32 fw_state;
3903
3904         if ((mfiStatus = instance->instancet->check_reset(instance,
3905                                         instance->reg_set)) == 1) {
3906                 return IRQ_HANDLED;
3907         }
3908
3909         mfiStatus = instance->instancet->clear_intr(instance);
3910         if (mfiStatus == 0) {
3911                 /* Hardware may not set outbound_intr_status in MSI-X mode */
3912                 if (!instance->msix_vectors)
3913                         return IRQ_NONE;
3914         }
3915
3916         instance->mfiStatus = mfiStatus;
3917
3918         if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) {
3919                 fw_state = instance->instancet->read_fw_status_reg(
3920                                 instance) & MFI_STATE_MASK;
3921
3922                 if (fw_state != MFI_STATE_FAULT) {
3923                         dev_notice(&instance->pdev->dev, "fw state:%x\n",
3924                                                 fw_state);
3925                 }
3926
3927                 if ((fw_state == MFI_STATE_FAULT) &&
3928                                 (instance->disableOnlineCtrlReset == 0)) {
3929                         dev_notice(&instance->pdev->dev, "wait adp restart\n");
3930
3931                         if ((instance->pdev->device ==
3932                                         PCI_DEVICE_ID_LSI_SAS1064R) ||
3933                                 (instance->pdev->device ==
3934                                         PCI_DEVICE_ID_DELL_PERC5) ||
3935                                 (instance->pdev->device ==
3936                                         PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
3937
3938                                 *instance->consumer =
3939                                         cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
3940                         }
3941
3942
3943                         instance->instancet->disable_intr(instance);
3944                         atomic_set(&instance->adprecovery, MEGASAS_ADPRESET_SM_INFAULT);
3945                         instance->issuepend_done = 0;
3946
3947                         atomic_set(&instance->fw_outstanding, 0);
3948                         megasas_internal_reset_defer_cmds(instance);
3949
3950                         dev_notice(&instance->pdev->dev, "fwState=%x, stage:%d\n",
3951                                         fw_state, atomic_read(&instance->adprecovery));
3952
3953                         schedule_work(&instance->work_init);
3954                         return IRQ_HANDLED;
3955
3956                 } else {
3957                         dev_notice(&instance->pdev->dev, "fwstate:%x, dis_OCR=%x\n",
3958                                 fw_state, instance->disableOnlineCtrlReset);
3959                 }
3960         }
3961
3962         tasklet_schedule(&instance->isr_tasklet);
3963         return IRQ_HANDLED;
3964 }
3965 /**
3966  * megasas_isr - isr entry point
3967  */
3968 static irqreturn_t megasas_isr(int irq, void *devp)
3969 {
3970         struct megasas_irq_context *irq_context = devp;
3971         struct megasas_instance *instance = irq_context->instance;
3972         unsigned long flags;
3973         irqreturn_t rc;
3974
3975         if (atomic_read(&instance->fw_reset_no_pci_access))
3976                 return IRQ_HANDLED;
3977
3978         spin_lock_irqsave(&instance->hba_lock, flags);
3979         rc = megasas_deplete_reply_queue(instance, DID_OK);
3980         spin_unlock_irqrestore(&instance->hba_lock, flags);
3981
3982         return rc;
3983 }
3984
3985 /**
3986  * megasas_transition_to_ready -        Move the FW to READY state
3987  * @instance:                           Adapter soft state
3988  *
3989  * During the initialization, FW passes can potentially be in any one of
3990  * several possible states. If the FW in operational, waiting-for-handshake
3991  * states, driver must take steps to bring it to ready state. Otherwise, it
3992  * has to wait for the ready state.
3993  */
3994 int
3995 megasas_transition_to_ready(struct megasas_instance *instance, int ocr)
3996 {
3997         int i;
3998         u8 max_wait;
3999         u32 fw_state;
4000         u32 abs_state, curr_abs_state;
4001
4002         abs_state = instance->instancet->read_fw_status_reg(instance);
4003         fw_state = abs_state & MFI_STATE_MASK;
4004
4005         if (fw_state != MFI_STATE_READY)
4006                 dev_info(&instance->pdev->dev, "Waiting for FW to come to ready"
4007                        " state\n");
4008
4009         while (fw_state != MFI_STATE_READY) {
4010
4011                 switch (fw_state) {
4012
4013                 case MFI_STATE_FAULT:
4014                         dev_printk(KERN_ERR, &instance->pdev->dev,
4015                                    "FW in FAULT state, Fault code:0x%x subcode:0x%x func:%s\n",
4016                                    abs_state & MFI_STATE_FAULT_CODE,
4017                                    abs_state & MFI_STATE_FAULT_SUBCODE, __func__);
4018                         if (ocr) {
4019                                 max_wait = MEGASAS_RESET_WAIT_TIME;
4020                                 break;
4021                         } else {
4022                                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4023                                 megasas_dump_reg_set(instance->reg_set);
4024                                 return -ENODEV;
4025                         }
4026
4027                 case MFI_STATE_WAIT_HANDSHAKE:
4028                         /*
4029                          * Set the CLR bit in inbound doorbell
4030                          */
4031                         if ((instance->pdev->device ==
4032                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4033                                 (instance->pdev->device ==
4034                                  PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
4035                                 (instance->adapter_type != MFI_SERIES))
4036                                 writel(
4037                                   MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
4038                                   &instance->reg_set->doorbell);
4039                         else
4040                                 writel(
4041                                     MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
4042                                         &instance->reg_set->inbound_doorbell);
4043
4044                         max_wait = MEGASAS_RESET_WAIT_TIME;
4045                         break;
4046
4047                 case MFI_STATE_BOOT_MESSAGE_PENDING:
4048                         if ((instance->pdev->device ==
4049                              PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4050                                 (instance->pdev->device ==
4051                                  PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
4052                                 (instance->adapter_type != MFI_SERIES))
4053                                 writel(MFI_INIT_HOTPLUG,
4054                                        &instance->reg_set->doorbell);
4055                         else
4056                                 writel(MFI_INIT_HOTPLUG,
4057                                         &instance->reg_set->inbound_doorbell);
4058
4059                         max_wait = MEGASAS_RESET_WAIT_TIME;
4060                         break;
4061
4062                 case MFI_STATE_OPERATIONAL:
4063                         /*
4064                          * Bring it to READY state; assuming max wait 10 secs
4065                          */
4066                         instance->instancet->disable_intr(instance);
4067                         if ((instance->pdev->device ==
4068                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4069                                 (instance->pdev->device ==
4070                                 PCI_DEVICE_ID_LSI_SAS0071SKINNY)  ||
4071                                 (instance->adapter_type != MFI_SERIES)) {
4072                                 writel(MFI_RESET_FLAGS,
4073                                         &instance->reg_set->doorbell);
4074
4075                                 if (instance->adapter_type != MFI_SERIES) {
4076                                         for (i = 0; i < (10 * 1000); i += 20) {
4077                                                 if (megasas_readl(
4078                                                             instance,
4079                                                             &instance->
4080                                                             reg_set->
4081                                                             doorbell) & 1)
4082                                                         msleep(20);
4083                                                 else
4084                                                         break;
4085                                         }
4086                                 }
4087                         } else
4088                                 writel(MFI_RESET_FLAGS,
4089                                         &instance->reg_set->inbound_doorbell);
4090
4091                         max_wait = MEGASAS_RESET_WAIT_TIME;
4092                         break;
4093
4094                 case MFI_STATE_UNDEFINED:
4095                         /*
4096                          * This state should not last for more than 2 seconds
4097                          */
4098                         max_wait = MEGASAS_RESET_WAIT_TIME;
4099                         break;
4100
4101                 case MFI_STATE_BB_INIT:
4102                         max_wait = MEGASAS_RESET_WAIT_TIME;
4103                         break;
4104
4105                 case MFI_STATE_FW_INIT:
4106                         max_wait = MEGASAS_RESET_WAIT_TIME;
4107                         break;
4108
4109                 case MFI_STATE_FW_INIT_2:
4110                         max_wait = MEGASAS_RESET_WAIT_TIME;
4111                         break;
4112
4113                 case MFI_STATE_DEVICE_SCAN:
4114                         max_wait = MEGASAS_RESET_WAIT_TIME;
4115                         break;
4116
4117                 case MFI_STATE_FLUSH_CACHE:
4118                         max_wait = MEGASAS_RESET_WAIT_TIME;
4119                         break;
4120
4121                 default:
4122                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "Unknown state 0x%x\n",
4123                                fw_state);
4124                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4125                         megasas_dump_reg_set(instance->reg_set);
4126                         return -ENODEV;
4127                 }
4128
4129                 /*
4130                  * The cur_state should not last for more than max_wait secs
4131                  */
4132                 for (i = 0; i < max_wait * 50; i++) {
4133                         curr_abs_state = instance->instancet->
4134                                 read_fw_status_reg(instance);
4135
4136                         if (abs_state == curr_abs_state) {
4137                                 msleep(20);
4138                         } else
4139                                 break;
4140                 }
4141
4142                 /*
4143                  * Return error if fw_state hasn't changed after max_wait
4144                  */
4145                 if (curr_abs_state == abs_state) {
4146                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "FW state [%d] hasn't changed "
4147                                "in %d secs\n", fw_state, max_wait);
4148                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "System Register set:\n");
4149                         megasas_dump_reg_set(instance->reg_set);
4150                         return -ENODEV;
4151                 }
4152
4153                 abs_state = curr_abs_state;
4154                 fw_state = curr_abs_state & MFI_STATE_MASK;
4155         }
4156         dev_info(&instance->pdev->dev, "FW now in Ready state\n");
4157
4158         return 0;
4159 }
4160
4161 /**
4162  * megasas_teardown_frame_pool -        Destroy the cmd frame DMA pool
4163  * @instance:                           Adapter soft state
4164  */
4165 static void megasas_teardown_frame_pool(struct megasas_instance *instance)
4166 {
4167         int i;
4168         u16 max_cmd = instance->max_mfi_cmds;
4169         struct megasas_cmd *cmd;
4170
4171         if (!instance->frame_dma_pool)
4172                 return;
4173
4174         /*
4175          * Return all frames to pool
4176          */
4177         for (i = 0; i < max_cmd; i++) {
4178
4179                 cmd = instance->cmd_list[i];
4180
4181                 if (cmd->frame)
4182                         dma_pool_free(instance->frame_dma_pool, cmd->frame,
4183                                       cmd->frame_phys_addr);
4184
4185                 if (cmd->sense)
4186                         dma_pool_free(instance->sense_dma_pool, cmd->sense,
4187                                       cmd->sense_phys_addr);
4188         }
4189
4190         /*
4191          * Now destroy the pool itself
4192          */
4193         dma_pool_destroy(instance->frame_dma_pool);
4194         dma_pool_destroy(instance->sense_dma_pool);
4195
4196         instance->frame_dma_pool = NULL;
4197         instance->sense_dma_pool = NULL;
4198 }
4199
4200 /**
4201  * megasas_create_frame_pool -  Creates DMA pool for cmd frames
4202  * @instance:                   Adapter soft state
4203  *
4204  * Each command packet has an embedded DMA memory buffer that is used for
4205  * filling MFI frame and the SG list that immediately follows the frame. This
4206  * function creates those DMA memory buffers for each command packet by using
4207  * PCI pool facility.
4208  */
4209 static int megasas_create_frame_pool(struct megasas_instance *instance)
4210 {
4211         int i;
4212         u16 max_cmd;
4213         u32 frame_count;
4214         struct megasas_cmd *cmd;
4215
4216         max_cmd = instance->max_mfi_cmds;
4217
4218         /*
4219          * For MFI controllers.
4220          * max_num_sge = 60
4221          * max_sge_sz  = 16 byte (sizeof megasas_sge_skinny)
4222          * Total 960 byte (15 MFI frame of 64 byte)
4223          *
4224          * Fusion adapter require only 3 extra frame.
4225          * max_num_sge = 16 (defined as MAX_IOCTL_SGE)
4226          * max_sge_sz  = 12 byte (sizeof  megasas_sge64)
4227          * Total 192 byte (3 MFI frame of 64 byte)
4228          */
4229         frame_count = (instance->adapter_type == MFI_SERIES) ?
4230                         (15 + 1) : (3 + 1);
4231         instance->mfi_frame_size = MEGAMFI_FRAME_SIZE * frame_count;
4232         /*
4233          * Use DMA pool facility provided by PCI layer
4234          */
4235         instance->frame_dma_pool = dma_pool_create("megasas frame pool",
4236                                         &instance->pdev->dev,
4237                                         instance->mfi_frame_size, 256, 0);
4238
4239         if (!instance->frame_dma_pool) {
4240                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup frame pool\n");
4241                 return -ENOMEM;
4242         }
4243
4244         instance->sense_dma_pool = dma_pool_create("megasas sense pool",
4245                                                    &instance->pdev->dev, 128,
4246                                                    4, 0);
4247
4248         if (!instance->sense_dma_pool) {
4249                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "failed to setup sense pool\n");
4250
4251                 dma_pool_destroy(instance->frame_dma_pool);
4252                 instance->frame_dma_pool = NULL;
4253
4254                 return -ENOMEM;
4255         }
4256
4257         /*
4258          * Allocate and attach a frame to each of the commands in cmd_list.
4259          * By making cmd->index as the context instead of the &cmd, we can
4260          * always use 32bit context regardless of the architecture
4261          */
4262         for (i = 0; i < max_cmd; i++) {
4263
4264                 cmd = instance->cmd_list[i];
4265
4266                 cmd->frame = dma_pool_zalloc(instance->frame_dma_pool,
4267                                             GFP_KERNEL, &cmd->frame_phys_addr);
4268
4269                 cmd->sense = dma_pool_alloc(instance->sense_dma_pool,
4270                                             GFP_KERNEL, &cmd->sense_phys_addr);
4271
4272                 /*
4273                  * megasas_teardown_frame_pool() takes care of freeing
4274                  * whatever has been allocated
4275                  */
4276                 if (!cmd->frame || !cmd->sense) {
4277                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "dma_pool_alloc failed\n");
4278                         megasas_teardown_frame_pool(instance);
4279                         return -ENOMEM;
4280                 }
4281
4282                 cmd->frame->io.context = cpu_to_le32(cmd->index);
4283                 cmd->frame->io.pad_0 = 0;
4284                 if ((instance->adapter_type == MFI_SERIES) && reset_devices)
4285                         cmd->frame->hdr.cmd = MFI_CMD_INVALID;
4286         }
4287
4288         return 0;
4289 }
4290
4291 /**
4292  * megasas_free_cmds -  Free all the cmds in the free cmd pool
4293  * @instance:           Adapter soft state
4294  */
4295 void megasas_free_cmds(struct megasas_instance *instance)
4296 {
4297         int i;
4298
4299         /* First free the MFI frame pool */
4300         megasas_teardown_frame_pool(instance);
4301
4302         /* Free all the commands in the cmd_list */
4303         for (i = 0; i < instance->max_mfi_cmds; i++)
4304
4305                 kfree(instance->cmd_list[i]);
4306
4307         /* Free the cmd_list buffer itself */
4308         kfree(instance->cmd_list);
4309         instance->cmd_list = NULL;
4310
4311         INIT_LIST_HEAD(&instance->cmd_pool);
4312 }
4313
4314 /**
4315  * megasas_alloc_cmds - Allocates the command packets
4316  * @instance:           Adapter soft state
4317  *
4318  * Each command that is issued to the FW, whether IO commands from the OS or
4319  * internal commands like IOCTLs, are wrapped in local data structure called
4320  * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to
4321  * the FW.
4322  *
4323  * Each frame has a 32-bit field called context (tag). This context is used
4324  * to get back the megasas_cmd from the frame when a frame gets completed in
4325  * the ISR. Typically the address of the megasas_cmd itself would be used as
4326  * the context. But we wanted to keep the differences between 32 and 64 bit
4327  * systems to the mininum. We always use 32 bit integers for the context. In
4328  * this driver, the 32 bit values are the indices into an array cmd_list.
4329  * This array is used only to look up the megasas_cmd given the context. The
4330  * free commands themselves are maintained in a linked list called cmd_pool.
4331  */
4332 int megasas_alloc_cmds(struct megasas_instance *instance)
4333 {
4334         int i;
4335         int j;
4336         u16 max_cmd;
4337         struct megasas_cmd *cmd;
4338
4339         max_cmd = instance->max_mfi_cmds;
4340
4341         /*
4342          * instance->cmd_list is an array of struct megasas_cmd pointers.
4343          * Allocate the dynamic array first and then allocate individual
4344          * commands.
4345          */
4346         instance->cmd_list = kcalloc(max_cmd, sizeof(struct megasas_cmd*), GFP_KERNEL);
4347
4348         if (!instance->cmd_list) {
4349                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "out of memory\n");
4350                 return -ENOMEM;
4351         }
4352
4353         memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) *max_cmd);
4354
4355         for (i = 0; i < max_cmd; i++) {
4356                 instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
4357                                                 GFP_KERNEL);
4358
4359                 if (!instance->cmd_list[i]) {
4360
4361                         for (j = 0; j < i; j++)
4362                                 kfree(instance->cmd_list[j]);
4363
4364                         kfree(instance->cmd_list);
4365                         instance->cmd_list = NULL;
4366
4367                         return -ENOMEM;
4368                 }
4369         }
4370
4371         for (i = 0; i < max_cmd; i++) {
4372                 cmd = instance->cmd_list[i];
4373                 memset(cmd, 0, sizeof(struct megasas_cmd));
4374                 cmd->index = i;
4375                 cmd->scmd = NULL;
4376                 cmd->instance = instance;
4377
4378                 list_add_tail(&cmd->list, &instance->cmd_pool);
4379         }
4380
4381         /*
4382          * Create a frame pool and assign one frame to each cmd
4383          */
4384         if (megasas_create_frame_pool(instance)) {
4385                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error creating frame DMA pool\n");
4386                 megasas_free_cmds(instance);
4387                 return -ENOMEM;
4388         }
4389
4390         return 0;
4391 }
4392
4393 /*
4394  * dcmd_timeout_ocr_possible -  Check if OCR is possible based on Driver/FW state.
4395  * @instance:                           Adapter soft state
4396  *
4397  * Return 0 for only Fusion adapter, if driver load/unload is not in progress
4398  * or FW is not under OCR.
4399  */
4400 inline int
4401 dcmd_timeout_ocr_possible(struct megasas_instance *instance) {
4402
4403         if (instance->adapter_type == MFI_SERIES)
4404                 return KILL_ADAPTER;
4405         else if (instance->unload ||
4406                         test_bit(MEGASAS_FUSION_OCR_NOT_POSSIBLE,
4407                                  &instance->reset_flags))
4408                 return IGNORE_TIMEOUT;
4409         else
4410                 return INITIATE_OCR;
4411 }
4412
4413 static void
4414 megasas_get_pd_info(struct megasas_instance *instance, struct scsi_device *sdev)
4415 {
4416         int ret;
4417         struct megasas_cmd *cmd;
4418         struct megasas_dcmd_frame *dcmd;
4419
4420         struct MR_PRIV_DEVICE *mr_device_priv_data;
4421         u16 device_id = 0;
4422
4423         device_id = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) + sdev->id;
4424         cmd = megasas_get_cmd(instance);
4425
4426         if (!cmd) {
4427                 dev_err(&instance->pdev->dev, "Failed to get cmd %s\n", __func__);
4428                 return;
4429         }
4430
4431         dcmd = &cmd->frame->dcmd;
4432
4433         memset(instance->pd_info, 0, sizeof(*instance->pd_info));
4434         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4435
4436         dcmd->mbox.s[0] = cpu_to_le16(device_id);
4437         dcmd->cmd = MFI_CMD_DCMD;
4438         dcmd->cmd_status = 0xFF;
4439         dcmd->sge_count = 1;
4440         dcmd->flags = MFI_FRAME_DIR_READ;
4441         dcmd->timeout = 0;
4442         dcmd->pad_0 = 0;
4443         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_PD_INFO));
4444         dcmd->opcode = cpu_to_le32(MR_DCMD_PD_GET_INFO);
4445
4446         megasas_set_dma_settings(instance, dcmd, instance->pd_info_h,
4447                                  sizeof(struct MR_PD_INFO));
4448
4449         if ((instance->adapter_type != MFI_SERIES) &&
4450             !instance->mask_interrupts)
4451                 ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
4452         else
4453                 ret = megasas_issue_polled(instance, cmd);
4454
4455         switch (ret) {
4456         case DCMD_SUCCESS:
4457                 mr_device_priv_data = sdev->hostdata;
4458                 le16_to_cpus((u16 *)&instance->pd_info->state.ddf.pdType);
4459                 mr_device_priv_data->interface_type =
4460                                 instance->pd_info->state.ddf.pdType.intf;
4461                 break;
4462
4463         case DCMD_TIMEOUT:
4464
4465                 switch (dcmd_timeout_ocr_possible(instance)) {
4466                 case INITIATE_OCR:
4467                         cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4468                         mutex_unlock(&instance->reset_mutex);
4469                         megasas_reset_fusion(instance->host,
4470                                 MFI_IO_TIMEOUT_OCR);
4471                         mutex_lock(&instance->reset_mutex);
4472                         break;
4473                 case KILL_ADAPTER:
4474                         megaraid_sas_kill_hba(instance);
4475                         break;
4476                 case IGNORE_TIMEOUT:
4477                         dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4478                                 __func__, __LINE__);
4479                         break;
4480                 }
4481
4482                 break;
4483         }
4484
4485         if (ret != DCMD_TIMEOUT)
4486                 megasas_return_cmd(instance, cmd);
4487
4488         return;
4489 }
4490 /*
4491  * megasas_get_pd_list_info -   Returns FW's pd_list structure
4492  * @instance:                           Adapter soft state
4493  * @pd_list:                            pd_list structure
4494  *
4495  * Issues an internal command (DCMD) to get the FW's controller PD
4496  * list structure.  This information is mainly used to find out SYSTEM
4497  * supported by the FW.
4498  */
4499 static int
4500 megasas_get_pd_list(struct megasas_instance *instance)
4501 {
4502         int ret = 0, pd_index = 0;
4503         struct megasas_cmd *cmd;
4504         struct megasas_dcmd_frame *dcmd;
4505         struct MR_PD_LIST *ci;
4506         struct MR_PD_ADDRESS *pd_addr;
4507
4508         if (instance->pd_list_not_supported) {
4509                 dev_info(&instance->pdev->dev, "MR_DCMD_PD_LIST_QUERY "
4510                 "not supported by firmware\n");
4511                 return ret;
4512         }
4513
4514         ci = instance->pd_list_buf;
4515
4516         cmd = megasas_get_cmd(instance);
4517
4518         if (!cmd) {
4519                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "(get_pd_list): Failed to get cmd\n");
4520                 return -ENOMEM;
4521         }
4522
4523         dcmd = &cmd->frame->dcmd;
4524
4525         memset(ci, 0, sizeof(*ci));
4526         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4527
4528         dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
4529         dcmd->mbox.b[1] = 0;
4530         dcmd->cmd = MFI_CMD_DCMD;
4531         dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
4532         dcmd->sge_count = 1;
4533         dcmd->flags = MFI_FRAME_DIR_READ;
4534         dcmd->timeout = 0;
4535         dcmd->pad_0 = 0;
4536         dcmd->data_xfer_len = cpu_to_le32(MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST));
4537         dcmd->opcode = cpu_to_le32(MR_DCMD_PD_LIST_QUERY);
4538
4539         megasas_set_dma_settings(instance, dcmd, instance->pd_list_buf_h,
4540                                  (MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST)));
4541
4542         if ((instance->adapter_type != MFI_SERIES) &&
4543             !instance->mask_interrupts)
4544                 ret = megasas_issue_blocked_cmd(instance, cmd,
4545                         MFI_IO_TIMEOUT_SECS);
4546         else
4547                 ret = megasas_issue_polled(instance, cmd);
4548
4549         switch (ret) {
4550         case DCMD_FAILED:
4551                 dev_info(&instance->pdev->dev, "MR_DCMD_PD_LIST_QUERY "
4552                         "failed/not supported by firmware\n");
4553
4554                 if (instance->adapter_type != MFI_SERIES)
4555                         megaraid_sas_kill_hba(instance);
4556                 else
4557                         instance->pd_list_not_supported = 1;
4558                 break;
4559         case DCMD_TIMEOUT:
4560
4561                 switch (dcmd_timeout_ocr_possible(instance)) {
4562                 case INITIATE_OCR:
4563                         cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4564                         /*
4565                          * DCMD failed from AEN path.
4566                          * AEN path already hold reset_mutex to avoid PCI access
4567                          * while OCR is in progress.
4568                          */
4569                         mutex_unlock(&instance->reset_mutex);
4570                         megasas_reset_fusion(instance->host,
4571                                                 MFI_IO_TIMEOUT_OCR);
4572                         mutex_lock(&instance->reset_mutex);
4573                         break;
4574                 case KILL_ADAPTER:
4575                         megaraid_sas_kill_hba(instance);
4576                         break;
4577                 case IGNORE_TIMEOUT:
4578                         dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d \n",
4579                                 __func__, __LINE__);
4580                         break;
4581                 }
4582
4583                 break;
4584
4585         case DCMD_SUCCESS:
4586                 pd_addr = ci->addr;
4587                 if (megasas_dbg_lvl & LD_PD_DEBUG)
4588                         dev_info(&instance->pdev->dev, "%s, sysPD count: 0x%x\n",
4589                                  __func__, le32_to_cpu(ci->count));
4590
4591                 if ((le32_to_cpu(ci->count) >
4592                         (MEGASAS_MAX_PD_CHANNELS * MEGASAS_MAX_DEV_PER_CHANNEL)))
4593                         break;
4594
4595                 memset(instance->local_pd_list, 0,
4596                                 MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
4597
4598                 for (pd_index = 0; pd_index < le32_to_cpu(ci->count); pd_index++) {
4599                         instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].tid     =
4600                                         le16_to_cpu(pd_addr->deviceId);
4601                         instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveType       =
4602                                         pd_addr->scsiDevType;
4603                         instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveState      =
4604                                         MR_PD_STATE_SYSTEM;
4605                         if (megasas_dbg_lvl & LD_PD_DEBUG)
4606                                 dev_info(&instance->pdev->dev,
4607                                          "PD%d: targetID: 0x%03x deviceType:0x%x\n",
4608                                          pd_index, le16_to_cpu(pd_addr->deviceId),
4609                                          pd_addr->scsiDevType);
4610                         pd_addr++;
4611                 }
4612
4613                 memcpy(instance->pd_list, instance->local_pd_list,
4614                         sizeof(instance->pd_list));
4615                 break;
4616
4617         }
4618
4619         if (ret != DCMD_TIMEOUT)
4620                 megasas_return_cmd(instance, cmd);
4621
4622         return ret;
4623 }
4624
4625 /*
4626  * megasas_get_ld_list_info -   Returns FW's ld_list structure
4627  * @instance:                           Adapter soft state
4628  * @ld_list:                            ld_list structure
4629  *
4630  * Issues an internal command (DCMD) to get the FW's controller PD
4631  * list structure.  This information is mainly used to find out SYSTEM
4632  * supported by the FW.
4633  */
4634 static int
4635 megasas_get_ld_list(struct megasas_instance *instance)
4636 {
4637         int ret = 0, ld_index = 0, ids = 0;
4638         struct megasas_cmd *cmd;
4639         struct megasas_dcmd_frame *dcmd;
4640         struct MR_LD_LIST *ci;
4641         dma_addr_t ci_h = 0;
4642         u32 ld_count;
4643
4644         ci = instance->ld_list_buf;
4645         ci_h = instance->ld_list_buf_h;
4646
4647         cmd = megasas_get_cmd(instance);
4648
4649         if (!cmd) {
4650                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "megasas_get_ld_list: Failed to get cmd\n");
4651                 return -ENOMEM;
4652         }
4653
4654         dcmd = &cmd->frame->dcmd;
4655
4656         memset(ci, 0, sizeof(*ci));
4657         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4658
4659         if (instance->supportmax256vd)
4660                 dcmd->mbox.b[0] = 1;
4661         dcmd->cmd = MFI_CMD_DCMD;
4662         dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
4663         dcmd->sge_count = 1;
4664         dcmd->flags = MFI_FRAME_DIR_READ;
4665         dcmd->timeout = 0;
4666         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_LIST));
4667         dcmd->opcode = cpu_to_le32(MR_DCMD_LD_GET_LIST);
4668         dcmd->pad_0  = 0;
4669
4670         megasas_set_dma_settings(instance, dcmd, ci_h,
4671                                  sizeof(struct MR_LD_LIST));
4672
4673         if ((instance->adapter_type != MFI_SERIES) &&
4674             !instance->mask_interrupts)
4675                 ret = megasas_issue_blocked_cmd(instance, cmd,
4676                         MFI_IO_TIMEOUT_SECS);
4677         else
4678                 ret = megasas_issue_polled(instance, cmd);
4679
4680         ld_count = le32_to_cpu(ci->ldCount);
4681
4682         switch (ret) {
4683         case DCMD_FAILED:
4684                 megaraid_sas_kill_hba(instance);
4685                 break;
4686         case DCMD_TIMEOUT:
4687
4688                 switch (dcmd_timeout_ocr_possible(instance)) {
4689                 case INITIATE_OCR:
4690                         cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4691                         /*
4692                          * DCMD failed from AEN path.
4693                          * AEN path already hold reset_mutex to avoid PCI access
4694                          * while OCR is in progress.
4695                          */
4696                         mutex_unlock(&instance->reset_mutex);
4697                         megasas_reset_fusion(instance->host,
4698                                                 MFI_IO_TIMEOUT_OCR);
4699                         mutex_lock(&instance->reset_mutex);
4700                         break;
4701                 case KILL_ADAPTER:
4702                         megaraid_sas_kill_hba(instance);
4703                         break;
4704                 case IGNORE_TIMEOUT:
4705                         dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4706                                 __func__, __LINE__);
4707                         break;
4708                 }
4709
4710                 break;
4711
4712         case DCMD_SUCCESS:
4713                 if (megasas_dbg_lvl & LD_PD_DEBUG)
4714                         dev_info(&instance->pdev->dev, "%s, LD count: 0x%x\n",
4715                                  __func__, ld_count);
4716
4717                 if (ld_count > instance->fw_supported_vd_count)
4718                         break;
4719
4720                 memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT);
4721
4722                 for (ld_index = 0; ld_index < ld_count; ld_index++) {
4723                         if (ci->ldList[ld_index].state != 0) {
4724                                 ids = ci->ldList[ld_index].ref.targetId;
4725                                 instance->ld_ids[ids] = ci->ldList[ld_index].ref.targetId;
4726                                 if (megasas_dbg_lvl & LD_PD_DEBUG)
4727                                         dev_info(&instance->pdev->dev,
4728                                                  "LD%d: targetID: 0x%03x\n",
4729                                                  ld_index, ids);
4730                         }
4731                 }
4732
4733                 break;
4734         }
4735
4736         if (ret != DCMD_TIMEOUT)
4737                 megasas_return_cmd(instance, cmd);
4738
4739         return ret;
4740 }
4741
4742 /**
4743  * megasas_ld_list_query -      Returns FW's ld_list structure
4744  * @instance:                           Adapter soft state
4745  * @ld_list:                            ld_list structure
4746  *
4747  * Issues an internal command (DCMD) to get the FW's controller PD
4748  * list structure.  This information is mainly used to find out SYSTEM
4749  * supported by the FW.
4750  */
4751 static int
4752 megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
4753 {
4754         int ret = 0, ld_index = 0, ids = 0;
4755         struct megasas_cmd *cmd;
4756         struct megasas_dcmd_frame *dcmd;
4757         struct MR_LD_TARGETID_LIST *ci;
4758         dma_addr_t ci_h = 0;
4759         u32 tgtid_count;
4760
4761         ci = instance->ld_targetid_list_buf;
4762         ci_h = instance->ld_targetid_list_buf_h;
4763
4764         cmd = megasas_get_cmd(instance);
4765
4766         if (!cmd) {
4767                 dev_warn(&instance->pdev->dev,
4768                          "megasas_ld_list_query: Failed to get cmd\n");
4769                 return -ENOMEM;
4770         }
4771
4772         dcmd = &cmd->frame->dcmd;
4773
4774         memset(ci, 0, sizeof(*ci));
4775         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4776
4777         dcmd->mbox.b[0] = query_type;
4778         if (instance->supportmax256vd)
4779                 dcmd->mbox.b[2] = 1;
4780
4781         dcmd->cmd = MFI_CMD_DCMD;
4782         dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
4783         dcmd->sge_count = 1;
4784         dcmd->flags = MFI_FRAME_DIR_READ;
4785         dcmd->timeout = 0;
4786         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST));
4787         dcmd->opcode = cpu_to_le32(MR_DCMD_LD_LIST_QUERY);
4788         dcmd->pad_0  = 0;
4789
4790         megasas_set_dma_settings(instance, dcmd, ci_h,
4791                                  sizeof(struct MR_LD_TARGETID_LIST));
4792
4793         if ((instance->adapter_type != MFI_SERIES) &&
4794             !instance->mask_interrupts)
4795                 ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
4796         else
4797                 ret = megasas_issue_polled(instance, cmd);
4798
4799         switch (ret) {
4800         case DCMD_FAILED:
4801                 dev_info(&instance->pdev->dev,
4802                         "DCMD not supported by firmware - %s %d\n",
4803                                 __func__, __LINE__);
4804                 ret = megasas_get_ld_list(instance);
4805                 break;
4806         case DCMD_TIMEOUT:
4807                 switch (dcmd_timeout_ocr_possible(instance)) {
4808                 case INITIATE_OCR:
4809                         cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4810                         /*
4811                          * DCMD failed from AEN path.
4812                          * AEN path already hold reset_mutex to avoid PCI access
4813                          * while OCR is in progress.
4814                          */
4815                         mutex_unlock(&instance->reset_mutex);
4816                         megasas_reset_fusion(instance->host,
4817                                                 MFI_IO_TIMEOUT_OCR);
4818                         mutex_lock(&instance->reset_mutex);
4819                         break;
4820                 case KILL_ADAPTER:
4821                         megaraid_sas_kill_hba(instance);
4822                         break;
4823                 case IGNORE_TIMEOUT:
4824                         dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4825                                 __func__, __LINE__);
4826                         break;
4827                 }
4828
4829                 break;
4830         case DCMD_SUCCESS:
4831                 tgtid_count = le32_to_cpu(ci->count);
4832
4833                 if (megasas_dbg_lvl & LD_PD_DEBUG)
4834                         dev_info(&instance->pdev->dev, "%s, LD count: 0x%x\n",
4835                                  __func__, tgtid_count);
4836
4837                 if ((tgtid_count > (instance->fw_supported_vd_count)))
4838                         break;
4839
4840                 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
4841                 for (ld_index = 0; ld_index < tgtid_count; ld_index++) {
4842                         ids = ci->targetId[ld_index];
4843                         instance->ld_ids[ids] = ci->targetId[ld_index];
4844                         if (megasas_dbg_lvl & LD_PD_DEBUG)
4845                                 dev_info(&instance->pdev->dev, "LD%d: targetID: 0x%03x\n",
4846                                          ld_index, ci->targetId[ld_index]);
4847                 }
4848
4849                 break;
4850         }
4851
4852         if (ret != DCMD_TIMEOUT)
4853                 megasas_return_cmd(instance, cmd);
4854
4855         return ret;
4856 }
4857
4858 /**
4859  * dcmd.opcode            - MR_DCMD_CTRL_DEVICE_LIST_GET
4860  * dcmd.mbox              - reserved
4861  * dcmd.sge IN            - ptr to return MR_HOST_DEVICE_LIST structure
4862  * Desc:    This DCMD will return the combined device list
4863  * Status:  MFI_STAT_OK - List returned successfully
4864  *          MFI_STAT_INVALID_CMD - Firmware support for the feature has been
4865  *                                 disabled
4866  * @instance:                   Adapter soft state
4867  * @is_probe:                   Driver probe check
4868  * Return:                      0 if DCMD succeeded
4869  *                               non-zero if failed
4870  */
4871 static int
4872 megasas_host_device_list_query(struct megasas_instance *instance,
4873                                bool is_probe)
4874 {
4875         int ret, i, target_id;
4876         struct megasas_cmd *cmd;
4877         struct megasas_dcmd_frame *dcmd;
4878         struct MR_HOST_DEVICE_LIST *ci;
4879         u32 count;
4880         dma_addr_t ci_h;
4881
4882         ci = instance->host_device_list_buf;
4883         ci_h = instance->host_device_list_buf_h;
4884
4885         cmd = megasas_get_cmd(instance);
4886
4887         if (!cmd) {
4888                 dev_warn(&instance->pdev->dev,
4889                          "%s: failed to get cmd\n",
4890                          __func__);
4891                 return -ENOMEM;
4892         }
4893
4894         dcmd = &cmd->frame->dcmd;
4895
4896         memset(ci, 0, sizeof(*ci));
4897         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4898
4899         dcmd->mbox.b[0] = is_probe ? 0 : 1;
4900         dcmd->cmd = MFI_CMD_DCMD;
4901         dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
4902         dcmd->sge_count = 1;
4903         dcmd->flags = MFI_FRAME_DIR_READ;
4904         dcmd->timeout = 0;
4905         dcmd->pad_0 = 0;
4906         dcmd->data_xfer_len = cpu_to_le32(HOST_DEVICE_LIST_SZ);
4907         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_DEVICE_LIST_GET);
4908
4909         megasas_set_dma_settings(instance, dcmd, ci_h, HOST_DEVICE_LIST_SZ);
4910
4911         if (!instance->mask_interrupts) {
4912                 ret = megasas_issue_blocked_cmd(instance, cmd,
4913                                                 MFI_IO_TIMEOUT_SECS);
4914         } else {
4915                 ret = megasas_issue_polled(instance, cmd);
4916                 cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4917         }
4918
4919         switch (ret) {
4920         case DCMD_SUCCESS:
4921                 /* Fill the internal pd_list and ld_ids array based on
4922                  * targetIds returned by FW
4923                  */
4924                 count = le32_to_cpu(ci->count);
4925
4926                 if (count > (MEGASAS_MAX_PD + MAX_LOGICAL_DRIVES_EXT))
4927                         break;
4928
4929                 if (megasas_dbg_lvl & LD_PD_DEBUG)
4930                         dev_info(&instance->pdev->dev, "%s, Device count: 0x%x\n",
4931                                  __func__, count);
4932
4933                 memset(instance->local_pd_list, 0,
4934                        MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
4935                 memset(instance->ld_ids, 0xff, MAX_LOGICAL_DRIVES_EXT);
4936                 for (i = 0; i < count; i++) {
4937                         target_id = le16_to_cpu(ci->host_device_list[i].target_id);
4938                         if (ci->host_device_list[i].flags.u.bits.is_sys_pd) {
4939                                 instance->local_pd_list[target_id].tid = target_id;
4940                                 instance->local_pd_list[target_id].driveType =
4941                                                 ci->host_device_list[i].scsi_type;
4942                                 instance->local_pd_list[target_id].driveState =
4943                                                 MR_PD_STATE_SYSTEM;
4944                                 if (megasas_dbg_lvl & LD_PD_DEBUG)
4945                                         dev_info(&instance->pdev->dev,
4946                                                  "Device %d: PD targetID: 0x%03x deviceType:0x%x\n",
4947                                                  i, target_id, ci->host_device_list[i].scsi_type);
4948                         } else {
4949                                 instance->ld_ids[target_id] = target_id;
4950                                 if (megasas_dbg_lvl & LD_PD_DEBUG)
4951                                         dev_info(&instance->pdev->dev,
4952                                                  "Device %d: LD targetID: 0x%03x\n",
4953                                                  i, target_id);
4954                         }
4955                 }
4956
4957                 memcpy(instance->pd_list, instance->local_pd_list,
4958                        sizeof(instance->pd_list));
4959                 break;
4960
4961         case DCMD_TIMEOUT:
4962                 switch (dcmd_timeout_ocr_possible(instance)) {
4963                 case INITIATE_OCR:
4964                         cmd->flags |= DRV_DCMD_SKIP_REFIRE;
4965                         mutex_unlock(&instance->reset_mutex);
4966                         megasas_reset_fusion(instance->host,
4967                                 MFI_IO_TIMEOUT_OCR);
4968                         mutex_lock(&instance->reset_mutex);
4969                         break;
4970                 case KILL_ADAPTER:
4971                         megaraid_sas_kill_hba(instance);
4972                         break;
4973                 case IGNORE_TIMEOUT:
4974                         dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
4975                                  __func__, __LINE__);
4976                         break;
4977                 }
4978                 break;
4979         case DCMD_FAILED:
4980                 dev_err(&instance->pdev->dev,
4981                         "%s: MR_DCMD_CTRL_DEVICE_LIST_GET failed\n",
4982                         __func__);
4983                 break;
4984         }
4985
4986         if (ret != DCMD_TIMEOUT)
4987                 megasas_return_cmd(instance, cmd);
4988
4989         return ret;
4990 }
4991
4992 /*
4993  * megasas_update_ext_vd_details : Update details w.r.t Extended VD
4994  * instance                      : Controller's instance
4995 */
4996 static void megasas_update_ext_vd_details(struct megasas_instance *instance)
4997 {
4998         struct fusion_context *fusion;
4999         u32 ventura_map_sz = 0;
5000
5001         fusion = instance->ctrl_context;
5002         /* For MFI based controllers return dummy success */
5003         if (!fusion)
5004                 return;
5005
5006         instance->supportmax256vd =
5007                 instance->ctrl_info_buf->adapterOperations3.supportMaxExtLDs;
5008         /* Below is additional check to address future FW enhancement */
5009         if (instance->ctrl_info_buf->max_lds > 64)
5010                 instance->supportmax256vd = 1;
5011
5012         instance->drv_supported_vd_count = MEGASAS_MAX_LD_CHANNELS
5013                                         * MEGASAS_MAX_DEV_PER_CHANNEL;
5014         instance->drv_supported_pd_count = MEGASAS_MAX_PD_CHANNELS
5015                                         * MEGASAS_MAX_DEV_PER_CHANNEL;
5016         if (instance->supportmax256vd) {
5017                 instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES_EXT;
5018                 instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
5019         } else {
5020                 instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
5021                 instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
5022         }
5023
5024         dev_info(&instance->pdev->dev,
5025                 "FW provided supportMaxExtLDs: %d\tmax_lds: %d\n",
5026                 instance->ctrl_info_buf->adapterOperations3.supportMaxExtLDs ? 1 : 0,
5027                 instance->ctrl_info_buf->max_lds);
5028
5029         if (instance->max_raid_mapsize) {
5030                 ventura_map_sz = instance->max_raid_mapsize *
5031                                                 MR_MIN_MAP_SIZE; /* 64k */
5032                 fusion->current_map_sz = ventura_map_sz;
5033                 fusion->max_map_sz = ventura_map_sz;
5034         } else {
5035                 fusion->old_map_sz =  sizeof(struct MR_FW_RAID_MAP) +
5036                                         (sizeof(struct MR_LD_SPAN_MAP) *
5037                                         (instance->fw_supported_vd_count - 1));
5038                 fusion->new_map_sz =  sizeof(struct MR_FW_RAID_MAP_EXT);
5039
5040                 fusion->max_map_sz =
5041                         max(fusion->old_map_sz, fusion->new_map_sz);
5042
5043                 if (instance->supportmax256vd)
5044                         fusion->current_map_sz = fusion->new_map_sz;
5045                 else
5046                         fusion->current_map_sz = fusion->old_map_sz;
5047         }
5048         /* irrespective of FW raid maps, driver raid map is constant */
5049         fusion->drv_map_sz = sizeof(struct MR_DRV_RAID_MAP_ALL);
5050 }
5051
5052 /*
5053  * dcmd.opcode                - MR_DCMD_CTRL_SNAPDUMP_GET_PROPERTIES
5054  * dcmd.hdr.length            - number of bytes to read
5055  * dcmd.sge                   - Ptr to MR_SNAPDUMP_PROPERTIES
5056  * Desc:                         Fill in snapdump properties
5057  * Status:                       MFI_STAT_OK- Command successful
5058  */
5059 void megasas_get_snapdump_properties(struct megasas_instance *instance)
5060 {
5061         int ret = 0;
5062         struct megasas_cmd *cmd;
5063         struct megasas_dcmd_frame *dcmd;
5064         struct MR_SNAPDUMP_PROPERTIES *ci;
5065         dma_addr_t ci_h = 0;
5066
5067         ci = instance->snapdump_prop;
5068         ci_h = instance->snapdump_prop_h;
5069
5070         if (!ci)
5071                 return;
5072
5073         cmd = megasas_get_cmd(instance);
5074
5075         if (!cmd) {
5076                 dev_dbg(&instance->pdev->dev, "Failed to get a free cmd\n");
5077                 return;
5078         }
5079
5080         dcmd = &cmd->frame->dcmd;
5081
5082         memset(ci, 0, sizeof(*ci));
5083         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5084
5085         dcmd->cmd = MFI_CMD_DCMD;
5086         dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
5087         dcmd->sge_count = 1;
5088         dcmd->flags = MFI_FRAME_DIR_READ;
5089         dcmd->timeout = 0;
5090         dcmd->pad_0 = 0;
5091         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_SNAPDUMP_PROPERTIES));
5092         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_SNAPDUMP_GET_PROPERTIES);
5093
5094         megasas_set_dma_settings(instance, dcmd, ci_h,
5095                                  sizeof(struct MR_SNAPDUMP_PROPERTIES));
5096
5097         if (!instance->mask_interrupts) {
5098                 ret = megasas_issue_blocked_cmd(instance, cmd,
5099                                                 MFI_IO_TIMEOUT_SECS);
5100         } else {
5101                 ret = megasas_issue_polled(instance, cmd);
5102                 cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5103         }
5104
5105         switch (ret) {
5106         case DCMD_SUCCESS:
5107                 instance->snapdump_wait_time =
5108                         min_t(u8, ci->trigger_min_num_sec_before_ocr,
5109                                 MEGASAS_MAX_SNAP_DUMP_WAIT_TIME);
5110                 break;
5111
5112         case DCMD_TIMEOUT:
5113                 switch (dcmd_timeout_ocr_possible(instance)) {
5114                 case INITIATE_OCR:
5115                         cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5116                         mutex_unlock(&instance->reset_mutex);
5117                         megasas_reset_fusion(instance->host,
5118                                 MFI_IO_TIMEOUT_OCR);
5119                         mutex_lock(&instance->reset_mutex);
5120                         break;
5121                 case KILL_ADAPTER:
5122                         megaraid_sas_kill_hba(instance);
5123                         break;
5124                 case IGNORE_TIMEOUT:
5125                         dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5126                                 __func__, __LINE__);
5127                         break;
5128                 }
5129         }
5130
5131         if (ret != DCMD_TIMEOUT)
5132                 megasas_return_cmd(instance, cmd);
5133 }
5134
5135 /**
5136  * megasas_get_controller_info -        Returns FW's controller structure
5137  * @instance:                           Adapter soft state
5138  *
5139  * Issues an internal command (DCMD) to get the FW's controller structure.
5140  * This information is mainly used to find out the maximum IO transfer per
5141  * command supported by the FW.
5142  */
5143 int
5144 megasas_get_ctrl_info(struct megasas_instance *instance)
5145 {
5146         int ret = 0;
5147         struct megasas_cmd *cmd;
5148         struct megasas_dcmd_frame *dcmd;
5149         struct megasas_ctrl_info *ci;
5150         dma_addr_t ci_h = 0;
5151
5152         ci = instance->ctrl_info_buf;
5153         ci_h = instance->ctrl_info_buf_h;
5154
5155         cmd = megasas_get_cmd(instance);
5156
5157         if (!cmd) {
5158                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a free cmd\n");
5159                 return -ENOMEM;
5160         }
5161
5162         dcmd = &cmd->frame->dcmd;
5163
5164         memset(ci, 0, sizeof(*ci));
5165         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5166
5167         dcmd->cmd = MFI_CMD_DCMD;
5168         dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
5169         dcmd->sge_count = 1;
5170         dcmd->flags = MFI_FRAME_DIR_READ;
5171         dcmd->timeout = 0;
5172         dcmd->pad_0 = 0;
5173         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_ctrl_info));
5174         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_GET_INFO);
5175         dcmd->mbox.b[0] = 1;
5176
5177         megasas_set_dma_settings(instance, dcmd, ci_h,
5178                                  sizeof(struct megasas_ctrl_info));
5179
5180         if ((instance->adapter_type != MFI_SERIES) &&
5181             !instance->mask_interrupts) {
5182                 ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
5183         } else {
5184                 ret = megasas_issue_polled(instance, cmd);
5185                 cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5186         }
5187
5188         switch (ret) {
5189         case DCMD_SUCCESS:
5190                 /* Save required controller information in
5191                  * CPU endianness format.
5192                  */
5193                 le32_to_cpus((u32 *)&ci->properties.OnOffProperties);
5194                 le16_to_cpus((u16 *)&ci->properties.on_off_properties2);
5195                 le32_to_cpus((u32 *)&ci->adapterOperations2);
5196                 le32_to_cpus((u32 *)&ci->adapterOperations3);
5197                 le16_to_cpus((u16 *)&ci->adapter_operations4);
5198                 le32_to_cpus((u32 *)&ci->adapter_operations5);
5199
5200                 /* Update the latest Ext VD info.
5201                  * From Init path, store current firmware details.
5202                  * From OCR path, detect any firmware properties changes.
5203                  * in case of Firmware upgrade without system reboot.
5204                  */
5205                 megasas_update_ext_vd_details(instance);
5206                 instance->support_seqnum_jbod_fp =
5207                         ci->adapterOperations3.useSeqNumJbodFP;
5208                 instance->support_morethan256jbod =
5209                         ci->adapter_operations4.support_pd_map_target_id;
5210                 instance->support_nvme_passthru =
5211                         ci->adapter_operations4.support_nvme_passthru;
5212                 instance->support_pci_lane_margining =
5213                         ci->adapter_operations5.support_pci_lane_margining;
5214                 instance->task_abort_tmo = ci->TaskAbortTO;
5215                 instance->max_reset_tmo = ci->MaxResetTO;
5216
5217                 /*Check whether controller is iMR or MR */
5218                 instance->is_imr = (ci->memory_size ? 0 : 1);
5219
5220                 instance->snapdump_wait_time =
5221                         (ci->properties.on_off_properties2.enable_snap_dump ?
5222                          MEGASAS_DEFAULT_SNAP_DUMP_WAIT_TIME : 0);
5223
5224                 instance->enable_fw_dev_list =
5225                         ci->properties.on_off_properties2.enable_fw_dev_list;
5226
5227                 dev_info(&instance->pdev->dev,
5228                         "controller type\t: %s(%dMB)\n",
5229                         instance->is_imr ? "iMR" : "MR",
5230                         le16_to_cpu(ci->memory_size));
5231
5232                 instance->disableOnlineCtrlReset =
5233                         ci->properties.OnOffProperties.disableOnlineCtrlReset;
5234                 instance->secure_jbod_support =
5235                         ci->adapterOperations3.supportSecurityonJBOD;
5236                 dev_info(&instance->pdev->dev, "Online Controller Reset(OCR)\t: %s\n",
5237                         instance->disableOnlineCtrlReset ? "Disabled" : "Enabled");
5238                 dev_info(&instance->pdev->dev, "Secure JBOD support\t: %s\n",
5239                         instance->secure_jbod_support ? "Yes" : "No");
5240                 dev_info(&instance->pdev->dev, "NVMe passthru support\t: %s\n",
5241                          instance->support_nvme_passthru ? "Yes" : "No");
5242                 dev_info(&instance->pdev->dev,
5243                          "FW provided TM TaskAbort/Reset timeout\t: %d secs/%d secs\n",
5244                          instance->task_abort_tmo, instance->max_reset_tmo);
5245                 dev_info(&instance->pdev->dev, "JBOD sequence map support\t: %s\n",
5246                          instance->support_seqnum_jbod_fp ? "Yes" : "No");
5247                 dev_info(&instance->pdev->dev, "PCI Lane Margining support\t: %s\n",
5248                          instance->support_pci_lane_margining ? "Yes" : "No");
5249
5250                 break;
5251
5252         case DCMD_TIMEOUT:
5253                 switch (dcmd_timeout_ocr_possible(instance)) {
5254                 case INITIATE_OCR:
5255                         cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5256                         mutex_unlock(&instance->reset_mutex);
5257                         megasas_reset_fusion(instance->host,
5258                                 MFI_IO_TIMEOUT_OCR);
5259                         mutex_lock(&instance->reset_mutex);
5260                         break;
5261                 case KILL_ADAPTER:
5262                         megaraid_sas_kill_hba(instance);
5263                         break;
5264                 case IGNORE_TIMEOUT:
5265                         dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5266                                 __func__, __LINE__);
5267                         break;
5268                 }
5269                 break;
5270         case DCMD_FAILED:
5271                 megaraid_sas_kill_hba(instance);
5272                 break;
5273
5274         }
5275
5276         if (ret != DCMD_TIMEOUT)
5277                 megasas_return_cmd(instance, cmd);
5278
5279         return ret;
5280 }
5281
5282 /*
5283  * megasas_set_crash_dump_params -      Sends address of crash dump DMA buffer
5284  *                                      to firmware
5285  *
5286  * @instance:                           Adapter soft state
5287  * @crash_buf_state             -       tell FW to turn ON/OFF crash dump feature
5288                                         MR_CRASH_BUF_TURN_OFF = 0
5289                                         MR_CRASH_BUF_TURN_ON = 1
5290  * @return 0 on success non-zero on failure.
5291  * Issues an internal command (DCMD) to set parameters for crash dump feature.
5292  * Driver will send address of crash dump DMA buffer and set mbox to tell FW
5293  * that driver supports crash dump feature. This DCMD will be sent only if
5294  * crash dump feature is supported by the FW.
5295  *
5296  */
5297 int megasas_set_crash_dump_params(struct megasas_instance *instance,
5298         u8 crash_buf_state)
5299 {
5300         int ret = 0;
5301         struct megasas_cmd *cmd;
5302         struct megasas_dcmd_frame *dcmd;
5303
5304         cmd = megasas_get_cmd(instance);
5305
5306         if (!cmd) {
5307                 dev_err(&instance->pdev->dev, "Failed to get a free cmd\n");
5308                 return -ENOMEM;
5309         }
5310
5311
5312         dcmd = &cmd->frame->dcmd;
5313
5314         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
5315         dcmd->mbox.b[0] = crash_buf_state;
5316         dcmd->cmd = MFI_CMD_DCMD;
5317         dcmd->cmd_status = MFI_STAT_INVALID_STATUS;
5318         dcmd->sge_count = 1;
5319         dcmd->flags = MFI_FRAME_DIR_NONE;
5320         dcmd->timeout = 0;
5321         dcmd->pad_0 = 0;
5322         dcmd->data_xfer_len = cpu_to_le32(CRASH_DMA_BUF_SIZE);
5323         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_SET_CRASH_DUMP_PARAMS);
5324
5325         megasas_set_dma_settings(instance, dcmd, instance->crash_dump_h,
5326                                  CRASH_DMA_BUF_SIZE);
5327
5328         if ((instance->adapter_type != MFI_SERIES) &&
5329             !instance->mask_interrupts)
5330                 ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
5331         else
5332                 ret = megasas_issue_polled(instance, cmd);
5333
5334         if (ret == DCMD_TIMEOUT) {
5335                 switch (dcmd_timeout_ocr_possible(instance)) {
5336                 case INITIATE_OCR:
5337                         cmd->flags |= DRV_DCMD_SKIP_REFIRE;
5338                         megasas_reset_fusion(instance->host,
5339                                         MFI_IO_TIMEOUT_OCR);
5340                         break;
5341                 case KILL_ADAPTER:
5342                         megaraid_sas_kill_hba(instance);
5343                         break;
5344                 case IGNORE_TIMEOUT:
5345                         dev_info(&instance->pdev->dev, "Ignore DCMD timeout: %s %d\n",
5346                                 __func__, __LINE__);
5347                         break;
5348                 }
5349         } else
5350                 megasas_return_cmd(instance, cmd);
5351
5352         return ret;
5353 }
5354
5355 /**
5356  * megasas_issue_init_mfi -     Initializes the FW
5357  * @instance:           Adapter soft state
5358  *
5359  * Issues the INIT MFI cmd
5360  */
5361 static int
5362 megasas_issue_init_mfi(struct megasas_instance *instance)
5363 {
5364         __le32 context;
5365         struct megasas_cmd *cmd;
5366         struct megasas_init_frame *init_frame;
5367         struct megasas_init_queue_info *initq_info;
5368         dma_addr_t init_frame_h;
5369         dma_addr_t initq_info_h;
5370
5371         /*
5372          * Prepare a init frame. Note the init frame points to queue info
5373          * structure. Each frame has SGL allocated after first 64 bytes. For
5374          * this frame - since we don't need any SGL - we use SGL's space as
5375          * queue info structure
5376          *
5377          * We will not get a NULL command below. We just created the pool.
5378          */
5379         cmd = megasas_get_cmd(instance);
5380
5381         init_frame = (struct megasas_init_frame *)cmd->frame;
5382         initq_info = (struct megasas_init_queue_info *)
5383                 ((unsigned long)init_frame + 64);
5384
5385         init_frame_h = cmd->frame_phys_addr;
5386         initq_info_h = init_frame_h + 64;
5387
5388         context = init_frame->context;
5389         memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
5390         memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
5391         init_frame->context = context;
5392
5393         initq_info->reply_queue_entries = cpu_to_le32(instance->max_fw_cmds + 1);
5394         initq_info->reply_queue_start_phys_addr_lo = cpu_to_le32(instance->reply_queue_h);
5395
5396         initq_info->producer_index_phys_addr_lo = cpu_to_le32(instance->producer_h);
5397         initq_info->consumer_index_phys_addr_lo = cpu_to_le32(instance->consumer_h);
5398
5399         init_frame->cmd = MFI_CMD_INIT;
5400         init_frame->cmd_status = MFI_STAT_INVALID_STATUS;
5401         init_frame->queue_info_new_phys_addr_lo =
5402                 cpu_to_le32(lower_32_bits(initq_info_h));
5403         init_frame->queue_info_new_phys_addr_hi =
5404                 cpu_to_le32(upper_32_bits(initq_info_h));
5405
5406         init_frame->data_xfer_len = cpu_to_le32(sizeof(struct megasas_init_queue_info));
5407
5408         /*
5409          * disable the intr before firing the init frame to FW
5410          */
5411         instance->instancet->disable_intr(instance);
5412
5413         /*
5414          * Issue the init frame in polled mode
5415          */
5416
5417         if (megasas_issue_polled(instance, cmd)) {
5418                 dev_err(&instance->pdev->dev, "Failed to init firmware\n");
5419                 megasas_return_cmd(instance, cmd);
5420                 goto fail_fw_init;
5421         }
5422
5423         megasas_return_cmd(instance, cmd);
5424
5425         return 0;
5426
5427 fail_fw_init:
5428         return -EINVAL;
5429 }
5430
5431 static u32
5432 megasas_init_adapter_mfi(struct megasas_instance *instance)
5433 {
5434         u32 context_sz;
5435         u32 reply_q_sz;
5436
5437         /*
5438          * Get various operational parameters from status register
5439          */
5440         instance->max_fw_cmds = instance->instancet->read_fw_status_reg(instance) & 0x00FFFF;
5441         /*
5442          * Reduce the max supported cmds by 1. This is to ensure that the
5443          * reply_q_sz (1 more than the max cmd that driver may send)
5444          * does not exceed max cmds that the FW can support
5445          */
5446         instance->max_fw_cmds = instance->max_fw_cmds-1;
5447         instance->max_mfi_cmds = instance->max_fw_cmds;
5448         instance->max_num_sge = (instance->instancet->read_fw_status_reg(instance) & 0xFF0000) >>
5449                                         0x10;
5450         /*
5451          * For MFI skinny adapters, MEGASAS_SKINNY_INT_CMDS commands
5452          * are reserved for IOCTL + driver's internal DCMDs.
5453          */
5454         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
5455                 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
5456                 instance->max_scsi_cmds = (instance->max_fw_cmds -
5457                         MEGASAS_SKINNY_INT_CMDS);
5458                 sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS);
5459         } else {
5460                 instance->max_scsi_cmds = (instance->max_fw_cmds -
5461                         MEGASAS_INT_CMDS);
5462                 sema_init(&instance->ioctl_sem, (MEGASAS_MFI_IOCTL_CMDS));
5463         }
5464
5465         instance->cur_can_queue = instance->max_scsi_cmds;
5466         /*
5467          * Create a pool of commands
5468          */
5469         if (megasas_alloc_cmds(instance))
5470                 goto fail_alloc_cmds;
5471
5472         /*
5473          * Allocate memory for reply queue. Length of reply queue should
5474          * be _one_ more than the maximum commands handled by the firmware.
5475          *
5476          * Note: When FW completes commands, it places corresponding contex
5477          * values in this circular reply queue. This circular queue is a fairly
5478          * typical producer-consumer queue. FW is the producer (of completed
5479          * commands) and the driver is the consumer.
5480          */
5481         context_sz = sizeof(u32);
5482         reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
5483
5484         instance->reply_queue = dma_alloc_coherent(&instance->pdev->dev,
5485                         reply_q_sz, &instance->reply_queue_h, GFP_KERNEL);
5486
5487         if (!instance->reply_queue) {
5488                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Out of DMA mem for reply queue\n");
5489                 goto fail_reply_queue;
5490         }
5491
5492         if (megasas_issue_init_mfi(instance))
5493                 goto fail_fw_init;
5494
5495         if (megasas_get_ctrl_info(instance)) {
5496                 dev_err(&instance->pdev->dev, "(%d): Could get controller info "
5497                         "Fail from %s %d\n", instance->unique_id,
5498                         __func__, __LINE__);
5499                 goto fail_fw_init;
5500         }
5501
5502         instance->fw_support_ieee = 0;
5503         instance->fw_support_ieee =
5504                 (instance->instancet->read_fw_status_reg(instance) &
5505                 0x04000000);
5506
5507         dev_notice(&instance->pdev->dev, "megasas_init_mfi: fw_support_ieee=%d",
5508                         instance->fw_support_ieee);
5509
5510         if (instance->fw_support_ieee)
5511                 instance->flag_ieee = 1;
5512
5513         return 0;
5514
5515 fail_fw_init:
5516
5517         dma_free_coherent(&instance->pdev->dev, reply_q_sz,
5518                             instance->reply_queue, instance->reply_queue_h);
5519 fail_reply_queue:
5520         megasas_free_cmds(instance);
5521
5522 fail_alloc_cmds:
5523         return 1;
5524 }
5525
5526 static
5527 void megasas_setup_irq_poll(struct megasas_instance *instance)
5528 {
5529         struct megasas_irq_context *irq_ctx;
5530         u32 count, i;
5531
5532         count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
5533
5534         /* Initialize IRQ poll */
5535         for (i = 0; i < count; i++) {
5536                 irq_ctx = &instance->irq_context[i];
5537                 irq_ctx->os_irq = pci_irq_vector(instance->pdev, i);
5538                 irq_ctx->irq_poll_scheduled = false;
5539                 irq_poll_init(&irq_ctx->irqpoll,
5540                               instance->threshold_reply_count,
5541                               megasas_irqpoll);
5542         }
5543 }
5544
5545 /*
5546  * megasas_setup_irqs_ioapic -          register legacy interrupts.
5547  * @instance:                           Adapter soft state
5548  *
5549  * Do not enable interrupt, only setup ISRs.
5550  *
5551  * Return 0 on success.
5552  */
5553 static int
5554 megasas_setup_irqs_ioapic(struct megasas_instance *instance)
5555 {
5556         struct pci_dev *pdev;
5557
5558         pdev = instance->pdev;
5559         instance->irq_context[0].instance = instance;
5560         instance->irq_context[0].MSIxIndex = 0;
5561         snprintf(instance->irq_context->name, MEGASAS_MSIX_NAME_LEN, "%s%u",
5562                 "megasas", instance->host->host_no);
5563         if (request_irq(pci_irq_vector(pdev, 0),
5564                         instance->instancet->service_isr, IRQF_SHARED,
5565                         instance->irq_context->name, &instance->irq_context[0])) {
5566                 dev_err(&instance->pdev->dev,
5567                                 "Failed to register IRQ from %s %d\n",
5568                                 __func__, __LINE__);
5569                 return -1;
5570         }
5571         instance->perf_mode = MR_LATENCY_PERF_MODE;
5572         instance->low_latency_index_start = 0;
5573         return 0;
5574 }
5575
5576 /**
5577  * megasas_setup_irqs_msix -            register MSI-x interrupts.
5578  * @instance:                           Adapter soft state
5579  * @is_probe:                           Driver probe check
5580  *
5581  * Do not enable interrupt, only setup ISRs.
5582  *
5583  * Return 0 on success.
5584  */
5585 static int
5586 megasas_setup_irqs_msix(struct megasas_instance *instance, u8 is_probe)
5587 {
5588         int i, j;
5589         struct pci_dev *pdev;
5590
5591         pdev = instance->pdev;
5592
5593         /* Try MSI-x */
5594         for (i = 0; i < instance->msix_vectors; i++) {
5595                 instance->irq_context[i].instance = instance;
5596                 instance->irq_context[i].MSIxIndex = i;
5597                 snprintf(instance->irq_context[i].name, MEGASAS_MSIX_NAME_LEN, "%s%u-msix%u",
5598                         "megasas", instance->host->host_no, i);
5599                 if (request_irq(pci_irq_vector(pdev, i),
5600                         instance->instancet->service_isr, 0, instance->irq_context[i].name,
5601                         &instance->irq_context[i])) {
5602                         dev_err(&instance->pdev->dev,
5603                                 "Failed to register IRQ for vector %d.\n", i);
5604                         for (j = 0; j < i; j++)
5605                                 free_irq(pci_irq_vector(pdev, j),
5606                                          &instance->irq_context[j]);
5607                         /* Retry irq register for IO_APIC*/
5608                         instance->msix_vectors = 0;
5609                         instance->msix_load_balance = false;
5610                         if (is_probe) {
5611                                 pci_free_irq_vectors(instance->pdev);
5612                                 return megasas_setup_irqs_ioapic(instance);
5613                         } else {
5614                                 return -1;
5615                         }
5616                 }
5617         }
5618
5619         return 0;
5620 }
5621
5622 /*
5623  * megasas_destroy_irqs-                unregister interrupts.
5624  * @instance:                           Adapter soft state
5625  * return:                              void
5626  */
5627 static void
5628 megasas_destroy_irqs(struct megasas_instance *instance) {
5629
5630         int i;
5631         int count;
5632         struct megasas_irq_context *irq_ctx;
5633
5634         count = instance->msix_vectors > 0 ? instance->msix_vectors : 1;
5635         if (instance->adapter_type != MFI_SERIES) {
5636                 for (i = 0; i < count; i++) {
5637                         irq_ctx = &instance->irq_context[i];
5638                         irq_poll_disable(&irq_ctx->irqpoll);
5639                 }
5640         }
5641
5642         if (instance->msix_vectors)
5643                 for (i = 0; i < instance->msix_vectors; i++) {
5644                         free_irq(pci_irq_vector(instance->pdev, i),
5645                                  &instance->irq_context[i]);
5646                 }
5647         else
5648                 free_irq(pci_irq_vector(instance->pdev, 0),
5649                          &instance->irq_context[0]);
5650 }
5651
5652 /**
5653  * megasas_setup_jbod_map -     setup jbod map for FP seq_number.
5654  * @instance:                           Adapter soft state
5655  * @is_probe:                           Driver probe check
5656  *
5657  * Return 0 on success.
5658  */
5659 void
5660 megasas_setup_jbod_map(struct megasas_instance *instance)
5661 {
5662         int i;
5663         struct fusion_context *fusion = instance->ctrl_context;
5664         u32 pd_seq_map_sz;
5665
5666         pd_seq_map_sz = sizeof(struct MR_PD_CFG_SEQ_NUM_SYNC) +
5667                 (sizeof(struct MR_PD_CFG_SEQ) * (MAX_PHYSICAL_DEVICES - 1));
5668
5669         instance->use_seqnum_jbod_fp =
5670                 instance->support_seqnum_jbod_fp;
5671         if (reset_devices || !fusion ||
5672                 !instance->support_seqnum_jbod_fp) {
5673                 dev_info(&instance->pdev->dev,
5674                         "JBOD sequence map is disabled %s %d\n",
5675                         __func__, __LINE__);
5676                 instance->use_seqnum_jbod_fp = false;
5677                 return;
5678         }
5679
5680         if (fusion->pd_seq_sync[0])
5681                 goto skip_alloc;
5682
5683         for (i = 0; i < JBOD_MAPS_COUNT; i++) {
5684                 fusion->pd_seq_sync[i] = dma_alloc_coherent
5685                         (&instance->pdev->dev, pd_seq_map_sz,
5686                         &fusion->pd_seq_phys[i], GFP_KERNEL);
5687                 if (!fusion->pd_seq_sync[i]) {
5688                         dev_err(&instance->pdev->dev,
5689                                 "Failed to allocate memory from %s %d\n",
5690                                 __func__, __LINE__);
5691                         if (i == 1) {
5692                                 dma_free_coherent(&instance->pdev->dev,
5693                                         pd_seq_map_sz, fusion->pd_seq_sync[0],
5694                                         fusion->pd_seq_phys[0]);
5695                                 fusion->pd_seq_sync[0] = NULL;
5696                         }
5697                         instance->use_seqnum_jbod_fp = false;
5698                         return;
5699                 }
5700         }
5701
5702 skip_alloc:
5703         if (!megasas_sync_pd_seq_num(instance, false) &&
5704                 !megasas_sync_pd_seq_num(instance, true))
5705                 instance->use_seqnum_jbod_fp = true;
5706         else
5707                 instance->use_seqnum_jbod_fp = false;
5708 }
5709
5710 static void megasas_setup_reply_map(struct megasas_instance *instance)
5711 {
5712         const struct cpumask *mask;
5713         unsigned int queue, cpu, low_latency_index_start;
5714
5715         low_latency_index_start = instance->low_latency_index_start;
5716
5717         for (queue = low_latency_index_start; queue < instance->msix_vectors; queue++) {
5718                 mask = pci_irq_get_affinity(instance->pdev, queue);
5719                 if (!mask)
5720                         goto fallback;
5721
5722                 for_each_cpu(cpu, mask)
5723                         instance->reply_map[cpu] = queue;
5724         }
5725         return;
5726
5727 fallback:
5728         queue = low_latency_index_start;
5729         for_each_possible_cpu(cpu) {
5730                 instance->reply_map[cpu] = queue;
5731                 if (queue == (instance->msix_vectors - 1))
5732                         queue = low_latency_index_start;
5733                 else
5734                         queue++;
5735         }
5736 }
5737
5738 /**
5739  * megasas_get_device_list -    Get the PD and LD device list from FW.
5740  * @instance:                   Adapter soft state
5741  * @return:                     Success or failure
5742  *
5743  * Issue DCMDs to Firmware to get the PD and LD list.
5744  * Based on the FW support, driver sends the HOST_DEVICE_LIST or combination
5745  * of PD_LIST/LD_LIST_QUERY DCMDs to get the device list.
5746  */
5747 static
5748 int megasas_get_device_list(struct megasas_instance *instance)
5749 {
5750         memset(instance->pd_list, 0,
5751                (MEGASAS_MAX_PD * sizeof(struct megasas_pd_list)));
5752         memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
5753
5754         if (instance->enable_fw_dev_list) {
5755                 if (megasas_host_device_list_query(instance, true))
5756                         return FAILED;
5757         } else {
5758                 if (megasas_get_pd_list(instance) < 0) {
5759                         dev_err(&instance->pdev->dev, "failed to get PD list\n");
5760                         return FAILED;
5761                 }
5762
5763                 if (megasas_ld_list_query(instance,
5764                                           MR_LD_QUERY_TYPE_EXPOSED_TO_HOST)) {
5765                         dev_err(&instance->pdev->dev, "failed to get LD list\n");
5766                         return FAILED;
5767                 }
5768         }
5769
5770         return SUCCESS;
5771 }
5772
5773 /**
5774  * megasas_set_high_iops_queue_affinity_hint -  Set affinity hint for high IOPS queues
5775  * @instance:                                   Adapter soft state
5776  * return:                                      void
5777  */
5778 static inline void
5779 megasas_set_high_iops_queue_affinity_hint(struct megasas_instance *instance)
5780 {
5781         int i;
5782         int local_numa_node;
5783
5784         if (instance->perf_mode == MR_BALANCED_PERF_MODE) {
5785                 local_numa_node = dev_to_node(&instance->pdev->dev);
5786
5787                 for (i = 0; i < instance->low_latency_index_start; i++)
5788                         irq_set_affinity_hint(pci_irq_vector(instance->pdev, i),
5789                                 cpumask_of_node(local_numa_node));
5790         }
5791 }
5792
5793 static int
5794 __megasas_alloc_irq_vectors(struct megasas_instance *instance)
5795 {
5796         int i, irq_flags;
5797         struct irq_affinity desc = { .pre_vectors = instance->low_latency_index_start };
5798         struct irq_affinity *descp = &desc;
5799
5800         irq_flags = PCI_IRQ_MSIX;
5801
5802         if (instance->smp_affinity_enable)
5803                 irq_flags |= PCI_IRQ_AFFINITY;
5804         else
5805                 descp = NULL;
5806
5807         i = pci_alloc_irq_vectors_affinity(instance->pdev,
5808                 instance->low_latency_index_start,
5809                 instance->msix_vectors, irq_flags, descp);
5810
5811         return i;
5812 }
5813
5814 /**
5815  * megasas_alloc_irq_vectors -  Allocate IRQ vectors/enable MSI-x vectors
5816  * @instance:                   Adapter soft state
5817  * return:                      void
5818  */
5819 static void
5820 megasas_alloc_irq_vectors(struct megasas_instance *instance)
5821 {
5822         int i;
5823         unsigned int num_msix_req;
5824
5825         i = __megasas_alloc_irq_vectors(instance);
5826
5827         if ((instance->perf_mode == MR_BALANCED_PERF_MODE) &&
5828             (i != instance->msix_vectors)) {
5829                 if (instance->msix_vectors)
5830                         pci_free_irq_vectors(instance->pdev);
5831                 /* Disable Balanced IOPS mode and try realloc vectors */
5832                 instance->perf_mode = MR_LATENCY_PERF_MODE;
5833                 instance->low_latency_index_start = 1;
5834                 num_msix_req = num_online_cpus() + instance->low_latency_index_start;
5835
5836                 instance->msix_vectors = min(num_msix_req,
5837                                 instance->msix_vectors);
5838
5839                 i = __megasas_alloc_irq_vectors(instance);
5840
5841         }
5842
5843         dev_info(&instance->pdev->dev,
5844                 "requested/available msix %d/%d\n", instance->msix_vectors, i);
5845
5846         if (i > 0)
5847                 instance->msix_vectors = i;
5848         else
5849                 instance->msix_vectors = 0;
5850
5851         if (instance->smp_affinity_enable)
5852                 megasas_set_high_iops_queue_affinity_hint(instance);
5853 }
5854
5855 /**
5856  * megasas_init_fw -    Initializes the FW
5857  * @instance:           Adapter soft state
5858  *
5859  * This is the main function for initializing firmware
5860  */
5861
5862 static int megasas_init_fw(struct megasas_instance *instance)
5863 {
5864         u32 max_sectors_1;
5865         u32 max_sectors_2, tmp_sectors, msix_enable;
5866         u32 scratch_pad_1, scratch_pad_2, scratch_pad_3, status_reg;
5867         resource_size_t base_addr;
5868         void *base_addr_phys;
5869         struct megasas_ctrl_info *ctrl_info = NULL;
5870         unsigned long bar_list;
5871         int i, j, loop;
5872         struct IOV_111 *iovPtr;
5873         struct fusion_context *fusion;
5874         bool intr_coalescing;
5875         unsigned int num_msix_req;
5876         u16 lnksta, speed;
5877
5878         fusion = instance->ctrl_context;
5879
5880         /* Find first memory bar */
5881         bar_list = pci_select_bars(instance->pdev, IORESOURCE_MEM);
5882         instance->bar = find_first_bit(&bar_list, BITS_PER_LONG);
5883         if (pci_request_selected_regions(instance->pdev, 1<<instance->bar,
5884                                          "megasas: LSI")) {
5885                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "IO memory region busy!\n");
5886                 return -EBUSY;
5887         }
5888
5889         base_addr = pci_resource_start(instance->pdev, instance->bar);
5890         instance->reg_set = ioremap(base_addr, 8192);
5891
5892         if (!instance->reg_set) {
5893                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to map IO mem\n");
5894                 goto fail_ioremap;
5895         }
5896
5897         base_addr_phys = &base_addr;
5898         dev_printk(KERN_DEBUG, &instance->pdev->dev,
5899                    "BAR:0x%lx  BAR's base_addr(phys):%pa  mapped virt_addr:0x%p\n",
5900                    instance->bar, base_addr_phys, instance->reg_set);
5901
5902         if (instance->adapter_type != MFI_SERIES)
5903                 instance->instancet = &megasas_instance_template_fusion;
5904         else {
5905                 switch (instance->pdev->device) {
5906                 case PCI_DEVICE_ID_LSI_SAS1078R:
5907                 case PCI_DEVICE_ID_LSI_SAS1078DE:
5908                         instance->instancet = &megasas_instance_template_ppc;
5909                         break;
5910                 case PCI_DEVICE_ID_LSI_SAS1078GEN2:
5911                 case PCI_DEVICE_ID_LSI_SAS0079GEN2:
5912                         instance->instancet = &megasas_instance_template_gen2;
5913                         break;
5914                 case PCI_DEVICE_ID_LSI_SAS0073SKINNY:
5915                 case PCI_DEVICE_ID_LSI_SAS0071SKINNY:
5916                         instance->instancet = &megasas_instance_template_skinny;
5917                         break;
5918                 case PCI_DEVICE_ID_LSI_SAS1064R:
5919                 case PCI_DEVICE_ID_DELL_PERC5:
5920                 default:
5921                         instance->instancet = &megasas_instance_template_xscale;
5922                         instance->pd_list_not_supported = 1;
5923                         break;
5924                 }
5925         }
5926
5927         if (megasas_transition_to_ready(instance, 0)) {
5928                 dev_info(&instance->pdev->dev,
5929                          "Failed to transition controller to ready from %s!\n",
5930                          __func__);
5931                 if (instance->adapter_type != MFI_SERIES) {
5932                         status_reg = instance->instancet->read_fw_status_reg(
5933                                         instance);
5934                         if (status_reg & MFI_RESET_ADAPTER) {
5935                                 if (megasas_adp_reset_wait_for_ready
5936                                         (instance, true, 0) == FAILED)
5937                                         goto fail_ready_state;
5938                         } else {
5939                                 goto fail_ready_state;
5940                         }
5941                 } else {
5942                         atomic_set(&instance->fw_reset_no_pci_access, 1);
5943                         instance->instancet->adp_reset
5944                                 (instance, instance->reg_set);
5945                         atomic_set(&instance->fw_reset_no_pci_access, 0);
5946
5947                         /*waiting for about 30 second before retry*/
5948                         ssleep(30);
5949
5950                         if (megasas_transition_to_ready(instance, 0))
5951                                 goto fail_ready_state;
5952                 }
5953
5954                 dev_info(&instance->pdev->dev,
5955                          "FW restarted successfully from %s!\n",
5956                          __func__);
5957         }
5958
5959         megasas_init_ctrl_params(instance);
5960
5961         if (megasas_set_dma_mask(instance))
5962                 goto fail_ready_state;
5963
5964         if (megasas_alloc_ctrl_mem(instance))
5965                 goto fail_alloc_dma_buf;
5966
5967         if (megasas_alloc_ctrl_dma_buffers(instance))
5968                 goto fail_alloc_dma_buf;
5969
5970         fusion = instance->ctrl_context;
5971
5972         if (instance->adapter_type >= VENTURA_SERIES) {
5973                 scratch_pad_2 =
5974                         megasas_readl(instance,
5975                                       &instance->reg_set->outbound_scratch_pad_2);
5976                 instance->max_raid_mapsize = ((scratch_pad_2 >>
5977                         MR_MAX_RAID_MAP_SIZE_OFFSET_SHIFT) &
5978                         MR_MAX_RAID_MAP_SIZE_MASK);
5979         }
5980
5981         instance->enable_sdev_max_qd = enable_sdev_max_qd;
5982
5983         switch (instance->adapter_type) {
5984         case VENTURA_SERIES:
5985                 fusion->pcie_bw_limitation = true;
5986                 break;
5987         case AERO_SERIES:
5988                 fusion->r56_div_offload = true;
5989                 break;
5990         default:
5991                 break;
5992         }
5993
5994         /* Check if MSI-X is supported while in ready state */
5995         msix_enable = (instance->instancet->read_fw_status_reg(instance) &
5996                        0x4000000) >> 0x1a;
5997         if (msix_enable && !msix_disable) {
5998
5999                 scratch_pad_1 = megasas_readl
6000                         (instance, &instance->reg_set->outbound_scratch_pad_1);
6001                 /* Check max MSI-X vectors */
6002                 if (fusion) {
6003                         if (instance->adapter_type == THUNDERBOLT_SERIES) {
6004                                 /* Thunderbolt Series*/
6005                                 instance->msix_vectors = (scratch_pad_1
6006                                         & MR_MAX_REPLY_QUEUES_OFFSET) + 1;
6007                         } else {
6008                                 instance->msix_vectors = ((scratch_pad_1
6009                                         & MR_MAX_REPLY_QUEUES_EXT_OFFSET)
6010                                         >> MR_MAX_REPLY_QUEUES_EXT_OFFSET_SHIFT) + 1;
6011
6012                                 /*
6013                                  * For Invader series, > 8 MSI-x vectors
6014                                  * supported by FW/HW implies combined
6015                                  * reply queue mode is enabled.
6016                                  * For Ventura series, > 16 MSI-x vectors
6017                                  * supported by FW/HW implies combined
6018                                  * reply queue mode is enabled.
6019                                  */
6020                                 switch (instance->adapter_type) {
6021                                 case INVADER_SERIES:
6022                                         if (instance->msix_vectors > 8)
6023                                                 instance->msix_combined = true;
6024                                         break;
6025                                 case AERO_SERIES:
6026                                 case VENTURA_SERIES:
6027                                         if (instance->msix_vectors > 16)
6028                                                 instance->msix_combined = true;
6029                                         break;
6030                                 }
6031
6032                                 if (rdpq_enable)
6033                                         instance->is_rdpq = (scratch_pad_1 & MR_RDPQ_MODE_OFFSET) ?
6034                                                                 1 : 0;
6035
6036                                 if (instance->adapter_type >= INVADER_SERIES &&
6037                                     !instance->msix_combined) {
6038                                         instance->msix_load_balance = true;
6039                                         instance->smp_affinity_enable = false;
6040                                 }
6041
6042                                 /* Save 1-15 reply post index address to local memory
6043                                  * Index 0 is already saved from reg offset
6044                                  * MPI2_REPLY_POST_HOST_INDEX_OFFSET
6045                                  */
6046                                 for (loop = 1; loop < MR_MAX_MSIX_REG_ARRAY; loop++) {
6047                                         instance->reply_post_host_index_addr[loop] =
6048                                                 (u32 __iomem *)
6049                                                 ((u8 __iomem *)instance->reg_set +
6050                                                 MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET
6051                                                 + (loop * 0x10));
6052                                 }
6053                         }
6054
6055                         dev_info(&instance->pdev->dev,
6056                                  "firmware supports msix\t: (%d)",
6057                                  instance->msix_vectors);
6058                         if (msix_vectors)
6059                                 instance->msix_vectors = min(msix_vectors,
6060                                         instance->msix_vectors);
6061                 } else /* MFI adapters */
6062                         instance->msix_vectors = 1;
6063
6064
6065                 /*
6066                  * For Aero (if some conditions are met), driver will configure a
6067                  * few additional reply queues with interrupt coalescing enabled.
6068                  * These queues with interrupt coalescing enabled are called
6069                  * High IOPS queues and rest of reply queues (based on number of
6070                  * logical CPUs) are termed as Low latency queues.
6071                  *
6072                  * Total Number of reply queues = High IOPS queues + low latency queues
6073                  *
6074                  * For rest of fusion adapters, 1 additional reply queue will be
6075                  * reserved for management commands, rest of reply queues
6076                  * (based on number of logical CPUs) will be used for IOs and
6077                  * referenced as IO queues.
6078                  * Total Number of reply queues = 1 + IO queues
6079                  *
6080                  * MFI adapters supports single MSI-x so single reply queue
6081                  * will be used for IO and management commands.
6082                  */
6083
6084                 intr_coalescing = (scratch_pad_1 & MR_INTR_COALESCING_SUPPORT_OFFSET) ?
6085                                                                 true : false;
6086                 if (intr_coalescing &&
6087                         (num_online_cpus() >= MR_HIGH_IOPS_QUEUE_COUNT) &&
6088                         (instance->msix_vectors == MEGASAS_MAX_MSIX_QUEUES))
6089                         instance->perf_mode = MR_BALANCED_PERF_MODE;
6090                 else
6091                         instance->perf_mode = MR_LATENCY_PERF_MODE;
6092
6093
6094                 if (instance->adapter_type == AERO_SERIES) {
6095                         pcie_capability_read_word(instance->pdev, PCI_EXP_LNKSTA, &lnksta);
6096                         speed = lnksta & PCI_EXP_LNKSTA_CLS;
6097
6098                         /*
6099                          * For Aero, if PCIe link speed is <16 GT/s, then driver should operate
6100                          * in latency perf mode and enable R1 PCI bandwidth algorithm
6101                          */
6102                         if (speed < 0x4) {
6103                                 instance->perf_mode = MR_LATENCY_PERF_MODE;
6104                                 fusion->pcie_bw_limitation = true;
6105                         }
6106
6107                         /*
6108                          * Performance mode settings provided through module parameter-perf_mode will
6109                          * take affect only for:
6110                          * 1. Aero family of adapters.
6111                          * 2. When user sets module parameter- perf_mode in range of 0-2.
6112                          */
6113                         if ((perf_mode >= MR_BALANCED_PERF_MODE) &&
6114                                 (perf_mode <= MR_LATENCY_PERF_MODE))
6115                                 instance->perf_mode = perf_mode;
6116                         /*
6117                          * If intr coalescing is not supported by controller FW, then IOPS
6118                          * and Balanced modes are not feasible.
6119                          */
6120                         if (!intr_coalescing)
6121                                 instance->perf_mode = MR_LATENCY_PERF_MODE;
6122
6123                 }
6124
6125                 if (instance->perf_mode == MR_BALANCED_PERF_MODE)
6126                         instance->low_latency_index_start =
6127                                 MR_HIGH_IOPS_QUEUE_COUNT;
6128                 else
6129                         instance->low_latency_index_start = 1;
6130
6131                 num_msix_req = num_online_cpus() + instance->low_latency_index_start;
6132
6133                 instance->msix_vectors = min(num_msix_req,
6134                                 instance->msix_vectors);
6135
6136                 megasas_alloc_irq_vectors(instance);
6137                 if (!instance->msix_vectors)
6138                         instance->msix_load_balance = false;
6139         }
6140         /*
6141          * MSI-X host index 0 is common for all adapter.
6142          * It is used for all MPT based Adapters.
6143          */
6144         if (instance->msix_combined) {
6145                 instance->reply_post_host_index_addr[0] =
6146                                 (u32 *)((u8 *)instance->reg_set +
6147                                 MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET);
6148         } else {
6149                 instance->reply_post_host_index_addr[0] =
6150                         (u32 *)((u8 *)instance->reg_set +
6151                         MPI2_REPLY_POST_HOST_INDEX_OFFSET);
6152         }
6153
6154         if (!instance->msix_vectors) {
6155                 i = pci_alloc_irq_vectors(instance->pdev, 1, 1, PCI_IRQ_LEGACY);
6156                 if (i < 0)
6157                         goto fail_init_adapter;
6158         }
6159
6160         megasas_setup_reply_map(instance);
6161
6162         dev_info(&instance->pdev->dev,
6163                 "current msix/online cpus\t: (%d/%d)\n",
6164                 instance->msix_vectors, (unsigned int)num_online_cpus());
6165         dev_info(&instance->pdev->dev,
6166                 "RDPQ mode\t: (%s)\n", instance->is_rdpq ? "enabled" : "disabled");
6167
6168         tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
6169                 (unsigned long)instance);
6170
6171         /*
6172          * Below are default value for legacy Firmware.
6173          * non-fusion based controllers
6174          */
6175         instance->fw_supported_vd_count = MAX_LOGICAL_DRIVES;
6176         instance->fw_supported_pd_count = MAX_PHYSICAL_DEVICES;
6177         /* Get operational params, sge flags, send init cmd to controller */
6178         if (instance->instancet->init_adapter(instance))
6179                 goto fail_init_adapter;
6180
6181         if (instance->adapter_type >= VENTURA_SERIES) {
6182                 scratch_pad_3 =
6183                         megasas_readl(instance,
6184                                       &instance->reg_set->outbound_scratch_pad_3);
6185                 if ((scratch_pad_3 & MR_NVME_PAGE_SIZE_MASK) >=
6186                         MR_DEFAULT_NVME_PAGE_SHIFT)
6187                         instance->nvme_page_size =
6188                                 (1 << (scratch_pad_3 & MR_NVME_PAGE_SIZE_MASK));
6189
6190                 dev_info(&instance->pdev->dev,
6191                          "NVME page size\t: (%d)\n", instance->nvme_page_size);
6192         }
6193
6194         if (instance->msix_vectors ?
6195                 megasas_setup_irqs_msix(instance, 1) :
6196                 megasas_setup_irqs_ioapic(instance))
6197                 goto fail_init_adapter;
6198
6199         if (instance->adapter_type != MFI_SERIES)
6200                 megasas_setup_irq_poll(instance);
6201
6202         instance->instancet->enable_intr(instance);
6203
6204         dev_info(&instance->pdev->dev, "INIT adapter done\n");
6205
6206         megasas_setup_jbod_map(instance);
6207
6208         if (megasas_get_device_list(instance) != SUCCESS) {
6209                 dev_err(&instance->pdev->dev,
6210                         "%s: megasas_get_device_list failed\n",
6211                         __func__);
6212                 goto fail_get_ld_pd_list;
6213         }
6214
6215         /* stream detection initialization */
6216         if (instance->adapter_type >= VENTURA_SERIES) {
6217                 fusion->stream_detect_by_ld =
6218                         kcalloc(MAX_LOGICAL_DRIVES_EXT,
6219                                 sizeof(struct LD_STREAM_DETECT *),
6220                                 GFP_KERNEL);
6221                 if (!fusion->stream_detect_by_ld) {
6222                         dev_err(&instance->pdev->dev,
6223                                 "unable to allocate stream detection for pool of LDs\n");
6224                         goto fail_get_ld_pd_list;
6225                 }
6226                 for (i = 0; i < MAX_LOGICAL_DRIVES_EXT; ++i) {
6227                         fusion->stream_detect_by_ld[i] =
6228                                 kzalloc(sizeof(struct LD_STREAM_DETECT),
6229                                 GFP_KERNEL);
6230                         if (!fusion->stream_detect_by_ld[i]) {
6231                                 dev_err(&instance->pdev->dev,
6232                                         "unable to allocate stream detect by LD\n ");
6233                                 for (j = 0; j < i; ++j)
6234                                         kfree(fusion->stream_detect_by_ld[j]);
6235                                 kfree(fusion->stream_detect_by_ld);
6236                                 fusion->stream_detect_by_ld = NULL;
6237                                 goto fail_get_ld_pd_list;
6238                         }
6239                         fusion->stream_detect_by_ld[i]->mru_bit_map
6240                                 = MR_STREAM_BITMAP;
6241                 }
6242         }
6243
6244         /*
6245          * Compute the max allowed sectors per IO: The controller info has two
6246          * limits on max sectors. Driver should use the minimum of these two.
6247          *
6248          * 1 << stripe_sz_ops.min = max sectors per strip
6249          *
6250          * Note that older firmwares ( < FW ver 30) didn't report information
6251          * to calculate max_sectors_1. So the number ended up as zero always.
6252          */
6253         tmp_sectors = 0;
6254         ctrl_info = instance->ctrl_info_buf;
6255
6256         max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) *
6257                 le16_to_cpu(ctrl_info->max_strips_per_io);
6258         max_sectors_2 = le32_to_cpu(ctrl_info->max_request_size);
6259
6260         tmp_sectors = min_t(u32, max_sectors_1, max_sectors_2);
6261
6262         instance->peerIsPresent = ctrl_info->cluster.peerIsPresent;
6263         instance->passive = ctrl_info->cluster.passive;
6264         memcpy(instance->clusterId, ctrl_info->clusterId, sizeof(instance->clusterId));
6265         instance->UnevenSpanSupport =
6266                 ctrl_info->adapterOperations2.supportUnevenSpans;
6267         if (instance->UnevenSpanSupport) {
6268                 struct fusion_context *fusion = instance->ctrl_context;
6269                 if (MR_ValidateMapInfo(instance, instance->map_id))
6270                         fusion->fast_path_io = 1;
6271                 else
6272                         fusion->fast_path_io = 0;
6273
6274         }
6275         if (ctrl_info->host_interface.SRIOV) {
6276                 instance->requestorId = ctrl_info->iov.requestorId;
6277                 if (instance->pdev->device == PCI_DEVICE_ID_LSI_PLASMA) {
6278                         if (!ctrl_info->adapterOperations2.activePassive)
6279                             instance->PlasmaFW111 = 1;
6280
6281                         dev_info(&instance->pdev->dev, "SR-IOV: firmware type: %s\n",
6282                             instance->PlasmaFW111 ? "1.11" : "new");
6283
6284                         if (instance->PlasmaFW111) {
6285                             iovPtr = (struct IOV_111 *)
6286                                 ((unsigned char *)ctrl_info + IOV_111_OFFSET);
6287                             instance->requestorId = iovPtr->requestorId;
6288                         }
6289                 }
6290                 dev_info(&instance->pdev->dev, "SRIOV: VF requestorId %d\n",
6291                         instance->requestorId);
6292         }
6293
6294         instance->crash_dump_fw_support =
6295                 ctrl_info->adapterOperations3.supportCrashDump;
6296         instance->crash_dump_drv_support =
6297                 (instance->crash_dump_fw_support &&
6298                 instance->crash_dump_buf);
6299         if (instance->crash_dump_drv_support)
6300                 megasas_set_crash_dump_params(instance,
6301                         MR_CRASH_BUF_TURN_OFF);
6302
6303         else {
6304                 if (instance->crash_dump_buf)
6305                         dma_free_coherent(&instance->pdev->dev,
6306                                 CRASH_DMA_BUF_SIZE,
6307                                 instance->crash_dump_buf,
6308                                 instance->crash_dump_h);
6309                 instance->crash_dump_buf = NULL;
6310         }
6311
6312         if (instance->snapdump_wait_time) {
6313                 megasas_get_snapdump_properties(instance);
6314                 dev_info(&instance->pdev->dev, "Snap dump wait time\t: %d\n",
6315                          instance->snapdump_wait_time);
6316         }
6317
6318         dev_info(&instance->pdev->dev,
6319                 "pci id\t\t: (0x%04x)/(0x%04x)/(0x%04x)/(0x%04x)\n",
6320                 le16_to_cpu(ctrl_info->pci.vendor_id),
6321                 le16_to_cpu(ctrl_info->pci.device_id),
6322                 le16_to_cpu(ctrl_info->pci.sub_vendor_id),
6323                 le16_to_cpu(ctrl_info->pci.sub_device_id));
6324         dev_info(&instance->pdev->dev, "unevenspan support      : %s\n",
6325                 instance->UnevenSpanSupport ? "yes" : "no");
6326         dev_info(&instance->pdev->dev, "firmware crash dump     : %s\n",
6327                 instance->crash_dump_drv_support ? "yes" : "no");
6328         dev_info(&instance->pdev->dev, "JBOD sequence map       : %s\n",
6329                 instance->use_seqnum_jbod_fp ? "enabled" : "disabled");
6330
6331         instance->max_sectors_per_req = instance->max_num_sge *
6332                                                 SGE_BUFFER_SIZE / 512;
6333         if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
6334                 instance->max_sectors_per_req = tmp_sectors;
6335
6336         /* Check for valid throttlequeuedepth module parameter */
6337         if (throttlequeuedepth &&
6338                         throttlequeuedepth <= instance->max_scsi_cmds)
6339                 instance->throttlequeuedepth = throttlequeuedepth;
6340         else
6341                 instance->throttlequeuedepth =
6342                                 MEGASAS_THROTTLE_QUEUE_DEPTH;
6343
6344         if ((resetwaittime < 1) ||
6345             (resetwaittime > MEGASAS_RESET_WAIT_TIME))
6346                 resetwaittime = MEGASAS_RESET_WAIT_TIME;
6347
6348         if ((scmd_timeout < 10) || (scmd_timeout > MEGASAS_DEFAULT_CMD_TIMEOUT))
6349                 scmd_timeout = MEGASAS_DEFAULT_CMD_TIMEOUT;
6350
6351         /* Launch SR-IOV heartbeat timer */
6352         if (instance->requestorId) {
6353                 if (!megasas_sriov_start_heartbeat(instance, 1)) {
6354                         megasas_start_timer(instance);
6355                 } else {
6356                         instance->skip_heartbeat_timer_del = 1;
6357                         goto fail_get_ld_pd_list;
6358                 }
6359         }
6360
6361         /*
6362          * Create and start watchdog thread which will monitor
6363          * controller state every 1 sec and trigger OCR when
6364          * it enters fault state
6365          */
6366         if (instance->adapter_type != MFI_SERIES)
6367                 if (megasas_fusion_start_watchdog(instance) != SUCCESS)
6368                         goto fail_start_watchdog;
6369
6370         return 0;
6371
6372 fail_start_watchdog:
6373         if (instance->requestorId && !instance->skip_heartbeat_timer_del)
6374                 del_timer_sync(&instance->sriov_heartbeat_timer);
6375 fail_get_ld_pd_list:
6376         instance->instancet->disable_intr(instance);
6377         megasas_destroy_irqs(instance);
6378 fail_init_adapter:
6379         if (instance->msix_vectors)
6380                 pci_free_irq_vectors(instance->pdev);
6381         instance->msix_vectors = 0;
6382 fail_alloc_dma_buf:
6383         megasas_free_ctrl_dma_buffers(instance);
6384         megasas_free_ctrl_mem(instance);
6385 fail_ready_state:
6386         iounmap(instance->reg_set);
6387
6388 fail_ioremap:
6389         pci_release_selected_regions(instance->pdev, 1<<instance->bar);
6390
6391         dev_err(&instance->pdev->dev, "Failed from %s %d\n",
6392                 __func__, __LINE__);
6393         return -EINVAL;
6394 }
6395
6396 /**
6397  * megasas_release_mfi -        Reverses the FW initialization
6398  * @instance:                   Adapter soft state
6399  */
6400 static void megasas_release_mfi(struct megasas_instance *instance)
6401 {
6402         u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);
6403
6404         if (instance->reply_queue)
6405                 dma_free_coherent(&instance->pdev->dev, reply_q_sz,
6406                             instance->reply_queue, instance->reply_queue_h);
6407
6408         megasas_free_cmds(instance);
6409
6410         iounmap(instance->reg_set);
6411
6412         pci_release_selected_regions(instance->pdev, 1<<instance->bar);
6413 }
6414
6415 /**
6416  * megasas_get_seq_num -        Gets latest event sequence numbers
6417  * @instance:                   Adapter soft state
6418  * @eli:                        FW event log sequence numbers information
6419  *
6420  * FW maintains a log of all events in a non-volatile area. Upper layers would
6421  * usually find out the latest sequence number of the events, the seq number at
6422  * the boot etc. They would "read" all the events below the latest seq number
6423  * by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq
6424  * number), they would subsribe to AEN (asynchronous event notification) and
6425  * wait for the events to happen.
6426  */
6427 static int
6428 megasas_get_seq_num(struct megasas_instance *instance,
6429                     struct megasas_evt_log_info *eli)
6430 {
6431         struct megasas_cmd *cmd;
6432         struct megasas_dcmd_frame *dcmd;
6433         struct megasas_evt_log_info *el_info;
6434         dma_addr_t el_info_h = 0;
6435         int ret;
6436
6437         cmd = megasas_get_cmd(instance);
6438
6439         if (!cmd) {
6440                 return -ENOMEM;
6441         }
6442
6443         dcmd = &cmd->frame->dcmd;
6444         el_info = dma_alloc_coherent(&instance->pdev->dev,
6445                                      sizeof(struct megasas_evt_log_info),
6446                                      &el_info_h, GFP_KERNEL);
6447         if (!el_info) {
6448                 megasas_return_cmd(instance, cmd);
6449                 return -ENOMEM;
6450         }
6451
6452         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
6453
6454         dcmd->cmd = MFI_CMD_DCMD;
6455         dcmd->cmd_status = 0x0;
6456         dcmd->sge_count = 1;
6457         dcmd->flags = MFI_FRAME_DIR_READ;
6458         dcmd->timeout = 0;
6459         dcmd->pad_0 = 0;
6460         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_log_info));
6461         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_GET_INFO);
6462
6463         megasas_set_dma_settings(instance, dcmd, el_info_h,
6464                                  sizeof(struct megasas_evt_log_info));
6465
6466         ret = megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS);
6467         if (ret != DCMD_SUCCESS) {
6468                 dev_err(&instance->pdev->dev, "Failed from %s %d\n",
6469                         __func__, __LINE__);
6470                 goto dcmd_failed;
6471         }
6472
6473         /*
6474          * Copy the data back into callers buffer
6475          */
6476         eli->newest_seq_num = el_info->newest_seq_num;
6477         eli->oldest_seq_num = el_info->oldest_seq_num;
6478         eli->clear_seq_num = el_info->clear_seq_num;
6479         eli->shutdown_seq_num = el_info->shutdown_seq_num;
6480         eli->boot_seq_num = el_info->boot_seq_num;
6481
6482 dcmd_failed:
6483         dma_free_coherent(&instance->pdev->dev,
6484                         sizeof(struct megasas_evt_log_info),
6485                         el_info, el_info_h);
6486
6487         megasas_return_cmd(instance, cmd);
6488
6489         return ret;
6490 }
6491
6492 /**
6493  * megasas_register_aen -       Registers for asynchronous event notification
6494  * @instance:                   Adapter soft state
6495  * @seq_num:                    The starting sequence number
6496  * @class_locale:               Class of the event
6497  *
6498  * This function subscribes for AEN for events beyond the @seq_num. It requests
6499  * to be notified if and only if the event is of type @class_locale
6500  */
6501 static int
6502 megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
6503                      u32 class_locale_word)
6504 {
6505         int ret_val;
6506         struct megasas_cmd *cmd;
6507         struct megasas_dcmd_frame *dcmd;
6508         union megasas_evt_class_locale curr_aen;
6509         union megasas_evt_class_locale prev_aen;
6510
6511         /*
6512          * If there an AEN pending already (aen_cmd), check if the
6513          * class_locale of that pending AEN is inclusive of the new
6514          * AEN request we currently have. If it is, then we don't have
6515          * to do anything. In other words, whichever events the current
6516          * AEN request is subscribing to, have already been subscribed
6517          * to.
6518          *
6519          * If the old_cmd is _not_ inclusive, then we have to abort
6520          * that command, form a class_locale that is superset of both
6521          * old and current and re-issue to the FW
6522          */
6523
6524         curr_aen.word = class_locale_word;
6525
6526         if (instance->aen_cmd) {
6527
6528                 prev_aen.word =
6529                         le32_to_cpu(instance->aen_cmd->frame->dcmd.mbox.w[1]);
6530
6531                 if ((curr_aen.members.class < MFI_EVT_CLASS_DEBUG) ||
6532                     (curr_aen.members.class > MFI_EVT_CLASS_DEAD)) {
6533                         dev_info(&instance->pdev->dev,
6534                                  "%s %d out of range class %d send by application\n",
6535                                  __func__, __LINE__, curr_aen.members.class);
6536                         return 0;
6537                 }
6538
6539                 /*
6540                  * A class whose enum value is smaller is inclusive of all
6541                  * higher values. If a PROGRESS (= -1) was previously
6542                  * registered, then a new registration requests for higher
6543                  * classes need not be sent to FW. They are automatically
6544                  * included.
6545                  *
6546                  * Locale numbers don't have such hierarchy. They are bitmap
6547                  * values
6548                  */
6549                 if ((prev_aen.members.class <= curr_aen.members.class) &&
6550                     !((prev_aen.members.locale & curr_aen.members.locale) ^
6551                       curr_aen.members.locale)) {
6552                         /*
6553                          * Previously issued event registration includes
6554                          * current request. Nothing to do.
6555                          */
6556                         return 0;
6557                 } else {
6558                         curr_aen.members.locale |= prev_aen.members.locale;
6559
6560                         if (prev_aen.members.class < curr_aen.members.class)
6561                                 curr_aen.members.class = prev_aen.members.class;
6562
6563                         instance->aen_cmd->abort_aen = 1;
6564                         ret_val = megasas_issue_blocked_abort_cmd(instance,
6565                                                                   instance->
6566                                                                   aen_cmd, 30);
6567
6568                         if (ret_val) {
6569                                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to abort "
6570                                        "previous AEN command\n");
6571                                 return ret_val;
6572                         }
6573                 }
6574         }
6575
6576         cmd = megasas_get_cmd(instance);
6577
6578         if (!cmd)
6579                 return -ENOMEM;
6580
6581         dcmd = &cmd->frame->dcmd;
6582
6583         memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail));
6584
6585         /*
6586          * Prepare DCMD for aen registration
6587          */
6588         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
6589
6590         dcmd->cmd = MFI_CMD_DCMD;
6591         dcmd->cmd_status = 0x0;
6592         dcmd->sge_count = 1;
6593         dcmd->flags = MFI_FRAME_DIR_READ;
6594         dcmd->timeout = 0;
6595         dcmd->pad_0 = 0;
6596         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_detail));
6597         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_WAIT);
6598         dcmd->mbox.w[0] = cpu_to_le32(seq_num);
6599         instance->last_seq_num = seq_num;
6600         dcmd->mbox.w[1] = cpu_to_le32(curr_aen.word);
6601
6602         megasas_set_dma_settings(instance, dcmd, instance->evt_detail_h,
6603                                  sizeof(struct megasas_evt_detail));
6604
6605         if (instance->aen_cmd != NULL) {
6606                 megasas_return_cmd(instance, cmd);
6607                 return 0;
6608         }
6609
6610         /*
6611          * Store reference to the cmd used to register for AEN. When an
6612          * application wants us to register for AEN, we have to abort this
6613          * cmd and re-register with a new EVENT LOCALE supplied by that app
6614          */
6615         instance->aen_cmd = cmd;
6616
6617         /*
6618          * Issue the aen registration frame
6619          */
6620         instance->instancet->issue_dcmd(instance, cmd);
6621
6622         return 0;
6623 }
6624
6625 /* megasas_get_target_prop - Send DCMD with below details to firmware.
6626  *
6627  * This DCMD will fetch few properties of LD/system PD defined
6628  * in MR_TARGET_DEV_PROPERTIES. eg. Queue Depth, MDTS value.
6629  *
6630  * DCMD send by drivers whenever new target is added to the OS.
6631  *
6632  * dcmd.opcode         - MR_DCMD_DEV_GET_TARGET_PROP
6633  * dcmd.mbox.b[0]      - DCMD is to be fired for LD or system PD.
6634  *                       0 = system PD, 1 = LD.
6635  * dcmd.mbox.s[1]      - TargetID for LD/system PD.
6636  * dcmd.sge IN         - Pointer to return MR_TARGET_DEV_PROPERTIES.
6637  *
6638  * @instance:           Adapter soft state
6639  * @sdev:               OS provided scsi device
6640  *
6641  * Returns 0 on success non-zero on failure.
6642  */
6643 int
6644 megasas_get_target_prop(struct megasas_instance *instance,
6645                         struct scsi_device *sdev)
6646 {
6647         int ret;
6648         struct megasas_cmd *cmd;
6649         struct megasas_dcmd_frame *dcmd;
6650         u16 targetId = ((sdev->channel % 2) * MEGASAS_MAX_DEV_PER_CHANNEL) +
6651                         sdev->id;
6652
6653         cmd = megasas_get_cmd(instance);
6654
6655         if (!cmd) {
6656                 dev_err(&instance->pdev->dev,
6657                         "Failed to get cmd %s\n", __func__);
6658                 return -ENOMEM;
6659         }
6660
6661         dcmd = &cmd->frame->dcmd;
6662
6663         memset(instance->tgt_prop, 0, sizeof(*instance->tgt_prop));
6664         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
6665         dcmd->mbox.b[0] = MEGASAS_IS_LOGICAL(sdev);
6666
6667         dcmd->mbox.s[1] = cpu_to_le16(targetId);
6668         dcmd->cmd = MFI_CMD_DCMD;
6669         dcmd->cmd_status = 0xFF;
6670         dcmd->sge_count = 1;
6671         dcmd->flags = MFI_FRAME_DIR_READ;
6672         dcmd->timeout = 0;
6673         dcmd->pad_0 = 0;
6674         dcmd->data_xfer_len =
6675                 cpu_to_le32(sizeof(struct MR_TARGET_PROPERTIES));
6676         dcmd->opcode = cpu_to_le32(MR_DCMD_DRV_GET_TARGET_PROP);
6677
6678         megasas_set_dma_settings(instance, dcmd, instance->tgt_prop_h,
6679                                  sizeof(struct MR_TARGET_PROPERTIES));
6680
6681         if ((instance->adapter_type != MFI_SERIES) &&
6682             !instance->mask_interrupts)
6683                 ret = megasas_issue_blocked_cmd(instance,
6684                                                 cmd, MFI_IO_TIMEOUT_SECS);
6685         else
6686                 ret = megasas_issue_polled(instance, cmd);
6687
6688         switch (ret) {
6689         case DCMD_TIMEOUT:
6690                 switch (dcmd_timeout_ocr_possible(instance)) {
6691                 case INITIATE_OCR:
6692                         cmd->flags |= DRV_DCMD_SKIP_REFIRE;
6693                         mutex_unlock(&instance->reset_mutex);
6694                         megasas_reset_fusion(instance->host,
6695                                              MFI_IO_TIMEOUT_OCR);
6696                         mutex_lock(&instance->reset_mutex);
6697                         break;
6698                 case KILL_ADAPTER:
6699                         megaraid_sas_kill_hba(instance);
6700                         break;
6701                 case IGNORE_TIMEOUT:
6702                         dev_info(&instance->pdev->dev,
6703                                  "Ignore DCMD timeout: %s %d\n",
6704                                  __func__, __LINE__);
6705                         break;
6706                 }
6707                 break;
6708
6709         default:
6710                 megasas_return_cmd(instance, cmd);
6711         }
6712         if (ret != DCMD_SUCCESS)
6713                 dev_err(&instance->pdev->dev,
6714                         "return from %s %d return value %d\n",
6715                         __func__, __LINE__, ret);
6716
6717         return ret;
6718 }
6719
6720 /**
6721  * megasas_start_aen -  Subscribes to AEN during driver load time
6722  * @instance:           Adapter soft state
6723  */
6724 static int megasas_start_aen(struct megasas_instance *instance)
6725 {
6726         struct megasas_evt_log_info eli;
6727         union megasas_evt_class_locale class_locale;
6728
6729         /*
6730          * Get the latest sequence number from FW
6731          */
6732         memset(&eli, 0, sizeof(eli));
6733
6734         if (megasas_get_seq_num(instance, &eli))
6735                 return -1;
6736
6737         /*
6738          * Register AEN with FW for latest sequence number plus 1
6739          */
6740         class_locale.members.reserved = 0;
6741         class_locale.members.locale = MR_EVT_LOCALE_ALL;
6742         class_locale.members.class = MR_EVT_CLASS_DEBUG;
6743
6744         return megasas_register_aen(instance,
6745                         le32_to_cpu(eli.newest_seq_num) + 1,
6746                         class_locale.word);
6747 }
6748
6749 /**
6750  * megasas_io_attach -  Attaches this driver to SCSI mid-layer
6751  * @instance:           Adapter soft state
6752  */
6753 static int megasas_io_attach(struct megasas_instance *instance)
6754 {
6755         struct Scsi_Host *host = instance->host;
6756
6757         /*
6758          * Export parameters required by SCSI mid-layer
6759          */
6760         host->unique_id = instance->unique_id;
6761         host->can_queue = instance->max_scsi_cmds;
6762         host->this_id = instance->init_id;
6763         host->sg_tablesize = instance->max_num_sge;
6764
6765         if (instance->fw_support_ieee)
6766                 instance->max_sectors_per_req = MEGASAS_MAX_SECTORS_IEEE;
6767
6768         /*
6769          * Check if the module parameter value for max_sectors can be used
6770          */
6771         if (max_sectors && max_sectors < instance->max_sectors_per_req)
6772                 instance->max_sectors_per_req = max_sectors;
6773         else {
6774                 if (max_sectors) {
6775                         if (((instance->pdev->device ==
6776                                 PCI_DEVICE_ID_LSI_SAS1078GEN2) ||
6777                                 (instance->pdev->device ==
6778                                 PCI_DEVICE_ID_LSI_SAS0079GEN2)) &&
6779                                 (max_sectors <= MEGASAS_MAX_SECTORS)) {
6780                                 instance->max_sectors_per_req = max_sectors;
6781                         } else {
6782                         dev_info(&instance->pdev->dev, "max_sectors should be > 0"
6783                                 "and <= %d (or < 1MB for GEN2 controller)\n",
6784                                 instance->max_sectors_per_req);
6785                         }
6786                 }
6787         }
6788
6789         host->max_sectors = instance->max_sectors_per_req;
6790         host->cmd_per_lun = MEGASAS_DEFAULT_CMD_PER_LUN;
6791         host->max_channel = MEGASAS_MAX_CHANNELS - 1;
6792         host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;
6793         host->max_lun = MEGASAS_MAX_LUN;
6794         host->max_cmd_len = 16;
6795
6796         /*
6797          * Notify the mid-layer about the new controller
6798          */
6799         if (scsi_add_host(host, &instance->pdev->dev)) {
6800                 dev_err(&instance->pdev->dev,
6801                         "Failed to add host from %s %d\n",
6802                         __func__, __LINE__);
6803                 return -ENODEV;
6804         }
6805
6806         return 0;
6807 }
6808
6809 /**
6810  * megasas_set_dma_mask -       Set DMA mask for supported controllers
6811  *
6812  * @instance:           Adapter soft state
6813  * Description:
6814  *
6815  * For Ventura, driver/FW will operate in 63bit DMA addresses.
6816  *
6817  * For invader-
6818  *      By default, driver/FW will operate in 32bit DMA addresses
6819  *      for consistent DMA mapping but if 32 bit consistent
6820  *      DMA mask fails, driver will try with 63 bit consistent
6821  *      mask provided FW is true 63bit DMA capable
6822  *
6823  * For older controllers(Thunderbolt and MFI based adapters)-
6824  *      driver/FW will operate in 32 bit consistent DMA addresses.
6825  */
6826 static int
6827 megasas_set_dma_mask(struct megasas_instance *instance)
6828 {
6829         u64 consistent_mask;
6830         struct pci_dev *pdev;
6831         u32 scratch_pad_1;
6832
6833         pdev = instance->pdev;
6834         consistent_mask = (instance->adapter_type >= VENTURA_SERIES) ?
6835                                 DMA_BIT_MASK(63) : DMA_BIT_MASK(32);
6836
6837         if (IS_DMA64) {
6838                 if (dma_set_mask(&pdev->dev, DMA_BIT_MASK(63)) &&
6839                     dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)))
6840                         goto fail_set_dma_mask;
6841
6842                 if ((*pdev->dev.dma_mask == DMA_BIT_MASK(63)) &&
6843                     (dma_set_coherent_mask(&pdev->dev, consistent_mask) &&
6844                      dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)))) {
6845                         /*
6846                          * If 32 bit DMA mask fails, then try for 64 bit mask
6847                          * for FW capable of handling 64 bit DMA.
6848                          */
6849                         scratch_pad_1 = megasas_readl
6850                                 (instance, &instance->reg_set->outbound_scratch_pad_1);
6851
6852                         if (!(scratch_pad_1 & MR_CAN_HANDLE_64_BIT_DMA_OFFSET))
6853                                 goto fail_set_dma_mask;
6854                         else if (dma_set_mask_and_coherent(&pdev->dev,
6855                                                            DMA_BIT_MASK(63)))
6856                                 goto fail_set_dma_mask;
6857                 }
6858         } else if (dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)))
6859                 goto fail_set_dma_mask;
6860
6861         if (pdev->dev.coherent_dma_mask == DMA_BIT_MASK(32))
6862                 instance->consistent_mask_64bit = false;
6863         else
6864                 instance->consistent_mask_64bit = true;
6865
6866         dev_info(&pdev->dev, "%s bit DMA mask and %s bit consistent mask\n",
6867                  ((*pdev->dev.dma_mask == DMA_BIT_MASK(63)) ? "63" : "32"),
6868                  (instance->consistent_mask_64bit ? "63" : "32"));
6869
6870         return 0;
6871
6872 fail_set_dma_mask:
6873         dev_err(&pdev->dev, "Failed to set DMA mask\n");
6874         return -1;
6875
6876 }
6877
6878 /*
6879  * megasas_set_adapter_type -   Set adapter type.
6880  *                              Supported controllers can be divided in
6881  *                              different categories-
6882  *                                      enum MR_ADAPTER_TYPE {
6883  *                                              MFI_SERIES = 1,
6884  *                                              THUNDERBOLT_SERIES = 2,
6885  *                                              INVADER_SERIES = 3,
6886  *                                              VENTURA_SERIES = 4,
6887  *                                              AERO_SERIES = 5,
6888  *                                      };
6889  * @instance:                   Adapter soft state
6890  * return:                      void
6891  */
6892 static inline void megasas_set_adapter_type(struct megasas_instance *instance)
6893 {
6894         if ((instance->pdev->vendor == PCI_VENDOR_ID_DELL) &&
6895             (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5)) {
6896                 instance->adapter_type = MFI_SERIES;
6897         } else {
6898                 switch (instance->pdev->device) {
6899                 case PCI_DEVICE_ID_LSI_AERO_10E1:
6900                 case PCI_DEVICE_ID_LSI_AERO_10E2:
6901                 case PCI_DEVICE_ID_LSI_AERO_10E5:
6902                 case PCI_DEVICE_ID_LSI_AERO_10E6:
6903                         instance->adapter_type = AERO_SERIES;
6904                         break;
6905                 case PCI_DEVICE_ID_LSI_VENTURA:
6906                 case PCI_DEVICE_ID_LSI_CRUSADER:
6907                 case PCI_DEVICE_ID_LSI_HARPOON:
6908                 case PCI_DEVICE_ID_LSI_TOMCAT:
6909                 case PCI_DEVICE_ID_LSI_VENTURA_4PORT:
6910                 case PCI_DEVICE_ID_LSI_CRUSADER_4PORT:
6911                         instance->adapter_type = VENTURA_SERIES;
6912                         break;
6913                 case PCI_DEVICE_ID_LSI_FUSION:
6914                 case PCI_DEVICE_ID_LSI_PLASMA:
6915                         instance->adapter_type = THUNDERBOLT_SERIES;
6916                         break;
6917                 case PCI_DEVICE_ID_LSI_INVADER:
6918                 case PCI_DEVICE_ID_LSI_INTRUDER:
6919                 case PCI_DEVICE_ID_LSI_INTRUDER_24:
6920                 case PCI_DEVICE_ID_LSI_CUTLASS_52:
6921                 case PCI_DEVICE_ID_LSI_CUTLASS_53:
6922                 case PCI_DEVICE_ID_LSI_FURY:
6923                         instance->adapter_type = INVADER_SERIES;
6924                         break;
6925                 default: /* For all other supported controllers */
6926                         instance->adapter_type = MFI_SERIES;
6927                         break;
6928                 }
6929         }
6930 }
6931
6932 static inline int megasas_alloc_mfi_ctrl_mem(struct megasas_instance *instance)
6933 {
6934         instance->producer = dma_alloc_coherent(&instance->pdev->dev,
6935                         sizeof(u32), &instance->producer_h, GFP_KERNEL);
6936         instance->consumer = dma_alloc_coherent(&instance->pdev->dev,
6937                         sizeof(u32), &instance->consumer_h, GFP_KERNEL);
6938
6939         if (!instance->producer || !instance->consumer) {
6940                 dev_err(&instance->pdev->dev,
6941                         "Failed to allocate memory for producer, consumer\n");
6942                 return -1;
6943         }
6944
6945         *instance->producer = 0;
6946         *instance->consumer = 0;
6947         return 0;
6948 }
6949
6950 /**
6951  * megasas_alloc_ctrl_mem -     Allocate per controller memory for core data
6952  *                              structures which are not common across MFI
6953  *                              adapters and fusion adapters.
6954  *                              For MFI based adapters, allocate producer and
6955  *                              consumer buffers. For fusion adapters, allocate
6956  *                              memory for fusion context.
6957  * @instance:                   Adapter soft state
6958  * return:                      0 for SUCCESS
6959  */
6960 static int megasas_alloc_ctrl_mem(struct megasas_instance *instance)
6961 {
6962         instance->reply_map = kcalloc(nr_cpu_ids, sizeof(unsigned int),
6963                                       GFP_KERNEL);
6964         if (!instance->reply_map)
6965                 return -ENOMEM;
6966
6967         switch (instance->adapter_type) {
6968         case MFI_SERIES:
6969                 if (megasas_alloc_mfi_ctrl_mem(instance))
6970                         goto fail;
6971                 break;
6972         case AERO_SERIES:
6973         case VENTURA_SERIES:
6974         case THUNDERBOLT_SERIES:
6975         case INVADER_SERIES:
6976                 if (megasas_alloc_fusion_context(instance))
6977                         goto fail;
6978                 break;
6979         }
6980
6981         return 0;
6982  fail:
6983         kfree(instance->reply_map);
6984         instance->reply_map = NULL;
6985         return -ENOMEM;
6986 }
6987
6988 /*
6989  * megasas_free_ctrl_mem -      Free fusion context for fusion adapters and
6990  *                              producer, consumer buffers for MFI adapters
6991  *
6992  * @instance -                  Adapter soft instance
6993  *
6994  */
6995 static inline void megasas_free_ctrl_mem(struct megasas_instance *instance)
6996 {
6997         kfree(instance->reply_map);
6998         if (instance->adapter_type == MFI_SERIES) {
6999                 if (instance->producer)
7000                         dma_free_coherent(&instance->pdev->dev, sizeof(u32),
7001                                             instance->producer,
7002                                             instance->producer_h);
7003                 if (instance->consumer)
7004                         dma_free_coherent(&instance->pdev->dev, sizeof(u32),
7005                                             instance->consumer,
7006                                             instance->consumer_h);
7007         } else {
7008                 megasas_free_fusion_context(instance);
7009         }
7010 }
7011
7012 /**
7013  * megasas_alloc_ctrl_dma_buffers -     Allocate consistent DMA buffers during
7014  *                                      driver load time
7015  *
7016  * @instance-                           Adapter soft instance
7017  * @return-                             O for SUCCESS
7018  */
7019 static inline
7020 int megasas_alloc_ctrl_dma_buffers(struct megasas_instance *instance)
7021 {
7022         struct pci_dev *pdev = instance->pdev;
7023         struct fusion_context *fusion = instance->ctrl_context;
7024
7025         instance->evt_detail = dma_alloc_coherent(&pdev->dev,
7026                         sizeof(struct megasas_evt_detail),
7027                         &instance->evt_detail_h, GFP_KERNEL);
7028
7029         if (!instance->evt_detail) {
7030                 dev_err(&instance->pdev->dev,
7031                         "Failed to allocate event detail buffer\n");
7032                 return -ENOMEM;
7033         }
7034
7035         if (fusion) {
7036                 fusion->ioc_init_request =
7037                         dma_alloc_coherent(&pdev->dev,
7038                                            sizeof(struct MPI2_IOC_INIT_REQUEST),
7039                                            &fusion->ioc_init_request_phys,
7040                                            GFP_KERNEL);
7041
7042                 if (!fusion->ioc_init_request) {
7043                         dev_err(&pdev->dev,
7044                                 "Failed to allocate PD list buffer\n");
7045                         return -ENOMEM;
7046                 }
7047
7048                 instance->snapdump_prop = dma_alloc_coherent(&pdev->dev,
7049                                 sizeof(struct MR_SNAPDUMP_PROPERTIES),
7050                                 &instance->snapdump_prop_h, GFP_KERNEL);
7051
7052                 if (!instance->snapdump_prop)
7053                         dev_err(&pdev->dev,
7054                                 "Failed to allocate snapdump properties buffer\n");
7055
7056                 instance->host_device_list_buf = dma_alloc_coherent(&pdev->dev,
7057                                                         HOST_DEVICE_LIST_SZ,
7058                                                         &instance->host_device_list_buf_h,
7059                                                         GFP_KERNEL);
7060
7061                 if (!instance->host_device_list_buf) {
7062                         dev_err(&pdev->dev,
7063                                 "Failed to allocate targetid list buffer\n");
7064                         return -ENOMEM;
7065                 }
7066
7067         }
7068
7069         instance->pd_list_buf =
7070                 dma_alloc_coherent(&pdev->dev,
7071                                      MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
7072                                      &instance->pd_list_buf_h, GFP_KERNEL);
7073
7074         if (!instance->pd_list_buf) {
7075                 dev_err(&pdev->dev, "Failed to allocate PD list buffer\n");
7076                 return -ENOMEM;
7077         }
7078
7079         instance->ctrl_info_buf =
7080                 dma_alloc_coherent(&pdev->dev,
7081                                      sizeof(struct megasas_ctrl_info),
7082                                      &instance->ctrl_info_buf_h, GFP_KERNEL);
7083
7084         if (!instance->ctrl_info_buf) {
7085                 dev_err(&pdev->dev,
7086                         "Failed to allocate controller info buffer\n");
7087                 return -ENOMEM;
7088         }
7089
7090         instance->ld_list_buf =
7091                 dma_alloc_coherent(&pdev->dev,
7092                                      sizeof(struct MR_LD_LIST),
7093                                      &instance->ld_list_buf_h, GFP_KERNEL);
7094
7095         if (!instance->ld_list_buf) {
7096                 dev_err(&pdev->dev, "Failed to allocate LD list buffer\n");
7097                 return -ENOMEM;
7098         }
7099
7100         instance->ld_targetid_list_buf =
7101                 dma_alloc_coherent(&pdev->dev,
7102                                 sizeof(struct MR_LD_TARGETID_LIST),
7103                                 &instance->ld_targetid_list_buf_h, GFP_KERNEL);
7104
7105         if (!instance->ld_targetid_list_buf) {
7106                 dev_err(&pdev->dev,
7107                         "Failed to allocate LD targetid list buffer\n");
7108                 return -ENOMEM;
7109         }
7110
7111         if (!reset_devices) {
7112                 instance->system_info_buf =
7113                         dma_alloc_coherent(&pdev->dev,
7114                                         sizeof(struct MR_DRV_SYSTEM_INFO),
7115                                         &instance->system_info_h, GFP_KERNEL);
7116                 instance->pd_info =
7117                         dma_alloc_coherent(&pdev->dev,
7118                                         sizeof(struct MR_PD_INFO),
7119                                         &instance->pd_info_h, GFP_KERNEL);
7120                 instance->tgt_prop =
7121                         dma_alloc_coherent(&pdev->dev,
7122                                         sizeof(struct MR_TARGET_PROPERTIES),
7123                                         &instance->tgt_prop_h, GFP_KERNEL);
7124                 instance->crash_dump_buf =
7125                         dma_alloc_coherent(&pdev->dev, CRASH_DMA_BUF_SIZE,
7126                                         &instance->crash_dump_h, GFP_KERNEL);
7127
7128                 if (!instance->system_info_buf)
7129                         dev_err(&instance->pdev->dev,
7130                                 "Failed to allocate system info buffer\n");
7131
7132                 if (!instance->pd_info)
7133                         dev_err(&instance->pdev->dev,
7134                                 "Failed to allocate pd_info buffer\n");
7135
7136                 if (!instance->tgt_prop)
7137                         dev_err(&instance->pdev->dev,
7138                                 "Failed to allocate tgt_prop buffer\n");
7139
7140                 if (!instance->crash_dump_buf)
7141                         dev_err(&instance->pdev->dev,
7142                                 "Failed to allocate crash dump buffer\n");
7143         }
7144
7145         return 0;
7146 }
7147
7148 /*
7149  * megasas_free_ctrl_dma_buffers -      Free consistent DMA buffers allocated
7150  *                                      during driver load time
7151  *
7152  * @instance-                           Adapter soft instance
7153  *
7154  */
7155 static inline
7156 void megasas_free_ctrl_dma_buffers(struct megasas_instance *instance)
7157 {
7158         struct pci_dev *pdev = instance->pdev;
7159         struct fusion_context *fusion = instance->ctrl_context;
7160
7161         if (instance->evt_detail)
7162                 dma_free_coherent(&pdev->dev, sizeof(struct megasas_evt_detail),
7163                                     instance->evt_detail,
7164                                     instance->evt_detail_h);
7165
7166         if (fusion && fusion->ioc_init_request)
7167                 dma_free_coherent(&pdev->dev,
7168                                   sizeof(struct MPI2_IOC_INIT_REQUEST),
7169                                   fusion->ioc_init_request,
7170                                   fusion->ioc_init_request_phys);
7171
7172         if (instance->pd_list_buf)
7173                 dma_free_coherent(&pdev->dev,
7174                                     MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
7175                                     instance->pd_list_buf,
7176                                     instance->pd_list_buf_h);
7177
7178         if (instance->ld_list_buf)
7179                 dma_free_coherent(&pdev->dev, sizeof(struct MR_LD_LIST),
7180                                     instance->ld_list_buf,
7181                                     instance->ld_list_buf_h);
7182
7183         if (instance->ld_targetid_list_buf)
7184                 dma_free_coherent(&pdev->dev, sizeof(struct MR_LD_TARGETID_LIST),
7185                                     instance->ld_targetid_list_buf,
7186                                     instance->ld_targetid_list_buf_h);
7187
7188         if (instance->ctrl_info_buf)
7189                 dma_free_coherent(&pdev->dev, sizeof(struct megasas_ctrl_info),
7190                                     instance->ctrl_info_buf,
7191                                     instance->ctrl_info_buf_h);
7192
7193         if (instance->system_info_buf)
7194                 dma_free_coherent(&pdev->dev, sizeof(struct MR_DRV_SYSTEM_INFO),
7195                                     instance->system_info_buf,
7196                                     instance->system_info_h);
7197
7198         if (instance->pd_info)
7199                 dma_free_coherent(&pdev->dev, sizeof(struct MR_PD_INFO),
7200                                     instance->pd_info, instance->pd_info_h);
7201
7202         if (instance->tgt_prop)
7203                 dma_free_coherent(&pdev->dev, sizeof(struct MR_TARGET_PROPERTIES),
7204                                     instance->tgt_prop, instance->tgt_prop_h);
7205
7206         if (instance->crash_dump_buf)
7207                 dma_free_coherent(&pdev->dev, CRASH_DMA_BUF_SIZE,
7208                                     instance->crash_dump_buf,
7209                                     instance->crash_dump_h);
7210
7211         if (instance->snapdump_prop)
7212                 dma_free_coherent(&pdev->dev,
7213                                   sizeof(struct MR_SNAPDUMP_PROPERTIES),
7214                                   instance->snapdump_prop,
7215                                   instance->snapdump_prop_h);
7216
7217         if (instance->host_device_list_buf)
7218                 dma_free_coherent(&pdev->dev,
7219                                   HOST_DEVICE_LIST_SZ,
7220                                   instance->host_device_list_buf,
7221                                   instance->host_device_list_buf_h);
7222
7223 }
7224
7225 /*
7226  * megasas_init_ctrl_params -           Initialize controller's instance
7227  *                                      parameters before FW init
7228  * @instance -                          Adapter soft instance
7229  * @return -                            void
7230  */
7231 static inline void megasas_init_ctrl_params(struct megasas_instance *instance)
7232 {
7233         instance->fw_crash_state = UNAVAILABLE;
7234
7235         megasas_poll_wait_aen = 0;
7236         instance->issuepend_done = 1;
7237         atomic_set(&instance->adprecovery, MEGASAS_HBA_OPERATIONAL);
7238
7239         /*
7240          * Initialize locks and queues
7241          */
7242         INIT_LIST_HEAD(&instance->cmd_pool);
7243         INIT_LIST_HEAD(&instance->internal_reset_pending_q);
7244
7245         atomic_set(&instance->fw_outstanding, 0);
7246         atomic64_set(&instance->total_io_count, 0);
7247
7248         init_waitqueue_head(&instance->int_cmd_wait_q);
7249         init_waitqueue_head(&instance->abort_cmd_wait_q);
7250
7251         spin_lock_init(&instance->crashdump_lock);
7252         spin_lock_init(&instance->mfi_pool_lock);
7253         spin_lock_init(&instance->hba_lock);
7254         spin_lock_init(&instance->stream_lock);
7255         spin_lock_init(&instance->completion_lock);
7256
7257         mutex_init(&instance->reset_mutex);
7258
7259         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
7260             (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY))
7261                 instance->flag_ieee = 1;
7262
7263         megasas_dbg_lvl = 0;
7264         instance->flag = 0;
7265         instance->unload = 1;
7266         instance->last_time = 0;
7267         instance->disableOnlineCtrlReset = 1;
7268         instance->UnevenSpanSupport = 0;
7269         instance->smp_affinity_enable = smp_affinity_enable ? true : false;
7270         instance->msix_load_balance = false;
7271
7272         if (instance->adapter_type != MFI_SERIES)
7273                 INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq);
7274         else
7275                 INIT_WORK(&instance->work_init, process_fw_state_change_wq);
7276 }
7277
7278 /**
7279  * megasas_probe_one -  PCI hotplug entry point
7280  * @pdev:               PCI device structure
7281  * @id:                 PCI ids of supported hotplugged adapter
7282  */
7283 static int megasas_probe_one(struct pci_dev *pdev,
7284                              const struct pci_device_id *id)
7285 {
7286         int rval, pos;
7287         struct Scsi_Host *host;
7288         struct megasas_instance *instance;
7289         u16 control = 0;
7290
7291         switch (pdev->device) {
7292         case PCI_DEVICE_ID_LSI_AERO_10E0:
7293         case PCI_DEVICE_ID_LSI_AERO_10E3:
7294         case PCI_DEVICE_ID_LSI_AERO_10E4:
7295         case PCI_DEVICE_ID_LSI_AERO_10E7:
7296                 dev_err(&pdev->dev, "Adapter is in non secure mode\n");
7297                 return 1;
7298         case PCI_DEVICE_ID_LSI_AERO_10E1:
7299         case PCI_DEVICE_ID_LSI_AERO_10E5:
7300                 dev_info(&pdev->dev, "Adapter is in configurable secure mode\n");
7301                 break;
7302         }
7303
7304         /* Reset MSI-X in the kdump kernel */
7305         if (reset_devices) {
7306                 pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
7307                 if (pos) {
7308                         pci_read_config_word(pdev, pos + PCI_MSIX_FLAGS,
7309                                              &control);
7310                         if (control & PCI_MSIX_FLAGS_ENABLE) {
7311                                 dev_info(&pdev->dev, "resetting MSI-X\n");
7312                                 pci_write_config_word(pdev,
7313                                                       pos + PCI_MSIX_FLAGS,
7314                                                       control &
7315                                                       ~PCI_MSIX_FLAGS_ENABLE);
7316                         }
7317                 }
7318         }
7319
7320         /*
7321          * PCI prepping: enable device set bus mastering and dma mask
7322          */
7323         rval = pci_enable_device_mem(pdev);
7324
7325         if (rval) {
7326                 return rval;
7327         }
7328
7329         pci_set_master(pdev);
7330
7331         host = scsi_host_alloc(&megasas_template,
7332                                sizeof(struct megasas_instance));
7333
7334         if (!host) {
7335                 dev_printk(KERN_DEBUG, &pdev->dev, "scsi_host_alloc failed\n");
7336                 goto fail_alloc_instance;
7337         }
7338
7339         instance = (struct megasas_instance *)host->hostdata;
7340         memset(instance, 0, sizeof(*instance));
7341         atomic_set(&instance->fw_reset_no_pci_access, 0);
7342
7343         /*
7344          * Initialize PCI related and misc parameters
7345          */
7346         instance->pdev = pdev;
7347         instance->host = host;
7348         instance->unique_id = pdev->bus->number << 8 | pdev->devfn;
7349         instance->init_id = MEGASAS_DEFAULT_INIT_ID;
7350
7351         megasas_set_adapter_type(instance);
7352
7353         /*
7354          * Initialize MFI Firmware
7355          */
7356         if (megasas_init_fw(instance))
7357                 goto fail_init_mfi;
7358
7359         if (instance->requestorId) {
7360                 if (instance->PlasmaFW111) {
7361                         instance->vf_affiliation_111 =
7362                                 dma_alloc_coherent(&pdev->dev,
7363                                         sizeof(struct MR_LD_VF_AFFILIATION_111),
7364                                         &instance->vf_affiliation_111_h,
7365                                         GFP_KERNEL);
7366                         if (!instance->vf_affiliation_111)
7367                                 dev_warn(&pdev->dev, "Can't allocate "
7368                                        "memory for VF affiliation buffer\n");
7369                 } else {
7370                         instance->vf_affiliation =
7371                                 dma_alloc_coherent(&pdev->dev,
7372                                         (MAX_LOGICAL_DRIVES + 1) *
7373                                         sizeof(struct MR_LD_VF_AFFILIATION),
7374                                         &instance->vf_affiliation_h,
7375                                         GFP_KERNEL);
7376                         if (!instance->vf_affiliation)
7377                                 dev_warn(&pdev->dev, "Can't allocate "
7378                                        "memory for VF affiliation buffer\n");
7379                 }
7380         }
7381
7382         /*
7383          * Store instance in PCI softstate
7384          */
7385         pci_set_drvdata(pdev, instance);
7386
7387         /*
7388          * Add this controller to megasas_mgmt_info structure so that it
7389          * can be exported to management applications
7390          */
7391         megasas_mgmt_info.count++;
7392         megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
7393         megasas_mgmt_info.max_index++;
7394
7395         /*
7396          * Register with SCSI mid-layer
7397          */
7398         if (megasas_io_attach(instance))
7399                 goto fail_io_attach;
7400
7401         instance->unload = 0;
7402         /*
7403          * Trigger SCSI to scan our drives
7404          */
7405         if (!instance->enable_fw_dev_list ||
7406             (instance->host_device_list_buf->count > 0))
7407                 scsi_scan_host(host);
7408
7409         /*
7410          * Initiate AEN (Asynchronous Event Notification)
7411          */
7412         if (megasas_start_aen(instance)) {
7413                 dev_printk(KERN_DEBUG, &pdev->dev, "start aen failed\n");
7414                 goto fail_start_aen;
7415         }
7416
7417         megasas_setup_debugfs(instance);
7418
7419         /* Get current SR-IOV LD/VF affiliation */
7420         if (instance->requestorId)
7421                 megasas_get_ld_vf_affiliation(instance, 1);
7422
7423         return 0;
7424
7425 fail_start_aen:
7426 fail_io_attach:
7427         megasas_mgmt_info.count--;
7428         megasas_mgmt_info.max_index--;
7429         megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
7430
7431         instance->instancet->disable_intr(instance);
7432         megasas_destroy_irqs(instance);
7433
7434         if (instance->adapter_type != MFI_SERIES)
7435                 megasas_release_fusion(instance);
7436         else
7437                 megasas_release_mfi(instance);
7438         if (instance->msix_vectors)
7439                 pci_free_irq_vectors(instance->pdev);
7440 fail_init_mfi:
7441         scsi_host_put(host);
7442 fail_alloc_instance:
7443         pci_disable_device(pdev);
7444
7445         return -ENODEV;
7446 }
7447
7448 /**
7449  * megasas_flush_cache -        Requests FW to flush all its caches
7450  * @instance:                   Adapter soft state
7451  */
7452 static void megasas_flush_cache(struct megasas_instance *instance)
7453 {
7454         struct megasas_cmd *cmd;
7455         struct megasas_dcmd_frame *dcmd;
7456
7457         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
7458                 return;
7459
7460         cmd = megasas_get_cmd(instance);
7461
7462         if (!cmd)
7463                 return;
7464
7465         dcmd = &cmd->frame->dcmd;
7466
7467         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
7468
7469         dcmd->cmd = MFI_CMD_DCMD;
7470         dcmd->cmd_status = 0x0;
7471         dcmd->sge_count = 0;
7472         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
7473         dcmd->timeout = 0;
7474         dcmd->pad_0 = 0;
7475         dcmd->data_xfer_len = 0;
7476         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_CACHE_FLUSH);
7477         dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
7478
7479         if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)
7480                         != DCMD_SUCCESS) {
7481                 dev_err(&instance->pdev->dev,
7482                         "return from %s %d\n", __func__, __LINE__);
7483                 return;
7484         }
7485
7486         megasas_return_cmd(instance, cmd);
7487 }
7488
7489 /**
7490  * megasas_shutdown_controller -        Instructs FW to shutdown the controller
7491  * @instance:                           Adapter soft state
7492  * @opcode:                             Shutdown/Hibernate
7493  */
7494 static void megasas_shutdown_controller(struct megasas_instance *instance,
7495                                         u32 opcode)
7496 {
7497         struct megasas_cmd *cmd;
7498         struct megasas_dcmd_frame *dcmd;
7499
7500         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR)
7501                 return;
7502
7503         cmd = megasas_get_cmd(instance);
7504
7505         if (!cmd)
7506                 return;
7507
7508         if (instance->aen_cmd)
7509                 megasas_issue_blocked_abort_cmd(instance,
7510                         instance->aen_cmd, MFI_IO_TIMEOUT_SECS);
7511         if (instance->map_update_cmd)
7512                 megasas_issue_blocked_abort_cmd(instance,
7513                         instance->map_update_cmd, MFI_IO_TIMEOUT_SECS);
7514         if (instance->jbod_seq_cmd)
7515                 megasas_issue_blocked_abort_cmd(instance,
7516                         instance->jbod_seq_cmd, MFI_IO_TIMEOUT_SECS);
7517
7518         dcmd = &cmd->frame->dcmd;
7519
7520         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
7521
7522         dcmd->cmd = MFI_CMD_DCMD;
7523         dcmd->cmd_status = 0x0;
7524         dcmd->sge_count = 0;
7525         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
7526         dcmd->timeout = 0;
7527         dcmd->pad_0 = 0;
7528         dcmd->data_xfer_len = 0;
7529         dcmd->opcode = cpu_to_le32(opcode);
7530
7531         if (megasas_issue_blocked_cmd(instance, cmd, MFI_IO_TIMEOUT_SECS)
7532                         != DCMD_SUCCESS) {
7533                 dev_err(&instance->pdev->dev,
7534                         "return from %s %d\n", __func__, __LINE__);
7535                 return;
7536         }
7537
7538         megasas_return_cmd(instance, cmd);
7539 }
7540
7541 #ifdef CONFIG_PM
7542 /**
7543  * megasas_suspend -    driver suspend entry point
7544  * @pdev:               PCI device structure
7545  * @state:              PCI power state to suspend routine
7546  */
7547 static int
7548 megasas_suspend(struct pci_dev *pdev, pm_message_t state)
7549 {
7550         struct megasas_instance *instance;
7551
7552         instance = pci_get_drvdata(pdev);
7553
7554         if (!instance)
7555                 return 0;
7556
7557         instance->unload = 1;
7558
7559         dev_info(&pdev->dev, "%s is called\n", __func__);
7560
7561         /* Shutdown SR-IOV heartbeat timer */
7562         if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7563                 del_timer_sync(&instance->sriov_heartbeat_timer);
7564
7565         /* Stop the FW fault detection watchdog */
7566         if (instance->adapter_type != MFI_SERIES)
7567                 megasas_fusion_stop_watchdog(instance);
7568
7569         megasas_flush_cache(instance);
7570         megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN);
7571
7572         /* cancel the delayed work if this work still in queue */
7573         if (instance->ev != NULL) {
7574                 struct megasas_aen_event *ev = instance->ev;
7575                 cancel_delayed_work_sync(&ev->hotplug_work);
7576                 instance->ev = NULL;
7577         }
7578
7579         tasklet_kill(&instance->isr_tasklet);
7580
7581         pci_set_drvdata(instance->pdev, instance);
7582         instance->instancet->disable_intr(instance);
7583
7584         megasas_destroy_irqs(instance);
7585
7586         if (instance->msix_vectors)
7587                 pci_free_irq_vectors(instance->pdev);
7588
7589         pci_save_state(pdev);
7590         pci_disable_device(pdev);
7591
7592         pci_set_power_state(pdev, pci_choose_state(pdev, state));
7593
7594         return 0;
7595 }
7596
7597 /**
7598  * megasas_resume-      driver resume entry point
7599  * @pdev:               PCI device structure
7600  */
7601 static int
7602 megasas_resume(struct pci_dev *pdev)
7603 {
7604         int rval;
7605         struct Scsi_Host *host;
7606         struct megasas_instance *instance;
7607         int irq_flags = PCI_IRQ_LEGACY;
7608         u32 status_reg;
7609
7610         instance = pci_get_drvdata(pdev);
7611
7612         if (!instance)
7613                 return 0;
7614
7615         host = instance->host;
7616         pci_set_power_state(pdev, PCI_D0);
7617         pci_enable_wake(pdev, PCI_D0, 0);
7618         pci_restore_state(pdev);
7619
7620         dev_info(&pdev->dev, "%s is called\n", __func__);
7621         /*
7622          * PCI prepping: enable device set bus mastering and dma mask
7623          */
7624         rval = pci_enable_device_mem(pdev);
7625
7626         if (rval) {
7627                 dev_err(&pdev->dev, "Enable device failed\n");
7628                 return rval;
7629         }
7630
7631         pci_set_master(pdev);
7632
7633         /*
7634          * We expect the FW state to be READY
7635          */
7636
7637         if (megasas_transition_to_ready(instance, 0)) {
7638                 dev_info(&instance->pdev->dev,
7639                          "Failed to transition controller to ready from %s!\n",
7640                          __func__);
7641                 if (instance->adapter_type != MFI_SERIES) {
7642                         status_reg =
7643                                 instance->instancet->read_fw_status_reg(instance);
7644                         if (!(status_reg & MFI_RESET_ADAPTER) ||
7645                                 ((megasas_adp_reset_wait_for_ready
7646                                 (instance, true, 0)) == FAILED))
7647                                 goto fail_ready_state;
7648                 } else {
7649                         atomic_set(&instance->fw_reset_no_pci_access, 1);
7650                         instance->instancet->adp_reset
7651                                 (instance, instance->reg_set);
7652                         atomic_set(&instance->fw_reset_no_pci_access, 0);
7653
7654                         /* waiting for about 30 seconds before retry */
7655                         ssleep(30);
7656
7657                         if (megasas_transition_to_ready(instance, 0))
7658                                 goto fail_ready_state;
7659                 }
7660
7661                 dev_info(&instance->pdev->dev,
7662                          "FW restarted successfully from %s!\n",
7663                          __func__);
7664         }
7665         if (megasas_set_dma_mask(instance))
7666                 goto fail_set_dma_mask;
7667
7668         /*
7669          * Initialize MFI Firmware
7670          */
7671
7672         atomic_set(&instance->fw_outstanding, 0);
7673         atomic_set(&instance->ldio_outstanding, 0);
7674
7675         /* Now re-enable MSI-X */
7676         if (instance->msix_vectors) {
7677                 irq_flags = PCI_IRQ_MSIX;
7678                 if (instance->smp_affinity_enable)
7679                         irq_flags |= PCI_IRQ_AFFINITY;
7680         }
7681         rval = pci_alloc_irq_vectors(instance->pdev, 1,
7682                                      instance->msix_vectors ?
7683                                      instance->msix_vectors : 1, irq_flags);
7684         if (rval < 0)
7685                 goto fail_reenable_msix;
7686
7687         megasas_setup_reply_map(instance);
7688
7689         if (instance->adapter_type != MFI_SERIES) {
7690                 megasas_reset_reply_desc(instance);
7691                 if (megasas_ioc_init_fusion(instance)) {
7692                         megasas_free_cmds(instance);
7693                         megasas_free_cmds_fusion(instance);
7694                         goto fail_init_mfi;
7695                 }
7696                 if (!megasas_get_map_info(instance))
7697                         megasas_sync_map_info(instance);
7698         } else {
7699                 *instance->producer = 0;
7700                 *instance->consumer = 0;
7701                 if (megasas_issue_init_mfi(instance))
7702                         goto fail_init_mfi;
7703         }
7704
7705         if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS)
7706                 goto fail_init_mfi;
7707
7708         tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
7709                      (unsigned long)instance);
7710
7711         if (instance->msix_vectors ?
7712                         megasas_setup_irqs_msix(instance, 0) :
7713                         megasas_setup_irqs_ioapic(instance))
7714                 goto fail_init_mfi;
7715
7716         if (instance->adapter_type != MFI_SERIES)
7717                 megasas_setup_irq_poll(instance);
7718
7719         /* Re-launch SR-IOV heartbeat timer */
7720         if (instance->requestorId) {
7721                 if (!megasas_sriov_start_heartbeat(instance, 0))
7722                         megasas_start_timer(instance);
7723                 else {
7724                         instance->skip_heartbeat_timer_del = 1;
7725                         goto fail_init_mfi;
7726                 }
7727         }
7728
7729         instance->instancet->enable_intr(instance);
7730         megasas_setup_jbod_map(instance);
7731         instance->unload = 0;
7732
7733         /*
7734          * Initiate AEN (Asynchronous Event Notification)
7735          */
7736         if (megasas_start_aen(instance))
7737                 dev_err(&instance->pdev->dev, "Start AEN failed\n");
7738
7739         /* Re-launch FW fault watchdog */
7740         if (instance->adapter_type != MFI_SERIES)
7741                 if (megasas_fusion_start_watchdog(instance) != SUCCESS)
7742                         goto fail_start_watchdog;
7743
7744         return 0;
7745
7746 fail_start_watchdog:
7747         if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7748                 del_timer_sync(&instance->sriov_heartbeat_timer);
7749 fail_init_mfi:
7750         megasas_free_ctrl_dma_buffers(instance);
7751         megasas_free_ctrl_mem(instance);
7752         scsi_host_put(host);
7753
7754 fail_reenable_msix:
7755 fail_set_dma_mask:
7756 fail_ready_state:
7757
7758         pci_disable_device(pdev);
7759
7760         return -ENODEV;
7761 }
7762 #else
7763 #define megasas_suspend NULL
7764 #define megasas_resume  NULL
7765 #endif
7766
7767 static inline int
7768 megasas_wait_for_adapter_operational(struct megasas_instance *instance)
7769 {
7770         int wait_time = MEGASAS_RESET_WAIT_TIME * 2;
7771         int i;
7772         u8 adp_state;
7773
7774         for (i = 0; i < wait_time; i++) {
7775                 adp_state = atomic_read(&instance->adprecovery);
7776                 if ((adp_state == MEGASAS_HBA_OPERATIONAL) ||
7777                     (adp_state == MEGASAS_HW_CRITICAL_ERROR))
7778                         break;
7779
7780                 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL))
7781                         dev_notice(&instance->pdev->dev, "waiting for controller reset to finish\n");
7782
7783                 msleep(1000);
7784         }
7785
7786         if (adp_state != MEGASAS_HBA_OPERATIONAL) {
7787                 dev_info(&instance->pdev->dev,
7788                          "%s HBA failed to become operational, adp_state %d\n",
7789                          __func__, adp_state);
7790                 return 1;
7791         }
7792
7793         return 0;
7794 }
7795
7796 /**
7797  * megasas_detach_one - PCI hot"un"plug entry point
7798  * @pdev:               PCI device structure
7799  */
7800 static void megasas_detach_one(struct pci_dev *pdev)
7801 {
7802         int i;
7803         struct Scsi_Host *host;
7804         struct megasas_instance *instance;
7805         struct fusion_context *fusion;
7806         u32 pd_seq_map_sz;
7807
7808         instance = pci_get_drvdata(pdev);
7809
7810         if (!instance)
7811                 return;
7812
7813         host = instance->host;
7814         fusion = instance->ctrl_context;
7815
7816         /* Shutdown SR-IOV heartbeat timer */
7817         if (instance->requestorId && !instance->skip_heartbeat_timer_del)
7818                 del_timer_sync(&instance->sriov_heartbeat_timer);
7819
7820         /* Stop the FW fault detection watchdog */
7821         if (instance->adapter_type != MFI_SERIES)
7822                 megasas_fusion_stop_watchdog(instance);
7823
7824         if (instance->fw_crash_state != UNAVAILABLE)
7825                 megasas_free_host_crash_buffer(instance);
7826         scsi_remove_host(instance->host);
7827         instance->unload = 1;
7828
7829         if (megasas_wait_for_adapter_operational(instance))
7830                 goto skip_firing_dcmds;
7831
7832         megasas_flush_cache(instance);
7833         megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
7834
7835 skip_firing_dcmds:
7836         /* cancel the delayed work if this work still in queue*/
7837         if (instance->ev != NULL) {
7838                 struct megasas_aen_event *ev = instance->ev;
7839                 cancel_delayed_work_sync(&ev->hotplug_work);
7840                 instance->ev = NULL;
7841         }
7842
7843         /* cancel all wait events */
7844         wake_up_all(&instance->int_cmd_wait_q);
7845
7846         tasklet_kill(&instance->isr_tasklet);
7847
7848         /*
7849          * Take the instance off the instance array. Note that we will not
7850          * decrement the max_index. We let this array be sparse array
7851          */
7852         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
7853                 if (megasas_mgmt_info.instance[i] == instance) {
7854                         megasas_mgmt_info.count--;
7855                         megasas_mgmt_info.instance[i] = NULL;
7856
7857                         break;
7858                 }
7859         }
7860
7861         instance->instancet->disable_intr(instance);
7862
7863         megasas_destroy_irqs(instance);
7864
7865         if (instance->msix_vectors)
7866                 pci_free_irq_vectors(instance->pdev);
7867
7868         if (instance->adapter_type >= VENTURA_SERIES) {
7869                 for (i = 0; i < MAX_LOGICAL_DRIVES_EXT; ++i)
7870                         kfree(fusion->stream_detect_by_ld[i]);
7871                 kfree(fusion->stream_detect_by_ld);
7872                 fusion->stream_detect_by_ld = NULL;
7873         }
7874
7875
7876         if (instance->adapter_type != MFI_SERIES) {
7877                 megasas_release_fusion(instance);
7878                         pd_seq_map_sz = sizeof(struct MR_PD_CFG_SEQ_NUM_SYNC) +
7879                                 (sizeof(struct MR_PD_CFG_SEQ) *
7880                                         (MAX_PHYSICAL_DEVICES - 1));
7881                 for (i = 0; i < 2 ; i++) {
7882                         if (fusion->ld_map[i])
7883                                 dma_free_coherent(&instance->pdev->dev,
7884                                                   fusion->max_map_sz,
7885                                                   fusion->ld_map[i],
7886                                                   fusion->ld_map_phys[i]);
7887                         if (fusion->ld_drv_map[i]) {
7888                                 if (is_vmalloc_addr(fusion->ld_drv_map[i]))
7889                                         vfree(fusion->ld_drv_map[i]);
7890                                 else
7891                                         free_pages((ulong)fusion->ld_drv_map[i],
7892                                                    fusion->drv_map_pages);
7893                         }
7894
7895                         if (fusion->pd_seq_sync[i])
7896                                 dma_free_coherent(&instance->pdev->dev,
7897                                         pd_seq_map_sz,
7898                                         fusion->pd_seq_sync[i],
7899                                         fusion->pd_seq_phys[i]);
7900                 }
7901         } else {
7902                 megasas_release_mfi(instance);
7903         }
7904
7905         if (instance->vf_affiliation)
7906                 dma_free_coherent(&pdev->dev, (MAX_LOGICAL_DRIVES + 1) *
7907                                     sizeof(struct MR_LD_VF_AFFILIATION),
7908                                     instance->vf_affiliation,
7909                                     instance->vf_affiliation_h);
7910
7911         if (instance->vf_affiliation_111)
7912                 dma_free_coherent(&pdev->dev,
7913                                     sizeof(struct MR_LD_VF_AFFILIATION_111),
7914                                     instance->vf_affiliation_111,
7915                                     instance->vf_affiliation_111_h);
7916
7917         if (instance->hb_host_mem)
7918                 dma_free_coherent(&pdev->dev, sizeof(struct MR_CTRL_HB_HOST_MEM),
7919                                     instance->hb_host_mem,
7920                                     instance->hb_host_mem_h);
7921
7922         megasas_free_ctrl_dma_buffers(instance);
7923
7924         megasas_free_ctrl_mem(instance);
7925
7926         megasas_destroy_debugfs(instance);
7927
7928         scsi_host_put(host);
7929
7930         pci_disable_device(pdev);
7931 }
7932
7933 /**
7934  * megasas_shutdown -   Shutdown entry point
7935  * @device:             Generic device structure
7936  */
7937 static void megasas_shutdown(struct pci_dev *pdev)
7938 {
7939         struct megasas_instance *instance = pci_get_drvdata(pdev);
7940
7941         if (!instance)
7942                 return;
7943
7944         instance->unload = 1;
7945
7946         if (megasas_wait_for_adapter_operational(instance))
7947                 goto skip_firing_dcmds;
7948
7949         megasas_flush_cache(instance);
7950         megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
7951
7952 skip_firing_dcmds:
7953         instance->instancet->disable_intr(instance);
7954         megasas_destroy_irqs(instance);
7955
7956         if (instance->msix_vectors)
7957                 pci_free_irq_vectors(instance->pdev);
7958 }
7959
7960 /**
7961  * megasas_mgmt_open -  char node "open" entry point
7962  */
7963 static int megasas_mgmt_open(struct inode *inode, struct file *filep)
7964 {
7965         /*
7966          * Allow only those users with admin rights
7967          */
7968         if (!capable(CAP_SYS_ADMIN))
7969                 return -EACCES;
7970
7971         return 0;
7972 }
7973
7974 /**
7975  * megasas_mgmt_fasync -        Async notifier registration from applications
7976  *
7977  * This function adds the calling process to a driver global queue. When an
7978  * event occurs, SIGIO will be sent to all processes in this queue.
7979  */
7980 static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)
7981 {
7982         int rc;
7983
7984         mutex_lock(&megasas_async_queue_mutex);
7985
7986         rc = fasync_helper(fd, filep, mode, &megasas_async_queue);
7987
7988         mutex_unlock(&megasas_async_queue_mutex);
7989
7990         if (rc >= 0) {
7991                 /* For sanity check when we get ioctl */
7992                 filep->private_data = filep;
7993                 return 0;
7994         }
7995
7996         printk(KERN_DEBUG "megasas: fasync_helper failed [%d]\n", rc);
7997
7998         return rc;
7999 }
8000
8001 /**
8002  * megasas_mgmt_poll -  char node "poll" entry point
8003  * */
8004 static __poll_t megasas_mgmt_poll(struct file *file, poll_table *wait)
8005 {
8006         __poll_t mask;
8007         unsigned long flags;
8008
8009         poll_wait(file, &megasas_poll_wait, wait);
8010         spin_lock_irqsave(&poll_aen_lock, flags);
8011         if (megasas_poll_wait_aen)
8012                 mask = (EPOLLIN | EPOLLRDNORM);
8013         else
8014                 mask = 0;
8015         megasas_poll_wait_aen = 0;
8016         spin_unlock_irqrestore(&poll_aen_lock, flags);
8017         return mask;
8018 }
8019
8020 /*
8021  * megasas_set_crash_dump_params_ioctl:
8022  *              Send CRASH_DUMP_MODE DCMD to all controllers
8023  * @cmd:        MFI command frame
8024  */
8025
8026 static int megasas_set_crash_dump_params_ioctl(struct megasas_cmd *cmd)
8027 {
8028         struct megasas_instance *local_instance;
8029         int i, error = 0;
8030         int crash_support;
8031
8032         crash_support = cmd->frame->dcmd.mbox.w[0];
8033
8034         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
8035                 local_instance = megasas_mgmt_info.instance[i];
8036                 if (local_instance && local_instance->crash_dump_drv_support) {
8037                         if ((atomic_read(&local_instance->adprecovery) ==
8038                                 MEGASAS_HBA_OPERATIONAL) &&
8039                                 !megasas_set_crash_dump_params(local_instance,
8040                                         crash_support)) {
8041                                 local_instance->crash_dump_app_support =
8042                                         crash_support;
8043                                 dev_info(&local_instance->pdev->dev,
8044                                         "Application firmware crash "
8045                                         "dump mode set success\n");
8046                                 error = 0;
8047                         } else {
8048                                 dev_info(&local_instance->pdev->dev,
8049                                         "Application firmware crash "
8050                                         "dump mode set failed\n");
8051                                 error = -1;
8052                         }
8053                 }
8054         }
8055         return error;
8056 }
8057
8058 /**
8059  * megasas_mgmt_fw_ioctl -      Issues management ioctls to FW
8060  * @instance:                   Adapter soft state
8061  * @argp:                       User's ioctl packet
8062  */
8063 static int
8064 megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
8065                       struct megasas_iocpacket __user * user_ioc,
8066                       struct megasas_iocpacket *ioc)
8067 {
8068         struct megasas_sge64 *kern_sge64 = NULL;
8069         struct megasas_sge32 *kern_sge32 = NULL;
8070         struct megasas_cmd *cmd;
8071         void *kbuff_arr[MAX_IOCTL_SGE];
8072         dma_addr_t buf_handle = 0;
8073         int error = 0, i;
8074         void *sense = NULL;
8075         dma_addr_t sense_handle;
8076         unsigned long *sense_ptr;
8077         u32 opcode = 0;
8078         int ret = DCMD_SUCCESS;
8079
8080         memset(kbuff_arr, 0, sizeof(kbuff_arr));
8081
8082         if (ioc->sge_count > MAX_IOCTL_SGE) {
8083                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "SGE count [%d] >  max limit [%d]\n",
8084                        ioc->sge_count, MAX_IOCTL_SGE);
8085                 return -EINVAL;
8086         }
8087
8088         if ((ioc->frame.hdr.cmd >= MFI_CMD_OP_COUNT) ||
8089             ((ioc->frame.hdr.cmd == MFI_CMD_NVME) &&
8090             !instance->support_nvme_passthru) ||
8091             ((ioc->frame.hdr.cmd == MFI_CMD_TOOLBOX) &&
8092             !instance->support_pci_lane_margining)) {
8093                 dev_err(&instance->pdev->dev,
8094                         "Received invalid ioctl command 0x%x\n",
8095                         ioc->frame.hdr.cmd);
8096                 return -ENOTSUPP;
8097         }
8098
8099         cmd = megasas_get_cmd(instance);
8100         if (!cmd) {
8101                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to get a cmd packet\n");
8102                 return -ENOMEM;
8103         }
8104
8105         /*
8106          * User's IOCTL packet has 2 frames (maximum). Copy those two
8107          * frames into our cmd's frames. cmd->frame's context will get
8108          * overwritten when we copy from user's frames. So set that value
8109          * alone separately
8110          */
8111         memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE);
8112         cmd->frame->hdr.context = cpu_to_le32(cmd->index);
8113         cmd->frame->hdr.pad_0 = 0;
8114
8115         cmd->frame->hdr.flags &= (~MFI_FRAME_IEEE);
8116
8117         if (instance->consistent_mask_64bit)
8118                 cmd->frame->hdr.flags |= cpu_to_le16((MFI_FRAME_SGL64 |
8119                                        MFI_FRAME_SENSE64));
8120         else
8121                 cmd->frame->hdr.flags &= cpu_to_le16(~(MFI_FRAME_SGL64 |
8122                                                MFI_FRAME_SENSE64));
8123
8124         if (cmd->frame->hdr.cmd == MFI_CMD_DCMD)
8125                 opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
8126
8127         if (opcode == MR_DCMD_CTRL_SHUTDOWN) {
8128                 mutex_lock(&instance->reset_mutex);
8129                 if (megasas_get_ctrl_info(instance) != DCMD_SUCCESS) {
8130                         megasas_return_cmd(instance, cmd);
8131                         mutex_unlock(&instance->reset_mutex);
8132                         return -1;
8133                 }
8134                 mutex_unlock(&instance->reset_mutex);
8135         }
8136
8137         if (opcode == MR_DRIVER_SET_APP_CRASHDUMP_MODE) {
8138                 error = megasas_set_crash_dump_params_ioctl(cmd);
8139                 megasas_return_cmd(instance, cmd);
8140                 return error;
8141         }
8142
8143         /*
8144          * The management interface between applications and the fw uses
8145          * MFI frames. E.g, RAID configuration changes, LD property changes
8146          * etc are accomplishes through different kinds of MFI frames. The
8147          * driver needs to care only about substituting user buffers with
8148          * kernel buffers in SGLs. The location of SGL is embedded in the
8149          * struct iocpacket itself.
8150          */
8151         if (instance->consistent_mask_64bit)
8152                 kern_sge64 = (struct megasas_sge64 *)
8153                         ((unsigned long)cmd->frame + ioc->sgl_off);
8154         else
8155                 kern_sge32 = (struct megasas_sge32 *)
8156                         ((unsigned long)cmd->frame + ioc->sgl_off);
8157
8158         /*
8159          * For each user buffer, create a mirror buffer and copy in
8160          */
8161         for (i = 0; i < ioc->sge_count; i++) {
8162                 if (!ioc->sgl[i].iov_len)
8163                         continue;
8164
8165                 kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev,
8166                                                     ioc->sgl[i].iov_len,
8167                                                     &buf_handle, GFP_KERNEL);
8168                 if (!kbuff_arr[i]) {
8169                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "Failed to alloc "
8170                                "kernel SGL buffer for IOCTL\n");
8171                         error = -ENOMEM;
8172                         goto out;
8173                 }
8174
8175                 /*
8176                  * We don't change the dma_coherent_mask, so
8177                  * dma_alloc_coherent only returns 32bit addresses
8178                  */
8179                 if (instance->consistent_mask_64bit) {
8180                         kern_sge64[i].phys_addr = cpu_to_le64(buf_handle);
8181                         kern_sge64[i].length = cpu_to_le32(ioc->sgl[i].iov_len);
8182                 } else {
8183                         kern_sge32[i].phys_addr = cpu_to_le32(buf_handle);
8184                         kern_sge32[i].length = cpu_to_le32(ioc->sgl[i].iov_len);
8185                 }
8186
8187                 /*
8188                  * We created a kernel buffer corresponding to the
8189                  * user buffer. Now copy in from the user buffer
8190                  */
8191                 if (copy_from_user(kbuff_arr[i], ioc->sgl[i].iov_base,
8192                                    (u32) (ioc->sgl[i].iov_len))) {
8193                         error = -EFAULT;
8194                         goto out;
8195                 }
8196         }
8197
8198         if (ioc->sense_len) {
8199                 sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len,
8200                                              &sense_handle, GFP_KERNEL);
8201                 if (!sense) {
8202                         error = -ENOMEM;
8203                         goto out;
8204                 }
8205
8206                 sense_ptr =
8207                 (unsigned long *) ((unsigned long)cmd->frame + ioc->sense_off);
8208                 if (instance->consistent_mask_64bit)
8209                         *sense_ptr = cpu_to_le64(sense_handle);
8210                 else
8211                         *sense_ptr = cpu_to_le32(sense_handle);
8212         }
8213
8214         /*
8215          * Set the sync_cmd flag so that the ISR knows not to complete this
8216          * cmd to the SCSI mid-layer
8217          */
8218         cmd->sync_cmd = 1;
8219
8220         ret = megasas_issue_blocked_cmd(instance, cmd, 0);
8221         switch (ret) {
8222         case DCMD_INIT:
8223         case DCMD_BUSY:
8224                 cmd->sync_cmd = 0;
8225                 dev_err(&instance->pdev->dev,
8226                         "return -EBUSY from %s %d cmd 0x%x opcode 0x%x cmd->cmd_status_drv 0x%x\n",
8227                          __func__, __LINE__, cmd->frame->hdr.cmd, opcode,
8228                          cmd->cmd_status_drv);
8229                         error = -EBUSY;
8230                         goto out;
8231         }
8232
8233         cmd->sync_cmd = 0;
8234
8235         if (instance->unload == 1) {
8236                 dev_info(&instance->pdev->dev, "Driver unload is in progress "
8237                         "don't submit data to application\n");
8238                 goto out;
8239         }
8240         /*
8241          * copy out the kernel buffers to user buffers
8242          */
8243         for (i = 0; i < ioc->sge_count; i++) {
8244                 if (copy_to_user(ioc->sgl[i].iov_base, kbuff_arr[i],
8245                                  ioc->sgl[i].iov_len)) {
8246                         error = -EFAULT;
8247                         goto out;
8248                 }
8249         }
8250
8251         /*
8252          * copy out the sense
8253          */
8254         if (ioc->sense_len) {
8255                 /*
8256                  * sense_ptr points to the location that has the user
8257                  * sense buffer address
8258                  */
8259                 sense_ptr = (unsigned long *) ((unsigned long)ioc->frame.raw +
8260                                 ioc->sense_off);
8261
8262                 if (copy_to_user((void __user *)((unsigned long)
8263                                  get_unaligned((unsigned long *)sense_ptr)),
8264                                  sense, ioc->sense_len)) {
8265                         dev_err(&instance->pdev->dev, "Failed to copy out to user "
8266                                         "sense data\n");
8267                         error = -EFAULT;
8268                         goto out;
8269                 }
8270         }
8271
8272         /*
8273          * copy the status codes returned by the fw
8274          */
8275         if (copy_to_user(&user_ioc->frame.hdr.cmd_status,
8276                          &cmd->frame->hdr.cmd_status, sizeof(u8))) {
8277                 dev_printk(KERN_DEBUG, &instance->pdev->dev, "Error copying out cmd_status\n");
8278                 error = -EFAULT;
8279         }
8280
8281 out:
8282         if (sense) {
8283                 dma_free_coherent(&instance->pdev->dev, ioc->sense_len,
8284                                     sense, sense_handle);
8285         }
8286
8287         for (i = 0; i < ioc->sge_count; i++) {
8288                 if (kbuff_arr[i]) {
8289                         if (instance->consistent_mask_64bit)
8290                                 dma_free_coherent(&instance->pdev->dev,
8291                                         le32_to_cpu(kern_sge64[i].length),
8292                                         kbuff_arr[i],
8293                                         le64_to_cpu(kern_sge64[i].phys_addr));
8294                         else
8295                                 dma_free_coherent(&instance->pdev->dev,
8296                                         le32_to_cpu(kern_sge32[i].length),
8297                                         kbuff_arr[i],
8298                                         le32_to_cpu(kern_sge32[i].phys_addr));
8299                         kbuff_arr[i] = NULL;
8300                 }
8301         }
8302
8303         megasas_return_cmd(instance, cmd);
8304         return error;
8305 }
8306
8307 static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
8308 {
8309         struct megasas_iocpacket __user *user_ioc =
8310             (struct megasas_iocpacket __user *)arg;
8311         struct megasas_iocpacket *ioc;
8312         struct megasas_instance *instance;
8313         int error;
8314
8315         ioc = memdup_user(user_ioc, sizeof(*ioc));
8316         if (IS_ERR(ioc))
8317                 return PTR_ERR(ioc);
8318
8319         instance = megasas_lookup_instance(ioc->host_no);
8320         if (!instance) {
8321                 error = -ENODEV;
8322                 goto out_kfree_ioc;
8323         }
8324
8325         /* Block ioctls in VF mode */
8326         if (instance->requestorId && !allow_vf_ioctls) {
8327                 error = -ENODEV;
8328                 goto out_kfree_ioc;
8329         }
8330
8331         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
8332                 dev_err(&instance->pdev->dev, "Controller in crit error\n");
8333                 error = -ENODEV;
8334                 goto out_kfree_ioc;
8335         }
8336
8337         if (instance->unload == 1) {
8338                 error = -ENODEV;
8339                 goto out_kfree_ioc;
8340         }
8341
8342         if (down_interruptible(&instance->ioctl_sem)) {
8343                 error = -ERESTARTSYS;
8344                 goto out_kfree_ioc;
8345         }
8346
8347         if  (megasas_wait_for_adapter_operational(instance)) {
8348                 error = -ENODEV;
8349                 goto out_up;
8350         }
8351
8352         error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
8353 out_up:
8354         up(&instance->ioctl_sem);
8355
8356 out_kfree_ioc:
8357         kfree(ioc);
8358         return error;
8359 }
8360
8361 static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
8362 {
8363         struct megasas_instance *instance;
8364         struct megasas_aen aen;
8365         int error;
8366
8367         if (file->private_data != file) {
8368                 printk(KERN_DEBUG "megasas: fasync_helper was not "
8369                        "called first\n");
8370                 return -EINVAL;
8371         }
8372
8373         if (copy_from_user(&aen, (void __user *)arg, sizeof(aen)))
8374                 return -EFAULT;
8375
8376         instance = megasas_lookup_instance(aen.host_no);
8377
8378         if (!instance)
8379                 return -ENODEV;
8380
8381         if (atomic_read(&instance->adprecovery) == MEGASAS_HW_CRITICAL_ERROR) {
8382                 return -ENODEV;
8383         }
8384
8385         if (instance->unload == 1) {
8386                 return -ENODEV;
8387         }
8388
8389         if  (megasas_wait_for_adapter_operational(instance))
8390                 return -ENODEV;
8391
8392         mutex_lock(&instance->reset_mutex);
8393         error = megasas_register_aen(instance, aen.seq_num,
8394                                      aen.class_locale_word);
8395         mutex_unlock(&instance->reset_mutex);
8396         return error;
8397 }
8398
8399 /**
8400  * megasas_mgmt_ioctl - char node ioctl entry point
8401  */
8402 static long
8403 megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
8404 {
8405         switch (cmd) {
8406         case MEGASAS_IOC_FIRMWARE:
8407                 return megasas_mgmt_ioctl_fw(file, arg);
8408
8409         case MEGASAS_IOC_GET_AEN:
8410                 return megasas_mgmt_ioctl_aen(file, arg);
8411         }
8412
8413         return -ENOTTY;
8414 }
8415
8416 #ifdef CONFIG_COMPAT
8417 static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
8418 {
8419         struct compat_megasas_iocpacket __user *cioc =
8420             (struct compat_megasas_iocpacket __user *)arg;
8421         struct megasas_iocpacket __user *ioc =
8422             compat_alloc_user_space(sizeof(struct megasas_iocpacket));
8423         int i;
8424         int error = 0;
8425         compat_uptr_t ptr;
8426         u32 local_sense_off;
8427         u32 local_sense_len;
8428         u32 user_sense_off;
8429
8430         if (clear_user(ioc, sizeof(*ioc)))
8431                 return -EFAULT;
8432
8433         if (copy_in_user(&ioc->host_no, &cioc->host_no, sizeof(u16)) ||
8434             copy_in_user(&ioc->sgl_off, &cioc->sgl_off, sizeof(u32)) ||
8435             copy_in_user(&ioc->sense_off, &cioc->sense_off, sizeof(u32)) ||
8436             copy_in_user(&ioc->sense_len, &cioc->sense_len, sizeof(u32)) ||
8437             copy_in_user(ioc->frame.raw, cioc->frame.raw, 128) ||
8438             copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32)))
8439                 return -EFAULT;
8440
8441         /*
8442          * The sense_ptr is used in megasas_mgmt_fw_ioctl only when
8443          * sense_len is not null, so prepare the 64bit value under
8444          * the same condition.
8445          */
8446         if (get_user(local_sense_off, &ioc->sense_off) ||
8447                 get_user(local_sense_len, &ioc->sense_len) ||
8448                 get_user(user_sense_off, &cioc->sense_off))
8449                 return -EFAULT;
8450
8451         if (local_sense_off != user_sense_off)
8452                 return -EINVAL;
8453
8454         if (local_sense_len) {
8455                 void __user **sense_ioc_ptr =
8456                         (void __user **)((u8 *)((unsigned long)&ioc->frame.raw) + local_sense_off);
8457                 compat_uptr_t *sense_cioc_ptr =
8458                         (compat_uptr_t *)(((unsigned long)&cioc->frame.raw) + user_sense_off);
8459                 if (get_user(ptr, sense_cioc_ptr) ||
8460                     put_user(compat_ptr(ptr), sense_ioc_ptr))
8461                         return -EFAULT;
8462         }
8463
8464         for (i = 0; i < MAX_IOCTL_SGE; i++) {
8465                 if (get_user(ptr, &cioc->sgl[i].iov_base) ||
8466                     put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) ||
8467                     copy_in_user(&ioc->sgl[i].iov_len,
8468                                  &cioc->sgl[i].iov_len, sizeof(compat_size_t)))
8469                         return -EFAULT;
8470         }
8471
8472         error = megasas_mgmt_ioctl_fw(file, (unsigned long)ioc);
8473
8474         if (copy_in_user(&cioc->frame.hdr.cmd_status,
8475                          &ioc->frame.hdr.cmd_status, sizeof(u8))) {
8476                 printk(KERN_DEBUG "megasas: error copy_in_user cmd_status\n");
8477                 return -EFAULT;
8478         }
8479         return error;
8480 }
8481
8482 static long
8483 megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd,
8484                           unsigned long arg)
8485 {
8486         switch (cmd) {
8487         case MEGASAS_IOC_FIRMWARE32:
8488                 return megasas_mgmt_compat_ioctl_fw(file, arg);
8489         case MEGASAS_IOC_GET_AEN:
8490                 return megasas_mgmt_ioctl_aen(file, arg);
8491         }
8492
8493         return -ENOTTY;
8494 }
8495 #endif
8496
8497 /*
8498  * File operations structure for management interface
8499  */
8500 static const struct file_operations megasas_mgmt_fops = {
8501         .owner = THIS_MODULE,
8502         .open = megasas_mgmt_open,
8503         .fasync = megasas_mgmt_fasync,
8504         .unlocked_ioctl = megasas_mgmt_ioctl,
8505         .poll = megasas_mgmt_poll,
8506 #ifdef CONFIG_COMPAT
8507         .compat_ioctl = megasas_mgmt_compat_ioctl,
8508 #endif
8509         .llseek = noop_llseek,
8510 };
8511
8512 /*
8513  * PCI hotplug support registration structure
8514  */
8515 static struct pci_driver megasas_pci_driver = {
8516
8517         .name = "megaraid_sas",
8518         .id_table = megasas_pci_table,
8519         .probe = megasas_probe_one,
8520         .remove = megasas_detach_one,
8521         .suspend = megasas_suspend,
8522         .resume = megasas_resume,
8523         .shutdown = megasas_shutdown,
8524 };
8525
8526 /*
8527  * Sysfs driver attributes
8528  */
8529 static ssize_t version_show(struct device_driver *dd, char *buf)
8530 {
8531         return snprintf(buf, strlen(MEGASAS_VERSION) + 2, "%s\n",
8532                         MEGASAS_VERSION);
8533 }
8534 static DRIVER_ATTR_RO(version);
8535
8536 static ssize_t release_date_show(struct device_driver *dd, char *buf)
8537 {
8538         return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, "%s\n",
8539                 MEGASAS_RELDATE);
8540 }
8541 static DRIVER_ATTR_RO(release_date);
8542
8543 static ssize_t support_poll_for_event_show(struct device_driver *dd, char *buf)
8544 {
8545         return sprintf(buf, "%u\n", support_poll_for_event);
8546 }
8547 static DRIVER_ATTR_RO(support_poll_for_event);
8548
8549 static ssize_t support_device_change_show(struct device_driver *dd, char *buf)
8550 {
8551         return sprintf(buf, "%u\n", support_device_change);
8552 }
8553 static DRIVER_ATTR_RO(support_device_change);
8554
8555 static ssize_t dbg_lvl_show(struct device_driver *dd, char *buf)
8556 {
8557         return sprintf(buf, "%u\n", megasas_dbg_lvl);
8558 }
8559
8560 static ssize_t dbg_lvl_store(struct device_driver *dd, const char *buf,
8561                              size_t count)
8562 {
8563         int retval = count;
8564
8565         if (sscanf(buf, "%u", &megasas_dbg_lvl) < 1) {
8566                 printk(KERN_ERR "megasas: could not set dbg_lvl\n");
8567                 retval = -EINVAL;
8568         }
8569         return retval;
8570 }
8571 static DRIVER_ATTR_RW(dbg_lvl);
8572
8573 static ssize_t
8574 support_nvme_encapsulation_show(struct device_driver *dd, char *buf)
8575 {
8576         return sprintf(buf, "%u\n", support_nvme_encapsulation);
8577 }
8578
8579 static DRIVER_ATTR_RO(support_nvme_encapsulation);
8580
8581 static ssize_t
8582 support_pci_lane_margining_show(struct device_driver *dd, char *buf)
8583 {
8584         return sprintf(buf, "%u\n", support_pci_lane_margining);
8585 }
8586
8587 static DRIVER_ATTR_RO(support_pci_lane_margining);
8588
8589 static inline void megasas_remove_scsi_device(struct scsi_device *sdev)
8590 {
8591         sdev_printk(KERN_INFO, sdev, "SCSI device is removed\n");
8592         scsi_remove_device(sdev);
8593         scsi_device_put(sdev);
8594 }
8595
8596 /**
8597  * megasas_update_device_list - Update the PD and LD device list from FW
8598  *                              after an AEN event notification
8599  * @instance:                   Adapter soft state
8600  * @event_type:                 Indicates type of event (PD or LD event)
8601  *
8602  * @return:                     Success or failure
8603  *
8604  * Issue DCMDs to Firmware to update the internal device list in driver.
8605  * Based on the FW support, driver sends the HOST_DEVICE_LIST or combination
8606  * of PD_LIST/LD_LIST_QUERY DCMDs to get the device list.
8607  */
8608 static
8609 int megasas_update_device_list(struct megasas_instance *instance,
8610                                int event_type)
8611 {
8612         int dcmd_ret = DCMD_SUCCESS;
8613
8614         if (instance->enable_fw_dev_list) {
8615                 dcmd_ret = megasas_host_device_list_query(instance, false);
8616                 if (dcmd_ret != DCMD_SUCCESS)
8617                         goto out;
8618         } else {
8619                 if (event_type & SCAN_PD_CHANNEL) {
8620                         dcmd_ret = megasas_get_pd_list(instance);
8621
8622                         if (dcmd_ret != DCMD_SUCCESS)
8623                                 goto out;
8624                 }
8625
8626                 if (event_type & SCAN_VD_CHANNEL) {
8627                         if (!instance->requestorId ||
8628                             (instance->requestorId &&
8629                              megasas_get_ld_vf_affiliation(instance, 0))) {
8630                                 dcmd_ret = megasas_ld_list_query(instance,
8631                                                 MR_LD_QUERY_TYPE_EXPOSED_TO_HOST);
8632                                 if (dcmd_ret != DCMD_SUCCESS)
8633                                         goto out;
8634                         }
8635                 }
8636         }
8637
8638 out:
8639         return dcmd_ret;
8640 }
8641
8642 /**
8643  * megasas_add_remove_devices - Add/remove devices to SCSI mid-layer
8644  *                              after an AEN event notification
8645  * @instance:                   Adapter soft state
8646  * @scan_type:                  Indicates type of devices (PD/LD) to add
8647  * @return                      void
8648  */
8649 static
8650 void megasas_add_remove_devices(struct megasas_instance *instance,
8651                                 int scan_type)
8652 {
8653         int i, j;
8654         u16 pd_index = 0;
8655         u16 ld_index = 0;
8656         u16 channel = 0, id = 0;
8657         struct Scsi_Host *host;
8658         struct scsi_device *sdev1;
8659         struct MR_HOST_DEVICE_LIST *targetid_list = NULL;
8660         struct MR_HOST_DEVICE_LIST_ENTRY *targetid_entry = NULL;
8661
8662         host = instance->host;
8663
8664         if (instance->enable_fw_dev_list) {
8665                 targetid_list = instance->host_device_list_buf;
8666                 for (i = 0; i < targetid_list->count; i++) {
8667                         targetid_entry = &targetid_list->host_device_list[i];
8668                         if (targetid_entry->flags.u.bits.is_sys_pd) {
8669                                 channel = le16_to_cpu(targetid_entry->target_id) /
8670                                                 MEGASAS_MAX_DEV_PER_CHANNEL;
8671                                 id = le16_to_cpu(targetid_entry->target_id) %
8672                                                 MEGASAS_MAX_DEV_PER_CHANNEL;
8673                         } else {
8674                                 channel = MEGASAS_MAX_PD_CHANNELS +
8675                                           (le16_to_cpu(targetid_entry->target_id) /
8676                                            MEGASAS_MAX_DEV_PER_CHANNEL);
8677                                 id = le16_to_cpu(targetid_entry->target_id) %
8678                                                 MEGASAS_MAX_DEV_PER_CHANNEL;
8679                         }
8680                         sdev1 = scsi_device_lookup(host, channel, id, 0);
8681                         if (!sdev1) {
8682                                 scsi_add_device(host, channel, id, 0);
8683                         } else {
8684                                 scsi_device_put(sdev1);
8685                         }
8686                 }
8687         }
8688
8689         if (scan_type & SCAN_PD_CHANNEL) {
8690                 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
8691                         for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
8692                                 pd_index = i * MEGASAS_MAX_DEV_PER_CHANNEL + j;
8693                                 sdev1 = scsi_device_lookup(host, i, j, 0);
8694                                 if (instance->pd_list[pd_index].driveState ==
8695                                                         MR_PD_STATE_SYSTEM) {
8696                                         if (!sdev1)
8697                                                 scsi_add_device(host, i, j, 0);
8698                                         else
8699                                                 scsi_device_put(sdev1);
8700                                 } else {
8701                                         if (sdev1)
8702                                                 megasas_remove_scsi_device(sdev1);
8703                                 }
8704                         }
8705                 }
8706         }
8707
8708         if (scan_type & SCAN_VD_CHANNEL) {
8709                 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
8710                         for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
8711                                 ld_index = (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
8712                                 sdev1 = scsi_device_lookup(host,
8713                                                 MEGASAS_MAX_PD_CHANNELS + i, j, 0);
8714                                 if (instance->ld_ids[ld_index] != 0xff) {
8715                                         if (!sdev1)
8716                                                 scsi_add_device(host, MEGASAS_MAX_PD_CHANNELS + i, j, 0);
8717                                         else
8718                                                 scsi_device_put(sdev1);
8719                                 } else {
8720                                         if (sdev1)
8721                                                 megasas_remove_scsi_device(sdev1);
8722                                 }
8723                         }
8724                 }
8725         }
8726
8727 }
8728
8729 static void
8730 megasas_aen_polling(struct work_struct *work)
8731 {
8732         struct megasas_aen_event *ev =
8733                 container_of(work, struct megasas_aen_event, hotplug_work.work);
8734         struct megasas_instance *instance = ev->instance;
8735         union megasas_evt_class_locale class_locale;
8736         int event_type = 0;
8737         u32 seq_num;
8738         int error;
8739         u8  dcmd_ret = DCMD_SUCCESS;
8740
8741         if (!instance) {
8742                 printk(KERN_ERR "invalid instance!\n");
8743                 kfree(ev);
8744                 return;
8745         }
8746
8747         /* Don't run the event workqueue thread if OCR is running */
8748         mutex_lock(&instance->reset_mutex);
8749
8750         instance->ev = NULL;
8751         if (instance->evt_detail) {
8752                 megasas_decode_evt(instance);
8753
8754                 switch (le32_to_cpu(instance->evt_detail->code)) {
8755
8756                 case MR_EVT_PD_INSERTED:
8757                 case MR_EVT_PD_REMOVED:
8758                         event_type = SCAN_PD_CHANNEL;
8759                         break;
8760
8761                 case MR_EVT_LD_OFFLINE:
8762                 case MR_EVT_CFG_CLEARED:
8763                 case MR_EVT_LD_DELETED:
8764                 case MR_EVT_LD_CREATED:
8765                         event_type = SCAN_VD_CHANNEL;
8766                         break;
8767
8768                 case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
8769                 case MR_EVT_FOREIGN_CFG_IMPORTED:
8770                 case MR_EVT_LD_STATE_CHANGE:
8771                         event_type = SCAN_PD_CHANNEL | SCAN_VD_CHANNEL;
8772                         dev_info(&instance->pdev->dev, "scanning for scsi%d...\n",
8773                                 instance->host->host_no);
8774                         break;
8775
8776                 case MR_EVT_CTRL_PROP_CHANGED:
8777                         dcmd_ret = megasas_get_ctrl_info(instance);
8778                         if (dcmd_ret == DCMD_SUCCESS &&
8779                             instance->snapdump_wait_time) {
8780                                 megasas_get_snapdump_properties(instance);
8781                                 dev_info(&instance->pdev->dev,
8782                                          "Snap dump wait time\t: %d\n",
8783                                          instance->snapdump_wait_time);
8784                         }
8785                         break;
8786                 default:
8787                         event_type = 0;
8788                         break;
8789                 }
8790         } else {
8791                 dev_err(&instance->pdev->dev, "invalid evt_detail!\n");
8792                 mutex_unlock(&instance->reset_mutex);
8793                 kfree(ev);
8794                 return;
8795         }
8796
8797         if (event_type)
8798                 dcmd_ret = megasas_update_device_list(instance, event_type);
8799
8800         mutex_unlock(&instance->reset_mutex);
8801
8802         if (event_type && dcmd_ret == DCMD_SUCCESS)
8803                 megasas_add_remove_devices(instance, event_type);
8804
8805         if (dcmd_ret == DCMD_SUCCESS)
8806                 seq_num = le32_to_cpu(instance->evt_detail->seq_num) + 1;
8807         else
8808                 seq_num = instance->last_seq_num;
8809
8810         /* Register AEN with FW for latest sequence number plus 1 */
8811         class_locale.members.reserved = 0;
8812         class_locale.members.locale = MR_EVT_LOCALE_ALL;
8813         class_locale.members.class = MR_EVT_CLASS_DEBUG;
8814
8815         if (instance->aen_cmd != NULL) {
8816                 kfree(ev);
8817                 return;
8818         }
8819
8820         mutex_lock(&instance->reset_mutex);
8821         error = megasas_register_aen(instance, seq_num,
8822                                         class_locale.word);
8823         if (error)
8824                 dev_err(&instance->pdev->dev,
8825                         "register aen failed error %x\n", error);
8826
8827         mutex_unlock(&instance->reset_mutex);
8828         kfree(ev);
8829 }
8830
8831 /**
8832  * megasas_init - Driver load entry point
8833  */
8834 static int __init megasas_init(void)
8835 {
8836         int rval;
8837
8838         /*
8839          * Booted in kdump kernel, minimize memory footprints by
8840          * disabling few features
8841          */
8842         if (reset_devices) {
8843                 msix_vectors = 1;
8844                 rdpq_enable = 0;
8845                 dual_qdepth_disable = 1;
8846         }
8847
8848         /*
8849          * Announce driver version and other information
8850          */
8851         pr_info("megasas: %s\n", MEGASAS_VERSION);
8852
8853         spin_lock_init(&poll_aen_lock);
8854
8855         support_poll_for_event = 2;
8856         support_device_change = 1;
8857         support_nvme_encapsulation = true;
8858         support_pci_lane_margining = true;
8859
8860         memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info));
8861
8862         /*
8863          * Register character device node
8864          */
8865         rval = register_chrdev(0, "megaraid_sas_ioctl", &megasas_mgmt_fops);
8866
8867         if (rval < 0) {
8868                 printk(KERN_DEBUG "megasas: failed to open device node\n");
8869                 return rval;
8870         }
8871
8872         megasas_mgmt_majorno = rval;
8873
8874         megasas_init_debugfs();
8875
8876         /*
8877          * Register ourselves as PCI hotplug module
8878          */
8879         rval = pci_register_driver(&megasas_pci_driver);
8880
8881         if (rval) {
8882                 printk(KERN_DEBUG "megasas: PCI hotplug registration failed \n");
8883                 goto err_pcidrv;
8884         }
8885
8886         if ((event_log_level < MFI_EVT_CLASS_DEBUG) ||
8887             (event_log_level > MFI_EVT_CLASS_DEAD)) {
8888                 pr_warn("megaraid_sas: provided event log level is out of range, setting it to default 2(CLASS_CRITICAL), permissible range is: -2 to 4\n");
8889                 event_log_level = MFI_EVT_CLASS_CRITICAL;
8890         }
8891
8892         rval = driver_create_file(&megasas_pci_driver.driver,
8893                                   &driver_attr_version);
8894         if (rval)
8895                 goto err_dcf_attr_ver;
8896
8897         rval = driver_create_file(&megasas_pci_driver.driver,
8898                                   &driver_attr_release_date);
8899         if (rval)
8900                 goto err_dcf_rel_date;
8901
8902         rval = driver_create_file(&megasas_pci_driver.driver,
8903                                 &driver_attr_support_poll_for_event);
8904         if (rval)
8905                 goto err_dcf_support_poll_for_event;
8906
8907         rval = driver_create_file(&megasas_pci_driver.driver,
8908                                   &driver_attr_dbg_lvl);
8909         if (rval)
8910                 goto err_dcf_dbg_lvl;
8911         rval = driver_create_file(&megasas_pci_driver.driver,
8912                                 &driver_attr_support_device_change);
8913         if (rval)
8914                 goto err_dcf_support_device_change;
8915
8916         rval = driver_create_file(&megasas_pci_driver.driver,
8917                                   &driver_attr_support_nvme_encapsulation);
8918         if (rval)
8919                 goto err_dcf_support_nvme_encapsulation;
8920
8921         rval = driver_create_file(&megasas_pci_driver.driver,
8922                                   &driver_attr_support_pci_lane_margining);
8923         if (rval)
8924                 goto err_dcf_support_pci_lane_margining;
8925
8926         return rval;
8927
8928 err_dcf_support_pci_lane_margining:
8929         driver_remove_file(&megasas_pci_driver.driver,
8930                            &driver_attr_support_nvme_encapsulation);
8931
8932 err_dcf_support_nvme_encapsulation:
8933         driver_remove_file(&megasas_pci_driver.driver,
8934                            &driver_attr_support_device_change);
8935
8936 err_dcf_support_device_change:
8937         driver_remove_file(&megasas_pci_driver.driver,
8938                            &driver_attr_dbg_lvl);
8939 err_dcf_dbg_lvl:
8940         driver_remove_file(&megasas_pci_driver.driver,
8941                         &driver_attr_support_poll_for_event);
8942 err_dcf_support_poll_for_event:
8943         driver_remove_file(&megasas_pci_driver.driver,
8944                            &driver_attr_release_date);
8945 err_dcf_rel_date:
8946         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
8947 err_dcf_attr_ver:
8948         pci_unregister_driver(&megasas_pci_driver);
8949 err_pcidrv:
8950         megasas_exit_debugfs();
8951         unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
8952         return rval;
8953 }
8954
8955 /**
8956  * megasas_exit - Driver unload entry point
8957  */
8958 static void __exit megasas_exit(void)
8959 {
8960         driver_remove_file(&megasas_pci_driver.driver,
8961                            &driver_attr_dbg_lvl);
8962         driver_remove_file(&megasas_pci_driver.driver,
8963                         &driver_attr_support_poll_for_event);
8964         driver_remove_file(&megasas_pci_driver.driver,
8965                         &driver_attr_support_device_change);
8966         driver_remove_file(&megasas_pci_driver.driver,
8967                            &driver_attr_release_date);
8968         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
8969         driver_remove_file(&megasas_pci_driver.driver,
8970                            &driver_attr_support_nvme_encapsulation);
8971         driver_remove_file(&megasas_pci_driver.driver,
8972                            &driver_attr_support_pci_lane_margining);
8973
8974         pci_unregister_driver(&megasas_pci_driver);
8975         megasas_exit_debugfs();
8976         unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
8977 }
8978
8979 module_init(megasas_init);
8980 module_exit(megasas_exit);