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(pbuf: buf, uval: (u64 *)val, startbit: start, endbit: end, pbuflen: len, |
20 | op: 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(pbuf: (void *)buf, uval: val, startbit: start, endbit: end, pbuflen: len, |
42 | op: 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(pbuf: buf, uval: val, startbit: start, endbit: end, pbuflen: 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: buf + i, val: &word, start: 31, end: 0, len: 4); |
89 | crc = crc32_le(crc, p: (u8 *)&word, len: 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, val: &entry->destmeta, start: 95, end: 48, len: size, op); |
101 | sja1105_packing(buf, val: &entry->srcmeta, start: 47, end: 0, len: 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, val: &entry->cas_master, start: 126, end: 126, len: size, op); |
112 | sja1105_packing(buf, val: &entry->destmeta, start: 125, end: 78, len: size, op); |
113 | sja1105_packing(buf, val: &entry->srcmeta, start: 77, end: 30, len: 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, val: &entry->vllupformat, start: 319, end: 319, len: size, op); |
124 | sja1105_packing(buf, val: &entry->mirr_ptacu, start: 318, end: 318, len: size, op); |
125 | sja1105_packing(buf, val: &entry->switchid, start: 317, end: 315, len: size, op); |
126 | sja1105_packing(buf, val: &entry->hostprio, start: 314, end: 312, len: size, op); |
127 | sja1105_packing(buf, val: &entry->mac_fltres1, start: 311, end: 264, len: size, op); |
128 | sja1105_packing(buf, val: &entry->mac_fltres0, start: 263, end: 216, len: size, op); |
129 | sja1105_packing(buf, val: &entry->mac_flt1, start: 215, end: 168, len: size, op); |
130 | sja1105_packing(buf, val: &entry->mac_flt0, start: 167, end: 120, len: size, op); |
131 | sja1105_packing(buf, val: &entry->incl_srcpt1, start: 119, end: 119, len: size, op); |
132 | sja1105_packing(buf, val: &entry->incl_srcpt0, start: 118, end: 118, len: size, op); |
133 | sja1105_packing(buf, val: &entry->send_meta1, start: 117, end: 117, len: size, op); |
134 | sja1105_packing(buf, val: &entry->send_meta0, start: 116, end: 116, len: size, op); |
135 | sja1105_packing(buf, val: &entry->casc_port, start: 115, end: 113, len: size, op); |
136 | sja1105_packing(buf, val: &entry->host_port, start: 112, end: 110, len: size, op); |
137 | sja1105_packing(buf, val: &entry->mirr_port, start: 109, end: 107, len: size, op); |
138 | sja1105_packing(buf, val: &entry->vlmarker, start: 106, end: 75, len: size, op); |
139 | sja1105_packing(buf, val: &entry->vlmask, start: 74, end: 43, len: size, op); |
140 | sja1105_packing(buf, val: &entry->tpid, start: 42, end: 27, len: size, op); |
141 | sja1105_packing(buf, val: &entry->ignore2stf, start: 26, end: 26, len: size, op); |
142 | sja1105_packing(buf, val: &entry->tpid2, start: 25, end: 10, len: 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, val: &entry->vllupformat, start: 351, end: 351, len: size, op); |
156 | sja1105_packing(buf, val: &entry->mirr_ptacu, start: 350, end: 350, len: size, op); |
157 | sja1105_packing(buf, val: &entry->switchid, start: 349, end: 347, len: size, op); |
158 | sja1105_packing(buf, val: &entry->hostprio, start: 346, end: 344, len: size, op); |
159 | sja1105_packing(buf, val: &entry->mac_fltres1, start: 343, end: 296, len: size, op); |
160 | sja1105_packing(buf, val: &entry->mac_fltres0, start: 295, end: 248, len: size, op); |
161 | sja1105_packing(buf, val: &entry->mac_flt1, start: 247, end: 200, len: size, op); |
162 | sja1105_packing(buf, val: &entry->mac_flt0, start: 199, end: 152, len: size, op); |
163 | sja1105_packing(buf, val: &entry->incl_srcpt1, start: 151, end: 151, len: size, op); |
164 | sja1105_packing(buf, val: &entry->incl_srcpt0, start: 150, end: 150, len: size, op); |
165 | sja1105_packing(buf, val: &entry->send_meta1, start: 149, end: 149, len: size, op); |
166 | sja1105_packing(buf, val: &entry->send_meta0, start: 148, end: 148, len: size, op); |
167 | sja1105_packing(buf, val: &entry->casc_port, start: 147, end: 145, len: size, op); |
168 | sja1105_packing(buf, val: &entry->host_port, start: 144, end: 142, len: size, op); |
169 | sja1105_packing(buf, val: &entry->mirr_port, start: 141, end: 139, len: size, op); |
170 | sja1105_packing(buf, val: &entry->vlmarker, start: 138, end: 107, len: size, op); |
171 | sja1105_packing(buf, val: &entry->vlmask, start: 106, end: 75, len: size, op); |
172 | sja1105_packing(buf, val: &entry->tpid2, start: 74, end: 59, len: size, op); |
173 | sja1105_packing(buf, val: &entry->ignore2stf, start: 58, end: 58, len: size, op); |
174 | sja1105_packing(buf, val: &entry->tpid, start: 57, end: 42, len: size, op); |
175 | sja1105_packing(buf, val: &entry->queue_ts, start: 41, end: 41, len: size, op); |
176 | sja1105_packing(buf, val: &entry->egrmirrvid, start: 40, end: 29, len: size, op); |
177 | sja1105_packing(buf, val: &entry->egrmirrpcp, start: 28, end: 26, len: size, op); |
178 | sja1105_packing(buf, val: &entry->egrmirrdei, start: 25, end: 25, len: size, op); |
179 | sja1105_packing(buf, val: &entry->replay_port, start: 24, end: 22, len: 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, val: &entry->vllupformat, start: 447, end: 447, len: size, op); |
190 | sja1105_packing(buf, val: &entry->mirr_ptacu, start: 446, end: 446, len: size, op); |
191 | sja1105_packing(buf, val: &entry->switchid, start: 445, end: 442, len: size, op); |
192 | sja1105_packing(buf, val: &entry->hostprio, start: 441, end: 439, len: size, op); |
193 | sja1105_packing(buf, val: &entry->mac_fltres1, start: 438, end: 391, len: size, op); |
194 | sja1105_packing(buf, val: &entry->mac_fltres0, start: 390, end: 343, len: size, op); |
195 | sja1105_packing(buf, val: &entry->mac_flt1, start: 342, end: 295, len: size, op); |
196 | sja1105_packing(buf, val: &entry->mac_flt0, start: 294, end: 247, len: size, op); |
197 | sja1105_packing(buf, val: &entry->incl_srcpt1, start: 246, end: 246, len: size, op); |
198 | sja1105_packing(buf, val: &entry->incl_srcpt0, start: 245, end: 245, len: size, op); |
199 | sja1105_packing(buf, val: &entry->send_meta1, start: 244, end: 244, len: size, op); |
200 | sja1105_packing(buf, val: &entry->send_meta0, start: 243, end: 243, len: size, op); |
201 | sja1105_packing(buf, val: &entry->casc_port, start: 242, end: 232, len: size, op); |
202 | sja1105_packing(buf, val: &entry->host_port, start: 231, end: 228, len: size, op); |
203 | sja1105_packing(buf, val: &entry->mirr_port, start: 227, end: 224, len: size, op); |
204 | sja1105_packing(buf, val: &entry->vlmarker, start: 223, end: 192, len: size, op); |
205 | sja1105_packing(buf, val: &entry->vlmask, start: 191, end: 160, len: size, op); |
206 | sja1105_packing(buf, val: &entry->tpid2, start: 159, end: 144, len: size, op); |
207 | sja1105_packing(buf, val: &entry->ignore2stf, start: 143, end: 143, len: size, op); |
208 | sja1105_packing(buf, val: &entry->tpid, start: 142, end: 127, len: size, op); |
209 | sja1105_packing(buf, val: &entry->queue_ts, start: 126, end: 126, len: size, op); |
210 | sja1105_packing(buf, val: &entry->egrmirrvid, start: 125, end: 114, len: size, op); |
211 | sja1105_packing(buf, val: &entry->egrmirrpcp, start: 113, end: 111, len: size, op); |
212 | sja1105_packing(buf, val: &entry->egrmirrdei, start: 110, end: 110, len: size, op); |
213 | sja1105_packing(buf, val: &entry->replay_port, start: 109, end: 106, len: size, op); |
214 | sja1105_packing(buf, val: &entry->tdmaconfigidx, start: 70, end: 67, len: size, op); |
215 | sja1105_packing(buf, val: &entry->header_type, start: 64, end: 49, len: size, op); |
216 | sja1105_packing(buf, val: &entry->tte_en, start: 16, end: 16, len: 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, val: &entry->max_dynp, start: 95, end: 93, len: size, op); |
229 | for (i = 0, offset = 13; i < 8; i++, offset += 10) |
230 | sja1105_packing(buf, val: &entry->part_spc[i], |
231 | start: offset + 9, end: offset + 0, len: 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, val: &entry->max_dynp, start: 95, end: 93, len: size, op); |
243 | for (i = 0, offset = 5; i < 8; i++, offset += 11) |
244 | sja1105_packing(buf, val: &entry->part_spc[i], |
245 | start: offset + 10, end: offset + 0, len: 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, val: &entry->bc_domain, start: 63, end: 59, len: size, op); |
257 | sja1105_packing(buf, val: &entry->reach_port, start: 58, end: 54, len: size, op); |
258 | sja1105_packing(buf, val: &entry->fl_domain, start: 53, end: 49, len: size, op); |
259 | for (i = 0, offset = 25; i < 8; i++, offset += 3) |
260 | sja1105_packing(buf, val: &entry->vlan_pmap[i], |
261 | start: offset + 2, end: offset + 0, len: 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, val: &entry->vlan_pmap[i], |
276 | start: offset + 2, end: offset + 0, len: size, op); |
277 | } |
278 | } else { |
279 | sja1105_packing(buf, val: &entry->bc_domain, start: 63, end: 53, len: size, op); |
280 | sja1105_packing(buf, val: &entry->reach_port, start: 52, end: 42, len: size, op); |
281 | sja1105_packing(buf, val: &entry->fl_domain, start: 41, end: 31, len: 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, val: &entry->maxage, start: 31, end: 17, len: size, op); |
294 | sja1105_packing(buf, val: &entry->dyn_tbsz, start: 16, end: 14, len: size, op); |
295 | sja1105_packing(buf, val: &entry->poly, start: 13, end: 6, len: size, op); |
296 | sja1105_packing(buf, val: &entry->shared_learn, start: 5, end: 5, len: size, op); |
297 | sja1105_packing(buf, val: &entry->no_enf_hostprt, start: 4, end: 4, len: size, op); |
298 | sja1105_packing(buf, val: &entry->no_mgmt_learn, start: 3, end: 3, len: 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, val: &entry->maxaddrp[i], |
311 | start: offset + 10, end: offset + 0, len: size, op); |
312 | sja1105_packing(buf, val: &entry->maxage, start: 57, end: 43, len: size, op); |
313 | sja1105_packing(buf, val: &entry->start_dynspc, start: 42, end: 33, len: size, op); |
314 | sja1105_packing(buf, val: &entry->drpnolearn, start: 32, end: 28, len: size, op); |
315 | sja1105_packing(buf, val: &entry->shared_learn, start: 27, end: 27, len: size, op); |
316 | sja1105_packing(buf, val: &entry->no_enf_hostprt, start: 26, end: 26, len: size, op); |
317 | sja1105_packing(buf, val: &entry->no_mgmt_learn, start: 25, end: 25, len: size, op); |
318 | sja1105_packing(buf, val: &entry->use_static, start: 24, end: 24, len: size, op); |
319 | sja1105_packing(buf, val: &entry->owr_dyn, start: 23, end: 23, len: size, op); |
320 | sja1105_packing(buf, val: &entry->learn_once, start: 22, end: 22, len: 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, val: &entry->maxaddrp[i], |
333 | start: offset + 10, end: offset + 0, len: size, op); |
334 | sja1105_packing(buf, val: &entry->maxage, start: 69, end: 55, len: size, op); |
335 | sja1105_packing(buf, val: &entry->start_dynspc, start: 54, end: 45, len: size, op); |
336 | sja1105_packing(buf, val: &entry->drpnolearn, start: 44, end: 34, len: size, op); |
337 | sja1105_packing(buf, val: &entry->shared_learn, start: 33, end: 33, len: size, op); |
338 | sja1105_packing(buf, val: &entry->no_enf_hostprt, start: 32, end: 32, len: size, op); |
339 | sja1105_packing(buf, val: &entry->no_mgmt_learn, start: 31, end: 31, len: size, op); |
340 | sja1105_packing(buf, val: &entry->use_static, start: 30, end: 30, len: size, op); |
341 | sja1105_packing(buf, val: &entry->owr_dyn, start: 29, end: 29, len: size, op); |
342 | sja1105_packing(buf, val: &entry->learn_once, start: 28, end: 28, len: 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, val: &entry->vlanid, start: 95, end: 84, len: size, op); |
353 | sja1105_packing(buf, val: &entry->macaddr, start: 83, end: 36, len: size, op); |
354 | sja1105_packing(buf, val: &entry->destports, start: 35, end: 31, len: size, op); |
355 | sja1105_packing(buf, val: &entry->enfport, start: 30, end: 30, len: size, op); |
356 | sja1105_packing(buf, val: &entry->index, start: 29, end: 20, len: 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, val: &entry->tsreg, start: 159, end: 159, len: size, op); |
368 | sja1105_packing(buf, val: &entry->mirrvlan, start: 158, end: 147, len: size, op); |
369 | sja1105_packing(buf, val: &entry->takets, start: 146, end: 146, len: size, op); |
370 | sja1105_packing(buf, val: &entry->mirr, start: 145, end: 145, len: size, op); |
371 | sja1105_packing(buf, val: &entry->retag, start: 144, end: 144, len: size, op); |
372 | } else { |
373 | sja1105_packing(buf, val: &entry->touched, start: 159, end: 159, len: size, op); |
374 | sja1105_packing(buf, val: &entry->age, start: 158, end: 144, len: size, op); |
375 | } |
376 | sja1105_packing(buf, val: &entry->mask_iotag, start: 143, end: 143, len: size, op); |
377 | sja1105_packing(buf, val: &entry->mask_vlanid, start: 142, end: 131, len: size, op); |
378 | sja1105_packing(buf, val: &entry->mask_macaddr, start: 130, end: 83, len: size, op); |
379 | sja1105_packing(buf, val: &entry->iotag, start: 82, end: 82, len: size, op); |
380 | sja1105_packing(buf, val: &entry->vlanid, start: 81, end: 70, len: size, op); |
381 | sja1105_packing(buf, val: &entry->macaddr, start: 69, end: 22, len: size, op); |
382 | sja1105_packing(buf, val: &entry->destports, start: 21, end: 17, len: size, op); |
383 | sja1105_packing(buf, val: &entry->enfport, start: 16, end: 16, len: size, op); |
384 | sja1105_packing(buf, val: &entry->index, start: 15, end: 6, len: 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, val: &entry->trap, start: 168, end: 168, len: size, op); |
396 | sja1105_packing(buf, val: &entry->mirrvlan, start: 167, end: 156, len: size, op); |
397 | sja1105_packing(buf, val: &entry->takets, start: 155, end: 155, len: size, op); |
398 | sja1105_packing(buf, val: &entry->mirr, start: 154, end: 154, len: size, op); |
399 | sja1105_packing(buf, val: &entry->retag, start: 153, end: 153, len: size, op); |
400 | } else { |
401 | sja1105_packing(buf, val: &entry->touched, start: 168, end: 168, len: size, op); |
402 | sja1105_packing(buf, val: &entry->age, start: 167, end: 153, len: size, op); |
403 | } |
404 | sja1105_packing(buf, val: &entry->mask_iotag, start: 152, end: 152, len: size, op); |
405 | sja1105_packing(buf, val: &entry->mask_vlanid, start: 151, end: 140, len: size, op); |
406 | sja1105_packing(buf, val: &entry->mask_macaddr, start: 139, end: 92, len: size, op); |
407 | sja1105_packing(buf, val: &entry->mask_srcport, start: 91, end: 88, len: size, op); |
408 | sja1105_packing(buf, val: &entry->iotag, start: 87, end: 87, len: size, op); |
409 | sja1105_packing(buf, val: &entry->vlanid, start: 86, end: 75, len: size, op); |
410 | sja1105_packing(buf, val: &entry->macaddr, start: 74, end: 27, len: size, op); |
411 | sja1105_packing(buf, val: &entry->srcport, start: 26, end: 23, len: size, op); |
412 | sja1105_packing(buf, val: &entry->destports, start: 22, end: 12, len: size, op); |
413 | sja1105_packing(buf, val: &entry->enfport, start: 11, end: 11, len: size, op); |
414 | sja1105_packing(buf, val: &entry->index, start: 10, end: 1, len: 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, val: &entry->sharindx, start: 63, end: 58, len: size, op); |
425 | sja1105_packing(buf, val: &entry->smax, start: 57, end: 42, len: size, op); |
426 | sja1105_packing(buf, val: &entry->rate, start: 41, end: 26, len: size, op); |
427 | sja1105_packing(buf, val: &entry->maxlen, start: 25, end: 15, len: size, op); |
428 | sja1105_packing(buf, val: &entry->partition, start: 14, end: 12, len: 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, val: &entry->sharindx, start: 63, end: 57, len: size, op); |
439 | sja1105_packing(buf, val: &entry->smax, start: 56, end: 39, len: size, op); |
440 | sja1105_packing(buf, val: &entry->rate, start: 38, end: 21, len: size, op); |
441 | sja1105_packing(buf, val: &entry->maxlen, start: 20, end: 10, len: size, op); |
442 | sja1105_packing(buf, val: &entry->partition, start: 9, end: 7, len: 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, val: &entry->enabled[i], |
455 | start: offset + 0, end: offset + 0, len: size, op); |
456 | sja1105_packing(buf, val: &entry->base[i], |
457 | start: offset + 9, end: offset + 1, len: size, op); |
458 | sja1105_packing(buf, val: &entry->top[i], |
459 | start: offset + 18, end: offset + 10, len: size, op); |
460 | } |
461 | sja1105_packing(buf, val: &entry->ifg, start: 71, end: 67, len: size, op); |
462 | sja1105_packing(buf, val: &entry->speed, start: 66, end: 65, len: size, op); |
463 | sja1105_packing(buf, val: &entry->tp_delin, start: 64, end: 49, len: size, op); |
464 | sja1105_packing(buf, val: &entry->tp_delout, start: 48, end: 33, len: size, op); |
465 | sja1105_packing(buf, val: &entry->maxage, start: 32, end: 25, len: size, op); |
466 | sja1105_packing(buf, val: &entry->vlanprio, start: 24, end: 22, len: size, op); |
467 | sja1105_packing(buf, val: &entry->vlanid, start: 21, end: 10, len: size, op); |
468 | sja1105_packing(buf, val: &entry->ing_mirr, start: 9, end: 9, len: size, op); |
469 | sja1105_packing(buf, val: &entry->egr_mirr, start: 8, end: 8, len: size, op); |
470 | sja1105_packing(buf, val: &entry->drpnona664, start: 7, end: 7, len: size, op); |
471 | sja1105_packing(buf, val: &entry->drpdtag, start: 6, end: 6, len: size, op); |
472 | sja1105_packing(buf, val: &entry->drpuntag, start: 5, end: 5, len: size, op); |
473 | sja1105_packing(buf, val: &entry->retag, start: 4, end: 4, len: size, op); |
474 | sja1105_packing(buf, val: &entry->dyn_learn, start: 3, end: 3, len: size, op); |
475 | sja1105_packing(buf, val: &entry->egress, start: 2, end: 2, len: size, op); |
476 | sja1105_packing(buf, val: &entry->ingress, start: 1, end: 1, len: 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, val: &entry->enabled[i], |
489 | start: offset + 0, end: offset + 0, len: size, op); |
490 | sja1105_packing(buf, val: &entry->base[i], |
491 | start: offset + 9, end: offset + 1, len: size, op); |
492 | sja1105_packing(buf, val: &entry->top[i], |
493 | start: offset + 18, end: offset + 10, len: size, op); |
494 | } |
495 | sja1105_packing(buf, val: &entry->ifg, start: 103, end: 99, len: size, op); |
496 | sja1105_packing(buf, val: &entry->speed, start: 98, end: 97, len: size, op); |
497 | sja1105_packing(buf, val: &entry->tp_delin, start: 96, end: 81, len: size, op); |
498 | sja1105_packing(buf, val: &entry->tp_delout, start: 80, end: 65, len: size, op); |
499 | sja1105_packing(buf, val: &entry->maxage, start: 64, end: 57, len: size, op); |
500 | sja1105_packing(buf, val: &entry->vlanprio, start: 56, end: 54, len: size, op); |
501 | sja1105_packing(buf, val: &entry->vlanid, start: 53, end: 42, len: size, op); |
502 | sja1105_packing(buf, val: &entry->ing_mirr, start: 41, end: 41, len: size, op); |
503 | sja1105_packing(buf, val: &entry->egr_mirr, start: 40, end: 40, len: size, op); |
504 | sja1105_packing(buf, val: &entry->drpnona664, start: 39, end: 39, len: size, op); |
505 | sja1105_packing(buf, val: &entry->drpdtag, start: 38, end: 38, len: size, op); |
506 | sja1105_packing(buf, val: &entry->drpuntag, start: 35, end: 35, len: size, op); |
507 | sja1105_packing(buf, val: &entry->retag, start: 34, end: 34, len: size, op); |
508 | sja1105_packing(buf, val: &entry->dyn_learn, start: 33, end: 33, len: size, op); |
509 | sja1105_packing(buf, val: &entry->egress, start: 32, end: 32, len: size, op); |
510 | sja1105_packing(buf, val: &entry->ingress, start: 31, end: 31, len: 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, val: &entry->enabled[i], |
523 | start: offset + 0, end: offset + 0, len: size, op); |
524 | sja1105_packing(buf, val: &entry->base[i], |
525 | start: offset + 9, end: offset + 1, len: size, op); |
526 | sja1105_packing(buf, val: &entry->top[i], |
527 | start: offset + 18, end: offset + 10, len: size, op); |
528 | } |
529 | sja1105_packing(buf, val: &entry->speed, start: 98, end: 96, len: size, op); |
530 | sja1105_packing(buf, val: &entry->tp_delin, start: 95, end: 80, len: size, op); |
531 | sja1105_packing(buf, val: &entry->tp_delout, start: 79, end: 64, len: size, op); |
532 | sja1105_packing(buf, val: &entry->maxage, start: 63, end: 56, len: size, op); |
533 | sja1105_packing(buf, val: &entry->vlanprio, start: 55, end: 53, len: size, op); |
534 | sja1105_packing(buf, val: &entry->vlanid, start: 52, end: 41, len: size, op); |
535 | sja1105_packing(buf, val: &entry->ing_mirr, start: 40, end: 40, len: size, op); |
536 | sja1105_packing(buf, val: &entry->egr_mirr, start: 39, end: 39, len: size, op); |
537 | sja1105_packing(buf, val: &entry->drpnona664, start: 38, end: 38, len: size, op); |
538 | sja1105_packing(buf, val: &entry->drpdtag, start: 37, end: 37, len: size, op); |
539 | sja1105_packing(buf, val: &entry->drpuntag, start: 34, end: 34, len: size, op); |
540 | sja1105_packing(buf, val: &entry->retag, start: 33, end: 33, len: size, op); |
541 | sja1105_packing(buf, val: &entry->dyn_learn, start: 32, end: 32, len: size, op); |
542 | sja1105_packing(buf, val: &entry->egress, start: 31, end: 31, len: size, op); |
543 | sja1105_packing(buf, val: &entry->ingress, start: 30, end: 30, len: size, op); |
544 | sja1105_packing(buf, val: &entry->ifg, start: 10, end: 5, len: 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, val: &entry->clksrc, start: 31, end: 30, len: size, op); |
556 | sja1105_packing(buf, val: &entry->actsubsch, start: 29, end: 27, len: 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, val: &entry->subschindx, start: 31, end: 29, len: size, op); |
568 | sja1105_packing(buf, val: &entry->delta, start: 28, end: 11, len: size, op); |
569 | sja1105_packing(buf, val: &entry->address, start: 10, end: 1, len: 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, val: &entry->subschindx, start: 63, end: 61, len: size, op); |
581 | sja1105_packing(buf, val: &entry->delta, start: 60, end: 43, len: size, op); |
582 | sja1105_packing(buf, val: &entry->address, start: 42, end: 31, len: 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, val: &entry->subscheind[i], |
595 | start: offset + 9, end: offset + 0, len: 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, val: &entry->subscheind[i], |
608 | start: offset + 11, end: offset + 0, len: 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, val: &entry->winstindex, start: 63, end: 54, len: size, op); |
619 | sja1105_packing(buf, val: &entry->winend, start: 53, end: 53, len: size, op); |
620 | sja1105_packing(buf, val: &entry->winst, start: 52, end: 52, len: size, op); |
621 | sja1105_packing(buf, val: &entry->destports, start: 51, end: 47, len: size, op); |
622 | sja1105_packing(buf, val: &entry->setvalid, start: 46, end: 46, len: size, op); |
623 | sja1105_packing(buf, val: &entry->txen, start: 45, end: 45, len: size, op); |
624 | sja1105_packing(buf, val: &entry->resmedia_en, start: 44, end: 44, len: size, op); |
625 | sja1105_packing(buf, val: &entry->resmedia, start: 43, end: 36, len: size, op); |
626 | sja1105_packing(buf, val: &entry->vlindex, start: 35, end: 26, len: size, op); |
627 | sja1105_packing(buf, val: &entry->delta, start: 25, end: 8, len: 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, val: &entry->winstindex, start: 95, end: 84, len: size, op); |
638 | sja1105_packing(buf, val: &entry->winend, start: 83, end: 83, len: size, op); |
639 | sja1105_packing(buf, val: &entry->winst, start: 82, end: 82, len: size, op); |
640 | sja1105_packing(buf, val: &entry->destports, start: 81, end: 71, len: size, op); |
641 | sja1105_packing(buf, val: &entry->setvalid, start: 70, end: 70, len: size, op); |
642 | sja1105_packing(buf, val: &entry->txen, start: 69, end: 69, len: size, op); |
643 | sja1105_packing(buf, val: &entry->resmedia_en, start: 68, end: 68, len: size, op); |
644 | sja1105_packing(buf, val: &entry->resmedia, start: 67, end: 60, len: size, op); |
645 | sja1105_packing(buf, val: &entry->vlindex, start: 59, end: 48, len: size, op); |
646 | sja1105_packing(buf, val: &entry->delta, start: 47, end: 30, len: 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, val: &entry->partspc[i], |
660 | start: offset + 9, end: offset + 0, len: size, op); |
661 | sja1105_packing(buf, val: &entry->debugen, start: 15, end: 15, len: 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, val: &entry->partspc[i], |
675 | start: offset + 10, end: offset + 0, len: size, op); |
676 | sja1105_packing(buf, val: &entry->debugen, start: 7, end: 7, len: 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, val: &entry->type, start: 31, end: 31, len: size, op); |
687 | sja1105_packing(buf, val: &entry->priority, start: 30, end: 28, len: size, op); |
688 | sja1105_packing(buf, val: &entry->partition, start: 27, end: 25, len: size, op); |
689 | sja1105_packing(buf, val: &entry->destports, start: 24, end: 20, len: 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, val: &entry->type, start: 31, end: 31, len: size, op); |
700 | sja1105_packing(buf, val: &entry->priority, start: 30, end: 28, len: size, op); |
701 | sja1105_packing(buf, val: &entry->partition, start: 27, end: 25, len: size, op); |
702 | sja1105_packing(buf, val: &entry->destports, start: 24, end: 14, len: 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, val: &entry->destports, |
715 | start: 95, end: 91, len: size, op); |
716 | sja1105_packing(buf, val: &entry->iscritical, |
717 | start: 90, end: 90, len: size, op); |
718 | sja1105_packing(buf, val: &entry->macaddr, |
719 | start: 89, end: 42, len: size, op); |
720 | sja1105_packing(buf, val: &entry->vlanid, |
721 | start: 41, end: 30, len: size, op); |
722 | sja1105_packing(buf, val: &entry->port, |
723 | start: 29, end: 27, len: size, op); |
724 | sja1105_packing(buf, val: &entry->vlanprior, |
725 | start: 26, end: 24, len: size, op); |
726 | } else { |
727 | /* Interpreting vllupformat as 1 */ |
728 | sja1105_packing(buf, val: &entry->egrmirr, |
729 | start: 95, end: 91, len: size, op); |
730 | sja1105_packing(buf, val: &entry->ingrmirr, |
731 | start: 90, end: 90, len: size, op); |
732 | sja1105_packing(buf, val: &entry->vlid, |
733 | start: 57, end: 42, len: size, op); |
734 | sja1105_packing(buf, val: &entry->port, |
735 | start: 29, end: 27, len: 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, val: &entry->destports, |
749 | start: 94, end: 84, len: size, op); |
750 | sja1105_packing(buf, val: &entry->iscritical, |
751 | start: 83, end: 83, len: size, op); |
752 | sja1105_packing(buf, val: &entry->macaddr, |
753 | start: 82, end: 35, len: size, op); |
754 | sja1105_packing(buf, val: &entry->vlanid, |
755 | start: 34, end: 23, len: size, op); |
756 | sja1105_packing(buf, val: &entry->port, |
757 | start: 22, end: 19, len: size, op); |
758 | sja1105_packing(buf, val: &entry->vlanprior, |
759 | start: 18, end: 16, len: size, op); |
760 | } else { |
761 | /* Interpreting vllupformat as 1 */ |
762 | sja1105_packing(buf, val: &entry->egrmirr, |
763 | start: 94, end: 84, len: size, op); |
764 | sja1105_packing(buf, val: &entry->ingrmirr, |
765 | start: 83, end: 83, len: size, op); |
766 | sja1105_packing(buf, val: &entry->vlid, |
767 | start: 50, end: 35, len: size, op); |
768 | sja1105_packing(buf, val: &entry->port, |
769 | start: 22, end: 19, len: 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, val: &entry->type, start: 63, end: 63, len: size, op); |
781 | sja1105_packing(buf, val: &entry->maxlen, start: 62, end: 52, len: size, op); |
782 | sja1105_packing(buf, val: &entry->sharindx, start: 51, end: 42, len: size, op); |
783 | if (entry->type == 0) { |
784 | sja1105_packing(buf, val: &entry->bag, start: 41, end: 28, len: size, op); |
785 | sja1105_packing(buf, val: &entry->jitter, start: 27, end: 18, len: 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, val: &entry->type, start: 63, end: 63, len: size, op); |
797 | sja1105_packing(buf, val: &entry->maxlen, start: 62, end: 52, len: size, op); |
798 | sja1105_packing(buf, val: &entry->sharindx, start: 51, end: 40, len: size, op); |
799 | if (entry->type == 0) { |
800 | sja1105_packing(buf, val: &entry->bag, start: 41, end: 28, len: size, op); |
801 | sja1105_packing(buf, val: &entry->jitter, start: 27, end: 18, len: 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, val: &entry->ving_mirr, start: 63, end: 59, len: size, op); |
813 | sja1105_packing(buf, val: &entry->vegr_mirr, start: 58, end: 54, len: size, op); |
814 | sja1105_packing(buf, val: &entry->vmemb_port, start: 53, end: 49, len: size, op); |
815 | sja1105_packing(buf, val: &entry->vlan_bc, start: 48, end: 44, len: size, op); |
816 | sja1105_packing(buf, val: &entry->tag_port, start: 43, end: 39, len: size, op); |
817 | sja1105_packing(buf, val: &entry->vlanid, start: 38, end: 27, len: 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, val: &entry->ving_mirr, start: 95, end: 85, len: size, op); |
828 | sja1105_packing(buf, val: &entry->vegr_mirr, start: 84, end: 74, len: size, op); |
829 | sja1105_packing(buf, val: &entry->vmemb_port, start: 73, end: 63, len: size, op); |
830 | sja1105_packing(buf, val: &entry->vlan_bc, start: 62, end: 52, len: size, op); |
831 | sja1105_packing(buf, val: &entry->tag_port, start: 51, end: 41, len: size, op); |
832 | sja1105_packing(buf, val: &entry->type_entry, start: 40, end: 39, len: size, op); |
833 | sja1105_packing(buf, val: &entry->vlanid, start: 38, end: 27, len: 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, val: &entry->xmii_mode[i], |
846 | start: offset + 1, end: offset + 0, len: size, op); |
847 | sja1105_packing(buf, val: &entry->phy_mac[i], |
848 | start: offset + 2, end: offset + 2, len: 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, val: &entry->xmii_mode[i], |
862 | start: offset + 1, end: offset + 0, len: size, op); |
863 | sja1105_packing(buf, val: &entry->phy_mac[i], |
864 | start: offset + 2, end: offset + 2, len: size, op); |
865 | sja1105_packing(buf, val: &entry->special[i], |
866 | start: offset + 3, end: offset + 3, len: 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, val: &entry->egr_port, start: 63, end: 59, len: size, op); |
878 | sja1105_packing(buf, val: &entry->ing_port, start: 58, end: 54, len: size, op); |
879 | sja1105_packing(buf, val: &entry->vlan_ing, start: 53, end: 42, len: size, op); |
880 | sja1105_packing(buf, val: &entry->vlan_egr, start: 41, end: 30, len: size, op); |
881 | sja1105_packing(buf, val: &entry->do_not_learn, start: 29, end: 29, len: size, op); |
882 | sja1105_packing(buf, val: &entry->use_dest_ports, start: 28, end: 28, len: size, op); |
883 | sja1105_packing(buf, val: &entry->destports, start: 27, end: 23, len: 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, val: &entry->egr_port, start: 63, end: 53, len: size, op); |
894 | sja1105_packing(buf, val: &entry->ing_port, start: 52, end: 42, len: size, op); |
895 | sja1105_packing(buf, val: &entry->vlan_ing, start: 41, end: 30, len: size, op); |
896 | sja1105_packing(buf, val: &entry->vlan_egr, start: 29, end: 18, len: size, op); |
897 | sja1105_packing(buf, val: &entry->do_not_learn, start: 17, end: 17, len: size, op); |
898 | sja1105_packing(buf, val: &entry->use_dest_ports, start: 16, end: 16, len: size, op); |
899 | sja1105_packing(buf, val: &entry->destports, start: 15, end: 5, len: 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, val: &entry->egrpcp[i], |
912 | start: offset + 2, end: offset + 0, len: size, op); |
913 | |
914 | return size; |
915 | } |
916 | |
917 | size_t (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, val: &entry->block_id, start: 31, end: 24, len: size, op); |
924 | sja1105_packing(buf, val: &entry->len, start: 55, end: 32, len: size, op); |
925 | sja1105_packing(buf, val: &entry->crc, start: 95, end: 64, len: 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 | (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, entry_ptr: hdr, op: PACK); |
940 | hdr->crc = sja1105_crc32(buf, SJA1105_SIZE_TABLE_HEADER - 4); |
941 | sja1105_pack(buf: buf + SJA1105_SIZE_TABLE_HEADER - 4, val: &hdr->crc, start: 31, end: 0, len: 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(buf: table_start, len: len_bytes); |
951 | sja1105_pack(buf: crc_ptr, val: &computed_crc, start: 31, end: 0, len: 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 = {0}; |
1123 | enum sja1105_blk_idx i; |
1124 | char *p = buf; |
1125 | int j; |
1126 | |
1127 | sja1105_pack(buf: p, val: &config->device_id, start: 31, end: 0, len: 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(buf: p, hdr: &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, crc_ptr: 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(buf: p, entry_ptr: &header, op: 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 ; |
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(objp: 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(n: new_count, size: 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(objp: old_entries); |
1951 | return 0; |
1952 | } |
1953 | |