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 __rte_unused, u8 *mac)
300 : : {
301 : 0 : rte_eth_random_addr(mac);
302 : :
303 : 0 : return 0;
304 : : }
305 : :
306 : 0 : static int nbl_disp_register_net(void *priv,
307 : : struct nbl_register_net_param *register_param,
308 : : struct nbl_register_net_result *register_result)
309 : : {
310 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
311 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
312 : :
313 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->register_net,
314 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), register_param, register_result));
315 : : }
316 : :
317 : 0 : static int nbl_disp_chan_register_net_req(void *priv,
318 : : struct nbl_register_net_param *register_param,
319 : : struct nbl_register_net_result *register_result)
320 : : {
321 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
322 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
323 : 0 : struct nbl_chan_param_register_net_info param = {0};
324 : : struct nbl_chan_send_info chan_send;
325 : : int ret = 0;
326 : :
327 : 0 : param.pf_bar_start = register_param->pf_bar_start;
328 : 0 : param.pf_bdf = register_param->pf_bdf;
329 : 0 : param.vf_bar_start = register_param->vf_bar_start;
330 : 0 : param.vf_bar_size = register_param->vf_bar_size;
331 : 0 : param.total_vfs = register_param->total_vfs;
332 : 0 : param.offset = register_param->offset;
333 : 0 : param.stride = register_param->stride;
334 : :
335 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REGISTER_NET,
336 : : ¶m, sizeof(param),
337 : : (void *)register_result, sizeof(*register_result), 1);
338 : :
339 : 0 : ret = chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
340 : 0 : return ret;
341 : : }
342 : :
343 : 0 : static int nbl_disp_unregister_net(void *priv)
344 : : {
345 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
346 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
347 : :
348 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->unregister_net, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt)));
349 : : }
350 : :
351 : 0 : static int nbl_disp_chan_unregister_net_req(void *priv)
352 : : {
353 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
354 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
355 : : struct nbl_chan_send_info chan_send;
356 : :
357 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_UNREGISTER_NET, NULL,
358 : : 0, NULL, 0, 1);
359 : :
360 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt),
361 : : &chan_send);
362 : : }
363 : :
364 : 0 : static u16 nbl_disp_get_vsi_id(void *priv)
365 : : {
366 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
367 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
368 : :
369 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->get_vsi_id, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt)));
370 : : }
371 : :
372 : 0 : static u16 nbl_disp_chan_get_vsi_id_req(void *priv)
373 : : {
374 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
375 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
376 : 0 : struct nbl_chan_param_get_vsi_id param = {0};
377 : 0 : struct nbl_chan_param_get_vsi_id result = {0};
378 : : struct nbl_chan_send_info chan_send;
379 : :
380 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_VSI_ID, ¶m,
381 : : sizeof(param), &result, sizeof(result), 1);
382 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
383 : :
384 : 0 : return result.vsi_id;
385 : : }
386 : :
387 : 0 : static void nbl_disp_get_eth_id(void *priv, u16 vsi_id, u8 *eth_mode, u8 *eth_id)
388 : : {
389 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
390 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
391 : :
392 [ # # ]: 0 : NBL_OPS_CALL(res_ops->get_eth_id, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
393 : : vsi_id, eth_mode, eth_id));
394 : 0 : }
395 : :
396 : 0 : static void nbl_disp_chan_get_eth_id_req(void *priv, u16 vsi_id, u8 *eth_mode, u8 *eth_id)
397 : : {
398 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
399 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
400 : 0 : struct nbl_chan_param_get_eth_id param = {0};
401 : 0 : struct nbl_chan_param_get_eth_id result = {0};
402 : : struct nbl_chan_send_info chan_send;
403 : :
404 : 0 : param.vsi_id = vsi_id;
405 : :
406 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_ETH_ID, ¶m, sizeof(param),
407 : : &result, sizeof(result), 1);
408 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
409 : :
410 : 0 : *eth_mode = result.eth_mode;
411 : 0 : *eth_id = result.eth_id;
412 : 0 : }
413 : :
414 : 0 : static u16 nbl_disp_get_vsi_global_qid(void *priv, u16 vsi_id, u16 local_qid)
415 : : {
416 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
417 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
418 : :
419 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->get_vsi_global_qid,
420 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, local_qid));
421 : : }
422 : :
423 : : static u16
424 : 0 : nbl_disp_chan_get_vsi_global_qid_req(void *priv, u16 vsi_id, u16 local_qid)
425 : : {
426 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
427 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
428 : : struct nbl_chan_vsi_qid_info param = {0};
429 : : struct nbl_chan_send_info chan_send;
430 : :
431 : 0 : param.vsi_id = vsi_id;
432 : 0 : param.local_qid = local_qid;
433 : :
434 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_VSI_GLOBAL_QUEUE_ID,
435 : : ¶m, sizeof(param), NULL, 0, 1);
436 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
437 : : }
438 : :
439 : 0 : static int nbl_disp_chan_setup_q2vsi(void *priv, u16 vsi_id)
440 : : {
441 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
442 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
443 : :
444 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->setup_q2vsi,
445 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
446 : : }
447 : :
448 : 0 : static int nbl_disp_chan_setup_q2vsi_req(void *priv, u16 vsi_id)
449 : : {
450 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
451 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
452 : : struct nbl_chan_param_cfg_q2vsi param = {0};
453 : : struct nbl_chan_send_info chan_send;
454 : :
455 : 0 : param.vsi_id = vsi_id;
456 : :
457 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_SETUP_Q2VSI, ¶m,
458 : : sizeof(param), NULL, 0, 1);
459 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
460 : : }
461 : :
462 : 0 : static void nbl_disp_chan_remove_q2vsi(void *priv, u16 vsi_id)
463 : : {
464 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
465 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
466 : :
467 [ # # ]: 0 : NBL_OPS_CALL(res_ops->remove_q2vsi,
468 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
469 : 0 : }
470 : :
471 : 0 : static void nbl_disp_chan_remove_q2vsi_req(void *priv, u16 vsi_id)
472 : : {
473 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
474 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
475 : : struct nbl_chan_param_cfg_q2vsi param = {0};
476 : : struct nbl_chan_send_info chan_send;
477 : :
478 : 0 : param.vsi_id = vsi_id;
479 : :
480 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REMOVE_Q2VSI, ¶m,
481 : : sizeof(param), NULL, 0, 1);
482 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
483 : 0 : }
484 : :
485 : 0 : static int nbl_disp_chan_register_vsi2q(void *priv, u16 vsi_index, u16 vsi_id,
486 : : u16 queue_offset, u16 queue_num)
487 : : {
488 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
489 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
490 : :
491 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->register_vsi2q,
492 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_index,
493 : : vsi_id, queue_offset, queue_num));
494 : : }
495 : :
496 : 0 : static int nbl_disp_chan_register_vsi2q_req(void *priv, u16 vsi_index, u16 vsi_id,
497 : : u16 queue_offset, u16 queue_num)
498 : : {
499 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
500 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
501 : : struct nbl_chan_param_register_vsi2q param = {0};
502 : : struct nbl_chan_send_info chan_send;
503 : :
504 : 0 : param.vsi_index = vsi_index;
505 : 0 : param.vsi_id = vsi_id;
506 : 0 : param.queue_offset = queue_offset;
507 : 0 : param.queue_num = queue_num;
508 : :
509 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REGISTER_VSI2Q, ¶m, sizeof(param),
510 : : NULL, 0, 1);
511 : :
512 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
513 : : }
514 : :
515 : 0 : static int nbl_disp_chan_setup_rss(void *priv, u16 vsi_id)
516 : : {
517 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
518 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
519 : :
520 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->setup_rss,
521 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
522 : : }
523 : :
524 : 0 : static int nbl_disp_chan_setup_rss_req(void *priv, u16 vsi_id)
525 : : {
526 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
527 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
528 : : struct nbl_chan_param_cfg_rss param = {0};
529 : : struct nbl_chan_send_info chan_send;
530 : :
531 : 0 : param.vsi_id = vsi_id;
532 : :
533 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_SETUP_RSS, ¶m,
534 : : sizeof(param), NULL, 0, 1);
535 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
536 : : }
537 : :
538 : 0 : static void nbl_disp_chan_remove_rss(void *priv, u16 vsi_id)
539 : : {
540 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
541 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
542 : :
543 [ # # ]: 0 : NBL_OPS_CALL(res_ops->remove_rss,
544 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
545 : 0 : }
546 : :
547 : 0 : static void nbl_disp_chan_remove_rss_req(void *priv, u16 vsi_id)
548 : : {
549 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
550 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
551 : : struct nbl_chan_param_cfg_rss param = {0};
552 : : struct nbl_chan_send_info chan_send;
553 : :
554 : 0 : param.vsi_id = vsi_id;
555 : :
556 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REMOVE_RSS, ¶m,
557 : : sizeof(param), NULL, 0, 1);
558 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
559 : 0 : }
560 : :
561 : 0 : static void nbl_disp_chan_get_board_info(void *priv, struct nbl_board_port_info *board_info)
562 : : {
563 : : RTE_SET_USED(priv);
564 : : RTE_SET_USED(board_info);
565 : 0 : }
566 : :
567 : 0 : static void nbl_disp_chan_get_board_info_req(void *priv, struct nbl_board_port_info *board_info)
568 : : {
569 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
570 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
571 : : struct nbl_chan_send_info chan_send;
572 : :
573 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_BOARD_INFO, NULL,
574 : : 0, board_info, sizeof(*board_info), 1);
575 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
576 : 0 : }
577 : :
578 : 0 : static void nbl_disp_clear_flow(void *priv, u16 vsi_id)
579 : : {
580 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
581 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
582 : :
583 [ # # ]: 0 : NBL_OPS_CALL(res_ops->clear_flow, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
584 : 0 : }
585 : :
586 : 0 : static void nbl_disp_chan_clear_flow_req(void *priv, u16 vsi_id)
587 : : {
588 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
589 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
590 : 0 : struct nbl_chan_send_info chan_send = {0};
591 : :
592 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_CLEAR_FLOW, &vsi_id, sizeof(vsi_id), NULL, 0, 1);
593 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
594 : 0 : }
595 : :
596 : 0 : static int nbl_disp_add_macvlan(void *priv, u8 *mac, u16 vlan_id, u16 vsi_id)
597 : : {
598 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
599 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
600 : :
601 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->add_macvlan,
602 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), mac, vlan_id, vsi_id));
603 : : }
604 : :
605 : : static int
606 : 0 : nbl_disp_chan_add_macvlan_req(void *priv, u8 *mac, u16 vlan_id, u16 vsi_id)
607 : : {
608 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
609 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
610 : 0 : struct nbl_chan_send_info chan_send = {0};
611 : : struct nbl_chan_param_macvlan_cfg param = {0};
612 : :
613 : : memcpy(¶m.mac, mac, sizeof(param.mac));
614 : 0 : param.vlan = vlan_id;
615 : 0 : param.vsi = vsi_id;
616 : :
617 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_ADD_MACVLAN, ¶m, sizeof(param), NULL, 0, 1);
618 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
619 : : }
620 : :
621 : 0 : static void nbl_disp_del_macvlan(void *priv, u8 *mac, u16 vlan_id, u16 vsi_id)
622 : : {
623 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
624 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
625 : :
626 [ # # ]: 0 : NBL_OPS_CALL(res_ops->del_macvlan,
627 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), mac, vlan_id, vsi_id));
628 : 0 : }
629 : :
630 : : static void
631 : 0 : nbl_disp_chan_del_macvlan_req(void *priv, u8 *mac, u16 vlan_id, u16 vsi_id)
632 : : {
633 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
634 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
635 : 0 : struct nbl_chan_send_info chan_send = {0};
636 : : struct nbl_chan_param_macvlan_cfg param = {0};
637 : :
638 : : memcpy(¶m.mac, mac, sizeof(param.mac));
639 : 0 : param.vlan = vlan_id;
640 : 0 : param.vsi = vsi_id;
641 : :
642 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_DEL_MACVLAN, ¶m, sizeof(param), NULL, 0, 1);
643 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
644 : 0 : }
645 : :
646 : 0 : static int nbl_disp_add_multi_rule(void *priv, u16 vsi_id)
647 : : {
648 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
649 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
650 : :
651 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->add_multi_rule, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
652 : : }
653 : :
654 : 0 : static int nbl_disp_chan_add_multi_rule_req(void *priv, u16 vsi_id)
655 : : {
656 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
657 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
658 : : struct nbl_chan_param_add_multi_rule param = {0};
659 : : struct nbl_chan_send_info chan_send;
660 : :
661 : 0 : param.vsi = vsi_id;
662 : :
663 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_ADD_MULTI_RULE, ¶m, sizeof(param), NULL, 0, 1);
664 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
665 : : }
666 : :
667 : 0 : static void nbl_disp_del_multi_rule(void *priv, u16 vsi_id)
668 : : {
669 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
670 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
671 : :
672 [ # # ]: 0 : NBL_OPS_CALL(res_ops->del_multi_rule, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
673 : 0 : }
674 : :
675 : 0 : static void nbl_disp_chan_del_multi_rule_req(void *priv, u16 vsi)
676 : : {
677 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
678 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
679 : : struct nbl_chan_param_del_multi_rule param = {0};
680 : : struct nbl_chan_send_info chan_send;
681 : :
682 : 0 : param.vsi = vsi;
683 : :
684 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_DEL_MULTI_RULE, ¶m, sizeof(param), NULL, 0, 1);
685 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
686 : 0 : }
687 : :
688 : 0 : static int nbl_disp_cfg_dsch(void *priv, u16 vsi_id, bool vld)
689 : : {
690 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
691 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
692 : :
693 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->cfg_dsch, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, vld));
694 : : }
695 : :
696 : 0 : static int nbl_disp_chan_cfg_dsch_req(void *priv, u16 vsi_id, bool vld)
697 : : {
698 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
699 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
700 : 0 : struct nbl_chan_param_cfg_dsch param = {0};
701 : : struct nbl_chan_send_info chan_send;
702 : :
703 : 0 : param.vsi_id = vsi_id;
704 : 0 : param.vld = vld;
705 : :
706 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_CFG_DSCH, ¶m, sizeof(param), NULL, 0, 1);
707 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
708 : : }
709 : :
710 : 0 : static int nbl_disp_setup_cqs(void *priv, u16 vsi_id, u16 real_qps, bool rss_indir_set)
711 : : {
712 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
713 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
714 : :
715 [ # # ]: 0 : return NBL_OPS_CALL(res_ops->setup_cqs,
716 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, real_qps, rss_indir_set));
717 : : }
718 : :
719 : 0 : static int nbl_disp_chan_setup_cqs_req(void *priv, u16 vsi_id, u16 real_qps, bool rss_indir_set)
720 : : {
721 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
722 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
723 : 0 : struct nbl_chan_param_setup_cqs param = {0};
724 : : struct nbl_chan_send_info chan_send;
725 : :
726 : 0 : param.vsi_id = vsi_id;
727 : 0 : param.real_qps = real_qps;
728 : 0 : param.rss_indir_set = rss_indir_set;
729 : :
730 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_SETUP_CQS, ¶m, sizeof(param), NULL, 0, 1);
731 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
732 : : }
733 : :
734 : 0 : static void nbl_disp_remove_cqs(void *priv, u16 vsi_id)
735 : : {
736 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
737 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
738 : :
739 [ # # ]: 0 : NBL_OPS_CALL(res_ops->remove_cqs, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id));
740 : 0 : }
741 : :
742 : 0 : static void nbl_disp_chan_remove_cqs_req(void *priv, u16 vsi_id)
743 : : {
744 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
745 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
746 : : struct nbl_chan_param_remove_cqs param = {0};
747 : : struct nbl_chan_send_info chan_send;
748 : :
749 : 0 : param.vsi_id = vsi_id;
750 : :
751 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_REMOVE_CQS, ¶m, sizeof(param), NULL, 0, 1);
752 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
753 : 0 : }
754 : :
755 : 0 : static void nbl_disp_get_res_pt_ops(void *priv, struct nbl_resource_pt_ops *pt_ops, bool offload)
756 : : {
757 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
758 : : struct nbl_resource_ops *res_ops;
759 : :
760 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
761 [ # # ]: 0 : NBL_OPS_CALL(res_ops->get_resource_pt_ops,
762 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), pt_ops, offload));
763 : 0 : }
764 : :
765 : 0 : static void nbl_disp_get_link_state(void *priv, u8 eth_id, struct nbl_eth_link_info *eth_link_info)
766 : : {
767 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
768 : : struct nbl_resource_ops *res_ops;
769 : :
770 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
771 : :
772 : : /* if do not have res_ops->get_link_state(), default eth is up */
773 [ # # ]: 0 : if (res_ops->get_link_state) {
774 : 0 : res_ops->get_link_state(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
775 : : eth_id, eth_link_info);
776 : : } else {
777 : 0 : eth_link_info->link_status = 1;
778 : 0 : eth_link_info->link_speed = RTE_ETH_LINK_SPEED_25G;
779 : : }
780 : 0 : }
781 : :
782 : 0 : static void nbl_disp_chan_get_link_state_req(void *priv, u8 eth_id,
783 : : struct nbl_eth_link_info *eth_link_info)
784 : : {
785 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
786 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
787 : : struct nbl_chan_param_get_link_state param = {0};
788 : : struct nbl_chan_send_info chan_send;
789 : :
790 : 0 : param.eth_id = eth_id;
791 : :
792 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_LINK_STATE, ¶m, sizeof(param),
793 : : eth_link_info, sizeof(*eth_link_info), 1);
794 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
795 : 0 : }
796 : :
797 : 0 : static int nbl_disp_get_stats(void *priv, struct rte_eth_stats *rte_stats,
798 : : struct eth_queue_stats *qstats)
799 : : {
800 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
801 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
802 : :
803 : 0 : return res_ops->get_stats(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), rte_stats, qstats);
804 : : }
805 : :
806 : 0 : static int nbl_disp_reset_stats(void *priv)
807 : : {
808 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
809 : 0 : struct nbl_resource_ops *res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
810 : :
811 : 0 : return res_ops->reset_stats(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt));
812 : : }
813 : :
814 : 0 : static int nbl_disp_get_txrx_xstats_cnt(void *priv, u16 *xstats_cnt)
815 : : {
816 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
817 : : struct nbl_resource_ops *res_ops;
818 : :
819 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
820 : 0 : return res_ops->get_txrx_xstats_cnt(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), xstats_cnt);
821 : : }
822 : :
823 : 0 : static int nbl_disp_get_txrx_xstats(void *priv, struct rte_eth_xstat *xstats,
824 : : u16 need_xstats_cnt, u16 *xstats_cnt)
825 : : {
826 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
827 : : struct nbl_resource_ops *res_ops;
828 : :
829 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
830 : 0 : return res_ops->get_txrx_xstats(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), xstats,
831 : : need_xstats_cnt, xstats_cnt);
832 : : }
833 : :
834 : 0 : static int nbl_disp_get_txrx_xstats_names(void *priv, struct rte_eth_xstat_name *xstats_names,
835 : : u16 need_xstats_cnt, u16 *xstats_cnt)
836 : : {
837 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
838 : : struct nbl_resource_ops *res_ops;
839 : :
840 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
841 : 0 : return res_ops->get_txrx_xstats_names(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
842 : : xstats_names, need_xstats_cnt, xstats_cnt);
843 : : }
844 : :
845 : 0 : static int nbl_disp_get_hw_xstats_cnt(void *priv, u16 *xstats_cnt)
846 : : {
847 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
848 : : struct nbl_resource_ops *res_ops;
849 : :
850 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
851 : 0 : return res_ops->get_hw_xstats_cnt(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), xstats_cnt);
852 : : }
853 : :
854 : 0 : static int nbl_disp_get_hw_xstats_names(void *priv, struct rte_eth_xstat_name *xstats_names,
855 : : u16 need_xstats_cnt, u16 *xstats_cnt)
856 : : {
857 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
858 : : struct nbl_resource_ops *res_ops;
859 : :
860 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
861 : 0 : return res_ops->get_hw_xstats_names(NBL_DISP_MGT_TO_RES_PRIV(disp_mgt),
862 : : xstats_names, need_xstats_cnt, xstats_cnt);
863 : : }
864 : :
865 : 0 : static void nbl_disp_get_private_stat_data(void *priv, u32 eth_id, u64 *data,
866 : : __rte_unused u32 data_len)
867 : : {
868 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
869 : : struct nbl_resource_ops *res_ops;
870 : :
871 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
872 [ # # ]: 0 : NBL_OPS_CALL(res_ops->get_private_stat_data,
873 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), eth_id, data));
874 : 0 : }
875 : :
876 : 0 : static void nbl_disp_get_private_stat_data_req(void *priv, u32 eth_id, u64 *data, u32 data_len)
877 : : {
878 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
879 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
880 : 0 : struct nbl_chan_send_info chan_send = {0};
881 : : struct nbl_chan_param_get_private_stat_data param = {0};
882 : :
883 : 0 : param.eth_id = eth_id;
884 : 0 : param.data_len = data_len;
885 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_GET_ETH_STATS, ¶m,
886 : : sizeof(param), data, data_len, 1);
887 : 0 : chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), &chan_send);
888 : 0 : }
889 : :
890 : 0 : static int nbl_disp_set_mtu(void *priv, u16 vsi_id, u16 mtu)
891 : : {
892 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
893 : : struct nbl_resource_ops *res_ops;
894 : : int ret = 0;
895 : :
896 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
897 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->set_mtu, (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, mtu));
898 : 0 : return ret;
899 : : }
900 : :
901 : 0 : static int nbl_disp_chan_set_mtu_req(void *priv, u16 vsi_id, u16 mtu)
902 : : {
903 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
904 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
905 : 0 : struct nbl_chan_send_info chan_send = {0};
906 : : struct nbl_chan_param_set_mtu param = {0};
907 : :
908 : 0 : param.mtu = mtu;
909 : 0 : param.vsi_id = vsi_id;
910 : :
911 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_MTU_SET,
912 : : ¶m, sizeof(param), NULL, 0, 1);
913 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt),
914 : : &chan_send);
915 : : }
916 : :
917 : 0 : static int nbl_disp_set_promisc_mode(void *priv, u16 vsi_id, u16 mode)
918 : : {
919 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
920 : : struct nbl_resource_ops *res_ops;
921 : : int ret = 0;
922 : :
923 : 0 : res_ops = NBL_DISP_MGT_TO_RES_OPS(disp_mgt);
924 [ # # ]: 0 : ret = NBL_OPS_CALL(res_ops->set_promisc_mode,
925 : : (NBL_DISP_MGT_TO_RES_PRIV(disp_mgt), vsi_id, mode));
926 : 0 : return ret;
927 : : }
928 : :
929 : 0 : static int nbl_disp_chan_set_promisc_mode_req(void *priv, u16 vsi_id, u16 mode)
930 : : {
931 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)priv;
932 : : struct nbl_common_info *common;
933 : 0 : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
934 : 0 : struct nbl_chan_param_set_promisc_mode param = {0};
935 : 0 : struct nbl_chan_send_info chan_send = {0};
936 : : int ret = 0;
937 : :
938 : 0 : common = NBL_DISP_MGT_TO_COMMON(disp_mgt);
939 [ # # ]: 0 : if (NBL_IS_COEXISTENCE(common)) {
940 : 0 : ret = ioctl(common->devfd, NBL_DEV_USER_SET_PROMISC_MODE, &mode);
941 [ # # ]: 0 : if (ret) {
942 : 0 : NBL_LOG(ERR, "userspace send set_promisc_mode ioctl msg failed ret %d",
943 : : ret);
944 : 0 : return ret;
945 : : }
946 : : return 0;
947 : : }
948 : :
949 : 0 : param.vsi_id = vsi_id;
950 : 0 : param.mode = mode;
951 : 0 : NBL_CHAN_SEND(chan_send, 0, NBL_CHAN_MSG_SET_PROSISC_MODE,
952 : : ¶m, sizeof(param), NULL, 0, 1);
953 : 0 : return chan_ops->send_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt),
954 : : &chan_send);
955 : : }
956 : :
957 : : #define NBL_DISP_OPS_TBL \
958 : : do { \
959 : : NBL_DISP_SET_OPS(configure_msix_map, nbl_disp_configure_msix_map, \
960 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_CONFIGURE_MSIX_MAP, \
961 : : nbl_disp_chan_configure_msix_map_req, \
962 : : NULL); \
963 : : NBL_DISP_SET_OPS(destroy_msix_map, nbl_disp_destroy_msix_map, \
964 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_DESTROY_MSIX_MAP, \
965 : : nbl_disp_chan_destroy_msix_map_req, \
966 : : NULL); \
967 : : NBL_DISP_SET_OPS(enable_mailbox_irq, nbl_disp_enable_mailbox_irq, \
968 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_MAILBOX_ENABLE_IRQ, \
969 : : nbl_disp_chan_enable_mailbox_irq_req, \
970 : : NULL); \
971 : : NBL_DISP_SET_OPS(alloc_txrx_queues, nbl_disp_alloc_txrx_queues, \
972 : : NBL_DISP_CTRL_LVL_MGT, \
973 : : NBL_CHAN_MSG_ALLOC_TXRX_QUEUES, \
974 : : nbl_disp_chan_alloc_txrx_queues_req, \
975 : : NULL); \
976 : : NBL_DISP_SET_OPS(free_txrx_queues, nbl_disp_free_txrx_queues, \
977 : : NBL_DISP_CTRL_LVL_MGT, \
978 : : NBL_CHAN_MSG_FREE_TXRX_QUEUES, \
979 : : nbl_disp_chan_free_txrx_queues_req, \
980 : : NULL); \
981 : : NBL_DISP_SET_OPS(alloc_rings, nbl_disp_alloc_rings, \
982 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
983 : : NULL, NULL); \
984 : : NBL_DISP_SET_OPS(remove_rings, nbl_disp_remove_rings, \
985 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
986 : : NULL, NULL); \
987 : : NBL_DISP_SET_OPS(start_tx_ring, nbl_disp_start_tx_ring, \
988 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
989 : : NBL_DISP_SET_OPS(stop_tx_ring, nbl_disp_stop_tx_ring, \
990 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
991 : : NBL_DISP_SET_OPS(release_tx_ring, nbl_disp_release_tx_ring, \
992 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
993 : : NBL_DISP_SET_OPS(start_rx_ring, nbl_disp_start_rx_ring, \
994 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
995 : : NBL_DISP_SET_OPS(alloc_rx_bufs, nbl_disp_alloc_rx_bufs, \
996 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
997 : : NBL_DISP_SET_OPS(stop_rx_ring, nbl_disp_stop_rx_ring, \
998 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
999 : : NBL_DISP_SET_OPS(release_rx_ring, nbl_disp_release_rx_ring, \
1000 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, NULL, NULL); \
1001 : : NBL_DISP_SET_OPS(update_rx_ring, nbl_disp_update_rx_ring, \
1002 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1003 : : NULL, NULL); \
1004 : : NBL_DISP_SET_OPS(setup_queue, nbl_disp_setup_queue, \
1005 : : NBL_DISP_CTRL_LVL_MGT, \
1006 : : NBL_CHAN_MSG_SETUP_QUEUE, \
1007 : : nbl_disp_chan_setup_queue_req, NULL); \
1008 : : NBL_DISP_SET_OPS(remove_all_queues, nbl_disp_remove_all_queues, \
1009 : : NBL_DISP_CTRL_LVL_MGT, \
1010 : : NBL_CHAN_MSG_REMOVE_ALL_QUEUES, \
1011 : : nbl_disp_chan_remove_all_queues_req, NULL); \
1012 : : NBL_DISP_SET_OPS(clear_queues, nbl_disp_clear_queues, \
1013 : : NBL_DISP_CTRL_LVL_MGT, \
1014 : : NBL_CHAN_MSG_CLEAR_QUEUE, \
1015 : : nbl_disp_chan_clear_queues_req, NULL); \
1016 : : NBL_DISP_SET_OPS(get_mac_addr, nbl_disp_get_mac_addr, \
1017 : : NBL_DISP_CTRL_LVL_MGT, \
1018 : : -1, nbl_disp_get_mac_addr_req, NULL); \
1019 : : NBL_DISP_SET_OPS(register_net, nbl_disp_register_net, \
1020 : : NBL_DISP_CTRL_LVL_MGT, \
1021 : : NBL_CHAN_MSG_REGISTER_NET, \
1022 : : nbl_disp_chan_register_net_req, \
1023 : : NULL); \
1024 : : NBL_DISP_SET_OPS(unregister_net, nbl_disp_unregister_net, \
1025 : : NBL_DISP_CTRL_LVL_MGT, \
1026 : : NBL_CHAN_MSG_UNREGISTER_NET, \
1027 : : nbl_disp_chan_unregister_net_req, NULL); \
1028 : : NBL_DISP_SET_OPS(get_vsi_id, nbl_disp_get_vsi_id, \
1029 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_GET_VSI_ID,\
1030 : : nbl_disp_chan_get_vsi_id_req, NULL); \
1031 : : NBL_DISP_SET_OPS(get_eth_id, nbl_disp_get_eth_id, \
1032 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_GET_ETH_ID,\
1033 : : nbl_disp_chan_get_eth_id_req, NULL); \
1034 : : NBL_DISP_SET_OPS(get_vsi_global_qid, \
1035 : : nbl_disp_get_vsi_global_qid, \
1036 : : NBL_DISP_CTRL_LVL_MGT, \
1037 : : NBL_CHAN_MSG_GET_VSI_GLOBAL_QUEUE_ID, \
1038 : : nbl_disp_chan_get_vsi_global_qid_req, NULL); \
1039 : : NBL_DISP_SET_OPS(setup_q2vsi, nbl_disp_chan_setup_q2vsi, \
1040 : : NBL_DISP_CTRL_LVL_MGT, \
1041 : : NBL_CHAN_MSG_SETUP_Q2VSI, \
1042 : : nbl_disp_chan_setup_q2vsi_req, NULL); \
1043 : : NBL_DISP_SET_OPS(remove_q2vsi, nbl_disp_chan_remove_q2vsi, \
1044 : : NBL_DISP_CTRL_LVL_MGT, \
1045 : : NBL_CHAN_MSG_REMOVE_Q2VSI, \
1046 : : nbl_disp_chan_remove_q2vsi_req, NULL); \
1047 : : NBL_DISP_SET_OPS(register_vsi2q, nbl_disp_chan_register_vsi2q, \
1048 : : NBL_DISP_CTRL_LVL_MGT, \
1049 : : NBL_CHAN_MSG_REGISTER_VSI2Q, \
1050 : : nbl_disp_chan_register_vsi2q_req, NULL); \
1051 : : NBL_DISP_SET_OPS(setup_rss, nbl_disp_chan_setup_rss, \
1052 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_SETUP_RSS, \
1053 : : nbl_disp_chan_setup_rss_req, NULL); \
1054 : : NBL_DISP_SET_OPS(remove_rss, nbl_disp_chan_remove_rss, \
1055 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_REMOVE_RSS,\
1056 : : nbl_disp_chan_remove_rss_req, NULL); \
1057 : : NBL_DISP_SET_OPS(get_board_info, nbl_disp_chan_get_board_info, \
1058 : : NBL_DISP_CTRL_LVL_MGT, \
1059 : : NBL_CHAN_MSG_GET_BOARD_INFO, \
1060 : : nbl_disp_chan_get_board_info_req, NULL); \
1061 : : NBL_DISP_SET_OPS(clear_flow, nbl_disp_clear_flow, \
1062 : : NBL_DISP_CTRL_LVL_MGT, \
1063 : : NBL_CHAN_MSG_CLEAR_FLOW, \
1064 : : nbl_disp_chan_clear_flow_req, NULL); \
1065 : : NBL_DISP_SET_OPS(add_macvlan, nbl_disp_add_macvlan, \
1066 : : NBL_DISP_CTRL_LVL_MGT, \
1067 : : NBL_CHAN_MSG_ADD_MACVLAN, \
1068 : : nbl_disp_chan_add_macvlan_req, NULL); \
1069 : : NBL_DISP_SET_OPS(del_macvlan, nbl_disp_del_macvlan, \
1070 : : NBL_DISP_CTRL_LVL_MGT, \
1071 : : NBL_CHAN_MSG_DEL_MACVLAN, \
1072 : : nbl_disp_chan_del_macvlan_req, NULL); \
1073 : : NBL_DISP_SET_OPS(add_multi_rule, nbl_disp_add_multi_rule, \
1074 : : NBL_DISP_CTRL_LVL_MGT, \
1075 : : NBL_CHAN_MSG_ADD_MULTI_RULE, \
1076 : : nbl_disp_chan_add_multi_rule_req, NULL); \
1077 : : NBL_DISP_SET_OPS(del_multi_rule, nbl_disp_del_multi_rule, \
1078 : : NBL_DISP_CTRL_LVL_MGT, \
1079 : : NBL_CHAN_MSG_DEL_MULTI_RULE, \
1080 : : nbl_disp_chan_del_multi_rule_req, NULL); \
1081 : : NBL_DISP_SET_OPS(cfg_dsch, nbl_disp_cfg_dsch, \
1082 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_CFG_DSCH, \
1083 : : nbl_disp_chan_cfg_dsch_req, NULL); \
1084 : : NBL_DISP_SET_OPS(setup_cqs, nbl_disp_setup_cqs, \
1085 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_SETUP_CQS, \
1086 : : nbl_disp_chan_setup_cqs_req, NULL); \
1087 : : NBL_DISP_SET_OPS(remove_cqs, nbl_disp_remove_cqs, \
1088 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_REMOVE_CQS,\
1089 : : nbl_disp_chan_remove_cqs_req, NULL); \
1090 : : NBL_DISP_SET_OPS(get_resource_pt_ops, \
1091 : : nbl_disp_get_res_pt_ops, \
1092 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1093 : : NULL, NULL); \
1094 : : NBL_DISP_SET_OPS(get_link_state, nbl_disp_get_link_state, \
1095 : : NBL_DISP_CTRL_LVL_MGT, \
1096 : : NBL_CHAN_MSG_GET_LINK_STATE, \
1097 : : nbl_disp_chan_get_link_state_req, NULL); \
1098 : : NBL_DISP_SET_OPS(get_stats, nbl_disp_get_stats, \
1099 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1100 : : NULL, NULL); \
1101 : : NBL_DISP_SET_OPS(reset_stats, nbl_disp_reset_stats, \
1102 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1103 : : NULL, NULL); \
1104 : : NBL_DISP_SET_OPS(get_txrx_xstats_cnt, \
1105 : : nbl_disp_get_txrx_xstats_cnt, \
1106 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1107 : : NULL, NULL); \
1108 : : NBL_DISP_SET_OPS(get_txrx_xstats, nbl_disp_get_txrx_xstats, \
1109 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1110 : : NULL, NULL); \
1111 : : NBL_DISP_SET_OPS(get_txrx_xstats_names, \
1112 : : nbl_disp_get_txrx_xstats_names, \
1113 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1114 : : NULL, NULL); \
1115 : : NBL_DISP_SET_OPS(get_hw_xstats_cnt, nbl_disp_get_hw_xstats_cnt, \
1116 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1117 : : NULL, NULL); \
1118 : : NBL_DISP_SET_OPS(get_hw_xstats_names, \
1119 : : nbl_disp_get_hw_xstats_names, \
1120 : : NBL_DISP_CTRL_LVL_ALWAYS, -1, \
1121 : : NULL, NULL); \
1122 : : NBL_DISP_SET_OPS(get_private_stat_data, \
1123 : : nbl_disp_get_private_stat_data, \
1124 : : NBL_DISP_CTRL_LVL_MGT, \
1125 : : NBL_CHAN_MSG_GET_ETH_STATS, \
1126 : : nbl_disp_get_private_stat_data_req, NULL); \
1127 : : NBL_DISP_SET_OPS(set_promisc_mode, nbl_disp_set_promisc_mode, \
1128 : : NBL_DISP_CTRL_LVL_MGT, \
1129 : : NBL_CHAN_MSG_SET_PROSISC_MODE, \
1130 : : nbl_disp_chan_set_promisc_mode_req, NULL); \
1131 : : NBL_DISP_SET_OPS(set_mtu, nbl_disp_set_mtu, \
1132 : : NBL_DISP_CTRL_LVL_MGT, NBL_CHAN_MSG_MTU_SET, \
1133 : : nbl_disp_chan_set_mtu_req, \
1134 : : NULL); \
1135 : : } while (0)
1136 : :
1137 : : /* Structure starts here, adding an op should not modify anything below */
1138 : 0 : static int nbl_disp_setup_msg(struct nbl_dispatch_mgt *disp_mgt)
1139 : : {
1140 : : struct nbl_dispatch_ops *disp_ops = NBL_DISP_MGT_TO_DISP_OPS(disp_mgt);
1141 : : const struct nbl_channel_ops *chan_ops = NBL_DISP_MGT_TO_CHAN_OPS(disp_mgt);
1142 : : int ret = 0;
1143 : :
1144 : : #define NBL_DISP_SET_OPS(disp_op, res_func, ctrl_lvl2, msg_type, msg_req, msg_resp) \
1145 : : do { \
1146 : : typeof(msg_type) _msg_type = (msg_type); \
1147 : : typeof(msg_resp) _msg_resp = (msg_resp); \
1148 : : RTE_SET_USED(disp_ops->NBL_NAME(disp_op)); \
1149 : : RTE_SET_USED(res_func); \
1150 : : RTE_SET_USED(msg_req); \
1151 : : uint32_t _ctrl_lvl = rte_bit_relaxed_get32(ctrl_lvl2, &disp_mgt->ctrl_lvl); \
1152 : : if (_msg_type >= 0 && _msg_resp != NULL && _ctrl_lvl) \
1153 : : ret += chan_ops->register_msg(NBL_DISP_MGT_TO_CHAN_PRIV(disp_mgt), \
1154 : : _msg_type, _msg_resp, disp_mgt); \
1155 : : } while (0)
1156 : : NBL_DISP_OPS_TBL;
1157 : : #undef NBL_DISP_SET_OPS
1158 : :
1159 : 0 : return ret;
1160 : : }
1161 : :
1162 : : /* Ctrl lvl means that if a certain level is set, then all disp_ops that declared this lvl
1163 : : * will go directly to res_ops, rather than send a channel msg, and vice versa.
1164 : : */
1165 : 0 : static int nbl_disp_setup_ctrl_lvl(struct nbl_dispatch_mgt *disp_mgt, u32 lvl)
1166 : : {
1167 [ # # ]: 0 : struct nbl_dispatch_ops *disp_ops = NBL_DISP_MGT_TO_DISP_OPS(disp_mgt);
1168 : :
1169 : : rte_bit_relaxed_set32(lvl, &disp_mgt->ctrl_lvl);
1170 : :
1171 : : #define NBL_DISP_SET_OPS(disp_op, res_func, ctrl, msg_type, msg_req, msg_resp) \
1172 : : do { \
1173 : : typeof(msg_type) _msg_type = (msg_type); \
1174 : : typeof(msg_resp) _msg_resp = (msg_resp); \
1175 : : RTE_SET_USED(_msg_type); \
1176 : : RTE_SET_USED(_msg_resp); \
1177 : : disp_ops->NBL_NAME(disp_op) = \
1178 : : rte_bit_relaxed_get32(ctrl, &disp_mgt->ctrl_lvl) ? res_func : msg_req; ;\
1179 : : } while (0)
1180 [ # # # # : 0 : NBL_DISP_OPS_TBL;
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
1181 : : #undef NBL_DISP_SET_OPS
1182 : :
1183 : 0 : return 0;
1184 : : }
1185 : :
1186 : : static int nbl_disp_setup_disp_mgt(struct nbl_dispatch_mgt **disp_mgt)
1187 : : {
1188 : 0 : *disp_mgt = rte_zmalloc("nbl_disp_mgt", sizeof(struct nbl_dispatch_mgt), 0);
1189 [ # # ]: 0 : if (!*disp_mgt)
1190 : : return -ENOMEM;
1191 : :
1192 : : return 0;
1193 : : }
1194 : :
1195 : : static void nbl_disp_remove_disp_mgt(struct nbl_dispatch_mgt **disp_mgt)
1196 : : {
1197 : 0 : rte_free(*disp_mgt);
1198 : 0 : *disp_mgt = NULL;
1199 : : }
1200 : :
1201 : 0 : static void nbl_disp_remove_ops(struct nbl_dispatch_ops_tbl **disp_ops_tbl)
1202 : : {
1203 : 0 : free(NBL_DISP_OPS_TBL_TO_OPS(*disp_ops_tbl));
1204 : 0 : free(*disp_ops_tbl);
1205 : 0 : *disp_ops_tbl = NULL;
1206 : 0 : }
1207 : :
1208 : 0 : static int nbl_disp_setup_ops(struct nbl_dispatch_ops_tbl **disp_ops_tbl,
1209 : : struct nbl_dispatch_mgt *disp_mgt)
1210 : : {
1211 : : struct nbl_dispatch_ops *disp_ops;
1212 : :
1213 : 0 : *disp_ops_tbl = calloc(1, sizeof(struct nbl_dispatch_ops_tbl));
1214 [ # # ]: 0 : if (!*disp_ops_tbl)
1215 : : return -ENOMEM;
1216 : :
1217 : 0 : disp_ops = calloc(1, sizeof(struct nbl_dispatch_ops));
1218 [ # # ]: 0 : if (!disp_ops) {
1219 : 0 : free(*disp_ops_tbl);
1220 : 0 : return -ENOMEM;
1221 : : }
1222 : :
1223 : 0 : NBL_DISP_OPS_TBL_TO_OPS(*disp_ops_tbl) = disp_ops;
1224 : 0 : NBL_DISP_OPS_TBL_TO_PRIV(*disp_ops_tbl) = disp_mgt;
1225 : :
1226 : 0 : return 0;
1227 : : }
1228 : :
1229 : 0 : int nbl_disp_init(void *p)
1230 : : {
1231 : : struct nbl_adapter *adapter = (struct nbl_adapter *)p;
1232 : : struct nbl_dispatch_mgt **disp_mgt;
1233 : : struct nbl_dispatch_ops_tbl **disp_ops_tbl;
1234 : : struct nbl_resource_ops_tbl *res_ops_tbl;
1235 : : struct nbl_channel_ops_tbl *chan_ops_tbl;
1236 : : struct nbl_product_dispatch_ops *disp_product_ops = NULL;
1237 : : int ret = 0;
1238 : :
1239 : : disp_mgt = (struct nbl_dispatch_mgt **)&NBL_ADAPTER_TO_DISP_MGT(adapter);
1240 : 0 : disp_ops_tbl = &NBL_ADAPTER_TO_DISP_OPS_TBL(adapter);
1241 : 0 : res_ops_tbl = NBL_ADAPTER_TO_RES_OPS_TBL(adapter);
1242 : 0 : chan_ops_tbl = NBL_ADAPTER_TO_CHAN_OPS_TBL(adapter);
1243 : 0 : disp_product_ops = nbl_dispatch_get_product_ops(adapter->caps.product_type);
1244 : :
1245 : : ret = nbl_disp_setup_disp_mgt(disp_mgt);
1246 : : if (ret)
1247 : : return ret;
1248 : :
1249 : 0 : ret = nbl_disp_setup_ops(disp_ops_tbl, *disp_mgt);
1250 [ # # ]: 0 : if (ret)
1251 : 0 : goto setup_ops_fail;
1252 : :
1253 : 0 : NBL_DISP_MGT_TO_RES_OPS_TBL(*disp_mgt) = res_ops_tbl;
1254 : 0 : NBL_DISP_MGT_TO_CHAN_OPS_TBL(*disp_mgt) = chan_ops_tbl;
1255 : 0 : NBL_DISP_MGT_TO_DISP_OPS_TBL(*disp_mgt) = *disp_ops_tbl;
1256 : 0 : NBL_DISP_MGT_TO_COMMON(*disp_mgt) = NBL_ADAPTER_TO_COMMON(adapter);
1257 : :
1258 [ # # ]: 0 : if (disp_product_ops->dispatch_init) {
1259 : 0 : ret = disp_product_ops->dispatch_init(*disp_mgt);
1260 [ # # ]: 0 : if (ret)
1261 : 0 : goto dispatch_init_fail;
1262 : : }
1263 : :
1264 : 0 : ret = nbl_disp_setup_ctrl_lvl(*disp_mgt, NBL_DISP_CTRL_LVL_ALWAYS);
1265 [ # # ]: 0 : if (ret)
1266 : 0 : goto setup_ctrl_lvl_fail;
1267 : : return 0;
1268 : :
1269 : : setup_ctrl_lvl_fail:
1270 : 0 : disp_product_ops->dispatch_uninit(*disp_mgt);
1271 : 0 : dispatch_init_fail:
1272 : 0 : nbl_disp_remove_ops(disp_ops_tbl);
1273 : 0 : setup_ops_fail:
1274 : : nbl_disp_remove_disp_mgt(disp_mgt);
1275 : :
1276 : 0 : return ret;
1277 : : }
1278 : :
1279 : 0 : void nbl_disp_remove(void *p)
1280 : : {
1281 : : struct nbl_adapter *adapter = (struct nbl_adapter *)p;
1282 : : struct nbl_dispatch_mgt **disp_mgt;
1283 : : struct nbl_dispatch_ops_tbl **disp_ops_tbl;
1284 : :
1285 : : disp_mgt = (struct nbl_dispatch_mgt **)&NBL_ADAPTER_TO_DISP_MGT(adapter);
1286 : 0 : disp_ops_tbl = &NBL_ADAPTER_TO_DISP_OPS_TBL(adapter);
1287 : :
1288 : 0 : nbl_disp_remove_ops(disp_ops_tbl);
1289 : : nbl_disp_remove_disp_mgt(disp_mgt);
1290 : 0 : }
1291 : :
1292 : 0 : static int nbl_disp_leonis_init(void *p)
1293 : : {
1294 : : struct nbl_dispatch_mgt *disp_mgt = (struct nbl_dispatch_mgt *)p;
1295 : : int ret;
1296 : :
1297 : 0 : nbl_disp_setup_ctrl_lvl(disp_mgt, NBL_DISP_CTRL_LVL_NET);
1298 : 0 : ret = nbl_disp_setup_msg(disp_mgt);
1299 : :
1300 : 0 : return ret;
1301 : : }
1302 : :
1303 : 0 : static int nbl_disp_leonis_uninit(void *p)
1304 : : {
1305 : : RTE_SET_USED(p);
1306 : 0 : return 0;
1307 : : }
1308 : :
1309 : : static struct nbl_product_dispatch_ops nbl_product_dispatch_ops[NBL_PRODUCT_MAX] = {
1310 : : {
1311 : : .dispatch_init = nbl_disp_leonis_init,
1312 : : .dispatch_uninit = nbl_disp_leonis_uninit,
1313 : : },
1314 : : };
1315 : :
1316 : 0 : struct nbl_product_dispatch_ops *nbl_dispatch_get_product_ops(enum nbl_product_type product_type)
1317 : : {
1318 : 0 : return &nbl_product_dispatch_ops[product_type];
1319 : : }
|
