From: Henrik Austad haustad@cisco.com

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 -- To unsubscribe from this list: send the line "unsubscribe alsa-devel" in

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

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; +}

From: Henrik Austad haustad@cisco.com

This exposes a *very* rudimentary and simplistic ALSA driver that hooks into TSN to create a device for userspace.

It currently only supports 44.1/48kHz sampling, 2ch, S16_LE

Userspace is supposed to reserve bandwidth, find StreamID etc.

To use as a Talker:

mkdir /config/tsn/test/eth0/talker cd /config/tsn/test/eth0/talker echo 65535 > buffer_size echo 08:00:27:08:9f:c3 > remote_mac echo 42 > stream_id echo alsa > enabled

aplay -Ddefault:CARD=avb -c2 -r48000 -fS16_LE /opt/rickroll.wav

The same applies to Listener and arecord.

Cc: Mauro Carvalho Chehab mchehab@osg.samsung.com Cc: Takashi Iwai tiwai@suse.de Cc: Mark Brown broonie@kernel.org Signed-off-by: Henrik Austad haustad@cisco.com --- 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 +++++++ 5 files changed, 888 insertions(+), 1 deletion(-) 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

diff --git a/drivers/media/Kconfig b/drivers/media/Kconfig index a8518fb..14ad1d9 100644 --- a/drivers/media/Kconfig +++ b/drivers/media/Kconfig @@ -217,3 +217,18 @@ source "drivers/media/tuners/Kconfig" source "drivers/media/dvb-frontends/Kconfig"

endif # MEDIA_SUPPORT + +config MEDIA_AVB_ALSA + tristate "ALSA part of AVB over TSN" + depends on TSN + help + + Enable the ALSA device that hoooks into TSN and allows the + computer to send ethernet frames over the network carrying + audio-data to selected hosts. + + This must be configured by userspace as MSRP and IEEE 1722.1 + (discovery and enumeration) is not implemented within the + kernel. + + If unsure, say N \ No newline at end of file diff --git a/drivers/media/Makefile b/drivers/media/Makefile index e608bbc..a1ca09e 100644 --- a/drivers/media/Makefile +++ b/drivers/media/Makefile @@ -20,6 +20,7 @@ endif

obj-$(CONFIG_VIDEO_DEV) += v4l2-core/ obj-$(CONFIG_DVB_CORE) += dvb-core/ +obj-$(CONFIG_AVB) += avb/

# There are both core and drivers at RC subtree - merge before drivers obj-y += rc/ @@ -30,4 +31,4 @@ obj-y += rc/

