Commit ea84c842 authored by David S. Miller's avatar David S. Miller

Merge branch 'net-ethernet-ti-k3-introduce-common-platform-time-sync-driver-cpts'

Grygorii Strashko says:

====================
net: ethernet: ti: k3: introduce common platform time sync driver - cpts

This series introduced support for significantly upgraded TI A65x/J721E Common
platform time sync (CPTS) modules which are part of AM65xx Time Synchronization
Architecture [1].
The TI A65x/J721E now contain more than one CPTS instance:
- MCU CPSW CPTS (IEEE 1588 compliant)
- Main NAVSS CPTS (central)
- PCIe CPTS(s) (PTM  compliant)
- J721E: Main CPSW9g CPTS (IEEE 1588 compliant)
which can work as separately as interact to each other through Time Sync Router
(TSR) and Compare Event Router (CER). In addition there are also ICSS-G IEP
blocks which can perform similar timsync functions, but require FW support.
More info also available in TRM [2][3]. Not all above modules are available
to the Linux by as of now as some of them are reserved for RTOS/FW purposes.

The scope of this submission is TI A65x/J721E CPSW CPTS and Main NAVSS CPTS,
and TSR was used for testing purposes.
                                                                       +---------------------------+
                                                                       | MCU CPSW                  |
+-------------------+           +------------------------+             |                TS         |
| Main Navss CPTS   |           | Time Sync Router (TSR) |             |          +-------------+  |
|                   |           |                        |             |          |             |  |
|            HW1_TS +<----------+                        |             | +--------v-----+    +--+--+
|                   |           |                        |             | |        CPTS  |    |Port |
|              ...  |           |                        |           X+-->HW1_TS        |    |     |
|            HW8_TS <------------<---------+             |           X|-->HW2_TS        |    +--^--+
|                   |           |          |             +--------------->HW3_TS        |       |  |
|                   |           |          |             +--------------->HW4_TS        |       |  |
|                   |           |          |             |             | |              |       |  |
|                   |           |          |             |             | |              |       |  |
|            Genf0  +----------->          (A)---------+ +<--------------+Genf0         |       |  |
|                   |           |          |             |             | |              |       |  |
|              ...  |           |          +-----------> <---------------+Genf1     ESTf+-------+  |
|                   |           |                        |             | |              |          |
|                   |           |                        |             | +--------------+          |
|            Genf8  +---------->+                        |             |                           |
|                   |           |    SYNC0 ...    SYNC3  |             |                           |
+-------------------+           +------+------------+----+             +---------------------------+
                                       +            +
                                       X            X
(A) shows possible routing path for MCU CPSW CPTS Genf0 signal as an example.

Main features of the new TI A65x/J721E CPTS modules are:
- 64-bit timestamp/counter mode support in ns by using add_val
- implemented in HW PPM and nudge adjustment.
- control of time sync events via interrupt or polling
- selection of multiple external reference clock sources
- hardware timestamp of ext. inputs events (HWx_TS_PUSH)
- periodic generator function outputs (TS_GENFx)
- (CPSW only) Ethernet Enhanced Scheduled Traffic Operations (CPTS_ESTFn),
  which drives TSN schedule
- timestamping of all RX packets bypassing CPTS FIFO

Patch 1 - DT bindings
Patch 2 - the AM65x/J721E driver
Patch 3 - enables packet timestamping support in TI AM65x/J721E MCU CPSW driver.
Patches 4-7 - DT updates.

=== PTP Testing:

phc2sys -s CLOCK_REALTIME -c eth0 -m -O 0 -u30
phc2sys[627.331]: eth0 rms 409912446712787392 max 1587584079521858304 freq  -6665 +/- 35040 delay   832 +/-  27
phc2sys[657.335]: eth0 rms   33 max   66 freq     -0 +/-  28 delay   820 +/-  30
phc2sys[687.339]: eth0 rms   37 max   70 freq     -1 +/-  32 delay   830 +/-  29
phc2sys[717.343]: eth0 rms   33 max   71 freq     -0 +/-  29 delay   828 +/-  23
phc2sys[747.346]: eth0 rms   35 max   75 freq     -0 +/-  31 delay   829 +/-  26
phc2sys[777.350]: eth0 rms   37 max   68 freq     -1 +/-  32 delay   825 +/-  25
phc2sys[807.354]: eth0 rms   28 max   57 freq     -1 +/-  25 delay   824 +/-  21
phc2sys[837.358]: eth0 rms   43 max   81 freq     -1 +/-  37 delay   836 +/-  23
phc2sys[867.361]: eth0 rms   33 max   74 freq     +0 +/-  29 delay   828 +/-  24
phc2sys[897.365]: eth0 rms   35 max   77 freq     -2 +/-  30 delay   824 +/-  25
phc2sys[927.369]: eth0 rms   28 max   50 freq     +0 +/-  25 delay   825 +/-  25

ptp4l -P -2 -H -i eth0 -l 6 -m -q -p /dev/ptp1 -f ptp.cfg -s
ptp4l[22095.754]: port 1: MASTER to UNCALIBRATED on RS_SLAVE
ptp4l[22097.754]: port 1: UNCALIBRATED to SLAVE on MASTER_CLOCK_SELECTED
ptp4l[22159.757]: rms  317 max 1418 freq    +79 +/- 186 delay   410 +/-   1
ptp4l[22223.760]: rms    9 max   24 freq    +42 +/-  12 delay   409 +/-   1
ptp4l[22287.763]: rms   10 max   28 freq    +41 +/-  11 delay   410 +/-   1
ptp4l[22351.767]: rms   10 max   26 freq    +34 +/-  12 delay   410 +/-   1
ptp4l[22415.770]: rms   10 max   26 freq    +49 +/-  14 delay   410 +/-   1

=== Ext. HW_TS and Genf testing:

For testing purposes Time Sync Router (TSR) can be modeled in DT as pin controller
+       timesync_router: timesync_router@A40000 {
+               compatible = "pinctrl-single";
+               reg = <0x0 0xA40000 0x0 0x800>;
+               #address-cells = <1>;
+               #size-cells = <0>;
+               #pinctrl-cells = <1>;
+               pinctrl-single,register-width = <32>;
+               pinctrl-single,function-mask = <0x800007ff>;
+       };

then signals routing can be done in board file, for example:
+#define TS_OFFSET(pa, val)     (0x4+(pa)*4) (0x80000000 | val)
+
+&timesync_router {
+       pinctrl-names = "default";
+       pinctrl-0 = <&mcu_cpts>;
+
+       /* Example of the timesync routing */
+       mcu_cpts: mcu_cpts {
+               pinctrl-single,pins = <
+                       /* [cpts genf1] in13 -> out25 [cpts hw4_push] */
+                       TS_OFFSET(25, 13)
+                       /* [cpts genf1] in13 -> out0 [main cpts hw1_push] */
+                       TS_OFFSET(0, 13)
+                       /* [main cpts genf0] in4 -> out1 [main cpts hw2_push] */
+                       TS_OFFSET(1, 4)
+                       /* [main cpts genf0] in4 -> out24 [cpts hw3_push] */
+                       TS_OFFSET(24, 4)
+               >;
+       };
+};

will create link:
    cpsw cpts Genf1 -> main cpts hw1_push
                    -> cpsw cpts hw4_push

    main cpts Genf0 -> main cpts hw2_push
                    -> cpsw cpts hw3_push

 testptp -d /dev/ptp0 -i 0 -p 1000000000
 periodic output request okay
 testptp -d /dev/ptp0 -i 1 -e 5
 external time stamp request okay
 event index 1 at 22583.000000025
 event index 1 at 22584.000000025
 event index 1 at 22585.000000025
 event index 1 at 22586.000000025
 event index 1 at 22587.000000025
 testptp -d /dev/ptp1 -i 2 -e 5
 external time stamp request okay
 event index 2 at 1587606764.249304554
 event index 2 at 1587606765.249304467
 event index 2 at 1587606766.249304380
 event index 2 at 1587606767.249304293
 event index 2 at 1587606768.249304206

