cxgb4: Add remaining driver headers and L2T management

/*

 * This file is part of the Chelsio T4 Ethernet driver for Linux.

 *

 * Copyright (c) 2003-2010 Chelsio Communications, Inc. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer.

 *

 *      - Redistributions in binary form must reproduce the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer in the documentation and/or other materials

 *        provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */

#ifndef __CXGB4_OFLD_H

#define __CXGB4_OFLD_H

#include <linux/cache.h>

#include <linux/spinlock.h>

#include <linux/skbuff.h>

#include <asm/atomic.h>

/* CPL message priority levels */

enum {

	CPL_PRIORITY_DATA     = 0,  /* data messages */

	CPL_PRIORITY_SETUP    = 1,  /* connection setup messages */

	CPL_PRIORITY_TEARDOWN = 0,  /* connection teardown messages */

	CPL_PRIORITY_LISTEN   = 1,  /* listen start/stop messages */

	CPL_PRIORITY_ACK      = 1,  /* RX ACK messages */

	CPL_PRIORITY_CONTROL  = 1   /* control messages */

};

#define INIT_TP_WR(w, tid) do { \

	(w)->wr.wr_hi = htonl(FW_WR_OP(FW_TP_WR) | \

			      FW_WR_IMMDLEN(sizeof(*w) - sizeof(w->wr))); \

	(w)->wr.wr_mid = htonl(FW_WR_LEN16(DIV_ROUND_UP(sizeof(*w), 16)) | \

			       FW_WR_FLOWID(tid)); \

	(w)->wr.wr_lo = cpu_to_be64(0); \

} while (0)

#define INIT_TP_WR_CPL(w, cpl, tid) do { \

	INIT_TP_WR(w, tid); \

	OPCODE_TID(w) = htonl(MK_OPCODE_TID(cpl, tid)); \

} while (0)

#define INIT_ULPTX_WR(w, wrlen, atomic, tid) do { \

	(w)->wr.wr_hi = htonl(FW_WR_OP(FW_ULPTX_WR) | FW_WR_ATOMIC(atomic)); \

	(w)->wr.wr_mid = htonl(FW_WR_LEN16(DIV_ROUND_UP(wrlen, 16)) | \

			       FW_WR_FLOWID(tid)); \

	(w)->wr.wr_lo = cpu_to_be64(0); \

} while (0)

/* Special asynchronous notification message */

#define CXGB4_MSG_AN ((void *)1)

struct serv_entry {

	void *data;

};

union aopen_entry {

	void *data;

	union aopen_entry *next;

};

/*

 * Holds the size, base address, free list start, etc of the TID, server TID,

 * and active-open TID tables.  The tables themselves are allocated dynamically.

 */

struct tid_info {

	void **tid_tab;

	unsigned int ntids;

	struct serv_entry *stid_tab;

	unsigned long *stid_bmap;

	unsigned int nstids;

	unsigned int stid_base;

	union aopen_entry *atid_tab;

	unsigned int natids;

	unsigned int nftids;

	unsigned int ftid_base;

	spinlock_t atid_lock ____cacheline_aligned_in_smp;

	union aopen_entry *afree;

	unsigned int atids_in_use;

	spinlock_t stid_lock;

	unsigned int stids_in_use;

	atomic_t tids_in_use;

};

static inline void *lookup_tid(const struct tid_info *t, unsigned int tid)

{

	return tid < t->ntids ? t->tid_tab[tid] : NULL;

}

static inline void *lookup_atid(const struct tid_info *t, unsigned int atid)

{

	return atid < t->natids ? t->atid_tab[atid].data : NULL;

}

static inline void *lookup_stid(const struct tid_info *t, unsigned int stid)

{

	stid -= t->stid_base;

	return stid < t->nstids ? t->stid_tab[stid].data : NULL;

}

static inline void cxgb4_insert_tid(struct tid_info *t, void *data,

				    unsigned int tid)

{

	t->tid_tab[tid] = data;

	atomic_inc(&t->tids_in_use);

}

