[net-next-2.6.git] / include / linux / etherdevice.h

/*
 * INET		An implementation of the TCP/IP protocol suite for the LINUX
 *		operating system.  NET  is implemented using the  BSD Socket
 *		interface as the means of communication with the user level.
 *
 *		Definitions for the Ethernet handlers.
 *
 * Version:	@(#)eth.h	1.0.4	05/13/93
 *
 * Authors:	Ross Biro
 *		Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 *
 *		Relocated to include/linux where it belongs by Alan Cox 
 *							<gw4pts@gw4pts.ampr.org>
 *
 *		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.
 *
 *	WARNING: This move may well be temporary. This file will get merged with others RSN.
 *
 */
#ifndef _LINUX_ETHERDEVICE_H
#define _LINUX_ETHERDEVICE_H

#include <linux/if_ether.h>
#include <linux/netdevice.h>
#include <linux/random.h>
#include <asm/unaligned.h>

#ifdef __KERNEL__
extern __be16		eth_type_trans(struct sk_buff *skb, struct net_device *dev);
extern const struct header_ops eth_header_ops;

extern int eth_header(struct sk_buff *skb, struct net_device *dev,
		      unsigned short type,
		      const void *daddr, const void *saddr, unsigned len);
extern int eth_rebuild_header(struct sk_buff *skb);
extern int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr);
extern int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh);
extern void eth_header_cache_update(struct hh_cache *hh,
				    const struct net_device *dev,
				    const unsigned char *haddr);
extern int eth_mac_addr(struct net_device *dev, void *p);
extern int eth_change_mtu(struct net_device *dev, int new_mtu);
extern int eth_validate_addr(struct net_device *dev);


extern struct net_device *alloc_etherdev_mq(int sizeof_priv, unsigned int queue_count);
#define alloc_etherdev(sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1)

/**
 * is_zero_ether_addr - Determine if give Ethernet address is all zeros.
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Return true if the address is all zeroes.
 */
static inline int is_zero_ether_addr(const u8 *addr)
{
	return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
}

/**
 * is_multicast_ether_addr - Determine if the Ethernet address is a multicast.
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Return true if the address is a multicast address.
 * By definition the broadcast address is also a multicast address.
 */
static inline int is_multicast_ether_addr(const u8 *addr)
{
	return 0x01 & addr[0];
}

/**
 * is_local_ether_addr - Determine if the Ethernet address is locally-assigned one (IEEE 802).
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Return true if the address is a local address.
 */
static inline int is_local_ether_addr(const u8 *addr)
{
	return 0x02 & addr[0];
}

/**
 * is_broadcast_ether_addr - Determine if the Ethernet address is broadcast
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Return true if the address is the broadcast address.
 */
static inline int is_broadcast_ether_addr(const u8 *addr)
{
	return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) == 0xff;
}

/**
 * is_valid_ether_addr - Determine if the given Ethernet address is valid
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Check that the Ethernet address (MAC) is not 00:00:00:00:00:00, is not
 * a multicast address, and is not FF:FF:FF:FF:FF:FF.
 *
 * Return true if the address is valid.
 */
static inline int is_valid_ether_addr(const u8 *addr)
{
	/* FF:FF:FF:FF:FF:FF is a multicast address so we don't need to
	 * explicitly check for it here. */
	return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr);
}

/**
 * random_ether_addr - Generate software assigned random Ethernet address
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Generate a random Ethernet address (MAC) that is not multicast
 * and has the local assigned bit set.
 */
static inline void random_ether_addr(u8 *addr)
{
	get_random_bytes (addr, ETH_ALEN);
	addr [0] &= 0xfe;	/* clear multicast bit */
	addr [0] |= 0x02;	/* set local assignment bit (IEEE802) */
}

/**
 * dev_hw_addr_random - Create random MAC and set device flag
 * @dev: pointer to net_device structure
 * @hwaddr: Pointer to a six-byte array containing the Ethernet address
 *
 * Generate random MAC to be used by a device and set addr_assign_type
 * so the state can be read by sysfs and be used by udev.
 */
static inline void dev_hw_addr_random(struct net_device *dev, u8 *hwaddr)
{
	dev->addr_assign_type |= NET_ADDR_RANDOM;
	random_ether_addr(hwaddr);
}

/**
 * compare_ether_addr - Compare two Ethernet addresses
 * @addr1: Pointer to a six-byte array containing the Ethernet address
 * @addr2: Pointer other six-byte array containing the Ethernet address
 *
 * Compare two ethernet addresses, returns 0 if equal
 */
static inline unsigned compare_ether_addr(const u8 *addr1, const u8 *addr2)
{
	const u16 *a = (const u16 *) addr1;
	const u16 *b = (const u16 *) addr2;

	BUILD_BUG_ON(ETH_ALEN != 6);
	return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) != 0;
}

static inline unsigned long zap_last_2bytes(unsigned long value)
{
#ifdef __BIG_ENDIAN
	return value >> 16;
#else
	return value << 16;
#endif
}

/**
 * compare_ether_addr_64bits - Compare two Ethernet addresses
 * @addr1: Pointer to an array of 8 bytes
 * @addr2: Pointer to an other array of 8 bytes
 *
 * Compare two ethernet addresses, returns 0 if equal.
 * Same result than "memcmp(addr1, addr2, ETH_ALEN)" but without conditional
 * branches, and possibly long word memory accesses on CPU allowing cheap
 * unaligned memory reads.
 * arrays = { byte1, byte2, byte3, byte4, byte6, byte7, pad1, pad2}
 *
 * Please note that alignment of addr1 & addr2 is only guaranted to be 16 bits.
 */

static inline unsigned compare_ether_addr_64bits(const u8 addr1[6+2],
						 const u8 addr2[6+2])
{
#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
	unsigned long fold = ((*(unsigned long *)addr1) ^
			      (*(unsigned long *)addr2));

	if (sizeof(fold) == 8)
		return zap_last_2bytes(fold) != 0;

	fold |= zap_last_2bytes((*(unsigned long *)(addr1 + 4)) ^
				(*(unsigned long *)(addr2 + 4)));
	return fold != 0;
#else
	return compare_ether_addr(addr1, addr2);
#endif
}

/**
 * is_etherdev_addr - Tell if given Ethernet address belongs to the device.
 * @dev: Pointer to a device structure
 * @addr: Pointer to a six-byte array containing the Ethernet address
 *
 * Compare passed address with all addresses of the device. Return true if the
 * address if one of the device addresses.
 *
 * Note that this function calls compare_ether_addr_64bits() so take care of
 * the right padding.
 */
static inline bool is_etherdev_addr(const struct net_device *dev,
				    const u8 addr[6 + 2])
{
	struct netdev_hw_addr *ha;
	int res = 1;

	rcu_read_lock();
	for_each_dev_addr(dev, ha) {
		res = compare_ether_addr_64bits(addr, ha->addr);
		if (!res)
			break;
	}
	rcu_read_unlock();
	return !res;
}
#endif	/* __KERNEL__ */

/**
 * compare_ether_header - Compare two Ethernet headers
 * @a: Pointer to Ethernet header
 * @b: Pointer to Ethernet header
 *
 * Compare two ethernet headers, returns 0 if equal.
 * This assumes that the network header (i.e., IP header) is 4-byte
 * aligned OR the platform can handle unaligned access.  This is the
 * case for all packets coming into netif_receive_skb or similar
 * entry points.
 */

static inline unsigned long compare_ether_header(const void *a, const void *b)
{
#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
	unsigned long fold;

	/*
	 * We want to compare 14 bytes:
	 *  [a0 ... a13] ^ [b0 ... b13]
	 * Use two long XOR, ORed together, with an overlap of two bytes.
	 *  [a0  a1  a2  a3  a4  a5  a6  a7 ] ^ [b0  b1  b2  b3  b4  b5  b6  b7 ] |
	 *  [a6  a7  a8  a9  a10 a11 a12 a13] ^ [b6  b7  b8  b9  b10 b11 b12 b13]
	 * This means the [a6 a7] ^ [b6 b7] part is done two times.
	*/
	fold = *(unsigned long *)a ^ *(unsigned long *)b;
	fold |= *(unsigned long *)(a + 6) ^ *(unsigned long *)(b + 6);
	return fold;
#else
	u32 *a32 = (u32 *)((u8 *)a + 2);
	u32 *b32 = (u32 *)((u8 *)b + 2);

	return (*(u16 *)a ^ *(u16 *)b) | (a32[0] ^ b32[0]) |
	       (a32[1] ^ b32[1]) | (a32[2] ^ b32[2]);
#endif
}

#endif	/* _LINUX_ETHERDEVICE_H */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* INET An implementation of the TCP/IP protocol suite for the LINUX
	3	* operating system. NET is implemented using the BSD Socket
	4	* interface as the means of communication with the user level.
	5	*
	6	* Definitions for the Ethernet handlers.
	7	*
	8	* Version: @(#)eth.h 1.0.4 05/13/93
	9	*
02c30a84	10	* Authors: Ross Biro
1da177e4 LT	11	* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
	12	*
	13	* Relocated to include/linux where it belongs by Alan Cox
	14	* <gw4pts@gw4pts.ampr.org>
	15	*
	16	* This program is free software; you can redistribute it and/or
	17	* modify it under the terms of the GNU General Public License
	18	* as published by the Free Software Foundation; either version
	19	* 2 of the License, or (at your option) any later version.
	20	*
	21	* WARNING: This move may well be temporary. This file will get merged with others RSN.
	22	*
	23	*/
	24	#ifndef _LINUX_ETHERDEVICE_H
	25	#define _LINUX_ETHERDEVICE_H
	26
	27	#include <linux/if_ether.h>
bcd61272	28	#include <linux/netdevice.h>
1da177e4	29	#include <linux/random.h>
1f87e235	30	#include <asm/unaligned.h>
1da177e4 LT	31
1da177e4 LT	32	#ifdef __KERNEL__
ab611487	33	extern __be16 eth_type_trans(struct sk_buff skb, struct net_device dev);
3b04ddde SH	34	extern const struct header_ops eth_header_ops;
	35
	36	extern int eth_header(struct sk_buff skb, struct net_device dev,
	37	unsigned short type,
	38	const void daddr, const void saddr, unsigned len);
	39	extern int eth_rebuild_header(struct sk_buff *skb);
	40	extern int eth_header_parse(const struct sk_buff skb, unsigned char haddr);
	41	extern int eth_header_cache(const struct neighbour neigh, struct hh_cache hh);
	42	extern void eth_header_cache_update(struct hh_cache *hh,
	43	const struct net_device *dev,
	44	const unsigned char *haddr);
ccad637b SH	45	extern int eth_mac_addr(struct net_device dev, void p);
	46	extern int eth_change_mtu(struct net_device *dev, int new_mtu);
	47	extern int eth_validate_addr(struct net_device *dev);
	48
3b04ddde	49
1da177e4	50
f25f4e44 PWJ	51	extern struct net_device *alloc_etherdev_mq(int sizeof_priv, unsigned int queue_count);
f25f4e44 PWJ	52	#define alloc_etherdev(sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1)
1da177e4 LT	53
1da177e4 LT	54	/**
c2da8aca SH	55	* is_zero_ether_addr - Determine if give Ethernet address is all zeros.
	56	* @addr: Pointer to a six-byte array containing the Ethernet address
	57	*
	58	* Return true if the address is all zeroes.
1da177e4 LT	59	*/
	60	static inline int is_zero_ether_addr(const u8 *addr)
	61	{
	62	return !(addr[0] \| addr[1] \| addr[2] \| addr[3] \| addr[4] \| addr[5]);
	63	}
	64
79165121	65	/**
c2da8aca	66	* is_multicast_ether_addr - Determine if the Ethernet address is a multicast.
79165121 ME	67	* @addr: Pointer to a six-byte array containing the Ethernet address
	68	*
	69	* Return true if the address is a multicast address.
88df8ef5	70	* By definition the broadcast address is also a multicast address.
79165121 ME	71	*/
	72	static inline int is_multicast_ether_addr(const u8 *addr)
	73	{
a02cec21	74	return 0x01 & addr[0];
79165121 ME	75	}
79165121 ME	76
e024715f	77	/**
bc2cda1e	78	* is_local_ether_addr - Determine if the Ethernet address is locally-assigned one (IEEE 802).
e024715f PBG	79	* @addr: Pointer to a six-byte array containing the Ethernet address
	80	*
	81	* Return true if the address is a local address.
	82	*/
	83	static inline int is_local_ether_addr(const u8 *addr)
	84	{
a02cec21	85	return 0x02 & addr[0];
e024715f PBG	86	}
e024715f PBG	87
c2da8aca SH	88	/**
	89	* is_broadcast_ether_addr - Determine if the Ethernet address is broadcast
	90	* @addr: Pointer to a six-byte array containing the Ethernet address
	91	*
	92	* Return true if the address is the broadcast address.
	93	*/
9bd481f8 JG	94	static inline int is_broadcast_ether_addr(const u8 *addr)
9bd481f8 JG	95	{
2407534f	96	return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) == 0xff;
9bd481f8 JG	97	}
9bd481f8 JG	98
1da177e4 LT	99	/**
	100	* is_valid_ether_addr - Determine if the given Ethernet address is valid
	101	* @addr: Pointer to a six-byte array containing the Ethernet address
	102	*
	103	* Check that the Ethernet address (MAC) is not 00:00:00:00:00:00, is not
79165121	104	* a multicast address, and is not FF:FF:FF:FF:FF:FF.
1da177e4 LT	105	*
	106	* Return true if the address is valid.
	107	*/
	108	static inline int is_valid_ether_addr(const u8 *addr)
	109	{
79165121 ME	110	/* FF:FF:FF:FF:FF:FF is a multicast address so we don't need to
	111	* explicitly check for it here. */
	112	return !is_multicast_ether_addr(addr) && !is_zero_ether_addr(addr);
1da177e4 LT	113	}
	114
	115	/**
	116	* random_ether_addr - Generate software assigned random Ethernet address
	117	* @addr: Pointer to a six-byte array containing the Ethernet address
	118	*
	119	* Generate a random Ethernet address (MAC) that is not multicast
	120	* and has the local assigned bit set.
	121	*/
	122	static inline void random_ether_addr(u8 *addr)
	123	{
	124	get_random_bytes (addr, ETH_ALEN);
	125	addr [0] &= 0xfe; /* clear multicast bit */
	126	addr [0] \|= 0x02; /* set local assignment bit (IEEE802) */
	127	}
360ac8e2	128
c1f79426 SA	129	/**
	130	* dev_hw_addr_random - Create random MAC and set device flag
	131	* @dev: pointer to net_device structure
7ed24e8d	132	* @hwaddr: Pointer to a six-byte array containing the Ethernet address
c1f79426 SA	133	*
	134	* Generate random MAC to be used by a device and set addr_assign_type
	135	* so the state can be read by sysfs and be used by udev.
	136	*/
	137	static inline void dev_hw_addr_random(struct net_device dev, u8 hwaddr)
	138	{
	139	dev->addr_assign_type \|= NET_ADDR_RANDOM;
	140	random_ether_addr(hwaddr);
	141	}
	142
360ac8e2 SH	143	/**
	144	* compare_ether_addr - Compare two Ethernet addresses
	145	* @addr1: Pointer to a six-byte array containing the Ethernet address
c2da8aca	146	* @addr2: Pointer other six-byte array containing the Ethernet address
360ac8e2 SH	147	*
	148	* Compare two ethernet addresses, returns 0 if equal
	149	*/
c2da8aca	150	static inline unsigned compare_ether_addr(const u8 addr1, const u8 addr2)
360ac8e2	151	{
c2da8aca SH	152	const u16 a = (const u16 ) addr1;
c2da8aca SH	153	const u16 b = (const u16 ) addr2;
360ac8e2 SH	154
	155	BUILD_BUG_ON(ETH_ALEN != 6);
	156	return ((a[0] ^ b[0]) \| (a[1] ^ b[1]) \| (a[2] ^ b[2])) != 0;
	157	}
1f87e235 ED	158
	159	static inline unsigned long zap_last_2bytes(unsigned long value)
	160	{
	161	#ifdef __BIG_ENDIAN
	162	return value >> 16;
	163	#else
	164	return value << 16;
	165	#endif
	166	}
	167
	168	/**
	169	* compare_ether_addr_64bits - Compare two Ethernet addresses
	170	* @addr1: Pointer to an array of 8 bytes
	171	* @addr2: Pointer to an other array of 8 bytes
	172	*
	173	* Compare two ethernet addresses, returns 0 if equal.
	174	* Same result than "memcmp(addr1, addr2, ETH_ALEN)" but without conditional
	175	* branches, and possibly long word memory accesses on CPU allowing cheap
	176	* unaligned memory reads.
	177	* arrays = { byte1, byte2, byte3, byte4, byte6, byte7, pad1, pad2}
	178	*
	179	* Please note that alignment of addr1 & addr2 is only guaranted to be 16 bits.
	180	*/
	181
	182	static inline unsigned compare_ether_addr_64bits(const u8 addr1[6+2],
	183	const u8 addr2[6+2])
	184	{
	185	#ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
	186	unsigned long fold = (((unsigned long )addr1) ^
	187	((unsigned long )addr2));
	188
	189	if (sizeof(fold) == 8)
	190	return zap_last_2bytes(fold) != 0;
	191
	192	fold \|= zap_last_2bytes(((unsigned long )(addr1 + 4)) ^
	193	((unsigned long )(addr2 + 4)));
	194	return fold != 0;
	195	#else
	196	return compare_ether_addr(addr1, addr2);
	197	#endif
	198	}
f001fde5 JP	199
	200	/**
	201	* is_etherdev_addr - Tell if given Ethernet address belongs to the device.
	202	* @dev: Pointer to a device structure
	203	* @addr: Pointer to a six-byte array containing the Ethernet address
	204	*
	205	* Compare passed address with all addresses of the device. Return true if the
	206	* address if one of the device addresses.
	207	*
	208	* Note that this function calls compare_ether_addr_64bits() so take care of
	209	* the right padding.
	210	*/
	211	static inline bool is_etherdev_addr(const struct net_device *dev,
	212	const u8 addr[6 + 2])
	213	{
	214	struct netdev_hw_addr *ha;
	215	int res = 1;
	216
	217	rcu_read_lock();
	218	for_each_dev_addr(dev, ha) {
	219	res = compare_ether_addr_64bits(addr, ha->addr);
	220	if (!res)
	221	break;
	222	}
	223	rcu_read_unlock();
	224	return !res;
	225	}
79165121	226	#endif /* __KERNEL__ */
1da177e4	227
aa4b9f53 HX	228	/**
	229	* compare_ether_header - Compare two Ethernet headers
	230	* @a: Pointer to Ethernet header
	231	* @b: Pointer to Ethernet header
	232	*
	233	* Compare two ethernet headers, returns 0 if equal.
	234	* This assumes that the network header (i.e., IP header) is 4-byte
	235	* aligned OR the platform can handle unaligned access. This is the
	236	* case for all packets coming into netif_receive_skb or similar
	237	* entry points.
	238	*/
	239
40d0802b	240	static inline unsigned long compare_ether_header(const void a, const void b)
aa4b9f53	241	{
40d0802b ED	242	#if defined(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) && BITS_PER_LONG == 64
	243	unsigned long fold;
	244
	245	/*
	246	* We want to compare 14 bytes:
	247	* [a0 ... a13] ^ [b0 ... b13]
	248	* Use two long XOR, ORed together, with an overlap of two bytes.
	249	* [a0 a1 a2 a3 a4 a5 a6 a7 ] ^ [b0 b1 b2 b3 b4 b5 b6 b7 ] \|
	250	* [a6 a7 a8 a9 a10 a11 a12 a13] ^ [b6 b7 b8 b9 b10 b11 b12 b13]
	251	* This means the [a6 a7] ^ [b6 b7] part is done two times.
	252	*/
	253	fold = (unsigned long )a ^ (unsigned long )b;
	254	fold \|= (unsigned long )(a + 6) ^ (unsigned long )(b + 6);
	255	return fold;
	256	#else
aa4b9f53 HX	257	u32 a32 = (u32 )((u8 *)a + 2);
	258	u32 b32 = (u32 )((u8 *)b + 2);
	259
	260	return ((u16 )a ^ (u16 )b) \| (a32[0] ^ b32[0]) \|
	261	(a32[1] ^ b32[1]) \| (a32[2] ^ b32[2]);
40d0802b	262	#endif
aa4b9f53 HX	263	}
aa4b9f53 HX	264
1da177e4	265	#endif /* _LINUX_ETHERDEVICE_H */