0001
0002
0003
0004
0005
0006
0007
0008 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0009 #include <linux/module.h>
0010 #include <linux/slab.h>
0011 #include <linux/init.h>
0012 #include <linux/configfs.h>
0013 #include <linux/most.h>
0014
0015 #define MAX_STRING_SIZE 80
0016
0017 struct mdev_link {
0018 struct config_item item;
0019 struct list_head list;
0020 bool create_link;
0021 bool destroy_link;
0022 u16 num_buffers;
0023 u16 buffer_size;
0024 u16 subbuffer_size;
0025 u16 packets_per_xact;
0026 u16 dbr_size;
0027 char datatype[MAX_STRING_SIZE];
0028 char direction[MAX_STRING_SIZE];
0029 char name[MAX_STRING_SIZE];
0030 char device[MAX_STRING_SIZE];
0031 char channel[MAX_STRING_SIZE];
0032 char comp[MAX_STRING_SIZE];
0033 char comp_params[MAX_STRING_SIZE];
0034 };
0035
0036 static struct list_head mdev_link_list;
0037
0038 static int set_cfg_buffer_size(struct mdev_link *link)
0039 {
0040 return most_set_cfg_buffer_size(link->device, link->channel,
0041 link->buffer_size);
0042 }
0043
0044 static int set_cfg_subbuffer_size(struct mdev_link *link)
0045 {
0046 return most_set_cfg_subbuffer_size(link->device, link->channel,
0047 link->subbuffer_size);
0048 }
0049
0050 static int set_cfg_dbr_size(struct mdev_link *link)
0051 {
0052 return most_set_cfg_dbr_size(link->device, link->channel,
0053 link->dbr_size);
0054 }
0055
0056 static int set_cfg_num_buffers(struct mdev_link *link)
0057 {
0058 return most_set_cfg_num_buffers(link->device, link->channel,
0059 link->num_buffers);
0060 }
0061
0062 static int set_cfg_packets_xact(struct mdev_link *link)
0063 {
0064 return most_set_cfg_packets_xact(link->device, link->channel,
0065 link->packets_per_xact);
0066 }
0067
0068 static int set_cfg_direction(struct mdev_link *link)
0069 {
0070 return most_set_cfg_direction(link->device, link->channel,
0071 link->direction);
0072 }
0073
0074 static int set_cfg_datatype(struct mdev_link *link)
0075 {
0076 return most_set_cfg_datatype(link->device, link->channel,
0077 link->datatype);
0078 }
0079
0080 static int (*set_config_val[])(struct mdev_link *link) = {
0081 set_cfg_buffer_size,
0082 set_cfg_subbuffer_size,
0083 set_cfg_dbr_size,
0084 set_cfg_num_buffers,
0085 set_cfg_packets_xact,
0086 set_cfg_direction,
0087 set_cfg_datatype,
0088 };
0089
0090 static struct mdev_link *to_mdev_link(struct config_item *item)
0091 {
0092 return container_of(item, struct mdev_link, item);
0093 }
0094
0095 static int set_config_and_add_link(struct mdev_link *mdev_link)
0096 {
0097 int i;
0098 int ret;
0099
0100 for (i = 0; i < ARRAY_SIZE(set_config_val); i++) {
0101 ret = set_config_val[i](mdev_link);
0102 if (ret < 0 && ret != -ENODEV) {
0103 pr_err("Config failed\n");
0104 return ret;
0105 }
0106 }
0107
0108 return most_add_link(mdev_link->device, mdev_link->channel,
0109 mdev_link->comp, mdev_link->name,
0110 mdev_link->comp_params);
0111 }
0112
0113 static ssize_t mdev_link_create_link_store(struct config_item *item,
0114 const char *page, size_t count)
0115 {
0116 struct mdev_link *mdev_link = to_mdev_link(item);
0117 bool tmp;
0118 int ret;
0119
0120 ret = kstrtobool(page, &tmp);
0121 if (ret)
0122 return ret;
0123 if (!tmp)
0124 return count;
0125 ret = set_config_and_add_link(mdev_link);
0126 if (ret && ret != -ENODEV)
0127 return ret;
0128 list_add_tail(&mdev_link->list, &mdev_link_list);
0129 mdev_link->create_link = tmp;
0130 mdev_link->destroy_link = false;
0131
0132 return count;
0133 }
0134
0135 static ssize_t mdev_link_destroy_link_store(struct config_item *item,
0136 const char *page, size_t count)
0137 {
0138 struct mdev_link *mdev_link = to_mdev_link(item);
0139 bool tmp;
0140 int ret;
0141
0142 ret = kstrtobool(page, &tmp);
0143 if (ret)
0144 return ret;
0145 if (!tmp)
0146 return count;
0147
0148 ret = most_remove_link(mdev_link->device, mdev_link->channel,
0149 mdev_link->comp);
0150 if (ret)
0151 return ret;
0152 if (!list_empty(&mdev_link_list))
0153 list_del(&mdev_link->list);
0154
0155 mdev_link->destroy_link = tmp;
0156
0157 return count;
0158 }
0159
0160 static ssize_t mdev_link_direction_show(struct config_item *item, char *page)
0161 {
0162 return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->direction);
0163 }
0164
0165 static ssize_t mdev_link_direction_store(struct config_item *item,
0166 const char *page, size_t count)
0167 {
0168 struct mdev_link *mdev_link = to_mdev_link(item);
0169
0170 if (!sysfs_streq(page, "dir_rx") && !sysfs_streq(page, "rx") &&
0171 !sysfs_streq(page, "dir_tx") && !sysfs_streq(page, "tx"))
0172 return -EINVAL;
0173 strcpy(mdev_link->direction, page);
0174 strim(mdev_link->direction);
0175 return count;
0176 }
0177
0178 static ssize_t mdev_link_datatype_show(struct config_item *item, char *page)
0179 {
0180 return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->datatype);
0181 }
0182
0183 static ssize_t mdev_link_datatype_store(struct config_item *item,
0184 const char *page, size_t count)
0185 {
0186 struct mdev_link *mdev_link = to_mdev_link(item);
0187
0188 if (!sysfs_streq(page, "control") && !sysfs_streq(page, "async") &&
0189 !sysfs_streq(page, "sync") && !sysfs_streq(page, "isoc") &&
0190 !sysfs_streq(page, "isoc_avp"))
0191 return -EINVAL;
0192 strcpy(mdev_link->datatype, page);
0193 strim(mdev_link->datatype);
0194 return count;
0195 }
0196
0197 static ssize_t mdev_link_device_show(struct config_item *item, char *page)
0198 {
0199 return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->device);
0200 }
0201
0202 static ssize_t mdev_link_device_store(struct config_item *item,
0203 const char *page, size_t count)
0204 {
0205 struct mdev_link *mdev_link = to_mdev_link(item);
0206
0207 strlcpy(mdev_link->device, page, sizeof(mdev_link->device));
0208 strim(mdev_link->device);
0209 return count;
0210 }
0211
0212 static ssize_t mdev_link_channel_show(struct config_item *item, char *page)
0213 {
0214 return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->channel);
0215 }
0216
0217 static ssize_t mdev_link_channel_store(struct config_item *item,
0218 const char *page, size_t count)
0219 {
0220 struct mdev_link *mdev_link = to_mdev_link(item);
0221
0222 strlcpy(mdev_link->channel, page, sizeof(mdev_link->channel));
0223 strim(mdev_link->channel);
0224 return count;
0225 }
0226
0227 static ssize_t mdev_link_comp_show(struct config_item *item, char *page)
0228 {
0229 return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->comp);
0230 }
0231
0232 static ssize_t mdev_link_comp_store(struct config_item *item,
0233 const char *page, size_t count)
0234 {
0235 struct mdev_link *mdev_link = to_mdev_link(item);
0236
0237 strlcpy(mdev_link->comp, page, sizeof(mdev_link->comp));
0238 strim(mdev_link->comp);
0239 return count;
0240 }
0241
0242 static ssize_t mdev_link_comp_params_show(struct config_item *item, char *page)
0243 {
0244 return snprintf(page, PAGE_SIZE, "%s\n",
0245 to_mdev_link(item)->comp_params);
0246 }
0247
0248 static ssize_t mdev_link_comp_params_store(struct config_item *item,
0249 const char *page, size_t count)
0250 {
0251 struct mdev_link *mdev_link = to_mdev_link(item);
0252
0253 strlcpy(mdev_link->comp_params, page, sizeof(mdev_link->comp_params));
0254 strim(mdev_link->comp_params);
0255 return count;
0256 }
0257
0258 static ssize_t mdev_link_num_buffers_show(struct config_item *item, char *page)
0259 {
0260 return snprintf(page, PAGE_SIZE, "%d\n",
0261 to_mdev_link(item)->num_buffers);
0262 }
0263
0264 static ssize_t mdev_link_num_buffers_store(struct config_item *item,
0265 const char *page, size_t count)
0266 {
0267 struct mdev_link *mdev_link = to_mdev_link(item);
0268 int ret;
0269
0270 ret = kstrtou16(page, 0, &mdev_link->num_buffers);
0271 if (ret)
0272 return ret;
0273 return count;
0274 }
0275
0276 static ssize_t mdev_link_buffer_size_show(struct config_item *item, char *page)
0277 {
0278 return snprintf(page, PAGE_SIZE, "%d\n",
0279 to_mdev_link(item)->buffer_size);
0280 }
0281
0282 static ssize_t mdev_link_buffer_size_store(struct config_item *item,
0283 const char *page, size_t count)
0284 {
0285 struct mdev_link *mdev_link = to_mdev_link(item);
0286 int ret;
0287
0288 ret = kstrtou16(page, 0, &mdev_link->buffer_size);
0289 if (ret)
0290 return ret;
0291 return count;
0292 }
0293
0294 static ssize_t mdev_link_subbuffer_size_show(struct config_item *item,
0295 char *page)
0296 {
0297 return snprintf(page, PAGE_SIZE, "%d\n",
0298 to_mdev_link(item)->subbuffer_size);
0299 }
0300
0301 static ssize_t mdev_link_subbuffer_size_store(struct config_item *item,
0302 const char *page, size_t count)
0303 {
0304 struct mdev_link *mdev_link = to_mdev_link(item);
0305 int ret;
0306
0307 ret = kstrtou16(page, 0, &mdev_link->subbuffer_size);
0308 if (ret)
0309 return ret;
0310 return count;
0311 }
0312
0313 static ssize_t mdev_link_packets_per_xact_show(struct config_item *item,
0314 char *page)
0315 {
0316 return snprintf(page, PAGE_SIZE, "%d\n",
0317 to_mdev_link(item)->packets_per_xact);
0318 }
0319
0320 static ssize_t mdev_link_packets_per_xact_store(struct config_item *item,
0321 const char *page, size_t count)
0322 {
0323 struct mdev_link *mdev_link = to_mdev_link(item);
0324 int ret;
0325
0326 ret = kstrtou16(page, 0, &mdev_link->packets_per_xact);
0327 if (ret)
0328 return ret;
0329 return count;
0330 }
0331
0332 static ssize_t mdev_link_dbr_size_show(struct config_item *item, char *page)
0333 {
0334 return snprintf(page, PAGE_SIZE, "%d\n", to_mdev_link(item)->dbr_size);
0335 }
0336
0337 static ssize_t mdev_link_dbr_size_store(struct config_item *item,
0338 const char *page, size_t count)
0339 {
0340 struct mdev_link *mdev_link = to_mdev_link(item);
0341 int ret;
0342
0343 ret = kstrtou16(page, 0, &mdev_link->dbr_size);
0344 if (ret)
0345 return ret;
0346 return count;
0347 }
0348
0349 CONFIGFS_ATTR_WO(mdev_link_, create_link);
0350 CONFIGFS_ATTR_WO(mdev_link_, destroy_link);
0351 CONFIGFS_ATTR(mdev_link_, device);
0352 CONFIGFS_ATTR(mdev_link_, channel);
0353 CONFIGFS_ATTR(mdev_link_, comp);
0354 CONFIGFS_ATTR(mdev_link_, comp_params);
0355 CONFIGFS_ATTR(mdev_link_, num_buffers);
0356 CONFIGFS_ATTR(mdev_link_, buffer_size);
0357 CONFIGFS_ATTR(mdev_link_, subbuffer_size);
0358 CONFIGFS_ATTR(mdev_link_, packets_per_xact);
0359 CONFIGFS_ATTR(mdev_link_, datatype);
0360 CONFIGFS_ATTR(mdev_link_, direction);
0361 CONFIGFS_ATTR(mdev_link_, dbr_size);
0362
0363 static struct configfs_attribute *mdev_link_attrs[] = {
0364 &mdev_link_attr_create_link,
0365 &mdev_link_attr_destroy_link,
0366 &mdev_link_attr_device,
0367 &mdev_link_attr_channel,
0368 &mdev_link_attr_comp,
0369 &mdev_link_attr_comp_params,
0370 &mdev_link_attr_num_buffers,
0371 &mdev_link_attr_buffer_size,
0372 &mdev_link_attr_subbuffer_size,
0373 &mdev_link_attr_packets_per_xact,
0374 &mdev_link_attr_datatype,
0375 &mdev_link_attr_direction,
0376 &mdev_link_attr_dbr_size,
0377 NULL,
0378 };
0379
0380 static void mdev_link_release(struct config_item *item)
0381 {
0382 struct mdev_link *mdev_link = to_mdev_link(item);
0383 int ret;
0384
0385 if (mdev_link->destroy_link)
0386 goto free_item;
0387
0388 ret = most_remove_link(mdev_link->device, mdev_link->channel,
0389 mdev_link->comp);
0390 if (ret) {
0391 pr_err("Removing link failed.\n");
0392 goto free_item;
0393 }
0394
0395 if (!list_empty(&mdev_link_list))
0396 list_del(&mdev_link->list);
0397
0398 free_item:
0399 kfree(to_mdev_link(item));
0400 }
0401
0402 static struct configfs_item_operations mdev_link_item_ops = {
0403 .release = mdev_link_release,
0404 };
0405
0406 static const struct config_item_type mdev_link_type = {
0407 .ct_item_ops = &mdev_link_item_ops,
0408 .ct_attrs = mdev_link_attrs,
0409 .ct_owner = THIS_MODULE,
0410 };
0411
0412 struct most_common {
0413 struct config_group group;
0414 struct module *mod;
0415 struct configfs_subsystem subsys;
0416 };
0417
0418 static struct most_common *to_most_common(struct configfs_subsystem *subsys)
0419 {
0420 return container_of(subsys, struct most_common, subsys);
0421 }
0422
0423 static struct config_item *most_common_make_item(struct config_group *group,
0424 const char *name)
0425 {
0426 struct mdev_link *mdev_link;
0427 struct most_common *mc = to_most_common(group->cg_subsys);
0428
0429 mdev_link = kzalloc(sizeof(*mdev_link), GFP_KERNEL);
0430 if (!mdev_link)
0431 return ERR_PTR(-ENOMEM);
0432
0433 if (!try_module_get(mc->mod)) {
0434 kfree(mdev_link);
0435 return ERR_PTR(-ENOLCK);
0436 }
0437 config_item_init_type_name(&mdev_link->item, name,
0438 &mdev_link_type);
0439
0440 if (!strcmp(group->cg_item.ci_namebuf, "most_cdev"))
0441 strcpy(mdev_link->comp, "cdev");
0442 else if (!strcmp(group->cg_item.ci_namebuf, "most_net"))
0443 strcpy(mdev_link->comp, "net");
0444 else if (!strcmp(group->cg_item.ci_namebuf, "most_video"))
0445 strcpy(mdev_link->comp, "video");
0446 strcpy(mdev_link->name, name);
0447 return &mdev_link->item;
0448 }
0449
0450 static void most_common_release(struct config_item *item)
0451 {
0452 struct config_group *group = to_config_group(item);
0453
0454 kfree(to_most_common(group->cg_subsys));
0455 }
0456
0457 static struct configfs_item_operations most_common_item_ops = {
0458 .release = most_common_release,
0459 };
0460
0461 static void most_common_disconnect(struct config_group *group,
0462 struct config_item *item)
0463 {
0464 struct most_common *mc = to_most_common(group->cg_subsys);
0465
0466 module_put(mc->mod);
0467 }
0468
0469 static struct configfs_group_operations most_common_group_ops = {
0470 .make_item = most_common_make_item,
0471 .disconnect_notify = most_common_disconnect,
0472 };
0473
0474 static const struct config_item_type most_common_type = {
0475 .ct_item_ops = &most_common_item_ops,
0476 .ct_group_ops = &most_common_group_ops,
0477 .ct_owner = THIS_MODULE,
0478 };
0479
0480 static struct most_common most_cdev = {
0481 .subsys = {
0482 .su_group = {
0483 .cg_item = {
0484 .ci_namebuf = "most_cdev",
0485 .ci_type = &most_common_type,
0486 },
0487 },
0488 },
0489 };
0490
0491 static struct most_common most_net = {
0492 .subsys = {
0493 .su_group = {
0494 .cg_item = {
0495 .ci_namebuf = "most_net",
0496 .ci_type = &most_common_type,
0497 },
0498 },
0499 },
0500 };
0501
0502 static struct most_common most_video = {
0503 .subsys = {
0504 .su_group = {
0505 .cg_item = {
0506 .ci_namebuf = "most_video",
0507 .ci_type = &most_common_type,
0508 },
0509 },
0510 },
0511 };
0512
0513 struct most_snd_grp {
0514 struct config_group group;
0515 bool create_card;
0516 struct list_head list;
0517 };
0518
0519 static struct most_snd_grp *to_most_snd_grp(struct config_item *item)
0520 {
0521 return container_of(to_config_group(item), struct most_snd_grp, group);
0522 }
0523
0524 static struct config_item *most_snd_grp_make_item(struct config_group *group,
0525 const char *name)
0526 {
0527 struct mdev_link *mdev_link;
0528
0529 mdev_link = kzalloc(sizeof(*mdev_link), GFP_KERNEL);
0530 if (!mdev_link)
0531 return ERR_PTR(-ENOMEM);
0532
0533 config_item_init_type_name(&mdev_link->item, name, &mdev_link_type);
0534 mdev_link->create_link = false;
0535 strcpy(mdev_link->name, name);
0536 strcpy(mdev_link->comp, "sound");
0537 return &mdev_link->item;
0538 }
0539
0540 static ssize_t most_snd_grp_create_card_store(struct config_item *item,
0541 const char *page, size_t count)
0542 {
0543 struct most_snd_grp *snd_grp = to_most_snd_grp(item);
0544 int ret;
0545 bool tmp;
0546
0547 ret = kstrtobool(page, &tmp);
0548 if (ret)
0549 return ret;
0550 if (tmp) {
0551 ret = most_cfg_complete("sound");
0552 if (ret)
0553 return ret;
0554 }
0555 snd_grp->create_card = tmp;
0556 return count;
0557 }
0558
0559 CONFIGFS_ATTR_WO(most_snd_grp_, create_card);
0560
0561 static struct configfs_attribute *most_snd_grp_attrs[] = {
0562 &most_snd_grp_attr_create_card,
0563 NULL,
0564 };
0565
0566 static void most_snd_grp_release(struct config_item *item)
0567 {
0568 struct most_snd_grp *group = to_most_snd_grp(item);
0569
0570 list_del(&group->list);
0571 kfree(group);
0572 }
0573
0574 static struct configfs_item_operations most_snd_grp_item_ops = {
0575 .release = most_snd_grp_release,
0576 };
0577
0578 static struct configfs_group_operations most_snd_grp_group_ops = {
0579 .make_item = most_snd_grp_make_item,
0580 };
0581
0582 static const struct config_item_type most_snd_grp_type = {
0583 .ct_item_ops = &most_snd_grp_item_ops,
0584 .ct_group_ops = &most_snd_grp_group_ops,
0585 .ct_attrs = most_snd_grp_attrs,
0586 .ct_owner = THIS_MODULE,
0587 };
0588
0589 struct most_sound {
0590 struct configfs_subsystem subsys;
0591 struct list_head soundcard_list;
0592 struct module *mod;
0593 };
0594
0595 static struct config_group *most_sound_make_group(struct config_group *group,
0596 const char *name)
0597 {
0598 struct most_snd_grp *most;
0599 struct most_sound *ms = container_of(group->cg_subsys,
0600 struct most_sound, subsys);
0601
0602 list_for_each_entry(most, &ms->soundcard_list, list) {
0603 if (!most->create_card) {
0604 pr_info("adapter configuration still in progress.\n");
0605 return ERR_PTR(-EPROTO);
0606 }
0607 }
0608 if (!try_module_get(ms->mod))
0609 return ERR_PTR(-ENOLCK);
0610 most = kzalloc(sizeof(*most), GFP_KERNEL);
0611 if (!most) {
0612 module_put(ms->mod);
0613 return ERR_PTR(-ENOMEM);
0614 }
0615 config_group_init_type_name(&most->group, name, &most_snd_grp_type);
0616 list_add_tail(&most->list, &ms->soundcard_list);
0617 return &most->group;
0618 }
0619
0620 static void most_sound_disconnect(struct config_group *group,
0621 struct config_item *item)
0622 {
0623 struct most_sound *ms = container_of(group->cg_subsys,
0624 struct most_sound, subsys);
0625 module_put(ms->mod);
0626 }
0627
0628 static struct configfs_group_operations most_sound_group_ops = {
0629 .make_group = most_sound_make_group,
0630 .disconnect_notify = most_sound_disconnect,
0631 };
0632
0633 static const struct config_item_type most_sound_type = {
0634 .ct_group_ops = &most_sound_group_ops,
0635 .ct_owner = THIS_MODULE,
0636 };
0637
0638 static struct most_sound most_sound_subsys = {
0639 .subsys = {
0640 .su_group = {
0641 .cg_item = {
0642 .ci_namebuf = "most_sound",
0643 .ci_type = &most_sound_type,
0644 },
0645 },
0646 },
0647 };
0648
0649 int most_register_configfs_subsys(struct most_component *c)
0650 {
0651 int ret;
0652
0653 if (!strcmp(c->name, "cdev")) {
0654 most_cdev.mod = c->mod;
0655 ret = configfs_register_subsystem(&most_cdev.subsys);
0656 } else if (!strcmp(c->name, "net")) {
0657 most_net.mod = c->mod;
0658 ret = configfs_register_subsystem(&most_net.subsys);
0659 } else if (!strcmp(c->name, "video")) {
0660 most_video.mod = c->mod;
0661 ret = configfs_register_subsystem(&most_video.subsys);
0662 } else if (!strcmp(c->name, "sound")) {
0663 most_sound_subsys.mod = c->mod;
0664 ret = configfs_register_subsystem(&most_sound_subsys.subsys);
0665 } else {
0666 return -ENODEV;
0667 }
0668
0669 if (ret) {
0670 pr_err("Error %d while registering subsystem %s\n",
0671 ret, c->name);
0672 }
0673 return ret;
0674 }
0675 EXPORT_SYMBOL_GPL(most_register_configfs_subsys);
0676
0677 void most_interface_register_notify(const char *mdev)
0678 {
0679 bool register_snd_card = false;
0680 struct mdev_link *mdev_link;
0681
0682 list_for_each_entry(mdev_link, &mdev_link_list, list) {
0683 if (!strcmp(mdev_link->device, mdev)) {
0684 set_config_and_add_link(mdev_link);
0685 if (!strcmp(mdev_link->comp, "sound"))
0686 register_snd_card = true;
0687 }
0688 }
0689 if (register_snd_card)
0690 most_cfg_complete("sound");
0691 }
0692
0693 void most_deregister_configfs_subsys(struct most_component *c)
0694 {
0695 if (!strcmp(c->name, "cdev"))
0696 configfs_unregister_subsystem(&most_cdev.subsys);
0697 else if (!strcmp(c->name, "net"))
0698 configfs_unregister_subsystem(&most_net.subsys);
0699 else if (!strcmp(c->name, "video"))
0700 configfs_unregister_subsystem(&most_video.subsys);
0701 else if (!strcmp(c->name, "sound"))
0702 configfs_unregister_subsystem(&most_sound_subsys.subsys);
0703 }
0704 EXPORT_SYMBOL_GPL(most_deregister_configfs_subsys);
0705
0706 int __init configfs_init(void)
0707 {
0708 config_group_init(&most_cdev.subsys.su_group);
0709 mutex_init(&most_cdev.subsys.su_mutex);
0710
0711 config_group_init(&most_net.subsys.su_group);
0712 mutex_init(&most_net.subsys.su_mutex);
0713
0714 config_group_init(&most_video.subsys.su_group);
0715 mutex_init(&most_video.subsys.su_mutex);
0716
0717 config_group_init(&most_sound_subsys.subsys.su_group);
0718 mutex_init(&most_sound_subsys.subsys.su_mutex);
0719
0720 INIT_LIST_HEAD(&most_sound_subsys.soundcard_list);
0721 INIT_LIST_HEAD(&mdev_link_list);
0722
0723 return 0;
0724 }
