app/test-pmd/ieee1588fwd.c

   1 /*-
   2  *   BSD LICENSE
   3  *
   4  *   Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
   5  *   All rights reserved.
   6  *
   7  *   Redistribution and use in source and binary forms, with or without
   8  *   modification, are permitted provided that the following conditions
   9  *   are met:
  10  *
  11  *     * Redistributions of source code must retain the above copyright
  12  *       notice, this list of conditions and the following disclaimer.
  13  *     * Redistributions in binary form must reproduce the above copyright
  14  *       notice, this list of conditions and the following disclaimer in
  15  *       the documentation and/or other materials provided with the
  16  *       distribution.
  17  *     * Neither the name of Intel Corporation nor the names of its
  18  *       contributors may be used to endorse or promote products derived
  19  *       from this software without specific prior written permission.
  20  *
  21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  32  */
  33
  34
  35 #include <rte_cycles.h>
  36 #include <rte_ethdev.h>
  37
  38 #include "testpmd.h"
  39
  40 /**
  41  * The structure of a PTP V2 packet.
  42  *
  43  * Only the minimum fields used by the ieee1588 test are represented.
  44  */
  45 struct ptpv2_msg {
  46         uint8_t msg_id;
  47         uint8_t version; /**< must be 0x02 */
  48         uint8_t unused[34];
  49 };
  50
  51 #define PTP_SYNC_MESSAGE                0x0
  52 #define PTP_DELAY_REQ_MESSAGE           0x1
  53 #define PTP_PATH_DELAY_REQ_MESSAGE      0x2
  54 #define PTP_PATH_DELAY_RESP_MESSAGE     0x3
  55 #define PTP_FOLLOWUP_MESSAGE            0x8
  56 #define PTP_DELAY_RESP_MESSAGE          0x9
  57 #define PTP_PATH_DELAY_FOLLOWUP_MESSAGE 0xA
  58 #define PTP_ANNOUNCE_MESSAGE            0xB
  59 #define PTP_SIGNALLING_MESSAGE          0xC
  60 #define PTP_MANAGEMENT_MESSAGE          0xD
  61
  62 /*
  63  * Forwarding of IEEE1588 Precise Time Protocol (PTP) packets.
  64  *
  65  * In this mode, packets are received one by one and are expected to be
  66  * PTP V2 L2 Ethernet frames (with the specific Ethernet type "0x88F7")
  67  * containing PTP "sync" messages (version 2 at offset 1, and message ID
  68  * 0 at offset 0).
  69  *
  70  * Check that each received packet is a IEEE1588 PTP V2 packet of type
  71  * PTP_SYNC_MESSAGE, and that it has been identified and timestamped
  72  * by the hardware.
  73  * Check that the value of the last RX timestamp recorded by the controller
  74  * is greater than the previous one.
  75  *
  76  * If everything is OK, send the received packet back on the same port,
  77  * requesting for it to be timestamped by the hardware.
  78  * Check that the value of the last TX timestamp recorded by the controller
  79  * is greater than the previous one.
  80  */
  81
  82 static void
  83 port_ieee1588_rx_timestamp_check(portid_t pi, uint32_t index)
  84 {
  85         struct timespec timestamp = {0, 0};
  86
  87         if (rte_eth_timesync_read_rx_timestamp(pi, &timestamp, index) < 0) {
  88                 printf("Port %u RX timestamp registers not valid\n",
  89                        (unsigned) pi);
  90                 return;
  91         }
  92         printf("Port %u RX timestamp value %"PRIu64"\n",
  93                (unsigned) pi, timestamp.tv_sec);
  94 }
  95
  96 #define MAX_TX_TMST_WAIT_MICROSECS 1000 /**< 1 milli-second */
  97
  98 static void
  99 port_ieee1588_tx_timestamp_check(portid_t pi)
 100 {
 101         struct timespec timestamp = {0, 0};
 102         unsigned wait_us = 0;
 103
 104         while ((rte_eth_timesync_read_tx_timestamp(pi, &timestamp) < 0) &&
 105                (wait_us < MAX_TX_TMST_WAIT_MICROSECS)) {
 106                 rte_delay_us(1);
 107                 wait_us++;
 108         }
 109         if (wait_us >= MAX_TX_TMST_WAIT_MICROSECS) {
 110                 printf("Port %u TX timestamp registers not valid after "
 111                        "%u micro-seconds\n",
 112                        (unsigned) pi, (unsigned) MAX_TX_TMST_WAIT_MICROSECS);
 113                 return;
 114         }
 115         printf("Port %u TX timestamp value %"PRIu64" validated after "
 116                "%u micro-second%s\n",
 117                (unsigned) pi, timestamp.tv_sec, wait_us,
 118                (wait_us == 1) ? "" : "s");
 119 }
 120
 121 static void
 122 ieee1588_packet_fwd(struct fwd_stream *fs)
 123 {
 124         struct rte_mbuf  *mb;
 125         struct ether_hdr *eth_hdr;
 126         struct ptpv2_msg *ptp_hdr;
 127         uint16_t eth_type;
 128         uint32_t timesync_index;
 129
 130         /*
 131          * Receive 1 packet at a time.
 132          */
 133         if (rte_eth_rx_burst(fs->rx_port, fs->rx_queue, &mb, 1) == 0)
 134                 return;
 135
 136         fs->rx_packets += 1;
 137
 138         /*
 139          * Check that the received packet is a PTP packet that was detected
 140          * by the hardware.
 141          */
 142         eth_hdr = rte_pktmbuf_mtod(mb, struct ether_hdr *);
 143         eth_type = rte_be_to_cpu_16(eth_hdr->ether_type);
 144
 145         if (! (mb->ol_flags & PKT_RX_IEEE1588_PTP)) {
 146                 if (eth_type == ETHER_TYPE_1588) {
 147                         printf("Port %u Received PTP packet not filtered"
 148                                " by hardware\n",
 149                                (unsigned) fs->rx_port);
 150                 } else {
 151                         printf("Port %u Received non PTP packet type=0x%4x "
 152                                "len=%u\n",
 153                                (unsigned) fs->rx_port, eth_type,
 154                                (unsigned) mb->pkt_len);
 155                 }
 156                 rte_pktmbuf_free(mb);
 157                 return;
 158         }
 159         if (eth_type != ETHER_TYPE_1588) {
 160                 printf("Port %u Received NON PTP packet incorrectly"
 161                        " detected by hardware\n",
 162                        (unsigned) fs->rx_port);
 163                 rte_pktmbuf_free(mb);
 164                 return;
 165         }
 166
 167         /*
 168          * Check that the received PTP packet is a PTP V2 packet of type
 169          * PTP_SYNC_MESSAGE.
 170          */
 171         ptp_hdr = (struct ptpv2_msg *) (rte_pktmbuf_mtod(mb, char *) +
 172                                         sizeof(struct ether_hdr));
 173         if (ptp_hdr->version != 0x02) {
 174                 printf("Port %u Received PTP V2 Ethernet frame with wrong PTP"
 175                        " protocol version 0x%x (should be 0x02)\n",
 176                        (unsigned) fs->rx_port, ptp_hdr->version);
 177                 rte_pktmbuf_free(mb);
 178                 return;
 179         }
 180         if (ptp_hdr->msg_id != PTP_SYNC_MESSAGE) {
 181                 printf("Port %u Received PTP V2 Ethernet frame with unexpected"
 182                        " message ID 0x%x (expected 0x0 - PTP_SYNC_MESSAGE)\n",
 183                        (unsigned) fs->rx_port, ptp_hdr->msg_id);
 184                 rte_pktmbuf_free(mb);
 185                 return;
 186         }
 187         printf("Port %u IEEE1588 PTP V2 SYNC Message filtered by hardware\n",
 188                (unsigned) fs->rx_port);
 189
 190         /*
 191          * Check that the received PTP packet has been timestamped by the
 192          * hardware.
 193          */
 194         if (! (mb->ol_flags & PKT_RX_IEEE1588_TMST)) {
 195                 printf("Port %u Received PTP packet not timestamped"
 196                        " by hardware\n",
 197                        (unsigned) fs->rx_port);
 198                 rte_pktmbuf_free(mb);
 199                 return;
 200         }
 201
 202         /* For i40e we need the timesync register index. It is ignored for the
 203          * other PMDs. */
 204         timesync_index = mb->timesync & 0x3;
 205         /* Read and check the RX timestamp. */
 206         port_ieee1588_rx_timestamp_check(fs->rx_port, timesync_index);
 207
 208         /* Forward PTP packet with hardware TX timestamp */
 209         mb->ol_flags |= PKT_TX_IEEE1588_TMST;
 210         fs->tx_packets += 1;
 211         if (rte_eth_tx_burst(fs->rx_port, fs->tx_queue, &mb, 1) == 0) {
 212                 printf("Port %u sent PTP packet dropped\n",
 213                        (unsigned) fs->rx_port);
 214                 fs->fwd_dropped += 1;
 215                 rte_pktmbuf_free(mb);
 216                 return;
 217         }
 218
 219         /*
 220          * Check the TX timestamp.
 221          */
 222         port_ieee1588_tx_timestamp_check(fs->rx_port);
 223 }
 224
 225 static void
 226 port_ieee1588_fwd_begin(portid_t pi)
 227 {
 228         rte_eth_timesync_enable(pi);
 229 }
 230
 231 static void
 232 port_ieee1588_fwd_end(portid_t pi)
 233 {
 234         rte_eth_timesync_disable(pi);
 235 }
 236
 237 struct fwd_engine ieee1588_fwd_engine = {
 238         .fwd_mode_name  = "ieee1588",
 239         .port_fwd_begin = port_ieee1588_fwd_begin,
 240         .port_fwd_end   = port_ieee1588_fwd_end,
 241         .packet_fwd     = ieee1588_packet_fwd,
 242 };