net: mhi: Remove MBIM protocol (7ffa7542) · Commits · EulixOS / Software / Kernel

drivers/net/Kconfig

+2 −2

Original line number	Diff line number	Diff line
		@@ -431,10 +431,10 @@ config VSOCKMON
		config MHI_NET
		tristate "MHI network driver"
		depends on MHI_BUS
		select WWAN
		help
		This is the network driver for MHI bus. It can be used with
		QCOM based WWAN modems (like SDX55). Say Y or M.
		QCOM based WWAN modems for IP or QMAP/rmnet protocol (like SDX55).
		Say Y or M.

		endif # NET_CORE

drivers/net/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -37,7 +37,7 @@ obj-$(CONFIG_GTP) += gtp.o
		obj-$(CONFIG_NLMON) += nlmon.o
		obj-$(CONFIG_NET_VRF) += vrf.o
		obj-$(CONFIG_VSOCKMON) += vsockmon.o
		obj-$(CONFIG_MHI_NET) += mhi/
		obj-$(CONFIG_MHI_NET) += mhi_net.o

		#
		# Networking Drivers

drivers/net/mhi/Makefile

deleted100644 → 0

+0 −3

Original line number	Diff line number	Diff line
		obj-$(CONFIG_MHI_NET) += mhi_net.o

		mhi_net-y := net.o proto_mbim.o

drivers/net/mhi/mhi.h

deleted100644 → 0

+0 −41

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0-or-later */
		/* MHI Network driver - Network over MHI bus
		*
		* Copyright (C) 2021 Linaro Ltd <loic.poulain@linaro.org>
		*/

		struct mhi_net_stats {
		u64_stats_t rx_packets;
		u64_stats_t rx_bytes;
		u64_stats_t rx_errors;
		u64_stats_t rx_dropped;
		u64_stats_t rx_length_errors;
		u64_stats_t tx_packets;
		u64_stats_t tx_bytes;
		u64_stats_t tx_errors;
		u64_stats_t tx_dropped;
		struct u64_stats_sync tx_syncp;
		struct u64_stats_sync rx_syncp;
		};

		struct mhi_net_dev {
		struct mhi_device *mdev;
		struct net_device *ndev;
		struct sk_buff *skbagg_head;
		struct sk_buff *skbagg_tail;
		const struct mhi_net_proto *proto;
		void *proto_data;
		struct delayed_work rx_refill;
		struct mhi_net_stats stats;
		u32 rx_queue_sz;
		int msg_enable;
		unsigned int mru;
		};

		struct mhi_net_proto {
		int (init)(struct mhi_net_dev mhi_netdev);
		struct sk_buff * (tx_fixup)(struct mhi_net_dev mhi_netdev, struct sk_buff *skb);
		void (rx)(struct mhi_net_dev mhi_netdev, struct sk_buff *skb);
		};

		extern const struct mhi_net_proto proto_mbim;

drivers/net/mhi/proto_mbim.c

deleted100644 → 0

