1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* Copyright (C) 2014-2017 aQuantia Corporation. */
4 /* File aq_filters.c: RX filters related functions. */
6 #include "aq_filters.h"
8 static bool __must_check
9 aq_rule_is_approve(struct ethtool_rx_flow_spec
*fsp
)
11 if (fsp
->flow_type
& FLOW_MAC_EXT
)
14 switch (fsp
->flow_type
& ~FLOW_EXT
) {
26 switch (fsp
->h_u
.usr_ip4_spec
.proto
) {
36 switch (fsp
->h_u
.usr_ip6_spec
.l4_proto
) {
52 static bool __must_check
53 aq_match_filter(struct ethtool_rx_flow_spec
*fsp1
,
54 struct ethtool_rx_flow_spec
*fsp2
)
56 if (fsp1
->flow_type
!= fsp2
->flow_type
||
57 memcmp(&fsp1
->h_u
, &fsp2
->h_u
, sizeof(fsp2
->h_u
)) ||
58 memcmp(&fsp1
->h_ext
, &fsp2
->h_ext
, sizeof(fsp2
->h_ext
)) ||
59 memcmp(&fsp1
->m_u
, &fsp2
->m_u
, sizeof(fsp2
->m_u
)) ||
60 memcmp(&fsp1
->m_ext
, &fsp2
->m_ext
, sizeof(fsp2
->m_ext
)))
66 static bool __must_check
67 aq_rule_already_exists(struct aq_nic_s
*aq_nic
,
68 struct ethtool_rx_flow_spec
*fsp
)
70 struct aq_rx_filter
*rule
;
71 struct hlist_node
*aq_node2
;
72 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
74 hlist_for_each_entry_safe(rule
, aq_node2
,
75 &rx_fltrs
->filter_list
, aq_node
) {
76 if (rule
->aq_fsp
.location
== fsp
->location
)
78 if (aq_match_filter(&rule
->aq_fsp
, fsp
)) {
79 netdev_err(aq_nic
->ndev
,
80 "ethtool: This filter is already set\n");
88 static int aq_check_approve_fl3l4(struct aq_nic_s
*aq_nic
,
89 struct aq_hw_rx_fltrs_s
*rx_fltrs
,
90 struct ethtool_rx_flow_spec
*fsp
)
92 if (fsp
->location
< AQ_RX_FIRST_LOC_FL3L4
||
93 fsp
->location
> AQ_RX_LAST_LOC_FL3L4
) {
94 netdev_err(aq_nic
->ndev
,
95 "ethtool: location must be in range [%d, %d]",
96 AQ_RX_FIRST_LOC_FL3L4
,
97 AQ_RX_LAST_LOC_FL3L4
);
100 if (rx_fltrs
->fl3l4
.is_ipv6
&& rx_fltrs
->fl3l4
.active_ipv4
) {
101 rx_fltrs
->fl3l4
.is_ipv6
= false;
102 netdev_err(aq_nic
->ndev
,
103 "ethtool: mixing ipv4 and ipv6 is not allowed");
105 } else if (!rx_fltrs
->fl3l4
.is_ipv6
&& rx_fltrs
->fl3l4
.active_ipv6
) {
106 rx_fltrs
->fl3l4
.is_ipv6
= true;
107 netdev_err(aq_nic
->ndev
,
108 "ethtool: mixing ipv4 and ipv6 is not allowed");
110 } else if (rx_fltrs
->fl3l4
.is_ipv6
&&
111 fsp
->location
!= AQ_RX_FIRST_LOC_FL3L4
+ 4 &&
112 fsp
->location
!= AQ_RX_FIRST_LOC_FL3L4
) {
113 netdev_err(aq_nic
->ndev
,
114 "ethtool: The specified location for ipv6 must be %d or %d",
115 AQ_RX_FIRST_LOC_FL3L4
, AQ_RX_FIRST_LOC_FL3L4
+ 4);
122 static int __must_check
123 aq_check_approve_fl2(struct aq_nic_s
*aq_nic
,
124 struct aq_hw_rx_fltrs_s
*rx_fltrs
,
125 struct ethtool_rx_flow_spec
*fsp
)
127 if (fsp
->location
< AQ_RX_FIRST_LOC_FETHERT
||
128 fsp
->location
> AQ_RX_LAST_LOC_FETHERT
) {
129 netdev_err(aq_nic
->ndev
,
130 "ethtool: location must be in range [%d, %d]",
131 AQ_RX_FIRST_LOC_FETHERT
,
132 AQ_RX_LAST_LOC_FETHERT
);
136 if (be16_to_cpu(fsp
->m_ext
.vlan_tci
) == VLAN_PRIO_MASK
&&
137 fsp
->m_u
.ether_spec
.h_proto
== 0U) {
138 netdev_err(aq_nic
->ndev
,
139 "ethtool: proto (ether_type) parameter must be specfied");
146 static int __must_check
147 aq_check_approve_fvlan(struct aq_nic_s
*aq_nic
,
148 struct aq_hw_rx_fltrs_s
*rx_fltrs
,
149 struct ethtool_rx_flow_spec
*fsp
)
151 if (fsp
->location
< AQ_RX_FIRST_LOC_FVLANID
||
152 fsp
->location
> AQ_RX_LAST_LOC_FVLANID
) {
153 netdev_err(aq_nic
->ndev
,
154 "ethtool: location must be in range [%d, %d]",
155 AQ_RX_FIRST_LOC_FVLANID
,
156 AQ_RX_LAST_LOC_FVLANID
);
160 if ((aq_nic
->ndev
->features
& NETIF_F_HW_VLAN_CTAG_FILTER
) &&
161 (!test_bit(be16_to_cpu(fsp
->h_ext
.vlan_tci
),
162 aq_nic
->active_vlans
))) {
163 netdev_err(aq_nic
->ndev
,
164 "ethtool: unknown vlan-id specified");
168 if (fsp
->ring_cookie
> aq_nic
->aq_nic_cfg
.num_rss_queues
) {
169 netdev_err(aq_nic
->ndev
,
170 "ethtool: queue number must be in range [0, %d]",
171 aq_nic
->aq_nic_cfg
.num_rss_queues
- 1);
177 static int __must_check
178 aq_check_filter(struct aq_nic_s
*aq_nic
,
179 struct ethtool_rx_flow_spec
*fsp
)
182 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
184 if (fsp
->flow_type
& FLOW_EXT
) {
185 if (be16_to_cpu(fsp
->m_ext
.vlan_tci
) == VLAN_VID_MASK
) {
186 err
= aq_check_approve_fvlan(aq_nic
, rx_fltrs
, fsp
);
187 } else if (be16_to_cpu(fsp
->m_ext
.vlan_tci
) == VLAN_PRIO_MASK
) {
188 err
= aq_check_approve_fl2(aq_nic
, rx_fltrs
, fsp
);
190 netdev_err(aq_nic
->ndev
,
191 "ethtool: invalid vlan mask 0x%x specified",
192 be16_to_cpu(fsp
->m_ext
.vlan_tci
));
196 switch (fsp
->flow_type
& ~FLOW_EXT
) {
198 err
= aq_check_approve_fl2(aq_nic
, rx_fltrs
, fsp
);
205 rx_fltrs
->fl3l4
.is_ipv6
= false;
206 err
= aq_check_approve_fl3l4(aq_nic
, rx_fltrs
, fsp
);
213 rx_fltrs
->fl3l4
.is_ipv6
= true;
214 err
= aq_check_approve_fl3l4(aq_nic
, rx_fltrs
, fsp
);
217 netdev_err(aq_nic
->ndev
,
218 "ethtool: unknown flow-type specified");
226 static bool __must_check
227 aq_rule_is_not_support(struct aq_nic_s
*aq_nic
,
228 struct ethtool_rx_flow_spec
*fsp
)
230 bool rule_is_not_support
= false;
232 if (!(aq_nic
->ndev
->features
& NETIF_F_NTUPLE
)) {
233 netdev_err(aq_nic
->ndev
,
234 "ethtool: Please, to enable the RX flow control:\n"
235 "ethtool -K %s ntuple on\n", aq_nic
->ndev
->name
);
236 rule_is_not_support
= true;
237 } else if (!aq_rule_is_approve(fsp
)) {
238 netdev_err(aq_nic
->ndev
,
239 "ethtool: The specified flow type is not supported\n");
240 rule_is_not_support
= true;
241 } else if ((fsp
->flow_type
& ~FLOW_EXT
) != ETHER_FLOW
&&
242 (fsp
->h_u
.tcp_ip4_spec
.tos
||
243 fsp
->h_u
.tcp_ip6_spec
.tclass
)) {
244 netdev_err(aq_nic
->ndev
,
245 "ethtool: The specified tos tclass are not supported\n");
246 rule_is_not_support
= true;
247 } else if (fsp
->flow_type
& FLOW_MAC_EXT
) {
248 netdev_err(aq_nic
->ndev
,
249 "ethtool: MAC_EXT is not supported");
250 rule_is_not_support
= true;
253 return rule_is_not_support
;
256 static bool __must_check
257 aq_rule_is_not_correct(struct aq_nic_s
*aq_nic
,
258 struct ethtool_rx_flow_spec
*fsp
)
260 bool rule_is_not_correct
= false;
263 rule_is_not_correct
= true;
264 } else if (fsp
->location
> AQ_RX_MAX_RXNFC_LOC
) {
265 netdev_err(aq_nic
->ndev
,
266 "ethtool: The specified number %u rule is invalid\n",
268 rule_is_not_correct
= true;
269 } else if (aq_check_filter(aq_nic
, fsp
)) {
270 rule_is_not_correct
= true;
271 } else if (fsp
->ring_cookie
!= RX_CLS_FLOW_DISC
) {
272 if (fsp
->ring_cookie
>= aq_nic
->aq_nic_cfg
.num_rss_queues
) {
273 netdev_err(aq_nic
->ndev
,
274 "ethtool: The specified action is invalid.\n"
275 "Maximum allowable value action is %u.\n",
276 aq_nic
->aq_nic_cfg
.num_rss_queues
- 1);
277 rule_is_not_correct
= true;
281 return rule_is_not_correct
;
284 static int __must_check
285 aq_check_rule(struct aq_nic_s
*aq_nic
,
286 struct ethtool_rx_flow_spec
*fsp
)
290 if (aq_rule_is_not_correct(aq_nic
, fsp
))
292 else if (aq_rule_is_not_support(aq_nic
, fsp
))
294 else if (aq_rule_already_exists(aq_nic
, fsp
))
300 static void aq_set_data_fl2(struct aq_nic_s
*aq_nic
,
301 struct aq_rx_filter
*aq_rx_fltr
,
302 struct aq_rx_filter_l2
*data
, bool add
)
304 const struct ethtool_rx_flow_spec
*fsp
= &aq_rx_fltr
->aq_fsp
;
306 memset(data
, 0, sizeof(*data
));
308 data
->location
= fsp
->location
- AQ_RX_FIRST_LOC_FETHERT
;
310 if (fsp
->ring_cookie
!= RX_CLS_FLOW_DISC
)
311 data
->queue
= fsp
->ring_cookie
;
315 data
->ethertype
= be16_to_cpu(fsp
->h_u
.ether_spec
.h_proto
);
316 data
->user_priority_en
= be16_to_cpu(fsp
->m_ext
.vlan_tci
)
318 data
->user_priority
= (be16_to_cpu(fsp
->h_ext
.vlan_tci
)
319 & VLAN_PRIO_MASK
) >> VLAN_PRIO_SHIFT
;
322 static int aq_add_del_fether(struct aq_nic_s
*aq_nic
,
323 struct aq_rx_filter
*aq_rx_fltr
, bool add
)
325 struct aq_rx_filter_l2 data
;
326 struct aq_hw_s
*aq_hw
= aq_nic
->aq_hw
;
327 const struct aq_hw_ops
*aq_hw_ops
= aq_nic
->aq_hw_ops
;
329 aq_set_data_fl2(aq_nic
, aq_rx_fltr
, &data
, add
);
331 if (unlikely(!aq_hw_ops
->hw_filter_l2_set
))
333 if (unlikely(!aq_hw_ops
->hw_filter_l2_clear
))
337 return aq_hw_ops
->hw_filter_l2_set(aq_hw
, &data
);
339 return aq_hw_ops
->hw_filter_l2_clear(aq_hw
, &data
);
342 static bool aq_fvlan_is_busy(struct aq_rx_filter_vlan
*aq_vlans
, int vlan
)
346 for (i
= 0; i
< AQ_VLAN_MAX_FILTERS
; ++i
) {
347 if (aq_vlans
[i
].enable
&&
348 aq_vlans
[i
].queue
!= AQ_RX_QUEUE_NOT_ASSIGNED
&&
349 aq_vlans
[i
].vlan_id
== vlan
) {
357 /* Function rebuilds array of vlan filters so that filters with assigned
358 * queue have a precedence over just vlans on the interface.
360 static void aq_fvlan_rebuild(struct aq_nic_s
*aq_nic
,
361 unsigned long *active_vlans
,
362 struct aq_rx_filter_vlan
*aq_vlans
)
364 bool vlan_busy
= false;
368 for (i
= 0; i
< AQ_VLAN_MAX_FILTERS
; ++i
) {
369 if (aq_vlans
[i
].enable
&&
370 aq_vlans
[i
].queue
!= AQ_RX_QUEUE_NOT_ASSIGNED
)
373 vlan
= find_next_bit(active_vlans
,
376 if (vlan
== VLAN_N_VID
) {
377 aq_vlans
[i
].enable
= 0U;
378 aq_vlans
[i
].queue
= AQ_RX_QUEUE_NOT_ASSIGNED
;
379 aq_vlans
[i
].vlan_id
= 0;
383 vlan_busy
= aq_fvlan_is_busy(aq_vlans
, vlan
);
385 aq_vlans
[i
].enable
= 1U;
386 aq_vlans
[i
].queue
= AQ_RX_QUEUE_NOT_ASSIGNED
;
387 aq_vlans
[i
].vlan_id
= vlan
;
389 } while (vlan_busy
&& vlan
!= VLAN_N_VID
);
393 static int aq_set_data_fvlan(struct aq_nic_s
*aq_nic
,
394 struct aq_rx_filter
*aq_rx_fltr
,
395 struct aq_rx_filter_vlan
*aq_vlans
, bool add
)
397 const struct ethtool_rx_flow_spec
*fsp
= &aq_rx_fltr
->aq_fsp
;
398 int location
= fsp
->location
- AQ_RX_FIRST_LOC_FVLANID
;
401 memset(&aq_vlans
[location
], 0, sizeof(aq_vlans
[location
]));
406 /* remove vlan if it was in table without queue assignment */
407 for (i
= 0; i
< AQ_VLAN_MAX_FILTERS
; ++i
) {
408 if (aq_vlans
[i
].vlan_id
==
409 (be16_to_cpu(fsp
->h_ext
.vlan_tci
) & VLAN_VID_MASK
)) {
410 aq_vlans
[i
].enable
= false;
414 aq_vlans
[location
].location
= location
;
415 aq_vlans
[location
].vlan_id
= be16_to_cpu(fsp
->h_ext
.vlan_tci
)
417 aq_vlans
[location
].queue
= fsp
->ring_cookie
& 0x1FU
;
418 aq_vlans
[location
].enable
= 1U;
423 int aq_del_fvlan_by_vlan(struct aq_nic_s
*aq_nic
, u16 vlan_id
)
425 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
426 struct aq_rx_filter
*rule
= NULL
;
427 struct hlist_node
*aq_node2
;
429 hlist_for_each_entry_safe(rule
, aq_node2
,
430 &rx_fltrs
->filter_list
, aq_node
) {
431 if (be16_to_cpu(rule
->aq_fsp
.h_ext
.vlan_tci
) == vlan_id
)
434 if (rule
&& be16_to_cpu(rule
->aq_fsp
.h_ext
.vlan_tci
) == vlan_id
) {
435 struct ethtool_rxnfc cmd
;
437 cmd
.fs
.location
= rule
->aq_fsp
.location
;
438 return aq_del_rxnfc_rule(aq_nic
, &cmd
);
444 static int aq_add_del_fvlan(struct aq_nic_s
*aq_nic
,
445 struct aq_rx_filter
*aq_rx_fltr
, bool add
)
447 const struct aq_hw_ops
*aq_hw_ops
= aq_nic
->aq_hw_ops
;
449 if (unlikely(!aq_hw_ops
->hw_filter_vlan_set
))
452 aq_set_data_fvlan(aq_nic
,
454 aq_nic
->aq_hw_rx_fltrs
.fl2
.aq_vlans
,
457 return aq_filters_vlans_update(aq_nic
);
460 static int aq_set_data_fl3l4(struct aq_nic_s
*aq_nic
,
461 struct aq_rx_filter
*aq_rx_fltr
,
462 struct aq_rx_filter_l3l4
*data
, bool add
)
464 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
465 const struct ethtool_rx_flow_spec
*fsp
= &aq_rx_fltr
->aq_fsp
;
467 memset(data
, 0, sizeof(*data
));
469 data
->is_ipv6
= rx_fltrs
->fl3l4
.is_ipv6
;
470 data
->location
= HW_ATL_GET_REG_LOCATION_FL3L4(fsp
->location
);
474 rx_fltrs
->fl3l4
.active_ipv4
&= ~BIT(data
->location
);
476 rx_fltrs
->fl3l4
.active_ipv6
&=
477 ~BIT((data
->location
) / 4);
482 data
->cmd
|= HW_ATL_RX_ENABLE_FLTR_L3L4
;
484 switch (fsp
->flow_type
) {
487 data
->cmd
|= HW_ATL_RX_ENABLE_CMP_PROT_L4
;
491 data
->cmd
|= HW_ATL_RX_UDP
;
492 data
->cmd
|= HW_ATL_RX_ENABLE_CMP_PROT_L4
;
496 data
->cmd
|= HW_ATL_RX_SCTP
;
497 data
->cmd
|= HW_ATL_RX_ENABLE_CMP_PROT_L4
;
503 if (!data
->is_ipv6
) {
505 ntohl(fsp
->h_u
.tcp_ip4_spec
.ip4src
);
507 ntohl(fsp
->h_u
.tcp_ip4_spec
.ip4dst
);
508 rx_fltrs
->fl3l4
.active_ipv4
|= BIT(data
->location
);
512 rx_fltrs
->fl3l4
.active_ipv6
|= BIT((data
->location
) / 4);
513 for (i
= 0; i
< HW_ATL_RX_CNT_REG_ADDR_IPV6
; ++i
) {
515 ntohl(fsp
->h_u
.tcp_ip6_spec
.ip6dst
[i
]);
517 ntohl(fsp
->h_u
.tcp_ip6_spec
.ip6src
[i
]);
519 data
->cmd
|= HW_ATL_RX_ENABLE_L3_IPV6
;
521 if (fsp
->flow_type
!= IP_USER_FLOW
&&
522 fsp
->flow_type
!= IPV6_USER_FLOW
) {
523 if (!data
->is_ipv6
) {
525 ntohs(fsp
->h_u
.tcp_ip4_spec
.pdst
);
527 ntohs(fsp
->h_u
.tcp_ip4_spec
.psrc
);
530 ntohs(fsp
->h_u
.tcp_ip6_spec
.pdst
);
532 ntohs(fsp
->h_u
.tcp_ip6_spec
.psrc
);
535 if (data
->ip_src
[0] && !data
->is_ipv6
)
536 data
->cmd
|= HW_ATL_RX_ENABLE_CMP_SRC_ADDR_L3
;
537 if (data
->ip_dst
[0] && !data
->is_ipv6
)
538 data
->cmd
|= HW_ATL_RX_ENABLE_CMP_DEST_ADDR_L3
;
540 data
->cmd
|= HW_ATL_RX_ENABLE_CMP_DEST_PORT_L4
;
542 data
->cmd
|= HW_ATL_RX_ENABLE_CMP_SRC_PORT_L4
;
543 if (fsp
->ring_cookie
!= RX_CLS_FLOW_DISC
) {
544 data
->cmd
|= HW_ATL_RX_HOST
<< HW_ATL_RX_ACTION_FL3F4_SHIFT
;
545 data
->cmd
|= fsp
->ring_cookie
<< HW_ATL_RX_QUEUE_FL3L4_SHIFT
;
546 data
->cmd
|= HW_ATL_RX_ENABLE_QUEUE_L3L4
;
548 data
->cmd
|= HW_ATL_RX_DISCARD
<< HW_ATL_RX_ACTION_FL3F4_SHIFT
;
554 static int aq_set_fl3l4(struct aq_hw_s
*aq_hw
,
555 const struct aq_hw_ops
*aq_hw_ops
,
556 struct aq_rx_filter_l3l4
*data
)
558 if (unlikely(!aq_hw_ops
->hw_filter_l3l4_set
))
561 return aq_hw_ops
->hw_filter_l3l4_set(aq_hw
, data
);
564 static int aq_add_del_fl3l4(struct aq_nic_s
*aq_nic
,
565 struct aq_rx_filter
*aq_rx_fltr
, bool add
)
567 const struct aq_hw_ops
*aq_hw_ops
= aq_nic
->aq_hw_ops
;
568 struct aq_hw_s
*aq_hw
= aq_nic
->aq_hw
;
569 struct aq_rx_filter_l3l4 data
;
571 if (unlikely(aq_rx_fltr
->aq_fsp
.location
< AQ_RX_FIRST_LOC_FL3L4
||
572 aq_rx_fltr
->aq_fsp
.location
> AQ_RX_LAST_LOC_FL3L4
||
573 aq_set_data_fl3l4(aq_nic
, aq_rx_fltr
, &data
, add
)))
576 return aq_set_fl3l4(aq_hw
, aq_hw_ops
, &data
);
579 static int aq_add_del_rule(struct aq_nic_s
*aq_nic
,
580 struct aq_rx_filter
*aq_rx_fltr
, bool add
)
584 if (aq_rx_fltr
->aq_fsp
.flow_type
& FLOW_EXT
) {
585 if (be16_to_cpu(aq_rx_fltr
->aq_fsp
.m_ext
.vlan_tci
)
587 aq_rx_fltr
->type
= aq_rx_filter_vlan
;
588 err
= aq_add_del_fvlan(aq_nic
, aq_rx_fltr
, add
);
589 } else if (be16_to_cpu(aq_rx_fltr
->aq_fsp
.m_ext
.vlan_tci
)
591 aq_rx_fltr
->type
= aq_rx_filter_ethertype
;
592 err
= aq_add_del_fether(aq_nic
, aq_rx_fltr
, add
);
595 switch (aq_rx_fltr
->aq_fsp
.flow_type
& ~FLOW_EXT
) {
597 aq_rx_fltr
->type
= aq_rx_filter_ethertype
;
598 err
= aq_add_del_fether(aq_nic
, aq_rx_fltr
, add
);
608 aq_rx_fltr
->type
= aq_rx_filter_l3l4
;
609 err
= aq_add_del_fl3l4(aq_nic
, aq_rx_fltr
, add
);
620 static int aq_update_table_filters(struct aq_nic_s
*aq_nic
,
621 struct aq_rx_filter
*aq_rx_fltr
, u16 index
,
622 struct ethtool_rxnfc
*cmd
)
624 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
625 struct aq_rx_filter
*rule
= NULL
, *parent
= NULL
;
626 struct hlist_node
*aq_node2
;
629 hlist_for_each_entry_safe(rule
, aq_node2
,
630 &rx_fltrs
->filter_list
, aq_node
) {
631 if (rule
->aq_fsp
.location
>= index
)
636 if (rule
&& rule
->aq_fsp
.location
== index
) {
637 err
= aq_add_del_rule(aq_nic
, rule
, false);
638 hlist_del(&rule
->aq_node
);
640 --rx_fltrs
->active_filters
;
643 if (unlikely(!aq_rx_fltr
))
646 INIT_HLIST_NODE(&aq_rx_fltr
->aq_node
);
649 hlist_add_behind(&aq_rx_fltr
->aq_node
, &parent
->aq_node
);
651 hlist_add_head(&aq_rx_fltr
->aq_node
, &rx_fltrs
->filter_list
);
653 ++rx_fltrs
->active_filters
;
658 u16
aq_get_rxnfc_count_all_rules(struct aq_nic_s
*aq_nic
)
660 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
662 return rx_fltrs
->active_filters
;
665 struct aq_hw_rx_fltrs_s
*aq_get_hw_rx_fltrs(struct aq_nic_s
*aq_nic
)
667 return &aq_nic
->aq_hw_rx_fltrs
;
670 int aq_add_rxnfc_rule(struct aq_nic_s
*aq_nic
, const struct ethtool_rxnfc
*cmd
)
672 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
673 struct ethtool_rx_flow_spec
*fsp
=
674 (struct ethtool_rx_flow_spec
*)&cmd
->fs
;
675 struct aq_rx_filter
*aq_rx_fltr
;
678 err
= aq_check_rule(aq_nic
, fsp
);
682 aq_rx_fltr
= kzalloc(sizeof(*aq_rx_fltr
), GFP_KERNEL
);
683 if (unlikely(!aq_rx_fltr
)) {
688 memcpy(&aq_rx_fltr
->aq_fsp
, fsp
, sizeof(*fsp
));
690 err
= aq_update_table_filters(aq_nic
, aq_rx_fltr
, fsp
->location
, NULL
);
694 err
= aq_add_del_rule(aq_nic
, aq_rx_fltr
, true);
696 hlist_del(&aq_rx_fltr
->aq_node
);
697 --rx_fltrs
->active_filters
;
709 int aq_del_rxnfc_rule(struct aq_nic_s
*aq_nic
, const struct ethtool_rxnfc
*cmd
)
711 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
712 struct aq_rx_filter
*rule
= NULL
;
713 struct hlist_node
*aq_node2
;
716 hlist_for_each_entry_safe(rule
, aq_node2
,
717 &rx_fltrs
->filter_list
, aq_node
) {
718 if (rule
->aq_fsp
.location
== cmd
->fs
.location
)
722 if (rule
&& rule
->aq_fsp
.location
== cmd
->fs
.location
) {
723 err
= aq_add_del_rule(aq_nic
, rule
, false);
724 hlist_del(&rule
->aq_node
);
726 --rx_fltrs
->active_filters
;
731 int aq_get_rxnfc_rule(struct aq_nic_s
*aq_nic
, struct ethtool_rxnfc
*cmd
)
733 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
734 struct ethtool_rx_flow_spec
*fsp
=
735 (struct ethtool_rx_flow_spec
*)&cmd
->fs
;
736 struct aq_rx_filter
*rule
= NULL
;
737 struct hlist_node
*aq_node2
;
739 hlist_for_each_entry_safe(rule
, aq_node2
,
740 &rx_fltrs
->filter_list
, aq_node
)
741 if (fsp
->location
<= rule
->aq_fsp
.location
)
744 if (unlikely(!rule
|| fsp
->location
!= rule
->aq_fsp
.location
))
747 memcpy(fsp
, &rule
->aq_fsp
, sizeof(*fsp
));
752 int aq_get_rxnfc_all_rules(struct aq_nic_s
*aq_nic
, struct ethtool_rxnfc
*cmd
,
755 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
756 struct hlist_node
*aq_node2
;
757 struct aq_rx_filter
*rule
;
760 cmd
->data
= aq_get_rxnfc_count_all_rules(aq_nic
);
762 hlist_for_each_entry_safe(rule
, aq_node2
,
763 &rx_fltrs
->filter_list
, aq_node
) {
764 if (unlikely(count
== cmd
->rule_cnt
))
767 rule_locs
[count
++] = rule
->aq_fsp
.location
;
770 cmd
->rule_cnt
= count
;
775 int aq_clear_rxnfc_all_rules(struct aq_nic_s
*aq_nic
)
777 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
778 struct hlist_node
*aq_node2
;
779 struct aq_rx_filter
*rule
;
782 hlist_for_each_entry_safe(rule
, aq_node2
,
783 &rx_fltrs
->filter_list
, aq_node
) {
784 err
= aq_add_del_rule(aq_nic
, rule
, false);
787 hlist_del(&rule
->aq_node
);
789 --rx_fltrs
->active_filters
;
796 int aq_reapply_rxnfc_all_rules(struct aq_nic_s
*aq_nic
)
798 struct aq_hw_rx_fltrs_s
*rx_fltrs
= aq_get_hw_rx_fltrs(aq_nic
);
799 struct hlist_node
*aq_node2
;
800 struct aq_rx_filter
*rule
;
803 hlist_for_each_entry_safe(rule
, aq_node2
,
804 &rx_fltrs
->filter_list
, aq_node
) {
805 err
= aq_add_del_rule(aq_nic
, rule
, true);
814 int aq_filters_vlans_update(struct aq_nic_s
*aq_nic
)
816 const struct aq_hw_ops
*aq_hw_ops
= aq_nic
->aq_hw_ops
;
817 struct aq_hw_s
*aq_hw
= aq_nic
->aq_hw
;
822 if (unlikely(!aq_hw_ops
->hw_filter_vlan_set
))
824 if (unlikely(!aq_hw_ops
->hw_filter_vlan_ctrl
))
827 aq_fvlan_rebuild(aq_nic
, aq_nic
->active_vlans
,
828 aq_nic
->aq_hw_rx_fltrs
.fl2
.aq_vlans
);
830 if (aq_nic
->ndev
->features
& NETIF_F_HW_VLAN_CTAG_FILTER
) {
831 for (i
= 0; i
< BITS_TO_LONGS(VLAN_N_VID
); i
++)
832 hweight
+= hweight_long(aq_nic
->active_vlans
[i
]);
834 err
= aq_hw_ops
->hw_filter_vlan_ctrl(aq_hw
, false);
839 err
= aq_hw_ops
->hw_filter_vlan_set(aq_hw
,
840 aq_nic
->aq_hw_rx_fltrs
.fl2
.aq_vlans
845 if (aq_nic
->ndev
->features
& NETIF_F_HW_VLAN_CTAG_FILTER
) {
846 if (hweight
< AQ_VLAN_MAX_FILTERS
)
847 err
= aq_hw_ops
->hw_filter_vlan_ctrl(aq_hw
, true);
848 /* otherwise left in promiscue mode */
854 int aq_filters_vlan_offload_off(struct aq_nic_s
*aq_nic
)
856 const struct aq_hw_ops
*aq_hw_ops
= aq_nic
->aq_hw_ops
;
857 struct aq_hw_s
*aq_hw
= aq_nic
->aq_hw
;
860 memset(aq_nic
->active_vlans
, 0, sizeof(aq_nic
->active_vlans
));
861 aq_fvlan_rebuild(aq_nic
, aq_nic
->active_vlans
,
862 aq_nic
->aq_hw_rx_fltrs
.fl2
.aq_vlans
);
864 if (unlikely(!aq_hw_ops
->hw_filter_vlan_set
))
866 if (unlikely(!aq_hw_ops
->hw_filter_vlan_ctrl
))
869 err
= aq_hw_ops
->hw_filter_vlan_ctrl(aq_hw
, false);
872 err
= aq_hw_ops
->hw_filter_vlan_set(aq_hw
,
873 aq_nic
->aq_hw_rx_fltrs
.fl2
.aq_vlans