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.506.00.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         .no_write_same = 1,
2103 };
2104
2105 /**
2106  * megasas_complete_int_cmd -   Completes an internal command
2107  * @instance:                   Adapter soft state
2108  * @cmd:                        Command to be completed
2109  *
2110  * The megasas_issue_blocked_cmd() function waits for a command to complete
2111  * after it issues a command. This function wakes up that waiting routine by
2112  * calling wake_up() on the wait queue.
2113  */
2114 static void
2115 megasas_complete_int_cmd(struct megasas_instance *instance,
2116                          struct megasas_cmd *cmd)
2117 {
2118         cmd->cmd_status = cmd->frame->io.cmd_status;
2119
2120         if (cmd->cmd_status == ENODATA) {
2121                 cmd->cmd_status = 0;
2122         }
2123         wake_up(&instance->int_cmd_wait_q);
2124 }
2125
2126 /**
2127  * megasas_complete_abort -     Completes aborting a command
2128  * @instance:                   Adapter soft state
2129  * @cmd:                        Cmd that was issued to abort another cmd
2130  *
2131  * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
2132  * after it issues an abort on a previously issued command. This function
2133  * wakes up all functions waiting on the same wait queue.
2134  */
2135 static void
2136 megasas_complete_abort(struct megasas_instance *instance,
2137                        struct megasas_cmd *cmd)
2138 {
2139         if (cmd->sync_cmd) {
2140                 cmd->sync_cmd = 0;
2141                 cmd->cmd_status = 0;
2142                 wake_up(&instance->abort_cmd_wait_q);
2143         }
2144
2145         return;
2146 }
2147
2148 /**
2149  * megasas_complete_cmd -       Completes a command
2150  * @instance:                   Adapter soft state
2151  * @cmd:                        Command to be completed
2152  * @alt_status:                 If non-zero, use this value as status to
2153  *                              SCSI mid-layer instead of the value returned
2154  *                              by the FW. This should be used if caller wants
2155  *                              an alternate status (as in the case of aborted
2156  *                              commands)
2157  */
2158 void
2159 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
2160                      u8 alt_status)
2161 {
2162         int exception = 0;
2163         struct megasas_header *hdr = &cmd->frame->hdr;
2164         unsigned long flags;
2165         struct fusion_context *fusion = instance->ctrl_context;
2166
2167         /* flag for the retry reset */
2168         cmd->retry_for_fw_reset = 0;
2169
2170         if (cmd->scmd)
2171                 cmd->scmd->SCp.ptr = NULL;
2172
2173         switch (hdr->cmd) {
2174         case MFI_CMD_INVALID:
2175                 /* Some older 1068 controller FW may keep a pended
2176                    MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel
2177                    when booting the kdump kernel.  Ignore this command to
2178                    prevent a kernel panic on shutdown of the kdump kernel. */
2179                 printk(KERN_WARNING "megaraid_sas: MFI_CMD_INVALID command "
2180                        "completed.\n");
2181                 printk(KERN_WARNING "megaraid_sas: If you have a controller "
2182                        "other than PERC5, please upgrade your firmware.\n");
2183                 break;
2184         case MFI_CMD_PD_SCSI_IO:
2185         case MFI_CMD_LD_SCSI_IO:
2186
2187                 /*
2188                  * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
2189                  * issued either through an IO path or an IOCTL path. If it
2190                  * was via IOCTL, we will send it to internal completion.
2191                  */
2192                 if (cmd->sync_cmd) {
2193                         cmd->sync_cmd = 0;
2194                         megasas_complete_int_cmd(instance, cmd);
2195                         break;
2196                 }
2197
2198         case MFI_CMD_LD_READ:
2199         case MFI_CMD_LD_WRITE:
2200
2201                 if (alt_status) {
2202                         cmd->scmd->result = alt_status << 16;
2203                         exception = 1;
2204                 }
2205
2206                 if (exception) {
2207
2208                         atomic_dec(&instance->fw_outstanding);
2209
2210                         scsi_dma_unmap(cmd->scmd);
2211                         cmd->scmd->scsi_done(cmd->scmd);
2212                         megasas_return_cmd(instance, cmd);
2213
2214                         break;
2215                 }
2216
2217                 switch (hdr->cmd_status) {
2218
2219                 case MFI_STAT_OK:
2220                         cmd->scmd->result = DID_OK << 16;
2221                         break;
2222
2223                 case MFI_STAT_SCSI_IO_FAILED:
2224                 case MFI_STAT_LD_INIT_IN_PROGRESS:
2225                         cmd->scmd->result =
2226                             (DID_ERROR << 16) | hdr->scsi_status;
2227                         break;
2228
2229                 case MFI_STAT_SCSI_DONE_WITH_ERROR:
2230
2231                         cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status;
2232
2233                         if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {
2234                                 memset(cmd->scmd->sense_buffer, 0,
2235                                        SCSI_SENSE_BUFFERSIZE);
2236                                 memcpy(cmd->scmd->sense_buffer, cmd->sense,
2237                                        hdr->sense_len);
2238
2239                                 cmd->scmd->result |= DRIVER_SENSE << 24;
2240                         }
2241
2242                         break;
2243
2244                 case MFI_STAT_LD_OFFLINE:
2245                 case MFI_STAT_DEVICE_NOT_FOUND:
2246                         cmd->scmd->result = DID_BAD_TARGET << 16;
2247                         break;
2248
2249                 default:
2250                         printk(KERN_DEBUG "megasas: MFI FW status %#x\n",
2251                                hdr->cmd_status);
2252                         cmd->scmd->result = DID_ERROR << 16;
2253                         break;
2254                 }
2255
2256                 atomic_dec(&instance->fw_outstanding);
2257
2258                 scsi_dma_unmap(cmd->scmd);
2259                 cmd->scmd->scsi_done(cmd->scmd);
2260                 megasas_return_cmd(instance, cmd);
2261
2262                 break;
2263
2264         case MFI_CMD_SMP:
2265         case MFI_CMD_STP:
2266         case MFI_CMD_DCMD:
2267                 /* Check for LD map update */
2268                 if ((cmd->frame->dcmd.opcode == MR_DCMD_LD_MAP_GET_INFO) &&
2269                     (cmd->frame->dcmd.mbox.b[1] == 1)) {
2270                         spin_lock_irqsave(instance->host->host_lock, flags);
2271                         if (cmd->frame->hdr.cmd_status != 0) {
2272                                 if (cmd->frame->hdr.cmd_status !=
2273                                     MFI_STAT_NOT_FOUND)
2274                                         printk(KERN_WARNING "megasas: map sync"
2275                                                "failed, status = 0x%x.\n",
2276                                                cmd->frame->hdr.cmd_status);
2277                                 else {
2278                                         megasas_return_cmd(instance, cmd);
2279                                         spin_unlock_irqrestore(
2280                                                 instance->host->host_lock,
2281                                                 flags);
2282                                         break;
2283                                 }
2284                         } else
2285                                 instance->map_id++;
2286                         megasas_return_cmd(instance, cmd);
2287                         if (MR_ValidateMapInfo(
2288                                     fusion->ld_map[(instance->map_id & 1)],
2289                                     fusion->load_balance_info))
2290                                 fusion->fast_path_io = 1;
2291                         else
2292                                 fusion->fast_path_io = 0;
2293                         megasas_sync_map_info(instance);
2294                         spin_unlock_irqrestore(instance->host->host_lock,
2295                                                flags);
2296                         break;
2297                 }
2298                 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
2299                         cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET) {
2300                         spin_lock_irqsave(&poll_aen_lock, flags);
2301                         megasas_poll_wait_aen = 0;
2302                         spin_unlock_irqrestore(&poll_aen_lock, flags);
2303                 }
2304
2305                 /*
2306                  * See if got an event notification
2307                  */
2308                 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_WAIT)
2309                         megasas_service_aen(instance, cmd);
2310                 else
2311                         megasas_complete_int_cmd(instance, cmd);
2312
2313                 break;
2314
2315         case MFI_CMD_ABORT:
2316                 /*
2317                  * Cmd issued to abort another cmd returned
2318                  */
2319                 megasas_complete_abort(instance, cmd);
2320                 break;
2321
2322         default:
2323                 printk("megasas: Unknown command completed! [0x%X]\n",
2324                        hdr->cmd);
2325                 break;
2326         }
2327 }
2328
2329 /**
2330  * megasas_issue_pending_cmds_again -   issue all pending cmds
2331  *                                      in FW again because of the fw reset
2332  * @instance:                           Adapter soft state
2333  */
2334 static inline void
2335 megasas_issue_pending_cmds_again(struct megasas_instance *instance)
2336 {
2337         struct megasas_cmd *cmd;
2338         struct list_head clist_local;
2339         union megasas_evt_class_locale class_locale;
2340         unsigned long flags;
2341         u32 seq_num;
2342
2343         INIT_LIST_HEAD(&clist_local);
2344         spin_lock_irqsave(&instance->hba_lock, flags);
2345         list_splice_init(&instance->internal_reset_pending_q, &clist_local);
2346         spin_unlock_irqrestore(&instance->hba_lock, flags);
2347
2348         while (!list_empty(&clist_local)) {
2349                 cmd     = list_entry((&clist_local)->next,
2350                                         struct megasas_cmd, list);
2351                 list_del_init(&cmd->list);
2352
2353                 if (cmd->sync_cmd || cmd->scmd) {
2354                         printk(KERN_NOTICE "megaraid_sas: command %p, %p:%d"
2355                                 "detected to be pending while HBA reset.\n",
2356                                         cmd, cmd->scmd, cmd->sync_cmd);
2357
2358                         cmd->retry_for_fw_reset++;
2359
2360                         if (cmd->retry_for_fw_reset == 3) {
2361                                 printk(KERN_NOTICE "megaraid_sas: cmd %p, %p:%d"
2362                                         "was tried multiple times during reset."
2363                                         "Shutting down the HBA\n",
2364                                         cmd, cmd->scmd, cmd->sync_cmd);
2365                                 megaraid_sas_kill_hba(instance);
2366
2367                                 instance->adprecovery =
2368                                                 MEGASAS_HW_CRITICAL_ERROR;
2369                                 return;
2370                         }
2371                 }
2372
2373                 if (cmd->sync_cmd == 1) {
2374                         if (cmd->scmd) {
2375                                 printk(KERN_NOTICE "megaraid_sas: unexpected"
2376                                         "cmd attached to internal command!\n");
2377                         }
2378                         printk(KERN_NOTICE "megasas: %p synchronous cmd"
2379                                                 "on the internal reset queue,"
2380                                                 "issue it again.\n", cmd);
2381                         cmd->cmd_status = ENODATA;
2382                         instance->instancet->fire_cmd(instance,
2383                                                         cmd->frame_phys_addr ,
2384                                                         0, instance->reg_set);
2385                 } else if (cmd->scmd) {
2386                         printk(KERN_NOTICE "megasas: %p scsi cmd [%02x]"
2387                         "detected on the internal queue, issue again.\n",
2388                         cmd, cmd->scmd->cmnd[0]);
2389
2390                         atomic_inc(&instance->fw_outstanding);
2391                         instance->instancet->fire_cmd(instance,
2392                                         cmd->frame_phys_addr,
2393                                         cmd->frame_count-1, instance->reg_set);
2394                 } else {
2395                         printk(KERN_NOTICE "megasas: %p unexpected cmd on the"
2396                                 "internal reset defer list while re-issue!!\n",
2397                                 cmd);
2398                 }
2399         }
2400
2401         if (instance->aen_cmd) {
2402                 printk(KERN_NOTICE "megaraid_sas: aen_cmd in def process\n");
2403                 megasas_return_cmd(instance, instance->aen_cmd);
2404
2405                 instance->aen_cmd       = NULL;
2406         }
2407
2408         /*
2409         * Initiate AEN (Asynchronous Event Notification)
2410         */
2411         seq_num = instance->last_seq_num;
2412         class_locale.members.reserved = 0;
2413         class_locale.members.locale = MR_EVT_LOCALE_ALL;
2414         class_locale.members.class = MR_EVT_CLASS_DEBUG;
2415
2416         megasas_register_aen(instance, seq_num, class_locale.word);
2417 }
2418
2419 /**
2420  * Move the internal reset pending commands to a deferred queue.
2421  *
2422  * We move the commands pending at internal reset time to a
2423  * pending queue. This queue would be flushed after successful
2424  * completion of the internal reset sequence. if the internal reset
2425  * did not complete in time, the kernel reset handler would flush
2426  * these commands.
2427  **/
2428 static void
2429 megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
2430 {
2431         struct megasas_cmd *cmd;
2432         int i;
2433         u32 max_cmd = instance->max_fw_cmds;
2434         u32 defer_index;
2435         unsigned long flags;
2436
2437         defer_index     = 0;
2438         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
2439         for (i = 0; i < max_cmd; i++) {
2440                 cmd = instance->cmd_list[i];
2441                 if (cmd->sync_cmd == 1 || cmd->scmd) {
2442                         printk(KERN_NOTICE "megasas: moving cmd[%d]:%p:%d:%p"
2443                                         "on the defer queue as internal\n",
2444                                 defer_index, cmd, cmd->sync_cmd, cmd->scmd);
2445
2446                         if (!list_empty(&cmd->list)) {
2447                                 printk(KERN_NOTICE "megaraid_sas: ERROR while"
2448                                         " moving this cmd:%p, %d %p, it was"
2449                                         "discovered on some list?\n",
2450                                         cmd, cmd->sync_cmd, cmd->scmd);
2451
2452                                 list_del_init(&cmd->list);
2453                         }
2454                         defer_index++;
2455                         list_add_tail(&cmd->list,
2456                                 &instance->internal_reset_pending_q);
2457                 }
2458         }
2459         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
2460 }
2461
2462
2463 static void
2464 process_fw_state_change_wq(struct work_struct *work)
2465 {
2466         struct megasas_instance *instance =
2467                 container_of(work, struct megasas_instance, work_init);
2468         u32 wait;
2469         unsigned long flags;
2470
2471         if (instance->adprecovery != MEGASAS_ADPRESET_SM_INFAULT) {
2472                 printk(KERN_NOTICE "megaraid_sas: error, recovery st %x \n",
2473                                 instance->adprecovery);
2474                 return ;
2475         }
2476
2477         if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) {
2478                 printk(KERN_NOTICE "megaraid_sas: FW detected to be in fault"
2479                                         "state, restarting it...\n");
2480
2481                 instance->instancet->disable_intr(instance->reg_set);
2482                 atomic_set(&instance->fw_outstanding, 0);
2483
2484                 atomic_set(&instance->fw_reset_no_pci_access, 1);
2485                 instance->instancet->adp_reset(instance, instance->reg_set);
2486                 atomic_set(&instance->fw_reset_no_pci_access, 0 );
2487
2488                 printk(KERN_NOTICE "megaraid_sas: FW restarted successfully,"
2489                                         "initiating next stage...\n");
2490
2491                 printk(KERN_NOTICE "megaraid_sas: HBA recovery state machine,"
2492                                         "state 2 starting...\n");
2493
2494                 /*waitting for about 20 second before start the second init*/
2495                 for (wait = 0; wait < 30; wait++) {
2496                         msleep(1000);
2497                 }
2498
2499                 if (megasas_transition_to_ready(instance, 1)) {
2500                         printk(KERN_NOTICE "megaraid_sas:adapter not ready\n");
2501
2502                         megaraid_sas_kill_hba(instance);
2503                         instance->adprecovery   = MEGASAS_HW_CRITICAL_ERROR;
2504                         return ;
2505                 }
2506
2507                 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
2508                         (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
2509                         (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)
2510                         ) {
2511                         *instance->consumer = *instance->producer;
2512                 } else {
2513                         *instance->consumer = 0;
2514                         *instance->producer = 0;
2515                 }
2516
2517                 megasas_issue_init_mfi(instance);
2518
2519                 spin_lock_irqsave(&instance->hba_lock, flags);
2520                 instance->adprecovery   = MEGASAS_HBA_OPERATIONAL;
2521                 spin_unlock_irqrestore(&instance->hba_lock, flags);
2522                 instance->instancet->enable_intr(instance->reg_set);
2523
2524                 megasas_issue_pending_cmds_again(instance);
2525                 instance->issuepend_done = 1;
2526         }
2527         return ;
2528 }
2529
2530 /**
2531  * megasas_deplete_reply_queue -        Processes all completed commands
2532  * @instance:                           Adapter soft state
2533  * @alt_status:                         Alternate status to be returned to
2534  *                                      SCSI mid-layer instead of the status
2535  *                                      returned by the FW
2536  * Note: this must be called with hba lock held
2537  */
2538 static int
2539 megasas_deplete_reply_queue(struct megasas_instance *instance,
2540                                         u8 alt_status)
2541 {
2542         u32 mfiStatus;
2543         u32 fw_state;
2544
2545         if ((mfiStatus = instance->instancet->check_reset(instance,
2546                                         instance->reg_set)) == 1) {
2547                 return IRQ_HANDLED;
2548         }
2549
2550         if ((mfiStatus = instance->instancet->clear_intr(
2551                                                 instance->reg_set)
2552                                                 ) == 0) {
2553                 /* Hardware may not set outbound_intr_status in MSI-X mode */
2554                 if (!instance->msix_vectors)
2555                         return IRQ_NONE;
2556         }
2557
2558         instance->mfiStatus = mfiStatus;
2559
2560         if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) {
2561                 fw_state = instance->instancet->read_fw_status_reg(
2562                                 instance->reg_set) & MFI_STATE_MASK;
2563
2564                 if (fw_state != MFI_STATE_FAULT) {
2565                         printk(KERN_NOTICE "megaraid_sas: fw state:%x\n",
2566                                                 fw_state);
2567                 }
2568
2569                 if ((fw_state == MFI_STATE_FAULT) &&
2570                                 (instance->disableOnlineCtrlReset == 0)) {
2571                         printk(KERN_NOTICE "megaraid_sas: wait adp restart\n");
2572
2573                         if ((instance->pdev->device ==
2574                                         PCI_DEVICE_ID_LSI_SAS1064R) ||
2575                                 (instance->pdev->device ==
2576                                         PCI_DEVICE_ID_DELL_PERC5) ||
2577                                 (instance->pdev->device ==
2578                                         PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
2579
2580                                 *instance->consumer =
2581                                         MEGASAS_ADPRESET_INPROG_SIGN;
2582                         }
2583
2584
2585                         instance->instancet->disable_intr(instance->reg_set);
2586                         instance->adprecovery   = MEGASAS_ADPRESET_SM_INFAULT;
2587                         instance->issuepend_done = 0;
2588
2589                         atomic_set(&instance->fw_outstanding, 0);
2590                         megasas_internal_reset_defer_cmds(instance);
2591
2592                         printk(KERN_NOTICE "megasas: fwState=%x, stage:%d\n",
2593                                         fw_state, instance->adprecovery);
2594
2595                         schedule_work(&instance->work_init);
2596                         return IRQ_HANDLED;
2597
2598                 } else {
2599                         printk(KERN_NOTICE "megasas: fwstate:%x, dis_OCR=%x\n",
2600                                 fw_state, instance->disableOnlineCtrlReset);
2601                 }
2602         }
2603
2604         tasklet_schedule(&instance->isr_tasklet);
2605         return IRQ_HANDLED;
2606 }
2607 /**
2608  * megasas_isr - isr entry point
2609  */
2610 static irqreturn_t megasas_isr(int irq, void *devp)
2611 {
2612         struct megasas_irq_context *irq_context = devp;
2613         struct megasas_instance *instance = irq_context->instance;
2614         unsigned long flags;
2615         irqreturn_t     rc;
2616
2617         if (atomic_read(&instance->fw_reset_no_pci_access))
2618                 return IRQ_HANDLED;
2619
2620         spin_lock_irqsave(&instance->hba_lock, flags);
2621         rc =  megasas_deplete_reply_queue(instance, DID_OK);
2622         spin_unlock_irqrestore(&instance->hba_lock, flags);
2623
2624         return rc;
2625 }
2626
2627 /**
2628  * megasas_transition_to_ready -        Move the FW to READY state
2629  * @instance:                           Adapter soft state
2630  *
2631  * During the initialization, FW passes can potentially be in any one of
2632  * several possible states. If the FW in operational, waiting-for-handshake
2633  * states, driver must take steps to bring it to ready state. Otherwise, it
2634  * has to wait for the ready state.
2635  */
2636 int
2637 megasas_transition_to_ready(struct megasas_instance *instance, int ocr)
2638 {
2639         int i;
2640         u8 max_wait;
2641         u32 fw_state;
2642         u32 cur_state;
2643         u32 abs_state, curr_abs_state;
2644
2645         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
2646
2647         if (fw_state != MFI_STATE_READY)
2648                 printk(KERN_INFO "megasas: Waiting for FW to come to ready"
2649                        " state\n");
2650
2651         while (fw_state != MFI_STATE_READY) {
2652
2653                 abs_state =
2654                 instance->instancet->read_fw_status_reg(instance->reg_set);
2655
2656                 switch (fw_state) {
2657
2658                 case MFI_STATE_FAULT:
2659                         printk(KERN_DEBUG "megasas: FW in FAULT state!!\n");
2660                         if (ocr) {
2661                                 max_wait = MEGASAS_RESET_WAIT_TIME;
2662                                 cur_state = MFI_STATE_FAULT;
2663                                 break;
2664                         } else
2665                                 return -ENODEV;
2666
2667                 case MFI_STATE_WAIT_HANDSHAKE:
2668                         /*
2669                          * Set the CLR bit in inbound doorbell
2670                          */
2671                         if ((instance->pdev->device ==
2672                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2673                                 (instance->pdev->device ==
2674                                  PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2675                                 (instance->pdev->device ==
2676                                  PCI_DEVICE_ID_LSI_FUSION) ||
2677                                 (instance->pdev->device ==
2678                                 PCI_DEVICE_ID_LSI_INVADER)) {
2679                                 writel(
2680                                   MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
2681                                   &instance->reg_set->doorbell);
2682                         } else {
2683                                 writel(
2684                                     MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
2685                                         &instance->reg_set->inbound_doorbell);
2686                         }
2687
2688                         max_wait = MEGASAS_RESET_WAIT_TIME;
2689                         cur_state = MFI_STATE_WAIT_HANDSHAKE;
2690                         break;
2691
2692                 case MFI_STATE_BOOT_MESSAGE_PENDING:
2693                         if ((instance->pdev->device ==
2694                              PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2695                                 (instance->pdev->device ==
2696                                  PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2697                             (instance->pdev->device ==
2698                              PCI_DEVICE_ID_LSI_FUSION) ||
2699                             (instance->pdev->device ==
2700                              PCI_DEVICE_ID_LSI_INVADER)) {
2701                                 writel(MFI_INIT_HOTPLUG,
2702                                        &instance->reg_set->doorbell);
2703                         } else
2704                                 writel(MFI_INIT_HOTPLUG,
2705                                         &instance->reg_set->inbound_doorbell);
2706
2707                         max_wait = MEGASAS_RESET_WAIT_TIME;
2708                         cur_state = MFI_STATE_BOOT_MESSAGE_PENDING;
2709                         break;
2710
2711                 case MFI_STATE_OPERATIONAL:
2712                         /*
2713                          * Bring it to READY state; assuming max wait 10 secs
2714                          */
2715                         instance->instancet->disable_intr(instance->reg_set);
2716                         if ((instance->pdev->device ==
2717                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2718                                 (instance->pdev->device ==
2719                                 PCI_DEVICE_ID_LSI_SAS0071SKINNY)  ||
2720                                 (instance->pdev->device
2721                                         == PCI_DEVICE_ID_LSI_FUSION) ||
2722                                 (instance->pdev->device
2723                                         == PCI_DEVICE_ID_LSI_INVADER)) {
2724                                 writel(MFI_RESET_FLAGS,
2725                                         &instance->reg_set->doorbell);
2726                                 if ((instance->pdev->device ==
2727                                     PCI_DEVICE_ID_LSI_FUSION) ||
2728                                     (instance->pdev->device ==
2729                                      PCI_DEVICE_ID_LSI_INVADER)) {
2730                                         for (i = 0; i < (10 * 1000); i += 20) {
2731                                                 if (readl(
2732                                                             &instance->
2733                                                             reg_set->
2734                                                             doorbell) & 1)
2735                                                         msleep(20);
2736                                                 else
2737                                                         break;
2738                                         }
2739                                 }
2740                         } else
2741                                 writel(MFI_RESET_FLAGS,
2742                                         &instance->reg_set->inbound_doorbell);
2743
2744                         max_wait = MEGASAS_RESET_WAIT_TIME;
2745                         cur_state = MFI_STATE_OPERATIONAL;
2746                         break;
2747
2748                 case MFI_STATE_UNDEFINED:
2749                         /*
2750                          * This state should not last for more than 2 seconds
2751                          */
2752                         max_wait = MEGASAS_RESET_WAIT_TIME;
2753                         cur_state = MFI_STATE_UNDEFINED;
2754                         break;
2755
2756                 case MFI_STATE_BB_INIT:
2757                         max_wait = MEGASAS_RESET_WAIT_TIME;
2758                         cur_state = MFI_STATE_BB_INIT;
2759                         break;
2760
2761                 case MFI_STATE_FW_INIT:
2762                         max_wait = MEGASAS_RESET_WAIT_TIME;
2763                         cur_state = MFI_STATE_FW_INIT;
2764                         break;
2765
2766                 case MFI_STATE_FW_INIT_2:
2767                         max_wait = MEGASAS_RESET_WAIT_TIME;
2768                         cur_state = MFI_STATE_FW_INIT_2;
2769                         break;
2770
2771                 case MFI_STATE_DEVICE_SCAN:
2772                         max_wait = MEGASAS_RESET_WAIT_TIME;
2773                         cur_state = MFI_STATE_DEVICE_SCAN;
2774                         break;
2775
2776                 case MFI_STATE_FLUSH_CACHE:
2777                         max_wait = MEGASAS_RESET_WAIT_TIME;
2778                         cur_state = MFI_STATE_FLUSH_CACHE;
2779                         break;
2780
2781                 default:
2782                         printk(KERN_DEBUG "megasas: Unknown state 0x%x\n",
2783                                fw_state);
2784                         return -ENODEV;
2785                 }
2786
2787                 /*
2788                  * The cur_state should not last for more than max_wait secs
2789                  */
2790                 for (i = 0; i < (max_wait * 1000); i++) {
2791                         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) &
2792                                         MFI_STATE_MASK ;
2793                 curr_abs_state =
2794                 instance->instancet->read_fw_status_reg(instance->reg_set);
2795
2796                         if (abs_state == curr_abs_state) {
2797                                 msleep(1);
2798                         } else
2799                                 break;
2800                 }
2801
2802                 /*
2803                  * Return error if fw_state hasn't changed after max_wait
2804                  */
2805                 if (curr_abs_state == abs_state) {
2806                         printk(KERN_DEBUG "FW state [%d] hasn't changed "
2807                                "in %d secs\n", fw_state, max_wait);
2808                         return -ENODEV;
2809                 }
2810         }
2811         printk(KERN_INFO "megasas: FW now in Ready state\n");
2812
2813         return 0;
2814 }
2815
2816 /**
2817  * megasas_teardown_frame_pool -        Destroy the cmd frame DMA pool
2818  * @instance:                           Adapter soft state
2819  */
2820 static void megasas_teardown_frame_pool(struct megasas_instance *instance)
2821 {
2822         int i;
2823         u32 max_cmd = instance->max_mfi_cmds;
2824         struct megasas_cmd *cmd;
2825
2826         if (!instance->frame_dma_pool)
2827                 return;
2828
2829         /*
2830          * Return all frames to pool
2831          */
2832         for (i = 0; i < max_cmd; i++) {
2833
2834                 cmd = instance->cmd_list[i];
2835
2836                 if (cmd->frame)
2837                         pci_pool_free(instance->frame_dma_pool, cmd->frame,
2838                                       cmd->frame_phys_addr);
2839
2840                 if (cmd->sense)
2841                         pci_pool_free(instance->sense_dma_pool, cmd->sense,
2842                                       cmd->sense_phys_addr);
2843         }
2844
2845         /*
2846          * Now destroy the pool itself
2847          */
2848         pci_pool_destroy(instance->frame_dma_pool);
2849         pci_pool_destroy(instance->sense_dma_pool);
2850
2851         instance->frame_dma_pool = NULL;
2852         instance->sense_dma_pool = NULL;
2853 }
2854
2855 /**
2856  * megasas_create_frame_pool -  Creates DMA pool for cmd frames
2857  * @instance:                   Adapter soft state
2858  *
2859  * Each command packet has an embedded DMA memory buffer that is used for
2860  * filling MFI frame and the SG list that immediately follows the frame. This
2861  * function creates those DMA memory buffers for each command packet by using
2862  * PCI pool facility.
2863  */
2864 static int megasas_create_frame_pool(struct megasas_instance *instance)
2865 {
2866         int i;
2867         u32 max_cmd;
2868         u32 sge_sz;
2869         u32 sgl_sz;
2870         u32 total_sz;
2871         u32 frame_count;
2872         struct megasas_cmd *cmd;
2873
2874         max_cmd = instance->max_mfi_cmds;
2875
2876         /*
2877          * Size of our frame is 64 bytes for MFI frame, followed by max SG
2878          * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer
2879          */
2880         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
2881             sizeof(struct megasas_sge32);
2882
2883         if (instance->flag_ieee) {
2884                 sge_sz = sizeof(struct megasas_sge_skinny);
2885         }
2886
2887         /*
2888          * Calculated the number of 64byte frames required for SGL
2889          */
2890         sgl_sz = sge_sz * instance->max_num_sge;
2891         frame_count = (sgl_sz + MEGAMFI_FRAME_SIZE - 1) / MEGAMFI_FRAME_SIZE;
2892         frame_count = 15;
2893
2894         /*
2895          * We need one extra frame for the MFI command
2896          */
2897         frame_count++;
2898
2899         total_sz = MEGAMFI_FRAME_SIZE * frame_count;
2900         /*
2901          * Use DMA pool facility provided by PCI layer
2902          */
2903         instance->frame_dma_pool = pci_pool_create("megasas frame pool",
2904                                                    instance->pdev, total_sz, 64,
2905                                                    0);
2906
2907         if (!instance->frame_dma_pool) {
2908                 printk(KERN_DEBUG "megasas: failed to setup frame pool\n");
2909                 return -ENOMEM;
2910         }
2911
2912         instance->sense_dma_pool = pci_pool_create("megasas sense pool",
2913                                                    instance->pdev, 128, 4, 0);
2914
2915         if (!instance->sense_dma_pool) {
2916                 printk(KERN_DEBUG "megasas: failed to setup sense pool\n");
2917
2918                 pci_pool_destroy(instance->frame_dma_pool);
2919                 instance->frame_dma_pool = NULL;
2920
2921                 return -ENOMEM;
2922         }
2923
2924         /*
2925          * Allocate and attach a frame to each of the commands in cmd_list.
2926          * By making cmd->index as the context instead of the &cmd, we can
2927          * always use 32bit context regardless of the architecture
2928          */
2929         for (i = 0; i < max_cmd; i++) {
2930
2931                 cmd = instance->cmd_list[i];
2932
2933                 cmd->frame = pci_pool_alloc(instance->frame_dma_pool,
2934                                             GFP_KERNEL, &cmd->frame_phys_addr);
2935
2936                 cmd->sense = pci_pool_alloc(instance->sense_dma_pool,
2937                                             GFP_KERNEL, &cmd->sense_phys_addr);
2938
2939                 /*
2940                  * megasas_teardown_frame_pool() takes care of freeing
2941                  * whatever has been allocated
2942                  */
2943                 if (!cmd->frame || !cmd->sense) {
2944                         printk(KERN_DEBUG "megasas: pci_pool_alloc failed \n");
2945                         megasas_teardown_frame_pool(instance);
2946                         return -ENOMEM;
2947                 }
2948
2949                 memset(cmd->frame, 0, total_sz);
2950                 cmd->frame->io.context = cmd->index;
2951                 cmd->frame->io.pad_0 = 0;
2952                 if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) &&
2953                     (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) &&
2954                     (reset_devices))
2955                         cmd->frame->hdr.cmd = MFI_CMD_INVALID;
2956         }
2957
2958         return 0;
2959 }
2960
2961 /**
2962  * megasas_free_cmds -  Free all the cmds in the free cmd pool
2963  * @instance:           Adapter soft state
2964  */
2965 void megasas_free_cmds(struct megasas_instance *instance)
2966 {
2967         int i;
2968         /* First free the MFI frame pool */
2969         megasas_teardown_frame_pool(instance);
2970
2971         /* Free all the commands in the cmd_list */
2972         for (i = 0; i < instance->max_mfi_cmds; i++)
2973
2974                 kfree(instance->cmd_list[i]);
2975
2976         /* Free the cmd_list buffer itself */
2977         kfree(instance->cmd_list);
2978         instance->cmd_list = NULL;
2979
2980         INIT_LIST_HEAD(&instance->cmd_pool);
2981 }
2982
2983 /**
2984  * megasas_alloc_cmds - Allocates the command packets
2985  * @instance:           Adapter soft state
2986  *
2987  * Each command that is issued to the FW, whether IO commands from the OS or
2988  * internal commands like IOCTLs, are wrapped in local data structure called
2989  * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to
2990  * the FW.
2991  *
2992  * Each frame has a 32-bit field called context (tag). This context is used
2993  * to get back the megasas_cmd from the frame when a frame gets completed in
2994  * the ISR. Typically the address of the megasas_cmd itself would be used as
2995  * the context. But we wanted to keep the differences between 32 and 64 bit
2996  * systems to the mininum. We always use 32 bit integers for the context. In
2997  * this driver, the 32 bit values are the indices into an array cmd_list.
2998  * This array is used only to look up the megasas_cmd given the context. The
2999  * free commands themselves are maintained in a linked list called cmd_pool.
3000  */
3001 int megasas_alloc_cmds(struct megasas_instance *instance)
3002 {
3003         int i;
3004         int j;
3005         u32 max_cmd;
3006         struct megasas_cmd *cmd;
3007
3008         max_cmd = instance->max_mfi_cmds;
3009
3010         /*
3011          * instance->cmd_list is an array of struct megasas_cmd pointers.
3012          * Allocate the dynamic array first and then allocate individual
3013          * commands.
3014          */
3015         instance->cmd_list = kcalloc(max_cmd, sizeof(struct megasas_cmd*), GFP_KERNEL);
3016
3017         if (!instance->cmd_list) {
3018                 printk(KERN_DEBUG "megasas: out of memory\n");
3019                 return -ENOMEM;
3020         }
3021
3022         memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) *max_cmd);
3023
3024         for (i = 0; i < max_cmd; i++) {
3025                 instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
3026                                                 GFP_KERNEL);
3027
3028                 if (!instance->cmd_list[i]) {
3029
3030                         for (j = 0; j < i; j++)
3031                                 kfree(instance->cmd_list[j]);
3032
3033                         kfree(instance->cmd_list);
3034                         instance->cmd_list = NULL;
3035
3036                         return -ENOMEM;
3037                 }
3038         }
3039
3040         /*
3041          * Add all the commands to command pool (instance->cmd_pool)
3042          */
3043         for (i = 0; i < max_cmd; i++) {
3044                 cmd = instance->cmd_list[i];
3045                 memset(cmd, 0, sizeof(struct megasas_cmd));
3046                 cmd->index = i;
3047                 cmd->scmd = NULL;
3048                 cmd->instance = instance;
3049
3050                 list_add_tail(&cmd->list, &instance->cmd_pool);
3051         }
3052
3053         /*
3054          * Create a frame pool and assign one frame to each cmd
3055          */
3056         if (megasas_create_frame_pool(instance)) {
3057                 printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n");
3058                 megasas_free_cmds(instance);
3059         }
3060
3061         return 0;
3062 }
3063
3064 /*
3065  * megasas_get_pd_list_info -   Returns FW's pd_list structure
3066  * @instance:                           Adapter soft state
3067  * @pd_list:                            pd_list structure
3068  *
3069  * Issues an internal command (DCMD) to get the FW's controller PD
3070  * list structure.  This information is mainly used to find out SYSTEM
3071  * supported by the FW.
3072  */
3073 static int
3074 megasas_get_pd_list(struct megasas_instance *instance)
3075 {
3076         int ret = 0, pd_index = 0;
3077         struct megasas_cmd *cmd;
3078         struct megasas_dcmd_frame *dcmd;
3079         struct MR_PD_LIST *ci;
3080         struct MR_PD_ADDRESS *pd_addr;
3081         dma_addr_t ci_h = 0;
3082
3083         cmd = megasas_get_cmd(instance);
3084
3085         if (!cmd) {
3086                 printk(KERN_DEBUG "megasas (get_pd_list): Failed to get cmd\n");
3087                 return -ENOMEM;
3088         }
3089
3090         dcmd = &cmd->frame->dcmd;
3091
3092         ci = pci_alloc_consistent(instance->pdev,
3093                   MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST), &ci_h);
3094
3095         if (!ci) {
3096                 printk(KERN_DEBUG "Failed to alloc mem for pd_list\n");
3097                 megasas_return_cmd(instance, cmd);
3098                 return -ENOMEM;
3099         }
3100
3101         memset(ci, 0, sizeof(*ci));
3102         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3103
3104         dcmd->mbox.b[0] = MR_PD_QUERY_TYPE_EXPOSED_TO_HOST;
3105         dcmd->mbox.b[1] = 0;
3106         dcmd->cmd = MFI_CMD_DCMD;
3107         dcmd->cmd_status = 0xFF;
3108         dcmd->sge_count = 1;
3109         dcmd->flags = MFI_FRAME_DIR_READ;
3110         dcmd->timeout = 0;
3111         dcmd->pad_0 = 0;
3112         dcmd->data_xfer_len = MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST);
3113         dcmd->opcode = MR_DCMD_PD_LIST_QUERY;
3114         dcmd->sgl.sge32[0].phys_addr = ci_h;
3115         dcmd->sgl.sge32[0].length = MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST);
3116
3117         if (!megasas_issue_polled(instance, cmd)) {
3118                 ret = 0;
3119         } else {
3120                 ret = -1;
3121         }
3122
3123         /*
3124         * the following function will get the instance PD LIST.
3125         */
3126
3127         pd_addr = ci->addr;
3128
3129         if ( ret == 0 &&
3130                 (ci->count <
3131                   (MEGASAS_MAX_PD_CHANNELS * MEGASAS_MAX_DEV_PER_CHANNEL))) {
3132
3133                 memset(instance->pd_list, 0,
3134                         MEGASAS_MAX_PD * sizeof(struct megasas_pd_list));
3135
3136                 for (pd_index = 0; pd_index < ci->count; pd_index++) {
3137
3138                         instance->pd_list[pd_addr->deviceId].tid        =
3139                                                         pd_addr->deviceId;
3140                         instance->pd_list[pd_addr->deviceId].driveType  =
3141                                                         pd_addr->scsiDevType;
3142                         instance->pd_list[pd_addr->deviceId].driveState =
3143                                                         MR_PD_STATE_SYSTEM;
3144                         pd_addr++;
3145                 }
3146         }
3147
3148         pci_free_consistent(instance->pdev,
3149                                 MEGASAS_MAX_PD * sizeof(struct MR_PD_LIST),
3150                                 ci, ci_h);
3151         megasas_return_cmd(instance, cmd);
3152
3153         return ret;
3154 }
3155
3156 /*
3157  * megasas_get_ld_list_info -   Returns FW's ld_list structure
3158  * @instance:                           Adapter soft state
3159  * @ld_list:                            ld_list structure
3160  *
3161  * Issues an internal command (DCMD) to get the FW's controller PD
3162  * list structure.  This information is mainly used to find out SYSTEM
3163  * supported by the FW.
3164  */
3165 static int
3166 megasas_get_ld_list(struct megasas_instance *instance)
3167 {
3168         int ret = 0, ld_index = 0, ids = 0;
3169         struct megasas_cmd *cmd;
3170         struct megasas_dcmd_frame *dcmd;
3171         struct MR_LD_LIST *ci;
3172         dma_addr_t ci_h = 0;
3173
3174         cmd = megasas_get_cmd(instance);
3175
3176         if (!cmd) {
3177                 printk(KERN_DEBUG "megasas_get_ld_list: Failed to get cmd\n");
3178                 return -ENOMEM;
3179         }
3180
3181         dcmd = &cmd->frame->dcmd;
3182
3183         ci = pci_alloc_consistent(instance->pdev,
3184                                 sizeof(struct MR_LD_LIST),
3185                                 &ci_h);
3186
3187         if (!ci) {
3188                 printk(KERN_DEBUG "Failed to alloc mem in get_ld_list\n");
3189                 megasas_return_cmd(instance, cmd);
3190                 return -ENOMEM;
3191         }
3192
3193         memset(ci, 0, sizeof(*ci));
3194         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3195
3196         dcmd->cmd = MFI_CMD_DCMD;
3197         dcmd->cmd_status = 0xFF;
3198         dcmd->sge_count = 1;
3199         dcmd->flags = MFI_FRAME_DIR_READ;
3200         dcmd->timeout = 0;
3201         dcmd->data_xfer_len = sizeof(struct MR_LD_LIST);
3202         dcmd->opcode = MR_DCMD_LD_GET_LIST;
3203         dcmd->sgl.sge32[0].phys_addr = ci_h;
3204         dcmd->sgl.sge32[0].length = sizeof(struct MR_LD_LIST);
3205         dcmd->pad_0  = 0;
3206
3207         if (!megasas_issue_polled(instance, cmd)) {
3208                 ret = 0;
3209         } else {
3210                 ret = -1;
3211         }
3212
3213         /* the following function will get the instance PD LIST */
3214
3215         if ((ret == 0) && (ci->ldCount <= MAX_LOGICAL_DRIVES)) {
3216                 memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
3217
3218                 for (ld_index = 0; ld_index < ci->ldCount; ld_index++) {
3219                         if (ci->ldList[ld_index].state != 0) {
3220                                 ids = ci->ldList[ld_index].ref.targetId;
3221                                 instance->ld_ids[ids] =
3222                                         ci->ldList[ld_index].ref.targetId;
3223                         }
3224                 }
3225         }
3226
3227         pci_free_consistent(instance->pdev,
3228                                 sizeof(struct MR_LD_LIST),
3229                                 ci,
3230                                 ci_h);
3231
3232         megasas_return_cmd(instance, cmd);
3233         return ret;
3234 }
3235
3236 /**
3237  * megasas_get_controller_info -        Returns FW's controller structure
3238  * @instance:                           Adapter soft state
3239  * @ctrl_info:                          Controller information structure
3240  *
3241  * Issues an internal command (DCMD) to get the FW's controller structure.
3242  * This information is mainly used to find out the maximum IO transfer per
3243  * command supported by the FW.
3244  */
3245 static int
3246 megasas_get_ctrl_info(struct megasas_instance *instance,
3247                       struct megasas_ctrl_info *ctrl_info)
3248 {
3249         int ret = 0;
3250         struct megasas_cmd *cmd;
3251         struct megasas_dcmd_frame *dcmd;
3252         struct megasas_ctrl_info *ci;
3253         dma_addr_t ci_h = 0;
3254
3255         cmd = megasas_get_cmd(instance);
3256
3257         if (!cmd) {
3258                 printk(KERN_DEBUG "megasas: Failed to get a free cmd\n");
3259                 return -ENOMEM;
3260         }
3261
3262         dcmd = &cmd->frame->dcmd;
3263
3264         ci = pci_alloc_consistent(instance->pdev,
3265                                   sizeof(struct megasas_ctrl_info), &ci_h);
3266
3267         if (!ci) {
3268                 printk(KERN_DEBUG "Failed to alloc mem for ctrl info\n");
3269                 megasas_return_cmd(instance, cmd);
3270                 return -ENOMEM;
3271         }
3272
3273         memset(ci, 0, sizeof(*ci));
3274         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3275
3276         dcmd->cmd = MFI_CMD_DCMD;
3277         dcmd->cmd_status = 0xFF;
3278         dcmd->sge_count = 1;
3279         dcmd->flags = MFI_FRAME_DIR_READ;
3280         dcmd->timeout = 0;
3281         dcmd->pad_0 = 0;
3282         dcmd->data_xfer_len = sizeof(struct megasas_ctrl_info);
3283         dcmd->opcode = MR_DCMD_CTRL_GET_INFO;
3284         dcmd->sgl.sge32[0].phys_addr = ci_h;
3285         dcmd->sgl.sge32[0].length = sizeof(struct megasas_ctrl_info);
3286
3287         if (!megasas_issue_polled(instance, cmd)) {
3288                 ret = 0;
3289                 memcpy(ctrl_info, ci, sizeof(struct megasas_ctrl_info));
3290         } else {
3291                 ret = -1;
3292         }
3293
3294         pci_free_consistent(instance->pdev, sizeof(struct megasas_ctrl_info),
3295                             ci, ci_h);
3296
3297         megasas_return_cmd(instance, cmd);
3298         return ret;
3299 }
3300
3301 /**
3302  * megasas_issue_init_mfi -     Initializes the FW
3303  * @instance:           Adapter soft state
3304  *
3305  * Issues the INIT MFI cmd
3306  */
3307 static int
3308 megasas_issue_init_mfi(struct megasas_instance *instance)
3309 {
3310         u32 context;
3311
3312         struct megasas_cmd *cmd;
3313
3314         struct megasas_init_frame *init_frame;
3315         struct megasas_init_queue_info *initq_info;
3316         dma_addr_t init_frame_h;
3317         dma_addr_t initq_info_h;
3318
3319         /*
3320          * Prepare a init frame. Note the init frame points to queue info
3321          * structure. Each frame has SGL allocated after first 64 bytes. For
3322          * this frame - since we don't need any SGL - we use SGL's space as
3323          * queue info structure
3324          *
3325          * We will not get a NULL command below. We just created the pool.
3326          */
3327         cmd = megasas_get_cmd(instance);
3328
3329         init_frame = (struct megasas_init_frame *)cmd->frame;
3330         initq_info = (struct megasas_init_queue_info *)
3331                 ((unsigned long)init_frame + 64);
3332
3333         init_frame_h = cmd->frame_phys_addr;
3334         initq_info_h = init_frame_h + 64;
3335
3336         context = init_frame->context;
3337         memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
3338         memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
3339         init_frame->context = context;
3340
3341         initq_info->reply_queue_entries = instance->max_fw_cmds + 1;
3342         initq_info->reply_queue_start_phys_addr_lo = instance->reply_queue_h;
3343
3344         initq_info->producer_index_phys_addr_lo = instance->producer_h;
3345         initq_info->consumer_index_phys_addr_lo = instance->consumer_h;
3346
3347         init_frame->cmd = MFI_CMD_INIT;
3348         init_frame->cmd_status = 0xFF;
3349         init_frame->queue_info_new_phys_addr_lo = initq_info_h;
3350
3351         init_frame->data_xfer_len = sizeof(struct megasas_init_queue_info);
3352
3353         /*
3354          * disable the intr before firing the init frame to FW
3355          */
3356         instance->instancet->disable_intr(instance->reg_set);
3357
3358         /*
3359          * Issue the init frame in polled mode
3360          */
3361
3362         if (megasas_issue_polled(instance, cmd)) {
3363                 printk(KERN_ERR "megasas: Failed to init firmware\n");
3364                 megasas_return_cmd(instance, cmd);
3365                 goto fail_fw_init;
3366         }
3367
3368         megasas_return_cmd(instance, cmd);
3369
3370         return 0;
3371
3372 fail_fw_init:
3373         return -EINVAL;
3374 }
3375
3376 static u32
3377 megasas_init_adapter_mfi(struct megasas_instance *instance)
3378 {
3379         struct megasas_register_set __iomem *reg_set;
3380         u32 context_sz;
3381         u32 reply_q_sz;
3382
3383         reg_set = instance->reg_set;
3384
3385         /*
3386          * Get various operational parameters from status register
3387          */
3388         instance->max_fw_cmds = instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
3389         /*
3390          * Reduce the max supported cmds by 1. This is to ensure that the
3391          * reply_q_sz (1 more than the max cmd that driver may send)
3392          * does not exceed max cmds that the FW can support
3393          */
3394         instance->max_fw_cmds = instance->max_fw_cmds-1;
3395         instance->max_mfi_cmds = instance->max_fw_cmds;
3396         instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >>
3397                                         0x10;
3398         /*
3399          * Create a pool of commands
3400          */
3401         if (megasas_alloc_cmds(instance))
3402                 goto fail_alloc_cmds;
3403
3404         /*
3405          * Allocate memory for reply queue. Length of reply queue should
3406          * be _one_ more than the maximum commands handled by the firmware.
3407          *
3408          * Note: When FW completes commands, it places corresponding contex
3409          * values in this circular reply queue. This circular queue is a fairly
3410          * typical producer-consumer queue. FW is the producer (of completed
3411          * commands) and the driver is the consumer.
3412          */
3413         context_sz = sizeof(u32);
3414         reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
3415
3416         instance->reply_queue = pci_alloc_consistent(instance->pdev,
3417                                                      reply_q_sz,
3418                                                      &instance->reply_queue_h);
3419
3420         if (!instance->reply_queue) {
3421                 printk(KERN_DEBUG "megasas: Out of DMA mem for reply queue\n");
3422                 goto fail_reply_queue;
3423         }
3424
3425         if (megasas_issue_init_mfi(instance))
3426                 goto fail_fw_init;
3427
3428         instance->fw_support_ieee = 0;
3429         instance->fw_support_ieee =
3430                 (instance->instancet->read_fw_status_reg(reg_set) &
3431                 0x04000000);
3432
3433         printk(KERN_NOTICE "megasas_init_mfi: fw_support_ieee=%d",
3434                         instance->fw_support_ieee);
3435
3436         if (instance->fw_support_ieee)
3437                 instance->flag_ieee = 1;
3438
3439         return 0;
3440
3441 fail_fw_init:
3442
3443         pci_free_consistent(instance->pdev, reply_q_sz,
3444                             instance->reply_queue, instance->reply_queue_h);
3445 fail_reply_queue:
3446         megasas_free_cmds(instance);
3447
3448 fail_alloc_cmds:
3449         return 1;
3450 }
3451
3452 /**
3453  * megasas_init_fw -    Initializes the FW
3454  * @instance:           Adapter soft state
3455  *
3456  * This is the main function for initializing firmware
3457  */
3458
3459 static int megasas_init_fw(struct megasas_instance *instance)
3460 {
3461         u32 max_sectors_1;
3462         u32 max_sectors_2;
3463         u32 tmp_sectors, msix_enable;
3464         struct megasas_register_set __iomem *reg_set;
3465         struct megasas_ctrl_info *ctrl_info;
3466         unsigned long bar_list;
3467         int i;
3468
3469         /* Find first memory bar */
3470         bar_list = pci_select_bars(instance->pdev, IORESOURCE_MEM);
3471         instance->bar = find_first_bit(&bar_list, sizeof(unsigned long));
3472         instance->base_addr = pci_resource_start(instance->pdev, instance->bar);
3473         if (pci_request_selected_regions(instance->pdev, instance->bar,
3474                                          "megasas: LSI")) {
3475                 printk(KERN_DEBUG "megasas: IO memory region busy!\n");
3476                 return -EBUSY;
3477         }
3478
3479         instance->reg_set = ioremap_nocache(instance->base_addr, 8192);
3480
3481         if (!instance->reg_set) {
3482                 printk(KERN_DEBUG "megasas: Failed to map IO mem\n");
3483                 goto fail_ioremap;
3484         }
3485
3486         reg_set = instance->reg_set;
3487
3488         switch (instance->pdev->device) {
3489         case PCI_DEVICE_ID_LSI_FUSION:
3490         case PCI_DEVICE_ID_LSI_INVADER:
3491                 instance->instancet = &megasas_instance_template_fusion;
3492                 break;
3493         case PCI_DEVICE_ID_LSI_SAS1078R:
3494         case PCI_DEVICE_ID_LSI_SAS1078DE:
3495                 instance->instancet = &megasas_instance_template_ppc;
3496                 break;
3497         case PCI_DEVICE_ID_LSI_SAS1078GEN2:
3498         case PCI_DEVICE_ID_LSI_SAS0079GEN2:
3499                 instance->instancet = &megasas_instance_template_gen2;
3500                 break;
3501         case PCI_DEVICE_ID_LSI_SAS0073SKINNY:
3502         case PCI_DEVICE_ID_LSI_SAS0071SKINNY:
3503                 instance->instancet = &megasas_instance_template_skinny;
3504                 break;
3505         case PCI_DEVICE_ID_LSI_SAS1064R:
3506         case PCI_DEVICE_ID_DELL_PERC5:
3507         default:
3508                 instance->instancet = &megasas_instance_template_xscale;
3509                 break;
3510         }
3511
3512         if (megasas_transition_to_ready(instance, 0)) {
3513                 atomic_set(&instance->fw_reset_no_pci_access, 1);
3514                 instance->instancet->adp_reset
3515                         (instance, instance->reg_set);
3516                 atomic_set(&instance->fw_reset_no_pci_access, 0);
3517                 dev_info(&instance->pdev->dev,
3518                         "megasas: FW restarted successfully from %s!\n",
3519                         __func__);
3520
3521                 /*waitting for about 30 second before retry*/
3522                 ssleep(30);
3523
3524                 if (megasas_transition_to_ready(instance, 0))
3525                         goto fail_ready_state;
3526         }
3527
3528         /* Check if MSI-X is supported while in ready state */
3529         msix_enable = (instance->instancet->read_fw_status_reg(reg_set) &
3530                        0x4000000) >> 0x1a;
3531         if (msix_enable && !msix_disable) {
3532                 /* Check max MSI-X vectors */
3533                 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
3534                     (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER)) {
3535                         instance->msix_vectors = (readl(&instance->reg_set->
3536                                                         outbound_scratch_pad_2
3537                                                           ) & 0x1F) + 1;
3538                         if (msix_vectors)
3539                                 instance->msix_vectors =
3540                                         min(msix_vectors,
3541                                             instance->msix_vectors);
3542                 } else
3543                         instance->msix_vectors = 1;
3544                 /* Don't bother allocating more MSI-X vectors than cpus */
3545                 instance->msix_vectors = min(instance->msix_vectors,
3546                                              (unsigned int)num_online_cpus());
3547                 for (i = 0; i < instance->msix_vectors; i++)
3548                         instance->msixentry[i].entry = i;
3549                 i = pci_enable_msix(instance->pdev, instance->msixentry,
3550                                     instance->msix_vectors);
3551                 if (i >= 0) {
3552                         if (i) {
3553                                 if (!pci_enable_msix(instance->pdev,
3554                                                      instance->msixentry, i))
3555                                         instance->msix_vectors = i;
3556                                 else
3557                                         instance->msix_vectors = 0;
3558                         }
3559                 } else
3560                         instance->msix_vectors = 0;
3561         }
3562
3563         /* Get operational params, sge flags, send init cmd to controller */
3564         if (instance->instancet->init_adapter(instance))
3565                 goto fail_init_adapter;
3566
3567         printk(KERN_ERR "megasas: INIT adapter done\n");
3568
3569         /** for passthrough
3570         * the following function will get the PD LIST.
3571         */
3572
3573         memset(instance->pd_list, 0 ,
3574                 (MEGASAS_MAX_PD * sizeof(struct megasas_pd_list)));
3575         megasas_get_pd_list(instance);
3576
3577         memset(instance->ld_ids, 0xff, MEGASAS_MAX_LD_IDS);
3578         megasas_get_ld_list(instance);
3579
3580         ctrl_info = kmalloc(sizeof(struct megasas_ctrl_info), GFP_KERNEL);
3581
3582         /*
3583          * Compute the max allowed sectors per IO: The controller info has two
3584          * limits on max sectors. Driver should use the minimum of these two.
3585          *
3586          * 1 << stripe_sz_ops.min = max sectors per strip
3587          *
3588          * Note that older firmwares ( < FW ver 30) didn't report information
3589          * to calculate max_sectors_1. So the number ended up as zero always.
3590          */
3591         tmp_sectors = 0;
3592         if (ctrl_info && !megasas_get_ctrl_info(instance, ctrl_info)) {
3593
3594                 max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) *
3595                     ctrl_info->max_strips_per_io;
3596                 max_sectors_2 = ctrl_info->max_request_size;
3597
3598                 tmp_sectors = min_t(u32, max_sectors_1 , max_sectors_2);
3599                 instance->disableOnlineCtrlReset =
3600                 ctrl_info->properties.OnOffProperties.disableOnlineCtrlReset;
3601         }
3602
3603         instance->max_sectors_per_req = instance->max_num_sge *
3604                                                 PAGE_SIZE / 512;
3605         if (tmp_sectors && (instance->max_sectors_per_req > tmp_sectors))
3606                 instance->max_sectors_per_req = tmp_sectors;
3607
3608         kfree(ctrl_info);
3609
3610         /* Check for valid throttlequeuedepth module parameter */
3611         if (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY ||
3612             instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) {
3613                 if (throttlequeuedepth > (instance->max_fw_cmds -
3614                                           MEGASAS_SKINNY_INT_CMDS))
3615                         instance->throttlequeuedepth =
3616                                 MEGASAS_THROTTLE_QUEUE_DEPTH;
3617                 else
3618                         instance->throttlequeuedepth = throttlequeuedepth;
3619         } else {
3620                 if (throttlequeuedepth > (instance->max_fw_cmds -
3621                                           MEGASAS_INT_CMDS))
3622                         instance->throttlequeuedepth =
3623                                 MEGASAS_THROTTLE_QUEUE_DEPTH;
3624                 else
3625                         instance->throttlequeuedepth = throttlequeuedepth;
3626         }
3627
3628         /*
3629         * Setup tasklet for cmd completion
3630         */
3631
3632         tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
3633                 (unsigned long)instance);
3634
3635         return 0;
3636
3637 fail_init_adapter:
3638 fail_ready_state:
3639         iounmap(instance->reg_set);
3640
3641       fail_ioremap:
3642         pci_release_selected_regions(instance->pdev, instance->bar);
3643
3644         return -EINVAL;
3645 }
3646
3647 /**
3648  * megasas_release_mfi -        Reverses the FW initialization
3649  * @intance:                    Adapter soft state
3650  */
3651 static void megasas_release_mfi(struct megasas_instance *instance)
3652 {
3653         u32 reply_q_sz = sizeof(u32) *(instance->max_mfi_cmds + 1);
3654
3655         if (instance->reply_queue)
3656                 pci_free_consistent(instance->pdev, reply_q_sz,
3657                             instance->reply_queue, instance->reply_queue_h);
3658
3659         megasas_free_cmds(instance);
3660
3661         iounmap(instance->reg_set);
3662
3663         pci_release_selected_regions(instance->pdev, instance->bar);
3664 }
3665
3666 /**
3667  * megasas_get_seq_num -        Gets latest event sequence numbers
3668  * @instance:                   Adapter soft state
3669  * @eli:                        FW event log sequence numbers information
3670  *
3671  * FW maintains a log of all events in a non-volatile area. Upper layers would
3672  * usually find out the latest sequence number of the events, the seq number at
3673  * the boot etc. They would "read" all the events below the latest seq number
3674  * by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq
3675  * number), they would subsribe to AEN (asynchronous event notification) and
3676  * wait for the events to happen.
3677  */
3678 static int
3679 megasas_get_seq_num(struct megasas_instance *instance,
3680                     struct megasas_evt_log_info *eli)
3681 {
3682         struct megasas_cmd *cmd;
3683         struct megasas_dcmd_frame *dcmd;
3684         struct megasas_evt_log_info *el_info;
3685         dma_addr_t el_info_h = 0;
3686
3687         cmd = megasas_get_cmd(instance);
3688
3689         if (!cmd) {
3690                 return -ENOMEM;
3691         }
3692
3693         dcmd = &cmd->frame->dcmd;
3694         el_info = pci_alloc_consistent(instance->pdev,
3695                                        sizeof(struct megasas_evt_log_info),
3696                                        &el_info_h);
3697
3698         if (!el_info) {
3699                 megasas_return_cmd(instance, cmd);
3700                 return -ENOMEM;
3701         }
3702
3703         memset(el_info, 0, sizeof(*el_info));
3704         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3705
3706         dcmd->cmd = MFI_CMD_DCMD;
3707         dcmd->cmd_status = 0x0;
3708         dcmd->sge_count = 1;
3709         dcmd->flags = MFI_FRAME_DIR_READ;
3710         dcmd->timeout = 0;
3711         dcmd->pad_0 = 0;
3712         dcmd->data_xfer_len = sizeof(struct megasas_evt_log_info);
3713         dcmd->opcode = MR_DCMD_CTRL_EVENT_GET_INFO;
3714         dcmd->sgl.sge32[0].phys_addr = el_info_h;
3715         dcmd->sgl.sge32[0].length = sizeof(struct megasas_evt_log_info);
3716
3717         megasas_issue_blocked_cmd(instance, cmd);
3718
3719         /*
3720          * Copy the data back into callers buffer
3721          */
3722         memcpy(eli, el_info, sizeof(struct megasas_evt_log_info));
3723
3724         pci_free_consistent(instance->pdev, sizeof(struct megasas_evt_log_info),
3725                             el_info, el_info_h);
3726
3727         megasas_return_cmd(instance, cmd);
3728
3729         return 0;
3730 }
3731
3732 /**
3733  * megasas_register_aen -       Registers for asynchronous event notification
3734  * @instance:                   Adapter soft state
3735  * @seq_num:                    The starting sequence number
3736  * @class_locale:               Class of the event
3737  *
3738  * This function subscribes for AEN for events beyond the @seq_num. It requests
3739  * to be notified if and only if the event is of type @class_locale
3740  */
3741 static int
3742 megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
3743                      u32 class_locale_word)
3744 {
3745         int ret_val;
3746         struct megasas_cmd *cmd;
3747         struct megasas_dcmd_frame *dcmd;
3748         union megasas_evt_class_locale curr_aen;
3749         union megasas_evt_class_locale prev_aen;
3750
3751         /*
3752          * If there an AEN pending already (aen_cmd), check if the
3753          * class_locale of that pending AEN is inclusive of the new
3754          * AEN request we currently have. If it is, then we don't have
3755          * to do anything. In other words, whichever events the current
3756          * AEN request is subscribing to, have already been subscribed
3757          * to.
3758          *
3759          * If the old_cmd is _not_ inclusive, then we have to abort
3760          * that command, form a class_locale that is superset of both
3761          * old and current and re-issue to the FW
3762          */
3763
3764         curr_aen.word = class_locale_word;
3765
3766         if (instance->aen_cmd) {
3767
3768                 prev_aen.word = instance->aen_cmd->frame->dcmd.mbox.w[1];
3769
3770                 /*
3771                  * A class whose enum value is smaller is inclusive of all
3772                  * higher values. If a PROGRESS (= -1) was previously
3773                  * registered, then a new registration requests for higher
3774                  * classes need not be sent to FW. They are automatically
3775                  * included.
3776                  *
3777                  * Locale numbers don't have such hierarchy. They are bitmap
3778                  * values
3779                  */
3780                 if ((prev_aen.members.class <= curr_aen.members.class) &&
3781                     !((prev_aen.members.locale & curr_aen.members.locale) ^
3782                       curr_aen.members.locale)) {
3783                         /*
3784                          * Previously issued event registration includes
3785                          * current request. Nothing to do.
3786                          */
3787                         return 0;
3788                 } else {
3789                         curr_aen.members.locale |= prev_aen.members.locale;
3790
3791                         if (prev_aen.members.class < curr_aen.members.class)
3792                                 curr_aen.members.class = prev_aen.members.class;
3793
3794                         instance->aen_cmd->abort_aen = 1;
3795                         ret_val = megasas_issue_blocked_abort_cmd(instance,
3796                                                                   instance->
3797                                                                   aen_cmd);
3798
3799                         if (ret_val) {
3800                                 printk(KERN_DEBUG "megasas: Failed to abort "
3801                                        "previous AEN command\n");
3802                                 return ret_val;
3803                         }
3804                 }
3805         }
3806
3807         cmd = megasas_get_cmd(instance);
3808
3809         if (!cmd)
3810                 return -ENOMEM;
3811
3812         dcmd = &cmd->frame->dcmd;
3813
3814         memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail));
3815
3816         /*
3817          * Prepare DCMD for aen registration
3818          */
3819         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
3820
3821         dcmd->cmd = MFI_CMD_DCMD;
3822         dcmd->cmd_status = 0x0;
3823         dcmd->sge_count = 1;
3824         dcmd->flags = MFI_FRAME_DIR_READ;
3825         dcmd->timeout = 0;
3826         dcmd->pad_0 = 0;
3827         instance->last_seq_num = seq_num;
3828         dcmd->data_xfer_len = sizeof(struct megasas_evt_detail);
3829         dcmd->opcode = MR_DCMD_CTRL_EVENT_WAIT;
3830         dcmd->mbox.w[0] = seq_num;
3831         dcmd->mbox.w[1] = curr_aen.word;
3832         dcmd->sgl.sge32[0].phys_addr = (u32) instance->evt_detail_h;
3833         dcmd->sgl.sge32[0].length = sizeof(struct megasas_evt_detail);
3834
3835         if (instance->aen_cmd != NULL) {
3836                 megasas_return_cmd(instance, cmd);
3837                 return 0;
3838         }
3839
3840         /*
3841          * Store reference to the cmd used to register for AEN. When an
3842          * application wants us to register for AEN, we have to abort this
3843          * cmd and re-register with a new EVENT LOCALE supplied by that app
3844          */
3845         instance->aen_cmd = cmd;
3846
3847         /*
3848          * Issue the aen registration frame
3849          */
3850         instance->instancet->issue_dcmd(instance, cmd);
3851
3852         return 0;
3853 }
3854
3855 /**
3856  * megasas_start_aen -  Subscribes to AEN during driver load time
3857  * @instance:           Adapter soft state
3858  */
3859 static int megasas_start_aen(struct megasas_instance *instance)
3860 {
3861         struct megasas_evt_log_info eli;
3862         union megasas_evt_class_locale class_locale;
3863
3864         /*
3865          * Get the latest sequence number from FW
3866          */
3867         memset(&eli, 0, sizeof(eli));
3868
3869         if (megasas_get_seq_num(instance, &eli))
3870                 return -1;
3871
3872         /*
3873          * Register AEN with FW for latest sequence number plus 1
3874          */
3875         class_locale.members.reserved = 0;
3876         class_locale.members.locale = MR_EVT_LOCALE_ALL;
3877         class_locale.members.class = MR_EVT_CLASS_DEBUG;
3878
3879         return megasas_register_aen(instance, eli.newest_seq_num + 1,
3880                                     class_locale.word);
3881 }
3882
3883 /**
3884  * megasas_io_attach -  Attaches this driver to SCSI mid-layer
3885  * @instance:           Adapter soft state
3886  */
3887 static int megasas_io_attach(struct megasas_instance *instance)
3888 {
3889         struct Scsi_Host *host = instance->host;
3890
3891         /*
3892          * Export parameters required by SCSI mid-layer
3893          */
3894         host->irq = instance->pdev->irq;
3895         host->unique_id = instance->unique_id;
3896         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
3897                 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
3898                 host->can_queue =
3899                         instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
3900         } else
3901                 host->can_queue =
3902                         instance->max_fw_cmds - MEGASAS_INT_CMDS;
3903         host->this_id = instance->init_id;
3904         host->sg_tablesize = instance->max_num_sge;
3905
3906         if (instance->fw_support_ieee)
3907                 instance->max_sectors_per_req = MEGASAS_MAX_SECTORS_IEEE;
3908
3909         /*
3910          * Check if the module parameter value for max_sectors can be used
3911          */
3912         if (max_sectors && max_sectors < instance->max_sectors_per_req)
3913                 instance->max_sectors_per_req = max_sectors;
3914         else {
3915                 if (max_sectors) {
3916                         if (((instance->pdev->device ==
3917                                 PCI_DEVICE_ID_LSI_SAS1078GEN2) ||
3918                                 (instance->pdev->device ==
3919                                 PCI_DEVICE_ID_LSI_SAS0079GEN2)) &&
3920                                 (max_sectors <= MEGASAS_MAX_SECTORS)) {
3921                                 instance->max_sectors_per_req = max_sectors;
3922                         } else {
3923                         printk(KERN_INFO "megasas: max_sectors should be > 0"
3924                                 "and <= %d (or < 1MB for GEN2 controller)\n",
3925                                 instance->max_sectors_per_req);
3926                         }
3927                 }
3928         }
3929
3930         host->max_sectors = instance->max_sectors_per_req;
3931         host->cmd_per_lun = MEGASAS_DEFAULT_CMD_PER_LUN;
3932         host->max_channel = MEGASAS_MAX_CHANNELS - 1;
3933         host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;
3934         host->max_lun = MEGASAS_MAX_LUN;
3935         host->max_cmd_len = 16;
3936
3937         /* Fusion only supports host reset */
3938         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
3939             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER)) {
3940                 host->hostt->eh_device_reset_handler = NULL;
3941                 host->hostt->eh_bus_reset_handler = NULL;
3942         }
3943
3944         /*
3945          * Notify the mid-layer about the new controller
3946          */
3947         if (scsi_add_host(host, &instance->pdev->dev)) {
3948                 printk(KERN_DEBUG "megasas: scsi_add_host failed\n");
3949                 return -ENODEV;
3950         }
3951
3952         /*
3953          * Trigger SCSI to scan our drives
3954          */
3955         scsi_scan_host(host);
3956         return 0;
3957 }
3958
3959 static int
3960 megasas_set_dma_mask(struct pci_dev *pdev)
3961 {
3962         /*
3963          * All our contollers are capable of performing 64-bit DMA
3964          */
3965         if (IS_DMA64) {
3966                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(64)) != 0) {
3967
3968                         if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
3969                                 goto fail_set_dma_mask;
3970                 }
3971         } else {
3972                 if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32)) != 0)
3973                         goto fail_set_dma_mask;
3974         }
3975         return 0;
3976
3977 fail_set_dma_mask:
3978         return 1;
3979 }
3980
3981 /**
3982  * megasas_probe_one -  PCI hotplug entry point
3983  * @pdev:               PCI device structure
3984  * @id:                 PCI ids of supported hotplugged adapter
3985  */
3986 static int megasas_probe_one(struct pci_dev *pdev,
3987                              const struct pci_device_id *id)
3988 {
3989         int rval, pos, i, j;
3990         struct Scsi_Host *host;
3991         struct megasas_instance *instance;
3992         u16 control = 0;
3993
3994         /* Reset MSI-X in the kdump kernel */
3995         if (reset_devices) {
3996                 pos = pci_find_capability(pdev, PCI_CAP_ID_MSIX);
3997                 if (pos) {
3998                         pci_read_config_word(pdev, pos + PCI_MSIX_FLAGS,
3999                                              &control);
4000                         if (control & PCI_MSIX_FLAGS_ENABLE) {
4001                                 dev_info(&pdev->dev, "resetting MSI-X\n");
4002                                 pci_write_config_word(pdev,
4003                                                       pos + PCI_MSIX_FLAGS,
4004                                                       control &
4005                                                       ~PCI_MSIX_FLAGS_ENABLE);
4006                         }
4007                 }
4008         }
4009
4010         /*
4011          * Announce PCI information
4012          */
4013         printk(KERN_INFO "megasas: %#4.04x:%#4.04x:%#4.04x:%#4.04x: ",
4014                pdev->vendor, pdev->device, pdev->subsystem_vendor,
4015                pdev->subsystem_device);
4016
4017         printk("bus %d:slot %d:func %d\n",
4018                pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
4019
4020         /*
4021          * PCI prepping: enable device set bus mastering and dma mask
4022          */
4023         rval = pci_enable_device_mem(pdev);
4024
4025         if (rval) {
4026                 return rval;
4027         }
4028
4029         pci_set_master(pdev);
4030
4031         if (megasas_set_dma_mask(pdev))
4032                 goto fail_set_dma_mask;
4033
4034         host = scsi_host_alloc(&megasas_template,
4035                                sizeof(struct megasas_instance));
4036
4037         if (!host) {
4038                 printk(KERN_DEBUG "megasas: scsi_host_alloc failed\n");
4039                 goto fail_alloc_instance;
4040         }
4041
4042         instance = (struct megasas_instance *)host->hostdata;
4043         memset(instance, 0, sizeof(*instance));
4044         atomic_set( &instance->fw_reset_no_pci_access, 0 );
4045         instance->pdev = pdev;
4046
4047         switch (instance->pdev->device) {
4048         case PCI_DEVICE_ID_LSI_FUSION:
4049         case PCI_DEVICE_ID_LSI_INVADER:
4050         {
4051                 struct fusion_context *fusion;
4052
4053                 instance->ctrl_context =
4054                         kzalloc(sizeof(struct fusion_context), GFP_KERNEL);
4055                 if (!instance->ctrl_context) {
4056                         printk(KERN_DEBUG "megasas: Failed to allocate "
4057                                "memory for Fusion context info\n");
4058                         goto fail_alloc_dma_buf;
4059                 }
4060                 fusion = instance->ctrl_context;
4061                 INIT_LIST_HEAD(&fusion->cmd_pool);
4062                 spin_lock_init(&fusion->cmd_pool_lock);
4063         }
4064         break;
4065         default: /* For all other supported controllers */
4066
4067                 instance->producer =
4068                         pci_alloc_consistent(pdev, sizeof(u32),
4069                                              &instance->producer_h);
4070                 instance->consumer =
4071                         pci_alloc_consistent(pdev, sizeof(u32),
4072                                              &instance->consumer_h);
4073
4074                 if (!instance->producer || !instance->consumer) {
4075                         printk(KERN_DEBUG "megasas: Failed to allocate"
4076                                "memory for producer, consumer\n");
4077                         goto fail_alloc_dma_buf;
4078                 }
4079
4080                 *instance->producer = 0;
4081                 *instance->consumer = 0;
4082                 break;
4083         }
4084
4085         megasas_poll_wait_aen = 0;
4086         instance->flag_ieee = 0;
4087         instance->ev = NULL;
4088         instance->issuepend_done = 1;
4089         instance->adprecovery = MEGASAS_HBA_OPERATIONAL;
4090         megasas_poll_wait_aen = 0;
4091
4092         instance->evt_detail = pci_alloc_consistent(pdev,
4093                                                     sizeof(struct
4094                                                            megasas_evt_detail),
4095                                                     &instance->evt_detail_h);
4096
4097         if (!instance->evt_detail) {
4098                 printk(KERN_DEBUG "megasas: Failed to allocate memory for "
4099                        "event detail structure\n");
4100                 goto fail_alloc_dma_buf;
4101         }
4102
4103         /*
4104          * Initialize locks and queues
4105          */
4106         INIT_LIST_HEAD(&instance->cmd_pool);
4107         INIT_LIST_HEAD(&instance->internal_reset_pending_q);
4108
4109         atomic_set(&instance->fw_outstanding,0);
4110
4111         init_waitqueue_head(&instance->int_cmd_wait_q);
4112         init_waitqueue_head(&instance->abort_cmd_wait_q);
4113
4114         spin_lock_init(&instance->cmd_pool_lock);
4115         spin_lock_init(&instance->hba_lock);
4116         spin_lock_init(&instance->completion_lock);
4117
4118         mutex_init(&instance->aen_mutex);
4119         mutex_init(&instance->reset_mutex);
4120
4121         /*
4122          * Initialize PCI related and misc parameters
4123          */
4124         instance->host = host;
4125         instance->unique_id = pdev->bus->number << 8 | pdev->devfn;
4126         instance->init_id = MEGASAS_DEFAULT_INIT_ID;
4127
4128         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
4129                 (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
4130                 instance->flag_ieee = 1;
4131                 sema_init(&instance->ioctl_sem, MEGASAS_SKINNY_INT_CMDS);
4132         } else
4133                 sema_init(&instance->ioctl_sem, MEGASAS_INT_CMDS);
4134
4135         megasas_dbg_lvl = 0;
4136         instance->flag = 0;
4137         instance->unload = 1;
4138         instance->last_time = 0;
4139         instance->disableOnlineCtrlReset = 1;
4140
4141         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
4142             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER))
4143                 INIT_WORK(&instance->work_init, megasas_fusion_ocr_wq);
4144         else
4145                 INIT_WORK(&instance->work_init, process_fw_state_change_wq);
4146
4147         /*
4148          * Initialize MFI Firmware
4149          */
4150         if (megasas_init_fw(instance))
4151                 goto fail_init_mfi;
4152
4153         /*
4154          * Register IRQ
4155          */
4156         if (instance->msix_vectors) {
4157                 for (i = 0 ; i < instance->msix_vectors; i++) {
4158                         instance->irq_context[i].instance = instance;
4159                         instance->irq_context[i].MSIxIndex = i;
4160                         if (request_irq(instance->msixentry[i].vector,
4161                                         instance->instancet->service_isr, 0,
4162                                         "megasas",
4163                                         &instance->irq_context[i])) {
4164                                 printk(KERN_DEBUG "megasas: Failed to "
4165                                        "register IRQ for vector %d.\n", i);
4166                                 for (j = 0 ; j < i ; j++)
4167                                         free_irq(
4168                                                 instance->msixentry[j].vector,
4169                                                 &instance->irq_context[j]);
4170                                 goto fail_irq;
4171                         }
4172                 }
4173         } else {
4174                 instance->irq_context[0].instance = instance;
4175                 instance->irq_context[0].MSIxIndex = 0;
4176                 if (request_irq(pdev->irq, instance->instancet->service_isr,
4177                                 IRQF_SHARED, "megasas",
4178                                 &instance->irq_context[0])) {
4179                         printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
4180                         goto fail_irq;
4181                 }
4182         }
4183
4184         instance->instancet->enable_intr(instance->reg_set);
4185
4186         /*
4187          * Store instance in PCI softstate
4188          */
4189         pci_set_drvdata(pdev, instance);
4190
4191         /*
4192          * Add this controller to megasas_mgmt_info structure so that it
4193          * can be exported to management applications
4194          */
4195         megasas_mgmt_info.count++;
4196         megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
4197         megasas_mgmt_info.max_index++;
4198
4199         /*
4200          * Register with SCSI mid-layer
4201          */
4202         if (megasas_io_attach(instance))
4203                 goto fail_io_attach;
4204
4205         instance->unload = 0;
4206
4207         /*
4208          * Initiate AEN (Asynchronous Event Notification)
4209          */
4210         if (megasas_start_aen(instance)) {
4211                 printk(KERN_DEBUG "megasas: start aen failed\n");
4212                 goto fail_start_aen;
4213         }
4214
4215         return 0;
4216
4217       fail_start_aen:
4218       fail_io_attach:
4219         megasas_mgmt_info.count--;
4220         megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
4221         megasas_mgmt_info.max_index--;
4222
4223         pci_set_drvdata(pdev, NULL);
4224         instance->instancet->disable_intr(instance->reg_set);
4225         if (instance->msix_vectors)
4226                 for (i = 0 ; i < instance->msix_vectors; i++)
4227                         free_irq(instance->msixentry[i].vector,
4228                                  &instance->irq_context[i]);
4229         else
4230                 free_irq(instance->pdev->irq, &instance->irq_context[0]);
4231 fail_irq:
4232         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
4233             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER))
4234                 megasas_release_fusion(instance);
4235         else
4236                 megasas_release_mfi(instance);
4237       fail_init_mfi:
4238         if (instance->msix_vectors)
4239                 pci_disable_msix(instance->pdev);
4240       fail_alloc_dma_buf:
4241         if (instance->evt_detail)
4242                 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
4243                                     instance->evt_detail,
4244                                     instance->evt_detail_h);
4245
4246         if (instance->producer)
4247                 pci_free_consistent(pdev, sizeof(u32), instance->producer,
4248                                     instance->producer_h);
4249         if (instance->consumer)
4250                 pci_free_consistent(pdev, sizeof(u32), instance->consumer,
4251                                     instance->consumer_h);
4252         scsi_host_put(host);
4253
4254       fail_alloc_instance:
4255       fail_set_dma_mask:
4256         pci_disable_device(pdev);
4257
4258         return -ENODEV;
4259 }
4260
4261 /**
4262  * megasas_flush_cache -        Requests FW to flush all its caches
4263  * @instance:                   Adapter soft state
4264  */
4265 static void megasas_flush_cache(struct megasas_instance *instance)
4266 {
4267         struct megasas_cmd *cmd;
4268         struct megasas_dcmd_frame *dcmd;
4269
4270         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
4271                 return;
4272
4273         cmd = megasas_get_cmd(instance);
4274
4275         if (!cmd)
4276                 return;
4277
4278         dcmd = &cmd->frame->dcmd;
4279
4280         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4281
4282         dcmd->cmd = MFI_CMD_DCMD;
4283         dcmd->cmd_status = 0x0;
4284         dcmd->sge_count = 0;
4285         dcmd->flags = MFI_FRAME_DIR_NONE;
4286         dcmd->timeout = 0;
4287         dcmd->pad_0 = 0;
4288         dcmd->data_xfer_len = 0;
4289         dcmd->opcode = MR_DCMD_CTRL_CACHE_FLUSH;
4290         dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
4291
4292         megasas_issue_blocked_cmd(instance, cmd);
4293
4294         megasas_return_cmd(instance, cmd);
4295
4296         return;
4297 }
4298
4299 /**
4300  * megasas_shutdown_controller -        Instructs FW to shutdown the controller
4301  * @instance:                           Adapter soft state
4302  * @opcode:                             Shutdown/Hibernate
4303  */
4304 static void megasas_shutdown_controller(struct megasas_instance *instance,
4305                                         u32 opcode)
4306 {
4307         struct megasas_cmd *cmd;
4308         struct megasas_dcmd_frame *dcmd;
4309
4310         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR)
4311                 return;
4312
4313         cmd = megasas_get_cmd(instance);
4314
4315         if (!cmd)
4316                 return;
4317
4318         if (instance->aen_cmd)
4319                 megasas_issue_blocked_abort_cmd(instance, instance->aen_cmd);
4320         if (instance->map_update_cmd)
4321                 megasas_issue_blocked_abort_cmd(instance,
4322                                                 instance->map_update_cmd);
4323         dcmd = &cmd->frame->dcmd;
4324
4325         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
4326
4327         dcmd->cmd = MFI_CMD_DCMD;
4328         dcmd->cmd_status = 0x0;
4329         dcmd->sge_count = 0;
4330         dcmd->flags = MFI_FRAME_DIR_NONE;
4331         dcmd->timeout = 0;
4332         dcmd->pad_0 = 0;
4333         dcmd->data_xfer_len = 0;
4334         dcmd->opcode = opcode;
4335
4336         megasas_issue_blocked_cmd(instance, cmd);
4337
4338         megasas_return_cmd(instance, cmd);
4339
4340         return;
4341 }
4342
4343 #ifdef CONFIG_PM
4344 /**
4345  * megasas_suspend -    driver suspend entry point
4346  * @pdev:               PCI device structure
4347  * @state:              PCI power state to suspend routine
4348  */
4349 static int
4350 megasas_suspend(struct pci_dev *pdev, pm_message_t state)
4351 {
4352         struct Scsi_Host *host;
4353         struct megasas_instance *instance;
4354         int i;
4355
4356         instance = pci_get_drvdata(pdev);
4357         host = instance->host;
4358         instance->unload = 1;
4359
4360         megasas_flush_cache(instance);
4361         megasas_shutdown_controller(instance, MR_DCMD_HIBERNATE_SHUTDOWN);
4362
4363         /* cancel the delayed work if this work still in queue */
4364         if (instance->ev != NULL) {
4365                 struct megasas_aen_event *ev = instance->ev;
4366                 cancel_delayed_work_sync(&ev->hotplug_work);
4367                 instance->ev = NULL;
4368         }
4369
4370         tasklet_kill(&instance->isr_tasklet);
4371
4372         pci_set_drvdata(instance->pdev, instance);
4373         instance->instancet->disable_intr(instance->reg_set);
4374
4375         if (instance->msix_vectors)
4376                 for (i = 0 ; i < instance->msix_vectors; i++)
4377                         free_irq(instance->msixentry[i].vector,
4378                                  &instance->irq_context[i]);
4379         else
4380                 free_irq(instance->pdev->irq, &instance->irq_context[0]);
4381         if (instance->msix_vectors)
4382                 pci_disable_msix(instance->pdev);
4383
4384         pci_save_state(pdev);
4385         pci_disable_device(pdev);
4386
4387         pci_set_power_state(pdev, pci_choose_state(pdev, state));
4388
4389         return 0;
4390 }
4391
4392 /**
4393  * megasas_resume-      driver resume entry point
4394  * @pdev:               PCI device structure
4395  */
4396 static int
4397 megasas_resume(struct pci_dev *pdev)
4398 {
4399         int rval, i, j;
4400         struct Scsi_Host *host;
4401         struct megasas_instance *instance;
4402
4403         instance = pci_get_drvdata(pdev);
4404         host = instance->host;
4405         pci_set_power_state(pdev, PCI_D0);
4406         pci_enable_wake(pdev, PCI_D0, 0);
4407         pci_restore_state(pdev);
4408
4409         /*
4410          * PCI prepping: enable device set bus mastering and dma mask
4411          */
4412         rval = pci_enable_device_mem(pdev);
4413
4414         if (rval) {
4415                 printk(KERN_ERR "megasas: Enable device failed\n");
4416                 return rval;
4417         }
4418
4419         pci_set_master(pdev);
4420
4421         if (megasas_set_dma_mask(pdev))
4422                 goto fail_set_dma_mask;
4423
4424         /*
4425          * Initialize MFI Firmware
4426          */
4427
4428         atomic_set(&instance->fw_outstanding, 0);
4429
4430         /*
4431          * We expect the FW state to be READY
4432          */
4433         if (megasas_transition_to_ready(instance, 0))
4434                 goto fail_ready_state;
4435
4436         /* Now re-enable MSI-X */
4437         if (instance->msix_vectors)
4438                 pci_enable_msix(instance->pdev, instance->msixentry,
4439                                 instance->msix_vectors);
4440
4441         switch (instance->pdev->device) {
4442         case PCI_DEVICE_ID_LSI_FUSION:
4443         case PCI_DEVICE_ID_LSI_INVADER:
4444         {
4445                 megasas_reset_reply_desc(instance);
4446                 if (megasas_ioc_init_fusion(instance)) {
4447                         megasas_free_cmds(instance);
4448                         megasas_free_cmds_fusion(instance);
4449                         goto fail_init_mfi;
4450                 }
4451                 if (!megasas_get_map_info(instance))
4452                         megasas_sync_map_info(instance);
4453         }
4454         break;
4455         default:
4456                 *instance->producer = 0;
4457                 *instance->consumer = 0;
4458                 if (megasas_issue_init_mfi(instance))
4459                         goto fail_init_mfi;
4460                 break;
4461         }
4462
4463         tasklet_init(&instance->isr_tasklet, instance->instancet->tasklet,
4464                      (unsigned long)instance);
4465
4466         /*
4467          * Register IRQ
4468          */
4469         if (instance->msix_vectors) {
4470                 for (i = 0 ; i < instance->msix_vectors; i++) {
4471                         instance->irq_context[i].instance = instance;
4472                         instance->irq_context[i].MSIxIndex = i;
4473                         if (request_irq(instance->msixentry[i].vector,
4474                                         instance->instancet->service_isr, 0,
4475                                         "megasas",
4476                                         &instance->irq_context[i])) {
4477                                 printk(KERN_DEBUG "megasas: Failed to "
4478                                        "register IRQ for vector %d.\n", i);
4479                                 for (j = 0 ; j < i ; j++)
4480                                         free_irq(
4481                                                 instance->msixentry[j].vector,
4482                                                 &instance->irq_context[j]);
4483                                 goto fail_irq;
4484                         }
4485                 }
4486         } else {
4487                 instance->irq_context[0].instance = instance;
4488                 instance->irq_context[0].MSIxIndex = 0;
4489                 if (request_irq(pdev->irq, instance->instancet->service_isr,
4490                                 IRQF_SHARED, "megasas",
4491                                 &instance->irq_context[0])) {
4492                         printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
4493                         goto fail_irq;
4494                 }
4495         }
4496
4497         instance->instancet->enable_intr(instance->reg_set);
4498         instance->unload = 0;
4499
4500         /*
4501          * Initiate AEN (Asynchronous Event Notification)
4502          */
4503         if (megasas_start_aen(instance))
4504                 printk(KERN_ERR "megasas: Start AEN failed\n");
4505
4506         return 0;
4507
4508 fail_irq:
4509 fail_init_mfi:
4510         if (instance->evt_detail)
4511                 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
4512                                 instance->evt_detail,
4513                                 instance->evt_detail_h);
4514
4515         if (instance->producer)
4516                 pci_free_consistent(pdev, sizeof(u32), instance->producer,
4517                                 instance->producer_h);
4518         if (instance->consumer)
4519                 pci_free_consistent(pdev, sizeof(u32), instance->consumer,
4520                                 instance->consumer_h);
4521         scsi_host_put(host);
4522
4523 fail_set_dma_mask:
4524 fail_ready_state:
4525
4526         pci_disable_device(pdev);
4527
4528         return -ENODEV;
4529 }
4530 #else
4531 #define megasas_suspend NULL
4532 #define megasas_resume  NULL
4533 #endif
4534
4535 /**
4536  * megasas_detach_one - PCI hot"un"plug entry point
4537  * @pdev:               PCI device structure
4538  */
4539 static void megasas_detach_one(struct pci_dev *pdev)
4540 {
4541         int i;
4542         struct Scsi_Host *host;
4543         struct megasas_instance *instance;
4544         struct fusion_context *fusion;
4545
4546         instance = pci_get_drvdata(pdev);
4547         instance->unload = 1;
4548         host = instance->host;
4549         fusion = instance->ctrl_context;
4550
4551         scsi_remove_host(instance->host);
4552         megasas_flush_cache(instance);
4553         megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
4554
4555         /* cancel the delayed work if this work still in queue*/
4556         if (instance->ev != NULL) {
4557                 struct megasas_aen_event *ev = instance->ev;
4558                 cancel_delayed_work_sync(&ev->hotplug_work);
4559                 instance->ev = NULL;
4560         }
4561
4562         tasklet_kill(&instance->isr_tasklet);
4563
4564         /*
4565          * Take the instance off the instance array. Note that we will not
4566          * decrement the max_index. We let this array be sparse array
4567          */
4568         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
4569                 if (megasas_mgmt_info.instance[i] == instance) {
4570                         megasas_mgmt_info.count--;
4571                         megasas_mgmt_info.instance[i] = NULL;
4572
4573                         break;
4574                 }
4575         }
4576
4577         pci_set_drvdata(instance->pdev, NULL);
4578
4579         instance->instancet->disable_intr(instance->reg_set);
4580
4581         if (instance->msix_vectors)
4582                 for (i = 0 ; i < instance->msix_vectors; i++)
4583                         free_irq(instance->msixentry[i].vector,
4584                                  &instance->irq_context[i]);
4585         else
4586                 free_irq(instance->pdev->irq, &instance->irq_context[0]);
4587         if (instance->msix_vectors)
4588                 pci_disable_msix(instance->pdev);
4589
4590         switch (instance->pdev->device) {
4591         case PCI_DEVICE_ID_LSI_FUSION:
4592         case PCI_DEVICE_ID_LSI_INVADER:
4593                 megasas_release_fusion(instance);
4594                 for (i = 0; i < 2 ; i++)
4595                         if (fusion->ld_map[i])
4596                                 dma_free_coherent(&instance->pdev->dev,
4597                                                   fusion->map_sz,
4598                                                   fusion->ld_map[i],
4599                                                   fusion->
4600                                                   ld_map_phys[i]);
4601                 kfree(instance->ctrl_context);
4602                 break;
4603         default:
4604                 megasas_release_mfi(instance);
4605                 pci_free_consistent(pdev,
4606                                     sizeof(struct megasas_evt_detail),
4607                                     instance->evt_detail,
4608                                     instance->evt_detail_h);
4609                 pci_free_consistent(pdev, sizeof(u32),
4610                                     instance->producer,
4611                                     instance->producer_h);
4612                 pci_free_consistent(pdev, sizeof(u32),
4613                                     instance->consumer,
4614                                     instance->consumer_h);
4615                 break;
4616         }
4617
4618         scsi_host_put(host);
4619
4620         pci_set_drvdata(pdev, NULL);
4621
4622         pci_disable_device(pdev);
4623
4624         return;
4625 }
4626
4627 /**
4628  * megasas_shutdown -   Shutdown entry point
4629  * @device:             Generic device structure
4630  */
4631 static void megasas_shutdown(struct pci_dev *pdev)
4632 {
4633         int i;
4634         struct megasas_instance *instance = pci_get_drvdata(pdev);
4635
4636         instance->unload = 1;
4637         megasas_flush_cache(instance);
4638         megasas_shutdown_controller(instance, MR_DCMD_CTRL_SHUTDOWN);
4639         instance->instancet->disable_intr(instance->reg_set);
4640         if (instance->msix_vectors)
4641                 for (i = 0 ; i < instance->msix_vectors; i++)
4642                         free_irq(instance->msixentry[i].vector,
4643                                  &instance->irq_context[i]);
4644         else
4645                 free_irq(instance->pdev->irq, &instance->irq_context[0]);
4646         if (instance->msix_vectors)
4647                 pci_disable_msix(instance->pdev);
4648 }
4649
4650 /**
4651  * megasas_mgmt_open -  char node "open" entry point
4652  */
4653 static int megasas_mgmt_open(struct inode *inode, struct file *filep)
4654 {
4655         /*
4656          * Allow only those users with admin rights
4657          */
4658         if (!capable(CAP_SYS_ADMIN))
4659                 return -EACCES;
4660
4661         return 0;
4662 }
4663
4664 /**
4665  * megasas_mgmt_fasync -        Async notifier registration from applications
4666  *
4667  * This function adds the calling process to a driver global queue. When an
4668  * event occurs, SIGIO will be sent to all processes in this queue.
4669  */
4670 static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)
4671 {
4672         int rc;
4673
4674         mutex_lock(&megasas_async_queue_mutex);
4675
4676         rc = fasync_helper(fd, filep, mode, &megasas_async_queue);
4677
4678         mutex_unlock(&megasas_async_queue_mutex);
4679
4680         if (rc >= 0) {
4681                 /* For sanity check when we get ioctl */
4682                 filep->private_data = filep;
4683                 return 0;
4684         }
4685
4686         printk(KERN_DEBUG "megasas: fasync_helper failed [%d]\n", rc);
4687
4688         return rc;
4689 }
4690
4691 /**
4692  * megasas_mgmt_poll -  char node "poll" entry point
4693  * */
4694 static unsigned int megasas_mgmt_poll(struct file *file, poll_table *wait)
4695 {
4696         unsigned int mask;
4697         unsigned long flags;
4698         poll_wait(file, &megasas_poll_wait, wait);
4699         spin_lock_irqsave(&poll_aen_lock, flags);
4700         if (megasas_poll_wait_aen)
4701                 mask =   (POLLIN | POLLRDNORM);
4702         else
4703                 mask = 0;
4704         spin_unlock_irqrestore(&poll_aen_lock, flags);
4705         return mask;
4706 }
4707
4708 /**
4709  * megasas_mgmt_fw_ioctl -      Issues management ioctls to FW
4710  * @instance:                   Adapter soft state
4711  * @argp:                       User's ioctl packet
4712  */
4713 static int
4714 megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
4715                       struct megasas_iocpacket __user * user_ioc,
4716                       struct megasas_iocpacket *ioc)
4717 {
4718         struct megasas_sge32 *kern_sge32;
4719         struct megasas_cmd *cmd;
4720         void *kbuff_arr[MAX_IOCTL_SGE];
4721         dma_addr_t buf_handle = 0;
4722         int error = 0, i;
4723         void *sense = NULL;
4724         dma_addr_t sense_handle;
4725         unsigned long *sense_ptr;
4726
4727         memset(kbuff_arr, 0, sizeof(kbuff_arr));
4728
4729         if (ioc->sge_count > MAX_IOCTL_SGE) {
4730                 printk(KERN_DEBUG "megasas: SGE count [%d] >  max limit [%d]\n",
4731                        ioc->sge_count, MAX_IOCTL_SGE);
4732                 return -EINVAL;
4733         }
4734
4735         cmd = megasas_get_cmd(instance);
4736         if (!cmd) {
4737                 printk(KERN_DEBUG "megasas: Failed to get a cmd packet\n");
4738                 return -ENOMEM;
4739         }
4740
4741         /*
4742          * User's IOCTL packet has 2 frames (maximum). Copy those two
4743          * frames into our cmd's frames. cmd->frame's context will get
4744          * overwritten when we copy from user's frames. So set that value
4745          * alone separately
4746          */
4747         memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE);
4748         cmd->frame->hdr.context = cmd->index;
4749         cmd->frame->hdr.pad_0 = 0;
4750         cmd->frame->hdr.flags &= ~(MFI_FRAME_IEEE | MFI_FRAME_SGL64 |
4751                                    MFI_FRAME_SENSE64);
4752
4753         /*
4754          * The management interface between applications and the fw uses
4755          * MFI frames. E.g, RAID configuration changes, LD property changes
4756          * etc are accomplishes through different kinds of MFI frames. The
4757          * driver needs to care only about substituting user buffers with
4758          * kernel buffers in SGLs. The location of SGL is embedded in the
4759          * struct iocpacket itself.
4760          */
4761         kern_sge32 = (struct megasas_sge32 *)
4762             ((unsigned long)cmd->frame + ioc->sgl_off);
4763
4764         /*
4765          * For each user buffer, create a mirror buffer and copy in
4766          */
4767         for (i = 0; i < ioc->sge_count; i++) {
4768                 if (!ioc->sgl[i].iov_len)
4769                         continue;
4770
4771                 kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev,
4772                                                     ioc->sgl[i].iov_len,
4773                                                     &buf_handle, GFP_KERNEL);
4774                 if (!kbuff_arr[i]) {
4775                         printk(KERN_DEBUG "megasas: Failed to alloc "
4776                                "kernel SGL buffer for IOCTL \n");
4777                         error = -ENOMEM;
4778                         goto out;
4779                 }
4780
4781                 /*
4782                  * We don't change the dma_coherent_mask, so
4783                  * pci_alloc_consistent only returns 32bit addresses
4784                  */
4785                 kern_sge32[i].phys_addr = (u32) buf_handle;
4786                 kern_sge32[i].length = ioc->sgl[i].iov_len;
4787
4788                 /*
4789                  * We created a kernel buffer corresponding to the
4790                  * user buffer. Now copy in from the user buffer
4791                  */
4792                 if (copy_from_user(kbuff_arr[i], ioc->sgl[i].iov_base,
4793                                    (u32) (ioc->sgl[i].iov_len))) {
4794                         error = -EFAULT;
4795                         goto out;
4796                 }
4797         }
4798
4799         if (ioc->sense_len) {
4800                 sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len,
4801                                              &sense_handle, GFP_KERNEL);
4802                 if (!sense) {
4803                         error = -ENOMEM;
4804                         goto out;
4805                 }
4806
4807                 sense_ptr =
4808                 (unsigned long *) ((unsigned long)cmd->frame + ioc->sense_off);
4809                 *sense_ptr = sense_handle;
4810         }
4811
4812         /*
4813          * Set the sync_cmd flag so that the ISR knows not to complete this
4814          * cmd to the SCSI mid-layer
4815          */
4816         cmd->sync_cmd = 1;
4817         megasas_issue_blocked_cmd(instance, cmd);
4818         cmd->sync_cmd = 0;
4819
4820         /*
4821          * copy out the kernel buffers to user buffers
4822          */
4823         for (i = 0; i < ioc->sge_count; i++) {
4824                 if (copy_to_user(ioc->sgl[i].iov_base, kbuff_arr[i],
4825                                  ioc->sgl[i].iov_len)) {
4826                         error = -EFAULT;
4827                         goto out;
4828                 }
4829         }
4830
4831         /*
4832          * copy out the sense
4833          */
4834         if (ioc->sense_len) {
4835                 /*
4836                  * sense_ptr points to the location that has the user
4837                  * sense buffer address
4838                  */
4839                 sense_ptr = (unsigned long *) ((unsigned long)ioc->frame.raw +
4840                                 ioc->sense_off);
4841
4842                 if (copy_to_user((void __user *)((unsigned long)(*sense_ptr)),
4843                                  sense, ioc->sense_len)) {
4844                         printk(KERN_ERR "megasas: Failed to copy out to user "
4845                                         "sense data\n");
4846                         error = -EFAULT;
4847                         goto out;
4848                 }
4849         }
4850
4851         /*
4852          * copy the status codes returned by the fw
4853          */
4854         if (copy_to_user(&user_ioc->frame.hdr.cmd_status,
4855                          &cmd->frame->hdr.cmd_status, sizeof(u8))) {
4856                 printk(KERN_DEBUG "megasas: Error copying out cmd_status\n");
4857                 error = -EFAULT;
4858         }
4859
4860       out:
4861         if (sense) {
4862                 dma_free_coherent(&instance->pdev->dev, ioc->sense_len,
4863                                     sense, sense_handle);
4864         }
4865
4866         for (i = 0; i < ioc->sge_count; i++) {
4867                 if (kbuff_arr[i])
4868                         dma_free_coherent(&instance->pdev->dev,
4869                                           kern_sge32[i].length,
4870                                           kbuff_arr[i],
4871                                           kern_sge32[i].phys_addr);
4872         }
4873
4874         megasas_return_cmd(instance, cmd);
4875         return error;
4876 }
4877
4878 static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
4879 {
4880         struct megasas_iocpacket __user *user_ioc =
4881             (struct megasas_iocpacket __user *)arg;
4882         struct megasas_iocpacket *ioc;
4883         struct megasas_instance *instance;
4884         int error;
4885         int i;
4886         unsigned long flags;
4887         u32 wait_time = MEGASAS_RESET_WAIT_TIME;
4888
4889         ioc = kmalloc(sizeof(*ioc), GFP_KERNEL);
4890         if (!ioc)
4891                 return -ENOMEM;
4892
4893         if (copy_from_user(ioc, user_ioc, sizeof(*ioc))) {
4894                 error = -EFAULT;
4895                 goto out_kfree_ioc;
4896         }
4897
4898         instance = megasas_lookup_instance(ioc->host_no);
4899         if (!instance) {
4900                 error = -ENODEV;
4901                 goto out_kfree_ioc;
4902         }
4903
4904         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
4905                 printk(KERN_ERR "Controller in crit error\n");
4906                 error = -ENODEV;
4907                 goto out_kfree_ioc;
4908         }
4909
4910         if (instance->unload == 1) {
4911                 error = -ENODEV;
4912                 goto out_kfree_ioc;
4913         }
4914
4915         /*
4916          * We will allow only MEGASAS_INT_CMDS number of parallel ioctl cmds
4917          */
4918         if (down_interruptible(&instance->ioctl_sem)) {
4919                 error = -ERESTARTSYS;
4920                 goto out_kfree_ioc;
4921         }
4922
4923         for (i = 0; i < wait_time; i++) {
4924
4925                 spin_lock_irqsave(&instance->hba_lock, flags);
4926                 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
4927                         spin_unlock_irqrestore(&instance->hba_lock, flags);
4928                         break;
4929                 }
4930                 spin_unlock_irqrestore(&instance->hba_lock, flags);
4931
4932                 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
4933                         printk(KERN_NOTICE "megasas: waiting"
4934                                 "for controller reset to finish\n");
4935                 }
4936
4937                 msleep(1000);
4938         }
4939
4940         spin_lock_irqsave(&instance->hba_lock, flags);
4941         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
4942                 spin_unlock_irqrestore(&instance->hba_lock, flags);
4943
4944                 printk(KERN_ERR "megaraid_sas: timed out while"
4945                         "waiting for HBA to recover\n");
4946                 error = -ENODEV;
4947                 goto out_up;
4948         }
4949         spin_unlock_irqrestore(&instance->hba_lock, flags);
4950
4951         error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
4952       out_up:
4953         up(&instance->ioctl_sem);
4954
4955       out_kfree_ioc:
4956         kfree(ioc);
4957         return error;
4958 }
4959
4960 static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
4961 {
4962         struct megasas_instance *instance;
4963         struct megasas_aen aen;
4964         int error;
4965         int i;
4966         unsigned long flags;
4967         u32 wait_time = MEGASAS_RESET_WAIT_TIME;
4968
4969         if (file->private_data != file) {
4970                 printk(KERN_DEBUG "megasas: fasync_helper was not "
4971                        "called first\n");
4972                 return -EINVAL;
4973         }
4974
4975         if (copy_from_user(&aen, (void __user *)arg, sizeof(aen)))
4976                 return -EFAULT;
4977
4978         instance = megasas_lookup_instance(aen.host_no);
4979
4980         if (!instance)
4981                 return -ENODEV;
4982
4983         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
4984                 return -ENODEV;
4985         }
4986
4987         if (instance->unload == 1) {
4988                 return -ENODEV;
4989         }
4990
4991         for (i = 0; i < wait_time; i++) {
4992
4993                 spin_lock_irqsave(&instance->hba_lock, flags);
4994                 if (instance->adprecovery == MEGASAS_HBA_OPERATIONAL) {
4995                         spin_unlock_irqrestore(&instance->hba_lock,
4996                                                 flags);
4997                         break;
4998                 }
4999
5000                 spin_unlock_irqrestore(&instance->hba_lock, flags);
5001
5002                 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
5003                         printk(KERN_NOTICE "megasas: waiting for"
5004                                 "controller reset to finish\n");
5005                 }
5006
5007                 msleep(1000);
5008         }
5009
5010         spin_lock_irqsave(&instance->hba_lock, flags);
5011         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
5012                 spin_unlock_irqrestore(&instance->hba_lock, flags);
5013                 printk(KERN_ERR "megaraid_sas: timed out while waiting"
5014                                 "for HBA to recover.\n");
5015                 return -ENODEV;
5016         }
5017         spin_unlock_irqrestore(&instance->hba_lock, flags);
5018
5019         mutex_lock(&instance->aen_mutex);
5020         error = megasas_register_aen(instance, aen.seq_num,
5021                                      aen.class_locale_word);
5022         mutex_unlock(&instance->aen_mutex);
5023         return error;
5024 }
5025
5026 /**
5027  * megasas_mgmt_ioctl - char node ioctl entry point
5028  */
5029 static long
5030 megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
5031 {
5032         switch (cmd) {
5033         case MEGASAS_IOC_FIRMWARE:
5034                 return megasas_mgmt_ioctl_fw(file, arg);
5035
5036         case MEGASAS_IOC_GET_AEN:
5037                 return megasas_mgmt_ioctl_aen(file, arg);
5038         }
5039
5040         return -ENOTTY;
5041 }
5042
5043 #ifdef CONFIG_COMPAT
5044 static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
5045 {
5046         struct compat_megasas_iocpacket __user *cioc =
5047             (struct compat_megasas_iocpacket __user *)arg;
5048         struct megasas_iocpacket __user *ioc =
5049             compat_alloc_user_space(sizeof(struct megasas_iocpacket));
5050         int i;
5051         int error = 0;
5052         compat_uptr_t ptr;
5053
5054         if (clear_user(ioc, sizeof(*ioc)))
5055                 return -EFAULT;
5056
5057         if (copy_in_user(&ioc->host_no, &cioc->host_no, sizeof(u16)) ||
5058             copy_in_user(&ioc->sgl_off, &cioc->sgl_off, sizeof(u32)) ||
5059             copy_in_user(&ioc->sense_off, &cioc->sense_off, sizeof(u32)) ||
5060             copy_in_user(&ioc->sense_len, &cioc->sense_len, sizeof(u32)) ||
5061             copy_in_user(ioc->frame.raw, cioc->frame.raw, 128) ||
5062             copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32)))
5063                 return -EFAULT;
5064
5065         /*
5066          * The sense_ptr is used in megasas_mgmt_fw_ioctl only when
5067          * sense_len is not null, so prepare the 64bit value under
5068          * the same condition.
5069          */
5070         if (ioc->sense_len) {
5071                 void __user **sense_ioc_ptr =
5072                         (void __user **)(ioc->frame.raw + ioc->sense_off);
5073                 compat_uptr_t *sense_cioc_ptr =
5074                         (compat_uptr_t *)(cioc->frame.raw + cioc->sense_off);
5075                 if (get_user(ptr, sense_cioc_ptr) ||
5076                     put_user(compat_ptr(ptr), sense_ioc_ptr))
5077                         return -EFAULT;
5078         }
5079
5080         for (i = 0; i < MAX_IOCTL_SGE; i++) {
5081                 if (get_user(ptr, &cioc->sgl[i].iov_base) ||
5082                     put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) ||
5083                     copy_in_user(&ioc->sgl[i].iov_len,
5084                                  &cioc->sgl[i].iov_len, sizeof(compat_size_t)))
5085                         return -EFAULT;
5086         }
5087
5088         error = megasas_mgmt_ioctl_fw(file, (unsigned long)ioc);
5089
5090         if (copy_in_user(&cioc->frame.hdr.cmd_status,
5091                          &ioc->frame.hdr.cmd_status, sizeof(u8))) {
5092                 printk(KERN_DEBUG "megasas: error copy_in_user cmd_status\n");
5093                 return -EFAULT;
5094         }
5095         return error;
5096 }
5097
5098 static long
5099 megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd,
5100                           unsigned long arg)
5101 {
5102         switch (cmd) {
5103         case MEGASAS_IOC_FIRMWARE32:
5104                 return megasas_mgmt_compat_ioctl_fw(file, arg);
5105         case MEGASAS_IOC_GET_AEN:
5106                 return megasas_mgmt_ioctl_aen(file, arg);
5107         }
5108
5109         return -ENOTTY;
5110 }
5111 #endif
5112
5113 /*
5114  * File operations structure for management interface
5115  */
5116 static const struct file_operations megasas_mgmt_fops = {
5117         .owner = THIS_MODULE,
5118         .open = megasas_mgmt_open,
5119         .fasync = megasas_mgmt_fasync,
5120         .unlocked_ioctl = megasas_mgmt_ioctl,
5121         .poll = megasas_mgmt_poll,
5122 #ifdef CONFIG_COMPAT
5123         .compat_ioctl = megasas_mgmt_compat_ioctl,
5124 #endif
5125         .llseek = noop_llseek,
5126 };
5127
5128 /*
5129  * PCI hotplug support registration structure
5130  */
5131 static struct pci_driver megasas_pci_driver = {
5132
5133         .name = "megaraid_sas",
5134         .id_table = megasas_pci_table,
5135         .probe = megasas_probe_one,
5136         .remove = megasas_detach_one,
5137         .suspend = megasas_suspend,
5138         .resume = megasas_resume,
5139         .shutdown = megasas_shutdown,
5140 };
5141
5142 /*
5143  * Sysfs driver attributes
5144  */
5145 static ssize_t megasas_sysfs_show_version(struct device_driver *dd, char *buf)
5146 {
5147         return snprintf(buf, strlen(MEGASAS_VERSION) + 2, "%s\n",
5148                         MEGASAS_VERSION);
5149 }
5150
5151 static DRIVER_ATTR(version, S_IRUGO, megasas_sysfs_show_version, NULL);
5152
5153 static ssize_t
5154 megasas_sysfs_show_release_date(struct device_driver *dd, char *buf)
5155 {
5156         return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, "%s\n",
5157                         MEGASAS_RELDATE);
5158 }
5159
5160 static DRIVER_ATTR(release_date, S_IRUGO, megasas_sysfs_show_release_date,
5161                    NULL);
5162
5163 static ssize_t
5164 megasas_sysfs_show_support_poll_for_event(struct device_driver *dd, char *buf)
5165 {
5166         return sprintf(buf, "%u\n", support_poll_for_event);
5167 }
5168
5169 static DRIVER_ATTR(support_poll_for_event, S_IRUGO,
5170                         megasas_sysfs_show_support_poll_for_event, NULL);
5171
5172  static ssize_t
5173 megasas_sysfs_show_support_device_change(struct device_driver *dd, char *buf)
5174 {
5175         return sprintf(buf, "%u\n", support_device_change);
5176 }
5177
5178 static DRIVER_ATTR(support_device_change, S_IRUGO,
5179                         megasas_sysfs_show_support_device_change, NULL);
5180
5181 static ssize_t
5182 megasas_sysfs_show_dbg_lvl(struct device_driver *dd, char *buf)
5183 {
5184         return sprintf(buf, "%u\n", megasas_dbg_lvl);
5185 }
5186
5187 static ssize_t
5188 megasas_sysfs_set_dbg_lvl(struct device_driver *dd, const char *buf, size_t count)
5189 {
5190         int retval = count;
5191         if(sscanf(buf,"%u",&megasas_dbg_lvl)<1){
5192                 printk(KERN_ERR "megasas: could not set dbg_lvl\n");
5193                 retval = -EINVAL;
5194         }
5195         return retval;
5196 }
5197
5198 static DRIVER_ATTR(dbg_lvl, S_IRUGO|S_IWUSR, megasas_sysfs_show_dbg_lvl,
5199                 megasas_sysfs_set_dbg_lvl);
5200
5201 static void
5202 megasas_aen_polling(struct work_struct *work)
5203 {
5204         struct megasas_aen_event *ev =
5205                 container_of(work, struct megasas_aen_event, hotplug_work.work);
5206         struct megasas_instance *instance = ev->instance;
5207         union megasas_evt_class_locale class_locale;
5208         struct  Scsi_Host *host;
5209         struct  scsi_device *sdev1;
5210         u16     pd_index = 0;
5211         u16     ld_index = 0;
5212         int     i, j, doscan = 0;
5213         u32 seq_num;
5214         int error;
5215
5216         if (!instance) {
5217                 printk(KERN_ERR "invalid instance!\n");
5218                 kfree(ev);
5219                 return;
5220         }
5221         instance->ev = NULL;
5222         host = instance->host;
5223         if (instance->evt_detail) {
5224
5225                 switch (instance->evt_detail->code) {
5226                 case MR_EVT_PD_INSERTED:
5227                         if (megasas_get_pd_list(instance) == 0) {
5228                         for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
5229                                 for (j = 0;
5230                                 j < MEGASAS_MAX_DEV_PER_CHANNEL;
5231                                 j++) {
5232
5233                                 pd_index =
5234                                 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
5235
5236                                 sdev1 =
5237                                 scsi_device_lookup(host, i, j, 0);
5238
5239                                 if (instance->pd_list[pd_index].driveState
5240                                                 == MR_PD_STATE_SYSTEM) {
5241                                                 if (!sdev1) {
5242                                                 scsi_add_device(host, i, j, 0);
5243                                                 }
5244
5245                                         if (sdev1)
5246                                                 scsi_device_put(sdev1);
5247                                         }
5248                                 }
5249                         }
5250                         }
5251                         doscan = 0;
5252                         break;
5253
5254                 case MR_EVT_PD_REMOVED:
5255                         if (megasas_get_pd_list(instance) == 0) {
5256                         for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
5257                                 for (j = 0;
5258                                 j < MEGASAS_MAX_DEV_PER_CHANNEL;
5259                                 j++) {
5260
5261                                 pd_index =
5262                                 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
5263
5264                                 sdev1 =
5265                                 scsi_device_lookup(host, i, j, 0);
5266
5267                                 if (instance->pd_list[pd_index].driveState
5268                                         == MR_PD_STATE_SYSTEM) {
5269                                         if (sdev1) {
5270                                                 scsi_device_put(sdev1);
5271                                         }
5272                                 } else {
5273                                         if (sdev1) {
5274                                                 scsi_remove_device(sdev1);
5275                                                 scsi_device_put(sdev1);
5276                                         }
5277                                 }
5278                                 }
5279                         }
5280                         }
5281                         doscan = 0;
5282                         break;
5283
5284                 case MR_EVT_LD_OFFLINE:
5285                 case MR_EVT_CFG_CLEARED:
5286                 case MR_EVT_LD_DELETED:
5287                         megasas_get_ld_list(instance);
5288                         for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
5289                                 for (j = 0;
5290                                 j < MEGASAS_MAX_DEV_PER_CHANNEL;
5291                                 j++) {
5292
5293                                 ld_index =
5294                                 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
5295
5296                                 sdev1 = scsi_device_lookup(host,
5297                                         i + MEGASAS_MAX_LD_CHANNELS,
5298                                         j,
5299                                         0);
5300
5301                                 if (instance->ld_ids[ld_index] != 0xff) {
5302                                         if (sdev1) {
5303                                                 scsi_device_put(sdev1);
5304                                         }
5305                                 } else {
5306                                         if (sdev1) {
5307                                                 scsi_remove_device(sdev1);
5308                                                 scsi_device_put(sdev1);
5309                                         }
5310                                 }
5311                                 }
5312                         }
5313                         doscan = 0;
5314                         break;
5315                 case MR_EVT_LD_CREATED:
5316                         megasas_get_ld_list(instance);
5317                         for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
5318                                 for (j = 0;
5319                                         j < MEGASAS_MAX_DEV_PER_CHANNEL;
5320                                         j++) {
5321                                         ld_index =
5322                                         (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
5323
5324                                         sdev1 = scsi_device_lookup(host,
5325                                                 i+MEGASAS_MAX_LD_CHANNELS,
5326                                                 j, 0);
5327
5328                                         if (instance->ld_ids[ld_index] !=
5329                                                                 0xff) {
5330                                                 if (!sdev1) {
5331                                                         scsi_add_device(host,
5332                                                                 i + 2,
5333                                                                 j, 0);
5334                                                 }
5335                                         }
5336                                         if (sdev1) {
5337                                                 scsi_device_put(sdev1);
5338                                         }
5339                                 }
5340                         }
5341                         doscan = 0;
5342                         break;
5343                 case MR_EVT_CTRL_HOST_BUS_SCAN_REQUESTED:
5344                 case MR_EVT_FOREIGN_CFG_IMPORTED:
5345                 case MR_EVT_LD_STATE_CHANGE:
5346                         doscan = 1;
5347                         break;
5348                 default:
5349                         doscan = 0;
5350                         break;
5351                 }
5352         } else {
5353                 printk(KERN_ERR "invalid evt_detail!\n");
5354                 kfree(ev);
5355                 return;
5356         }
5357
5358         if (doscan) {
5359                 printk(KERN_INFO "scanning ...\n");
5360                 megasas_get_pd_list(instance);
5361                 for (i = 0; i < MEGASAS_MAX_PD_CHANNELS; i++) {
5362                         for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
5363                                 pd_index = i*MEGASAS_MAX_DEV_PER_CHANNEL + j;
5364                                 sdev1 = scsi_device_lookup(host, i, j, 0);
5365                                 if (instance->pd_list[pd_index].driveState ==
5366                                                         MR_PD_STATE_SYSTEM) {
5367                                         if (!sdev1) {
5368                                                 scsi_add_device(host, i, j, 0);
5369                                         }
5370                                         if (sdev1)
5371                                                 scsi_device_put(sdev1);
5372                                 } else {
5373                                         if (sdev1) {
5374                                                 scsi_remove_device(sdev1);
5375                                                 scsi_device_put(sdev1);
5376                                         }
5377                                 }
5378                         }
5379                 }
5380
5381                 megasas_get_ld_list(instance);
5382                 for (i = 0; i < MEGASAS_MAX_LD_CHANNELS; i++) {
5383                         for (j = 0; j < MEGASAS_MAX_DEV_PER_CHANNEL; j++) {
5384                                 ld_index =
5385                                 (i * MEGASAS_MAX_DEV_PER_CHANNEL) + j;
5386
5387                                 sdev1 = scsi_device_lookup(host,
5388                                         i+MEGASAS_MAX_LD_CHANNELS, j, 0);
5389                                 if (instance->ld_ids[ld_index] != 0xff) {
5390                                         if (!sdev1) {
5391                                                 scsi_add_device(host,
5392                                                                 i+2,
5393                                                                 j, 0);
5394                                         } else {
5395                                                 scsi_device_put(sdev1);
5396                                         }
5397                                 } else {
5398                                         if (sdev1) {
5399                                                 scsi_remove_device(sdev1);
5400                                                 scsi_device_put(sdev1);
5401                                         }
5402                                 }
5403                         }
5404                 }
5405         }
5406
5407         if ( instance->aen_cmd != NULL ) {
5408                 kfree(ev);
5409                 return ;
5410         }
5411
5412         seq_num = instance->evt_detail->seq_num + 1;
5413
5414         /* Register AEN with FW for latest sequence number plus 1 */
5415         class_locale.members.reserved = 0;
5416         class_locale.members.locale = MR_EVT_LOCALE_ALL;
5417         class_locale.members.class = MR_EVT_CLASS_DEBUG;
5418         mutex_lock(&instance->aen_mutex);
5419         error = megasas_register_aen(instance, seq_num,
5420                                         class_locale.word);
5421         mutex_unlock(&instance->aen_mutex);
5422
5423         if (error)
5424                 printk(KERN_ERR "register aen failed error %x\n", error);
5425
5426         kfree(ev);
5427 }
5428
5429 /**
5430  * megasas_init - Driver load entry point
5431  */
5432 static int __init megasas_init(void)
5433 {
5434         int rval;
5435
5436         /*
5437          * Announce driver version and other information
5438          */
5439         printk(KERN_INFO "megasas: %s %s\n", MEGASAS_VERSION,
5440                MEGASAS_EXT_VERSION);
5441
5442         spin_lock_init(&poll_aen_lock);
5443
5444         support_poll_for_event = 2;
5445         support_device_change = 1;
5446
5447         memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info));
5448
5449         /*
5450          * Register character device node
5451          */
5452         rval = register_chrdev(0, "megaraid_sas_ioctl", &megasas_mgmt_fops);
5453
5454         if (rval < 0) {
5455                 printk(KERN_DEBUG "megasas: failed to open device node\n");
5456                 return rval;
5457         }
5458
5459         megasas_mgmt_majorno = rval;
5460
5461         /*
5462          * Register ourselves as PCI hotplug module
5463          */
5464         rval = pci_register_driver(&megasas_pci_driver);
5465
5466         if (rval) {
5467                 printk(KERN_DEBUG "megasas: PCI hotplug regisration failed \n");
5468                 goto err_pcidrv;
5469         }
5470
5471         rval = driver_create_file(&megasas_pci_driver.driver,
5472                                   &driver_attr_version);
5473         if (rval)
5474                 goto err_dcf_attr_ver;
5475         rval = driver_create_file(&megasas_pci_driver.driver,
5476                                   &driver_attr_release_date);
5477         if (rval)
5478                 goto err_dcf_rel_date;
5479
5480         rval = driver_create_file(&megasas_pci_driver.driver,
5481                                 &driver_attr_support_poll_for_event);
5482         if (rval)
5483                 goto err_dcf_support_poll_for_event;
5484
5485         rval = driver_create_file(&megasas_pci_driver.driver,
5486                                   &driver_attr_dbg_lvl);
5487         if (rval)
5488                 goto err_dcf_dbg_lvl;
5489         rval = driver_create_file(&megasas_pci_driver.driver,
5490                                 &driver_attr_support_device_change);
5491         if (rval)
5492                 goto err_dcf_support_device_change;
5493
5494         return rval;
5495
5496 err_dcf_support_device_change:
5497         driver_remove_file(&megasas_pci_driver.driver,
5498                            &driver_attr_dbg_lvl);
5499 err_dcf_dbg_lvl:
5500         driver_remove_file(&megasas_pci_driver.driver,
5501                         &driver_attr_support_poll_for_event);
5502
5503 err_dcf_support_poll_for_event:
5504         driver_remove_file(&megasas_pci_driver.driver,
5505                            &driver_attr_release_date);
5506
5507 err_dcf_rel_date:
5508         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
5509 err_dcf_attr_ver:
5510         pci_unregister_driver(&megasas_pci_driver);
5511 err_pcidrv:
5512         unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
5513         return rval;
5514 }
5515
5516 /**
5517  * megasas_exit - Driver unload entry point
5518  */
5519 static void __exit megasas_exit(void)
5520 {
5521         driver_remove_file(&megasas_pci_driver.driver,
5522                            &driver_attr_dbg_lvl);
5523         driver_remove_file(&megasas_pci_driver.driver,
5524                         &driver_attr_support_poll_for_event);
5525         driver_remove_file(&megasas_pci_driver.driver,
5526                         &driver_attr_support_device_change);
5527         driver_remove_file(&megasas_pci_driver.driver,
5528                            &driver_attr_release_date);
5529         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
5530
5531         pci_unregister_driver(&megasas_pci_driver);
5532         unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
5533 }
5534
5535 module_init(megasas_init);
5536 module_exit(megasas_exit);