[SCSI] aacraid: rework communication support code

Received from Mark Salyzyn,

Replace all if/else communication transports with a platform function call.
This is in recognition of the need to migrate to up-and-coming transports.
Currently the Linux driver does not support two available communication
transports provided by our products, these will be added in future patches, and
will expand the platform function set.

Signed-off-by Mark Haverkamp <markh@linux-foundation.org>
Signed-off-by: James Bottomley <James.Bottomley@SteelEye.com>

1 files changed, 166 insertions, 97 deletions

diff --git a/drivers/scsi/aacraid/rx.c b/drivers/scsi/aacraid/rx.c
index dcc8b0ea7a9d..c632d9354a26 100644
--- a/drivers/scsi/aacraid/rx.c
+++ b/drivers/scsi/aacraid/rx.c
@@ -46,60 +46,60 @@
 
 #include "aacraid.h"
 
-static irqreturn_t aac_rx_intr(int irq, void *dev_id)
+static irqreturn_t aac_rx_intr_producer(int irq, void *dev_id)
 {
         struct aac_dev *dev = dev_id;
+        unsigned long bellbits;
+        u8 intstat = rx_readb(dev, MUnit.OISR);
 
-        dprintk((KERN_DEBUG "aac_rx_intr(%d,%p)\n", irq, dev_id));
-        if (dev->new_comm_interface) {
-                u32 Index = rx_readl(dev, MUnit.OutboundQueue);
-                if (Index == 0xFFFFFFFFL)
-                        Index = rx_readl(dev, MUnit.OutboundQueue);
-                if (Index != 0xFFFFFFFFL) {
-                        do {
-                                if (aac_intr_normal(dev, Index)) {
-                                        rx_writel(dev, MUnit.OutboundQueue, Index);
-                                        rx_writel(dev, MUnit.ODR, DoorBellAdapterNormRespReady);
-                                }
-                                Index = rx_readl(dev, MUnit.OutboundQueue);
-                        } while (Index != 0xFFFFFFFFL);
-                        return IRQ_HANDLED;
+        /*
+         *      Read mask and invert because drawbridge is reversed.
+         *      This allows us to only service interrupts that have
+         *      been enabled.
+         *      Check to see if this is our interrupt.  If it isn't just return
+         */
+        if (intstat & ~(dev->OIMR)) {
+                bellbits = rx_readl(dev, OutboundDoorbellReg);
+                if (bellbits & DoorBellPrintfReady) {
+                        aac_printf(dev, readl (&dev->IndexRegs->Mailbox[5]));
+                        rx_writel(dev, MUnit.ODR,DoorBellPrintfReady);
+                        rx_writel(dev, InboundDoorbellReg,DoorBellPrintfDone);
                 }
-        } else {
-                unsigned long bellbits;
-                u8 intstat;
-                intstat = rx_readb(dev, MUnit.OISR);
-                /*
-                 *      Read mask and invert because drawbridge is reversed.
-                 *      This allows us to only service interrupts that have 
-                 *      been enabled.
-                 *      Check to see if this is our interrupt.  If it isn't just return
-                 */
-                if (intstat & ~(dev->OIMR)) 
-                {
-                        bellbits = rx_readl(dev, OutboundDoorbellReg);
-                        if (bellbits & DoorBellPrintfReady) {
-                                aac_printf(dev, readl (&dev->IndexRegs->Mailbox[5]));
-                                rx_writel(dev, MUnit.ODR,DoorBellPrintfReady);
-                                rx_writel(dev, InboundDoorbellReg,DoorBellPrintfDone);
-                        }
-                        else if (bellbits & DoorBellAdapterNormCmdReady) {
-                                rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
-                                aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
-                        }
-                        else if (bellbits & DoorBellAdapterNormRespReady) {
-                                rx_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady);
-                                aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
-                        }
-                        else if (bellbits & DoorBellAdapterNormCmdNotFull) {
-                                rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
-                        }
-                        else if (bellbits & DoorBellAdapterNormRespNotFull) {
-                                rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
-                                rx_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull);
-                        }
-                        return IRQ_HANDLED;
+                else if (bellbits & DoorBellAdapterNormCmdReady) {
+                        rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdReady);
+                        aac_command_normal(&dev->queues->queue[HostNormCmdQueue]);
+                }
+                else if (bellbits & DoorBellAdapterNormRespReady) {
+                        rx_writel(dev, MUnit.ODR,DoorBellAdapterNormRespReady);
+                        aac_response_normal(&dev->queues->queue[HostNormRespQueue]);
+                }
+                else if (bellbits & DoorBellAdapterNormCmdNotFull) {
+                        rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
                 }
+                else if (bellbits & DoorBellAdapterNormRespNotFull) {
+                        rx_writel(dev, MUnit.ODR, DoorBellAdapterNormCmdNotFull);
+                        rx_writel(dev, MUnit.ODR, DoorBellAdapterNormRespNotFull);
+                }
+                return IRQ_HANDLED;
+        }
+        return IRQ_NONE;
+}
+
+static irqreturn_t aac_rx_intr_message(int irq, void *dev_id)
+{
+        struct aac_dev *dev = dev_id;
+        u32 Index = rx_readl(dev, MUnit.OutboundQueue);
+        if (Index == 0xFFFFFFFFL)
+                Index = rx_readl(dev, MUnit.OutboundQueue);
+        if (Index != 0xFFFFFFFFL) {
+                do {
+                        if (aac_intr_normal(dev, Index)) {
+                                rx_writel(dev, MUnit.OutboundQueue, Index);
+                                rx_writel(dev, MUnit.ODR, DoorBellAdapterNormRespReady);
+                        }
+                        Index = rx_readl(dev, MUnit.OutboundQueue);
+                } while (Index != 0xFFFFFFFFL);
+                return IRQ_HANDLED;
         }
         return IRQ_NONE;
 }
@@ -115,6 +115,26 @@ static void aac_rx_disable_interrupt(struct aac_dev *dev)
 }
 
 /**
+ *      aac_rx_enable_interrupt_producer        -       Enable interrupts
+ *      @dev: Adapter
+ */
+
+static void aac_rx_enable_interrupt_producer(struct aac_dev *dev)
+{
+        rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
+}
+
+/**
+ *      aac_rx_enable_interrupt_message -       Enable interrupts
+ *      @dev: Adapter
+ */
+
+static void aac_rx_enable_interrupt_message(struct aac_dev *dev)
+{
+        rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
+}
+
+/**
  *      rx_sync_cmd     -       send a command and wait
  *      @dev: Adapter
  *      @command: Command to execute
@@ -189,10 +209,7 @@ static int rx_sync_cmd(struct aac_dev *dev, u32 command,
                 /*
                  *      Restore interrupt mask even though we timed out
                  */
-                if (dev->new_comm_interface)
-                        rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
-                else
-                        rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
+                aac_adapter_enable_int(dev);
                 return -ETIMEDOUT;
         }
         /*
@@ -215,10 +232,7 @@ static int rx_sync_cmd(struct aac_dev *dev, u32 command,
         /*
          *      Restore interrupt mask
          */
-        if (dev->new_comm_interface)
-                rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
-        else
-                rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
+        aac_adapter_enable_int(dev);
         return 0;
 
 }
@@ -360,35 +374,72 @@ static int aac_rx_check_health(struct aac_dev *dev)
 }
 
 /**
- *      aac_rx_send
+ *      aac_rx_deliver_producer
  *      @fib: fib to issue
  *
  *      Will send a fib, returning 0 if successful.
  */
-static int aac_rx_send(struct fib * fib)
+static int aac_rx_deliver_producer(struct fib * fib)
 {
-        u64 addr = fib->hw_fib_pa;
         struct aac_dev *dev = fib->dev;
-        volatile void __iomem *device = dev->regs.rx;
+        struct aac_queue *q = &dev->queues->queue[AdapNormCmdQueue];
+        unsigned long qflags;
         u32 Index;
+        unsigned long nointr = 0;
 
-        dprintk((KERN_DEBUG "%p->aac_rx_send(%p->%llx)\n", dev, fib, addr));
-        Index = rx_readl(dev, MUnit.InboundQueue);
-        if (Index == 0xFFFFFFFFL)
+        spin_lock_irqsave(q->lock, qflags);
+        aac_queue_get( dev, &Index, AdapNormCmdQueue, fib->hw_fib, 1, fib, &nointr);
+
+        q->numpending++;
+        *(q->headers.producer) = cpu_to_le32(Index + 1);
+        spin_unlock_irqrestore(q->lock, qflags);
+        if (!(nointr & aac_config.irq_mod))
+                aac_adapter_notify(dev, AdapNormCmdQueue);
+
+        return 0;
+}
+
+/**
+ *      aac_rx_deliver_message
+ *      @fib: fib to issue
+ *
+ *      Will send a fib, returning 0 if successful.
+ */
+static int aac_rx_deliver_message(struct fib * fib)
+{
+        struct aac_dev *dev = fib->dev;
+        struct aac_queue *q = &dev->queues->queue[AdapNormCmdQueue];
+        unsigned long qflags;
+        u32 Index;
+        u64 addr;
+        volatile void __iomem *device;
+
+        unsigned long count = 10000000L; /* 50 seconds */
+        spin_lock_irqsave(q->lock, qflags);
+        q->numpending++;
+        spin_unlock_irqrestore(q->lock, qflags);
+        for(;;) {
                 Index = rx_readl(dev, MUnit.InboundQueue);
-        dprintk((KERN_DEBUG "Index = 0x%x\n", Index));
-        if (Index == 0xFFFFFFFFL)
-                return Index;
+                if (Index == 0xFFFFFFFFL)
+                        Index = rx_readl(dev, MUnit.InboundQueue);
+                if (Index != 0xFFFFFFFFL)
+                        break;
+                if (--count == 0) {
+                        spin_lock_irqsave(q->lock, qflags);
+                        q->numpending--;
+                        spin_unlock_irqrestore(q->lock, qflags);
+                        return -ETIMEDOUT;
+                }
+                udelay(5);
+        }
         device = dev->base + Index;
-        dprintk((KERN_DEBUG "entry = %x %x %u\n", (u32)(addr & 0xffffffff),
-          (u32)(addr >> 32), (u32)le16_to_cpu(fib->hw_fib->header.Size)));
+        addr = fib->hw_fib_pa;
         writel((u32)(addr & 0xffffffff), device);
         device += sizeof(u32);
         writel((u32)(addr >> 32), device);
         device += sizeof(u32);
         writel(le16_to_cpu(fib->hw_fib->header.Size), device);
         rx_writel(dev, MUnit.InboundQueue, Index);
-        dprintk((KERN_DEBUG "aac_rx_send - return 0\n"));
         return 0;
 }
 
