You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
448 lines
13 KiB
448 lines
13 KiB
/*
|
|
* 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;
|
|
}
|
|
|
|
|