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