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.06.12-rc1
  22  *
  23  *  Authors: LSI Corporation
  24  *           Sreenivas Bagalkote
  25  *           Sumant Patro
  26  *           Bo Yang
  27  *           Adam Radford <linuxraid@lsi.com>
  28  *
  29  *  Send feedback to: <megaraidlinux@lsi.com>
  30  *
  31  *  Mail to: LSI Corporation, 1621 Barber Lane, Milpitas, CA 95035
  32  *     ATTN: Linuxraid
  33  */
  34
  35 #include <linux/kernel.h>
  36 #include <linux/types.h>
  37 #include <linux/pci.h>
  38 #include <linux/list.h>
  39 #include <linux/moduleparam.h>
  40 #include <linux/module.h>
  41 #include <linux/spinlock.h>
  42 #include <linux/interrupt.h>
  43 #include <linux/delay.h>
  44 #include <linux/uio.h>
  45 #include <linux/slab.h>
  46 #include <asm/uaccess.h>
  47 #include <linux/fs.h>
  48 #include <linux/compat.h>
  49 #include <linux/blkdev.h>
  50 #include <linux/mutex.h>
  51 #include <linux/poll.h>
  52
  53 #include <scsi/scsi.h>
  54 #include <scsi/scsi_cmnd.h>
  55 #include <scsi/scsi_device.h>
  56 #include <scsi/scsi_host.h>
  57 #include <scsi/scsi_tcq.h>
  58 #include "megaraid_sas_fusion.h"
  59 #include "megaraid_sas.h"
  60
  61 /*
  62  * poll_mode_io:1- schedule complete completion from q cmd
  63  */
  64 static unsigned int poll_mode_io;
  65 module_param_named(poll_mode_io, poll_mode_io, int, 0);
  66 MODULE_PARM_DESC(poll_mode_io,
  67         "Complete cmds from IO path, (default=0)");
  68
  69 /*
  70  * Number of sectors per IO command
  71  * Will be set in megasas_init_mfi if user does not provide
  72  */
  73 static unsigned int max_sectors;
  74 module_param_named(max_sectors, max_sectors, int, 0);
  75 MODULE_PARM_DESC(max_sectors,
  76         "Maximum number of sectors per IO command");
  77
  78 static int msix_disable;
  79 module_param(msix_disable, int, S_IRUGO);
  80 MODULE_PARM_DESC(msix_disable, "Disable MSI-X interrupt handling. Default: 0");
  81
  82 MODULE_LICENSE("GPL");
  83 MODULE_VERSION(MEGASAS_VERSION);
  84 MODULE_AUTHOR("megaraidlinux@lsi.com");
  85 MODULE_DESCRIPTION("LSI MegaRAID SAS Driver");
  86
  87 int megasas_transition_to_ready(struct megasas_instance *instance, int ocr);
  88 static int megasas_get_pd_list(struct megasas_instance *instance);
  89 static int megasas_issue_init_mfi(struct megasas_instance *instance);
  90 static int megasas_register_aen(struct megasas_instance *instance,
  91                                 u32 seq_num, u32 class_locale_word);
  92 /*
  93  * PCI ID table for all supported controllers
  94  */
  95 static struct pci_device_id megasas_pci_table[] = {
  96
  97         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064R)},
  98         /* xscale IOP */
  99         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078R)},
 100         /* ppc IOP */
 101         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078DE)},
 102         /* ppc IOP */
 103         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078GEN2)},
 104         /* gen2*/
 105         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0079GEN2)},
 106         /* gen2*/
 107         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0073SKINNY)},
 108         /* skinny*/
 109         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS0071SKINNY)},
 110         /* skinny*/
 111         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)},
 112         /* xscale IOP, vega */
 113         {PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},
 114         /* xscale IOP */
 115         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_FUSION)},
 116         /* Fusion */
 117         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_INVADER)},
 118         /* Invader */
 119         {}
 120 };
 121
 122 MODULE_DEVICE_TABLE(pci, megasas_pci_table);
 123
 124 static int megasas_mgmt_majorno;
 125 static struct megasas_mgmt_info megasas_mgmt_info;
 126 static struct fasync_struct *megasas_async_queue;
 127 static DEFINE_MUTEX(megasas_async_queue_mutex);
 128
 129 static int megasas_poll_wait_aen;
 130 static DECLARE_WAIT_QUEUE_HEAD(megasas_poll_wait);
 131 static u32 support_poll_for_event;
 132 u32 megasas_dbg_lvl;
 133 static u32 support_device_change;
 134
 135 /* define lock for aen poll */
 136 spinlock_t poll_aen_lock;
 137
 138 void
 139 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
 140                      u8 alt_status);
 141 static u32
 142 megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs);
 143 static int
 144 megasas_adp_reset_gen2(struct megasas_instance *instance,
 145                        struct megasas_register_set __iomem *reg_set);
 146 static irqreturn_t megasas_isr(int irq, void *devp);
 147 static u32
 148 megasas_init_adapter_mfi(struct megasas_instance *instance);
 149 u32
 150 megasas_build_and_issue_cmd(struct megasas_instance *instance,
 151                             struct scsi_cmnd *scmd);
 152 static void megasas_complete_cmd_dpc(unsigned long instance_addr);
 153 void
 154 megasas_release_fusion(struct megasas_instance *instance);
 155 int
 156 megasas_ioc_init_fusion(struct megasas_instance *instance);
 157 void
 158 megasas_free_cmds_fusion(struct megasas_instance *instance);
 159 u8
 160 megasas_get_map_info(struct megasas_instance *instance);
 161 int
 162 megasas_sync_map_info(struct megasas_instance *instance);
 163 int
 164 wait_and_poll(struct megasas_instance *instance, struct megasas_cmd *cmd);
 165 void megasas_reset_reply_desc(struct megasas_instance *instance);
 166 u8 MR_ValidateMapInfo(struct MR_FW_RAID_MAP_ALL *map,
 167                       struct LD_LOAD_BALANCE_INFO *lbInfo);
 168 int megasas_reset_fusion(struct Scsi_Host *shost);
 169 void megasas_fusion_ocr_wq(struct work_struct *work);
 170
 171 void
 172 megasas_issue_dcmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
 173 {
 174         instance->instancet->fire_cmd(instance,
 175                 cmd->frame_phys_addr, 0, instance->reg_set);
 176 }
 177
 178 /**
 179  * megasas_get_cmd -    Get a command from the free pool
 180  * @instance:           Adapter soft state
 181  *
 182  * Returns a free command from the pool
 183  */
 184 struct megasas_cmd *megasas_get_cmd(struct megasas_instance
 185                                                   *instance)
 186 {
 187         unsigned long flags;
 188         struct megasas_cmd *cmd = NULL;
 189
 190         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
 191
 192         if (!list_empty(&instance->cmd_pool)) {
 193                 cmd = list_entry((&instance->cmd_pool)->next,
 194                                  struct megasas_cmd, list);
 195                 list_del_init(&cmd->list);
 196         } else {
 197                 printk(KERN_ERR "megasas: Command pool empty!\n");
 198         }
 199
 200         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
 201         return cmd;
 202 }
 203
 204 /**
 205  * megasas_return_cmd - Return a cmd to free command pool
 206  * @instance:           Adapter soft state
 207  * @cmd:                Command packet to be returned to free command pool
 208  */
 209 inline void
 210 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
 211 {
 212         unsigned long flags;
 213
 214         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
 215
 216         cmd->scmd = NULL;
 217         cmd->frame_count = 0;
 218         if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) &&
 219             (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) &&
 220             (reset_devices))
 221                 cmd->frame->hdr.cmd = MFI_CMD_INVALID;
 222         list_add_tail(&cmd->list, &instance->cmd_pool);
 223
 224         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
 225 }
 226
 227
 228 /**
 229 *       The following functions are defined for xscale
 230 *       (deviceid : 1064R, PERC5) controllers
 231 */
 232
 233 /**
 234  * megasas_enable_intr_xscale - Enables interrupts
 235  * @regs:                       MFI register set
 236  */
 237 static inline void
 238 megasas_enable_intr_xscale(struct megasas_register_set __iomem * regs)
 239 {
 240         writel(0, &(regs)->outbound_intr_mask);
 241
 242         /* Dummy readl to force pci flush */
 243         readl(&regs->outbound_intr_mask);
 244 }
 245
 246 /**
 247  * megasas_disable_intr_xscale -Disables interrupt
 248  * @regs:                       MFI register set
 249  */
 250 static inline void
 251 megasas_disable_intr_xscale(struct megasas_register_set __iomem * regs)
 252 {
 253         u32 mask = 0x1f;
 254         writel(mask, &regs->outbound_intr_mask);
 255         /* Dummy readl to force pci flush */
 256         readl(&regs->outbound_intr_mask);
 257 }
 258
 259 /**
 260  * megasas_read_fw_status_reg_xscale - returns the current FW status value
 261  * @regs:                       MFI register set
 262  */
 263 static u32
 264 megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem * regs)
 265 {
 266         return readl(&(regs)->outbound_msg_0);
 267 }
 268 /**
 269  * megasas_clear_interrupt_xscale -     Check & clear interrupt
 270  * @regs:                               MFI register set
 271  */
 272 static int
 273 megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs)
 274 {
 275         u32 status;
 276         u32 mfiStatus = 0;
 277         /*
 278          * Check if it is our interrupt
 279          */
 280         status = readl(&regs->outbound_intr_status);
 281
 282         if (status & MFI_OB_INTR_STATUS_MASK)
 283                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 284         if (status & MFI_XSCALE_OMR0_CHANGE_INTERRUPT)
 285                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 286
 287         /*
 288          * Clear the interrupt by writing back the same value
 289          */
 290         if (mfiStatus)
 291                 writel(status, &regs->outbound_intr_status);
 292
 293         /* Dummy readl to force pci flush */
 294         readl(&regs->outbound_intr_status);
 295
 296         return mfiStatus;
 297 }
 298
 299 /**
 300  * megasas_fire_cmd_xscale -    Sends command to the FW
 301  * @frame_phys_addr :           Physical address of cmd
 302  * @frame_count :               Number of frames for the command
 303  * @regs :                      MFI register set
 304  */
 305 static inline void
 306 megasas_fire_cmd_xscale(struct megasas_instance *instance,
 307                 dma_addr_t frame_phys_addr,
 308                 u32 frame_count,
 309                 struct megasas_register_set __iomem *regs)
 310 {
 311         unsigned long flags;
 312         spin_lock_irqsave(&instance->hba_lock, flags);
 313         writel((frame_phys_addr >> 3)|(frame_count),
 314                &(regs)->inbound_queue_port);
 315         spin_unlock_irqrestore(&instance->hba_lock, flags);
 316 }
 317
 318 /**
 319  * megasas_adp_reset_xscale -  For controller reset
 320  * @regs:                              MFI register set
 321  */
 322 static int
 323 megasas_adp_reset_xscale(struct megasas_instance *instance,
 324         struct megasas_register_set __iomem *regs)
 325 {
 326         u32 i;
 327         u32 pcidata;
 328         writel(MFI_ADP_RESET, &regs->inbound_doorbell);
 329
 330         for (i = 0; i < 3; i++)
 331                 msleep(1000); /* sleep for 3 secs */
 332         pcidata  = 0;
 333         pci_read_config_dword(instance->pdev, MFI_1068_PCSR_OFFSET, &pcidata);
 334         printk(KERN_NOTICE "pcidata = %x\n", pcidata);
 335         if (pcidata & 0x2) {
 336                 printk(KERN_NOTICE "mfi 1068 offset read=%x\n", pcidata);
 337                 pcidata &= ~0x2;
 338                 pci_write_config_dword(instance->pdev,
 339                                 MFI_1068_PCSR_OFFSET, pcidata);
 340
 341                 for (i = 0; i < 2; i++)
 342                         msleep(1000); /* need to wait 2 secs again */
 343
 344                 pcidata  = 0;
 345                 pci_read_config_dword(instance->pdev,
 346                                 MFI_1068_FW_HANDSHAKE_OFFSET, &pcidata);
 347                 printk(KERN_NOTICE "1068 offset handshake read=%x\n", pcidata);
 348                 if ((pcidata & 0xffff0000) == MFI_1068_FW_READY) {
 349                         printk(KERN_NOTICE "1068 offset pcidt=%x\n", pcidata);
 350                         pcidata = 0;
 351                         pci_write_config_dword(instance->pdev,
 352                                 MFI_1068_FW_HANDSHAKE_OFFSET, pcidata);
 353                 }
 354         }
 355         return 0;
 356 }
 357
 358 /**
 359  * megasas_check_reset_xscale - For controller reset check
 360  * @regs:                               MFI register set
 361  */
 362 static int
 363 megasas_check_reset_xscale(struct megasas_instance *instance,
 364                 struct megasas_register_set __iomem *regs)
 365 {
 366         u32 consumer;
 367         consumer = *instance->consumer;
 368
 369         if ((instance->adprecovery != MEGASAS_HBA_OPERATIONAL) &&
 370                 (*instance->consumer == MEGASAS_ADPRESET_INPROG_SIGN)) {
 371                 return 1;
 372         }
 373         return 0;
 374 }
 375
 376 static struct megasas_instance_template megasas_instance_template_xscale = {
 377
 378         .fire_cmd = megasas_fire_cmd_xscale,
 379         .enable_intr = megasas_enable_intr_xscale,
 380         .disable_intr = megasas_disable_intr_xscale,
 381         .clear_intr = megasas_clear_intr_xscale,
 382         .read_fw_status_reg = megasas_read_fw_status_reg_xscale,
 383         .adp_reset = megasas_adp_reset_xscale,
 384         .check_reset = megasas_check_reset_xscale,
 385         .service_isr = megasas_isr,
 386         .tasklet = megasas_complete_cmd_dpc,
 387         .init_adapter = megasas_init_adapter_mfi,
 388         .build_and_issue_cmd = megasas_build_and_issue_cmd,
 389         .issue_dcmd = megasas_issue_dcmd,
 390 };
 391
 392 /**
 393 *       This is the end of set of functions & definitions specific
 394 *       to xscale (deviceid : 1064R, PERC5) controllers
 395 */
 396
 397 /**
 398 *       The following functions are defined for ppc (deviceid : 0x60)
 399 *       controllers
 400 */
 401
 402 /**
 403  * megasas_enable_intr_ppc -    Enables interrupts
 404  * @regs:                       MFI register set
 405  */
 406 static inline void
 407 megasas_enable_intr_ppc(struct megasas_register_set __iomem * regs)
 408 {
 409         writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
 410
 411         writel(~0x80000000, &(regs)->outbound_intr_mask);
 412
 413         /* Dummy readl to force pci flush */
 414         readl(&regs->outbound_intr_mask);
 415 }
 416
 417 /**
 418  * megasas_disable_intr_ppc -   Disable interrupt
 419  * @regs:                       MFI register set
 420  */
 421 static inline void
 422 megasas_disable_intr_ppc(struct megasas_register_set __iomem * regs)
 423 {
 424         u32 mask = 0xFFFFFFFF;
 425         writel(mask, &regs->outbound_intr_mask);
 426         /* Dummy readl to force pci flush */
 427         readl(&regs->outbound_intr_mask);
 428 }
 429
 430 /**
 431  * megasas_read_fw_status_reg_ppc - returns the current FW status value
 432  * @regs:                       MFI register set
 433  */
 434 static u32
 435 megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs)
 436 {
 437         return readl(&(regs)->outbound_scratch_pad);
 438 }
 439
 440 /**
 441  * megasas_clear_interrupt_ppc -        Check & clear interrupt
 442  * @regs:                               MFI register set
 443  */
 444 static int
 445 megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
 446 {
 447         u32 status, mfiStatus = 0;
 448
 449         /*
 450          * Check if it is our interrupt
 451          */
 452         status = readl(&regs->outbound_intr_status);
 453
 454         if (status & MFI_REPLY_1078_MESSAGE_INTERRUPT)
 455                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 456
 457         if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT)
 458                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 459
 460         /*
 461          * Clear the interrupt by writing back the same value
 462          */
 463         writel(status, &regs->outbound_doorbell_clear);
 464
 465         /* Dummy readl to force pci flush */
 466         readl(&regs->outbound_doorbell_clear);
 467
 468         return mfiStatus;
 469 }
 470
 471 /**
 472  * megasas_fire_cmd_ppc -       Sends command to the FW
 473  * @frame_phys_addr :           Physical address of cmd
 474  * @frame_count :               Number of frames for the command
 475  * @regs :                      MFI register set
 476  */
 477 static inline void
 478 megasas_fire_cmd_ppc(struct megasas_instance *instance,
 479                 dma_addr_t frame_phys_addr,
 480                 u32 frame_count,
 481                 struct megasas_register_set __iomem *regs)
 482 {
 483         unsigned long flags;
 484         spin_lock_irqsave(&instance->hba_lock, flags);
 485         writel((frame_phys_addr | (frame_count<<1))|1,
 486                         &(regs)->inbound_queue_port);
 487         spin_unlock_irqrestore(&instance->hba_lock, flags);
 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         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
 499                 return 1;
 500
 501         return 0;
 502 }
 503
 504 static struct megasas_instance_template megasas_instance_template_ppc = {
 505
 506         .fire_cmd = megasas_fire_cmd_ppc,
 507         .enable_intr = megasas_enable_intr_ppc,
 508         .disable_intr = megasas_disable_intr_ppc,
 509         .clear_intr = megasas_clear_intr_ppc,
 510         .read_fw_status_reg = megasas_read_fw_status_reg_ppc,
 511         .adp_reset = megasas_adp_reset_xscale,
 512         .check_reset = megasas_check_reset_ppc,
 513         .service_isr = megasas_isr,
 514         .tasklet = megasas_complete_cmd_dpc,
 515         .init_adapter = megasas_init_adapter_mfi,
 516         .build_and_issue_cmd = megasas_build_and_issue_cmd,
 517         .issue_dcmd = megasas_issue_dcmd,
 518 };
 519
 520 /**
 521  * megasas_enable_intr_skinny - Enables interrupts
 522  * @regs:                       MFI register set
 523  */
 524 static inline void
 525 megasas_enable_intr_skinny(struct megasas_register_set __iomem *regs)
 526 {
 527         writel(0xFFFFFFFF, &(regs)->outbound_intr_mask);
 528
 529         writel(~MFI_SKINNY_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
 530
 531         /* Dummy readl to force pci flush */
 532         readl(&regs->outbound_intr_mask);
 533 }
 534
 535 /**
 536  * megasas_disable_intr_skinny -        Disables interrupt
 537  * @regs:                       MFI register set
 538  */
 539 static inline void
 540 megasas_disable_intr_skinny(struct megasas_register_set __iomem *regs)
 541 {
 542         u32 mask = 0xFFFFFFFF;
 543         writel(mask, &regs->outbound_intr_mask);
 544         /* Dummy readl to force pci flush */
 545         readl(&regs->outbound_intr_mask);
 546 }
 547
 548 /**
 549  * megasas_read_fw_status_reg_skinny - returns the current FW status value
 550  * @regs:                       MFI register set
 551  */
 552 static u32
 553 megasas_read_fw_status_reg_skinny(struct megasas_register_set __iomem *regs)
 554 {
 555         return readl(&(regs)->outbound_scratch_pad);
 556 }
 557
 558 /**
 559  * megasas_clear_interrupt_skinny -     Check & clear interrupt
 560  * @regs:                               MFI register set
 561  */
 562 static int
 563 megasas_clear_intr_skinny(struct megasas_register_set __iomem *regs)
 564 {
 565         u32 status;
 566         u32 mfiStatus = 0;
 567
 568         /*
 569          * Check if it is our interrupt
 570          */
 571         status = readl(&regs->outbound_intr_status);
 572
 573         if (!(status & MFI_SKINNY_ENABLE_INTERRUPT_MASK)) {
 574                 return 0;
 575         }
 576
 577         /*
 578          * Check if it is our interrupt
 579          */
 580         if ((megasas_read_fw_status_reg_gen2(regs) & MFI_STATE_MASK) ==
 581             MFI_STATE_FAULT) {
 582                 mfiStatus = MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 583         } else
 584                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 585
 586         /*
 587          * Clear the interrupt by writing back the same value
 588          */
 589         writel(status, &regs->outbound_intr_status);
 590
 591         /*
 592         * dummy read to flush PCI
 593         */
 594         readl(&regs->outbound_intr_status);
 595
 596         return mfiStatus;
 597 }
 598
 599 /**
 600  * megasas_fire_cmd_skinny -    Sends command to the FW
 601  * @frame_phys_addr :           Physical address of cmd
 602  * @frame_count :               Number of frames for the command
 603  * @regs :                      MFI register set
 604  */
 605 static inline void
 606 megasas_fire_cmd_skinny(struct megasas_instance *instance,
 607                         dma_addr_t frame_phys_addr,
 608                         u32 frame_count,
 609                         struct megasas_register_set __iomem *regs)
 610 {
 611         unsigned long flags;
 612         spin_lock_irqsave(&instance->hba_lock, flags);
 613         writel(0, &(regs)->inbound_high_queue_port);
 614         writel((frame_phys_addr | (frame_count<<1))|1,
 615                 &(regs)->inbound_low_queue_port);
 616         spin_unlock_irqrestore(&instance->hba_lock, flags);
 617 }
 618
 619 /**
 620  * megasas_check_reset_skinny - For controller reset check
 621  * @regs:                               MFI register set
 622  */
 623 static int
 624 megasas_check_reset_skinny(struct megasas_instance *instance,
 625                                 struct megasas_register_set __iomem *regs)
 626 {
 627         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL)
 628                 return 1;
 629
 630         return 0;
 631 }
 632
 633 static struct megasas_instance_template megasas_instance_template_skinny = {
 634
 635         .fire_cmd = megasas_fire_cmd_skinny,
 636         .enable_intr = megasas_enable_intr_skinny,
 637         .disable_intr = megasas_disable_intr_skinny,
 638         .clear_intr = megasas_clear_intr_skinny,
 639         .read_fw_status_reg = megasas_read_fw_status_reg_skinny,
 640         .adp_reset = megasas_adp_reset_gen2,
 641         .check_reset = megasas_check_reset_skinny,
 642         .service_isr = megasas_isr,
 643         .tasklet = megasas_complete_cmd_dpc,
 644         .init_adapter = megasas_init_adapter_mfi,
 645         .build_and_issue_cmd = megasas_build_and_issue_cmd,
 646         .issue_dcmd = megasas_issue_dcmd,
 647 };
 648
 649
 650 /**
 651 *       The following functions are defined for gen2 (deviceid : 0x78 0x79)
 652 *       controllers
 653 */
 654
 655 /**
 656  * megasas_enable_intr_gen2 -  Enables interrupts
 657  * @regs:                      MFI register set
 658  */
 659 static inline void
 660 megasas_enable_intr_gen2(struct megasas_register_set __iomem *regs)
 661 {
 662         writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
 663
 664         /* write ~0x00000005 (4 & 1) to the intr mask*/
 665         writel(~MFI_GEN2_ENABLE_INTERRUPT_MASK, &(regs)->outbound_intr_mask);
 666
 667         /* Dummy readl to force pci flush */
 668         readl(&regs->outbound_intr_mask);
 669 }
 670
 671 /**
 672  * megasas_disable_intr_gen2 - Disables interrupt
 673  * @regs:                      MFI register set
 674  */
 675 static inline void
 676 megasas_disable_intr_gen2(struct megasas_register_set __iomem *regs)
 677 {
 678         u32 mask = 0xFFFFFFFF;
 679         writel(mask, &regs->outbound_intr_mask);
 680         /* Dummy readl to force pci flush */
 681         readl(&regs->outbound_intr_mask);
 682 }
 683
 684 /**
 685  * megasas_read_fw_status_reg_gen2 - returns the current FW status value
 686  * @regs:                      MFI register set
 687  */
 688 static u32
 689 megasas_read_fw_status_reg_gen2(struct megasas_register_set __iomem *regs)
 690 {
 691         return readl(&(regs)->outbound_scratch_pad);
 692 }
 693
 694 /**
 695  * megasas_clear_interrupt_gen2 -      Check & clear interrupt
 696  * @regs:                              MFI register set
 697  */
 698 static int
 699 megasas_clear_intr_gen2(struct megasas_register_set __iomem *regs)
 700 {
 701         u32 status;
 702         u32 mfiStatus = 0;
 703         /*
 704          * Check if it is our interrupt
 705          */
 706         status = readl(&regs->outbound_intr_status);
 707
 708         if (status & MFI_GEN2_ENABLE_INTERRUPT_MASK) {
 709                 mfiStatus = MFI_INTR_FLAG_REPLY_MESSAGE;
 710         }
 711         if (status & MFI_G2_OUTBOUND_DOORBELL_CHANGE_INTERRUPT) {
 712                 mfiStatus |= MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE;
 713         }
 714
 715         /*
 716          * Clear the interrupt by writing back the same value
 717          */
 718         if (mfiStatus)
 719                 writel(status, &regs->outbound_doorbell_clear);
 720
 721         /* Dummy readl to force pci flush */
 722         readl(&regs->outbound_intr_status);
 723
 724         return mfiStatus;
 725 }
 726 /**
 727  * megasas_fire_cmd_gen2 -     Sends command to the FW
 728  * @frame_phys_addr :          Physical address of cmd
 729  * @frame_count :              Number of frames for the command
 730  * @regs :                     MFI register set
 731  */
 732 static inline void
 733 megasas_fire_cmd_gen2(struct megasas_instance *instance,
 734                         dma_addr_t frame_phys_addr,
 735                         u32 frame_count,
 736                         struct megasas_register_set __iomem *regs)
 737 {
 738         unsigned long flags;
 739         spin_lock_irqsave(&instance->hba_lock, flags);
 740         writel((frame_phys_addr | (frame_count<<1))|1,
 741                         &(regs)->inbound_queue_port);
 742         spin_unlock_irqrestore(&instance->hba_lock, flags);
 743 }
 744
 745 /**
 746  * megasas_adp_reset_gen2 -     For controller reset
 747  * @regs:                               MFI register set
 748  */
 749 static int
 750 megasas_adp_reset_gen2(struct megasas_instance *instance,
 751                         struct megasas_register_set __iomem *reg_set)
 752 {
 753         u32                     retry = 0 ;
 754         u32                     HostDiag;
 755         u32                     *seq_offset = &reg_set->seq_offset;
 756         u32                     *hostdiag_offset = &reg_set->host_diag;
 757
 758         if (instance->instancet == &megasas_instance_template_skinny) {
 759                 seq_offset = &reg_set->fusion_seq_offset;
 760                 hostdiag_offset = &reg_set->fusion_host_diag;
 761         }
 762
 763         writel(0, seq_offset);
 764         writel(4, seq_offset);
 765         writel(0xb, seq_offset);
 766         writel(2, seq_offset);
 767         writel(7, seq_offset);
 768         writel(0xd, seq_offset);
 769
 770         msleep(1000);
 771
 772         HostDiag = (u32)readl(hostdiag_offset);
 773
 774         while ( !( HostDiag & DIAG_WRITE_ENABLE) ) {
 775                 msleep(100);
 776                 HostDiag = (u32)readl(hostdiag_offset);
 777                 printk(KERN_NOTICE "RESETGEN2: retry=%x, hostdiag=%x\n",
 778                                         retry, HostDiag);
 779
 780                 if (retry++ >= 100)
 781                         return 1;
 782
 783         }
 784
 785         printk(KERN_NOTICE "ADP_RESET_GEN2: HostDiag=%x\n", HostDiag);
 786
 787         writel((HostDiag | DIAG_RESET_ADAPTER), hostdiag_offset);
 788
 789         ssleep(10);
 790
 791         HostDiag = (u32)readl(hostdiag_offset);
 792         while ( ( HostDiag & DIAG_RESET_ADAPTER) ) {
 793                 msleep(100);
 794                 HostDiag = (u32)readl(hostdiag_offset);
 795                 printk(KERN_NOTICE "RESET_GEN2: retry=%x, hostdiag=%x\n",
 796                                 retry, HostDiag);
 797
 798                 if (retry++ >= 1000)
 799                         return 1;
 800
 801         }
 802         return 0;
 803 }
 804
 805 /**
 806  * megasas_check_reset_gen2 -   For controller reset check
 807  * @regs:                               MFI register set
 808  */
 809 static int
 810 megasas_check_reset_gen2(struct megasas_instance *instance,
 811                 struct megasas_register_set __iomem *regs)
 812 {
 813         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
 814                 return 1;
 815         }
 816
 817         return 0;
 818 }
 819
 820 static struct megasas_instance_template megasas_instance_template_gen2 = {
 821
 822         .fire_cmd = megasas_fire_cmd_gen2,
 823         .enable_intr = megasas_enable_intr_gen2,
 824         .disable_intr = megasas_disable_intr_gen2,
 825         .clear_intr = megasas_clear_intr_gen2,
 826         .read_fw_status_reg = megasas_read_fw_status_reg_gen2,
 827         .adp_reset = megasas_adp_reset_gen2,
 828         .check_reset = megasas_check_reset_gen2,
 829         .service_isr = megasas_isr,
 830         .tasklet = megasas_complete_cmd_dpc,
 831         .init_adapter = megasas_init_adapter_mfi,
 832         .build_and_issue_cmd = megasas_build_and_issue_cmd,
 833         .issue_dcmd = megasas_issue_dcmd,
 834 };
 835
 836 /**
 837 *       This is the end of set of functions & definitions
 838 *       specific to gen2 (deviceid : 0x78, 0x79) controllers
 839 */
 840
 841 /*
 842  * Template added for TB (Fusion)
 843  */
 844 extern struct megasas_instance_template megasas_instance_template_fusion;
 845
 846 /**
 847  * megasas_issue_polled -       Issues a polling command
 848  * @instance:                   Adapter soft state
 849  * @cmd:                        Command packet to be issued
 850  *
 851  * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
 852  */
 853 int
 854 megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
 855 {
 856
 857         struct megasas_header *frame_hdr = &cmd->frame->hdr;
 858
 859         frame_hdr->cmd_status = 0xFF;
 860         frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
 861
 862         /*
 863          * Issue the frame using inbound queue port
 864          */
 865         instance->instancet->issue_dcmd(instance, cmd);
 866
 867         /*
 868          * Wait for cmd_status to change
 869          */
 870         return wait_and_poll(instance, cmd);
 871 }
 872
 873 /**
 874  * megasas_issue_blocked_cmd -  Synchronous wrapper around regular FW cmds
 875  * @instance:                   Adapter soft state
 876  * @cmd:                        Command to be issued
 877  *
 878  * This function waits on an event for the command to be returned from ISR.
 879  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
 880  * Used to issue ioctl commands.
 881  */
 882 static int
 883 megasas_issue_blocked_cmd(struct megasas_instance *instance,
 884                           struct megasas_cmd *cmd)
 885 {
 886         cmd->cmd_status = ENODATA;
 887
 888         instance->instancet->issue_dcmd(instance, cmd);
 889
 890         wait_event(instance->int_cmd_wait_q, cmd->cmd_status != ENODATA);
 891
 892         return 0;
 893 }
 894
 895 /**
 896  * megasas_issue_blocked_abort_cmd -    Aborts previously issued cmd
 897  * @instance:                           Adapter soft state
 898  * @cmd_to_abort:                       Previously issued cmd to be aborted
 899  *
 900  * MFI firmware can abort previously issued AEN command (automatic event
 901  * notification). The megasas_issue_blocked_abort_cmd() issues such abort
 902  * cmd and waits for return status.
 903  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
 904  */
 905 static int
 906 megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
 907                                 struct megasas_cmd *cmd_to_abort)
 908 {
 909         struct megasas_cmd *cmd;
 910         struct megasas_abort_frame *abort_fr;
 911
 912         cmd = megasas_get_cmd(instance);
 913
 914         if (!cmd)
 915                 return -1;
 916
 917         abort_fr = &cmd->frame->abort;
 918
 919         /*
 920          * Prepare and issue the abort frame
 921          */
 922         abort_fr->cmd = MFI_CMD_ABORT;
 923         abort_fr->cmd_status = 0xFF;
 924         abort_fr->flags = 0;
 925         abort_fr->abort_context = cmd_to_abort->index;
 926         abort_fr->abort_mfi_phys_addr_lo = cmd_to_abort->frame_phys_addr;
 927         abort_fr->abort_mfi_phys_addr_hi = 0;
 928
 929         cmd->sync_cmd = 1;
 930         cmd->cmd_status = 0xFF;
 931
 932         instance->instancet->issue_dcmd(instance, cmd);
 933
 934         /*
 935          * Wait for this cmd to complete
 936          */
 937         wait_event(instance->abort_cmd_wait_q, cmd->cmd_status != 0xFF);
 938         cmd->sync_cmd = 0;
 939
 940         megasas_return_cmd(instance, cmd);
 941         return 0;
 942 }
 943
 944 /**
 945  * megasas_make_sgl32 - Prepares 32-bit SGL
 946  * @instance:           Adapter soft state
 947  * @scp:                SCSI command from the mid-layer
 948  * @mfi_sgl:            SGL to be filled in
 949  *
 950  * If successful, this function returns the number of SG elements. Otherwise,
 951  * it returnes -1.
 952  */
 953 static int
 954 megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
 955                    union megasas_sgl *mfi_sgl)
 956 {
 957         int i;
 958         int sge_count;
 959         struct scatterlist *os_sgl;
 960
 961         sge_count = scsi_dma_map(scp);
 962         BUG_ON(sge_count < 0);
 963
 964         if (sge_count) {
 965                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
 966                         mfi_sgl->sge32[i].length = sg_dma_len(os_sgl);
 967                         mfi_sgl->sge32[i].phys_addr = sg_dma_address(os_sgl);
 968                 }
 969         }
 970         return sge_count;
 971 }
 972
 973 /**
 974  * megasas_make_sgl64 - Prepares 64-bit SGL
 975  * @instance:           Adapter soft state
 976  * @scp:                SCSI command from the mid-layer
 977  * @mfi_sgl:            SGL to be filled in
 978  *
 979  * If successful, this function returns the number of SG elements. Otherwise,
 980  * it returnes -1.
 981  */
 982 static int
 983 megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
 984                    union megasas_sgl *mfi_sgl)
 985 {
 986         int i;
 987         int sge_count;
 988         struct scatterlist *os_sgl;
 989
 990         sge_count = scsi_dma_map(scp);
 991         BUG_ON(sge_count < 0);
 992
 993         if (sge_count) {
 994                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
 995                         mfi_sgl->sge64[i].length = sg_dma_len(os_sgl);
 996                         mfi_sgl->sge64[i].phys_addr = sg_dma_address(os_sgl);
 997                 }
 998         }
 999         return sge_count;
