Orange Pi5 kernel

// SPDX-License-Identifier: GPL-2.0
/*
 * configfs.c - Implementation of configfs interface to the driver stack
 *
 * Copyright (C) 2013-2015 Microchip Technology Germany II GmbH & Co. KG
 */
 
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/configfs.h>
#include <linux/most.h>
 
#define MAX_STRING_SIZE 80
 
struct mdev_link {
<------>struct config_item item;
<------>struct list_head list;
<------>bool create_link;
<------>bool destroy_link;
<------>u16 num_buffers;
<------>u16 buffer_size;
<------>u16 subbuffer_size;
<------>u16 packets_per_xact;
<------>u16 dbr_size;
<------>char datatype[MAX_STRING_SIZE];
<------>char direction[MAX_STRING_SIZE];
<------>char name[MAX_STRING_SIZE];
<------>char device[MAX_STRING_SIZE];
<------>char channel[MAX_STRING_SIZE];
<------>char comp[MAX_STRING_SIZE];
<------>char comp_params[MAX_STRING_SIZE];
};
 
static struct list_head mdev_link_list;
 
static int set_cfg_buffer_size(struct mdev_link *link)
{
<------>return most_set_cfg_buffer_size(link->device, link->channel,
<------><------><------><------><------>link->buffer_size);
}
 
static int set_cfg_subbuffer_size(struct mdev_link *link)
{
<------>return most_set_cfg_subbuffer_size(link->device, link->channel,
<------><------><------><------><------>   link->subbuffer_size);
}
 
static int set_cfg_dbr_size(struct mdev_link *link)
{
<------>return most_set_cfg_dbr_size(link->device, link->channel,
<------><------><------><------>     link->dbr_size);
}
 
static int set_cfg_num_buffers(struct mdev_link *link)
{
<------>return most_set_cfg_num_buffers(link->device, link->channel,
<------><------><------><------><------>link->num_buffers);
}
 
static int set_cfg_packets_xact(struct mdev_link *link)
{
<------>return most_set_cfg_packets_xact(link->device, link->channel,
<------><------><------><------><------> link->packets_per_xact);
}
 
static int set_cfg_direction(struct mdev_link *link)
{
<------>return most_set_cfg_direction(link->device, link->channel,
<------><------><------><------>      link->direction);
}
 
static int set_cfg_datatype(struct mdev_link *link)
{
<------>return most_set_cfg_datatype(link->device, link->channel,
<------><------><------><------>     link->datatype);
}
 
static int (*set_config_val[])(struct mdev_link *link) = {
<------>set_cfg_buffer_size,
<------>set_cfg_subbuffer_size,
<------>set_cfg_dbr_size,
<------>set_cfg_num_buffers,
<------>set_cfg_packets_xact,
<------>set_cfg_direction,
<------>set_cfg_datatype,
};
 
static struct mdev_link *to_mdev_link(struct config_item *item)
{
<------>return container_of(item, struct mdev_link, item);
}
 
static int set_config_and_add_link(struct mdev_link *mdev_link)
{
<------>int i;
<------>int ret;
 
<------>for (i = 0; i < ARRAY_SIZE(set_config_val); i++) {
<------><------>ret = set_config_val[i](mdev_link);
<------><------>if (ret < 0 && ret != -ENODEV) {
<------><------><------>pr_err("Config failed\n");
<------><------><------>return ret;
<------><------>}
<------>}
 
<------>return most_add_link(mdev_link->device, mdev_link->channel,
<------><------><------>     mdev_link->comp, mdev_link->name,
<------><------><------>     mdev_link->comp_params);
}
 
static ssize_t mdev_link_create_link_store(struct config_item *item,
<------><------><------><------><------>   const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
<------>bool tmp;
<------>int ret;
 
<------>ret = kstrtobool(page, &tmp);
<------>if (ret)
<------><------>return ret;
<------>if (!tmp)
<------><------>return count;
<------>ret = set_config_and_add_link(mdev_link);
<------>if (ret && ret != -ENODEV)
<------><------>return ret;
<------>list_add_tail(&mdev_link->list, &mdev_link_list);
<------>mdev_link->create_link = tmp;
<------>mdev_link->destroy_link = false;
 
<------>return count;
}
 
