Merge branch 'qualcomm-rmnet-mapv5' (92c35cfd) · Commits · EulixOS / Software / Kernel

Documentation/networking/device_drivers/cellular/qualcomm/rmnet.rst

+114 −12

Original line number	Original line	Diff line number	Diff line
	@@ -27,32 +27,134 @@ these MAP frames and send them to appropriate PDN's.
	2. Packet format		2. Packet format
	================		================

	a. MAP packet (data / control)		a. MAP packet v1 (data / control)

	MAP header has the same endianness of the IP packet.		MAP header fields are in big endian format.

	Packet format::		Packet format::

	Bit 0 1 2-7 8-15 16-31		Bit 0 1 2-7 8-15 16-31
	Function Command / Data Reserved Pad Multiplexer ID Payload length		Function Command / Data Reserved Pad Multiplexer ID Payload length

			Bit 32-x
			Function Raw bytes

			Command (1)/ Data (0) bit value is to indicate if the packet is a MAP command
			or data packet. Command packet is used for transport level flow control. Data
			packets are standard IP packets.

			Reserved bits must be zero when sent and ignored when received.

			Padding is the number of bytes to be appended to the payload to
			ensure 4 byte alignment.

			Multiplexer ID is to indicate the PDN on which data has to be sent.

			Payload length includes the padding length but does not include MAP header
			length.

			b. Map packet v4 (data / control)

			MAP header fields are in big endian format.

			Packet format::

			Bit 0 1 2-7 8-15 16-31
			Function Command / Data Reserved Pad Multiplexer ID Payload length

			Bit 32-(x-33) (x-32)-x
			Function Raw bytes Checksum offload header

			Command (1)/ Data (0) bit value is to indicate if the packet is a MAP command
			or data packet. Command packet is used for transport level flow control. Data
			packets are standard IP packets.

			Reserved bits must be zero when sent and ignored when received.

			Padding is the number of bytes to be appended to the payload to
			ensure 4 byte alignment.

			Multiplexer ID is to indicate the PDN on which data has to be sent.

			Payload length includes the padding length but does not include MAP header
			length.

			Checksum offload header, has the information about the checksum processing done
			by the hardware.Checksum offload header fields are in big endian format.

			Packet format::

			Bit 0-14 15 16-31
			Function Reserved Valid Checksum start offset

			Bit 31-47 48-64
			Function Checksum length Checksum value

			Reserved bits must be zero when sent and ignored when received.

			Valid bit indicates whether the partial checksum is calculated and is valid.
			Set to 1, if its is valid. Set to 0 otherwise.

			Padding is the number of bytes to be appended to the payload to
			ensure 4 byte alignment.

			Checksum start offset, Indicates the offset in bytes from the beginning of the
			IP header, from which modem computed checksum.

			Checksum length is the Length in bytes starting from CKSUM_START_OFFSET,
			over which checksum is computed.

			Checksum value, indicates the checksum computed.

			c. MAP packet v5 (data / control)

			MAP header fields are in big endian format.

			Packet format::

			Bit 0 1 2-7 8-15 16-31
			Function Command / Data Next header Pad Multiplexer ID Payload length

	Bit 32-x		Bit 32-x
	Function Raw Bytes		Function Raw bytes

	Command (1)/ Data (0) bit value is to indicate if the packet is a MAP command		Command (1)/ Data (0) bit value is to indicate if the packet is a MAP command
	or data packet. Control packet is used for transport level flow control. Data		or data packet. Command packet is used for transport level flow control. Data
	packets are standard IP packets.		packets are standard IP packets.

	Reserved bits are usually zeroed out and to be ignored by receiver.		Next header is used to indicate the presence of another header, currently is
			limited to checksum header.

	Padding is number of bytes to be added for 4 byte alignment if required by		Padding is the number of bytes to be appended to the payload to
	hardware.		ensure 4 byte alignment.

	Multiplexer ID is to indicate the PDN on which data has to be sent.		Multiplexer ID is to indicate the PDN on which data has to be sent.

	Payload length includes the padding length but does not include MAP header		Payload length includes the padding length but does not include MAP header
	length.		length.

	b. MAP packet (command specific)::		d. Checksum offload header v5

			Checksum offload header fields are in big endian format.

			Bit 0 - 6 7 8-15 16-31
			Function Header Type Next Header Checksum Valid Reserved

			Header Type is to indicate the type of header, this usually is set to CHECKSUM

			Header types
			= ==========================================
			0 Reserved
			1 Reserved
			2 checksum header

			Checksum Valid is to indicate whether the header checksum is valid. Value of 1
			implies that checksum is calculated on this packet and is valid, value of 0
			indicates that the calculated packet checksum is invalid.

			Reserved bits must be zero when sent and ignored when received.

			e. MAP packet v1/v5 (command specific)::

	Bit 0 1 2-7 8 - 15 16 - 31		Bit 0 1 2-7 8 - 15 16 - 31
	Function Command Reserved Pad Multiplexer ID Payload length		Function Command Reserved Pad Multiplexer ID Payload length
	@@ -74,7 +176,7 @@ Command types
	3 is for error during processing of commands		3 is for error during processing of commands
	= ==========================================		= ==========================================

	c. Aggregation		f. Aggregation

	Aggregation is multiple MAP packets (can be data or command) delivered to		Aggregation is multiple MAP packets (can be data or command) delivered to
	rmnet in a single linear skb. rmnet will process the individual		rmnet in a single linear skb. rmnet will process the individual

