1 files changed, 242 insertions, 51 deletions

diff --git a/drivers/scsi/aacraid/src.c b/drivers/scsi/aacraid/src.c
index 957595a7a45c..2bee51506a91 100644
--- a/drivers/scsi/aacraid/src.c
+++ b/drivers/scsi/aacraid/src.c
@@ -96,6 +96,38 @@ static irqreturn_t aac_src_intr_message(int irq, void *dev_id)
                         our_interrupt = 1;
                         /* handle AIF */
                         aac_intr_normal(dev, 0, 2, 0, NULL);
+                } else if (bellbits_shifted & OUTBOUNDDOORBELL_0) {
+                        unsigned long sflags;
+                        struct list_head *entry;
+                        int send_it = 0;
+
+                        if (dev->sync_fib) {
+                                our_interrupt = 1;
+                                if (dev->sync_fib->callback)
+                                        dev->sync_fib->callback(dev->sync_fib->callback_data,
+                                                dev->sync_fib);
+                                spin_lock_irqsave(&dev->sync_fib->event_lock, sflags);
+                                if (dev->sync_fib->flags & FIB_CONTEXT_FLAG_WAIT) {
+                                        dev->management_fib_count--;
+                                        up(&dev->sync_fib->event_wait);
+                                }
+                                spin_unlock_irqrestore(&dev->sync_fib->event_lock, sflags);
+                                spin_lock_irqsave(&dev->sync_lock, sflags);
+                                if (!list_empty(&dev->sync_fib_list)) {
+                                        entry = dev->sync_fib_list.next;
+                                        dev->sync_fib = list_entry(entry, struct fib, fiblink);
+                                        list_del(entry);
+                                        send_it = 1;
+                                } else {
+                                        dev->sync_fib = NULL;
+                                }
+                                spin_unlock_irqrestore(&dev->sync_lock, sflags);
+                                if (send_it) {
+                                        aac_adapter_sync_cmd(dev, SEND_SYNCHRONOUS_FIB,
+                                                (u32)dev->sync_fib->hw_fib_pa, 0, 0, 0, 0, 0,
+                                                NULL, NULL, NULL, NULL, NULL);
+                                }
+                        }
                 }
         }
 
