| /* Copyright (c) 2013-2020, The Linux Foundation. All rights reserved. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License version 2 and |
| * only version 2 as published by the Free Software Foundation. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| * |
| * RMNET configuration engine |
| * |
| */ |
| |
| #include <net/sock.h> |
| #include <linux/module.h> |
| #include <linux/netlink.h> |
| #include <linux/netdevice.h> |
| #include "rmnet_config.h" |
| #include "rmnet_handlers.h" |
| #include "rmnet_vnd.h" |
| #include "rmnet_private.h" |
| #include "rmnet_map.h" |
| #include "rmnet_descriptor.h" |
| #include "rmnet_genl.h" |
| #include "rmnet_qmi.h" |
| #include "qmi_rmnet.h" |
| #define CONFIG_QTI_QMI_RMNET 1 |
| #define CONFIG_QTI_QMI_DFC 1 |
| #define CONFIG_QTI_QMI_POWER_COLLAPSE 1 |
| |
| /* Locking scheme - |
| * The shared resource which needs to be protected is realdev->rx_handler_data. |
| * For the writer path, this is using rtnl_lock(). The writer paths are |
| * rmnet_newlink(), rmnet_dellink() and rmnet_force_unassociate_device(). These |
| * paths are already called with rtnl_lock() acquired in. There is also an |
| * ASSERT_RTNL() to ensure that we are calling with rtnl acquired. For |
| * dereference here, we will need to use rtnl_dereference(). Dev list writing |
| * needs to happen with rtnl_lock() acquired for netdev_master_upper_dev_link(). |
| * For the reader path, the real_dev->rx_handler_data is called in the TX / RX |
| * path. We only need rcu_read_lock() for these scenarios. In these cases, |
| * the rcu_read_lock() is held in __dev_queue_xmit() and |
| * netif_receive_skb_internal(), so readers need to use rcu_dereference_rtnl() |
| * to get the relevant information. For dev list reading, we again acquire |
| * rcu_read_lock() in rmnet_dellink() for netdev_master_upper_dev_get_rcu(). |
| * We also use unregister_netdevice_many() to free all rmnet devices in |
| * rmnet_force_unassociate_device() so we dont lose the rtnl_lock() and free in |
| * same context. |
| */ |
| |
| /* Local Definitions and Declarations */ |
| |
| enum { |
| IFLA_RMNET_DFC_QOS = __IFLA_RMNET_MAX, |
| IFLA_RMNET_UL_AGG_PARAMS, |
| __IFLA_RMNET_EXT_MAX, |
| }; |
| |
| static const struct nla_policy rmnet_policy[__IFLA_RMNET_EXT_MAX] = { |
| [IFLA_RMNET_MUX_ID] = { |
| .type = NLA_U16 |
| }, |
| [IFLA_RMNET_FLAGS] = { |
| .len = sizeof(struct ifla_rmnet_flags) |
| }, |
| [IFLA_RMNET_DFC_QOS] = { |
| .len = sizeof(struct tcmsg) |
| }, |
| [IFLA_RMNET_UL_AGG_PARAMS] = { |
| .len = sizeof(struct rmnet_egress_agg_params) |
| }, |
| }; |
| |
| int rmnet_is_real_dev_registered(const struct net_device *real_dev) |
| { |
| return rcu_access_pointer(real_dev->rx_handler) == rmnet_rx_handler; |
| } |
| EXPORT_SYMBOL(rmnet_is_real_dev_registered); |
| |
| /* Needs rtnl lock */ |
| static struct rmnet_port* |
| rmnet_get_port_rtnl(const struct net_device *real_dev) |
| { |
| return rtnl_dereference(real_dev->rx_handler_data); |
| } |
| |
| static int rmnet_unregister_real_device(struct net_device *real_dev, |
| struct rmnet_port *port) |
| { |
| if (port->nr_rmnet_devs) |
| return -EINVAL; |
| |
| netdev_rx_handler_unregister(real_dev); |
| |
| rmnet_map_cmd_exit(port); |
| rmnet_map_tx_aggregate_exit(port); |
| |
| rmnet_descriptor_deinit(port); |
| |
| kfree(port); |
| |
| /* release reference on real_dev */ |
| dev_put(real_dev); |
| |
| netdev_dbg(real_dev, "Removed from rmnet\n"); |
| return 0; |
| } |
| |
| static int rmnet_register_real_device(struct net_device *real_dev) |
| { |
| struct rmnet_port *port; |
| int rc, entry; |
| |
| ASSERT_RTNL(); |
| |
| if (rmnet_is_real_dev_registered(real_dev)) |
| return 0; |
| |
| port = kzalloc(sizeof(*port), GFP_ATOMIC); |
| if (!port) |
| return -ENOMEM; |
| |
| port->dev = real_dev; |
| rc = netdev_rx_handler_register(real_dev, rmnet_rx_handler, port); |
| if (rc) { |
| kfree(port); |
| return -EBUSY; |
| } |
| /* hold on to real dev for MAP data */ |
| dev_hold(real_dev); |
| |
| for (entry = 0; entry < RMNET_MAX_LOGICAL_EP; entry++) |
| INIT_HLIST_HEAD(&port->muxed_ep[entry]); |
| |
| rc = rmnet_descriptor_init(port); |
| if (rc) { |
| rmnet_descriptor_deinit(port); |
| return rc; |
| } |
| |
| rmnet_map_tx_aggregate_init(port); |
| rmnet_map_cmd_init(port); |
| |
| netdev_dbg(real_dev, "registered with rmnet\n"); |
| return 0; |
| } |
| |
| static void rmnet_unregister_bridge(struct net_device *dev, |
| struct rmnet_port *port) |
| { |
| struct rmnet_port *bridge_port; |
| struct net_device *bridge_dev; |
| |
| if (port->rmnet_mode != RMNET_EPMODE_BRIDGE) |
| return; |
| |
| /* bridge slave handling */ |
| if (!port->nr_rmnet_devs) { |
| bridge_dev = port->bridge_ep; |
| |
| bridge_port = rmnet_get_port_rtnl(bridge_dev); |
| bridge_port->bridge_ep = NULL; |
| bridge_port->rmnet_mode = RMNET_EPMODE_VND; |
| } else { |
| bridge_dev = port->bridge_ep; |
| |
| bridge_port = rmnet_get_port_rtnl(bridge_dev); |
| rmnet_unregister_real_device(bridge_dev, bridge_port); |
| } |
| } |
| |
| static int rmnet_newlink(struct net *src_net, struct net_device *dev, |
| struct nlattr *tb[], struct nlattr *data[], |
| struct netlink_ext_ack *extack) |
| { |
| struct net_device *real_dev; |
| int mode = RMNET_EPMODE_VND; |
| struct rmnet_endpoint *ep; |
| struct rmnet_port *port; |
| u32 data_format; |
| int err = 0; |
| u16 mux_id; |
| |
| real_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK])); |
| if (!real_dev || !dev) |
| return -ENODEV; |
| |
| if (!data[IFLA_RMNET_MUX_ID]) |
| return -EINVAL; |
| |
| ep = kzalloc(sizeof(*ep), GFP_ATOMIC); |
| if (!ep) |
| return -ENOMEM; |
| |
| mux_id = nla_get_u16(data[IFLA_RMNET_MUX_ID]); |
| |
| err = rmnet_register_real_device(real_dev); |
| if (err) |
| goto err0; |
| |
| port = rmnet_get_port_rtnl(real_dev); |
| err = rmnet_vnd_newlink(mux_id, dev, port, real_dev, ep); |
| if (err) |
| goto err1; |
| |
| port->rmnet_mode = mode; |
| |
| hlist_add_head_rcu(&ep->hlnode, &port->muxed_ep[mux_id]); |
| |
| if (data[IFLA_RMNET_FLAGS]) { |
| struct ifla_rmnet_flags *flags; |
| |
| flags = nla_data(data[IFLA_RMNET_FLAGS]); |
| data_format = flags->flags & flags->mask; |
| netdev_dbg(dev, "data format [0x%08X]\n", data_format); |
| port->data_format = data_format; |
| } |
| |
| if (data[IFLA_RMNET_UL_AGG_PARAMS]) { |
| void *agg_params; |
| unsigned long irq_flags; |
| |
| agg_params = nla_data(data[IFLA_RMNET_UL_AGG_PARAMS]); |
| spin_lock_irqsave(&port->agg_lock, irq_flags); |
| memcpy(&port->egress_agg_params, agg_params, |
| sizeof(port->egress_agg_params)); |
| spin_unlock_irqrestore(&port->agg_lock, irq_flags); |
| } |
| |
| return 0; |
| |
| err1: |
| rmnet_unregister_real_device(real_dev, port); |
| err0: |
| kfree(ep); |
| return err; |
| } |
| |
| static void rmnet_dellink(struct net_device *dev, struct list_head *head) |
| { |
| struct rmnet_priv *priv = netdev_priv(dev); |
| struct net_device *real_dev; |
| struct rmnet_endpoint *ep; |
| struct rmnet_port *port; |
| u8 mux_id; |
| |
| real_dev = priv->real_dev; |
| |
| if (!real_dev || !rmnet_is_real_dev_registered(real_dev)) |
| return; |
| |
| port = rmnet_get_port_rtnl(real_dev); |
| |
| mux_id = rmnet_vnd_get_mux(dev); |
| |
| ep = rmnet_get_endpoint(port, mux_id); |
| if (ep) { |
| hlist_del_init_rcu(&ep->hlnode); |
| rmnet_unregister_bridge(dev, port); |
| rmnet_vnd_dellink(mux_id, port, ep); |
| synchronize_rcu(); |
| kfree(ep); |
| } |
| |
| if (!port->nr_rmnet_devs) |
| qmi_rmnet_qmi_exit(port->qmi_info, port); |
| |
| unregister_netdevice(dev); |
| |
| qmi_rmnet_qos_exit_post(); |
| |
| rmnet_unregister_real_device(real_dev, port); |
| } |
| |
| static void rmnet_force_unassociate_device(struct net_device *dev) |
| { |
| struct net_device *real_dev = dev; |
| struct hlist_node *tmp_ep; |
| struct rmnet_endpoint *ep; |
| struct rmnet_port *port; |
| unsigned long bkt_ep; |
| LIST_HEAD(list); |
| HLIST_HEAD(cleanup_list); |
| |
| if (!rmnet_is_real_dev_registered(real_dev)) |
| return; |
| |
| ASSERT_RTNL(); |
| |
| port = rmnet_get_port_rtnl(dev); |
| qmi_rmnet_qmi_exit(port->qmi_info, port); |
| |
| rmnet_unregister_bridge(dev, port); |
| |
| hash_for_each_safe(port->muxed_ep, bkt_ep, tmp_ep, ep, hlnode) { |
| unregister_netdevice_queue(ep->egress_dev, &list); |
| rmnet_vnd_dellink(ep->mux_id, port, ep); |
| |
| hlist_del_init_rcu(&ep->hlnode); |
| hlist_add_head(&ep->hlnode, &cleanup_list); |
| } |
| |
| synchronize_rcu(); |
| |
| hlist_for_each_entry_safe(ep, tmp_ep, &cleanup_list, hlnode) { |
| hlist_del(&ep->hlnode); |
| kfree(ep); |
| } |
| |
| /* Unregistering devices in context before freeing port. |
| * If this API becomes non-context their order should switch. |
| */ |
| unregister_netdevice_many(&list); |
| |
| qmi_rmnet_qos_exit_post(); |
| |
| rmnet_unregister_real_device(real_dev, port); |
| } |
| |
| static int rmnet_config_notify_cb(struct notifier_block *nb, |
| unsigned long event, void *data) |
| { |
| struct net_device *dev = netdev_notifier_info_to_dev(data); |
| |
| if (!dev) |
| return NOTIFY_DONE; |
| |
| switch (event) { |
| case NETDEV_UNREGISTER: |
| netdev_dbg(dev, "Kernel unregister\n"); |
| rmnet_force_unassociate_device(dev); |
| break; |
| |
| default: |
| break; |
| } |
| |
| return NOTIFY_DONE; |
| } |
| |
| static struct notifier_block rmnet_dev_notifier __read_mostly = { |
| .notifier_call = rmnet_config_notify_cb, |
| }; |
| |
| static int rmnet_rtnl_validate(struct nlattr *tb[], struct nlattr *data[], |
| struct netlink_ext_ack *extack) |
| { |
| struct rmnet_egress_agg_params *agg_params; |
| u16 mux_id; |
| |
| if (!data) { |
| return -EINVAL; |
| } else { |
| if (data[IFLA_RMNET_MUX_ID]) { |
| mux_id = nla_get_u16(data[IFLA_RMNET_MUX_ID]); |
| if (mux_id > (RMNET_MAX_LOGICAL_EP - 1)) |
| return -ERANGE; |
| } |
| |
| if (data[IFLA_RMNET_UL_AGG_PARAMS]) { |
| agg_params = nla_data(data[IFLA_RMNET_UL_AGG_PARAMS]); |
| if (agg_params->agg_time < 3000000) |
| return -EINVAL; |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int rmnet_changelink(struct net_device *dev, struct nlattr *tb[], |
| struct nlattr *data[], |
| struct netlink_ext_ack *extack) |
| { |
| struct rmnet_priv *priv = netdev_priv(dev); |
| struct net_device *real_dev; |
| struct rmnet_endpoint *ep; |
| struct rmnet_port *port; |
| u16 mux_id; |
| |
| real_dev = __dev_get_by_index(dev_net(dev), |
| nla_get_u32(tb[IFLA_LINK])); |
| |
| if (!real_dev || !dev || !rmnet_is_real_dev_registered(real_dev)) |
| return -ENODEV; |
| |
| port = rmnet_get_port_rtnl(real_dev); |
| |
| if (data[IFLA_RMNET_MUX_ID]) { |
| mux_id = nla_get_u16(data[IFLA_RMNET_MUX_ID]); |
| ep = rmnet_get_endpoint(port, priv->mux_id); |
| if (!ep) |
| return -ENODEV; |
| |
| hlist_del_init_rcu(&ep->hlnode); |
| hlist_add_head_rcu(&ep->hlnode, &port->muxed_ep[mux_id]); |
| |
| ep->mux_id = mux_id; |
| priv->mux_id = mux_id; |
| } |
| |
| if (data[IFLA_RMNET_FLAGS]) { |
| struct ifla_rmnet_flags *flags; |
| |
| flags = nla_data(data[IFLA_RMNET_FLAGS]); |
| port->data_format = flags->flags & flags->mask; |
| } |
| |
| if (data[IFLA_RMNET_DFC_QOS]) { |
| struct tcmsg *tcm; |
| |
| tcm = nla_data(data[IFLA_RMNET_DFC_QOS]); |
| qmi_rmnet_change_link(dev, port, tcm); |
| } |
| |
| if (data[IFLA_RMNET_UL_AGG_PARAMS]) { |
| struct rmnet_egress_agg_params *agg_params; |
| |
| agg_params = nla_data(data[IFLA_RMNET_UL_AGG_PARAMS]); |
| rmnet_map_update_ul_agg_config(port, agg_params->agg_size, |
| agg_params->agg_count, |
| agg_params->agg_features, |
| agg_params->agg_time); |
| } |
| |
| return 0; |
| } |
| |
| static size_t rmnet_get_size(const struct net_device *dev) |
| { |
| return |
| /* IFLA_RMNET_MUX_ID */ |
| nla_total_size(2) + |
| /* IFLA_RMNET_FLAGS */ |
| nla_total_size(sizeof(struct ifla_rmnet_flags)) + |
| /* IFLA_RMNET_DFC_QOS */ |
| nla_total_size(sizeof(struct tcmsg)) + |
| /* IFLA_RMNET_UL_AGG_PARAMS */ |
| nla_total_size(sizeof(struct rmnet_egress_agg_params)); |
| } |
| |
| static int rmnet_fill_info(struct sk_buff *skb, const struct net_device *dev) |
| { |
| struct rmnet_priv *priv = netdev_priv(dev); |
| struct net_device *real_dev; |
| struct ifla_rmnet_flags f; |
| struct rmnet_port *port = NULL; |
| |
| real_dev = priv->real_dev; |
| |
| if (nla_put_u16(skb, IFLA_RMNET_MUX_ID, priv->mux_id)) |
| goto nla_put_failure; |
| |
| if (rmnet_is_real_dev_registered(real_dev)) { |
| port = rmnet_get_port_rtnl(real_dev); |
| f.flags = port->data_format; |
| } else { |
| f.flags = 0; |
| } |
| |
| f.mask = ~0; |
| |
| if (nla_put(skb, IFLA_RMNET_FLAGS, sizeof(f), &f)) |
| goto nla_put_failure; |
| |
| if (port) { |
| if (nla_put(skb, IFLA_RMNET_UL_AGG_PARAMS, |
| sizeof(port->egress_agg_params), |
| &port->egress_agg_params)) |
| goto nla_put_failure; |
| } |
| |
| return 0; |
| |
| nla_put_failure: |
| return -EMSGSIZE; |
| } |
| |
| struct rtnl_link_ops rmnet_link_ops __read_mostly = { |
| .kind = "rmnet", |
| .maxtype = __IFLA_RMNET_EXT_MAX, |
| .priv_size = sizeof(struct rmnet_priv), |
| .setup = rmnet_vnd_setup, |
| .validate = rmnet_rtnl_validate, |
| .newlink = rmnet_newlink, |
| .dellink = rmnet_dellink, |
| .get_size = rmnet_get_size, |
| .changelink = rmnet_changelink, |
| .policy = rmnet_policy, |
| .fill_info = rmnet_fill_info, |
| }; |
| |
| /* Needs either rcu_read_lock() or rtnl lock */ |
| struct rmnet_port *rmnet_get_port(struct net_device *real_dev) |
| { |
| if (rmnet_is_real_dev_registered(real_dev)) |
| return rcu_dereference_rtnl(real_dev->rx_handler_data); |
| else |
| return NULL; |
| } |
| EXPORT_SYMBOL(rmnet_get_port); |
| |
| struct rmnet_endpoint *rmnet_get_endpoint(struct rmnet_port *port, u8 mux_id) |
| { |
| struct rmnet_endpoint *ep; |
| |
| hlist_for_each_entry_rcu(ep, &port->muxed_ep[mux_id], hlnode) { |
| if (ep->mux_id == mux_id) |
| return ep; |
| } |
| |
| return NULL; |
| } |
| EXPORT_SYMBOL(rmnet_get_endpoint); |
| |
| int rmnet_add_bridge(struct net_device *rmnet_dev, |
| struct net_device *slave_dev, |
| struct netlink_ext_ack *extack) |
| { |
| struct rmnet_priv *priv = netdev_priv(rmnet_dev); |
| struct net_device *real_dev = priv->real_dev; |
| struct rmnet_port *port, *slave_port; |
| int err; |
| |
| port = rmnet_get_port(real_dev); |
| |
| /* If there is more than one rmnet dev attached, its probably being |
| * used for muxing. Skip the briding in that case |
| */ |
| if (port->nr_rmnet_devs > 1) |
| return -EINVAL; |
| |
| if (rmnet_is_real_dev_registered(slave_dev)) |
| return -EBUSY; |
| |
| err = rmnet_register_real_device(slave_dev); |
| if (err) |
| return -EBUSY; |
| |
| slave_port = rmnet_get_port(slave_dev); |
| slave_port->rmnet_mode = RMNET_EPMODE_BRIDGE; |
| slave_port->bridge_ep = real_dev; |
| |
| port->rmnet_mode = RMNET_EPMODE_BRIDGE; |
| port->bridge_ep = slave_dev; |
| |
| netdev_dbg(slave_dev, "registered with rmnet as slave\n"); |
| return 0; |
| } |
| |
| int rmnet_del_bridge(struct net_device *rmnet_dev, |
| struct net_device *slave_dev) |
| { |
| struct rmnet_priv *priv = netdev_priv(rmnet_dev); |
| struct net_device *real_dev = priv->real_dev; |
| struct rmnet_port *port, *slave_port; |
| |
| port = rmnet_get_port(real_dev); |
| port->rmnet_mode = RMNET_EPMODE_VND; |
| port->bridge_ep = NULL; |
| |
| slave_port = rmnet_get_port(slave_dev); |
| rmnet_unregister_real_device(slave_dev, slave_port); |
| |
| netdev_dbg(slave_dev, "removed from rmnet as slave\n"); |
| return 0; |
| } |
| |
| void *rmnet_get_qmi_pt(void *port) |
| { |
| if (port) |
| return ((struct rmnet_port *)port)->qmi_info; |
| |
| return NULL; |
| } |
| EXPORT_SYMBOL(rmnet_get_qmi_pt); |
| |
| void *rmnet_get_qos_pt(struct net_device *dev) |
| { |
| struct rmnet_priv *priv; |
| |
| if (dev) { |
| priv = netdev_priv(dev); |
| return rcu_dereference(priv->qos_info); |
| } |
| |
| return NULL; |
| } |
| EXPORT_SYMBOL(rmnet_get_qos_pt); |
| |
| void *rmnet_get_rmnet_port(struct net_device *dev) |
| { |
| struct rmnet_priv *priv; |
| |
| if (dev) { |
| priv = netdev_priv(dev); |
| return (void *)rmnet_get_port(priv->real_dev); |
| } |
| |
| return NULL; |
| } |
| EXPORT_SYMBOL(rmnet_get_rmnet_port); |
| |
| struct net_device *rmnet_get_rmnet_dev(void *port, u8 mux_id) |
| { |
| struct rmnet_endpoint *ep; |
| |
| if (port) { |
| ep = rmnet_get_endpoint((struct rmnet_port *)port, mux_id); |
| if (ep) |
| return ep->egress_dev; |
| } |
| |
| return NULL; |
| } |
| EXPORT_SYMBOL(rmnet_get_rmnet_dev); |
| |
| void rmnet_reset_qmi_pt(void *port) |
| { |
| if (port) |
| ((struct rmnet_port *)port)->qmi_info = NULL; |
| } |
| EXPORT_SYMBOL(rmnet_reset_qmi_pt); |
| |
| void rmnet_init_qmi_pt(void *port, void *qmi) |
| { |
| if (port) |
| ((struct rmnet_port *)port)->qmi_info = qmi; |
| } |
| EXPORT_SYMBOL(rmnet_init_qmi_pt); |
| |
| void rmnet_get_packets(void *port, u64 *rx, u64 *tx) |
| { |
| struct rmnet_priv *priv; |
| struct rmnet_pcpu_stats *ps; |
| unsigned int cpu, start; |
| |
| struct rmnet_endpoint *ep; |
| unsigned long bkt; |
| |
| if (!port || !tx || !rx) |
| return; |
| |
| *tx = 0; |
| *rx = 0; |
| rcu_read_lock(); |
| hash_for_each(((struct rmnet_port *)port)->muxed_ep, bkt, ep, hlnode) { |
| priv = netdev_priv(ep->egress_dev); |
| for_each_possible_cpu(cpu) { |
| ps = per_cpu_ptr(priv->pcpu_stats, cpu); |
| do { |
| start = u64_stats_fetch_begin_irq(&ps->syncp); |
| *tx += ps->stats.tx_pkts; |
| *rx += ps->stats.rx_pkts; |
| } while (u64_stats_fetch_retry_irq(&ps->syncp, start)); |
| } |
| } |
| rcu_read_unlock(); |
| } |
| EXPORT_SYMBOL(rmnet_get_packets); |
| |
| void rmnet_set_powersave_format(void *port) |
| { |
| if (!port) |
| return; |
| ((struct rmnet_port *)port)->data_format |= RMNET_INGRESS_FORMAT_PS; |
| } |
| EXPORT_SYMBOL(rmnet_set_powersave_format); |
| |
| void rmnet_clear_powersave_format(void *port) |
| { |
| if (!port) |
| return; |
| ((struct rmnet_port *)port)->data_format &= ~RMNET_INGRESS_FORMAT_PS; |
| } |
| EXPORT_SYMBOL(rmnet_clear_powersave_format); |
| |
| void rmnet_enable_all_flows(void *port) |
| { |
| struct rmnet_endpoint *ep; |
| unsigned long bkt; |
| |
| if (unlikely(!port)) |
| return; |
| |
| rcu_read_lock(); |
| hash_for_each_rcu(((struct rmnet_port *)port)->muxed_ep, |
| bkt, ep, hlnode) { |
| qmi_rmnet_enable_all_flows(ep->egress_dev); |
| } |
| rcu_read_unlock(); |
| } |
| EXPORT_SYMBOL(rmnet_enable_all_flows); |
| |
| bool rmnet_all_flows_enabled(void *port) |
| { |
| struct rmnet_endpoint *ep; |
| unsigned long bkt; |
| bool ret = true; |
| |
| if (unlikely(!port)) |
| return true; |
| |
| rcu_read_lock(); |
| hash_for_each_rcu(((struct rmnet_port *)port)->muxed_ep, |
| bkt, ep, hlnode) { |
| if (!qmi_rmnet_all_flows_enabled(ep->egress_dev)) { |
| ret = false; |
| goto out; |
| } |
| } |
| out: |
| rcu_read_unlock(); |
| |
| return ret; |
| } |
| EXPORT_SYMBOL(rmnet_all_flows_enabled); |
| |
| int rmnet_get_powersave_notif(void *port) |
| { |
| if (!port) |
| return 0; |
| return ((struct rmnet_port *)port)->data_format & RMNET_FORMAT_PS_NOTIF; |
| } |
| EXPORT_SYMBOL(rmnet_get_powersave_notif); |
| |
| struct net_device *rmnet_get_real_dev(void *port) |
| { |
| if (port) |
| return ((struct rmnet_port *)port)->dev; |
| |
| return NULL; |
| } |
| EXPORT_SYMBOL(rmnet_get_real_dev); |
| |
| int rmnet_get_dlmarker_info(void *port) |
| { |
| if (!port) |
| return 0; |
| |
| return ((struct rmnet_port *)port)->data_format & |
| (RMNET_INGRESS_FORMAT_DL_MARKER_V1 | |
| RMNET_INGRESS_FORMAT_DL_MARKER_V2); |
| } |
| EXPORT_SYMBOL(rmnet_get_dlmarker_info); |
| |
| /* Startup/Shutdown */ |
| |
| static int __init rmnet_init(void) |
| { |
| int rc; |
| |
| rc = register_netdevice_notifier(&rmnet_dev_notifier); |
| if (rc != 0) |
| return rc; |
| |
| rc = rtnl_link_register(&rmnet_link_ops); |
| if (rc != 0) { |
| unregister_netdevice_notifier(&rmnet_dev_notifier); |
| return rc; |
| } |
| |
| rmnet_core_genl_init(); |
| return rc; |
| } |
| |
| static void __exit rmnet_exit(void) |
| { |
| unregister_netdevice_notifier(&rmnet_dev_notifier); |
| rtnl_link_unregister(&rmnet_link_ops); |
| rmnet_core_genl_deinit(); |
| } |
| |
| module_init(rmnet_init) |
| module_exit(rmnet_exit) |
| MODULE_LICENSE("GPL v2"); |