int cxgb4_alloc_atid(struct tid_info *t, void *data);

int cxgb4_alloc_stid(struct tid_info *t, int family, void *data);

void cxgb4_free_atid(struct tid_info *t, unsigned int atid);

void cxgb4_free_stid(struct tid_info *t, unsigned int stid, int family);

void cxgb4_remove_tid(struct tid_info *t, unsigned int qid, unsigned int tid);

void cxgb4_queue_tid_release(struct tid_info *t, unsigned int chan,

			     unsigned int tid);

struct in6_addr;

int cxgb4_create_server(const struct net_device *dev, unsigned int stid,

			__be32 sip, __be16 sport, unsigned int queue);

int cxgb4_create_server6(const struct net_device *dev, unsigned int stid,

			 const struct in6_addr *sip, __be16 sport,

			 unsigned int queue);

static inline void set_wr_txq(struct sk_buff *skb, int prio, int queue)

{

	skb_set_queue_mapping(skb, (queue << 1) | prio);

}

enum cxgb4_uld {

	CXGB4_ULD_RDMA,

	CXGB4_ULD_ISCSI,

	CXGB4_ULD_MAX

};

enum cxgb4_state {

	CXGB4_STATE_UP,

	CXGB4_STATE_START_RECOVERY,

	CXGB4_STATE_DOWN,

	CXGB4_STATE_DETACH

};

struct pci_dev;

struct l2t_data;

struct net_device;

struct pkt_gl;

struct tp_tcp_stats;

struct cxgb4_range {

	unsigned int start;

	unsigned int size;

};

struct cxgb4_virt_res {                      /* virtualized HW resources */

	struct cxgb4_range ddp;

	struct cxgb4_range iscsi;

	struct cxgb4_range stag;

	struct cxgb4_range rq;

	struct cxgb4_range pbl;

};

/*

 * Block of information the LLD provides to ULDs attaching to a device.

 */

struct cxgb4_lld_info {

	struct pci_dev *pdev;                /* associated PCI device */

	struct l2t_data *l2t;                /* L2 table */

	struct tid_info *tids;               /* TID table */

	struct net_device **ports;           /* device ports */

	const struct cxgb4_virt_res *vr;     /* assorted HW resources */

	const unsigned short *mtus;          /* MTU table */

	const unsigned short *rxq_ids;       /* the ULD's Rx queue ids */

	unsigned short nrxq;                 /* # of Rx queues */

	unsigned short ntxq;                 /* # of Tx queues */

	unsigned char nchan:4;               /* # of channels */

	unsigned char nports:4;              /* # of ports */

	unsigned char wr_cred;               /* WR 16-byte credits */

	unsigned char adapter_type;          /* type of adapter */

	unsigned char fw_api_ver;            /* FW API version */

	unsigned int fw_vers;                /* FW version */

	unsigned int iscsi_iolen;            /* iSCSI max I/O length */

	unsigned short udb_density;          /* # of user DB/page */

	unsigned short ucq_density;          /* # of user CQs/page */

	void __iomem *gts_reg;               /* address of GTS register */

	void __iomem *db_reg;                /* address of kernel doorbell */

};

struct cxgb4_uld_info {

	const char *name;

	void *(*add)(const struct cxgb4_lld_info *p);

	int (*rx_handler)(void *handle, const __be64 *rsp,

			  const struct pkt_gl *gl);

	int (*state_change)(void *handle, enum cxgb4_state new_state);

};

int cxgb4_register_uld(enum cxgb4_uld type, const struct cxgb4_uld_info *p);

int cxgb4_unregister_uld(enum cxgb4_uld type);

int cxgb4_ofld_send(struct net_device *dev, struct sk_buff *skb);

unsigned int cxgb4_port_chan(const struct net_device *dev);

unsigned int cxgb4_port_viid(const struct net_device *dev);

unsigned int cxgb4_port_idx(const struct net_device *dev);

struct net_device *cxgb4_netdev_by_hwid(struct pci_dev *pdev, unsigned int id);