obj-y += common/ platform/ pci/ usb/ mmc/ firewire/ obj-$(CONFIG_VIDEO_DEV) += radio/ - +obj-$(CONFIG_MEDIA_AVB_ALSA) += avb/ diff --git a/drivers/media/avb/Makefile b/drivers/media/avb/Makefile new file mode 100644 index 0000000..5d6302c --- /dev/null +++ b/drivers/media/avb/Makefile @@ -0,0 +1,5 @@ +# +# Makefile for the ALSA shim in AVB/TSN +# + +obj-$(CONFIG_MEDIA_AVB_ALSA) += avb_alsa.o diff --git a/drivers/media/avb/avb_alsa.c b/drivers/media/avb/avb_alsa.c new file mode 100644 index 0000000..9aff7d3 --- /dev/null +++ b/drivers/media/avb/avb_alsa.c @@ -0,0 +1,742 @@ +/* Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights + * reserved. + * + * This program is free software; you may redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; version 2 of the License. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ +#include <linux/platform_device.h> +#include <sound/pcm_params.h> +#include <linux/module.h> +#include <linux/slab.h> +#include <sound/core.h> +#include <sound/pcm.h> + +#include <linux/tsn.h> +#include "tsn_iec61883.h" + +struct avb_chip { + struct snd_card *card; + struct tsn_link *link; + struct snd_pcm *pcm; + struct snd_pcm_substream *substream; + + /* Need a reference to this when we unregister the platform + * driver. + */ + struct platform_device *device; + + /* on first copy, we set a few values, use this to make sure we + * only do this once. + */ + u8 first_copy; + + u8 sample_size; + u8 channels; + + /* current idx in 10ms set of frames + * class A: 80 + * class B: 40 + * + * This is mostly relevant for 44.1kHz samplefreq + */ + u8 num_10ms_series; + + u32 sample_freq; +}; + +/* currently, only playback is implemented in TSN layer + * + + * FIXMEs: (should be set according to the active TSN link) + * - format + * - rates + * - channels + */ +static struct snd_pcm_hardware snd_avb_hw = { + .info = SNDRV_PCM_INFO_INTERLEAVED, + .formats = SNDRV_PCM_FMTBIT_S16_LE, + .rates = SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000, + .rate_min = 44100, + .rate_max = 48000, + .channels_min = 2, + .channels_max = 2, + .period_bytes_min = 4096, + .period_bytes_max = 32768, + .buffer_bytes_max = 32768, + .periods_min = 1, + .periods_max = 1024, + .fifo_size = 0, +}; + +static size_t snd_avb_copy_size(struct tsn_link *link); + + +static int _set_chip_values(struct avb_chip *avb_chip, + struct snd_pcm_runtime *runtime) +{ + if (!avb_chip->first_copy) + return 0; + + + /* + * first copy, we now know that runtime has all the correct + * values set, we can grab channels and rate. Sample_size + * (runtime->format) is currently hard-coded to S16_LE. + */ + avb_chip->channels = runtime->channels; + avb_chip->sample_freq = runtime->rate; + avb_chip->sample_size = 16; + + if (snd_avb_copy_size(avb_chip->link) > avb_chip->link->max_payload_size) { + pr_err("%s: Resulting payload-size is larger (%zd) than available (%u)\n", + __func__, snd_avb_copy_size(avb_chip->link), + avb_chip->link->max_payload_size); + return -EINVAL; + } + avb_chip->first_copy = 0; + return 0; +} + +static int _snd_avb_open(struct avb_chip *avb_chip, + struct snd_pcm_runtime *runtime) +{ + /* + * We do not know what some of these values are until we see the + * first copy. We set to sane defaults where we don't have exact + * content. + */ + avb_chip->channels = 0; + avb_chip->sample_size = 0; + avb_chip->sample_freq = 0; + avb_chip->num_10ms_series = 0; + avb_chip->first_copy = 1; + + runtime->hw = snd_avb_hw; + runtime->buffer_size = avb_chip->link->buffer_size; + return 0; +} + +/* + * bytes_to_frames() + * frames_to_bytes() + * + * frames_to_bytes(runtime, runtrime->period_size); + * + * Interrupt callbacks: + * The field traonsfer_ack_begin and transfer_ack_end are called at the + * beginning and at the end of snd_pcm_period_elapsed(), respectively. + */ +static int snd_avb_playback_open(struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct avb_chip *avb_chip = snd_pcm_substream_chip(substream); + int ret = 0; + + /* + * we've opened the PCM before probe returned properly and + * stored link in the struct. + */ + if (!avb_chip || !avb_chip->link) { + pr_err("%s: Chip-data or link not available, cannot continue\n", + __func__); + return -EINVAL; + } + if (!avb_chip->link->estype_talker) { + pr_info("Link (%llu) not registered as Talker, cannot do playback\n", + avb_chip->link->stream_id); + return -EINVAL; + } + + ret = _snd_avb_open(avb_chip, runtime); + if (ret < 0) { + pr_err("%s: Could not open playback-device (requested %d ch, %zd buffer)", + __func__, avb_chip->channels, + avb_chip->link->buffer_size); + return ret; + } + pr_info("%s: %d channel PCM stream opened successfully, buffersize: %zd\n", + __func__, avb_chip->channels, avb_chip->link->buffer_size); + return 0; +} + +static int snd_avb_playback_close(struct snd_pcm_substream *substream) +{ + struct avb_chip *avb_chip = snd_pcm_substream_chip(substream); + + tsn_lb_disable(avb_chip->link); + + pr_info("%s: something happened\n", __func__); + return 0; +} + +/* + * snd_avb snd_avb.0: BUG: , + * pos = 12288, + * buffer size = 8192, + * period size = 2048 + * + * Playback is when we *send* data to a remote speaker + */ +static int snd_avb_playback_copy(struct snd_pcm_substream *substream, + int channel, + snd_pcm_uframes_t pos, + void *src, + snd_pcm_uframes_t count) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct avb_chip *avb_chip = snd_pcm_substream_chip(substream); + size_t bytes; + int ret; + + /* + * From alsadoc: + * + * You need to check the channel argument, and if it's -1, copy + * the whole channels. Otherwise, you have to copy only the + * specified channel. Please check isa/gus/gus_pcm.c as an + * example. + */ + if (channel != -1) { + pr_err("%s: partial copy not supportet\n", __func__); + return -EINVAL; + } + + ret = _set_chip_values(avb_chip, runtime); + if (ret != 0) + return ret; + + bytes = frames_to_bytes(runtime, count); + ret = tsn_buffer_write(avb_chip->link, src, bytes); + if (ret != bytes) { + pr_err("%s: Incorrect copy (%zd, %d) corruption possible\n", + __func__, bytes, ret); + return -EIO; + } + return 0; +} + +static int snd_avb_capture_open(struct snd_pcm_substream *substream) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct avb_chip *avb_chip = snd_pcm_substream_chip(substream); + int ret = 0; + + if (!avb_chip || !avb_chip->link) { + pr_err("%s: Chip-data or link not available, cannot continue\n", + __func__); + return -EINVAL; + } + if (avb_chip->link->estype_talker) { + pr_info("Link (%llu) registered as Talker, cannot capture\n", + avb_chip->link->stream_id); + return -EINVAL; + } + ret = _snd_avb_open(avb_chip, runtime); + if (ret < 0) { + pr_err("%s: Could not open capture-device (requested %d ch, %zd buffer)", + __func__, avb_chip->channels, + avb_chip->link->buffer_size); + return ret; + } + tsn_lb_enable(avb_chip->link); + pr_info("%s: %d channel PCM stream opened successfully, buffersize: %zd\n", + __func__, avb_chip->channels, avb_chip->link->buffer_size); + return 0; +} + +static int snd_avb_capture_close(struct snd_pcm_substream *substream) +{ + struct avb_chip *avb_chip = snd_pcm_substream_chip(substream); + + if (!avb_chip || !avb_chip->link) + return -EINVAL; + pr_err("%s: closing stream\n", __func__); + + tsn_lb_disable(avb_chip->link); + + return 0; +} + +static int snd_avb_capture_copy(struct snd_pcm_substream *substream, + int channel, + snd_pcm_uframes_t pos, + void *src, + snd_pcm_uframes_t count) +{ + struct snd_pcm_runtime *runtime = substream->runtime; + struct avb_chip *avb_chip = snd_pcm_substream_chip(substream); + size_t bytes; + int ret; + + bytes = frames_to_bytes(runtime, count); + ret = tsn_buffer_read(avb_chip->link, src, bytes); + if (ret != bytes) { + pr_err("%s: incorrect copy (%zd, %d), corrupt capture possible\n", + __func__, bytes, ret); + tsn_lb_disable(avb_chip->link); + return -EIO; + } + return 0; +} + +static int snd_avb_silence(struct snd_pcm_substream *substream, + int channel, snd_pcm_uframes_t pos, + snd_pcm_uframes_t count) +{ + /* FIXME, should do more than nothing */ + return 0; +} + +/* + * Called when the client defines buffer_size, period_size, format etc + * for the pcm substream. + * + * This is where link->buffer is allocated and link->buffer_size is + * defined. + * + * We are called in the beginning of snd_pcm_hw_params in + * sound/core/pcm_native.c, we cannot override runtime-values as they + * are updated from hw_params. + */ +static int snd_avb_pcm_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *hw_params) +{ + struct avb_chip *avb_chip = snd_pcm_substream_chip(substream); + unsigned int bsize = params_buffer_bytes(hw_params); + int ret = 0; + + /* We need this reference for the refill callback so that we can + * call snd_pcm_period_elapsed(); + */ + avb_chip->substream = substream; + ret = tsn_set_buffer_size(avb_chip->link, bsize); + if (ret < 0) { + pr_err("%s: could not set buffer_size (alsa requested too large? (%d)\n", + __func__, ret); + goto out; + } + + avb_chip->num_10ms_series = 0; + pr_info("%s: successfully set hw-params\n", __func__); +out: + return ret; +} + +static int snd_avb_pcm_hw_free(struct snd_pcm_substream *substream) +{ + struct avb_chip *avb_chip = snd_pcm_substream_chip(substream); + + if (!avb_chip || !avb_chip->link) + return -EINVAL; + tsn_clear_buffer_size(avb_chip->link); + pr_info("%s: something happened\n", __func__); + avb_chip->substream = NULL; + return 0; +} + +static int snd_avb_pcm_prepare(struct snd_pcm_substream *substream) +{ + /* verify that samplerate, freq and size is what we have set in + * the link. + */ + + return 0; +} + +/* + * When the PCM stream is started, stopped, paused etc. + * + * Atomic function (some lock is being held by PCM layer) + */ +static int snd_avb_pcm_trigger(struct snd_pcm_substream *substream, + int cmd) +{ + struct avb_chip *avb_chip = snd_pcm_substream_chip(substream); + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + case SNDRV_PCM_TRIGGER_RESUME: + /* pr_err("%s: starting for some reason\n", __func__); */ + tsn_lb_enable(avb_chip->link); + break; + case SNDRV_PCM_TRIGGER_STOP: + case SNDRV_PCM_TRIGGER_SUSPEND: + /* memset buffer to 0 */ + /* pr_err("%s: stopping for some reason\n", __func__); */ + tsn_lb_disable(avb_chip->link); + break; + default: + pr_info("%s: cmd: %d (return -EINVAL)\n", __func__, cmd); + return -EINVAL; + } + return 0; +} + +/* + * current hw-position in the buffer, in frames from 0 to buffer_size -1 + * + * Need to know where the hw-pointer is and how this corresponds to the + * underlying TSN-buffer setup + * + * Atomic function (some lock is being held by PCM layer) + * + */ +static snd_pcm_uframes_t snd_avb_pcm_pointer(struct snd_pcm_substream *substream) +{ + struct avb_chip *avb_chip = snd_pcm_substream_chip(substream); + struct tsn_link *link = avb_chip->link; + snd_pcm_uframes_t pointer; + + if (link->estype_talker) + pointer = bytes_to_frames(substream->runtime, + link->tail - link->buffer); + else + pointer = bytes_to_frames(substream->runtime, + link->head - link->buffer); + return pointer; +} + +static struct snd_pcm_ops snd_avb_playback_ops = { + .open = snd_avb_playback_open, + .close = snd_avb_playback_close, + .copy = snd_avb_playback_copy, + .silence = snd_avb_silence, + .ioctl = snd_pcm_lib_ioctl, + .hw_params = snd_avb_pcm_hw_params, + .hw_free = snd_avb_pcm_hw_free, + .prepare = snd_avb_pcm_prepare, + .trigger = snd_avb_pcm_trigger, + .pointer = snd_avb_pcm_pointer, +}; + +static struct snd_pcm_ops snd_avb_capture_ops = { + .open = snd_avb_capture_open, + .close = snd_avb_capture_close, + .copy = snd_avb_capture_copy, + .silence = snd_avb_silence, + .ioctl = snd_pcm_lib_ioctl, + .hw_params = snd_avb_pcm_hw_params, + .hw_free = snd_avb_pcm_hw_free, + .prepare = snd_avb_pcm_prepare, + .trigger = snd_avb_pcm_trigger, + .pointer = snd_avb_pcm_pointer, +}; + +/* + * Callback for tsn_core for moving data into the buffer. + * + * This should be a wrapper (replace it with) the refill-functionality ALSA use. + */ +static size_t snd_avb_refill(struct tsn_link *link) +{ + struct avb_chip *avb_chip = link->media_chip; + + if (avb_chip && avb_chip->substream) { + snd_pcm_period_elapsed(avb_chip->substream); + return 0; + } + return -EINVAL; +} + +static size_t snd_avb_drain(struct tsn_link *link) +{ + struct avb_chip *avb_chip = link->media_chip; + + if (avb_chip && avb_chip->substream) { + snd_pcm_period_elapsed(avb_chip->substream); + return 0; + } + return -EINVAL; +} + +static size_t snd_avb_hdr_size(struct tsn_link *link) +{ + /* return the size of the iec61883-6 audio header */ + return _iec61883_hdr_len(); +} + +static size_t snd_avb_copy_size(struct tsn_link *link) +{ + struct avb_chip *chip = link->media_chip; + /* use values in avb_chip, not link */ + size_t framesize = (chip->sample_size >> 3) * chip->channels; + size_t numframes = 0; + + if (!chip->sample_freq) + return link->max_payload_size; + + /* size of each frame (samples per frame, sample-size && class) + * sample_size: 16 -> 2 + * spframe : 12 (class b) + * channels: 2 + * + * framesize: 2*12*2 -> 48 + */ + + switch (chip->sample_freq) { + case 44100: + /* + * Class B: 40 frames, first 12 bytes, next 39 should be 11 + */ + if (!link->class_a) { + numframes = (chip->num_10ms_series ? 11 : 12); + chip->num_10ms_series++; + if (chip->num_10ms_series > 39) + chip->num_10ms_series = 0; + } else { + /* Class A slightly more involved + * Need 41 6 bytes and 39 5 bytes + * + * If 0th is set to 6, remaining odd idx should + * be 6, even (except 0th) to be 6 + */ + numframes = 5; + if (!chip->num_10ms_series || + (chip->num_10ms_series % 0x2)) + numframes++; + chip->num_10ms_series++; + if (chip->num_10ms_series > 79) + chip->num_10ms_series = 0; + } + break; + case 48000: + numframes = (link->class_a ? 6 : 12); + break; + default: + pr_err("Unsupported sample_freq (%d), disabling link\n", + chip->sample_freq); + tsn_lb_disable(link); + return -EINVAL; + } + return numframes * framesize; +} + +static void snd_avb_assemble_iidc(struct tsn_link *link, + struct avtpdu_header *header, size_t bytes) +{ + _iec61883_hdr_assemble(header, bytes); +} + +static int snd_avb_validate_iidc(struct tsn_link *link, + struct avtpdu_header *header) +{ + return _iec61883_hdr_verify(header); +} + +static void *snd_avb_get_payload_data(struct tsn_link *link, + struct avtpdu_header *header) +{ + return _iec61883_payload(header); +} + +static int snd_avb_new_pcm(struct avb_chip *avb_chip, int device) +{ + struct snd_pcm *pcm; + int err; + + err = snd_pcm_new(avb_chip->card, "AVB PCM", device, 1, 1, &pcm); + if (err < 0) + return err; + pcm->private_data = avb_chip; + strcpy(pcm->name, "AVB PCM"); + avb_chip->pcm = pcm; + + /* only playback at the moment, once we implement capture, we + * need to grab the Talker/Listener from TSN link + */ + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &snd_avb_playback_ops); + snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_avb_capture_ops); + + return 0; + +} +static int snd_avb_probe(struct platform_device *devptr) +{ + int err; + struct snd_card *card; + struct avb_chip *avb_chip; + + pr_info("%s: starting\n", __func__); + + /* + * older kernel use snd_card_create. This is handled by + * tsn_compat.h in an attempt to make it easier to backport to + * older kernels. + */ + err = snd_card_new(&devptr->dev, 1, "avb", THIS_MODULE, + sizeof(struct avb_chip), &card); + if (err < 0) { + pr_err("%s: trouble creating new card -> %d\n", + __func__, err); + return err; + } + avb_chip = card->private_data; + avb_chip->card = card; + + + /* create PCM device*/ + err = snd_avb_new_pcm(avb_chip, 0); + if (err < 0) { + pr_err("%s: could not create new PCM device\n", __func__); + goto err_out; + } + + /* register card */ + pr_info("%s: ready to register card\n", __func__); + strcpy(card->driver, "Avb"); + strcpy(card->shortname, "Avb"); + sprintf(card->longname, "Avb %i", devptr->id + 1); + err = snd_card_register(card); + if (err < 0) { + pr_err("%s: Could not register card -> %d\n", + __func__, err); + snd_card_free(card); + return err; + } + + if (err == 0) { + platform_set_drvdata(devptr, card); + pr_info("%s: Successfully initialized %s\n", + __func__, card->shortname); + return 0; + } +err_out: + snd_card_free(card); + return err; +} + +/* + * We are here as a result from being removed via + * tsn_link->shim_ops->media_close, which is snd_avb_close() + */ +static int snd_avb_remove(struct platform_device *devptr) +{ + struct snd_card *card = platform_get_drvdata(devptr); + struct avb_chip *avb_chip = card->private_data; + + /* Make sure link holds no ref to this now dead card */ + if (avb_chip && avb_chip->link) { + avb_chip->link->media_chip = NULL; + avb_chip->link = NULL; + } + + /* call into link->ops->media_close() ? */ + snd_card_free(card); + return 0; +} + +static struct platform_driver snd_avb_driver = { + .probe = snd_avb_probe, + .remove = snd_avb_remove, + .driver = { + .name = "snd_avb", + .pm = NULL, /* don't care about Power Management */ + }, +}; + +static int snd_avb_close(struct tsn_link *link) +{ + struct avb_chip *avb_chip = link->media_chip; + + if (!link->media_chip) + return 0; + + pr_info("%s: Removing device\n", __func__); + + platform_device_unregister(avb_chip->device); + /* platform unregister will call into snd_avb_remove */ + platform_driver_unregister(&snd_avb_driver); + + /* update link to remove pointer to now invalid memory */ + link->media_chip = NULL; + return 0; +} + +static int snd_avb_new(struct tsn_link *link) +{ + struct avb_chip *avb_chip; + struct snd_card *card; + struct platform_device *device; + int err; + + err = platform_driver_register(&snd_avb_driver); + if (err < 0) { + pr_info("%s: trouble registering driver %d, unreg. partial driver and abort.\n", + __func__, err); + return err; + } + + /* + * We only register a single card for now, look to + * /sys/devices/platform/snd_avb.0 for content. + * + * Probe will be triggered if name is same as .name in platform_driver + */ + device = platform_device_register_simple("snd_avb", 0, NULL, 0); + if (IS_ERR(device)) { + pr_info("%s: ERROR registering simple platform-device\n", + __func__); + platform_driver_unregister(&snd_avb_driver); + return -ENODEV; + } + + /* store data in driver so we can access it in .probe */ + card = platform_get_drvdata(device); + if (card == NULL) { + pr_info("%s: Did not get anything from platform_get_drvdata()\n", + __func__); + platform_device_unregister(device); + return -ENODEV; + } + avb_chip = card->private_data; + avb_chip->device = device; + avb_chip->link = link; + + link->media_chip = avb_chip; + + return 0; +} + +static struct tsn_shim_ops shim_ops = { + .shim_name = "alsa", + .probe = snd_avb_new, + .buffer_refill = snd_avb_refill, + .buffer_drain = snd_avb_drain, + .media_close = snd_avb_close, + .hdr_size = snd_avb_hdr_size, + .copy_size = snd_avb_copy_size, + .assemble_header = snd_avb_assemble_iidc, + .validate_header = snd_avb_validate_iidc, + .get_payload_data = snd_avb_get_payload_data, +}; + +static int __init avb_alsa_init(void) +{ + if (tsn_shim_register_ops(&shim_ops)) { + pr_err("Could not register ALSA-shim with TSN\n"); + return -EINVAL; + } + pr_info("AVB ALSA added OK\n"); + return 0; +} + +static void __exit avb_alsa_exit(void) +{ + tsn_shim_deregister_ops(&shim_ops); +} + +module_init(avb_alsa_init); +module_exit(avb_alsa_exit); +MODULE_AUTHOR("Henrik Austad"); +MODULE_LICENSE("GPL"); +MODULE_DESCRIPTION("TSN ALSA shim driver"); diff --git a/drivers/media/avb/tsn_iec61883.h b/drivers/media/avb/tsn_iec61883.h new file mode 100644 index 0000000..bf26138 --- /dev/null +++ b/drivers/media/avb/tsn_iec61883.h @@ -0,0 +1,124 @@ +#ifndef TSN_IEC61883_H +#define TSN_IEC61883_H +#include <linux/tsn.h> + +/* + * psh: + * tag:2 + * channel:6 + * tcode:4 + * sy:4 + * See IEEE 1722.1 :: 6.2 for details + */ +struct iec61883_tag { + u8 tag:2; + u8 channel:6; + u8 tcode:4; + u8 sy:4; +} __packed; + +struct iec61883_audio_header { + u8 sid:6; + u8 cip_1:2; + + u8 dbs:8; + + u8 rsv:2; /* reserved */ + u8 sph:1; + u8 qpc:3; + u8 fn:2; + + u8 dbc; + + u8 fmt:6; + u8 cip_2:2; + u8 fdf; + u16 syt; + u8 payload[0]; +} __packed; + +static inline size_t _iec61883_hdr_len(void) +{ + return sizeof(struct iec61883_audio_header); +} + +static inline int _iec61883_hdr_verify(struct avtpdu_header *hdr) +{ + struct iec61883_audio_header *dh; + struct iec61883_tag *psh; + + if (hdr->subtype != AVTP_61883_IIDC) + return -EINVAL; + dh = (struct iec61883_audio_header *)&hdr->data; + psh = (struct iec61883_tag *)&hdr->psh; + + /* Verify 61883 header */ + if (psh->tag != 1 || psh->channel != 31 || + psh->tcode != 0xA || psh->sy != 0) + return -EINVAL; + + /* check flags that should be static from frame to frame */ + if (dh->cip_1 != 0 || dh->sid != 0x3f || dh->qpc != 0 || dh->fn != 0 || + dh->sph != 0 || dh->cip_2 != 2) + return -EINVAL; + + if (dh->dbs != ntohs(hdr->sd_len)*2 || dh->dbc != hdr->seqnr) + return -EINVAL; + + return 0; +} + +static inline void _iec61883_hdr_assemble(struct avtpdu_header *hdr, + size_t bytes) +{ + struct iec61883_tag *psh; + struct iec61883_audio_header *dh; + + if (bytes > 0x7f) + pr_warn("%s: hdr->dbs will overflow, malformed frame will be the result\n", + __func__); + + + hdr->subtype = AVTP_61883_IIDC; + + /* IIDC 61883 header */ + psh = (struct iec61883_tag *)&hdr->psh; + psh->tag = 1; + psh->channel = 31; /* 0x1f */ + psh->tcode = 0xA; + psh->sy = 0; + + dh = (struct iec61883_audio_header *)&hdr->data; + dh->cip_1 = 0; + dh->sid = 63; /* 0x3f */ + dh->dbs = (u8)(bytes*2); /* number of quadlets of data in AVTPDU */ + dh->qpc = 0; + dh->fn = 0; + dh->sph = 0; + dh->dbc = hdr->seqnr; + dh->cip_2 = 2; + + /* + * FMT (Format ID): same as specified in iec 61883-1:2003 + * + * For IEC 61883-6, it shall be 0x10 (16) to define Audio and + * Music data + */ + dh->fmt = 0x10; + + /* FIXME: find value + * Could be sampling-freq, but 8 bits give 0 - 65kHz sampling. + */ + dh->fdf = 0; + + dh->syt = 0xFFFF; +} + +static inline void *_iec61883_payload(struct avtpdu_header *hdr) +{ + struct iec61883_audio_header *dh = (struct iec61883_audio_header *)&hdr->data; + /* TODO: add some basic checks before returning payload ? */ + return &dh->payload; +} + +#endif /* TSN_IEC61883_H */

From: Henrik Austad haustad@cisco.com

Not sure how relevant this is other than making a point about maintaining it.

Signed-off-by: Henrik Austad haustad@cisco.com --- MAINTAINERS | 14 ++++++++++++++ 1 file changed, 14 insertions(+)

diff --git a/MAINTAINERS b/MAINTAINERS index ed42cb6..ef5d926 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -11634,6 +11634,20 @@ T: git git://linuxtv.org/anttip/media_tree.git S: Maintained F: drivers/media/tuners/tua9001*

+TSN CORE DRIVER +M: Henrik Austad haustad@cisco.com +L: linux-kernel@vger.kernel.org +S: Supported +F: drivers/net/tsn/ +F: include/linux/tsn.h +F: include/trace/events/tsn.h + +TSN_AVB_DRIVER +M: Henrik Austad haustad@cisco.com +L: alsa-devel@alsa-project.org (moderated for non-subscribers) +S: Supported +F: drivers/media/avb/ + TULIP NETWORK DRIVERS L: netdev@vger.kernel.org L: linux-parisc@vger.kernel.org