From 8dea78da5cee153b8af9c07a2745f6c55057fe12 Mon Sep 17 00:00:00 2001 From: Jonathan Herman Date: Thu, 17 Jan 2013 16:15:55 -0500 Subject: Patched in Tegra support. --- include/linux/etherdevice.h | 132 +++++++++++++------------------------------- 1 file changed, 38 insertions(+), 94 deletions(-) (limited to 'include/linux/etherdevice.h') diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h index 243eea1e33d..05955cf0993 100644 --- a/include/linux/etherdevice.h +++ b/include/linux/etherdevice.h @@ -18,6 +18,8 @@ * 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 @@ -51,33 +53,13 @@ extern struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs, #define alloc_etherdev(sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1) #define alloc_etherdev_mq(sizeof_priv, count) alloc_etherdev_mqs(sizeof_priv, count, count) -/* Reserved Ethernet Addresses per IEEE 802.1Q */ -static const u8 eth_reserved_addr_base[ETH_ALEN] __aligned(2) = -{ 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 }; - -/** - * is_link_local_ether_addr - Determine if given Ethernet address is link-local - * @addr: Pointer to a six-byte array containing the Ethernet address - * - * Return true if address is link local reserved addr (01:80:c2:00:00:0X) per - * IEEE 802.1Q 8.6.3 Frame filtering. - */ -static inline bool is_link_local_ether_addr(const u8 *addr) -{ - __be16 *a = (__be16 *)addr; - static const __be16 *b = (const __be16 *)eth_reserved_addr_base; - static const __be16 m = cpu_to_be16(0xfff0); - - return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | ((a[2] ^ b[2]) & m)) == 0; -} - /** * 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 bool is_zero_ether_addr(const u8 *addr) +static inline int is_zero_ether_addr(const u8 *addr) { return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]); } @@ -89,7 +71,7 @@ static inline bool is_zero_ether_addr(const u8 *addr) * Return true if the address is a multicast address. * By definition the broadcast address is also a multicast address. */ -static inline bool is_multicast_ether_addr(const u8 *addr) +static inline int is_multicast_ether_addr(const u8 *addr) { return 0x01 & addr[0]; } @@ -100,7 +82,7 @@ static inline bool is_multicast_ether_addr(const u8 *addr) * * Return true if the address is a local address. */ -static inline bool is_local_ether_addr(const u8 *addr) +static inline int is_local_ether_addr(const u8 *addr) { return 0x02 & addr[0]; } @@ -111,7 +93,7 @@ static inline bool is_local_ether_addr(const u8 *addr) * * Return true if the address is the broadcast address. */ -static inline bool is_broadcast_ether_addr(const u8 *addr) +static inline int is_broadcast_ether_addr(const u8 *addr) { return (addr[0] & addr[1] & addr[2] & addr[3] & addr[4] & addr[5]) == 0xff; } @@ -122,7 +104,7 @@ static inline bool is_broadcast_ether_addr(const u8 *addr) * * Return true if the address is a unicast address. */ -static inline bool is_unicast_ether_addr(const u8 *addr) +static inline int is_unicast_ether_addr(const u8 *addr) { return !is_multicast_ether_addr(addr); } @@ -136,7 +118,7 @@ static inline bool is_unicast_ether_addr(const u8 *addr) * * Return true if the address is valid. */ -static inline bool is_valid_ether_addr(const u8 *addr) +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. */ @@ -144,56 +126,31 @@ static inline bool is_valid_ether_addr(const u8 *addr) } /** - * eth_random_addr - Generate software assigned random Ethernet address + * 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 eth_random_addr(u8 *addr) -{ - get_random_bytes(addr, ETH_ALEN); - addr[0] &= 0xfe; /* clear multicast bit */ - addr[0] |= 0x02; /* set local assignment bit (IEEE802) */ -} - -#define random_ether_addr(addr) eth_random_addr(addr) - -/** - * eth_broadcast_addr - Assign broadcast address - * @addr: Pointer to a six-byte array containing the Ethernet address - * - * Assign the broadcast address to the given address array. - */ -static inline void eth_broadcast_addr(u8 *addr) +static inline void random_ether_addr(u8 *addr) { - memset(addr, 0xff, ETH_ALEN); + get_random_bytes (addr, ETH_ALEN); + addr [0] &= 0xfe; /* clear multicast bit */ + addr [0] |= 0x02; /* set local assignment bit (IEEE802) */ } /** - * eth_zero_addr - Assign zero address - * @addr: Pointer to a six-byte array containing the Ethernet address - * - * Assign the zero address to the given address array. - */ -static inline void eth_zero_addr(u8 *addr) -{ - memset(addr, 0x00, ETH_ALEN); -} - -/** - * eth_hw_addr_random - Generate software assigned random Ethernet and - * set device flag + * 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 a random Ethernet address (MAC) to be used by a net device - * and set addr_assign_type so the state can be read by sysfs and be - * used by userspace. + * 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 eth_hw_addr_random(struct net_device *dev) +static inline void dev_hw_addr_random(struct net_device *dev, u8 *hwaddr) { dev->addr_assign_type |= NET_ADDR_RANDOM; - eth_random_addr(dev->dev_addr); + random_ether_addr(hwaddr); } /** @@ -201,8 +158,7 @@ static inline void eth_hw_addr_random(struct net_device *dev) * @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, non-zero otherwise. - * Unlike memcmp(), it doesn't return a value suitable for sorting. + * Compare two ethernet addresses, returns 0 if equal */ static inline unsigned compare_ether_addr(const u8 *addr1, const u8 *addr2) { @@ -213,18 +169,6 @@ static inline unsigned compare_ether_addr(const u8 *addr1, const u8 *addr2) return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2])) != 0; } -/** - * ether_addr_equal - 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 true if equal - */ -static inline bool ether_addr_equal(const u8 *addr1, const u8 *addr2) -{ - return !compare_ether_addr(addr1, addr2); -} - static inline unsigned long zap_last_2bytes(unsigned long value) { #ifdef __BIG_ENDIAN @@ -235,34 +179,34 @@ static inline unsigned long zap_last_2bytes(unsigned long value) } /** - * ether_addr_equal_64bits - Compare two Ethernet addresses + * 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 true if equal, false otherwise. - * - * The function doesn't need any conditional branches and possibly uses - * word memory accesses on CPU allowing cheap unaligned memory reads. - * arrays = { byte1, byte2, byte3, byte4, byte5, byte6, pad1, pad2 } + * 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 are only guaranteed to be 16 bits. + * Please note that alignment of addr1 & addr2 is only guaranted to be 16 bits. */ -static inline bool ether_addr_equal_64bits(const u8 addr1[6+2], - const u8 addr2[6+2]) +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; + return zap_last_2bytes(fold) != 0; fold |= zap_last_2bytes((*(unsigned long *)(addr1 + 4)) ^ (*(unsigned long *)(addr2 + 4))); - return fold == 0; + return fold != 0; #else - return ether_addr_equal(addr1, addr2); + return compare_ether_addr(addr1, addr2); #endif } @@ -274,23 +218,23 @@ static inline bool ether_addr_equal_64bits(const u8 addr1[6+2], * 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 ether_addr_equal_64bits() so take care of + * 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; - bool res = false; + int res = 1; rcu_read_lock(); for_each_dev_addr(dev, ha) { - res = ether_addr_equal_64bits(addr, ha->addr); - if (res) + res = compare_ether_addr_64bits(addr, ha->addr); + if (!res) break; } rcu_read_unlock(); - return res; + return !res; } #endif /* __KERNEL__ */ @@ -299,7 +243,7 @@ static inline bool is_etherdev_addr(const struct net_device *dev, * @a: Pointer to Ethernet header * @b: Pointer to Ethernet header * - * Compare two Ethernet headers, returns 0 if equal. + * 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 -- cgit v1.2.2