[1] https://www.ti.com/lit/pdf/spracp7
[2] https://www.ti.com/lit/pdf/sprz452
[3] https://www.ti.com/lit/pdf/spruil1
====================
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 1248dc00 461d6d05
......@@ -144,6 +144,13 @@ patternProperties:
description:
CPSW MDIO bus.
"^cpts$":
type: object
allOf:
- $ref: "ti,am654-cpts.yaml#"
description:
CPSW Common Platform Time Sync (CPTS) module.
required:
- compatible
- reg
......
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
%YAML 1.2
---
$id: http://devicetree.org/schemas/net/ti,am654-cpts.yaml#
$schema: http://devicetree.org/meta-schemas/core.yaml#
title: The TI AM654x/J721E Common Platform Time Sync (CPTS) module Device Tree Bindings
maintainers:
- Grygorii Strashko <grygorii.strashko@ti.com>
- Sekhar Nori <nsekhar@ti.com>
description: |+
The TI AM654x/J721E CPTS module is used to facilitate host control of time
sync operations.
Main features of CPTS module are
- selection of multiple external clock sources
- Software control of time sync events via interrupt or polling
- 64-bit timestamp mode in ns with PPM and nudge adjustment.
- hardware timestamp push inputs (HWx_TS_PUSH)
- timestamp counter compare output (TS_COMP)
- timestamp counter bit output (TS_SYNC)
- periodic Generator function outputs (TS_GENFx)
- Ethernet Enhanced Scheduled Traffic Operations (CPTS_ESTFn) (TSN)
- external hardware timestamp push inputs (HWx_TS_PUSH) timestamping
Depending on integration it enables compliance with the IEEE 1588-2008
standard for a precision clock synchronization protocol, Ethernet Enhanced
Scheduled Traffic Operations (CPTS_ESTFn) and PCIe Subsystem Precision Time
Measurement (PTM).
TI AM654x/J721E SoCs has several similar CPTS modules integrated into the
different parts of the system which could be synchronized with each other
- Main CPTS
- MCU CPSW CPTS with IEEE 1588-2008 support
- PCIe subsystem CPTS for PTM support
Depending on CPTS module integration and when CPTS is integral part of
another module (MCU CPSW for example) "compatible" and "reg" can
be omitted - parent module is fully responsible for CPTS enabling and
configuration.
properties:
$nodename:
pattern: "^cpts(@.*|-[0-9a-f])*$"
compatible:
oneOf:
- const: ti,am65-cpts
- const: ti,j721e-cpts
reg:
maxItems: 1
description:
The physical base address and size of CPTS IO range
reg-names:
items:
- const: cpts
clocks:
description: CPTS reference clock
clock-names:
items:
- const: cpts
interrupts-extended:
items:
- description: CPTS events interrupt
interrupt-names:
items:
- const: "cpts"
ti,cpts-ext-ts-inputs:
allOf:
- $ref: /schemas/types.yaml#/definitions/uint32
maximum: 8
description:
Number of hardware timestamp push inputs (HWx_TS_PUSH)
ti,cpts-periodic-outputs:
allOf:
- $ref: /schemas/types.yaml#/definitions/uint32
maximum: 8
description:
Number of timestamp Generator function outputs (TS_GENFx)
refclk-mux:
type: object
description: CPTS reference clock multiplexer clock
properties:
'#clock-cells':
const: 0
clocks:
maxItems: 8
assigned-clocks:
maxItems: 1
assigned-clocks-parents:
maxItems: 1
required:
- clocks
required:
- clocks
- clock-names
- interrupts-extended
- interrupt-names
additionalProperties: false
examples:
- |
#include <dt-bindings/interrupt-controller/irq.h>
#include <dt-bindings/interrupt-controller/arm-gic.h>
cpts@310d0000 {
compatible = "ti,am65-cpts";
reg = <0x0 0x310d0000 0x0 0x400>;
reg-names = "cpts";
clocks = <&main_cpts_mux>;
clock-names = "cpts";
interrupts-extended = <&k3_irq 163 0 IRQ_TYPE_LEVEL_HIGH>;
interrupt-names = "cpts";
ti,cpts-periodic-outputs = <6>;
ti,cpts-ext-ts-inputs = <8>;
main_cpts_mux: refclk-mux {
#clock-cells = <0>;
clocks = <&k3_clks 118 5>, <&k3_clks 118 11>,
<&k3_clks 157 91>, <&k3_clks 157 77>,
<&k3_clks 157 102>, <&k3_clks 157 80>,
<&k3_clks 120 3>, <&k3_clks 121 3>;
assigned-clocks = <&main_cpts_mux>;
assigned-clock-parents = <&k3_clks 118 11>;
};
};
- |
cpts {
clocks = <&k3_clks 18 2>;
clock-names = "cpts";
interrupts-extended = <&gic500 GIC_SPI 858 IRQ_TYPE_LEVEL_HIGH>;
interrupt-names = "cpts";
ti,cpts-ext-ts-inputs = <4>;
ti,cpts-periodic-outputs = <2>;
};
......@@ -570,6 +570,28 @@ main_udmap: dma-controller@31150000 {
<0x5>; /* RX_CHAN */
ti,sci-rm-range-rflow = <0x6>; /* GP RFLOW */
};
cpts@310d0000 {
compatible = "ti,am65-cpts";
reg = <0x0 0x310d0000 0x0 0x400>;
reg-names = "cpts";
clocks = <&main_cpts_mux>;
clock-names = "cpts";
interrupts-extended = <&intr_main_navss 163 0>;
interrupt-names = "cpts";
ti,cpts-periodic-outputs = <6>;
ti,cpts-ext-ts-inputs = <8>;
main_cpts_mux: refclk-mux {
#clock-cells = <0>;
clocks = <&k3_clks 118 5>, <&k3_clks 118 11>,
<&k3_clks 118 6>, <&k3_clks 118 3>,
<&k3_clks 118 8>, <&k3_clks 118 14>,
<&k3_clks 120 3>, <&k3_clks 121 3>;
assigned-clocks = <&main_cpts_mux>;
assigned-clock-parents = <&k3_clks 118 5>;
};
};
};
main_gpio0: main_gpio0@600000 {
......
......@@ -247,5 +247,24 @@ davinci_mdio: mdio@f00 {
clock-names = "fck";
bus_freq = <1000000>;
};
cpts {
clocks = <&mcu_cpsw_cpts_mux>;
clock-names = "cpts";
interrupts-extended = <&gic500 GIC_SPI 570 IRQ_TYPE_LEVEL_HIGH>;
interrupt-names = "cpts";
ti,cpts-ext-ts-inputs = <4>;
ti,cpts-periodic-outputs = <2>;
mcu_cpsw_cpts_mux: refclk-mux {
#clock-cells = <0>;
clocks = <&k3_clks 118 5>, <&k3_clks 118 11>,
<&k3_clks 118 6>, <&k3_clks 118 3>,
<&k3_clks 118 8>, <&k3_clks 118 14>,
<&k3_clks 120 3>, <&k3_clks 121 3>;
assigned-clocks = <&mcu_cpsw_cpts_mux>;
assigned-clock-parents = <&k3_clks 118 5>;
};
};
};
};
......@@ -254,6 +254,18 @@ main_udmap: dma-controller@31150000 {
<0x0c>; /* RX_UHCHAN */
ti,sci-rm-range-rflow = <0x00>; /* GP RFLOW */
};
cpts@310d0000 {
compatible = "ti,j721e-cpts";
reg = <0x0 0x310d0000 0x0 0x400>;
reg-names = "cpts";
clocks = <&k3_clks 201 1>;
clock-names = "cpts";
interrupts-extended = <&main_navss_intr 201 0>;
interrupt-names = "cpts";
ti,cpts-periodic-outputs = <6>;
ti,cpts-ext-ts-inputs = <8>;
};
};
main_pmx0: pinmux@11c000 {
......
......@@ -338,5 +338,14 @@ davinci_mdio: mdio@f00 {
clock-names = "fck";
bus_freq = <1000000>;
};
cpts {
clocks = <&k3_clks 18 2>;
clock-names = "cpts";
interrupts-extended = <&gic500 GIC_SPI 858 IRQ_TYPE_LEVEL_HIGH>;
interrupt-names = "cpts";
ti,cpts-ext-ts-inputs = <4>;
ti,cpts-periodic-outputs = <2>;
};
};
};
......@@ -100,6 +100,7 @@ config TI_K3_AM65_CPSW_NUSS
depends on ARCH_K3 && OF && TI_K3_UDMA_GLUE_LAYER
select TI_DAVINCI_MDIO
imply PHY_TI_GMII_SEL
imply TI_AM65_CPTS
help
This driver supports TI K3 AM654/J721E CPSW2G Ethernet SubSystem.
The two-port Gigabit Ethernet MAC (MCU_CPSW0) subsystem provides
......@@ -110,6 +111,20 @@ config TI_K3_AM65_CPSW_NUSS
To compile this driver as a module, choose M here: the module
will be called ti-am65-cpsw-nuss.
config TI_K3_AM65_CPTS
tristate "TI K3 AM65x CPTS"
depends on ARCH_K3 && OF && PTP_1588_CLOCK
depends on PTP_1588_CLOCK
select NET_PTP_CLASSIFY
help
Say y here to support the TI K3 AM65x CPTS with 1588 features such as
PTP hardware clock for each CPTS device and network packets
timestamping where applicable.
Depending on integration CPTS blocks enable compliance with
the IEEE 1588-2008 standard for a precision clock synchronization
protocol, Ethernet Enhanced Scheduled Traffic Operations (CPTS_ESTFn)
and PCIe Subsystem Precision Time Measurement (PTM).
config TI_KEYSTONE_NETCP
tristate "TI Keystone NETCP Core Support"
select TI_DAVINCI_MDIO
......
......@@ -26,3 +26,4 @@ keystone_netcp_ethss-y := netcp_ethss.o netcp_sgmii.o netcp_xgbepcsr.o cpsw_ale.
obj-$(CONFIG_TI_K3_AM65_CPSW_NUSS) += ti-am65-cpsw-nuss.o
ti-am65-cpsw-nuss-y := am65-cpsw-nuss.o cpsw_sl.o am65-cpsw-ethtool.o cpsw_ale.o k3-cppi-desc-pool.o
obj-$(CONFIG_TI_K3_AM65_CPTS) += am65-cpts.o
......@@ -12,6 +12,7 @@
#include "am65-cpsw-nuss.h"
#include "cpsw_ale.h"
#include "am65-cpts.h"
#define AM65_CPSW_REGDUMP_VER 0x1
......@@ -694,6 +695,27 @@ static void am65_cpsw_get_ethtool_stats(struct net_device *ndev,
hw_stats[i].offset);
}
static int am65_cpsw_get_ethtool_ts_info(struct net_device *ndev,
struct ethtool_ts_info *info)
{
struct am65_cpsw_common *common = am65_ndev_to_common(ndev);
if (!IS_ENABLED(CONFIG_TI_K3_AM65_CPTS))
return ethtool_op_get_ts_info(ndev, info);
info->so_timestamping =
SOF_TIMESTAMPING_TX_HARDWARE |
SOF_TIMESTAMPING_TX_SOFTWARE |
SOF_TIMESTAMPING_RX_HARDWARE |
SOF_TIMESTAMPING_RX_SOFTWARE |
SOF_TIMESTAMPING_SOFTWARE |
SOF_TIMESTAMPING_RAW_HARDWARE;
info->phc_index = am65_cpts_phc_index(common->cpts);
info->tx_types = BIT(HWTSTAMP_TX_OFF) | BIT(HWTSTAMP_TX_ON);
info->rx_filters = BIT(HWTSTAMP_FILTER_NONE) | BIT(HWTSTAMP_FILTER_ALL);
return 0;
}
static u32 am65_cpsw_get_ethtool_priv_flags(struct net_device *ndev)
{
struct am65_cpsw_common *common = am65_ndev_to_common(ndev);
......@@ -730,7 +752,7 @@ const struct ethtool_ops am65_cpsw_ethtool_ops_slave = {
.get_sset_count = am65_cpsw_get_sset_count,
.get_strings = am65_cpsw_get_strings,
.get_ethtool_stats = am65_cpsw_get_ethtool_stats,
.get_ts_info = ethtool_op_get_ts_info,
.get_ts_info = am65_cpsw_get_ethtool_ts_info,
.get_priv_flags = am65_cpsw_get_ethtool_priv_flags,
.set_priv_flags = am65_cpsw_set_ethtool_priv_flags,
......
......@@ -30,6 +30,7 @@
#include "cpsw_sl.h"
#include "am65-cpsw-nuss.h"
#include "k3-cppi-desc-pool.h"
#include "am65-cpts.h"
#define AM65_CPSW_SS_BASE 0x0
#define AM65_CPSW_SGMII_BASE 0x100
......@@ -668,6 +669,18 @@ static void am65_cpsw_nuss_rx_cleanup(void *data, dma_addr_t desc_dma)
dev_kfree_skb_any(skb);
}
static void am65_cpsw_nuss_rx_ts(struct sk_buff *skb, u32 *psdata)
{
struct skb_shared_hwtstamps *ssh;
u64 ns;
ns = ((u64)psdata[1] << 32) | psdata[0];
ssh = skb_hwtstamps(skb);
memset(ssh, 0, sizeof(*ssh));
ssh->hwtstamp = ns_to_ktime(ns);
}
/* RX psdata[2] word format - checksum information */
#define AM65_CPSW_RX_PSD_CSUM_ADD GENMASK(15, 0)
#define AM65_CPSW_RX_PSD_CSUM_ERR BIT(16)
......@@ -745,6 +758,9 @@ static int am65_cpsw_nuss_rx_packets(struct am65_cpsw_common *common,
skb->dev = ndev;
psdata = cppi5_hdesc_get_psdata(desc_rx);
/* add RX timestamp */
if (port->rx_ts_enabled)
am65_cpsw_nuss_rx_ts(skb, psdata);
csum_info = psdata[2];
dev_dbg(dev, "%s rx csum_info:%#x\n", __func__, csum_info);
......@@ -904,6 +920,8 @@ static int am65_cpsw_nuss_tx_compl_packets(struct am65_cpsw_common *common,
ndev = skb->dev;
am65_cpts_tx_timestamp(common->cpts, skb);
ndev_priv = netdev_priv(ndev);
stats = this_cpu_ptr(ndev_priv->stats);
u64_stats_update_begin(&stats->syncp);
......@@ -995,6 +1013,10 @@ static netdev_tx_t am65_cpsw_nuss_ndo_slave_xmit(struct sk_buff *skb,
/* padding enabled in hw */
pkt_len = skb_headlen(skb);
/* SKB TX timestamp */
if (port->tx_ts_enabled)
am65_cpts_prep_tx_timestamp(common->cpts, skb);
q_idx = skb_get_queue_mapping(skb);
dev_dbg(dev, "%s skb_queue:%d\n", __func__, q_idx);
......@@ -1158,6 +1180,111 @@ static int am65_cpsw_nuss_ndo_slave_set_mac_address(struct net_device *ndev,
return 0;
}
static int am65_cpsw_nuss_hwtstamp_set(struct net_device *ndev,
struct ifreq *ifr)
{
struct am65_cpsw_common *common = am65_ndev_to_common(ndev);
struct am65_cpsw_port *port = am65_ndev_to_port(ndev);
u32 ts_ctrl, seq_id, ts_ctrl_ltype2, ts_vlan_ltype;
struct hwtstamp_config cfg;
if (!IS_ENABLED(CONFIG_TI_K3_AM65_CPTS))
return -EOPNOTSUPP;
if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
return -EFAULT;
/* TX HW timestamp */
switch (cfg.tx_type) {
case HWTSTAMP_TX_OFF:
case HWTSTAMP_TX_ON:
break;
default:
return -ERANGE;
}
switch (cfg.rx_filter) {
case HWTSTAMP_FILTER_NONE:
port->rx_ts_enabled = 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:
case HWTSTAMP_FILTER_NTP_ALL:
port->rx_ts_enabled = true;
cfg.rx_filter = HWTSTAMP_FILTER_ALL;
break;
default:
return -ERANGE;
}
port->tx_ts_enabled = (cfg.tx_type == HWTSTAMP_TX_ON);
/* cfg TX timestamp */
seq_id = (AM65_CPSW_TS_SEQ_ID_OFFSET <<
AM65_CPSW_PN_TS_SEQ_ID_OFFSET_SHIFT) | ETH_P_1588;
ts_vlan_ltype = ETH_P_8021Q;
ts_ctrl_ltype2 = ETH_P_1588 |
AM65_CPSW_PN_TS_CTL_LTYPE2_TS_107 |
AM65_CPSW_PN_TS_CTL_LTYPE2_TS_129 |
AM65_CPSW_PN_TS_CTL_LTYPE2_TS_130 |
AM65_CPSW_PN_TS_CTL_LTYPE2_TS_131 |
AM65_CPSW_PN_TS_CTL_LTYPE2_TS_132 |
AM65_CPSW_PN_TS_CTL_LTYPE2_TS_319 |
AM65_CPSW_PN_TS_CTL_LTYPE2_TS_320 |
AM65_CPSW_PN_TS_CTL_LTYPE2_TS_TTL_NONZERO;
ts_ctrl = AM65_CPSW_TS_EVENT_MSG_TYPE_BITS <<
AM65_CPSW_PN_TS_CTL_MSG_TYPE_EN_SHIFT;
if (port->tx_ts_enabled)
ts_ctrl |= AM65_CPSW_TS_TX_ANX_ALL_EN |
AM65_CPSW_PN_TS_CTL_TX_VLAN_LT1_EN;
writel(seq_id, port->port_base + AM65_CPSW_PORTN_REG_TS_SEQ_LTYPE_REG);
writel(ts_vlan_ltype, port->port_base +
AM65_CPSW_PORTN_REG_TS_VLAN_LTYPE_REG);
writel(ts_ctrl_ltype2, port->port_base +
AM65_CPSW_PORTN_REG_TS_CTL_LTYPE2);
writel(ts_ctrl, port->port_base + AM65_CPSW_PORTN_REG_TS_CTL);
/* en/dis RX timestamp */
am65_cpts_rx_enable(common->cpts, port->rx_ts_enabled);
return copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg)) ? -EFAULT : 0;
}
static int am65_cpsw_nuss_hwtstamp_get(struct net_device *ndev,
struct ifreq *ifr)
{
struct am65_cpsw_port *port = am65_ndev_to_port(ndev);
struct hwtstamp_config cfg;
if (!IS_ENABLED(CONFIG_TI_K3_AM65_CPTS))
return -EOPNOTSUPP;
cfg.flags = 0;
cfg.tx_type = port->tx_ts_enabled ?
HWTSTAMP_TX_ON : HWTSTAMP_TX_OFF;
cfg.rx_filter = port->rx_ts_enabled ?
HWTSTAMP_FILTER_ALL : HWTSTAMP_FILTER_NONE;
return copy_to_user(ifr->ifr_data, &cfg, sizeof(cfg)) ? -EFAULT : 0;
}
static int am65_cpsw_nuss_ndo_slave_ioctl(struct net_device *ndev,
struct ifreq *req, int cmd)
{
......@@ -1166,6 +1293,13 @@ static int am65_cpsw_nuss_ndo_slave_ioctl(struct net_device *ndev,
if (!netif_running(ndev))
return -EINVAL;
switch (cmd) {
case SIOCSHWTSTAMP:
return am65_cpsw_nuss_hwtstamp_set(ndev, req);
case SIOCGHWTSTAMP:
return am65_cpsw_nuss_hwtstamp_get(ndev, req);
}
if (!port->slave.phy)
return -EOPNOTSUPP;
......@@ -1531,6 +1665,40 @@ static int am65_cpsw_am654_get_efuse_macid(struct device_node *of_node,
return 0;
}
static int am65_cpsw_init_cpts(struct am65_cpsw_common *common)
{
struct device *dev = common->dev;
struct device_node *node;
struct am65_cpts *cpts;
void __iomem *reg_base;
if (!IS_ENABLED(CONFIG_TI_K3_AM65_CPTS))
return 0;
node = of_get_child_by_name(dev->of_node, "cpts");
if (!node) {
dev_err(dev, "%s cpts not found\n", __func__);
return -ENOENT;
}
reg_base = common->cpsw_base + AM65_CPSW_NU_CPTS_BASE;
cpts = am65_cpts_create(dev, reg_base, node);
if (IS_ERR(cpts)) {
int ret = PTR_ERR(cpts);
if (ret == -EOPNOTSUPP) {
dev_info(dev, "cpts disabled\n");
return 0;
}
dev_err(dev, "cpts create err %d\n", ret);
return ret;
}
common->cpts = cpts;
return 0;
}
static int am65_cpsw_nuss_init_slave_ports(struct am65_cpsw_common *common)
{
struct device_node *node, *port_np;
......@@ -1899,6 +2067,10 @@ static int am65_cpsw_nuss_probe(struct platform_device *pdev)
goto err_of_clear;
}
ret = am65_cpsw_init_cpts(common);
if (ret)
goto err_of_clear;
/* init ports */
for (i = 0; i < common->port_num; i++)
am65_cpsw_nuss_slave_disable_unused(&common->ports[i]);
......
......@@ -10,6 +10,8 @@
#include <linux/module.h>
#include <linux/netdevice.h>
struct am65_cpts;
#define HOST_PORT_NUM 0
#define AM65_CPSW_MAX_TX_QUEUES 8
......@@ -37,6 +39,8 @@ struct am65_cpsw_port {
void __iomem *stat_base;
bool disabled;
struct am65_cpsw_slave_data slave;
bool tx_ts_enabled;
bool rx_ts_enabled;
};
struct am65_cpsw_host {
......@@ -96,8 +100,8 @@ struct am65_cpsw_common {
u32 nuss_ver;
u32 cpsw_ver;
bool pf_p0_rx_ptype_rrobin;
struct am65_cpts *cpts;
};
struct am65_cpsw_ndev_stats {
......
// SPDX-License-Identifier: GPL-2.0
/* TI K3 AM65x Common Platform Time Sync
*
* Copyright (C) 2020 Texas Instruments Incorporated - http://www.ti.com
*
*/
#include <linux/clk.h>
#include <linux/clk-provider.h>
#include <linux/err.h>
#include <linux/if_vlan.h>
#include <linux/interrupt.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/net_tstamp.h>
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/platform_device.h>
#include <linux/pm_runtime.h>
#include <linux/ptp_classify.h>
#include <linux/ptp_clock_kernel.h>
#include "am65-cpts.h"
struct am65_genf_regs {
u32 comp_lo; /* Comparison Low Value 0:31 */
u32 comp_hi; /* Comparison High Value 32:63 */
u32 control; /* control */
u32 length; /* Length */
u32 ppm_low; /* PPM Load Low Value 0:31 */
u32 ppm_hi; /* PPM Load High Value 32:63 */
u32 ts_nudge; /* Nudge value */
} __aligned(32) __packed;
#define AM65_CPTS_GENF_MAX_NUM 9
#define AM65_CPTS_ESTF_MAX_NUM 8
struct am65_cpts_regs {
u32 idver; /* Identification and version */
u32 control; /* Time sync control */
u32 rftclk_sel; /* Reference Clock Select Register */
u32 ts_push; /* Time stamp event push */
u32 ts_load_val_lo; /* Time Stamp Load Low Value 0:31 */
u32 ts_load_en; /* Time stamp load enable */
u32 ts_comp_lo; /* Time Stamp Comparison Low Value 0:31 */
u32 ts_comp_length; /* Time Stamp Comparison Length */
u32 intstat_raw; /* Time sync interrupt status raw */
u32 intstat_masked; /* Time sync interrupt status masked */
u32 int_enable; /* Time sync interrupt enable */
u32 ts_comp_nudge; /* Time Stamp Comparison Nudge Value */
u32 event_pop; /* Event interrupt pop */
u32 event_0; /* Event Time Stamp lo 0:31 */
u32 event_1; /* Event Type Fields */
u32 event_2; /* Event Type Fields domain */
u32 event_3; /* Event Time Stamp hi 32:63 */
u32 ts_load_val_hi; /* Time Stamp Load High Value 32:63 */
u32 ts_comp_hi; /* Time Stamp Comparison High Value 32:63 */
u32 ts_add_val; /* Time Stamp Add value */
u32 ts_ppm_low; /* Time Stamp PPM Load Low Value 0:31 */
u32 ts_ppm_hi; /* Time Stamp PPM Load High Value 32:63 */
u32 ts_nudge; /* Time Stamp Nudge value */
u32 reserv[33];
struct am65_genf_regs genf[AM65_CPTS_GENF_MAX_NUM];
struct am65_genf_regs estf[AM65_CPTS_ESTF_MAX_NUM];
};
/* CONTROL_REG */
#define AM65_CPTS_CONTROL_EN BIT(0)
#define AM65_CPTS_CONTROL_INT_TEST BIT(1)
#define AM65_CPTS_CONTROL_TS_COMP_POLARITY BIT(2)
#define AM65_CPTS_CONTROL_TSTAMP_EN BIT(3)
#define AM65_CPTS_CONTROL_SEQUENCE_EN BIT(4)
#define AM65_CPTS_CONTROL_64MODE BIT(5)
#define AM65_CPTS_CONTROL_TS_COMP_TOG BIT(6)
#define AM65_CPTS_CONTROL_TS_PPM_DIR BIT(7)
#define AM65_CPTS_CONTROL_HW1_TS_PUSH_EN BIT(8)
#define AM65_CPTS_CONTROL_HW2_TS_PUSH_EN BIT(9)
#define AM65_CPTS_CONTROL_HW3_TS_PUSH_EN BIT(10)
#define AM65_CPTS_CONTROL_HW4_TS_PUSH_EN BIT(11)
#define AM65_CPTS_CONTROL_HW5_TS_PUSH_EN BIT(12)
#define AM65_CPTS_CONTROL_HW6_TS_PUSH_EN BIT(13)
#define AM65_CPTS_CONTROL_HW7_TS_PUSH_EN BIT(14)
#define AM65_CPTS_CONTROL_HW8_TS_PUSH_EN BIT(15)
#define AM65_CPTS_CONTROL_HW1_TS_PUSH_OFFSET (8)
#define AM65_CPTS_CONTROL_TS_SYNC_SEL_MASK (0xF)
#define AM65_CPTS_CONTROL_TS_SYNC_SEL_SHIFT (28)
/* RFTCLK_SEL_REG */
#define AM65_CPTS_RFTCLK_SEL_MASK (0x1F)
/* TS_PUSH_REG */
#define AM65_CPTS_TS_PUSH BIT(0)
/* TS_LOAD_EN_REG */
#define AM65_CPTS_TS_LOAD_EN BIT(0)
/* INTSTAT_RAW_REG */
#define AM65_CPTS_INTSTAT_RAW_TS_PEND BIT(0)
/* INTSTAT_MASKED_REG */
#define AM65_CPTS_INTSTAT_MASKED_TS_PEND BIT(0)
/* INT_ENABLE_REG */
#define AM65_CPTS_INT_ENABLE_TS_PEND_EN BIT(0)
/* TS_COMP_NUDGE_REG */
#define AM65_CPTS_TS_COMP_NUDGE_MASK (0xFF)
/* EVENT_POP_REG */
#define AM65_CPTS_EVENT_POP BIT(0)
/* EVENT_1_REG */
#define AM65_CPTS_EVENT_1_SEQUENCE_ID_MASK GENMASK(15, 0)
#define AM65_CPTS_EVENT_1_MESSAGE_TYPE_MASK GENMASK(19, 16)
#define AM65_CPTS_EVENT_1_MESSAGE_TYPE_SHIFT (16)
#define AM65_CPTS_EVENT_1_EVENT_TYPE_MASK GENMASK(23, 20)
#define AM65_CPTS_EVENT_1_EVENT_TYPE_SHIFT (20)
#define AM65_CPTS_EVENT_1_PORT_NUMBER_MASK GENMASK(28, 24)
#define AM65_CPTS_EVENT_1_PORT_NUMBER_SHIFT (24)
/* EVENT_2_REG */
#define AM65_CPTS_EVENT_2_REG_DOMAIN_MASK (0xFF)
#define AM65_CPTS_EVENT_2_REG_DOMAIN_SHIFT (0)
enum {
AM65_CPTS_EV_PUSH, /* Time Stamp Push Event */
AM65_CPTS_EV_ROLL, /* Time Stamp Rollover Event */
AM65_CPTS_EV_HALF, /* Time Stamp Half Rollover Event */
AM65_CPTS_EV_HW, /* Hardware Time Stamp Push Event */
AM65_CPTS_EV_RX, /* Ethernet Receive Event */
AM65_CPTS_EV_TX, /* Ethernet Transmit Event */
AM65_CPTS_EV_TS_COMP, /* Time Stamp Compare Event */
AM65_CPTS_EV_HOST, /* Host Transmit Event */
};
struct am65_cpts_event {
struct list_head list;
unsigned long tmo;
u32 event1;
u32 event2;
u64 timestamp;
};
#define AM65_CPTS_FIFO_DEPTH (16)
#define AM65_CPTS_MAX_EVENTS (32)
#define AM65_CPTS_EVENT_RX_TX_TIMEOUT (20) /* ms */
#define AM65_CPTS_SKB_TX_WORK_TIMEOUT 1 /* jiffies */
#define AM65_CPTS_MIN_PPM 0x400
struct am65_cpts {
struct device *dev;
struct am65_cpts_regs __iomem *reg;
struct ptp_clock_info ptp_info;
struct ptp_clock *ptp_clock;
int phc_index;
struct clk_hw *clk_mux_hw;
struct device_node *clk_mux_np;
struct clk *refclk;
u32 refclk_freq;
struct list_head events;
struct list_head pool;
struct am65_cpts_event pool_data[AM65_CPTS_MAX_EVENTS];
spinlock_t lock; /* protects events lists*/
u32 ext_ts_inputs;
u32 genf_num;
u32 ts_add_val;
int irq;
struct mutex ptp_clk_lock; /* PHC access sync */
u64 timestamp;
u32 genf_enable;
u32 hw_ts_enable;
struct sk_buff_head txq;
};
struct am65_cpts_skb_cb_data {
unsigned long tmo;
u32 skb_mtype_seqid;
};
#define am65_cpts_write32(c, v, r) writel(v, &(c)->reg->r)
#define am65_cpts_read32(c, r) readl(&(c)->reg->r)
static void am65_cpts_settime(struct am65_cpts *cpts, u64 start_tstamp)
{
u32 val;
val = upper_32_bits(start_tstamp);
am65_cpts_write32(cpts, val, ts_load_val_hi);
val = lower_32_bits(start_tstamp);
am65_cpts_write32(cpts, val, ts_load_val_lo);
am65_cpts_write32(cpts, AM65_CPTS_TS_LOAD_EN, ts_load_en);
}
static void am65_cpts_set_add_val(struct am65_cpts *cpts)
{
/* select coefficient according to the rate */
cpts->ts_add_val = (NSEC_PER_SEC / cpts->refclk_freq - 1) & 0x7;
am65_cpts_write32(cpts, cpts->ts_add_val, ts_add_val);
}
static void am65_cpts_disable(struct am65_cpts *cpts)
{
am65_cpts_write32(cpts, 0, control);
am65_cpts_write32(cpts, 0, int_enable);
}
static int am65_cpts_event_get_port(struct am65_cpts_event *event)
{
return (event->event1 & AM65_CPTS_EVENT_1_PORT_NUMBER_MASK) >>
AM65_CPTS_EVENT_1_PORT_NUMBER_SHIFT;
}
static int am65_cpts_event_get_type(struct am65_cpts_event *event)
{
return (event->event1 & AM65_CPTS_EVENT_1_EVENT_TYPE_MASK) >>
AM65_CPTS_EVENT_1_EVENT_TYPE_SHIFT;
}
static int am65_cpts_cpts_purge_events(struct am65_cpts *cpts)
{
struct list_head *this, *next;
struct am65_cpts_event *event;
int removed = 0;
list_for_each_safe(this, next, &cpts->events) {
event = list_entry(this, struct am65_cpts_event, list);
if (time_after(jiffies, event->tmo)) {
list_del_init(&event->list);
list_add(&event->list, &cpts->pool);
++removed;
}
}
if (removed)
dev_dbg(cpts->dev, "event pool cleaned up %d\n", removed);
return removed ? 0 : -1;
}
static bool am65_cpts_fifo_pop_event(struct am65_cpts *cpts,
struct am65_cpts_event *event)
{
u32 r = am65_cpts_read32(cpts, intstat_raw);
if (r & AM65_CPTS_INTSTAT_RAW_TS_PEND) {
event->timestamp = am65_cpts_read32(cpts, event_0);
event->event1 = am65_cpts_read32(cpts, event_1);
event->event2 = am65_cpts_read32(cpts, event_2);
event->timestamp |= (u64)am65_cpts_read32(cpts, event_3) << 32;
am65_cpts_write32(cpts, AM65_CPTS_EVENT_POP, event_pop);
return false;
}
return true;
}
static int am65_cpts_fifo_read(struct am65_cpts *cpts)
{
struct ptp_clock_event pevent;
struct am65_cpts_event *event;
bool schedule = false;
int i, type, ret = 0;
unsigned long flags;
spin_lock_irqsave(&cpts->lock, flags);
for (i = 0; i < AM65_CPTS_FIFO_DEPTH; i++) {
event = list_first_entry_or_null(&cpts->pool,
struct am65_cpts_event, list);
if (!event) {
if (am65_cpts_cpts_purge_events(cpts)) {
dev_err(cpts->dev, "cpts: event pool empty\n");
ret = -1;
goto out;
}
continue;
}
if (am65_cpts_fifo_pop_event(cpts, event))
break;
type = am65_cpts_event_get_type(event);
switch (type) {
case AM65_CPTS_EV_PUSH:
cpts->timestamp = event->timestamp;
dev_dbg(cpts->dev, "AM65_CPTS_EV_PUSH t:%llu\n",
cpts->timestamp);
break;
case AM65_CPTS_EV_RX:
case AM65_CPTS_EV_TX:
event->tmo = jiffies +
msecs_to_jiffies(AM65_CPTS_EVENT_RX_TX_TIMEOUT);
list_del_init(&event->list);
list_add_tail(&event->list, &cpts->events);
dev_dbg(cpts->dev,
"AM65_CPTS_EV_TX e1:%08x e2:%08x t:%lld\n",
event->event1, event->event2,
event->timestamp);
schedule = true;
break;
case AM65_CPTS_EV_HW:
pevent.index = am65_cpts_event_get_port(event) - 1;
pevent.timestamp = event->timestamp;
pevent.type = PTP_CLOCK_EXTTS;
dev_dbg(cpts->dev, "AM65_CPTS_EV_HW p:%d t:%llu\n",
pevent.index, event->timestamp);
ptp_clock_event(cpts->ptp_clock, &pevent);
break;
case AM65_CPTS_EV_HOST:
break;
case AM65_CPTS_EV_ROLL:
case AM65_CPTS_EV_HALF:
case AM65_CPTS_EV_TS_COMP:
dev_dbg(cpts->dev,
"AM65_CPTS_EVT: %d e1:%08x e2:%08x t:%lld\n",
type,
event->event1, event->event2,
event->timestamp);
break;
default:
dev_err(cpts->dev, "cpts: unknown event type\n");
ret = -1;
goto out;
}
}
out:
spin_unlock_irqrestore(&cpts->lock, flags);
if (schedule)
ptp_schedule_worker(cpts->ptp_clock, 0);
return ret;
}
static u64 am65_cpts_gettime(struct am65_cpts *cpts,
struct ptp_system_timestamp *sts)
{
unsigned long flags;
u64 val = 0;
/* temporarily disable cpts interrupt to avoid intentional
* doubled read. Interrupt can be in-flight - it's Ok.
*/
am65_cpts_write32(cpts, 0, int_enable);
/* use spin_lock_irqsave() here as it has to run very fast */
spin_lock_irqsave(&cpts->lock, flags);
ptp_read_system_prets(sts);
am65_cpts_write32(cpts, AM65_CPTS_TS_PUSH, ts_push);
am65_cpts_read32(cpts, ts_push);
ptp_read_system_postts(sts);
spin_unlock_irqrestore(&cpts->lock, flags);
am65_cpts_fifo_read(cpts);
am65_cpts_write32(cpts, AM65_CPTS_INT_ENABLE_TS_PEND_EN, int_enable);
val = cpts->timestamp;
return val;
}
static irqreturn_t am65_cpts_interrupt(int irq, void *dev_id)
{
struct am65_cpts *cpts = dev_id;
if (am65_cpts_fifo_read(cpts))
dev_dbg(cpts->dev, "cpts: unable to obtain a time stamp\n");
return IRQ_HANDLED;
}
/* PTP clock operations */
static int am65_cpts_ptp_adjfreq(struct ptp_clock_info *ptp, s32 ppb)
{
struct am65_cpts *cpts = container_of(ptp, struct am65_cpts, ptp_info);
int neg_adj = 0;
u64 adj_period;
u32 val;
if (ppb < 0) {
neg_adj = 1;
ppb = -ppb;
}
/* base freq = 1GHz = 1 000 000 000
* ppb_norm = ppb * base_freq / clock_freq;
* ppm_norm = ppb_norm / 1000
* adj_period = 1 000 000 / ppm_norm
* adj_period = 1 000 000 000 / ppb_norm
* adj_period = 1 000 000 000 / (ppb * base_freq / clock_freq)
* adj_period = (1 000 000 000 * clock_freq) / (ppb * base_freq)
* adj_period = clock_freq / ppb
*/
adj_period = div_u64(cpts->refclk_freq, ppb);
mutex_lock(&cpts->ptp_clk_lock);
val = am65_cpts_read32(cpts, control);
if (neg_adj)
val |= AM65_CPTS_CONTROL_TS_PPM_DIR;
else
val &= ~AM65_CPTS_CONTROL_TS_PPM_DIR;
am65_cpts_write32(cpts, val, control);
val = upper_32_bits(adj_period) & 0x3FF;
am65_cpts_write32(cpts, val, ts_ppm_hi);
val = lower_32_bits(adj_period);
am65_cpts_write32(cpts, val, ts_ppm_low);
mutex_unlock(&cpts->ptp_clk_lock);
return 0;
}
static int am65_cpts_ptp_adjtime(struct ptp_clock_info *ptp, s64 delta)
{
struct am65_cpts *cpts = container_of(ptp, struct am65_cpts, ptp_info);
s64 ns;
mutex_lock(&cpts->ptp_clk_lock);
ns = am65_cpts_gettime(cpts, NULL);
ns += delta;
am65_cpts_settime(cpts, ns);
mutex_unlock(&cpts->ptp_clk_lock);
return 0;
}
static int am65_cpts_ptp_gettimex(struct ptp_clock_info *ptp,
struct timespec64 *ts,
struct ptp_system_timestamp *sts)
{
struct am65_cpts *cpts = container_of(ptp, struct am65_cpts, ptp_info);
u64 ns;
mutex_lock(&cpts->ptp_clk_lock);
ns = am65_cpts_gettime(cpts, sts);
mutex_unlock(&cpts->ptp_clk_lock);
*ts = ns_to_timespec64(ns);
return 0;
}
static int am65_cpts_ptp_settime(struct ptp_clock_info *ptp,
const struct timespec64 *ts)
{
struct am65_cpts *cpts = container_of(ptp, struct am65_cpts, ptp_info);
u64 ns;
ns = timespec64_to_ns(ts);
mutex_lock(&cpts->ptp_clk_lock);
am65_cpts_settime(cpts, ns);
mutex_unlock(&cpts->ptp_clk_lock);
return 0;
}
static void am65_cpts_extts_enable_hw(struct am65_cpts *cpts, u32 index, int on)
{
u32 v;
v = am65_cpts_read32(cpts, control);
if (on) {
v |= BIT(AM65_CPTS_CONTROL_HW1_TS_PUSH_OFFSET + index);
cpts->hw_ts_enable |= BIT(index);
} else {
v &= ~BIT(AM65_CPTS_CONTROL_HW1_TS_PUSH_OFFSET + index);
cpts->hw_ts_enable &= ~BIT(index);
}
am65_cpts_write32(cpts, v, control);
}
static int am65_cpts_extts_enable(struct am65_cpts *cpts, u32 index, int on)
{
if (!!(cpts->hw_ts_enable & BIT(index)) == !!on)
return 0;
mutex_lock(&cpts->ptp_clk_lock);
am65_cpts_extts_enable_hw(cpts, index, on);
mutex_unlock(&cpts->ptp_clk_lock);
dev_dbg(cpts->dev, "%s: ExtTS:%u %s\n",
__func__, index, on ? "enabled" : "disabled");
return 0;
}
static void am65_cpts_perout_enable_hw(struct am65_cpts *cpts,
struct ptp_perout_request *req, int on)
{
u64 ns_period, ns_start, cycles;
struct timespec64 ts;
u32 val;
if (on) {
ts.tv_sec = req->period.sec;
ts.tv_nsec = req->period.nsec;
ns_period = timespec64_to_ns(&ts);
cycles = (ns_period * cpts->refclk_freq) / NSEC_PER_SEC;
ts.tv_sec = req->start.sec;
ts.tv_nsec = req->start.nsec;
ns_start = timespec64_to_ns(&ts);
val = upper_32_bits(ns_start);
am65_cpts_write32(cpts, val, genf[req->index].comp_hi);
val = lower_32_bits(ns_start);
am65_cpts_write32(cpts, val, genf[req->index].comp_lo);
val = lower_32_bits(cycles);
am65_cpts_write32(cpts, val, genf[req->index].length);
cpts->genf_enable |= BIT(req->index);
} else {
am65_cpts_write32(cpts, 0, genf[req->index].length);
cpts->genf_enable &= ~BIT(req->index);
}
}
static int am65_cpts_perout_enable(struct am65_cpts *cpts,
struct ptp_perout_request *req, int on)
{
if (!!(cpts->genf_enable & BIT(req->index)) == !!on)
return 0;
mutex_lock(&cpts->ptp_clk_lock);
am65_cpts_perout_enable_hw(cpts, req, on);
mutex_unlock(&cpts->ptp_clk_lock);
dev_dbg(cpts->dev, "%s: GenF:%u %s\n",
__func__, req->index, on ? "enabled" : "disabled");
return 0;
}
static int am65_cpts_ptp_enable(struct ptp_clock_info *ptp,
struct ptp_clock_request *rq, int on)
{
struct am65_cpts *cpts = container_of(ptp, struct am65_cpts, ptp_info);
switch (rq->type) {
case PTP_CLK_REQ_EXTTS:
return am65_cpts_extts_enable(cpts, rq->extts.index, on);
case PTP_CLK_REQ_PEROUT:
return am65_cpts_perout_enable(cpts, &rq->perout, on);
default:
break;
}
return -EOPNOTSUPP;
}
static long am65_cpts_ts_work(struct ptp_clock_info *ptp);
static struct ptp_clock_info am65_ptp_info = {
.owner = THIS_MODULE,
.name = "CTPS timer",
.adjfreq = am65_cpts_ptp_adjfreq,
.adjtime = am65_cpts_ptp_adjtime,
.gettimex64 = am65_cpts_ptp_gettimex,
.settime64 = am65_cpts_ptp_settime,
.enable = am65_cpts_ptp_enable,
.do_aux_work = am65_cpts_ts_work,
};
static bool am65_cpts_match_tx_ts(struct am65_cpts *cpts,
struct am65_cpts_event *event)
{
struct sk_buff_head txq_list;
struct sk_buff *skb, *tmp;
unsigned long flags;
bool found = false;
u32 mtype_seqid;
mtype_seqid = event->event1 &
(AM65_CPTS_EVENT_1_MESSAGE_TYPE_MASK |
AM65_CPTS_EVENT_1_EVENT_TYPE_MASK |
AM65_CPTS_EVENT_1_SEQUENCE_ID_MASK);
__skb_queue_head_init(&txq_list);
spin_lock_irqsave(&cpts->txq.lock, flags);
skb_queue_splice_init(&cpts->txq, &txq_list);
spin_unlock_irqrestore(&cpts->txq.lock, flags);
/* no need to grab txq.lock as access is always done under cpts->lock */
skb_queue_walk_safe(&txq_list, skb, tmp) {
struct skb_shared_hwtstamps ssh;
struct am65_cpts_skb_cb_data *skb_cb =
(struct am65_cpts_skb_cb_data *)skb->cb;
if (mtype_seqid == skb_cb->skb_mtype_seqid) {
u64 ns = event->timestamp;
memset(&ssh, 0, sizeof(ssh));
ssh.hwtstamp = ns_to_ktime(ns);
skb_tstamp_tx(skb, &ssh);
found = true;
__skb_unlink(skb, &txq_list);
dev_consume_skb_any(skb);
dev_dbg(cpts->dev,
"match tx timestamp mtype_seqid %08x\n",
mtype_seqid);
break;
}
if (time_after(jiffies, skb_cb->tmo)) {
/* timeout any expired skbs over 100 ms */
dev_dbg(cpts->dev,
"expiring tx timestamp mtype_seqid %08x\n",
mtype_seqid);
__skb_unlink(skb, &txq_list);
dev_consume_skb_any(skb);
}
}
spin_lock_irqsave(&cpts->txq.lock, flags);
skb_queue_splice(&txq_list, &cpts->txq);
spin_unlock_irqrestore(&cpts->txq.lock, flags);
return found;
}
static void am65_cpts_find_ts(struct am65_cpts *cpts)
{
struct am65_cpts_event *event;
struct list_head *this, *next;
LIST_HEAD(events_free);
unsigned long flags;
LIST_HEAD(events);
spin_lock_irqsave(&cpts->lock, flags);
list_splice_init(&cpts->events, &events);
spin_unlock_irqrestore(&cpts->lock, flags);
list_for_each_safe(this, next, &events) {
event = list_entry(this, struct am65_cpts_event, list);
if (am65_cpts_match_tx_ts(cpts, event) ||
time_after(jiffies, event->tmo)) {
list_del_init(&event->list);
list_add(&event->list, &events_free);
}
}
spin_lock_irqsave(&cpts->lock, flags);
list_splice_tail(&events, &cpts->events);
list_splice_tail(&events_free, &cpts->pool);
spin_unlock_irqrestore(&cpts->lock, flags);
}
static long am65_cpts_ts_work(struct ptp_clock_info *ptp)
{
struct am65_cpts *cpts = container_of(ptp, struct am65_cpts, ptp_info);
unsigned long flags;
long delay = -1;
am65_cpts_find_ts(cpts);
spin_lock_irqsave(&cpts->txq.lock, flags);
if (!skb_queue_empty(&cpts->txq))
delay = AM65_CPTS_SKB_TX_WORK_TIMEOUT;
spin_unlock_irqrestore(&cpts->txq.lock, flags);
return delay;
}
/**
* am65_cpts_rx_enable - enable rx timestamping
* @cpts: cpts handle
* @skb: packet
*
* This functions enables rx packets timestamping. The CPTS can timestamp all
* rx packets.
*/
void am65_cpts_rx_enable(struct am65_cpts *cpts, bool en)
{
u32 val;
mutex_lock(&cpts->ptp_clk_lock);
val = am65_cpts_read32(cpts, control);
if (en)
val |= AM65_CPTS_CONTROL_TSTAMP_EN;
else
val &= ~AM65_CPTS_CONTROL_TSTAMP_EN;
am65_cpts_write32(cpts, val, control);
mutex_unlock(&cpts->ptp_clk_lock);
}
EXPORT_SYMBOL_GPL(am65_cpts_rx_enable);
static int am65_skb_get_mtype_seqid(struct sk_buff *skb, u32 *mtype_seqid)
{
unsigned int ptp_class = ptp_classify_raw(skb);
u8 *msgtype, *data = skb->data;
unsigned int offset = 0;
__be16 *seqid;
if (ptp_class == PTP_CLASS_NONE)
return 0;
if (ptp_class & PTP_CLASS_VLAN)
offset += VLAN_HLEN;
switch (ptp_class & PTP_CLASS_PMASK) {
case PTP_CLASS_IPV4:
offset += ETH_HLEN + IPV4_HLEN(data + offset) + UDP_HLEN;
break;
case PTP_CLASS_IPV6:
offset += ETH_HLEN + IP6_HLEN + UDP_HLEN;
break;
case PTP_CLASS_L2:
offset += ETH_HLEN;
break;
default:
return 0;
}
if (skb->len + ETH_HLEN < offset + OFF_PTP_SEQUENCE_ID + sizeof(*seqid))
return 0;
if (unlikely(ptp_class & PTP_CLASS_V1))
msgtype = data + offset + OFF_PTP_CONTROL;
else
msgtype = data + offset;
seqid = (__be16 *)(data + offset + OFF_PTP_SEQUENCE_ID);
*mtype_seqid = (*msgtype << AM65_CPTS_EVENT_1_MESSAGE_TYPE_SHIFT) &
AM65_CPTS_EVENT_1_MESSAGE_TYPE_MASK;
*mtype_seqid |= (ntohs(*seqid) & AM65_CPTS_EVENT_1_SEQUENCE_ID_MASK);
return 1;
}
/**
* am65_cpts_tx_timestamp - save tx packet for timestamping
* @cpts: cpts handle
* @skb: packet
*
* This functions saves tx packet for timestamping if packet can be timestamped.
* The future processing is done in from PTP auxiliary worker.
*/
void am65_cpts_tx_timestamp(struct am65_cpts *cpts, struct sk_buff *skb)
{
struct am65_cpts_skb_cb_data *skb_cb = (void *)skb->cb;
if (!(skb_shinfo(skb)->tx_flags & SKBTX_IN_PROGRESS))
return;
/* add frame to queue for processing later.
* The periodic FIFO check will handle this.
*/
skb_get(skb);
/* get the timestamp for timeouts */
skb_cb->tmo = jiffies + msecs_to_jiffies(100);
skb_queue_tail(&cpts->txq, skb);
ptp_schedule_worker(cpts->ptp_clock, 0);
}
EXPORT_SYMBOL_GPL(am65_cpts_tx_timestamp);
/**
* am65_cpts_prep_tx_timestamp - check and prepare tx packet for timestamping
* @cpts: cpts handle
* @skb: packet
*
* This functions should be called from .xmit().
* It checks if packet can be timestamped, fills internal cpts data
* in skb-cb and marks packet as SKBTX_IN_PROGRESS.
*/
void am65_cpts_prep_tx_timestamp(struct am65_cpts *cpts, struct sk_buff *skb)
{
struct am65_cpts_skb_cb_data *skb_cb = (void *)skb->cb;
int ret;
if (!(skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP))
return;
ret = am65_skb_get_mtype_seqid(skb, &skb_cb->skb_mtype_seqid);
if (!ret)
return;
skb_cb->skb_mtype_seqid |= (AM65_CPTS_EV_TX <<
AM65_CPTS_EVENT_1_EVENT_TYPE_SHIFT);
skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
}
EXPORT_SYMBOL_GPL(am65_cpts_prep_tx_timestamp);
int am65_cpts_phc_index(struct am65_cpts *cpts)
{
return cpts->phc_index;
}
EXPORT_SYMBOL_GPL(am65_cpts_phc_index);
static void cpts_free_clk_mux(void *data)
{
struct am65_cpts *cpts = data;
of_clk_del_provider(cpts->clk_mux_np);
clk_hw_unregister_mux(cpts->clk_mux_hw);
of_node_put(cpts->clk_mux_np);
}
static int cpts_of_mux_clk_setup(struct am65_cpts *cpts,
struct device_node *node)
{
unsigned int num_parents;
const char **parent_names;
char *clk_mux_name;
void __iomem *reg;
int ret = -EINVAL;
cpts->clk_mux_np = of_get_child_by_name(node, "refclk-mux");
if (!cpts->clk_mux_np)
return 0;
num_parents = of_clk_get_parent_count(cpts->clk_mux_np);
if (num_parents < 1) {
dev_err(cpts->dev, "mux-clock %pOF must have parents\n",
cpts->clk_mux_np);
goto mux_fail;
}
parent_names = devm_kcalloc(cpts->dev, sizeof(char *), num_parents,
GFP_KERNEL);
if (!parent_names) {
ret = -ENOMEM;
goto mux_fail;
}
of_clk_parent_fill(cpts->clk_mux_np, parent_names, num_parents);
clk_mux_name = devm_kasprintf(cpts->dev, GFP_KERNEL, "%s.%pOFn",
dev_name(cpts->dev), cpts->clk_mux_np);
if (!clk_mux_name) {
ret = -ENOMEM;
goto mux_fail;
}
reg = &cpts->reg->rftclk_sel;
/* dev must be NULL to avoid recursive incrementing
* of module refcnt
*/
cpts->clk_mux_hw = clk_hw_register_mux(NULL, clk_mux_name,
parent_names, num_parents,
0, reg, 0, 5, 0, NULL);
if (IS_ERR(cpts->clk_mux_hw)) {
ret = PTR_ERR(cpts->clk_mux_hw);
goto mux_fail;
}
ret = of_clk_add_hw_provider(cpts->clk_mux_np, of_clk_hw_simple_get,
cpts->clk_mux_hw);
if (ret)
goto clk_hw_register;
ret = devm_add_action_or_reset(cpts->dev, cpts_free_clk_mux, cpts);
if (ret)
dev_err(cpts->dev, "failed to add clkmux reset action %d", ret);
return ret;
clk_hw_register:
clk_hw_unregister_mux(cpts->clk_mux_hw);
mux_fail:
of_node_put(cpts->clk_mux_np);
return ret;
}
static int am65_cpts_of_parse(struct am65_cpts *cpts, struct device_node *node)
{
u32 prop[2];
if (!of_property_read_u32(node, "ti,cpts-ext-ts-inputs", &prop[0]))
cpts->ext_ts_inputs = prop[0];
if (!of_property_read_u32(node, "ti,cpts-periodic-outputs", &prop[0]))
cpts->genf_num = prop[0];
return cpts_of_mux_clk_setup(cpts, node);
}
static void am65_cpts_release(void *data)
{
struct am65_cpts *cpts = data;
ptp_clock_unregister(cpts->ptp_clock);
am65_cpts_disable(cpts);
clk_disable_unprepare(cpts->refclk);
}
struct am65_cpts *am65_cpts_create(struct device *dev, void __iomem *regs,
struct device_node *node)
{
struct am65_cpts *cpts;
int ret, i;
cpts = devm_kzalloc(dev, sizeof(*cpts), GFP_KERNEL);
if (!cpts)
return ERR_PTR(-ENOMEM);
cpts->dev = dev;
cpts->reg = (struct am65_cpts_regs __iomem *)regs;
cpts->irq = of_irq_get_byname(node, "cpts");
if (cpts->irq <= 0) {
ret = cpts->irq ?: -ENXIO;
if (ret != -EPROBE_DEFER)
dev_err(dev, "Failed to get IRQ number (err = %d)\n",
ret);
return ERR_PTR(ret);
}
ret = am65_cpts_of_parse(cpts, node);
if (ret)
return ERR_PTR(ret);
mutex_init(&cpts->ptp_clk_lock);
INIT_LIST_HEAD(&cpts->events);
INIT_LIST_HEAD(&cpts->pool);
spin_lock_init(&cpts->lock);
skb_queue_head_init(&cpts->txq);
for (i = 0; i < AM65_CPTS_MAX_EVENTS; i++)
list_add(&cpts->pool_data[i].list, &cpts->pool);
cpts->refclk = devm_get_clk_from_child(dev, node, "cpts");
if (IS_ERR(cpts->refclk)) {
ret = PTR_ERR(cpts->refclk);
if (ret != -EPROBE_DEFER)
dev_err(dev, "Failed to get refclk %d\n", ret);
return ERR_PTR(ret);
}
ret = clk_prepare_enable(cpts->refclk);
if (ret) {
dev_err(dev, "Failed to enable refclk %d\n", ret);
return ERR_PTR(ret);
}
cpts->refclk_freq = clk_get_rate(cpts->refclk);
am65_ptp_info.max_adj = cpts->refclk_freq / AM65_CPTS_MIN_PPM;
cpts->ptp_info = am65_ptp_info;
if (cpts->ext_ts_inputs)
cpts->ptp_info.n_ext_ts = cpts->ext_ts_inputs;
if (cpts->genf_num)
cpts->ptp_info.n_per_out = cpts->genf_num;
am65_cpts_set_add_val(cpts);
am65_cpts_write32(cpts, AM65_CPTS_CONTROL_EN | AM65_CPTS_CONTROL_64MODE,
control);
am65_cpts_write32(cpts, AM65_CPTS_INT_ENABLE_TS_PEND_EN, int_enable);
/* set time to the current system time */
am65_cpts_settime(cpts, ktime_to_ns(ktime_get_real()));
cpts->ptp_clock = ptp_clock_register(&cpts->ptp_info, cpts->dev);
if (IS_ERR_OR_NULL(cpts->ptp_clock)) {
dev_err(dev, "Failed to register ptp clk %ld\n",
PTR_ERR(cpts->ptp_clock));
if (!cpts->ptp_clock)
ret = -ENODEV;
goto refclk_disable;
}
cpts->phc_index = ptp_clock_index(cpts->ptp_clock);
ret = devm_add_action_or_reset(dev, am65_cpts_release, cpts);
if (ret) {
dev_err(dev, "failed to add ptpclk reset action %d", ret);
return ERR_PTR(ret);
}
ret = devm_request_threaded_irq(dev, cpts->irq, NULL,
am65_cpts_interrupt,
IRQF_ONESHOT, dev_name(dev), cpts);
if (ret < 0) {
dev_err(cpts->dev, "error attaching irq %d\n", ret);
return ERR_PTR(ret);
}
dev_info(dev, "CPTS ver 0x%08x, freq:%u, add_val:%u\n",
am65_cpts_read32(cpts, idver),
cpts->refclk_freq, cpts->ts_add_val);
return cpts;
refclk_disable:
clk_disable_unprepare(cpts->refclk);
return ERR_PTR(ret);
}
EXPORT_SYMBOL_GPL(am65_cpts_create);
static int am65_cpts_probe(struct platform_device *pdev)
{
struct device_node *node = pdev->dev.of_node;
struct device *dev = &pdev->dev;
struct am65_cpts *cpts;
struct resource *res;
void __iomem *base;
res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "cpts");
base = devm_ioremap_resource(dev, res);
if (IS_ERR(base))
return PTR_ERR(base);
cpts = am65_cpts_create(dev, base, node);
if (IS_ERR(cpts))
return PTR_ERR(cpts);
return 0;
}
static const struct of_device_id am65_cpts_of_match[] = {
{ .compatible = "ti,am65-cpts", },
{ .compatible = "ti,j721e-cpts", },
{},
};
MODULE_DEVICE_TABLE(of, am65_cpts_of_match);
static struct platform_driver am65_cpts_driver = {
.probe = am65_cpts_probe,
.driver = {
.name = "am65-cpts",
.of_match_table = am65_cpts_of_match,
},
};
module_platform_driver(am65_cpts_driver);
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Grygorii Strashko <grygorii.strashko@ti.com>");
MODULE_DESCRIPTION("TI K3 AM65 CPTS driver");
/* SPDX-License-Identifier: GPL-2.0+ */
/* TI K3 AM65 CPTS driver interface
*
* Copyright (C) 2020 Texas Instruments Incorporated - http://www.ti.com
*/
#ifndef K3_CPTS_H_
#define K3_CPTS_H_
#include <linux/device.h>
#include <linux/of.h>
struct am65_cpts;
#if IS_ENABLED(CONFIG_TI_K3_AM65_CPTS)
struct am65_cpts *am65_cpts_create(struct device *dev, void __iomem *regs,
struct device_node *node);
int am65_cpts_phc_index(struct am65_cpts *cpts);
void am65_cpts_tx_timestamp(struct am65_cpts *cpts, struct sk_buff *skb);
void am65_cpts_prep_tx_timestamp(struct am65_cpts *cpts, struct sk_buff *skb);
void am65_cpts_rx_enable(struct am65_cpts *cpts, bool en);
#else
static inline struct am65_cpts *am65_cpts_create(struct device *dev,
void __iomem *regs,
struct device_node *node)
{
return ERR_PTR(-EOPNOTSUPP);
}
static inline int am65_cpts_phc_index(struct am65_cpts *cpts)
{
return -1;
}
static inline void am65_cpts_tx_timestamp(struct am65_cpts *cpts,
struct sk_buff *skb)
{
}
static inline void am65_cpts_prep_tx_timestamp(struct am65_cpts *cpts,
struct sk_buff *skb)
{
}
static inline void am65_cpts_rx_enable(struct am65_cpts *cpts, bool en)
{
}
#endif
#endif /* K3_CPTS_H_ */
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment