1 // SPDX-License-Identifier: (GPL-2.0 OR MIT)
2 /*
3  * Copyright (c) 2018 Synopsys, Inc. and/or its affiliates.
4  * stmmac TC Handling (HW only)
5  */
6 
7 #include <net/pkt_cls.h>
8 #include <net/tc_act/tc_gact.h>
9 #include "common.h"
10 #include "dwmac4.h"
11 #include "dwmac5.h"
12 #include "stmmac.h"
13 
14 static void tc_fill_all_pass_entry(struct stmmac_tc_entry *entry)
15 {
16 	memset(entry, 0, sizeof(*entry));
17 	entry->in_use = true;
18 	entry->is_last = true;
19 	entry->is_frag = false;
20 	entry->prio = ~0x0;
21 	entry->handle = 0;
22 	entry->val.match_data = 0x0;
23 	entry->val.match_en = 0x0;
24 	entry->val.af = 1;
25 	entry->val.dma_ch_no = 0x0;
26 }
27 
28 static struct stmmac_tc_entry *tc_find_entry(struct stmmac_priv *priv,
29 					     struct tc_cls_u32_offload *cls,
30 					     bool free)
31 {
32 	struct stmmac_tc_entry *entry, *first = NULL, *dup = NULL;
33 	u32 loc = cls->knode.handle;
34 	int i;
35 
36 	for (i = 0; i < priv->tc_entries_max; i++) {
37 		entry = &priv->tc_entries[i];
38 		if (!entry->in_use && !first && free)
39 			first = entry;
40 		if (entry->handle == loc && !free)
41 			dup = entry;
42 	}
43 
44 	if (dup)
45 		return dup;
46 	if (first) {
47 		first->handle = loc;
48 		first->in_use = true;
49 
50 		/* Reset HW values */
51 		memset(&first->val, 0, sizeof(first->val));
52 	}
53 
54 	return first;
55 }
56 
57 static int tc_fill_actions(struct stmmac_tc_entry *entry,
58 			   struct stmmac_tc_entry *frag,
59 			   struct tc_cls_u32_offload *cls)
60 {
61 	struct stmmac_tc_entry *action_entry = entry;
62 	const struct tc_action *act;
63 	struct tcf_exts *exts;
64 	LIST_HEAD(actions);
65 
66 	exts = cls->knode.exts;
67 	if (!tcf_exts_has_actions(exts))
68 		return -EINVAL;
69 	if (frag)
70 		action_entry = frag;
71 
72 	tcf_exts_to_list(exts, &actions);
73 	list_for_each_entry(act, &actions, list) {
74 		/* Accept */
75 		if (is_tcf_gact_ok(act)) {
76 			action_entry->val.af = 1;
77 			break;
78 		}
79 		/* Drop */
80 		if (is_tcf_gact_shot(act)) {
81 			action_entry->val.rf = 1;
82 			break;
83 		}
84 
85 		/* Unsupported */
86 		return -EINVAL;
87 	}
88 
89 	return 0;
90 }
91 
92 static int tc_fill_entry(struct stmmac_priv *priv,
93 			 struct tc_cls_u32_offload *cls)
94 {
95 	struct stmmac_tc_entry *entry, *frag = NULL;
96 	struct tc_u32_sel *sel = cls->knode.sel;
97 	u32 off, data, mask, real_off, rem;
98 	u32 prio = cls->common.prio;
99 	int ret;
100 
101 	/* Only 1 match per entry */
102 	if (sel->nkeys <= 0 || sel->nkeys > 1)
103 		return -EINVAL;
104 
105 	off = sel->keys[0].off << sel->offshift;
106 	data = sel->keys[0].val;
107 	mask = sel->keys[0].mask;
108 
109 	switch (ntohs(cls->common.protocol)) {
110 	case ETH_P_ALL:
111 		break;
112 	case ETH_P_IP:
113 		off += ETH_HLEN;
114 		break;
115 	default:
116 		return -EINVAL;
117 	}
118 
119 	if (off > priv->tc_off_max)
120 		return -EINVAL;
121 
122 	real_off = off / 4;
123 	rem = off % 4;
124 
125 	entry = tc_find_entry(priv, cls, true);
126 	if (!entry)
127 		return -EINVAL;
128 
129 	if (rem) {
130 		frag = tc_find_entry(priv, cls, true);
131 		if (!frag) {
132 			ret = -EINVAL;
133 			goto err_unuse;
134 		}
135 
136 		entry->frag_ptr = frag;
137 		entry->val.match_en = (mask << (rem * 8)) &
138 			GENMASK(31, rem * 8);
139 		entry->val.match_data = (data << (rem * 8)) &
140 			GENMASK(31, rem * 8);
141 		entry->val.frame_offset = real_off;
142 		entry->prio = prio;
143 
144 		frag->val.match_en = (mask >> (rem * 8)) &
145 			GENMASK(rem * 8 - 1, 0);
146 		frag->val.match_data = (data >> (rem * 8)) &
147 			GENMASK(rem * 8 - 1, 0);
148 		frag->val.frame_offset = real_off + 1;
149 		frag->prio = prio;
150 		frag->is_frag = true;
151 	} else {
152 		entry->frag_ptr = NULL;
153 		entry->val.match_en = mask;
154 		entry->val.match_data = data;
155 		entry->val.frame_offset = real_off;
156 		entry->prio = prio;
157 	}
158 
159 	ret = tc_fill_actions(entry, frag, cls);
160 	if (ret)
161 		goto err_unuse;
162 
163 	return 0;
164 
165 err_unuse:
166 	if (frag)
167 		frag->in_use = false;
168 	entry->in_use = false;
169 	return ret;
170 }
171 
172 static void tc_unfill_entry(struct stmmac_priv *priv,
173 			    struct tc_cls_u32_offload *cls)
174 {
175 	struct stmmac_tc_entry *entry;
176 
177 	entry = tc_find_entry(priv, cls, false);
178 	if (!entry)
179 		return;
180 
181 	entry->in_use = false;
182 	if (entry->frag_ptr) {
183 		entry = entry->frag_ptr;
184 		entry->is_frag = false;
185 		entry->in_use = false;
186 	}
187 }
188 
189 static int tc_config_knode(struct stmmac_priv *priv,
190 			   struct tc_cls_u32_offload *cls)
191 {
192 	int ret;
193 
194 	ret = tc_fill_entry(priv, cls);
195 	if (ret)
196 		return ret;
197 
198 	ret = stmmac_rxp_config(priv, priv->hw->pcsr, priv->tc_entries,
199 			priv->tc_entries_max);
200 	if (ret)
201 		goto err_unfill;
202 
203 	return 0;
204 
205 err_unfill:
206 	tc_unfill_entry(priv, cls);
207 	return ret;
208 }
209 
210 static int tc_delete_knode(struct stmmac_priv *priv,
211 			   struct tc_cls_u32_offload *cls)
212 {
213 	int ret;
214 
215 	/* Set entry and fragments as not used */
216 	tc_unfill_entry(priv, cls);
217 
218 	ret = stmmac_rxp_config(priv, priv->hw->pcsr, priv->tc_entries,
219 			priv->tc_entries_max);
220 	if (ret)
221 		return ret;
222 
223 	return 0;
224 }
225 
226 static int tc_setup_cls_u32(struct stmmac_priv *priv,
227 			    struct tc_cls_u32_offload *cls)
228 {
229 	switch (cls->command) {
230 	case TC_CLSU32_REPLACE_KNODE:
231 		tc_unfill_entry(priv, cls);
232 		/* Fall through */
233 	case TC_CLSU32_NEW_KNODE:
234 		return tc_config_knode(priv, cls);
235 	case TC_CLSU32_DELETE_KNODE:
236 		return tc_delete_knode(priv, cls);
237 	default:
238 		return -EOPNOTSUPP;
239 	}
240 }
241 
242 static int tc_init(struct stmmac_priv *priv)
243 {
244 	struct dma_features *dma_cap = &priv->dma_cap;
245 	unsigned int count;
246 
247 	if (!dma_cap->frpsel)
248 		return -EINVAL;
249 
250 	switch (dma_cap->frpbs) {
251 	case 0x0:
252 		priv->tc_off_max = 64;
253 		break;
254 	case 0x1:
255 		priv->tc_off_max = 128;
256 		break;
257 	case 0x2:
258 		priv->tc_off_max = 256;
259 		break;
260 	default:
261 		return -EINVAL;
262 	}
263 
264 	switch (dma_cap->frpes) {
265 	case 0x0:
266 		count = 64;
267 		break;
268 	case 0x1:
269 		count = 128;
270 		break;
271 	case 0x2:
272 		count = 256;
273 		break;
274 	default:
275 		return -EINVAL;
276 	}
277 
278 	/* Reserve one last filter which lets all pass */
279 	priv->tc_entries_max = count;
280 	priv->tc_entries = devm_kcalloc(priv->device,
281 			count, sizeof(*priv->tc_entries), GFP_KERNEL);
282 	if (!priv->tc_entries)
283 		return -ENOMEM;
284 
285 	tc_fill_all_pass_entry(&priv->tc_entries[count - 1]);
286 
287 	dev_info(priv->device, "Enabling HW TC (entries=%d, max_off=%d)\n",
288 			priv->tc_entries_max, priv->tc_off_max);
289 	return 0;
290 }
291 
292 const struct stmmac_tc_ops dwmac510_tc_ops = {
293 	.init = tc_init,
294 	.setup_cls_u32 = tc_setup_cls_u32,
295 };
296