1 // SPDX-License-Identifier: GPL-2.0
2 // Copyright (c) Huawei Technologies Co., Ltd. 2025. All rights reserved.
3
4 #include <linux/kernel.h>
5 #include <linux/pci.h>
6 #include <linux/device.h>
7 #include <linux/types.h>
8 #include <linux/errno.h>
9 #include <linux/etherdevice.h>
10 #include <linux/netdevice.h>
11 #include <linux/module.h>
12 #include <linux/moduleparam.h>
13
14 #include "hinic3_hwif.h"
15 #include "hinic3_nic_dev.h"
16 #include "hinic3_nic_cfg.h"
17
hinic3_filter_addr_sync(struct net_device * netdev,u8 * addr)18 static int hinic3_filter_addr_sync(struct net_device *netdev, u8 *addr)
19 {
20 struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
21
22 return hinic3_set_mac(nic_dev->hwdev, addr, 0,
23 hinic3_global_func_id(nic_dev->hwdev));
24 }
25
hinic3_filter_addr_unsync(struct net_device * netdev,u8 * addr)26 static int hinic3_filter_addr_unsync(struct net_device *netdev, u8 *addr)
27 {
28 struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
29
30 /* The addr is in use */
31 if (ether_addr_equal(addr, netdev->dev_addr))
32 return 0;
33
34 return hinic3_del_mac(nic_dev->hwdev, addr, 0,
35 hinic3_global_func_id(nic_dev->hwdev));
36 }
37
hinic3_clean_mac_list_filter(struct net_device * netdev)38 void hinic3_clean_mac_list_filter(struct net_device *netdev)
39 {
40 struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
41 struct hinic3_mac_filter *ftmp;
42 struct hinic3_mac_filter *f;
43
44 list_for_each_entry_safe(f, ftmp, &nic_dev->uc_filter_list, list) {
45 if (f->state == HINIC3_MAC_HW_SYNCED)
46 hinic3_filter_addr_unsync(netdev, f->addr);
47 list_del(&f->list);
48 kfree(f);
49 }
50
51 list_for_each_entry_safe(f, ftmp, &nic_dev->mc_filter_list, list) {
52 if (f->state == HINIC3_MAC_HW_SYNCED)
53 hinic3_filter_addr_unsync(netdev, f->addr);
54 list_del(&f->list);
55 kfree(f);
56 }
57 }
58
59 static struct hinic3_mac_filter *
hinic3_find_mac(const struct list_head * filter_list,u8 * addr)60 hinic3_find_mac(const struct list_head *filter_list, u8 *addr)
61 {
62 struct hinic3_mac_filter *f;
63
64 list_for_each_entry(f, filter_list, list) {
65 if (ether_addr_equal(addr, f->addr))
66 return f;
67 }
68 return NULL;
69 }
70
hinic3_add_filter(struct net_device * netdev,struct list_head * mac_filter_list,u8 * addr)71 static void hinic3_add_filter(struct net_device *netdev,
72 struct list_head *mac_filter_list,
73 u8 *addr)
74 {
75 struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
76 struct hinic3_mac_filter *f;
77
78 f = kzalloc_obj(*f, GFP_ATOMIC);
79 if (!f)
80 return;
81
82 ether_addr_copy(f->addr, addr);
83
84 INIT_LIST_HEAD(&f->list);
85 list_add_tail(&f->list, mac_filter_list);
86
87 f->state = HINIC3_MAC_WAIT_HW_SYNC;
88 set_bit(HINIC3_MAC_FILTER_CHANGED, &nic_dev->flags);
89 }
90
hinic3_del_filter(struct net_device * netdev,struct hinic3_mac_filter * f)91 static void hinic3_del_filter(struct net_device *netdev,
92 struct hinic3_mac_filter *f)
93 {
94 struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
95
96 set_bit(HINIC3_MAC_FILTER_CHANGED, &nic_dev->flags);
97
98 if (f->state == HINIC3_MAC_WAIT_HW_SYNC) {
99 /* have not added to hw, delete it directly */
100 list_del(&f->list);
101 kfree(f);
102 return;
103 }
104
105 f->state = HINIC3_MAC_WAIT_HW_UNSYNC;
106 }
107
108 static struct hinic3_mac_filter *
hinic3_mac_filter_entry_clone(const struct hinic3_mac_filter * src)109 hinic3_mac_filter_entry_clone(const struct hinic3_mac_filter *src)
110 {
111 struct hinic3_mac_filter *f;
112
113 f = kzalloc_obj(*f, GFP_ATOMIC);
114 if (!f)
115 return NULL;
116
117 *f = *src;
118 INIT_LIST_HEAD(&f->list);
119
120 return f;
121 }
122
hinic3_undo_del_filter_entries(struct list_head * filter_list,const struct list_head * from)123 static void hinic3_undo_del_filter_entries(struct list_head *filter_list,
124 const struct list_head *from)
125 {
126 struct hinic3_mac_filter *ftmp;
127 struct hinic3_mac_filter *f;
128
129 list_for_each_entry_safe(f, ftmp, from, list) {
130 if (hinic3_find_mac(filter_list, f->addr))
131 continue;
132
133 if (f->state == HINIC3_MAC_HW_UNSYNCED)
134 f->state = HINIC3_MAC_WAIT_HW_UNSYNC;
135
136 list_move_tail(&f->list, filter_list);
137 }
138 }
139
hinic3_undo_add_filter_entries(struct list_head * filter_list,const struct list_head * from)140 static void hinic3_undo_add_filter_entries(struct list_head *filter_list,
141 const struct list_head *from)
142 {
143 struct hinic3_mac_filter *ftmp;
144 struct hinic3_mac_filter *tmp;
145 struct hinic3_mac_filter *f;
146
147 list_for_each_entry_safe(f, ftmp, from, list) {
148 tmp = hinic3_find_mac(filter_list, f->addr);
149 if (tmp && tmp->state == HINIC3_MAC_HW_SYNCING)
150 tmp->state = HINIC3_MAC_WAIT_HW_SYNC;
151 }
152 }
153
hinic3_cleanup_filter_list(const struct list_head * head)154 static void hinic3_cleanup_filter_list(const struct list_head *head)
155 {
156 struct hinic3_mac_filter *ftmp;
157 struct hinic3_mac_filter *f;
158
159 list_for_each_entry_safe(f, ftmp, head, list) {
160 list_del(&f->list);
161 kfree(f);
162 }
163 }
164
hinic3_mac_filter_sync_hw(struct net_device * netdev,struct list_head * del_list,struct list_head * add_list,int * add_count)165 static int hinic3_mac_filter_sync_hw(struct net_device *netdev,
166 struct list_head *del_list,
167 struct list_head *add_list,
168 int *add_count)
169 {
170 struct hinic3_mac_filter *ftmp;
171 struct hinic3_mac_filter *f;
172 int err;
173
174 if (!list_empty(del_list)) {
175 list_for_each_entry_safe(f, ftmp, del_list, list) {
176 /* ignore errors when deleting mac */
177 hinic3_filter_addr_unsync(netdev, f->addr);
178 list_del(&f->list);
179 kfree(f);
180 }
181 }
182
183 if (!list_empty(add_list)) {
184 list_for_each_entry_safe(f, ftmp, add_list, list) {
185 if (f->state != HINIC3_MAC_HW_SYNCING)
186 continue;
187
188 err = hinic3_filter_addr_sync(netdev, f->addr);
189 if (err) {
190 netdev_err(netdev, "Failed to add mac\n");
191 return err;
192 }
193
194 f->state = HINIC3_MAC_HW_SYNCED;
195 (*add_count)++;
196 }
197 }
198
199 return 0;
200 }
201
hinic3_mac_filter_sync(struct net_device * netdev,struct list_head * mac_filter_list,bool uc)202 static int hinic3_mac_filter_sync(struct net_device *netdev,
203 struct list_head *mac_filter_list, bool uc)
204 {
205 struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
206 struct list_head tmp_del_list, tmp_add_list;
207 struct hinic3_mac_filter *fclone;
208 struct hinic3_mac_filter *ftmp;
209 struct hinic3_mac_filter *f;
210 int err = 0, add_count = 0;
211
212 INIT_LIST_HEAD(&tmp_del_list);
213 INIT_LIST_HEAD(&tmp_add_list);
214
215 list_for_each_entry_safe(f, ftmp, mac_filter_list, list) {
216 if (f->state != HINIC3_MAC_WAIT_HW_UNSYNC)
217 continue;
218
219 f->state = HINIC3_MAC_HW_UNSYNCED;
220 list_move_tail(&f->list, &tmp_del_list);
221 }
222
223 list_for_each_entry_safe(f, ftmp, mac_filter_list, list) {
224 if (f->state != HINIC3_MAC_WAIT_HW_SYNC)
225 continue;
226
227 fclone = hinic3_mac_filter_entry_clone(f);
228 if (!fclone) {
229 hinic3_undo_del_filter_entries(mac_filter_list,
230 &tmp_del_list);
231 hinic3_undo_add_filter_entries(mac_filter_list,
232 &tmp_add_list);
233
234 netdev_err(netdev,
235 "Failed to clone mac_filter_entry\n");
236 err = -ENOMEM;
237 goto cleanup_tmp_filter_list;
238 }
239
240 f->state = HINIC3_MAC_HW_SYNCING;
241 list_add_tail(&fclone->list, &tmp_add_list);
242 }
243
244 err = hinic3_mac_filter_sync_hw(netdev, &tmp_del_list,
245 &tmp_add_list, &add_count);
246 if (err) {
247 /* there were errors, delete all mac in hw */
248 hinic3_undo_add_filter_entries(mac_filter_list, &tmp_add_list);
249 add_count = 0;
250 /* VF does not support promiscuous mode,
251 * don't delete any other uc mac.
252 */
253 if (!HINIC3_IS_VF(nic_dev->hwdev) || !uc) {
254 list_for_each_entry_safe(f, ftmp, mac_filter_list,
255 list) {
256 if (f->state != HINIC3_MAC_HW_SYNCED)
257 continue;
258
259 fclone = hinic3_mac_filter_entry_clone(f);
260 if (!fclone)
261 break;
262
263 f->state = HINIC3_MAC_WAIT_HW_SYNC;
264 list_add_tail(&fclone->list, &tmp_del_list);
265 }
266 }
267
268 hinic3_mac_filter_sync_hw(netdev, &tmp_del_list,
269 &tmp_add_list, &add_count);
270 }
271
272 cleanup_tmp_filter_list:
273 hinic3_cleanup_filter_list(&tmp_del_list);
274 hinic3_cleanup_filter_list(&tmp_add_list);
275
276 return err ? err : add_count;
277 }
278
hinic3_mac_filter_sync_all(struct net_device * netdev)279 static void hinic3_mac_filter_sync_all(struct net_device *netdev)
280 {
281 struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
282 int add_count;
283
284 if (test_bit(HINIC3_MAC_FILTER_CHANGED, &nic_dev->flags)) {
285 clear_bit(HINIC3_MAC_FILTER_CHANGED, &nic_dev->flags);
286 add_count = hinic3_mac_filter_sync(netdev,
287 &nic_dev->uc_filter_list,
288 true);
289 if (add_count < 0 &&
290 hinic3_test_support(nic_dev, HINIC3_NIC_F_PROMISC))
291 set_bit(HINIC3_PROMISC_FORCE_ON,
292 &nic_dev->rx_mod_state);
293 else if (add_count)
294 clear_bit(HINIC3_PROMISC_FORCE_ON,
295 &nic_dev->rx_mod_state);
296
297 add_count = hinic3_mac_filter_sync(netdev,
298 &nic_dev->mc_filter_list,
299 false);
300 if (add_count < 0 &&
301 hinic3_test_support(nic_dev, HINIC3_NIC_F_ALLMULTI))
302 set_bit(HINIC3_ALLMULTI_FORCE_ON,
303 &nic_dev->rx_mod_state);
304 else if (add_count)
305 clear_bit(HINIC3_ALLMULTI_FORCE_ON,
306 &nic_dev->rx_mod_state);
307 }
308 }
309
310 #define HINIC3_DEFAULT_RX_MODE \
311 (L2NIC_RX_MODE_UC | L2NIC_RX_MODE_MC | L2NIC_RX_MODE_BC)
312
hinic3_update_mac_filter(struct net_device * netdev,const struct netdev_hw_addr_list * src_list,struct list_head * filter_list)313 static void hinic3_update_mac_filter(struct net_device *netdev,
314 const struct netdev_hw_addr_list *src_list,
315 struct list_head *filter_list)
316 {
317 struct hinic3_mac_filter *filter;
318 struct hinic3_mac_filter *ftmp;
319 struct hinic3_mac_filter *f;
320 struct netdev_hw_addr *ha;
321
322 /* add addr if not already in the filter list */
323 netif_addr_lock_bh(netdev);
324 netdev_hw_addr_list_for_each(ha, src_list) {
325 filter = hinic3_find_mac(filter_list, ha->addr);
326 if (!filter)
327 hinic3_add_filter(netdev, filter_list, ha->addr);
328 else if (filter->state == HINIC3_MAC_WAIT_HW_UNSYNC)
329 filter->state = HINIC3_MAC_HW_SYNCED;
330 }
331 netif_addr_unlock_bh(netdev);
332
333 /* delete addr if not in netdev list */
334 list_for_each_entry_safe(f, ftmp, filter_list, list) {
335 bool found = false;
336
337 netif_addr_lock_bh(netdev);
338 netdev_hw_addr_list_for_each(ha, src_list)
339 if (ether_addr_equal(ha->addr, f->addr)) {
340 found = true;
341 break;
342 }
343 netif_addr_unlock_bh(netdev);
344
345 if (found)
346 continue;
347
348 hinic3_del_filter(netdev, f);
349 }
350 }
351
hinic3_sync_rx_mode_to_hw(struct net_device * netdev,int promisc_en,int allmulti_en)352 static void hinic3_sync_rx_mode_to_hw(struct net_device *netdev, int promisc_en,
353 int allmulti_en)
354 {
355 struct hinic3_nic_dev *nic_dev = netdev_priv(netdev);
356 u32 rx_mode = HINIC3_DEFAULT_RX_MODE;
357 int err;
358
359 rx_mode |= (promisc_en ? L2NIC_RX_MODE_PROMISC : 0);
360 rx_mode |= (allmulti_en ? L2NIC_RX_MODE_MC_ALL : 0);
361
362 if (promisc_en != test_bit(HINIC3_HW_PROMISC_ON,
363 &nic_dev->rx_mod_state))
364 netdev_dbg(netdev, "%s promisc mode\n",
365 promisc_en ? "Enter" : "Left");
366 if (allmulti_en !=
367 test_bit(HINIC3_HW_ALLMULTI_ON, &nic_dev->rx_mod_state))
368 netdev_dbg(netdev, "%s all_multi mode\n",
369 allmulti_en ? "Enter" : "Left");
370
371 err = hinic3_set_rx_mode(nic_dev->hwdev, rx_mode);
372 if (err) {
373 netdev_err(netdev, "Failed to set rx_mode\n");
374 return;
375 }
376
377 promisc_en ? set_bit(HINIC3_HW_PROMISC_ON, &nic_dev->rx_mod_state) :
378 clear_bit(HINIC3_HW_PROMISC_ON, &nic_dev->rx_mod_state);
379
380 allmulti_en ? set_bit(HINIC3_HW_ALLMULTI_ON, &nic_dev->rx_mod_state) :
381 clear_bit(HINIC3_HW_ALLMULTI_ON, &nic_dev->rx_mod_state);
382 }
383
hinic3_set_rx_mode_work(struct work_struct * work)384 void hinic3_set_rx_mode_work(struct work_struct *work)
385 {
386 int promisc_en = 0, allmulti_en = 0;
387 struct hinic3_nic_dev *nic_dev;
388 struct net_device *netdev;
389
390 nic_dev = container_of(work, struct hinic3_nic_dev, rx_mode_work);
391 netdev = nic_dev->netdev;
392
393 if (test_and_clear_bit(HINIC3_UPDATE_MAC_FILTER, &nic_dev->flags)) {
394 hinic3_update_mac_filter(netdev, &netdev->uc,
395 &nic_dev->uc_filter_list);
396 hinic3_update_mac_filter(netdev, &netdev->mc,
397 &nic_dev->mc_filter_list);
398 }
399
400 hinic3_mac_filter_sync_all(netdev);
401
402 if (hinic3_test_support(nic_dev, HINIC3_NIC_F_PROMISC))
403 promisc_en = !!(netdev->flags & IFF_PROMISC) ||
404 test_bit(HINIC3_PROMISC_FORCE_ON,
405 &nic_dev->rx_mod_state);
406
407 if (hinic3_test_support(nic_dev, HINIC3_NIC_F_ALLMULTI))
408 allmulti_en = !!(netdev->flags & IFF_ALLMULTI) ||
409 test_bit(HINIC3_ALLMULTI_FORCE_ON,
410 &nic_dev->rx_mod_state);
411
412 if (promisc_en != test_bit(HINIC3_HW_PROMISC_ON,
413 &nic_dev->rx_mod_state) ||
414 allmulti_en != test_bit(HINIC3_HW_ALLMULTI_ON,
415 &nic_dev->rx_mod_state))
416 hinic3_sync_rx_mode_to_hw(netdev, promisc_en, allmulti_en);
417 }
418