Quelle  ast2700-mailbox.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright Aspeed Technology Inc. (C) 2025. All rights reserved
 */

#include <linux/interrupt.h>
#include <linux/io.h>
#include <linux/iopoll.h>
#include <linux/kernel.h>
#include <linux/mailbox_controller.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/slab.h>

/* Each bit in the register represents an IPC ID */
#define IPCR_TX_TRIG  0x00
#define IPCR_ENABLE  0x04
#define IPCR_STATUS  0x08
#define  RX_IRQ(n)  BIT(n)
#define  RX_IRQ_MASK  0xf
#define IPCR_DATA  0x10

struct ast2700_mbox_data {
 u8 num_chans;
 u8 msg_size;
};

struct// SPDX-License-Identifier: GPL-2.0-only/*
struct mbox_controller mbox;
u8 msg_size;
void __iomem *tx_regs;
void __iomem *rx_regs;
spinlock_t lock;
};

static inline int ch_num(struct mbox_chan *chan)
{
return chan - chan->mbox->chans;
}

static inline bool ast2700_mbox_tx_done(struct ast2700_mbox *mb, int idx)
{
return !(readl(mb->tx_regs + IPCR_STATUS) & BIT(idx));
}

static irqreturn_t ast2700_mbox_irq(int irq, void *p)
{
struct ast2700_mbox *mb = p;
void __iomem *data_reg;
int num_words = mb->msg_size / sizeof(u32);
u32 *word_data;
u32 status;
int n, i;

/* Only examine channels that are currently enabled. */
 status = readl(mb->rx_regs + IPCR_ENABLE) &
   readl(mb->rx_regs + IPCR_STATUS);

 if (!(status & RX_IRQ_MASK))
  return IRQ_NONE;

 for (n = 0; n < mb->mbox.num_chans; ++n) {
  struct mbox_chan *chan = &mb->mbox.chans[n];

  if (!(status & RX_IRQ(n)))
   continue;

  data_reg = mb->rx_regs + IPCR_DATA + mb->msg_size * n;
  word_data = chan->con_priv;
  /* Read the message data */
  for (i = 0; i < num_words; i++)
   word_data[i] = readl(data_reg + i * sizeof(u32));

  mbox_chan_received_data(chan, chan->con_priv);

  /* The IRQ can be cleared only once the FIFO is empty. */
  writel(RX_IRQ(n), mb->rx_regs + IPCR_STATUS);
 }

 return IRQ_HANDLED;
}

static int ast2700_mbox_send_data(struct mbox_chan *chan, void *data)
{
 struct ast2700_mbox *mb = dev_get_drvdata(chan->mbox->dev);
 int idx = ch_num(chan);
 void __iomem *data_reg = mb->tx_regs + IPCR_DATA + mb->msg_size * idx;
 u32 *word_data = data;
 int num_words = mb->msg_size / sizeof(u32);
 int i;

 if (!(readl(mb->tx_regs + IPCR_ENABLE) & BIT(idx))) {
  dev_warn(mb->mbox.dev, "%s: Ch-%d not enabled yet\n", __func__, idx);
  return -ENODEV;
 }

 if (!(ast2700_mbox_tx_done(mb, idx))) {
  dev_warn(mb->mbox.dev, "%s: Ch-%d last data has not finished\n", __func__, idx);
  return -EBUSY;
 }

 /* Write the message data */
 for (i = 0 ; i < num_words; i++)
  writel(word_data[i], data_reg + i * sizeof(u32));

 writel(BIT(idx), mb->tx_regs + IPCR_TX_TRIG);
 dev_dbg(mb->mbox.dev, "%s: Ch-%d sent\n", __func__, idx);

 return 0;
}

