1 // SPDX-License-Identifier: BSD-3-Clause 2 /* Copyright (c) 2016-2018, NXP Semiconductors 3 * Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com> 4 */ 5 #include "sja1105_static_config.h" 6 #include <linux/crc32.h> 7 #include <linux/slab.h> 8 #include <linux/string.h> 9 #include <linux/errno.h> 10 11 /* Convenience wrappers over the generic packing functions. These take into 12 * account the SJA1105 memory layout quirks and provide some level of 13 * programmer protection against incorrect API use. The errors are not expected 14 * to occur durring runtime, therefore printing and swallowing them here is 15 * appropriate instead of clutterring up higher-level code. 16 */ 17 void sja1105_pack(void *buf, const u64 *val, int start, int end, size_t len) 18 { 19 int rc = packing(buf, (u64 *)val, start, end, len, 20 PACK, QUIRK_LSW32_IS_FIRST); 21 22 if (likely(!rc)) 23 return; 24 25 if (rc == -EINVAL) { 26 pr_err("Start bit (%d) expected to be larger than end (%d)\n", 27 start, end); 28 } else if (rc == -ERANGE) { 29 if ((start - end + 1) > 64) 30 pr_err("Field %d-%d too large for 64 bits!\n", 31 start, end); 32 else 33 pr_err("Cannot store %llx inside bits %d-%d (would truncate)\n", 34 *val, start, end); 35 } 36 dump_stack(); 37 } 38 EXPORT_SYMBOL_GPL(sja1105_pack); 39 40 void sja1105_unpack(const void *buf, u64 *val, int start, int end, size_t len) 41 { 42 int rc = packing((void *)buf, val, start, end, len, 43 UNPACK, QUIRK_LSW32_IS_FIRST); 44 45 if (likely(!rc)) 46 return; 47 48 if (rc == -EINVAL) 49 pr_err("Start bit (%d) expected to be larger than end (%d)\n", 50 start, end); 51 else if (rc == -ERANGE) 52 pr_err("Field %d-%d too large for 64 bits!\n", 53 start, end); 54 dump_stack(); 55 } 56 EXPORT_SYMBOL_GPL(sja1105_unpack); 57 58 void sja1105_packing(void *buf, u64 *val, int start, int end, 59 size_t len, enum packing_op op) 60 { 61 int rc = packing(buf, val, start, end, len, op, QUIRK_LSW32_IS_FIRST); 62 63 if (likely(!rc)) 64 return; 65 66 if (rc == -EINVAL) { 67 pr_err("Start bit (%d) expected to be larger than end (%d)\n", 68 start, end); 69 } else if (rc == -ERANGE) { 70 if ((start - end + 1) > 64) 71 pr_err("Field %d-%d too large for 64 bits!\n", 72 start, end); 73 else 74 pr_err("Cannot store %llx inside bits %d-%d (would truncate)\n", 75 *val, start, end); 76 } 77 dump_stack(); 78 } 79 EXPORT_SYMBOL_GPL(sja1105_packing); 80 81 /* Little-endian Ethernet CRC32 of data packed as big-endian u32 words */ 82 u32 sja1105_crc32(const void *buf, size_t len) 83 { 84 unsigned int i; 85 u64 word; 86 u32 crc; 87 88 /* seed */ 89 crc = ~0; 90 for (i = 0; i < len; i += 4) { 91 sja1105_unpack((void *)buf + i, &word, 31, 0, 4); 92 crc = crc32_le(crc, (u8 *)&word, 4); 93 } 94 return ~crc; 95 } 96 97 static size_t sja1105et_avb_params_entry_packing(void *buf, void *entry_ptr, 98 enum packing_op op) 99 { 100 const size_t size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY; 101 struct sja1105_avb_params_entry *entry = entry_ptr; 102 103 sja1105_packing(buf, &entry->destmeta, 95, 48, size, op); 104 sja1105_packing(buf, &entry->srcmeta, 47, 0, size, op); 105 return size; 106 } 107 108 static size_t sja1105pqrs_avb_params_entry_packing(void *buf, void *entry_ptr, 109 enum packing_op op) 110 { 111 const size_t size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY; 112 struct sja1105_avb_params_entry *entry = entry_ptr; 113 114 sja1105_packing(buf, &entry->destmeta, 125, 78, size, op); 115 sja1105_packing(buf, &entry->srcmeta, 77, 30, size, op); 116 return size; 117 } 118 119 static size_t sja1105et_general_params_entry_packing(void *buf, void *entry_ptr, 120 enum packing_op op) 121 { 122 const size_t size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY; 123 struct sja1105_general_params_entry *entry = entry_ptr; 124 125 sja1105_packing(buf, &entry->vllupformat, 319, 319, size, op); 126 sja1105_packing(buf, &entry->mirr_ptacu, 318, 318, size, op); 127 sja1105_packing(buf, &entry->switchid, 317, 315, size, op); 128 sja1105_packing(buf, &entry->hostprio, 314, 312, size, op); 129 sja1105_packing(buf, &entry->mac_fltres1, 311, 264, size, op); 130 sja1105_packing(buf, &entry->mac_fltres0, 263, 216, size, op); 131 sja1105_packing(buf, &entry->mac_flt1, 215, 168, size, op); 132 sja1105_packing(buf, &entry->mac_flt0, 167, 120, size, op); 133 sja1105_packing(buf, &entry->incl_srcpt1, 119, 119, size, op); 134 sja1105_packing(buf, &entry->incl_srcpt0, 118, 118, size, op); 135 sja1105_packing(buf, &entry->send_meta1, 117, 117, size, op); 136 sja1105_packing(buf, &entry->send_meta0, 116, 116, size, op); 137 sja1105_packing(buf, &entry->casc_port, 115, 113, size, op); 138 sja1105_packing(buf, &entry->host_port, 112, 110, size, op); 139 sja1105_packing(buf, &entry->mirr_port, 109, 107, size, op); 140 sja1105_packing(buf, &entry->vlmarker, 106, 75, size, op); 141 sja1105_packing(buf, &entry->vlmask, 74, 43, size, op); 142 sja1105_packing(buf, &entry->tpid, 42, 27, size, op); 143 sja1105_packing(buf, &entry->ignore2stf, 26, 26, size, op); 144 sja1105_packing(buf, &entry->tpid2, 25, 10, size, op); 145 return size; 146 } 147 148 static size_t 149 sja1105pqrs_general_params_entry_packing(void *buf, void *entry_ptr, 150 enum packing_op op) 151 { 152 const size_t size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY; 153 struct sja1105_general_params_entry *entry = entry_ptr; 154 155 sja1105_packing(buf, &entry->vllupformat, 351, 351, size, op); 156 sja1105_packing(buf, &entry->mirr_ptacu, 350, 350, size, op); 157 sja1105_packing(buf, &entry->switchid, 349, 347, size, op); 158 sja1105_packing(buf, &entry->hostprio, 346, 344, size, op); 159 sja1105_packing(buf, &entry->mac_fltres1, 343, 296, size, op); 160 sja1105_packing(buf, &entry->mac_fltres0, 295, 248, size, op); 161 sja1105_packing(buf, &entry->mac_flt1, 247, 200, size, op); 162 sja1105_packing(buf, &entry->mac_flt0, 199, 152, size, op); 163 sja1105_packing(buf, &entry->incl_srcpt1, 151, 151, size, op); 164 sja1105_packing(buf, &entry->incl_srcpt0, 150, 150, size, op); 165 sja1105_packing(buf, &entry->send_meta1, 149, 149, size, op); 166 sja1105_packing(buf, &entry->send_meta0, 148, 148, size, op); 167 sja1105_packing(buf, &entry->casc_port, 147, 145, size, op); 168 sja1105_packing(buf, &entry->host_port, 144, 142, size, op); 169 sja1105_packing(buf, &entry->mirr_port, 141, 139, size, op); 170 sja1105_packing(buf, &entry->vlmarker, 138, 107, size, op); 171 sja1105_packing(buf, &entry->vlmask, 106, 75, size, op); 172 sja1105_packing(buf, &entry->tpid, 74, 59, size, op); 173 sja1105_packing(buf, &entry->ignore2stf, 58, 58, size, op); 174 sja1105_packing(buf, &entry->tpid2, 57, 42, size, op); 175 sja1105_packing(buf, &entry->queue_ts, 41, 41, size, op); 176 sja1105_packing(buf, &entry->egrmirrvid, 40, 29, size, op); 177 sja1105_packing(buf, &entry->egrmirrpcp, 28, 26, size, op); 178 sja1105_packing(buf, &entry->egrmirrdei, 25, 25, size, op); 179 sja1105_packing(buf, &entry->replay_port, 24, 22, size, op); 180 return size; 181 } 182 183 static size_t 184 sja1105_l2_forwarding_params_entry_packing(void *buf, void *entry_ptr, 185 enum packing_op op) 186 { 187 const size_t size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY; 188 struct sja1105_l2_forwarding_params_entry *entry = entry_ptr; 189 int offset, i; 190 191 sja1105_packing(buf, &entry->max_dynp, 95, 93, size, op); 192 for (i = 0, offset = 13; i < 8; i++, offset += 10) 193 sja1105_packing(buf, &entry->part_spc[i], 194 offset + 9, offset + 0, size, op); 195 return size; 196 } 197 198 size_t sja1105_l2_forwarding_entry_packing(void *buf, void *entry_ptr, 199 enum packing_op op) 200 { 201 const size_t size = SJA1105_SIZE_L2_FORWARDING_ENTRY; 202 struct sja1105_l2_forwarding_entry *entry = entry_ptr; 203 int offset, i; 204 205 sja1105_packing(buf, &entry->bc_domain, 63, 59, size, op); 206 sja1105_packing(buf, &entry->reach_port, 58, 54, size, op); 207 sja1105_packing(buf, &entry->fl_domain, 53, 49, size, op); 208 for (i = 0, offset = 25; i < 8; i++, offset += 3) 209 sja1105_packing(buf, &entry->vlan_pmap[i], 210 offset + 2, offset + 0, size, op); 211 return size; 212 } 213 214 static size_t 215 sja1105et_l2_lookup_params_entry_packing(void *buf, void *entry_ptr, 216 enum packing_op op) 217 { 218 const size_t size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY; 219 struct sja1105_l2_lookup_params_entry *entry = entry_ptr; 220 221 sja1105_packing(buf, &entry->maxage, 31, 17, size, op); 222 sja1105_packing(buf, &entry->dyn_tbsz, 16, 14, size, op); 223 sja1105_packing(buf, &entry->poly, 13, 6, size, op); 224 sja1105_packing(buf, &entry->shared_learn, 5, 5, size, op); 225 sja1105_packing(buf, &entry->no_enf_hostprt, 4, 4, size, op); 226 sja1105_packing(buf, &entry->no_mgmt_learn, 3, 3, size, op); 227 return size; 228 } 229 230 static size_t 231 sja1105pqrs_l2_lookup_params_entry_packing(void *buf, void *entry_ptr, 232 enum packing_op op) 233 { 234 const size_t size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY; 235 struct sja1105_l2_lookup_params_entry *entry = entry_ptr; 236 237 sja1105_packing(buf, &entry->maxage, 57, 43, size, op); 238 sja1105_packing(buf, &entry->shared_learn, 27, 27, size, op); 239 sja1105_packing(buf, &entry->no_enf_hostprt, 26, 26, size, op); 240 sja1105_packing(buf, &entry->no_mgmt_learn, 25, 25, size, op); 241 return size; 242 } 243 244 size_t sja1105et_l2_lookup_entry_packing(void *buf, void *entry_ptr, 245 enum packing_op op) 246 { 247 const size_t size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY; 248 struct sja1105_l2_lookup_entry *entry = entry_ptr; 249 250 sja1105_packing(buf, &entry->vlanid, 95, 84, size, op); 251 sja1105_packing(buf, &entry->macaddr, 83, 36, size, op); 252 sja1105_packing(buf, &entry->destports, 35, 31, size, op); 253 sja1105_packing(buf, &entry->enfport, 30, 30, size, op); 254 sja1105_packing(buf, &entry->index, 29, 20, size, op); 255 return size; 256 } 257 258 size_t sja1105pqrs_l2_lookup_entry_packing(void *buf, void *entry_ptr, 259 enum packing_op op) 260 { 261 const size_t size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY; 262 struct sja1105_l2_lookup_entry *entry = entry_ptr; 263 264 if (entry->lockeds) { 265 sja1105_packing(buf, &entry->tsreg, 159, 159, size, op); 266 sja1105_packing(buf, &entry->mirrvlan, 158, 147, size, op); 267 sja1105_packing(buf, &entry->takets, 146, 146, size, op); 268 sja1105_packing(buf, &entry->mirr, 145, 145, size, op); 269 sja1105_packing(buf, &entry->retag, 144, 144, size, op); 270 } else { 271 sja1105_packing(buf, &entry->touched, 159, 159, size, op); 272 sja1105_packing(buf, &entry->age, 158, 144, size, op); 273 } 274 sja1105_packing(buf, &entry->mask_iotag, 143, 143, size, op); 275 sja1105_packing(buf, &entry->mask_vlanid, 142, 131, size, op); 276 sja1105_packing(buf, &entry->mask_macaddr, 130, 83, size, op); 277 sja1105_packing(buf, &entry->iotag, 82, 82, size, op); 278 sja1105_packing(buf, &entry->vlanid, 81, 70, size, op); 279 sja1105_packing(buf, &entry->macaddr, 69, 22, size, op); 280 sja1105_packing(buf, &entry->destports, 21, 17, size, op); 281 sja1105_packing(buf, &entry->enfport, 16, 16, size, op); 282 sja1105_packing(buf, &entry->index, 15, 6, size, op); 283 return size; 284 } 285 286 static size_t sja1105_l2_policing_entry_packing(void *buf, void *entry_ptr, 287 enum packing_op op) 288 { 289 const size_t size = SJA1105_SIZE_L2_POLICING_ENTRY; 290 struct sja1105_l2_policing_entry *entry = entry_ptr; 291 292 sja1105_packing(buf, &entry->sharindx, 63, 58, size, op); 293 sja1105_packing(buf, &entry->smax, 57, 42, size, op); 294 sja1105_packing(buf, &entry->rate, 41, 26, size, op); 295 sja1105_packing(buf, &entry->maxlen, 25, 15, size, op); 296 sja1105_packing(buf, &entry->partition, 14, 12, size, op); 297 return size; 298 } 299 300 static size_t sja1105et_mac_config_entry_packing(void *buf, void *entry_ptr, 301 enum packing_op op) 302 { 303 const size_t size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY; 304 struct sja1105_mac_config_entry *entry = entry_ptr; 305 int offset, i; 306 307 for (i = 0, offset = 72; i < 8; i++, offset += 19) { 308 sja1105_packing(buf, &entry->enabled[i], 309 offset + 0, offset + 0, size, op); 310 sja1105_packing(buf, &entry->base[i], 311 offset + 9, offset + 1, size, op); 312 sja1105_packing(buf, &entry->top[i], 313 offset + 18, offset + 10, size, op); 314 } 315 sja1105_packing(buf, &entry->ifg, 71, 67, size, op); 316 sja1105_packing(buf, &entry->speed, 66, 65, size, op); 317 sja1105_packing(buf, &entry->tp_delin, 64, 49, size, op); 318 sja1105_packing(buf, &entry->tp_delout, 48, 33, size, op); 319 sja1105_packing(buf, &entry->maxage, 32, 25, size, op); 320 sja1105_packing(buf, &entry->vlanprio, 24, 22, size, op); 321 sja1105_packing(buf, &entry->vlanid, 21, 10, size, op); 322 sja1105_packing(buf, &entry->ing_mirr, 9, 9, size, op); 323 sja1105_packing(buf, &entry->egr_mirr, 8, 8, size, op); 324 sja1105_packing(buf, &entry->drpnona664, 7, 7, size, op); 325 sja1105_packing(buf, &entry->drpdtag, 6, 6, size, op); 326 sja1105_packing(buf, &entry->drpuntag, 5, 5, size, op); 327 sja1105_packing(buf, &entry->retag, 4, 4, size, op); 328 sja1105_packing(buf, &entry->dyn_learn, 3, 3, size, op); 329 sja1105_packing(buf, &entry->egress, 2, 2, size, op); 330 sja1105_packing(buf, &entry->ingress, 1, 1, size, op); 331 return size; 332 } 333 334 size_t sja1105pqrs_mac_config_entry_packing(void *buf, void *entry_ptr, 335 enum packing_op op) 336 { 337 const size_t size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY; 338 struct sja1105_mac_config_entry *entry = entry_ptr; 339 int offset, i; 340 341 for (i = 0, offset = 104; i < 8; i++, offset += 19) { 342 sja1105_packing(buf, &entry->enabled[i], 343 offset + 0, offset + 0, size, op); 344 sja1105_packing(buf, &entry->base[i], 345 offset + 9, offset + 1, size, op); 346 sja1105_packing(buf, &entry->top[i], 347 offset + 18, offset + 10, size, op); 348 } 349 sja1105_packing(buf, &entry->ifg, 103, 99, size, op); 350 sja1105_packing(buf, &entry->speed, 98, 97, size, op); 351 sja1105_packing(buf, &entry->tp_delin, 96, 81, size, op); 352 sja1105_packing(buf, &entry->tp_delout, 80, 65, size, op); 353 sja1105_packing(buf, &entry->maxage, 64, 57, size, op); 354 sja1105_packing(buf, &entry->vlanprio, 56, 54, size, op); 355 sja1105_packing(buf, &entry->vlanid, 53, 42, size, op); 356 sja1105_packing(buf, &entry->ing_mirr, 41, 41, size, op); 357 sja1105_packing(buf, &entry->egr_mirr, 40, 40, size, op); 358 sja1105_packing(buf, &entry->drpnona664, 39, 39, size, op); 359 sja1105_packing(buf, &entry->drpdtag, 38, 38, size, op); 360 sja1105_packing(buf, &entry->drpuntag, 35, 35, size, op); 361 sja1105_packing(buf, &entry->retag, 34, 34, size, op); 362 sja1105_packing(buf, &entry->dyn_learn, 33, 33, size, op); 363 sja1105_packing(buf, &entry->egress, 32, 32, size, op); 364 sja1105_packing(buf, &entry->ingress, 31, 31, size, op); 365 return size; 366 } 367 368 size_t sja1105_vlan_lookup_entry_packing(void *buf, void *entry_ptr, 369 enum packing_op op) 370 { 371 const size_t size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY; 372 struct sja1105_vlan_lookup_entry *entry = entry_ptr; 373 374 sja1105_packing(buf, &entry->ving_mirr, 63, 59, size, op); 375 sja1105_packing(buf, &entry->vegr_mirr, 58, 54, size, op); 376 sja1105_packing(buf, &entry->vmemb_port, 53, 49, size, op); 377 sja1105_packing(buf, &entry->vlan_bc, 48, 44, size, op); 378 sja1105_packing(buf, &entry->tag_port, 43, 39, size, op); 379 sja1105_packing(buf, &entry->vlanid, 38, 27, size, op); 380 return size; 381 } 382 383 static size_t sja1105_xmii_params_entry_packing(void *buf, void *entry_ptr, 384 enum packing_op op) 385 { 386 const size_t size = SJA1105_SIZE_XMII_PARAMS_ENTRY; 387 struct sja1105_xmii_params_entry *entry = entry_ptr; 388 int offset, i; 389 390 for (i = 0, offset = 17; i < 5; i++, offset += 3) { 391 sja1105_packing(buf, &entry->xmii_mode[i], 392 offset + 1, offset + 0, size, op); 393 sja1105_packing(buf, &entry->phy_mac[i], 394 offset + 2, offset + 2, size, op); 395 } 396 return size; 397 } 398 399 size_t sja1105_table_header_packing(void *buf, void *entry_ptr, 400 enum packing_op op) 401 { 402 const size_t size = SJA1105_SIZE_TABLE_HEADER; 403 struct sja1105_table_header *entry = entry_ptr; 404 405 sja1105_packing(buf, &entry->block_id, 31, 24, size, op); 406 sja1105_packing(buf, &entry->len, 55, 32, size, op); 407 sja1105_packing(buf, &entry->crc, 95, 64, size, op); 408 return size; 409 } 410 411 /* WARNING: the *hdr pointer is really non-const, because it is 412 * modifying the CRC of the header for a 2-stage packing operation 413 */ 414 void 415 sja1105_table_header_pack_with_crc(void *buf, struct sja1105_table_header *hdr) 416 { 417 /* First pack the table as-is, then calculate the CRC, and 418 * finally put the proper CRC into the packed buffer 419 */ 420 memset(buf, 0, SJA1105_SIZE_TABLE_HEADER); 421 sja1105_table_header_packing(buf, hdr, PACK); 422 hdr->crc = sja1105_crc32(buf, SJA1105_SIZE_TABLE_HEADER - 4); 423 sja1105_pack(buf + SJA1105_SIZE_TABLE_HEADER - 4, &hdr->crc, 31, 0, 4); 424 } 425 426 static void sja1105_table_write_crc(u8 *table_start, u8 *crc_ptr) 427 { 428 u64 computed_crc; 429 int len_bytes; 430 431 len_bytes = (uintptr_t)(crc_ptr - table_start); 432 computed_crc = sja1105_crc32(table_start, len_bytes); 433 sja1105_pack(crc_ptr, &computed_crc, 31, 0, 4); 434 } 435 436 /* The block IDs that the switches support are unfortunately sparse, so keep a 437 * mapping table to "block indices" and translate back and forth so that we 438 * don't waste useless memory in struct sja1105_static_config. 439 * Also, since the block id comes from essentially untrusted input (unpacking 440 * the static config from userspace) it has to be sanitized (range-checked) 441 * before blindly indexing kernel memory with the blk_idx. 442 */ 443 static u64 blk_id_map[BLK_IDX_MAX] = { 444 [BLK_IDX_L2_LOOKUP] = BLKID_L2_LOOKUP, 445 [BLK_IDX_L2_POLICING] = BLKID_L2_POLICING, 446 [BLK_IDX_VLAN_LOOKUP] = BLKID_VLAN_LOOKUP, 447 [BLK_IDX_L2_FORWARDING] = BLKID_L2_FORWARDING, 448 [BLK_IDX_MAC_CONFIG] = BLKID_MAC_CONFIG, 449 [BLK_IDX_L2_LOOKUP_PARAMS] = BLKID_L2_LOOKUP_PARAMS, 450 [BLK_IDX_L2_FORWARDING_PARAMS] = BLKID_L2_FORWARDING_PARAMS, 451 [BLK_IDX_AVB_PARAMS] = BLKID_AVB_PARAMS, 452 [BLK_IDX_GENERAL_PARAMS] = BLKID_GENERAL_PARAMS, 453 [BLK_IDX_XMII_PARAMS] = BLKID_XMII_PARAMS, 454 }; 455 456 const char *sja1105_static_config_error_msg[] = { 457 [SJA1105_CONFIG_OK] = "", 458 [SJA1105_MISSING_L2_POLICING_TABLE] = 459 "l2-policing-table needs to have at least one entry", 460 [SJA1105_MISSING_L2_FORWARDING_TABLE] = 461 "l2-forwarding-table is either missing or incomplete", 462 [SJA1105_MISSING_L2_FORWARDING_PARAMS_TABLE] = 463 "l2-forwarding-parameters-table is missing", 464 [SJA1105_MISSING_GENERAL_PARAMS_TABLE] = 465 "general-parameters-table is missing", 466 [SJA1105_MISSING_VLAN_TABLE] = 467 "vlan-lookup-table needs to have at least the default untagged VLAN", 468 [SJA1105_MISSING_XMII_TABLE] = 469 "xmii-table is missing", 470 [SJA1105_MISSING_MAC_TABLE] = 471 "mac-configuration-table needs to contain an entry for each port", 472 [SJA1105_OVERCOMMITTED_FRAME_MEMORY] = 473 "Not allowed to overcommit frame memory. L2 memory partitions " 474 "and VL memory partitions share the same space. The sum of all " 475 "16 memory partitions is not allowed to be larger than 929 " 476 "128-byte blocks (or 910 with retagging). Please adjust " 477 "l2-forwarding-parameters-table.part_spc and/or " 478 "vl-forwarding-parameters-table.partspc.", 479 }; 480 481 static sja1105_config_valid_t 482 static_config_check_memory_size(const struct sja1105_table *tables) 483 { 484 const struct sja1105_l2_forwarding_params_entry *l2_fwd_params; 485 int i, mem = 0; 486 487 l2_fwd_params = tables[BLK_IDX_L2_FORWARDING_PARAMS].entries; 488 489 for (i = 0; i < 8; i++) 490 mem += l2_fwd_params->part_spc[i]; 491 492 if (mem > SJA1105_MAX_FRAME_MEMORY) 493 return SJA1105_OVERCOMMITTED_FRAME_MEMORY; 494 495 return SJA1105_CONFIG_OK; 496 } 497 498 sja1105_config_valid_t 499 sja1105_static_config_check_valid(const struct sja1105_static_config *config) 500 { 501 const struct sja1105_table *tables = config->tables; 502 #define IS_FULL(blk_idx) \ 503 (tables[blk_idx].entry_count == tables[blk_idx].ops->max_entry_count) 504 505 if (tables[BLK_IDX_L2_POLICING].entry_count == 0) 506 return SJA1105_MISSING_L2_POLICING_TABLE; 507 508 if (tables[BLK_IDX_VLAN_LOOKUP].entry_count == 0) 509 return SJA1105_MISSING_VLAN_TABLE; 510 511 if (!IS_FULL(BLK_IDX_L2_FORWARDING)) 512 return SJA1105_MISSING_L2_FORWARDING_TABLE; 513 514 if (!IS_FULL(BLK_IDX_MAC_CONFIG)) 515 return SJA1105_MISSING_MAC_TABLE; 516 517 if (!IS_FULL(BLK_IDX_L2_FORWARDING_PARAMS)) 518 return SJA1105_MISSING_L2_FORWARDING_PARAMS_TABLE; 519 520 if (!IS_FULL(BLK_IDX_GENERAL_PARAMS)) 521 return SJA1105_MISSING_GENERAL_PARAMS_TABLE; 522 523 if (!IS_FULL(BLK_IDX_XMII_PARAMS)) 524 return SJA1105_MISSING_XMII_TABLE; 525 526 return static_config_check_memory_size(tables); 527 #undef IS_FULL 528 } 529 530 void 531 sja1105_static_config_pack(void *buf, struct sja1105_static_config *config) 532 { 533 struct sja1105_table_header header = {0}; 534 enum sja1105_blk_idx i; 535 char *p = buf; 536 int j; 537 538 sja1105_pack(p, &config->device_id, 31, 0, 4); 539 p += SJA1105_SIZE_DEVICE_ID; 540 541 for (i = 0; i < BLK_IDX_MAX; i++) { 542 const struct sja1105_table *table; 543 char *table_start; 544 545 table = &config->tables[i]; 546 if (!table->entry_count) 547 continue; 548 549 header.block_id = blk_id_map[i]; 550 header.len = table->entry_count * 551 table->ops->packed_entry_size / 4; 552 sja1105_table_header_pack_with_crc(p, &header); 553 p += SJA1105_SIZE_TABLE_HEADER; 554 table_start = p; 555 for (j = 0; j < table->entry_count; j++) { 556 u8 *entry_ptr = table->entries; 557 558 entry_ptr += j * table->ops->unpacked_entry_size; 559 memset(p, 0, table->ops->packed_entry_size); 560 table->ops->packing(p, entry_ptr, PACK); 561 p += table->ops->packed_entry_size; 562 } 563 sja1105_table_write_crc(table_start, p); 564 p += 4; 565 } 566 /* Final header: 567 * Block ID does not matter 568 * Length of 0 marks that header is final 569 * CRC will be replaced on-the-fly on "config upload" 570 */ 571 header.block_id = 0; 572 header.len = 0; 573 header.crc = 0xDEADBEEF; 574 memset(p, 0, SJA1105_SIZE_TABLE_HEADER); 575 sja1105_table_header_packing(p, &header, PACK); 576 } 577 578 size_t 579 sja1105_static_config_get_length(const struct sja1105_static_config *config) 580 { 581 unsigned int sum; 582 unsigned int header_count; 583 enum sja1105_blk_idx i; 584 585 /* Ending header */ 586 header_count = 1; 587 sum = SJA1105_SIZE_DEVICE_ID; 588 589 /* Tables (headers and entries) */ 590 for (i = 0; i < BLK_IDX_MAX; i++) { 591 const struct sja1105_table *table; 592 593 table = &config->tables[i]; 594 if (table->entry_count) 595 header_count++; 596 597 sum += table->ops->packed_entry_size * table->entry_count; 598 } 599 /* Headers have an additional CRC at the end */ 600 sum += header_count * (SJA1105_SIZE_TABLE_HEADER + 4); 601 /* Last header does not have an extra CRC because there is no data */ 602 sum -= 4; 603 604 return sum; 605 } 606 607 /* Compatibility matrices */ 608 609 /* SJA1105E: First generation, no TTEthernet */ 610 struct sja1105_table_ops sja1105e_table_ops[BLK_IDX_MAX] = { 611 [BLK_IDX_L2_LOOKUP] = { 612 .packing = sja1105et_l2_lookup_entry_packing, 613 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry), 614 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY, 615 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT, 616 }, 617 [BLK_IDX_L2_POLICING] = { 618 .packing = sja1105_l2_policing_entry_packing, 619 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry), 620 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY, 621 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT, 622 }, 623 [BLK_IDX_VLAN_LOOKUP] = { 624 .packing = sja1105_vlan_lookup_entry_packing, 625 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry), 626 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY, 627 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT, 628 }, 629 [BLK_IDX_L2_FORWARDING] = { 630 .packing = sja1105_l2_forwarding_entry_packing, 631 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry), 632 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY, 633 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT, 634 }, 635 [BLK_IDX_MAC_CONFIG] = { 636 .packing = sja1105et_mac_config_entry_packing, 637 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry), 638 .packed_entry_size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY, 639 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT, 640 }, 641 [BLK_IDX_L2_LOOKUP_PARAMS] = { 642 .packing = sja1105et_l2_lookup_params_entry_packing, 643 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry), 644 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY, 645 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT, 646 }, 647 [BLK_IDX_L2_FORWARDING_PARAMS] = { 648 .packing = sja1105_l2_forwarding_params_entry_packing, 649 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry), 650 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY, 651 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT, 652 }, 653 [BLK_IDX_AVB_PARAMS] = { 654 .packing = sja1105et_avb_params_entry_packing, 655 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry), 656 .packed_entry_size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY, 657 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT, 658 }, 659 [BLK_IDX_GENERAL_PARAMS] = { 660 .packing = sja1105et_general_params_entry_packing, 661 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry), 662 .packed_entry_size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY, 663 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT, 664 }, 665 [BLK_IDX_XMII_PARAMS] = { 666 .packing = sja1105_xmii_params_entry_packing, 667 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry), 668 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY, 669 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT, 670 }, 671 }; 672 673 /* SJA1105T: First generation, TTEthernet */ 674 struct sja1105_table_ops sja1105t_table_ops[BLK_IDX_MAX] = { 675 [BLK_IDX_L2_LOOKUP] = { 676 .packing = sja1105et_l2_lookup_entry_packing, 677 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry), 678 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY, 679 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT, 680 }, 681 [BLK_IDX_L2_POLICING] = { 682 .packing = sja1105_l2_policing_entry_packing, 683 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry), 684 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY, 685 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT, 686 }, 687 [BLK_IDX_VLAN_LOOKUP] = { 688 .packing = sja1105_vlan_lookup_entry_packing, 689 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry), 690 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY, 691 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT, 692 }, 693 [BLK_IDX_L2_FORWARDING] = { 694 .packing = sja1105_l2_forwarding_entry_packing, 695 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry), 696 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY, 697 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT, 698 }, 699 [BLK_IDX_MAC_CONFIG] = { 700 .packing = sja1105et_mac_config_entry_packing, 701 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry), 702 .packed_entry_size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY, 703 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT, 704 }, 705 [BLK_IDX_L2_LOOKUP_PARAMS] = { 706 .packing = sja1105et_l2_lookup_params_entry_packing, 707 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry), 708 .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY, 709 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT, 710 }, 711 [BLK_IDX_L2_FORWARDING_PARAMS] = { 712 .packing = sja1105_l2_forwarding_params_entry_packing, 713 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry), 714 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY, 715 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT, 716 }, 717 [BLK_IDX_AVB_PARAMS] = { 718 .packing = sja1105et_avb_params_entry_packing, 719 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry), 720 .packed_entry_size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY, 721 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT, 722 }, 723 [BLK_IDX_GENERAL_PARAMS] = { 724 .packing = sja1105et_general_params_entry_packing, 725 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry), 726 .packed_entry_size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY, 727 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT, 728 }, 729 [BLK_IDX_XMII_PARAMS] = { 730 .packing = sja1105_xmii_params_entry_packing, 731 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry), 732 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY, 733 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT, 734 }, 735 }; 736 737 /* SJA1105P: Second generation, no TTEthernet, no SGMII */ 738 struct sja1105_table_ops sja1105p_table_ops[BLK_IDX_MAX] = { 739 [BLK_IDX_L2_LOOKUP] = { 740 .packing = sja1105pqrs_l2_lookup_entry_packing, 741 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry), 742 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY, 743 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT, 744 }, 745 [BLK_IDX_L2_POLICING] = { 746 .packing = sja1105_l2_policing_entry_packing, 747 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry), 748 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY, 749 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT, 750 }, 751 [BLK_IDX_VLAN_LOOKUP] = { 752 .packing = sja1105_vlan_lookup_entry_packing, 753 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry), 754 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY, 755 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT, 756 }, 757 [BLK_IDX_L2_FORWARDING] = { 758 .packing = sja1105_l2_forwarding_entry_packing, 759 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry), 760 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY, 761 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT, 762 }, 763 [BLK_IDX_MAC_CONFIG] = { 764 .packing = sja1105pqrs_mac_config_entry_packing, 765 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry), 766 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY, 767 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT, 768 }, 769 [BLK_IDX_L2_LOOKUP_PARAMS] = { 770 .packing = sja1105pqrs_l2_lookup_params_entry_packing, 771 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry), 772 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY, 773 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT, 774 }, 775 [BLK_IDX_L2_FORWARDING_PARAMS] = { 776 .packing = sja1105_l2_forwarding_params_entry_packing, 777 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry), 778 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY, 779 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT, 780 }, 781 [BLK_IDX_AVB_PARAMS] = { 782 .packing = sja1105pqrs_avb_params_entry_packing, 783 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry), 784 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY, 785 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT, 786 }, 787 [BLK_IDX_GENERAL_PARAMS] = { 788 .packing = sja1105pqrs_general_params_entry_packing, 789 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry), 790 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY, 791 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT, 792 }, 793 [BLK_IDX_XMII_PARAMS] = { 794 .packing = sja1105_xmii_params_entry_packing, 795 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry), 796 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY, 797 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT, 798 }, 799 }; 800 801 /* SJA1105Q: Second generation, TTEthernet, no SGMII */ 802 struct sja1105_table_ops sja1105q_table_ops[BLK_IDX_MAX] = { 803 [BLK_IDX_L2_LOOKUP] = { 804 .packing = sja1105pqrs_l2_lookup_entry_packing, 805 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry), 806 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY, 807 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT, 808 }, 809 [BLK_IDX_L2_POLICING] = { 810 .packing = sja1105_l2_policing_entry_packing, 811 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry), 812 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY, 813 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT, 814 }, 815 [BLK_IDX_VLAN_LOOKUP] = { 816 .packing = sja1105_vlan_lookup_entry_packing, 817 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry), 818 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY, 819 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT, 820 }, 821 [BLK_IDX_L2_FORWARDING] = { 822 .packing = sja1105_l2_forwarding_entry_packing, 823 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry), 824 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY, 825 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT, 826 }, 827 [BLK_IDX_MAC_CONFIG] = { 828 .packing = sja1105pqrs_mac_config_entry_packing, 829 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry), 830 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY, 831 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT, 832 }, 833 [BLK_IDX_L2_LOOKUP_PARAMS] = { 834 .packing = sja1105pqrs_l2_lookup_params_entry_packing, 835 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry), 836 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY, 837 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT, 838 }, 839 [BLK_IDX_L2_FORWARDING_PARAMS] = { 840 .packing = sja1105_l2_forwarding_params_entry_packing, 841 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry), 842 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY, 843 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT, 844 }, 845 [BLK_IDX_AVB_PARAMS] = { 846 .packing = sja1105pqrs_avb_params_entry_packing, 847 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry), 848 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY, 849 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT, 850 }, 851 [BLK_IDX_GENERAL_PARAMS] = { 852 .packing = sja1105pqrs_general_params_entry_packing, 853 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry), 854 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY, 855 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT, 856 }, 857 [BLK_IDX_XMII_PARAMS] = { 858 .packing = sja1105_xmii_params_entry_packing, 859 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry), 860 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY, 861 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT, 862 }, 863 }; 864 865 /* SJA1105R: Second generation, no TTEthernet, SGMII */ 866 struct sja1105_table_ops sja1105r_table_ops[BLK_IDX_MAX] = { 867 [BLK_IDX_L2_LOOKUP] = { 868 .packing = sja1105pqrs_l2_lookup_entry_packing, 869 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry), 870 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY, 871 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT, 872 }, 873 [BLK_IDX_L2_POLICING] = { 874 .packing = sja1105_l2_policing_entry_packing, 875 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry), 876 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY, 877 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT, 878 }, 879 [BLK_IDX_VLAN_LOOKUP] = { 880 .packing = sja1105_vlan_lookup_entry_packing, 881 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry), 882 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY, 883 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT, 884 }, 885 [BLK_IDX_L2_FORWARDING] = { 886 .packing = sja1105_l2_forwarding_entry_packing, 887 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry), 888 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY, 889 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT, 890 }, 891 [BLK_IDX_MAC_CONFIG] = { 892 .packing = sja1105pqrs_mac_config_entry_packing, 893 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry), 894 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY, 895 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT, 896 }, 897 [BLK_IDX_L2_LOOKUP_PARAMS] = { 898 .packing = sja1105pqrs_l2_lookup_params_entry_packing, 899 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry), 900 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY, 901 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT, 902 }, 903 [BLK_IDX_L2_FORWARDING_PARAMS] = { 904 .packing = sja1105_l2_forwarding_params_entry_packing, 905 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry), 906 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY, 907 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT, 908 }, 909 [BLK_IDX_AVB_PARAMS] = { 910 .packing = sja1105pqrs_avb_params_entry_packing, 911 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry), 912 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY, 913 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT, 914 }, 915 [BLK_IDX_GENERAL_PARAMS] = { 916 .packing = sja1105pqrs_general_params_entry_packing, 917 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry), 918 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY, 919 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT, 920 }, 921 [BLK_IDX_XMII_PARAMS] = { 922 .packing = sja1105_xmii_params_entry_packing, 923 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry), 924 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY, 925 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT, 926 }, 927 }; 928 929 /* SJA1105S: Second generation, TTEthernet, SGMII */ 930 struct sja1105_table_ops sja1105s_table_ops[BLK_IDX_MAX] = { 931 [BLK_IDX_L2_LOOKUP] = { 932 .packing = sja1105pqrs_l2_lookup_entry_packing, 933 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry), 934 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY, 935 .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT, 936 }, 937 [BLK_IDX_L2_POLICING] = { 938 .packing = sja1105_l2_policing_entry_packing, 939 .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry), 940 .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY, 941 .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT, 942 }, 943 [BLK_IDX_VLAN_LOOKUP] = { 944 .packing = sja1105_vlan_lookup_entry_packing, 945 .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry), 946 .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY, 947 .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT, 948 }, 949 [BLK_IDX_L2_FORWARDING] = { 950 .packing = sja1105_l2_forwarding_entry_packing, 951 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry), 952 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY, 953 .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT, 954 }, 955 [BLK_IDX_MAC_CONFIG] = { 956 .packing = sja1105pqrs_mac_config_entry_packing, 957 .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry), 958 .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY, 959 .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT, 960 }, 961 [BLK_IDX_L2_LOOKUP_PARAMS] = { 962 .packing = sja1105pqrs_l2_lookup_params_entry_packing, 963 .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry), 964 .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY, 965 .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT, 966 }, 967 [BLK_IDX_L2_FORWARDING_PARAMS] = { 968 .packing = sja1105_l2_forwarding_params_entry_packing, 969 .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry), 970 .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY, 971 .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT, 972 }, 973 [BLK_IDX_AVB_PARAMS] = { 974 .packing = sja1105pqrs_avb_params_entry_packing, 975 .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry), 976 .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY, 977 .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT, 978 }, 979 [BLK_IDX_GENERAL_PARAMS] = { 980 .packing = sja1105pqrs_general_params_entry_packing, 981 .unpacked_entry_size = sizeof(struct sja1105_general_params_entry), 982 .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY, 983 .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT, 984 }, 985 [BLK_IDX_XMII_PARAMS] = { 986 .packing = sja1105_xmii_params_entry_packing, 987 .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry), 988 .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY, 989 .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT, 990 }, 991 }; 992 993 int sja1105_static_config_init(struct sja1105_static_config *config, 994 const struct sja1105_table_ops *static_ops, 995 u64 device_id) 996 { 997 enum sja1105_blk_idx i; 998 999 *config = (struct sja1105_static_config) {0}; 1000 1001 /* Transfer static_ops array from priv into per-table ops 1002 * for handier access 1003 */ 1004 for (i = 0; i < BLK_IDX_MAX; i++) 1005 config->tables[i].ops = &static_ops[i]; 1006 1007 config->device_id = device_id; 1008 return 0; 1009 } 1010 1011 void sja1105_static_config_free(struct sja1105_static_config *config) 1012 { 1013 enum sja1105_blk_idx i; 1014 1015 for (i = 0; i < BLK_IDX_MAX; i++) { 1016 if (config->tables[i].entry_count) { 1017 kfree(config->tables[i].entries); 1018 config->tables[i].entry_count = 0; 1019 } 1020 } 1021 } 1022 1023 int sja1105_table_delete_entry(struct sja1105_table *table, int i) 1024 { 1025 size_t entry_size = table->ops->unpacked_entry_size; 1026 u8 *entries = table->entries; 1027 1028 if (i > table->entry_count) 1029 return -ERANGE; 1030 1031 memmove(entries + i * entry_size, entries + (i + 1) * entry_size, 1032 (table->entry_count - i) * entry_size); 1033 1034 table->entry_count--; 1035 1036 return 0; 1037 } 1038 1039 /* No pointers to table->entries should be kept when this is called. */ 1040 int sja1105_table_resize(struct sja1105_table *table, size_t new_count) 1041 { 1042 size_t entry_size = table->ops->unpacked_entry_size; 1043 void *new_entries, *old_entries = table->entries; 1044 1045 if (new_count > table->ops->max_entry_count) 1046 return -ERANGE; 1047 1048 new_entries = kcalloc(new_count, entry_size, GFP_KERNEL); 1049 if (!new_entries) 1050 return -ENOMEM; 1051 1052 memcpy(new_entries, old_entries, min(new_count, table->entry_count) * 1053 entry_size); 1054 1055 table->entries = new_entries; 1056 table->entry_count = new_count; 1057 kfree(old_entries); 1058 return 0; 1059 } 1060