Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: BSD-3-Clause
0002 /* Copyright 2016-2018 NXP
0003  * Copyright (c) 2018-2019, Vladimir Oltean <olteanv@gmail.com>
0004  */
0005 #include "sja1105_static_config.h"
0006 #include <linux/crc32.h>
0007 #include <linux/slab.h>
0008 #include <linux/string.h>
0009 #include <linux/errno.h>
0010 
0011 /* Convenience wrappers over the generic packing functions. These take into
0012  * account the SJA1105 memory layout quirks and provide some level of
0013  * programmer protection against incorrect API use. The errors are not expected
0014  * to occur durring runtime, therefore printing and swallowing them here is
0015  * appropriate instead of clutterring up higher-level code.
0016  */
0017 void sja1105_pack(void *buf, const u64 *val, int start, int end, size_t len)
0018 {
0019     int rc = packing(buf, (u64 *)val, start, end, len,
0020              PACK, QUIRK_LSW32_IS_FIRST);
0021 
0022     if (likely(!rc))
0023         return;
0024 
0025     if (rc == -EINVAL) {
0026         pr_err("Start bit (%d) expected to be larger than end (%d)\n",
0027                start, end);
0028     } else if (rc == -ERANGE) {
0029         if ((start - end + 1) > 64)
0030             pr_err("Field %d-%d too large for 64 bits!\n",
0031                    start, end);
0032         else
0033             pr_err("Cannot store %llx inside bits %d-%d (would truncate)\n",
0034                    *val, start, end);
0035     }
0036     dump_stack();
0037 }
0038 
0039 void sja1105_unpack(const void *buf, u64 *val, int start, int end, size_t len)
0040 {
0041     int rc = packing((void *)buf, val, start, end, len,
0042              UNPACK, QUIRK_LSW32_IS_FIRST);
0043 
0044     if (likely(!rc))
0045         return;
0046 
0047     if (rc == -EINVAL)
0048         pr_err("Start bit (%d) expected to be larger than end (%d)\n",
0049                start, end);
0050     else if (rc == -ERANGE)
0051         pr_err("Field %d-%d too large for 64 bits!\n",
0052                start, end);
0053     dump_stack();
0054 }
0055 
0056 void sja1105_packing(void *buf, u64 *val, int start, int end,
0057              size_t len, enum packing_op op)
0058 {
0059     int rc = packing(buf, val, start, end, len, op, QUIRK_LSW32_IS_FIRST);
0060 
0061     if (likely(!rc))
0062         return;
0063 
0064     if (rc == -EINVAL) {
0065         pr_err("Start bit (%d) expected to be larger than end (%d)\n",
0066                start, end);
0067     } else if (rc == -ERANGE) {
0068         if ((start - end + 1) > 64)
0069             pr_err("Field %d-%d too large for 64 bits!\n",
0070                    start, end);
0071         else
0072             pr_err("Cannot store %llx inside bits %d-%d (would truncate)\n",
0073                    *val, start, end);
0074     }
0075     dump_stack();
0076 }
0077 
0078 /* Little-endian Ethernet CRC32 of data packed as big-endian u32 words */
0079 u32 sja1105_crc32(const void *buf, size_t len)
0080 {
0081     unsigned int i;
0082     u64 word;
0083     u32 crc;
0084 
0085     /* seed */
0086     crc = ~0;
0087     for (i = 0; i < len; i += 4) {
0088         sja1105_unpack(buf + i, &word, 31, 0, 4);
0089         crc = crc32_le(crc, (u8 *)&word, 4);
0090     }
0091     return ~crc;
0092 }
0093 
0094 static size_t sja1105et_avb_params_entry_packing(void *buf, void *entry_ptr,
0095                          enum packing_op op)
0096 {
0097     const size_t size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY;
0098     struct sja1105_avb_params_entry *entry = entry_ptr;
0099 
0100     sja1105_packing(buf, &entry->destmeta, 95, 48, size, op);
0101     sja1105_packing(buf, &entry->srcmeta,  47,  0, size, op);
0102     return size;
0103 }
0104 
0105 size_t sja1105pqrs_avb_params_entry_packing(void *buf, void *entry_ptr,
0106                         enum packing_op op)
0107 {
0108     const size_t size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY;
0109     struct sja1105_avb_params_entry *entry = entry_ptr;
0110 
0111     sja1105_packing(buf, &entry->cas_master, 126, 126, size, op);
0112     sja1105_packing(buf, &entry->destmeta,   125,  78, size, op);
0113     sja1105_packing(buf, &entry->srcmeta,     77,  30, size, op);
0114     return size;
0115 }
0116 
0117 static size_t sja1105et_general_params_entry_packing(void *buf, void *entry_ptr,
0118                              enum packing_op op)
0119 {
0120     const size_t size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY;
0121     struct sja1105_general_params_entry *entry = entry_ptr;
0122 
0123     sja1105_packing(buf, &entry->vllupformat, 319, 319, size, op);
0124     sja1105_packing(buf, &entry->mirr_ptacu,  318, 318, size, op);
0125     sja1105_packing(buf, &entry->switchid,    317, 315, size, op);
0126     sja1105_packing(buf, &entry->hostprio,    314, 312, size, op);
0127     sja1105_packing(buf, &entry->mac_fltres1, 311, 264, size, op);
0128     sja1105_packing(buf, &entry->mac_fltres0, 263, 216, size, op);
0129     sja1105_packing(buf, &entry->mac_flt1,    215, 168, size, op);
0130     sja1105_packing(buf, &entry->mac_flt0,    167, 120, size, op);
0131     sja1105_packing(buf, &entry->incl_srcpt1, 119, 119, size, op);
0132     sja1105_packing(buf, &entry->incl_srcpt0, 118, 118, size, op);
0133     sja1105_packing(buf, &entry->send_meta1,  117, 117, size, op);
0134     sja1105_packing(buf, &entry->send_meta0,  116, 116, size, op);
0135     sja1105_packing(buf, &entry->casc_port,   115, 113, size, op);
0136     sja1105_packing(buf, &entry->host_port,   112, 110, size, op);
0137     sja1105_packing(buf, &entry->mirr_port,   109, 107, size, op);
0138     sja1105_packing(buf, &entry->vlmarker,    106,  75, size, op);
0139     sja1105_packing(buf, &entry->vlmask,       74,  43, size, op);
0140     sja1105_packing(buf, &entry->tpid,         42,  27, size, op);
0141     sja1105_packing(buf, &entry->ignore2stf,   26,  26, size, op);
0142     sja1105_packing(buf, &entry->tpid2,        25,  10, size, op);
0143     return size;
0144 }
0145 
0146 /* TPID and TPID2 are intentionally reversed so that semantic
0147  * compatibility with E/T is kept.
0148  */
0149 size_t sja1105pqrs_general_params_entry_packing(void *buf, void *entry_ptr,
0150                         enum packing_op op)
0151 {
0152     const size_t size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY;
0153     struct sja1105_general_params_entry *entry = entry_ptr;
0154 
0155     sja1105_packing(buf, &entry->vllupformat, 351, 351, size, op);
0156     sja1105_packing(buf, &entry->mirr_ptacu,  350, 350, size, op);
0157     sja1105_packing(buf, &entry->switchid,    349, 347, size, op);
0158     sja1105_packing(buf, &entry->hostprio,    346, 344, size, op);
0159     sja1105_packing(buf, &entry->mac_fltres1, 343, 296, size, op);
0160     sja1105_packing(buf, &entry->mac_fltres0, 295, 248, size, op);
0161     sja1105_packing(buf, &entry->mac_flt1,    247, 200, size, op);
0162     sja1105_packing(buf, &entry->mac_flt0,    199, 152, size, op);
0163     sja1105_packing(buf, &entry->incl_srcpt1, 151, 151, size, op);
0164     sja1105_packing(buf, &entry->incl_srcpt0, 150, 150, size, op);
0165     sja1105_packing(buf, &entry->send_meta1,  149, 149, size, op);
0166     sja1105_packing(buf, &entry->send_meta0,  148, 148, size, op);
0167     sja1105_packing(buf, &entry->casc_port,   147, 145, size, op);
0168     sja1105_packing(buf, &entry->host_port,   144, 142, size, op);
0169     sja1105_packing(buf, &entry->mirr_port,   141, 139, size, op);
0170     sja1105_packing(buf, &entry->vlmarker,    138, 107, size, op);
0171     sja1105_packing(buf, &entry->vlmask,      106,  75, size, op);
0172     sja1105_packing(buf, &entry->tpid2,        74,  59, size, op);
0173     sja1105_packing(buf, &entry->ignore2stf,   58,  58, size, op);
0174     sja1105_packing(buf, &entry->tpid,         57,  42, size, op);
0175     sja1105_packing(buf, &entry->queue_ts,     41,  41, size, op);
0176     sja1105_packing(buf, &entry->egrmirrvid,   40,  29, size, op);
0177     sja1105_packing(buf, &entry->egrmirrpcp,   28,  26, size, op);
0178     sja1105_packing(buf, &entry->egrmirrdei,   25,  25, size, op);
0179     sja1105_packing(buf, &entry->replay_port,  24,  22, size, op);
0180     return size;
0181 }
0182 
0183 size_t sja1110_general_params_entry_packing(void *buf, void *entry_ptr,
0184                         enum packing_op op)
0185 {
0186     struct sja1105_general_params_entry *entry = entry_ptr;
0187     const size_t size = SJA1110_SIZE_GENERAL_PARAMS_ENTRY;
0188 
0189     sja1105_packing(buf, &entry->vllupformat,  447, 447, size, op);
0190     sja1105_packing(buf, &entry->mirr_ptacu,   446, 446, size, op);
0191     sja1105_packing(buf, &entry->switchid,     445, 442, size, op);
0192     sja1105_packing(buf, &entry->hostprio,     441, 439, size, op);
0193     sja1105_packing(buf, &entry->mac_fltres1,  438, 391, size, op);
0194     sja1105_packing(buf, &entry->mac_fltres0,  390, 343, size, op);
0195     sja1105_packing(buf, &entry->mac_flt1,     342, 295, size, op);
0196     sja1105_packing(buf, &entry->mac_flt0,     294, 247, size, op);
0197     sja1105_packing(buf, &entry->incl_srcpt1,  246, 246, size, op);
0198     sja1105_packing(buf, &entry->incl_srcpt0,  245, 245, size, op);
0199     sja1105_packing(buf, &entry->send_meta1,   244, 244, size, op);
0200     sja1105_packing(buf, &entry->send_meta0,   243, 243, size, op);
0201     sja1105_packing(buf, &entry->casc_port,    242, 232, size, op);
0202     sja1105_packing(buf, &entry->host_port,    231, 228, size, op);
0203     sja1105_packing(buf, &entry->mirr_port,    227, 224, size, op);
0204     sja1105_packing(buf, &entry->vlmarker,     223, 192, size, op);
0205     sja1105_packing(buf, &entry->vlmask,       191, 160, size, op);
0206     sja1105_packing(buf, &entry->tpid2,        159, 144, size, op);
0207     sja1105_packing(buf, &entry->ignore2stf,   143, 143, size, op);
0208     sja1105_packing(buf, &entry->tpid,         142, 127, size, op);
0209     sja1105_packing(buf, &entry->queue_ts,     126, 126, size, op);
0210     sja1105_packing(buf, &entry->egrmirrvid,   125, 114, size, op);
0211     sja1105_packing(buf, &entry->egrmirrpcp,   113, 111, size, op);
0212     sja1105_packing(buf, &entry->egrmirrdei,   110, 110, size, op);
0213     sja1105_packing(buf, &entry->replay_port,  109, 106, size, op);
0214     sja1105_packing(buf, &entry->tdmaconfigidx, 70,  67, size, op);
0215     sja1105_packing(buf, &entry->header_type,   64,  49, size, op);
0216     sja1105_packing(buf, &entry->tte_en,        16,  16, size, op);
0217     return size;
0218 }
0219 
0220 static size_t
0221 sja1105_l2_forwarding_params_entry_packing(void *buf, void *entry_ptr,
0222                        enum packing_op op)
0223 {
0224     const size_t size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY;
0225     struct sja1105_l2_forwarding_params_entry *entry = entry_ptr;
0226     int offset, i;
0227 
0228     sja1105_packing(buf, &entry->max_dynp, 95, 93, size, op);
0229     for (i = 0, offset = 13; i < 8; i++, offset += 10)
0230         sja1105_packing(buf, &entry->part_spc[i],
0231                 offset + 9, offset + 0, size, op);
0232     return size;
0233 }
0234 
0235 size_t sja1110_l2_forwarding_params_entry_packing(void *buf, void *entry_ptr,
0236                           enum packing_op op)
0237 {
0238     struct sja1105_l2_forwarding_params_entry *entry = entry_ptr;
0239     const size_t size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY;
0240     int offset, i;
0241 
0242     sja1105_packing(buf, &entry->max_dynp, 95, 93, size, op);
0243     for (i = 0, offset = 5; i < 8; i++, offset += 11)
0244         sja1105_packing(buf, &entry->part_spc[i],
0245                 offset + 10, offset + 0, size, op);
0246     return size;
0247 }
0248 
0249 size_t sja1105_l2_forwarding_entry_packing(void *buf, void *entry_ptr,
0250                        enum packing_op op)
0251 {
0252     const size_t size = SJA1105_SIZE_L2_FORWARDING_ENTRY;
0253     struct sja1105_l2_forwarding_entry *entry = entry_ptr;
0254     int offset, i;
0255 
0256     sja1105_packing(buf, &entry->bc_domain,  63, 59, size, op);
0257     sja1105_packing(buf, &entry->reach_port, 58, 54, size, op);
0258     sja1105_packing(buf, &entry->fl_domain,  53, 49, size, op);
0259     for (i = 0, offset = 25; i < 8; i++, offset += 3)
0260         sja1105_packing(buf, &entry->vlan_pmap[i],
0261                 offset + 2, offset + 0, size, op);
0262     return size;
0263 }
0264 
0265 size_t sja1110_l2_forwarding_entry_packing(void *buf, void *entry_ptr,
0266                        enum packing_op op)
0267 {
0268     struct sja1105_l2_forwarding_entry *entry = entry_ptr;
0269     const size_t size = SJA1105_SIZE_L2_FORWARDING_ENTRY;
0270     int offset, i;
0271 
0272     if (entry->type_egrpcp2outputq) {
0273         for (i = 0, offset = 31; i < SJA1110_NUM_PORTS;
0274              i++, offset += 3) {
0275             sja1105_packing(buf, &entry->vlan_pmap[i],
0276                     offset + 2, offset + 0, size, op);
0277         }
0278     } else {
0279         sja1105_packing(buf, &entry->bc_domain,  63, 53, size, op);
0280         sja1105_packing(buf, &entry->reach_port, 52, 42, size, op);
0281         sja1105_packing(buf, &entry->fl_domain,  41, 31, size, op);
0282     }
0283     return size;
0284 }
0285 
0286 static size_t
0287 sja1105et_l2_lookup_params_entry_packing(void *buf, void *entry_ptr,
0288                      enum packing_op op)
0289 {
0290     const size_t size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY;
0291     struct sja1105_l2_lookup_params_entry *entry = entry_ptr;
0292 
0293     sja1105_packing(buf, &entry->maxage,         31, 17, size, op);
0294     sja1105_packing(buf, &entry->dyn_tbsz,       16, 14, size, op);
0295     sja1105_packing(buf, &entry->poly,           13,  6, size, op);
0296     sja1105_packing(buf, &entry->shared_learn,    5,  5, size, op);
0297     sja1105_packing(buf, &entry->no_enf_hostprt,  4,  4, size, op);
0298     sja1105_packing(buf, &entry->no_mgmt_learn,   3,  3, size, op);
0299     return size;
0300 }
0301 
0302 size_t sja1105pqrs_l2_lookup_params_entry_packing(void *buf, void *entry_ptr,
0303                           enum packing_op op)
0304 {
0305     const size_t size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY;
0306     struct sja1105_l2_lookup_params_entry *entry = entry_ptr;
0307     int offset, i;
0308 
0309     for (i = 0, offset = 58; i < 5; i++, offset += 11)
0310         sja1105_packing(buf, &entry->maxaddrp[i],
0311                 offset + 10, offset + 0, size, op);
0312     sja1105_packing(buf, &entry->maxage,         57,  43, size, op);
0313     sja1105_packing(buf, &entry->start_dynspc,   42,  33, size, op);
0314     sja1105_packing(buf, &entry->drpnolearn,     32,  28, size, op);
0315     sja1105_packing(buf, &entry->shared_learn,   27,  27, size, op);
0316     sja1105_packing(buf, &entry->no_enf_hostprt, 26,  26, size, op);
0317     sja1105_packing(buf, &entry->no_mgmt_learn,  25,  25, size, op);
0318     sja1105_packing(buf, &entry->use_static,     24,  24, size, op);
0319     sja1105_packing(buf, &entry->owr_dyn,        23,  23, size, op);
0320     sja1105_packing(buf, &entry->learn_once,     22,  22, size, op);
0321     return size;
0322 }
0323 
0324 size_t sja1110_l2_lookup_params_entry_packing(void *buf, void *entry_ptr,
0325                           enum packing_op op)
0326 {
0327     struct sja1105_l2_lookup_params_entry *entry = entry_ptr;
0328     const size_t size = SJA1110_SIZE_L2_LOOKUP_PARAMS_ENTRY;
0329     int offset, i;
0330 
0331     for (i = 0, offset = 70; i < SJA1110_NUM_PORTS; i++, offset += 11)
0332         sja1105_packing(buf, &entry->maxaddrp[i],
0333                 offset + 10, offset + 0, size, op);
0334     sja1105_packing(buf, &entry->maxage,         69,  55, size, op);
0335     sja1105_packing(buf, &entry->start_dynspc,   54,  45, size, op);
0336     sja1105_packing(buf, &entry->drpnolearn,     44,  34, size, op);
0337     sja1105_packing(buf, &entry->shared_learn,   33,  33, size, op);
0338     sja1105_packing(buf, &entry->no_enf_hostprt, 32,  32, size, op);
0339     sja1105_packing(buf, &entry->no_mgmt_learn,  31,  31, size, op);
0340     sja1105_packing(buf, &entry->use_static,     30,  30, size, op);
0341     sja1105_packing(buf, &entry->owr_dyn,        29,  29, size, op);
0342     sja1105_packing(buf, &entry->learn_once,     28,  28, size, op);
0343     return size;
0344 }
0345 
0346 size_t sja1105et_l2_lookup_entry_packing(void *buf, void *entry_ptr,
0347                      enum packing_op op)
0348 {
0349     const size_t size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY;
0350     struct sja1105_l2_lookup_entry *entry = entry_ptr;
0351 
0352     sja1105_packing(buf, &entry->vlanid,    95, 84, size, op);
0353     sja1105_packing(buf, &entry->macaddr,   83, 36, size, op);
0354     sja1105_packing(buf, &entry->destports, 35, 31, size, op);
0355     sja1105_packing(buf, &entry->enfport,   30, 30, size, op);
0356     sja1105_packing(buf, &entry->index,     29, 20, size, op);
0357     return size;
0358 }
0359 
0360 size_t sja1105pqrs_l2_lookup_entry_packing(void *buf, void *entry_ptr,
0361                        enum packing_op op)
0362 {
0363     const size_t size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY;
0364     struct sja1105_l2_lookup_entry *entry = entry_ptr;
0365 
0366     if (entry->lockeds) {
0367         sja1105_packing(buf, &entry->tsreg,    159, 159, size, op);
0368         sja1105_packing(buf, &entry->mirrvlan, 158, 147, size, op);
0369         sja1105_packing(buf, &entry->takets,   146, 146, size, op);
0370         sja1105_packing(buf, &entry->mirr,     145, 145, size, op);
0371         sja1105_packing(buf, &entry->retag,    144, 144, size, op);
0372     } else {
0373         sja1105_packing(buf, &entry->touched,  159, 159, size, op);
0374         sja1105_packing(buf, &entry->age,      158, 144, size, op);
0375     }
0376     sja1105_packing(buf, &entry->mask_iotag,   143, 143, size, op);
0377     sja1105_packing(buf, &entry->mask_vlanid,  142, 131, size, op);
0378     sja1105_packing(buf, &entry->mask_macaddr, 130,  83, size, op);
0379     sja1105_packing(buf, &entry->iotag,         82,  82, size, op);
0380     sja1105_packing(buf, &entry->vlanid,        81,  70, size, op);
0381     sja1105_packing(buf, &entry->macaddr,       69,  22, size, op);
0382     sja1105_packing(buf, &entry->destports,     21,  17, size, op);
0383     sja1105_packing(buf, &entry->enfport,       16,  16, size, op);
0384     sja1105_packing(buf, &entry->index,         15,   6, size, op);
0385     return size;
0386 }
0387 
0388 size_t sja1110_l2_lookup_entry_packing(void *buf, void *entry_ptr,
0389                        enum packing_op op)
0390 {
0391     const size_t size = SJA1110_SIZE_L2_LOOKUP_ENTRY;
0392     struct sja1105_l2_lookup_entry *entry = entry_ptr;
0393 
0394     if (entry->lockeds) {
0395         sja1105_packing(buf, &entry->trap,     168, 168, size, op);
0396         sja1105_packing(buf, &entry->mirrvlan, 167, 156, size, op);
0397         sja1105_packing(buf, &entry->takets,   155, 155, size, op);
0398         sja1105_packing(buf, &entry->mirr,     154, 154, size, op);
0399         sja1105_packing(buf, &entry->retag,    153, 153, size, op);
0400     } else {
0401         sja1105_packing(buf, &entry->touched,  168, 168, size, op);
0402         sja1105_packing(buf, &entry->age,      167, 153, size, op);
0403     }
0404     sja1105_packing(buf, &entry->mask_iotag,   152, 152, size, op);
0405     sja1105_packing(buf, &entry->mask_vlanid,  151, 140, size, op);
0406     sja1105_packing(buf, &entry->mask_macaddr, 139,  92, size, op);
0407     sja1105_packing(buf, &entry->mask_srcport,  91,  88, size, op);
0408     sja1105_packing(buf, &entry->iotag,         87,  87, size, op);
0409     sja1105_packing(buf, &entry->vlanid,        86,  75, size, op);
0410     sja1105_packing(buf, &entry->macaddr,       74,  27, size, op);
0411     sja1105_packing(buf, &entry->srcport,       26,  23, size, op);
0412     sja1105_packing(buf, &entry->destports,     22,  12, size, op);
0413     sja1105_packing(buf, &entry->enfport,       11,  11, size, op);
0414     sja1105_packing(buf, &entry->index,         10,   1, size, op);
0415     return size;
0416 }
0417 
0418 static size_t sja1105_l2_policing_entry_packing(void *buf, void *entry_ptr,
0419                         enum packing_op op)
0420 {
0421     const size_t size = SJA1105_SIZE_L2_POLICING_ENTRY;
0422     struct sja1105_l2_policing_entry *entry = entry_ptr;
0423 
0424     sja1105_packing(buf, &entry->sharindx,  63, 58, size, op);
0425     sja1105_packing(buf, &entry->smax,      57, 42, size, op);
0426     sja1105_packing(buf, &entry->rate,      41, 26, size, op);
0427     sja1105_packing(buf, &entry->maxlen,    25, 15, size, op);
0428     sja1105_packing(buf, &entry->partition, 14, 12, size, op);
0429     return size;
0430 }
0431 
0432 size_t sja1110_l2_policing_entry_packing(void *buf, void *entry_ptr,
0433                      enum packing_op op)
0434 {
0435     struct sja1105_l2_policing_entry *entry = entry_ptr;
0436     const size_t size = SJA1105_SIZE_L2_POLICING_ENTRY;
0437 
0438     sja1105_packing(buf, &entry->sharindx, 63, 57, size, op);
0439     sja1105_packing(buf, &entry->smax,     56, 39, size, op);
0440     sja1105_packing(buf, &entry->rate,     38, 21, size, op);
0441     sja1105_packing(buf, &entry->maxlen,   20, 10, size, op);
0442     sja1105_packing(buf, &entry->partition, 9,  7, size, op);
0443     return size;
0444 }
0445 
0446 static size_t sja1105et_mac_config_entry_packing(void *buf, void *entry_ptr,
0447                          enum packing_op op)
0448 {
0449     const size_t size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY;
0450     struct sja1105_mac_config_entry *entry = entry_ptr;
0451     int offset, i;
0452 
0453     for (i = 0, offset = 72; i < 8; i++, offset += 19) {
0454         sja1105_packing(buf, &entry->enabled[i],
0455                 offset +  0, offset +  0, size, op);
0456         sja1105_packing(buf, &entry->base[i],
0457                 offset +  9, offset +  1, size, op);
0458         sja1105_packing(buf, &entry->top[i],
0459                 offset + 18, offset + 10, size, op);
0460     }
0461     sja1105_packing(buf, &entry->ifg,       71, 67, size, op);
0462     sja1105_packing(buf, &entry->speed,     66, 65, size, op);
0463     sja1105_packing(buf, &entry->tp_delin,  64, 49, size, op);
0464     sja1105_packing(buf, &entry->tp_delout, 48, 33, size, op);
0465     sja1105_packing(buf, &entry->maxage,    32, 25, size, op);
0466     sja1105_packing(buf, &entry->vlanprio,  24, 22, size, op);
0467     sja1105_packing(buf, &entry->vlanid,    21, 10, size, op);
0468     sja1105_packing(buf, &entry->ing_mirr,   9,  9, size, op);
0469     sja1105_packing(buf, &entry->egr_mirr,   8,  8, size, op);
0470     sja1105_packing(buf, &entry->drpnona664, 7,  7, size, op);
0471     sja1105_packing(buf, &entry->drpdtag,    6,  6, size, op);
0472     sja1105_packing(buf, &entry->drpuntag,   5,  5, size, op);
0473     sja1105_packing(buf, &entry->retag,      4,  4, size, op);
0474     sja1105_packing(buf, &entry->dyn_learn,  3,  3, size, op);
0475     sja1105_packing(buf, &entry->egress,     2,  2, size, op);
0476     sja1105_packing(buf, &entry->ingress,    1,  1, size, op);
0477     return size;
0478 }
0479 
0480 size_t sja1105pqrs_mac_config_entry_packing(void *buf, void *entry_ptr,
0481                         enum packing_op op)
0482 {
0483     const size_t size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY;
0484     struct sja1105_mac_config_entry *entry = entry_ptr;
0485     int offset, i;
0486 
0487     for (i = 0, offset = 104; i < 8; i++, offset += 19) {
0488         sja1105_packing(buf, &entry->enabled[i],
0489                 offset +  0, offset +  0, size, op);
0490         sja1105_packing(buf, &entry->base[i],
0491                 offset +  9, offset +  1, size, op);
0492         sja1105_packing(buf, &entry->top[i],
0493                 offset + 18, offset + 10, size, op);
0494     }
0495     sja1105_packing(buf, &entry->ifg,       103, 99, size, op);
0496     sja1105_packing(buf, &entry->speed,      98, 97, size, op);
0497     sja1105_packing(buf, &entry->tp_delin,   96, 81, size, op);
0498     sja1105_packing(buf, &entry->tp_delout,  80, 65, size, op);
0499     sja1105_packing(buf, &entry->maxage,     64, 57, size, op);
0500     sja1105_packing(buf, &entry->vlanprio,   56, 54, size, op);
0501     sja1105_packing(buf, &entry->vlanid,     53, 42, size, op);
0502     sja1105_packing(buf, &entry->ing_mirr,   41, 41, size, op);
0503     sja1105_packing(buf, &entry->egr_mirr,   40, 40, size, op);
0504     sja1105_packing(buf, &entry->drpnona664, 39, 39, size, op);
0505     sja1105_packing(buf, &entry->drpdtag,    38, 38, size, op);
0506     sja1105_packing(buf, &entry->drpuntag,   35, 35, size, op);
0507     sja1105_packing(buf, &entry->retag,      34, 34, size, op);
0508     sja1105_packing(buf, &entry->dyn_learn,  33, 33, size, op);
0509     sja1105_packing(buf, &entry->egress,     32, 32, size, op);
0510     sja1105_packing(buf, &entry->ingress,    31, 31, size, op);
0511     return size;
0512 }
0513 
0514 size_t sja1110_mac_config_entry_packing(void *buf, void *entry_ptr,
0515                     enum packing_op op)
0516 {
0517     const size_t size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY;
0518     struct sja1105_mac_config_entry *entry = entry_ptr;
0519     int offset, i;
0520 
0521     for (i = 0, offset = 104; i < 8; i++, offset += 19) {
0522         sja1105_packing(buf, &entry->enabled[i],
0523                 offset +  0, offset +  0, size, op);
0524         sja1105_packing(buf, &entry->base[i],
0525                 offset +  9, offset +  1, size, op);
0526         sja1105_packing(buf, &entry->top[i],
0527                 offset + 18, offset + 10, size, op);
0528     }
0529     sja1105_packing(buf, &entry->speed,      98, 96, size, op);
0530     sja1105_packing(buf, &entry->tp_delin,   95, 80, size, op);
0531     sja1105_packing(buf, &entry->tp_delout,  79, 64, size, op);
0532     sja1105_packing(buf, &entry->maxage,     63, 56, size, op);
0533     sja1105_packing(buf, &entry->vlanprio,   55, 53, size, op);
0534     sja1105_packing(buf, &entry->vlanid,     52, 41, size, op);
0535     sja1105_packing(buf, &entry->ing_mirr,   40, 40, size, op);
0536     sja1105_packing(buf, &entry->egr_mirr,   39, 39, size, op);
0537     sja1105_packing(buf, &entry->drpnona664, 38, 38, size, op);
0538     sja1105_packing(buf, &entry->drpdtag,    37, 37, size, op);
0539     sja1105_packing(buf, &entry->drpuntag,   34, 34, size, op);
0540     sja1105_packing(buf, &entry->retag,      33, 33, size, op);
0541     sja1105_packing(buf, &entry->dyn_learn,  32, 32, size, op);
0542     sja1105_packing(buf, &entry->egress,     31, 31, size, op);
0543     sja1105_packing(buf, &entry->ingress,    30, 30, size, op);
0544     sja1105_packing(buf, &entry->ifg,        10,  5, size, op);
0545     return size;
0546 }
0547 
0548 static size_t
0549 sja1105_schedule_entry_points_params_entry_packing(void *buf, void *entry_ptr,
0550                            enum packing_op op)
0551 {
0552     struct sja1105_schedule_entry_points_params_entry *entry = entry_ptr;
0553     const size_t size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY;
0554 
0555     sja1105_packing(buf, &entry->clksrc,    31, 30, size, op);
0556     sja1105_packing(buf, &entry->actsubsch, 29, 27, size, op);
0557     return size;
0558 }
0559 
0560 static size_t
0561 sja1105_schedule_entry_points_entry_packing(void *buf, void *entry_ptr,
0562                         enum packing_op op)
0563 {
0564     struct sja1105_schedule_entry_points_entry *entry = entry_ptr;
0565     const size_t size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY;
0566 
0567     sja1105_packing(buf, &entry->subschindx, 31, 29, size, op);
0568     sja1105_packing(buf, &entry->delta,      28, 11, size, op);
0569     sja1105_packing(buf, &entry->address,    10, 1,  size, op);
0570     return size;
0571 }
0572 
0573 static size_t
0574 sja1110_schedule_entry_points_entry_packing(void *buf, void *entry_ptr,
0575                         enum packing_op op)
0576 {
0577     struct sja1105_schedule_entry_points_entry *entry = entry_ptr;
0578     const size_t size = SJA1110_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY;
0579 
0580     sja1105_packing(buf, &entry->subschindx, 63, 61, size, op);
0581     sja1105_packing(buf, &entry->delta,      60, 43, size, op);
0582     sja1105_packing(buf, &entry->address,    42, 31, size, op);
0583     return size;
0584 }
0585 
0586 static size_t sja1105_schedule_params_entry_packing(void *buf, void *entry_ptr,
0587                             enum packing_op op)
0588 {
0589     const size_t size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY;
0590     struct sja1105_schedule_params_entry *entry = entry_ptr;
0591     int offset, i;
0592 
0593     for (i = 0, offset = 16; i < 8; i++, offset += 10)
0594         sja1105_packing(buf, &entry->subscheind[i],
0595                 offset + 9, offset + 0, size, op);
0596     return size;
0597 }
0598 
0599 static size_t sja1110_schedule_params_entry_packing(void *buf, void *entry_ptr,
0600                             enum packing_op op)
0601 {
0602     struct sja1105_schedule_params_entry *entry = entry_ptr;
0603     const size_t size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY;
0604     int offset, i;
0605 
0606     for (i = 0, offset = 0; i < 8; i++, offset += 12)
0607         sja1105_packing(buf, &entry->subscheind[i],
0608                 offset + 11, offset + 0, size, op);
0609     return size;
0610 }
0611 
0612 static size_t sja1105_schedule_entry_packing(void *buf, void *entry_ptr,
0613                          enum packing_op op)
0614 {
0615     const size_t size = SJA1105_SIZE_SCHEDULE_ENTRY;
0616     struct sja1105_schedule_entry *entry = entry_ptr;
0617 
0618     sja1105_packing(buf, &entry->winstindex,  63, 54, size, op);
0619     sja1105_packing(buf, &entry->winend,      53, 53, size, op);
0620     sja1105_packing(buf, &entry->winst,       52, 52, size, op);
0621     sja1105_packing(buf, &entry->destports,   51, 47, size, op);
0622     sja1105_packing(buf, &entry->setvalid,    46, 46, size, op);
0623     sja1105_packing(buf, &entry->txen,        45, 45, size, op);
0624     sja1105_packing(buf, &entry->resmedia_en, 44, 44, size, op);
0625     sja1105_packing(buf, &entry->resmedia,    43, 36, size, op);
0626     sja1105_packing(buf, &entry->vlindex,     35, 26, size, op);
0627     sja1105_packing(buf, &entry->delta,       25, 8,  size, op);
0628     return size;
0629 }
0630 
0631 static size_t sja1110_schedule_entry_packing(void *buf, void *entry_ptr,
0632                          enum packing_op op)
0633 {
0634     const size_t size = SJA1110_SIZE_SCHEDULE_ENTRY;
0635     struct sja1105_schedule_entry *entry = entry_ptr;
0636 
0637     sja1105_packing(buf, &entry->winstindex,  95, 84, size, op);
0638     sja1105_packing(buf, &entry->winend,      83, 83, size, op);
0639     sja1105_packing(buf, &entry->winst,       82, 82, size, op);
0640     sja1105_packing(buf, &entry->destports,   81, 71, size, op);
0641     sja1105_packing(buf, &entry->setvalid,    70, 70, size, op);
0642     sja1105_packing(buf, &entry->txen,        69, 69, size, op);
0643     sja1105_packing(buf, &entry->resmedia_en, 68, 68, size, op);
0644     sja1105_packing(buf, &entry->resmedia,    67, 60, size, op);
0645     sja1105_packing(buf, &entry->vlindex,     59, 48, size, op);
0646     sja1105_packing(buf, &entry->delta,       47, 30, size, op);
0647     return size;
0648 }
0649 
0650 static size_t
0651 sja1105_vl_forwarding_params_entry_packing(void *buf, void *entry_ptr,
0652                        enum packing_op op)
0653 {
0654     struct sja1105_vl_forwarding_params_entry *entry = entry_ptr;
0655     const size_t size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY;
0656     int offset, i;
0657 
0658     for (i = 0, offset = 16; i < 8; i++, offset += 10)
0659         sja1105_packing(buf, &entry->partspc[i],
0660                 offset + 9, offset + 0, size, op);
0661     sja1105_packing(buf, &entry->debugen, 15, 15, size, op);
0662     return size;
0663 }
0664 
0665 static size_t
0666 sja1110_vl_forwarding_params_entry_packing(void *buf, void *entry_ptr,
0667                        enum packing_op op)
0668 {
0669     struct sja1105_vl_forwarding_params_entry *entry = entry_ptr;
0670     const size_t size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY;
0671     int offset, i;
0672 
0673     for (i = 0, offset = 8; i < 8; i++, offset += 11)
0674         sja1105_packing(buf, &entry->partspc[i],
0675                 offset + 10, offset + 0, size, op);
0676     sja1105_packing(buf, &entry->debugen, 7, 7, size, op);
0677     return size;
0678 }
0679 
0680 static size_t sja1105_vl_forwarding_entry_packing(void *buf, void *entry_ptr,
0681                           enum packing_op op)
0682 {
0683     struct sja1105_vl_forwarding_entry *entry = entry_ptr;
0684     const size_t size = SJA1105_SIZE_VL_FORWARDING_ENTRY;
0685 
0686     sja1105_packing(buf, &entry->type,      31, 31, size, op);
0687     sja1105_packing(buf, &entry->priority,  30, 28, size, op);
0688     sja1105_packing(buf, &entry->partition, 27, 25, size, op);
0689     sja1105_packing(buf, &entry->destports, 24, 20, size, op);
0690     return size;
0691 }
0692 
0693 static size_t sja1110_vl_forwarding_entry_packing(void *buf, void *entry_ptr,
0694                           enum packing_op op)
0695 {
0696     struct sja1105_vl_forwarding_entry *entry = entry_ptr;
0697     const size_t size = SJA1105_SIZE_VL_FORWARDING_ENTRY;
0698 
0699     sja1105_packing(buf, &entry->type,      31, 31, size, op);
0700     sja1105_packing(buf, &entry->priority,  30, 28, size, op);
0701     sja1105_packing(buf, &entry->partition, 27, 25, size, op);
0702     sja1105_packing(buf, &entry->destports, 24, 14, size, op);
0703     return size;
0704 }
0705 
0706 size_t sja1105_vl_lookup_entry_packing(void *buf, void *entry_ptr,
0707                        enum packing_op op)
0708 {
0709     struct sja1105_vl_lookup_entry *entry = entry_ptr;
0710     const size_t size = SJA1105_SIZE_VL_LOOKUP_ENTRY;
0711 
0712     if (entry->format == SJA1105_VL_FORMAT_PSFP) {
0713         /* Interpreting vllupformat as 0 */
0714         sja1105_packing(buf, &entry->destports,
0715                 95, 91, size, op);
0716         sja1105_packing(buf, &entry->iscritical,
0717                 90, 90, size, op);
0718         sja1105_packing(buf, &entry->macaddr,
0719                 89, 42, size, op);
0720         sja1105_packing(buf, &entry->vlanid,
0721                 41, 30, size, op);
0722         sja1105_packing(buf, &entry->port,
0723                 29, 27, size, op);
0724         sja1105_packing(buf, &entry->vlanprior,
0725                 26, 24, size, op);
0726     } else {
0727         /* Interpreting vllupformat as 1 */
0728         sja1105_packing(buf, &entry->egrmirr,
0729                 95, 91, size, op);
0730         sja1105_packing(buf, &entry->ingrmirr,
0731                 90, 90, size, op);
0732         sja1105_packing(buf, &entry->vlid,
0733                 57, 42, size, op);
0734         sja1105_packing(buf, &entry->port,
0735                 29, 27, size, op);
0736     }
0737     return size;
0738 }
0739 
0740 size_t sja1110_vl_lookup_entry_packing(void *buf, void *entry_ptr,
0741                        enum packing_op op)
0742 {
0743     struct sja1105_vl_lookup_entry *entry = entry_ptr;
0744     const size_t size = SJA1105_SIZE_VL_LOOKUP_ENTRY;
0745 
0746     if (entry->format == SJA1105_VL_FORMAT_PSFP) {
0747         /* Interpreting vllupformat as 0 */
0748         sja1105_packing(buf, &entry->destports,
0749                 94, 84, size, op);
0750         sja1105_packing(buf, &entry->iscritical,
0751                 83, 83, size, op);
0752         sja1105_packing(buf, &entry->macaddr,
0753                 82, 35, size, op);
0754         sja1105_packing(buf, &entry->vlanid,
0755                 34, 23, size, op);
0756         sja1105_packing(buf, &entry->port,
0757                 22, 19, size, op);
0758         sja1105_packing(buf, &entry->vlanprior,
0759                 18, 16, size, op);
0760     } else {
0761         /* Interpreting vllupformat as 1 */
0762         sja1105_packing(buf, &entry->egrmirr,
0763                 94, 84, size, op);
0764         sja1105_packing(buf, &entry->ingrmirr,
0765                 83, 83, size, op);
0766         sja1105_packing(buf, &entry->vlid,
0767                 50, 35, size, op);
0768         sja1105_packing(buf, &entry->port,
0769                 22, 19, size, op);
0770     }
0771     return size;
0772 }
0773 
0774 static size_t sja1105_vl_policing_entry_packing(void *buf, void *entry_ptr,
0775                         enum packing_op op)
0776 {
0777     struct sja1105_vl_policing_entry *entry = entry_ptr;
0778     const size_t size = SJA1105_SIZE_VL_POLICING_ENTRY;
0779 
0780     sja1105_packing(buf, &entry->type,      63, 63, size, op);
0781     sja1105_packing(buf, &entry->maxlen,    62, 52, size, op);
0782     sja1105_packing(buf, &entry->sharindx,  51, 42, size, op);
0783     if (entry->type == 0) {
0784         sja1105_packing(buf, &entry->bag,    41, 28, size, op);
0785         sja1105_packing(buf, &entry->jitter, 27, 18, size, op);
0786     }
0787     return size;
0788 }
0789 
0790 size_t sja1110_vl_policing_entry_packing(void *buf, void *entry_ptr,
0791                      enum packing_op op)
0792 {
0793     struct sja1105_vl_policing_entry *entry = entry_ptr;
0794     const size_t size = SJA1105_SIZE_VL_POLICING_ENTRY;
0795 
0796     sja1105_packing(buf, &entry->type,      63, 63, size, op);
0797     sja1105_packing(buf, &entry->maxlen,    62, 52, size, op);
0798     sja1105_packing(buf, &entry->sharindx,  51, 40, size, op);
0799     if (entry->type == 0) {
0800         sja1105_packing(buf, &entry->bag,    41, 28, size, op);
0801         sja1105_packing(buf, &entry->jitter, 27, 18, size, op);
0802     }
0803     return size;
0804 }
0805 
0806 size_t sja1105_vlan_lookup_entry_packing(void *buf, void *entry_ptr,
0807                      enum packing_op op)
0808 {
0809     const size_t size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY;
0810     struct sja1105_vlan_lookup_entry *entry = entry_ptr;
0811 
0812     sja1105_packing(buf, &entry->ving_mirr,  63, 59, size, op);
0813     sja1105_packing(buf, &entry->vegr_mirr,  58, 54, size, op);
0814     sja1105_packing(buf, &entry->vmemb_port, 53, 49, size, op);
0815     sja1105_packing(buf, &entry->vlan_bc,    48, 44, size, op);
0816     sja1105_packing(buf, &entry->tag_port,   43, 39, size, op);
0817     sja1105_packing(buf, &entry->vlanid,     38, 27, size, op);
0818     return size;
0819 }
0820 
0821 size_t sja1110_vlan_lookup_entry_packing(void *buf, void *entry_ptr,
0822                      enum packing_op op)
0823 {
0824     struct sja1105_vlan_lookup_entry *entry = entry_ptr;
0825     const size_t size = SJA1110_SIZE_VLAN_LOOKUP_ENTRY;
0826 
0827     sja1105_packing(buf, &entry->ving_mirr,  95, 85, size, op);
0828     sja1105_packing(buf, &entry->vegr_mirr,  84, 74, size, op);
0829     sja1105_packing(buf, &entry->vmemb_port, 73, 63, size, op);
0830     sja1105_packing(buf, &entry->vlan_bc,    62, 52, size, op);
0831     sja1105_packing(buf, &entry->tag_port,   51, 41, size, op);
0832     sja1105_packing(buf, &entry->type_entry, 40, 39, size, op);
0833     sja1105_packing(buf, &entry->vlanid,     38, 27, size, op);
0834     return size;
0835 }
0836 
0837 static size_t sja1105_xmii_params_entry_packing(void *buf, void *entry_ptr,
0838                         enum packing_op op)
0839 {
0840     const size_t size = SJA1105_SIZE_XMII_PARAMS_ENTRY;
0841     struct sja1105_xmii_params_entry *entry = entry_ptr;
0842     int offset, i;
0843 
0844     for (i = 0, offset = 17; i < 5; i++, offset += 3) {
0845         sja1105_packing(buf, &entry->xmii_mode[i],
0846                 offset + 1, offset + 0, size, op);
0847         sja1105_packing(buf, &entry->phy_mac[i],
0848                 offset + 2, offset + 2, size, op);
0849     }
0850     return size;
0851 }
0852 
0853 size_t sja1110_xmii_params_entry_packing(void *buf, void *entry_ptr,
0854                      enum packing_op op)
0855 {
0856     const size_t size = SJA1110_SIZE_XMII_PARAMS_ENTRY;
0857     struct sja1105_xmii_params_entry *entry = entry_ptr;
0858     int offset, i;
0859 
0860     for (i = 0, offset = 20; i < SJA1110_NUM_PORTS; i++, offset += 4) {
0861         sja1105_packing(buf, &entry->xmii_mode[i],
0862                 offset + 1, offset + 0, size, op);
0863         sja1105_packing(buf, &entry->phy_mac[i],
0864                 offset + 2, offset + 2, size, op);
0865         sja1105_packing(buf, &entry->special[i],
0866                 offset + 3, offset + 3, size, op);
0867     }
0868     return size;
0869 }
0870 
0871 size_t sja1105_retagging_entry_packing(void *buf, void *entry_ptr,
0872                        enum packing_op op)
0873 {
0874     struct sja1105_retagging_entry *entry = entry_ptr;
0875     const size_t size = SJA1105_SIZE_RETAGGING_ENTRY;
0876 
0877     sja1105_packing(buf, &entry->egr_port,       63, 59, size, op);
0878     sja1105_packing(buf, &entry->ing_port,       58, 54, size, op);
0879     sja1105_packing(buf, &entry->vlan_ing,       53, 42, size, op);
0880     sja1105_packing(buf, &entry->vlan_egr,       41, 30, size, op);
0881     sja1105_packing(buf, &entry->do_not_learn,   29, 29, size, op);
0882     sja1105_packing(buf, &entry->use_dest_ports, 28, 28, size, op);
0883     sja1105_packing(buf, &entry->destports,      27, 23, size, op);
0884     return size;
0885 }
0886 
0887 size_t sja1110_retagging_entry_packing(void *buf, void *entry_ptr,
0888                        enum packing_op op)
0889 {
0890     struct sja1105_retagging_entry *entry = entry_ptr;
0891     const size_t size = SJA1105_SIZE_RETAGGING_ENTRY;
0892 
0893     sja1105_packing(buf, &entry->egr_port,       63, 53, size, op);
0894     sja1105_packing(buf, &entry->ing_port,       52, 42, size, op);
0895     sja1105_packing(buf, &entry->vlan_ing,       41, 30, size, op);
0896     sja1105_packing(buf, &entry->vlan_egr,       29, 18, size, op);
0897     sja1105_packing(buf, &entry->do_not_learn,   17, 17, size, op);
0898     sja1105_packing(buf, &entry->use_dest_ports, 16, 16, size, op);
0899     sja1105_packing(buf, &entry->destports,      15, 5, size, op);
0900     return size;
0901 }
0902 
0903 static size_t sja1110_pcp_remapping_entry_packing(void *buf, void *entry_ptr,
0904                           enum packing_op op)
0905 {
0906     struct sja1110_pcp_remapping_entry *entry = entry_ptr;
0907     const size_t size = SJA1110_SIZE_PCP_REMAPPING_ENTRY;
0908     int offset, i;
0909 
0910     for (i = 0, offset = 8; i < SJA1105_NUM_TC; i++, offset += 3)
0911         sja1105_packing(buf, &entry->egrpcp[i],
0912                 offset + 2, offset + 0, size, op);
0913 
0914     return size;
0915 }
0916 
0917 size_t sja1105_table_header_packing(void *buf, void *entry_ptr,
0918                     enum packing_op op)
0919 {
0920     const size_t size = SJA1105_SIZE_TABLE_HEADER;
0921     struct sja1105_table_header *entry = entry_ptr;
0922 
0923     sja1105_packing(buf, &entry->block_id, 31, 24, size, op);
0924     sja1105_packing(buf, &entry->len,      55, 32, size, op);
0925     sja1105_packing(buf, &entry->crc,      95, 64, size, op);
0926     return size;
0927 }
0928 
0929 /* WARNING: the *hdr pointer is really non-const, because it is
0930  * modifying the CRC of the header for a 2-stage packing operation
0931  */
0932 void
0933 sja1105_table_header_pack_with_crc(void *buf, struct sja1105_table_header *hdr)
0934 {
0935     /* First pack the table as-is, then calculate the CRC, and
0936      * finally put the proper CRC into the packed buffer
0937      */
0938     memset(buf, 0, SJA1105_SIZE_TABLE_HEADER);
0939     sja1105_table_header_packing(buf, hdr, PACK);
0940     hdr->crc = sja1105_crc32(buf, SJA1105_SIZE_TABLE_HEADER - 4);
0941     sja1105_pack(buf + SJA1105_SIZE_TABLE_HEADER - 4, &hdr->crc, 31, 0, 4);
0942 }
0943 
0944 static void sja1105_table_write_crc(u8 *table_start, u8 *crc_ptr)
0945 {
0946     u64 computed_crc;
0947     int len_bytes;
0948 
0949     len_bytes = (uintptr_t)(crc_ptr - table_start);
0950     computed_crc = sja1105_crc32(table_start, len_bytes);
0951     sja1105_pack(crc_ptr, &computed_crc, 31, 0, 4);
0952 }
0953 
0954 /* The block IDs that the switches support are unfortunately sparse, so keep a
0955  * mapping table to "block indices" and translate back and forth so that we
0956  * don't waste useless memory in struct sja1105_static_config.
0957  * Also, since the block id comes from essentially untrusted input (unpacking
0958  * the static config from userspace) it has to be sanitized (range-checked)
0959  * before blindly indexing kernel memory with the blk_idx.
0960  */
0961 static u64 blk_id_map[BLK_IDX_MAX] = {
0962     [BLK_IDX_SCHEDULE] = BLKID_SCHEDULE,
0963     [BLK_IDX_SCHEDULE_ENTRY_POINTS] = BLKID_SCHEDULE_ENTRY_POINTS,
0964     [BLK_IDX_VL_LOOKUP] = BLKID_VL_LOOKUP,
0965     [BLK_IDX_VL_POLICING] = BLKID_VL_POLICING,
0966     [BLK_IDX_VL_FORWARDING] = BLKID_VL_FORWARDING,
0967     [BLK_IDX_L2_LOOKUP] = BLKID_L2_LOOKUP,
0968     [BLK_IDX_L2_POLICING] = BLKID_L2_POLICING,
0969     [BLK_IDX_VLAN_LOOKUP] = BLKID_VLAN_LOOKUP,
0970     [BLK_IDX_L2_FORWARDING] = BLKID_L2_FORWARDING,
0971     [BLK_IDX_MAC_CONFIG] = BLKID_MAC_CONFIG,
0972     [BLK_IDX_SCHEDULE_PARAMS] = BLKID_SCHEDULE_PARAMS,
0973     [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = BLKID_SCHEDULE_ENTRY_POINTS_PARAMS,
0974     [BLK_IDX_VL_FORWARDING_PARAMS] = BLKID_VL_FORWARDING_PARAMS,
0975     [BLK_IDX_L2_LOOKUP_PARAMS] = BLKID_L2_LOOKUP_PARAMS,
0976     [BLK_IDX_L2_FORWARDING_PARAMS] = BLKID_L2_FORWARDING_PARAMS,
0977     [BLK_IDX_AVB_PARAMS] = BLKID_AVB_PARAMS,
0978     [BLK_IDX_GENERAL_PARAMS] = BLKID_GENERAL_PARAMS,
0979     [BLK_IDX_RETAGGING] = BLKID_RETAGGING,
0980     [BLK_IDX_XMII_PARAMS] = BLKID_XMII_PARAMS,
0981     [BLK_IDX_PCP_REMAPPING] = BLKID_PCP_REMAPPING,
0982 };
0983 
0984 const char *sja1105_static_config_error_msg[] = {
0985     [SJA1105_CONFIG_OK] = "",
0986     [SJA1105_TTETHERNET_NOT_SUPPORTED] =
0987         "schedule-table present, but TTEthernet is "
0988         "only supported on T and Q/S",
0989     [SJA1105_INCORRECT_TTETHERNET_CONFIGURATION] =
0990         "schedule-table present, but one of "
0991         "schedule-entry-points-table, schedule-parameters-table or "
0992         "schedule-entry-points-parameters table is empty",
0993     [SJA1105_INCORRECT_VIRTUAL_LINK_CONFIGURATION] =
0994         "vl-lookup-table present, but one of vl-policing-table, "
0995         "vl-forwarding-table or vl-forwarding-parameters-table is empty",
0996     [SJA1105_MISSING_L2_POLICING_TABLE] =
0997         "l2-policing-table needs to have at least one entry",
0998     [SJA1105_MISSING_L2_FORWARDING_TABLE] =
0999         "l2-forwarding-table is either missing or incomplete",
1000     [SJA1105_MISSING_L2_FORWARDING_PARAMS_TABLE] =
1001         "l2-forwarding-parameters-table is missing",
1002     [SJA1105_MISSING_GENERAL_PARAMS_TABLE] =
1003         "general-parameters-table is missing",
1004     [SJA1105_MISSING_VLAN_TABLE] =
1005         "vlan-lookup-table needs to have at least the default untagged VLAN",
1006     [SJA1105_MISSING_XMII_TABLE] =
1007         "xmii-table is missing",
1008     [SJA1105_MISSING_MAC_TABLE] =
1009         "mac-configuration-table needs to contain an entry for each port",
1010     [SJA1105_OVERCOMMITTED_FRAME_MEMORY] =
1011         "Not allowed to overcommit frame memory. L2 memory partitions "
1012         "and VL memory partitions share the same space. The sum of all "
1013         "16 memory partitions is not allowed to be larger than 929 "
1014         "128-byte blocks (or 910 with retagging). Please adjust "
1015         "l2-forwarding-parameters-table.part_spc and/or "
1016         "vl-forwarding-parameters-table.partspc.",
1017 };
1018 
1019 static sja1105_config_valid_t
1020 static_config_check_memory_size(const struct sja1105_table *tables, int max_mem)
1021 {
1022     const struct sja1105_l2_forwarding_params_entry *l2_fwd_params;
1023     const struct sja1105_vl_forwarding_params_entry *vl_fwd_params;
1024     int i, mem = 0;
1025 
1026     l2_fwd_params = tables[BLK_IDX_L2_FORWARDING_PARAMS].entries;
1027 
1028     for (i = 0; i < 8; i++)
1029         mem += l2_fwd_params->part_spc[i];
1030 
1031     if (tables[BLK_IDX_VL_FORWARDING_PARAMS].entry_count) {
1032         vl_fwd_params = tables[BLK_IDX_VL_FORWARDING_PARAMS].entries;
1033         for (i = 0; i < 8; i++)
1034             mem += vl_fwd_params->partspc[i];
1035     }
1036 
1037     if (tables[BLK_IDX_RETAGGING].entry_count)
1038         max_mem -= SJA1105_FRAME_MEMORY_RETAGGING_OVERHEAD;
1039 
1040     if (mem > max_mem)
1041         return SJA1105_OVERCOMMITTED_FRAME_MEMORY;
1042 
1043     return SJA1105_CONFIG_OK;
1044 }
1045 
1046 sja1105_config_valid_t
1047 sja1105_static_config_check_valid(const struct sja1105_static_config *config,
1048                   int max_mem)
1049 {
1050     const struct sja1105_table *tables = config->tables;
1051 #define IS_FULL(blk_idx) \
1052     (tables[blk_idx].entry_count == tables[blk_idx].ops->max_entry_count)
1053 
1054     if (tables[BLK_IDX_SCHEDULE].entry_count) {
1055         if (!tables[BLK_IDX_SCHEDULE].ops->max_entry_count)
1056             return SJA1105_TTETHERNET_NOT_SUPPORTED;
1057 
1058         if (tables[BLK_IDX_SCHEDULE_ENTRY_POINTS].entry_count == 0)
1059             return SJA1105_INCORRECT_TTETHERNET_CONFIGURATION;
1060 
1061         if (!IS_FULL(BLK_IDX_SCHEDULE_PARAMS))
1062             return SJA1105_INCORRECT_TTETHERNET_CONFIGURATION;
1063 
1064         if (!IS_FULL(BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS))
1065             return SJA1105_INCORRECT_TTETHERNET_CONFIGURATION;
1066     }
1067     if (tables[BLK_IDX_VL_LOOKUP].entry_count) {
1068         struct sja1105_vl_lookup_entry *vl_lookup;
1069         bool has_critical_links = false;
1070         int i;
1071 
1072         vl_lookup = tables[BLK_IDX_VL_LOOKUP].entries;
1073 
1074         for (i = 0; i < tables[BLK_IDX_VL_LOOKUP].entry_count; i++) {
1075             if (vl_lookup[i].iscritical) {
1076                 has_critical_links = true;
1077                 break;
1078             }
1079         }
1080 
1081         if (tables[BLK_IDX_VL_POLICING].entry_count == 0 &&
1082             has_critical_links)
1083             return SJA1105_INCORRECT_VIRTUAL_LINK_CONFIGURATION;
1084 
1085         if (tables[BLK_IDX_VL_FORWARDING].entry_count == 0 &&
1086             has_critical_links)
1087             return SJA1105_INCORRECT_VIRTUAL_LINK_CONFIGURATION;
1088 
1089         if (tables[BLK_IDX_VL_FORWARDING_PARAMS].entry_count == 0 &&
1090             has_critical_links)
1091             return SJA1105_INCORRECT_VIRTUAL_LINK_CONFIGURATION;
1092     }
1093 
1094     if (tables[BLK_IDX_L2_POLICING].entry_count == 0)
1095         return SJA1105_MISSING_L2_POLICING_TABLE;
1096 
1097     if (tables[BLK_IDX_VLAN_LOOKUP].entry_count == 0)
1098         return SJA1105_MISSING_VLAN_TABLE;
1099 
1100     if (!IS_FULL(BLK_IDX_L2_FORWARDING))
1101         return SJA1105_MISSING_L2_FORWARDING_TABLE;
1102 
1103     if (!IS_FULL(BLK_IDX_MAC_CONFIG))
1104         return SJA1105_MISSING_MAC_TABLE;
1105 
1106     if (!IS_FULL(BLK_IDX_L2_FORWARDING_PARAMS))
1107         return SJA1105_MISSING_L2_FORWARDING_PARAMS_TABLE;
1108 
1109     if (!IS_FULL(BLK_IDX_GENERAL_PARAMS))
1110         return SJA1105_MISSING_GENERAL_PARAMS_TABLE;
1111 
1112     if (!IS_FULL(BLK_IDX_XMII_PARAMS))
1113         return SJA1105_MISSING_XMII_TABLE;
1114 
1115     return static_config_check_memory_size(tables, max_mem);
1116 #undef IS_FULL
1117 }
1118 
1119 void
1120 sja1105_static_config_pack(void *buf, struct sja1105_static_config *config)
1121 {
1122     struct sja1105_table_header header = {0};
1123     enum sja1105_blk_idx i;
1124     char *p = buf;
1125     int j;
1126 
1127     sja1105_pack(p, &config->device_id, 31, 0, 4);
1128     p += SJA1105_SIZE_DEVICE_ID;
1129 
1130     for (i = 0; i < BLK_IDX_MAX; i++) {
1131         const struct sja1105_table *table;
1132         char *table_start;
1133 
1134         table = &config->tables[i];
1135         if (!table->entry_count)
1136             continue;
1137 
1138         header.block_id = blk_id_map[i];
1139         header.len = table->entry_count *
1140                  table->ops->packed_entry_size / 4;
1141         sja1105_table_header_pack_with_crc(p, &header);
1142         p += SJA1105_SIZE_TABLE_HEADER;
1143         table_start = p;
1144         for (j = 0; j < table->entry_count; j++) {
1145             u8 *entry_ptr = table->entries;
1146 
1147             entry_ptr += j * table->ops->unpacked_entry_size;
1148             memset(p, 0, table->ops->packed_entry_size);
1149             table->ops->packing(p, entry_ptr, PACK);
1150             p += table->ops->packed_entry_size;
1151         }
1152         sja1105_table_write_crc(table_start, p);
1153         p += 4;
1154     }
1155     /* Final header:
1156      * Block ID does not matter
1157      * Length of 0 marks that header is final
1158      * CRC will be replaced on-the-fly on "config upload"
1159      */
1160     header.block_id = 0;
1161     header.len = 0;
1162     header.crc = 0xDEADBEEF;
1163     memset(p, 0, SJA1105_SIZE_TABLE_HEADER);
1164     sja1105_table_header_packing(p, &header, PACK);
1165 }
1166 
1167 size_t
1168 sja1105_static_config_get_length(const struct sja1105_static_config *config)
1169 {
1170     unsigned int sum;
1171     unsigned int header_count;
1172     enum sja1105_blk_idx i;
1173 
1174     /* Ending header */
1175     header_count = 1;
1176     sum = SJA1105_SIZE_DEVICE_ID;
1177 
1178     /* Tables (headers and entries) */
1179     for (i = 0; i < BLK_IDX_MAX; i++) {
1180         const struct sja1105_table *table;
1181 
1182         table = &config->tables[i];
1183         if (table->entry_count)
1184             header_count++;
1185 
1186         sum += table->ops->packed_entry_size * table->entry_count;
1187     }
1188     /* Headers have an additional CRC at the end */
1189     sum += header_count * (SJA1105_SIZE_TABLE_HEADER + 4);
1190     /* Last header does not have an extra CRC because there is no data */
1191     sum -= 4;
1192 
1193     return sum;
1194 }
1195 
1196 /* Compatibility matrices */
1197 
1198 /* SJA1105E: First generation, no TTEthernet */
1199 const struct sja1105_table_ops sja1105e_table_ops[BLK_IDX_MAX] = {
1200     [BLK_IDX_L2_LOOKUP] = {
1201         .packing = sja1105et_l2_lookup_entry_packing,
1202         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1203         .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY,
1204         .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1205     },
1206     [BLK_IDX_L2_POLICING] = {
1207         .packing = sja1105_l2_policing_entry_packing,
1208         .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1209         .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1210         .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1211     },
1212     [BLK_IDX_VLAN_LOOKUP] = {
1213         .packing = sja1105_vlan_lookup_entry_packing,
1214         .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1215         .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1216         .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1217     },
1218     [BLK_IDX_L2_FORWARDING] = {
1219         .packing = sja1105_l2_forwarding_entry_packing,
1220         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1221         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1222         .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1223     },
1224     [BLK_IDX_MAC_CONFIG] = {
1225         .packing = sja1105et_mac_config_entry_packing,
1226         .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1227         .packed_entry_size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY,
1228         .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1229     },
1230     [BLK_IDX_L2_LOOKUP_PARAMS] = {
1231         .packing = sja1105et_l2_lookup_params_entry_packing,
1232         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1233         .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1234         .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1235     },
1236     [BLK_IDX_L2_FORWARDING_PARAMS] = {
1237         .packing = sja1105_l2_forwarding_params_entry_packing,
1238         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1239         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1240         .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1241     },
1242     [BLK_IDX_AVB_PARAMS] = {
1243         .packing = sja1105et_avb_params_entry_packing,
1244         .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1245         .packed_entry_size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY,
1246         .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1247     },
1248     [BLK_IDX_GENERAL_PARAMS] = {
1249         .packing = sja1105et_general_params_entry_packing,
1250         .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1251         .packed_entry_size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY,
1252         .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1253     },
1254     [BLK_IDX_RETAGGING] = {
1255         .packing = sja1105_retagging_entry_packing,
1256         .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1257         .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1258         .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1259     },
1260     [BLK_IDX_XMII_PARAMS] = {
1261         .packing = sja1105_xmii_params_entry_packing,
1262         .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1263         .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1264         .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1265     },
1266 };
1267 
1268 /* SJA1105T: First generation, TTEthernet */
1269 const struct sja1105_table_ops sja1105t_table_ops[BLK_IDX_MAX] = {
1270     [BLK_IDX_SCHEDULE] = {
1271         .packing = sja1105_schedule_entry_packing,
1272         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry),
1273         .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY,
1274         .max_entry_count = SJA1105_MAX_SCHEDULE_COUNT,
1275     },
1276     [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {
1277         .packing = sja1105_schedule_entry_points_entry_packing,
1278         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_entry),
1279         .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY,
1280         .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_COUNT,
1281     },
1282     [BLK_IDX_VL_LOOKUP] = {
1283         .packing = sja1105_vl_lookup_entry_packing,
1284         .unpacked_entry_size = sizeof(struct sja1105_vl_lookup_entry),
1285         .packed_entry_size = SJA1105_SIZE_VL_LOOKUP_ENTRY,
1286         .max_entry_count = SJA1105_MAX_VL_LOOKUP_COUNT,
1287     },
1288     [BLK_IDX_VL_POLICING] = {
1289         .packing = sja1105_vl_policing_entry_packing,
1290         .unpacked_entry_size = sizeof(struct sja1105_vl_policing_entry),
1291         .packed_entry_size = SJA1105_SIZE_VL_POLICING_ENTRY,
1292         .max_entry_count = SJA1105_MAX_VL_POLICING_COUNT,
1293     },
1294     [BLK_IDX_VL_FORWARDING] = {
1295         .packing = sja1105_vl_forwarding_entry_packing,
1296         .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_entry),
1297         .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_ENTRY,
1298         .max_entry_count = SJA1105_MAX_VL_FORWARDING_COUNT,
1299     },
1300     [BLK_IDX_L2_LOOKUP] = {
1301         .packing = sja1105et_l2_lookup_entry_packing,
1302         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1303         .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_ENTRY,
1304         .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1305     },
1306     [BLK_IDX_L2_POLICING] = {
1307         .packing = sja1105_l2_policing_entry_packing,
1308         .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1309         .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1310         .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1311     },
1312     [BLK_IDX_VLAN_LOOKUP] = {
1313         .packing = sja1105_vlan_lookup_entry_packing,
1314         .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1315         .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1316         .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1317     },
1318     [BLK_IDX_L2_FORWARDING] = {
1319         .packing = sja1105_l2_forwarding_entry_packing,
1320         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1321         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1322         .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1323     },
1324     [BLK_IDX_MAC_CONFIG] = {
1325         .packing = sja1105et_mac_config_entry_packing,
1326         .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1327         .packed_entry_size = SJA1105ET_SIZE_MAC_CONFIG_ENTRY,
1328         .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1329     },
1330     [BLK_IDX_SCHEDULE_PARAMS] = {
1331         .packing = sja1105_schedule_params_entry_packing,
1332         .unpacked_entry_size = sizeof(struct sja1105_schedule_params_entry),
1333         .packed_entry_size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY,
1334         .max_entry_count = SJA1105_MAX_SCHEDULE_PARAMS_COUNT,
1335     },
1336     [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {
1337         .packing = sja1105_schedule_entry_points_params_entry_packing,
1338         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_params_entry),
1339         .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY,
1340         .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_PARAMS_COUNT,
1341     },
1342     [BLK_IDX_VL_FORWARDING_PARAMS] = {
1343         .packing = sja1105_vl_forwarding_params_entry_packing,
1344         .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_params_entry),
1345         .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY,
1346         .max_entry_count = SJA1105_MAX_VL_FORWARDING_PARAMS_COUNT,
1347     },
1348     [BLK_IDX_L2_LOOKUP_PARAMS] = {
1349         .packing = sja1105et_l2_lookup_params_entry_packing,
1350         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1351         .packed_entry_size = SJA1105ET_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1352         .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1353     },
1354     [BLK_IDX_L2_FORWARDING_PARAMS] = {
1355         .packing = sja1105_l2_forwarding_params_entry_packing,
1356         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1357         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1358         .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1359     },
1360     [BLK_IDX_AVB_PARAMS] = {
1361         .packing = sja1105et_avb_params_entry_packing,
1362         .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1363         .packed_entry_size = SJA1105ET_SIZE_AVB_PARAMS_ENTRY,
1364         .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1365     },
1366     [BLK_IDX_GENERAL_PARAMS] = {
1367         .packing = sja1105et_general_params_entry_packing,
1368         .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1369         .packed_entry_size = SJA1105ET_SIZE_GENERAL_PARAMS_ENTRY,
1370         .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1371     },
1372     [BLK_IDX_RETAGGING] = {
1373         .packing = sja1105_retagging_entry_packing,
1374         .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1375         .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1376         .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1377     },
1378     [BLK_IDX_XMII_PARAMS] = {
1379         .packing = sja1105_xmii_params_entry_packing,
1380         .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1381         .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1382         .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1383     },
1384 };
1385 
1386 /* SJA1105P: Second generation, no TTEthernet, no SGMII */
1387 const struct sja1105_table_ops sja1105p_table_ops[BLK_IDX_MAX] = {
1388     [BLK_IDX_L2_LOOKUP] = {
1389         .packing = sja1105pqrs_l2_lookup_entry_packing,
1390         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1391         .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
1392         .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1393     },
1394     [BLK_IDX_L2_POLICING] = {
1395         .packing = sja1105_l2_policing_entry_packing,
1396         .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1397         .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1398         .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1399     },
1400     [BLK_IDX_VLAN_LOOKUP] = {
1401         .packing = sja1105_vlan_lookup_entry_packing,
1402         .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1403         .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1404         .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1405     },
1406     [BLK_IDX_L2_FORWARDING] = {
1407         .packing = sja1105_l2_forwarding_entry_packing,
1408         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1409         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1410         .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1411     },
1412     [BLK_IDX_MAC_CONFIG] = {
1413         .packing = sja1105pqrs_mac_config_entry_packing,
1414         .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1415         .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1416         .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1417     },
1418     [BLK_IDX_L2_LOOKUP_PARAMS] = {
1419         .packing = sja1105pqrs_l2_lookup_params_entry_packing,
1420         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1421         .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1422         .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1423     },
1424     [BLK_IDX_L2_FORWARDING_PARAMS] = {
1425         .packing = sja1105_l2_forwarding_params_entry_packing,
1426         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1427         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1428         .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1429     },
1430     [BLK_IDX_AVB_PARAMS] = {
1431         .packing = sja1105pqrs_avb_params_entry_packing,
1432         .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1433         .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1434         .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1435     },
1436     [BLK_IDX_GENERAL_PARAMS] = {
1437         .packing = sja1105pqrs_general_params_entry_packing,
1438         .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1439         .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
1440         .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1441     },
1442     [BLK_IDX_RETAGGING] = {
1443         .packing = sja1105_retagging_entry_packing,
1444         .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1445         .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1446         .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1447     },
1448     [BLK_IDX_XMII_PARAMS] = {
1449         .packing = sja1105_xmii_params_entry_packing,
1450         .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1451         .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1452         .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1453     },
1454 };
1455 
1456 /* SJA1105Q: Second generation, TTEthernet, no SGMII */
1457 const struct sja1105_table_ops sja1105q_table_ops[BLK_IDX_MAX] = {
1458     [BLK_IDX_SCHEDULE] = {
1459         .packing = sja1105_schedule_entry_packing,
1460         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry),
1461         .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY,
1462         .max_entry_count = SJA1105_MAX_SCHEDULE_COUNT,
1463     },
1464     [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {
1465         .packing = sja1105_schedule_entry_points_entry_packing,
1466         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_entry),
1467         .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY,
1468         .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_COUNT,
1469     },
1470     [BLK_IDX_VL_LOOKUP] = {
1471         .packing = sja1105_vl_lookup_entry_packing,
1472         .unpacked_entry_size = sizeof(struct sja1105_vl_lookup_entry),
1473         .packed_entry_size = SJA1105_SIZE_VL_LOOKUP_ENTRY,
1474         .max_entry_count = SJA1105_MAX_VL_LOOKUP_COUNT,
1475     },
1476     [BLK_IDX_VL_POLICING] = {
1477         .packing = sja1105_vl_policing_entry_packing,
1478         .unpacked_entry_size = sizeof(struct sja1105_vl_policing_entry),
1479         .packed_entry_size = SJA1105_SIZE_VL_POLICING_ENTRY,
1480         .max_entry_count = SJA1105_MAX_VL_POLICING_COUNT,
1481     },
1482     [BLK_IDX_VL_FORWARDING] = {
1483         .packing = sja1105_vl_forwarding_entry_packing,
1484         .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_entry),
1485         .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_ENTRY,
1486         .max_entry_count = SJA1105_MAX_VL_FORWARDING_COUNT,
1487     },
1488     [BLK_IDX_L2_LOOKUP] = {
1489         .packing = sja1105pqrs_l2_lookup_entry_packing,
1490         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1491         .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
1492         .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1493     },
1494     [BLK_IDX_L2_POLICING] = {
1495         .packing = sja1105_l2_policing_entry_packing,
1496         .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1497         .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1498         .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1499     },
1500     [BLK_IDX_VLAN_LOOKUP] = {
1501         .packing = sja1105_vlan_lookup_entry_packing,
1502         .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1503         .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1504         .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1505     },
1506     [BLK_IDX_L2_FORWARDING] = {
1507         .packing = sja1105_l2_forwarding_entry_packing,
1508         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1509         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1510         .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1511     },
1512     [BLK_IDX_MAC_CONFIG] = {
1513         .packing = sja1105pqrs_mac_config_entry_packing,
1514         .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1515         .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1516         .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1517     },
1518     [BLK_IDX_SCHEDULE_PARAMS] = {
1519         .packing = sja1105_schedule_params_entry_packing,
1520         .unpacked_entry_size = sizeof(struct sja1105_schedule_params_entry),
1521         .packed_entry_size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY,
1522         .max_entry_count = SJA1105_MAX_SCHEDULE_PARAMS_COUNT,
1523     },
1524     [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {
1525         .packing = sja1105_schedule_entry_points_params_entry_packing,
1526         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_params_entry),
1527         .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY,
1528         .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_PARAMS_COUNT,
1529     },
1530     [BLK_IDX_VL_FORWARDING_PARAMS] = {
1531         .packing = sja1105_vl_forwarding_params_entry_packing,
1532         .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_params_entry),
1533         .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY,
1534         .max_entry_count = SJA1105_MAX_VL_FORWARDING_PARAMS_COUNT,
1535     },
1536     [BLK_IDX_L2_LOOKUP_PARAMS] = {
1537         .packing = sja1105pqrs_l2_lookup_params_entry_packing,
1538         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1539         .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1540         .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1541     },
1542     [BLK_IDX_L2_FORWARDING_PARAMS] = {
1543         .packing = sja1105_l2_forwarding_params_entry_packing,
1544         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1545         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1546         .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1547     },
1548     [BLK_IDX_AVB_PARAMS] = {
1549         .packing = sja1105pqrs_avb_params_entry_packing,
1550         .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1551         .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1552         .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1553     },
1554     [BLK_IDX_GENERAL_PARAMS] = {
1555         .packing = sja1105pqrs_general_params_entry_packing,
1556         .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1557         .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
1558         .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1559     },
1560     [BLK_IDX_RETAGGING] = {
1561         .packing = sja1105_retagging_entry_packing,
1562         .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1563         .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1564         .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1565     },
1566     [BLK_IDX_XMII_PARAMS] = {
1567         .packing = sja1105_xmii_params_entry_packing,
1568         .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1569         .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1570         .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1571     },
1572 };
1573 
1574 /* SJA1105R: Second generation, no TTEthernet, SGMII */
1575 const struct sja1105_table_ops sja1105r_table_ops[BLK_IDX_MAX] = {
1576     [BLK_IDX_L2_LOOKUP] = {
1577         .packing = sja1105pqrs_l2_lookup_entry_packing,
1578         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1579         .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
1580         .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1581     },
1582     [BLK_IDX_L2_POLICING] = {
1583         .packing = sja1105_l2_policing_entry_packing,
1584         .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1585         .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1586         .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1587     },
1588     [BLK_IDX_VLAN_LOOKUP] = {
1589         .packing = sja1105_vlan_lookup_entry_packing,
1590         .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1591         .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1592         .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1593     },
1594     [BLK_IDX_L2_FORWARDING] = {
1595         .packing = sja1105_l2_forwarding_entry_packing,
1596         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1597         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1598         .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1599     },
1600     [BLK_IDX_MAC_CONFIG] = {
1601         .packing = sja1105pqrs_mac_config_entry_packing,
1602         .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1603         .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1604         .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1605     },
1606     [BLK_IDX_L2_LOOKUP_PARAMS] = {
1607         .packing = sja1105pqrs_l2_lookup_params_entry_packing,
1608         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1609         .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1610         .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1611     },
1612     [BLK_IDX_L2_FORWARDING_PARAMS] = {
1613         .packing = sja1105_l2_forwarding_params_entry_packing,
1614         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1615         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1616         .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1617     },
1618     [BLK_IDX_AVB_PARAMS] = {
1619         .packing = sja1105pqrs_avb_params_entry_packing,
1620         .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1621         .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1622         .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1623     },
1624     [BLK_IDX_GENERAL_PARAMS] = {
1625         .packing = sja1105pqrs_general_params_entry_packing,
1626         .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1627         .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
1628         .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1629     },
1630     [BLK_IDX_RETAGGING] = {
1631         .packing = sja1105_retagging_entry_packing,
1632         .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1633         .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1634         .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1635     },
1636     [BLK_IDX_XMII_PARAMS] = {
1637         .packing = sja1105_xmii_params_entry_packing,
1638         .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1639         .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1640         .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1641     },
1642 };
1643 
1644 /* SJA1105S: Second generation, TTEthernet, SGMII */
1645 const struct sja1105_table_ops sja1105s_table_ops[BLK_IDX_MAX] = {
1646     [BLK_IDX_SCHEDULE] = {
1647         .packing = sja1105_schedule_entry_packing,
1648         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry),
1649         .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY,
1650         .max_entry_count = SJA1105_MAX_SCHEDULE_COUNT,
1651     },
1652     [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {
1653         .packing = sja1105_schedule_entry_points_entry_packing,
1654         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_entry),
1655         .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY,
1656         .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_COUNT,
1657     },
1658     [BLK_IDX_VL_LOOKUP] = {
1659         .packing = sja1105_vl_lookup_entry_packing,
1660         .unpacked_entry_size = sizeof(struct sja1105_vl_lookup_entry),
1661         .packed_entry_size = SJA1105_SIZE_VL_LOOKUP_ENTRY,
1662         .max_entry_count = SJA1105_MAX_VL_LOOKUP_COUNT,
1663     },
1664     [BLK_IDX_VL_POLICING] = {
1665         .packing = sja1105_vl_policing_entry_packing,
1666         .unpacked_entry_size = sizeof(struct sja1105_vl_policing_entry),
1667         .packed_entry_size = SJA1105_SIZE_VL_POLICING_ENTRY,
1668         .max_entry_count = SJA1105_MAX_VL_POLICING_COUNT,
1669     },
1670     [BLK_IDX_VL_FORWARDING] = {
1671         .packing = sja1105_vl_forwarding_entry_packing,
1672         .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_entry),
1673         .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_ENTRY,
1674         .max_entry_count = SJA1105_MAX_VL_FORWARDING_COUNT,
1675     },
1676     [BLK_IDX_L2_LOOKUP] = {
1677         .packing = sja1105pqrs_l2_lookup_entry_packing,
1678         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1679         .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_ENTRY,
1680         .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1681     },
1682     [BLK_IDX_L2_POLICING] = {
1683         .packing = sja1105_l2_policing_entry_packing,
1684         .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1685         .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1686         .max_entry_count = SJA1105_MAX_L2_POLICING_COUNT,
1687     },
1688     [BLK_IDX_VLAN_LOOKUP] = {
1689         .packing = sja1105_vlan_lookup_entry_packing,
1690         .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1691         .packed_entry_size = SJA1105_SIZE_VLAN_LOOKUP_ENTRY,
1692         .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1693     },
1694     [BLK_IDX_L2_FORWARDING] = {
1695         .packing = sja1105_l2_forwarding_entry_packing,
1696         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1697         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1698         .max_entry_count = SJA1105_MAX_L2_FORWARDING_COUNT,
1699     },
1700     [BLK_IDX_MAC_CONFIG] = {
1701         .packing = sja1105pqrs_mac_config_entry_packing,
1702         .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1703         .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1704         .max_entry_count = SJA1105_MAX_MAC_CONFIG_COUNT,
1705     },
1706     [BLK_IDX_SCHEDULE_PARAMS] = {
1707         .packing = sja1105_schedule_params_entry_packing,
1708         .unpacked_entry_size = sizeof(struct sja1105_schedule_params_entry),
1709         .packed_entry_size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY,
1710         .max_entry_count = SJA1105_MAX_SCHEDULE_PARAMS_COUNT,
1711     },
1712     [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {
1713         .packing = sja1105_schedule_entry_points_params_entry_packing,
1714         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_params_entry),
1715         .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY,
1716         .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_PARAMS_COUNT,
1717     },
1718     [BLK_IDX_VL_FORWARDING_PARAMS] = {
1719         .packing = sja1105_vl_forwarding_params_entry_packing,
1720         .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_params_entry),
1721         .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY,
1722         .max_entry_count = SJA1105_MAX_VL_FORWARDING_PARAMS_COUNT,
1723     },
1724     [BLK_IDX_L2_LOOKUP_PARAMS] = {
1725         .packing = sja1105pqrs_l2_lookup_params_entry_packing,
1726         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1727         .packed_entry_size = SJA1105PQRS_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1728         .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1729     },
1730     [BLK_IDX_L2_FORWARDING_PARAMS] = {
1731         .packing = sja1105_l2_forwarding_params_entry_packing,
1732         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1733         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1734         .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1735     },
1736     [BLK_IDX_AVB_PARAMS] = {
1737         .packing = sja1105pqrs_avb_params_entry_packing,
1738         .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1739         .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1740         .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1741     },
1742     [BLK_IDX_GENERAL_PARAMS] = {
1743         .packing = sja1105pqrs_general_params_entry_packing,
1744         .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1745         .packed_entry_size = SJA1105PQRS_SIZE_GENERAL_PARAMS_ENTRY,
1746         .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1747     },
1748     [BLK_IDX_RETAGGING] = {
1749         .packing = sja1105_retagging_entry_packing,
1750         .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1751         .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1752         .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1753     },
1754     [BLK_IDX_XMII_PARAMS] = {
1755         .packing = sja1105_xmii_params_entry_packing,
1756         .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1757         .packed_entry_size = SJA1105_SIZE_XMII_PARAMS_ENTRY,
1758         .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1759     },
1760 };
1761 
1762 /* SJA1110A: Third generation */
1763 const struct sja1105_table_ops sja1110_table_ops[BLK_IDX_MAX] = {
1764     [BLK_IDX_SCHEDULE] = {
1765         .packing = sja1110_schedule_entry_packing,
1766         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry),
1767         .packed_entry_size = SJA1110_SIZE_SCHEDULE_ENTRY,
1768         .max_entry_count = SJA1110_MAX_SCHEDULE_COUNT,
1769     },
1770     [BLK_IDX_SCHEDULE_ENTRY_POINTS] = {
1771         .packing = sja1110_schedule_entry_points_entry_packing,
1772         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_entry),
1773         .packed_entry_size = SJA1110_SIZE_SCHEDULE_ENTRY_POINTS_ENTRY,
1774         .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_COUNT,
1775     },
1776     [BLK_IDX_VL_LOOKUP] = {
1777         .packing = sja1110_vl_lookup_entry_packing,
1778         .unpacked_entry_size = sizeof(struct sja1105_vl_lookup_entry),
1779         .packed_entry_size = SJA1105_SIZE_VL_LOOKUP_ENTRY,
1780         .max_entry_count = SJA1110_MAX_VL_LOOKUP_COUNT,
1781     },
1782     [BLK_IDX_VL_POLICING] = {
1783         .packing = sja1110_vl_policing_entry_packing,
1784         .unpacked_entry_size = sizeof(struct sja1105_vl_policing_entry),
1785         .packed_entry_size = SJA1105_SIZE_VL_POLICING_ENTRY,
1786         .max_entry_count = SJA1110_MAX_VL_POLICING_COUNT,
1787     },
1788     [BLK_IDX_VL_FORWARDING] = {
1789         .packing = sja1110_vl_forwarding_entry_packing,
1790         .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_entry),
1791         .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_ENTRY,
1792         .max_entry_count = SJA1110_MAX_VL_FORWARDING_COUNT,
1793     },
1794     [BLK_IDX_L2_LOOKUP] = {
1795         .packing = sja1110_l2_lookup_entry_packing,
1796         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_entry),
1797         .packed_entry_size = SJA1110_SIZE_L2_LOOKUP_ENTRY,
1798         .max_entry_count = SJA1105_MAX_L2_LOOKUP_COUNT,
1799     },
1800     [BLK_IDX_L2_POLICING] = {
1801         .packing = sja1110_l2_policing_entry_packing,
1802         .unpacked_entry_size = sizeof(struct sja1105_l2_policing_entry),
1803         .packed_entry_size = SJA1105_SIZE_L2_POLICING_ENTRY,
1804         .max_entry_count = SJA1110_MAX_L2_POLICING_COUNT,
1805     },
1806     [BLK_IDX_VLAN_LOOKUP] = {
1807         .packing = sja1110_vlan_lookup_entry_packing,
1808         .unpacked_entry_size = sizeof(struct sja1105_vlan_lookup_entry),
1809         .packed_entry_size = SJA1110_SIZE_VLAN_LOOKUP_ENTRY,
1810         .max_entry_count = SJA1105_MAX_VLAN_LOOKUP_COUNT,
1811     },
1812     [BLK_IDX_L2_FORWARDING] = {
1813         .packing = sja1110_l2_forwarding_entry_packing,
1814         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_entry),
1815         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_ENTRY,
1816         .max_entry_count = SJA1110_MAX_L2_FORWARDING_COUNT,
1817     },
1818     [BLK_IDX_MAC_CONFIG] = {
1819         .packing = sja1110_mac_config_entry_packing,
1820         .unpacked_entry_size = sizeof(struct sja1105_mac_config_entry),
1821         .packed_entry_size = SJA1105PQRS_SIZE_MAC_CONFIG_ENTRY,
1822         .max_entry_count = SJA1110_MAX_MAC_CONFIG_COUNT,
1823     },
1824     [BLK_IDX_SCHEDULE_PARAMS] = {
1825         .packing = sja1110_schedule_params_entry_packing,
1826         .unpacked_entry_size = sizeof(struct sja1105_schedule_params_entry),
1827         .packed_entry_size = SJA1105_SIZE_SCHEDULE_PARAMS_ENTRY,
1828         .max_entry_count = SJA1105_MAX_SCHEDULE_PARAMS_COUNT,
1829     },
1830     [BLK_IDX_SCHEDULE_ENTRY_POINTS_PARAMS] = {
1831         .packing = sja1105_schedule_entry_points_params_entry_packing,
1832         .unpacked_entry_size = sizeof(struct sja1105_schedule_entry_points_params_entry),
1833         .packed_entry_size = SJA1105_SIZE_SCHEDULE_ENTRY_POINTS_PARAMS_ENTRY,
1834         .max_entry_count = SJA1105_MAX_SCHEDULE_ENTRY_POINTS_PARAMS_COUNT,
1835     },
1836     [BLK_IDX_VL_FORWARDING_PARAMS] = {
1837         .packing = sja1110_vl_forwarding_params_entry_packing,
1838         .unpacked_entry_size = sizeof(struct sja1105_vl_forwarding_params_entry),
1839         .packed_entry_size = SJA1105_SIZE_VL_FORWARDING_PARAMS_ENTRY,
1840         .max_entry_count = SJA1105_MAX_VL_FORWARDING_PARAMS_COUNT,
1841     },
1842     [BLK_IDX_L2_LOOKUP_PARAMS] = {
1843         .packing = sja1110_l2_lookup_params_entry_packing,
1844         .unpacked_entry_size = sizeof(struct sja1105_l2_lookup_params_entry),
1845         .packed_entry_size = SJA1110_SIZE_L2_LOOKUP_PARAMS_ENTRY,
1846         .max_entry_count = SJA1105_MAX_L2_LOOKUP_PARAMS_COUNT,
1847     },
1848     [BLK_IDX_L2_FORWARDING_PARAMS] = {
1849         .packing = sja1110_l2_forwarding_params_entry_packing,
1850         .unpacked_entry_size = sizeof(struct sja1105_l2_forwarding_params_entry),
1851         .packed_entry_size = SJA1105_SIZE_L2_FORWARDING_PARAMS_ENTRY,
1852         .max_entry_count = SJA1105_MAX_L2_FORWARDING_PARAMS_COUNT,
1853     },
1854     [BLK_IDX_AVB_PARAMS] = {
1855         .packing = sja1105pqrs_avb_params_entry_packing,
1856         .unpacked_entry_size = sizeof(struct sja1105_avb_params_entry),
1857         .packed_entry_size = SJA1105PQRS_SIZE_AVB_PARAMS_ENTRY,
1858         .max_entry_count = SJA1105_MAX_AVB_PARAMS_COUNT,
1859     },
1860     [BLK_IDX_GENERAL_PARAMS] = {
1861         .packing = sja1110_general_params_entry_packing,
1862         .unpacked_entry_size = sizeof(struct sja1105_general_params_entry),
1863         .packed_entry_size = SJA1110_SIZE_GENERAL_PARAMS_ENTRY,
1864         .max_entry_count = SJA1105_MAX_GENERAL_PARAMS_COUNT,
1865     },
1866     [BLK_IDX_RETAGGING] = {
1867         .packing = sja1110_retagging_entry_packing,
1868         .unpacked_entry_size = sizeof(struct sja1105_retagging_entry),
1869         .packed_entry_size = SJA1105_SIZE_RETAGGING_ENTRY,
1870         .max_entry_count = SJA1105_MAX_RETAGGING_COUNT,
1871     },
1872     [BLK_IDX_XMII_PARAMS] = {
1873         .packing = sja1110_xmii_params_entry_packing,
1874         .unpacked_entry_size = sizeof(struct sja1105_xmii_params_entry),
1875         .packed_entry_size = SJA1110_SIZE_XMII_PARAMS_ENTRY,
1876         .max_entry_count = SJA1105_MAX_XMII_PARAMS_COUNT,
1877     },
1878     [BLK_IDX_PCP_REMAPPING] = {
1879         .packing = sja1110_pcp_remapping_entry_packing,
1880         .unpacked_entry_size = sizeof(struct sja1110_pcp_remapping_entry),
1881         .packed_entry_size = SJA1110_SIZE_PCP_REMAPPING_ENTRY,
1882         .max_entry_count = SJA1110_MAX_PCP_REMAPPING_COUNT,
1883     },
1884 };
1885 
1886 int sja1105_static_config_init(struct sja1105_static_config *config,
1887                    const struct sja1105_table_ops *static_ops,
1888                    u64 device_id)
1889 {
1890     enum sja1105_blk_idx i;
1891 
1892     *config = (struct sja1105_static_config) {0};
1893 
1894     /* Transfer static_ops array from priv into per-table ops
1895      * for handier access
1896      */
1897     for (i = 0; i < BLK_IDX_MAX; i++)
1898         config->tables[i].ops = &static_ops[i];
1899 
1900     config->device_id = device_id;
1901     return 0;
1902 }
1903 
1904 void sja1105_static_config_free(struct sja1105_static_config *config)
1905 {
1906     enum sja1105_blk_idx i;
1907 
1908     for (i = 0; i < BLK_IDX_MAX; i++) {
1909         if (config->tables[i].entry_count) {
1910             kfree(config->tables[i].entries);
1911             config->tables[i].entry_count = 0;
1912         }
1913     }
1914 }
1915 
1916 int sja1105_table_delete_entry(struct sja1105_table *table, int i)
1917 {
1918     size_t entry_size = table->ops->unpacked_entry_size;
1919     u8 *entries = table->entries;
1920 
1921     if (i > table->entry_count)
1922         return -ERANGE;
1923 
1924     memmove(entries + i * entry_size, entries + (i + 1) * entry_size,
1925         (table->entry_count - i) * entry_size);
1926 
1927     table->entry_count--;
1928 
1929     return 0;
1930 }
1931 
1932 /* No pointers to table->entries should be kept when this is called. */
1933 int sja1105_table_resize(struct sja1105_table *table, size_t new_count)
1934 {
1935     size_t entry_size = table->ops->unpacked_entry_size;
1936     void *new_entries, *old_entries = table->entries;
1937 
1938     if (new_count > table->ops->max_entry_count)
1939         return -ERANGE;
1940 
1941     new_entries = kcalloc(new_count, entry_size, GFP_KERNEL);
1942     if (!new_entries)
1943         return -ENOMEM;
1944 
1945     memcpy(new_entries, old_entries, min(new_count, table->entry_count) *
1946         entry_size);
1947 
1948     table->entries = new_entries;
1949     table->entry_count = new_count;
1950     kfree(old_entries);
1951     return 0;
1952 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!