Loading...
1// SPDX-License-Identifier: GPL-2.0-only
2/* Atlantic Network Driver
3 * Copyright (C) 2020 Marvell International Ltd.
4 */
5
6#include "macsec_api.h"
7#include <linux/mdio.h>
8#include "MSS_Ingress_registers.h"
9#include "MSS_Egress_registers.h"
10#include "aq_phy.h"
11
12#define AQ_API_CALL_SAFE(func, ...) \
13({ \
14 int ret; \
15 do { \
16 ret = aq_mss_mdio_sem_get(hw); \
17 if (unlikely(ret)) \
18 break; \
19 \
20 ret = func(__VA_ARGS__); \
21 \
22 aq_mss_mdio_sem_put(hw); \
23 } while (0); \
24 ret; \
25})
26
27/*******************************************************************************
28 * MDIO wrappers
29 ******************************************************************************/
30static int aq_mss_mdio_sem_get(struct aq_hw_s *hw)
31{
32 u32 val;
33
34 return readx_poll_timeout_atomic(hw_atl_sem_mdio_get, hw, val,
35 val == 1U, 10U, 100000U);
36}
37
38static void aq_mss_mdio_sem_put(struct aq_hw_s *hw)
39{
40 hw_atl_reg_glb_cpu_sem_set(hw, 1U, HW_ATL_FW_SM_MDIO);
41}
42
43static int aq_mss_mdio_read(struct aq_hw_s *hw, u16 mmd, u16 addr, u16 *data)
44{
45 *data = aq_mdio_read_word(hw, mmd, addr);
46 return (*data != 0xffff) ? 0 : -ETIME;
47}
48
49static int aq_mss_mdio_write(struct aq_hw_s *hw, u16 mmd, u16 addr, u16 data)
50{
51 aq_mdio_write_word(hw, mmd, addr, data);
52 return 0;
53}
54
55/*******************************************************************************
56 * MACSEC config and status
57 ******************************************************************************/
58
59static int set_raw_ingress_record(struct aq_hw_s *hw, u16 *packed_record,
60 u8 num_words, u8 table_id,
61 u16 table_index)
62{
63 struct mss_ingress_lut_addr_ctl_register lut_sel_reg;
64 struct mss_ingress_lut_ctl_register lut_op_reg;
65
66 unsigned int i;
67
68 /* NOTE: MSS registers must always be read/written as adjacent pairs.
69 * For instance, to write either or both 1E.80A0 and 80A1, we have to:
70 * 1. Write 1E.80A0 first
71 * 2. Then write 1E.80A1
72 *
73 * For HHD devices: These writes need to be performed consecutively, and
74 * to ensure this we use the PIF mailbox to delegate the reads/writes to
75 * the FW.
76 *
77 * For EUR devices: Not need to use the PIF mailbox; it is safe to
78 * write to the registers directly.
79 */
80
81 /* Write the packed record words to the data buffer registers. */
82 for (i = 0; i < num_words; i += 2) {
83 aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
84 MSS_INGRESS_LUT_DATA_CTL_REGISTER_ADDR + i,
85 packed_record[i]);
86 aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
87 MSS_INGRESS_LUT_DATA_CTL_REGISTER_ADDR + i +
88 1,
89 packed_record[i + 1]);
90 }
91
92 /* Clear out the unused data buffer registers. */
93 for (i = num_words; i < 24; i += 2) {
94 aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
95 MSS_INGRESS_LUT_DATA_CTL_REGISTER_ADDR + i,
96 0);
97 aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
98 MSS_INGRESS_LUT_DATA_CTL_REGISTER_ADDR + i + 1, 0);
99 }
100
101 /* Select the table and row index to write to */
102 lut_sel_reg.bits_0.lut_select = table_id;
103 lut_sel_reg.bits_0.lut_addr = table_index;
104
105 lut_op_reg.bits_0.lut_read = 0;
106 lut_op_reg.bits_0.lut_write = 1;
107
108 aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
109 MSS_INGRESS_LUT_ADDR_CTL_REGISTER_ADDR,
110 lut_sel_reg.word_0);
111 aq_mss_mdio_write(hw, MDIO_MMD_VEND1, MSS_INGRESS_LUT_CTL_REGISTER_ADDR,
112 lut_op_reg.word_0);
113
114 return 0;
115}
116
117/*! Read the specified Ingress LUT table row.
118 * packed_record - [OUT] The table row data (raw).
119 */
120static int get_raw_ingress_record(struct aq_hw_s *hw, u16 *packed_record,
121 u8 num_words, u8 table_id,
122 u16 table_index)
123{
124 struct mss_ingress_lut_addr_ctl_register lut_sel_reg;
125 struct mss_ingress_lut_ctl_register lut_op_reg;
126 int ret;
127
128 unsigned int i;
129
130 /* Select the table and row index to read */
131 lut_sel_reg.bits_0.lut_select = table_id;
132 lut_sel_reg.bits_0.lut_addr = table_index;
133
134 lut_op_reg.bits_0.lut_read = 1;
135 lut_op_reg.bits_0.lut_write = 0;
136
137 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
138 MSS_INGRESS_LUT_ADDR_CTL_REGISTER_ADDR,
139 lut_sel_reg.word_0);
140 if (unlikely(ret))
141 return ret;
142 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
143 MSS_INGRESS_LUT_CTL_REGISTER_ADDR,
144 lut_op_reg.word_0);
145 if (unlikely(ret))
146 return ret;
147
148 memset(packed_record, 0, sizeof(u16) * num_words);
149
150 for (i = 0; i < num_words; i += 2) {
151 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1,
152 MSS_INGRESS_LUT_DATA_CTL_REGISTER_ADDR +
153 i,
154 &packed_record[i]);
155 if (unlikely(ret))
156 return ret;
157 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1,
158 MSS_INGRESS_LUT_DATA_CTL_REGISTER_ADDR +
159 i + 1,
160 &packed_record[i + 1]);
161 if (unlikely(ret))
162 return ret;
163 }
164
165 return 0;
166}
167
168/*! Write packed_record to the specified Egress LUT table row. */
169static int set_raw_egress_record(struct aq_hw_s *hw, u16 *packed_record,
170 u8 num_words, u8 table_id,
171 u16 table_index)
172{
173 struct mss_egress_lut_addr_ctl_register lut_sel_reg;
174 struct mss_egress_lut_ctl_register lut_op_reg;
175
176 unsigned int i;
177
178 /* Write the packed record words to the data buffer registers. */
179 for (i = 0; i < num_words; i += 2) {
180 aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
181 MSS_EGRESS_LUT_DATA_CTL_REGISTER_ADDR + i,
182 packed_record[i]);
183 aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
184 MSS_EGRESS_LUT_DATA_CTL_REGISTER_ADDR + i + 1,
185 packed_record[i + 1]);
186 }
187
188 /* Clear out the unused data buffer registers. */
189 for (i = num_words; i < 28; i += 2) {
190 aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
191 MSS_EGRESS_LUT_DATA_CTL_REGISTER_ADDR + i, 0);
192 aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
193 MSS_EGRESS_LUT_DATA_CTL_REGISTER_ADDR + i + 1,
194 0);
195 }
196
197 /* Select the table and row index to write to */
198 lut_sel_reg.bits_0.lut_select = table_id;
199 lut_sel_reg.bits_0.lut_addr = table_index;
200
201 lut_op_reg.bits_0.lut_read = 0;
202 lut_op_reg.bits_0.lut_write = 1;
203
204 aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
205 MSS_EGRESS_LUT_ADDR_CTL_REGISTER_ADDR,
206 lut_sel_reg.word_0);
207 aq_mss_mdio_write(hw, MDIO_MMD_VEND1, MSS_EGRESS_LUT_CTL_REGISTER_ADDR,
208 lut_op_reg.word_0);
209
210 return 0;
211}
212
213static int get_raw_egress_record(struct aq_hw_s *hw, u16 *packed_record,
214 u8 num_words, u8 table_id,
215 u16 table_index)
216{
217 struct mss_egress_lut_addr_ctl_register lut_sel_reg;
218 struct mss_egress_lut_ctl_register lut_op_reg;
219 int ret;
220
221 unsigned int i;
222
223 /* Select the table and row index to read */
224 lut_sel_reg.bits_0.lut_select = table_id;
225 lut_sel_reg.bits_0.lut_addr = table_index;
226
227 lut_op_reg.bits_0.lut_read = 1;
228 lut_op_reg.bits_0.lut_write = 0;
229
230 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
231 MSS_EGRESS_LUT_ADDR_CTL_REGISTER_ADDR,
232 lut_sel_reg.word_0);
233 if (unlikely(ret))
234 return ret;
235 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
236 MSS_EGRESS_LUT_CTL_REGISTER_ADDR,
237 lut_op_reg.word_0);
238 if (unlikely(ret))
239 return ret;
240
241 memset(packed_record, 0, sizeof(u16) * num_words);
242
243 for (i = 0; i < num_words; i += 2) {
244 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1,
245 MSS_EGRESS_LUT_DATA_CTL_REGISTER_ADDR +
246 i,
247 &packed_record[i]);
248 if (unlikely(ret))
249 return ret;
250 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1,
251 MSS_EGRESS_LUT_DATA_CTL_REGISTER_ADDR +
252 i + 1,
253 &packed_record[i + 1]);
254 if (unlikely(ret))
255 return ret;
256 }
257
258 return 0;
259}
260
261static int
262set_ingress_prectlf_record(struct aq_hw_s *hw,
263 const struct aq_mss_ingress_prectlf_record *rec,
264 u16 table_index)
265{
266 u16 packed_record[6];
267
268 if (table_index >= NUMROWS_INGRESSPRECTLFRECORD)
269 return -EINVAL;
270
271 memset(packed_record, 0, sizeof(u16) * 6);
272
273 packed_record[0] = rec->sa_da[0] & 0xFFFF;
274 packed_record[1] = (rec->sa_da[0] >> 16) & 0xFFFF;
275 packed_record[2] = rec->sa_da[1] & 0xFFFF;
276 packed_record[3] = rec->eth_type & 0xFFFF;
277 packed_record[4] = rec->match_mask & 0xFFFF;
278 packed_record[5] = rec->match_type & 0xF;
279 packed_record[5] |= (rec->action & 0x1) << 4;
280
281 return set_raw_ingress_record(hw, packed_record, 6, 0,
282 ROWOFFSET_INGRESSPRECTLFRECORD +
283 table_index);
284}
285
286int aq_mss_set_ingress_prectlf_record(struct aq_hw_s *hw,
287 const struct aq_mss_ingress_prectlf_record *rec,
288 u16 table_index)
289{
290 return AQ_API_CALL_SAFE(set_ingress_prectlf_record, hw, rec,
291 table_index);
292}
293
294static int get_ingress_prectlf_record(struct aq_hw_s *hw,
295 struct aq_mss_ingress_prectlf_record *rec,
296 u16 table_index)
297{
298 u16 packed_record[6];
299 int ret;
300
301 if (table_index >= NUMROWS_INGRESSPRECTLFRECORD)
302 return -EINVAL;
303
304 /* If the row that we want to read is odd, first read the previous even
305 * row, throw that value away, and finally read the desired row.
306 * This is a workaround for EUR devices that allows us to read
307 * odd-numbered rows. For HHD devices: this workaround will not work,
308 * so don't bother; odd-numbered rows are not readable.
309 */
310 if ((table_index % 2) > 0) {
311 ret = get_raw_ingress_record(hw, packed_record, 6, 0,
312 ROWOFFSET_INGRESSPRECTLFRECORD +
313 table_index - 1);
314 if (unlikely(ret))
315 return ret;
316 }
317
318 ret = get_raw_ingress_record(hw, packed_record, 6, 0,
319 ROWOFFSET_INGRESSPRECTLFRECORD +
320 table_index);
321 if (unlikely(ret))
322 return ret;
323
324 rec->sa_da[0] = packed_record[0];
325 rec->sa_da[0] |= packed_record[1] << 16;
326
327 rec->sa_da[1] = packed_record[2];
328
329 rec->eth_type = packed_record[3];
330
331 rec->match_mask = packed_record[4];
332
333 rec->match_type = packed_record[5] & 0xF;
334
335 rec->action = (packed_record[5] >> 4) & 0x1;
336
337 return 0;
338}
339
340int aq_mss_get_ingress_prectlf_record(struct aq_hw_s *hw,
341 struct aq_mss_ingress_prectlf_record *rec,
342 u16 table_index)
343{
344 memset(rec, 0, sizeof(*rec));
345
346 return AQ_API_CALL_SAFE(get_ingress_prectlf_record, hw, rec,
347 table_index);
348}
349
350static int
351set_ingress_preclass_record(struct aq_hw_s *hw,
352 const struct aq_mss_ingress_preclass_record *rec,
353 u16 table_index)
354{
355 u16 packed_record[20];
356
357 if (table_index >= NUMROWS_INGRESSPRECLASSRECORD)
358 return -EINVAL;
359
360 memset(packed_record, 0, sizeof(u16) * 20);
361
362 packed_record[0] = rec->sci[0] & 0xFFFF;
363 packed_record[1] = (rec->sci[0] >> 16) & 0xFFFF;
364
365 packed_record[2] = rec->sci[1] & 0xFFFF;
366 packed_record[3] = (rec->sci[1] >> 16) & 0xFFFF;
367
368 packed_record[4] = rec->tci & 0xFF;
369
370 packed_record[4] |= (rec->encr_offset & 0xFF) << 8;
371
372 packed_record[5] = rec->eth_type & 0xFFFF;
373
374 packed_record[6] = rec->snap[0] & 0xFFFF;
375 packed_record[7] = (rec->snap[0] >> 16) & 0xFFFF;
376
377 packed_record[8] = rec->snap[1] & 0xFF;
378
379 packed_record[8] |= (rec->llc & 0xFF) << 8;
380 packed_record[9] = (rec->llc >> 8) & 0xFFFF;
381
382 packed_record[10] = rec->mac_sa[0] & 0xFFFF;
383 packed_record[11] = (rec->mac_sa[0] >> 16) & 0xFFFF;
384
385 packed_record[12] = rec->mac_sa[1] & 0xFFFF;
386
387 packed_record[13] = rec->mac_da[0] & 0xFFFF;
388 packed_record[14] = (rec->mac_da[0] >> 16) & 0xFFFF;
389
390 packed_record[15] = rec->mac_da[1] & 0xFFFF;
391
392 packed_record[16] = rec->lpbk_packet & 0x1;
393
394 packed_record[16] |= (rec->an_mask & 0x3) << 1;
395
396 packed_record[16] |= (rec->tci_mask & 0x3F) << 3;
397
398 packed_record[16] |= (rec->sci_mask & 0x7F) << 9;
399 packed_record[17] = (rec->sci_mask >> 7) & 0x1;
400
401 packed_record[17] |= (rec->eth_type_mask & 0x3) << 1;
402
403 packed_record[17] |= (rec->snap_mask & 0x1F) << 3;
404
405 packed_record[17] |= (rec->llc_mask & 0x7) << 8;
406
407 packed_record[17] |= (rec->_802_2_encapsulate & 0x1) << 11;
408
409 packed_record[17] |= (rec->sa_mask & 0xF) << 12;
410 packed_record[18] = (rec->sa_mask >> 4) & 0x3;
411
412 packed_record[18] |= (rec->da_mask & 0x3F) << 2;
413
414 packed_record[18] |= (rec->lpbk_mask & 0x1) << 8;
415
416 packed_record[18] |= (rec->sc_idx & 0x1F) << 9;
417
418 packed_record[18] |= (rec->proc_dest & 0x1) << 14;
419
420 packed_record[18] |= (rec->action & 0x1) << 15;
421 packed_record[19] = (rec->action >> 1) & 0x1;
422
423 packed_record[19] |= (rec->ctrl_unctrl & 0x1) << 1;
424
425 packed_record[19] |= (rec->sci_from_table & 0x1) << 2;
426
427 packed_record[19] |= (rec->reserved & 0xF) << 3;
428
429 packed_record[19] |= (rec->valid & 0x1) << 7;
430
431 return set_raw_ingress_record(hw, packed_record, 20, 1,
432 ROWOFFSET_INGRESSPRECLASSRECORD +
433 table_index);
434}
435
436int aq_mss_set_ingress_preclass_record(struct aq_hw_s *hw,
437 const struct aq_mss_ingress_preclass_record *rec,
438 u16 table_index)
439{
440 int err = AQ_API_CALL_SAFE(set_ingress_preclass_record, hw, rec,
441 table_index);
442
443 WARN_ONCE(err, "%s failed with %d\n", __func__, err);
444
445 return err;
446}
447
448static int
449get_ingress_preclass_record(struct aq_hw_s *hw,
450 struct aq_mss_ingress_preclass_record *rec,
451 u16 table_index)
452{
453 u16 packed_record[20];
454 int ret;
455
456 if (table_index >= NUMROWS_INGRESSPRECLASSRECORD)
457 return -EINVAL;
458
459 /* If the row that we want to read is odd, first read the previous even
460 * row, throw that value away, and finally read the desired row.
461 */
462 if ((table_index % 2) > 0) {
463 ret = get_raw_ingress_record(hw, packed_record, 20, 1,
464 ROWOFFSET_INGRESSPRECLASSRECORD +
465 table_index - 1);
466 if (unlikely(ret))
467 return ret;
468 }
469
470 ret = get_raw_ingress_record(hw, packed_record, 20, 1,
471 ROWOFFSET_INGRESSPRECLASSRECORD +
472 table_index);
473 if (unlikely(ret))
474 return ret;
475
476 rec->sci[0] = packed_record[0];
477 rec->sci[0] |= packed_record[1] << 16;
478
479 rec->sci[1] = packed_record[2];
480 rec->sci[1] |= packed_record[3] << 16;
481
482 rec->tci = packed_record[4] & 0xFF;
483
484 rec->encr_offset = (packed_record[4] >> 8) & 0xFF;
485
486 rec->eth_type = packed_record[5];
487
488 rec->snap[0] = packed_record[6];
489 rec->snap[0] |= packed_record[7] << 16;
490
491 rec->snap[1] = packed_record[8] & 0xFF;
492
493 rec->llc = (packed_record[8] >> 8) & 0xFF;
494 rec->llc |= packed_record[9] << 8;
495
496 rec->mac_sa[0] = packed_record[10];
497 rec->mac_sa[0] |= packed_record[11] << 16;
498
499 rec->mac_sa[1] = packed_record[12];
500
501 rec->mac_da[0] = packed_record[13];
502 rec->mac_da[0] |= packed_record[14] << 16;
503
504 rec->mac_da[1] = packed_record[15];
505
506 rec->lpbk_packet = packed_record[16] & 0x1;
507
508 rec->an_mask = (packed_record[16] >> 1) & 0x3;
509
510 rec->tci_mask = (packed_record[16] >> 3) & 0x3F;
511
512 rec->sci_mask = (packed_record[16] >> 9) & 0x7F;
513 rec->sci_mask |= (packed_record[17] & 0x1) << 7;
514
515 rec->eth_type_mask = (packed_record[17] >> 1) & 0x3;
516
517 rec->snap_mask = (packed_record[17] >> 3) & 0x1F;
518
519 rec->llc_mask = (packed_record[17] >> 8) & 0x7;
520
521 rec->_802_2_encapsulate = (packed_record[17] >> 11) & 0x1;
522
523 rec->sa_mask = (packed_record[17] >> 12) & 0xF;
524 rec->sa_mask |= (packed_record[18] & 0x3) << 4;
525
526 rec->da_mask = (packed_record[18] >> 2) & 0x3F;
527
528 rec->lpbk_mask = (packed_record[18] >> 8) & 0x1;
529
530 rec->sc_idx = (packed_record[18] >> 9) & 0x1F;
531
532 rec->proc_dest = (packed_record[18] >> 14) & 0x1;
533
534 rec->action = (packed_record[18] >> 15) & 0x1;
535 rec->action |= (packed_record[19] & 0x1) << 1;
536
537 rec->ctrl_unctrl = (packed_record[19] >> 1) & 0x1;
538
539 rec->sci_from_table = (packed_record[19] >> 2) & 0x1;
540
541 rec->reserved = (packed_record[19] >> 3) & 0xF;
542
543 rec->valid = (packed_record[19] >> 7) & 0x1;
544
545 return 0;
546}
547
548int aq_mss_get_ingress_preclass_record(struct aq_hw_s *hw,
549 struct aq_mss_ingress_preclass_record *rec,
550 u16 table_index)
551{
552 memset(rec, 0, sizeof(*rec));
553
554 return AQ_API_CALL_SAFE(get_ingress_preclass_record, hw, rec,
555 table_index);
556}
557
558static int set_ingress_sc_record(struct aq_hw_s *hw,
559 const struct aq_mss_ingress_sc_record *rec,
560 u16 table_index)
561{
562 u16 packed_record[8];
563
564 if (table_index >= NUMROWS_INGRESSSCRECORD)
565 return -EINVAL;
566
567 memset(packed_record, 0, sizeof(u16) * 8);
568
569 packed_record[0] = rec->stop_time & 0xFFFF;
570 packed_record[1] = (rec->stop_time >> 16) & 0xFFFF;
571
572 packed_record[2] = rec->start_time & 0xFFFF;
573 packed_record[3] = (rec->start_time >> 16) & 0xFFFF;
574
575 packed_record[4] = rec->validate_frames & 0x3;
576
577 packed_record[4] |= (rec->replay_protect & 0x1) << 2;
578
579 packed_record[4] |= (rec->anti_replay_window & 0x1FFF) << 3;
580 packed_record[5] = (rec->anti_replay_window >> 13) & 0xFFFF;
581 packed_record[6] = (rec->anti_replay_window >> 29) & 0x7;
582
583 packed_record[6] |= (rec->receiving & 0x1) << 3;
584
585 packed_record[6] |= (rec->fresh & 0x1) << 4;
586
587 packed_record[6] |= (rec->an_rol & 0x1) << 5;
588
589 packed_record[6] |= (rec->reserved & 0x3FF) << 6;
590 packed_record[7] = (rec->reserved >> 10) & 0x7FFF;
591
592 packed_record[7] |= (rec->valid & 0x1) << 15;
593
594 return set_raw_ingress_record(hw, packed_record, 8, 3,
595 ROWOFFSET_INGRESSSCRECORD + table_index);
596}
597
598int aq_mss_set_ingress_sc_record(struct aq_hw_s *hw,
599 const struct aq_mss_ingress_sc_record *rec,
600 u16 table_index)
601{
602 int err = AQ_API_CALL_SAFE(set_ingress_sc_record, hw, rec, table_index);
603
604 WARN_ONCE(err, "%s failed with %d\n", __func__, err);
605
606 return err;
607}
608
609static int get_ingress_sc_record(struct aq_hw_s *hw,
610 struct aq_mss_ingress_sc_record *rec,
611 u16 table_index)
612{
613 u16 packed_record[8];
614 int ret;
615
616 if (table_index >= NUMROWS_INGRESSSCRECORD)
617 return -EINVAL;
618
619 ret = get_raw_ingress_record(hw, packed_record, 8, 3,
620 ROWOFFSET_INGRESSSCRECORD + table_index);
621 if (unlikely(ret))
622 return ret;
623
624 rec->stop_time = packed_record[0];
625 rec->stop_time |= packed_record[1] << 16;
626
627 rec->start_time = packed_record[2];
628 rec->start_time |= packed_record[3] << 16;
629
630 rec->validate_frames = packed_record[4] & 0x3;
631
632 rec->replay_protect = (packed_record[4] >> 2) & 0x1;
633
634 rec->anti_replay_window = (packed_record[4] >> 3) & 0x1FFF;
635 rec->anti_replay_window |= packed_record[5] << 13;
636 rec->anti_replay_window |= (packed_record[6] & 0x7) << 29;
637
638 rec->receiving = (packed_record[6] >> 3) & 0x1;
639
640 rec->fresh = (packed_record[6] >> 4) & 0x1;
641
642 rec->an_rol = (packed_record[6] >> 5) & 0x1;
643
644 rec->reserved = (packed_record[6] >> 6) & 0x3FF;
645 rec->reserved |= (packed_record[7] & 0x7FFF) << 10;
646
647 rec->valid = (packed_record[7] >> 15) & 0x1;
648
649 return 0;
650}
651
652int aq_mss_get_ingress_sc_record(struct aq_hw_s *hw,
653 struct aq_mss_ingress_sc_record *rec,
654 u16 table_index)
655{
656 memset(rec, 0, sizeof(*rec));
657
658 return AQ_API_CALL_SAFE(get_ingress_sc_record, hw, rec, table_index);
659}
660
661static int set_ingress_sa_record(struct aq_hw_s *hw,
662 const struct aq_mss_ingress_sa_record *rec,
663 u16 table_index)
664{
665 u16 packed_record[8];
666
667 if (table_index >= NUMROWS_INGRESSSARECORD)
668 return -EINVAL;
669
670 memset(packed_record, 0, sizeof(u16) * 8);
671
672 packed_record[0] = rec->stop_time & 0xFFFF;
673 packed_record[1] = (rec->stop_time >> 16) & 0xFFFF;
674
675 packed_record[2] = rec->start_time & 0xFFFF;
676 packed_record[3] = (rec->start_time >> 16) & 0xFFFF;
677
678 packed_record[4] = rec->next_pn & 0xFFFF;
679 packed_record[5] = (rec->next_pn >> 16) & 0xFFFF;
680
681 packed_record[6] = rec->sat_nextpn & 0x1;
682
683 packed_record[6] |= (rec->in_use & 0x1) << 1;
684
685 packed_record[6] |= (rec->fresh & 0x1) << 2;
686
687 packed_record[6] |= (rec->reserved & 0x1FFF) << 3;
688 packed_record[7] = (rec->reserved >> 13) & 0x7FFF;
689
690 packed_record[7] |= (rec->valid & 0x1) << 15;
691
692 return set_raw_ingress_record(hw, packed_record, 8, 3,
693 ROWOFFSET_INGRESSSARECORD + table_index);
694}
695
696int aq_mss_set_ingress_sa_record(struct aq_hw_s *hw,
697 const struct aq_mss_ingress_sa_record *rec,
698 u16 table_index)
699{
700 int err = AQ_API_CALL_SAFE(set_ingress_sa_record, hw, rec, table_index);
701
702 WARN_ONCE(err, "%s failed with %d\n", __func__, err);
703
704 return err;
705}
706
707static int get_ingress_sa_record(struct aq_hw_s *hw,
708 struct aq_mss_ingress_sa_record *rec,
709 u16 table_index)
710{
711 u16 packed_record[8];
712 int ret;
713
714 if (table_index >= NUMROWS_INGRESSSARECORD)
715 return -EINVAL;
716
717 ret = get_raw_ingress_record(hw, packed_record, 8, 3,
718 ROWOFFSET_INGRESSSARECORD + table_index);
719 if (unlikely(ret))
720 return ret;
721
722 rec->stop_time = packed_record[0];
723 rec->stop_time |= packed_record[1] << 16;
724
725 rec->start_time = packed_record[2];
726 rec->start_time |= packed_record[3] << 16;
727
728 rec->next_pn = packed_record[4];
729 rec->next_pn |= packed_record[5] << 16;
730
731 rec->sat_nextpn = packed_record[6] & 0x1;
732
733 rec->in_use = (packed_record[6] >> 1) & 0x1;
734
735 rec->fresh = (packed_record[6] >> 2) & 0x1;
736
737 rec->reserved = (packed_record[6] >> 3) & 0x1FFF;
738 rec->reserved |= (packed_record[7] & 0x7FFF) << 13;
739
740 rec->valid = (packed_record[7] >> 15) & 0x1;
741
742 return 0;
743}
744
745int aq_mss_get_ingress_sa_record(struct aq_hw_s *hw,
746 struct aq_mss_ingress_sa_record *rec,
747 u16 table_index)
748{
749 memset(rec, 0, sizeof(*rec));
750
751 return AQ_API_CALL_SAFE(get_ingress_sa_record, hw, rec, table_index);
752}
753
754static int
755set_ingress_sakey_record(struct aq_hw_s *hw,
756 const struct aq_mss_ingress_sakey_record *rec,
757 u16 table_index)
758{
759 u16 packed_record[18];
760 int ret;
761
762 if (table_index >= NUMROWS_INGRESSSAKEYRECORD)
763 return -EINVAL;
764
765 memset(packed_record, 0, sizeof(u16) * 18);
766
767 packed_record[0] = rec->key[0] & 0xFFFF;
768 packed_record[1] = (rec->key[0] >> 16) & 0xFFFF;
769
770 packed_record[2] = rec->key[1] & 0xFFFF;
771 packed_record[3] = (rec->key[1] >> 16) & 0xFFFF;
772
773 packed_record[4] = rec->key[2] & 0xFFFF;
774 packed_record[5] = (rec->key[2] >> 16) & 0xFFFF;
775
776 packed_record[6] = rec->key[3] & 0xFFFF;
777 packed_record[7] = (rec->key[3] >> 16) & 0xFFFF;
778
779 packed_record[8] = rec->key[4] & 0xFFFF;
780 packed_record[9] = (rec->key[4] >> 16) & 0xFFFF;
781
782 packed_record[10] = rec->key[5] & 0xFFFF;
783 packed_record[11] = (rec->key[5] >> 16) & 0xFFFF;
784
785 packed_record[12] = rec->key[6] & 0xFFFF;
786 packed_record[13] = (rec->key[6] >> 16) & 0xFFFF;
787
788 packed_record[14] = rec->key[7] & 0xFFFF;
789 packed_record[15] = (rec->key[7] >> 16) & 0xFFFF;
790
791 packed_record[16] = rec->key_len & 0x3;
792
793 ret = set_raw_ingress_record(hw, packed_record, 18, 2,
794 ROWOFFSET_INGRESSSAKEYRECORD +
795 table_index);
796
797 memzero_explicit(packed_record, sizeof(packed_record));
798 return ret;
799}
800
801int aq_mss_set_ingress_sakey_record(struct aq_hw_s *hw,
802 const struct aq_mss_ingress_sakey_record *rec,
803 u16 table_index)
804{
805 int err = AQ_API_CALL_SAFE(set_ingress_sakey_record, hw, rec,
806 table_index);
807
808 WARN_ONCE(err, "%s failed with %d\n", __func__, err);
809
810 return err;
811}
812
813static int get_ingress_sakey_record(struct aq_hw_s *hw,
814 struct aq_mss_ingress_sakey_record *rec,
815 u16 table_index)
816{
817 u16 packed_record[18];
818 int ret;
819
820 if (table_index >= NUMROWS_INGRESSSAKEYRECORD)
821 return -EINVAL;
822
823 ret = get_raw_ingress_record(hw, packed_record, 18, 2,
824 ROWOFFSET_INGRESSSAKEYRECORD +
825 table_index);
826 if (unlikely(ret))
827 return ret;
828
829 rec->key[0] = packed_record[0];
830 rec->key[0] |= packed_record[1] << 16;
831
832 rec->key[1] = packed_record[2];
833 rec->key[1] |= packed_record[3] << 16;
834
835 rec->key[2] = packed_record[4];
836 rec->key[2] |= packed_record[5] << 16;
837
838 rec->key[3] = packed_record[6];
839 rec->key[3] |= packed_record[7] << 16;
840
841 rec->key[4] = packed_record[8];
842 rec->key[4] |= packed_record[9] << 16;
843
844 rec->key[5] = packed_record[10];
845 rec->key[5] |= packed_record[11] << 16;
846
847 rec->key[6] = packed_record[12];
848 rec->key[6] |= packed_record[13] << 16;
849
850 rec->key[7] = packed_record[14];
851 rec->key[7] |= packed_record[15] << 16;
852
853 rec->key_len = packed_record[16] & 0x3;
854
855 return 0;
856}
857
858int aq_mss_get_ingress_sakey_record(struct aq_hw_s *hw,
859 struct aq_mss_ingress_sakey_record *rec,
860 u16 table_index)
861{
862 memset(rec, 0, sizeof(*rec));
863
864 return AQ_API_CALL_SAFE(get_ingress_sakey_record, hw, rec, table_index);
865}
866
867static int
868set_ingress_postclass_record(struct aq_hw_s *hw,
869 const struct aq_mss_ingress_postclass_record *rec,
870 u16 table_index)
871{
872 u16 packed_record[8];
873
874 if (table_index >= NUMROWS_INGRESSPOSTCLASSRECORD)
875 return -EINVAL;
876
877 memset(packed_record, 0, sizeof(u16) * 8);
878
879 packed_record[0] = rec->byte0 & 0xFF;
880
881 packed_record[0] |= (rec->byte1 & 0xFF) << 8;
882
883 packed_record[1] = rec->byte2 & 0xFF;
884
885 packed_record[1] |= (rec->byte3 & 0xFF) << 8;
886
887 packed_record[2] = rec->eth_type & 0xFFFF;
888
889 packed_record[3] = rec->eth_type_valid & 0x1;
890
891 packed_record[3] |= (rec->vlan_id & 0xFFF) << 1;
892
893 packed_record[3] |= (rec->vlan_up & 0x7) << 13;
894
895 packed_record[4] = rec->vlan_valid & 0x1;
896
897 packed_record[4] |= (rec->sai & 0x1F) << 1;
898
899 packed_record[4] |= (rec->sai_hit & 0x1) << 6;
900
901 packed_record[4] |= (rec->eth_type_mask & 0xF) << 7;
902
903 packed_record[4] |= (rec->byte3_location & 0x1F) << 11;
904 packed_record[5] = (rec->byte3_location >> 5) & 0x1;
905
906 packed_record[5] |= (rec->byte3_mask & 0x3) << 1;
907
908 packed_record[5] |= (rec->byte2_location & 0x3F) << 3;
909
910 packed_record[5] |= (rec->byte2_mask & 0x3) << 9;
911
912 packed_record[5] |= (rec->byte1_location & 0x1F) << 11;
913 packed_record[6] = (rec->byte1_location >> 5) & 0x1;
914
915 packed_record[6] |= (rec->byte1_mask & 0x3) << 1;
916
917 packed_record[6] |= (rec->byte0_location & 0x3F) << 3;
918
919 packed_record[6] |= (rec->byte0_mask & 0x3) << 9;
920
921 packed_record[6] |= (rec->eth_type_valid_mask & 0x3) << 11;
922
923 packed_record[6] |= (rec->vlan_id_mask & 0x7) << 13;
924 packed_record[7] = (rec->vlan_id_mask >> 3) & 0x1;
925
926 packed_record[7] |= (rec->vlan_up_mask & 0x3) << 1;
927
928 packed_record[7] |= (rec->vlan_valid_mask & 0x3) << 3;
929
930 packed_record[7] |= (rec->sai_mask & 0x3) << 5;
931
932 packed_record[7] |= (rec->sai_hit_mask & 0x3) << 7;
933
934 packed_record[7] |= (rec->firstlevel_actions & 0x1) << 9;
935
936 packed_record[7] |= (rec->secondlevel_actions & 0x1) << 10;
937
938 packed_record[7] |= (rec->reserved & 0xF) << 11;
939
940 packed_record[7] |= (rec->valid & 0x1) << 15;
941
942 return set_raw_ingress_record(hw, packed_record, 8, 4,
943 ROWOFFSET_INGRESSPOSTCLASSRECORD +
944 table_index);
945}
946
947int aq_mss_set_ingress_postclass_record(struct aq_hw_s *hw,
948 const struct aq_mss_ingress_postclass_record *rec,
949 u16 table_index)
950{
951 return AQ_API_CALL_SAFE(set_ingress_postclass_record, hw, rec,
952 table_index);
953}
954
955static int
956get_ingress_postclass_record(struct aq_hw_s *hw,
957 struct aq_mss_ingress_postclass_record *rec,
958 u16 table_index)
959{
960 u16 packed_record[8];
961 int ret;
962
963 if (table_index >= NUMROWS_INGRESSPOSTCLASSRECORD)
964 return -EINVAL;
965
966 /* If the row that we want to read is odd, first read the previous even
967 * row, throw that value away, and finally read the desired row.
968 */
969 if ((table_index % 2) > 0) {
970 ret = get_raw_ingress_record(hw, packed_record, 8, 4,
971 ROWOFFSET_INGRESSPOSTCLASSRECORD +
972 table_index - 1);
973 if (unlikely(ret))
974 return ret;
975 }
976
977 ret = get_raw_ingress_record(hw, packed_record, 8, 4,
978 ROWOFFSET_INGRESSPOSTCLASSRECORD +
979 table_index);
980 if (unlikely(ret))
981 return ret;
982
983 rec->byte0 = packed_record[0] & 0xFF;
984
985 rec->byte1 = (packed_record[0] >> 8) & 0xFF;
986
987 rec->byte2 = packed_record[1] & 0xFF;
988
989 rec->byte3 = (packed_record[1] >> 8) & 0xFF;
990
991 rec->eth_type = packed_record[2];
992
993 rec->eth_type_valid = packed_record[3] & 0x1;
994
995 rec->vlan_id = (packed_record[3] >> 1) & 0xFFF;
996
997 rec->vlan_up = (packed_record[3] >> 13) & 0x7;
998
999 rec->vlan_valid = packed_record[4] & 0x1;
1000
1001 rec->sai = (packed_record[4] >> 1) & 0x1F;
1002
1003 rec->sai_hit = (packed_record[4] >> 6) & 0x1;
1004
1005 rec->eth_type_mask = (packed_record[4] >> 7) & 0xF;
1006
1007 rec->byte3_location = (packed_record[4] >> 11) & 0x1F;
1008 rec->byte3_location |= (packed_record[5] & 0x1) << 5;
1009
1010 rec->byte3_mask = (packed_record[5] >> 1) & 0x3;
1011
1012 rec->byte2_location = (packed_record[5] >> 3) & 0x3F;
1013
1014 rec->byte2_mask = (packed_record[5] >> 9) & 0x3;
1015
1016 rec->byte1_location = (packed_record[5] >> 11) & 0x1F;
1017 rec->byte1_location |= (packed_record[6] & 0x1) << 5;
1018
1019 rec->byte1_mask = (packed_record[6] >> 1) & 0x3;
1020
1021 rec->byte0_location = (packed_record[6] >> 3) & 0x3F;
1022
1023 rec->byte0_mask = (packed_record[6] >> 9) & 0x3;
1024
1025 rec->eth_type_valid_mask = (packed_record[6] >> 11) & 0x3;
1026
1027 rec->vlan_id_mask = (packed_record[6] >> 13) & 0x7;
1028 rec->vlan_id_mask |= (packed_record[7] & 0x1) << 3;
1029
1030 rec->vlan_up_mask = (packed_record[7] >> 1) & 0x3;
1031
1032 rec->vlan_valid_mask = (packed_record[7] >> 3) & 0x3;
1033
1034 rec->sai_mask = (packed_record[7] >> 5) & 0x3;
1035
1036 rec->sai_hit_mask = (packed_record[7] >> 7) & 0x3;
1037
1038 rec->firstlevel_actions = (packed_record[7] >> 9) & 0x1;
1039
1040 rec->secondlevel_actions = (packed_record[7] >> 10) & 0x1;
1041
1042 rec->reserved = (packed_record[7] >> 11) & 0xF;
1043
1044 rec->valid = (packed_record[7] >> 15) & 0x1;
1045
1046 return 0;
1047}
1048
1049int aq_mss_get_ingress_postclass_record(struct aq_hw_s *hw,
1050 struct aq_mss_ingress_postclass_record *rec,
1051 u16 table_index)
1052{
1053 memset(rec, 0, sizeof(*rec));
1054
1055 return AQ_API_CALL_SAFE(get_ingress_postclass_record, hw, rec,
1056 table_index);
1057}
1058
1059static int
1060set_ingress_postctlf_record(struct aq_hw_s *hw,
1061 const struct aq_mss_ingress_postctlf_record *rec,
1062 u16 table_index)
1063{
1064 u16 packed_record[6];
1065
1066 if (table_index >= NUMROWS_INGRESSPOSTCTLFRECORD)
1067 return -EINVAL;
1068
1069 memset(packed_record, 0, sizeof(u16) * 6);
1070
1071 packed_record[0] = rec->sa_da[0] & 0xFFFF;
1072 packed_record[1] = (rec->sa_da[0] >> 16) & 0xFFFF;
1073
1074 packed_record[2] = rec->sa_da[1] & 0xFFFF;
1075
1076 packed_record[3] = rec->eth_type & 0xFFFF;
1077
1078 packed_record[4] = rec->match_mask & 0xFFFF;
1079
1080 packed_record[5] = rec->match_type & 0xF;
1081
1082 packed_record[5] |= (rec->action & 0x1) << 4;
1083
1084 return set_raw_ingress_record(hw, packed_record, 6, 5,
1085 ROWOFFSET_INGRESSPOSTCTLFRECORD +
1086 table_index);
1087}
1088
1089int aq_mss_set_ingress_postctlf_record(struct aq_hw_s *hw,
1090 const struct aq_mss_ingress_postctlf_record *rec,
1091 u16 table_index)
1092{
1093 return AQ_API_CALL_SAFE(set_ingress_postctlf_record, hw, rec,
1094 table_index);
1095}
1096
1097static int
1098get_ingress_postctlf_record(struct aq_hw_s *hw,
1099 struct aq_mss_ingress_postctlf_record *rec,
1100 u16 table_index)
1101{
1102 u16 packed_record[6];
1103 int ret;
1104
1105 if (table_index >= NUMROWS_INGRESSPOSTCTLFRECORD)
1106 return -EINVAL;
1107
1108 /* If the row that we want to read is odd, first read the previous even
1109 * row, throw that value away, and finally read the desired row.
1110 */
1111 if ((table_index % 2) > 0) {
1112 ret = get_raw_ingress_record(hw, packed_record, 6, 5,
1113 ROWOFFSET_INGRESSPOSTCTLFRECORD +
1114 table_index - 1);
1115 if (unlikely(ret))
1116 return ret;
1117 }
1118
1119 ret = get_raw_ingress_record(hw, packed_record, 6, 5,
1120 ROWOFFSET_INGRESSPOSTCTLFRECORD +
1121 table_index);
1122 if (unlikely(ret))
1123 return ret;
1124
1125 rec->sa_da[0] = packed_record[0];
1126 rec->sa_da[0] |= packed_record[1] << 16;
1127
1128 rec->sa_da[1] = packed_record[2];
1129
1130 rec->eth_type = packed_record[3];
1131
1132 rec->match_mask = packed_record[4];
1133
1134 rec->match_type = packed_record[5] & 0xF;
1135
1136 rec->action = (packed_record[5] >> 4) & 0x1;
1137
1138 return 0;
1139}
1140
1141int aq_mss_get_ingress_postctlf_record(struct aq_hw_s *hw,
1142 struct aq_mss_ingress_postctlf_record *rec,
1143 u16 table_index)
1144{
1145 memset(rec, 0, sizeof(*rec));
1146
1147 return AQ_API_CALL_SAFE(get_ingress_postctlf_record, hw, rec,
1148 table_index);
1149}
1150
1151static int set_egress_ctlf_record(struct aq_hw_s *hw,
1152 const struct aq_mss_egress_ctlf_record *rec,
1153 u16 table_index)
1154{
1155 u16 packed_record[6];
1156
1157 if (table_index >= NUMROWS_EGRESSCTLFRECORD)
1158 return -EINVAL;
1159
1160 memset(packed_record, 0, sizeof(u16) * 6);
1161
1162 packed_record[0] = rec->sa_da[0] & 0xFFFF;
1163 packed_record[1] = (rec->sa_da[0] >> 16) & 0xFFFF;
1164
1165 packed_record[2] = rec->sa_da[1] & 0xFFFF;
1166
1167 packed_record[3] = rec->eth_type & 0xFFFF;
1168
1169 packed_record[4] = rec->match_mask & 0xFFFF;
1170
1171 packed_record[5] = rec->match_type & 0xF;
1172
1173 packed_record[5] |= (rec->action & 0x1) << 4;
1174
1175 return set_raw_egress_record(hw, packed_record, 6, 0,
1176 ROWOFFSET_EGRESSCTLFRECORD + table_index);
1177}
1178
1179int aq_mss_set_egress_ctlf_record(struct aq_hw_s *hw,
1180 const struct aq_mss_egress_ctlf_record *rec,
1181 u16 table_index)
1182{
1183 return AQ_API_CALL_SAFE(set_egress_ctlf_record, hw, rec, table_index);
1184}
1185
1186static int get_egress_ctlf_record(struct aq_hw_s *hw,
1187 struct aq_mss_egress_ctlf_record *rec,
1188 u16 table_index)
1189{
1190 u16 packed_record[6];
1191 int ret;
1192
1193 if (table_index >= NUMROWS_EGRESSCTLFRECORD)
1194 return -EINVAL;
1195
1196 /* If the row that we want to read is odd, first read the previous even
1197 * row, throw that value away, and finally read the desired row.
1198 */
1199 if ((table_index % 2) > 0) {
1200 ret = get_raw_egress_record(hw, packed_record, 6, 0,
1201 ROWOFFSET_EGRESSCTLFRECORD +
1202 table_index - 1);
1203 if (unlikely(ret))
1204 return ret;
1205 }
1206
1207 ret = get_raw_egress_record(hw, packed_record, 6, 0,
1208 ROWOFFSET_EGRESSCTLFRECORD + table_index);
1209 if (unlikely(ret))
1210 return ret;
1211
1212 rec->sa_da[0] = packed_record[0];
1213 rec->sa_da[0] |= packed_record[1] << 16;
1214
1215 rec->sa_da[1] = packed_record[2];
1216
1217 rec->eth_type = packed_record[3];
1218
1219 rec->match_mask = packed_record[4];
1220
1221 rec->match_type = packed_record[5] & 0xF;
1222
1223 rec->action = (packed_record[5] >> 4) & 0x1;
1224
1225 return 0;
1226}
1227
1228int aq_mss_get_egress_ctlf_record(struct aq_hw_s *hw,
1229 struct aq_mss_egress_ctlf_record *rec,
1230 u16 table_index)
1231{
1232 memset(rec, 0, sizeof(*rec));
1233
1234 return AQ_API_CALL_SAFE(get_egress_ctlf_record, hw, rec, table_index);
1235}
1236
1237static int set_egress_class_record(struct aq_hw_s *hw,
1238 const struct aq_mss_egress_class_record *rec,
1239 u16 table_index)
1240{
1241 u16 packed_record[28];
1242
1243 if (table_index >= NUMROWS_EGRESSCLASSRECORD)
1244 return -EINVAL;
1245
1246 memset(packed_record, 0, sizeof(u16) * 28);
1247
1248 packed_record[0] = rec->vlan_id & 0xFFF;
1249
1250 packed_record[0] |= (rec->vlan_up & 0x7) << 12;
1251
1252 packed_record[0] |= (rec->vlan_valid & 0x1) << 15;
1253
1254 packed_record[1] = rec->byte3 & 0xFF;
1255
1256 packed_record[1] |= (rec->byte2 & 0xFF) << 8;
1257
1258 packed_record[2] = rec->byte1 & 0xFF;
1259
1260 packed_record[2] |= (rec->byte0 & 0xFF) << 8;
1261
1262 packed_record[3] = rec->tci & 0xFF;
1263
1264 packed_record[3] |= (rec->sci[0] & 0xFF) << 8;
1265 packed_record[4] = (rec->sci[0] >> 8) & 0xFFFF;
1266 packed_record[5] = (rec->sci[0] >> 24) & 0xFF;
1267
1268 packed_record[5] |= (rec->sci[1] & 0xFF) << 8;
1269 packed_record[6] = (rec->sci[1] >> 8) & 0xFFFF;
1270 packed_record[7] = (rec->sci[1] >> 24) & 0xFF;
1271
1272 packed_record[7] |= (rec->eth_type & 0xFF) << 8;
1273 packed_record[8] = (rec->eth_type >> 8) & 0xFF;
1274
1275 packed_record[8] |= (rec->snap[0] & 0xFF) << 8;
1276 packed_record[9] = (rec->snap[0] >> 8) & 0xFFFF;
1277 packed_record[10] = (rec->snap[0] >> 24) & 0xFF;
1278
1279 packed_record[10] |= (rec->snap[1] & 0xFF) << 8;
1280
1281 packed_record[11] = rec->llc & 0xFFFF;
1282 packed_record[12] = (rec->llc >> 16) & 0xFF;
1283
1284 packed_record[12] |= (rec->mac_sa[0] & 0xFF) << 8;
1285 packed_record[13] = (rec->mac_sa[0] >> 8) & 0xFFFF;
1286 packed_record[14] = (rec->mac_sa[0] >> 24) & 0xFF;
1287
1288 packed_record[14] |= (rec->mac_sa[1] & 0xFF) << 8;
1289 packed_record[15] = (rec->mac_sa[1] >> 8) & 0xFF;
1290
1291 packed_record[15] |= (rec->mac_da[0] & 0xFF) << 8;
1292 packed_record[16] = (rec->mac_da[0] >> 8) & 0xFFFF;
1293 packed_record[17] = (rec->mac_da[0] >> 24) & 0xFF;
1294
1295 packed_record[17] |= (rec->mac_da[1] & 0xFF) << 8;
1296 packed_record[18] = (rec->mac_da[1] >> 8) & 0xFF;
1297
1298 packed_record[18] |= (rec->pn & 0xFF) << 8;
1299 packed_record[19] = (rec->pn >> 8) & 0xFFFF;
1300 packed_record[20] = (rec->pn >> 24) & 0xFF;
1301
1302 packed_record[20] |= (rec->byte3_location & 0x3F) << 8;
1303
1304 packed_record[20] |= (rec->byte3_mask & 0x1) << 14;
1305
1306 packed_record[20] |= (rec->byte2_location & 0x1) << 15;
1307 packed_record[21] = (rec->byte2_location >> 1) & 0x1F;
1308
1309 packed_record[21] |= (rec->byte2_mask & 0x1) << 5;
1310
1311 packed_record[21] |= (rec->byte1_location & 0x3F) << 6;
1312
1313 packed_record[21] |= (rec->byte1_mask & 0x1) << 12;
1314
1315 packed_record[21] |= (rec->byte0_location & 0x7) << 13;
1316 packed_record[22] = (rec->byte0_location >> 3) & 0x7;
1317
1318 packed_record[22] |= (rec->byte0_mask & 0x1) << 3;
1319
1320 packed_record[22] |= (rec->vlan_id_mask & 0x3) << 4;
1321
1322 packed_record[22] |= (rec->vlan_up_mask & 0x1) << 6;
1323
1324 packed_record[22] |= (rec->vlan_valid_mask & 0x1) << 7;
1325
1326 packed_record[22] |= (rec->tci_mask & 0xFF) << 8;
1327
1328 packed_record[23] = rec->sci_mask & 0xFF;
1329
1330 packed_record[23] |= (rec->eth_type_mask & 0x3) << 8;
1331
1332 packed_record[23] |= (rec->snap_mask & 0x1F) << 10;
1333
1334 packed_record[23] |= (rec->llc_mask & 0x1) << 15;
1335 packed_record[24] = (rec->llc_mask >> 1) & 0x3;
1336
1337 packed_record[24] |= (rec->sa_mask & 0x3F) << 2;
1338
1339 packed_record[24] |= (rec->da_mask & 0x3F) << 8;
1340
1341 packed_record[24] |= (rec->pn_mask & 0x3) << 14;
1342 packed_record[25] = (rec->pn_mask >> 2) & 0x3;
1343
1344 packed_record[25] |= (rec->eight02dot2 & 0x1) << 2;
1345
1346 packed_record[25] |= (rec->tci_sc & 0x1) << 3;
1347
1348 packed_record[25] |= (rec->tci_87543 & 0x1) << 4;
1349
1350 packed_record[25] |= (rec->exp_sectag_en & 0x1) << 5;
1351
1352 packed_record[25] |= (rec->sc_idx & 0x1F) << 6;
1353
1354 packed_record[25] |= (rec->sc_sa & 0x3) << 11;
1355
1356 packed_record[25] |= (rec->debug & 0x1) << 13;
1357
1358 packed_record[25] |= (rec->action & 0x3) << 14;
1359
1360 packed_record[26] = (rec->valid & 0x1) << 3;
1361
1362 return set_raw_egress_record(hw, packed_record, 28, 1,
1363 ROWOFFSET_EGRESSCLASSRECORD + table_index);
1364}
1365
1366int aq_mss_set_egress_class_record(struct aq_hw_s *hw,
1367 const struct aq_mss_egress_class_record *rec,
1368 u16 table_index)
1369{
1370 return AQ_API_CALL_SAFE(set_egress_class_record, hw, rec, table_index);
1371}
1372
1373static int get_egress_class_record(struct aq_hw_s *hw,
1374 struct aq_mss_egress_class_record *rec,
1375 u16 table_index)
1376{
1377 u16 packed_record[28];
1378 int ret;
1379
1380 if (table_index >= NUMROWS_EGRESSCLASSRECORD)
1381 return -EINVAL;
1382
1383 /* If the row that we want to read is odd, first read the previous even
1384 * row, throw that value away, and finally read the desired row.
1385 */
1386 if ((table_index % 2) > 0) {
1387 ret = get_raw_egress_record(hw, packed_record, 28, 1,
1388 ROWOFFSET_EGRESSCLASSRECORD +
1389 table_index - 1);
1390 if (unlikely(ret))
1391 return ret;
1392 }
1393
1394 ret = get_raw_egress_record(hw, packed_record, 28, 1,
1395 ROWOFFSET_EGRESSCLASSRECORD + table_index);
1396 if (unlikely(ret))
1397 return ret;
1398
1399 rec->vlan_id = packed_record[0] & 0xFFF;
1400
1401 rec->vlan_up = (packed_record[0] >> 12) & 0x7;
1402
1403 rec->vlan_valid = (packed_record[0] >> 15) & 0x1;
1404
1405 rec->byte3 = packed_record[1] & 0xFF;
1406
1407 rec->byte2 = (packed_record[1] >> 8) & 0xFF;
1408
1409 rec->byte1 = packed_record[2] & 0xFF;
1410
1411 rec->byte0 = (packed_record[2] >> 8) & 0xFF;
1412
1413 rec->tci = packed_record[3] & 0xFF;
1414
1415 rec->sci[0] = (packed_record[3] >> 8) & 0xFF;
1416 rec->sci[0] |= packed_record[4] << 8;
1417 rec->sci[0] |= (packed_record[5] & 0xFF) << 24;
1418
1419 rec->sci[1] = (packed_record[5] >> 8) & 0xFF;
1420 rec->sci[1] |= packed_record[6] << 8;
1421 rec->sci[1] |= (packed_record[7] & 0xFF) << 24;
1422
1423 rec->eth_type = (packed_record[7] >> 8) & 0xFF;
1424 rec->eth_type |= (packed_record[8] & 0xFF) << 8;
1425
1426 rec->snap[0] = (packed_record[8] >> 8) & 0xFF;
1427 rec->snap[0] |= packed_record[9] << 8;
1428 rec->snap[0] |= (packed_record[10] & 0xFF) << 24;
1429
1430 rec->snap[1] = (packed_record[10] >> 8) & 0xFF;
1431
1432 rec->llc = packed_record[11];
1433 rec->llc |= (packed_record[12] & 0xFF) << 16;
1434
1435 rec->mac_sa[0] = (packed_record[12] >> 8) & 0xFF;
1436 rec->mac_sa[0] |= packed_record[13] << 8;
1437 rec->mac_sa[0] |= (packed_record[14] & 0xFF) << 24;
1438
1439 rec->mac_sa[1] = (packed_record[14] >> 8) & 0xFF;
1440 rec->mac_sa[1] |= (packed_record[15] & 0xFF) << 8;
1441
1442 rec->mac_da[0] = (packed_record[15] >> 8) & 0xFF;
1443 rec->mac_da[0] |= packed_record[16] << 8;
1444 rec->mac_da[0] |= (packed_record[17] & 0xFF) << 24;
1445
1446 rec->mac_da[1] = (packed_record[17] >> 8) & 0xFF;
1447 rec->mac_da[1] |= (packed_record[18] & 0xFF) << 8;
1448
1449 rec->pn = (packed_record[18] >> 8) & 0xFF;
1450 rec->pn |= packed_record[19] << 8;
1451 rec->pn |= (packed_record[20] & 0xFF) << 24;
1452
1453 rec->byte3_location = (packed_record[20] >> 8) & 0x3F;
1454
1455 rec->byte3_mask = (packed_record[20] >> 14) & 0x1;
1456
1457 rec->byte2_location = (packed_record[20] >> 15) & 0x1;
1458 rec->byte2_location |= (packed_record[21] & 0x1F) << 1;
1459
1460 rec->byte2_mask = (packed_record[21] >> 5) & 0x1;
1461
1462 rec->byte1_location = (packed_record[21] >> 6) & 0x3F;
1463
1464 rec->byte1_mask = (packed_record[21] >> 12) & 0x1;
1465
1466 rec->byte0_location = (packed_record[21] >> 13) & 0x7;
1467 rec->byte0_location |= (packed_record[22] & 0x7) << 3;
1468
1469 rec->byte0_mask = (packed_record[22] >> 3) & 0x1;
1470
1471 rec->vlan_id_mask = (packed_record[22] >> 4) & 0x3;
1472
1473 rec->vlan_up_mask = (packed_record[22] >> 6) & 0x1;
1474
1475 rec->vlan_valid_mask = (packed_record[22] >> 7) & 0x1;
1476
1477 rec->tci_mask = (packed_record[22] >> 8) & 0xFF;
1478
1479 rec->sci_mask = packed_record[23] & 0xFF;
1480
1481 rec->eth_type_mask = (packed_record[23] >> 8) & 0x3;
1482
1483 rec->snap_mask = (packed_record[23] >> 10) & 0x1F;
1484
1485 rec->llc_mask = (packed_record[23] >> 15) & 0x1;
1486 rec->llc_mask |= (packed_record[24] & 0x3) << 1;
1487
1488 rec->sa_mask = (packed_record[24] >> 2) & 0x3F;
1489
1490 rec->da_mask = (packed_record[24] >> 8) & 0x3F;
1491
1492 rec->pn_mask = (packed_record[24] >> 14) & 0x3;
1493 rec->pn_mask |= (packed_record[25] & 0x3) << 2;
1494
1495 rec->eight02dot2 = (packed_record[25] >> 2) & 0x1;
1496
1497 rec->tci_sc = (packed_record[25] >> 3) & 0x1;
1498
1499 rec->tci_87543 = (packed_record[25] >> 4) & 0x1;
1500
1501 rec->exp_sectag_en = (packed_record[25] >> 5) & 0x1;
1502
1503 rec->sc_idx = (packed_record[25] >> 6) & 0x1F;
1504
1505 rec->sc_sa = (packed_record[25] >> 11) & 0x3;
1506
1507 rec->debug = (packed_record[25] >> 13) & 0x1;
1508
1509 rec->action = (packed_record[25] >> 14) & 0x3;
1510
1511 rec->valid = (packed_record[26] >> 3) & 0x1;
1512
1513 return 0;
1514}
1515
1516int aq_mss_get_egress_class_record(struct aq_hw_s *hw,
1517 struct aq_mss_egress_class_record *rec,
1518 u16 table_index)
1519{
1520 memset(rec, 0, sizeof(*rec));
1521
1522 return AQ_API_CALL_SAFE(get_egress_class_record, hw, rec, table_index);
1523}
1524
1525static int set_egress_sc_record(struct aq_hw_s *hw,
1526 const struct aq_mss_egress_sc_record *rec,
1527 u16 table_index)
1528{
1529 u16 packed_record[8];
1530
1531 if (table_index >= NUMROWS_EGRESSSCRECORD)
1532 return -EINVAL;
1533
1534 memset(packed_record, 0, sizeof(u16) * 8);
1535
1536 packed_record[0] = rec->start_time & 0xFFFF;
1537 packed_record[1] = (rec->start_time >> 16) & 0xFFFF;
1538
1539 packed_record[2] = rec->stop_time & 0xFFFF;
1540 packed_record[3] = (rec->stop_time >> 16) & 0xFFFF;
1541
1542 packed_record[4] = rec->curr_an & 0x3;
1543
1544 packed_record[4] |= (rec->an_roll & 0x1) << 2;
1545
1546 packed_record[4] |= (rec->tci & 0x3F) << 3;
1547
1548 packed_record[4] |= (rec->enc_off & 0x7F) << 9;
1549 packed_record[5] = (rec->enc_off >> 7) & 0x1;
1550
1551 packed_record[5] |= (rec->protect & 0x1) << 1;
1552
1553 packed_record[5] |= (rec->recv & 0x1) << 2;
1554
1555 packed_record[5] |= (rec->fresh & 0x1) << 3;
1556
1557 packed_record[5] |= (rec->sak_len & 0x3) << 4;
1558
1559 packed_record[7] = (rec->valid & 0x1) << 15;
1560
1561 return set_raw_egress_record(hw, packed_record, 8, 2,
1562 ROWOFFSET_EGRESSSCRECORD + table_index);
1563}
1564
1565int aq_mss_set_egress_sc_record(struct aq_hw_s *hw,
1566 const struct aq_mss_egress_sc_record *rec,
1567 u16 table_index)
1568{
1569 return AQ_API_CALL_SAFE(set_egress_sc_record, hw, rec, table_index);
1570}
1571
1572static int get_egress_sc_record(struct aq_hw_s *hw,
1573 struct aq_mss_egress_sc_record *rec,
1574 u16 table_index)
1575{
1576 u16 packed_record[8];
1577 int ret;
1578
1579 if (table_index >= NUMROWS_EGRESSSCRECORD)
1580 return -EINVAL;
1581
1582 ret = get_raw_egress_record(hw, packed_record, 8, 2,
1583 ROWOFFSET_EGRESSSCRECORD + table_index);
1584 if (unlikely(ret))
1585 return ret;
1586
1587 rec->start_time = packed_record[0];
1588 rec->start_time |= packed_record[1] << 16;
1589
1590 rec->stop_time = packed_record[2];
1591 rec->stop_time |= packed_record[3] << 16;
1592
1593 rec->curr_an = packed_record[4] & 0x3;
1594
1595 rec->an_roll = (packed_record[4] >> 2) & 0x1;
1596
1597 rec->tci = (packed_record[4] >> 3) & 0x3F;
1598
1599 rec->enc_off = (packed_record[4] >> 9) & 0x7F;
1600 rec->enc_off |= (packed_record[5] & 0x1) << 7;
1601
1602 rec->protect = (packed_record[5] >> 1) & 0x1;
1603
1604 rec->recv = (packed_record[5] >> 2) & 0x1;
1605
1606 rec->fresh = (packed_record[5] >> 3) & 0x1;
1607
1608 rec->sak_len = (packed_record[5] >> 4) & 0x3;
1609
1610 rec->valid = (packed_record[7] >> 15) & 0x1;
1611
1612 return 0;
1613}
1614
1615int aq_mss_get_egress_sc_record(struct aq_hw_s *hw,
1616 struct aq_mss_egress_sc_record *rec,
1617 u16 table_index)
1618{
1619 memset(rec, 0, sizeof(*rec));
1620
1621 return AQ_API_CALL_SAFE(get_egress_sc_record, hw, rec, table_index);
1622}
1623
1624static int set_egress_sa_record(struct aq_hw_s *hw,
1625 const struct aq_mss_egress_sa_record *rec,
1626 u16 table_index)
1627{
1628 u16 packed_record[8];
1629
1630 if (table_index >= NUMROWS_EGRESSSARECORD)
1631 return -EINVAL;
1632
1633 memset(packed_record, 0, sizeof(u16) * 8);
1634
1635 packed_record[0] = rec->start_time & 0xFFFF;
1636 packed_record[1] = (rec->start_time >> 16) & 0xFFFF;
1637
1638 packed_record[2] = rec->stop_time & 0xFFFF;
1639 packed_record[3] = (rec->stop_time >> 16) & 0xFFFF;
1640
1641 packed_record[4] = rec->next_pn & 0xFFFF;
1642 packed_record[5] = (rec->next_pn >> 16) & 0xFFFF;
1643
1644 packed_record[6] = rec->sat_pn & 0x1;
1645
1646 packed_record[6] |= (rec->fresh & 0x1) << 1;
1647
1648 packed_record[7] = (rec->valid & 0x1) << 15;
1649
1650 return set_raw_egress_record(hw, packed_record, 8, 2,
1651 ROWOFFSET_EGRESSSARECORD + table_index);
1652}
1653
1654int aq_mss_set_egress_sa_record(struct aq_hw_s *hw,
1655 const struct aq_mss_egress_sa_record *rec,
1656 u16 table_index)
1657{
1658 int err = AQ_API_CALL_SAFE(set_egress_sa_record, hw, rec, table_index);
1659
1660 WARN_ONCE(err, "%s failed with %d\n", __func__, err);
1661
1662 return err;
1663}
1664
1665static int get_egress_sa_record(struct aq_hw_s *hw,
1666 struct aq_mss_egress_sa_record *rec,
1667 u16 table_index)
1668{
1669 u16 packed_record[8];
1670 int ret;
1671
1672 if (table_index >= NUMROWS_EGRESSSARECORD)
1673 return -EINVAL;
1674
1675 ret = get_raw_egress_record(hw, packed_record, 8, 2,
1676 ROWOFFSET_EGRESSSARECORD + table_index);
1677 if (unlikely(ret))
1678 return ret;
1679
1680 rec->start_time = packed_record[0];
1681 rec->start_time |= packed_record[1] << 16;
1682
1683 rec->stop_time = packed_record[2];
1684 rec->stop_time |= packed_record[3] << 16;
1685
1686 rec->next_pn = packed_record[4];
1687 rec->next_pn |= packed_record[5] << 16;
1688
1689 rec->sat_pn = packed_record[6] & 0x1;
1690
1691 rec->fresh = (packed_record[6] >> 1) & 0x1;
1692
1693 rec->valid = (packed_record[7] >> 15) & 0x1;
1694
1695 return 0;
1696}
1697
1698int aq_mss_get_egress_sa_record(struct aq_hw_s *hw,
1699 struct aq_mss_egress_sa_record *rec,
1700 u16 table_index)
1701{
1702 memset(rec, 0, sizeof(*rec));
1703
1704 return AQ_API_CALL_SAFE(get_egress_sa_record, hw, rec, table_index);
1705}
1706
1707static int set_egress_sakey_record(struct aq_hw_s *hw,
1708 const struct aq_mss_egress_sakey_record *rec,
1709 u16 table_index)
1710{
1711 u16 packed_record[16];
1712 int ret;
1713
1714 if (table_index >= NUMROWS_EGRESSSAKEYRECORD)
1715 return -EINVAL;
1716
1717 memset(packed_record, 0, sizeof(u16) * 16);
1718
1719 packed_record[0] = rec->key[0] & 0xFFFF;
1720 packed_record[1] = (rec->key[0] >> 16) & 0xFFFF;
1721
1722 packed_record[2] = rec->key[1] & 0xFFFF;
1723 packed_record[3] = (rec->key[1] >> 16) & 0xFFFF;
1724
1725 packed_record[4] = rec->key[2] & 0xFFFF;
1726 packed_record[5] = (rec->key[2] >> 16) & 0xFFFF;
1727
1728 packed_record[6] = rec->key[3] & 0xFFFF;
1729 packed_record[7] = (rec->key[3] >> 16) & 0xFFFF;
1730
1731 packed_record[8] = rec->key[4] & 0xFFFF;
1732 packed_record[9] = (rec->key[4] >> 16) & 0xFFFF;
1733
1734 packed_record[10] = rec->key[5] & 0xFFFF;
1735 packed_record[11] = (rec->key[5] >> 16) & 0xFFFF;
1736
1737 packed_record[12] = rec->key[6] & 0xFFFF;
1738 packed_record[13] = (rec->key[6] >> 16) & 0xFFFF;
1739
1740 packed_record[14] = rec->key[7] & 0xFFFF;
1741 packed_record[15] = (rec->key[7] >> 16) & 0xFFFF;
1742
1743 ret = set_raw_egress_record(hw, packed_record, 8, 2,
1744 ROWOFFSET_EGRESSSAKEYRECORD + table_index);
1745 if (unlikely(ret))
1746 goto clear_key;
1747 ret = set_raw_egress_record(hw, packed_record + 8, 8, 2,
1748 ROWOFFSET_EGRESSSAKEYRECORD + table_index -
1749 32);
1750
1751clear_key:
1752 memzero_explicit(packed_record, sizeof(packed_record));
1753 return ret;
1754}
1755
1756int aq_mss_set_egress_sakey_record(struct aq_hw_s *hw,
1757 const struct aq_mss_egress_sakey_record *rec,
1758 u16 table_index)
1759{
1760 int err = AQ_API_CALL_SAFE(set_egress_sakey_record, hw, rec,
1761 table_index);
1762
1763 WARN_ONCE(err, "%s failed with %d\n", __func__, err);
1764
1765 return err;
1766}
1767
1768static int get_egress_sakey_record(struct aq_hw_s *hw,
1769 struct aq_mss_egress_sakey_record *rec,
1770 u16 table_index)
1771{
1772 u16 packed_record[16];
1773 int ret;
1774
1775 if (table_index >= NUMROWS_EGRESSSAKEYRECORD)
1776 return -EINVAL;
1777
1778 ret = get_raw_egress_record(hw, packed_record, 8, 2,
1779 ROWOFFSET_EGRESSSAKEYRECORD + table_index);
1780 if (unlikely(ret))
1781 return ret;
1782 ret = get_raw_egress_record(hw, packed_record + 8, 8, 2,
1783 ROWOFFSET_EGRESSSAKEYRECORD + table_index -
1784 32);
1785 if (unlikely(ret))
1786 return ret;
1787
1788 rec->key[0] = packed_record[0];
1789 rec->key[0] |= packed_record[1] << 16;
1790
1791 rec->key[1] = packed_record[2];
1792 rec->key[1] |= packed_record[3] << 16;
1793
1794 rec->key[2] = packed_record[4];
1795 rec->key[2] |= packed_record[5] << 16;
1796
1797 rec->key[3] = packed_record[6];
1798 rec->key[3] |= packed_record[7] << 16;
1799
1800 rec->key[4] = packed_record[8];
1801 rec->key[4] |= packed_record[9] << 16;
1802
1803 rec->key[5] = packed_record[10];
1804 rec->key[5] |= packed_record[11] << 16;
1805
1806 rec->key[6] = packed_record[12];
1807 rec->key[6] |= packed_record[13] << 16;
1808
1809 rec->key[7] = packed_record[14];
1810 rec->key[7] |= packed_record[15] << 16;
1811
1812 return 0;
1813}
1814
1815int aq_mss_get_egress_sakey_record(struct aq_hw_s *hw,
1816 struct aq_mss_egress_sakey_record *rec,
1817 u16 table_index)
1818{
1819 memset(rec, 0, sizeof(*rec));
1820
1821 return AQ_API_CALL_SAFE(get_egress_sakey_record, hw, rec, table_index);
1822}
1823
1824static int get_egress_sc_counters(struct aq_hw_s *hw,
1825 struct aq_mss_egress_sc_counters *counters,
1826 u16 sc_index)
1827{
1828 u16 packed_record[4];
1829 int ret;
1830
1831 if (sc_index >= NUMROWS_EGRESSSCRECORD)
1832 return -EINVAL;
1833
1834 ret = get_raw_egress_record(hw, packed_record, 4, 3, sc_index * 8 + 4);
1835 if (unlikely(ret))
1836 return ret;
1837 counters->sc_protected_pkts[0] =
1838 packed_record[0] | (packed_record[1] << 16);
1839 counters->sc_protected_pkts[1] =
1840 packed_record[2] | (packed_record[3] << 16);
1841
1842 ret = get_raw_egress_record(hw, packed_record, 4, 3, sc_index * 8 + 5);
1843 if (unlikely(ret))
1844 return ret;
1845 counters->sc_encrypted_pkts[0] =
1846 packed_record[0] | (packed_record[1] << 16);
1847 counters->sc_encrypted_pkts[1] =
1848 packed_record[2] | (packed_record[3] << 16);
1849
1850 ret = get_raw_egress_record(hw, packed_record, 4, 3, sc_index * 8 + 6);
1851 if (unlikely(ret))
1852 return ret;
1853 counters->sc_protected_octets[0] =
1854 packed_record[0] | (packed_record[1] << 16);
1855 counters->sc_protected_octets[1] =
1856 packed_record[2] | (packed_record[3] << 16);
1857
1858 ret = get_raw_egress_record(hw, packed_record, 4, 3, sc_index * 8 + 7);
1859 if (unlikely(ret))
1860 return ret;
1861 counters->sc_encrypted_octets[0] =
1862 packed_record[0] | (packed_record[1] << 16);
1863 counters->sc_encrypted_octets[1] =
1864 packed_record[2] | (packed_record[3] << 16);
1865
1866 return 0;
1867}
1868
1869int aq_mss_get_egress_sc_counters(struct aq_hw_s *hw,
1870 struct aq_mss_egress_sc_counters *counters,
1871 u16 sc_index)
1872{
1873 memset(counters, 0, sizeof(*counters));
1874
1875 return AQ_API_CALL_SAFE(get_egress_sc_counters, hw, counters, sc_index);
1876}
1877
1878static int get_egress_sa_counters(struct aq_hw_s *hw,
1879 struct aq_mss_egress_sa_counters *counters,
1880 u16 sa_index)
1881{
1882 u16 packed_record[4];
1883 int ret;
1884
1885 if (sa_index >= NUMROWS_EGRESSSARECORD)
1886 return -EINVAL;
1887
1888 ret = get_raw_egress_record(hw, packed_record, 4, 3, sa_index * 8 + 0);
1889 if (unlikely(ret))
1890 return ret;
1891 counters->sa_hit_drop_redirect[0] =
1892 packed_record[0] | (packed_record[1] << 16);
1893 counters->sa_hit_drop_redirect[1] =
1894 packed_record[2] | (packed_record[3] << 16);
1895
1896 ret = get_raw_egress_record(hw, packed_record, 4, 3, sa_index * 8 + 1);
1897 if (unlikely(ret))
1898 return ret;
1899 counters->sa_protected2_pkts[0] =
1900 packed_record[0] | (packed_record[1] << 16);
1901 counters->sa_protected2_pkts[1] =
1902 packed_record[2] | (packed_record[3] << 16);
1903
1904 ret = get_raw_egress_record(hw, packed_record, 4, 3, sa_index * 8 + 2);
1905 if (unlikely(ret))
1906 return ret;
1907 counters->sa_protected_pkts[0] =
1908 packed_record[0] | (packed_record[1] << 16);
1909 counters->sa_protected_pkts[1] =
1910 packed_record[2] | (packed_record[3] << 16);
1911
1912 ret = get_raw_egress_record(hw, packed_record, 4, 3, sa_index * 8 + 3);
1913 if (unlikely(ret))
1914 return ret;
1915 counters->sa_encrypted_pkts[0] =
1916 packed_record[0] | (packed_record[1] << 16);
1917 counters->sa_encrypted_pkts[1] =
1918 packed_record[2] | (packed_record[3] << 16);
1919
1920 return 0;
1921}
1922
1923int aq_mss_get_egress_sa_counters(struct aq_hw_s *hw,
1924 struct aq_mss_egress_sa_counters *counters,
1925 u16 sa_index)
1926{
1927 memset(counters, 0, sizeof(*counters));
1928
1929 return AQ_API_CALL_SAFE(get_egress_sa_counters, hw, counters, sa_index);
1930}
1931
1932static int
1933get_egress_common_counters(struct aq_hw_s *hw,
1934 struct aq_mss_egress_common_counters *counters)
1935{
1936 u16 packed_record[4];
1937 int ret;
1938
1939 ret = get_raw_egress_record(hw, packed_record, 4, 3, 256 + 0);
1940 if (unlikely(ret))
1941 return ret;
1942 counters->ctl_pkt[0] = packed_record[0] | (packed_record[1] << 16);
1943 counters->ctl_pkt[1] = packed_record[2] | (packed_record[3] << 16);
1944
1945 ret = get_raw_egress_record(hw, packed_record, 4, 3, 256 + 1);
1946 if (unlikely(ret))
1947 return ret;
1948 counters->unknown_sa_pkts[0] =
1949 packed_record[0] | (packed_record[1] << 16);
1950 counters->unknown_sa_pkts[1] =
1951 packed_record[2] | (packed_record[3] << 16);
1952
1953 ret = get_raw_egress_record(hw, packed_record, 4, 3, 256 + 2);
1954 if (unlikely(ret))
1955 return ret;
1956 counters->untagged_pkts[0] =
1957 packed_record[0] | (packed_record[1] << 16);
1958 counters->untagged_pkts[1] =
1959 packed_record[2] | (packed_record[3] << 16);
1960
1961 ret = get_raw_egress_record(hw, packed_record, 4, 3, 256 + 3);
1962 if (unlikely(ret))
1963 return ret;
1964 counters->too_long[0] = packed_record[0] | (packed_record[1] << 16);
1965 counters->too_long[1] = packed_record[2] | (packed_record[3] << 16);
1966
1967 ret = get_raw_egress_record(hw, packed_record, 4, 3, 256 + 4);
1968 if (unlikely(ret))
1969 return ret;
1970 counters->ecc_error_pkts[0] =
1971 packed_record[0] | (packed_record[1] << 16);
1972 counters->ecc_error_pkts[1] =
1973 packed_record[2] | (packed_record[3] << 16);
1974
1975 ret = get_raw_egress_record(hw, packed_record, 4, 3, 256 + 5);
1976 if (unlikely(ret))
1977 return ret;
1978 counters->unctrl_hit_drop_redir[0] =
1979 packed_record[0] | (packed_record[1] << 16);
1980 counters->unctrl_hit_drop_redir[1] =
1981 packed_record[2] | (packed_record[3] << 16);
1982
1983 return 0;
1984}
1985
1986int aq_mss_get_egress_common_counters(struct aq_hw_s *hw,
1987 struct aq_mss_egress_common_counters *counters)
1988{
1989 memset(counters, 0, sizeof(*counters));
1990
1991 return AQ_API_CALL_SAFE(get_egress_common_counters, hw, counters);
1992}
1993
1994static int clear_egress_counters(struct aq_hw_s *hw)
1995{
1996 struct mss_egress_ctl_register ctl_reg;
1997 int ret;
1998
1999 memset(&ctl_reg, 0, sizeof(ctl_reg));
2000
2001 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1, MSS_EGRESS_CTL_REGISTER_ADDR,
2002 &ctl_reg.word_0);
2003 if (unlikely(ret))
2004 return ret;
2005 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1,
2006 MSS_EGRESS_CTL_REGISTER_ADDR + 4,
2007 &ctl_reg.word_1);
2008 if (unlikely(ret))
2009 return ret;
2010
2011 /* Toggle the Egress MIB clear bit 0->1->0 */
2012 ctl_reg.bits_0.clear_counter = 0;
2013 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2014 MSS_EGRESS_CTL_REGISTER_ADDR, ctl_reg.word_0);
2015 if (unlikely(ret))
2016 return ret;
2017 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2018 MSS_EGRESS_CTL_REGISTER_ADDR + 4,
2019 ctl_reg.word_1);
2020 if (unlikely(ret))
2021 return ret;
2022
2023 ctl_reg.bits_0.clear_counter = 1;
2024 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2025 MSS_EGRESS_CTL_REGISTER_ADDR, ctl_reg.word_0);
2026 if (unlikely(ret))
2027 return ret;
2028 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2029 MSS_EGRESS_CTL_REGISTER_ADDR + 4,
2030 ctl_reg.word_1);
2031 if (unlikely(ret))
2032 return ret;
2033
2034 ctl_reg.bits_0.clear_counter = 0;
2035 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2036 MSS_EGRESS_CTL_REGISTER_ADDR, ctl_reg.word_0);
2037 if (unlikely(ret))
2038 return ret;
2039 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2040 MSS_EGRESS_CTL_REGISTER_ADDR + 4,
2041 ctl_reg.word_1);
2042 if (unlikely(ret))
2043 return ret;
2044
2045 return 0;
2046}
2047
2048int aq_mss_clear_egress_counters(struct aq_hw_s *hw)
2049{
2050 return AQ_API_CALL_SAFE(clear_egress_counters, hw);
2051}
2052
2053static int get_ingress_sa_counters(struct aq_hw_s *hw,
2054 struct aq_mss_ingress_sa_counters *counters,
2055 u16 sa_index)
2056{
2057 u16 packed_record[4];
2058 int ret;
2059
2060 if (sa_index >= NUMROWS_INGRESSSARECORD)
2061 return -EINVAL;
2062
2063 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2064 sa_index * 12 + 0);
2065 if (unlikely(ret))
2066 return ret;
2067 counters->untagged_hit_pkts[0] =
2068 packed_record[0] | (packed_record[1] << 16);
2069 counters->untagged_hit_pkts[1] =
2070 packed_record[2] | (packed_record[3] << 16);
2071
2072 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2073 sa_index * 12 + 1);
2074 if (unlikely(ret))
2075 return ret;
2076 counters->ctrl_hit_drop_redir_pkts[0] =
2077 packed_record[0] | (packed_record[1] << 16);
2078 counters->ctrl_hit_drop_redir_pkts[1] =
2079 packed_record[2] | (packed_record[3] << 16);
2080
2081 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2082 sa_index * 12 + 2);
2083 if (unlikely(ret))
2084 return ret;
2085 counters->not_using_sa[0] = packed_record[0] | (packed_record[1] << 16);
2086 counters->not_using_sa[1] = packed_record[2] | (packed_record[3] << 16);
2087
2088 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2089 sa_index * 12 + 3);
2090 if (unlikely(ret))
2091 return ret;
2092 counters->unused_sa[0] = packed_record[0] | (packed_record[1] << 16);
2093 counters->unused_sa[1] = packed_record[2] | (packed_record[3] << 16);
2094
2095 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2096 sa_index * 12 + 4);
2097 if (unlikely(ret))
2098 return ret;
2099 counters->not_valid_pkts[0] =
2100 packed_record[0] | (packed_record[1] << 16);
2101 counters->not_valid_pkts[1] =
2102 packed_record[2] | (packed_record[3] << 16);
2103
2104 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2105 sa_index * 12 + 5);
2106 if (unlikely(ret))
2107 return ret;
2108 counters->invalid_pkts[0] = packed_record[0] | (packed_record[1] << 16);
2109 counters->invalid_pkts[1] = packed_record[2] | (packed_record[3] << 16);
2110
2111 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2112 sa_index * 12 + 6);
2113 if (unlikely(ret))
2114 return ret;
2115 counters->ok_pkts[0] = packed_record[0] | (packed_record[1] << 16);
2116 counters->ok_pkts[1] = packed_record[2] | (packed_record[3] << 16);
2117
2118 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2119 sa_index * 12 + 7);
2120 if (unlikely(ret))
2121 return ret;
2122 counters->late_pkts[0] = packed_record[0] | (packed_record[1] << 16);
2123 counters->late_pkts[1] = packed_record[2] | (packed_record[3] << 16);
2124
2125 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2126 sa_index * 12 + 8);
2127 if (unlikely(ret))
2128 return ret;
2129 counters->delayed_pkts[0] = packed_record[0] | (packed_record[1] << 16);
2130 counters->delayed_pkts[1] = packed_record[2] | (packed_record[3] << 16);
2131
2132 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2133 sa_index * 12 + 9);
2134 if (unlikely(ret))
2135 return ret;
2136 counters->unchecked_pkts[0] =
2137 packed_record[0] | (packed_record[1] << 16);
2138 counters->unchecked_pkts[1] =
2139 packed_record[2] | (packed_record[3] << 16);
2140
2141 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2142 sa_index * 12 + 10);
2143 if (unlikely(ret))
2144 return ret;
2145 counters->validated_octets[0] =
2146 packed_record[0] | (packed_record[1] << 16);
2147 counters->validated_octets[1] =
2148 packed_record[2] | (packed_record[3] << 16);
2149
2150 ret = get_raw_ingress_record(hw, packed_record, 4, 6,
2151 sa_index * 12 + 11);
2152 if (unlikely(ret))
2153 return ret;
2154 counters->decrypted_octets[0] =
2155 packed_record[0] | (packed_record[1] << 16);
2156 counters->decrypted_octets[1] =
2157 packed_record[2] | (packed_record[3] << 16);
2158
2159 return 0;
2160}
2161
2162int aq_mss_get_ingress_sa_counters(struct aq_hw_s *hw,
2163 struct aq_mss_ingress_sa_counters *counters,
2164 u16 sa_index)
2165{
2166 memset(counters, 0, sizeof(*counters));
2167
2168 return AQ_API_CALL_SAFE(get_ingress_sa_counters, hw, counters,
2169 sa_index);
2170}
2171
2172static int
2173get_ingress_common_counters(struct aq_hw_s *hw,
2174 struct aq_mss_ingress_common_counters *counters)
2175{
2176 u16 packed_record[4];
2177 int ret;
2178
2179 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 0);
2180 if (unlikely(ret))
2181 return ret;
2182 counters->ctl_pkts[0] = packed_record[0] | (packed_record[1] << 16);
2183 counters->ctl_pkts[1] = packed_record[2] | (packed_record[3] << 16);
2184
2185 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 1);
2186 if (unlikely(ret))
2187 return ret;
2188 counters->tagged_miss_pkts[0] =
2189 packed_record[0] | (packed_record[1] << 16);
2190 counters->tagged_miss_pkts[1] =
2191 packed_record[2] | (packed_record[3] << 16);
2192
2193 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 2);
2194 if (unlikely(ret))
2195 return ret;
2196 counters->untagged_miss_pkts[0] =
2197 packed_record[0] | (packed_record[1] << 16);
2198 counters->untagged_miss_pkts[1] =
2199 packed_record[2] | (packed_record[3] << 16);
2200
2201 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 3);
2202 if (unlikely(ret))
2203 return ret;
2204 counters->notag_pkts[0] = packed_record[0] | (packed_record[1] << 16);
2205 counters->notag_pkts[1] = packed_record[2] | (packed_record[3] << 16);
2206
2207 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 4);
2208 if (unlikely(ret))
2209 return ret;
2210 counters->untagged_pkts[0] =
2211 packed_record[0] | (packed_record[1] << 16);
2212 counters->untagged_pkts[1] =
2213 packed_record[2] | (packed_record[3] << 16);
2214
2215 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 5);
2216 if (unlikely(ret))
2217 return ret;
2218 counters->bad_tag_pkts[0] = packed_record[0] | (packed_record[1] << 16);
2219 counters->bad_tag_pkts[1] = packed_record[2] | (packed_record[3] << 16);
2220
2221 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 6);
2222 if (unlikely(ret))
2223 return ret;
2224 counters->no_sci_pkts[0] = packed_record[0] | (packed_record[1] << 16);
2225 counters->no_sci_pkts[1] = packed_record[2] | (packed_record[3] << 16);
2226
2227 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 7);
2228 if (unlikely(ret))
2229 return ret;
2230 counters->unknown_sci_pkts[0] =
2231 packed_record[0] | (packed_record[1] << 16);
2232 counters->unknown_sci_pkts[1] =
2233 packed_record[2] | (packed_record[3] << 16);
2234
2235 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 8);
2236 if (unlikely(ret))
2237 return ret;
2238 counters->ctrl_prt_pass_pkts[0] =
2239 packed_record[0] | (packed_record[1] << 16);
2240 counters->ctrl_prt_pass_pkts[1] =
2241 packed_record[2] | (packed_record[3] << 16);
2242
2243 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 9);
2244 if (unlikely(ret))
2245 return ret;
2246 counters->unctrl_prt_pass_pkts[0] =
2247 packed_record[0] | (packed_record[1] << 16);
2248 counters->unctrl_prt_pass_pkts[1] =
2249 packed_record[2] | (packed_record[3] << 16);
2250
2251 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 10);
2252 if (unlikely(ret))
2253 return ret;
2254 counters->ctrl_prt_fail_pkts[0] =
2255 packed_record[0] | (packed_record[1] << 16);
2256 counters->ctrl_prt_fail_pkts[1] =
2257 packed_record[2] | (packed_record[3] << 16);
2258
2259 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 11);
2260 if (unlikely(ret))
2261 return ret;
2262 counters->unctrl_prt_fail_pkts[0] =
2263 packed_record[0] | (packed_record[1] << 16);
2264 counters->unctrl_prt_fail_pkts[1] =
2265 packed_record[2] | (packed_record[3] << 16);
2266
2267 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 12);
2268 if (unlikely(ret))
2269 return ret;
2270 counters->too_long_pkts[0] =
2271 packed_record[0] | (packed_record[1] << 16);
2272 counters->too_long_pkts[1] =
2273 packed_record[2] | (packed_record[3] << 16);
2274
2275 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 13);
2276 if (unlikely(ret))
2277 return ret;
2278 counters->igpoc_ctl_pkts[0] =
2279 packed_record[0] | (packed_record[1] << 16);
2280 counters->igpoc_ctl_pkts[1] =
2281 packed_record[2] | (packed_record[3] << 16);
2282
2283 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 14);
2284 if (unlikely(ret))
2285 return ret;
2286 counters->ecc_error_pkts[0] =
2287 packed_record[0] | (packed_record[1] << 16);
2288 counters->ecc_error_pkts[1] =
2289 packed_record[2] | (packed_record[3] << 16);
2290
2291 ret = get_raw_ingress_record(hw, packed_record, 4, 6, 385 + 15);
2292 if (unlikely(ret))
2293 return ret;
2294 counters->unctrl_hit_drop_redir[0] =
2295 packed_record[0] | (packed_record[1] << 16);
2296 counters->unctrl_hit_drop_redir[1] =
2297 packed_record[2] | (packed_record[3] << 16);
2298
2299 return 0;
2300}
2301
2302int aq_mss_get_ingress_common_counters(struct aq_hw_s *hw,
2303 struct aq_mss_ingress_common_counters *counters)
2304{
2305 memset(counters, 0, sizeof(*counters));
2306
2307 return AQ_API_CALL_SAFE(get_ingress_common_counters, hw, counters);
2308}
2309
2310static int clear_ingress_counters(struct aq_hw_s *hw)
2311{
2312 struct mss_ingress_ctl_register ctl_reg;
2313 int ret;
2314
2315 memset(&ctl_reg, 0, sizeof(ctl_reg));
2316
2317 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1,
2318 MSS_INGRESS_CTL_REGISTER_ADDR, &ctl_reg.word_0);
2319 if (unlikely(ret))
2320 return ret;
2321 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1,
2322 MSS_INGRESS_CTL_REGISTER_ADDR + 4,
2323 &ctl_reg.word_1);
2324 if (unlikely(ret))
2325 return ret;
2326
2327 /* Toggle the Ingress MIB clear bit 0->1->0 */
2328 ctl_reg.bits_0.clear_count = 0;
2329 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2330 MSS_INGRESS_CTL_REGISTER_ADDR, ctl_reg.word_0);
2331 if (unlikely(ret))
2332 return ret;
2333 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2334 MSS_INGRESS_CTL_REGISTER_ADDR + 4,
2335 ctl_reg.word_1);
2336 if (unlikely(ret))
2337 return ret;
2338
2339 ctl_reg.bits_0.clear_count = 1;
2340 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2341 MSS_INGRESS_CTL_REGISTER_ADDR, ctl_reg.word_0);
2342 if (unlikely(ret))
2343 return ret;
2344 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2345 MSS_INGRESS_CTL_REGISTER_ADDR + 4,
2346 ctl_reg.word_1);
2347 if (unlikely(ret))
2348 return ret;
2349
2350 ctl_reg.bits_0.clear_count = 0;
2351 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2352 MSS_INGRESS_CTL_REGISTER_ADDR, ctl_reg.word_0);
2353 if (unlikely(ret))
2354 return ret;
2355 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2356 MSS_INGRESS_CTL_REGISTER_ADDR + 4,
2357 ctl_reg.word_1);
2358 if (unlikely(ret))
2359 return ret;
2360
2361 return 0;
2362}
2363
2364int aq_mss_clear_ingress_counters(struct aq_hw_s *hw)
2365{
2366 return AQ_API_CALL_SAFE(clear_ingress_counters, hw);
2367}
2368
2369static int get_egress_sa_expired(struct aq_hw_s *hw, u32 *expired)
2370{
2371 u16 val;
2372 int ret;
2373
2374 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1,
2375 MSS_EGRESS_SA_EXPIRED_STATUS_REGISTER_ADDR,
2376 &val);
2377 if (unlikely(ret))
2378 return ret;
2379
2380 *expired = val;
2381
2382 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1,
2383 MSS_EGRESS_SA_EXPIRED_STATUS_REGISTER_ADDR + 1,
2384 &val);
2385 if (unlikely(ret))
2386 return ret;
2387
2388 *expired |= val << 16;
2389
2390 return 0;
2391}
2392
2393int aq_mss_get_egress_sa_expired(struct aq_hw_s *hw, u32 *expired)
2394{
2395 *expired = 0;
2396
2397 return AQ_API_CALL_SAFE(get_egress_sa_expired, hw, expired);
2398}
2399
2400static int get_egress_sa_threshold_expired(struct aq_hw_s *hw,
2401 u32 *expired)
2402{
2403 u16 val;
2404 int ret;
2405
2406 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1,
2407 MSS_EGRESS_SA_THRESHOLD_EXPIRED_STATUS_REGISTER_ADDR, &val);
2408 if (unlikely(ret))
2409 return ret;
2410
2411 *expired = val;
2412
2413 ret = aq_mss_mdio_read(hw, MDIO_MMD_VEND1,
2414 MSS_EGRESS_SA_THRESHOLD_EXPIRED_STATUS_REGISTER_ADDR + 1, &val);
2415 if (unlikely(ret))
2416 return ret;
2417
2418 *expired |= val << 16;
2419
2420 return 0;
2421}
2422
2423int aq_mss_get_egress_sa_threshold_expired(struct aq_hw_s *hw,
2424 u32 *expired)
2425{
2426 *expired = 0;
2427
2428 return AQ_API_CALL_SAFE(get_egress_sa_threshold_expired, hw, expired);
2429}
2430
2431static int set_egress_sa_expired(struct aq_hw_s *hw, u32 expired)
2432{
2433 int ret;
2434
2435 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2436 MSS_EGRESS_SA_EXPIRED_STATUS_REGISTER_ADDR,
2437 expired & 0xFFFF);
2438 if (unlikely(ret))
2439 return ret;
2440
2441 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2442 MSS_EGRESS_SA_EXPIRED_STATUS_REGISTER_ADDR + 1,
2443 expired >> 16);
2444 if (unlikely(ret))
2445 return ret;
2446
2447 return 0;
2448}
2449
2450int aq_mss_set_egress_sa_expired(struct aq_hw_s *hw, u32 expired)
2451{
2452 return AQ_API_CALL_SAFE(set_egress_sa_expired, hw, expired);
2453}
2454
2455static int set_egress_sa_threshold_expired(struct aq_hw_s *hw, u32 expired)
2456{
2457 int ret;
2458
2459 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2460 MSS_EGRESS_SA_THRESHOLD_EXPIRED_STATUS_REGISTER_ADDR,
2461 expired & 0xFFFF);
2462 if (unlikely(ret))
2463 return ret;
2464
2465 ret = aq_mss_mdio_write(hw, MDIO_MMD_VEND1,
2466 MSS_EGRESS_SA_THRESHOLD_EXPIRED_STATUS_REGISTER_ADDR + 1,
2467 expired >> 16);
2468 if (unlikely(ret))
2469 return ret;
2470
2471 return 0;
2472}
2473
2474int aq_mss_set_egress_sa_threshold_expired(struct aq_hw_s *hw, u32 expired)
2475{
2476 return AQ_API_CALL_SAFE(set_egress_sa_threshold_expired, hw, expired);
2477}