mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-10-29 23:53:32 +00:00
Merge branch 'net-thunderx-add-support-for-PTP-clock'
Aleksey Makarov says: ==================== net: thunderx: add support for PTP clock This series adds support for IEEE 1588 Precision Time Protocol to Cavium ethernet driver. The first patch adds support for the Precision Time Protocol Clocks and Timestamping coprocessor (PTP) found on Cavium processors. It registers a new PTP clock in the PTP core and provides functions to use the counter in BGX, TNS, GTI, and NIC blocks. The second patch introduces support for the PTP protocol to the Cavium ThunderX ethernet driver. v6: - check if ptp_clock_register() returns NULL (Richard Cochran) - fix doc comment for cavium_ptp_enable() (Richard Cochran) - fix a function call formatting; use defined constant (Richard Cochran) - add comments for `tx_ptp_skbs` and `ptp_skb` (Richard Cochran) - use adjfine() instead of adjfreq() (Richard Cochran) - add Acked-by: Philippe Ombredanne <pombredanne@nexb.com> v5: https://lkml.kernel.org/r/20171211141435.2915-1-aleksey.makarov@cavium.com - fix the file headers (add SPDX tags, remove advertisment) (Philippe Ombredanne) - use "imply" instead of "select" (Richard Cochran) - add some code in cavium_ptp_get() for the case when the PTP driver has not been registered with the PTP core v4: https://lkml.kernel.org/r/20171208103442.19354-1-aleksey.makarov@cavium.com - use IS_ENABLED. This fixes compilation of the ptp as a module (David Miller) - select PTP_1588_CLOCK, not depend on it. This fixes a build warning. - change u64 to __be64. This fixes the sparse warning "warning: cast to restricted __be64" - make nicvf_config_hwtstamp() static. This fixes the sparse warning "warning: symbol 'nicvf_config_hwtstamp' was not declared. Should it be static?" v3: https://lkml.kernel.org/r/20171206133100.26436-1-aleksey.makarov@cavium.com - rebase to net-next v2: https://lkml.kernel.org/r/20171117134909.8954-1-aleksey.makarov@cavium.com - use readq()/writeq() in place of cavium_ptp_reg_read()/cavium_ptp_reg_write(), don't use readq_relaxed()/writeq_relaxed() (David Daney) v1: https://lkml.kernel.org/r/20171107190704.15458-1-aleksey.makarov@cavium.com ==================== Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
David S. Miller
commit
3b039b42e4
13 changed files with 782 additions and 6 deletions
|
|
@ -27,6 +27,7 @@ config THUNDER_NIC_PF
|
|||
|
||||
config THUNDER_NIC_VF
|
||||
tristate "Thunder Virtual function driver"
|
||||
imply CAVIUM_PTP
|
||||
depends on 64BIT
|
||||
---help---
|
||||
This driver supports Thunder's NIC virtual function
|
||||
|
|
@ -50,6 +51,18 @@ config THUNDER_NIC_RGX
|
|||
This driver supports configuring XCV block of RGX interface
|
||||
present on CN81XX chip.
|
||||
|
||||
config CAVIUM_PTP
|
||||
tristate "Cavium PTP coprocessor as PTP clock"
|
||||
depends on 64BIT
|
||||
imply PTP_1588_CLOCK
|
||||
default y
|
||||
---help---
|
||||
This driver adds support for the Precision Time Protocol Clocks and
|
||||
Timestamping coprocessor (PTP) found on Cavium processors.
|
||||
PTP provides timestamping mechanism that is suitable for use in IEEE 1588
|
||||
Precision Time Protocol or other purposes. Timestamps can be used in
|
||||
BGX, TNS, GTI, and NIC blocks.
|
||||
|
||||
config LIQUIDIO
|
||||
tristate "Cavium LiquidIO support"
|
||||
depends on 64BIT
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
#
|
||||
# Makefile for the Cavium ethernet device drivers.
|
||||
#
|
||||
obj-$(CONFIG_NET_VENDOR_CAVIUM) += common/
|
||||
obj-$(CONFIG_NET_VENDOR_CAVIUM) += thunder/
|
||||
obj-$(CONFIG_NET_VENDOR_CAVIUM) += liquidio/
|
||||
obj-$(CONFIG_NET_VENDOR_CAVIUM) += octeon/
|
||||
|
|
|
|||
1
drivers/net/ethernet/cavium/common/Makefile
Normal file
1
drivers/net/ethernet/cavium/common/Makefile
Normal file
|
|
@ -0,0 +1 @@
|
|||
obj-$(CONFIG_CAVIUM_PTP) += cavium_ptp.o
|
||||
353
drivers/net/ethernet/cavium/common/cavium_ptp.c
Normal file
353
drivers/net/ethernet/cavium/common/cavium_ptp.c
Normal file
|
|
@ -0,0 +1,353 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* cavium_ptp.c - PTP 1588 clock on Cavium hardware
|
||||
* Copyright (c) 2003-2015, 2017 Cavium, Inc.
|
||||
*/
|
||||
|
||||
#include <linux/device.h>
|
||||
#include <linux/module.h>
|
||||
#include <linux/timecounter.h>
|
||||
#include <linux/pci.h>
|
||||
|
||||
#include "cavium_ptp.h"
|
||||
|
||||
#define DRV_NAME "Cavium PTP Driver"
|
||||
|
||||
#define PCI_DEVICE_ID_CAVIUM_PTP 0xA00C
|
||||
#define PCI_DEVICE_ID_CAVIUM_RST 0xA00E
|
||||
|
||||
#define PCI_PTP_BAR_NO 0
|
||||
#define PCI_RST_BAR_NO 0
|
||||
|
||||
#define PTP_CLOCK_CFG 0xF00ULL
|
||||
#define PTP_CLOCK_CFG_PTP_EN BIT(0)
|
||||
#define PTP_CLOCK_LO 0xF08ULL
|
||||
#define PTP_CLOCK_HI 0xF10ULL
|
||||
#define PTP_CLOCK_COMP 0xF18ULL
|
||||
|
||||
#define RST_BOOT 0x1600ULL
|
||||
#define CLOCK_BASE_RATE 50000000ULL
|
||||
|
||||
static u64 ptp_cavium_clock_get(void)
|
||||
{
|
||||
struct pci_dev *pdev;
|
||||
void __iomem *base;
|
||||
u64 ret = CLOCK_BASE_RATE * 16;
|
||||
|
||||
pdev = pci_get_device(PCI_VENDOR_ID_CAVIUM,
|
||||
PCI_DEVICE_ID_CAVIUM_RST, NULL);
|
||||
if (!pdev)
|
||||
goto error;
|
||||
|
||||
base = pci_ioremap_bar(pdev, PCI_RST_BAR_NO);
|
||||
if (!base)
|
||||
goto error_put_pdev;
|
||||
|
||||
ret = CLOCK_BASE_RATE * ((readq(base + RST_BOOT) >> 33) & 0x3f);
|
||||
|
||||
iounmap(base);
|
||||
|
||||
error_put_pdev:
|
||||
pci_dev_put(pdev);
|
||||
|
||||
error:
|
||||
return ret;
|
||||
}
|
||||
|
||||
struct cavium_ptp *cavium_ptp_get(void)
|
||||
{
|
||||
struct cavium_ptp *ptp;
|
||||
struct pci_dev *pdev;
|
||||
|
||||
pdev = pci_get_device(PCI_VENDOR_ID_CAVIUM,
|
||||
PCI_DEVICE_ID_CAVIUM_PTP, NULL);
|
||||
if (!pdev)
|
||||
return ERR_PTR(-ENODEV);
|
||||
|
||||
ptp = pci_get_drvdata(pdev);
|
||||
if (!ptp)
|
||||
ptp = ERR_PTR(-EPROBE_DEFER);
|
||||
if (IS_ERR(ptp))
|
||||
pci_dev_put(pdev);
|
||||
|
||||
return ptp;
|
||||
}
|
||||
EXPORT_SYMBOL(cavium_ptp_get);
|
||||
|
||||
void cavium_ptp_put(struct cavium_ptp *ptp)
|
||||
{
|
||||
pci_dev_put(ptp->pdev);
|
||||
}
|
||||
EXPORT_SYMBOL(cavium_ptp_put);
|
||||
|
||||
/**
|
||||
* cavium_ptp_adjfine() - Adjust ptp frequency
|
||||
* @ptp: PTP clock info
|
||||
* @scaled_ppm: how much to adjust by, in parts per million, but with a
|
||||
* 16 bit binary fractional field
|
||||
*/
|
||||
static int cavium_ptp_adjfine(struct ptp_clock_info *ptp_info, long scaled_ppm)
|
||||
{
|
||||
struct cavium_ptp *clock =
|
||||
container_of(ptp_info, struct cavium_ptp, ptp_info);
|
||||
unsigned long flags;
|
||||
u64 comp;
|
||||
u64 adj;
|
||||
bool neg_adj = false;
|
||||
|
||||
if (scaled_ppm < 0) {
|
||||
neg_adj = true;
|
||||
scaled_ppm = -scaled_ppm;
|
||||
}
|
||||
|
||||
/* The hardware adds the clock compensation value to the PTP clock
|
||||
* on every coprocessor clock cycle. Typical convention is that it
|
||||
* represent number of nanosecond betwen each cycle. In this
|
||||
* convention compensation value is in 64 bit fixed-point
|
||||
* representation where upper 32 bits are number of nanoseconds
|
||||
* and lower is fractions of nanosecond.
|
||||
* The scaled_ppm represent the ratio in "parts per bilion" by which the
|
||||
* compensation value should be corrected.
|
||||
* To calculate new compenstation value we use 64bit fixed point
|
||||
* arithmetic on following formula
|
||||
* comp = tbase + tbase * scaled_ppm / (1M * 2^16)
|
||||
* where tbase is the basic compensation value calculated initialy
|
||||
* in cavium_ptp_init() -> tbase = 1/Hz. Then we use endian
|
||||
* independent structure definition to write data to PTP register.
|
||||
*/
|
||||
comp = ((u64)1000000000ull << 32) / clock->clock_rate;
|
||||
adj = comp * scaled_ppm;
|
||||
adj >>= 16;
|
||||
adj = div_u64(adj, 1000000ull);
|
||||
comp = neg_adj ? comp - adj : comp + adj;
|
||||
|
||||
spin_lock_irqsave(&clock->spin_lock, flags);
|
||||
writeq(comp, clock->reg_base + PTP_CLOCK_COMP);
|
||||
spin_unlock_irqrestore(&clock->spin_lock, flags);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* cavium_ptp_adjtime() - Adjust ptp time
|
||||
* @ptp: PTP clock info
|
||||
* @delta: how much to adjust by, in nanosecs
|
||||
*/
|
||||
static int cavium_ptp_adjtime(struct ptp_clock_info *ptp_info, s64 delta)
|
||||
{
|
||||
struct cavium_ptp *clock =
|
||||
container_of(ptp_info, struct cavium_ptp, ptp_info);
|
||||
unsigned long flags;
|
||||
|
||||
spin_lock_irqsave(&clock->spin_lock, flags);
|
||||
timecounter_adjtime(&clock->time_counter, delta);
|
||||
spin_unlock_irqrestore(&clock->spin_lock, flags);
|
||||
|
||||
/* Sync, for network driver to get latest value */
|
||||
smp_mb();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* cavium_ptp_gettime() - Get hardware clock time with adjustment
|
||||
* @ptp: PTP clock info
|
||||
* @ts: timespec
|
||||
*/
|
||||
static int cavium_ptp_gettime(struct ptp_clock_info *ptp_info,
|
||||
struct timespec64 *ts)
|
||||
{
|
||||
struct cavium_ptp *clock =
|
||||
container_of(ptp_info, struct cavium_ptp, ptp_info);
|
||||
unsigned long flags;
|
||||
u64 nsec;
|
||||
|
||||
spin_lock_irqsave(&clock->spin_lock, flags);
|
||||
nsec = timecounter_read(&clock->time_counter);
|
||||
spin_unlock_irqrestore(&clock->spin_lock, flags);
|
||||
|
||||
*ts = ns_to_timespec64(nsec);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* cavium_ptp_settime() - Set hardware clock time. Reset adjustment
|
||||
* @ptp: PTP clock info
|
||||
* @ts: timespec
|
||||
*/
|
||||
static int cavium_ptp_settime(struct ptp_clock_info *ptp_info,
|
||||
const struct timespec64 *ts)
|
||||
{
|
||||
struct cavium_ptp *clock =
|
||||
container_of(ptp_info, struct cavium_ptp, ptp_info);
|
||||
unsigned long flags;
|
||||
u64 nsec;
|
||||
|
||||
nsec = timespec64_to_ns(ts);
|
||||
|
||||
spin_lock_irqsave(&clock->spin_lock, flags);
|
||||
timecounter_init(&clock->time_counter, &clock->cycle_counter, nsec);
|
||||
spin_unlock_irqrestore(&clock->spin_lock, flags);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* cavium_ptp_enable() - Request to enable or disable an ancillary feature.
|
||||
* @ptp: PTP clock info
|
||||
* @rq: request
|
||||
* @on: is it on
|
||||
*/
|
||||
static int cavium_ptp_enable(struct ptp_clock_info *ptp_info,
|
||||
struct ptp_clock_request *rq, int on)
|
||||
{
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
|
||||
static u64 cavium_ptp_cc_read(const struct cyclecounter *cc)
|
||||
{
|
||||
struct cavium_ptp *clock =
|
||||
container_of(cc, struct cavium_ptp, cycle_counter);
|
||||
|
||||
return readq(clock->reg_base + PTP_CLOCK_HI);
|
||||
}
|
||||
|
||||
static int cavium_ptp_probe(struct pci_dev *pdev,
|
||||
const struct pci_device_id *ent)
|
||||
{
|
||||
struct device *dev = &pdev->dev;
|
||||
struct cavium_ptp *clock;
|
||||
struct cyclecounter *cc;
|
||||
u64 clock_cfg;
|
||||
u64 clock_comp;
|
||||
int err;
|
||||
|
||||
clock = devm_kzalloc(dev, sizeof(*clock), GFP_KERNEL);
|
||||
if (!clock) {
|
||||
err = -ENOMEM;
|
||||
goto error;
|
||||
}
|
||||
|
||||
clock->pdev = pdev;
|
||||
|
||||
err = pcim_enable_device(pdev);
|
||||
if (err)
|
||||
goto error_free;
|
||||
|
||||
err = pcim_iomap_regions(pdev, 1 << PCI_PTP_BAR_NO, pci_name(pdev));
|
||||
if (err)
|
||||
goto error_free;
|
||||
|
||||
clock->reg_base = pcim_iomap_table(pdev)[PCI_PTP_BAR_NO];
|
||||
|
||||
spin_lock_init(&clock->spin_lock);
|
||||
|
||||
cc = &clock->cycle_counter;
|
||||
cc->read = cavium_ptp_cc_read;
|
||||
cc->mask = CYCLECOUNTER_MASK(64);
|
||||
cc->mult = 1;
|
||||
cc->shift = 0;
|
||||
|
||||
timecounter_init(&clock->time_counter, &clock->cycle_counter,
|
||||
ktime_to_ns(ktime_get_real()));
|
||||
|
||||
clock->clock_rate = ptp_cavium_clock_get();
|
||||
|
||||
clock->ptp_info = (struct ptp_clock_info) {
|
||||
.owner = THIS_MODULE,
|
||||
.name = "ThunderX PTP",
|
||||
.max_adj = 1000000000ull,
|
||||
.n_ext_ts = 0,
|
||||
.n_pins = 0,
|
||||
.pps = 0,
|
||||
.adjfine = cavium_ptp_adjfine,
|
||||
.adjtime = cavium_ptp_adjtime,
|
||||
.gettime64 = cavium_ptp_gettime,
|
||||
.settime64 = cavium_ptp_settime,
|
||||
.enable = cavium_ptp_enable,
|
||||
};
|
||||
|
||||
clock_cfg = readq(clock->reg_base + PTP_CLOCK_CFG);
|
||||
clock_cfg |= PTP_CLOCK_CFG_PTP_EN;
|
||||
writeq(clock_cfg, clock->reg_base + PTP_CLOCK_CFG);
|
||||
|
||||
clock_comp = ((u64)1000000000ull << 32) / clock->clock_rate;
|
||||
writeq(clock_comp, clock->reg_base + PTP_CLOCK_COMP);
|
||||
|
||||
clock->ptp_clock = ptp_clock_register(&clock->ptp_info, dev);
|
||||
if (!clock->ptp_clock) {
|
||||
err = -ENODEV;
|
||||
goto error_stop;
|
||||
}
|
||||
if (IS_ERR(clock->ptp_clock)) {
|
||||
err = PTR_ERR(clock->ptp_clock);
|
||||
goto error_stop;
|
||||
}
|
||||
|
||||
pci_set_drvdata(pdev, clock);
|
||||
return 0;
|
||||
|
||||
error_stop:
|
||||
clock_cfg = readq(clock->reg_base + PTP_CLOCK_CFG);
|
||||
clock_cfg &= ~PTP_CLOCK_CFG_PTP_EN;
|
||||
writeq(clock_cfg, clock->reg_base + PTP_CLOCK_CFG);
|
||||
pcim_iounmap_regions(pdev, 1 << PCI_PTP_BAR_NO);
|
||||
|
||||
error_free:
|
||||
devm_kfree(dev, clock);
|
||||
|
||||
error:
|
||||
/* For `cavium_ptp_get()` we need to differentiate between the case
|
||||
* when the core has not tried to probe this device and the case when
|
||||
* the probe failed. In the later case we pretend that the
|
||||
* initialization was successful and keep the error in
|
||||
* `dev->driver_data`.
|
||||
*/
|
||||
pci_set_drvdata(pdev, ERR_PTR(err));
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void cavium_ptp_remove(struct pci_dev *pdev)
|
||||
{
|
||||
struct cavium_ptp *clock = pci_get_drvdata(pdev);
|
||||
u64 clock_cfg;
|
||||
|
||||
if (IS_ERR_OR_NULL(clock))
|
||||
return;
|
||||
|
||||
ptp_clock_unregister(clock->ptp_clock);
|
||||
|
||||
clock_cfg = readq(clock->reg_base + PTP_CLOCK_CFG);
|
||||
clock_cfg &= ~PTP_CLOCK_CFG_PTP_EN;
|
||||
writeq(clock_cfg, clock->reg_base + PTP_CLOCK_CFG);
|
||||
}
|
||||
|
||||
static const struct pci_device_id cavium_ptp_id_table[] = {
|
||||
{ PCI_DEVICE(PCI_VENDOR_ID_CAVIUM, PCI_DEVICE_ID_CAVIUM_PTP) },
|
||||
{ 0, }
|
||||
};
|
||||
|
||||
static struct pci_driver cavium_ptp_driver = {
|
||||
.name = DRV_NAME,
|
||||
.id_table = cavium_ptp_id_table,
|
||||
.probe = cavium_ptp_probe,
|
||||
.remove = cavium_ptp_remove,
|
||||
};
|
||||
|
||||
static int __init cavium_ptp_init_module(void)
|
||||
{
|
||||
return pci_register_driver(&cavium_ptp_driver);
|
||||
}
|
||||
|
||||
static void __exit cavium_ptp_cleanup_module(void)
|
||||
{
|
||||
pci_unregister_driver(&cavium_ptp_driver);
|
||||
}
|
||||
|
||||
module_init(cavium_ptp_init_module);
|
||||
module_exit(cavium_ptp_cleanup_module);
|
||||
|
||||
MODULE_DESCRIPTION(DRV_NAME);
|
||||
MODULE_AUTHOR("Cavium Networks <support@cavium.com>");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
MODULE_DEVICE_TABLE(pci, cavium_ptp_id_table);
|
||||
70
drivers/net/ethernet/cavium/common/cavium_ptp.h
Normal file
70
drivers/net/ethernet/cavium/common/cavium_ptp.h
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
// SPDX-License-Identifier: GPL-2.0
|
||||
/* cavium_ptp.h - PTP 1588 clock on Cavium hardware
|
||||
* Copyright (c) 2003-2015, 2017 Cavium, Inc.
|
||||
*/
|
||||
|
||||
#ifndef CAVIUM_PTP_H
|
||||
#define CAVIUM_PTP_H
|
||||
|
||||
#include <linux/ptp_clock_kernel.h>
|
||||
#include <linux/timecounter.h>
|
||||
|
||||
struct cavium_ptp {
|
||||
struct pci_dev *pdev;
|
||||
|
||||
/* Serialize access to cycle_counter, time_counter and hw_registers */
|
||||
spinlock_t spin_lock;
|
||||
struct cyclecounter cycle_counter;
|
||||
struct timecounter time_counter;
|
||||
void __iomem *reg_base;
|
||||
|
||||
u32 clock_rate;
|
||||
|
||||
struct ptp_clock_info ptp_info;
|
||||
struct ptp_clock *ptp_clock;
|
||||
};
|
||||
|
||||
#if IS_ENABLED(CONFIG_CAVIUM_PTP)
|
||||
|
||||
struct cavium_ptp *cavium_ptp_get(void);
|
||||
void cavium_ptp_put(struct cavium_ptp *ptp);
|
||||
|
||||
static inline u64 cavium_ptp_tstamp2time(struct cavium_ptp *ptp, u64 tstamp)
|
||||
{
|
||||
unsigned long flags;
|
||||
u64 ret;
|
||||
|
||||
spin_lock_irqsave(&ptp->spin_lock, flags);
|
||||
ret = timecounter_cyc2time(&ptp->time_counter, tstamp);
|
||||
spin_unlock_irqrestore(&ptp->spin_lock, flags);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline int cavium_ptp_clock_index(struct cavium_ptp *clock)
|
||||
{
|
||||
return ptp_clock_index(clock->ptp_clock);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static inline struct cavium_ptp *cavium_ptp_get(void)
|
||||
{
|
||||
return ERR_PTR(-ENODEV);
|
||||
}
|
||||
|
||||
static inline void cavium_ptp_put(struct cavium_ptp *ptp) {}
|
||||
|
||||
static inline u64 cavium_ptp_tstamp2time(struct cavium_ptp *ptp, u64 tstamp)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
static inline int cavium_ptp_clock_index(struct cavium_ptp *clock)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -263,6 +263,8 @@ struct nicvf_drv_stats {
|
|||
struct u64_stats_sync syncp;
|
||||
};
|
||||
|
||||
struct cavium_ptp;
|
||||
|
||||
struct nicvf {
|
||||
struct nicvf *pnicvf;
|
||||
struct net_device *netdev;
|
||||
|
|
@ -312,6 +314,33 @@ struct nicvf {
|
|||
struct tasklet_struct qs_err_task;
|
||||
struct work_struct reset_task;
|
||||
|
||||
/* PTP timestamp */
|
||||
struct cavium_ptp *ptp_clock;
|
||||
/* Inbound timestamping is on */
|
||||
bool hw_rx_tstamp;
|
||||
/* When the packet that requires timestamping is sent, hardware inserts
|
||||
* two entries to the completion queue. First is the regular
|
||||
* CQE_TYPE_SEND entry that signals that the packet was sent.
|
||||
* The second is CQE_TYPE_SEND_PTP that contains the actual timestamp
|
||||
* for that packet.
|
||||
* `ptp_skb` is initialized in the handler for the CQE_TYPE_SEND
|
||||
* entry and is used and zeroed in the handler for the CQE_TYPE_SEND_PTP
|
||||
* entry.
|
||||
* So `ptp_skb` is used to hold the pointer to the packet between
|
||||
* the calls to CQE_TYPE_SEND and CQE_TYPE_SEND_PTP handlers.
|
||||
*/
|
||||
struct sk_buff *ptp_skb;
|
||||
/* `tx_ptp_skbs` is set when the hardware is sending a packet that
|
||||
* requires timestamping. Cavium hardware can not process more than one
|
||||
* such packet at once so this is set each time the driver submits
|
||||
* a packet that requires timestamping to the send queue and clears
|
||||
* each time it receives the entry on the completion queue saying
|
||||
* that such packet was sent.
|
||||
* So `tx_ptp_skbs` prevents driver from submitting more than one
|
||||
* packet that requires timestamping to the hardware for transmitting.
|
||||
*/
|
||||
atomic_t tx_ptp_skbs;
|
||||
|
||||
/* Interrupt coalescing settings */
|
||||
u32 cq_coalesce_usecs;
|
||||
u32 msg_enable;
|
||||
|
|
@ -371,6 +400,7 @@ struct nicvf {
|
|||
#define NIC_MBOX_MSG_LOOPBACK 0x16 /* Set interface in loopback */
|
||||
#define NIC_MBOX_MSG_RESET_STAT_COUNTER 0x17 /* Reset statistics counters */
|
||||
#define NIC_MBOX_MSG_PFC 0x18 /* Pause frame control */
|
||||
#define NIC_MBOX_MSG_PTP_CFG 0x19 /* HW packet timestamp */
|
||||
#define NIC_MBOX_MSG_CFG_DONE 0xF0 /* VF configuration done */
|
||||
#define NIC_MBOX_MSG_SHUTDOWN 0xF1 /* VF is being shutdown */
|
||||
|
||||
|
|
@ -521,6 +551,11 @@ struct pfc {
|
|||
u8 fc_tx;
|
||||
};
|
||||
|
||||
struct set_ptp {
|
||||
u8 msg;
|
||||
bool enable;
|
||||
};
|
||||
|
||||
/* 128 bit shared memory between PF and each VF */
|
||||
union nic_mbx {
|
||||
struct { u8 msg; } msg;
|
||||
|
|
@ -540,6 +575,7 @@ union nic_mbx {
|
|||
struct set_loopback lbk;
|
||||
struct reset_stat_cfg reset_stat;
|
||||
struct pfc pfc;
|
||||
struct set_ptp ptp;
|
||||
};
|
||||
|
||||
#define NIC_NODE_ID_MASK 0x03
|
||||
|
|
|
|||
|
|
@ -426,13 +426,22 @@ static void nic_init_hw(struct nicpf *nic)
|
|||
/* Enable backpressure */
|
||||
nic_reg_write(nic, NIC_PF_BP_CFG, (1ULL << 6) | 0x03);
|
||||
|
||||
/* TNS and TNS bypass modes are present only on 88xx */
|
||||
/* TNS and TNS bypass modes are present only on 88xx
|
||||
* Also offset of this CSR has changed in 81xx and 83xx.
|
||||
*/
|
||||
if (nic->pdev->subsystem_device == PCI_SUBSYS_DEVID_88XX_NIC_PF) {
|
||||
/* Disable TNS mode on both interfaces */
|
||||
nic_reg_write(nic, NIC_PF_INTF_0_1_SEND_CFG,
|
||||
(NIC_TNS_BYPASS_MODE << 7) | BGX0_BLOCK);
|
||||
(NIC_TNS_BYPASS_MODE << 7) |
|
||||
BGX0_BLOCK | (1ULL << 16));
|
||||
nic_reg_write(nic, NIC_PF_INTF_0_1_SEND_CFG | (1 << 8),
|
||||
(NIC_TNS_BYPASS_MODE << 7) | BGX1_BLOCK);
|
||||
(NIC_TNS_BYPASS_MODE << 7) |
|
||||
BGX1_BLOCK | (1ULL << 16));
|
||||
} else {
|
||||
/* Configure timestamp generation timeout to 10us */
|
||||
for (i = 0; i < nic->hw->bgx_cnt; i++)
|
||||
nic_reg_write(nic, NIC_PF_INTFX_SEND_CFG | (i << 3),
|
||||
(1ULL << 16));
|
||||
}
|
||||
|
||||
nic_reg_write(nic, NIC_PF_INTF_0_1_BP_CFG,
|
||||
|
|
@ -880,6 +889,44 @@ static void nic_pause_frame(struct nicpf *nic, int vf, struct pfc *cfg)
|
|||
}
|
||||
}
|
||||
|
||||
/* Enable or disable HW timestamping by BGX for pkts received on a LMAC */
|
||||
static void nic_config_timestamp(struct nicpf *nic, int vf, struct set_ptp *ptp)
|
||||
{
|
||||
struct pkind_cfg *pkind;
|
||||
u8 lmac, bgx_idx;
|
||||
u64 pkind_val, pkind_idx;
|
||||
|
||||
if (vf >= nic->num_vf_en)
|
||||
return;
|
||||
|
||||
bgx_idx = NIC_GET_BGX_FROM_VF_LMAC_MAP(nic->vf_lmac_map[vf]);
|
||||
lmac = NIC_GET_LMAC_FROM_VF_LMAC_MAP(nic->vf_lmac_map[vf]);
|
||||
|
||||
pkind_idx = lmac + bgx_idx * MAX_LMAC_PER_BGX;
|
||||
pkind_val = nic_reg_read(nic, NIC_PF_PKIND_0_15_CFG | (pkind_idx << 3));
|
||||
pkind = (struct pkind_cfg *)&pkind_val;
|
||||
|
||||
if (ptp->enable && !pkind->hdr_sl) {
|
||||
/* Skiplen to exclude 8byte timestamp while parsing pkt
|
||||
* If not configured, will result in L2 errors.
|
||||
*/
|
||||
pkind->hdr_sl = 4;
|
||||
/* Adjust max packet length allowed */
|
||||
pkind->maxlen += (pkind->hdr_sl * 2);
|
||||
bgx_config_timestamping(nic->node, bgx_idx, lmac, true);
|
||||
nic_reg_write(nic, NIC_PF_RX_ETYPE_0_7 | (1 << 3),
|
||||
(ETYPE_ALG_ENDPARSE << 16) | ETH_P_1588);
|
||||
} else if (!ptp->enable && pkind->hdr_sl) {
|
||||
pkind->maxlen -= (pkind->hdr_sl * 2);
|
||||
pkind->hdr_sl = 0;
|
||||
bgx_config_timestamping(nic->node, bgx_idx, lmac, false);
|
||||
nic_reg_write(nic, NIC_PF_RX_ETYPE_0_7 | (1 << 3),
|
||||
(ETYPE_ALG_SKIP << 16) | ETH_P_8021Q);
|
||||
}
|
||||
|
||||
nic_reg_write(nic, NIC_PF_PKIND_0_15_CFG | (pkind_idx << 3), pkind_val);
|
||||
}
|
||||
|
||||
/* Interrupt handler to handle mailbox messages from VFs */
|
||||
static void nic_handle_mbx_intr(struct nicpf *nic, int vf)
|
||||
{
|
||||
|
|
@ -1022,6 +1069,9 @@ static void nic_handle_mbx_intr(struct nicpf *nic, int vf)
|
|||
case NIC_MBOX_MSG_PFC:
|
||||
nic_pause_frame(nic, vf, &mbx.pfc);
|
||||
goto unlock;
|
||||
case NIC_MBOX_MSG_PTP_CFG:
|
||||
nic_config_timestamp(nic, vf, &mbx.ptp);
|
||||
break;
|
||||
default:
|
||||
dev_err(&nic->pdev->dev,
|
||||
"Invalid msg from VF%d, msg 0x%x\n", vf, mbx.msg.msg);
|
||||
|
|
|
|||
|
|
@ -99,6 +99,7 @@
|
|||
#define NIC_PF_ECC3_DBE_INT_W1S (0x2708)
|
||||
#define NIC_PF_ECC3_DBE_ENA_W1C (0x2710)
|
||||
#define NIC_PF_ECC3_DBE_ENA_W1S (0x2718)
|
||||
#define NIC_PF_INTFX_SEND_CFG (0x4000)
|
||||
#define NIC_PF_MCAM_0_191_ENA (0x100000)
|
||||
#define NIC_PF_MCAM_0_191_M_0_5_DATA (0x110000)
|
||||
#define NIC_PF_MCAM_CTRL (0x120000)
|
||||
|
|
|
|||
|
|
@ -9,12 +9,14 @@
|
|||
/* ETHTOOL Support for VNIC_VF Device*/
|
||||
|
||||
#include <linux/pci.h>
|
||||
#include <linux/net_tstamp.h>
|
||||
|
||||
#include "nic_reg.h"
|
||||
#include "nic.h"
|
||||
#include "nicvf_queues.h"
|
||||
#include "q_struct.h"
|
||||
#include "thunder_bgx.h"
|
||||
#include "../common/cavium_ptp.h"
|
||||
|
||||
#define DRV_NAME "thunder-nicvf"
|
||||
#define DRV_VERSION "1.0"
|
||||
|
|
@ -824,6 +826,31 @@ static int nicvf_set_pauseparam(struct net_device *dev,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int nicvf_get_ts_info(struct net_device *netdev,
|
||||
struct ethtool_ts_info *info)
|
||||
{
|
||||
struct nicvf *nic = netdev_priv(netdev);
|
||||
|
||||
if (!nic->ptp_clock)
|
||||
return ethtool_op_get_ts_info(netdev, info);
|
||||
|
||||
info->so_timestamping = SOF_TIMESTAMPING_TX_SOFTWARE |
|
||||
SOF_TIMESTAMPING_RX_SOFTWARE |
|
||||
SOF_TIMESTAMPING_SOFTWARE |
|
||||
SOF_TIMESTAMPING_TX_HARDWARE |
|
||||
SOF_TIMESTAMPING_RX_HARDWARE |
|
||||
SOF_TIMESTAMPING_RAW_HARDWARE;
|
||||
|
||||
info->phc_index = cavium_ptp_clock_index(nic->ptp_clock);
|
||||
|
||||
info->tx_types = (1 << HWTSTAMP_TX_OFF) | (1 << HWTSTAMP_TX_ON);
|
||||
|
||||
info->rx_filters = (1 << HWTSTAMP_FILTER_NONE) |
|
||||
(1 << HWTSTAMP_FILTER_ALL);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static const struct ethtool_ops nicvf_ethtool_ops = {
|
||||
.get_link = nicvf_get_link,
|
||||
.get_drvinfo = nicvf_get_drvinfo,
|
||||
|
|
@ -847,7 +874,7 @@ static const struct ethtool_ops nicvf_ethtool_ops = {
|
|||
.set_channels = nicvf_set_channels,
|
||||
.get_pauseparam = nicvf_get_pauseparam,
|
||||
.set_pauseparam = nicvf_set_pauseparam,
|
||||
.get_ts_info = ethtool_op_get_ts_info,
|
||||
.get_ts_info = nicvf_get_ts_info,
|
||||
.get_link_ksettings = nicvf_get_link_ksettings,
|
||||
};
|
||||
|
||||
|
|
|
|||
|
|
@ -20,11 +20,13 @@
|
|||
#include <linux/bpf.h>
|
||||
#include <linux/bpf_trace.h>
|
||||
#include <linux/filter.h>
|
||||
#include <linux/net_tstamp.h>
|
||||
|
||||
#include "nic_reg.h"
|
||||
#include "nic.h"
|
||||
#include "nicvf_queues.h"
|
||||
#include "thunder_bgx.h"
|
||||
#include "../common/cavium_ptp.h"
|
||||
|
||||
#define DRV_NAME "thunder-nicvf"
|
||||
#define DRV_VERSION "1.0"
|
||||
|
|
@ -602,6 +604,44 @@ static inline bool nicvf_xdp_rx(struct nicvf *nic, struct bpf_prog *prog,
|
|||
return false;
|
||||
}
|
||||
|
||||
static void nicvf_snd_ptp_handler(struct net_device *netdev,
|
||||
struct cqe_send_t *cqe_tx)
|
||||
{
|
||||
struct nicvf *nic = netdev_priv(netdev);
|
||||
struct skb_shared_hwtstamps ts;
|
||||
u64 ns;
|
||||
|
||||
nic = nic->pnicvf;
|
||||
|
||||
/* Sync for 'ptp_skb' */
|
||||
smp_rmb();
|
||||
|
||||
/* New timestamp request can be queued now */
|
||||
atomic_set(&nic->tx_ptp_skbs, 0);
|
||||
|
||||
/* Check for timestamp requested skb */
|
||||
if (!nic->ptp_skb)
|
||||
return;
|
||||
|
||||
/* Check if timestamping is timedout, which is set to 10us */
|
||||
if (cqe_tx->send_status == CQ_TX_ERROP_TSTMP_TIMEOUT ||
|
||||
cqe_tx->send_status == CQ_TX_ERROP_TSTMP_CONFLICT)
|
||||
goto no_tstamp;
|
||||
|
||||
/* Get the timestamp */
|
||||
memset(&ts, 0, sizeof(ts));
|
||||
ns = cavium_ptp_tstamp2time(nic->ptp_clock, cqe_tx->ptp_timestamp);
|
||||
ts.hwtstamp = ns_to_ktime(ns);
|
||||
skb_tstamp_tx(nic->ptp_skb, &ts);
|
||||
|
||||
no_tstamp:
|
||||
/* Free the original skb */
|
||||
dev_kfree_skb_any(nic->ptp_skb);
|
||||
nic->ptp_skb = NULL;
|
||||
/* Sync 'ptp_skb' */
|
||||
smp_wmb();
|
||||
}
|
||||
|
||||
static void nicvf_snd_pkt_handler(struct net_device *netdev,
|
||||
struct cqe_send_t *cqe_tx,
|
||||
int budget, int *subdesc_cnt,
|
||||
|
|
@ -658,7 +698,12 @@ static void nicvf_snd_pkt_handler(struct net_device *netdev,
|
|||
prefetch(skb);
|
||||
(*tx_pkts)++;
|
||||
*tx_bytes += skb->len;
|
||||
napi_consume_skb(skb, budget);
|
||||
/* If timestamp is requested for this skb, don't free it */
|
||||
if (skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS &&
|
||||
!nic->pnicvf->ptp_skb)
|
||||
nic->pnicvf->ptp_skb = skb;
|
||||
else
|
||||
napi_consume_skb(skb, budget);
|
||||
sq->skbuff[cqe_tx->sqe_ptr] = (u64)NULL;
|
||||
} else {
|
||||
/* In case of SW TSO on 88xx, only last segment will have
|
||||
|
|
@ -697,6 +742,21 @@ static inline void nicvf_set_rxhash(struct net_device *netdev,
|
|||
skb_set_hash(skb, hash, hash_type);
|
||||
}
|
||||
|
||||
static inline void nicvf_set_rxtstamp(struct nicvf *nic, struct sk_buff *skb)
|
||||
{
|
||||
u64 ns;
|
||||
|
||||
if (!nic->ptp_clock || !nic->hw_rx_tstamp)
|
||||
return;
|
||||
|
||||
/* The first 8 bytes is the timestamp */
|
||||
ns = cavium_ptp_tstamp2time(nic->ptp_clock,
|
||||
be64_to_cpu(*(__be64 *)skb->data));
|
||||
skb_hwtstamps(skb)->hwtstamp = ns_to_ktime(ns);
|
||||
|
||||
__skb_pull(skb, 8);
|
||||
}
|
||||
|
||||
static void nicvf_rcv_pkt_handler(struct net_device *netdev,
|
||||
struct napi_struct *napi,
|
||||
struct cqe_rx_t *cqe_rx,
|
||||
|
|
@ -748,6 +808,7 @@ static void nicvf_rcv_pkt_handler(struct net_device *netdev,
|
|||
return;
|
||||
}
|
||||
|
||||
nicvf_set_rxtstamp(nic, skb);
|
||||
nicvf_set_rxhash(netdev, cqe_rx, skb);
|
||||
|
||||
skb_record_rx_queue(skb, rq_idx);
|
||||
|
|
@ -823,10 +884,12 @@ static int nicvf_cq_intr_handler(struct net_device *netdev, u8 cq_idx,
|
|||
&tx_pkts, &tx_bytes);
|
||||
tx_done++;
|
||||
break;
|
||||
case CQE_TYPE_SEND_PTP:
|
||||
nicvf_snd_ptp_handler(netdev, (void *)cq_desc);
|
||||
break;
|
||||
case CQE_TYPE_INVALID:
|
||||
case CQE_TYPE_RX_SPLIT:
|
||||
case CQE_TYPE_RX_TCP:
|
||||
case CQE_TYPE_SEND_PTP:
|
||||
/* Ignore for now */
|
||||
break;
|
||||
}
|
||||
|
|
@ -1322,12 +1385,28 @@ int nicvf_stop(struct net_device *netdev)
|
|||
|
||||
nicvf_free_cq_poll(nic);
|
||||
|
||||
/* Free any pending SKB saved to receive timestamp */
|
||||
if (nic->ptp_skb) {
|
||||
dev_kfree_skb_any(nic->ptp_skb);
|
||||
nic->ptp_skb = NULL;
|
||||
}
|
||||
|
||||
/* Clear multiqset info */
|
||||
nic->pnicvf = nic;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int nicvf_config_hw_rx_tstamp(struct nicvf *nic, bool enable)
|
||||
{
|
||||
union nic_mbx mbx = {};
|
||||
|
||||
mbx.ptp.msg = NIC_MBOX_MSG_PTP_CFG;
|
||||
mbx.ptp.enable = enable;
|
||||
|
||||
return nicvf_send_msg_to_pf(nic, &mbx);
|
||||
}
|
||||
|
||||
static int nicvf_update_hw_max_frs(struct nicvf *nic, int mtu)
|
||||
{
|
||||
union nic_mbx mbx = {};
|
||||
|
|
@ -1397,6 +1476,12 @@ int nicvf_open(struct net_device *netdev)
|
|||
if (nic->sqs_mode)
|
||||
nicvf_get_primary_vf_struct(nic);
|
||||
|
||||
/* Configure PTP timestamp */
|
||||
if (nic->ptp_clock)
|
||||
nicvf_config_hw_rx_tstamp(nic, nic->hw_rx_tstamp);
|
||||
atomic_set(&nic->tx_ptp_skbs, 0);
|
||||
nic->ptp_skb = NULL;
|
||||
|
||||
/* Configure receive side scaling and MTU */
|
||||
if (!nic->sqs_mode) {
|
||||
nicvf_rss_init(nic);
|
||||
|
|
@ -1823,6 +1908,73 @@ static void nicvf_xdp_flush(struct net_device *dev)
|
|||
return;
|
||||
}
|
||||
|
||||
static int nicvf_config_hwtstamp(struct net_device *netdev, struct ifreq *ifr)
|
||||
{
|
||||
struct hwtstamp_config config;
|
||||
struct nicvf *nic = netdev_priv(netdev);
|
||||
|
||||
if (!nic->ptp_clock)
|
||||
return -ENODEV;
|
||||
|
||||
if (copy_from_user(&config, ifr->ifr_data, sizeof(config)))
|
||||
return -EFAULT;
|
||||
|
||||
/* reserved for future extensions */
|
||||
if (config.flags)
|
||||
return -EINVAL;
|
||||
|
||||
switch (config.tx_type) {
|
||||
case HWTSTAMP_TX_OFF:
|
||||
case HWTSTAMP_TX_ON:
|
||||
break;
|
||||
default:
|
||||
return -ERANGE;
|
||||
}
|
||||
|
||||
switch (config.rx_filter) {
|
||||
case HWTSTAMP_FILTER_NONE:
|
||||
nic->hw_rx_tstamp = false;
|
||||
break;
|
||||
case HWTSTAMP_FILTER_ALL:
|
||||
case HWTSTAMP_FILTER_SOME:
|
||||
case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
|
||||
case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
|
||||
case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
|
||||
case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
|
||||
case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
|
||||
case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
|
||||
case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
|
||||
case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
|
||||
case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
|
||||
case HWTSTAMP_FILTER_PTP_V2_EVENT:
|
||||
case HWTSTAMP_FILTER_PTP_V2_SYNC:
|
||||
case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
|
||||
nic->hw_rx_tstamp = true;
|
||||
config.rx_filter = HWTSTAMP_FILTER_ALL;
|
||||
break;
|
||||
default:
|
||||
return -ERANGE;
|
||||
}
|
||||
|
||||
if (netif_running(netdev))
|
||||
nicvf_config_hw_rx_tstamp(nic, nic->hw_rx_tstamp);
|
||||
|
||||
if (copy_to_user(ifr->ifr_data, &config, sizeof(config)))
|
||||
return -EFAULT;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int nicvf_ioctl(struct net_device *netdev, struct ifreq *req, int cmd)
|
||||
{
|
||||
switch (cmd) {
|
||||
case SIOCSHWTSTAMP:
|
||||
return nicvf_config_hwtstamp(netdev, req);
|
||||
default:
|
||||
return -EOPNOTSUPP;
|
||||
}
|
||||
}
|
||||
|
||||
static const struct net_device_ops nicvf_netdev_ops = {
|
||||
.ndo_open = nicvf_open,
|
||||
.ndo_stop = nicvf_stop,
|
||||
|
|
@ -1836,6 +1988,7 @@ static const struct net_device_ops nicvf_netdev_ops = {
|
|||
.ndo_bpf = nicvf_xdp,
|
||||
.ndo_xdp_xmit = nicvf_xdp_xmit,
|
||||
.ndo_xdp_flush = nicvf_xdp_flush,
|
||||
.ndo_do_ioctl = nicvf_ioctl,
|
||||
};
|
||||
|
||||
static int nicvf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
|
||||
|
|
@ -1845,6 +1998,16 @@ static int nicvf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
|
|||
struct nicvf *nic;
|
||||
int err, qcount;
|
||||
u16 sdevid;
|
||||
struct cavium_ptp *ptp_clock;
|
||||
|
||||
ptp_clock = cavium_ptp_get();
|
||||
if (IS_ERR(ptp_clock)) {
|
||||
if (PTR_ERR(ptp_clock) == -ENODEV)
|
||||
/* In virtualized environment we proceed without ptp */
|
||||
ptp_clock = NULL;
|
||||
else
|
||||
return PTR_ERR(ptp_clock);
|
||||
}
|
||||
|
||||
err = pci_enable_device(pdev);
|
||||
if (err) {
|
||||
|
|
@ -1899,6 +2062,7 @@ static int nicvf_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
|
|||
*/
|
||||
if (!nic->t88)
|
||||
nic->max_queues *= 2;
|
||||
nic->ptp_clock = ptp_clock;
|
||||
|
||||
/* MAP VF's configuration registers */
|
||||
nic->reg_base = pcim_iomap(pdev, PCI_CFG_REG_BAR_NUM, 0);
|
||||
|
|
@ -2012,6 +2176,7 @@ static void nicvf_remove(struct pci_dev *pdev)
|
|||
pci_set_drvdata(pdev, NULL);
|
||||
if (nic->drv_stats)
|
||||
free_percpu(nic->drv_stats);
|
||||
cavium_ptp_put(nic->ptp_clock);
|
||||
free_netdev(netdev);
|
||||
pci_release_regions(pdev);
|
||||
pci_disable_device(pdev);
|
||||
|
|
|
|||
|
|
@ -982,6 +982,9 @@ void nicvf_qset_config(struct nicvf *nic, bool enable)
|
|||
qs_cfg->be = 1;
|
||||
#endif
|
||||
qs_cfg->vnic = qs->vnic_id;
|
||||
/* Enable Tx timestamping capability */
|
||||
if (nic->ptp_clock)
|
||||
qs_cfg->send_tstmp_ena = 1;
|
||||
}
|
||||
nicvf_send_msg_to_pf(nic, &mbx);
|
||||
}
|
||||
|
|
@ -1389,6 +1392,29 @@ nicvf_sq_add_hdr_subdesc(struct nicvf *nic, struct snd_queue *sq, int qentry,
|
|||
hdr->inner_l3_offset = skb_network_offset(skb) - 2;
|
||||
this_cpu_inc(nic->pnicvf->drv_stats->tx_tso);
|
||||
}
|
||||
|
||||
/* Check if timestamp is requested */
|
||||
if (!(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP)) {
|
||||
skb_tx_timestamp(skb);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Tx timestamping not supported along with TSO, so ignore request */
|
||||
if (skb_shinfo(skb)->gso_size)
|
||||
return;
|
||||
|
||||
/* HW supports only a single outstanding packet to timestamp */
|
||||
if (!atomic_add_unless(&nic->pnicvf->tx_ptp_skbs, 1, 1))
|
||||
return;
|
||||
|
||||
/* Mark the SKB for later reference */
|
||||
skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
|
||||
|
||||
/* Finally enable timestamp generation
|
||||
* Since 'post_cqe' is also set, two CQEs will be posted
|
||||
* for this packet i.e CQE_TYPE_SEND and CQE_TYPE_SEND_PTP.
|
||||
*/
|
||||
hdr->tstmp = 1;
|
||||
}
|
||||
|
||||
/* SQ GATHER subdescriptor
|
||||
|
|
|
|||
|
|
@ -245,6 +245,35 @@ void bgx_lmac_rx_tx_enable(int node, int bgx_idx, int lmacid, bool enable)
|
|||
}
|
||||
EXPORT_SYMBOL(bgx_lmac_rx_tx_enable);
|
||||
|
||||
/* Enables or disables timestamp insertion by BGX for Rx packets */
|
||||
void bgx_config_timestamping(int node, int bgx_idx, int lmacid, bool enable)
|
||||
{
|
||||
struct bgx *bgx = get_bgx(node, bgx_idx);
|
||||
struct lmac *lmac;
|
||||
u64 csr_offset, cfg;
|
||||
|
||||
if (!bgx)
|
||||
return;
|
||||
|
||||
lmac = &bgx->lmac[lmacid];
|
||||
|
||||
if (lmac->lmac_type == BGX_MODE_SGMII ||
|
||||
lmac->lmac_type == BGX_MODE_QSGMII ||
|
||||
lmac->lmac_type == BGX_MODE_RGMII)
|
||||
csr_offset = BGX_GMP_GMI_RXX_FRM_CTL;
|
||||
else
|
||||
csr_offset = BGX_SMUX_RX_FRM_CTL;
|
||||
|
||||
cfg = bgx_reg_read(bgx, lmacid, csr_offset);
|
||||
|
||||
if (enable)
|
||||
cfg |= BGX_PKT_RX_PTP_EN;
|
||||
else
|
||||
cfg &= ~BGX_PKT_RX_PTP_EN;
|
||||
bgx_reg_write(bgx, lmacid, csr_offset, cfg);
|
||||
}
|
||||
EXPORT_SYMBOL(bgx_config_timestamping);
|
||||
|
||||
void bgx_lmac_get_pfc(int node, int bgx_idx, int lmacid, void *pause)
|
||||
{
|
||||
struct pfc *pfc = (struct pfc *)pause;
|
||||
|
|
|
|||
|
|
@ -122,6 +122,8 @@
|
|||
#define SPU_DBG_CTL_AN_NONCE_MCT_DIS BIT_ULL(29)
|
||||
|
||||
#define BGX_SMUX_RX_INT 0x20000
|
||||
#define BGX_SMUX_RX_FRM_CTL 0x20020
|
||||
#define BGX_PKT_RX_PTP_EN BIT_ULL(12)
|
||||
#define BGX_SMUX_RX_JABBER 0x20030
|
||||
#define BGX_SMUX_RX_CTL 0x20048
|
||||
#define SMU_RX_CTL_STATUS (3ull << 0)
|
||||
|
|
@ -172,6 +174,7 @@
|
|||
#define GMI_PORT_CFG_SPEED_MSB BIT_ULL(8)
|
||||
#define GMI_PORT_CFG_RX_IDLE BIT_ULL(12)
|
||||
#define GMI_PORT_CFG_TX_IDLE BIT_ULL(13)
|
||||
#define BGX_GMP_GMI_RXX_FRM_CTL 0x38028
|
||||
#define BGX_GMP_GMI_RXX_JABBER 0x38038
|
||||
#define BGX_GMP_GMI_TXX_THRESH 0x38210
|
||||
#define BGX_GMP_GMI_TXX_APPEND 0x38218
|
||||
|
|
@ -223,6 +226,7 @@ void bgx_set_lmac_mac(int node, int bgx_idx, int lmacid, const u8 *mac);
|
|||
void bgx_get_lmac_link_state(int node, int bgx_idx, int lmacid, void *status);
|
||||
void bgx_lmac_internal_loopback(int node, int bgx_idx,
|
||||
int lmac_idx, bool enable);
|
||||
void bgx_config_timestamping(int node, int bgx_idx, int lmacid, bool enable);
|
||||
void bgx_lmac_get_pfc(int node, int bgx_idx, int lmacid, void *pause);
|
||||
void bgx_lmac_set_pfc(int node, int bgx_idx, int lmacid, void *pause);
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue