net/hsr/hsr_main.h

   1 /* Copyright 2011-2013 Autronica Fire and Security AS
   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):
   9  *      2011-2013 Arvid Brodin, arvid.brodin@xdin.com
  10  */
  11
  12 #ifndef _HSR_PRIVATE_H
  13 #define _HSR_PRIVATE_H
  14
  15 #include <linux/netdevice.h>
  16 #include <linux/list.h>
  17
  18
  19 /* Time constants as specified in the HSR specification (IEC-62439-3 2010)
  20  * Table 8.
  21  * All values in milliseconds.
  22  */
  23 #define HSR_LIFE_CHECK_INTERVAL          2000 /* ms */
  24 #define HSR_NODE_FORGET_TIME            60000 /* ms */
  25 #define HSR_ANNOUNCE_INTERVAL             100 /* ms */
  26
  27
  28 /* By how much may slave1 and slave2 timestamps of latest received frame from
  29  * each node differ before we notify of communication problem?
  30  */
  31 #define MAX_SLAVE_DIFF                   3000 /* ms */
  32
  33
  34 /* How often shall we check for broken ring and remove node entries older than
  35  * HSR_NODE_FORGET_TIME?
  36  */
  37 #define PRUNE_PERIOD                     3000 /* ms */
  38
  39
  40 #define HSR_TLV_ANNOUNCE                   22
  41 #define HSR_TLV_LIFE_CHECK                 23
  42
  43
  44 /* HSR Tag.
  45  * As defined in IEC-62439-3:2010, the HSR tag is really { ethertype = 0x88FB,
  46  * path, LSDU_size, sequence Nr }. But we let eth_header() create { h_dest,
  47  * h_source, h_proto = 0x88FB }, and add { path, LSDU_size, sequence Nr,
  48  * encapsulated protocol } instead.
  49  */
  50 #define HSR_TAGLEN      6
  51
  52 /* Field names below as defined in the IEC:2010 standard for HSR. */
  53 struct hsr_tag {
  54         __be16          path_and_LSDU_size;
  55         __be16          sequence_nr;
  56         __be16          encap_proto;
  57 } __packed;
  58
  59
  60 /* The helper functions below assumes that 'path' occupies the 4 most
  61  * significant bits of the 16-bit field shared by 'path' and 'LSDU_size' (or
  62  * equivalently, the 4 most significant bits of HSR tag byte 14).
  63  *
  64  * This is unclear in the IEC specification; its definition of MAC addresses
  65  * indicates the spec is written with the least significant bit first (to the
  66  * left). This, however, would mean that the LSDU field would be split in two
  67  * with the path field in-between, which seems strange. I'm guessing the MAC
  68  * address definition is in error.
  69  */
  70 static inline u16 get_hsr_tag_path(struct hsr_tag *ht)
  71 {
  72         return ntohs(ht->path_and_LSDU_size) >> 12;
  73 }
  74
  75 static inline u16 get_hsr_tag_LSDU_size(struct hsr_tag *ht)
  76 {
  77         return ntohs(ht->path_and_LSDU_size) & 0x0FFF;
  78 }
  79
  80 static inline void set_hsr_tag_path(struct hsr_tag *ht, u16 path)
  81 {
  82         ht->path_and_LSDU_size = htons(
  83                         (ntohs(ht->path_and_LSDU_size) & 0x0FFF) | (path << 12));
  84 }
  85
  86 static inline void set_hsr_tag_LSDU_size(struct hsr_tag *ht, u16 LSDU_size)
  87 {
  88         ht->path_and_LSDU_size = htons(
  89                         (ntohs(ht->path_and_LSDU_size) & 0xF000) |
  90                         (LSDU_size & 0x0FFF));
  91 }
  92
  93 struct hsr_ethhdr {
  94         struct ethhdr   ethhdr;
  95         struct hsr_tag  hsr_tag;
  96 } __packed;
  97
  98
  99 /* HSR Supervision Frame data types.
 100  * Field names as defined in the IEC:2010 standard for HSR.
 101  */
 102 struct hsr_sup_tag {
 103         __be16          path_and_HSR_Ver;
 104         __be16          sequence_nr;
 105         __u8            HSR_TLV_Type;
 106         __u8            HSR_TLV_Length;
 107 } __packed;
 108
 109 struct hsr_sup_payload {
 110         unsigned char   MacAddressA[ETH_ALEN];
 111 } __packed;
 112
 113 static inline u16 get_hsr_stag_path(struct hsr_sup_tag *hst)
 114 {
 115         return get_hsr_tag_path((struct hsr_tag *) hst);
 116 }
 117
 118 static inline u16 get_hsr_stag_HSR_ver(struct hsr_sup_tag *hst)
 119 {
 120         return get_hsr_tag_LSDU_size((struct hsr_tag *) hst);
 121 }
 122
 123 static inline void set_hsr_stag_path(struct hsr_sup_tag *hst, u16 path)
 124 {
 125         set_hsr_tag_path((struct hsr_tag *) hst, path);
 126 }
 127
 128 static inline void set_hsr_stag_HSR_Ver(struct hsr_sup_tag *hst, u16 HSR_Ver)
 129 {
 130         set_hsr_tag_LSDU_size((struct hsr_tag *) hst, HSR_Ver);
 131 }
 132
 133 struct hsr_ethhdr_sp {
 134         struct ethhdr           ethhdr;
 135         struct hsr_sup_tag      hsr_sup;
 136 } __packed;
 137
 138
 139 enum hsr_dev_idx {
 140         HSR_DEV_NONE = -1,
 141         HSR_DEV_SLAVE_A = 0,
 142         HSR_DEV_SLAVE_B,
 143         HSR_DEV_MASTER,
 144 };
 145 #define HSR_MAX_SLAVE   (HSR_DEV_SLAVE_B + 1)
 146 #define HSR_MAX_DEV     (HSR_DEV_MASTER + 1)
 147
 148 struct hsr_priv {
 149         struct list_head        hsr_list;       /* List of hsr devices */
 150         struct rcu_head         rcu_head;
 151         struct net_device       *dev;
 152         struct net_device       *slave[HSR_MAX_SLAVE];
 153         struct list_head        node_db;        /* Other HSR nodes */
 154         struct list_head        self_node_db;   /* MACs of slaves */
 155         struct timer_list       announce_timer; /* Supervision frame dispatch */
 156         int announce_count;
 157         u16 sequence_nr;
 158         spinlock_t seqnr_lock;                  /* locking for sequence_nr */
 159         unsigned char           sup_multicast_addr[ETH_ALEN];
 160 };
 161
 162 void register_hsr_master(struct hsr_priv *hsr_priv);
 163 void unregister_hsr_master(struct hsr_priv *hsr_priv);
 164 bool is_hsr_slave(struct net_device *dev);
 165
 166 #endif /*  _HSR_PRIVATE_H */