unsigned int cxgb4_best_mtu(const unsigned short *mtus, unsigned short mtu,

			    unsigned int *idx);

void cxgb4_get_tcp_stats(struct pci_dev *pdev, struct tp_tcp_stats *v4,

			 struct tp_tcp_stats *v6);

void cxgb4_iscsi_init(struct net_device *dev, unsigned int tag_mask,

		      const unsigned int *pgsz_order);

struct sk_buff *cxgb4_pktgl_to_skb(const struct pkt_gl *gl,

				   unsigned int skb_len, unsigned int pull_len);

#endif  /* !__CXGB4_OFLD_H */

/*

 * This file is part of the Chelsio T4 Ethernet driver for Linux.

 *

 * Copyright (c) 2003-2010 Chelsio Communications, Inc. All rights reserved.

 *

 * This software is available to you under a choice of one of two

 * licenses.  You may choose to be licensed under the terms of the GNU

 * General Public License (GPL) Version 2, available from the file

 * COPYING in the main directory of this source tree, or the

 * OpenIB.org BSD license below:

 *

 *     Redistribution and use in source and binary forms, with or

 *     without modification, are permitted provided that the following

 *     conditions are met:

 *

 *      - Redistributions of source code must retain the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer.

 *

 *      - Redistributions in binary form must reproduce the above

 *        copyright notice, this list of conditions and the following

 *        disclaimer in the documentation and/or other materials

 *        provided with the distribution.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS

 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

 * SOFTWARE.

 */

#include <linux/skbuff.h>

#include <linux/netdevice.h>

#include <linux/if.h>

#include <linux/if_vlan.h>

#include <linux/jhash.h>

#include <net/neighbour.h>

#include "cxgb4.h"

#include "l2t.h"

#include "t4_msg.h"

#include "t4fw_api.h"

#define VLAN_NONE 0xfff

/* identifies sync vs async L2T_WRITE_REQs */

#define F_SYNC_WR    (1 << 12)

enum {

	L2T_STATE_VALID,      /* entry is up to date */

	L2T_STATE_STALE,      /* entry may be used but needs revalidation */

	L2T_STATE_RESOLVING,  /* entry needs address resolution */

	L2T_STATE_SYNC_WRITE, /* synchronous write of entry underway */

	/* when state is one of the below the entry is not hashed */

	L2T_STATE_SWITCHING,  /* entry is being used by a switching filter */

	L2T_STATE_UNUSED      /* entry not in use */

};

struct l2t_data {

	rwlock_t lock;

	atomic_t nfree;             /* number of free entries */

	struct l2t_entry *rover;    /* starting point for next allocation */

	struct l2t_entry l2tab[L2T_SIZE];

};

static inline unsigned int vlan_prio(const struct l2t_entry *e)

{

	return e->vlan >> 13;

}

static inline void l2t_hold(struct l2t_data *d, struct l2t_entry *e)

{

	if (atomic_add_return(1, &e->refcnt) == 1)  /* 0 -> 1 transition */

		atomic_dec(&d->nfree);

}

/*

 * To avoid having to check address families we do not allow v4 and v6

 * neighbors to be on the same hash chain.  We keep v4 entries in the first

 * half of available hash buckets and v6 in the second.

 */

enum {

	L2T_SZ_HALF = L2T_SIZE / 2,

	L2T_HASH_MASK = L2T_SZ_HALF - 1

};

static inline unsigned int arp_hash(const u32 *key, int ifindex)

{

	return jhash_2words(*key, ifindex, 0) & L2T_HASH_MASK;

}

static inline unsigned int ipv6_hash(const u32 *key, int ifindex)

{

	u32 xor = key[0] ^ key[1] ^ key[2] ^ key[3];

	return L2T_SZ_HALF + (jhash_2words(xor, ifindex, 0) & L2T_HASH_MASK);

}

static unsigned int addr_hash(const u32 *addr, int addr_len, int ifindex)