static ssize_t mdev_link_destroy_link_store(struct config_item *item,
<------><------><------><------><------>    const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
<------>bool tmp;
<------>int ret;
 
<------>ret = kstrtobool(page, &tmp);
<------>if (ret)
<------><------>return ret;
<------>if (!tmp)
<------><------>return count;
 
<------>ret = most_remove_link(mdev_link->device, mdev_link->channel,
<------><------><------>       mdev_link->comp);
<------>if (ret)
<------><------>return ret;
<------>if (!list_empty(&mdev_link_list))
<------><------>list_del(&mdev_link->list);
 
<------>mdev_link->destroy_link = tmp;
 
<------>return count;
}
 
static ssize_t mdev_link_direction_show(struct config_item *item, char *page)
{
<------>return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->direction);
}
 
static ssize_t mdev_link_direction_store(struct config_item *item,
<------><------><------><------><------> const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
 
<------>if (!sysfs_streq(page, "dir_rx") && !sysfs_streq(page, "rx") &&
<------>    !sysfs_streq(page, "dir_tx") && !sysfs_streq(page, "tx"))
<------><------>return -EINVAL;
<------>strcpy(mdev_link->direction, page);
<------>strim(mdev_link->direction);
<------>return count;
}
 
static ssize_t mdev_link_datatype_show(struct config_item *item, char *page)
{
<------>return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->datatype);
}
 
static ssize_t mdev_link_datatype_store(struct config_item *item,
<------><------><------><------><------>const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
 
<------>if (!sysfs_streq(page, "control") && !sysfs_streq(page, "async") &&
<------>    !sysfs_streq(page, "sync") && !sysfs_streq(page, "isoc") &&
<------>    !sysfs_streq(page, "isoc_avp"))
<------><------>return -EINVAL;
<------>strcpy(mdev_link->datatype, page);
<------>strim(mdev_link->datatype);
<------>return count;
}
 
static ssize_t mdev_link_device_show(struct config_item *item, char *page)
{
<------>return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->device);
}
 
static ssize_t mdev_link_device_store(struct config_item *item,
<------><------><------><------>      const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
 
<------>strlcpy(mdev_link->device, page, sizeof(mdev_link->device));
<------>strim(mdev_link->device);
<------>return count;
}
 
static ssize_t mdev_link_channel_show(struct config_item *item, char *page)
{
<------>return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->channel);
}
 
static ssize_t mdev_link_channel_store(struct config_item *item,
<------><------><------><------>       const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
 
<------>strlcpy(mdev_link->channel, page, sizeof(mdev_link->channel));
<------>strim(mdev_link->channel);
<------>return count;
}
 
static ssize_t mdev_link_comp_show(struct config_item *item, char *page)
{
<------>return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->comp);
}
 
static ssize_t mdev_link_comp_store(struct config_item *item,
<------><------><------><------>    const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
 
<------>strlcpy(mdev_link->comp, page, sizeof(mdev_link->comp));
<------>strim(mdev_link->comp);
<------>return count;
}
 
static ssize_t mdev_link_comp_params_show(struct config_item *item, char *page)
{
<------>return snprintf(page, PAGE_SIZE, "%s\n",
<------><------><------>to_mdev_link(item)->comp_params);
}
 
static ssize_t mdev_link_comp_params_store(struct config_item *item,
<------><------><------><------><------>   const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
 
<------>strlcpy(mdev_link->comp_params, page, sizeof(mdev_link->comp_params));
<------>strim(mdev_link->comp_params);
<------>return count;
}
 
static ssize_t mdev_link_num_buffers_show(struct config_item *item, char *page)
{
<------>return snprintf(page, PAGE_SIZE, "%d\n",
<------><------><------>to_mdev_link(item)->num_buffers);
}
 
