Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : *
3 : : * Copyright(c) 2020-2021 Xilinx, Inc.
4 : : */
5 : :
6 : : #include "efx.h"
7 : : #include "efx_impl.h"
8 : :
9 : : #if EFSYS_OPT_RIVERHEAD && EFSYS_OPT_VIRTIO
10 : :
11 : : /*
12 : : * Get function-local index of the associated VI from the
13 : : * virtqueue number queue 0 is reserved for MCDI
14 : : */
15 : : #define EFX_VIRTIO_GET_VI_INDEX(vq_num) (((vq_num) / 2) + 1)
16 : :
17 : : __checkReturn efx_rc_t
18 : 0 : rhead_virtio_qstart(
19 : : __in efx_virtio_vq_t *evvp,
20 : : __in efx_virtio_vq_cfg_t *evvcp,
21 : : __in_opt efx_virtio_vq_dyncfg_t *evvdp)
22 : :
23 : : {
24 : 0 : efx_nic_t *enp = evvp->evv_enp;
25 : : efx_mcdi_req_t req;
26 : : uint32_t vi_index;
27 : 0 : EFX_MCDI_DECLARE_BUF(payload, MC_CMD_VIRTIO_INIT_QUEUE_REQ_LEN,
28 : : MC_CMD_VIRTIO_INIT_QUEUE_RESP_LEN);
29 : : efx_rc_t rc;
30 : :
31 : : EFX_STATIC_ASSERT(EFX_VIRTIO_VQ_TYPE_NET_RXQ ==
32 : : MC_CMD_VIRTIO_INIT_QUEUE_REQ_NET_RXQ);
33 : : EFX_STATIC_ASSERT(EFX_VIRTIO_VQ_TYPE_NET_TXQ ==
34 : : MC_CMD_VIRTIO_INIT_QUEUE_REQ_NET_TXQ);
35 : : EFX_STATIC_ASSERT(EFX_VIRTIO_VQ_TYPE_BLOCK ==
36 : : MC_CMD_VIRTIO_INIT_QUEUE_REQ_BLOCK);
37 : :
38 [ # # ]: 0 : if (evvcp->evvc_type >= EFX_VIRTIO_VQ_NTYPES) {
39 : : rc = EINVAL;
40 : 0 : goto fail1;
41 : : }
42 : :
43 : : /* virtqueue size must be power of 2 */
44 [ # # # # ]: 0 : if ((!ISP2(evvcp->evvc_vq_size)) ||
45 : : (evvcp->evvc_vq_size > EFX_VIRTIO_MAX_VQ_SIZE)) {
46 : : rc = EINVAL;
47 : 0 : goto fail2;
48 : : }
49 : :
50 : 0 : req.emr_cmd = MC_CMD_VIRTIO_INIT_QUEUE;
51 : 0 : req.emr_in_buf = payload;
52 : 0 : req.emr_in_length = MC_CMD_VIRTIO_INIT_QUEUE_REQ_LEN;
53 : 0 : req.emr_out_buf = payload;
54 : 0 : req.emr_out_length = MC_CMD_VIRTIO_INIT_QUEUE_RESP_LEN;
55 : :
56 : 0 : MCDI_IN_SET_BYTE(req, VIRTIO_INIT_QUEUE_REQ_QUEUE_TYPE,
57 : : evvcp->evvc_type);
58 : 0 : MCDI_IN_SET_WORD(req, VIRTIO_INIT_QUEUE_REQ_TARGET_VF,
59 : : evvcp->evvc_target_vf);
60 : :
61 : 0 : vi_index = EFX_VIRTIO_GET_VI_INDEX(evvcp->evvc_vq_num);
62 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_INSTANCE, vi_index);
63 : :
64 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_SIZE,
65 : : evvcp->evvc_vq_size);
66 : :
67 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_DESC_TBL_ADDR_LO,
68 : : evvcp->evvc_desc_tbl_addr & 0xFFFFFFFF);
69 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_DESC_TBL_ADDR_HI,
70 : : evvcp->evvc_desc_tbl_addr >> 32);
71 : :
72 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_AVAIL_RING_ADDR_LO,
73 : : evvcp->evvc_avail_ring_addr & 0xFFFFFFFF);
74 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_AVAIL_RING_ADDR_HI,
75 : : evvcp->evvc_avail_ring_addr >> 32);
76 : :
77 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_USED_RING_ADDR_LO,
78 : : evvcp->evvc_used_ring_addr & 0xFFFFFFFF);
79 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_USED_RING_ADDR_HI,
80 : : evvcp->evvc_used_ring_addr >> 32);
81 : :
82 [ # # ]: 0 : if (evvcp->evvc_use_pasid) {
83 : 0 : MCDI_IN_POPULATE_DWORD_1(req, VIRTIO_INIT_QUEUE_REQ_FLAGS,
84 : : VIRTIO_INIT_QUEUE_REQ_USE_PASID, 1);
85 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_PASID,
86 : : evvcp->evvc_pas_id);
87 : : }
88 : :
89 : 0 : MCDI_IN_SET_WORD(req, VIRTIO_INIT_QUEUE_REQ_MSIX_VECTOR,
90 : : evvcp->evvc_msix_vector);
91 : :
92 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_FEATURES_LO,
93 : : evvcp->evcc_features & 0xFFFFFFFF);
94 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_FEATURES_HI,
95 : : evvcp->evcc_features >> 32);
96 : :
97 [ # # ]: 0 : if (evvdp != NULL) {
98 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_INITIAL_AVAIL_IDX,
99 : : evvdp->evvd_vq_avail_idx);
100 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_INITIAL_USED_IDX,
101 : : evvdp->evvd_vq_used_idx);
102 : : }
103 : :
104 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_MPORT_SELECTOR,
105 : : MAE_MPORT_SELECTOR_ASSIGNED);
106 : :
107 : 0 : efx_mcdi_execute(enp, &req);
108 : :
109 [ # # ]: 0 : if (req.emr_rc != 0) {
110 : : rc = req.emr_rc;
111 : 0 : goto fail3;
112 : : }
113 : :
114 : 0 : evvp->evv_vi_index = vi_index;
115 : :
116 : 0 : return (0);
117 : :
118 : : fail3:
119 : : EFSYS_PROBE(fail3);
120 : : fail2:
121 : : EFSYS_PROBE(fail2);
122 : : fail1:
123 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
124 : :
125 : : return (rc);
126 : : }
127 : :
128 : : __checkReturn efx_rc_t
129 : 0 : rhead_virtio_qstop(
130 : : __in efx_virtio_vq_t *evvp,
131 : : __out_opt efx_virtio_vq_dyncfg_t *evvdp)
132 : : {
133 : : efx_mcdi_req_t req;
134 : 0 : efx_nic_t *enp = evvp->evv_enp;
135 : 0 : EFX_MCDI_DECLARE_BUF(payload, MC_CMD_VIRTIO_FINI_QUEUE_REQ_LEN,
136 : : MC_CMD_VIRTIO_FINI_QUEUE_RESP_LEN);
137 : : efx_rc_t rc;
138 : :
139 : 0 : req.emr_cmd = MC_CMD_VIRTIO_FINI_QUEUE;
140 : 0 : req.emr_in_buf = payload;
141 : 0 : req.emr_in_length = MC_CMD_VIRTIO_FINI_QUEUE_REQ_LEN;
142 : 0 : req.emr_out_buf = payload;
143 : 0 : req.emr_out_length = MC_CMD_VIRTIO_FINI_QUEUE_RESP_LEN;
144 : :
145 : 0 : MCDI_IN_SET_BYTE(req, VIRTIO_FINI_QUEUE_REQ_QUEUE_TYPE, evvp->evv_type);
146 : 0 : MCDI_IN_SET_WORD(req, VIRTIO_INIT_QUEUE_REQ_TARGET_VF,
147 : : evvp->evv_target_vf);
148 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_INIT_QUEUE_REQ_INSTANCE,
149 : : evvp->evv_vi_index);
150 : :
151 : 0 : efx_mcdi_execute(enp, &req);
152 : :
153 [ # # ]: 0 : if (req.emr_rc != 0) {
154 : : rc = req.emr_rc;
155 : 0 : goto fail1;
156 : : }
157 : :
158 [ # # ]: 0 : if (req.emr_out_length_used < MC_CMD_VIRTIO_FINI_QUEUE_RESP_LEN) {
159 : : rc = EMSGSIZE;
160 : 0 : goto fail2;
161 : : }
162 : :
163 [ # # ]: 0 : if (evvdp != NULL) {
164 : 0 : evvdp->evvd_vq_avail_idx =
165 : 0 : MCDI_OUT_DWORD(req, VIRTIO_FINI_QUEUE_RESP_FINAL_AVAIL_IDX);
166 : 0 : evvdp->evvd_vq_used_idx =
167 : 0 : MCDI_OUT_DWORD(req, VIRTIO_FINI_QUEUE_RESP_FINAL_USED_IDX);
168 : : }
169 : :
170 : : return (0);
171 : :
172 : : fail2:
173 : : EFSYS_PROBE(fail2);
174 : : fail1:
175 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
176 : :
177 : : return (rc);
178 : : }
179 : :
180 : : __checkReturn efx_rc_t
181 : 0 : rhead_virtio_get_doorbell_offset(
182 : : __in efx_virtio_vq_t *evvp,
183 : : __out uint32_t *offsetp)
184 : : {
185 : 0 : efx_nic_t *enp = evvp->evv_enp;
186 : : efx_mcdi_req_t req;
187 : : uint32_t type;
188 : 0 : EFX_MCDI_DECLARE_BUF(payload, MC_CMD_VIRTIO_GET_DOORBELL_OFFSET_REQ_LEN,
189 : : MC_CMD_VIRTIO_GET_NET_DOORBELL_OFFSET_RESP_LEN);
190 : : efx_rc_t rc;
191 : :
192 : 0 : req.emr_cmd = MC_CMD_VIRTIO_GET_DOORBELL_OFFSET;
193 : 0 : req.emr_in_buf = payload;
194 : 0 : req.emr_in_length = MC_CMD_VIRTIO_GET_DOORBELL_OFFSET_REQ_LEN;
195 : 0 : req.emr_out_buf = payload;
196 : 0 : req.emr_out_length = MC_CMD_VIRTIO_GET_NET_DOORBELL_OFFSET_RESP_LEN;
197 : :
198 [ # # # ]: 0 : switch (evvp->evv_type) {
199 : : case EFX_VIRTIO_VQ_TYPE_NET_RXQ:
200 : : case EFX_VIRTIO_VQ_TYPE_NET_TXQ:
201 : : type = MC_CMD_VIRTIO_GET_FEATURES_IN_NET;
202 : : break;
203 : 0 : case EFX_VIRTIO_VQ_TYPE_BLOCK:
204 : : type = MC_CMD_VIRTIO_GET_FEATURES_IN_BLOCK;
205 : 0 : break;
206 : 0 : default:
207 : : rc = EINVAL;
208 : 0 : goto fail1;
209 : : }
210 : :
211 : 0 : MCDI_IN_SET_BYTE(req, VIRTIO_GET_DOORBELL_OFFSET_REQ_DEVICE_ID,
212 : : type);
213 : 0 : MCDI_IN_SET_WORD(req, VIRTIO_GET_DOORBELL_OFFSET_REQ_TARGET_VF,
214 : : evvp->evv_target_vf);
215 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_GET_DOORBELL_OFFSET_REQ_INSTANCE,
216 : : evvp->evv_vi_index);
217 : :
218 : 0 : efx_mcdi_execute(enp, &req);
219 : :
220 [ # # ]: 0 : if (req.emr_rc != 0) {
221 : : rc = req.emr_rc;
222 : 0 : goto fail2;
223 : : }
224 : :
225 [ # # ]: 0 : switch (type) {
226 : 0 : case MC_CMD_VIRTIO_GET_FEATURES_IN_NET:
227 [ # # ]: 0 : if (req.emr_out_length_used <
228 : : MC_CMD_VIRTIO_GET_NET_DOORBELL_OFFSET_RESP_LEN) {
229 : : rc = EMSGSIZE;
230 : 0 : goto fail3;
231 : : }
232 : :
233 [ # # ]: 0 : if (evvp->evv_type == EFX_VIRTIO_VQ_TYPE_NET_RXQ) {
234 : 0 : *offsetp = MCDI_OUT_DWORD(req,
235 : : VIRTIO_GET_NET_DOORBELL_OFFSET_RESP_RX_DBL_OFFSET);
236 [ # # ]: 0 : } else if (evvp->evv_type == EFX_VIRTIO_VQ_TYPE_NET_TXQ) {
237 : 0 : *offsetp = MCDI_OUT_DWORD(req,
238 : : VIRTIO_GET_NET_DOORBELL_OFFSET_RESP_TX_DBL_OFFSET);
239 : : }
240 : : break;
241 : 0 : case MC_CMD_VIRTIO_GET_FEATURES_IN_BLOCK:
242 [ # # ]: 0 : if (req.emr_out_length_used <
243 : : MC_CMD_VIRTIO_GET_BLOCK_DOORBELL_OFFSET_RESP_LEN) {
244 : : rc = EMSGSIZE;
245 : 0 : goto fail4;
246 : : }
247 : :
248 : 0 : *offsetp = MCDI_OUT_DWORD(req,
249 : : VIRTIO_GET_BLOCK_DOORBELL_OFFSET_RESP_DBL_OFFSET);
250 : 0 : break;
251 : : default:
252 : : EFSYS_ASSERT(0);
253 : : rc = EINVAL;
254 : : goto fail5;
255 : : }
256 : :
257 : : return (0);
258 : :
259 : : fail5:
260 : : EFSYS_PROBE(fail5);
261 : : fail4:
262 : : EFSYS_PROBE(fail4);
263 : : fail3:
264 : : EFSYS_PROBE(fail3);
265 : : fail2:
266 : : EFSYS_PROBE(fail2);
267 : : fail1:
268 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
269 : :
270 : : return (rc);
271 : : }
272 : :
273 : : __checkReturn efx_rc_t
274 : 0 : rhead_virtio_get_features(
275 : : __in efx_nic_t *enp,
276 : : __in efx_virtio_device_type_t type,
277 : : __out uint64_t *featuresp)
278 : : {
279 : : efx_mcdi_req_t req;
280 : : uint32_t features_lo;
281 : : uint32_t features_hi;
282 : 0 : EFX_MCDI_DECLARE_BUF(payload, MC_CMD_VIRTIO_GET_FEATURES_IN_LEN,
283 : : MC_CMD_VIRTIO_GET_FEATURES_OUT_LEN);
284 : : efx_rc_t rc;
285 : :
286 : : EFX_STATIC_ASSERT(EFX_VIRTIO_DEVICE_TYPE_NET ==
287 : : MC_CMD_VIRTIO_GET_FEATURES_IN_NET);
288 : : EFX_STATIC_ASSERT(EFX_VIRTIO_DEVICE_TYPE_BLOCK ==
289 : : MC_CMD_VIRTIO_GET_FEATURES_IN_BLOCK);
290 : :
291 : 0 : req.emr_cmd = MC_CMD_VIRTIO_GET_FEATURES;
292 : 0 : req.emr_in_buf = payload;
293 : 0 : req.emr_in_length = MC_CMD_VIRTIO_GET_FEATURES_IN_LEN;
294 : 0 : req.emr_out_buf = payload;
295 : 0 : req.emr_out_length = MC_CMD_VIRTIO_GET_FEATURES_OUT_LEN;
296 : :
297 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_GET_FEATURES_IN_DEVICE_ID, type);
298 : :
299 : 0 : efx_mcdi_execute(enp, &req);
300 : :
301 [ # # ]: 0 : if (req.emr_rc != 0) {
302 : : rc = req.emr_rc;
303 : 0 : goto fail1;
304 : : }
305 : :
306 [ # # ]: 0 : if (req.emr_out_length_used < MC_CMD_VIRTIO_GET_FEATURES_OUT_LEN) {
307 : : rc = EMSGSIZE;
308 : 0 : goto fail2;
309 : : }
310 : :
311 : 0 : features_lo = MCDI_OUT_DWORD(req, VIRTIO_GET_FEATURES_OUT_FEATURES_LO);
312 : 0 : features_hi = MCDI_OUT_DWORD(req, VIRTIO_GET_FEATURES_OUT_FEATURES_HI);
313 : 0 : *featuresp = ((uint64_t)features_hi << 32) | features_lo;
314 : :
315 : 0 : return (0);
316 : :
317 : : fail2:
318 : : EFSYS_PROBE(fail2);
319 : : fail1:
320 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
321 : :
322 : : return (rc);
323 : : }
324 : :
325 : : __checkReturn efx_rc_t
326 : 0 : rhead_virtio_verify_features(
327 : : __in efx_nic_t *enp,
328 : : __in efx_virtio_device_type_t type,
329 : : __in uint64_t features)
330 : : {
331 : : efx_mcdi_req_t req;
332 : 0 : EFX_MCDI_DECLARE_BUF(payload, MC_CMD_VIRTIO_TEST_FEATURES_IN_LEN,
333 : : MC_CMD_VIRTIO_TEST_FEATURES_OUT_LEN);
334 : : efx_rc_t rc;
335 : :
336 : : EFX_STATIC_ASSERT(EFX_VIRTIO_DEVICE_TYPE_NET ==
337 : : MC_CMD_VIRTIO_GET_FEATURES_IN_NET);
338 : : EFX_STATIC_ASSERT(EFX_VIRTIO_DEVICE_TYPE_BLOCK ==
339 : : MC_CMD_VIRTIO_GET_FEATURES_IN_BLOCK);
340 : :
341 : 0 : req.emr_cmd = MC_CMD_VIRTIO_TEST_FEATURES;
342 : 0 : req.emr_in_buf = payload;
343 : 0 : req.emr_in_length = MC_CMD_VIRTIO_TEST_FEATURES_IN_LEN;
344 : 0 : req.emr_out_buf = payload;
345 : 0 : req.emr_out_length = MC_CMD_VIRTIO_TEST_FEATURES_OUT_LEN;
346 : :
347 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_TEST_FEATURES_IN_DEVICE_ID, type);
348 : :
349 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_TEST_FEATURES_IN_FEATURES_LO,
350 : : features & 0xFFFFFFFF);
351 : 0 : MCDI_IN_SET_DWORD(req, VIRTIO_TEST_FEATURES_IN_FEATURES_HI,
352 : : ((features >> 32) & 0xFFFFFFFF));
353 : :
354 : 0 : efx_mcdi_execute(enp, &req);
355 : :
356 [ # # ]: 0 : if (req.emr_rc != 0) {
357 : : rc = req.emr_rc;
358 : 0 : goto fail1;
359 : : }
360 : :
361 : : return (0);
362 : :
363 : : fail1:
364 : : EFSYS_PROBE1(fail1, efx_rc_t, rc);
365 : :
366 : 0 : return (rc);
367 : : }
368 : :
369 : : #endif /* EFSYS_OPT_RIVERHEAD && EFSYS_OPT_VIRTIO */
|