cxgb4: time stamping interface for PTP (a4569504) · Commits · e / devices / android_kernel_oneplus_sm7250

drivers/net/ethernet/chelsio/cxgb4/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -4,7 +4,7 @@

		obj-$(CONFIG_CHELSIO_T4) += cxgb4.o

		cxgb4-objs := cxgb4_main.o l2t.o t4_hw.o sge.o clip_tbl.o cxgb4_ethtool.o cxgb4_uld.o sched.o cxgb4_filter.o cxgb4_tc_u32.o
		cxgb4-objs := cxgb4_main.o l2t.o t4_hw.o sge.o clip_tbl.o cxgb4_ethtool.o cxgb4_uld.o sched.o cxgb4_filter.o cxgb4_tc_u32.o cxgb4_ptp.o
		cxgb4-$(CONFIG_CHELSIO_T4_DCB) += cxgb4_dcb.o
		cxgb4-$(CONFIG_CHELSIO_T4_FCOE) += cxgb4_fcoe.o
		cxgb4-$(CONFIG_DEBUG_FS) += cxgb4_debugfs.o

drivers/net/ethernet/chelsio/cxgb4/cxgb4.h

+9 −0

Original line number	Diff line number	Diff line
		@@ -48,6 +48,8 @@
		#include <linux/vmalloc.h>
		#include <linux/etherdevice.h>
		#include <linux/net_tstamp.h>
		#include <linux/ptp_clock_kernel.h>
		#include <linux/ptp_classify.h>
		#include <asm/io.h>
		#include "t4_chip_type.h"
		#include "cxgb4_uld.h"
		@@ -510,6 +512,7 @@ struct port_info {
		#endif /* CONFIG_CHELSIO_T4_FCOE */
		bool rxtstamp; /* Enable TS */
		struct hwtstamp_config tstamp_config;
		bool ptp_enable;
		struct sched_table *sched_tbl;
		};

		@@ -705,6 +708,7 @@ struct sge_uld_txq_info {

		struct sge {
		struct sge_eth_txq ethtxq[MAX_ETH_QSETS];
		struct sge_eth_txq ptptxq;
		struct sge_ctrl_txq ctrlq[MAX_CTRL_QUEUES];

		struct sge_eth_rxq ethrxq[MAX_ETH_QSETS];
		@@ -869,6 +873,11 @@ struct adapter {
		* used for all 4 filters.
		*/

		struct ptp_clock *ptp_clock;
		struct ptp_clock_info ptp_clock_info;
		struct sk_buff *ptp_tx_skb;
		/* ptp lock */
		spinlock_t ptp_lock;
		spinlock_t stats_lock;
		spinlock_t win0_lock ____cacheline_aligned_in_smp;

drivers/net/ethernet/chelsio/cxgb4/cxgb4_main.c

+70 −6

Original line number	Diff line number	Diff line
		@@ -79,6 +79,7 @@
		#include "l2t.h"
		#include "sched.h"
		#include "cxgb4_tc_u32.h"
		#include "cxgb4_ptp.h"

		char cxgb4_driver_name[] = KBUILD_MODNAME;

		@@ -872,6 +873,14 @@ static int setup_sge_queues(struct adapter *adap)
		goto freeout;
		}

		if (!is_t4(adap->params.chip)) {
		err = t4_sge_alloc_eth_txq(adap, &s->ptptxq, adap->port[0],
		netdev_get_tx_queue(adap->port[0], 0)
		, s->fw_evtq.cntxt_id);
		if (err)
		goto freeout;
		}

		t4_write_reg(adap, is_t4(adap->params.chip) ?
		MPS_TRC_RSS_CONTROL_A :
		MPS_T5_TRC_RSS_CONTROL_A,
		@@ -2438,6 +2447,7 @@ static int cxgb_ioctl(struct net_device dev, struct ifreq req, int cmd)
		unsigned int mbox;
		int ret = 0, prtad, devad;
		struct port_info *pi = netdev_priv(dev);
		struct adapter *adapter = pi->adapter;
		struct mii_ioctl_data data = (struct mii_ioctl_data )&req->ifr_data;

		switch (cmd) {
		@@ -2475,18 +2485,69 @@ static int cxgb_ioctl(struct net_device dev, struct ifreq req, int cmd)
		sizeof(pi->tstamp_config)))
		return -EFAULT;

		if (!is_t4(adapter->params.chip)) {
		switch (pi->tstamp_config.tx_type) {
		case HWTSTAMP_TX_OFF:
		case HWTSTAMP_TX_ON:
		break;
		default:
		return -ERANGE;
		}

		switch (pi->tstamp_config.rx_filter) {
		case HWTSTAMP_FILTER_NONE:
		pi->rxtstamp = false;
		break;
		case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
		case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
		cxgb4_ptprx_timestamping(pi, pi->port_id,
		PTP_TS_L4);
		break;
		case HWTSTAMP_FILTER_PTP_V2_EVENT:
		cxgb4_ptprx_timestamping(pi, pi->port_id,
		PTP_TS_L2_L4);
		break;
		case HWTSTAMP_FILTER_ALL:
		case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
		case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
		case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
		case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
		pi->rxtstamp = true;
		break;
		default:
		pi->tstamp_config.rx_filter = HWTSTAMP_FILTER_NONE;
		pi->tstamp_config.rx_filter =
		HWTSTAMP_FILTER_NONE;
		return -ERANGE;
		}

		if ((pi->tstamp_config.tx_type == HWTSTAMP_TX_OFF) &&
		(pi->tstamp_config.rx_filter ==
		HWTSTAMP_FILTER_NONE)) {
		if (cxgb4_ptp_txtype(adapter, pi->port_id) >= 0)
		pi->ptp_enable = false;
		}

		if (pi->tstamp_config.rx_filter !=
		HWTSTAMP_FILTER_NONE) {
		if (cxgb4_ptp_redirect_rx_packet(adapter,
		pi) >= 0)
		pi->ptp_enable = true;
		}
		} else {
		/* For T4 Adapters */
		switch (pi->tstamp_config.rx_filter) {
		case HWTSTAMP_FILTER_NONE:
		pi->rxtstamp = false;
		break;
		case HWTSTAMP_FILTER_ALL:
		pi->rxtstamp = true;
		break;
		default:
		pi->tstamp_config.rx_filter =
		HWTSTAMP_FILTER_NONE;
		return -ERANGE;
		}
		}
		return copy_to_user(req->ifr_data, &pi->tstamp_config,
		sizeof(pi->tstamp_config)) ?
		-EFAULT : 0;
		@@ -4240,6 +4301,9 @@ static void cfg_queues(struct adapter *adap)
		for (i = 0; i < ARRAY_SIZE(s->ctrlq); i++)
		s->ctrlq[i].q.size = 512;

		if (!is_t4(adap->params.chip))
		s->ptptxq.q.size = 8;

		init_rspq(adap, &s->fw_evtq, 0, 1, 1024, 64);
		init_rspq(adap, &s->intrq, 0, 1, 512, 64);
		}

drivers/net/ethernet/chelsio/cxgb4/cxgb4_ptp.c

0 → 100644

+194 −0

Original line number	Diff line number	Diff line
		/*
		* cxgb4_ptp.c:Chelsio PTP support for T5/T6
		*
		* Copyright (c) 2003-2017 Chelsio Communications, Inc. All rights reserved.
		*
		* This software is available to you under a choice of one of two
		* licenses. You may choose to be licensed under the terms of the GNU
		* General Public License (GPL) Version 2, available from the file
		* COPYING in the main directory of this source tree, or the
		* OpenIB.org BSD license below:
		*
		* Redistribution and use in source and binary forms, with or
		* without modification, are permitted provided that the following
		* conditions are met:
		*
		* - Redistributions of source code must retain the above
		* copyright notice, this list of conditions and the following
		* disclaimer.
		*
		* - Redistributions in binary form must reproduce the above
		* copyright notice, this list of conditions and the following
		* disclaimer in the documentation and/or other materials
		* provided with the distribution.
		*
		* 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.
		*
		* Written by: Atul Gupta (atul.gupta@chelsio.com)
		*/

		#include <linux/module.h>
		#include <linux/net_tstamp.h>
		#include <linux/skbuff.h>
		#include <linux/netdevice.h>
		#include <linux/pps_kernel.h>
		#include <linux/ptp_clock_kernel.h>
		#include <linux/ptp_classify.h>
		#include <linux/udp.h>

		#include "cxgb4.h"
		#include "t4_hw.h"
		#include "t4_regs.h"
		#include "t4_msg.h"
		#include "t4fw_api.h"
		#include "cxgb4_ptp.h"

		/**
		* cxgb4_ptp_is_ptp_tx - determine whether TX packet is PTP or not
		* @skb: skb of outgoing ptp request
		*
		*/
		bool cxgb4_ptp_is_ptp_tx(struct sk_buff *skb)
		{
		struct udphdr *uh;

		uh = udp_hdr(skb);
		return skb->len >= PTP_MIN_LENGTH &&
		skb->len <= PTP_IN_TRANSMIT_PACKET_MAXNUM &&
		likely(skb->protocol == htons(ETH_P_IP)) &&
		ip_hdr(skb)->protocol == IPPROTO_UDP &&
		uh->dest == htons(PTP_EVENT_PORT);
		}

		bool is_ptp_enabled(struct sk_buff skb, struct net_device dev)
		{
		struct port_info *pi;

		pi = netdev_priv(dev);
		return (pi->ptp_enable && cxgb4_xmit_with_hwtstamp(skb) &&
		cxgb4_ptp_is_ptp_tx(skb));
		}

		/**
		* cxgb4_ptp_is_ptp_rx - determine whether RX packet is PTP or not
		* @skb: skb of incoming ptp request
		*
		*/
		bool cxgb4_ptp_is_ptp_rx(struct sk_buff *skb)
		{
		struct udphdr uh = (struct udphdr )(skb->data + ETH_HLEN +
		IPV4_HLEN(skb->data));

		return uh->dest == htons(PTP_EVENT_PORT) &&
		uh->source == htons(PTP_EVENT_PORT);
		}

		/**
		* cxgb4_ptp_read_hwstamp - read timestamp for TX event PTP message
		* @adapter: board private structure
		* @pi: port private structure
		*
		*/
		void cxgb4_ptp_read_hwstamp(struct adapter adapter, struct port_info pi)
		{
		struct skb_shared_hwtstamps *skb_ts = NULL;
		u64 tx_ts;

		skb_ts = skb_hwtstamps(adapter->ptp_tx_skb);

		tx_ts = t4_read_reg(adapter,
		T5_PORT_REG(pi->port_id, MAC_PORT_TX_TS_VAL_LO));

		tx_ts \|= (u64)t4_read_reg(adapter,
		T5_PORT_REG(pi->port_id,
		MAC_PORT_TX_TS_VAL_HI)) << 32;
		skb_ts->hwtstamp = ns_to_ktime(tx_ts);
		skb_tstamp_tx(adapter->ptp_tx_skb, skb_ts);
		dev_kfree_skb_any(adapter->ptp_tx_skb);
		spin_lock(&adapter->ptp_lock);
		adapter->ptp_tx_skb = NULL;
		spin_unlock(&adapter->ptp_lock);
		}

		/**
		* cxgb4_ptprx_timestamping - Enable Timestamp for RX PTP event message
		* @pi: port private structure
		* @port: pot number
		* @mode: RX mode
		*
		*/
		int cxgb4_ptprx_timestamping(struct port_info *pi, u8 port, u16 mode)
		{
		struct adapter *adapter = pi->adapter;
		struct fw_ptp_cmd c;
		int err;

		memset(&c, 0, sizeof(c));
		c.op_to_portid = cpu_to_be32(FW_CMD_OP_V(FW_PTP_CMD) \|
		FW_CMD_REQUEST_F \|
		FW_CMD_WRITE_F \|
		FW_PTP_CMD_PORTID_V(port));
		c.retval_len16 = cpu_to_be32(FW_CMD_LEN16_V(sizeof(c) / 16));
		c.u.init.sc = FW_PTP_SC_RXTIME_STAMP;
		c.u.init.mode = cpu_to_be16(mode);

		err = t4_wr_mbox(adapter, adapter->mbox, &c, sizeof(c), NULL);
		if (err < 0)
		dev_err(adapter->pdev_dev,
		"PTP: %s error %d\n", __func__, -err);
		return err;
		}

		int cxgb4_ptp_txtype(struct adapter *adapter, u8 port)
		{
		struct fw_ptp_cmd c;
		int err;

		memset(&c, 0, sizeof(c));
		c.op_to_portid = cpu_to_be32(FW_CMD_OP_V(FW_PTP_CMD) \|
		FW_CMD_REQUEST_F \|
		FW_CMD_WRITE_F \|
		FW_PTP_CMD_PORTID_V(port));
		c.retval_len16 = cpu_to_be32(FW_CMD_LEN16_V(sizeof(c) / 16));
		c.u.init.sc = FW_PTP_SC_TX_TYPE;
		c.u.init.mode = cpu_to_be16(PTP_TS_NONE);

		err = t4_wr_mbox(adapter, adapter->mbox, &c, sizeof(c), NULL);
		if (err < 0)
		dev_err(adapter->pdev_dev,
		"PTP: %s error %d\n", __func__, -err);

		return err;
		}

		int cxgb4_ptp_redirect_rx_packet(struct adapter adapter, struct port_info pi)
		{
		struct sge *s = &adapter->sge;
		struct sge_eth_rxq *receive_q = &s->ethrxq[pi->first_qset];
		struct fw_ptp_cmd c;
		int err;

		memset(&c, 0, sizeof(c));
		c.op_to_portid = cpu_to_be32(FW_CMD_OP_V(FW_PTP_CMD) \|
		FW_CMD_REQUEST_F \|
		FW_CMD_WRITE_F \|
		FW_PTP_CMD_PORTID_V(pi->port_id));

		c.retval_len16 = cpu_to_be32(FW_CMD_LEN16_V(sizeof(c) / 16));
		c.u.init.sc = FW_PTP_SC_RDRX_TYPE;
		c.u.init.txchan = pi->tx_chan;
		c.u.init.absid = cpu_to_be16(receive_q->rspq.abs_id);

		err = t4_wr_mbox(adapter, adapter->mbox, &c, sizeof(c), NULL);
		if (err < 0)
		dev_err(adapter->pdev_dev,
		"PTP: %s error %d\n", __func__, -err);
		return err;
		}

drivers/net/ethernet/chelsio/cxgb4/cxgb4_ptp.h

0 → 100644

+74 −0

Original line number	Diff line number	Diff line
		/*
		* This file is part of the Chelsio T4 Ethernet driver for Linux.
		*
		* Copyright (c) 2003-2017 Chelsio Communications, Inc. All rights reserved.
		*
		* This software is available to you under a choice of one of two
		* licenses. You may choose to be licensed under the terms of the GNU
		* General Public License (GPL) Version 2, available from the file
		* COPYING in the main directory of this source tree, or the
		* OpenIB.org BSD license below:
		*
		* Redistribution and use in source and binary forms, with or
		* without modification, are permitted provided that the following
		* conditions are met:
		*
		* - Redistributions of source code must retain the above
		* copyright notice, this list of conditions and the following
		* disclaimer.
		*
		* - Redistributions in binary form must reproduce the above
		* copyright notice, this list of conditions and the following
		* disclaimer in the documentation and/or other materials
		* provided with the distribution.
		*
		* 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.
		*/

		#ifndef __CXGB4_PTP_H__
		#define __CXGB4_PTP_H__

		/* Maximum parts-per-billion adjustment that is acceptable */
		#define MAX_PTP_FREQ_ADJ 1000000
		#define PTP_CLOCK_MAX_ADJTIME 10000000 /* 10 ms */

		#define PTP_MIN_LENGTH 63
		#define PTP_IN_TRANSMIT_PACKET_MAXNUM 240
		#define PTP_EVENT_PORT 319

		enum ptp_rx_filter_mode {
		PTP_TS_NONE = 0,
		PTP_TS_L2,
		PTP_TS_L4,
		PTP_TS_L2_L4
		};

		struct port_info;

		static inline bool cxgb4_xmit_with_hwtstamp(struct sk_buff *skb)
		{
		return skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP;
		}

		static inline void cxgb4_xmit_hwtstamp_pending(struct sk_buff *skb)
		{
		skb_shinfo(skb)->tx_flags \|= SKBTX_IN_PROGRESS;
		}

		void cxgb4_ptp_init(struct adapter *adap);
		void cxgb4_ptp_stop(struct adapter *adap);
		bool cxgb4_ptp_is_ptp_tx(struct sk_buff *skb);
		bool cxgb4_ptp_is_ptp_rx(struct sk_buff *skb);
		int cxgb4_ptprx_timestamping(struct port_info *pi, u8 port, u16 mode);
		int cxgb4_ptp_redirect_rx_packet(struct adapter adap, struct port_info pi);
		int cxgb4_ptp_txtype(struct adapter *adap, u8 port_id);
		void cxgb4_ptp_read_hwstamp(struct adapter adap, struct port_info pi);
		bool is_ptp_enabled(struct sk_buff skb, struct net_device dev);
		#endif /* __CXGB4_PTP_H__ */