@@ -430,6 +481,31 @@ static int aac_rx_restart_adapter(struct aac_dev *dev)
 }
 
 /**
+ *      aac_rx_select_comm      -       Select communications method
+ *      @dev: Adapter
+ *      @comm: communications method
+ */
+
+int aac_rx_select_comm(struct aac_dev *dev, int comm)
+{
+        switch (comm) {
+        case AAC_COMM_PRODUCER:
+                dev->a_ops.adapter_enable_int = aac_rx_enable_interrupt_producer;
+                dev->a_ops.adapter_intr = aac_rx_intr_producer;
+                dev->a_ops.adapter_deliver = aac_rx_deliver_producer;
+                break;
+        case AAC_COMM_MESSAGE:
+                dev->a_ops.adapter_enable_int = aac_rx_enable_interrupt_message;
+                dev->a_ops.adapter_intr = aac_rx_intr_message;
+                dev->a_ops.adapter_deliver = aac_rx_deliver_message;
+                break;
+        default:
+                return 1;
+        }
+        return 0;
+}
+
+/**
  *      aac_rx_init     -       initialize an i960 based AAC card
  *      @dev: device to configure
  *
@@ -489,40 +565,42 @@ int _aac_rx_init(struct aac_dev *dev)
                 }
                 msleep(1);
         }
-        if (request_irq(dev->scsi_host_ptr->irq, aac_rx_intr, IRQF_SHARED|IRQF_DISABLED, "aacraid", (void *)dev)<0)
-        {
-                printk(KERN_ERR "%s%d: Interrupt unavailable.\n", name, instance);
-                goto error_iounmap;
-        }
         /*
-         *      Fill in the function dispatch table.
+         *      Fill in the common function dispatch table.
          */
         dev->a_ops.adapter_interrupt = aac_rx_interrupt_adapter;
         dev->a_ops.adapter_disable_int = aac_rx_disable_interrupt;
         dev->a_ops.adapter_notify = aac_rx_notify_adapter;
         dev->a_ops.adapter_sync_cmd = rx_sync_cmd;
         dev->a_ops.adapter_check_health = aac_rx_check_health;
-        dev->a_ops.adapter_send = aac_rx_send;
 
         /*
          *      First clear out all interrupts.  Then enable the one's that we
          *      can handle.
          */
-        rx_writeb(dev, MUnit.OIMR, 0xff);
+        aac_adapter_comm(dev, AAC_COMM_PRODUCER);
+        aac_adapter_disable_int(dev);
         rx_writel(dev, MUnit.ODR, 0xffffffff);
-        rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xfb);
+        aac_adapter_enable_int(dev);
 
         if (aac_init_adapter(dev) == NULL)
-                goto error_irq;
-        if (dev->new_comm_interface)
-                rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xf7);
+                goto error_iounmap;
+        aac_adapter_comm(dev, dev->comm_interface);
+        if (request_irq(dev->scsi_host_ptr->irq, dev->a_ops.adapter_intr,
+                        IRQF_SHARED|IRQF_DISABLED, "aacraid", dev) < 0) {
+                printk(KERN_ERR "%s%d: Interrupt unavailable.\n",
+                        name, instance);
+                goto error_iounmap;
+        }
+        aac_adapter_enable_int(dev);
+        /*
+         *      Tell the adapter that all is configured, and it can
+         * start accepting requests
+         */
+        aac_rx_start_adapter(dev);
 
         return 0;
 
-error_irq:
-        rx_writeb(dev, MUnit.OIMR, dev->OIMR = 0xff);
-        free_irq(dev->scsi_host_ptr->irq, (void *)dev);
-
 error_iounmap:
 
         return -1;
@@ -530,20 +608,11 @@ error_iounmap:
 
 int aac_rx_init(struct aac_dev *dev)
 {
-        int retval;
-
         /*
          *      Fill in the function dispatch table.
          */
         dev->a_ops.adapter_ioremap = aac_rx_ioremap;
+        dev->a_ops.adapter_comm = aac_rx_select_comm;
 
-        retval = _aac_rx_init(dev);
-        if (!retval) {
-                /*
-                 *      Tell the adapter that all is configured, and it can
-                 * start accepting requests
-                 */
-                aac_rx_start_adapter(dev);
-        }
-        return retval;
+        return _aac_rx_init(dev);
 }