[deliverable/linux.git] / drivers / usb / gadget / function / u_ether_configfs.h

/*
 * u_ether_configfs.h
 *
 * Utility definitions for configfs support in USB Ethernet functions
 *
 * Copyright (c) 2013 Samsung Electronics Co., Ltd.
 *		http://www.samsung.com
 *
 * Author: Andrzej Pietrasiewicz <andrzej.p@samsung.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.
 */

#ifndef __U_ETHER_CONFIGFS_H
#define __U_ETHER_CONFIGFS_H

#define USB_ETHERNET_CONFIGFS_ITEM(_f_)					\
	static void _f_##_attr_release(struct config_item *item)	\
	{								\
		struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item);	\
									\
		usb_put_function_instance(&opts->func_inst);		\
	}								\
									\
	static struct configfs_item_operations _f_##_item_ops = {	\
		.release	= _f_##_attr_release,			\
	}

#define USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(_f_)			\
	static ssize_t _f_##_opts_dev_addr_show(struct config_item *item, \
						char *page)		\
	{								\
		struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item);	\
		int result;						\
									\
		mutex_lock(&opts->lock);				\
		result = gether_get_dev_addr(opts->net, page, PAGE_SIZE); \
		mutex_unlock(&opts->lock);				\
									\
		return result;						\
	}								\
									\
	static ssize_t _f_##_opts_dev_addr_store(struct config_item *item, \
						 const char *page, size_t len)\
	{								\
		struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item);	\
		int ret;						\
									\
		mutex_lock(&opts->lock);				\
		if (opts->refcnt) {					\
			mutex_unlock(&opts->lock);			\
			return -EBUSY;					\
		}							\
									\
		ret = gether_set_dev_addr(opts->net, page);		\
		mutex_unlock(&opts->lock);				\
		if (!ret)						\
			ret = len;					\
		return ret;						\
	}								\
									\
	CONFIGFS_ATTR(_f_##_opts_, dev_addr)

#define USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(_f_)			\
	static ssize_t _f_##_opts_host_addr_show(struct config_item *item, \
						 char *page)		\
	{								\
		struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item);	\
		int result;						\
									\
		mutex_lock(&opts->lock);				\
		result = gether_get_host_addr(opts->net, page, PAGE_SIZE); \
		mutex_unlock(&opts->lock);				\
									\
		return result;						\
	}								\
									\
	static ssize_t _f_##_opts_host_addr_store(struct config_item *item, \
						  const char *page, size_t len)\
	{								\
		struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item);	\
		int ret;						\
									\
		mutex_lock(&opts->lock);				\
		if (opts->refcnt) {					\
			mutex_unlock(&opts->lock);			\
			return -EBUSY;					\
		}							\
									\
		ret = gether_set_host_addr(opts->net, page);		\
		mutex_unlock(&opts->lock);				\
		if (!ret)						\
			ret = len;					\
		return ret;						\
	}								\
									\
	CONFIGFS_ATTR(_f_##_opts_, host_addr)

#define USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(_f_)			\
	static ssize_t _f_##_opts_qmult_show(struct config_item *item,	\
					     char *page)		\
	{								\
		struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item);	\
		unsigned qmult;						\
									\
		mutex_lock(&opts->lock);				\
		qmult = gether_get_qmult(opts->net);			\
		mutex_unlock(&opts->lock);				\
		return sprintf(page, "%d", qmult);			\
	}								\
									\
	static ssize_t _f_##_opts_qmult_store(struct config_item *item, \
					      const char *page, size_t len)\
	{								\
		struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item);	\
		u8 val;							\
		int ret;						\
									\
		mutex_lock(&opts->lock);				\
		if (opts->refcnt) {					\
			ret = -EBUSY;					\
			goto out;					\
		}							\
									\
		ret = kstrtou8(page, 0, &val);				\
		if (ret)						\
			goto out;					\
									\
		gether_set_qmult(opts->net, val);			\
		ret = len;						\
out:									\
		mutex_unlock(&opts->lock);				\
		return ret;						\
	}								\
									\
	CONFIGFS_ATTR(_f_##_opts_, qmult)

#define USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(_f_)			\
	static ssize_t _f_##_opts_ifname_show(struct config_item *item, \
					      char *page)		\
	{								\
		struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item);	\
		int ret;						\
									\
		mutex_lock(&opts->lock);				\
		ret = gether_get_ifname(opts->net, page, PAGE_SIZE);	\
		mutex_unlock(&opts->lock);				\
									\
		return ret;						\
	}								\
									\
	CONFIGFS_ATTR_RO(_f_##_opts_, ifname)

#endif /* __U_ETHER_CONFIGFS_H */
Commit	Line	Data
aa83c6ad AP	1	/*
	2	* u_ether_configfs.h
	3	*
	4	* Utility definitions for configfs support in USB Ethernet functions
	5	*
	6	* Copyright (c) 2013 Samsung Electronics Co., Ltd.
	7	* http://www.samsung.com
	8	*
	9	* Author: Andrzej Pietrasiewicz <andrzej.p@samsung.com>
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License version 2 as
	13	* published by the Free Software Foundation.
	14	*/
	15
	16	#ifndef __U_ETHER_CONFIGFS_H
	17	#define __U_ETHER_CONFIGFS_H
	18
	19	#define USB_ETHERNET_CONFIGFS_ITEM(_f_) \
aa83c6ad AP	20	static void _f_##_attr_release(struct config_item *item) \
	21	{ \
	22	struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item); \
	23	\
	24	usb_put_function_instance(&opts->func_inst); \
	25	} \
	26	\
	27	static struct configfs_item_operations _f_##_item_ops = { \
	28	.release = _f_##_attr_release, \
