Quelle  saa7164-bus.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 *  Driver for the NXP SAA7164 PCIe bridge
 *
 *  Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
 */

#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)
{
 struct tmComResBusInfo *b = &dev->bus;

 mutex_init(&b->lock);

 b->Type   = TYPE_BUS_PCIe;
 b->m_wMaxReqSize = SAA_DEVICE_MAXREQUESTSIZE;

 b->m_pdwSetRing  = (u8 __iomem *)(dev->bmmio +
  ((u32)dev->busdesc.CommandRing));

 b->m_dwSizeSetRing = SAA_DEVICE_BUFFERBLOCKSIZE;

 b->m_pdwGetRing  = (u8 __iomem *)(dev->bmmio +
  ((u32)dev->busdesc.ResponseRing));

 b->m_dwSizeGetRing = SAA_DEVICE_BUFFERBLOCKSIZE;

 b->m_dwSetWritePos = ((u32)dev->intfdesc.BARLocation) +
  (2 * sizeof(u64));
 b->m_dwSetReadPos = b->m_dwSetWritePos + (1 * sizeof(u32));

 b->m_dwGetWritePos = b->m_dwSetWritePos + (2 * sizeof(u32));
 b->m_dwGetReadPos = b->m_dwSetWritePos + (3 * sizeof(u32));

 return 0;
}

void saa7164_bus_dump(struct saa7164_dev *dev)
{
 struct tmComResBusInfo *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_dwSetReadPos   = 0x%x (0x%08x)\n",
  b->m_dwSetReadPos, saa7164_readl(b->m_dwSetReadPos));

 dprintk(DBGLVL_BUS, " .m_dwSetWritePos  = 0x%x (0x%08x)\n",
  b->m_dwSetWritePos, saa7164_readl(b->m_dwSetWritePos));

 dprintk(DBGLVL_BUS, " .m_dwGetReadPos   = 0x%x (0x%08x)\n",
  b->m_dwGetReadPos, saa7164_readl(b->m_dwGetReadPos));

 dprintk(DBGLVL_BUS, " .m_dwGetWritePos  = 0x%x (0x%08x)\n",
  b->m_dwGetWritePos, saa7164_readl(b->m_dwGetWritePos));

}

/* Intensionally throw a BUG() if the state of the message bus looks corrupt */
static void saa7164_bus_verify(struct saa7164_dev *dev)
{
 struct tmComResBusInfo *b = &dev->bus;
 int bug = 0;

 if (saa7164_readl(b->m_dwSetReadPos) > b->m_dwSizeSetRing)
  bug++;

 if (saa7164_readl(b->m_dwSetWritePos) > b->m_dwSizeSetRing)
  bug++;

 if (saa7164_readl(b->m_dwGetReadPos) > b->m_dwSizeGetRing)
  bug++;

 if (saa7164_readl(b->m_dwGetWritePos) > b->m_dwSizeGetRing)
  bug++;

 if (bug) {
  saa_debug = 0xffff; /* Ensure we get the bus dump */
  saa7164_bus_dump(dev);
  saa_debug = 1024; /* Ensure we get the bus dump */
  BUG();
 }
}