{

	return addr_len == 4 ? arp_hash(addr, ifindex) :

			       ipv6_hash(addr, ifindex);

}

/*

 * Checks if an L2T entry is for the given IP/IPv6 address.  It does not check

 * whether the L2T entry and the address are of the same address family.

 * Callers ensure an address is only checked against L2T entries of the same

 * family, something made trivial by the separation of IP and IPv6 hash chains

 * mentioned above.  Returns 0 if there's a match,

 */

static int addreq(const struct l2t_entry *e, const u32 *addr)

{

	if (e->v6)

		return (e->addr[0] ^ addr[0]) | (e->addr[1] ^ addr[1]) |

		       (e->addr[2] ^ addr[2]) | (e->addr[3] ^ addr[3]);

	return e->addr[0] ^ addr[0];

}

static void neigh_replace(struct l2t_entry *e, struct neighbour *n)

{

	neigh_hold(n);

	if (e->neigh)

		neigh_release(e->neigh);

	e->neigh = n;

}

/*

 * Write an L2T entry.  Must be called with the entry locked.

 * The write may be synchronous or asynchronous.

 */

static int write_l2e(struct adapter *adap, struct l2t_entry *e, int sync)

{

	struct sk_buff *skb;

	struct cpl_l2t_write_req *req;

	skb = alloc_skb(sizeof(*req), GFP_ATOMIC);

	if (!skb)

		return -ENOMEM;

	req = (struct cpl_l2t_write_req *)__skb_put(skb, sizeof(*req));

	INIT_TP_WR(req, 0);

	OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_L2T_WRITE_REQ,

					e->idx | (sync ? F_SYNC_WR : 0) |

					TID_QID(adap->sge.fw_evtq.abs_id)));

	req->params = htons(L2T_W_PORT(e->lport) | L2T_W_NOREPLY(!sync));

	req->l2t_idx = htons(e->idx);

	req->vlan = htons(e->vlan);

	if (e->neigh)

		memcpy(e->dmac, e->neigh->ha, sizeof(e->dmac));

	memcpy(req->dst_mac, e->dmac, sizeof(req->dst_mac));

	set_wr_txq(skb, CPL_PRIORITY_CONTROL, 0);

	t4_ofld_send(adap, skb);

	if (sync && e->state != L2T_STATE_SWITCHING)

		e->state = L2T_STATE_SYNC_WRITE;

	return 0;

}

/*

 * Send packets waiting in an L2T entry's ARP queue.  Must be called with the

 * entry locked.

 */

static void send_pending(struct adapter *adap, struct l2t_entry *e)

{

	while (e->arpq_head) {

		struct sk_buff *skb = e->arpq_head;

		e->arpq_head = skb->next;

		skb->next = NULL;

		t4_ofld_send(adap, skb);

	}

	e->arpq_tail = NULL;

}

/*

 * Process a CPL_L2T_WRITE_RPL.  Wake up the ARP queue if it completes a

 * synchronous L2T_WRITE.  Note that the TID in the reply is really the L2T

 * index it refers to.

 */

void do_l2t_write_rpl(struct adapter *adap, const struct cpl_l2t_write_rpl *rpl)

{

	unsigned int tid = GET_TID(rpl);

	unsigned int idx = tid & (L2T_SIZE - 1);

	if (unlikely(rpl->status != CPL_ERR_NONE)) {

		dev_err(adap->pdev_dev,

			"Unexpected L2T_WRITE_RPL status %u for entry %u\n",

			rpl->status, idx);

		return;

	}

	if (tid & F_SYNC_WR) {

		struct l2t_entry *e = &adap->l2t->l2tab[idx];

		spin_lock(&e->lock);

		if (e->state != L2T_STATE_SWITCHING) {

			send_pending(adap, e);

			e->state = (e->neigh->nud_state & NUD_STALE) ?

					L2T_STATE_STALE : L2T_STATE_VALID;

		}

		spin_unlock(&e->lock);

	}

}

/*

 * Add a packet to an L2T entry's queue of packets awaiting resolution.

 * Must be called with the entry's lock held.

 */

