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" | |
24 | ||
25 | ||
26 | static bool is_admin_up(struct net_device *dev) | |
27 | { | |
28 | return dev && (dev->flags & IFF_UP); | |
29 | } | |
30 | ||
31 | static bool is_slave_up(struct net_device *dev) | |
32 | { | |
33 | return dev && is_admin_up(dev) && netif_oper_up(dev); | |
34 | } | |
35 | ||
36 | static void __hsr_set_operstate(struct net_device *dev, int transition) | |
37 | { | |
38 | write_lock_bh(&dev_base_lock); | |
39 | if (dev->operstate != transition) { | |
40 | dev->operstate = transition; | |
41 | write_unlock_bh(&dev_base_lock); | |
42 | netdev_state_change(dev); | |
43 | } else { | |
44 | write_unlock_bh(&dev_base_lock); | |
45 | } | |
46 | } | |
47 | ||
c5a75911 | 48 | static void hsr_set_operstate(struct hsr_port *master, bool has_carrier) |
f421436a | 49 | { |
c5a75911 AB |
50 | if (!is_admin_up(master->dev)) { |
51 | __hsr_set_operstate(master->dev, IF_OPER_DOWN); | |
f421436a AB |
52 | return; |
53 | } | |
54 | ||
e9aae56e | 55 | if (has_carrier) |
c5a75911 | 56 | __hsr_set_operstate(master->dev, IF_OPER_UP); |
f421436a | 57 | else |
c5a75911 | 58 | __hsr_set_operstate(master->dev, IF_OPER_LOWERLAYERDOWN); |
f421436a AB |
59 | } |
60 | ||
c5a75911 | 61 | static bool hsr_check_carrier(struct hsr_port *master) |
f421436a | 62 | { |
c5a75911 | 63 | struct hsr_port *port; |
e9aae56e AB |
64 | bool has_carrier; |
65 | ||
c5a75911 AB |
66 | has_carrier = false; |
67 | ||
68 | rcu_read_lock(); | |
69 | hsr_for_each_port(master->hsr, port) | |
70 | if ((port->type != HSR_PT_MASTER) && is_slave_up(port->dev)) { | |
71 | has_carrier = true; | |
72 | break; | |
73 | } | |
74 | rcu_read_unlock(); | |
e9aae56e AB |
75 | |
76 | if (has_carrier) | |
c5a75911 | 77 | netif_carrier_on(master->dev); |
f421436a | 78 | else |
c5a75911 | 79 | netif_carrier_off(master->dev); |
e9aae56e AB |
80 | |
81 | return has_carrier; | |
f421436a AB |
82 | } |
83 | ||
84 | ||
e9aae56e AB |
85 | static void hsr_check_announce(struct net_device *hsr_dev, |
86 | unsigned char old_operstate) | |
f421436a | 87 | { |
70ebe4a4 | 88 | struct hsr_priv *hsr; |
f421436a | 89 | |
70ebe4a4 | 90 | hsr = netdev_priv(hsr_dev); |
f421436a AB |
91 | |
92 | if ((hsr_dev->operstate == IF_OPER_UP) && (old_operstate != IF_OPER_UP)) { | |
93 | /* Went up */ | |
70ebe4a4 AB |
94 | hsr->announce_count = 0; |
95 | hsr->announce_timer.expires = jiffies + | |
f421436a | 96 | msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL); |
70ebe4a4 | 97 | add_timer(&hsr->announce_timer); |
f421436a AB |
98 | } |
99 | ||
100 | if ((hsr_dev->operstate != IF_OPER_UP) && (old_operstate == IF_OPER_UP)) | |
101 | /* Went down */ | |
70ebe4a4 | 102 | del_timer(&hsr->announce_timer); |
f421436a AB |
103 | } |
104 | ||
e9aae56e AB |
105 | void hsr_check_carrier_and_operstate(struct hsr_priv *hsr) |
106 | { | |
c5a75911 | 107 | struct hsr_port *master; |
e9aae56e AB |
108 | unsigned char old_operstate; |
109 | bool has_carrier; | |
110 | ||
c5a75911 | 111 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); |
e9aae56e AB |
112 | /* netif_stacked_transfer_operstate() cannot be used here since |
113 | * it doesn't set IF_OPER_LOWERLAYERDOWN (?) | |
114 | */ | |
c5a75911 AB |
115 | old_operstate = master->dev->operstate; |
116 | has_carrier = hsr_check_carrier(master); | |
117 | hsr_set_operstate(master, has_carrier); | |
118 | hsr_check_announce(master->dev, old_operstate); | |
e9aae56e AB |
119 | } |
120 | ||
70ebe4a4 | 121 | int hsr_get_max_mtu(struct hsr_priv *hsr) |
f421436a | 122 | { |
51f3c605 | 123 | unsigned int mtu_max; |
c5a75911 | 124 | struct hsr_port *port; |
51f3c605 AB |
125 | |
126 | mtu_max = ETH_DATA_LEN; | |
127 | rcu_read_lock(); | |
c5a75911 AB |
128 | hsr_for_each_port(hsr, port) |
129 | if (port->type != HSR_PT_MASTER) | |
130 | mtu_max = min(port->dev->mtu, mtu_max); | |
51f3c605 AB |
131 | rcu_read_unlock(); |
132 | ||
133 | if (mtu_max < HSR_HLEN) | |
134 | return 0; | |
70ebe4a4 | 135 | return mtu_max - HSR_HLEN; |
f421436a AB |
136 | } |
137 | ||
51f3c605 | 138 | |
f421436a AB |
139 | static int hsr_dev_change_mtu(struct net_device *dev, int new_mtu) |
140 | { | |
70ebe4a4 | 141 | struct hsr_priv *hsr; |
c5a75911 | 142 | struct hsr_port *master; |
f421436a | 143 | |
70ebe4a4 | 144 | hsr = netdev_priv(dev); |
c5a75911 | 145 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); |
f421436a | 146 | |
70ebe4a4 | 147 | if (new_mtu > hsr_get_max_mtu(hsr)) { |
c5a75911 | 148 | 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 | 149 | HSR_HLEN); |
f421436a AB |
150 | return -EINVAL; |
151 | } | |
152 | ||
153 | dev->mtu = new_mtu; | |
154 | ||
155 | return 0; | |
156 | } | |
157 | ||
158 | static int hsr_dev_open(struct net_device *dev) | |
159 | { | |
70ebe4a4 | 160 | struct hsr_priv *hsr; |
c5a75911 AB |
161 | struct hsr_port *port; |
162 | char designation; | |
f421436a | 163 | |
70ebe4a4 | 164 | hsr = netdev_priv(dev); |
c5a75911 | 165 | designation = '\0'; |
f421436a | 166 | |
c5a75911 AB |
167 | rcu_read_lock(); |
168 | hsr_for_each_port(hsr, port) { | |
169 | if (port->type == HSR_PT_MASTER) | |
170 | continue; | |
171 | switch (port->type) { | |
172 | case HSR_PT_SLAVE_A: | |
173 | designation = 'A'; | |
174 | break; | |
175 | case HSR_PT_SLAVE_B: | |
176 | designation = 'B'; | |
177 | break; | |
178 | default: | |
179 | designation = '?'; | |
180 | } | |
181 | if (!is_slave_up(port->dev)) | |
182 | netdev_warn(dev, "Slave %c (%s) is not up; please bring it up to get a fully working HSR network\n", | |
183 | designation, port->dev->name); | |
f421436a | 184 | } |
c5a75911 AB |
185 | rcu_read_unlock(); |
186 | ||
187 | if (designation == '\0') | |
188 | netdev_warn(dev, "No slave devices configured\n"); | |
f421436a AB |
189 | |
190 | return 0; | |
191 | } | |
192 | ||
c5a75911 | 193 | |
f421436a AB |
194 | static int hsr_dev_close(struct net_device *dev) |
195 | { | |
c5a75911 | 196 | /* Nothing to do here. */ |
f421436a AB |
197 | return 0; |
198 | } | |
199 | ||
200 | ||
1cc1eb52 AB |
201 | static netdev_features_t hsr_features_recompute(struct hsr_priv *hsr, |
202 | netdev_features_t features) | |
203 | { | |
204 | netdev_features_t mask; | |
205 | struct hsr_port *port; | |
206 | ||
207 | mask = features; | |
208 | ||
209 | /* Mask out all features that, if supported by one device, should be | |
210 | * enabled for all devices (see NETIF_F_ONE_FOR_ALL). | |
211 | * | |
212 | * Anything that's off in mask will not be enabled - so only things | |
213 | * that were in features originally, and also is in NETIF_F_ONE_FOR_ALL, | |
214 | * may become enabled. | |
215 | */ | |
216 | features &= ~NETIF_F_ONE_FOR_ALL; | |
217 | hsr_for_each_port(hsr, port) | |
218 | features = netdev_increment_features(features, | |
219 | port->dev->features, | |
220 | mask); | |
221 | ||
222 | return features; | |
223 | } | |
224 | ||
225 | static netdev_features_t hsr_fix_features(struct net_device *dev, | |
226 | netdev_features_t features) | |
227 | { | |
228 | struct hsr_priv *hsr = netdev_priv(dev); | |
229 | ||
230 | return hsr_features_recompute(hsr, features); | |
231 | } | |
232 | ||
233 | ||
70ebe4a4 | 234 | static void hsr_fill_tag(struct hsr_ethhdr *hsr_ethhdr, struct hsr_priv *hsr) |
f421436a AB |
235 | { |
236 | unsigned long irqflags; | |
237 | ||
238 | /* IEC 62439-1:2010, p 48, says the 4-bit "path" field can take values | |
239 | * between 0001-1001 ("ring identifier", for regular HSR frames), | |
240 | * or 1111 ("HSR management", supervision frames). Unfortunately, the | |
241 | * spec writers forgot to explain what a "ring identifier" is, or | |
242 | * how it is used. So we just set this to 0001 for regular frames, | |
243 | * and 1111 for supervision frames. | |
244 | */ | |
245 | set_hsr_tag_path(&hsr_ethhdr->hsr_tag, 0x1); | |
246 | ||
247 | /* IEC 62439-1:2010, p 12: "The link service data unit in an Ethernet | |
248 | * frame is the content of the frame located between the Length/Type | |
249 | * field and the Frame Check Sequence." | |
250 | * | |
251 | * IEC 62439-3, p 48, specifies the "original LPDU" to include the | |
252 | * original "LT" field (what "LT" means is not explained anywhere as | |
253 | * far as I can see - perhaps "Length/Type"?). So LSDU_size might | |
254 | * equal original length + 2. | |
255 | * Also, the fact that this field is not used anywhere (might be used | |
256 | * by a RedBox connecting HSR and PRP nets?) means I cannot test its | |
257 | * correctness. Instead of guessing, I set this to 0 here, to make any | |
258 | * problems immediately apparent. Anyone using this driver with PRP/HSR | |
259 | * RedBoxes might need to fix this... | |
260 | */ | |
261 | set_hsr_tag_LSDU_size(&hsr_ethhdr->hsr_tag, 0); | |
262 | ||
70ebe4a4 AB |
263 | spin_lock_irqsave(&hsr->seqnr_lock, irqflags); |
264 | hsr_ethhdr->hsr_tag.sequence_nr = htons(hsr->sequence_nr); | |
265 | hsr->sequence_nr++; | |
266 | spin_unlock_irqrestore(&hsr->seqnr_lock, irqflags); | |
f421436a AB |
267 | |
268 | hsr_ethhdr->hsr_tag.encap_proto = hsr_ethhdr->ethhdr.h_proto; | |
269 | ||
270 | hsr_ethhdr->ethhdr.h_proto = htons(ETH_P_PRP); | |
271 | } | |
272 | ||
c5a75911 AB |
273 | static int slave_xmit(struct hsr_priv *hsr, struct sk_buff *skb, |
274 | enum hsr_port_type type) | |
f421436a | 275 | { |
c5a75911 | 276 | struct hsr_port *port; |
f421436a AB |
277 | struct hsr_ethhdr *hsr_ethhdr; |
278 | ||
279 | hsr_ethhdr = (struct hsr_ethhdr *) skb->data; | |
280 | ||
c5a75911 AB |
281 | rcu_read_lock(); |
282 | port = hsr_port_get_hsr(hsr, type); | |
283 | if (!port) { | |
284 | rcu_read_unlock(); | |
51f3c605 | 285 | return NET_XMIT_DROP; |
c5a75911 AB |
286 | } |
287 | skb->dev = port->dev; | |
f421436a | 288 | |
c5a75911 AB |
289 | hsr_addr_subst_dest(port->hsr, &hsr_ethhdr->ethhdr, port); |
290 | rcu_read_unlock(); | |
f421436a AB |
291 | |
292 | /* Address substitution (IEC62439-3 pp 26, 50): replace mac | |
293 | * address of outgoing frame with that of the outgoing slave's. | |
294 | */ | |
e83abe37 | 295 | ether_addr_copy(hsr_ethhdr->ethhdr.h_source, skb->dev->dev_addr); |
f421436a AB |
296 | |
297 | return dev_queue_xmit(skb); | |
298 | } | |
299 | ||
f421436a AB |
300 | static int hsr_dev_xmit(struct sk_buff *skb, struct net_device *dev) |
301 | { | |
70ebe4a4 | 302 | struct hsr_priv *hsr; |
c5a75911 | 303 | struct hsr_port *master; |
f421436a AB |
304 | struct hsr_ethhdr *hsr_ethhdr; |
305 | struct sk_buff *skb2; | |
306 | int res1, res2; | |
307 | ||
70ebe4a4 | 308 | hsr = netdev_priv(dev); |
f421436a AB |
309 | hsr_ethhdr = (struct hsr_ethhdr *) skb->data; |
310 | ||
311 | if ((skb->protocol != htons(ETH_P_PRP)) || | |
312 | (hsr_ethhdr->ethhdr.h_proto != htons(ETH_P_PRP))) { | |
70ebe4a4 | 313 | hsr_fill_tag(hsr_ethhdr, hsr); |
f421436a AB |
314 | skb->protocol = htons(ETH_P_PRP); |
315 | } | |
316 | ||
317 | skb2 = pskb_copy(skb, GFP_ATOMIC); | |
f421436a | 318 | |
c5a75911 AB |
319 | res1 = slave_xmit(hsr, skb, HSR_PT_SLAVE_A); |
320 | if (skb2) | |
321 | res2 = slave_xmit(hsr, skb2, HSR_PT_SLAVE_B); | |
322 | else | |
323 | res2 = NET_XMIT_DROP; | |
324 | ||
325 | rcu_read_lock(); | |
326 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); | |
f421436a AB |
327 | if (likely(res1 == NET_XMIT_SUCCESS || res1 == NET_XMIT_CN || |
328 | res2 == NET_XMIT_SUCCESS || res2 == NET_XMIT_CN)) { | |
c5a75911 AB |
329 | master->dev->stats.tx_packets++; |
330 | master->dev->stats.tx_bytes += skb->len; | |
f421436a | 331 | } else { |
c5a75911 | 332 | master->dev->stats.tx_dropped++; |
f421436a | 333 | } |
c5a75911 | 334 | rcu_read_unlock(); |
f421436a AB |
335 | |
336 | return NETDEV_TX_OK; | |
337 | } | |
338 | ||
339 | ||
340 | static int hsr_header_create(struct sk_buff *skb, struct net_device *dev, | |
341 | unsigned short type, const void *daddr, | |
342 | const void *saddr, unsigned int len) | |
343 | { | |
344 | int res; | |
345 | ||
346 | /* Make room for the HSR tag now. We will fill it in later (in | |
347 | * hsr_dev_xmit) | |
348 | */ | |
70ebe4a4 | 349 | if (skb_headroom(skb) < HSR_HLEN + ETH_HLEN) |
f421436a | 350 | return -ENOBUFS; |
70ebe4a4 | 351 | skb_push(skb, HSR_HLEN); |
f421436a AB |
352 | |
353 | /* To allow VLAN/HSR combos we should probably use | |
70ebe4a4 | 354 | * res = dev_hard_header(skb, dev, type, daddr, saddr, len + HSR_HLEN); |
f421436a AB |
355 | * here instead. It would require other changes too, though - e.g. |
356 | * separate headers for each slave etc... | |
357 | */ | |
70ebe4a4 | 358 | res = eth_header(skb, dev, type, daddr, saddr, len + HSR_HLEN); |
f421436a AB |
359 | if (res <= 0) |
360 | return res; | |
361 | skb_reset_mac_header(skb); | |
362 | ||
70ebe4a4 | 363 | return res + HSR_HLEN; |
f421436a AB |
364 | } |
365 | ||
366 | ||
367 | static const struct header_ops hsr_header_ops = { | |
368 | .create = hsr_header_create, | |
369 | .parse = eth_header_parse, | |
370 | }; | |
371 | ||
372 | ||
373 | /* HSR:2010 supervision frames should be padded so that the whole frame, | |
374 | * including headers and FCS, is 64 bytes (without VLAN). | |
375 | */ | |
376 | static int hsr_pad(int size) | |
377 | { | |
70ebe4a4 | 378 | const int min_size = ETH_ZLEN - HSR_HLEN - ETH_HLEN; |
f421436a AB |
379 | |
380 | if (size >= min_size) | |
381 | return size; | |
382 | return min_size; | |
383 | } | |
384 | ||
385 | static void send_hsr_supervision_frame(struct net_device *hsr_dev, u8 type) | |
386 | { | |
70ebe4a4 | 387 | struct hsr_priv *hsr; |
c5a75911 | 388 | struct hsr_port *master; |
f421436a AB |
389 | struct sk_buff *skb; |
390 | int hlen, tlen; | |
391 | struct hsr_sup_tag *hsr_stag; | |
392 | struct hsr_sup_payload *hsr_sp; | |
393 | unsigned long irqflags; | |
c5a75911 AB |
394 | int res; |
395 | ||
396 | hsr = netdev_priv(hsr_dev); | |
397 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); | |
f421436a | 398 | |
c5a75911 AB |
399 | hlen = LL_RESERVED_SPACE(master->dev); |
400 | tlen = master->dev->needed_tailroom; | |
f421436a AB |
401 | skb = alloc_skb(hsr_pad(sizeof(struct hsr_sup_payload)) + hlen + tlen, |
402 | GFP_ATOMIC); | |
403 | ||
404 | if (skb == NULL) | |
405 | return; | |
406 | ||
f421436a AB |
407 | skb_reserve(skb, hlen); |
408 | ||
c5a75911 | 409 | skb->dev = master->dev; |
f421436a AB |
410 | skb->protocol = htons(ETH_P_PRP); |
411 | skb->priority = TC_PRIO_CONTROL; | |
412 | ||
c5a75911 AB |
413 | res = dev_hard_header(skb, skb->dev, ETH_P_PRP, |
414 | hsr->sup_multicast_addr, | |
415 | skb->dev->dev_addr, skb->len); | |
416 | if (res <= 0) | |
f421436a AB |
417 | goto out; |
418 | ||
419 | skb_pull(skb, sizeof(struct ethhdr)); | |
420 | hsr_stag = (typeof(hsr_stag)) skb->data; | |
421 | ||
422 | set_hsr_stag_path(hsr_stag, 0xf); | |
423 | set_hsr_stag_HSR_Ver(hsr_stag, 0); | |
424 | ||
70ebe4a4 AB |
425 | spin_lock_irqsave(&hsr->seqnr_lock, irqflags); |
426 | hsr_stag->sequence_nr = htons(hsr->sequence_nr); | |
427 | hsr->sequence_nr++; | |
428 | spin_unlock_irqrestore(&hsr->seqnr_lock, irqflags); | |
f421436a AB |
429 | |
430 | hsr_stag->HSR_TLV_Type = type; | |
431 | hsr_stag->HSR_TLV_Length = 12; | |
432 | ||
433 | skb_push(skb, sizeof(struct ethhdr)); | |
434 | ||
435 | /* Payload: MacAddressA */ | |
436 | hsr_sp = (typeof(hsr_sp)) skb_put(skb, sizeof(*hsr_sp)); | |
c5a75911 | 437 | ether_addr_copy(hsr_sp->MacAddressA, master->dev->dev_addr); |
f421436a AB |
438 | |
439 | dev_queue_xmit(skb); | |
440 | return; | |
441 | ||
442 | out: | |
c5a75911 | 443 | WARN_ON_ONCE("HSR: Could not send supervision frame\n"); |
f421436a AB |
444 | kfree_skb(skb); |
445 | } | |
446 | ||
447 | ||
448 | /* Announce (supervision frame) timer function | |
449 | */ | |
450 | static void hsr_announce(unsigned long data) | |
451 | { | |
70ebe4a4 | 452 | struct hsr_priv *hsr; |
c5a75911 | 453 | struct hsr_port *master; |
f421436a | 454 | |
70ebe4a4 | 455 | hsr = (struct hsr_priv *) data; |
c5a75911 | 456 | master = hsr_port_get_hsr(hsr, HSR_PT_MASTER); |
f421436a | 457 | |
70ebe4a4 | 458 | if (hsr->announce_count < 3) { |
c5a75911 | 459 | send_hsr_supervision_frame(master->dev, HSR_TLV_ANNOUNCE); |
70ebe4a4 | 460 | hsr->announce_count++; |
f421436a | 461 | } else { |
c5a75911 | 462 | send_hsr_supervision_frame(master->dev, HSR_TLV_LIFE_CHECK); |
f421436a AB |
463 | } |
464 | ||
70ebe4a4 AB |
465 | if (hsr->announce_count < 3) |
466 | hsr->announce_timer.expires = jiffies + | |
f421436a AB |
467 | msecs_to_jiffies(HSR_ANNOUNCE_INTERVAL); |
468 | else | |
70ebe4a4 | 469 | hsr->announce_timer.expires = jiffies + |
f421436a AB |
470 | msecs_to_jiffies(HSR_LIFE_CHECK_INTERVAL); |
471 | ||
c5a75911 | 472 | if (is_admin_up(master->dev)) |
70ebe4a4 | 473 | add_timer(&hsr->announce_timer); |
f421436a AB |
474 | } |
475 | ||
476 | ||
f421436a AB |
477 | /* According to comments in the declaration of struct net_device, this function |
478 | * is "Called from unregister, can be used to call free_netdev". Ok then... | |
479 | */ | |
480 | static void hsr_dev_destroy(struct net_device *hsr_dev) | |
481 | { | |
70ebe4a4 | 482 | struct hsr_priv *hsr; |
c5a75911 | 483 | struct hsr_port *port; |
f421436a | 484 | |
70ebe4a4 | 485 | hsr = netdev_priv(hsr_dev); |
c5a75911 AB |
486 | hsr_for_each_port(hsr, port) |
487 | hsr_del_port(port); | |
f421436a | 488 | |
abff7162 AB |
489 | del_timer_sync(&hsr->prune_timer); |
490 | del_timer_sync(&hsr->announce_timer); | |
c5a75911 AB |
491 | |
492 | synchronize_rcu(); | |
493 | free_netdev(hsr_dev); | |
f421436a AB |
494 | } |
495 | ||
496 | static const struct net_device_ops hsr_device_ops = { | |
497 | .ndo_change_mtu = hsr_dev_change_mtu, | |
498 | .ndo_open = hsr_dev_open, | |
499 | .ndo_stop = hsr_dev_close, | |
500 | .ndo_start_xmit = hsr_dev_xmit, | |
1cc1eb52 | 501 | .ndo_fix_features = hsr_fix_features, |
f421436a AB |
502 | }; |
503 | ||
4c3477dc AB |
504 | static struct device_type hsr_type = { |
505 | .name = "hsr", | |
506 | }; | |
f421436a AB |
507 | |
508 | void hsr_dev_setup(struct net_device *dev) | |
509 | { | |
510 | random_ether_addr(dev->dev_addr); | |
511 | ||
512 | ether_setup(dev); | |
4c3477dc AB |
513 | dev->header_ops = &hsr_header_ops; |
514 | dev->netdev_ops = &hsr_device_ops; | |
515 | SET_NETDEV_DEVTYPE(dev, &hsr_type); | |
516 | dev->tx_queue_len = 0; | |
f421436a AB |
517 | |
518 | dev->destructor = hsr_dev_destroy; | |
1cc1eb52 AB |
519 | |
520 | dev->hw_features = NETIF_F_SG | NETIF_F_FRAGLIST | NETIF_F_HIGHDMA | | |
521 | NETIF_F_GSO_MASK | NETIF_F_HW_CSUM | | |
522 | NETIF_F_HW_VLAN_CTAG_TX; | |
523 | ||
524 | dev->features = dev->hw_features; | |
525 | ||
526 | /* Prevent recursive tx locking */ | |
527 | dev->features |= NETIF_F_LLTX; | |
528 | /* VLAN on top of HSR needs testing and probably some work on | |
529 | * hsr_header_create() etc. | |
530 | */ | |
531 | dev->features |= NETIF_F_VLAN_CHALLENGED; | |
4c3477dc AB |
532 | /* Not sure about this. Taken from bridge code. netdev_features.h says |
533 | * it means "Does not change network namespaces". | |
534 | */ | |
535 | dev->features |= NETIF_F_NETNS_LOCAL; | |
f421436a AB |
536 | } |
537 | ||
538 | ||
539 | /* Return true if dev is a HSR master; return false otherwise. | |
540 | */ | |
c5a75911 | 541 | inline bool is_hsr_master(struct net_device *dev) |
f421436a AB |
542 | { |
543 | return (dev->netdev_ops->ndo_start_xmit == hsr_dev_xmit); | |
544 | } | |
545 | ||
f421436a | 546 | /* Default multicast address for HSR Supervision frames */ |
e83abe37 | 547 | static const unsigned char def_multicast_addr[ETH_ALEN] __aligned(2) = { |
f421436a AB |
548 | 0x01, 0x15, 0x4e, 0x00, 0x01, 0x00 |
549 | }; | |
550 | ||
551 | int hsr_dev_finalize(struct net_device *hsr_dev, struct net_device *slave[2], | |
552 | unsigned char multicast_spec) | |
553 | { | |
70ebe4a4 | 554 | struct hsr_priv *hsr; |
c5a75911 | 555 | struct hsr_port *port; |
f421436a AB |
556 | int res; |
557 | ||
70ebe4a4 | 558 | hsr = netdev_priv(hsr_dev); |
c5a75911 | 559 | INIT_LIST_HEAD(&hsr->ports); |
70ebe4a4 AB |
560 | INIT_LIST_HEAD(&hsr->node_db); |
561 | INIT_LIST_HEAD(&hsr->self_node_db); | |
51f3c605 AB |
562 | |
563 | ether_addr_copy(hsr_dev->dev_addr, slave[0]->dev_addr); | |
564 | ||
565 | /* Make sure we recognize frames from ourselves in hsr_rcv() */ | |
566 | res = hsr_create_self_node(&hsr->self_node_db, hsr_dev->dev_addr, | |
567 | slave[1]->dev_addr); | |
568 | if (res < 0) | |
569 | return res; | |
570 | ||
70ebe4a4 | 571 | spin_lock_init(&hsr->seqnr_lock); |
f421436a | 572 | /* Overflow soon to find bugs easier: */ |
70ebe4a4 | 573 | hsr->sequence_nr = USHRT_MAX - 1024; |
f421436a | 574 | |
70ebe4a4 AB |
575 | init_timer(&hsr->announce_timer); |
576 | hsr->announce_timer.function = hsr_announce; | |
577 | hsr->announce_timer.data = (unsigned long) hsr; | |
f421436a | 578 | |
abff7162 AB |
579 | init_timer(&hsr->prune_timer); |
580 | hsr->prune_timer.function = hsr_prune_nodes; | |
581 | hsr->prune_timer.data = (unsigned long) hsr; | |
582 | ||
70ebe4a4 AB |
583 | ether_addr_copy(hsr->sup_multicast_addr, def_multicast_addr); |
584 | hsr->sup_multicast_addr[ETH_ALEN - 1] = multicast_spec; | |
f421436a | 585 | |
c5a75911 AB |
586 | /* FIXME: should I modify the value of these? |
587 | * | |
588 | * - hsr_dev->flags - i.e. | |
589 | * IFF_MASTER/SLAVE? | |
590 | * - hsr_dev->priv_flags - i.e. | |
591 | * IFF_EBRIDGE? | |
592 | * IFF_TX_SKB_SHARING? | |
593 | * IFF_HSR_MASTER/SLAVE? | |
594 | */ | |
f421436a | 595 | |
f421436a AB |
596 | /* Make sure the 1st call to netif_carrier_on() gets through */ |
597 | netif_carrier_off(hsr_dev); | |
598 | ||
c5a75911 | 599 | res = hsr_add_port(hsr, hsr_dev, HSR_PT_MASTER); |
f421436a | 600 | if (res) |
51f3c605 AB |
601 | return res; |
602 | ||
c5a75911 | 603 | res = register_netdevice(hsr_dev); |
51f3c605 | 604 | if (res) |
c5a75911 AB |
605 | goto fail; |
606 | ||
607 | res = hsr_add_port(hsr, slave[0], HSR_PT_SLAVE_A); | |
608 | if (res) | |
609 | goto fail; | |
610 | res = hsr_add_port(hsr, slave[1], HSR_PT_SLAVE_B); | |
611 | if (res) | |
612 | goto fail; | |
f421436a | 613 | |
abff7162 AB |
614 | hsr->prune_timer.expires = jiffies + msecs_to_jiffies(PRUNE_PERIOD); |
615 | add_timer(&hsr->prune_timer); | |
616 | ||
f421436a | 617 | return 0; |
c5a75911 AB |
618 | |
619 | fail: | |
620 | hsr_for_each_port(hsr, port) | |
621 | hsr_del_port(port); | |
622 | ||
623 | return res; | |
f421436a | 624 | } |