drivers/remoteproc/ti_k3_common.c

Source file repositories/reference/linux-study-clean/drivers/remoteproc/ti_k3_common.c

File Facts

System
Linux kernel
Corpus path
drivers/remoteproc/ti_k3_common.c
Extension
.c
Size
16232 bytes
Lines
543
Domain
Driver Families
Bucket
drivers/remoteproc
Inferred role
Driver Families: exported/initcall integration point
Status
integration implementation candidate

Why This File Exists

Repeatable hardware-adapter layer. Deep compatibility for every driver is out of scope; this atlas records patterns, probe lifecycles, bus glue, IRQ/DMA usage, and links back to core abstractions.

Dependency Surface

Detected Declarations

Annotated Snippet

if (msg > rproc->max_notifyid) {
			dev_dbg(dev, "dropping unknown message 0x%x", msg);
			return;
		}
		/* msg contains the index of the triggered vring */
		if (rproc_vq_interrupt(rproc, msg) == IRQ_NONE)
			dev_dbg(dev, "no message was found in vqid %d\n", msg);
	}
}
EXPORT_SYMBOL_GPL(k3_rproc_mbox_callback);

/*
 * Kick the remote processor to notify about pending unprocessed messages.
 * The vqid usage is not used and is inconsequential, as the kick is performed
 * through a simulated GPIO (a bit in an IPC interrupt-triggering register),
 * the remote processor is expected to process both its Tx and Rx virtqueues.
 */
void k3_rproc_kick(struct rproc *rproc, int vqid)
{
	struct k3_rproc *kproc = rproc->priv;
	struct device *dev = kproc->dev;
	u32 msg = (u32)vqid;
	int ret;

	/*
	 * Send the index of the triggered virtqueue in the mailbox payload.
	 * NOTE: msg is cast to uintptr_t to prevent compiler warnings when
	 * void* is 64bit. It is safely cast back to u32 in the mailbox driver.
	 */
	ret = mbox_send_message(kproc->mbox, (void *)(uintptr_t)msg);
	if (ret < 0)
		dev_err(dev, "failed to send mailbox message, status = %d\n",
			ret);
}
EXPORT_SYMBOL_GPL(k3_rproc_kick);

/* Put the remote processor into reset */
int k3_rproc_reset(struct k3_rproc *kproc)
{
	struct device *dev = kproc->dev;
	int ret;

	if (kproc->data->uses_lreset) {
		ret = reset_control_assert(kproc->reset);
		if (ret)
			dev_err(dev, "local-reset assert failed (%pe)\n", ERR_PTR(ret));
	} else {
		ret = kproc->ti_sci->ops.dev_ops.put_device(kproc->ti_sci,
							    kproc->ti_sci_id);
		if (ret)
			dev_err(dev, "module-reset assert failed (%pe)\n", ERR_PTR(ret));
	}

	return ret;
}
EXPORT_SYMBOL_GPL(k3_rproc_reset);

/* Release the remote processor from reset */
int k3_rproc_release(struct k3_rproc *kproc)
{
	struct device *dev = kproc->dev;
	int ret;

	if (kproc->data->uses_lreset) {
		ret = reset_control_deassert(kproc->reset);
		if (ret) {
			dev_err(dev, "local-reset deassert failed, (%pe)\n", ERR_PTR(ret));
			if (kproc->ti_sci->ops.dev_ops.put_device(kproc->ti_sci,
								  kproc->ti_sci_id))
				dev_warn(dev, "module-reset assert back failed\n");
		}
	} else {
		ret = kproc->ti_sci->ops.dev_ops.get_device(kproc->ti_sci,
							    kproc->ti_sci_id);
		if (ret)
			dev_err(dev, "module-reset deassert failed (%pe)\n", ERR_PTR(ret));
	}

	return ret;
}
EXPORT_SYMBOL_GPL(k3_rproc_release);

static void k3_rproc_free_channel(void *data)
{
	struct k3_rproc *kproc = data;

	mbox_free_channel(kproc->mbox);
}

int k3_rproc_request_mbox(struct rproc *rproc)

Annotation

Implementation Notes