FD.io VPP  v21.01.1
Vector Packet Processing
pp2.c
Go to the documentation of this file.
1 /*
2  *------------------------------------------------------------------
3  * Copyright (c) 2018 Cisco and/or its affiliates.
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *------------------------------------------------------------------
16  */
17 
18 #include <sys/types.h>
19 #include <sys/stat.h>
20 #include <fcntl.h>
21 #include <sys/ioctl.h>
22 
23 #include <vlib/vlib.h>
24 #include <vlib/unix/unix.h>
25 #include <vppinfra/linux/syscall.h>
26 #include <vnet/plugin/plugin.h>
27 #include <marvell/pp2/pp2.h>
28 
29 /* size of DMA memory used by musdk (not used for buffers) */
30 #define MV_SYS_DMA_MEM_SZ (2 << 20)
31 /* number of HIFs reserved (first X) */
32 #define NUM_HIFS_RSVD 4
33 /* number of buffer pools reserved (first X) */
34 #define NUM_BPOOLS_RSVD 7
35 
38 
39 static void
41 {
43  int i;
45  {
47  i);
48  if (ptd->hif)
49  pp2_hif_deinit (ptd->hif);
50  vec_free (ptd->descs);
51  }
53  pp2_deinit ();
54  mv_sys_dma_mem_destroy ();
55 }
56 
57 static clib_error_t *
59 {
62  clib_error_t *err = 0;
63  struct pp2_init_params init_params = { 0 };
64  int i, rv;
65  u8 *s = 0;
66 
67  rv = mv_sys_dma_mem_init (MV_SYS_DMA_MEM_SZ);
68  if (rv)
69  return clib_error_return (0, "mv_sys_dma_mem_init failed, rv = %u", rv);
70 
71  init_params.hif_reserved_map = ((1 << NUM_HIFS_RSVD) - 1);
72  init_params.bm_pool_reserved_map = ((1 << NUM_BPOOLS_RSVD) - 1);
73  rv = pp2_init (&init_params);
74  if (rv)
75  {
76  err = clib_error_return (0, "mrvl_pp2_init failed, rv = %u", rv);
77  goto done;
78  }
79 
82 
84  {
86  i);
87  struct pp2_hif_params hif_params = { 0 };
88  vec_reset_length (s);
89  s = format (s, "hif-%d%c", NUM_HIFS_RSVD + i, 0);
90  hif_params.match = (char *) s;
91  hif_params.out_size = 2048; /* FIXME */
92  if (pp2_hif_init (&hif_params, &ptd->hif))
93  {
94  err = clib_error_return (0, "hif '%s' init failed", s);
95  goto done;
96  }
97  }
98 
99 done:
100  if (err)
102  vec_free (s);
103  return err;
104 }
105 
106 static u32
108  u32 flags)
109 {
110  /* nothing for now */
111  return 0;
112 }
113 
114 void
116 {
118  vnet_main_t *vnm = vnet_get_main ();
120  mrvl_pp2_outq_t *outq;
121  mrvl_pp2_inq_t *inq;
122  int i;
123 
124  if (ppif->hw_if_index != ~0)
125  {
126  vec_foreach_index (i, ppif->inqs)
129  }
130 
131  if (ppif->ppio)
132  {
133  pp2_ppio_disable (ppif->ppio);
134  pp2_ppio_deinit (ppif->ppio);
135  }
136 
137  /* *INDENT-OFF* */
138  /* free buffers hanging in the tx ring */
139  vec_foreach (outq, ppif->outqs)
140  {
141  while (outq->tail < outq->head)
142  {
143  u16 slot = outq->tail & (outq->size - 1);
144  vlib_buffer_free (vm, outq->buffers + slot, 1);
145  outq->tail++;
146  }
147  vec_free (outq->buffers);
148  }
149  vec_free (ppif->outqs);
150 
151  /* free buffers hangin in the rx buffer pool */
152  vec_foreach (inq, ppif->inqs)
153  if (inq->bpool)
154  {
155  u32 n_bufs = 0;
156  pp2_bpool_get_num_buffs (inq->bpool, &n_bufs);
157  while (n_bufs--)
158  {
159  struct pp2_buff_inf binf;
160  if (pp2_bpool_get_buff (ppm->per_thread_data[0].hif, inq->bpool,
161  &binf) == 0)
162  {
163  u32 bi = binf.cookie;
164  vlib_buffer_free (vm, &bi, 1);
165  }
166  }
167  pp2_bpool_deinit (inq->bpool);
168  }
169  vec_free (ppif->inqs);
170  /* *INDENT-ON* */
171 
172 
173  pool_put (ppm->interfaces, ppif);
174 
175  if (pool_elts (ppm->interfaces) == 0)
177 }
178 
179 void
181 {
183  vnet_main_t *vnm = vnet_get_main ();
186  struct pp2_bpool_params bpool_params = { 0 };
187  struct pp2_ppio_params ppio_params = { 0 };
188  struct pp2_ppio_inq_params inq_params = { 0 };
190  mrvl_pp2_if_t *ppif = 0;
191  u8 pp2_id, port_id, *s = 0;
192  eth_addr_t mac_addr;
193  u8 n_outqs, n_inqs = 1;
194  int i;
195 
196  if (tm->n_vlib_mains > PP2_PPIO_MAX_NUM_OUTQS)
197  {
198  args->rv = VNET_API_ERROR_INIT_FAILED;
199  args->error = clib_error_return (0, "number of threads (main + workers)"
200  " is bigger than number of output "
201  "queues (%u)", PP2_PPIO_MAX_NUM_OUTQS);
202  return;
203  }
204  n_outqs = tm->n_vlib_mains;
205 
206  /* defaults */
207  args->tx_q_sz = args->tx_q_sz ? args->tx_q_sz : 2 * VLIB_FRAME_SIZE;
208  args->rx_q_sz = args->rx_q_sz ? args->rx_q_sz : 2 * VLIB_FRAME_SIZE;
209 
210  if (vec_len (ppm->per_thread_data) == 0)
211  {
212  if ((args->error = mrvl_pp2_main_init ()) != 0)
213  {
214  args->rv = VNET_API_ERROR_INIT_FAILED;
215  return;
216  }
217  }
218 
219  pool_get_zero (ppm->interfaces, ppif);
220  ppif->dev_instance = ppif - ppm->interfaces;
221  ppif->hw_if_index = ~0;
222  vec_validate_aligned (ppif->inqs, n_inqs - 1, CLIB_CACHE_LINE_BYTES);
223  vec_validate_aligned (ppif->outqs, n_outqs - 1, CLIB_CACHE_LINE_BYTES);
224 
225  for (i = 0; i < n_inqs; i++)
226  {
227  mrvl_pp2_inq_t *inq = vec_elt_at_index (ppif->inqs, i);
228  inq->size = args->rx_q_sz;
229  }
230  for (i = 0; i < n_outqs; i++)
231  {
232  mrvl_pp2_outq_t *outq = vec_elt_at_index (ppif->outqs, i);
233  outq->size = args->tx_q_sz;
235  }
236 
237  if (pp2_netdev_get_ppio_info ((char *) args->name, &pp2_id, &port_id))
238  {
239  args->rv = VNET_API_ERROR_INVALID_INTERFACE;
240  args->error = clib_error_return (0, "Invalid interface '%s'",
241  args->name);
242  goto error;
243  }
244 
245  /* FIXME bpool bit select per pp */
246  s = format (s, "pool-%d:%d%c", pp2_id, pp2_id + 8, 0);
247  bpool_params.match = (char *) s;
248  bpool_params.buff_len = vlib_buffer_get_default_data_size (vm);
249  /* FIXME +64 ? */
250  if (pp2_bpool_init (&bpool_params, &ppif->inqs[0].bpool))
251  {
252  args->rv = VNET_API_ERROR_INIT_FAILED;
253  args->error = clib_error_return (0, "bpool '%s' init failed", s);
254  goto error;
255  }
256  vec_reset_length (s);
257 
258  s = format (s, "ppio-%d:%d%c", pp2_id, port_id, 0);
259  ppio_params.match = (char *) s;
260  ppio_params.type = PP2_PPIO_T_NIC;
261  inq_params.size = args->rx_q_sz;
262  ppio_params.inqs_params.num_tcs = 1;
263  ppio_params.inqs_params.tcs_params[0].pkt_offset = 0;
264  ppio_params.inqs_params.tcs_params[0].num_in_qs = n_inqs;
265  ppio_params.inqs_params.tcs_params[0].inqs_params = &inq_params;
266  ppio_params.inqs_params.tcs_params[0].pools[0][0] = ppif->inqs[0].bpool;
267  ppio_params.outqs_params.num_outqs = n_outqs;
268  for (i = 0; i < n_outqs; i++)
269  {
270  ppio_params.outqs_params.outqs_params[i].weight = 1;
271  ppio_params.outqs_params.outqs_params[i].size = args->tx_q_sz;
272  }
273  if (pp2_ppio_init (&ppio_params, &ppif->ppio))
274  {
275  args->rv = VNET_API_ERROR_INIT_FAILED;
276  args->error = clib_error_return (0, "ppio '%s' init failed", s);
277  goto error;
278  }
279  vec_reset_length (s);
280 
281  if (pp2_ppio_get_mac_addr (ppif->ppio, mac_addr))
282  {
283  args->rv = VNET_API_ERROR_INIT_FAILED;
284  args->error =
285  clib_error_return (0, "%s: pp2_ppio_get_mac_addr failed", s);
286  goto error;
287  }
288 
290  ppif->dev_instance,
291  mac_addr,
292  &ppif->hw_if_index,
294  if (args->error)
295  {
296  args->rv = VNET_API_ERROR_INVALID_REGISTRATION;
297  goto error;
298  }
299 
300  sw = vnet_get_hw_sw_interface (vnm, ppif->hw_if_index);
301  ppif->sw_if_index = sw->sw_if_index;
302  ppif->per_interface_next_index = ~0;
303  args->sw_if_index = sw->sw_if_index;
305  mrvl_pp2_input_node.index);
311  goto done;
312 
313 error:
314  mrvl_pp2_delete_if (ppif);
315 done:
316  vec_free (s);
317 }
318 
319 static clib_error_t *
321  u32 flags)
322 {
324  vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
326  static clib_error_t *error = 0;
327  int is_up = (flags & VNET_SW_INTERFACE_FLAG_ADMIN_UP) != 0;
328  int rv;
329 
330  if (is_up)
331  rv = pp2_ppio_enable (ppif->ppio);
332  else
333  rv = pp2_ppio_disable (ppif->ppio);
334 
335  if (rv)
336  return clib_error_return (0, "failed to %s interface",
337  is_up ? "enable" : "disable");
338 
339  if (is_up)
340  ppif->flags |= MRVL_PP2_IF_F_ADMIN_UP;
341  else
342  ppif->flags &= ~MRVL_PP2_IF_F_ADMIN_UP;
343 
344  return error;
345 }
346 
347 static void
349 {
351  mrvl_pp2_if_t *ppif = pool_elt_at_index (ppm->interfaces, instance);
352  struct pp2_ppio_statistics stats;
353 
354  pp2_ppio_get_statistics (ppif->ppio, &stats, 1);
355 }
356 
357 static void
359  u32 node_index)
360 {
362  vnet_hw_interface_t *hw = vnet_get_hw_interface (vnm, hw_if_index);
364 
365  /* Shut off redirection */
366  if (node_index == ~0)
367  {
368  ppif->per_interface_next_index = node_index;
369  return;
370  }
371 
374  node_index);
375 }
376 
378 #define _(n,s) s,
380 #undef _
381 };
382 
383 /* *INDENT-OFF* */
385 {
386  .name = "Marvell PPv2 interface",
387  .format_device_name = format_mrvl_pp2_interface_name,
388  .format_device = format_mrvl_pp2_interface,
389  .tx_function = mrvl_pp2_interface_tx,
390  .tx_function_n_errors = MRVL_PP2_TX_N_ERROR,
391  .tx_function_error_strings = mrvl_pp2_tx_func_error_strings,
392  .admin_up_down_function = mrvl_pp2_interface_admin_up_down,
393  .clear_counters = mrvl_pp2_clear_interface_counters,
394  .rx_redirect_to_node = mrvl_pp2_set_interface_next_node,
395 };
396 /* *INDENT-ON* */
397 
398 static clib_error_t *
400 {
401  return 0;
402 }
403 
405 
406 /*
407  * fd.io coding-style-patch-verification: ON
408  *
409  * Local Variables:
410  * eval: (c-set-style "gnu")
411  * End:
412  */
struct pp2_ppio * ppio
Definition: pp2.h:55
static u32 mrvl_pp2_eth_flag_change(vnet_main_t *vnm, vnet_hw_interface_t *hi, u32 flags)
Definition: pp2.c:107
mrvl_pp2_outq_t * outqs
Definition: pp2.h:59
#define vec_foreach_index(var, v)
Iterate over vector indices.
#define NUM_BPOOLS_RSVD
Definition: pp2.c:34
u32 dev_instance
Definition: pp2.h:61
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:105
u16 head
Definition: pp2.h:46
static void vlib_buffer_free(vlib_main_t *vm, u32 *buffers, u32 n_buffers)
Free buffers Frees the entire buffer chain for each buffer.
Definition: buffer_funcs.h:937
void ethernet_delete_interface(vnet_main_t *vnm, u32 hw_if_index)
Definition: interface.c:393
vnet_main_t * vnet_get_main(void)
Definition: misc.c:46
#define pool_get_zero(P, E)
Allocate an object E from a pool P and zero it.
Definition: pool.h:254
struct pp2_ppio_desc * descs
Definition: pp2.h:72
static vnet_hw_interface_t * vnet_get_hw_interface(vnet_main_t *vnm, u32 hw_if_index)
u32 per_interface_next_index
Definition: pp2.h:56
mrvl_pp2_main_t mrvl_pp2_main
Definition: pp2.c:36
vnet_device_class_t mrvl_pp2_device_class
vlib_main_t * vm
Definition: in2out_ed.c:1580
#define vec_validate_aligned(V, I, A)
Make sure vector is long enough for given index (no header, specified alignment)
Definition: vec.h:520
#define MV_SYS_DMA_MEM_SZ
Definition: pp2.c:30
static clib_error_t * mrvl_pp2_main_init()
Definition: pp2.c:58
struct _vnet_device_class vnet_device_class_t
clib_error_t * vnet_hw_interface_set_flags(vnet_main_t *vnm, u32 hw_if_index, vnet_hw_interface_flags_t flags)
Definition: interface.c:509
static uword vlib_node_add_next(vlib_main_t *vm, uword node, uword next_node)
Definition: node_funcs.h:1173
unsigned char u8
Definition: types.h:56
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
u32 hw_if_index
Definition: pp2.h:63
static vnet_sw_interface_t * vnet_get_hw_sw_interface(vnet_main_t *vnm, u32 hw_if_index)
static clib_error_t * mrvl_pp2_init(vlib_main_t *vm)
Definition: pp2.c:399
struct pp2_bpool * bpool
Definition: pp2.h:38
static char * mrvl_pp2_tx_func_error_strings[]
Definition: pp2.c:377
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:173
#define foreach_mrvl_pp2_tx_func_error
Definition: pp2.h:107
format_function_t format_mrvl_pp2_interface
Definition: pp2.h:136
description fragment has unexpected format
Definition: map.api:433
u32 sw_if_index
Definition: pp2.h:62
#define vec_elt_at_index(v, i)
Get vector value at index i checking that i is in bounds.
#define clib_error_return(e, args...)
Definition: error.h:99
unsigned int u32
Definition: types.h:88
u16 size
Definition: pp2.h:44
#define VLIB_FRAME_SIZE
Definition: node.h:378
struct pp2_hif * hif
Definition: pp2.h:71
Definition: cJSON.c:84
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:546
unsigned short u16
Definition: types.h:57
int vnet_hw_interface_set_rx_mode(vnet_main_t *vnm, u32 hw_if_index, u16 queue_id, vnet_hw_if_rx_mode mode)
Definition: devices.c:253
static clib_error_t * mrvl_pp2_interface_admin_up_down(vnet_main_t *vnm, u32 hw_if_index, u32 flags)
Definition: pp2.c:320
u32 flags
Definition: pp2.h:53
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:301
vlib_node_registration_t mrvl_pp2_input_node
(constructor) VLIB_REGISTER_NODE (mrvl_pp2_input_node)
Definition: input.c:375
static_always_inline u32 vlib_buffer_get_default_data_size(vlib_main_t *vm)
Definition: buffer_funcs.h:96
VNET_DEVICE_CLASS(mrvl_pp2_device_class,)
u8 slot
Definition: pci_types.api:22
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
u32 * buffers
Definition: pp2.h:45
void mrvl_pp2_delete_if(mrvl_pp2_if_t *ppif)
Definition: pp2.c:115
#define NUM_HIFS_RSVD
Definition: pp2.c:32
void vnet_hw_interface_assign_rx_thread(vnet_main_t *vnm, u32 hw_if_index, u16 queue_id, uword thread_index)
Definition: devices.c:139
static void mrvl_pp2_clear_interface_counters(u32 instance)
Definition: pp2.c:348
void mrvl_pp2_create_if(mrvl_pp2_create_if_args_t *args)
Definition: pp2.c:180
u16 tail
Definition: pp2.h:47
static void mrvl_pp2_set_interface_next_node(vnet_main_t *vnm, u32 hw_if_index, u32 node_index)
Definition: pp2.c:358
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
vl_api_ip4_address_t hi
Definition: arp.api:37
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
clib_error_t * ethernet_register_interface(vnet_main_t *vnm, u32 dev_class_index, u32 dev_instance, const u8 *address, u32 *hw_if_index_return, ethernet_flag_change_function_t flag_change)
Definition: interface.c:348
vl_api_mac_address_t mac_addr
Definition: l2.api:180
u32 instance
Definition: gre.api:51
format_function_t format_mrvl_pp2_interface_name
Definition: pp2.h:137
uword mrvl_pp2_interface_tx(vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
Definition: output.c:31
int vnet_hw_interface_unassign_rx_thread(vnet_main_t *vnm, u32 hw_if_index, u16 queue_id)
Definition: devices.c:188
clib_error_t * error
Definition: pp2.h:98
static vlib_thread_main_t * vlib_get_thread_main()
Definition: global_funcs.h:32
#define vec_foreach(var, vec)
Vector iterator.
mrvl_pp2_if_t * interfaces
Definition: pp2.h:79
mrvl_pp2_per_thread_data_t * per_thread_data
Definition: pp2.h:80
static void mrvl_pp2_main_deinit()
Definition: pp2.c:40
#define CLIB_CACHE_LINE_BYTES
Definition: cache.h:59
mrvl_pp2_inq_t * inqs
Definition: pp2.h:58
vnet_device_class_t ppa2_device_class
static void vnet_hw_interface_set_input_node(vnet_main_t *vnm, u32 hw_if_index, u32 node_index)
Definition: devices.h:79
#define MRVL_PP2_IF_F_ADMIN_UP
Definition: pp2.h:54
u16 size
Definition: pp2.h:37
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:127