[linux-2.6-block.git] / sound / hda / hdac_sysfs.c

/*
 * sysfs support for HD-audio core device
 */

#include <linux/slab.h>
#include <linux/sysfs.h>
#include <linux/device.h>
#include <sound/core.h>
#include <sound/hdaudio.h>
#include "local.h"

struct hdac_widget_tree {
	struct kobject *root;
	struct kobject *afg;
	struct kobject **nodes;
};

#define CODEC_ATTR(type)					\
static ssize_t type##_show(struct device *dev,			\
			   struct device_attribute *attr,	\
			   char *buf)				\
{								\
	struct hdac_device *codec = dev_to_hdac_dev(dev);	\
	return sprintf(buf, "0x%x\n", codec->type);		\
} \
static DEVICE_ATTR_RO(type)

#define CODEC_ATTR_STR(type)					\
static ssize_t type##_show(struct device *dev,			\
			     struct device_attribute *attr,	\
					char *buf)		\
{								\
	struct hdac_device *codec = dev_to_hdac_dev(dev);	\
	return sprintf(buf, "%s\n",				\
		       codec->type ? codec->type : "");		\
} \
static DEVICE_ATTR_RO(type)

CODEC_ATTR(type);
CODEC_ATTR(vendor_id);
CODEC_ATTR(subsystem_id);
CODEC_ATTR(revision_id);
CODEC_ATTR(afg);
CODEC_ATTR(mfg);
CODEC_ATTR_STR(vendor_name);
CODEC_ATTR_STR(chip_name);

static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
			     char *buf)
{
	return snd_hdac_codec_modalias(dev_to_hdac_dev(dev), buf, 256);
}
static DEVICE_ATTR_RO(modalias);

static struct attribute *hdac_dev_attrs[] = {
	&dev_attr_type.attr,
	&dev_attr_vendor_id.attr,
	&dev_attr_subsystem_id.attr,
	&dev_attr_revision_id.attr,
	&dev_attr_afg.attr,
	&dev_attr_mfg.attr,
	&dev_attr_vendor_name.attr,
	&dev_attr_chip_name.attr,
	&dev_attr_modalias.attr,
	NULL
};

static struct attribute_group hdac_dev_attr_group = {
	.attrs	= hdac_dev_attrs,
};

const struct attribute_group *hdac_dev_attr_groups[] = {
	&hdac_dev_attr_group,
	NULL
};

/*
 * Widget tree sysfs
 *
 * This is a tree showing the attributes of each widget.  It appears like
 * /sys/bus/hdaudioC0D0/widgets/04/caps
 */

struct widget_attribute;

struct widget_attribute {
	struct attribute	attr;
	ssize_t (*show)(struct hdac_device *codec, hda_nid_t nid,
			struct widget_attribute *attr, char *buf);
	ssize_t (*store)(struct hdac_device *codec, hda_nid_t nid,
			 struct widget_attribute *attr,
			 const char *buf, size_t count);
};

static int get_codec_nid(struct kobject *kobj, struct hdac_device **codecp)
{
	struct device *dev = kobj_to_dev(kobj->parent->parent);
	int nid;
	ssize_t ret;

	ret = kstrtoint(kobj->name, 16, &nid);
	if (ret < 0)
		return ret;
	*codecp = dev_to_hdac_dev(dev);
	return nid;
}

static ssize_t widget_attr_show(struct kobject *kobj, struct attribute *attr,
				char *buf)
{
	struct widget_attribute *wid_attr =
		container_of(attr, struct widget_attribute, attr);
	struct hdac_device *codec;
	int nid;

	if (!wid_attr->show)
		return -EIO;
	nid = get_codec_nid(kobj, &codec);
	if (nid < 0)
		return nid;
	return wid_attr->show(codec, nid, wid_attr, buf);
}

static ssize_t widget_attr_store(struct kobject *kobj, struct attribute *attr,
				 const char *buf, size_t count)
{
	struct widget_attribute *wid_attr =
		container_of(attr, struct widget_attribute, attr);
	struct hdac_device *codec;
	int nid;

	if (!wid_attr->store)
		return -EIO;
	nid = get_codec_nid(kobj, &codec);
	if (nid < 0)
		return nid;
	return wid_attr->store(codec, nid, wid_attr, buf, count);
}

