Commit 2a226927 authored by Nipun Gupta's avatar Nipun Gupta Committed by Greg Kroah-Hartman
Browse files

cdx: add rpmsg communication channel for CDX 



RPMsg is used as a transport communication channel. This
change introduces RPMsg driver and integrates it with the
CDX controller.

Signed-off-by: default avatarAbhijit Gangurde <abhijit.gangurde@amd.com>
Signed-off-by: default avatarNipun Gupta <nipun.gupta@amd.com>
Reviewed-by: default avatarPieter Jansen van Vuuren <pieter.jansen-van-vuuren@amd.com>
Tested-by: default avatarNikhil Agarwal <nikhil.agarwal@amd.com>
Link: https://lore.kernel.org/r/20230313132636.31850-7-nipun.gupta@amd.com


Signed-off-by: default avatarGreg Kroah-Hartman <gregkh@linuxfoundation.org>
parent 8a7923df

drivers/cdx/controller/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -9,6 +9,8 @@ if CDX_BUS 


config CDX_CONTROLLER

	tristate "CDX bus controller"

	select REMOTEPROC

	select RPMSG

	help

	  CDX controller drives the CDX bus. It interacts with

	  firmware to get the hardware devices and registers with

drivers/cdx/controller/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -6,4 +6,4 @@ 
#



obj-$(CONFIG_CDX_CONTROLLER) += cdx-controller.o

cdx-controller-objs := cdx_controller.o mcdi.o mcdi_functions.o
 
cdx-controller-objs := cdx_controller.o cdx_rpmsg.o mcdi.o mcdi_functions.o

drivers/cdx/controller/cdx_controller.c

+28 −4
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ 
#include <linux/slab.h>

#include <linux/cdx/cdx_bus.h>



#include "cdx_controller.h"

#include "../cdx.h"

#include "mcdi_functions.h"

#include "mcdi.h"
@@ -22,10 +23,8 @@ static void cdx_mcdi_request(struct cdx_mcdi *cdx, 
			     const struct cdx_dword *hdr, size_t hdr_len,

			     const struct cdx_dword *sdu, size_t sdu_len)

{

	/*

	 * This will get updated by rpmsg APIs, with RPMSG introduction

	 * in CDX controller as a transport layer.

	 */

	if (cdx_rpmsg_send(cdx, hdr, hdr_len, sdu, sdu_len))

		dev_err(&cdx->rpdev->dev, "Failed to send rpmsg data\n");

}



