drivers/staging/most/configfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * configfs.c - Implementation of configfs interface to the driver stack
   4  *
   5  * Copyright (C) 2013-2015 Microchip Technology Germany II GmbH & Co. KG
   6  */
   7
   8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
   9 #include <linux/module.h>
  10 #include <linux/slab.h>
  11 #include <linux/init.h>
  12 #include <linux/configfs.h>
  13
  14 #include "most.h"
  15
  16 #define MAX_STRING_SIZE 80
  17
  18 struct mdev_link {
  19         struct config_item item;
  20         struct list_head list;
  21         bool create_link;
  22         bool destroy_link;
  23         u16 num_buffers;
  24         u16 buffer_size;
  25         u16 subbuffer_size;
  26         u16 packets_per_xact;
  27         u16 dbr_size;
  28         char datatype[MAX_STRING_SIZE];
  29         char direction[MAX_STRING_SIZE];
  30         char name[MAX_STRING_SIZE];
  31         char device[MAX_STRING_SIZE];
  32         char channel[MAX_STRING_SIZE];
  33         char comp[MAX_STRING_SIZE];
  34         char comp_params[MAX_STRING_SIZE];
  35 };
  36
  37 static struct list_head mdev_link_list;
  38
  39 static int set_cfg_buffer_size(struct mdev_link *link)
  40 {
  41         return most_set_cfg_buffer_size(link->device, link->channel,
  42                                         link->buffer_size);
  43 }
  44
  45 static int set_cfg_subbuffer_size(struct mdev_link *link)
  46 {
  47         return most_set_cfg_subbuffer_size(link->device, link->channel,
  48                                            link->subbuffer_size);
  49 }
  50
  51 static int set_cfg_dbr_size(struct mdev_link *link)
  52 {
  53         return most_set_cfg_dbr_size(link->device, link->channel,
  54                                      link->dbr_size);
  55 }
  56
  57 static int set_cfg_num_buffers(struct mdev_link *link)
  58 {
  59         return most_set_cfg_num_buffers(link->device, link->channel,
  60                                         link->num_buffers);
  61 }
  62
  63 static int set_cfg_packets_xact(struct mdev_link *link)
  64 {
  65         return most_set_cfg_packets_xact(link->device, link->channel,
  66                                          link->packets_per_xact);
  67 }
  68
  69 static int set_cfg_direction(struct mdev_link *link)
  70 {
  71         return most_set_cfg_direction(link->device, link->channel,
  72                                       link->direction);
  73 }
  74
  75 static int set_cfg_datatype(struct mdev_link *link)
  76 {
  77         return most_set_cfg_datatype(link->device, link->channel,
  78                                      link->datatype);
  79 }
  80
  81 static int (*set_config_val[])(struct mdev_link *link) = {
  82         set_cfg_buffer_size,
  83         set_cfg_subbuffer_size,
  84         set_cfg_dbr_size,
  85         set_cfg_num_buffers,
  86         set_cfg_packets_xact,
  87         set_cfg_direction,
  88         set_cfg_datatype,
  89 };
  90
  91 static struct mdev_link *to_mdev_link(struct config_item *item)
  92 {
  93         return container_of(item, struct mdev_link, item);
  94 }
  95
  96 static int set_config_and_add_link(struct mdev_link *mdev_link)
  97 {
  98         int i;
  99         int ret;
 100
 101         for (i = 0; i < ARRAY_SIZE(set_config_val); i++) {
 102                 ret = set_config_val[i](mdev_link);
 103                 if (ret < 0 && ret != -ENODEV) {
 104                         pr_err("Config failed\n");
 105                         return ret;
 106                 }
 107         }
 108
 109         return most_add_link(mdev_link->device, mdev_link->channel,
 110                              mdev_link->comp, mdev_link->name,
 111                              mdev_link->comp_params);
 112 }
 113
 114 static ssize_t mdev_link_create_link_store(struct config_item *item,
 115                                            const char *page, size_t count)
 116 {
 117         struct mdev_link *mdev_link = to_mdev_link(item);
 118         bool tmp;
 119         int ret;
 120
 121         ret = kstrtobool(page, &tmp);
 122         if (ret)
 123                 return ret;
 124         if (!tmp)
 125                 return count;
 126         ret = set_config_and_add_link(mdev_link);
 127         if (ret && ret != -ENODEV)
 128                 return ret;
 129         list_add_tail(&mdev_link->list, &mdev_link_list);
 130         mdev_link->create_link = tmp;
 131         return count;
 132 }
 133
 134 static ssize_t mdev_link_destroy_link_store(struct config_item *item,
 135                                             const char *page, size_t count)
 136 {
 137         struct mdev_link *mdev_link = to_mdev_link(item);
 138         bool tmp;
 139         int ret;
 140
 141         ret = kstrtobool(page, &tmp);
 142         if (ret)
 143                 return ret;
 144         if (!tmp)
 145                 return count;
 146         mdev_link->destroy_link = tmp;
 147         ret = most_remove_link(mdev_link->device, mdev_link->channel,
 148                                mdev_link->comp);
 149         if (ret)
 150                 return ret;
 151         if (!list_empty(&mdev_link_list))
 152                 list_del(&mdev_link->list);
 153         return count;
 154 }
 155
 156 static ssize_t mdev_link_direction_show(struct config_item *item, char *page)
 157 {
 158         return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->direction);
 159 }
 160
 161 static ssize_t mdev_link_direction_store(struct config_item *item,
 162                                          const char *page, size_t count)
 163 {
 164         struct mdev_link *mdev_link = to_mdev_link(item);
 165
 166         if (!sysfs_streq(page, "dir_rx") && !sysfs_streq(page, "rx") &&
 167             !sysfs_streq(page, "dir_tx") && !sysfs_streq(page, "tx"))
 168                 return -EINVAL;
 169         strcpy(mdev_link->direction, page);
 170         strim(mdev_link->direction);
 171         return count;
 172 }
 173
 174 static ssize_t mdev_link_datatype_show(struct config_item *item, char *page)
 175 {
 176         return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->datatype);
 177 }
 178
 179 static ssize_t mdev_link_datatype_store(struct config_item *item,
 180                                         const char *page, size_t count)
 181 {
 182         struct mdev_link *mdev_link = to_mdev_link(item);
 183
 184         if (!sysfs_streq(page, "control") && !sysfs_streq(page, "async") &&
 185             !sysfs_streq(page, "sync") && !sysfs_streq(page, "isoc") &&
 186             !sysfs_streq(page, "isoc_avp"))
 187                 return -EINVAL;
 188         strcpy(mdev_link->datatype, page);
 189         strim(mdev_link->datatype);
 190         return count;
 191 }
 192
 193 static ssize_t mdev_link_device_show(struct config_item *item, char *page)
 194 {
 195         return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->device);
 196 }
 197
 198 static ssize_t mdev_link_device_store(struct config_item *item,
 199                                       const char *page, size_t count)
 200 {
 201         struct mdev_link *mdev_link = to_mdev_link(item);
 202
 203         strlcpy(mdev_link->device, page, sizeof(mdev_link->device));
 204         strim(mdev_link->device);
 205         return count;
 206 }
 207
 208 static ssize_t mdev_link_channel_show(struct config_item *item, char *page)
 209 {
 210         return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->channel);
 211 }
 212
 213 static ssize_t mdev_link_channel_store(struct config_item *item,
 214                                        const char *page, size_t count)
 215 {
 216         struct mdev_link *mdev_link = to_mdev_link(item);
 217
 218         strlcpy(mdev_link->channel, page, sizeof(mdev_link->channel));
 219         strim(mdev_link->channel);
 220         return count;
 221 }
 222
 223 static ssize_t mdev_link_comp_show(struct config_item *item, char *page)
 224 {
 225         return snprintf(page, PAGE_SIZE, "%s\n", to_mdev_link(item)->comp);
 226 }
 227
 228 static ssize_t mdev_link_comp_store(struct config_item *item,
 229                                     const char *page, size_t count)
 230 {
 231         struct mdev_link *mdev_link = to_mdev_link(item);
 232
 233         strlcpy(mdev_link->comp, page, sizeof(mdev_link->comp));
 234         strim(mdev_link->comp);
 235         return count;
 236 }
 237
 238 static ssize_t mdev_link_comp_params_show(struct config_item *item, char *page)
 239 {
 240         return snprintf(page, PAGE_SIZE, "%s\n",
 241                         to_mdev_link(item)->comp_params);
 242 }
 243
 244 static ssize_t mdev_link_comp_params_store(struct config_item *item,
 245                                            const char *page, size_t count)
 246 {
 247         struct mdev_link *mdev_link = to_mdev_link(item);
 248
 249         strlcpy(mdev_link->comp_params, page, sizeof(mdev_link->comp_params));
 250         strim(mdev_link->comp_params);
 251         return count;
 252 }
 253
 254 static ssize_t mdev_link_num_buffers_show(struct config_item *item, char *page)
 255 {
 256         return snprintf(page, PAGE_SIZE, "%d\n",
 257                         to_mdev_link(item)->num_buffers);
 258 }
 259
 260 static ssize_t mdev_link_num_buffers_store(struct config_item *item,
 261                                            const char *page, size_t count)
 262 {
 263         struct mdev_link *mdev_link = to_mdev_link(item);
 264         int ret;
 265
 266         ret = kstrtou16(page, 0, &mdev_link->num_buffers);
 267         if (ret)
 268                 return ret;
 269         return count;
 270 }
 271
 272 static ssize_t mdev_link_buffer_size_show(struct config_item *item, char *page)
 273 {
 274         return snprintf(page, PAGE_SIZE, "%d\n",
 275                         to_mdev_link(item)->buffer_size);
 276 }
 277
 278 static ssize_t mdev_link_buffer_size_store(struct config_item *item,
 279                                            const char *page, size_t count)
 280 {
 281         struct mdev_link *mdev_link = to_mdev_link(item);
 282         int ret;
 283
 284         ret = kstrtou16(page, 0, &mdev_link->buffer_size);
 285         if (ret)
 286                 return ret;
 287         return count;
 288 }
 289
 290 static ssize_t mdev_link_subbuffer_size_show(struct config_item *item,
 291                                              char *page)
 292 {
 293         return snprintf(page, PAGE_SIZE, "%d\n",
 294                         to_mdev_link(item)->subbuffer_size);
 295 }
 296
 297 static ssize_t mdev_link_subbuffer_size_store(struct config_item *item,
 298                                               const char *page, size_t count)
 299 {
 300         struct mdev_link *mdev_link = to_mdev_link(item);
 301         int ret;
 302
 303         ret = kstrtou16(page, 0, &mdev_link->subbuffer_size);
 304         if (ret)
 305                 return ret;
 306         return count;
 307 }
 308
 309 static ssize_t mdev_link_packets_per_xact_show(struct config_item *item,
 310                                                char *page)
 311 {
 312         return snprintf(page, PAGE_SIZE, "%d\n",
 313                         to_mdev_link(item)->packets_per_xact);
 314 }
 315
 316 static ssize_t mdev_link_packets_per_xact_store(struct config_item *item,
 317                                                 const char *page, size_t count)
 318 {
 319         struct mdev_link *mdev_link = to_mdev_link(item);
 320         int ret;
 321
 322         ret = kstrtou16(page, 0, &mdev_link->packets_per_xact);
 323         if (ret)
 324                 return ret;
 325         return count;
 326 }
 327
 328 static ssize_t mdev_link_dbr_size_show(struct config_item *item, char *page)
 329 {
 330         return snprintf(page, PAGE_SIZE, "%d\n", to_mdev_link(item)->dbr_size);
 331 }
 332
 333 static ssize_t mdev_link_dbr_size_store(struct config_item *item,
 334                                         const char *page, size_t count)
 335 {
 336         struct mdev_link *mdev_link = to_mdev_link(item);
 337         int ret;
 338
 339         ret = kstrtou16(page, 0, &mdev_link->dbr_size);
 340         if (ret)
 341                 return ret;
 342         return count;
 343 }
 344
 345 CONFIGFS_ATTR_WO(mdev_link_, create_link);
 346 CONFIGFS_ATTR_WO(mdev_link_, destroy_link);
 347 CONFIGFS_ATTR(mdev_link_, device);
 348 CONFIGFS_ATTR(mdev_link_, channel);
 349 CONFIGFS_ATTR(mdev_link_, comp);
 350 CONFIGFS_ATTR(mdev_link_, comp_params);
 351 CONFIGFS_ATTR(mdev_link_, num_buffers);
 352 CONFIGFS_ATTR(mdev_link_, buffer_size);
 353 CONFIGFS_ATTR(mdev_link_, subbuffer_size);
 354 CONFIGFS_ATTR(mdev_link_, packets_per_xact);
 355 CONFIGFS_ATTR(mdev_link_, datatype);
 356 CONFIGFS_ATTR(mdev_link_, direction);
 357 CONFIGFS_ATTR(mdev_link_, dbr_size);
 358
 359 static struct configfs_attribute *mdev_link_attrs[] = {
 360         &mdev_link_attr_create_link,
 361         &mdev_link_attr_destroy_link,
 362         &mdev_link_attr_device,
 363         &mdev_link_attr_channel,
 364         &mdev_link_attr_comp,
 365         &mdev_link_attr_comp_params,
 366         &mdev_link_attr_num_buffers,
 367         &mdev_link_attr_buffer_size,
 368         &mdev_link_attr_subbuffer_size,
 369         &mdev_link_attr_packets_per_xact,
 370         &mdev_link_attr_datatype,
 371         &mdev_link_attr_direction,
 372         &mdev_link_attr_dbr_size,
 373         NULL,
 374 };
 375
 376 static void mdev_link_release(struct config_item *item)
 377 {
 378         struct mdev_link *mdev_link = to_mdev_link(item);
 379         int ret;
 380
 381         if (!list_empty(&mdev_link_list)) {
 382                 ret = most_remove_link(mdev_link->device, mdev_link->channel,
 383                                        mdev_link->comp);
 384                 if (ret && (ret != -ENODEV))
 385                         pr_err("Removing link failed.\n");
 386                 list_del(&mdev_link->list);
 387         }
 388         kfree(to_mdev_link(item));
 389 }
 390
 391 static struct configfs_item_operations mdev_link_item_ops = {
 392         .release                = mdev_link_release,
 393 };
 394
 395 static const struct config_item_type mdev_link_type = {
 396         .ct_item_ops    = &mdev_link_item_ops,
 397         .ct_attrs       = mdev_link_attrs,
 398         .ct_owner       = THIS_MODULE,
 399 };
 400
 401 struct most_common {
 402         struct config_group group;
 403         struct module *mod;
 404         struct configfs_subsystem subsys;
 405 };
 406
 407 static struct most_common *to_most_common(struct configfs_subsystem *subsys)
 408 {
 409         return container_of(subsys, struct most_common, subsys);
 410 }
 411
 412 static struct config_item *most_common_make_item(struct config_group *group,
 413                                                  const char *name)
 414 {
 415         struct mdev_link *mdev_link;
 416         struct most_common *mc = to_most_common(group->cg_subsys);
 417
 418         mdev_link = kzalloc(sizeof(*mdev_link), GFP_KERNEL);
 419         if (!mdev_link)
 420                 return ERR_PTR(-ENOMEM);
 421
 422         if (!try_module_get(mc->mod)) {
 423                 kfree(mdev_link);
 424                 return ERR_PTR(-ENOLCK);
 425         }
 426         config_item_init_type_name(&mdev_link->item, name,
 427                                    &mdev_link_type);
 428
 429         if (!strcmp(group->cg_item.ci_namebuf, "most_cdev"))
 430                 strcpy(mdev_link->comp, "cdev");
 431         else if (!strcmp(group->cg_item.ci_namebuf, "most_net"))
 432                 strcpy(mdev_link->comp, "net");
 433         else if (!strcmp(group->cg_item.ci_namebuf, "most_video"))
 434                 strcpy(mdev_link->comp, "video");
 435         strcpy(mdev_link->name, name);
 436         return &mdev_link->item;
 437 }
 438
 439 static void most_common_release(struct config_item *item)
 440 {
 441         struct config_group *group = to_config_group(item);
 442
 443         kfree(to_most_common(group->cg_subsys));
 444 }
 445
 446 static struct configfs_item_operations most_common_item_ops = {
 447         .release        = most_common_release,
 448 };
 449
 450 static void most_common_disconnect(struct config_group *group,
 451                                    struct config_item *item)
 452 {
 453         struct most_common *mc = to_most_common(group->cg_subsys);
 454
 455         module_put(mc->mod);
 456 }
 457
 458 static struct configfs_group_operations most_common_group_ops = {
 459         .make_item      = most_common_make_item,
 460         .disconnect_notify = most_common_disconnect,
 461 };
 462
 463 static const struct config_item_type most_common_type = {
 464         .ct_item_ops    = &most_common_item_ops,
 465         .ct_group_ops   = &most_common_group_ops,
 466         .ct_owner       = THIS_MODULE,
 467 };
 468
 469 static struct most_common most_cdev = {
 470         .subsys = {
 471                 .su_group = {
 472                         .cg_item = {
 473                                 .ci_namebuf = "most_cdev",
 474                                 .ci_type = &most_common_type,
 475                         },
 476                 },
 477         },
 478 };
 479
 480 static struct most_common most_net = {
 481         .subsys = {
 482                 .su_group = {
 483                         .cg_item = {
 484                                 .ci_namebuf = "most_net",
 485                                 .ci_type = &most_common_type,
 486                         },
 487                 },
 488         },
 489 };
 490
 491 static struct most_common most_video = {
 492         .subsys = {
 493                 .su_group = {
 494                         .cg_item = {
 495                                 .ci_namebuf = "most_video",
 496                                 .ci_type = &most_common_type,
 497                         },
 498                 },
 499         },
 500 };
 501
 502 struct most_snd_grp {
 503         struct config_group group;
 504         bool create_card;
 505         struct list_head list;
 506 };
 507
 508 static struct most_snd_grp *to_most_snd_grp(struct config_item *item)
 509 {
 510         return container_of(to_config_group(item), struct most_snd_grp, group);
 511 }
 512
 513 static struct config_item *most_snd_grp_make_item(struct config_group *group,
 514                                                   const char *name)
 515 {
 516         struct mdev_link *mdev_link;
 517
 518         mdev_link = kzalloc(sizeof(*mdev_link), GFP_KERNEL);
 519         if (!mdev_link)
 520                 return ERR_PTR(-ENOMEM);
 521
 522         config_item_init_type_name(&mdev_link->item, name, &mdev_link_type);
 523         mdev_link->create_link = false;
 524         strcpy(mdev_link->name, name);
 525         strcpy(mdev_link->comp, "sound");
 526         return &mdev_link->item;
 527 }
 528
 529 static ssize_t most_snd_grp_create_card_store(struct config_item *item,
 530                                               const char *page, size_t count)
 531 {
 532         struct most_snd_grp *snd_grp = to_most_snd_grp(item);
 533         int ret;
 534         bool tmp;
 535
 536         ret = kstrtobool(page, &tmp);
 537         if (ret)
 538                 return ret;
 539         if (tmp) {
 540                 ret = most_cfg_complete("sound");
 541                 if (ret)
 542                         return ret;
 543         }
 544         snd_grp->create_card = tmp;
 545         return count;
 546 }
 547
 548 CONFIGFS_ATTR_WO(most_snd_grp_, create_card);
 549
 550 static struct configfs_attribute *most_snd_grp_attrs[] = {
 551         &most_snd_grp_attr_create_card,
 552         NULL,
 553 };
 554
 555 static void most_snd_grp_release(struct config_item *item)
 556 {
 557         struct most_snd_grp *group = to_most_snd_grp(item);
 558
 559         list_del(&group->list);
 560         kfree(group);
 561 }
 562
 563 static struct configfs_item_operations most_snd_grp_item_ops = {
 564         .release        = most_snd_grp_release,
 565 };
 566
 567 static struct configfs_group_operations most_snd_grp_group_ops = {
 568         .make_item      = most_snd_grp_make_item,
 569 };
 570
 571 static const struct config_item_type most_snd_grp_type = {
 572         .ct_item_ops    = &most_snd_grp_item_ops,
 573         .ct_group_ops   = &most_snd_grp_group_ops,
 574         .ct_attrs       = most_snd_grp_attrs,
 575         .ct_owner       = THIS_MODULE,
 576 };
 577
 578 struct most_sound {
 579         struct configfs_subsystem subsys;
 580         struct list_head soundcard_list;
 581         struct module *mod;
 582 };
 583
 584 static struct config_group *most_sound_make_group(struct config_group *group,
 585                                                   const char *name)
 586 {
 587         struct most_snd_grp *most;
 588         struct most_sound *ms = container_of(group->cg_subsys,
 589                                              struct most_sound, subsys);
 590
 591         list_for_each_entry(most, &ms->soundcard_list, list) {
 592                 if (!most->create_card) {
 593                         pr_info("adapter configuration still in progress.\n");
 594                         return ERR_PTR(-EPROTO);
 595                 }
 596         }
 597         if (!try_module_get(ms->mod))
 598                 return ERR_PTR(-ENOLCK);
 599         most = kzalloc(sizeof(*most), GFP_KERNEL);
 600         if (!most) {
 601                 module_put(ms->mod);
 602                 return ERR_PTR(-ENOMEM);
 603         }
 604         config_group_init_type_name(&most->group, name, &most_snd_grp_type);
 605         list_add_tail(&most->list, &ms->soundcard_list);
 606         return &most->group;
 607 }
 608
 609 static void most_sound_disconnect(struct config_group *group,
 610                                   struct config_item *item)
 611 {
 612         struct most_sound *ms = container_of(group->cg_subsys,
 613                                              struct most_sound, subsys);
 614         module_put(ms->mod);
 615 }
 616
 617 static struct configfs_group_operations most_sound_group_ops = {
 618         .make_group     = most_sound_make_group,
 619         .disconnect_notify = most_sound_disconnect,
 620 };
 621
 622 static const struct config_item_type most_sound_type = {
 623         .ct_group_ops   = &most_sound_group_ops,
 624         .ct_owner       = THIS_MODULE,
 625 };
 626
 627 static struct most_sound most_sound_subsys = {
 628         .subsys = {
 629                 .su_group = {
 630                         .cg_item = {
 631                                 .ci_namebuf = "most_sound",
 632                                 .ci_type = &most_sound_type,
 633                         },
 634                 },
 635         },
 636 };
 637
 638 int most_register_configfs_subsys(struct most_component *c)
 639 {
 640         int ret;
 641
 642         if (!strcmp(c->name, "cdev")) {
 643                 most_cdev.mod = c->mod;
 644                 ret = configfs_register_subsystem(&most_cdev.subsys);
 645         } else if (!strcmp(c->name, "net")) {
 646                 most_net.mod = c->mod;
 647                 ret = configfs_register_subsystem(&most_net.subsys);
 648         } else if (!strcmp(c->name, "video")) {
 649                 most_video.mod = c->mod;
 650                 ret = configfs_register_subsystem(&most_video.subsys);
 651         } else if (!strcmp(c->name, "sound")) {
 652                 most_sound_subsys.mod = c->mod;
 653                 ret = configfs_register_subsystem(&most_sound_subsys.subsys);
 654         } else {
 655                 return -ENODEV;
 656         }
 657
 658         if (ret) {
 659                 pr_err("Error %d while registering subsystem %s\n",
 660                        ret, c->name);
 661         }
 662         return ret;
 663 }
 664 EXPORT_SYMBOL_GPL(most_register_configfs_subsys);
 665
 666 void most_interface_register_notify(const char *mdev)
 667 {
 668         bool register_snd_card = false;
 669         struct mdev_link *mdev_link;
 670
 671         list_for_each_entry(mdev_link, &mdev_link_list, list) {
 672                 if (!strcmp(mdev_link->device, mdev)) {
 673                         set_config_and_add_link(mdev_link);
 674                         if (!strcmp(mdev_link->comp, "sound"))
 675                                 register_snd_card = true;
 676                 }
 677         }
 678         if (register_snd_card)
 679                 most_cfg_complete("sound");
 680 }
 681
 682 void most_deregister_configfs_subsys(struct most_component *c)
 683 {
 684         if (!strcmp(c->name, "cdev"))
 685                 configfs_unregister_subsystem(&most_cdev.subsys);
 686         else if (!strcmp(c->name, "net"))
 687                 configfs_unregister_subsystem(&most_net.subsys);
 688         else if (!strcmp(c->name, "video"))
 689                 configfs_unregister_subsystem(&most_video.subsys);
 690         else if (!strcmp(c->name, "sound"))
 691                 configfs_unregister_subsystem(&most_sound_subsys.subsys);
 692 }
 693 EXPORT_SYMBOL_GPL(most_deregister_configfs_subsys);
 694
 695 int __init configfs_init(void)
 696 {
 697         config_group_init(&most_cdev.subsys.su_group);
 698         mutex_init(&most_cdev.subsys.su_mutex);
 699
 700         config_group_init(&most_net.subsys.su_group);
 701         mutex_init(&most_net.subsys.su_mutex);
 702
 703         config_group_init(&most_video.subsys.su_group);
 704         mutex_init(&most_video.subsys.su_mutex);
 705
 706         config_group_init(&most_sound_subsys.subsys.su_group);
 707         mutex_init(&most_sound_subsys.subsys.su_mutex);
 708
 709         INIT_LIST_HEAD(&most_sound_subsys.soundcard_list);
 710         INIT_LIST_HEAD(&mdev_link_list);
 711
 712         return 0;
 713 }