static const struct sysfs_ops widget_sysfs_ops = {
	.show	= widget_attr_show,
	.store	= widget_attr_store,
};

static void widget_release(struct kobject *kobj)
{
	kfree(kobj);
}

static struct kobj_type widget_ktype = {
	.release	= widget_release,
	.sysfs_ops	= &widget_sysfs_ops,
};

#define WIDGET_ATTR_RO(_name) \
	struct widget_attribute wid_attr_##_name = __ATTR_RO(_name)
#define WIDGET_ATTR_RW(_name) \
	struct widget_attribute wid_attr_##_name = __ATTR_RW(_name)

static ssize_t caps_show(struct hdac_device *codec, hda_nid_t nid,
			struct widget_attribute *attr, char *buf)
{
	return sprintf(buf, "0x%08x\n", get_wcaps(codec, nid));
}

static ssize_t pin_caps_show(struct hdac_device *codec, hda_nid_t nid,
			     struct widget_attribute *attr, char *buf)
{
	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
		return 0;
	return sprintf(buf, "0x%08x\n",
		       snd_hdac_read_parm(codec, nid, AC_PAR_PIN_CAP));
}

static ssize_t pin_cfg_show(struct hdac_device *codec, hda_nid_t nid,
			    struct widget_attribute *attr, char *buf)
{
	unsigned int val;

	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
		return 0;
	if (snd_hdac_read(codec, nid, AC_VERB_GET_CONFIG_DEFAULT, 0, &val))
		return 0;
	return sprintf(buf, "0x%08x\n", val);
}

static bool has_pcm_cap(struct hdac_device *codec, hda_nid_t nid)
{
	if (nid == codec->afg || nid == codec->mfg)
		return true;
	switch (get_wcaps_type(get_wcaps(codec, nid))) {
	case AC_WID_AUD_OUT:
	case AC_WID_AUD_IN:
		return true;
	default:
		return false;
	}
}

static ssize_t pcm_caps_show(struct hdac_device *codec, hda_nid_t nid,
			     struct widget_attribute *attr, char *buf)
{
	if (!has_pcm_cap(codec, nid))
		return 0;
	return sprintf(buf, "0x%08x\n",
		       snd_hdac_read_parm(codec, nid, AC_PAR_PCM));
}

static ssize_t pcm_formats_show(struct hdac_device *codec, hda_nid_t nid,
				struct widget_attribute *attr, char *buf)
{
	if (!has_pcm_cap(codec, nid))
		return 0;
	return sprintf(buf, "0x%08x\n",
		       snd_hdac_read_parm(codec, nid, AC_PAR_STREAM));
}

static ssize_t amp_in_caps_show(struct hdac_device *codec, hda_nid_t nid,
				struct widget_attribute *attr, char *buf)
{
	if (nid != codec->afg && !(get_wcaps(codec, nid) & AC_WCAP_IN_AMP))
		return 0;
	return sprintf(buf, "0x%08x\n",
		       snd_hdac_read_parm(codec, nid, AC_PAR_AMP_IN_CAP));
}

