1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2018 Chelsio Communications.
9 match_entry(struct mps_tcam_entry *entry, const u8 *eth_addr, const u8 *mask)
11 if (!memcmp(eth_addr, entry->eth_addr, RTE_ETHER_ADDR_LEN) &&
12 !memcmp(mask, entry->mask, RTE_ETHER_ADDR_LEN))
17 static int cxgbe_update_free_idx(struct mpstcam_table *t)
19 struct mps_tcam_entry *entry = t->entry;
20 u16 i, next = t->free_idx + 1;
22 if (entry[t->free_idx].state == MPS_ENTRY_UNUSED)
23 /* You are already pointing to a free entry !! */
26 /* loop, till we don't rollback to same index where we started */
27 for (i = next; i != t->free_idx; i++) {
29 /* rollback and search free entry from start */
32 if (entry[i].state == MPS_ENTRY_UNUSED) {
38 return -1; /* table is full */
41 static struct mps_tcam_entry *
42 cxgbe_mpstcam_lookup(struct mpstcam_table *t, const u8 *eth_addr,
45 struct mps_tcam_entry *entry = t->entry;
51 for (i = 0; i < t->size; i++) {
52 if (entry[i].state == MPS_ENTRY_UNUSED)
53 continue; /* entry is not being used */
54 if (match_entry(&entry[i], eth_addr, mask))
61 int cxgbe_mpstcam_alloc(struct port_info *pi, const u8 *eth_addr,
64 struct adapter *adap = pi->adapter;
65 struct mpstcam_table *mpstcam = adap->mpstcam;
66 struct mps_tcam_entry *entry;
70 dev_err(adap, "mpstcam table is not available\n");
74 /* If entry already present, return it. */
75 t4_os_write_lock(&mpstcam->lock);
76 entry = cxgbe_mpstcam_lookup(adap->mpstcam, eth_addr, mask);
78 rte_atomic32_add(&entry->refcnt, 1);
79 t4_os_write_unlock(&mpstcam->lock);
84 t4_os_write_unlock(&mpstcam->lock);
85 dev_err(adap, "mps-tcam table is full\n");
89 ret = t4_alloc_raw_mac_filt(adap, pi->viid, eth_addr, mask,
90 mpstcam->free_idx, 0, pi->port_id, false);
92 t4_os_write_unlock(&mpstcam->lock);
96 /* Fill in the new values */
97 entry = &mpstcam->entry[ret];
98 memcpy(entry->eth_addr, eth_addr, RTE_ETHER_ADDR_LEN);
99 memcpy(entry->mask, mask, RTE_ETHER_ADDR_LEN);
100 rte_atomic32_set(&entry->refcnt, 1);
101 entry->state = MPS_ENTRY_USED;
103 if (cxgbe_update_free_idx(mpstcam))
104 mpstcam->full = true;
106 t4_os_write_unlock(&mpstcam->lock);
110 int cxgbe_mpstcam_modify(struct port_info *pi, int idx, const u8 *addr)
112 struct adapter *adap = pi->adapter;
113 struct mpstcam_table *mpstcam = adap->mpstcam;
114 struct mps_tcam_entry *entry;
118 t4_os_write_lock(&mpstcam->lock);
119 if (idx != -1 && idx >= mpstcam->size) {
120 t4_os_write_unlock(&mpstcam->lock);
124 entry = &mpstcam->entry[idx];
125 /* user wants to modify an existing entry.
126 * verify if entry exists
128 if (entry->state != MPS_ENTRY_USED) {
129 t4_os_write_unlock(&mpstcam->lock);
134 idx = t4_change_mac(adap, adap->mbox, pi->viid, idx, addr, true, true);
136 t4_os_write_unlock(&mpstcam->lock);
140 /* idx can now be different from what user provided */
141 entry = &mpstcam->entry[idx];
142 memcpy(entry->eth_addr, addr, RTE_ETHER_ADDR_LEN);
143 memset(entry->mask, ~0, RTE_ETHER_ADDR_LEN);
144 /* NOTE: we have considered the case that idx returned by t4_change_mac
145 * will be different from the user provided value only if user
146 * provided value is -1
148 if (entry->state == MPS_ENTRY_UNUSED) {
149 rte_atomic32_set(&entry->refcnt, 1);
150 entry->state = MPS_ENTRY_USED;
153 if (cxgbe_update_free_idx(mpstcam))
154 mpstcam->full = true;
156 t4_os_write_unlock(&mpstcam->lock);
161 * hold appropriate locks while calling this.
163 static inline void reset_mpstcam_entry(struct mps_tcam_entry *entry)
165 memset(entry->eth_addr, 0, RTE_ETHER_ADDR_LEN);
166 memset(entry->mask, 0, RTE_ETHER_ADDR_LEN);
167 rte_atomic32_clear(&entry->refcnt);
168 entry->state = MPS_ENTRY_UNUSED;
172 * ret < 0: fatal error
173 * ret = 0: entry removed in h/w
174 * ret > 0: updated refcount.
176 int cxgbe_mpstcam_remove(struct port_info *pi, u16 idx)
178 struct adapter *adap = pi->adapter;
179 struct mpstcam_table *t = adap->mpstcam;
180 struct mps_tcam_entry *entry;
185 t4_os_write_lock(&t->lock);
186 entry = &t->entry[idx];
187 if (entry->state == MPS_ENTRY_UNUSED) {
188 t4_os_write_unlock(&t->lock);
192 if (rte_atomic32_read(&entry->refcnt) == 1)
193 ret = t4_free_raw_mac_filt(adap, pi->viid, entry->eth_addr,
194 entry->mask, idx, 1, pi->port_id,
197 ret = rte_atomic32_sub_return(&entry->refcnt, 1);
200 reset_mpstcam_entry(entry);
201 t->full = false; /* We have atleast 1 free entry */
202 cxgbe_update_free_idx(t);
205 t4_os_write_unlock(&t->lock);
209 struct mpstcam_table *t4_init_mpstcam(struct adapter *adap)
211 struct mpstcam_table *t;
213 u16 size = adap->params.arch.mps_tcam_size;
215 t = t4_os_alloc(sizeof(*t) + size * sizeof(struct mps_tcam_entry));
219 t4_os_rwlock_init(&t->lock);
223 for (i = 0; i < size; i++) {
224 reset_mpstcam_entry(&t->entry[i]);
225 t->entry[i].mpstcam = t;
229 /* first entry is used by chip. this is overwritten only
230 * in t4_cleanup_mpstcam()
232 t->entry[0].state = MPS_ENTRY_USED;
238 void t4_cleanup_mpstcam(struct adapter *adap)
241 t4_os_free(adap->mpstcam);