Pileus Git - ~andy/linux/blob - drivers/scsi/megaraid/megaraid_sas_base.c

   1 /*
   2  *  Linux MegaRAID driver for SAS based RAID controllers
   3  *
   4  *  Copyright (c) 2003-2012  LSI Corporation.
   5  *
   6  *  This program is free software; you can redistribute it and/or
   7  *  modify it under the terms of the GNU General Public License
   8  *  as published by the Free Software Foundation; either version 2
   9  *  of the License, or (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19  *
  20  *  FILE: megaraid_sas_base.c
  21  *  Version : 06.700.06.00-rc1
  22  *
  23  *  Authors: LSI Corporation
  24  *           Sreenivas Bagalkote
  25  *           Sumant Patro
  26  *           Bo Yang
  27  *           Adam Radford <linuxraid@lsi.com>
  28  *
  29  *  Send feedback to: <megaraidlinux@lsi.com>
  30  *
  31  *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
  32  *     ATTN: Linuxraid
  33  */
  34
  35 #include <linux/kernel.h>
  36 #include <linux/types.h>
  37 #include <linux/pci.h>
  38 #include <linux/list.h>
  39 #include <linux/moduleparam.h>
  40 #include <linux/module.h>
  41 #include <linux/spinlock.h>
  42 #include <linux/interrupt.h>
  43 #include <linux/delay.h>
  44 #include <linux/uio.h>
  45 #include <linux/slab.h>
  46 #include <asm/uaccess.h>
  47 #include <linux/fs.h>
  48 #include <linux/compat.h>
  49 #include <linux/blkdev.h>
  50 #include <linux/mutex.h>
  51 #include <linux/poll.h>
  52
  53 #include <scsi/scsi.h>
  54 #include <scsi/scsi_cmnd.h>
  55 #include <scsi/scsi_device.h>
  56 #include <scsi/scsi_host.h>
  57 #include <scsi/scsi_tcq.h>
  58 #include "megaraid_sas_fusion.h"
  59 #include "megaraid_sas.h"
  60
  61 /*
  62  * Number of sectors per IO command
  63  * Will be set in megasas_init_mfi if user does not provide
  64  */
  65 static unsigned int max_sectors;
  66 module_param_named(max_sectors, max_sectors, int, 0);
  67 MODULE_PARM_DESC(max_sectors,
  68         "Maximum number of sectors per IO command");
  69
  70 static int msix_disable;
  71 module_param(msix_disable, int, S_IRUGO);
  72 MODULE_PARM_DESC(msix_disable, "Disable MSI-X interrupt handling. Default: 0");
  73
  74 static unsigned int msix_vectors;
  75 module_param(msix_vectors, int, S_IRUGO);
  76 MODULE_PARM_DESC(msix_vectors, "MSI-X max vector count. Default: Set by FW");
  77
  78 static int throttlequeuedepth = MEGASAS_THROTTLE_QUEUE_DEPTH;
  79 module_param(throttlequeuedepth, int, S_IRUGO);
  80 MODULE_PARM_DESC(throttlequeuedepth,
  81         "Adapter queue depth when throttled due to I/O timeout. Default: 16");
  82
  83 int resetwaittime = MEGASAS_RESET_WAIT_TIME;
  84 module_param(resetwaittime, int, S_IRUGO);
  85 MODULE_PARM_DESC(resetwaittime, "Wait time in seconds after I/O timeout "
  86                  "before resetting adapter. Default: 180");
  87
  88 MODULE_LICENSE("GPL");
  89 MODULE_VERSION(MEGASAS_VERSION);
  90 MODULE_AUTHOR("megaraidlinux@lsi.com");
  91 MODULE_DESCRIPTION("LSI MegaRAID SAS Driver");
  92
  93 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
  94 static int megasas_get_pd_list(struct megasas_instance *instance);
  95 static int megasas_ld_list_query(struct megasas_instance *instance,
  96                                  u8 query_type);
  97 static int megasas_issue_init_mfi(struct megasas_instance *instance);
  98 static int megasas_register_aen(struct megasas_instance *instance,
  99                                 u32 seq_num, u32 class_locale_word);
 100 /*
 101  * PCI ID table for all supported controllers
 102  */
 103 static struct pci_device_id megasas_pci_table[] = {
 104
 105         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064R)},
 106         /* xscale IOP */
 107         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078R)},
 108         /* ppc IOP */
 109         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078DE)},
 110         /* ppc IOP */
 111         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078GEN2)},
 112         /* gen2*/
 113         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0079GEN2)},
 114         /* gen2*/
 115         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0073SKINNY)},
 116         /* skinny*/
 117         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0071SKINNY)},
 118         /* skinny*/
 119         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)},
 120         /* xscale IOP, vega */
 121         {PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},
 122         /* xscale IOP */
 123         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FUSION)},
 124         /* Fusion */
 125         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INVADER)},
 126         /* Invader */
 127         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FURY)},
 128         /* Fury */
 129         {}
 130 };
 131
 132 MODULE_DEVICE_TABLE(pci, megasas_pci_table);
 133
 134 static int megasas_mgmt_majorno;
 135 static struct megasas_mgmt_info megasas_mgmt_info;
 136 static struct fasync_struct *megasas_async_queue;
 137 static DEFINE_MUTEX(megasas_async_queue_mutex);
 138
 139 static int megasas_poll_wait_aen;
 140 static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait);
 141 static u32 support_poll_for_event;
 142 u32 megasas_dbg_lvl;
 143 static u32 support_device_change;
 144
 145 /* define lock for aen poll */
 146 spinlock_t poll_aen_lock;
 147
 148 void
 149 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
 150                      u8 alt_status);
 151 static u32
 152 megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs);
 153 static int
 154 megasas_adp_reset_gen2(struct megasas_instance *instance,
 155                        struct megasas_register_set __iomem *reg_set);
 156 static irqreturn_t megasas_isr(int irq, void *devp);
 157 static u32
 158 megasas_init_adapter_mfi(struct megasas_instance *instance);
 159 u32
 160 megasas_build_and_issue_cmd(struct megasas_instance *instance,
 161                             struct scsi_cmnd *scmd);
 162 static void megasas_complete_cmd_dpc(unsigned long instance_addr);
 163 void
 164 megasas_release_fusion(struct megasas_instance *instance);
 165 int
 166 megasas_ioc_init_fusion(struct megasas_instance *instance);
 167 void
 168 megasas_free_cmds_fusion(struct megasas_instance *instance);
 169 u8
 170 megasas_get_map_info(struct megasas_instance *instance);
 171 int
 172 megasas_sync_map_info(struct megasas_instance *instance);
 173 int
 174 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd);
 175 void megasas_reset_reply_desc(struct megasas_instance *instance);
 176 int megasas_reset_fusion(struct Scsi_Host *shost);
 177 void megasas_fusion_ocr_wq(struct work_struct *work);
 178
 179 void
 180 megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
 181 {
 182         instance->instancet->fire_cmd(instance,
 183                 cmd->frame_phys_addr, 0, instance->reg_set);
 184 }
 185
 186 /**
 187  * megasas_get_cmd -    Get a command from the free pool
 188  * @instance:           Adapter soft state
 189  *
 190  * Returns a free command from the pool
 191  */
 192 struct megasas_cmd *megasas_get_cmd(struct megasas_instance
 193                                                   *instance)
 194 {
 195         unsigned long flags;
 196         struct megasas_cmd *cmd = NULL;
 197
 198         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
 199
 200         if (!list_empty(&instance->cmd_pool)) {
 201                 cmd = list_entry((&instance->cmd_pool)->next,
 202                                  struct megasas_cmd, list);
 203                 list_del_init(&cmd->list);
 204         } else {
 205                 printk(KERN_ERR "megasas: Command pool empty!\n");
 206         }
 207
 208         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
 209         return cmd;
 210 }
 211
 212 /**
 213  * megasas_return_cmd - Return a cmd to free command pool
 214  * @instance:           Adapter soft state
 215  * @cmd:                Command packet to be returned to free command pool
 216  */
 217 inline void
 218 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
 219 {
 220         unsigned long flags;
 221
 222         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
 223
 224         cmd->scmd = NULL;
 225         cmd->frame_count = 0;
 226         if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) &&
 227             (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) &&
 228             (instance->pdev->device != PCI_DEVICE_ID_LSI_FURY) &&
 229             (reset_devices))
 230                 cmd->frame->hdr.cmd = MFI_CMD_INVALID;
 231         list_add_tail(&cmd->list, &instance->cmd_pool);
 232
 233         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
 234 }
 235
 236
 237 /**
 238 *       The following functions are defined for xscale
 239 *       (deviceid : 1064R, PERC5) controllers
 240 */
 241
 242 /**
 243  * megasas_enable_intr_xscale - Enables interrupts
 244  * @regs:                       MFI register set
 245  */
 246 static inline void
 247 megasas_enable_intr_xscale(struct megasas_instance *instance)
 248 {
 249         struct megasas_register_set __iomem *regs;
 250         regs = instance->reg_set;
 251         writel(0, &(regs)->outbound_intr_mask);
 252
 253         /* Dummy readl to force pci flush */
 254         readl(&regs->outbound_intr_mask);
 255 }
 256
 257 /**
 258  * megasas_disable_intr_xscale -Disables interrupt
 259  * @regs:                       MFI register set
 260  */
 261 static inline void
 262 megasas_disable_intr_xscale(struct megasas_instance *instance)
 263 {
 264         struct megasas_register_set __iomem *regs;
 265         u32 mask = 0x1f;
 266         regs = instance->reg_set;
 267         writel(mask, &regs->outbound_intr_mask);
 268         /* Dummy readl to force pci flush */
 269         readl(&regs->outbound_intr_mask);
 270 }
 271
 272 /**
 273  * megasas_read_fw_status_reg_xscale - returns the current FW status value
 274  * @regs:                       MFI register set
 275  */
 276 static u32
 277 megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem * regs)
 278 {
 279         return readl(&(regs)->outbound_msg_0);
 280 }
 281 /**
 282  * megasas_clear_interrupt_xscale -     Check & clear interrupt
 283  * @regs:                               MFI register set
 284  */
 285 static int
 286 megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs)
 287 {
 288         u32 status;
 289         u32 mfiStatus = 0;
 290         /*
 291          * Check if it is our interrupt
 292          */
 293         status = readl(&regs->outbound_intr_status);
 294
 295         if (status & MFI_OB_INTR_STATUS_MASK)
 296                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 297         if (status & MFI_XSCALE_OMR0_CHANGE_INTERRUPT)
 298                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 299
 300         /*
 301          * Clear the interrupt by writing back the same value
 302          */
 303         if (mfiStatus)
 304                 writel(status, &regs->outbound_intr_status);
 305
 306         /* Dummy readl to force pci flush */
 307         readl(&regs->outbound_intr_status);
 308
 309         return mfiStatus;
 310 }
 311
 312 /**
 313  * megasas_fire_cmd_xscale -    Sends command to the FW
 314  * @frame_phys_addr :           Physical address of cmd
 315  * @frame_count :               Number of frames for the command
 316  * @regs :                      MFI register set
 317  */
 318 static inline void
 319 megasas_fire_cmd_xscale(struct megasas_instance *instance,
 320                 dma_addr_t frame_phys_addr,
 321                 u32 frame_count,
 322                 struct megasas_register_set __iomem *regs)
 323 {
 324         unsigned long flags;
 325         spin_lock_irqsave(&instance->hba_lock, flags);
 326         writel((frame_phys_addr >> 3)|(frame_count),
 327                &(regs)->inbound_queue_port);
 328         spin_unlock_irqrestore(&instance->hba_lock, flags);
 329 }
 330
 331 /**
 332  * megasas_adp_reset_xscale -  For controller reset
 333  * @regs:                              MFI register set
 334  */
 335 static int
 336 megasas_adp_reset_xscale(struct megasas_instance *instance,
 337         struct megasas_register_set __iomem *regs)
 338 {
 339         u32 i;
 340         u32 pcidata;
 341         writel(MFI_ADP_RESET, &regs->inbound_doorbell);
 342
 343         for (i = 0; i < 3; i++)
 344                 msleep(1000); /* sleep for 3 secs */
 345         pcidata  = 0;
 346         pci_read_config_dword(instance->pdev, MFI_1068_PCSR_OFFSET, &pcidata);
 347         printk(KERN_NOTICE "pcidata = %x\n", pcidata);
 348         if (pcidata & 0x2) {
 349                 printk(KERN_NOTICE "mfi 1068 offset read=%x\n", pcidata);
 350                 pcidata &= ~0x2;
 351                 pci_write_config_dword(instance->pdev,
 352                                 MFI_1068_PCSR_OFFSET, pcidata);
 353
 354                 for (i = 0; i < 2; i++)
 355                         msleep(1000); /* need to wait 2 secs again */
 356
 357                 pcidata  = 0;
 358                 pci_read_config_dword(instance->pdev,
 359                                 MFI_1068_FW_HANDSHAKE_OFFSET, &pcidata);
 360                 printk(KERN_NOTICE "1068 offset handshake read=%x\n", pcidata);
 361                 if ((pcidata & 0xffff0000) == MFI_1068_FW_READY) {
 362                         printk(KERN_NOTICE "1068 offset pcidt=%x\n", pcidata);
 363                         pcidata = 0;
 364                         pci_write_config_dword(instance->pdev,
 365                                 MFI_1068_FW_HANDSHAKE_OFFSET, pcidata);
 366                 }
 367         }
 368         return 0;
 369 }
 370
 371 /**
 372  * megasas_check_reset_xscale - For controller reset check
 373  * @regs:                               MFI register set
 374  */
 375 static int
 376 megasas_check_reset_xscale(struct megasas_instance *instance,
 377                 struct megasas_register_set __iomem *regs)
 378 {
 379
 380         if ((instance->adprecovery != MEGASAS_HBA_OPERATIONAL) &&
 381             (le32_to_cpu(*instance->consumer) ==
 382                 MEGASAS_ADPRESET_INPROG_SIGN))
 383                 return 1;
 384         return 0;
 385 }
 386
 387 static struct megasas_instance_template megasas_instance_template_xscale = {
 388
 389         .fire_cmd = megasas_fire_cmd_xscale,
 390         .enable_intr = megasas_enable_intr_xscale,
 391         .disable_intr = megasas_disable_intr_xscale,
 392         .clear_intr = megasas_clear_intr_xscale,
 393         .read_fw_status_reg = megasas_read_fw_status_reg_xscale,
 394         .adp_reset = megasas_adp_reset_xscale,
 395         .check_reset = megasas_check_reset_xscale,
 396         .service_isr = megasas_isr,
 397         .tasklet = megasas_complete_cmd_dpc,
 398         .init_adapter = megasas_init_adapter_mfi,
 399         .build_and_issue_cmd = megasas_build_and_issue_cmd,
 400         .issue_dcmd = megasas_issue_dcmd,
 401 };
 402
 403 /**
 404 *       This is the end of set of functions & definitions specific
 405 *       to xscale (deviceid : 1064R, PERC5) controllers
 406 */
 407
 408 /**
 409 *       The following functions are defined for ppc (deviceid : 0x60)
 410 *       controllers
 411 */
 412
 413 /**
 414  * megasas_enable_intr_ppc -    Enables interrupts
 415  * @regs:                       MFI register set
 416  */
 417 static inline void
 418 megasas_enable_intr_ppc(struct megasas_instance *instance)
 419 {
 420         struct megasas_register_set __iomem *regs;
 421         regs = instance->reg_set;
 422         writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
 423
 424         writel(~0x80000000, &(regs)->outbound_intr_mask);
 425
 426         /* Dummy readl to force pci flush */
 427         readl(&regs->outbound_intr_mask);
 428 }
 429
 430 /**
 431  * megasas_disable_intr_ppc -   Disable interrupt
 432  * @regs:                       MFI register set
 433  */
 434 static inline void
 435 megasas_disable_intr_ppc(struct megasas_instance *instance)
 436 {
 437         struct megasas_register_set __iomem *regs;
 438         u32 mask = 0xFFFFFFFF;
 439         regs = instance->reg_set;
 440         writel(mask, &regs->outbound_intr_mask);
 441         /* Dummy readl to force pci flush */
 442         readl(&regs->outbound_intr_mask);
 443 }
 444
 445 /**
 446  * megasas_read_fw_status_reg_ppc - returns the current FW status value
 447  * @regs:                       MFI register set
 448  */
 449 static u32
 450 megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs)
 451 {
 452         return readl(&(regs)->outbound_scratch_pad);
 453 }
 454
 455 /**
 456  * megasas_clear_interrupt_ppc -        Check & clear interrupt
 457  * @regs:                               MFI register set
 458  */
 459 static int
 460 megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
 461 {
 462         u32 status, mfiStatus = 0;
 463
 464         /*
 465          * Check if it is our interrupt
 466          */
 467         status = readl(&regs->outbound_intr_status);
 468
 469         if (status & MFI_REPLY_1078_MESSAGE_INTERRUPT)
 470                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 471
 472         if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT)
 473                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 474
 475         /*
 476          * Clear the interrupt by writing back the same value
 477          */
 478         writel(status, &regs->outbound_doorbell_clear);
 479
 480         /* Dummy readl to force pci flush */
 481         readl(&regs->outbound_doorbell_clear);
 482
 483         return mfiStatus;
 484 }
 485
 486 /**
 487  * megasas_fire_cmd_ppc -       Sends command to the FW
 488  * @frame_phys_addr :           Physical address of cmd
 489  * @frame_count :               Number of frames for the command
 490  * @regs :                      MFI register set
 491  */
 492 static inline void
 493 megasas_fire_cmd_ppc(struct megasas_instance *instance,
 494                 dma_addr_t frame_phys_addr,
 495                 u32 frame_count,
 496                 struct megasas_register_set __iomem *regs)
 497 {
 498         unsigned long flags;
 499         spin_lock_irqsave(&instance->hba_lock, flags);
 500         writel((frame_phys_addr | (frame_count<<1))|1,
 501                         &(regs)->inbound_queue_port);
 502         spin_unlock_irqrestore(&instance->hba_lock, flags);
 503 }
 504
 505 /**
 506  * megasas_check_reset_ppc -    For controller reset check
 507  * @regs:                               MFI register set
 508  */
 509 static int
 510 megasas_check_reset_ppc(struct megasas_instance *instance,
 511                         struct megasas_register_set __iomem *regs)
 512 {
 513         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
 514                 return 1;
 515
 516         return 0;
 517 }
 518
 519 static struct megasas_instance_template megasas_instance_template_ppc = {
 520
 521         .fire_cmd = megasas_fire_cmd_ppc,
 522         .enable_intr = megasas_enable_intr_ppc,
 523         .disable_intr = megasas_disable_intr_ppc,
 524         .clear_intr = megasas_clear_intr_ppc,
 525         .read_fw_status_reg = megasas_read_fw_status_reg_ppc,
 526         .adp_reset = megasas_adp_reset_xscale,
 527         .check_reset = megasas_check_reset_ppc,
 528         .service_isr = megasas_isr,
 529         .tasklet = megasas_complete_cmd_dpc,
 530         .init_adapter = megasas_init_adapter_mfi,
 531         .build_and_issue_cmd = megasas_build_and_issue_cmd,
 532         .issue_dcmd = megasas_issue_dcmd,
 533 };
 534
 535 /**
 536  * megasas_enable_intr_skinny - Enables interrupts
 537  * @regs:                       MFI register set
 538  */
 539 static inline void
 540 megasas_enable_intr_skinny(struct megasas_instance *instance)
 541 {
 542         struct megasas_register_set __iomem *regs;
 543         regs = instance->reg_set;
 544         writel(0xFFFFFFFF, &(regs)->outbound_intr_mask);
 545
 546         writel(~MFI_SKINNY_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
 547
 548         /* Dummy readl to force pci flush */
 549         readl(&regs->outbound_intr_mask);
 550 }
 551
 552 /**
 553  * megasas_disable_intr_skinny -        Disables interrupt
 554  * @regs:                       MFI register set
 555  */
 556 static inline void
 557 megasas_disable_intr_skinny(struct megasas_instance *instance)
 558 {
 559         struct megasas_register_set __iomem *regs;
 560         u32 mask = 0xFFFFFFFF;
 561         regs = instance->reg_set;
 562         writel(mask, &regs->outbound_intr_mask);
 563         /* Dummy readl to force pci flush */
 564         readl(&regs->outbound_intr_mask);
 565 }
 566
 567 /**
 568  * megasas_read_fw_status_reg_skinny - returns the current FW status value
 569  * @regs:                       MFI register set
 570  */
 571 static u32
 572 megasas_read_fw_status_reg_skinny(struct megasas_register_set __iomem *regs)
 573 {
 574         return readl(&(regs)->outbound_scratch_pad);
 575 }
 576
 577 /**
 578  * megasas_clear_interrupt_skinny -     Check & clear interrupt
 579  * @regs:                               MFI register set
 580  */
 581 static int
 582 megasas_clear_intr_skinny(struct megasas_register_set __iomem *regs)
 583 {
 584         u32 status;
 585         u32 mfiStatus = 0;
 586
 587         /*
 588          * Check if it is our interrupt
 589          */
 590         status = readl(&regs->outbound_intr_status);
 591
 592         if (!(status & MFI_SKINNY_ENABLE_INTERRUPT_MASK)) {
 593                 return 0;
 594         }
 595
 596         /*
 597          * Check if it is our interrupt
 598          */
 599         if ((megasas_read_fw_status_reg_skinny(regs) & MFI_STATE_MASK) ==
 600             MFI_STATE_FAULT) {
 601                 mfiStatus = MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 602         } else
 603                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 604
 605         /*
 606          * Clear the interrupt by writing back the same value
 607          */
 608         writel(status, &regs->outbound_intr_status);
 609
 610         /*
 611         * dummy read to flush PCI
 612         */
 613         readl(&regs->outbound_intr_status);
 614
 615         return mfiStatus;
 616 }
 617
 618 /**
 619  * megasas_fire_cmd_skinny -    Sends command to the FW
 620  * @frame_phys_addr :           Physical address of cmd
 621  * @frame_count :               Number of frames for the command
 622  * @regs :                      MFI register set
 623  */
 624 static inline void
 625 megasas_fire_cmd_skinny(struct megasas_instance *instance,
 626                         dma_addr_t frame_phys_addr,
 627                         u32 frame_count,
 628                         struct megasas_register_set __iomem *regs)
 629 {
 630         unsigned long flags;
 631         spin_lock_irqsave(&instance->hba_lock, flags);
 632         writel(upper_32_bits(frame_phys_addr),
 633                &(regs)->inbound_high_queue_port);
 634         writel((lower_32_bits(frame_phys_addr) | (frame_count<<1))|1,
 635                &(regs)->inbound_low_queue_port);
 636         spin_unlock_irqrestore(&instance->hba_lock, flags);
 637 }
 638
 639 /**
 640  * megasas_check_reset_skinny - For controller reset check
 641  * @regs:                               MFI register set
 642  */
 643 static int
 644 megasas_check_reset_skinny(struct megasas_instance *instance,
 645                                 struct megasas_register_set __iomem *regs)
 646 {
 647         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
 648                 return 1;
 649
 650         return 0;
 651 }
 652
 653 static struct megasas_instance_template megasas_instance_template_skinny = {
 654
 655         .fire_cmd = megasas_fire_cmd_skinny,
 656         .enable_intr = megasas_enable_intr_skinny,
 657         .disable_intr = megasas_disable_intr_skinny,
 658         .clear_intr = megasas_clear_intr_skinny,
 659         .read_fw_status_reg = megasas_read_fw_status_reg_skinny,
 660         .adp_reset = megasas_adp_reset_gen2,
 661         .check_reset = megasas_check_reset_skinny,
 662         .service_isr = megasas_isr,
 663         .tasklet = megasas_complete_cmd_dpc,
 664         .init_adapter = megasas_init_adapter_mfi,
 665         .build_and_issue_cmd = megasas_build_and_issue_cmd,
 666         .issue_dcmd = megasas_issue_dcmd,
 667 };
 668
 669
 670 /**
 671 *       The following functions are defined for gen2 (deviceid : 0x78 0x79)
 672 *       controllers
 673 */
 674
 675 /**
 676  * megasas_enable_intr_gen2 -  Enables interrupts
 677  * @regs:                      MFI register set
 678  */
 679 static inline void
 680 megasas_enable_intr_gen2(struct megasas_instance *instance)
 681 {
 682         struct megasas_register_set __iomem *regs;
 683         regs = instance->reg_set;
 684         writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
 685
 686         /* write ~0x00000005 (4 & 1) to the intr mask*/
 687         writel(~MFI_GEN2_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
 688
 689         /* Dummy readl to force pci flush */
 690         readl(&regs->outbound_intr_mask);
 691 }
 692
 693 /**
 694  * megasas_disable_intr_gen2 - Disables interrupt
 695  * @regs:                      MFI register set
 696  */
 697 static inline void
 698 megasas_disable_intr_gen2(struct megasas_instance *instance)
 699 {
 700         struct megasas_register_set __iomem *regs;
 701         u32 mask = 0xFFFFFFFF;
 702         regs = instance->reg_set;
 703         writel(mask, &regs->outbound_intr_mask);
 704         /* Dummy readl to force pci flush */
 705         readl(&regs->outbound_intr_mask);
 706 }
 707
 708 /**
 709  * megasas_read_fw_status_reg_gen2 - returns the current FW status value
 710  * @regs:                      MFI register set
 711  */
 712 static u32
 713 megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs)
 714 {
 715         return readl(&(regs)->outbound_scratch_pad);
 716 }
 717
 718 /**
 719  * megasas_clear_interrupt_gen2 -      Check & clear interrupt
 720  * @regs:                              MFI register set
 721  */
 722 static int
 723 megasas_clear_intr_gen2(struct megasas_register_set __iomem *regs)
 724 {
 725         u32 status;
 726         u32 mfiStatus = 0;
 727         /*
 728          * Check if it is our interrupt
 729          */
 730         status = readl(&regs->outbound_intr_status);
 731
 732         if (status & MFI_INTR_FLAG_REPLY_MESSAGE) {
 733                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 734         }
 735         if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT) {
 736                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 737         }
 738
 739         /*
 740          * Clear the interrupt by writing back the same value
 741          */
 742         if (mfiStatus)
 743                 writel(status, &regs->outbound_doorbell_clear);
 744
 745         /* Dummy readl to force pci flush */
 746         readl(&regs->outbound_intr_status);
 747
 748         return mfiStatus;
 749 }
 750 /**
 751  * megasas_fire_cmd_gen2 -     Sends command to the FW
 752  * @frame_phys_addr :          Physical address of cmd
 753  * @frame_count :              Number of frames for the command
 754  * @regs :                     MFI register set
 755  */
 756 static inline void
 757 megasas_fire_cmd_gen2(struct megasas_instance *instance,
 758                         dma_addr_t frame_phys_addr,
 759                         u32 frame_count,
 760                         struct megasas_register_set __iomem *regs)
 761 {
 762         unsigned long flags;
 763         spin_lock_irqsave(&instance->hba_lock, flags);
 764         writel((frame_phys_addr | (frame_count<<1))|1,
 765                         &(regs)->inbound_queue_port);
 766         spin_unlock_irqrestore(&instance->hba_lock, flags);
 767 }
 768
 769 /**
 770  * megasas_adp_reset_gen2 -     For controller reset
 771  * @regs:                               MFI register set
 772  */
 773 static int
 774 megasas_adp_reset_gen2(struct megasas_instance *instance,
 775                         struct megasas_register_set __iomem *reg_set)
 776 {
 777         u32                     retry = 0 ;
 778         u32                     HostDiag;
 779         u32                     *seq_offset = &reg_set->seq_offset;
 780         u32                     *hostdiag_offset = &reg_set->host_diag;
 781
 782         if (instance->instancet == &megasas_instance_template_skinny) {
 783                 seq_offset = &reg_set->fusion_seq_offset;
 784                 hostdiag_offset = &reg_set->fusion_host_diag;
 785         }
 786
 787         writel(0, seq_offset);
 788         writel(4, seq_offset);
 789         writel(0xb, seq_offset);
 790         writel(2, seq_offset);
 791         writel(7, seq_offset);
 792         writel(0xd, seq_offset);
 793
 794         msleep(1000);
 795
 796         HostDiag = (u32)readl(hostdiag_offset);
 797
 798         while ( !( HostDiag & DIAG_WRITE_ENABLE) ) {
 799                 msleep(100);
 800                 HostDiag = (u32)readl(hostdiag_offset);
 801                 printk(KERN_NOTICE "RESETGEN2: retry=%x, hostdiag=%x\n",
 802                                         retry, HostDiag);
 803
 804                 if (retry++ >= 100)
 805                         return 1;
 806
 807         }
 808
 809         printk(KERN_NOTICE "ADP_RESET_GEN2: HostDiag=%x\n", HostDiag);
 810
 811         writel((HostDiag | DIAG_RESET_ADAPTER), hostdiag_offset);
 812
 813         ssleep(10);
 814
 815         HostDiag = (u32)readl(hostdiag_offset);
 816         while ( ( HostDiag & DIAG_RESET_ADAPTER) ) {
 817                 msleep(100);
 818                 HostDiag = (u32)readl(hostdiag_offset);
 819                 printk(KERN_NOTICE "RESET_GEN2: retry=%x, hostdiag=%x\n",
 820                                 retry, HostDiag);
 821
 822                 if (retry++ >= 1000)
 823                         return 1;
 824
 825         }
 826         return 0;
 827 }
 828
 829 /**
 830  * megasas_check_reset_gen2 -   For controller reset check
 831  * @regs:                               MFI register set
 832  */
 833 static int
 834 megasas_check_reset_gen2(struct megasas_instance *instance,
 835                 struct megasas_register_set __iomem *regs)
 836 {
 837         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
 838                 return 1;
 839         }
 840
 841         return 0;
 842 }
 843
 844 static struct megasas_instance_template megasas_instance_template_gen2 = {
 845
 846         .fire_cmd = megasas_fire_cmd_gen2,
 847         .enable_intr = megasas_enable_intr_gen2,
 848         .disable_intr = megasas_disable_intr_gen2,
 849         .clear_intr = megasas_clear_intr_gen2,
 850         .read_fw_status_reg = megasas_read_fw_status_reg_gen2,
 851         .adp_reset = megasas_adp_reset_gen2,
 852         .check_reset = megasas_check_reset_gen2,
 853         .service_isr = megasas_isr,
 854         .tasklet = megasas_complete_cmd_dpc,
 855         .init_adapter = megasas_init_adapter_mfi,
 856         .build_and_issue_cmd = megasas_build_and_issue_cmd,
 857         .issue_dcmd = megasas_issue_dcmd,
 858 };
 859
 860 /**
 861 *       This is the end of set of functions & definitions
 862 *       specific to gen2 (deviceid : 0x78, 0x79) controllers
 863 */
 864
 865 /*
 866  * Template added for TB (Fusion)
 867  */
 868 extern struct megasas_instance_template megasas_instance_template_fusion;
 869
 870 /**
 871  * megasas_issue_polled -       Issues a polling command
 872  * @instance:                   Adapter soft state
 873  * @cmd:                        Command packet to be issued
 874  *
 875  * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
 876  */
 877 int
 878 megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
 879 {
 880
 881         struct megasas_header *frame_hdr = &cmd->frame->hdr;
 882
 883         frame_hdr->cmd_status = MFI_CMD_STATUS_POLL_MODE;
 884         frame_hdr->flags |= cpu_to_le16(MFI_FRAME_DONT_POST_IN_REPLY_QUEUE);
 885
 886         /*
 887          * Issue the frame using inbound queue port
 888          */
 889         instance->instancet->issue_dcmd(instance, cmd);
 890
 891         /*
 892          * Wait for cmd_status to change
 893          */
 894         return wait_and_poll(instance, cmd);
 895 }
 896
 897 /**
 898  * megasas_issue_blocked_cmd -  Synchronous wrapper around regular FW cmds
 899  * @instance:                   Adapter soft state
 900  * @cmd:                        Command to be issued
 901  *
 902  * This function waits on an event for the command to be returned from ISR.
 903  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
 904  * Used to issue ioctl commands.
 905  */
 906 static int
 907 megasas_issue_blocked_cmd(struct megasas_instance *instance,
 908                           struct megasas_cmd *cmd)
 909 {
 910         cmd->cmd_status = ENODATA;
 911
 912         instance->instancet->issue_dcmd(instance, cmd);
 913
 914         wait_event(instance->int_cmd_wait_q, cmd->cmd_status != ENODATA);
 915
 916         return 0;
 917 }
 918
 919 /**
 920  * megasas_issue_blocked_abort_cmd -    Aborts previously issued cmd
 921  * @instance:                           Adapter soft state
 922  * @cmd_to_abort:                       Previously issued cmd to be aborted
 923  *
 924  * MFI firmware can abort previously issued AEN command (automatic event
 925  * notification). The megasas_issue_blocked_abort_cmd() issues such abort
 926  * cmd and waits for return status.
 927  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
 928  */
 929 static int
 930 megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
 931                                 struct megasas_cmd *cmd_to_abort)
 932 {
 933         struct megasas_cmd *cmd;
 934         struct megasas_abort_frame *abort_fr;
 935
 936         cmd = megasas_get_cmd(instance);
 937
 938         if (!cmd)
 939                 return -1;
 940
 941         abort_fr = &cmd->frame->abort;
 942
 943         /*
 944          * Prepare and issue the abort frame
 945          */
 946         abort_fr->cmd = MFI_CMD_ABORT;
 947         abort_fr->cmd_status = 0xFF;
 948         abort_fr->flags = cpu_to_le16(0);
 949         abort_fr->abort_context = cpu_to_le32(cmd_to_abort->index);
 950         abort_fr->abort_mfi_phys_addr_lo =
 951                 cpu_to_le32(lower_32_bits(cmd_to_abort->frame_phys_addr));
 952         abort_fr->abort_mfi_phys_addr_hi =
 953                 cpu_to_le32(upper_32_bits(cmd_to_abort->frame_phys_addr));
 954
 955         cmd->sync_cmd = 1;
 956         cmd->cmd_status = 0xFF;
 957
 958         instance->instancet->issue_dcmd(instance, cmd);
 959
 960         /*
 961          * Wait for this cmd to complete
 962          */
 963         wait_event(instance->abort_cmd_wait_q, cmd->cmd_status != 0xFF);
 964         cmd->sync_cmd = 0;
 965
 966         megasas_return_cmd(instance, cmd);
 967         return 0;
 968 }
 969
 970 /**
 971  * megasas_make_sgl32 - Prepares 32-bit SGL
 972  * @instance:           Adapter soft state
 973  * @scp:                SCSI command from the mid-layer
 974  * @mfi_sgl:            SGL to be filled in
 975  *
 976  * If successful, this function returns the number of SG elements. Otherwise,
 977  * it returnes -1.
 978  */
 979 static int
 980 megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
 981                    union megasas_sgl *mfi_sgl)
 982 {
 983         int i;
 984         int sge_count;
 985         struct scatterlist *os_sgl;
 986
 987         sge_count = scsi_dma_map(scp);
 988         BUG_ON(sge_count < 0);
 989
 990         if (sge_count) {
 991                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
 992                         mfi_sgl->sge32[i].length = cpu_to_le32(sg_dma_len(os_sgl));
 993                         mfi_sgl->sge32[i].phys_addr = cpu_to_le32(sg_dma_address(os_sgl));
 994                 }
 995         }
 996         return sge_count;
 997 }
 998
 999 /**
1000  * megasas_make_sgl64 - Prepares 64-bit SGL
1001  * @instance:           Adapter soft state
1002  * @scp:                SCSI command from the mid-layer
1003  * @mfi_sgl:            SGL to be filled in
1004  *
1005  * If successful, this function returns the number of SG elements. Otherwise,
1006  * it returnes -1.
1007  */
1008 static int
1009 megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
1010                    union megasas_sgl *mfi_sgl)
1011 {
1012         int i;
1013         int sge_count;
1014         struct scatterlist *os_sgl;
1015
1016         sge_count = scsi_dma_map(scp);
1017         BUG_ON(sge_count < 0);
1018
1019         if (sge_count) {
1020                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1021                         mfi_sgl->sge64[i].length = cpu_to_le32(sg_dma_len(os_sgl));
1022                         mfi_sgl->sge64[i].phys_addr = cpu_to_le64(sg_dma_address(os_sgl));
1023                 }
1024         }
1025         return sge_count;
1026 }
1027
1028 /**
1029  * megasas_make_sgl_skinny - Prepares IEEE SGL
1030  * @instance:           Adapter soft state
1031  * @scp:                SCSI command from the mid-layer
1032  * @mfi_sgl:            SGL to be filled in
1033  *
1034  * If successful, this function returns the number of SG elements. Otherwise,
1035  * it returnes -1.
1036  */
1037 static int
1038 megasas_make_sgl_skinny(struct megasas_instance *instance,
1039                 struct scsi_cmnd *scp, union megasas_sgl *mfi_sgl)
1040 {
1041         int i;
1042         int sge_count;
1043         struct scatterlist *os_sgl;
1044
1045         sge_count = scsi_dma_map(scp);
1046
1047         if (sge_count) {
1048                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1049                         mfi_sgl->sge_skinny[i].length =
1050                                 cpu_to_le32(sg_dma_len(os_sgl));
1051                         mfi_sgl->sge_skinny[i].phys_addr =
1052                                 cpu_to_le64(sg_dma_address(os_sgl));
1053                         mfi_sgl->sge_skinny[i].flag = cpu_to_le32(0);
1054                 }
1055         }
1056         return sge_count;
1057 }
1058
1059  /**
1060  * megasas_get_frame_count - Computes the number of frames
1061  * @frame_type          : type of frame- io or pthru frame
1062  * @sge_count           : number of sg elements
1063  *
1064  * Returns the number of frames required for numnber of sge's (sge_count)
1065  */
1066
1067 static u32 megasas_get_frame_count(struct megasas_instance *instance,
1068                         u8 sge_count, u8 frame_type)
1069 {
1070         int num_cnt;
1071         int sge_bytes;
1072         u32 sge_sz;
1073         u32 frame_count=0;
1074
1075         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
1076             sizeof(struct megasas_sge32);
1077
1078         if (instance->flag_ieee) {
1079                 sge_sz = sizeof(struct megasas_sge_skinny);
1080         }
1081
1082         /*
1083          * Main frame can contain 2 SGEs for 64-bit SGLs and
1084          * 3 SGEs for 32-bit SGLs for ldio &
1085          * 1 SGEs for 64-bit SGLs and
1086          * 2 SGEs for 32-bit SGLs for pthru frame
1087          */
1088         if (unlikely(frame_type == PTHRU_FRAME)) {
1089                 if (instance->flag_ieee == 1) {
1090                         num_cnt = sge_count - 1;
1091                 } else if (IS_DMA64)
1092                         num_cnt = sge_count - 1;
1093                 else
1094                         num_cnt = sge_count - 2;
1095         } else {
1096                 if (instance->flag_ieee == 1) {
1097                         num_cnt = sge_count - 1;
1098                 } else if (IS_DMA64)
1099                         num_cnt = sge_count - 2;
1100                 else
1101                         num_cnt = sge_count - 3;
1102         }
1103
1104         if(num_cnt>0){
1105                 sge_bytes = sge_sz * num_cnt;
1106
1107                 frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
1108                     ((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) ;
1109         }
1110         /* Main frame */
1111         frame_count +=1;
1112
1113         if (frame_count > 7)
1114                 frame_count = 8;
1115         return frame_count;
1116 }
1117
1118 /**
1119  * megasas_build_dcdb - Prepares a direct cdb (DCDB) command
1120  * @instance:           Adapter soft state
1121  * @scp:                SCSI command
1122  * @cmd:                Command to be prepared in
1123  *
1124  * This function prepares CDB commands. These are typcially pass-through
1125  * commands to the devices.
1126  */
1127 static int
1128 megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
1129                    struct megasas_cmd *cmd)
1130 {
1131         u32 is_logical;
1132         u32 device_id;
1133         u16 flags = 0;
1134         struct megasas_pthru_frame *pthru;
1135
1136         is_logical = MEGASAS_IS_LOGICAL(scp);
1137         device_id = MEGASAS_DEV_INDEX(instance, scp);
1138         pthru = (struct megasas_pthru_frame *)cmd->frame;
1139
1140         if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1141                 flags = MFI_FRAME_DIR_WRITE;
1142         else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1143                 flags = MFI_FRAME_DIR_READ;
1144         else if (scp->sc_data_direction == PCI_DMA_NONE)
1145                 flags = MFI_FRAME_DIR_NONE;
1146
1147         if (instance->flag_ieee == 1) {
1148                 flags |= MFI_FRAME_IEEE;
1149         }
1150
1151         /*
1152          * Prepare the DCDB frame
1153          */
1154         pthru->cmd = (is_logical) ? MFI_CMD_LD_SCSI_IO : MFI_CMD_PD_SCSI_IO;
1155         pthru->cmd_status = 0x0;
1156         pthru->scsi_status = 0x0;
1157         pthru->target_id = device_id;
1158         pthru->lun = scp->device->lun;
1159         pthru->cdb_len = scp->cmd_len;
1160         pthru->timeout = 0;
1161         pthru->pad_0 = 0;
1162         pthru->flags = cpu_to_le16(flags);
1163         pthru->data_xfer_len = cpu_to_le32(scsi_bufflen(scp));
1164
1165         memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
1166
1167         /*
1168         * If the command is for the tape device, set the
1169         * pthru timeout to the os layer timeout value.
1170         */
1171         if (scp->device->type == TYPE_TAPE) {
1172                 if ((scp->request->timeout / HZ) > 0xFFFF)
1173                         pthru->timeout = 0xFFFF;
1174                 else
1175                         pthru->timeout = cpu_to_le16(scp->request->timeout / HZ);
1176         }
1177
1178         /*
1179          * Construct SGL
1180          */
1181         if (instance->flag_ieee == 1) {
1182                 pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1183                 pthru->sge_count = megasas_make_sgl_skinny(instance, scp,
1184                                                       &pthru->sgl);
1185         } else if (IS_DMA64) {
1186                 pthru->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1187                 pthru->sge_count = megasas_make_sgl64(instance, scp,
1188                                                       &pthru->sgl);
1189         } else
1190                 pthru->sge_count = megasas_make_sgl32(instance, scp,
1191                                                       &pthru->sgl);
1192
1193         if (pthru->sge_count > instance->max_num_sge) {
1194                 printk(KERN_ERR "megasas: DCDB two many SGE NUM=%x\n",
1195                         pthru->sge_count);
1196                 return 0;
1197         }
1198
1199         /*
1200          * Sense info specific
1201          */
1202         pthru->sense_len = SCSI_SENSE_BUFFERSIZE;
1203         pthru->sense_buf_phys_addr_hi =
1204                 cpu_to_le32(upper_32_bits(cmd->sense_phys_addr));
1205         pthru->sense_buf_phys_addr_lo =
1206                 cpu_to_le32(lower_32_bits(cmd->sense_phys_addr));
1207
1208         /*
1209          * Compute the total number of frames this command consumes. FW uses
1210          * this number to pull sufficient number of frames from host memory.
1211          */
1212         cmd->frame_count = megasas_get_frame_count(instance, pthru->sge_count,
1213                                                         PTHRU_FRAME);
1214
1215         return cmd->frame_count;
1216 }
1217
1218 /**
1219  * megasas_build_ldio - Prepares IOs to logical devices
1220  * @instance:           Adapter soft state
1221  * @scp:                SCSI command
1222  * @cmd:                Command to be prepared
1223  *
1224  * Frames (and accompanying SGLs) for regular SCSI IOs use this function.
1225  */
1226 static int
1227 megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
1228                    struct megasas_cmd *cmd)
1229 {
1230         u32 device_id;
1231         u8 sc = scp->cmnd[0];
1232         u16 flags = 0;
1233         struct megasas_io_frame *ldio;
1234
1235         device_id = MEGASAS_DEV_INDEX(instance, scp);
1236         ldio = (struct megasas_io_frame *)cmd->frame;
1237
1238         if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1239                 flags = MFI_FRAME_DIR_WRITE;
1240         else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1241                 flags = MFI_FRAME_DIR_READ;
1242
1243         if (instance->flag_ieee == 1) {
1244                 flags |= MFI_FRAME_IEEE;
1245         }
1246
1247         /*
1248          * Prepare the Logical IO frame: 2nd bit is zero for all read cmds
1249          */
1250         ldio->cmd = (sc & 0x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ;
1251         ldio->cmd_status = 0x0;
1252         ldio->scsi_status = 0x0;
1253         ldio->target_id = device_id;
1254         ldio->timeout = 0;
1255         ldio->reserved_0 = 0;
1256         ldio->pad_0 = 0;
1257         ldio->flags = cpu_to_le16(flags);
1258         ldio->start_lba_hi = 0;
1259         ldio->access_byte = (scp->cmd_len != 6) ? scp->cmnd[1] : 0;
1260
1261         /*
1262          * 6-byte READ(0x08) or WRITE(0x0A) cdb
1263          */
1264         if (scp->cmd_len == 6) {
1265                 ldio->lba_count = cpu_to_le32((u32) scp->cmnd[4]);
1266                 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[1] << 16) |
1267                                                  ((u32) scp->cmnd[2] << 8) |
1268                                                  (u32) scp->cmnd[3]);
1269
1270                 ldio->start_lba_lo &= cpu_to_le32(0x1FFFFF);
1271         }
1272
1273         /*
1274          * 10-byte READ(0x28) or WRITE(0x2A) cdb
1275          */
1276         else if (scp->cmd_len == 10) {
1277                 ldio->lba_count = cpu_to_le32((u32) scp->cmnd[8] |
1278                                               ((u32) scp->cmnd[7] << 8));
1279                 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1280                                                  ((u32) scp->cmnd[3] << 16) |
1281                                                  ((u32) scp->cmnd[4] << 8) |
1282                                                  (u32) scp->cmnd[5]);
1283         }
1284
1285         /*
1286          * 12-byte READ(0xA8) or WRITE(0xAA) cdb
1287          */
1288         else if (scp->cmd_len == 12) {
1289                 ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[6] << 24) |
1290                                               ((u32) scp->cmnd[7] << 16) |
1291                                               ((u32) scp->cmnd[8] << 8) |
1292                                               (u32) scp->cmnd[9]);
1293
1294                 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1295                                                  ((u32) scp->cmnd[3] << 16) |
1296                                                  ((u32) scp->cmnd[4] << 8) |
1297                                                  (u32) scp->cmnd[5]);
1298         }
1299
1300         /*
1301          * 16-byte READ(0x88) or WRITE(0x8A) cdb
1302          */
1303         else if (scp->cmd_len == 16) {
1304                 ldio->lba_count = cpu_to_le32(((u32) scp->cmnd[10] << 24) |
1305                                               ((u32) scp->cmnd[11] << 16) |
1306                                               ((u32) scp->cmnd[12] << 8) |
1307                                               (u32) scp->cmnd[13]);
1308
1309                 ldio->start_lba_lo = cpu_to_le32(((u32) scp->cmnd[6] << 24) |
1310                                                  ((u32) scp->cmnd[7] << 16) |
1311                                                  ((u32) scp->cmnd[8] << 8) |
1312                                                  (u32) scp->cmnd[9]);
1313
1314                 ldio->start_lba_hi = cpu_to_le32(((u32) scp->cmnd[2] << 24) |
1315                                                  ((u32) scp->cmnd[3] << 16) |
1316                                                  ((u32) scp->cmnd[4] << 8) |
1317                                                  (u32) scp->cmnd[5]);
1318
1319         }
1320
1321         /*
1322          * Construct SGL
1323          */
1324         if (instance->flag_ieee) {
1325                 ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1326                 ldio->sge_count = megasas_make_sgl_skinny(instance, scp,
1327                                               &ldio->sgl);
1328         } else if (IS_DMA64) {
1329                 ldio->flags |= cpu_to_le16(MFI_FRAME_SGL64);
1330                 ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl);
1331         } else
1332                 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
1333
1334         if (ldio->sge_count > instance->max_num_sge) {
1335                 printk(KERN_ERR "megasas: build_ld_io: sge_count = %x\n",
1336                         ldio->sge_count);
1337                 return 0;
1338         }
1339
1340         /*
1341          * Sense info specific
1342          */
1343         ldio->sense_len = SCSI_SENSE_BUFFERSIZE;
1344         ldio->sense_buf_phys_addr_hi = 0;
1345         ldio->sense_buf_phys_addr_lo = cpu_to_le32(cmd->sense_phys_addr);
1346
1347         /*
1348          * Compute the total number of frames this command consumes. FW uses
1349          * this number to pull sufficient number of frames from host memory.
1350          */
1351         cmd->frame_count = megasas_get_frame_count(instance,
1352                         ldio->sge_count, IO_FRAME);
1353
1354         return cmd->frame_count;
1355 }
1356
1357 /**
1358  * megasas_is_ldio -            Checks if the cmd is for logical drive
1359  * @scmd:                       SCSI command
1360  *
1361  * Called by megasas_queue_command to find out if the command to be queued
1362  * is a logical drive command
1363  */
1364 inline int megasas_is_ldio(struct scsi_cmnd *cmd)
1365 {
1366         if (!MEGASAS_IS_LOGICAL(cmd))
1367                 return 0;
1368         switch (cmd->cmnd[0]) {
1369         case READ_10:
1370         case WRITE_10:
1371         case READ_12:
1372         case WRITE_12:
1373         case READ_6:
1374         case WRITE_6:
1375         case READ_16:
1376         case WRITE_16:
1377                 return 1;
1378         default:
1379                 return 0;
1380         }
1381 }
1382
1383  /**
1384  * megasas_dump_pending_frames -        Dumps the frame address of all pending cmds
1385  *                                      in FW
1386  * @instance:                           Adapter soft state
1387  */
1388 static inline void
1389 megasas_dump_pending_frames(struct megasas_instance *instance)
1390 {
1391         struct megasas_cmd *cmd;
1392         int i,n;
1393         union megasas_sgl *mfi_sgl;
1394         struct megasas_io_frame *ldio;
1395         struct megasas_pthru_frame *pthru;
1396         u32 sgcount;
1397         u32 max_cmd = instance->max_fw_cmds;
1398
1399         printk(KERN_ERR "\nmegasas[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no);
1400         printk(KERN_ERR "megasas[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding));
1401         if (IS_DMA64)
1402                 printk(KERN_ERR "\nmegasas[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no);
1403         else
1404                 printk(KERN_ERR "\nmegasas[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no);
1405
1406         printk(KERN_ERR "megasas[%d]: Pending OS cmds in FW : \n",instance->host->host_no);
1407         for (i = 0; i < max_cmd; i++) {
1408                 cmd = instance->cmd_list[i];
1409                 if(!cmd->scmd)
1410                         continue;
1411                 printk(KERN_ERR "megasas[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
1412                 if (megasas_is_ldio(cmd->scmd)){
1413                         ldio = (struct megasas_io_frame *)cmd->frame;
1414                         mfi_sgl = &ldio->sgl;
1415                         sgcount = ldio->sge_count;
1416                         printk(KERN_ERR "megasas[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x,"
1417                         " lba lo : 0x%x, lba_hi : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1418                         instance->host->host_no, cmd->frame_count, ldio->cmd, ldio->target_id,
1419                         le32_to_cpu(ldio->start_lba_lo), le32_to_cpu(ldio->start_lba_hi),
1420                         le32_to_cpu(ldio->sense_buf_phys_addr_lo), sgcount);
1421                 }
1422                 else {
1423                         pthru = (struct megasas_pthru_frame *) cmd->frame;
1424                         mfi_sgl = &pthru->sgl;
1425                         sgcount = pthru->sge_count;
1426                         printk(KERN_ERR "megasas[%d]: frame count : 0x%x, Cmd : 0x%x, Tgt id : 0x%x, "
1427                         "lun : 0x%x, cdb_len : 0x%x, data xfer len : 0x%x, sense_buf addr : 0x%x,sge count : 0x%x\n",
1428                         instance->host->host_no, cmd->frame_count, pthru->cmd, pthru->target_id,
1429                         pthru->lun, pthru->cdb_len, le32_to_cpu(pthru->data_xfer_len),
1430                         le32_to_cpu(pthru->sense_buf_phys_addr_lo), sgcount);
1431                 }
1432         if(megasas_dbg_lvl & MEGASAS_DBG_LVL){
1433                 for (n = 0; n < sgcount; n++){
1434                         if (IS_DMA64)
1435                                 printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%llx ",
1436                                         le32_to_cpu(mfi_sgl->sge64[n].length),
1437                                         le64_to_cpu(mfi_sgl->sge64[n].phys_addr));
1438                         else
1439                                 printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%x ",
1440                                         le32_to_cpu(mfi_sgl->sge32[n].length),
1441                                         le32_to_cpu(mfi_sgl->sge32[n].phys_addr));
1442                         }
1443                 }
1444                 printk(KERN_ERR "\n");
1445         } /*for max_cmd*/
1446         printk(KERN_ERR "\nmegasas[%d]: Pending Internal cmds in FW : \n",instance->host->host_no);
1447         for (i = 0; i < max_cmd; i++) {
1448
1449                 cmd = instance->cmd_list[i];
1450
1451                 if(cmd->sync_cmd == 1){
1452                         printk(KERN_ERR "0x%08lx : ", (unsigned long)cmd->frame_phys_addr);
1453                 }
1454         }
1455         printk(KERN_ERR "megasas[%d]: Dumping Done.\n\n",instance->host->host_no);
1456 }
1457
1458 u32
1459 megasas_build_and_issue_cmd(struct megasas_instance *instance,
1460                             struct scsi_cmnd *scmd)
1461 {
1462         struct megasas_cmd *cmd;
1463         u32 frame_count;
1464
1465         cmd = megasas_get_cmd(instance);
1466         if (!cmd)
1467                 return SCSI_MLQUEUE_HOST_BUSY;
1468
1469         /*
1470          * Logical drive command
1471          */
1472         if (megasas_is_ldio(scmd))
1473                 frame_count = megasas_build_ldio(instance, scmd, cmd);
1474         else
1475                 frame_count = megasas_build_dcdb(instance, scmd, cmd);
1476
1477         if (!frame_count)
1478                 goto out_return_cmd;
1479
1480         cmd->scmd = scmd;
1481         scmd->SCp.ptr = (char *)cmd;
1482
1483         /*
1484          * Issue the command to the FW
1485          */
1486         atomic_inc(&instance->fw_outstanding);
1487
1488         instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
1489                                 cmd->frame_count-1, instance->reg_set);
1490
1491         return 0;
1492 out_return_cmd:
1493         megasas_return_cmd(instance, cmd);
1494         return 1;
1495 }
1496
1497
1498 /**
1499  * megasas_queue_command -      Queue entry point
1500  * @scmd:                       SCSI command to be queued
1501  * @done:                       Callback entry point
1502  */
1503 static int
1504 megasas_queue_command_lck(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *))
1505 {
1506         struct megasas_instance *instance;
1507         unsigned long flags;
1508
1509         instance = (struct megasas_instance *)
1510             scmd->device->host->hostdata;
1511
1512         if (instance->issuepend_done == 0)
1513                 return SCSI_MLQUEUE_HOST_BUSY;
1514
1515         spin_lock_irqsave(&instance->hba_lock, flags);
1516
1517         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
1518                 spin_unlock_irqrestore(&instance->hba_lock, flags);
1519                 scmd->result = DID_ERROR << 16;
1520                 done(scmd);
1521                 return 0;
1522         }
1523
1524         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
1525                 spin_unlock_irqrestore(&instance->hba_lock, flags);
1526                 return SCSI_MLQUEUE_HOST_BUSY;
1527         }
1528
1529         spin_unlock_irqrestore(&instance->hba_lock, flags);
1530
1531         scmd->scsi_done = done;
1532         scmd->result = 0;
1533
1534         if (MEGASAS_IS_LOGICAL(scmd) &&
1535             (scmd->device->id >= MEGASAS_MAX_LD || scmd->device->lun)) {
1536                 scmd->result = DID_BAD_TARGET << 16;
1537                 goto out_done;
1538         }
1539
1540         switch (scmd->cmnd[0]) {
1541         case SYNCHRONIZE_CACHE:
1542                 /*
1543                  * FW takes care of flush cache on its own
1544                  * No need to send it down
1545                  */
1546                 scmd->result = DID_OK << 16;
1547                 goto out_done;
1548         default:
1549                 break;
1550         }
1551
1552         if (instance->instancet->build_and_issue_cmd(instance, scmd)) {
1553                 printk(KERN_ERR "megasas: Err returned from build_and_issue_cmd\n");
1554                 return SCSI_MLQUEUE_HOST_BUSY;
1555         }
1556
1557         return 0;
1558
1559  out_done:
1560         done(scmd);
1561         return 0;
1562 }
1563
1564 static DEF_SCSI_QCMD(megasas_queue_command)
1565
1566 static struct megasas_instance *megasas_lookup_instance(u16 host_no)
1567 {
1568         int i;
1569
1570         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
1571
1572                 if ((megasas_mgmt_info.instance[i]) &&
1573                     (megasas_mgmt_info.instance[i]->host->host_no == host_no))
1574                         return megasas_mgmt_info.instance[i];
1575         }
1576
1577         return NULL;
1578 }
1579
1580 static int megasas_slave_configure(struct scsi_device *sdev)
1581 {
1582         u16             pd_index = 0;
1583         struct  megasas_instance *instance ;
1584
1585         instance = megasas_lookup_instance(sdev->host->host_no);
1586
1587         /*
1588         * Don't export physical disk devices to the disk driver.
1589         *
1590         * FIXME: Currently we don't export them to the midlayer at all.
1591         *        That will be fixed once LSI engineers have audited the
1592         *        firmware for possible issues.
1593         */
1594         if (sdev->channel < MEGASAS_MAX_PD_CHANNELS &&
1595                                 sdev->type == TYPE_DISK) {
1596                 pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
1597                                                                 sdev->id;
1598                 if (instance->pd_list[pd_index].driveState ==
1599                                                 MR_PD_STATE_SYSTEM) {
1600                         blk_queue_rq_timeout(sdev->request_queue,
1601                                 MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
1602                         return 0;
1603                 }
1604                 return -ENXIO;
1605         }
1606
1607         /*
1608         * The RAID firmware may require extended timeouts.
1609         */
1610         blk_queue_rq_timeout(sdev->request_queue,
1611                 MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
1612         return 0;
1613 }
1614
1615 static int megasas_slave_alloc(struct scsi_device *sdev)
1616 {
1617         u16             pd_index = 0;
1618         struct megasas_instance *instance ;
1619         instance = megasas_lookup_instance(sdev->host->host_no);
1620         if ((sdev->channel < MEGASAS_MAX_PD_CHANNELS) &&
1621                                 (sdev->type == TYPE_DISK)) {
1622                 /*
1623                  * Open the OS scan to the SYSTEM PD
1624                  */
1625                 pd_index =
1626                         (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
1627                         sdev->id;
1628                 if ((instance->pd_list[pd_index].driveState ==
1629                                         MR_PD_STATE_SYSTEM) &&
1630                         (instance->pd_list[pd_index].driveType ==
1631                                                 TYPE_DISK)) {
1632                         return 0;
1633                 }
1634                 return -ENXIO;
1635         }
1636         return 0;
1637 }
1638
1639 void megaraid_sas_kill_hba(struct megasas_instance *instance)
1640 {
1641         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
1642             (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
1643             (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
1644             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
1645             (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
1646                 writel(MFI_STOP_ADP, &instance->reg_set->doorbell);
1647         } else {
1648                 writel(MFI_STOP_ADP, &instance->reg_set->inbound_doorbell);
1649         }
1650 }
1651
1652  /**
1653   * megasas_check_and_restore_queue_depth - Check if queue depth needs to be
1654   *                                     restored to max value
1655   * @instance:                  Adapter soft state
1656   *
1657   */
1658 void
1659 megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
1660 {
1661         unsigned long flags;
1662         if (instance->flag & MEGASAS_FW_BUSY
1663             && time_after(jiffies, instance->last_time + 5 * HZ)
1664             && atomic_read(&instance->fw_outstanding) <
1665             instance->throttlequeuedepth + 1) {
1666
1667                 spin_lock_irqsave(instance->host->host_lock, flags);
1668                 instance->flag &= ~MEGASAS_FW_BUSY;
1669                 if (instance->is_imr) {
1670                         instance->host->can_queue =
1671                                 instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
1672                 } else
1673                         instance->host->can_queue =
1674                                 instance->max_fw_cmds - MEGASAS_INT_CMDS;
1675
1676                 spin_unlock_irqrestore(instance->host->host_lock, flags);
1677         }
1678 }
1679
1680 /**
1681  * megasas_complete_cmd_dpc      -      Returns FW's controller structure
1682  * @instance_addr:                      Address of adapter soft state
1683  *
1684  * Tasklet to complete cmds
1685  */
1686 static void megasas_complete_cmd_dpc(unsigned long instance_addr)
1687 {
1688         u32 producer;
1689         u32 consumer;
1690         u32 context;
1691         struct megasas_cmd *cmd;
1692         struct megasas_instance *instance =
1693                                 (struct megasas_instance *)instance_addr;
1694         unsigned long flags;
1695
1696         /* If we have already declared adapter dead, donot complete cmds */
1697         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR )
1698                 return;
1699
1700         spin_lock_irqsave(&instance->completion_lock, flags);
1701
1702         producer = le32_to_cpu(*instance->producer);
1703         consumer = le32_to_cpu(*instance->consumer);
1704
1705         while (consumer != producer) {
1706                 context = le32_to_cpu(instance->reply_queue[consumer]);
1707                 if (context >= instance->max_fw_cmds) {
1708                         printk(KERN_ERR "Unexpected context value %x\n",
1709                                 context);
1710                         BUG();
1711                 }
1712
1713                 cmd = instance->cmd_list[context];
1714
1715                 megasas_complete_cmd(instance, cmd, DID_OK);
1716
1717                 consumer++;
1718                 if (consumer == (instance->max_fw_cmds + 1)) {
1719                         consumer = 0;
1720                 }
1721         }
1722
1723         *instance->consumer = cpu_to_le32(producer);
1724
1725         spin_unlock_irqrestore(&instance->completion_lock, flags);
1726
1727         /*
1728          * Check if we can restore can_queue
1729          */
1730         megasas_check_and_restore_queue_depth(instance);
1731 }
1732
1733 static void
1734 megasas_internal_reset_defer_cmds(struct megasas_instance *instance);
1735
1736 static void
1737 process_fw_state_change_wq(struct work_struct *work);
1738
1739 void megasas_do_ocr(struct megasas_instance *instance)
1740 {
1741         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
1742         (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
1743         (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
1744                 *instance->consumer = cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
1745         }
1746         instance->instancet->disable_intr(instance);
1747         instance->adprecovery   = MEGASAS_ADPRESET_SM_INFAULT;
1748         instance->issuepend_done = 0;
1749
1750         atomic_set(&instance->fw_outstanding, 0);
1751         megasas_internal_reset_defer_cmds(instance);
1752         process_fw_state_change_wq(&instance->work_init);
1753 }
1754
1755 /**
1756  * megasas_wait_for_outstanding -       Wait for all outstanding cmds
1757  * @instance:                           Adapter soft state
1758  *
1759  * This function waits for up to MEGASAS_RESET_WAIT_TIME seconds for FW to
1760  * complete all its outstanding commands. Returns error if one or more IOs
1761  * are pending after this time period. It also marks the controller dead.
1762  */
1763 static int megasas_wait_for_outstanding(struct megasas_instance *instance)
1764 {
1765         int i;
1766         u32 reset_index;
1767         u32 wait_time = MEGASAS_RESET_WAIT_TIME;
1768         u8 adprecovery;
1769         unsigned long flags;
1770         struct list_head clist_local;
1771         struct megasas_cmd *reset_cmd;
1772         u32 fw_state;
1773         u8 kill_adapter_flag;
1774
1775         spin_lock_irqsave(&instance->hba_lock, flags);
1776         adprecovery = instance->adprecovery;
1777         spin_unlock_irqrestore(&instance->hba_lock, flags);
1778
1779         if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
1780
1781                 INIT_LIST_HEAD(&clist_local);
1782                 spin_lock_irqsave(&instance->hba_lock, flags);
1783                 list_splice_init(&instance->internal_reset_pending_q,
1784                                 &clist_local);
1785                 spin_unlock_irqrestore(&instance->hba_lock, flags);
1786
1787                 printk(KERN_NOTICE "megasas: HBA reset wait ...\n");
1788                 for (i = 0; i < wait_time; i++) {
1789                         msleep(1000);
1790                         spin_lock_irqsave(&instance->hba_lock, flags);
1791                         adprecovery = instance->adprecovery;
1792                         spin_unlock_irqrestore(&instance->hba_lock, flags);
1793                         if (adprecovery == MEGASAS_HBA_OPERATIONAL)
1794                                 break;
1795                 }
1796
1797                 if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
1798                         printk(KERN_NOTICE "megasas: reset: Stopping HBA.\n");
1799                         spin_lock_irqsave(&instance->hba_lock, flags);
1800                         instance->adprecovery   = MEGASAS_HW_CRITICAL_ERROR;
1801                         spin_unlock_irqrestore(&instance->hba_lock, flags);
1802                         return FAILED;
1803                 }
1804
1805                 reset_index     = 0;
1806                 while (!list_empty(&clist_local)) {
1807                         reset_cmd       = list_entry((&clist_local)->next,
1808                                                 struct megasas_cmd, list);
1809                         list_del_init(&reset_cmd->list);
1810                         if (reset_cmd->scmd) {
1811                                 reset_cmd->scmd->result = DID_RESET << 16;
1812                                 printk(KERN_NOTICE "%d:%p reset [%02x]\n",
1813                                         reset_index, reset_cmd,
1814                                         reset_cmd->scmd->cmnd[0]);
1815
1816                                 reset_cmd->scmd->scsi_done(reset_cmd->scmd);
1817                                 megasas_return_cmd(instance, reset_cmd);
1818                         } else if (reset_cmd->sync_cmd) {
1819                                 printk(KERN_NOTICE "megasas:%p synch cmds"
1820                                                 "reset queue\n",
1821                                                 reset_cmd);
1822
1823                                 reset_cmd->cmd_status = ENODATA;
1824                                 instance->instancet->fire_cmd(instance,
1825                                                 reset_cmd->frame_phys_addr,
1826                                                 0, instance->reg_set);
1827                         } else {
1828                                 printk(KERN_NOTICE "megasas: %p unexpected"
1829                                         "cmds lst\n",
1830                                         reset_cmd);
1831                         }
1832                         reset_index++;
1833                 }
1834
1835                 return SUCCESS;
1836         }
1837
1838         for (i = 0; i < resetwaittime; i++) {
1839
1840                 int outstanding = atomic_read(&instance->fw_outstanding);
1841
1842                 if (!outstanding)
1843                         break;
1844
1845                 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
1846                         printk(KERN_NOTICE "megasas: [%2d]waiting for %d "
1847                                "commands to complete\n",i,outstanding);
1848                         /*
1849                          * Call cmd completion routine. Cmd to be
1850                          * be completed directly without depending on isr.
1851                          */
1852                         megasas_complete_cmd_dpc((unsigned long)instance);
1853                 }
1854
1855                 msleep(1000);
1856         }
1857
1858         i = 0;
1859         kill_adapter_flag = 0;
1860         do {
1861                 fw_state = instance->instancet->read_fw_status_reg(
1862                                         instance->reg_set) & MFI_STATE_MASK;
1863                 if ((fw_state == MFI_STATE_FAULT) &&
1864                         (instance->disableOnlineCtrlReset == 0)) {
1865                         if (i == 3) {
1866                                 kill_adapter_flag = 2;
1867                                 break;
1868                         }
1869                         megasas_do_ocr(instance);
1870                         kill_adapter_flag = 1;
1871
1872                         /* wait for 1 secs to let FW finish the pending cmds */
1873                         msleep(1000);
1874                 }
1875                 i++;
1876         } while (i <= 3);
1877
1878         if (atomic_read(&instance->fw_outstanding) &&
1879                                         !kill_adapter_flag) {
1880                 if (instance->disableOnlineCtrlReset == 0) {
1881
1882                         megasas_do_ocr(instance);
1883
1884                         /* wait for 5 secs to let FW finish the pending cmds */
1885                         for (i = 0; i < wait_time; i++) {
1886                                 int outstanding =
1887                                         atomic_read(&instance->fw_outstanding);
1888                                 if (!outstanding)
1889                                         return SUCCESS;
1890                                 msleep(1000);
1891                         }
1892                 }
1893         }
1894
1895         if (atomic_read(&instance->fw_outstanding) ||
1896                                         (kill_adapter_flag == 2)) {
1897                 printk(KERN_NOTICE "megaraid_sas: pending cmds after reset\n");
1898                 /*
1899                 * Send signal to FW to stop processing any pending cmds.
1900                 * The controller will be taken offline by the OS now.
1901                 */
1902                 if ((instance->pdev->device ==
1903                         PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
1904                         (instance->pdev->device ==
1905                         PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
1906                         writel(MFI_STOP_ADP,
1907                                 &instance->reg_set->doorbell);
1908                 } else {
1909                         writel(MFI_STOP_ADP,
1910                                 &instance->reg_set->inbound_doorbell);
1911                 }
1912                 megasas_dump_pending_frames(instance);
1913                 spin_lock_irqsave(&instance->hba_lock, flags);
1914                 instance->adprecovery   = MEGASAS_HW_CRITICAL_ERROR;
1915                 spin_unlock_irqrestore(&instance->hba_lock, flags);
1916                 return FAILED;
1917         }
1918
1919         printk(KERN_NOTICE "megaraid_sas: no pending cmds after reset\n");
1920
1921         return SUCCESS;
1922 }
1923
1924 /**
1925  * megasas_generic_reset -      Generic reset routine
1926  * @scmd:                       Mid-layer SCSI command
1927  *
1928  * This routine implements a generic reset handler for device, bus and host
1929  * reset requests. Device, bus and host specific reset handlers can use this
1930  * function after they do their specific tasks.
1931  */
1932 static int megasas_generic_reset(struct scsi_cmnd *scmd)
1933 {
1934         int ret_val;
1935         struct megasas_instance *instance;
1936
1937         instance = (struct megasas_instance *)scmd->device->host->hostdata;
1938
1939         scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
1940                  scmd->cmnd[0], scmd->retries);
1941
1942         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
1943                 printk(KERN_ERR "megasas: cannot recover from previous reset "
1944                        "failures\n");
1945                 return FAILED;
1946         }
1947
1948         ret_val = megasas_wait_for_outstanding(instance);
1949         if (ret_val == SUCCESS)
1950                 printk(KERN_NOTICE "megasas: reset successful \n");
1951         else
1952                 printk(KERN_ERR "megasas: failed to do reset\n");
1953
1954         return ret_val;
1955 }
1956
1957 /**
1958  * megasas_reset_timer - quiesce the adapter if required
1959  * @scmd:               scsi cmnd
1960  *
1961  * Sets the FW busy flag and reduces the host->can_queue if the
1962  * cmd has not been completed within the timeout period.
1963  */
1964 static enum
1965 blk_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd)
1966 {
1967         struct megasas_instance *instance;
1968         unsigned long flags;
1969
1970         if (time_after(jiffies, scmd->jiffies_at_alloc +
1971                                 (MEGASAS_DEFAULT_CMD_TIMEOUT * 2) * HZ)) {
1972                 return BLK_EH_NOT_HANDLED;
1973         }
1974
1975         instance = (struct megasas_instance *)scmd->device->host->hostdata;
1976         if (!(instance->flag & MEGASAS_FW_BUSY)) {
1977                 /* FW is busy, throttle IO */
1978                 spin_lock_irqsave(instance->host->host_lock, flags);
1979
1980                 instance->host->can_queue = instance->throttlequeuedepth;
1981                 instance->last_time = jiffies;
1982                 instance->flag |= MEGASAS_FW_BUSY;
1983
1984                 spin_unlock_irqrestore(instance->host->host_lock, flags);
1985         }
1986         return BLK_EH_RESET_TIMER;
1987 }
1988
1989 /**
1990  * megasas_reset_device -       Device reset handler entry point
1991  */
1992 static int megasas_reset_device(struct scsi_cmnd *scmd)
1993 {
1994         int ret;
1995
1996         /*
1997          * First wait for all commands to complete
1998          */
1999         ret = megasas_generic_reset(scmd);
2000
2001         return ret;
2002 }
2003
2004 /**
2005  * megasas_reset_bus_host -     Bus & host reset handler entry point
2006  */
2007 static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
2008 {
2009         int ret;
2010         struct megasas_instance *instance;
2011         instance = (struct megasas_instance *)scmd->device->host->hostdata;
2012
2013         /*
2014          * First wait for all commands to complete
2015          */
2016         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
2017             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
2018             (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
2019                 ret = megasas_reset_fusion(scmd->device->host);
2020         else
2021                 ret = megasas_generic_reset(scmd);
2022
2023         return ret;
2024 }
2025
2026 /**
2027  * megasas_bios_param - Returns disk geometry for a disk
2028  * @sdev:               device handle
2029  * @bdev:               block device
2030  * @capacity:           drive capacity
2031  * @geom:               geometry parameters
2032  */
2033 static int
2034 megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
2035                  sector_t capacity, int geom[])
2036 {
2037         int heads;
2038         int sectors;
2039         sector_t cylinders;
2040         unsigned long tmp;
2041         /* Default heads (64) & sectors (32) */
2042         heads = 64;
2043         sectors = 32;
2044
2045         tmp = heads * sectors;
2046         cylinders = capacity;
2047
2048         sector_div(cylinders, tmp);
2049
2050         /*
2051          * Handle extended translation size for logical drives > 1Gb
2052          */
2053
2054         if (capacity >= 0x200000) {
2055                 heads = 255;
2056                 sectors = 63;
2057                 tmp = heads*sectors;
2058                 cylinders = capacity;
2059                 sector_div(cylinders, tmp);
2060         }
2061
2062         geom[0] = heads;
2063         geom[1] = sectors;
2064         geom[2] = cylinders;
2065
2066         return 0;
2067 }
2068
2069 static void megasas_aen_polling(struct work_struct *work);
2070
2071 /**
2072  * megasas_service_aen -        Processes an event notification
2073  * @instance:                   Adapter soft state
2074  * @cmd:                        AEN command completed by the ISR
2075  *
2076  * For AEN, driver sends a command down to FW that is held by the FW till an
2077  * event occurs. When an event of interest occurs, FW completes the command
2078  * that it was previously holding.
2079  *
2080  * This routines sends SIGIO signal to processes that have registered with the
2081  * driver for AEN.
2082  */
2083 static void
2084 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
2085 {
2086         unsigned long flags;
2087         /*
2088          * Don't signal app if it is just an aborted previously registered aen
2089          */
2090         if ((!cmd->abort_aen) && (instance->unload == 0)) {
2091                 spin_lock_irqsave(&poll_aen_lock, flags);
2092                 megasas_poll_wait_aen = 1;
2093                 spin_unlock_irqrestore(&poll_aen_lock, flags);
2094                 wake_up(&megasas_poll_wait);
2095                 kill_fasync(&megasas_async_queue, SIGIO, POLL_IN);
2096         }
2097         else
2098                 cmd->abort_aen = 0;
2099
2100         instance->aen_cmd = NULL;
2101         megasas_return_cmd(instance, cmd);
2102
2103         if ((instance->unload == 0) &&
2104                 ((instance->issuepend_done == 1))) {
2105                 struct megasas_aen_event *ev;
2106                 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2107                 if (!ev) {
2108                         printk(KERN_ERR "megasas_service_aen: out of memory\n");
2109                 } else {
2110                         ev->instance = instance;
2111                         instance->ev = ev;
2112                         INIT_DELAYED_WORK(&ev->hotplug_work,
2113                                           megasas_aen_polling);
2114                         schedule_delayed_work(&ev->hotplug_work, 0);
2115                 }
2116         }
2117 }
2118
2119 static int megasas_change_queue_depth(struct scsi_device *sdev,
2120                                       int queue_depth, int reason)
2121 {
2122         if (reason != SCSI_QDEPTH_DEFAULT)
2123                 return -EOPNOTSUPP;
2124
2125         if (queue_depth > sdev->host->can_queue)
2126                 queue_depth = sdev->host->can_queue;
2127         scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev),
2128                                 queue_depth);
2129
2130         return queue_depth;
2131 }
2132
2133 /*
2134  * Scsi host template for megaraid_sas driver
2135  */
2136 static struct scsi_host_template megasas_template = {
2137
2138         .module = THIS_MODULE,
2139         .name = "LSI SAS based MegaRAID driver",
2140         .proc_name = "megaraid_sas",
2141         .slave_configure = megasas_slave_configure,
2142         .slave_alloc = megasas_slave_alloc,
2143         .queuecommand = megasas_queue_command,
2144         .eh_device_reset_handler = megasas_reset_device,
2145         .eh_bus_reset_handler = megasas_reset_bus_host,
2146         .eh_host_reset_handler = megasas_reset_bus_host,
2147         .eh_timed_out = megasas_reset_timer,
2148         .bios_param = megasas_bios_param,
2149         .use_clustering = ENABLE_CLUSTERING,
2150         .change_queue_depth = megasas_change_queue_depth,
2151         .no_write_same = 1,
2152 };
2153
2154 /**
2155  * megasas_complete_int_cmd -   Completes an internal command
2156  * @instance:                   Adapter soft state
2157  * @cmd:                        Command to be completed
2158  *
2159  * The megasas_issue_blocked_cmd() function waits for a command to complete
2160  * after it issues a command. This function wakes up that waiting routine by
2161  * calling wake_up() on the wait queue.
2162  */
2163 static void
2164 megasas_complete_int_cmd(struct megasas_instance *instance,
2165                          struct megasas_cmd *cmd)
2166 {
2167         cmd->cmd_status = cmd->frame->io.cmd_status;
2168
2169         if (cmd->cmd_status == ENODATA) {
2170                 cmd->cmd_status = 0;
2171         }
2172         wake_up(&instance->int_cmd_wait_q);
2173 }
2174
2175 /**
2176  * megasas_complete_abort -     Completes aborting a command
2177  * @instance:                   Adapter soft state
2178  * @cmd:                        Cmd that was issued to abort another cmd
2179  *
2180  * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
2181  * after it issues an abort on a previously issued command. This function
2182  * wakes up all functions waiting on the same wait queue.
2183  */
2184 static void
2185 megasas_complete_abort(struct megasas_instance *instance,
2186                        struct megasas_cmd *cmd)
2187 {
2188         if (cmd->sync_cmd) {
2189                 cmd->sync_cmd = 0;
2190                 cmd->cmd_status = 0;
2191                 wake_up(&instance->abort_cmd_wait_q);
2192         }
2193
2194         return;
2195 }
2196
2197 /**
2198  * megasas_complete_cmd -       Completes a command
2199  * @instance:                   Adapter soft state
2200  * @cmd:                        Command to be completed
2201  * @alt_status:                 If non-zero, use this value as status to
2202  *                              SCSI mid-layer instead of the value returned
2203  *                              by the FW. This should be used if caller wants
2204  *                              an alternate status (as in the case of aborted
2205  *                              commands)
2206  */
2207 void
2208 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
2209                      u8 alt_status)
2210 {
2211         int exception = 0;
2212         struct megasas_header *hdr = &cmd->frame->hdr;
2213         unsigned long flags;
2214         struct fusion_context *fusion = instance->ctrl_context;
2215         u32 opcode;
2216
2217         /* flag for the retry reset */
2218         cmd->retry_for_fw_reset = 0;
2219
2220         if (cmd->scmd)
2221                 cmd->scmd->SCp.ptr = NULL;
2222
2223         switch (hdr->cmd) {
2224         case MFI_CMD_INVALID:
2225                 /* Some older 1068 controller FW may keep a pended
2226                    MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel
2227                    when booting the kdump kernel.  Ignore this command to
2228                    prevent a kernel panic on shutdown of the kdump kernel. */
2229                 printk(KERN_WARNING "megaraid_sas: MFI_CMD_INVALID command "
2230                        "completed.\n");
2231                 printk(KERN_WARNING "megaraid_sas: If you have a controller "
2232                        "other than PERC5, please upgrade your firmware.\n");
2233                 break;
2234         case MFI_CMD_PD_SCSI_IO:
2235         case MFI_CMD_LD_SCSI_IO:
2236
2237                 /*
2238                  * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
2239                  * issued either through an IO path or an IOCTL path. If it
2240                  * was via IOCTL, we will send it to internal completion.
2241                  */
2242                 if (cmd->sync_cmd) {
2243                         cmd->sync_cmd = 0;
2244                         megasas_complete_int_cmd(instance, cmd);
2245                         break;
2246                 }
2247
2248         case MFI_CMD_LD_READ:
2249         case MFI_CMD_LD_WRITE:
2250
2251                 if (alt_status) {
2252                         cmd->scmd->result = alt_status << 16;
2253                         exception = 1;
2254                 }
2255
2256                 if (exception) {
2257
2258                         atomic_dec(&instance->fw_outstanding);
2259
2260                         scsi_dma_unmap(cmd->scmd);
2261                         cmd->scmd->scsi_done(cmd->scmd);
2262                         megasas_return_cmd(instance, cmd);
2263
2264                         break;
2265                 }
2266
2267                 switch (hdr->cmd_status) {
2268
2269                 case MFI_STAT_OK:
2270                         cmd->scmd->result = DID_OK << 16;
2271                         break;
2272
2273                 case MFI_STAT_SCSI_IO_FAILED:
2274                 case MFI_STAT_LD_INIT_IN_PROGRESS:
2275                         cmd->scmd->result =
2276                             (DID_ERROR << 16) | hdr->scsi_status;
2277                         break;
2278
2279                 case MFI_STAT_SCSI_DONE_WITH_ERROR:
2280
2281                         cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status;
2282
2283                         if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {
2284                                 memset(cmd->scmd->sense_buffer, 0,
2285                                        SCSI_SENSE_BUFFERSIZE);
2286                                 memcpy(cmd->scmd->sense_buffer, cmd->sense,
2287                                        hdr->sense_len);
2288
2289                                 cmd->scmd->result |= DRIVER_SENSE << 24;
2290                         }
2291
2292                         break;
2293
2294                 case MFI_STAT_LD_OFFLINE:
2295                 case MFI_STAT_DEVICE_NOT_FOUND:
2296                         cmd->scmd->result = DID_BAD_TARGET << 16;
2297                         break;
2298
2299                 default:
2300                         printk(KERN_DEBUG "megasas: MFI FW status %#x\n",
2301                                hdr->cmd_status);
2302                         cmd->scmd->result = DID_ERROR << 16;
2303                         break;
2304                 }
2305
2306                 atomic_dec(&instance->fw_outstanding);
2307
2308                 scsi_dma_unmap(cmd->scmd);
2309                 cmd->scmd->scsi_done(cmd->scmd);
2310                 megasas_return_cmd(instance, cmd);
2311
2312                 break;
2313
2314         case MFI_CMD_SMP:
2315         case MFI_CMD_STP:
2316         case MFI_CMD_DCMD:
2317                 opcode = le32_to_cpu(cmd->frame->dcmd.opcode);
2318                 /* Check for LD map update */
2319                 if ((opcode == MR_DCMD_LD_MAP_GET_INFO)
2320                         && (cmd->frame->dcmd.mbox.b[1] == 1)) {
2321                         fusion->fast_path_io = 0;
2322                         spin_lock_irqsave(instance->host->host_lock, flags);
2323                         if (cmd->frame->hdr.cmd_status != 0) {
2324                                 if (cmd->frame->hdr.cmd_status !=
2325                                     MFI_STAT_NOT_FOUND)
2326                                         printk(KERN_WARNING "megasas: map sync"
2327                                                "failed, status = 0x%x.\n",
2328                                                cmd->frame->hdr.cmd_status);
2329                                 else {
2330                                         megasas_return_cmd(instance, cmd);
2331                                         spin_unlock_irqrestore(
2332                                                 instance->host->host_lock,
2333                                                 flags);
2334                                         break;
2335                                 }
2336                         } else
2337                                 instance->map_id++;
2338                         megasas_return_cmd(instance, cmd);
2339
2340                         /*
2341                          * Set fast path IO to ZERO.
2342                          * Validate Map will set proper value.
2343                          * Meanwhile all IOs will go as LD IO.
2344                          */
2345                         if (MR_ValidateMapInfo(instance))
2346                                 fusion->fast_path_io = 1;
2347                         else
2348                                 fusion->fast_path_io = 0;
2349                         megasas_sync_map_info(instance);
2350                         spin_unlock_irqrestore(instance->host->host_lock,
2351                                                flags);
2352                         break;
2353                 }
2354                 if (opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
2355                     opcode == MR_DCMD_CTRL_EVENT_GET) {
2356                         spin_lock_irqsave(&poll_aen_lock, flags);
2357                         megasas_poll_wait_aen = 0;
2358                         spin_unlock_irqrestore(&poll_aen_lock, flags);
2359                 }
2360
2361                 /*
2362                  * See if got an event notification
2363                  */
2364                 if (opcode == MR_DCMD_CTRL_EVENT_WAIT)
2365                         megasas_service_aen(instance, cmd);
2366                 else
2367                         megasas_complete_int_cmd(instance, cmd);
2368
2369                 break;
2370
2371         case MFI_CMD_ABORT:
2372                 /*
2373                  * Cmd issued to abort another cmd returned
2374                  */
2375                 megasas_complete_abort(instance, cmd);
2376                 break;
2377
2378         default:
2379                 printk("megasas: Unknown command completed! [0x%X]\n",
2380                        hdr->cmd);
2381                 break;
2382         }
2383 }
2384
2385 /**
2386  * megasas_issue_pending_cmds_again -   issue all pending cmds
2387  *                                      in FW again because of the fw reset
2388  * @instance:                           Adapter soft state
2389  */
2390 static inline void
2391 megasas_issue_pending_cmds_again(struct megasas_instance *instance)
2392 {
2393         struct megasas_cmd *cmd;
2394         struct list_head clist_local;
2395         union megasas_evt_class_locale class_locale;
2396         unsigned long flags;
2397         u32 seq_num;
2398
2399         INIT_LIST_HEAD(&clist_local);
2400         spin_lock_irqsave(&instance->hba_lock, flags);
2401         list_splice_init(&instance->internal_reset_pending_q, &clist_local);
2402         spin_unlock_irqrestore(&instance->hba_lock, flags);
2403
2404         while (!list_empty(&clist_local)) {
2405                 cmd     = list_entry((&clist_local)->next,
2406                                         struct megasas_cmd, list);
2407                 list_del_init(&cmd->list);
2408
2409                 if (cmd->sync_cmd || cmd->scmd) {
2410                         printk(KERN_NOTICE "megaraid_sas: command %p, %p:%d"
2411                                 "detected to be pending while HBA reset.\n",
2412                                         cmd, cmd->scmd, cmd->sync_cmd);
2413
2414                         cmd->retry_for_fw_reset++;
2415
2416                         if (cmd->retry_for_fw_reset == 3) {
2417                                 printk(KERN_NOTICE "megaraid_sas: cmd %p, %p:%d"
2418                                         "was tried multiple times during reset."
2419                                         "Shutting down the HBA\n",
2420                                         cmd, cmd->scmd, cmd->sync_cmd);
2421                                 megaraid_sas_kill_hba(instance);
2422
2423                                 instance->adprecovery =
2424                                                 MEGASAS_HW_CRITICAL_ERROR;
2425                                 return;
2426                         }
2427                 }
2428
2429                 if (cmd->sync_cmd == 1) {
2430                         if (cmd->scmd) {
2431                                 printk(KERN_NOTICE "megaraid_sas: unexpected"
2432                                         "cmd attached to internal command!\n");
2433                         }
2434                         printk(KERN_NOTICE "megasas: %p synchronous cmd"
2435                                                 "on the internal reset queue,"
2436                                                 "issue it again.\n", cmd);
2437                         cmd->cmd_status = ENODATA;
2438                         instance->instancet->fire_cmd(instance,
2439                                                         cmd->frame_phys_addr ,
2440                                                         0, instance->reg_set);
2441                 } else if (cmd->scmd) {
2442                         printk(KERN_NOTICE "megasas: %p scsi cmd [%02x]"
2443                         "detected on the internal queue, issue again.\n",
2444                         cmd, cmd->scmd->cmnd[0]);
2445
2446                         atomic_inc(&instance->fw_outstanding);
2447                         instance->instancet->fire_cmd(instance,
2448                                         cmd->frame_phys_addr,
2449                                         cmd->frame_count-1, instance->reg_set);
2450                 } else {
2451                         printk(KERN_NOTICE "megasas: %p unexpected cmd on the"
2452                                 "internal reset defer list while re-issue!!\n",
2453                                 cmd);
2454                 }
2455         }
2456
2457         if (instance->aen_cmd) {
2458                 printk(KERN_NOTICE "megaraid_sas: aen_cmd in def process\n");
2459                 megasas_return_cmd(instance, instance->aen_cmd);
2460
2461                 instance->aen_cmd       = NULL;
2462         }
2463
2464         /*
2465         * Initiate AEN (Asynchronous Event Notification)
2466         */
2467         seq_num = instance->last_seq_num;
2468         class_locale.members.reserved = 0;
2469         class_locale.members.locale = MR_EVT_LOCALE_ALL;
2470         class_locale.members.class = MR_EVT_CLASS_DEBUG;
2471
2472         megasas_register_aen(instance, seq_num, class_locale.word);
2473 }
2474
2475 /**
2476  * Move the internal reset pending commands to a deferred queue.
2477  *
2478  * We move the commands pending at internal reset time to a
2479  * pending queue. This queue would be flushed after successful
2480  * completion of the internal reset sequence. if the internal reset
2481  * did not complete in time, the kernel reset handler would flush
2482  * these commands.
2483  **/
2484 static void
2485 megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
2486 {
2487         struct megasas_cmd *cmd;
2488         int i;
2489         u32 max_cmd = instance->max_fw_cmds;
2490         u32 defer_index;
2491         unsigned long flags;
2492
2493         defer_index     = 0;
2494         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
2495         for (i = 0; i < max_cmd; i++) {
2496                 cmd = instance->cmd_list[i];
2497                 if (cmd->sync_cmd == 1 || cmd->scmd) {
2498                         printk(KERN_NOTICE "megasas: moving cmd[%d]:%p:%d:%p"
2499                                         "on the defer queue as internal\n",
2500                                 defer_index, cmd, cmd->sync_cmd, cmd->scmd);
2501
2502                         if (!list_empty(&cmd->list)) {
2503                                 printk(KERN_NOTICE "megaraid_sas: ERROR while"
2504                                         " moving this cmd:%p, %d %p, it was"
2505                                         "discovered on some list?\n",
2506                                         cmd, cmd->sync_cmd, cmd->scmd);
2507
2508                                 list_del_init(&cmd->list);
2509                         }
2510                         defer_index++;
2511                         list_add_tail(&cmd->list,
2512                                 &instance->internal_reset_pending_q);
2513                 }
2514         }
2515         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
2516 }
2517
2518
2519 static void
2520 process_fw_state_change_wq(struct work_struct *work)
2521 {
2522         struct megasas_instance *instance =
2523                 container_of(work, struct megasas_instance, work_init);
2524         u32 wait;
2525         unsigned long flags;
2526
2527         if (instance->adprecovery != MEGASAS_ADPRESET_SM_INFAULT) {
2528                 printk(KERN_NOTICE "megaraid_sas: error, recovery st %x \n",
2529                                 instance->adprecovery);
2530                 return ;
2531         }
2532
2533         if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) {
2534                 printk(KERN_NOTICE "megaraid_sas: FW detected to be in fault"
2535                                         "state, restarting it...\n");
2536
2537                 instance->instancet->disable_intr(instance);
2538                 atomic_set(&instance->fw_outstanding, 0);
2539
2540                 atomic_set(&instance->fw_reset_no_pci_access, 1);
2541                 instance->instancet->adp_reset(instance, instance->reg_set);
2542                 atomic_set(&instance->fw_reset_no_pci_access, 0 );
2543
2544                 printk(KERN_NOTICE "megaraid_sas: FW restarted successfully,"
2545                                         "initiating next stage...\n");
2546
2547                 printk(KERN_NOTICE "megaraid_sas: HBA recovery state machine,"
2548                                         "state 2 starting...\n");
2549
2550                 /*waitting for about 20 second before start the second init*/
2551                 for (wait = 0; wait < 30; wait++) {
2552                         msleep(1000);
2553                 }
2554
2555                 if (megasas_transition_to_ready(instance, 1)) {
2556                         printk(KERN_NOTICE "megaraid_sas:adapter not ready\n");
2557
2558                         megaraid_sas_kill_hba(instance);
2559                         instance->adprecovery   = MEGASAS_HW_CRITICAL_ERROR;
2560                         return ;
2561                 }
2562
2563                 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
2564                         (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
2565                         (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)
2566                         ) {
2567                         *instance->consumer = *instance->producer;
2568                 } else {
2569                         *instance->consumer = 0;
2570                         *instance->producer = 0;
2571                 }
2572
2573                 megasas_issue_init_mfi(instance);
2574
2575                 spin_lock_irqsave(&instance->hba_lock, flags);
2576                 instance->adprecovery   = MEGASAS_HBA_OPERATIONAL;
2577                 spin_unlock_irqrestore(&instance->hba_lock, flags);
2578                 instance->instancet->enable_intr(instance);
2579
2580                 megasas_issue_pending_cmds_again(instance);
2581                 instance->issuepend_done = 1;
2582         }
2583         return ;
2584 }
2585
2586 /**
2587  * megasas_deplete_reply_queue -        Processes all completed commands
2588  * @instance:                           Adapter soft state
2589  * @alt_status:                         Alternate status to be returned to
2590  *                                      SCSI mid-layer instead of the status
2591  *                                      returned by the FW
2592  * Note: this must be called with hba lock held
2593  */
2594 static int
2595 megasas_deplete_reply_queue(struct megasas_instance *instance,
2596                                         u8 alt_status)
2597 {
2598         u32 mfiStatus;
2599         u32 fw_state;
2600
2601         if ((mfiStatus = instance->instancet->check_reset(instance,
2602                                         instance->reg_set)) == 1) {
2603                 return IRQ_HANDLED;
2604         }
2605
2606         if ((mfiStatus = instance->instancet->clear_intr(
2607                                                 instance->reg_set)
2608                                                 ) == 0) {
2609                 /* Hardware may not set outbound_intr_status in MSI-X mode */
2610                 if (!instance->msix_vectors)
2611                         return IRQ_NONE;
2612         }
2613
2614         instance->mfiStatus = mfiStatus;
2615
2616         if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) {
2617                 fw_state = instance->instancet->read_fw_status_reg(
2618                                 instance->reg_set) & MFI_STATE_MASK;
2619
2620                 if (fw_state != MFI_STATE_FAULT) {
2621                         printk(KERN_NOTICE "megaraid_sas: fw state:%x\n",
2622                                                 fw_state);
2623                 }
2624
2625                 if ((fw_state == MFI_STATE_FAULT) &&
2626                                 (instance->disableOnlineCtrlReset == 0)) {
2627                         printk(KERN_NOTICE "megaraid_sas: wait adp restart\n");
2628
2629                         if ((instance->pdev->device ==
2630                                         PCI_DEVICE_ID_LSI_SAS1064R) ||
2631                                 (instance->pdev->device ==
2632                                         PCI_DEVICE_ID_DELL_PERC5) ||
2633                                 (instance->pdev->device ==
2634                                         PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
2635
2636                                 *instance->consumer =
2637                                         cpu_to_le32(MEGASAS_ADPRESET_INPROG_SIGN);
2638                         }
2639
2640
2641                         instance->instancet->disable_intr(instance);
2642                         instance->adprecovery   = MEGASAS_ADPRESET_SM_INFAULT;
2643                         instance->issuepend_done = 0;
2644
2645                         atomic_set(&instance->fw_outstanding, 0);
2646                         megasas_internal_reset_defer_cmds(instance);
2647
2648                         printk(KERN_NOTICE "megasas: fwState=%x, stage:%d\n",
2649                                         fw_state, instance->adprecovery);
2650
2651                         schedule_work(&instance->work_init);
2652                         return IRQ_HANDLED;
2653
2654                 } else {
2655                         printk(KERN_NOTICE "megasas: fwstate:%x, dis_OCR=%x\n",
2656                                 fw_state, instance->disableOnlineCtrlReset);
2657                 }
2658         }
2659
2660         tasklet_schedule(&instance->isr_tasklet);
2661         return IRQ_HANDLED;
2662 }
2663 /**
2664  * megasas_isr - isr entry point
2665  */
2666 static irqreturn_t megasas_isr(int irq, void *devp)
2667 {
2668         struct megasas_irq_context *irq_context = devp;
2669         struct megasas_instance *instance = irq_context->instance;
2670         unsigned long flags;
2671         irqreturn_t     rc;
2672
2673         if (atomic_read(&instance->fw_reset_no_pci_access))
2674                 return IRQ_HANDLED;
2675
2676         spin_lock_irqsave(&instance->hba_lock, flags);
2677         rc =  megasas_deplete_reply_queue(instance, DID_OK);
2678         spin_unlock_irqrestore(&instance->hba_lock, flags);
2679
2680         return rc;
2681 }
2682
2683 /**
2684  * megasas_transition_to_ready -        Move the FW to READY state
2685  * @instance:                           Adapter soft state
2686  *
2687  * During the initialization, FW passes can potentially be in any one of
2688  * several possible states. If the FW in operational, waiting-for-handshake
2689  * states, driver must take steps to bring it to ready state. Otherwise, it
2690  * has to wait for the ready state.
2691  */
2692 int
2693 megasas_transition_to_ready(struct megasas_instance *instance, int ocr)
2694 {
2695         int i;
2696         u8 max_wait;
2697         u32 fw_state;
2698         u32 cur_state;
2699         u32 abs_state, curr_abs_state;
2700
2701         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
2702
2703         if (fw_state != MFI_STATE_READY)
2704                 printk(KERN_INFO "megasas: Waiting for FW to come to ready"
2705                        " state\n");
2706
2707         while (fw_state != MFI_STATE_READY) {
2708
2709                 abs_state =
2710                 instance->instancet->read_fw_status_reg(instance->reg_set);
2711
2712                 switch (fw_state) {
2713
2714                 case MFI_STATE_FAULT:
2715                         printk(KERN_DEBUG "megasas: FW in FAULT state!!\n");
2716                         if (ocr) {
2717                                 max_wait = MEGASAS_RESET_WAIT_TIME;
2718                                 cur_state = MFI_STATE_FAULT;
2719                                 break;
2720                         } else
2721                                 return -ENODEV;
2722
2723                 case MFI_STATE_WAIT_HANDSHAKE:
2724                         /*
2725                          * Set the CLR bit in inbound doorbell
2726                          */
2727                         if ((instance->pdev->device ==
2728                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2729                                 (instance->pdev->device ==
2730                                  PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2731                                 (instance->pdev->device ==
2732                                 PCI_DEVICE_ID_LSI_FUSION) ||
2733                                 (instance->pdev->device ==
2734                                 PCI_DEVICE_ID_LSI_INVADER) ||
2735                                 (instance->pdev->device ==
2736                                 PCI_DEVICE_ID_LSI_FURY)) {
2737                                 writel(
2738                                   MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
2739                                   &instance->reg_set->doorbell);
2740                         } else {
2741                                 writel(
2742                                     MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
2743                                         &instance->reg_set->inbound_doorbell);
2744                         }
2745
2746                         max_wait = MEGASAS_RESET_WAIT_TIME;
2747                         cur_state = MFI_STATE_WAIT_HANDSHAKE;
2748                         break;
2749
2750                 case MFI_STATE_BOOT_MESSAGE_PENDING:
2751                         if ((instance->pdev->device ==
2752                              PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2753                                 (instance->pdev->device ==
2754                                  PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2755                             (instance->pdev->device ==
2756                              PCI_DEVICE_ID_LSI_FUSION) ||
2757                             (instance->pdev->device ==
2758                              PCI_DEVICE_ID_LSI_INVADER) ||
2759                             (instance->pdev->device ==
2760                              PCI_DEVICE_ID_LSI_FURY)) {
2761                                 writel(MFI_INIT_HOTPLUG,
2762                                        &instance->reg_set->doorbell);
2763                         } else
2764                                 writel(MFI_INIT_HOTPLUG,
2765                                         &instance->reg_set->inbound_doorbell);
2766
2767                         max_wait = MEGASAS_RESET_WAIT_TIME;
2768                         cur_state = MFI_STATE_BOOT_MESSAGE_PENDING;
2769                         break;
2770
2771                 case MFI_STATE_OPERATIONAL:
2772                         /*
2773                          * Bring it to READY state; assuming max wait 10 secs
2774                          */
2775                         instance->instancet->disable_intr(instance);
2776                         if ((instance->pdev->device ==
2777                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2778                                 (instance->pdev->device ==
2779                                 PCI_DEVICE_ID_LSI_SAS0071SKINNY)  ||
2780                                 (instance->pdev->device
2781                                         == PCI_DEVICE_ID_LSI_FUSION) ||
2782                                 (instance->pdev->device
2783                                         == PCI_DEVICE_ID_LSI_INVADER) ||
2784                                 (instance->pdev->device
2785                                         == PCI_DEVICE_ID_LSI_FURY)) {
2786                                 writel(MFI_RESET_FLAGS,
2787                                         &instance->reg_set->doorbell);
2788                                 if ((instance->pdev->device ==
2789                                         PCI_DEVICE_ID_LSI_FUSION) ||
2790                                         (instance->pdev->device ==
2791                                         PCI_DEVICE_ID_LSI_INVADER) ||
2792                                         (instance->pdev->device ==
2793                                         PCI_DEVICE_ID_LSI_FURY)) {
2794                                         for (i = 0; i < (10 * 1000); i += 20) {
2795                                                 if (readl(
2796                                                             &instance->
2797                                                             reg_set->
2798                                                             doorbell) & 1)
2799                                                         msleep(20);
2800                                                 else
2801                                                         break;
2802                                         }
2803                                 }
2804                         } else
2805                                 writel(MFI_RESET_FLAGS,
2806                                         &instance->reg_set->inbound_doorbell);
2807
2808                         max_wait = MEGASAS_RESET_WAIT_TIME;
2809                         cur_state = MFI_STATE_OPERATIONAL;
2810                         break;
2811
2812                 case MFI_STATE_UNDEFINED:
2813                         /*
2814                          * This state should not last for more than 2 seconds
2815                          */
2816                         max_wait = MEGASAS_RESET_WAIT_TIME;
2817                         cur_state = MFI_STATE_UNDEFINED;
2818                         break;
2819
2820                 case MFI_STATE_BB_INIT:
2821                         max_wait = MEGASAS_RESET_WAIT_TIME;
2822                         cur_state = MFI_STATE_BB_INIT;
2823                         break;
2824
2825                 case MFI_STATE_FW_INIT:
2826                         max_wait = MEGASAS_RESET_WAIT_TIME;
2827                         cur_state = MFI_STATE_FW_INIT;
2828                         break;
2829
2830                 case MFI_STATE_FW_INIT_2:
2831                         max_wait = MEGASAS_RESET_WAIT_TIME;
2832                         cur_state = MFI_STATE_FW_INIT_2;
2833                         break;
2834
2835                 case MFI_STATE_DEVICE_SCAN:
2836                         max_wait = MEGASAS_RESET_WAIT_TIME;
2837                         cur_state = MFI_STATE_DEVICE_SCAN;
2838                         break;
2839
2840                 case MFI_STATE_FLUSH_CACHE:
2841                         max_wait = MEGASAS_RESET_WAIT_TIME;
2842                         cur_state = MFI_STATE_FLUSH_CACHE;
2843                         break;
2844
2845                 default:
2846                         printk(KERN_DEBUG "megasas: Unknown state 0x%x\n",
2847                                fw_state);
2848                         return -ENODEV;
2849                 }
2850
2851                 /*
2852                  * The cur_state should not last for more than max_wait secs
2853                  */
2854                 for (i = 0; i < (max_wait * 1000); i++) {
2855                         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) &
2856                                         MFI_STATE_MASK ;
2857                 curr_abs_state =
2858                 instance->instancet->read_fw_status_reg(instance->reg_set);
2859
2860                         if (abs_state == curr_abs_state) {
2861                                 msleep(1);
2862                         } else
2863                                 break;
2864                 }
2865
2866                 /*
2867                  * Return error if fw_state hasn't changed after max_wait
2868                  */
2869                 if (curr_abs_state == abs_state) {
2870                         printk(KERN_DEBUG "FW state [%d] hasn't changed "
2871                                "in %d secs\n", fw_state, max_wait);
2872                         return -ENODEV;
2873                 }
2874         }
2875         printk(KERN_INFO "megasas: FW now in Ready state\n");
2876
2877         return 0;
2878 }
2879
2880 /**
2881  * megasas_teardown_frame_pool -        Destroy the cmd frame DMA pool
2882  * @instance:                           Adapter soft state
2883  */
2884 static void megasas_teardown_frame_pool(struct megasas_instance *instance)
2885 {
2886         int i;
2887         u32 max_cmd = instance->max_mfi_cmds;
2888         struct megasas_cmd *cmd;
2889
2890         if (!instance->frame_dma_pool)
2891                 return;
2892
2893         /*
2894          * Return all frames to pool
2895          */
2896         for (i = 0; i < max_cmd; i++) {
2897
2898                 cmd = instance->cmd_list[i];
2899
2900                 if (cmd->frame)
2901                         pci_pool_free(instance->frame_dma_pool, cmd->frame,
2902                                       cmd->frame_phys_addr);
2903
2904                 if (cmd->sense)
2905                         pci_pool_free(instance->sense_dma_pool, cmd->sense,
2906                                       cmd->sense_phys_addr);
2907         }
2908
2909         /*
2910          * Now destroy the pool itself
2911          */
2912         pci_pool_destroy(instance->frame_dma_pool);
2913         pci_pool_destroy(instance->sense_dma_pool);
2914
2915         instance->frame_dma_pool = NULL;
2916         instance->sense_dma_pool = NULL;
2917 }
2918
2919 /**
2920  * megasas_create_frame_pool -  Creates DMA pool for cmd frames
2921  * @instance:                   Adapter soft state
2922  *
2923  * Each command packet has an embedded DMA memory buffer that is used for
2924  * filling MFI frame and the SG list that immediately follows the frame. This
2925  * function creates those DMA memory buffers for each command packet by using
2926  * PCI pool facility.
2927  */
2928 static int megasas_create_frame_pool(struct megasas_instance *instance)
2929 {
2930         int i;
2931         u32 max_cmd;
2932         u32 sge_sz;
2933         u32 sgl_sz;
2934         u32 total_sz;
2935         u32 frame_count;
2936         struct megasas_cmd *cmd;
2937
2938         max_cmd = instance->max_mfi_cmds;
2939
2940         /*
2941          * Size of our frame is 64 bytes for MFI frame, followed by max SG
2942          * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer
2943          */
2944         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
2945             sizeof(struct megasas_sge32);
2946
2947         if (instance->flag_ieee) {
2948                 sge_sz = sizeof(struct megasas_sge_skinny);
2949         }
2950
2951         /*
2952          * Calculated the number of 64byte frames required for SGL
2953          */
2954         sgl_sz = sge_sz * instance->max_num_sge;
2955         frame_count = (sgl_sz + MEGAMFI_FRAME_SIZE - 1) / MEGAMFI_FRAME_SIZE;
2956         frame_count = 15;
2957
2958         /*
2959          * We need one extra frame for the MFI command
2960          */
2961         frame_count++;
2962
2963         total_sz = MEGAMFI_FRAME_SIZE * frame_count;
2964         /*
2965          * Use DMA pool facility provided by PCI layer
2966          */
2967         instance->frame_dma_pool = pci_pool_create("megasas frame pool",
2968                                                    instance->pdev, total_sz, 64,
2969                                                    0);
2970
2971         if (!instance->frame_dma_pool) {
2972                 printk(KERN_DEBUG "megasas: failed to setup frame pool\n");
2973                 return -ENOMEM;
2974         }
2975
2976         instance->sense_dma_pool = pci_pool_create("megasas sense pool",
2977                                                    instance->pdev, 128, 4, 0);
2978
2979         if (!instance->sense_dma_pool) {
2980                 printk(KERN_DEBUG "megasas: failed to setup sense pool\n");
2981
2982                 pci_pool_destroy(instance->frame_dma_pool);
2983                 instance->frame_dma_pool = NULL;
2984
2985                 return -ENOMEM;
2986         }
2987
2988         /*
2989          * Allocate and attach a frame to each of the commands in cmd_list.
2990          * By making cmd->index as the context instead of the &cmd, we can
2991          * always use 32bit context regardless of the architecture
2992          */
2993         for (i = 0; i < max_cmd; i++) {
2994
2995                 cmd = instance->cmd_list[i];
2996
2997                 cmd->frame = pci_pool_alloc(instance->frame_dma_pool,
2998                                             GFP_KERNEL, &cmd->frame_phys_addr);
2999
3000                 cmd->sense = pci_pool_alloc(instance->sense_dma_pool,
3001                                             GFP_KERNEL, &cmd->sense_phys_addr);
3002
3003                 /*
3004                  * megasas_teardown_frame_pool() takes care of freeing
3005                  * whatever has been allocated
3006                  */
3007                 if (!cmd->frame || !cmd->sense) {
3008                         printk(KERN_DEBUG "megasas: pci_pool_alloc failed \n");
3009                         megasas_teardown_frame_pool(instance);
3010                         return -ENOMEM;
3011                 }
3012
3013                 memset(cmd->frame, 0, total_sz);
3014                 cmd->frame->io.context = cpu_to_le32(cmd->index);
3015                 cmd->frame->io.pad_0 = 0;
3016                 if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) &&
3017                     (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) &&
3018                         (instance->pdev->device != PCI_DEVICE_ID_LSI_FURY) &&
3019                     (reset_devices))
3020                         cmd->frame->hdr.cmd = MFI_CMD_INVALID;
3021         }
3022
3023         return 0;
3024 }
3025
3026 /**
3027  * megasas_free_cmds -  Free all the cmds in the free cmd pool
3028  * @instance:           Adapter soft state
3029  */
3030 void megasas_free_cmds(struct megasas_instance *instance)
3031 {
3032         int i;
3033         /* First free the MFI frame pool */
3034         megasas_teardown_frame_pool(instance);
3035
3036         /* Free all the commands in the cmd_list */
3037         for (i = 0; i < instance->max_mfi_cmds; i++)
3038
3039                 kfree(instance->cmd_list[i]);
3040
3041         /* Free the cmd_list buffer itself */
3042         kfree(instance->cmd_list);
3043         instance->cmd_list = NULL;
3044
3045         INIT_LIST_HEAD(&instance->cmd_pool);
3046 }
3047
3048 /**
3049  * megasas_alloc_cmds - Allocates the command packets
3050  * @instance:           Adapter soft state
3051  *
3052  * Each command that is issued to the FW, whether IO commands from the OS or
3053  * internal commands like IOCTLs, are wrapped in local data structure called
3054  * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to
3055  * the FW.
3056  *
3057  * Each frame has a 32-bit field called context (tag). This context is used
3058  * to get back the megasas_cmd from the frame when a frame gets completed in
3059  * the ISR. Typically the address of the megasas_cmd itself would be used as
3060  * the context. But we wanted to keep the differences between 32 and 64 bit
3061  * systems to the mininum. We always use 32 bit integers for the context. In
3062  * this driver, the 32 bit values are the indices into an array cmd_list.
3063  * This array is used only to look up the megasas_cmd given the context. The
3064  * free commands themselves are maintained in a linked list called cmd_pool.
3065  */
3066 int megasas_alloc_cmds(struct megasas_instance *instance)
3067 {
3068         int i;
3069         int j;
3070         u32 max_cmd;
3071         struct megasas_cmd *cmd;
3072
3073         max_cmd = instance->max_mfi_cmds;
3074
3075         /*
3076          * instance->cmd_list is an array of struct megasas_cmd pointers.
3077          * Allocate the dynamic array first and then allocate individual
3078          * commands.
3079          */
3080         instance->cmd_list = kcalloc(max_cmd, sizeof(struct megasas_cmd*), GFP_KERNEL);
3081
3082         if (!instance->cmd_list) {
3083                 printk(KERN_DEBUG "megasas: out of memory\n");
3084                 return -ENOMEM;
3085         }
3086
3087         memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) *max_cmd);
3088
3089         for (i = 0; i < max_cmd; i++) {
3090                 instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
3091                                                 GFP_KERNEL);
3092
3093                 if (!instance->cmd_list[i]) {
3094
3095                         for (j = 0; j < i; j++)
3096                                 kfree(instance->cmd_list[j]);
3097
3098                         kfree(instance->cmd_list);
3099                         instance->cmd_list = NULL;
3100
3101                         return -ENOMEM;
3102                 }
3103         }
3104
3105         /*
3106          * Add all the commands to command pool (instance->cmd_pool)
3107          */
3108         for (i = 0; i < max_cmd; i++) {
3109                 cmd = instance->cmd_list[i];
3110                 memset(cmd, 0, sizeof(struct megasas_cmd));
3111                 cmd->index = i;
3112                 cmd->scmd = NULL;
3113                 cmd->instance = instance;
3114
3115                 list_add_tail(&cmd->list, &instance->cmd_pool);
3116         }
3117
3118         /*
3119          * Create a frame pool and assign one frame to each cmd
3120          */
3121         if (megasas_create_frame_pool(instance)) {
3122                 printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n");
3123                 megasas_free_cmds(instance);
3124         }
3125
3126         return 0;
3127 }
3128
3129 /*
3130  * megasas_get_pd_list_info -   Returns FW's pd_list structure
3131  * @instance:                           Adapter soft state
3132  * @pd_list:                            pd_list structure
3133  *
3134  * Issues an internal command (DCMD) to get the FW's controller PD
3135  * list structure.  This information is mainly used to find out SYSTEM
3136  * supported by the FW.
3137  */
3138 static int
3139 megasas_get_pd_list(struct megasas_instance *instance)
3140 {
3141         int ret = 0, pd_index = 0;
3142         struct megasas_cmd *cmd;
3143         struct megasas_dcmd_frame *dcmd;
3144         struct MR_PD_LIST *ci;
3145         struct MR_PD_ADDRESS *pd_addr;
3146         dma_addr_t ci_h = 0;
3147
3148         cmd = megasas_get_cmd(instance);
3149
3150         if (!cmd) {
3151                 printk(KERN_DEBUG "megasas (get_pd_list): Failed to get cmd\n");
3152                 return -ENOMEM;
3153         }
3154
3155         dcmd = &cmd->frame->dcmd;
3156
3157         ci = pci_alloc_consistent(instance->pdev,
3158                   MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST), &ci_h);
3159
3160         if (!ci) {
3161                 printk(KERN_DEBUG "Failed to alloc mem for pd_list\n");
3162                 megasas_return_cmd(instance, cmd);
3163                 return -ENOMEM;
3164         }
3165
3166         memset(ci, 0, sizeof(*ci));
3167         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3168
3169         dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
3170         dcmd->mbox.b[1] = 0;
3171         dcmd->cmd = MFI_CMD_DCMD;
3172         dcmd->cmd_status = 0xFF;
3173         dcmd->sge_count = 1;
3174         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
3175         dcmd->timeout = 0;
3176         dcmd->pad_0 = 0;
3177         dcmd->data_xfer_len = cpu_to_le32(MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST));
3178         dcmd->opcode = cpu_to_le32(MR_DCMD_PD_LIST_QUERY);
3179         dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
3180         dcmd->sgl.sge32[0].length = cpu_to_le32(MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST));
3181
3182         if (!megasas_issue_polled(instance, cmd)) {
3183                 ret = 0;
3184         } else {
3185                 ret = -1;
3186         }
3187
3188         /*
3189         * the following function will get the instance PD LIST.
3190         */
3191
3192         pd_addr = ci->addr;
3193
3194         if ( ret == 0 &&
3195              (le32_to_cpu(ci->count) <
3196                   (MEGASAS_MAX_PD_CHANNELS * MEGASAS_MAX_DEV_PER_CHANNEL))) {
3197
3198                 memset(instance->local_pd_list, 0,
3199                         MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
3200
3201                 for (pd_index = 0; pd_index < le32_to_cpu(ci->count); pd_index++) {
3202
3203                         instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].tid     =
3204                                 le16_to_cpu(pd_addr->deviceId);
3205                         instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveType       =
3206                                                         pd_addr->scsiDevType;
3207                         instance->local_pd_list[le16_to_cpu(pd_addr->deviceId)].driveState      =
3208                                                         MR_PD_STATE_SYSTEM;
3209                         pd_addr++;
3210                 }
3211                 memcpy(instance->pd_list, instance->local_pd_list,
3212                         sizeof(instance->pd_list));
3213         }
3214
3215         pci_free_consistent(instance->pdev,
3216                                 MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
3217                                 ci, ci_h);
3218         megasas_return_cmd(instance, cmd);
3219
3220         return ret;
3221 }
3222
3223 /*
3224  * megasas_get_ld_list_info -   Returns FW's ld_list structure
3225  * @instance:                           Adapter soft state
3226  * @ld_list:                            ld_list structure
3227  *
3228  * Issues an internal command (DCMD) to get the FW's controller PD
3229  * list structure.  This information is mainly used to find out SYSTEM
3230  * supported by the FW.
3231  */
3232 static int
3233 megasas_get_ld_list(struct megasas_instance *instance)
3234 {
3235         int ret = 0, ld_index = 0, ids = 0;
3236         struct megasas_cmd *cmd;
3237         struct megasas_dcmd_frame *dcmd;
3238         struct MR_LD_LIST *ci;
3239         dma_addr_t ci_h = 0;
3240         u32 ld_count;
3241
3242         cmd = megasas_get_cmd(instance);
3243
3244         if (!cmd) {
3245                 printk(KERN_DEBUG "megasas_get_ld_list: Failed to get cmd\n");
3246                 return -ENOMEM;
3247         }
3248
3249         dcmd = &cmd->frame->dcmd;
3250
3251         ci = pci_alloc_consistent(instance->pdev,
3252                                 sizeof(struct MR_LD_LIST),
3253                                 &ci_h);
3254
3255         if (!ci) {
3256                 printk(KERN_DEBUG "Failed to alloc mem in get_ld_list\n");
3257                 megasas_return_cmd(instance, cmd);
3258                 return -ENOMEM;
3259         }
3260
3261         memset(ci, 0, sizeof(*ci));
3262         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3263
3264         dcmd->cmd = MFI_CMD_DCMD;
3265         dcmd->cmd_status = 0xFF;
3266         dcmd->sge_count = 1;
3267         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
3268         dcmd->timeout = 0;
3269         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_LIST));
3270         dcmd->opcode = cpu_to_le32(MR_DCMD_LD_GET_LIST);
3271         dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
3272         dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct MR_LD_LIST));
3273         dcmd->pad_0  = 0;
3274
3275         if (!megasas_issue_polled(instance, cmd)) {
3276                 ret = 0;
3277         } else {
3278                 ret = -1;
3279         }
3280
3281         ld_count = le32_to_cpu(ci->ldCount);
3282
3283         /* the following function will get the instance PD LIST */
3284
3285         if ((ret == 0) && (ld_count <= MAX_LOGICAL_DRIVES)) {
3286                 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
3287
3288                 for (ld_index = 0; ld_index < ld_count; ld_index++) {
3289                         if (ci->ldList[ld_index].state != 0) {
3290                                 ids = ci->ldList[ld_index].ref.targetId;
3291                                 instance->ld_ids[ids] =
3292                                         ci->ldList[ld_index].ref.targetId;
3293                         }
3294                 }
3295         }
3296
3297         pci_free_consistent(instance->pdev,
3298                                 sizeof(struct MR_LD_LIST),
3299                                 ci,
3300                                 ci_h);
3301
3302         megasas_return_cmd(instance, cmd);
3303         return ret;
3304 }
3305
3306 /**
3307  * megasas_ld_list_query -      Returns FW's ld_list structure
3308  * @instance:                           Adapter soft state
3309  * @ld_list:                            ld_list structure
3310  *
3311  * Issues an internal command (DCMD) to get the FW's controller PD
3312  * list structure.  This information is mainly used to find out SYSTEM
3313  * supported by the FW.
3314  */
3315 static int
3316 megasas_ld_list_query(struct megasas_instance *instance, u8 query_type)
3317 {
3318         int ret = 0, ld_index = 0, ids = 0;
3319         struct megasas_cmd *cmd;
3320         struct megasas_dcmd_frame *dcmd;
3321         struct MR_LD_TARGETID_LIST *ci;
3322         dma_addr_t ci_h = 0;
3323         u32 tgtid_count;
3324
3325         cmd = megasas_get_cmd(instance);
3326
3327         if (!cmd) {
3328                 printk(KERN_WARNING
3329                        "megasas:(megasas_ld_list_query): Failed to get cmd\n");
3330                 return -ENOMEM;
3331         }
3332
3333         dcmd = &cmd->frame->dcmd;
3334
3335         ci = pci_alloc_consistent(instance->pdev,
3336                                   sizeof(struct MR_LD_TARGETID_LIST), &ci_h);
3337
3338         if (!ci) {
3339                 printk(KERN_WARNING
3340                        "megasas: Failed to alloc mem for ld_list_query\n");
3341                 megasas_return_cmd(instance, cmd);
3342                 return -ENOMEM;
3343         }
3344
3345         memset(ci, 0, sizeof(*ci));
3346         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3347
3348         dcmd->mbox.b[0] = query_type;
3349
3350         dcmd->cmd = MFI_CMD_DCMD;
3351         dcmd->cmd_status = 0xFF;
3352         dcmd->sge_count = 1;
3353         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
3354         dcmd->timeout = 0;
3355         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST));
3356         dcmd->opcode = cpu_to_le32(MR_DCMD_LD_LIST_QUERY);
3357         dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
3358         dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct MR_LD_TARGETID_LIST));
3359         dcmd->pad_0  = 0;
3360
3361         if (!megasas_issue_polled(instance, cmd) && !dcmd->cmd_status) {
3362                 ret = 0;
3363         } else {
3364                 /* On failure, call older LD list DCMD */
3365                 ret = 1;
3366         }
3367
3368         tgtid_count = le32_to_cpu(ci->count);
3369
3370         if ((ret == 0) && (tgtid_count <= (MAX_LOGICAL_DRIVES))) {
3371                 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
3372                 for (ld_index = 0; ld_index < tgtid_count; ld_index++) {
3373                         ids = ci->targetId[ld_index];
3374                         instance->ld_ids[ids] = ci->targetId[ld_index];
3375                 }
3376
3377         }
3378
3379         pci_free_consistent(instance->pdev, sizeof(struct MR_LD_TARGETID_LIST),
3380                             ci, ci_h);
3381
3382         megasas_return_cmd(instance, cmd);
3383
3384         return ret;
3385 }
3386
3387 /**
3388  * megasas_get_controller_info -        Returns FW's controller structure
3389  * @instance:                           Adapter soft state
3390  * @ctrl_info:                          Controller information structure
3391  *
3392  * Issues an internal command (DCMD) to get the FW's controller structure.
3393  * This information is mainly used to find out the maximum IO transfer per
3394  * command supported by the FW.
3395  */
3396 static int
3397 megasas_get_ctrl_info(struct megasas_instance *instance,
3398                       struct megasas_ctrl_info *ctrl_info)
3399 {
3400         int ret = 0;
3401         struct megasas_cmd *cmd;
3402         struct megasas_dcmd_frame *dcmd;
3403         struct megasas_ctrl_info *ci;
3404         dma_addr_t ci_h = 0;
3405
3406         cmd = megasas_get_cmd(instance);
3407
3408         if (!cmd) {
3409                 printk(KERN_DEBUG "megasas: Failed to get a free cmd\n");
3410                 return -ENOMEM;
3411         }
3412
3413         dcmd = &cmd->frame->dcmd;
3414
3415         ci = pci_alloc_consistent(instance->pdev,
3416                                   sizeof(struct megasas_ctrl_info), &ci_h);
3417
3418         if (!ci) {
3419                 printk(KERN_DEBUG "Failed to alloc mem for ctrl info\n");
3420                 megasas_return_cmd(instance, cmd);
3421                 return -ENOMEM;
3422         }
3423
3424         memset(ci, 0, sizeof(*ci));
3425         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3426
3427         dcmd->cmd = MFI_CMD_DCMD;
3428         dcmd->cmd_status = 0xFF;
3429         dcmd->sge_count = 1;
3430         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
3431         dcmd->timeout = 0;
3432         dcmd->pad_0 = 0;
3433         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_ctrl_info));
3434         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_GET_INFO);
3435         dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(ci_h);
3436         dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_ctrl_info));
3437
3438         if (!megasas_issue_polled(instance, cmd)) {
3439                 ret = 0;
3440                 memcpy(ctrl_info, ci, sizeof(struct megasas_ctrl_info));
3441         } else {
3442                 ret = -1;
3443         }
3444
3445         pci_free_consistent(instance->pdev, sizeof(struct megasas_ctrl_info),
3446                             ci, ci_h);
3447
3448         megasas_return_cmd(instance, cmd);
3449         return ret;
3450 }
3451
3452 /**
3453  * megasas_issue_init_mfi -     Initializes the FW
3454  * @instance:           Adapter soft state
3455  *
3456  * Issues the INIT MFI cmd
3457  */
3458 static int
3459 megasas_issue_init_mfi(struct megasas_instance *instance)
3460 {
3461         u32 context;
3462
3463         struct megasas_cmd *cmd;
3464
3465         struct megasas_init_frame *init_frame;
3466         struct megasas_init_queue_info *initq_info;
3467         dma_addr_t init_frame_h;
3468         dma_addr_t initq_info_h;
3469
3470         /*
3471          * Prepare a init frame. Note the init frame points to queue info
3472          * structure. Each frame has SGL allocated after first 64 bytes. For
3473          * this frame - since we don't need any SGL - we use SGL's space as
3474          * queue info structure
3475          *
3476          * We will not get a NULL command below. We just created the pool.
3477          */
3478         cmd = megasas_get_cmd(instance);
3479
3480         init_frame = (struct megasas_init_frame *)cmd->frame;
3481         initq_info = (struct megasas_init_queue_info *)
3482                 ((unsigned long)init_frame + 64);
3483
3484         init_frame_h = cmd->frame_phys_addr;
3485         initq_info_h = init_frame_h + 64;
3486
3487         context = init_frame->context;
3488         memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
3489         memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
3490         init_frame->context = context;
3491
3492         initq_info->reply_queue_entries = cpu_to_le32(instance->max_fw_cmds + 1);
3493         initq_info->reply_queue_start_phys_addr_lo = cpu_to_le32(instance->reply_queue_h);
3494
3495         initq_info->producer_index_phys_addr_lo = cpu_to_le32(instance->producer_h);
3496         initq_info->consumer_index_phys_addr_lo = cpu_to_le32(instance->consumer_h);
3497
3498         init_frame->cmd = MFI_CMD_INIT;
3499         init_frame->cmd_status = 0xFF;
3500         init_frame->queue_info_new_phys_addr_lo =
3501                 cpu_to_le32(lower_32_bits(initq_info_h));
3502         init_frame->queue_info_new_phys_addr_hi =
3503                 cpu_to_le32(upper_32_bits(initq_info_h));
3504
3505         init_frame->data_xfer_len = cpu_to_le32(sizeof(struct megasas_init_queue_info));
3506
3507         /*
3508          * disable the intr before firing the init frame to FW
3509          */
3510         instance->instancet->disable_intr(instance);
3511
3512         /*
3513          * Issue the init frame in polled mode
3514          */
3515
3516         if (megasas_issue_polled(instance, cmd)) {
3517                 printk(KERN_ERR "megasas: Failed to init firmware\n");
3518                 megasas_return_cmd(instance, cmd);
3519                 goto fail_fw_init;
3520         }
3521
3522         megasas_return_cmd(instance, cmd);
3523
3524         return 0;
3525
3526 fail_fw_init:
3527         return -EINVAL;
3528 }
3529
3530 static u32
3531 megasas_init_adapter_mfi(struct megasas_instance *instance)
3532 {
3533         struct megasas_register_set __iomem *reg_set;
3534         u32 context_sz;
3535         u32 reply_q_sz;
3536
3537         reg_set = instance->reg_set;
3538
3539         /*
3540          * Get various operational parameters from status register
3541          */
3542         instance->max_fw_cmds = instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
3543         /*
3544          * Reduce the max supported cmds by 1. This is to ensure that the
3545          * reply_q_sz (1 more than the max cmd that driver may send)
3546          * does not exceed max cmds that the FW can support
3547          */
3548         instance->max_fw_cmds = instance->max_fw_cmds-1;
3549         instance->max_mfi_cmds = instance->max_fw_cmds;
3550         instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >>
3551                                         0x10;
3552         /*
3553          * Create a pool of commands
3554          */
3555         if (megasas_alloc_cmds(instance))
3556                 goto fail_alloc_cmds;
3557
3558         /*
3559          * Allocate memory for reply queue. Length of reply queue should
3560          * be _one_ more than the maximum commands handled by the firmware.
3561          *
3562          * Note: When FW completes commands, it places corresponding contex
3563          * values in this circular reply queue. This circular queue is a fairly
3564          * typical producer-consumer queue. FW is the producer (of completed
3565          * commands) and the driver is the consumer.
3566          */
3567         context_sz = sizeof(u32);
3568         reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
3569
3570         instance->reply_queue = pci_alloc_consistent(instance->pdev,
3571                                                      reply_q_sz,
3572                                                      &instance->reply_queue_h);
3573
3574         if (!instance->reply_queue) {
3575                 printk(KERN_DEBUG "megasas: Out of DMA mem for reply queue\n");
3576                 goto fail_reply_queue;
3577         }
3578
3579         if (megasas_issue_init_mfi(instance))
3580                 goto fail_fw_init;
3581
3582         instance->fw_support_ieee = 0;
3583         instance->fw_support_ieee =
3584                 (instance->instancet->read_fw_status_reg(reg_set) &
3585                 0x04000000);
3586
3587         printk(KERN_NOTICE "megasas_init_mfi: fw_support_ieee=%d",
3588                         instance->fw_support_ieee);
3589
3590         if (instance->fw_support_ieee)
3591                 instance->flag_ieee = 1;
3592
3593         return 0;
3594
3595 fail_fw_init:
3596
3597         pci_free_consistent(instance->pdev, reply_q_sz,
3598                             instance->reply_queue, instance->reply_queue_h);
3599 fail_reply_queue:
3600         megasas_free_cmds(instance);
3601
3602 fail_alloc_cmds:
3603         return 1;
3604 }
3605
3606 /**
3607  * megasas_init_fw -    Initializes the FW
3608  * @instance:           Adapter soft state
3609  *
3610  * This is the main function for initializing firmware
3611  */
3612
3613 static int megasas_init_fw(struct megasas_instance *instance)
3614 {
3615         u32 max_sectors_1;
3616         u32 max_sectors_2;
3617         u32 tmp_sectors, msix_enable, scratch_pad_2;
3618         resource_size_t base_addr;
3619         struct megasas_register_set __iomem *reg_set;
3620         struct megasas_ctrl_info *ctrl_info;
3621         unsigned long bar_list;
3622         int i, loop, fw_msix_count = 0;
3623
3624         /* Find first memory bar */
3625         bar_list = pci_select_bars(instance->pdev, IORESOURCE_MEM);
3626         instance->bar = find_first_bit(&bar_list, sizeof(unsigned long));
3627         if (pci_request_selected_regions(instance->pdev, instance->bar,
3628                                          "megasas: LSI")) {
3629                 printk(KERN_DEBUG "megasas: IO memory region busy!\n");
3630                 return -EBUSY;
3631         }
3632
3633         base_addr = pci_resource_start(instance->pdev, instance->bar);
3634         instance->reg_set = ioremap_nocache(base_addr, 8192);
3635
3636         if (!instance->reg_set) {
3637                 printk(KERN_DEBUG "megasas: Failed to map IO mem\n");
3638                 goto fail_ioremap;
3639         }
3640
3641         reg_set = instance->reg_set;
3642
3643         switch (instance->pdev->device) {
3644         case PCI_DEVICE_ID_LSI_FUSION:
3645         case PCI_DEVICE_ID_LSI_INVADER:
3646         case PCI_DEVICE_ID_LSI_FURY:
3647                 instance->instancet = &megasas_instance_template_fusion;
3648                 break;
3649         case PCI_DEVICE_ID_LSI_SAS1078R:
3650         case PCI_DEVICE_ID_LSI_SAS1078DE:
3651                 instance->instancet = &megasas_instance_template_ppc;
3652                 break;
3653         case PCI_DEVICE_ID_LSI_SAS1078GEN2:
3654         case PCI_DEVICE_ID_LSI_SAS0079GEN2:
3655                 instance->instancet = &megasas_instance_template_gen2;
3656                 break;
3657         case PCI_DEVICE_ID_LSI_SAS0073SKINNY:
3658         case PCI_DEVICE_ID_LSI_SAS0071SKINNY:
3659                 instance->instancet = &megasas_instance_template_skinny;
3660                 break;
3661         case PCI_DEVICE_ID_LSI_SAS1064R:
3662         case PCI_DEVICE_ID_DELL_PERC5:
3663         default:
3664                 instance->instancet = &megasas_instance_template_xscale;
3665                 break;
3666         }
3667
3668         if (megasas_transition_to_ready(instance, 0)) {
3669                 atomic_set(&instance->fw_reset_no_pci_access, 1);
3670                 instance->instancet->adp_reset
3671                         (instance, instance->reg_set);
3672                 atomic_set(&instance->fw_reset_no_pci_access, 0);
3673                 dev_info(&instance->pdev->dev,
3674                         "megasas: FW restarted successfully from %s!\n",
3675                         __func__);
3676
3677                 /*waitting for about 30 second before retry*/
3678                 ssleep(30);
3679
3680                 if (megasas_transition_to_ready(instance, 0))
3681                         goto fail_ready_state;
3682         }
3683
3684         /*
3685          * MSI-X host index 0 is common for all adapter.
3686          * It is used for all MPT based Adapters.
3687          */
3688         instance->reply_post_host_index_addr[0] =
3689                 (u32 *)((u8 *)instance->reg_set +
3690                 MPI2_REPLY_POST_HOST_INDEX_OFFSET);
3691
3692         /* Check if MSI-X is supported while in ready state */
3693         msix_enable = (instance->instancet->read_fw_status_reg(reg_set) &
3694                        0x4000000) >> 0x1a;
3695         if (msix_enable && !msix_disable) {
3696                 scratch_pad_2 = readl
3697                         (&instance->reg_set->outbound_scratch_pad_2);
3698                 /* Check max MSI-X vectors */
3699                 if (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) {
3700                         instance->msix_vectors = (scratch_pad_2
3701                                 & MR_MAX_REPLY_QUEUES_OFFSET) + 1;
3702                         fw_msix_count = instance->msix_vectors;
3703                         if (msix_vectors)
3704                                 instance->msix_vectors =
3705                                         min(msix_vectors,
3706                                             instance->msix_vectors);
3707                 } else if ((instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER)
3708                         || (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
3709                         /* Invader/Fury supports more than 8 MSI-X */
3710                         instance->msix_vectors = ((scratch_pad_2
3711                                 & MR_MAX_REPLY_QUEUES_EXT_OFFSET)
3712                                 >> MR_MAX_REPLY_QUEUES_EXT_OFFSET_SHIFT) + 1;
3713                         fw_msix_count = instance->msix_vectors;
3714                         /* Save 1-15 reply post index address to local memory
3715                          * Index 0 is already saved from reg offset
3716                          * MPI2_REPLY_POST_HOST_INDEX_OFFSET
3717                          */
3718                         for (loop = 1; loop < MR_MAX_MSIX_REG_ARRAY; loop++) {
3719                                 instance->reply_post_host_index_addr[loop] =
3720                                         (u32 *)((u8 *)instance->reg_set +
3721                                         MPI2_SUP_REPLY_POST_HOST_INDEX_OFFSET
3722                                         + (loop * 0x10));
3723                         }
3724                         if (msix_vectors)
3725                                 instance->msix_vectors = min(msix_vectors,
3726                                         instance->msix_vectors);
3727                 } else
3728                         instance->msix_vectors = 1;
3729                 /* Don't bother allocating more MSI-X vectors than cpus */
3730                 instance->msix_vectors = min(instance->msix_vectors,
3731                                              (unsigned int)num_online_cpus());
3732                 for (i = 0; i < instance->msix_vectors; i++)
3733                         instance->msixentry[i].entry = i;
3734                 i = pci_enable_msix(instance->pdev, instance->msixentry,
3735                                     instance->msix_vectors);
3736                 if (i >= 0) {
3737                         if (i) {
3738                                 if (!pci_enable_msix(instance->pdev,
3739                                                      instance->msixentry, i))
3740                                         instance->msix_vectors = i;
3741                                 else
3742                                         instance->msix_vectors = 0;
3743                         }
3744                 } else
3745                         instance->msix_vectors = 0;
3746
3747                 dev_info(&instance->pdev->dev, "[scsi%d]: FW supports"
3748                         "<%d> MSIX vector,Online CPUs: <%d>,"
3749                         "Current MSIX <%d>\n", instance->host->host_no,
3750                         fw_msix_count, (unsigned int)num_online_cpus(),
3751                         instance->msix_vectors);
3752         }
3753
3754         /* Get operational params, sge flags, send init cmd to controller */
3755         if (instance->instancet->init_adapter(instance))
3756                 goto fail_init_adapter;
3757
3758         printk(KERN_ERR "megasas: INIT adapter done\n");
3759
3760         /** for passthrough
3761         * the following function will get the PD LIST.
3762         */
3763
3764         memset(instance->pd_list, 0 ,
3765                 (MEGASAS_MAX_PD * sizeof(struct megasas_pd_list)));
3766         megasas_get_pd_list(instance);
3767
3768         memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
3769         if (megasas_ld_list_query(instance,
3770                                   MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
3771                 megasas_get_ld_list(instance);
3772
3773         ctrl_info = kmalloc(sizeof(struct megasas_ctrl_info), GFP_KERNEL);
3774
3775         /*
3776          * Compute the max allowed sectors per IO: The controller info has two
3777          * limits on max sectors. Driver should use the minimum of these two.
3778          *
3779          * 1 << stripe_sz_ops.min = max sectors per strip
3780          *
3781          * Note that older firmwares ( < FW ver 30) didn't report information
3782          * to calculate max_sectors_1. So the number ended up as zero always.
3783          */
3784         tmp_sectors = 0;
3785         if (ctrl_info && !megasas_get_ctrl_info(instance, ctrl_info)) {
3786
3787                 max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) *
3788                         le16_to_cpu(ctrl_info->max_strips_per_io);
3789                 max_sectors_2 = le32_to_cpu(ctrl_info->max_request_size);
3790
3791                 tmp_sectors = min_t(u32, max_sectors_1 , max_sectors_2);
3792
3793                 /*Check whether controller is iMR or MR */
3794                 if (ctrl_info->memory_size) {
3795                         instance->is_imr = 0;
3796                         dev_info(&instance->pdev->dev, "Controller type: MR,"
3797                                 "Memory size is: %dMB\n",
3798                                 le16_to_cpu(ctrl_info->memory_size));
3799                 } else {
3800                         instance->is_imr = 1;
3801                         dev_info(&instance->pdev->dev,
3802                                 "Controller type: iMR\n");
3803                 }
3804                 /* OnOffProperties are converted into CPU arch*/
3805                 le32_to_cpus((u32 *)&ctrl_info->properties.OnOffProperties);
3806                 instance->disableOnlineCtrlReset =
3807                 ctrl_info->properties.OnOffProperties.disableOnlineCtrlReset;
3808                 /* adapterOperations2 are converted into CPU arch*/
3809                 le32_to_cpus((u32 *)&ctrl_info->adapterOperations2);
3810                 instance->UnevenSpanSupport =
3811                         ctrl_info->adapterOperations2.supportUnevenSpans;
3812                 if (instance->UnevenSpanSupport) {
3813                         struct fusion_context *fusion = instance->ctrl_context;
3814                         dev_info(&instance->pdev->dev, "FW supports: "
3815                         "UnevenSpanSupport=%x\n", instance->UnevenSpanSupport);
3816                         if (MR_ValidateMapInfo(instance))
3817                                 fusion->fast_path_io = 1;
3818                         else
3819                                 fusion->fast_path_io = 0;
3820
3821                 }
3822         }
3823         instance->max_sectors_per_req = instance->max_num_sge *
3824                                                 PAGE_SIZE / 512;
3825         if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
3826                 instance->max_sectors_per_req = tmp_sectors;
3827
3828         kfree(ctrl_info);
3829
3830         /* Check for valid throttlequeuedepth module parameter */
3831         if (instance->is_imr) {
3832                 if (throttlequeuedepth > (instance->max_fw_cmds -
3833                                           MEGASAS_SKINNY_INT_CMDS))
3834                         instance->throttlequeuedepth =
3835                                 MEGASAS_THROTTLE_QUEUE_DEPTH;
3836                 else
3837                         instance->throttlequeuedepth = throttlequeuedepth;
3838         } else {
3839                 if (throttlequeuedepth > (instance->max_fw_cmds -
3840                                           MEGASAS_INT_CMDS))
3841                         instance->throttlequeuedepth =
3842                                 MEGASAS_THROTTLE_QUEUE_DEPTH;
3843                 else
3844                         instance->throttlequeuedepth = throttlequeuedepth;
3845         }
3846
3847         /*
3848         * Setup tasklet for cmd completion
3849         */
3850
3851         tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
3852                 (unsigned long)instance);
3853
3854         return 0;
3855
3856 fail_init_adapter:
3857 fail_ready_state:
3858         iounmap(instance->reg_set);
3859
3860       fail_ioremap:
3861         pci_release_selected_regions(instance->pdev, instance->bar);
3862
3863         return -EINVAL;
3864 }
3865
3866 /**
3867  * megasas_release_mfi -        Reverses the FW initialization
3868  * @intance:                    Adapter soft state
3869  */
3870 static void megasas_release_mfi(struct megasas_instance *instance)
3871 {
3872         u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);
3873
3874         if (instance->reply_queue)
3875                 pci_free_consistent(instance->pdev, reply_q_sz,
3876                             instance->reply_queue, instance->reply_queue_h);
3877
3878         megasas_free_cmds(instance);
3879
3880         iounmap(instance->reg_set);
3881
3882         pci_release_selected_regions(instance->pdev, instance->bar);
3883 }
3884
3885 /**
3886  * megasas_get_seq_num -        Gets latest event sequence numbers
3887  * @instance:                   Adapter soft state
3888  * @eli:                        FW event log sequence numbers information
3889  *
3890  * FW maintains a log of all events in a non-volatile area. Upper layers would
3891  * usually find out the latest sequence number of the events, the seq number at
3892  * the boot etc. They would "read" all the events below the latest seq number
3893  * by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq
3894  * number), they would subsribe to AEN (asynchronous event notification) and
3895  * wait for the events to happen.
3896  */
3897 static int
3898 megasas_get_seq_num(struct megasas_instance *instance,
3899                     struct megasas_evt_log_info *eli)
3900 {
3901         struct megasas_cmd *cmd;
3902         struct megasas_dcmd_frame *dcmd;
3903         struct megasas_evt_log_info *el_info;
3904         dma_addr_t el_info_h = 0;
3905
3906         cmd = megasas_get_cmd(instance);
3907
3908         if (!cmd) {
3909                 return -ENOMEM;
3910         }
3911
3912         dcmd = &cmd->frame->dcmd;
3913         el_info = pci_alloc_consistent(instance->pdev,
3914                                        sizeof(struct megasas_evt_log_info),
3915                                        &el_info_h);
3916
3917         if (!el_info) {
3918                 megasas_return_cmd(instance, cmd);
3919                 return -ENOMEM;
3920         }
3921
3922         memset(el_info, 0, sizeof(*el_info));
3923         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3924
3925         dcmd->cmd = MFI_CMD_DCMD;
3926         dcmd->cmd_status = 0x0;
3927         dcmd->sge_count = 1;
3928         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
3929         dcmd->timeout = 0;
3930         dcmd->pad_0 = 0;
3931         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_log_info));
3932         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_GET_INFO);
3933         dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(el_info_h);
3934         dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_evt_log_info));
3935
3936         megasas_issue_blocked_cmd(instance, cmd);
3937
3938         /*
3939          * Copy the data back into callers buffer
3940          */
3941         eli->newest_seq_num = le32_to_cpu(el_info->newest_seq_num);
3942         eli->oldest_seq_num = le32_to_cpu(el_info->oldest_seq_num);
3943         eli->clear_seq_num = le32_to_cpu(el_info->clear_seq_num);
3944         eli->shutdown_seq_num = le32_to_cpu(el_info->shutdown_seq_num);
3945         eli->boot_seq_num = le32_to_cpu(el_info->boot_seq_num);
3946
3947         pci_free_consistent(instance->pdev, sizeof(struct megasas_evt_log_info),
3948                             el_info, el_info_h);
3949
3950         megasas_return_cmd(instance, cmd);
3951
3952         return 0;
3953 }
3954
3955 /**
3956  * megasas_register_aen -       Registers for asynchronous event notification
3957  * @instance:                   Adapter soft state
3958  * @seq_num:                    The starting sequence number
3959  * @class_locale:               Class of the event
3960  *
3961  * This function subscribes for AEN for events beyond the @seq_num. It requests
3962  * to be notified if and only if the event is of type @class_locale
3963  */
3964 static int
3965 megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
3966                      u32 class_locale_word)
3967 {
3968         int ret_val;
3969         struct megasas_cmd *cmd;
3970         struct megasas_dcmd_frame *dcmd;
3971         union megasas_evt_class_locale curr_aen;
3972         union megasas_evt_class_locale prev_aen;
3973
3974         /*
3975          * If there an AEN pending already (aen_cmd), check if the
3976          * class_locale of that pending AEN is inclusive of the new
3977          * AEN request we currently have. If it is, then we don't have
3978          * to do anything. In other words, whichever events the current
3979          * AEN request is subscribing to, have already been subscribed
3980          * to.
3981          *
3982          * If the old_cmd is _not_ inclusive, then we have to abort
3983          * that command, form a class_locale that is superset of both
3984          * old and current and re-issue to the FW
3985          */
3986
3987         curr_aen.word = class_locale_word;
3988
3989         if (instance->aen_cmd) {
3990
3991                 prev_aen.word = instance->aen_cmd->frame->dcmd.mbox.w[1];
3992                 prev_aen.members.locale = le16_to_cpu(prev_aen.members.locale);
3993
3994                 /*
3995                  * A class whose enum value is smaller is inclusive of all
3996                  * higher values. If a PROGRESS (= -1) was previously
3997                  * registered, then a new registration requests for higher
3998                  * classes need not be sent to FW. They are automatically
3999                  * included.
4000                  *
4001                  * Locale numbers don't have such hierarchy. They are bitmap
4002                  * values
4003                  */
4004                 if ((prev_aen.members.class <= curr_aen.members.class) &&
4005                     !((prev_aen.members.locale & curr_aen.members.locale) ^
4006                       curr_aen.members.locale)) {
4007                         /*
4008                          * Previously issued event registration includes
4009                          * current request. Nothing to do.
4010                          */
4011                         return 0;
4012                 } else {
4013                         curr_aen.members.locale |= prev_aen.members.locale;
4014
4015                         if (prev_aen.members.class < curr_aen.members.class)
4016                                 curr_aen.members.class = prev_aen.members.class;
4017
4018                         instance->aen_cmd->abort_aen = 1;
4019                         ret_val = megasas_issue_blocked_abort_cmd(instance,
4020                                                                   instance->
4021                                                                   aen_cmd);
4022
4023                         if (ret_val) {
4024                                 printk(KERN_DEBUG "megasas: Failed to abort "
4025                                        "previous AEN command\n");
4026                                 return ret_val;
4027                         }
4028                 }
4029         }
4030
4031         cmd = megasas_get_cmd(instance);
4032
4033         if (!cmd)
4034                 return -ENOMEM;
4035
4036         dcmd = &cmd->frame->dcmd;
4037
4038         memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail));
4039
4040         /*
4041          * Prepare DCMD for aen registration
4042          */
4043         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4044
4045         dcmd->cmd = MFI_CMD_DCMD;
4046         dcmd->cmd_status = 0x0;
4047         dcmd->sge_count = 1;
4048         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_READ);
4049         dcmd->timeout = 0;
4050         dcmd->pad_0 = 0;
4051         dcmd->data_xfer_len = cpu_to_le32(sizeof(struct megasas_evt_detail));
4052         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_EVENT_WAIT);
4053         dcmd->mbox.w[0] = cpu_to_le32(seq_num);
4054         instance->last_seq_num = seq_num;
4055         dcmd->mbox.w[1] = cpu_to_le32(curr_aen.word);
4056         dcmd->sgl.sge32[0].phys_addr = cpu_to_le32(instance->evt_detail_h);
4057         dcmd->sgl.sge32[0].length = cpu_to_le32(sizeof(struct megasas_evt_detail));
4058
4059         if (instance->aen_cmd != NULL) {
4060                 megasas_return_cmd(instance, cmd);
4061                 return 0;
4062         }
4063
4064         /*
4065          * Store reference to the cmd used to register for AEN. When an
4066          * application wants us to register for AEN, we have to abort this
4067          * cmd and re-register with a new EVENT LOCALE supplied by that app
4068          */
4069         instance->aen_cmd = cmd;
4070
4071         /*
4072          * Issue the aen registration frame
4073          */
4074         instance->instancet->issue_dcmd(instance, cmd);
4075
4076         return 0;
4077 }
4078
4079 /**
4080  * megasas_start_aen -  Subscribes to AEN during driver load time
4081  * @instance:           Adapter soft state
4082  */
4083 static int megasas_start_aen(struct megasas_instance *instance)
4084 {
4085         struct megasas_evt_log_info eli;
4086         union megasas_evt_class_locale class_locale;
4087
4088         /*
4089          * Get the latest sequence number from FW
4090          */
4091         memset(&eli, 0, sizeof(eli));
4092
4093         if (megasas_get_seq_num(instance, &eli))
4094                 return -1;
4095
4096         /*
4097          * Register AEN with FW for latest sequence number plus 1
4098          */
4099         class_locale.members.reserved = 0;
4100         class_locale.members.locale = MR_EVT_LOCALE_ALL;
4101         class_locale.members.class = MR_EVT_CLASS_DEBUG;
4102
4103         return megasas_register_aen(instance,
4104                         eli.newest_seq_num + 1,
4105                         class_locale.word);
4106 }
4107
4108 /**
4109  * megasas_io_attach -  Attaches this driver to SCSI mid-layer
4110  * @instance:           Adapter soft state
4111  */
4112 static int megasas_io_attach(struct megasas_instance *instance)
4113 {
4114         struct Scsi_Host *host = instance->host;
4115
4116         /*
4117          * Export parameters required by SCSI mid-layer
4118          */
4119         host->irq = instance->pdev->irq;
4120         host->unique_id = instance->unique_id;
4121         if (instance->is_imr) {
4122                 host->can_queue =
4123                         instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
4124         } else
4125                 host->can_queue =
4126                         instance->max_fw_cmds - MEGASAS_INT_CMDS;
4127         host->this_id = instance->init_id;
4128         host->sg_tablesize = instance->max_num_sge;
4129
4130         if (instance->fw_support_ieee)
4131                 instance->max_sectors_per_req = MEGASAS_MAX_SECTORS_IEEE;
4132
4133         /*
4134          * Check if the module parameter value for max_sectors can be used
4135          */
4136         if (max_sectors && max_sectors < instance->max_sectors_per_req)
4137                 instance->max_sectors_per_req = max_sectors;
4138         else {
4139                 if (max_sectors) {
4140                         if (((instance->pdev->device ==
4141                                 PCI_DEVICE_ID_LSI_SAS1078GEN2) ||
4142                                 (instance->pdev->device ==
4143                                 PCI_DEVICE_ID_LSI_SAS0079GEN2)) &&
4144                                 (max_sectors <= MEGASAS_MAX_SECTORS)) {
4145                                 instance->max_sectors_per_req = max_sectors;
4146                         } else {
4147                         printk(KERN_INFO "megasas: max_sectors should be > 0"
4148                                 "and <= %d (or < 1MB for GEN2 controller)\n",
4149                                 instance->max_sectors_per_req);
4150                         }
4151                 }
4152         }
4153
4154         host->max_sectors = instance->max_sectors_per_req;
4155         host->cmd_per_lun = MEGASAS_DEFAULT_CMD_PER_LUN;
4156         host->max_channel = MEGASAS_MAX_CHANNELS - 1;
4157         host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;
4158         host->max_lun = MEGASAS_MAX_LUN;
4159         host->max_cmd_len = 16;
4160
4161         /* Fusion only supports host reset */
4162         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
4163             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
4164             (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY)) {
4165                 host->hostt->eh_device_reset_handler = NULL;
4166                 host->hostt->eh_bus_reset_handler = NULL;
4167         }
4168
4169         /*
4170          * Notify the mid-layer about the new controller
4171          */
4172         if (scsi_add_host(host, &instance->pdev->dev)) {
4173                 printk(KERN_DEBUG "megasas: scsi_add_host failed\n");
4174                 return -ENODEV;
4175         }
4176
4177         /*
4178          * Trigger SCSI to scan our drives
4179          */
4180         scsi_scan_host(host);
4181         return 0;
4182 }
4183
4184 static int
4185 megasas_set_dma_mask(struct pci_dev *pdev)
4186 {
4187         /*
4188          * All our contollers are capable of performing 64-bit DMA
4189          */
4190         if (IS_DMA64) {
4191                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) {
4192
4193                         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
4194                                 goto fail_set_dma_mask;
4195                 }
4196         } else {
4197                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
4198                         goto fail_set_dma_mask;
4199         }
4200
4201         return 0;
4202
4203 fail_set_dma_mask:
4204         return 1;
4205 }
4206
4207 /**
4208  * megasas_probe_one -  PCI hotplug entry point
4209  * @pdev:               PCI device structure
4210  * @id:                 PCI ids of supported hotplugged adapter
4211  */
4212 static int megasas_probe_one(struct pci_dev *pdev,
4213                              const struct pci_device_id *id)
4214 {
4215         int rval, pos, i, j;
4216         struct Scsi_Host *host;
4217         struct megasas_instance *instance;
4218         u16 control = 0;
4219
4220         /* Reset MSI-X in the kdump kernel */
4221         if (reset_devices) {
4222                 pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
4223                 if (pos) {
4224                         pci_read_config_word(pdev, pos + PCI_MSIX_FLAGS,
4225                                              &control);
4226                         if (control & PCI_MSIX_FLAGS_ENABLE) {
4227                                 dev_info(&pdev->dev, "resetting MSI-X\n");
4228                                 pci_write_config_word(pdev,
4229                                                       pos + PCI_MSIX_FLAGS,
4230                                                       control &
4231                                                       ~PCI_MSIX_FLAGS_ENABLE);
4232                         }
4233                 }
4234         }
4235
4236         /*
4237          * Announce PCI information
4238          */
4239         printk(KERN_INFO "megasas: %#4.04x:%#4.04x:%#4.04x:%#4.04x: ",
4240                pdev->vendor, pdev->device, pdev->subsystem_vendor,
4241                pdev->subsystem_device);
4242
4243         printk("bus %d:slot %d:func %d\n",
4244                pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
4245
4246         /*
4247          * PCI prepping: enable device set bus mastering and dma mask
4248          */
4249         rval = pci_enable_device_mem(pdev);
4250
4251         if (rval) {
4252                 return rval;
4253         }
4254
4255         pci_set_master(pdev);
4256
4257         if (megasas_set_dma_mask(pdev))
4258                 goto fail_set_dma_mask;
4259
4260         host = scsi_host_alloc(&megasas_template,
4261                                sizeof(struct megasas_instance));
4262
4263         if (!host) {
4264                 printk(KERN_DEBUG "megasas: scsi_host_alloc failed\n");
4265                 goto fail_alloc_instance;
4266         }
4267
4268         instance = (struct megasas_instance *)host->hostdata;
4269         memset(instance, 0, sizeof(*instance));
4270         atomic_set( &instance->fw_reset_no_pci_access, 0 );
4271         instance->pdev = pdev;
4272
4273         switch (instance->pdev->device) {
4274         case PCI_DEVICE_ID_LSI_FUSION:
4275         case PCI_DEVICE_ID_LSI_INVADER:
4276         case PCI_DEVICE_ID_LSI_FURY:
4277         {
4278                 struct fusion_context *fusion;
4279
4280                 instance->ctrl_context =
4281                         kzalloc(sizeof(struct fusion_context), GFP_KERNEL);
4282                 if (!instance->ctrl_context) {
4283                         printk(KERN_DEBUG "megasas: Failed to allocate "
4284                                "memory for Fusion context info\n");
4285                         goto fail_alloc_dma_buf;
4286                 }
4287                 fusion = instance->ctrl_context;
4288                 INIT_LIST_HEAD(&fusion->cmd_pool);
4289                 spin_lock_init(&fusion->cmd_pool_lock);
4290         }
4291         break;
4292         default: /* For all other supported controllers */
4293
4294                 instance->producer =
4295                         pci_alloc_consistent(pdev, sizeof(u32),
4296                                              &instance->producer_h);
4297                 instance->consumer =
4298                         pci_alloc_consistent(pdev, sizeof(u32),
4299                                              &instance->consumer_h);
4300
4301                 if (!instance->producer || !instance->consumer) {
4302                         printk(KERN_DEBUG "megasas: Failed to allocate"
4303                                "memory for producer, consumer\n");
4304                         goto fail_alloc_dma_buf;
4305                 }
4306
4307                 *instance->producer = 0;
4308                 *instance->consumer = 0;
4309                 break;
4310         }
4311
4312         megasas_poll_wait_aen = 0;
4313         instance->flag_ieee = 0;
4314         instance->ev = NULL;
4315         instance->issuepend_done = 1;
4316         instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
4317         instance->is_imr = 0;
4318         megasas_poll_wait_aen = 0;
4319
4320         instance->evt_detail = pci_alloc_consistent(pdev,
4321                                                     sizeof(struct
4322                                                            megasas_evt_detail),
4323                                                     &instance->evt_detail_h);
4324
4325         if (!instance->evt_detail) {
4326                 printk(KERN_DEBUG "megasas: Failed to allocate memory for "
4327                        "event detail structure\n");
4328                 goto fail_alloc_dma_buf;
4329         }
4330
4331         /*
4332          * Initialize locks and queues
4333          */
4334         INIT_LIST_HEAD(&instance->cmd_pool);
4335         INIT_LIST_HEAD(&instance->internal_reset_pending_q);
4336
4337         atomic_set(&instance->fw_outstanding,0);
4338
4339         init_waitqueue_head(&instance->int_cmd_wait_q);
4340         init_waitqueue_head(&instance->abort_cmd_wait_q);
4341
4342         spin_lock_init(&instance->cmd_pool_lock);
4343         spin_lock_init(&instance->hba_lock);
4344         spin_lock_init(&instance->completion_lock);
4345
4346         mutex_init(&instance->aen_mutex);
4347         mutex_init(&instance->reset_mutex);
4348
4349         /*
4350          * Initialize PCI related and misc parameters
4351          */
4352         instance->host = host;
4353         instance->unique_id = pdev->bus->number << 8 | pdev->devfn;
4354         instance->init_id = MEGASAS_DEFAULT_INIT_ID;
4355
4356         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4357                 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
4358                 instance->flag_ieee = 1;
4359                 sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS);
4360         } else
4361                 sema_init(&instance->ioctl_sem, MEGASAS_INT_CMDS);
4362
4363         megasas_dbg_lvl = 0;
4364         instance->flag = 0;
4365         instance->unload = 1;
4366         instance->last_time = 0;
4367         instance->disableOnlineCtrlReset = 1;
4368         instance->UnevenSpanSupport = 0;
4369
4370         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
4371             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
4372             (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
4373                 INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq);
4374         else
4375                 INIT_WORK(&instance->work_init, process_fw_state_change_wq);
4376
4377         /*
4378          * Initialize MFI Firmware
4379          */
4380         if (megasas_init_fw(instance))
4381                 goto fail_init_mfi;
4382
4383 retry_irq_register:
4384         /*
4385          * Register IRQ
4386          */
4387         if (instance->msix_vectors) {
4388                 for (i = 0 ; i < instance->msix_vectors; i++) {
4389                         instance->irq_context[i].instance = instance;
4390                         instance->irq_context[i].MSIxIndex = i;
4391                         if (request_irq(instance->msixentry[i].vector,
4392                                         instance->instancet->service_isr, 0,
4393                                         "megasas",
4394                                         &instance->irq_context[i])) {
4395                                 printk(KERN_DEBUG "megasas: Failed to "
4396                                        "register IRQ for vector %d.\n", i);
4397                                 for (j = 0 ; j < i ; j++)
4398                                         free_irq(
4399                                                 instance->msixentry[j].vector,
4400                                                 &instance->irq_context[j]);
4401                                 /* Retry irq register for IO_APIC */
4402                                 instance->msix_vectors = 0;
4403                                 goto retry_irq_register;
4404                         }
4405                 }
4406         } else {
4407                 instance->irq_context[0].instance = instance;
4408                 instance->irq_context[0].MSIxIndex = 0;
4409                 if (request_irq(pdev->irq, instance->instancet->service_isr,
4410                                 IRQF_SHARED, "megasas",
4411                                 &instance->irq_context[0])) {
4412                         printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
4413                         goto fail_irq;
4414                 }
4415         }
4416
4417         instance->instancet->enable_intr(instance);
4418
4419         /*
4420          * Store instance in PCI softstate
4421          */
4422         pci_set_drvdata(pdev, instance);
4423
4424         /*
4425          * Add this controller to megasas_mgmt_info structure so that it
4426          * can be exported to management applications
4427          */
4428         megasas_mgmt_info.count++;
4429         megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
4430         megasas_mgmt_info.max_index++;
4431
4432         /*
4433          * Register with SCSI mid-layer
4434          */
4435         if (megasas_io_attach(instance))
4436                 goto fail_io_attach;
4437
4438         instance->unload = 0;
4439
4440         /*
4441          * Initiate AEN (Asynchronous Event Notification)
4442          */
4443         if (megasas_start_aen(instance)) {
4444                 printk(KERN_DEBUG "megasas: start aen failed\n");
4445                 goto fail_start_aen;
4446         }
4447
4448         return 0;
4449
4450       fail_start_aen:
4451       fail_io_attach:
4452         megasas_mgmt_info.count--;
4453         megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
4454         megasas_mgmt_info.max_index--;
4455
4456         instance->instancet->disable_intr(instance);
4457         if (instance->msix_vectors)
4458                 for (i = 0 ; i < instance->msix_vectors; i++)
4459                         free_irq(instance->msixentry[i].vector,
4460                                  &instance->irq_context[i]);
4461         else
4462                 free_irq(instance->pdev->irq, &instance->irq_context[0]);
4463 fail_irq:
4464         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
4465             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER) ||
4466             (instance->pdev->device == PCI_DEVICE_ID_LSI_FURY))
4467                 megasas_release_fusion(instance);
4468         else
4469                 megasas_release_mfi(instance);
4470       fail_init_mfi:
4471         if (instance->msix_vectors)
4472                 pci_disable_msix(instance->pdev);
4473       fail_alloc_dma_buf:
4474         if (instance->evt_detail)
4475                 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
4476                                     instance->evt_detail,
4477                                     instance->evt_detail_h);
4478
4479         if (instance->producer)
4480                 pci_free_consistent(pdev, sizeof(u32), instance->producer,
4481                                     instance->producer_h);
4482         if (instance->consumer)
4483                 pci_free_consistent(pdev, sizeof(u32), instance->consumer,
4484                                     instance->consumer_h);
4485         scsi_host_put(host);
4486
4487       fail_alloc_instance:
4488       fail_set_dma_mask:
4489         pci_disable_device(pdev);
4490
4491         return -ENODEV;
4492 }
4493
4494 /**
4495  * megasas_flush_cache -        Requests FW to flush all its caches
4496  * @instance:                   Adapter soft state
4497  */
4498 static void megasas_flush_cache(struct megasas_instance *instance)
4499 {
4500         struct megasas_cmd *cmd;
4501         struct megasas_dcmd_frame *dcmd;
4502
4503         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
4504                 return;
4505
4506         cmd = megasas_get_cmd(instance);
4507
4508         if (!cmd)
4509                 return;
4510
4511         dcmd = &cmd->frame->dcmd;
4512
4513         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4514
4515         dcmd->cmd = MFI_CMD_DCMD;
4516         dcmd->cmd_status = 0x0;
4517         dcmd->sge_count = 0;
4518         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
4519         dcmd->timeout = 0;
4520         dcmd->pad_0 = 0;
4521         dcmd->data_xfer_len = 0;
4522         dcmd->opcode = cpu_to_le32(MR_DCMD_CTRL_CACHE_FLUSH);
4523         dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
4524
4525         megasas_issue_blocked_cmd(instance, cmd);
4526
4527         megasas_return_cmd(instance, cmd);
4528
4529         return;
4530 }
4531
4532 /**
4533  * megasas_shutdown_controller -        Instructs FW to shutdown the controller
4534  * @instance:                           Adapter soft state
4535  * @opcode:                             Shutdown/Hibernate
4536  */
4537 static void megasas_shutdown_controller(struct megasas_instance *instance,
4538                                         u32 opcode)
4539 {
4540         struct megasas_cmd *cmd;
4541         struct megasas_dcmd_frame *dcmd;
4542
4543         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
4544                 return;
4545
4546         cmd = megasas_get_cmd(instance);
4547
4548         if (!cmd)
4549                 return;
4550
4551         if (instance->aen_cmd)
4552                 megasas_issue_blocked_abort_cmd(instance, instance->aen_cmd);
4553         if (instance->map_update_cmd)
4554                 megasas_issue_blocked_abort_cmd(instance,
4555                                                 instance->map_update_cmd);
4556         dcmd = &cmd->frame->dcmd;
4557
4558         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4559
4560         dcmd->cmd = MFI_CMD_DCMD;
4561         dcmd->cmd_status = 0x0;
4562         dcmd->sge_count = 0;
4563         dcmd->flags = cpu_to_le16(MFI_FRAME_DIR_NONE);
4564         dcmd->timeout = 0;
4565         dcmd->pad_0 = 0;
4566         dcmd->data_xfer_len = 0;
4567         dcmd->opcode = cpu_to_le32(opcode);
4568
4569         megasas_issue_blocked_cmd(instance, cmd);
4570
4571         megasas_return_cmd(instance, cmd);
4572
4573         return;
4574 }
4575
4576 #ifdef CONFIG_PM
4577 /**
4578  * megasas_suspend -    driver suspend entry point
4579  * @pdev:               PCI device structure
4580  * @state:              PCI power state to suspend routine
4581  */
4582 static int
4583 megasas_suspend(struct pci_dev *pdev, pm_message_t state)
4584 {
4585         struct Scsi_Host *host;
4586         struct megasas_instance *instance;
4587         int i;
4588
4589         instance = pci_get_drvdata(pdev);
4590         host = instance->host;
4591         instance->unload = 1;
4592
4593         megasas_flush_cache(instance);
4594         megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN);
4595
4596         /* cancel the delayed work if this work still in queue */
4597         if (instance->ev != NULL) {
4598                 struct megasas_aen_event *ev = instance->ev;
4599                 cancel_delayed_work_sync(&ev->hotplug_work);
4600                 instance->ev = NULL;
4601         }
4602
4603         tasklet_kill(&instance->isr_tasklet);
4604
4605         pci_set_drvdata(instance->pdev, instance);
4606         instance->instancet->disable_intr(instance);
4607
4608         if (instance->msix_vectors)
4609                 for (i = 0 ; i < instance->msix_vectors; i++)
4610                         free_irq(instance->msixentry[i].vector,
4611                                  &instance->irq_context[i]);
4612         else
4613                 free_irq(instance->pdev->irq, &instance->irq_context[0]);
4614         if (instance->msix_vectors)
4615                 pci_disable_msix(instance->pdev);
4616
4617         pci_save_state(pdev);
4618         pci_disable_device(pdev);
4619
4620         pci_set_power_state(pdev, pci_choose_state(pdev, state));
4621
4622         return 0;
4623 }
4624
4625 /**
4626  * megasas_resume-      driver resume entry point
4627  * @pdev:               PCI device structure
4628  */
4629 static int
4630 megasas_resume(struct pci_dev *pdev)
4631 {
4632         int rval, i, j;
4633         struct Scsi_Host *host;
4634         struct megasas_instance *instance;
4635
4636         instance = pci_get_drvdata(pdev);
4637         host = instance->host;
4638         pci_set_power_state(pdev, PCI_D0);
4639         pci_enable_wake(pdev, PCI_D0, 0);
4640         pci_restore_state(pdev);
4641
4642         /*
4643          * PCI prepping: enable device set bus mastering and dma mask
4644          */
4645         rval = pci_enable_device_mem(pdev);
4646
4647         if (rval) {
4648                 printk(KERN_ERR "megasas: Enable device failed\n");
4649                 return rval;
4650         }
4651
4652         pci_set_master(pdev);
4653
4654         if (megasas_set_dma_mask(pdev))
4655                 goto fail_set_dma_mask;
4656
4657         /*
4658          * Initialize MFI Firmware
4659          */
4660
4661         atomic_set(&instance->fw_outstanding, 0);
4662
4663         /*
4664          * We expect the FW state to be READY
4665          */
4666         if (megasas_transition_to_ready(instance, 0))
4667                 goto fail_ready_state;
4668
4669         /* Now re-enable MSI-X */
4670         if (instance->msix_vectors)
4671                 pci_enable_msix(instance->pdev, instance->msixentry,
4672                                 instance->msix_vectors);
4673
4674         switch (instance->pdev->device) {
4675         case PCI_DEVICE_ID_LSI_FUSION:
4676         case PCI_DEVICE_ID_LSI_INVADER:
4677         case PCI_DEVICE_ID_LSI_FURY:
4678         {
4679                 megasas_reset_reply_desc(instance);
4680                 if (megasas_ioc_init_fusion(instance)) {
4681                         megasas_free_cmds(instance);
4682                         megasas_free_cmds_fusion(instance);
4683                         goto fail_init_mfi;
4684                 }
4685                 if (!megasas_get_map_info(instance))
4686                         megasas_sync_map_info(instance);
4687         }
4688         break;
4689         default:
4690                 *instance->producer = 0;
4691                 *instance->consumer = 0;
4692                 if (megasas_issue_init_mfi(instance))
4693                         goto fail_init_mfi;
4694                 break;
4695         }
4696
4697         tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
4698                      (unsigned long)instance);
4699
4700         /*
4701          * Register IRQ
4702          */
4703         if (instance->msix_vectors) {
4704                 for (i = 0 ; i < instance->msix_vectors; i++) {
4705                         instance->irq_context[i].instance = instance;
4706                         instance->irq_context[i].MSIxIndex = i;
4707                         if (request_irq(instance->msixentry[i].vector,
4708                                         instance->instancet->service_isr, 0,
4709                                         "megasas",
4710                                         &instance->irq_context[i])) {
4711                                 printk(KERN_DEBUG "megasas: Failed to "
4712                                        "register IRQ for vector %d.\n", i);
4713                                 for (j = 0 ; j < i ; j++)
4714                                         free_irq(
4715                                                 instance->msixentry[j].vector,
4716                                                 &instance->irq_context[j]);
4717                                 goto fail_irq;
4718                         }
4719                 }
4720         } else {
4721                 instance->irq_context[0].instance = instance;
4722                 instance->irq_context[0].MSIxIndex = 0;
4723                 if (request_irq(pdev->irq, instance->instancet->service_isr,
4724                                 IRQF_SHARED, "megasas",
4725                                 &instance->irq_context[0])) {
4726                         printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
4727                         goto fail_irq;
4728                 }
4729         }
4730
4731         instance->instancet->enable_intr(instance);
4732         instance->unload = 0;
4733
4734         /*
4735          * Initiate AEN (Asynchronous Event Notification)
4736          */
4737         if (megasas_start_aen(instance))
4738                 printk(KERN_ERR "megasas: Start AEN failed\n");
4739
4740         return 0;
4741
4742 fail_irq:
4743 fail_init_mfi:
4744         if (instance->evt_detail)
4745                 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
4746                                 instance->evt_detail,
4747                                 instance->evt_detail_h);
4748
4749         if (instance->producer)
4750                 pci_free_consistent(pdev, sizeof(u32), instance->producer,
4751                                 instance->producer_h);
4752         if (instance->consumer)
4753                 pci_free_consistent(pdev, sizeof(u32), instance->consumer,
4754                                 instance->consumer_h);
4755         scsi_host_put(host);
4756
4757 fail_set_dma_mask:
4758 fail_ready_state:
4759
4760         pci_disable_device(pdev);
4761
4762         return -ENODEV;
4763 }
4764 #else
4765 #define megasas_suspend NULL
4766 #define megasas_resume  NULL
4767 #endif
4768
4769 /**
4770  * megasas_detach_one - PCI hot"un"plug entry point
4771  * @pdev:               PCI device structure
4772  */
4773 static void megasas_detach_one(struct pci_dev *pdev)
4774 {
4775         int i;
4776         struct Scsi_Host *host;
4777         struct megasas_instance *instance;
4778         struct fusion_context *fusion;
4779
4780         instance = pci_get_drvdata(pdev);
4781         instance->unload = 1;
4782         host = instance->host;
4783         fusion = instance->ctrl_context;
4784
4785         scsi_remove_host(instance->host);
4786         megasas_flush_cache(instance);
4787         megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
4788
4789         /* cancel the delayed work if this work still in queue*/
4790         if (instance->ev != NULL) {
4791                 struct megasas_aen_event *ev = instance->ev;
4792                 cancel_delayed_work_sync(&ev->hotplug_work);
4793                 instance->ev = NULL;
4794         }
4795
4796         tasklet_kill(&instance->isr_tasklet);
4797
4798         /*
4799          * Take the instance off the instance array. Note that we will not
4800          * decrement the max_index. We let this array be sparse array
4801          */
4802         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
4803                 if (megasas_mgmt_info.instance[i] == instance) {
4804                         megasas_mgmt_info.count--;
4805                         megasas_mgmt_info.instance[i] = NULL;
4806
4807                         break;
4808                 }
4809         }
4810
4811         instance->instancet->disable_intr(instance);
4812
4813         if (instance->msix_vectors)
4814                 for (i = 0 ; i < instance->msix_vectors; i++)
4815                         free_irq(instance->msixentry[i].vector,
4816                                  &instance->irq_context[i]);
4817         else
4818                 free_irq(instance->pdev->irq, &instance->irq_context[0]);
4819         if (instance->msix_vectors)
4820                 pci_disable_msix(instance->pdev);
4821
4822         switch (instance->pdev->device) {
4823         case PCI_DEVICE_ID_LSI_FUSION:
4824         case PCI_DEVICE_ID_LSI_INVADER:
4825         case PCI_DEVICE_ID_LSI_FURY:
4826                 megasas_release_fusion(instance);
4827                 for (i = 0; i < 2 ; i++)
4828                         if (fusion->ld_map[i])
4829                                 dma_free_coherent(&instance->pdev->dev,
4830                                                   fusion->map_sz,
4831                                                   fusion->ld_map[i],
4832                                                   fusion->
4833                                                   ld_map_phys[i]);
4834                 kfree(instance->ctrl_context);
4835                 break;
4836         default:
4837                 megasas_release_mfi(instance);
4838                 pci_free_consistent(pdev, sizeof(u32),
4839                                     instance->producer,
4840                                     instance->producer_h);
4841                 pci_free_consistent(pdev, sizeof(u32),
4842                                     instance->consumer,
4843                                     instance->consumer_h);
4844                 break;
4845         }
4846
4847         if (instance->evt_detail)
4848                 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
4849                                 instance->evt_detail, instance->evt_detail_h);
4850         scsi_host_put(host);
4851
4852         pci_disable_device(pdev);
4853
4854         return;
4855 }
4856
4857 /**
4858  * megasas_shutdown -   Shutdown entry point
4859  * @device:             Generic device structure
4860  */
4861 static void megasas_shutdown(struct pci_dev *pdev)
4862 {
4863         int i;
4864         struct megasas_instance *instance = pci_get_drvdata(pdev);
4865
4866         instance->unload = 1;
4867         megasas_flush_cache(instance);
4868         megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
4869         instance->instancet->disable_intr(instance);
4870         if (instance->msix_vectors)
4871                 for (i = 0 ; i < instance->msix_vectors; i++)
4872                         free_irq(instance->msixentry[i].vector,
4873                                  &instance->irq_context[i]);
4874         else
4875                 free_irq(instance->pdev->irq, &instance->irq_context[0]);
4876         if (instance->msix_vectors)
4877                 pci_disable_msix(instance->pdev);
4878 }
4879
4880 /**
4881  * megasas_mgmt_open -  char node "open" entry point
4882  */
4883 static int megasas_mgmt_open(struct inode *inode, struct file *filep)
4884 {
4885         /*
4886          * Allow only those users with admin rights
4887          */
4888         if (!capable(CAP_SYS_ADMIN))
4889                 return -EACCES;
4890
4891         return 0;
4892 }
4893
4894 /**
4895  * megasas_mgmt_fasync -        Async notifier registration from applications
4896  *
4897  * This function adds the calling process to a driver global queue. When an
4898  * event occurs, SIGIO will be sent to all processes in this queue.
4899  */
4900 static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)
4901 {
4902         int rc;
4903
4904         mutex_lock(&megasas_async_queue_mutex);
4905
4906         rc = fasync_helper(fd, filep, mode, &megasas_async_queue);
4907
4908         mutex_unlock(&megasas_async_queue_mutex);
4909
4910         if (rc >= 0) {
4911                 /* For sanity check when we get ioctl */
4912                 filep->private_data = filep;
4913                 return 0;
4914         }
4915
4916         printk(KERN_DEBUG "megasas: fasync_helper failed [%d]\n", rc);
4917
4918         return rc;
4919 }
4920
4921 /**
4922  * megasas_mgmt_poll -  char node "poll" entry point
4923  * */
4924 static unsigned int megasas_mgmt_poll(struct file *file, poll_table *wait)
4925 {
4926         unsigned int mask;
4927         unsigned long flags;
4928         poll_wait(file, &megasas_poll_wait, wait);
4929         spin_lock_irqsave(&poll_aen_lock, flags);
4930         if (megasas_poll_wait_aen)
4931                 mask =   (POLLIN | POLLRDNORM);
4932         else
4933                 mask = 0;
4934         spin_unlock_irqrestore(&poll_aen_lock, flags);
4935         return mask;
4936 }
4937
4938 /**
4939  * megasas_mgmt_fw_ioctl -      Issues management ioctls to FW
4940  * @instance:                   Adapter soft state
4941  * @argp:                       User's ioctl packet
4942  */
4943 static int
4944 megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
4945                       struct megasas_iocpacket __user * user_ioc,
4946                       struct megasas_iocpacket *ioc)
4947 {
4948         struct megasas_sge32 *kern_sge32;
4949         struct megasas_cmd *cmd;
4950         void *kbuff_arr[MAX_IOCTL_SGE];
4951         dma_addr_t buf_handle = 0;
4952         int error = 0, i;
4953         void *sense = NULL;
4954         dma_addr_t sense_handle;
4955         unsigned long *sense_ptr;
4956
4957         memset(kbuff_arr, 0, sizeof(kbuff_arr));
4958
4959         if (ioc->sge_count > MAX_IOCTL_SGE) {
4960                 printk(KERN_DEBUG "megasas: SGE count [%d] >  max limit [%d]\n",
4961                        ioc->sge_count, MAX_IOCTL_SGE);
4962                 return -EINVAL;
4963         }
4964
4965         cmd = megasas_get_cmd(instance);
4966         if (!cmd) {
4967                 printk(KERN_DEBUG "megasas: Failed to get a cmd packet\n");
4968                 return -ENOMEM;
4969         }
4970
4971         /*
4972          * User's IOCTL packet has 2 frames (maximum). Copy those two
4973          * frames into our cmd's frames. cmd->frame's context will get
4974          * overwritten when we copy from user's frames. So set that value
4975          * alone separately
4976          */
4977         memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE);
4978         cmd->frame->hdr.context = cpu_to_le32(cmd->index);
4979         cmd->frame->hdr.pad_0 = 0;
4980         cmd->frame->hdr.flags &= cpu_to_le16(~(MFI_FRAME_IEEE |
4981                                                MFI_FRAME_SGL64 |
4982                                                MFI_FRAME_SENSE64));
4983
4984         /*
4985          * The management interface between applications and the fw uses
4986          * MFI frames. E.g, RAID configuration changes, LD property changes
4987          * etc are accomplishes through different kinds of MFI frames. The
4988          * driver needs to care only about substituting user buffers with
4989          * kernel buffers in SGLs. The location of SGL is embedded in the
4990          * struct iocpacket itself.
4991          */
4992         kern_sge32 = (struct megasas_sge32 *)
4993             ((unsigned long)cmd->frame + ioc->sgl_off);
4994
4995         /*
4996          * For each user buffer, create a mirror buffer and copy in
4997          */
4998         for (i = 0; i < ioc->sge_count; i++) {
4999                 if (!ioc->sgl[i].iov_len)
5000                         continue;
5001
5002                 kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev,
5003                                                     ioc->sgl[i].iov_len,
5004                                                     &buf_handle, GFP_KERNEL);
5005                 if (!kbuff_arr[i]) {
5006                         printk(KERN_DEBUG "megasas: Failed to alloc "
5007                                "kernel SGL buffer for IOCTL \n");
5008                         error = -ENOMEM;
5009                         goto out;
5010                 }
5011
5012                 /*
5013                  * We don't change the dma_coherent_mask, so
5014                  * pci_alloc_consistent only returns 32bit addresses
5015                  */
5016                 kern_sge32[i].phys_addr = cpu_to_le32(buf_handle);
5017                 kern_sge32[i].length = cpu_to_le32(ioc->sgl[i].iov_len);
5018
5019                 /*
5020                  * We created a kernel buffer corresponding to the
5021                  * user buffer. Now copy in from the user buffer
5022                  */
5023                 if (copy_from_user(kbuff_arr[i], ioc->sgl[i].iov_base,
5024                                    (u32) (ioc->sgl[i].iov_len))) {
5025                         error = -EFAULT;
5026                         goto out;
5027                 }
5028         }
5029
5030         if (ioc->sense_len) {
5031                 sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len,
5032                                              &sense_handle, GFP_KERNEL);
5033                 if (!sense) {
5034                         error = -ENOMEM;
5035                         goto out;
5036                 }
5037
5038                 sense_ptr =
5039                 (unsigned long *) ((unsigned long)cmd->frame + ioc->sense_off);
5040                 *sense_ptr = cpu_to_le32(sense_handle);
5041         }
5042
5043         /*
5044          * Set the sync_cmd flag so that the ISR knows not to complete this
5045          * cmd to the SCSI mid-layer
5046          */
5047         cmd->sync_cmd = 1;
5048         megasas_issue_blocked_cmd(instance, cmd);
5049         cmd->sync_cmd = 0;
5050
5051         /*
5052          * copy out the kernel buffers to user buffers
5053          */
5054         for (i = 0; i < ioc->sge_count; i++) {
5055                 if (copy_to_user(ioc->sgl[i].iov_base, kbuff_arr[i],
5056                                  ioc->sgl[i].iov_len)) {
5057                         error = -EFAULT;
5058                         goto out;
5059                 }
5060         }
5061
5062         /*
5063          * copy out the sense
5064          */
5065         if (ioc->sense_len) {
5066                 /*
5067                  * sense_ptr points to the location that has the user
5068                  * sense buffer address
5069                  */
5070                 sense_ptr = (unsigned long *) ((unsigned long)ioc->frame.raw +
5071                                 ioc->sense_off);
5072
5073                 if (copy_to_user((void __user *)((unsigned long)(*sense_ptr)),
5074                                  sense, ioc->sense_len)) {
5075                         printk(KERN_ERR "megasas: Failed to copy out to user "
5076                                         "sense data\n");
5077                         error = -EFAULT;
5078                         goto out;
5079                 }
5080         }
5081
5082         /*
5083          * copy the status codes returned by the fw
5084          */
5085         if (copy_to_user(&user_ioc->frame.hdr.cmd_status,
5086                          &cmd->frame->hdr.cmd_status, sizeof(u8))) {
5087                 printk(KERN_DEBUG "megasas: Error copying out cmd_status\n");
5088                 error = -EFAULT;
5089         }
5090
5091       out:
5092         if (sense) {
5093                 dma_free_coherent(&instance->pdev->dev, ioc->sense_len,
5094                                     sense, sense_handle);
5095         }
5096
5097         for (i = 0; i < ioc->sge_count; i++) {
5098                 if (kbuff_arr[i])
5099                         dma_free_coherent(&instance->pdev->dev,
5100                                           le32_to_cpu(kern_sge32[i].length),
5101                                           kbuff_arr[i],
5102                                           le32_to_cpu(kern_sge32[i].phys_addr));
5103         }
5104
5105         megasas_return_cmd(instance, cmd);
5106         return error;
5107 }
5108
5109 static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
5110 {
5111         struct megasas_iocpacket __user *user_ioc =
5112             (struct megasas_iocpacket __user *)arg;
5113         struct megasas_iocpacket *ioc;
5114         struct megasas_instance *instance;
5115         int error;
5116         int i;
5117         unsigned long flags;
5118         u32 wait_time = MEGASAS_RESET_WAIT_TIME;
5119
5120         ioc = kmalloc(sizeof(*ioc), GFP_KERNEL);
5121         if (!ioc)
5122                 return -ENOMEM;
5123
5124         if (copy_from_user(ioc, user_ioc, sizeof(*ioc))) {
5125                 error = -EFAULT;
5126                 goto out_kfree_ioc;
5127         }
5128
5129         instance = megasas_lookup_instance(ioc->host_no);
5130         if (!instance) {
5131                 error = -ENODEV;
5132                 goto out_kfree_ioc;
5133         }
5134
5135         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
5136                 printk(KERN_ERR "Controller in crit error\n");
5137                 error = -ENODEV;
5138                 goto out_kfree_ioc;
5139         }
5140
5141         if (instance->unload == 1) {
5142                 error = -ENODEV;
5143                 goto out_kfree_ioc;
5144         }
5145
5146         /*
5147          * We will allow only MEGASAS_INT_CMDS number of parallel ioctl cmds
5148          */
5149         if (down_interruptible(&instance->ioctl_sem)) {
5150                 error = -ERESTARTSYS;
5151                 goto out_kfree_ioc;
5152         }
5153
5154         for (i = 0; i < wait_time; i++) {
5155
5156                 spin_lock_irqsave(&instance->hba_lock, flags);
5157                 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
5158                         spin_unlock_irqrestore(&instance->hba_lock, flags);
5159                         break;
5160                 }
5161                 spin_unlock_irqrestore(&instance->hba_lock, flags);
5162
5163                 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
5164                         printk(KERN_NOTICE "megasas: waiting"
5165                                 "for controller reset to finish\n");
5166                 }
5167
5168                 msleep(1000);
5169         }
5170
5171         spin_lock_irqsave(&instance->hba_lock, flags);
5172         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
5173                 spin_unlock_irqrestore(&instance->hba_lock, flags);
5174
5175                 printk(KERN_ERR "megaraid_sas: timed out while"
5176                         "waiting for HBA to recover\n");
5177                 error = -ENODEV;
5178                 goto out_up;
5179         }
5180         spin_unlock_irqrestore(&instance->hba_lock, flags);
5181
5182         error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
5183       out_up:
5184         up(&instance->ioctl_sem);
5185
5186       out_kfree_ioc:
5187         kfree(ioc);
5188         return error;
5189 }
5190
5191 static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
5192 {
5193         struct megasas_instance *instance;
5194         struct megasas_aen aen;
5195         int error;
5196         int i;
5197         unsigned long flags;
5198         u32 wait_time = MEGASAS_RESET_WAIT_TIME;
5199
5200         if (file->private_data != file) {
5201                 printk(KERN_DEBUG "megasas: fasync_helper was not "
5202                        "called first\n");
5203                 return -EINVAL;
5204         }
5205
5206         if (copy_from_user(&aen, (void __user *)arg, sizeof(aen)))
5207                 return -EFAULT;
5208
5209         instance = megasas_lookup_instance(aen.host_no);
5210
5211         if (!instance)
5212                 return -ENODEV;
5213
5214         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
5215                 return -ENODEV;
5216         }
5217
5218         if (instance->unload == 1) {
5219                 return -ENODEV;
5220         }
5221
5222         for (i = 0; i < wait_time; i++) {
5223
5224                 spin_lock_irqsave(&instance->hba_lock, flags);
5225                 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
5226                         spin_unlock_irqrestore(&instance->hba_lock,
5227                                                 flags);
5228                         break;
5229                 }
5230
5231                 spin_unlock_irqrestore(&instance->hba_lock, flags);
5232
5233                 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
5234                         printk(KERN_NOTICE "megasas: waiting for"
5235                                 "controller reset to finish\n");
5236                 }
5237
5238                 msleep(1000);
5239         }
5240
5241         spin_lock_irqsave(&instance->hba_lock, flags);
5242         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
5243                 spin_unlock_irqrestore(&instance->hba_lock, flags);
5244                 printk(KERN_ERR "megaraid_sas: timed out while waiting"
5245                                 "for HBA to recover.\n");
5246                 return -ENODEV;
5247         }
5248         spin_unlock_irqrestore(&instance->hba_lock, flags);
5249
5250         mutex_lock(&instance->aen_mutex);
5251         error = megasas_register_aen(instance, aen.seq_num,
5252                                      aen.class_locale_word);
5253         mutex_unlock(&instance->aen_mutex);
5254         return error;
5255 }
5256
5257 /**
5258  * megasas_mgmt_ioctl - char node ioctl entry point
5259  */
5260 static long
5261 megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
5262 {
5263         switch (cmd) {
5264         case MEGASAS_IOC_FIRMWARE:
5265                 return megasas_mgmt_ioctl_fw(file, arg);
5266
5267         case MEGASAS_IOC_GET_AEN:
5268                 return megasas_mgmt_ioctl_aen(file, arg);
5269         }
5270
5271         return -ENOTTY;
5272 }
5273
5274 #ifdef CONFIG_COMPAT
5275 static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
5276 {
5277         struct compat_megasas_iocpacket __user *cioc =
5278             (struct compat_megasas_iocpacket __user *)arg;
5279         struct megasas_iocpacket __user *ioc =
5280             compat_alloc_user_space(sizeof(struct megasas_iocpacket));
5281         int i;
5282         int error = 0;
5283         compat_uptr_t ptr;
5284
5285         if (clear_user(ioc, sizeof(*ioc)))
5286                 return -EFAULT;
5287
5288         if (copy_in_user(&ioc->host_no, &cioc->host_no, sizeof(u16)) ||
5289             copy_in_user(&ioc->sgl_off, &cioc->sgl_off, sizeof(u32)) ||
5290             copy_in_user(&ioc->sense_off, &cioc->sense_off, sizeof(u32)) ||
5291             copy_in_user(&ioc->sense_len, &cioc->sense_len, sizeof(u32)) ||
5292             copy_in_user(ioc->frame.raw, cioc->frame.raw, 128) ||
5293             copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32)))
5294                 return -EFAULT;
5295
5296         /*
5297          * The sense_ptr is used in megasas_mgmt_fw_ioctl only when
5298          * sense_len is not null, so prepare the 64bit value under
5299          * the same condition.
5300          */
5301         if (ioc->sense_len) {
5302                 void __user **sense_ioc_ptr =
5303                         (void __user **)(ioc->frame.raw + ioc->sense_off);
5304                 compat_uptr_t *sense_cioc_ptr =
5305                         (compat_uptr_t *)(cioc->frame.raw + cioc->sense_off);
5306                 if (get_user(ptr, sense_cioc_ptr) ||
5307                     put_user(compat_ptr(ptr), sense_ioc_ptr))
5308                         return -EFAULT;
5309         }
5310
5311         for (i = 0; i < MAX_IOCTL_SGE; i++) {
5312                 if (get_user(ptr, &cioc->sgl[i].iov_base) ||
5313                     put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) ||
5314                     copy_in_user(&ioc->sgl[i].iov_len,
5315                                  &cioc->sgl[i].iov_len, sizeof(compat_size_t)))
5316                         return -EFAULT;
5317         }
5318
5319         error = megasas_mgmt_ioctl_fw(file, (unsigned long)ioc);
5320
5321         if (copy_in_user(&cioc->frame.hdr.cmd_status,
5322                          &ioc->frame.hdr.cmd_status, sizeof(u8))) {
5323                 printk(KERN_DEBUG "megasas: error copy_in_user cmd_status\n");
5324                 return -EFAULT;
5325         }
5326         return error;
5327 }
5328
5329 static long
5330 megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd,
5331                           unsigned long arg)
5332 {
5333         switch (cmd) {
5334         case MEGASAS_IOC_FIRMWARE32:
5335                 return megasas_mgmt_compat_ioctl_fw(file, arg);
5336         case MEGASAS_IOC_GET_AEN:
5337                 return megasas_mgmt_ioctl_aen(file, arg);
5338         }
5339
5340         return -ENOTTY;
5341 }
5342 #endif
5343
5344 /*
5345  * File operations structure for management interface
5346  */
5347 static const struct file_operations megasas_mgmt_fops = {
5348         .owner = THIS_MODULE,
5349         .open = megasas_mgmt_open,
5350         .fasync = megasas_mgmt_fasync,
5351         .unlocked_ioctl = megasas_mgmt_ioctl,
5352         .poll = megasas_mgmt_poll,
5353 #ifdef CONFIG_COMPAT
5354         .compat_ioctl = megasas_mgmt_compat_ioctl,
5355 #endif
5356         .llseek = noop_llseek,
5357 };
5358
5359 /*
5360  * PCI hotplug support registration structure
5361  */
5362 static struct pci_driver megasas_pci_driver = {
5363
5364         .name = "megaraid_sas",
5365         .id_table = megasas_pci_table,
5366         .probe = megasas_probe_one,
5367         .remove = megasas_detach_one,
5368         .suspend = megasas_suspend,
5369         .resume = megasas_resume,
5370         .shutdown = megasas_shutdown,
5371 };
5372
5373 /*
5374  * Sysfs driver attributes
5375  */
5376 static ssize_t megasas_sysfs_show_version(struct device_driver *dd, char *buf)
5377 {
5378         return snprintf(buf, strlen(MEGASAS_VERSION) + 2, "%s\n",
5379                         MEGASAS_VERSION);
5380 }
5381
5382 static DRIVER_ATTR(version, S_IRUGO, megasas_sysfs_show_version, NULL);
5383
5384 static ssize_t
5385 megasas_sysfs_show_release_date(struct device_driver *dd, char *buf)
5386 {
5387         return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, "%s\n",
5388                         MEGASAS_RELDATE);
5389 }
5390
5391 static DRIVER_ATTR(release_date, S_IRUGO, megasas_sysfs_show_release_date,
5392                    NULL);
5393
5394 static ssize_t
5395 megasas_sysfs_show_support_poll_for_event(struct device_driver *dd, char *buf)
5396 {
5397         return sprintf(buf, "%u\n", support_poll_for_event);
5398 }
5399
5400 static DRIVER_ATTR(support_poll_for_event, S_IRUGO,
5401                         megasas_sysfs_show_support_poll_for_event, NULL);
5402
5403  static ssize_t
5404 megasas_sysfs_show_support_device_change(struct device_driver *dd, char *buf)
5405 {
5406         return sprintf(buf, "%u\n", support_device_change);
5407 }
5408
5409 static DRIVER_ATTR(support_device_change, S_IRUGO,
5410                         megasas_sysfs_show_support_device_change, NULL);
5411
5412 static ssize_t
5413 megasas_sysfs_show_dbg_lvl(struct device_driver *dd, char *buf)
5414 {
5415         return sprintf(buf, "%u\n", megasas_dbg_lvl);
5416 }
5417
5418 static ssize_t
5419 megasas_sysfs_set_dbg_lvl(struct device_driver *dd, const char *buf, size_t count)
5420 {
5421         int retval = count;
5422         if(sscanf(buf,"%u",&megasas_dbg_lvl)<1){
5423                 printk(KERN_ERR "megasas: could not set dbg_lvl\n");
5424                 retval = -EINVAL;
5425         }
5426         return retval;
5427 }
5428
5429 static DRIVER_ATTR(dbg_lvl, S_IRUGO|S_IWUSR, megasas_sysfs_show_dbg_lvl,
5430                 megasas_sysfs_set_dbg_lvl);
5431
5432 static void
5433 megasas_aen_polling(struct work_struct *work)
5434 {
5435         struct megasas_aen_event *ev =
5436                 container_of(work, struct megasas_aen_event, hotplug_work.work);
5437         struct megasas_instance *instance = ev->instance;
5438         union megasas_evt_class_locale class_locale;
5439         struct  Scsi_Host *host;
5440         struct  scsi_device *sdev1;
5441         u16     pd_index = 0;
5442         u16     ld_index = 0;
5443         int     i, j, doscan = 0;
5444         u32 seq_num;
5445         int error;
5446
5447         if (!instance) {
5448                 printk(KERN_ERR "invalid instance!\n");
5449                 kfree(ev);
5450                 return;
5451         }
5452         instance->ev = NULL;
5453         host = instance->host;
5454         if (instance->evt_detail) {
5455
5456                 switch (le32_to_cpu(instance->evt_detail->code)) {
5457                 case MR_EVT_PD_INSERTED:
5458                         if (megasas_get_pd_list(instance) == 0) {
5459                         for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
5460                                 for (j = 0;
5461                                 j < MEGASAS_MAX_DEV_PER_CHANNEL;
5462                                 j++) {
5463
5464                                 pd_index =
5465                                 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
5466
5467                                 sdev1 =
5468                                 scsi_device_lookup(host, i, j, 0);
5469
5470                                 if (instance->pd_list[pd_index].driveState
5471                                                 == MR_PD_STATE_SYSTEM) {
5472                                                 if (!sdev1) {
5473                                                 scsi_add_device(host, i, j, 0);
5474                                                 }
5475
5476                                         if (sdev1)
5477                                                 scsi_device_put(sdev1);
5478                                         }
5479                                 }
5480                         }
5481                         }
5482                         doscan = 0;
5483                         break;
5484
5485                 case MR_EVT_PD_REMOVED:
5486                         if (megasas_get_pd_list(instance) == 0) {
5487                         for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
5488                                 for (j = 0;
5489                                 j < MEGASAS_MAX_DEV_PER_CHANNEL;
5490                                 j++) {
5491
5492                                 pd_index =
5493                                 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
5494
5495                                 sdev1 =
5496                                 scsi_device_lookup(host, i, j, 0);
5497
5498                                 if (instance->pd_list[pd_index].driveState
5499                                         == MR_PD_STATE_SYSTEM) {
5500                                         if (sdev1) {
5501                                                 scsi_device_put(sdev1);
5502                                         }
5503                                 } else {
5504                                         if (sdev1) {
5505                                                 scsi_remove_device(sdev1);
5506                                                 scsi_device_put(sdev1);
5507                                         }
5508                                 }
5509                                 }
5510                         }
5511                         }
5512                         doscan = 0;
5513                         break;
5514
5515                 case MR_EVT_LD_OFFLINE:
5516                 case MR_EVT_CFG_CLEARED:
5517                 case MR_EVT_LD_DELETED:
5518                         if (megasas_ld_list_query(instance,
5519                                         MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
5520                                 megasas_get_ld_list(instance);
5521                         for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
5522                                 for (j = 0;
5523                                 j < MEGASAS_MAX_DEV_PER_CHANNEL;
5524                                 j++) {
5525
5526                                 ld_index =
5527                                 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
5528
5529                                 sdev1 = scsi_device_lookup(host,
5530                                         MEGASAS_MAX_PD_CHANNELS + i,
5531                                         j,
5532                                         0);
5533
5534                                 if (instance->ld_ids[ld_index] != 0xff) {
5535                                         if (sdev1) {
5536                                                 scsi_device_put(sdev1);
5537                                         }
5538                                 } else {
5539                                         if (sdev1) {
5540                                                 scsi_remove_device(sdev1);
5541                                                 scsi_device_put(sdev1);
5542                                         }
5543                                 }
5544                                 }
5545                         }
5546                         doscan = 0;
5547                         break;
5548                 case MR_EVT_LD_CREATED:
5549                         if (megasas_ld_list_query(instance,
5550                                         MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
5551                                 megasas_get_ld_list(instance);
5552                         for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
5553                                 for (j = 0;
5554                                         j < MEGASAS_MAX_DEV_PER_CHANNEL;
5555                                         j++) {
5556                                         ld_index =
5557                                         (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
5558
5559                                         sdev1 = scsi_device_lookup(host,
5560                                                 MEGASAS_MAX_PD_CHANNELS + i,
5561                                                 j, 0);
5562
5563                                         if (instance->ld_ids[ld_index] !=
5564                                                                 0xff) {
5565                                                 if (!sdev1) {
5566                                                         scsi_add_device(host,
5567                                                 MEGASAS_MAX_PD_CHANNELS + i,
5568                                                                 j, 0);
5569                                                 }
5570                                         }
5571                                         if (sdev1) {
5572                                                 scsi_device_put(sdev1);
5573                                         }
5574                                 }
5575                         }
5576                         doscan = 0;
5577                         break;
5578                 case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
5579                 case MR_EVT_FOREIGN_CFG_IMPORTED:
5580                 case MR_EVT_LD_STATE_CHANGE:
5581                         doscan = 1;
5582                         break;
5583                 default:
5584                         doscan = 0;
5585                         break;
5586                 }
5587         } else {
5588                 printk(KERN_ERR "invalid evt_detail!\n");
5589                 kfree(ev);
5590                 return;
5591         }
5592
5593         if (doscan) {
5594                 printk(KERN_INFO "scanning ...\n");
5595                 megasas_get_pd_list(instance);
5596                 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
5597                         for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
5598                                 pd_index = i*MEGASAS_MAX_DEV_PER_CHANNEL + j;
5599                                 sdev1 = scsi_device_lookup(host, i, j, 0);
5600                                 if (instance->pd_list[pd_index].driveState ==
5601                                                         MR_PD_STATE_SYSTEM) {
5602                                         if (!sdev1) {
5603                                                 scsi_add_device(host, i, j, 0);
5604                                         }
5605                                         if (sdev1)
5606                                                 scsi_device_put(sdev1);
5607                                 } else {
5608                                         if (sdev1) {
5609                                                 scsi_remove_device(sdev1);
5610                                                 scsi_device_put(sdev1);
5611                                         }
5612                                 }
5613                         }
5614                 }
5615
5616                 if (megasas_ld_list_query(instance,
5617                                           MR_LD_QUERY_TYPE_EXPOSED_TO_HOST))
5618                         megasas_get_ld_list(instance);
5619                 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
5620                         for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
5621                                 ld_index =
5622                                 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
5623
5624                                 sdev1 = scsi_device_lookup(host,
5625                                         MEGASAS_MAX_PD_CHANNELS + i, j, 0);
5626                                 if (instance->ld_ids[ld_index] != 0xff) {
5627                                         if (!sdev1) {
5628                                                 scsi_add_device(host,
5629                                                 MEGASAS_MAX_PD_CHANNELS + i,
5630                                                                 j, 0);
5631                                         } else {
5632                                                 scsi_device_put(sdev1);
5633                                         }
5634                                 } else {
5635                                         if (sdev1) {
5636                                                 scsi_remove_device(sdev1);
5637                                                 scsi_device_put(sdev1);
5638                                         }
5639                                 }
5640                         }
5641                 }
5642         }
5643
5644         if ( instance->aen_cmd != NULL ) {
5645                 kfree(ev);
5646                 return ;
5647         }
5648
5649         seq_num = le32_to_cpu(instance->evt_detail->seq_num) + 1;
5650
5651         /* Register AEN with FW for latest sequence number plus 1 */
5652         class_locale.members.reserved = 0;
5653         class_locale.members.locale = MR_EVT_LOCALE_ALL;
5654         class_locale.members.class = MR_EVT_CLASS_DEBUG;
5655         mutex_lock(&instance->aen_mutex);
5656         error = megasas_register_aen(instance, seq_num,
5657                                         class_locale.word);
5658         mutex_unlock(&instance->aen_mutex);
5659
5660         if (error)
5661                 printk(KERN_ERR "register aen failed error %x\n", error);
5662
5663         kfree(ev);
5664 }
5665
5666 /**
5667  * megasas_init - Driver load entry point
5668  */
5669 static int __init megasas_init(void)
5670 {
5671         int rval;
5672
5673         /*
5674          * Announce driver version and other information
5675          */
5676         printk(KERN_INFO "megasas: %s %s\n", MEGASAS_VERSION,
5677                MEGASAS_EXT_VERSION);
5678
5679         spin_lock_init(&poll_aen_lock);
5680
5681         support_poll_for_event = 2;
5682         support_device_change = 1;
5683
5684         memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info));
5685
5686         /*
5687          * Register character device node
5688          */
5689         rval = register_chrdev(0, "megaraid_sas_ioctl", &megasas_mgmt_fops);
5690
5691         if (rval < 0) {
5692                 printk(KERN_DEBUG "megasas: failed to open device node\n");
5693                 return rval;
5694         }
5695
5696         megasas_mgmt_majorno = rval;
5697
5698         /*
5699          * Register ourselves as PCI hotplug module
5700          */
5701         rval = pci_register_driver(&megasas_pci_driver);
5702
5703         if (rval) {
5704                 printk(KERN_DEBUG "megasas: PCI hotplug regisration failed \n");
5705                 goto err_pcidrv;
5706         }
5707
5708         rval = driver_create_file(&megasas_pci_driver.driver,
5709                                   &driver_attr_version);
5710         if (rval)
5711                 goto err_dcf_attr_ver;
5712         rval = driver_create_file(&megasas_pci_driver.driver,
5713                                   &driver_attr_release_date);
5714         if (rval)
5715                 goto err_dcf_rel_date;
5716
5717         rval = driver_create_file(&megasas_pci_driver.driver,
5718                                 &driver_attr_support_poll_for_event);
5719         if (rval)
5720                 goto err_dcf_support_poll_for_event;
5721
5722         rval = driver_create_file(&megasas_pci_driver.driver,
5723                                   &driver_attr_dbg_lvl);
5724         if (rval)
5725                 goto err_dcf_dbg_lvl;
5726         rval = driver_create_file(&megasas_pci_driver.driver,
5727                                 &driver_attr_support_device_change);
5728         if (rval)
5729                 goto err_dcf_support_device_change;
5730
5731         return rval;
5732
5733 err_dcf_support_device_change:
5734         driver_remove_file(&megasas_pci_driver.driver,
5735                            &driver_attr_dbg_lvl);
5736 err_dcf_dbg_lvl:
5737         driver_remove_file(&megasas_pci_driver.driver,
5738                         &driver_attr_support_poll_for_event);
5739
5740 err_dcf_support_poll_for_event:
5741         driver_remove_file(&megasas_pci_driver.driver,
5742                            &driver_attr_release_date);
5743
5744 err_dcf_rel_date:
5745         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
5746 err_dcf_attr_ver:
5747         pci_unregister_driver(&megasas_pci_driver);
5748 err_pcidrv:
5749         unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
5750         return rval;
5751 }
5752
5753 /**
5754  * megasas_exit - Driver unload entry point
5755  */
5756 static void __exit megasas_exit(void)
5757 {
5758         driver_remove_file(&megasas_pci_driver.driver,
5759                            &driver_attr_dbg_lvl);
5760         driver_remove_file(&megasas_pci_driver.driver,
5761                         &driver_attr_support_poll_for_event);
5762         driver_remove_file(&megasas_pci_driver.driver,
5763                         &driver_attr_support_device_change);
5764         driver_remove_file(&megasas_pci_driver.driver,
5765                            &driver_attr_release_date);
5766         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
5767
5768         pci_unregister_driver(&megasas_pci_driver);
5769         unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
5770 }
5771
5772 module_init(megasas_init);
5773 module_exit(megasas_exit);