path: root/drivers/uwb/wlp/sysfs.c

/*
 * WiMedia Logical Link Control Protocol (WLP)
 * sysfs functions
 *
 * Copyright (C) 2007 Intel Corporation
 * Reinette Chatre <reinette.chatre@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.
 *
 *
 * FIXME: Docs
 *
 */
#include <linux/wlp.h>

#include "wlp-internal.h"

static
size_t wlp_wss_wssid_e_print(char *buf, size_t bufsize,
			     struct wlp_wssid_e *wssid_e)
{
	size_t used = 0;
	used += scnprintf(buf, bufsize, " WSS: ");
	used += wlp_wss_uuid_print(buf + used, bufsize - used,
				   &wssid_e->wssid);

	if (wssid_e->info != NULL) {
		used += scnprintf(buf + used, bufsize - used, " ");
		used += uwb_mac_addr_print(buf + used, bufsize - used,
					   &wssid_e->info->bcast);
		used += scnprintf(buf + used, bufsize - used, " %u %u %s\n",
				  wssid_e->info->accept_enroll,
				  wssid_e->info->sec_status,
				  wssid_e->info->name);
	}
	return used;
}

/**
 * Print out information learned from neighbor discovery
 *
 * Some fields being printed may not be included in the device discovery
 * information (it is not mandatory). We are thus careful how the
 * information is printed to ensure it is clear to the user what field is
 * being referenced.
 * The information being printed is for one time use - temporary storage is
 * cleaned after it is printed.
 *
 * Ideally sysfs output should be on one line. The information printed here
 * contain a few strings so it will be hard to parse if they are all
 * printed on the same line - without agreeing on a standard field
 * separator.
 */
static
ssize_t wlp_wss_neighborhood_print_remove(struct wlp *wlp, char *buf,
				   size_t bufsize)
{
	size_t used = 0;
	struct wlp_neighbor_e *neighb;
	struct wlp_wssid_e *wssid_e;

	mutex_lock(&wlp->nbmutex);
	used = scnprintf(buf, bufsize, "#Neighbor information\n"
			 "#uuid dev_addr\n"
			 "# Device Name:\n# Model Name:\n# Manufacturer:\n"
			 "# Model Nr:\n# Serial:\n"
			 "# Pri Dev type: CategoryID OUI OUISubdiv "
			 "SubcategoryID\n"
			 "# WSS: WSSID WSS_name accept_enroll sec_status "
			 "bcast\n"
			 "# WSS: WSSID WSS_name accept_enroll sec_status "
			 "bcast\n\n");
	list_for_each_entry(neighb, &wlp->neighbors, node) {
		if (bufsize - used <= 0)
			goto out;
		used += wlp_wss_uuid_print(buf + used, bufsize - used,
					   &neighb->uuid);
		buf[used++] = ' ';
		used += uwb_dev_addr_print(buf + used, bufsize - used,
					   &neighb->uwb_dev->dev_addr);
		if (neighb->info != NULL)
			used += scnprintf(buf + used, bufsize - used,
					  "\n Device Name: %s\n"
					  " Model Name: %s\n"
					  " Manufacturer:%s \n"
					  " Model Nr: %s\n"
					  " Serial: %s\n"
					  " Pri Dev type: "
					  "%u %02x:%02x:%02x %u %u\n",
					  neighb->info->name,
					  neighb->info->model_name,
					  neighb->info->manufacturer,
					  neighb->info->model_nr,
					  neighb->info->serial,
					  neighb->info->prim_dev_type.category,
					  neighb->info->prim_dev_type.OUI[0],
					  neighb->info->prim_dev_type.OUI[1],
					  neighb->info->prim_dev_type.OUI[2],
					  neighb->info->prim_dev_type.OUIsubdiv,
					  neighb->info->prim_dev_type.subID);
		list_for_each_entry(wssid_e, &neighb->wssid, node) {
			used += wlp_wss_wssid_e_print(buf + used,
						      bufsize - used,
						      wssid_e);
		}
		buf[used++] = '\n';
		wlp_remove_neighbor_tmp_info(neighb);
	}


out:
	mutex_unlock(&wlp->nbmutex);
	return used;
}


/**
 * Show properties of all WSS in neighborhood.
 *
 * Will trigger a complete discovery of WSS activated by this device and
 * its neighbors.
 */
ssize_t wlp_neighborhood_show(struct wlp *wlp, char *buf)
{
	wlp_discover(wlp);
	return wlp_wss_neighborhood_print_remove(wlp, buf, PAGE_SIZE);
}
EXPORT_SYMBOL_GPL(wlp_neighborhood_show);

static
ssize_t __wlp_wss_properties_show(struct wlp_wss *wss, char *buf,
				  size_t bufsize)
{
	ssize_t result;

	result = wlp_wss_uuid_print(buf, bufsize, &wss->wssid);
	result += scnprintf(buf + result, bufsize - result, " ");
	result += uwb_mac_addr_print(buf + result, bufsize - result,
				     &wss->bcast);
	result += scnprintf(buf + result, bufsize - result,
			    " 0x%02x %u ", wss->hash, wss->secure_status);
	result += wlp_wss_key_print(buf + result, bufsize - result,
				    wss->master_key);
	result += scnprintf(buf + result, bufsize - result, " 0x%02x ",
			    wss->tag);
	result += uwb_mac_addr_print(buf + result, bufsize - result,
				     &wss->virtual_addr);
	result += scnprintf(buf + result, bufsize - result, " %s", wss->name);
	result += scnprintf(buf + result, bufsize - result,
			    "\n\n#WSSID\n#WSS broadcast address\n"
			    "#WSS hash\n#WSS secure status\n"
			    "#WSS master key\n#WSS local tag\n"
			    "#WSS local virtual EUI-48\n#WSS name\n");
	return result;
}

/**
 * Show which WSS is activated.
 */
ssize_t wlp_wss_activate_show(struct wlp_wss *wss, char *buf)
{
	int result = 0;

	if (mutex_lock_interruptible(&wss->mutex))
		goto out;
	if (wss->state >= WLP_WSS_STATE_ACTIVE)
		result = __wlp_wss_properties_show(wss, buf, PAGE_SIZE);
	else
		result = scnprintf(buf, PAGE_SIZE, "No local WSS active.\n");
	result += scnprintf(buf + result, PAGE_SIZE - result,
			"\n\n"
			"# echo WSSID SECURE_STATUS ACCEPT_ENROLLMENT "
			"NAME #create new WSS\n"
			"# echo WSSID [DEV ADDR] #enroll in and activate "
			"existing WSS, can request registrar\n"
			"#\n"
			"# WSSID is a 16 byte hex array. Eg. 12 A3 3B ... \n"
			"# SECURE_STATUS 0 - unsecure, 1 - secure (default)\n"
			"# ACCEPT_ENROLLMENT 0 - no, 1 - yes (default)\n"
			"# NAME is the text string identifying the WSS\n"
			"# DEV ADDR is the device address of neighbor "
			"that should be registrar. Eg. 32:AB\n");

	mutex_unlock(&wss->mutex);
out:
	return result;

}
EXPORT_SYMBOL_GPL(wlp_wss_activate_show);

/**
 * Create/activate a new WSS or enroll/activate in neighboring WSS
 *
 * The user can provide the WSSID of a WSS in which it wants to enroll.
 * Only the WSSID is necessary if the WSS have been discovered before. If
 * the WSS has not been discovered before, or the user wants to use a
 * particular neighbor as its registrar, then the user can also provide a
 * device address or the neighbor that will be used as registrar.
 *
 * A new WSS is created when the user provides a WSSID, secure status, and
 * WSS name.
 */
ssize_t wlp_wss_activate_store(struct wlp_wss *wss,
			       const char *buf, size_t size)
{
	ssize_t result = -EINVAL;
	struct wlp_uuid wssid;
	struct uwb_dev_addr dev;
	struct uwb_dev_addr bcast = {.data = {0xff, 0xff} };
	char name[65];
	unsigned sec_status, accept;
	memset(name, 0, sizeof(name));
	result = sscanf(buf, "%02hhx %02hhx %02hhx %02hhx "
			"%02hhx %02hhx %02hhx %02hhx "
			"%02hhx %02hhx %02hhx %02hhx "
			"%02hhx %02hhx %02hhx %02hhx "
			"%02hhx:%02hhx",
			&wssid.data[0] , &wssid.data[1],
			&wssid.data[2] , &wssid.data[3],
			&wssid.data[4] , &wssid.data[5],
			&wssid.data[6] , &wssid.data[7],
			&wssid.data[8] , &wssid.data[9],
			&wssid.data[10], &wssid.data[11],
			&wssid.data[12], &wssid.data[13],
			&wssid.data[14], &wssid.data[15],
			&dev.data[1], &dev.data[0]);
	if (result == 16 || result == 17) {
		result = sscanf(buf, "%02hhx %02hhx %02hhx %02hhx "
				"%02hhx %02hhx %02hhx %02hhx "
				"%02hhx %02hhx %02hhx %02hhx "
				"%02hhx %02hhx %02hhx %02hhx "
				"%u %u %64c",
				&wssid.data[0] , &wssid.data[1],
				&wssid.data[2] , &wssid.data[3],
				&wssid.data[4] , &wssid.data[5],
				&wssid.data[6] , &wssid.data[7],
				&wssid.data[8] , &wssid.data[9],
				&wssid.data[10], &wssid.data[11],
				&wssid.data[12], &wssid.data[13],
				&wssid.data[14], &wssid.data[15],
				&sec_status, &accept, name);
		if (result == 16)
			result = wlp_wss_enroll_activate(wss, &wssid, &bcast);
		else if (result == 19) {
			sec_status = sec_status == 0 ? 0 : 1;
			accept = accept == 0 ? 0 : 1;
			/* We read name using %c, so the newline needs to be
			 * removed */
			if (strlen(name) != sizeof(name) - 1)
				name[strlen(name) - 1] = '\0';
			result = wlp_wss_create_activate(wss, &wssid, name,
							 sec_status, accept);
		} else
			result = -EINVAL;
	} else if (result == 18)
		result = wlp_wss_enroll_activate(wss, &wssid, &dev);
	else
		result = -EINVAL;
	return result < 0 ? result : size;
}
EXPORT_SYMBOL_GPL(wlp_wss_activate_store);

/**
 * Show the UUID of this host
 */
ssize_t wlp_uuid_show(struct wlp *wlp, char *buf)
{
	ssize_t result = 0;

	mutex_lock(&wlp->mutex);
	result = wlp_wss_uuid_print(buf, PAGE_SIZE, &wlp->uuid);
	buf[result++] = '\n';
	mutex_unlock(&wlp->mutex);
	return result;
}
EXPORT_SYMBOL_GPL(wlp_uuid_show);

/**
 * Store a new UUID for this host
 *
 * According to the spec this should be encoded as an octet string in the
 * order the octets are shown in string representation in RFC 4122 (WLP
 * 0.99 [Table 6])
 *
 * We do not check value provided by user.
 */
ssize_t wlp_uuid_store(struct wlp *wlp, const char *buf, size_t size)
{
	ssize_t result;
	struct wlp_uuid uuid;

	mutex_lock(&wlp->mutex);
	result = sscanf(buf, "%02hhx %02hhx %02hhx %02hhx "
			"%02hhx %02hhx %02hhx %02hhx "
			"%02hhx %02hhx %02hhx %02hhx "
			"%02hhx %02hhx %02hhx %02hhx ",
			&uuid.data[0] , &uuid.data[1],
			&uuid.data[2] , &uuid.data[3],
			&uuid.data[4] , &uuid.data[5],
			&uuid.data[6] , &uuid.data[7],
			&uuid.data[8] , &uuid.data[9],
			&uuid.data[10], &uuid.data[11],
			&uuid.data[12], &uuid.data[13],
			&uuid.data[14], &uuid.data[15]);
	if (result != 16) {
		result = -EINVAL;
		goto error;
	}
	wlp->uuid = uuid;
error:
	mutex_unlock(&wlp->mutex);
	return result < 0 ? result : size;
}
EXPORT_SYMBOL_GPL(wlp_uuid_store);

/**
 * Show contents of members of device information structure
 */