static inline void arpq_enqueue(struct l2t_entry *e, struct sk_buff *skb)

{

	skb->next = NULL;

	if (e->arpq_head)

		e->arpq_tail->next = skb;

	else

		e->arpq_head = skb;

	e->arpq_tail = skb;

}

int cxgb4_l2t_send(struct net_device *dev, struct sk_buff *skb,

		   struct l2t_entry *e)

{

	struct adapter *adap = netdev2adap(dev);

again:

	switch (e->state) {

	case L2T_STATE_STALE:     /* entry is stale, kick off revalidation */

		neigh_event_send(e->neigh, NULL);

		spin_lock_bh(&e->lock);

		if (e->state == L2T_STATE_STALE)

			e->state = L2T_STATE_VALID;

		spin_unlock_bh(&e->lock);

	case L2T_STATE_VALID:     /* fast-path, send the packet on */

		return t4_ofld_send(adap, skb);

	case L2T_STATE_RESOLVING:

	case L2T_STATE_SYNC_WRITE:

		spin_lock_bh(&e->lock);

		if (e->state != L2T_STATE_SYNC_WRITE &&

		    e->state != L2T_STATE_RESOLVING) {

			spin_unlock_bh(&e->lock);

			goto again;

		}

		arpq_enqueue(e, skb);

		spin_unlock_bh(&e->lock);

		if (e->state == L2T_STATE_RESOLVING &&

		    !neigh_event_send(e->neigh, NULL)) {

			spin_lock_bh(&e->lock);

			if (e->state == L2T_STATE_RESOLVING && e->arpq_head)

				write_l2e(adap, e, 1);

			spin_unlock_bh(&e->lock);

		}

	}

	return 0;

}

EXPORT_SYMBOL(cxgb4_l2t_send);

/*

 * Allocate a free L2T entry.  Must be called with l2t_data.lock held.

 */

static struct l2t_entry *alloc_l2e(struct l2t_data *d)

{

	struct l2t_entry *end, *e, **p;

	if (!atomic_read(&d->nfree))

		return NULL;

	/* there's definitely a free entry */

	for (e = d->rover, end = &d->l2tab[L2T_SIZE]; e != end; ++e)

		if (atomic_read(&e->refcnt) == 0)

			goto found;

	for (e = d->l2tab; atomic_read(&e->refcnt); ++e)

		;

found:

	d->rover = e + 1;

	atomic_dec(&d->nfree);

	/*

	 * The entry we found may be an inactive entry that is

	 * presently in the hash table.  We need to remove it.

	 */

	if (e->state < L2T_STATE_SWITCHING)

		for (p = &d->l2tab[e->hash].first; *p; p = &(*p)->next)

			if (*p == e) {

				*p = e->next;

				e->next = NULL;

				break;

			}

	e->state = L2T_STATE_UNUSED;

	return e;

}

/*

 * Called when an L2T entry has no more users.

 */

static void t4_l2e_free(struct l2t_entry *e)

{

	struct l2t_data *d;

	spin_lock_bh(&e->lock);

	if (atomic_read(&e->refcnt) == 0) {  /* hasn't been recycled */

		if (e->neigh) {

			neigh_release(e->neigh);

			e->neigh = NULL;

		}

	}

	spin_unlock_bh(&e->lock);

	d = container_of(e, struct l2t_data, l2tab[e->idx]);

	atomic_inc(&d->nfree);

}

void cxgb4_l2t_release(struct l2t_entry *e)

{

	if (atomic_dec_and_test(&e->refcnt))

		t4_l2e_free(e);

}

EXPORT_SYMBOL(cxgb4_l2t_release);

/*

 * Update an L2T entry that was previously used for the same next hop as neigh.

 * Must be called with softirqs disabled.

 */

static void reuse_entry(struct l2t_entry *e, struct neighbour *neigh)

