Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * CDX host controller driver for AMD versal-net platform.
4 *
5 * Copyright (C) 2022-2023, Advanced Micro Devices, Inc.
6 */
7
8#include <linux/of_platform.h>
9#include <linux/slab.h>
10#include <linux/cdx/cdx_bus.h>
11
12#include "cdx_controller.h"
13#include "../cdx.h"
14#include "mcdi_functions.h"
15#include "mcdi.h"
16
17static unsigned int cdx_mcdi_rpc_timeout(struct cdx_mcdi *cdx, unsigned int cmd)
18{
19 return MCDI_RPC_TIMEOUT;
20}
21
22static void cdx_mcdi_request(struct cdx_mcdi *cdx,
23 const struct cdx_dword *hdr, size_t hdr_len,
24 const struct cdx_dword *sdu, size_t sdu_len)
25{
26 if (cdx_rpmsg_send(cdx, hdr, hdr_len, sdu, sdu_len))
27 dev_err(&cdx->rpdev->dev, "Failed to send rpmsg data\n");
28}
29
30static const struct cdx_mcdi_ops mcdi_ops = {
31 .mcdi_rpc_timeout = cdx_mcdi_rpc_timeout,
32 .mcdi_request = cdx_mcdi_request,
33};
34
35void cdx_rpmsg_post_probe(struct cdx_controller *cdx)
36{
37 /* Register CDX controller with CDX bus driver */
38 if (cdx_register_controller(cdx))
39 dev_err(cdx->dev, "Failed to register CDX controller\n");
40}
41
42void cdx_rpmsg_pre_remove(struct cdx_controller *cdx)
43{
44 cdx_unregister_controller(cdx);
45 cdx_mcdi_wait_for_quiescence(cdx->priv, MCDI_RPC_TIMEOUT);
46}
47
48static int cdx_configure_device(struct cdx_controller *cdx,
49 u8 bus_num, u8 dev_num,
50 struct cdx_device_config *dev_config)
51{
52 int ret = 0;
53
54 switch (dev_config->type) {
55 case CDX_DEV_RESET_CONF:
56 ret = cdx_mcdi_reset_device(cdx->priv, bus_num, dev_num);
57 break;
58 default:
59 ret = -EINVAL;
60 }
61
62 return ret;
63}
64
65static int cdx_scan_devices(struct cdx_controller *cdx)
66{
67 struct cdx_mcdi *cdx_mcdi = cdx->priv;
68 u8 bus_num, dev_num, num_cdx_bus;
69 int ret;
70
71 /* MCDI FW Read: Fetch the number of CDX buses on this controller */
72 ret = cdx_mcdi_get_num_buses(cdx_mcdi);
73 if (ret < 0) {
74 dev_err(cdx->dev,
75 "Get number of CDX buses failed: %d\n", ret);
76 return ret;
77 }
78 num_cdx_bus = (u8)ret;
79
80 for (bus_num = 0; bus_num < num_cdx_bus; bus_num++) {
81 u8 num_cdx_dev;
82
83 /* MCDI FW Read: Fetch the number of devices present */
84 ret = cdx_mcdi_get_num_devs(cdx_mcdi, bus_num);
85 if (ret < 0) {
86 dev_err(cdx->dev,
87 "Get devices on CDX bus %d failed: %d\n", bus_num, ret);
88 continue;
89 }
90 num_cdx_dev = (u8)ret;
91
92 for (dev_num = 0; dev_num < num_cdx_dev; dev_num++) {
93 struct cdx_dev_params dev_params;
94
95 /* MCDI FW: Get the device config */
96 ret = cdx_mcdi_get_dev_config(cdx_mcdi, bus_num,
97 dev_num, &dev_params);
98 if (ret) {
99 dev_err(cdx->dev,
100 "CDX device config get failed for %d(bus):%d(dev), %d\n",
101 bus_num, dev_num, ret);
102 continue;
103 }
104 dev_params.cdx = cdx;
105
106 /* Add the device to the cdx bus */
107 ret = cdx_device_add(&dev_params);
108 if (ret) {
109 dev_err(cdx->dev, "registering cdx dev: %d failed: %d\n",
110 dev_num, ret);
111 continue;
112 }
113
114 dev_dbg(cdx->dev, "CDX dev: %d on cdx bus: %d created\n",
115 dev_num, bus_num);
116 }
117 }
118
119 return 0;
120}
121
122static struct cdx_ops cdx_ops = {
123 .scan = cdx_scan_devices,
124 .dev_configure = cdx_configure_device,
125};
126
127static int xlnx_cdx_probe(struct platform_device *pdev)
128{
129 struct cdx_controller *cdx;
130 struct cdx_mcdi *cdx_mcdi;
131 int ret;
132
133 cdx_mcdi = kzalloc(sizeof(*cdx_mcdi), GFP_KERNEL);
134 if (!cdx_mcdi)
135 return -ENOMEM;
136
137 /* Store the MCDI ops */
138 cdx_mcdi->mcdi_ops = &mcdi_ops;
139 /* MCDI FW: Initialize the FW path */
140 ret = cdx_mcdi_init(cdx_mcdi);
141 if (ret) {
142 dev_err_probe(&pdev->dev, ret, "MCDI Initialization failed\n");
143 goto mcdi_init_fail;
144 }
145
146 cdx = kzalloc(sizeof(*cdx), GFP_KERNEL);
147 if (!cdx) {
148 ret = -ENOMEM;
149 goto cdx_alloc_fail;
150 }
151 platform_set_drvdata(pdev, cdx);
152
153 cdx->dev = &pdev->dev;
154 cdx->priv = cdx_mcdi;
155 cdx->ops = &cdx_ops;
156
157 ret = cdx_setup_rpmsg(pdev);
158 if (ret) {
159 if (ret != -EPROBE_DEFER)
160 dev_err(&pdev->dev, "Failed to register CDX RPMsg transport\n");
161 goto cdx_rpmsg_fail;
162 }
163
164 dev_info(&pdev->dev, "Successfully registered CDX controller with RPMsg as transport\n");
165 return 0;
166
167cdx_rpmsg_fail:
168 kfree(cdx);
169cdx_alloc_fail:
170 cdx_mcdi_finish(cdx_mcdi);
171mcdi_init_fail:
172 kfree(cdx_mcdi);
173
174 return ret;
175}
176
177static int xlnx_cdx_remove(struct platform_device *pdev)
178{
179 struct cdx_controller *cdx = platform_get_drvdata(pdev);
180 struct cdx_mcdi *cdx_mcdi = cdx->priv;
181
182 cdx_destroy_rpmsg(pdev);
183
184 kfree(cdx);
185
186 cdx_mcdi_finish(cdx_mcdi);
187 kfree(cdx_mcdi);
188
189 return 0;
190}
191
192static const struct of_device_id cdx_match_table[] = {
193 {.compatible = "xlnx,versal-net-cdx",},
194 { },
195};
196
197MODULE_DEVICE_TABLE(of, cdx_match_table);
198
199static struct platform_driver cdx_pdriver = {
200 .driver = {
201 .name = "cdx-controller",
202 .pm = NULL,
203 .of_match_table = cdx_match_table,
204 },
205 .probe = xlnx_cdx_probe,
206 .remove = xlnx_cdx_remove,
207};
208
209static int __init cdx_controller_init(void)
210{
211 int ret;
212
213 ret = platform_driver_register(&cdx_pdriver);
214 if (ret)
215 pr_err("platform_driver_register() failed: %d\n", ret);
216
217 return ret;
218}
219
220static void __exit cdx_controller_exit(void)
221{
222 platform_driver_unregister(&cdx_pdriver);
223}
224
225module_init(cdx_controller_init);
226module_exit(cdx_controller_exit);
227
228MODULE_AUTHOR("AMD Inc.");
229MODULE_DESCRIPTION("CDX controller for AMD devices");
230MODULE_LICENSE("GPL");