hsr_device.c

  1// SPDX-License-Identifier: GPL-2.0
  2/* Copyright 2011-2014 Autronica Fire and Security AS
  3 *
  4 * Author(s):
  5 *	2011-2014 Arvid Brodin, arvid.brodin@alten.se
  6 * This file contains device methods for creating, using and destroying
  7 * virtual HSR or PRP devices.
  8 */
  9
 10#include <linux/netdevice.h>
 11#include <linux/skbuff.h>
 12#include <linux/etherdevice.h>
 13#include <linux/rtnetlink.h>
 14#include <linux/pkt_sched.h>
 15#include "hsr_device.h"
 16#include "hsr_slave.h"
 17#include "hsr_framereg.h"
 18#include "hsr_main.h"
 19#include "hsr_forward.h"
 20
 21static bool is_admin_up(struct net_device *dev)
 22{
 23	return dev && (dev->flags & IFF_UP);
 24}
 25
 26static bool is_slave_up(struct net_device *dev)
 27{
 28	return dev && is_admin_up(dev) && netif_oper_up(dev);
 29}
 30
 31static void hsr_set_operstate(struct hsr_port *master, bool has_carrier)
 32{
 33	struct net_device *dev = master->dev;
 34
 35	if (!is_admin_up(dev)) {
 36		netif_set_operstate(dev, IF_OPER_DOWN);
 37		return;
 38	}
 39
 40	if (has_carrier)
 41		netif_set_operstate(dev, IF_OPER_UP);
 42	else
 43		netif_set_operstate(dev, IF_OPER_LOWERLAYERDOWN);
 44}
 45
 46static bool hsr_check_carrier(struct hsr_port *master)
 47{
 48	struct hsr_port *port;
 49
 50	ASSERT_RTNL();
 51
 52	hsr_for_each_port_rtnl(master->hsr, port) {
 53		if (port->type != HSR_PT_MASTER && is_slave_up(port->dev)) {
 54			netif_carrier_on(master->dev);
 55			return true;
 56		}
 57	}
 58
 59	netif_carrier_off(master->dev);
 60
 61	return false;
 62}
 63
 64static void hsr_check_announce(struct net_device *hsr_dev)
 65{
 66	struct hsr_priv *hsr;
 67
 68	hsr = netdev_priv(hsr_dev);
 69	if (netif_running(hsr_dev) && netif_oper_up(hsr_dev)) {
 70		/* Enable announce timer and start sending supervisory frames */
 71		if (!timer_pending(&hsr->announce_timer)) {
 72			hsr->announce_count = 0;
 73			mod_timer(&hsr->announce_timer, jiffies +
 74				  msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL));
 75		}
 76
 77		if (hsr->redbox && !timer_pending(&hsr->announce_proxy_timer))
 78			mod_timer(&hsr->announce_proxy_timer, jiffies +
 79				  msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL) / 2);
 80	} else {
 81		/* Deactivate the announce timer  */
 82		timer_delete(&hsr->announce_timer);
 83		if (hsr->redbox)
 84			timer_delete(&hsr->announce_proxy_timer);
 85	}
 86}
 87
 88void hsr_check_carrier_and_operstate(struct hsr_priv *hsr)
 89{
 90	struct hsr_port *master;
 91	bool has_carrier;
 92
 93	master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
 94	/* netif_stacked_transfer_operstate() cannot be used here since
 95	 * it doesn't set IF_OPER_LOWERLAYERDOWN (?)
 96	 */
 97	has_carrier = hsr_check_carrier(master);
 98	hsr_set_operstate(master, has_carrier);
 99	hsr_check_announce(master->dev);
100}
101
102int hsr_get_max_mtu(struct hsr_priv *hsr)
103{
104	unsigned int mtu_max;
105	struct hsr_port *port;
106
107	mtu_max = ETH_DATA_LEN;
108	hsr_for_each_port_rtnl(hsr, port)
109		if (port->type != HSR_PT_MASTER)
110			mtu_max = min(port->dev->mtu, mtu_max);
111
112	if (mtu_max < HSR_HLEN)
113		return 0;
114	return mtu_max - HSR_HLEN;
115}
116
117static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu)
118{
119	struct hsr_priv *hsr;
120
121	hsr = netdev_priv(dev);
122
123	if (new_mtu > hsr_get_max_mtu(hsr)) {
124		netdev_info(dev, "A HSR master's MTU cannot be greater than the smallest MTU of its slaves minus the HSR Tag length (%d octets).\n",
125			    HSR_HLEN);
126		return -EINVAL;
127	}
128
129	WRITE_ONCE(dev->mtu, new_mtu);
130
131	return 0;
132}
133
134static int hsr_dev_open(struct net_device *dev)
135{
136	struct hsr_priv *hsr;
137	struct hsr_port *port;
138	const char *designation = NULL;
139
140	hsr = netdev_priv(dev);
141
142	hsr_for_each_port_rtnl(hsr, port) {
143		if (port->type == HSR_PT_MASTER)
144			continue;
145		switch (port->type) {
146		case HSR_PT_SLAVE_A:
147			designation = "Slave A";
148			break;
149		case HSR_PT_SLAVE_B:
150			designation = "Slave B";
151			break;
152		case HSR_PT_INTERLINK:
153			designation = "Interlink";
154			break;
155		default:
156			designation = "Unknown";
157		}
158		if (!is_slave_up(port->dev))
159			netdev_warn(dev, "%s (%s) is not up; please bring it up to get a fully working HSR network\n",
160				    designation, port->dev->name);
161	}
162
163	if (!designation)
164		netdev_warn(dev, "No slave devices configured\n");
165
166	return 0;
167}
168
169static int hsr_dev_close(struct net_device *dev)
170{
171	struct hsr_port *port;
172	struct hsr_priv *hsr;
173
174	hsr = netdev_priv(dev);
175	hsr_for_each_port_rtnl(hsr, port) {
176		if (port->type == HSR_PT_MASTER)
177			continue;
178		switch (port->type) {
179		case HSR_PT_SLAVE_A:
180		case HSR_PT_SLAVE_B:
181			dev_uc_unsync(port->dev, dev);
182			dev_mc_unsync(port->dev, dev);
183			break;
184		default:
185			break;
186		}
187	}
188
189	return 0;
190}
191
192static netdev_features_t hsr_features_recompute(struct hsr_priv *hsr,
193						netdev_features_t features)
194{
195	netdev_features_t mask;
196	struct hsr_port *port;
197
198	mask = features;
199
200	/* Mask out all features that, if supported by one device, should be
201	 * enabled for all devices (see NETIF_F_ONE_FOR_ALL).
202	 *
203	 * Anything that's off in mask will not be enabled - so only things
204	 * that were in features originally, and also is in NETIF_F_ONE_FOR_ALL,
205	 * may become enabled.
206	 */
207	features &= ~NETIF_F_ONE_FOR_ALL;
208	hsr_for_each_port_rtnl(hsr, port)
209		features = netdev_increment_features(features,
210						     port->dev->features,
211						     mask);
212
213	return features;
214}
215
216static netdev_features_t hsr_fix_features(struct net_device *dev,
217					  netdev_features_t features)
218{
219	struct hsr_priv *hsr = netdev_priv(dev);
220
221	return hsr_features_recompute(hsr, features);
222}
223
224static netdev_tx_t hsr_dev_xmit(struct sk_buff *skb, struct net_device *dev)
225{
226	struct hsr_priv *hsr = netdev_priv(dev);
227	struct hsr_port *master;
228
229	rcu_read_lock();
230	master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
231	if (master) {
232		skb->dev = master->dev;
233		skb_reset_mac_header(skb);
234		skb_reset_mac_len(skb);
235		spin_lock_bh(&hsr->seqnr_lock);
236		hsr_forward_skb(skb, master);
237		spin_unlock_bh(&hsr->seqnr_lock);
238	} else {
239		dev_core_stats_tx_dropped_inc(dev);
240		dev_kfree_skb_any(skb);
241	}
242	rcu_read_unlock();
243
244	return NETDEV_TX_OK;
245}
246
247static const struct header_ops hsr_header_ops = {
248	.create	 = eth_header,
249	.parse	 = eth_header_parse,
250};
251
252static struct sk_buff *hsr_init_skb(struct hsr_port *master, int extra)
253{
254	struct hsr_priv *hsr = master->hsr;
255	struct sk_buff *skb;
256	int hlen, tlen;
257	int len;
258
259	hlen = LL_RESERVED_SPACE(master->dev);
260	tlen = master->dev->needed_tailroom;
261	len = sizeof(struct hsr_sup_tag) + sizeof(struct hsr_sup_payload);
262	/* skb size is same for PRP/HSR frames, only difference
263	 * being, for PRP it is a trailer and for HSR it is a
264	 * header.
265	 * RedBox might use @extra more bytes.
266	 */
267	skb = dev_alloc_skb(len + extra + hlen + tlen);
268
269	if (!skb)
270		return skb;
271
272	skb_reserve(skb, hlen);
273	skb->dev = master->dev;
274	skb->priority = TC_PRIO_CONTROL;
275
276	skb_reset_network_header(skb);
277	skb_reset_transport_header(skb);
278	if (dev_hard_header(skb, skb->dev, ETH_P_PRP,
279			    hsr->sup_multicast_addr,
280			    skb->dev->dev_addr, skb->len) <= 0)
281		goto out;
282
283	skb_reset_mac_header(skb);
284	skb_reset_mac_len(skb);
285
286	return skb;
287out:
288	kfree_skb(skb);
289
290	return NULL;
291}
292
293static void send_hsr_supervision_frame(struct hsr_port *port,
294				       unsigned long *interval,
295				       const unsigned char *addr)
296{
297	struct hsr_priv *hsr = port->hsr;
298	__u8 type = HSR_TLV_LIFE_CHECK;
299	struct hsr_sup_payload *hsr_sp;
300	struct hsr_sup_tlv *hsr_stlv;
301	struct hsr_sup_tag *hsr_stag;
302	struct sk_buff *skb;
303	int extra = 0;
304
305	*interval = msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL);
306	if (hsr->announce_count < 3 && hsr->prot_version == 0) {
307		type = HSR_TLV_ANNOUNCE;
308		*interval = msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL);
309		hsr->announce_count++;
310	}
311
312	if (hsr->redbox)
313		extra = sizeof(struct hsr_sup_tlv) +
314			sizeof(struct hsr_sup_payload);
315
316	skb = hsr_init_skb(port, extra);
317	if (!skb) {
318		netdev_warn_once(port->dev, "HSR: Could not send supervision frame\n");
319		return;
320	}
321
322	hsr_stag = skb_put(skb, sizeof(struct hsr_sup_tag));
323	skb_set_network_header(skb, ETH_HLEN + HSR_HLEN);
324	skb_reset_mac_len(skb);
325
326	set_hsr_stag_path(hsr_stag, (hsr->prot_version ? 0x0 : 0xf));
327	set_hsr_stag_HSR_ver(hsr_stag, hsr->prot_version);
328
329	/* From HSRv1 on we have separate supervision sequence numbers. */
330	spin_lock_bh(&hsr->seqnr_lock);
331	if (hsr->prot_version > 0) {
332		hsr_stag->sequence_nr = htons(hsr->sup_sequence_nr);
333		hsr->sup_sequence_nr++;
334	} else {
335		hsr_stag->sequence_nr = htons(hsr->sequence_nr);
336		hsr->sequence_nr++;
337	}
338
339	hsr_stag->tlv.HSR_TLV_type = type;
340	/* HSRv0 has 6 unused bytes after the MAC */
341	hsr_stag->tlv.HSR_TLV_length = hsr->prot_version ?
342				sizeof(struct hsr_sup_payload) : 12;
343
344	/* Payload: MacAddressA / SAN MAC from ProxyNodeTable */
345	hsr_sp = skb_put(skb, sizeof(struct hsr_sup_payload));
346	ether_addr_copy(hsr_sp->macaddress_A, addr);
347
348	if (hsr->redbox &&
349	    hsr_is_node_in_db(&hsr->proxy_node_db, addr)) {
350		hsr_stlv = skb_put(skb, sizeof(struct hsr_sup_tlv));
351		hsr_stlv->HSR_TLV_type = PRP_TLV_REDBOX_MAC;
352		hsr_stlv->HSR_TLV_length = sizeof(struct hsr_sup_payload);
353
354		/* Payload: MacAddressRedBox */
355		hsr_sp = skb_put(skb, sizeof(struct hsr_sup_payload));
356		ether_addr_copy(hsr_sp->macaddress_A, hsr->macaddress_redbox);
357	}
358
359	if (skb_put_padto(skb, ETH_ZLEN)) {
360		spin_unlock_bh(&hsr->seqnr_lock);
361		return;
362	}
363
364	hsr_forward_skb(skb, port);
365	spin_unlock_bh(&hsr->seqnr_lock);
366	return;
367}
368
369static void send_prp_supervision_frame(struct hsr_port *master,
370				       unsigned long *interval,
371				       const unsigned char *addr)
372{
373	struct hsr_priv *hsr = master->hsr;
374	struct hsr_sup_payload *hsr_sp;
375	struct hsr_sup_tag *hsr_stag;
376	struct sk_buff *skb;
377
378	skb = hsr_init_skb(master, 0);
379	if (!skb) {
380		netdev_warn_once(master->dev, "PRP: Could not send supervision frame\n");
381		return;
382	}
383
384	*interval = msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL);
385	hsr_stag = skb_put(skb, sizeof(struct hsr_sup_tag));
386	set_hsr_stag_path(hsr_stag, (hsr->prot_version ? 0x0 : 0xf));
387	set_hsr_stag_HSR_ver(hsr_stag, (hsr->prot_version ? 1 : 0));
388
389	/* From HSRv1 on we have separate supervision sequence numbers. */
390	spin_lock_bh(&hsr->seqnr_lock);
391	hsr_stag->sequence_nr = htons(hsr->sup_sequence_nr);
392	hsr->sup_sequence_nr++;
393	hsr_stag->tlv.HSR_TLV_type = PRP_TLV_LIFE_CHECK_DD;
394	hsr_stag->tlv.HSR_TLV_length = sizeof(struct hsr_sup_payload);
395
396	/* Payload: MacAddressA */
397	hsr_sp = skb_put(skb, sizeof(struct hsr_sup_payload));
398	ether_addr_copy(hsr_sp->macaddress_A, master->dev->dev_addr);
399
400	if (skb_put_padto(skb, ETH_ZLEN)) {
401		spin_unlock_bh(&hsr->seqnr_lock);
402		return;
403	}
404
405	hsr_forward_skb(skb, master);
406	spin_unlock_bh(&hsr->seqnr_lock);
407}
408
409/* Announce (supervision frame) timer function
410 */
411static void hsr_announce(struct timer_list *t)
412{
413	struct hsr_priv *hsr;
414	struct hsr_port *master;
415	unsigned long interval;
416
417	hsr = timer_container_of(hsr, t, announce_timer);
418
419	rcu_read_lock();
420	master = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
421	hsr->proto_ops->send_sv_frame(master, &interval, master->dev->dev_addr);
422
423	if (is_admin_up(master->dev))
424		mod_timer(&hsr->announce_timer, jiffies + interval);
425
426	rcu_read_unlock();
427}
428
429/* Announce (supervision frame) timer function for RedBox
430 */
431static void hsr_proxy_announce(struct timer_list *t)
432{
433	struct hsr_priv *hsr = timer_container_of(hsr, t,
434						  announce_proxy_timer);
435	struct hsr_port *interlink;
436	unsigned long interval = 0;
437	struct hsr_node *node;
438
439	rcu_read_lock();
440	/* RedBOX sends supervisory frames to HSR network with MAC addresses
441	 * of SAN nodes stored in ProxyNodeTable.
442	 */
443	interlink = hsr_port_get_hsr(hsr, HSR_PT_INTERLINK);
444	if (!interlink)
445		goto done;
446
447	list_for_each_entry_rcu(node, &hsr->proxy_node_db, mac_list) {
448		if (hsr_addr_is_redbox(hsr, node->macaddress_A))
449			continue;
450		hsr->proto_ops->send_sv_frame(interlink, &interval,
451					      node->macaddress_A);
452	}
453
454	if (is_admin_up(interlink->dev)) {
455		if (!interval)
456			interval = msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL);
457
458		mod_timer(&hsr->announce_proxy_timer, jiffies + interval);
459	}
460
461done:
462	rcu_read_unlock();
463}
464
465void hsr_del_ports(struct hsr_priv *hsr)
466{
467	struct hsr_port *port;
468
469	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_A);
470	if (port)
471		hsr_del_port(port);
472
473	port = hsr_port_get_hsr(hsr, HSR_PT_SLAVE_B);
474	if (port)
475		hsr_del_port(port);
476
477	port = hsr_port_get_hsr(hsr, HSR_PT_INTERLINK);
478	if (port)
479		hsr_del_port(port);
480
481	port = hsr_port_get_hsr(hsr, HSR_PT_MASTER);
482	if (port)
483		hsr_del_port(port);
484}
485
486static void hsr_set_rx_mode(struct net_device *dev)
487{
488	struct hsr_port *port;
489	struct hsr_priv *hsr;
490
491	hsr = netdev_priv(dev);
492
493	hsr_for_each_port_rtnl(hsr, port) {
494		if (port->type == HSR_PT_MASTER)
495			continue;
496		switch (port->type) {
497		case HSR_PT_SLAVE_A:
498		case HSR_PT_SLAVE_B:
499			dev_mc_sync_multiple(port->dev, dev);
500			dev_uc_sync_multiple(port->dev, dev);
501			break;
502		default:
503			break;
504		}
505	}
506}
507
508static void hsr_change_rx_flags(struct net_device *dev, int change)
509{
510	struct hsr_port *port;
511	struct hsr_priv *hsr;
512
513	hsr = netdev_priv(dev);
514
515	hsr_for_each_port_rtnl(hsr, port) {
516		if (port->type == HSR_PT_MASTER)
517			continue;
518		switch (port->type) {
519		case HSR_PT_SLAVE_A:
520		case HSR_PT_SLAVE_B:
521			if (change & IFF_ALLMULTI)
522				dev_set_allmulti(port->dev,
523						 dev->flags &
524						 IFF_ALLMULTI ? 1 : -1);
525			break;
526		default:
527			break;
528		}
529	}
530}
531
532static int hsr_ndo_vlan_rx_add_vid(struct net_device *dev,
533				   __be16 proto, u16 vid)
534{
535	struct net_device *slave_a_dev = NULL;
536	struct net_device *slave_b_dev = NULL;
537	struct hsr_port *port;
538	struct hsr_priv *hsr;
539	int ret = 0;
540
541	hsr = netdev_priv(dev);
542
543	hsr_for_each_port_rtnl(hsr, port) {
544		if (port->type == HSR_PT_MASTER ||
545		    port->type == HSR_PT_INTERLINK)
546			continue;
547
548		ret = vlan_vid_add(port->dev, proto, vid);
549		switch (port->type) {
550		case HSR_PT_SLAVE_A:
551			if (ret) {
552				netdev_err(dev, "add vid failed for Slave-A\n");
553				goto unwind;
554			}
555			slave_a_dev = port->dev;
556			break;
557		case HSR_PT_SLAVE_B:
558			if (ret) {
559				netdev_err(dev, "add vid failed for Slave-B\n");
560				goto unwind;
561			}
562			slave_b_dev = port->dev;
563			break;
564		default:
565			if (ret)
566				goto unwind;
567			break;
568		}
569	}
570
571	return 0;
572
573unwind:
574	if (slave_a_dev)
575		vlan_vid_del(slave_a_dev, proto, vid);
576
577	if (slave_b_dev)
578		vlan_vid_del(slave_b_dev, proto, vid);
579
580	return ret;
581}
582
583static int hsr_ndo_vlan_rx_kill_vid(struct net_device *dev,
584				    __be16 proto, u16 vid)
585{
586	struct hsr_port *port;
587	struct hsr_priv *hsr;
588
589	hsr = netdev_priv(dev);
590
591	hsr_for_each_port_rtnl(hsr, port) {
592		switch (port->type) {
593		case HSR_PT_SLAVE_A:
594		case HSR_PT_SLAVE_B:
595			vlan_vid_del(port->dev, proto, vid);
596			break;
597		default:
598			break;
599		}
600	}
601
602	return 0;
603}
604
605static const struct net_device_ops hsr_device_ops = {
606	.ndo_change_mtu = hsr_dev_change_mtu,
607	.ndo_open = hsr_dev_open,
608	.ndo_stop = hsr_dev_close,
609	.ndo_start_xmit = hsr_dev_xmit,
610	.ndo_change_rx_flags = hsr_change_rx_flags,
611	.ndo_fix_features = hsr_fix_features,
612	.ndo_set_rx_mode = hsr_set_rx_mode,
613	.ndo_vlan_rx_add_vid = hsr_ndo_vlan_rx_add_vid,
614	.ndo_vlan_rx_kill_vid = hsr_ndo_vlan_rx_kill_vid,
615};
616
617static const struct device_type hsr_type = {
618	.name = "hsr",
619};
620
621static struct hsr_proto_ops hsr_ops = {
622	.send_sv_frame = send_hsr_supervision_frame,
623	.create_tagged_frame = hsr_create_tagged_frame,
624	.get_untagged_frame = hsr_get_untagged_frame,
625	.drop_frame = hsr_drop_frame,
626	.fill_frame_info = hsr_fill_frame_info,
627	.invalid_dan_ingress_frame = hsr_invalid_dan_ingress_frame,
628	.register_frame_out = hsr_register_frame_out,
629};
630
631static struct hsr_proto_ops prp_ops = {
632	.send_sv_frame = send_prp_supervision_frame,
633	.create_tagged_frame = prp_create_tagged_frame,
634	.get_untagged_frame = prp_get_untagged_frame,
635	.drop_frame = prp_drop_frame,
636	.fill_frame_info = prp_fill_frame_info,
637	.handle_san_frame = prp_handle_san_frame,
638	.update_san_info = prp_update_san_info,
639	.register_frame_out = prp_register_frame_out,
640};
641
642void hsr_dev_setup(struct net_device *dev)
643{
644	eth_hw_addr_random(dev);
645
646	ether_setup(dev);
647	dev->min_mtu = 0;
648	dev->header_ops = &hsr_header_ops;
649	dev->netdev_ops = &hsr_device_ops;
650	SET_NETDEV_DEVTYPE(dev, &hsr_type);
651	dev->priv_flags |= IFF_NO_QUEUE | IFF_DISABLE_NETPOLL;
652	/* Prevent recursive tx locking */
653	dev->lltx = true;
654	/* Not sure about this. Taken from bridge code. netdevice.h says
655	 * it means "Does not change network namespaces".
656	 */
657	dev->netns_immutable = true;
658
659	dev->needs_free_netdev = true;
660
661	dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA |
662			   NETIF_F_GSO_MASK | NETIF_F_HW_CSUM |
663			   NETIF_F_HW_VLAN_CTAG_TX |
664			   NETIF_F_HW_VLAN_CTAG_FILTER;
665
666	dev->features = dev->hw_features;
667}
668
669/* Return true if dev is a HSR master; return false otherwise.
670 */
671bool is_hsr_master(struct net_device *dev)
672{
673	return (dev->netdev_ops->ndo_start_xmit == hsr_dev_xmit);
674}
675EXPORT_SYMBOL(is_hsr_master);
676
677struct net_device *hsr_get_port_ndev(struct net_device *ndev,
678				     enum hsr_port_type pt)
679{
680	struct hsr_priv *hsr = netdev_priv(ndev);
681	struct hsr_port *port;
682
683	rcu_read_lock();
684	hsr_for_each_port(hsr, port)
685		if (port->type == pt) {
686			dev_hold(port->dev);
687			rcu_read_unlock();
688			return port->dev;
689		}
690	rcu_read_unlock();
691	return NULL;
692}
693EXPORT_SYMBOL(hsr_get_port_ndev);
694
695int hsr_get_port_type(struct net_device *hsr_dev, struct net_device *dev,
696		      enum hsr_port_type *type)
697{
698	struct hsr_priv *hsr = netdev_priv(hsr_dev);
699	struct hsr_port *port;
700
701	rcu_read_lock();
702	hsr_for_each_port(hsr, port) {
703		if (port->dev == dev) {
704			*type = port->type;
705			rcu_read_unlock();
706			return 0;
707		}
708	}
709	rcu_read_unlock();
710
711	return -EINVAL;
712}
713EXPORT_SYMBOL(hsr_get_port_type);
714
715/* Default multicast address for HSR Supervision frames */
716static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = {
717	0x01, 0x15, 0x4e, 0x00, 0x01, 0x00
718};
719
720int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2],
721		     struct net_device *interlink, unsigned char multicast_spec,
722		     u8 protocol_version, struct netlink_ext_ack *extack)
723{
724	bool unregister = false;
725	struct hsr_priv *hsr;
726	int res;
727
728	hsr = netdev_priv(hsr_dev);
729	INIT_LIST_HEAD(&hsr->ports);
730	INIT_LIST_HEAD(&hsr->node_db);
731	INIT_LIST_HEAD(&hsr->proxy_node_db);
732	spin_lock_init(&hsr->list_lock);
733
734	eth_hw_addr_set(hsr_dev, slave[0]->dev_addr);
735
736	/* initialize protocol specific functions */
737	if (protocol_version == PRP_V1) {
738		/* For PRP, lan_id has most significant 3 bits holding
739		 * the net_id of PRP_LAN_ID
740		 */
741		hsr->net_id = PRP_LAN_ID << 1;
742		hsr->proto_ops = &prp_ops;
743	} else {
744		hsr->proto_ops = &hsr_ops;
745	}
746
747	/* Make sure we recognize frames from ourselves in hsr_rcv() */
748	res = hsr_create_self_node(hsr, hsr_dev->dev_addr,
749				   slave[1]->dev_addr);
750	if (res < 0)
751		return res;
752
753	spin_lock_init(&hsr->seqnr_lock);
754	/* Overflow soon to find bugs easier: */
755	hsr->sequence_nr = HSR_SEQNR_START;
756	hsr->sup_sequence_nr = HSR_SUP_SEQNR_START;
757
758	timer_setup(&hsr->announce_timer, hsr_announce, 0);
759	timer_setup(&hsr->prune_timer, hsr_prune_nodes, 0);
760	timer_setup(&hsr->prune_proxy_timer, hsr_prune_proxy_nodes, 0);
761	timer_setup(&hsr->announce_proxy_timer, hsr_proxy_announce, 0);
762
763	ether_addr_copy(hsr->sup_multicast_addr, def_multicast_addr);
764	hsr->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec;
765
766	hsr->prot_version = protocol_version;
767
768	/* Make sure the 1st call to netif_carrier_on() gets through */
769	netif_carrier_off(hsr_dev);
770
771	res = hsr_add_port(hsr, hsr_dev, HSR_PT_MASTER, extack);
772	if (res)
773		goto err_add_master;
774
775	/* HSR forwarding offload supported in lower device? */
776	if ((slave[0]->features & NETIF_F_HW_HSR_FWD) &&
777	    (slave[1]->features & NETIF_F_HW_HSR_FWD))
778		hsr->fwd_offloaded = true;
779
780	if ((slave[0]->features & NETIF_F_HW_VLAN_CTAG_FILTER) &&
781	    (slave[1]->features & NETIF_F_HW_VLAN_CTAG_FILTER))
782		hsr_dev->features |= NETIF_F_HW_VLAN_CTAG_FILTER;
783
784	res = register_netdevice(hsr_dev);
785	if (res)
786		goto err_unregister;
787
788	unregister = true;
789
790	res = hsr_add_port(hsr, slave[0], HSR_PT_SLAVE_A, extack);
791	if (res)
792		goto err_unregister;
793
794	res = hsr_add_port(hsr, slave[1], HSR_PT_SLAVE_B, extack);
795	if (res)
796		goto err_unregister;
797
798	if (protocol_version == PRP_V1) {
799		eth_hw_addr_set(slave[1], slave[0]->dev_addr);
800		call_netdevice_notifiers(NETDEV_CHANGEADDR, slave[1]);
801	}
802
803	if (interlink) {
804		res = hsr_add_port(hsr, interlink, HSR_PT_INTERLINK, extack);
805		if (res)
806			goto err_unregister;
807
808		hsr->redbox = true;
809		ether_addr_copy(hsr->macaddress_redbox, interlink->dev_addr);
810		mod_timer(&hsr->prune_proxy_timer,
811			  jiffies + msecs_to_jiffies(PRUNE_PROXY_PERIOD));
812	}
813
814	hsr_debugfs_init(hsr, hsr_dev);
815	mod_timer(&hsr->prune_timer, jiffies + msecs_to_jiffies(PRUNE_PERIOD));
816
817	return 0;
818
819err_unregister:
820	hsr_del_ports(hsr);
821err_add_master:
822	hsr_del_self_node(hsr);
823
824	if (unregister)
825		unregister_netdevice(hsr_dev);
826	return res;
827}