static ssize_t mdev_link_num_buffers_store(struct config_item *item,
<------><------><------><------><------>   const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
<------>int ret;
 
<------>ret = kstrtou16(page, 0, &mdev_link->num_buffers);
<------>if (ret)
<------><------>return ret;
<------>return count;
}
 
static ssize_t mdev_link_buffer_size_show(struct config_item *item, char *page)
{
<------>return snprintf(page, PAGE_SIZE, "%d\n",
<------><------><------>to_mdev_link(item)->buffer_size);
}
 
static ssize_t mdev_link_buffer_size_store(struct config_item *item,
<------><------><------><------><------>   const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
<------>int ret;
 
<------>ret = kstrtou16(page, 0, &mdev_link->buffer_size);
<------>if (ret)
<------><------>return ret;
<------>return count;
}
 
static ssize_t mdev_link_subbuffer_size_show(struct config_item *item,
<------><------><------><------><------>     char *page)
{
<------>return snprintf(page, PAGE_SIZE, "%d\n",
<------><------><------>to_mdev_link(item)->subbuffer_size);
}
 
static ssize_t mdev_link_subbuffer_size_store(struct config_item *item,
<------><------><------><------><------>      const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
<------>int ret;
 
<------>ret = kstrtou16(page, 0, &mdev_link->subbuffer_size);
<------>if (ret)
<------><------>return ret;
<------>return count;
}
 
static ssize_t mdev_link_packets_per_xact_show(struct config_item *item,
<------><------><------><------><------>       char *page)
{
<------>return snprintf(page, PAGE_SIZE, "%d\n",
<------><------><------>to_mdev_link(item)->packets_per_xact);
}
 
static ssize_t mdev_link_packets_per_xact_store(struct config_item *item,
<------><------><------><------><------><------>const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
<------>int ret;
 
<------>ret = kstrtou16(page, 0, &mdev_link->packets_per_xact);
<------>if (ret)
<------><------>return ret;
<------>return count;
}
 
static ssize_t mdev_link_dbr_size_show(struct config_item *item, char *page)
{
<------>return snprintf(page, PAGE_SIZE, "%d\n", to_mdev_link(item)->dbr_size);
}
 
static ssize_t mdev_link_dbr_size_store(struct config_item *item,
<------><------><------><------><------>const char *page, size_t count)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
<------>int ret;
 
<------>ret = kstrtou16(page, 0, &mdev_link->dbr_size);
<------>if (ret)
<------><------>return ret;
<------>return count;
}
 
CONFIGFS_ATTR_WO(mdev_link_, create_link);
CONFIGFS_ATTR_WO(mdev_link_, destroy_link);
CONFIGFS_ATTR(mdev_link_, device);
CONFIGFS_ATTR(mdev_link_, channel);
CONFIGFS_ATTR(mdev_link_, comp);
CONFIGFS_ATTR(mdev_link_, comp_params);
CONFIGFS_ATTR(mdev_link_, num_buffers);
CONFIGFS_ATTR(mdev_link_, buffer_size);
CONFIGFS_ATTR(mdev_link_, subbuffer_size);
CONFIGFS_ATTR(mdev_link_, packets_per_xact);
CONFIGFS_ATTR(mdev_link_, datatype);
CONFIGFS_ATTR(mdev_link_, direction);
CONFIGFS_ATTR(mdev_link_, dbr_size);
 
static struct configfs_attribute *mdev_link_attrs[] = {
<------>&mdev_link_attr_create_link,
<------>&mdev_link_attr_destroy_link,
<------>&mdev_link_attr_device,
<------>&mdev_link_attr_channel,
<------>&mdev_link_attr_comp,
<------>&mdev_link_attr_comp_params,
<------>&mdev_link_attr_num_buffers,
<------>&mdev_link_attr_buffer_size,
<------>&mdev_link_attr_subbuffer_size,
<------>&mdev_link_attr_packets_per_xact,
<------>&mdev_link_attr_datatype,
<------>&mdev_link_attr_direction,
<------>&mdev_link_attr_dbr_size,
<------>NULL,
};
 
