ixgbe: fix MAC anti-spoofing filter after VFLR
[muen/linux.git] / drivers / net / ethernet / mellanox / mlxsw / reg.h
1 /* SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 */
2 /* Copyright (c) 2015-2018 Mellanox Technologies. All rights reserved */
3
4 #ifndef _MLXSW_REG_H
5 #define _MLXSW_REG_H
6
7 #include <linux/kernel.h>
8 #include <linux/string.h>
9 #include <linux/bitops.h>
10 #include <linux/if_vlan.h>
11
12 #include "item.h"
13 #include "port.h"
14
15 struct mlxsw_reg_info {
16         u16 id;
17         u16 len; /* In u8 */
18         const char *name;
19 };
20
21 #define MLXSW_REG_DEFINE(_name, _id, _len)                              \
22 static const struct mlxsw_reg_info mlxsw_reg_##_name = {                \
23         .id = _id,                                                      \
24         .len = _len,                                                    \
25         .name = #_name,                                                 \
26 }
27
28 #define MLXSW_REG(type) (&mlxsw_reg_##type)
29 #define MLXSW_REG_LEN(type) MLXSW_REG(type)->len
30 #define MLXSW_REG_ZERO(type, payload) memset(payload, 0, MLXSW_REG(type)->len)
31
32 /* SGCR - Switch General Configuration Register
33  * --------------------------------------------
34  * This register is used for configuration of the switch capabilities.
35  */
36 #define MLXSW_REG_SGCR_ID 0x2000
37 #define MLXSW_REG_SGCR_LEN 0x10
38
39 MLXSW_REG_DEFINE(sgcr, MLXSW_REG_SGCR_ID, MLXSW_REG_SGCR_LEN);
40
41 /* reg_sgcr_llb
42  * Link Local Broadcast (Default=0)
43  * When set, all Link Local packets (224.0.0.X) will be treated as broadcast
44  * packets and ignore the IGMP snooping entries.
45  * Access: RW
46  */
47 MLXSW_ITEM32(reg, sgcr, llb, 0x04, 0, 1);
48
49 static inline void mlxsw_reg_sgcr_pack(char *payload, bool llb)
50 {
51         MLXSW_REG_ZERO(sgcr, payload);
52         mlxsw_reg_sgcr_llb_set(payload, !!llb);
53 }
54
55 /* SPAD - Switch Physical Address Register
56  * ---------------------------------------
57  * The SPAD register configures the switch physical MAC address.
58  */
59 #define MLXSW_REG_SPAD_ID 0x2002
60 #define MLXSW_REG_SPAD_LEN 0x10
61
62 MLXSW_REG_DEFINE(spad, MLXSW_REG_SPAD_ID, MLXSW_REG_SPAD_LEN);
63
64 /* reg_spad_base_mac
65  * Base MAC address for the switch partitions.
66  * Per switch partition MAC address is equal to:
67  * base_mac + swid
68  * Access: RW
69  */
70 MLXSW_ITEM_BUF(reg, spad, base_mac, 0x02, 6);
71
72 /* SMID - Switch Multicast ID
73  * --------------------------
74  * The MID record maps from a MID (Multicast ID), which is a unique identifier
75  * of the multicast group within the stacking domain, into a list of local
76  * ports into which the packet is replicated.
77  */
78 #define MLXSW_REG_SMID_ID 0x2007
79 #define MLXSW_REG_SMID_LEN 0x240
80
81 MLXSW_REG_DEFINE(smid, MLXSW_REG_SMID_ID, MLXSW_REG_SMID_LEN);
82
83 /* reg_smid_swid
84  * Switch partition ID.
85  * Access: Index
86  */
87 MLXSW_ITEM32(reg, smid, swid, 0x00, 24, 8);
88
89 /* reg_smid_mid
90  * Multicast identifier - global identifier that represents the multicast group
91  * across all devices.
92  * Access: Index
93  */
94 MLXSW_ITEM32(reg, smid, mid, 0x00, 0, 16);
95
96 /* reg_smid_port
97  * Local port memebership (1 bit per port).
98  * Access: RW
99  */
100 MLXSW_ITEM_BIT_ARRAY(reg, smid, port, 0x20, 0x20, 1);
101
102 /* reg_smid_port_mask
103  * Local port mask (1 bit per port).
104  * Access: W
105  */
106 MLXSW_ITEM_BIT_ARRAY(reg, smid, port_mask, 0x220, 0x20, 1);
107
108 static inline void mlxsw_reg_smid_pack(char *payload, u16 mid,
109                                        u8 port, bool set)
110 {
111         MLXSW_REG_ZERO(smid, payload);
112         mlxsw_reg_smid_swid_set(payload, 0);
113         mlxsw_reg_smid_mid_set(payload, mid);
114         mlxsw_reg_smid_port_set(payload, port, set);
115         mlxsw_reg_smid_port_mask_set(payload, port, 1);
116 }
117
118 /* SSPR - Switch System Port Record Register
119  * -----------------------------------------
120  * Configures the system port to local port mapping.
121  */
122 #define MLXSW_REG_SSPR_ID 0x2008
123 #define MLXSW_REG_SSPR_LEN 0x8
124
125 MLXSW_REG_DEFINE(sspr, MLXSW_REG_SSPR_ID, MLXSW_REG_SSPR_LEN);
126
127 /* reg_sspr_m
128  * Master - if set, then the record describes the master system port.
129  * This is needed in case a local port is mapped into several system ports
130  * (for multipathing). That number will be reported as the source system
131  * port when packets are forwarded to the CPU. Only one master port is allowed
132  * per local port.
133  *
134  * Note: Must be set for Spectrum.
135  * Access: RW
136  */
137 MLXSW_ITEM32(reg, sspr, m, 0x00, 31, 1);
138
139 /* reg_sspr_local_port
140  * Local port number.
141  *
142  * Access: RW
143  */
144 MLXSW_ITEM32(reg, sspr, local_port, 0x00, 16, 8);
145
146 /* reg_sspr_sub_port
147  * Virtual port within the physical port.
148  * Should be set to 0 when virtual ports are not enabled on the port.
149  *
150  * Access: RW
151  */
152 MLXSW_ITEM32(reg, sspr, sub_port, 0x00, 8, 8);
153
154 /* reg_sspr_system_port
155  * Unique identifier within the stacking domain that represents all the ports
156  * that are available in the system (external ports).
157  *
158  * Currently, only single-ASIC configurations are supported, so we default to
159  * 1:1 mapping between system ports and local ports.
160  * Access: Index
161  */
162 MLXSW_ITEM32(reg, sspr, system_port, 0x04, 0, 16);
163
164 static inline void mlxsw_reg_sspr_pack(char *payload, u8 local_port)
165 {
166         MLXSW_REG_ZERO(sspr, payload);
167         mlxsw_reg_sspr_m_set(payload, 1);
168         mlxsw_reg_sspr_local_port_set(payload, local_port);
169         mlxsw_reg_sspr_sub_port_set(payload, 0);
170         mlxsw_reg_sspr_system_port_set(payload, local_port);
171 }
172
173 /* SFDAT - Switch Filtering Database Aging Time
174  * --------------------------------------------
175  * Controls the Switch aging time. Aging time is able to be set per Switch
176  * Partition.
177  */
178 #define MLXSW_REG_SFDAT_ID 0x2009
179 #define MLXSW_REG_SFDAT_LEN 0x8
180
181 MLXSW_REG_DEFINE(sfdat, MLXSW_REG_SFDAT_ID, MLXSW_REG_SFDAT_LEN);
182
183 /* reg_sfdat_swid
184  * Switch partition ID.
185  * Access: Index
186  */
187 MLXSW_ITEM32(reg, sfdat, swid, 0x00, 24, 8);
188
189 /* reg_sfdat_age_time
190  * Aging time in seconds
191  * Min - 10 seconds
192  * Max - 1,000,000 seconds
193  * Default is 300 seconds.
194  * Access: RW
195  */
196 MLXSW_ITEM32(reg, sfdat, age_time, 0x04, 0, 20);
197
198 static inline void mlxsw_reg_sfdat_pack(char *payload, u32 age_time)
199 {
200         MLXSW_REG_ZERO(sfdat, payload);
201         mlxsw_reg_sfdat_swid_set(payload, 0);
202         mlxsw_reg_sfdat_age_time_set(payload, age_time);
203 }
204
205 /* SFD - Switch Filtering Database
206  * -------------------------------
207  * The following register defines the access to the filtering database.
208  * The register supports querying, adding, removing and modifying the database.
209  * The access is optimized for bulk updates in which case more than one
210  * FDB record is present in the same command.
211  */
212 #define MLXSW_REG_SFD_ID 0x200A
213 #define MLXSW_REG_SFD_BASE_LEN 0x10 /* base length, without records */
214 #define MLXSW_REG_SFD_REC_LEN 0x10 /* record length */
215 #define MLXSW_REG_SFD_REC_MAX_COUNT 64
216 #define MLXSW_REG_SFD_LEN (MLXSW_REG_SFD_BASE_LEN +     \
217                            MLXSW_REG_SFD_REC_LEN * MLXSW_REG_SFD_REC_MAX_COUNT)
218
219 MLXSW_REG_DEFINE(sfd, MLXSW_REG_SFD_ID, MLXSW_REG_SFD_LEN);
220
221 /* reg_sfd_swid
222  * Switch partition ID for queries. Reserved on Write.
223  * Access: Index
224  */
225 MLXSW_ITEM32(reg, sfd, swid, 0x00, 24, 8);
226
227 enum mlxsw_reg_sfd_op {
228         /* Dump entire FDB a (process according to record_locator) */
229         MLXSW_REG_SFD_OP_QUERY_DUMP = 0,
230         /* Query records by {MAC, VID/FID} value */
231         MLXSW_REG_SFD_OP_QUERY_QUERY = 1,
232         /* Query and clear activity. Query records by {MAC, VID/FID} value */
233         MLXSW_REG_SFD_OP_QUERY_QUERY_AND_CLEAR_ACTIVITY = 2,
234         /* Test. Response indicates if each of the records could be
235          * added to the FDB.
236          */
237         MLXSW_REG_SFD_OP_WRITE_TEST = 0,
238         /* Add/modify. Aged-out records cannot be added. This command removes
239          * the learning notification of the {MAC, VID/FID}. Response includes
240          * the entries that were added to the FDB.
241          */
242         MLXSW_REG_SFD_OP_WRITE_EDIT = 1,
243         /* Remove record by {MAC, VID/FID}. This command also removes
244          * the learning notification and aged-out notifications
245          * of the {MAC, VID/FID}. The response provides current (pre-removal)
246          * entries as non-aged-out.
247          */
248         MLXSW_REG_SFD_OP_WRITE_REMOVE = 2,
249         /* Remove learned notification by {MAC, VID/FID}. The response provides
250          * the removed learning notification.
251          */
252         MLXSW_REG_SFD_OP_WRITE_REMOVE_NOTIFICATION = 2,
253 };
254
255 /* reg_sfd_op
256  * Operation.
257  * Access: OP
258  */
259 MLXSW_ITEM32(reg, sfd, op, 0x04, 30, 2);
260
261 /* reg_sfd_record_locator
262  * Used for querying the FDB. Use record_locator=0 to initiate the
263  * query. When a record is returned, a new record_locator is
264  * returned to be used in the subsequent query.
265  * Reserved for database update.
266  * Access: Index
267  */
268 MLXSW_ITEM32(reg, sfd, record_locator, 0x04, 0, 30);
269
270 /* reg_sfd_num_rec
271  * Request: Number of records to read/add/modify/remove
272  * Response: Number of records read/added/replaced/removed
273  * See above description for more details.
274  * Ranges 0..64
275  * Access: RW
276  */
277 MLXSW_ITEM32(reg, sfd, num_rec, 0x08, 0, 8);
278
279 static inline void mlxsw_reg_sfd_pack(char *payload, enum mlxsw_reg_sfd_op op,
280                                       u32 record_locator)
281 {
282         MLXSW_REG_ZERO(sfd, payload);
283         mlxsw_reg_sfd_op_set(payload, op);
284         mlxsw_reg_sfd_record_locator_set(payload, record_locator);
285 }
286
287 /* reg_sfd_rec_swid
288  * Switch partition ID.
289  * Access: Index
290  */
291 MLXSW_ITEM32_INDEXED(reg, sfd, rec_swid, MLXSW_REG_SFD_BASE_LEN, 24, 8,
292                      MLXSW_REG_SFD_REC_LEN, 0x00, false);
293
294 enum mlxsw_reg_sfd_rec_type {
295         MLXSW_REG_SFD_REC_TYPE_UNICAST = 0x0,
296         MLXSW_REG_SFD_REC_TYPE_UNICAST_LAG = 0x1,
297         MLXSW_REG_SFD_REC_TYPE_MULTICAST = 0x2,
298         MLXSW_REG_SFD_REC_TYPE_UNICAST_TUNNEL = 0xC,
299 };
300
301 /* reg_sfd_rec_type
302  * FDB record type.
303  * Access: RW
304  */
305 MLXSW_ITEM32_INDEXED(reg, sfd, rec_type, MLXSW_REG_SFD_BASE_LEN, 20, 4,
306                      MLXSW_REG_SFD_REC_LEN, 0x00, false);
307
308 enum mlxsw_reg_sfd_rec_policy {
309         /* Replacement disabled, aging disabled. */
310         MLXSW_REG_SFD_REC_POLICY_STATIC_ENTRY = 0,
311         /* (mlag remote): Replacement enabled, aging disabled,
312          * learning notification enabled on this port.
313          */
314         MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_MLAG = 1,
315         /* (ingress device): Replacement enabled, aging enabled. */
316         MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_INGRESS = 3,
317 };
318
319 /* reg_sfd_rec_policy
320  * Policy.
321  * Access: RW
322  */
323 MLXSW_ITEM32_INDEXED(reg, sfd, rec_policy, MLXSW_REG_SFD_BASE_LEN, 18, 2,
324                      MLXSW_REG_SFD_REC_LEN, 0x00, false);
325
326 /* reg_sfd_rec_a
327  * Activity. Set for new static entries. Set for static entries if a frame SMAC
328  * lookup hits on the entry.
329  * To clear the a bit, use "query and clear activity" op.
330  * Access: RO
331  */
332 MLXSW_ITEM32_INDEXED(reg, sfd, rec_a, MLXSW_REG_SFD_BASE_LEN, 16, 1,
333                      MLXSW_REG_SFD_REC_LEN, 0x00, false);
334
335 /* reg_sfd_rec_mac
336  * MAC address.
337  * Access: Index
338  */
339 MLXSW_ITEM_BUF_INDEXED(reg, sfd, rec_mac, MLXSW_REG_SFD_BASE_LEN, 6,
340                        MLXSW_REG_SFD_REC_LEN, 0x02);
341
342 enum mlxsw_reg_sfd_rec_action {
343         /* forward */
344         MLXSW_REG_SFD_REC_ACTION_NOP = 0,
345         /* forward and trap, trap_id is FDB_TRAP */
346         MLXSW_REG_SFD_REC_ACTION_MIRROR_TO_CPU = 1,
347         /* trap and do not forward, trap_id is FDB_TRAP */
348         MLXSW_REG_SFD_REC_ACTION_TRAP = 2,
349         /* forward to IP router */
350         MLXSW_REG_SFD_REC_ACTION_FORWARD_IP_ROUTER = 3,
351         MLXSW_REG_SFD_REC_ACTION_DISCARD_ERROR = 15,
352 };
353
354 /* reg_sfd_rec_action
355  * Action to apply on the packet.
356  * Note: Dynamic entries can only be configured with NOP action.
357  * Access: RW
358  */
359 MLXSW_ITEM32_INDEXED(reg, sfd, rec_action, MLXSW_REG_SFD_BASE_LEN, 28, 4,
360                      MLXSW_REG_SFD_REC_LEN, 0x0C, false);
361
362 /* reg_sfd_uc_sub_port
363  * VEPA channel on local port.
364  * Valid only if local port is a non-stacking port. Must be 0 if multichannel
365  * VEPA is not enabled.
366  * Access: RW
367  */
368 MLXSW_ITEM32_INDEXED(reg, sfd, uc_sub_port, MLXSW_REG_SFD_BASE_LEN, 16, 8,
369                      MLXSW_REG_SFD_REC_LEN, 0x08, false);
370
371 /* reg_sfd_uc_fid_vid
372  * Filtering ID or VLAN ID
373  * For SwitchX and SwitchX-2:
374  * - Dynamic entries (policy 2,3) use FID
375  * - Static entries (policy 0) use VID
376  * - When independent learning is configured, VID=FID
377  * For Spectrum: use FID for both Dynamic and Static entries.
378  * VID should not be used.
379  * Access: Index
380  */
381 MLXSW_ITEM32_INDEXED(reg, sfd, uc_fid_vid, MLXSW_REG_SFD_BASE_LEN, 0, 16,
382                      MLXSW_REG_SFD_REC_LEN, 0x08, false);
383
384 /* reg_sfd_uc_system_port
385  * Unique port identifier for the final destination of the packet.
386  * Access: RW
387  */
388 MLXSW_ITEM32_INDEXED(reg, sfd, uc_system_port, MLXSW_REG_SFD_BASE_LEN, 0, 16,
389                      MLXSW_REG_SFD_REC_LEN, 0x0C, false);
390
391 static inline void mlxsw_reg_sfd_rec_pack(char *payload, int rec_index,
392                                           enum mlxsw_reg_sfd_rec_type rec_type,
393                                           const char *mac,
394                                           enum mlxsw_reg_sfd_rec_action action)
395 {
396         u8 num_rec = mlxsw_reg_sfd_num_rec_get(payload);
397
398         if (rec_index >= num_rec)
399                 mlxsw_reg_sfd_num_rec_set(payload, rec_index + 1);
400         mlxsw_reg_sfd_rec_swid_set(payload, rec_index, 0);
401         mlxsw_reg_sfd_rec_type_set(payload, rec_index, rec_type);
402         mlxsw_reg_sfd_rec_mac_memcpy_to(payload, rec_index, mac);
403         mlxsw_reg_sfd_rec_action_set(payload, rec_index, action);
404 }
405
406 static inline void mlxsw_reg_sfd_uc_pack(char *payload, int rec_index,
407                                          enum mlxsw_reg_sfd_rec_policy policy,
408                                          const char *mac, u16 fid_vid,
409                                          enum mlxsw_reg_sfd_rec_action action,
410                                          u8 local_port)
411 {
412         mlxsw_reg_sfd_rec_pack(payload, rec_index,
413                                MLXSW_REG_SFD_REC_TYPE_UNICAST, mac, action);
414         mlxsw_reg_sfd_rec_policy_set(payload, rec_index, policy);
415         mlxsw_reg_sfd_uc_sub_port_set(payload, rec_index, 0);
416         mlxsw_reg_sfd_uc_fid_vid_set(payload, rec_index, fid_vid);
417         mlxsw_reg_sfd_uc_system_port_set(payload, rec_index, local_port);
418 }
419
420 static inline void mlxsw_reg_sfd_uc_unpack(char *payload, int rec_index,
421                                            char *mac, u16 *p_fid_vid,
422                                            u8 *p_local_port)
423 {
424         mlxsw_reg_sfd_rec_mac_memcpy_from(payload, rec_index, mac);
425         *p_fid_vid = mlxsw_reg_sfd_uc_fid_vid_get(payload, rec_index);
426         *p_local_port = mlxsw_reg_sfd_uc_system_port_get(payload, rec_index);
427 }
428
429 /* reg_sfd_uc_lag_sub_port
430  * LAG sub port.
431  * Must be 0 if multichannel VEPA is not enabled.
432  * Access: RW
433  */
434 MLXSW_ITEM32_INDEXED(reg, sfd, uc_lag_sub_port, MLXSW_REG_SFD_BASE_LEN, 16, 8,
435                      MLXSW_REG_SFD_REC_LEN, 0x08, false);
436
437 /* reg_sfd_uc_lag_fid_vid
438  * Filtering ID or VLAN ID
439  * For SwitchX and SwitchX-2:
440  * - Dynamic entries (policy 2,3) use FID
441  * - Static entries (policy 0) use VID
442  * - When independent learning is configured, VID=FID
443  * For Spectrum: use FID for both Dynamic and Static entries.
444  * VID should not be used.
445  * Access: Index
446  */
447 MLXSW_ITEM32_INDEXED(reg, sfd, uc_lag_fid_vid, MLXSW_REG_SFD_BASE_LEN, 0, 16,
448                      MLXSW_REG_SFD_REC_LEN, 0x08, false);
449
450 /* reg_sfd_uc_lag_lag_vid
451  * Indicates VID in case of vFIDs. Reserved for FIDs.
452  * Access: RW
453  */
454 MLXSW_ITEM32_INDEXED(reg, sfd, uc_lag_lag_vid, MLXSW_REG_SFD_BASE_LEN, 16, 12,
455                      MLXSW_REG_SFD_REC_LEN, 0x0C, false);
456
457 /* reg_sfd_uc_lag_lag_id
458  * LAG Identifier - pointer into the LAG descriptor table.
459  * Access: RW
460  */
461 MLXSW_ITEM32_INDEXED(reg, sfd, uc_lag_lag_id, MLXSW_REG_SFD_BASE_LEN, 0, 10,
462                      MLXSW_REG_SFD_REC_LEN, 0x0C, false);
463
464 static inline void
465 mlxsw_reg_sfd_uc_lag_pack(char *payload, int rec_index,
466                           enum mlxsw_reg_sfd_rec_policy policy,
467                           const char *mac, u16 fid_vid,
468                           enum mlxsw_reg_sfd_rec_action action, u16 lag_vid,
469                           u16 lag_id)
470 {
471         mlxsw_reg_sfd_rec_pack(payload, rec_index,
472                                MLXSW_REG_SFD_REC_TYPE_UNICAST_LAG,
473                                mac, action);
474         mlxsw_reg_sfd_rec_policy_set(payload, rec_index, policy);
475         mlxsw_reg_sfd_uc_lag_sub_port_set(payload, rec_index, 0);
476         mlxsw_reg_sfd_uc_lag_fid_vid_set(payload, rec_index, fid_vid);
477         mlxsw_reg_sfd_uc_lag_lag_vid_set(payload, rec_index, lag_vid);
478         mlxsw_reg_sfd_uc_lag_lag_id_set(payload, rec_index, lag_id);
479 }
480
481 static inline void mlxsw_reg_sfd_uc_lag_unpack(char *payload, int rec_index,
482                                                char *mac, u16 *p_vid,
483                                                u16 *p_lag_id)
484 {
485         mlxsw_reg_sfd_rec_mac_memcpy_from(payload, rec_index, mac);
486         *p_vid = mlxsw_reg_sfd_uc_lag_fid_vid_get(payload, rec_index);
487         *p_lag_id = mlxsw_reg_sfd_uc_lag_lag_id_get(payload, rec_index);
488 }
489
490 /* reg_sfd_mc_pgi
491  *
492  * Multicast port group index - index into the port group table.
493  * Value 0x1FFF indicates the pgi should point to the MID entry.
494  * For Spectrum this value must be set to 0x1FFF
495  * Access: RW
496  */
497 MLXSW_ITEM32_INDEXED(reg, sfd, mc_pgi, MLXSW_REG_SFD_BASE_LEN, 16, 13,
498                      MLXSW_REG_SFD_REC_LEN, 0x08, false);
499
500 /* reg_sfd_mc_fid_vid
501  *
502  * Filtering ID or VLAN ID
503  * Access: Index
504  */
505 MLXSW_ITEM32_INDEXED(reg, sfd, mc_fid_vid, MLXSW_REG_SFD_BASE_LEN, 0, 16,
506                      MLXSW_REG_SFD_REC_LEN, 0x08, false);
507
508 /* reg_sfd_mc_mid
509  *
510  * Multicast identifier - global identifier that represents the multicast
511  * group across all devices.
512  * Access: RW
513  */
514 MLXSW_ITEM32_INDEXED(reg, sfd, mc_mid, MLXSW_REG_SFD_BASE_LEN, 0, 16,
515                      MLXSW_REG_SFD_REC_LEN, 0x0C, false);
516
517 static inline void
518 mlxsw_reg_sfd_mc_pack(char *payload, int rec_index,
519                       const char *mac, u16 fid_vid,
520                       enum mlxsw_reg_sfd_rec_action action, u16 mid)
521 {
522         mlxsw_reg_sfd_rec_pack(payload, rec_index,
523                                MLXSW_REG_SFD_REC_TYPE_MULTICAST, mac, action);
524         mlxsw_reg_sfd_mc_pgi_set(payload, rec_index, 0x1FFF);
525         mlxsw_reg_sfd_mc_fid_vid_set(payload, rec_index, fid_vid);
526         mlxsw_reg_sfd_mc_mid_set(payload, rec_index, mid);
527 }
528
529 /* reg_sfd_uc_tunnel_uip_msb
530  * When protocol is IPv4, the most significant byte of the underlay IPv4
531  * destination IP.
532  * When protocol is IPv6, reserved.
533  * Access: RW
534  */
535 MLXSW_ITEM32_INDEXED(reg, sfd, uc_tunnel_uip_msb, MLXSW_REG_SFD_BASE_LEN, 24,
536                      8, MLXSW_REG_SFD_REC_LEN, 0x08, false);
537
538 /* reg_sfd_uc_tunnel_fid
539  * Filtering ID.
540  * Access: Index
541  */
542 MLXSW_ITEM32_INDEXED(reg, sfd, uc_tunnel_fid, MLXSW_REG_SFD_BASE_LEN, 0, 16,
543                      MLXSW_REG_SFD_REC_LEN, 0x08, false);
544
545 enum mlxsw_reg_sfd_uc_tunnel_protocol {
546         MLXSW_REG_SFD_UC_TUNNEL_PROTOCOL_IPV4,
547         MLXSW_REG_SFD_UC_TUNNEL_PROTOCOL_IPV6,
548 };
549
550 /* reg_sfd_uc_tunnel_protocol
551  * IP protocol.
552  * Access: RW
553  */
554 MLXSW_ITEM32_INDEXED(reg, sfd, uc_tunnel_protocol, MLXSW_REG_SFD_BASE_LEN, 27,
555                      1, MLXSW_REG_SFD_REC_LEN, 0x0C, false);
556
557 /* reg_sfd_uc_tunnel_uip_lsb
558  * When protocol is IPv4, the least significant bytes of the underlay
559  * IPv4 destination IP.
560  * When protocol is IPv6, pointer to the underlay IPv6 destination IP
561  * which is configured by RIPS.
562  * Access: RW
563  */
564 MLXSW_ITEM32_INDEXED(reg, sfd, uc_tunnel_uip_lsb, MLXSW_REG_SFD_BASE_LEN, 0,
565                      24, MLXSW_REG_SFD_REC_LEN, 0x0C, false);
566
567 static inline void
568 mlxsw_reg_sfd_uc_tunnel_pack(char *payload, int rec_index,
569                              enum mlxsw_reg_sfd_rec_policy policy,
570                              const char *mac, u16 fid,
571                              enum mlxsw_reg_sfd_rec_action action, u32 uip,
572                              enum mlxsw_reg_sfd_uc_tunnel_protocol proto)
573 {
574         mlxsw_reg_sfd_rec_pack(payload, rec_index,
575                                MLXSW_REG_SFD_REC_TYPE_UNICAST_TUNNEL, mac,
576                                action);
577         mlxsw_reg_sfd_rec_policy_set(payload, rec_index, policy);
578         mlxsw_reg_sfd_uc_tunnel_uip_msb_set(payload, rec_index, uip >> 24);
579         mlxsw_reg_sfd_uc_tunnel_uip_lsb_set(payload, rec_index, uip);
580         mlxsw_reg_sfd_uc_tunnel_fid_set(payload, rec_index, fid);
581         mlxsw_reg_sfd_uc_tunnel_protocol_set(payload, rec_index, proto);
582 }
583
584 /* SFN - Switch FDB Notification Register
585  * -------------------------------------------
586  * The switch provides notifications on newly learned FDB entries and
587  * aged out entries. The notifications can be polled by software.
588  */
589 #define MLXSW_REG_SFN_ID 0x200B
590 #define MLXSW_REG_SFN_BASE_LEN 0x10 /* base length, without records */
591 #define MLXSW_REG_SFN_REC_LEN 0x10 /* record length */
592 #define MLXSW_REG_SFN_REC_MAX_COUNT 64
593 #define MLXSW_REG_SFN_LEN (MLXSW_REG_SFN_BASE_LEN +     \
594                            MLXSW_REG_SFN_REC_LEN * MLXSW_REG_SFN_REC_MAX_COUNT)
595
596 MLXSW_REG_DEFINE(sfn, MLXSW_REG_SFN_ID, MLXSW_REG_SFN_LEN);
597
598 /* reg_sfn_swid
599  * Switch partition ID.
600  * Access: Index
601  */
602 MLXSW_ITEM32(reg, sfn, swid, 0x00, 24, 8);
603
604 /* reg_sfn_end
605  * Forces the current session to end.
606  * Access: OP
607  */
608 MLXSW_ITEM32(reg, sfn, end, 0x04, 20, 1);
609
610 /* reg_sfn_num_rec
611  * Request: Number of learned notifications and aged-out notification
612  * records requested.
613  * Response: Number of notification records returned (must be smaller
614  * than or equal to the value requested)
615  * Ranges 0..64
616  * Access: OP
617  */
618 MLXSW_ITEM32(reg, sfn, num_rec, 0x04, 0, 8);
619
620 static inline void mlxsw_reg_sfn_pack(char *payload)
621 {
622         MLXSW_REG_ZERO(sfn, payload);
623         mlxsw_reg_sfn_swid_set(payload, 0);
624         mlxsw_reg_sfn_end_set(payload, 1);
625         mlxsw_reg_sfn_num_rec_set(payload, MLXSW_REG_SFN_REC_MAX_COUNT);
626 }
627
628 /* reg_sfn_rec_swid
629  * Switch partition ID.
630  * Access: RO
631  */
632 MLXSW_ITEM32_INDEXED(reg, sfn, rec_swid, MLXSW_REG_SFN_BASE_LEN, 24, 8,
633                      MLXSW_REG_SFN_REC_LEN, 0x00, false);
634
635 enum mlxsw_reg_sfn_rec_type {
636         /* MAC addresses learned on a regular port. */
637         MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC = 0x5,
638         /* MAC addresses learned on a LAG port. */
639         MLXSW_REG_SFN_REC_TYPE_LEARNED_MAC_LAG = 0x6,
640         /* Aged-out MAC address on a regular port. */
641         MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC = 0x7,
642         /* Aged-out MAC address on a LAG port. */
643         MLXSW_REG_SFN_REC_TYPE_AGED_OUT_MAC_LAG = 0x8,
644 };
645
646 /* reg_sfn_rec_type
647  * Notification record type.
648  * Access: RO
649  */
650 MLXSW_ITEM32_INDEXED(reg, sfn, rec_type, MLXSW_REG_SFN_BASE_LEN, 20, 4,
651                      MLXSW_REG_SFN_REC_LEN, 0x00, false);
652
653 /* reg_sfn_rec_mac
654  * MAC address.
655  * Access: RO
656  */
657 MLXSW_ITEM_BUF_INDEXED(reg, sfn, rec_mac, MLXSW_REG_SFN_BASE_LEN, 6,
658                        MLXSW_REG_SFN_REC_LEN, 0x02);
659
660 /* reg_sfn_mac_sub_port
661  * VEPA channel on the local port.
662  * 0 if multichannel VEPA is not enabled.
663  * Access: RO
664  */
665 MLXSW_ITEM32_INDEXED(reg, sfn, mac_sub_port, MLXSW_REG_SFN_BASE_LEN, 16, 8,
666                      MLXSW_REG_SFN_REC_LEN, 0x08, false);
667
668 /* reg_sfn_mac_fid
669  * Filtering identifier.
670  * Access: RO
671  */
672 MLXSW_ITEM32_INDEXED(reg, sfn, mac_fid, MLXSW_REG_SFN_BASE_LEN, 0, 16,
673                      MLXSW_REG_SFN_REC_LEN, 0x08, false);
674
675 /* reg_sfn_mac_system_port
676  * Unique port identifier for the final destination of the packet.
677  * Access: RO
678  */
679 MLXSW_ITEM32_INDEXED(reg, sfn, mac_system_port, MLXSW_REG_SFN_BASE_LEN, 0, 16,
680                      MLXSW_REG_SFN_REC_LEN, 0x0C, false);
681
682 static inline void mlxsw_reg_sfn_mac_unpack(char *payload, int rec_index,
683                                             char *mac, u16 *p_vid,
684                                             u8 *p_local_port)
685 {
686         mlxsw_reg_sfn_rec_mac_memcpy_from(payload, rec_index, mac);
687         *p_vid = mlxsw_reg_sfn_mac_fid_get(payload, rec_index);
688         *p_local_port = mlxsw_reg_sfn_mac_system_port_get(payload, rec_index);
689 }
690
691 /* reg_sfn_mac_lag_lag_id
692  * LAG ID (pointer into the LAG descriptor table).
693  * Access: RO
694  */
695 MLXSW_ITEM32_INDEXED(reg, sfn, mac_lag_lag_id, MLXSW_REG_SFN_BASE_LEN, 0, 10,
696                      MLXSW_REG_SFN_REC_LEN, 0x0C, false);
697
698 static inline void mlxsw_reg_sfn_mac_lag_unpack(char *payload, int rec_index,
699                                                 char *mac, u16 *p_vid,
700                                                 u16 *p_lag_id)
701 {
702         mlxsw_reg_sfn_rec_mac_memcpy_from(payload, rec_index, mac);
703         *p_vid = mlxsw_reg_sfn_mac_fid_get(payload, rec_index);
704         *p_lag_id = mlxsw_reg_sfn_mac_lag_lag_id_get(payload, rec_index);
705 }
706
707 /* SPMS - Switch Port MSTP/RSTP State Register
708  * -------------------------------------------
709  * Configures the spanning tree state of a physical port.
710  */
711 #define MLXSW_REG_SPMS_ID 0x200D
712 #define MLXSW_REG_SPMS_LEN 0x404
713
714 MLXSW_REG_DEFINE(spms, MLXSW_REG_SPMS_ID, MLXSW_REG_SPMS_LEN);
715
716 /* reg_spms_local_port
717  * Local port number.
718  * Access: Index
719  */
720 MLXSW_ITEM32(reg, spms, local_port, 0x00, 16, 8);
721
722 enum mlxsw_reg_spms_state {
723         MLXSW_REG_SPMS_STATE_NO_CHANGE,
724         MLXSW_REG_SPMS_STATE_DISCARDING,
725         MLXSW_REG_SPMS_STATE_LEARNING,
726         MLXSW_REG_SPMS_STATE_FORWARDING,
727 };
728
729 /* reg_spms_state
730  * Spanning tree state of each VLAN ID (VID) of the local port.
731  * 0 - Do not change spanning tree state (used only when writing).
732  * 1 - Discarding. No learning or forwarding to/from this port (default).
733  * 2 - Learning. Port is learning, but not forwarding.
734  * 3 - Forwarding. Port is learning and forwarding.
735  * Access: RW
736  */
737 MLXSW_ITEM_BIT_ARRAY(reg, spms, state, 0x04, 0x400, 2);
738
739 static inline void mlxsw_reg_spms_pack(char *payload, u8 local_port)
740 {
741         MLXSW_REG_ZERO(spms, payload);
742         mlxsw_reg_spms_local_port_set(payload, local_port);
743 }
744
745 static inline void mlxsw_reg_spms_vid_pack(char *payload, u16 vid,
746                                            enum mlxsw_reg_spms_state state)
747 {
748         mlxsw_reg_spms_state_set(payload, vid, state);
749 }
750
751 /* SPVID - Switch Port VID
752  * -----------------------
753  * The switch port VID configures the default VID for a port.
754  */
755 #define MLXSW_REG_SPVID_ID 0x200E
756 #define MLXSW_REG_SPVID_LEN 0x08
757
758 MLXSW_REG_DEFINE(spvid, MLXSW_REG_SPVID_ID, MLXSW_REG_SPVID_LEN);
759
760 /* reg_spvid_local_port
761  * Local port number.
762  * Access: Index
763  */
764 MLXSW_ITEM32(reg, spvid, local_port, 0x00, 16, 8);
765
766 /* reg_spvid_sub_port
767  * Virtual port within the physical port.
768  * Should be set to 0 when virtual ports are not enabled on the port.
769  * Access: Index
770  */
771 MLXSW_ITEM32(reg, spvid, sub_port, 0x00, 8, 8);
772
773 /* reg_spvid_pvid
774  * Port default VID
775  * Access: RW
776  */
777 MLXSW_ITEM32(reg, spvid, pvid, 0x04, 0, 12);
778
779 static inline void mlxsw_reg_spvid_pack(char *payload, u8 local_port, u16 pvid)
780 {
781         MLXSW_REG_ZERO(spvid, payload);
782         mlxsw_reg_spvid_local_port_set(payload, local_port);
783         mlxsw_reg_spvid_pvid_set(payload, pvid);
784 }
785
786 /* SPVM - Switch Port VLAN Membership
787  * ----------------------------------
788  * The Switch Port VLAN Membership register configures the VLAN membership
789  * of a port in a VLAN denoted by VID. VLAN membership is managed per
790  * virtual port. The register can be used to add and remove VID(s) from a port.
791  */
792 #define MLXSW_REG_SPVM_ID 0x200F
793 #define MLXSW_REG_SPVM_BASE_LEN 0x04 /* base length, without records */
794 #define MLXSW_REG_SPVM_REC_LEN 0x04 /* record length */
795 #define MLXSW_REG_SPVM_REC_MAX_COUNT 255
796 #define MLXSW_REG_SPVM_LEN (MLXSW_REG_SPVM_BASE_LEN +   \
797                     MLXSW_REG_SPVM_REC_LEN * MLXSW_REG_SPVM_REC_MAX_COUNT)
798
799 MLXSW_REG_DEFINE(spvm, MLXSW_REG_SPVM_ID, MLXSW_REG_SPVM_LEN);
800
801 /* reg_spvm_pt
802  * Priority tagged. If this bit is set, packets forwarded to the port with
803  * untagged VLAN membership (u bit is set) will be tagged with priority tag
804  * (VID=0)
805  * Access: RW
806  */
807 MLXSW_ITEM32(reg, spvm, pt, 0x00, 31, 1);
808
809 /* reg_spvm_pte
810  * Priority Tagged Update Enable. On Write operations, if this bit is cleared,
811  * the pt bit will NOT be updated. To update the pt bit, pte must be set.
812  * Access: WO
813  */
814 MLXSW_ITEM32(reg, spvm, pte, 0x00, 30, 1);
815
816 /* reg_spvm_local_port
817  * Local port number.
818  * Access: Index
819  */
820 MLXSW_ITEM32(reg, spvm, local_port, 0x00, 16, 8);
821
822 /* reg_spvm_sub_port
823  * Virtual port within the physical port.
824  * Should be set to 0 when virtual ports are not enabled on the port.
825  * Access: Index
826  */
827 MLXSW_ITEM32(reg, spvm, sub_port, 0x00, 8, 8);
828
829 /* reg_spvm_num_rec
830  * Number of records to update. Each record contains: i, e, u, vid.
831  * Access: OP
832  */
833 MLXSW_ITEM32(reg, spvm, num_rec, 0x00, 0, 8);
834
835 /* reg_spvm_rec_i
836  * Ingress membership in VLAN ID.
837  * Access: Index
838  */
839 MLXSW_ITEM32_INDEXED(reg, spvm, rec_i,
840                      MLXSW_REG_SPVM_BASE_LEN, 14, 1,
841                      MLXSW_REG_SPVM_REC_LEN, 0, false);
842
843 /* reg_spvm_rec_e
844  * Egress membership in VLAN ID.
845  * Access: Index
846  */
847 MLXSW_ITEM32_INDEXED(reg, spvm, rec_e,
848                      MLXSW_REG_SPVM_BASE_LEN, 13, 1,
849                      MLXSW_REG_SPVM_REC_LEN, 0, false);
850
851 /* reg_spvm_rec_u
852  * Untagged - port is an untagged member - egress transmission uses untagged
853  * frames on VID<n>
854  * Access: Index
855  */
856 MLXSW_ITEM32_INDEXED(reg, spvm, rec_u,
857                      MLXSW_REG_SPVM_BASE_LEN, 12, 1,
858                      MLXSW_REG_SPVM_REC_LEN, 0, false);
859
860 /* reg_spvm_rec_vid
861  * Egress membership in VLAN ID.
862  * Access: Index
863  */
864 MLXSW_ITEM32_INDEXED(reg, spvm, rec_vid,
865                      MLXSW_REG_SPVM_BASE_LEN, 0, 12,
866                      MLXSW_REG_SPVM_REC_LEN, 0, false);
867
868 static inline void mlxsw_reg_spvm_pack(char *payload, u8 local_port,
869                                        u16 vid_begin, u16 vid_end,
870                                        bool is_member, bool untagged)
871 {
872         int size = vid_end - vid_begin + 1;
873         int i;
874
875         MLXSW_REG_ZERO(spvm, payload);
876         mlxsw_reg_spvm_local_port_set(payload, local_port);
877         mlxsw_reg_spvm_num_rec_set(payload, size);
878
879         for (i = 0; i < size; i++) {
880                 mlxsw_reg_spvm_rec_i_set(payload, i, is_member);
881                 mlxsw_reg_spvm_rec_e_set(payload, i, is_member);
882                 mlxsw_reg_spvm_rec_u_set(payload, i, untagged);
883                 mlxsw_reg_spvm_rec_vid_set(payload, i, vid_begin + i);
884         }
885 }
886
887 /* SPAFT - Switch Port Acceptable Frame Types
888  * ------------------------------------------
889  * The Switch Port Acceptable Frame Types register configures the frame
890  * admittance of the port.
891  */
892 #define MLXSW_REG_SPAFT_ID 0x2010
893 #define MLXSW_REG_SPAFT_LEN 0x08
894
895 MLXSW_REG_DEFINE(spaft, MLXSW_REG_SPAFT_ID, MLXSW_REG_SPAFT_LEN);
896
897 /* reg_spaft_local_port
898  * Local port number.
899  * Access: Index
900  *
901  * Note: CPU port is not supported (all tag types are allowed).
902  */
903 MLXSW_ITEM32(reg, spaft, local_port, 0x00, 16, 8);
904
905 /* reg_spaft_sub_port
906  * Virtual port within the physical port.
907  * Should be set to 0 when virtual ports are not enabled on the port.
908  * Access: RW
909  */
910 MLXSW_ITEM32(reg, spaft, sub_port, 0x00, 8, 8);
911
912 /* reg_spaft_allow_untagged
913  * When set, untagged frames on the ingress are allowed (default).
914  * Access: RW
915  */
916 MLXSW_ITEM32(reg, spaft, allow_untagged, 0x04, 31, 1);
917
918 /* reg_spaft_allow_prio_tagged
919  * When set, priority tagged frames on the ingress are allowed (default).
920  * Access: RW
921  */
922 MLXSW_ITEM32(reg, spaft, allow_prio_tagged, 0x04, 30, 1);
923
924 /* reg_spaft_allow_tagged
925  * When set, tagged frames on the ingress are allowed (default).
926  * Access: RW
927  */
928 MLXSW_ITEM32(reg, spaft, allow_tagged, 0x04, 29, 1);
929
930 static inline void mlxsw_reg_spaft_pack(char *payload, u8 local_port,
931                                         bool allow_untagged)
932 {
933         MLXSW_REG_ZERO(spaft, payload);
934         mlxsw_reg_spaft_local_port_set(payload, local_port);
935         mlxsw_reg_spaft_allow_untagged_set(payload, allow_untagged);
936         mlxsw_reg_spaft_allow_prio_tagged_set(payload, true);
937         mlxsw_reg_spaft_allow_tagged_set(payload, true);
938 }
939
940 /* SFGC - Switch Flooding Group Configuration
941  * ------------------------------------------
942  * The following register controls the association of flooding tables and MIDs
943  * to packet types used for flooding.
944  */
945 #define MLXSW_REG_SFGC_ID 0x2011
946 #define MLXSW_REG_SFGC_LEN 0x10
947
948 MLXSW_REG_DEFINE(sfgc, MLXSW_REG_SFGC_ID, MLXSW_REG_SFGC_LEN);
949
950 enum mlxsw_reg_sfgc_type {
951         MLXSW_REG_SFGC_TYPE_BROADCAST,
952         MLXSW_REG_SFGC_TYPE_UNKNOWN_UNICAST,
953         MLXSW_REG_SFGC_TYPE_UNREGISTERED_MULTICAST_IPV4,
954         MLXSW_REG_SFGC_TYPE_UNREGISTERED_MULTICAST_IPV6,
955         MLXSW_REG_SFGC_TYPE_RESERVED,
956         MLXSW_REG_SFGC_TYPE_UNREGISTERED_MULTICAST_NON_IP,
957         MLXSW_REG_SFGC_TYPE_IPV4_LINK_LOCAL,
958         MLXSW_REG_SFGC_TYPE_IPV6_ALL_HOST,
959         MLXSW_REG_SFGC_TYPE_MAX,
960 };
961
962 /* reg_sfgc_type
963  * The traffic type to reach the flooding table.
964  * Access: Index
965  */
966 MLXSW_ITEM32(reg, sfgc, type, 0x00, 0, 4);
967
968 enum mlxsw_reg_sfgc_bridge_type {
969         MLXSW_REG_SFGC_BRIDGE_TYPE_1Q_FID = 0,
970         MLXSW_REG_SFGC_BRIDGE_TYPE_VFID = 1,
971 };
972
973 /* reg_sfgc_bridge_type
974  * Access: Index
975  *
976  * Note: SwitchX-2 only supports 802.1Q mode.
977  */
978 MLXSW_ITEM32(reg, sfgc, bridge_type, 0x04, 24, 3);
979
980 enum mlxsw_flood_table_type {
981         MLXSW_REG_SFGC_TABLE_TYPE_VID = 1,
982         MLXSW_REG_SFGC_TABLE_TYPE_SINGLE = 2,
983         MLXSW_REG_SFGC_TABLE_TYPE_ANY = 0,
984         MLXSW_REG_SFGC_TABLE_TYPE_FID_OFFSET = 3,
985         MLXSW_REG_SFGC_TABLE_TYPE_FID = 4,
986 };
987
988 /* reg_sfgc_table_type
989  * See mlxsw_flood_table_type
990  * Access: RW
991  *
992  * Note: FID offset and FID types are not supported in SwitchX-2.
993  */
994 MLXSW_ITEM32(reg, sfgc, table_type, 0x04, 16, 3);
995
996 /* reg_sfgc_flood_table
997  * Flooding table index to associate with the specific type on the specific
998  * switch partition.
999  * Access: RW
1000  */
1001 MLXSW_ITEM32(reg, sfgc, flood_table, 0x04, 0, 6);
1002
1003 /* reg_sfgc_mid
1004  * The multicast ID for the swid. Not supported for Spectrum
1005  * Access: RW
1006  */
1007 MLXSW_ITEM32(reg, sfgc, mid, 0x08, 0, 16);
1008
1009 /* reg_sfgc_counter_set_type
1010  * Counter Set Type for flow counters.
1011  * Access: RW
1012  */
1013 MLXSW_ITEM32(reg, sfgc, counter_set_type, 0x0C, 24, 8);
1014
1015 /* reg_sfgc_counter_index
1016  * Counter Index for flow counters.
1017  * Access: RW
1018  */
1019 MLXSW_ITEM32(reg, sfgc, counter_index, 0x0C, 0, 24);
1020
1021 static inline void
1022 mlxsw_reg_sfgc_pack(char *payload, enum mlxsw_reg_sfgc_type type,
1023                     enum mlxsw_reg_sfgc_bridge_type bridge_type,
1024                     enum mlxsw_flood_table_type table_type,
1025                     unsigned int flood_table)
1026 {
1027         MLXSW_REG_ZERO(sfgc, payload);
1028         mlxsw_reg_sfgc_type_set(payload, type);
1029         mlxsw_reg_sfgc_bridge_type_set(payload, bridge_type);
1030         mlxsw_reg_sfgc_table_type_set(payload, table_type);
1031         mlxsw_reg_sfgc_flood_table_set(payload, flood_table);
1032         mlxsw_reg_sfgc_mid_set(payload, MLXSW_PORT_MID);
1033 }
1034
1035 /* SFTR - Switch Flooding Table Register
1036  * -------------------------------------
1037  * The switch flooding table is used for flooding packet replication. The table
1038  * defines a bit mask of ports for packet replication.
1039  */
1040 #define MLXSW_REG_SFTR_ID 0x2012
1041 #define MLXSW_REG_SFTR_LEN 0x420
1042
1043 MLXSW_REG_DEFINE(sftr, MLXSW_REG_SFTR_ID, MLXSW_REG_SFTR_LEN);
1044
1045 /* reg_sftr_swid
1046  * Switch partition ID with which to associate the port.
1047  * Access: Index
1048  */
1049 MLXSW_ITEM32(reg, sftr, swid, 0x00, 24, 8);
1050
1051 /* reg_sftr_flood_table
1052  * Flooding table index to associate with the specific type on the specific
1053  * switch partition.
1054  * Access: Index
1055  */
1056 MLXSW_ITEM32(reg, sftr, flood_table, 0x00, 16, 6);
1057
1058 /* reg_sftr_index
1059  * Index. Used as an index into the Flooding Table in case the table is
1060  * configured to use VID / FID or FID Offset.
1061  * Access: Index
1062  */
1063 MLXSW_ITEM32(reg, sftr, index, 0x00, 0, 16);
1064
1065 /* reg_sftr_table_type
1066  * See mlxsw_flood_table_type
1067  * Access: RW
1068  */
1069 MLXSW_ITEM32(reg, sftr, table_type, 0x04, 16, 3);
1070
1071 /* reg_sftr_range
1072  * Range of entries to update
1073  * Access: Index
1074  */
1075 MLXSW_ITEM32(reg, sftr, range, 0x04, 0, 16);
1076
1077 /* reg_sftr_port
1078  * Local port membership (1 bit per port).
1079  * Access: RW
1080  */
1081 MLXSW_ITEM_BIT_ARRAY(reg, sftr, port, 0x20, 0x20, 1);
1082
1083 /* reg_sftr_cpu_port_mask
1084  * CPU port mask (1 bit per port).
1085  * Access: W
1086  */
1087 MLXSW_ITEM_BIT_ARRAY(reg, sftr, port_mask, 0x220, 0x20, 1);
1088
1089 static inline void mlxsw_reg_sftr_pack(char *payload,
1090                                        unsigned int flood_table,
1091                                        unsigned int index,
1092                                        enum mlxsw_flood_table_type table_type,
1093                                        unsigned int range, u8 port, bool set)
1094 {
1095         MLXSW_REG_ZERO(sftr, payload);
1096         mlxsw_reg_sftr_swid_set(payload, 0);
1097         mlxsw_reg_sftr_flood_table_set(payload, flood_table);
1098         mlxsw_reg_sftr_index_set(payload, index);
1099         mlxsw_reg_sftr_table_type_set(payload, table_type);
1100         mlxsw_reg_sftr_range_set(payload, range);
1101         mlxsw_reg_sftr_port_set(payload, port, set);
1102         mlxsw_reg_sftr_port_mask_set(payload, port, 1);
1103 }
1104
1105 /* SFDF - Switch Filtering DB Flush
1106  * --------------------------------
1107  * The switch filtering DB flush register is used to flush the FDB.
1108  * Note that FDB notifications are flushed as well.
1109  */
1110 #define MLXSW_REG_SFDF_ID 0x2013
1111 #define MLXSW_REG_SFDF_LEN 0x14
1112
1113 MLXSW_REG_DEFINE(sfdf, MLXSW_REG_SFDF_ID, MLXSW_REG_SFDF_LEN);
1114
1115 /* reg_sfdf_swid
1116  * Switch partition ID.
1117  * Access: Index
1118  */
1119 MLXSW_ITEM32(reg, sfdf, swid, 0x00, 24, 8);
1120
1121 enum mlxsw_reg_sfdf_flush_type {
1122         MLXSW_REG_SFDF_FLUSH_PER_SWID,
1123         MLXSW_REG_SFDF_FLUSH_PER_FID,
1124         MLXSW_REG_SFDF_FLUSH_PER_PORT,
1125         MLXSW_REG_SFDF_FLUSH_PER_PORT_AND_FID,
1126         MLXSW_REG_SFDF_FLUSH_PER_LAG,
1127         MLXSW_REG_SFDF_FLUSH_PER_LAG_AND_FID,
1128         MLXSW_REG_SFDF_FLUSH_PER_NVE,
1129         MLXSW_REG_SFDF_FLUSH_PER_NVE_AND_FID,
1130 };
1131
1132 /* reg_sfdf_flush_type
1133  * Flush type.
1134  * 0 - All SWID dynamic entries are flushed.
1135  * 1 - All FID dynamic entries are flushed.
1136  * 2 - All dynamic entries pointing to port are flushed.
1137  * 3 - All FID dynamic entries pointing to port are flushed.
1138  * 4 - All dynamic entries pointing to LAG are flushed.
1139  * 5 - All FID dynamic entries pointing to LAG are flushed.
1140  * 6 - All entries of type "Unicast Tunnel" or "Multicast Tunnel" are
1141  *     flushed.
1142  * 7 - All entries of type "Unicast Tunnel" or "Multicast Tunnel" are
1143  *     flushed, per FID.
1144  * Access: RW
1145  */
1146 MLXSW_ITEM32(reg, sfdf, flush_type, 0x04, 28, 4);
1147
1148 /* reg_sfdf_flush_static
1149  * Static.
1150  * 0 - Flush only dynamic entries.
1151  * 1 - Flush both dynamic and static entries.
1152  * Access: RW
1153  */
1154 MLXSW_ITEM32(reg, sfdf, flush_static, 0x04, 24, 1);
1155
1156 static inline void mlxsw_reg_sfdf_pack(char *payload,
1157                                        enum mlxsw_reg_sfdf_flush_type type)
1158 {
1159         MLXSW_REG_ZERO(sfdf, payload);
1160         mlxsw_reg_sfdf_flush_type_set(payload, type);
1161         mlxsw_reg_sfdf_flush_static_set(payload, true);
1162 }
1163
1164 /* reg_sfdf_fid
1165  * FID to flush.
1166  * Access: RW
1167  */
1168 MLXSW_ITEM32(reg, sfdf, fid, 0x0C, 0, 16);
1169
1170 /* reg_sfdf_system_port
1171  * Port to flush.
1172  * Access: RW
1173  */
1174 MLXSW_ITEM32(reg, sfdf, system_port, 0x0C, 0, 16);
1175
1176 /* reg_sfdf_port_fid_system_port
1177  * Port to flush, pointed to by FID.
1178  * Access: RW
1179  */
1180 MLXSW_ITEM32(reg, sfdf, port_fid_system_port, 0x08, 0, 16);
1181
1182 /* reg_sfdf_lag_id
1183  * LAG ID to flush.
1184  * Access: RW
1185  */
1186 MLXSW_ITEM32(reg, sfdf, lag_id, 0x0C, 0, 10);
1187
1188 /* reg_sfdf_lag_fid_lag_id
1189  * LAG ID to flush, pointed to by FID.
1190  * Access: RW
1191  */
1192 MLXSW_ITEM32(reg, sfdf, lag_fid_lag_id, 0x08, 0, 10);
1193
1194 /* SLDR - Switch LAG Descriptor Register
1195  * -----------------------------------------
1196  * The switch LAG descriptor register is populated by LAG descriptors.
1197  * Each LAG descriptor is indexed by lag_id. The LAG ID runs from 0 to
1198  * max_lag-1.
1199  */
1200 #define MLXSW_REG_SLDR_ID 0x2014
1201 #define MLXSW_REG_SLDR_LEN 0x0C /* counting in only one port in list */
1202
1203 MLXSW_REG_DEFINE(sldr, MLXSW_REG_SLDR_ID, MLXSW_REG_SLDR_LEN);
1204
1205 enum mlxsw_reg_sldr_op {
1206         /* Indicates a creation of a new LAG-ID, lag_id must be valid */
1207         MLXSW_REG_SLDR_OP_LAG_CREATE,
1208         MLXSW_REG_SLDR_OP_LAG_DESTROY,
1209         /* Ports that appear in the list have the Distributor enabled */
1210         MLXSW_REG_SLDR_OP_LAG_ADD_PORT_LIST,
1211         /* Removes ports from the disributor list */
1212         MLXSW_REG_SLDR_OP_LAG_REMOVE_PORT_LIST,
1213 };
1214
1215 /* reg_sldr_op
1216  * Operation.
1217  * Access: RW
1218  */
1219 MLXSW_ITEM32(reg, sldr, op, 0x00, 29, 3);
1220
1221 /* reg_sldr_lag_id
1222  * LAG identifier. The lag_id is the index into the LAG descriptor table.
1223  * Access: Index
1224  */
1225 MLXSW_ITEM32(reg, sldr, lag_id, 0x00, 0, 10);
1226
1227 static inline void mlxsw_reg_sldr_lag_create_pack(char *payload, u8 lag_id)
1228 {
1229         MLXSW_REG_ZERO(sldr, payload);
1230         mlxsw_reg_sldr_op_set(payload, MLXSW_REG_SLDR_OP_LAG_CREATE);
1231         mlxsw_reg_sldr_lag_id_set(payload, lag_id);
1232 }
1233
1234 static inline void mlxsw_reg_sldr_lag_destroy_pack(char *payload, u8 lag_id)
1235 {
1236         MLXSW_REG_ZERO(sldr, payload);
1237         mlxsw_reg_sldr_op_set(payload, MLXSW_REG_SLDR_OP_LAG_DESTROY);
1238         mlxsw_reg_sldr_lag_id_set(payload, lag_id);
1239 }
1240
1241 /* reg_sldr_num_ports
1242  * The number of member ports of the LAG.
1243  * Reserved for Create / Destroy operations
1244  * For Add / Remove operations - indicates the number of ports in the list.
1245  * Access: RW
1246  */
1247 MLXSW_ITEM32(reg, sldr, num_ports, 0x04, 24, 8);
1248
1249 /* reg_sldr_system_port
1250  * System port.
1251  * Access: RW
1252  */
1253 MLXSW_ITEM32_INDEXED(reg, sldr, system_port, 0x08, 0, 16, 4, 0, false);
1254
1255 static inline void mlxsw_reg_sldr_lag_add_port_pack(char *payload, u8 lag_id,
1256                                                     u8 local_port)
1257 {
1258         MLXSW_REG_ZERO(sldr, payload);
1259         mlxsw_reg_sldr_op_set(payload, MLXSW_REG_SLDR_OP_LAG_ADD_PORT_LIST);
1260         mlxsw_reg_sldr_lag_id_set(payload, lag_id);
1261         mlxsw_reg_sldr_num_ports_set(payload, 1);
1262         mlxsw_reg_sldr_system_port_set(payload, 0, local_port);
1263 }
1264
1265 static inline void mlxsw_reg_sldr_lag_remove_port_pack(char *payload, u8 lag_id,
1266                                                        u8 local_port)
1267 {
1268         MLXSW_REG_ZERO(sldr, payload);
1269         mlxsw_reg_sldr_op_set(payload, MLXSW_REG_SLDR_OP_LAG_REMOVE_PORT_LIST);
1270         mlxsw_reg_sldr_lag_id_set(payload, lag_id);
1271         mlxsw_reg_sldr_num_ports_set(payload, 1);
1272         mlxsw_reg_sldr_system_port_set(payload, 0, local_port);
1273 }
1274
1275 /* SLCR - Switch LAG Configuration 2 Register
1276  * -------------------------------------------
1277  * The Switch LAG Configuration register is used for configuring the
1278  * LAG properties of the switch.
1279  */
1280 #define MLXSW_REG_SLCR_ID 0x2015
1281 #define MLXSW_REG_SLCR_LEN 0x10
1282
1283 MLXSW_REG_DEFINE(slcr, MLXSW_REG_SLCR_ID, MLXSW_REG_SLCR_LEN);
1284
1285 enum mlxsw_reg_slcr_pp {
1286         /* Global Configuration (for all ports) */
1287         MLXSW_REG_SLCR_PP_GLOBAL,
1288         /* Per port configuration, based on local_port field */
1289         MLXSW_REG_SLCR_PP_PER_PORT,
1290 };
1291
1292 /* reg_slcr_pp
1293  * Per Port Configuration
1294  * Note: Reading at Global mode results in reading port 1 configuration.
1295  * Access: Index
1296  */
1297 MLXSW_ITEM32(reg, slcr, pp, 0x00, 24, 1);
1298
1299 /* reg_slcr_local_port
1300  * Local port number
1301  * Supported from CPU port
1302  * Not supported from router port
1303  * Reserved when pp = Global Configuration
1304  * Access: Index
1305  */
1306 MLXSW_ITEM32(reg, slcr, local_port, 0x00, 16, 8);
1307
1308 enum mlxsw_reg_slcr_type {
1309         MLXSW_REG_SLCR_TYPE_CRC, /* default */
1310         MLXSW_REG_SLCR_TYPE_XOR,
1311         MLXSW_REG_SLCR_TYPE_RANDOM,
1312 };
1313
1314 /* reg_slcr_type
1315  * Hash type
1316  * Access: RW
1317  */
1318 MLXSW_ITEM32(reg, slcr, type, 0x00, 0, 4);
1319
1320 /* Ingress port */
1321 #define MLXSW_REG_SLCR_LAG_HASH_IN_PORT         BIT(0)
1322 /* SMAC - for IPv4 and IPv6 packets */
1323 #define MLXSW_REG_SLCR_LAG_HASH_SMAC_IP         BIT(1)
1324 /* SMAC - for non-IP packets */
1325 #define MLXSW_REG_SLCR_LAG_HASH_SMAC_NONIP      BIT(2)
1326 #define MLXSW_REG_SLCR_LAG_HASH_SMAC \
1327         (MLXSW_REG_SLCR_LAG_HASH_SMAC_IP | \
1328          MLXSW_REG_SLCR_LAG_HASH_SMAC_NONIP)
1329 /* DMAC - for IPv4 and IPv6 packets */
1330 #define MLXSW_REG_SLCR_LAG_HASH_DMAC_IP         BIT(3)
1331 /* DMAC - for non-IP packets */
1332 #define MLXSW_REG_SLCR_LAG_HASH_DMAC_NONIP      BIT(4)
1333 #define MLXSW_REG_SLCR_LAG_HASH_DMAC \
1334         (MLXSW_REG_SLCR_LAG_HASH_DMAC_IP | \
1335          MLXSW_REG_SLCR_LAG_HASH_DMAC_NONIP)
1336 /* Ethertype - for IPv4 and IPv6 packets */
1337 #define MLXSW_REG_SLCR_LAG_HASH_ETHERTYPE_IP    BIT(5)
1338 /* Ethertype - for non-IP packets */
1339 #define MLXSW_REG_SLCR_LAG_HASH_ETHERTYPE_NONIP BIT(6)
1340 #define MLXSW_REG_SLCR_LAG_HASH_ETHERTYPE \
1341         (MLXSW_REG_SLCR_LAG_HASH_ETHERTYPE_IP | \
1342          MLXSW_REG_SLCR_LAG_HASH_ETHERTYPE_NONIP)
1343 /* VLAN ID - for IPv4 and IPv6 packets */
1344 #define MLXSW_REG_SLCR_LAG_HASH_VLANID_IP       BIT(7)
1345 /* VLAN ID - for non-IP packets */
1346 #define MLXSW_REG_SLCR_LAG_HASH_VLANID_NONIP    BIT(8)
1347 #define MLXSW_REG_SLCR_LAG_HASH_VLANID \
1348         (MLXSW_REG_SLCR_LAG_HASH_VLANID_IP | \
1349          MLXSW_REG_SLCR_LAG_HASH_VLANID_NONIP)
1350 /* Source IP address (can be IPv4 or IPv6) */
1351 #define MLXSW_REG_SLCR_LAG_HASH_SIP             BIT(9)
1352 /* Destination IP address (can be IPv4 or IPv6) */
1353 #define MLXSW_REG_SLCR_LAG_HASH_DIP             BIT(10)
1354 /* TCP/UDP source port */
1355 #define MLXSW_REG_SLCR_LAG_HASH_SPORT           BIT(11)
1356 /* TCP/UDP destination port*/
1357 #define MLXSW_REG_SLCR_LAG_HASH_DPORT           BIT(12)
1358 /* IPv4 Protocol/IPv6 Next Header */
1359 #define MLXSW_REG_SLCR_LAG_HASH_IPPROTO         BIT(13)
1360 /* IPv6 Flow label */
1361 #define MLXSW_REG_SLCR_LAG_HASH_FLOWLABEL       BIT(14)
1362 /* SID - FCoE source ID */
1363 #define MLXSW_REG_SLCR_LAG_HASH_FCOE_SID        BIT(15)
1364 /* DID - FCoE destination ID */
1365 #define MLXSW_REG_SLCR_LAG_HASH_FCOE_DID        BIT(16)
1366 /* OXID - FCoE originator exchange ID */
1367 #define MLXSW_REG_SLCR_LAG_HASH_FCOE_OXID       BIT(17)
1368 /* Destination QP number - for RoCE packets */
1369 #define MLXSW_REG_SLCR_LAG_HASH_ROCE_DQP        BIT(19)
1370
1371 /* reg_slcr_lag_hash
1372  * LAG hashing configuration. This is a bitmask, in which each set
1373  * bit includes the corresponding item in the LAG hash calculation.
1374  * The default lag_hash contains SMAC, DMAC, VLANID and
1375  * Ethertype (for all packet types).
1376  * Access: RW
1377  */
1378 MLXSW_ITEM32(reg, slcr, lag_hash, 0x04, 0, 20);
1379
1380 /* reg_slcr_seed
1381  * LAG seed value. The seed is the same for all ports.
1382  * Access: RW
1383  */
1384 MLXSW_ITEM32(reg, slcr, seed, 0x08, 0, 32);
1385
1386 static inline void mlxsw_reg_slcr_pack(char *payload, u16 lag_hash, u32 seed)
1387 {
1388         MLXSW_REG_ZERO(slcr, payload);
1389         mlxsw_reg_slcr_pp_set(payload, MLXSW_REG_SLCR_PP_GLOBAL);
1390         mlxsw_reg_slcr_type_set(payload, MLXSW_REG_SLCR_TYPE_CRC);
1391         mlxsw_reg_slcr_lag_hash_set(payload, lag_hash);
1392         mlxsw_reg_slcr_seed_set(payload, seed);
1393 }
1394
1395 /* SLCOR - Switch LAG Collector Register
1396  * -------------------------------------
1397  * The Switch LAG Collector register controls the Local Port membership
1398  * in a LAG and enablement of the collector.
1399  */
1400 #define MLXSW_REG_SLCOR_ID 0x2016
1401 #define MLXSW_REG_SLCOR_LEN 0x10
1402
1403 MLXSW_REG_DEFINE(slcor, MLXSW_REG_SLCOR_ID, MLXSW_REG_SLCOR_LEN);
1404
1405 enum mlxsw_reg_slcor_col {
1406         /* Port is added with collector disabled */
1407         MLXSW_REG_SLCOR_COL_LAG_ADD_PORT,
1408         MLXSW_REG_SLCOR_COL_LAG_COLLECTOR_ENABLED,
1409         MLXSW_REG_SLCOR_COL_LAG_COLLECTOR_DISABLED,
1410         MLXSW_REG_SLCOR_COL_LAG_REMOVE_PORT,
1411 };
1412
1413 /* reg_slcor_col
1414  * Collector configuration
1415  * Access: RW
1416  */
1417 MLXSW_ITEM32(reg, slcor, col, 0x00, 30, 2);
1418
1419 /* reg_slcor_local_port
1420  * Local port number
1421  * Not supported for CPU port
1422  * Access: Index
1423  */
1424 MLXSW_ITEM32(reg, slcor, local_port, 0x00, 16, 8);
1425
1426 /* reg_slcor_lag_id
1427  * LAG Identifier. Index into the LAG descriptor table.
1428  * Access: Index
1429  */
1430 MLXSW_ITEM32(reg, slcor, lag_id, 0x00, 0, 10);
1431
1432 /* reg_slcor_port_index
1433  * Port index in the LAG list. Only valid on Add Port to LAG col.
1434  * Valid range is from 0 to cap_max_lag_members-1
1435  * Access: RW
1436  */
1437 MLXSW_ITEM32(reg, slcor, port_index, 0x04, 0, 10);
1438
1439 static inline void mlxsw_reg_slcor_pack(char *payload,
1440                                         u8 local_port, u16 lag_id,
1441                                         enum mlxsw_reg_slcor_col col)
1442 {
1443         MLXSW_REG_ZERO(slcor, payload);
1444         mlxsw_reg_slcor_col_set(payload, col);
1445         mlxsw_reg_slcor_local_port_set(payload, local_port);
1446         mlxsw_reg_slcor_lag_id_set(payload, lag_id);
1447 }
1448
1449 static inline void mlxsw_reg_slcor_port_add_pack(char *payload,
1450                                                  u8 local_port, u16 lag_id,
1451                                                  u8 port_index)
1452 {
1453         mlxsw_reg_slcor_pack(payload, local_port, lag_id,
1454                              MLXSW_REG_SLCOR_COL_LAG_ADD_PORT);
1455         mlxsw_reg_slcor_port_index_set(payload, port_index);
1456 }
1457
1458 static inline void mlxsw_reg_slcor_port_remove_pack(char *payload,
1459                                                     u8 local_port, u16 lag_id)
1460 {
1461         mlxsw_reg_slcor_pack(payload, local_port, lag_id,
1462                              MLXSW_REG_SLCOR_COL_LAG_REMOVE_PORT);
1463 }
1464
1465 static inline void mlxsw_reg_slcor_col_enable_pack(char *payload,
1466                                                    u8 local_port, u16 lag_id)
1467 {
1468         mlxsw_reg_slcor_pack(payload, local_port, lag_id,
1469                              MLXSW_REG_SLCOR_COL_LAG_COLLECTOR_ENABLED);
1470 }
1471
1472 static inline void mlxsw_reg_slcor_col_disable_pack(char *payload,
1473                                                     u8 local_port, u16 lag_id)
1474 {
1475         mlxsw_reg_slcor_pack(payload, local_port, lag_id,
1476                              MLXSW_REG_SLCOR_COL_LAG_COLLECTOR_ENABLED);
1477 }
1478
1479 /* SPMLR - Switch Port MAC Learning Register
1480  * -----------------------------------------
1481  * Controls the Switch MAC learning policy per port.
1482  */
1483 #define MLXSW_REG_SPMLR_ID 0x2018
1484 #define MLXSW_REG_SPMLR_LEN 0x8
1485
1486 MLXSW_REG_DEFINE(spmlr, MLXSW_REG_SPMLR_ID, MLXSW_REG_SPMLR_LEN);
1487
1488 /* reg_spmlr_local_port
1489  * Local port number.
1490  * Access: Index
1491  */
1492 MLXSW_ITEM32(reg, spmlr, local_port, 0x00, 16, 8);
1493
1494 /* reg_spmlr_sub_port
1495  * Virtual port within the physical port.
1496  * Should be set to 0 when virtual ports are not enabled on the port.
1497  * Access: Index
1498  */
1499 MLXSW_ITEM32(reg, spmlr, sub_port, 0x00, 8, 8);
1500
1501 enum mlxsw_reg_spmlr_learn_mode {
1502         MLXSW_REG_SPMLR_LEARN_MODE_DISABLE = 0,
1503         MLXSW_REG_SPMLR_LEARN_MODE_ENABLE = 2,
1504         MLXSW_REG_SPMLR_LEARN_MODE_SEC = 3,
1505 };
1506
1507 /* reg_spmlr_learn_mode
1508  * Learning mode on the port.
1509  * 0 - Learning disabled.
1510  * 2 - Learning enabled.
1511  * 3 - Security mode.
1512  *
1513  * In security mode the switch does not learn MACs on the port, but uses the
1514  * SMAC to see if it exists on another ingress port. If so, the packet is
1515  * classified as a bad packet and is discarded unless the software registers
1516  * to receive port security error packets usign HPKT.
1517  */
1518 MLXSW_ITEM32(reg, spmlr, learn_mode, 0x04, 30, 2);
1519
1520 static inline void mlxsw_reg_spmlr_pack(char *payload, u8 local_port,
1521                                         enum mlxsw_reg_spmlr_learn_mode mode)
1522 {
1523         MLXSW_REG_ZERO(spmlr, payload);
1524         mlxsw_reg_spmlr_local_port_set(payload, local_port);
1525         mlxsw_reg_spmlr_sub_port_set(payload, 0);
1526         mlxsw_reg_spmlr_learn_mode_set(payload, mode);
1527 }
1528
1529 /* SVFA - Switch VID to FID Allocation Register
1530  * --------------------------------------------
1531  * Controls the VID to FID mapping and {Port, VID} to FID mapping for
1532  * virtualized ports.
1533  */
1534 #define MLXSW_REG_SVFA_ID 0x201C
1535 #define MLXSW_REG_SVFA_LEN 0x10
1536
1537 MLXSW_REG_DEFINE(svfa, MLXSW_REG_SVFA_ID, MLXSW_REG_SVFA_LEN);
1538
1539 /* reg_svfa_swid
1540  * Switch partition ID.
1541  * Access: Index
1542  */
1543 MLXSW_ITEM32(reg, svfa, swid, 0x00, 24, 8);
1544
1545 /* reg_svfa_local_port
1546  * Local port number.
1547  * Access: Index
1548  *
1549  * Note: Reserved for 802.1Q FIDs.
1550  */
1551 MLXSW_ITEM32(reg, svfa, local_port, 0x00, 16, 8);
1552
1553 enum mlxsw_reg_svfa_mt {
1554         MLXSW_REG_SVFA_MT_VID_TO_FID,
1555         MLXSW_REG_SVFA_MT_PORT_VID_TO_FID,
1556 };
1557
1558 /* reg_svfa_mapping_table
1559  * Mapping table:
1560  * 0 - VID to FID
1561  * 1 - {Port, VID} to FID
1562  * Access: Index
1563  *
1564  * Note: Reserved for SwitchX-2.
1565  */
1566 MLXSW_ITEM32(reg, svfa, mapping_table, 0x00, 8, 3);
1567
1568 /* reg_svfa_v
1569  * Valid.
1570  * Valid if set.
1571  * Access: RW
1572  *
1573  * Note: Reserved for SwitchX-2.
1574  */
1575 MLXSW_ITEM32(reg, svfa, v, 0x00, 0, 1);
1576
1577 /* reg_svfa_fid
1578  * Filtering ID.
1579  * Access: RW
1580  */
1581 MLXSW_ITEM32(reg, svfa, fid, 0x04, 16, 16);
1582
1583 /* reg_svfa_vid
1584  * VLAN ID.
1585  * Access: Index
1586  */
1587 MLXSW_ITEM32(reg, svfa, vid, 0x04, 0, 12);
1588
1589 /* reg_svfa_counter_set_type
1590  * Counter set type for flow counters.
1591  * Access: RW
1592  *
1593  * Note: Reserved for SwitchX-2.
1594  */
1595 MLXSW_ITEM32(reg, svfa, counter_set_type, 0x08, 24, 8);
1596
1597 /* reg_svfa_counter_index
1598  * Counter index for flow counters.
1599  * Access: RW
1600  *
1601  * Note: Reserved for SwitchX-2.
1602  */
1603 MLXSW_ITEM32(reg, svfa, counter_index, 0x08, 0, 24);
1604
1605 static inline void mlxsw_reg_svfa_pack(char *payload, u8 local_port,
1606                                        enum mlxsw_reg_svfa_mt mt, bool valid,
1607                                        u16 fid, u16 vid)
1608 {
1609         MLXSW_REG_ZERO(svfa, payload);
1610         local_port = mt == MLXSW_REG_SVFA_MT_VID_TO_FID ? 0 : local_port;
1611         mlxsw_reg_svfa_swid_set(payload, 0);
1612         mlxsw_reg_svfa_local_port_set(payload, local_port);
1613         mlxsw_reg_svfa_mapping_table_set(payload, mt);
1614         mlxsw_reg_svfa_v_set(payload, valid);
1615         mlxsw_reg_svfa_fid_set(payload, fid);
1616         mlxsw_reg_svfa_vid_set(payload, vid);
1617 }
1618
1619 /* SVPE - Switch Virtual-Port Enabling Register
1620  * --------------------------------------------
1621  * Enables port virtualization.
1622  */
1623 #define MLXSW_REG_SVPE_ID 0x201E
1624 #define MLXSW_REG_SVPE_LEN 0x4
1625
1626 MLXSW_REG_DEFINE(svpe, MLXSW_REG_SVPE_ID, MLXSW_REG_SVPE_LEN);
1627
1628 /* reg_svpe_local_port
1629  * Local port number
1630  * Access: Index
1631  *
1632  * Note: CPU port is not supported (uses VLAN mode only).
1633  */
1634 MLXSW_ITEM32(reg, svpe, local_port, 0x00, 16, 8);
1635
1636 /* reg_svpe_vp_en
1637  * Virtual port enable.
1638  * 0 - Disable, VLAN mode (VID to FID).
1639  * 1 - Enable, Virtual port mode ({Port, VID} to FID).
1640  * Access: RW
1641  */
1642 MLXSW_ITEM32(reg, svpe, vp_en, 0x00, 8, 1);
1643
1644 static inline void mlxsw_reg_svpe_pack(char *payload, u8 local_port,
1645                                        bool enable)
1646 {
1647         MLXSW_REG_ZERO(svpe, payload);
1648         mlxsw_reg_svpe_local_port_set(payload, local_port);
1649         mlxsw_reg_svpe_vp_en_set(payload, enable);
1650 }
1651
1652 /* SFMR - Switch FID Management Register
1653  * -------------------------------------
1654  * Creates and configures FIDs.
1655  */
1656 #define MLXSW_REG_SFMR_ID 0x201F
1657 #define MLXSW_REG_SFMR_LEN 0x18
1658
1659 MLXSW_REG_DEFINE(sfmr, MLXSW_REG_SFMR_ID, MLXSW_REG_SFMR_LEN);
1660
1661 enum mlxsw_reg_sfmr_op {
1662         MLXSW_REG_SFMR_OP_CREATE_FID,
1663         MLXSW_REG_SFMR_OP_DESTROY_FID,
1664 };
1665
1666 /* reg_sfmr_op
1667  * Operation.
1668  * 0 - Create or edit FID.
1669  * 1 - Destroy FID.
1670  * Access: WO
1671  */
1672 MLXSW_ITEM32(reg, sfmr, op, 0x00, 24, 4);
1673
1674 /* reg_sfmr_fid
1675  * Filtering ID.
1676  * Access: Index
1677  */
1678 MLXSW_ITEM32(reg, sfmr, fid, 0x00, 0, 16);
1679
1680 /* reg_sfmr_fid_offset
1681  * FID offset.
1682  * Used to point into the flooding table selected by SFGC register if
1683  * the table is of type FID-Offset. Otherwise, this field is reserved.
1684  * Access: RW
1685  */
1686 MLXSW_ITEM32(reg, sfmr, fid_offset, 0x08, 0, 16);
1687
1688 /* reg_sfmr_vtfp
1689  * Valid Tunnel Flood Pointer.
1690  * If not set, then nve_tunnel_flood_ptr is reserved and considered NULL.
1691  * Access: RW
1692  *
1693  * Note: Reserved for 802.1Q FIDs.
1694  */
1695 MLXSW_ITEM32(reg, sfmr, vtfp, 0x0C, 31, 1);
1696
1697 /* reg_sfmr_nve_tunnel_flood_ptr
1698  * Underlay Flooding and BC Pointer.
1699  * Used as a pointer to the first entry of the group based link lists of
1700  * flooding or BC entries (for NVE tunnels).
1701  * Access: RW
1702  */
1703 MLXSW_ITEM32(reg, sfmr, nve_tunnel_flood_ptr, 0x0C, 0, 24);
1704
1705 /* reg_sfmr_vv
1706  * VNI Valid.
1707  * If not set, then vni is reserved.
1708  * Access: RW
1709  *
1710  * Note: Reserved for 802.1Q FIDs.
1711  */
1712 MLXSW_ITEM32(reg, sfmr, vv, 0x10, 31, 1);
1713
1714 /* reg_sfmr_vni
1715  * Virtual Network Identifier.
1716  * Access: RW
1717  *
1718  * Note: A given VNI can only be assigned to one FID.
1719  */
1720 MLXSW_ITEM32(reg, sfmr, vni, 0x10, 0, 24);
1721
1722 static inline void mlxsw_reg_sfmr_pack(char *payload,
1723                                        enum mlxsw_reg_sfmr_op op, u16 fid,
1724                                        u16 fid_offset)
1725 {
1726         MLXSW_REG_ZERO(sfmr, payload);
1727         mlxsw_reg_sfmr_op_set(payload, op);
1728         mlxsw_reg_sfmr_fid_set(payload, fid);
1729         mlxsw_reg_sfmr_fid_offset_set(payload, fid_offset);
1730         mlxsw_reg_sfmr_vtfp_set(payload, false);
1731         mlxsw_reg_sfmr_vv_set(payload, false);
1732 }
1733
1734 /* SPVMLR - Switch Port VLAN MAC Learning Register
1735  * -----------------------------------------------
1736  * Controls the switch MAC learning policy per {Port, VID}.
1737  */
1738 #define MLXSW_REG_SPVMLR_ID 0x2020
1739 #define MLXSW_REG_SPVMLR_BASE_LEN 0x04 /* base length, without records */
1740 #define MLXSW_REG_SPVMLR_REC_LEN 0x04 /* record length */
1741 #define MLXSW_REG_SPVMLR_REC_MAX_COUNT 255
1742 #define MLXSW_REG_SPVMLR_LEN (MLXSW_REG_SPVMLR_BASE_LEN + \
1743                               MLXSW_REG_SPVMLR_REC_LEN * \
1744                               MLXSW_REG_SPVMLR_REC_MAX_COUNT)
1745
1746 MLXSW_REG_DEFINE(spvmlr, MLXSW_REG_SPVMLR_ID, MLXSW_REG_SPVMLR_LEN);
1747
1748 /* reg_spvmlr_local_port
1749  * Local ingress port.
1750  * Access: Index
1751  *
1752  * Note: CPU port is not supported.
1753  */
1754 MLXSW_ITEM32(reg, spvmlr, local_port, 0x00, 16, 8);
1755
1756 /* reg_spvmlr_num_rec
1757  * Number of records to update.
1758  * Access: OP
1759  */
1760 MLXSW_ITEM32(reg, spvmlr, num_rec, 0x00, 0, 8);
1761
1762 /* reg_spvmlr_rec_learn_enable
1763  * 0 - Disable learning for {Port, VID}.
1764  * 1 - Enable learning for {Port, VID}.
1765  * Access: RW
1766  */
1767 MLXSW_ITEM32_INDEXED(reg, spvmlr, rec_learn_enable, MLXSW_REG_SPVMLR_BASE_LEN,
1768                      31, 1, MLXSW_REG_SPVMLR_REC_LEN, 0x00, false);
1769
1770 /* reg_spvmlr_rec_vid
1771  * VLAN ID to be added/removed from port or for querying.
1772  * Access: Index
1773  */
1774 MLXSW_ITEM32_INDEXED(reg, spvmlr, rec_vid, MLXSW_REG_SPVMLR_BASE_LEN, 0, 12,
1775                      MLXSW_REG_SPVMLR_REC_LEN, 0x00, false);
1776
1777 static inline void mlxsw_reg_spvmlr_pack(char *payload, u8 local_port,
1778                                          u16 vid_begin, u16 vid_end,
1779                                          bool learn_enable)
1780 {
1781         int num_rec = vid_end - vid_begin + 1;
1782         int i;
1783
1784         WARN_ON(num_rec < 1 || num_rec > MLXSW_REG_SPVMLR_REC_MAX_COUNT);
1785
1786         MLXSW_REG_ZERO(spvmlr, payload);
1787         mlxsw_reg_spvmlr_local_port_set(payload, local_port);
1788         mlxsw_reg_spvmlr_num_rec_set(payload, num_rec);
1789
1790         for (i = 0; i < num_rec; i++) {
1791                 mlxsw_reg_spvmlr_rec_learn_enable_set(payload, i, learn_enable);
1792                 mlxsw_reg_spvmlr_rec_vid_set(payload, i, vid_begin + i);
1793         }
1794 }
1795
1796 /* CWTP - Congetion WRED ECN TClass Profile
1797  * ----------------------------------------
1798  * Configures the profiles for queues of egress port and traffic class
1799  */
1800 #define MLXSW_REG_CWTP_ID 0x2802
1801 #define MLXSW_REG_CWTP_BASE_LEN 0x28
1802 #define MLXSW_REG_CWTP_PROFILE_DATA_REC_LEN 0x08
1803 #define MLXSW_REG_CWTP_LEN 0x40
1804
1805 MLXSW_REG_DEFINE(cwtp, MLXSW_REG_CWTP_ID, MLXSW_REG_CWTP_LEN);
1806
1807 /* reg_cwtp_local_port
1808  * Local port number
1809  * Not supported for CPU port
1810  * Access: Index
1811  */
1812 MLXSW_ITEM32(reg, cwtp, local_port, 0, 16, 8);
1813
1814 /* reg_cwtp_traffic_class
1815  * Traffic Class to configure
1816  * Access: Index
1817  */
1818 MLXSW_ITEM32(reg, cwtp, traffic_class, 32, 0, 8);
1819
1820 /* reg_cwtp_profile_min
1821  * Minimum Average Queue Size of the profile in cells.
1822  * Access: RW
1823  */
1824 MLXSW_ITEM32_INDEXED(reg, cwtp, profile_min, MLXSW_REG_CWTP_BASE_LEN,
1825                      0, 20, MLXSW_REG_CWTP_PROFILE_DATA_REC_LEN, 0, false);
1826
1827 /* reg_cwtp_profile_percent
1828  * Percentage of WRED and ECN marking for maximum Average Queue size
1829  * Range is 0 to 100, units of integer percentage
1830  * Access: RW
1831  */
1832 MLXSW_ITEM32_INDEXED(reg, cwtp, profile_percent, MLXSW_REG_CWTP_BASE_LEN,
1833                      24, 7, MLXSW_REG_CWTP_PROFILE_DATA_REC_LEN, 4, false);
1834
1835 /* reg_cwtp_profile_max
1836  * Maximum Average Queue size of the profile in cells
1837  * Access: RW
1838  */
1839 MLXSW_ITEM32_INDEXED(reg, cwtp, profile_max, MLXSW_REG_CWTP_BASE_LEN,
1840                      0, 20, MLXSW_REG_CWTP_PROFILE_DATA_REC_LEN, 4, false);
1841
1842 #define MLXSW_REG_CWTP_MIN_VALUE 64
1843 #define MLXSW_REG_CWTP_MAX_PROFILE 2
1844 #define MLXSW_REG_CWTP_DEFAULT_PROFILE 1
1845
1846 static inline void mlxsw_reg_cwtp_pack(char *payload, u8 local_port,
1847                                        u8 traffic_class)
1848 {
1849         int i;
1850
1851         MLXSW_REG_ZERO(cwtp, payload);
1852         mlxsw_reg_cwtp_local_port_set(payload, local_port);
1853         mlxsw_reg_cwtp_traffic_class_set(payload, traffic_class);
1854
1855         for (i = 0; i <= MLXSW_REG_CWTP_MAX_PROFILE; i++) {
1856                 mlxsw_reg_cwtp_profile_min_set(payload, i,
1857                                                MLXSW_REG_CWTP_MIN_VALUE);
1858                 mlxsw_reg_cwtp_profile_max_set(payload, i,
1859                                                MLXSW_REG_CWTP_MIN_VALUE);
1860         }
1861 }
1862
1863 #define MLXSW_REG_CWTP_PROFILE_TO_INDEX(profile) (profile - 1)
1864
1865 static inline void
1866 mlxsw_reg_cwtp_profile_pack(char *payload, u8 profile, u32 min, u32 max,
1867                             u32 probability)
1868 {
1869         u8 index = MLXSW_REG_CWTP_PROFILE_TO_INDEX(profile);
1870
1871         mlxsw_reg_cwtp_profile_min_set(payload, index, min);
1872         mlxsw_reg_cwtp_profile_max_set(payload, index, max);
1873         mlxsw_reg_cwtp_profile_percent_set(payload, index, probability);
1874 }
1875
1876 /* CWTPM - Congestion WRED ECN TClass and Pool Mapping
1877  * ---------------------------------------------------
1878  * The CWTPM register maps each egress port and traffic class to profile num.
1879  */
1880 #define MLXSW_REG_CWTPM_ID 0x2803
1881 #define MLXSW_REG_CWTPM_LEN 0x44
1882
1883 MLXSW_REG_DEFINE(cwtpm, MLXSW_REG_CWTPM_ID, MLXSW_REG_CWTPM_LEN);
1884
1885 /* reg_cwtpm_local_port
1886  * Local port number
1887  * Not supported for CPU port
1888  * Access: Index
1889  */
1890 MLXSW_ITEM32(reg, cwtpm, local_port, 0, 16, 8);
1891
1892 /* reg_cwtpm_traffic_class
1893  * Traffic Class to configure
1894  * Access: Index
1895  */
1896 MLXSW_ITEM32(reg, cwtpm, traffic_class, 32, 0, 8);
1897
1898 /* reg_cwtpm_ew
1899  * Control enablement of WRED for traffic class:
1900  * 0 - Disable
1901  * 1 - Enable
1902  * Access: RW
1903  */
1904 MLXSW_ITEM32(reg, cwtpm, ew, 36, 1, 1);
1905
1906 /* reg_cwtpm_ee
1907  * Control enablement of ECN for traffic class:
1908  * 0 - Disable
1909  * 1 - Enable
1910  * Access: RW
1911  */
1912 MLXSW_ITEM32(reg, cwtpm, ee, 36, 0, 1);
1913
1914 /* reg_cwtpm_tcp_g
1915  * TCP Green Profile.
1916  * Index of the profile within {port, traffic class} to use.
1917  * 0 for disabling both WRED and ECN for this type of traffic.
1918  * Access: RW
1919  */
1920 MLXSW_ITEM32(reg, cwtpm, tcp_g, 52, 0, 2);
1921
1922 /* reg_cwtpm_tcp_y
1923  * TCP Yellow Profile.
1924  * Index of the profile within {port, traffic class} to use.
1925  * 0 for disabling both WRED and ECN for this type of traffic.
1926  * Access: RW
1927  */
1928 MLXSW_ITEM32(reg, cwtpm, tcp_y, 56, 16, 2);
1929
1930 /* reg_cwtpm_tcp_r
1931  * TCP Red Profile.
1932  * Index of the profile within {port, traffic class} to use.
1933  * 0 for disabling both WRED and ECN for this type of traffic.
1934  * Access: RW
1935  */
1936 MLXSW_ITEM32(reg, cwtpm, tcp_r, 56, 0, 2);
1937
1938 /* reg_cwtpm_ntcp_g
1939  * Non-TCP Green Profile.
1940  * Index of the profile within {port, traffic class} to use.
1941  * 0 for disabling both WRED and ECN for this type of traffic.
1942  * Access: RW
1943  */
1944 MLXSW_ITEM32(reg, cwtpm, ntcp_g, 60, 0, 2);
1945
1946 /* reg_cwtpm_ntcp_y
1947  * Non-TCP Yellow Profile.
1948  * Index of the profile within {port, traffic class} to use.
1949  * 0 for disabling both WRED and ECN for this type of traffic.
1950  * Access: RW
1951  */
1952 MLXSW_ITEM32(reg, cwtpm, ntcp_y, 64, 16, 2);
1953
1954 /* reg_cwtpm_ntcp_r
1955  * Non-TCP Red Profile.
1956  * Index of the profile within {port, traffic class} to use.
1957  * 0 for disabling both WRED and ECN for this type of traffic.
1958  * Access: RW
1959  */
1960 MLXSW_ITEM32(reg, cwtpm, ntcp_r, 64, 0, 2);
1961
1962 #define MLXSW_REG_CWTPM_RESET_PROFILE 0
1963
1964 static inline void mlxsw_reg_cwtpm_pack(char *payload, u8 local_port,
1965                                         u8 traffic_class, u8 profile,
1966                                         bool wred, bool ecn)
1967 {
1968         MLXSW_REG_ZERO(cwtpm, payload);
1969         mlxsw_reg_cwtpm_local_port_set(payload, local_port);
1970         mlxsw_reg_cwtpm_traffic_class_set(payload, traffic_class);
1971         mlxsw_reg_cwtpm_ew_set(payload, wred);
1972         mlxsw_reg_cwtpm_ee_set(payload, ecn);
1973         mlxsw_reg_cwtpm_tcp_g_set(payload, profile);
1974         mlxsw_reg_cwtpm_tcp_y_set(payload, profile);
1975         mlxsw_reg_cwtpm_tcp_r_set(payload, profile);
1976         mlxsw_reg_cwtpm_ntcp_g_set(payload, profile);
1977         mlxsw_reg_cwtpm_ntcp_y_set(payload, profile);
1978         mlxsw_reg_cwtpm_ntcp_r_set(payload, profile);
1979 }
1980
1981 /* PGCR - Policy-Engine General Configuration Register
1982  * ---------------------------------------------------
1983  * This register configures general Policy-Engine settings.
1984  */
1985 #define MLXSW_REG_PGCR_ID 0x3001
1986 #define MLXSW_REG_PGCR_LEN 0x20
1987
1988 MLXSW_REG_DEFINE(pgcr, MLXSW_REG_PGCR_ID, MLXSW_REG_PGCR_LEN);
1989
1990 /* reg_pgcr_default_action_pointer_base
1991  * Default action pointer base. Each region has a default action pointer
1992  * which is equal to default_action_pointer_base + region_id.
1993  * Access: RW
1994  */
1995 MLXSW_ITEM32(reg, pgcr, default_action_pointer_base, 0x1C, 0, 24);
1996
1997 static inline void mlxsw_reg_pgcr_pack(char *payload, u32 pointer_base)
1998 {
1999         MLXSW_REG_ZERO(pgcr, payload);
2000         mlxsw_reg_pgcr_default_action_pointer_base_set(payload, pointer_base);
2001 }
2002
2003 /* PPBT - Policy-Engine Port Binding Table
2004  * ---------------------------------------
2005  * This register is used for configuration of the Port Binding Table.
2006  */
2007 #define MLXSW_REG_PPBT_ID 0x3002
2008 #define MLXSW_REG_PPBT_LEN 0x14
2009
2010 MLXSW_REG_DEFINE(ppbt, MLXSW_REG_PPBT_ID, MLXSW_REG_PPBT_LEN);
2011
2012 enum mlxsw_reg_pxbt_e {
2013         MLXSW_REG_PXBT_E_IACL,
2014         MLXSW_REG_PXBT_E_EACL,
2015 };
2016
2017 /* reg_ppbt_e
2018  * Access: Index
2019  */
2020 MLXSW_ITEM32(reg, ppbt, e, 0x00, 31, 1);
2021
2022 enum mlxsw_reg_pxbt_op {
2023         MLXSW_REG_PXBT_OP_BIND,
2024         MLXSW_REG_PXBT_OP_UNBIND,
2025 };
2026
2027 /* reg_ppbt_op
2028  * Access: RW
2029  */
2030 MLXSW_ITEM32(reg, ppbt, op, 0x00, 28, 3);
2031
2032 /* reg_ppbt_local_port
2033  * Local port. Not including CPU port.
2034  * Access: Index
2035  */
2036 MLXSW_ITEM32(reg, ppbt, local_port, 0x00, 16, 8);
2037
2038 /* reg_ppbt_g
2039  * group - When set, the binding is of an ACL group. When cleared,
2040  * the binding is of an ACL.
2041  * Must be set to 1 for Spectrum.
2042  * Access: RW
2043  */
2044 MLXSW_ITEM32(reg, ppbt, g, 0x10, 31, 1);
2045
2046 /* reg_ppbt_acl_info
2047  * ACL/ACL group identifier. If the g bit is set, this field should hold
2048  * the acl_group_id, else it should hold the acl_id.
2049  * Access: RW
2050  */
2051 MLXSW_ITEM32(reg, ppbt, acl_info, 0x10, 0, 16);
2052
2053 static inline void mlxsw_reg_ppbt_pack(char *payload, enum mlxsw_reg_pxbt_e e,
2054                                        enum mlxsw_reg_pxbt_op op,
2055                                        u8 local_port, u16 acl_info)
2056 {
2057         MLXSW_REG_ZERO(ppbt, payload);
2058         mlxsw_reg_ppbt_e_set(payload, e);
2059         mlxsw_reg_ppbt_op_set(payload, op);
2060         mlxsw_reg_ppbt_local_port_set(payload, local_port);
2061         mlxsw_reg_ppbt_g_set(payload, true);
2062         mlxsw_reg_ppbt_acl_info_set(payload, acl_info);
2063 }
2064
2065 /* PACL - Policy-Engine ACL Register
2066  * ---------------------------------
2067  * This register is used for configuration of the ACL.
2068  */
2069 #define MLXSW_REG_PACL_ID 0x3004
2070 #define MLXSW_REG_PACL_LEN 0x70
2071
2072 MLXSW_REG_DEFINE(pacl, MLXSW_REG_PACL_ID, MLXSW_REG_PACL_LEN);
2073
2074 /* reg_pacl_v
2075  * Valid. Setting the v bit makes the ACL valid. It should not be cleared
2076  * while the ACL is bounded to either a port, VLAN or ACL rule.
2077  * Access: RW
2078  */
2079 MLXSW_ITEM32(reg, pacl, v, 0x00, 24, 1);
2080
2081 /* reg_pacl_acl_id
2082  * An identifier representing the ACL (managed by software)
2083  * Range 0 .. cap_max_acl_regions - 1
2084  * Access: Index
2085  */
2086 MLXSW_ITEM32(reg, pacl, acl_id, 0x08, 0, 16);
2087
2088 #define MLXSW_REG_PXXX_TCAM_REGION_INFO_LEN 16
2089
2090 /* reg_pacl_tcam_region_info
2091  * Opaque object that represents a TCAM region.
2092  * Obtained through PTAR register.
2093  * Access: RW
2094  */
2095 MLXSW_ITEM_BUF(reg, pacl, tcam_region_info, 0x30,
2096                MLXSW_REG_PXXX_TCAM_REGION_INFO_LEN);
2097
2098 static inline void mlxsw_reg_pacl_pack(char *payload, u16 acl_id,
2099                                        bool valid, const char *tcam_region_info)
2100 {
2101         MLXSW_REG_ZERO(pacl, payload);
2102         mlxsw_reg_pacl_acl_id_set(payload, acl_id);
2103         mlxsw_reg_pacl_v_set(payload, valid);
2104         mlxsw_reg_pacl_tcam_region_info_memcpy_to(payload, tcam_region_info);
2105 }
2106
2107 /* PAGT - Policy-Engine ACL Group Table
2108  * ------------------------------------
2109  * This register is used for configuration of the ACL Group Table.
2110  */
2111 #define MLXSW_REG_PAGT_ID 0x3005
2112 #define MLXSW_REG_PAGT_BASE_LEN 0x30
2113 #define MLXSW_REG_PAGT_ACL_LEN 4
2114 #define MLXSW_REG_PAGT_ACL_MAX_NUM 16
2115 #define MLXSW_REG_PAGT_LEN (MLXSW_REG_PAGT_BASE_LEN + \
2116                 MLXSW_REG_PAGT_ACL_MAX_NUM * MLXSW_REG_PAGT_ACL_LEN)
2117
2118 MLXSW_REG_DEFINE(pagt, MLXSW_REG_PAGT_ID, MLXSW_REG_PAGT_LEN);
2119
2120 /* reg_pagt_size
2121  * Number of ACLs in the group.
2122  * Size 0 invalidates a group.
2123  * Range 0 .. cap_max_acl_group_size (hard coded to 16 for now)
2124  * Total number of ACLs in all groups must be lower or equal
2125  * to cap_max_acl_tot_groups
2126  * Note: a group which is binded must not be invalidated
2127  * Access: Index
2128  */
2129 MLXSW_ITEM32(reg, pagt, size, 0x00, 0, 8);
2130
2131 /* reg_pagt_acl_group_id
2132  * An identifier (numbered from 0..cap_max_acl_groups-1) representing
2133  * the ACL Group identifier (managed by software).
2134  * Access: Index
2135  */
2136 MLXSW_ITEM32(reg, pagt, acl_group_id, 0x08, 0, 16);
2137
2138 /* reg_pagt_acl_id
2139  * ACL identifier
2140  * Access: RW
2141  */
2142 MLXSW_ITEM32_INDEXED(reg, pagt, acl_id, 0x30, 0, 16, 0x04, 0x00, false);
2143
2144 static inline void mlxsw_reg_pagt_pack(char *payload, u16 acl_group_id)
2145 {
2146         MLXSW_REG_ZERO(pagt, payload);
2147         mlxsw_reg_pagt_acl_group_id_set(payload, acl_group_id);
2148 }
2149
2150 static inline void mlxsw_reg_pagt_acl_id_pack(char *payload, int index,
2151                                               u16 acl_id)
2152 {
2153         u8 size = mlxsw_reg_pagt_size_get(payload);
2154
2155         if (index >= size)
2156                 mlxsw_reg_pagt_size_set(payload, index + 1);
2157         mlxsw_reg_pagt_acl_id_set(payload, index, acl_id);
2158 }
2159
2160 /* PTAR - Policy-Engine TCAM Allocation Register
2161  * ---------------------------------------------
2162  * This register is used for allocation of regions in the TCAM.
2163  * Note: Query method is not supported on this register.
2164  */
2165 #define MLXSW_REG_PTAR_ID 0x3006
2166 #define MLXSW_REG_PTAR_BASE_LEN 0x20
2167 #define MLXSW_REG_PTAR_KEY_ID_LEN 1
2168 #define MLXSW_REG_PTAR_KEY_ID_MAX_NUM 16
2169 #define MLXSW_REG_PTAR_LEN (MLXSW_REG_PTAR_BASE_LEN + \
2170                 MLXSW_REG_PTAR_KEY_ID_MAX_NUM * MLXSW_REG_PTAR_KEY_ID_LEN)
2171
2172 MLXSW_REG_DEFINE(ptar, MLXSW_REG_PTAR_ID, MLXSW_REG_PTAR_LEN);
2173
2174 enum mlxsw_reg_ptar_op {
2175         /* allocate a TCAM region */
2176         MLXSW_REG_PTAR_OP_ALLOC,
2177         /* resize a TCAM region */
2178         MLXSW_REG_PTAR_OP_RESIZE,
2179         /* deallocate TCAM region */
2180         MLXSW_REG_PTAR_OP_FREE,
2181         /* test allocation */
2182         MLXSW_REG_PTAR_OP_TEST,
2183 };
2184
2185 /* reg_ptar_op
2186  * Access: OP
2187  */
2188 MLXSW_ITEM32(reg, ptar, op, 0x00, 28, 4);
2189
2190 /* reg_ptar_action_set_type
2191  * Type of action set to be used on this region.
2192  * For Spectrum and Spectrum-2, this is always type 2 - "flexible"
2193  * Access: WO
2194  */
2195 MLXSW_ITEM32(reg, ptar, action_set_type, 0x00, 16, 8);
2196
2197 enum mlxsw_reg_ptar_key_type {
2198         MLXSW_REG_PTAR_KEY_TYPE_FLEX = 0x50, /* Spetrum */
2199         MLXSW_REG_PTAR_KEY_TYPE_FLEX2 = 0x51, /* Spectrum-2 */
2200 };
2201
2202 /* reg_ptar_key_type
2203  * TCAM key type for the region.
2204  * Access: WO
2205  */
2206 MLXSW_ITEM32(reg, ptar, key_type, 0x00, 0, 8);
2207
2208 /* reg_ptar_region_size
2209  * TCAM region size. When allocating/resizing this is the requested size,
2210  * the response is the actual size. Note that actual size may be
2211  * larger than requested.
2212  * Allowed range 1 .. cap_max_rules-1
2213  * Reserved during op deallocate.
2214  * Access: WO
2215  */
2216 MLXSW_ITEM32(reg, ptar, region_size, 0x04, 0, 16);
2217
2218 /* reg_ptar_region_id
2219  * Region identifier
2220  * Range 0 .. cap_max_regions-1
2221  * Access: Index
2222  */
2223 MLXSW_ITEM32(reg, ptar, region_id, 0x08, 0, 16);
2224
2225 /* reg_ptar_tcam_region_info
2226  * Opaque object that represents the TCAM region.
2227  * Returned when allocating a region.
2228  * Provided by software for ACL generation and region deallocation and resize.
2229  * Access: RW
2230  */
2231 MLXSW_ITEM_BUF(reg, ptar, tcam_region_info, 0x10,
2232                MLXSW_REG_PXXX_TCAM_REGION_INFO_LEN);
2233
2234 /* reg_ptar_flexible_key_id
2235  * Identifier of the Flexible Key.
2236  * Only valid if key_type == "FLEX_KEY"
2237  * The key size will be rounded up to one of the following values:
2238  * 9B, 18B, 36B, 54B.
2239  * This field is reserved for in resize operation.
2240  * Access: WO
2241  */
2242 MLXSW_ITEM8_INDEXED(reg, ptar, flexible_key_id, 0x20, 0, 8,
2243                     MLXSW_REG_PTAR_KEY_ID_LEN, 0x00, false);
2244
2245 static inline void mlxsw_reg_ptar_pack(char *payload, enum mlxsw_reg_ptar_op op,
2246                                        enum mlxsw_reg_ptar_key_type key_type,
2247                                        u16 region_size, u16 region_id,
2248                                        const char *tcam_region_info)
2249 {
2250         MLXSW_REG_ZERO(ptar, payload);
2251         mlxsw_reg_ptar_op_set(payload, op);
2252         mlxsw_reg_ptar_action_set_type_set(payload, 2); /* "flexible" */
2253         mlxsw_reg_ptar_key_type_set(payload, key_type);
2254         mlxsw_reg_ptar_region_size_set(payload, region_size);
2255         mlxsw_reg_ptar_region_id_set(payload, region_id);
2256         mlxsw_reg_ptar_tcam_region_info_memcpy_to(payload, tcam_region_info);
2257 }
2258
2259 static inline void mlxsw_reg_ptar_key_id_pack(char *payload, int index,
2260                                               u16 key_id)
2261 {
2262         mlxsw_reg_ptar_flexible_key_id_set(payload, index, key_id);
2263 }
2264
2265 static inline void mlxsw_reg_ptar_unpack(char *payload, char *tcam_region_info)
2266 {
2267         mlxsw_reg_ptar_tcam_region_info_memcpy_from(payload, tcam_region_info);
2268 }
2269
2270 /* PPBS - Policy-Engine Policy Based Switching Register
2271  * ----------------------------------------------------
2272  * This register retrieves and sets Policy Based Switching Table entries.
2273  */
2274 #define MLXSW_REG_PPBS_ID 0x300C
2275 #define MLXSW_REG_PPBS_LEN 0x14
2276
2277 MLXSW_REG_DEFINE(ppbs, MLXSW_REG_PPBS_ID, MLXSW_REG_PPBS_LEN);
2278
2279 /* reg_ppbs_pbs_ptr
2280  * Index into the PBS table.
2281  * For Spectrum, the index points to the KVD Linear.
2282  * Access: Index
2283  */
2284 MLXSW_ITEM32(reg, ppbs, pbs_ptr, 0x08, 0, 24);
2285
2286 /* reg_ppbs_system_port
2287  * Unique port identifier for the final destination of the packet.
2288  * Access: RW
2289  */
2290 MLXSW_ITEM32(reg, ppbs, system_port, 0x10, 0, 16);
2291
2292 static inline void mlxsw_reg_ppbs_pack(char *payload, u32 pbs_ptr,
2293                                        u16 system_port)
2294 {
2295         MLXSW_REG_ZERO(ppbs, payload);
2296         mlxsw_reg_ppbs_pbs_ptr_set(payload, pbs_ptr);
2297         mlxsw_reg_ppbs_system_port_set(payload, system_port);
2298 }
2299
2300 /* PRCR - Policy-Engine Rules Copy Register
2301  * ----------------------------------------
2302  * This register is used for accessing rules within a TCAM region.
2303  */
2304 #define MLXSW_REG_PRCR_ID 0x300D
2305 #define MLXSW_REG_PRCR_LEN 0x40
2306
2307 MLXSW_REG_DEFINE(prcr, MLXSW_REG_PRCR_ID, MLXSW_REG_PRCR_LEN);
2308
2309 enum mlxsw_reg_prcr_op {
2310         /* Move rules. Moves the rules from "tcam_region_info" starting
2311          * at offset "offset" to "dest_tcam_region_info"
2312          * at offset "dest_offset."
2313          */
2314         MLXSW_REG_PRCR_OP_MOVE,
2315         /* Copy rules. Copies the rules from "tcam_region_info" starting
2316          * at offset "offset" to "dest_tcam_region_info"
2317          * at offset "dest_offset."
2318          */
2319         MLXSW_REG_PRCR_OP_COPY,
2320 };
2321
2322 /* reg_prcr_op
2323  * Access: OP
2324  */
2325 MLXSW_ITEM32(reg, prcr, op, 0x00, 28, 4);
2326
2327 /* reg_prcr_offset
2328  * Offset within the source region to copy/move from.
2329  * Access: Index
2330  */
2331 MLXSW_ITEM32(reg, prcr, offset, 0x00, 0, 16);
2332
2333 /* reg_prcr_size
2334  * The number of rules to copy/move.
2335  * Access: WO
2336  */
2337 MLXSW_ITEM32(reg, prcr, size, 0x04, 0, 16);
2338
2339 /* reg_prcr_tcam_region_info
2340  * Opaque object that represents the source TCAM region.
2341  * Access: Index
2342  */
2343 MLXSW_ITEM_BUF(reg, prcr, tcam_region_info, 0x10,
2344                MLXSW_REG_PXXX_TCAM_REGION_INFO_LEN);
2345
2346 /* reg_prcr_dest_offset
2347  * Offset within the source region to copy/move to.
2348  * Access: Index
2349  */
2350 MLXSW_ITEM32(reg, prcr, dest_offset, 0x20, 0, 16);
2351
2352 /* reg_prcr_dest_tcam_region_info
2353  * Opaque object that represents the destination TCAM region.
2354  * Access: Index
2355  */
2356 MLXSW_ITEM_BUF(reg, prcr, dest_tcam_region_info, 0x30,
2357                MLXSW_REG_PXXX_TCAM_REGION_INFO_LEN);
2358
2359 static inline void mlxsw_reg_prcr_pack(char *payload, enum mlxsw_reg_prcr_op op,
2360                                        const char *src_tcam_region_info,
2361                                        u16 src_offset,
2362                                        const char *dest_tcam_region_info,
2363                                        u16 dest_offset, u16 size)
2364 {
2365         MLXSW_REG_ZERO(prcr, payload);
2366         mlxsw_reg_prcr_op_set(payload, op);
2367         mlxsw_reg_prcr_offset_set(payload, src_offset);
2368         mlxsw_reg_prcr_size_set(payload, size);
2369         mlxsw_reg_prcr_tcam_region_info_memcpy_to(payload,
2370                                                   src_tcam_region_info);
2371         mlxsw_reg_prcr_dest_offset_set(payload, dest_offset);
2372         mlxsw_reg_prcr_dest_tcam_region_info_memcpy_to(payload,
2373                                                        dest_tcam_region_info);
2374 }
2375
2376 /* PEFA - Policy-Engine Extended Flexible Action Register
2377  * ------------------------------------------------------
2378  * This register is used for accessing an extended flexible action entry
2379  * in the central KVD Linear Database.
2380  */
2381 #define MLXSW_REG_PEFA_ID 0x300F
2382 #define MLXSW_REG_PEFA_LEN 0xB0
2383
2384 MLXSW_REG_DEFINE(pefa, MLXSW_REG_PEFA_ID, MLXSW_REG_PEFA_LEN);
2385
2386 /* reg_pefa_index
2387  * Index in the KVD Linear Centralized Database.
2388  * Access: Index
2389  */
2390 MLXSW_ITEM32(reg, pefa, index, 0x00, 0, 24);
2391
2392 /* reg_pefa_a
2393  * Index in the KVD Linear Centralized Database.
2394  * Activity
2395  * For a new entry: set if ca=0, clear if ca=1
2396  * Set if a packet lookup has hit on the specific entry
2397  * Access: RO
2398  */
2399 MLXSW_ITEM32(reg, pefa, a, 0x04, 29, 1);
2400
2401 /* reg_pefa_ca
2402  * Clear activity
2403  * When write: activity is according to this field
2404  * When read: after reading the activity is cleared according to ca
2405  * Access: OP
2406  */
2407 MLXSW_ITEM32(reg, pefa, ca, 0x04, 24, 1);
2408
2409 #define MLXSW_REG_FLEX_ACTION_SET_LEN 0xA8
2410
2411 /* reg_pefa_flex_action_set
2412  * Action-set to perform when rule is matched.
2413  * Must be zero padded if action set is shorter.
2414  * Access: RW
2415  */
2416 MLXSW_ITEM_BUF(reg, pefa, flex_action_set, 0x08, MLXSW_REG_FLEX_ACTION_SET_LEN);
2417
2418 static inline void mlxsw_reg_pefa_pack(char *payload, u32 index, bool ca,
2419                                        const char *flex_action_set)
2420 {
2421         MLXSW_REG_ZERO(pefa, payload);
2422         mlxsw_reg_pefa_index_set(payload, index);
2423         mlxsw_reg_pefa_ca_set(payload, ca);
2424         if (flex_action_set)
2425                 mlxsw_reg_pefa_flex_action_set_memcpy_to(payload,
2426                                                          flex_action_set);
2427 }
2428
2429 static inline void mlxsw_reg_pefa_unpack(char *payload, bool *p_a)
2430 {
2431         *p_a = mlxsw_reg_pefa_a_get(payload);
2432 }
2433
2434 /* PTCE-V2 - Policy-Engine TCAM Entry Register Version 2
2435  * -----------------------------------------------------
2436  * This register is used for accessing rules within a TCAM region.
2437  * It is a new version of PTCE in order to support wider key,
2438  * mask and action within a TCAM region. This register is not supported
2439  * by SwitchX and SwitchX-2.
2440  */
2441 #define MLXSW_REG_PTCE2_ID 0x3017
2442 #define MLXSW_REG_PTCE2_LEN 0x1D8
2443
2444 MLXSW_REG_DEFINE(ptce2, MLXSW_REG_PTCE2_ID, MLXSW_REG_PTCE2_LEN);
2445
2446 /* reg_ptce2_v
2447  * Valid.
2448  * Access: RW
2449  */
2450 MLXSW_ITEM32(reg, ptce2, v, 0x00, 31, 1);
2451
2452 /* reg_ptce2_a
2453  * Activity. Set if a packet lookup has hit on the specific entry.
2454  * To clear the "a" bit, use "clear activity" op or "clear on read" op.
2455  * Access: RO
2456  */
2457 MLXSW_ITEM32(reg, ptce2, a, 0x00, 30, 1);
2458
2459 enum mlxsw_reg_ptce2_op {
2460         /* Read operation. */
2461         MLXSW_REG_PTCE2_OP_QUERY_READ = 0,
2462         /* clear on read operation. Used to read entry
2463          * and clear Activity bit.
2464          */
2465         MLXSW_REG_PTCE2_OP_QUERY_CLEAR_ON_READ = 1,
2466         /* Write operation. Used to write a new entry to the table.
2467          * All R/W fields are relevant for new entry. Activity bit is set
2468          * for new entries - Note write with v = 0 will delete the entry.
2469          */
2470         MLXSW_REG_PTCE2_OP_WRITE_WRITE = 0,
2471         /* Update action. Only action set will be updated. */
2472         MLXSW_REG_PTCE2_OP_WRITE_UPDATE = 1,
2473         /* Clear activity. A bit is cleared for the entry. */
2474         MLXSW_REG_PTCE2_OP_WRITE_CLEAR_ACTIVITY = 2,
2475 };
2476
2477 /* reg_ptce2_op
2478  * Access: OP
2479  */
2480 MLXSW_ITEM32(reg, ptce2, op, 0x00, 20, 3);
2481
2482 /* reg_ptce2_offset
2483  * Access: Index
2484  */
2485 MLXSW_ITEM32(reg, ptce2, offset, 0x00, 0, 16);
2486
2487 /* reg_ptce2_priority
2488  * Priority of the rule, higher values win. The range is 1..cap_kvd_size-1.
2489  * Note: priority does not have to be unique per rule.
2490  * Within a region, higher priority should have lower offset (no limitation
2491  * between regions in a multi-region).
2492  * Access: RW
2493  */
2494 MLXSW_ITEM32(reg, ptce2, priority, 0x04, 0, 24);
2495
2496 /* reg_ptce2_tcam_region_info
2497  * Opaque object that represents the TCAM region.
2498  * Access: Index
2499  */
2500 MLXSW_ITEM_BUF(reg, ptce2, tcam_region_info, 0x10,
2501                MLXSW_REG_PXXX_TCAM_REGION_INFO_LEN);
2502
2503 #define MLXSW_REG_PTCEX_FLEX_KEY_BLOCKS_LEN 96
2504
2505 /* reg_ptce2_flex_key_blocks
2506  * ACL Key.
2507  * Access: RW
2508  */
2509 MLXSW_ITEM_BUF(reg, ptce2, flex_key_blocks, 0x20,
2510                MLXSW_REG_PTCEX_FLEX_KEY_BLOCKS_LEN);
2511
2512 /* reg_ptce2_mask
2513  * mask- in the same size as key. A bit that is set directs the TCAM
2514  * to compare the corresponding bit in key. A bit that is clear directs
2515  * the TCAM to ignore the corresponding bit in key.
2516  * Access: RW
2517  */
2518 MLXSW_ITEM_BUF(reg, ptce2, mask, 0x80,
2519                MLXSW_REG_PTCEX_FLEX_KEY_BLOCKS_LEN);
2520
2521 /* reg_ptce2_flex_action_set
2522  * ACL action set.
2523  * Access: RW
2524  */
2525 MLXSW_ITEM_BUF(reg, ptce2, flex_action_set, 0xE0,
2526                MLXSW_REG_FLEX_ACTION_SET_LEN);
2527
2528 static inline void mlxsw_reg_ptce2_pack(char *payload, bool valid,
2529                                         enum mlxsw_reg_ptce2_op op,
2530                                         const char *tcam_region_info,
2531                                         u16 offset, u32 priority)
2532 {
2533         MLXSW_REG_ZERO(ptce2, payload);
2534         mlxsw_reg_ptce2_v_set(payload, valid);
2535         mlxsw_reg_ptce2_op_set(payload, op);
2536         mlxsw_reg_ptce2_offset_set(payload, offset);
2537         mlxsw_reg_ptce2_priority_set(payload, priority);
2538         mlxsw_reg_ptce2_tcam_region_info_memcpy_to(payload, tcam_region_info);
2539 }
2540
2541 /* PERPT - Policy-Engine ERP Table Register
2542  * ----------------------------------------
2543  * This register adds and removes eRPs from the eRP table.
2544  */
2545 #define MLXSW_REG_PERPT_ID 0x3021
2546 #define MLXSW_REG_PERPT_LEN 0x80
2547
2548 MLXSW_REG_DEFINE(perpt, MLXSW_REG_PERPT_ID, MLXSW_REG_PERPT_LEN);
2549
2550 /* reg_perpt_erpt_bank
2551  * eRP table bank.
2552  * Range 0 .. cap_max_erp_table_banks - 1
2553  * Access: Index
2554  */
2555 MLXSW_ITEM32(reg, perpt, erpt_bank, 0x00, 16, 4);
2556
2557 /* reg_perpt_erpt_index
2558  * Index to eRP table within the eRP bank.
2559  * Range is 0 .. cap_max_erp_table_bank_size - 1
2560  * Access: Index
2561  */
2562 MLXSW_ITEM32(reg, perpt, erpt_index, 0x00, 0, 8);
2563
2564 enum mlxsw_reg_perpt_key_size {
2565         MLXSW_REG_PERPT_KEY_SIZE_2KB,
2566         MLXSW_REG_PERPT_KEY_SIZE_4KB,
2567         MLXSW_REG_PERPT_KEY_SIZE_8KB,
2568         MLXSW_REG_PERPT_KEY_SIZE_12KB,
2569 };
2570
2571 /* reg_perpt_key_size
2572  * Access: OP
2573  */
2574 MLXSW_ITEM32(reg, perpt, key_size, 0x04, 0, 4);
2575
2576 /* reg_perpt_bf_bypass
2577  * 0 - The eRP is used only if bloom filter state is set for the given
2578  * rule.
2579  * 1 - The eRP is used regardless of bloom filter state.
2580  * The bypass is an OR condition of region_id or eRP. See PERCR.bf_bypass
2581  * Access: RW
2582  */
2583 MLXSW_ITEM32(reg, perpt, bf_bypass, 0x08, 8, 1);
2584
2585 /* reg_perpt_erp_id
2586  * eRP ID for use by the rules.
2587  * Access: RW
2588  */
2589 MLXSW_ITEM32(reg, perpt, erp_id, 0x08, 0, 4);
2590
2591 /* reg_perpt_erpt_base_bank
2592  * Base eRP table bank, points to head of erp_vector
2593  * Range is 0 .. cap_max_erp_table_banks - 1
2594  * Access: OP
2595  */
2596 MLXSW_ITEM32(reg, perpt, erpt_base_bank, 0x0C, 16, 4);
2597
2598 /* reg_perpt_erpt_base_index
2599  * Base index to eRP table within the eRP bank
2600  * Range is 0 .. cap_max_erp_table_bank_size - 1
2601  * Access: OP
2602  */
2603 MLXSW_ITEM32(reg, perpt, erpt_base_index, 0x0C, 0, 8);
2604
2605 /* reg_perpt_erp_index_in_vector
2606  * eRP index in the vector.
2607  * Access: OP
2608  */
2609 MLXSW_ITEM32(reg, perpt, erp_index_in_vector, 0x10, 0, 4);
2610
2611 /* reg_perpt_erp_vector
2612  * eRP vector.
2613  * Access: OP
2614  */
2615 MLXSW_ITEM_BIT_ARRAY(reg, perpt, erp_vector, 0x14, 4, 1);
2616
2617 /* reg_perpt_mask
2618  * Mask
2619  * 0 - A-TCAM will ignore the bit in key
2620  * 1 - A-TCAM will compare the bit in key
2621  * Access: RW
2622  */
2623 MLXSW_ITEM_BUF(reg, perpt, mask, 0x20, MLXSW_REG_PTCEX_FLEX_KEY_BLOCKS_LEN);
2624
2625 static inline void mlxsw_reg_perpt_erp_vector_pack(char *payload,
2626                                                    unsigned long *erp_vector,
2627                                                    unsigned long size)
2628 {
2629         unsigned long bit;
2630
2631         for_each_set_bit(bit, erp_vector, size)
2632                 mlxsw_reg_perpt_erp_vector_set(payload, bit, true);
2633 }
2634
2635 static inline void
2636 mlxsw_reg_perpt_pack(char *payload, u8 erpt_bank, u8 erpt_index,
2637                      enum mlxsw_reg_perpt_key_size key_size, u8 erp_id,
2638                      u8 erpt_base_bank, u8 erpt_base_index, u8 erp_index,
2639                      char *mask)
2640 {
2641         MLXSW_REG_ZERO(perpt, payload);
2642         mlxsw_reg_perpt_erpt_bank_set(payload, erpt_bank);
2643         mlxsw_reg_perpt_erpt_index_set(payload, erpt_index);
2644         mlxsw_reg_perpt_key_size_set(payload, key_size);
2645         mlxsw_reg_perpt_bf_bypass_set(payload, true);
2646         mlxsw_reg_perpt_erp_id_set(payload, erp_id);
2647         mlxsw_reg_perpt_erpt_base_bank_set(payload, erpt_base_bank);
2648         mlxsw_reg_perpt_erpt_base_index_set(payload, erpt_base_index);
2649         mlxsw_reg_perpt_erp_index_in_vector_set(payload, erp_index);
2650         mlxsw_reg_perpt_mask_memcpy_to(payload, mask);
2651 }
2652
2653 /* PERAR - Policy-Engine Region Association Register
2654  * -------------------------------------------------
2655  * This register associates a hw region for region_id's. Changing on the fly
2656  * is supported by the device.
2657  */
2658 #define MLXSW_REG_PERAR_ID 0x3026
2659 #define MLXSW_REG_PERAR_LEN 0x08
2660
2661 MLXSW_REG_DEFINE(perar, MLXSW_REG_PERAR_ID, MLXSW_REG_PERAR_LEN);
2662
2663 /* reg_perar_region_id
2664  * Region identifier
2665  * Range 0 .. cap_max_regions-1
2666  * Access: Index
2667  */
2668 MLXSW_ITEM32(reg, perar, region_id, 0x00, 0, 16);
2669
2670 static inline unsigned int
2671 mlxsw_reg_perar_hw_regions_needed(unsigned int block_num)
2672 {
2673         return DIV_ROUND_UP(block_num, 4);
2674 }
2675
2676 /* reg_perar_hw_region
2677  * HW Region
2678  * Range 0 .. cap_max_regions-1
2679  * Default: hw_region = region_id
2680  * For a 8 key block region, 2 consecutive regions are used
2681  * For a 12 key block region, 3 consecutive regions are used
2682  * Access: RW
2683  */
2684 MLXSW_ITEM32(reg, perar, hw_region, 0x04, 0, 16);
2685
2686 static inline void mlxsw_reg_perar_pack(char *payload, u16 region_id,
2687                                         u16 hw_region)
2688 {
2689         MLXSW_REG_ZERO(perar, payload);
2690         mlxsw_reg_perar_region_id_set(payload, region_id);
2691         mlxsw_reg_perar_hw_region_set(payload, hw_region);
2692 }
2693
2694 /* PTCE-V3 - Policy-Engine TCAM Entry Register Version 3
2695  * -----------------------------------------------------
2696  * This register is a new version of PTCE-V2 in order to support the
2697  * A-TCAM. This register is not supported by SwitchX/-2 and Spectrum.
2698  */
2699 #define MLXSW_REG_PTCE3_ID 0x3027
2700 #define MLXSW_REG_PTCE3_LEN 0xF0
2701
2702 MLXSW_REG_DEFINE(ptce3, MLXSW_REG_PTCE3_ID, MLXSW_REG_PTCE3_LEN);
2703
2704 /* reg_ptce3_v
2705  * Valid.
2706  * Access: RW
2707  */
2708 MLXSW_ITEM32(reg, ptce3, v, 0x00, 31, 1);
2709
2710 enum mlxsw_reg_ptce3_op {
2711         /* Write operation. Used to write a new entry to the table.
2712          * All R/W fields are relevant for new entry. Activity bit is set
2713          * for new entries. Write with v = 0 will delete the entry. Must
2714          * not be used if an entry exists.
2715          */
2716          MLXSW_REG_PTCE3_OP_WRITE_WRITE = 0,
2717          /* Update operation */
2718          MLXSW_REG_PTCE3_OP_WRITE_UPDATE = 1,
2719          /* Read operation */
2720          MLXSW_REG_PTCE3_OP_QUERY_READ = 0,
2721 };
2722
2723 /* reg_ptce3_op
2724  * Access: OP
2725  */
2726 MLXSW_ITEM32(reg, ptce3, op, 0x00, 20, 3);
2727
2728 /* reg_ptce3_priority
2729  * Priority of the rule. Higher values win.
2730  * For Spectrum-2 range is 1..cap_kvd_size - 1
2731  * Note: Priority does not have to be unique per rule.
2732  * Access: RW
2733  */
2734 MLXSW_ITEM32(reg, ptce3, priority, 0x04, 0, 24);
2735
2736 /* reg_ptce3_tcam_region_info
2737  * Opaque object that represents the TCAM region.
2738  * Access: Index
2739  */
2740 MLXSW_ITEM_BUF(reg, ptce3, tcam_region_info, 0x10,
2741                MLXSW_REG_PXXX_TCAM_REGION_INFO_LEN);
2742
2743 /* reg_ptce3_flex2_key_blocks
2744  * ACL key. The key must be masked according to eRP (if exists) or
2745  * according to master mask.
2746  * Access: Index
2747  */
2748 MLXSW_ITEM_BUF(reg, ptce3, flex2_key_blocks, 0x20,
2749                MLXSW_REG_PTCEX_FLEX_KEY_BLOCKS_LEN);
2750
2751 /* reg_ptce3_erp_id
2752  * eRP ID.
2753  * Access: Index
2754  */
2755 MLXSW_ITEM32(reg, ptce3, erp_id, 0x80, 0, 4);
2756
2757 /* reg_ptce3_delta_start
2758  * Start point of delta_value and delta_mask, in bits. Must not exceed
2759  * num_key_blocks * 36 - 8. Reserved when delta_mask = 0.
2760  * Access: Index
2761  */
2762 MLXSW_ITEM32(reg, ptce3, delta_start, 0x84, 0, 10);
2763
2764 /* reg_ptce3_delta_mask
2765  * Delta mask.
2766  * 0 - Ignore relevant bit in delta_value
2767  * 1 - Compare relevant bit in delta_value
2768  * Delta mask must not be set for reserved fields in the key blocks.
2769  * Note: No delta when no eRPs. Thus, for regions with
2770  * PERERP.erpt_pointer_valid = 0 the delta mask must be 0.
2771  * Access: Index
2772  */
2773 MLXSW_ITEM32(reg, ptce3, delta_mask, 0x88, 16, 8);
2774
2775 /* reg_ptce3_delta_value
2776  * Delta value.
2777  * Bits which are masked by delta_mask must be 0.
2778  * Access: Index
2779  */
2780 MLXSW_ITEM32(reg, ptce3, delta_value, 0x88, 0, 8);
2781
2782 /* reg_ptce3_prune_vector
2783  * Pruning vector relative to the PERPT.erp_id.
2784  * Used for reducing lookups.
2785  * 0 - NEED: Do a lookup using the eRP.
2786  * 1 - PRUNE: Do not perform a lookup using the eRP.
2787  * Maybe be modified by PEAPBL and PEAPBM.
2788  * Note: In Spectrum-2, a region of 8 key blocks must be set to either
2789  * all 1's or all 0's.
2790  * Access: RW
2791  */
2792 MLXSW_ITEM_BIT_ARRAY(reg, ptce3, prune_vector, 0x90, 4, 1);
2793
2794 /* reg_ptce3_prune_ctcam
2795  * Pruning on C-TCAM. Used for reducing lookups.
2796  * 0 - NEED: Do a lookup in the C-TCAM.
2797  * 1 - PRUNE: Do not perform a lookup in the C-TCAM.
2798  * Access: RW
2799  */
2800 MLXSW_ITEM32(reg, ptce3, prune_ctcam, 0x94, 31, 1);
2801
2802 /* reg_ptce3_large_exists
2803  * Large entry key ID exists.
2804  * Within the region:
2805  * 0 - SINGLE: The large_entry_key_id is not currently in use.
2806  * For rule insert: The MSB of the key (blocks 6..11) will be added.
2807  * For rule delete: The MSB of the key will be removed.
2808  * 1 - NON_SINGLE: The large_entry_key_id is currently in use.
2809  * For rule insert: The MSB of the key (blocks 6..11) will not be added.
2810  * For rule delete: The MSB of the key will not be removed.
2811  * Access: WO
2812  */
2813 MLXSW_ITEM32(reg, ptce3, large_exists, 0x98, 31, 1);
2814
2815 /* reg_ptce3_large_entry_key_id
2816  * Large entry key ID.
2817  * A key for 12 key blocks rules. Reserved when region has less than 12 key
2818  * blocks. Must be different for different keys which have the same common
2819  * 6 key blocks (MSB, blocks 6..11) key within a region.
2820  * Range is 0..cap_max_pe_large_key_id - 1
2821  * Access: RW
2822  */
2823 MLXSW_ITEM32(reg, ptce3, large_entry_key_id, 0x98, 0, 24);
2824
2825 /* reg_ptce3_action_pointer
2826  * Pointer to action.
2827  * Range is 0..cap_max_kvd_action_sets - 1
2828  * Access: RW
2829  */
2830 MLXSW_ITEM32(reg, ptce3, action_pointer, 0xA0, 0, 24);
2831
2832 static inline void mlxsw_reg_ptce3_pack(char *payload, bool valid,
2833                                         enum mlxsw_reg_ptce3_op op,
2834                                         u32 priority,
2835                                         const char *tcam_region_info,
2836                                         const char *key, u8 erp_id,
2837                                         bool large_exists, u32 lkey_id,
2838                                         u32 action_pointer)
2839 {
2840         MLXSW_REG_ZERO(ptce3, payload);
2841         mlxsw_reg_ptce3_v_set(payload, valid);
2842         mlxsw_reg_ptce3_op_set(payload, op);
2843         mlxsw_reg_ptce3_priority_set(payload, priority);
2844         mlxsw_reg_ptce3_tcam_region_info_memcpy_to(payload, tcam_region_info);
2845         mlxsw_reg_ptce3_flex2_key_blocks_memcpy_to(payload, key);
2846         mlxsw_reg_ptce3_erp_id_set(payload, erp_id);
2847         mlxsw_reg_ptce3_large_exists_set(payload, large_exists);
2848         mlxsw_reg_ptce3_large_entry_key_id_set(payload, lkey_id);
2849         mlxsw_reg_ptce3_action_pointer_set(payload, action_pointer);
2850 }
2851
2852 /* PERCR - Policy-Engine Region Configuration Register
2853  * ---------------------------------------------------
2854  * This register configures the region parameters. The region_id must be
2855  * allocated.
2856  */
2857 #define MLXSW_REG_PERCR_ID 0x302A
2858 #define MLXSW_REG_PERCR_LEN 0x80
2859
2860 MLXSW_REG_DEFINE(percr, MLXSW_REG_PERCR_ID, MLXSW_REG_PERCR_LEN);
2861
2862 /* reg_percr_region_id
2863  * Region identifier.
2864  * Range 0..cap_max_regions-1
2865  * Access: Index
2866  */
2867 MLXSW_ITEM32(reg, percr, region_id, 0x00, 0, 16);
2868
2869 /* reg_percr_atcam_ignore_prune
2870  * Ignore prune_vector by other A-TCAM rules. Used e.g., for a new rule.
2871  * Access: RW
2872  */
2873 MLXSW_ITEM32(reg, percr, atcam_ignore_prune, 0x04, 25, 1);
2874
2875 /* reg_percr_ctcam_ignore_prune
2876  * Ignore prune_ctcam by other A-TCAM rules. Used e.g., for a new rule.
2877  * Access: RW
2878  */
2879 MLXSW_ITEM32(reg, percr, ctcam_ignore_prune, 0x04, 24, 1);
2880
2881 /* reg_percr_bf_bypass
2882  * Bloom filter bypass.
2883  * 0 - Bloom filter is used (default)
2884  * 1 - Bloom filter is bypassed. The bypass is an OR condition of
2885  * region_id or eRP. See PERPT.bf_bypass
2886  * Access: RW
2887  */
2888 MLXSW_ITEM32(reg, percr, bf_bypass, 0x04, 16, 1);
2889
2890 /* reg_percr_master_mask
2891  * Master mask. Logical OR mask of all masks of all rules of a region
2892  * (both A-TCAM and C-TCAM). When there are no eRPs
2893  * (erpt_pointer_valid = 0), then this provides the mask.
2894  * Access: RW
2895  */
2896 MLXSW_ITEM_BUF(reg, percr, master_mask, 0x20, 96);
2897
2898 static inline void mlxsw_reg_percr_pack(char *payload, u16 region_id)
2899 {
2900         MLXSW_REG_ZERO(percr, payload);
2901         mlxsw_reg_percr_region_id_set(payload, region_id);
2902         mlxsw_reg_percr_atcam_ignore_prune_set(payload, false);
2903         mlxsw_reg_percr_ctcam_ignore_prune_set(payload, false);
2904         mlxsw_reg_percr_bf_bypass_set(payload, true);
2905 }
2906
2907 /* PERERP - Policy-Engine Region eRP Register
2908  * ------------------------------------------
2909  * This register configures the region eRP. The region_id must be
2910  * allocated.
2911  */
2912 #define MLXSW_REG_PERERP_ID 0x302B
2913 #define MLXSW_REG_PERERP_LEN 0x1C
2914
2915 MLXSW_REG_DEFINE(pererp, MLXSW_REG_PERERP_ID, MLXSW_REG_PERERP_LEN);
2916
2917 /* reg_pererp_region_id
2918  * Region identifier.
2919  * Range 0..cap_max_regions-1
2920  * Access: Index
2921  */
2922 MLXSW_ITEM32(reg, pererp, region_id, 0x00, 0, 16);
2923
2924 /* reg_pererp_ctcam_le
2925  * C-TCAM lookup enable. Reserved when erpt_pointer_valid = 0.
2926  * Access: RW
2927  */
2928 MLXSW_ITEM32(reg, pererp, ctcam_le, 0x04, 28, 1);
2929
2930 /* reg_pererp_erpt_pointer_valid
2931  * erpt_pointer is valid.
2932  * Access: RW
2933  */
2934 MLXSW_ITEM32(reg, pererp, erpt_pointer_valid, 0x10, 31, 1);
2935
2936 /* reg_pererp_erpt_bank_pointer
2937  * Pointer to eRP table bank. May be modified at any time.
2938  * Range 0..cap_max_erp_table_banks-1
2939  * Reserved when erpt_pointer_valid = 0
2940  */
2941 MLXSW_ITEM32(reg, pererp, erpt_bank_pointer, 0x10, 16, 4);
2942
2943 /* reg_pererp_erpt_pointer
2944  * Pointer to eRP table within the eRP bank. Can be changed for an
2945  * existing region.
2946  * Range 0..cap_max_erp_table_size-1
2947  * Reserved when erpt_pointer_valid = 0
2948  * Access: RW
2949  */
2950 MLXSW_ITEM32(reg, pererp, erpt_pointer, 0x10, 0, 8);
2951
2952 /* reg_pererp_erpt_vector
2953  * Vector of allowed eRP indexes starting from erpt_pointer within the
2954  * erpt_bank_pointer. Next entries will be in next bank.
2955  * Note that eRP index is used and not eRP ID.
2956  * Reserved when erpt_pointer_valid = 0
2957  * Access: RW
2958  */
2959 MLXSW_ITEM_BIT_ARRAY(reg, pererp, erpt_vector, 0x14, 4, 1);
2960
2961 /* reg_pererp_master_rp_id
2962  * Master RP ID. When there are no eRPs, then this provides the eRP ID
2963  * for the lookup. Can be changed for an existing region.
2964  * Reserved when erpt_pointer_valid = 1
2965  * Access: RW
2966  */
2967 MLXSW_ITEM32(reg, pererp, master_rp_id, 0x18, 0, 4);
2968
2969 static inline void mlxsw_reg_pererp_erp_vector_pack(char *payload,
2970                                                     unsigned long *erp_vector,
2971                                                     unsigned long size)
2972 {
2973         unsigned long bit;
2974
2975         for_each_set_bit(bit, erp_vector, size)
2976                 mlxsw_reg_pererp_erpt_vector_set(payload, bit, true);
2977 }
2978
2979 static inline void mlxsw_reg_pererp_pack(char *payload, u16 region_id,
2980                                          bool ctcam_le, bool erpt_pointer_valid,
2981                                          u8 erpt_bank_pointer, u8 erpt_pointer,
2982                                          u8 master_rp_id)
2983 {
2984         MLXSW_REG_ZERO(pererp, payload);
2985         mlxsw_reg_pererp_region_id_set(payload, region_id);
2986         mlxsw_reg_pererp_ctcam_le_set(payload, ctcam_le);
2987         mlxsw_reg_pererp_erpt_pointer_valid_set(payload, erpt_pointer_valid);
2988         mlxsw_reg_pererp_erpt_bank_pointer_set(payload, erpt_bank_pointer);
2989         mlxsw_reg_pererp_erpt_pointer_set(payload, erpt_pointer);
2990         mlxsw_reg_pererp_master_rp_id_set(payload, master_rp_id);
2991 }
2992
2993 /* IEDR - Infrastructure Entry Delete Register
2994  * ----------------------------------------------------
2995  * This register is used for deleting entries from the entry tables.
2996  * It is legitimate to attempt to delete a nonexisting entry (the device will
2997  * respond as a good flow).
2998  */
2999 #define MLXSW_REG_IEDR_ID 0x3804
3000 #define MLXSW_REG_IEDR_BASE_LEN 0x10 /* base length, without records */
3001 #define MLXSW_REG_IEDR_REC_LEN 0x8 /* record length */
3002 #define MLXSW_REG_IEDR_REC_MAX_COUNT 64
3003 #define MLXSW_REG_IEDR_LEN (MLXSW_REG_IEDR_BASE_LEN +   \
3004                             MLXSW_REG_IEDR_REC_LEN *    \
3005                             MLXSW_REG_IEDR_REC_MAX_COUNT)
3006
3007 MLXSW_REG_DEFINE(iedr, MLXSW_REG_IEDR_ID, MLXSW_REG_IEDR_LEN);
3008
3009 /* reg_iedr_num_rec
3010  * Number of records.
3011  * Access: OP
3012  */
3013 MLXSW_ITEM32(reg, iedr, num_rec, 0x00, 0, 8);
3014
3015 /* reg_iedr_rec_type
3016  * Resource type.
3017  * Access: OP
3018  */
3019 MLXSW_ITEM32_INDEXED(reg, iedr, rec_type, MLXSW_REG_IEDR_BASE_LEN, 24, 8,
3020                      MLXSW_REG_IEDR_REC_LEN, 0x00, false);
3021
3022 /* reg_iedr_rec_size
3023  * Size of entries do be deleted. The unit is 1 entry, regardless of entry type.
3024  * Access: OP
3025  */
3026 MLXSW_ITEM32_INDEXED(reg, iedr, rec_size, MLXSW_REG_IEDR_BASE_LEN, 0, 11,
3027                      MLXSW_REG_IEDR_REC_LEN, 0x00, false);
3028
3029 /* reg_iedr_rec_index_start
3030  * Resource index start.
3031  * Access: OP
3032  */
3033 MLXSW_ITEM32_INDEXED(reg, iedr, rec_index_start, MLXSW_REG_IEDR_BASE_LEN, 0, 24,
3034                      MLXSW_REG_IEDR_REC_LEN, 0x04, false);
3035
3036 static inline void mlxsw_reg_iedr_pack(char *payload)
3037 {
3038         MLXSW_REG_ZERO(iedr, payload);
3039 }
3040
3041 static inline void mlxsw_reg_iedr_rec_pack(char *payload, int rec_index,
3042                                            u8 rec_type, u16 rec_size,
3043                                            u32 rec_index_start)
3044 {
3045         u8 num_rec = mlxsw_reg_iedr_num_rec_get(payload);
3046
3047         if (rec_index >= num_rec)
3048                 mlxsw_reg_iedr_num_rec_set(payload, rec_index + 1);
3049         mlxsw_reg_iedr_rec_type_set(payload, rec_index, rec_type);
3050         mlxsw_reg_iedr_rec_size_set(payload, rec_index, rec_size);
3051         mlxsw_reg_iedr_rec_index_start_set(payload, rec_index, rec_index_start);
3052 }
3053
3054 /* QPTS - QoS Priority Trust State Register
3055  * ----------------------------------------
3056  * This register controls the port policy to calculate the switch priority and
3057  * packet color based on incoming packet fields.
3058  */
3059 #define MLXSW_REG_QPTS_ID 0x4002
3060 #define MLXSW_REG_QPTS_LEN 0x8
3061
3062 MLXSW_REG_DEFINE(qpts, MLXSW_REG_QPTS_ID, MLXSW_REG_QPTS_LEN);
3063
3064 /* reg_qpts_local_port
3065  * Local port number.
3066  * Access: Index
3067  *
3068  * Note: CPU port is supported.
3069  */
3070 MLXSW_ITEM32(reg, qpts, local_port, 0x00, 16, 8);
3071
3072 enum mlxsw_reg_qpts_trust_state {
3073         MLXSW_REG_QPTS_TRUST_STATE_PCP = 1,
3074         MLXSW_REG_QPTS_TRUST_STATE_DSCP = 2, /* For MPLS, trust EXP. */
3075 };
3076
3077 /* reg_qpts_trust_state
3078  * Trust state for a given port.
3079  * Access: RW
3080  */
3081 MLXSW_ITEM32(reg, qpts, trust_state, 0x04, 0, 3);
3082
3083 static inline void mlxsw_reg_qpts_pack(char *payload, u8 local_port,
3084                                        enum mlxsw_reg_qpts_trust_state ts)
3085 {
3086         MLXSW_REG_ZERO(qpts, payload);
3087
3088         mlxsw_reg_qpts_local_port_set(payload, local_port);
3089         mlxsw_reg_qpts_trust_state_set(payload, ts);
3090 }
3091
3092 /* QPCR - QoS Policer Configuration Register
3093  * -----------------------------------------
3094  * The QPCR register is used to create policers - that limit
3095  * the rate of bytes or packets via some trap group.
3096  */
3097 #define MLXSW_REG_QPCR_ID 0x4004
3098 #define MLXSW_REG_QPCR_LEN 0x28
3099
3100 MLXSW_REG_DEFINE(qpcr, MLXSW_REG_QPCR_ID, MLXSW_REG_QPCR_LEN);
3101
3102 enum mlxsw_reg_qpcr_g {
3103         MLXSW_REG_QPCR_G_GLOBAL = 2,
3104         MLXSW_REG_QPCR_G_STORM_CONTROL = 3,
3105 };
3106
3107 /* reg_qpcr_g
3108  * The policer type.
3109  * Access: Index
3110  */
3111 MLXSW_ITEM32(reg, qpcr, g, 0x00, 14, 2);
3112
3113 /* reg_qpcr_pid
3114  * Policer ID.
3115  * Access: Index
3116  */
3117 MLXSW_ITEM32(reg, qpcr, pid, 0x00, 0, 14);
3118
3119 /* reg_qpcr_color_aware
3120  * Is the policer aware of colors.
3121  * Must be 0 (unaware) for cpu port.
3122  * Access: RW for unbounded policer. RO for bounded policer.
3123  */
3124 MLXSW_ITEM32(reg, qpcr, color_aware, 0x04, 15, 1);
3125
3126 /* reg_qpcr_bytes
3127  * Is policer limit is for bytes per sec or packets per sec.
3128  * 0 - packets
3129  * 1 - bytes
3130  * Access: RW for unbounded policer. RO for bounded policer.
3131  */
3132 MLXSW_ITEM32(reg, qpcr, bytes, 0x04, 14, 1);
3133
3134 enum mlxsw_reg_qpcr_ir_units {
3135         MLXSW_REG_QPCR_IR_UNITS_M,
3136         MLXSW_REG_QPCR_IR_UNITS_K,
3137 };
3138
3139 /* reg_qpcr_ir_units
3140  * Policer's units for cir and eir fields (for bytes limits only)
3141  * 1 - 10^3
3142  * 0 - 10^6
3143  * Access: OP
3144  */
3145 MLXSW_ITEM32(reg, qpcr, ir_units, 0x04, 12, 1);
3146
3147 enum mlxsw_reg_qpcr_rate_type {
3148         MLXSW_REG_QPCR_RATE_TYPE_SINGLE = 1,
3149         MLXSW_REG_QPCR_RATE_TYPE_DOUBLE = 2,
3150 };
3151
3152 /* reg_qpcr_rate_type
3153  * Policer can have one limit (single rate) or 2 limits with specific operation
3154  * for packets that exceed the lower rate but not the upper one.
3155  * (For cpu port must be single rate)
3156  * Access: RW for unbounded policer. RO for bounded policer.
3157  */
3158 MLXSW_ITEM32(reg, qpcr, rate_type, 0x04, 8, 2);
3159
3160 /* reg_qpc_cbs
3161  * Policer's committed burst size.
3162  * The policer is working with time slices of 50 nano sec. By default every
3163  * slice is granted the proportionate share of the committed rate. If we want to
3164  * allow a slice to exceed that share (while still keeping the rate per sec) we
3165  * can allow burst. The burst size is between the default proportionate share
3166  * (and no lower than 8) to 32Gb. (Even though giving a number higher than the
3167  * committed rate will result in exceeding the rate). The burst size must be a
3168  * log of 2 and will be determined by 2^cbs.
3169  * Access: RW
3170  */
3171 MLXSW_ITEM32(reg, qpcr, cbs, 0x08, 24, 6);
3172
3173 /* reg_qpcr_cir
3174  * Policer's committed rate.
3175  * The rate used for sungle rate, the lower rate for double rate.
3176  * For bytes limits, the rate will be this value * the unit from ir_units.
3177  * (Resolution error is up to 1%).
3178  * Access: RW
3179  */
3180 MLXSW_ITEM32(reg, qpcr, cir, 0x0C, 0, 32);
3181
3182 /* reg_qpcr_eir
3183  * Policer's exceed rate.
3184  * The higher rate for double rate, reserved for single rate.
3185  * Lower rate for double rate policer.
3186  * For bytes limits, the rate will be this value * the unit from ir_units.
3187  * (Resolution error is up to 1%).
3188  * Access: RW
3189  */
3190 MLXSW_ITEM32(reg, qpcr, eir, 0x10, 0, 32);
3191
3192 #define MLXSW_REG_QPCR_DOUBLE_RATE_ACTION 2
3193
3194 /* reg_qpcr_exceed_action.
3195  * What to do with packets between the 2 limits for double rate.
3196  * Access: RW for unbounded policer. RO for bounded policer.
3197  */
3198 MLXSW_ITEM32(reg, qpcr, exceed_action, 0x14, 0, 4);
3199
3200 enum mlxsw_reg_qpcr_action {
3201         /* Discard */
3202         MLXSW_REG_QPCR_ACTION_DISCARD = 1,
3203         /* Forward and set color to red.
3204          * If the packet is intended to cpu port, it will be dropped.
3205          */
3206         MLXSW_REG_QPCR_ACTION_FORWARD = 2,
3207 };
3208
3209 /* reg_qpcr_violate_action
3210  * What to do with packets that cross the cir limit (for single rate) or the eir
3211  * limit (for double rate).
3212  * Access: RW for unbounded policer. RO for bounded policer.
3213  */
3214 MLXSW_ITEM32(reg, qpcr, violate_action, 0x18, 0, 4);
3215
3216 static inline void mlxsw_reg_qpcr_pack(char *payload, u16 pid,
3217                                        enum mlxsw_reg_qpcr_ir_units ir_units,
3218                                        bool bytes, u32 cir, u16 cbs)
3219 {
3220         MLXSW_REG_ZERO(qpcr, payload);
3221         mlxsw_reg_qpcr_pid_set(payload, pid);
3222         mlxsw_reg_qpcr_g_set(payload, MLXSW_REG_QPCR_G_GLOBAL);
3223         mlxsw_reg_qpcr_rate_type_set(payload, MLXSW_REG_QPCR_RATE_TYPE_SINGLE);
3224         mlxsw_reg_qpcr_violate_action_set(payload,
3225                                           MLXSW_REG_QPCR_ACTION_DISCARD);
3226         mlxsw_reg_qpcr_cir_set(payload, cir);
3227         mlxsw_reg_qpcr_ir_units_set(payload, ir_units);
3228         mlxsw_reg_qpcr_bytes_set(payload, bytes);
3229         mlxsw_reg_qpcr_cbs_set(payload, cbs);
3230 }
3231
3232 /* QTCT - QoS Switch Traffic Class Table
3233  * -------------------------------------
3234  * Configures the mapping between the packet switch priority and the
3235  * traffic class on the transmit port.
3236  */
3237 #define MLXSW_REG_QTCT_ID 0x400A
3238 #define MLXSW_REG_QTCT_LEN 0x08
3239
3240 MLXSW_REG_DEFINE(qtct, MLXSW_REG_QTCT_ID, MLXSW_REG_QTCT_LEN);
3241
3242 /* reg_qtct_local_port
3243  * Local port number.
3244  * Access: Index
3245  *
3246  * Note: CPU port is not supported.
3247  */
3248 MLXSW_ITEM32(reg, qtct, local_port, 0x00, 16, 8);
3249
3250 /* reg_qtct_sub_port
3251  * Virtual port within the physical port.
3252  * Should be set to 0 when virtual ports are not enabled on the port.
3253  * Access: Index
3254  */
3255 MLXSW_ITEM32(reg, qtct, sub_port, 0x00, 8, 8);
3256
3257 /* reg_qtct_switch_prio
3258  * Switch priority.
3259  * Access: Index
3260  */
3261 MLXSW_ITEM32(reg, qtct, switch_prio, 0x00, 0, 4);
3262
3263 /* reg_qtct_tclass
3264  * Traffic class.
3265  * Default values:
3266  * switch_prio 0 : tclass 1
3267  * switch_prio 1 : tclass 0
3268  * switch_prio i : tclass i, for i > 1
3269  * Access: RW
3270  */
3271 MLXSW_ITEM32(reg, qtct, tclass, 0x04, 0, 4);
3272
3273 static inline void mlxsw_reg_qtct_pack(char *payload, u8 local_port,
3274                                        u8 switch_prio, u8 tclass)
3275 {
3276         MLXSW_REG_ZERO(qtct, payload);
3277         mlxsw_reg_qtct_local_port_set(payload, local_port);
3278         mlxsw_reg_qtct_switch_prio_set(payload, switch_prio);
3279         mlxsw_reg_qtct_tclass_set(payload, tclass);
3280 }
3281
3282 /* QEEC - QoS ETS Element Configuration Register
3283  * ---------------------------------------------
3284  * Configures the ETS elements.
3285  */
3286 #define MLXSW_REG_QEEC_ID 0x400D
3287 #define MLXSW_REG_QEEC_LEN 0x1C
3288
3289 MLXSW_REG_DEFINE(qeec, MLXSW_REG_QEEC_ID, MLXSW_REG_QEEC_LEN);
3290
3291 /* reg_qeec_local_port
3292  * Local port number.
3293  * Access: Index
3294  *
3295  * Note: CPU port is supported.
3296  */
3297 MLXSW_ITEM32(reg, qeec, local_port, 0x00, 16, 8);
3298
3299 enum mlxsw_reg_qeec_hr {
3300         MLXSW_REG_QEEC_HIERARCY_PORT,
3301         MLXSW_REG_QEEC_HIERARCY_GROUP,
3302         MLXSW_REG_QEEC_HIERARCY_SUBGROUP,
3303         MLXSW_REG_QEEC_HIERARCY_TC,
3304 };
3305
3306 /* reg_qeec_element_hierarchy
3307  * 0 - Port
3308  * 1 - Group
3309  * 2 - Subgroup
3310  * 3 - Traffic Class
3311  * Access: Index
3312  */
3313 MLXSW_ITEM32(reg, qeec, element_hierarchy, 0x04, 16, 4);
3314
3315 /* reg_qeec_element_index
3316  * The index of the element in the hierarchy.
3317  * Access: Index
3318  */
3319 MLXSW_ITEM32(reg, qeec, element_index, 0x04, 0, 8);
3320
3321 /* reg_qeec_next_element_index
3322  * The index of the next (lower) element in the hierarchy.
3323  * Access: RW
3324  *
3325  * Note: Reserved for element_hierarchy 0.
3326  */
3327 MLXSW_ITEM32(reg, qeec, next_element_index, 0x08, 0, 8);
3328
3329 enum {
3330         MLXSW_REG_QEEC_BYTES_MODE,
3331         MLXSW_REG_QEEC_PACKETS_MODE,
3332 };
3333
3334 /* reg_qeec_pb
3335  * Packets or bytes mode.
3336  * 0 - Bytes mode
3337  * 1 - Packets mode
3338  * Access: RW
3339  *
3340  * Note: Used for max shaper configuration. For Spectrum, packets mode
3341  * is supported only for traffic classes of CPU port.
3342  */
3343 MLXSW_ITEM32(reg, qeec, pb, 0x0C, 28, 1);
3344
3345 /* reg_qeec_mase
3346  * Max shaper configuration enable. Enables configuration of the max
3347  * shaper on this ETS element.
3348  * 0 - Disable
3349  * 1 - Enable
3350  * Access: RW
3351  */
3352 MLXSW_ITEM32(reg, qeec, mase, 0x10, 31, 1);
3353
3354 /* A large max rate will disable the max shaper. */
3355 #define MLXSW_REG_QEEC_MAS_DIS  200000000       /* Kbps */
3356
3357 /* reg_qeec_max_shaper_rate
3358  * Max shaper information rate.
3359  * For CPU port, can only be configured for port hierarchy.
3360  * When in bytes mode, value is specified in units of 1000bps.
3361  * Access: RW
3362  */
3363 MLXSW_ITEM32(reg, qeec, max_shaper_rate, 0x10, 0, 28);
3364
3365 /* reg_qeec_de
3366  * DWRR configuration enable. Enables configuration of the dwrr and
3367  * dwrr_weight.
3368  * 0 - Disable
3369  * 1 - Enable
3370  * Access: RW
3371  */
3372 MLXSW_ITEM32(reg, qeec, de, 0x18, 31, 1);
3373
3374 /* reg_qeec_dwrr
3375  * Transmission selection algorithm to use on the link going down from
3376  * the ETS element.
3377  * 0 - Strict priority
3378  * 1 - DWRR
3379  * Access: RW
3380  */
3381 MLXSW_ITEM32(reg, qeec, dwrr, 0x18, 15, 1);
3382
3383 /* reg_qeec_dwrr_weight
3384  * DWRR weight on the link going down from the ETS element. The
3385  * percentage of bandwidth guaranteed to an ETS element within
3386  * its hierarchy. The sum of all weights across all ETS elements
3387  * within one hierarchy should be equal to 100. Reserved when
3388  * transmission selection algorithm is strict priority.
3389  * Access: RW
3390  */
3391 MLXSW_ITEM32(reg, qeec, dwrr_weight, 0x18, 0, 8);
3392
3393 static inline void mlxsw_reg_qeec_pack(char *payload, u8 local_port,
3394                                        enum mlxsw_reg_qeec_hr hr, u8 index,
3395                                        u8 next_index)
3396 {
3397         MLXSW_REG_ZERO(qeec, payload);
3398         mlxsw_reg_qeec_local_port_set(payload, local_port);
3399         mlxsw_reg_qeec_element_hierarchy_set(payload, hr);
3400         mlxsw_reg_qeec_element_index_set(payload, index);
3401         mlxsw_reg_qeec_next_element_index_set(payload, next_index);
3402 }
3403
3404 /* QRWE - QoS ReWrite Enable
3405  * -------------------------
3406  * This register configures the rewrite enable per receive port.
3407  */
3408 #define MLXSW_REG_QRWE_ID 0x400F
3409 #define MLXSW_REG_QRWE_LEN 0x08
3410
3411 MLXSW_REG_DEFINE(qrwe, MLXSW_REG_QRWE_ID, MLXSW_REG_QRWE_LEN);
3412
3413 /* reg_qrwe_local_port
3414  * Local port number.
3415  * Access: Index
3416  *
3417  * Note: CPU port is supported. No support for router port.
3418  */
3419 MLXSW_ITEM32(reg, qrwe, local_port, 0x00, 16, 8);
3420
3421 /* reg_qrwe_dscp
3422  * Whether to enable DSCP rewrite (default is 0, don't rewrite).
3423  * Access: RW
3424  */
3425 MLXSW_ITEM32(reg, qrwe, dscp, 0x04, 1, 1);
3426
3427 /* reg_qrwe_pcp
3428  * Whether to enable PCP and DEI rewrite (default is 0, don't rewrite).
3429  * Access: RW
3430  */
3431 MLXSW_ITEM32(reg, qrwe, pcp, 0x04, 0, 1);
3432
3433 static inline void mlxsw_reg_qrwe_pack(char *payload, u8 local_port,
3434                                        bool rewrite_pcp, bool rewrite_dscp)
3435 {
3436         MLXSW_REG_ZERO(qrwe, payload);
3437         mlxsw_reg_qrwe_local_port_set(payload, local_port);
3438         mlxsw_reg_qrwe_pcp_set(payload, rewrite_pcp);
3439         mlxsw_reg_qrwe_dscp_set(payload, rewrite_dscp);
3440 }
3441
3442 /* QPDSM - QoS Priority to DSCP Mapping
3443  * ------------------------------------
3444  * QoS Priority to DSCP Mapping Register
3445  */
3446 #define MLXSW_REG_QPDSM_ID 0x4011
3447 #define MLXSW_REG_QPDSM_BASE_LEN 0x04 /* base length, without records */
3448 #define MLXSW_REG_QPDSM_PRIO_ENTRY_REC_LEN 0x4 /* record length */
3449 #define MLXSW_REG_QPDSM_PRIO_ENTRY_REC_MAX_COUNT 16
3450 #define MLXSW_REG_QPDSM_LEN (MLXSW_REG_QPDSM_BASE_LEN +                 \
3451                              MLXSW_REG_QPDSM_PRIO_ENTRY_REC_LEN *       \
3452                              MLXSW_REG_QPDSM_PRIO_ENTRY_REC_MAX_COUNT)
3453
3454 MLXSW_REG_DEFINE(qpdsm, MLXSW_REG_QPDSM_ID, MLXSW_REG_QPDSM_LEN);
3455
3456 /* reg_qpdsm_local_port
3457  * Local Port. Supported for data packets from CPU port.
3458  * Access: Index
3459  */
3460 MLXSW_ITEM32(reg, qpdsm, local_port, 0x00, 16, 8);
3461
3462 /* reg_qpdsm_prio_entry_color0_e
3463  * Enable update of the entry for color 0 and a given port.
3464  * Access: WO
3465  */
3466 MLXSW_ITEM32_INDEXED(reg, qpdsm, prio_entry_color0_e,
3467                      MLXSW_REG_QPDSM_BASE_LEN, 31, 1,
3468                      MLXSW_REG_QPDSM_PRIO_ENTRY_REC_LEN, 0x00, false);
3469
3470 /* reg_qpdsm_prio_entry_color0_dscp
3471  * DSCP field in the outer label of the packet for color 0 and a given port.
3472  * Reserved when e=0.
3473  * Access: RW
3474  */
3475 MLXSW_ITEM32_INDEXED(reg, qpdsm, prio_entry_color0_dscp,
3476                      MLXSW_REG_QPDSM_BASE_LEN, 24, 6,
3477                      MLXSW_REG_QPDSM_PRIO_ENTRY_REC_LEN, 0x00, false);
3478
3479 /* reg_qpdsm_prio_entry_color1_e
3480  * Enable update of the entry for color 1 and a given port.
3481  * Access: WO
3482  */
3483 MLXSW_ITEM32_INDEXED(reg, qpdsm, prio_entry_color1_e,
3484                      MLXSW_REG_QPDSM_BASE_LEN, 23, 1,
3485                      MLXSW_REG_QPDSM_PRIO_ENTRY_REC_LEN, 0x00, false);
3486
3487 /* reg_qpdsm_prio_entry_color1_dscp
3488  * DSCP field in the outer label of the packet for color 1 and a given port.
3489  * Reserved when e=0.
3490  * Access: RW
3491  */
3492 MLXSW_ITEM32_INDEXED(reg, qpdsm, prio_entry_color1_dscp,
3493                      MLXSW_REG_QPDSM_BASE_LEN, 16, 6,
3494                      MLXSW_REG_QPDSM_PRIO_ENTRY_REC_LEN, 0x00, false);
3495
3496 /* reg_qpdsm_prio_entry_color2_e
3497  * Enable update of the entry for color 2 and a given port.
3498  * Access: WO
3499  */
3500 MLXSW_ITEM32_INDEXED(reg, qpdsm, prio_entry_color2_e,
3501                      MLXSW_REG_QPDSM_BASE_LEN, 15, 1,
3502                      MLXSW_REG_QPDSM_PRIO_ENTRY_REC_LEN, 0x00, false);
3503
3504 /* reg_qpdsm_prio_entry_color2_dscp
3505  * DSCP field in the outer label of the packet for color 2 and a given port.
3506  * Reserved when e=0.
3507  * Access: RW
3508  */
3509 MLXSW_ITEM32_INDEXED(reg, qpdsm, prio_entry_color2_dscp,
3510                      MLXSW_REG_QPDSM_BASE_LEN, 8, 6,
3511                      MLXSW_REG_QPDSM_PRIO_ENTRY_REC_LEN, 0x00, false);
3512
3513 static inline void mlxsw_reg_qpdsm_pack(char *payload, u8 local_port)
3514 {
3515         MLXSW_REG_ZERO(qpdsm, payload);
3516         mlxsw_reg_qpdsm_local_port_set(payload, local_port);
3517 }
3518
3519 static inline void
3520 mlxsw_reg_qpdsm_prio_pack(char *payload, unsigned short prio, u8 dscp)
3521 {
3522         mlxsw_reg_qpdsm_prio_entry_color0_e_set(payload, prio, 1);
3523         mlxsw_reg_qpdsm_prio_entry_color0_dscp_set(payload, prio, dscp);
3524         mlxsw_reg_qpdsm_prio_entry_color1_e_set(payload, prio, 1);
3525         mlxsw_reg_qpdsm_prio_entry_color1_dscp_set(payload, prio, dscp);
3526         mlxsw_reg_qpdsm_prio_entry_color2_e_set(payload, prio, 1);
3527         mlxsw_reg_qpdsm_prio_entry_color2_dscp_set(payload, prio, dscp);
3528 }
3529
3530 /* QPDPM - QoS Port DSCP to Priority Mapping Register
3531  * --------------------------------------------------
3532  * This register controls the mapping from DSCP field to
3533  * Switch Priority for IP packets.
3534  */
3535 #define MLXSW_REG_QPDPM_ID 0x4013
3536 #define MLXSW_REG_QPDPM_BASE_LEN 0x4 /* base length, without records */
3537 #define MLXSW_REG_QPDPM_DSCP_ENTRY_REC_LEN 0x2 /* record length */
3538 #define MLXSW_REG_QPDPM_DSCP_ENTRY_REC_MAX_COUNT 64
3539 #define MLXSW_REG_QPDPM_LEN (MLXSW_REG_QPDPM_BASE_LEN +                 \
3540                              MLXSW_REG_QPDPM_DSCP_ENTRY_REC_LEN *       \
3541                              MLXSW_REG_QPDPM_DSCP_ENTRY_REC_MAX_COUNT)
3542
3543 MLXSW_REG_DEFINE(qpdpm, MLXSW_REG_QPDPM_ID, MLXSW_REG_QPDPM_LEN);
3544
3545 /* reg_qpdpm_local_port
3546  * Local Port. Supported for data packets from CPU port.
3547  * Access: Index
3548  */
3549 MLXSW_ITEM32(reg, qpdpm, local_port, 0x00, 16, 8);
3550
3551 /* reg_qpdpm_dscp_e
3552  * Enable update of the specific entry. When cleared, the switch_prio and color
3553  * fields are ignored and the previous switch_prio and color values are
3554  * preserved.
3555  * Access: WO
3556  */