aa83c6ad AP	29	}
	30
	31	#define USB_ETHERNET_CONFIGFS_ITEM_ATTR_DEV_ADDR(_f_) \
f9a63da3	32	static ssize_t _f_##_opts_dev_addr_show(struct config_item *item, \
aa83c6ad AP	33	char *page) \
aa83c6ad AP	34	{ \
f9a63da3	35	struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item); \
aa83c6ad AP	36	int result; \
	37	\
	38	mutex_lock(&opts->lock); \
	39	result = gether_get_dev_addr(opts->net, page, PAGE_SIZE); \
	40	mutex_unlock(&opts->lock); \
	41	\
	42	return result; \
	43	} \
	44	\
f9a63da3	45	static ssize_t _f_##_opts_dev_addr_store(struct config_item *item, \
aa83c6ad AP	46	const char *page, size_t len)\
aa83c6ad AP	47	{ \
f9a63da3	48	struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item); \
aa83c6ad AP	49	int ret; \
	50	\
	51	mutex_lock(&opts->lock); \
	52	if (opts->refcnt) { \
	53	mutex_unlock(&opts->lock); \
	54	return -EBUSY; \
	55	} \
	56	\
	57	ret = gether_set_dev_addr(opts->net, page); \
	58	mutex_unlock(&opts->lock); \
	59	if (!ret) \
	60	ret = len; \
	61	return ret; \
	62	} \
	63	\
f9a63da3	64	CONFIGFS_ATTR(_f_##_opts_, dev_addr)
aa83c6ad AP	65
aa83c6ad AP	66	#define USB_ETHERNET_CONFIGFS_ITEM_ATTR_HOST_ADDR(_f_) \
f9a63da3	67	static ssize_t _f_##_opts_host_addr_show(struct config_item *item, \
aa83c6ad AP	68	char *page) \
aa83c6ad AP	69	{ \
f9a63da3	70	struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item); \
aa83c6ad AP	71	int result; \
	72	\
	73	mutex_lock(&opts->lock); \
	74	result = gether_get_host_addr(opts->net, page, PAGE_SIZE); \
	75	mutex_unlock(&opts->lock); \
	76	\
	77	return result; \
	78	} \
	79	\
f9a63da3	80	static ssize_t _f_##_opts_host_addr_store(struct config_item *item, \
aa83c6ad AP	81	const char *page, size_t len)\
aa83c6ad AP	82	{ \
f9a63da3	83	struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item); \
aa83c6ad AP	84	int ret; \
	85	\
	86	mutex_lock(&opts->lock); \
	87	if (opts->refcnt) { \
	88	mutex_unlock(&opts->lock); \
	89	return -EBUSY; \
	90	} \
	91	\
	92	ret = gether_set_host_addr(opts->net, page); \
	93	mutex_unlock(&opts->lock); \
	94	if (!ret) \
	95	ret = len; \
	96	return ret; \
	97	} \
	98	\
f9a63da3	99	CONFIGFS_ATTR(_f_##_opts_, host_addr)
aa83c6ad AP	100
aa83c6ad AP	101	#define USB_ETHERNET_CONFIGFS_ITEM_ATTR_QMULT(_f_) \
f9a63da3	102	static ssize_t _f_##_opts_qmult_show(struct config_item *item, \
aa83c6ad AP	103	char *page) \
aa83c6ad AP	104	{ \
f9a63da3	105	struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item); \
aa83c6ad AP	106	unsigned qmult; \
	107	\
	108	mutex_lock(&opts->lock); \
	109	qmult = gether_get_qmult(opts->net); \
	110	mutex_unlock(&opts->lock); \
	111	return sprintf(page, "%d", qmult); \
	112	} \
	113	\
f9a63da3	114	static ssize_t _f_##_opts_qmult_store(struct config_item *item, \
aa83c6ad AP	115	const char *page, size_t len)\
aa83c6ad AP	116	{ \
f9a63da3	117	struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item); \
aa83c6ad AP	118	u8 val; \
	119	int ret; \
	120	\
	121	mutex_lock(&opts->lock); \
	122	if (opts->refcnt) { \
	123	ret = -EBUSY; \
	124	goto out; \
	125	} \
	126	\
	127	ret = kstrtou8(page, 0, &val); \
	128	if (ret) \
	129	goto out; \
	130	\
	131	gether_set_qmult(opts->net, val); \
	132	ret = len; \
	133	out: \
	134	mutex_unlock(&opts->lock); \
	135	return ret; \
	136	} \
	137	\
f9a63da3	138	CONFIGFS_ATTR(_f_##_opts_, qmult)
aa83c6ad AP	139
aa83c6ad AP	140	#define USB_ETHERNET_CONFIGFS_ITEM_ATTR_IFNAME(_f_) \
f9a63da3	141	static ssize_t _f_##_opts_ifname_show(struct config_item *item, \
aa83c6ad AP	142	char *page) \
aa83c6ad AP	143	{ \
f9a63da3	144	struct f_##_f_##_opts *opts = to_f_##_f_##_opts(item); \
aa83c6ad AP	145	int ret; \
	146	\
	147	mutex_lock(&opts->lock); \
	148	ret = gether_get_ifname(opts->net, page, PAGE_SIZE); \
	149	mutex_unlock(&opts->lock); \
	150	\
	151	return ret; \
	152	} \
	153	\
f9a63da3	154	CONFIGFS_ATTR_RO(_f_##_opts_, ifname)
aa83c6ad AP	155
aa83c6ad AP	156	#endif /* __U_ETHER_CONFIGFS_H */