drivers/uwb/wlp/eda.c - kernel/skids - Git at Google

 /*
  * WUSB Wire Adapter: WLP interface
  * Ethernet to device address cache
  *
  * Copyright (C) 2005-2006 Intel Corporation
  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License version
  * 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  * 02110-1301, USA.
  *
  *
  * We need to be able to map ethernet addresses to device addresses
  * and back because there is not explicit relationship between the eth
  * addresses used in the ETH frames and the device addresses (no, it
  * would not have been simpler to force as ETH address the MBOA MAC
  * address...no, not at all :).
  *
  * A device has one MBOA MAC address and one device address. It is possible
  * for a device to have more than one virtual MAC address (although a
  * virtual address can be the same as the MBOA MAC address). The device
  * address is guaranteed to be unique among the devices in the extended
  * beacon group (see ECMA 17.1.1). We thus use the device address as index
  * to this cache. We do allow searching based on virtual address as this
  * is how Ethernet frames will be addressed.
  *
  * We need to support virtual EUI-48. Although, right now the virtual
  * EUI-48 will always be the same as the MAC SAP address. The EDA cache
  * entry thus contains a MAC SAP address as well as the virtual address
  * (used to map the network stack address to a neighbor). When we move
  * to support more than one virtual MAC on a host then this organization
  * will have to change. Perhaps a neighbor has a list of WSSs, each with a
  * tag and virtual EUI-48.
  *
  * On data transmission
  * it is used to determine if the neighbor is connected and what WSS it
  * belongs to. With this we know what tag to add to the WLP frame. Storing
  * the WSS in the EDA cache may be overkill because we only support one
  * WSS. Hopefully we will support more than one WSS at some point.
  * On data reception it is used to determine the WSS based on
  * the tag and address of the transmitting neighbor.
  */

 #include <linux/netdevice.h>
 #include <linux/etherdevice.h>
 #include <linux/slab.h>
 #include <linux/wlp.h>
 #include "wlp-internal.h"


 /* FIXME: cache is not purged, only on device close */

 /* FIXME: does not scale, change to dynamic array */

 /*
  * Initialize the EDA cache
  *
  * @returns 0 if ok, < 0 errno code on error
  *
  * Call when the interface is being brought up
  *
  * NOTE: Keep it as a separate function as the implementation will
  *       change and be more complex.
  */
 void wlp_eda_init(struct wlp_eda *eda)
 {
 	INIT_LIST_HEAD(&eda->cache);
 	spin_lock_init(&eda->lock);
 }

 /*
  * Release the EDA cache
  *
  * @returns 0 if ok, < 0 errno code on error
  *
  * Called when the interface is brought down
  */
 void wlp_eda_release(struct wlp_eda *eda)
 {
 	unsigned long flags;
 	struct wlp_eda_node *itr, *next;

 	spin_lock_irqsave(&eda->lock, flags);
 	list_for_each_entry_safe(itr, next, &eda->cache, list_node) {
 		list_del(&itr->list_node);
 		kfree(itr);
 	}
 	spin_unlock_irqrestore(&eda->lock, flags);
 }

 /*
  * Add an address mapping
  *
  * @returns 0 if ok, < 0 errno code on error
  *
  * An address mapping is initially created when the neighbor device is seen
  * for the first time (it is "onair"). At this time the neighbor is not
  * connected or associated with a WSS so we only populate the Ethernet and
  * Device address fields.
  *
  */
 int wlp_eda_create_node(struct wlp_eda *eda,
 			const unsigned char eth_addr[ETH_ALEN],
 			const struct uwb_dev_addr *dev_addr)
 {
 	int result = 0;
 	struct wlp_eda_node *itr;
 	unsigned long flags;

 	BUG_ON(dev_addr == NULL || eth_addr == NULL);
 	spin_lock_irqsave(&eda->lock, flags);
 	list_for_each_entry(itr, &eda->cache, list_node) {
 		if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
 			printk(KERN_ERR "EDA cache already contains entry "
 			       "for neighbor %02x:%02x\n",
 			       dev_addr->data[1], dev_addr->data[0]);
 			result = -EEXIST;
 			goto out_unlock;
 		}
 	}
 	itr = kzalloc(sizeof(*itr), GFP_ATOMIC);
 	if (itr != NULL) {
 		memcpy(itr->eth_addr, eth_addr, sizeof(itr->eth_addr));
 		itr->dev_addr = *dev_addr;
 		list_add(&itr->list_node, &eda->cache);
 	} else
 		result = -ENOMEM;
 out_unlock:
 	spin_unlock_irqrestore(&eda->lock, flags);
 	return result;
 }

 /*
  * Remove entry from EDA cache
  *
  * This is done when the device goes off air.
  */
 void wlp_eda_rm_node(struct wlp_eda *eda, const struct uwb_dev_addr *dev_addr)
 {
 	struct wlp_eda_node *itr, *next;
 	unsigned long flags;

 	spin_lock_irqsave(&eda->lock, flags);
 	list_for_each_entry_safe(itr, next, &eda->cache, list_node) {
 		if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
 			list_del(&itr->list_node);
 			kfree(itr);
 			break;
 		}
 	}
 	spin_unlock_irqrestore(&eda->lock, flags);
 }

 /*
  * Update an address mapping
  *
  * @returns 0 if ok, < 0 errno code on error
  */
 int wlp_eda_update_node(struct wlp_eda *eda,
 			const struct uwb_dev_addr *dev_addr,
 			struct wlp_wss *wss,
 			const unsigned char virt_addr[ETH_ALEN],
 			const u8 tag, const enum wlp_wss_connect state)
 {
 	int result = -ENOENT;
 	struct wlp_eda_node *itr;
 	unsigned long flags;

 	spin_lock_irqsave(&eda->lock, flags);
 	list_for_each_entry(itr, &eda->cache, list_node) {
 		if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
 			/* Found it, update it */
 			itr->wss = wss;
 			memcpy(itr->virt_addr, virt_addr,
 			       sizeof(itr->virt_addr));
 			itr->tag = tag;
 			itr->state = state;
 			result = 0;
 			goto out_unlock;
 		}
 	}
 	/* Not found */
 out_unlock:
 	spin_unlock_irqrestore(&eda->lock, flags);
 	return result;
 }

 /*
  * Update only state field of an address mapping
  *
  * @returns 0 if ok, < 0 errno code on error
  */
 int wlp_eda_update_node_state(struct wlp_eda *eda,
 			      const struct uwb_dev_addr *dev_addr,
 			      const enum wlp_wss_connect state)
 {
 	int result = -ENOENT;
 	struct wlp_eda_node *itr;
 	unsigned long flags;

 	spin_lock_irqsave(&eda->lock, flags);
 	list_for_each_entry(itr, &eda->cache, list_node) {
 		if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
 			/* Found it, update it */
 			itr->state = state;
 			result = 0;
 			goto out_unlock;
 		}
 	}
 	/* Not found */
 out_unlock:
 	spin_unlock_irqrestore(&eda->lock, flags);
 	return result;
 }

 /*
  * Return contents of EDA cache entry
  *
  * @dev_addr: index to EDA cache
  * @eda_entry: pointer to where contents of EDA cache will be copied
  */
 int wlp_copy_eda_node(struct wlp_eda *eda, struct uwb_dev_addr *dev_addr,
 		      struct wlp_eda_node *eda_entry)
 {
 	int result = -ENOENT;
 	struct wlp_eda_node *itr;
 	unsigned long flags;

 	spin_lock_irqsave(&eda->lock, flags);
 	list_for_each_entry(itr, &eda->cache, list_node) {
 		if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
 			*eda_entry = *itr;
 			result = 0;
 			goto out_unlock;
 		}
 	}
 	/* Not found */
 out_unlock:
 	spin_unlock_irqrestore(&eda->lock, flags);
 	return result;
 }

 /*
  * Execute function for every element in the cache
  *
  * @function: function to execute on element of cache (must be atomic)
  * @priv:     private data of function
  * @returns:  result of first function that failed, or last function
  *            executed if no function failed.
  *
  * Stop executing when function returns error for any element in cache.
  *
  * IMPORTANT: We are using a spinlock here: the function executed on each
  * element has to be atomic.
  */
 int wlp_eda_for_each(struct wlp_eda *eda, wlp_eda_for_each_f function,
 		     void *priv)
 {
 	int result = 0;
 	struct wlp *wlp = container_of(eda, struct wlp, eda);
 	struct wlp_eda_node *entry;
 	unsigned long flags;

 	spin_lock_irqsave(&eda->lock, flags);
 	list_for_each_entry(entry, &eda->cache, list_node) {
 		result = (*function)(wlp, entry, priv);
 		if (result < 0)
 			break;
 	}
 	spin_unlock_irqrestore(&eda->lock, flags);
 	return result;
 }

 /*
  * Execute function for single element in the cache (return dev addr)
  *
  * @virt_addr: index into EDA cache used to determine which element to
  *             execute the function on
  * @dev_addr: device address of element in cache will be returned using
  *            @dev_addr
  * @function: function to execute on element of cache (must be atomic)
  * @priv:     private data of function
  * @returns:  result of function
  *
  * IMPORTANT: We are using a spinlock here: the function executed on the
  * element has to be atomic.
  */
 int wlp_eda_for_virtual(struct wlp_eda *eda,
 			const unsigned char virt_addr[ETH_ALEN],
 			struct uwb_dev_addr *dev_addr,
 			wlp_eda_for_each_f function,
 			void *priv)
 {
 	int result = 0;
 	struct wlp *wlp = container_of(eda, struct wlp, eda);
 	struct wlp_eda_node *itr;
 	unsigned long flags;
 	int found = 0;

 	spin_lock_irqsave(&eda->lock, flags);
 	list_for_each_entry(itr, &eda->cache, list_node) {
 		if (!memcmp(itr->virt_addr, virt_addr,
 			   sizeof(itr->virt_addr))) {
 			result = (*function)(wlp, itr, priv);
 			*dev_addr = itr->dev_addr;
 			found = 1;
 			break;
 		}
 	}
 	if (!found)
 		result = -ENODEV;
 	spin_unlock_irqrestore(&eda->lock, flags);
 	return result;
 }

 static const char *__wlp_wss_connect_state[] = { "WLP_WSS_UNCONNECTED",
 					  "WLP_WSS_CONNECTED",
 					  "WLP_WSS_CONNECT_FAILED",
 };

 static const char *wlp_wss_connect_state_str(unsigned id)
 {
 	if (id >= ARRAY_SIZE(__wlp_wss_connect_state))
 		return "unknown WSS connection state";
 	return __wlp_wss_connect_state[id];
 }

 /*
  * View EDA cache from user space
  *
  * A debugging feature to give user visibility into the EDA cache. Also
  * used to display members of WSS to user (called from wlp_wss_members_show())
  */
 ssize_t wlp_eda_show(struct wlp *wlp, char *buf)
 {
 	ssize_t result = 0;
 	struct wlp_eda_node *entry;
 	unsigned long flags;
 	struct wlp_eda *eda = &wlp->eda;
 	spin_lock_irqsave(&eda->lock, flags);
 	result = scnprintf(buf, PAGE_SIZE, "#eth_addr dev_addr wss_ptr "
 			   "tag state virt_addr\n");
 	list_for_each_entry(entry, &eda->cache, list_node) {
 		result += scnprintf(buf + result, PAGE_SIZE - result,
 				    "%pM %02x:%02x %p 0x%02x %s %pM\n",
 				    entry->eth_addr,
 				    entry->dev_addr.data[1],
 				    entry->dev_addr.data[0], entry->wss,
 				    entry->tag,
 				    wlp_wss_connect_state_str(entry->state),
 				    entry->virt_addr);
 		if (result >= PAGE_SIZE)
 			break;
 	}
 	spin_unlock_irqrestore(&eda->lock, flags);
 	return result;
 }
 EXPORT_SYMBOL_GPL(wlp_eda_show);

 /*
  * Add new EDA cache entry based on user input in sysfs
  *
  * Should only be used for debugging.
  *
  * The WSS is assumed to be the only WSS supported. This needs to be
  * redesigned when we support more than one WSS.
  */
 ssize_t wlp_eda_store(struct wlp *wlp, const char *buf, size_t size)
 {
 	ssize_t result;
 	struct wlp_eda *eda = &wlp->eda;
 	u8 eth_addr[6];
 	struct uwb_dev_addr dev_addr;
 	u8 tag;
 	unsigned state;

 	result = sscanf(buf, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx "
 			"%02hhx:%02hhx %02hhx %u\n",
 			&eth_addr[0], &eth_addr[1],
 			&eth_addr[2], &eth_addr[3],
 			&eth_addr[4], &eth_addr[5],
 			&dev_addr.data[1], &dev_addr.data[0], &tag, &state);
 	switch (result) {
 	case 6: /* no dev addr specified -- remove entry NOT IMPLEMENTED */
 		/*result = wlp_eda_rm(eda, eth_addr, &dev_addr);*/
 		result = -ENOSYS;
 		break;
 	case 10:
 		state = state >= 1 ? 1 : 0;
 		result = wlp_eda_create_node(eda, eth_addr, &dev_addr);
 		if (result < 0 && result != -EEXIST)
 			goto error;
 		/* Set virtual addr to be same as MAC */
 		result = wlp_eda_update_node(eda, &dev_addr, &wlp->wss,
 					     eth_addr, tag, state);
 		if (result < 0)
 			goto error;
 		break;
 	default: /* bad format */
 		result = -EINVAL;
 	}
 error:
 	return result < 0 ? result : size;
 }
 EXPORT_SYMBOL_GPL(wlp_eda_store);
	/*
	* WUSB Wire Adapter: WLP interface
	* Ethernet to device address cache
	*
	* Copyright (C) 2005-2006 Intel Corporation
	* Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License version
	* 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
	* 02110-1301, USA.
	*
	*
	* We need to be able to map ethernet addresses to device addresses
	* and back because there is not explicit relationship between the eth
	* addresses used in the ETH frames and the device addresses (no, it
	* would not have been simpler to force as ETH address the MBOA MAC
	* address...no, not at all :).
	*
	* A device has one MBOA MAC address and one device address. It is possible
	* for a device to have more than one virtual MAC address (although a
	* virtual address can be the same as the MBOA MAC address). The device
	* address is guaranteed to be unique among the devices in the extended
	* beacon group (see ECMA 17.1.1). We thus use the device address as index
	* to this cache. We do allow searching based on virtual address as this
	* is how Ethernet frames will be addressed.
	*
	* We need to support virtual EUI-48. Although, right now the virtual
	* EUI-48 will always be the same as the MAC SAP address. The EDA cache
	* entry thus contains a MAC SAP address as well as the virtual address
	* (used to map the network stack address to a neighbor). When we move
	* to support more than one virtual MAC on a host then this organization
	* will have to change. Perhaps a neighbor has a list of WSSs, each with a
	* tag and virtual EUI-48.
	*
	* On data transmission
	* it is used to determine if the neighbor is connected and what WSS it
	* belongs to. With this we know what tag to add to the WLP frame. Storing
	* the WSS in the EDA cache may be overkill because we only support one
	* WSS. Hopefully we will support more than one WSS at some point.
	* On data reception it is used to determine the WSS based on
	* the tag and address of the transmitting neighbor.
	*/

	#include <linux/netdevice.h>
	#include <linux/etherdevice.h>
	#include <linux/slab.h>
	#include <linux/wlp.h>
	#include "wlp-internal.h"


	/* FIXME: cache is not purged, only on device close */

	/* FIXME: does not scale, change to dynamic array */

	/*
	* Initialize the EDA cache
	*
	* @returns 0 if ok, < 0 errno code on error
	*
	* Call when the interface is being brought up
	*
	* NOTE: Keep it as a separate function as the implementation will
	* change and be more complex.
	*/
	void wlp_eda_init(struct wlp_eda *eda)
	{
	INIT_LIST_HEAD(&eda->cache);
	spin_lock_init(&eda->lock);
	}

	/*
	* Release the EDA cache
	*
	* @returns 0 if ok, < 0 errno code on error
	*
	* Called when the interface is brought down
	*/
	void wlp_eda_release(struct wlp_eda *eda)
	{
	unsigned long flags;
	struct wlp_eda_node itr, next;

	spin_lock_irqsave(&eda->lock, flags);
	list_for_each_entry_safe(itr, next, &eda->cache, list_node) {
	list_del(&itr->list_node);
	kfree(itr);
	}
	spin_unlock_irqrestore(&eda->lock, flags);
	}

	/*
	* Add an address mapping
	*
	* @returns 0 if ok, < 0 errno code on error
	*
	* An address mapping is initially created when the neighbor device is seen
	* for the first time (it is "onair"). At this time the neighbor is not
	* connected or associated with a WSS so we only populate the Ethernet and
	* Device address fields.
	*
	*/
	int wlp_eda_create_node(struct wlp_eda *eda,
	const unsigned char eth_addr[ETH_ALEN],
	const struct uwb_dev_addr *dev_addr)
	{
	int result = 0;
	struct wlp_eda_node *itr;
	unsigned long flags;

	BUG_ON(dev_addr == NULL \|\| eth_addr == NULL);
	spin_lock_irqsave(&eda->lock, flags);
	list_for_each_entry(itr, &eda->cache, list_node) {
	if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
	printk(KERN_ERR "EDA cache already contains entry "
	"for neighbor %02x:%02x\n",
	dev_addr->data[1], dev_addr->data[0]);
	result = -EEXIST;
	goto out_unlock;
	}
	}
	itr = kzalloc(sizeof(*itr), GFP_ATOMIC);
	if (itr != NULL) {
	memcpy(itr->eth_addr, eth_addr, sizeof(itr->eth_addr));
	itr->dev_addr = *dev_addr;
	list_add(&itr->list_node, &eda->cache);
	} else
	result = -ENOMEM;
	out_unlock:
	spin_unlock_irqrestore(&eda->lock, flags);
	return result;
	}

	/*
	* Remove entry from EDA cache
	*
	* This is done when the device goes off air.
	*/
	void wlp_eda_rm_node(struct wlp_eda eda, const struct uwb_dev_addr dev_addr)
	{
	struct wlp_eda_node itr, next;
	unsigned long flags;

	spin_lock_irqsave(&eda->lock, flags);
	list_for_each_entry_safe(itr, next, &eda->cache, list_node) {
	if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
	list_del(&itr->list_node);
	kfree(itr);
	break;
	}
	}
	spin_unlock_irqrestore(&eda->lock, flags);
	}

	/*
	* Update an address mapping
	*
	* @returns 0 if ok, < 0 errno code on error
	*/
	int wlp_eda_update_node(struct wlp_eda *eda,
	const struct uwb_dev_addr *dev_addr,
	struct wlp_wss *wss,
	const unsigned char virt_addr[ETH_ALEN],
	const u8 tag, const enum wlp_wss_connect state)
	{
	int result = -ENOENT;
	struct wlp_eda_node *itr;
	unsigned long flags;

	spin_lock_irqsave(&eda->lock, flags);
	list_for_each_entry(itr, &eda->cache, list_node) {
	if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
	/* Found it, update it */
	itr->wss = wss;
	memcpy(itr->virt_addr, virt_addr,
	sizeof(itr->virt_addr));
	itr->tag = tag;
	itr->state = state;
	result = 0;
	goto out_unlock;
	}
	}
	/* Not found */
	out_unlock:
	spin_unlock_irqrestore(&eda->lock, flags);
	return result;
	}

	/*
	* Update only state field of an address mapping
	*
	* @returns 0 if ok, < 0 errno code on error
	*/
	int wlp_eda_update_node_state(struct wlp_eda *eda,
	const struct uwb_dev_addr *dev_addr,
	const enum wlp_wss_connect state)
	{
	int result = -ENOENT;
	struct wlp_eda_node *itr;
	unsigned long flags;

	spin_lock_irqsave(&eda->lock, flags);
	list_for_each_entry(itr, &eda->cache, list_node) {
	if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
	/* Found it, update it */
	itr->state = state;
	result = 0;
	goto out_unlock;
	}
	}
	/* Not found */
	out_unlock:
	spin_unlock_irqrestore(&eda->lock, flags);
	return result;
	}

	/*
	* Return contents of EDA cache entry
	*
	* @dev_addr: index to EDA cache
	* @eda_entry: pointer to where contents of EDA cache will be copied
	*/
	int wlp_copy_eda_node(struct wlp_eda eda, struct uwb_dev_addr dev_addr,
	struct wlp_eda_node *eda_entry)
	{
	int result = -ENOENT;
	struct wlp_eda_node *itr;
	unsigned long flags;

	spin_lock_irqsave(&eda->lock, flags);
	list_for_each_entry(itr, &eda->cache, list_node) {
	if (!memcmp(&itr->dev_addr, dev_addr, sizeof(itr->dev_addr))) {
	eda_entry = itr;
	result = 0;
	goto out_unlock;
	}
	}
	/* Not found */
	out_unlock:
	spin_unlock_irqrestore(&eda->lock, flags);
	return result;
	}

	/*
	* Execute function for every element in the cache
	*
	* @function: function to execute on element of cache (must be atomic)
	* @priv: private data of function
	* @returns: result of first function that failed, or last function
	* executed if no function failed.
	*
	* Stop executing when function returns error for any element in cache.
	*
	* IMPORTANT: We are using a spinlock here: the function executed on each
	* element has to be atomic.
	*/
	int wlp_eda_for_each(struct wlp_eda *eda, wlp_eda_for_each_f function,
	void *priv)
	{
	int result = 0;
	struct wlp *wlp = container_of(eda, struct wlp, eda);
	struct wlp_eda_node *entry;
	unsigned long flags;

	spin_lock_irqsave(&eda->lock, flags);
	list_for_each_entry(entry, &eda->cache, list_node) {
	result = (*function)(wlp, entry, priv);
	if (result < 0)
	break;
	}
	spin_unlock_irqrestore(&eda->lock, flags);
	return result;
	}

	/*
	* Execute function for single element in the cache (return dev addr)
	*
	* @virt_addr: index into EDA cache used to determine which element to
	* execute the function on
	* @dev_addr: device address of element in cache will be returned using
	* @dev_addr
	* @function: function to execute on element of cache (must be atomic)
	* @priv: private data of function
	* @returns: result of function
	*
	* IMPORTANT: We are using a spinlock here: the function executed on the
	* element has to be atomic.
	*/
	int wlp_eda_for_virtual(struct wlp_eda *eda,
	const unsigned char virt_addr[ETH_ALEN],
	struct uwb_dev_addr *dev_addr,
	wlp_eda_for_each_f function,
	void *priv)
	{
	int result = 0;
	struct wlp *wlp = container_of(eda, struct wlp, eda);
	struct wlp_eda_node *itr;
	unsigned long flags;
	int found = 0;

	spin_lock_irqsave(&eda->lock, flags);
	list_for_each_entry(itr, &eda->cache, list_node) {
	if (!memcmp(itr->virt_addr, virt_addr,
	sizeof(itr->virt_addr))) {
	result = (*function)(wlp, itr, priv);
	*dev_addr = itr->dev_addr;
	found = 1;
	break;
	}
	}
	if (!found)
	result = -ENODEV;
	spin_unlock_irqrestore(&eda->lock, flags);
	return result;
	}

	static const char *__wlp_wss_connect_state[] = { "WLP_WSS_UNCONNECTED",
	"WLP_WSS_CONNECTED",
	"WLP_WSS_CONNECT_FAILED",
	};

	static const char *wlp_wss_connect_state_str(unsigned id)
	{
	if (id >= ARRAY_SIZE(__wlp_wss_connect_state))
	return "unknown WSS connection state";
	return __wlp_wss_connect_state[id];
	}

	/*
	* View EDA cache from user space
	*
	* A debugging feature to give user visibility into the EDA cache. Also
	* used to display members of WSS to user (called from wlp_wss_members_show())
	*/
	ssize_t wlp_eda_show(struct wlp wlp, char buf)
	{
	ssize_t result = 0;
	struct wlp_eda_node *entry;
	unsigned long flags;
	struct wlp_eda *eda = &wlp->eda;
	spin_lock_irqsave(&eda->lock, flags);
	result = scnprintf(buf, PAGE_SIZE, "#eth_addr dev_addr wss_ptr "
	"tag state virt_addr\n");
	list_for_each_entry(entry, &eda->cache, list_node) {
	result += scnprintf(buf + result, PAGE_SIZE - result,
	"%pM %02x:%02x %p 0x%02x %s %pM\n",
	entry->eth_addr,
	entry->dev_addr.data[1],
	entry->dev_addr.data[0], entry->wss,
	entry->tag,
	wlp_wss_connect_state_str(entry->state),
	entry->virt_addr);
	if (result >= PAGE_SIZE)
	break;
	}
	spin_unlock_irqrestore(&eda->lock, flags);
	return result;
	}
	EXPORT_SYMBOL_GPL(wlp_eda_show);

	/*
	* Add new EDA cache entry based on user input in sysfs
	*
	* Should only be used for debugging.
	*
	* The WSS is assumed to be the only WSS supported. This needs to be
	* redesigned when we support more than one WSS.
	*/
	ssize_t wlp_eda_store(struct wlp wlp, const char buf, size_t size)
	{
	ssize_t result;
	struct wlp_eda *eda = &wlp->eda;
	u8 eth_addr[6];
	struct uwb_dev_addr dev_addr;
	u8 tag;
	unsigned state;

	result = sscanf(buf, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx "
	"%02hhx:%02hhx %02hhx %u\n",
	&eth_addr[0], &eth_addr[1],
	&eth_addr[2], &eth_addr[3],
	&eth_addr[4], &eth_addr[5],
	&dev_addr.data[1], &dev_addr.data[0], &tag, &state);
	switch (result) {
	case 6: /* no dev addr specified -- remove entry NOT IMPLEMENTED */
	/result = wlp_eda_rm(eda, eth_addr, &dev_addr);/
	result = -ENOSYS;
	break;
	case 10:
	state = state >= 1 ? 1 : 0;
	result = wlp_eda_create_node(eda, eth_addr, &dev_addr);
	if (result < 0 && result != -EEXIST)
	goto error;
	/* Set virtual addr to be same as MAC */
	result = wlp_eda_update_node(eda, &dev_addr, &wlp->wss,
	eth_addr, tag, state);
	if (result < 0)
	goto error;
	break;
	default: /* bad format */
	result = -EINVAL;
	}
	error:
	return result < 0 ? result : size;
	}
	EXPORT_SYMBOL_GPL(wlp_eda_store);