From patchwork Tue Jun 9 15:13:43 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Sebastian, Selwin" X-Patchwork-Id: 71066 X-Patchwork-Delegate: ferruh.yigit@amd.com Return-Path: X-Original-To: patchwork@inbox.dpdk.org Delivered-To: patchwork@inbox.dpdk.org Received: from dpdk.org (dpdk.org [92.243.14.124]) by inbox.dpdk.org (Postfix) with ESMTP id 01A70A04FE; Tue, 9 Jun 2020 17:14:28 +0200 (CEST) Received: from [92.243.14.124] (localhost [127.0.0.1]) by dpdk.org (Postfix) with ESMTP id 2DB971BE83; Tue, 9 Jun 2020 17:14:28 +0200 (CEST) Received: from NAM10-MW2-obe.outbound.protection.outlook.com (mail-mw2nam10on2051.outbound.protection.outlook.com [40.107.94.51]) by dpdk.org (Postfix) with ESMTP id 9C2D11BDFD for ; Tue, 9 Jun 2020 17:14:26 +0200 (CEST) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=Xsi4fZZB7Rr5nmcd5KKId48hhXnkVxeWen4qDG4M28PViSxTds7v1J/KtrWQ/ZuggCUmk5lXZoGs1NHsjdtj4B0SCnpAch63FfC8Tf8Q2v7q41wnks5ND74fajiQ41WfI0OoV+h/oBeiqwCVfo6rCiKGjha8yxxSobfh3NCz0+Bu6gDhLYnoh1W3IQD6sA9er5jRhu8ZoY6DqlIeDvdJEbQFAenHCiJdlO2568CSKXJNcnZvfI2tM9cxx1w8jZuTGWFXkKSlEt3u3ITdR33jY21bmVzEZKcaZmJ06Mcvxsb5VY3S0cymq20yUyMeEqdpHj+Jye1IMPgDwfZRSGixDQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=04kMlQWwMbWJ7cb/iHSLDZqCjqxi0qYXFHn4X0uvEkE=; b=M5uBtdJvT5O1TXZ4jtOyRUJDHuIVIfRc20BV7peBFf6iKFHTdKCh+FVMxV65weo2bh7XQx5oNJYuq0XvxBNz+RROVy9RlmE5JogOb1wAymcEe2/lKFBFkrPwIh33gwbz7yZbAL3jvIVOhaiV/ipCyDrnfkvXAYZk+BPbRnD7kK2gAsDFCJYRHSxsAuDNRo5PQzVKIcIFfyWDgG6Xj17isTtydFu+pQWUHFE/G/Aye2+gArpyXH17xo2PkGUKNv7K9falmyZuqXv8p2vfKdI5msd2r7QxTOg0vhW+TsB/aXeDGs9LKo067U5nAQOAfcD09DfCESisS4I0EZ6LRVMfWQ== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=amd.com; dmarc=pass action=none header.from=amd.com; dkim=pass header.d=amd.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=amdcloud.onmicrosoft.com; s=selector2-amdcloud-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=04kMlQWwMbWJ7cb/iHSLDZqCjqxi0qYXFHn4X0uvEkE=; b=1g5uepltD8PJC8jO1SG52ZGhg2iq+QpDseNoetelUofmkkVFfAiQ7Hvz5oRjuSL9aOPO6BIlEJ4tcpAPMyXYD6i+lZAlWxhaid4Ygj6kX7V+JaPOfADSChnAEkIbNfP2K1T4O6MpsndpbgsnhL0rfGGHF6XWulrnSwhhFT52sY0= Authentication-Results: dpdk.org; dkim=none (message not signed) header.d=none;dpdk.org; dmarc=none action=none header.from=amd.com; Received: from SN6PR12MB2704.namprd12.prod.outlook.com (2603:10b6:805:72::20) by SN6PR12MB2607.namprd12.prod.outlook.com (2603:10b6:805:6d::30) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3066.18; Tue, 9 Jun 2020 15:14:24 +0000 Received: from SN6PR12MB2704.namprd12.prod.outlook.com ([fe80::41be:1aa:2c92:71e4]) by SN6PR12MB2704.namprd12.prod.outlook.com ([fe80::41be:1aa:2c92:71e4%3]) with mapi id 15.20.3066.023; Tue, 9 Jun 2020 15:14:24 +0000 From: selwin.sebastian@amd.com To: dev@dpdk.org Cc: asomalap@amd.com Date: Tue, 9 Jun 2020 20:43:43 +0530 Message-Id: <20200609151343.2097-1-selwin.sebastian@amd.com> X-Mailer: git-send-email 2.17.1 X-ClientProxiedBy: MAXPR0101CA0026.INDPRD01.PROD.OUTLOOK.COM (2603:1096:a00:d::12) To SN6PR12MB2704.namprd12.prod.outlook.com (2603:10b6:805:72::20) MIME-Version: 1.0 X-MS-Exchange-MessageSentRepresentingType: 1 Received: from cae-Bilby-RV1.amd.com (165.204.156.251) by MAXPR0101CA0026.INDPRD01.PROD.OUTLOOK.COM (2603:1096:a00:d::12) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.3088.18 via Frontend Transport; Tue, 9 Jun 2020 15:14:23 +0000 X-Mailer: git-send-email 2.17.1 X-Originating-IP: [165.204.156.251] X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-HT: Tenant X-MS-Office365-Filtering-Correlation-Id: 645694ef-47ce-4124-48da-08d80c87cb27 X-MS-TrafficTypeDiagnostic: SN6PR12MB2607: X-MS-Exchange-Transport-Forked: True X-Microsoft-Antispam-PRVS: X-MS-Oob-TLC-OOBClassifiers: OLM:95; X-Forefront-PRVS: 042957ACD7 X-MS-Exchange-SenderADCheck: 1 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 1ecXOLT70aRkE+l6YG4ozu5wETC6JiAzJ+IrMO2Fs8vbd4bigENYOmW7sV8oG/zQnENV1Zr+5tVptM7EYKUCuGBYbLeGfNFjybROfrGbHZiAuCBf79kQNrWVQdv97y4+qfolustT2PwSIXjam72K0ARVdx/lLr4B5l7TfRzdVSUOho3xRSexo6WCiKXEEyJvUFCIfLhYGRKiSzJzObzFzVj+sCD8BGW/mrbvE1HZouTDC0ROXmoXuvealIZ2S9DrqW+xwtyCiSODqysS1jxebXFwtMMY2/hdR2W79ZZhm8QYeLKRoTECLfeEeNRq2inI1Qb1PBikQ3ZgQnCpSurBuA== X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:SN6PR12MB2704.namprd12.prod.outlook.com; PTR:; CAT:NONE; SFTY:; SFS:(4636009)(396003)(346002)(39860400002)(136003)(376002)(366004)(9686003)(52116002)(16526019)(5660300002)(186003)(83380400001)(7696005)(4326008)(6916009)(30864003)(86362001)(8936002)(66946007)(6486002)(6666004)(36756003)(1076003)(956004)(26005)(66556008)(8676002)(478600001)(66476007)(316002)(2616005)(2906002); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData: +c9UDUwhL3yOX0qVnelwFQ4uNbPDq3U/gYVxc0C4C/h7bYHC3jedPpjG5st7O5AimdCrrEuf+r/WkijOFVzIUv4l7CxY9GIOQE1D95yG0JMpDmJobns/Ao2zRiHk3FMyM8hbAmbYtCz5qPBzbK29WQiQc39fK9lica7OF1aPkS82fEHWWnn4ilnrvsxhFUReVYM0O8uue5/bL05k3py3LKmpBQipxh1tCQ4K1A4oEyKyD5oXs2WHZQWxRxsm2DRM6aih18h+gNclUiGJFAnIfFGSOgLkThPUahUmXxu2IIdI69UitbFlaWMvrW2ej92h1xgah7W4cIcT1swB31+mpmXuEq2pPouv36csgYPsNk1h3JM+DPAZRyqvvAt0wj0aR9JXbwNFy+iOd0FY2lpYjduXxk7FI/grgY4+sLgCXmRwrLLwprtU8mjACUm3oVEroThNOlC1wREgI02KjpmpLPL1LN7ajv6u+Ys6dt+te73IVU9FrT7ozNmMNUUo8MWi X-OriginatorOrg: amd.com X-MS-Exchange-CrossTenant-Network-Message-Id: 645694ef-47ce-4124-48da-08d80c87cb27 X-MS-Exchange-CrossTenant-OriginalArrivalTime: 09 Jun 2020 15:14:24.3251 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 3dd8961f-e488-4e60-8e11-a82d994e183d X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: u8MQ2MkY53CEZxzgfKA4EJU2lDGjhJzMT+4VRQ/iH0fmkRHS+R/YQad2DrBKvZyznGjaoobAHFT/q0Q6isOv/w== X-MS-Exchange-Transport-CrossTenantHeadersStamped: SN6PR12MB2607 Subject: [dpdk-dev] [PATCH v2] net/axgbe: enable IEEE 1588 PTP support X-BeenThere: dev@dpdk.org X-Mailman-Version: 2.1.15 Precedence: list List-Id: DPDK patches and discussions List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dev-bounces@dpdk.org Sender: "dev" From: Selwin Sebastian Add ethdev APIs to support PTP timestamping Signed-off-by: Selwin Sebastian Signed-off-by: Selwin Sebastian Acked-by: Amaranath Somalapuram --- drivers/net/axgbe/axgbe_common.h | 8 + drivers/net/axgbe/axgbe_ethdev.c | 336 +++++++++++++++++++++++++ drivers/net/axgbe/axgbe_ethdev.h | 14 ++ drivers/net/axgbe/axgbe_rxtx.c | 8 + drivers/net/axgbe/axgbe_rxtx_vec_sse.c | 8 +- 5 files changed, 373 insertions(+), 1 deletion(-) diff --git a/drivers/net/axgbe/axgbe_common.h b/drivers/net/axgbe/axgbe_common.h index f48117180..e0a0b0fbb 100644 --- a/drivers/net/axgbe/axgbe_common.h +++ b/drivers/net/axgbe/axgbe_common.h @@ -45,6 +45,7 @@ #endif #define AXGBE_HZ 250 +#define NSEC_PER_SEC 1000000000L /* DMA register offsets */ #define DMA_MR 0x3000 @@ -491,6 +492,8 @@ #define MAC_TSCR_TSEVNTENA_WIDTH 1 #define MAC_TSCR_TSINIT_INDEX 2 #define MAC_TSCR_TSINIT_WIDTH 1 +#define MAC_TSCR_TSUPDT_INDEX 3 +#define MAC_TSCR_TSUPDT_WIDTH 1 #define MAC_TSCR_TSIPENA_INDEX 11 #define MAC_TSCR_TSIPENA_WIDTH 1 #define MAC_TSCR_TSIPV4ENA_INDEX 13 @@ -505,6 +508,8 @@ #define MAC_TSCR_TXTSSTSM_WIDTH 1 #define MAC_TSSR_TXTSC_INDEX 15 #define MAC_TSSR_TXTSC_WIDTH 1 +#define MAC_STNUR_ADDSUB_INDEX 31 +#define MAC_STNUR_ADDSUB_WIDTH 1 #define MAC_TXSNR_TXTSSTSMIS_INDEX 31 #define MAC_TXSNR_TXTSSTSMIS_WIDTH 1 #define MAC_VLANHTR_VLHT_INDEX 0 @@ -538,6 +543,7 @@ #define MAC_VR_USERVER_INDEX 16 #define MAC_VR_USERVER_WIDTH 8 + /* MMC register offsets */ #define MMC_CR 0x0800 #define MMC_RISR 0x0804 @@ -1170,6 +1176,8 @@ #define RX_CONTEXT_DESC3_TSA_WIDTH 1 #define RX_CONTEXT_DESC3_TSD_INDEX 6 #define RX_CONTEXT_DESC3_TSD_WIDTH 1 +#define RX_CONTEXT_DESC3_PMT_INDEX 0 +#define RX_CONTEXT_DESC3_PMT_WIDTH 4 #define TX_PACKET_ATTRIBUTES_CSUM_ENABLE_INDEX 0 #define TX_PACKET_ATTRIBUTES_CSUM_ENABLE_WIDTH 1 diff --git a/drivers/net/axgbe/axgbe_ethdev.c b/drivers/net/axgbe/axgbe_ethdev.c index 867058845..a19bfcb0e 100644 --- a/drivers/net/axgbe/axgbe_ethdev.c +++ b/drivers/net/axgbe/axgbe_ethdev.c @@ -8,6 +8,7 @@ #include "axgbe_common.h" #include "axgbe_phy.h" #include "axgbe_regs.h" +#include "rte_time.h" static int eth_axgbe_dev_init(struct rte_eth_dev *eth_dev); static int eth_axgbe_dev_uninit(struct rte_eth_dev *eth_dev); @@ -74,6 +75,31 @@ static void axgbe_txq_info_get(struct rte_eth_dev *dev, uint16_t queue_id, struct rte_eth_txq_info *qinfo); const uint32_t *axgbe_dev_supported_ptypes_get(struct rte_eth_dev *dev); +static int +axgbe_timesync_enable(struct rte_eth_dev *dev); +static int +axgbe_timesync_disable(struct rte_eth_dev *dev); +static int +axgbe_timesync_read_rx_timestamp(struct rte_eth_dev *dev, + struct timespec *timestamp, uint32_t flags); +static int +axgbe_timesync_read_tx_timestamp(struct rte_eth_dev *dev, + struct timespec *timestamp); +static int +axgbe_timesync_adjust_time(struct rte_eth_dev *dev, int64_t delta); +static int +axgbe_timesync_read_time(struct rte_eth_dev *dev, + struct timespec *timestamp); +static int +axgbe_timesync_write_time(struct rte_eth_dev *dev, + const struct timespec *timestamp); +static void +axgbe_set_tstamp_time(struct axgbe_port *pdata, unsigned int sec, + unsigned int nsec); +static void +axgbe_update_tstamp_addend(struct axgbe_port *pdata, + unsigned int addend); + struct axgbe_xstats { char name[RTE_ETH_XSTATS_NAME_SIZE]; int offset; @@ -214,6 +240,14 @@ static const struct eth_dev_ops axgbe_eth_dev_ops = { .dev_supported_ptypes_get = axgbe_dev_supported_ptypes_get, .rx_descriptor_status = axgbe_dev_rx_descriptor_status, .tx_descriptor_status = axgbe_dev_tx_descriptor_status, + .timesync_enable = axgbe_timesync_enable, + .timesync_disable = axgbe_timesync_disable, + .timesync_read_rx_timestamp = axgbe_timesync_read_rx_timestamp, + .timesync_read_tx_timestamp = axgbe_timesync_read_tx_timestamp, + .timesync_adjust_time = axgbe_timesync_adjust_time, + .timesync_read_time = axgbe_timesync_read_time, + .timesync_write_time = axgbe_timesync_write_time, + }; static int axgbe_phy_reset(struct axgbe_port *pdata) @@ -1255,6 +1289,308 @@ axgbe_dev_supported_ptypes_get(struct rte_eth_dev *dev) return NULL; } +static void +axgbe_update_tstamp_time(struct axgbe_port *pdata, + unsigned int sec, unsigned int nsec, int addsub) +{ + unsigned int count = 100; + uint32_t sub_val = 0; + uint32_t sub_val_sec = 0xFFFFFFFF; + uint32_t sub_val_nsec = 0x3B9ACA00; + + if (addsub) { + if (sec) + sub_val = sub_val_sec - (sec - 1); + else + sub_val = sec; + + AXGMAC_IOWRITE(pdata, MAC_STSUR, sub_val); + sub_val = sub_val_nsec - nsec; + AXGMAC_IOWRITE(pdata, MAC_STNUR, sub_val); + AXGMAC_IOWRITE_BITS(pdata, MAC_STNUR, ADDSUB, 1); + } else { + AXGMAC_IOWRITE(pdata, MAC_STSUR, sec); + AXGMAC_IOWRITE_BITS(pdata, MAC_STNUR, ADDSUB, 0); + AXGMAC_IOWRITE(pdata, MAC_STNUR, nsec); + } + AXGMAC_IOWRITE_BITS(pdata, MAC_TSCR, TSUPDT, 1); + /* Wait for time update to complete */ + while (--count && AXGMAC_IOREAD_BITS(pdata, MAC_TSCR, TSUPDT)) + rte_delay_ms(1); +} + +static inline uint64_t +div_u64_rem(uint64_t dividend, uint32_t divisor, uint32_t *remainder) +{ + *remainder = dividend % divisor; + return dividend / divisor; +} + +static inline uint64_t +div_u64(uint64_t dividend, uint32_t divisor) +{ + uint32_t remainder; + return div_u64_rem(dividend, divisor, &remainder); +} + +static int +axgbe_adjfreq(struct axgbe_port *pdata, int64_t delta) +{ + uint64_t adjust; + uint32_t addend, diff; + unsigned int neg_adjust = 0; + + if (delta < 0) { + neg_adjust = 1; + delta = -delta; + } + adjust = (uint64_t)pdata->tstamp_addend; + adjust *= delta; + diff = (uint32_t)div_u64(adjust, 1000000000UL); + addend = (neg_adjust) ? pdata->tstamp_addend - diff : + pdata->tstamp_addend + diff; + pdata->tstamp_addend = addend; + axgbe_update_tstamp_addend(pdata, addend); + return 0; +} + +static int +axgbe_timesync_adjust_time(struct rte_eth_dev *dev, int64_t delta) +{ + struct axgbe_port *pdata = dev->data->dev_private; + struct timespec timestamp_delta; + + axgbe_adjfreq(pdata, delta); + pdata->systime_tc.nsec += delta; + + if (delta < 0) { + delta = -delta; + timestamp_delta = rte_ns_to_timespec(delta); + axgbe_update_tstamp_time(pdata, timestamp_delta.tv_sec, + timestamp_delta.tv_nsec, 1); + } else { + timestamp_delta = rte_ns_to_timespec(delta); + axgbe_update_tstamp_time(pdata, timestamp_delta.tv_sec, + timestamp_delta.tv_nsec, 0); + } + return 0; +} + +static int +axgbe_timesync_read_time(struct rte_eth_dev *dev, + struct timespec *timestamp) +{ + uint64_t nsec; + struct axgbe_port *pdata = dev->data->dev_private; + + nsec = AXGMAC_IOREAD(pdata, MAC_STSR); + nsec *= NSEC_PER_SEC; + nsec += AXGMAC_IOREAD(pdata, MAC_STNR); + *timestamp = rte_ns_to_timespec(nsec); + return 0; +} +static int +axgbe_timesync_write_time(struct rte_eth_dev *dev, + const struct timespec *timestamp) +{ + unsigned int count = 100; + struct axgbe_port *pdata = dev->data->dev_private; + + AXGMAC_IOWRITE(pdata, MAC_STSUR, timestamp->tv_sec); + AXGMAC_IOWRITE(pdata, MAC_STNUR, timestamp->tv_nsec); + AXGMAC_IOWRITE_BITS(pdata, MAC_TSCR, TSUPDT, 1); + /* Wait for time update to complete */ + while (--count && AXGMAC_IOREAD_BITS(pdata, MAC_TSCR, TSUPDT)) + rte_delay_ms(1); + if (!count) + PMD_DRV_LOG(ERR, "Timed out update timestamp\n"); + return 0; +} + +static void +axgbe_update_tstamp_addend(struct axgbe_port *pdata, + uint32_t addend) +{ + unsigned int count = 100; + + AXGMAC_IOWRITE(pdata, MAC_TSAR, addend); + AXGMAC_IOWRITE_BITS(pdata, MAC_TSCR, TSADDREG, 1); + + /* Wait for addend update to complete */ + while (--count && AXGMAC_IOREAD_BITS(pdata, MAC_TSCR, TSADDREG)) + rte_delay_ms(1); + if (!count) + PMD_DRV_LOG(ERR, "Timed out updating timestamp addend register\n"); +} + +static void +axgbe_set_tstamp_time(struct axgbe_port *pdata, unsigned int sec, + unsigned int nsec) +{ + unsigned int count = 100; + + /*System Time Sec Update*/ + AXGMAC_IOWRITE(pdata, MAC_STSUR, sec); + /*System Time nanoSec Update*/ + AXGMAC_IOWRITE(pdata, MAC_STNUR, nsec); + /*Initialize Timestamp*/ + AXGMAC_IOWRITE_BITS(pdata, MAC_TSCR, TSINIT, 1); + + /* Wait for time update to complete */ + while (--count && AXGMAC_IOREAD_BITS(pdata, MAC_TSCR, TSINIT)) + rte_delay_ms(1); + if (!count) + PMD_DRV_LOG(ERR, "Timed out initializing timestamp\n"); +} + +static int +axgbe_timesync_enable(struct rte_eth_dev *dev) +{ + struct axgbe_port *pdata = dev->data->dev_private; + unsigned int mac_tscr = 0; + uint64_t dividend; + struct timespec timestamp; + uint64_t nsec; + + /* Set one nano-second accuracy */ + AXGMAC_SET_BITS(mac_tscr, MAC_TSCR, TSCTRLSSR, 1); + + /* Set fine timestamp update */ + AXGMAC_SET_BITS(mac_tscr, MAC_TSCR, TSCFUPDT, 1); + + /* Overwrite earlier timestamps */ + AXGMAC_SET_BITS(mac_tscr, MAC_TSCR, TXTSSTSM, 1); + + AXGMAC_IOWRITE(pdata, MAC_TSCR, mac_tscr); + + /* Enabling processing of ptp over eth pkt */ + AXGMAC_SET_BITS(mac_tscr, MAC_TSCR, TSIPENA, 1); + AXGMAC_SET_BITS(mac_tscr, MAC_TSCR, TSVER2ENA, 1); + /* Enable timestamp for all pkts*/ + AXGMAC_SET_BITS(mac_tscr, MAC_TSCR, TSENALL, 1); + + /* enabling timestamp */ + AXGMAC_SET_BITS(mac_tscr, MAC_TSCR, TSENA, 1); + AXGMAC_IOWRITE(pdata, MAC_TSCR, mac_tscr); + + /* Exit if timestamping is not enabled */ + if (!AXGMAC_GET_BITS(mac_tscr, MAC_TSCR, TSENA)) { + PMD_DRV_LOG(ERR, "Exiting as timestamp is not enabled\n"); + return 0; + } + + /* Sub-second Increment Value*/ + AXGMAC_IOWRITE_BITS(pdata, MAC_SSIR, SSINC, AXGBE_TSTAMP_SSINC); + /* Sub-nanosecond Increment Value */ + AXGMAC_IOWRITE_BITS(pdata, MAC_SSIR, SNSINC, AXGBE_TSTAMP_SNSINC); + + pdata->ptpclk_rate = AXGBE_V2_PTP_CLOCK_FREQ; + dividend = 50000000; + dividend <<= 32; + pdata->tstamp_addend = div_u64(dividend, pdata->ptpclk_rate); + + axgbe_update_tstamp_addend(pdata, pdata->tstamp_addend); + axgbe_set_tstamp_time(pdata, 0, 0); + + /* Initialize the timecounter */ + memset(&pdata->systime_tc, 0, sizeof(struct rte_timecounter)); + + pdata->systime_tc.cc_mask = AXGBE_CYCLECOUNTER_MASK; + pdata->systime_tc.cc_shift = 0; + pdata->systime_tc.nsec_mask = 0; + + PMD_DRV_LOG(DEBUG, "Intializing system time counter with realtime\n"); + + /* Updating the counter once with clock real time */ + clock_gettime(CLOCK_REALTIME, ×tamp); + nsec = rte_timespec_to_ns(×tamp); + nsec = rte_timecounter_update(&pdata->systime_tc, nsec); + axgbe_set_tstamp_time(pdata, timestamp.tv_sec, timestamp.tv_nsec); + return 0; +} + +static int +axgbe_timesync_disable(struct rte_eth_dev *dev) +{ + struct axgbe_port *pdata = dev->data->dev_private; + unsigned int mac_tscr = 0; + + /*disable timestamp for all pkts*/ + AXGMAC_SET_BITS(mac_tscr, MAC_TSCR, TSENALL, 0); + /*disable the addened register*/ + AXGMAC_IOWRITE_BITS(pdata, MAC_TSCR, TSADDREG, 0); + /* disable timestamp update */ + AXGMAC_SET_BITS(mac_tscr, MAC_TSCR, TSCFUPDT, 0); + /*disable time stamp*/ + AXGMAC_SET_BITS(mac_tscr, MAC_TSCR, TSENA, 0); + return 0; +} + +static int +axgbe_timesync_read_rx_timestamp(struct rte_eth_dev *dev, + struct timespec *timestamp, uint32_t flags) +{ + uint64_t nsec = 0; + volatile union axgbe_rx_desc *desc; + uint16_t idx, pmt; + struct axgbe_rx_queue *rxq = *dev->data->rx_queues; + + idx = AXGBE_GET_DESC_IDX(rxq, rxq->cur); + desc = &rxq->desc[idx]; + + while (AXGMAC_GET_BITS_LE(desc->write.desc3, RX_NORMAL_DESC3, OWN)) + rte_delay_ms(1); + if (AXGMAC_GET_BITS_LE(desc->write.desc3, RX_NORMAL_DESC3, CTXT)) { + if (AXGMAC_GET_BITS_LE(desc->write.desc3, RX_CONTEXT_DESC3, TSA) + && !AXGMAC_GET_BITS_LE(desc->write.desc3, + RX_CONTEXT_DESC3, TSD)) { + pmt = AXGMAC_GET_BITS_LE(desc->write.desc3, + RX_CONTEXT_DESC3, PMT); + nsec = rte_le_to_cpu_32(desc->write.desc1); + nsec *= NSEC_PER_SEC; + nsec += rte_le_to_cpu_32(desc->write.desc0); + if (nsec != 0xffffffffffffffffULL) { + if (pmt == 0x01) + *timestamp = rte_ns_to_timespec(nsec); + PMD_DRV_LOG(DEBUG, "flags = 0x%x nsec = %lu\n", + flags, nsec); + } + } + } + + return 0; +} + +static int +axgbe_timesync_read_tx_timestamp(struct rte_eth_dev *dev, + struct timespec *timestamp) +{ + uint64_t nsec; + struct axgbe_port *pdata = dev->data->dev_private; + unsigned int tx_snr, tx_ssr; + + rte_delay_us(5); + if (pdata->vdata->tx_tstamp_workaround) { + tx_snr = AXGMAC_IOREAD(pdata, MAC_TXSNR); + tx_ssr = AXGMAC_IOREAD(pdata, MAC_TXSSR); + + } else { + tx_ssr = AXGMAC_IOREAD(pdata, MAC_TXSSR); + tx_snr = AXGMAC_IOREAD(pdata, MAC_TXSNR); + } + if (AXGMAC_GET_BITS(tx_snr, MAC_TXSNR, TXTSSTSMIS)) { + PMD_DRV_LOG(DEBUG, "Waiting for TXTSSTSMIS\n"); + return 0; + } + nsec = tx_ssr; + nsec *= NSEC_PER_SEC; + nsec += tx_snr; + PMD_DRV_LOG(DEBUG, "nsec = %lu tx_ssr = %d tx_snr = %d\n", + nsec, tx_ssr, tx_snr); + *timestamp = rte_ns_to_timespec(nsec); + return 0; +} + static void axgbe_get_all_hw_features(struct axgbe_port *pdata) { unsigned int mac_hfr0, mac_hfr1, mac_hfr2; diff --git a/drivers/net/axgbe/axgbe_ethdev.h b/drivers/net/axgbe/axgbe_ethdev.h index f10ec4a40..8a6bbbb22 100644 --- a/drivers/net/axgbe/axgbe_ethdev.h +++ b/drivers/net/axgbe/axgbe_ethdev.h @@ -9,6 +9,7 @@ #include #include #include "axgbe_common.h" +#include "rte_time.h" #define IRQ 0xff #define VLAN_HLEN 4 @@ -63,6 +64,13 @@ #define AXGBE_V2_DMA_CLOCK_FREQ 500000000 #define AXGBE_V2_PTP_CLOCK_FREQ 125000000 +/* Timestamp support - values based on 50MHz PTP clock + * 50MHz => 20 nsec + */ +#define AXGBE_TSTAMP_SSINC 20 +#define AXGBE_TSTAMP_SNSINC 0 +#define AXGBE_CYCLECOUNTER_MASK 0xffffffffffffffffULL + #define AXGMAC_FIFO_MIN_ALLOC 2048 #define AXGMAC_FIFO_UNIT 256 #define AXGMAC_FIFO_ALIGN(_x) \ @@ -644,6 +652,12 @@ struct axgbe_port { unsigned int hash_table_count; unsigned int uc_hash_mac_addr; unsigned int uc_hash_table[AXGBE_MAC_HASH_TABLE_SIZE]; + + /* For IEEE1588 PTP */ + struct rte_timecounter systime_tc; + struct rte_timecounter tx_tstamp; + unsigned int tstamp_addend; + }; void axgbe_init_function_ptrs_dev(struct axgbe_hw_if *hw_if); diff --git a/drivers/net/axgbe/axgbe_rxtx.c b/drivers/net/axgbe/axgbe_rxtx.c index 30c467db7..4d4bf59b5 100644 --- a/drivers/net/axgbe/axgbe_rxtx.c +++ b/drivers/net/axgbe/axgbe_rxtx.c @@ -275,6 +275,10 @@ axgbe_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts, /* Get the RSS hash */ if (AXGMAC_GET_BITS_LE(desc->write.desc3, RX_NORMAL_DESC3, RSV)) mbuf->hash.rss = rte_le_to_cpu_32(desc->write.desc1); + /* Indicate if a Context Descriptor is next */ + if (AXGMAC_GET_BITS_LE(desc->write.desc3, RX_NORMAL_DESC3, CDA)) + mbuf->ol_flags |= PKT_RX_IEEE1588_PTP + | PKT_RX_IEEE1588_TMST; pkt_len = AXGMAC_GET_BITS_LE(desc->write.desc3, RX_NORMAL_DESC3, PL) - rxq->crc_len; /* Mbuf populate */ @@ -722,6 +726,10 @@ static int axgbe_xmit_hw(struct axgbe_tx_queue *txq, /* Total msg length to transmit */ AXGMAC_SET_BITS_LE(desc->desc3, TX_NORMAL_DESC3, FL, mbuf->pkt_len); + /* Timestamp enablement check */ + if (mbuf->ol_flags & PKT_TX_IEEE1588_TMST) + AXGMAC_SET_BITS_LE(desc->desc2, TX_NORMAL_DESC2, TTSE, 1); + rte_wmb(); /* Mark it as First and Last Descriptor */ AXGMAC_SET_BITS_LE(desc->desc3, TX_NORMAL_DESC3, FD, 1); AXGMAC_SET_BITS_LE(desc->desc3, TX_NORMAL_DESC3, LD, 1); diff --git a/drivers/net/axgbe/axgbe_rxtx_vec_sse.c b/drivers/net/axgbe/axgbe_rxtx_vec_sse.c index 9be703713..1c962b933 100644 --- a/drivers/net/axgbe/axgbe_rxtx_vec_sse.c +++ b/drivers/net/axgbe/axgbe_rxtx_vec_sse.c @@ -13,6 +13,7 @@ /* Useful to avoid shifting for every descriptor prepration*/ #define TX_DESC_CTRL_FLAGS 0xb000000000000000 +#define TX_DESC_CTRL_FLAG_TMST 0x40000000 #define TX_FREE_BULK 8 #define TX_FREE_BULK_CHECK (TX_FREE_BULK - 1) @@ -20,8 +21,13 @@ static inline void axgbe_vec_tx(volatile struct axgbe_tx_desc *desc, struct rte_mbuf *mbuf) { + uint64_t tmst_en = 0; + /* Timestamp enablement check */ + if (mbuf->ol_flags & PKT_TX_IEEE1588_TMST) + tmst_en = TX_DESC_CTRL_FLAG_TMST; __m128i descriptor = _mm_set_epi64x((uint64_t)mbuf->pkt_len << 32 | - TX_DESC_CTRL_FLAGS | mbuf->data_len, + TX_DESC_CTRL_FLAGS | mbuf->data_len + | tmst_en, mbuf->buf_iova + mbuf->data_off); _mm_store_si128((__m128i *)desc, descriptor);