xsk: Add launch time hardware offload support to XDP Tx metadata

        name: tx-checksum

        doc:

          L3 checksum HW offload is supported by the driver.

      -

        name: tx-launch-time-fifo

        doc:

          Launch time HW offload is supported by the driver.

  -

    name: queue-type

    type: enum

  checksum. ``csum_start`` specifies byte offset of where the checksumming

  should start and ``csum_offset`` specifies byte offset where the

  device should store the computed checksum.

- ``XDP_TXMD_FLAGS_LAUNCH_TIME``: requests the device to schedule the

  packet for transmission at a pre-determined time called launch time. The

  value of launch time is indicated by ``launch_time`` field of

  ``union xsk_tx_metadata``.

Besides the flags above, in order to trigger the offloads, the first

packet's ``struct xdp_desc`` descriptor should set ``XDP_TX_METADATA``

is calculated on the CPU. Do not enable this option in production because

it will negatively affect performance.

Launch Time

===========

The value of the requested launch time should be based on the device's PTP

Hardware Clock (PHC) to ensure accuracy. AF_XDP takes a different data path

compared to the ETF queuing discipline, which organizes packets and delays

their transmission. Instead, AF_XDP immediately hands off the packets to

the device driver without rearranging their order or holding them prior to

transmission. Since the driver maintains FIFO behavior and does not perform

packet reordering, a packet with a launch time request will block other

packets in the same Tx Queue until it is sent. Therefore, it is recommended

to allocate separate queue for scheduling traffic that is intended for

future transmission.

In scenarios where the launch time offload feature is disabled, the device

driver is expected to disregard the launch time request. For correct

interpretation and meaningful operation, the launch time should never be

set to a value larger than the farthest programmable time in the future

(the horizon). Different devices have different hardware limitations on the

launch time offload feature.

stmmac driver

-------------

For stmmac, TSO and launch time (TBS) features are mutually exclusive for

each individual Tx Queue. By default, the driver configures Tx Queue 0 to

support TSO and the rest of the Tx Queues to support TBS. The launch time

hardware offload feature can be enabled or disabled by using the tc-etf

command to call the driver's ndo_setup_tc() callback.

The value of the launch time that is programmed in the Enhanced Normal

Transmit Descriptors is a 32-bit value, where the most significant 8 bits

represent the time in seconds and the remaining 24 bits represent the time

in 256 ns increments. The programmed launch time is compared against the

PTP time (bits[39:8]) and rolls over after 256 seconds. Therefore, the

horizon of the launch time for dwmac4 and dwxlgmac2 is 128 seconds in the

future.

igc driver

----------

For igc, all four Tx Queues support the launch time feature. The launch

time hardware offload feature can be enabled or disabled by using the

tc-etf command to call the driver's ndo_setup_tc() callback. When entering

TSN mode, the igc driver will reset the device and create a default Qbv

schedule with a 1-second cycle time, with all Tx Queues open at all times.

The value of the launch time that is programmed in the Advanced Transmit

Context Descriptor is a relative offset to the starting time of the Qbv

transmission window of the queue. The Frst flag of the descriptor can be

set to schedule the packet for the next Qbv cycle. Therefore, the horizon

of the launch time for i225 and i226 is the ending time of the next cycle

of the Qbv transmission window of the queue. For example, when the Qbv

cycle time is set to 1 second, the horizon of the launch time ranges

from 1 second to 2 seconds, depending on where the Qbv cycle is currently

running.

Querying Device Capabilities

============================

- ``tx-timestamp``: device supports ``XDP_TXMD_FLAGS_TIMESTAMP``

- ``tx-checksum``: device supports ``XDP_TXMD_FLAGS_CHECKSUM``

- ``tx-launch-time-fifo``: device supports ``XDP_TXMD_FLAGS_LAUNCH_TIME``

See ``tools/net/ynl/samples/netdev.c`` on how to query this information.

 *     indicates position where checksumming should start.

 *     csum_offset indicates position where checksum should be stored.

 *

 * void (*tmo_request_launch_time)(u64 launch_time, void *priv)

 *     Called when AF_XDP frame requested launch time HW offload support.

 *     launch_time indicates the PTP time at which the device can schedule the

 *     packet for transmission.

 */

struct xsk_tx_metadata_ops {

	void	(*tmo_request_timestamp)(void *priv);

	u64	(*tmo_fill_timestamp)(void *priv);

	void	(*tmo_request_checksum)(u16 csum_start, u16 csum_offset, void *priv);

	void	(*tmo_request_launch_time)(u64 launch_time, void *priv);

};

#ifdef CONFIG_XDP_SOCKETS

	if (!meta)

		return;

	if (ops->tmo_request_launch_time)

		if (meta->flags & XDP_TXMD_FLAGS_LAUNCH_TIME)

			ops->tmo_request_launch_time(meta->request.launch_time,

						     priv);

	if (ops->tmo_request_timestamp)

		if (meta->flags & XDP_TXMD_FLAGS_TIMESTAMP)

			ops->tmo_request_timestamp(priv);

#define XDP_TXMD_FLAGS_VALID ( \

		XDP_TXMD_FLAGS_TIMESTAMP | \

		XDP_TXMD_FLAGS_CHECKSUM | \

		XDP_TXMD_FLAGS_LAUNCH_TIME | \

	0)

static inline bool

 */

#define XDP_TXMD_FLAGS_CHECKSUM			(1 << 1)

/* Request launch time hardware offload. The device will schedule the packet for

 * transmission at a pre-determined time called launch time. The value of

 * launch time is communicated via launch_time field of struct xsk_tx_metadata.

 */

#define XDP_TXMD_FLAGS_LAUNCH_TIME		(1 << 2)

/* AF_XDP offloads request. 'request' union member is consumed by the driver

 * when the packet is being transmitted. 'completion' union member is

 * filled by the driver when the transmit completion arrives.

			__u16 csum_start;

			/* Offset from csum_start where checksum should be stored. */

			__u16 csum_offset;

			/* XDP_TXMD_FLAGS_LAUNCH_TIME */

			/* Launch time in nanosecond against the PTP HW Clock */

			__u64 launch_time;

		} request;

		struct {