{

	unsigned int nud_state;

	spin_lock(&e->lock);                /* avoid race with t4_l2t_free */

	if (neigh != e->neigh)

		neigh_replace(e, neigh);

	nud_state = neigh->nud_state;

	if (memcmp(e->dmac, neigh->ha, sizeof(e->dmac)) ||

	    !(nud_state & NUD_VALID))

		e->state = L2T_STATE_RESOLVING;

	else if (nud_state & NUD_CONNECTED)

		e->state = L2T_STATE_VALID;

	else

		e->state = L2T_STATE_STALE;

	spin_unlock(&e->lock);

}

struct l2t_entry *cxgb4_l2t_get(struct l2t_data *d, struct neighbour *neigh,

				const struct net_device *physdev,

				unsigned int priority)

{

	u8 lport;

	u16 vlan;

	struct l2t_entry *e;

	int addr_len = neigh->tbl->key_len;

	u32 *addr = (u32 *)neigh->primary_key;

	int ifidx = neigh->dev->ifindex;

	int hash = addr_hash(addr, addr_len, ifidx);

	if (neigh->dev->flags & IFF_LOOPBACK)

		lport = netdev2pinfo(physdev)->tx_chan + 4;

	else

		lport = netdev2pinfo(physdev)->lport;

	if (neigh->dev->priv_flags & IFF_802_1Q_VLAN)

		vlan = vlan_dev_vlan_id(neigh->dev);

	else

		vlan = VLAN_NONE;

	write_lock_bh(&d->lock);

	for (e = d->l2tab[hash].first; e; e = e->next)

		if (!addreq(e, addr) && e->ifindex == ifidx &&

		    e->vlan == vlan && e->lport == lport) {

			l2t_hold(d, e);

			if (atomic_read(&e->refcnt) == 1)

				reuse_entry(e, neigh);

			goto done;

		}

	/* Need to allocate a new entry */

	e = alloc_l2e(d);

	if (e) {

		spin_lock(&e->lock);          /* avoid race with t4_l2t_free */

		e->state = L2T_STATE_RESOLVING;

		memcpy(e->addr, addr, addr_len);

		e->ifindex = ifidx;

		e->hash = hash;

		e->lport = lport;

		e->v6 = addr_len == 16;

		atomic_set(&e->refcnt, 1);

		neigh_replace(e, neigh);

		e->vlan = vlan;

		e->next = d->l2tab[hash].first;

		d->l2tab[hash].first = e;

		spin_unlock(&e->lock);

	}

done:

	write_unlock_bh(&d->lock);

	return e;

}

EXPORT_SYMBOL(cxgb4_l2t_get);

/*

 * Called when address resolution fails for an L2T entry to handle packets

 * on the arpq head.  If a packet specifies a failure handler it is invoked,

 * otherwise the packet is sent to the device.

 */

static void handle_failed_resolution(struct adapter *adap, struct sk_buff *arpq)

{

	while (arpq) {

		struct sk_buff *skb = arpq;

		const struct l2t_skb_cb *cb = L2T_SKB_CB(skb);

		arpq = skb->next;

		skb->next = NULL;

		if (cb->arp_err_handler)

			cb->arp_err_handler(cb->handle, skb);

		else

			t4_ofld_send(adap, skb);

	}

}

/*

 * Called when the host's neighbor layer makes a change to some entry that is

 * loaded into the HW L2 table.

 */

void t4_l2t_update(struct adapter *adap, struct neighbour *neigh)

{

	struct l2t_entry *e;

	struct sk_buff *arpq = NULL;

	struct l2t_data *d = adap->l2t;

	int addr_len = neigh->tbl->key_len;

	u32 *addr = (u32 *) neigh->primary_key;

	int ifidx = neigh->dev->ifindex;

	int hash = addr_hash(addr, addr_len, ifidx);

	read_lock_bh(&d->lock);

	for (e = d->l2tab[hash].first; e; e = e->next)

		if (!addreq(e, addr) && e->ifindex == ifidx) {

			spin_lock(&e->lock);

			if (atomic_read(&e->refcnt))

				goto found;

			spin_unlock(&e->lock);