1/* SPDX-License-Identifier: GPL-2.0 */
  2/* Copyright 2011-2014 Autronica Fire and Security AS
 
 
 
 
  3 *
  4 * Author(s):
  5 *	2011-2014 Arvid Brodin, arvid.brodin@alten.se
  6 */
  7
  8#ifndef __HSR_PRIVATE_H
  9#define __HSR_PRIVATE_H
 10
 11#include <linux/netdevice.h>
 12#include <linux/list.h>
 13
 
 14/* Time constants as specified in the HSR specification (IEC-62439-3 2010)
 15 * Table 8.
 16 * All values in milliseconds.
 17 */
 18#define HSR_LIFE_CHECK_INTERVAL		 2000 /* ms */
 19#define HSR_NODE_FORGET_TIME		60000 /* ms */
 20#define HSR_ANNOUNCE_INTERVAL		  100 /* ms */
 21
 
 22/* By how much may slave1 and slave2 timestamps of latest received frame from
 23 * each node differ before we notify of communication problem?
 24 */
 25#define MAX_SLAVE_DIFF			 3000 /* ms */
 26#define HSR_SEQNR_START			(USHRT_MAX - 1024)
 27#define HSR_SUP_SEQNR_START		(HSR_SEQNR_START / 2)
 28
 29/* How often shall we check for broken ring and remove node entries older than
 30 * HSR_NODE_FORGET_TIME?
 31 */
 32#define PRUNE_PERIOD			 3000 /* ms */
 33
 
 34#define HSR_TLV_ANNOUNCE		   22
 35#define HSR_TLV_LIFE_CHECK		   23
 36
 
 37/* HSR Tag.
 38 * As defined in IEC-62439-3:2010, the HSR tag is really { ethertype = 0x88FB,
 39 * path, LSDU_size, sequence Nr }. But we let eth_header() create { h_dest,
 40 * h_source, h_proto = 0x88FB }, and add { path, LSDU_size, sequence Nr,
 41 * encapsulated protocol } instead.
 42 *
 43 * Field names as defined in the IEC:2010 standard for HSR.
 44 */
 
 
 
 45struct hsr_tag {
 46	__be16		path_and_LSDU_size;
 47	__be16		sequence_nr;
 48	__be16		encap_proto;
 49} __packed;
 50
 51#define HSR_HLEN	6
 52
 53#define HSR_V1_SUP_LSDUSIZE		52
 54
 55/* The helper functions below assumes that 'path' occupies the 4 most
 56 * significant bits of the 16-bit field shared by 'path' and 'LSDU_size' (or
 57 * equivalently, the 4 most significant bits of HSR tag byte 14).
 58 *
 59 * This is unclear in the IEC specification; its definition of MAC addresses
 60 * indicates the spec is written with the least significant bit first (to the
 61 * left). This, however, would mean that the LSDU field would be split in two
 62 * with the path field in-between, which seems strange. I'm guessing the MAC
 63 * address definition is in error.
 64 */
 65static inline u16 get_hsr_tag_path(struct hsr_tag *ht)
 66{
 67	return ntohs(ht->path_and_LSDU_size) >> 12;
 68}
 69
 70static inline u16 get_hsr_tag_LSDU_size(struct hsr_tag *ht)
 71{
 72	return ntohs(ht->path_and_LSDU_size) & 0x0FFF;
 73}
 74
 75static inline void set_hsr_tag_path(struct hsr_tag *ht, u16 path)
 76{
 77	ht->path_and_LSDU_size =
 78		htons((ntohs(ht->path_and_LSDU_size) & 0x0FFF) | (path << 12));
 79}
 80
 81static inline void set_hsr_tag_LSDU_size(struct hsr_tag *ht, u16 LSDU_size)
 82{
 83	ht->path_and_LSDU_size = htons((ntohs(ht->path_and_LSDU_size) &
 84				       0xF000) | (LSDU_size & 0x0FFF));
 
 85}
 86
 87struct hsr_ethhdr {
 88	struct ethhdr	ethhdr;
 89	struct hsr_tag	hsr_tag;
 90} __packed;
 91
 
 92/* HSR Supervision Frame data types.
 93 * Field names as defined in the IEC:2010 standard for HSR.
 94 */
 95struct hsr_sup_tag {
 96	__be16		path_and_HSR_ver;
 97	__be16		sequence_nr;
 98	__u8		HSR_TLV_type;
 99	__u8		HSR_TLV_length;
100} __packed;
101
102struct hsr_sup_payload {
103	unsigned char	macaddress_A[ETH_ALEN];
104} __packed;
105
106static inline u16 get_hsr_stag_path(struct hsr_sup_tag *hst)
107{
108	return get_hsr_tag_path((struct hsr_tag *)hst);
109}
110
111static inline u16 get_hsr_stag_HSR_ver(struct hsr_sup_tag *hst)
112{
113	return get_hsr_tag_LSDU_size((struct hsr_tag *)hst);
114}
115
116static inline void set_hsr_stag_path(struct hsr_sup_tag *hst, u16 path)
117{
118	set_hsr_tag_path((struct hsr_tag *)hst, path);
119}
120
121static inline void set_hsr_stag_HSR_ver(struct hsr_sup_tag *hst, u16 HSR_ver)
122{
123	set_hsr_tag_LSDU_size((struct hsr_tag *)hst, HSR_ver);
124}
125
126struct hsrv0_ethhdr_sp {
127	struct ethhdr		ethhdr;
128	struct hsr_sup_tag	hsr_sup;
129} __packed;
130
131struct hsrv1_ethhdr_sp {
132	struct ethhdr		ethhdr;
133	struct hsr_tag		hsr;
134	struct hsr_sup_tag	hsr_sup;
135} __packed;
136
137enum hsr_port_type {
138	HSR_PT_NONE = 0,	/* Must be 0, used by framereg */
139	HSR_PT_SLAVE_A,
140	HSR_PT_SLAVE_B,
141	HSR_PT_INTERLINK,
142	HSR_PT_MASTER,
143	HSR_PT_PORTS,	/* This must be the last item in the enum */
144};
145
146struct hsr_port {
147	struct list_head	port_list;
148	struct net_device	*dev;
149	struct hsr_priv		*hsr;
150	enum hsr_port_type	type;
151};
 
 
152
153struct hsr_priv {
 
154	struct rcu_head		rcu_head;
155	struct list_head	ports;
156	struct list_head	node_db;	/* Known HSR nodes */
 
157	struct list_head	self_node_db;	/* MACs of slaves */
158	struct timer_list	announce_timer;	/* Supervision frame dispatch */
159	struct timer_list	prune_timer;
160	int announce_count;
161	u16 sequence_nr;
162	u16 sup_sequence_nr;	/* For HSRv1 separate seq_nr for supervision */
163	u8 prot_version;		/* Indicate if HSRv0 or HSRv1. */
164	spinlock_t seqnr_lock;			/* locking for sequence_nr */
165	unsigned char		sup_multicast_addr[ETH_ALEN];
166#ifdef	CONFIG_DEBUG_FS
167	struct dentry *node_tbl_root;
168	struct dentry *node_tbl_file;
169#endif
170};
171
172#define hsr_for_each_port(hsr, port) \
173	list_for_each_entry_rcu((port), &(hsr)->ports, port_list)
174
175struct hsr_port *hsr_port_get_hsr(struct hsr_priv *hsr, enum hsr_port_type pt);
176
177/* Caller must ensure skb is a valid HSR frame */
178static inline u16 hsr_get_skb_sequence_nr(struct sk_buff *skb)
179{
180	struct hsr_ethhdr *hsr_ethhdr;
181
182	hsr_ethhdr = (struct hsr_ethhdr *)skb_mac_header(skb);
183	return ntohs(hsr_ethhdr->hsr_tag.sequence_nr);
184}
185
186#if IS_ENABLED(CONFIG_DEBUG_FS)
187int hsr_debugfs_init(struct hsr_priv *priv, struct net_device *hsr_dev);
188void hsr_debugfs_term(struct hsr_priv *priv);
189#else
190static inline int hsr_debugfs_init(struct hsr_priv *priv,
191				   struct net_device *hsr_dev)
192{
193	return 0;
194}
195
196static inline void hsr_debugfs_term(struct hsr_priv *priv)
197{}
198#endif
199
200#endif /*  __HSR_PRIVATE_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. */
 53struct 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 */
 70static inline u16 get_hsr_tag_path(struct hsr_tag *ht)
 71{
 72	return ntohs(ht->path_and_LSDU_size) >> 12;
 73}
 74
 75static inline u16 get_hsr_tag_LSDU_size(struct hsr_tag *ht)
 76{
 77	return ntohs(ht->path_and_LSDU_size) & 0x0FFF;
 78}
 79
 80static 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
 86static 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
 93struct 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 */
102struct 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
109struct hsr_sup_payload {
110	unsigned char	MacAddressA[ETH_ALEN];
111} __packed;
112
113static inline u16 get_hsr_stag_path(struct hsr_sup_tag *hst)
114{
115	return get_hsr_tag_path((struct hsr_tag *) hst);
116}
117
118static 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
123static 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
128static 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
133struct hsr_ethhdr_sp {
134	struct ethhdr		ethhdr;
135	struct hsr_sup_tag	hsr_sup;
136} __packed;
137
 
 
 
 
 
138
139enum 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
148struct 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
162void register_hsr_master(struct hsr_priv *hsr_priv);
163void unregister_hsr_master(struct hsr_priv *hsr_priv);
164bool is_hsr_slave(struct net_device *dev);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
165
166#endif /*  _HSR_PRIVATE_H */