Skip to content

L
linux
Commit 93bbcfee authored by David S. Miller's avatar David S. Miller
Browse files
Options

Merge branch 'mhi-mbim' 

Loic Poulain says:

====================
net: mhi: move MBIM to WWAN

Implement a proper WWAN driver for MBIM network protocol, with multi link
management supported through the WWAN framework (wwan rtnetlink).

Until now, MBIM over MHI was supported directly in the mhi_net driver, via
some protocol rx/tx fixup callbacks, but with only one session supported
(no multilink muxing). We can then remove that part from mhi_net and restore
the driver to a simpler version for 'raw' ip transfer (or QMAP via rmnet link).

Note that a wwan0 link is created by default for session-id 0. Additional links
can be managed via ip tool:

    $ ip link add dev wwan0mms parentdev wwan0 type wwan linkid 1
====================
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 8730379e 7ffa7542
Hide whitespace changes
Inline Side-by-side
Showing with 720 additions and 475 deletions
drivers/net/Kconfig
View file @ 93bbcfee
...@@ -431,10 +431,10 @@ config VSOCKMON ...@@ -431,10 +431,10 @@ config VSOCKMON
config MHI_NET config MHI_NET
tristate "MHI network driver" tristate "MHI network driver"
depends on MHI_BUS depends on MHI_BUS
select WWAN
help help
This is the network driver for MHI bus. It can be used with 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 endif # NET_CORE
......
drivers/net/Makefile
View file @ 93bbcfee
...@@ -37,7 +37,7 @@ obj-$(CONFIG_GTP) += gtp.o ...@@ -37,7 +37,7 @@ obj-$(CONFIG_GTP) += gtp.o
obj-$(CONFIG_NLMON) += nlmon.o obj-$(CONFIG_NLMON) += nlmon.o
obj-$(CONFIG_NET_VRF) += vrf.o obj-$(CONFIG_NET_VRF) += vrf.o
obj-$(CONFIG_VSOCKMON) += vsockmon.o obj-$(CONFIG_VSOCKMON) += vsockmon.o
obj-$(CONFIG_MHI_NET) += mhi/ obj-$(CONFIG_MHI_NET) += mhi_net.o
# #
# Networking Drivers # Networking Drivers
......
drivers/net/mhi/Makefile deleted 100644 → 0
View file @ 8730379e
obj-$(CONFIG_MHI_NET) += mhi_net.o
mhi_net-y := net.o proto_mbim.o
drivers/net/mhi/mhi.h deleted 100644 → 0
View file @ 8730379e
/* 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 deleted 100644 → 0
View file @ 8730379e
// 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,
};
drivers/net/mhi/net.c → drivers/net/mhi_net.c
View file @ 93bbcfee
...@@ -11,28 +11,42 @@ ...@@ -11,28 +11,42 @@
#include <linux/netdevice.h> #include <linux/netdevice.h>
#include <linux/skbuff.h> #include <linux/skbuff.h>
#include <linux/u64_stats_sync.h> #include <linux/u64_stats_sync.h>
#include <linux/wwan.h>
#include "mhi.h"
#define MHI_NET_MIN_MTU ETH_MIN_MTU #define MHI_NET_MIN_MTU ETH_MIN_MTU
#define MHI_NET_MAX_MTU 0xffff #define MHI_NET_MAX_MTU 0xffff
#define MHI_NET_DEFAULT_MTU 0x4000 #define MHI_NET_DEFAULT_MTU 0x4000
/* When set to false, the default netdev (link 0) is not created, and it's up struct mhi_net_stats {
* to user to create the link (via wwan rtnetlink). u64_stats_t rx_packets;
*/ u64_stats_t rx_bytes;
static bool create_default_iface = true; u64_stats_t rx_errors;
module_param(create_default_iface, bool, 0); 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;
struct delayed_work rx_refill;
struct mhi_net_stats stats;
u32 rx_queue_sz;
int msg_enable;
unsigned int mru;
};
struct mhi_device_info { struct mhi_device_info {
const char *netname; const char *netname;
const struct mhi_net_proto *proto;
}; };
static int mhi_ndo_open(struct net_device *ndev) static int mhi_ndo_open(struct net_device *ndev)
{ {
struct mhi_net_dev *mhi_netdev = wwan_netdev_drvpriv(ndev); struct mhi_net_dev *mhi_netdev = netdev_priv(ndev);
/* Feed the rx buffer pool */ /* Feed the rx buffer pool */
schedule_delayed_work(&mhi_netdev->rx_refill, 0); schedule_delayed_work(&mhi_netdev->rx_refill, 0);
...@@ -47,7 +61,7 @@ static int mhi_ndo_open(struct net_device *ndev) ...@@ -47,7 +61,7 @@ static int mhi_ndo_open(struct net_device *ndev)
static int mhi_ndo_stop(struct net_device *ndev) static int mhi_ndo_stop(struct net_device *ndev)
{ {
struct mhi_net_dev *mhi_netdev = wwan_netdev_drvpriv(ndev); struct mhi_net_dev *mhi_netdev = netdev_priv(ndev);
netif_stop_queue(ndev); netif_stop_queue(ndev);
netif_carrier_off(ndev); netif_carrier_off(ndev);
...@@ -58,17 +72,10 @@ static int mhi_ndo_stop(struct net_device *ndev) ...@@ -58,17 +72,10 @@ static int mhi_ndo_stop(struct net_device *ndev)
static netdev_tx_t mhi_ndo_xmit(struct sk_buff *skb, struct net_device *ndev) static netdev_tx_t mhi_ndo_xmit(struct sk_buff *skb, struct net_device *ndev)
{ {
struct mhi_net_dev *mhi_netdev = wwan_netdev_drvpriv(ndev); struct mhi_net_dev *mhi_netdev = netdev_priv(ndev);
const struct mhi_net_proto *proto = mhi_netdev->proto;
struct mhi_device *mdev = mhi_netdev->mdev; struct mhi_device *mdev = mhi_netdev->mdev;
int err; int err;
if (proto && proto->tx_fixup) {
skb = proto->tx_fixup(mhi_netdev, skb);
if (unlikely(!skb))
goto exit_drop;
}
err = mhi_queue_skb(mdev, DMA_TO_DEVICE, skb, skb->len, MHI_EOT); err = mhi_queue_skb(mdev, DMA_TO_DEVICE, skb, skb->len, MHI_EOT);
if (unlikely(err)) { if (unlikely(err)) {
net_err_ratelimited("%s: Failed to queue TX buf (%d)\n", net_err_ratelimited("%s: Failed to queue TX buf (%d)\n",
...@@ -93,7 +100,7 @@ static netdev_tx_t mhi_ndo_xmit(struct sk_buff *skb, struct net_device *ndev) ...@@ -93,7 +100,7 @@ static netdev_tx_t mhi_ndo_xmit(struct sk_buff *skb, struct net_device *ndev)
static void mhi_ndo_get_stats64(struct net_device *ndev, static void mhi_ndo_get_stats64(struct net_device *ndev,
struct rtnl_link_stats64 *stats) struct rtnl_link_stats64 *stats)
{ {
struct mhi_net_dev *mhi_netdev = wwan_netdev_drvpriv(ndev); struct mhi_net_dev *mhi_netdev = netdev_priv(ndev);
unsigned int start; unsigned int start;
do { do {
...@@ -101,8 +108,6 @@ static void mhi_ndo_get_stats64(struct net_device *ndev, ...@@ -101,8 +108,6 @@ static void mhi_ndo_get_stats64(struct net_device *ndev,
stats->rx_packets = u64_stats_read(&mhi_netdev->stats.rx_packets); stats->rx_packets = u64_stats_read(&mhi_netdev->stats.rx_packets);
stats->rx_bytes = u64_stats_read(&mhi_netdev->stats.rx_bytes); stats->rx_bytes = u64_stats_read(&mhi_netdev->stats.rx_bytes);
stats->rx_errors = u64_stats_read(&mhi_netdev->stats.rx_errors); stats->rx_errors = u64_stats_read(&mhi_netdev->stats.rx_errors);
stats->rx_dropped = u64_stats_read(&mhi_netdev->stats.rx_dropped);
stats->rx_length_errors = u64_stats_read(&mhi_netdev->stats.rx_length_errors);
} while (u64_stats_fetch_retry_irq(&mhi_netdev->stats.rx_syncp, start)); } while (u64_stats_fetch_retry_irq(&mhi_netdev->stats.rx_syncp, start));
do { do {
...@@ -165,7 +170,6 @@ static void mhi_net_dl_callback(struct mhi_device *mhi_dev, ...@@ -165,7 +170,6 @@ static void mhi_net_dl_callback(struct mhi_device *mhi_dev,
struct mhi_result *mhi_res) struct mhi_result *mhi_res)
{ {
struct mhi_net_dev *mhi_netdev = dev_get_drvdata(&mhi_dev->dev); struct mhi_net_dev *mhi_netdev = dev_get_drvdata(&mhi_dev->dev);
const struct mhi_net_proto *proto = mhi_netdev->proto;
struct sk_buff *skb = mhi_res->buf_addr; struct sk_buff *skb = mhi_res->buf_addr;
int free_desc_count; int free_desc_count;
...@@ -217,15 +221,11 @@ static void mhi_net_dl_callback(struct mhi_device *mhi_dev, ...@@ -217,15 +221,11 @@ static void mhi_net_dl_callback(struct mhi_device *mhi_dev,
break; break;
} }
if (proto && proto->rx) { u64_stats_update_begin(&mhi_netdev->stats.rx_syncp);
proto->rx(mhi_netdev, skb); u64_stats_inc(&mhi_netdev->stats.rx_packets);
} else { u64_stats_add(&mhi_netdev->stats.rx_bytes, skb->len);
u64_stats_update_begin(&mhi_netdev->stats.rx_syncp); u64_stats_update_end(&mhi_netdev->stats.rx_syncp);
u64_stats_inc(&mhi_netdev->stats.rx_packets); netif_rx(skb);
u64_stats_add(&mhi_netdev->stats.rx_bytes, skb->len);
u64_stats_update_end(&mhi_netdev->stats.rx_syncp);
netif_rx(skb);
}
} }
/* Refill if RX buffers queue becomes low */ /* Refill if RX buffers queue becomes low */
...@@ -248,7 +248,6 @@ static void mhi_net_ul_callback(struct mhi_device *mhi_dev, ...@@ -248,7 +248,6 @@ static void mhi_net_ul_callback(struct mhi_device *mhi_dev,
u64_stats_update_begin(&mhi_netdev->stats.tx_syncp); u64_stats_update_begin(&mhi_netdev->stats.tx_syncp);
if (unlikely(mhi_res->transaction_status)) { if (unlikely(mhi_res->transaction_status)) {
/* MHI layer stopping/resetting the UL channel */ /* MHI layer stopping/resetting the UL channel */
if (mhi_res->transaction_status == -ENOTCONN) { if (mhi_res->transaction_status == -ENOTCONN) {
u64_stats_update_end(&mhi_netdev->stats.tx_syncp); u64_stats_update_end(&mhi_netdev->stats.tx_syncp);
...@@ -302,33 +301,17 @@ static void mhi_net_rx_refill_work(struct work_struct *work) ...@@ -302,33 +301,17 @@ static void mhi_net_rx_refill_work(struct work_struct *work)
schedule_delayed_work(&mhi_netdev->rx_refill, HZ / 2); schedule_delayed_work(&mhi_netdev->rx_refill, HZ / 2);
} }
static int mhi_net_newlink(void *ctxt, struct net_device *ndev, u32 if_id, static int mhi_net_newlink(struct mhi_device *mhi_dev, struct net_device *ndev)
struct netlink_ext_ack *extack)
{ {
const struct mhi_device_info *info;
struct mhi_device *mhi_dev = ctxt;
struct mhi_net_dev *mhi_netdev; struct mhi_net_dev *mhi_netdev;
int err; int err;
info = (struct mhi_device_info *)mhi_dev->id->driver_data; mhi_netdev = netdev_priv(ndev);
/* For now we only support one link (link context 0), driver must be
* reworked to break 1:1 relationship for net MBIM and to forward setup
* call to rmnet(QMAP) otherwise.
*/
if (if_id != 0)
return -EINVAL;
if (dev_get_drvdata(&mhi_dev->dev))
return -EBUSY;
mhi_netdev = wwan_netdev_drvpriv(ndev);
dev_set_drvdata(&mhi_dev->dev, mhi_netdev); dev_set_drvdata(&mhi_dev->dev, mhi_netdev);
mhi_netdev->ndev = ndev; mhi_netdev->ndev = ndev;
mhi_netdev->mdev = mhi_dev; mhi_netdev->mdev = mhi_dev;
mhi_netdev->skbagg_head = NULL; mhi_netdev->skbagg_head = NULL;
mhi_netdev->proto = info->proto;
mhi_netdev->mru = mhi_dev->mhi_cntrl->mru; mhi_netdev->mru = mhi_dev->mhi_cntrl->mru;
INIT_DELAYED_WORK(&mhi_netdev->rx_refill, mhi_net_rx_refill_work); INIT_DELAYED_WORK(&mhi_netdev->rx_refill, mhi_net_rx_refill_work);
...@@ -343,38 +326,22 @@ static int mhi_net_newlink(void *ctxt, struct net_device *ndev, u32 if_id, ...@@ -343,38 +326,22 @@ static int mhi_net_newlink(void *ctxt, struct net_device *ndev, u32 if_id,
/* Number of transfer descriptors determines size of the queue */ /* Number of transfer descriptors determines size of the queue */
mhi_netdev->rx_queue_sz = mhi_get_free_desc_count(mhi_dev, DMA_FROM_DEVICE); mhi_netdev->rx_queue_sz = mhi_get_free_desc_count(mhi_dev, DMA_FROM_DEVICE);
if (extack) err = register_netdev(ndev);
err = register_netdevice(ndev);
else
err = register_netdev(ndev);
if (err) if (err)
goto out_err; return err;
if (mhi_netdev->proto) {
err = mhi_netdev->proto->init(mhi_netdev);
if (err)
goto out_err_proto;
}
return 0; return 0;
out_err_proto:
unregister_netdevice(ndev);
out_err: out_err:
free_netdev(ndev); free_netdev(ndev);
return err; return err;
} }
static void mhi_net_dellink(void *ctxt, struct net_device *ndev, static void mhi_net_dellink(struct mhi_device *mhi_dev, struct net_device *ndev)
struct list_head *head)
{ {
struct mhi_net_dev *mhi_netdev = wwan_netdev_drvpriv(ndev); struct mhi_net_dev *mhi_netdev = netdev_priv(ndev);
struct mhi_device *mhi_dev = ctxt;
if (head) unregister_netdev(ndev);
unregister_netdevice_queue(ndev, head);
else
unregister_netdev(ndev);
mhi_unprepare_from_transfer(mhi_dev); mhi_unprepare_from_transfer(mhi_dev);
...@@ -383,65 +350,34 @@ static void mhi_net_dellink(void *ctxt, struct net_device *ndev, ...@@ -383,65 +350,34 @@ static void mhi_net_dellink(void *ctxt, struct net_device *ndev,
dev_set_drvdata(&mhi_dev->dev, NULL); dev_set_drvdata(&mhi_dev->dev, NULL);
} }
static const struct wwan_ops mhi_wwan_ops = {
.priv_size = sizeof(struct mhi_net_dev),
.setup = mhi_net_setup,
.newlink = mhi_net_newlink,
.dellink = mhi_net_dellink,
};
static int mhi_net_probe(struct mhi_device *mhi_dev, static int mhi_net_probe(struct mhi_device *mhi_dev,
const struct mhi_device_id *id) const struct mhi_device_id *id)
{ {
const struct mhi_device_info *info = (struct mhi_device_info *)id->driver_data; const struct mhi_device_info *info = (struct mhi_device_info *)id->driver_data;
struct mhi_controller *cntrl = mhi_dev->mhi_cntrl;
struct net_device *ndev; struct net_device *ndev;
int err; int err;
err = wwan_register_ops(&cntrl->mhi_dev->dev, &mhi_wwan_ops, mhi_dev,
WWAN_NO_DEFAULT_LINK);
if (err)
return err;
if (!create_default_iface)
return 0;
/* Create a default interface which is used as either RMNET real-dev,
* MBIM link 0 or ip link 0)
*/
ndev = alloc_netdev(sizeof(struct mhi_net_dev), info->netname, ndev = alloc_netdev(sizeof(struct mhi_net_dev), info->netname,
NET_NAME_PREDICTABLE, mhi_net_setup); NET_NAME_PREDICTABLE, mhi_net_setup);
if (!ndev) { if (!ndev)
err = -ENOMEM; return -ENOMEM;
goto err_unregister;
}
SET_NETDEV_DEV(ndev, &mhi_dev->dev); SET_NETDEV_DEV(ndev, &mhi_dev->dev);
err = mhi_net_newlink(mhi_dev, ndev, 0, NULL); err = mhi_net_newlink(mhi_dev, ndev);
if (err) if (err) {
goto err_release; free_netdev(ndev);
return err;
}
return 0; return 0;
err_release:
free_netdev(ndev);
err_unregister:
wwan_unregister_ops(&cntrl->mhi_dev->dev);
return err;
} }
static void mhi_net_remove(struct mhi_device *mhi_dev) static void mhi_net_remove(struct mhi_device *mhi_dev)
{ {
struct mhi_net_dev *mhi_netdev = dev_get_drvdata(&mhi_dev->dev); struct mhi_net_dev *mhi_netdev = dev_get_drvdata(&mhi_dev->dev);
struct mhi_controller *cntrl = mhi_dev->mhi_cntrl;
/* WWAN core takes care of removing remaining links */
wwan_unregister_ops(&cntrl->mhi_dev->dev);
if (create_default_iface) mhi_net_dellink(mhi_dev, mhi_netdev->ndev);
mhi_net_dellink(mhi_dev, mhi_netdev->ndev, NULL);
} }
static const struct mhi_device_info mhi_hwip0 = { static const struct mhi_device_info mhi_hwip0 = {
...@@ -452,18 +388,11 @@ static const struct mhi_device_info mhi_swip0 = { ...@@ -452,18 +388,11 @@ static const struct mhi_device_info mhi_swip0 = {
.netname = "mhi_swip%d", .netname = "mhi_swip%d",
}; };
static const struct mhi_device_info mhi_hwip0_mbim = {
.netname = "mhi_mbim%d",
.proto = &proto_mbim,
};
static const struct mhi_device_id mhi_net_id_table[] = { static const struct mhi_device_id mhi_net_id_table[] = {
/* Hardware accelerated data PATH (to modem IPA), protocol agnostic */ /* Hardware accelerated data PATH (to modem IPA), protocol agnostic */
{ .chan = "IP_HW0", .driver_data = (kernel_ulong_t)&mhi_hwip0 }, { .chan = "IP_HW0", .driver_data = (kernel_ulong_t)&mhi_hwip0 },
/* Software data PATH (to modem CPU) */ /* Software data PATH (to modem CPU) */
{ .chan = "IP_SW0", .driver_data = (kernel_ulong_t)&mhi_swip0 }, { .chan = "IP_SW0", .driver_data = (kernel_ulong_t)&mhi_swip0 },
/* Hardware accelerated data PATH (to modem IPA), MBIM protocol */
{ .chan = "IP_HW0_MBIM", .driver_data = (kernel_ulong_t)&mhi_hwip0_mbim },
{} {}
}; };
MODULE_DEVICE_TABLE(mhi, mhi_net_id_table); MODULE_DEVICE_TABLE(mhi, mhi_net_id_table);
......
drivers/net/wwan/Kconfig
View file @ 93bbcfee
...@@ -38,6 +38,18 @@ config MHI_WWAN_CTRL ...@@ -38,6 +38,18 @@ config MHI_WWAN_CTRL
To compile this driver as a module, choose M here: the module will be To compile this driver as a module, choose M here: the module will be
called mhi_wwan_ctrl. called mhi_wwan_ctrl.
config MHI_WWAN_MBIM
tristate "MHI WWAN MBIM network driver for QCOM-based PCIe modems"
depends on MHI_BUS
help
MHI WWAN MBIM is a WWAN network driver for QCOM-based PCIe modems.
It implements MBIM over MHI, for IP data aggregation and muxing.
A default wwan0 network interface is created for MBIM data session
ID 0. Additional links can be created via wwan rtnetlink type.
To compile this driver as a module, choose M here: the module will be
called mhi_wwan_mbim.
config RPMSG_WWAN_CTRL config RPMSG_WWAN_CTRL
tristate "RPMSG WWAN control driver" tristate "RPMSG WWAN control driver"
depends on RPMSG depends on RPMSG
......
drivers/net/wwan/Makefile
View file @ 93bbcfee
...@@ -9,5 +9,6 @@ wwan-objs += wwan_core.o ...@@ -9,5 +9,6 @@ wwan-objs += wwan_core.o
obj-$(CONFIG_WWAN_HWSIM) += wwan_hwsim.o obj-$(CONFIG_WWAN_HWSIM) += wwan_hwsim.o
obj-$(CONFIG_MHI_WWAN_CTRL) += mhi_wwan_ctrl.o obj-$(CONFIG_MHI_WWAN_CTRL) += mhi_wwan_ctrl.o
obj-$(CONFIG_MHI_WWAN_MBIM) += mhi_wwan_mbim.o
obj-$(CONFIG_RPMSG_WWAN_CTRL) += rpmsg_wwan_ctrl.o obj-$(CONFIG_RPMSG_WWAN_CTRL) += rpmsg_wwan_ctrl.o
obj-$(CONFIG_IOSM) += iosm/ obj-$(CONFIG_IOSM) += iosm/
drivers/net/wwan/mhi_wwan_mbim.c 0 → 100644
View file @ 93bbcfee
// SPDX-License-Identifier: GPL-2.0-or-later
/* MHI MBIM Network driver - Network/MBIM 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_arp.h>
#include <linux/if_vlan.h>
#include <linux/ip.h>
#include <linux/mhi.h>
#include <linux/mii.h>
#include <linux/mod_devicetable.h>
#include <linux/module.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/u64_stats_sync.h>
#include <linux/usb.h>
#include <linux/usb/cdc.h>
#include <linux/usb/usbnet.h>
#include <linux/usb/cdc_ncm.h>
#include <linux/wwan.h>
/* 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_DEFAULT_MRU 3500
#define MHI_MBIM_DEFAULT_MTU 1500
#define MHI_MAX_BUF_SZ 0xffff
#define MBIM_NDP16_SIGN_MASK 0x00ffffff
#define MHI_MBIM_LINK_HASH_SIZE 8
#define LINK_HASH(session) ((session) % MHI_MBIM_LINK_HASH_SIZE)
struct mhi_mbim_link {
struct mhi_mbim_context *mbim;
struct net_device *ndev;
unsigned int session;
/* stats */
u64_stats_t rx_packets;
u64_stats_t rx_bytes;
u64_stats_t rx_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 hlist_node hlnode;
};
struct mhi_mbim_context {
struct mhi_device *mdev;
struct sk_buff *skbagg_head;
struct sk_buff *skbagg_tail;
unsigned int mru;
u32 rx_queue_sz;
u16 rx_seq;
u16 tx_seq;
struct delayed_work rx_refill;
spinlock_t tx_lock;
struct hlist_head link_list[MHI_MBIM_LINK_HASH_SIZE];
};
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 mhi_mbim_link *mhi_mbim_get_link_rcu(struct mhi_mbim_context *mbim,
unsigned int session)
{
struct mhi_mbim_link *link;
hlist_for_each_entry_rcu(link, &mbim->link_list[LINK_HASH(session)], hlnode) {
if (link->session == session)
return link;
}
return NULL;
}
static struct sk_buff *mbim_tx_fixup(struct sk_buff *skb, unsigned int session,
u16 tx_seq)
{
unsigned int dgram_size = skb->len;
struct usb_cdc_ncm_nth16 *nth16;
struct usb_cdc_ncm_ndp16 *ndp16;
struct mbim_tx_hdr *mbim_hdr;
/* 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(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 | (session << 24));
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 netdev_tx_t mhi_mbim_ndo_xmit(struct sk_buff *skb, struct net_device *ndev)
{
struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev);
struct mhi_mbim_context *mbim = link->mbim;
unsigned long flags;
int err = -ENOMEM;
/* Serialize MHI channel queuing and MBIM seq */
spin_lock_irqsave(&mbim->tx_lock, flags);
skb = mbim_tx_fixup(skb, link->session, mbim->tx_seq);
if (unlikely(!skb))
goto exit_unlock;
err = mhi_queue_skb(mbim->mdev, DMA_TO_DEVICE, skb, skb->len, MHI_EOT);
if (mhi_queue_is_full(mbim->mdev, DMA_TO_DEVICE))
netif_stop_queue(ndev);
if (!err)
mbim->tx_seq++;
exit_unlock:
spin_unlock_irqrestore(&mbim->tx_lock, flags);
if (unlikely(err)) {
net_err_ratelimited("%s: Failed to queue TX buf (%d)\n",
ndev->name, err);
dev_kfree_skb_any(skb);
goto exit_drop;
}
return NETDEV_TX_OK;
exit_drop:
u64_stats_update_begin(&link->tx_syncp);
u64_stats_inc(&link->tx_dropped);
u64_stats_update_end(&link->tx_syncp);
return NETDEV_TX_OK;
}
static int mbim_rx_verify_nth16(struct mhi_mbim_context *mbim, struct sk_buff *skb)
{
struct usb_cdc_ncm_nth16 *nth16;
int len;
if (skb->len < sizeof(struct usb_cdc_ncm_nth16) +
sizeof(struct usb_cdc_ncm_ndp16)) {
net_err_ratelimited("frame too short\n");
return -EINVAL;
}
nth16 = (struct usb_cdc_ncm_nth16 *)skb->data;
if (nth16->dwSignature != cpu_to_le32(USB_CDC_NCM_NTH16_SIGN)) {
net_err_ratelimited("invalid NTH16 signature <%#010x>\n",
le32_to_cpu(nth16->dwSignature));
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) {
net_err_ratelimited("NTB does not fit into the skb %u/%u\n",
len, skb->len);
return -EINVAL;
}
if (mbim->rx_seq + 1 != le16_to_cpu(nth16->wSequence) &&
(mbim->rx_seq || le16_to_cpu(nth16->wSequence)) &&
!(mbim->rx_seq == 0xffff && !le16_to_cpu(nth16->wSequence))) {
net_err_ratelimited("sequence number glitch prev=%d curr=%d\n",
mbim->rx_seq, le16_to_cpu(nth16->wSequence));
}
mbim->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)
{
int ret;
if (le16_to_cpu(ndp16->wLength) < USB_CDC_NCM_NDP16_LENGTH_MIN) {
net_err_ratelimited("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) {
net_err_ratelimited("Invalid nframes = %d\n", ret);
return -EINVAL;
}
return ret;
}
static void mhi_mbim_rx(struct mhi_mbim_context *mbim, struct sk_buff *skb)
{
int ndpoffset;
/* Check NTB header and retrieve first NDP offset */
ndpoffset = mbim_rx_verify_nth16(mbim, skb);
if (ndpoffset < 0) {
net_err_ratelimited("mbim: Incorrect NTB header\n");
goto error;
}
/* Process each NDP */
while (1) {
struct usb_cdc_ncm_ndp16 ndp16;
struct usb_cdc_ncm_dpe16 dpe16;
struct mhi_mbim_link *link;
int nframes, n, dpeoffset;
unsigned int session;
if (skb_copy_bits(skb, ndpoffset, &ndp16, sizeof(ndp16))) {
net_err_ratelimited("mbim: Incorrect NDP offset (%u)\n",
ndpoffset);
goto error;
}
/* Check NDP header and retrieve number of datagrams */
nframes = mbim_rx_verify_ndp16(skb, &ndp16);
if (nframes < 0) {
net_err_ratelimited("mbim: Incorrect NDP16\n");
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("mbim: Unsupported NDP type\n");
goto next_ndp;
}
session = (le32_to_cpu(ndp16.dwSignature) & ~MBIM_NDP16_SIGN_MASK) >> 24;
rcu_read_lock();
link = mhi_mbim_get_link_rcu(mbim, session);
if (!link) {
net_err_ratelimited("mbim: bad packet session (%u)\n", session);
goto unlock;
}
/* 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(link->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",
link->ndev->name);
dev_kfree_skb_any(skbn);
u64_stats_update_begin(&link->rx_syncp);
u64_stats_inc(&link->rx_errors);
u64_stats_update_end(&link->rx_syncp);
continue;
}
u64_stats_update_begin(&link->rx_syncp);
u64_stats_inc(&link->rx_packets);
u64_stats_add(&link->rx_bytes, skbn->len);
u64_stats_update_end(&link->rx_syncp);
netif_rx(skbn);
}
unlock:
rcu_read_unlock();
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);
}
static struct sk_buff *mhi_net_skb_agg(struct mhi_mbim_context *mbim,
struct sk_buff *skb)
{
struct sk_buff *head = mbim->skbagg_head;
struct sk_buff *tail = mbim->skbagg_tail;
/* This is non-paged skb chaining using frag_list */
if (!head) {
mbim->skbagg_head = skb;
return skb;
}
if (!skb_shinfo(head)->frag_list)
skb_shinfo(head)->frag_list = skb;
else
tail->next = skb;
head->len += skb->len;
head->data_len += skb->len;
head->truesize += skb->truesize;
mbim->skbagg_tail = skb;
return mbim->skbagg_head;
}
static void mhi_net_rx_refill_work(struct work_struct *work)
{
struct mhi_mbim_context *mbim = container_of(work, struct mhi_mbim_context,
rx_refill.work);
struct mhi_device *mdev = mbim->mdev;
int err;
while (!mhi_queue_is_full(mdev, DMA_FROM_DEVICE)) {
struct sk_buff *skb = alloc_skb(MHI_DEFAULT_MRU, GFP_KERNEL);
if (unlikely(!skb))
break;
err = mhi_queue_skb(mdev, DMA_FROM_DEVICE, skb,
MHI_DEFAULT_MRU, MHI_EOT);
if (unlikely(err)) {
kfree_skb(skb);
break;
}
/* Do not hog the CPU if rx buffers are consumed faster than
* queued (unlikely).
*/
cond_resched();
}
/* If we're still starved of rx buffers, reschedule later */
if (mhi_get_free_desc_count(mdev, DMA_FROM_DEVICE) == mbim->rx_queue_sz)
schedule_delayed_work(&mbim->rx_refill, HZ / 2);
}
static void mhi_mbim_dl_callback(struct mhi_device *mhi_dev,
struct mhi_result *mhi_res)
{
struct mhi_mbim_context *mbim = dev_get_drvdata(&mhi_dev->dev);
struct sk_buff *skb = mhi_res->buf_addr;
int free_desc_count;
free_desc_count = mhi_get_free_desc_count(mhi_dev, DMA_FROM_DEVICE);
if (unlikely(mhi_res->transaction_status)) {
switch (mhi_res->transaction_status) {
case -EOVERFLOW:
/* Packet has been split over multiple transfers */
skb_put(skb, mhi_res->bytes_xferd);
mhi_net_skb_agg(mbim, skb);
break;
case -ENOTCONN:
/* MHI layer stopping/resetting the DL channel */
dev_kfree_skb_any(skb);
return;
default:
/* Unknown error, simply drop */
dev_kfree_skb_any(skb);
}
} else {
skb_put(skb, mhi_res->bytes_xferd);
if (mbim->skbagg_head) {
/* Aggregate the final fragment */
skb = mhi_net_skb_agg(mbim, skb);
mbim->skbagg_head = NULL;
}
mhi_mbim_rx(mbim, skb);
}
/* Refill if RX buffers queue becomes low */
if (free_desc_count >= mbim->rx_queue_sz / 2)
schedule_delayed_work(&mbim->rx_refill, 0);
}
static void mhi_mbim_ndo_get_stats64(struct net_device *ndev,
struct rtnl_link_stats64 *stats)
{
struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev);
unsigned int start;
do {
start = u64_stats_fetch_begin_irq(&link->rx_syncp);
stats->rx_packets = u64_stats_read(&link->rx_packets);
stats->rx_bytes = u64_stats_read(&link->rx_bytes);
stats->rx_errors = u64_stats_read(&link->rx_errors);
} while (u64_stats_fetch_retry_irq(&link->rx_syncp, start));
do {
start = u64_stats_fetch_begin_irq(&link->tx_syncp);
stats->tx_packets = u64_stats_read(&link->tx_packets);
stats->tx_bytes = u64_stats_read(&link->tx_bytes);
stats->tx_errors = u64_stats_read(&link->tx_errors);
stats->tx_dropped = u64_stats_read(&link->tx_dropped);
} while (u64_stats_fetch_retry_irq(&link->tx_syncp, start));
}
static void mhi_mbim_ul_callback(struct mhi_device *mhi_dev,
struct mhi_result *mhi_res)
{
struct mhi_mbim_context *mbim = dev_get_drvdata(&mhi_dev->dev);
struct sk_buff *skb = mhi_res->buf_addr;
struct net_device *ndev = skb->dev;
struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev);
/* Hardware has consumed the buffer, so free the skb (which is not
* freed by the MHI stack) and perform accounting.
*/
dev_consume_skb_any(skb);
u64_stats_update_begin(&link->tx_syncp);
if (unlikely(mhi_res->transaction_status)) {
/* MHI layer stopping/resetting the UL channel */
if (mhi_res->transaction_status == -ENOTCONN) {
u64_stats_update_end(&link->tx_syncp);
return;
}
u64_stats_inc(&link->tx_errors);
} else {
u64_stats_inc(&link->tx_packets);
u64_stats_add(&link->tx_bytes, mhi_res->bytes_xferd);
}
u64_stats_update_end(&link->tx_syncp);
if (netif_queue_stopped(ndev) && !mhi_queue_is_full(mbim->mdev, DMA_TO_DEVICE))
netif_wake_queue(ndev);
}
static int mhi_mbim_ndo_open(struct net_device *ndev)
{
struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev);
/* Feed the MHI rx buffer pool */
schedule_delayed_work(&link->mbim->rx_refill, 0);
/* Carrier is established via out-of-band channel (e.g. qmi) */
netif_carrier_on(ndev);
netif_start_queue(ndev);
return 0;
}
static int mhi_mbim_ndo_stop(struct net_device *ndev)
{
netif_stop_queue(ndev);
netif_carrier_off(ndev);
return 0;
}
static const struct net_device_ops mhi_mbim_ndo = {
.ndo_open = mhi_mbim_ndo_open,
.ndo_stop = mhi_mbim_ndo_stop,
.ndo_start_xmit = mhi_mbim_ndo_xmit,
.ndo_get_stats64 = mhi_mbim_ndo_get_stats64,
};
static int mhi_mbim_newlink(void *ctxt, struct net_device *ndev, u32 if_id,
struct netlink_ext_ack *extack)
{
struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev);
struct mhi_mbim_context *mbim = ctxt;
link->session = if_id;
link->mbim = mbim;
link->ndev = ndev;
u64_stats_init(&link->rx_syncp);
u64_stats_init(&link->tx_syncp);
rcu_read_lock();
if (mhi_mbim_get_link_rcu(mbim, if_id)) {
rcu_read_unlock();
return -EEXIST;
}
rcu_read_unlock();
/* Already protected by RTNL lock */
hlist_add_head_rcu(&link->hlnode, &mbim->link_list[LINK_HASH(if_id)]);
return register_netdevice(ndev);
}
static void mhi_mbim_dellink(void *ctxt, struct net_device *ndev,
struct list_head *head)
{
struct mhi_mbim_link *link = wwan_netdev_drvpriv(ndev);
hlist_del_init_rcu(&link->hlnode);
synchronize_rcu();
unregister_netdevice_queue(ndev, head);
}
static void mhi_mbim_setup(struct net_device *ndev)
{
ndev->header_ops = NULL; /* No header */
ndev->type = ARPHRD_RAWIP;
ndev->needed_headroom = sizeof(struct mbim_tx_hdr);
ndev->hard_header_len = 0;
ndev->addr_len = 0;
ndev->flags = IFF_POINTOPOINT | IFF_NOARP;
ndev->netdev_ops = &mhi_mbim_ndo;
ndev->mtu = MHI_MBIM_DEFAULT_MTU;
ndev->min_mtu = ETH_MIN_MTU;
ndev->max_mtu = MHI_MAX_BUF_SZ - ndev->needed_headroom;
ndev->tx_queue_len = 1000;
}
static const struct wwan_ops mhi_mbim_wwan_ops = {
.priv_size = sizeof(struct mhi_mbim_link),
.setup = mhi_mbim_setup,
.newlink = mhi_mbim_newlink,
.dellink = mhi_mbim_dellink,
};
static int mhi_mbim_probe(struct mhi_device *mhi_dev, const struct mhi_device_id *id)
{
struct mhi_controller *cntrl = mhi_dev->mhi_cntrl;
struct mhi_mbim_context *mbim;
int err;
mbim = devm_kzalloc(&mhi_dev->dev, sizeof(*mbim), GFP_KERNEL);
if (!mbim)
return -ENOMEM;
dev_set_drvdata(&mhi_dev->dev, mbim);
mbim->mdev = mhi_dev;
mbim->mru = mhi_dev->mhi_cntrl->mru ? mhi_dev->mhi_cntrl->mru : MHI_DEFAULT_MRU;
INIT_DELAYED_WORK(&mbim->rx_refill, mhi_net_rx_refill_work);
/* Start MHI channels */
err = mhi_prepare_for_transfer(mhi_dev);
if (err)
return err;
/* Number of transfer descriptors determines size of the queue */
mbim->rx_queue_sz = mhi_get_free_desc_count(mhi_dev, DMA_FROM_DEVICE);
/* Register wwan link ops with MHI controller representing WWAN instance */
return wwan_register_ops(&cntrl->mhi_dev->dev, &mhi_mbim_wwan_ops, mbim, 0);
}
static void mhi_mbim_remove(struct mhi_device *mhi_dev)
{
struct mhi_mbim_context *mbim = dev_get_drvdata(&mhi_dev->dev);
struct mhi_controller *cntrl = mhi_dev->mhi_cntrl;
mhi_unprepare_from_transfer(mhi_dev);
cancel_delayed_work_sync(&mbim->rx_refill);
wwan_unregister_ops(&cntrl->mhi_dev->dev);
kfree_skb(mbim->skbagg_head);
dev_set_drvdata(&mhi_dev->dev, NULL);
}
static const struct mhi_device_id mhi_mbim_id_table[] = {
/* Hardware accelerated data PATH (to modem IPA), MBIM protocol */
{ .chan = "IP_HW0_MBIM", .driver_data = 0 },
{}
};
MODULE_DEVICE_TABLE(mhi, mhi_mbim_id_table);
static struct mhi_driver mhi_mbim_driver = {
.probe = mhi_mbim_probe,
.remove = mhi_mbim_remove,
.dl_xfer_cb = mhi_mbim_dl_callback,
.ul_xfer_cb = mhi_mbim_ul_callback,
.id_table = mhi_mbim_id_table,
.driver = {
.name = "mhi_wwan_mbim",
.owner = THIS_MODULE,
},
};
module_mhi_driver(mhi_mbim_driver);
MODULE_AUTHOR("Loic Poulain <loic.poulain@linaro.org>");
MODULE_DESCRIPTION("Network/MBIM over MHI");
MODULE_LICENSE("GPL v2");
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
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7