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 13struct 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 */ 61static const u16 mlxsw_sp2_acl_bf_crc16_tab[256] = { 620x0000, 0x8529, 0x8f7b, 0x0a52, 0x9bdf, 0x1ef6, 0x14a4, 0x918d, 630xb297, 0x37be, 0x3dec, 0xb8c5, 0x2948, 0xac61, 0xa633, 0x231a, 640xe007, 0x652e, 0x6f7c, 0xea55, 0x7bd8, 0xfef1, 0xf4a3, 0x718a, 650x5290, 0xd7b9, 0xddeb, 0x58c2, 0xc94f, 0x4c66, 0x4634, 0xc31d, 660x4527, 0xc00e, 0xca5c, 0x4f75, 0xdef8, 0x5bd1, 0x5183, 0xd4aa, 670xf7b0, 0x7299, 0x78cb, 0xfde2, 0x6c6f, 0xe946, 0xe314, 0x663d, 680xa520, 0x2009, 0x2a5b, 0xaf72, 0x3eff, 0xbbd6, 0xb184, 0x34ad, 690x17b7, 0x929e, 0x98cc, 0x1de5, 0x8c68, 0x0941, 0x0313, 0x863a, 700x8a4e, 0x0f67, 0x0535, 0x801c, 0x1191, 0x94b8, 0x9eea, 0x1bc3, 710x38d9, 0xbdf0, 0xb7a2, 0x328b, 0xa306, 0x262f, 0x2c7d, 0xa954, 720x6a49, 0xef60, 0xe532, 0x601b, 0xf196, 0x74bf, 0x7eed, 0xfbc4, 730xd8de, 0x5df7, 0x57a5, 0xd28c, 0x4301, 0xc628, 0xcc7a, 0x4953, 740xcf69, 0x4a40, 0x4012, 0xc53b, 0x54b6, 0xd19f, 0xdbcd, 0x5ee4, 750x7dfe, 0xf8d7, 0xf285, 0x77ac, 0xe621, 0x6308, 0x695a, 0xec73, 760x2f6e, 0xaa47, 0xa015, 0x253c, 0xb4b1, 0x3198, 0x3bca, 0xbee3, 770x9df9, 0x18d0, 0x1282, 0x97ab, 0x0626, 0x830f, 0x895d, 0x0c74, 780x91b5, 0x149c, 0x1ece, 0x9be7, 0x0a6a, 0x8f43, 0x8511, 0x0038, 790x2322, 0xa60b, 0xac59, 0x2970, 0xb8fd, 0x3dd4, 0x3786, 0xb2af, 800x71b2, 0xf49b, 0xfec9, 0x7be0, 0xea6d, 0x6f44, 0x6516, 0xe03f, 810xc325, 0x460c, 0x4c5e, 0xc977, 0x58fa, 0xddd3, 0xd781, 0x52a8, 820xd492, 0x51bb, 0x5be9, 0xdec0, 0x4f4d, 0xca64, 0xc036, 0x451f, 830x6605, 0xe32c, 0xe97e, 0x6c57, 0xfdda, 0x78f3, 0x72a1, 0xf788, 840x3495, 0xb1bc, 0xbbee, 0x3ec7, 0xaf4a, 0x2a63, 0x2031, 0xa518, 850x8602, 0x032b, 0x0979, 0x8c50, 0x1ddd, 0x98f4, 0x92a6, 0x178f, 860x1bfb, 0x9ed2, 0x9480, 0x11a9, 0x8024, 0x050d, 0x0f5f, 0x8a76, 870xa96c, 0x2c45, 0x2617, 0xa33e, 0x32b3, 0xb79a, 0xbdc8, 0x38e1, 880xfbfc, 0x7ed5, 0x7487, 0xf1ae, 0x6023, 0xe50a, 0xef58, 0x6a71, 890x496b, 0xcc42, 0xc610, 0x4339, 0xd2b4, 0x579d, 0x5dcf, 0xd8e6, 900x5edc, 0xdbf5, 0xd1a7, 0x548e, 0xc503, 0x402a, 0x4a78, 0xcf51, 910xec4b, 0x6962, 0x6330, 0xe619, 0x7794, 0xf2bd, 0xf8ef, 0x7dc6, 920xbedb, 0x3bf2, 0x31a0, 0xb489, 0x2504, 0xa02d, 0xaa7f, 0x2f56, 930x0c4c, 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 */ 132static const u16 mlxsw_sp4_acl_bf_crc10_tab[256] = { 1330x0000, 0x001b, 0x0036, 0x002d, 0x006c, 0x0077, 0x005a, 0x0041, 1340x00d8, 0x00c3, 0x00ee, 0x00f5, 0x00b4, 0x00af, 0x0082, 0x0099, 1350x01b0, 0x01ab, 0x0186, 0x019d, 0x01dc, 0x01c7, 0x01ea, 0x01f1, 1360x0168, 0x0173, 0x015e, 0x0145, 0x0104, 0x011f, 0x0132, 0x0129, 1370x0360, 0x037b, 0x0356, 0x034d, 0x030c, 0x0317, 0x033a, 0x0321, 1380x03b8, 0x03a3, 0x038e, 0x0395, 0x03d4, 0x03cf, 0x03e2, 0x03f9, 1390x02d0, 0x02cb, 0x02e6, 0x02fd, 0x02bc, 0x02a7, 0x028a, 0x0291, 1400x0208, 0x0213, 0x023e, 0x0225, 0x0264, 0x027f, 0x0252, 0x0249, 1410x02db, 0x02c0, 0x02ed, 0x02f6, 0x02b7, 0x02ac, 0x0281, 0x029a, 1420x0203, 0x0218, 0x0235, 0x022e, 0x026f, 0x0274, 0x0259, 0x0242, 1430x036b, 0x0370, 0x035d, 0x0346, 0x0307, 0x031c, 0x0331, 0x032a, 1440x03b3, 0x03a8, 0x0385, 0x039e, 0x03df, 0x03c4, 0x03e9, 0x03f2, 1450x01bb, 0x01a0, 0x018d, 0x0196, 0x01d7, 0x01cc, 0x01e1, 0x01fa, 1460x0163, 0x0178, 0x0155, 0x014e, 0x010f, 0x0114, 0x0139, 0x0122, 1470x000b, 0x0010, 0x003d, 0x0026, 0x0067, 0x007c, 0x0051, 0x004a, 1480x00d3, 0x00c8, 0x00e5, 0x00fe, 0x00bf, 0x00a4, 0x0089, 0x0092, 1490x01ad, 0x01b6, 0x019b, 0x0180, 0x01c1, 0x01da, 0x01f7, 0x01ec, 1500x0175, 0x016e, 0x0143, 0x0158, 0x0119, 0x0102, 0x012f, 0x0134, 1510x001d, 0x0006, 0x002b, 0x0030, 0x0071, 0x006a, 0x0047, 0x005c, 1520x00c5, 0x00de, 0x00f3, 0x00e8, 0x00a9, 0x00b2, 0x009f, 0x0084, 1530x02cd, 0x02d6, 0x02fb, 0x02e0, 0x02a1, 0x02ba, 0x0297, 0x028c, 1540x0215, 0x020e, 0x0223, 0x0238, 0x0279, 0x0262, 0x024f, 0x0254, 1550x037d, 0x0366, 0x034b, 0x0350, 0x0311, 0x030a, 0x0327, 0x033c, 1560x03a5, 0x03be, 0x0393, 0x0388, 0x03c9, 0x03d2, 0x03ff, 0x03e4, 1570x0376, 0x036d, 0x0340, 0x035b, 0x031a, 0x0301, 0x032c, 0x0337, 1580x03ae, 0x03b5, 0x0398, 0x0383, 0x03c2, 0x03d9, 0x03f4, 0x03ef, 1590x02c6, 0x02dd, 0x02f0, 0x02eb, 0x02aa, 0x02b1, 0x029c, 0x0287, 1600x021e, 0x0205, 0x0228, 0x0233, 0x0272, 0x0269, 0x0244, 0x025f, 1610x0016, 0x000d, 0x0020, 0x003b, 0x007a, 0x0061, 0x004c, 0x0057, 1620x00ce, 0x00d5, 0x00f8, 0x00e3, 0x00a2, 0x00b9, 0x0094, 0x008f, 1630x01a6, 0x01bd, 0x0190, 0x018b, 0x01ca, 0x01d1, 0x01fc, 0x01e7, 1640x017e, 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 */ 171static const u8 mlxsw_sp4_acl_bf_crc6_tab[256] = { 1720x00, 0x2d, 0x37, 0x1a, 0x03, 0x2e, 0x34, 0x19, 1730x06, 0x2b, 0x31, 0x1c, 0x05, 0x28, 0x32, 0x1f, 1740x0c, 0x21, 0x3b, 0x16, 0x0f, 0x22, 0x38, 0x15, 1750x0a, 0x27, 0x3d, 0x10, 0x09, 0x24, 0x3e, 0x13, 1760x18, 0x35, 0x2f, 0x02, 0x1b, 0x36, 0x2c, 0x01, 1770x1e, 0x33, 0x29, 0x04, 0x1d, 0x30, 0x2a, 0x07, 1780x14, 0x39, 0x23, 0x0e, 0x17, 0x3a, 0x20, 0x0d, 1790x12, 0x3f, 0x25, 0x08, 0x11, 0x3c, 0x26, 0x0b, 1800x30, 0x1d, 0x07, 0x2a, 0x33, 0x1e, 0x04, 0x29, 1810x36, 0x1b, 0x01, 0x2c, 0x35, 0x18, 0x02, 0x2f, 1820x3c, 0x11, 0x0b, 0x26, 0x3f, 0x12, 0x08, 0x25, 1830x3a, 0x17, 0x0d, 0x20, 0x39, 0x14, 0x0e, 0x23, 1840x28, 0x05, 0x1f, 0x32, 0x2b, 0x06, 0x1c, 0x31, 1850x2e, 0x03, 0x19, 0x34, 0x2d, 0x00, 0x1a, 0x37, 1860x24, 0x09, 0x13, 0x3e, 0x27, 0x0a, 0x10, 0x3d, 1870x22, 0x0f, 0x15, 0x38, 0x21, 0x0c, 0x16, 0x3b, 1880x0d, 0x20, 0x3a, 0x17, 0x0e, 0x23, 0x39, 0x14, 1890x0b, 0x26, 0x3c, 0x11, 0x08, 0x25, 0x3f, 0x12, 1900x01, 0x2c, 0x36, 0x1b, 0x02, 0x2f, 0x35, 0x18, 1910x07, 0x2a, 0x30, 0x1d, 0x04, 0x29, 0x33, 0x1e, 1920x15, 0x38, 0x22, 0x0f, 0x16, 0x3b, 0x21, 0x0c, 1930x13, 0x3e, 0x24, 0x09, 0x10, 0x3d, 0x27, 0x0a, 1940x19, 0x34, 0x2e, 0x03, 0x1a, 0x37, 0x2d, 0x00, 1950x1f, 0x32, 0x28, 0x05, 0x1c, 0x31, 0x2b, 0x06, 1960x3d, 0x10, 0x0a, 0x27, 0x3e, 0x13, 0x09, 0x24, 1970x3b, 0x16, 0x0c, 0x21, 0x38, 0x15, 0x0f, 0x22, 1980x31, 0x1c, 0x06, 0x2b, 0x32, 0x1f, 0x05, 0x28, 1990x37, 0x1a, 0x00, 0x2d, 0x34, 0x19, 0x03, 0x2e, 2000x25, 0x08, 0x12, 0x3f, 0x26, 0x0b, 0x11, 0x3c, 2010x23, 0x0e, 0x14, 0x39, 0x20, 0x0d, 0x17, 0x3a, 2020x29, 0x04, 0x1e, 0x33, 0x2a, 0x07, 0x1d, 0x30, 2030x2f, 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 */ 215static const u8 chunk_key_offsets[MLXSW_BLOOM_KEY_CHUNKS] = {2, 20, 38}; 216 217static 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 222static 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 231static void 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->enc_key[chunk_key_offsets[chunk_index]], 253 chunk_key_len); 254 chunk += chunk_len; 255 } 256 *len = chunk_count * chunk_len; 257} 258 259static void 260mlxsw_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 272static unsigned int 273mlxsw_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 284static 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 291static 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 298static 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 314static 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 334static 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 372static void 373mlxsw_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 390static unsigned int 391mlxsw_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 402static unsigned int 403mlxsw_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 410int 411mlxsw_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 449unlock: 450 mutex_unlock(&bf->lock); 451 return err; 452} 453 454void 455mlxsw_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 482unlock: 483 mutex_unlock(&bf->lock); 484} 485 486struct mlxsw_sp_acl_bf * 487mlxsw_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 510void mlxsw_sp_acl_bf_fini(struct mlxsw_sp_acl_bf *bf) 511{ 512 mutex_destroy(&bf->lock); 513 kfree(bf); 514} 515 516const struct mlxsw_sp_acl_bf_ops mlxsw_sp2_acl_bf_ops = { 517 .index_get = mlxsw_sp2_acl_bf_index_get, 518}; 519 520const struct mlxsw_sp_acl_bf_ops mlxsw_sp4_acl_bf_ops = { 521 .index_get = mlxsw_sp4_acl_bf_index_get, 522}; 523