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