1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2018 Netronome Systems, Inc. */
3
4 #include "main.h"
5
6 /* LAG group config flags. */
7 #define NFP_FL_LAG_LAST BIT(1)
8 #define NFP_FL_LAG_FIRST BIT(2)
9 #define NFP_FL_LAG_DATA BIT(3)
10 #define NFP_FL_LAG_XON BIT(4)
11 #define NFP_FL_LAG_SYNC BIT(5)
12 #define NFP_FL_LAG_SWITCH BIT(6)
13 #define NFP_FL_LAG_RESET BIT(7)
14
15 /* LAG port state flags. */
16 #define NFP_PORT_LAG_LINK_UP BIT(0)
17 #define NFP_PORT_LAG_TX_ENABLED BIT(1)
18 #define NFP_PORT_LAG_CHANGED BIT(2)
19
20 enum nfp_fl_lag_batch {
21 NFP_FL_LAG_BATCH_FIRST,
22 NFP_FL_LAG_BATCH_MEMBER,
23 NFP_FL_LAG_BATCH_FINISHED
24 };
25
26 /**
27 * struct nfp_flower_cmsg_lag_config - control message payload for LAG config
28 * @ctrl_flags: Configuration flags
29 * @reserved: Reserved for future use
30 * @ttl: Time to live of packet - host always sets to 0xff
31 * @pkt_number: Config message packet number - increment for each message
32 * @batch_ver: Batch version of messages - increment for each batch of messages
33 * @group_id: Group ID applicable
34 * @group_inst: Group instance number - increment when group is reused
35 * @members: Array of 32-bit words listing all active group members
36 */
37 struct nfp_flower_cmsg_lag_config {
38 u8 ctrl_flags;
39 u8 reserved[2];
40 u8 ttl;
41 __be32 pkt_number;
42 __be32 batch_ver;
43 __be32 group_id;
44 __be32 group_inst;
45 __be32 members[];
46 };
47
48 /**
49 * struct nfp_fl_lag_group - list entry for each LAG group
50 * @group_id: Assigned group ID for host/kernel sync
51 * @group_inst: Group instance in case of ID reuse
52 * @list: List entry
53 * @master_ndev: Group master Netdev
54 * @dirty: Marked if the group needs synced to HW
55 * @offloaded: Marked if the group is currently offloaded to NIC
56 * @to_remove: Marked if the group should be removed from NIC
57 * @to_destroy: Marked if the group should be removed from driver
58 * @slave_cnt: Number of slaves in group
59 */
60 struct nfp_fl_lag_group {
61 unsigned int group_id;
62 u8 group_inst;
63 struct list_head list;
64 struct net_device *master_ndev;
65 bool dirty;
66 bool offloaded;
67 bool to_remove;
68 bool to_destroy;
69 unsigned int slave_cnt;
70 };
71
72 #define NFP_FL_LAG_PKT_NUMBER_MASK GENMASK(30, 0)
73 #define NFP_FL_LAG_VERSION_MASK GENMASK(22, 0)
74 #define NFP_FL_LAG_HOST_TTL 0xff
75
76 /* Use this ID with zero members to ack a batch config */
77 #define NFP_FL_LAG_SYNC_ID 0
78 #define NFP_FL_LAG_GROUP_MIN 1 /* ID 0 reserved */
79 #define NFP_FL_LAG_GROUP_MAX 31 /* IDs 1 to 31 are valid */
80
81 /* wait for more config */
82 #define NFP_FL_LAG_DELAY (msecs_to_jiffies(2))
83
84 #define NFP_FL_LAG_RETRANS_LIMIT 100 /* max retrans cmsgs to store */
85
nfp_fl_get_next_pkt_number(struct nfp_fl_lag * lag)86 static unsigned int nfp_fl_get_next_pkt_number(struct nfp_fl_lag *lag)
87 {
88 lag->pkt_num++;
89 lag->pkt_num &= NFP_FL_LAG_PKT_NUMBER_MASK;
90
91 return lag->pkt_num;
92 }
93
nfp_fl_increment_version(struct nfp_fl_lag * lag)94 static void nfp_fl_increment_version(struct nfp_fl_lag *lag)
95 {
96 /* LSB is not considered by firmware so add 2 for each increment. */
97 lag->batch_ver += 2;
98 lag->batch_ver &= NFP_FL_LAG_VERSION_MASK;
99
100 /* Zero is reserved by firmware. */
101 if (!lag->batch_ver)
102 lag->batch_ver += 2;
103 }
104
105 static struct nfp_fl_lag_group *
nfp_fl_lag_group_create(struct nfp_fl_lag * lag,struct net_device * master)106 nfp_fl_lag_group_create(struct nfp_fl_lag *lag, struct net_device *master)
107 {
108 struct nfp_fl_lag_group *group;
109 struct nfp_flower_priv *priv;
110 int id;
111
112 priv = container_of(lag, struct nfp_flower_priv, nfp_lag);
113
114 id = ida_alloc_range(&lag->ida_handle, NFP_FL_LAG_GROUP_MIN,
115 NFP_FL_LAG_GROUP_MAX, GFP_KERNEL);
116 if (id < 0) {
117 nfp_flower_cmsg_warn(priv->app,
118 "No more bonding groups available\n");
119 return ERR_PTR(id);
120 }
121
122 group = kmalloc(sizeof(*group), GFP_KERNEL);
123 if (!group) {
124 ida_free(&lag->ida_handle, id);
125 return ERR_PTR(-ENOMEM);
126 }
127
128 group->group_id = id;
129 group->master_ndev = master;
130 group->dirty = true;
131 group->offloaded = false;
132 group->to_remove = false;
133 group->to_destroy = false;
134 group->slave_cnt = 0;
135 group->group_inst = ++lag->global_inst;
136 list_add_tail(&group->list, &lag->group_list);
137
138 return group;
139 }
140
141 static struct nfp_fl_lag_group *
nfp_fl_lag_find_group_for_master_with_lag(struct nfp_fl_lag * lag,struct net_device * master)142 nfp_fl_lag_find_group_for_master_with_lag(struct nfp_fl_lag *lag,
143 struct net_device *master)
144 {
145 struct nfp_fl_lag_group *entry;
146
147 if (!master)
148 return NULL;
149
150 list_for_each_entry(entry, &lag->group_list, list)
151 if (entry->master_ndev == master)
152 return entry;
153
154 return NULL;
155 }
156
nfp_fl_lag_get_group_info(struct nfp_app * app,struct net_device * netdev,__be16 * group_id,u8 * batch_ver,u8 * group_inst)157 static int nfp_fl_lag_get_group_info(struct nfp_app *app,
158 struct net_device *netdev,
159 __be16 *group_id,
160 u8 *batch_ver,
161 u8 *group_inst)
162 {
163 struct nfp_flower_priv *priv = app->priv;
164 struct nfp_fl_lag_group *group = NULL;
165 __be32 temp_vers;
166
167 mutex_lock(&priv->nfp_lag.lock);
168 group = nfp_fl_lag_find_group_for_master_with_lag(&priv->nfp_lag,
169 netdev);
170 if (!group) {
171 mutex_unlock(&priv->nfp_lag.lock);
172 return -ENOENT;
173 }
174
175 if (group_id)
176 *group_id = cpu_to_be16(group->group_id);
177
178 if (batch_ver) {
179 temp_vers = cpu_to_be32(priv->nfp_lag.batch_ver <<
180 NFP_FL_PRE_LAG_VER_OFF);
181 memcpy(batch_ver, &temp_vers, 3);
182 }
183
184 if (group_inst)
185 *group_inst = group->group_inst;
186
187 mutex_unlock(&priv->nfp_lag.lock);
188
189 return 0;
190 }
191
nfp_flower_lag_populate_pre_action(struct nfp_app * app,struct net_device * master,struct nfp_fl_pre_lag * pre_act,struct netlink_ext_ack * extack)192 int nfp_flower_lag_populate_pre_action(struct nfp_app *app,
193 struct net_device *master,
194 struct nfp_fl_pre_lag *pre_act,
195 struct netlink_ext_ack *extack)
196 {
197 if (nfp_fl_lag_get_group_info(app, master, &pre_act->group_id,
198 pre_act->lag_version,
199 &pre_act->instance)) {
200 NL_SET_ERR_MSG_MOD(extack, "invalid entry: group does not exist for LAG action");
201 return -ENOENT;
202 }
203
204 return 0;
205 }
206
nfp_flower_lag_get_info_from_netdev(struct nfp_app * app,struct net_device * netdev,struct nfp_tun_neigh_lag * lag)207 void nfp_flower_lag_get_info_from_netdev(struct nfp_app *app,
208 struct net_device *netdev,
209 struct nfp_tun_neigh_lag *lag)
210 {
211 nfp_fl_lag_get_group_info(app, netdev, NULL,
212 lag->lag_version, &lag->lag_instance);
213 }
214
nfp_flower_lag_get_output_id(struct nfp_app * app,struct net_device * master)215 int nfp_flower_lag_get_output_id(struct nfp_app *app, struct net_device *master)
216 {
217 struct nfp_flower_priv *priv = app->priv;
218 struct nfp_fl_lag_group *group = NULL;
219 int group_id = -ENOENT;
220
221 mutex_lock(&priv->nfp_lag.lock);
222 group = nfp_fl_lag_find_group_for_master_with_lag(&priv->nfp_lag,
223 master);
224 if (group)
225 group_id = group->group_id;
226 mutex_unlock(&priv->nfp_lag.lock);
227
228 return group_id;
229 }
230
231 static int
nfp_fl_lag_config_group(struct nfp_fl_lag * lag,struct nfp_fl_lag_group * group,struct net_device ** active_members,unsigned int member_cnt,enum nfp_fl_lag_batch * batch)232 nfp_fl_lag_config_group(struct nfp_fl_lag *lag, struct nfp_fl_lag_group *group,
233 struct net_device **active_members,
234 unsigned int member_cnt, enum nfp_fl_lag_batch *batch)
235 {
236 struct nfp_flower_cmsg_lag_config *cmsg_payload;
237 struct nfp_flower_priv *priv;
238 unsigned long int flags;
239 unsigned int size, i;
240 struct sk_buff *skb;
241
242 priv = container_of(lag, struct nfp_flower_priv, nfp_lag);
243 size = sizeof(*cmsg_payload) + sizeof(__be32) * member_cnt;
244 skb = nfp_flower_cmsg_alloc(priv->app, size,
245 NFP_FLOWER_CMSG_TYPE_LAG_CONFIG,
246 GFP_KERNEL);
247 if (!skb)
248 return -ENOMEM;
249
250 cmsg_payload = nfp_flower_cmsg_get_data(skb);
251 flags = 0;
252
253 /* Increment batch version for each new batch of config messages. */
254 if (*batch == NFP_FL_LAG_BATCH_FIRST) {
255 flags |= NFP_FL_LAG_FIRST;
256 nfp_fl_increment_version(lag);
257 *batch = NFP_FL_LAG_BATCH_MEMBER;
258 }
259
260 /* If it is a reset msg then it is also the end of the batch. */
261 if (lag->rst_cfg) {
262 flags |= NFP_FL_LAG_RESET;
263 *batch = NFP_FL_LAG_BATCH_FINISHED;
264 }
265
266 /* To signal the end of a batch, both the switch and last flags are set
267 * and the reserved SYNC group ID is used.
268 */
269 if (*batch == NFP_FL_LAG_BATCH_FINISHED) {
270 flags |= NFP_FL_LAG_SWITCH | NFP_FL_LAG_LAST;
271 lag->rst_cfg = false;
272 cmsg_payload->group_id = cpu_to_be32(NFP_FL_LAG_SYNC_ID);
273 cmsg_payload->group_inst = 0;
274 } else {
275 cmsg_payload->group_id = cpu_to_be32(group->group_id);
276 cmsg_payload->group_inst = cpu_to_be32(group->group_inst);
277 }
278
279 cmsg_payload->reserved[0] = 0;
280 cmsg_payload->reserved[1] = 0;
281 cmsg_payload->ttl = NFP_FL_LAG_HOST_TTL;
282 cmsg_payload->ctrl_flags = flags;
283 cmsg_payload->batch_ver = cpu_to_be32(lag->batch_ver);
284 cmsg_payload->pkt_number = cpu_to_be32(nfp_fl_get_next_pkt_number(lag));
285
286 for (i = 0; i < member_cnt; i++)
287 cmsg_payload->members[i] =
288 cpu_to_be32(nfp_repr_get_port_id(active_members[i]));
289
290 nfp_ctrl_tx(priv->app->ctrl, skb);
291 return 0;
292 }
293
nfp_fl_lag_do_work(struct work_struct * work)294 static void nfp_fl_lag_do_work(struct work_struct *work)
295 {
296 enum nfp_fl_lag_batch batch = NFP_FL_LAG_BATCH_FIRST;
297 struct nfp_fl_lag_group *entry, *storage;
298 struct delayed_work *delayed_work;
299 struct nfp_flower_priv *priv;
300 struct nfp_fl_lag *lag;
301 int err;
302
303 delayed_work = to_delayed_work(work);
304 lag = container_of(delayed_work, struct nfp_fl_lag, work);
305 priv = container_of(lag, struct nfp_flower_priv, nfp_lag);
306
307 mutex_lock(&lag->lock);
308 list_for_each_entry_safe(entry, storage, &lag->group_list, list) {
309 struct net_device *iter_netdev, **acti_netdevs;
310 struct nfp_flower_repr_priv *repr_priv;
311 int active_count = 0, slaves = 0;
312 struct nfp_repr *repr;
313 unsigned long *flags;
314
315 if (entry->to_remove) {
316 /* Active count of 0 deletes group on hw. */
317 err = nfp_fl_lag_config_group(lag, entry, NULL, 0,
318 &batch);
319 if (!err) {
320 entry->to_remove = false;
321 entry->offloaded = false;
322 } else {
323 nfp_flower_cmsg_warn(priv->app,
324 "group delete failed\n");
325 schedule_delayed_work(&lag->work,
326 NFP_FL_LAG_DELAY);
327 continue;
328 }
329
330 if (entry->to_destroy) {
331 ida_free(&lag->ida_handle, entry->group_id);
332 list_del(&entry->list);
333 kfree(entry);
334 }
335 continue;
336 }
337
338 acti_netdevs = kmalloc_array(entry->slave_cnt,
339 sizeof(*acti_netdevs), GFP_KERNEL);
340 if (!acti_netdevs) {
341 schedule_delayed_work(&lag->work,
342 NFP_FL_LAG_DELAY);
343 continue;
344 }
345
346 /* Include sanity check in the loop. It may be that a bond has
347 * changed between processing the last notification and the
348 * work queue triggering. If the number of slaves has changed
349 * or it now contains netdevs that cannot be offloaded, ignore
350 * the group until pending notifications are processed.
351 */
352 rcu_read_lock();
353 for_each_netdev_in_bond_rcu(entry->master_ndev, iter_netdev) {
354 if (!nfp_netdev_is_nfp_repr(iter_netdev)) {
355 slaves = 0;
356 break;
357 }
358
359 repr = netdev_priv(iter_netdev);
360
361 if (repr->app != priv->app) {
362 slaves = 0;
363 break;
364 }
365
366 slaves++;
367 if (slaves > entry->slave_cnt)
368 break;
369
370 /* Check the ports for state changes. */
371 repr_priv = repr->app_priv;
372 flags = &repr_priv->lag_port_flags;
373
374 if (*flags & NFP_PORT_LAG_CHANGED) {
375 *flags &= ~NFP_PORT_LAG_CHANGED;
376 entry->dirty = true;
377 }
378
379 if ((*flags & NFP_PORT_LAG_TX_ENABLED) &&
380 (*flags & NFP_PORT_LAG_LINK_UP))
381 acti_netdevs[active_count++] = iter_netdev;
382 }
383 rcu_read_unlock();
384
385 if (slaves != entry->slave_cnt || !entry->dirty) {
386 kfree(acti_netdevs);
387 continue;
388 }
389
390 err = nfp_fl_lag_config_group(lag, entry, acti_netdevs,
391 active_count, &batch);
392 if (!err) {
393 entry->offloaded = true;
394 entry->dirty = false;
395 } else {
396 nfp_flower_cmsg_warn(priv->app,
397 "group offload failed\n");
398 schedule_delayed_work(&lag->work, NFP_FL_LAG_DELAY);
399 }
400
401 kfree(acti_netdevs);
402 }
403
404 /* End the config batch if at least one packet has been batched. */
405 if (batch == NFP_FL_LAG_BATCH_MEMBER) {
406 batch = NFP_FL_LAG_BATCH_FINISHED;
407 err = nfp_fl_lag_config_group(lag, NULL, NULL, 0, &batch);
408 if (err)
409 nfp_flower_cmsg_warn(priv->app,
410 "group batch end cmsg failed\n");
411 }
412
413 mutex_unlock(&lag->lock);
414 }
415
416 static int
nfp_fl_lag_put_unprocessed(struct nfp_fl_lag * lag,struct sk_buff * skb)417 nfp_fl_lag_put_unprocessed(struct nfp_fl_lag *lag, struct sk_buff *skb)
418 {
419 struct nfp_flower_cmsg_lag_config *cmsg_payload;
420
421 cmsg_payload = nfp_flower_cmsg_get_data(skb);
422 if (be32_to_cpu(cmsg_payload->group_id) > NFP_FL_LAG_GROUP_MAX)
423 return -EINVAL;
424
425 /* Drop cmsg retrans if storage limit is exceeded to prevent
426 * overloading. If the fw notices that expected messages have not been
427 * received in a given time block, it will request a full resync.
428 */
429 if (skb_queue_len(&lag->retrans_skbs) >= NFP_FL_LAG_RETRANS_LIMIT)
430 return -ENOSPC;
431
432 __skb_queue_tail(&lag->retrans_skbs, skb);
433
434 return 0;
435 }
436
nfp_fl_send_unprocessed(struct nfp_fl_lag * lag)437 static void nfp_fl_send_unprocessed(struct nfp_fl_lag *lag)
438 {
439 struct nfp_flower_priv *priv;
440 struct sk_buff *skb;
441
442 priv = container_of(lag, struct nfp_flower_priv, nfp_lag);
443
444 while ((skb = __skb_dequeue(&lag->retrans_skbs)))
445 nfp_ctrl_tx(priv->app->ctrl, skb);
446 }
447
nfp_flower_lag_unprocessed_msg(struct nfp_app * app,struct sk_buff * skb)448 bool nfp_flower_lag_unprocessed_msg(struct nfp_app *app, struct sk_buff *skb)
449 {
450 struct nfp_flower_cmsg_lag_config *cmsg_payload;
451 struct nfp_flower_priv *priv = app->priv;
452 struct nfp_fl_lag_group *group_entry;
453 unsigned long int flags;
454 bool store_skb = false;
455 int err;
456
457 cmsg_payload = nfp_flower_cmsg_get_data(skb);
458 flags = cmsg_payload->ctrl_flags;
459
460 /* Note the intentional fall through below. If DATA and XON are both
461 * set, the message will stored and sent again with the rest of the
462 * unprocessed messages list.
463 */
464
465 /* Store */
466 if (flags & NFP_FL_LAG_DATA)
467 if (!nfp_fl_lag_put_unprocessed(&priv->nfp_lag, skb))
468 store_skb = true;
469
470 /* Send stored */
471 if (flags & NFP_FL_LAG_XON)
472 nfp_fl_send_unprocessed(&priv->nfp_lag);
473
474 /* Resend all */
475 if (flags & NFP_FL_LAG_SYNC) {
476 /* To resend all config:
477 * 1) Clear all unprocessed messages
478 * 2) Mark all groups dirty
479 * 3) Reset NFP group config
480 * 4) Schedule a LAG config update
481 */
482
483 __skb_queue_purge(&priv->nfp_lag.retrans_skbs);
484
485 mutex_lock(&priv->nfp_lag.lock);
486 list_for_each_entry(group_entry, &priv->nfp_lag.group_list,
487 list)
488 group_entry->dirty = true;
489
490 err = nfp_flower_lag_reset(&priv->nfp_lag);
491 if (err)
492 nfp_flower_cmsg_warn(priv->app,
493 "mem err in group reset msg\n");
494 mutex_unlock(&priv->nfp_lag.lock);
495
496 schedule_delayed_work(&priv->nfp_lag.work, 0);
497 }
498
499 return store_skb;
500 }
501
502 static void
nfp_fl_lag_schedule_group_remove(struct nfp_fl_lag * lag,struct nfp_fl_lag_group * group)503 nfp_fl_lag_schedule_group_remove(struct nfp_fl_lag *lag,
504 struct nfp_fl_lag_group *group)
505 {
506 group->to_remove = true;
507
508 schedule_delayed_work(&lag->work, NFP_FL_LAG_DELAY);
509 }
510
511 static void
nfp_fl_lag_schedule_group_delete(struct nfp_fl_lag * lag,struct net_device * master)512 nfp_fl_lag_schedule_group_delete(struct nfp_fl_lag *lag,
513 struct net_device *master)
514 {
515 struct nfp_fl_lag_group *group;
516 struct nfp_flower_priv *priv;
517
518 priv = container_of(lag, struct nfp_flower_priv, nfp_lag);
519
520 if (!netif_is_bond_master(master))
521 return;
522
523 mutex_lock(&lag->lock);
524 group = nfp_fl_lag_find_group_for_master_with_lag(lag, master);
525 if (!group) {
526 mutex_unlock(&lag->lock);
527 nfp_warn(priv->app->cpp, "untracked bond got unregistered %s\n",
528 netdev_name(master));
529 return;
530 }
531
532 group->to_remove = true;
533 group->to_destroy = true;
534 mutex_unlock(&lag->lock);
535
536 schedule_delayed_work(&lag->work, NFP_FL_LAG_DELAY);
537 }
538
539 static int
nfp_fl_lag_changeupper_event(struct nfp_fl_lag * lag,struct netdev_notifier_changeupper_info * info)540 nfp_fl_lag_changeupper_event(struct nfp_fl_lag *lag,
541 struct netdev_notifier_changeupper_info *info)
542 {
543 struct net_device *upper = info->upper_dev, *iter_netdev;
544 struct netdev_lag_upper_info *lag_upper_info;
545 struct nfp_fl_lag_group *group;
546 struct nfp_flower_priv *priv;
547 unsigned int slave_count = 0;
548 bool can_offload = true;
549 struct nfp_repr *repr;
550
551 if (!netif_is_lag_master(upper))
552 return 0;
553
554 priv = container_of(lag, struct nfp_flower_priv, nfp_lag);
555
556 rcu_read_lock();
557 for_each_netdev_in_bond_rcu(upper, iter_netdev) {
558 if (!nfp_netdev_is_nfp_repr(iter_netdev)) {
559 can_offload = false;
560 break;
561 }
562 repr = netdev_priv(iter_netdev);
563
564 /* Ensure all ports are created by the same app/on same card. */
565 if (repr->app != priv->app) {
566 can_offload = false;
567 break;
568 }
569
570 slave_count++;
571 }
572 rcu_read_unlock();
573
574 lag_upper_info = info->upper_info;
575
576 /* Firmware supports active/backup and L3/L4 hash bonds. */
577 if (lag_upper_info &&
578 lag_upper_info->tx_type != NETDEV_LAG_TX_TYPE_ACTIVEBACKUP &&
579 (lag_upper_info->tx_type != NETDEV_LAG_TX_TYPE_HASH ||
580 (lag_upper_info->hash_type != NETDEV_LAG_HASH_L34 &&
581 lag_upper_info->hash_type != NETDEV_LAG_HASH_E34 &&
582 lag_upper_info->hash_type != NETDEV_LAG_HASH_UNKNOWN))) {
583 can_offload = false;
584 nfp_flower_cmsg_warn(priv->app,
585 "Unable to offload tx_type %u hash %u\n",
586 lag_upper_info->tx_type,
587 lag_upper_info->hash_type);
588 }
589
590 mutex_lock(&lag->lock);
591 group = nfp_fl_lag_find_group_for_master_with_lag(lag, upper);
592
593 if (slave_count == 0 || !can_offload) {
594 /* Cannot offload the group - remove if previously offloaded. */
595 if (group && group->offloaded)
596 nfp_fl_lag_schedule_group_remove(lag, group);
597
598 mutex_unlock(&lag->lock);
599 return 0;
600 }
601
602 if (!group) {
603 group = nfp_fl_lag_group_create(lag, upper);
604 if (IS_ERR(group)) {
605 mutex_unlock(&lag->lock);
606 return PTR_ERR(group);
607 }
608 }
609
610 group->dirty = true;
611 group->slave_cnt = slave_count;
612
613 /* Group may have been on queue for removal but is now offloadable. */
614 group->to_remove = false;
615 mutex_unlock(&lag->lock);
616
617 schedule_delayed_work(&lag->work, NFP_FL_LAG_DELAY);
618 return 0;
619 }
620
621 static void
nfp_fl_lag_changels_event(struct nfp_fl_lag * lag,struct net_device * netdev,struct netdev_notifier_changelowerstate_info * info)622 nfp_fl_lag_changels_event(struct nfp_fl_lag *lag, struct net_device *netdev,
623 struct netdev_notifier_changelowerstate_info *info)
624 {
625 struct netdev_lag_lower_state_info *lag_lower_info;
626 struct nfp_flower_repr_priv *repr_priv;
627 struct nfp_flower_priv *priv;
628 struct nfp_repr *repr;
629 unsigned long *flags;
630
631 if (!netif_is_lag_port(netdev) || !nfp_netdev_is_nfp_repr(netdev))
632 return;
633
634 lag_lower_info = info->lower_state_info;
635 if (!lag_lower_info)
636 return;
637
638 priv = container_of(lag, struct nfp_flower_priv, nfp_lag);
639 repr = netdev_priv(netdev);
640
641 /* Verify that the repr is associated with this app. */
642 if (repr->app != priv->app)
643 return;
644
645 repr_priv = repr->app_priv;
646 flags = &repr_priv->lag_port_flags;
647
648 mutex_lock(&lag->lock);
649 if (lag_lower_info->link_up)
650 *flags |= NFP_PORT_LAG_LINK_UP;
651 else
652 *flags &= ~NFP_PORT_LAG_LINK_UP;
653
654 if (lag_lower_info->tx_enabled)
655 *flags |= NFP_PORT_LAG_TX_ENABLED;
656 else
657 *flags &= ~NFP_PORT_LAG_TX_ENABLED;
658
659 *flags |= NFP_PORT_LAG_CHANGED;
660 mutex_unlock(&lag->lock);
661
662 schedule_delayed_work(&lag->work, NFP_FL_LAG_DELAY);
663 }
664
nfp_flower_lag_netdev_event(struct nfp_flower_priv * priv,struct net_device * netdev,unsigned long event,void * ptr)665 int nfp_flower_lag_netdev_event(struct nfp_flower_priv *priv,
666 struct net_device *netdev,
667 unsigned long event, void *ptr)
668 {
669 struct nfp_fl_lag *lag = &priv->nfp_lag;
670 int err;
671
672 switch (event) {
673 case NETDEV_CHANGEUPPER:
674 err = nfp_fl_lag_changeupper_event(lag, ptr);
675 if (err)
676 return NOTIFY_BAD;
677 return NOTIFY_OK;
678 case NETDEV_CHANGELOWERSTATE:
679 nfp_fl_lag_changels_event(lag, netdev, ptr);
680 return NOTIFY_OK;
681 case NETDEV_UNREGISTER:
682 nfp_fl_lag_schedule_group_delete(lag, netdev);
683 return NOTIFY_OK;
684 }
685
686 return NOTIFY_DONE;
687 }
688
nfp_flower_lag_reset(struct nfp_fl_lag * lag)689 int nfp_flower_lag_reset(struct nfp_fl_lag *lag)
690 {
691 enum nfp_fl_lag_batch batch = NFP_FL_LAG_BATCH_FIRST;
692
693 lag->rst_cfg = true;
694 return nfp_fl_lag_config_group(lag, NULL, NULL, 0, &batch);
695 }
696
nfp_flower_lag_init(struct nfp_fl_lag * lag)697 void nfp_flower_lag_init(struct nfp_fl_lag *lag)
698 {
699 INIT_DELAYED_WORK(&lag->work, nfp_fl_lag_do_work);
700 INIT_LIST_HEAD(&lag->group_list);
701 mutex_init(&lag->lock);
702 ida_init(&lag->ida_handle);
703
704 __skb_queue_head_init(&lag->retrans_skbs);
705
706 /* 0 is a reserved batch version so increment to first valid value. */
707 nfp_fl_increment_version(lag);
708 }
709
nfp_flower_lag_cleanup(struct nfp_fl_lag * lag)710 void nfp_flower_lag_cleanup(struct nfp_fl_lag *lag)
711 {
712 struct nfp_fl_lag_group *entry, *storage;
713
714 cancel_delayed_work_sync(&lag->work);
715
716 __skb_queue_purge(&lag->retrans_skbs);
717
718 /* Remove all groups. */
719 mutex_lock(&lag->lock);
720 list_for_each_entry_safe(entry, storage, &lag->group_list, list) {
721 list_del(&entry->list);
722 kfree(entry);
723 }
724 mutex_unlock(&lag->lock);
725 mutex_destroy(&lag->lock);
726 ida_destroy(&lag->ida_handle);
727 }
728