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 */ 167