Re: [very-RFC 1/8] TSN: add documentation

Re: [very-RFC 1/8] TSN: add documentation

[Henrik Austad]

[-- Attachment #1: Type: text/plain, Size: 414 bytes --]

On Sat, Jun 11, 2016 at 03:35:10PM -0700, David Miller wrote:
> 
> Networking patches not CC:'d to netdev@vger.kernel.org are unlikely to
> be reviewed by networking developers at all.

Oh no! I messed up git send-email and wrote linux-netdev@vger instead of 
netdev@vger.

What would be the best approach? Resend series to netdev@vger? I don't want 
to spam too many lists either.

-- 
Henrik Austad

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 181 bytes --]

Re: [very-RFC 1/8] TSN: add documentation

[David Miller]

From: Henrik Austad <henrik@austad.us>
Date: Sun, 12 Jun 2016 00:47:28 +0200

> What would be the best approach? Resend series to netdev@vger? I don't want 
> to spam too many lists either.

Resend to all the lists.

Re: [very-RFC 0/8] TSN driver for the kernel

[Henrik Austad]

On Sun, Jun 12, 2016 at 12:22:13AM +0200, Henrik Austad wrote:
> Hi all

Sorry.. I somehow managed to mess up the address to netdev, so if you feel 
like replying to this, use this as it has the correct netdev-address.

again, sorry

> (series based on v4.7-rc2)
> 
> This is a *very* early RFC for a TSN-driver in the kernel. It has been
> floating around in my repo for a while and I would appreciate some
> feedback on the overall design to avoid doing some major blunders.
> 
> TSN: Time Sensitive Networking, formely known as AVB (Audio/Video
> Bridging).
> 
> There are at least one AVB-driver (the AV-part of TSN) in the kernel
> already, however this driver aims to solve a wider scope as TSN can do
> much more than just audio. A very basic ALSA-driver is added to the end
> that allows you to play music between 2 machines using aplay in one end
> and arecord | aplay on the other (some fiddling required) We have plans
> for doing the same for v4l2 eventually (but there are other fishes to
> fry first). The same goes for a TSN_SOCK type approach as well.
> 
> TSN is all about providing infrastructure. Allthough there are a few
> very interesting uses for TSN (reliable, deterministic network for audio
> and video), once you have that reliable link, you can do a lot more.
> 
> Some notes on the design:
> 
> The driver is directed via ConfigFS as we need userspace to handle
> stream-reservation (MSRP), discovery and enumeration (IEEE 1722.1) and
> whatever other management is needed. Once we have all the required
> attributes, we can create link using mkdir, and use write() to set the
> attributes. Once ready, specify the 'shim' (basically a thin wrapper
> between TSN and another subsystem) and we start pushing out frames.
> 
> The network part: it ties directly into the rx-handler for receive and
> writes skb's using netdev_start_xmit(). This could probably be
> improved. 2 new fields in netdev_ops have been introduced, and the Intel
> igb-driver has been updated (as this is available as a PCI-e card). The
> igb-driver works-ish
> 
> 
> What remains
> - tie to (g)PTP properly, currently using ktime_get() for presentation
>   time
> - get time from shim into TSN and vice versa
> - let shim create/manage buffer
> 
> Henrik Austad (8):
>   TSN: add documentation
>   TSN: Add the standard formerly known as AVB to the kernel
>   Adding TSN-driver to Intel I210 controller
>   Add TSN header for the driver
>   Add TSN machinery to drive the traffic from a shim over the network
>   Add TSN event-tracing
>   AVB ALSA - Add ALSA shim for TSN
>   MAINTAINERS: add TSN/AVB-entries
> 
>  Documentation/TSN/tsn.txt                 | 147 +++++
>  MAINTAINERS                               |  14 +
>  drivers/media/Kconfig                     |  15 +
>  drivers/media/Makefile                    |   3 +-
>  drivers/media/avb/Makefile                |   5 +
>  drivers/media/avb/avb_alsa.c              | 742 +++++++++++++++++++++++
>  drivers/media/avb/tsn_iec61883.h          | 124 ++++
>  drivers/net/ethernet/intel/Kconfig        |  18 +
>  drivers/net/ethernet/intel/igb/Makefile   |   2 +-
>  drivers/net/ethernet/intel/igb/igb.h      |  19 +
>  drivers/net/ethernet/intel/igb/igb_main.c |  10 +-
>  drivers/net/ethernet/intel/igb/igb_tsn.c  | 396 ++++++++++++
>  include/linux/netdevice.h                 |  32 +
>  include/linux/tsn.h                       | 806 ++++++++++++++++++++++++
>  include/trace/events/tsn.h                | 349 +++++++++++
>  net/Kconfig                               |   1 +
>  net/Makefile                              |   1 +
>  net/tsn/Kconfig                           |  32 +
>  net/tsn/Makefile                          |   6 +
>  net/tsn/tsn_configfs.c                    | 623 +++++++++++++++++++
>  net/tsn/tsn_core.c                        | 975 ++++++++++++++++++++++++++++++
>  net/tsn/tsn_header.c                      | 203 +++++++
>  net/tsn/tsn_internal.h                    | 383 ++++++++++++
>  net/tsn/tsn_net.c                         | 403 ++++++++++++
>  24 files changed, 5306 insertions(+), 3 deletions(-)
>  create mode 100644 Documentation/TSN/tsn.txt
>  create mode 100644 drivers/media/avb/Makefile
>  create mode 100644 drivers/media/avb/avb_alsa.c
>  create mode 100644 drivers/media/avb/tsn_iec61883.h
>  create mode 100644 drivers/net/ethernet/intel/igb/igb_tsn.c
>  create mode 100644 include/linux/tsn.h
>  create mode 100644 include/trace/events/tsn.h
>  create mode 100644 net/tsn/Kconfig
>  create mode 100644 net/tsn/Makefile
>  create mode 100644 net/tsn/tsn_configfs.c
>  create mode 100644 net/tsn/tsn_core.c
>  create mode 100644 net/tsn/tsn_header.c
>  create mode 100644 net/tsn/tsn_internal.h
>  create mode 100644 net/tsn/tsn_net.c
> 
> --
> 2.7.4

-- 
Henrik Austad

Re: [very-RFC 1/8] TSN: add documentation

[Henrik Austad]

On Sun, Jun 12, 2016 at 12:22:14AM +0200, Henrik Austad wrote:
> From: Henrik Austad <haustad@cisco.com>

Clearing up the netdev-typo

