1 /* SPDX-License-Identifier: BSD-3-Clause
3 * Copyright(c) 2019-2021 Xilinx, Inc.
4 * Copyright(c) 2019 Solarflare Communications Inc.
6 * This software was jointly developed between OKTET Labs (under contract
7 * for Solarflare) and Solarflare Communications, Inc.
12 #include <rte_common.h>
13 #include <rte_spinlock.h>
19 #include "sfc_switch.h"
22 * Switch port registry entry.
24 * Drivers aware of RTE switch domains also have to maintain RTE switch
25 * port IDs for RTE ethdev instances they operate. These IDs are supposed
26 * to stand for physical interconnect entities, in example, PCIe functions.
28 * In terms of MAE, a physical interconnect entity can be referred to using
29 * an MPORT selector, that is, a 32-bit value. RTE switch port IDs, in turn,
30 * are 16-bit values, so indirect mapping has to be maintained:
32 * +--------------------+ +---------------------------------------+
33 * | RTE switch port ID | ------ | MAE switch port entry |
34 * +--------------------+ | --------------------- |
36 * | Entity (PCIe function) MPORT selector |
38 * | Port type (independent/representor) |
39 * +---------------------------------------+
41 * This mapping comprises a port type to ensure that RTE switch port ID
42 * of a represented entity and that of its representor are different in
43 * the case when the entity gets plugged into DPDK and not into a guest.
45 * Entry data also comprises RTE ethdev's own MPORT. This value
46 * coincides with the entity MPORT in the case of independent ports.
47 * In the case of representors, this ID is not a selector and refers
48 * to an allocatable object (that is, it's likely to change on RTE
49 * ethdev replug). Flow API backend must use this value rather
50 * than entity_mport to support flow rule action PORT_ID.
52 struct sfc_mae_switch_port {
53 TAILQ_ENTRY(sfc_mae_switch_port) switch_domain_ports;
55 /** RTE ethdev MPORT */
56 efx_mport_sel_t ethdev_mport;
57 /** RTE ethdev port ID */
58 uint16_t ethdev_port_id;
60 /** Entity (PCIe function) MPORT selector */
61 efx_mport_sel_t entity_mport;
62 /** Port type (independent/representor) */
63 enum sfc_mae_switch_port_type type;
64 /** RTE switch port ID */
67 union sfc_mae_switch_port_data data;
70 TAILQ_HEAD(sfc_mae_switch_ports, sfc_mae_switch_port);
73 * Switch domain registry entry.
75 * Even if an RTE ethdev instance gets unplugged, the corresponding
76 * entry in the switch port registry will not be removed because the
77 * entity (PCIe function) MPORT is static and cannot change. If this
78 * RTE ethdev gets plugged back, the entry will be reused, and
79 * RTE switch port ID will be the same.
81 struct sfc_mae_switch_domain {
82 TAILQ_ENTRY(sfc_mae_switch_domain) entries;
85 struct sfc_hw_switch_id *hw_switch_id;
86 /** The number of ports in the switch port registry */
87 unsigned int nb_ports;
88 /** Switch port registry */
89 struct sfc_mae_switch_ports ports;
90 /** RTE switch domain ID allocated for a group of devices */
92 /** DPDK controller -> EFX interface mapping */
93 efx_pcie_interface_t *controllers;
94 /** Number of DPDK controllers and EFX interfaces */
95 size_t nb_controllers;
98 TAILQ_HEAD(sfc_mae_switch_domains, sfc_mae_switch_domain);
101 * MAE representation of RTE switch infrastructure.
103 * It is possible that an RTE flow API client tries to insert a rule
104 * referencing an RTE ethdev deployed on top of a different physical
105 * device (it may belong to the same vendor or not). This particular
106 * driver/engine cannot support this and has to turn down such rules.
108 * Technically, it's HW switch identifier which, if queried for each
109 * RTE ethdev instance, indicates relationship between the instances.
110 * In the meantime, RTE flow API clients also need to somehow figure
111 * out relationship between RTE ethdev instances in advance.
113 * The concept of RTE switch domains resolves this issue. The driver
114 * maintains a static list of switch domains which is easy to browse,
115 * and each RTE ethdev fills RTE switch parameters in device
116 * information structure which is made available to clients.
118 * Even if all RTE ethdev instances belonging to a switch domain get
119 * unplugged, the corresponding entry in the switch domain registry
120 * will not be removed because the corresponding HW switch exists
121 * regardless of its ports being plugged to DPDK or kept aside.
122 * If a port gets plugged back to DPDK, the corresponding
123 * RTE ethdev will indicate the same RTE switch domain ID.
125 struct sfc_mae_switch {
126 /** A lock to protect the whole structure */
128 /** Switch domain registry */
129 struct sfc_mae_switch_domains domains;
132 static struct sfc_mae_switch sfc_mae_switch = {
133 .lock = RTE_SPINLOCK_INITIALIZER,
134 .domains = TAILQ_HEAD_INITIALIZER(sfc_mae_switch.domains),
138 /* This function expects to be called only when the lock is held */
139 static struct sfc_mae_switch_domain *
140 sfc_mae_find_switch_domain_by_id(uint16_t switch_domain_id)
142 struct sfc_mae_switch_domain *domain;
144 SFC_ASSERT(rte_spinlock_is_locked(&sfc_mae_switch.lock));
146 TAILQ_FOREACH(domain, &sfc_mae_switch.domains, entries) {
147 if (domain->id == switch_domain_id)
154 /* This function expects to be called only when the lock is held */
155 static struct sfc_mae_switch_domain *
156 sfc_mae_find_switch_domain_by_hw_switch_id(const struct sfc_hw_switch_id *id)
158 struct sfc_mae_switch_domain *domain;
160 SFC_ASSERT(rte_spinlock_is_locked(&sfc_mae_switch.lock));
162 TAILQ_FOREACH(domain, &sfc_mae_switch.domains, entries) {
163 if (sfc_hw_switch_ids_equal(domain->hw_switch_id, id))
171 sfc_mae_assign_switch_domain(struct sfc_adapter *sa,
172 uint16_t *switch_domain_id)
174 struct sfc_hw_switch_id *hw_switch_id;
175 struct sfc_mae_switch_domain *domain;
178 rte_spinlock_lock(&sfc_mae_switch.lock);
180 rc = sfc_hw_switch_id_init(sa, &hw_switch_id);
182 goto fail_hw_switch_id_init;
184 domain = sfc_mae_find_switch_domain_by_hw_switch_id(hw_switch_id);
185 if (domain != NULL) {
186 sfc_hw_switch_id_fini(sa, hw_switch_id);
190 domain = rte_zmalloc("sfc_mae_switch_domain", sizeof(*domain), 0);
191 if (domain == NULL) {
197 * This code belongs to driver init path, that is, negation is
198 * done at the end of the path by sfc_eth_dev_init(). RTE APIs
199 * negate error codes, so drop negation here.
201 rc = -rte_eth_switch_domain_alloc(&domain->id);
203 goto fail_domain_alloc;
205 domain->hw_switch_id = hw_switch_id;
207 TAILQ_INIT(&domain->ports);
209 TAILQ_INSERT_TAIL(&sfc_mae_switch.domains, domain, entries);
212 *switch_domain_id = domain->id;
214 rte_spinlock_unlock(&sfc_mae_switch.lock);
222 sfc_hw_switch_id_fini(sa, hw_switch_id);
224 fail_hw_switch_id_init:
225 rte_spinlock_unlock(&sfc_mae_switch.lock);
230 sfc_mae_switch_domain_controllers(uint16_t switch_domain_id,
231 const efx_pcie_interface_t **controllers,
232 size_t *nb_controllers)
234 struct sfc_mae_switch_domain *domain;
236 if (controllers == NULL || nb_controllers == NULL)
239 rte_spinlock_lock(&sfc_mae_switch.lock);
241 domain = sfc_mae_find_switch_domain_by_id(switch_domain_id);
242 if (domain == NULL) {
243 rte_spinlock_unlock(&sfc_mae_switch.lock);
247 *controllers = domain->controllers;
248 *nb_controllers = domain->nb_controllers;
250 rte_spinlock_unlock(&sfc_mae_switch.lock);
255 sfc_mae_switch_domain_map_controllers(uint16_t switch_domain_id,
256 efx_pcie_interface_t *controllers,
257 size_t nb_controllers)
259 struct sfc_mae_switch_domain *domain;
261 rte_spinlock_lock(&sfc_mae_switch.lock);
263 domain = sfc_mae_find_switch_domain_by_id(switch_domain_id);
264 if (domain == NULL) {
265 rte_spinlock_unlock(&sfc_mae_switch.lock);
269 /* Controller mapping may be set only once */
270 if (domain->controllers != NULL) {
271 rte_spinlock_unlock(&sfc_mae_switch.lock);
275 domain->controllers = controllers;
276 domain->nb_controllers = nb_controllers;
278 rte_spinlock_unlock(&sfc_mae_switch.lock);
283 sfc_mae_switch_domain_get_controller(uint16_t switch_domain_id,
284 efx_pcie_interface_t intf,
287 const efx_pcie_interface_t *controllers;
288 size_t nb_controllers;
292 rc = sfc_mae_switch_domain_controllers(switch_domain_id, &controllers,
297 if (controllers == NULL)
300 for (i = 0; i < nb_controllers; i++) {
301 if (controllers[i] == intf) {
310 int sfc_mae_switch_domain_get_intf(uint16_t switch_domain_id,
312 efx_pcie_interface_t *intf)
314 const efx_pcie_interface_t *controllers;
315 size_t nb_controllers;
318 rc = sfc_mae_switch_domain_controllers(switch_domain_id, &controllers,
323 if (controllers == NULL)
326 if ((size_t)controller > nb_controllers)
329 *intf = controllers[controller];
334 /* This function expects to be called only when the lock is held */
335 static struct sfc_mae_switch_port *
336 sfc_mae_find_switch_port_by_entity(const struct sfc_mae_switch_domain *domain,
337 const efx_mport_sel_t *entity_mportp,
338 enum sfc_mae_switch_port_type type)
340 struct sfc_mae_switch_port *port;
342 SFC_ASSERT(rte_spinlock_is_locked(&sfc_mae_switch.lock));
344 TAILQ_FOREACH(port, &domain->ports, switch_domain_ports) {
345 if (port->entity_mport.sel == entity_mportp->sel &&
354 sfc_mae_assign_switch_port(uint16_t switch_domain_id,
355 const struct sfc_mae_switch_port_request *req,
356 uint16_t *switch_port_id)
358 struct sfc_mae_switch_domain *domain;
359 struct sfc_mae_switch_port *port;
362 rte_spinlock_lock(&sfc_mae_switch.lock);
364 domain = sfc_mae_find_switch_domain_by_id(switch_domain_id);
365 if (domain == NULL) {
367 goto fail_find_switch_domain_by_id;
370 port = sfc_mae_find_switch_port_by_entity(domain, req->entity_mportp,
375 port = rte_zmalloc("sfc_mae_switch_port", sizeof(*port), 0);
381 port->entity_mport.sel = req->entity_mportp->sel;
382 port->type = req->type;
384 port->id = (domain->nb_ports++);
386 TAILQ_INSERT_TAIL(&domain->ports, port, switch_domain_ports);
389 port->ethdev_mport = *req->ethdev_mportp;
390 port->ethdev_port_id = req->ethdev_port_id;
393 case SFC_MAE_SWITCH_PORT_INDEPENDENT:
396 case SFC_MAE_SWITCH_PORT_REPRESENTOR:
397 memcpy(&port->data.repr, &req->port_data,
398 sizeof(port->data.repr));
404 *switch_port_id = port->id;
406 rte_spinlock_unlock(&sfc_mae_switch.lock);
411 fail_find_switch_domain_by_id:
412 rte_spinlock_unlock(&sfc_mae_switch.lock);
416 /* This function expects to be called only when the lock is held */
418 sfc_mae_find_switch_port_by_ethdev(uint16_t switch_domain_id,
419 uint16_t ethdev_port_id,
420 efx_mport_sel_t *mport_sel)
422 struct sfc_mae_switch_domain *domain;
423 struct sfc_mae_switch_port *port;
425 SFC_ASSERT(rte_spinlock_is_locked(&sfc_mae_switch.lock));
427 if (ethdev_port_id == RTE_MAX_ETHPORTS)
430 domain = sfc_mae_find_switch_domain_by_id(switch_domain_id);
434 TAILQ_FOREACH(port, &domain->ports, switch_domain_ports) {
435 if (port->ethdev_port_id == ethdev_port_id) {
436 *mport_sel = port->ethdev_mport;
445 sfc_mae_switch_port_by_ethdev(uint16_t switch_domain_id,
446 uint16_t ethdev_port_id,
447 efx_mport_sel_t *mport_sel)
451 rte_spinlock_lock(&sfc_mae_switch.lock);
452 rc = sfc_mae_find_switch_port_by_ethdev(switch_domain_id,
453 ethdev_port_id, mport_sel);
454 rte_spinlock_unlock(&sfc_mae_switch.lock);