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  */
17 void 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 
39 void 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 
56 void 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 */
79 u32 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 
94 static 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 
105 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->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 
117 static 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  */
149 size_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 
183 size_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 
220 static size_t
221 sja1105_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 
235 size_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 
249 size_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 
265 size_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 
286 static size_t
287 sja1105et_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 
302 size_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 
324 size_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 
346 size_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 
360 size_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 
388 size_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 
418 static 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 
432 size_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 
446 static 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 
480 size_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 
514 size_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 
548 static size_t
549 sja1105_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 
560 static size_t
561 sja1105_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 
573 static size_t
574 sja1110_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 
586 static 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 
599 static 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 
612 static 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 
631 static 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 
650 static size_t
651 sja1105_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 
665 static size_t
666 sja1110_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 
680 static 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 
693 static 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 
706 size_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 
740 size_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 
774 static 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 
790 size_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 
806 size_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 
821 size_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 
837 static 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 
853 size_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 
871 size_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 
887 size_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 
903 static 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 
917 size_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  */
932 void
933 sja1105_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 
944 static 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  */
961 static 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 
984 const 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 
1019 static sja1105_config_valid_t
1020 static_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 
1046 sja1105_config_valid_t
1047 sja1105_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 
1119 void
1120 sja1105_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 
1167 size_t
1168 sja1105_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 */
1199 const 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 */
1269 const 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 */
1387 const 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 */
1457 const 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 */
1575 const 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 */
1645 const 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 */
1763 const 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 
1886 int 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 
1904 void 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 
1916 int 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. */
1933 int 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 }
1953