> 
> Describe the overall design behind the TSN standard, the TSN-driver,
> requirements to userspace and new functionality introduced.
> 
> Cc: "David S. Miller" <davem@davemloft.net>
> Signed-off-by: Henrik Austad <haustad@cisco.com>
> ---
>  Documentation/TSN/tsn.txt | 147 ++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 147 insertions(+)
>  create mode 100644 Documentation/TSN/tsn.txt
> 
> Index: linux/Documentation/TSN/tsn.txt
> ===================================================================
> --- /dev/null
> +++ linux/Documentation/TSN/tsn.txt
> @@ -0,0 +1,188 @@
> +		Time Sensitive Networking (TSN)
> +		-------------------------------
> +
> +[work in progress]
> +
> +1. Motivation
> +=============
> +
> +TSN is a set of open standards, formerly known as 'AVB' (Audio/Video
> +Bridging). It was renamed to TSN to better reflect that it can do much
> +more than just media transport.
> +
> +TSN is a way to create reliable streams across a network without loss of
> +frames due to congestion in the network. By using gPTP (a specialized
> +IEEE-1588v2 PTP profile), the time can be synchronized with sub-us
> +granularity across all the connected devices in the AVB domain.
> +
> +2. Intro to AVB/TSN
> +===================
> +
> +The original standards were written with Audio/Video in mind, so the
> +initial standards refer to this as 'AVB'. In later standards, this has
> +changed to TSN, and AVB now refers to a service you can add on top of
> +TSN. Hopefully it will not be too confusing.
> +
> +In this document, we refer to the infrastructure part as TSN and AVB to
> +the ALSA/V4L2 shim which can be added on top of TSN to provide a
> +media-service.
> +
> +TSN operates with 'streams', and one stream can contain pretty much
> +whatever you like. Currently, only media has been defined properly
> +though, which is why you only have media-subtypes for the
> +avtp_subtype-field.
> +
> +For a media-setup, one stream can contain multiple channels, all going
> +to the same destination. A destination can be a single Listener
> +(singlecast) or a group of Listeners (multicast).
> +
> +2.1 Endpoints
> +
> +A TSN 'endpoint' is where a stream either originates or ends -what
> +others would call sources (Talkers) and sinks (Listeners). Looking back
> +at pre-TSN when this was called AVB, these names make a bit more sense.
> +
> +Common for both types, they need to be PTPv2 capable, i.e. you need to
> +timestamp gPTP frames upon ingress/egress to improve the accuracy of
> +PTP.
> +
> +2.1.1 Talkers
> +
> +Hardware requirements:
> +- Multiple Tx-queues
> +- Credit based shaper on at least one of the queues for pacing the
> +  frames onto the network
> +- VLAN capable
> +
> +2.1.2 Listener
> +
> +A Listener does not have the same requirements as a Talker as it cannot
> +control the pace of the incoming frames anyway. It is beneficial if the
> +NIC understands VLANs and has a few Rx-queues so that you can steer all
> +TSN-frames to a dedicated queue.
> +
> +2.2 Bridges
> +
> +What TSN calls switches that are TSN-capable. They must be able to
> +prioritize TSN-streams, have the credit-based shaper available for that
> +class, support SRP, support gPTP and so on.
> +
> +2.3 Relevant standards
> +
> +* IEEE 802.1BA-2011 Audio Video Bridging (AVB) Systems
> +
> +* IEEE 802.1Q-2011 sec 34 and 35
> +
> +  What is referred to as:
> +  IEEE 802.1Qav (Forwarding and Queueing for Time-sensitive Streams)
> +  IEEE 802.1Qat (Stream Registration protocol)
> +
> +* IEEE 802.1AS gPTP
> +
> +  A PTPv2 profile (from IEEE 1588) tailored for this domain. Notable
> +  changes include the requirement that all nodes in the network must be
> +  gPTP capable (i.e. no traversing non-PTP entities), and it allows
> +  traffic over a wider range of medium that what "pure" PTPv2 allows.
> +
> +* IEEE 1722 AVTP Layer 2 Transport Protocol for Time-Sensitive
> +  Applications in Bridged Local Area Networks
> +
> +* IEEE 1722.1 Device Discovery, Connection Management and Control for 1722
> +
> +  What allows AVB (TSN) devices to handle discovery, enumeration and
> +  control, basically let you connect 2 devices from a 3rd
> +
> +  In this (in the scope of the Linux kernel TSN driver) must be done
> +  purely from userspace as we do not want the kernel to suddenly attach
> +  to a remote system without the user's knowledge. This is further
> +  reflected in how the attributes for the link is managed via ConfigFS.
> +
> +
> +3. Overview and/or design of the TSN-driver
> +===========================================
> +
> +The driver handles the shifting of data for TSN-streams. Anything else
> +is left for userspace to handle. This includes stream reservation (using
> +some sort of MSRP client), negotiating multicast addresses, finding the
> +value of the different attributes and connect application(s) to the
> +exposed devices (currently we only have an ALSA-device).
> +
> +       	       /--------------------\
> +       	       |                    |
> +	       |  Media application |
> +	       |       	       	    |
> +	       \--------------------/
> +		     | 	      |
> +       	  +----------+	      +----+
> +	  | 			   |
> +	  | 			   |
> +     +------------+		   |
> +     |   ALSA  	  |		   |
> +     +------------+		   |
> +	  |			   |
> +	  |			   |
> +     +------------+          +--------------+
> +     | 	avb_alsa  | 	     | tsn_configfs |
> +     | (tsn-shim) |	     +--------------+
> +     +------------+ 		   |
> +       	  |  	    		   |
> +	  |    	  		   |
> +	  +------+     	  	   |
> +	   	 |		   |
> +       	       	 |		   |
> +            +------------+	   |
> + 	    |  tsn_core  |<--------+
> +            +------------+
> +       	       	 |
> +		 |
> +            +------------+
> +       	    |  tsn_net   |
> +            +------------+
> +		 |
> +		 |
> +	    +------------+
> +	    |  network	 |
> +       	    | subsystem  |
> +	    +------------+
> +	       	 |
> +		 |
> +		...
> +
> +
> +3.1 Terms and concepts
> +
> +TSN uses the concept of streams and shims.
> +
> +- A shim is a thin wrapper that binds TSN to another subsystem (or
> +  directly to userspace). avb_alsa is an example of such a shim.
> +
> +- A stream is the only data TSN cares about. What the data inside the
> +  stream represents, is left for the associated shim to handle. TSN will
> +  verify the headers up to the protocol specific header and then pass it
> +  along to the shim.
> +
> +Note: currently, only the data-unit part is implemented, the control
> +part, in which 1722.1 (discovery and enumeration) is part, is not
> +handled.
> +
> +3.2 Userspace requirements
> +
> +(msrp-client, "tsnctl"-tool
> +
> +4. Creating a new link from userspace
> +=====================================
> +
> +[coming]
> +
> +
> +5. Creating a new shim
> +======================
> +
> +shim_ops
> +[coming]
> +
> +
> +6. Other resources:
> +===================
> +
> +https://en.wikipedia.org/wiki/Audio_Video_Bridging

-- 
Henrik Austad

Re: [very-RFC 1/8] TSN: add documentation

[Henrik Austad]

[-- Attachment #1: Type: text/plain, Size: 358 bytes --]

On Sat, Jun 11, 2016 at 03:49:42PM -0700, David Miller wrote:
> From: Henrik Austad <henrik@austad.us>
> Date: Sun, 12 Jun 2016 00:47:28 +0200
> 
> > What would be the best approach? Resend series to netdev@vger? I don't want 
> > to spam too many lists either.
> 
> Resend to all the lists.

ok, I'll do that then.

Thanks

-- 
Henrik Austad

[-- Attachment #2: Digital signature --]
[-- Type: application/pgp-signature, Size: 181 bytes --]

Re: [very-RFC 2/8] TSN: Add the standard formerly known as AVB to the kernel

[Henrik Austad]

clearing up netdev-typo

On Sun, Jun 12, 2016 at 12:22:15AM +0200, Henrik Austad wrote:
> TSN provides a mechanism to create reliable, jitter-free, low latency
> guaranteed bandwidth links over a local network. It does this by
> reserving a path through the network. Support for TSN must be found in
> both the NIC as well as in the network itself.
> 
> This adds required hooks into netdev_ops so that the core TSN driver can
> use this when configuring a new NIC or setting up a new link.
> 
> Cc: "David S. Miller" <davem@davemloft.net>
> Signed-off-by: Henrik Austad <henrik@austad.us>
> ---
>  include/linux/netdevice.h | 32 ++++++++++++++++++++++++++++++++
>  net/Kconfig               |  1 +
>  net/tsn/Kconfig           | 32 ++++++++++++++++++++++++++++++++
>  3 files changed, 65 insertions(+)
>  create mode 100644 net/tsn/Kconfig
> 
> diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
> index f45929c..de025eb 100644
> --- a/include/linux/netdevice.h
> +++ b/include/linux/netdevice.h
> @@ -109,6 +109,13 @@ enum netdev_tx {
>  };
>  typedef enum netdev_tx netdev_tx_t;
>  
> +#if IS_ENABLED(CONFIG_TSN)
> +enum sr_class {
> +	SR_CLASS_A = 1,
> +	SR_CLASS_B = 2,
> +};
> +#endif
> +
>  /*
>   * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
>   * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
> @@ -902,6 +909,22 @@ struct tc_to_netdev {
>   *
>   * void (*ndo_poll_controller)(struct net_device *dev);
>   *
> + *	TSN functions (if CONFIG_TSN)
> + *
> + * int (*ndo_tsn_capable)(struct net_device *dev);
> + *	If a particular device is capable of sustaining TSN traffic
> + *	provided current configuration
> + * int (*ndo_tsn_link_configure)(struct net_device *dev,
> + *				 enum sr_class class,
> + *				 u16 framesize,
> + *				 u16 vid);
> + *     - When a new TSN link is either added or removed, this is called to
> + *       update the bandwidth for the particular stream-class
> + *     - The framesize is the size of the _entire_ frame, not just the
> + *       payload since the full size is required to allocate bandwidth through
> + *       the credit based shaper in the NIC
> + *     - the vlan_id is the configured vlan for TSN in this session.
> + *
>   *	SR-IOV management functions.
>   * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
>   * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos);
> @@ -1148,6 +1171,15 @@ struct net_device_ops {
>  #ifdef CONFIG_NET_RX_BUSY_POLL
>  	int			(*ndo_busy_poll)(struct napi_struct *dev);
>  #endif
> +
> +#if IS_ENABLED(CONFIG_TSN)
> +	int			(*ndo_tsn_capable)(struct net_device *dev);
> +	int			(*ndo_tsn_link_configure)(struct net_device *dev,
> +							  enum sr_class class,
> +							  u16 framesize,
> +							  u16 vid);
> +#endif	/* CONFIG_TSN */
> +
>  	int			(*ndo_set_vf_mac)(struct net_device *dev,
>  						  int queue, u8 *mac);
>  	int			(*ndo_set_vf_vlan)(struct net_device *dev,
> diff --git a/net/Kconfig b/net/Kconfig
> index ff40562..fa9f691 100644
> --- a/net/Kconfig
> +++ b/net/Kconfig
> @@ -215,6 +215,7 @@ source "net/802/Kconfig"
>  source "net/bridge/Kconfig"
>  source "net/dsa/Kconfig"
>  source "net/8021q/Kconfig"
> +source "net/tsn/Kconfig"
>  source "net/decnet/Kconfig"
>  source "net/llc/Kconfig"
>  source "net/ipx/Kconfig"
> diff --git a/net/tsn/Kconfig b/net/tsn/Kconfig
> new file mode 100644
> index 0000000..1fc3c1d
> --- /dev/null
> +++ b/net/tsn/Kconfig
> @@ -0,0 +1,32 @@
> +#
> +# Configuration for 802.1 Time Sensitive Networking (TSN)
> +#
> +
> +config TSN
> +	tristate "802.1 TSN Support"
> +	depends on VLAN_8021Q && PTP_1588_CLOCK && CONFIGFS_FS
> +	---help---
> +	  Select this if you want to enable TSN on capable interfaces.
> +
> +	  TSN allows you to set up deterministic links on your LAN (only
> +	  L2 is currently supported). Once loaded, the driver will probe
> +	  all available interfaces if they are capable of supporting TSN
> +	  links.
> +
> +	  Once loaded, a directory in configfs called tsn/ will expose
> +	  the capable NICs and allow userspace to create
> +	  links. Userspace must provide us with a StreamID as well as
> +	  reserving bandwidth through the network and once this is done,
> +	  a new link can be created by issuing a mkdir() in configfs and
> +	  updating the attributes for the new link.
> +
> +	  TSN itself does not produce nor consume data, it is dependent
> +	  upon 'shims' doing this, which can be virtually anything. ALSA
> +	  is a good candidate.
> +
> +	  For more information, refer to the TSN-documentation in the
> +	  kernel documentation repository.
> +
> +	  The resulting module will be called 'tsn'
> +
> +	  If unsure, say N.
> -- 
> 2.7.4
> 

-- 
Henrik Austad

Re: [very-RFC 3/8] Adding TSN-driver to Intel I210 controller

[Henrik Austad]

clearing up netdev-typo
-H

On Sun, Jun 12, 2016 at 12:22:16AM +0200, Henrik Austad wrote:
> This adds support for loading the igb.ko module with tsn
> capabilities. This requires a 2-step approach. First enabling TSN in
> .config, then load the module with use_tsn=1.
> 
> Once enabled and loaded, the controller will be placed in "Qav-mode"
> which is when the credit-based shaper is available, 3 of the queues are
> removed from regular traffic, max payload is set to 1522 octets (no
> jumboframes allowed).
> 
> It dumps the registers of interest before and after, so this clutters
> kern.log a bit. In time this will be reduced / tied to the debug-param
> for the module.
> 
> Note: currently this driver is *not* stable, it is still a work in
> progress.
> 
> Cc: Jeff Kirsher <jeffrey.t.kirsher@intel.com>
> Cc: intel-wired-lan@lists.osuosl.org
> Cc: "David S. Miller" <davem@davemloft.net>
> Signed-off-by: Henrik Austad <haustad@cisco.com>
> ---
>  drivers/net/ethernet/intel/Kconfig        |  18 ++
>  drivers/net/ethernet/intel/igb/Makefile   |   2 +-
>  drivers/net/ethernet/intel/igb/igb.h      |  19 ++
>  drivers/net/ethernet/intel/igb/igb_main.c |  10 +-
>  drivers/net/ethernet/intel/igb/igb_tsn.c  | 396 ++++++++++++++++++++++++++++++
>  5 files changed, 443 insertions(+), 2 deletions(-)
>  create mode 100644 drivers/net/ethernet/intel/igb/igb_tsn.c
> 
> diff --git a/drivers/net/ethernet/intel/Kconfig b/drivers/net/ethernet/intel/Kconfig
> index 714bd10..8e620a9 100644
> --- a/drivers/net/ethernet/intel/Kconfig
> +++ b/drivers/net/ethernet/intel/Kconfig
> @@ -99,6 +99,24 @@ config IGB
>  	  To compile this driver as a module, choose M here. The module
>  	  will be called igb.
>  
> +config IGB_TSN
> +       tristate "TSN Support for Intel(R) 82575/82576 i210 Network Controller"
> +       depends on IGB && TSN
> +	---help---
> +	  This driver supports TSN (AVB) on Intel I210 network controllers.
> +
> +	  When enabled, it will allow the module to be loaded with
> +	  "use_tsn" which will initialize the controller to A/V-mode
> +	  instead of legacy-mode. This will take 3 of the tx-queues and
> +	  place them in 802.1Q QoS mode and enable the credit-based
> +	  shaper for 2 of the queues.
> +
> +	  If built with this option, but not loaded with use_tsn, the
> +	  only difference is a slightly larger module, no extra
> +	  code paths are called.
> +
> +	  If unsure, say No
> +
>  config IGB_HWMON
>  	bool "Intel(R) PCI-Express Gigabit adapters HWMON support"
>  	default y
> diff --git a/drivers/net/ethernet/intel/igb/Makefile b/drivers/net/ethernet/intel/igb/Makefile
> index 5bcb2de..1a9b776 100644
> --- a/drivers/net/ethernet/intel/igb/Makefile
> +++ b/drivers/net/ethernet/intel/igb/Makefile
> @@ -33,4 +33,4 @@ obj-$(CONFIG_IGB) += igb.o
>  
>  igb-objs := igb_main.o igb_ethtool.o e1000_82575.o \
>  	    e1000_mac.o e1000_nvm.o e1000_phy.o e1000_mbx.o \
> -	    e1000_i210.o igb_ptp.o igb_hwmon.o
> +	    e1000_i210.o igb_ptp.o igb_hwmon.o igb_tsn.o
> diff --git a/drivers/net/ethernet/intel/igb/igb.h b/drivers/net/ethernet/intel/igb/igb.h
> index b9609af..708f705 100644
> --- a/drivers/net/ethernet/intel/igb/igb.h
> +++ b/drivers/net/ethernet/intel/igb/igb.h
> @@ -356,6 +356,7 @@ struct hwmon_buff {
>  #define IGB_RETA_SIZE	128
>  
>  /* board specific private data structure */
> +
>  struct igb_adapter {
>  	unsigned long active_vlans[BITS_TO_LONGS(VLAN_N_VID)];
>  
> @@ -472,6 +473,13 @@ struct igb_adapter {
>  	int copper_tries;
>  	struct e1000_info ei;
>  	u16 eee_advert;
> +
> +#if IS_ENABLED(CONFIG_IGB_TSN)
> +	/* Reserved BW for class A and B */
> +	u16 sra_idleslope_res;
> +	u16 srb_idleslope_res;
> +	u8 tsn_ready:1;
> +#endif	/* IGB_TSN */
>  };
>  
>  #define IGB_FLAG_HAS_MSI		BIT(0)
> @@ -552,6 +560,17 @@ void igb_ptp_rx_pktstamp(struct igb_q_vector *q_vector, unsigned char *va,
>  			 struct sk_buff *skb);
>  int igb_ptp_set_ts_config(struct net_device *netdev, struct ifreq *ifr);
>  int igb_ptp_get_ts_config(struct net_device *netdev, struct ifreq *ifr);
> +/* This should be the only place where we add ifdeffery
> + * to include tsn-stuff or not. Everything else is located in igb_tsn.c
> + */
> +#if IS_ENABLED(CONFIG_IGB_TSN)
> +void igb_tsn_init(struct igb_adapter *adapter);
> +int igb_tsn_capable(struct net_device *netdev);
> +int igb_tsn_link_configure(struct net_device *netdev, enum sr_class sr_class,
> +			   u16 framesize, u16 vid);
> +#else
> +static inline void igb_tsn_init(struct igb_adapter *adapter) { }
> +#endif	/* CONFIG_IGB_TSN */
>  void igb_set_flag_queue_pairs(struct igb_adapter *, const u32);
>  #ifdef CONFIG_IGB_HWMON
>  void igb_sysfs_exit(struct igb_adapter *adapter);
> diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
> index ef3d642..4d8789f 100644
> --- a/drivers/net/ethernet/intel/igb/igb_main.c
> +++ b/drivers/net/ethernet/intel/igb/igb_main.c
> @@ -2142,6 +2142,10 @@ static const struct net_device_ops igb_netdev_ops = {
>  #ifdef CONFIG_NET_POLL_CONTROLLER
>  	.ndo_poll_controller	= igb_netpoll,
>  #endif
> +#if IS_ENABLED(CONFIG_IGB_TSN)
> +	.ndo_tsn_capable	= igb_tsn_capable,
> +	.ndo_tsn_link_configure = igb_tsn_link_configure,
> +#endif	/* CONFIG_IGB_TSN */
>  	.ndo_fix_features	= igb_fix_features,
>  	.ndo_set_features	= igb_set_features,
>  	.ndo_fdb_add		= igb_ndo_fdb_add,
> @@ -2665,6 +2669,8 @@ static int igb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
>  	/* do hw tstamp init after resetting */
>  	igb_ptp_init(adapter);
>  
> +	igb_tsn_init(adapter);
> +
>  	dev_info(&pdev->dev, "Intel(R) Gigabit Ethernet Network Connection\n");
>  	/* print bus type/speed/width info, not applicable to i354 */
>  	if (hw->mac.type != e1000_i354) {
> @@ -5323,8 +5329,10 @@ static netdev_tx_t igb_xmit_frame(struct sk_buff *skb,
>  	/* The minimum packet size with TCTL.PSP set is 17 so pad the skb
>  	 * in order to meet this minimum size requirement.
>  	 */
> -	if (skb_put_padto(skb, 17))
> +	if (skb_put_padto(skb, 17)) {
> +		pr_err("%s: skb_put_padto FAILED. skb->len < 17\n", __func__);
>  		return NETDEV_TX_OK;
> +	}
>  
>  	return igb_xmit_frame_ring(skb, igb_tx_queue_mapping(adapter, skb));
>  }
> diff --git a/drivers/net/ethernet/intel/igb/igb_tsn.c b/drivers/net/ethernet/intel/igb/igb_tsn.c
> new file mode 100644
> index 0000000..641f4f2
> --- /dev/null
> +++ b/drivers/net/ethernet/intel/igb/igb_tsn.c
> @@ -0,0 +1,396 @@
> +/*
> + * Copyright(c) 2015-2016 Henrik Austad <haustad@cisco.com>
> + *                        Cisco Systems, Inc.
> + *
> + * This program is free software; you can redistribute it and/or modify it
> + * under the terms and conditions of the GNU General Public License,
> + * version 2, as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope it will be useful, but WITHOUT
> + * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
> + * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
> + * more details.
> + */
> +
> +/* FIXME: This should probably be handled by some Makefile-magic */
> +
> +#if IS_ENABLED(CONFIG_IGB_TSN)
> +#include "igb.h"
> +#include <linux/module.h>
> +
> +/* NOTE: keep the defines not present in e1000_regs.h to avoid
> + * cluttering too many files. Once we are pretty stable, these will move
> + * into it's proper home. Until then, make merge a bit easier by
> + * avoiding it
> + */
> +
> +/* Qav regs */
> +#define E1000_IRPBS	 0x02404 /* Rx Packet Buffer Size - RW */
> +#define E1000_ITPBS	 0x03404 /* Tx buffer size assignment */
> +#define E1000_TQAVCTRL   0x03570 /* Tx Qav Control */
> +#define E1000_DTXMXPKTSZ 0x0355C /* DMA TX Maximum Packet Size */
> +
> +/* Qav defines. */
> +#define E1000_TQAVCH_ZERO_CREDIT       0x80000000
> +#define E1000_LINK_RATE		       0x7735
> +
> +/* queue mode, 0=strict, 1=SR mode */
> +#define E1000_TQAVCC_QUEUEMODE         0x80000000
> +/* Transmit mode, 0=legacy, 1=QAV */
> +#define E1000_TQAVCTRL_TXMODE          0x00000001
> +/* report DMA time of tx packets */
> +#define E1000_TQAVCTRL_1588_STAT_EN    0x00000004
> +/* data fetch arbitration */
> +#define E1000_TQAVCTRL_DATA_FETCH_ARB  0x00000010
> +/* data tx arbitration */
> +#define E1000_TQAVCTRL_DATA_TRAN_ARB   0x00000100
> +/* data launch time valid */
> +#define E1000_TQAVCTRL_DATA_TRAN_TIM   0x00000200
> +/* stall SP to guarantee SR */
> +#define E1000_TQAVCTRL_SP_WAIT_SR      0x00000400
> +
> +/* ... and associated shift value */
> +#define E1000_TQAVCTRL_FETCH_TM_SHIFT  (16)
> +
> +/* QAV Tx mode control registers where _n can be 0 or 1. */
> +#define E1000_TQAVCC(_idx)			(0x03004 + 0x40 * (_idx))
> +
> +/* Tx Qav High Credit - See 7.2.7.6 for calculations
> + * intel 8.12.18
> + */
> +#define E1000_TQAVHC(_idx)			(0x0300C + 0x40 * (_idx))
> +
> +/* Queues priority masks where _n and _p can be 0-3. */
> +
> +#define MAX_FRAME_SIZE 1522
> +#define MIN_FRAME_SIZE   64
> +
> +static int use_tsn = -1;
> +static int debug_tsn = -1;
> +module_param(use_tsn, int, 0);
> +module_param(debug_tsn, int, 0);
> +MODULE_PARM_DESC(use_tsn, "use_tsn (0=off, 1=enabled)");
> +MODULE_PARM_DESC(debug_tsn, "debug_tsn (0=off, 1=enabled)");
> +
> +/* For a full list of the registers dumped here, see sec 8.1.3 in the
> + * i210 controller datasheet.
> + */
> +static inline void _tsn_dump_regs(struct igb_adapter *adapter)
> +{
> +	u32 val = 0;
> +	struct device *dev;
> +	struct e1000_hw *hw = &adapter->hw;
> +
> +	/* do not dump regs if we're not debugging driver */
> +	if (debug_tsn != 1)
> +		return;
> +
> +	dev = &adapter->pdev->dev;
> +	dev_info(dev, "num_tx_queues=%d, num_rx_queues=%d\n",
> +		 adapter->num_tx_queues, adapter->num_rx_queues);
> +
> +	/* 0x0008 - E1000_STATUS Device status register */
> +	val = rd32(E1000_STATUS);
> +	dev_info(&adapter->pdev->dev, "\n");
> +	dev_info(dev, "Status: FullDuplex=%s, LinkUp=%s, speed=%0x01x\n",
> +		 val & 0x1 ? "FD" : "HD",
> +		 val & 0x2 ? "LU" : "LD",
> +		 val & 0xc0 >> 6);
> +
> +	/* E1000_VET vlan ether type */
> +	val = rd32(E1000_VET);
> +	dev_info(dev, "VLAN ether type: VET.VET=0x%04x, VET.VET_EXT=0x%04x\n",
> +		 val & 0xffff, (val >> 16) & 0xffff);
> +
> +	/* E1000_RXPBS (RXPBSIZE) Rx Packet Buffer Size */
> +	val = rd32(E1000_RXPBS);
> +	dev_info(dev, "Rx Packet buffer: RXPBSIZE=%dkB, Bmc2ospbsize=%dkB, cfg_ts_en=%s\n",
> +		 val & 0x1f,
> +		 (val >> 6) & 0x1f,
> +		 (val & (1 << 31)) ? "cfg_ts_en" : "cfg_ts_dis");
> +
> +	/* Transmit stuff */
> +	/* E1000_TXPBS (TXPBSIZE) Tx Packet Buffer Size - RW */
> +	val = rd32(E1000_TXPBS);
> +	dev_info(dev, "Tx Packet buffer: Txpb0size=%dkB, Txpb1size=%dkB, Txpb2size=%dkB, Txpb3size=%dkB, os2Bmcpbsize=%dkB\n",
> +		 val & 0x3f, (val >> 6) & 0x3f, (val >> 12) & 0x3f,
> +		 (val >> 18) & 0x3f, (val >> 24) & 0x3f);
> +
> +	/* E1000_TCTL (TCTL) Tx control - RW*/
> +	val = rd32(E1000_TCTL);
> +	dev_info(dev, "Tx control reg: TxEnable=%s, CT=0x%X\n",
> +		 val & 2 ? "EN" : "DIS", (val >> 3) & 0x3F);
> +
> +	/* TQAVHC     : Transmit Qav High credits 0x300C + 0x40*n - RW */
> +	val = rd32(E1000_TQAVHC(0));
> +	dev_info(dev, "E1000_TQAVHC0: %0x08x\n", val);
> +	val = rd32(E1000_TQAVHC(1));
> +	dev_info(dev, "E1000_TQAVHC1: %0x08x\n", val);
> +
> +	/* TQAVCC[0-1]: Transmit Qav 0x3004 + 0x40*n  - RW */
> +	val = rd32(E1000_TQAVCC(0));
> +	dev_info(dev, "E1000_TQAVCC0: idleSlope=%02x, QueueMode=%s\n",
> +		 val % 0xff,
> +		 val > 31 ? "Stream reservation" : "Strict priority");
> +	val = rd32(E1000_TQAVCC(1));
> +	dev_info(dev, "E1000_TQAVCC1: idleSlope=%02x, QueueMode=%s\n",
> +		 val % 0xff,
> +		 val > 31 ? "Stream reservation" : "Strict priority");
> +
> +	/* TQAVCTRL   : Transmit Qav control - RW */
> +	val = rd32(E1000_TQAVCTRL);
> +	dev_info(dev, "E1000_TQAVCTRL: TransmitMode=%s,1588_STAT_EN=%s,DataFetchARB=%s,DataTranARB=%s,DataTranTIM=%s,SP_WAIT_SR=%s,FetchTimDelta=%dns (0x%04x)\n",
> +		 (val & 0x0001) ? "Qav" : "Legacy",
> +		 (val & 0x0004) ? "En" : "Dis",
> +		 (val & 0x0010) ? "Most Empty" : "Round Robin",
> +		 (val & 0x0100) ? "Credit Shaper" : "Strict priority",
> +		 (val & 0x0200) ? "Valid" : "N/A",
> +		 (val & 0x0400) ? "Wait" : "nowait",
> +		 (val >> 16) * 32, (val >> 16));
> +}
> +
> +/* Place the NIC in Qav-mode.
> + *
> + * This will result in a _single_ queue for normal BE traffic, the rest
> + * will be grabbed by the Qav-machinery and kept for strict priority
> + * transmission.
> + *
> + * I210 Datasheet Sec 7.2.7.7 gives a lot of information.
> + */
> +void igb_tsn_init(struct igb_adapter *adapter)
> +{
> +	struct e1000_hw *hw = &adapter->hw;
> +	u32 val;
> +
> +	if (use_tsn != 1) {
> +		adapter->tsn_ready = 0;
> +		dev_info(&adapter->pdev->dev, "%s got use_tsn > 0 (%d)\n",
> +			 __func__, use_tsn);
> +		return;
> +	}
> +
> +	if (debug_tsn < 0 || debug_tsn > 1)
> +		debug_tsn = 0;
> +
> +	if (!adapter->pdev) {
> +		adapter->tsn_ready = 0;
> +		return;
> +	}
> +
> +	switch (adapter->pdev->device) {
> +	case 0x1533:   /* E1000_DEV_ID_I210_COPPER */
> +	case 0x1536:   /* E1000_DEV_ID_I210_FIBER */
> +	case 0x1537:   /* E1000_DEV_ID_I210_SERDES: */
> +	case 0x1538:   /* E1000_DEV_ID_I210_SGMII: */
> +	case 0x157b:   /* E1000_DEV_ID_I210_COPPER_FLASHLESS: */
> +	case 0x157c:   /* E1000_DEV_ID_I210_SERDES_FLASHLESS: */
> +		break;
> +	default:
> +		/* not a known IGB-TSN capable device */
> +		adapter->tsn_ready = 0;
> +		return;
> +	}
> +	_tsn_dump_regs(adapter);
> +
> +	/* Set Tx packet buffer size assignment, see 7.2.7.7 in i210
> +	 * PB0: 8kB
> +	 * PB1: 8kB
> +	 * PB2: 4kB
> +	 * PB3: 4kB
> +	 * os2bmcsize: 2kB
> +	 * sumTx: 26kB
> +	 *
> +	 * Rxpbsize: 0x20 (32kB)
> +	 * bmc2ossize: 0x02
> +	 * sumRx: 34kB
> +	 *
> +	 * See 8.3.1 && 8.3.2
> +	 */
> +	val = (0x02 << 24 | 0x04 << 18 | 0x04 << 12 | 0x08 << 6 | 0x08);
> +	wr32(E1000_ITPBS, val);
> +	wr32(E1000_IRPBS, (0x02 << 6 | 0x20));
> +
> +	/* DMA Tx maximum packet size, the largest frame DMA should transport
> +	 * do not allow frames larger than 1522 + preample. Reg expects
> +	 * size in 64B increments. 802.1BA 6.3
> +	 * Round up to 1536 to handle 64B increments
> +	 *
> +	 * Initial value: 0x98 (152 => 9728 bytes)
> +	 */
> +	wr32(E1000_DTXMXPKTSZ, 1536 >> 6);
> +
> +	/* Place card in Qav-mode, use tx-queue 0,1 for Qav
> +	 * (Credit-based shaper), 2,3 for standard priority (and
> +	 * best-effort) traffic.
> +	 *
> +	 * i210 8.12.19 and 8.12.21
> +	 *
> +	 * - Fetch: most empty and time based (not round-robin)
> +	 * - Transmit: Credit based shaper for SR queues
> +	 * - Data launch time valid (in Qav mode)
> +	 * - Wait for SR queues to ensure that launch time is always valid.
> +	 * - Set ~10us wait-time-delta, 32ns granularity
> +	 *
> +	 * Do *not* enable Tx for shaper (E1000_TQAVCTRL_DATA_TRAN_ARB)
> +	 * yet as we do not have data to Tx
> +	 */
> +	val = E1000_TQAVCTRL_TXMODE           |
> +		E1000_TQAVCTRL_DATA_FETCH_ARB |
> +		E1000_TQAVCTRL_DATA_TRAN_TIM  |
> +		E1000_TQAVCTRL_SP_WAIT_SR     |
> +		320 << E1000_TQAVCTRL_FETCH_TM_SHIFT;
> +
> +	wr32(E1000_TQAVCTRL, val);
> +
> +	/* For now, only set CreditBased shaper for A and B, not set
> +	 * idleSlope as we have not yet gotten any streams.
> +	 * 8.12.19
> +	 */
> +	wr32(E1000_TQAVCC(0), E1000_TQAVCC_QUEUEMODE);
> +	wr32(E1000_TQAVCC(1), E1000_TQAVCC_QUEUEMODE);
> +
> +	wr32(E1000_TQAVHC(0), E1000_TQAVCH_ZERO_CREDIT);
> +	wr32(E1000_TQAVHC(1), E1000_TQAVCH_ZERO_CREDIT);
> +
> +	/* reset Tx Descriptor tail and head for the queues */
> +	wr32(E1000_TDT(0), 0);
> +	wr32(E1000_TDT(1), 0);
> +	wr32(E1000_TDH(0), 0);
> +	wr32(E1000_TDH(1), 0);
> +
> +	_tsn_dump_regs(adapter);
> +	dev_info(&adapter->pdev->dev, "\n");
> +
> +	adapter->sra_idleslope_res = 0;
> +	adapter->srb_idleslope_res = 0;
> +	adapter->tsn_ready = 1;
> +
> +	dev_info(&adapter->pdev->dev, "%s: setup done\n", __func__);
> +}
> +
> +int igb_tsn_capable(struct net_device *netdev)
> +{
> +	struct igb_adapter *adapter;
> +
> +	if (!netdev)
> +		return -EINVAL;
> +	adapter = netdev_priv(netdev);
> +	if (use_tsn == 1)
> +		return adapter->tsn_ready == 1;
> +	return 0;
> +}
> +
> +/* igb_tsn_link_configure - configure NIC to handle a new stream
> + *
> + * @netdev: pointer to NIC device
> + * @class: the class for the stream used to find the correct queue.
> + * @framesize: size of each frame, *including* headers (not preamble)
> + * @vid: VLAN ID
> + *
> + * NOTE: the sr_class only instructs the driver which queue to use, not
> + * what priority the network expects for a given class. This is
> + * something userspace must find out and then let the tsn-driver set in
> + * the frame before xmit.
> + *
> + * FIXME: remove bw-req from a stream that goes away.
> + */
> +int igb_tsn_link_configure(struct net_device *netdev, enum sr_class class,
> +			   u16 framesize, u16 vid)
> +{
> +	/* FIXME: push into adapter-storage */
> +	static int class_a_size;
> +	static int class_b_size;
> +	int err;
> +	u32 idle_slope_a = 0;
> +	u32 idle_slope_b = 0;
> +	u32 new_is = 0;
> +	u32 hicred_a = 0;
> +	u32 hicred_b = 0;
> +	u32 tqavctrl;
> +
> +	struct igb_adapter *adapter;
> +	struct e1000_hw *hw;
> +
> +	if (!netdev)
> +		return -EINVAL;
> +	adapter  = netdev_priv(netdev);
> +	hw = &adapter->hw;
> +
> +	if (!igb_tsn_capable(netdev)) {
> +		pr_err("%s:  NIC not capable\n", __func__);
> +		return -EINVAL;
> +	}
> +
> +	if (framesize > MAX_FRAME_SIZE || framesize < MIN_FRAME_SIZE) {
> +		pr_err("%s: framesize (%u) must be [%d,%d]\n", __func__,
> +		       framesize, MIN_FRAME_SIZE, MAX_FRAME_SIZE);
> +		return -EINVAL;
> +	}
> +
> +	/* TODO: is this the correct place/way? Is it required? */
> +	rtnl_lock();
> +	pr_info("%s: adding VLAN %u to HW filter on device %s\n",
> +		__func__, vid, netdev->name);
> +	err = vlan_vid_add(netdev, htons(ETH_P_8021Q), vid);
> +	if (err != 0)
> +		pr_err("%s: error adding vlan %u, res=%d\n",
> +		       __func__, vid, err);
> +	rtnl_unlock();
> +
> +	/* Grab current values of idle_slope */
> +	idle_slope_a = rd32(E1000_TQAVHC(0)) & ~E1000_TQAVCH_ZERO_CREDIT;
> +	idle_slope_b = rd32(E1000_TQAVHC(1)) & ~E1000_TQAVCH_ZERO_CREDIT;
> +
> +	/* Calculate new idle slope and add to appropriate idle_slope
> +	 * idle_slope = BW * linkrate * 2 (0r 0.2 for 100Mbit)
> +	 * BW: % of total bandwidth
> +	 */
> +	new_is = framesize * E1000_LINK_RATE * 16 / 1000000;
> +
> +	switch (class) {
> +	case SR_CLASS_A:
> +		new_is *= 2; /* A is 8kHz, B is 4kHz */
> +		idle_slope_a += new_is;
> +		class_a_size  = framesize;
> +		break;
> +	case SR_CLASS_B:
> +		idle_slope_b += new_is;
> +		class_b_size  = framesize;
> +		break;
> +	default:
> +		pr_err("%s: unhandled SR-class (%d)\n", __func__, class);
> +		return -EINVAL;
> +	}
> +
> +	/* HiCred: cred obtained while waiting for current frame &&
> +	 * higher-class frames to finish xmit.
> +	 *
> +	 * Covered in detail in 7.2.7.6 in i210 datasheet
> +	 * For class A: only worst-case framesize that just started;
> +	 *		i.e. 1522 * idleSlope / linkrate;
> +	 * For class B: (worst-case framesize + burstSize(A))*idleSlope
> +	 *
> +	 * See 802.1Q Annex L, eq L.10 for hicred_a and L.41 for
> +	 * hicred_b
> +	 */
> +	if (class == SR_CLASS_A) {
> +		hicred_a = E1000_TQAVCH_ZERO_CREDIT + idle_slope_a * MAX_FRAME_SIZE / E1000_LINK_RATE;
> +		wr32(E1000_TQAVCC(0), E1000_TQAVCC_QUEUEMODE | idle_slope_a);
> +		wr32(E1000_TQAVHC(0), hicred_a);
> +	} else {
> +		hicred_b = E1000_TQAVCH_ZERO_CREDIT | idle_slope_b * (MAX_FRAME_SIZE + class_a_size) / (E1000_LINK_RATE - idle_slope_a);
> +		wr32(E1000_TQAVCC(1), E1000_TQAVCC_QUEUEMODE | idle_slope_b);
> +		wr32(E1000_TQAVHC(1), hicred_b);
> +	}
> +
> +	/* Enable Tx for shaper now that we have data */
> +	tqavctrl = rd32(E1000_TQAVCTRL);
> +	if (!(tqavctrl & E1000_TQAVCTRL_DATA_TRAN_ARB)) {
> +		tqavctrl |= E1000_TQAVCTRL_DATA_TRAN_ARB;
> +		wr32(E1000_TQAVCTRL, tqavctrl);
> +	}
> +	_tsn_dump_regs(netdev_priv(netdev));
> +	return 0;
> +}
> +
> +#endif	/* #if IS_ENABLED(CONFIG_IGB_TSN) */
> -- 
> 2.7.4
> 

-- 
Henrik Austad

Re: [very-RFC 2/8] TSN: Add the standard formerly known as AVB to the kernel

[David Miller]

Not as a reply, fresh new patch postings. :-/

Re: [very-RFC 5/8] Add TSN machinery to drive the traffic from a shim over the network

[Henrik Austad]

clearing up netdev-typo
-H

On Sun, Jun 12, 2016 at 12:22:18AM +0200, Henrik Austad wrote:
> From: Henrik Austad <haustad@cisco.com>
> 
> In short summary:
> 
> * tsn_core.c is the main driver of tsn, all new links go through
>   here and all data to/form the shims are handled here
>   core also manages the shim-interface.
> 
> * tsn_configfs.c is the API to userspace. TSN is driven from userspace
>   and a link is created, configured, enabled, disabled and removed
>   purely from userspace. All attributes requried must be determined by
>   userspace, preferrably via IEEE 1722.1 (discovery and enumeration).
> 
> * tsn_header.c small part that handles the actual header of the frames
>   we send. Kept out of core for cleanliness.
> 
> * tsn_net.c handles operations towards the networking layer.
> 
> The current driver is under development. This means that from the moment it
> is enabled with a shim, it will send traffic, either 0-traffic (frames of
> reserved length but with payload 0) or actual traffic. This will change
> once the driver stabilizes.
> 
> For more detail, see Documentation/networking/tsn/
> 
> Cc: "David S. Miller" <davem@davemloft.net>
> Signed-off-by: Henrik Austad <haustad@cisco.com>
> ---
>  net/Makefile           |   1 +
>  net/tsn/Makefile       |   6 +
>  net/tsn/tsn_configfs.c | 623 +++++++++++++++++++++++++++++++
>  net/tsn/tsn_core.c     | 975 +++++++++++++++++++++++++++++++++++++++++++++++++
>  net/tsn/tsn_header.c   | 203 ++++++++++
>  net/tsn/tsn_internal.h | 383 +++++++++++++++++++
>  net/tsn/tsn_net.c      | 403 ++++++++++++++++++++
>  7 files changed, 2594 insertions(+)
>  create mode 100644 net/tsn/Makefile
>  create mode 100644 net/tsn/tsn_configfs.c
>  create mode 100644 net/tsn/tsn_core.c
>  create mode 100644 net/tsn/tsn_header.c
>  create mode 100644 net/tsn/tsn_internal.h
>  create mode 100644 net/tsn/tsn_net.c
> 
> diff --git a/net/Makefile b/net/Makefile
> index bdd1455..c15482e 100644
> --- a/net/Makefile
> +++ b/net/Makefile
> @@ -79,3 +79,4 @@ ifneq ($(CONFIG_NET_L3_MASTER_DEV),)
>  obj-y				+= l3mdev/
>  endif
>  obj-$(CONFIG_QRTR)		+= qrtr/
> +obj-$(CONFIG_TSN)		+= tsn/
> diff --git a/net/tsn/Makefile b/net/tsn/Makefile
> new file mode 100644
> index 0000000..0d87687
> --- /dev/null
> +++ b/net/tsn/Makefile
> @@ -0,0 +1,6 @@
> +#
> +# Makefile for the Linux TSN subsystem
> +#
> +
> +obj-$(CONFIG_TSN) += tsn.o
> +tsn-objs :=tsn_core.o tsn_configfs.o tsn_net.o tsn_header.o
> diff --git a/net/tsn/tsn_configfs.c b/net/tsn/tsn_configfs.c
> new file mode 100644
> index 0000000..f3d0986
> --- /dev/null
> +++ b/net/tsn/tsn_configfs.c
> @@ -0,0 +1,623 @@
> +/*
> + *   ConfigFS interface to TSN
> + *   Copyright (C) 2015- Henrik Austad <haustad@cisco.com>
> + *
> + *   This program is free software; you can redistribute it and/or modify
> + *   it under the terms of the GNU General Public License as published by
> + *   the Free Software Foundation; either version 2 of the License, or
> + *   (at your option) any later version.
> + *
> + *   This program is distributed in the hope that it will be useful,
> + *   but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *   GNU General Public License for more details.
> + */
> +#include <linux/init.h>
> +#include <linux/module.h>
> +#include <linux/slab.h>
> +#include <linux/configfs.h>
> +#include <linux/netdevice.h>
> +#include <linux/rtmutex.h>
> +#include <linux/tsn.h>
> +#include "tsn_internal.h"
> +
> +static inline struct tsn_link *to_tsn_link(struct config_item *item)
> +{
> +	/* this line causes checkpatch to WARN. making checkpatch happy,
> +	 * makes code messy..
> +	 */
> +	return item ? container_of(to_config_group(item), struct tsn_link, group) : NULL;
> +}
> +
> +static inline struct tsn_nic *to_tsn_nic(struct config_group *group)
> +{
> +	return group ? container_of(group, struct tsn_nic, group) : NULL;
> +}
> +
> +/* -----------------------------------------------
> + * Tier2 attributes
> + *
> + * The content of the links userspace can see/modify
> + * -----------------------------------------------
> +*/
> +static ssize_t _tsn_max_payload_size_show(struct config_item *item,
> +					  char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "%u\n", (u32)link->max_payload_size);
> +}
> +
> +static ssize_t _tsn_max_payload_size_store(struct config_item *item,
> +					   const char *page, size_t count)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +	u16 mpl_size = 0;
> +	int ret = 0;
> +
> +	if (!link)
> +		return -EINVAL;
> +	if (tsn_link_is_on(link)) {
> +		pr_err("ERROR: Cannot change Payload size on on enabled link\n");
> +		return -EINVAL;
> +	}
> +	ret = kstrtou16(page, 0, &mpl_size);
> +	if (ret)
> +		return ret;
> +
> +	/* 802.1BA-2011 6.4 payload must be <1500 octets (excluding
> +	 * headers, tags etc) However, this is not directly mappable to
> +	 * how some hw handles things, so to be conservative, we
> +	 * restrict it down to [26..1485]
> +	 *
> +	 * This is also the _payload_ size, which does not include the
> +	 * AVTPDU header. This is an upper limit to how much raw data
> +	 * the shim can transport in each frame.
> +	 */
> +	if (!tsnh_payload_size_valid(mpl_size, link->shim_header_size)) {
> +		pr_err("%s: payload (%u) should be [26..1480] octets.\n",
> +		       __func__, (u32)mpl_size);
> +		return -EINVAL;
> +	}
> +	link->max_payload_size = mpl_size;
> +	return count;
> +}
> +
> +static ssize_t _tsn_shim_header_size_show(struct config_item *item,
> +					  char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "%u\n", (u32)link->shim_header_size);
> +}
> +
> +static ssize_t _tsn_shim_header_size_store(struct config_item *item,
> +					   const char *page, size_t count)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +	u16 hdr_size = 0;
> +	int ret = 0;
> +
> +	if (!link)
> +		return -EINVAL;
> +	if (tsn_link_is_on(link)) {
> +		pr_err("ERROR: Cannot change shim-header size on on enabled link\n");
> +		return -EINVAL;
> +	}
> +
> +	ret = kstrtou16(page, 0, &hdr_size);
> +	if (ret)
> +		return ret;
> +
> +	if (!tsnh_payload_size_valid(link->max_payload_size, hdr_size))
> +		return -EINVAL;
> +
> +	link->shim_header_size = hdr_size;
> +	return count;
> +}
> +
> +static ssize_t _tsn_stream_id_show(struct config_item *item, char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "%llu\n", link->stream_id);
> +}
> +
> +static ssize_t _tsn_stream_id_store(struct config_item *item,
> +				    const char *page, size_t count)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +	u64 sid;
> +	int ret = 0;
> +
> +	if (!link)
> +		return -EINVAL;
> +	if (tsn_link_is_on(link)) {
> +		pr_err("ERROR: Cannot change StreamID on on enabled link\n");
> +		return -EINVAL;
> +	}
> +	ret = kstrtou64(page, 0, &sid);
> +	if (ret)
> +		return ret;
> +
> +	if (sid == link->stream_id)
> +		return count;
> +
> +	if (tsn_find_by_stream_id(sid)) {
> +		pr_warn("Cannot set sid to %llu - exists\n", sid);
> +		return -EEXIST;
> +	}
> +	if (sid != link->stream_id)
> +		tsn_readd_link(link, sid);
> +	return count;
> +}
> +
> +static ssize_t _tsn_buffer_size_show(struct config_item *item, char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "%zu\n", link->buffer_size);
> +}
> +
> +static ssize_t _tsn_buffer_size_store(struct config_item *item,
> +				      const char *page, size_t count)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +	u32 tmp;
> +	int ret = 0;
> +
> +	if (!link)
> +		return -EINVAL;
> +	if (tsn_link_is_on(link)) {
> +		pr_err("ERROR: Cannot change Buffer Size on on enabled link\n");
> +		return -EINVAL;
> +	}
> +
> +	ret = kstrtou32(page, 0, &tmp);
> +	/* only allow buffers !0 and smaller than 8MB for now */
> +	if (!ret && tmp) {
> +		pr_info("%s: update buffer_size from %zu to %u\n",
> +			__func__, link->buffer_size, tmp);
> +		link->buffer_size = (size_t)tmp;
> +		return count;
> +	}
> +	return -EINVAL;
> +}
> +
> +static ssize_t _tsn_class_show(struct config_item *item, char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "%s\n", (link->class_a ? "A" : "B"));
> +}
> +
> +static ssize_t _tsn_class_store(struct config_item *item,
> +				const char *page, size_t count)
> +{
> +	char class[2] = { 0 };
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	if (tsn_link_is_on(link)) {
> +		pr_err("ERROR: Cannot change Class-type on on enabled link\n");
> +		return -EINVAL;
> +	}
> +	if (strncpy(class, page, 1)) {
> +		if (strcmp(class, "a") == 0 || strcmp(class, "A") == 0)
> +			link->class_a = 1;
> +		else if (strcmp(class, "b") == 0 || strcmp(class, "B") == 0)
> +			link->class_a = 0;
> +		return count;
> +	}
> +
> +	pr_err("%s: Could not copy new class into buffer\n", __func__);
> +	return -EINVAL;
> +}
> +
> +static ssize_t _tsn_vlan_id_show(struct config_item *item, char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "%u\n", link->vlan_id);
> +}
> +
> +static ssize_t _tsn_vlan_id_store(struct config_item *item,
> +				  const char *page, size_t count)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +	u16 vlan_id;
> +	int ret = 0;
> +
> +	if (!link)
> +		return -EINVAL;
> +	if (tsn_link_is_on(link)) {
> +		pr_err("ERROR: Cannot change VLAN-ID on on enabled link\n");
> +		return -EINVAL;
> +	}
> +	ret = kstrtou16(page, 0, &vlan_id);
> +	if (ret)
> +		return ret;
> +	if (vlan_id > 0xfff)
> +		return -EINVAL;
> +	link->vlan_id = vlan_id & 0xfff;
> +	return count;
> +}
> +
> +static ssize_t _tsn_pcp_a_show(struct config_item *item, char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "0x%x\n", link->pcp_a);
> +}
> +
> +static ssize_t _tsn_pcp_a_store(struct config_item *item,
> +				const char *page, size_t count)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +	int ret = 0;
> +	u8 pcp;
> +
> +	if (!link)
> +		return -EINVAL;
> +	if (tsn_link_is_on(link)) {
> +		pr_err("ERROR: Cannot change PCP-A on enabled link.\n");
> +		return -EINVAL;
> +	}
> +	ret = kstrtou8(page, 0, &pcp);
> +	if (ret)
> +		return ret;
> +	if (pcp > 0x7)
> +		return -EINVAL;
> +	link->pcp_a = pcp & 0x7;
> +	return count;
> +}
> +
> +static ssize_t _tsn_pcp_b_show(struct config_item *item, char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "0x%x\n", link->pcp_b);
> +}
> +
> +static ssize_t _tsn_pcp_b_store(struct config_item *item,
> +				const char *page, size_t count)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +	int ret = 0;
> +	u8 pcp;
> +
> +	if (!link)
> +		return -EINVAL;
> +	if (tsn_link_is_on(link)) {
> +		pr_err("ERROR: Cannot change PCP-B on enabled link.\n");
> +		return -EINVAL;
> +	}
> +	ret = kstrtou8(page, 0, &pcp);
> +	if (ret)
> +		return ret;
> +	if (pcp > 0x7)
> +		return -EINVAL;
> +	link->pcp_b = pcp & 0x7;
> +	return count;
> +}
> +
> +static ssize_t _tsn_end_station_show(struct config_item *item, char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "%s\n",
> +		      (link->estype_talker ? "Talker" : "Listener"));
> +}
> +
> +static ssize_t _tsn_end_station_store(struct config_item *item,
> +				      const char *page, size_t count)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +	char estype[9] = {0};
> +
> +	if (!link)
> +		return -EINVAL;
> +	if (tsn_link_is_on(link)) {
> +		pr_err("ERROR: Cannot change End-station type on enabled link.\n");
> +		return -EINVAL;
> +	}
> +	if (strncpy(estype, page, 8)) {
> +		if (strncmp(estype, "Talker", 6) == 0 ||
> +		    strncmp(estype, "talker", 6) == 0) {
> +			link->estype_talker = 1;
> +			return count;
> +		} else if (strncmp(estype, "Listener", 8) == 0 ||
> +			   strncmp(estype, "listener", 8) == 0) {
> +			link->estype_talker = 0;
> +			return count;
> +		}
> +	}
> +	return -EINVAL;
> +}
> +
> +static ssize_t _tsn_enabled_show(struct config_item *item, char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "%s\n", tsn_shim_get_active(link));
> +}
> +
> +static ssize_t _tsn_enabled_store(struct config_item *item,
> +				  const char *page, size_t count)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +	char driver_type[SHIM_NAME_SIZE] = { 0 };
> +	struct tsn_shim_ops *shim_ops;
> +	size_t len;
> +	int ret = 0;
> +
> +	if (!link)
> +		return -EINVAL;
> +
> +	strncpy(driver_type, page, SHIM_NAME_SIZE - 1);
> +	len = strlen(driver_type);
> +	while (len-- > 0) {
> +		if (driver_type[len] == '\n')
> +			driver_type[len] = 0x00;
> +	}
> +	if (tsn_link_is_on(link)) {
> +		if (strncmp(driver_type, "off", 3) == 0) {
> +			tsn_teardown_link(link);
> +		} else {
> +			pr_err("Unknown value (%s), ignoring\n", driver_type);
> +			return -EINVAL;
> +		}
> +	} else {
> +		shim_ops = tsn_shim_find_by_name(driver_type);
> +
> +		if (!shim_ops) {
> +			pr_info("%s: could not enable desired shim, %s is not available\n",
> +				__func__, driver_type);
> +			return -EINVAL;
> +		}
> +
> +		ret = tsn_prepare_link(link, shim_ops);
> +		if (ret != 0) {
> +			pr_err("%s: Trouble perparing link, somethign went wrong - %d\n",
> +			       __func__, ret);
> +			return ret;
> +		}
> +	}
> +	return count;
> +}
> +
> +static ssize_t _tsn_remote_mac_show(struct config_item *item, char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "%pM\n", link->remote_mac);
> +}
> +
> +static ssize_t _tsn_remote_mac_store(struct config_item *item,
> +				     const char *page, size_t count)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +	unsigned char mac[6] = {0};
> +	int ret = 0;
> +
> +	if (!link)
> +		return -EINVAL;
> +	if (tsn_link_is_on(link)) {
> +		pr_err("ERROR: Cannot change Remote MAC on enabled link.\n");
> +		return -EINVAL;
> +	}
> +	ret = sscanf(page, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx",
> +		     &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5]);
> +	if (ret > 0) {
> +		pr_info("Got MAC, copying to storage\n");
> +		memcpy(link->remote_mac, mac, 6);
> +		return count;
> +	}
> +	return -EINVAL;
> +}
> +
> +static ssize_t _tsn_local_mac_show(struct config_item *item, char *page)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +
> +	if (!link)
> +		return -EINVAL;
> +	return sprintf(page, "%pMq\n", link->nic->dev->perm_addr);
> +}
> +
> +CONFIGFS_ATTR(_tsn_, max_payload_size);
> +CONFIGFS_ATTR(_tsn_, shim_header_size);
> +CONFIGFS_ATTR(_tsn_, stream_id);
> +CONFIGFS_ATTR(_tsn_, buffer_size);
> +CONFIGFS_ATTR(_tsn_, class);
> +CONFIGFS_ATTR(_tsn_, vlan_id);
> +CONFIGFS_ATTR(_tsn_, pcp_a);
> +CONFIGFS_ATTR(_tsn_, pcp_b);
> +CONFIGFS_ATTR(_tsn_, end_station);
> +CONFIGFS_ATTR(_tsn_, enabled);
> +CONFIGFS_ATTR(_tsn_, remote_mac);
> +CONFIGFS_ATTR_RO(_tsn_, local_mac);
> +static struct configfs_attribute *tsn_tier2_attrs[] = {
> +	&_tsn_attr_max_payload_size,
> +	&_tsn_attr_shim_header_size,
> +	&_tsn_attr_stream_id,
> +	&_tsn_attr_buffer_size,
> +	&_tsn_attr_class,
> +	&_tsn_attr_vlan_id,
> +	&_tsn_attr_pcp_a,
> +	&_tsn_attr_pcp_b,
> +	&_tsn_attr_end_station,
> +	&_tsn_attr_enabled,
> +	&_tsn_attr_remote_mac,
> +	&_tsn_attr_local_mac,
> +	NULL,
> +};
> +
> +static struct config_item_type group_tsn_tier2_type = {
> +	.ct_owner     = THIS_MODULE,
> +	.ct_attrs     = tsn_tier2_attrs,
> +	.ct_group_ops = NULL,
> +};
> +
> +/* -----------------------------------------------
> + * Tier1
> + *
> + * The only interesting info at this level are the available links
> + * belonging to this nic. This will be the subdirectories. Apart from
> + * making/removing tier-2 folders, nothing else is required here.
> + */
> +static struct config_group *group_tsn_1_make_group(struct config_group *group,
> +						   const char *name)
> +{
> +	struct tsn_nic *nic = to_tsn_nic(group);
> +	struct tsn_link *link = tsn_create_and_add_link(nic);
> +
> +	if (!nic || !link)
> +		return ERR_PTR(-ENOMEM);
> +
> +	config_group_init_type_name(&link->group, name, &group_tsn_tier2_type);
> +
> +	return &link->group;
> +}
> +
> +static void group_tsn_1_drop_group(struct config_group *group,
> +				   struct config_item *item)
> +{
> +	struct tsn_link *link = to_tsn_link(item);
> +	struct tsn_nic *nic = to_tsn_nic(group);
> +
> +	if (link) {
> +		tsn_teardown_link(link);
> +		tsn_remove_link(link);
> +	}
> +	pr_info("Dropping %s from NIC: %s\n", item->ci_name, nic->name);
> +}
> +
> +static struct configfs_attribute *tsn_tier1_attrs[] = {
> +	NULL,
> +};
> +
> +static struct configfs_group_operations group_tsn_1_group_ops = {
> +	.make_group	= group_tsn_1_make_group,
> +	.drop_item      = group_tsn_1_drop_group,
> +};
> +
> +static struct config_item_type group_tsn_tier1_type = {
> +	.ct_group_ops	= &group_tsn_1_group_ops,
> +	.ct_attrs	= tsn_tier1_attrs,
> +	.ct_owner	= THIS_MODULE,
> +};
> +
> +/* -----------------------------------------------
> + * Tier0
> + *
> + * Top level. This will expose all the TSN-capable NICs as well as
> + * currently active StreamIDs and registered shims. 'Global' info goes
> + * here.
> + */
> +static ssize_t _tsn_used_sids_show(struct config_item *item, char *page)
> +{
> +	return tsn_get_stream_ids(page, PAGE_SIZE);
> +}
> +
> +static ssize_t _tsn_available_shims_show(struct config_item *item, char *page)
> +{
> +	return tsn_shim_export_probe_triggers(page);
> +}
> +
> +static struct configfs_attribute tsn_used_sids = {
> +	.ca_owner = THIS_MODULE,
> +	.ca_name  = "stream_ids",
> +	.ca_mode  = S_IRUGO,
> +	.show     = _tsn_used_sids_show,
> +};
> +
> +static struct configfs_attribute available_shims = {
> +	.ca_owner = THIS_MODULE,
> +	.ca_name  = "available_shims",
> +	.ca_mode  = S_IRUGO,
> +	.show     = _tsn_available_shims_show,
> +};
> +
> +static struct configfs_attribute *group_tsn_attrs[] = {
> +	&tsn_used_sids,
> +	&available_shims,
> +	NULL,
> +};
> +
> +static struct config_item_type group_tsn_tier0_type = {
> +	.ct_group_ops	= NULL,
> +	.ct_attrs	= group_tsn_attrs,
> +	.ct_owner	= THIS_MODULE,
> +};
> +
> +int tsn_configfs_init(struct tsn_list *tlist)
> +{
> +	int ret = 0;
> +	struct tsn_nic *next;
> +	struct configfs_subsystem *subsys;
> +
> +	if (!tlist || !tlist->num_avail)
> +		return -EINVAL;
> +
> +	/* Tier-0 */
> +	subsys = &tlist->tsn_subsys;
> +	strncpy(subsys->su_group.cg_item.ci_namebuf, "tsn",
> +		CONFIGFS_ITEM_NAME_LEN);
> +	subsys->su_group.cg_item.ci_type = &group_tsn_tier0_type;
> +
> +	config_group_init(&subsys->su_group);
> +	mutex_init(&subsys->su_mutex);
> +
> +	/* Tier-1
> +	 * (tsn-capable NICs), automatic subgroups
> +	 */
> +	list_for_each_entry(next, &tlist->head, list) {
> +		config_group_init_type_name(&next->group, next->name,
> +					    &group_tsn_tier1_type);
> +		configfs_add_default_group(&next->group, &subsys->su_group);
> +	}
> +
> +	/* This is the final step, once done, system is live, make sure
> +	 * init has completed properly
> +	 */
> +	ret = configfs_register_subsystem(subsys);
> +	if (ret) {
> +		pr_err("Trouble registering TSN ConfigFS subsystem\n");
> +		return ret;
> +	}
> +
> +	pr_warn("configfs_init_module() OK\n");
> +	return 0;
> +}
> +
> +void tsn_configfs_exit(struct tsn_list *tlist)
> +{
> +	if (!tlist)
> +		return;
> +	configfs_unregister_subsystem(&tlist->tsn_subsys);
> +	pr_warn("configfs_exit_module()\n");
> +}
> diff --git a/net/tsn/tsn_core.c b/net/tsn/tsn_core.c
> new file mode 100644
> index 0000000..51f1d13
> --- /dev/null
> +++ b/net/tsn/tsn_core.c
> @@ -0,0 +1,975 @@
> +/*
> + *   TSN Core main part of TSN driver
> + *
> + *   Copyright (C) 2015- Henrik Austad <haustad@cisco.com>
> + *
> + *   This program is free software; you can redistribute it and/or modify
> + *   it under the terms of the GNU General Public License as published by
> + *   the Free Software Foundation; either version 2 of the License, or
> + *   (at your option) any later version.
> + *
> + *   This program is distributed in the hope that it will be useful,
> + *   but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *   GNU General Public License for more details.
> + */
> +
> +#include <linux/pci.h>
> +#include <linux/slab.h>
> +#include <linux/init.h>
> +#include <linux/module.h>
> +#include <linux/random.h>
> +#include <linux/rtmutex.h>
> +#include <linux/hashtable.h>
> +#include <linux/netdevice.h>
> +#include <linux/net.h>
> +#include <linux/dma-mapping.h>
> +#include <net/sock.h>
> +#include <net/net_namespace.h>
> +#include <linux/hrtimer.h>
> +#include <linux/configfs.h>
> +
> +#define CREATE_TRACE_POINTS
> +#include <trace/events/tsn.h>
> +#include "tsn_internal.h"
> +
> +static struct tsn_list tlist;
> +static int in_debug;
> +static int on_cpu = -1;
> +
> +#define TLINK_HASH_BITS 8
> +DEFINE_HASHTABLE(tlinks, TLINK_HASH_BITS);
> +
> +static LIST_HEAD(tsn_shim_ops);
> +
> +/* Called with link->lock held */
> +static inline size_t _get_low_water(struct tsn_link *link)
> +{
> +	/* use max_payload_size and give a rough estimate of how many
> +	 * bytes that would be for low_water_ms
> +	 */
> +	int low_water_ms = 20;
> +	int numframes = low_water_ms * 8;
> +
> +	if (link->class_a)
> +		numframes *= 2;
> +	return link->max_payload_size * numframes;
> +}
> +
> +/* Called with link->lock held */
> +static inline size_t _get_high_water(struct tsn_link *link)
> +{
> +	size_t low_water =  _get_low_water(link);
> +
> +	return max(link->used_buffer_size - low_water, low_water);
> +}
> +
> +/**
> + * _tsn_set_buffer - register a memory region to use as the buffer
> + *
> + * This is used when we are operating in !external_buffer mode.
> + *
> + * TSN expects a ring-buffer and will update pointers to keep track of
> + * where we are. When the buffer is refilled, head and tail will be
> + * updated accordingly.
> + *
> + * @param link		the link that should hold the buffer
> + * @param buffer	the new buffer
> + * @param bufsize	size of new buffer.
> + *
> + * @returns 0 on success, negative on error
> + *
> + * Must be called with tsn_lock() held.
> + */
> +static int _tsn_set_buffer(struct tsn_link *link, void *buffer, size_t bufsize)
> +{
> +	if (link->buffer) {
> +		pr_err("%s: Cannot add buffer, buffer already registred\n",
> +		       __func__);
> +		return -EINVAL;
> +	}
> +
> +	trace_tsn_set_buffer(link, bufsize);
> +	link->buffer = buffer;
> +	link->head = link->buffer;
> +	link->tail = link->buffer;
> +	link->end = link->buffer + bufsize;
> +	link->buffer_size = bufsize;
> +	link->used_buffer_size = bufsize;
> +	return 0;
> +}
> +
> +/**
> + * _tsn_free_buffer - remove internal buffers
> + *
> + * This is the buffer where we store data before shipping it to TSN, or
> + * where incoming data is staged.
> + *
> + * @param link   - the link that holds the buffer
> + *
> + * Must be called with tsn_lock() held.
> + */
> +static void _tsn_free_buffer(struct tsn_link *link)
> +{
> +	if (!link)
> +		return;
> +	trace_tsn_free_buffer(link);
> +	kfree(link->buffer);
> +	link->buffer = NULL;
> +	link->head   = NULL;
> +	link->tail   = NULL;
> +	link->end    = NULL;
> +}
> +
> +int tsn_set_buffer_size(struct tsn_link *link, size_t bsize)
> +{
> +	if (!link)
> +		return -EINVAL;
> +
> +	if (bsize > link->buffer_size) {
> +		pr_err("%s: requested buffer (%zd) larger than allocated memory (%zd)\n",
> +		       __func__, bsize, link->buffer_size);
> +		return -ENOMEM;
> +	}
> +
> +	tsn_lock(link);
> +	link->used_buffer_size = bsize;
> +	link->tail = link->buffer;
> +	link->head = link->buffer;
> +	link->end = link->buffer + link->used_buffer_size;
> +	link->low_water_mark = _get_low_water(link);
> +	link->high_water_mark = _get_high_water(link);
> +	tsn_unlock(link);
> +
> +	pr_info("Set buffer_size, size: %zd, lowwater: %zd, highwater: %zd\n",
> +		link->used_buffer_size, link->low_water_mark,
> +		link->high_water_mark);
> +	return 0;
> +}
> +EXPORT_SYMBOL(tsn_set_buffer_size);
> +
> +int tsn_clear_buffer_size(struct tsn_link *link)
> +{
> +	if (!link)
> +		return -EINVAL;
> +
> +	tsn_lock(link);
> +	link->tail = link->buffer;
> +	link->head = link->buffer;
> +	link->end = link->buffer + link->buffer_size;
> +	memset(link->buffer, 0,  link->used_buffer_size);
> +	link->used_buffer_size = link->buffer_size;
> +	link->low_water_mark = _get_low_water(link);
> +	link->high_water_mark = _get_high_water(link);
> +	tsn_unlock(link);
> +	return 0;
> +}
> +EXPORT_SYMBOL(tsn_clear_buffer_size);
> +
> +void *tsn_set_external_buffer(struct tsn_link *link, void *buffer,
> +			      size_t buffer_size)
> +{
> +	void *old_buffer;
> +
> +	if (!link)
> +		return NULL;
> +	if (buffer_size < link->max_payload_size)
> +		pr_warn("%s: buffer_size (%zu) < max_payload_size (%u)\n",
> +			__func__, buffer_size, link->max_payload_size);
> +
> +	tsn_lock(link);
> +	if (!link->external_buffer && link->buffer)
> +		_tsn_free_buffer(link);
> +
> +	old_buffer = link->buffer;
> +	link->external_buffer = 1;
> +	link->buffer_size = buffer_size;
> +	link->used_buffer_size = buffer_size;
> +	link->buffer = buffer;
> +	link->head = link->buffer;
> +	link->tail = link->buffer;
> +	link->end = link->buffer + link->used_buffer_size;
> +	tsn_unlock(link);
> +	return old_buffer;
> +}
> +EXPORT_SYMBOL(tsn_set_external_buffer);
> +
> +/* Caller must hold link->lock!
> + *
> + * Write data *into* buffer, either from net or from shim due to a
> + * closing underflow event.
> + */
> +static void __tsn_buffer_write(struct tsn_link *link, void *src, size_t bytes)
> +{
> +	int rem = 0;
> +
> +	/* No Need To Wrap, if overflow we will overwrite without
> +	 * warning.
> +	 */
> +	trace_tsn_buffer_write(link, bytes);
> +	if (link->head + bytes < link->end) {
> +		memcpy(link->head, src, bytes);
> +		link->head += bytes;
> +	} else {
> +		rem = link->end - link->head;
> +		memcpy(link->head, src, rem);
> +		memcpy(link->buffer, (src + rem), bytes - rem);
> +		link->head = link->buffer + (bytes - rem);
> +	}
> +}
> +
> +int tsn_buffer_write(struct tsn_link *link, void *src, size_t bytes)
> +{
> +	if (!link)
> +		return -EINVAL;
> +
> +	/* We should not do anything if link has gone inactive */
> +	if (!tsn_link_is_on(link))
> +		return 0;
> +
> +	/* Copied a batch of data and if link is disabled, it is now
> +	 * safe to enable it. Otherwise we will continue to send
> +	 * null-frames to remote.
> +	 */
> +	if (!tsn_lb(link))
> +		tsn_lb_enable(link);
> +
> +	__tsn_buffer_write(link, src, bytes);
> +
> +	return bytes;
> +}
> +EXPORT_SYMBOL(tsn_buffer_write);
> +
> +/**
> + * tsn_buffer_write_net - take data from a skbuff and write it into buffer
> + *
> + * When we receive a frame, we grab data from the skbuff and add it to
> + * link->buffer.
> + *
> + * Note that this routine does NOT CARE about channels, samplesize etc,
> + * it is a _pure_ copy that handles ringbuffer wraps etc.
> + *
> + * This function have side-effects as it will update internal tsn_link
> + * values and trigger refill() should the buffer run low.
> + *
> + * NOTE: called from tsn_rx_handler() -> _tsnh_handle_du(), with
> + *	 tsn_lock held.
> + *
> + * @param link current link that holds the buffer
> + * @param buffer the buffer to copy from
> + * @param bytes number of bytes
> + * @returns Bytes copied into link->buffer, negative value upon error.
> + */
> +int tsn_buffer_write_net(struct tsn_link *link, void *src, size_t bytes)
> +{
> +	size_t used;
> +
> +	if (!link)
> +		return -EINVAL;
> +
> +	/* Driver has not been enabled yet, i.e. it is in state 'off' and we
> +	 * have no way of knowing the state of the buffers.
> +	 * Silently drop the data, pretend write went ok
> +	 */
> +	trace_tsn_buffer_write_net(link, bytes);
> +	if (!tsn_lb(link))
> +		return bytes;
> +
> +	__tsn_buffer_write(link, src, bytes);
> +
> +	/* If we stored more data than high_water, we need to drain
> +	 *
> +	 * In ALSA, this will trigger a snd_pcm_period_elapsed() for the
> +	 * substream connected to this particular link.
> +	 */
> +	used = _tsn_buffer_used(link);
> +	if (used > link->high_water_mark) {
> +		trace_tsn_buffer_drain(link, used);
> +		link->ops->buffer_drain(link);
> +	}
> +
> +	return bytes;
> +}
> +
> +/* caller must hold link->lock!
> + *
> + * Read data *from* buffer, either to net or to shim due to a
> + * closing overflow event.
> + *
> + * Function will *not* care if you read past head and into unchartered
> + * territory, caller must ascertain validity of bytes.
> + */
> +static void __tsn_buffer_read(struct tsn_link *link, void *dst, size_t bytes)
> +{
> +	int rem = 0;
> +
> +	trace_tsn_buffer_read(link, bytes);
> +	if ((link->tail + bytes) < link->end) {
> +		memcpy(dst, link->tail, bytes);
> +		link->tail += bytes;
> +	} else {
> +		rem = link->end - link->tail;
> +		memcpy(dst, link->tail, rem);
> +		memcpy(dst + rem, link->buffer, bytes - rem);
> +		link->tail = link->buffer + bytes - rem;
> +	}
> +}
> +
> +/**
> + * tsn_buffer_read_net - read data from link->buffer and give to network layer
> + *
> + * When we send a frame, we grab data from the buffer and add it to the
> + * sk_buff->data, this is primarily done by the Tx-subsystem in tsn_net
> + * and is typically done in small chunks
> + *
> + * @param link current link that holds the buffer
> + * @param buffer the buffer to copy into, must be at least of size bytes
> + * @param bytes number of bytes.
> + *
> + * Note that this routine does NOT CARE about channels, samplesize etc,
> + * it is a _pure_ copy that handles ringbuffer wraps etc.
> + *
> + * This function have side-effects as it will update internal tsn_link
> + * values and trigger refill() should the buffer run low.
> + *
> + * NOTE: expects to be called with locks held
> + *
> + * @return Bytes copied into link->buffer, negative value upon error.
> + */
> +int tsn_buffer_read_net(struct tsn_link *link, void *buffer, size_t bytes)
> +{
> +	size_t used;
> +
> +	if (!link)
> +		return -EINVAL;
> +
> +	/* link is currently inactive, e.g. we send frames, but without
> +	 * content
> +	 *
> +	 * This can be done before we ship data, or if we are muted
> +	 * (without expressively stating that over 1722.1
> +	 *
> +	 * We do not need to grab any locks here as we won't touch the
> +	 * link
> +	 */
> +	if (!tsn_lb(link)) {
> +		memset(buffer, 0, bytes);
> +		goto out;
> +	}
> +
> +	/* sanity check of bytes to read
> +	 * FIXME
> +	 */
> +
> +	__tsn_buffer_read(link, buffer, bytes);
> +
> +	/* Trigger refill from client app */
> +	used = _tsn_buffer_used(link);
> +	if (used < link->low_water_mark) {
> +		trace_tsn_refill(link, used);
> +		link->ops->buffer_refill(link);
> +	}
> +out:
> +	return bytes;
> +}
> +
> +int tsn_buffer_read(struct tsn_link *link, void *buffer, size_t bytes)
> +{
> +	if (!link)
> +		return -EINVAL;
> +
> +	/* We should not do anything if link has gone inactive */
> +	if (!tsn_link_is_on(link))
> +		return 0;
> +
> +	tsn_lock(link);
> +	__tsn_buffer_read(link, buffer, bytes);
> +	tsn_unlock(link);
> +	return bytes;
> +}
> +EXPORT_SYMBOL(tsn_buffer_read);
> +
> +static int _tsn_send_batch(struct tsn_link *link)
> +{
> +	int ret = 0;
> +	int num_frames = (link->class_a ? 8 : 4);
> +	u64 ts_base_ns = ktime_to_ns(ktime_get()) + (link->class_a ? 2000000 : 50000000);
> +	u64 ts_delta_ns = (link->class_a ? 125000 : 250000);
> +
> +	trace_tsn_send_batch(link, num_frames, ts_base_ns, ts_delta_ns);
> +	ret = tsn_net_send_set(link, num_frames, ts_base_ns, ts_delta_ns);
> +	if (ret < 0)
> +		pr_err("%s: could not send frame - %d\n", __func__, ret);
> +
> +	return ret;
> +}
> +
> +static int _tsn_hrtimer_callback(struct tsn_link *link)
> +{
> +	int ret = _tsn_send_batch(link);
> +
> +	if (ret) {
> +		pr_err("%s: Error sending frames (%d), disabling link.\n",
> +		       __func__, ret);
> +		tsn_teardown_link(link);
> +		return 0;
> +	}
> +	return 0;
> +}
> +
> +static enum hrtimer_restart tsn_hrtimer_callback(struct hrtimer *hrt)
> +{
> +	struct tsn_list *list = container_of(hrt, struct tsn_list, tsn_timer);
> +	struct tsn_link *link;
> +	struct hlist_node *tmp;
> +	int bkt = 0;
> +
> +	if (!tsn_core_running(list))
> +		return HRTIMER_NORESTART;
> +
> +	hrtimer_forward_now(hrt, ns_to_ktime(list->period_ns));
> +
> +	hash_for_each_safe(tlinks, bkt, tmp, link, node) {
> +		if (tsn_link_is_on(link) && link->estype_talker)
> +			_tsn_hrtimer_callback(link);
> +	}
> +
> +	return HRTIMER_RESTART;
> +}
> +
> +static long tsn_hrtimer_init(void *arg)
> +{
> +	/* Run every 1ms, _tsn_send_batch will figure out how many
> +	 * frames to send for active frames
> +	 */
> +	struct tsn_list *list = (struct tsn_list *)arg;
> +
> +	hrtimer_init(&list->tsn_timer, CLOCK_MONOTONIC,
> +		     HRTIMER_MODE_REL | HRTIMER_MODE_PINNED);
> +
> +	list->tsn_timer.function = tsn_hrtimer_callback;
> +	hrtimer_cancel(&list->tsn_timer);
> +	atomic_set(&list->running, 1);
> +
> +	hrtimer_start(&list->tsn_timer, ns_to_ktime(list->period_ns),
> +		      HRTIMER_MODE_REL);
> +	return 0;
> +}
> +
> +static void tsn_hrtimer_exit(struct tsn_list *list)
> +{
> +	atomic_set(&list->running, 0);
> +	hrtimer_cancel(&list->tsn_timer);
> +}
> +
> +/**
> + * tsn_prepare_link - prepare link for role as Talker/Receiver
> + *
> + * Iow; this will start shipping data through the network-layer.
> + *
> + * @link: the actual link
> + *
> + * Current status: each link will get a periodic hrtimer that interrupts
> + * and ships data every 1ms. This will change once we have proper driver
> + * for hw (i.e. i210 driver).
> + */
> +int tsn_prepare_link(struct tsn_link *link, struct tsn_shim_ops *shim_ops)
> +{
> +	int ret = 0;
> +	void *buffer;
> +	u16 framesize;
> +	struct net_device *netdev;
> +
> +	/* TODO: use separate buckets (lists/rbtrees/whatever) for
> +	 * class_a and class_b talker streams. hrtimer-callback should
> +	 * not iterate over all.
> +	 */
> +
> +	if (!link || !shim_ops || !shim_ops->probe)
> +		return -EINVAL;
> +
> +	pr_info("TSN: allocating buffer, %zd bytes\n", link->buffer_size);
> +
> +	tsn_lock(link);
> +
> +	/* configure will calculate idle_slope based on framesize
> +	 * (header + payload)
> +	 */
> +	netdev = link->nic->dev;
> +	if (netdev->netdev_ops->ndo_tsn_link_configure) {
> +		framesize  = link->max_payload_size +
> +			     link->shim_header_size + tsnh_len_all();
> +		ret = netdev->netdev_ops->ndo_tsn_link_configure(netdev, link->class_a,
> +								 framesize, link->vlan_id & 0xfff);
> +		if (ret < 0)
> +			pr_err("Could not configure link - %d\n", ret);
> +	}
> +
> +	link->ops = shim_ops;
> +	tsn_unlock(link);
> +	ret = link->ops->probe(link);
> +	if (ret != 0) {
> +		pr_err("%s: Could not probe shim (%d), cannot create link\n",
> +		       __func__, ret);
> +		link->ops = NULL;
> +		goto out;
> +	}
> +
> +	tsn_lock(link);
> +	if (!link->external_buffer) {
> +		buffer = kmalloc(link->buffer_size, GFP_KERNEL);
> +		if (!buffer) {
> +			pr_err("%s: Could not allocate memory (%zu) for buffer\n",
> +			       __func__, link->buffer_size);
> +			link->ops = NULL;
> +			ret = -ENOMEM;
> +			goto unlock_out;
> +		}
> +
> +		ret = _tsn_set_buffer(link, buffer, link->buffer_size);
> +		if (ret != 0) {
> +			pr_err("%s: Could not set buffer for TSN, got %d\n",
> +			       __func__, ret);
> +			goto unlock_out;
> +		}
> +	} else {
> +		/* FIXME: not handled */
> +		pr_info("TSN does not currently handle externally hosted buffers. This is on the TODO-list\n");
> +		ret = -EINVAL;
> +		goto unlock_out;
> +	}
> +
> +	tsn_link_on(link);
> +
> +unlock_out:
> +	tsn_unlock(link);
> +out:
> +	pr_info("%s: ret=%d\n", __func__, ret);
> +	return ret;
> +}
> +
> +int tsn_teardown_link(struct tsn_link *link)
> +{
> +	if (!link)
> +		return -EINVAL;
> +
> +	tsn_lock(link);
> +	tsn_lb_disable(link);
> +	tsn_link_off(link);
> +	tsn_unlock(link);
> +
> +	/* Need to call media_close() without (spin-)locks held.
> +	 */
> +	if (link->ops)
> +		link->ops->media_close(link);
> +
> +	tsn_lock(link);
> +	link->ops = NULL;
> +	_tsn_free_buffer(link);
> +	tsn_unlock(link);
> +	pr_info("%s: disabling all parts of link\n", __func__);
> +	return 0;
> +}
> +
> +int tsn_shim_register_ops(struct tsn_shim_ops *shim_ops)
> +{
> +	if (!shim_ops)
> +		return -EINVAL;
> +
> +	if (!shim_ops->buffer_refill || !shim_ops->buffer_drain ||
> +	    !shim_ops->media_close || !shim_ops->copy_size ||
> +	    !shim_ops->validate_header || !shim_ops->assemble_header ||
> +	    !shim_ops->get_payload_data)
> +		return -EINVAL;
> +
> +	INIT_LIST_HEAD(&shim_ops->head);
> +	list_add_tail(&shim_ops->head, &tsn_shim_ops);
> +	return 0;
> +}
> +EXPORT_SYMBOL(tsn_shim_register_ops);
> +
> +void tsn_shim_deregister_ops(struct tsn_shim_ops *shim_ops)
> +{
> +	struct tsn_link *link;
> +	struct hlist_node *tmp;
> +	int bkt;
> +
> +	hash_for_each_safe(tlinks, bkt, tmp, link, node) {
> +		if (!link)
> +			continue;
> +		if (link->ops == shim_ops)
> +			tsn_teardown_link(link);
> +	}
> +	list_del(&shim_ops->head);
> +}
> +EXPORT_SYMBOL(tsn_shim_deregister_ops);
> +
> +char *tsn_shim_get_active(struct tsn_link *link)
> +{
> +	if (!link || !link->ops)
> +		return "off";
> +	return link->ops->shim_name;
> +}
> +
> +struct tsn_shim_ops *tsn_shim_find_by_name(const char *name)
> +{
> +	struct tsn_shim_ops *ops;
> +
> +	if (!name || list_empty(&tsn_shim_ops))
> +		return NULL;
> +
> +	list_for_each_entry(ops, &tsn_shim_ops, head) {
> +		if (strcmp(name, ops->shim_name) == 0)
> +			return ops;
> +	}
> +	return NULL;
> +}
> +
> +ssize_t tsn_shim_export_probe_triggers(char *page)
> +{
> +	struct tsn_shim_ops *ops;
> +	ssize_t res = 0;
> +
> +	if (!page || list_empty(&tsn_shim_ops))
> +		return 0;
> +	list_for_each_entry(ops, &tsn_shim_ops, head) {
> +		res += snprintf((page + res), PAGE_SIZE - res, "%s\n",
> +				 ops->shim_name);
> +	}
> +	return res;
> +}
> +
> +struct tsn_link *tsn_create_and_add_link(struct tsn_nic *nic)
> +{
> +	u64 sid = 0;
> +	struct tsn_link *link = kzalloc(sizeof(*link), GFP_KERNEL);
> +
> +	if (!link)
> +		return NULL;
> +	if (!nic) {
> +		kfree(link);
> +		return NULL;
> +	}
> +
> +	spin_lock_init(&link->lock);
> +	tsn_lock(link);
> +	tsn_link_off(link);
> +	tsn_lb_disable(link);
> +	do {
> +		sid = prandom_u32();
> +		sid |= prandom_u32() << 31;
> +	} while (tsn_find_by_stream_id(sid));
> +	link->stream_id = sid;
> +
> +	/* There's a slim chance that we actually hit on the first frame
> +	 * of data, but if we do, remote seqnr is most likely 0. If this
> +	 * is not up to par,, fix in rx_handler
> +	 */
> +	link->last_seqnr = 0xff;
> +
> +	/* class B audio 48kHz sampling, S16LE, 2ch and IEC61883-6 CIP
> +	 * header
> +	 */
> +	link->max_payload_size = 48;
> +	link->shim_header_size =  8;
> +
> +	/* Default VLAN ID is SR_PVID (2) unless otherwise supplied from
> +	 * MSRP, PCP is default 3 for class A, 2 for Class B (See IEEE
> +	 * 802.1Q-2011, table 6-6)
> +	 */
> +	link->vlan_id = 0x2;
> +	link->pcp_a = 3;
> +	link->pcp_b = 2;
> +	link->class_a = 0;
> +
> +	link->buffer_size = 16536;
> +	/* default: talker since listener isn't implemented yet. */
> +	link->estype_talker = 1;
> +
> +	link->nic = nic;
> +	tsn_unlock(link);
> +
> +	/* Add the newly created link to the hashmap of all active links.
> +	 *
> +	 * test if sid is present in hashmap already (barf on that)
> +	 */
> +
> +	mutex_lock(&tlist.lock);
> +	hash_add(tlinks, &link->node, link->stream_id);
> +	mutex_unlock(&tlist.lock);
> +	pr_info("%s: added link with stream_id: %llu\n",
> +		__func__, link->stream_id);
> +
> +	return link;
> +}
> +
> +ssize_t tsn_get_stream_ids(char *page, ssize_t len)
> +{
> +	struct tsn_link *link;
> +	struct hlist_node *tmp;
> +	char *buffer = page;
> +	int bkt;
> +
> +	if (!page)
> +		return 0;
> +
> +	if (hash_empty(tlinks))
> +		return sprintf(buffer, "no links registered\n");
> +
> +	hash_for_each_safe(tlinks, bkt, tmp, link, node)
> +		buffer += sprintf(buffer, "%llu\n", link->stream_id);
> +
> +	return (buffer - page);
> +}
> +
> +struct tsn_link *tsn_find_by_stream_id(u64 sid)
> +{
> +	struct tsn_link *link;
> +
> +	if (hash_empty(tlinks))
> +		return 0;
> +
> +	hash_for_each_possible(tlinks, link, node, sid) {
> +		if (link->stream_id == sid)
> +			return link;
> +	}
> +
> +	return NULL;
> +}
> +
> +void tsn_remove_link(struct tsn_link *link)
> +{
> +	if (!link)
> +		return;
> +	tsn_net_close(link);
> +	mutex_lock(&tlist.lock);
> +	hash_del(&link->node);
> +	if (link->ops) {
> +		link->ops->media_close(link);
> +		link->ops = NULL;
> +	}
> +
> +	mutex_unlock(&tlist.lock);
> +}
> +
> +void tsn_readd_link(struct tsn_link *link, u64 newkey)
> +{
> +	if (!link)
> +		return;
> +	tsn_lock(link);
> +	if (hash_hashed(&link->node)) {
> +		pr_info("%s: updating link with stream_id %llu -> %llu\n",
> +			__func__, link->stream_id, newkey);
> +		tsn_remove_link(link);
> +	}
> +
> +	link->stream_id = newkey;
> +	tsn_unlock(link);
> +
> +	hash_add(tlinks, &link->node, link->stream_id);
> +}
> +
> +static int _tsn_capable_nic(struct net_device *netdev, struct tsn_nic *nic)
> +{
> +	if (!nic || !netdev || !netdev->netdev_ops ||
> +	    !netdev->netdev_ops->ndo_tsn_capable)
> +		return -EINVAL;
> +
> +	if (netdev->netdev_ops->ndo_tsn_capable(netdev) > 0)
> +		nic->capable = 1;
> +
> +	return 0;
> +}
> +
> +/* Identify all TSN-capable NICs in the system
> + */
> +static int tsn_nic_probe(void)
> +{
> +	struct net *net;
> +	struct net_device *netdev;
> +	struct tsn_nic *nic;
> +
> +	net = &init_net;
> +	rcu_read_lock();
> +	for_each_netdev_rcu(net, netdev) {
> +		pr_info("Found %s, alias %s on irq %d\n",
> +			netdev->name,
> +			netdev->ifalias,
> +			netdev->irq);
> +		pr_info("MAC: %pM", netdev->dev_addr);
> +		if (netdev->tx_queue_len)
> +			pr_info("Tx queue length: %lu\n", netdev->tx_queue_len);
> +		nic = kzalloc(sizeof(*nic), GFP_KERNEL);
> +		if (!nic) {
> +			pr_err("Could not allocate memory for tsn_nic!\n");
> +			return -ENOMEM;
> +		}
> +		nic->dev = netdev;
> +		nic->txq = netdev->num_tx_queues;
> +		nic->name = netdev->name;
> +		nic->tsn_list = &tlist;
> +		nic->dma_size = 1048576;
> +
> +		_tsn_capable_nic(netdev, nic);
> +
> +		/* if not capable and we are not in debug-mode, drop nic
> +		 * and continue
> +		 */
> +		if (!nic->capable && !in_debug) {
> +			pr_info("Invalid capabilities for NIC (%s), dropping from TSN list\n",
> +				netdev->name);
> +			kfree(nic);
> +			continue;
> +		}
> +
> +		INIT_LIST_HEAD(&nic->list);
> +		mutex_lock(&tlist.lock);
> +		list_add_tail(&nic->list, &tlist.head);
> +		tlist.num_avail++;
> +		mutex_unlock(&tlist.lock);
> +	}
> +	rcu_read_unlock();
> +
> +	return 0;
> +}
> +
> +static void tsn_free_nic_list(struct tsn_list *list)
> +{
> +	struct tsn_nic *tmp, *next;
> +
> +	mutex_lock(&list->lock);
> +	list_for_each_entry_safe(tmp, next, &list->head, list) {
> +		pr_info("Dropping %s from list\n", tmp->dev->name);
> +		list_del(&tmp->list);
> +		tmp->dev = NULL;
> +		kfree(tmp);
> +	}
> +	mutex_unlock(&list->lock);
> +}
> +
> +/* all active links are stored in hashmap 'tlinks'
> + */
> +static void tsn_remove_all_links(void)
> +{
> +	int bkt;
> +	struct tsn_link *link;
> +	struct hlist_node *tmp;
> +
> +	hash_for_each_safe(tlinks, bkt, tmp, link, node) {
> +		pr_info("%s removing a link\n", __func__);
> +		if (!tsn_teardown_link(link))
> +			tsn_remove_link(link);
> +	}
> +
> +	pr_info("%s: all links have been removed\n", __func__);
> +}
> +
> +static int __init tsn_init_module(void)
> +{
> +	int ret = 0;
> +
> +	INIT_LIST_HEAD(&tlist.head);
> +	mutex_init(&tlist.lock);
> +
> +	atomic_set(&tlist.running, 0);
> +	tlist.period_ns =  1000000;
> +
> +	/* Find all NICs, attach a rx-handler for sniffing out TSN
> +	 * traffic on *all* of them.
> +	 */
> +	tlist.num_avail = 0;
> +	ret = tsn_nic_probe();
> +	if (ret < 0) {
> +		pr_err("%s: somethign went awry whilst probing for NICs, aborting\n",
> +		       __func__);
> +		goto out;
> +	}
> +
> +	if (!tlist.num_avail) {
> +		pr_err("%s: No capable NIC found. Perhaps load with in_debug=1 ?\n",
> +		       __func__);
> +		ret = -EINVAL;
> +		goto out;
> +	}
> +
> +	/* register Rx-callbacks for all (valid) NICs */
> +	ret = tsn_net_add_rx(&tlist);
> +	if (ret < 0) {
> +		pr_err("%s: Could add Rx-handler, aborting\n", __func__);
> +		goto error_rx_out;
> +	}
> +
> +	/* init DMA regions etc */
> +	ret = tsn_net_prepare_tx(&tlist);
> +	if (ret < 0) {
> +		pr_err("%s: could not prepare Tx, aborting\n", __func__);
> +		goto error_tx_out;
> +	}
> +
> +	/* init hashtable */
> +	hash_init(tlinks);
> +
> +	/* init configfs */
> +	ret = tsn_configfs_init(&tlist);
> +	if (ret < 0) {
> +		pr_err("%s: Could not initialize configfs properly (%d), aborting\n",
> +		       __func__, ret);
> +		goto error_cfs_out;
> +	}
> +
> +	/* Test to see if on_cpu is available */
> +	if (on_cpu >= 0) {
> +		pr_info("%s: pinning timer on CPU %d\n", __func__, on_cpu);
> +		ret = work_on_cpu(on_cpu, tsn_hrtimer_init, &tlist);
> +		if (ret != 0) {
> +			pr_err("%s: could not init hrtimer properly on CPU %d, aborting\n",
> +			       __func__, on_cpu);
> +			goto error_hrt_out;
> +		}
> +	} else {
> +		ret = tsn_hrtimer_init(&tlist);
> +		if (ret < 0) {
> +			pr_err("%s: could not init hrtimer properly, aborting\n",
> +			       __func__);
> +			goto error_hrt_out;
> +		}
> +	}
> +	pr_info("TSN subsystem init OK\n");
> +	return 0;
> +
> +error_hrt_out:
> +	tsn_remove_all_links();
> +	tsn_configfs_exit(&tlist);
> +error_cfs_out:
> +	tsn_net_disable_tx(&tlist);
> +error_tx_out:
> +	tsn_net_remove_rx(&tlist);
> +error_rx_out:
> +	tsn_free_nic_list(&tlist);
> +out:
> +	return ret;
> +}
> +
> +static void __exit tsn_exit_module(void)
> +{
> +	pr_warn("removing module TSN\n");
> +	tsn_hrtimer_exit(&tlist);
> +
> +	tsn_remove_all_links();
> +	tsn_configfs_exit(&tlist);
> +
> +	/* Unregister Rx-handlers if set */
> +	tsn_net_remove_rx(&tlist);
> +
> +	tsn_net_disable_tx(&tlist);
> +
> +	tsn_free_nic_list(&tlist);
> +
> +	pr_warn("TSN exit\n");
> +}
> +module_param(in_debug, int, S_IRUGO);
> +module_param(on_cpu, int, S_IRUGO);
> +module_init(tsn_init_module);
> +module_exit(tsn_exit_module);
> +MODULE_AUTHOR("Henrik Austad");
> +MODULE_LICENSE("GPL");
> diff --git a/net/tsn/tsn_header.c b/net/tsn/tsn_header.c
> new file mode 100644
> index 0000000..a0d31c5
> --- /dev/null
> +++ b/net/tsn/tsn_header.c
> @@ -0,0 +1,203 @@
> +/*
> + *   Network header handling for TSN
> + *
> + *   Copyright (C) 2015- Henrik Austad <haustad@cisco.com>
> + *
> + *   This program is free software; you can redistribute it and/or modify
> + *   it under the terms of the GNU General Public License as published by
> + *   the Free Software Foundation; either version 2 of the License, or
> + *   (at your option) any later version.
> + *
> + *   This program is distributed in the hope that it will be useful,
> + *   but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *   GNU General Public License for more details.
> + */
> +#include <linux/tsn.h>
> +#include <trace/events/tsn.h>
> +
> +#include "tsn_internal.h"
> +
> +#define AVTP_GPTP_TIMEMASK 0xFFFFFFFF
> +
> +static u32 tsnh_avtp_timestamp(u64 ptime_ns)
> +{
> +	/* See 1722-2011, 5.4.8
> +	 *
> +	 * (AS_sec * 1e9 + AS_ns) % 2^32
> +	 *
> +	 * Just use ktime_get_ns() and grab lower 32 bits of it.
> +	 */
> +	/* u64 ns = ktime_to_ns(ktime_get()); */
> +	u32 gptp_ts = ptime_ns & AVTP_GPTP_TIMEMASK;
> +	return gptp_ts;
> +}
> +
> +int tsnh_ch_init(struct avtp_ch *header)
> +{
> +	if (!header)
> +		return -EINVAL;
> +	header = memset(header, 0, sizeof(*header));
> +
> +	/* This should be changed when setting control / data
> +	 * content. Set to experimental to allow for strange content
> +	 * should callee not do job properly
> +	 */
> +	header->subtype = AVTP_EXPERIMENTAL;
> +
> +	header->version = 0;
> +	return 0;
> +}
> +
> +int _tsnh_validate_du_header(struct tsn_link *link, struct avtp_ch *ch,
> +			     struct sk_buff *skb)
> +{
> +	struct avtpdu_header *header = (struct avtpdu_header *)ch;
> +	struct sockaddr_ll *sll;
> +	u16 bytes;
> +	u8 seqnr;
> +
> +	if  (ch->cd)
> +		return -EINVAL;
> +
> +	/* As a minimum, we should match the sender's MAC to the
> +	 * expected MAC before we pass the frame along.
> +	 *
> +	 * This does not give much in the way of security (a malicious
> +	 * user could probably fake this), but it should remove most
> +	 * accidents.
> +	 */
> +	sll = (struct sockaddr_ll *)&skb->cb;
> +	sll->sll_halen = dev_parse_header(skb, sll->sll_addr);
> +	if (sll->sll_halen != 6) {
> +		trace_printk("%s: received MAC address length mismatch. Expected 6 bytes, got %d\n",
> +			     __func__, sll->sll_halen);
> +		return -EPROTO;
> +	}
> +
> +	if (memcmp(link->remote_mac, &sll->sll_addr, 6)) {
> +		trace_printk("%s: received MAC-address mismatch (expected %pM, got %pM), dropping frame\n",
> +			     __func__, link->remote_mac, &sll->sll_addr);
> +		return -EPROTO;
> +	}
> +
> +	/* Current iteration of TSNis 0b000 only */
> +	if (ch->version)
> +		return -EPROTO;
> +
> +	/* Invalid StreamID, should not have ended up here in the first
> +	 * place (since we do DU only), if invalid sid, how did we find
> +	 * the link?
> +	 */
> +	if (!ch->sv)
> +		return -EPROTO;
> +
> +	/* Check seqnr, if we have lost one frame, we _could_ insert an
> +	 * empty frame, but since we have frame-guarantee from 802.1Qav,
> +	 * we don't
> +	 */
> +	seqnr = (link->last_seqnr + 1) & 0xff;
> +	if (header->seqnr != seqnr) {
> +		trace_printk("%llu: seqnr mismatch. Got %u, expected %u\n",
> +			     link->stream_id, header->seqnr, seqnr);
> +		return -EPROTO;
> +	}
> +
> +	bytes = ntohs(header->sd_len);
> +	if (bytes == 0 || bytes > link->max_payload_size) {
> +		trace_printk("%llu: payload size larger than expected (%u, expected %u)\n",
> +			     link->stream_id, bytes, link->max_payload_size);
> +		return -EINVAL;
> +	}
> +
> +	/* let shim validate header here as well */
> +	if (link->ops->validate_header &&
> +	    link->ops->validate_header(link, header) != 0)
> +		return -EINVAL;
> +
> +	return 0;
> +}
> +
> +int tsnh_assemble_du(struct tsn_link *link, struct avtpdu_header *header,
> +		     size_t bytes, u64 ts_pres_ns)
> +{
> +	int ret = 0;
> +	void *data;
> +
> +	if (!header || !link)
> +		return -EINVAL;
> +
> +	tsnh_ch_init((struct avtp_ch *)header);
> +	header->cd = 0;
> +	header->sv = 1;
> +	header->mr = 0;
> +	header->gv = 0;
> +	header->tv = 1;
> +	header->tu = 0;
> +	header->avtp_timestamp = htonl(tsnh_avtp_timestamp(ts_pres_ns));
> +	header->gateway_info = 0;
> +	header->sd_len = htons(bytes);
> +
> +	tsn_lock(link);
> +	if (!link->ops) {
> +		pr_err("%s: No available ops, cannot assemble data-unit\n",
> +		       __func__);
> +		ret = -EINVAL;
> +		goto unlock_out;
> +	}
> +	/* get pointer to where data starts */
> +	data = link->ops->get_payload_data(link, header);
> +
> +	if (bytes > link->used_buffer_size) {
> +		pr_err("bytes > buffer_size (%zd >  %zd)\n",
> +		       bytes, link->used_buffer_size);
> +		ret = -EINVAL;
> +		goto unlock_out;
> +	}
> +
> +	header->stream_id = cpu_to_be64(link->stream_id);
> +	header->seqnr = link->last_seqnr++;
> +	link->ops->assemble_header(link, header, bytes);
> +	tsn_unlock(link);
> +
> +	/* payload */
> +	ret = tsn_buffer_read_net(link, data, bytes);
> +	if (ret != bytes) {
> +		pr_err("%s: Could not copy %zd bytes of data. Res: %d\n",
> +		       __func__, bytes, ret);
> +		/* FIXME: header cleanup */
> +		goto out;
> +	}
> +	ret = 0;
> +out:
> +	return ret;
> +unlock_out:
> +	tsn_unlock(link);
> +	return ret;
> +}
> +
> +int _tsnh_handle_du(struct tsn_link *link, struct avtp_ch *ch)
> +{
> +	struct avtpdu_header *header = (struct avtpdu_header *)ch;
> +	void *data;
> +	u16 bytes;
> +	int ret;
> +
> +	bytes = ntohs(header->sd_len);
> +
> +	trace_tsn_du(link, bytes);
> +	/* bump seqnr */
> +	data = link->ops->get_payload_data(link, header);
> +	if (!data)
> +		return -EINVAL;
> +
> +	link->last_seqnr = header->seqnr;
> +	ret = tsn_buffer_write_net(link, data, bytes);
> +	if (ret != bytes) {
> +		trace_printk("%s: Could not copy %u bytes of data. Res: %d\n",
> +			     __func__, bytes, ret);
> +		return ret;
> +	}
> +
> +	return 0;
> +}
> diff --git a/net/tsn/tsn_internal.h b/net/tsn/tsn_internal.h
> new file mode 100644
> index 0000000..d0d2201
> --- /dev/null
> +++ b/net/tsn/tsn_internal.h
> @@ -0,0 +1,383 @@
> +/*
> + *   Copyright (C) 2015- Henrik Austad <haustad@cisco.com>
> + *
> + *   This program is free software; you can redistribute it and/or modify
> + *   it under the terms of the GNU General Public License as published by
> + *   the Free Software Foundation; either version 2 of the License, or
> + *   (at your option) any later version.
> + *
> + *   This program is distributed in the hope that it will be useful,
> + *   but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *   GNU General Public License for more details.
> + */
> +#ifndef _TSN_INTERNAL_H_
> +#define _TSN_INTERNAL_H_
> +#include <linux/tsn.h>
> +
> +#include <linux/mutex.h>
> +#include <linux/spinlock.h>
> +#include <linux/if_ether.h>
> +#include <linux/if_vlan.h>
> +
> +/* TODO:
> + * - hide tsn-structs and provide handlers
> + * - decouple config/net from core
> + */
> +
> +struct avtpdu_header;
> +struct tsn_link;
> +struct tsn_shim_ops;
> +
> +#define IS_TSN_FRAME(x) (ntohs(x) == ETH_P_TSN)
> +#define IS_PTP_FRAME(x) (ntohs(x) == ETH_P_1588)
> +#define IS_1Q_FRAME(x)  (ntohs(x) == ETH_P_8021Q)
> +
> +/**
> + * tsn_add_link - create and add a new link to the system
> + *
> + * Note: this will not enable the link, just allocate most of the data
> + * required for the link. One notable exception being the buffer as we
> + * can modify the buffersize before we start the link.
> + *
> + * @param nic : the nic the link is tied to
> + * @returns the new link
> + */
> +struct tsn_link *tsn_create_and_add_link(struct tsn_nic *nic);
> +
> +/**
> + * tsn_get_stream_ids - write all current Stream IDs into the page.
> + *
> + * @param page the page to write into
> + * @param len size of page
> + * @returns the number of bytes written
> + */
> +ssize_t tsn_get_stream_ids(char *page, ssize_t len);
> +
> +/**
> + * tsn_find_by_stream_id - given a sid, find the corresponding link
> + *
> + * @param sid stream_id
> + * @returns tsn_link struct or NULL if not found
> + */
> +struct tsn_link *tsn_find_by_stream_id(u64 sid);
> +
> +/**
> + * tsn_readd_link - make sure a link is moved to the correct bucket when
> + * stream_id is updated
> + *
> + * @link the TSN link
> + * @old_key previous key for which it can be located in the hashmap
> + *
> + */
> +void tsn_readd_link(struct tsn_link *link, u64 old_key);
> +
> +/**
> + * tsn_remove_link: cleanup and remove from internal storage
> + *
> + * @link: the link to be removed
> + */
> +void tsn_remove_link(struct tsn_link *link);
> +
> +/**
> + * tsn_prepare_link - make link ready for usage
> + *
> + * Caller is happy with the different knobs, this will create the link and start
> + * pushing the data.
> + *
> + * Requirement:
> + *	- callback registered
> + *	- State set to either Talker or Listener
> + *
> + * @param active link
> + * @param the shim_ops to use for the new link
> + * @return 0 on success, negative on error
> + */
> +int tsn_prepare_link(struct tsn_link *link, struct tsn_shim_ops *shim_ops);
> +int tsn_teardown_link(struct tsn_link *link);
> +
> +/**
> + * tsn_set_external_buffer - force an update of the buffer
> + *
> + * This will cause tsn_core to use an external buffer. If external
> + * buffering is already in use, this has the effect of forcing an update
> + * of the buffer.
> + *
> + * This will cause tsn_core to swap buffers. The current buffer is
> + * returned and the new is used in place.
> + *
> + * Note: If the new buffer is NULL or buffer_size is less than
> + * max_payload_size, the result can be interesting (by calling this
> + * function, you claim to know what you are doing and should pass sane
> + * values).
> + *
> + * This can also be used if you need to resize the buffer in use.
> + *
> + * Core will continue to use the tsn_shim_swap when the new buffer is
> + * full.
> + *
> + * @param link current link owning the buffer
> + * @param buffer new buffer to use
> + * @param buffer_size size of new buffer
> + * @return old buffer
> + */
> +void *tsn_set_external_buffer(struct tsn_link *link, void *buffer,
> +			      size_t buffer_size);
> +
> +/**
> + * tsn_buffer_write_net - write data *into* link->buffer from the network layer
> + *
> + * Used by tsn_net and will typicall accept very small pieces of data.
> + *
> + * @param link  the link associated with the stream_id in the frame
> + * @param src   pointer to data in buffer
> + * @param bytes number of bytes to copy
> + * @return number of bytes copied into the buffer
> + */
> +int tsn_buffer_write_net(struct tsn_link *link, void *src, size_t bytes);
> +
> +/**
> + * tsn_buffer_read_net - read data from link->buffer and give to network layer
> + *
> + * When we send a frame, we grab data from the buffer and add it to the
> + * sk_buff->data, this is primarily done by the Tx-subsystem in tsn_net
> + * and is typically done in small chunks
> + *
> + * @param link current link that holds the buffer
> + * @param buffer the buffer to copy into, must be at least of size bytes
> + * @param bytes number of bytes.
> + *
> + * Note that this routine does NOT CARE about channels, samplesize etc,
> + * it is a _pure_ copy that handles ringbuffer wraps etc.
> + *
> + * This function have side-effects as it will update internal tsn_link
> + * values and trigger refill() should the buffer run low.
> + *
> + * @return Bytes copied into link->buffer, negative value upon error.
> + */
> +int tsn_buffer_read_net(struct tsn_link *link, void *buffer, size_t bytes);
> +
> +/**
> + * tsn_core_running(): test if the link is running
> + *
> + * By running, we mean that it is configured and a proper shim has been
> + * loaded. It does *not* mean that we are currently pushing data in any
> + * direction, see tsn_net_buffer_disabled() for this
> + *
> + * @param struct tsn_link active link
> + * @returns 1 if core is running
> + */
> +static inline int tsn_core_running(struct tsn_list *list)
> +{
> +	if (list)
> +		return atomic_read(&list->running);
> +	return 0;
> +}
> +
> +/**
> + * _tsn_buffer_used - how much of the buffer is filled with valid data
> + *
> + * - assumes link->running in state running
> + * - will ignore change changed state
> + *
> + * We write to head, read from tail.
> + */
> +static inline size_t _tsn_buffer_used(struct tsn_link *link)
> +{
> +	return  (link->head - link->tail) % link->used_buffer_size;
> +}
> +
> +static inline void tsn_lock(struct tsn_link *link)
> +{
> +	spin_lock(&link->lock);
> +}
> +
> +static inline void tsn_unlock(struct tsn_link *link)
> +{
> +	spin_unlock(&link->lock);
> +}
> +
> +/* -----------------------------
> + * ConfigFS handling
> + */
> +int tsn_configfs_init(struct tsn_list *tlist);
> +void tsn_configfs_exit(struct tsn_list *tlist);
> +
> +/* -----------------------------
> + * TSN Header
> + */
> +
> +static inline size_t tsnh_len(void)
> +{
> +	/* include 802.1Q tag */
> +	return sizeof(struct avtpdu_header);
> +}
> +
> +static inline u16 tsnh_len_all(void)
> +{
> +	return (u16)tsnh_len() + ETH_HLEN;
> +}
> +
> +/**
> + * tsnh_payload_size_valid - if the entire payload is within size-limit
> + *
> + * Ensure that max_payload_size and shim_header_size is within acceptable limits
> + *
> + * We need both values to calculate the payload size when reserving
> + * bandwidth, but only payload-size when instructing the shim to copy
> + * out data for us.
> + *
> + * @param max_payload_size requested payload to send in each frame (upper limit)
> + * @return 0 on invalid, 1 on valid
> + */
> +static inline int tsnh_payload_size_valid(u16 max_payload_size,
> +					  u16 shim_hdr_size)
> +{
> +	/* VLAN_ETH_ZLEN	64 */
> +	/* VLAN_ETH_FRAME_LEN	1518 */
> +	u32 framesize = max_payload_size + tsnh_len_all() + shim_hdr_size;
> +
> +	return framesize >= VLAN_ETH_ZLEN && framesize <= VLAN_ETH_FRAME_LEN;
> +}
> +
> +/**
> + * _tsnh_validate_du_header - basic header validation
> + *
> + * This expects the parameters to be present and the link-lock to be
> + * held.
> + *
> + * @param header header to verify
> + * @param link owner of stream
> + * @param socket_buffer
> + * @return 0 on valid, negative on invalid/error
> + */
> +int _tsnh_validate_du_header(struct tsn_link *link, struct avtp_ch *ch,
> +			     struct sk_buff *skb);
> +
> +/**
> + * tsnh_assemble_du - assemble header and copy data from buffer
> + *
> + * This function will initialize the header and pass final init to
> + * shim->assemble_header before copying data into the buffer.
> + *
> + * It assumes that 'bytes' is a sane value, i.e. that it is a valid
> + * multiple of number of channels, sample size etc.
> + *
> + * @param link   Current TSN link, also holds the buffer
> + *
> + * @param header header to assemble for data
> + *
> + * @param bytes  Number of bytes to send in this frame
> + *
> + * @param ts_pres_ns current for when the frame should be presented or
> + *                   considered valid by the receiving end. In
> + *                   nanoseconds since epoch, will be converted to gPTP
> + *                   compatible timestamp.
> + *
> + * @return 0 on success, negative on error
> + */
> +int tsnh_assemble_du(struct tsn_link *link, struct avtpdu_header *header,
> +		     size_t bytes, u64 ts_pres_ns);
> +
> +/**
> + * _tsnh_handle_du - handle incoming data and store to media-buffer
> + *
> + * This assumes that the frame actually belongs to the link and that it
> + * has passed basic validation.
> + *
> + * It also expects the link lock to be held.
> + *
> + * @param link    Link associated with stream_id
> + * @param header  Header of incoming frame
> + * @return number of bytes copied to buffer or negative on error
> + */
> +int _tsnh_handle_du(struct tsn_link *link, struct avtp_ch *ch);
> +
> +static inline struct avtp_ch *tsnh_ch_from_skb(struct sk_buff *skb)
> +{
> +	if (!skb)
> +		return NULL;
> +	if (!IS_TSN_FRAME(eth_hdr(skb)->h_proto))
> +		return NULL;
> +
> +	return (struct avtp_ch *)skb->data;
> +}
> +
> +/**
> + * tsn_net_add_rx - add Rx handler for all NICs listed
> + *
> + * @param list tsn_list to add Rx handler to
> + * @return 0 on success, negative on error
> + */
> +int tsn_net_add_rx(struct tsn_list *list);
> +
> +/**
> + * tsn_net_remove_rx - remove Rx-handlers for all tsn_nics
> + *
> + * Go through all NICs and remove those Rx-handlers we have
> + * registred. If someone else has added an Rx-handler to the NIC, we do
> + * not touch it.
> + *
> + * @param list list of all tsn_nics (with links)
> + */
> +void tsn_net_remove_rx(struct tsn_list *list);
> +
> +/**
> + * tsn_net_open_tx - prepare all capable links for Tx
> + *
> + * This will prepare all NICs for Tx, and those marked as 'capable'
> + * will be initialized with DMA regions. Note that this is not the final
> + * step for preparing for Tx, it is only when we have active links that
> + * we know how much bandwidth we need and then can set the appropriate
> + * idleSlope params etc.
> + *
> + * @tlist: list of all available card
> + * @return: negative on error, on success the number of prepared NICS
> + *          are returned.
> + */
> +int tsn_net_prepare_tx(struct tsn_list *tlist);
> +
> +/**
> + * tsn_net_disable_tx - disable Tx on card
> + *
> + * This frees DMA-memory from capable NICs
> + *
> + * @param tsn_list: link to all available NICs used by TSN
> + */
> +void tsn_net_disable_tx(struct tsn_list *tlist);
> +
> +/**
> + * tsn_net_set_vlan - try to register the VLAN on the NIC
> + *
> + * Some NICs will handle VLAN themselves, try to register this vlan with
> + * the card to enable hw-support for Tx via this VLAN
> + *
> + * @param: tsn_link the active link
> + * @return: 0 on success, negative on error.
> + */
> +int tsn_net_set_vlan(struct tsn_link *link);
> +
> +/**
> + * tsn_net_close - close down link properly
> + *
> + * @param struct tsn_link * active link to close down
> + */
> +void tsn_net_close(struct tsn_link *link);
> +
> +/**
> + * tsn_net_send_set - send a set of frames
> + *
> + * We want to assemble a number of sk_buffs at a time and ship them off
> + * in a single go and then go back to sleep. Pacing should be done by
> + * hardware, or if we are in in_debug, we don't really care anyway
> + *
> + * @param link        : current TSN-link
> + * @param num         : the number of frames to create
> + * @param ts_base_ns  : base timestamp for when the frames should be
> + *		        considered valid
> + * @param ts_delta_ns : time between each frame in the set
> + */
> +int tsn_net_send_set(struct tsn_link *link, size_t num, u64 ts_base_ns,
> +		     u64 ts_delta_ns);
> +
> +#endif	/* _TSN_INTERNAL_H_ */
> diff --git a/net/tsn/tsn_net.c b/net/tsn/tsn_net.c
> new file mode 100644
> index 0000000..560e2fd
> --- /dev/null
> +++ b/net/tsn/tsn_net.c
> @@ -0,0 +1,403 @@
> +/*
> + *   Network part of TSN
> + *
> + *   Copyright (C) 2015- Henrik Austad <haustad@cisco.com>
> + *
> + *   This program is free software; you can redistribute it and/or modify
> + *   it under the terms of the GNU General Public License as published by
> + *   the Free Software Foundation; either version 2 of the License, or
> + *   (at your option) any later version.
> + *
> + *   This program is distributed in the hope that it will be useful,
> + *   but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *   GNU General Public License for more details.
> + */
> +
> +#include <linux/kernel.h>
> +#include <linux/module.h>
> +#include <linux/netdevice.h>
> +#include <linux/socket.h>
> +#include <linux/skbuff.h>
> +#include <linux/if_vlan.h>
> +#include <linux/skbuff.h>
> +#include <net/sock.h>
> +
> +#include <linux/tsn.h>
> +#include <trace/events/tsn.h>
> +#include "tsn_internal.h"
> +
> +/**
> + * tsn_rx_handler - consume all TSN-tagged frames and forward to tsn_link.
> + *
> + * This handler, if it regsters properly, will consume all TSN-tagged
> + * frames belonging to registered Stream IDs
> + *
> + * Unknown StreamIDs will be passed through without being touched.
> + *
> + * @param pskb sk_buff with incomign data
> + * @returns RX_HANDLER_CONSUMED for TSN frames to known StreamIDs,
> + *	    RX_HANDLER_PASS for everything else.
> + */
> +static rx_handler_result_t tsn_rx_handler(struct sk_buff **pskb)
> +{
> +	struct sk_buff *skb = *pskb;
> +	const struct ethhdr *ethhdr = eth_hdr(skb);
> +	struct avtp_ch *ch;
> +	struct tsn_link *link;
> +	rx_handler_result_t ret = RX_HANDLER_PASS;
> +
> +	ch = tsnh_ch_from_skb(skb);
> +	if (!ch)
> +		return RX_HANDLER_PASS;
> +	/* We do not (currently) touch control_data frames. */
> +	if (ch->cd)
> +		return RX_HANDLER_PASS;
> +
> +	link = tsn_find_by_stream_id(be64_to_cpu(ch->stream_id));
> +	if (!link)
> +		return RX_HANDLER_PASS;
> +
> +	tsn_lock(link);
> +
> +	if (!tsn_link_is_on(link))
> +		goto out_unlock;
> +
> +	/* If link->ops is not set yet, there's nothing we can do, just
> +	 * ignore this frame
> +	 */
> +	if (!link->ops)
> +		goto out_unlock;
> +
> +	if (_tsnh_validate_du_header(link, ch, skb))
> +		goto out_unlock;
> +
> +	trace_tsn_rx_handler(link, ethhdr, be64_to_cpu(ch->stream_id));
> +
> +	/* Handle dataunit, if it failes, pass on the frame and let
> +	 * userspace pick it up.
> +	 */
> +	if (_tsnh_handle_du(link, ch) < 0)
> +		goto out_unlock;
> +
> +	/* Done, data has been copied, free skb and return consumed */
> +	consume_skb(skb);
> +	ret = RX_HANDLER_CONSUMED;
> +
> +out_unlock:
> +	tsn_unlock(link);
> +	return ret;
> +}
> +
> +int tsn_net_add_rx(struct tsn_list *tlist)
> +{
> +	struct tsn_nic *nic;
> +
> +	if (!tlist)
> +		return -EINVAL;
> +
> +	/* Setup receive handler for TSN traffic.
> +	 *
> +	 * Receive will happen all the time, once a link is active as a
> +	 * Listener, we will add a hook into the receive-handler to
> +	 * steer the frames to the correct link.
> +	 *
> +	 * We try to add Rx-handlers to all the card listed in tlist (we
> +	 * assume core has filtered the NICs appropriatetly sothat only
> +	 * TSN-capable cards are present).
> +	 */
> +	mutex_lock(&tlist->lock);
> +	list_for_each_entry(nic, &tlist->head, list) {
> +		rtnl_lock();
> +		if (netdev_rx_handler_register(nic->dev, tsn_rx_handler, nic) < 0) {
> +			pr_err("%s: could not attach an Rx-handler to %s, this link will not be able to accept TSN traffic\n",
> +			       __func__, nic->name);
> +			rtnl_unlock();
> +			continue;
> +		}
> +		rtnl_unlock();
> +		pr_info("%s: attached rx-handler to %s\n",
> +			__func__, nic->name);
> +		nic->rx_registered = 1;
> +	}
> +	mutex_unlock(&tlist->lock);
> +	return 0;
> +}
> +
> +void tsn_net_remove_rx(struct tsn_list *tlist)
> +{
> +	struct tsn_nic *nic;
> +
> +	if (!tlist)
> +		return;
> +	mutex_lock(&tlist->lock);
> +	list_for_each_entry(nic, &tlist->head, list) {
> +		rtnl_lock();
> +		if (nic->rx_registered)
> +			netdev_rx_handler_unregister(nic->dev);
> +		rtnl_unlock();
> +		nic->rx_registered = 0;
> +		pr_info("%s: RX-handler for %s removed\n",
> +			__func__, nic->name);
> +	}
> +	mutex_unlock(&tlist->lock);
> +}
> +
> +int tsn_net_prepare_tx(struct tsn_list *tlist)
> +{
> +	struct tsn_nic *nic;
> +	struct device *dev;
> +	int ret = 0;
> +
> +	if (!tlist)
> +		return -EINVAL;
> +
> +	mutex_lock(&tlist->lock);
> +	list_for_each_entry(nic, &tlist->head, list) {
> +		if (!nic)
> +			continue;
> +		if (!nic->capable)
> +			continue;
> +
> +		if (!nic->dev->netdev_ops)
> +			continue;
> +
> +		dev = nic->dev->dev.parent;
> +		nic->dma_mem = dma_alloc_coherent(dev, nic->dma_size,
> +						  &nic->dma_handle, GFP_KERNEL);
> +		if (!nic->dma_mem) {
> +			nic->capable = 0;
> +			nic->dma_size = 0;
> +			continue;
> +		}
> +		ret++;
> +	}
> +	mutex_unlock(&tlist->lock);
> +	pr_info("%s: configured %d cards to use DMA\n", __func__, ret);
> +	return ret;
> +}
> +
> +void tsn_net_disable_tx(struct tsn_list *tlist)
> +{
> +	struct tsn_nic *nic;
> +	struct device *dev;
> +	int res = 0;
> +
> +	if (!tlist)
> +		return;
> +	mutex_lock(&tlist->lock);
> +	list_for_each_entry(nic, &tlist->head, list) {
> +		if (nic->capable && nic->dma_mem) {
> +			dev = nic->dev->dev.parent;
> +			dma_free_coherent(dev, nic->dma_size, nic->dma_mem,
> +					  nic->dma_handle);
> +			res++;
> +		}
> +	}
> +	mutex_unlock(&tlist->lock);
> +	pr_info("%s: freed DMA regions from %d cards\n", __func__, res);
> +}
> +
> +void tsn_net_close(struct tsn_link *link)
> +{
> +	/* struct tsn_rx_handler_data *rx_data; */
> +
> +	/* Careful! we need to make sure that we actually succeeded in
> +	 * registering the handler in open unless we want to unregister
> +	 * some random rx_handler..
> +	 */
> +	if (!link->estype_talker) {
> +		;
> +		/* Make sure we notify rx-handler so it doesn't write
> +		 * into NULL
> +		 */
> +	}
> +}
> +
> +int tsn_net_set_vlan(struct tsn_link *link)
> +{
> +	int err;
> +	struct tsn_nic *nic = link->nic;
> +	const struct net_device_ops *ops = nic->dev->netdev_ops;
> +
> +	int vf   = 2;
> +	u16 vlan = link->vlan_id;
> +	u8 qos   = link->class_a ? link->pcp_a : link->pcp_b;
> +
> +	pr_info("%s:%s Setting vlan=%u,vf=%d,qos=%u\n",
> +		__func__, nic->name, vlan, vf, qos);
> +	if (ops->ndo_set_vf_vlan) {
> +		err = ops->ndo_set_vf_vlan(nic->dev, vf, vlan, qos);
> +		if (err != 0) {
> +			pr_err("%s:%s could not set VLAN to %u, got %d\n",
> +			       __func__,  nic->name, vlan, err);
> +			return -EINVAL;
> +		}
> +		return 0;
> +	}
> +	return -1;
> +}
> +
> +static inline u16 _get_8021q_vid(struct tsn_link *link)
> +{
> +	u16 pcp = link->class_a ? link->pcp_a : link->pcp_b;
> +	/* If not explicitly provided, use SR_PVID 0x2*/
> +	return (link->vlan_id & VLAN_VID_MASK) | ((pcp & 0x7) << 13);
> +}
> +
> +/* create and initialize a sk_buff with appropriate TSN Header values
> + *
> + * layout of frame:
> + * - Ethernet header
> + *   dst (6) | src (6) | 802.1Q (4) | EtherType (2)
> + * - 1722 (sizeof struct avtpdu)
> + * - payload data
> + *	- type header (e.g. iec61883-6 hdr)
> + *	- payload data
> + *
> + * Required size:
> + *  Ethernet: 18 -> VLAN_ETH_HLEN
> + *  1722: tsnh_len()
> + *  payload: shim_hdr_size + data_bytes
> + *
> + * Note:
> + *	- seqnr is not set
> + *	- payload is not set
> + */
> +static struct sk_buff *_skbuf_create_init(struct tsn_link *link,
> +					  size_t data_bytes,
> +					  size_t shim_hdr_size,
> +					  u64 ts_pres_ns, u8 more)
> +{
> +	struct sk_buff *skb = NULL;
> +	struct avtpdu_header *avtpdu;
> +	struct net_device *netdev = link->nic->dev;
> +	int queue_idx;
> +	int res = 0;
> +	int hard_hdr_len;
> +
> +	/* length is size of AVTPDU + data
> +	 * +-----+ <-- head
> +	 * | - link layer header
> +	 * | - 1722 header (avtpdu_header)
> +	 * +-----+ <-- data
> +	 * | - shim_header
> +	 * | - data
> +	 * +-----+ <-- tail
> +	 * |
> +	 * +-----+ <--end
> +	 * We stuff all of TSN-related
> +	 * headers in the data-segment to make it easy
> +	 */
> +	size_t hdr_len = VLAN_ETH_HLEN;
> +	size_t avtpdu_len = tsnh_len() + shim_hdr_size + data_bytes;
> +
> +	skb = alloc_skb(hdr_len + avtpdu_len + netdev->needed_tailroom,
> +			GFP_ATOMIC | GFP_DMA);
> +	if (!skb)
> +		return NULL;
> +	skb_reserve(skb, hdr_len);
> +
> +	skb->protocol = htons(ETH_P_TSN);
> +	skb->pkt_type = PACKET_OUTGOING;
> +	skb->priority = (link->class_a ? link->pcp_a : link->pcp_b);
> +	skb->dev = link->nic->dev;
> +	skb_shinfo(skb)->tx_flags |= SKBTX_HW_TSTAMP;
> +	skb->xmit_more = (more > 0 ? 1 : 0);
> +	skb_set_mac_header(skb, 0);
> +
> +	/* We are using a ethernet-type frame (even though we could send
> +	 * TSN over other medium.
> +	 *
> +	 * - skb_push(skb, ETH_HLEN)
> +	 * - set header htons(header)
> +	 * - set source addr (netdev mac addr)
> +	 * - set dest addr
> +	 * - return ETH_HLEN
> +	 */
> +	hard_hdr_len = dev_hard_header(skb, skb->dev, ETH_P_TSN,
> +				       link->remote_mac, NULL, 6);
> +
> +	skb = vlan_insert_tag(skb, htons(ETH_P_8021Q), _get_8021q_vid(link));
> +	if (!skb) {
> +		pr_err("%s: could not insert tag in buffer, aborting\n",
> +		       __func__);
> +		return NULL;
> +	}
> +
> +	/* tsnh_assemble_du() will deref avtpdu to find start of data
> +	 * segment and use that, this is to update the skb
> +	 * appropriately.
> +	 *
> +	 * tsnh_assemble_du() will grab tsn-lock before updating link
> +	 */
> +	avtpdu = (struct avtpdu_header *)skb_put(skb, avtpdu_len);
> +	res = tsnh_assemble_du(link, avtpdu, data_bytes, ts_pres_ns);
> +	if (res < 0) {
> +		pr_err("%s: Error initializing header (-> %d) , we are in an inconsistent state!\n",
> +		       __func__, res);
> +		kfree_skb(skb);
> +		return NULL;
> +	}
> +
> +	/* FIXME: Find a suitable Tx-queue
> +	 *
> +	 * For igb, this returns -1
> +	 */
> +	queue_idx = sk_tx_queue_get(skb->sk);
> +	if (queue_idx < 0 || queue_idx >= netdev->real_num_tx_queues)
> +		queue_idx = 0;
> +	skb_set_queue_mapping(skb, queue_idx);
> +	skb->queue_mapping = 0;
> +
> +	skb->csum = skb_checksum(skb, 0, hdr_len + data_bytes, 0);
> +	return skb;
> +}
> +
> +/**
> + * Send a set of frames as efficiently as possible
> + */
> +int tsn_net_send_set(struct tsn_link *link, size_t num, u64 ts_base_ns,
> +		     u64 ts_delta_ns)
> +{
> +	struct sk_buff *skb;
> +	struct net_device *dev;
> +	size_t data_size;
> +	int res;
> +	struct netdev_queue *txq;
> +	u64 ts_pres_ns = ts_base_ns;
> +
> +	if (!link)
> +		return -EINVAL;
> +	dev = link->nic->dev;
> +
> +	/* create and init sk_buff_head */
> +	while (num-- > 0) {
> +		data_size = tsn_shim_get_framesize(link);
> +
> +		skb = _skbuf_create_init(link, data_size,
> +					 tsn_shim_get_hdr_size(link),
> +					 ts_pres_ns, (num > 0));
> +		if (!skb) {
> +			pr_err("%s: could not allocate memory for skb\n",
> +			       __func__);
> +			return -ENOMEM;
> +		}
> +
> +		trace_tsn_pre_tx(link, skb, data_size);
> +		txq = skb_get_tx_queue(dev, skb);
> +		if (!txq) {
> +			pr_err("%s: Could not get tx_queue, dropping sending\n",
> +			       __func__);
> +			kfree_skb(skb);
> +			return -EINVAL;
> +		}
> +		res = netdev_start_xmit(skb, dev, txq, (num > 0));
> +		if (res != NETDEV_TX_OK) {
> +			pr_err("%s: Tx FAILED\n", __func__);
> +			return res;
> +		}
> +		ts_pres_ns += ts_delta_ns;
> +	}
> +	return 0;
> +}
> -- 
> 2.7.4
> 

