1

/* Intel PRO/1000 Linux driver

     2

 * Copyright(c) 1999 - 2014 Intel Corporation.

     3

 *

     4

 * This program is free software; you can redistribute it and/or modify it

     5

 * under the terms and conditions of the GNU General Public License,

     6

 * version 2, as published by the Free Software Foundation.

     7

 *

     8

 * This program is distributed in the hope it will be useful, but WITHOUT

     9

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    10

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

    11

 * more details.

    12

 *

    13

 * The full GNU General Public License is included in this distribution in

    14

 * the file called "COPYING".

    15

 *

    16

 * Contact Information:

    17

 * Linux NICS <linux.nics@intel.com>

    18

 * e1000-devel Mailing List <e1000-devel@lists.sourceforge.net>

    19

 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497

    20

 */

    21

    22

/* PTP 1588 Hardware Clock (PHC)

    23

 * Derived from PTP Hardware Clock driver for Intel 82576 and 82580 (igb)

    24

 * Copyright (C) 2011 Richard Cochran <richardcochran@gmail.com>

    25

 */

    26

    27

#include "e1000.h"

    28

    29

/**

    30

 * e1000e_phc_adjfreq - adjust the frequency of the hardware clock

    31

 * @ptp: ptp clock structure

    32

 * @delta: Desired frequency change in parts per billion

    33

 *

    34

 * Adjust the frequency of the PHC cycle counter by the indicated delta from

    35

 * the base frequency.

    36

 **/

    37

static int e1000e_phc_adjfreq(struct ptp_clock_info *ptp, s32 delta)

    38

{

    39

	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,

    40

						     ptp_clock_info);

    41

	struct e1000_hw *hw = &adapter->hw;

    42

	bool neg_adj = false;

    43

	unsigned long flags;

    44

	u64 adjustment;

    45

	u32 timinca, incvalue;

    46

	s32 ret_val;

    47

    48

	if ((delta > ptp->max_adj) || (delta <= -1000000000))

    49

		return -EINVAL;

    50

    51

	if (delta < 0) {

    52

		neg_adj = true;

    53

		delta = -delta;

    54

	}

    55

    56

	/* Get the System Time Register SYSTIM base frequency */

    57

	ret_val = e1000e_get_base_timinca(adapter, &timinca);

    58

	if (ret_val)

    59

		return ret_val;

    60

    61

	spin_lock_irqsave(&adapter->systim_lock, flags);

    62

    63

	incvalue = timinca & E1000_TIMINCA_INCVALUE_MASK;

    64

    65

	adjustment = incvalue;

    66

	adjustment *= delta;

    67

	adjustment = div_u64(adjustment, 1000000000);

    68

    69

	incvalue = neg_adj ? (incvalue - adjustment) : (incvalue + adjustment);

    70

    71

	timinca &= ~E1000_TIMINCA_INCVALUE_MASK;

    72

	timinca |= incvalue;

    73

    74

	ew32(TIMINCA, timinca);

    75

    76

	spin_unlock_irqrestore(&adapter->systim_lock, flags);

    77

    78

	return 0;

    79

}

    80

    81

/**

    82

 * e1000e_phc_adjtime - Shift the time of the hardware clock

    83

 * @ptp: ptp clock structure

    84

 * @delta: Desired change in nanoseconds

    85

 *

    86

 * Adjust the timer by resetting the timecounter structure.

    87

 **/

    88

static int e1000e_phc_adjtime(struct ptp_clock_info *ptp, s64 delta)

    89

{

    90

	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,

    91

						     ptp_clock_info);

    92

	unsigned long flags;

    93

	s64 now;

    94

    95

	spin_lock_irqsave(&adapter->systim_lock, flags);

    96

	now = timecounter_read(&adapter->tc);

    97

	now += delta;

    98

	timecounter_init(&adapter->tc, &adapter->cc, now);

    99

	spin_unlock_irqrestore(&adapter->systim_lock, flags);

   100

   101

	return 0;

   102

}

   103

   104

/**

   105

 * e1000e_phc_gettime - Reads the current time from the hardware clock

   106

 * @ptp: ptp clock structure

   107

 * @ts: timespec structure to hold the current time value

   108

 *

   109

 * Read the timecounter and return the correct value in ns after converting

   110

 * it into a struct timespec.

   111

 **/

   112

static int e1000e_phc_gettime(struct ptp_clock_info *ptp, struct timespec *ts)

   113

{

   114

	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,

   115

						     ptp_clock_info);

   116

	unsigned long flags;

   117

	u32 remainder;

   118

	u64 ns;

   119

   120

	spin_lock_irqsave(&adapter->systim_lock, flags);

   121

	ns = timecounter_read(&adapter->tc);

   122

	spin_unlock_irqrestore(&adapter->systim_lock, flags);

   123

   124

	ts->tv_sec = div_u64_rem(ns, NSEC_PER_SEC, &remainder);

   125

	ts->tv_nsec = remainder;

   126

   127

	return 0;

   128

}

   129

   130

/**

   131

 * e1000e_phc_settime - Set the current time on the hardware clock

   132

 * @ptp: ptp clock structure

   133

 * @ts: timespec containing the new time for the cycle counter

   134

 *

   135

 * Reset the timecounter to use a new base value instead of the kernel

   136

 * wall timer value.

   137

 **/

   138

static int e1000e_phc_settime(struct ptp_clock_info *ptp,

   139

			      const struct timespec *ts)

   140