static void mdev_link_release(struct config_item *item)
{
<------>struct mdev_link *mdev_link = to_mdev_link(item);
<------>int ret;
 
<------>if (mdev_link->destroy_link)
<------><------>goto free_item;
 
<------>ret = most_remove_link(mdev_link->device, mdev_link->channel,
<------><------><------>       mdev_link->comp);
<------>if (ret) {
<------><------>pr_err("Removing link failed.\n");
<------><------>goto free_item;
<------>}
 
<------>if (!list_empty(&mdev_link_list))
<------><------>list_del(&mdev_link->list);
 
free_item:
<------>kfree(to_mdev_link(item));
}
 
static struct configfs_item_operations mdev_link_item_ops = {
<------>.release		= mdev_link_release,
};
 
static const struct config_item_type mdev_link_type = {
<------>.ct_item_ops	= &mdev_link_item_ops,
<------>.ct_attrs	= mdev_link_attrs,
<------>.ct_owner	= THIS_MODULE,
};
 
struct most_common {
<------>struct config_group group;
<------>struct module *mod;
<------>struct configfs_subsystem subsys;
};
 
static struct most_common *to_most_common(struct configfs_subsystem *subsys)
{
<------>return container_of(subsys, struct most_common, subsys);
}
 
static struct config_item *most_common_make_item(struct config_group *group,
<------><------><------><------><------><------> const char *name)
{
<------>struct mdev_link *mdev_link;
<------>struct most_common *mc = to_most_common(group->cg_subsys);
 
<------>mdev_link = kzalloc(sizeof(*mdev_link), GFP_KERNEL);
<------>if (!mdev_link)
<------><------>return ERR_PTR(-ENOMEM);
 
<------>if (!try_module_get(mc->mod)) {
<------><------>kfree(mdev_link);
<------><------>return ERR_PTR(-ENOLCK);
<------>}
<------>config_item_init_type_name(&mdev_link->item, name,
<------><------><------><------>   &mdev_link_type);
 
<------>if (!strcmp(group->cg_item.ci_namebuf, "most_cdev"))
<------><------>strcpy(mdev_link->comp, "cdev");
<------>else if (!strcmp(group->cg_item.ci_namebuf, "most_net"))
<------><------>strcpy(mdev_link->comp, "net");
<------>else if (!strcmp(group->cg_item.ci_namebuf, "most_video"))
<------><------>strcpy(mdev_link->comp, "video");
<------>strcpy(mdev_link->name, name);
<------>return &mdev_link->item;
}
 
static void most_common_release(struct config_item *item)
{
<------>struct config_group *group = to_config_group(item);
 
<------>kfree(to_most_common(group->cg_subsys));
}
 
static struct configfs_item_operations most_common_item_ops = {
<------>.release	= most_common_release,
};
 
static void most_common_disconnect(struct config_group *group,
<------><------><------><------>   struct config_item *item)
{
<------>struct most_common *mc = to_most_common(group->cg_subsys);
 
<------>module_put(mc->mod);
}
 
static struct configfs_group_operations most_common_group_ops = {
<------>.make_item	= most_common_make_item,
<------>.disconnect_notify = most_common_disconnect,
};
 
static const struct config_item_type most_common_type = {
<------>.ct_item_ops	= &most_common_item_ops,
<------>.ct_group_ops	= &most_common_group_ops,
<------>.ct_owner	= THIS_MODULE,
};
 
static struct most_common most_cdev = {
<------>.subsys = {
<------><------>.su_group = {
<------><------><------>.cg_item = {
<------><------><------><------>.ci_namebuf = "most_cdev",
<------><------><------><------>.ci_type = &most_common_type,
<------><------><------>},
<------><------>},
<------>},
};
 
static struct most_common most_net = {
<------>.subsys = {
<------><------>.su_group = {
<------><------><------>.cg_item = {
<------><------><------><------>.ci_namebuf = "most_net",
<------><------><------><------>.ci_type = &most_common_type,
<------><------><------>},
<------><------>},
<------>},
};
 
