Minki/linux
1
0
Fork 1
mirror of https://github.com/torvalds/linux.git synced 2024-11-27 22:51:35 +00:00
Code Issues Packages Projects Releases Wiki Activity

net: mhi: Remove MBIM protocol

Browse Source 
The MBIM protocol has now been integrated in a proper WWAN driver. We
can then revert back to a simpler driver for mhi_net, which is used
for raw IP or QMAP protocol (via rmnet link).

- Remove protocol management
- Remove WWAN framework usage (only valid for mbim)
- Remove net/mhi directory for simpler mhi_net.c file

Signed-off-by: Loic Poulain <loic.poulain@linaro.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Loic Poulain 2021-08-03 15:36:29 +02:00 committed by David S. Miller
parent aa730a9905
commit 7ffa7542ec
6 changed files with 50 additions and 475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/net/Kconfig
View File

@ -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

2
drivers/net/Makefile
View File

@ -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

3
drivers/net/mhi/Makefile
View File

@ -1,3 +0,0 @@
obj-$(CONFIG_MHI_NET) += mhi_net.o
mhi_net-y := net.o proto_mbim.o

41
drivers/net/mhi/mhi.h
View File

@ -1,41 +0,0 @@
/* 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;

310
drivers/net/mhi/proto_mbim.c
View File

@ -1,310 +0,0 @@
// 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,
};

151
drivers/net/mhi/net.c → drivers/net/mhi_net.c
View File

@ -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)
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)
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 @@ exit_drop:
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,
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,
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,16 +221,12 @@ static void mhi_net_dl_callback(struct mhi_device *mhi_dev,
break; break;
} }
if (proto && proto->rx) {
proto->rx(mhi_netdev, skb);
} else {
u64_stats_update_begin(&mhi_netdev->stats.rx_syncp); u64_stats_update_begin(&mhi_netdev->stats.rx_syncp);
u64_stats_inc(&mhi_netdev->stats.rx_packets); u64_stats_inc(&mhi_netdev->stats.rx_packets);
u64_stats_add(&mhi_netdev->stats.rx_bytes, skb->len); u64_stats_add(&mhi_netdev->stats.rx_bytes, skb->len);
u64_stats_update_end(&mhi_netdev->stats.rx_syncp); u64_stats_update_end(&mhi_netdev->stats.rx_syncp);
netif_rx(skb); netif_rx(skb);
} }
}
/* Refill if RX buffers queue becomes low */ /* Refill if RX buffers queue becomes low */
if (free_desc_count >= mhi_netdev->rx_queue_sz / 2) if (free_desc_count >= mhi_netdev->rx_queue_sz / 2)
@ -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)
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,37 +326,21 @@ 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_netdevice(ndev);
else
err = register_netdev(ndev); 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_netdevice_queue(ndev, head);
else
unregister_netdev(ndev); 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,
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 */ mhi_net_dellink(mhi_dev, mhi_netdev->ndev);
wwan_unregister_ops(&cntrl->mhi_dev->dev);
if (create_default_iface)
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 = {
.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);