{

   141

	struct e1000_adapter *adapter = container_of(ptp, struct e1000_adapter,

   142

						     ptp_clock_info);

   143

	unsigned long flags;

   144

	u64 ns;

   145

   146

	ns = timespec_to_ns(ts);

   147

   148

	/* reset the timecounter */

   149

	spin_lock_irqsave(&adapter->systim_lock, flags);

   150

	timecounter_init(&adapter->tc, &adapter->cc, ns);

   151

	spin_unlock_irqrestore(&adapter->systim_lock, flags);

   152

   153

	return 0;

   154

}

   155

   156

/**

   157

 * e1000e_phc_enable - enable or disable an ancillary feature

   158

 * @ptp: ptp clock structure

   159

 * @request: Desired resource to enable or disable

   160

 * @on: Caller passes one to enable or zero to disable

   161

 *

   162

 * Enable (or disable) ancillary features of the PHC subsystem.

   163

 * Currently, no ancillary features are supported.

   164

 **/

   165

static int e1000e_phc_enable(struct ptp_clock_info __always_unused *ptp,

   166

			     struct ptp_clock_request __always_unused *request,

   167

			     int __always_unused on)

   168

{

   169

	return -EOPNOTSUPP;

   170

}

   171

   172

static void e1000e_systim_overflow_work(struct work_struct *work)

   173

{

   174

	struct e1000_adapter *adapter = container_of(work, struct e1000_adapter,

   175

						     systim_overflow_work.work);

   176

	struct e1000_hw *hw = &adapter->hw;

   177

	struct timespec ts;

   178

   179

	adapter->ptp_clock_info.gettime(&adapter->ptp_clock_info, &ts);

   180

   181

	e_dbg("SYSTIM overflow check at %ld.%09lu\n", ts.tv_sec, ts.tv_nsec);

   182

   183

	schedule_delayed_work(&adapter->systim_overflow_work,

   184

			      E1000_SYSTIM_OVERFLOW_PERIOD);

   185

}

   186

   187

static const struct ptp_clock_info e1000e_ptp_clock_info = {

   188

	.owner		= THIS_MODULE,

   189

	.n_alarm	= 0,

   190

	.n_ext_ts	= 0,

   191

	.n_per_out	= 0,

   192

	.n_pins		= 0,

   193

	.pps		= 0,

   194

	.adjfreq	= e1000e_phc_adjfreq,

   195

	.adjtime	= e1000e_phc_adjtime,

   196

	.gettime	= e1000e_phc_gettime,

   197

	.settime	= e1000e_phc_settime,

   198

	.enable		= e1000e_phc_enable,

   199

};

   200

   201

/**

   202

 * e1000e_ptp_init - initialize PTP for devices which support it

   203

 * @adapter: board private structure

   204

 *

   205

 * This function performs the required steps for enabling PTP support.

   206

 * If PTP support has already been loaded it simply calls the cyclecounter

   207

 * init routine and exits.

   208

 **/

   209

void e1000e_ptp_init(struct e1000_adapter *adapter)

   210

{

   211

	struct e1000_hw *hw = &adapter->hw;

   212

   213

	adapter->ptp_clock = NULL;

   214

   215

	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))

   216

		return;

   217

   218

	adapter->ptp_clock_info = e1000e_ptp_clock_info;

   219

   220

	snprintf(adapter->ptp_clock_info.name,

   221

		 sizeof(adapter->ptp_clock_info.name), "%pm",

   222

		 adapter->netdev->perm_addr);

   223

   224

	switch (hw->mac.type) {

   225

	case e1000_pch2lan:

   226

	case e1000_pch_lpt:

   227

		if ((hw->mac.type != e1000_pch_lpt) ||

   228

		    (er32(TSYNCRXCTL) & E1000_TSYNCRXCTL_SYSCFI)) {

   229

			adapter->ptp_clock_info.max_adj = 24000000 - 1;

   230

			break;

   231

		}

   232

		/* fall-through */

   233

	case e1000_82574:

   234

	case e1000_82583:

   235

		adapter->ptp_clock_info.max_adj = 600000000 - 1;

   236

		break;

   237

	default:

   238

		break;

   239

	}

   240

   241

	INIT_DELAYED_WORK(&adapter->systim_overflow_work,

   242

			  e1000e_systim_overflow_work);

   243

   244

	schedule_delayed_work(&adapter->systim_overflow_work,

   245

			      E1000_SYSTIM_OVERFLOW_PERIOD);

   246

   247

	adapter->ptp_clock = ptp_clock_register(&adapter->ptp_clock_info,

   248

						&adapter->pdev->dev);

   249

	if (IS_ERR(adapter->ptp_clock)) {

   250

		adapter->ptp_clock = NULL;

   251

		e_err("ptp_clock_register failed\n");

   252

	} else {

   253

		e_info("registered PHC clock\n");

   254

	}

   255

}

   256

   257

/**

   258

 * e1000e_ptp_remove - disable PTP device and stop the overflow check

   259

 * @adapter: board private structure

   260

 *

   261

 * Stop the PTP support, and cancel the delayed work.

   262

 **/

   263

void e1000e_ptp_remove(struct e1000_adapter *adapter)

   264

{

   265

	if (!(adapter->flags & FLAG_HAS_HW_TIMESTAMP))

   266

		return;

   267

   268

	cancel_delayed_work_sync(&adapter->systim_overflow_work);

   269

   270

	if (adapter->ptp_clock) {

   271

		ptp_clock_unregister(adapter->ptp_clock);

   272

		adapter->ptp_clock = NULL;

   273

		e_info("removed PHC\n");

   274

	}

   275

}