devargs: add common key definition
[dpdk.git] / drivers / net / bonding / rte_eth_bond_args.c
1 /* SPDX-License-Identifier: BSD-3-Clause
2  * Copyright(c) 2010-2014 Intel Corporation
3  */
4
5 #include <rte_devargs.h>
6 #include <rte_pci.h>
7 #include <rte_bus_pci.h>
8 #include <rte_kvargs.h>
9
10 #include "rte_eth_bond.h"
11 #include "eth_bond_private.h"
12
13 const char *pmd_bond_init_valid_arguments[] = {
14         PMD_BOND_SLAVE_PORT_KVARG,
15         PMD_BOND_PRIMARY_SLAVE_KVARG,
16         PMD_BOND_MODE_KVARG,
17         PMD_BOND_XMIT_POLICY_KVARG,
18         PMD_BOND_SOCKET_ID_KVARG,
19         PMD_BOND_MAC_ADDR_KVARG,
20         PMD_BOND_AGG_MODE_KVARG,
21         RTE_DEVARGS_KEY_DRIVER,
22         NULL
23 };
24
25 static inline int
26 bond_pci_addr_cmp(const struct rte_device *dev, const void *_pci_addr)
27 {
28         const struct rte_pci_device *pdev = RTE_DEV_TO_PCI_CONST(dev);
29         const struct rte_pci_addr *paddr = _pci_addr;
30
31         return rte_pci_addr_cmp(&pdev->addr, paddr);
32 }
33
34 static inline int
35 find_port_id_by_pci_addr(const struct rte_pci_addr *pci_addr)
36 {
37         struct rte_bus *pci_bus;
38         struct rte_device *dev;
39         unsigned i;
40
41         pci_bus = rte_bus_find_by_name("pci");
42         if (pci_bus == NULL) {
43                 RTE_BOND_LOG(ERR, "No PCI bus found");
44                 return -1;
45         }
46
47         dev = pci_bus->find_device(NULL, bond_pci_addr_cmp, pci_addr);
48         if (dev == NULL) {
49                 RTE_BOND_LOG(ERR, "unable to find PCI device");
50                 return -1;
51         }
52
53         RTE_ETH_FOREACH_DEV(i)
54                 if (rte_eth_devices[i].device == dev)
55                         return i;
56         return -1;
57 }
58
59 static inline int
60 find_port_id_by_dev_name(const char *name)
61 {
62         unsigned i;
63
64         RTE_ETH_FOREACH_DEV(i) {
65                 if (rte_eth_devices[i].data == NULL)
66                         continue;
67
68                 if (strcmp(rte_eth_devices[i].device->name, name) == 0)
69                         return i;
70         }
71         return -1;
72 }
73
74 /**
75  * Parses a port identifier string to a port id by pci address, then by name,
76  * and finally port id.
77  */
78 static inline int
79 parse_port_id(const char *port_str)
80 {
81         struct rte_pci_addr dev_addr;
82         int port_id;
83
84         /* try parsing as pci address, physical devices */
85         if (rte_pci_addr_parse(port_str, &dev_addr) == 0) {
86                 port_id = find_port_id_by_pci_addr(&dev_addr);
87                 if (port_id < 0)
88                         return -1;
89         } else {
90                 /* try parsing as device name, virtual devices */
91                 port_id = find_port_id_by_dev_name(port_str);
92                 if (port_id < 0) {
93                         char *end;
94                         errno = 0;
95
96                         /* try parsing as port id */
97                         port_id = strtol(port_str, &end, 10);
98                         if (*end != 0 || errno != 0)
99                                 return -1;
100                 }
101         }
102
103         if (!rte_eth_dev_is_valid_port(port_id)) {
104                 RTE_BOND_LOG(ERR, "Specified port (%s) is invalid", port_str);
105                 return -1;
106         }
107         return port_id;
108 }
109
110 int
111 bond_ethdev_parse_slave_port_kvarg(const char *key,
112                 const char *value, void *extra_args)
113 {
114         struct bond_ethdev_slave_ports *slave_ports;
115
116         if (value == NULL || extra_args == NULL)
117                 return -1;
118
119         slave_ports = extra_args;
120
121         if (strcmp(key, PMD_BOND_SLAVE_PORT_KVARG) == 0) {
122                 int port_id = parse_port_id(value);
123                 if (port_id < 0) {
124                         RTE_BOND_LOG(ERR, "Invalid slave port value (%s) specified",
125                                      value);
126                         return -1;
127                 } else
128                         slave_ports->slaves[slave_ports->slave_count++] =
129                                         port_id;
130         }
131         return 0;
132 }
133
134 int
135 bond_ethdev_parse_slave_mode_kvarg(const char *key __rte_unused,
136                 const char *value, void *extra_args)
137 {
138         uint8_t *mode;
139         char *endptr;
140
141         if (value == NULL || extra_args == NULL)
142                 return -1;
143
144         mode = extra_args;
145
146         errno = 0;
147         *mode = strtol(value, &endptr, 10);
148         if (*endptr != 0 || errno != 0)
149                 return -1;
150
151         /* validate mode value */
152         switch (*mode) {
153         case BONDING_MODE_ROUND_ROBIN:
154         case BONDING_MODE_ACTIVE_BACKUP:
155         case BONDING_MODE_BALANCE:
156         case BONDING_MODE_BROADCAST:
157         case BONDING_MODE_8023AD:
158         case BONDING_MODE_TLB:
159         case BONDING_MODE_ALB:
160                 return 0;
161         default:
162                 RTE_BOND_LOG(ERR, "Invalid slave mode value (%s) specified", value);
163                 return -1;
164         }
165 }
166
167 int
168 bond_ethdev_parse_slave_agg_mode_kvarg(const char *key __rte_unused,
169                 const char *value, void *extra_args)
170 {
171         uint8_t *agg_mode;
172
173         if (value == NULL || extra_args == NULL)
174                 return -1;
175
176         agg_mode = extra_args;
177
178         errno = 0;
179         if (strncmp(value, "stable", 6) == 0)
180                 *agg_mode = AGG_STABLE;
181
182         if (strncmp(value, "bandwidth", 9) == 0)
183                 *agg_mode = AGG_BANDWIDTH;
184
185         if (strncmp(value, "count", 5) == 0)
186                 *agg_mode = AGG_COUNT;
187
188         switch (*agg_mode) {
189         case AGG_STABLE:
190         case AGG_BANDWIDTH:
191         case AGG_COUNT:
192                 return 0;
193         default:
194                 RTE_BOND_LOG(ERR, "Invalid agg mode value stable/bandwidth/count");
195                 return -1;
196         }
197 }
198
199 int
200 bond_ethdev_parse_socket_id_kvarg(const char *key __rte_unused,
201                 const char *value, void *extra_args)
202 {
203         long socket_id;
204         char *endptr;
205
206         if (value == NULL || extra_args == NULL)
207                 return -1;
208
209         errno = 0;
210         socket_id = strtol(value, &endptr, 10);
211         if (*endptr != 0 || errno != 0)
212                 return -1;
213
214         /* validate socket id value */
215         if (socket_id >= 0 && socket_id < RTE_MAX_NUMA_NODES) {
216                 *(int *)extra_args = (int)socket_id;
217                 return 0;
218         }
219         return -1;
220 }
221
222 int
223 bond_ethdev_parse_primary_slave_port_id_kvarg(const char *key __rte_unused,
224                 const char *value, void *extra_args)
225 {
226         int primary_slave_port_id;
227
228         if (value == NULL || extra_args == NULL)
229                 return -1;
230
231         primary_slave_port_id = parse_port_id(value);
232         if (primary_slave_port_id < 0)
233                 return -1;
234
235         *(uint16_t *)extra_args = (uint16_t)primary_slave_port_id;
236
237         return 0;
238 }
239
240 int
241 bond_ethdev_parse_balance_xmit_policy_kvarg(const char *key __rte_unused,
242                 const char *value, void *extra_args)
243 {
244         uint8_t *xmit_policy;
245
246         if (value == NULL || extra_args == NULL)
247                 return -1;
248
249         xmit_policy = extra_args;
250
251         if (strcmp(PMD_BOND_XMIT_POLICY_LAYER2_KVARG, value) == 0)
252                 *xmit_policy = BALANCE_XMIT_POLICY_LAYER2;
253         else if (strcmp(PMD_BOND_XMIT_POLICY_LAYER23_KVARG, value) == 0)
254                 *xmit_policy = BALANCE_XMIT_POLICY_LAYER23;
255         else if (strcmp(PMD_BOND_XMIT_POLICY_LAYER34_KVARG, value) == 0)
256                 *xmit_policy = BALANCE_XMIT_POLICY_LAYER34;
257         else
258                 return -1;
259
260         return 0;
261 }
262
263 int
264 bond_ethdev_parse_bond_mac_addr_kvarg(const char *key __rte_unused,
265                 const char *value, void *extra_args)
266 {
267         if (value == NULL || extra_args == NULL)
268                 return -1;
269
270         /* Parse MAC */
271         return rte_ether_unformat_addr(value, extra_args);
272 }
273
274 int
275 bond_ethdev_parse_time_ms_kvarg(const char *key __rte_unused,
276                 const char *value, void *extra_args)
277 {
278         uint32_t time_ms;
279         char *endptr;
280
281         if (value == NULL || extra_args == NULL)
282                 return -1;
283
284         errno = 0;
285         time_ms = (uint32_t)strtol(value, &endptr, 10);
286         if (*endptr != 0 || errno != 0)
287                 return -1;
288
289         *(uint32_t *)extra_args = time_ms;
290
291         return 0;
292 }