static ssize_t amp_out_caps_show(struct hdac_device *codec, hda_nid_t nid,
				 struct widget_attribute *attr, char *buf)
{
	if (nid != codec->afg && !(get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
		return 0;
	return sprintf(buf, "0x%08x\n",
		       snd_hdac_read_parm(codec, nid, AC_PAR_AMP_OUT_CAP));
}

static ssize_t power_caps_show(struct hdac_device *codec, hda_nid_t nid,
			       struct widget_attribute *attr, char *buf)
{
	if (nid != codec->afg && !(get_wcaps(codec, nid) & AC_WCAP_POWER))
		return 0;
	return sprintf(buf, "0x%08x\n",
		       snd_hdac_read_parm(codec, nid, AC_PAR_POWER_STATE));
}

static ssize_t gpio_caps_show(struct hdac_device *codec, hda_nid_t nid,
			      struct widget_attribute *attr, char *buf)
{
	return sprintf(buf, "0x%08x\n",
		       snd_hdac_read_parm(codec, nid, AC_PAR_GPIO_CAP));
}

static ssize_t connections_show(struct hdac_device *codec, hda_nid_t nid,
				struct widget_attribute *attr, char *buf)
{
	hda_nid_t list[32];
	int i, nconns;
	ssize_t ret = 0;

	nconns = snd_hdac_get_connections(codec, nid, list, ARRAY_SIZE(list));
	if (nconns <= 0)
		return nconns;
	for (i = 0; i < nconns; i++)
		ret += sprintf(buf + ret, "%s0x%02x", i ? " " : "", list[i]);
	ret += sprintf(buf + ret, "\n");
	return ret;
}

static WIDGET_ATTR_RO(caps);
static WIDGET_ATTR_RO(pin_caps);
static WIDGET_ATTR_RO(pin_cfg);
static WIDGET_ATTR_RO(pcm_caps);
static WIDGET_ATTR_RO(pcm_formats);
static WIDGET_ATTR_RO(amp_in_caps);
static WIDGET_ATTR_RO(amp_out_caps);
static WIDGET_ATTR_RO(power_caps);
static WIDGET_ATTR_RO(gpio_caps);
static WIDGET_ATTR_RO(connections);

static struct attribute *widget_node_attrs[] = {
	&wid_attr_caps.attr,
	&wid_attr_pin_caps.attr,
	&wid_attr_pin_cfg.attr,
	&wid_attr_pcm_caps.attr,
	&wid_attr_pcm_formats.attr,
	&wid_attr_amp_in_caps.attr,
	&wid_attr_amp_out_caps.attr,
	&wid_attr_power_caps.attr,
	&wid_attr_connections.attr,
	NULL,
};

static struct attribute *widget_afg_attrs[] = {
	&wid_attr_pcm_caps.attr,
	&wid_attr_pcm_formats.attr,
	&wid_attr_amp_in_caps.attr,
	&wid_attr_amp_out_caps.attr,
	&wid_attr_power_caps.attr,
	&wid_attr_gpio_caps.attr,
	NULL,
};

static const struct attribute_group widget_node_group = {
	.attrs = widget_node_attrs,
};

static const struct attribute_group widget_afg_group = {
	.attrs = widget_afg_attrs,
};

static void free_widget_node(struct kobject *kobj,
			     const struct attribute_group *group)
{
	if (kobj) {
		sysfs_remove_group(kobj, group);
		kobject_put(kobj);
	}
}

static void widget_tree_free(struct hdac_device *codec)
{
	struct hdac_widget_tree *tree = codec->widgets;
	struct kobject **p;

	if (!tree)
		return;
	free_widget_node(tree->afg, &widget_afg_group);
	if (tree->nodes) {
		for (p = tree->nodes; *p; p++)
			free_widget_node(*p, &widget_node_group);
		kfree(tree->nodes);
	}
	kobject_put(tree->root);
	kfree(tree);
	codec->widgets = NULL;
}

static int add_widget_node(struct kobject *parent, hda_nid_t nid,
			   const struct attribute_group *group,
			   struct kobject **res)
{
	struct kobject *kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
	int err;

	if (!kobj)
		return -ENOMEM;
	kobject_init(kobj, &widget_ktype);
	err = kobject_add(kobj, parent, "%02x", nid);
	if (err < 0)
		return err;
	err = sysfs_create_group(kobj, group);
	if (err < 0) {
		kobject_put(kobj);
		return err;
	}

	*res = kobj;
	return 0;
}

static int widget_tree_create(struct hdac_device *codec)
{
	struct hdac_widget_tree *tree;
	int i, err;
	hda_nid_t nid;

	tree = codec->widgets = kzalloc(sizeof(*tree), GFP_KERNEL);
	if (!tree)
		return -ENOMEM;

	tree->root = kobject_create_and_add("widgets", &codec->dev.kobj);
	if (!tree->root)
		return -ENOMEM;

	tree->nodes = kcalloc(codec->num_nodes + 1, sizeof(*tree->nodes),
			      GFP_KERNEL);
	if (!tree->nodes)
		return -ENOMEM;

	for (i = 0, nid = codec->start_nid; i < codec->num_nodes; i++, nid++) {
		err = add_widget_node(tree->root, nid, &widget_node_group,
				      &tree->nodes[i]);
		if (err < 0)
			return err;
	}

	if (codec->afg) {
		err = add_widget_node(tree->root, codec->afg,
				      &widget_afg_group, &tree->afg);
		if (err < 0)
			return err;
	}

	kobject_uevent(tree->root, KOBJ_CHANGE);
	return 0;
}

int hda_widget_sysfs_init(struct hdac_device *codec)
{
	int err;

	if (codec->widgets)
		return 0; /* already created */

	err = widget_tree_create(codec);
	if (err < 0) {
		widget_tree_free(codec);
		return err;
	}

	return 0;
}

void hda_widget_sysfs_exit(struct hdac_device *codec)
{
	widget_tree_free(codec);
}
Commit	Line	Data
3256be65 TI	1	/*
	2	* sysfs support for HD-audio core device
	3	*/
	4
	5	#include <linux/slab.h>
	6	#include <linux/sysfs.h>
	7	#include <linux/device.h>
	8	#include <sound/core.h>
	9	#include <sound/hdaudio.h>
	10	#include "local.h"
	11
	12	struct hdac_widget_tree {
	13	struct kobject *root;
	14	struct kobject *afg;
	15	struct kobject **nodes;
	16	};
	17
	18	#define CODEC_ATTR(type) \
	19	static ssize_t type##_show(struct device *dev, \
	20	struct device_attribute *attr, \
	21	char *buf) \
	22	{ \
	23	struct hdac_device *codec = dev_to_hdac_dev(dev); \
	24	return sprintf(buf, "0x%x\n", codec->type); \
	25	} \
	26	static DEVICE_ATTR_RO(type)
	27
	28	#define CODEC_ATTR_STR(type) \
	29	static ssize_t type##_show(struct device *dev, \
	30	struct device_attribute *attr, \
	31	char *buf) \
	32	{ \
	33	struct hdac_device *codec = dev_to_hdac_dev(dev); \
	34	return sprintf(buf, "%s\n", \
	35	codec->type ? codec->type : ""); \
	36	} \
	37	static DEVICE_ATTR_RO(type)
	38