drivers/net/ethernet/qualcomm/rmnet/rmnet_config.h

+3 −1

Original line number	Original line	Diff line number	Diff line
	/* SPDX-License-Identifier: GPL-2.0-only */		/* SPDX-License-Identifier: GPL-2.0-only */
	/* Copyright (c) 2013-2014, 2016-2018 The Linux Foundation. All rights reserved.		/* Copyright (c) 2013-2014, 2016-2018, 2021 The Linux Foundation.
			* All rights reserved.
	*		*
	* RMNET Data configuration engine		* RMNET Data configuration engine
	*/		*/
	@@ -56,6 +57,7 @@ struct rmnet_priv_stats {
	u64 csum_fragmented_pkt;		u64 csum_fragmented_pkt;
	u64 csum_skipped;		u64 csum_skipped;
	u64 csum_sw;		u64 csum_sw;
			u64 csum_hw;
	};		};

	struct rmnet_priv {		struct rmnet_priv {

drivers/net/ethernet/qualcomm/rmnet/rmnet_handlers.c

+25 −15

Original line number	Original line	Diff line number	Diff line
	// SPDX-License-Identifier: GPL-2.0-only		// SPDX-License-Identifier: GPL-2.0-only
	/* Copyright (c) 2013-2018, The Linux Foundation. All rights reserved.		/* Copyright (c) 2013-2018, 2021, The Linux Foundation. All rights reserved.
	*		*
	* RMNET Data ingress/egress handler		* RMNET Data ingress/egress handler
	*/		*/
	@@ -82,11 +82,16 @@ __rmnet_map_ingress_handler(struct sk_buff *skb,

	skb->dev = ep->egress_dev;		skb->dev = ep->egress_dev;

			if ((port->data_format & RMNET_FLAGS_INGRESS_MAP_CKSUMV5) &&
			(map_header->flags & MAP_NEXT_HEADER_FLAG)) {
			if (rmnet_map_process_next_hdr_packet(skb, len))
			goto free_skb;
			skb_pull(skb, sizeof(*map_header));
			rmnet_set_skb_proto(skb);
			} else if (port->data_format & RMNET_FLAGS_INGRESS_MAP_CKSUMV4) {
	/* Subtract MAP header */		/* Subtract MAP header */
	skb_pull(skb, sizeof(struct rmnet_map_header));		skb_pull(skb, sizeof(*map_header));
	rmnet_set_skb_proto(skb);		rmnet_set_skb_proto(skb);

	if (port->data_format & RMNET_FLAGS_INGRESS_MAP_CKSUMV4) {
	if (!rmnet_map_checksum_downlink_packet(skb, len + pad))		if (!rmnet_map_checksum_downlink_packet(skb, len + pad))
	skb->ip_summed = CHECKSUM_UNNECESSARY;		skb->ip_summed = CHECKSUM_UNNECESSARY;
	}		}
	@@ -128,7 +133,7 @@ static int rmnet_map_egress_handler(struct sk_buff *skb,
	struct rmnet_port *port, u8 mux_id,		struct rmnet_port *port, u8 mux_id,
	struct net_device *orig_dev)		struct net_device *orig_dev)
	{		{
	int required_headroom, additional_header_len;		int required_headroom, additional_header_len, csum_type = 0;
	struct rmnet_map_header *map_header;		struct rmnet_map_header *map_header;

	additional_header_len = 0;		additional_header_len = 0;
	@@ -136,18 +141,23 @@ static int rmnet_map_egress_handler(struct sk_buff *skb,

	if (port->data_format & RMNET_FLAGS_EGRESS_MAP_CKSUMV4) {		if (port->data_format & RMNET_FLAGS_EGRESS_MAP_CKSUMV4) {
	additional_header_len = sizeof(struct rmnet_map_ul_csum_header);		additional_header_len = sizeof(struct rmnet_map_ul_csum_header);
	required_headroom += additional_header_len;		csum_type = RMNET_FLAGS_EGRESS_MAP_CKSUMV4;
			} else if (port->data_format & RMNET_FLAGS_EGRESS_MAP_CKSUMV5) {
			additional_header_len = sizeof(struct rmnet_map_v5_csum_header);
			csum_type = RMNET_FLAGS_EGRESS_MAP_CKSUMV5;
	}		}

	if (skb_headroom(skb) < required_headroom) {		required_headroom += additional_header_len;
	if (pskb_expand_head(skb, required_headroom, 0, GFP_ATOMIC))
			if (skb_cow_head(skb, required_headroom) < 0)
	return -ENOMEM;		return -ENOMEM;
	}

	if (port->data_format & RMNET_FLAGS_EGRESS_MAP_CKSUMV4)		if (csum_type)
	rmnet_map_checksum_uplink_packet(skb, orig_dev);		rmnet_map_checksum_uplink_packet(skb, port, orig_dev,
			csum_type);

	map_header = rmnet_map_add_map_header(skb, additional_header_len, 0);		map_header = rmnet_map_add_map_header(skb, additional_header_len,
			port, 0);
	if (!map_header)		if (!map_header)
	return -ENOMEM;		return -ENOMEM;

drivers/net/ethernet/qualcomm/rmnet/rmnet_map.h

+8 −3

Original line number	Original line	Diff line number	Diff line
	/* SPDX-License-Identifier: GPL-2.0-only */		/* SPDX-License-Identifier: GPL-2.0-only */
	/* Copyright (c) 2013-2018, The Linux Foundation. All rights reserved.		/* Copyright (c) 2013-2018, 2021, The Linux Foundation. All rights reserved.
	*/		*/

	#ifndef _RMNET_MAP_H_		#ifndef _RMNET_MAP_H_
	@@ -43,10 +43,15 @@ enum rmnet_map_commands {
	struct sk_buff rmnet_map_deaggregate(struct sk_buff skb,		struct sk_buff rmnet_map_deaggregate(struct sk_buff skb,
	struct rmnet_port *port);		struct rmnet_port *port);
	struct rmnet_map_header rmnet_map_add_map_header(struct sk_buff skb,		struct rmnet_map_header rmnet_map_add_map_header(struct sk_buff skb,
	int hdrlen, int pad);		int hdrlen,
			struct rmnet_port *port,
			int pad);
	void rmnet_map_command(struct sk_buff skb, struct rmnet_port port);		void rmnet_map_command(struct sk_buff skb, struct rmnet_port port);
	int rmnet_map_checksum_downlink_packet(struct sk_buff *skb, u16 len);		int rmnet_map_checksum_downlink_packet(struct sk_buff *skb, u16 len);
	void rmnet_map_checksum_uplink_packet(struct sk_buff *skb,		void rmnet_map_checksum_uplink_packet(struct sk_buff *skb,
	struct net_device *orig_dev);		struct rmnet_port *port,
			struct net_device *orig_dev,
			int csum_type);
			int rmnet_map_process_next_hdr_packet(struct sk_buff *skb, u16 len);

	#endif /* _RMNET_MAP_H_ */		#endif /* _RMNET_MAP_H_ */

drivers/net/ethernet/qualcomm/rmnet/rmnet_map_data.c

+141 −8

Original line number	Original line	Diff line number	Diff line
	// SPDX-License-Identifier: GPL-2.0-only		// SPDX-License-Identifier: GPL-2.0-only
	/* Copyright (c) 2013-2018, The Linux Foundation. All rights reserved.		/* Copyright (c) 2013-2018, 2021, The Linux Foundation. All rights reserved.
	*		*
	* RMNET Data MAP protocol		* RMNET Data MAP protocol
	*/		*/
	@@ -8,6 +8,7 @@
	#include <linux/ip.h>		#include <linux/ip.h>
	#include <linux/ipv6.h>		#include <linux/ipv6.h>
	#include <net/ip6_checksum.h>		#include <net/ip6_checksum.h>
			#include <linux/bitfield.h>
	#include "rmnet_config.h"		#include "rmnet_config.h"
	#include "rmnet_map.h"		#include "rmnet_map.h"
	#include "rmnet_private.h"		#include "rmnet_private.h"
	@@ -250,12 +251,69 @@ rmnet_map_ipv6_ul_csum_header(void *ip6hdr,
	}		}
	#endif		#endif

			static void rmnet_map_v5_checksum_uplink_packet(struct sk_buff *skb,
			struct rmnet_port *port,
			struct net_device *orig_dev)
			{
			struct rmnet_priv *priv = netdev_priv(orig_dev);
			struct rmnet_map_v5_csum_header *ul_header;

			ul_header = skb_push(skb, sizeof(*ul_header));
			memset(ul_header, 0, sizeof(*ul_header));
			ul_header->header_info = u8_encode_bits(RMNET_MAP_HEADER_TYPE_CSUM_OFFLOAD,
			MAPV5_HDRINFO_HDR_TYPE_FMASK);

			if (skb->ip_summed == CHECKSUM_PARTIAL) {
			void *iph = ip_hdr(skb);
			__sum16 *check;
			void *trans;
			u8 proto;

			if (skb->protocol != htons(ETH_P_IP) &&
			skb->protocol != htons(ETH_P_IPV6)) {
			priv->stats.csum_err_invalid_ip_version++;
			goto sw_csum;
			}

			if (skb->protocol == htons(ETH_P_IP)) {
			u16 ip_len = ((struct iphdr )iph)->ihl 4;

			proto = ((struct iphdr *)iph)->protocol;
			trans = iph + ip_len;
			} else if (skb->protocol == htons(ETH_P_IPV6)) {
			#if IS_ENABLED(CONFIG_IPV6)
			u16 ip_len = sizeof(struct ipv6hdr);

			proto = ((struct ipv6hdr *)iph)->nexthdr;
			trans = iph + ip_len;
			#else
			priv->stats.csum_err_invalid_ip_version++;
			goto sw_csum;
			#endif /* CONFIG_IPV6 */
			}

			check = rmnet_map_get_csum_field(proto, trans);
			if (check) {
			skb->ip_summed = CHECKSUM_NONE;
			/* Ask for checksum offloading */
			ul_header->csum_info \|= MAPV5_CSUMINFO_VALID_FLAG;
			priv->stats.csum_hw++;
			return;
			}
			}

			sw_csum:
			priv->stats.csum_sw++;
			}

	/* Adds MAP header to front of skb->data		/* Adds MAP header to front of skb->data
	* Padding is calculated and set appropriately in MAP header. Mux ID is		* Padding is calculated and set appropriately in MAP header. Mux ID is
	* initialized to 0.		* initialized to 0.
	*/		*/
	struct rmnet_map_header rmnet_map_add_map_header(struct sk_buff skb,		struct rmnet_map_header rmnet_map_add_map_header(struct sk_buff skb,
	int hdrlen, int pad)		int hdrlen,
			struct rmnet_port *port,
			int pad)
	{		{
	struct rmnet_map_header *map_header;		struct rmnet_map_header *map_header;
	u32 padding, map_datalen;		u32 padding, map_datalen;
	@@ -266,6 +324,10 @@ struct rmnet_map_header rmnet_map_add_map_header(struct sk_buff skb,
	skb_push(skb, sizeof(struct rmnet_map_header));		skb_push(skb, sizeof(struct rmnet_map_header));
	memset(map_header, 0, sizeof(struct rmnet_map_header));		memset(map_header, 0, sizeof(struct rmnet_map_header));

			/* Set next_hdr bit for csum offload packets */
			if (port->data_format & RMNET_FLAGS_EGRESS_MAP_CKSUMV5)
			map_header->flags \|= MAP_NEXT_HEADER_FLAG;

	if (pad == RMNET_MAP_NO_PAD_BYTES) {		if (pad == RMNET_MAP_NO_PAD_BYTES) {
	map_header->pkt_len = htons(map_datalen);		map_header->pkt_len = htons(map_datalen);
	return map_header;		return map_header;
	@@ -300,8 +362,11 @@ struct rmnet_map_header rmnet_map_add_map_header(struct sk_buff skb,
	struct sk_buff rmnet_map_deaggregate(struct sk_buff skb,		struct sk_buff rmnet_map_deaggregate(struct sk_buff skb,
	struct rmnet_port *port)		struct rmnet_port *port)
	{		{
			struct rmnet_map_v5_csum_header *next_hdr = NULL;
	struct rmnet_map_header *maph;		struct rmnet_map_header *maph;
			void *data = skb->data;
	struct sk_buff *skbn;		struct sk_buff *skbn;
			u8 nexthdr_type;
	u32 packet_len;		u32 packet_len;

	if (skb->len == 0)		if (skb->len == 0)
	@@ -310,8 +375,18 @@ struct sk_buff rmnet_map_deaggregate(struct sk_buff skb,
	maph = (struct rmnet_map_header *)skb->data;		maph = (struct rmnet_map_header *)skb->data;
	packet_len = ntohs(maph->pkt_len) + sizeof(*maph);		packet_len = ntohs(maph->pkt_len) + sizeof(*maph);

	if (port->data_format & RMNET_FLAGS_INGRESS_MAP_CKSUMV4)		if (port->data_format & RMNET_FLAGS_INGRESS_MAP_CKSUMV4) {
	packet_len += sizeof(struct rmnet_map_dl_csum_trailer);		packet_len += sizeof(struct rmnet_map_dl_csum_trailer);
			} else if (port->data_format & RMNET_FLAGS_INGRESS_MAP_CKSUMV5) {
			if (!(maph->flags & MAP_CMD_FLAG)) {
			packet_len += sizeof(*next_hdr);
			if (maph->flags & MAP_NEXT_HEADER_FLAG)
			next_hdr = data + sizeof(*maph);
			else
			/* Mapv5 data pkt without csum hdr is invalid */
			return NULL;
			}
			}

	if (((int)skb->len - (int)packet_len) < 0)		if (((int)skb->len - (int)packet_len) < 0)
	return NULL;		return NULL;
	@@ -320,6 +395,13 @@ struct sk_buff rmnet_map_deaggregate(struct sk_buff skb,
	if (!maph->pkt_len)		if (!maph->pkt_len)
	return NULL;		return NULL;

			if (next_hdr) {
			nexthdr_type = u8_get_bits(next_hdr->header_info,
			MAPV5_HDRINFO_HDR_TYPE_FMASK);
			if (nexthdr_type != RMNET_MAP_HEADER_TYPE_CSUM_OFFLOAD)
			return NULL;
			}

	skbn = alloc_skb(packet_len + RMNET_MAP_DEAGGR_SPACING, GFP_ATOMIC);		skbn = alloc_skb(packet_len + RMNET_MAP_DEAGGR_SPACING, GFP_ATOMIC);
	if (!skbn)		if (!skbn)
	return NULL;		return NULL;
	@@ -372,10 +454,7 @@ int rmnet_map_checksum_downlink_packet(struct sk_buff *skb, u16 len)
	return 0;		return 0;
	}		}

	/* Generates UL checksum meta info header for IPv4 and IPv6 over TCP and UDP		static void rmnet_map_v4_checksum_uplink_packet(struct sk_buff *skb,
	* packets that are supported for UL checksum offload.
	*/
	void rmnet_map_checksum_uplink_packet(struct sk_buff *skb,
	struct net_device *orig_dev)		struct net_device *orig_dev)
	{		{
	struct rmnet_priv *priv = netdev_priv(orig_dev);		struct rmnet_priv *priv = netdev_priv(orig_dev);
	@@ -395,10 +474,12 @@ void rmnet_map_checksum_uplink_packet(struct sk_buff *skb,

	if (skb->protocol == htons(ETH_P_IP)) {		if (skb->protocol == htons(ETH_P_IP)) {
	rmnet_map_ipv4_ul_csum_header(iphdr, ul_header, skb);		rmnet_map_ipv4_ul_csum_header(iphdr, ul_header, skb);
			priv->stats.csum_hw++;
	return;		return;
	} else if (skb->protocol == htons(ETH_P_IPV6)) {		} else if (skb->protocol == htons(ETH_P_IPV6)) {
	#if IS_ENABLED(CONFIG_IPV6)		#if IS_ENABLED(CONFIG_IPV6)
	rmnet_map_ipv6_ul_csum_header(iphdr, ul_header, skb);		rmnet_map_ipv6_ul_csum_header(iphdr, ul_header, skb);
			priv->stats.csum_hw++;
	return;		return;
	#else		#else
	priv->stats.csum_err_invalid_ip_version++;		priv->stats.csum_err_invalid_ip_version++;
	@@ -414,3 +495,55 @@ void rmnet_map_checksum_uplink_packet(struct sk_buff *skb,

	priv->stats.csum_sw++;		priv->stats.csum_sw++;
	}		}

			/* Generates UL checksum meta info header for IPv4 and IPv6 over TCP and UDP
			* packets that are supported for UL checksum offload.
			*/
			void rmnet_map_checksum_uplink_packet(struct sk_buff *skb,
			struct rmnet_port *port,
			struct net_device *orig_dev,
			int csum_type)
			{
			switch (csum_type) {
			case RMNET_FLAGS_EGRESS_MAP_CKSUMV4:
			rmnet_map_v4_checksum_uplink_packet(skb, orig_dev);
			break;
			case RMNET_FLAGS_EGRESS_MAP_CKSUMV5:
			rmnet_map_v5_checksum_uplink_packet(skb, port, orig_dev);
			break;
			default:
			break;
			}
			}

			/* Process a MAPv5 packet header */
			int rmnet_map_process_next_hdr_packet(struct sk_buff *skb,
			u16 len)
			{
			struct rmnet_priv *priv = netdev_priv(skb->dev);
			struct rmnet_map_v5_csum_header *next_hdr;
			u8 nexthdr_type;

			next_hdr = (struct rmnet_map_v5_csum_header *)(skb->data +
			sizeof(struct rmnet_map_header));

			nexthdr_type = u8_get_bits(next_hdr->header_info,
			MAPV5_HDRINFO_HDR_TYPE_FMASK);

			if (nexthdr_type != RMNET_MAP_HEADER_TYPE_CSUM_OFFLOAD)
			return -EINVAL;

			if (unlikely(!(skb->dev->features & NETIF_F_RXCSUM))) {
			priv->stats.csum_sw++;
			} else if (next_hdr->csum_info & MAPV5_CSUMINFO_VALID_FLAG) {
			priv->stats.csum_ok++;
			skb->ip_summed = CHECKSUM_UNNECESSARY;
			} else {
			priv->stats.csum_valid_unset++;
			}

			/* Pull csum v5 header */
			skb_pull(skb, sizeof(*next_hdr));

			return 0;
			}