-- 
Henrik Austad

Re: [very-RFC 4/8] Add TSN header for the driver

[Henrik Austad]

Clearing up netdev-typo
-H

On Sun, Jun 12, 2016 at 12:22:17AM +0200, Henrik Austad wrote:
> From: Henrik Austad <haustad@cisco.com>
> 
> This defines the general TSN headers for network packets, the
> shim-interface and the central 'tsn_list' structure.
> 
> Cc: "David S. Miller" <davem@davemloft.net>
> Signed-off-by: Henrik Austad <haustad@cisco.com>
> ---
>  include/linux/tsn.h | 806 ++++++++++++++++++++++++++++++++++++++++++++++++++++
>  1 file changed, 806 insertions(+)
>  create mode 100644 include/linux/tsn.h
> 
> diff --git a/include/linux/tsn.h b/include/linux/tsn.h
> new file mode 100644
> index 0000000..0e1f732b
> --- /dev/null
> +++ b/include/linux/tsn.h
> @@ -0,0 +1,806 @@
> +/*   TSN - Time Sensitive Networking
> + *
> + *   Copyright (C) 2016- Henrik Austad <haustad@cisco.com>
> + *
> + *   This program is free software; you can redistribute it and/or modify
> + *   it under the terms of the GNU General Public License as published by
> + *   the Free Software Foundation; either version 2 of the License, or
> + *   (at your option) any later version.
> + *
> + *   This program is distributed in the hope that it will be useful,
> + *   but WITHOUT ANY WARRANTY; without even the implied warranty of
> + *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
> + *   GNU General Public License for more details.
> + */
> +#ifndef _TSN_H
> +#define _TSN_H
> +#include <linux/list.h>
> +#include <linux/configfs.h>
> +#include <linux/hrtimer.h>
> +
> +/* The naming here can be a bit confusing as we call it TSN but naming
> + * suggests 'AVB'. Reason: IEE 1722 was written before the working group
> + * was renamed to Time Sensitive Networking.
> + *
> + * To be precise. TSN describes the protocol for shipping data, AVB is a
> + * medialayer which you can build on top of TSN.
> + *
> + * For this reason the frames are given avb-names whereas the functions
> + * use tsn_-naming.
> + */
> +
> +/* 7 bit value 0x00 - 0x7F */
> +enum avtp_subtype {
> +	AVTP_61883_IIDC = 0,
> +	AVTP_MMA = 0x1,
> +	AVTP_MAAP = 0x7e,
> +	AVTP_EXPERIMENTAL = 0x7f,
> +};
> +
> +/*		NOTE NOTE NOTE !!
> + * The headers below use bitfields extensively and verifications
> + * are needed when using little-endian vs big-endian systems.
> + */
> +
> +/* Common part of avtph header
> + *
> + * AVB Transport Protocol Common Header
> + *
> + * Defined in 1722-2011 Sec. 5.2
> + */
> +struct avtp_ch {
> +#if defined(__LITTLE_ENDIAN_BITFIELD)
> +	/* use avtp_subtype enum.
> +	 */
> +	u8 subtype:7;
> +
> +	/* Controlframe: 1
> +	 * Dataframe   : 0
> +	 */
> +	u8 cd:1;
> +
> +	/* Type specific data, part 1 */
> +	u8 tsd_1:4;
> +
> +	/* In current version of AVB, only 0 is valid, all other values
> +	 * are reserved for future versions.
> +	 */
> +	u8 version:3;
> +
> +	/* Valid StreamID in frame
> +	 *
> +	 * ControlData not related to a specific stream should clear
> +	 * this (and have stream_id = 0), _all_ other values should set
> +	 * this to 1.
> +	 */
> +	u8 sv:1;
> +#elif defined(__BIG_ENDIAN_BITFIELD)
> +	u8 cd:1;
> +	u8 subtype:7;
> +	u8 sv:1;
> +	u8 version:3;
> +	u8 tsd_1:4;
> +#else
> +#error "Unknown Endianness, cannot determine bitfield ordering"
> +#endif
> +	/* Type specific data (adjacent to tsd_1, but split due to bitfield) */
> +	u16 tsd_2;
> +	u64 stream_id;
> +
> +	/*
> +	 * payload by subtype
> +	 */
> +	u8 pbs[0];
> +} __packed;
> +
> +/* AVTPDU Common Control header format
> + * IEEE 1722#5.3
> + */
> +struct avtpc_header {
> +#if defined(__LITTLE_ENDIAN_BITFIELD)
> +	u8 subtype:7;
> +	u8 cd:1;
> +	u8 control_data:4;
> +	u8 version:3;
> +	u8 sv:1;
> +	u16 control_data_length:11;
> +	u16 status:5;
> +#elif defined(__BIG_ENDIAN_BITFIELD)
> +	u8 cd:1;
> +	u8 subtype:7;
> +	u8 sv:1;
> +	u8 version:3;
> +	u8 control_data:4;
> +	u16 status:5;
> +	u16 control_data_length:11;
> +#else
> +#error "Unknown Endianness, cannot determine bitfield ordering"
> +#endif
> +	u64 stream_id;
> +} __packed;
> +
> +/* AVTP common stream data AVTPDU header format
> + * IEEE 1722#5.4
> + */
> +struct avtpdu_header {
> +#if defined(__LITTLE_ENDIAN_BITFIELD)
> +	u8 subtype:7;
> +	u8 cd:1;
> +
> +	/* avtp_timestamp valid */
> +	u8 tv: 1;
> +
> +	/* gateway_info valid */
> +	u8 gv:1;
> +
> +	/* reserved */
> +	u8 r:1;
> +
> +	/*
> +	 * Media clock Restart toggle
> +	 */
> +	u8 mr:1;
> +
> +	u8 version:3;
> +
> +	/* StreamID valid */
> +	u8 sv:1;
> +	u8 seqnr;
> +
> +	/* Timestamp uncertain */
> +	u8 tu:1;
> +	u8 r2:7;
> +#elif defined(__BIG_ENDIAN_BITFIELD)
> +	u8 cd:1;
> +	u8 subtype:7;
> +
> +	u8 sv:1;
> +	u8 version:3;
> +	u8 mr:1;
> +	u8 r:1;
> +	u8 gv:1;
> +	u8 tv: 1;
> +
> +	u8 seqnr;
> +	u8 r2:7;
> +	u8 tu:1;
> +#else
> +#error "Unknown Endianness, cannot determine bitfield ordering"
> +#endif
> +
> +	u64 stream_id;
> +
> +	u32 avtp_timestamp;
> +	u32 gateway_info;
> +
> +	/* Stream Data Length */
> +	u16 sd_len;
> +
> +	/* Protocol specific header, derived from avtp_subtype */
> +	u16 psh;
> +
> +	/* Stream Payload Data 0 to n octets
> +	 * n so that total size < MTU
> +	 */
> +	u8 data[0];
> +} __packed;
> +
> +
> +/**
> + * struct tsn_list - The top level container of TSN
> + *
> + * This is what tsn_configfs refers to as 'tier-0'
> + *
> + * @head List of TSN cards
> + * @lock lock protecting global entries
> + * @tsn_subsys Ref to ConfigFS subsystem
> + *
> + * @running: hrtimer is running driving data out
> + * @tsn_timer: hrtimer container
> + * @num_avail Number of available TSN NICs exposed through ConfigFS
> + */
> +struct tsn_list {
> +	struct list_head head;
> +	struct mutex lock;
> +	struct configfs_subsystem tsn_subsys;
> +
> +	/*
> +	 * TSN-timer is running. Not to be confused with the per-link
> +	 * disabled flag which indicates if a remote client, like aplay,
> +	 * is pushing data to it.
> +	 */
> +	atomic_t running;
> +	struct hrtimer tsn_timer;
> +	unsigned int period_ns;
> +
> +
> +	size_t num_avail;
> +};
> +
> +/**
> + * struct tsn_nic
> + *
> + * Individual TSN-capable NICs, or 'tier-1' struct
> + *
> + * @list linked list of all TSN NICs
> + * @group configfs group
> + * @dev corresponding net_device
> + * @dma_size : size of the DMA buffer
> + * @dma_handle: housekeeping DMA-stuff
> + * @dma_mem : pointer to memory region we're using for DMAing to the NIC
> + * @name Name of NIC (same as name in dev), TO BE REMOVED
> + * @txq Size of Tx-queue. TO BE REMOVED
> + * @rx_registered flag indicating if a handler is registered for the nic
> + * @capable: if the NIC is capable for proper TSN traffic or if it must
> + *	     be emulated in software.
> + *
> + */
> +struct tsn_nic {
> +	struct list_head list;
> +	struct config_group group;
> +	struct net_device *dev;
> +	struct tsn_list *tsn_list;
> +
> +	size_t dma_size;
> +	dma_addr_t dma_handle;
> +	void *dma_mem;
> +
> +	char *name;
> +	int txq;
> +	u8 rx_registered:1;
> +	u8 capable:1;
> +	u8 reserved:6;
> +};
> +
> +struct tsn_shim_ops;
> +/**
> + * tsn_link - Structure describing a single TSN link
> + *
> + */
> +struct tsn_link {
> +	/*
> +	 * Lock for protecting the buffer
> +	 */
> +	spinlock_t lock;
> +
> +	struct config_group group;
> +	struct tsn_nic *nic;
> +	struct hlist_node node;
> +
> +	/* The link itself is active, and the tsn_core will treat it as
> +	 * an active participant and feed data from it to the
> +	 * network. This places some restrictions on which attributes
> +	 * can be changed.
> +	 *
> +	 * 1: active
> +	 * 0: inactive
> +	 */
> +	atomic_t active;
> +
> +	u64 timer_period_ns;
> +
> +	/* Pointer to media-specific data.
> +	 * e.g. struct avb_chip
> +	 */
> +	void *media_chip;
> +
> +	u64 stream_id;
> +
> +	/*
> +	 * The max required size for a _single_ TSN frame.
> +	 *
> +	 * To be used instead of channels and sample_freq.
> +	 */
> +	u16 max_payload_size;
> +	u16 shim_header_size;
> +
> +	/*
> +	 * Size of buffer (in bytes) to use when handling data to/from
> +	 * NIC.
> +	 *
> +	 * Smaller size will result in client being called more often
> +	 * but also provides lower latencies.
> +	 */
> +	size_t buffer_size;
> +	size_t used_buffer_size;
> +
> +	/*
> +	 * Used when frames are constructed and shipped to the network
> +	 * layer. If this is true, 0-frames will be sent insted of data
> +	 * from the buffer.
> +	 */
> +	atomic_t buffer_active;
> +
> +	/*
> +	 * ringbuffer for incoming or outging traffic
> +	 * +-----------------------------------+
> +	 * |                  ##########       |
> +	 * +-----------------------------------+
> +	 * ^                  ^         ^      ^
> +	 * buffer           tail      head    end
> +	 *
> +	 * Buffer: start of memory area
> +	 * tail: first byte of data in buffer
> +	 * head: first unused slot in which to store new data
> +	 *
> +	 * head,tail is used to represent the position of 'live data' in
> +	 * the buffer.
> +	 */
> +	void *buffer;
> +	void *head;
> +	void *tail;
> +	void *end;
> +
> +	/* Number of bytes to run refill/drain callbacks */
> +	size_t low_water_mark;
> +	size_t high_water_mark;
> +
> +
> +	/*
> +	 * callback ops.
> +	 */
> +	struct tsn_shim_ops *ops;
> +
> +	/*
> +	 * EndStation Type
> +	 *
> +	 * Either Talker or Listener
> +	 *
> +	 * 1: We are *Talker*, i.e. producing data to send
> +	 * 0: We are *Listener*, i.e. we receive data from another ES.
> +	 *
> +	 * This is for a single link, so even though an end-station can
> +	 * be both Talker *and* Listener, a link can only be one.
> +	 */
> +	u8 estype_talker;
> +
> +	/*
> +	 * Link will use buffer managed by the shim. For this to work,
> +	 * the shim must:
> +	 *
> +	 * - call tsn_use_external_buffer(link, size);
> +	 * - provide tsn_shim_buffer_swap(link) in tsn_shim_ops
> +	 */
> +	u8 external_buffer;
> +
> +	u8 last_seqnr;
> +
> +	/*
> +	 * Class can be either A or B
> +	 *
> +	 * ClassA: every 125us
> +	 * ClassB: every 250us
> +	 *
> +	 * This will also affect how large each frame will be.
> +	 */
> +	u8 class_a:1;
> +
> +	/*
> +	 * Any AVTP data stream must set the 802.1Q vlan id and priority
> +	 * Code point. This should be obtained from MSRP, default values
> +	 * are:
> +	 *
> +	 * pvid: SR_PVID 2
> +	 * pcp: Class A: 3
> +	 *	Class B: 2
> +	 *
> +	 * See IEEE 802.1Q-2011, Sec 35.2.2.9.3 and table 6-6 in 6.6.2
> +	 * for details
> +	 */
> +	u8 pcp_a:3;
> +	u8 pcp_b:3;
> +	u16 vlan_id:12;
> +
> +	u8 remote_mac[6];
> +};
> +
> +/**
> + * tsn_link_on - make link active
> + *
> + * This cause most of the attributes to be treated read-only since we
> + * will have to re-negotiate with the network if most of these
> + * parameters change.
> + *
> + * Note: this means that the link will be handled by the rx-handler or
> + * the timer callback, but until the link_buffer is set active (via
> + * tsn_lb_on()), actual data is not moved.
> + *
> + * @link: link being set to active
> + */
> +static inline void tsn_link_on(struct tsn_link *link)
> +{
> +	if (link)
> +		atomic_set(&link->active, 1);
> +}
> +
> +/**
> + * tsn_link_off - make link inactive
> + *
> + * The link will now be ignored by timer callback or the
> + * rx-handler. Attributes can be mostly freely changed (we assume that
> + * userspace sets values that are negotiated properly).
> + *
> + * @link: link to deactivate
> + */
> +static inline void tsn_link_off(struct tsn_link *link)
> +{
> +	if (link)
> +		atomic_set(&link->active, 0);
> +}
> +
> +/**
> + * tsn_link_is_on - query link to see if it is active
> + *
> + * Mostly used by tsn_configfs to respect the "read-only" once link is
> + * configured and made active.
> + *
> + * @link active link
> + * @returns 1 if active/on, 0 otherwise
> + */
> +static inline int tsn_link_is_on(struct tsn_link *link)
> +{
> +	if (link)
> +		return atomic_read(&link->active);
> +	return 0;
> +}
> +
> +/**
> + * tsn_set_buffer_size - adjust buffersize to match a shim
> + *
> + * This will not allocate (or deallcoate) memory, just adjust how much
> + * of the buffer allocated in tsn_prepare_link is being used. tsn_
> + * expects tsn_clear_buffer_size() to be invoked when stream is closed.
> + */
> +int tsn_set_buffer_size(struct tsn_link *link, size_t bsize);
> +int tsn_clear_buffer_size(struct tsn_link *link);
> +
> +/**
> + * tsn_buffer_write write data into the buffer from shim
> + *
> + * This is called from the shim-driver when more data is available and
> + * data needs to be pushed out to the network.
> + *
> + * NOTE: This is used when TSN handles the databuffer. This will not be
> + *	 needed for "shim-hosted" buffers.
> + *
> + * _If_ this function is called when the link is inactive, it will
> + * _enable_ the link (i.e. link will mark the buffer as 'active'). Do
> + * not copy data into the buffer unless you are ready to start sending
> + * frames!
> + *
> + * @link active link
> + * @src	the buffer to copy data from
> + * @bytes bytes to copy
> + * @return bytes copied from link->buffer or negative error
> + */
> +int tsn_buffer_write(struct tsn_link *link, void *src, size_t bytes);
> +
> +
> +/**
> + * tsn_buffer_read - read data from link->buffer and give to shim
> + *
> + * When we act as a listener, this is what the shim (should|will) call
> + * to grab data. It typically grabs much more data than the _net
> + * equivalent. It also do not trigger a refill-event the same way
> + * buffer_read_net does.
> + *
> + * @param link current link that holds the buffer
> + * @param buffer the buffer to copy into, must be at least of size bytes
> + * @param bytes number of bytes.
> + *
> + * Note that this routine does NOT CARE about channels, samplesize etc,
> + * it is a _pure_ copy that handles ringbuffer wraps etc.
> + *
> + * This function have side-effects as it will update internal tsn_link
> + * values.
> + *
> + * @return Bytes copied into link->buffer, negative value upon error.
> + */
> +int tsn_buffer_read(struct tsn_link *link, void *buffer, size_t bytes);
> +
> +/**
> + * tsn_lb_enable - TSN Link Buffer Enable
> + *
> + * Mark the link as "buffer-enabled" which will let the core start
> + * shifting data in/out of the buffer instead of ignoring incoming
> + * frames or sending "nullframes".
> + *
> + * This is for the network-end of the tsn-buffer, i.e.
> + * - when enabled frames *from* the network will be inserted into the buffer,
> + * - or frames going *out* will include data from the buffer instead of sending
> + *   null-frames.
> + *
> + * When disabled, data will be zero'd, e.g Tx will send NULL-frames and
> + * Rx will silently drop the frames.
> + *
> + * @link: active link
> + */
> +static inline void tsn_lb_enable(struct tsn_link *link)
> +{
> +	if (link)
> +		atomic_set(&link->buffer_active, 1);
> +}
> +
> +/**
> + * tsn_lb_disable - stop using the buffer for the net-side of TSN
> + *
> + * When we close a stream, we do not necessarily tear down the link, and
> + * we need to handle the data in some way.
> + */
> +static inline void tsn_lb_disable(struct tsn_link *link)
> +{
> +	if (link)
> +		atomic_set(&link->buffer_active, 0);
> +}
> +
> +/**
> + * tsn_lb() - query if we have disabled pushing of data to/from link-buffer
> + *
> + * @param struct tsn_link *link - active link
> + * @returns 1 if link is enabled
> + */
> +static inline int tsn_lb(struct tsn_link *link)
> +{
> +	if (link)
> +		return atomic_read(&link->buffer_active);
> +
> +	/* if link is NULL; buffer not active */
> +	return 0;
> +}
> +
> +
> +/**
> + * Shim ops - what tsn_core use when calling back into the shim. All ops
> + * must be reentrant.
> + */
> +#define SHIM_NAME_SIZE 32
> +struct tsn_shim_ops {
> +
> +	/* internal linked list used by tsn_core to keep track of all
> +	 * shims.
> +	 */
> +	struct list_head head;
> +
> +	/**
> +	 * name - a unique name identifying this shim
> +	 *
> +	 * This is what userspace use to indicate to core what SHIM a
> +	 * particular link will use. If the name is already present,
> +	 * core will reject this name.
> +	 */
> +	char shim_name[SHIM_NAME_SIZE];
> +
> +	/**
> +	 * probe - callback when a new link of this type is instantiated.
> +	 *
> +	 * When a new link is brought online, this is called once the
> +	 * essential parts of tsn_core has finiesh. Once probe_cb has
> +	 * finisehd, the shim _must_ be ready to accept data to/from
> +	 * tsn_core. On the other hand, due to the final steps of setup,
> +	 * it cannot expect to be called into action immediately after
> +	 * probe has finished.
> +	 *
> +	 * In other words, shim must be ready, but core doesn't have to
> +	 *
> +	 * @param : a particular link to pass along to the probe-function.
> +	 */
> +	int (*probe)(struct tsn_link *link);
> +
> +	/**
> +	 * buffer_swap - set a new buffer for the link. [OPTIONAL]
> +	 *
> +	 * Used when external buffering is enabled.
> +	 *
> +	 * When called, a new buffer must be returned WITHOUT blocking
> +	 * as this will be called from interrupt context.
> +	 *
> +	 * The buffer returned from the shim must be at least the size
> +	 * of used_buffer_size.
> +	 *
> +	 * @param current link
> +	 * @param old_buffer the buffer that are no longer needed
> +	 * @param used number of bytes in buffer that has been filled with data.
> +	 * @return new buffer to use
> +	 */
> +	void * (*buffer_swap)(struct tsn_link *link, void *old_buffer,
> +			      size_t used);
> +
> +	/**
> +	 * buffer_refill - signal shim that more data is required
> +	 * @link Active link
> +	 *
> +	 * This function should not do anything that can preempt the
> +	 * task (kmalloc, sleeping lock) or invoke actions that can take
> +	 * a long time to complete.
> +	 *
> +	 * This will be called from tsn_buffer_read_net() when available
> +	 * data in the buffer drops below low_water_mark. It will be
> +	 * called with the link-lock *held*
> +	 */
> +	size_t (*buffer_refill)(struct tsn_link *link);
> +
> +	/**
> +	 * buffer_drain - shim need to copy data from buffer
> +	 *
> +	 * This will be called from tsn_buffer_write_net() when data in
> +	 * the buffer exceeds high_water_mark.
> +	 *
> +	 * The expected behavior is for the shim to then fill data into
> +	 * the buffer via tsn_buffer_write()
> +	 */
> +	size_t (*buffer_drain)(struct tsn_link *link);
> +
> +	/**
> +	 * media_close - shut down media controller properly
> +	 *
> +	 * when the link is closed/removed for some reason
> +	 * external to the media controller (ALSA soundcard, v4l2 driver
> +	 * etc), we call this to clean up.
> +	 *
> +	 * Normal operation is stopped before media_close is called, but
> +	 * all references should be valid. TSN core expects media_close
> +	 * to handle any local cleanup, once returned, any references in
> +	 * stale tsn_links cannot be trusted.
> +	 *
> +	 * @link: current link where data is stored
> +	 * @returns: 0 upon success, negative on error.
> +	 */
> +	int (*media_close)(struct tsn_link *link);
> +
> +	/**
> +	 * hdr_size - ask shim how large the header is
> +	 *
> +	 * Needed when reserving space in skb for transmitting data.
> +	 *
> +	 * @link: current link where data is stored
> +	 * @return: size of header for this shim
> +	 */
> +	size_t (*hdr_size)(struct tsn_link *link);
> +
> +	/**
> +	 * copy_size - ask client how much from the buffer to include in
> +	 *	       the next frame.
> +	 *
> +	 *	       This is for *outgoing* frames, incoming frames
> +	 *	       have 'sd_len' set in the header.
> +	 *
> +	 *	       Note: copy_size should not return a size larger
> +	 *		     than link->max_payload_size
> +	 */
> +	size_t (*copy_size)(struct tsn_link *link);
> +
> +	/**
> +	 * validate_header - let the shim validate subtype-header
> +	 *
> +	 * Both psh and data may (or may not) contain headers that need
> +	 * validating. This is the responsibility of the shim to
> +	 * validate, and ops->valdiate_header() will be called before
> +	 * any data is copied from the incoming frame and into the
> +	 * buffer.
> +	 *
> +	 * Important: tsn_core expects validate_header to _not_ alter
> +	 * the contents of the frame, and ideally, validate_header could
> +	 * be called multiple times and give the same result.
> +	 *
> +	 * @param: active link owning the new data
> +	 * @param: start of data-unit header
> +	 *
> +	 * This function will be called from interrupt-context and MUST
> +	 * NOT take any locks.
> +	 */
> +	int (*validate_header)(struct tsn_link *link,
> +			       struct avtpdu_header *header);
> +
> +	/**
> +	 * assemble_header - add shim-specific headers
> +	 *
> +	 * This adds the headers required by the current shim after the
> +	 * generic 1722-header.
> +	 *
> +	 * @param: active link
> +	 * @param: start of data-unit header
> +	 * @param: size of data to send in this frame
> +	 * @return void
> +	 */
> +	void (*assemble_header)(struct tsn_link *link,
> +				struct avtpdu_header *header, size_t bytes);
> +
> +	/**
> +	 * get_payload_data - get a pointer to where the data is stored
> +	 *
> +	 * core will use the pointer (or drop it if NULL is returned)
> +	 * and copy header->sd_len bytes of *consecutive* data from the
> +	 * target memory and into the buffer memory.
> +	 *
> +	 * This is called with relevant locks held, from interrupt context.
> +	 *
> +	 * @param link active link
> +	 * @param header header of frame, which contains data
> +	 * @returns pointer to memory to copy from
> +	 */
> +	void * (*get_payload_data)(struct tsn_link *link,
> +				   struct avtpdu_header *header);
> +};
> +/**
> + * tsn_shim_register_ops - register shim-callbacks for a given shim
> + *
> + * @param shim_ops - callbacks. The ops-struct should be kept intact for
> + *		     as long as the driver is running.
> + *
> + *
> + */
> +int tsn_shim_register_ops(struct tsn_shim_ops *shim_ops);
> +
> +/**
> + * tsn_shim_deregister_ops - remove callback for module
> + *
> + * Completely remove shim_ops. This will close any links currently using
> + * this shim. Note: the links will be closed, but _not_ removed.
> + *
> + * @param shim_ops ops associated with this shim
> + */
> +void tsn_shim_deregister_ops(struct tsn_shim_ops *shim_ops);
> +
> +/**
> + * tsn_shim_get_active : return the name of the currently loaded shim
> + *
> + * @param current link
> + * @return name of shim (matches an entry from exported triggers)
> + */
> +char *tsn_shim_get_active(struct tsn_link *link);
> +
> +/**
> + * tsn_shim_find_by_name find shim_ops by name
> + *
> + * @param name of shim
> + * @return shim or NULL if not found/error.
> + */
> +struct tsn_shim_ops *tsn_shim_find_by_name(const char *name);
> +
> +/**
> + * tsn_shim_export_probe_triggers - export a list of registered shims
> + *
> + * @param page to write content into
> + * @returns length of data written to page
> + */
> +ssize_t tsn_shim_export_probe_triggers(char *page);
> +
> +/**
> + * tsn_get_framesize - get the size of the next TSN frame to send
> + *
> + * This will call into the shim to get the next chunk of data to
> + * read. Some sanitychecking is performed, i.e.
> + *
> + * 0 <= size <= max_payload_size
> + *
> + * @param struct tsn_link *link active link
> + * @returns size of frame in bytes or negative on error.
> + */
> +static inline size_t tsn_shim_get_framesize(struct tsn_link *link)
> +{
> +	size_t ret;
> +
> +	ret = link->ops->copy_size(link);
> +	if (ret <= link->max_payload_size)
> +		return ret;
> +	return link->max_payload_size;
> +}
> +
> +/**
> + * tsn_get_hdr_size - get the size of the shim-specific header size
> + *
> + * The shim will add it's own header to the frame.
> + */
> +static inline size_t tsn_shim_get_hdr_size(struct tsn_link *link)
> +{
> +	size_t ret;
> +
> +	if (!link || !link->ops->hdr_size)
> +		return -EINVAL;
> +	ret = link->ops->hdr_size(link);
> +	if (ret > link->max_payload_size)
> +		return -EINVAL;
> +	return ret;
> +}
> +
> +#endif	/* _TSN_H */
> -- 
> 2.7.4
> 