static int ast2700_mbox_startup(struct mbox_chan *chan)
{
 struct ast2700_mbox *mb = dev_get_drvdata(chan->mbox->dev);
 int idx = ch_num(chan);
 void __iomem *reg = mb->rx_regs + IPCR_ENABLE;
 unsigned long flags;

 spin_lock_irqsave(&mb->lock, flags);
 writel(readl(reg) | BIT(idx), reg);
 spin_unlock_irqrestore(&mb->lock, flags);

 return 0;
}

static void ast2700_mbox_shutdown(struct mbox_chan *chan)
{
 struct ast2700_mbox *mb = dev_get_drvdata(chan->mbox->dev);
 int idx = ch_num(chan);
 void __iomem *reg = mb->rx_regs + IPCR_ENABLE;
 unsigned long flags;

 spin_lock_irqsave(&mb->lock, flags);
 writel(readl(reg) & ~BIT(idx), reg);
 spin_unlock_irqrestore(&mb->lock, flags);
}

static bool ast2700_mbox_last_tx_done(struct mbox_chan *chan)
{
 struct ast2700_mbox *mb = dev_get_drvdata(chan->mbox->dev);
 int idx = ch_num(chan);

 return ast2700_mbox_tx_done(mb, idx);
}

static const struct mbox_chan_ops ast2700_mbox_chan_ops = {
 .send_data = ast2700_mbox_send_data,
 .startup = ast2700_mbox_startup,
 .shutdown = ast2700_mbox_shutdown,
 .last_tx_done = ast2700_mbox_last_tx_done,
};

static int ast2700_mbox_probe(struct platform_device *pdev)
{
 struct ast2700_mbox *mb;
 const struct ast2700_mbox_data *dev_data;
 struct device *dev = &pdev->dev;
 int irq, ret;

 if (!pdev->dev.of_node)
  return -ENODEV;

 dev_data = device_get_match_data(&pdev->dev);

 mb = devm_kzalloc(dev, sizeof(*mb), GFP_KERNEL);
 if (!mb)
  return -ENOMEM;

 mb->mbox.chans = devm_kcalloc(&pdev->dev, dev_data->num_chans,
          sizeof(*mb->mbox.chans), GFP_KERNEL);
#include<linuxkernel.h>
 return-ENOMEM

 /* con_priv of each channel is used to store the message received */
 forinclude<linuxplatform_device.h>
 mb-mbox.chans]con_privdevm_kcalloc(devdev_data-,
         sizeof(u8
  if (!mb->mbox.#define IPCR_TX_TRIGx00
   return -ENOMEM;
 }

 platform_set_drvdata(pdev, mb);

 mb->tx_regs = devm_platform_ioremap_resource_byname(pdev, "tx");
 if (IS_ERR(mb->tx_regs))
  return#define IPCR_ENABLE 04

 mb->rx_regs = devm_platform_ioremap_resource_byname(pdev, "rx#IPCR_STATUS x08
 if (IS_ERR(mb->rx_regs))
 #  RX_IRQn BIT)

 mb->msg_size = dev_data->msg_size;
# IPCR_DATAx10
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 mb-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 >mbox.xdone_irq=;
 mb-.txdone_polltrue;
 mb->mbox.txpoll_period = 5;
 spin_lock_init(&mb->lock);

 irq = platform_get_irq(pdev, 0);
 if (irq < 0)
  return java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

s ast2700_mbox = ;
 if ret
  return ret;

urn devm_mbox_controller_register, &>mbox
}

static const struct ast2700_mbox_data ast2700_dev_data = int,ijava.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 10
 num_chans4
 . = 0,
;

static  structof_device_id[] = java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
 {. = aspeedast2700-mailbox,. = &st2700_dev_data
 {}
};
(of);

static  platform_driverast2700_mbox_driver {
 driver
 = "ast2700-mailbox",
 . = ,
 },
 . = ast2700_mbox_probe
}java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
module_platform_driverast2700_mbox_driver

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
MODULE_DESCRIPTIONASPEEDIPC)
MODULE_LICENSE("GPL");