1000 }
1001
1002 /**
1003  * megasas_make_sgl_skinny - Prepares IEEE SGL
1004  * @instance:           Adapter soft state
1005  * @scp:                SCSI command from the mid-layer
1006  * @mfi_sgl:            SGL to be filled in
1007  *
1008  * If successful, this function returns the number of SG elements. Otherwise,
1009  * it returnes -1.
1010  */
1011 static int
1012 megasas_make_sgl_skinny(struct megasas_instance *instance,
1013                 struct scsi_cmnd *scp, union megasas_sgl *mfi_sgl)
1014 {
1015         int i;
1016         int sge_count;
1017         struct scatterlist *os_sgl;
1018
1019         sge_count = scsi_dma_map(scp);
1020
1021         if (sge_count) {
1022                 scsi_for_each_sg(scp, os_sgl, sge_count, i) {
1023                         mfi_sgl->sge_skinny[i].length = sg_dma_len(os_sgl);
1024                         mfi_sgl->sge_skinny[i].phys_addr =
1025                                                 sg_dma_address(os_sgl);
1026                         mfi_sgl->sge_skinny[i].flag = 0;
1027                 }
1028         }
1029         return sge_count;
1030 }
1031
1032  /**
1033  * megasas_get_frame_count - Computes the number of frames
1034  * @frame_type          : type of frame- io or pthru frame
1035  * @sge_count           : number of sg elements
1036  *
1037  * Returns the number of frames required for numnber of sge's (sge_count)
1038  */
1039
1040 static u32 megasas_get_frame_count(struct megasas_instance *instance,
1041                         u8 sge_count, u8 frame_type)
1042 {
1043         int num_cnt;
1044         int sge_bytes;
1045         u32 sge_sz;
1046         u32 frame_count=0;
1047
1048         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
1049             sizeof(struct megasas_sge32);
1050
1051         if (instance->flag_ieee) {
1052                 sge_sz = sizeof(struct megasas_sge_skinny);
1053         }
1054
1055         /*
1056          * Main frame can contain 2 SGEs for 64-bit SGLs and
1057          * 3 SGEs for 32-bit SGLs for ldio &
1058          * 1 SGEs for 64-bit SGLs and
1059          * 2 SGEs for 32-bit SGLs for pthru frame
1060          */
1061         if (unlikely(frame_type == PTHRU_FRAME)) {
1062                 if (instance->flag_ieee == 1) {
1063                         num_cnt = sge_count - 1;
1064                 } else if (IS_DMA64)
1065                         num_cnt = sge_count - 1;
1066                 else
1067                         num_cnt = sge_count - 2;
1068         } else {
1069                 if (instance->flag_ieee == 1) {
1070                         num_cnt = sge_count - 1;
1071                 } else if (IS_DMA64)
1072                         num_cnt = sge_count - 2;
1073                 else
1074                         num_cnt = sge_count - 3;
1075         }
1076
1077         if(num_cnt>0){
1078                 sge_bytes = sge_sz * num_cnt;
1079
1080                 frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
1081                     ((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) ;
1082         }
1083         /* Main frame */
1084         frame_count +=1;
1085
1086         if (frame_count > 7)
1087                 frame_count = 8;
1088         return frame_count;
1089 }
1090
1091 /**
1092  * megasas_build_dcdb - Prepares a direct cdb (DCDB) command
1093  * @instance:           Adapter soft state
1094  * @scp:                SCSI command
1095  * @cmd:                Command to be prepared in
1096  *
1097  * This function prepares CDB commands. These are typcially pass-through
1098  * commands to the devices.
1099  */
1100 static int
1101 megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
1102                    struct megasas_cmd *cmd)
1103 {
1104         u32 is_logical;
1105         u32 device_id;
1106         u16 flags = 0;
1107         struct megasas_pthru_frame *pthru;
1108
1109         is_logical = MEGASAS_IS_LOGICAL(scp);
1110         device_id = MEGASAS_DEV_INDEX(instance, scp);
1111         pthru = (struct megasas_pthru_frame *)cmd->frame;
1112
1113         if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1114                 flags = MFI_FRAME_DIR_WRITE;
1115         else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1116                 flags = MFI_FRAME_DIR_READ;
1117         else if (scp->sc_data_direction == PCI_DMA_NONE)
1118                 flags = MFI_FRAME_DIR_NONE;
1119
1120         if (instance->flag_ieee == 1) {
1121                 flags |= MFI_FRAME_IEEE;
1122         }
1123
1124         /*
1125          * Prepare the DCDB frame
1126          */
1127         pthru->cmd = (is_logical) ? MFI_CMD_LD_SCSI_IO : MFI_CMD_PD_SCSI_IO;
1128         pthru->cmd_status = 0x0;
1129         pthru->scsi_status = 0x0;
1130         pthru->target_id = device_id;
1131         pthru->lun = scp->device->lun;
1132         pthru->cdb_len = scp->cmd_len;
1133         pthru->timeout = 0;
1134         pthru->pad_0 = 0;
1135         pthru->flags = flags;
1136         pthru->data_xfer_len = scsi_bufflen(scp);
1137
1138         memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
1139
1140         /*
1141         * If the command is for the tape device, set the
1142         * pthru timeout to the os layer timeout value.
1143         */
1144         if (scp->device->type == TYPE_TAPE) {
1145                 if ((scp->request->timeout / HZ) > 0xFFFF)
1146                         pthru->timeout = 0xFFFF;
1147                 else
1148                         pthru->timeout = scp->request->timeout / HZ;
1149         }
1150
1151         /*
1152          * Construct SGL
1153          */
1154         if (instance->flag_ieee == 1) {
1155                 pthru->flags |= MFI_FRAME_SGL64;
1156                 pthru->sge_count = megasas_make_sgl_skinny(instance, scp,
1157                                                       &pthru->sgl);
1158         } else if (IS_DMA64) {
1159                 pthru->flags |= MFI_FRAME_SGL64;
1160                 pthru->sge_count = megasas_make_sgl64(instance, scp,
1161                                                       &pthru->sgl);
1162         } else
1163                 pthru->sge_count = megasas_make_sgl32(instance, scp,
1164                                                       &pthru->sgl);
1165
1166         if (pthru->sge_count > instance->max_num_sge) {
1167                 printk(KERN_ERR "megasas: DCDB two many SGE NUM=%x\n",
1168                         pthru->sge_count);
1169                 return 0;
1170         }
1171
1172         /*
1173          * Sense info specific
1174          */
1175         pthru->sense_len = SCSI_SENSE_BUFFERSIZE;
1176         pthru->sense_buf_phys_addr_hi = 0;
1177         pthru->sense_buf_phys_addr_lo = cmd->sense_phys_addr;
1178
1179         /*
1180          * Compute the total number of frames this command consumes. FW uses
1181          * this number to pull sufficient number of frames from host memory.
1182          */
1183         cmd->frame_count = megasas_get_frame_count(instance, pthru->sge_count,
1184                                                         PTHRU_FRAME);
1185
1186         return cmd->frame_count;
1187 }
1188
1189 /**
1190  * megasas_build_ldio - Prepares IOs to logical devices
1191  * @instance:           Adapter soft state
1192  * @scp:                SCSI command
1193  * @cmd:                Command to be prepared
1194  *
1195  * Frames (and accompanying SGLs) for regular SCSI IOs use this function.
1196  */
1197 static int
1198 megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
1199                    struct megasas_cmd *cmd)
1200 {
1201         u32 device_id;
1202         u8 sc = scp->cmnd[0];
1203         u16 flags = 0;
1204         struct megasas_io_frame *ldio;
1205
1206         device_id = MEGASAS_DEV_INDEX(instance, scp);
1207         ldio = (struct megasas_io_frame *)cmd->frame;
1208
1209         if (scp->sc_data_direction == PCI_DMA_TODEVICE)
1210                 flags = MFI_FRAME_DIR_WRITE;
1211         else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
1212                 flags = MFI_FRAME_DIR_READ;
1213
1214         if (instance->flag_ieee == 1) {
1215                 flags |= MFI_FRAME_IEEE;
1216         }
1217
1218         /*
1219          * Prepare the Logical IO frame: 2nd bit is zero for all read cmds
1220          */
1221         ldio->cmd = (sc & 0x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ;
1222         ldio->cmd_status = 0x0;
1223         ldio->scsi_status = 0x0;
1224         ldio->target_id = device_id;
1225         ldio->timeout = 0;
1226         ldio->reserved_0 = 0;
1227         ldio->pad_0 = 0;
1228         ldio->flags = flags;
1229         ldio->start_lba_hi = 0;
1230         ldio->access_byte = (scp->cmd_len != 6) ? scp->cmnd[1] : 0;
1231
1232         /*
1233          * 6-byte READ(0x08) or WRITE(0x0A) cdb
1234          */
1235         if (scp->cmd_len == 6) {
1236                 ldio->lba_count = (u32) scp->cmnd[4];
1237                 ldio->start_lba_lo = ((u32) scp->cmnd[1] << 16) |
1238                     ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3];
1239
1240                 ldio->start_lba_lo &= 0x1FFFFF;
1241         }
1242
1243         /*
1244          * 10-byte READ(0x28) or WRITE(0x2A) cdb
1245          */
1246         else if (scp->cmd_len == 10) {
1247                 ldio->lba_count = (u32) scp->cmnd[8] |
1248                     ((u32) scp->cmnd[7] << 8);
1249                 ldio->start_lba_lo = ((u32) scp->cmnd[2] << 24) |
1250                     ((u32) scp->cmnd[3] << 16) |
1251                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1252         }
1253
1254         /*
1255          * 12-byte READ(0xA8) or WRITE(0xAA) cdb
1256          */
1257         else if (scp->cmd_len == 12) {
1258                 ldio->lba_count = ((u32) scp->cmnd[6] << 24) |
1259                     ((u32) scp->cmnd[7] << 16) |
1260                     ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
1261
1262                 ldio->start_lba_lo = ((u32) scp->cmnd[2] << 24) |
1263                     ((u32) scp->cmnd[3] << 16) |
1264                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1265         }
1266
1267         /*
1268          * 16-byte READ(0x88) or WRITE(0x8A) cdb
1269          */
1270         else if (scp->cmd_len == 16) {
1271                 ldio->lba_count = ((u32) scp->cmnd[10] << 24) |
1272                     ((u32) scp->cmnd[11] << 16) |
1273                     ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13];
1274
1275                 ldio->start_lba_lo = ((u32) scp->cmnd[6] << 24) |
1276                     ((u32) scp->cmnd[7] << 16) |
1277                     ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
1278
1279                 ldio->start_lba_hi = ((u32) scp->cmnd[2] << 24) |
1280                     ((u32) scp->cmnd[3] << 16) |
1281                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
1282
1283         }
1284
1285         /*
1286          * Construct SGL
1287          */
1288         if (instance->flag_ieee) {
1289                 ldio->flags |= MFI_FRAME_SGL64;
1290                 ldio->sge_count = megasas_make_sgl_skinny(instance, scp,
1291                                               &ldio->sgl);
1292         } else if (IS_DMA64) {
1293                 ldio->flags |= MFI_FRAME_SGL64;
1294                 ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl);
1295         } else
1296                 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
1297
1298         if (ldio->sge_count > instance->max_num_sge) {
1299                 printk(KERN_ERR "megasas: build_ld_io: sge_count = %x\n",
1300                         ldio->sge_count);
1301                 return 0;
1302         }
1303
1304         /*
1305          * Sense info specific
1306          */
1307         ldio->sense_len = SCSI_SENSE_BUFFERSIZE;
1308         ldio->sense_buf_phys_addr_hi = 0;
1309         ldio->sense_buf_phys_addr_lo = cmd->sense_phys_addr;
1310
1311         /*
1312          * Compute the total number of frames this command consumes. FW uses
1313          * this number to pull sufficient number of frames from host memory.
1314          */
1315         cmd->frame_count = megasas_get_frame_count(instance,
1316                         ldio->sge_count, IO_FRAME);
1317
1318         return cmd->frame_count;
1319 }
1320
1321 /**
1322  * megasas_is_ldio -            Checks if the cmd is for logical drive
1323  * @scmd:                       SCSI command
1324  *
1325  * Called by megasas_queue_command to find out if the command to be queued
1326  * is a logical drive command
1327  */
1328 inline int megasas_is_ldio(struct scsi_cmnd *cmd)
1329 {
1330         if (!MEGASAS_IS_LOGICAL(cmd))
1331                 return 0;
1332         switch (cmd->cmnd[0]) {
1333         case READ_10:
1334         case WRITE_10:
1335         case READ_12:
1336         case WRITE_12:
1337         case READ_6:
1338         case WRITE_6:
1339         case READ_16:
1340         case WRITE_16:
1341                 return 1;
1342         default:
1343                 return 0;
1344         }
1345 }
1346
1347  /**
1348  * megasas_dump_pending_frames -        Dumps the frame address of all pending cmds
1349  *                                      in FW
1350  * @instance:                           Adapter soft state
1351  */
1352 static inline void
1353 megasas_dump_pending_frames(struct megasas_instance *instance)
1354 {
1355         struct megasas_cmd *cmd;
1356         int i,n;
1357         union megasas_sgl *mfi_sgl;
1358         struct megasas_io_frame *ldio;
1359         struct megasas_pthru_frame *pthru;
1360         u32 sgcount;
1361         u32 max_cmd = instance->max_fw_cmds;
1362
1363         printk(KERN_ERR "\nmegasas[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no);
1364         printk(KERN_ERR "megasas[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding));
1365         if (IS_DMA64)
1366                 printk(KERN_ERR "\nmegasas[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no);
1367         else
1368                 printk(KERN_ERR "\nmegasas[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no);
1369
1370         printk(KERN_ERR "megasas[%d]: Pending OS cmds in FW : \n",instance->host->host_no);
1371         for (i = 0; i < max_cmd; i++) {
1372                 cmd = instance->cmd_list[i];
1373                 if(!cmd->scmd)
1374                         continue;
1375                 printk(KERN_ERR "megasas[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
1376                 if (megasas_is_ldio(cmd->scmd)){
1377                         ldio = (struct megasas_io_frame *)cmd->frame;
1378                         mfi_sgl = &ldio->sgl;
1379                         sgcount = ldio->sge_count;
1380                         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);
1381                 }
1382                 else {
1383                         pthru = (struct megasas_pthru_frame *) cmd->frame;
1384                         mfi_sgl = &pthru->sgl;
1385                         sgcount = pthru->sge_count;
1386                         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);
1387                 }
1388         if(megasas_dbg_lvl & MEGASAS_DBG_LVL){
1389                 for (n = 0; n < sgcount; n++){
1390                         if (IS_DMA64)
1391                                 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) ;
1392                         else
1393                                 printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%x ",mfi_sgl->sge32[n].length , mfi_sgl->sge32[n].phys_addr) ;
1394                         }
1395                 }
1396                 printk(KERN_ERR "\n");
1397         } /*for max_cmd*/
1398         printk(KERN_ERR "\nmegasas[%d]: Pending Internal cmds in FW : \n",instance->host->host_no);
1399         for (i = 0; i < max_cmd; i++) {
1400
1401                 cmd = instance->cmd_list[i];
1402
1403                 if(cmd->sync_cmd == 1){
1404                         printk(KERN_ERR "0x%08lx : ", (unsigned long)cmd->frame_phys_addr);
1405                 }
1406         }
1407         printk(KERN_ERR "megasas[%d]: Dumping Done.\n\n",instance->host->host_no);
1408 }
1409
1410 u32
1411 megasas_build_and_issue_cmd(struct megasas_instance *instance,
1412                             struct scsi_cmnd *scmd)
1413 {
1414         struct megasas_cmd *cmd;
1415         u32 frame_count;
1416
1417         cmd = megasas_get_cmd(instance);
1418         if (!cmd)
1419                 return SCSI_MLQUEUE_HOST_BUSY;
1420
1421         /*
1422          * Logical drive command
1423          */
1424         if (megasas_is_ldio(scmd))
1425                 frame_count = megasas_build_ldio(instance, scmd, cmd);
1426         else
1427                 frame_count = megasas_build_dcdb(instance, scmd, cmd);
1428
1429         if (!frame_count)
1430                 goto out_return_cmd;
1431
1432         cmd->scmd = scmd;
1433         scmd->SCp.ptr = (char *)cmd;
1434
1435         /*
1436          * Issue the command to the FW
1437          */
1438         atomic_inc(&instance->fw_outstanding);
1439
1440         instance->instancet->fire_cmd(instance, cmd->frame_phys_addr,
1441                                 cmd->frame_count-1, instance->reg_set);
1442         /*
1443          * Check if we have pend cmds to be completed
1444          */
1445         if (poll_mode_io && atomic_read(&instance->fw_outstanding))
1446                 tasklet_schedule(&instance->isr_tasklet);
1447
1448         return 0;
1449 out_return_cmd:
1450         megasas_return_cmd(instance, cmd);
1451         return 1;
1452 }
1453
1454
1455 /**
1456  * megasas_queue_command -      Queue entry point
1457  * @scmd:                       SCSI command to be queued
1458  * @done:                       Callback entry point
1459  */
1460 static int
1461 megasas_queue_command_lck(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *))
1462 {
1463         struct megasas_instance *instance;
1464         unsigned long flags;
1465
1466         instance = (struct megasas_instance *)
1467             scmd->device->host->hostdata;
1468
1469         if (instance->issuepend_done == 0)
1470                 return SCSI_MLQUEUE_HOST_BUSY;
1471
1472         spin_lock_irqsave(&instance->hba_lock, flags);
1473         if (instance->adprecovery != MEGASAS_HBA_OPERATIONAL) {
1474                 spin_unlock_irqrestore(&instance->hba_lock, flags);
1475                 return SCSI_MLQUEUE_HOST_BUSY;
1476         }
1477
1478         spin_unlock_irqrestore(&instance->hba_lock, flags);
1479
1480         scmd->scsi_done = done;
1481         scmd->result = 0;
1482
1483         if (MEGASAS_IS_LOGICAL(scmd) &&
1484             (scmd->device->id >= MEGASAS_MAX_LD || scmd->device->lun)) {
1485                 scmd->result = DID_BAD_TARGET << 16;
1486                 goto out_done;
1487         }
1488
1489         /*
1490          * FW takes care of flush cache on its own for Virtual Disk.
1491          * No need to send it down for VD. For JBOD send SYNCHRONIZE_CACHE to FW.
1492          */
1493         if ((scmd->cmnd[0] == SYNCHRONIZE_CACHE) && MEGASAS_IS_LOGICAL(scmd)) {
1494                 scmd->result = DID_OK << 16;
1495                 goto out_done;
1496         }
1497
1498         if (instance->instancet->build_and_issue_cmd(instance, scmd)) {
1499                 printk(KERN_ERR "megasas: Err returned from build_and_issue_cmd\n");
1500                 return SCSI_MLQUEUE_HOST_BUSY;
1501         }
1502
1503         return 0;
1504
1505  out_done:
1506         done(scmd);
1507         return 0;
1508 }
1509
1510 static DEF_SCSI_QCMD(megasas_queue_command)
1511
1512 static struct megasas_instance *megasas_lookup_instance(u16 host_no)
1513 {
1514         int i;
1515
1516         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
1517
1518                 if ((megasas_mgmt_info.instance[i]) &&
1519                     (megasas_mgmt_info.instance[i]->host->host_no == host_no))
1520                         return megasas_mgmt_info.instance[i];
1521         }
1522
1523         return NULL;
1524 }
1525
1526 static int megasas_slave_configure(struct scsi_device *sdev)
1527 {
1528         u16             pd_index = 0;
1529         struct  megasas_instance *instance ;
1530
1531         instance = megasas_lookup_instance(sdev->host->host_no);
1532
1533         /*
1534         * Don't export physical disk devices to the disk driver.
1535         *
1536         * FIXME: Currently we don't export them to the midlayer at all.
1537         *        That will be fixed once LSI engineers have audited the
1538         *        firmware for possible issues.
1539         */
1540         if (sdev->channel < MEGASAS_MAX_PD_CHANNELS &&
1541                                 sdev->type == TYPE_DISK) {
1542                 pd_index = (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
1543                                                                 sdev->id;
1544                 if (instance->pd_list[pd_index].driveState ==
1545                                                 MR_PD_STATE_SYSTEM) {
1546                         blk_queue_rq_timeout(sdev->request_queue,
1547                                 MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
1548                         return 0;
1549                 }
1550                 return -ENXIO;
1551         }
1552
1553         /*
1554         * The RAID firmware may require extended timeouts.
1555         */
1556         blk_queue_rq_timeout(sdev->request_queue,
1557                 MEGASAS_DEFAULT_CMD_TIMEOUT * HZ);
1558         return 0;
1559 }
1560
1561 static int megasas_slave_alloc(struct scsi_device *sdev)
1562 {
1563         u16             pd_index = 0;
1564         struct megasas_instance *instance ;
1565         instance = megasas_lookup_instance(sdev->host->host_no);
1566         if ((sdev->channel < MEGASAS_MAX_PD_CHANNELS) &&
1567                                 (sdev->type == TYPE_DISK)) {
1568                 /*
1569                  * Open the OS scan to the SYSTEM PD
1570                  */
1571                 pd_index =
1572                         (sdev->channel * MEGASAS_MAX_DEV_PER_CHANNEL) +
1573                         sdev->id;
1574                 if ((instance->pd_list[pd_index].driveState ==
1575                                         MR_PD_STATE_SYSTEM) &&
1576                         (instance->pd_list[pd_index].driveType ==
1577                                                 TYPE_DISK)) {
1578                         return 0;
1579                 }
1580                 return -ENXIO;
1581         }
1582         return 0;
1583 }
1584
1585 void megaraid_sas_kill_hba(struct megasas_instance *instance)
1586 {
1587         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
1588             (instance->pdev->device == PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
1589             (instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
1590             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER)) {
1591                 writel(MFI_STOP_ADP, &instance->reg_set->doorbell);
1592         } else {
1593                 writel(MFI_STOP_ADP, &instance->reg_set->inbound_doorbell);
1594         }
1595 }
1596
1597  /**
1598   * megasas_check_and_restore_queue_depth - Check if queue depth needs to be
1599   *                                     restored to max value
1600   * @instance:                  Adapter soft state
1601   *
1602   */
1603 void
1604 megasas_check_and_restore_queue_depth(struct megasas_instance *instance)
1605 {
1606         unsigned long flags;
1607         if (instance->flag & MEGASAS_FW_BUSY
1608                 && time_after(jiffies, instance->last_time + 5 * HZ)
1609                 && atomic_read(&instance->fw_outstanding) < 17) {
1610
1611                 spin_lock_irqsave(instance->host->host_lock, flags);
1612                 instance->flag &= ~MEGASAS_FW_BUSY;
1613                 if ((instance->pdev->device ==
1614                         PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
1615                         (instance->pdev->device ==
1616                         PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
1617                         instance->host->can_queue =
1618                                 instance->max_fw_cmds - MEGASAS_SKINNY_INT_CMDS;
1619                 } else
1620                         instance->host->can_queue =
1621                                 instance->max_fw_cmds - MEGASAS_INT_CMDS;
1622
1623                 spin_unlock_irqrestore(instance->host->host_lock, flags);
1624         }
1625 }
1626
1627 /**
1628  * megasas_complete_cmd_dpc      -      Returns FW's controller structure
1629  * @instance_addr:                      Address of adapter soft state
1630  *
1631  * Tasklet to complete cmds
1632  */
1633 static void megasas_complete_cmd_dpc(unsigned long instance_addr)
1634 {
1635         u32 producer;
1636         u32 consumer;
1637         u32 context;
1638         struct megasas_cmd *cmd;
1639         struct megasas_instance *instance =
1640                                 (struct megasas_instance *)instance_addr;
1641         unsigned long flags;
1642
1643         /* If we have already declared adapter dead, donot complete cmds */
1644         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR )
1645                 return;
1646
1647         spin_lock_irqsave(&instance->completion_lock, flags);
1648
1649         producer = *instance->producer;
1650         consumer = *instance->consumer;
1651
1652         while (consumer != producer) {
1653                 context = instance->reply_queue[consumer];
1654                 if (context >= instance->max_fw_cmds) {
1655                         printk(KERN_ERR "Unexpected context value %x\n",
1656                                 context);
1657                         BUG();
1658                 }
1659
1660                 cmd = instance->cmd_list[context];
1661
1662                 megasas_complete_cmd(instance, cmd, DID_OK);
1663
1664                 consumer++;
1665                 if (consumer == (instance->max_fw_cmds + 1)) {
1666                         consumer = 0;
1667                 }
1668         }
1669
1670         *instance->consumer = producer;
1671
1672         spin_unlock_irqrestore(&instance->completion_lock, flags);
1673
1674         /*
1675          * Check if we can restore can_queue
1676          */
1677         megasas_check_and_restore_queue_depth(instance);
1678 }
1679
1680 static void
1681 megasas_internal_reset_defer_cmds(struct megasas_instance *instance);
1682
1683 static void
1684 process_fw_state_change_wq(struct work_struct *work);
1685
1686 void megasas_do_ocr(struct megasas_instance *instance)
1687 {
1688         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
1689         (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
1690         (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
1691                 *instance->consumer     = MEGASAS_ADPRESET_INPROG_SIGN;
1692         }
1693         instance->instancet->disable_intr(instance->reg_set);
1694         instance->adprecovery   = MEGASAS_ADPRESET_SM_INFAULT;
1695         instance->issuepend_done = 0;
1696
1697         atomic_set(&instance->fw_outstanding, 0);
1698         megasas_internal_reset_defer_cmds(instance);
1699         process_fw_state_change_wq(&instance->work_init);
1700 }
1701
1702 /**
1703  * megasas_wait_for_outstanding -       Wait for all outstanding cmds
1704  * @instance:                           Adapter soft state
1705  *
1706  * This function waits for up to MEGASAS_RESET_WAIT_TIME seconds for FW to
1707  * complete all its outstanding commands. Returns error if one or more IOs
1708  * are pending after this time period. It also marks the controller dead.
1709  */
1710 static int megasas_wait_for_outstanding(struct megasas_instance *instance)
1711 {
1712         int i;
1713         u32 reset_index;
1714         u32 wait_time = MEGASAS_RESET_WAIT_TIME;
1715         u8 adprecovery;
1716         unsigned long flags;
1717         struct list_head clist_local;
1718         struct megasas_cmd *reset_cmd;
1719         u32 fw_state;
1720         u8 kill_adapter_flag;
1721
1722         spin_lock_irqsave(&instance->hba_lock, flags);
1723         adprecovery = instance->adprecovery;
1724         spin_unlock_irqrestore(&instance->hba_lock, flags);
1725
1726         if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
1727
1728                 INIT_LIST_HEAD(&clist_local);
1729                 spin_lock_irqsave(&instance->hba_lock, flags);
1730                 list_splice_init(&instance->internal_reset_pending_q,
1731                                 &clist_local);
1732                 spin_unlock_irqrestore(&instance->hba_lock, flags);
1733
1734                 printk(KERN_NOTICE "megasas: HBA reset wait ...\n");
1735                 for (i = 0; i < wait_time; i++) {
1736                         msleep(1000);
1737                         spin_lock_irqsave(&instance->hba_lock, flags);
1738                         adprecovery = instance->adprecovery;
1739                         spin_unlock_irqrestore(&instance->hba_lock, flags);
1740                         if (adprecovery == MEGASAS_HBA_OPERATIONAL)
1741                                 break;
1742                 }
1743
1744                 if (adprecovery != MEGASAS_HBA_OPERATIONAL) {
1745                         printk(KERN_NOTICE "megasas: reset: Stopping HBA.\n");
1746                         spin_lock_irqsave(&instance->hba_lock, flags);
1747                         instance->adprecovery   = MEGASAS_HW_CRITICAL_ERROR;
1748                         spin_unlock_irqrestore(&instance->hba_lock, flags);
1749                         return FAILED;
1750                 }
1751
1752                 reset_index     = 0;
1753                 while (!list_empty(&clist_local)) {
1754                         reset_cmd       = list_entry((&clist_local)->next,
1755                                                 struct megasas_cmd, list);
1756                         list_del_init(&reset_cmd->list);
1757                         if (reset_cmd->scmd) {
1758                                 reset_cmd->scmd->result = DID_RESET << 16;
1759                                 printk(KERN_NOTICE "%d:%p reset [%02x]\n",
1760                                         reset_index, reset_cmd,
1761                                         reset_cmd->scmd->cmnd[0]);
1762
1763                                 reset_cmd->scmd->scsi_done(reset_cmd->scmd);
1764                                 megasas_return_cmd(instance, reset_cmd);
1765                         } else if (reset_cmd->sync_cmd) {
1766                                 printk(KERN_NOTICE "megasas:%p synch cmds"
1767                                                 "reset queue\n",
1768                                                 reset_cmd);
1769
1770                                 reset_cmd->cmd_status = ENODATA;
1771                                 instance->instancet->fire_cmd(instance,
1772                                                 reset_cmd->frame_phys_addr,
1773                                                 0, instance->reg_set);
1774                         } else {
1775                                 printk(KERN_NOTICE "megasas: %p unexpected"
1776                                         "cmds lst\n",
1777                                         reset_cmd);
1778                         }
1779                         reset_index++;
1780                 }
1781
1782                 return SUCCESS;
1783         }
1784
1785         for (i = 0; i < wait_time; i++) {
1786
1787                 int outstanding = atomic_read(&instance->fw_outstanding);
1788
1789                 if (!outstanding)
1790                         break;
1791
1792                 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
1793                         printk(KERN_NOTICE "megasas: [%2d]waiting for %d "
1794                                "commands to complete\n",i,outstanding);
1795                         /*
1796                          * Call cmd completion routine. Cmd to be
1797                          * be completed directly without depending on isr.
1798                          */
1799                         megasas_complete_cmd_dpc((unsigned long)instance);
1800                 }
1801
1802                 msleep(1000);
1803         }
1804
1805         i = 0;
1806         kill_adapter_flag = 0;
1807         do {
1808                 fw_state = instance->instancet->read_fw_status_reg(
1809                                         instance->reg_set) & MFI_STATE_MASK;
1810                 if ((fw_state == MFI_STATE_FAULT) &&
1811                         (instance->disableOnlineCtrlReset == 0)) {
1812                         if (i == 3) {
1813                                 kill_adapter_flag = 2;
1814                                 break;
1815                         }
1816                         megasas_do_ocr(instance);
1817                         kill_adapter_flag = 1;
1818
1819                         /* wait for 1 secs to let FW finish the pending cmds */
1820                         msleep(1000);
1821                 }
1822                 i++;
1823         } while (i <= 3);
1824
1825         if (atomic_read(&instance->fw_outstanding) &&
1826                                         !kill_adapter_flag) {
1827                 if (instance->disableOnlineCtrlReset == 0) {
1828
1829                         megasas_do_ocr(instance);
1830
1831                         /* wait for 5 secs to let FW finish the pending cmds */
1832                         for (i = 0; i < wait_time; i++) {
1833                                 int outstanding =
1834                                         atomic_read(&instance->fw_outstanding);
1835                                 if (!outstanding)
1836                                         return SUCCESS;
1837                                 msleep(1000);
1838                         }
1839                 }
1840         }
1841
1842         if (atomic_read(&instance->fw_outstanding) ||
1843                                         (kill_adapter_flag == 2)) {
1844                 printk(KERN_NOTICE "megaraid_sas: pending cmds after reset\n");
1845                 /*
1846                 * Send signal to FW to stop processing any pending cmds.
1847                 * The controller will be taken offline by the OS now.
1848                 */
1849                 if ((instance->pdev->device ==
1850                         PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
1851                         (instance->pdev->device ==
1852                         PCI_DEVICE_ID_LSI_SAS0071SKINNY)) {
1853                         writel(MFI_STOP_ADP,
1854                                 &instance->reg_set->doorbell);
1855                 } else {
1856                         writel(MFI_STOP_ADP,
1857                                 &instance->reg_set->inbound_doorbell);
1858                 }
1859                 megasas_dump_pending_frames(instance);
1860                 spin_lock_irqsave(&instance->hba_lock, flags);
1861                 instance->adprecovery   = MEGASAS_HW_CRITICAL_ERROR;
1862                 spin_unlock_irqrestore(&instance->hba_lock, flags);
1863                 return FAILED;
1864         }
1865
1866         printk(KERN_NOTICE "megaraid_sas: no pending cmds after reset\n");
1867
1868         return SUCCESS;
1869 }
1870
1871 /**
1872  * megasas_generic_reset -      Generic reset routine
1873  * @scmd:                       Mid-layer SCSI command
1874  *
1875  * This routine implements a generic reset handler for device, bus and host
1876  * reset requests. Device, bus and host specific reset handlers can use this
1877  * function after they do their specific tasks.
1878  */
1879 static int megasas_generic_reset(struct scsi_cmnd *scmd)
1880 {
1881         int ret_val;
1882         struct megasas_instance *instance;
1883
1884         instance = (struct megasas_instance *)scmd->device->host->hostdata;
1885
1886         scmd_printk(KERN_NOTICE, scmd, "megasas: RESET cmd=%x retries=%x\n",
1887                  scmd->cmnd[0], scmd->retries);
1888
1889         if (instance->adprecovery == MEGASAS_HW_CRITICAL_ERROR) {
1890                 printk(KERN_ERR "megasas: cannot recover from previous reset "
1891                        "failures\n");
1892                 return FAILED;
1893         }
1894
1895         ret_val = megasas_wait_for_outstanding(instance);
1896         if (ret_val == SUCCESS)
1897                 printk(KERN_NOTICE "megasas: reset successful \n");
1898         else
1899                 printk(KERN_ERR "megasas: failed to do reset\n");
1900
1901         return ret_val;
1902 }
1903
1904 /**
1905  * megasas_reset_timer - quiesce the adapter if required
1906  * @scmd:               scsi cmnd
1907  *
1908  * Sets the FW busy flag and reduces the host->can_queue if the
1909  * cmd has not been completed within the timeout period.
1910  */
1911 static enum
1912 blk_eh_timer_return megasas_reset_timer(struct scsi_cmnd *scmd)
1913 {
1914         struct megasas_instance *instance;
1915         unsigned long flags;
1916
1917         if (time_after(jiffies, scmd->jiffies_at_alloc +
1918                                 (MEGASAS_DEFAULT_CMD_TIMEOUT * 2) * HZ)) {
1919                 return BLK_EH_NOT_HANDLED;
1920         }
1921
1922         instance = (struct megasas_instance *)scmd->device->host->hostdata;
1923         if (!(instance->flag & MEGASAS_FW_BUSY)) {
1924                 /* FW is busy, throttle IO */
1925                 spin_lock_irqsave(instance->host->host_lock, flags);
1926
1927                 instance->host->can_queue = 16;
1928                 instance->last_time = jiffies;
1929                 instance->flag |= MEGASAS_FW_BUSY;
1930
1931                 spin_unlock_irqrestore(instance->host->host_lock, flags);
1932         }
1933         return BLK_EH_RESET_TIMER;
1934 }
1935
1936 /**
1937  * megasas_reset_device -       Device reset handler entry point
1938  */
1939 static int megasas_reset_device(struct scsi_cmnd *scmd)
1940 {
1941         int ret;
1942
1943         /*
1944          * First wait for all commands to complete
1945          */
1946         ret = megasas_generic_reset(scmd);
1947
1948         return ret;
1949 }
1950
1951 /**
1952  * megasas_reset_bus_host -     Bus & host reset handler entry point
1953  */
1954 static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
1955 {
1956         int ret;
1957         struct megasas_instance *instance;
1958         instance = (struct megasas_instance *)scmd->device->host->hostdata;
1959
1960         /*
1961          * First wait for all commands to complete
1962          */
1963         if ((instance->pdev->device == PCI_DEVICE_ID_LSI_FUSION) ||
1964             (instance->pdev->device == PCI_DEVICE_ID_LSI_INVADER))
1965                 ret = megasas_reset_fusion(scmd->device->host);
1966         else
1967                 ret = megasas_generic_reset(scmd);
1968
1969         return ret;
1970 }
1971
1972 /**
1973  * megasas_bios_param - Returns disk geometry for a disk
1974  * @sdev:               device handle
1975  * @bdev:               block device
1976  * @capacity:           drive capacity
1977  * @geom:               geometry parameters
1978  */
1979 static int
1980 megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
1981                  sector_t capacity, int geom[])
1982 {
1983         int heads;
1984         int sectors;
1985         sector_t cylinders;
1986         unsigned long tmp;
1987         /* Default heads (64) & sectors (32) */
1988         heads = 64;
1989         sectors = 32;
1990
1991         tmp = heads * sectors;
1992         cylinders = capacity;
1993
1994         sector_div(cylinders, tmp);
1995
1996         /*
1997          * Handle extended translation size for logical drives > 1Gb
1998          */
1999
2000         if (capacity >= 0x200000) {
2001                 heads = 255;
2002                 sectors = 63;
2003                 tmp = heads*sectors;
2004                 cylinders = capacity;
2005                 sector_div(cylinders, tmp);
2006         }
2007
2008         geom[0] = heads;
2009         geom[1] = sectors;
2010         geom[2] = cylinders;
2011
2012         return 0;
2013 }
2014
2015 static void megasas_aen_polling(struct work_struct *work);
2016
2017 /**
2018  * megasas_service_aen -        Processes an event notification
2019  * @instance:                   Adapter soft state
2020  * @cmd:                        AEN command completed by the ISR
2021  *
2022  * For AEN, driver sends a command down to FW that is held by the FW till an
2023  * event occurs. When an event of interest occurs, FW completes the command
2024  * that it was previously holding.
2025  *
2026  * This routines sends SIGIO signal to processes that have registered with the
2027  * driver for AEN.
2028  */
2029 static void
2030 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
2031 {
2032         unsigned long flags;
2033         /*
2034          * Don't signal app if it is just an aborted previously registered aen
2035          */
2036         if ((!cmd->abort_aen) && (instance->unload == 0)) {
2037                 spin_lock_irqsave(&poll_aen_lock, flags);
2038                 megasas_poll_wait_aen = 1;
2039                 spin_unlock_irqrestore(&poll_aen_lock, flags);
2040                 wake_up(&megasas_poll_wait);
2041                 kill_fasync(&megasas_async_queue, SIGIO, POLL_IN);
2042         }
2043         else
2044                 cmd->abort_aen = 0;
2045
2046         instance->aen_cmd = NULL;
2047         megasas_return_cmd(instance, cmd);
2048
2049         if ((instance->unload == 0) &&
2050                 ((instance->issuepend_done == 1))) {
2051                 struct megasas_aen_event *ev;
2052                 ev = kzalloc(sizeof(*ev), GFP_ATOMIC);
2053                 if (!ev) {
2054                         printk(KERN_ERR "megasas_service_aen: out of memory\n");
2055                 } else {
2056                         ev->instance = instance;
2057                         instance->ev = ev;
2058                         INIT_WORK(&ev->hotplug_work, megasas_aen_polling);
2059                         schedule_delayed_work(
2060                                 (struct delayed_work *)&ev->hotplug_work, 0);
2061                 }
2062         }
2063 }
2064
2065 static int megasas_change_queue_depth(struct scsi_device *sdev,
2066                                       int queue_depth, int reason)
2067 {
2068         if (reason != SCSI_QDEPTH_DEFAULT)
2069                 return -EOPNOTSUPP;
2070
2071         if (queue_depth > sdev->host->can_queue)
2072                 queue_depth = sdev->host->can_queue;
2073         scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev),
2074                                 queue_depth);
2075
2076         return queue_depth;
2077 }
2078
2079 /*
2080  * Scsi host template for megaraid_sas driver
2081  */
2082 static struct scsi_host_template megasas_template = {
2083
2084         .module = THIS_MODULE,
2085         .name = "LSI SAS based MegaRAID driver",
2086         .proc_name = "megaraid_sas",
2087         .slave_configure = megasas_slave_configure,
2088         .slave_alloc = megasas_slave_alloc,
2089         .queuecommand = megasas_queue_command,
2090         .eh_device_reset_handler = megasas_reset_device,
2091         .eh_bus_reset_handler = megasas_reset_bus_host,
2092         .eh_host_reset_handler = megasas_reset_bus_host,
2093         .eh_timed_out = megasas_reset_timer,
2094         .bios_param = megasas_bios_param,
2095         .use_clustering = ENABLE_CLUSTERING,
2096         .change_queue_depth = megasas_change_queue_depth,
2097 };
2098
2099 /**
2100  * megasas_complete_int_cmd -   Completes an internal command
2101  * @instance:                   Adapter soft state
2102  * @cmd:                        Command to be completed
2103  *
2104  * The megasas_issue_blocked_cmd() function waits for a command to complete
2105  * after it issues a command. This function wakes up that waiting routine by
2106  * calling wake_up() on the wait queue.
2107  */
2108 static void
2109 megasas_complete_int_cmd(struct megasas_instance *instance,
2110                          struct megasas_cmd *cmd)
2111 {
2112         cmd->cmd_status = cmd->frame->io.cmd_status;
2113
2114         if (cmd->cmd_status == ENODATA) {
2115                 cmd->cmd_status = 0;
2116         }
2117         wake_up(&instance->int_cmd_wait_q);
2118 }
2119
2120 /**
2121  * megasas_complete_abort -     Completes aborting a command
2122  * @instance:                   Adapter soft state
2123  * @cmd:                        Cmd that was issued to abort another cmd
2124  *
2125  * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
2126  * after it issues an abort on a previously issued command. This function
2127  * wakes up all functions waiting on the same wait queue.
2128  */
2129 static void
2130 megasas_complete_abort(struct megasas_instance *instance,
2131                        struct megasas_cmd *cmd)
2132 {
2133         if (cmd->sync_cmd) {
2134                 cmd->sync_cmd = 0;
2135                 cmd->cmd_status = 0;
2136                 wake_up(&instance->abort_cmd_wait_q);
2137         }
2138
2139         return;
2140 }
2141
2142 /**
2143  * megasas_complete_cmd -       Completes a command
2144  * @instance:                   Adapter soft state
2145  * @cmd:                        Command to be completed
2146  * @alt_status:                 If non-zero, use this value as status to
2147  *                              SCSI mid-layer instead of the value returned
2148  *                              by the FW. This should be used if caller wants
2149  *                              an alternate status (as in the case of aborted
2150  *                              commands)
2151  */
2152 void
2153 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
2154                      u8 alt_status)
2155 {
2156         int exception = 0;
2157         struct megasas_header *hdr = &cmd->frame->hdr;
2158         unsigned long flags;
2159         struct fusion_context *fusion = instance->ctrl_context;
2160
2161         /* flag for the retry reset */
2162         cmd->retry_for_fw_reset = 0;
2163
2164         if (cmd->scmd)
2165                 cmd->scmd->SCp.ptr = NULL;
2166
2167         switch (hdr->cmd) {
2168         case MFI_CMD_INVALID:
2169                 /* Some older 1068 controller FW may keep a pended
2170                    MR_DCMD_CTRL_EVENT_GET_INFO left over from the main kernel
2171                    when booting the kdump kernel.  Ignore this command to
2172                    prevent a kernel panic on shutdown of the kdump kernel. */
2173                 printk(KERN_WARNING "megaraid_sas: MFI_CMD_INVALID command "
2174                        "completed.\n");
2175                 printk(KERN_WARNING "megaraid_sas: If you have a controller "
2176                        "other than PERC5, please upgrade your firmware.\n");
2177                 break;
2178         case MFI_CMD_PD_SCSI_IO:
2179         case MFI_CMD_LD_SCSI_IO:
2180
2181                 /*
2182                  * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
2183                  * issued either through an IO path or an IOCTL path. If it
2184                  * was via IOCTL, we will send it to internal completion.
2185                  */
2186                 if (cmd->sync_cmd) {
2187                         cmd->sync_cmd = 0;
2188                         megasas_complete_int_cmd(instance, cmd);
2189                         break;
2190                 }
2191
2192         case MFI_CMD_LD_READ:
2193         case MFI_CMD_LD_WRITE:
2194
2195                 if (alt_status) {
2196                         cmd->scmd->result = alt_status << 16;
2197                         exception = 1;
2198                 }
2199
2200                 if (exception) {
2201
2202                         atomic_dec(&instance->fw_outstanding);
2203
2204                         scsi_dma_unmap(cmd->scmd);
2205                         cmd->scmd->scsi_done(cmd->scmd);
2206                         megasas_return_cmd(instance, cmd);
2207
2208                         break;
2209                 }
2210
2211                 switch (hdr->cmd_status) {
2212
2213                 case MFI_STAT_OK:
2214                         cmd->scmd->result = DID_OK << 16;
2215                         break;
2216
2217                 case MFI_STAT_SCSI_IO_FAILED:
2218                 case MFI_STAT_LD_INIT_IN_PROGRESS:
2219                         cmd->scmd->result =
2220                             (DID_ERROR << 16) | hdr->scsi_status;
2221                         break;
2222
2223                 case MFI_STAT_SCSI_DONE_WITH_ERROR:
2224
2225                         cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status;
2226
2227                         if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {
2228                                 memset(cmd->scmd->sense_buffer, 0,
2229                                        SCSI_SENSE_BUFFERSIZE);
2230                                 memcpy(cmd->scmd->sense_buffer, cmd->sense,
2231                                        hdr->sense_len);
2232
2233                                 cmd->scmd->result |= DRIVER_SENSE << 24;
2234                         }
2235
2236                         break;
2237
2238                 case MFI_STAT_LD_OFFLINE:
2239                 case MFI_STAT_DEVICE_NOT_FOUND:
2240                         cmd->scmd->result = DID_BAD_TARGET << 16;
2241                         break;
2242
2243                 default:
2244                         printk(KERN_DEBUG "megasas: MFI FW status %#x\n",
2245                                hdr->cmd_status);
2246                         cmd->scmd->result = DID_ERROR << 16;
2247                         break;
2248                 }
2249
2250                 atomic_dec(&instance->fw_outstanding);
2251
2252                 scsi_dma_unmap(cmd->scmd);
2253                 cmd->scmd->scsi_done(cmd->scmd);
2254                 megasas_return_cmd(instance, cmd);
2255
2256                 break;
2257
2258         case MFI_CMD_SMP:
2259         case MFI_CMD_STP:
2260         case MFI_CMD_DCMD:
2261                 /* Check for LD map update */
2262                 if ((cmd->frame->dcmd.opcode == MR_DCMD_LD_MAP_GET_INFO) &&
2263                     (cmd->frame->dcmd.mbox.b[1] == 1)) {
2264                         spin_lock_irqsave(instance->host->host_lock, flags);
2265                         if (cmd->frame->hdr.cmd_status != 0) {
2266                                 if (cmd->frame->hdr.cmd_status !=
2267                                     MFI_STAT_NOT_FOUND)
2268                                         printk(KERN_WARNING "megasas: map sync"
2269                                                "failed, status = 0x%x.\n",
2270                                                cmd->frame->hdr.cmd_status);
2271                                 else {
2272                                         megasas_return_cmd(instance, cmd);
2273                                         spin_unlock_irqrestore(
2274                                                 instance->host->host_lock,
2275                                                 flags);
2276                                         break;
2277                                 }
2278                         } else
2279                                 instance->map_id++;
2280                         megasas_return_cmd(instance, cmd);
2281                         if (MR_ValidateMapInfo(
2282                                     fusion->ld_map[(instance->map_id & 1)],
2283                                     fusion->load_balance_info))
2284                                 fusion->fast_path_io = 1;
2285                         else
2286                                 fusion->fast_path_io = 0;
2287                         megasas_sync_map_info(instance);
2288                         spin_unlock_irqrestore(instance->host->host_lock,
2289                                                flags);
2290                         break;
2291                 }
2292                 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET_INFO ||
2293                         cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_GET) {
2294                         spin_lock_irqsave(&poll_aen_lock, flags);
2295                         megasas_poll_wait_aen = 0;
2296                         spin_unlock_irqrestore(&poll_aen_lock, flags);
2297                 }
2298
2299                 /*
2300                  * See if got an event notification
2301                  */
2302                 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_WAIT)
2303                         megasas_service_aen(instance, cmd);
2304                 else
2305                         megasas_complete_int_cmd(instance, cmd);
2306
2307                 break;
2308
2309         case MFI_CMD_ABORT:
2310                 /*
2311                  * Cmd issued to abort another cmd returned
2312                  */
2313                 megasas_complete_abort(instance, cmd);
2314                 break;
2315
2316         default:
2317                 printk("megasas: Unknown command completed! [0x%X]\n",
2318                        hdr->cmd);
2319                 break;
2320         }
2321 }
2322
2323 /**
2324  * megasas_issue_pending_cmds_again -   issue all pending cmds
2325  *                                      in FW again because of the fw reset
2326  * @instance:                           Adapter soft state
2327  */
2328 static inline void
2329 megasas_issue_pending_cmds_again(struct megasas_instance *instance)
2330 {
2331         struct megasas_cmd *cmd;
2332         struct list_head clist_local;
2333         union megasas_evt_class_locale class_locale;
2334         unsigned long flags;
2335         u32 seq_num;
2336
2337         INIT_LIST_HEAD(&clist_local);
2338         spin_lock_irqsave(&instance->hba_lock, flags);
2339         list_splice_init(&instance->internal_reset_pending_q, &clist_local);
2340         spin_unlock_irqrestore(&instance->hba_lock, flags);
2341
2342         while (!list_empty(&clist_local)) {
2343                 cmd     = list_entry((&clist_local)->next,
2344                                         struct megasas_cmd, list);
2345                 list_del_init(&cmd->list);
2346
2347                 if (cmd->sync_cmd || cmd->scmd) {
2348                         printk(KERN_NOTICE "megaraid_sas: command %p, %p:%d"
2349                                 "detected to be pending while HBA reset.\n",
2350                                         cmd, cmd->scmd, cmd->sync_cmd);
2351
2352                         cmd->retry_for_fw_reset++;
2353
2354                         if (cmd->retry_for_fw_reset == 3) {
2355                                 printk(KERN_NOTICE "megaraid_sas: cmd %p, %p:%d"
2356                                         "was tried multiple times during reset."
2357                                         "Shutting down the HBA\n",
2358                                         cmd, cmd->scmd, cmd->sync_cmd);
2359                                 megaraid_sas_kill_hba(instance);
2360
2361                                 instance->adprecovery =
2362                                                 MEGASAS_HW_CRITICAL_ERROR;
2363                                 return;
2364                         }
2365                 }
2366
2367                 if (cmd->sync_cmd == 1) {
2368                         if (cmd->scmd) {
2369                                 printk(KERN_NOTICE "megaraid_sas: unexpected"
2370                                         "cmd attached to internal command!\n");
2371                         }
2372                         printk(KERN_NOTICE "megasas: %p synchronous cmd"
2373                                                 "on the internal reset queue,"
2374                                                 "issue it again.\n", cmd);
2375                         cmd->cmd_status = ENODATA;
2376                         instance->instancet->fire_cmd(instance,
2377                                                         cmd->frame_phys_addr ,
2378                                                         0, instance->reg_set);
2379                 } else if (cmd->scmd) {
2380                         printk(KERN_NOTICE "megasas: %p scsi cmd [%02x]"
2381                         "detected on the internal queue, issue again.\n",
2382                         cmd, cmd->scmd->cmnd[0]);
2383
2384                         atomic_inc(&instance->fw_outstanding);
2385                         instance->instancet->fire_cmd(instance,
2386                                         cmd->frame_phys_addr,
2387                                         cmd->frame_count-1, instance->reg_set);
2388                 } else {
2389                         printk(KERN_NOTICE "megasas: %p unexpected cmd on the"
2390                                 "internal reset defer list while re-issue!!\n",
2391                                 cmd);
2392                 }
2393         }
2394
2395         if (instance->aen_cmd) {
2396                 printk(KERN_NOTICE "megaraid_sas: aen_cmd in def process\n");
2397                 megasas_return_cmd(instance, instance->aen_cmd);
2398
2399                 instance->aen_cmd       = NULL;
2400         }
2401
2402         /*
2403         * Initiate AEN (Asynchronous Event Notification)
2404         */
2405         seq_num = instance->last_seq_num;
2406         class_locale.members.reserved = 0;
2407         class_locale.members.locale = MR_EVT_LOCALE_ALL;
2408         class_locale.members.class = MR_EVT_CLASS_DEBUG;
2409
2410         megasas_register_aen(instance, seq_num, class_locale.word);
2411 }
2412
2413 /**
2414  * Move the internal reset pending commands to a deferred queue.
2415  *
2416  * We move the commands pending at internal reset time to a
2417  * pending queue. This queue would be flushed after successful
2418  * completion of the internal reset sequence. if the internal reset
2419  * did not complete in time, the kernel reset handler would flush
2420  * these commands.
2421  **/
2422 static void
2423 megasas_internal_reset_defer_cmds(struct megasas_instance *instance)
2424 {
2425         struct megasas_cmd *cmd;
2426         int i;
2427         u32 max_cmd = instance->max_fw_cmds;
2428         u32 defer_index;
2429         unsigned long flags;
2430
2431         defer_index     = 0;
2432         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
2433         for (i = 0; i < max_cmd; i++) {
2434                 cmd = instance->cmd_list[i];
2435                 if (cmd->sync_cmd == 1 || cmd->scmd) {
2436                         printk(KERN_NOTICE "megasas: moving cmd[%d]:%p:%d:%p"
2437                                         "on the defer queue as internal\n",
2438                                 defer_index, cmd, cmd->sync_cmd, cmd->scmd);
2439
2440                         if (!list_empty(&cmd->list)) {
2441                                 printk(KERN_NOTICE "megaraid_sas: ERROR while"
2442                                         " moving this cmd:%p, %d %p, it was"
2443                                         "discovered on some list?\n",
2444                                         cmd, cmd->sync_cmd, cmd->scmd);
2445
2446                                 list_del_init(&cmd->list);
2447                         }
2448                         defer_index++;
2449                         list_add_tail(&cmd->list,
2450                                 &instance->internal_reset_pending_q);
2451                 }
2452         }
2453         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
2454 }
2455
2456
2457 static void
2458 process_fw_state_change_wq(struct work_struct *work)
2459 {
2460         struct megasas_instance *instance =
2461                 container_of(work, struct megasas_instance, work_init);
2462         u32 wait;
2463         unsigned long flags;
2464
2465         if (instance->adprecovery != MEGASAS_ADPRESET_SM_INFAULT) {
2466                 printk(KERN_NOTICE "megaraid_sas: error, recovery st %x \n",
2467                                 instance->adprecovery);
2468                 return ;
2469         }
2470
2471         if (instance->adprecovery == MEGASAS_ADPRESET_SM_INFAULT) {
2472                 printk(KERN_NOTICE "megaraid_sas: FW detected to be in fault"
2473                                         "state, restarting it...\n");
2474
2475                 instance->instancet->disable_intr(instance->reg_set);
2476                 atomic_set(&instance->fw_outstanding, 0);
2477
2478                 atomic_set(&instance->fw_reset_no_pci_access, 1);
2479                 instance->instancet->adp_reset(instance, instance->reg_set);
2480                 atomic_set(&instance->fw_reset_no_pci_access, 0 );
2481
2482                 printk(KERN_NOTICE "megaraid_sas: FW restarted successfully,"
2483                                         "initiating next stage...\n");
2484
2485                 printk(KERN_NOTICE "megaraid_sas: HBA recovery state machine,"
2486                                         "state 2 starting...\n");
2487
2488                 /*waitting for about 20 second before start the second init*/
2489                 for (wait = 0; wait < 30; wait++) {
2490                         msleep(1000);
2491                 }
2492
2493                 if (megasas_transition_to_ready(instance, 1)) {
2494                         printk(KERN_NOTICE "megaraid_sas:adapter not ready\n");
2495
2496                         megaraid_sas_kill_hba(instance);
2497                         instance->adprecovery   = MEGASAS_HW_CRITICAL_ERROR;
2498                         return ;
2499                 }
2500
2501                 if ((instance->pdev->device == PCI_DEVICE_ID_LSI_SAS1064R) ||
2502                         (instance->pdev->device == PCI_DEVICE_ID_DELL_PERC5) ||
2503                         (instance->pdev->device == PCI_DEVICE_ID_LSI_VERDE_ZCR)
2504                         ) {
2505                         *instance->consumer = *instance->producer;
2506                 } else {
2507                         *instance->consumer = 0;
2508                         *instance->producer = 0;
2509                 }
2510
2511                 megasas_issue_init_mfi(instance);
2512
2513                 spin_lock_irqsave(&instance->hba_lock, flags);
2514                 instance->adprecovery   = MEGASAS_HBA_OPERATIONAL;
2515                 spin_unlock_irqrestore(&instance->hba_lock, flags);
2516                 instance->instancet->enable_intr(instance->reg_set);
2517
2518                 megasas_issue_pending_cmds_again(instance);
2519                 instance->issuepend_done = 1;
2520         }
2521         return ;
2522 }
2523
2524 /**
2525  * megasas_deplete_reply_queue -        Processes all completed commands
2526  * @instance:                           Adapter soft state
2527  * @alt_status:                         Alternate status to be returned to
2528  *                                      SCSI mid-layer instead of the status
2529  *                                      returned by the FW
2530  * Note: this must be called with hba lock held
2531  */
2532 static int
2533 megasas_deplete_reply_queue(struct megasas_instance *instance,
2534                                         u8 alt_status)
2535 {
2536         u32 mfiStatus;
2537         u32 fw_state;
2538
2539         if ((mfiStatus = instance->instancet->check_reset(instance,
2540                                         instance->reg_set)) == 1) {
2541                 return IRQ_HANDLED;
2542         }
2543
2544         if ((mfiStatus = instance->instancet->clear_intr(
2545                                                 instance->reg_set)
2546                                                 ) == 0) {
2547                 /* Hardware may not set outbound_intr_status in MSI-X mode */
2548                 if (!instance->msix_vectors)
2549                         return IRQ_NONE;
2550         }
2551
2552         instance->mfiStatus = mfiStatus;
2553
2554         if ((mfiStatus & MFI_INTR_FLAG_FIRMWARE_STATE_CHANGE)) {
2555                 fw_state = instance->instancet->read_fw_status_reg(
2556                                 instance->reg_set) & MFI_STATE_MASK;
2557
2558                 if (fw_state != MFI_STATE_FAULT) {
2559                         printk(KERN_NOTICE "megaraid_sas: fw state:%x\n",
2560                                                 fw_state);
2561                 }
2562
2563                 if ((fw_state == MFI_STATE_FAULT) &&
2564                                 (instance->disableOnlineCtrlReset == 0)) {
2565                         printk(KERN_NOTICE "megaraid_sas: wait adp restart\n");
2566
2567                         if ((instance->pdev->device ==
2568                                         PCI_DEVICE_ID_LSI_SAS1064R) ||
2569                                 (instance->pdev->device ==
2570                                         PCI_DEVICE_ID_DELL_PERC5) ||
2571                                 (instance->pdev->device ==
2572                                         PCI_DEVICE_ID_LSI_VERDE_ZCR)) {
2573
2574                                 *instance->consumer =
2575                                         MEGASAS_ADPRESET_INPROG_SIGN;
2576                         }
2577
2578
2579                         instance->instancet->disable_intr(instance->reg_set);
2580                         instance->adprecovery   = MEGASAS_ADPRESET_SM_INFAULT;
2581                         instance->issuepend_done = 0;
2582
2583                         atomic_set(&instance->fw_outstanding, 0);
2584                         megasas_internal_reset_defer_cmds(instance);
2585
2586                         printk(KERN_NOTICE "megasas: fwState=%x, stage:%d\n",
2587                                         fw_state, instance->adprecovery);
2588
2589                         schedule_work(&instance->work_init);
2590                         return IRQ_HANDLED;
2591
2592                 } else {
2593                         printk(KERN_NOTICE "megasas: fwstate:%x, dis_OCR=%x\n",
2594                                 fw_state, instance->disableOnlineCtrlReset);
2595                 }
2596         }
2597
2598         tasklet_schedule(&instance->isr_tasklet);
2599         return IRQ_HANDLED;
2600 }
2601 /**
2602  * megasas_isr - isr entry point
2603  */
2604 static irqreturn_t megasas_isr(int irq, void *devp)
2605 {
2606         struct megasas_irq_context *irq_context = devp;
2607         struct megasas_instance *instance = irq_context->instance;
2608         unsigned long flags;
2609         irqreturn_t     rc;
2610
2611         if (atomic_read(&instance->fw_reset_no_pci_access))
2612                 return IRQ_HANDLED;
2613
2614         spin_lock_irqsave(&instance->hba_lock, flags);
2615         rc =  megasas_deplete_reply_queue(instance, DID_OK);
2616         spin_unlock_irqrestore(&instance->hba_lock, flags);
2617
2618         return rc;
2619 }
2620
2621 /**
2622  * megasas_transition_to_ready -        Move the FW to READY state
2623  * @instance:                           Adapter soft state
2624  *
2625  * During the initialization, FW passes can potentially be in any one of
2626  * several possible states. If the FW in operational, waiting-for-handshake
2627  * states, driver must take steps to bring it to ready state. Otherwise, it
2628  * has to wait for the ready state.
2629  */
2630 int
2631 megasas_transition_to_ready(struct megasas_instance *instance, int ocr)
2632 {
2633         int i;
2634         u8 max_wait;
2635         u32 fw_state;
2636         u32 cur_state;
2637         u32 abs_state, curr_abs_state;
2638
2639         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
2640
2641         if (fw_state != MFI_STATE_READY)
2642                 printk(KERN_INFO "megasas: Waiting for FW to come to ready"
2643                        " state\n");
2644
2645         while (fw_state != MFI_STATE_READY) {
2646
2647                 abs_state =
2648                 instance->instancet->read_fw_status_reg(instance->reg_set);
2649
2650                 switch (fw_state) {
2651
2652                 case MFI_STATE_FAULT:
2653                         printk(KERN_DEBUG "megasas: FW in FAULT state!!\n");
2654                         if (ocr) {
2655                                 max_wait = MEGASAS_RESET_WAIT_TIME;
2656                                 cur_state = MFI_STATE_FAULT;
2657                                 break;
2658                         } else
2659                                 return -ENODEV;
2660
2661                 case MFI_STATE_WAIT_HANDSHAKE:
2662                         /*
2663                          * Set the CLR bit in inbound doorbell
2664                          */
2665                         if ((instance->pdev->device ==
2666                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2667                                 (instance->pdev->device ==
2668                                  PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2669                                 (instance->pdev->device ==
2670                                  PCI_DEVICE_ID_LSI_FUSION) ||
2671                                 (instance->pdev->device ==
2672                                 PCI_DEVICE_ID_LSI_INVADER)) {
2673                                 writel(
2674                                   MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
2675                                   &instance->reg_set->doorbell);
2676                         } else {
2677                                 writel(
2678                                     MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
2679                                         &instance->reg_set->inbound_doorbell);
2680                         }
2681
2682                         max_wait = MEGASAS_RESET_WAIT_TIME;
2683                         cur_state = MFI_STATE_WAIT_HANDSHAKE;
2684                         break;
2685
2686                 case MFI_STATE_BOOT_MESSAGE_PENDING:
2687                         if ((instance->pdev->device ==
2688                              PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2689                                 (instance->pdev->device ==
2690                                  PCI_DEVICE_ID_LSI_SAS0071SKINNY) ||
2691                             (instance->pdev->device ==
2692                              PCI_DEVICE_ID_LSI_FUSION) ||
2693                             (instance->pdev->device ==
2694                              PCI_DEVICE_ID_LSI_INVADER)) {
2695                                 writel(MFI_INIT_HOTPLUG,
2696                                        &instance->reg_set->doorbell);
2697                         } else
2698                                 writel(MFI_INIT_HOTPLUG,
2699                                         &instance->reg_set->inbound_doorbell);
2700
2701                         max_wait = MEGASAS_RESET_WAIT_TIME;
2702                         cur_state = MFI_STATE_BOOT_MESSAGE_PENDING;
2703                         break;
2704
2705                 case MFI_STATE_OPERATIONAL:
2706                         /*
2707                          * Bring it to READY state; assuming max wait 10 secs
2708                          */
2709                         instance->instancet->disable_intr(instance->reg_set);
2710                         if ((instance->pdev->device ==
2711                                 PCI_DEVICE_ID_LSI_SAS0073SKINNY) ||
2712                                 (instance->pdev->device ==
2713                                 PCI_DEVICE_ID_LSI_SAS0071SKINNY)  ||
2714                                 (instance->pdev->device
2715                                         == PCI_DEVICE_ID_LSI_FUSION) ||
2716                                 (instance->pdev->device
2717                                         == PCI_DEVICE_ID_LSI_INVADER)) {
2718                                 writel(MFI_RESET_FLAGS,
2719                                         &instance->reg_set->doorbell);
2720                                 if ((instance->pdev->device ==
2721                                     PCI_DEVICE_ID_LSI_FUSION) ||
2722                                     (instance->pdev->device ==
2723                                      PCI_DEVICE_ID_LSI_INVADER)) {
2724                                         for (i = 0; i < (10 * 1000); i += 20) {
2725                                                 if (readl(
2726                                                             &instance->
2727                                                             reg_set->
2728                                                             doorbell) & 1)
2729                                                         msleep(20);
2730                                                 else
2731                                                         break;
2732                                         }
2733                                 }
2734                         } else
2735                                 writel(MFI_RESET_FLAGS,
2736                                         &instance->reg_set->inbound_doorbell);
2737
2738                         max_wait = MEGASAS_RESET_WAIT_TIME;
2739                         cur_state = MFI_STATE_OPERATIONAL;
2740                         break;
2741
2742                 case MFI_STATE_UNDEFINED:
2743                         /*
2744                          * This state should not last for more than 2 seconds
2745                          */
2746                         max_wait = MEGASAS_RESET_WAIT_TIME;
2747                         cur_state = MFI_STATE_UNDEFINED;
2748                         break;
2749
2750                 case MFI_STATE_BB_INIT:
2751                         max_wait = MEGASAS_RESET_WAIT_TIME;
2752                         cur_state = MFI_STATE_BB_INIT;
2753                         break;
2754
2755                 case MFI_STATE_FW_INIT:
2756                         max_wait = MEGASAS_RESET_WAIT_TIME;
2757                         cur_state = MFI_STATE_FW_INIT;
2758                         break;
2759
2760                 case MFI_STATE_FW_INIT_2:
2761                         max_wait = MEGASAS_RESET_WAIT_TIME;
2762                         cur_state = MFI_STATE_FW_INIT_2;
2763                         break;
2764
2765                 case MFI_STATE_DEVICE_SCAN:
2766                         max_wait = MEGASAS_RESET_WAIT_TIME;
2767                         cur_state = MFI_STATE_DEVICE_SCAN;
2768                         break;
2769
2770                 case MFI_STATE_FLUSH_CACHE:
2771                         max_wait = MEGASAS_RESET_WAIT_TIME;
2772                         cur_state = MFI_STATE_FLUSH_CACHE;
2773                         break;
2774
2775                 default:
2776                         printk(KERN_DEBUG "megasas: Unknown state 0x%x\n",
2777                                fw_state);
2778                         return -ENODEV;
2779                 }
2780
2781                 /*
2782                  * The cur_state should not last for more than max_wait secs
2783                  */
2784                 for (i = 0; i < (max_wait * 1000); i++) {
2785                         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) &
2786                                         MFI_STATE_MASK ;
2787                 curr_abs_state =
2788                 instance->instancet->read_fw_status_reg(instance->reg_set);
2789
2790                         if (abs_state == curr_abs_state) {
2791                                 msleep(1);
2792                         } else
2793                                 break;
2794                 }
2795
2796                 /*
2797                  * Return error if fw_state hasn't changed after max_wait
2798                  */
2799                 if (curr_abs_state == abs_state) {
2800                         printk(KERN_DEBUG "FW state [%d] hasn't changed "
2801                                "in %d secs\n", fw_state, max_wait);
2802                         return -ENODEV;
2803                 }
2804         }
2805         printk(KERN_INFO "megasas: FW now in Ready state\n");
2806
2807         return 0;
2808 }
2809
2810 /**
2811  * megasas_teardown_frame_pool -        Destroy the cmd frame DMA pool
2812  * @instance:                           Adapter soft state
2813  */
2814 static void megasas_teardown_frame_pool(struct megasas_instance *instance)
2815 {
2816         int i;
2817         u32 max_cmd = instance->max_mfi_cmds;
2818         struct megasas_cmd *cmd;
2819
2820         if (!instance->frame_dma_pool)
2821                 return;
2822
2823         /*
2824          * Return all frames to pool
2825          */
2826         for (i = 0; i < max_cmd; i++) {
2827
2828                 cmd = instance->cmd_list[i];
2829
2830                 if (cmd->frame)
2831                         pci_pool_free(instance->frame_dma_pool, cmd->frame,
2832                                       cmd->frame_phys_addr);
2833
2834                 if (cmd->sense)
2835                         pci_pool_free(instance->sense_dma_pool, cmd->sense,
2836                                       cmd->sense_phys_addr);
2837         }
2838
2839         /*
2840          * Now destroy the pool itself
2841          */
2842         pci_pool_destroy(instance->frame_dma_pool);
2843         pci_pool_destroy(instance->sense_dma_pool);
2844
2845         instance->frame_dma_pool = NULL;
2846         instance->sense_dma_pool = NULL;
2847 }
2848
2849 /**
2850  * megasas_create_frame_pool -  Creates DMA pool for cmd frames
2851  * @instance:                   Adapter soft state
2852  *
2853  * Each command packet has an embedded DMA memory buffer that is used for
2854  * filling MFI frame and the SG list that immediately follows the frame. This
2855  * function creates those DMA memory buffers for each command packet by using
2856  * PCI pool facility.
2857  */
2858 static int megasas_create_frame_pool(struct megasas_instance *instance)
2859 {
2860         int i;
2861         u32 max_cmd;
2862         u32 sge_sz;
2863         u32 sgl_sz;
2864         u32 total_sz;
2865         u32 frame_count;
2866         struct megasas_cmd *cmd;
2867
2868         max_cmd = instance->max_mfi_cmds;
2869
2870         /*
2871          * Size of our frame is 64 bytes for MFI frame, followed by max SG
2872          * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer
2873          */
2874         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
2875             sizeof(struct megasas_sge32);
2876
2877         if (instance->flag_ieee) {
2878                 sge_sz = sizeof(struct megasas_sge_skinny);
2879         }
2880
2881         /*
2882          * Calculated the number of 64byte frames required for SGL
2883          */
2884         sgl_sz = sge_sz * instance->max_num_sge;
2885         frame_count = (sgl_sz + MEGAMFI_FRAME_SIZE - 1) / MEGAMFI_FRAME_SIZE;
2886         frame_count = 15;
2887
2888         /*
2889          * We need one extra frame for the MFI command
2890          */
2891         frame_count++;
2892
2893         total_sz = MEGAMFI_FRAME_SIZE * frame_count;
2894         /*
2895          * Use DMA pool facility provided by PCI layer
2896          */
2897         instance->frame_dma_pool = pci_pool_create("megasas frame pool",
2898                                                    instance->pdev, total_sz, 64,
2899                                                    0);
2900
2901         if (!instance->frame_dma_pool) {
2902                 printk(KERN_DEBUG "megasas: failed to setup frame pool\n");
2903                 return -ENOMEM;
2904         }
2905
2906         instance->sense_dma_pool = pci_pool_create("megasas sense pool",
2907                                                    instance->pdev, 128, 4, 0);
2908
2909         if (!instance->sense_dma_pool) {
2910                 printk(KERN_DEBUG "megasas: failed to setup sense pool\n");
2911
2912                 pci_pool_destroy(instance->frame_dma_pool);
2913                 instance->frame_dma_pool = NULL;
2914
2915                 return -ENOMEM;
2916         }
2917
2918         /*
2919          * Allocate and attach a frame to each of the commands in cmd_list.
2920          * By making cmd->index as the context instead of the &cmd, we can
2921          * always use 32bit context regardless of the architecture
2922          */
2923         for (i = 0; i < max_cmd; i++) {
2924
2925                 cmd = instance->cmd_list[i];
2926
2927                 cmd->frame = pci_pool_alloc(instance->frame_dma_pool,
2928                                             GFP_KERNEL, &cmd->frame_phys_addr);
2929
2930                 cmd->sense = pci_pool_alloc(instance->sense_dma_pool,
2931                                             GFP_KERNEL, &cmd->sense_phys_addr);
2932
2933                 /*
2934                  * megasas_teardown_frame_pool() takes care of freeing
2935                  * whatever has been allocated
2936                  */
2937                 if (!cmd->frame || !cmd->sense) {
2938                         printk(KERN_DEBUG "megasas: pci_pool_alloc failed \n");
2939                         megasas_teardown_frame_pool(instance);
2940                         return -ENOMEM;
2941                 }
2942
2943                 memset(cmd->frame, 0, total_sz);
2944                 cmd->frame->io.context = cmd->index;
2945                 cmd->frame->io.pad_0 = 0;
2946                 if ((instance->pdev->device != PCI_DEVICE_ID_LSI_FUSION) &&
2947                     (instance->pdev->device != PCI_DEVICE_ID_LSI_INVADER) &&
2948                     (reset_devices))
2949                         cmd->frame->hdr.cmd = MFI_CMD_INVALID;
2950         }
2951
2952         return 0;
2953 }
2954
2955 /**
2956  * megasas_free_cmds -  Free all the cmds in the free cmd pool
2957  * @instance:           Adapter soft state
2958  */
2959 void megasas_free_cmds(struct megasas_instance *instance)
2960 {
2961         int i;
2962         /* First free the MFI frame pool */
2963         megasas_teardown_frame_pool(instance);
2964
2965         /* Free all the commands in the cmd_list */
2966         for (i = 0; i < instance->max_mfi_cmds; i++)
2967
2968                 kfree(instance->cmd_list[i]);
2969
2970         /* Free the cmd_list buffer itself */