1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2022-2023, Advanced Micro Devices, Inc.
4 */
5
6#include <linux/module.h>
7
8#include "mcdi_functions.h"
9
10int cdx_mcdi_get_num_buses(struct cdx_mcdi *cdx)
11{
12 MCDI_DECLARE_BUF(outbuf, MC_CMD_CDX_BUS_ENUM_BUSES_OUT_LEN);
13 size_t outlen;
14 int ret;
15
16 ret = cdx_mcdi_rpc(cdx, MC_CMD_CDX_BUS_ENUM_BUSES, NULL, inlen: 0,
17 outbuf, outlen: sizeof(outbuf), outlen_actual: &outlen);
18 if (ret)
19 return ret;
20
21 if (outlen != MC_CMD_CDX_BUS_ENUM_BUSES_OUT_LEN)
22 return -EIO;
23
24 return MCDI_DWORD(outbuf, CDX_BUS_ENUM_BUSES_OUT_BUS_COUNT);
25}
26
27int cdx_mcdi_get_num_devs(struct cdx_mcdi *cdx, int bus_num)
28{
29 MCDI_DECLARE_BUF(outbuf, MC_CMD_CDX_BUS_ENUM_DEVICES_OUT_LEN);
30 MCDI_DECLARE_BUF(inbuf, MC_CMD_CDX_BUS_ENUM_DEVICES_IN_LEN);
31 size_t outlen;
32 int ret;
33
34 MCDI_SET_DWORD(inbuf, CDX_BUS_ENUM_DEVICES_IN_BUS, bus_num);
35
36 ret = cdx_mcdi_rpc(cdx, MC_CMD_CDX_BUS_ENUM_DEVICES, inbuf, inlen: sizeof(inbuf),
37 outbuf, outlen: sizeof(outbuf), outlen_actual: &outlen);
38 if (ret)
39 return ret;
40
41 if (outlen != MC_CMD_CDX_BUS_ENUM_DEVICES_OUT_LEN)
42 return -EIO;
43
44 return MCDI_DWORD(outbuf, CDX_BUS_ENUM_DEVICES_OUT_DEVICE_COUNT);
45}
46
47int cdx_mcdi_get_dev_config(struct cdx_mcdi *cdx,
48 u8 bus_num, u8 dev_num,
49 struct cdx_dev_params *dev_params)
50{
51 MCDI_DECLARE_BUF(outbuf, MC_CMD_CDX_BUS_GET_DEVICE_CONFIG_OUT_V2_LEN);
52 MCDI_DECLARE_BUF(inbuf, MC_CMD_CDX_BUS_GET_DEVICE_CONFIG_IN_LEN);
53 struct resource *res = &dev_params->res[0];
54 size_t outlen;
55 u32 req_id;
56 int ret;
57
58 MCDI_SET_DWORD(inbuf, CDX_BUS_GET_DEVICE_CONFIG_IN_BUS, bus_num);
59 MCDI_SET_DWORD(inbuf, CDX_BUS_GET_DEVICE_CONFIG_IN_DEVICE, dev_num);
60
61 ret = cdx_mcdi_rpc(cdx, MC_CMD_CDX_BUS_GET_DEVICE_CONFIG, inbuf, inlen: sizeof(inbuf),
62 outbuf, outlen: sizeof(outbuf), outlen_actual: &outlen);
63 if (ret)
64 return ret;
65
66 if (outlen != MC_CMD_CDX_BUS_GET_DEVICE_CONFIG_OUT_V2_LEN)
67 return -EIO;
68
69 dev_params->bus_num = bus_num;
70 dev_params->dev_num = dev_num;
71
72 req_id = MCDI_DWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_REQUESTER_ID);
73 dev_params->req_id = req_id;
74
75 dev_params->msi_dev_id = MCDI_DWORD(outbuf,
76 CDX_BUS_GET_DEVICE_CONFIG_OUT_V2_REQUESTER_DEVICE_ID);
77
78 dev_params->res_count = 0;
79 if (MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION0_SIZE) != 0) {
80 res[dev_params->res_count].start =
81 MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION0_BASE);
82 res[dev_params->res_count].end =
83 MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION0_BASE) +
84 MCDI_QWORD(outbuf,
85 CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION0_SIZE) - 1;
86 res[dev_params->res_count].flags = IORESOURCE_MEM;
87 dev_params->res_count++;
88 }
89
90 if (MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION1_SIZE) != 0) {
91 res[dev_params->res_count].start =
92 MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION1_BASE);
93 res[dev_params->res_count].end =
94 MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION1_BASE) +
95 MCDI_QWORD(outbuf,
96 CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION1_SIZE) - 1;
97 res[dev_params->res_count].flags = IORESOURCE_MEM;
98 dev_params->res_count++;
99 }
100
101 if (MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION2_SIZE) != 0) {
102 res[dev_params->res_count].start =
103 MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION2_BASE);
104 res[dev_params->res_count].end =
105 MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION2_BASE) +
106 MCDI_QWORD(outbuf,
107 CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION2_SIZE) - 1;
108 res[dev_params->res_count].flags = IORESOURCE_MEM;
109 dev_params->res_count++;
110 }
111
112 if (MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION3_SIZE) != 0) {
113 res[dev_params->res_count].start =
114 MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION3_BASE);
115 res[dev_params->res_count].end =
116 MCDI_QWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION3_BASE) +
117 MCDI_QWORD(outbuf,
118 CDX_BUS_GET_DEVICE_CONFIG_OUT_MMIO_REGION3_SIZE) - 1;
119 res[dev_params->res_count].flags = IORESOURCE_MEM;
120 dev_params->res_count++;
121 }
122
123 dev_params->vendor = MCDI_WORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_VENDOR_ID);
124 dev_params->device = MCDI_WORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_DEVICE_ID);
125 dev_params->subsys_vendor = MCDI_WORD(outbuf,
126 CDX_BUS_GET_DEVICE_CONFIG_OUT_SUBSYS_VENDOR_ID);
127 dev_params->subsys_device = MCDI_WORD(outbuf,
128 CDX_BUS_GET_DEVICE_CONFIG_OUT_SUBSYS_DEVICE_ID);
129 dev_params->class = MCDI_DWORD(outbuf,
130 CDX_BUS_GET_DEVICE_CONFIG_OUT_DEVICE_CLASS) & 0xFFFFFF;
131 dev_params->revision = MCDI_BYTE(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_DEVICE_REVISION);
132 dev_params->num_msi = MCDI_DWORD(outbuf, CDX_BUS_GET_DEVICE_CONFIG_OUT_MSI_COUNT);
133
134 return 0;
135}
136
137int cdx_mcdi_bus_enable(struct cdx_mcdi *cdx, u8 bus_num)
138{
139 MCDI_DECLARE_BUF(inbuf, MC_CMD_CDX_BUS_UP_IN_LEN);
140 int ret;
141
142 MCDI_SET_DWORD(inbuf, CDX_BUS_UP_IN_BUS, bus_num);
143 ret = cdx_mcdi_rpc(cdx, MC_CMD_CDX_BUS_UP, inbuf, inlen: sizeof(inbuf),
144 NULL, outlen: 0, NULL);
145
146 return ret;
147}
148
149int cdx_mcdi_bus_disable(struct cdx_mcdi *cdx, u8 bus_num)
150{
151 MCDI_DECLARE_BUF(inbuf, MC_CMD_CDX_BUS_DOWN_IN_LEN);
152 int ret;
153
154 MCDI_SET_DWORD(inbuf, CDX_BUS_DOWN_IN_BUS, bus_num);
155 ret = cdx_mcdi_rpc(cdx, MC_CMD_CDX_BUS_DOWN, inbuf, inlen: sizeof(inbuf),
156 NULL, outlen: 0, NULL);
157
158 return ret;
159}
160
161int cdx_mcdi_write_msi(struct cdx_mcdi *cdx, u8 bus_num, u8 dev_num,
162 u32 msi_vector, u64 msi_address, u32 msi_data)
163{
164 MCDI_DECLARE_BUF(inbuf, MC_CMD_CDX_DEVICE_WRITE_MSI_MSG_IN_LEN);
165 int ret;
166
167 MCDI_SET_DWORD(inbuf, CDX_DEVICE_WRITE_MSI_MSG_IN_BUS, bus_num);
168 MCDI_SET_DWORD(inbuf, CDX_DEVICE_WRITE_MSI_MSG_IN_DEVICE, dev_num);
169 MCDI_SET_DWORD(inbuf, CDX_DEVICE_WRITE_MSI_MSG_IN_MSI_VECTOR, msi_vector);
170 MCDI_SET_QWORD(inbuf, CDX_DEVICE_WRITE_MSI_MSG_IN_MSI_ADDRESS, msi_address);
171 MCDI_SET_DWORD(inbuf, CDX_DEVICE_WRITE_MSI_MSG_IN_MSI_DATA, msi_data);
172
173 ret = cdx_mcdi_rpc(cdx, MC_CMD_CDX_DEVICE_WRITE_MSI_MSG, inbuf, inlen: sizeof(inbuf),
174 NULL, outlen: 0, NULL);
175
176 return ret;
177}
178
179int cdx_mcdi_reset_device(struct cdx_mcdi *cdx, u8 bus_num, u8 dev_num)
180{
181 MCDI_DECLARE_BUF(inbuf, MC_CMD_CDX_DEVICE_RESET_IN_LEN);
182 int ret;
183
184 MCDI_SET_DWORD(inbuf, CDX_DEVICE_RESET_IN_BUS, bus_num);
185 MCDI_SET_DWORD(inbuf, CDX_DEVICE_RESET_IN_DEVICE, dev_num);
186
187 ret = cdx_mcdi_rpc(cdx, MC_CMD_CDX_DEVICE_RESET, inbuf, inlen: sizeof(inbuf),
188 NULL, outlen: 0, NULL);
189
190 return ret;
191}
192
193static int cdx_mcdi_ctrl_flag_get(struct cdx_mcdi *cdx, u8 bus_num,
194 u8 dev_num, u32 *flags)
195{
196 MCDI_DECLARE_BUF(inbuf, MC_CMD_CDX_DEVICE_CONTROL_GET_IN_LEN);
197 MCDI_DECLARE_BUF(outbuf, MC_CMD_CDX_DEVICE_CONTROL_GET_OUT_LEN);
198 size_t outlen;
199 int ret;
200
201 MCDI_SET_DWORD(inbuf, CDX_DEVICE_CONTROL_GET_IN_BUS, bus_num);
202 MCDI_SET_DWORD(inbuf, CDX_DEVICE_CONTROL_GET_IN_DEVICE, dev_num);
203 ret = cdx_mcdi_rpc(cdx, MC_CMD_CDX_DEVICE_CONTROL_GET, inbuf,
204 inlen: sizeof(inbuf), outbuf, outlen: sizeof(outbuf), outlen_actual: &outlen);
205 if (ret)
206 return ret;
207
208 if (outlen != MC_CMD_CDX_DEVICE_CONTROL_GET_OUT_LEN)
209 return -EIO;
210
211 *flags = MCDI_DWORD(outbuf, CDX_DEVICE_CONTROL_GET_OUT_FLAGS);
212
213 return 0;
214}
215
216static int cdx_mcdi_ctrl_flag_set(struct cdx_mcdi *cdx, u8 bus_num,
217 u8 dev_num, bool enable, int bit_pos)
218{
219 MCDI_DECLARE_BUF(inbuf, MC_CMD_CDX_DEVICE_CONTROL_SET_IN_LEN);
220 u32 flags;
221 int ret;
222
223 /*
224 * Get flags and then set/reset bit at bit_pos according to
225 * the input params.
226 */
227 ret = cdx_mcdi_ctrl_flag_get(cdx, bus_num, dev_num, flags: &flags);
228 if (ret)
229 return ret;
230
231 flags = flags & (u32)(~(BIT(bit_pos)));
232 if (enable)
233 flags |= (1 << bit_pos);
234
235 MCDI_SET_DWORD(inbuf, CDX_DEVICE_CONTROL_SET_IN_BUS, bus_num);
236 MCDI_SET_DWORD(inbuf, CDX_DEVICE_CONTROL_SET_IN_DEVICE, dev_num);
237 MCDI_SET_DWORD(inbuf, CDX_DEVICE_CONTROL_SET_IN_FLAGS, flags);
238 ret = cdx_mcdi_rpc(cdx, MC_CMD_CDX_DEVICE_CONTROL_SET, inbuf,
239 inlen: sizeof(inbuf), NULL, outlen: 0, NULL);
240
241 return ret;
242}
243
244int cdx_mcdi_bus_master_enable(struct cdx_mcdi *cdx, u8 bus_num,
245 u8 dev_num, bool enable)
246{
247 return cdx_mcdi_ctrl_flag_set(cdx, bus_num, dev_num, enable,
248 MC_CMD_CDX_DEVICE_CONTROL_SET_IN_BUS_MASTER_ENABLE_LBN);
249}
250
251int cdx_mcdi_msi_enable(struct cdx_mcdi *cdx, u8 bus_num,
252 u8 dev_num, bool enable)
253{
254 return cdx_mcdi_ctrl_flag_set(cdx, bus_num, dev_num, enable,
255 MC_CMD_CDX_DEVICE_CONTROL_SET_IN_MSI_ENABLE_LBN);
256}
257

source code of linux/drivers/cdx/controller/mcdi_functions.c