drivers/scsi/megaraid/megaraid_sas.c

   1 /*
   2  *
   3  *              Linux MegaRAID driver for SAS based RAID controllers
   4  *
   5  * Copyright (c) 2003-2005  LSI Logic Corporation.
   6  *
   7  *         This program is free software; you can redistribute it and/or
   8  *         modify it under the terms of the GNU General Public License
   9  *         as published by the Free Software Foundation; either version
  10  *         2 of the License, or (at your option) any later version.
  11  *
  12  * FILE         : megaraid_sas.c
  13  * Version      : v00.00.03.10-rc1
  14  *
  15  * Authors:
  16  *      (email-id : megaraidlinux@lsi.com)
  17  *      Sreenivas Bagalkote
  18  *      Sumant Patro
  19  *      Bo Yang
  20  *
  21  * List of supported controllers
  22  *
  23  * OEM  Product Name                    VID     DID     SSVID   SSID
  24  * ---  ------------                    ---     ---     ----    ----
  25  */
  26
  27 #include <linux/kernel.h>
  28 #include <linux/types.h>
  29 #include <linux/pci.h>
  30 #include <linux/list.h>
  31 #include <linux/moduleparam.h>
  32 #include <linux/module.h>
  33 #include <linux/spinlock.h>
  34 #include <linux/interrupt.h>
  35 #include <linux/delay.h>
  36 #include <linux/uio.h>
  37 #include <asm/uaccess.h>
  38 #include <linux/fs.h>
  39 #include <linux/compat.h>
  40 #include <linux/blkdev.h>
  41 #include <linux/mutex.h>
  42
  43 #include <scsi/scsi.h>
  44 #include <scsi/scsi_cmnd.h>
  45 #include <scsi/scsi_device.h>
  46 #include <scsi/scsi_host.h>
  47 #include "megaraid_sas.h"
  48
  49 MODULE_LICENSE("GPL");
  50 MODULE_VERSION(MEGASAS_VERSION);
  51 MODULE_AUTHOR("megaraidlinux@lsi.com");
  52 MODULE_DESCRIPTION("LSI Logic MegaRAID SAS Driver");
  53
  54 /*
  55  * PCI ID table for all supported controllers
  56  */
  57 static struct pci_device_id megasas_pci_table[] = {
  58
  59         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1064R)},
  60         /* xscale IOP */
  61         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_SAS1078R)},
  62         /* ppc IOP */
  63         {PCI_DEVICE(PCI_VENDOR_ID_LSI_LOGIC, PCI_DEVICE_ID_LSI_VERDE_ZCR)},
  64         /* xscale IOP, vega */
  65         {PCI_DEVICE(PCI_VENDOR_ID_DELL, PCI_DEVICE_ID_DELL_PERC5)},
  66         /* xscale IOP */
  67         {}
  68 };
  69
  70 MODULE_DEVICE_TABLE(pci, megasas_pci_table);
  71
  72 static int megasas_mgmt_majorno;
  73 static struct megasas_mgmt_info megasas_mgmt_info;
  74 static struct fasync_struct *megasas_async_queue;
  75 static DEFINE_MUTEX(megasas_async_queue_mutex);
  76
  77 static u32 megasas_dbg_lvl;
  78
  79 /**
  80  * megasas_get_cmd -    Get a command from the free pool
  81  * @instance:           Adapter soft state
  82  *
  83  * Returns a free command from the pool
  84  */
  85 static struct megasas_cmd *megasas_get_cmd(struct megasas_instance
  86                                                   *instance)
  87 {
  88         unsigned long flags;
  89         struct megasas_cmd *cmd = NULL;
  90
  91         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
  92
  93         if (!list_empty(&instance->cmd_pool)) {
  94                 cmd = list_entry((&instance->cmd_pool)->next,
  95                                  struct megasas_cmd, list);
  96                 list_del_init(&cmd->list);
  97         } else {
  98                 printk(KERN_ERR "megasas: Command pool empty!\n");
  99         }
 100
 101         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
 102         return cmd;
 103 }
 104
 105 /**
 106  * megasas_return_cmd - Return a cmd to free command pool
 107  * @instance:           Adapter soft state
 108  * @cmd:                Command packet to be returned to free command pool
 109  */
 110 static inline void
 111 megasas_return_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd)
 112 {
 113         unsigned long flags;
 114
 115         spin_lock_irqsave(&instance->cmd_pool_lock, flags);
 116
 117         cmd->scmd = NULL;
 118         list_add_tail(&cmd->list, &instance->cmd_pool);
 119
 120         spin_unlock_irqrestore(&instance->cmd_pool_lock, flags);
 121 }
 122
 123
 124 /**
 125 *       The following functions are defined for xscale
 126 *       (deviceid : 1064R, PERC5) controllers
 127 */
 128
 129 /**
 130  * megasas_enable_intr_xscale - Enables interrupts
 131  * @regs:                       MFI register set
 132  */
 133 static inline void
 134 megasas_enable_intr_xscale(struct megasas_register_set __iomem * regs)
 135 {
 136         writel(1, &(regs)->outbound_intr_mask);
 137
 138         /* Dummy readl to force pci flush */
 139         readl(&regs->outbound_intr_mask);
 140 }
 141
 142 /**
 143  * megasas_disable_intr_xscale -Disables interrupt
 144  * @regs:                       MFI register set
 145  */
 146 static inline void
 147 megasas_disable_intr_xscale(struct megasas_register_set __iomem * regs)
 148 {
 149         u32 mask = 0x1f;
 150         writel(mask, &regs->outbound_intr_mask);
 151         /* Dummy readl to force pci flush */
 152         readl(&regs->outbound_intr_mask);
 153 }
 154
 155 /**
 156  * megasas_read_fw_status_reg_xscale - returns the current FW status value
 157  * @regs:                       MFI register set
 158  */
 159 static u32
 160 megasas_read_fw_status_reg_xscale(struct megasas_register_set __iomem * regs)
 161 {
 162         return readl(&(regs)->outbound_msg_0);
 163 }
 164 /**
 165  * megasas_clear_interrupt_xscale -     Check & clear interrupt
 166  * @regs:                               MFI register set
 167  */
 168 static int
 169 megasas_clear_intr_xscale(struct megasas_register_set __iomem * regs)
 170 {
 171         u32 status;
 172         /*
 173          * Check if it is our interrupt
 174          */
 175         status = readl(&regs->outbound_intr_status);
 176
 177         if (!(status & MFI_OB_INTR_STATUS_MASK)) {
 178                 return 1;
 179         }
 180
 181         /*
 182          * Clear the interrupt by writing back the same value
 183          */
 184         writel(status, &regs->outbound_intr_status);
 185
 186         return 0;
 187 }
 188
 189 /**
 190  * megasas_fire_cmd_xscale -    Sends command to the FW
 191  * @frame_phys_addr :           Physical address of cmd
 192  * @frame_count :               Number of frames for the command
 193  * @regs :                      MFI register set
 194  */
 195 static inline void
 196 megasas_fire_cmd_xscale(dma_addr_t frame_phys_addr,u32 frame_count, struct megasas_register_set __iomem *regs)
 197 {
 198         writel((frame_phys_addr >> 3)|(frame_count),
 199                &(regs)->inbound_queue_port);
 200 }
 201
 202 static struct megasas_instance_template megasas_instance_template_xscale = {
 203
 204         .fire_cmd = megasas_fire_cmd_xscale,
 205         .enable_intr = megasas_enable_intr_xscale,
 206         .disable_intr = megasas_disable_intr_xscale,
 207         .clear_intr = megasas_clear_intr_xscale,
 208         .read_fw_status_reg = megasas_read_fw_status_reg_xscale,
 209 };
 210
 211 /**
 212 *       This is the end of set of functions & definitions specific
 213 *       to xscale (deviceid : 1064R, PERC5) controllers
 214 */
 215
 216 /**
 217 *       The following functions are defined for ppc (deviceid : 0x60)
 218 *       controllers
 219 */
 220
 221 /**
 222  * megasas_enable_intr_ppc -    Enables interrupts
 223  * @regs:                       MFI register set
 224  */
 225 static inline void
 226 megasas_enable_intr_ppc(struct megasas_register_set __iomem * regs)
 227 {
 228         writel(0xFFFFFFFF, &(regs)->outbound_doorbell_clear);
 229
 230         writel(~0x80000004, &(regs)->outbound_intr_mask);
 231
 232         /* Dummy readl to force pci flush */
 233         readl(&regs->outbound_intr_mask);
 234 }
 235
 236 /**
 237  * megasas_disable_intr_ppc -   Disable interrupt
 238  * @regs:                       MFI register set
 239  */
 240 static inline void
 241 megasas_disable_intr_ppc(struct megasas_register_set __iomem * regs)
 242 {
 243         u32 mask = 0xFFFFFFFF;
 244         writel(mask, &regs->outbound_intr_mask);
 245         /* Dummy readl to force pci flush */
 246         readl(&regs->outbound_intr_mask);
 247 }
 248
 249 /**
 250  * megasas_read_fw_status_reg_ppc - returns the current FW status value
 251  * @regs:                       MFI register set
 252  */
 253 static u32
 254 megasas_read_fw_status_reg_ppc(struct megasas_register_set __iomem * regs)
 255 {
 256         return readl(&(regs)->outbound_scratch_pad);
 257 }
 258
 259 /**
 260  * megasas_clear_interrupt_ppc -        Check & clear interrupt
 261  * @regs:                               MFI register set
 262  */
 263 static int
 264 megasas_clear_intr_ppc(struct megasas_register_set __iomem * regs)
 265 {
 266         u32 status;
 267         /*
 268          * Check if it is our interrupt
 269          */
 270         status = readl(&regs->outbound_intr_status);
 271
 272         if (!(status & MFI_REPLY_1078_MESSAGE_INTERRUPT)) {
 273                 return 1;
 274         }
 275
 276         /*
 277          * Clear the interrupt by writing back the same value
 278          */
 279         writel(status, &regs->outbound_doorbell_clear);
 280
 281         return 0;
 282 }
 283 /**
 284  * megasas_fire_cmd_ppc -       Sends command to the FW
 285  * @frame_phys_addr :           Physical address of cmd
 286  * @frame_count :               Number of frames for the command
 287  * @regs :                      MFI register set
 288  */
 289 static inline void
 290 megasas_fire_cmd_ppc(dma_addr_t frame_phys_addr, u32 frame_count, struct megasas_register_set __iomem *regs)
 291 {
 292         writel((frame_phys_addr | (frame_count<<1))|1,
 293                         &(regs)->inbound_queue_port);
 294 }
 295
 296 static struct megasas_instance_template megasas_instance_template_ppc = {
 297
 298         .fire_cmd = megasas_fire_cmd_ppc,
 299         .enable_intr = megasas_enable_intr_ppc,
 300         .disable_intr = megasas_disable_intr_ppc,
 301         .clear_intr = megasas_clear_intr_ppc,
 302         .read_fw_status_reg = megasas_read_fw_status_reg_ppc,
 303 };
 304
 305 /**
 306 *       This is the end of set of functions & definitions
 307 *       specific to ppc (deviceid : 0x60) controllers
 308 */
 309
 310 /**
 311  * megasas_issue_polled -       Issues a polling command
 312  * @instance:                   Adapter soft state
 313  * @cmd:                        Command packet to be issued
 314  *
 315  * For polling, MFI requires the cmd_status to be set to 0xFF before posting.
 316  */
 317 static int
 318 megasas_issue_polled(struct megasas_instance *instance, struct megasas_cmd *cmd)
 319 {
 320         int i;
 321         u32 msecs = MFI_POLL_TIMEOUT_SECS * 1000;
 322
 323         struct megasas_header *frame_hdr = &cmd->frame->hdr;
 324
 325         frame_hdr->cmd_status = 0xFF;
 326         frame_hdr->flags |= MFI_FRAME_DONT_POST_IN_REPLY_QUEUE;
 327
 328         /*
 329          * Issue the frame using inbound queue port
 330          */
 331         instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
 332
 333         /*
 334          * Wait for cmd_status to change
 335          */
 336         for (i = 0; (i < msecs) && (frame_hdr->cmd_status == 0xff); i++) {
 337                 rmb();
 338                 msleep(1);
 339         }
 340
 341         if (frame_hdr->cmd_status == 0xff)
 342                 return -ETIME;
 343
 344         return 0;
 345 }
 346
 347 /**
 348  * megasas_issue_blocked_cmd -  Synchronous wrapper around regular FW cmds
 349  * @instance:                   Adapter soft state
 350  * @cmd:                        Command to be issued
 351  *
 352  * This function waits on an event for the command to be returned from ISR.
 353  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
 354  * Used to issue ioctl commands.
 355  */
 356 static int
 357 megasas_issue_blocked_cmd(struct megasas_instance *instance,
 358                           struct megasas_cmd *cmd)
 359 {
 360         cmd->cmd_status = ENODATA;
 361
 362         instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
 363
 364         wait_event_timeout(instance->int_cmd_wait_q, (cmd->cmd_status != ENODATA),
 365                 MEGASAS_INTERNAL_CMD_WAIT_TIME*HZ);
 366
 367         return 0;
 368 }
 369
 370 /**
 371  * megasas_issue_blocked_abort_cmd -    Aborts previously issued cmd
 372  * @instance:                           Adapter soft state
 373  * @cmd_to_abort:                       Previously issued cmd to be aborted
 374  *
 375  * MFI firmware can abort previously issued AEN comamnd (automatic event
 376  * notification). The megasas_issue_blocked_abort_cmd() issues such abort
 377  * cmd and waits for return status.
 378  * Max wait time is MEGASAS_INTERNAL_CMD_WAIT_TIME secs
 379  */
 380 static int
 381 megasas_issue_blocked_abort_cmd(struct megasas_instance *instance,
 382                                 struct megasas_cmd *cmd_to_abort)
 383 {
 384         struct megasas_cmd *cmd;
 385         struct megasas_abort_frame *abort_fr;
 386
 387         cmd = megasas_get_cmd(instance);
 388
 389         if (!cmd)
 390                 return -1;
 391
 392         abort_fr = &cmd->frame->abort;
 393
 394         /*
 395          * Prepare and issue the abort frame
 396          */
 397         abort_fr->cmd = MFI_CMD_ABORT;
 398         abort_fr->cmd_status = 0xFF;
 399         abort_fr->flags = 0;
 400         abort_fr->abort_context = cmd_to_abort->index;
 401         abort_fr->abort_mfi_phys_addr_lo = cmd_to_abort->frame_phys_addr;
 402         abort_fr->abort_mfi_phys_addr_hi = 0;
 403
 404         cmd->sync_cmd = 1;
 405         cmd->cmd_status = 0xFF;
 406
 407         instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
 408
 409         /*
 410          * Wait for this cmd to complete
 411          */
 412         wait_event_timeout(instance->abort_cmd_wait_q, (cmd->cmd_status != 0xFF),
 413                 MEGASAS_INTERNAL_CMD_WAIT_TIME*HZ);
 414
 415         megasas_return_cmd(instance, cmd);
 416         return 0;
 417 }
 418
 419 /**
 420  * megasas_make_sgl32 - Prepares 32-bit SGL
 421  * @instance:           Adapter soft state
 422  * @scp:                SCSI command from the mid-layer
 423  * @mfi_sgl:            SGL to be filled in
 424  *
 425  * If successful, this function returns the number of SG elements. Otherwise,
 426  * it returnes -1.
 427  */
 428 static int
 429 megasas_make_sgl32(struct megasas_instance *instance, struct scsi_cmnd *scp,
 430                    union megasas_sgl *mfi_sgl)
 431 {
 432         int i;
 433         int sge_count;
 434         struct scatterlist *os_sgl;
 435
 436         /*
 437          * Return 0 if there is no data transfer
 438          */
 439         if (!scp->request_buffer || !scp->request_bufflen)
 440                 return 0;
 441
 442         if (!scp->use_sg) {
 443                 mfi_sgl->sge32[0].phys_addr = pci_map_single(instance->pdev,
 444                                                              scp->
 445                                                              request_buffer,
 446                                                              scp->
 447                                                              request_bufflen,
 448                                                              scp->
 449                                                              sc_data_direction);
 450                 mfi_sgl->sge32[0].length = scp->request_bufflen;
 451
 452                 return 1;
 453         }
 454
 455         os_sgl = (struct scatterlist *)scp->request_buffer;
 456         sge_count = pci_map_sg(instance->pdev, os_sgl, scp->use_sg,
 457                                scp->sc_data_direction);
 458
 459         for (i = 0; i < sge_count; i++, os_sgl++) {
 460                 mfi_sgl->sge32[i].length = sg_dma_len(os_sgl);
 461                 mfi_sgl->sge32[i].phys_addr = sg_dma_address(os_sgl);
 462         }
 463
 464         return sge_count;
 465 }
 466
 467 /**
 468  * megasas_make_sgl64 - Prepares 64-bit SGL
 469  * @instance:           Adapter soft state
 470  * @scp:                SCSI command from the mid-layer
 471  * @mfi_sgl:            SGL to be filled in
 472  *
 473  * If successful, this function returns the number of SG elements. Otherwise,
 474  * it returnes -1.
 475  */
 476 static int
 477 megasas_make_sgl64(struct megasas_instance *instance, struct scsi_cmnd *scp,
 478                    union megasas_sgl *mfi_sgl)
 479 {
 480         int i;
 481         int sge_count;
 482         struct scatterlist *os_sgl;
 483
 484         /*
 485          * Return 0 if there is no data transfer
 486          */
 487         if (!scp->request_buffer || !scp->request_bufflen)
 488                 return 0;
 489
 490         if (!scp->use_sg) {
 491                 mfi_sgl->sge64[0].phys_addr = pci_map_single(instance->pdev,
 492                                                              scp->
 493                                                              request_buffer,
 494                                                              scp->
 495                                                              request_bufflen,
 496                                                              scp->
 497                                                              sc_data_direction);
 498
 499                 mfi_sgl->sge64[0].length = scp->request_bufflen;
 500
 501                 return 1;
 502         }
 503
 504         os_sgl = (struct scatterlist *)scp->request_buffer;
 505         sge_count = pci_map_sg(instance->pdev, os_sgl, scp->use_sg,
 506                                scp->sc_data_direction);
 507
 508         for (i = 0; i < sge_count; i++, os_sgl++) {
 509                 mfi_sgl->sge64[i].length = sg_dma_len(os_sgl);
 510                 mfi_sgl->sge64[i].phys_addr = sg_dma_address(os_sgl);
 511         }
 512
 513         return sge_count;
 514 }
 515
 516  /**
 517  * megasas_get_frame_count - Computes the number of frames
 518  * @sge_count           : number of sg elements
 519  *
 520  * Returns the number of frames required for numnber of sge's (sge_count)
 521  */
 522
 523 static u32 megasas_get_frame_count(u8 sge_count)
 524 {
 525         int num_cnt;
 526         int sge_bytes;
 527         u32 sge_sz;
 528         u32 frame_count=0;
 529
 530         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
 531             sizeof(struct megasas_sge32);
 532
 533         /*
 534         * Main frame can contain 2 SGEs for 64-bit SGLs and
 535         * 3 SGEs for 32-bit SGLs
 536         */
 537         if (IS_DMA64)
 538                 num_cnt = sge_count - 2;
 539         else
 540                 num_cnt = sge_count - 3;
 541
 542         if(num_cnt>0){
 543                 sge_bytes = sge_sz * num_cnt;
 544
 545                 frame_count = (sge_bytes / MEGAMFI_FRAME_SIZE) +
 546                     ((sge_bytes % MEGAMFI_FRAME_SIZE) ? 1 : 0) ;
 547         }
 548         /* Main frame */
 549         frame_count +=1;
 550
 551         if (frame_count > 7)
 552                 frame_count = 8;
 553         return frame_count;
 554 }
 555
 556 /**
 557  * megasas_build_dcdb - Prepares a direct cdb (DCDB) command
 558  * @instance:           Adapter soft state
 559  * @scp:                SCSI command
 560  * @cmd:                Command to be prepared in
 561  *
 562  * This function prepares CDB commands. These are typcially pass-through
 563  * commands to the devices.
 564  */
 565 static int
 566 megasas_build_dcdb(struct megasas_instance *instance, struct scsi_cmnd *scp,
 567                    struct megasas_cmd *cmd)
 568 {
 569         u32 is_logical;
 570         u32 device_id;
 571         u16 flags = 0;
 572         struct megasas_pthru_frame *pthru;
 573
 574         is_logical = MEGASAS_IS_LOGICAL(scp);
 575         device_id = MEGASAS_DEV_INDEX(instance, scp);
 576         pthru = (struct megasas_pthru_frame *)cmd->frame;
 577
 578         if (scp->sc_data_direction == PCI_DMA_TODEVICE)
 579                 flags = MFI_FRAME_DIR_WRITE;
 580         else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
 581                 flags = MFI_FRAME_DIR_READ;
 582         else if (scp->sc_data_direction == PCI_DMA_NONE)
 583                 flags = MFI_FRAME_DIR_NONE;
 584
 585         /*
 586          * Prepare the DCDB frame
 587          */
 588         pthru->cmd = (is_logical) ? MFI_CMD_LD_SCSI_IO : MFI_CMD_PD_SCSI_IO;
 589         pthru->cmd_status = 0x0;
 590         pthru->scsi_status = 0x0;
 591         pthru->target_id = device_id;
 592         pthru->lun = scp->device->lun;
 593         pthru->cdb_len = scp->cmd_len;
 594         pthru->timeout = 0;
 595         pthru->flags = flags;
 596         pthru->data_xfer_len = scp->request_bufflen;
 597
 598         memcpy(pthru->cdb, scp->cmnd, scp->cmd_len);
 599
 600         /*
 601          * Construct SGL
 602          */
 603         if (IS_DMA64) {
 604                 pthru->flags |= MFI_FRAME_SGL64;
 605                 pthru->sge_count = megasas_make_sgl64(instance, scp,
 606                                                       &pthru->sgl);
 607         } else
 608                 pthru->sge_count = megasas_make_sgl32(instance, scp,
 609                                                       &pthru->sgl);
 610
 611         /*
 612          * Sense info specific
 613          */
 614         pthru->sense_len = SCSI_SENSE_BUFFERSIZE;
 615         pthru->sense_buf_phys_addr_hi = 0;
 616         pthru->sense_buf_phys_addr_lo = cmd->sense_phys_addr;
 617
 618         /*
 619          * Compute the total number of frames this command consumes. FW uses
 620          * this number to pull sufficient number of frames from host memory.
 621          */
 622         cmd->frame_count = megasas_get_frame_count(pthru->sge_count);
 623
 624         return cmd->frame_count;
 625 }
 626
 627 /**
 628  * megasas_build_ldio - Prepares IOs to logical devices
 629  * @instance:           Adapter soft state
 630  * @scp:                SCSI command
 631  * @cmd:                Command to to be prepared
 632  *
 633  * Frames (and accompanying SGLs) for regular SCSI IOs use this function.
 634  */
 635 static int
 636 megasas_build_ldio(struct megasas_instance *instance, struct scsi_cmnd *scp,
 637                    struct megasas_cmd *cmd)
 638 {
 639         u32 device_id;
 640         u8 sc = scp->cmnd[0];
 641         u16 flags = 0;
 642         struct megasas_io_frame *ldio;
 643
 644         device_id = MEGASAS_DEV_INDEX(instance, scp);
 645         ldio = (struct megasas_io_frame *)cmd->frame;
 646
 647         if (scp->sc_data_direction == PCI_DMA_TODEVICE)
 648                 flags = MFI_FRAME_DIR_WRITE;
 649         else if (scp->sc_data_direction == PCI_DMA_FROMDEVICE)
 650                 flags = MFI_FRAME_DIR_READ;
 651
 652         /*
 653          * Prepare the Logical IO frame: 2nd bit is zero for all read cmds
 654          */
 655         ldio->cmd = (sc & 0x02) ? MFI_CMD_LD_WRITE : MFI_CMD_LD_READ;
 656         ldio->cmd_status = 0x0;
 657         ldio->scsi_status = 0x0;
 658         ldio->target_id = device_id;
 659         ldio->timeout = 0;
 660         ldio->reserved_0 = 0;
 661         ldio->pad_0 = 0;
 662         ldio->flags = flags;
 663         ldio->start_lba_hi = 0;
 664         ldio->access_byte = (scp->cmd_len != 6) ? scp->cmnd[1] : 0;
 665
 666         /*
 667          * 6-byte READ(0x08) or WRITE(0x0A) cdb
 668          */
 669         if (scp->cmd_len == 6) {
 670                 ldio->lba_count = (u32) scp->cmnd[4];
 671                 ldio->start_lba_lo = ((u32) scp->cmnd[1] << 16) |
 672                     ((u32) scp->cmnd[2] << 8) | (u32) scp->cmnd[3];
 673
 674                 ldio->start_lba_lo &= 0x1FFFFF;
 675         }
 676
 677         /*
 678          * 10-byte READ(0x28) or WRITE(0x2A) cdb
 679          */
 680         else if (scp->cmd_len == 10) {
 681                 ldio->lba_count = (u32) scp->cmnd[8] |
 682                     ((u32) scp->cmnd[7] << 8);
 683                 ldio->start_lba_lo = ((u32) scp->cmnd[2] << 24) |
 684                     ((u32) scp->cmnd[3] << 16) |
 685                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
 686         }
 687
 688         /*
 689          * 12-byte READ(0xA8) or WRITE(0xAA) cdb
 690          */
 691         else if (scp->cmd_len == 12) {
 692                 ldio->lba_count = ((u32) scp->cmnd[6] << 24) |
 693                     ((u32) scp->cmnd[7] << 16) |
 694                     ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
 695
 696                 ldio->start_lba_lo = ((u32) scp->cmnd[2] << 24) |
 697                     ((u32) scp->cmnd[3] << 16) |
 698                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
 699         }
 700
 701         /*
 702          * 16-byte READ(0x88) or WRITE(0x8A) cdb
 703          */
 704         else if (scp->cmd_len == 16) {
 705                 ldio->lba_count = ((u32) scp->cmnd[10] << 24) |
 706                     ((u32) scp->cmnd[11] << 16) |
 707                     ((u32) scp->cmnd[12] << 8) | (u32) scp->cmnd[13];
 708
 709                 ldio->start_lba_lo = ((u32) scp->cmnd[6] << 24) |
 710                     ((u32) scp->cmnd[7] << 16) |
 711                     ((u32) scp->cmnd[8] << 8) | (u32) scp->cmnd[9];
 712
 713                 ldio->start_lba_hi = ((u32) scp->cmnd[2] << 24) |
 714                     ((u32) scp->cmnd[3] << 16) |
 715                     ((u32) scp->cmnd[4] << 8) | (u32) scp->cmnd[5];
 716
 717         }
 718
 719         /*
 720          * Construct SGL
 721          */
 722         if (IS_DMA64) {
 723                 ldio->flags |= MFI_FRAME_SGL64;
 724                 ldio->sge_count = megasas_make_sgl64(instance, scp, &ldio->sgl);
 725         } else
 726                 ldio->sge_count = megasas_make_sgl32(instance, scp, &ldio->sgl);
 727
 728         /*
 729          * Sense info specific
 730          */
 731         ldio->sense_len = SCSI_SENSE_BUFFERSIZE;
 732         ldio->sense_buf_phys_addr_hi = 0;
 733         ldio->sense_buf_phys_addr_lo = cmd->sense_phys_addr;
 734
 735         /*
 736          * Compute the total number of frames this command consumes. FW uses
 737          * this number to pull sufficient number of frames from host memory.
 738          */
 739         cmd->frame_count = megasas_get_frame_count(ldio->sge_count);
 740
 741         return cmd->frame_count;
 742 }
 743
 744 /**
 745  * megasas_is_ldio -            Checks if the cmd is for logical drive
 746  * @scmd:                       SCSI command
 747  *
 748  * Called by megasas_queue_command to find out if the command to be queued
 749  * is a logical drive command
 750  */
 751 static inline int megasas_is_ldio(struct scsi_cmnd *cmd)
 752 {
 753         if (!MEGASAS_IS_LOGICAL(cmd))
 754                 return 0;
 755         switch (cmd->cmnd[0]) {
 756         case READ_10:
 757         case WRITE_10:
 758         case READ_12:
 759         case WRITE_12:
 760         case READ_6:
 761         case WRITE_6:
 762         case READ_16:
 763         case WRITE_16:
 764                 return 1;
 765         default:
 766                 return 0;
 767         }
 768 }
 769
 770  /**
 771  * megasas_dump_pending_frames -        Dumps the frame address of all pending cmds
 772  *                                      in FW
 773  * @instance:                           Adapter soft state
 774  */
 775 static inline void
 776 megasas_dump_pending_frames(struct megasas_instance *instance)
 777 {
 778         struct megasas_cmd *cmd;
 779         int i,n;
 780         union megasas_sgl *mfi_sgl;
 781         struct megasas_io_frame *ldio;
 782         struct megasas_pthru_frame *pthru;
 783         u32 sgcount;
 784         u32 max_cmd = instance->max_fw_cmds;
 785
 786         printk(KERN_ERR "\nmegasas[%d]: Dumping Frame Phys Address of all pending cmds in FW\n",instance->host->host_no);
 787         printk(KERN_ERR "megasas[%d]: Total OS Pending cmds : %d\n",instance->host->host_no,atomic_read(&instance->fw_outstanding));
 788         if (IS_DMA64)
 789                 printk(KERN_ERR "\nmegasas[%d]: 64 bit SGLs were sent to FW\n",instance->host->host_no);
 790         else
 791                 printk(KERN_ERR "\nmegasas[%d]: 32 bit SGLs were sent to FW\n",instance->host->host_no);
 792
 793         printk(KERN_ERR "megasas[%d]: Pending OS cmds in FW : \n",instance->host->host_no);
 794         for (i = 0; i < max_cmd; i++) {
 795                 cmd = instance->cmd_list[i];
 796                 if(!cmd->scmd)
 797                         continue;
 798                 printk(KERN_ERR "megasas[%d]: Frame addr :0x%08lx : ",instance->host->host_no,(unsigned long)cmd->frame_phys_addr);
 799                 if (megasas_is_ldio(cmd->scmd)){
 800                         ldio = (struct megasas_io_frame *)cmd->frame;
 801                         mfi_sgl = &ldio->sgl;
 802                         sgcount = ldio->sge_count;
 803                         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);
 804                 }
 805                 else {
 806                         pthru = (struct megasas_pthru_frame *) cmd->frame;
 807                         mfi_sgl = &pthru->sgl;
 808                         sgcount = pthru->sge_count;
 809                         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);
 810                 }
 811         if(megasas_dbg_lvl & MEGASAS_DBG_LVL){
 812                 for (n = 0; n < sgcount; n++){
 813                         if (IS_DMA64)
 814                                 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) ;
 815                         else
 816                                 printk(KERN_ERR "megasas: sgl len : 0x%x, sgl addr : 0x%x ",mfi_sgl->sge32[n].length , mfi_sgl->sge32[n].phys_addr) ;
 817                         }
 818                 }
 819                 printk(KERN_ERR "\n");
 820         } /*for max_cmd*/
 821         printk(KERN_ERR "\nmegasas[%d]: Pending Internal cmds in FW : \n",instance->host->host_no);
 822         for (i = 0; i < max_cmd; i++) {
 823
 824                 cmd = instance->cmd_list[i];
 825
 826                 if(cmd->sync_cmd == 1){
 827                         printk(KERN_ERR "0x%08lx : ", (unsigned long)cmd->frame_phys_addr);
 828                 }
 829         }
 830         printk(KERN_ERR "megasas[%d]: Dumping Done.\n\n",instance->host->host_no);
 831 }
 832
 833 /**
 834  * megasas_queue_command -      Queue entry point
 835  * @scmd:                       SCSI command to be queued
 836  * @done:                       Callback entry point
 837  */
 838 static int
 839 megasas_queue_command(struct scsi_cmnd *scmd, void (*done) (struct scsi_cmnd *))
 840 {
 841         u32 frame_count;
 842         struct megasas_cmd *cmd;
 843         struct megasas_instance *instance;
 844
 845         instance = (struct megasas_instance *)
 846             scmd->device->host->hostdata;
 847
 848         /* Don't process if we have already declared adapter dead */
 849         if (instance->hw_crit_error)
 850                 return SCSI_MLQUEUE_HOST_BUSY;
 851
 852         scmd->scsi_done = done;
 853         scmd->result = 0;
 854
 855         if (MEGASAS_IS_LOGICAL(scmd) &&
 856             (scmd->device->id >= MEGASAS_MAX_LD || scmd->device->lun)) {
 857                 scmd->result = DID_BAD_TARGET << 16;
 858                 goto out_done;
 859         }
 860
 861         switch (scmd->cmnd[0]) {
 862         case SYNCHRONIZE_CACHE:
 863                 /*
 864                  * FW takes care of flush cache on its own
 865                  * No need to send it down
 866                  */
 867                 scmd->result = DID_OK << 16;
 868                 goto out_done;
 869         default:
 870                 break;
 871         }
 872
 873         cmd = megasas_get_cmd(instance);
 874         if (!cmd)
 875                 return SCSI_MLQUEUE_HOST_BUSY;
 876
 877         /*
 878          * Logical drive command
 879          */
 880         if (megasas_is_ldio(scmd))
 881                 frame_count = megasas_build_ldio(instance, scmd, cmd);
 882         else
 883                 frame_count = megasas_build_dcdb(instance, scmd, cmd);
 884
 885         if (!frame_count)
 886                 goto out_return_cmd;
 887
 888         cmd->scmd = scmd;
 889
 890         /*
 891          * Issue the command to the FW
 892          */
 893         atomic_inc(&instance->fw_outstanding);
 894
 895         instance->instancet->fire_cmd(cmd->frame_phys_addr ,cmd->frame_count-1,instance->reg_set);
 896
 897         return 0;
 898
 899  out_return_cmd:
 900         megasas_return_cmd(instance, cmd);
 901  out_done:
 902         done(scmd);
 903         return 0;
 904 }
 905
 906 static int megasas_slave_configure(struct scsi_device *sdev)
 907 {
 908         /*
 909          * Don't export physical disk devices to the disk driver.
 910          *
 911          * FIXME: Currently we don't export them to the midlayer at all.
 912          *        That will be fixed once LSI engineers have audited the
 913          *        firmware for possible issues.
 914          */
 915         if (sdev->channel < MEGASAS_MAX_PD_CHANNELS && sdev->type == TYPE_DISK)
 916                 return -ENXIO;
 917
 918         /*
 919          * The RAID firmware may require extended timeouts.
 920          */
 921         if (sdev->channel >= MEGASAS_MAX_PD_CHANNELS)
 922                 sdev->timeout = 90 * HZ;
 923         return 0;
 924 }
 925
 926 /**
 927  * megasas_wait_for_outstanding -       Wait for all outstanding cmds
 928  * @instance:                           Adapter soft state
 929  *
 930  * This function waits for upto MEGASAS_RESET_WAIT_TIME seconds for FW to
 931  * complete all its outstanding commands. Returns error if one or more IOs
 932  * are pending after this time period. It also marks the controller dead.
 933  */
 934 static int megasas_wait_for_outstanding(struct megasas_instance *instance)
 935 {
 936         int i;
 937         u32 wait_time = MEGASAS_RESET_WAIT_TIME;
 938
 939         for (i = 0; i < wait_time; i++) {
 940
 941                 int outstanding = atomic_read(&instance->fw_outstanding);
 942
 943                 if (!outstanding)
 944                         break;
 945
 946                 if (!(i % MEGASAS_RESET_NOTICE_INTERVAL)) {
 947                         printk(KERN_NOTICE "megasas: [%2d]waiting for %d "
 948                                "commands to complete\n",i,outstanding);
 949                 }
 950
 951                 msleep(1000);
 952         }
 953
 954         if (atomic_read(&instance->fw_outstanding)) {
 955                 /*
 956                 * Send signal to FW to stop processing any pending cmds.
 957                 * The controller will be taken offline by the OS now.
 958                 */
 959                 writel(MFI_STOP_ADP,
 960                                 &instance->reg_set->inbound_doorbell);
 961                 megasas_dump_pending_frames(instance);
 962                 instance->hw_crit_error = 1;
 963                 return FAILED;
 964         }
 965
 966         return SUCCESS;
 967 }
 968
 969 /**
 970  * megasas_generic_reset -      Generic reset routine
 971  * @scmd:                       Mid-layer SCSI command
 972  *
 973  * This routine implements a generic reset handler for device, bus and host
 974  * reset requests. Device, bus and host specific reset handlers can use this
 975  * function after they do their specific tasks.
 976  */
 977 static int megasas_generic_reset(struct scsi_cmnd *scmd)
 978 {
 979         int ret_val;
 980         struct megasas_instance *instance;
 981
 982         instance = (struct megasas_instance *)scmd->device->host->hostdata;
 983
 984         scmd_printk(KERN_NOTICE, scmd, "megasas: RESET -%ld cmd=%x\n",
 985                scmd->serial_number, scmd->cmnd[0]);
 986
 987         if (instance->hw_crit_error) {
 988                 printk(KERN_ERR "megasas: cannot recover from previous reset "
 989                        "failures\n");
 990                 return FAILED;
 991         }
 992
 993         ret_val = megasas_wait_for_outstanding(instance);
 994         if (ret_val == SUCCESS)
 995                 printk(KERN_NOTICE "megasas: reset successful \n");
 996         else
 997                 printk(KERN_ERR "megasas: failed to do reset\n");
 998
 999         return ret_val;
1000 }
1001
1002 /**
1003  * megasas_reset_device -       Device reset handler entry point
1004  */
1005 static int megasas_reset_device(struct scsi_cmnd *scmd)
1006 {
1007         int ret;
1008
1009         /*
1010          * First wait for all commands to complete
1011          */
1012         ret = megasas_generic_reset(scmd);
1013
1014         return ret;
1015 }
1016
1017 /**
1018  * megasas_reset_bus_host -     Bus & host reset handler entry point
1019  */
1020 static int megasas_reset_bus_host(struct scsi_cmnd *scmd)
1021 {
1022         int ret;
1023
1024         /*
1025          * First wait for all commands to complete
1026          */
1027         ret = megasas_generic_reset(scmd);
1028
1029         return ret;
1030 }
1031
1032 /**
1033  * megasas_bios_param - Returns disk geometry for a disk
1034  * @sdev:               device handle
1035  * @bdev:               block device
1036  * @capacity:           drive capacity
1037  * @geom:               geometry parameters
1038  */
1039 static int
1040 megasas_bios_param(struct scsi_device *sdev, struct block_device *bdev,
1041                  sector_t capacity, int geom[])
1042 {
1043         int heads;
1044         int sectors;
1045         sector_t cylinders;
1046         unsigned long tmp;
1047         /* Default heads (64) & sectors (32) */
1048         heads = 64;
1049         sectors = 32;
1050
1051         tmp = heads * sectors;
1052         cylinders = capacity;
1053
1054         sector_div(cylinders, tmp);
1055
1056         /*
1057          * Handle extended translation size for logical drives > 1Gb
1058          */
1059
1060         if (capacity >= 0x200000) {
1061                 heads = 255;
1062                 sectors = 63;
1063                 tmp = heads*sectors;
1064                 cylinders = capacity;
1065                 sector_div(cylinders, tmp);
1066         }
1067
1068         geom[0] = heads;
1069         geom[1] = sectors;
1070         geom[2] = cylinders;
1071
1072         return 0;
1073 }
1074
1075 /**
1076  * megasas_service_aen -        Processes an event notification
1077  * @instance:                   Adapter soft state
1078  * @cmd:                        AEN command completed by the ISR
1079  *
1080  * For AEN, driver sends a command down to FW that is held by the FW till an
1081  * event occurs. When an event of interest occurs, FW completes the command
1082  * that it was previously holding.
1083  *
1084  * This routines sends SIGIO signal to processes that have registered with the
1085  * driver for AEN.
1086  */
1087 static void
1088 megasas_service_aen(struct megasas_instance *instance, struct megasas_cmd *cmd)
1089 {
1090         /*
1091          * Don't signal app if it is just an aborted previously registered aen
1092          */
1093         if (!cmd->abort_aen)
1094                 kill_fasync(&megasas_async_queue, SIGIO, POLL_IN);
1095         else
1096                 cmd->abort_aen = 0;
1097
1098         instance->aen_cmd = NULL;
1099         megasas_return_cmd(instance, cmd);
1100 }
1101
1102 /*
1103  * Scsi host template for megaraid_sas driver
1104  */
1105 static struct scsi_host_template megasas_template = {
1106
1107         .module = THIS_MODULE,
1108         .name = "LSI Logic SAS based MegaRAID driver",
1109         .proc_name = "megaraid_sas",
1110         .slave_configure = megasas_slave_configure,
1111         .queuecommand = megasas_queue_command,
1112         .eh_device_reset_handler = megasas_reset_device,
1113         .eh_bus_reset_handler = megasas_reset_bus_host,
1114         .eh_host_reset_handler = megasas_reset_bus_host,
1115         .bios_param = megasas_bios_param,
1116         .use_clustering = ENABLE_CLUSTERING,
1117 };
1118
1119 /**
1120  * megasas_complete_int_cmd -   Completes an internal command
1121  * @instance:                   Adapter soft state
1122  * @cmd:                        Command to be completed
1123  *
1124  * The megasas_issue_blocked_cmd() function waits for a command to complete
1125  * after it issues a command. This function wakes up that waiting routine by
1126  * calling wake_up() on the wait queue.
1127  */
1128 static void
1129 megasas_complete_int_cmd(struct megasas_instance *instance,
1130                          struct megasas_cmd *cmd)
1131 {
1132         cmd->cmd_status = cmd->frame->io.cmd_status;
1133
1134         if (cmd->cmd_status == ENODATA) {
1135                 cmd->cmd_status = 0;
1136         }
1137         wake_up(&instance->int_cmd_wait_q);
1138 }
1139
1140 /**
1141  * megasas_complete_abort -     Completes aborting a command
1142  * @instance:                   Adapter soft state
1143  * @cmd:                        Cmd that was issued to abort another cmd
1144  *
1145  * The megasas_issue_blocked_abort_cmd() function waits on abort_cmd_wait_q
1146  * after it issues an abort on a previously issued command. This function
1147  * wakes up all functions waiting on the same wait queue.
1148  */
1149 static void
1150 megasas_complete_abort(struct megasas_instance *instance,
1151                        struct megasas_cmd *cmd)
1152 {
1153         if (cmd->sync_cmd) {
1154                 cmd->sync_cmd = 0;
1155                 cmd->cmd_status = 0;
1156                 wake_up(&instance->abort_cmd_wait_q);
1157         }
1158
1159         return;
1160 }
1161
1162 /**
1163  * megasas_unmap_sgbuf -        Unmap SG buffers
1164  * @instance:                   Adapter soft state
1165  * @cmd:                        Completed command
1166  */
1167 static void
1168 megasas_unmap_sgbuf(struct megasas_instance *instance, struct megasas_cmd *cmd)
1169 {
1170         dma_addr_t buf_h;
1171         u8 opcode;
1172
1173         if (cmd->scmd->use_sg) {
1174                 pci_unmap_sg(instance->pdev, cmd->scmd->request_buffer,
1175                              cmd->scmd->use_sg, cmd->scmd->sc_data_direction);
1176                 return;
1177         }
1178
1179         if (!cmd->scmd->request_bufflen)
1180                 return;
1181
1182         opcode = cmd->frame->hdr.cmd;
1183
1184         if ((opcode == MFI_CMD_LD_READ) || (opcode == MFI_CMD_LD_WRITE)) {
1185                 if (IS_DMA64)
1186                         buf_h = cmd->frame->io.sgl.sge64[0].phys_addr;
1187                 else
1188                         buf_h = cmd->frame->io.sgl.sge32[0].phys_addr;
1189         } else {
1190                 if (IS_DMA64)
1191                         buf_h = cmd->frame->pthru.sgl.sge64[0].phys_addr;
1192                 else
1193                         buf_h = cmd->frame->pthru.sgl.sge32[0].phys_addr;
1194         }
1195
1196         pci_unmap_single(instance->pdev, buf_h, cmd->scmd->request_bufflen,
1197                          cmd->scmd->sc_data_direction);
1198         return;
1199 }
1200
1201 /**
1202  * megasas_complete_cmd -       Completes a command
1203  * @instance:                   Adapter soft state
1204  * @cmd:                        Command to be completed
1205  * @alt_status:                 If non-zero, use this value as status to
1206  *                              SCSI mid-layer instead of the value returned
1207  *                              by the FW. This should be used if caller wants
1208  *                              an alternate status (as in the case of aborted
1209  *                              commands)
1210  */
1211 static void
1212 megasas_complete_cmd(struct megasas_instance *instance, struct megasas_cmd *cmd,
1213                      u8 alt_status)
1214 {
1215         int exception = 0;
1216         struct megasas_header *hdr = &cmd->frame->hdr;
1217
1218         if (cmd->scmd) {
1219                 cmd->scmd->SCp.ptr = (char *)0;
1220         }
1221
1222         switch (hdr->cmd) {
1223
1224         case MFI_CMD_PD_SCSI_IO:
1225         case MFI_CMD_LD_SCSI_IO:
1226
1227                 /*
1228                  * MFI_CMD_PD_SCSI_IO and MFI_CMD_LD_SCSI_IO could have been
1229                  * issued either through an IO path or an IOCTL path. If it
1230                  * was via IOCTL, we will send it to internal completion.
1231                  */
1232                 if (cmd->sync_cmd) {
1233                         cmd->sync_cmd = 0;
1234                         megasas_complete_int_cmd(instance, cmd);
1235                         break;
1236                 }
1237
1238         case MFI_CMD_LD_READ:
1239         case MFI_CMD_LD_WRITE:
1240
1241                 if (alt_status) {
1242                         cmd->scmd->result = alt_status << 16;
1243                         exception = 1;
1244                 }
1245
1246                 if (exception) {
1247
1248                         atomic_dec(&instance->fw_outstanding);
1249
1250                         megasas_unmap_sgbuf(instance, cmd);
1251                         cmd->scmd->scsi_done(cmd->scmd);
1252                         megasas_return_cmd(instance, cmd);
1253
1254                         break;
1255                 }
1256
1257                 switch (hdr->cmd_status) {
1258
1259                 case MFI_STAT_OK:
1260                         cmd->scmd->result = DID_OK << 16;
1261                         break;
1262
1263                 case MFI_STAT_SCSI_IO_FAILED:
1264                 case MFI_STAT_LD_INIT_IN_PROGRESS:
1265                         cmd->scmd->result =
1266                             (DID_ERROR << 16) | hdr->scsi_status;
1267                         break;
1268
1269                 case MFI_STAT_SCSI_DONE_WITH_ERROR:
1270
1271                         cmd->scmd->result = (DID_OK << 16) | hdr->scsi_status;
1272
1273                         if (hdr->scsi_status == SAM_STAT_CHECK_CONDITION) {
1274                                 memset(cmd->scmd->sense_buffer, 0,
1275                                        SCSI_SENSE_BUFFERSIZE);
1276                                 memcpy(cmd->scmd->sense_buffer, cmd->sense,
1277                                        hdr->sense_len);
1278
1279                                 cmd->scmd->result |= DRIVER_SENSE << 24;
1280                         }
1281
1282                         break;
1283
1284                 case MFI_STAT_LD_OFFLINE:
1285                 case MFI_STAT_DEVICE_NOT_FOUND:
1286                         cmd->scmd->result = DID_BAD_TARGET << 16;
1287                         break;
1288
1289                 default:
1290                         printk(KERN_DEBUG "megasas: MFI FW status %#x\n",
1291                                hdr->cmd_status);
1292                         cmd->scmd->result = DID_ERROR << 16;
1293                         break;
1294                 }
1295
1296                 atomic_dec(&instance->fw_outstanding);
1297
1298                 megasas_unmap_sgbuf(instance, cmd);
1299                 cmd->scmd->scsi_done(cmd->scmd);
1300                 megasas_return_cmd(instance, cmd);
1301
1302                 break;
1303
1304         case MFI_CMD_SMP:
1305         case MFI_CMD_STP:
1306         case MFI_CMD_DCMD:
1307
1308                 /*
1309                  * See if got an event notification
1310                  */
1311                 if (cmd->frame->dcmd.opcode == MR_DCMD_CTRL_EVENT_WAIT)
1312                         megasas_service_aen(instance, cmd);
1313                 else
1314                         megasas_complete_int_cmd(instance, cmd);
1315
1316                 break;
1317
1318         case MFI_CMD_ABORT:
1319                 /*
1320                  * Cmd issued to abort another cmd returned
1321                  */
1322                 megasas_complete_abort(instance, cmd);
1323                 break;
1324
1325         default:
1326                 printk("megasas: Unknown command completed! [0x%X]\n",
1327                        hdr->cmd);
1328                 break;
1329         }
1330 }
1331
1332 /**
1333  * megasas_deplete_reply_queue -        Processes all completed commands
1334  * @instance:                           Adapter soft state
1335  * @alt_status:                         Alternate status to be returned to
1336  *                                      SCSI mid-layer instead of the status
1337  *                                      returned by the FW
1338  */
1339 static int
1340 megasas_deplete_reply_queue(struct megasas_instance *instance, u8 alt_status)
1341 {
1342         /*
1343          * Check if it is our interrupt
1344          * Clear the interrupt
1345          */
1346         if(instance->instancet->clear_intr(instance->reg_set))
1347                 return IRQ_NONE;
1348
1349         if (instance->hw_crit_error)
1350                 goto out_done;
1351         /*
1352          * Schedule the tasklet for cmd completion
1353          */
1354         tasklet_schedule(&instance->isr_tasklet);
1355 out_done:
1356         return IRQ_HANDLED;
1357 }
1358
1359 /**
1360  * megasas_isr - isr entry point
1361  */
1362 static irqreturn_t megasas_isr(int irq, void *devp)
1363 {
1364         return megasas_deplete_reply_queue((struct megasas_instance *)devp,
1365                                            DID_OK);
1366 }
1367
1368 /**
1369  * megasas_transition_to_ready -        Move the FW to READY state
1370  * @instance:                           Adapter soft state
1371  *
1372  * During the initialization, FW passes can potentially be in any one of
1373  * several possible states. If the FW in operational, waiting-for-handshake
1374  * states, driver must take steps to bring it to ready state. Otherwise, it
1375  * has to wait for the ready state.
1376  */
1377 static int
1378 megasas_transition_to_ready(struct megasas_instance* instance)
1379 {
1380         int i;
1381         u8 max_wait;
1382         u32 fw_state;
1383         u32 cur_state;
1384
1385         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) & MFI_STATE_MASK;
1386
1387         if (fw_state != MFI_STATE_READY)
1388                 printk(KERN_INFO "megasas: Waiting for FW to come to ready"
1389                        " state\n");
1390
1391         while (fw_state != MFI_STATE_READY) {
1392
1393                 switch (fw_state) {
1394
1395                 case MFI_STATE_FAULT:
1396
1397                         printk(KERN_DEBUG "megasas: FW in FAULT state!!\n");
1398                         return -ENODEV;
1399
1400                 case MFI_STATE_WAIT_HANDSHAKE:
1401                         /*
1402                          * Set the CLR bit in inbound doorbell
1403                          */
1404                         writel(MFI_INIT_CLEAR_HANDSHAKE|MFI_INIT_HOTPLUG,
1405                                 &instance->reg_set->inbound_doorbell);
1406
1407                         max_wait = 2;
1408                         cur_state = MFI_STATE_WAIT_HANDSHAKE;
1409                         break;
1410
1411                 case MFI_STATE_BOOT_MESSAGE_PENDING:
1412                         writel(MFI_INIT_HOTPLUG,
1413                                 &instance->reg_set->inbound_doorbell);
1414
1415                         max_wait = 10;
1416                         cur_state = MFI_STATE_BOOT_MESSAGE_PENDING;
1417                         break;
1418
1419                 case MFI_STATE_OPERATIONAL:
1420                         /*
1421                          * Bring it to READY state; assuming max wait 10 secs
1422                          */
1423                         instance->instancet->disable_intr(instance->reg_set);
1424                         writel(MFI_RESET_FLAGS, &instance->reg_set->inbound_doorbell);
1425
1426                         max_wait = 10;
1427                         cur_state = MFI_STATE_OPERATIONAL;
1428                         break;
1429
1430                 case MFI_STATE_UNDEFINED:
1431                         /*
1432                          * This state should not last for more than 2 seconds
1433                          */
1434                         max_wait = 2;
1435                         cur_state = MFI_STATE_UNDEFINED;
1436                         break;
1437
1438                 case MFI_STATE_BB_INIT:
1439                         max_wait = 2;
1440                         cur_state = MFI_STATE_BB_INIT;
1441                         break;
1442
1443                 case MFI_STATE_FW_INIT:
1444                         max_wait = 20;
1445                         cur_state = MFI_STATE_FW_INIT;
1446                         break;
1447
1448                 case MFI_STATE_FW_INIT_2:
1449                         max_wait = 20;
1450                         cur_state = MFI_STATE_FW_INIT_2;
1451                         break;
1452
1453                 case MFI_STATE_DEVICE_SCAN:
1454                         max_wait = 20;
1455                         cur_state = MFI_STATE_DEVICE_SCAN;
1456                         break;
1457
1458                 case MFI_STATE_FLUSH_CACHE:
1459                         max_wait = 20;
1460                         cur_state = MFI_STATE_FLUSH_CACHE;
1461                         break;
1462
1463                 default:
1464                         printk(KERN_DEBUG "megasas: Unknown state 0x%x\n",
1465                                fw_state);
1466                         return -ENODEV;
1467                 }
1468
1469                 /*
1470                  * The cur_state should not last for more than max_wait secs
1471                  */
1472                 for (i = 0; i < (max_wait * 1000); i++) {
1473                         fw_state = instance->instancet->read_fw_status_reg(instance->reg_set) &
1474                                         MFI_STATE_MASK ;
1475
1476                         if (fw_state == cur_state) {
1477                                 msleep(1);
1478                         } else
1479                                 break;
1480                 }
1481
1482                 /*
1483                  * Return error if fw_state hasn't changed after max_wait
1484                  */
1485                 if (fw_state == cur_state) {
1486                         printk(KERN_DEBUG "FW state [%d] hasn't changed "
1487                                "in %d secs\n", fw_state, max_wait);
1488                         return -ENODEV;
1489                 }
1490         };
1491         printk(KERN_INFO "megasas: FW now in Ready state\n");
1492
1493         return 0;
1494 }
1495
1496 /**
1497  * megasas_teardown_frame_pool -        Destroy the cmd frame DMA pool
1498  * @instance:                           Adapter soft state
1499  */
1500 static void megasas_teardown_frame_pool(struct megasas_instance *instance)
1501 {
1502         int i;
1503         u32 max_cmd = instance->max_fw_cmds;
1504         struct megasas_cmd *cmd;
1505
1506         if (!instance->frame_dma_pool)
1507                 return;
1508
1509         /*
1510          * Return all frames to pool
1511          */
1512         for (i = 0; i < max_cmd; i++) {
1513
1514                 cmd = instance->cmd_list[i];
1515
1516                 if (cmd->frame)
1517                         pci_pool_free(instance->frame_dma_pool, cmd->frame,
1518                                       cmd->frame_phys_addr);
1519
1520                 if (cmd->sense)
1521                         pci_pool_free(instance->sense_dma_pool, cmd->sense,
1522                                       cmd->sense_phys_addr);
1523         }
1524
1525         /*
1526          * Now destroy the pool itself
1527          */
1528         pci_pool_destroy(instance->frame_dma_pool);
1529         pci_pool_destroy(instance->sense_dma_pool);
1530
1531         instance->frame_dma_pool = NULL;
1532         instance->sense_dma_pool = NULL;
1533 }
1534
1535 /**
1536  * megasas_create_frame_pool -  Creates DMA pool for cmd frames
1537  * @instance:                   Adapter soft state
1538  *
1539  * Each command packet has an embedded DMA memory buffer that is used for
1540  * filling MFI frame and the SG list that immediately follows the frame. This
1541  * function creates those DMA memory buffers for each command packet by using
1542  * PCI pool facility.
1543  */
1544 static int megasas_create_frame_pool(struct megasas_instance *instance)
1545 {
1546         int i;
1547         u32 max_cmd;
1548         u32 sge_sz;
1549         u32 sgl_sz;
1550         u32 total_sz;
1551         u32 frame_count;
1552         struct megasas_cmd *cmd;
1553
1554         max_cmd = instance->max_fw_cmds;
1555
1556         /*
1557          * Size of our frame is 64 bytes for MFI frame, followed by max SG
1558          * elements and finally SCSI_SENSE_BUFFERSIZE bytes for sense buffer
1559          */
1560         sge_sz = (IS_DMA64) ? sizeof(struct megasas_sge64) :
1561             sizeof(struct megasas_sge32);
1562
1563         /*
1564          * Calculated the number of 64byte frames required for SGL
1565          */
1566         sgl_sz = sge_sz * instance->max_num_sge;
1567         frame_count = (sgl_sz + MEGAMFI_FRAME_SIZE - 1) / MEGAMFI_FRAME_SIZE;
1568
1569         /*
1570          * We need one extra frame for the MFI command
1571          */
1572         frame_count++;
1573
1574         total_sz = MEGAMFI_FRAME_SIZE * frame_count;
1575         /*
1576          * Use DMA pool facility provided by PCI layer
1577          */
1578         instance->frame_dma_pool = pci_pool_create("megasas frame pool",
1579                                                    instance->pdev, total_sz, 64,
1580                                                    0);
1581
1582         if (!instance->frame_dma_pool) {
1583                 printk(KERN_DEBUG "megasas: failed to setup frame pool\n");
1584                 return -ENOMEM;
1585         }
1586
1587         instance->sense_dma_pool = pci_pool_create("megasas sense pool",
1588                                                    instance->pdev, 128, 4, 0);
1589
1590         if (!instance->sense_dma_pool) {
1591                 printk(KERN_DEBUG "megasas: failed to setup sense pool\n");
1592
1593                 pci_pool_destroy(instance->frame_dma_pool);
1594                 instance->frame_dma_pool = NULL;
1595
1596                 return -ENOMEM;
1597         }
1598
1599         /*
1600          * Allocate and attach a frame to each of the commands in cmd_list.
1601          * By making cmd->index as the context instead of the &cmd, we can
1602          * always use 32bit context regardless of the architecture
1603          */
1604         for (i = 0; i < max_cmd; i++) {
1605
1606                 cmd = instance->cmd_list[i];
1607
1608                 cmd->frame = pci_pool_alloc(instance->frame_dma_pool,
1609                                             GFP_KERNEL, &cmd->frame_phys_addr);
1610
1611                 cmd->sense = pci_pool_alloc(instance->sense_dma_pool,
1612                                             GFP_KERNEL, &cmd->sense_phys_addr);
1613
1614                 /*
1615                  * megasas_teardown_frame_pool() takes care of freeing
1616                  * whatever has been allocated
1617                  */
1618                 if (!cmd->frame || !cmd->sense) {
1619                         printk(KERN_DEBUG "megasas: pci_pool_alloc failed \n");
1620                         megasas_teardown_frame_pool(instance);
1621                         return -ENOMEM;
1622                 }
1623
1624                 cmd->frame->io.context = cmd->index;
1625         }
1626
1627         return 0;
1628 }
1629
1630 /**
1631  * megasas_free_cmds -  Free all the cmds in the free cmd pool
1632  * @instance:           Adapter soft state
1633  */
1634 static void megasas_free_cmds(struct megasas_instance *instance)
1635 {
1636         int i;
1637         /* First free the MFI frame pool */
1638         megasas_teardown_frame_pool(instance);
1639
1640         /* Free all the commands in the cmd_list */
1641         for (i = 0; i < instance->max_fw_cmds; i++)
1642                 kfree(instance->cmd_list[i]);
1643
1644         /* Free the cmd_list buffer itself */
1645         kfree(instance->cmd_list);
1646         instance->cmd_list = NULL;
1647
1648         INIT_LIST_HEAD(&instance->cmd_pool);
1649 }
1650
1651 /**
1652  * megasas_alloc_cmds - Allocates the command packets
1653  * @instance:           Adapter soft state
1654  *
1655  * Each command that is issued to the FW, whether IO commands from the OS or
1656  * internal commands like IOCTLs, are wrapped in local data structure called
1657  * megasas_cmd. The frame embedded in this megasas_cmd is actually issued to
1658  * the FW.
1659  *
1660  * Each frame has a 32-bit field called context (tag). This context is used
1661  * to get back the megasas_cmd from the frame when a frame gets completed in
1662  * the ISR. Typically the address of the megasas_cmd itself would be used as
1663  * the context. But we wanted to keep the differences between 32 and 64 bit
1664  * systems to the mininum. We always use 32 bit integers for the context. In
1665  * this driver, the 32 bit values are the indices into an array cmd_list.
1666  * This array is used only to look up the megasas_cmd given the context. The
1667  * free commands themselves are maintained in a linked list called cmd_pool.
1668  */
1669 static int megasas_alloc_cmds(struct megasas_instance *instance)
1670 {
1671         int i;
1672         int j;
1673         u32 max_cmd;
1674         struct megasas_cmd *cmd;
1675
1676         max_cmd = instance->max_fw_cmds;
1677
1678         /*
1679          * instance->cmd_list is an array of struct megasas_cmd pointers.
1680          * Allocate the dynamic array first and then allocate individual
1681          * commands.
1682          */
1683         instance->cmd_list = kmalloc(sizeof(struct megasas_cmd *) * max_cmd,
1684                                      GFP_KERNEL);
1685
1686         if (!instance->cmd_list) {
1687                 printk(KERN_DEBUG "megasas: out of memory\n");
1688                 return -ENOMEM;
1689         }
1690
1691         memset(instance->cmd_list, 0, sizeof(struct megasas_cmd *) * max_cmd);
1692
1693         for (i = 0; i < max_cmd; i++) {
1694                 instance->cmd_list[i] = kmalloc(sizeof(struct megasas_cmd),
1695                                                 GFP_KERNEL);
1696
1697                 if (!instance->cmd_list[i]) {
1698
1699                         for (j = 0; j < i; j++)
1700                                 kfree(instance->cmd_list[j]);
1701
1702                         kfree(instance->cmd_list);
1703                         instance->cmd_list = NULL;
1704
1705                         return -ENOMEM;
1706                 }
1707         }
1708
1709         /*
1710          * Add all the commands to command pool (instance->cmd_pool)
1711          */
1712         for (i = 0; i < max_cmd; i++) {
1713                 cmd = instance->cmd_list[i];
1714                 memset(cmd, 0, sizeof(struct megasas_cmd));
1715                 cmd->index = i;
1716                 cmd->instance = instance;
1717
1718                 list_add_tail(&cmd->list, &instance->cmd_pool);
1719         }
1720
1721         /*
1722          * Create a frame pool and assign one frame to each cmd
1723          */
1724         if (megasas_create_frame_pool(instance)) {
1725                 printk(KERN_DEBUG "megasas: Error creating frame DMA pool\n");
1726                 megasas_free_cmds(instance);
1727         }
1728
1729         return 0;
1730 }
1731
1732 /**
1733  * megasas_get_controller_info -        Returns FW's controller structure
1734  * @instance:                           Adapter soft state
1735  * @ctrl_info:                          Controller information structure
1736  *
1737  * Issues an internal command (DCMD) to get the FW's controller structure.
1738  * This information is mainly used to find out the maximum IO transfer per
1739  * command supported by the FW.
1740  */
1741 static int
1742 megasas_get_ctrl_info(struct megasas_instance *instance,
1743                       struct megasas_ctrl_info *ctrl_info)
1744 {
1745         int ret = 0;
1746         struct megasas_cmd *cmd;
1747         struct megasas_dcmd_frame *dcmd;
1748         struct megasas_ctrl_info *ci;
1749         dma_addr_t ci_h = 0;
1750
1751         cmd = megasas_get_cmd(instance);
1752
1753         if (!cmd) {
1754                 printk(KERN_DEBUG "megasas: Failed to get a free cmd\n");
1755                 return -ENOMEM;
1756         }
1757
1758         dcmd = &cmd->frame->dcmd;
1759
1760         ci = pci_alloc_consistent(instance->pdev,
1761                                   sizeof(struct megasas_ctrl_info), &ci_h);
1762
1763         if (!ci) {
1764                 printk(KERN_DEBUG "Failed to alloc mem for ctrl info\n");
1765                 megasas_return_cmd(instance, cmd);
1766                 return -ENOMEM;
1767         }
1768
1769         memset(ci, 0, sizeof(*ci));
1770         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
1771
1772         dcmd->cmd = MFI_CMD_DCMD;
1773         dcmd->cmd_status = 0xFF;
1774         dcmd->sge_count = 1;
1775         dcmd->flags = MFI_FRAME_DIR_READ;
1776         dcmd->timeout = 0;
1777         dcmd->data_xfer_len = sizeof(struct megasas_ctrl_info);
1778         dcmd->opcode = MR_DCMD_CTRL_GET_INFO;
1779         dcmd->sgl.sge32[0].phys_addr = ci_h;
1780         dcmd->sgl.sge32[0].length = sizeof(struct megasas_ctrl_info);
1781
1782         if (!megasas_issue_polled(instance, cmd)) {
1783                 ret = 0;
1784                 memcpy(ctrl_info, ci, sizeof(struct megasas_ctrl_info));
1785         } else {
1786                 ret = -1;
1787         }
1788
1789         pci_free_consistent(instance->pdev, sizeof(struct megasas_ctrl_info),
1790                             ci, ci_h);
1791
1792         megasas_return_cmd(instance, cmd);
1793         return ret;
1794 }
1795
1796 /**
1797  * megasas_complete_cmd_dpc      -      Returns FW's controller structure
1798  * @instance_addr:                      Address of adapter soft state
1799  *
1800  * Tasklet to complete cmds
1801  */
1802 static void megasas_complete_cmd_dpc(unsigned long instance_addr)
1803 {
1804         u32 producer;
1805         u32 consumer;
1806         u32 context;
1807         struct megasas_cmd *cmd;
1808         struct megasas_instance *instance = (struct megasas_instance *)instance_addr;
1809
1810         /* If we have already declared adapter dead, donot complete cmds */
1811         if (instance->hw_crit_error)
1812                 return;
1813
1814         producer = *instance->producer;
1815         consumer = *instance->consumer;
1816
1817         while (consumer != producer) {
1818                 context = instance->reply_queue[consumer];
1819
1820                 cmd = instance->cmd_list[context];
1821
1822                 megasas_complete_cmd(instance, cmd, DID_OK);
1823
1824                 consumer++;
1825                 if (consumer == (instance->max_fw_cmds + 1)) {
1826                         consumer = 0;
1827                 }
1828         }
1829
1830         *instance->consumer = producer;
1831 }
1832
1833 /**
1834  * megasas_init_mfi -   Initializes the FW
1835  * @instance:           Adapter soft state
1836  *
1837  * This is the main function for initializing MFI firmware.
1838  */
1839 static int megasas_init_mfi(struct megasas_instance *instance)
1840 {
1841         u32 context_sz;
1842         u32 reply_q_sz;
1843         u32 max_sectors_1;
1844         u32 max_sectors_2;
1845         struct megasas_register_set __iomem *reg_set;
1846
1847         struct megasas_cmd *cmd;
1848         struct megasas_ctrl_info *ctrl_info;
1849
1850         struct megasas_init_frame *init_frame;
1851         struct megasas_init_queue_info *initq_info;
1852         dma_addr_t init_frame_h;
1853         dma_addr_t initq_info_h;
1854
1855         /*
1856          * Map the message registers
1857          */
1858         instance->base_addr = pci_resource_start(instance->pdev, 0);
1859
1860         if (pci_request_regions(instance->pdev, "megasas: LSI Logic")) {
1861                 printk(KERN_DEBUG "megasas: IO memory region busy!\n");
1862                 return -EBUSY;
1863         }
1864
1865         instance->reg_set = ioremap_nocache(instance->base_addr, 8192);
1866
1867         if (!instance->reg_set) {
1868                 printk(KERN_DEBUG "megasas: Failed to map IO mem\n");
1869                 goto fail_ioremap;
1870         }
1871
1872         reg_set = instance->reg_set;
1873
1874         switch(instance->pdev->device)
1875         {
1876                 case PCI_DEVICE_ID_LSI_SAS1078R:
1877                         instance->instancet = &megasas_instance_template_ppc;
1878                         break;
1879                 case PCI_DEVICE_ID_LSI_SAS1064R:
1880                 case PCI_DEVICE_ID_DELL_PERC5:
1881                 default:
1882                         instance->instancet = &megasas_instance_template_xscale;
1883                         break;
1884         }
1885
1886         /*
1887          * We expect the FW state to be READY
1888          */
1889         if (megasas_transition_to_ready(instance))
1890                 goto fail_ready_state;
1891
1892         /*
1893          * Get various operational parameters from status register
1894          */
1895         instance->max_fw_cmds = instance->instancet->read_fw_status_reg(reg_set) & 0x00FFFF;
1896         /*
1897          * Reduce the max supported cmds by 1. This is to ensure that the
1898          * reply_q_sz (1 more than the max cmd that driver may send)
1899          * does not exceed max cmds that the FW can support
1900          */
1901         instance->max_fw_cmds = instance->max_fw_cmds-1;
1902         instance->max_num_sge = (instance->instancet->read_fw_status_reg(reg_set) & 0xFF0000) >>
1903                                         0x10;
1904         /*
1905          * Create a pool of commands
1906          */
1907         if (megasas_alloc_cmds(instance))
1908                 goto fail_alloc_cmds;
1909
1910         /*
1911          * Allocate memory for reply queue. Length of reply queue should
1912          * be _one_ more than the maximum commands handled by the firmware.
1913          *
1914          * Note: When FW completes commands, it places corresponding contex
1915          * values in this circular reply queue. This circular queue is a fairly
1916          * typical producer-consumer queue. FW is the producer (of completed
1917          * commands) and the driver is the consumer.
1918          */
1919         context_sz = sizeof(u32);
1920         reply_q_sz = context_sz * (instance->max_fw_cmds + 1);
1921
1922         instance->reply_queue = pci_alloc_consistent(instance->pdev,
1923                                                      reply_q_sz,
1924                                                      &instance->reply_queue_h);
1925
1926         if (!instance->reply_queue) {
1927                 printk(KERN_DEBUG "megasas: Out of DMA mem for reply queue\n");
1928                 goto fail_reply_queue;
1929         }
1930
1931         /*
1932          * Prepare a init frame. Note the init frame points to queue info
1933          * structure. Each frame has SGL allocated after first 64 bytes. For
1934          * this frame - since we don't need any SGL - we use SGL's space as
1935          * queue info structure
1936          *
1937          * We will not get a NULL command below. We just created the pool.
1938          */
1939         cmd = megasas_get_cmd(instance);
1940
1941         init_frame = (struct megasas_init_frame *)cmd->frame;
1942         initq_info = (struct megasas_init_queue_info *)
1943             ((unsigned long)init_frame + 64);
1944
1945         init_frame_h = cmd->frame_phys_addr;
1946         initq_info_h = init_frame_h + 64;
1947
1948         memset(init_frame, 0, MEGAMFI_FRAME_SIZE);
1949         memset(initq_info, 0, sizeof(struct megasas_init_queue_info));
1950
1951         initq_info->reply_queue_entries = instance->max_fw_cmds + 1;
1952         initq_info->reply_queue_start_phys_addr_lo = instance->reply_queue_h;
1953
1954         initq_info->producer_index_phys_addr_lo = instance->producer_h;
1955         initq_info->consumer_index_phys_addr_lo = instance->consumer_h;
1956
1957         init_frame->cmd = MFI_CMD_INIT;
1958         init_frame->cmd_status = 0xFF;
1959         init_frame->queue_info_new_phys_addr_lo = initq_info_h;
1960
1961         init_frame->data_xfer_len = sizeof(struct megasas_init_queue_info);
1962
1963         /*
1964          * disable the intr before firing the init frame to FW
1965          */
1966         instance->instancet->disable_intr(instance->reg_set);
1967
1968         /*
1969          * Issue the init frame in polled mode
1970          */
1971         if (megasas_issue_polled(instance, cmd)) {
1972                 printk(KERN_DEBUG "megasas: Failed to init firmware\n");
1973                 goto fail_fw_init;
1974         }
1975
1976         megasas_return_cmd(instance, cmd);
1977
1978         ctrl_info = kmalloc(sizeof(struct megasas_ctrl_info), GFP_KERNEL);
1979
1980         /*
1981          * Compute the max allowed sectors per IO: The controller info has two
1982          * limits on max sectors. Driver should use the minimum of these two.
1983          *
1984          * 1 << stripe_sz_ops.min = max sectors per strip
1985          *
1986          * Note that older firmwares ( < FW ver 30) didn't report information
1987          * to calculate max_sectors_1. So the number ended up as zero always.
1988          */
1989         if (ctrl_info && !megasas_get_ctrl_info(instance, ctrl_info)) {
1990
1991                 max_sectors_1 = (1 << ctrl_info->stripe_sz_ops.min) *
1992                     ctrl_info->max_strips_per_io;
1993                 max_sectors_2 = ctrl_info->max_request_size;
1994
1995                 instance->max_sectors_per_req = (max_sectors_1 < max_sectors_2)
1996                     ? max_sectors_1 : max_sectors_2;
1997         } else
1998                 instance->max_sectors_per_req = instance->max_num_sge *
1999                     PAGE_SIZE / 512;
2000
2001         kfree(ctrl_info);
2002
2003         /*
2004         * Setup tasklet for cmd completion
2005         */
2006
2007         tasklet_init(&instance->isr_tasklet, megasas_complete_cmd_dpc,
2008                         (unsigned long)instance);
2009         return 0;
2010
2011       fail_fw_init:
2012         megasas_return_cmd(instance, cmd);
2013
2014         pci_free_consistent(instance->pdev, reply_q_sz,
2015                             instance->reply_queue, instance->reply_queue_h);
2016       fail_reply_queue:
2017         megasas_free_cmds(instance);
2018
2019       fail_alloc_cmds:
2020       fail_ready_state:
2021         iounmap(instance->reg_set);
2022
2023       fail_ioremap:
2024         pci_release_regions(instance->pdev);
2025
2026         return -EINVAL;
2027 }
2028
2029 /**
2030  * megasas_release_mfi -        Reverses the FW initialization
2031  * @intance:                    Adapter soft state
2032  */
2033 static void megasas_release_mfi(struct megasas_instance *instance)
2034 {
2035         u32 reply_q_sz = sizeof(u32) * (instance->max_fw_cmds + 1);
2036
2037         pci_free_consistent(instance->pdev, reply_q_sz,
2038                             instance->reply_queue, instance->reply_queue_h);
2039
2040         megasas_free_cmds(instance);
2041
2042         iounmap(instance->reg_set);
2043
2044         pci_release_regions(instance->pdev);
2045 }
2046
2047 /**
2048  * megasas_get_seq_num -        Gets latest event sequence numbers
2049  * @instance:                   Adapter soft state
2050  * @eli:                        FW event log sequence numbers information
2051  *
2052  * FW maintains a log of all events in a non-volatile area. Upper layers would
2053  * usually find out the latest sequence number of the events, the seq number at
2054  * the boot etc. They would "read" all the events below the latest seq number
2055  * by issuing a direct fw cmd (DCMD). For the future events (beyond latest seq
2056  * number), they would subsribe to AEN (asynchronous event notification) and
2057  * wait for the events to happen.
2058  */
2059 static int
2060 megasas_get_seq_num(struct megasas_instance *instance,
2061                     struct megasas_evt_log_info *eli)
2062 {
2063         struct megasas_cmd *cmd;
2064         struct megasas_dcmd_frame *dcmd;
2065         struct megasas_evt_log_info *el_info;
2066         dma_addr_t el_info_h = 0;
2067
2068         cmd = megasas_get_cmd(instance);
2069
2070         if (!cmd) {
2071                 return -ENOMEM;
2072         }
2073
2074         dcmd = &cmd->frame->dcmd;
2075         el_info = pci_alloc_consistent(instance->pdev,
2076                                        sizeof(struct megasas_evt_log_info),
2077                                        &el_info_h);
2078
2079         if (!el_info) {
2080                 megasas_return_cmd(instance, cmd);
2081                 return -ENOMEM;
2082         }
2083
2084         memset(el_info, 0, sizeof(*el_info));
2085         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2086
2087         dcmd->cmd = MFI_CMD_DCMD;
2088         dcmd->cmd_status = 0x0;
2089         dcmd->sge_count = 1;
2090         dcmd->flags = MFI_FRAME_DIR_READ;
2091         dcmd->timeout = 0;
2092         dcmd->data_xfer_len = sizeof(struct megasas_evt_log_info);
2093         dcmd->opcode = MR_DCMD_CTRL_EVENT_GET_INFO;
2094         dcmd->sgl.sge32[0].phys_addr = el_info_h;
2095         dcmd->sgl.sge32[0].length = sizeof(struct megasas_evt_log_info);
2096
2097         megasas_issue_blocked_cmd(instance, cmd);
2098
2099         /*
2100          * Copy the data back into callers buffer
2101          */
2102         memcpy(eli, el_info, sizeof(struct megasas_evt_log_info));
2103
2104         pci_free_consistent(instance->pdev, sizeof(struct megasas_evt_log_info),
2105                             el_info, el_info_h);
2106
2107         megasas_return_cmd(instance, cmd);
2108
2109         return 0;
2110 }
2111
2112 /**
2113  * megasas_register_aen -       Registers for asynchronous event notification
2114  * @instance:                   Adapter soft state
2115  * @seq_num:                    The starting sequence number
2116  * @class_locale:               Class of the event
2117  *
2118  * This function subscribes for AEN for events beyond the @seq_num. It requests
2119  * to be notified if and only if the event is of type @class_locale
2120  */
2121 static int
2122 megasas_register_aen(struct megasas_instance *instance, u32 seq_num,
2123                      u32 class_locale_word)
2124 {
2125         int ret_val;
2126         struct megasas_cmd *cmd;
2127         struct megasas_dcmd_frame *dcmd;
2128         union megasas_evt_class_locale curr_aen;
2129         union megasas_evt_class_locale prev_aen;
2130
2131         /*
2132          * If there an AEN pending already (aen_cmd), check if the
2133          * class_locale of that pending AEN is inclusive of the new
2134          * AEN request we currently have. If it is, then we don't have
2135          * to do anything. In other words, whichever events the current
2136          * AEN request is subscribing to, have already been subscribed
2137          * to.
2138          *
2139          * If the old_cmd is _not_ inclusive, then we have to abort
2140          * that command, form a class_locale that is superset of both
2141          * old and current and re-issue to the FW
2142          */
2143
2144         curr_aen.word = class_locale_word;
2145
2146         if (instance->aen_cmd) {
2147
2148                 prev_aen.word = instance->aen_cmd->frame->dcmd.mbox.w[1];
2149
2150                 /*
2151                  * A class whose enum value is smaller is inclusive of all
2152                  * higher values. If a PROGRESS (= -1) was previously
2153                  * registered, then a new registration requests for higher
2154                  * classes need not be sent to FW. They are automatically
2155                  * included.
2156                  *
2157                  * Locale numbers don't have such hierarchy. They are bitmap
2158                  * values
2159                  */
2160                 if ((prev_aen.members.class <= curr_aen.members.class) &&
2161                     !((prev_aen.members.locale & curr_aen.members.locale) ^
2162                       curr_aen.members.locale)) {
2163                         /*
2164                          * Previously issued event registration includes
2165                          * current request. Nothing to do.
2166                          */
2167                         return 0;
2168                 } else {
2169                         curr_aen.members.locale |= prev_aen.members.locale;
2170
2171                         if (prev_aen.members.class < curr_aen.members.class)
2172                                 curr_aen.members.class = prev_aen.members.class;
2173
2174                         instance->aen_cmd->abort_aen = 1;
2175                         ret_val = megasas_issue_blocked_abort_cmd(instance,
2176                                                                   instance->
2177                                                                   aen_cmd);
2178
2179                         if (ret_val) {
2180                                 printk(KERN_DEBUG "megasas: Failed to abort "
2181                                        "previous AEN command\n");
2182                                 return ret_val;
2183                         }
2184                 }
2185         }
2186
2187         cmd = megasas_get_cmd(instance);
2188
2189         if (!cmd)
2190                 return -ENOMEM;
2191
2192         dcmd = &cmd->frame->dcmd;
2193
2194         memset(instance->evt_detail, 0, sizeof(struct megasas_evt_detail));
2195
2196         /*
2197          * Prepare DCMD for aen registration
2198          */
2199         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2200
2201         dcmd->cmd = MFI_CMD_DCMD;
2202         dcmd->cmd_status = 0x0;
2203         dcmd->sge_count = 1;
2204         dcmd->flags = MFI_FRAME_DIR_READ;
2205         dcmd->timeout = 0;
2206         dcmd->data_xfer_len = sizeof(struct megasas_evt_detail);
2207         dcmd->opcode = MR_DCMD_CTRL_EVENT_WAIT;
2208         dcmd->mbox.w[0] = seq_num;
2209         dcmd->mbox.w[1] = curr_aen.word;
2210         dcmd->sgl.sge32[0].phys_addr = (u32) instance->evt_detail_h;
2211         dcmd->sgl.sge32[0].length = sizeof(struct megasas_evt_detail);
2212
2213         /*
2214          * Store reference to the cmd used to register for AEN. When an
2215          * application wants us to register for AEN, we have to abort this
2216          * cmd and re-register with a new EVENT LOCALE supplied by that app
2217          */
2218         instance->aen_cmd = cmd;
2219
2220         /*
2221          * Issue the aen registration frame
2222          */
2223         instance->instancet->fire_cmd(cmd->frame_phys_addr ,0,instance->reg_set);
2224
2225         return 0;
2226 }
2227
2228 /**
2229  * megasas_start_aen -  Subscribes to AEN during driver load time
2230  * @instance:           Adapter soft state
2231  */
2232 static int megasas_start_aen(struct megasas_instance *instance)
2233 {
2234         struct megasas_evt_log_info eli;
2235         union megasas_evt_class_locale class_locale;
2236
2237         /*
2238          * Get the latest sequence number from FW
2239          */
2240         memset(&eli, 0, sizeof(eli));
2241
2242         if (megasas_get_seq_num(instance, &eli))
2243                 return -1;
2244
2245         /*
2246          * Register AEN with FW for latest sequence number plus 1
2247          */
2248         class_locale.members.reserved = 0;
2249         class_locale.members.locale = MR_EVT_LOCALE_ALL;
2250         class_locale.members.class = MR_EVT_CLASS_DEBUG;
2251
2252         return megasas_register_aen(instance, eli.newest_seq_num + 1,
2253                                     class_locale.word);
2254 }
2255
2256 /**
2257  * megasas_io_attach -  Attaches this driver to SCSI mid-layer
2258  * @instance:           Adapter soft state
2259  */
2260 static int megasas_io_attach(struct megasas_instance *instance)
2261 {
2262         struct Scsi_Host *host = instance->host;
2263
2264         /*
2265          * Export parameters required by SCSI mid-layer
2266          */
2267         host->irq = instance->pdev->irq;
2268         host->unique_id = instance->unique_id;
2269         host->can_queue = instance->max_fw_cmds - MEGASAS_INT_CMDS;
2270         host->this_id = instance->init_id;
2271         host->sg_tablesize = instance->max_num_sge;
2272         host->max_sectors = instance->max_sectors_per_req;
2273         host->cmd_per_lun = 128;
2274         host->max_channel = MEGASAS_MAX_CHANNELS - 1;
2275         host->max_id = MEGASAS_MAX_DEV_PER_CHANNEL;
2276         host->max_lun = MEGASAS_MAX_LUN;
2277         host->max_cmd_len = 16;
2278
2279         /*
2280          * Notify the mid-layer about the new controller
2281          */
2282         if (scsi_add_host(host, &instance->pdev->dev)) {
2283                 printk(KERN_DEBUG "megasas: scsi_add_host failed\n");
2284                 return -ENODEV;
2285         }
2286
2287         /*
2288          * Trigger SCSI to scan our drives
2289          */
2290         scsi_scan_host(host);
2291         return 0;
2292 }
2293
2294 /**
2295  * megasas_probe_one -  PCI hotplug entry point
2296  * @pdev:               PCI device structure
2297  * @id:                 PCI ids of supported hotplugged adapter
2298  */
2299 static int __devinit
2300 megasas_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
2301 {
2302         int rval;
2303         struct Scsi_Host *host;
2304         struct megasas_instance *instance;
2305
2306         /*
2307          * Announce PCI information
2308          */
2309         printk(KERN_INFO "megasas: %#4.04x:%#4.04x:%#4.04x:%#4.04x: ",
2310                pdev->vendor, pdev->device, pdev->subsystem_vendor,
2311                pdev->subsystem_device);
2312
2313         printk("bus %d:slot %d:func %d\n",
2314                pdev->bus->number, PCI_SLOT(pdev->devfn), PCI_FUNC(pdev->devfn));
2315
2316         /*
2317          * PCI prepping: enable device set bus mastering and dma mask
2318          */
2319         rval = pci_enable_device(pdev);
2320
2321         if (rval) {
2322                 return rval;
2323         }
2324
2325         pci_set_master(pdev);
2326
2327         /*
2328          * All our contollers are capable of performing 64-bit DMA
2329          */
2330         if (IS_DMA64) {
2331                 if (pci_set_dma_mask(pdev, DMA_64BIT_MASK) != 0) {
2332
2333                         if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0)
2334                                 goto fail_set_dma_mask;
2335                 }
2336         } else {
2337                 if (pci_set_dma_mask(pdev, DMA_32BIT_MASK) != 0)
2338                         goto fail_set_dma_mask;
2339         }
2340
2341         host = scsi_host_alloc(&megasas_template,
2342                                sizeof(struct megasas_instance));
2343
2344         if (!host) {
2345                 printk(KERN_DEBUG "megasas: scsi_host_alloc failed\n");
2346                 goto fail_alloc_instance;
2347         }
2348
2349         instance = (struct megasas_instance *)host->hostdata;
2350         memset(instance, 0, sizeof(*instance));
2351
2352         instance->producer = pci_alloc_consistent(pdev, sizeof(u32),
2353                                                   &instance->producer_h);
2354         instance->consumer = pci_alloc_consistent(pdev, sizeof(u32),
2355                                                   &instance->consumer_h);
2356
2357         if (!instance->producer || !instance->consumer) {
2358                 printk(KERN_DEBUG "megasas: Failed to allocate memory for "
2359                        "producer, consumer\n");
2360                 goto fail_alloc_dma_buf;
2361         }
2362
2363         *instance->producer = 0;
2364         *instance->consumer = 0;
2365
2366         instance->evt_detail = pci_alloc_consistent(pdev,
2367                                                     sizeof(struct
2368                                                            megasas_evt_detail),
2369                                                     &instance->evt_detail_h);
2370
2371         if (!instance->evt_detail) {
2372                 printk(KERN_DEBUG "megasas: Failed to allocate memory for "
2373                        "event detail structure\n");
2374                 goto fail_alloc_dma_buf;
2375         }
2376
2377         /*
2378          * Initialize locks and queues
2379          */
2380         INIT_LIST_HEAD(&instance->cmd_pool);
2381
2382         atomic_set(&instance->fw_outstanding,0);
2383
2384         init_waitqueue_head(&instance->int_cmd_wait_q);
2385         init_waitqueue_head(&instance->abort_cmd_wait_q);
2386
2387         spin_lock_init(&instance->cmd_pool_lock);
2388
2389         sema_init(&instance->aen_mutex, 1);
2390         sema_init(&instance->ioctl_sem, MEGASAS_INT_CMDS);
2391
2392         /*
2393          * Initialize PCI related and misc parameters
2394          */
2395         instance->pdev = pdev;
2396         instance->host = host;
2397         instance->unique_id = pdev->bus->number << 8 | pdev->devfn;
2398         instance->init_id = MEGASAS_DEFAULT_INIT_ID;
2399
2400         megasas_dbg_lvl = 0;
2401
2402         /*
2403          * Initialize MFI Firmware
2404          */
2405         if (megasas_init_mfi(instance))
2406                 goto fail_init_mfi;
2407
2408         /*
2409          * Register IRQ
2410          */
2411         if (request_irq(pdev->irq, megasas_isr, IRQF_SHARED, "megasas", instance)) {
2412                 printk(KERN_DEBUG "megasas: Failed to register IRQ\n");
2413                 goto fail_irq;
2414         }
2415
2416         instance->instancet->enable_intr(instance->reg_set);
2417
2418         /*
2419          * Store instance in PCI softstate
2420          */
2421         pci_set_drvdata(pdev, instance);
2422
2423         /*
2424          * Add this controller to megasas_mgmt_info structure so that it
2425          * can be exported to management applications
2426          */
2427         megasas_mgmt_info.count++;
2428         megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = instance;
2429         megasas_mgmt_info.max_index++;
2430
2431         /*
2432          * Initiate AEN (Asynchronous Event Notification)
2433          */
2434         if (megasas_start_aen(instance)) {
2435                 printk(KERN_DEBUG "megasas: start aen failed\n");
2436                 goto fail_start_aen;
2437         }
2438
2439         /*
2440          * Register with SCSI mid-layer
2441          */
2442         if (megasas_io_attach(instance))
2443                 goto fail_io_attach;
2444
2445         return 0;
2446
2447       fail_start_aen:
2448       fail_io_attach:
2449         megasas_mgmt_info.count--;
2450         megasas_mgmt_info.instance[megasas_mgmt_info.max_index] = NULL;
2451         megasas_mgmt_info.max_index--;
2452
2453         pci_set_drvdata(pdev, NULL);
2454         instance->instancet->disable_intr(instance->reg_set);
2455         free_irq(instance->pdev->irq, instance);
2456
2457         megasas_release_mfi(instance);
2458
2459       fail_irq:
2460       fail_init_mfi:
2461       fail_alloc_dma_buf:
2462         if (instance->evt_detail)
2463                 pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
2464                                     instance->evt_detail,
2465                                     instance->evt_detail_h);
2466
2467         if (instance->producer)
2468                 pci_free_consistent(pdev, sizeof(u32), instance->producer,
2469                                     instance->producer_h);
2470         if (instance->consumer)
2471                 pci_free_consistent(pdev, sizeof(u32), instance->consumer,
2472                                     instance->consumer_h);
2473         scsi_host_put(host);
2474
2475       fail_alloc_instance:
2476       fail_set_dma_mask:
2477         pci_disable_device(pdev);
2478
2479         return -ENODEV;
2480 }
2481
2482 /**
2483  * megasas_flush_cache -        Requests FW to flush all its caches
2484  * @instance:                   Adapter soft state
2485  */
2486 static void megasas_flush_cache(struct megasas_instance *instance)
2487 {
2488         struct megasas_cmd *cmd;
2489         struct megasas_dcmd_frame *dcmd;
2490
2491         cmd = megasas_get_cmd(instance);
2492
2493         if (!cmd)
2494                 return;
2495
2496         dcmd = &cmd->frame->dcmd;
2497
2498         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2499
2500         dcmd->cmd = MFI_CMD_DCMD;
2501         dcmd->cmd_status = 0x0;
2502         dcmd->sge_count = 0;
2503         dcmd->flags = MFI_FRAME_DIR_NONE;
2504         dcmd->timeout = 0;
2505         dcmd->data_xfer_len = 0;
2506         dcmd->opcode = MR_DCMD_CTRL_CACHE_FLUSH;
2507         dcmd->mbox.b[0] = MR_FLUSH_CTRL_CACHE | MR_FLUSH_DISK_CACHE;
2508
2509         megasas_issue_blocked_cmd(instance, cmd);
2510
2511         megasas_return_cmd(instance, cmd);
2512
2513         return;
2514 }
2515
2516 /**
2517  * megasas_shutdown_controller -        Instructs FW to shutdown the controller
2518  * @instance:                           Adapter soft state
2519  */
2520 static void megasas_shutdown_controller(struct megasas_instance *instance)
2521 {
2522         struct megasas_cmd *cmd;
2523         struct megasas_dcmd_frame *dcmd;
2524
2525         cmd = megasas_get_cmd(instance);
2526
2527         if (!cmd)
2528                 return;
2529
2530         if (instance->aen_cmd)
2531                 megasas_issue_blocked_abort_cmd(instance, instance->aen_cmd);
2532
2533         dcmd = &cmd->frame->dcmd;
2534
2535         memset(dcmd->mbox.b, 0, MFI_MBOX_SIZE);
2536
2537         dcmd->cmd = MFI_CMD_DCMD;
2538         dcmd->cmd_status = 0x0;
2539         dcmd->sge_count = 0;
2540         dcmd->flags = MFI_FRAME_DIR_NONE;
2541         dcmd->timeout = 0;
2542         dcmd->data_xfer_len = 0;
2543         dcmd->opcode = MR_DCMD_CTRL_SHUTDOWN;
2544
2545         megasas_issue_blocked_cmd(instance, cmd);
2546
2547         megasas_return_cmd(instance, cmd);
2548
2549         return;
2550 }
2551
2552 /**
2553  * megasas_detach_one - PCI hot"un"plug entry point
2554  * @pdev:               PCI device structure
2555  */
2556 static void megasas_detach_one(struct pci_dev *pdev)
2557 {
2558         int i;
2559         struct Scsi_Host *host;
2560         struct megasas_instance *instance;
2561
2562         instance = pci_get_drvdata(pdev);
2563         host = instance->host;
2564
2565         scsi_remove_host(instance->host);
2566         megasas_flush_cache(instance);
2567         megasas_shutdown_controller(instance);
2568         tasklet_kill(&instance->isr_tasklet);
2569
2570         /*
2571          * Take the instance off the instance array. Note that we will not
2572          * decrement the max_index. We let this array be sparse array
2573          */
2574         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
2575                 if (megasas_mgmt_info.instance[i] == instance) {
2576                         megasas_mgmt_info.count--;
2577                         megasas_mgmt_info.instance[i] = NULL;
2578
2579                         break;
2580                 }
2581         }
2582
2583         pci_set_drvdata(instance->pdev, NULL);
2584
2585         instance->instancet->disable_intr(instance->reg_set);
2586
2587         free_irq(instance->pdev->irq, instance);
2588
2589         megasas_release_mfi(instance);
2590
2591         pci_free_consistent(pdev, sizeof(struct megasas_evt_detail),
2592                             instance->evt_detail, instance->evt_detail_h);
2593
2594         pci_free_consistent(pdev, sizeof(u32), instance->producer,
2595                             instance->producer_h);
2596
2597         pci_free_consistent(pdev, sizeof(u32), instance->consumer,
2598                             instance->consumer_h);
2599
2600         scsi_host_put(host);
2601
2602         pci_set_drvdata(pdev, NULL);
2603
2604         pci_disable_device(pdev);
2605
2606         return;
2607 }
2608
2609 /**
2610  * megasas_shutdown -   Shutdown entry point
2611  * @device:             Generic device structure
2612  */
2613 static void megasas_shutdown(struct pci_dev *pdev)
2614 {
2615         struct megasas_instance *instance = pci_get_drvdata(pdev);
2616         megasas_flush_cache(instance);
2617 }
2618
2619 /**
2620  * megasas_mgmt_open -  char node "open" entry point
2621  */
2622 static int megasas_mgmt_open(struct inode *inode, struct file *filep)
2623 {
2624         /*
2625          * Allow only those users with admin rights
2626          */
2627         if (!capable(CAP_SYS_ADMIN))
2628                 return -EACCES;
2629
2630         return 0;
2631 }
2632
2633 /**
2634  * megasas_mgmt_release - char node "release" entry point
2635  */
2636 static int megasas_mgmt_release(struct inode *inode, struct file *filep)
2637 {
2638         filep->private_data = NULL;
2639         fasync_helper(-1, filep, 0, &megasas_async_queue);
2640
2641         return 0;
2642 }
2643
2644 /**
2645  * megasas_mgmt_fasync -        Async notifier registration from applications
2646  *
2647  * This function adds the calling process to a driver global queue. When an
2648  * event occurs, SIGIO will be sent to all processes in this queue.
2649  */
2650 static int megasas_mgmt_fasync(int fd, struct file *filep, int mode)
2651 {
2652         int rc;
2653
2654         mutex_lock(&megasas_async_queue_mutex);
2655
2656         rc = fasync_helper(fd, filep, mode, &megasas_async_queue);
2657
2658         mutex_unlock(&megasas_async_queue_mutex);
2659
2660         if (rc >= 0) {
2661                 /* For sanity check when we get ioctl */
2662                 filep->private_data = filep;
2663                 return 0;
2664         }
2665
2666         printk(KERN_DEBUG "megasas: fasync_helper failed [%d]\n", rc);
2667
2668         return rc;
2669 }
2670
2671 /**
2672  * megasas_mgmt_fw_ioctl -      Issues management ioctls to FW
2673  * @instance:                   Adapter soft state
2674  * @argp:                       User's ioctl packet
2675  */
2676 static int
2677 megasas_mgmt_fw_ioctl(struct megasas_instance *instance,
2678                       struct megasas_iocpacket __user * user_ioc,
2679                       struct megasas_iocpacket *ioc)
2680 {
2681         struct megasas_sge32 *kern_sge32;
2682         struct megasas_cmd *cmd;
2683         void *kbuff_arr[MAX_IOCTL_SGE];
2684         dma_addr_t buf_handle = 0;
2685         int error = 0, i;
2686         void *sense = NULL;
2687         dma_addr_t sense_handle;
2688         u32 *sense_ptr;
2689
2690         memset(kbuff_arr, 0, sizeof(kbuff_arr));
2691
2692         if (ioc->sge_count > MAX_IOCTL_SGE) {
2693                 printk(KERN_DEBUG "megasas: SGE count [%d] >  max limit [%d]\n",
2694                        ioc->sge_count, MAX_IOCTL_SGE);
2695                 return -EINVAL;
2696         }
2697
2698         cmd = megasas_get_cmd(instance);
2699         if (!cmd) {
2700                 printk(KERN_DEBUG "megasas: Failed to get a cmd packet\n");
2701                 return -ENOMEM;
2702         }
2703
2704         /*
2705          * User's IOCTL packet has 2 frames (maximum). Copy those two
2706          * frames into our cmd's frames. cmd->frame's context will get
2707          * overwritten when we copy from user's frames. So set that value
2708          * alone separately
2709          */
2710         memcpy(cmd->frame, ioc->frame.raw, 2 * MEGAMFI_FRAME_SIZE);
2711         cmd->frame->hdr.context = cmd->index;
2712
2713         /*
2714          * The management interface between applications and the fw uses
2715          * MFI frames. E.g, RAID configuration changes, LD property changes
2716          * etc are accomplishes through different kinds of MFI frames. The
2717          * driver needs to care only about substituting user buffers with
2718          * kernel buffers in SGLs. The location of SGL is embedded in the
2719          * struct iocpacket itself.
2720          */
2721         kern_sge32 = (struct megasas_sge32 *)
2722             ((unsigned long)cmd->frame + ioc->sgl_off);
2723
2724         /*
2725          * For each user buffer, create a mirror buffer and copy in
2726          */
2727         for (i = 0; i < ioc->sge_count; i++) {
2728                 kbuff_arr[i] = dma_alloc_coherent(&instance->pdev->dev,
2729                                                     ioc->sgl[i].iov_len,
2730                                                     &buf_handle, GFP_KERNEL);
2731                 if (!kbuff_arr[i]) {
2732                         printk(KERN_DEBUG "megasas: Failed to alloc "
2733                                "kernel SGL buffer for IOCTL \n");
2734                         error = -ENOMEM;
2735                         goto out;
2736                 }
2737
2738                 /*
2739                  * We don't change the dma_coherent_mask, so
2740                  * pci_alloc_consistent only returns 32bit addresses
2741                  */
2742                 kern_sge32[i].phys_addr = (u32) buf_handle;
2743                 kern_sge32[i].length = ioc->sgl[i].iov_len;
2744
2745                 /*
2746                  * We created a kernel buffer corresponding to the
2747                  * user buffer. Now copy in from the user buffer
2748                  */
2749                 if (copy_from_user(kbuff_arr[i], ioc->sgl[i].iov_base,
2750                                    (u32) (ioc->sgl[i].iov_len))) {
2751                         error = -EFAULT;
2752                         goto out;
2753                 }
2754         }
2755
2756         if (ioc->sense_len) {
2757                 sense = dma_alloc_coherent(&instance->pdev->dev, ioc->sense_len,
2758                                              &sense_handle, GFP_KERNEL);
2759                 if (!sense) {
2760                         error = -ENOMEM;
2761                         goto out;
2762                 }
2763
2764                 sense_ptr =
2765                     (u32 *) ((unsigned long)cmd->frame + ioc->sense_off);
2766                 *sense_ptr = sense_handle;
2767         }
2768
2769         /*
2770          * Set the sync_cmd flag so that the ISR knows not to complete this
2771          * cmd to the SCSI mid-layer
2772          */
2773         cmd->sync_cmd = 1;
2774         megasas_issue_blocked_cmd(instance, cmd);
2775         cmd->sync_cmd = 0;
2776
2777         /*
2778          * copy out the kernel buffers to user buffers
2779          */
2780         for (i = 0; i < ioc->sge_count; i++) {
2781                 if (copy_to_user(ioc->sgl[i].iov_base, kbuff_arr[i],
2782                                  ioc->sgl[i].iov_len)) {
2783                         error = -EFAULT;
2784                         goto out;
2785                 }
2786         }
2787
2788         /*
2789          * copy out the sense
2790          */
2791         if (ioc->sense_len) {
2792                 /*
2793                  * sense_ptr points to the location that has the user
2794                  * sense buffer address
2795                  */
2796                 sense_ptr = (u32 *) ((unsigned long)ioc->frame.raw +
2797                                      ioc->sense_off);
2798
2799                 if (copy_to_user((void __user *)((unsigned long)(*sense_ptr)),
2800                                  sense, ioc->sense_len)) {
2801                         error = -EFAULT;
2802                         goto out;
2803                 }
2804         }
2805
2806         /*
2807          * copy the status codes returned by the fw
2808          */
2809         if (copy_to_user(&user_ioc->frame.hdr.cmd_status,
2810                          &cmd->frame->hdr.cmd_status, sizeof(u8))) {
2811                 printk(KERN_DEBUG "megasas: Error copying out cmd_status\n");
2812                 error = -EFAULT;
2813         }
2814
2815       out:
2816         if (sense) {
2817                 dma_free_coherent(&instance->pdev->dev, ioc->sense_len,
2818                                     sense, sense_handle);
2819         }
2820
2821         for (i = 0; i < ioc->sge_count && kbuff_arr[i]; i++) {
2822                 dma_free_coherent(&instance->pdev->dev,
2823                                     kern_sge32[i].length,
2824                                     kbuff_arr[i], kern_sge32[i].phys_addr);
2825         }
2826
2827         megasas_return_cmd(instance, cmd);
2828         return error;
2829 }
2830
2831 static struct megasas_instance *megasas_lookup_instance(u16 host_no)
2832 {
2833         int i;
2834
2835         for (i = 0; i < megasas_mgmt_info.max_index; i++) {
2836
2837                 if ((megasas_mgmt_info.instance[i]) &&
2838                     (megasas_mgmt_info.instance[i]->host->host_no == host_no))
2839                         return megasas_mgmt_info.instance[i];
2840         }
2841
2842         return NULL;
2843 }
2844
2845 static int megasas_mgmt_ioctl_fw(struct file *file, unsigned long arg)
2846 {
2847         struct megasas_iocpacket __user *user_ioc =
2848             (struct megasas_iocpacket __user *)arg;
2849         struct megasas_iocpacket *ioc;
2850         struct megasas_instance *instance;
2851         int error;
2852
2853         ioc = kmalloc(sizeof(*ioc), GFP_KERNEL);
2854         if (!ioc)
2855                 return -ENOMEM;
2856
2857         if (copy_from_user(ioc, user_ioc, sizeof(*ioc))) {
2858                 error = -EFAULT;
2859                 goto out_kfree_ioc;
2860         }
2861
2862         instance = megasas_lookup_instance(ioc->host_no);
2863         if (!instance) {
2864                 error = -ENODEV;
2865                 goto out_kfree_ioc;
2866         }
2867
2868         /*
2869          * We will allow only MEGASAS_INT_CMDS number of parallel ioctl cmds
2870          */
2871         if (down_interruptible(&instance->ioctl_sem)) {
2872                 error = -ERESTARTSYS;
2873                 goto out_kfree_ioc;
2874         }
2875         error = megasas_mgmt_fw_ioctl(instance, user_ioc, ioc);
2876         up(&instance->ioctl_sem);
2877
2878       out_kfree_ioc:
2879         kfree(ioc);
2880         return error;
2881 }
2882
2883 static int megasas_mgmt_ioctl_aen(struct file *file, unsigned long arg)
2884 {
2885         struct megasas_instance *instance;
2886         struct megasas_aen aen;
2887         int error;
2888
2889         if (file->private_data != file) {
2890                 printk(KERN_DEBUG "megasas: fasync_helper was not "
2891                        "called first\n");
2892                 return -EINVAL;
2893         }
2894
2895         if (copy_from_user(&aen, (void __user *)arg, sizeof(aen)))
2896                 return -EFAULT;
2897
2898         instance = megasas_lookup_instance(aen.host_no);
2899
2900         if (!instance)
2901                 return -ENODEV;
2902
2903         down(&instance->aen_mutex);
2904         error = megasas_register_aen(instance, aen.seq_num,
2905                                      aen.class_locale_word);
2906         up(&instance->aen_mutex);
2907         return error;
2908 }
2909
2910 /**
2911  * megasas_mgmt_ioctl - char node ioctl entry point
2912  */
2913 static long
2914 megasas_mgmt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
2915 {
2916         switch (cmd) {
2917         case MEGASAS_IOC_FIRMWARE:
2918                 return megasas_mgmt_ioctl_fw(file, arg);
2919
2920         case MEGASAS_IOC_GET_AEN:
2921                 return megasas_mgmt_ioctl_aen(file, arg);
2922         }
2923
2924         return -ENOTTY;
2925 }
2926
2927 #ifdef CONFIG_COMPAT
2928 static int megasas_mgmt_compat_ioctl_fw(struct file *file, unsigned long arg)
2929 {
2930         struct compat_megasas_iocpacket __user *cioc =
2931             (struct compat_megasas_iocpacket __user *)arg;
2932         struct megasas_iocpacket __user *ioc =
2933             compat_alloc_user_space(sizeof(struct megasas_iocpacket));
2934         int i;
2935         int error = 0;
2936
2937         if (clear_user(ioc, sizeof(*ioc)))
2938                 return -EFAULT;
2939
2940         if (copy_in_user(&ioc->host_no, &cioc->host_no, sizeof(u16)) ||
2941             copy_in_user(&ioc->sgl_off, &cioc->sgl_off, sizeof(u32)) ||
2942             copy_in_user(&ioc->sense_off, &cioc->sense_off, sizeof(u32)) ||
2943             copy_in_user(&ioc->sense_len, &cioc->sense_len, sizeof(u32)) ||
2944             copy_in_user(ioc->frame.raw, cioc->frame.raw, 128) ||
2945             copy_in_user(&ioc->sge_count, &cioc->sge_count, sizeof(u32)))
2946                 return -EFAULT;
2947
2948         for (i = 0; i < MAX_IOCTL_SGE; i++) {
2949                 compat_uptr_t ptr;
2950
2951                 if (get_user(ptr, &cioc->sgl[i].iov_base) ||
2952                     put_user(compat_ptr(ptr), &ioc->sgl[i].iov_base) ||
2953                     copy_in_user(&ioc->sgl[i].iov_len,
2954                                  &cioc->sgl[i].iov_len, sizeof(compat_size_t)))
2955                         return -EFAULT;
2956         }
2957
2958         error = megasas_mgmt_ioctl_fw(file, (unsigned long)ioc);
2959
2960         if (copy_in_user(&cioc->frame.hdr.cmd_status,
2961                          &ioc->frame.hdr.cmd_status, sizeof(u8))) {
2962                 printk(KERN_DEBUG "megasas: error copy_in_user cmd_status\n");
2963                 return -EFAULT;
2964         }
2965         return error;
2966 }
2967
2968 static long
2969 megasas_mgmt_compat_ioctl(struct file *file, unsigned int cmd,
2970                           unsigned long arg)
2971 {
2972         switch (cmd) {
2973         case MEGASAS_IOC_FIRMWARE32:
2974                 return megasas_mgmt_compat_ioctl_fw(file, arg);
2975         case MEGASAS_IOC_GET_AEN:
2976                 return megasas_mgmt_ioctl_aen(file, arg);
2977         }
2978
2979         return -ENOTTY;
2980 }
2981 #endif
2982
2983 /*
2984  * File operations structure for management interface
2985  */
2986 static const struct file_operations megasas_mgmt_fops = {
2987         .owner = THIS_MODULE,
2988         .open = megasas_mgmt_open,
2989         .release = megasas_mgmt_release,
2990         .fasync = megasas_mgmt_fasync,
2991         .unlocked_ioctl = megasas_mgmt_ioctl,
2992 #ifdef CONFIG_COMPAT
2993         .compat_ioctl = megasas_mgmt_compat_ioctl,
2994 #endif
2995 };
2996
2997 /*
2998  * PCI hotplug support registration structure
2999  */
3000 static struct pci_driver megasas_pci_driver = {
3001
3002         .name = "megaraid_sas",
3003         .id_table = megasas_pci_table,
3004         .probe = megasas_probe_one,
3005         .remove = __devexit_p(megasas_detach_one),
3006         .shutdown = megasas_shutdown,
3007 };
3008
3009 /*
3010  * Sysfs driver attributes
3011  */
3012 static ssize_t megasas_sysfs_show_version(struct device_driver *dd, char *buf)
3013 {
3014         return snprintf(buf, strlen(MEGASAS_VERSION) + 2, "%s\n",
3015                         MEGASAS_VERSION);
3016 }
3017
3018 static DRIVER_ATTR(version, S_IRUGO, megasas_sysfs_show_version, NULL);
3019
3020 static ssize_t
3021 megasas_sysfs_show_release_date(struct device_driver *dd, char *buf)
3022 {
3023         return snprintf(buf, strlen(MEGASAS_RELDATE) + 2, "%s\n",
3024                         MEGASAS_RELDATE);
3025 }
3026
3027 static DRIVER_ATTR(release_date, S_IRUGO, megasas_sysfs_show_release_date,
3028                    NULL);
3029
3030 static ssize_t
3031 megasas_sysfs_show_dbg_lvl(struct device_driver *dd, char *buf)
3032 {
3033         return sprintf(buf,"%u",megasas_dbg_lvl);
3034 }
3035
3036 static ssize_t
3037 megasas_sysfs_set_dbg_lvl(struct device_driver *dd, const char *buf, size_t count)
3038 {
3039         int retval = count;
3040         if(sscanf(buf,"%u",&megasas_dbg_lvl)<1){
3041                 printk(KERN_ERR "megasas: could not set dbg_lvl\n");
3042                 retval = -EINVAL;
3043         }
3044         return retval;
3045 }
3046
3047 static DRIVER_ATTR(dbg_lvl, S_IRUGO|S_IWUGO, megasas_sysfs_show_dbg_lvl,
3048                    megasas_sysfs_set_dbg_lvl);
3049
3050 /**
3051  * megasas_init - Driver load entry point
3052  */
3053 static int __init megasas_init(void)
3054 {
3055         int rval;
3056
3057         /*
3058          * Announce driver version and other information
3059          */
3060         printk(KERN_INFO "megasas: %s %s\n", MEGASAS_VERSION,
3061                MEGASAS_EXT_VERSION);
3062
3063         memset(&megasas_mgmt_info, 0, sizeof(megasas_mgmt_info));
3064
3065         /*
3066          * Register character device node
3067          */
3068         rval = register_chrdev(0, "megaraid_sas_ioctl", &megasas_mgmt_fops);
3069
3070         if (rval < 0) {
3071                 printk(KERN_DEBUG "megasas: failed to open device node\n");
3072                 return rval;
3073         }
3074
3075         megasas_mgmt_majorno = rval;
3076
3077         /*
3078          * Register ourselves as PCI hotplug module
3079          */
3080         rval = pci_register_driver(&megasas_pci_driver);
3081
3082         if (rval) {
3083                 printk(KERN_DEBUG "megasas: PCI hotplug regisration failed \n");
3084                 goto err_pcidrv;
3085         }
3086
3087         rval = driver_create_file(&megasas_pci_driver.driver,
3088                                   &driver_attr_version);
3089         if (rval)
3090                 goto err_dcf_attr_ver;
3091         rval = driver_create_file(&megasas_pci_driver.driver,
3092                                   &driver_attr_release_date);
3093         if (rval)
3094                 goto err_dcf_rel_date;
3095         rval = driver_create_file(&megasas_pci_driver.driver,
3096                                   &driver_attr_dbg_lvl);
3097         if (rval)
3098                 goto err_dcf_dbg_lvl;
3099
3100         return rval;
3101 err_dcf_dbg_lvl:
3102         driver_remove_file(&megasas_pci_driver.driver,
3103                            &driver_attr_release_date);
3104 err_dcf_rel_date:
3105         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
3106 err_dcf_attr_ver:
3107         pci_unregister_driver(&megasas_pci_driver);
3108 err_pcidrv:
3109         unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
3110         return rval;
3111 }
3112
3113 /**
3114  * megasas_exit - Driver unload entry point
3115  */
3116 static void __exit megasas_exit(void)
3117 {
3118         driver_remove_file(&megasas_pci_driver.driver,
3119                            &driver_attr_dbg_lvl);
3120         driver_remove_file(&megasas_pci_driver.driver,
3121                            &driver_attr_release_date);
3122         driver_remove_file(&megasas_pci_driver.driver, &driver_attr_version);
3123
3124         pci_unregister_driver(&megasas_pci_driver);
3125         unregister_chrdev(megasas_mgmt_majorno, "megaraid_sas_ioctl");
3126 }
3127
3128 module_init(megasas_init);
3129 module_exit(megasas_exit);