]>
Commit | Line | Data |
---|---|---|
0e7623bd | 1 | // SPDX-License-Identifier: GPL-2.0 |
70ebe4a4 | 2 | /* Copyright 2011-2014 Autronica Fire and Security AS |
f421436a AB |
3 | * |
4 | * Author(s): | |
70ebe4a4 | 5 | * 2011-2014 Arvid Brodin, arvid.brodin@alten.se |
f421436a AB |
6 | * |
7 | * This file contains device methods for creating, using and destroying | |
8 | * virtual HSR devices. | |
9 | */ | |
10 | ||
11 | #include <linux/netdevice.h> | |
12 | #include <linux/skbuff.h> | |
13 | #include <linux/etherdevice.h> | |
f421436a AB |
14 | #include <linux/rtnetlink.h> |
15 | #include <linux/pkt_sched.h> | |
16 | #include "hsr_device.h" | |
81ba6afd | 17 | #include "hsr_slave.h" |
f421436a AB |
18 | #include "hsr_framereg.h" |
19 | #include "hsr_main.h" | |
f266a683 | 20 | #include "hsr_forward.h" |
f421436a | 21 | |
f421436a AB |
22 | static bool is_admin_up(struct net_device *dev) |
23 | { | |
24 | return dev && (dev->flags & IFF_UP); | |
25 | } | |
26 | ||
27 | static bool is_slave_up(struct net_device *dev) | |
28 | { | |
29 | return dev && is_admin_up(dev) && netif_oper_up(dev); | |
30 | } | |
31 | ||
32 | static void __hsr_set_operstate(struct net_device *dev, int transition) | |
33 | { | |
34 | write_lock_bh(&dev_base_lock); | |
35 | if (dev->operstate != transition) { | |
36 | dev->operstate = transition; | |
37 | write_unlock_bh(&dev_base_lock); | |
38 | netdev_state_change(dev); | |
39 | } else { | |
40 | write_unlock_bh(&dev_base_lock); | |
41 | } | |
42 | } | |
43 | ||
c5a75911 | 44 | static void hsr_set_operstate(struct hsr_port *master, bool has_carrier) |
f421436a | 45 | { |
c5a75911 AB |
46 | if (!is_admin_up(master->dev)) { |
47 | __hsr_set_operstate(master->dev, IF_OPER_DOWN); | |
f421436a AB |
48 | return; |
49 | } | |
50 | ||
e9aae56e | 51 | if (has_carrier) |
c5a75911 | 52 | __hsr_set_operstate(master->dev, IF_OPER_UP); |
f421436a | 53 | else |
c5a75911 | 54 | __hsr_set_operstate(master->dev, IF_OPER_LOWERLAYERDOWN); |
f421436a AB |
55 | } |
56 | ||
c5a75911 | 57 | static bool hsr_check_carrier(struct hsr_port *master) |
f421436a | 58 | { |
c5a75911 | 59 | struct hsr_port *port; |
e9aae56e AB |
60 | bool has_carrier; |
61 | ||
c5a75911 AB |
62 | has_carrier = false; |
63 | ||
64 | rcu_read_lock(); | |
65 | hsr_for_each_port(master->hsr, port) | |
5670342c | 66 | if (port->type != HSR_PT_MASTER && is_slave_up(port->dev)) { |
c5a75911 AB |
67 | has_carrier = true; |
68 | break; | |
69 | } | |
70 | rcu_read_unlock(); | |
e9aae56e AB |
71 | |
72 | if (has_carrier) | |
c5a75911 | 73 | netif_carrier_on(master->dev); |
f421436a | 74 | else |
c5a75911 | 75 | netif_carrier_off(master->dev); |
e9aae56e AB |
76 | |
77 | return has_carrier; | |
f421436a AB |
78 | } |
79 | ||
e9aae56e AB |
80 | static void hsr_check_announce(struct net_device *hsr_dev, |
81 | unsigned char old_operstate) | |
f421436a | 82 | { |
70ebe4a4 | 83 | struct hsr_priv *hsr; |
f421436a | 84 | |
70ebe4a4 | 85 | hsr = netdev_priv(hsr_dev); |
f421436a | 86 | |
5670342c | 87 | if (hsr_dev->operstate == IF_OPER_UP && old_operstate != IF_OPER_UP) { |
f421436a | 88 | /* Went up */ |
70ebe4a4 | 89 | hsr->announce_count = 0; |
1e027960 ED |
90 | mod_timer(&hsr->announce_timer, |
91 | jiffies + msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL)); | |
f421436a AB |
92 | } |
93 | ||
5670342c | 94 | if (hsr_dev->operstate != IF_OPER_UP && old_operstate == IF_OPER_UP) |
f421436a | 95 | /* Went down */ |
70ebe4a4 | 96 | del_timer(&hsr->announce_timer); |
f421436a AB |
97 | } |
98 | ||
e9aae56e AB |
99 | void hsr_check_carrier_and_operstate(struct hsr_priv *hsr) |
100 | { | |
c5a75911 | 101 | struct hsr_port *master; |
e9aae56e AB |
102 | unsigned char old_operstate; |
103 | bool has_carrier; | |
104 | ||
c5a75911 | 105 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); |
e9aae56e AB |
106 | /* netif_stacked_transfer_operstate() cannot be used here since |
107 | * it doesn't set IF_OPER_LOWERLAYERDOWN (?) | |
108 | */ | |
c5a75911 AB |
109 | old_operstate = master->dev->operstate; |
110 | has_carrier = hsr_check_carrier(master); | |
111 | hsr_set_operstate(master, has_carrier); | |
112 | hsr_check_announce(master->dev, old_operstate); | |
e9aae56e AB |
113 | } |
114 | ||
70ebe4a4 | 115 | int hsr_get_max_mtu(struct hsr_priv *hsr) |
f421436a | 116 | { |
51f3c605 | 117 | unsigned int mtu_max; |
c5a75911 | 118 | struct hsr_port *port; |
51f3c605 AB |
119 | |
120 | mtu_max = ETH_DATA_LEN; | |
121 | rcu_read_lock(); | |
c5a75911 AB |
122 | hsr_for_each_port(hsr, port) |
123 | if (port->type != HSR_PT_MASTER) | |
124 | mtu_max = min(port->dev->mtu, mtu_max); | |
51f3c605 AB |
125 | rcu_read_unlock(); |
126 | ||
127 | if (mtu_max < HSR_HLEN) | |
128 | return 0; | |
70ebe4a4 | 129 | return mtu_max - HSR_HLEN; |
f421436a AB |
130 | } |
131 | ||
132 | static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu) | |
133 | { | |
70ebe4a4 | 134 | struct hsr_priv *hsr; |
c5a75911 | 135 | struct hsr_port *master; |
f421436a | 136 | |
70ebe4a4 | 137 | hsr = netdev_priv(dev); |
c5a75911 | 138 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); |
f421436a | 139 | |
70ebe4a4 | 140 | if (new_mtu > hsr_get_max_mtu(hsr)) { |
c5a75911 | 141 | netdev_info(master->dev, "A HSR master's MTU cannot be greater than the smallest MTU of its slaves minus the HSR Tag length (%d octets).\n", |
70ebe4a4 | 142 | HSR_HLEN); |
f421436a AB |
143 | return -EINVAL; |
144 | } | |
145 | ||
146 | dev->mtu = new_mtu; | |
147 | ||
148 | return 0; | |
149 | } | |
150 | ||
151 | static int hsr_dev_open(struct net_device *dev) | |
152 | { | |
70ebe4a4 | 153 | struct hsr_priv *hsr; |
c5a75911 AB |
154 | struct hsr_port *port; |
155 | char designation; | |
f421436a | 156 | |
70ebe4a4 | 157 | hsr = netdev_priv(dev); |
c5a75911 | 158 | designation = '\0'; |
f421436a | 159 | |
c5a75911 AB |
160 | rcu_read_lock(); |
161 | hsr_for_each_port(hsr, port) { | |
162 | if (port->type == HSR_PT_MASTER) | |
163 | continue; | |
164 | switch (port->type) { | |
165 | case HSR_PT_SLAVE_A: | |
166 | designation = 'A'; | |
167 | break; | |
168 | case HSR_PT_SLAVE_B: | |
169 | designation = 'B'; | |
170 | break; | |
171 | default: | |
172 | designation = '?'; | |
173 | } | |
174 | if (!is_slave_up(port->dev)) | |
175 | netdev_warn(dev, "Slave %c (%s) is not up; please bring it up to get a fully working HSR network\n", | |
176 | designation, port->dev->name); | |
f421436a | 177 | } |
c5a75911 AB |
178 | rcu_read_unlock(); |
179 | ||
180 | if (designation == '\0') | |
181 | netdev_warn(dev, "No slave devices configured\n"); | |
f421436a AB |
182 | |
183 | return 0; | |
184 | } | |
185 | ||
186 | static int hsr_dev_close(struct net_device *dev) | |
187 | { | |
c5a75911 | 188 | /* Nothing to do here. */ |
f421436a AB |
189 | return 0; |
190 | } | |
191 | ||
1cc1eb52 AB |
192 | static 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(hsr, port) | |
209 | features = netdev_increment_features(features, | |
210 | port->dev->features, | |
211 | mask); | |
212 | ||
213 | return features; | |
214 | } | |
215 | ||
216 | static 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 | ||
f421436a AB |
224 | static int hsr_dev_xmit(struct sk_buff *skb, struct net_device *dev) |
225 | { | |
f266a683 | 226 | struct hsr_priv *hsr = netdev_priv(dev); |
c5a75911 | 227 | struct hsr_port *master; |
f421436a | 228 | |
c5a75911 | 229 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); |
311633b6 CW |
230 | skb->dev = master->dev; |
231 | hsr_forward_skb(skb, master); | |
f421436a AB |
232 | return NETDEV_TX_OK; |
233 | } | |
234 | ||
f421436a | 235 | static const struct header_ops hsr_header_ops = { |
f266a683 | 236 | .create = eth_header, |
f421436a AB |
237 | .parse = eth_header_parse, |
238 | }; | |
239 | ||
ee1c2797 | 240 | static void send_hsr_supervision_frame(struct hsr_port *master, |
b1b4aa91 | 241 | u8 type, u8 hsr_ver) |
f421436a | 242 | { |
f421436a AB |
243 | struct sk_buff *skb; |
244 | int hlen, tlen; | |
ee1c2797 | 245 | struct hsr_tag *hsr_tag; |
f421436a AB |
246 | struct hsr_sup_tag *hsr_stag; |
247 | struct hsr_sup_payload *hsr_sp; | |
248 | unsigned long irqflags; | |
249 | ||
c5a75911 AB |
250 | hlen = LL_RESERVED_SPACE(master->dev); |
251 | tlen = master->dev->needed_tailroom; | |
0525fc06 MK |
252 | skb = dev_alloc_skb(sizeof(struct hsr_tag) + |
253 | sizeof(struct hsr_sup_tag) + | |
254 | sizeof(struct hsr_sup_payload) + hlen + tlen); | |
f421436a | 255 | |
05ca6e64 | 256 | if (!skb) |
f421436a AB |
257 | return; |
258 | ||
f421436a AB |
259 | skb_reserve(skb, hlen); |
260 | ||
c5a75911 | 261 | skb->dev = master->dev; |
b1b4aa91 | 262 | skb->protocol = htons(hsr_ver ? ETH_P_HSR : ETH_P_PRP); |
f421436a AB |
263 | skb->priority = TC_PRIO_CONTROL; |
264 | ||
b1b4aa91 | 265 | if (dev_hard_header(skb, skb->dev, (hsr_ver ? ETH_P_HSR : ETH_P_PRP), |
f266a683 AB |
266 | master->hsr->sup_multicast_addr, |
267 | skb->dev->dev_addr, skb->len) <= 0) | |
f421436a | 268 | goto out; |
f266a683 | 269 | skb_reset_mac_header(skb); |
f421436a | 270 | |
b1b4aa91 | 271 | if (hsr_ver > 0) { |
b952f4df | 272 | hsr_tag = skb_put(skb, sizeof(struct hsr_tag)); |
ee1c2797 PH |
273 | hsr_tag->encap_proto = htons(ETH_P_PRP); |
274 | set_hsr_tag_LSDU_size(hsr_tag, HSR_V1_SUP_LSDUSIZE); | |
275 | } | |
f421436a | 276 | |
b952f4df | 277 | hsr_stag = skb_put(skb, sizeof(struct hsr_sup_tag)); |
b1b4aa91 MK |
278 | set_hsr_stag_path(hsr_stag, (hsr_ver ? 0x0 : 0xf)); |
279 | set_hsr_stag_HSR_ver(hsr_stag, hsr_ver); | |
f421436a | 280 | |
ee1c2797 | 281 | /* From HSRv1 on we have separate supervision sequence numbers. */ |
f266a683 | 282 | spin_lock_irqsave(&master->hsr->seqnr_lock, irqflags); |
b1b4aa91 | 283 | if (hsr_ver > 0) { |
ee1c2797 PH |
284 | hsr_stag->sequence_nr = htons(master->hsr->sup_sequence_nr); |
285 | hsr_tag->sequence_nr = htons(master->hsr->sequence_nr); | |
286 | master->hsr->sup_sequence_nr++; | |
287 | master->hsr->sequence_nr++; | |
288 | } else { | |
289 | hsr_stag->sequence_nr = htons(master->hsr->sequence_nr); | |
290 | master->hsr->sequence_nr++; | |
291 | } | |
f266a683 | 292 | spin_unlock_irqrestore(&master->hsr->seqnr_lock, irqflags); |
f421436a | 293 | |
b1b4aa91 | 294 | hsr_stag->HSR_TLV_type = type; |
ee1c2797 | 295 | /* TODO: Why 12 in HSRv0? */ |
b1b4aa91 MK |
296 | hsr_stag->HSR_TLV_length = |
297 | hsr_ver ? sizeof(struct hsr_sup_payload) : 12; | |
f421436a | 298 | |
f421436a | 299 | /* Payload: MacAddressA */ |
b952f4df | 300 | hsr_sp = skb_put(skb, sizeof(struct hsr_sup_payload)); |
b1b4aa91 | 301 | ether_addr_copy(hsr_sp->macaddress_A, master->dev->dev_addr); |
f421436a | 302 | |
414e7d76 FF |
303 | if (skb_put_padto(skb, ETH_ZLEN + HSR_HLEN)) |
304 | return; | |
ee1c2797 | 305 | |
f266a683 | 306 | hsr_forward_skb(skb, master); |
f421436a AB |
307 | return; |
308 | ||
309 | out: | |
3d1a54e8 | 310 | WARN_ONCE(1, "HSR: Could not send supervision frame\n"); |
f421436a AB |
311 | kfree_skb(skb); |
312 | } | |
313 | ||
f421436a AB |
314 | /* Announce (supervision frame) timer function |
315 | */ | |
dda436b7 | 316 | static void hsr_announce(struct timer_list *t) |
f421436a | 317 | { |
70ebe4a4 | 318 | struct hsr_priv *hsr; |
c5a75911 | 319 | struct hsr_port *master; |
1e027960 | 320 | unsigned long interval; |
f421436a | 321 | |
dda436b7 | 322 | hsr = from_timer(hsr, t, announce_timer); |
f266a683 AB |
323 | |
324 | rcu_read_lock(); | |
c5a75911 | 325 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); |
f421436a | 326 | |
b1b4aa91 | 327 | if (hsr->announce_count < 3 && hsr->prot_version == 0) { |
ee1c2797 | 328 | send_hsr_supervision_frame(master, HSR_TLV_ANNOUNCE, |
b1b4aa91 | 329 | hsr->prot_version); |
70ebe4a4 | 330 | hsr->announce_count++; |
f421436a | 331 | |
1e027960 | 332 | interval = msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL); |
ee1c2797 PH |
333 | } else { |
334 | send_hsr_supervision_frame(master, HSR_TLV_LIFE_CHECK, | |
b1b4aa91 | 335 | hsr->prot_version); |
ee1c2797 | 336 | |
1e027960 | 337 | interval = msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL); |
ee1c2797 | 338 | } |
f421436a | 339 | |
c5a75911 | 340 | if (is_admin_up(master->dev)) |
1e027960 | 341 | mod_timer(&hsr->announce_timer, jiffies + interval); |
f266a683 AB |
342 | |
343 | rcu_read_unlock(); | |
f421436a AB |
344 | } |
345 | ||
311633b6 CW |
346 | /* This has to be called after all the readers are gone. |
347 | * Otherwise we would have to check the return value of | |
348 | * hsr_port_get_hsr(). | |
349 | */ | |
350 | static void hsr_dev_destroy(struct net_device *hsr_dev) | |
f421436a | 351 | { |
70ebe4a4 | 352 | struct hsr_priv *hsr; |
c5a75911 | 353 | struct hsr_port *port; |
619afef0 | 354 | struct hsr_port *tmp; |
f421436a | 355 | |
70ebe4a4 | 356 | hsr = netdev_priv(hsr_dev); |
56b08fdc | 357 | |
9c5f8a19 | 358 | hsr_debugfs_term(hsr); |
fc4ecaee | 359 | |
619afef0 | 360 | list_for_each_entry_safe(port, tmp, &hsr->ports, port_list) |
c5a75911 | 361 | hsr_del_port(port); |
f421436a | 362 | |
abff7162 AB |
363 | del_timer_sync(&hsr->prune_timer); |
364 | del_timer_sync(&hsr->announce_timer); | |
c5a75911 | 365 | |
b9a1e627 CW |
366 | hsr_del_self_node(&hsr->self_node_db); |
367 | hsr_del_nodes(&hsr->node_db); | |
f421436a AB |
368 | } |
369 | ||
370 | static const struct net_device_ops hsr_device_ops = { | |
371 | .ndo_change_mtu = hsr_dev_change_mtu, | |
372 | .ndo_open = hsr_dev_open, | |
373 | .ndo_stop = hsr_dev_close, | |
374 | .ndo_start_xmit = hsr_dev_xmit, | |
1cc1eb52 | 375 | .ndo_fix_features = hsr_fix_features, |
311633b6 | 376 | .ndo_uninit = hsr_dev_destroy, |
f421436a AB |
377 | }; |
378 | ||
4c3477dc AB |
379 | static struct device_type hsr_type = { |
380 | .name = "hsr", | |
381 | }; | |
f421436a AB |
382 | |
383 | void hsr_dev_setup(struct net_device *dev) | |
384 | { | |
d4af4c0a | 385 | eth_hw_addr_random(dev); |
f421436a AB |
386 | |
387 | ether_setup(dev); | |
b3e3893e | 388 | dev->min_mtu = 0; |
4c3477dc AB |
389 | dev->header_ops = &hsr_header_ops; |
390 | dev->netdev_ops = &hsr_device_ops; | |
391 | SET_NETDEV_DEVTYPE(dev, &hsr_type); | |
9ad09c5c | 392 | dev->priv_flags |= IFF_NO_QUEUE; |
f421436a | 393 | |
cf124db5 | 394 | dev->needs_free_netdev = true; |
1cc1eb52 AB |
395 | |
396 | dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA | | |
397 | NETIF_F_GSO_MASK | NETIF_F_HW_CSUM | | |
398 | NETIF_F_HW_VLAN_CTAG_TX; | |
399 | ||
400 | dev->features = dev->hw_features; | |
401 | ||
402 | /* Prevent recursive tx locking */ | |
403 | dev->features |= NETIF_F_LLTX; | |
404 | /* VLAN on top of HSR needs testing and probably some work on | |
405 | * hsr_header_create() etc. | |
406 | */ | |
407 | dev->features |= NETIF_F_VLAN_CHALLENGED; | |
4c3477dc AB |
408 | /* Not sure about this. Taken from bridge code. netdev_features.h says |
409 | * it means "Does not change network namespaces". | |
410 | */ | |
411 | dev->features |= NETIF_F_NETNS_LOCAL; | |
f421436a AB |
412 | } |
413 | ||
f421436a AB |
414 | /* Return true if dev is a HSR master; return false otherwise. |
415 | */ | |
c5a75911 | 416 | inline bool is_hsr_master(struct net_device *dev) |
f421436a AB |
417 | { |
418 | return (dev->netdev_ops->ndo_start_xmit == hsr_dev_xmit); | |
419 | } | |
420 | ||
f421436a | 421 | /* Default multicast address for HSR Supervision frames */ |
e83abe37 | 422 | static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = { |
f421436a AB |
423 | 0x01, 0x15, 0x4e, 0x00, 0x01, 0x00 |
424 | }; | |
425 | ||
426 | int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2], | |
ee1c2797 | 427 | unsigned char multicast_spec, u8 protocol_version) |
f421436a | 428 | { |
70ebe4a4 | 429 | struct hsr_priv *hsr; |
c5a75911 | 430 | struct hsr_port *port; |
619afef0 | 431 | struct hsr_port *tmp; |
f421436a AB |
432 | int res; |
433 | ||
70ebe4a4 | 434 | hsr = netdev_priv(hsr_dev); |
c5a75911 | 435 | INIT_LIST_HEAD(&hsr->ports); |
70ebe4a4 AB |
436 | INIT_LIST_HEAD(&hsr->node_db); |
437 | INIT_LIST_HEAD(&hsr->self_node_db); | |
51f3c605 AB |
438 | |
439 | ether_addr_copy(hsr_dev->dev_addr, slave[0]->dev_addr); | |
440 | ||
441 | /* Make sure we recognize frames from ourselves in hsr_rcv() */ | |
442 | res = hsr_create_self_node(&hsr->self_node_db, hsr_dev->dev_addr, | |
443 | slave[1]->dev_addr); | |
444 | if (res < 0) | |
445 | return res; | |
446 | ||
70ebe4a4 | 447 | spin_lock_init(&hsr->seqnr_lock); |
f421436a | 448 | /* Overflow soon to find bugs easier: */ |
f266a683 | 449 | hsr->sequence_nr = HSR_SEQNR_START; |
ee1c2797 | 450 | hsr->sup_sequence_nr = HSR_SUP_SEQNR_START; |
f421436a | 451 | |
dda436b7 KC |
452 | timer_setup(&hsr->announce_timer, hsr_announce, 0); |
453 | timer_setup(&hsr->prune_timer, hsr_prune_nodes, 0); | |
abff7162 | 454 | |
70ebe4a4 AB |
455 | ether_addr_copy(hsr->sup_multicast_addr, def_multicast_addr); |
456 | hsr->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec; | |
f421436a | 457 | |
b1b4aa91 | 458 | hsr->prot_version = protocol_version; |
ee1c2797 | 459 | |
c5a75911 AB |
460 | /* FIXME: should I modify the value of these? |
461 | * | |
462 | * - hsr_dev->flags - i.e. | |
463 | * IFF_MASTER/SLAVE? | |
464 | * - hsr_dev->priv_flags - i.e. | |
465 | * IFF_EBRIDGE? | |
466 | * IFF_TX_SKB_SHARING? | |
467 | * IFF_HSR_MASTER/SLAVE? | |
468 | */ | |
f421436a | 469 | |
f421436a AB |
470 | /* Make sure the 1st call to netif_carrier_on() gets through */ |
471 | netif_carrier_off(hsr_dev); | |
472 | ||
c5a75911 | 473 | res = hsr_add_port(hsr, hsr_dev, HSR_PT_MASTER); |
f421436a | 474 | if (res) |
6caabe7f | 475 | goto err_add_port; |
51f3c605 | 476 | |
c5a75911 | 477 | res = register_netdevice(hsr_dev); |
51f3c605 | 478 | if (res) |
c5a75911 AB |
479 | goto fail; |
480 | ||
481 | res = hsr_add_port(hsr, slave[0], HSR_PT_SLAVE_A); | |
482 | if (res) | |
483 | goto fail; | |
484 | res = hsr_add_port(hsr, slave[1], HSR_PT_SLAVE_B); | |
485 | if (res) | |
486 | goto fail; | |
f421436a | 487 | |
15db6e0d | 488 | mod_timer(&hsr->prune_timer, jiffies + msecs_to_jiffies(PRUNE_PERIOD)); |
32712733 | 489 | res = hsr_debugfs_init(hsr, hsr_dev); |
fc4ecaee MK |
490 | if (res) |
491 | goto fail; | |
abff7162 | 492 | |
f421436a | 493 | return 0; |
c5a75911 AB |
494 | |
495 | fail: | |
619afef0 | 496 | list_for_each_entry_safe(port, tmp, &hsr->ports, port_list) |
c5a75911 | 497 | hsr_del_port(port); |
6caabe7f | 498 | err_add_port: |
b9a1e627 | 499 | hsr_del_self_node(&hsr->self_node_db); |
c5a75911 AB |
500 | |
501 | return res; | |
f421436a | 502 | } |