xref: /dpdk/drivers/net/ark/ark_pktgen.c (revision bbbe38a6d59ccdda25917712701e629d0b10af6f) 
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright (c) 2015-2018 Atomic Rules LLC
3  */
4 
5 #include <unistd.h>
6 #include <pthread.h>
7 
8 #include <rte_string_fns.h>
9 #include <rte_malloc.h>
10 
11 #include "ark_pktgen.h"
12 #include "ark_logs.h"
13 
14 #define ARK_MAX_STR_LEN 64
15 union OPTV {
16 	int INT;
17 	int BOOL;
18 	uint64_t LONG;
19 	char STR[ARK_MAX_STR_LEN];
20 };
21 
22 enum OPTYPE {
23 	OTINT,
24 	OTLONG,
25 	OTBOOL,
26 	OTSTRING
27 };
28 
29 struct OPTIONS {
30 	char opt[ARK_MAX_STR_LEN];
31 	enum OPTYPE t;
32 	union OPTV v;
33 };
34 
35 static struct OPTIONS toptions[] = {
36 	{{"configure"}, OTBOOL, {1} },
37 	{{"dg-mode"}, OTBOOL, {1} },
38 	{{"run"}, OTBOOL, {0} },
39 	{{"pause"}, OTBOOL, {0} },
40 	{{"reset"}, OTBOOL, {0} },
41 	{{"dump"}, OTBOOL, {0} },
42 	{{"gen_forever"}, OTBOOL, {0} },
43 	{{"en_slaved_start"}, OTBOOL, {0} },
44 	{{"vary_length"}, OTBOOL, {0} },
45 	{{"incr_payload"}, OTBOOL, {0} },
46 	{{"incr_first_byte"}, OTBOOL, {0} },
47 	{{"ins_seq_num"}, OTBOOL, {0} },
48 	{{"ins_time_stamp"}, OTBOOL, {1} },
49 	{{"ins_udp_hdr"}, OTBOOL, {0} },
50 	{{"num_pkts"}, OTLONG, .v.LONG = 100000000},
51 	{{"payload_byte"}, OTINT, {0x55} },
52 	{{"pkt_spacing"}, OTINT, {130} },
53 	{{"pkt_size_min"}, OTINT, {2006} },
54 	{{"pkt_size_max"}, OTINT, {1514} },
55 	{{"pkt_size_incr"}, OTINT, {1} },
56 	{{"eth_type"}, OTINT, {0x0800} },
57 	{{"src_mac_addr"}, OTLONG, .v.LONG = 0xdC3cF6425060L},
58 	{{"dst_mac_addr"}, OTLONG, .v.LONG = 0x112233445566L},
59 	{{"hdr_dW0"}, OTINT, {0x0016e319} },
60 	{{"hdr_dW1"}, OTINT, {0x27150004} },
61 	{{"hdr_dW2"}, OTINT, {0x76967bda} },
62 	{{"hdr_dW3"}, OTINT, {0x08004500} },
63 	{{"hdr_dW4"}, OTINT, {0x005276ed} },
64 	{{"hdr_dW5"}, OTINT, {0x40004006} },
65 	{{"hdr_dW6"}, OTINT, {0x56cfc0a8} },
66 	{{"start_offset"}, OTINT, {0} },
67 	{{"bytes_per_cycle"}, OTINT, {10} },
68 	{{"shaping"}, OTBOOL, {0} },
69 	{{"dst_ip"}, OTSTRING, .v.STR = "169.254.10.240"},
70 	{{"dst_port"}, OTINT, {65536} },
71 	{{"src_port"}, OTINT, {65536} },
72 };
73 
74 ark_pkt_gen_t
75 ark_pktgen_init(void *adr, int ord, int l2_mode)
76 {
77 	struct ark_pkt_gen_inst *inst =
78 		rte_malloc("ark_pkt_gen_inst_pmd",
79 			   sizeof(struct ark_pkt_gen_inst), 0);
80 	if (inst == NULL) {
81 		ARK_PMD_LOG(ERR, "Failed to malloc ark_pkt_gen_inst.\n");
82 		return inst;
83 	}
84 	inst->regs = (struct ark_pkt_gen_regs *)adr;
85 	inst->ordinal = ord;
86 	inst->l2_mode = l2_mode;
87 	return inst;
88 }
89 
90 void
91 ark_pktgen_uninit(ark_pkt_gen_t handle)
92 {
93 	rte_free(handle);
94 }
95 
96 void
97 ark_pktgen_run(ark_pkt_gen_t handle)
98 {
99 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
100 
101 	inst->regs->pkt_start_stop = 1;
102 }
103 
104 uint32_t
105 ark_pktgen_paused(ark_pkt_gen_t handle)
106 {
107 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
108 	uint32_t r = inst->regs->pkt_start_stop;
109 
110 	return (((r >> 16) & 1) == 1);
111 }
112 
113 void
114 ark_pktgen_pause(ark_pkt_gen_t handle)
115 {
116 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
117 	int cnt = 0;
118 
119 	inst->regs->pkt_start_stop = 0;
120 
121 	while (!ark_pktgen_paused(handle)) {
122 		usleep(1000);
123 		if (cnt++ > 100) {
124 			ARK_PMD_LOG(NOTICE, "Pktgen %d failed to pause.\n",
125 				    inst->ordinal);
126 			break;
127 		}
128 	}
129 	ARK_PMD_LOG(DEBUG, "Pktgen %d paused.\n", inst->ordinal);
130 }
131 
132 void
133 ark_pktgen_reset(ark_pkt_gen_t handle)
134 {
135 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
136 
137 	if (!ark_pktgen_is_running(handle) &&
138 	    !ark_pktgen_paused(handle)) {
139 		ARK_PMD_LOG(DEBUG, "Pktgen %d is not running"
140 			      " and is not paused. No need to reset.\n",
141 			      inst->ordinal);
142 		return;
143 	}
144 
145 	if (ark_pktgen_is_running(handle) &&
146 	    !ark_pktgen_paused(handle)) {
147 		ARK_PMD_LOG(DEBUG,
148 			      "Pktgen %d is not paused. Pausing first.\n",
149 			      inst->ordinal);
150 		ark_pktgen_pause(handle);
151 	}
152 
153 	ARK_PMD_LOG(DEBUG, "Resetting pktgen %d.\n", inst->ordinal);
154 	inst->regs->pkt_start_stop = (1 << 8);
155 }
156 
157 uint32_t
158 ark_pktgen_tx_done(ark_pkt_gen_t handle)
159 {
160 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
161 	uint32_t r = inst->regs->pkt_start_stop;
162 
163 	return (((r >> 24) & 1) == 1);
164 }
165 
166 uint32_t
167 ark_pktgen_is_running(ark_pkt_gen_t handle)
168 {
169 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
170 	uint32_t r = inst->regs->pkt_start_stop;
171 
172 	return ((r & 1) == 1);
173 }
174 
175 uint32_t
176 ark_pktgen_is_gen_forever(ark_pkt_gen_t handle)
177 {
178 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
179 	uint32_t r = inst->regs->pkt_ctrl;
180 
181 	return (((r >> 24) & 1) == 1);
182 }
183 
184 void
185 ark_pktgen_wait_done(ark_pkt_gen_t handle)
186 {
187 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
188 	int wait_cycle = 10;
189 
190 	if (ark_pktgen_is_gen_forever(handle))
191 		ARK_PMD_LOG(NOTICE, "Pktgen wait_done will not terminate"
192 			    " because gen_forever=1\n");
193 
194 	while (!ark_pktgen_tx_done(handle) && (wait_cycle > 0)) {
195 		usleep(1000);
196 		wait_cycle--;
197 		ARK_PMD_LOG(DEBUG,
198 			      "Waiting for pktgen %d to finish sending...\n",
199 			      inst->ordinal);
200 	}
201 	ARK_PMD_LOG(DEBUG, "Pktgen %d done.\n", inst->ordinal);
202 }
203 
204 uint32_t
205 ark_pktgen_get_pkts_sent(ark_pkt_gen_t handle)
206 {
207 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
208 	return inst->regs->pkts_sent;
209 }
210 
211 void
212 ark_pktgen_set_payload_byte(ark_pkt_gen_t handle, uint32_t b)
213 {
214 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
215 	inst->regs->pkt_payload = b;
216 }
217 
218 void
219 ark_pktgen_set_pkt_spacing(ark_pkt_gen_t handle, uint32_t x)
220 {
221 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
222 	inst->regs->pkt_spacing = x;
223 }
224 
225 void
226 ark_pktgen_set_pkt_size_min(ark_pkt_gen_t handle, uint32_t x)
227 {
228 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
229 	inst->regs->pkt_size_min = x;
230 }
231 
232 void
233 ark_pktgen_set_pkt_size_max(ark_pkt_gen_t handle, uint32_t x)
234 {
235 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
236 	inst->regs->pkt_size_max = x;
237 }
238 
239 void
240 ark_pktgen_set_pkt_size_incr(ark_pkt_gen_t handle, uint32_t x)
241 {
242 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
243 	inst->regs->pkt_size_incr = x;
244 }
245 
246 void
247 ark_pktgen_set_num_pkts(ark_pkt_gen_t handle, uint32_t x)
248 {
249 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
250 	inst->regs->num_pkts = x;
251 }
252 
253 void
254 ark_pktgen_set_src_mac_addr(ark_pkt_gen_t handle, uint64_t mac_addr)
255 {
256 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
257 	inst->regs->src_mac_addr_h = (mac_addr >> 32) & 0xffff;
258 	inst->regs->src_mac_addr_l = mac_addr & 0xffffffff;
259 }
260 
261 void
262 ark_pktgen_set_dst_mac_addr(ark_pkt_gen_t handle, uint64_t mac_addr)
263 {
264 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
265 	inst->regs->dst_mac_addr_h = (mac_addr >> 32) & 0xffff;
266 	inst->regs->dst_mac_addr_l = mac_addr & 0xffffffff;
267 }
268 
269 void
270 ark_pktgen_set_eth_type(ark_pkt_gen_t handle, uint32_t x)
271 {
272 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
273 	inst->regs->eth_type = x;
274 }
275 
276 void
277 ark_pktgen_set_hdr_dW(ark_pkt_gen_t handle, uint32_t *hdr)
278 {
279 	uint32_t i;
280 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
281 
282 	for (i = 0; i < 7; i++)
283 		inst->regs->hdr_dw[i] = hdr[i];
284 }
285 
286 void
287 ark_pktgen_set_start_offset(ark_pkt_gen_t handle, uint32_t x)
288 {
289 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
290 
291 	inst->regs->start_offset = x;
292 }
293 
294 static struct OPTIONS *
295 options(const char *id)
296 {
297 	unsigned int i;
298 
299 	for (i = 0; i < sizeof(toptions) / sizeof(struct OPTIONS); i++) {
300 		if (strcmp(id, toptions[i].opt) == 0)
301 			return &toptions[i];
302 	}
303 
304 	ARK_PMD_LOG(ERR,
305 		    "Pktgen: Could not find requested option!, "
306 		    "option = %s\n",
307 		    id
308 		    );
309 	return NULL;
310 }
311 
312 static int pmd_set_arg(char *arg, char *val);
313 static int
314 pmd_set_arg(char *arg, char *val)
315 {
316 	struct OPTIONS *o = options(arg);
317 
318 	if (o) {
319 		switch (o->t) {
320 		case OTINT:
321 		case OTBOOL:
322 			o->v.INT = atoi(val);
323 			break;
324 		case OTLONG:
325 			o->v.INT = atoll(val);
326 			break;
327 		case OTSTRING:
328 			strlcpy(o->v.STR, val, ARK_MAX_STR_LEN);
329 			break;
330 		}
331 		return 1;
332 	}
333 	return 0;
334 }
335 
336 /******
337  * Arg format = "opt0=v,opt_n=v ..."
338  ******/
339 void
340 ark_pktgen_parse(char *args)
341 {
342 	char *argv, *v;
343 	const char toks[] = " =\n\t\v\f \r";
344 	argv = strtok(args, toks);
345 	v = strtok(NULL, toks);
346 	while (argv && v) {
347 		pmd_set_arg(argv, v);
348 		argv = strtok(NULL, toks);
349 		v = strtok(NULL, toks);
350 	}
351 }
352 
353 static int32_t parse_ipv4_string(char const *ip_address);
354 static int32_t
355 parse_ipv4_string(char const *ip_address)
356 {
357 	unsigned int ip[4];
358 
359 	if (sscanf(ip_address, "%u.%u.%u.%u",
360 		   &ip[0], &ip[1], &ip[2], &ip[3]) != 4)
361 		return 0;
362 	return ip[3] + ip[2] * 0x100 + ip[1] * 0x10000ul + ip[0] * 0x1000000ul;
363 }
364 
365 static void
366 ark_pktgen_set_pkt_ctrl(ark_pkt_gen_t handle,
367 			uint32_t gen_forever,
368 			uint32_t en_slaved_start,
369 			uint32_t vary_length,
370 			uint32_t incr_payload,
371 			uint32_t incr_first_byte,
372 			uint32_t ins_seq_num,
373 			uint32_t ins_udp_hdr,
374 			uint32_t ins_time_stamp)
375 {
376 	uint32_t r;
377 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)handle;
378 
379 	if (!inst->l2_mode)
380 		ins_udp_hdr = 0;
381 
382 	r = ((gen_forever << 24) |
383 	     (en_slaved_start << 20) |
384 	     (vary_length << 16) |
385 	     (incr_payload << 12) |
386 	     (incr_first_byte << 8) |
387 	     (ins_time_stamp << 5) |
388 	     (ins_seq_num << 4) |
389 	     ins_udp_hdr);
390 
391 	inst->regs->bytes_per_cycle = options("bytes_per_cycle")->v.INT;
392 	if (options("shaping")->v.BOOL)
393 		r = r | (1 << 28);	/* enable shaping */
394 
395 	inst->regs->pkt_ctrl = r;
396 }
397 
398 void
399 ark_pktgen_setup(ark_pkt_gen_t handle)
400 {
401 	uint32_t hdr[7];
402 	int32_t dst_ip = parse_ipv4_string(options("dst_ip")->v.STR);
403 
404 	if (!options("pause")->v.BOOL &&
405 	    (!options("reset")->v.BOOL &&
406 	     (options("configure")->v.BOOL))) {
407 		ark_pktgen_set_payload_byte(handle,
408 					    options("payload_byte")->v.INT);
409 		ark_pktgen_set_src_mac_addr(handle,
410 					    options("src_mac_addr")->v.INT);
411 		ark_pktgen_set_dst_mac_addr(handle,
412 					    options("dst_mac_addr")->v.LONG);
413 		ark_pktgen_set_eth_type(handle,
414 					options("eth_type")->v.INT);
415 
416 		if (options("dg-mode")->v.BOOL) {
417 			hdr[0] = options("hdr_dW0")->v.INT;
418 			hdr[1] = options("hdr_dW1")->v.INT;
419 			hdr[2] = options("hdr_dW2")->v.INT;
420 			hdr[3] = options("hdr_dW3")->v.INT;
421 			hdr[4] = options("hdr_dW4")->v.INT;
422 			hdr[5] = options("hdr_dW5")->v.INT;
423 			hdr[6] = options("hdr_dW6")->v.INT;
424 		} else {
425 			hdr[0] = dst_ip;
426 			hdr[1] = options("dst_port")->v.INT;
427 			hdr[2] = options("src_port")->v.INT;
428 			hdr[3] = 0;
429 			hdr[4] = 0;
430 			hdr[5] = 0;
431 			hdr[6] = 0;
432 		}
433 		ark_pktgen_set_hdr_dW(handle, hdr);
434 		ark_pktgen_set_num_pkts(handle,
435 					options("num_pkts")->v.INT);
436 		ark_pktgen_set_pkt_size_min(handle,
437 					    options("pkt_size_min")->v.INT);
438 		ark_pktgen_set_pkt_size_max(handle,
439 					    options("pkt_size_max")->v.INT);
440 		ark_pktgen_set_pkt_size_incr(handle,
441 					     options("pkt_size_incr")->v.INT);
442 		ark_pktgen_set_pkt_spacing(handle,
443 					   options("pkt_spacing")->v.INT);
444 		ark_pktgen_set_start_offset(handle,
445 					    options("start_offset")->v.INT);
446 		ark_pktgen_set_pkt_ctrl(handle,
447 					options("gen_forever")->v.BOOL,
448 					options("en_slaved_start")->v.BOOL,
449 					options("vary_length")->v.BOOL,
450 					options("incr_payload")->v.BOOL,
451 					options("incr_first_byte")->v.BOOL,
452 					options("ins_seq_num")->v.INT,
453 					options("ins_udp_hdr")->v.BOOL,
454 					options("ins_time_stamp")->v.INT);
455 	}
456 
457 	if (options("pause")->v.BOOL)
458 		ark_pktgen_pause(handle);
459 
460 	if (options("reset")->v.BOOL)
461 		ark_pktgen_reset(handle);
462 	if (options("run")->v.BOOL) {
463 		ARK_PMD_LOG(DEBUG, "Starting packet generator on port %d\n",
464 				options("port")->v.INT);
465 		ark_pktgen_run(handle);
466 	}
467 }
468 
469 void *
470 ark_pktgen_delay_start(void *arg)
471 {
472 	struct ark_pkt_gen_inst *inst = (struct ark_pkt_gen_inst *)arg;
473 
474 	/* This function is used exclusively for regression testing, We
475 	 * perform a blind sleep here to ensure that the external test
476 	 * application has time to setup the test before we generate packets
477 	 */
478 	pthread_detach(pthread_self());
479 	usleep(100000);
480 	ark_pktgen_run(inst);
481 	return NULL;
482 }
483