1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /* Copyright (c) 2018 Mellanox Technologies. All rights reserved */
3
4 #include <linux/errno.h>
5 #include <linux/gfp.h>
6 #include <linux/kernel.h>
7 #include <linux/refcount.h>
8 #include <linux/mutex.h>
9
10 #include "spectrum.h"
11 #include "spectrum_acl_tcam.h"
12
13 struct mlxsw_sp_acl_bf {
14 struct mutex lock; /* Protects Bloom Filter updates. */
15 unsigned int bank_size;
16 refcount_t refcnt[];
17 };
18
19 /* Bloom filter uses a crc-16 hash over chunks of data which contain 4 key
20 * blocks, eRP ID and region ID. In Spectrum-2 and above, region key is combined
21 * of up to 12 key blocks, so there can be up to 3 chunks in the Bloom filter
22 * key, depending on the actual number of key blocks used in the region.
23 * The layout of the Bloom filter key is as follows:
24 *
25 * +-------------------------+------------------------+------------------------+
26 * | Chunk 2 Key blocks 11-8 | Chunk 1 Key blocks 7-4 | Chunk 0 Key blocks 3-0 |
27 * +-------------------------+------------------------+------------------------+
28 */
29 #define MLXSW_BLOOM_KEY_CHUNKS 3
30
31 /* Spectrum-2 and Spectrum-3 chunks */
32 #define MLXSW_SP2_BLOOM_KEY_LEN 69
33
34 /* Each chunk size is 23 bytes. 18 bytes of it contain 4 key blocks, each is
35 * 36 bits, 2 bytes which hold eRP ID and region ID, and 3 bytes of zero
36 * padding.
37 * The layout of each chunk is as follows:
38 *
39 * +---------+----------------------+-----------------------------------+
40 * | 3 bytes | 2 bytes | 18 bytes |
41 * +---------+-----------+----------+-----------------------------------+
42 * | 183:158 | 157:148 | 147:144 | 143:0 |
43 * +---------+-----------+----------+-----------------------------------+
44 * | 0 | region ID | eRP ID | 4 Key blocks (18 Bytes) |
45 * +---------+-----------+----------+-----------------------------------+
46 */
47 #define MLXSW_SP2_BLOOM_CHUNK_PAD_BYTES 3
48 #define MLXSW_SP2_BLOOM_CHUNK_KEY_BYTES 18
49 #define MLXSW_SP2_BLOOM_KEY_CHUNK_BYTES 23
50
51 /* The offset of the key block within a chunk is 5 bytes as it comes after
52 * 3 bytes of zero padding and 16 bits of region ID and eRP ID.
53 */
54 #define MLXSW_SP2_BLOOM_CHUNK_KEY_OFFSET 5
55
56 /* This table is just the CRC of each possible byte which is used for
57 * Spectrum-{2-3}. It is computed, Msbit first, for the Bloom filter
58 * polynomial which is 0x8529 (1 + x^3 + x^5 + x^8 + x^10 + x^15 and
59 * the implicit x^16).
60 */
61 static const u16 mlxsw_sp2_acl_bf_crc16_tab[256] = {
62 0x0000, 0x8529, 0x8f7b, 0x0a52, 0x9bdf, 0x1ef6, 0x14a4, 0x918d,
63 0xb297, 0x37be, 0x3dec, 0xb8c5, 0x2948, 0xac61, 0xa633, 0x231a,
64 0xe007, 0x652e, 0x6f7c, 0xea55, 0x7bd8, 0xfef1, 0xf4a3, 0x718a,
65 0x5290, 0xd7b9, 0xddeb, 0x58c2, 0xc94f, 0x4c66, 0x4634, 0xc31d,
66 0x4527, 0xc00e, 0xca5c, 0x4f75, 0xdef8, 0x5bd1, 0x5183, 0xd4aa,
67 0xf7b0, 0x7299, 0x78cb, 0xfde2, 0x6c6f, 0xe946, 0xe314, 0x663d,
68 0xa520, 0x2009, 0x2a5b, 0xaf72, 0x3eff, 0xbbd6, 0xb184, 0x34ad,
69 0x17b7, 0x929e, 0x98cc, 0x1de5, 0x8c68, 0x0941, 0x0313, 0x863a,
70 0x8a4e, 0x0f67, 0x0535, 0x801c, 0x1191, 0x94b8, 0x9eea, 0x1bc3,
71 0x38d9, 0xbdf0, 0xb7a2, 0x328b, 0xa306, 0x262f, 0x2c7d, 0xa954,
72 0x6a49, 0xef60, 0xe532, 0x601b, 0xf196, 0x74bf, 0x7eed, 0xfbc4,
73 0xd8de, 0x5df7, 0x57a5, 0xd28c, 0x4301, 0xc628, 0xcc7a, 0x4953,
74 0xcf69, 0x4a40, 0x4012, 0xc53b, 0x54b6, 0xd19f, 0xdbcd, 0x5ee4,
75 0x7dfe, 0xf8d7, 0xf285, 0x77ac, 0xe621, 0x6308, 0x695a, 0xec73,
76 0x2f6e, 0xaa47, 0xa015, 0x253c, 0xb4b1, 0x3198, 0x3bca, 0xbee3,
77 0x9df9, 0x18d0, 0x1282, 0x97ab, 0x0626, 0x830f, 0x895d, 0x0c74,
78 0x91b5, 0x149c, 0x1ece, 0x9be7, 0x0a6a, 0x8f43, 0x8511, 0x0038,
79 0x2322, 0xa60b, 0xac59, 0x2970, 0xb8fd, 0x3dd4, 0x3786, 0xb2af,
80 0x71b2, 0xf49b, 0xfec9, 0x7be0, 0xea6d, 0x6f44, 0x6516, 0xe03f,
81 0xc325, 0x460c, 0x4c5e, 0xc977, 0x58fa, 0xddd3, 0xd781, 0x52a8,
82 0xd492, 0x51bb, 0x5be9, 0xdec0, 0x4f4d, 0xca64, 0xc036, 0x451f,
83 0x6605, 0xe32c, 0xe97e, 0x6c57, 0xfdda, 0x78f3, 0x72a1, 0xf788,
84 0x3495, 0xb1bc, 0xbbee, 0x3ec7, 0xaf4a, 0x2a63, 0x2031, 0xa518,
85 0x8602, 0x032b, 0x0979, 0x8c50, 0x1ddd, 0x98f4, 0x92a6, 0x178f,
86 0x1bfb, 0x9ed2, 0x9480, 0x11a9, 0x8024, 0x050d, 0x0f5f, 0x8a76,
87 0xa96c, 0x2c45, 0x2617, 0xa33e, 0x32b3, 0xb79a, 0xbdc8, 0x38e1,
88 0xfbfc, 0x7ed5, 0x7487, 0xf1ae, 0x6023, 0xe50a, 0xef58, 0x6a71,
89 0x496b, 0xcc42, 0xc610, 0x4339, 0xd2b4, 0x579d, 0x5dcf, 0xd8e6,
90 0x5edc, 0xdbf5, 0xd1a7, 0x548e, 0xc503, 0x402a, 0x4a78, 0xcf51,
91 0xec4b, 0x6962, 0x6330, 0xe619, 0x7794, 0xf2bd, 0xf8ef, 0x7dc6,
92 0xbedb, 0x3bf2, 0x31a0, 0xb489, 0x2504, 0xa02d, 0xaa7f, 0x2f56,
93 0x0c4c, 0x8965, 0x8337, 0x061e, 0x9793, 0x12ba, 0x18e8, 0x9dc1,
94 };
95
96 /* Spectrum-4 chunks */
97 #define MLXSW_SP4_BLOOM_KEY_LEN 60
98
99 /* In Spectrum-4, there is no padding. Each chunk size is 20 bytes.
100 * 18 bytes of it contain 4 key blocks, each is 36 bits, and 2 bytes which hold
101 * eRP ID and region ID.
102 * The layout of each chunk is as follows:
103 *
104 * +----------------------+-----------------------------------+
105 * | 2 bytes | 18 bytes |
106 * +-----------+----------+-----------------------------------+
107 * | 157:148 | 147:144 | 143:0 |
108 * +---------+-----------+----------+-------------------------+
109 * | region ID | eRP ID | 4 Key blocks (18 Bytes) |
110 * +-----------+----------+-----------------------------------+
111 */
112
113 #define MLXSW_SP4_BLOOM_CHUNK_PAD_BYTES 0
114 #define MLXSW_SP4_BLOOM_CHUNK_KEY_BYTES 18
115 #define MLXSW_SP4_BLOOM_KEY_CHUNK_BYTES 20
116
117 /* The offset of the key block within a chunk is 2 bytes as it comes after
118 * 16 bits of region ID and eRP ID.
119 */
120 #define MLXSW_SP4_BLOOM_CHUNK_KEY_OFFSET 2
121
122 /* For Spectrum-4, two hash functions are used, CRC-10 and CRC-6 based.
123 * The result is combination of the two calculations -
124 * 6 bit column are MSB (result of CRC-6),
125 * 10 bit row are LSB (result of CRC-10).
126 */
127
128 /* This table is just the CRC of each possible byte which is used for
129 * Spectrum-4. It is computed, Msbit first, for the Bloom filter
130 * polynomial which is 0x1b (1 + x^1 + x^3 + x^4 and the implicit x^10).
131 */
132 static const u16 mlxsw_sp4_acl_bf_crc10_tab[256] = {
133 0x0000, 0x001b, 0x0036, 0x002d, 0x006c, 0x0077, 0x005a, 0x0041,
134 0x00d8, 0x00c3, 0x00ee, 0x00f5, 0x00b4, 0x00af, 0x0082, 0x0099,
135 0x01b0, 0x01ab, 0x0186, 0x019d, 0x01dc, 0x01c7, 0x01ea, 0x01f1,
136 0x0168, 0x0173, 0x015e, 0x0145, 0x0104, 0x011f, 0x0132, 0x0129,
137 0x0360, 0x037b, 0x0356, 0x034d, 0x030c, 0x0317, 0x033a, 0x0321,
138 0x03b8, 0x03a3, 0x038e, 0x0395, 0x03d4, 0x03cf, 0x03e2, 0x03f9,
139 0x02d0, 0x02cb, 0x02e6, 0x02fd, 0x02bc, 0x02a7, 0x028a, 0x0291,
140 0x0208, 0x0213, 0x023e, 0x0225, 0x0264, 0x027f, 0x0252, 0x0249,
141 0x02db, 0x02c0, 0x02ed, 0x02f6, 0x02b7, 0x02ac, 0x0281, 0x029a,
142 0x0203, 0x0218, 0x0235, 0x022e, 0x026f, 0x0274, 0x0259, 0x0242,
143 0x036b, 0x0370, 0x035d, 0x0346, 0x0307, 0x031c, 0x0331, 0x032a,
144 0x03b3, 0x03a8, 0x0385, 0x039e, 0x03df, 0x03c4, 0x03e9, 0x03f2,
145 0x01bb, 0x01a0, 0x018d, 0x0196, 0x01d7, 0x01cc, 0x01e1, 0x01fa,
146 0x0163, 0x0178, 0x0155, 0x014e, 0x010f, 0x0114, 0x0139, 0x0122,
147 0x000b, 0x0010, 0x003d, 0x0026, 0x0067, 0x007c, 0x0051, 0x004a,
148 0x00d3, 0x00c8, 0x00e5, 0x00fe, 0x00bf, 0x00a4, 0x0089, 0x0092,
149 0x01ad, 0x01b6, 0x019b, 0x0180, 0x01c1, 0x01da, 0x01f7, 0x01ec,
150 0x0175, 0x016e, 0x0143, 0x0158, 0x0119, 0x0102, 0x012f, 0x0134,
151 0x001d, 0x0006, 0x002b, 0x0030, 0x0071, 0x006a, 0x0047, 0x005c,
152 0x00c5, 0x00de, 0x00f3, 0x00e8, 0x00a9, 0x00b2, 0x009f, 0x0084,
153 0x02cd, 0x02d6, 0x02fb, 0x02e0, 0x02a1, 0x02ba, 0x0297, 0x028c,
154 0x0215, 0x020e, 0x0223, 0x0238, 0x0279, 0x0262, 0x024f, 0x0254,
155 0x037d, 0x0366, 0x034b, 0x0350, 0x0311, 0x030a, 0x0327, 0x033c,
156 0x03a5, 0x03be, 0x0393, 0x0388, 0x03c9, 0x03d2, 0x03ff, 0x03e4,
157 0x0376, 0x036d, 0x0340, 0x035b, 0x031a, 0x0301, 0x032c, 0x0337,
158 0x03ae, 0x03b5, 0x0398, 0x0383, 0x03c2, 0x03d9, 0x03f4, 0x03ef,
159 0x02c6, 0x02dd, 0x02f0, 0x02eb, 0x02aa, 0x02b1, 0x029c, 0x0287,
160 0x021e, 0x0205, 0x0228, 0x0233, 0x0272, 0x0269, 0x0244, 0x025f,
161 0x0016, 0x000d, 0x0020, 0x003b, 0x007a, 0x0061, 0x004c, 0x0057,
162 0x00ce, 0x00d5, 0x00f8, 0x00e3, 0x00a2, 0x00b9, 0x0094, 0x008f,
163 0x01a6, 0x01bd, 0x0190, 0x018b, 0x01ca, 0x01d1, 0x01fc, 0x01e7,
164 0x017e, 0x0165, 0x0148, 0x0153, 0x0112, 0x0109, 0x0124, 0x013f,
165 };
166
167 /* This table is just the CRC of each possible byte which is used for
168 * Spectrum-4. It is computed, Msbit first, for the Bloom filter
169 * polynomial which is 0x2d (1 + x^2+ x^3 + x^5 and the implicit x^6).
170 */
171 static const u8 mlxsw_sp4_acl_bf_crc6_tab[256] = {
172 0x00, 0x2d, 0x37, 0x1a, 0x03, 0x2e, 0x34, 0x19,
173 0x06, 0x2b, 0x31, 0x1c, 0x05, 0x28, 0x32, 0x1f,
174 0x0c, 0x21, 0x3b, 0x16, 0x0f, 0x22, 0x38, 0x15,
175 0x0a, 0x27, 0x3d, 0x10, 0x09, 0x24, 0x3e, 0x13,
176 0x18, 0x35, 0x2f, 0x02, 0x1b, 0x36, 0x2c, 0x01,
177 0x1e, 0x33, 0x29, 0x04, 0x1d, 0x30, 0x2a, 0x07,
178 0x14, 0x39, 0x23, 0x0e, 0x17, 0x3a, 0x20, 0x0d,
179 0x12, 0x3f, 0x25, 0x08, 0x11, 0x3c, 0x26, 0x0b,
180 0x30, 0x1d, 0x07, 0x2a, 0x33, 0x1e, 0x04, 0x29,
181 0x36, 0x1b, 0x01, 0x2c, 0x35, 0x18, 0x02, 0x2f,
182 0x3c, 0x11, 0x0b, 0x26, 0x3f, 0x12, 0x08, 0x25,
183 0x3a, 0x17, 0x0d, 0x20, 0x39, 0x14, 0x0e, 0x23,
184 0x28, 0x05, 0x1f, 0x32, 0x2b, 0x06, 0x1c, 0x31,
185 0x2e, 0x03, 0x19, 0x34, 0x2d, 0x00, 0x1a, 0x37,
186 0x24, 0x09, 0x13, 0x3e, 0x27, 0x0a, 0x10, 0x3d,
187 0x22, 0x0f, 0x15, 0x38, 0x21, 0x0c, 0x16, 0x3b,
188 0x0d, 0x20, 0x3a, 0x17, 0x0e, 0x23, 0x39, 0x14,
189 0x0b, 0x26, 0x3c, 0x11, 0x08, 0x25, 0x3f, 0x12,
190 0x01, 0x2c, 0x36, 0x1b, 0x02, 0x2f, 0x35, 0x18,
191 0x07, 0x2a, 0x30, 0x1d, 0x04, 0x29, 0x33, 0x1e,
192 0x15, 0x38, 0x22, 0x0f, 0x16, 0x3b, 0x21, 0x0c,
193 0x13, 0x3e, 0x24, 0x09, 0x10, 0x3d, 0x27, 0x0a,
194 0x19, 0x34, 0x2e, 0x03, 0x1a, 0x37, 0x2d, 0x00,
195 0x1f, 0x32, 0x28, 0x05, 0x1c, 0x31, 0x2b, 0x06,
196 0x3d, 0x10, 0x0a, 0x27, 0x3e, 0x13, 0x09, 0x24,
197 0x3b, 0x16, 0x0c, 0x21, 0x38, 0x15, 0x0f, 0x22,
198 0x31, 0x1c, 0x06, 0x2b, 0x32, 0x1f, 0x05, 0x28,
199 0x37, 0x1a, 0x00, 0x2d, 0x34, 0x19, 0x03, 0x2e,
200 0x25, 0x08, 0x12, 0x3f, 0x26, 0x0b, 0x11, 0x3c,
201 0x23, 0x0e, 0x14, 0x39, 0x20, 0x0d, 0x17, 0x3a,
202 0x29, 0x04, 0x1e, 0x33, 0x2a, 0x07, 0x1d, 0x30,
203 0x2f, 0x02, 0x18, 0x35, 0x2c, 0x01, 0x1b, 0x36,
204 };
205
206 /* Each chunk contains 4 key blocks. Chunk 2 uses key blocks 11-8,
207 * and we need to populate it with 4 key blocks copied from the entry encoded
208 * key. The original keys layout is same for Spectrum-{2,3,4}.
209 * Since the encoded key contains a 2 bytes padding, key block 11 starts at
210 * offset 2. block 7 that is used in chunk 1 starts at offset 20 as 4 key blocks
211 * take 18 bytes. See 'MLXSW_SP2_AFK_BLOCK_LAYOUT' for more details.
212 * This array defines key offsets for easy access when copying key blocks from
213 * entry key to Bloom filter chunk.
214 */
215 static const u8 chunk_key_offsets[MLXSW_BLOOM_KEY_CHUNKS] = {2, 20, 38};
216
mlxsw_sp2_acl_bf_crc16_byte(u16 crc,u8 c)217 static u16 mlxsw_sp2_acl_bf_crc16_byte(u16 crc, u8 c)
218 {
219 return (crc << 8) ^ mlxsw_sp2_acl_bf_crc16_tab[(crc >> 8) ^ c];
220 }
221
mlxsw_sp2_acl_bf_crc(const u8 * buffer,size_t len)222 static u16 mlxsw_sp2_acl_bf_crc(const u8 *buffer, size_t len)
223 {
224 u16 crc = 0;
225
226 while (len--)
227 crc = mlxsw_sp2_acl_bf_crc16_byte(crc, *buffer++);
228 return crc;
229 }
230
231 static void
__mlxsw_sp_acl_bf_key_encode(struct mlxsw_sp_acl_atcam_region * aregion,struct mlxsw_sp_acl_atcam_entry * aentry,char * output,u8 * len,u8 max_chunks,u8 pad_bytes,u8 key_offset,u8 chunk_key_len,u8 chunk_len)232 __mlxsw_sp_acl_bf_key_encode(struct mlxsw_sp_acl_atcam_region *aregion,
233 struct mlxsw_sp_acl_atcam_entry *aentry,
234 char *output, u8 *len, u8 max_chunks, u8 pad_bytes,
235 u8 key_offset, u8 chunk_key_len, u8 chunk_len)
236 {
237 struct mlxsw_afk_key_info *key_info = aregion->region->key_info;
238 u8 chunk_index, chunk_count, block_count;
239 char *chunk = output;
240 __be16 erp_region_id;
241
242 block_count = mlxsw_afk_key_info_blocks_count_get(key_info);
243 chunk_count = 1 + ((block_count - 1) >> 2);
244 erp_region_id = cpu_to_be16(aentry->ht_key.erp_id |
245 (aregion->region->id << 4));
246 for (chunk_index = max_chunks - chunk_count; chunk_index < max_chunks;
247 chunk_index++) {
248 memset(chunk, 0, pad_bytes);
249 memcpy(chunk + pad_bytes, &erp_region_id,
250 sizeof(erp_region_id));
251 memcpy(chunk + key_offset,
252 &aentry->ht_key.enc_key[chunk_key_offsets[chunk_index]],
253 chunk_key_len);
254 chunk += chunk_len;
255 }
256 *len = chunk_count * chunk_len;
257 }
258
259 static void
mlxsw_sp2_acl_bf_key_encode(struct mlxsw_sp_acl_atcam_region * aregion,struct mlxsw_sp_acl_atcam_entry * aentry,char * output,u8 * len)260 mlxsw_sp2_acl_bf_key_encode(struct mlxsw_sp_acl_atcam_region *aregion,
261 struct mlxsw_sp_acl_atcam_entry *aentry,
262 char *output, u8 *len)
263 {
264 __mlxsw_sp_acl_bf_key_encode(aregion, aentry, output, len,
265 MLXSW_BLOOM_KEY_CHUNKS,
266 MLXSW_SP2_BLOOM_CHUNK_PAD_BYTES,
267 MLXSW_SP2_BLOOM_CHUNK_KEY_OFFSET,
268 MLXSW_SP2_BLOOM_CHUNK_KEY_BYTES,
269 MLXSW_SP2_BLOOM_KEY_CHUNK_BYTES);
270 }
271
272 static unsigned int
mlxsw_sp2_acl_bf_index_get(struct mlxsw_sp_acl_bf * bf,struct mlxsw_sp_acl_atcam_region * aregion,struct mlxsw_sp_acl_atcam_entry * aentry)273 mlxsw_sp2_acl_bf_index_get(struct mlxsw_sp_acl_bf *bf,
274 struct mlxsw_sp_acl_atcam_region *aregion,
275 struct mlxsw_sp_acl_atcam_entry *aentry)
276 {
277 char bf_key[MLXSW_SP2_BLOOM_KEY_LEN];
278 u8 bf_size;
279
280 mlxsw_sp2_acl_bf_key_encode(aregion, aentry, bf_key, &bf_size);
281 return mlxsw_sp2_acl_bf_crc(bf_key, bf_size);
282 }
283
mlxsw_sp4_acl_bf_crc10_byte(u16 crc,u8 c)284 static u16 mlxsw_sp4_acl_bf_crc10_byte(u16 crc, u8 c)
285 {
286 u8 index = ((crc >> 2) ^ c) & 0xff;
287
288 return ((crc << 8) ^ mlxsw_sp4_acl_bf_crc10_tab[index]) & 0x3ff;
289 }
290
mlxsw_sp4_acl_bf_crc6_byte(u16 crc,u8 c)291 static u16 mlxsw_sp4_acl_bf_crc6_byte(u16 crc, u8 c)
292 {
293 u8 index = (crc ^ c) & 0xff;
294
295 return ((crc << 6) ^ (mlxsw_sp4_acl_bf_crc6_tab[index] << 2)) & 0xfc;
296 }
297
mlxsw_sp4_acl_bf_crc(const u8 * buffer,size_t len)298 static u16 mlxsw_sp4_acl_bf_crc(const u8 *buffer, size_t len)
299 {
300 u16 crc_row = 0, crc_col = 0;
301
302 while (len--) {
303 crc_row = mlxsw_sp4_acl_bf_crc10_byte(crc_row, *buffer);
304 crc_col = mlxsw_sp4_acl_bf_crc6_byte(crc_col, *buffer);
305 buffer++;
306 }
307
308 crc_col >>= 2;
309
310 /* 6 bit column are MSB, 10 bit row are LSB */
311 return (crc_col << 10) | crc_row;
312 }
313
right_shift_array(char * arr,u8 len,u8 shift_bits)314 static void right_shift_array(char *arr, u8 len, u8 shift_bits)
315 {
316 u8 byte_mask = 0xff >> shift_bits;
317 int i;
318
319 if (WARN_ON(!shift_bits || shift_bits >= 8))
320 return;
321
322 for (i = len - 1; i >= 0; i--) {
323 /* The first iteration looks like out-of-bounds access,
324 * but actually references a buffer that the array is shifted
325 * into. This move is legal as we never send the last chunk to
326 * this function.
327 */
328 arr[i + 1] &= byte_mask;
329 arr[i + 1] |= arr[i] << (8 - shift_bits);
330 arr[i] = arr[i] >> shift_bits;
331 }
332 }
333
mlxsw_sp4_bf_key_shift_chunks(u8 chunk_count,char * output)334 static void mlxsw_sp4_bf_key_shift_chunks(u8 chunk_count, char *output)
335 {
336 /* The chunks are suppoosed to be continuous, with no padding.
337 * Since region ID and eRP ID use 14 bits, and not fully 2 bytes,
338 * and in Spectrum-4 there is no padding, it is necessary to shift some
339 * chunks 2 bits right.
340 */
341 switch (chunk_count) {
342 case 2:
343 /* The chunks are copied as follow:
344 * +-------------+-----------------+
345 * | Chunk 0 | Chunk 1 |
346 * | IDs | keys |(**) IDs | keys |
347 * +-------------+-----------------+
348 * In (**), there are two unused bits, therefore, chunk 0 needs
349 * to be shifted two bits right.
350 */
351 right_shift_array(output, MLXSW_SP4_BLOOM_KEY_CHUNK_BYTES, 2);
352 break;
353 case 3:
354 /* The chunks are copied as follow:
355 * +-------------+-----------------+-----------------+
356 * | Chunk 0 | Chunk 1 | Chunk 2 |
357 * | IDs | keys |(**) IDs | keys |(**) IDs | keys |
358 * +-------------+-----------------+-----------------+
359 * In (**), there are two unused bits, therefore, chunk 1 needs
360 * to be shifted two bits right and chunk 0 needs to be shifted
361 * four bits right.
362 */
363 right_shift_array(output + MLXSW_SP4_BLOOM_KEY_CHUNK_BYTES,
364 MLXSW_SP4_BLOOM_KEY_CHUNK_BYTES, 2);
365 right_shift_array(output, MLXSW_SP4_BLOOM_KEY_CHUNK_BYTES, 4);
366 break;
367 default:
368 WARN_ON(chunk_count > MLXSW_BLOOM_KEY_CHUNKS);
369 }
370 }
371
372 static void
mlxsw_sp4_acl_bf_key_encode(struct mlxsw_sp_acl_atcam_region * aregion,struct mlxsw_sp_acl_atcam_entry * aentry,char * output,u8 * len)373 mlxsw_sp4_acl_bf_key_encode(struct mlxsw_sp_acl_atcam_region *aregion,
374 struct mlxsw_sp_acl_atcam_entry *aentry,
375 char *output, u8 *len)
376 {
377 struct mlxsw_afk_key_info *key_info = aregion->region->key_info;
378 u8 block_count = mlxsw_afk_key_info_blocks_count_get(key_info);
379 u8 chunk_count = 1 + ((block_count - 1) >> 2);
380
381 __mlxsw_sp_acl_bf_key_encode(aregion, aentry, output, len,
382 MLXSW_BLOOM_KEY_CHUNKS,
383 MLXSW_SP4_BLOOM_CHUNK_PAD_BYTES,
384 MLXSW_SP4_BLOOM_CHUNK_KEY_OFFSET,
385 MLXSW_SP4_BLOOM_CHUNK_KEY_BYTES,
386 MLXSW_SP4_BLOOM_KEY_CHUNK_BYTES);
387 mlxsw_sp4_bf_key_shift_chunks(chunk_count, output);
388 }
389
390 static unsigned int
mlxsw_sp4_acl_bf_index_get(struct mlxsw_sp_acl_bf * bf,struct mlxsw_sp_acl_atcam_region * aregion,struct mlxsw_sp_acl_atcam_entry * aentry)391 mlxsw_sp4_acl_bf_index_get(struct mlxsw_sp_acl_bf *bf,
392 struct mlxsw_sp_acl_atcam_region *aregion,
393 struct mlxsw_sp_acl_atcam_entry *aentry)
394 {
395 char bf_key[MLXSW_SP4_BLOOM_KEY_LEN] = {};
396 u8 bf_size;
397
398 mlxsw_sp4_acl_bf_key_encode(aregion, aentry, bf_key, &bf_size);
399 return mlxsw_sp4_acl_bf_crc(bf_key, bf_size);
400 }
401
402 static unsigned int
mlxsw_sp_acl_bf_rule_count_index_get(struct mlxsw_sp_acl_bf * bf,unsigned int erp_bank,unsigned int bf_index)403 mlxsw_sp_acl_bf_rule_count_index_get(struct mlxsw_sp_acl_bf *bf,
404 unsigned int erp_bank,
405 unsigned int bf_index)
406 {
407 return erp_bank * bf->bank_size + bf_index;
408 }
409
410 int
mlxsw_sp_acl_bf_entry_add(struct mlxsw_sp * mlxsw_sp,struct mlxsw_sp_acl_bf * bf,struct mlxsw_sp_acl_atcam_region * aregion,unsigned int erp_bank,struct mlxsw_sp_acl_atcam_entry * aentry)411 mlxsw_sp_acl_bf_entry_add(struct mlxsw_sp *mlxsw_sp,
412 struct mlxsw_sp_acl_bf *bf,
413 struct mlxsw_sp_acl_atcam_region *aregion,
414 unsigned int erp_bank,
415 struct mlxsw_sp_acl_atcam_entry *aentry)
416 {
417 unsigned int rule_index;
418 char *peabfe_pl;
419 u16 bf_index;
420 int err;
421
422 mutex_lock(&bf->lock);
423
424 bf_index = mlxsw_sp->acl_bf_ops->index_get(bf, aregion, aentry);
425 rule_index = mlxsw_sp_acl_bf_rule_count_index_get(bf, erp_bank,
426 bf_index);
427
428 if (refcount_inc_not_zero(&bf->refcnt[rule_index])) {
429 err = 0;
430 goto unlock;
431 }
432
433 peabfe_pl = kmalloc(MLXSW_REG_PEABFE_LEN, GFP_KERNEL);
434 if (!peabfe_pl) {
435 err = -ENOMEM;
436 goto unlock;
437 }
438
439 mlxsw_reg_peabfe_pack(peabfe_pl);
440 mlxsw_reg_peabfe_rec_pack(peabfe_pl, 0, 1, erp_bank, bf_index);
441 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(peabfe), peabfe_pl);
442 kfree(peabfe_pl);
443 if (err)
444 goto unlock;
445
446 refcount_set(&bf->refcnt[rule_index], 1);
447 err = 0;
448
449 unlock:
450 mutex_unlock(&bf->lock);
451 return err;
452 }
453
454 void
mlxsw_sp_acl_bf_entry_del(struct mlxsw_sp * mlxsw_sp,struct mlxsw_sp_acl_bf * bf,struct mlxsw_sp_acl_atcam_region * aregion,unsigned int erp_bank,struct mlxsw_sp_acl_atcam_entry * aentry)455 mlxsw_sp_acl_bf_entry_del(struct mlxsw_sp *mlxsw_sp,
456 struct mlxsw_sp_acl_bf *bf,
457 struct mlxsw_sp_acl_atcam_region *aregion,
458 unsigned int erp_bank,
459 struct mlxsw_sp_acl_atcam_entry *aentry)
460 {
461 unsigned int rule_index;
462 char *peabfe_pl;
463 u16 bf_index;
464
465 mutex_lock(&bf->lock);
466
467 bf_index = mlxsw_sp->acl_bf_ops->index_get(bf, aregion, aentry);
468 rule_index = mlxsw_sp_acl_bf_rule_count_index_get(bf, erp_bank,
469 bf_index);
470
471 if (refcount_dec_and_test(&bf->refcnt[rule_index])) {
472 peabfe_pl = kmalloc(MLXSW_REG_PEABFE_LEN, GFP_KERNEL);
473 if (!peabfe_pl)
474 goto unlock;
475
476 mlxsw_reg_peabfe_pack(peabfe_pl);
477 mlxsw_reg_peabfe_rec_pack(peabfe_pl, 0, 0, erp_bank, bf_index);
478 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(peabfe), peabfe_pl);
479 kfree(peabfe_pl);
480 }
481
482 unlock:
483 mutex_unlock(&bf->lock);
484 }
485
486 struct mlxsw_sp_acl_bf *
mlxsw_sp_acl_bf_init(struct mlxsw_sp * mlxsw_sp,unsigned int num_erp_banks)487 mlxsw_sp_acl_bf_init(struct mlxsw_sp *mlxsw_sp, unsigned int num_erp_banks)
488 {
489 struct mlxsw_sp_acl_bf *bf;
490 unsigned int bf_bank_size;
491
492 if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, ACL_MAX_BF_LOG))
493 return ERR_PTR(-EIO);
494
495 /* Bloom filter size per erp_table_bank
496 * is 2^ACL_MAX_BF_LOG
497 */
498 bf_bank_size = 1 << MLXSW_CORE_RES_GET(mlxsw_sp->core, ACL_MAX_BF_LOG);
499 bf = kzalloc(struct_size(bf, refcnt, size_mul(bf_bank_size, num_erp_banks)),
500 GFP_KERNEL);
501 if (!bf)
502 return ERR_PTR(-ENOMEM);
503
504 bf->bank_size = bf_bank_size;
505 mutex_init(&bf->lock);
506
507 return bf;
508 }
509
mlxsw_sp_acl_bf_fini(struct mlxsw_sp_acl_bf * bf)510 void mlxsw_sp_acl_bf_fini(struct mlxsw_sp_acl_bf *bf)
511 {
512 mutex_destroy(&bf->lock);
513 kfree(bf);
514 }
515
516 const struct mlxsw_sp_acl_bf_ops mlxsw_sp2_acl_bf_ops = {
517 .index_get = mlxsw_sp2_acl_bf_index_get,
518 };
519
520 const struct mlxsw_sp_acl_bf_ops mlxsw_sp4_acl_bf_ops = {
521 .index_get = mlxsw_sp4_acl_bf_index_get,
522 };
523