-- 
Henrik Austad

[very-RFC 2/8] TSN: Add the standard formerly known as AVB to the kernel

[Henrik Austad]

TSN provides a mechanism to create reliable, jitter-free, low latency
guaranteed bandwidth links over a local network. It does this by
reserving a path through the network. Support for TSN must be found in
both the NIC as well as in the network itself.

This adds required hooks into netdev_ops so that the core TSN driver can
use this when configuring a new NIC or setting up a new link.

Cc: "David S. Miller" <davem@davemloft.net>
Signed-off-by: Henrik Austad <henrik@austad.us>
---
 include/linux/netdevice.h | 32 ++++++++++++++++++++++++++++++++
 net/Kconfig               |  1 +
 net/tsn/Kconfig           | 32 ++++++++++++++++++++++++++++++++
 3 files changed, 65 insertions(+)
 create mode 100644 net/tsn/Kconfig

diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index f45929c..de025eb 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -109,6 +109,13 @@ enum netdev_tx {
 };
 typedef enum netdev_tx netdev_tx_t;
 
+#if IS_ENABLED(CONFIG_TSN)
+enum sr_class {
+	SR_CLASS_A = 1,
+	SR_CLASS_B = 2,
+};
+#endif
+
 /*
  * Current order: NETDEV_TX_MASK > NET_XMIT_MASK >= 0 is significant;
  * hard_start_xmit() return < NET_XMIT_MASK means skb was consumed.
@@ -902,6 +909,22 @@ struct tc_to_netdev {
  *
  * void (*ndo_poll_controller)(struct net_device *dev);
  *
+ *	TSN functions (if CONFIG_TSN)
+ *
+ * int (*ndo_tsn_capable)(struct net_device *dev);
+ *	If a particular device is capable of sustaining TSN traffic
+ *	provided current configuration
+ * int (*ndo_tsn_link_configure)(struct net_device *dev,
+ *				 enum sr_class class,
+ *				 u16 framesize,
+ *				 u16 vid);
+ *     - When a new TSN link is either added or removed, this is called to
+ *       update the bandwidth for the particular stream-class
+ *     - The framesize is the size of the _entire_ frame, not just the
+ *       payload since the full size is required to allocate bandwidth through
+ *       the credit based shaper in the NIC
+ *     - the vlan_id is the configured vlan for TSN in this session.
+ *
  *	SR-IOV management functions.
  * int (*ndo_set_vf_mac)(struct net_device *dev, int vf, u8* mac);
  * int (*ndo_set_vf_vlan)(struct net_device *dev, int vf, u16 vlan, u8 qos);
@@ -1148,6 +1171,15 @@ struct net_device_ops {
 #ifdef CONFIG_NET_RX_BUSY_POLL
 	int			(*ndo_busy_poll)(struct napi_struct *dev);
 #endif
+
+#if IS_ENABLED(CONFIG_TSN)
+	int			(*ndo_tsn_capable)(struct net_device *dev);
+	int			(*ndo_tsn_link_configure)(struct net_device *dev,
+							  enum sr_class class,
+							  u16 framesize,
+							  u16 vid);
+#endif	/* CONFIG_TSN */
+
 	int			(*ndo_set_vf_mac)(struct net_device *dev,
 						  int queue, u8 *mac);
 	int			(*ndo_set_vf_vlan)(struct net_device *dev,
diff --git a/net/Kconfig b/net/Kconfig
index ff40562..fa9f691 100644
--- a/net/Kconfig
+++ b/net/Kconfig
@@ -215,6 +215,7 @@ source "net/802/Kconfig"
 source "net/bridge/Kconfig"
 source "net/dsa/Kconfig"
 source "net/8021q/Kconfig"
+source "net/tsn/Kconfig"
 source "net/decnet/Kconfig"
 source "net/llc/Kconfig"
 source "net/ipx/Kconfig"
diff --git a/net/tsn/Kconfig b/net/tsn/Kconfig
new file mode 100644
index 0000000..1fc3c1d
--- /dev/null
+++ b/net/tsn/Kconfig
@@ -0,0 +1,32 @@
+#
+# Configuration for 802.1 Time Sensitive Networking (TSN)
+#
+
+config TSN
+	tristate "802.1 TSN Support"
+	depends on VLAN_8021Q && PTP_1588_CLOCK && CONFIGFS_FS
+	---help---
+	  Select this if you want to enable TSN on capable interfaces.
+
+	  TSN allows you to set up deterministic links on your LAN (only
+	  L2 is currently supported). Once loaded, the driver will probe
+	  all available interfaces if they are capable of supporting TSN
+	  links.
+
+	  Once loaded, a directory in configfs called tsn/ will expose
+	  the capable NICs and allow userspace to create
+	  links. Userspace must provide us with a StreamID as well as
+	  reserving bandwidth through the network and once this is done,
+	  a new link can be created by issuing a mkdir() in configfs and
+	  updating the attributes for the new link.
+
+	  TSN itself does not produce nor consume data, it is dependent
+	  upon 'shims' doing this, which can be virtually anything. ALSA
+	  is a good candidate.
+
+	  For more information, refer to the TSN-documentation in the
+	  kernel documentation repository.
+
+	  The resulting module will be called 'tsn'
+
+	  If unsure, say N.
-- 
2.7.4