Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright 2025 Nebulamatrix Technology Co., Ltd.
3 : : */
4 : :
5 : : #include "nbl_dispatch.h"
6 : :
7 : 0 : static int nbl_disp_configure_msix_map(void *priv, u16 num_net_msix, u16 num_others_msix,
8 : : bool net_msix_mask_en)
9 : : {
10 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
11 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
12 : : int ret = 0;
13 : :
14 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->configure_msix_map,
15 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), 0, num_net_msix,
16 : : num_others_msix, net_msix_mask_en));
17 : 0 : return ret;
18 : : }
19 : :
20 : 0 : static int nbl_disp_chan_configure_msix_map_req(void *priv, u16 num_net_msix, u16 num_others_msix,
21 : : bool net_msix_mask_en)
22 : : {
23 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
24 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
25 : : struct nbl_chan_param_cfg_msix_map param = {0};
26 : : struct nbl_chan_send_info chan_send;
27 : :
28 : 0 : param.num_net_msix = num_net_msix;
29 : 0 : param.num_others_msix = num_others_msix;
30 : 0 : param.msix_mask_en = net_msix_mask_en;
31 : :
32 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_CONFIGURE_MSIX_MAP,
33 : : ¶m, sizeof(param), NULL, 0, 1);
34 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
35 : : }
36 : :
37 : 0 : static int nbl_disp_destroy_msix_map(void *priv)
38 : : {
39 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
40 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
41 : : int ret = 0;
42 : :
43 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->destroy_msix_map, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), 0));
44 : 0 : return ret;
45 : : }
46 : :
47 : 0 : static int nbl_disp_chan_destroy_msix_map_req(void *priv)
48 : : {
49 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
50 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
51 : : struct nbl_chan_send_info chan_send;
52 : :
53 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_DESTROY_MSIX_MAP, NULL, 0, NULL, 0, 1);
54 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
55 : : }
56 : :
57 : 0 : static int nbl_disp_enable_mailbox_irq(void *priv, u16 vector_id, bool enable_msix)
58 : : {
59 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
60 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
61 : : int ret = 0;
62 : :
63 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->enable_mailbox_irq,
64 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), 0, vector_id, enable_msix));
65 : 0 : return ret;
66 : : }
67 : :
68 : 0 : static int nbl_disp_chan_enable_mailbox_irq_req(void *priv, u16 vector_id, bool enable_msix)
69 : : {
70 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
71 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
72 : 0 : struct nbl_chan_param_enable_mailbox_irq param = {0};
73 : : struct nbl_chan_send_info chan_send;
74 : :
75 : 0 : param.vector_id = vector_id;
76 : 0 : param.enable_msix = enable_msix;
77 : :
78 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_MAILBOX_ENABLE_IRQ,
79 : : ¶m, sizeof(param), NULL, 0, 1);
80 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
81 : : }
82 : :
83 : 0 : static int nbl_disp_alloc_txrx_queues(void *priv, u16 vsi_id, u16 queue_num)
84 : : {
85 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
86 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
87 : :
88 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->alloc_txrx_queues,
89 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, queue_num));
90 : : }
91 : :
92 : 0 : static int nbl_disp_chan_alloc_txrx_queues_req(void *priv, u16 vsi_id,
93 : : u16 queue_num)
94 : : {
95 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
96 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
97 : : struct nbl_chan_param_alloc_txrx_queues param = {0};
98 : 0 : struct nbl_chan_param_alloc_txrx_queues result = {0};
99 : : struct nbl_chan_send_info chan_send;
100 : :
101 : 0 : param.vsi_id = vsi_id;
102 : 0 : param.queue_num = queue_num;
103 : :
104 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_ALLOC_TXRX_QUEUES, ¶m,
105 : : sizeof(param), &result, sizeof(result), 1);
106 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
107 : :
108 : 0 : return 0;
109 : : }
110 : :
111 : 0 : static void nbl_disp_free_txrx_queues(void *priv, u16 vsi_id)
112 : : {
113 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
114 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
115 : :
116 [ # # ]: 0 : NBL_OPS_CALL(res_ops->free_txrx_queues, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
117 : 0 : }
118 : :
119 : 0 : static void nbl_disp_chan_free_txrx_queues_req(void *priv, u16 vsi_id)
120 : : {
121 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
122 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
123 : : struct nbl_chan_param_free_txrx_queues param = {0};
124 : : struct nbl_chan_send_info chan_send;
125 : :
126 : 0 : param.vsi_id = vsi_id;
127 : :
128 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_FREE_TXRX_QUEUES, ¶m,
129 : : sizeof(param), NULL, 0, 1);
130 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
131 : 0 : }
132 : :
133 : 0 : static void nbl_disp_clear_queues(void *priv, u16 vsi_id)
134 : : {
135 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
136 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
137 : :
138 [ # # ]: 0 : NBL_OPS_CALL(res_ops->clear_queues, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
139 : 0 : }
140 : :
141 : 0 : static void nbl_disp_chan_clear_queues_req(void *priv, u16 vsi_id)
142 : : {
143 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
144 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
145 : 0 : struct nbl_chan_send_info chan_send = {0};
146 : :
147 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_CLEAR_QUEUE, &vsi_id, sizeof(vsi_id),
148 : : NULL, 0, 1);
149 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
150 : 0 : }
151 : :
152 : 0 : static int nbl_disp_start_tx_ring(void *priv,
153 : : struct nbl_start_tx_ring_param *param,
154 : : u64 *dma_addr)
155 : : {
156 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
157 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
158 : :
159 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->start_tx_ring,
160 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), param, dma_addr));
161 : : }
162 : :
163 : 0 : static void nbl_disp_release_tx_ring(void *priv, u16 queue_idx)
164 : : {
165 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
166 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
167 : :
168 [ # # ]: 0 : NBL_OPS_CALL(res_ops->release_tx_ring, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), queue_idx));
169 : 0 : }
170 : :
171 : 0 : static void nbl_disp_stop_tx_ring(void *priv, u16 queue_idx)
172 : : {
173 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
174 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
175 : :
176 [ # # ]: 0 : NBL_OPS_CALL(res_ops->stop_tx_ring, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), queue_idx));
177 : 0 : }
178 : :
179 : 0 : static int nbl_disp_start_rx_ring(void *priv,
180 : : struct nbl_start_rx_ring_param *param,
181 : : u64 *dma_addr)
182 : : {
183 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
184 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
185 : :
186 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->start_rx_ring,
187 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), param, dma_addr));
188 : : }
189 : :
190 : 0 : static int nbl_disp_alloc_rx_bufs(void *priv, u16 queue_idx)
191 : : {
192 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
193 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
194 : :
195 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->alloc_rx_bufs,
196 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), queue_idx));
197 : : }
198 : :
199 : 0 : static void nbl_disp_release_rx_ring(void *priv, u16 queue_idx)
200 : : {
201 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
202 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
203 : :
204 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->release_rx_ring,
205 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), queue_idx));
206 : : }
207 : :
208 : 0 : static void nbl_disp_stop_rx_ring(void *priv, u16 queue_idx)
209 : : {
210 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
211 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
212 : :
213 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->stop_rx_ring,
214 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), queue_idx));
215 : : }
216 : :
217 : 0 : static void nbl_disp_update_rx_ring(void *priv, u16 index)
218 : : {
219 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
220 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
221 : :
222 [ # # ]: 0 : NBL_OPS_CALL(res_ops->update_rx_ring, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), index));
223 : 0 : }
224 : :
225 : 0 : static int nbl_disp_alloc_rings(void *priv, u16 tx_num, u16 rx_num, u16 queue_offset)
226 : : {
227 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
228 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
229 : :
230 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->alloc_rings,
231 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), tx_num, rx_num, queue_offset));
232 : : }
233 : :
234 : 0 : static void nbl_disp_remove_rings(void *priv)
235 : : {
236 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
237 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
238 : :
239 [ # # ]: 0 : NBL_OPS_CALL(res_ops->remove_rings, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt)));
240 : 0 : }
241 : :
242 : : static int
243 : 0 : nbl_disp_setup_queue(void *priv, struct nbl_txrx_queue_param *param, bool is_tx)
244 : : {
245 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
246 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
247 : :
248 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->setup_queue,
249 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), param, is_tx));
250 : : }
251 : :
252 : : static int
253 : 0 : nbl_disp_chan_setup_queue_req(void *priv,
254 : : struct nbl_txrx_queue_param *queue_param,
255 : : bool is_tx)
256 : : {
257 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
258 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
259 : 0 : struct nbl_chan_param_setup_queue param = {0};
260 : : struct nbl_chan_send_info chan_send;
261 : :
262 : : memcpy(¶m.queue_param, queue_param, sizeof(param.queue_param));
263 : 0 : param.is_tx = is_tx;
264 : :
265 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_SETUP_QUEUE, ¶m,
266 : : sizeof(param), NULL, 0, 1);
267 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
268 : : }
269 : :
270 : 0 : static void nbl_disp_remove_all_queues(void *priv, u16 vsi_id)
271 : : {
272 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
273 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
274 : :
275 [ # # ]: 0 : NBL_OPS_CALL(res_ops->remove_all_queues, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
276 : 0 : }
277 : :
278 : 0 : static void nbl_disp_chan_remove_all_queues_req(void *priv, u16 vsi_id)
279 : : {
280 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
281 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
282 : : struct nbl_chan_param_remove_all_queues param = {0};
283 : : struct nbl_chan_send_info chan_send;
284 : :
285 : 0 : param.vsi_id = vsi_id;
286 : :
287 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REMOVE_ALL_QUEUES,
288 : : ¶m, sizeof(param), NULL, 0, 1);
289 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
290 : 0 : }
291 : :
292 : 0 : static int nbl_disp_get_mac_addr(void *priv __rte_unused, u8 *mac)
293 : : {
294 : 0 : rte_eth_random_addr(mac);
295 : :
296 : 0 : return 0;
297 : : }
298 : :
299 : 0 : static int nbl_disp_get_mac_addr_req(void *priv, u8 *mac)
300 : : {
301 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
302 : 0 : struct nbl_common_info *common = NBL_DISP_MGT_TO_COMMON(disp_mgt);
303 : : int ret = -1;
304 : :
305 [ # # # # ]: 0 : if (common->nl_socket_route >= 0 && common->ifindex >= 0)
306 : 0 : ret = nbl_userdev_get_mac_addr(common, mac);
307 : :
308 [ # # ]: 0 : if (ret) {
309 [ # # ]: 0 : if (rte_is_zero_ether_addr((struct rte_ether_addr *)common->mac))
310 : 0 : rte_eth_random_addr(mac);
311 : : else
312 : : rte_ether_addr_copy((struct rte_ether_addr *)common->mac,
313 : : (struct rte_ether_addr *)mac);
314 : : }
315 : :
316 : 0 : return 0;
317 : : }
318 : :
319 : 0 : static int nbl_disp_register_net(void *priv,
320 : : struct nbl_register_net_param *register_param,
321 : : struct nbl_register_net_result *register_result)
322 : : {
323 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
324 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
325 : :
326 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->register_net,
327 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), register_param, register_result));
328 : : }
329 : :
330 : 0 : static int nbl_disp_chan_register_net_req(void *priv,
331 : : struct nbl_register_net_param *register_param,
332 : : struct nbl_register_net_result *register_result)
333 : : {
334 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
335 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
336 : 0 : struct nbl_chan_param_register_net_info param = {0};
337 : : struct nbl_chan_send_info chan_send;
338 : : int ret = 0;
339 : :
340 : 0 : param.pf_bar_start = register_param->pf_bar_start;
341 : 0 : param.pf_bdf = register_param->pf_bdf;
342 : 0 : param.vf_bar_start = register_param->vf_bar_start;
343 : 0 : param.vf_bar_size = register_param->vf_bar_size;
344 : 0 : param.total_vfs = register_param->total_vfs;
345 : 0 : param.offset = register_param->offset;
346 : 0 : param.stride = register_param->stride;
347 : :
348 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REGISTER_NET,
349 : : ¶m, sizeof(param),
350 : : (void *)register_result, sizeof(*register_result), 1);
351 : :
352 : 0 : ret = chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
353 : 0 : return ret;
354 : : }
355 : :
356 : 0 : static int nbl_disp_unregister_net(void *priv)
357 : : {
358 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
359 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
360 : :
361 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->unregister_net, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt)));
362 : : }
363 : :
364 : 0 : static int nbl_disp_chan_unregister_net_req(void *priv)
365 : : {
366 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
367 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
368 : : struct nbl_chan_send_info chan_send;
369 : :
370 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_UNREGISTER_NET, NULL,
371 : : 0, NULL, 0, 1);
372 : :
373 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt),
374 : : &chan_send);
375 : : }
376 : :
377 : 0 : static u16 nbl_disp_get_vsi_id(void *priv)
378 : : {
379 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
380 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
381 : :
382 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->get_vsi_id, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt)));
383 : : }
384 : :
385 : 0 : static u16 nbl_disp_chan_get_vsi_id_req(void *priv)
386 : : {
387 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
388 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
389 : 0 : struct nbl_chan_param_get_vsi_id param = {0};
390 : 0 : struct nbl_chan_param_get_vsi_id result = {0};
391 : : struct nbl_chan_send_info chan_send;
392 : :
393 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_VSI_ID, ¶m,
394 : : sizeof(param), &result, sizeof(result), 1);
395 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
396 : :
397 : 0 : return result.vsi_id;
398 : : }
399 : :
400 : 0 : static void nbl_disp_get_eth_id(void *priv, u16 vsi_id, u8 *eth_mode, u8 *eth_id)
401 : : {
402 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
403 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
404 : :
405 [ # # ]: 0 : NBL_OPS_CALL(res_ops->get_eth_id, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
406 : : vsi_id, eth_mode, eth_id));
407 : 0 : }
408 : :
409 : 0 : static void nbl_disp_chan_get_eth_id_req(void *priv, u16 vsi_id, u8 *eth_mode, u8 *eth_id)
410 : : {
411 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
412 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
413 : 0 : struct nbl_chan_param_get_eth_id param = {0};
414 : 0 : struct nbl_chan_param_get_eth_id result = {0};
415 : : struct nbl_chan_send_info chan_send;
416 : :
417 : 0 : param.vsi_id = vsi_id;
418 : :
419 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_ETH_ID, ¶m, sizeof(param),
420 : : &result, sizeof(result), 1);
421 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
422 : :
423 : 0 : *eth_mode = result.eth_mode;
424 : 0 : *eth_id = result.eth_id;
425 : 0 : }
426 : :
427 : 0 : static u16 nbl_disp_get_vsi_global_qid(void *priv, u16 vsi_id, u16 local_qid)
428 : : {
429 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
430 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
431 : :
432 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->get_vsi_global_qid,
433 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, local_qid));
434 : : }
435 : :
436 : : static u16
437 : 0 : nbl_disp_chan_get_vsi_global_qid_req(void *priv, u16 vsi_id, u16 local_qid)
438 : : {
439 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
440 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
441 : : struct nbl_chan_vsi_qid_info param = {0};
442 : : struct nbl_chan_send_info chan_send;
443 : :
444 : 0 : param.vsi_id = vsi_id;
445 : 0 : param.local_qid = local_qid;
446 : :
447 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_VSI_GLOBAL_QUEUE_ID,
448 : : ¶m, sizeof(param), NULL, 0, 1);
449 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
450 : : }
451 : :
452 : 0 : static int nbl_disp_chan_setup_q2vsi(void *priv, u16 vsi_id)
453 : : {
454 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
455 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
456 : :
457 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->setup_q2vsi,
458 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
459 : : }
460 : :
461 : 0 : static int nbl_disp_chan_setup_q2vsi_req(void *priv, u16 vsi_id)
462 : : {
463 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
464 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
465 : : struct nbl_chan_param_cfg_q2vsi param = {0};
466 : : struct nbl_chan_send_info chan_send;
467 : :
468 : 0 : param.vsi_id = vsi_id;
469 : :
470 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_SETUP_Q2VSI, ¶m,
471 : : sizeof(param), NULL, 0, 1);
472 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
473 : : }
474 : :
475 : 0 : static void nbl_disp_chan_remove_q2vsi(void *priv, u16 vsi_id)
476 : : {
477 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
478 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
479 : :
480 [ # # ]: 0 : NBL_OPS_CALL(res_ops->remove_q2vsi,
481 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
482 : 0 : }
483 : :
484 : 0 : static void nbl_disp_chan_remove_q2vsi_req(void *priv, u16 vsi_id)
485 : : {
486 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
487 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
488 : : struct nbl_chan_param_cfg_q2vsi param = {0};
489 : : struct nbl_chan_send_info chan_send;
490 : :
491 : 0 : param.vsi_id = vsi_id;
492 : :
493 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REMOVE_Q2VSI, ¶m,
494 : : sizeof(param), NULL, 0, 1);
495 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
496 : 0 : }
497 : :
498 : 0 : static int nbl_disp_chan_register_vsi2q(void *priv, u16 vsi_index, u16 vsi_id,
499 : : u16 queue_offset, u16 queue_num)
500 : : {
501 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
502 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
503 : :
504 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->register_vsi2q,
505 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_index,
506 : : vsi_id, queue_offset, queue_num));
507 : : }
508 : :
509 : 0 : static int nbl_disp_chan_register_vsi2q_req(void *priv, u16 vsi_index, u16 vsi_id,
510 : : u16 queue_offset, u16 queue_num)
511 : : {
512 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
513 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
514 : : struct nbl_chan_param_register_vsi2q param = {0};
515 : : struct nbl_chan_send_info chan_send;
516 : :
517 : 0 : param.vsi_index = vsi_index;
518 : 0 : param.vsi_id = vsi_id;
519 : 0 : param.queue_offset = queue_offset;
520 : 0 : param.queue_num = queue_num;
521 : :
522 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REGISTER_VSI2Q, ¶m, sizeof(param),
523 : : NULL, 0, 1);
524 : :
525 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
526 : : }
527 : :
528 : 0 : static int nbl_disp_chan_setup_rss(void *priv, u16 vsi_id)
529 : : {
530 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
531 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
532 : :
533 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->setup_rss,
534 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
535 : : }
536 : :
537 : 0 : static int nbl_disp_chan_setup_rss_req(void *priv, u16 vsi_id)
538 : : {
539 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
540 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
541 : : struct nbl_chan_param_cfg_rss param = {0};
542 : : struct nbl_chan_send_info chan_send;
543 : :
544 : 0 : param.vsi_id = vsi_id;
545 : :
546 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_SETUP_RSS, ¶m,
547 : : sizeof(param), NULL, 0, 1);
548 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
549 : : }
550 : :
551 : 0 : static void nbl_disp_chan_remove_rss(void *priv, u16 vsi_id)
552 : : {
553 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
554 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
555 : :
556 [ # # ]: 0 : NBL_OPS_CALL(res_ops->remove_rss,
557 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
558 : 0 : }
559 : :
560 : 0 : static void nbl_disp_chan_remove_rss_req(void *priv, u16 vsi_id)
561 : : {
562 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
563 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
564 : : struct nbl_chan_param_cfg_rss param = {0};
565 : : struct nbl_chan_send_info chan_send;
566 : :
567 : 0 : param.vsi_id = vsi_id;
568 : :
569 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REMOVE_RSS, ¶m,
570 : : sizeof(param), NULL, 0, 1);
571 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
572 : 0 : }
573 : :
574 : 0 : static void nbl_disp_chan_get_board_info(void *priv, struct nbl_board_port_info *board_info)
575 : : {
576 : : RTE_SET_USED(priv);
577 : : RTE_SET_USED(board_info);
578 : 0 : }
579 : :
580 : 0 : static void nbl_disp_chan_get_board_info_req(void *priv, struct nbl_board_port_info *board_info)
581 : : {
582 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
583 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
584 : : struct nbl_chan_send_info chan_send;
585 : :
586 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_BOARD_INFO, NULL,
587 : : 0, board_info, sizeof(*board_info), 1);
588 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
589 : 0 : }
590 : :
591 : 0 : static void nbl_disp_clear_flow(void *priv, u16 vsi_id)
592 : : {
593 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
594 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
595 : :
596 [ # # ]: 0 : NBL_OPS_CALL(res_ops->clear_flow, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
597 : 0 : }
598 : :
599 : 0 : static void nbl_disp_chan_clear_flow_req(void *priv, u16 vsi_id)
600 : : {
601 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
602 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
603 : 0 : struct nbl_chan_send_info chan_send = {0};
604 : :
605 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_CLEAR_FLOW, &vsi_id, sizeof(vsi_id), NULL, 0, 1);
606 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
607 : 0 : }
608 : :
609 : 0 : static int nbl_disp_add_macvlan(void *priv, u8 *mac, u16 vlan_id, u16 vsi_id)
610 : : {
611 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
612 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
613 : :
614 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->add_macvlan,
615 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), mac, vlan_id, vsi_id));
616 : : }
617 : :
618 : : static int
619 : 0 : nbl_disp_chan_add_macvlan_req(void *priv, u8 *mac, u16 vlan_id, u16 vsi_id)
620 : : {
621 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
622 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
623 : 0 : struct nbl_chan_send_info chan_send = {0};
624 : : struct nbl_chan_param_macvlan_cfg param = {0};
625 : :
626 : : memcpy(¶m.mac, mac, sizeof(param.mac));
627 : 0 : param.vlan = vlan_id;
628 : 0 : param.vsi = vsi_id;
629 : :
630 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_ADD_MACVLAN, ¶m, sizeof(param), NULL, 0, 1);
631 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
632 : : }
633 : :
634 : 0 : static void nbl_disp_del_macvlan(void *priv, u8 *mac, u16 vlan_id, u16 vsi_id)
635 : : {
636 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
637 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
638 : :
639 [ # # ]: 0 : NBL_OPS_CALL(res_ops->del_macvlan,
640 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), mac, vlan_id, vsi_id));
641 : 0 : }
642 : :
643 : : static void
644 : 0 : nbl_disp_chan_del_macvlan_req(void *priv, u8 *mac, u16 vlan_id, u16 vsi_id)
645 : : {
646 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
647 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
648 : 0 : struct nbl_chan_send_info chan_send = {0};
649 : : struct nbl_chan_param_macvlan_cfg param = {0};
650 : :
651 : : memcpy(¶m.mac, mac, sizeof(param.mac));
652 : 0 : param.vlan = vlan_id;
653 : 0 : param.vsi = vsi_id;
654 : :
655 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_DEL_MACVLAN, ¶m, sizeof(param), NULL, 0, 1);
656 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
657 : 0 : }
658 : :
659 : 0 : static int nbl_disp_add_multi_rule(void *priv, u16 vsi_id)
660 : : {
661 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
662 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
663 : :
664 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->add_multi_rule, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
665 : : }
666 : :
667 : 0 : static int nbl_disp_chan_add_multi_rule_req(void *priv, u16 vsi_id)
668 : : {
669 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
670 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
671 : : struct nbl_chan_param_add_multi_rule param = {0};
672 : : struct nbl_chan_send_info chan_send;
673 : :
674 : 0 : param.vsi = vsi_id;
675 : :
676 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_ADD_MULTI_RULE, ¶m, sizeof(param), NULL, 0, 1);
677 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
678 : : }
679 : :
680 : 0 : static void nbl_disp_del_multi_rule(void *priv, u16 vsi_id)
681 : : {
682 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
683 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
684 : :
685 [ # # ]: 0 : NBL_OPS_CALL(res_ops->del_multi_rule, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
686 : 0 : }
687 : :
688 : 0 : static void nbl_disp_chan_del_multi_rule_req(void *priv, u16 vsi)
689 : : {
690 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
691 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
692 : : struct nbl_chan_param_del_multi_rule param = {0};
693 : : struct nbl_chan_send_info chan_send;
694 : :
695 : 0 : param.vsi = vsi;
696 : :
697 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_DEL_MULTI_RULE, ¶m, sizeof(param), NULL, 0, 1);
698 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
699 : 0 : }
700 : :
701 : 0 : static int nbl_disp_cfg_multi_mcast(void *priv, u16 vsi, u16 enable)
702 : : {
703 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
704 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
705 : : int ret = 0;
706 : :
707 [ # # ]: 0 : if (enable)
708 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->add_multi_mcast,
709 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi));
710 : : else
711 [ # # ]: 0 : NBL_OPS_CALL(res_ops->del_multi_mcast, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi));
712 : :
713 : 0 : return ret;
714 : : }
715 : :
716 : 0 : static int nbl_disp_chan_cfg_multi_mcast_req(void *priv, u16 vsi, u16 enable)
717 : : {
718 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
719 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
720 : 0 : struct nbl_common_info *common = NBL_DISP_MGT_TO_COMMON(disp_mgt);
721 : 0 : struct nbl_chan_param_cfg_multi_mcast param = {0};
722 : : struct nbl_chan_send_info chan_send;
723 : : int ret = 0;
724 : :
725 [ # # ]: 0 : if (NBL_IS_COEXISTENCE(common)) {
726 : 0 : ret = ioctl(common->devfd, NBL_DEV_USER_SET_MCAST_MODE, &enable);
727 [ # # ]: 0 : if (ret) {
728 : 0 : NBL_LOG(ERR, "userspace send cfg_multi_mcast ioctl msg failed ret %d",
729 : : ret);
730 : 0 : return ret;
731 : : }
732 : : return 0;
733 : : }
734 : :
735 : 0 : param.vsi = vsi;
736 : 0 : param.enable = enable;
737 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_CFG_MULTI_MCAST_RULE,
738 : : ¶m, sizeof(param), NULL, 0, 1);
739 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
740 : : }
741 : :
742 : 0 : static int nbl_disp_cfg_dsch(void *priv, u16 vsi_id, bool vld)
743 : : {
744 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
745 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
746 : :
747 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->cfg_dsch, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, vld));
748 : : }
749 : :
750 : 0 : static int nbl_disp_chan_cfg_dsch_req(void *priv, u16 vsi_id, bool vld)
751 : : {
752 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
753 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
754 : 0 : struct nbl_chan_param_cfg_dsch param = {0};
755 : : struct nbl_chan_send_info chan_send;
756 : :
757 : 0 : param.vsi_id = vsi_id;
758 : 0 : param.vld = vld;
759 : :
760 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_CFG_DSCH, ¶m, sizeof(param), NULL, 0, 1);
761 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
762 : : }
763 : :
764 : 0 : static int nbl_disp_setup_cqs(void *priv, u16 vsi_id, u16 real_qps, bool rss_indir_set)
765 : : {
766 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
767 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
768 : :
769 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->setup_cqs,
770 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, real_qps, rss_indir_set));
771 : : }
772 : :
773 : 0 : static int nbl_disp_chan_setup_cqs_req(void *priv, u16 vsi_id, u16 real_qps, bool rss_indir_set)
774 : : {
775 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
776 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
777 : 0 : struct nbl_chan_param_setup_cqs param = {0};
778 : : struct nbl_chan_send_info chan_send;
779 : :
780 : 0 : param.vsi_id = vsi_id;
781 : 0 : param.real_qps = real_qps;
782 : 0 : param.rss_indir_set = rss_indir_set;
783 : :
784 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_SETUP_CQS, ¶m, sizeof(param), NULL, 0, 1);
785 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
786 : : }
787 : :
788 : 0 : static void nbl_disp_remove_cqs(void *priv, u16 vsi_id)
789 : : {
790 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
791 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
792 : :
793 [ # # ]: 0 : NBL_OPS_CALL(res_ops->remove_cqs, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
794 : 0 : }
795 : :
796 : 0 : static void nbl_disp_chan_remove_cqs_req(void *priv, u16 vsi_id)
797 : : {
798 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
799 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
800 : : struct nbl_chan_param_remove_cqs param = {0};
801 : : struct nbl_chan_send_info chan_send;
802 : :
803 : 0 : param.vsi_id = vsi_id;
804 : :
805 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REMOVE_CQS, ¶m, sizeof(param), NULL, 0, 1);
806 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
807 : 0 : }
808 : :
809 : 0 : static void nbl_disp_get_res_pt_ops(void *priv, struct nbl_resource_pt_ops *pt_ops, bool offload)
810 : : {
811 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
812 : : struct nbl_resource_ops *res_ops;
813 : :
814 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
815 [ # # ]: 0 : NBL_OPS_CALL(res_ops->get_resource_pt_ops,
816 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), pt_ops, offload));
817 : 0 : }
818 : :
819 : 0 : static void nbl_disp_get_link_state(void *priv, u8 eth_id, struct nbl_eth_link_info *eth_link_info)
820 : : {
821 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
822 : : struct nbl_resource_ops *res_ops;
823 : :
824 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
825 : :
826 : : /* if do not have res_ops->get_link_state(), default eth is up */
827 [ # # ]: 0 : if (res_ops->get_link_state) {
828 : 0 : res_ops->get_link_state(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
829 : : eth_id, eth_link_info);
830 : : } else {
831 : 0 : eth_link_info->link_status = 1;
832 : 0 : eth_link_info->link_speed = RTE_ETH_LINK_SPEED_25G;
833 : : }
834 : 0 : }
835 : :
836 : 0 : static void nbl_disp_chan_get_link_state_req(void *priv, u8 eth_id,
837 : : struct nbl_eth_link_info *eth_link_info)
838 : : {
839 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
840 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
841 : : struct nbl_chan_param_get_link_state param = {0};
842 : : struct nbl_chan_send_info chan_send;
843 : :
844 : 0 : param.eth_id = eth_id;
845 : :
846 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_LINK_STATE, ¶m, sizeof(param),
847 : : eth_link_info, sizeof(*eth_link_info), 1);
848 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
849 : 0 : }
850 : :
851 : 0 : static int nbl_disp_get_stats(void *priv, struct rte_eth_stats *rte_stats,
852 : : struct eth_queue_stats *qstats)
853 : : {
854 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
855 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
856 : :
857 : 0 : return res_ops->get_stats(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), rte_stats, qstats);
858 : : }
859 : :
860 : 0 : static int nbl_disp_get_uvn_pkt_drop_stats(void *priv, u16 vsi_id,
861 : : u16 num_queues, u32 *uvn_stat_pkt_drop)
862 : : {
863 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
864 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
865 : : int ret = 0;
866 : :
867 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->get_uvn_pkt_drop_stats,
868 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
869 : : vsi_id, num_queues, uvn_stat_pkt_drop));
870 : 0 : return ret;
871 : : }
872 : :
873 : 0 : static int nbl_disp_chan_get_uvn_pkt_drop_stats_req(void *priv, u16 vsi_id,
874 : : u16 num_queues, u32 *uvn_stat_pkt_drop)
875 : : {
876 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
877 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
878 : : struct nbl_chan_param_get_uvn_pkt_drop_stats param = {0};
879 : 0 : struct nbl_chan_send_info chan_send = {0};
880 : :
881 : 0 : param.vsi_id = vsi_id;
882 : 0 : param.num_queues = num_queues;
883 : :
884 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_GET_UVN_PKT_DROP_STATS,
885 : : ¶m, sizeof(param),
886 : : uvn_stat_pkt_drop, num_queues * sizeof(*uvn_stat_pkt_drop), 1);
887 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
888 : : }
889 : :
890 : 0 : static int nbl_disp_get_ustore_total_pkt_drop_stats(void *priv, u8 eth_id,
891 : : struct nbl_ustore_stats *ustore_stats)
892 : : {
893 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
894 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
895 : : int ret = 0;
896 : :
897 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->get_ustore_total_pkt_drop_stats,
898 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), eth_id, ustore_stats));
899 : 0 : return ret;
900 : : }
901 : :
902 : 0 : static int nbl_disp_chan_get_ustore_total_pkt_drop_stats_req(void *priv, u8 eth_id,
903 : : struct nbl_ustore_stats *ustore_stats)
904 : : {
905 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
906 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
907 : 0 : struct nbl_chan_send_info chan_send = {0};
908 : :
909 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_GET_USTORE_TOTAL_PKT_DROP_STATS,
910 : : ð_id, sizeof(eth_id), ustore_stats, sizeof(*ustore_stats), 1);
911 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
912 : : }
913 : :
914 : 0 : static int nbl_disp_reset_stats(void *priv)
915 : : {
916 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
917 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
918 : :
919 : 0 : return res_ops->reset_stats(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt));
920 : : }
921 : :
922 : 0 : static int nbl_disp_get_txrx_xstats_cnt(void *priv, u16 *xstats_cnt)
923 : : {
924 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
925 : : struct nbl_resource_ops *res_ops;
926 : :
927 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
928 : 0 : return res_ops->get_txrx_xstats_cnt(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), xstats_cnt);
929 : : }
930 : :
931 : 0 : static int nbl_disp_get_txrx_xstats(void *priv, struct rte_eth_xstat *xstats,
932 : : u16 need_xstats_cnt, u16 *xstats_cnt)
933 : : {
934 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
935 : : struct nbl_resource_ops *res_ops;
936 : :
937 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
938 : 0 : return res_ops->get_txrx_xstats(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), xstats,
939 : : need_xstats_cnt, xstats_cnt);
940 : : }
941 : :
942 : 0 : static int nbl_disp_get_txrx_xstats_names(void *priv, struct rte_eth_xstat_name *xstats_names,
943 : : u16 need_xstats_cnt, u16 *xstats_cnt)
944 : : {
945 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
946 : : struct nbl_resource_ops *res_ops;
947 : :
948 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
949 : 0 : return res_ops->get_txrx_xstats_names(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
950 : : xstats_names, need_xstats_cnt, xstats_cnt);
951 : : }
952 : :
953 : 0 : static int nbl_disp_get_hw_xstats_cnt(void *priv, u16 *xstats_cnt)
954 : : {
955 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
956 : : struct nbl_resource_ops *res_ops;
957 : :
958 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
959 : 0 : return res_ops->get_hw_xstats_cnt(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), xstats_cnt);
960 : : }
961 : :
962 : 0 : static int nbl_disp_get_hw_xstats_names(void *priv, struct rte_eth_xstat_name *xstats_names,
963 : : u16 need_xstats_cnt, u16 *xstats_cnt)
964 : : {
965 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
966 : : struct nbl_resource_ops *res_ops;
967 : :
968 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
969 : 0 : return res_ops->get_hw_xstats_names(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
970 : : xstats_names, need_xstats_cnt, xstats_cnt);
971 : : }
972 : :
973 : 0 : static void nbl_disp_get_private_stat_data(void *priv, u32 eth_id, u64 *data,
974 : : __rte_unused u32 data_len)
975 : : {
976 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
977 : : struct nbl_resource_ops *res_ops;
978 : :
979 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
980 [ # # ]: 0 : NBL_OPS_CALL(res_ops->get_private_stat_data,
981 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), eth_id, data));
982 : 0 : }
983 : :
984 : 0 : static void nbl_disp_get_private_stat_data_req(void *priv, u32 eth_id, u64 *data, u32 data_len)
985 : : {
986 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
987 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
988 : 0 : struct nbl_chan_send_info chan_send = {0};
989 : : struct nbl_chan_param_get_private_stat_data param = {0};
990 : :
991 : 0 : param.eth_id = eth_id;
992 : 0 : param.data_len = data_len;
993 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_ETH_STATS, ¶m,
994 : : sizeof(param), data, data_len, 1);
995 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
996 : 0 : }
997 : :
998 : 0 : static int nbl_disp_set_mtu(void *priv, u16 vsi_id, u16 mtu)
999 : : {
1000 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
1001 : : struct nbl_resource_ops *res_ops;
1002 : : int ret = 0;
1003 : :
1004 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
1005 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->set_mtu, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, mtu));
1006 : 0 : return ret;
1007 : : }
1008 : :
1009 : 0 : static int nbl_disp_chan_set_mtu_req(void *priv, u16 vsi_id, u16 mtu)
1010 : : {
1011 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
1012 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
1013 : 0 : struct nbl_chan_send_info chan_send = {0};
1014 : : struct nbl_chan_param_set_mtu param = {0};
1015 : :
1016 : 0 : param.mtu = mtu;
1017 : 0 : param.vsi_id = vsi_id;
1018 : :
1019 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_MTU_SET,
1020 : : ¶m, sizeof(param), NULL, 0, 1);
1021 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt),
1022 : : &chan_send);
1023 : : }
1024 : :
1025 : 0 : static int nbl_disp_set_promisc_mode(void *priv, u16 vsi_id, u16 mode)
1026 : : {
1027 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
1028 : : struct nbl_resource_ops *res_ops;
1029 : : int ret = 0;
1030 : :
1031 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
1032 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->set_promisc_mode,
1033 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, mode));
1034 : 0 : return ret;
1035 : : }
1036 : :
1037 : 0 : static int nbl_disp_chan_set_promisc_mode_req(void *priv, u16 vsi_id, u16 mode)
1038 : : {
1039 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
1040 : : struct nbl_common_info *common;
1041 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
1042 : 0 : struct nbl_chan_param_set_promisc_mode param = {0};
1043 : 0 : struct nbl_chan_send_info chan_send = {0};
1044 : : int ret = 0;
1045 : :
1046 : 0 : common = NBL_DISP_MGT_TO_COMMON(disp_mgt);
1047 [ # # ]: 0 : if (NBL_IS_COEXISTENCE(common)) {
1048 : 0 : ret = ioctl(common->devfd, NBL_DEV_USER_SET_PROMISC_MODE, &mode);
1049 [ # # ]: 0 : if (ret) {
1050 : 0 : NBL_LOG(ERR, "userspace send set_promisc_mode ioctl msg failed ret %d",
1051 : : ret);
1052 : 0 : return ret;
1053 : : }
1054 : : return 0;
1055 : : }
1056 : :
1057 : 0 : param.vsi_id = vsi_id;
1058 : 0 : param.mode = mode;
1059 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_SET_PROSISC_MODE,
1060 : : ¶m, sizeof(param), NULL, 0, 1);
1061 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt),
1062 : : &chan_send);
1063 : : }
1064 : :
1065 : : #define NBL_DISP_OPS_TBL \
1066 : : do { \
1067 : : NBL_DISP_SET_OPS(configure_msix_map, nbl_disp_configure_msix_map, \
1068 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_CONFIGURE_MSIX_MAP, \
1069 : : nbl_disp_chan_configure_msix_map_req, \
1070 : : NULL); \
1071 : : NBL_DISP_SET_OPS(destroy_msix_map, nbl_disp_destroy_msix_map, \
1072 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_DESTROY_MSIX_MAP, \
1073 : : nbl_disp_chan_destroy_msix_map_req, \
1074 : : NULL); \
1075 : : NBL_DISP_SET_OPS(enable_mailbox_irq, nbl_disp_enable_mailbox_irq, \
1076 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_MAILBOX_ENABLE_IRQ, \
1077 : : nbl_disp_chan_enable_mailbox_irq_req, \
1078 : : NULL); \
1079 : : NBL_DISP_SET_OPS(alloc_txrx_queues, nbl_disp_alloc_txrx_queues, \
1080 : : NBL_DISP_CTRL_LVL_MGT, \
1081 : : NBL_CHAN_MSG_ALLOC_TXRX_QUEUES, \
1082 : : nbl_disp_chan_alloc_txrx_queues_req, \
1083 : : NULL); \
1084 : : NBL_DISP_SET_OPS(free_txrx_queues, nbl_disp_free_txrx_queues, \
1085 : : NBL_DISP_CTRL_LVL_MGT, \
1086 : : NBL_CHAN_MSG_FREE_TXRX_QUEUES, \
1087 : : nbl_disp_chan_free_txrx_queues_req, \
1088 : : NULL); \
1089 : : NBL_DISP_SET_OPS(alloc_rings, nbl_disp_alloc_rings, \
1090 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1091 : : NULL, NULL); \
1092 : : NBL_DISP_SET_OPS(remove_rings, nbl_disp_remove_rings, \
1093 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1094 : : NULL, NULL); \
1095 : : NBL_DISP_SET_OPS(start_tx_ring, nbl_disp_start_tx_ring, \
1096 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1097 : : NBL_DISP_SET_OPS(stop_tx_ring, nbl_disp_stop_tx_ring, \
1098 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1099 : : NBL_DISP_SET_OPS(release_tx_ring, nbl_disp_release_tx_ring, \
1100 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1101 : : NBL_DISP_SET_OPS(start_rx_ring, nbl_disp_start_rx_ring, \
1102 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1103 : : NBL_DISP_SET_OPS(alloc_rx_bufs, nbl_disp_alloc_rx_bufs, \
1104 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1105 : : NBL_DISP_SET_OPS(stop_rx_ring, nbl_disp_stop_rx_ring, \
1106 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1107 : : NBL_DISP_SET_OPS(release_rx_ring, nbl_disp_release_rx_ring, \
1108 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1109 : : NBL_DISP_SET_OPS(update_rx_ring, nbl_disp_update_rx_ring, \
1110 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1111 : : NULL, NULL); \
1112 : : NBL_DISP_SET_OPS(setup_queue, nbl_disp_setup_queue, \
1113 : : NBL_DISP_CTRL_LVL_MGT, \
1114 : : NBL_CHAN_MSG_SETUP_QUEUE, \
1115 : : nbl_disp_chan_setup_queue_req, NULL); \
1116 : : NBL_DISP_SET_OPS(remove_all_queues, nbl_disp_remove_all_queues, \
1117 : : NBL_DISP_CTRL_LVL_MGT, \
1118 : : NBL_CHAN_MSG_REMOVE_ALL_QUEUES, \
1119 : : nbl_disp_chan_remove_all_queues_req, NULL); \
1120 : : NBL_DISP_SET_OPS(clear_queues, nbl_disp_clear_queues, \
1121 : : NBL_DISP_CTRL_LVL_MGT, \
1122 : : NBL_CHAN_MSG_CLEAR_QUEUE, \
1123 : : nbl_disp_chan_clear_queues_req, NULL); \
1124 : : NBL_DISP_SET_OPS(get_mac_addr, nbl_disp_get_mac_addr, \
1125 : : NBL_DISP_CTRL_LVL_MGT, \
1126 : : -1, nbl_disp_get_mac_addr_req, NULL); \
1127 : : NBL_DISP_SET_OPS(register_net, nbl_disp_register_net, \
1128 : : NBL_DISP_CTRL_LVL_MGT, \
1129 : : NBL_CHAN_MSG_REGISTER_NET, \
1130 : : nbl_disp_chan_register_net_req, \
1131 : : NULL); \
1132 : : NBL_DISP_SET_OPS(unregister_net, nbl_disp_unregister_net, \
1133 : : NBL_DISP_CTRL_LVL_MGT, \
1134 : : NBL_CHAN_MSG_UNREGISTER_NET, \
1135 : : nbl_disp_chan_unregister_net_req, NULL); \
1136 : : NBL_DISP_SET_OPS(get_vsi_id, nbl_disp_get_vsi_id, \
1137 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_GET_VSI_ID,\
1138 : : nbl_disp_chan_get_vsi_id_req, NULL); \
1139 : : NBL_DISP_SET_OPS(get_eth_id, nbl_disp_get_eth_id, \
1140 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_GET_ETH_ID,\
1141 : : nbl_disp_chan_get_eth_id_req, NULL); \
1142 : : NBL_DISP_SET_OPS(get_vsi_global_qid, \
1143 : : nbl_disp_get_vsi_global_qid, \
1144 : : NBL_DISP_CTRL_LVL_MGT, \
1145 : : NBL_CHAN_MSG_GET_VSI_GLOBAL_QUEUE_ID, \
1146 : : nbl_disp_chan_get_vsi_global_qid_req, NULL); \
1147 : : NBL_DISP_SET_OPS(setup_q2vsi, nbl_disp_chan_setup_q2vsi, \
1148 : : NBL_DISP_CTRL_LVL_MGT, \
1149 : : NBL_CHAN_MSG_SETUP_Q2VSI, \
1150 : : nbl_disp_chan_setup_q2vsi_req, NULL); \
1151 : : NBL_DISP_SET_OPS(remove_q2vsi, nbl_disp_chan_remove_q2vsi, \
1152 : : NBL_DISP_CTRL_LVL_MGT, \
1153 : : NBL_CHAN_MSG_REMOVE_Q2VSI, \
1154 : : nbl_disp_chan_remove_q2vsi_req, NULL); \
1155 : : NBL_DISP_SET_OPS(register_vsi2q, nbl_disp_chan_register_vsi2q, \
1156 : : NBL_DISP_CTRL_LVL_MGT, \
1157 : : NBL_CHAN_MSG_REGISTER_VSI2Q, \
1158 : : nbl_disp_chan_register_vsi2q_req, NULL); \
1159 : : NBL_DISP_SET_OPS(setup_rss, nbl_disp_chan_setup_rss, \
1160 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_SETUP_RSS, \
1161 : : nbl_disp_chan_setup_rss_req, NULL); \
1162 : : NBL_DISP_SET_OPS(remove_rss, nbl_disp_chan_remove_rss, \
1163 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_REMOVE_RSS,\
1164 : : nbl_disp_chan_remove_rss_req, NULL); \
1165 : : NBL_DISP_SET_OPS(get_board_info, nbl_disp_chan_get_board_info, \
1166 : : NBL_DISP_CTRL_LVL_MGT, \
1167 : : NBL_CHAN_MSG_GET_BOARD_INFO, \
1168 : : nbl_disp_chan_get_board_info_req, NULL); \
1169 : : NBL_DISP_SET_OPS(clear_flow, nbl_disp_clear_flow, \
1170 : : NBL_DISP_CTRL_LVL_MGT, \
1171 : : NBL_CHAN_MSG_CLEAR_FLOW, \
1172 : : nbl_disp_chan_clear_flow_req, NULL); \
1173 : : NBL_DISP_SET_OPS(add_macvlan, nbl_disp_add_macvlan, \
1174 : : NBL_DISP_CTRL_LVL_MGT, \
1175 : : NBL_CHAN_MSG_ADD_MACVLAN, \
1176 : : nbl_disp_chan_add_macvlan_req, NULL); \
1177 : : NBL_DISP_SET_OPS(del_macvlan, nbl_disp_del_macvlan, \
1178 : : NBL_DISP_CTRL_LVL_MGT, \
1179 : : NBL_CHAN_MSG_DEL_MACVLAN, \
1180 : : nbl_disp_chan_del_macvlan_req, NULL); \
1181 : : NBL_DISP_SET_OPS(add_multi_rule, nbl_disp_add_multi_rule, \
1182 : : NBL_DISP_CTRL_LVL_MGT, \
1183 : : NBL_CHAN_MSG_ADD_MULTI_RULE, \
1184 : : nbl_disp_chan_add_multi_rule_req, NULL); \
1185 : : NBL_DISP_SET_OPS(del_multi_rule, nbl_disp_del_multi_rule, \
1186 : : NBL_DISP_CTRL_LVL_MGT, \
1187 : : NBL_CHAN_MSG_DEL_MULTI_RULE, \
1188 : : nbl_disp_chan_del_multi_rule_req, NULL); \
1189 : : NBL_DISP_SET_OPS(cfg_multi_mcast, nbl_disp_cfg_multi_mcast, \
1190 : : NBL_DISP_CTRL_LVL_MGT, \
1191 : : NBL_CHAN_MSG_CFG_MULTI_MCAST_RULE, \
1192 : : nbl_disp_chan_cfg_multi_mcast_req, NULL); \
1193 : : NBL_DISP_SET_OPS(cfg_dsch, nbl_disp_cfg_dsch, \
1194 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_CFG_DSCH, \
1195 : : nbl_disp_chan_cfg_dsch_req, NULL); \
1196 : : NBL_DISP_SET_OPS(setup_cqs, nbl_disp_setup_cqs, \
1197 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_SETUP_CQS, \
1198 : : nbl_disp_chan_setup_cqs_req, NULL); \
1199 : : NBL_DISP_SET_OPS(remove_cqs, nbl_disp_remove_cqs, \
1200 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_REMOVE_CQS,\
1201 : : nbl_disp_chan_remove_cqs_req, NULL); \
1202 : : NBL_DISP_SET_OPS(get_resource_pt_ops, \
1203 : : nbl_disp_get_res_pt_ops, \
1204 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1205 : : NULL, NULL); \
1206 : : NBL_DISP_SET_OPS(get_link_state, nbl_disp_get_link_state, \
1207 : : NBL_DISP_CTRL_LVL_MGT, \
1208 : : NBL_CHAN_MSG_GET_LINK_STATE, \
1209 : : nbl_disp_chan_get_link_state_req, NULL); \
1210 : : NBL_DISP_SET_OPS(get_stats, nbl_disp_get_stats, \
1211 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1212 : : NULL, NULL); \
1213 : : NBL_DISP_SET_OPS(get_uvn_pkt_drop_stats, \
1214 : : nbl_disp_get_uvn_pkt_drop_stats, \
1215 : : NBL_DISP_CTRL_LVL_MGT, \
1216 : : NBL_CHAN_GET_UVN_PKT_DROP_STATS, \
1217 : : nbl_disp_chan_get_uvn_pkt_drop_stats_req, NULL);\
1218 : : NBL_DISP_SET_OPS(get_ustore_total_pkt_drop_stats, \
1219 : : nbl_disp_get_ustore_total_pkt_drop_stats, \
1220 : : NBL_DISP_CTRL_LVL_MGT, \
1221 : : NBL_CHAN_GET_USTORE_TOTAL_PKT_DROP_STATS, \
1222 : : nbl_disp_chan_get_ustore_total_pkt_drop_stats_req,\
1223 : : NULL); \
1224 : : NBL_DISP_SET_OPS(reset_stats, nbl_disp_reset_stats, \
1225 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1226 : : NULL, NULL); \
1227 : : NBL_DISP_SET_OPS(get_txrx_xstats_cnt, \
1228 : : nbl_disp_get_txrx_xstats_cnt, \
1229 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1230 : : NULL, NULL); \
1231 : : NBL_DISP_SET_OPS(get_txrx_xstats, nbl_disp_get_txrx_xstats, \
1232 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1233 : : NULL, NULL); \
1234 : : NBL_DISP_SET_OPS(get_txrx_xstats_names, \
1235 : : nbl_disp_get_txrx_xstats_names, \
1236 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1237 : : NULL, NULL); \
1238 : : NBL_DISP_SET_OPS(get_hw_xstats_cnt, nbl_disp_get_hw_xstats_cnt, \
1239 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1240 : : NULL, NULL); \
1241 : : NBL_DISP_SET_OPS(get_hw_xstats_names, \
1242 : : nbl_disp_get_hw_xstats_names, \
1243 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1244 : : NULL, NULL); \
1245 : : NBL_DISP_SET_OPS(get_private_stat_data, \
1246 : : nbl_disp_get_private_stat_data, \
1247 : : NBL_DISP_CTRL_LVL_MGT, \
1248 : : NBL_CHAN_MSG_GET_ETH_STATS, \
1249 : : nbl_disp_get_private_stat_data_req, NULL); \
1250 : : NBL_DISP_SET_OPS(set_promisc_mode, nbl_disp_set_promisc_mode, \
1251 : : NBL_DISP_CTRL_LVL_MGT, \
1252 : : NBL_CHAN_MSG_SET_PROSISC_MODE, \
1253 : : nbl_disp_chan_set_promisc_mode_req, NULL); \
1254 : : NBL_DISP_SET_OPS(set_mtu, nbl_disp_set_mtu, \
1255 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_MTU_SET, \
1256 : : nbl_disp_chan_set_mtu_req, \
1257 : : NULL); \
1258 : : } while (0)
1259 : :
1260 : : /* Structure starts here, adding an op should not modify anything below */
1261 : 0 : static int nbl_disp_setup_msg(struct nbl_dispatch_mgt *disp_mgt)
1262 : : {
1263 : : struct nbl_dispatch_ops *disp_ops = NBL_DISP_MGT_TO_DISP_OPS(disp_mgt);
1264 : : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
1265 : : int ret = 0;
1266 : :
1267 : : #define NBL_DISP_SET_OPS(disp_op, res_func, ctrl_lvl2, msg_type, msg_req, msg_resp) \
1268 : : do { \
1269 : : typeof(msg_type) _msg_type = (msg_type); \
1270 : : typeof(msg_resp) _msg_resp = (msg_resp); \
1271 : : RTE_SET_USED(disp_ops->NBL_NAME(disp_op)); \
1272 : : RTE_SET_USED(res_func); \
1273 : : RTE_SET_USED(msg_req); \
1274 : : uint32_t _ctrl_lvl = rte_bit_relaxed_get32(ctrl_lvl2, &disp_mgt->ctrl_lvl); \
1275 : : if (_msg_type >= 0 && _msg_resp != NULL && _ctrl_lvl) \
1276 : : ret += chan_ops->register_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), \
1277 : : _msg_type, _msg_resp, disp_mgt); \
1278 : : } while (0)
1279 : : NBL_DISP_OPS_TBL;
1280 : : #undef NBL_DISP_SET_OPS
1281 : :
1282 : 0 : return ret;
1283 : : }
1284 : :
1285 : : /* Ctrl lvl means that if a certain level is set, then all disp_ops that declared this lvl
1286 : : * will go directly to res_ops, rather than send a channel msg, and vice versa.
1287 : : */
1288 : 0 : static int nbl_disp_setup_ctrl_lvl(struct nbl_dispatch_mgt *disp_mgt, u32 lvl)
1289 : : {
1290 [ # # ]: 0 : struct nbl_dispatch_ops *disp_ops = NBL_DISP_MGT_TO_DISP_OPS(disp_mgt);
1291 : :
1292 : : rte_bit_relaxed_set32(lvl, &disp_mgt->ctrl_lvl);
1293 : :
1294 : : #define NBL_DISP_SET_OPS(disp_op, res_func, ctrl, msg_type, msg_req, msg_resp) \
1295 : : do { \
1296 : : typeof(msg_type) _msg_type = (msg_type); \
1297 : : typeof(msg_resp) _msg_resp = (msg_resp); \
1298 : : RTE_SET_USED(_msg_type); \
1299 : : RTE_SET_USED(_msg_resp); \
1300 : : disp_ops->NBL_NAME(disp_op) = \
1301 : : rte_bit_relaxed_get32(ctrl, &disp_mgt->ctrl_lvl) ? res_func : msg_req; ;\
1302 : : } while (0)
1303 [ # # # # : 0 : NBL_DISP_OPS_TBL;
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # ]
1304 : : #undef NBL_DISP_SET_OPS
1305 : :
1306 : 0 : return 0;
1307 : : }
1308 : :
1309 : : static int nbl_disp_setup_disp_mgt(struct nbl_dispatch_mgt **disp_mgt)
1310 : : {
1311 : 0 : *disp_mgt = rte_zmalloc("nbl_disp_mgt", sizeof(struct nbl_dispatch_mgt), 0);
1312 [ # # ]: 0 : if (!*disp_mgt)
1313 : : return -ENOMEM;
1314 : :
1315 : : return 0;
1316 : : }
1317 : :
1318 : : static void nbl_disp_remove_disp_mgt(struct nbl_dispatch_mgt **disp_mgt)
1319 : : {
1320 : 0 : rte_free(*disp_mgt);
1321 : 0 : *disp_mgt = NULL;
1322 : : }
1323 : :
1324 : 0 : static void nbl_disp_remove_ops(struct nbl_dispatch_ops_tbl **disp_ops_tbl)
1325 : : {
1326 : 0 : free(NBL_DISP_OPS_TBL_TO_OPS(*disp_ops_tbl));
1327 : 0 : free(*disp_ops_tbl);
1328 : 0 : *disp_ops_tbl = NULL;
1329 : 0 : }
1330 : :
1331 : 0 : static int nbl_disp_setup_ops(struct nbl_dispatch_ops_tbl **disp_ops_tbl,
1332 : : struct nbl_dispatch_mgt *disp_mgt)
1333 : : {
1334 : : struct nbl_dispatch_ops *disp_ops;
1335 : :
1336 : 0 : *disp_ops_tbl = calloc(1, sizeof(struct nbl_dispatch_ops_tbl));
1337 [ # # ]: 0 : if (!*disp_ops_tbl)
1338 : : return -ENOMEM;
1339 : :
1340 : 0 : disp_ops = calloc(1, sizeof(struct nbl_dispatch_ops));
1341 [ # # ]: 0 : if (!disp_ops) {
1342 : 0 : free(*disp_ops_tbl);
1343 : 0 : return -ENOMEM;
1344 : : }
1345 : :
1346 : 0 : NBL_DISP_OPS_TBL_TO_OPS(*disp_ops_tbl) = disp_ops;
1347 : 0 : NBL_DISP_OPS_TBL_TO_PRIV(*disp_ops_tbl) = disp_mgt;
1348 : :
1349 : 0 : return 0;
1350 : : }
1351 : :
1352 : 0 : int nbl_disp_init(void *p)
1353 : : {
1354 : : struct nbl_adapter *adapter = (struct nbl_adapter *)p;
1355 : : struct nbl_dispatch_mgt **disp_mgt;
1356 : : struct nbl_dispatch_ops_tbl **disp_ops_tbl;
1357 : : struct nbl_resource_ops_tbl *res_ops_tbl;
1358 : : struct nbl_channel_ops_tbl *chan_ops_tbl;
1359 : : struct nbl_product_dispatch_ops *disp_product_ops = NULL;
1360 : : int ret = 0;
1361 : :
1362 : : disp_mgt = (struct nbl_dispatch_mgt **)&NBL_ADAPTER_TO_DISP_MGT(adapter);
1363 : 0 : disp_ops_tbl = &NBL_ADAPTER_TO_DISP_OPS_TBL(adapter);
1364 : 0 : res_ops_tbl = NBL_ADAPTER_TO_RES_OPS_TBL(adapter);
1365 : 0 : chan_ops_tbl = NBL_ADAPTER_TO_CHAN_OPS_TBL(adapter);
1366 : 0 : disp_product_ops = nbl_dispatch_get_product_ops(adapter->caps.product_type);
1367 : :
1368 : : ret = nbl_disp_setup_disp_mgt(disp_mgt);
1369 : : if (ret)
1370 : : return ret;
1371 : :
1372 : 0 : ret = nbl_disp_setup_ops(disp_ops_tbl, *disp_mgt);
1373 [ # # ]: 0 : if (ret)
1374 : 0 : goto setup_ops_fail;
1375 : :
1376 : 0 : NBL_DISP_MGT_TO_RES_OPS_TBL(*disp_mgt) = res_ops_tbl;
1377 : 0 : NBL_DISP_MGT_TO_CHAN_OPS_TBL(*disp_mgt) = chan_ops_tbl;
1378 : 0 : NBL_DISP_MGT_TO_DISP_OPS_TBL(*disp_mgt) = *disp_ops_tbl;
1379 : 0 : NBL_DISP_MGT_TO_COMMON(*disp_mgt) = NBL_ADAPTER_TO_COMMON(adapter);
1380 : :
1381 [ # # ]: 0 : if (disp_product_ops->dispatch_init) {
1382 : 0 : ret = disp_product_ops->dispatch_init(*disp_mgt);
1383 [ # # ]: 0 : if (ret)
1384 : 0 : goto dispatch_init_fail;
1385 : : }
1386 : :
1387 : 0 : ret = nbl_disp_setup_ctrl_lvl(*disp_mgt, NBL_DISP_CTRL_LVL_ALWAYS);
1388 [ # # ]: 0 : if (ret)
1389 : 0 : goto setup_ctrl_lvl_fail;
1390 : : return 0;
1391 : :
1392 : : setup_ctrl_lvl_fail:
1393 : 0 : disp_product_ops->dispatch_uninit(*disp_mgt);
1394 : 0 : dispatch_init_fail:
1395 : 0 : nbl_disp_remove_ops(disp_ops_tbl);
1396 : 0 : setup_ops_fail:
1397 : : nbl_disp_remove_disp_mgt(disp_mgt);
1398 : :
1399 : 0 : return ret;
1400 : : }
1401 : :
1402 : 0 : void nbl_disp_remove(void *p)
1403 : : {
1404 : : struct nbl_adapter *adapter = (struct nbl_adapter *)p;
1405 : : struct nbl_dispatch_mgt **disp_mgt;
1406 : : struct nbl_dispatch_ops_tbl **disp_ops_tbl;
1407 : :
1408 : : disp_mgt = (struct nbl_dispatch_mgt **)&NBL_ADAPTER_TO_DISP_MGT(adapter);
1409 : 0 : disp_ops_tbl = &NBL_ADAPTER_TO_DISP_OPS_TBL(adapter);
1410 : :
1411 : 0 : nbl_disp_remove_ops(disp_ops_tbl);
1412 : : nbl_disp_remove_disp_mgt(disp_mgt);
1413 : 0 : }
1414 : :
1415 : 0 : static int nbl_disp_leonis_init(void *p)
1416 : : {
1417 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)p;
1418 : : int ret;
1419 : :
1420 : 0 : nbl_disp_setup_ctrl_lvl(disp_mgt, NBL_DISP_CTRL_LVL_NET);
1421 : 0 : ret = nbl_disp_setup_msg(disp_mgt);
1422 : :
1423 : 0 : return ret;
1424 : : }
1425 : :
1426 : 0 : static int nbl_disp_leonis_uninit(void *p)
1427 : : {
1428 : : RTE_SET_USED(p);
1429 : 0 : return 0;
1430 : : }
1431 : :
1432 : : static struct nbl_product_dispatch_ops nbl_product_dispatch_ops[NBL_PRODUCT_MAX] = {
1433 : : {
1434 : : .dispatch_init = nbl_disp_leonis_init,
1435 : : .dispatch_uninit = nbl_disp_leonis_uninit,
1436 : : },
1437 : : };
1438 : :
1439 : 0 : struct nbl_product_dispatch_ops *nbl_dispatch_get_product_ops(enum nbl_product_type product_type)
1440 : : {
1441 : 0 : return &nbl_product_dispatch_ops[product_type];
1442 : : }
|