@@ -177,56 +209,63 @@ static int src_sync_cmd(struct aac_dev *dev, u32 command,
          */
         src_writel(dev, MUnit.IDR, INBOUNDDOORBELL_0 << SRC_IDR_SHIFT);
 
-        ok = 0;
-        start = jiffies;
+        if (!dev->sync_mode || command != SEND_SYNCHRONOUS_FIB) {
+                ok = 0;
+                start = jiffies;
 
-        /*
-         *      Wait up to 30 seconds
-         */
-        while (time_before(jiffies, start+30*HZ)) {
-                /* Delay 5 microseconds to let Mon960 get info. */
-                udelay(5);
-
-                /* Mon960 will set doorbell0 bit
-                 * when it has completed the command
+                /*
+                 *      Wait up to 5 minutes
                  */
-                if ((src_readl(dev, MUnit.ODR_R) >> SRC_ODR_SHIFT) & OUTBOUNDDOORBELL_0) {
-                        /* Clear the doorbell */
-                        src_writel(dev,
-                                MUnit.ODR_C,
-                                OUTBOUNDDOORBELL_0 << SRC_ODR_SHIFT);
-                        ok = 1;
-                        break;
+                while (time_before(jiffies, start+300*HZ)) {
+                        udelay(5);      /* Delay 5 microseconds to let Mon960 get info. */
+                        /*
+                         *      Mon960 will set doorbell0 bit when it has completed the command.
+                         */
+                        if ((src_readl(dev, MUnit.ODR_R) >> SRC_ODR_SHIFT) & OUTBOUNDDOORBELL_0) {
+                                /*
+                                 *      Clear the doorbell.
+                                 */
+                                src_writel(dev, MUnit.ODR_C, OUTBOUNDDOORBELL_0 << SRC_ODR_SHIFT);
+                                ok = 1;
+                                break;
+                        }
+                        /*
+                         *      Yield the processor in case we are slow
+                         */
+                        msleep(1);
                 }
-
-                 /* Yield the processor in case we are slow */
-                msleep(1);
-        }
-        if (unlikely(ok != 1)) {
-                 /* Restore interrupt mask even though we timed out */
-                aac_adapter_enable_int(dev);
-                return -ETIMEDOUT;
+                if (unlikely(ok != 1)) {
+                        /*
+                         *      Restore interrupt mask even though we timed out
+                         */
+                        aac_adapter_enable_int(dev);
+                        return -ETIMEDOUT;
+                }
+                /*
+                 *      Pull the synch status from Mailbox 0.
+                 */
+                if (status)
+                        *status = readl(&dev->IndexRegs->Mailbox[0]);
+                if (r1)
+                        *r1 = readl(&dev->IndexRegs->Mailbox[1]);
+                if (r2)
+                        *r2 = readl(&dev->IndexRegs->Mailbox[2]);
+                if (r3)
+                        *r3 = readl(&dev->IndexRegs->Mailbox[3]);
+                if (r4)
+                        *r4 = readl(&dev->IndexRegs->Mailbox[4]);
+
+                /*
+                 *      Clear the synch command doorbell.
+                 */
+                src_writel(dev, MUnit.ODR_C, OUTBOUNDDOORBELL_0 << SRC_ODR_SHIFT);
         }
 
-         /* Pull the synch status from Mailbox 0 */
-        if (status)
-                *status = readl(&dev->IndexRegs->Mailbox[0]);
-        if (r1)
-                *r1 = readl(&dev->IndexRegs->Mailbox[1]);
-        if (r2)
-                *r2 = readl(&dev->IndexRegs->Mailbox[2]);
-        if (r3)
-                *r3 = readl(&dev->IndexRegs->Mailbox[3]);
-        if (r4)
-                *r4 = readl(&dev->IndexRegs->Mailbox[4]);
-
-         /* Clear the synch command doorbell */
-        src_writel(dev, MUnit.ODR_C, OUTBOUNDDOORBELL_0 << SRC_ODR_SHIFT);
-
-         /* Restore interrupt mask */
+        /*
+         *      Restore interrupt mask
+         */
         aac_adapter_enable_int(dev);
         return 0;
-
 }
 
 /**
@@ -386,9 +425,7 @@ static int aac_src_ioremap(struct aac_dev *dev, u32 size)
 {
         if (!size) {
                 iounmap(dev->regs.src.bar0);
-                dev->regs.src.bar0 = NULL;
-                iounmap(dev->base);
-                dev->base = NULL;
+                dev->base = dev->regs.src.bar0 = NULL;
                 return 0;
         }
         dev->regs.src.bar1 = ioremap(pci_resource_start(dev->pdev, 2),
@@ -404,7 +441,27 @@ static int aac_src_ioremap(struct aac_dev *dev, u32 size)
                 return -1;
         }
         dev->IndexRegs = &((struct src_registers __iomem *)
-                dev->base)->IndexRegs;
+                dev->base)->u.tupelo.IndexRegs;
+        return 0;
+}
+
+/**
+ *  aac_srcv_ioremap
+ *      @size: mapping resize request
+ *
+ */
+static int aac_srcv_ioremap(struct aac_dev *dev, u32 size)
+{
+        if (!size) {
+                iounmap(dev->regs.src.bar0);
+                dev->base = dev->regs.src.bar0 = NULL;
+                return 0;
+        }
+        dev->base = dev->regs.src.bar0 = ioremap(dev->scsi_host_ptr->base, size);
+        if (dev->base == NULL)
+                return -1;
+        dev->IndexRegs = &((struct src_registers __iomem *)
+                dev->base)->u.denali.IndexRegs;
         return 0;
 }
 
@@ -419,7 +476,7 @@ static int aac_src_restart_adapter(struct aac_dev *dev, int bled)
                 bled = aac_adapter_sync_cmd(dev, IOP_RESET_ALWAYS,
                         0, 0, 0, 0, 0, 0, &var, &reset_mask, NULL, NULL, NULL);
                         if (bled || (var != 0x00000001))
-                                bled = -EINVAL;
+                                return -EINVAL;
                 if (dev->supplement_adapter_info.SupportedOptions2 &
                         AAC_OPTION_DOORBELL_RESET) {
                         src_writel(dev, MUnit.IDR, reset_mask);
@@ -579,15 +636,149 @@ int aac_src_init(struct aac_dev *dev)
         dev->dbg_size = AAC_MIN_SRC_BAR1_SIZE;
 
         aac_adapter_enable_int(dev);
+
+        if (!dev->sync_mode) {
+                /*
+                 * Tell the adapter that all is configured, and it can
+                 * start accepting requests
+                 */
+                aac_src_start_adapter(dev);
+        }
+        return 0;
+
+error_iounmap:
+
+        return -1;
+}
+
+/**
+ *  aac_srcv_init       -       initialize an SRCv card
+ *  @dev: device to configure
+ *
+ */
+
+int aac_srcv_init(struct aac_dev *dev)
+{
+        unsigned long start;
+        unsigned long status;
+        int restart = 0;
+        int instance = dev->id;
+        const char *name = dev->name;
+
+        dev->a_ops.adapter_ioremap = aac_srcv_ioremap;
+        dev->a_ops.adapter_comm = aac_src_select_comm;
+
+        dev->base_size = AAC_MIN_SRCV_BAR0_SIZE;
+        if (aac_adapter_ioremap(dev, dev->base_size)) {
+                printk(KERN_WARNING "%s: unable to map adapter.\n", name);
+                goto error_iounmap;
+        }
+
+        /* Failure to reset here is an option ... */
+        dev->a_ops.adapter_sync_cmd = src_sync_cmd;
+        dev->a_ops.adapter_enable_int = aac_src_disable_interrupt;
+        if ((aac_reset_devices || reset_devices) &&
+                !aac_src_restart_adapter(dev, 0))
+                ++restart;
         /*
-         *      Tell the adapter that all is configured, and it can
-         * start accepting requests
+         *      Check to see if the board panic'd while booting.
          */
-        aac_src_start_adapter(dev);
+        status = src_readl(dev, MUnit.OMR);
+        if (status & KERNEL_PANIC) {
+                if (aac_src_restart_adapter(dev, aac_src_check_health(dev)))
+                        goto error_iounmap;
+                ++restart;
+        }
+        /*
+         *      Check to see if the board failed any self tests.
+         */
+        status = src_readl(dev, MUnit.OMR);
+        if (status & SELF_TEST_FAILED) {
+                printk(KERN_ERR "%s%d: adapter self-test failed.\n", dev->name, instance);
+                goto error_iounmap;
+        }
+        /*
+         *      Check to see if the monitor panic'd while booting.
+         */
+        if (status & MONITOR_PANIC) {
+                printk(KERN_ERR "%s%d: adapter monitor panic.\n", dev->name, instance);
+                goto error_iounmap;
+        }
+        start = jiffies;
+        /*
+         *      Wait for the adapter to be up and running. Wait up to 3 minutes
+         */
+        while (!((status = src_readl(dev, MUnit.OMR)) & KERNEL_UP_AND_RUNNING)) {
+                if ((restart &&
+                  (status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC))) ||
+                  time_after(jiffies, start+HZ*startup_timeout)) {
+                        printk(KERN_ERR "%s%d: adapter kernel failed to start, init status = %lx.\n",
+                                        dev->name, instance, status);
+                        goto error_iounmap;
+                }
+                if (!restart &&
+                  ((status & (KERNEL_PANIC|SELF_TEST_FAILED|MONITOR_PANIC)) ||
+                  time_after(jiffies, start + HZ *
+                  ((startup_timeout > 60)
+                    ? (startup_timeout - 60)
+                    : (startup_timeout / 2))))) {
+                        if (likely(!aac_src_restart_adapter(dev, aac_src_check_health(dev))))
+                                start = jiffies;
+                        ++restart;
+                }
+                msleep(1);
+        }
+        if (restart && aac_commit)
+                aac_commit = 1;
+        /*
+         *      Fill in the common function dispatch table.
+         */
+        dev->a_ops.adapter_interrupt = aac_src_interrupt_adapter;
+        dev->a_ops.adapter_disable_int = aac_src_disable_interrupt;
+        dev->a_ops.adapter_notify = aac_src_notify_adapter;
+        dev->a_ops.adapter_sync_cmd = src_sync_cmd;
+        dev->a_ops.adapter_check_health = aac_src_check_health;
+        dev->a_ops.adapter_restart = aac_src_restart_adapter;
+
+        /*
+         *      First clear out all interrupts.  Then enable the one's that we
+         *      can handle.
+         */
+        aac_adapter_comm(dev, AAC_COMM_MESSAGE);
+        aac_adapter_disable_int(dev);
+        src_writel(dev, MUnit.ODR_C, 0xffffffff);
+        aac_adapter_enable_int(dev);
 
+        if (aac_init_adapter(dev) == NULL)
+                goto error_iounmap;
+        if (dev->comm_interface != AAC_COMM_MESSAGE_TYPE1)
+                goto error_iounmap;
+        dev->msi = aac_msi && !pci_enable_msi(dev->pdev);
+        if (request_irq(dev->pdev->irq, dev->a_ops.adapter_intr,
+                IRQF_SHARED|IRQF_DISABLED, "aacraid", dev) < 0) {
+                if (dev->msi)
+                        pci_disable_msi(dev->pdev);
+                printk(KERN_ERR "%s%d: Interrupt unavailable.\n",
+                        name, instance);
+                goto error_iounmap;
+        }
+        dev->dbg_base = dev->scsi_host_ptr->base;
+        dev->dbg_base_mapped = dev->base;
+        dev->dbg_size = dev->base_size;
+
+        aac_adapter_enable_int(dev);
+
+        if (!dev->sync_mode) {
+                /*
+                 * Tell the adapter that all is configured, and it can
+                 * start accepting requests
+                 */
+                aac_src_start_adapter(dev);
+        }
         return 0;
 
 error_iounmap:
 
         return -1;
 }
+