Commit cf78f8ee authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'for-davem' of git://git.kernel.org/pub/scm/linux/kernel/git/bwh/sfc-next-2.6

parents 1e13f863 c39d35eb

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 @@ found: 
	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 @@ found: 
 * @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 @@ out: 
	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.