static void saa7164_bus_dumpmsg(struct saa7164_dev *dev, struct tmComResInfo *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 struct tmComResBusInfo
 * 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, struct tmComResInfo* msg,
 void *buf)
{
 struct tmComResBusInfo *bus = &dev->bus;
 u32 bytes_to_write, free_write_space, timeout, curr_srp, curr_swp;
 u32 new_swp, space_rem;
 int ret = SAA_ERR_BAD_PARAMETER;
 u16 size;

 if (!msg) {
  printk(KERN_ERR "%s() !msg\n", __func__);
  return SAA_ERR_BAD_PARAMETER;
 }

 dprintk(DBGLVL_BUS, "%s()\n", __func__);

 saa7164_bus_verify(dev);

 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 == NULL)) {
  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;
 free_write_space = 0;
 timeout = SAA_BUS_TIMEOUT;
 curr_srp = saa7164_readl(bus->m_dwSetReadPos);
 curr_swp = saa7164_readl(bus->m_dwSetWritePos);

 /* Deal with ring wrapping issues */
 if (curr_srp > curr_swp)
  /* Deal with the wrapped ring */
  free_write_space = curr_srp - curr_swp;
 else
  /* The ring has not wrapped yet */
  free_write_space = (curr_srp + bus->m_dwSizeSetRing) - curr_swp;

 dprintk(DBGLVL_BUS, "%s() bytes_to_write = %d\n", __func__,
  bytes_to_write);

 dprintk(DBGLVL_BUS, "%s() free_write_space = %d\n", __func__,
  free_write_space);

 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 >= free_write_space) {

  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 = saa7164_readl(bus->m_dwSetReadPos);

  /* Deal with ring wrapping issues */
  if (curr_srp > curr_swp)
   /* Deal with the wrapped ring */
   free_write_space = curr_srp - curr_swp;
  else
   /* Read didn't wrap around the buffer */
   free_write_space = (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);

 /*
  * Make a copy of msg->size before it is converted to le16 since it is
  * used in the code below.
 */
 size = msg->size;
 /* Convert to le16/le32 */
 msg->size = (__force u16)cpu_to_le16(msg->size);
 msg->command = (__force u32)cpu_to_le32(msg->command);
 msg->controlselector = (__force u16)cpu_to_le16(msg->controlselector);

 /* 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_toio(bus->m_pdwSetRing + curr_swp, msg, space_rem);
   memcpy_toio(bus->m_pdwSetRing, (u8 *)msg + space_rem,
    sizeof(*msg) - space_rem);

   memcpy_toio(bus->m_pdwSetRing + sizeof(*msg) - space_rem,
    buf, size);

  } else if (space_rem == sizeof(*msg)) {
   dprintk(DBGLVL_BUS, "%s() tr5\n", __func__);

   /* Additional data at the beginning of the ring */
   memcpy_toio(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
   memcpy_toio(bus->m_pdwSetRing, buf, size);

  } else {
   /* Additional data wraps around the ring */
   memcpy_toio(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
   if (size > 0) {
    memcpy_toio(bus->m_pdwSetRing + curr_swp +
     sizeof(*msg), buf, space_rem -
     sizeof(*msg));
    memcpy_toio(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_toio(bus->m_pdwSetRing + curr_swp, msg, sizeof(*msg));
  memcpy_toio(bus->m_pdwSetRing + curr_swp + sizeof(*msg), buf,
   size);
 }

 dprintk(DBGLVL_BUS, "%s() new_swp = %x\n", __func__, new_swp);

 /* Update the bus write position */
 saa7164_writel(bus->m_dwSetWritePos, new_swp);

 /* Convert back to cpu after writing the msg to the ringbuffer. */
 msg->size = le16_to_cpu((__force __le16)msg->size);
 msg->command = le32_to_cpu((__force __le32)msg->command);
 msg->controlselector = le16_to_cpu((__force __le16)msg->controlselector);
 ret = SAA_OK;

out:
 saa7164_bus_dump(dev);
 mutex_unlock(&bus->lock);
 saa7164_bus_verify(dev);
 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 struct tmComResBusInfo
 * structure.
 *
 * Return Value:
 *  0          The function executed successfully.
 *  < 0        One or more members are not initialized.
 */
int saa7164_bus_get(struct saa7164_dev *dev, struct tmComResInfo* msg,
 void *buf, int peekonly)
{
 struct tmComResBusInfo *bus = &dev->bus;
 u32 bytes_to_read, write_distance, curr_grp, curr_gwp,
  new_grp, buf_size, space_rem;
 struct tmComResInfo msg_tmp;
 int ret = SAA_ERR_BAD_PARAMETER;

 saa7164_bus_verify(dev);

 if (msg == NULL)
  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 == NULL)) {
  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 = saa7164_readl(bus->m_dwGetWritePos);
 curr_grp = saa7164_readl(bus->m_dwGetReadPos);

 if (curr_gwp == curr_grp) {
  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_fromio(&msg_tmp, bus->m_pdwGetRing + curr_grp, space_rem);
  memcpy_fromio((u8 *)&msg_tmp + space_rem, bus->m_pdwGetRing,
   bytes_to_read - space_rem);

 } else {
  /* No wrapping */
  memcpy_fromio(&msg_tmp, bus->m_pdwGetRing + curr_grp, bytes_to_read);
 }
 /* Convert from little endian to CPU */
 msg_tmp.size = le16_to_cpu((__force __le16)msg_tmp.size);
 msg_tmp.command = le32_to_cpu((__force __le32)msg_tmp.command);
 msg_tmp.controlselector = le16_to_cpu((__force __le16)msg_tmp.controlselector);
 memcpy(msg, &msg_tmp, sizeof(*msg));

 /* No need to update the read positions, because this was a peek */
 /* If the caller specifically want to peek, return */
 if (peekonly) {
  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, NULL);
  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)) {
   if (buf)
    memcpy_fromio(buf, bus->m_pdwGetRing + sizeof(*msg) -
     space_rem, buf_size);

  } else if (space_rem == sizeof(*msg)) {
   if (buf)
    memcpy_fromio(buf, bus->m_pdwGetRing, buf_size);
  } else {
   /* Additional data wraps around the ring */
   if (buf) {
    memcpy_fromio(buf, bus->m_pdwGetRing + curr_grp +
     sizeof(*msg), space_rem - sizeof(*msg));
    memcpy_fromio(buf + space_rem - sizeof(*msg),
     bus->m_pdwGetRing, bytes_to_read -
     space_rem);
   }

  }

 } else {
  /* No wrapping */
  if (buf)
   memcpy_fromio(buf, bus->m_pdwGetRing + curr_grp + sizeof(*msg),
    buf_size);
 }

 /* Update the read positions, adjusting the ring */
 saa7164_writel(bus->m_dwGetReadPos, new_grp);

peekout:
 ret = SAA_OK;
out:
 mutex_unlock(&bus->lock);
 saa7164_bus_verify(dev);
 return ret;
}