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 AB |
92 | |
93 | if ((hsr_dev->operstate == IF_OPER_UP) && (old_operstate != IF_OPER_UP)) { | |
94 | /* Went up */ | |
70ebe4a4 AB |
95 | hsr->announce_count = 0; |
96 | hsr->announce_timer.expires = jiffies + | |
f421436a | 97 | msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL); |
70ebe4a4 | 98 | add_timer(&hsr->announce_timer); |
f421436a AB |
99 | } |
100 | ||
101 | if ((hsr_dev->operstate != IF_OPER_UP) && (old_operstate == IF_OPER_UP)) | |
102 | /* Went down */ | |
70ebe4a4 | 103 | del_timer(&hsr->announce_timer); |
f421436a AB |
104 | } |
105 | ||
e9aae56e AB |
106 | void hsr_check_carrier_and_operstate(struct hsr_priv *hsr) |
107 | { | |
c5a75911 | 108 | struct hsr_port *master; |
e9aae56e AB |
109 | unsigned char old_operstate; |
110 | bool has_carrier; | |
111 | ||
c5a75911 | 112 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); |
e9aae56e AB |
113 | /* netif_stacked_transfer_operstate() cannot be used here since |
114 | * it doesn't set IF_OPER_LOWERLAYERDOWN (?) | |
115 | */ | |
c5a75911 AB |
116 | old_operstate = master->dev->operstate; |
117 | has_carrier = hsr_check_carrier(master); | |
118 | hsr_set_operstate(master, has_carrier); | |
119 | hsr_check_announce(master->dev, old_operstate); | |
e9aae56e AB |
120 | } |
121 | ||
70ebe4a4 | 122 | int hsr_get_max_mtu(struct hsr_priv *hsr) |
f421436a | 123 | { |
51f3c605 | 124 | unsigned int mtu_max; |
c5a75911 | 125 | struct hsr_port *port; |
51f3c605 AB |
126 | |
127 | mtu_max = ETH_DATA_LEN; | |
128 | rcu_read_lock(); | |
c5a75911 AB |
129 | hsr_for_each_port(hsr, port) |
130 | if (port->type != HSR_PT_MASTER) | |
131 | mtu_max = min(port->dev->mtu, mtu_max); | |
51f3c605 AB |
132 | rcu_read_unlock(); |
133 | ||
134 | if (mtu_max < HSR_HLEN) | |
135 | return 0; | |
70ebe4a4 | 136 | return mtu_max - HSR_HLEN; |
f421436a AB |
137 | } |
138 | ||
51f3c605 | 139 | |
f421436a AB |
140 | static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu) |
141 | { | |
70ebe4a4 | 142 | struct hsr_priv *hsr; |
c5a75911 | 143 | struct hsr_port *master; |
f421436a | 144 | |
70ebe4a4 | 145 | hsr = netdev_priv(dev); |
c5a75911 | 146 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); |
f421436a | 147 | |
70ebe4a4 | 148 | if (new_mtu > hsr_get_max_mtu(hsr)) { |
c5a75911 | 149 | 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 | 150 | HSR_HLEN); |
f421436a AB |
151 | return -EINVAL; |
152 | } | |
153 | ||
154 | dev->mtu = new_mtu; | |
155 | ||
156 | return 0; | |
157 | } | |
158 | ||
159 | static int hsr_dev_open(struct net_device *dev) | |
160 | { | |
70ebe4a4 | 161 | struct hsr_priv *hsr; |
c5a75911 AB |
162 | struct hsr_port *port; |
163 | char designation; | |
f421436a | 164 | |
70ebe4a4 | 165 | hsr = netdev_priv(dev); |
c5a75911 | 166 | designation = '\0'; |
f421436a | 167 | |
c5a75911 AB |
168 | rcu_read_lock(); |
169 | hsr_for_each_port(hsr, port) { | |
170 | if (port->type == HSR_PT_MASTER) | |
171 | continue; | |
172 | switch (port->type) { | |
173 | case HSR_PT_SLAVE_A: | |
174 | designation = 'A'; | |
175 | break; | |
176 | case HSR_PT_SLAVE_B: | |
177 | designation = 'B'; | |
178 | break; | |
179 | default: | |
180 | designation = '?'; | |
181 | } | |
182 | if (!is_slave_up(port->dev)) | |
183 | netdev_warn(dev, "Slave %c (%s) is not up; please bring it up to get a fully working HSR network\n", | |
184 | designation, port->dev->name); | |
f421436a | 185 | } |
c5a75911 AB |
186 | rcu_read_unlock(); |
187 | ||
188 | if (designation == '\0') | |
189 | netdev_warn(dev, "No slave devices configured\n"); | |
f421436a AB |
190 | |
191 | return 0; | |
192 | } | |
193 | ||
c5a75911 | 194 | |
f421436a AB |
195 | static int hsr_dev_close(struct net_device *dev) |
196 | { | |
c5a75911 | 197 | /* Nothing to do here. */ |
f421436a AB |
198 | return 0; |
199 | } | |
200 | ||
201 | ||
1cc1eb52 AB |
202 | static netdev_features_t hsr_features_recompute(struct hsr_priv *hsr, |
203 | netdev_features_t features) | |
204 | { | |
205 | netdev_features_t mask; | |
206 | struct hsr_port *port; | |
207 | ||
208 | mask = features; | |
209 | ||
210 | /* Mask out all features that, if supported by one device, should be | |
211 | * enabled for all devices (see NETIF_F_ONE_FOR_ALL). | |
212 | * | |
213 | * Anything that's off in mask will not be enabled - so only things | |
214 | * that were in features originally, and also is in NETIF_F_ONE_FOR_ALL, | |
215 | * may become enabled. | |
216 | */ | |
217 | features &= ~NETIF_F_ONE_FOR_ALL; | |
218 | hsr_for_each_port(hsr, port) | |
219 | features = netdev_increment_features(features, | |
220 | port->dev->features, | |
221 | mask); | |
222 | ||
223 | return features; | |
224 | } | |
225 | ||
226 | static netdev_features_t hsr_fix_features(struct net_device *dev, | |
227 | netdev_features_t features) | |
228 | { | |
229 | struct hsr_priv *hsr = netdev_priv(dev); | |
230 | ||
231 | return hsr_features_recompute(hsr, features); | |
232 | } | |
233 | ||
234 | ||
f421436a AB |
235 | static int hsr_dev_xmit(struct sk_buff *skb, struct net_device *dev) |
236 | { | |
f266a683 | 237 | struct hsr_priv *hsr = netdev_priv(dev); |
c5a75911 | 238 | struct hsr_port *master; |
f421436a | 239 | |
c5a75911 | 240 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); |
f266a683 AB |
241 | skb->dev = master->dev; |
242 | hsr_forward_skb(skb, master); | |
f421436a AB |
243 | |
244 | return NETDEV_TX_OK; | |
245 | } | |
246 | ||
247 | ||
f421436a | 248 | static const struct header_ops hsr_header_ops = { |
f266a683 | 249 | .create = eth_header, |
f421436a AB |
250 | .parse = eth_header_parse, |
251 | }; | |
252 | ||
253 | ||
254 | /* HSR:2010 supervision frames should be padded so that the whole frame, | |
255 | * including headers and FCS, is 64 bytes (without VLAN). | |
256 | */ | |
257 | static int hsr_pad(int size) | |
258 | { | |
70ebe4a4 | 259 | const int min_size = ETH_ZLEN - HSR_HLEN - ETH_HLEN; |
f421436a AB |
260 | |
261 | if (size >= min_size) | |
262 | return size; | |
263 | return min_size; | |
264 | } | |
265 | ||
f266a683 | 266 | static void send_hsr_supervision_frame(struct hsr_port *master, u8 type) |
f421436a | 267 | { |
f421436a AB |
268 | struct sk_buff *skb; |
269 | int hlen, tlen; | |
270 | struct hsr_sup_tag *hsr_stag; | |
271 | struct hsr_sup_payload *hsr_sp; | |
272 | unsigned long irqflags; | |
273 | ||
c5a75911 AB |
274 | hlen = LL_RESERVED_SPACE(master->dev); |
275 | tlen = master->dev->needed_tailroom; | |
f421436a AB |
276 | skb = alloc_skb(hsr_pad(sizeof(struct hsr_sup_payload)) + hlen + tlen, |
277 | GFP_ATOMIC); | |
278 | ||
279 | if (skb == NULL) | |
280 | return; | |
281 | ||
f421436a AB |
282 | skb_reserve(skb, hlen); |
283 | ||
c5a75911 | 284 | skb->dev = master->dev; |
f421436a AB |
285 | skb->protocol = htons(ETH_P_PRP); |
286 | skb->priority = TC_PRIO_CONTROL; | |
287 | ||
f266a683 AB |
288 | if (dev_hard_header(skb, skb->dev, ETH_P_PRP, |
289 | master->hsr->sup_multicast_addr, | |
290 | skb->dev->dev_addr, skb->len) <= 0) | |
f421436a | 291 | goto out; |
f266a683 | 292 | skb_reset_mac_header(skb); |
f421436a | 293 | |
f266a683 | 294 | hsr_stag = (typeof(hsr_stag)) skb_put(skb, sizeof(*hsr_stag)); |
f421436a AB |
295 | |
296 | set_hsr_stag_path(hsr_stag, 0xf); | |
297 | set_hsr_stag_HSR_Ver(hsr_stag, 0); | |
298 | ||
f266a683 AB |
299 | spin_lock_irqsave(&master->hsr->seqnr_lock, irqflags); |
300 | hsr_stag->sequence_nr = htons(master->hsr->sequence_nr); | |
301 | master->hsr->sequence_nr++; | |
302 | spin_unlock_irqrestore(&master->hsr->seqnr_lock, irqflags); | |
f421436a AB |
303 | |
304 | hsr_stag->HSR_TLV_Type = type; | |
305 | hsr_stag->HSR_TLV_Length = 12; | |
306 | ||
f421436a AB |
307 | /* Payload: MacAddressA */ |
308 | hsr_sp = (typeof(hsr_sp)) skb_put(skb, sizeof(*hsr_sp)); | |
c5a75911 | 309 | ether_addr_copy(hsr_sp->MacAddressA, master->dev->dev_addr); |
f421436a | 310 | |
f266a683 | 311 | hsr_forward_skb(skb, master); |
f421436a AB |
312 | return; |
313 | ||
314 | out: | |
3d1a54e8 | 315 | WARN_ONCE(1, "HSR: Could not send supervision frame\n"); |
f421436a AB |
316 | kfree_skb(skb); |
317 | } | |
318 | ||
319 | ||
320 | /* Announce (supervision frame) timer function | |
321 | */ | |
322 | static void hsr_announce(unsigned long data) | |
323 | { | |
70ebe4a4 | 324 | struct hsr_priv *hsr; |
c5a75911 | 325 | struct hsr_port *master; |
f421436a | 326 | |
70ebe4a4 | 327 | hsr = (struct hsr_priv *) data; |
f266a683 AB |
328 | |
329 | rcu_read_lock(); | |
c5a75911 | 330 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); |
f421436a | 331 | |
70ebe4a4 | 332 | if (hsr->announce_count < 3) { |
f266a683 | 333 | send_hsr_supervision_frame(master, HSR_TLV_ANNOUNCE); |
70ebe4a4 | 334 | hsr->announce_count++; |
f421436a | 335 | } else { |
f266a683 | 336 | send_hsr_supervision_frame(master, HSR_TLV_LIFE_CHECK); |
f421436a AB |
337 | } |
338 | ||
70ebe4a4 AB |
339 | if (hsr->announce_count < 3) |
340 | hsr->announce_timer.expires = jiffies + | |
f421436a AB |
341 | msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL); |
342 | else | |
70ebe4a4 | 343 | hsr->announce_timer.expires = jiffies + |
f421436a AB |
344 | msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL); |
345 | ||
c5a75911 | 346 | if (is_admin_up(master->dev)) |
70ebe4a4 | 347 | add_timer(&hsr->announce_timer); |
f266a683 AB |
348 | |
349 | rcu_read_unlock(); | |
f421436a AB |
350 | } |
351 | ||
352 | ||
f421436a AB |
353 | /* According to comments in the declaration of struct net_device, this function |
354 | * is "Called from unregister, can be used to call free_netdev". Ok then... | |
355 | */ | |
356 | static void hsr_dev_destroy(struct net_device *hsr_dev) | |
357 | { | |
70ebe4a4 | 358 | struct hsr_priv *hsr; |
c5a75911 | 359 | struct hsr_port *port; |
f421436a | 360 | |
70ebe4a4 | 361 | hsr = netdev_priv(hsr_dev); |
56b08fdc AB |
362 | |
363 | rtnl_lock(); | |
c5a75911 AB |
364 | hsr_for_each_port(hsr, port) |
365 | hsr_del_port(port); | |
56b08fdc | 366 | rtnl_unlock(); |
f421436a | 367 | |
abff7162 AB |
368 | del_timer_sync(&hsr->prune_timer); |
369 | del_timer_sync(&hsr->announce_timer); | |
c5a75911 AB |
370 | |
371 | synchronize_rcu(); | |
372 | free_netdev(hsr_dev); | |
f421436a AB |
373 | } |
374 | ||
375 | static const struct net_device_ops hsr_device_ops = { | |
376 | .ndo_change_mtu = hsr_dev_change_mtu, | |
377 | .ndo_open = hsr_dev_open, | |
378 | .ndo_stop = hsr_dev_close, | |
379 | .ndo_start_xmit = hsr_dev_xmit, | |
1cc1eb52 | 380 | .ndo_fix_features = hsr_fix_features, |
f421436a AB |
381 | }; |
382 | ||
4c3477dc AB |
383 | static struct device_type hsr_type = { |
384 | .name = "hsr", | |
385 | }; | |
f421436a AB |
386 | |
387 | void hsr_dev_setup(struct net_device *dev) | |
388 | { | |
389 | random_ether_addr(dev->dev_addr); | |
390 | ||
391 | ether_setup(dev); | |
4c3477dc AB |
392 | dev->header_ops = &hsr_header_ops; |
393 | dev->netdev_ops = &hsr_device_ops; | |
394 | SET_NETDEV_DEVTYPE(dev, &hsr_type); | |
9ad09c5c | 395 | dev->priv_flags |= IFF_NO_QUEUE; |
f421436a AB |
396 | |
397 | dev->destructor = hsr_dev_destroy; | |
1cc1eb52 AB |
398 | |
399 | dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA | | |
400 | NETIF_F_GSO_MASK | NETIF_F_HW_CSUM | | |
401 | NETIF_F_HW_VLAN_CTAG_TX; | |
402 | ||
403 | dev->features = dev->hw_features; | |
404 | ||
405 | /* Prevent recursive tx locking */ | |
406 | dev->features |= NETIF_F_LLTX; | |
407 | /* VLAN on top of HSR needs testing and probably some work on | |
408 | * hsr_header_create() etc. | |
409 | */ | |
410 | dev->features |= NETIF_F_VLAN_CHALLENGED; | |
4c3477dc AB |
411 | /* Not sure about this. Taken from bridge code. netdev_features.h says |
412 | * it means "Does not change network namespaces". | |
413 | */ | |
414 | dev->features |= NETIF_F_NETNS_LOCAL; | |
f421436a AB |
415 | } |
416 | ||
417 | ||
418 | /* Return true if dev is a HSR master; return false otherwise. | |
419 | */ | |
c5a75911 | 420 | inline bool is_hsr_master(struct net_device *dev) |
f421436a AB |
421 | { |
422 | return (dev->netdev_ops->ndo_start_xmit == hsr_dev_xmit); | |
423 | } | |
424 | ||
f421436a | 425 | /* Default multicast address for HSR Supervision frames */ |
e83abe37 | 426 | static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = { |
f421436a AB |
427 | 0x01, 0x15, 0x4e, 0x00, 0x01, 0x00 |
428 | }; | |
429 | ||
430 | int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2], | |
431 | unsigned char multicast_spec) | |
432 | { | |
70ebe4a4 | 433 | struct hsr_priv *hsr; |
c5a75911 | 434 | struct hsr_port *port; |
f421436a AB |
435 | int res; |
436 | ||
70ebe4a4 | 437 | hsr = netdev_priv(hsr_dev); |
c5a75911 | 438 | INIT_LIST_HEAD(&hsr->ports); |
70ebe4a4 AB |
439 | INIT_LIST_HEAD(&hsr->node_db); |
440 | INIT_LIST_HEAD(&hsr->self_node_db); | |
51f3c605 AB |
441 | |
442 | ether_addr_copy(hsr_dev->dev_addr, slave[0]->dev_addr); | |
443 | ||
444 | /* Make sure we recognize frames from ourselves in hsr_rcv() */ | |
445 | res = hsr_create_self_node(&hsr->self_node_db, hsr_dev->dev_addr, | |
446 | slave[1]->dev_addr); | |
447 | if (res < 0) | |
448 | return res; | |
449 | ||
70ebe4a4 | 450 | spin_lock_init(&hsr->seqnr_lock); |
f421436a | 451 | /* Overflow soon to find bugs easier: */ |
f266a683 | 452 | hsr->sequence_nr = HSR_SEQNR_START; |
f421436a | 453 | |
70ebe4a4 AB |
454 | init_timer(&hsr->announce_timer); |
455 | hsr->announce_timer.function = hsr_announce; | |
456 | hsr->announce_timer.data = (unsigned long) hsr; | |
f421436a | 457 | |
abff7162 AB |
458 | init_timer(&hsr->prune_timer); |
459 | hsr->prune_timer.function = hsr_prune_nodes; | |
460 | hsr->prune_timer.data = (unsigned long) hsr; | |
461 | ||
70ebe4a4 AB |
462 | ether_addr_copy(hsr->sup_multicast_addr, def_multicast_addr); |
463 | hsr->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec; | |
f421436a | 464 | |
c5a75911 AB |
465 | /* FIXME: should I modify the value of these? |
466 | * | |
467 | * - hsr_dev->flags - i.e. | |
468 | * IFF_MASTER/SLAVE? | |
469 | * - hsr_dev->priv_flags - i.e. | |
470 | * IFF_EBRIDGE? | |
471 | * IFF_TX_SKB_SHARING? | |
472 | * IFF_HSR_MASTER/SLAVE? | |
473 | */ | |
f421436a | 474 | |
f421436a AB |
475 | /* Make sure the 1st call to netif_carrier_on() gets through */ |
476 | netif_carrier_off(hsr_dev); | |
477 | ||
c5a75911 | 478 | res = hsr_add_port(hsr, hsr_dev, HSR_PT_MASTER); |
f421436a | 479 | if (res) |
51f3c605 AB |
480 | return res; |
481 | ||
c5a75911 | 482 | res = register_netdevice(hsr_dev); |
51f3c605 | 483 | if (res) |
c5a75911 AB |
484 | goto fail; |
485 | ||
486 | res = hsr_add_port(hsr, slave[0], HSR_PT_SLAVE_A); | |
487 | if (res) | |
488 | goto fail; | |
489 | res = hsr_add_port(hsr, slave[1], HSR_PT_SLAVE_B); | |
490 | if (res) | |
491 | goto fail; | |
f421436a | 492 | |
abff7162 AB |
493 | hsr->prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD); |
494 | add_timer(&hsr->prune_timer); | |
495 | ||
f421436a | 496 | return 0; |
c5a75911 AB |
497 | |
498 | fail: | |
499 | hsr_for_each_port(hsr, port) | |
500 | hsr_del_port(port); | |
501 | ||
502 | return res; | |
f421436a | 503 | } |