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 */
68 TAILQ_HEAD(sfc_mae_switch_ports, sfc_mae_switch_port);
71 * Switch domain registry entry.
73 * Even if an RTE ethdev instance gets unplugged, the corresponding
74 * entry in the switch port registry will not be removed because the
75 * entity (PCIe function) MPORT is static and cannot change. If this
76 * RTE ethdev gets plugged back, the entry will be reused, and
77 * RTE switch port ID will be the same.
79 struct sfc_mae_switch_domain {
80 TAILQ_ENTRY(sfc_mae_switch_domain) entries;
83 struct sfc_hw_switch_id *hw_switch_id;
84 /** The number of ports in the switch port registry */
85 unsigned int nb_ports;
86 /** Switch port registry */
87 struct sfc_mae_switch_ports ports;
88 /** RTE switch domain ID allocated for a group of devices */
92 TAILQ_HEAD(sfc_mae_switch_domains, sfc_mae_switch_domain);
95 * MAE representation of RTE switch infrastructure.
97 * It is possible that an RTE flow API client tries to insert a rule
98 * referencing an RTE ethdev deployed on top of a different physical
99 * device (it may belong to the same vendor or not). This particular
100 * driver/engine cannot support this and has to turn down such rules.
102 * Technically, it's HW switch identifier which, if queried for each
103 * RTE ethdev instance, indicates relationship between the instances.
104 * In the meantime, RTE flow API clients also need to somehow figure
105 * out relationship between RTE ethdev instances in advance.
107 * The concept of RTE switch domains resolves this issue. The driver
108 * maintains a static list of switch domains which is easy to browse,
109 * and each RTE ethdev fills RTE switch parameters in device
110 * information structure which is made available to clients.
112 * Even if all RTE ethdev instances belonging to a switch domain get
113 * unplugged, the corresponding entry in the switch domain registry
114 * will not be removed because the corresponding HW switch exists
115 * regardless of its ports being plugged to DPDK or kept aside.
116 * If a port gets plugged back to DPDK, the corresponding
117 * RTE ethdev will indicate the same RTE switch domain ID.
119 struct sfc_mae_switch {
120 /** A lock to protect the whole structure */
122 /** Switch domain registry */
123 struct sfc_mae_switch_domains domains;
126 static struct sfc_mae_switch sfc_mae_switch = {
127 .lock = RTE_SPINLOCK_INITIALIZER,
128 .domains = TAILQ_HEAD_INITIALIZER(sfc_mae_switch.domains),
132 /* This function expects to be called only when the lock is held */
133 static struct sfc_mae_switch_domain *
134 sfc_mae_find_switch_domain_by_id(uint16_t switch_domain_id)
136 struct sfc_mae_switch_domain *domain;
138 SFC_ASSERT(rte_spinlock_is_locked(&sfc_mae_switch.lock));
140 TAILQ_FOREACH(domain, &sfc_mae_switch.domains, entries) {
141 if (domain->id == switch_domain_id)
148 /* This function expects to be called only when the lock is held */
149 static struct sfc_mae_switch_domain *
150 sfc_mae_find_switch_domain_by_hw_switch_id(const struct sfc_hw_switch_id *id)
152 struct sfc_mae_switch_domain *domain;
154 SFC_ASSERT(rte_spinlock_is_locked(&sfc_mae_switch.lock));
156 TAILQ_FOREACH(domain, &sfc_mae_switch.domains, entries) {
157 if (sfc_hw_switch_ids_equal(domain->hw_switch_id, id))
165 sfc_mae_assign_switch_domain(struct sfc_adapter *sa,
166 uint16_t *switch_domain_id)
168 struct sfc_hw_switch_id *hw_switch_id;
169 struct sfc_mae_switch_domain *domain;
172 rte_spinlock_lock(&sfc_mae_switch.lock);
174 rc = sfc_hw_switch_id_init(sa, &hw_switch_id);
176 goto fail_hw_switch_id_init;
178 domain = sfc_mae_find_switch_domain_by_hw_switch_id(hw_switch_id);
179 if (domain != NULL) {
180 sfc_hw_switch_id_fini(sa, hw_switch_id);
184 domain = rte_zmalloc("sfc_mae_switch_domain", sizeof(*domain), 0);
185 if (domain == NULL) {
191 * This code belongs to driver init path, that is, negation is
192 * done at the end of the path by sfc_eth_dev_init(). RTE APIs
193 * negate error codes, so drop negation here.
195 rc = -rte_eth_switch_domain_alloc(&domain->id);
197 goto fail_domain_alloc;
199 domain->hw_switch_id = hw_switch_id;
201 TAILQ_INIT(&domain->ports);
203 TAILQ_INSERT_TAIL(&sfc_mae_switch.domains, domain, entries);
206 *switch_domain_id = domain->id;
208 rte_spinlock_unlock(&sfc_mae_switch.lock);
216 sfc_hw_switch_id_fini(sa, hw_switch_id);
217 rte_spinlock_unlock(&sfc_mae_switch.lock);
219 fail_hw_switch_id_init:
223 /* This function expects to be called only when the lock is held */
224 static struct sfc_mae_switch_port *
225 sfc_mae_find_switch_port_by_entity(const struct sfc_mae_switch_domain *domain,
226 const efx_mport_sel_t *entity_mportp,
227 enum sfc_mae_switch_port_type type)
229 struct sfc_mae_switch_port *port;
231 SFC_ASSERT(rte_spinlock_is_locked(&sfc_mae_switch.lock));
233 TAILQ_FOREACH(port, &domain->ports, switch_domain_ports) {
234 if (port->entity_mport.sel == entity_mportp->sel &&
243 sfc_mae_assign_switch_port(uint16_t switch_domain_id,
244 const struct sfc_mae_switch_port_request *req,
245 uint16_t *switch_port_id)
247 struct sfc_mae_switch_domain *domain;
248 struct sfc_mae_switch_port *port;
251 rte_spinlock_lock(&sfc_mae_switch.lock);
253 domain = sfc_mae_find_switch_domain_by_id(switch_domain_id);
254 if (domain == NULL) {
256 goto fail_find_switch_domain_by_id;
259 port = sfc_mae_find_switch_port_by_entity(domain, req->entity_mportp,
264 port = rte_zmalloc("sfc_mae_switch_port", sizeof(*port), 0);
270 port->entity_mport.sel = req->entity_mportp->sel;
271 port->type = req->type;
273 port->id = (domain->nb_ports++);
275 TAILQ_INSERT_TAIL(&domain->ports, port, switch_domain_ports);
278 port->ethdev_mport = *req->ethdev_mportp;
279 port->ethdev_port_id = req->ethdev_port_id;
281 *switch_port_id = port->id;
283 rte_spinlock_unlock(&sfc_mae_switch.lock);
288 fail_find_switch_domain_by_id:
289 rte_spinlock_unlock(&sfc_mae_switch.lock);
293 /* This function expects to be called only when the lock is held */
295 sfc_mae_find_switch_port_by_ethdev(uint16_t switch_domain_id,
296 uint16_t ethdev_port_id,
297 efx_mport_sel_t *mport_sel)
299 struct sfc_mae_switch_domain *domain;
300 struct sfc_mae_switch_port *port;
302 SFC_ASSERT(rte_spinlock_is_locked(&sfc_mae_switch.lock));
304 if (ethdev_port_id == RTE_MAX_ETHPORTS)
307 domain = sfc_mae_find_switch_domain_by_id(switch_domain_id);
311 TAILQ_FOREACH(port, &domain->ports, switch_domain_ports) {
312 if (port->ethdev_port_id == ethdev_port_id) {
313 *mport_sel = port->ethdev_mport;
322 sfc_mae_switch_port_by_ethdev(uint16_t switch_domain_id,
323 uint16_t ethdev_port_id,
324 efx_mport_sel_t *mport_sel)
328 rte_spinlock_lock(&sfc_mae_switch.lock);
329 rc = sfc_mae_find_switch_port_by_ethdev(switch_domain_id,
330 ethdev_port_id, mport_sel);
331 rte_spinlock_unlock(&sfc_mae_switch.lock);