* [PATCH net-next V3 0/2] igb: ptp hardware clock
@ 2012-01-07 19:38 Richard Cochran
2012-01-07 19:38 ` [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code Richard Cochran
` (2 more replies)
0 siblings, 3 replies; 10+ messages in thread
From: Richard Cochran @ 2012-01-07 19:38 UTC (permalink / raw)
To: netdev
Cc: e1000-devel, John Ronciak, John Stultz, Jacob Keller,
Thomas Gleixner
* ChangeLog
** V3
- Driver compiles even without CONFIG_PTP_1588_CLOCK.
- Timestamping always works, even when PTP code missing or fails.
** V2
- Fixed wrong bit shifting in the 82576 code.
- Explained the timestamp locking with a comment in the code.
- Preserved the comments from the original timecompare implementation.
- Added an additional test within the overflow counter code to fix
a race condition. Details of the problem are given in the commit
message.
This patch series implements a PHC driver for the Intel 82576 and
82580 devices, as part of the igb driver.
The first patch adds the PHC driver code as a new source module but
does not link it into the main igb driver. Because the system time
counter is not so very wide, the code implements an overflow counter
in software. Every read operation maintains the overflow counter, as
does a "delayed work" watchdog. Only the base clock operations are
implemented. The hardware does have some ancillary features, but these
can be easily added later.
The second patch removes the timecompare code and links in the new
functions.
I have tested the 82580 with good results. However, I don't have the
82576 and so would appreciate testing and feedback.
Thanks,
Richard
Richard Cochran (2):
igb: add PTP Hardware Clock code
igb: offer a PTP Hardware Clock instead of the timecompare method
drivers/net/ethernet/intel/igb/Makefile | 2 +-
drivers/net/ethernet/intel/igb/igb.h | 21 +-
drivers/net/ethernet/intel/igb/igb_main.c | 167 +----------
drivers/net/ethernet/intel/igb/igb_ptp.c | 493 +++++++++++++++++++++++++++++
4 files changed, 512 insertions(+), 171 deletions(-)
create mode 100644 drivers/net/ethernet/intel/igb/igb_ptp.c
--
1.7.2.5
------------------------------------------------------------------------------
Ridiculously easy VDI. With Citrix VDI-in-a-Box, you don't need a complex
infrastructure or vast IT resources to deliver seamless, secure access to
virtual desktops. With this all-in-one solution, easily deploy virtual
desktops for less than the cost of PCs and save 60% on VDI infrastructure
costs. Try it free! http://p.sf.net/sfu/Citrix-VDIinabox
_______________________________________________
E1000-devel mailing list
E1000-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/e1000-devel
To learn more about Intel® Ethernet, visit http://communities.intel.com/community/wired
^ permalink raw reply [flat|nested] 10+ messages in thread
* [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code
2012-01-07 19:38 [PATCH net-next V3 0/2] igb: ptp hardware clock Richard Cochran
@ 2012-01-07 19:38 ` Richard Cochran
2012-01-09 17:42 ` Keller, Jacob E
2012-01-07 19:38 ` [PATCH net-next V3 2/2] igb: offer a PTP Hardware Clock instead of the timecompare method Richard Cochran
2012-01-08 1:02 ` [PATCH net-next V3 0/2] igb: ptp hardware clock Jeff Kirsher
2 siblings, 1 reply; 10+ messages in thread
From: Richard Cochran @ 2012-01-07 19:38 UTC (permalink / raw)
To: netdev
Cc: e1000-devel, John Ronciak, John Stultz, Jacob Keller,
Thomas Gleixner
This patch adds a source file implementing a PHC. Only the basic
clock operations have been implemented, although the hardware
would offer some ancillary functions. The code is fairly self
contained and is not yet used in the main igb driver.
Every timestamp and clock read operation must consult the overflow
counter to form a correct time value. Access to the counter is
protected by a spin lock, and this would be sufficient, assuming that
the time values are monotonic.
However, this assumption does not hold in general. Consider the
following sequence.
1. Hardware latches a receive timestamp (just before counter overflow).
2. User calls clock_gettime() (just after counter overflow).
3. User takes lock, detects 1-0 transition, and increments overflow count.
4. Driver takes lock, incorrectly combines overflow count with timestamp.
A very similar race condition exists between two nearly simultaneous
hardware timestamps.
The implementation detects this race by checking the two most
significant bits for a transition from 11b to 00b. When this pattern
is detected, the code uses the previous value of the overflow count.
The two most significant bits divide the overflow period into four
regions, and so the watchdog timeout is set to sample the counter at
just over four times per period.
Signed-off-by: Richard Cochran <richardcochran@gmail.com>
---
drivers/net/ethernet/intel/igb/igb.h | 8 +
drivers/net/ethernet/intel/igb/igb_ptp.c | 427 ++++++++++++++++++++++++++++++
2 files changed, 435 insertions(+), 0 deletions(-)
create mode 100644 drivers/net/ethernet/intel/igb/igb_ptp.c
diff --git a/drivers/net/ethernet/intel/igb/igb.h b/drivers/net/ethernet/intel/igb/igb.h
index c69feeb..f30458d 100644
--- a/drivers/net/ethernet/intel/igb/igb.h
+++ b/drivers/net/ethernet/intel/igb/igb.h
@@ -37,6 +37,7 @@
#include <linux/clocksource.h>
#include <linux/timecompare.h>
#include <linux/net_tstamp.h>
+#include <linux/ptp_clock_kernel.h>
#include <linux/bitops.h>
#include <linux/if_vlan.h>
@@ -364,6 +365,13 @@ struct igb_adapter {
u32 wvbr;
int node;
u32 *shadow_vfta;
+
+ struct ptp_clock *ptp_clock;
+ struct ptp_clock_info caps;
+ struct delayed_work overflow_work;
+ spinlock_t tmreg_lock;
+ u32 overflow_counter;
+ unsigned int last_msb;
};
#define IGB_FLAG_HAS_MSI (1 << 0)
diff --git a/drivers/net/ethernet/intel/igb/igb_ptp.c b/drivers/net/ethernet/intel/igb/igb_ptp.c
new file mode 100644
index 0000000..dd27be1
--- /dev/null
+++ b/drivers/net/ethernet/intel/igb/igb_ptp.c
@@ -0,0 +1,427 @@
+/*
+ * PTP Hardware Clock (PHC) driver for the Intel 82576 and 82580
+ *
+ * Copyright (C) 2011 Richard Cochran <richardcochran@gmail.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.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+#include <linux/device.h>
+#include <linux/pci.h>
+
+#include "igb.h"
+
+#define INCVALUE_MASK 0x7fffffff
+#define ISGN 0x80000000
+
+/*
+ * Neither the 82576 nor the 82580 offer registers wide enough to hold
+ * nanoseconds time values for very long. For the 82580, SYSTIM always
+ * counts nanoseconds, but the upper 24 bits are not availible. The
+ * frequency is adjusted by changing the 32 bit fractional nanoseconds
+ * register, TIMINCA.
+ *
+ * For the 82576, the SYSTIM register time unit is affect by the
+ * choice of the 24 bit TININCA:IV (incvalue) field. Five bits of this
+ * field are needed to provide the nominal 16 nanosecond period,
+ * leaving 19 bits for fractional nanoseconds.
+ *
+ *
+ * SYSTIMH SYSTIML
+ * +--------------+ +---+---+------+
+ * 82576 | 32 | | 8 | 5 | 19 |
+ * +--------------+ +---+---+------+
+ * \________ 45 bits _______/ fract
+ *
+ * +----------+---+ +--------------+
+ * 82580 | 24 | 8 | | 32 |
+ * +----------+---+ +--------------+
+ * reserved \______ 40 bits _____/
+ *
+ *
+ * The 45 bit 82576 SYSTIM overflows every
+ * 2^45 * 10^-9 / 3600 = 9.77 hours.
+ *
+ * The 40 bit 82580 SYSTIM overflows every
+ * 2^40 * 10^-9 / 60 = 18.3 minutes.
+ *
+ * We implement a 32 bit overflow counter in software to hold the
+ * missing 19 or 24 bits, for a combined virtual nanosecond time
+ * register of 64 bits.
+ */
+
+#define IGB_OVERFLOW_PERIOD (HZ * 60 * 4)
+#define INCPERIOD_82576 (1 << E1000_TIMINCA_16NS_SHIFT)
+#define INCVALUE_82576_MASK ((1 << E1000_TIMINCA_16NS_SHIFT) - 1)
+#define INCVALUE_82576 (16 << IGB_82576_TSYNC_SHIFT)
+#define OFL_SHIFT_82580 40
+#define OFL_SHIFT_82576 45
+#define NS_SHIFT_82576 IGB_82576_TSYNC_SHIFT
+
+/*
+ * Overflow counter for the SYSTIM register.
+ */
+
+static u64 igb_overflow_get(struct igb_adapter *igb, u64 low, unsigned int nbit)
+{
+ unsigned int msb_set = (low >> (nbit - 2)) & 0x3;
+
+ if (msb_set == 0x3 && igb->last_msb == 0x0) {
+ /*
+ * This time stamp was taken before the last overflow,
+ * but it lost the race to read the overflow counter.
+ * Therefore, we just use the previous overflow value.
+ */
+ low |= ((u64) igb->overflow_counter - 1ULL) << nbit;
+ return low;
+ }
+
+ /*
+ * Test for a one to zero transition of the most significant
+ * bit, and increment the overflow counter.
+ */
+ if ((igb->last_msb & 0x2) && !(msb_set & 0x2))
+ igb->overflow_counter++;
+
+ igb->last_msb = msb_set;
+
+ low |= ((u64) igb->overflow_counter) << nbit;
+
+ return low;
+}
+
+static void igb_overflow_set(struct igb_adapter *igb, u64 ns, unsigned int nbit)
+{
+ igb->overflow_counter = ns >> nbit;
+ igb->last_msb = (ns >> (nbit - 2)) & 0x3;
+}
+
+/*
+ * SYSTIM / overflow access functions for the 82576
+ */
+
+static u64 igb_82576_systim_read(struct igb_adapter *igb)
+{
+ u64 ns;
+ u32 lo, hi;
+ struct e1000_hw *hw = &igb->hw;
+
+ lo = rd32(E1000_SYSTIML);
+ hi = rd32(E1000_SYSTIMH);
+
+ ns = ((u64) hi) << 32;
+ ns |= lo;
+ ns >>= NS_SHIFT_82576;
+
+ ns = igb_overflow_get(igb, ns, OFL_SHIFT_82576);
+
+ return ns;
+}
+
+static void igb_82576_systim_write(struct igb_adapter *igb, u64 ns)
+{
+ u32 hi, lo;
+ struct e1000_hw *hw = &igb->hw;
+
+ hi = (ns >> 13) & 0xffffffff;
+ lo = (ns & 0x1fff) << NS_SHIFT_82576;
+
+ wr32(E1000_SYSTIML, lo);
+ wr32(E1000_SYSTIMH, hi);
+
+ igb_overflow_set(igb, ns, OFL_SHIFT_82576);
+}
+
+/*
+ * SYSTIM / overflow access functions for the 82580
+ */
+
+static u64 igb_82580_systim_read(struct igb_adapter *igb)
+{
+ u64 ns;
+ u32 lo, hi, jk;
+ struct e1000_hw *hw = &igb->hw;
+
+ jk = rd32(E1000_SYSTIMR);
+ lo = rd32(E1000_SYSTIML);
+ hi = rd32(E1000_SYSTIMH);
+
+ ns = ((u64) hi) << 32;
+ ns |= lo;
+
+ ns = igb_overflow_get(igb, ns, OFL_SHIFT_82580);
+
+ return ns;
+}
+
+static void igb_82580_systim_write(struct igb_adapter *igb, u64 ns)
+{
+ u32 hi, lo;
+ struct e1000_hw *hw = &igb->hw;
+
+ hi = ns >> 32;
+ lo = ns & 0xffffffff;
+
+ wr32(E1000_SYSTIMR, 0);
+ wr32(E1000_SYSTIML, lo);
+ wr32(E1000_SYSTIMH, hi & 0xff);
+
+ igb_overflow_set(igb, ns, OFL_SHIFT_82580);
+}
+
+/*
+ * SYSTIM / overflow register access functions
+ * Callers must hold tmreg_lock.
+ */
+
+static u64 igb_systim_read(struct igb_adapter *igb)
+{
+ switch (igb->hw.mac.type) {
+ case e1000_i350:
+ case e1000_82580:
+ return igb_82580_systim_read(igb);
+ case e1000_82576:
+ return igb_82576_systim_read(igb);
+ default:
+ return 0;
+ }
+}
+
+static void igb_systim_write(struct igb_adapter *igb, u64 ns)
+{
+ switch (igb->hw.mac.type) {
+ case e1000_i350:
+ case e1000_82580:
+ igb_82580_systim_write(igb, ns);
+ break;
+ case e1000_82576:
+ igb_82576_systim_write(igb, ns);
+ break;
+ default:
+ break;
+ }
+}
+
+/*
+ * PTP clock operations
+ */
+
+static int ptp_82576_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
+{
+ u64 rate;
+ u32 incvalue;
+ int neg_adj = 0;
+ struct igb_adapter *igb = container_of(ptp, struct igb_adapter, caps);
+ struct e1000_hw *hw = &igb->hw;
+
+ if (ppb < 0) {
+ neg_adj = 1;
+ ppb = -ppb;
+ }
+ rate = ppb;
+ rate <<= 14;
+ rate = div_u64(rate, 1953125);
+
+ incvalue = 16 << IGB_82576_TSYNC_SHIFT;
+
+ if (neg_adj)
+ incvalue -= rate;
+ else
+ incvalue += rate;
+
+ wr32(E1000_TIMINCA, INCPERIOD_82576 | (incvalue & INCVALUE_82576_MASK));
+
+ return 0;
+}
+
+static int ptp_82580_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
+{
+ u64 rate;
+ u32 inca;
+ int neg_adj = 0;
+ struct igb_adapter *igb = container_of(ptp, struct igb_adapter, caps);
+ struct e1000_hw *hw = &igb->hw;
+
+ if (ppb < 0) {
+ neg_adj = 1;
+ ppb = -ppb;
+ }
+ rate = ppb;
+ rate <<= 26;
+ rate = div_u64(rate, 1953125);
+
+ inca = rate & INCVALUE_MASK;
+ if (neg_adj)
+ inca |= ISGN;
+
+ wr32(E1000_TIMINCA, inca);
+
+ return 0;
+}
+
+static int igb_adjtime(struct ptp_clock_info *ptp, s64 delta)
+{
+ s64 now;
+ unsigned long flags;
+ struct igb_adapter *igb = container_of(ptp, struct igb_adapter, caps);
+
+ spin_lock_irqsave(&igb->tmreg_lock, flags);
+
+ now = igb_systim_read(igb);
+ now += delta;
+ igb_systim_write(igb, now);
+
+ spin_unlock_irqrestore(&igb->tmreg_lock, flags);
+
+ return 0;
+}
+
+static int igb_gettime(struct ptp_clock_info *ptp, struct timespec *ts)
+{
+ u64 ns;
+ u32 remainder;
+ unsigned long flags;
+ struct igb_adapter *igb = container_of(ptp, struct igb_adapter, caps);
+
+ spin_lock_irqsave(&igb->tmreg_lock, flags);
+
+ ns = igb_systim_read(igb);
+
+ spin_unlock_irqrestore(&igb->tmreg_lock, flags);
+
+ ts->tv_sec = div_u64_rem(ns, 1000000000, &remainder);
+ ts->tv_nsec = remainder;
+
+ return 0;
+}
+
+static int igb_settime(struct ptp_clock_info *ptp, const struct timespec *ts)
+{
+ u64 ns;
+ unsigned long flags;
+ struct igb_adapter *igb = container_of(ptp, struct igb_adapter, caps);
+
+ ns = ts->tv_sec * 1000000000ULL;
+ ns += ts->tv_nsec;
+
+ spin_lock_irqsave(&igb->tmreg_lock, flags);
+
+ igb_systim_write(igb, ns);
+
+ spin_unlock_irqrestore(&igb->tmreg_lock, flags);
+
+ return 0;
+}
+
+static int ptp_82576_enable(struct ptp_clock_info *ptp,
+ struct ptp_clock_request *rq, int on)
+{
+ return -EOPNOTSUPP;
+}
+
+static int ptp_82580_enable(struct ptp_clock_info *ptp,
+ struct ptp_clock_request *rq, int on)
+{
+ return -EOPNOTSUPP;
+}
+
+static void igb_overflow_check(struct work_struct *work)
+{
+ struct timespec ts;
+ struct igb_adapter *igb =
+ container_of(work, struct igb_adapter, overflow_work.work);
+
+ igb_gettime(&igb->caps, &ts);
+
+ pr_debug("igb overflow check at %ld.%09lu\n", ts.tv_sec, ts.tv_nsec);
+
+ schedule_delayed_work(&igb->overflow_work, IGB_OVERFLOW_PERIOD);
+}
+
+void igb_ptp_init(struct igb_adapter *adapter)
+{
+ struct e1000_hw *hw = &adapter->hw;
+
+ switch (hw->mac.type) {
+ case e1000_i350:
+ case e1000_82580:
+ adapter->caps.owner = THIS_MODULE;
+ strcpy(adapter->caps.name, "igb-82580");
+ adapter->caps.max_adj = 62499999;
+ adapter->caps.n_ext_ts = 0;
+ adapter->caps.pps = 0;
+ adapter->caps.adjfreq = ptp_82580_adjfreq;
+ adapter->caps.adjtime = igb_adjtime;
+ adapter->caps.gettime = igb_gettime;
+ adapter->caps.settime = igb_settime;
+ adapter->caps.enable = ptp_82580_enable;
+ /* Enable the timer functions by clearing bit 31. */
+ wr32(E1000_TSAUXC, 0x0);
+ break;
+
+ case e1000_82576:
+ adapter->caps.owner = THIS_MODULE;
+ strcpy(adapter->caps.name, "igb-82576");
+ adapter->caps.max_adj = 1000000000;
+ adapter->caps.n_ext_ts = 0;
+ adapter->caps.pps = 0;
+ adapter->caps.adjfreq = ptp_82576_adjfreq;
+ adapter->caps.adjtime = igb_adjtime;
+ adapter->caps.gettime = igb_gettime;
+ adapter->caps.settime = igb_settime;
+ adapter->caps.enable = ptp_82576_enable;
+ /* Dial the nominal frequency. */
+ wr32(E1000_TIMINCA, INCPERIOD_82576 | INCVALUE_82576);
+ break;
+
+ default:
+ adapter->ptp_clock = NULL;
+ return;
+ }
+
+ wrfl();
+
+ INIT_DELAYED_WORK(&adapter->overflow_work, igb_overflow_check);
+
+ spin_lock_init(&adapter->tmreg_lock);
+
+ schedule_delayed_work(&adapter->overflow_work, IGB_OVERFLOW_PERIOD);
+
+#ifdef CONFIG_PTP_1588_CLOCK
+
+ adapter->ptp_clock = ptp_clock_register(&adapter->caps);
+ if (IS_ERR(adapter->ptp_clock)) {
+ adapter->ptp_clock = NULL;
+ dev_err(&adapter->pdev->dev, "ptp_clock_register failed\n");
+ } else
+ dev_info(&adapter->pdev->dev, "added PHC on %s\n",
+ adapter->netdev->name);
+
+#endif /*CONFIG_PTP_1588_CLOCK*/
+}
+
+void igb_ptp_remove(struct igb_adapter *adapter)
+{
+ cancel_delayed_work_sync(&adapter->overflow_work);
+
+#ifdef CONFIG_PTP_1588_CLOCK
+
+ if (adapter->ptp_clock) {
+ ptp_clock_unregister(adapter->ptp_clock);
+ dev_info(&adapter->pdev->dev, "removed PHC on %s\n",
+ adapter->netdev->name);
+ }
+
+#endif /*CONFIG_PTP_1588_CLOCK*/
+}
--
1.7.2.5
------------------------------------------------------------------------------
Ridiculously easy VDI. With Citrix VDI-in-a-Box, you don't need a complex
infrastructure or vast IT resources to deliver seamless, secure access to
virtual desktops. With this all-in-one solution, easily deploy virtual
desktops for less than the cost of PCs and save 60% on VDI infrastructure
costs. Try it free! http://p.sf.net/sfu/Citrix-VDIinabox
_______________________________________________
E1000-devel mailing list
E1000-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/e1000-devel
To learn more about Intel® Ethernet, visit http://communities.intel.com/community/wired
^ permalink raw reply related [flat|nested] 10+ messages in thread
* [PATCH net-next V3 2/2] igb: offer a PTP Hardware Clock instead of the timecompare method
2012-01-07 19:38 [PATCH net-next V3 0/2] igb: ptp hardware clock Richard Cochran
2012-01-07 19:38 ` [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code Richard Cochran
@ 2012-01-07 19:38 ` Richard Cochran
2012-01-08 1:02 ` [PATCH net-next V3 0/2] igb: ptp hardware clock Jeff Kirsher
2 siblings, 0 replies; 10+ messages in thread
From: Richard Cochran @ 2012-01-07 19:38 UTC (permalink / raw)
To: netdev
Cc: e1000-devel, John Ronciak, John Stultz, Jacob Keller,
Thomas Gleixner
This commit removes the legacy timecompare code from the igb driver and
offers a tunable PHC instead.
Signed-off-by: Richard Cochran <richardcochran@gmail.com>
---
drivers/net/ethernet/intel/igb/Makefile | 2 +-
drivers/net/ethernet/intel/igb/igb.h | 13 ++-
drivers/net/ethernet/intel/igb/igb_main.c | 167 +----------------------------
drivers/net/ethernet/intel/igb/igb_ptp.c | 66 +++++++++++
4 files changed, 77 insertions(+), 171 deletions(-)
diff --git a/drivers/net/ethernet/intel/igb/Makefile b/drivers/net/ethernet/intel/igb/Makefile
index c6e4621..42f0868 100644
--- a/drivers/net/ethernet/intel/igb/Makefile
+++ b/drivers/net/ethernet/intel/igb/Makefile
@@ -32,6 +32,6 @@
obj-$(CONFIG_IGB) += igb.o
-igb-objs := igb_main.o igb_ethtool.o e1000_82575.o \
+igb-objs := igb_main.o igb_ethtool.o igb_ptp.o e1000_82575.o \
e1000_mac.o e1000_nvm.o e1000_phy.o e1000_mbx.o
diff --git a/drivers/net/ethernet/intel/igb/igb.h b/drivers/net/ethernet/intel/igb/igb.h
index f30458d..d554d83 100644
--- a/drivers/net/ethernet/intel/igb/igb.h
+++ b/drivers/net/ethernet/intel/igb/igb.h
@@ -34,8 +34,6 @@
#include "e1000_mac.h"
#include "e1000_82575.h"
-#include <linux/clocksource.h>
-#include <linux/timecompare.h>
#include <linux/net_tstamp.h>
#include <linux/ptp_clock_kernel.h>
#include <linux/bitops.h>
@@ -329,9 +327,6 @@ struct igb_adapter {
/* OS defined structs */
struct pci_dev *pdev;
- struct cyclecounter cycles;
- struct timecounter clock;
- struct timecompare compare;
struct hwtstamp_config hwtstamp_config;
spinlock_t stats64_lock;
@@ -386,7 +381,6 @@ struct igb_adapter {
#define IGB_DMCTLX_DCFLUSH_DIS 0x80000000 /* Disable DMA Coal Flush */
#define IGB_82576_TSYNC_SHIFT 19
-#define IGB_82580_TSYNC_SHIFT 24
#define IGB_TS_HDR_LEN 16
enum e1000_state_t {
__IGB_TESTING,
@@ -423,6 +417,13 @@ extern bool igb_has_link(struct igb_adapter *adapter);
extern void igb_set_ethtool_ops(struct net_device *);
extern void igb_power_up_link(struct igb_adapter *);
+extern void igb_ptp_init(struct igb_adapter *adapter);
+extern void igb_ptp_remove(struct igb_adapter *adapter);
+
+extern void igb_systim_to_hwtstamp(struct igb_adapter *adapter,
+ struct skb_shared_hwtstamps *hwtstamps,
+ u64 systim);
+
static inline s32 igb_reset_phy(struct e1000_hw *hw)
{
if (hw->phy.ops.reset)
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index 89d576c..0ee04b9 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -113,7 +113,6 @@ static void igb_free_all_rx_resources(struct igb_adapter *);
static void igb_setup_mrqc(struct igb_adapter *);
static int igb_probe(struct pci_dev *, const struct pci_device_id *);
static void __devexit igb_remove(struct pci_dev *pdev);
-static void igb_init_hw_timer(struct igb_adapter *adapter);
static int igb_sw_init(struct igb_adapter *);
static int igb_open(struct net_device *);
static int igb_close(struct net_device *);
@@ -549,33 +548,6 @@ exit:
return;
}
-
-/**
- * igb_read_clock - read raw cycle counter (to be used by time counter)
- */
-static cycle_t igb_read_clock(const struct cyclecounter *tc)
-{
- struct igb_adapter *adapter =
- container_of(tc, struct igb_adapter, cycles);
- struct e1000_hw *hw = &adapter->hw;
- u64 stamp = 0;
- int shift = 0;
-
- /*
- * The timestamp latches on lowest register read. For the 82580
- * the lowest register is SYSTIMR instead of SYSTIML. However we never
- * adjusted TIMINCA so SYSTIMR will just read as all 0s so ignore it.
- */
- if (hw->mac.type >= e1000_82580) {
- stamp = rd32(E1000_SYSTIMR) >> 8;
- shift = IGB_82580_TSYNC_SHIFT;
- }
-
- stamp |= (u64)rd32(E1000_SYSTIML) << shift;
- stamp |= (u64)rd32(E1000_SYSTIMH) << (shift + 32);
- return stamp;
-}
-
/**
* igb_get_hw_dev - return device
* used by hardware layer to print debugging information
@@ -2080,7 +2052,7 @@ static int __devinit igb_probe(struct pci_dev *pdev,
#endif
/* do hw tstamp init after resetting */
- igb_init_hw_timer(adapter);
+ igb_ptp_init(adapter);
dev_info(&pdev->dev, "Intel(R) Gigabit Ethernet Network Connection\n");
/* print bus type/speed/width info */
@@ -2150,6 +2122,8 @@ static void __devexit igb_remove(struct pci_dev *pdev)
struct igb_adapter *adapter = netdev_priv(netdev);
struct e1000_hw *hw = &adapter->hw;
+ igb_ptp_remove(adapter);
+
/*
* The watchdog timer may be rescheduled, so explicitly
* disable watchdog from being rescheduled.
@@ -2269,112 +2243,6 @@ out:
}
/**
- * igb_init_hw_timer - Initialize hardware timer used with IEEE 1588 timestamp
- * @adapter: board private structure to initialize
- *
- * igb_init_hw_timer initializes the function pointer and values for the hw
- * timer found in hardware.
- **/
-static void igb_init_hw_timer(struct igb_adapter *adapter)
-{
- struct e1000_hw *hw = &adapter->hw;
-
- switch (hw->mac.type) {
- case e1000_i350:
- case e1000_82580:
- memset(&adapter->cycles, 0, sizeof(adapter->cycles));
- adapter->cycles.read = igb_read_clock;
- adapter->cycles.mask = CLOCKSOURCE_MASK(64);
- adapter->cycles.mult = 1;
- /*
- * The 82580 timesync updates the system timer every 8ns by 8ns
- * and the value cannot be shifted. Instead we need to shift
- * the registers to generate a 64bit timer value. As a result
- * SYSTIMR/L/H, TXSTMPL/H, RXSTMPL/H all have to be shifted by
- * 24 in order to generate a larger value for synchronization.
- */
- adapter->cycles.shift = IGB_82580_TSYNC_SHIFT;
- /* disable system timer temporarily by setting bit 31 */
- wr32(E1000_TSAUXC, 0x80000000);
- wrfl();
-
- /* Set registers so that rollover occurs soon to test this. */
- wr32(E1000_SYSTIMR, 0x00000000);
- wr32(E1000_SYSTIML, 0x80000000);
- wr32(E1000_SYSTIMH, 0x000000FF);
- wrfl();
-
- /* enable system timer by clearing bit 31 */
- wr32(E1000_TSAUXC, 0x0);
- wrfl();
-
- timecounter_init(&adapter->clock,
- &adapter->cycles,
- ktime_to_ns(ktime_get_real()));
- /*
- * Synchronize our NIC clock against system wall clock. NIC
- * time stamp reading requires ~3us per sample, each sample
- * was pretty stable even under load => only require 10
- * samples for each offset comparison.
- */
- memset(&adapter->compare, 0, sizeof(adapter->compare));
- adapter->compare.source = &adapter->clock;
- adapter->compare.target = ktime_get_real;
- adapter->compare.num_samples = 10;
- timecompare_update(&adapter->compare, 0);
- break;
- case e1000_82576:
- /*
- * Initialize hardware timer: we keep it running just in case
- * that some program needs it later on.
- */
- memset(&adapter->cycles, 0, sizeof(adapter->cycles));
- adapter->cycles.read = igb_read_clock;
- adapter->cycles.mask = CLOCKSOURCE_MASK(64);
- adapter->cycles.mult = 1;
- /**
- * Scale the NIC clock cycle by a large factor so that
- * relatively small clock corrections can be added or
- * subtracted at each clock tick. The drawbacks of a large
- * factor are a) that the clock register overflows more quickly
- * (not such a big deal) and b) that the increment per tick has
- * to fit into 24 bits. As a result we need to use a shift of
- * 19 so we can fit a value of 16 into the TIMINCA register.
- */
- adapter->cycles.shift = IGB_82576_TSYNC_SHIFT;
- wr32(E1000_TIMINCA,
- (1 << E1000_TIMINCA_16NS_SHIFT) |
- (16 << IGB_82576_TSYNC_SHIFT));
-
- /* Set registers so that rollover occurs soon to test this. */
- wr32(E1000_SYSTIML, 0x00000000);
- wr32(E1000_SYSTIMH, 0xFF800000);
- wrfl();
-
- timecounter_init(&adapter->clock,
- &adapter->cycles,
- ktime_to_ns(ktime_get_real()));
- /*
- * Synchronize our NIC clock against system wall clock. NIC
- * time stamp reading requires ~3us per sample, each sample
- * was pretty stable even under load => only require 10
- * samples for each offset comparison.
- */
- memset(&adapter->compare, 0, sizeof(adapter->compare));
- adapter->compare.source = &adapter->clock;
- adapter->compare.target = ktime_get_real;
- adapter->compare.num_samples = 10;
- timecompare_update(&adapter->compare, 0);
- break;
- case e1000_82575:
- /* 82575 does not support timesync */
- default:
- break;
- }
-
-}
-
-/**
* igb_sw_init - Initialize general software structures (struct igb_adapter)
* @adapter: board private structure to initialize
*
@@ -5628,35 +5496,6 @@ static int igb_poll(struct napi_struct *napi, int budget)
}
/**
- * igb_systim_to_hwtstamp - convert system time value to hw timestamp
- * @adapter: board private structure
- * @shhwtstamps: timestamp structure to update
- * @regval: unsigned 64bit system time value.
- *
- * We need to convert the system time value stored in the RX/TXSTMP registers
- * into a hwtstamp which can be used by the upper level timestamping functions
- */
-static void igb_systim_to_hwtstamp(struct igb_adapter *adapter,
- struct skb_shared_hwtstamps *shhwtstamps,
- u64 regval)
-{
- u64 ns;
-
- /*
- * The 82580 starts with 1ns at bit 0 in RX/TXSTMPL, shift this up to
- * 24 to match clock shift we setup earlier.
- */
- if (adapter->hw.mac.type >= e1000_82580)
- regval <<= IGB_82580_TSYNC_SHIFT;
-
- ns = timecounter_cyc2time(&adapter->clock, regval);
- timecompare_update(&adapter->compare, ns);
- memset(shhwtstamps, 0, sizeof(struct skb_shared_hwtstamps));
- shhwtstamps->hwtstamp = ns_to_ktime(ns);
- shhwtstamps->syststamp = timecompare_transform(&adapter->compare, ns);
-}
-
-/**
* igb_tx_hwtstamp - utility function which checks for TX time stamp
* @q_vector: pointer to q_vector containing needed info
* @buffer: pointer to igb_tx_buffer structure
diff --git a/drivers/net/ethernet/intel/igb/igb_ptp.c b/drivers/net/ethernet/intel/igb/igb_ptp.c
index dd27be1..69a1f21 100644
--- a/drivers/net/ethernet/intel/igb/igb_ptp.c
+++ b/drivers/net/ethernet/intel/igb/igb_ptp.c
@@ -26,6 +26,9 @@
#define ISGN 0x80000000
/*
+ * The 82580 timesync updates the system timer every 8ns by 8ns,
+ * and this update value cannot be reprogrammed.
+ *
* Neither the 82576 nor the 82580 offer registers wide enough to hold
* nanoseconds time values for very long. For the 82580, SYSTIM always
* counts nanoseconds, but the upper 24 bits are not availible. The
@@ -37,6 +40,14 @@
* field are needed to provide the nominal 16 nanosecond period,
* leaving 19 bits for fractional nanoseconds.
*
+ * We scale the NIC clock cycle by a large factor so that relatively
+ * small clock corrections can be added or subtracted at each clock
+ * tick. The drawbacks of a large factor are a) that the clock
+ * register overflows more quickly (not such a big deal) and b) that
+ * the increment per tick has to fit into 24 bits. As a result we
+ * need to use a shift of 19 so we can fit a value of 16 into the
+ * TIMINCA register.
+ *
*
* SYSTIMH SYSTIML
* +--------------+ +---+---+------+
@@ -153,6 +164,11 @@ static u64 igb_82580_systim_read(struct igb_adapter *igb)
u32 lo, hi, jk;
struct e1000_hw *hw = &igb->hw;
+ /*
+ * The timestamp latches on lowest register read. For the 82580
+ * the lowest register is SYSTIMR instead of SYSTIML. However we only
+ * need to provide nanosecond resolution, so we just ignore it.
+ */
jk = rd32(E1000_SYSTIMR);
lo = rd32(E1000_SYSTIML);
hi = rd32(E1000_SYSTIMH);
@@ -425,3 +441,53 @@ void igb_ptp_remove(struct igb_adapter *adapter)
#endif /*CONFIG_PTP_1588_CLOCK*/
}
+
+/**
+ * igb_systim_to_hwtstamp - convert system time value to hw timestamp
+ * @adapter: board private structure
+ * @hwtstamps: timestamp structure to update
+ * @systim: unsigned 64bit system time value.
+ *
+ * We need to convert the system time value stored in the RX/TXSTMP registers
+ * into a hwtstamp which can be used by the upper level timestamping functions.
+ *
+ * The 'tmreg_lock' spinlock is used to protect the consistency of the
+ * system time value. This is needed because reading the 64 bit time
+ * value involves reading two (or three) 32 bit registers. The first
+ * read latches the value. Ditto for writing.
+ *
+ * In addition, here have extended the system time with an overflow
+ * counter in software. We have to watch the most significant bit for
+ * one-to-zero transition, in order to keep count of the overflow.
+ */
+void igb_systim_to_hwtstamp(struct igb_adapter *adapter,
+ struct skb_shared_hwtstamps *hwtstamps,
+ u64 systim)
+{
+ u64 ns;
+ unsigned long flags;
+ unsigned int shift;
+
+ switch (adapter->hw.mac.type) {
+ case e1000_i350:
+ case e1000_82580:
+ ns = systim;
+ shift = OFL_SHIFT_82580;
+ break;
+ case e1000_82576:
+ ns = systim >> NS_SHIFT_82576;
+ shift = OFL_SHIFT_82576;
+ break;
+ default:
+ return;
+ }
+
+ spin_lock_irqsave(&adapter->tmreg_lock, flags);
+
+ ns = igb_overflow_get(adapter, ns, shift);
+
+ spin_unlock_irqrestore(&adapter->tmreg_lock, flags);
+
+ memset(hwtstamps, 0, sizeof(*hwtstamps));
+ hwtstamps->hwtstamp = ns_to_ktime(ns);
+}
--
1.7.2.5
------------------------------------------------------------------------------
Ridiculously easy VDI. With Citrix VDI-in-a-Box, you don't need a complex
infrastructure or vast IT resources to deliver seamless, secure access to
virtual desktops. With this all-in-one solution, easily deploy virtual
desktops for less than the cost of PCs and save 60% on VDI infrastructure
costs. Try it free! http://p.sf.net/sfu/Citrix-VDIinabox
_______________________________________________
E1000-devel mailing list
E1000-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/e1000-devel
To learn more about Intel® Ethernet, visit http://communities.intel.com/community/wired
^ permalink raw reply related [flat|nested] 10+ messages in thread
* Re: [PATCH net-next V3 0/2] igb: ptp hardware clock
2012-01-07 19:38 [PATCH net-next V3 0/2] igb: ptp hardware clock Richard Cochran
2012-01-07 19:38 ` [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code Richard Cochran
2012-01-07 19:38 ` [PATCH net-next V3 2/2] igb: offer a PTP Hardware Clock instead of the timecompare method Richard Cochran
@ 2012-01-08 1:02 ` Jeff Kirsher
2012-01-19 9:39 ` Richard Cochran
2 siblings, 1 reply; 10+ messages in thread
From: Jeff Kirsher @ 2012-01-08 1:02 UTC (permalink / raw)
To: Richard Cochran
Cc: netdev, e1000-devel, Jacob Keller, John Ronciak, John Stultz,
Thomas Gleixner
[-- Attachment #1: Type: text/plain, Size: 1469 bytes --]
On Sat, 2012-01-07 at 20:38 +0100, Richard Cochran wrote:
> * ChangeLog
> ** V3
> - Driver compiles even without CONFIG_PTP_1588_CLOCK.
> - Timestamping always works, even when PTP code missing or fails.
> ** V2
> - Fixed wrong bit shifting in the 82576 code.
> - Explained the timestamp locking with a comment in the code.
> - Preserved the comments from the original timecompare
> implementation.
> - Added an additional test within the overflow counter code to fix
> a race condition. Details of the problem are given in the commit
> message.
>
> This patch series implements a PHC driver for the Intel 82576 and
> 82580 devices, as part of the igb driver.
>
> The first patch adds the PHC driver code as a new source module but
> does not link it into the main igb driver. Because the system time
> counter is not so very wide, the code implements an overflow counter
> in software. Every read operation maintains the overflow counter, as
> does a "delayed work" watchdog. Only the base clock operations are
> implemented. The hardware does have some ancillary features, but these
> can be easily added later.
>
> The second patch removes the timecompare code and links in the new
> functions.
>
> I have tested the 82580 with good results. However, I don't have the
> 82576 and so would appreciate testing and feedback.
>
> Thanks,
> Richard
Thanks Richard, I will add this series to my queue.
[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 836 bytes --]
^ permalink raw reply [flat|nested] 10+ messages in thread
* RE: [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code
2012-01-07 19:38 ` [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code Richard Cochran
@ 2012-01-09 17:42 ` Keller, Jacob E
2012-01-10 8:44 ` Richard Cochran
0 siblings, 1 reply; 10+ messages in thread
From: Keller, Jacob E @ 2012-01-09 17:42 UTC (permalink / raw)
To: Richard Cochran, netdev@vger.kernel.org
Cc: e1000-devel@lists.sourceforge.net, Kirsher, Jeffrey T,
Ronciak, John, John Stultz, Thomas Gleixner
> -----Original Message-----
> From: Richard Cochran [mailto:richardcochran@gmail.com]
> Sent: Saturday, January 07, 2012 11:38 AM
> To: netdev@vger.kernel.org
> Cc: e1000-devel@lists.sourceforge.net; Keller, Jacob E; Kirsher,
> Jeffrey T; Ronciak, John; John Stultz; Thomas Gleixner
> Subject: [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code
>
> This patch adds a source file implementing a PHC. Only the basic
> clock operations have been implemented, although the hardware
> would offer some ancillary functions. The code is fairly self
> contained and is not yet used in the main igb driver.
>
> Every timestamp and clock read operation must consult the overflow
> counter to form a correct time value. Access to the counter is
> protected by a spin lock, and this would be sufficient, assuming that
> the time values are monotonic.
>
> However, this assumption does not hold in general. Consider the
> following sequence.
>
> 1. Hardware latches a receive timestamp (just before counter
> overflow).
> 2. User calls clock_gettime() (just after counter overflow).
> 3. User takes lock, detects 1-0 transition, and increments overflow
> count.
> 4. Driver takes lock, incorrectly combines overflow count with
> timestamp.
>
> A very similar race condition exists between two nearly simultaneous
> hardware timestamps.
>
> The implementation detects this race by checking the two most
> significant bits for a transition from 11b to 00b. When this pattern
> is detected, the code uses the previous value of the overflow count.
>
> The two most significant bits divide the overflow period into four
> regions, and so the watchdog timeout is set to sample the counter at
> just over four times per period.
>
Is there a reason for not using the timecounter structure from the kernel? It is a layer beneath the timecompare code which is meant to handle this condition. As far as I can tell this issue is solved in the timecounter code. If it is not, then that should be a bug in the timecounter cyclecounter code. I don't know if this issue occurs in the timecounter structure because it handles the ns conversion differently.
> Signed-off-by: Richard Cochran <richardcochran@gmail.com>
> ---
> drivers/net/ethernet/intel/igb/igb.h | 8 +
> drivers/net/ethernet/intel/igb/igb_ptp.c | 427
> ++++++++++++++++++++++++++++++
> 2 files changed, 435 insertions(+), 0 deletions(-)
> create mode 100644 drivers/net/ethernet/intel/igb/igb_ptp.c
>
> diff --git a/drivers/net/ethernet/intel/igb/igb.h
> b/drivers/net/ethernet/intel/igb/igb.h
> index c69feeb..f30458d 100644
> --- a/drivers/net/ethernet/intel/igb/igb.h
> +++ b/drivers/net/ethernet/intel/igb/igb.h
> @@ -37,6 +37,7 @@
> #include <linux/clocksource.h>
> #include <linux/timecompare.h>
> #include <linux/net_tstamp.h>
> +#include <linux/ptp_clock_kernel.h>
> #include <linux/bitops.h>
> #include <linux/if_vlan.h>
>
> @@ -364,6 +365,13 @@ struct igb_adapter {
> u32 wvbr;
> int node;
> u32 *shadow_vfta;
> +
> + struct ptp_clock *ptp_clock;
> + struct ptp_clock_info caps;
> + struct delayed_work overflow_work;
> + spinlock_t tmreg_lock;
> + u32 overflow_counter;
> + unsigned int last_msb;
> };
>
> #define IGB_FLAG_HAS_MSI (1 << 0)
> diff --git a/drivers/net/ethernet/intel/igb/igb_ptp.c
> b/drivers/net/ethernet/intel/igb/igb_ptp.c
> new file mode 100644
> index 0000000..dd27be1
> --- /dev/null
> +++ b/drivers/net/ethernet/intel/igb/igb_ptp.c
> @@ -0,0 +1,427 @@
> +/*
> + * PTP Hardware Clock (PHC) driver for the Intel 82576 and 82580
> + *
> + * Copyright (C) 2011 Richard Cochran <richardcochran@gmail.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.
> + *
> + * You should have received a copy of the GNU General Public License
> along
> + * with this program; if not, write to the Free Software Foundation,
> Inc.,
> + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
> + */
> +#include <linux/device.h>
> +#include <linux/pci.h>
> +
> +#include "igb.h"
> +
> +#define INCVALUE_MASK 0x7fffffff
> +#define ISGN 0x80000000
> +
> +/*
> + * Neither the 82576 nor the 82580 offer registers wide enough to hold
> + * nanoseconds time values for very long. For the 82580, SYSTIM always
> + * counts nanoseconds, but the upper 24 bits are not availible. The
> + * frequency is adjusted by changing the 32 bit fractional nanoseconds
> + * register, TIMINCA.
> + *
> + * For the 82576, the SYSTIM register time unit is affect by the
> + * choice of the 24 bit TININCA:IV (incvalue) field. Five bits of this
> + * field are needed to provide the nominal 16 nanosecond period,
> + * leaving 19 bits for fractional nanoseconds.
> + *
> + *
> + * SYSTIMH SYSTIML
> + * +--------------+ +---+---+------+
> + * 82576 | 32 | | 8 | 5 | 19 |
> + * +--------------+ +---+---+------+
> + * \________ 45 bits _______/ fract
> + *
> + * +----------+---+ +--------------+
> + * 82580 | 24 | 8 | | 32 |
> + * +----------+---+ +--------------+
> + * reserved \______ 40 bits _____/
> + *
> + *
> + * The 45 bit 82576 SYSTIM overflows every
> + * 2^45 * 10^-9 / 3600 = 9.77 hours.
> + *
> + * The 40 bit 82580 SYSTIM overflows every
> + * 2^40 * 10^-9 / 60 = 18.3 minutes.
> + *
> + * We implement a 32 bit overflow counter in software to hold the
> + * missing 19 or 24 bits, for a combined virtual nanosecond time
> + * register of 64 bits.
> + */
> +
> +#define IGB_OVERFLOW_PERIOD (HZ * 60 * 4)
> +#define INCPERIOD_82576 (1 << E1000_TIMINCA_16NS_SHIFT)
> +#define INCVALUE_82576_MASK ((1 << E1000_TIMINCA_16NS_SHIFT) - 1)
> +#define INCVALUE_82576 (16 << IGB_82576_TSYNC_SHIFT)
> +#define OFL_SHIFT_82580 40
> +#define OFL_SHIFT_82576 45
> +#define NS_SHIFT_82576 IGB_82576_TSYNC_SHIFT
> +
> +/*
> + * Overflow counter for the SYSTIM register.
> + */
> +
> +static u64 igb_overflow_get(struct igb_adapter *igb, u64 low, unsigned
> int nbit)
> +{
> + unsigned int msb_set = (low >> (nbit - 2)) & 0x3;
> +
> + if (msb_set == 0x3 && igb->last_msb == 0x0) {
> + /*
> + * This time stamp was taken before the last overflow,
> + * but it lost the race to read the overflow counter.
> + * Therefore, we just use the previous overflow value.
> + */
> + low |= ((u64) igb->overflow_counter - 1ULL) << nbit;
> + return low;
> + }
> +
> + /*
> + * Test for a one to zero transition of the most significant
> + * bit, and increment the overflow counter.
> + */
> + if ((igb->last_msb & 0x2) && !(msb_set & 0x2))
> + igb->overflow_counter++;
> +
> + igb->last_msb = msb_set;
> +
> + low |= ((u64) igb->overflow_counter) << nbit;
> +
> + return low;
> +}
> +
> +static void igb_overflow_set(struct igb_adapter *igb, u64 ns, unsigned
> int nbit)
> +{
> + igb->overflow_counter = ns >> nbit;
> + igb->last_msb = (ns >> (nbit - 2)) & 0x3;
> +}
> +
> +/*
> + * SYSTIM / overflow access functions for the 82576
> + */
> +
> +static u64 igb_82576_systim_read(struct igb_adapter *igb)
> +{
> + u64 ns;
> + u32 lo, hi;
> + struct e1000_hw *hw = &igb->hw;
> +
> + lo = rd32(E1000_SYSTIML);
> + hi = rd32(E1000_SYSTIMH);
> +
> + ns = ((u64) hi) << 32;
> + ns |= lo;
> + ns >>= NS_SHIFT_82576;
> +
> + ns = igb_overflow_get(igb, ns, OFL_SHIFT_82576);
> +
> + return ns;
> +}
> +
> +static void igb_82576_systim_write(struct igb_adapter *igb, u64 ns)
> +{
> + u32 hi, lo;
> + struct e1000_hw *hw = &igb->hw;
> +
> + hi = (ns >> 13) & 0xffffffff;
> + lo = (ns & 0x1fff) << NS_SHIFT_82576;
> +
> + wr32(E1000_SYSTIML, lo);
> + wr32(E1000_SYSTIMH, hi);
> +
> + igb_overflow_set(igb, ns, OFL_SHIFT_82576);
> +}
> +
> +/*
> + * SYSTIM / overflow access functions for the 82580
> + */
> +
> +static u64 igb_82580_systim_read(struct igb_adapter *igb)
> +{
> + u64 ns;
> + u32 lo, hi, jk;
> + struct e1000_hw *hw = &igb->hw;
> +
> + jk = rd32(E1000_SYSTIMR);
> + lo = rd32(E1000_SYSTIML);
> + hi = rd32(E1000_SYSTIMH);
> +
> + ns = ((u64) hi) << 32;
> + ns |= lo;
> +
> + ns = igb_overflow_get(igb, ns, OFL_SHIFT_82580);
> +
> + return ns;
> +}
> +
> +static void igb_82580_systim_write(struct igb_adapter *igb, u64 ns)
> +{
> + u32 hi, lo;
> + struct e1000_hw *hw = &igb->hw;
> +
> + hi = ns >> 32;
> + lo = ns & 0xffffffff;
> +
> + wr32(E1000_SYSTIMR, 0);
> + wr32(E1000_SYSTIML, lo);
> + wr32(E1000_SYSTIMH, hi & 0xff);
> +
> + igb_overflow_set(igb, ns, OFL_SHIFT_82580);
> +}
> +
> +/*
> + * SYSTIM / overflow register access functions
> + * Callers must hold tmreg_lock.
> + */
> +
> +static u64 igb_systim_read(struct igb_adapter *igb)
> +{
> + switch (igb->hw.mac.type) {
> + case e1000_i350:
> + case e1000_82580:
> + return igb_82580_systim_read(igb);
> + case e1000_82576:
> + return igb_82576_systim_read(igb);
> + default:
> + return 0;
> + }
> +}
> +
> +static void igb_systim_write(struct igb_adapter *igb, u64 ns)
> +{
> + switch (igb->hw.mac.type) {
> + case e1000_i350:
> + case e1000_82580:
> + igb_82580_systim_write(igb, ns);
> + break;
> + case e1000_82576:
> + igb_82576_systim_write(igb, ns);
> + break;
> + default:
> + break;
> + }
> +}
> +
> +/*
> + * PTP clock operations
> + */
> +
> +static int ptp_82576_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
> +{
> + u64 rate;
> + u32 incvalue;
> + int neg_adj = 0;
> + struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
> caps);
> + struct e1000_hw *hw = &igb->hw;
> +
> + if (ppb < 0) {
> + neg_adj = 1;
> + ppb = -ppb;
> + }
> + rate = ppb;
> + rate <<= 14;
> + rate = div_u64(rate, 1953125);
> +
> + incvalue = 16 << IGB_82576_TSYNC_SHIFT;
> +
> + if (neg_adj)
> + incvalue -= rate;
> + else
> + incvalue += rate;
> +
> + wr32(E1000_TIMINCA, INCPERIOD_82576 | (incvalue &
> INCVALUE_82576_MASK));
> +
> + return 0;
> +}
> +
> +static int ptp_82580_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
> +{
> + u64 rate;
> + u32 inca;
> + int neg_adj = 0;
> + struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
> caps);
> + struct e1000_hw *hw = &igb->hw;
> +
> + if (ppb < 0) {
> + neg_adj = 1;
> + ppb = -ppb;
> + }
> + rate = ppb;
> + rate <<= 26;
> + rate = div_u64(rate, 1953125);
> +
> + inca = rate & INCVALUE_MASK;
> + if (neg_adj)
> + inca |= ISGN;
> +
> + wr32(E1000_TIMINCA, inca);
> +
> + return 0;
> +}
> +
> +static int igb_adjtime(struct ptp_clock_info *ptp, s64 delta)
> +{
> + s64 now;
> + unsigned long flags;
> + struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
> caps);
> +
> + spin_lock_irqsave(&igb->tmreg_lock, flags);
> +
> + now = igb_systim_read(igb);
> + now += delta;
> + igb_systim_write(igb, now);
> +
> + spin_unlock_irqrestore(&igb->tmreg_lock, flags);
> +
> + return 0;
> +}
> +
> +static int igb_gettime(struct ptp_clock_info *ptp, struct timespec
> *ts)
> +{
> + u64 ns;
> + u32 remainder;
> + unsigned long flags;
> + struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
> caps);
> +
> + spin_lock_irqsave(&igb->tmreg_lock, flags);
> +
> + ns = igb_systim_read(igb);
> +
> + spin_unlock_irqrestore(&igb->tmreg_lock, flags);
> +
> + ts->tv_sec = div_u64_rem(ns, 1000000000, &remainder);
> + ts->tv_nsec = remainder;
> +
> + return 0;
> +}
> +
> +static int igb_settime(struct ptp_clock_info *ptp, const struct
> timespec *ts)
> +{
> + u64 ns;
> + unsigned long flags;
> + struct igb_adapter *igb = container_of(ptp, struct igb_adapter,
> caps);
> +
> + ns = ts->tv_sec * 1000000000ULL;
> + ns += ts->tv_nsec;
> +
> + spin_lock_irqsave(&igb->tmreg_lock, flags);
> +
> + igb_systim_write(igb, ns);
> +
> + spin_unlock_irqrestore(&igb->tmreg_lock, flags);
> +
> + return 0;
> +}
> +
> +static int ptp_82576_enable(struct ptp_clock_info *ptp,
> + struct ptp_clock_request *rq, int on)
> +{
> + return -EOPNOTSUPP;
> +}
> +
> +static int ptp_82580_enable(struct ptp_clock_info *ptp,
> + struct ptp_clock_request *rq, int on)
> +{
> + return -EOPNOTSUPP;
> +}
> +
> +static void igb_overflow_check(struct work_struct *work)
> +{
> + struct timespec ts;
> + struct igb_adapter *igb =
> + container_of(work, struct igb_adapter, overflow_work.work);
> +
> + igb_gettime(&igb->caps, &ts);
> +
> + pr_debug("igb overflow check at %ld.%09lu\n", ts.tv_sec,
> ts.tv_nsec);
> +
> + schedule_delayed_work(&igb->overflow_work, IGB_OVERFLOW_PERIOD);
> +}
> +
> +void igb_ptp_init(struct igb_adapter *adapter)
> +{
> + struct e1000_hw *hw = &adapter->hw;
> +
> + switch (hw->mac.type) {
> + case e1000_i350:
> + case e1000_82580:
> + adapter->caps.owner = THIS_MODULE;
> + strcpy(adapter->caps.name, "igb-82580");
> + adapter->caps.max_adj = 62499999;
> + adapter->caps.n_ext_ts = 0;
> + adapter->caps.pps = 0;
> + adapter->caps.adjfreq = ptp_82580_adjfreq;
> + adapter->caps.adjtime = igb_adjtime;
> + adapter->caps.gettime = igb_gettime;
> + adapter->caps.settime = igb_settime;
> + adapter->caps.enable = ptp_82580_enable;
> + /* Enable the timer functions by clearing bit 31. */
> + wr32(E1000_TSAUXC, 0x0);
> + break;
> +
> + case e1000_82576:
> + adapter->caps.owner = THIS_MODULE;
> + strcpy(adapter->caps.name, "igb-82576");
> + adapter->caps.max_adj = 1000000000;
> + adapter->caps.n_ext_ts = 0;
> + adapter->caps.pps = 0;
> + adapter->caps.adjfreq = ptp_82576_adjfreq;
> + adapter->caps.adjtime = igb_adjtime;
> + adapter->caps.gettime = igb_gettime;
> + adapter->caps.settime = igb_settime;
> + adapter->caps.enable = ptp_82576_enable;
> + /* Dial the nominal frequency. */
> + wr32(E1000_TIMINCA, INCPERIOD_82576 | INCVALUE_82576);
> + break;
> +
> + default:
> + adapter->ptp_clock = NULL;
> + return;
> + }
> +
> + wrfl();
> +
> + INIT_DELAYED_WORK(&adapter->overflow_work, igb_overflow_check);
> +
> + spin_lock_init(&adapter->tmreg_lock);
> +
> + schedule_delayed_work(&adapter->overflow_work,
> IGB_OVERFLOW_PERIOD);
> +
> +#ifdef CONFIG_PTP_1588_CLOCK
> +
> + adapter->ptp_clock = ptp_clock_register(&adapter->caps);
> + if (IS_ERR(adapter->ptp_clock)) {
> + adapter->ptp_clock = NULL;
> + dev_err(&adapter->pdev->dev, "ptp_clock_register
> failed\n");
> + } else
> + dev_info(&adapter->pdev->dev, "added PHC on %s\n",
> + adapter->netdev->name);
> +
> +#endif /*CONFIG_PTP_1588_CLOCK*/
> +}
> +
> +void igb_ptp_remove(struct igb_adapter *adapter)
> +{
> + cancel_delayed_work_sync(&adapter->overflow_work);
> +
> +#ifdef CONFIG_PTP_1588_CLOCK
> +
> + if (adapter->ptp_clock) {
> + ptp_clock_unregister(adapter->ptp_clock);
> + dev_info(&adapter->pdev->dev, "removed PHC on %s\n",
> + adapter->netdev->name);
> + }
> +
> +#endif /*CONFIG_PTP_1588_CLOCK*/
> +}
> --
> 1.7.2.5
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code
2012-01-09 17:42 ` Keller, Jacob E
@ 2012-01-10 8:44 ` Richard Cochran
2012-01-10 9:33 ` Richard Cochran
2012-01-11 17:14 ` Keller, Jacob E
0 siblings, 2 replies; 10+ messages in thread
From: Richard Cochran @ 2012-01-10 8:44 UTC (permalink / raw)
To: Keller, Jacob E
Cc: netdev@vger.kernel.org, e1000-devel@lists.sourceforge.net,
Kirsher, Jeffrey T, Ronciak, John, John Stultz, Thomas Gleixner
On Mon, Jan 09, 2012 at 05:42:20PM +0000, Keller, Jacob E wrote:
> Is there a reason for not using the timecounter structure from the
> kernel? It is a layer beneath the timecompare code which is meant to
> handle this condition. As far as I can tell this issue is solved in
> the timecounter code. If it is not, then that should be a bug in the
> timecounter cyclecounter code. I don't know if this issue occurs in
> the timecounter structure because it handles the ns conversion
> differently.
My only reason is that I am not sure that the timecounter code really
does what we need. It might well work. Consider, though, that the
82580 register does not overflow in the usual way. The upper 24 bits
are always zero.
What I wrote does the right thing, I think. However, duplicated
effort is always bad, so can you show me how to change it?
Thanks,
Richard
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code
2012-01-10 8:44 ` Richard Cochran
@ 2012-01-10 9:33 ` Richard Cochran
2012-01-11 17:14 ` Keller, Jacob E
1 sibling, 0 replies; 10+ messages in thread
From: Richard Cochran @ 2012-01-10 9:33 UTC (permalink / raw)
To: Keller, Jacob E
Cc: netdev@vger.kernel.org, e1000-devel@lists.sourceforge.net,
Kirsher, Jeffrey T, Ronciak, John, John Stultz, Thomas Gleixner
On Tue, Jan 10, 2012 at 09:44:50AM +0100, Richard Cochran wrote:
> On Mon, Jan 09, 2012 at 05:42:20PM +0000, Keller, Jacob E wrote:
>
> > Is there a reason for not using the timecounter structure from the
> > kernel? It is a layer beneath the timecompare code which is meant to
> > handle this condition. As far as I can tell this issue is solved in
> > the timecounter code. If it is not, then that should be a bug in the
> > timecounter cyclecounter code. I don't know if this issue occurs in
> > the timecounter structure because it handles the ns conversion
> > differently.
>
> My only reason is that I am not sure that the timecounter code really
> does what we need. It might well work. Consider, though, that the
> 82580 register does not overflow in the usual way. The upper 24 bits
> are always zero.
>
> What I wrote does the right thing, I think. However, duplicated
> effort is always bad, so can you show me how to change it?
I took a brief look, and I think the timecounter idea might work.
Later this week I'll try it out if I can.
Thanks,
Richard
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code
2012-01-10 8:44 ` Richard Cochran
2012-01-10 9:33 ` Richard Cochran
@ 2012-01-11 17:14 ` Keller, Jacob E
1 sibling, 0 replies; 10+ messages in thread
From: Keller, Jacob E @ 2012-01-11 17:14 UTC (permalink / raw)
To: Richard Cochran
Cc: Thomas, e1000-devel@lists.sourceforge.net, netdev@vger.kernel.org,
Ronciak, John, John Stultz, Gleixner
> -----Original Message-----
> From: Richard Cochran [mailto:richardcochran@gmail.com]
> Sent: Tuesday, January 10, 2012 12:45 AM
> To: Keller, Jacob E
> Cc: netdev@vger.kernel.org; e1000-devel@lists.sourceforge.net; Kirsher,
> Jeffrey T; Ronciak, John; John Stultz; Thomas Gleixner
> Subject: Re: [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code
>
> On Mon, Jan 09, 2012 at 05:42:20PM +0000, Keller, Jacob E wrote:
>
> > Is there a reason for not using the timecounter structure from the
> > kernel? It is a layer beneath the timecompare code which is meant to
> > handle this condition. As far as I can tell this issue is solved in
> > the timecounter code. If it is not, then that should be a bug in the
> > timecounter cyclecounter code. I don't know if this issue occurs in
> > the timecounter structure because it handles the ns conversion
> > differently.
>
> My only reason is that I am not sure that the timecounter code really
> does what we need. It might well work. Consider, though, that the
> 82580 register does not overflow in the usual way. The upper 24 bits
> are always zero.
>
> What I wrote does the right thing, I think. However, duplicated
> effort is always bad, so can you show me how to change it?
>
Sure :) The way to set it up also includes the ability to specify width, so that for example the 82580 can be set to the bit length, and you provide the whole cycle counter value as a 40bit value.
I will send you a copy of the code I will be using for the ixgbe driver.
It *does* handle the conversion in a different way, because it doesn't keep an overflow counter, instead it converts "cycles" to nanoseconds. However, it claims to have support for past timestamps as long as they are within half the cycle max value.
Basically it's a portion of the code used in the timecompare stuff, but without the timecompare averaging scheme which is bad. I don't use the structure the same way that the older igb code did (because it does funky things with the 82580 and doesn't setup the other devices correctly for clock rate adjustment)
> Thanks,
> Richard
------------------------------------------------------------------------------
Ridiculously easy VDI. With Citrix VDI-in-a-Box, you don't need a complex
infrastructure or vast IT resources to deliver seamless, secure access to
virtual desktops. With this all-in-one solution, easily deploy virtual
desktops for less than the cost of PCs and save 60% on VDI infrastructure
costs. Try it free! http://p.sf.net/sfu/Citrix-VDIinabox
_______________________________________________
E1000-devel mailing list
E1000-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/e1000-devel
To learn more about Intel® Ethernet, visit http://communities.intel.com/community/wired
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH net-next V3 0/2] igb: ptp hardware clock
2012-01-08 1:02 ` [PATCH net-next V3 0/2] igb: ptp hardware clock Jeff Kirsher
@ 2012-01-19 9:39 ` Richard Cochran
2012-01-19 9:56 ` Jeff Kirsher
0 siblings, 1 reply; 10+ messages in thread
From: Richard Cochran @ 2012-01-19 9:39 UTC (permalink / raw)
To: Jeff Kirsher
Cc: e1000-devel, netdev, John Ronciak, John Stultz, Jacob Keller,
Thomas Gleixner
On Sat, Jan 07, 2012 at 05:02:39PM -0800, Jeff Kirsher wrote:
> On Sat, 2012-01-07 at 20:38 +0100, Richard Cochran wrote:
> > * ChangeLog
> > ** V3
> > - Driver compiles even without CONFIG_PTP_1588_CLOCK.
> > - Timestamping always works, even when PTP code missing or fails.
> > ** V2
> > - Fixed wrong bit shifting in the 82576 code.
> > - Explained the timestamp locking with a comment in the code.
> > - Preserved the comments from the original timecompare
> > implementation.
> > - Added an additional test within the overflow counter code to fix
> > a race condition. Details of the problem are given in the commit
> > message.
...
> Thanks Richard, I will add this series to my queue.
Jeff,
Please hold off with these. I adapted the driver to use
timecounter/cyclecounter as Jacob suggested, and the result is surely
nicer. I will post a V4 after I finish testing it.
Thanks,
Richard
------------------------------------------------------------------------------
Keep Your Developer Skills Current with LearnDevNow!
The most comprehensive online learning library for Microsoft developers
is just $99.99! Visual Studio, SharePoint, SQL - plus HTML5, CSS3, MVC3,
Metro Style Apps, more. Free future releases when you subscribe now!
http://p.sf.net/sfu/learndevnow-d2d
_______________________________________________
E1000-devel mailing list
E1000-devel@lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/e1000-devel
To learn more about Intel® Ethernet, visit http://communities.intel.com/community/wired
^ permalink raw reply [flat|nested] 10+ messages in thread
* Re: [PATCH net-next V3 0/2] igb: ptp hardware clock
2012-01-19 9:39 ` Richard Cochran
@ 2012-01-19 9:56 ` Jeff Kirsher
0 siblings, 0 replies; 10+ messages in thread
From: Jeff Kirsher @ 2012-01-19 9:56 UTC (permalink / raw)
To: Richard Cochran
Cc: netdev, e1000-devel, Jacob Keller, John Ronciak, John Stultz,
Thomas Gleixner
[-- Attachment #1: Type: text/plain, Size: 1116 bytes --]
On Thu, 2012-01-19 at 10:39 +0100, Richard Cochran wrote:
> On Sat, Jan 07, 2012 at 05:02:39PM -0800, Jeff Kirsher wrote:
> > On Sat, 2012-01-07 at 20:38 +0100, Richard Cochran wrote:
> > > * ChangeLog
> > > ** V3
> > > - Driver compiles even without CONFIG_PTP_1588_CLOCK.
> > > - Timestamping always works, even when PTP code missing or fails.
> > > ** V2
> > > - Fixed wrong bit shifting in the 82576 code.
> > > - Explained the timestamp locking with a comment in the code.
> > > - Preserved the comments from the original timecompare
> > > implementation.
> > > - Added an additional test within the overflow counter code to fix
> > > a race condition. Details of the problem are given in the commit
> > > message.
> ...
> > Thanks Richard, I will add this series to my queue.
>
> Jeff,
>
> Please hold off with these. I adapted the driver to use
> timecounter/cyclecounter as Jacob suggested, and the result is surely
> nicer. I will post a V4 after I finish testing it.
>
> Thanks,
> Richard
>
Ok, I will await v4 of the patches. Thanks Richard!
[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 836 bytes --]
^ permalink raw reply [flat|nested] 10+ messages in thread
end of thread, other threads:[~2012-01-19 9:56 UTC | newest]
Thread overview: 10+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2012-01-07 19:38 [PATCH net-next V3 0/2] igb: ptp hardware clock Richard Cochran
2012-01-07 19:38 ` [PATCH net-next V3 1/2] igb: add PTP Hardware Clock code Richard Cochran
2012-01-09 17:42 ` Keller, Jacob E
2012-01-10 8:44 ` Richard Cochran
2012-01-10 9:33 ` Richard Cochran
2012-01-11 17:14 ` Keller, Jacob E
2012-01-07 19:38 ` [PATCH net-next V3 2/2] igb: offer a PTP Hardware Clock instead of the timecompare method Richard Cochran
2012-01-08 1:02 ` [PATCH net-next V3 0/2] igb: ptp hardware clock Jeff Kirsher
2012-01-19 9:39 ` Richard Cochran
2012-01-19 9:56 ` Jeff Kirsher
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).