Merge branch 'for-davem' of git://git.kernel.org/pub/scm/linux/kernel/git/bwh/sfc-next-2.6 (cf78f8ee) · Commits · e / devices / android_kernel_fairphone_FP3

drivers/net/sfc/efx.h

+2 −3

Original line number	Diff line number	Diff line
		@@ -74,8 +74,7 @@ extern int efx_filter_insert_filter(struct efx_nic *efx,
		bool replace);
		extern int efx_filter_remove_filter(struct efx_nic *efx,
		struct efx_filter_spec *spec);
		extern void efx_filter_table_clear(struct efx_nic *efx,
		enum efx_filter_table_id table_id,
		extern void efx_filter_clear_rx(struct efx_nic *efx,
		enum efx_filter_priority priority);

		/* Channels */

drivers/net/sfc/ethtool.c

+44 −55

Original line number	Diff line number	Diff line
		@@ -11,6 +11,7 @@
		#include <linux/netdevice.h>
		#include <linux/ethtool.h>
		#include <linux/rtnetlink.h>
		#include <linux/in.h>
		#include "net_driver.h"
		#include "workarounds.h"
		#include "selftest.h"
		@@ -558,12 +559,8 @@ static int efx_ethtool_set_flags(struct net_device *net_dev, u32 data)
		if (rc)
		return rc;

		if (!(data & ETH_FLAG_NTUPLE)) {
		efx_filter_table_clear(efx, EFX_FILTER_TABLE_RX_IP,
		EFX_FILTER_PRI_MANUAL);
		efx_filter_table_clear(efx, EFX_FILTER_TABLE_RX_MAC,
		EFX_FILTER_PRI_MANUAL);
		}
		if (!(data & ETH_FLAG_NTUPLE))
		efx_filter_clear_rx(efx, EFX_FILTER_PRI_MANUAL);

		return 0;
		}
		@@ -582,6 +579,9 @@ static void efx_ethtool_self_test(struct net_device *net_dev,
		goto fail1;
		}

		netif_info(efx, drv, efx->net_dev, "starting %sline testing\n",
		(test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");

		/* We need rx buffers and interrupts. */
		already_up = (efx->net_dev->flags & IFF_UP);
		if (!already_up) {
		@@ -600,7 +600,7 @@ static void efx_ethtool_self_test(struct net_device *net_dev,
		if (!already_up)
		dev_close(efx->net_dev);

		netif_dbg(efx, drv, efx->net_dev, "%s %sline self-tests\n",
		netif_info(efx, drv, efx->net_dev, "%s %sline self-tests\n",
		rc == 0 ? "passed" : "failed",
		(test->flags & ETH_TEST_FL_OFFLINE) ? "off" : "on");

		@@ -921,6 +921,7 @@ static int efx_ethtool_set_rx_ntuple(struct net_device *net_dev,
		struct ethhdr *mac_entry = &ntuple->fs.h_u.ether_spec;
		struct ethhdr *mac_mask = &ntuple->fs.m_u.ether_spec;
		struct efx_filter_spec filter;
		int rc;

		/* Range-check action */
		if (ntuple->fs.action < ETHTOOL_RXNTUPLE_ACTION_CLEAR \|\|
		@@ -930,9 +931,16 @@ static int efx_ethtool_set_rx_ntuple(struct net_device *net_dev,
		if (~ntuple->fs.data_mask)
		return -EINVAL;

		efx_filter_init_rx(&filter, EFX_FILTER_PRI_MANUAL, 0,
		(ntuple->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP) ?
		0xfff : ntuple->fs.action);

		switch (ntuple->fs.flow_type) {
		case TCP_V4_FLOW:
		case UDP_V4_FLOW:
		case UDP_V4_FLOW: {
		u8 proto = (ntuple->fs.flow_type == TCP_V4_FLOW ?
		IPPROTO_TCP : IPPROTO_UDP);

		/* Must match all of destination, */
		if (ip_mask->ip4dst \| ip_mask->pdst)
		return -EINVAL;
		@@ -944,7 +952,22 @@ static int efx_ethtool_set_rx_ntuple(struct net_device *net_dev,
		/* and nothing else */
		if ((u8)~ip_mask->tos \| (u16)~ntuple->fs.vlan_tag_mask)
		return -EINVAL;

		if (!ip_mask->ip4src)
		rc = efx_filter_set_ipv4_full(&filter, proto,
		ip_entry->ip4dst,
		ip_entry->pdst,
		ip_entry->ip4src,
		ip_entry->psrc);
		else
		rc = efx_filter_set_ipv4_local(&filter, proto,
		ip_entry->ip4dst,
		ip_entry->pdst);
		if (rc)
		return rc;
		break;
		}

		case ETHER_FLOW:
		/* Must match all of destination, */
		if (!is_zero_ether_addr(mac_mask->h_dest))
		@@ -957,59 +980,25 @@ static int efx_ethtool_set_rx_ntuple(struct net_device *net_dev,
		if (!is_broadcast_ether_addr(mac_mask->h_source) \|\|
		mac_mask->h_proto != htons(0xffff))
		return -EINVAL;
		break;
		default:
		return -EINVAL;
		}

		filter.priority = EFX_FILTER_PRI_MANUAL;
		filter.flags = 0;

		switch (ntuple->fs.flow_type) {
		case TCP_V4_FLOW:
		if (!ip_mask->ip4src)
		efx_filter_set_rx_tcp_full(&filter,
		htonl(ip_entry->ip4src),
		htons(ip_entry->psrc),
		htonl(ip_entry->ip4dst),
		htons(ip_entry->pdst));
		else
		efx_filter_set_rx_tcp_wild(&filter,
		htonl(ip_entry->ip4dst),
		htons(ip_entry->pdst));
		break;
		case UDP_V4_FLOW:
		if (!ip_mask->ip4src)
		efx_filter_set_rx_udp_full(&filter,
		htonl(ip_entry->ip4src),
		htons(ip_entry->psrc),
		htonl(ip_entry->ip4dst),
		htons(ip_entry->pdst));
		else
		efx_filter_set_rx_udp_wild(&filter,
		htonl(ip_entry->ip4dst),
		htons(ip_entry->pdst));
		break;
		case ETHER_FLOW:
		if (ntuple->fs.vlan_tag_mask == 0xf000)
		efx_filter_set_rx_mac_full(&filter,
		ntuple->fs.vlan_tag & 0xfff,
		rc = efx_filter_set_eth_local(
		&filter,
		(ntuple->fs.vlan_tag_mask == 0xf000) ?
		ntuple->fs.vlan_tag : EFX_FILTER_VID_UNSPEC,
		mac_entry->h_dest);
		else
		efx_filter_set_rx_mac_wild(&filter, mac_entry->h_dest);
		if (rc)
		return rc;
		break;

		default:
		return -EINVAL;
		}

		if (ntuple->fs.action == ETHTOOL_RXNTUPLE_ACTION_CLEAR) {
		if (ntuple->fs.action == ETHTOOL_RXNTUPLE_ACTION_CLEAR)
		return efx_filter_remove_filter(efx, &filter);
		} else {
		if (ntuple->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP)
		filter.dmaq_id = 0xfff;
		else
		filter.dmaq_id = ntuple->fs.action;
		return efx_filter_insert_filter(efx, &filter, true);
		}
		}

		static int efx_ethtool_get_rxfh_indir(struct net_device *net_dev,
		struct ethtool_rxfh_indir *indir)

drivers/net/sfc/filter.c

+205 −47

Original line number	Diff line number	Diff line
		@@ -7,6 +7,7 @@
		* by the Free Software Foundation, incorporated herein by reference.
		*/

		#include <linux/in.h>
		#include "efx.h"
		#include "filter.h"
		#include "io.h"
		@@ -26,19 +27,26 @@
		*/
		#define FILTER_CTL_SRCH_MAX 200

		enum efx_filter_table_id {
		EFX_FILTER_TABLE_RX_IP = 0,
		EFX_FILTER_TABLE_RX_MAC,
		EFX_FILTER_TABLE_COUNT,
		};

		struct efx_filter_table {
		enum efx_filter_table_id id;
		u32 offset; /* address of table relative to BAR */
		unsigned size; /* number of entries */
		unsigned step; /* step between entries */
		unsigned used; /* number currently used */
		unsigned long *used_bitmap;
		struct efx_filter_spec *spec;
		unsigned search_depth[EFX_FILTER_TYPE_COUNT];
		};

		struct efx_filter_state {
		spinlock_t lock;
		struct efx_filter_table table[EFX_FILTER_TABLE_COUNT];
		unsigned search_depth[EFX_FILTER_TYPE_COUNT];
		};

		/* The filter hash function is LFSR polynomial x^16 + x^3 + 1 of a 32-bit
		@@ -65,68 +73,203 @@ static u16 efx_filter_increment(u32 key)
		}

		static enum efx_filter_table_id
		efx_filter_type_table_id(enum efx_filter_type type)
		efx_filter_spec_table_id(const struct efx_filter_spec *spec)
		{
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_TCP_FULL >> 2));
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_TCP_WILD >> 2));
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_UDP_FULL >> 2));
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_UDP_WILD >> 2));
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_MAC != (EFX_FILTER_MAC_FULL >> 2));
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_MAC != (EFX_FILTER_MAC_WILD >> 2));
		EFX_BUG_ON_PARANOID(spec->type == EFX_FILTER_UNSPEC);
		return spec->type >> 2;
		}

		static struct efx_filter_table *
		efx_filter_spec_table(struct efx_filter_state *state,
		const struct efx_filter_spec *spec)
		{
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_RX_TCP_FULL >> 2));
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_RX_TCP_WILD >> 2));
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_RX_UDP_FULL >> 2));
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_IP != (EFX_FILTER_RX_UDP_WILD >> 2));
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_MAC != (EFX_FILTER_RX_MAC_FULL >> 2));
		BUILD_BUG_ON(EFX_FILTER_TABLE_RX_MAC != (EFX_FILTER_RX_MAC_WILD >> 2));
		return type >> 2;
		}

		static void
		efx_filter_table_reset_search_depth(struct efx_filter_state *state,
		enum efx_filter_table_id table_id)
		if (spec->type == EFX_FILTER_UNSPEC)
		return NULL;
		else
		return &state->table[efx_filter_spec_table_id(spec)];
		}

		static void efx_filter_table_reset_search_depth(struct efx_filter_table *table)
		{
		memset(state->search_depth + (table_id << 2), 0,
		sizeof(state->search_depth[0]) << 2);
		memset(table->search_depth, 0, sizeof(table->search_depth));
		}

		static void efx_filter_push_rx_limits(struct efx_nic *efx)
		{
		struct efx_filter_state *state = efx->filter_state;
		struct efx_filter_table *table;
		efx_oword_t filter_ctl;

		efx_reado(efx, &filter_ctl, FR_BZ_RX_FILTER_CTL);

		table = &state->table[EFX_FILTER_TABLE_RX_IP];
		EFX_SET_OWORD_FIELD(filter_ctl, FRF_BZ_TCP_FULL_SRCH_LIMIT,
		state->search_depth[EFX_FILTER_RX_TCP_FULL] +
		table->search_depth[EFX_FILTER_TCP_FULL] +
		FILTER_CTL_SRCH_FUDGE_FULL);
		EFX_SET_OWORD_FIELD(filter_ctl, FRF_BZ_TCP_WILD_SRCH_LIMIT,
		state->search_depth[EFX_FILTER_RX_TCP_WILD] +
		table->search_depth[EFX_FILTER_TCP_WILD] +
		FILTER_CTL_SRCH_FUDGE_WILD);
		EFX_SET_OWORD_FIELD(filter_ctl, FRF_BZ_UDP_FULL_SRCH_LIMIT,
		state->search_depth[EFX_FILTER_RX_UDP_FULL] +
		table->search_depth[EFX_FILTER_UDP_FULL] +
		FILTER_CTL_SRCH_FUDGE_FULL);
		EFX_SET_OWORD_FIELD(filter_ctl, FRF_BZ_UDP_WILD_SRCH_LIMIT,
		state->search_depth[EFX_FILTER_RX_UDP_WILD] +
		table->search_depth[EFX_FILTER_UDP_WILD] +
		FILTER_CTL_SRCH_FUDGE_WILD);

		if (state->table[EFX_FILTER_TABLE_RX_MAC].size) {
		table = &state->table[EFX_FILTER_TABLE_RX_MAC];
		if (table->size) {
		EFX_SET_OWORD_FIELD(
		filter_ctl, FRF_CZ_ETHERNET_FULL_SEARCH_LIMIT,
		state->search_depth[EFX_FILTER_RX_MAC_FULL] +
		table->search_depth[EFX_FILTER_MAC_FULL] +
		FILTER_CTL_SRCH_FUDGE_FULL);
		EFX_SET_OWORD_FIELD(
		filter_ctl, FRF_CZ_ETHERNET_WILDCARD_SEARCH_LIMIT,
		state->search_depth[EFX_FILTER_RX_MAC_WILD] +
		table->search_depth[EFX_FILTER_MAC_WILD] +
		FILTER_CTL_SRCH_FUDGE_WILD);
		}

		efx_writeo(efx, &filter_ctl, FR_BZ_RX_FILTER_CTL);
		}

		static inline void __efx_filter_set_ipv4(struct efx_filter_spec *spec,
		__be32 host1, __be16 port1,
		__be32 host2, __be16 port2)
		{
		spec->data[0] = ntohl(host1) << 16 \| ntohs(port1);
		spec->data[1] = ntohs(port2) << 16 \| ntohl(host1) >> 16;
		spec->data[2] = ntohl(host2);
		}

		/**
		* efx_filter_set_ipv4_local - specify IPv4 host, transport protocol and port
		* @spec: Specification to initialise
		* @proto: Transport layer protocol number
		* @host: Local host address (network byte order)
		* @port: Local port (network byte order)
		*/
		int efx_filter_set_ipv4_local(struct efx_filter_spec *spec, u8 proto,
		__be32 host, __be16 port)
		{
		__be32 host1;
		__be16 port1;

		EFX_BUG_ON_PARANOID(!(spec->flags & EFX_FILTER_FLAG_RX));

		/* This cannot currently be combined with other filtering */
		if (spec->type != EFX_FILTER_UNSPEC)
		return -EPROTONOSUPPORT;

		if (port == 0)
		return -EINVAL;

		switch (proto) {
		case IPPROTO_TCP:
		spec->type = EFX_FILTER_TCP_WILD;
		break;
		case IPPROTO_UDP:
		spec->type = EFX_FILTER_UDP_WILD;
		break;
		default:
		return -EPROTONOSUPPORT;
		}

		/* Filter is constructed in terms of source and destination,
		* with the odd wrinkle that the ports are swapped in a UDP
		* wildcard filter. We need to convert from local and remote
		* (= zero for wildcard) addresses.
		*/
		host1 = 0;
		if (proto != IPPROTO_UDP) {
		port1 = 0;
		} else {
		port1 = port;
		port = 0;
		}

		__efx_filter_set_ipv4(spec, host1, port1, host, port);
		return 0;
		}

		/**
		* efx_filter_set_ipv4_full - specify IPv4 hosts, transport protocol and ports
		* @spec: Specification to initialise
		* @proto: Transport layer protocol number
		* @host: Local host address (network byte order)
		* @port: Local port (network byte order)
		* @rhost: Remote host address (network byte order)
		* @rport: Remote port (network byte order)
		*/
		int efx_filter_set_ipv4_full(struct efx_filter_spec *spec, u8 proto,
		__be32 host, __be16 port,
		__be32 rhost, __be16 rport)
		{
		EFX_BUG_ON_PARANOID(!(spec->flags & EFX_FILTER_FLAG_RX));

		/* This cannot currently be combined with other filtering */
		if (spec->type != EFX_FILTER_UNSPEC)
		return -EPROTONOSUPPORT;

		if (port == 0 \|\| rport == 0)
		return -EINVAL;

		switch (proto) {
		case IPPROTO_TCP:
		spec->type = EFX_FILTER_TCP_FULL;
		break;
		case IPPROTO_UDP:
		spec->type = EFX_FILTER_UDP_FULL;
		break;
		default:
		return -EPROTONOSUPPORT;
		}

		__efx_filter_set_ipv4(spec, rhost, rport, host, port);
		return 0;
		}

		/**
		* efx_filter_set_eth_local - specify local Ethernet address and optional VID
		* @spec: Specification to initialise
		* @vid: VLAN ID to match, or %EFX_FILTER_VID_UNSPEC
		* @addr: Local Ethernet MAC address
		*/
		int efx_filter_set_eth_local(struct efx_filter_spec *spec,
		u16 vid, const u8 *addr)
		{
		EFX_BUG_ON_PARANOID(!(spec->flags & EFX_FILTER_FLAG_RX));

		/* This cannot currently be combined with other filtering */
		if (spec->type != EFX_FILTER_UNSPEC)
		return -EPROTONOSUPPORT;

		if (vid == EFX_FILTER_VID_UNSPEC) {
		spec->type = EFX_FILTER_MAC_WILD;
		spec->data[0] = 0;
		} else {
		spec->type = EFX_FILTER_MAC_FULL;
		spec->data[0] = vid;
		}

		spec->data[1] = addr[2] << 24 \| addr[3] << 16 \| addr[4] << 8 \| addr[5];
		spec->data[2] = addr[0] << 8 \| addr[1];
		return 0;
		}

		/* Build a filter entry and return its n-tuple key. */
		static u32 efx_filter_build(efx_oword_t filter, struct efx_filter_spec spec)
		{
		u32 data3;

		switch (efx_filter_type_table_id(spec->type)) {
		switch (efx_filter_spec_table_id(spec)) {
		case EFX_FILTER_TABLE_RX_IP: {
		bool is_udp = (spec->type == EFX_FILTER_RX_UDP_FULL \|\|
		spec->type == EFX_FILTER_RX_UDP_WILD);
		bool is_udp = (spec->type == EFX_FILTER_UDP_FULL \|\|
		spec->type == EFX_FILTER_UDP_WILD);
		EFX_POPULATE_OWORD_7(
		*filter,
		FRF_BZ_RSS_EN,
		@@ -143,7 +286,7 @@ static u32 efx_filter_build(efx_oword_t filter, struct efx_filter_spec spec)
		}

		case EFX_FILTER_TABLE_RX_MAC: {
		bool is_wild = spec->type == EFX_FILTER_RX_MAC_WILD;
		bool is_wild = spec->type == EFX_FILTER_MAC_WILD;
		EFX_POPULATE_OWORD_8(
		*filter,
		FRF_CZ_RMFT_RSS_EN,
		@@ -206,6 +349,14 @@ static int efx_filter_search(struct efx_filter_table *table,
		return filter_idx;
		}

		/* Construct/deconstruct external filter IDs */

		static inline int
		efx_filter_make_id(enum efx_filter_table_id table_id, unsigned index)
		{
		return table_id << 16 \| index;
		}

		/**
		* efx_filter_insert_filter - add or replace a filter
		* @efx: NIC in which to insert the filter
		@@ -213,30 +364,28 @@ static int efx_filter_search(struct efx_filter_table *table,
		* @replace: Flag for whether the specified filter may replace a filter
		* with an identical match expression and equal or lower priority
		*
		* On success, return the filter index within its table.
		* On success, return the filter ID.
		* On failure, return a negative error code.
		*/
		int efx_filter_insert_filter(struct efx_nic efx, struct efx_filter_spec spec,
		bool replace)
		{
		struct efx_filter_state *state = efx->filter_state;
		enum efx_filter_table_id table_id =
		efx_filter_type_table_id(spec->type);
		struct efx_filter_table *table = &state->table[table_id];
		struct efx_filter_table *table = efx_filter_spec_table(state, spec);
		struct efx_filter_spec *saved_spec;
		efx_oword_t filter;
		int filter_idx, depth;
		u32 key;
		int rc;

		if (table->size == 0)
		if (!table \|\| table->size == 0)
		return -EINVAL;

		key = efx_filter_build(&filter, spec);

		netif_vdbg(efx, hw, efx->net_dev,
		"%s: type %d search_depth=%d", __func__, spec->type,
		state->search_depth[spec->type]);
		table->search_depth[spec->type]);

		spin_lock_bh(&state->lock);

		@@ -263,8 +412,8 @@ int efx_filter_insert_filter(struct efx_nic efx, struct efx_filter_spec spec,
		}
		saved_spec = spec;

		if (state->search_depth[spec->type] < depth) {
		state->search_depth[spec->type] = depth;
		if (table->search_depth[spec->type] < depth) {
		table->search_depth[spec->type] = depth;
		efx_filter_push_rx_limits(efx);
		}

		@@ -273,6 +422,7 @@ int efx_filter_insert_filter(struct efx_nic efx, struct efx_filter_spec spec,
		netif_vdbg(efx, hw, efx->net_dev,
		"%s: filter type %d index %d rxq %u set",
		__func__, spec->type, filter_idx, spec->dmaq_id);
		rc = efx_filter_make_id(table->id, filter_idx);

		out:
		spin_unlock_bh(&state->lock);
		@@ -306,15 +456,16 @@ static void efx_filter_table_clear_entry(struct efx_nic *efx,
		int efx_filter_remove_filter(struct efx_nic efx, struct efx_filter_spec spec)
		{
		struct efx_filter_state *state = efx->filter_state;
		enum efx_filter_table_id table_id =
		efx_filter_type_table_id(spec->type);
		struct efx_filter_table *table = &state->table[table_id];
		struct efx_filter_table *table = efx_filter_spec_table(state, spec);
		struct efx_filter_spec *saved_spec;
		efx_oword_t filter;
		int filter_idx, depth;
		u32 key;
		int rc;

		if (!table)
		return -EINVAL;

		key = efx_filter_build(&filter, spec);

		spin_lock_bh(&state->lock);
		@@ -332,7 +483,7 @@ int efx_filter_remove_filter(struct efx_nic efx, struct efx_filter_spec spec)

		efx_filter_table_clear_entry(efx, table, filter_idx);
		if (table->used == 0)
		efx_filter_table_reset_search_depth(state, table_id);
		efx_filter_table_reset_search_depth(table);
		rc = 0;

		out:
		@@ -340,13 +491,7 @@ int efx_filter_remove_filter(struct efx_nic efx, struct efx_filter_spec spec)
		return rc;
		}

		/**
		* efx_filter_table_clear - remove filters from a table by priority
		* @efx: NIC from which to remove the filters
		* @table_id: Table from which to remove the filters
		* @priority: Maximum priority to remove
		*/
		void efx_filter_table_clear(struct efx_nic *efx,
		static void efx_filter_table_clear(struct efx_nic *efx,
		enum efx_filter_table_id table_id,
		enum efx_filter_priority priority)
		{
		@@ -360,11 +505,22 @@ void efx_filter_table_clear(struct efx_nic *efx,
		if (table->spec[filter_idx].priority <= priority)
		efx_filter_table_clear_entry(efx, table, filter_idx);
		if (table->used == 0)
		efx_filter_table_reset_search_depth(state, table_id);
		efx_filter_table_reset_search_depth(table);

		spin_unlock_bh(&state->lock);
		}

		/**
		* efx_filter_clear_rx - remove RX filters by priority
		* @efx: NIC from which to remove the filters
		* @priority: Maximum priority to remove
		*/
		void efx_filter_clear_rx(struct efx_nic *efx, enum efx_filter_priority priority)
		{
		efx_filter_table_clear(efx, EFX_FILTER_TABLE_RX_IP, priority);
		efx_filter_table_clear(efx, EFX_FILTER_TABLE_RX_MAC, priority);
		}

		/* Restore filter stater after reset */
		void efx_restore_filters(struct efx_nic *efx)
		{
		@@ -407,6 +563,7 @@ int efx_probe_filters(struct efx_nic *efx)

		if (efx_nic_rev(efx) >= EFX_REV_FALCON_B0) {
		table = &state->table[EFX_FILTER_TABLE_RX_IP];
		table->id = EFX_FILTER_TABLE_RX_IP;
		table->offset = FR_BZ_RX_FILTER_TBL0;
		table->size = FR_BZ_RX_FILTER_TBL0_ROWS;
		table->step = FR_BZ_RX_FILTER_TBL0_STEP;
		@@ -414,6 +571,7 @@ int efx_probe_filters(struct efx_nic *efx)

		if (efx_nic_rev(efx) >= EFX_REV_SIENA_A0) {
		table = &state->table[EFX_FILTER_TABLE_RX_MAC];
		table->id = EFX_FILTER_TABLE_RX_MAC;
		table->offset = FR_CZ_RX_MAC_FILTER_TBL0;
		table->size = FR_CZ_RX_MAC_FILTER_TBL0_ROWS;
		table->step = FR_CZ_RX_MAC_FILTER_TBL0_STEP;

drivers/net/sfc/filter.h

+36 −113

Original line number	Diff line number	Diff line
		@@ -12,31 +12,27 @@

		#include <linux/types.h>

		enum efx_filter_table_id {
		EFX_FILTER_TABLE_RX_IP = 0,
		EFX_FILTER_TABLE_RX_MAC,
		EFX_FILTER_TABLE_COUNT,
		};

		/**
		* enum efx_filter_type - type of hardware filter
		* @EFX_FILTER_RX_TCP_FULL: RX, matching TCP/IPv4 4-tuple
		* @EFX_FILTER_RX_TCP_WILD: RX, matching TCP/IPv4 destination (host, port)
		* @EFX_FILTER_RX_UDP_FULL: RX, matching UDP/IPv4 4-tuple
		* @EFX_FILTER_RX_UDP_WILD: RX, matching UDP/IPv4 destination (host, port)
		* @EFX_FILTER_RX_MAC_FULL: RX, matching Ethernet destination MAC address, VID
		* @EFX_FILTER_RX_MAC_WILD: RX, matching Ethernet destination MAC address
		* @EFX_FILTER_TCP_FULL: Matching TCP/IPv4 4-tuple
		* @EFX_FILTER_TCP_WILD: Matching TCP/IPv4 destination (host, port)
		* @EFX_FILTER_UDP_FULL: Matching UDP/IPv4 4-tuple
		* @EFX_FILTER_UDP_WILD: Matching UDP/IPv4 destination (host, port)
		* @EFX_FILTER_MAC_FULL: Matching Ethernet destination MAC address, VID
		* @EFX_FILTER_MAC_WILD: Matching Ethernet destination MAC address
		* @EFX_FILTER_UNSPEC: Match type is unspecified
		*
		* Falcon NICs only support the RX TCP/IPv4 and UDP/IPv4 filter types.
		* Falcon NICs only support the TCP/IPv4 and UDP/IPv4 filter types.
		*/
		enum efx_filter_type {
		EFX_FILTER_RX_TCP_FULL = 0,
		EFX_FILTER_RX_TCP_WILD,
		EFX_FILTER_RX_UDP_FULL,
		EFX_FILTER_RX_UDP_WILD,
		EFX_FILTER_RX_MAC_FULL = 4,
		EFX_FILTER_RX_MAC_WILD,
		EFX_FILTER_TYPE_COUNT,
		EFX_FILTER_TCP_FULL = 0,
		EFX_FILTER_TCP_WILD,
		EFX_FILTER_UDP_FULL,
		EFX_FILTER_UDP_WILD,
		EFX_FILTER_MAC_FULL = 4,
		EFX_FILTER_MAC_WILD,
		EFX_FILTER_TYPE_COUNT, /* number of specific types */
		EFX_FILTER_UNSPEC = 0xf,
		};

		/**
		@@ -63,13 +59,13 @@ enum efx_filter_priority {
		* @EFX_FILTER_FLAG_RX_OVERRIDE_IP: Enables a MAC filter to override
		* any IP filter that matches the same packet. By default, IP
		* filters take precedence.
		*
		* Currently, no flags are defined for TX filters.
		* @EFX_FILTER_FLAG_RX: Filter is for RX
		*/
		enum efx_filter_flags {
		EFX_FILTER_FLAG_RX_RSS = 0x01,
		EFX_FILTER_FLAG_RX_SCATTER = 0x02,
		EFX_FILTER_FLAG_RX_OVERRIDE_IP = 0x04,
		EFX_FILTER_FLAG_RX = 0x08,
		};

		/**
		@@ -91,99 +87,26 @@ struct efx_filter_spec {
		u32 data[3];
		};

		/**
		* efx_filter_set_rx_tcp_full - specify RX filter with TCP/IPv4 full match
		* @spec: Specification to initialise
		* @shost: Source host address (host byte order)
		* @sport: Source port (host byte order)
		* @dhost: Destination host address (host byte order)
		* @dport: Destination port (host byte order)
		*/
		static inline void
		efx_filter_set_rx_tcp_full(struct efx_filter_spec *spec,
		u32 shost, u16 sport, u32 dhost, u16 dport)
		{
		spec->type = EFX_FILTER_RX_TCP_FULL;
		spec->data[0] = sport \| shost << 16;
		spec->data[1] = dport << 16 \| shost >> 16;
		spec->data[2] = dhost;
		}

		/**
		* efx_filter_set_rx_tcp_wild - specify RX filter with TCP/IPv4 wildcard match
		* @spec: Specification to initialise
		* @dhost: Destination host address (host byte order)
		* @dport: Destination port (host byte order)
		*/
		static inline void
		efx_filter_set_rx_tcp_wild(struct efx_filter_spec *spec, u32 dhost, u16 dport)
		{
		spec->type = EFX_FILTER_RX_TCP_WILD;
		spec->data[0] = 0;
		spec->data[1] = dport << 16;
		spec->data[2] = dhost;
		}

		/**
		* efx_filter_set_rx_udp_full - specify RX filter with UDP/IPv4 full match
		* @spec: Specification to initialise
		* @shost: Source host address (host byte order)
		* @sport: Source port (host byte order)
		* @dhost: Destination host address (host byte order)
		* @dport: Destination port (host byte order)
		*/
		static inline void
		efx_filter_set_rx_udp_full(struct efx_filter_spec *spec,
		u32 shost, u16 sport, u32 dhost, u16 dport)
		{
		spec->type = EFX_FILTER_RX_UDP_FULL;
		spec->data[0] = sport \| shost << 16;
		spec->data[1] = dport << 16 \| shost >> 16;
		spec->data[2] = dhost;
		}

		/**
		* efx_filter_set_rx_udp_wild - specify RX filter with UDP/IPv4 wildcard match
		* @spec: Specification to initialise
		* @dhost: Destination host address (host byte order)
		* @dport: Destination port (host byte order)
		*/
		static inline void
		efx_filter_set_rx_udp_wild(struct efx_filter_spec *spec, u32 dhost, u16 dport)
		static inline void efx_filter_init_rx(struct efx_filter_spec *spec,
		enum efx_filter_priority priority,
		enum efx_filter_flags flags,
		unsigned rxq_id)
		{
		spec->type = EFX_FILTER_RX_UDP_WILD;
		spec->data[0] = dport;
		spec->data[1] = 0;
		spec->data[2] = dhost;
		spec->type = EFX_FILTER_UNSPEC;
		spec->priority = priority;
		spec->flags = EFX_FILTER_FLAG_RX \| flags;
		spec->dmaq_id = rxq_id;
		}

		/**
		* efx_filter_set_rx_mac_full - specify RX filter with MAC full match
		* @spec: Specification to initialise
		* @vid: VLAN ID
		* @addr: Destination MAC address
		*/
		static inline void efx_filter_set_rx_mac_full(struct efx_filter_spec *spec,
		u16 vid, const u8 *addr)
		{
		spec->type = EFX_FILTER_RX_MAC_FULL;
		spec->data[0] = vid;
		spec->data[1] = addr[2] << 24 \| addr[3] << 16 \| addr[4] << 8 \| addr[5];
		spec->data[2] = addr[0] << 8 \| addr[1];
		}

		/**
		* efx_filter_set_rx_mac_full - specify RX filter with MAC wildcard match
		* @spec: Specification to initialise
		* @addr: Destination MAC address
		*/
		static inline void efx_filter_set_rx_mac_wild(struct efx_filter_spec *spec,
		const u8 *addr)
		{
		spec->type = EFX_FILTER_RX_MAC_WILD;
		spec->data[0] = 0;
		spec->data[1] = addr[2] << 24 \| addr[3] << 16 \| addr[4] << 8 \| addr[5];
		spec->data[2] = addr[0] << 8 \| addr[1];
		}
		extern int efx_filter_set_ipv4_local(struct efx_filter_spec *spec, u8 proto,
		__be32 host, __be16 port);
		extern int efx_filter_set_ipv4_full(struct efx_filter_spec *spec, u8 proto,
		__be32 host, __be16 port,
		__be32 rhost, __be16 rport);
		extern int efx_filter_set_eth_local(struct efx_filter_spec *spec,
		u16 vid, const u8 *addr);
		enum {
		EFX_FILTER_VID_UNSPEC = 0xffff,
		};

		#endif /* EFX_FILTER_H */

drivers/net/sfc/io.h

+88 −65

File changed.

Preview size limit exceeded, changes collapsed.