+0 −310

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-or-later
		/* MHI Network driver - Network over MHI bus
		*
		* Copyright (C) 2021 Linaro Ltd <loic.poulain@linaro.org>
		*
		* This driver copy some code from cdc_ncm, which is:
		* Copyright (C) ST-Ericsson 2010-2012
		* and cdc_mbim, which is:
		* Copyright (c) 2012 Smith Micro Software, Inc.
		* Copyright (c) 2012 Bjørn Mork <bjorn@mork.no>
		*
		*/

		#include <linux/ethtool.h>
		#include <linux/if_vlan.h>
		#include <linux/ip.h>
		#include <linux/mii.h>
		#include <linux/netdevice.h>
		#include <linux/wwan.h>
		#include <linux/skbuff.h>
		#include <linux/usb.h>
		#include <linux/usb/cdc.h>
		#include <linux/usb/usbnet.h>
		#include <linux/usb/cdc_ncm.h>

		#include "mhi.h"

		#define MBIM_NDP16_SIGN_MASK 0x00ffffff

		/* Usual WWAN MTU */
		#define MHI_MBIM_DEFAULT_MTU 1500

		/* 3500 allows to optimize skb allocation, the skbs will basically fit in
		* one 4K page. Large MBIM packets will simply be split over several MHI
		* transfers and chained by the MHI net layer (zerocopy).
		*/
		#define MHI_MBIM_DEFAULT_MRU 3500

		struct mbim_context {
		u16 rx_seq;
		u16 tx_seq;
		};

		static void __mbim_length_errors_inc(struct mhi_net_dev *dev)
		{
		u64_stats_update_begin(&dev->stats.rx_syncp);
		u64_stats_inc(&dev->stats.rx_length_errors);
		u64_stats_update_end(&dev->stats.rx_syncp);
		}

		static void __mbim_errors_inc(struct mhi_net_dev *dev)
		{
		u64_stats_update_begin(&dev->stats.rx_syncp);
		u64_stats_inc(&dev->stats.rx_errors);
		u64_stats_update_end(&dev->stats.rx_syncp);
		}

		static int mbim_rx_verify_nth16(struct sk_buff *skb)
		{
		struct mhi_net_dev *dev = wwan_netdev_drvpriv(skb->dev);
		struct mbim_context *ctx = dev->proto_data;
		struct usb_cdc_ncm_nth16 *nth16;
		int len;

		if (skb->len < sizeof(struct usb_cdc_ncm_nth16) +
		sizeof(struct usb_cdc_ncm_ndp16)) {
		netif_dbg(dev, rx_err, dev->ndev, "frame too short\n");
		__mbim_length_errors_inc(dev);
		return -EINVAL;
		}

		nth16 = (struct usb_cdc_ncm_nth16 *)skb->data;

		if (nth16->dwSignature != cpu_to_le32(USB_CDC_NCM_NTH16_SIGN)) {
		netif_dbg(dev, rx_err, dev->ndev,
		"invalid NTH16 signature <%#010x>\n",
		le32_to_cpu(nth16->dwSignature));
		__mbim_errors_inc(dev);
		return -EINVAL;
		}

		/* No limit on the block length, except the size of the data pkt */
		len = le16_to_cpu(nth16->wBlockLength);
		if (len > skb->len) {
		netif_dbg(dev, rx_err, dev->ndev,
		"NTB does not fit into the skb %u/%u\n", len,
		skb->len);
		__mbim_length_errors_inc(dev);
		return -EINVAL;
		}

		if (ctx->rx_seq + 1 != le16_to_cpu(nth16->wSequence) &&
		(ctx->rx_seq \|\| le16_to_cpu(nth16->wSequence)) &&
		!(ctx->rx_seq == 0xffff && !le16_to_cpu(nth16->wSequence))) {
		netif_dbg(dev, rx_err, dev->ndev,
		"sequence number glitch prev=%d curr=%d\n",
		ctx->rx_seq, le16_to_cpu(nth16->wSequence));
		}
		ctx->rx_seq = le16_to_cpu(nth16->wSequence);

		return le16_to_cpu(nth16->wNdpIndex);
		}

		static int mbim_rx_verify_ndp16(struct sk_buff skb, struct usb_cdc_ncm_ndp16 ndp16)
		{
		struct mhi_net_dev *dev = wwan_netdev_drvpriv(skb->dev);
		int ret;

		if (le16_to_cpu(ndp16->wLength) < USB_CDC_NCM_NDP16_LENGTH_MIN) {
		netif_dbg(dev, rx_err, dev->ndev, "invalid DPT16 length <%u>\n",
		le16_to_cpu(ndp16->wLength));
		return -EINVAL;
		}

		ret = ((le16_to_cpu(ndp16->wLength) - sizeof(struct usb_cdc_ncm_ndp16))
		/ sizeof(struct usb_cdc_ncm_dpe16));
		ret--; /* Last entry is always a NULL terminator */

		if (sizeof(struct usb_cdc_ncm_ndp16) +
		ret * sizeof(struct usb_cdc_ncm_dpe16) > skb->len) {
		netif_dbg(dev, rx_err, dev->ndev,
		"Invalid nframes = %d\n", ret);
		return -EINVAL;
		}

		return ret;
		}

		static void mbim_rx(struct mhi_net_dev mhi_netdev, struct sk_buff skb)
		{
		struct net_device *ndev = mhi_netdev->ndev;
		int ndpoffset;

		/* Check NTB header and retrieve first NDP offset */
		ndpoffset = mbim_rx_verify_nth16(skb);
		if (ndpoffset < 0) {
		net_err_ratelimited("%s: Incorrect NTB header\n", ndev->name);
		goto error;
		}

		/* Process each NDP */
		while (1) {
		struct usb_cdc_ncm_ndp16 ndp16;
		struct usb_cdc_ncm_dpe16 dpe16;
		int nframes, n, dpeoffset;

		if (skb_copy_bits(skb, ndpoffset, &ndp16, sizeof(ndp16))) {
		net_err_ratelimited("%s: Incorrect NDP offset (%u)\n",
		ndev->name, ndpoffset);
		__mbim_length_errors_inc(mhi_netdev);
		goto error;
		}

		/* Check NDP header and retrieve number of datagrams */
		nframes = mbim_rx_verify_ndp16(skb, &ndp16);
		if (nframes < 0) {
		net_err_ratelimited("%s: Incorrect NDP16\n", ndev->name);
		__mbim_length_errors_inc(mhi_netdev);
		goto error;
		}

		/* Only IP data type supported, no DSS in MHI context */
		if ((ndp16.dwSignature & cpu_to_le32(MBIM_NDP16_SIGN_MASK))
		!= cpu_to_le32(USB_CDC_MBIM_NDP16_IPS_SIGN)) {
		net_err_ratelimited("%s: Unsupported NDP type\n", ndev->name);
		__mbim_errors_inc(mhi_netdev);
		goto next_ndp;
		}

		/* Only primary IP session 0 (0x00) supported for now */
		if (ndp16.dwSignature & ~cpu_to_le32(MBIM_NDP16_SIGN_MASK)) {
		net_err_ratelimited("%s: bad packet session\n", ndev->name);
		__mbim_errors_inc(mhi_netdev);
		goto next_ndp;
		}

		/* de-aggregate and deliver IP packets */
		dpeoffset = ndpoffset + sizeof(struct usb_cdc_ncm_ndp16);
		for (n = 0; n < nframes; n++, dpeoffset += sizeof(dpe16)) {
		u16 dgram_offset, dgram_len;
		struct sk_buff *skbn;

		if (skb_copy_bits(skb, dpeoffset, &dpe16, sizeof(dpe16)))
		break;

		dgram_offset = le16_to_cpu(dpe16.wDatagramIndex);
		dgram_len = le16_to_cpu(dpe16.wDatagramLength);

		if (!dgram_offset \|\| !dgram_len)
		break; /* null terminator */

		skbn = netdev_alloc_skb(ndev, dgram_len);
		if (!skbn)
		continue;

		skb_put(skbn, dgram_len);
		skb_copy_bits(skb, dgram_offset, skbn->data, dgram_len);

		switch (skbn->data[0] & 0xf0) {
		case 0x40:
		skbn->protocol = htons(ETH_P_IP);
		break;
		case 0x60:
		skbn->protocol = htons(ETH_P_IPV6);
		break;
		default:
		net_err_ratelimited("%s: unknown protocol\n",
		ndev->name);
		__mbim_errors_inc(mhi_netdev);
		dev_kfree_skb_any(skbn);
		continue;
		}

		u64_stats_update_begin(&mhi_netdev->stats.rx_syncp);
		u64_stats_inc(&mhi_netdev->stats.rx_packets);
		u64_stats_add(&mhi_netdev->stats.rx_bytes, skbn->len);
		u64_stats_update_end(&mhi_netdev->stats.rx_syncp);
		netif_rx(skbn);
		}
		next_ndp:
		/* Other NDP to process? */
		ndpoffset = (int)le16_to_cpu(ndp16.wNextNdpIndex);
		if (!ndpoffset)
		break;
		}

		/* free skb */
		dev_consume_skb_any(skb);
		return;
		error:
		dev_kfree_skb_any(skb);
		}

		struct mbim_tx_hdr {
		struct usb_cdc_ncm_nth16 nth16;
		struct usb_cdc_ncm_ndp16 ndp16;
		struct usb_cdc_ncm_dpe16 dpe16[2];
		} __packed;

		static struct sk_buff mbim_tx_fixup(struct mhi_net_dev mhi_netdev,
		struct sk_buff *skb)
		{
		struct mbim_context *ctx = mhi_netdev->proto_data;
		unsigned int dgram_size = skb->len;
		struct usb_cdc_ncm_nth16 *nth16;
		struct usb_cdc_ncm_ndp16 *ndp16;
		struct mbim_tx_hdr *mbim_hdr;

		/* For now, this is a partial implementation of CDC MBIM, only one NDP
		* is sent, containing the IP packet (no aggregation).
		*/

		/* Ensure we have enough headroom for crafting MBIM header */
		if (skb_cow_head(skb, sizeof(struct mbim_tx_hdr))) {
		dev_kfree_skb_any(skb);
		return NULL;
		}

		mbim_hdr = skb_push(skb, sizeof(struct mbim_tx_hdr));

		/* Fill NTB header */
		nth16 = &mbim_hdr->nth16;
		nth16->dwSignature = cpu_to_le32(USB_CDC_NCM_NTH16_SIGN);
		nth16->wHeaderLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth16));
		nth16->wSequence = cpu_to_le16(ctx->tx_seq++);
		nth16->wBlockLength = cpu_to_le16(skb->len);
		nth16->wNdpIndex = cpu_to_le16(sizeof(struct usb_cdc_ncm_nth16));

		/* Fill the unique NDP */
		ndp16 = &mbim_hdr->ndp16;
		ndp16->dwSignature = cpu_to_le32(USB_CDC_MBIM_NDP16_IPS_SIGN);
		ndp16->wLength = cpu_to_le16(sizeof(struct usb_cdc_ncm_ndp16)
		+ sizeof(struct usb_cdc_ncm_dpe16) * 2);
		ndp16->wNextNdpIndex = 0;

		/* Datagram follows the mbim header */
		ndp16->dpe16[0].wDatagramIndex = cpu_to_le16(sizeof(struct mbim_tx_hdr));
		ndp16->dpe16[0].wDatagramLength = cpu_to_le16(dgram_size);

		/* null termination */
		ndp16->dpe16[1].wDatagramIndex = 0;
		ndp16->dpe16[1].wDatagramLength = 0;

		return skb;
		}

		static int mbim_init(struct mhi_net_dev *mhi_netdev)
		{
		struct net_device *ndev = mhi_netdev->ndev;

		mhi_netdev->proto_data = devm_kzalloc(&ndev->dev,
		sizeof(struct mbim_context),
		GFP_KERNEL);
		if (!mhi_netdev->proto_data)
		return -ENOMEM;

		ndev->needed_headroom = sizeof(struct mbim_tx_hdr);
		ndev->mtu = MHI_MBIM_DEFAULT_MTU;

		if (!mhi_netdev->mru)
		mhi_netdev->mru = MHI_MBIM_DEFAULT_MRU;

		return 0;
		}

		const struct mhi_net_proto proto_mbim = {
		.init = mbim_init,
		.rx = mbim_rx,
		.tx_fixup = mbim_tx_fixup,
		};