#define wlp_dev_info_show(type)						\
ssize_t wlp_dev_##type##_show(struct wlp *wlp, char *buf)		\
{									\
	ssize_t result = 0;						\
	mutex_lock(&wlp->mutex);					\
	if (wlp->dev_info == NULL) {					\
		result = __wlp_setup_device_info(wlp);			\
		if (result < 0)						\
			goto out;					\
	}								\
	result = scnprintf(buf, PAGE_SIZE, "%s\n", wlp->dev_info->type);\
out:									\
	mutex_unlock(&wlp->mutex);					\
	return result;							\
}									\
EXPORT_SYMBOL_GPL(wlp_dev_##type##_show);

wlp_dev_info_show(name)
wlp_dev_info_show(model_name)
wlp_dev_info_show(model_nr)
wlp_dev_info_show(manufacturer)
wlp_dev_info_show(serial)

/**
 * Store contents of members of device information structure
 */
#define wlp_dev_info_store(type, len)					\
ssize_t wlp_dev_##type##_store(struct wlp *wlp, const char *buf, size_t size)\
{									\
	ssize_t result;							\
	char format[10];						\
	mutex_lock(&wlp->mutex);					\
	if (wlp->dev_info == NULL) {					\
		result = __wlp_alloc_device_info(wlp);			\
		if (result < 0)						\
			goto out;					\
	}								\
	memset(wlp->dev_info->type, 0, sizeof(wlp->dev_info->type));	\
	sprintf(format, "%%%uc", len);					\
	result = sscanf(buf, format, wlp->dev_info->type);		\
out:									\
	mutex_unlock(&wlp->mutex);					\
	return result < 0 ? result : size;				\
}									\
EXPORT_SYMBOL_GPL(wlp_dev_##type##_store);

wlp_dev_info_store(name, 32)
wlp_dev_info_store(manufacturer, 64)
wlp_dev_info_store(model_name, 32)
wlp_dev_info_store(model_nr, 32)
wlp_dev_info_store(serial, 32)

static
const char *__wlp_dev_category[] = {
	[WLP_DEV_CAT_COMPUTER] = "Computer",
	[WLP_DEV_CAT_INPUT] = "Input device",
	[WLP_DEV_CAT_PRINT_SCAN_FAX_COPIER] = "Printer, scanner, FAX, or "
					      "Copier",
	[WLP_DEV_CAT_CAMERA] = "Camera",
	[WLP_DEV_CAT_STORAGE] = "Storage Network",
	[WLP_DEV_CAT_INFRASTRUCTURE] = "Infrastructure",
	[WLP_DEV_CAT_DISPLAY] = "Display",
	[WLP_DEV_CAT_MULTIM] = "Multimedia device",
	[WLP_DEV_CAT_GAMING] = "Gaming device",
	[WLP_DEV_CAT_TELEPHONE] = "Telephone",
	[WLP_DEV_CAT_OTHER] = "Other",
};

static
const char *wlp_dev_category_str(unsigned cat)
{
	if ((cat >= WLP_DEV_CAT_COMPUTER && cat <= WLP_DEV_CAT_TELEPHONE)
	    || cat == WLP_DEV_CAT_OTHER)
		return __wlp_dev_category[cat];
	return "unknown category";
}

ssize_t wlp_dev_prim_category_show(struct wlp *wlp, char *buf)
{
	ssize_t result = 0;
	mutex_lock(&wlp->mutex);
	if (wlp->dev_info == NULL) {
		result = __wlp_setup_device_info(wlp);
		if (result < 0)
			goto out;
	}
	result = scnprintf(buf, PAGE_SIZE, "%s\n",
		  wlp_dev_category_str(wlp->dev_info->prim_dev_type.category));
out:
	mutex_unlock(&wlp->mutex);
	return result;
}
EXPORT_SYMBOL_GPL(wlp_dev_prim_category_show);

ssize_t wlp_dev_prim_category_store(struct wlp *wlp, const char *buf,
				    size_t size)
{
	ssize_t result;
	u16 cat;
	mutex_lock(&wlp->mutex);
	if (wlp->dev_info == NULL) {
		result = __wlp_alloc_device_info(wlp);
		if (result < 0)
			goto out;
	}
	result = sscanf(buf, "%hu", &cat);
	if ((cat >= WLP_DEV_CAT_COMPUTER && cat <= WLP_DEV_CAT_TELEPHONE)
	    || cat == WLP_DEV_CAT_OTHER)
		wlp->dev_info->prim_dev_type.category = cat;
	else
		result = -EINVAL;
out:
	mutex_unlock(&wlp->mutex);
	return result < 0 ? result : size;
}
EXPORT_SYMBOL_GPL(wlp_dev_prim_category_store);

ssize_t wlp_dev_prim_OUI_show(struct wlp *wlp, char *buf)
{
	ssize_t result = 0;
	mutex_lock(&wlp->mutex);
	if (wlp->dev_info == NULL) {
		result = __wlp_setup_device_info(wlp);
		if (result < 0)
			goto out;
	}
	result = scnprintf(buf, PAGE_SIZE, "%02x:%02x:%02x\n",
			   wlp->dev_info->prim_dev_type.OUI[0],
			   wlp->dev_info->prim_dev_type.OUI[1],
			   wlp->dev_info->prim_dev_type.OUI[2]);
out:
	mutex_unlock(&wlp->mutex);
	return result;
}
EXPORT_SYMBOL_GPL(wlp_dev_prim_OUI_show);

ssize_t wlp_dev_prim_OUI_store(struct wlp *wlp, const char *buf, size_t size)
{
	ssize_t result;
	u8 OUI[3];
	mutex_lock(&wlp->mutex);
	if (wlp->dev_info == NULL) {
		result = __wlp_alloc_device_info(wlp);
		if (result < 0)
			goto out;
	}
	result = sscanf(buf, "%hhx:%hhx:%hhx",
			&OUI[0], &OUI[1], &OUI[2]);
	if (result != 3) {
		result = -EINVAL;
		goto out;
	} else
		memcpy(wlp->dev_info->prim_dev_type.OUI, OUI, sizeof(OUI));
out:
	mutex_unlock(&wlp->mutex);
	return result < 0 ? result : size;
}
EXPORT_SYMBOL_GPL(wlp_dev_prim_OUI_store);


ssize_t wlp_dev_prim_OUI_sub_show(struct wlp *wlp, char *buf)
{
	ssize_t result = 0;
	mutex_lock(&wlp->mutex);
	if (wlp->dev_info == NULL) {
		result = __wlp_setup_device_info(wlp);
		if (result < 0)
			goto out;
	}
	result = scnprintf(buf, PAGE_SIZE, "%u\n",
			   wlp->dev_info->prim_dev_type.OUIsubdiv);
out:
	mutex_unlock(&wlp->mutex);
	return result;
}
EXPORT_SYMBOL_GPL(wlp_dev_prim_OUI_sub_show);

ssize_t wlp_dev_prim_OUI_sub_store(struct wlp *wlp, const char *buf,
				   size_t size)
{
	ssize_t result;
	unsigned sub;
	u8 max_sub = ~0;
	mutex_lock(&wlp->mutex);
	if (wlp->dev_info == NULL) {
		result = __wlp_alloc_device_info(wlp);
		if (result < 0)
			goto out;
	}
	result = sscanf(buf, "%u", &sub);
	if (sub <= max_sub)
		wlp->dev_info->prim_dev_type.OUIsubdiv = sub;
	else
		result = -EINVAL;
out:
	mutex_unlock(&wlp->mutex);
	return result < 0 ? result : size;
}
EXPORT_SYMBOL_GPL(wlp_dev_prim_OUI_sub_store);

ssize_t wlp_dev_prim_subcat_show(struct wlp *wlp, char *buf)
{
	ssize_t result = 0;
	mutex_lock(&wlp->mutex);
	if (wlp->dev_info == NULL) {
		result = __wlp_setup_device_info(wlp);
		if (result < 0)
			goto out;
	}
	result = scnprintf(buf, PAGE_SIZE, "%u\n",
			   wlp->dev_info->prim_dev_type.subID);
out:
	mutex_unlock(&wlp->mutex);
	return result;
}
EXPORT_SYMBOL_GPL(wlp_dev_prim_subcat_show);

ssize_t wlp_dev_prim_subcat_store(struct wlp *wlp, const char *buf,
				  size_t size)
{
	ssize_t result;
	unsigned sub;
	__le16 max_sub = ~0;
	mutex_lock(&wlp->mutex);
	if (wlp->dev_info == NULL) {
		result = __wlp_alloc_device_info(wlp);
		if (result < 0)
			goto out;
	}
	result = sscanf(buf, "%u", &sub);
	if (sub <= max_sub)
		wlp->dev_info->prim_dev_type.subID = sub;
	else
		result = -EINVAL;
out:
	mutex_unlock(&wlp->mutex);
	return result < 0 ? result : size;
}
EXPORT_SYMBOL_GPL(wlp_dev_prim_subcat_store);

/**
 * Subsystem implementation for interaction with individual WSS via sysfs
 *
 * Followed instructions for subsystem in Documentation/filesystems/sysfs.txt
 */

#define kobj_to_wlp_wss(obj) container_of(obj, struct wlp_wss, kobj)
#define attr_to_wlp_wss_attr(_attr) \
	container_of(_attr, struct wlp_wss_attribute, attr)

/**
 * Sysfs subsystem: forward read calls
 *
 * Sysfs operation for forwarding read call to the show method of the
 * attribute owner
 */
static
ssize_t wlp_wss_attr_show(struct kobject *kobj, struct attribute *attr,
			  char *buf)
{
	struct wlp_wss_attribute *wss_attr = attr_to_wlp_wss_attr(attr);
	struct wlp_wss *wss = kobj_to_wlp_wss(kobj);
	ssize_t ret = -EIO;

	if (wss_attr->show)
		ret = wss_attr->show(wss, buf);
	return ret;
}
/**
 * Sysfs subsystem: forward write calls
 *
 * Sysfs operation for forwarding write call to the store method of the
 * attribute owner
 */
static
ssize_t wlp_wss_attr_store(struct kobject *kobj, struct attribute *attr,
			   const char *buf, size_t count)
{
	struct wlp_wss_attribute *wss_attr = attr_to_wlp_wss_attr(attr);
	struct wlp_wss *wss = kobj_to_wlp_wss(kobj);
	ssize_t ret = -EIO;

	if (wss_attr->store)
		ret = wss_attr->store(wss, buf, count);
	return ret;
}

static
struct sysfs_ops wss_sysfs_ops = {
	.show	= wlp_wss_attr_show,
	.store	= wlp_wss_attr_store,
};

struct kobj_type wss_ktype = {
	.release	= wlp_wss_release,
	.sysfs_ops	= &wss_sysfs_ops,
};


/**
 * Sysfs files for individual WSS
 */

/**
 * Print static properties of this WSS
 *
 * The name of a WSS may not be null teminated. It's max size is 64 bytes
 * so we copy it to a larger array just to make sure we print sane data.
 */
static ssize_t wlp_wss_properties_show(struct wlp_wss *wss, char *buf)
{
	int result = 0;

	if (mutex_lock_interruptible(&wss->mutex))
		goto out;
	result = __wlp_wss_properties_show(wss, buf, PAGE_SIZE);
	mutex_unlock(&wss->mutex);
out:
	return result;
}
WSS_ATTR(properties, S_IRUGO, wlp_wss_properties_show, NULL);

/**
 * Print all connected members of this WSS
 * The EDA cache contains all members of WSS neighborhood.
 */
static ssize_t wlp_wss_members_show(struct wlp_wss *wss, char *buf)
{
	struct wlp *wlp = container_of(wss, struct wlp, wss);
	return wlp_eda_show(wlp, buf);
}
WSS_ATTR(members, S_IRUGO, wlp_wss_members_show, NULL);

static
const char *__wlp_strstate[] = {
	"none",
	"partially enrolled",
	"enrolled",
	"active",
	"connected",
};

static const char *wlp_wss_strstate(unsigned state)
{
	if (state >= ARRAY_SIZE(__wlp_strstate))
		return "unknown state";
	return __wlp_strstate[state];
}

/*
 * Print current state of this WSS
 */
static ssize_t wlp_wss_state_show(struct wlp_wss *wss, char *buf)
{
	int result = 0;

	if (mutex_lock_interruptible(&wss->mutex))
		goto out;
	result = scnprintf(buf, PAGE_SIZE, "%s\n",
			   wlp_wss_strstate(wss->state));
	mutex_unlock(&wss->mutex);
out:
	return result;
}
WSS_ATTR(state, S_IRUGO, wlp_wss_state_show, NULL);


static
struct attribute *wss_attrs[] = {
	&wss_attr_properties.attr,
	&wss_attr_members.attr,
	&wss_attr_state.attr,
	NULL,
};

struct attribute_group wss_attr_group = {
	.name = NULL,	/* we want them in the same directory */
	.attrs = wss_attrs,
};