static const struct cdx_mcdi_ops mcdi_ops = {
@@ -33,6 +32,19 @@ static const struct cdx_mcdi_ops mcdi_ops = { 
	.mcdi_request = cdx_mcdi_request,

};



void cdx_rpmsg_post_probe(struct cdx_controller *cdx)

{

	/* Register CDX controller with CDX bus driver */

	if (cdx_register_controller(cdx))

		dev_err(cdx->dev, "Failed to register CDX controller\n");

}



void cdx_rpmsg_pre_remove(struct cdx_controller *cdx)

{

	cdx_unregister_controller(cdx);

	cdx_mcdi_wait_for_quiescence(cdx->priv, MCDI_RPC_TIMEOUT);

}



static int cdx_scan_devices(struct cdx_controller *cdx)

{

	struct cdx_mcdi *cdx_mcdi = cdx->priv;
@@ -124,8 +136,18 @@ static int xlnx_cdx_probe(struct platform_device *pdev) 
	cdx->priv = cdx_mcdi;

	cdx->ops = &cdx_ops;



	ret = cdx_setup_rpmsg(pdev);

	if (ret) {

		if (ret != -EPROBE_DEFER)

			dev_err(&pdev->dev, "Failed to register CDX RPMsg transport\n");

		goto cdx_rpmsg_fail;

	}



	dev_info(&pdev->dev, "Successfully registered CDX controller with RPMsg as transport\n");

	return 0;



cdx_rpmsg_fail:

	kfree(cdx);

cdx_alloc_fail:

	cdx_mcdi_finish(cdx_mcdi);

mcdi_init_fail:
@@ -139,6 +161,8 @@ static int xlnx_cdx_remove(struct platform_device *pdev) 
	struct cdx_controller *cdx = platform_get_drvdata(pdev);

	struct cdx_mcdi *cdx_mcdi = cdx->priv;



	cdx_destroy_rpmsg(pdev);



	kfree(cdx);



	cdx_mcdi_finish(cdx_mcdi);

drivers/cdx/controller/cdx_controller.h

0 → 100644
+30 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0

 *

 * Header file for the CDX Controller

 *

 * Copyright (C) 2022-2023, Advanced Micro Devices, Inc.

 */



#ifndef _CDX_CONTROLLER_H_

#define _CDX_CONTROLLER_H_



#include <linux/cdx/cdx_bus.h>

#include "mcdi_functions.h"



void cdx_rpmsg_post_probe(struct cdx_controller *cdx);



void cdx_rpmsg_pre_remove(struct cdx_controller *cdx);



int cdx_rpmsg_send(struct cdx_mcdi *cdx_mcdi,

		   const struct cdx_dword *hdr, size_t hdr_len,

		   const struct cdx_dword *sdu, size_t sdu_len);



void cdx_rpmsg_read_resp(struct cdx_mcdi *cdx_mcdi,

			 struct cdx_dword *outbuf, size_t offset,

			 size_t outlen);



int cdx_setup_rpmsg(struct platform_device *pdev);



void cdx_destroy_rpmsg(struct platform_device *pdev);



#endif /* _CDX_CONT_PRIV_H_ */

drivers/cdx/controller/cdx_rpmsg.c

0 → 100644
+202 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Platform driver for CDX bus.

 *

 * Copyright (C) 2022-2023, Advanced Micro Devices, Inc.

 */



#include <linux/rpmsg.h>

#include <linux/remoteproc.h>

#include <linux/of_platform.h>

#include <linux/cdx/cdx_bus.h>

#include <linux/module.h>



#include "../cdx.h"

#include "cdx_controller.h"

#include "mcdi_functions.h"

#include "mcdi.h"



static struct rpmsg_device_id cdx_rpmsg_id_table[] = {

	{ .name = "mcdi_ipc" },

	{ },

};

MODULE_DEVICE_TABLE(rpmsg, cdx_rpmsg_id_table);



int cdx_rpmsg_send(struct cdx_mcdi *cdx_mcdi,

		   const struct cdx_dword *hdr, size_t hdr_len,

		   const struct cdx_dword *sdu, size_t sdu_len)

{

	unsigned char *send_buf;

	int ret;



	send_buf = kzalloc(hdr_len + sdu_len, GFP_KERNEL);

	if (!send_buf)

		return -ENOMEM;



	memcpy(send_buf, hdr, hdr_len);

	memcpy(send_buf + hdr_len, sdu, sdu_len);



	ret = rpmsg_send(cdx_mcdi->ept, send_buf, hdr_len + sdu_len);

	kfree(send_buf);



	return ret;

}



static int cdx_attach_to_rproc(struct platform_device *pdev)

{

	struct device_node *r5_core_node;

	struct cdx_controller *cdx_c;

	struct cdx_mcdi *cdx_mcdi;

	struct device *dev;

	struct rproc *rp;

	int ret;



	dev = &pdev->dev;

	cdx_c = platform_get_drvdata(pdev);

	cdx_mcdi = cdx_c->priv;



	r5_core_node = of_parse_phandle(dev->of_node, "xlnx,rproc", 0);

	if (!r5_core_node) {

		dev_err(&pdev->dev, "xlnx,rproc: invalid phandle\n");

		return -EINVAL;

	}



	rp = rproc_get_by_phandle(r5_core_node->phandle);

	if (!rp) {

		ret = -EPROBE_DEFER;

		goto pdev_err;

	}



	/* Attach to remote processor */

	ret = rproc_boot(rp);

	if (ret) {

		dev_err(&pdev->dev, "Failed to attach to remote processor\n");

		rproc_put(rp);

		goto pdev_err;

	}



	cdx_mcdi->r5_rproc = rp;

pdev_err:

	of_node_put(r5_core_node);

	return ret;

}



static void cdx_detach_to_r5(struct platform_device *pdev)

{

	struct cdx_controller *cdx_c;

	struct cdx_mcdi *cdx_mcdi;



	cdx_c = platform_get_drvdata(pdev);

	cdx_mcdi = cdx_c->priv;



	rproc_detach(cdx_mcdi->r5_rproc);

	rproc_put(cdx_mcdi->r5_rproc);

}



static int cdx_rpmsg_cb(struct rpmsg_device *rpdev, void *data,

			int len, void *priv, u32 src)

{

	struct cdx_controller *cdx_c = dev_get_drvdata(&rpdev->dev);

	struct cdx_mcdi *cdx_mcdi = cdx_c->priv;



	if (len > MCDI_BUF_LEN)

		return -EINVAL;



	cdx_mcdi_process_cmd(cdx_mcdi, (struct cdx_dword *)data, len);



	return 0;

}



static void cdx_rpmsg_post_probe_work(struct work_struct *work)

{

	struct cdx_controller *cdx_c;

	struct cdx_mcdi *cdx_mcdi;



	cdx_mcdi = container_of(work, struct cdx_mcdi, work);

	cdx_c = dev_get_drvdata(&cdx_mcdi->rpdev->dev);

	cdx_rpmsg_post_probe(cdx_c);

}



static int cdx_rpmsg_probe(struct rpmsg_device *rpdev)

{

	struct rpmsg_channel_info chinfo = {0};

	struct cdx_controller *cdx_c;

	struct cdx_mcdi *cdx_mcdi;



	cdx_c = (struct cdx_controller *)cdx_rpmsg_id_table[0].driver_data;

	cdx_mcdi = cdx_c->priv;



	chinfo.src = RPMSG_ADDR_ANY;

	chinfo.dst = rpdev->dst;

	strscpy(chinfo.name, cdx_rpmsg_id_table[0].name,

		strlen(cdx_rpmsg_id_table[0].name));



	cdx_mcdi->ept = rpmsg_create_ept(rpdev, cdx_rpmsg_cb, NULL, chinfo);

	if (!cdx_mcdi->ept) {

		dev_err_probe(&rpdev->dev, -ENXIO,

			      "Failed to create ept for channel %s\n",

			      chinfo.name);

		return -EINVAL;

	}



	cdx_mcdi->rpdev = rpdev;

	dev_set_drvdata(&rpdev->dev, cdx_c);



	schedule_work(&cdx_mcdi->work);

	return 0;

}



static void cdx_rpmsg_remove(struct rpmsg_device *rpdev)

{

	struct cdx_controller *cdx_c = dev_get_drvdata(&rpdev->dev);

	struct cdx_mcdi *cdx_mcdi = cdx_c->priv;



	flush_work(&cdx_mcdi->work);

	cdx_rpmsg_pre_remove(cdx_c);



	rpmsg_destroy_ept(cdx_mcdi->ept);

	dev_set_drvdata(&rpdev->dev, NULL);

}



static struct rpmsg_driver cdx_rpmsg_driver = {

	.drv.name = KBUILD_MODNAME,

	.id_table = cdx_rpmsg_id_table,

	.probe = cdx_rpmsg_probe,

	.remove = cdx_rpmsg_remove,

	.callback = cdx_rpmsg_cb,

};



int cdx_setup_rpmsg(struct platform_device *pdev)

{

	struct cdx_controller *cdx_c;

	struct cdx_mcdi *cdx_mcdi;

	int ret;



	/* Attach to remote processor */

	ret = cdx_attach_to_rproc(pdev);

	if (ret)

		return ret;



	cdx_c = platform_get_drvdata(pdev);

	cdx_mcdi = cdx_c->priv;



	/* Register RPMsg driver */

	cdx_rpmsg_id_table[0].driver_data = (kernel_ulong_t)cdx_c;



	INIT_WORK(&cdx_mcdi->work, cdx_rpmsg_post_probe_work);

	ret = register_rpmsg_driver(&cdx_rpmsg_driver);

	if (ret) {

		dev_err(&pdev->dev,

			"Failed to register cdx RPMsg driver: %d\n", ret);

		cdx_detach_to_r5(pdev);

	}



	return ret;

}



void cdx_destroy_rpmsg(struct platform_device *pdev)

{

	unregister_rpmsg_driver(&cdx_rpmsg_driver);



	cdx_detach_to_r5(pdev);

}