[deliverable/linux.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(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 struct attribute *hdac_dev_attrs[] = {
	&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,
	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;
	if (tree->nodes) {
		for (p = tree->nodes; *p; p++)
			free_widget_node(*p, &widget_node_group);
		kfree(tree->nodes);
	}
	free_widget_node(tree->afg, &widget_afg_group);
	if (tree->root)
		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;

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

	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;
	}

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

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

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