static struct most_common most_video = {
<------>.subsys = {
<------><------>.su_group = {
<------><------><------>.cg_item = {
<------><------><------><------>.ci_namebuf = "most_video",
<------><------><------><------>.ci_type = &most_common_type,
<------><------><------>},
<------><------>},
<------>},
};
 
struct most_snd_grp {
<------>struct config_group group;
<------>bool create_card;
<------>struct list_head list;
};
 
static struct most_snd_grp *to_most_snd_grp(struct config_item *item)
{
<------>return container_of(to_config_group(item), struct most_snd_grp, group);
}
 
static struct config_item *most_snd_grp_make_item(struct config_group *group,
<------><------><------><------><------><------>  const char *name)
{
<------>struct mdev_link *mdev_link;
 
<------>mdev_link = kzalloc(sizeof(*mdev_link), GFP_KERNEL);
<------>if (!mdev_link)
<------><------>return ERR_PTR(-ENOMEM);
 
<------>config_item_init_type_name(&mdev_link->item, name, &mdev_link_type);
<------>mdev_link->create_link = false;
<------>strcpy(mdev_link->name, name);
<------>strcpy(mdev_link->comp, "sound");
<------>return &mdev_link->item;
}
 
static ssize_t most_snd_grp_create_card_store(struct config_item *item,
<------><------><------><------><------>      const char *page, size_t count)
{
<------>struct most_snd_grp *snd_grp = to_most_snd_grp(item);
<------>int ret;
<------>bool tmp;
 
<------>ret = kstrtobool(page, &tmp);
<------>if (ret)
<------><------>return ret;
<------>if (tmp) {
<------><------>ret = most_cfg_complete("sound");
<------><------>if (ret)
<------><------><------>return ret;
<------>}
<------>snd_grp->create_card = tmp;
<------>return count;
}
 
CONFIGFS_ATTR_WO(most_snd_grp_, create_card);
 
static struct configfs_attribute *most_snd_grp_attrs[] = {
<------>&most_snd_grp_attr_create_card,
<------>NULL,
};
 
static void most_snd_grp_release(struct config_item *item)
{
<------>struct most_snd_grp *group = to_most_snd_grp(item);
 
<------>list_del(&group->list);
<------>kfree(group);
}
 
static struct configfs_item_operations most_snd_grp_item_ops = {
<------>.release	= most_snd_grp_release,
};
 
static struct configfs_group_operations most_snd_grp_group_ops = {
<------>.make_item	= most_snd_grp_make_item,
};
 
static const struct config_item_type most_snd_grp_type = {
<------>.ct_item_ops	= &most_snd_grp_item_ops,
<------>.ct_group_ops	= &most_snd_grp_group_ops,
<------>.ct_attrs	= most_snd_grp_attrs,
<------>.ct_owner	= THIS_MODULE,
};
 
struct most_sound {
<------>struct configfs_subsystem subsys;
<------>struct list_head soundcard_list;
<------>struct module *mod;
};
 
static struct config_group *most_sound_make_group(struct config_group *group,
<------><------><------><------><------><------>  const char *name)
{
<------>struct most_snd_grp *most;
<------>struct most_sound *ms = container_of(group->cg_subsys,
<------><------><------><------><------>     struct most_sound, subsys);
 
<------>list_for_each_entry(most, &ms->soundcard_list, list) {
<------><------>if (!most->create_card) {
<------><------><------>pr_info("adapter configuration still in progress.\n");
<------><------><------>return ERR_PTR(-EPROTO);
<------><------>}
<------>}
<------>if (!try_module_get(ms->mod))
<------><------>return ERR_PTR(-ENOLCK);
<------>most = kzalloc(sizeof(*most), GFP_KERNEL);
<------>if (!most) {
<------><------>module_put(ms->mod);
<------><------>return ERR_PTR(-ENOMEM);
<------>}
<------>config_group_init_type_name(&most->group, name, &most_snd_grp_type);
<------>list_add_tail(&most->list, &ms->soundcard_list);
<------>return &most->group;
}
 