eacf6e0a	39	CODEC_ATTR(type);
3256be65 TI	40	CODEC_ATTR(vendor_id);
	41	CODEC_ATTR(subsystem_id);
	42	CODEC_ATTR(revision_id);
	43	CODEC_ATTR(afg);
	44	CODEC_ATTR(mfg);
	45	CODEC_ATTR_STR(vendor_name);
	46	CODEC_ATTR_STR(chip_name);
	47
78abb2af SP	48	static ssize_t modalias_show(struct device dev, struct device_attribute attr,
	49	char *buf)
	50	{
	51	return snd_hdac_codec_modalias(dev_to_hdac_dev(dev), buf, 256);
	52	}
	53	static DEVICE_ATTR_RO(modalias);
	54
3256be65	55	static struct attribute *hdac_dev_attrs[] = {
eacf6e0a	56	&dev_attr_type.attr,
3256be65 TI	57	&dev_attr_vendor_id.attr,
	58	&dev_attr_subsystem_id.attr,
	59	&dev_attr_revision_id.attr,
	60	&dev_attr_afg.attr,
	61	&dev_attr_mfg.attr,
	62	&dev_attr_vendor_name.attr,
	63	&dev_attr_chip_name.attr,
78abb2af	64	&dev_attr_modalias.attr,
3256be65 TI	65	NULL
	66	};
	67
	68	static struct attribute_group hdac_dev_attr_group = {
	69	.attrs = hdac_dev_attrs,
	70	};
	71
	72	const struct attribute_group *hdac_dev_attr_groups[] = {
	73	&hdac_dev_attr_group,
	74	NULL
	75	};
	76
	77	/*
	78	* Widget tree sysfs
	79	*
	80	* This is a tree showing the attributes of each widget. It appears like
	81	* /sys/bus/hdaudioC0D0/widgets/04/caps
	82	*/
	83
	84	struct widget_attribute;
	85
	86	struct widget_attribute {
	87	struct attribute attr;
	88	ssize_t (show)(struct hdac_device codec, hda_nid_t nid,
	89	struct widget_attribute attr, char buf);
	90	ssize_t (store)(struct hdac_device codec, hda_nid_t nid,
	91	struct widget_attribute *attr,
	92	const char *buf, size_t count);
	93	};
	94
	95	static int get_codec_nid(struct kobject kobj, struct hdac_device *codecp)
	96	{
	97	struct device *dev = kobj_to_dev(kobj->parent->parent);
	98	int nid;
	99	ssize_t ret;
	100
	101	ret = kstrtoint(kobj->name, 16, &nid);
	102	if (ret < 0)
	103	return ret;
	104	*codecp = dev_to_hdac_dev(dev);
	105	return nid;
	106	}
	107
	108	static ssize_t widget_attr_show(struct kobject kobj, struct attribute attr,
	109	char *buf)
	110	{
	111	struct widget_attribute *wid_attr =
	112	container_of(attr, struct widget_attribute, attr);
	113	struct hdac_device *codec;
	114	int nid;
	115
	116	if (!wid_attr->show)
	117	return -EIO;
	118	nid = get_codec_nid(kobj, &codec);
	119	if (nid < 0)
	120	return nid;
	121	return wid_attr->show(codec, nid, wid_attr, buf);
	122	}
	123
	124	static ssize_t widget_attr_store(struct kobject kobj, struct attribute attr,
	125	const char *buf, size_t count)
	126	{
	127	struct widget_attribute *wid_attr =
	128	container_of(attr, struct widget_attribute, attr);
129	struct hdac_device *codec;
130	int nid;
131
132	if (!wid_attr->store)
133	return -EIO;
134	nid = get_codec_nid(kobj, &codec);
135	if (nid < 0)
136	return nid;
137	return wid_attr->store(codec, nid, wid_attr, buf, count);
138	}
139
140	static const struct sysfs_ops widget_sysfs_ops = {
141	.show = widget_attr_show,
142	.store = widget_attr_store,
143	};
144
145	static void widget_release(struct kobject *kobj)
146	{
147	kfree(kobj);
148	}
149
150	static struct kobj_type widget_ktype = {
151	.release = widget_release,
152	.sysfs_ops = &widget_sysfs_ops,
153	};
154
155	#define WIDGET_ATTR_RO(_name) \
156	struct widget_attribute wid_attr_##_name = __ATTR_RO(_name)
157	#define WIDGET_ATTR_RW(_name) \
158	struct widget_attribute wid_attr_##_name = __ATTR_RW(_name)
159
160	static ssize_t caps_show(struct hdac_device *codec, hda_nid_t nid,
161	struct widget_attribute attr, char buf)
162	{
163	return sprintf(buf, "0x%08x\n", get_wcaps(codec, nid));
164	}
165
166	static ssize_t pin_caps_show(struct hdac_device *codec, hda_nid_t nid,
167	struct widget_attribute attr, char buf)
168	{
169	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
170	return 0;
171	return sprintf(buf, "0x%08x\n",
172	snd_hdac_read_parm(codec, nid, AC_PAR_PIN_CAP));
173	}
174
175	static ssize_t pin_cfg_show(struct hdac_device *codec, hda_nid_t nid,
176	struct widget_attribute attr, char buf)
177	{
178	unsigned int val;
179
180	if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
181	return 0;
182	if (snd_hdac_read(codec, nid, AC_VERB_GET_CONFIG_DEFAULT, 0, &val))
183	return 0;
184	return sprintf(buf, "0x%08x\n", val);
185	}
186
187	static bool has_pcm_cap(struct hdac_device *codec, hda_nid_t nid)
188	{
189	if (nid == codec->afg \|\| nid == codec->mfg)
190	return true;
191	switch (get_wcaps_type(get_wcaps(codec, nid))) {
192	case AC_WID_AUD_OUT:
193	case AC_WID_AUD_IN:
194	return true;
195	default:
196	return false;
197	}
198	}
199
200	static ssize_t pcm_caps_show(struct hdac_device *codec, hda_nid_t nid,
201	struct widget_attribute attr, char buf)
202	{
203	if (!has_pcm_cap(codec, nid))
204	return 0;
205	return sprintf(buf, "0x%08x\n",
206	snd_hdac_read_parm(codec, nid, AC_PAR_PCM));
207	}
208
209	static ssize_t pcm_formats_show(struct hdac_device *codec, hda_nid_t nid,
210	struct widget_attribute attr, char buf)
211	{
212	if (!has_pcm_cap(codec, nid))
213	return 0;
214	return sprintf(buf, "0x%08x\n",
215	snd_hdac_read_parm(codec, nid, AC_PAR_STREAM));
216	}
217
218	static ssize_t amp_in_caps_show(struct hdac_device *codec, hda_nid_t nid,
219	struct widget_attribute attr, char buf)
220	{
221	if (nid != codec->afg && !(get_wcaps(codec, nid) & AC_WCAP_IN_AMP))
222	return 0;
223	return sprintf(buf, "0x%08x\n",
224	snd_hdac_read_parm(codec, nid, AC_PAR_AMP_IN_CAP));
225	}
226
227	static ssize_t amp_out_caps_show(struct hdac_device *codec, hda_nid_t nid,
228	struct widget_attribute attr, char buf)
229	{
230	if (nid != codec->afg && !(get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
231	return 0;
232	return sprintf(buf, "0x%08x\n",
233	snd_hdac_read_parm(codec, nid, AC_PAR_AMP_OUT_CAP));
234	}
235
236	static ssize_t power_caps_show(struct hdac_device *codec, hda_nid_t nid,
237	struct widget_attribute attr, char buf)
238	{
239	if (nid != codec->afg && !(get_wcaps(codec, nid) & AC_WCAP_POWER))
240	return 0;
241	return sprintf(buf, "0x%08x\n",
242	snd_hdac_read_parm(codec, nid, AC_PAR_POWER_STATE));
243	}
244
245	static ssize_t gpio_caps_show(struct hdac_device *codec, hda_nid_t nid,
246	struct widget_attribute attr, char buf)
247	{
248	return sprintf(buf, "0x%08x\n",
249	snd_hdac_read_parm(codec, nid, AC_PAR_GPIO_CAP));
250	}
251
252	static ssize_t connections_show(struct hdac_device *codec, hda_nid_t nid,
253	struct widget_attribute attr, char buf)
254	{
255	hda_nid_t list[32];
256	int i, nconns;
257	ssize_t ret = 0;
258
259	nconns = snd_hdac_get_connections(codec, nid, list, ARRAY_SIZE(list));
260	if (nconns <= 0)
261	return nconns;
262	for (i = 0; i < nconns; i++)
263	ret += sprintf(buf + ret, "%s0x%02x", i ? " " : "", list[i]);
264	ret += sprintf(buf + ret, "\n");
265	return ret;
266	}
267
268	static WIDGET_ATTR_RO(caps);
269	static WIDGET_ATTR_RO(pin_caps);
270	static WIDGET_ATTR_RO(pin_cfg);
271	static WIDGET_ATTR_RO(pcm_caps);
272	static WIDGET_ATTR_RO(pcm_formats);
273	static WIDGET_ATTR_RO(amp_in_caps);
274	static WIDGET_ATTR_RO(amp_out_caps);
275	static WIDGET_ATTR_RO(power_caps);
276	static WIDGET_ATTR_RO(gpio_caps);
277	static WIDGET_ATTR_RO(connections);
278
279	static struct attribute *widget_node_attrs[] = {
280	&wid_attr_caps.attr,
281	&wid_attr_pin_caps.attr,
282	&wid_attr_pin_cfg.attr,
283	&wid_attr_pcm_caps.attr,
284	&wid_attr_pcm_formats.attr,
285	&wid_attr_amp_in_caps.attr,
286	&wid_attr_amp_out_caps.attr,
287	&wid_attr_power_caps.attr,
288	&wid_attr_connections.attr,
289	NULL,
290	};
291
292	static struct attribute *widget_afg_attrs[] = {
293	&wid_attr_pcm_caps.attr,
294	&wid_attr_pcm_formats.attr,
295	&wid_attr_amp_in_caps.attr,
296	&wid_attr_amp_out_caps.attr,
297	&wid_attr_power_caps.attr,
298	&wid_attr_gpio_caps.attr,
299	NULL,
300	};
301
302	static const struct attribute_group widget_node_group = {
303	.attrs = widget_node_attrs,
304	};
305
306	static const struct attribute_group widget_afg_group = {
307	.attrs = widget_afg_attrs,
308	};
309
310	static void free_widget_node(struct kobject *kobj,
311	const struct attribute_group *group)
312	{
313	if (kobj) {
314	sysfs_remove_group(kobj, group);
315	kobject_put(kobj);
316	}
317	}
318
319	static void widget_tree_free(struct hdac_device *codec)
320	{
321	struct hdac_widget_tree *tree = codec->widgets;
322	struct kobject **p;
323
324	if (!tree)
325	return;
142267c9	326	free_widget_node(tree->afg, &widget_afg_group);
3256be65 TI	327	if (tree->nodes) {
	328	for (p = tree->nodes; *p; p++)
	329	free_widget_node(*p, &widget_node_group);
	330	kfree(tree->nodes);
	331	}
24d9b755	332	kobject_put(tree->root);
3256be65 TI	333	kfree(tree);
	334	codec->widgets = NULL;
	335	}
	336
	337	static int add_widget_node(struct kobject *parent, hda_nid_t nid,
	338	const struct attribute_group *group,
	339	struct kobject **res)
	340	{
	341	struct kobject kobj = kzalloc(sizeof(kobj), GFP_KERNEL);
	342	int err;
	343
	344	if (!kobj)
	345	return -ENOMEM;
	346	kobject_init(kobj, &widget_ktype);
	347	err = kobject_add(kobj, parent, "%02x", nid);
	348	if (err < 0)
	349	return err;
	350	err = sysfs_create_group(kobj, group);
	351	if (err < 0) {
	352	kobject_put(kobj);
	353	return err;
	354	}
	355
	356	*res = kobj;
	357	return 0;
	358	}
	359
	360	static int widget_tree_create(struct hdac_device *codec)
	361	{
	362	struct hdac_widget_tree *tree;
	363	int i, err;
	364	hda_nid_t nid;
	365
	366	tree = codec->widgets = kzalloc(sizeof(*tree), GFP_KERNEL);
	367	if (!tree)
	368	return -ENOMEM;
	369
	370	tree->root = kobject_create_and_add("widgets", &codec->dev.kobj);
	371	if (!tree->root)
	372	return -ENOMEM;
	373
3256be65 TI	374	tree->nodes = kcalloc(codec->num_nodes + 1, sizeof(*tree->nodes),
	375	GFP_KERNEL);
	376	if (!tree->nodes)
	377	return -ENOMEM;
	378
	379	for (i = 0, nid = codec->start_nid; i < codec->num_nodes; i++, nid++) {
	380	err = add_widget_node(tree->root, nid, &widget_node_group,
	381	&tree->nodes[i]);
	382	if (err < 0)
	383	return err;
	384	}
	385
142267c9 TI	386	if (codec->afg) {
	387	err = add_widget_node(tree->root, codec->afg,
	388	&widget_afg_group, &tree->afg);
	389	if (err < 0)
	390	return err;
	391	}
	392
3256be65 TI	393	kobject_uevent(tree->root, KOBJ_CHANGE);
	394	return 0;
	395	}
	396
	397	int hda_widget_sysfs_init(struct hdac_device *codec)
	398	{
	399	int err;
	400
a92d5ee8 TI	401	if (codec->widgets)
	402	return 0; /* already created */
	403
3256be65 TI	404	err = widget_tree_create(codec);
	405	if (err < 0) {
	406	widget_tree_free(codec);
	407	return err;
	408	}
	409
	410	return 0;
	411	}
	412
	413	void hda_widget_sysfs_exit(struct hdac_device *codec)
	414	{
	415	widget_tree_free(codec);
	416	}