/***
|
*
|
* stack/rtdev.c - NIC device driver layer
|
*
|
* Copyright (C) 1999 Lineo, Inc
|
* 1999, 2002 David A. Schleef <ds@schleef.org>
|
* 2002 Ulrich Marx <marx@kammer.uni-hannover.de>
|
* 2003-2005 Jan Kiszka <jan.kiszka@web.de>
|
*
|
* This program is free software; you can redistribute it and/or modify
|
* it under the terms of the GNU General Public License as published by
|
* the Free Software Foundation; either version 2 of the License, or
|
* (at your option) any later version.
|
*
|
* 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.
|
*
|
* You should have received a copy of the GNU General Public License
|
* along with this program; if not, write to the Free Software
|
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
*
|
*/
|
|
#include <linux/spinlock.h>
|
#include <linux/if.h>
|
#include <linux/if_arp.h> /* ARPHRD_ETHER */
|
#include <linux/netdevice.h>
|
#include <linux/moduleparam.h>
|
|
#include <rtnet_internal.h>
|
#include <rtskb.h>
|
#include <ethernet/eth.h>
|
#include <rtmac/rtmac_disc.h>
|
#include <rtnet_port.h>
|
|
static unsigned int device_rtskbs = DEFAULT_DEVICE_RTSKBS;
|
module_param(device_rtskbs, uint, 0444);
|
MODULE_PARM_DESC(device_rtskbs, "Number of additional global realtime socket "
|
"buffers per network adapter");
|
|
struct rtnet_device *rtnet_devices[MAX_RT_DEVICES];
|
static struct rtnet_device *loopback_device;
|
static DEFINE_RTDM_LOCK(rtnet_devices_rt_lock);
|
static LIST_HEAD(rtskb_mapped_list);
|
static LIST_HEAD(rtskb_mapwait_list);
|
|
LIST_HEAD(event_hook_list);
|
DEFINE_MUTEX(rtnet_devices_nrt_lock);
|
|
static int rtdev_locked_xmit(struct rtskb *skb, struct rtnet_device *rtdev);
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(4, 19, 0)
|
#define atomic_fetch_add_unless __atomic_add_unless
|
#endif
|
|
int rtdev_reference(struct rtnet_device *rtdev)
|
{
|
smp_mb__before_atomic();
|
if (rtdev->rt_owner &&
|
atomic_fetch_add_unless(&rtdev->refcount, 1, 0) == 0) {
|
if (!try_module_get(rtdev->rt_owner))
|
return 0;
|
if (atomic_inc_return(&rtdev->refcount) != 1)
|
module_put(rtdev->rt_owner);
|
}
|
return 1;
|
}
|
EXPORT_SYMBOL_GPL(rtdev_reference);
|
|
struct rtskb *rtnetdev_alloc_rtskb(struct rtnet_device *rtdev,
|
unsigned int size)
|
{
|
struct rtskb *rtskb = alloc_rtskb(size, &rtdev->dev_pool);
|
if (rtskb)
|
rtskb->rtdev = rtdev;
|
return rtskb;
|
}
|
EXPORT_SYMBOL_GPL(rtnetdev_alloc_rtskb);
|
|
/***
|
* __rtdev_get_by_name - find a rtnet_device by its name
|
* @name: name to find
|
* @note: caller must hold rtnet_devices_nrt_lock
|
*/
|
static struct rtnet_device *__rtdev_get_by_name(const char *name)
|
{
|
int i;
|
struct rtnet_device *rtdev;
|
|
for (i = 0; i < MAX_RT_DEVICES; i++) {
|
rtdev = rtnet_devices[i];
|
if ((rtdev != NULL) &&
|
(strncmp(rtdev->name, name, IFNAMSIZ) == 0))
|
return rtdev;
|
}
|
return NULL;
|
}
|
|
/***
|
* rtdev_get_by_name - find and lock a rtnet_device by its name
|
* @name: name to find
|
*/
|
struct rtnet_device *rtdev_get_by_name(const char *name)
|
{
|
struct rtnet_device *rtdev;
|
rtdm_lockctx_t context;
|
|
rtdm_lock_get_irqsave(&rtnet_devices_rt_lock, context);
|
|
rtdev = __rtdev_get_by_name(name);
|
if (rtdev != NULL && !rtdev_reference(rtdev))
|
rtdev = NULL;
|
|
rtdm_lock_put_irqrestore(&rtnet_devices_rt_lock, context);
|
|
return rtdev;
|
}
|
|
/***
|
* rtdev_get_by_index - find and lock a rtnet_device by its ifindex
|
* @ifindex: index of device
|
*/
|
struct rtnet_device *rtdev_get_by_index(int ifindex)
|
{
|
struct rtnet_device *rtdev;
|
rtdm_lockctx_t context;
|
|
if ((ifindex <= 0) || (ifindex > MAX_RT_DEVICES))
|
return NULL;
|
|
rtdm_lock_get_irqsave(&rtnet_devices_rt_lock, context);
|
|
rtdev = __rtdev_get_by_index(ifindex);
|
if (rtdev != NULL && !rtdev_reference(rtdev))
|
rtdev = NULL;
|
|
rtdm_lock_put_irqrestore(&rtnet_devices_rt_lock, context);
|
|
return rtdev;
|
}
|
|
/***
|
* __rtdev_get_by_hwaddr - find a rtnetdevice by its mac-address
|
* @type: Type of the net_device (may be ARPHRD_ETHER)
|
* @hw_addr: MAC-Address
|
*/
|
static inline struct rtnet_device *__rtdev_get_by_hwaddr(unsigned short type,
|
char *hw_addr)
|
{
|
int i;
|
struct rtnet_device *rtdev;
|
|
for (i = 0; i < MAX_RT_DEVICES; i++) {
|
rtdev = rtnet_devices[i];
|
if ((rtdev != NULL) && (rtdev->type == type) &&
|
(!memcmp(rtdev->dev_addr, hw_addr, rtdev->addr_len))) {
|
return rtdev;
|
}
|
}
|
return NULL;
|
}
|
|
/***
|
* rtdev_get_by_hwaddr - find and lock a rtnetdevice by its mac-address
|
* @type: Type of the net_device (may be ARPHRD_ETHER)
|
* @hw_addr: MAC-Address
|
*/
|
struct rtnet_device *rtdev_get_by_hwaddr(unsigned short type, char *hw_addr)
|
{
|
struct rtnet_device *rtdev;
|
rtdm_lockctx_t context;
|
|
rtdm_lock_get_irqsave(&rtnet_devices_rt_lock, context);
|
|
rtdev = __rtdev_get_by_hwaddr(type, hw_addr);
|
if (rtdev != NULL && !rtdev_reference(rtdev))
|
rtdev = NULL;
|
|
rtdm_lock_put_irqrestore(&rtnet_devices_rt_lock, context);
|
|
return rtdev;
|
}
|
|
/***
|
* rtdev_get_by_hwaddr - find and lock the loopback device if available
|
*/
|
struct rtnet_device *rtdev_get_loopback(void)
|
{
|
struct rtnet_device *rtdev;
|
rtdm_lockctx_t context;
|
|
rtdm_lock_get_irqsave(&rtnet_devices_rt_lock, context);
|
|
rtdev = loopback_device;
|
if (rtdev != NULL && !rtdev_reference(rtdev))
|
rtdev = NULL;
|
|
rtdm_lock_put_irqrestore(&rtnet_devices_rt_lock, context);
|
|
return rtdev;
|
}
|
|
/***
|
* rtdev_alloc_name - allocate a name for the rtnet_device
|
* @rtdev: the rtnet_device
|
* @name_mask: a name mask (e.g. "rteth%d" for ethernet)
|
*
|
* This function have to be called from the driver probe function.
|
*/
|
void rtdev_alloc_name(struct rtnet_device *rtdev, const char *mask)
|
{
|
char buf[IFNAMSIZ];
|
int i;
|
struct rtnet_device *tmp;
|
|
for (i = 0; i < MAX_RT_DEVICES; i++) {
|
snprintf(buf, IFNAMSIZ, mask, i);
|
if ((tmp = rtdev_get_by_name(buf)) == NULL) {
|
strncpy(rtdev->name, buf, IFNAMSIZ);
|
break;
|
} else
|
rtdev_dereference(tmp);
|
}
|
}
|
|
static int rtdev_pool_trylock(void *cookie)
|
{
|
return rtdev_reference(cookie);
|
}
|
|
static void rtdev_pool_unlock(void *cookie)
|
{
|
rtdev_dereference(cookie);
|
}
|
|
static const struct rtskb_pool_lock_ops rtdev_ops = {
|
.trylock = rtdev_pool_trylock,
|
.unlock = rtdev_pool_unlock,
|
};
|
|
int rtdev_init(struct rtnet_device *rtdev, unsigned dev_pool_size)
|
{
|
int ret;
|
|
ret = rtskb_pool_init(&rtdev->dev_pool, dev_pool_size, &rtdev_ops,
|
rtdev);
|
if (ret < dev_pool_size) {
|
printk(KERN_ERR "RTnet: cannot allocate rtnet device pool\n");
|
rtskb_pool_release(&rtdev->dev_pool);
|
return -ENOMEM;
|
}
|
|
rtdm_mutex_init(&rtdev->xmit_mutex);
|
rtdm_lock_init(&rtdev->rtdev_lock);
|
mutex_init(&rtdev->nrt_lock);
|
|
atomic_set(&rtdev->refcount, 0);
|
|
/* scale global rtskb pool */
|
rtdev->add_rtskbs = rtskb_pool_extend(&global_pool, device_rtskbs);
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(rtdev_init);
|
|
void rtdev_destroy(struct rtnet_device *rtdev)
|
{
|
rtskb_pool_release(&rtdev->dev_pool);
|
rtskb_pool_shrink(&global_pool, rtdev->add_rtskbs);
|
rtdev->stack_event = NULL;
|
rtdm_mutex_destroy(&rtdev->xmit_mutex);
|
}
|
EXPORT_SYMBOL_GPL(rtdev_destroy);
|
|
/***
|
* rtdev_alloc
|
* @int sizeof_priv:
|
*
|
* allocate memory for a new rt-network-adapter
|
*/
|
struct rtnet_device *rtdev_alloc(unsigned sizeof_priv, unsigned dev_pool_size)
|
{
|
struct rtnet_device *rtdev;
|
unsigned alloc_size;
|
int ret;
|
|
/* ensure 32-byte alignment of the private area */
|
alloc_size = sizeof(*rtdev) + sizeof_priv + 31;
|
|
rtdev = kzalloc(alloc_size, GFP_KERNEL);
|
if (rtdev == NULL) {
|
printk(KERN_ERR "RTnet: cannot allocate rtnet device\n");
|
return NULL;
|
}
|
|
ret = rtdev_init(rtdev, dev_pool_size);
|
if (ret) {
|
kfree(rtdev);
|
return NULL;
|
}
|
|
if (sizeof_priv)
|
rtdev->priv = (void *)(((long)(rtdev + 1) + 31) & ~31);
|
|
return rtdev;
|
}
|
|
/***
|
* rtdev_free
|
*/
|
void rtdev_free(struct rtnet_device *rtdev)
|
{
|
if (rtdev != NULL) {
|
rtdev_destroy(rtdev);
|
kfree(rtdev);
|
}
|
}
|
EXPORT_SYMBOL_GPL(rtdev_free);
|
|
static void init_etherdev(struct rtnet_device *rtdev, struct module *module)
|
{
|
rtdev->hard_header = rt_eth_header;
|
rtdev->type = ARPHRD_ETHER;
|
rtdev->hard_header_len = ETH_HLEN;
|
rtdev->mtu = 1500; /* eth_mtu */
|
rtdev->addr_len = ETH_ALEN;
|
rtdev->flags = IFF_BROADCAST; /* TODO: IFF_MULTICAST; */
|
rtdev->get_mtu = rt_hard_mtu;
|
rtdev->rt_owner = module;
|
|
memset(rtdev->broadcast, 0xFF, ETH_ALEN);
|
strcpy(rtdev->name, "rteth%d");
|
}
|
|
/**
|
* rt_init_etherdev - sets up an ethernet device
|
* @module: module initializing the device
|
*
|
* Fill in the fields of the device structure with ethernet-generic
|
* values. This routine can be used to set up a pre-allocated device
|
* structure. The device still needs to be registered afterwards.
|
*/
|
int __rt_init_etherdev(struct rtnet_device *rtdev, unsigned dev_pool_size,
|
struct module *module)
|
{
|
int ret;
|
|
ret = rtdev_init(rtdev, dev_pool_size);
|
if (ret)
|
return ret;
|
|
init_etherdev(rtdev, module);
|
|
return 0;
|
}
|
EXPORT_SYMBOL_GPL(__rt_init_etherdev);
|
|
/**
|
* rt_alloc_etherdev - Allocates and sets up an ethernet device
|
* @sizeof_priv: size of additional driver-private structure to
|
* be allocated for this ethernet device
|
* @dev_pool_size: size of the rx pool
|
* @module: module creating the device
|
*
|
* Allocates then fills in the fields of a new device structure with
|
* ethernet-generic values. Basically does everything except
|
* registering the device.
|
*
|
* A 32-byte alignment is enforced for the private data area.
|
*/
|
struct rtnet_device *__rt_alloc_etherdev(unsigned sizeof_priv,
|
unsigned dev_pool_size,
|
struct module *module)
|
{
|
struct rtnet_device *rtdev;
|
|
rtdev = rtdev_alloc(sizeof_priv, dev_pool_size);
|
if (!rtdev)
|
return NULL;
|
|
init_etherdev(rtdev, module);
|
|
return rtdev;
|
}
|
EXPORT_SYMBOL_GPL(__rt_alloc_etherdev);
|
|
static inline int __rtdev_new_index(void)
|
{
|
int i;
|
|
for (i = 0; i < MAX_RT_DEVICES; i++)
|
if (rtnet_devices[i] == NULL)
|
return i + 1;
|
|
return -ENOMEM;
|
}
|
|
static int rtskb_map(struct rtnet_device *rtdev, struct rtskb *skb)
|
{
|
dma_addr_t addr;
|
|
addr = rtdev->map_rtskb(rtdev, skb);
|
|
if (WARN_ON(addr == RTSKB_UNMAPPED))
|
return -ENOMEM;
|
|
if (skb->buf_dma_addr != RTSKB_UNMAPPED && addr != skb->buf_dma_addr) {
|
printk("RTnet: device %s maps skb differently than others. "
|
"Different IOMMU domain?\nThis is not supported.\n",
|
rtdev->name);
|
return -EACCES;
|
}
|
|
skb->buf_dma_addr = addr;
|
|
return 0;
|
}
|
|
int rtdev_map_rtskb(struct rtskb *skb)
|
{
|
struct rtnet_device *rtdev;
|
int err = 0;
|
int i;
|
|
skb->buf_dma_addr = RTSKB_UNMAPPED;
|
|
mutex_lock(&rtnet_devices_nrt_lock);
|
|
for (i = 0; i < MAX_RT_DEVICES; i++) {
|
rtdev = rtnet_devices[i];
|
if (rtdev && rtdev->map_rtskb) {
|
err = rtskb_map(rtdev, skb);
|
if (err)
|
break;
|
}
|
}
|
|
if (!err) {
|
if (skb->buf_dma_addr != RTSKB_UNMAPPED)
|
list_add(&skb->entry, &rtskb_mapped_list);
|
else
|
list_add(&skb->entry, &rtskb_mapwait_list);
|
}
|
|
mutex_unlock(&rtnet_devices_nrt_lock);
|
|
return err;
|
}
|
|
static int rtdev_map_all_rtskbs(struct rtnet_device *rtdev)
|
{
|
struct rtskb *skb, *n;
|
int err = 0;
|
|
if (!rtdev->map_rtskb)
|
return 0;
|
|
list_for_each_entry (skb, &rtskb_mapped_list, entry) {
|
err = rtskb_map(rtdev, skb);
|
if (err)
|
break;
|
}
|
|
list_for_each_entry_safe (skb, n, &rtskb_mapwait_list, entry) {
|
err = rtskb_map(rtdev, skb);
|
if (err)
|
break;
|
list_del(&skb->entry);
|
list_add(&skb->entry, &rtskb_mapped_list);
|
}
|
|
return err;
|
}
|
|
void rtdev_unmap_rtskb(struct rtskb *skb)
|
{
|
struct rtnet_device *rtdev;
|
int i;
|
|
mutex_lock(&rtnet_devices_nrt_lock);
|
|
list_del(&skb->entry);
|
|
if (skb->buf_dma_addr != RTSKB_UNMAPPED) {
|
for (i = 0; i < MAX_RT_DEVICES; i++) {
|
rtdev = rtnet_devices[i];
|
if (rtdev && rtdev->unmap_rtskb) {
|
rtdev->unmap_rtskb(rtdev, skb);
|
}
|
}
|
}
|
|
skb->buf_dma_addr = RTSKB_UNMAPPED;
|
|
mutex_unlock(&rtnet_devices_nrt_lock);
|
}
|
|
static void rtdev_unmap_all_rtskbs(struct rtnet_device *rtdev)
|
{
|
struct rtskb *skb;
|
|
if (!rtdev->unmap_rtskb)
|
return;
|
|
list_for_each_entry (skb, &rtskb_mapped_list, entry) {
|
rtdev->unmap_rtskb(rtdev, skb);
|
}
|
}
|
|
/***
|
* rt_register_rtnetdev: register a new rtnet_device (linux-like)
|
* @rtdev: the device
|
*/
|
int rt_register_rtnetdev(struct rtnet_device *rtdev)
|
{
|
struct list_head *entry;
|
struct rtdev_event_hook *hook;
|
rtdm_lockctx_t context;
|
int ifindex;
|
int err;
|
|
/* requires at least driver layer version 2.0 */
|
if (rtdev->vers < RTDEV_VERS_2_0)
|
return -EINVAL;
|
|
if (rtdev->features & NETIF_F_LLTX)
|
rtdev->start_xmit = rtdev->hard_start_xmit;
|
else
|
rtdev->start_xmit = rtdev_locked_xmit;
|
|
mutex_lock(&rtnet_devices_nrt_lock);
|
|
ifindex = __rtdev_new_index();
|
if (ifindex < 0) {
|
err = ifindex;
|
goto fail;
|
}
|
rtdev->ifindex = ifindex;
|
|
if (strchr(rtdev->name, '%') != NULL)
|
rtdev_alloc_name(rtdev, rtdev->name);
|
|
if (__rtdev_get_by_name(rtdev->name) != NULL) {
|
err = -EEXIST;
|
goto fail;
|
}
|
|
rtdev->sysdev =
|
device_create(rtnet_class, NULL, MKDEV(0, rtdev->ifindex),
|
rtdev, rtdev->name);
|
if (IS_ERR(rtdev->sysdev)) {
|
err = PTR_ERR(rtdev->sysdev);
|
goto fail;
|
}
|
|
if (rtdev->sysbind) {
|
err = sysfs_create_link(&rtdev->sysdev->kobj,
|
&rtdev->sysbind->kobj, "adapter");
|
if (err)
|
goto fail_link;
|
}
|
|
err = rtdev_map_all_rtskbs(rtdev);
|
if (err)
|
goto fail_map;
|
|
rtdm_lock_get_irqsave(&rtnet_devices_rt_lock, context);
|
|
if (rtdev->flags & IFF_LOOPBACK) {
|
/* allow only one loopback device */
|
if (loopback_device) {
|
rtdm_lock_put_irqrestore(&rtnet_devices_rt_lock,
|
context);
|
err = -EEXIST;
|
goto fail_loopback;
|
}
|
loopback_device = rtdev;
|
}
|
rtnet_devices[rtdev->ifindex - 1] = rtdev;
|
|
rtdm_lock_put_irqrestore(&rtnet_devices_rt_lock, context);
|
|
list_for_each (entry, &event_hook_list) {
|
hook = list_entry(entry, struct rtdev_event_hook, entry);
|
if (hook->register_device)
|
hook->register_device(rtdev);
|
}
|
|
mutex_unlock(&rtnet_devices_nrt_lock);
|
|
/* Default state at registration is that the device is present. */
|
set_bit(__RTNET_LINK_STATE_PRESENT, &rtdev->link_state);
|
|
printk("RTnet: registered %s\n", rtdev->name);
|
|
return 0;
|
|
fail_loopback:
|
rtdev_unmap_all_rtskbs(rtdev);
|
fail_map:
|
if (rtdev->sysbind)
|
sysfs_remove_link(&rtdev->sysdev->kobj, "adapter");
|
fail_link:
|
device_destroy(rtnet_class, MKDEV(0, rtdev->ifindex));
|
fail:
|
mutex_unlock(&rtnet_devices_nrt_lock);
|
|
return err;
|
}
|
|
/***
|
* rt_unregister_rtnetdev: unregister a rtnet_device
|
* @rtdev: the device
|
*/
|
int rt_unregister_rtnetdev(struct rtnet_device *rtdev)
|
{
|
struct list_head *entry;
|
struct rtdev_event_hook *hook;
|
rtdm_lockctx_t context;
|
|
RTNET_ASSERT(rtdev->ifindex != 0,
|
printk("RTnet: device %s/%p was not registered\n",
|
rtdev->name, rtdev);
|
return -ENODEV;);
|
|
if (rtdev->sysbind)
|
sysfs_remove_link(&rtdev->sysdev->kobj, "adapter");
|
|
device_destroy(rtnet_class, MKDEV(0, rtdev->ifindex));
|
|
mutex_lock(&rtnet_devices_nrt_lock);
|
rtdm_lock_get_irqsave(&rtnet_devices_rt_lock, context);
|
|
RTNET_ASSERT(atomic_read(&rtdev->refcount == 0), BUG());
|
rtnet_devices[rtdev->ifindex - 1] = NULL;
|
if (rtdev->flags & IFF_LOOPBACK)
|
loopback_device = NULL;
|
|
rtdm_lock_put_irqrestore(&rtnet_devices_rt_lock, context);
|
|
list_for_each (entry, &event_hook_list) {
|
hook = list_entry(entry, struct rtdev_event_hook, entry);
|
if (hook->unregister_device)
|
hook->unregister_device(rtdev);
|
}
|
|
rtdev_unmap_all_rtskbs(rtdev);
|
|
mutex_unlock(&rtnet_devices_nrt_lock);
|
|
clear_bit(__RTNET_LINK_STATE_PRESENT, &rtdev->link_state);
|
|
RTNET_ASSERT(atomic_read(&rtdev->refcount) == 0,
|
printk("RTnet: rtdev reference counter < 0!\n"););
|
|
printk("RTnet: unregistered %s\n", rtdev->name);
|
|
return 0;
|
}
|
|
void rtdev_add_event_hook(struct rtdev_event_hook *hook)
|
{
|
mutex_lock(&rtnet_devices_nrt_lock);
|
list_add(&hook->entry, &event_hook_list);
|
mutex_unlock(&rtnet_devices_nrt_lock);
|
}
|
|
void rtdev_del_event_hook(struct rtdev_event_hook *hook)
|
{
|
mutex_lock(&rtnet_devices_nrt_lock);
|
list_del(&hook->entry);
|
mutex_unlock(&rtnet_devices_nrt_lock);
|
}
|
|
int rtdev_up(struct rtnet_device *rtdev, struct rtnet_core_cmd *cmd)
|
{
|
struct list_head *entry;
|
struct rtdev_event_hook *hook;
|
int ret = 0;
|
|
if (mutex_lock_interruptible(&rtdev->nrt_lock))
|
return -ERESTARTSYS;
|
|
/* We cannot change the promisc flag or the hardware address if
|
the device is already up. */
|
if ((rtdev->flags & IFF_UP) &&
|
(((cmd->args.up.set_dev_flags | cmd->args.up.clear_dev_flags) &
|
IFF_PROMISC) ||
|
(cmd->args.up.dev_addr_type != ARPHRD_VOID))) {
|
ret = -EBUSY;
|
goto out;
|
}
|
|
if (cmd->args.up.dev_addr_type != ARPHRD_VOID &&
|
cmd->args.up.dev_addr_type != rtdev->type) {
|
ret = -EINVAL;
|
goto out;
|
}
|
|
/* Skip upon extraneous call only after args have been checked. */
|
if (test_and_set_bit(PRIV_FLAG_UP, &rtdev->priv_flags))
|
goto out;
|
|
rtdev->flags |= cmd->args.up.set_dev_flags;
|
rtdev->flags &= ~cmd->args.up.clear_dev_flags;
|
|
if (cmd->args.up.dev_addr_type != ARPHRD_VOID)
|
memcpy(rtdev->dev_addr, cmd->args.up.dev_addr, MAX_ADDR_LEN);
|
|
ret = rtdev_open(rtdev); /* also == 0 if rtdev is already up */
|
|
if (ret == 0) {
|
mutex_lock(&rtnet_devices_nrt_lock);
|
|
list_for_each (entry, &event_hook_list) {
|
hook = list_entry(entry, struct rtdev_event_hook,
|
entry);
|
if (hook->ifup)
|
hook->ifup(rtdev, cmd);
|
}
|
|
mutex_unlock(&rtnet_devices_nrt_lock);
|
} else
|
clear_bit(PRIV_FLAG_UP, &rtdev->priv_flags);
|
out:
|
mutex_unlock(&rtdev->nrt_lock);
|
|
return ret;
|
}
|
EXPORT_SYMBOL_GPL(rtdev_up);
|
|
int rtdev_down(struct rtnet_device *rtdev)
|
{
|
struct list_head *entry;
|
struct rtdev_event_hook *hook;
|
rtdm_lockctx_t context;
|
int ret = 0;
|
|
if (mutex_lock_interruptible(&rtdev->nrt_lock))
|
return -ERESTARTSYS;
|
|
/* spin lock required for sync with routing code */
|
rtdm_lock_get_irqsave(&rtdev->rtdev_lock, context);
|
|
if (test_bit(PRIV_FLAG_ADDING_ROUTE, &rtdev->priv_flags)) {
|
ret = -EBUSY;
|
goto fail;
|
}
|
|
if (!test_and_clear_bit(PRIV_FLAG_UP, &rtdev->priv_flags))
|
goto fail;
|
|
rtdm_lock_put_irqrestore(&rtdev->rtdev_lock, context);
|
|
if (rtdev->mac_detach != NULL)
|
ret = rtdev->mac_detach(rtdev);
|
|
if (ret == 0) {
|
mutex_lock(&rtnet_devices_nrt_lock);
|
|
list_for_each (entry, &event_hook_list) {
|
hook = list_entry(entry, struct rtdev_event_hook,
|
entry);
|
if (hook->ifdown)
|
hook->ifdown(rtdev);
|
}
|
|
mutex_unlock(&rtnet_devices_nrt_lock);
|
|
ret = rtdev_close(rtdev);
|
}
|
out:
|
mutex_unlock(&rtdev->nrt_lock);
|
|
return ret;
|
fail:
|
rtdm_lock_put_irqrestore(&rtdev->rtdev_lock, context);
|
goto out;
|
}
|
EXPORT_SYMBOL_GPL(rtdev_down);
|
|
/***
|
* rtdev_open
|
*
|
* Prepare an interface for use.
|
*/
|
int rtdev_open(struct rtnet_device *rtdev)
|
{
|
int ret = 0;
|
|
if (rtdev->flags & IFF_UP) /* Is it already up? */
|
return 0;
|
|
if (!rtdev_reference(rtdev))
|
return -EIDRM;
|
|
if (rtdev->open) /* Call device private open method */
|
ret = rtdev->open(rtdev);
|
|
if (!ret) {
|
rtdev->flags |= IFF_UP;
|
set_bit(__RTNET_LINK_STATE_START, &rtdev->link_state);
|
} else
|
rtdev_dereference(rtdev);
|
|
return ret;
|
}
|
|
/***
|
* rtdev_close
|
*/
|
int rtdev_close(struct rtnet_device *rtdev)
|
{
|
int ret = 0;
|
|
if (!(rtdev->flags & IFF_UP))
|
return 0;
|
|
if (rtdev->stop)
|
ret = rtdev->stop(rtdev);
|
|
rtdev->flags &= ~(IFF_UP | IFF_RUNNING);
|
clear_bit(__RTNET_LINK_STATE_START, &rtdev->link_state);
|
|
if (ret == 0)
|
rtdev_dereference(rtdev);
|
|
return ret;
|
}
|
|
static int rtdev_locked_xmit(struct rtskb *skb, struct rtnet_device *rtdev)
|
{
|
int ret;
|
|
rtdm_mutex_lock(&rtdev->xmit_mutex);
|
ret = rtdev->hard_start_xmit(skb, rtdev);
|
rtdm_mutex_unlock(&rtdev->xmit_mutex);
|
|
return ret;
|
}
|
|
/***
|
* rtdev_xmit - send real-time packet
|
*/
|
int rtdev_xmit(struct rtskb *rtskb)
|
{
|
struct rtnet_device *rtdev;
|
int err;
|
|
RTNET_ASSERT(rtskb != NULL, return -EINVAL;);
|
|
rtdev = rtskb->rtdev;
|
|
if (!rtnetif_carrier_ok(rtdev)) {
|
err = -EAGAIN;
|
kfree_rtskb(rtskb);
|
return err;
|
}
|
|
if (rtskb_acquire(rtskb, &rtdev->dev_pool) != 0) {
|
err = -ENOBUFS;
|
kfree_rtskb(rtskb);
|
return err;
|
}
|
|
RTNET_ASSERT(rtdev != NULL, return -EINVAL;);
|
|
err = rtdev->start_xmit(rtskb, rtdev);
|
if (err) {
|
/* on error we must free the rtskb here */
|
kfree_rtskb(rtskb);
|
|
rtdm_printk("hard_start_xmit returned %d\n", err);
|
}
|
|
return err;
|
}
|
|
#if IS_ENABLED(CONFIG_XENO_DRIVERS_NET_ADDON_PROXY)
|
/***
|
* rtdev_xmit_proxy - send rtproxy packet
|
*/
|
int rtdev_xmit_proxy(struct rtskb *rtskb)
|
{
|
struct rtnet_device *rtdev;
|
int err;
|
|
RTNET_ASSERT(rtskb != NULL, return -EINVAL;);
|
|
rtdev = rtskb->rtdev;
|
|
RTNET_ASSERT(rtdev != NULL, return -EINVAL;);
|
|
/* TODO: make these lines race-condition-safe */
|
if (rtdev->mac_disc) {
|
RTNET_ASSERT(rtdev->mac_disc->nrt_packet_tx != NULL,
|
return -EINVAL;);
|
|
err = rtdev->mac_disc->nrt_packet_tx(rtskb);
|
} else {
|
err = rtdev->start_xmit(rtskb, rtdev);
|
if (err) {
|
/* on error we must free the rtskb here */
|
kfree_rtskb(rtskb);
|
|
rtdm_printk("hard_start_xmit returned %d\n", err);
|
}
|
}
|
|
return err;
|
}
|
#endif /* CONFIG_XENO_DRIVERS_NET_ADDON_PROXY */
|
|
unsigned int rt_hard_mtu(struct rtnet_device *rtdev, unsigned int priority)
|
{
|
return rtdev->mtu;
|
}
|
|
EXPORT_SYMBOL_GPL(rtdev_alloc_name);
|
|
EXPORT_SYMBOL_GPL(rt_register_rtnetdev);
|
EXPORT_SYMBOL_GPL(rt_unregister_rtnetdev);
|
|
EXPORT_SYMBOL_GPL(rtdev_add_event_hook);
|
EXPORT_SYMBOL_GPL(rtdev_del_event_hook);
|
|
EXPORT_SYMBOL_GPL(rtdev_get_by_name);
|
EXPORT_SYMBOL_GPL(rtdev_get_by_index);
|
EXPORT_SYMBOL_GPL(rtdev_get_by_hwaddr);
|
EXPORT_SYMBOL_GPL(rtdev_get_loopback);
|
|
EXPORT_SYMBOL_GPL(rtdev_xmit);
|
|
#if IS_ENABLED(CONFIG_XENO_DRIVERS_NET_ADDON_PROXY)
|
EXPORT_SYMBOL_GPL(rtdev_xmit_proxy);
|
#endif
|
|
EXPORT_SYMBOL_GPL(rt_hard_mtu);
|
