Loading...
1// SPDX-License-Identifier: BSD-3-Clause
2/* Copyright 2016-2018 NXP
3 * Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
4 */
5#include "sja1105_static_config.h"
6#include <linux/crc32.h>
7#include <linux/slab.h>
8#include <linux/string.h>
9#include <linux/errno.h>
10
11/* Convenience wrappers over the generic packing functions. These take into
12 * account the SJA1105 memory layout quirks and provide some level of
13 * programmer protection against incorrect API use. The errors are not expected
14 * to occur durring runtime, therefore printing and swallowing them here is
15 * appropriate instead of clutterring up higher-level code.
16 */
17void sja1105_pack(void *buf, const u64 *val, int start, int end, size_t len)
18{
19 int rc = packing(buf, (u64 *)val, start, end, len,
20 PACK, QUIRK_LSW32_IS_FIRST);
21
22 if (likely(!rc))
23 return;
24
25 if (rc == -EINVAL) {
26 pr_err("Start bit (%d) expected to be larger than end (%d)\n",
27 start, end);
28 } else if (rc == -ERANGE) {
29 if ((start - end + 1) > 64)
30 pr_err("Field %d-%d too large for 64 bits!\n",
31 start, end);
32 else
33 pr_err("Cannot store %llx inside bits %d-%d (would truncate)\n",
34 *val, start, end);
35 }
36 dump_stack();
37}
38
39void sja1105_unpack(const void *buf, u64 *val, int start, int end, size_t len)
40{
41 int rc = packing((void *)buf, val, start, end, len,
42 UNPACK, QUIRK_LSW32_IS_FIRST);
43
44 if (likely(!rc))
45 return;
46
47 if (rc == -EINVAL)
48 pr_err("Start bit (%d) expected to be larger than end (%d)\n",
49 start, end);
50 else if (rc == -ERANGE)
51 pr_err("Field %d-%d too large for 64 bits!\n",
52 start, end);
53 dump_stack();
54}
55
56void sja1105_packing(void *buf, u64 *val, int start, int end,
57 size_t len, enum packing_op op)
58{
59 int rc = packing(buf, val, start, end, len, op, QUIRK_LSW32_IS_FIRST);
60
61 if (likely(!rc))
62 return;
63
64 if (rc == -EINVAL) {
65 pr_err("Start bit (%d) expected to be larger than end (%d)\n",
66 start, end);
67 } else if (rc == -ERANGE) {
68 if ((start - end + 1) > 64)
69 pr_err("Field %d-%d too large for 64 bits!\n",
70 start, end);
71 else
72 pr_err("Cannot store %llx inside bits %d-%d (would truncate)\n",
73 *val, start, end);
74 }
75 dump_stack();
76}
77
78/* Little-endian Ethernet CRC32 of data packed as big-endian u32 words */
79u32 sja1105_crc32(const void *buf, size_t len)
80{
81 unsigned int i;
82 u64 word;
83 u32 crc;
84
85 /* seed */
86 crc = ~0;
87 for (i = 0; i < len; i += 4) {
88 sja1105_unpack(buf + i, &word, 31, 0, 4);
89 crc = crc32_le(crc, (u8 *)&word, 4);
90 }
91 return ~crc;
92}
93
94static size_t sja1105et_avb_params_entry_packing(void *buf, void *entry_ptr,
95 enum packing_op op)
96{
97 const size_t size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY;
98 struct sja1105_avb_params_entry *entry = entry_ptr;
99
100 sja1105_packing(buf, &entry->destmeta, 95, 48, size, op);
101 sja1105_packing(buf, &entry->srcmeta, 47, 0, size, op);
102 return size;
103}
104
105size_t sja1105pqrs_avb_params_entry_packing(void *buf, void *entry_ptr,
106 enum packing_op op)
107{
108 const size_t size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY;
109 struct sja1105_avb_params_entry *entry = entry_ptr;
110
111 sja1105_packing(buf, &entry->cas_master, 126, 126, size, op);
112 sja1105_packing(buf, &entry->destmeta, 125, 78, size, op);
113 sja1105_packing(buf, &entry->srcmeta, 77, 30, size, op);
114 return size;
115}
116
117static size_t sja1105et_general_params_entry_packing(void *buf, void *entry_ptr,
118 enum packing_op op)
119{
120 const size_t size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY;
121 struct sja1105_general_params_entry *entry = entry_ptr;
122
123 sja1105_packing(buf, &entry->vllupformat, 319, 319, size, op);
124 sja1105_packing(buf, &entry->mirr_ptacu, 318, 318, size, op);
125 sja1105_packing(buf, &entry->switchid, 317, 315, size, op);
126 sja1105_packing(buf, &entry->hostprio, 314, 312, size, op);
127 sja1105_packing(buf, &entry->mac_fltres1, 311, 264, size, op);
128 sja1105_packing(buf, &entry->mac_fltres0, 263, 216, size, op);
129 sja1105_packing(buf, &entry->mac_flt1, 215, 168, size, op);
130 sja1105_packing(buf, &entry->mac_flt0, 167, 120, size, op);
131 sja1105_packing(buf, &entry->incl_srcpt1, 119, 119, size, op);
132 sja1105_packing(buf, &entry->incl_srcpt0, 118, 118, size, op);
133 sja1105_packing(buf, &entry->send_meta1, 117, 117, size, op);
134 sja1105_packing(buf, &entry->send_meta0, 116, 116, size, op);
135 sja1105_packing(buf, &entry->casc_port, 115, 113, size, op);
136 sja1105_packing(buf, &entry->host_port, 112, 110, size, op);
137 sja1105_packing(buf, &entry->mirr_port, 109, 107, size, op);
138 sja1105_packing(buf, &entry->vlmarker, 106, 75, size, op);
139 sja1105_packing(buf, &entry->vlmask, 74, 43, size, op);
140 sja1105_packing(buf, &entry->tpid, 42, 27, size, op);
141 sja1105_packing(buf, &entry->ignore2stf, 26, 26, size, op);
142 sja1105_packing(buf, &entry->tpid2, 25, 10, size, op);
143 return size;
144}
145
146/* TPID and TPID2 are intentionally reversed so that semantic
147 * compatibility with E/T is kept.
148 */
149size_t sja1105pqrs_general_params_entry_packing(void *buf, void *entry_ptr,
150 enum packing_op op)
151{
152 const size_t size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY;
153 struct sja1105_general_params_entry *entry = entry_ptr;
154
155 sja1105_packing(buf, &entry->vllupformat, 351, 351, size, op);
156 sja1105_packing(buf, &entry->mirr_ptacu, 350, 350, size, op);
157 sja1105_packing(buf, &entry->switchid, 349, 347, size, op);
158 sja1105_packing(buf, &entry->hostprio, 346, 344, size, op);
159 sja1105_packing(buf, &entry->mac_fltres1, 343, 296, size, op);
160 sja1105_packing(buf, &entry->mac_fltres0, 295, 248, size, op);
161 sja1105_packing(buf, &entry->mac_flt1, 247, 200, size, op);
162 sja1105_packing(buf, &entry->mac_flt0, 199, 152, size, op);
163 sja1105_packing(buf, &entry->incl_srcpt1, 151, 151, size, op);
164 sja1105_packing(buf, &entry->incl_srcpt0, 150, 150, size, op);
165 sja1105_packing(buf, &entry->send_meta1, 149, 149, size, op);
166 sja1105_packing(buf, &entry->send_meta0, 148, 148, size, op);
167 sja1105_packing(buf, &entry->casc_port, 147, 145, size, op);
168 sja1105_packing(buf, &entry->host_port, 144, 142, size, op);
169 sja1105_packing(buf, &entry->mirr_port, 141, 139, size, op);
170 sja1105_packing(buf, &entry->vlmarker, 138, 107, size, op);
171 sja1105_packing(buf, &entry->vlmask, 106, 75, size, op);
172 sja1105_packing(buf, &entry->tpid2, 74, 59, size, op);
173 sja1105_packing(buf, &entry->ignore2stf, 58, 58, size, op);
174 sja1105_packing(buf, &entry->tpid, 57, 42, size, op);
175 sja1105_packing(buf, &entry->queue_ts, 41, 41, size, op);
176 sja1105_packing(buf, &entry->egrmirrvid, 40, 29, size, op);
177 sja1105_packing(buf, &entry->egrmirrpcp, 28, 26, size, op);
178 sja1105_packing(buf, &entry->egrmirrdei, 25, 25, size, op);
179 sja1105_packing(buf, &entry->replay_port, 24, 22, size, op);
180 return size;
181}
182
183size_t sja1110_general_params_entry_packing(void *buf, void *entry_ptr,
184 enum packing_op op)
185{
186 struct sja1105_general_params_entry *entry = entry_ptr;
187 const size_t size = SJA1110_SIZE_GENERAL_PARAMS_ENTRY;
188
189 sja1105_packing(buf, &entry->vllupformat, 447, 447, size, op);
190 sja1105_packing(buf, &entry->mirr_ptacu, 446, 446, size, op);
191 sja1105_packing(buf, &entry->switchid, 445, 442, size, op);
192 sja1105_packing(buf, &entry->hostprio, 441, 439, size, op);
193 sja1105_packing(buf, &entry->mac_fltres1, 438, 391, size, op);
194 sja1105_packing(buf, &entry->mac_fltres0, 390, 343, size, op);
195 sja1105_packing(buf, &entry->mac_flt1, 342, 295, size, op);
196 sja1105_packing(buf, &entry->mac_flt0, 294, 247, size, op);
197 sja1105_packing(buf, &entry->incl_srcpt1, 246, 246, size, op);
198 sja1105_packing(buf, &entry->incl_srcpt0, 245, 245, size, op);
199 sja1105_packing(buf, &entry->send_meta1, 244, 244, size, op);
200 sja1105_packing(buf, &entry->send_meta0, 243, 243, size, op);
201 sja1105_packing(buf, &entry->casc_port, 242, 232, size, op);
202 sja1105_packing(buf, &entry->host_port, 231, 228, size, op);
203 sja1105_packing(buf, &entry->mirr_port, 227, 224, size, op);
204 sja1105_packing(buf, &entry->vlmarker, 223, 192, size, op);
205 sja1105_packing(buf, &entry->vlmask, 191, 160, size, op);
206 sja1105_packing(buf, &entry->tpid2, 159, 144, size, op);
207 sja1105_packing(buf, &entry->ignore2stf, 143, 143, size, op);
208 sja1105_packing(buf, &entry->tpid, 142, 127, size, op);
209 sja1105_packing(buf, &entry->queue_ts, 126, 126, size, op);
210 sja1105_packing(buf, &entry->egrmirrvid, 125, 114, size, op);
211 sja1105_packing(buf, &entry->egrmirrpcp, 113, 111, size, op);
212 sja1105_packing(buf, &entry->egrmirrdei, 110, 110, size, op);
213 sja1105_packing(buf, &entry->replay_port, 109, 106, size, op);
214 sja1105_packing(buf, &entry->tdmaconfigidx, 70, 67, size, op);
215 sja1105_packing(buf, &entry->header_type, 64, 49, size, op);
216 sja1105_packing(buf, &entry->tte_en, 16, 16, size, op);
217 return size;
218}
219
220static size_t
221sja1105_l2_forwarding_params_entry_packing(void *buf, void *entry_ptr,
222 enum packing_op op)
223{
224 const size_t size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY;
225 struct sja1105_l2_forwarding_params_entry *entry = entry_ptr;
226 int offset, i;
227
228 sja1105_packing(buf, &entry->max_dynp, 95, 93, size, op);
229 for (i = 0, offset = 13; i < 8; i++, offset += 10)
230 sja1105_packing(buf, &entry->part_spc[i],
231 offset + 9, offset + 0, size, op);
232 return size;
233}
234
235size_t sja1110_l2_forwarding_params_entry_packing(void *buf, void *entry_ptr,
236 enum packing_op op)
237{
238 struct sja1105_l2_forwarding_params_entry *entry = entry_ptr;
239 const size_t size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY;
240 int offset, i;
241
242 sja1105_packing(buf, &entry->max_dynp, 95, 93, size, op);
243 for (i = 0, offset = 5; i < 8; i++, offset += 11)
244 sja1105_packing(buf, &entry->part_spc[i],
245 offset + 10, offset + 0, size, op);
246 return size;
247}
248
249size_t sja1105_l2_forwarding_entry_packing(void *buf, void *entry_ptr,
250 enum packing_op op)
251{
252 const size_t size = SJA1105_SIZE_L2_FORWARDING_ENTRY;
253 struct sja1105_l2_forwarding_entry *entry = entry_ptr;
254 int offset, i;
255
256 sja1105_packing(buf, &entry->bc_domain, 63, 59, size, op);
257 sja1105_packing(buf, &entry->reach_port, 58, 54, size, op);
258 sja1105_packing(buf, &entry->fl_domain, 53, 49, size, op);
259 for (i = 0, offset = 25; i < 8; i++, offset += 3)
260 sja1105_packing(buf, &entry->vlan_pmap[i],
261 offset + 2, offset + 0, size, op);
262 return size;
263}
264
265size_t sja1110_l2_forwarding_entry_packing(void *buf, void *entry_ptr,
266 enum packing_op op)
267{
268 struct sja1105_l2_forwarding_entry *entry = entry_ptr;
269 const size_t size = SJA1105_SIZE_L2_FORWARDING_ENTRY;
270 int offset, i;
271
272 if (entry->type_egrpcp2outputq) {
273 for (i = 0, offset = 31; i < SJA1110_NUM_PORTS;
274 i++, offset += 3) {
275 sja1105_packing(buf, &entry->vlan_pmap[i],
276 offset + 2, offset + 0, size, op);
277 }
278 } else {
279 sja1105_packing(buf, &entry->bc_domain, 63, 53, size, op);
280 sja1105_packing(buf, &entry->reach_port, 52, 42, size, op);
281 sja1105_packing(buf, &entry->fl_domain, 41, 31, size, op);
282 }
283 return size;
284}
285
286static size_t
287sja1105et_l2_lookup_params_entry_packing(void *buf, void *entry_ptr,
288 enum packing_op op)
289{
290 const size_t size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY;
291 struct sja1105_l2_lookup_params_entry *entry = entry_ptr;
292
293 sja1105_packing(buf, &entry->maxage, 31, 17, size, op);
294 sja1105_packing(buf, &entry->dyn_tbsz, 16, 14, size, op);
295 sja1105_packing(buf, &entry->poly, 13, 6, size, op);
296 sja1105_packing(buf, &entry->shared_learn, 5, 5, size, op);
297 sja1105_packing(buf, &entry->no_enf_hostprt, 4, 4, size, op);
298 sja1105_packing(buf, &entry->no_mgmt_learn, 3, 3, size, op);
299 return size;
300}
301
302size_t sja1105pqrs_l2_lookup_params_entry_packing(void *buf, void *entry_ptr,
303 enum packing_op op)
304{
305 const size_t size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY;
306 struct sja1105_l2_lookup_params_entry *entry = entry_ptr;
307 int offset, i;
308
309 for (i = 0, offset = 58; i < 5; i++, offset += 11)
310 sja1105_packing(buf, &entry->maxaddrp[i],
311 offset + 10, offset + 0, size, op);
312 sja1105_packing(buf, &entry->maxage, 57, 43, size, op);
313 sja1105_packing(buf, &entry->start_dynspc, 42, 33, size, op);
314 sja1105_packing(buf, &entry->drpnolearn, 32, 28, size, op);
315 sja1105_packing(buf, &entry->shared_learn, 27, 27, size, op);
316 sja1105_packing(buf, &entry->no_enf_hostprt, 26, 26, size, op);
317 sja1105_packing(buf, &entry->no_mgmt_learn, 25, 25, size, op);
318 sja1105_packing(buf, &entry->use_static, 24, 24, size, op);
319 sja1105_packing(buf, &entry->owr_dyn, 23, 23, size, op);
320 sja1105_packing(buf, &entry->learn_once, 22, 22, size, op);
321 return size;
322}
323
324size_t sja1110_l2_lookup_params_entry_packing(void *buf, void *entry_ptr,
325 enum packing_op op)
326{
327 struct sja1105_l2_lookup_params_entry *entry = entry_ptr;
328 const size_t size = SJA1110_SIZE_L2_LOOKUP_PARAMS_ENTRY;
329 int offset, i;
330
331 for (i = 0, offset = 70; i < SJA1110_NUM_PORTS; i++, offset += 11)
332 sja1105_packing(buf, &entry->maxaddrp[i],
333 offset + 10, offset + 0, size, op);
334 sja1105_packing(buf, &entry->maxage, 69, 55, size, op);
335 sja1105_packing(buf, &entry->start_dynspc, 54, 45, size, op);
336 sja1105_packing(buf, &entry->drpnolearn, 44, 34, size, op);
337 sja1105_packing(buf, &entry->shared_learn, 33, 33, size, op);
338 sja1105_packing(buf, &entry->no_enf_hostprt, 32, 32, size, op);
339 sja1105_packing(buf, &entry->no_mgmt_learn, 31, 31, size, op);
340 sja1105_packing(buf, &entry->use_static, 30, 30, size, op);
341 sja1105_packing(buf, &entry->owr_dyn, 29, 29, size, op);
342 sja1105_packing(buf, &entry->learn_once, 28, 28, size, op);
343 return size;
344}
345
346size_t sja1105et_l2_lookup_entry_packing(void *buf, void *entry_ptr,
347 enum packing_op op)
348{
349 const size_t size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY;
350 struct sja1105_l2_lookup_entry *entry = entry_ptr;
351
352 sja1105_packing(buf, &entry->vlanid, 95, 84, size, op);
353 sja1105_packing(buf, &entry->macaddr, 83, 36, size, op);
354 sja1105_packing(buf, &entry->destports, 35, 31, size, op);
355 sja1105_packing(buf, &entry->enfport, 30, 30, size, op);
356 sja1105_packing(buf, &entry->index, 29, 20, size, op);
357 return size;
358}
359
360size_t sja1105pqrs_l2_lookup_entry_packing(void *buf, void *entry_ptr,
361 enum packing_op op)
362{
363 const size_t size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY;
364 struct sja1105_l2_lookup_entry *entry = entry_ptr;
365
366 if (entry->lockeds) {
367 sja1105_packing(buf, &entry->tsreg, 159, 159, size, op);
368 sja1105_packing(buf, &entry->mirrvlan, 158, 147, size, op);
369 sja1105_packing(buf, &entry->takets, 146, 146, size, op);
370 sja1105_packing(buf, &entry->mirr, 145, 145, size, op);
371 sja1105_packing(buf, &entry->retag, 144, 144, size, op);
372 } else {
373 sja1105_packing(buf, &entry->touched, 159, 159, size, op);
374 sja1105_packing(buf, &entry->age, 158, 144, size, op);
375 }
376 sja1105_packing(buf, &entry->mask_iotag, 143, 143, size, op);
377 sja1105_packing(buf, &entry->mask_vlanid, 142, 131, size, op);
378 sja1105_packing(buf, &entry->mask_macaddr, 130, 83, size, op);
379 sja1105_packing(buf, &entry->iotag, 82, 82, size, op);
380 sja1105_packing(buf, &entry->vlanid, 81, 70, size, op);
381 sja1105_packing(buf, &entry->macaddr, 69, 22, size, op);
382 sja1105_packing(buf, &entry->destports, 21, 17, size, op);
383 sja1105_packing(buf, &entry->enfport, 16, 16, size, op);
384 sja1105_packing(buf, &entry->index, 15, 6, size, op);
385 return size;
386}
387
388size_t sja1110_l2_lookup_entry_packing(void *buf, void *entry_ptr,
389 enum packing_op op)
390{
391 const size_t size = SJA1110_SIZE_L2_LOOKUP_ENTRY;
392 struct sja1105_l2_lookup_entry *entry = entry_ptr;
393
394 if (entry->lockeds) {
395 sja1105_packing(buf, &entry->trap, 168, 168, size, op);
396 sja1105_packing(buf, &entry->mirrvlan, 167, 156, size, op);
397 sja1105_packing(buf, &entry->takets, 155, 155, size, op);
398 sja1105_packing(buf, &entry->mirr, 154, 154, size, op);
399 sja1105_packing(buf, &entry->retag, 153, 153, size, op);
400 } else {
401 sja1105_packing(buf, &entry->touched, 168, 168, size, op);
402 sja1105_packing(buf, &entry->age, 167, 153, size, op);
403 }
404 sja1105_packing(buf, &entry->mask_iotag, 152, 152, size, op);
405 sja1105_packing(buf, &entry->mask_vlanid, 151, 140, size, op);
406 sja1105_packing(buf, &entry->mask_macaddr, 139, 92, size, op);
407 sja1105_packing(buf, &entry->mask_srcport, 91, 88, size, op);
408 sja1105_packing(buf, &entry->iotag, 87, 87, size, op);
409 sja1105_packing(buf, &entry->vlanid, 86, 75, size, op);
410 sja1105_packing(buf, &entry->macaddr, 74, 27, size, op);
411 sja1105_packing(buf, &entry->srcport, 26, 23, size, op);
412 sja1105_packing(buf, &entry->destports, 22, 12, size, op);
413 sja1105_packing(buf, &entry->enfport, 11, 11, size, op);
414 sja1105_packing(buf, &entry->index, 10, 1, size, op);
415 return size;
416}
417
418static size_t sja1105_l2_policing_entry_packing(void *buf, void *entry_ptr,
419 enum packing_op op)
420{
421 const size_t size = SJA1105_SIZE_L2_POLICING_ENTRY;
422 struct sja1105_l2_policing_entry *entry = entry_ptr;
423
424 sja1105_packing(buf, &entry->sharindx, 63, 58, size, op);
425 sja1105_packing(buf, &entry->smax, 57, 42, size, op);
426 sja1105_packing(buf, &entry->rate, 41, 26, size, op);
427 sja1105_packing(buf, &entry->maxlen, 25, 15, size, op);
428 sja1105_packing(buf, &entry->partition, 14, 12, size, op);
429 return size;
430}
431
432size_t sja1110_l2_policing_entry_packing(void *buf, void *entry_ptr,
433 enum packing_op op)
434{
435 struct sja1105_l2_policing_entry *entry = entry_ptr;
436 const size_t size = SJA1105_SIZE_L2_POLICING_ENTRY;
437
438 sja1105_packing(buf, &entry->sharindx, 63, 57, size, op);
439 sja1105_packing(buf, &entry->smax, 56, 39, size, op);
440 sja1105_packing(buf, &entry->rate, 38, 21, size, op);
441 sja1105_packing(buf, &entry->maxlen, 20, 10, size, op);
442 sja1105_packing(buf, &entry->partition, 9, 7, size, op);
443 return size;
444}
445
446static size_t sja1105et_mac_config_entry_packing(void *buf, void *entry_ptr,
447 enum packing_op op)
448{
449 const size_t size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY;
450 struct sja1105_mac_config_entry *entry = entry_ptr;
451 int offset, i;
452
453 for (i = 0, offset = 72; i < 8; i++, offset += 19) {
454 sja1105_packing(buf, &entry->enabled[i],
455 offset + 0, offset + 0, size, op);
456 sja1105_packing(buf, &entry->base[i],
457 offset + 9, offset + 1, size, op);
458 sja1105_packing(buf, &entry->top[i],
459 offset + 18, offset + 10, size, op);
460 }
461 sja1105_packing(buf, &entry->ifg, 71, 67, size, op);
462 sja1105_packing(buf, &entry->speed, 66, 65, size, op);
463 sja1105_packing(buf, &entry->tp_delin, 64, 49, size, op);
464 sja1105_packing(buf, &entry->tp_delout, 48, 33, size, op);
465 sja1105_packing(buf, &entry->maxage, 32, 25, size, op);
466 sja1105_packing(buf, &entry->vlanprio, 24, 22, size, op);
467 sja1105_packing(buf, &entry->vlanid, 21, 10, size, op);
468 sja1105_packing(buf, &entry->ing_mirr, 9, 9, size, op);
469 sja1105_packing(buf, &entry->egr_mirr, 8, 8, size, op);
470 sja1105_packing(buf, &entry->drpnona664, 7, 7, size, op);
471 sja1105_packing(buf, &entry->drpdtag, 6, 6, size, op);
472 sja1105_packing(buf, &entry->drpuntag, 5, 5, size, op);
473 sja1105_packing(buf, &entry->retag, 4, 4, size, op);
474 sja1105_packing(buf, &entry->dyn_learn, 3, 3, size, op);
475 sja1105_packing(buf, &entry->egress, 2, 2, size, op);
476 sja1105_packing(buf, &entry->ingress, 1, 1, size, op);
477 return size;
478}
479
480size_t sja1105pqrs_mac_config_entry_packing(void *buf, void *entry_ptr,
481 enum packing_op op)
482{
483 const size_t size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY;
484 struct sja1105_mac_config_entry *entry = entry_ptr;
485 int offset, i;
486
487 for (i = 0, offset = 104; i < 8; i++, offset += 19) {
488 sja1105_packing(buf, &entry->enabled[i],
489 offset + 0, offset + 0, size, op);
490 sja1105_packing(buf, &entry->base[i],
491 offset + 9, offset + 1, size, op);
492 sja1105_packing(buf, &entry->top[i],
493 offset + 18, offset + 10, size, op);
494 }
495 sja1105_packing(buf, &entry->ifg, 103, 99, size, op);
496 sja1105_packing(buf, &entry->speed, 98, 97, size, op);
497 sja1105_packing(buf, &entry->tp_delin, 96, 81, size, op);
498 sja1105_packing(buf, &entry->tp_delout, 80, 65, size, op);
499 sja1105_packing(buf, &entry->maxage, 64, 57, size, op);
500 sja1105_packing(buf, &entry->vlanprio, 56, 54, size, op);
501 sja1105_packing(buf, &entry->vlanid, 53, 42, size, op);
502 sja1105_packing(buf, &entry->ing_mirr, 41, 41, size, op);
503 sja1105_packing(buf, &entry->egr_mirr, 40, 40, size, op);
504 sja1105_packing(buf, &entry->drpnona664, 39, 39, size, op);
505 sja1105_packing(buf, &entry->drpdtag, 38, 38, size, op);
506 sja1105_packing(buf, &entry->drpuntag, 35, 35, size, op);
507 sja1105_packing(buf, &entry->retag, 34, 34, size, op);
508 sja1105_packing(buf, &entry->dyn_learn, 33, 33, size, op);
509 sja1105_packing(buf, &entry->egress, 32, 32, size, op);
510 sja1105_packing(buf, &entry->ingress, 31, 31, size, op);
511 return size;
512}
513
514size_t sja1110_mac_config_entry_packing(void *buf, void *entry_ptr,
515 enum packing_op op)
516{
517 const size_t size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY;
518 struct sja1105_mac_config_entry *entry = entry_ptr;
519 int offset, i;
520
521 for (i = 0, offset = 104; i < 8; i++, offset += 19) {
522 sja1105_packing(buf, &entry->enabled[i],
523 offset + 0, offset + 0, size, op);
524 sja1105_packing(buf, &entry->base[i],
525 offset + 9, offset + 1, size, op);
526 sja1105_packing(buf, &entry->top[i],
527 offset + 18, offset + 10, size, op);
528 }
529 sja1105_packing(buf, &entry->speed, 98, 96, size, op);
530 sja1105_packing(buf, &entry->tp_delin, 95, 80, size, op);
531 sja1105_packing(buf, &entry->tp_delout, 79, 64, size, op);
532 sja1105_packing(buf, &entry->maxage, 63, 56, size, op);
533 sja1105_packing(buf, &entry->vlanprio, 55, 53, size, op);
534 sja1105_packing(buf, &entry->vlanid, 52, 41, size, op);
535 sja1105_packing(buf, &entry->ing_mirr, 40, 40, size, op);
536 sja1105_packing(buf, &entry->egr_mirr, 39, 39, size, op);
537 sja1105_packing(buf, &entry->drpnona664, 38, 38, size, op);
538 sja1105_packing(buf, &entry->drpdtag, 37, 37, size, op);
539 sja1105_packing(buf, &entry->drpuntag, 34, 34, size, op);
540 sja1105_packing(buf, &entry->retag, 33, 33, size, op);
541 sja1105_packing(buf, &entry->dyn_learn, 32, 32, size, op);
542 sja1105_packing(buf, &entry->egress, 31, 31, size, op);
543 sja1105_packing(buf, &entry->ingress, 30, 30, size, op);
544 sja1105_packing(buf, &entry->ifg, 10, 5, size, op);
545 return size;
546}
547
548static size_t
549sja1105_schedule_entry_points_params_entry_packing(void *buf, void *entry_ptr,
550 enum packing_op op)
551{
552 struct sja1105_schedule_entry_points_params_entry *entry = entry_ptr;
553 const size_t size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY;
554
555 sja1105_packing(buf, &entry->clksrc, 31, 30, size, op);
556 sja1105_packing(buf, &entry->actsubsch, 29, 27, size, op);
557 return size;
558}
559
560static size_t
561sja1105_schedule_entry_points_entry_packing(void *buf, void *entry_ptr,
562 enum packing_op op)
563{
564 struct sja1105_schedule_entry_points_entry *entry = entry_ptr;
565 const size_t size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY;
566
567 sja1105_packing(buf, &entry->subschindx, 31, 29, size, op);
568 sja1105_packing(buf, &entry->delta, 28, 11, size, op);
569 sja1105_packing(buf, &entry->address, 10, 1, size, op);
570 return size;
571}
572
573static size_t
574sja1110_schedule_entry_points_entry_packing(void *buf, void *entry_ptr,
575 enum packing_op op)
576{
577 struct sja1105_schedule_entry_points_entry *entry = entry_ptr;
578 const size_t size = SJA1110_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY;
579
580 sja1105_packing(buf, &entry->subschindx, 63, 61, size, op);
581 sja1105_packing(buf, &entry->delta, 60, 43, size, op);
582 sja1105_packing(buf, &entry->address, 42, 31, size, op);
583 return size;
584}
585
586static size_t sja1105_schedule_params_entry_packing(void *buf, void *entry_ptr,
587 enum packing_op op)
588{
589 const size_t size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY;
590 struct sja1105_schedule_params_entry *entry = entry_ptr;
591 int offset, i;
592
593 for (i = 0, offset = 16; i < 8; i++, offset += 10)
594 sja1105_packing(buf, &entry->subscheind[i],
595 offset + 9, offset + 0, size, op);
596 return size;
597}
598
599static size_t sja1110_schedule_params_entry_packing(void *buf, void *entry_ptr,
600 enum packing_op op)
601{
602 struct sja1105_schedule_params_entry *entry = entry_ptr;
603 const size_t size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY;
604 int offset, i;
605
606 for (i = 0, offset = 0; i < 8; i++, offset += 12)
607 sja1105_packing(buf, &entry->subscheind[i],
608 offset + 11, offset + 0, size, op);
609 return size;
610}
611
612static size_t sja1105_schedule_entry_packing(void *buf, void *entry_ptr,
613 enum packing_op op)
614{
615 const size_t size = SJA1105_SIZE_SCHEDULE_ENTRY;
616 struct sja1105_schedule_entry *entry = entry_ptr;
617
618 sja1105_packing(buf, &entry->winstindex, 63, 54, size, op);
619 sja1105_packing(buf, &entry->winend, 53, 53, size, op);
620 sja1105_packing(buf, &entry->winst, 52, 52, size, op);
621 sja1105_packing(buf, &entry->destports, 51, 47, size, op);
622 sja1105_packing(buf, &entry->setvalid, 46, 46, size, op);
623 sja1105_packing(buf, &entry->txen, 45, 45, size, op);
624 sja1105_packing(buf, &entry->resmedia_en, 44, 44, size, op);
625 sja1105_packing(buf, &entry->resmedia, 43, 36, size, op);
626 sja1105_packing(buf, &entry->vlindex, 35, 26, size, op);
627 sja1105_packing(buf, &entry->delta, 25, 8, size, op);
628 return size;
629}
630
631static size_t sja1110_schedule_entry_packing(void *buf, void *entry_ptr,
632 enum packing_op op)
633{
634 const size_t size = SJA1110_SIZE_SCHEDULE_ENTRY;
635 struct sja1105_schedule_entry *entry = entry_ptr;
636
637 sja1105_packing(buf, &entry->winstindex, 95, 84, size, op);
638 sja1105_packing(buf, &entry->winend, 83, 83, size, op);
639 sja1105_packing(buf, &entry->winst, 82, 82, size, op);
640 sja1105_packing(buf, &entry->destports, 81, 71, size, op);
641 sja1105_packing(buf, &entry->setvalid, 70, 70, size, op);
642 sja1105_packing(buf, &entry->txen, 69, 69, size, op);
643 sja1105_packing(buf, &entry->resmedia_en, 68, 68, size, op);
644 sja1105_packing(buf, &entry->resmedia, 67, 60, size, op);
645 sja1105_packing(buf, &entry->vlindex, 59, 48, size, op);
646 sja1105_packing(buf, &entry->delta, 47, 30, size, op);
647 return size;
648}
649
650static size_t
651sja1105_vl_forwarding_params_entry_packing(void *buf, void *entry_ptr,
652 enum packing_op op)
653{
654 struct sja1105_vl_forwarding_params_entry *entry = entry_ptr;
655 const size_t size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY;
656 int offset, i;
657
658 for (i = 0, offset = 16; i < 8; i++, offset += 10)
659 sja1105_packing(buf, &entry->partspc[i],
660 offset + 9, offset + 0, size, op);
661 sja1105_packing(buf, &entry->debugen, 15, 15, size, op);
662 return size;
663}
664
665static size_t
666sja1110_vl_forwarding_params_entry_packing(void *buf, void *entry_ptr,
667 enum packing_op op)
668{
669 struct sja1105_vl_forwarding_params_entry *entry = entry_ptr;
670 const size_t size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY;
671 int offset, i;
672
673 for (i = 0, offset = 8; i < 8; i++, offset += 11)
674 sja1105_packing(buf, &entry->partspc[i],
675 offset + 10, offset + 0, size, op);
676 sja1105_packing(buf, &entry->debugen, 7, 7, size, op);
677 return size;
678}
679
680static size_t sja1105_vl_forwarding_entry_packing(void *buf, void *entry_ptr,
681 enum packing_op op)
682{
683 struct sja1105_vl_forwarding_entry *entry = entry_ptr;
684 const size_t size = SJA1105_SIZE_VL_FORWARDING_ENTRY;
685
686 sja1105_packing(buf, &entry->type, 31, 31, size, op);
687 sja1105_packing(buf, &entry->priority, 30, 28, size, op);
688 sja1105_packing(buf, &entry->partition, 27, 25, size, op);
689 sja1105_packing(buf, &entry->destports, 24, 20, size, op);
690 return size;
691}
692
693static size_t sja1110_vl_forwarding_entry_packing(void *buf, void *entry_ptr,
694 enum packing_op op)
695{
696 struct sja1105_vl_forwarding_entry *entry = entry_ptr;
697 const size_t size = SJA1105_SIZE_VL_FORWARDING_ENTRY;
698
699 sja1105_packing(buf, &entry->type, 31, 31, size, op);
700 sja1105_packing(buf, &entry->priority, 30, 28, size, op);
701 sja1105_packing(buf, &entry->partition, 27, 25, size, op);
702 sja1105_packing(buf, &entry->destports, 24, 14, size, op);
703 return size;
704}
705
706size_t sja1105_vl_lookup_entry_packing(void *buf, void *entry_ptr,
707 enum packing_op op)
708{
709 struct sja1105_vl_lookup_entry *entry = entry_ptr;
710 const size_t size = SJA1105_SIZE_VL_LOOKUP_ENTRY;
711
712 if (entry->format == SJA1105_VL_FORMAT_PSFP) {
713 /* Interpreting vllupformat as 0 */
714 sja1105_packing(buf, &entry->destports,
715 95, 91, size, op);
716 sja1105_packing(buf, &entry->iscritical,
717 90, 90, size, op);
718 sja1105_packing(buf, &entry->macaddr,
719 89, 42, size, op);
720 sja1105_packing(buf, &entry->vlanid,
721 41, 30, size, op);
722 sja1105_packing(buf, &entry->port,
723 29, 27, size, op);
724 sja1105_packing(buf, &entry->vlanprior,
725 26, 24, size, op);
726 } else {
727 /* Interpreting vllupformat as 1 */
728 sja1105_packing(buf, &entry->egrmirr,
729 95, 91, size, op);
730 sja1105_packing(buf, &entry->ingrmirr,
731 90, 90, size, op);
732 sja1105_packing(buf, &entry->vlid,
733 57, 42, size, op);
734 sja1105_packing(buf, &entry->port,
735 29, 27, size, op);
736 }
737 return size;
738}
739
740size_t sja1110_vl_lookup_entry_packing(void *buf, void *entry_ptr,
741 enum packing_op op)
742{
743 struct sja1105_vl_lookup_entry *entry = entry_ptr;
744 const size_t size = SJA1105_SIZE_VL_LOOKUP_ENTRY;
745
746 if (entry->format == SJA1105_VL_FORMAT_PSFP) {
747 /* Interpreting vllupformat as 0 */
748 sja1105_packing(buf, &entry->destports,
749 94, 84, size, op);
750 sja1105_packing(buf, &entry->iscritical,
751 83, 83, size, op);
752 sja1105_packing(buf, &entry->macaddr,
753 82, 35, size, op);
754 sja1105_packing(buf, &entry->vlanid,
755 34, 23, size, op);
756 sja1105_packing(buf, &entry->port,
757 22, 19, size, op);
758 sja1105_packing(buf, &entry->vlanprior,
759 18, 16, size, op);
760 } else {
761 /* Interpreting vllupformat as 1 */
762 sja1105_packing(buf, &entry->egrmirr,
763 94, 84, size, op);
764 sja1105_packing(buf, &entry->ingrmirr,
765 83, 83, size, op);
766 sja1105_packing(buf, &entry->vlid,
767 50, 35, size, op);
768 sja1105_packing(buf, &entry->port,
769 22, 19, size, op);
770 }
771 return size;
772}
773
774static size_t sja1105_vl_policing_entry_packing(void *buf, void *entry_ptr,
775 enum packing_op op)
776{
777 struct sja1105_vl_policing_entry *entry = entry_ptr;
778 const size_t size = SJA1105_SIZE_VL_POLICING_ENTRY;
779
780 sja1105_packing(buf, &entry->type, 63, 63, size, op);
781 sja1105_packing(buf, &entry->maxlen, 62, 52, size, op);
782 sja1105_packing(buf, &entry->sharindx, 51, 42, size, op);
783 if (entry->type == 0) {
784 sja1105_packing(buf, &entry->bag, 41, 28, size, op);
785 sja1105_packing(buf, &entry->jitter, 27, 18, size, op);
786 }
787 return size;
788}
789
790size_t sja1110_vl_policing_entry_packing(void *buf, void *entry_ptr,
791 enum packing_op op)
792{
793 struct sja1105_vl_policing_entry *entry = entry_ptr;
794 const size_t size = SJA1105_SIZE_VL_POLICING_ENTRY;
795
796 sja1105_packing(buf, &entry->type, 63, 63, size, op);
797 sja1105_packing(buf, &entry->maxlen, 62, 52, size, op);
798 sja1105_packing(buf, &entry->sharindx, 51, 40, size, op);
799 if (entry->type == 0) {
800 sja1105_packing(buf, &entry->bag, 41, 28, size, op);
801 sja1105_packing(buf, &entry->jitter, 27, 18, size, op);
802 }
803 return size;
804}
805
806size_t sja1105_vlan_lookup_entry_packing(void *buf, void *entry_ptr,
807 enum packing_op op)
808{
809 const size_t size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY;
810 struct sja1105_vlan_lookup_entry *entry = entry_ptr;
811
812 sja1105_packing(buf, &entry->ving_mirr, 63, 59, size, op);
813 sja1105_packing(buf, &entry->vegr_mirr, 58, 54, size, op);
814 sja1105_packing(buf, &entry->vmemb_port, 53, 49, size, op);
815 sja1105_packing(buf, &entry->vlan_bc, 48, 44, size, op);
816 sja1105_packing(buf, &entry->tag_port, 43, 39, size, op);
817 sja1105_packing(buf, &entry->vlanid, 38, 27, size, op);
818 return size;
819}
820
821size_t sja1110_vlan_lookup_entry_packing(void *buf, void *entry_ptr,
822 enum packing_op op)
823{
824 struct sja1105_vlan_lookup_entry *entry = entry_ptr;
825 const size_t size = SJA1110_SIZE_VLAN_LOOKUP_ENTRY;
826
827 sja1105_packing(buf, &entry->ving_mirr, 95, 85, size, op);
828 sja1105_packing(buf, &entry->vegr_mirr, 84, 74, size, op);
829 sja1105_packing(buf, &entry->vmemb_port, 73, 63, size, op);
830 sja1105_packing(buf, &entry->vlan_bc, 62, 52, size, op);
831 sja1105_packing(buf, &entry->tag_port, 51, 41, size, op);
832 sja1105_packing(buf, &entry->type_entry, 40, 39, size, op);
833 sja1105_packing(buf, &entry->vlanid, 38, 27, size, op);
834 return size;
835}
836
837static size_t sja1105_xmii_params_entry_packing(void *buf, void *entry_ptr,
838 enum packing_op op)
839{
840 const size_t size = SJA1105_SIZE_XMII_PARAMS_ENTRY;
841 struct sja1105_xmii_params_entry *entry = entry_ptr;
842 int offset, i;
843
844 for (i = 0, offset = 17; i < 5; i++, offset += 3) {
845 sja1105_packing(buf, &entry->xmii_mode[i],
846 offset + 1, offset + 0, size, op);
847 sja1105_packing(buf, &entry->phy_mac[i],
848 offset + 2, offset + 2, size, op);
849 }
850 return size;
851}
852
853size_t sja1110_xmii_params_entry_packing(void *buf, void *entry_ptr,
854 enum packing_op op)
855{
856 const size_t size = SJA1110_SIZE_XMII_PARAMS_ENTRY;
857 struct sja1105_xmii_params_entry *entry = entry_ptr;
858 int offset, i;
859
860 for (i = 0, offset = 20; i < SJA1110_NUM_PORTS; i++, offset += 4) {
861 sja1105_packing(buf, &entry->xmii_mode[i],
862 offset + 1, offset + 0, size, op);
863 sja1105_packing(buf, &entry->phy_mac[i],
864 offset + 2, offset + 2, size, op);
865 sja1105_packing(buf, &entry->special[i],
866 offset + 3, offset + 3, size, op);
867 }
868 return size;
869}
870
871size_t sja1105_retagging_entry_packing(void *buf, void *entry_ptr,
872 enum packing_op op)
873{
874 struct sja1105_retagging_entry *entry = entry_ptr;
875 const size_t size = SJA1105_SIZE_RETAGGING_ENTRY;
876
877 sja1105_packing(buf, &entry->egr_port, 63, 59, size, op);
878 sja1105_packing(buf, &entry->ing_port, 58, 54, size, op);
879 sja1105_packing(buf, &entry->vlan_ing, 53, 42, size, op);
880 sja1105_packing(buf, &entry->vlan_egr, 41, 30, size, op);
881 sja1105_packing(buf, &entry->do_not_learn, 29, 29, size, op);
882 sja1105_packing(buf, &entry->use_dest_ports, 28, 28, size, op);
883 sja1105_packing(buf, &entry->destports, 27, 23, size, op);
884 return size;
885}
886
887size_t sja1110_retagging_entry_packing(void *buf, void *entry_ptr,
888 enum packing_op op)
889{
890 struct sja1105_retagging_entry *entry = entry_ptr;
891 const size_t size = SJA1105_SIZE_RETAGGING_ENTRY;
892
893 sja1105_packing(buf, &entry->egr_port, 63, 53, size, op);
894 sja1105_packing(buf, &entry->ing_port, 52, 42, size, op);
895 sja1105_packing(buf, &entry->vlan_ing, 41, 30, size, op);
896 sja1105_packing(buf, &entry->vlan_egr, 29, 18, size, op);
897 sja1105_packing(buf, &entry->do_not_learn, 17, 17, size, op);
898 sja1105_packing(buf, &entry->use_dest_ports, 16, 16, size, op);
899 sja1105_packing(buf, &entry->destports, 15, 5, size, op);
900 return size;
901}
902
903static size_t sja1110_pcp_remapping_entry_packing(void *buf, void *entry_ptr,
904 enum packing_op op)
905{
906 struct sja1110_pcp_remapping_entry *entry = entry_ptr;
907 const size_t size = SJA1110_SIZE_PCP_REMAPPING_ENTRY;
908 int offset, i;
909
910 for (i = 0, offset = 8; i < SJA1105_NUM_TC; i++, offset += 3)
911 sja1105_packing(buf, &entry->egrpcp[i],
912 offset + 2, offset + 0, size, op);
913
914 return size;
915}
916
917size_t sja1105_table_header_packing(void *buf, void *entry_ptr,
918 enum packing_op op)
919{
920 const size_t size = SJA1105_SIZE_TABLE_HEADER;
921 struct sja1105_table_header *entry = entry_ptr;
922
923 sja1105_packing(buf, &entry->block_id, 31, 24, size, op);
924 sja1105_packing(buf, &entry->len, 55, 32, size, op);
925 sja1105_packing(buf, &entry->crc, 95, 64, size, op);
926 return size;
927}
928
929/* WARNING: the *hdr pointer is really non-const, because it is
930 * modifying the CRC of the header for a 2-stage packing operation
931 */
932void
933sja1105_table_header_pack_with_crc(void *buf, struct sja1105_table_header *hdr)
934{
935 /* First pack the table as-is, then calculate the CRC, and
936 * finally put the proper CRC into the packed buffer
937 */
938 memset(buf, 0, SJA1105_SIZE_TABLE_HEADER);
939 sja1105_table_header_packing(buf, hdr, PACK);
940 hdr->crc = sja1105_crc32(buf, SJA1105_SIZE_TABLE_HEADER - 4);
941 sja1105_pack(buf + SJA1105_SIZE_TABLE_HEADER - 4, &hdr->crc, 31, 0, 4);
942}
943
944static void sja1105_table_write_crc(u8 *table_start, u8 *crc_ptr)
945{
946 u64 computed_crc;
947 int len_bytes;
948
949 len_bytes = (uintptr_t)(crc_ptr - table_start);
950 computed_crc = sja1105_crc32(table_start, len_bytes);
951 sja1105_pack(crc_ptr, &computed_crc, 31, 0, 4);
952}
953
954/* The block IDs that the switches support are unfortunately sparse, so keep a
955 * mapping table to "block indices" and translate back and forth so that we
956 * don't waste useless memory in struct sja1105_static_config.
957 * Also, since the block id comes from essentially untrusted input (unpacking
958 * the static config from userspace) it has to be sanitized (range-checked)
959 * before blindly indexing kernel memory with the blk_idx.
960 */
961static u64 blk_id_map[BLK_IDX_MAX] = {
962 [BLK_IDX_SCHEDULE] = BLKID_SCHEDULE,
963 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = BLKID_SCHEDULE_ENTRY_POINTS,
964 [BLK_IDX_VL_LOOKUP] = BLKID_VL_LOOKUP,
965 [BLK_IDX_VL_POLICING] = BLKID_VL_POLICING,
966 [BLK_IDX_VL_FORWARDING] = BLKID_VL_FORWARDING,
967 [BLK_IDX_L2_LOOKUP] = BLKID_L2_LOOKUP,
968 [BLK_IDX_L2_POLICING] = BLKID_L2_POLICING,
969 [BLK_IDX_VLAN_LOOKUP] = BLKID_VLAN_LOOKUP,
970 [BLK_IDX_L2_FORWARDING] = BLKID_L2_FORWARDING,
971 [BLK_IDX_MAC_CONFIG] = BLKID_MAC_CONFIG,
972 [BLK_IDX_SCHEDULE_PARAMS] = BLKID_SCHEDULE_PARAMS,
973 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = BLKID_SCHEDULE_ENTRY_POINTS_PARAMS,
974 [BLK_IDX_VL_FORWARDING_PARAMS] = BLKID_VL_FORWARDING_PARAMS,
975 [BLK_IDX_L2_LOOKUP_PARAMS] = BLKID_L2_LOOKUP_PARAMS,
976 [BLK_IDX_L2_FORWARDING_PARAMS] = BLKID_L2_FORWARDING_PARAMS,
977 [BLK_IDX_AVB_PARAMS] = BLKID_AVB_PARAMS,
978 [BLK_IDX_GENERAL_PARAMS] = BLKID_GENERAL_PARAMS,
979 [BLK_IDX_RETAGGING] = BLKID_RETAGGING,
980 [BLK_IDX_XMII_PARAMS] = BLKID_XMII_PARAMS,
981 [BLK_IDX_PCP_REMAPPING] = BLKID_PCP_REMAPPING,
982};
983
984const char *sja1105_static_config_error_msg[] = {
985 [SJA1105_CONFIG_OK] = "",
986 [SJA1105_TTETHERNET_NOT_SUPPORTED] =
987 "schedule-table present, but TTEthernet is "
988 "only supported on T and Q/S",
989 [SJA1105_INCORRECT_TTETHERNET_CONFIGURATION] =
990 "schedule-table present, but one of "
991 "schedule-entry-points-table, schedule-parameters-table or "
992 "schedule-entry-points-parameters table is empty",
993 [SJA1105_INCORRECT_VIRTUAL_LINK_CONFIGURATION] =
994 "vl-lookup-table present, but one of vl-policing-table, "
995 "vl-forwarding-table or vl-forwarding-parameters-table is empty",
996 [SJA1105_MISSING_L2_POLICING_TABLE] =
997 "l2-policing-table needs to have at least one entry",
998 [SJA1105_MISSING_L2_FORWARDING_TABLE] =
999 "l2-forwarding-table is either missing or incomplete",
1000 [SJA1105_MISSING_L2_FORWARDING_PARAMS_TABLE] =
1001 "l2-forwarding-parameters-table is missing",
1002 [SJA1105_MISSING_GENERAL_PARAMS_TABLE] =
1003 "general-parameters-table is missing",
1004 [SJA1105_MISSING_VLAN_TABLE] =
1005 "vlan-lookup-table needs to have at least the default untagged VLAN",
1006 [SJA1105_MISSING_XMII_TABLE] =
1007 "xmii-table is missing",
1008 [SJA1105_MISSING_MAC_TABLE] =
1009 "mac-configuration-table needs to contain an entry for each port",
1010 [SJA1105_OVERCOMMITTED_FRAME_MEMORY] =
1011 "Not allowed to overcommit frame memory. L2 memory partitions "
1012 "and VL memory partitions share the same space. The sum of all "
1013 "16 memory partitions is not allowed to be larger than 929 "
1014 "128-byte blocks (or 910 with retagging). Please adjust "
1015 "l2-forwarding-parameters-table.part_spc and/or "
1016 "vl-forwarding-parameters-table.partspc.",
1017};
1018
1019static sja1105_config_valid_t
1020static_config_check_memory_size(const struct sja1105_table *tables, int max_mem)
1021{
1022 const struct sja1105_l2_forwarding_params_entry *l2_fwd_params;
1023 const struct sja1105_vl_forwarding_params_entry *vl_fwd_params;
1024 int i, mem = 0;
1025
1026 l2_fwd_params = tables[BLK_IDX_L2_FORWARDING_PARAMS].entries;
1027
1028 for (i = 0; i < 8; i++)
1029 mem += l2_fwd_params->part_spc[i];
1030
1031 if (tables[BLK_IDX_VL_FORWARDING_PARAMS].entry_count) {
1032 vl_fwd_params = tables[BLK_IDX_VL_FORWARDING_PARAMS].entries;
1033 for (i = 0; i < 8; i++)
1034 mem += vl_fwd_params->partspc[i];
1035 }
1036
1037 if (tables[BLK_IDX_RETAGGING].entry_count)
1038 max_mem -= SJA1105_FRAME_MEMORY_RETAGGING_OVERHEAD;
1039
1040 if (mem > max_mem)
1041 return SJA1105_OVERCOMMITTED_FRAME_MEMORY;
1042
1043 return SJA1105_CONFIG_OK;
1044}
1045
1046sja1105_config_valid_t
1047sja1105_static_config_check_valid(const struct sja1105_static_config *config,
1048 int max_mem)
1049{
1050 const struct sja1105_table *tables = config->tables;
1051#define IS_FULL(blk_idx) \
1052 (tables[blk_idx].entry_count == tables[blk_idx].ops->max_entry_count)
1053
1054 if (tables[BLK_IDX_SCHEDULE].entry_count) {
1055 if (!tables[BLK_IDX_SCHEDULE].ops->max_entry_count)
1056 return SJA1105_TTETHERNET_NOT_SUPPORTED;
1057
1058 if (tables[BLK_IDX_SCHEDULE_ENTRY_POINTS].entry_count == 0)
1059 return SJA1105_INCORRECT_TTETHERNET_CONFIGURATION;
1060
1061 if (!IS_FULL(BLK_IDX_SCHEDULE_PARAMS))
1062 return SJA1105_INCORRECT_TTETHERNET_CONFIGURATION;
1063
1064 if (!IS_FULL(BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS))
1065 return SJA1105_INCORRECT_TTETHERNET_CONFIGURATION;
1066 }
1067 if (tables[BLK_IDX_VL_LOOKUP].entry_count) {
1068 struct sja1105_vl_lookup_entry *vl_lookup;
1069 bool has_critical_links = false;
1070 int i;
1071
1072 vl_lookup = tables[BLK_IDX_VL_LOOKUP].entries;
1073
1074 for (i = 0; i < tables[BLK_IDX_VL_LOOKUP].entry_count; i++) {
1075 if (vl_lookup[i].iscritical) {
1076 has_critical_links = true;
1077 break;
1078 }
1079 }
1080
1081 if (tables[BLK_IDX_VL_POLICING].entry_count == 0 &&
1082 has_critical_links)
1083 return SJA1105_INCORRECT_VIRTUAL_LINK_CONFIGURATION;
1084
1085 if (tables[BLK_IDX_VL_FORWARDING].entry_count == 0 &&
1086 has_critical_links)
1087 return SJA1105_INCORRECT_VIRTUAL_LINK_CONFIGURATION;
1088
1089 if (tables[BLK_IDX_VL_FORWARDING_PARAMS].entry_count == 0 &&
1090 has_critical_links)
1091 return SJA1105_INCORRECT_VIRTUAL_LINK_CONFIGURATION;
1092 }
1093
1094 if (tables[BLK_IDX_L2_POLICING].entry_count == 0)
1095 return SJA1105_MISSING_L2_POLICING_TABLE;
1096
1097 if (tables[BLK_IDX_VLAN_LOOKUP].entry_count == 0)
1098 return SJA1105_MISSING_VLAN_TABLE;
1099
1100 if (!IS_FULL(BLK_IDX_L2_FORWARDING))
1101 return SJA1105_MISSING_L2_FORWARDING_TABLE;
1102
1103 if (!IS_FULL(BLK_IDX_MAC_CONFIG))
1104 return SJA1105_MISSING_MAC_TABLE;
1105
1106 if (!IS_FULL(BLK_IDX_L2_FORWARDING_PARAMS))
1107 return SJA1105_MISSING_L2_FORWARDING_PARAMS_TABLE;
1108
1109 if (!IS_FULL(BLK_IDX_GENERAL_PARAMS))
1110 return SJA1105_MISSING_GENERAL_PARAMS_TABLE;
1111
1112 if (!IS_FULL(BLK_IDX_XMII_PARAMS))
1113 return SJA1105_MISSING_XMII_TABLE;
1114
1115 return static_config_check_memory_size(tables, max_mem);
1116#undef IS_FULL
1117}
1118
1119void
1120sja1105_static_config_pack(void *buf, struct sja1105_static_config *config)
1121{
1122 struct sja1105_table_header header = {0};
1123 enum sja1105_blk_idx i;
1124 char *p = buf;
1125 int j;
1126
1127 sja1105_pack(p, &config->device_id, 31, 0, 4);
1128 p += SJA1105_SIZE_DEVICE_ID;
1129
1130 for (i = 0; i < BLK_IDX_MAX; i++) {
1131 const struct sja1105_table *table;
1132 char *table_start;
1133
1134 table = &config->tables[i];
1135 if (!table->entry_count)
1136 continue;
1137
1138 header.block_id = blk_id_map[i];
1139 header.len = table->entry_count *
1140 table->ops->packed_entry_size / 4;
1141 sja1105_table_header_pack_with_crc(p, &header);
1142 p += SJA1105_SIZE_TABLE_HEADER;
1143 table_start = p;
1144 for (j = 0; j < table->entry_count; j++) {
1145 u8 *entry_ptr = table->entries;
1146
1147 entry_ptr += j * table->ops->unpacked_entry_size;
1148 memset(p, 0, table->ops->packed_entry_size);
1149 table->ops->packing(p, entry_ptr, PACK);
1150 p += table->ops->packed_entry_size;
1151 }
1152 sja1105_table_write_crc(table_start, p);
1153 p += 4;
1154 }
1155 /* Final header:
1156 * Block ID does not matter
1157 * Length of 0 marks that header is final
1158 * CRC will be replaced on-the-fly on "config upload"
1159 */
1160 header.block_id = 0;
1161 header.len = 0;
1162 header.crc = 0xDEADBEEF;
1163 memset(p, 0, SJA1105_SIZE_TABLE_HEADER);
1164 sja1105_table_header_packing(p, &header, PACK);
1165}
1166
1167size_t
1168sja1105_static_config_get_length(const struct sja1105_static_config *config)
1169{
1170 unsigned int sum;
1171 unsigned int header_count;
1172 enum sja1105_blk_idx i;
1173
1174 /* Ending header */
1175 header_count = 1;
1176 sum = SJA1105_SIZE_DEVICE_ID;
1177
1178 /* Tables (headers and entries) */
1179 for (i = 0; i < BLK_IDX_MAX; i++) {
1180 const struct sja1105_table *table;
1181
1182 table = &config->tables[i];
1183 if (table->entry_count)
1184 header_count++;
1185
1186 sum += table->ops->packed_entry_size * table->entry_count;
1187 }
1188 /* Headers have an additional CRC at the end */
1189 sum += header_count * (SJA1105_SIZE_TABLE_HEADER + 4);
1190 /* Last header does not have an extra CRC because there is no data */
1191 sum -= 4;
1192
1193 return sum;
1194}
1195
1196/* Compatibility matrices */
1197
1198/* SJA1105E: First generation, no TTEthernet */
1199const struct sja1105_table_ops sja1105e_table_ops[BLK_IDX_MAX] = {
1200 [BLK_IDX_L2_LOOKUP] = {
1201 .packing = sja1105et_l2_lookup_entry_packing,
1202 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1203 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY,
1204 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1205 },
1206 [BLK_IDX_L2_POLICING] = {
1207 .packing = sja1105_l2_policing_entry_packing,
1208 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1209 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1210 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1211 },
1212 [BLK_IDX_VLAN_LOOKUP] = {
1213 .packing = sja1105_vlan_lookup_entry_packing,
1214 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1215 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1216 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1217 },
1218 [BLK_IDX_L2_FORWARDING] = {
1219 .packing = sja1105_l2_forwarding_entry_packing,
1220 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1221 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1222 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1223 },
1224 [BLK_IDX_MAC_CONFIG] = {
1225 .packing = sja1105et_mac_config_entry_packing,
1226 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1227 .packed_entry_size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY,
1228 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1229 },
1230 [BLK_IDX_L2_LOOKUP_PARAMS] = {
1231 .packing = sja1105et_l2_lookup_params_entry_packing,
1232 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1233 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1234 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1235 },
1236 [BLK_IDX_L2_FORWARDING_PARAMS] = {
1237 .packing = sja1105_l2_forwarding_params_entry_packing,
1238 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1239 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1240 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1241 },
1242 [BLK_IDX_AVB_PARAMS] = {
1243 .packing = sja1105et_avb_params_entry_packing,
1244 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1245 .packed_entry_size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY,
1246 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1247 },
1248 [BLK_IDX_GENERAL_PARAMS] = {
1249 .packing = sja1105et_general_params_entry_packing,
1250 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1251 .packed_entry_size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY,
1252 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1253 },
1254 [BLK_IDX_RETAGGING] = {
1255 .packing = sja1105_retagging_entry_packing,
1256 .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1257 .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1258 .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1259 },
1260 [BLK_IDX_XMII_PARAMS] = {
1261 .packing = sja1105_xmii_params_entry_packing,
1262 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1263 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1264 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1265 },
1266};
1267
1268/* SJA1105T: First generation, TTEthernet */
1269const struct sja1105_table_ops sja1105t_table_ops[BLK_IDX_MAX] = {
1270 [BLK_IDX_SCHEDULE] = {
1271 .packing = sja1105_schedule_entry_packing,
1272 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry),
1273 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY,
1274 .max_entry_count = SJA1105_MAX_SCHEDULE_COUNT,
1275 },
1276 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {
1277 .packing = sja1105_schedule_entry_points_entry_packing,
1278 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_entry),
1279 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY,
1280 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_COUNT,
1281 },
1282 [BLK_IDX_VL_LOOKUP] = {
1283 .packing = sja1105_vl_lookup_entry_packing,
1284 .unpacked_entry_size = sizeof(struct sja1105_vl_lookup_entry),
1285 .packed_entry_size = SJA1105_SIZE_VL_LOOKUP_ENTRY,
1286 .max_entry_count = SJA1105_MAX_VL_LOOKUP_COUNT,
1287 },
1288 [BLK_IDX_VL_POLICING] = {
1289 .packing = sja1105_vl_policing_entry_packing,
1290 .unpacked_entry_size = sizeof(struct sja1105_vl_policing_entry),
1291 .packed_entry_size = SJA1105_SIZE_VL_POLICING_ENTRY,
1292 .max_entry_count = SJA1105_MAX_VL_POLICING_COUNT,
1293 },
1294 [BLK_IDX_VL_FORWARDING] = {
1295 .packing = sja1105_vl_forwarding_entry_packing,
1296 .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_entry),
1297 .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_ENTRY,
1298 .max_entry_count = SJA1105_MAX_VL_FORWARDING_COUNT,
1299 },
1300 [BLK_IDX_L2_LOOKUP] = {
1301 .packing = sja1105et_l2_lookup_entry_packing,
1302 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1303 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY,
1304 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1305 },
1306 [BLK_IDX_L2_POLICING] = {
1307 .packing = sja1105_l2_policing_entry_packing,
1308 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1309 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1310 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1311 },
1312 [BLK_IDX_VLAN_LOOKUP] = {
1313 .packing = sja1105_vlan_lookup_entry_packing,
1314 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1315 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1316 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1317 },
1318 [BLK_IDX_L2_FORWARDING] = {
1319 .packing = sja1105_l2_forwarding_entry_packing,
1320 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1321 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1322 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1323 },
1324 [BLK_IDX_MAC_CONFIG] = {
1325 .packing = sja1105et_mac_config_entry_packing,
1326 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1327 .packed_entry_size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY,
1328 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1329 },
1330 [BLK_IDX_SCHEDULE_PARAMS] = {
1331 .packing = sja1105_schedule_params_entry_packing,
1332 .unpacked_entry_size = sizeof(struct sja1105_schedule_params_entry),
1333 .packed_entry_size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY,
1334 .max_entry_count = SJA1105_MAX_SCHEDULE_PARAMS_COUNT,
1335 },
1336 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {
1337 .packing = sja1105_schedule_entry_points_params_entry_packing,
1338 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_params_entry),
1339 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY,
1340 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_PARAMS_COUNT,
1341 },
1342 [BLK_IDX_VL_FORWARDING_PARAMS] = {
1343 .packing = sja1105_vl_forwarding_params_entry_packing,
1344 .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_params_entry),
1345 .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY,
1346 .max_entry_count = SJA1105_MAX_VL_FORWARDING_PARAMS_COUNT,
1347 },
1348 [BLK_IDX_L2_LOOKUP_PARAMS] = {
1349 .packing = sja1105et_l2_lookup_params_entry_packing,
1350 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1351 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1352 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1353 },
1354 [BLK_IDX_L2_FORWARDING_PARAMS] = {
1355 .packing = sja1105_l2_forwarding_params_entry_packing,
1356 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1357 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1358 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1359 },
1360 [BLK_IDX_AVB_PARAMS] = {
1361 .packing = sja1105et_avb_params_entry_packing,
1362 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1363 .packed_entry_size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY,
1364 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1365 },
1366 [BLK_IDX_GENERAL_PARAMS] = {
1367 .packing = sja1105et_general_params_entry_packing,
1368 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1369 .packed_entry_size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY,
1370 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1371 },
1372 [BLK_IDX_RETAGGING] = {
1373 .packing = sja1105_retagging_entry_packing,
1374 .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1375 .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1376 .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1377 },
1378 [BLK_IDX_XMII_PARAMS] = {
1379 .packing = sja1105_xmii_params_entry_packing,
1380 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1381 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1382 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1383 },
1384};
1385
1386/* SJA1105P: Second generation, no TTEthernet, no SGMII */
1387const struct sja1105_table_ops sja1105p_table_ops[BLK_IDX_MAX] = {
1388 [BLK_IDX_L2_LOOKUP] = {
1389 .packing = sja1105pqrs_l2_lookup_entry_packing,
1390 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1391 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
1392 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1393 },
1394 [BLK_IDX_L2_POLICING] = {
1395 .packing = sja1105_l2_policing_entry_packing,
1396 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1397 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1398 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1399 },
1400 [BLK_IDX_VLAN_LOOKUP] = {
1401 .packing = sja1105_vlan_lookup_entry_packing,
1402 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1403 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1404 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1405 },
1406 [BLK_IDX_L2_FORWARDING] = {
1407 .packing = sja1105_l2_forwarding_entry_packing,
1408 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1409 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1410 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1411 },
1412 [BLK_IDX_MAC_CONFIG] = {
1413 .packing = sja1105pqrs_mac_config_entry_packing,
1414 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1415 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1416 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1417 },
1418 [BLK_IDX_L2_LOOKUP_PARAMS] = {
1419 .packing = sja1105pqrs_l2_lookup_params_entry_packing,
1420 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1421 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1422 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1423 },
1424 [BLK_IDX_L2_FORWARDING_PARAMS] = {
1425 .packing = sja1105_l2_forwarding_params_entry_packing,
1426 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1427 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1428 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1429 },
1430 [BLK_IDX_AVB_PARAMS] = {
1431 .packing = sja1105pqrs_avb_params_entry_packing,
1432 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1433 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1434 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1435 },
1436 [BLK_IDX_GENERAL_PARAMS] = {
1437 .packing = sja1105pqrs_general_params_entry_packing,
1438 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1439 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
1440 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1441 },
1442 [BLK_IDX_RETAGGING] = {
1443 .packing = sja1105_retagging_entry_packing,
1444 .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1445 .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1446 .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1447 },
1448 [BLK_IDX_XMII_PARAMS] = {
1449 .packing = sja1105_xmii_params_entry_packing,
1450 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1451 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1452 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1453 },
1454};
1455
1456/* SJA1105Q: Second generation, TTEthernet, no SGMII */
1457const struct sja1105_table_ops sja1105q_table_ops[BLK_IDX_MAX] = {
1458 [BLK_IDX_SCHEDULE] = {
1459 .packing = sja1105_schedule_entry_packing,
1460 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry),
1461 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY,
1462 .max_entry_count = SJA1105_MAX_SCHEDULE_COUNT,
1463 },
1464 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {
1465 .packing = sja1105_schedule_entry_points_entry_packing,
1466 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_entry),
1467 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY,
1468 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_COUNT,
1469 },
1470 [BLK_IDX_VL_LOOKUP] = {
1471 .packing = sja1105_vl_lookup_entry_packing,
1472 .unpacked_entry_size = sizeof(struct sja1105_vl_lookup_entry),
1473 .packed_entry_size = SJA1105_SIZE_VL_LOOKUP_ENTRY,
1474 .max_entry_count = SJA1105_MAX_VL_LOOKUP_COUNT,
1475 },
1476 [BLK_IDX_VL_POLICING] = {
1477 .packing = sja1105_vl_policing_entry_packing,
1478 .unpacked_entry_size = sizeof(struct sja1105_vl_policing_entry),
1479 .packed_entry_size = SJA1105_SIZE_VL_POLICING_ENTRY,
1480 .max_entry_count = SJA1105_MAX_VL_POLICING_COUNT,
1481 },
1482 [BLK_IDX_VL_FORWARDING] = {
1483 .packing = sja1105_vl_forwarding_entry_packing,
1484 .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_entry),
1485 .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_ENTRY,
1486 .max_entry_count = SJA1105_MAX_VL_FORWARDING_COUNT,
1487 },
1488 [BLK_IDX_L2_LOOKUP] = {
1489 .packing = sja1105pqrs_l2_lookup_entry_packing,
1490 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1491 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
1492 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1493 },
1494 [BLK_IDX_L2_POLICING] = {
1495 .packing = sja1105_l2_policing_entry_packing,
1496 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1497 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1498 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1499 },
1500 [BLK_IDX_VLAN_LOOKUP] = {
1501 .packing = sja1105_vlan_lookup_entry_packing,
1502 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1503 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1504 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1505 },
1506 [BLK_IDX_L2_FORWARDING] = {
1507 .packing = sja1105_l2_forwarding_entry_packing,
1508 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1509 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1510 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1511 },
1512 [BLK_IDX_MAC_CONFIG] = {
1513 .packing = sja1105pqrs_mac_config_entry_packing,
1514 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1515 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1516 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1517 },
1518 [BLK_IDX_SCHEDULE_PARAMS] = {
1519 .packing = sja1105_schedule_params_entry_packing,
1520 .unpacked_entry_size = sizeof(struct sja1105_schedule_params_entry),
1521 .packed_entry_size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY,
1522 .max_entry_count = SJA1105_MAX_SCHEDULE_PARAMS_COUNT,
1523 },
1524 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {
1525 .packing = sja1105_schedule_entry_points_params_entry_packing,
1526 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_params_entry),
1527 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY,
1528 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_PARAMS_COUNT,
1529 },
1530 [BLK_IDX_VL_FORWARDING_PARAMS] = {
1531 .packing = sja1105_vl_forwarding_params_entry_packing,
1532 .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_params_entry),
1533 .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY,
1534 .max_entry_count = SJA1105_MAX_VL_FORWARDING_PARAMS_COUNT,
1535 },
1536 [BLK_IDX_L2_LOOKUP_PARAMS] = {
1537 .packing = sja1105pqrs_l2_lookup_params_entry_packing,
1538 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1539 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1540 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1541 },
1542 [BLK_IDX_L2_FORWARDING_PARAMS] = {
1543 .packing = sja1105_l2_forwarding_params_entry_packing,
1544 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1545 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1546 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1547 },
1548 [BLK_IDX_AVB_PARAMS] = {
1549 .packing = sja1105pqrs_avb_params_entry_packing,
1550 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1551 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1552 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1553 },
1554 [BLK_IDX_GENERAL_PARAMS] = {
1555 .packing = sja1105pqrs_general_params_entry_packing,
1556 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1557 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
1558 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1559 },
1560 [BLK_IDX_RETAGGING] = {
1561 .packing = sja1105_retagging_entry_packing,
1562 .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1563 .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1564 .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1565 },
1566 [BLK_IDX_XMII_PARAMS] = {
1567 .packing = sja1105_xmii_params_entry_packing,
1568 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1569 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1570 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1571 },
1572};
1573
1574/* SJA1105R: Second generation, no TTEthernet, SGMII */
1575const struct sja1105_table_ops sja1105r_table_ops[BLK_IDX_MAX] = {
1576 [BLK_IDX_L2_LOOKUP] = {
1577 .packing = sja1105pqrs_l2_lookup_entry_packing,
1578 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1579 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
1580 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1581 },
1582 [BLK_IDX_L2_POLICING] = {
1583 .packing = sja1105_l2_policing_entry_packing,
1584 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1585 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1586 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1587 },
1588 [BLK_IDX_VLAN_LOOKUP] = {
1589 .packing = sja1105_vlan_lookup_entry_packing,
1590 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1591 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1592 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1593 },
1594 [BLK_IDX_L2_FORWARDING] = {
1595 .packing = sja1105_l2_forwarding_entry_packing,
1596 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1597 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1598 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1599 },
1600 [BLK_IDX_MAC_CONFIG] = {
1601 .packing = sja1105pqrs_mac_config_entry_packing,
1602 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1603 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1604 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1605 },
1606 [BLK_IDX_L2_LOOKUP_PARAMS] = {
1607 .packing = sja1105pqrs_l2_lookup_params_entry_packing,
1608 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1609 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1610 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1611 },
1612 [BLK_IDX_L2_FORWARDING_PARAMS] = {
1613 .packing = sja1105_l2_forwarding_params_entry_packing,
1614 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1615 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1616 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1617 },
1618 [BLK_IDX_AVB_PARAMS] = {
1619 .packing = sja1105pqrs_avb_params_entry_packing,
1620 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1621 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1622 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1623 },
1624 [BLK_IDX_GENERAL_PARAMS] = {
1625 .packing = sja1105pqrs_general_params_entry_packing,
1626 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1627 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
1628 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1629 },
1630 [BLK_IDX_RETAGGING] = {
1631 .packing = sja1105_retagging_entry_packing,
1632 .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1633 .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1634 .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1635 },
1636 [BLK_IDX_XMII_PARAMS] = {
1637 .packing = sja1105_xmii_params_entry_packing,
1638 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1639 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1640 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1641 },
1642};
1643
1644/* SJA1105S: Second generation, TTEthernet, SGMII */
1645const struct sja1105_table_ops sja1105s_table_ops[BLK_IDX_MAX] = {
1646 [BLK_IDX_SCHEDULE] = {
1647 .packing = sja1105_schedule_entry_packing,
1648 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry),
1649 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY,
1650 .max_entry_count = SJA1105_MAX_SCHEDULE_COUNT,
1651 },
1652 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {
1653 .packing = sja1105_schedule_entry_points_entry_packing,
1654 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_entry),
1655 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY,
1656 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_COUNT,
1657 },
1658 [BLK_IDX_VL_LOOKUP] = {
1659 .packing = sja1105_vl_lookup_entry_packing,
1660 .unpacked_entry_size = sizeof(struct sja1105_vl_lookup_entry),
1661 .packed_entry_size = SJA1105_SIZE_VL_LOOKUP_ENTRY,
1662 .max_entry_count = SJA1105_MAX_VL_LOOKUP_COUNT,
1663 },
1664 [BLK_IDX_VL_POLICING] = {
1665 .packing = sja1105_vl_policing_entry_packing,
1666 .unpacked_entry_size = sizeof(struct sja1105_vl_policing_entry),
1667 .packed_entry_size = SJA1105_SIZE_VL_POLICING_ENTRY,
1668 .max_entry_count = SJA1105_MAX_VL_POLICING_COUNT,
1669 },
1670 [BLK_IDX_VL_FORWARDING] = {
1671 .packing = sja1105_vl_forwarding_entry_packing,
1672 .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_entry),
1673 .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_ENTRY,
1674 .max_entry_count = SJA1105_MAX_VL_FORWARDING_COUNT,
1675 },
1676 [BLK_IDX_L2_LOOKUP] = {
1677 .packing = sja1105pqrs_l2_lookup_entry_packing,
1678 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1679 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
1680 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1681 },
1682 [BLK_IDX_L2_POLICING] = {
1683 .packing = sja1105_l2_policing_entry_packing,
1684 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1685 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1686 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1687 },
1688 [BLK_IDX_VLAN_LOOKUP] = {
1689 .packing = sja1105_vlan_lookup_entry_packing,
1690 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1691 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1692 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1693 },
1694 [BLK_IDX_L2_FORWARDING] = {
1695 .packing = sja1105_l2_forwarding_entry_packing,
1696 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1697 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1698 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1699 },
1700 [BLK_IDX_MAC_CONFIG] = {
1701 .packing = sja1105pqrs_mac_config_entry_packing,
1702 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1703 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1704 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1705 },
1706 [BLK_IDX_SCHEDULE_PARAMS] = {
1707 .packing = sja1105_schedule_params_entry_packing,
1708 .unpacked_entry_size = sizeof(struct sja1105_schedule_params_entry),
1709 .packed_entry_size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY,
1710 .max_entry_count = SJA1105_MAX_SCHEDULE_PARAMS_COUNT,
1711 },
1712 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {
1713 .packing = sja1105_schedule_entry_points_params_entry_packing,
1714 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_params_entry),
1715 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY,
1716 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_PARAMS_COUNT,
1717 },
1718 [BLK_IDX_VL_FORWARDING_PARAMS] = {
1719 .packing = sja1105_vl_forwarding_params_entry_packing,
1720 .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_params_entry),
1721 .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY,
1722 .max_entry_count = SJA1105_MAX_VL_FORWARDING_PARAMS_COUNT,
1723 },
1724 [BLK_IDX_L2_LOOKUP_PARAMS] = {
1725 .packing = sja1105pqrs_l2_lookup_params_entry_packing,
1726 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1727 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1728 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1729 },
1730 [BLK_IDX_L2_FORWARDING_PARAMS] = {
1731 .packing = sja1105_l2_forwarding_params_entry_packing,
1732 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1733 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1734 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1735 },
1736 [BLK_IDX_AVB_PARAMS] = {
1737 .packing = sja1105pqrs_avb_params_entry_packing,
1738 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1739 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1740 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1741 },
1742 [BLK_IDX_GENERAL_PARAMS] = {
1743 .packing = sja1105pqrs_general_params_entry_packing,
1744 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1745 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
1746 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1747 },
1748 [BLK_IDX_RETAGGING] = {
1749 .packing = sja1105_retagging_entry_packing,
1750 .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1751 .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1752 .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1753 },
1754 [BLK_IDX_XMII_PARAMS] = {
1755 .packing = sja1105_xmii_params_entry_packing,
1756 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1757 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1758 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1759 },
1760};
1761
1762/* SJA1110A: Third generation */
1763const struct sja1105_table_ops sja1110_table_ops[BLK_IDX_MAX] = {
1764 [BLK_IDX_SCHEDULE] = {
1765 .packing = sja1110_schedule_entry_packing,
1766 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry),
1767 .packed_entry_size = SJA1110_SIZE_SCHEDULE_ENTRY,
1768 .max_entry_count = SJA1110_MAX_SCHEDULE_COUNT,
1769 },
1770 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {
1771 .packing = sja1110_schedule_entry_points_entry_packing,
1772 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_entry),
1773 .packed_entry_size = SJA1110_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY,
1774 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_COUNT,
1775 },
1776 [BLK_IDX_VL_LOOKUP] = {
1777 .packing = sja1110_vl_lookup_entry_packing,
1778 .unpacked_entry_size = sizeof(struct sja1105_vl_lookup_entry),
1779 .packed_entry_size = SJA1105_SIZE_VL_LOOKUP_ENTRY,
1780 .max_entry_count = SJA1110_MAX_VL_LOOKUP_COUNT,
1781 },
1782 [BLK_IDX_VL_POLICING] = {
1783 .packing = sja1110_vl_policing_entry_packing,
1784 .unpacked_entry_size = sizeof(struct sja1105_vl_policing_entry),
1785 .packed_entry_size = SJA1105_SIZE_VL_POLICING_ENTRY,
1786 .max_entry_count = SJA1110_MAX_VL_POLICING_COUNT,
1787 },
1788 [BLK_IDX_VL_FORWARDING] = {
1789 .packing = sja1110_vl_forwarding_entry_packing,
1790 .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_entry),
1791 .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_ENTRY,
1792 .max_entry_count = SJA1110_MAX_VL_FORWARDING_COUNT,
1793 },
1794 [BLK_IDX_L2_LOOKUP] = {
1795 .packing = sja1110_l2_lookup_entry_packing,
1796 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1797 .packed_entry_size = SJA1110_SIZE_L2_LOOKUP_ENTRY,
1798 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1799 },
1800 [BLK_IDX_L2_POLICING] = {
1801 .packing = sja1110_l2_policing_entry_packing,
1802 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1803 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1804 .max_entry_count = SJA1110_MAX_L2_POLICING_COUNT,
1805 },
1806 [BLK_IDX_VLAN_LOOKUP] = {
1807 .packing = sja1110_vlan_lookup_entry_packing,
1808 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1809 .packed_entry_size = SJA1110_SIZE_VLAN_LOOKUP_ENTRY,
1810 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1811 },
1812 [BLK_IDX_L2_FORWARDING] = {
1813 .packing = sja1110_l2_forwarding_entry_packing,
1814 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1815 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1816 .max_entry_count = SJA1110_MAX_L2_FORWARDING_COUNT,
1817 },
1818 [BLK_IDX_MAC_CONFIG] = {
1819 .packing = sja1110_mac_config_entry_packing,
1820 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1821 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1822 .max_entry_count = SJA1110_MAX_MAC_CONFIG_COUNT,
1823 },
1824 [BLK_IDX_SCHEDULE_PARAMS] = {
1825 .packing = sja1110_schedule_params_entry_packing,
1826 .unpacked_entry_size = sizeof(struct sja1105_schedule_params_entry),
1827 .packed_entry_size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY,
1828 .max_entry_count = SJA1105_MAX_SCHEDULE_PARAMS_COUNT,
1829 },
1830 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {
1831 .packing = sja1105_schedule_entry_points_params_entry_packing,
1832 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_params_entry),
1833 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY,
1834 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_PARAMS_COUNT,
1835 },
1836 [BLK_IDX_VL_FORWARDING_PARAMS] = {
1837 .packing = sja1110_vl_forwarding_params_entry_packing,
1838 .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_params_entry),
1839 .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY,
1840 .max_entry_count = SJA1105_MAX_VL_FORWARDING_PARAMS_COUNT,
1841 },
1842 [BLK_IDX_L2_LOOKUP_PARAMS] = {
1843 .packing = sja1110_l2_lookup_params_entry_packing,
1844 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1845 .packed_entry_size = SJA1110_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1846 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1847 },
1848 [BLK_IDX_L2_FORWARDING_PARAMS] = {
1849 .packing = sja1110_l2_forwarding_params_entry_packing,
1850 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1851 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1852 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1853 },
1854 [BLK_IDX_AVB_PARAMS] = {
1855 .packing = sja1105pqrs_avb_params_entry_packing,
1856 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1857 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1858 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1859 },
1860 [BLK_IDX_GENERAL_PARAMS] = {
1861 .packing = sja1110_general_params_entry_packing,
1862 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1863 .packed_entry_size = SJA1110_SIZE_GENERAL_PARAMS_ENTRY,
1864 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1865 },
1866 [BLK_IDX_RETAGGING] = {
1867 .packing = sja1110_retagging_entry_packing,
1868 .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1869 .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1870 .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1871 },
1872 [BLK_IDX_XMII_PARAMS] = {
1873 .packing = sja1110_xmii_params_entry_packing,
1874 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1875 .packed_entry_size = SJA1110_SIZE_XMII_PARAMS_ENTRY,
1876 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1877 },
1878 [BLK_IDX_PCP_REMAPPING] = {
1879 .packing = sja1110_pcp_remapping_entry_packing,
1880 .unpacked_entry_size = sizeof(struct sja1110_pcp_remapping_entry),
1881 .packed_entry_size = SJA1110_SIZE_PCP_REMAPPING_ENTRY,
1882 .max_entry_count = SJA1110_MAX_PCP_REMAPPING_COUNT,
1883 },
1884};
1885
1886int sja1105_static_config_init(struct sja1105_static_config *config,
1887 const struct sja1105_table_ops *static_ops,
1888 u64 device_id)
1889{
1890 enum sja1105_blk_idx i;
1891
1892 *config = (struct sja1105_static_config) {0};
1893
1894 /* Transfer static_ops array from priv into per-table ops
1895 * for handier access
1896 */
1897 for (i = 0; i < BLK_IDX_MAX; i++)
1898 config->tables[i].ops = &static_ops[i];
1899
1900 config->device_id = device_id;
1901 return 0;
1902}
1903
1904void sja1105_static_config_free(struct sja1105_static_config *config)
1905{
1906 enum sja1105_blk_idx i;
1907
1908 for (i = 0; i < BLK_IDX_MAX; i++) {
1909 if (config->tables[i].entry_count) {
1910 kfree(config->tables[i].entries);
1911 config->tables[i].entry_count = 0;
1912 }
1913 }
1914}
1915
1916int sja1105_table_delete_entry(struct sja1105_table *table, int i)
1917{
1918 size_t entry_size = table->ops->unpacked_entry_size;
1919 u8 *entries = table->entries;
1920
1921 if (i > table->entry_count)
1922 return -ERANGE;
1923
1924 memmove(entries + i * entry_size, entries + (i + 1) * entry_size,
1925 (table->entry_count - i) * entry_size);
1926
1927 table->entry_count--;
1928
1929 return 0;
1930}
1931
1932/* No pointers to table->entries should be kept when this is called. */
1933int sja1105_table_resize(struct sja1105_table *table, size_t new_count)
1934{
1935 size_t entry_size = table->ops->unpacked_entry_size;
1936 void *new_entries, *old_entries = table->entries;
1937
1938 if (new_count > table->ops->max_entry_count)
1939 return -ERANGE;
1940
1941 new_entries = kcalloc(new_count, entry_size, GFP_KERNEL);
1942 if (!new_entries)
1943 return -ENOMEM;
1944
1945 memcpy(new_entries, old_entries, min(new_count, table->entry_count) *
1946 entry_size);
1947
1948 table->entries = new_entries;
1949 table->entry_count = new_count;
1950 kfree(old_entries);
1951 return 0;
1952}
1// SPDX-License-Identifier: BSD-3-Clause
2/* Copyright (c) 2016-2018, NXP Semiconductors
3 * Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
4 */
5#include "sja1105_static_config.h"
6#include <linux/crc32.h>
7#include <linux/slab.h>
8#include <linux/string.h>
9#include <linux/errno.h>
10
11/* Convenience wrappers over the generic packing functions. These take into
12 * account the SJA1105 memory layout quirks and provide some level of
13 * programmer protection against incorrect API use. The errors are not expected
14 * to occur durring runtime, therefore printing and swallowing them here is
15 * appropriate instead of clutterring up higher-level code.
16 */
17void sja1105_pack(void *buf, const u64 *val, int start, int end, size_t len)
18{
19 int rc = packing(buf, (u64 *)val, start, end, len,
20 PACK, QUIRK_LSW32_IS_FIRST);
21
22 if (likely(!rc))
23 return;
24
25 if (rc == -EINVAL) {
26 pr_err("Start bit (%d) expected to be larger than end (%d)\n",
27 start, end);
28 } else if (rc == -ERANGE) {
29 if ((start - end + 1) > 64)
30 pr_err("Field %d-%d too large for 64 bits!\n",
31 start, end);
32 else
33 pr_err("Cannot store %llx inside bits %d-%d (would truncate)\n",
34 *val, start, end);
35 }
36 dump_stack();
37}
38
39void sja1105_unpack(const void *buf, u64 *val, int start, int end, size_t len)
40{
41 int rc = packing((void *)buf, val, start, end, len,
42 UNPACK, QUIRK_LSW32_IS_FIRST);
43
44 if (likely(!rc))
45 return;
46
47 if (rc == -EINVAL)
48 pr_err("Start bit (%d) expected to be larger than end (%d)\n",
49 start, end);
50 else if (rc == -ERANGE)
51 pr_err("Field %d-%d too large for 64 bits!\n",
52 start, end);
53 dump_stack();
54}
55
56void sja1105_packing(void *buf, u64 *val, int start, int end,
57 size_t len, enum packing_op op)
58{
59 int rc = packing(buf, val, start, end, len, op, QUIRK_LSW32_IS_FIRST);
60
61 if (likely(!rc))
62 return;
63
64 if (rc == -EINVAL) {
65 pr_err("Start bit (%d) expected to be larger than end (%d)\n",
66 start, end);
67 } else if (rc == -ERANGE) {
68 if ((start - end + 1) > 64)
69 pr_err("Field %d-%d too large for 64 bits!\n",
70 start, end);
71 else
72 pr_err("Cannot store %llx inside bits %d-%d (would truncate)\n",
73 *val, start, end);
74 }
75 dump_stack();
76}
77
78/* Little-endian Ethernet CRC32 of data packed as big-endian u32 words */
79u32 sja1105_crc32(const void *buf, size_t len)
80{
81 unsigned int i;
82 u64 word;
83 u32 crc;
84
85 /* seed */
86 crc = ~0;
87 for (i = 0; i < len; i += 4) {
88 sja1105_unpack((void *)buf + i, &word, 31, 0, 4);
89 crc = crc32_le(crc, (u8 *)&word, 4);
90 }
91 return ~crc;
92}
93
94static size_t sja1105et_avb_params_entry_packing(void *buf, void *entry_ptr,
95 enum packing_op op)
96{
97 const size_t size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY;
98 struct sja1105_avb_params_entry *entry = entry_ptr;
99
100 sja1105_packing(buf, &entry->destmeta, 95, 48, size, op);
101 sja1105_packing(buf, &entry->srcmeta, 47, 0, size, op);
102 return size;
103}
104
105static size_t sja1105pqrs_avb_params_entry_packing(void *buf, void *entry_ptr,
106 enum packing_op op)
107{
108 const size_t size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY;
109 struct sja1105_avb_params_entry *entry = entry_ptr;
110
111 sja1105_packing(buf, &entry->destmeta, 125, 78, size, op);
112 sja1105_packing(buf, &entry->srcmeta, 77, 30, size, op);
113 return size;
114}
115
116static size_t sja1105et_general_params_entry_packing(void *buf, void *entry_ptr,
117 enum packing_op op)
118{
119 const size_t size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY;
120 struct sja1105_general_params_entry *entry = entry_ptr;
121
122 sja1105_packing(buf, &entry->vllupformat, 319, 319, size, op);
123 sja1105_packing(buf, &entry->mirr_ptacu, 318, 318, size, op);
124 sja1105_packing(buf, &entry->switchid, 317, 315, size, op);
125 sja1105_packing(buf, &entry->hostprio, 314, 312, size, op);
126 sja1105_packing(buf, &entry->mac_fltres1, 311, 264, size, op);
127 sja1105_packing(buf, &entry->mac_fltres0, 263, 216, size, op);
128 sja1105_packing(buf, &entry->mac_flt1, 215, 168, size, op);
129 sja1105_packing(buf, &entry->mac_flt0, 167, 120, size, op);
130 sja1105_packing(buf, &entry->incl_srcpt1, 119, 119, size, op);
131 sja1105_packing(buf, &entry->incl_srcpt0, 118, 118, size, op);
132 sja1105_packing(buf, &entry->send_meta1, 117, 117, size, op);
133 sja1105_packing(buf, &entry->send_meta0, 116, 116, size, op);
134 sja1105_packing(buf, &entry->casc_port, 115, 113, size, op);
135 sja1105_packing(buf, &entry->host_port, 112, 110, size, op);
136 sja1105_packing(buf, &entry->mirr_port, 109, 107, size, op);
137 sja1105_packing(buf, &entry->vlmarker, 106, 75, size, op);
138 sja1105_packing(buf, &entry->vlmask, 74, 43, size, op);
139 sja1105_packing(buf, &entry->tpid, 42, 27, size, op);
140 sja1105_packing(buf, &entry->ignore2stf, 26, 26, size, op);
141 sja1105_packing(buf, &entry->tpid2, 25, 10, size, op);
142 return size;
143}
144
145static size_t
146sja1105pqrs_general_params_entry_packing(void *buf, void *entry_ptr,
147 enum packing_op op)
148{
149 const size_t size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY;
150 struct sja1105_general_params_entry *entry = entry_ptr;
151
152 sja1105_packing(buf, &entry->vllupformat, 351, 351, size, op);
153 sja1105_packing(buf, &entry->mirr_ptacu, 350, 350, size, op);
154 sja1105_packing(buf, &entry->switchid, 349, 347, size, op);
155 sja1105_packing(buf, &entry->hostprio, 346, 344, size, op);
156 sja1105_packing(buf, &entry->mac_fltres1, 343, 296, size, op);
157 sja1105_packing(buf, &entry->mac_fltres0, 295, 248, size, op);
158 sja1105_packing(buf, &entry->mac_flt1, 247, 200, size, op);
159 sja1105_packing(buf, &entry->mac_flt0, 199, 152, size, op);
160 sja1105_packing(buf, &entry->incl_srcpt1, 151, 151, size, op);
161 sja1105_packing(buf, &entry->incl_srcpt0, 150, 150, size, op);
162 sja1105_packing(buf, &entry->send_meta1, 149, 149, size, op);
163 sja1105_packing(buf, &entry->send_meta0, 148, 148, size, op);
164 sja1105_packing(buf, &entry->casc_port, 147, 145, size, op);
165 sja1105_packing(buf, &entry->host_port, 144, 142, size, op);
166 sja1105_packing(buf, &entry->mirr_port, 141, 139, size, op);
167 sja1105_packing(buf, &entry->vlmarker, 138, 107, size, op);
168 sja1105_packing(buf, &entry->vlmask, 106, 75, size, op);
169 sja1105_packing(buf, &entry->tpid, 74, 59, size, op);
170 sja1105_packing(buf, &entry->ignore2stf, 58, 58, size, op);
171 sja1105_packing(buf, &entry->tpid2, 57, 42, size, op);
172 sja1105_packing(buf, &entry->queue_ts, 41, 41, size, op);
173 sja1105_packing(buf, &entry->egrmirrvid, 40, 29, size, op);
174 sja1105_packing(buf, &entry->egrmirrpcp, 28, 26, size, op);
175 sja1105_packing(buf, &entry->egrmirrdei, 25, 25, size, op);
176 sja1105_packing(buf, &entry->replay_port, 24, 22, size, op);
177 return size;
178}
179
180static size_t
181sja1105_l2_forwarding_params_entry_packing(void *buf, void *entry_ptr,
182 enum packing_op op)
183{
184 const size_t size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY;
185 struct sja1105_l2_forwarding_params_entry *entry = entry_ptr;
186 int offset, i;
187
188 sja1105_packing(buf, &entry->max_dynp, 95, 93, size, op);
189 for (i = 0, offset = 13; i < 8; i++, offset += 10)
190 sja1105_packing(buf, &entry->part_spc[i],
191 offset + 9, offset + 0, size, op);
192 return size;
193}
194
195size_t sja1105_l2_forwarding_entry_packing(void *buf, void *entry_ptr,
196 enum packing_op op)
197{
198 const size_t size = SJA1105_SIZE_L2_FORWARDING_ENTRY;
199 struct sja1105_l2_forwarding_entry *entry = entry_ptr;
200 int offset, i;
201
202 sja1105_packing(buf, &entry->bc_domain, 63, 59, size, op);
203 sja1105_packing(buf, &entry->reach_port, 58, 54, size, op);
204 sja1105_packing(buf, &entry->fl_domain, 53, 49, size, op);
205 for (i = 0, offset = 25; i < 8; i++, offset += 3)
206 sja1105_packing(buf, &entry->vlan_pmap[i],
207 offset + 2, offset + 0, size, op);
208 return size;
209}
210
211static size_t
212sja1105et_l2_lookup_params_entry_packing(void *buf, void *entry_ptr,
213 enum packing_op op)
214{
215 const size_t size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY;
216 struct sja1105_l2_lookup_params_entry *entry = entry_ptr;
217
218 sja1105_packing(buf, &entry->maxage, 31, 17, size, op);
219 sja1105_packing(buf, &entry->dyn_tbsz, 16, 14, size, op);
220 sja1105_packing(buf, &entry->poly, 13, 6, size, op);
221 sja1105_packing(buf, &entry->shared_learn, 5, 5, size, op);
222 sja1105_packing(buf, &entry->no_enf_hostprt, 4, 4, size, op);
223 sja1105_packing(buf, &entry->no_mgmt_learn, 3, 3, size, op);
224 return size;
225}
226
227static size_t
228sja1105pqrs_l2_lookup_params_entry_packing(void *buf, void *entry_ptr,
229 enum packing_op op)
230{
231 const size_t size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY;
232 struct sja1105_l2_lookup_params_entry *entry = entry_ptr;
233 int offset, i;
234
235 for (i = 0, offset = 58; i < 5; i++, offset += 11)
236 sja1105_packing(buf, &entry->maxaddrp[i],
237 offset + 10, offset + 0, size, op);
238 sja1105_packing(buf, &entry->maxage, 57, 43, size, op);
239 sja1105_packing(buf, &entry->start_dynspc, 42, 33, size, op);
240 sja1105_packing(buf, &entry->drpnolearn, 32, 28, size, op);
241 sja1105_packing(buf, &entry->shared_learn, 27, 27, size, op);
242 sja1105_packing(buf, &entry->no_enf_hostprt, 26, 26, size, op);
243 sja1105_packing(buf, &entry->no_mgmt_learn, 25, 25, size, op);
244 sja1105_packing(buf, &entry->use_static, 24, 24, size, op);
245 sja1105_packing(buf, &entry->owr_dyn, 23, 23, size, op);
246 sja1105_packing(buf, &entry->learn_once, 22, 22, size, op);
247 return size;
248}
249
250size_t sja1105et_l2_lookup_entry_packing(void *buf, void *entry_ptr,
251 enum packing_op op)
252{
253 const size_t size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY;
254 struct sja1105_l2_lookup_entry *entry = entry_ptr;
255
256 sja1105_packing(buf, &entry->vlanid, 95, 84, size, op);
257 sja1105_packing(buf, &entry->macaddr, 83, 36, size, op);
258 sja1105_packing(buf, &entry->destports, 35, 31, size, op);
259 sja1105_packing(buf, &entry->enfport, 30, 30, size, op);
260 sja1105_packing(buf, &entry->index, 29, 20, size, op);
261 return size;
262}
263
264size_t sja1105pqrs_l2_lookup_entry_packing(void *buf, void *entry_ptr,
265 enum packing_op op)
266{
267 const size_t size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY;
268 struct sja1105_l2_lookup_entry *entry = entry_ptr;
269
270 if (entry->lockeds) {
271 sja1105_packing(buf, &entry->tsreg, 159, 159, size, op);
272 sja1105_packing(buf, &entry->mirrvlan, 158, 147, size, op);
273 sja1105_packing(buf, &entry->takets, 146, 146, size, op);
274 sja1105_packing(buf, &entry->mirr, 145, 145, size, op);
275 sja1105_packing(buf, &entry->retag, 144, 144, size, op);
276 } else {
277 sja1105_packing(buf, &entry->touched, 159, 159, size, op);
278 sja1105_packing(buf, &entry->age, 158, 144, size, op);
279 }
280 sja1105_packing(buf, &entry->mask_iotag, 143, 143, size, op);
281 sja1105_packing(buf, &entry->mask_vlanid, 142, 131, size, op);
282 sja1105_packing(buf, &entry->mask_macaddr, 130, 83, size, op);
283 sja1105_packing(buf, &entry->iotag, 82, 82, size, op);
284 sja1105_packing(buf, &entry->vlanid, 81, 70, size, op);
285 sja1105_packing(buf, &entry->macaddr, 69, 22, size, op);
286 sja1105_packing(buf, &entry->destports, 21, 17, size, op);
287 sja1105_packing(buf, &entry->enfport, 16, 16, size, op);
288 sja1105_packing(buf, &entry->index, 15, 6, size, op);
289 return size;
290}
291
292static size_t sja1105_l2_policing_entry_packing(void *buf, void *entry_ptr,
293 enum packing_op op)
294{
295 const size_t size = SJA1105_SIZE_L2_POLICING_ENTRY;
296 struct sja1105_l2_policing_entry *entry = entry_ptr;
297
298 sja1105_packing(buf, &entry->sharindx, 63, 58, size, op);
299 sja1105_packing(buf, &entry->smax, 57, 42, size, op);
300 sja1105_packing(buf, &entry->rate, 41, 26, size, op);
301 sja1105_packing(buf, &entry->maxlen, 25, 15, size, op);
302 sja1105_packing(buf, &entry->partition, 14, 12, size, op);
303 return size;
304}
305
306static size_t sja1105et_mac_config_entry_packing(void *buf, void *entry_ptr,
307 enum packing_op op)
308{
309 const size_t size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY;
310 struct sja1105_mac_config_entry *entry = entry_ptr;
311 int offset, i;
312
313 for (i = 0, offset = 72; i < 8; i++, offset += 19) {
314 sja1105_packing(buf, &entry->enabled[i],
315 offset + 0, offset + 0, size, op);
316 sja1105_packing(buf, &entry->base[i],
317 offset + 9, offset + 1, size, op);
318 sja1105_packing(buf, &entry->top[i],
319 offset + 18, offset + 10, size, op);
320 }
321 sja1105_packing(buf, &entry->ifg, 71, 67, size, op);
322 sja1105_packing(buf, &entry->speed, 66, 65, size, op);
323 sja1105_packing(buf, &entry->tp_delin, 64, 49, size, op);
324 sja1105_packing(buf, &entry->tp_delout, 48, 33, size, op);
325 sja1105_packing(buf, &entry->maxage, 32, 25, size, op);
326 sja1105_packing(buf, &entry->vlanprio, 24, 22, size, op);
327 sja1105_packing(buf, &entry->vlanid, 21, 10, size, op);
328 sja1105_packing(buf, &entry->ing_mirr, 9, 9, size, op);
329 sja1105_packing(buf, &entry->egr_mirr, 8, 8, size, op);
330 sja1105_packing(buf, &entry->drpnona664, 7, 7, size, op);
331 sja1105_packing(buf, &entry->drpdtag, 6, 6, size, op);
332 sja1105_packing(buf, &entry->drpuntag, 5, 5, size, op);
333 sja1105_packing(buf, &entry->retag, 4, 4, size, op);
334 sja1105_packing(buf, &entry->dyn_learn, 3, 3, size, op);
335 sja1105_packing(buf, &entry->egress, 2, 2, size, op);
336 sja1105_packing(buf, &entry->ingress, 1, 1, size, op);
337 return size;
338}
339
340size_t sja1105pqrs_mac_config_entry_packing(void *buf, void *entry_ptr,
341 enum packing_op op)
342{
343 const size_t size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY;
344 struct sja1105_mac_config_entry *entry = entry_ptr;
345 int offset, i;
346
347 for (i = 0, offset = 104; i < 8; i++, offset += 19) {
348 sja1105_packing(buf, &entry->enabled[i],
349 offset + 0, offset + 0, size, op);
350 sja1105_packing(buf, &entry->base[i],
351 offset + 9, offset + 1, size, op);
352 sja1105_packing(buf, &entry->top[i],
353 offset + 18, offset + 10, size, op);
354 }
355 sja1105_packing(buf, &entry->ifg, 103, 99, size, op);
356 sja1105_packing(buf, &entry->speed, 98, 97, size, op);
357 sja1105_packing(buf, &entry->tp_delin, 96, 81, size, op);
358 sja1105_packing(buf, &entry->tp_delout, 80, 65, size, op);
359 sja1105_packing(buf, &entry->maxage, 64, 57, size, op);
360 sja1105_packing(buf, &entry->vlanprio, 56, 54, size, op);
361 sja1105_packing(buf, &entry->vlanid, 53, 42, size, op);
362 sja1105_packing(buf, &entry->ing_mirr, 41, 41, size, op);
363 sja1105_packing(buf, &entry->egr_mirr, 40, 40, size, op);
364 sja1105_packing(buf, &entry->drpnona664, 39, 39, size, op);
365 sja1105_packing(buf, &entry->drpdtag, 38, 38, size, op);
366 sja1105_packing(buf, &entry->drpuntag, 35, 35, size, op);
367 sja1105_packing(buf, &entry->retag, 34, 34, size, op);
368 sja1105_packing(buf, &entry->dyn_learn, 33, 33, size, op);
369 sja1105_packing(buf, &entry->egress, 32, 32, size, op);
370 sja1105_packing(buf, &entry->ingress, 31, 31, size, op);
371 return size;
372}
373
374static size_t
375sja1105_schedule_entry_points_params_entry_packing(void *buf, void *entry_ptr,
376 enum packing_op op)
377{
378 struct sja1105_schedule_entry_points_params_entry *entry = entry_ptr;
379 const size_t size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY;
380
381 sja1105_packing(buf, &entry->clksrc, 31, 30, size, op);
382 sja1105_packing(buf, &entry->actsubsch, 29, 27, size, op);
383 return size;
384}
385
386static size_t
387sja1105_schedule_entry_points_entry_packing(void *buf, void *entry_ptr,
388 enum packing_op op)
389{
390 struct sja1105_schedule_entry_points_entry *entry = entry_ptr;
391 const size_t size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY;
392
393 sja1105_packing(buf, &entry->subschindx, 31, 29, size, op);
394 sja1105_packing(buf, &entry->delta, 28, 11, size, op);
395 sja1105_packing(buf, &entry->address, 10, 1, size, op);
396 return size;
397}
398
399static size_t sja1105_schedule_params_entry_packing(void *buf, void *entry_ptr,
400 enum packing_op op)
401{
402 const size_t size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY;
403 struct sja1105_schedule_params_entry *entry = entry_ptr;
404 int offset, i;
405
406 for (i = 0, offset = 16; i < 8; i++, offset += 10)
407 sja1105_packing(buf, &entry->subscheind[i],
408 offset + 9, offset + 0, size, op);
409 return size;
410}
411
412static size_t sja1105_schedule_entry_packing(void *buf, void *entry_ptr,
413 enum packing_op op)
414{
415 const size_t size = SJA1105_SIZE_SCHEDULE_ENTRY;
416 struct sja1105_schedule_entry *entry = entry_ptr;
417
418 sja1105_packing(buf, &entry->winstindex, 63, 54, size, op);
419 sja1105_packing(buf, &entry->winend, 53, 53, size, op);
420 sja1105_packing(buf, &entry->winst, 52, 52, size, op);
421 sja1105_packing(buf, &entry->destports, 51, 47, size, op);
422 sja1105_packing(buf, &entry->setvalid, 46, 46, size, op);
423 sja1105_packing(buf, &entry->txen, 45, 45, size, op);
424 sja1105_packing(buf, &entry->resmedia_en, 44, 44, size, op);
425 sja1105_packing(buf, &entry->resmedia, 43, 36, size, op);
426 sja1105_packing(buf, &entry->vlindex, 35, 26, size, op);
427 sja1105_packing(buf, &entry->delta, 25, 8, size, op);
428 return size;
429}
430
431size_t sja1105_vlan_lookup_entry_packing(void *buf, void *entry_ptr,
432 enum packing_op op)
433{
434 const size_t size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY;
435 struct sja1105_vlan_lookup_entry *entry = entry_ptr;
436
437 sja1105_packing(buf, &entry->ving_mirr, 63, 59, size, op);
438 sja1105_packing(buf, &entry->vegr_mirr, 58, 54, size, op);
439 sja1105_packing(buf, &entry->vmemb_port, 53, 49, size, op);
440 sja1105_packing(buf, &entry->vlan_bc, 48, 44, size, op);
441 sja1105_packing(buf, &entry->tag_port, 43, 39, size, op);
442 sja1105_packing(buf, &entry->vlanid, 38, 27, size, op);
443 return size;
444}
445
446static size_t sja1105_xmii_params_entry_packing(void *buf, void *entry_ptr,
447 enum packing_op op)
448{
449 const size_t size = SJA1105_SIZE_XMII_PARAMS_ENTRY;
450 struct sja1105_xmii_params_entry *entry = entry_ptr;
451 int offset, i;
452
453 for (i = 0, offset = 17; i < 5; i++, offset += 3) {
454 sja1105_packing(buf, &entry->xmii_mode[i],
455 offset + 1, offset + 0, size, op);
456 sja1105_packing(buf, &entry->phy_mac[i],
457 offset + 2, offset + 2, size, op);
458 }
459 return size;
460}
461
462size_t sja1105_table_header_packing(void *buf, void *entry_ptr,
463 enum packing_op op)
464{
465 const size_t size = SJA1105_SIZE_TABLE_HEADER;
466 struct sja1105_table_header *entry = entry_ptr;
467
468 sja1105_packing(buf, &entry->block_id, 31, 24, size, op);
469 sja1105_packing(buf, &entry->len, 55, 32, size, op);
470 sja1105_packing(buf, &entry->crc, 95, 64, size, op);
471 return size;
472}
473
474/* WARNING: the *hdr pointer is really non-const, because it is
475 * modifying the CRC of the header for a 2-stage packing operation
476 */
477void
478sja1105_table_header_pack_with_crc(void *buf, struct sja1105_table_header *hdr)
479{
480 /* First pack the table as-is, then calculate the CRC, and
481 * finally put the proper CRC into the packed buffer
482 */
483 memset(buf, 0, SJA1105_SIZE_TABLE_HEADER);
484 sja1105_table_header_packing(buf, hdr, PACK);
485 hdr->crc = sja1105_crc32(buf, SJA1105_SIZE_TABLE_HEADER - 4);
486 sja1105_pack(buf + SJA1105_SIZE_TABLE_HEADER - 4, &hdr->crc, 31, 0, 4);
487}
488
489static void sja1105_table_write_crc(u8 *table_start, u8 *crc_ptr)
490{
491 u64 computed_crc;
492 int len_bytes;
493
494 len_bytes = (uintptr_t)(crc_ptr - table_start);
495 computed_crc = sja1105_crc32(table_start, len_bytes);
496 sja1105_pack(crc_ptr, &computed_crc, 31, 0, 4);
497}
498
499/* The block IDs that the switches support are unfortunately sparse, so keep a
500 * mapping table to "block indices" and translate back and forth so that we
501 * don't waste useless memory in struct sja1105_static_config.
502 * Also, since the block id comes from essentially untrusted input (unpacking
503 * the static config from userspace) it has to be sanitized (range-checked)
504 * before blindly indexing kernel memory with the blk_idx.
505 */
506static u64 blk_id_map[BLK_IDX_MAX] = {
507 [BLK_IDX_SCHEDULE] = BLKID_SCHEDULE,
508 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = BLKID_SCHEDULE_ENTRY_POINTS,
509 [BLK_IDX_L2_LOOKUP] = BLKID_L2_LOOKUP,
510 [BLK_IDX_L2_POLICING] = BLKID_L2_POLICING,
511 [BLK_IDX_VLAN_LOOKUP] = BLKID_VLAN_LOOKUP,
512 [BLK_IDX_L2_FORWARDING] = BLKID_L2_FORWARDING,
513 [BLK_IDX_MAC_CONFIG] = BLKID_MAC_CONFIG,
514 [BLK_IDX_SCHEDULE_PARAMS] = BLKID_SCHEDULE_PARAMS,
515 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = BLKID_SCHEDULE_ENTRY_POINTS_PARAMS,
516 [BLK_IDX_L2_LOOKUP_PARAMS] = BLKID_L2_LOOKUP_PARAMS,
517 [BLK_IDX_L2_FORWARDING_PARAMS] = BLKID_L2_FORWARDING_PARAMS,
518 [BLK_IDX_AVB_PARAMS] = BLKID_AVB_PARAMS,
519 [BLK_IDX_GENERAL_PARAMS] = BLKID_GENERAL_PARAMS,
520 [BLK_IDX_XMII_PARAMS] = BLKID_XMII_PARAMS,
521};
522
523const char *sja1105_static_config_error_msg[] = {
524 [SJA1105_CONFIG_OK] = "",
525 [SJA1105_TTETHERNET_NOT_SUPPORTED] =
526 "schedule-table present, but TTEthernet is "
527 "only supported on T and Q/S",
528 [SJA1105_INCORRECT_TTETHERNET_CONFIGURATION] =
529 "schedule-table present, but one of "
530 "schedule-entry-points-table, schedule-parameters-table or "
531 "schedule-entry-points-parameters table is empty",
532 [SJA1105_MISSING_L2_POLICING_TABLE] =
533 "l2-policing-table needs to have at least one entry",
534 [SJA1105_MISSING_L2_FORWARDING_TABLE] =
535 "l2-forwarding-table is either missing or incomplete",
536 [SJA1105_MISSING_L2_FORWARDING_PARAMS_TABLE] =
537 "l2-forwarding-parameters-table is missing",
538 [SJA1105_MISSING_GENERAL_PARAMS_TABLE] =
539 "general-parameters-table is missing",
540 [SJA1105_MISSING_VLAN_TABLE] =
541 "vlan-lookup-table needs to have at least the default untagged VLAN",
542 [SJA1105_MISSING_XMII_TABLE] =
543 "xmii-table is missing",
544 [SJA1105_MISSING_MAC_TABLE] =
545 "mac-configuration-table needs to contain an entry for each port",
546 [SJA1105_OVERCOMMITTED_FRAME_MEMORY] =
547 "Not allowed to overcommit frame memory. L2 memory partitions "
548 "and VL memory partitions share the same space. The sum of all "
549 "16 memory partitions is not allowed to be larger than 929 "
550 "128-byte blocks (or 910 with retagging). Please adjust "
551 "l2-forwarding-parameters-table.part_spc and/or "
552 "vl-forwarding-parameters-table.partspc.",
553};
554
555static sja1105_config_valid_t
556static_config_check_memory_size(const struct sja1105_table *tables)
557{
558 const struct sja1105_l2_forwarding_params_entry *l2_fwd_params;
559 int i, mem = 0;
560
561 l2_fwd_params = tables[BLK_IDX_L2_FORWARDING_PARAMS].entries;
562
563 for (i = 0; i < 8; i++)
564 mem += l2_fwd_params->part_spc[i];
565
566 if (mem > SJA1105_MAX_FRAME_MEMORY)
567 return SJA1105_OVERCOMMITTED_FRAME_MEMORY;
568
569 return SJA1105_CONFIG_OK;
570}
571
572sja1105_config_valid_t
573sja1105_static_config_check_valid(const struct sja1105_static_config *config)
574{
575 const struct sja1105_table *tables = config->tables;
576#define IS_FULL(blk_idx) \
577 (tables[blk_idx].entry_count == tables[blk_idx].ops->max_entry_count)
578
579 if (tables[BLK_IDX_SCHEDULE].entry_count) {
580 if (config->device_id != SJA1105T_DEVICE_ID &&
581 config->device_id != SJA1105QS_DEVICE_ID)
582 return SJA1105_TTETHERNET_NOT_SUPPORTED;
583
584 if (tables[BLK_IDX_SCHEDULE_ENTRY_POINTS].entry_count == 0)
585 return SJA1105_INCORRECT_TTETHERNET_CONFIGURATION;
586
587 if (!IS_FULL(BLK_IDX_SCHEDULE_PARAMS))
588 return SJA1105_INCORRECT_TTETHERNET_CONFIGURATION;
589
590 if (!IS_FULL(BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS))
591 return SJA1105_INCORRECT_TTETHERNET_CONFIGURATION;
592 }
593
594 if (tables[BLK_IDX_L2_POLICING].entry_count == 0)
595 return SJA1105_MISSING_L2_POLICING_TABLE;
596
597 if (tables[BLK_IDX_VLAN_LOOKUP].entry_count == 0)
598 return SJA1105_MISSING_VLAN_TABLE;
599
600 if (!IS_FULL(BLK_IDX_L2_FORWARDING))
601 return SJA1105_MISSING_L2_FORWARDING_TABLE;
602
603 if (!IS_FULL(BLK_IDX_MAC_CONFIG))
604 return SJA1105_MISSING_MAC_TABLE;
605
606 if (!IS_FULL(BLK_IDX_L2_FORWARDING_PARAMS))
607 return SJA1105_MISSING_L2_FORWARDING_PARAMS_TABLE;
608
609 if (!IS_FULL(BLK_IDX_GENERAL_PARAMS))
610 return SJA1105_MISSING_GENERAL_PARAMS_TABLE;
611
612 if (!IS_FULL(BLK_IDX_XMII_PARAMS))
613 return SJA1105_MISSING_XMII_TABLE;
614
615 return static_config_check_memory_size(tables);
616#undef IS_FULL
617}
618
619void
620sja1105_static_config_pack(void *buf, struct sja1105_static_config *config)
621{
622 struct sja1105_table_header header = {0};
623 enum sja1105_blk_idx i;
624 char *p = buf;
625 int j;
626
627 sja1105_pack(p, &config->device_id, 31, 0, 4);
628 p += SJA1105_SIZE_DEVICE_ID;
629
630 for (i = 0; i < BLK_IDX_MAX; i++) {
631 const struct sja1105_table *table;
632 char *table_start;
633
634 table = &config->tables[i];
635 if (!table->entry_count)
636 continue;
637
638 header.block_id = blk_id_map[i];
639 header.len = table->entry_count *
640 table->ops->packed_entry_size / 4;
641 sja1105_table_header_pack_with_crc(p, &header);
642 p += SJA1105_SIZE_TABLE_HEADER;
643 table_start = p;
644 for (j = 0; j < table->entry_count; j++) {
645 u8 *entry_ptr = table->entries;
646
647 entry_ptr += j * table->ops->unpacked_entry_size;
648 memset(p, 0, table->ops->packed_entry_size);
649 table->ops->packing(p, entry_ptr, PACK);
650 p += table->ops->packed_entry_size;
651 }
652 sja1105_table_write_crc(table_start, p);
653 p += 4;
654 }
655 /* Final header:
656 * Block ID does not matter
657 * Length of 0 marks that header is final
658 * CRC will be replaced on-the-fly on "config upload"
659 */
660 header.block_id = 0;
661 header.len = 0;
662 header.crc = 0xDEADBEEF;
663 memset(p, 0, SJA1105_SIZE_TABLE_HEADER);
664 sja1105_table_header_packing(p, &header, PACK);
665}
666
667size_t
668sja1105_static_config_get_length(const struct sja1105_static_config *config)
669{
670 unsigned int sum;
671 unsigned int header_count;
672 enum sja1105_blk_idx i;
673
674 /* Ending header */
675 header_count = 1;
676 sum = SJA1105_SIZE_DEVICE_ID;
677
678 /* Tables (headers and entries) */
679 for (i = 0; i < BLK_IDX_MAX; i++) {
680 const struct sja1105_table *table;
681
682 table = &config->tables[i];
683 if (table->entry_count)
684 header_count++;
685
686 sum += table->ops->packed_entry_size * table->entry_count;
687 }
688 /* Headers have an additional CRC at the end */
689 sum += header_count * (SJA1105_SIZE_TABLE_HEADER + 4);
690 /* Last header does not have an extra CRC because there is no data */
691 sum -= 4;
692
693 return sum;
694}
695
696/* Compatibility matrices */
697
698/* SJA1105E: First generation, no TTEthernet */
699struct sja1105_table_ops sja1105e_table_ops[BLK_IDX_MAX] = {
700 [BLK_IDX_SCHEDULE] = {0},
701 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {0},
702 [BLK_IDX_L2_LOOKUP] = {
703 .packing = sja1105et_l2_lookup_entry_packing,
704 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
705 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY,
706 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
707 },
708 [BLK_IDX_L2_POLICING] = {
709 .packing = sja1105_l2_policing_entry_packing,
710 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
711 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
712 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
713 },
714 [BLK_IDX_VLAN_LOOKUP] = {
715 .packing = sja1105_vlan_lookup_entry_packing,
716 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
717 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
718 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
719 },
720 [BLK_IDX_L2_FORWARDING] = {
721 .packing = sja1105_l2_forwarding_entry_packing,
722 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
723 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
724 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
725 },
726 [BLK_IDX_MAC_CONFIG] = {
727 .packing = sja1105et_mac_config_entry_packing,
728 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
729 .packed_entry_size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY,
730 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
731 },
732 [BLK_IDX_SCHEDULE_PARAMS] = {0},
733 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {0},
734 [BLK_IDX_L2_LOOKUP_PARAMS] = {
735 .packing = sja1105et_l2_lookup_params_entry_packing,
736 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
737 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY,
738 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
739 },
740 [BLK_IDX_L2_FORWARDING_PARAMS] = {
741 .packing = sja1105_l2_forwarding_params_entry_packing,
742 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
743 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
744 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
745 },
746 [BLK_IDX_AVB_PARAMS] = {
747 .packing = sja1105et_avb_params_entry_packing,
748 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
749 .packed_entry_size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY,
750 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
751 },
752 [BLK_IDX_GENERAL_PARAMS] = {
753 .packing = sja1105et_general_params_entry_packing,
754 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
755 .packed_entry_size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY,
756 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
757 },
758 [BLK_IDX_XMII_PARAMS] = {
759 .packing = sja1105_xmii_params_entry_packing,
760 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
761 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
762 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
763 },
764};
765
766/* SJA1105T: First generation, TTEthernet */
767struct sja1105_table_ops sja1105t_table_ops[BLK_IDX_MAX] = {
768 [BLK_IDX_SCHEDULE] = {
769 .packing = sja1105_schedule_entry_packing,
770 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry),
771 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY,
772 .max_entry_count = SJA1105_MAX_SCHEDULE_COUNT,
773 },
774 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {
775 .packing = sja1105_schedule_entry_points_entry_packing,
776 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_entry),
777 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY,
778 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_COUNT,
779 },
780 [BLK_IDX_L2_LOOKUP] = {
781 .packing = sja1105et_l2_lookup_entry_packing,
782 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
783 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY,
784 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
785 },
786 [BLK_IDX_L2_POLICING] = {
787 .packing = sja1105_l2_policing_entry_packing,
788 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
789 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
790 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
791 },
792 [BLK_IDX_VLAN_LOOKUP] = {
793 .packing = sja1105_vlan_lookup_entry_packing,
794 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
795 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
796 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
797 },
798 [BLK_IDX_L2_FORWARDING] = {
799 .packing = sja1105_l2_forwarding_entry_packing,
800 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
801 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
802 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
803 },
804 [BLK_IDX_MAC_CONFIG] = {
805 .packing = sja1105et_mac_config_entry_packing,
806 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
807 .packed_entry_size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY,
808 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
809 },
810 [BLK_IDX_SCHEDULE_PARAMS] = {
811 .packing = sja1105_schedule_params_entry_packing,
812 .unpacked_entry_size = sizeof(struct sja1105_schedule_params_entry),
813 .packed_entry_size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY,
814 .max_entry_count = SJA1105_MAX_SCHEDULE_PARAMS_COUNT,
815 },
816 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {
817 .packing = sja1105_schedule_entry_points_params_entry_packing,
818 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_params_entry),
819 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY,
820 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_PARAMS_COUNT,
821 },
822 [BLK_IDX_L2_LOOKUP_PARAMS] = {
823 .packing = sja1105et_l2_lookup_params_entry_packing,
824 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
825 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY,
826 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
827 },
828 [BLK_IDX_L2_FORWARDING_PARAMS] = {
829 .packing = sja1105_l2_forwarding_params_entry_packing,
830 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
831 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
832 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
833 },
834 [BLK_IDX_AVB_PARAMS] = {
835 .packing = sja1105et_avb_params_entry_packing,
836 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
837 .packed_entry_size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY,
838 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
839 },
840 [BLK_IDX_GENERAL_PARAMS] = {
841 .packing = sja1105et_general_params_entry_packing,
842 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
843 .packed_entry_size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY,
844 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
845 },
846 [BLK_IDX_XMII_PARAMS] = {
847 .packing = sja1105_xmii_params_entry_packing,
848 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
849 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
850 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
851 },
852};
853
854/* SJA1105P: Second generation, no TTEthernet, no SGMII */
855struct sja1105_table_ops sja1105p_table_ops[BLK_IDX_MAX] = {
856 [BLK_IDX_SCHEDULE] = {0},
857 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {0},
858 [BLK_IDX_L2_LOOKUP] = {
859 .packing = sja1105pqrs_l2_lookup_entry_packing,
860 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
861 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
862 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
863 },
864 [BLK_IDX_L2_POLICING] = {
865 .packing = sja1105_l2_policing_entry_packing,
866 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
867 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
868 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
869 },
870 [BLK_IDX_VLAN_LOOKUP] = {
871 .packing = sja1105_vlan_lookup_entry_packing,
872 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
873 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
874 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
875 },
876 [BLK_IDX_L2_FORWARDING] = {
877 .packing = sja1105_l2_forwarding_entry_packing,
878 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
879 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
880 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
881 },
882 [BLK_IDX_MAC_CONFIG] = {
883 .packing = sja1105pqrs_mac_config_entry_packing,
884 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
885 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
886 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
887 },
888 [BLK_IDX_SCHEDULE_PARAMS] = {0},
889 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {0},
890 [BLK_IDX_L2_LOOKUP_PARAMS] = {
891 .packing = sja1105pqrs_l2_lookup_params_entry_packing,
892 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
893 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
894 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
895 },
896 [BLK_IDX_L2_FORWARDING_PARAMS] = {
897 .packing = sja1105_l2_forwarding_params_entry_packing,
898 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
899 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
900 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
901 },
902 [BLK_IDX_AVB_PARAMS] = {
903 .packing = sja1105pqrs_avb_params_entry_packing,
904 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
905 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
906 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
907 },
908 [BLK_IDX_GENERAL_PARAMS] = {
909 .packing = sja1105pqrs_general_params_entry_packing,
910 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
911 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
912 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
913 },
914 [BLK_IDX_XMII_PARAMS] = {
915 .packing = sja1105_xmii_params_entry_packing,
916 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
917 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
918 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
919 },
920};
921
922/* SJA1105Q: Second generation, TTEthernet, no SGMII */
923struct sja1105_table_ops sja1105q_table_ops[BLK_IDX_MAX] = {
924 [BLK_IDX_SCHEDULE] = {
925 .packing = sja1105_schedule_entry_packing,
926 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry),
927 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY,
928 .max_entry_count = SJA1105_MAX_SCHEDULE_COUNT,
929 },
930 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {
931 .packing = sja1105_schedule_entry_points_entry_packing,
932 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_entry),
933 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY,
934 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_COUNT,
935 },
936 [BLK_IDX_L2_LOOKUP] = {
937 .packing = sja1105pqrs_l2_lookup_entry_packing,
938 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
939 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
940 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
941 },
942 [BLK_IDX_L2_POLICING] = {
943 .packing = sja1105_l2_policing_entry_packing,
944 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
945 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
946 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
947 },
948 [BLK_IDX_VLAN_LOOKUP] = {
949 .packing = sja1105_vlan_lookup_entry_packing,
950 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
951 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
952 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
953 },
954 [BLK_IDX_L2_FORWARDING] = {
955 .packing = sja1105_l2_forwarding_entry_packing,
956 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
957 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
958 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
959 },
960 [BLK_IDX_MAC_CONFIG] = {
961 .packing = sja1105pqrs_mac_config_entry_packing,
962 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
963 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
964 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
965 },
966 [BLK_IDX_SCHEDULE_PARAMS] = {
967 .packing = sja1105_schedule_params_entry_packing,
968 .unpacked_entry_size = sizeof(struct sja1105_schedule_params_entry),
969 .packed_entry_size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY,
970 .max_entry_count = SJA1105_MAX_SCHEDULE_PARAMS_COUNT,
971 },
972 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {
973 .packing = sja1105_schedule_entry_points_params_entry_packing,
974 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_params_entry),
975 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY,
976 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_PARAMS_COUNT,
977 },
978 [BLK_IDX_L2_LOOKUP_PARAMS] = {
979 .packing = sja1105pqrs_l2_lookup_params_entry_packing,
980 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
981 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
982 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
983 },
984 [BLK_IDX_L2_FORWARDING_PARAMS] = {
985 .packing = sja1105_l2_forwarding_params_entry_packing,
986 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
987 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
988 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
989 },
990 [BLK_IDX_AVB_PARAMS] = {
991 .packing = sja1105pqrs_avb_params_entry_packing,
992 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
993 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
994 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
995 },
996 [BLK_IDX_GENERAL_PARAMS] = {
997 .packing = sja1105pqrs_general_params_entry_packing,
998 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
999 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
1000 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1001 },
1002 [BLK_IDX_XMII_PARAMS] = {
1003 .packing = sja1105_xmii_params_entry_packing,
1004 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1005 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1006 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1007 },
1008};
1009
1010/* SJA1105R: Second generation, no TTEthernet, SGMII */
1011struct sja1105_table_ops sja1105r_table_ops[BLK_IDX_MAX] = {
1012 [BLK_IDX_SCHEDULE] = {0},
1013 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {0},
1014 [BLK_IDX_L2_LOOKUP] = {
1015 .packing = sja1105pqrs_l2_lookup_entry_packing,
1016 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1017 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
1018 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1019 },
1020 [BLK_IDX_L2_POLICING] = {
1021 .packing = sja1105_l2_policing_entry_packing,
1022 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1023 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1024 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1025 },
1026 [BLK_IDX_VLAN_LOOKUP] = {
1027 .packing = sja1105_vlan_lookup_entry_packing,
1028 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1029 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1030 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1031 },
1032 [BLK_IDX_L2_FORWARDING] = {
1033 .packing = sja1105_l2_forwarding_entry_packing,
1034 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1035 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1036 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1037 },
1038 [BLK_IDX_MAC_CONFIG] = {
1039 .packing = sja1105pqrs_mac_config_entry_packing,
1040 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1041 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1042 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1043 },
1044 [BLK_IDX_SCHEDULE_PARAMS] = {0},
1045 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {0},
1046 [BLK_IDX_L2_LOOKUP_PARAMS] = {
1047 .packing = sja1105pqrs_l2_lookup_params_entry_packing,
1048 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1049 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1050 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1051 },
1052 [BLK_IDX_L2_FORWARDING_PARAMS] = {
1053 .packing = sja1105_l2_forwarding_params_entry_packing,
1054 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1055 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1056 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1057 },
1058 [BLK_IDX_AVB_PARAMS] = {
1059 .packing = sja1105pqrs_avb_params_entry_packing,
1060 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1061 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1062 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1063 },
1064 [BLK_IDX_GENERAL_PARAMS] = {
1065 .packing = sja1105pqrs_general_params_entry_packing,
1066 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1067 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
1068 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1069 },
1070 [BLK_IDX_XMII_PARAMS] = {
1071 .packing = sja1105_xmii_params_entry_packing,
1072 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1073 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1074 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1075 },
1076};
1077
1078/* SJA1105S: Second generation, TTEthernet, SGMII */
1079struct sja1105_table_ops sja1105s_table_ops[BLK_IDX_MAX] = {
1080 [BLK_IDX_SCHEDULE] = {
1081 .packing = sja1105_schedule_entry_packing,
1082 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry),
1083 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY,
1084 .max_entry_count = SJA1105_MAX_SCHEDULE_COUNT,
1085 },
1086 [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {
1087 .packing = sja1105_schedule_entry_points_entry_packing,
1088 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_entry),
1089 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY,
1090 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_COUNT,
1091 },
1092 [BLK_IDX_L2_LOOKUP] = {
1093 .packing = sja1105pqrs_l2_lookup_entry_packing,
1094 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1095 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
1096 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1097 },
1098 [BLK_IDX_L2_POLICING] = {
1099 .packing = sja1105_l2_policing_entry_packing,
1100 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1101 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1102 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1103 },
1104 [BLK_IDX_VLAN_LOOKUP] = {
1105 .packing = sja1105_vlan_lookup_entry_packing,
1106 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1107 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1108 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1109 },
1110 [BLK_IDX_L2_FORWARDING] = {
1111 .packing = sja1105_l2_forwarding_entry_packing,
1112 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1113 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1114 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1115 },
1116 [BLK_IDX_MAC_CONFIG] = {
1117 .packing = sja1105pqrs_mac_config_entry_packing,
1118 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1119 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1120 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1121 },
1122 [BLK_IDX_SCHEDULE_PARAMS] = {
1123 .packing = sja1105_schedule_params_entry_packing,
1124 .unpacked_entry_size = sizeof(struct sja1105_schedule_params_entry),
1125 .packed_entry_size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY,
1126 .max_entry_count = SJA1105_MAX_SCHEDULE_PARAMS_COUNT,
1127 },
1128 [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {
1129 .packing = sja1105_schedule_entry_points_params_entry_packing,
1130 .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_params_entry),
1131 .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY,
1132 .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_PARAMS_COUNT,
1133 },
1134 [BLK_IDX_L2_LOOKUP_PARAMS] = {
1135 .packing = sja1105pqrs_l2_lookup_params_entry_packing,
1136 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1137 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1138 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1139 },
1140 [BLK_IDX_L2_FORWARDING_PARAMS] = {
1141 .packing = sja1105_l2_forwarding_params_entry_packing,
1142 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1143 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1144 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1145 },
1146 [BLK_IDX_AVB_PARAMS] = {
1147 .packing = sja1105pqrs_avb_params_entry_packing,
1148 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1149 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1150 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1151 },
1152 [BLK_IDX_GENERAL_PARAMS] = {
1153 .packing = sja1105pqrs_general_params_entry_packing,
1154 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1155 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
1156 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1157 },
1158 [BLK_IDX_XMII_PARAMS] = {
1159 .packing = sja1105_xmii_params_entry_packing,
1160 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1161 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1162 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1163 },
1164};
1165
1166int sja1105_static_config_init(struct sja1105_static_config *config,
1167 const struct sja1105_table_ops *static_ops,
1168 u64 device_id)
1169{
1170 enum sja1105_blk_idx i;
1171
1172 *config = (struct sja1105_static_config) {0};
1173
1174 /* Transfer static_ops array from priv into per-table ops
1175 * for handier access
1176 */
1177 for (i = 0; i < BLK_IDX_MAX; i++)
1178 config->tables[i].ops = &static_ops[i];
1179
1180 config->device_id = device_id;
1181 return 0;
1182}
1183
1184void sja1105_static_config_free(struct sja1105_static_config *config)
1185{
1186 enum sja1105_blk_idx i;
1187
1188 for (i = 0; i < BLK_IDX_MAX; i++) {
1189 if (config->tables[i].entry_count) {
1190 kfree(config->tables[i].entries);
1191 config->tables[i].entry_count = 0;
1192 }
1193 }
1194}
1195
1196int sja1105_table_delete_entry(struct sja1105_table *table, int i)
1197{
1198 size_t entry_size = table->ops->unpacked_entry_size;
1199 u8 *entries = table->entries;
1200
1201 if (i > table->entry_count)
1202 return -ERANGE;
1203
1204 memmove(entries + i * entry_size, entries + (i + 1) * entry_size,
1205 (table->entry_count - i) * entry_size);
1206
1207 table->entry_count--;
1208
1209 return 0;
1210}
1211
1212/* No pointers to table->entries should be kept when this is called. */
1213int sja1105_table_resize(struct sja1105_table *table, size_t new_count)
1214{
1215 size_t entry_size = table->ops->unpacked_entry_size;
1216 void *new_entries, *old_entries = table->entries;
1217
1218 if (new_count > table->ops->max_entry_count)
1219 return -ERANGE;
1220
1221 new_entries = kcalloc(new_count, entry_size, GFP_KERNEL);
1222 if (!new_entries)
1223 return -ENOMEM;
1224
1225 memcpy(new_entries, old_entries, min(new_count, table->entry_count) *
1226 entry_size);
1227
1228 table->entries = new_entries;
1229 table->entry_count = new_count;
1230 kfree(old_entries);
1231 return 0;
1232}