1 files changed, 448 insertions, 0 deletions

diff --git a/drivers/media/video/saa7164/saa7164-bus.c b/drivers/media/video/saa7164/saa7164-bus.c
new file mode 100644
index 000000000000..83a04640a25a
--- /dev/null
+++ b/drivers/media/video/saa7164/saa7164-bus.c
@@ -0,0 +1,448 @@
+/*
+ *  Driver for the NXP SAA7164 PCIe bridge
+ *
+ *  Copyright (c) 2009 Steven Toth <stoth@kernellabs.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "saa7164.h"
+
+/* The message bus to/from the firmware is a ring buffer in PCI address
+ * space. Establish the defaults.
+ */
+int saa7164_bus_setup(struct saa7164_dev *dev)
+{
+        tmComResBusInfo_t *b    = &dev->bus;
+
+        mutex_init(&b->lock);
+
+        b->Type                 = TYPE_BUS_PCIe;
+        b->m_wMaxReqSize        = SAA_DEVICE_MAXREQUESTSIZE;
+
+        b->m_pdwSetRing         = (u8 *)(dev->bmmio +
+                ((u32)dev->busdesc.CommandRing));
+
+        b->m_dwSizeSetRing      = SAA_DEVICE_BUFFERBLOCKSIZE;
+
+        b->m_pdwGetRing         = (u8 *)(dev->bmmio +
+                ((u32)dev->busdesc.ResponseRing));
+
+        b->m_dwSizeGetRing      = SAA_DEVICE_BUFFERBLOCKSIZE;
+
+        b->m_pdwSetWritePos     = (u32 *)((u8 *)(dev->bmmio +
+                ((u32)dev->intfdesc.BARLocation) + (2 * sizeof(u64))));
+
+        b->m_pdwSetReadPos      = (u32 *)((u8 *)b->m_pdwSetWritePos +
+                1 * sizeof(u32));
+
+        b->m_pdwGetWritePos     = (u32 *)((u8 *)b->m_pdwSetWritePos +
+                2 * sizeof(u32));
+
+        b->m_pdwGetReadPos      = (u32 *)((u8 *)b->m_pdwSetWritePos +
+                3 * sizeof(u32));
+
+        return 0;
+}
+
+void saa7164_bus_dump(struct saa7164_dev *dev)
+{
+        tmComResBusInfo_t *b = &dev->bus;
+
+        dprintk(DBGLVL_BUS, "Dumping the bus structure:\n");
+        dprintk(DBGLVL_BUS, " .type             = %d\n", b->Type);
+        dprintk(DBGLVL_BUS, " .dev->bmmio       = 0x%p\n", dev->bmmio);
+        dprintk(DBGLVL_BUS, " .m_wMaxReqSize    = 0x%x\n", b->m_wMaxReqSize);
+        dprintk(DBGLVL_BUS, " .m_pdwSetRing     = 0x%p\n", b->m_pdwSetRing);
+        dprintk(DBGLVL_BUS, " .m_dwSizeSetRing  = 0x%x\n", b->m_dwSizeSetRing);
+        dprintk(DBGLVL_BUS, " .m_pdwGetRing     = 0x%p\n", b->m_pdwGetRing);
+        dprintk(DBGLVL_BUS, " .m_dwSizeGetRing  = 0x%x\n", b->m_dwSizeGetRing);
+
+        dprintk(DBGLVL_BUS, " .m_pdwSetWritePos = 0x%p (0x%08x)\n",
+                b->m_pdwSetWritePos, *b->m_pdwSetWritePos);
+
+        dprintk(DBGLVL_BUS, " .m_pdwSetReadPos  = 0x%p (0x%08x)\n",
+                b->m_pdwSetReadPos, *b->m_pdwSetReadPos);
+
+        dprintk(DBGLVL_BUS, " .m_pdwGetWritePos = 0x%p (0x%08x)\n",
+                b->m_pdwGetWritePos, *b->m_pdwGetWritePos);
+
+        dprintk(DBGLVL_BUS, " .m_pdwGetReadPos  = 0x%p (0x%08x)\n",
+                b->m_pdwGetReadPos, *b->m_pdwGetReadPos);
+}
+
+void saa7164_bus_dumpmsg(struct saa7164_dev *dev, tmComResInfo_t* m, void *buf)
+{
+        dprintk(DBGLVL_BUS, "Dumping msg structure:\n");
+        dprintk(DBGLVL_BUS, " .id               = %d\n",   m->id);
+        dprintk(DBGLVL_BUS, " .flags            = 0x%x\n", m->flags);
+        dprintk(DBGLVL_BUS, " .size             = 0x%x\n", m->size);
+        dprintk(DBGLVL_BUS, " .command          = 0x%x\n", m->command);
+        dprintk(DBGLVL_BUS, " .controlselector  = 0x%x\n", m->controlselector);
+        dprintk(DBGLVL_BUS, " .seqno            = %d\n",   m->seqno);
+        if (buf)
+                dprintk(DBGLVL_BUS, " .buffer (ignored)\n");
+}
+
+/*
+ * Places a command or a response on the bus. The implementation does not
+ * know if it is a command or a response it just places the data on the
+ * bus depending on the bus information given in the tmComResBusInfo_t
+ * structure. If the command or response does not fit into the bus ring
+ * buffer it will be refused.
+ *
+ * Return Value:
+ *  SAA_OK     The function executed successfully.
+ *  < 0        One or more members are not initialized.
+ */
+int saa7164_bus_set(struct saa7164_dev *dev, tmComResInfo_t* msg, void *buf)
+{
+        tmComResBusInfo_t *bus = &dev->bus;
+        u32 bytes_to_write, read_distance, timeout, curr_srp, curr_swp;
+        u32 new_swp, space_rem;
+        int ret = SAA_ERR_BAD_PARAMETER;
+
+        if (!msg) {
+                printk(KERN_ERR "%s() !msg\n", __func__);
+                return SAA_ERR_BAD_PARAMETER;
+        }
+
+        dprintk(DBGLVL_BUS, "%s()\n", __func__);
+
+        msg->size = cpu_to_le16(msg->size);
+        msg->command = cpu_to_le16(msg->command);
+        msg->controlselector = cpu_to_le16(msg->controlselector);
+
+        if (msg->size > dev->bus.m_wMaxReqSize) {
+                printk(KERN_ERR "%s() Exceeded dev->bus.m_wMaxReqSize\n",
+                        __func__);
+                return SAA_ERR_BAD_PARAMETER;
+        }
+
+        if ((msg->size > 0) && (buf == 0)) {
+                printk(KERN_ERR "%s() Missing message buffer\n", __func__);
+                return SAA_ERR_BAD_PARAMETER;
+        }
+
+        /* Lock the bus from any other access */
+        mutex_lock(&bus->lock);
+
+        bytes_to_write = sizeof(*msg) + msg->size;
+        read_distance = 0;
+        timeout = SAA_BUS_TIMEOUT;
+        curr_srp = le32_to_cpu(*bus->m_pdwSetReadPos);
+        curr_swp = le32_to_cpu(*bus->m_pdwSetWritePos);
+
+        /* Deal with ring wrapping issues */
+        if (curr_srp > curr_swp)
+                /* The ring has not wrapped yet */
+                read_distance = curr_srp - curr_swp;
+        else
+                /* Deal with the wrapped ring */
+                read_distance = (curr_srp + bus->m_dwSizeSetRing) - curr_swp;
+
+        dprintk(DBGLVL_BUS, "%s() bytes_to_write = %d\n", __func__,
+                bytes_to_write);
+
+        dprintk(DBGLVL_BUS, "%s() read_distance = %d\n", __func__,
+                read_distance);
+
+        dprintk(DBGLVL_BUS, "%s() curr_srp = %x\n", __func__, curr_srp);
+        dprintk(DBGLVL_BUS, "%s() curr_swp = %x\n", __func__, curr_swp);
+
+        /* Process the msg and write the content onto the bus */
+        while (bytes_to_write >= read_distance) {
+
+                if (timeout-- == 0) {
+                        printk(KERN_ERR "%s() bus timeout\n", __func__);
+                        ret = SAA_ERR_NO_RESOURCES;
+                        goto out;
+                }
+
+                /* TODO: Review this delay, efficient? */
+                /* Wait, allowing the hardware fetch time */
+                mdelay(1);
+
+                /* Check the space usage again */
+                curr_srp = le32_to_cpu(*bus->m_pdwSetReadPos);
+
+                /* Deal with ring wrapping issues */
+                if (curr_srp > curr_swp)
+                        /* Read didn't wrap around the buffer */
+                        read_distance = curr_srp - curr_swp;
+                else
+                        /* Deal with the wrapped ring */
+                        read_distance = (curr_srp + bus->m_dwSizeSetRing) -
+                                curr_swp;
+
+        }
+
+        /* Calculate the new write position */
+        new_swp = curr_swp + bytes_to_write;
+
+        dprintk(DBGLVL_BUS, "%s() new_swp = %x\n", __func__, new_swp);
+        dprintk(DBGLVL_BUS, "%s() bus->m_dwSizeSetRing = %x\n", __func__,
+                bus->m_dwSizeSetRing);
+
+        /* Mental Note: line 462 tmmhComResBusPCIe.cpp */
+
+        /* Check if we're going to wrap again */
+        if (new_swp > bus->m_dwSizeSetRing) {
+
+                /* Ring wraps */
+                new_swp -= bus->m_dwSizeSetRing;
+
+                space_rem = bus->m_dwSizeSetRing - curr_swp;
+
+                dprintk(DBGLVL_BUS, "%s() space_rem = %x\n", __func__,
+                        space_rem);
+
+                dprintk(DBGLVL_BUS, "%s() sizeof(*msg) = %d\n", __func__,
+                        (u32)sizeof(*msg));
+
+                if (space_rem < sizeof(*msg)) {
+                        dprintk(DBGLVL_BUS, "%s() tr4\n", __func__);
+
+                        /* Split the msg into pieces as the ring wraps */
+                        memcpy(bus->m_pdwSetRing + curr_swp, msg, space_rem);
+                        memcpy(bus->m_pdwSetRing, (u8 *)msg + space_rem,
+                                sizeof(*msg) - space_rem);
+
+                        memcpy(bus->m_pdwSetRing + sizeof(*msg) - space_rem,
+                                buf, msg->size);
+
+                } else if (space_rem == sizeof(*msg)) {
+                        dprintk(DBGLVL_BUS, "%s() tr5\n", __func__);
+
+                        /* Additional data at the beginning of the ring */
+                        memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
+                        memcpy(bus->m_pdwSetRing, buf, msg->size);
+
+                } else {
+                        /* Additional data wraps around the ring */
+                        memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
+                        if (msg->size > 0) {
+                                memcpy(bus->m_pdwSetRing + curr_swp +
+                                        sizeof(*msg), buf, space_rem -
+                                        sizeof(*msg));
+                                memcpy(bus->m_pdwSetRing, (u8 *)buf +
+                                        space_rem - sizeof(*msg),
+                                        bytes_to_write - space_rem);
+                        }
+
+                }
+
+        } /* (new_swp > bus->m_dwSizeSetRing) */
+        else {
+                dprintk(DBGLVL_BUS, "%s() tr6\n", __func__);
+
+                /* The ring buffer doesn't wrap, two simple copies */
+                memcpy(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
+                memcpy(bus->m_pdwSetRing + curr_swp + sizeof(*msg), buf,
+                        msg->size);
+        }
+
+        dprintk(DBGLVL_BUS, "%s() new_swp = %x\n", __func__, new_swp);
+
+        /* TODO: Convert all of the direct PCI writes into
+         * saa7164_writel/b calls for consistency.
+         */
+
+        /* Update the bus write position */
+        *bus->m_pdwSetWritePos = cpu_to_le32(new_swp);
+        ret = SAA_OK;
+
+out:
+        mutex_unlock(&bus->lock);
+        return ret;
+}
+
+/*
+ * Receive a command or a response from the bus. The implementation does not
+ * know if it is a command or a response it simply dequeues the data,
+ * depending on the bus information given in the tmComResBusInfo_t structure.
+ *
+ * Return Value:
+ *  0          The function executed successfully.
+ *  < 0        One or more members are not initialized.
+ */
+int saa7164_bus_get(struct saa7164_dev *dev, tmComResInfo_t* msg, void *buf,
+        int peekonly)
+{
+        tmComResBusInfo_t *bus = &dev->bus;
+        u32 bytes_to_read, write_distance, curr_grp, curr_gwp,
+                new_grp, buf_size, space_rem;
+        tmComResInfo_t msg_tmp;
+        int ret = SAA_ERR_BAD_PARAMETER;
+
+        if (msg == 0)
+                return ret;
+
+        if (msg->size > dev->bus.m_wMaxReqSize) {
+                printk(KERN_ERR "%s() Exceeded dev->bus.m_wMaxReqSize\n",
+                        __func__);
+                return ret;
+        }
+
+        if ((peekonly == 0) && (msg->size > 0) && (buf == 0)) {
+                printk(KERN_ERR
+                        "%s() Missing msg buf, size should be %d bytes\n",
+                        __func__, msg->size);
+                return ret;
+        }
+
+        mutex_lock(&bus->lock);
+
+        /* Peek the bus to see if a msg exists, if it's not what we're expecting
+         * then return cleanly else read the message from the bus.
+         */
+        curr_gwp = le32_to_cpu(*bus->m_pdwGetWritePos);
+        curr_grp = le32_to_cpu(*bus->m_pdwGetReadPos);
+
+        if (curr_gwp == curr_grp) {
+                dprintk(DBGLVL_BUS, "%s() No message on the bus\n", __func__);
+                ret = SAA_ERR_EMPTY;
+                goto out;
+        }
+
+        bytes_to_read = sizeof(*msg);
+
+        /* Calculate write distance to current read position */
+        write_distance = 0;
+        if (curr_gwp >= curr_grp)
+                /* Write doesn't wrap around the ring */
+                write_distance = curr_gwp - curr_grp;
+        else
+                /* Write wraps around the ring */
+                write_distance = curr_gwp + bus->m_dwSizeGetRing - curr_grp;
+
+        if (bytes_to_read > write_distance) {
+                printk(KERN_ERR "%s() No message/response found\n", __func__);
+                ret = SAA_ERR_INVALID_COMMAND;
+                goto out;
+        }
+
+        /* Calculate the new read position */
+        new_grp = curr_grp + bytes_to_read;
+        if (new_grp > bus->m_dwSizeGetRing) {
+
+                /* Ring wraps */
+                new_grp -= bus->m_dwSizeGetRing;
+                space_rem = bus->m_dwSizeGetRing - curr_grp;
+
+                memcpy(&msg_tmp, bus->m_pdwGetRing + curr_grp, space_rem);
+                memcpy((u8 *)&msg_tmp + space_rem, bus->m_pdwGetRing,
+                        bytes_to_read - space_rem);
+
+        } else {
+                /* No wrapping */
+                memcpy(&msg_tmp, bus->m_pdwGetRing + curr_grp, bytes_to_read);
+        }
+
+        /* No need to update the read positions, because this was a peek */
+        /* If the caller specifically want to peek, return */
+        if (peekonly) {
+                memcpy(msg, &msg_tmp, sizeof(*msg));
+                goto peekout;
+        }
+
+        /* Check if the command/response matches what is expected */
+        if ((msg_tmp.id != msg->id) || (msg_tmp.command != msg->command) ||
+                (msg_tmp.controlselector != msg->controlselector) ||
+                (msg_tmp.seqno != msg->seqno) || (msg_tmp.size != msg->size)) {
+
+                printk(KERN_ERR "%s() Unexpected msg miss-match\n", __func__);
+                saa7164_bus_dumpmsg(dev, msg, buf);
+                saa7164_bus_dumpmsg(dev, &msg_tmp, 0);
+                ret = SAA_ERR_INVALID_COMMAND;
+                goto out;
+        }
+
+        /* Get the actual command and response from the bus */
+        buf_size = msg->size;
+
+        bytes_to_read = sizeof(*msg) + msg->size;
+        /* Calculate write distance to current read position */
+        write_distance = 0;
+        if (curr_gwp >= curr_grp)
+                /* Write doesn't wrap around the ring */
+                write_distance = curr_gwp - curr_grp;
+        else
+                /* Write wraps around the ring */
+                write_distance = curr_gwp + bus->m_dwSizeGetRing - curr_grp;
+
+        if (bytes_to_read > write_distance) {
+                printk(KERN_ERR "%s() Invalid bus state, missing msg "
+                        "or mangled ring, faulty H/W / bad code?\n", __func__);
+                ret = SAA_ERR_INVALID_COMMAND;
+                goto out;
+        }
+
+        /* Calculate the new read position */
+        new_grp = curr_grp + bytes_to_read;
+        if (new_grp > bus->m_dwSizeGetRing) {
+
+                /* Ring wraps */
+                new_grp -= bus->m_dwSizeGetRing;
+                space_rem = bus->m_dwSizeGetRing - curr_grp;
+
+                if (space_rem < sizeof(*msg)) {
+                        /* msg wraps around the ring */
+                        memcpy(msg, bus->m_pdwGetRing + curr_grp, space_rem);
+                        memcpy((u8 *)msg + space_rem, bus->m_pdwGetRing,
+                                sizeof(*msg) - space_rem);
+                        if (buf)
+                                memcpy(buf, bus->m_pdwGetRing + sizeof(*msg) -
+                                        space_rem, buf_size);
+
+                } else if (space_rem == sizeof(*msg)) {
+                        memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
+                        if (buf)
+                                memcpy(buf, bus->m_pdwGetRing, buf_size);
+                } else {
+                        /* Additional data wraps around the ring */
+                        memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
+                        if (buf) {
+                                memcpy(buf, bus->m_pdwGetRing + curr_grp +
+                                        sizeof(*msg), space_rem - sizeof(*msg));
+                                memcpy(buf + space_rem - sizeof(*msg),
+                                        bus->m_pdwGetRing, bytes_to_read -
+                                        space_rem);
+                        }
+
+                }
+
+        } else {
+                /* No wrapping */
+                memcpy(msg, bus->m_pdwGetRing + curr_grp, sizeof(*msg));
+                if (buf)
+                        memcpy(buf, bus->m_pdwGetRing + curr_grp + sizeof(*msg),
+                                buf_size);
+        }
+
+        /* Update the read positions, adjusting the ring */
+        *bus->m_pdwGetReadPos = cpu_to_le32(new_grp);
+
+peekout:
+        msg->size = le16_to_cpu(msg->size);
+        msg->command = le16_to_cpu(msg->command);
+        msg->controlselector = le16_to_cpu(msg->controlselector);
+        ret = SAA_OK;
+out:
+        mutex_unlock(&bus->lock);
+        return ret;
+}
+