[mirror_ubuntu-zesty-kernel.git] / net / rose / rose_dev.c

/*
 * 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.
 *
 * Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
 */
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/sysctl.h>
#include <linux/string.h>
#include <linux/socket.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/in.h>
#include <linux/if_ether.h>
#include <linux/slab.h>

#include <asm/io.h>

#include <linux/inet.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/if_arp.h>
#include <linux/skbuff.h>

#include <net/ip.h>
#include <net/arp.h>

#include <net/ax25.h>
#include <net/rose.h>

static int rose_header(struct sk_buff *skb, struct net_device *dev,
		       unsigned short type,
		       const void *daddr, const void *saddr, unsigned int len)
{
	unsigned char *buff = skb_push(skb, ROSE_MIN_LEN + 2);

	if (daddr)
		memcpy(buff + 7, daddr, dev->addr_len);

	*buff++ = ROSE_GFI | ROSE_Q_BIT;
	*buff++ = 0x00;
	*buff++ = ROSE_DATA;
	*buff++ = 0x7F;
	*buff++ = AX25_P_IP;

	if (daddr != NULL)
		return 37;

	return -37;
}

static int rose_set_mac_address(struct net_device *dev, void *addr)
{
	struct sockaddr *sa = addr;
	int err;

	if (!memcmp(dev->dev_addr, sa->sa_data, dev->addr_len))
		return 0;

	if (dev->flags & IFF_UP) {
		err = rose_add_loopback_node((rose_address *)sa->sa_data);
		if (err)
			return err;

		rose_del_loopback_node((rose_address *)dev->dev_addr);
	}

	memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);

	return 0;
}

static int rose_open(struct net_device *dev)
{
	int err;

	err = rose_add_loopback_node((rose_address *)dev->dev_addr);
	if (err)
		return err;

	netif_start_queue(dev);

	return 0;
}

static int rose_close(struct net_device *dev)
{
	netif_stop_queue(dev);
	rose_del_loopback_node((rose_address *)dev->dev_addr);
	return 0;
}

static netdev_tx_t rose_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct net_device_stats *stats = &dev->stats;
	unsigned int len = skb->len;

	if (!netif_running(dev)) {
		printk(KERN_ERR "ROSE: rose_xmit - called when iface is down\n");
		return NETDEV_TX_BUSY;
	}

	if (!rose_route_frame(skb, NULL)) {
		dev_kfree_skb(skb);
		stats->tx_errors++;
		return NETDEV_TX_OK;
	}

	stats->tx_packets++;
	stats->tx_bytes += len;
	return NETDEV_TX_OK;
}

static const struct header_ops rose_header_ops = {
	.create	= rose_header,
};

static const struct net_device_ops rose_netdev_ops = {
	.ndo_open		= rose_open,
	.ndo_stop		= rose_close,
	.ndo_start_xmit		= rose_xmit,
	.ndo_set_mac_address    = rose_set_mac_address,
};

void rose_setup(struct net_device *dev)
{
	dev->mtu		= ROSE_MAX_PACKET_SIZE - 2;
	dev->netdev_ops		= &rose_netdev_ops;

	dev->header_ops		= &rose_header_ops;
	dev->hard_header_len	= AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN;
	dev->addr_len		= ROSE_ADDR_LEN;
	dev->type		= ARPHRD_ROSE;

	/* New-style flags. */
	dev->flags		= IFF_NOARP;
}
Commit	Line	Data
1da177e4 LT	1	/*
	2	* This program is free software; you can redistribute it and/or modify
	3	* it under the terms of the GNU General Public License as published by
	4	* the Free Software Foundation; either version 2 of the License, or
	5	* (at your option) any later version.
	6	*
	7	* Copyright (C) Jonathan Naylor G4KLX (g4klx@g4klx.demon.co.uk)
	8	*/
1da177e4 LT	9	#include <linux/module.h>
	10	#include <linux/proc_fs.h>
	11	#include <linux/kernel.h>
1da177e4 LT	12	#include <linux/interrupt.h>
	13	#include <linux/fs.h>
	14	#include <linux/types.h>
	15	#include <linux/sysctl.h>
	16	#include <linux/string.h>
	17	#include <linux/socket.h>
	18	#include <linux/errno.h>
	19	#include <linux/fcntl.h>
	20	#include <linux/in.h>
	21	#include <linux/if_ether.h>
5a0e3ad6	22	#include <linux/slab.h>
1da177e4	23
1da177e4 LT	24	#include <asm/io.h>
	25
	26	#include <linux/inet.h>
	27	#include <linux/netdevice.h>
	28	#include <linux/etherdevice.h>
	29	#include <linux/if_arp.h>
	30	#include <linux/skbuff.h>
	31
	32	#include <net/ip.h>
	33	#include <net/arp.h>
	34
	35	#include <net/ax25.h>
	36	#include <net/rose.h>
	37