static void most_sound_disconnect(struct config_group *group,
<------><------><------><------>  struct config_item *item)
{
<------>struct most_sound *ms = container_of(group->cg_subsys,
<------><------><------><------><------>     struct most_sound, subsys);
<------>module_put(ms->mod);
}
 
static struct configfs_group_operations most_sound_group_ops = {
<------>.make_group	= most_sound_make_group,
<------>.disconnect_notify = most_sound_disconnect,
};
 
static const struct config_item_type most_sound_type = {
<------>.ct_group_ops	= &most_sound_group_ops,
<------>.ct_owner	= THIS_MODULE,
};
 
static struct most_sound most_sound_subsys = {
<------>.subsys = {
<------><------>.su_group = {
<------><------><------>.cg_item = {
<------><------><------><------>.ci_namebuf = "most_sound",
<------><------><------><------>.ci_type = &most_sound_type,
<------><------><------>},
<------><------>},
<------>},
};
 
int most_register_configfs_subsys(struct most_component *c)
{
<------>int ret;
 
<------>if (!strcmp(c->name, "cdev")) {
<------><------>most_cdev.mod = c->mod;
<------><------>ret = configfs_register_subsystem(&most_cdev.subsys);
<------>} else if (!strcmp(c->name, "net")) {
<------><------>most_net.mod = c->mod;
<------><------>ret = configfs_register_subsystem(&most_net.subsys);
<------>} else if (!strcmp(c->name, "video")) {
<------><------>most_video.mod = c->mod;
<------><------>ret = configfs_register_subsystem(&most_video.subsys);
<------>} else if (!strcmp(c->name, "sound")) {
<------><------>most_sound_subsys.mod = c->mod;
<------><------>ret = configfs_register_subsystem(&most_sound_subsys.subsys);
<------>} else {
<------><------>return -ENODEV;
<------>}
 
<------>if (ret) {
<------><------>pr_err("Error %d while registering subsystem %s\n",
<------><------>       ret, c->name);
<------>}
<------>return ret;
}
EXPORT_SYMBOL_GPL(most_register_configfs_subsys);
 
void most_interface_register_notify(const char *mdev)
{
<------>bool register_snd_card = false;
<------>struct mdev_link *mdev_link;
 
<------>list_for_each_entry(mdev_link, &mdev_link_list, list) {
<------><------>if (!strcmp(mdev_link->device, mdev)) {
<------><------><------>set_config_and_add_link(mdev_link);
<------><------><------>if (!strcmp(mdev_link->comp, "sound"))
<------><------><------><------>register_snd_card = true;
<------><------>}
<------>}
<------>if (register_snd_card)
<------><------>most_cfg_complete("sound");
}
 
void most_deregister_configfs_subsys(struct most_component *c)
{
<------>if (!strcmp(c->name, "cdev"))
<------><------>configfs_unregister_subsystem(&most_cdev.subsys);
<------>else if (!strcmp(c->name, "net"))
<------><------>configfs_unregister_subsystem(&most_net.subsys);
<------>else if (!strcmp(c->name, "video"))
<------><------>configfs_unregister_subsystem(&most_video.subsys);
<------>else if (!strcmp(c->name, "sound"))
<------><------>configfs_unregister_subsystem(&most_sound_subsys.subsys);
}
EXPORT_SYMBOL_GPL(most_deregister_configfs_subsys);
 
int __init configfs_init(void)
{
<------>config_group_init(&most_cdev.subsys.su_group);
<------>mutex_init(&most_cdev.subsys.su_mutex);
 
<------>config_group_init(&most_net.subsys.su_group);
<------>mutex_init(&most_net.subsys.su_mutex);
 
<------>config_group_init(&most_video.subsys.su_group);
<------>mutex_init(&most_video.subsys.su_mutex);
 
<------>config_group_init(&most_sound_subsys.subsys.su_group);
<------>mutex_init(&most_sound_subsys.subsys.su_mutex);
 
<------>INIT_LIST_HEAD(&most_sound_subsys.soundcard_list);
<------>INIT_LIST_HEAD(&mdev_link_list);
 
<------>return 0;
}