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_dsch(void *priv, u16 vsi_id, bool vld)
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 : :
706 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->cfg_dsch, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, vld));
707 : : }
708 : :
709 : 0 : static int nbl_disp_chan_cfg_dsch_req(void *priv, u16 vsi_id, bool vld)
710 : : {
711 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
712 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
713 : 0 : struct nbl_chan_param_cfg_dsch param = {0};
714 : : struct nbl_chan_send_info chan_send;
715 : :
716 : 0 : param.vsi_id = vsi_id;
717 : 0 : param.vld = vld;
718 : :
719 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_CFG_DSCH, ¶m, sizeof(param), NULL, 0, 1);
720 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
721 : : }
722 : :
723 : 0 : static int nbl_disp_setup_cqs(void *priv, u16 vsi_id, u16 real_qps, bool rss_indir_set)
724 : : {
725 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
726 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
727 : :
728 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->setup_cqs,
729 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, real_qps, rss_indir_set));
730 : : }
731 : :
732 : 0 : static int nbl_disp_chan_setup_cqs_req(void *priv, u16 vsi_id, u16 real_qps, bool rss_indir_set)
733 : : {
734 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
735 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
736 : 0 : struct nbl_chan_param_setup_cqs param = {0};
737 : : struct nbl_chan_send_info chan_send;
738 : :
739 : 0 : param.vsi_id = vsi_id;
740 : 0 : param.real_qps = real_qps;
741 : 0 : param.rss_indir_set = rss_indir_set;
742 : :
743 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_SETUP_CQS, ¶m, sizeof(param), NULL, 0, 1);
744 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
745 : : }
746 : :
747 : 0 : static void nbl_disp_remove_cqs(void *priv, u16 vsi_id)
748 : : {
749 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
750 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
751 : :
752 [ # # ]: 0 : NBL_OPS_CALL(res_ops->remove_cqs, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
753 : 0 : }
754 : :
755 : 0 : static void nbl_disp_chan_remove_cqs_req(void *priv, u16 vsi_id)
756 : : {
757 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
758 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
759 : : struct nbl_chan_param_remove_cqs param = {0};
760 : : struct nbl_chan_send_info chan_send;
761 : :
762 : 0 : param.vsi_id = vsi_id;
763 : :
764 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REMOVE_CQS, ¶m, sizeof(param), NULL, 0, 1);
765 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
766 : 0 : }
767 : :
768 : 0 : static void nbl_disp_get_res_pt_ops(void *priv, struct nbl_resource_pt_ops *pt_ops, bool offload)
769 : : {
770 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
771 : : struct nbl_resource_ops *res_ops;
772 : :
773 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
774 [ # # ]: 0 : NBL_OPS_CALL(res_ops->get_resource_pt_ops,
775 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), pt_ops, offload));
776 : 0 : }
777 : :
778 : 0 : static void nbl_disp_get_link_state(void *priv, u8 eth_id, struct nbl_eth_link_info *eth_link_info)
779 : : {
780 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
781 : : struct nbl_resource_ops *res_ops;
782 : :
783 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
784 : :
785 : : /* if do not have res_ops->get_link_state(), default eth is up */
786 [ # # ]: 0 : if (res_ops->get_link_state) {
787 : 0 : res_ops->get_link_state(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
788 : : eth_id, eth_link_info);
789 : : } else {
790 : 0 : eth_link_info->link_status = 1;
791 : 0 : eth_link_info->link_speed = RTE_ETH_LINK_SPEED_25G;
792 : : }
793 : 0 : }
794 : :
795 : 0 : static void nbl_disp_chan_get_link_state_req(void *priv, u8 eth_id,
796 : : struct nbl_eth_link_info *eth_link_info)
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_get_link_state param = {0};
801 : : struct nbl_chan_send_info chan_send;
802 : :
803 : 0 : param.eth_id = eth_id;
804 : :
805 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_LINK_STATE, ¶m, sizeof(param),
806 : : eth_link_info, sizeof(*eth_link_info), 1);
807 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
808 : 0 : }
809 : :
810 : 0 : static int nbl_disp_get_stats(void *priv, struct rte_eth_stats *rte_stats,
811 : : struct eth_queue_stats *qstats)
812 : : {
813 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
814 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
815 : :
816 : 0 : return res_ops->get_stats(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), rte_stats, qstats);
817 : : }
818 : :
819 : 0 : static int nbl_disp_get_uvn_pkt_drop_stats(void *priv, u16 vsi_id,
820 : : u16 num_queues, u32 *uvn_stat_pkt_drop)
821 : : {
822 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
823 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
824 : : int ret = 0;
825 : :
826 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->get_uvn_pkt_drop_stats,
827 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
828 : : vsi_id, num_queues, uvn_stat_pkt_drop));
829 : 0 : return ret;
830 : : }
831 : :
832 : 0 : static int nbl_disp_chan_get_uvn_pkt_drop_stats_req(void *priv, u16 vsi_id,
833 : : u16 num_queues, u32 *uvn_stat_pkt_drop)
834 : : {
835 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
836 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
837 : : struct nbl_chan_param_get_uvn_pkt_drop_stats param = {0};
838 : 0 : struct nbl_chan_send_info chan_send = {0};
839 : :
840 : 0 : param.vsi_id = vsi_id;
841 : 0 : param.num_queues = num_queues;
842 : :
843 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_GET_UVN_PKT_DROP_STATS,
844 : : ¶m, sizeof(param),
845 : : uvn_stat_pkt_drop, num_queues * sizeof(*uvn_stat_pkt_drop), 1);
846 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
847 : : }
848 : :
849 : 0 : static int nbl_disp_get_ustore_total_pkt_drop_stats(void *priv, u8 eth_id,
850 : : struct nbl_ustore_stats *ustore_stats)
851 : : {
852 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
853 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
854 : : int ret = 0;
855 : :
856 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->get_ustore_total_pkt_drop_stats,
857 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), eth_id, ustore_stats));
858 : 0 : return ret;
859 : : }
860 : :
861 : 0 : static int nbl_disp_chan_get_ustore_total_pkt_drop_stats_req(void *priv, u8 eth_id,
862 : : struct nbl_ustore_stats *ustore_stats)
863 : : {
864 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
865 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
866 : 0 : struct nbl_chan_send_info chan_send = {0};
867 : :
868 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_GET_USTORE_TOTAL_PKT_DROP_STATS,
869 : : ð_id, sizeof(eth_id), ustore_stats, sizeof(*ustore_stats), 1);
870 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
871 : : }
872 : :
873 : 0 : static int nbl_disp_reset_stats(void *priv)
874 : : {
875 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
876 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
877 : :
878 : 0 : return res_ops->reset_stats(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt));
879 : : }
880 : :
881 : 0 : static int nbl_disp_get_txrx_xstats_cnt(void *priv, u16 *xstats_cnt)
882 : : {
883 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
884 : : struct nbl_resource_ops *res_ops;
885 : :
886 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
887 : 0 : return res_ops->get_txrx_xstats_cnt(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), xstats_cnt);
888 : : }
889 : :
890 : 0 : static int nbl_disp_get_txrx_xstats(void *priv, struct rte_eth_xstat *xstats,
891 : : u16 need_xstats_cnt, u16 *xstats_cnt)
892 : : {
893 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
894 : : struct nbl_resource_ops *res_ops;
895 : :
896 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
897 : 0 : return res_ops->get_txrx_xstats(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), xstats,
898 : : need_xstats_cnt, xstats_cnt);
899 : : }
900 : :
901 : 0 : static int nbl_disp_get_txrx_xstats_names(void *priv, struct rte_eth_xstat_name *xstats_names,
902 : : u16 need_xstats_cnt, u16 *xstats_cnt)
903 : : {
904 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
905 : : struct nbl_resource_ops *res_ops;
906 : :
907 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
908 : 0 : return res_ops->get_txrx_xstats_names(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
909 : : xstats_names, need_xstats_cnt, xstats_cnt);
910 : : }
911 : :
912 : 0 : static int nbl_disp_get_hw_xstats_cnt(void *priv, u16 *xstats_cnt)
913 : : {
914 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
915 : : struct nbl_resource_ops *res_ops;
916 : :
917 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
918 : 0 : return res_ops->get_hw_xstats_cnt(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), xstats_cnt);
919 : : }
920 : :
921 : 0 : static int nbl_disp_get_hw_xstats_names(void *priv, struct rte_eth_xstat_name *xstats_names,
922 : : u16 need_xstats_cnt, 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_hw_xstats_names(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
929 : : xstats_names, need_xstats_cnt, xstats_cnt);
930 : : }
931 : :
932 : 0 : static void nbl_disp_get_private_stat_data(void *priv, u32 eth_id, u64 *data,
933 : : __rte_unused u32 data_len)
934 : : {
935 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
936 : : struct nbl_resource_ops *res_ops;
937 : :
938 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
939 [ # # ]: 0 : NBL_OPS_CALL(res_ops->get_private_stat_data,
940 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), eth_id, data));
941 : 0 : }
942 : :
943 : 0 : static void nbl_disp_get_private_stat_data_req(void *priv, u32 eth_id, u64 *data, u32 data_len)
944 : : {
945 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
946 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
947 : 0 : struct nbl_chan_send_info chan_send = {0};
948 : : struct nbl_chan_param_get_private_stat_data param = {0};
949 : :
950 : 0 : param.eth_id = eth_id;
951 : 0 : param.data_len = data_len;
952 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_ETH_STATS, ¶m,
953 : : sizeof(param), data, data_len, 1);
954 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
955 : 0 : }
956 : :
957 : 0 : static int nbl_disp_set_mtu(void *priv, u16 vsi_id, u16 mtu)
958 : : {
959 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
960 : : struct nbl_resource_ops *res_ops;
961 : : int ret = 0;
962 : :
963 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
964 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->set_mtu, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, mtu));
965 : 0 : return ret;
966 : : }
967 : :
968 : 0 : static int nbl_disp_chan_set_mtu_req(void *priv, u16 vsi_id, u16 mtu)
969 : : {
970 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
971 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
972 : 0 : struct nbl_chan_send_info chan_send = {0};
973 : : struct nbl_chan_param_set_mtu param = {0};
974 : :
975 : 0 : param.mtu = mtu;
976 : 0 : param.vsi_id = vsi_id;
977 : :
978 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_MTU_SET,
979 : : ¶m, sizeof(param), NULL, 0, 1);
980 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt),
981 : : &chan_send);
982 : : }
983 : :
984 : 0 : static int nbl_disp_set_promisc_mode(void *priv, u16 vsi_id, u16 mode)
985 : : {
986 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
987 : : struct nbl_resource_ops *res_ops;
988 : : int ret = 0;
989 : :
990 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
991 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->set_promisc_mode,
992 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, mode));
993 : 0 : return ret;
994 : : }
995 : :
996 : 0 : static int nbl_disp_chan_set_promisc_mode_req(void *priv, u16 vsi_id, u16 mode)
997 : : {
998 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
999 : : struct nbl_common_info *common;
1000 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
1001 : 0 : struct nbl_chan_param_set_promisc_mode param = {0};
1002 : 0 : struct nbl_chan_send_info chan_send = {0};
1003 : : int ret = 0;
1004 : :
1005 : 0 : common = NBL_DISP_MGT_TO_COMMON(disp_mgt);
1006 [ # # ]: 0 : if (NBL_IS_COEXISTENCE(common)) {
1007 : 0 : ret = ioctl(common->devfd, NBL_DEV_USER_SET_PROMISC_MODE, &mode);
1008 [ # # ]: 0 : if (ret) {
1009 : 0 : NBL_LOG(ERR, "userspace send set_promisc_mode ioctl msg failed ret %d",
1010 : : ret);
1011 : 0 : return ret;
1012 : : }
1013 : : return 0;
1014 : : }
1015 : :
1016 : 0 : param.vsi_id = vsi_id;
1017 : 0 : param.mode = mode;
1018 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_SET_PROSISC_MODE,
1019 : : ¶m, sizeof(param), NULL, 0, 1);
1020 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt),
1021 : : &chan_send);
1022 : : }
1023 : :
1024 : : #define NBL_DISP_OPS_TBL \
1025 : : do { \
1026 : : NBL_DISP_SET_OPS(configure_msix_map, nbl_disp_configure_msix_map, \
1027 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_CONFIGURE_MSIX_MAP, \
1028 : : nbl_disp_chan_configure_msix_map_req, \
1029 : : NULL); \
1030 : : NBL_DISP_SET_OPS(destroy_msix_map, nbl_disp_destroy_msix_map, \
1031 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_DESTROY_MSIX_MAP, \
1032 : : nbl_disp_chan_destroy_msix_map_req, \
1033 : : NULL); \
1034 : : NBL_DISP_SET_OPS(enable_mailbox_irq, nbl_disp_enable_mailbox_irq, \
1035 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_MAILBOX_ENABLE_IRQ, \
1036 : : nbl_disp_chan_enable_mailbox_irq_req, \
1037 : : NULL); \
1038 : : NBL_DISP_SET_OPS(alloc_txrx_queues, nbl_disp_alloc_txrx_queues, \
1039 : : NBL_DISP_CTRL_LVL_MGT, \
1040 : : NBL_CHAN_MSG_ALLOC_TXRX_QUEUES, \
1041 : : nbl_disp_chan_alloc_txrx_queues_req, \
1042 : : NULL); \
1043 : : NBL_DISP_SET_OPS(free_txrx_queues, nbl_disp_free_txrx_queues, \
1044 : : NBL_DISP_CTRL_LVL_MGT, \
1045 : : NBL_CHAN_MSG_FREE_TXRX_QUEUES, \
1046 : : nbl_disp_chan_free_txrx_queues_req, \
1047 : : NULL); \
1048 : : NBL_DISP_SET_OPS(alloc_rings, nbl_disp_alloc_rings, \
1049 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1050 : : NULL, NULL); \
1051 : : NBL_DISP_SET_OPS(remove_rings, nbl_disp_remove_rings, \
1052 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1053 : : NULL, NULL); \
1054 : : NBL_DISP_SET_OPS(start_tx_ring, nbl_disp_start_tx_ring, \
1055 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1056 : : NBL_DISP_SET_OPS(stop_tx_ring, nbl_disp_stop_tx_ring, \
1057 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1058 : : NBL_DISP_SET_OPS(release_tx_ring, nbl_disp_release_tx_ring, \
1059 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1060 : : NBL_DISP_SET_OPS(start_rx_ring, nbl_disp_start_rx_ring, \
1061 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1062 : : NBL_DISP_SET_OPS(alloc_rx_bufs, nbl_disp_alloc_rx_bufs, \
1063 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1064 : : NBL_DISP_SET_OPS(stop_rx_ring, nbl_disp_stop_rx_ring, \
1065 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1066 : : NBL_DISP_SET_OPS(release_rx_ring, nbl_disp_release_rx_ring, \
1067 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1068 : : NBL_DISP_SET_OPS(update_rx_ring, nbl_disp_update_rx_ring, \
1069 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1070 : : NULL, NULL); \
1071 : : NBL_DISP_SET_OPS(setup_queue, nbl_disp_setup_queue, \
1072 : : NBL_DISP_CTRL_LVL_MGT, \
1073 : : NBL_CHAN_MSG_SETUP_QUEUE, \
1074 : : nbl_disp_chan_setup_queue_req, NULL); \
1075 : : NBL_DISP_SET_OPS(remove_all_queues, nbl_disp_remove_all_queues, \
1076 : : NBL_DISP_CTRL_LVL_MGT, \
1077 : : NBL_CHAN_MSG_REMOVE_ALL_QUEUES, \
1078 : : nbl_disp_chan_remove_all_queues_req, NULL); \
1079 : : NBL_DISP_SET_OPS(clear_queues, nbl_disp_clear_queues, \
1080 : : NBL_DISP_CTRL_LVL_MGT, \
1081 : : NBL_CHAN_MSG_CLEAR_QUEUE, \
1082 : : nbl_disp_chan_clear_queues_req, NULL); \
1083 : : NBL_DISP_SET_OPS(get_mac_addr, nbl_disp_get_mac_addr, \
1084 : : NBL_DISP_CTRL_LVL_MGT, \
1085 : : -1, nbl_disp_get_mac_addr_req, NULL); \
1086 : : NBL_DISP_SET_OPS(register_net, nbl_disp_register_net, \
1087 : : NBL_DISP_CTRL_LVL_MGT, \
1088 : : NBL_CHAN_MSG_REGISTER_NET, \
1089 : : nbl_disp_chan_register_net_req, \
1090 : : NULL); \
1091 : : NBL_DISP_SET_OPS(unregister_net, nbl_disp_unregister_net, \
1092 : : NBL_DISP_CTRL_LVL_MGT, \
1093 : : NBL_CHAN_MSG_UNREGISTER_NET, \
1094 : : nbl_disp_chan_unregister_net_req, NULL); \
1095 : : NBL_DISP_SET_OPS(get_vsi_id, nbl_disp_get_vsi_id, \
1096 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_GET_VSI_ID,\
1097 : : nbl_disp_chan_get_vsi_id_req, NULL); \
1098 : : NBL_DISP_SET_OPS(get_eth_id, nbl_disp_get_eth_id, \
1099 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_GET_ETH_ID,\
1100 : : nbl_disp_chan_get_eth_id_req, NULL); \
1101 : : NBL_DISP_SET_OPS(get_vsi_global_qid, \
1102 : : nbl_disp_get_vsi_global_qid, \
1103 : : NBL_DISP_CTRL_LVL_MGT, \
1104 : : NBL_CHAN_MSG_GET_VSI_GLOBAL_QUEUE_ID, \
1105 : : nbl_disp_chan_get_vsi_global_qid_req, NULL); \
1106 : : NBL_DISP_SET_OPS(setup_q2vsi, nbl_disp_chan_setup_q2vsi, \
1107 : : NBL_DISP_CTRL_LVL_MGT, \
1108 : : NBL_CHAN_MSG_SETUP_Q2VSI, \
1109 : : nbl_disp_chan_setup_q2vsi_req, NULL); \
1110 : : NBL_DISP_SET_OPS(remove_q2vsi, nbl_disp_chan_remove_q2vsi, \
1111 : : NBL_DISP_CTRL_LVL_MGT, \
1112 : : NBL_CHAN_MSG_REMOVE_Q2VSI, \
1113 : : nbl_disp_chan_remove_q2vsi_req, NULL); \
1114 : : NBL_DISP_SET_OPS(register_vsi2q, nbl_disp_chan_register_vsi2q, \
1115 : : NBL_DISP_CTRL_LVL_MGT, \
1116 : : NBL_CHAN_MSG_REGISTER_VSI2Q, \
1117 : : nbl_disp_chan_register_vsi2q_req, NULL); \
1118 : : NBL_DISP_SET_OPS(setup_rss, nbl_disp_chan_setup_rss, \
1119 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_SETUP_RSS, \
1120 : : nbl_disp_chan_setup_rss_req, NULL); \
1121 : : NBL_DISP_SET_OPS(remove_rss, nbl_disp_chan_remove_rss, \
1122 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_REMOVE_RSS,\
1123 : : nbl_disp_chan_remove_rss_req, NULL); \
1124 : : NBL_DISP_SET_OPS(get_board_info, nbl_disp_chan_get_board_info, \
1125 : : NBL_DISP_CTRL_LVL_MGT, \
1126 : : NBL_CHAN_MSG_GET_BOARD_INFO, \
1127 : : nbl_disp_chan_get_board_info_req, NULL); \
1128 : : NBL_DISP_SET_OPS(clear_flow, nbl_disp_clear_flow, \
1129 : : NBL_DISP_CTRL_LVL_MGT, \
1130 : : NBL_CHAN_MSG_CLEAR_FLOW, \
1131 : : nbl_disp_chan_clear_flow_req, NULL); \
1132 : : NBL_DISP_SET_OPS(add_macvlan, nbl_disp_add_macvlan, \
1133 : : NBL_DISP_CTRL_LVL_MGT, \
1134 : : NBL_CHAN_MSG_ADD_MACVLAN, \
1135 : : nbl_disp_chan_add_macvlan_req, NULL); \
1136 : : NBL_DISP_SET_OPS(del_macvlan, nbl_disp_del_macvlan, \
1137 : : NBL_DISP_CTRL_LVL_MGT, \
1138 : : NBL_CHAN_MSG_DEL_MACVLAN, \
1139 : : nbl_disp_chan_del_macvlan_req, NULL); \
1140 : : NBL_DISP_SET_OPS(add_multi_rule, nbl_disp_add_multi_rule, \
1141 : : NBL_DISP_CTRL_LVL_MGT, \
1142 : : NBL_CHAN_MSG_ADD_MULTI_RULE, \
1143 : : nbl_disp_chan_add_multi_rule_req, NULL); \
1144 : : NBL_DISP_SET_OPS(del_multi_rule, nbl_disp_del_multi_rule, \
1145 : : NBL_DISP_CTRL_LVL_MGT, \
1146 : : NBL_CHAN_MSG_DEL_MULTI_RULE, \
1147 : : nbl_disp_chan_del_multi_rule_req, NULL); \
1148 : : NBL_DISP_SET_OPS(cfg_dsch, nbl_disp_cfg_dsch, \
1149 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_CFG_DSCH, \
1150 : : nbl_disp_chan_cfg_dsch_req, NULL); \
1151 : : NBL_DISP_SET_OPS(setup_cqs, nbl_disp_setup_cqs, \
1152 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_SETUP_CQS, \
1153 : : nbl_disp_chan_setup_cqs_req, NULL); \
1154 : : NBL_DISP_SET_OPS(remove_cqs, nbl_disp_remove_cqs, \
1155 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_REMOVE_CQS,\
1156 : : nbl_disp_chan_remove_cqs_req, NULL); \
1157 : : NBL_DISP_SET_OPS(get_resource_pt_ops, \
1158 : : nbl_disp_get_res_pt_ops, \
1159 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1160 : : NULL, NULL); \
1161 : : NBL_DISP_SET_OPS(get_link_state, nbl_disp_get_link_state, \
1162 : : NBL_DISP_CTRL_LVL_MGT, \
1163 : : NBL_CHAN_MSG_GET_LINK_STATE, \
1164 : : nbl_disp_chan_get_link_state_req, NULL); \
1165 : : NBL_DISP_SET_OPS(get_stats, nbl_disp_get_stats, \
1166 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1167 : : NULL, NULL); \
1168 : : NBL_DISP_SET_OPS(get_uvn_pkt_drop_stats, \
1169 : : nbl_disp_get_uvn_pkt_drop_stats, \
1170 : : NBL_DISP_CTRL_LVL_MGT, \
1171 : : NBL_CHAN_GET_UVN_PKT_DROP_STATS, \
1172 : : nbl_disp_chan_get_uvn_pkt_drop_stats_req, NULL);\
1173 : : NBL_DISP_SET_OPS(get_ustore_total_pkt_drop_stats, \
1174 : : nbl_disp_get_ustore_total_pkt_drop_stats, \
1175 : : NBL_DISP_CTRL_LVL_MGT, \
1176 : : NBL_CHAN_GET_USTORE_TOTAL_PKT_DROP_STATS, \
1177 : : nbl_disp_chan_get_ustore_total_pkt_drop_stats_req,\
1178 : : NULL); \
1179 : : NBL_DISP_SET_OPS(reset_stats, nbl_disp_reset_stats, \
1180 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1181 : : NULL, NULL); \
1182 : : NBL_DISP_SET_OPS(get_txrx_xstats_cnt, \
1183 : : nbl_disp_get_txrx_xstats_cnt, \
1184 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1185 : : NULL, NULL); \
1186 : : NBL_DISP_SET_OPS(get_txrx_xstats, nbl_disp_get_txrx_xstats, \
1187 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1188 : : NULL, NULL); \
1189 : : NBL_DISP_SET_OPS(get_txrx_xstats_names, \
1190 : : nbl_disp_get_txrx_xstats_names, \
1191 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1192 : : NULL, NULL); \
1193 : : NBL_DISP_SET_OPS(get_hw_xstats_cnt, nbl_disp_get_hw_xstats_cnt, \
1194 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1195 : : NULL, NULL); \
1196 : : NBL_DISP_SET_OPS(get_hw_xstats_names, \
1197 : : nbl_disp_get_hw_xstats_names, \
1198 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1199 : : NULL, NULL); \
1200 : : NBL_DISP_SET_OPS(get_private_stat_data, \
1201 : : nbl_disp_get_private_stat_data, \
1202 : : NBL_DISP_CTRL_LVL_MGT, \
1203 : : NBL_CHAN_MSG_GET_ETH_STATS, \
1204 : : nbl_disp_get_private_stat_data_req, NULL); \
1205 : : NBL_DISP_SET_OPS(set_promisc_mode, nbl_disp_set_promisc_mode, \
1206 : : NBL_DISP_CTRL_LVL_MGT, \
1207 : : NBL_CHAN_MSG_SET_PROSISC_MODE, \
1208 : : nbl_disp_chan_set_promisc_mode_req, NULL); \
1209 : : NBL_DISP_SET_OPS(set_mtu, nbl_disp_set_mtu, \
1210 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_MTU_SET, \
1211 : : nbl_disp_chan_set_mtu_req, \
1212 : : NULL); \
1213 : : } while (0)
1214 : :
1215 : : /* Structure starts here, adding an op should not modify anything below */
1216 : 0 : static int nbl_disp_setup_msg(struct nbl_dispatch_mgt *disp_mgt)
1217 : : {
1218 : : struct nbl_dispatch_ops *disp_ops = NBL_DISP_MGT_TO_DISP_OPS(disp_mgt);
1219 : : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
1220 : : int ret = 0;
1221 : :
1222 : : #define NBL_DISP_SET_OPS(disp_op, res_func, ctrl_lvl2, msg_type, msg_req, msg_resp) \
1223 : : do { \
1224 : : typeof(msg_type) _msg_type = (msg_type); \
1225 : : typeof(msg_resp) _msg_resp = (msg_resp); \
1226 : : RTE_SET_USED(disp_ops->NBL_NAME(disp_op)); \
1227 : : RTE_SET_USED(res_func); \
1228 : : RTE_SET_USED(msg_req); \
1229 : : uint32_t _ctrl_lvl = rte_bit_relaxed_get32(ctrl_lvl2, &disp_mgt->ctrl_lvl); \
1230 : : if (_msg_type >= 0 && _msg_resp != NULL && _ctrl_lvl) \
1231 : : ret += chan_ops->register_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), \
1232 : : _msg_type, _msg_resp, disp_mgt); \
1233 : : } while (0)
1234 : : NBL_DISP_OPS_TBL;
1235 : : #undef NBL_DISP_SET_OPS
1236 : :
1237 : 0 : return ret;
1238 : : }
1239 : :
1240 : : /* Ctrl lvl means that if a certain level is set, then all disp_ops that declared this lvl
1241 : : * will go directly to res_ops, rather than send a channel msg, and vice versa.
1242 : : */
1243 : 0 : static int nbl_disp_setup_ctrl_lvl(struct nbl_dispatch_mgt *disp_mgt, u32 lvl)
1244 : : {
1245 [ # # ]: 0 : struct nbl_dispatch_ops *disp_ops = NBL_DISP_MGT_TO_DISP_OPS(disp_mgt);
1246 : :
1247 : : rte_bit_relaxed_set32(lvl, &disp_mgt->ctrl_lvl);
1248 : :
1249 : : #define NBL_DISP_SET_OPS(disp_op, res_func, ctrl, msg_type, msg_req, msg_resp) \
1250 : : do { \
1251 : : typeof(msg_type) _msg_type = (msg_type); \
1252 : : typeof(msg_resp) _msg_resp = (msg_resp); \
1253 : : RTE_SET_USED(_msg_type); \
1254 : : RTE_SET_USED(_msg_resp); \
1255 : : disp_ops->NBL_NAME(disp_op) = \
1256 : : rte_bit_relaxed_get32(ctrl, &disp_mgt->ctrl_lvl) ? res_func : msg_req; ;\
1257 : : } while (0)
1258 [ # # # # : 0 : NBL_DISP_OPS_TBL;
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # #
# ]
1259 : : #undef NBL_DISP_SET_OPS
1260 : :
1261 : 0 : return 0;
1262 : : }
1263 : :
1264 : : static int nbl_disp_setup_disp_mgt(struct nbl_dispatch_mgt **disp_mgt)
1265 : : {
1266 : 0 : *disp_mgt = rte_zmalloc("nbl_disp_mgt", sizeof(struct nbl_dispatch_mgt), 0);
1267 [ # # ]: 0 : if (!*disp_mgt)
1268 : : return -ENOMEM;
1269 : :
1270 : : return 0;
1271 : : }
1272 : :
1273 : : static void nbl_disp_remove_disp_mgt(struct nbl_dispatch_mgt **disp_mgt)
1274 : : {
1275 : 0 : rte_free(*disp_mgt);
1276 : 0 : *disp_mgt = NULL;
1277 : : }
1278 : :
1279 : 0 : static void nbl_disp_remove_ops(struct nbl_dispatch_ops_tbl **disp_ops_tbl)
1280 : : {
1281 : 0 : free(NBL_DISP_OPS_TBL_TO_OPS(*disp_ops_tbl));
1282 : 0 : free(*disp_ops_tbl);
1283 : 0 : *disp_ops_tbl = NULL;
1284 : 0 : }
1285 : :
1286 : 0 : static int nbl_disp_setup_ops(struct nbl_dispatch_ops_tbl **disp_ops_tbl,
1287 : : struct nbl_dispatch_mgt *disp_mgt)
1288 : : {
1289 : : struct nbl_dispatch_ops *disp_ops;
1290 : :
1291 : 0 : *disp_ops_tbl = calloc(1, sizeof(struct nbl_dispatch_ops_tbl));
1292 [ # # ]: 0 : if (!*disp_ops_tbl)
1293 : : return -ENOMEM;
1294 : :
1295 : 0 : disp_ops = calloc(1, sizeof(struct nbl_dispatch_ops));
1296 [ # # ]: 0 : if (!disp_ops) {
1297 : 0 : free(*disp_ops_tbl);
1298 : 0 : return -ENOMEM;
1299 : : }
1300 : :
1301 : 0 : NBL_DISP_OPS_TBL_TO_OPS(*disp_ops_tbl) = disp_ops;
1302 : 0 : NBL_DISP_OPS_TBL_TO_PRIV(*disp_ops_tbl) = disp_mgt;
1303 : :
1304 : 0 : return 0;
1305 : : }
1306 : :
1307 : 0 : int nbl_disp_init(void *p)
1308 : : {
1309 : : struct nbl_adapter *adapter = (struct nbl_adapter *)p;
1310 : : struct nbl_dispatch_mgt **disp_mgt;
1311 : : struct nbl_dispatch_ops_tbl **disp_ops_tbl;
1312 : : struct nbl_resource_ops_tbl *res_ops_tbl;
1313 : : struct nbl_channel_ops_tbl *chan_ops_tbl;
1314 : : struct nbl_product_dispatch_ops *disp_product_ops = NULL;
1315 : : int ret = 0;
1316 : :
1317 : : disp_mgt = (struct nbl_dispatch_mgt **)&NBL_ADAPTER_TO_DISP_MGT(adapter);
1318 : 0 : disp_ops_tbl = &NBL_ADAPTER_TO_DISP_OPS_TBL(adapter);
1319 : 0 : res_ops_tbl = NBL_ADAPTER_TO_RES_OPS_TBL(adapter);
1320 : 0 : chan_ops_tbl = NBL_ADAPTER_TO_CHAN_OPS_TBL(adapter);
1321 : 0 : disp_product_ops = nbl_dispatch_get_product_ops(adapter->caps.product_type);
1322 : :
1323 : : ret = nbl_disp_setup_disp_mgt(disp_mgt);
1324 : : if (ret)
1325 : : return ret;
1326 : :
1327 : 0 : ret = nbl_disp_setup_ops(disp_ops_tbl, *disp_mgt);
1328 [ # # ]: 0 : if (ret)
1329 : 0 : goto setup_ops_fail;
1330 : :
1331 : 0 : NBL_DISP_MGT_TO_RES_OPS_TBL(*disp_mgt) = res_ops_tbl;
1332 : 0 : NBL_DISP_MGT_TO_CHAN_OPS_TBL(*disp_mgt) = chan_ops_tbl;
1333 : 0 : NBL_DISP_MGT_TO_DISP_OPS_TBL(*disp_mgt) = *disp_ops_tbl;
1334 : 0 : NBL_DISP_MGT_TO_COMMON(*disp_mgt) = NBL_ADAPTER_TO_COMMON(adapter);
1335 : :
1336 [ # # ]: 0 : if (disp_product_ops->dispatch_init) {
1337 : 0 : ret = disp_product_ops->dispatch_init(*disp_mgt);
1338 [ # # ]: 0 : if (ret)
1339 : 0 : goto dispatch_init_fail;
1340 : : }
1341 : :
1342 : 0 : ret = nbl_disp_setup_ctrl_lvl(*disp_mgt, NBL_DISP_CTRL_LVL_ALWAYS);
1343 [ # # ]: 0 : if (ret)
1344 : 0 : goto setup_ctrl_lvl_fail;
1345 : : return 0;
1346 : :
1347 : : setup_ctrl_lvl_fail:
1348 : 0 : disp_product_ops->dispatch_uninit(*disp_mgt);
1349 : 0 : dispatch_init_fail:
1350 : 0 : nbl_disp_remove_ops(disp_ops_tbl);
1351 : 0 : setup_ops_fail:
1352 : : nbl_disp_remove_disp_mgt(disp_mgt);
1353 : :
1354 : 0 : return ret;
1355 : : }
1356 : :
1357 : 0 : void nbl_disp_remove(void *p)
1358 : : {
1359 : : struct nbl_adapter *adapter = (struct nbl_adapter *)p;
1360 : : struct nbl_dispatch_mgt **disp_mgt;
1361 : : struct nbl_dispatch_ops_tbl **disp_ops_tbl;
1362 : :
1363 : : disp_mgt = (struct nbl_dispatch_mgt **)&NBL_ADAPTER_TO_DISP_MGT(adapter);
1364 : 0 : disp_ops_tbl = &NBL_ADAPTER_TO_DISP_OPS_TBL(adapter);
1365 : :
1366 : 0 : nbl_disp_remove_ops(disp_ops_tbl);
1367 : : nbl_disp_remove_disp_mgt(disp_mgt);
1368 : 0 : }
1369 : :
1370 : 0 : static int nbl_disp_leonis_init(void *p)
1371 : : {
1372 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)p;
1373 : : int ret;
1374 : :
1375 : 0 : nbl_disp_setup_ctrl_lvl(disp_mgt, NBL_DISP_CTRL_LVL_NET);
1376 : 0 : ret = nbl_disp_setup_msg(disp_mgt);
1377 : :
1378 : 0 : return ret;
1379 : : }
1380 : :
1381 : 0 : static int nbl_disp_leonis_uninit(void *p)
1382 : : {
1383 : : RTE_SET_USED(p);
1384 : 0 : return 0;
1385 : : }
1386 : :
1387 : : static struct nbl_product_dispatch_ops nbl_product_dispatch_ops[NBL_PRODUCT_MAX] = {
1388 : : {
1389 : : .dispatch_init = nbl_disp_leonis_init,
1390 : : .dispatch_uninit = nbl_disp_leonis_uninit,
1391 : : },
1392 : : };
1393 : :
1394 : 0 : struct nbl_product_dispatch_ops *nbl_dispatch_get_product_ops(enum nbl_product_type product_type)
1395 : : {
1396 : 0 : return &nbl_product_dispatch_ops[product_type];
1397 : : }
|