3b04ddde SH	38	static int rose_header(struct sk_buff skb, struct net_device dev,
3b04ddde SH	39	unsigned short type,
95c96174	40	const void daddr, const void saddr, unsigned int len)
1da177e4 LT	41	{
	42	unsigned char *buff = skb_push(skb, ROSE_MIN_LEN + 2);
	43
b753af31 EB	44	if (daddr)
	45	memcpy(buff + 7, daddr, dev->addr_len);
	46
1da177e4 LT	47	*buff++ = ROSE_GFI \| ROSE_Q_BIT;
	48	*buff++ = 0x00;
	49	*buff++ = ROSE_DATA;
	50	*buff++ = 0x7F;
	51	*buff++ = AX25_P_IP;
	52
	53	if (daddr != NULL)
	54	return 37;
	55
	56	return -37;
	57	}
	58
1da177e4 LT	59	static int rose_set_mac_address(struct net_device dev, void addr)
	60	{
	61	struct sockaddr *sa = addr;
a159aaa3	62	int err;
1da177e4	63
81213b5e	64	if (!memcmp(dev->dev_addr, sa->sa_data, dev->addr_len))
a159aaa3	65	return 0;
1da177e4	66
a159aaa3	67	if (dev->flags & IFF_UP) {
81213b5e	68	err = rose_add_loopback_node((rose_address *)sa->sa_data);
a159aaa3 RB	69	if (err)
	70	return err;
	71
	72	rose_del_loopback_node((rose_address *)dev->dev_addr);
	73	}
1da177e4	74
a159aaa3	75	memcpy(dev->dev_addr, sa->sa_data, dev->addr_len);
1da177e4 LT	76
	77	return 0;
	78	}
	79
	80	static int rose_open(struct net_device *dev)
	81	{
a159aaa3 RB	82	int err;
	83
	84	err = rose_add_loopback_node((rose_address *)dev->dev_addr);
	85	if (err)
	86	return err;
	87
1da177e4	88	netif_start_queue(dev);
a159aaa3	89
1da177e4 LT	90	return 0;
	91	}
	92
	93	static int rose_close(struct net_device *dev)
	94	{
	95	netif_stop_queue(dev);
	96	rose_del_loopback_node((rose_address *)dev->dev_addr);
	97	return 0;
	98	}
	99
36e4d64a	100	static netdev_tx_t rose_xmit(struct sk_buff skb, struct net_device dev)
1da177e4	101	{
d289d120	102	struct net_device_stats *stats = &dev->stats;
03ec2ac0	103	unsigned int len = skb->len;
1da177e4 LT	104
	105	if (!netif_running(dev)) {
	106	printk(KERN_ERR "ROSE: rose_xmit - called when iface is down\n");
5b548140	107	return NETDEV_TX_BUSY;
1da177e4	108	}
03ec2ac0 EB	109
	110	if (!rose_route_frame(skb, NULL)) {
	111	dev_kfree_skb(skb);
	112	stats->tx_errors++;
	113	return NETDEV_TX_OK;
	114	}
	115
	116	stats->tx_packets++;
	117	stats->tx_bytes += len;
6ed10654	118	return NETDEV_TX_OK;
1da177e4 LT	119	}
1da177e4 LT	120
3b04ddde SH	121	static const struct header_ops rose_header_ops = {
3b04ddde SH	122	.create = rose_header,
3b04ddde SH	123	};
3b04ddde SH	124
3170c656 SH	125	static const struct net_device_ops rose_netdev_ops = {
	126	.ndo_open = rose_open,
	127	.ndo_stop = rose_close,
	128	.ndo_start_xmit = rose_xmit,
	129	.ndo_set_mac_address = rose_set_mac_address,
	130	};
	131
1da177e4 LT	132	void rose_setup(struct net_device *dev)
1da177e4 LT	133	{
1da177e4	134	dev->mtu = ROSE_MAX_PACKET_SIZE - 2;
3170c656	135	dev->netdev_ops = &rose_netdev_ops;
1da177e4	136
3b04ddde	137	dev->header_ops = &rose_header_ops;
1da177e4 LT	138	dev->hard_header_len = AX25_BPQ_HEADER_LEN + AX25_MAX_HEADER_LEN + ROSE_MIN_LEN;
	139	dev->addr_len = ROSE_ADDR_LEN;
	140	dev->type = ARPHRD_ROSE;
1da177e4 LT	141
1da177e4 LT	142	/* New-style flags. */
d2ce4bc3	143	dev->flags = IFF_NOARP;
1da177e4	144	}