drivers/scsi/megaraid/megaraid_sas_base.c

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