drivers/usb/gadget/function/uvc_configfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * uvc_configfs.c
   4  *
   5  * Configfs support for the uvc function.
   6  *
   7  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   8  *              http://www.samsung.com
   9  *
  10  * Author: Andrzej Pietrasiewicz <andrzejtp2010@gmail.com>
  11  */
  12
  13 #include <linux/sort.h>
  14
  15 #include "u_uvc.h"
  16 #include "uvc_configfs.h"
  17
  18 /* -----------------------------------------------------------------------------
  19  * Global Utility Structures and Macros
  20  */
  21
  22 #define UVCG_STREAMING_CONTROL_SIZE     1
  23
  24 #define UVC_ATTR(prefix, cname, aname) \
  25 static struct configfs_attribute prefix##attr_##cname = { \
  26         .ca_name        = __stringify(aname),                           \
  27         .ca_mode        = S_IRUGO | S_IWUGO,                            \
  28         .ca_owner       = THIS_MODULE,                                  \
  29         .show           = prefix##cname##_show,                         \
  30         .store          = prefix##cname##_store,                        \
  31 }
  32
  33 #define UVC_ATTR_RO(prefix, cname, aname) \
  34 static struct configfs_attribute prefix##attr_##cname = { \
  35         .ca_name        = __stringify(aname),                           \
  36         .ca_mode        = S_IRUGO,                                      \
  37         .ca_owner       = THIS_MODULE,                                  \
  38         .show           = prefix##cname##_show,                         \
  39 }
  40
  41 #define le8_to_cpu(x)   (x)
  42 #define cpu_to_le8(x)   (x)
  43
  44 static int uvcg_config_compare_u32(const void *l, const void *r)
  45 {
  46         u32 li = *(const u32 *)l;
  47         u32 ri = *(const u32 *)r;
  48
  49         return li < ri ? -1 : li == ri ? 0 : 1;
  50 }
  51
  52 static inline struct f_uvc_opts *to_f_uvc_opts(struct config_item *item)
  53 {
  54         return container_of(to_config_group(item), struct f_uvc_opts,
  55                             func_inst.group);
  56 }
  57
  58 struct uvcg_config_group_type {
  59         struct config_item_type type;
  60         const char *name;
  61         const struct uvcg_config_group_type **children;
  62         int (*create_children)(struct config_group *group);
  63 };
  64
  65 static void uvcg_config_item_release(struct config_item *item)
  66 {
  67         struct config_group *group = to_config_group(item);
  68
  69         kfree(group);
  70 }
  71
  72 static struct configfs_item_operations uvcg_config_item_ops = {
  73         .release        = uvcg_config_item_release,
  74 };
  75
  76 static int uvcg_config_create_group(struct config_group *parent,
  77                                     const struct uvcg_config_group_type *type);
  78
  79 static int uvcg_config_create_children(struct config_group *group,
  80                                 const struct uvcg_config_group_type *type)
  81 {
  82         const struct uvcg_config_group_type **child;
  83         int ret;
  84
  85         if (type->create_children)
  86                 return type->create_children(group);
  87
  88         for (child = type->children; child && *child; ++child) {
  89                 ret = uvcg_config_create_group(group, *child);
  90                 if (ret < 0)
  91                         return ret;
  92         }
  93
  94         return 0;
  95 }
  96
  97 static int uvcg_config_create_group(struct config_group *parent,
  98                                     const struct uvcg_config_group_type *type)
  99 {
 100         struct config_group *group;
 101
 102         group = kzalloc(sizeof(*group), GFP_KERNEL);
 103         if (!group)
 104                 return -ENOMEM;
 105
 106         config_group_init_type_name(group, type->name, &type->type);
 107         configfs_add_default_group(group, parent);
 108
 109         return uvcg_config_create_children(group, type);
 110 }
 111
 112 static void uvcg_config_remove_children(struct config_group *group)
 113 {
 114         struct config_group *child, *n;
 115
 116         list_for_each_entry_safe(child, n, &group->default_groups, group_entry) {
 117                 list_del(&child->group_entry);
 118                 uvcg_config_remove_children(child);
 119                 config_item_put(&child->cg_item);
 120         }
 121 }
 122
 123 /* -----------------------------------------------------------------------------
 124  * control/header/<NAME>
 125  * control/header
 126  */
 127
 128 DECLARE_UVC_HEADER_DESCRIPTOR(1);
 129
 130 struct uvcg_control_header {
 131         struct config_item              item;
 132         struct UVC_HEADER_DESCRIPTOR(1) desc;
 133         unsigned                        linked;
 134 };
 135
 136 static struct uvcg_control_header *to_uvcg_control_header(struct config_item *item)
 137 {
 138         return container_of(item, struct uvcg_control_header, item);
 139 }
 140
 141 #define UVCG_CTRL_HDR_ATTR(cname, aname, bits, limit)                   \
 142 static ssize_t uvcg_control_header_##cname##_show(                      \
 143         struct config_item *item, char *page)                           \
 144 {                                                                       \
 145         struct uvcg_control_header *ch = to_uvcg_control_header(item);  \
 146         struct f_uvc_opts *opts;                                        \
 147         struct config_item *opts_item;                                  \
 148         struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;\
 149         int result;                                                     \
 150                                                                         \
 151         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
 152                                                                         \
 153         opts_item = ch->item.ci_parent->ci_parent->ci_parent;           \
 154         opts = to_f_uvc_opts(opts_item);                                \
 155                                                                         \
 156         mutex_lock(&opts->lock);                                        \
 157         result = sprintf(page, "%u\n", le##bits##_to_cpu(ch->desc.aname));\
 158         mutex_unlock(&opts->lock);                                      \
 159                                                                         \
 160         mutex_unlock(su_mutex);                                         \
 161         return result;                                                  \
 162 }                                                                       \
 163                                                                         \
 164 static ssize_t                                                          \
 165 uvcg_control_header_##cname##_store(struct config_item *item,           \
 166                            const char *page, size_t len)                \
 167 {                                                                       \
 168         struct uvcg_control_header *ch = to_uvcg_control_header(item);  \
 169         struct f_uvc_opts *opts;                                        \
 170         struct config_item *opts_item;                                  \
 171         struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;\
 172         int ret;                                                        \
 173         u##bits num;                                                    \
 174                                                                         \
 175         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
 176                                                                         \
 177         opts_item = ch->item.ci_parent->ci_parent->ci_parent;           \
 178         opts = to_f_uvc_opts(opts_item);                                \
 179                                                                         \
 180         mutex_lock(&opts->lock);                                        \
 181         if (ch->linked || opts->refcnt) {                               \
 182                 ret = -EBUSY;                                           \
 183                 goto end;                                               \
 184         }                                                               \
 185                                                                         \
 186         ret = kstrtou##bits(page, 0, &num);                             \
 187         if (ret)                                                        \
 188                 goto end;                                               \
 189                                                                         \
 190         if (num > limit) {                                              \
 191                 ret = -EINVAL;                                          \
 192                 goto end;                                               \
 193         }                                                               \
 194         ch->desc.aname = cpu_to_le##bits(num);                          \
 195         ret = len;                                                      \
 196 end:                                                                    \
 197         mutex_unlock(&opts->lock);                                      \
 198         mutex_unlock(su_mutex);                                         \
 199         return ret;                                                     \
 200 }                                                                       \
 201                                                                         \
 202 UVC_ATTR(uvcg_control_header_, cname, aname)
 203
 204 UVCG_CTRL_HDR_ATTR(bcd_uvc, bcdUVC, 16, 0xffff);
 205
 206 UVCG_CTRL_HDR_ATTR(dw_clock_frequency, dwClockFrequency, 32, 0x7fffffff);
 207
 208 #undef UVCG_CTRL_HDR_ATTR
 209
 210 static struct configfs_attribute *uvcg_control_header_attrs[] = {
 211         &uvcg_control_header_attr_bcd_uvc,
 212         &uvcg_control_header_attr_dw_clock_frequency,
 213         NULL,
 214 };
 215
 216 static const struct config_item_type uvcg_control_header_type = {
 217         .ct_item_ops    = &uvcg_config_item_ops,
 218         .ct_attrs       = uvcg_control_header_attrs,
 219         .ct_owner       = THIS_MODULE,
 220 };
 221
 222 static struct config_item *uvcg_control_header_make(struct config_group *group,
 223                                                     const char *name)
 224 {
 225         struct uvcg_control_header *h;
 226
 227         h = kzalloc(sizeof(*h), GFP_KERNEL);
 228         if (!h)
 229                 return ERR_PTR(-ENOMEM);
 230
 231         h->desc.bLength                 = UVC_DT_HEADER_SIZE(1);
 232         h->desc.bDescriptorType         = USB_DT_CS_INTERFACE;
 233         h->desc.bDescriptorSubType      = UVC_VC_HEADER;
 234         h->desc.bcdUVC                  = cpu_to_le16(0x0100);
 235         h->desc.dwClockFrequency        = cpu_to_le32(48000000);
 236
 237         config_item_init_type_name(&h->item, name, &uvcg_control_header_type);
 238
 239         return &h->item;
 240 }
 241
 242 static struct configfs_group_operations uvcg_control_header_grp_ops = {
 243         .make_item              = uvcg_control_header_make,
 244 };
 245
 246 static const struct uvcg_config_group_type uvcg_control_header_grp_type = {
 247         .type = {
 248                 .ct_item_ops    = &uvcg_config_item_ops,
 249                 .ct_group_ops   = &uvcg_control_header_grp_ops,
 250                 .ct_owner       = THIS_MODULE,
 251         },
 252         .name = "header",
 253 };
 254
 255 /* -----------------------------------------------------------------------------
 256  * control/processing/default
 257  */
 258
 259 #define UVCG_DEFAULT_PROCESSING_ATTR(cname, aname, bits)                \
 260 static ssize_t uvcg_default_processing_##cname##_show(                  \
 261         struct config_item *item, char *page)                           \
 262 {                                                                       \
 263         struct config_group *group = to_config_group(item);             \
 264         struct f_uvc_opts *opts;                                        \
 265         struct config_item *opts_item;                                  \
 266         struct mutex *su_mutex = &group->cg_subsys->su_mutex;           \
 267         struct uvc_processing_unit_descriptor *pd;                      \
 268         int result;                                                     \
 269                                                                         \
 270         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
 271                                                                         \
 272         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;     \
 273         opts = to_f_uvc_opts(opts_item);                                \
 274         pd = &opts->uvc_processing;                                     \
 275                                                                         \
 276         mutex_lock(&opts->lock);                                        \
 277         result = sprintf(page, "%u\n", le##bits##_to_cpu(pd->aname));   \
 278         mutex_unlock(&opts->lock);                                      \
 279                                                                         \
 280         mutex_unlock(su_mutex);                                         \
 281         return result;                                                  \
 282 }                                                                       \
 283                                                                         \
 284 UVC_ATTR_RO(uvcg_default_processing_, cname, aname)
 285
 286 UVCG_DEFAULT_PROCESSING_ATTR(b_unit_id, bUnitID, 8);
 287 UVCG_DEFAULT_PROCESSING_ATTR(b_source_id, bSourceID, 8);
 288 UVCG_DEFAULT_PROCESSING_ATTR(w_max_multiplier, wMaxMultiplier, 16);
 289 UVCG_DEFAULT_PROCESSING_ATTR(i_processing, iProcessing, 8);
 290
 291 #undef UVCG_DEFAULT_PROCESSING_ATTR
 292
 293 static ssize_t uvcg_default_processing_bm_controls_show(
 294         struct config_item *item, char *page)
 295 {
 296         struct config_group *group = to_config_group(item);
 297         struct f_uvc_opts *opts;
 298         struct config_item *opts_item;
 299         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 300         struct uvc_processing_unit_descriptor *pd;
 301         int result, i;
 302         char *pg = page;
 303
 304         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 305
 306         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
 307         opts = to_f_uvc_opts(opts_item);
 308         pd = &opts->uvc_processing;
 309
 310         mutex_lock(&opts->lock);
 311         for (result = 0, i = 0; i < pd->bControlSize; ++i) {
 312                 result += sprintf(pg, "%u\n", pd->bmControls[i]);
 313                 pg = page + result;
 314         }
 315         mutex_unlock(&opts->lock);
 316
 317         mutex_unlock(su_mutex);
 318
 319         return result;
 320 }
 321
 322 UVC_ATTR_RO(uvcg_default_processing_, bm_controls, bmControls);
 323
 324 static struct configfs_attribute *uvcg_default_processing_attrs[] = {
 325         &uvcg_default_processing_attr_b_unit_id,
 326         &uvcg_default_processing_attr_b_source_id,
 327         &uvcg_default_processing_attr_w_max_multiplier,
 328         &uvcg_default_processing_attr_bm_controls,
 329         &uvcg_default_processing_attr_i_processing,
 330         NULL,
 331 };
 332
 333 static const struct uvcg_config_group_type uvcg_default_processing_type = {
 334         .type = {
 335                 .ct_item_ops    = &uvcg_config_item_ops,
 336                 .ct_attrs       = uvcg_default_processing_attrs,
 337                 .ct_owner       = THIS_MODULE,
 338         },
 339         .name = "default",
 340 };
 341
 342 /* -----------------------------------------------------------------------------
 343  * control/processing
 344  */
 345
 346 static const struct uvcg_config_group_type uvcg_processing_grp_type = {
 347         .type = {
 348                 .ct_item_ops    = &uvcg_config_item_ops,
 349                 .ct_owner       = THIS_MODULE,
 350         },
 351         .name = "processing",
 352         .children = (const struct uvcg_config_group_type*[]) {
 353                 &uvcg_default_processing_type,
 354                 NULL,
 355         },
 356 };
 357
 358 /* -----------------------------------------------------------------------------
 359  * control/terminal/camera/default
 360  */
 361
 362 #define UVCG_DEFAULT_CAMERA_ATTR(cname, aname, bits)                    \
 363 static ssize_t uvcg_default_camera_##cname##_show(                      \
 364         struct config_item *item, char *page)                           \
 365 {                                                                       \
 366         struct config_group *group = to_config_group(item);             \
 367         struct f_uvc_opts *opts;                                        \
 368         struct config_item *opts_item;                                  \
 369         struct mutex *su_mutex = &group->cg_subsys->su_mutex;           \
 370         struct uvc_camera_terminal_descriptor *cd;                      \
 371         int result;                                                     \
 372                                                                         \
 373         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
 374                                                                         \
 375         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent->    \
 376                         ci_parent;                                      \
 377         opts = to_f_uvc_opts(opts_item);                                \
 378         cd = &opts->uvc_camera_terminal;                                \
 379                                                                         \
 380         mutex_lock(&opts->lock);                                        \
 381         result = sprintf(page, "%u\n", le##bits##_to_cpu(cd->aname));   \
 382         mutex_unlock(&opts->lock);                                      \
 383                                                                         \
 384         mutex_unlock(su_mutex);                                         \
 385                                                                         \
 386         return result;                                                  \
 387 }                                                                       \
 388                                                                         \
 389 UVC_ATTR_RO(uvcg_default_camera_, cname, aname)
 390
 391 UVCG_DEFAULT_CAMERA_ATTR(b_terminal_id, bTerminalID, 8);
 392 UVCG_DEFAULT_CAMERA_ATTR(w_terminal_type, wTerminalType, 16);
 393 UVCG_DEFAULT_CAMERA_ATTR(b_assoc_terminal, bAssocTerminal, 8);
 394 UVCG_DEFAULT_CAMERA_ATTR(i_terminal, iTerminal, 8);
 395 UVCG_DEFAULT_CAMERA_ATTR(w_objective_focal_length_min, wObjectiveFocalLengthMin,
 396                          16);
 397 UVCG_DEFAULT_CAMERA_ATTR(w_objective_focal_length_max, wObjectiveFocalLengthMax,
 398                          16);
 399 UVCG_DEFAULT_CAMERA_ATTR(w_ocular_focal_length, wOcularFocalLength,
 400                          16);
 401
 402 #undef UVCG_DEFAULT_CAMERA_ATTR
 403
 404 static ssize_t uvcg_default_camera_bm_controls_show(
 405         struct config_item *item, char *page)
 406 {
 407         struct config_group *group = to_config_group(item);
 408         struct f_uvc_opts *opts;
 409         struct config_item *opts_item;
 410         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 411         struct uvc_camera_terminal_descriptor *cd;
 412         int result, i;
 413         char *pg = page;
 414
 415         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 416
 417         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent->
 418                         ci_parent;
 419         opts = to_f_uvc_opts(opts_item);
 420         cd = &opts->uvc_camera_terminal;
 421
 422         mutex_lock(&opts->lock);
 423         for (result = 0, i = 0; i < cd->bControlSize; ++i) {
 424                 result += sprintf(pg, "%u\n", cd->bmControls[i]);
 425                 pg = page + result;
 426         }
 427         mutex_unlock(&opts->lock);
 428
 429         mutex_unlock(su_mutex);
 430         return result;
 431 }
 432
 433 UVC_ATTR_RO(uvcg_default_camera_, bm_controls, bmControls);
 434
 435 static struct configfs_attribute *uvcg_default_camera_attrs[] = {
 436         &uvcg_default_camera_attr_b_terminal_id,
 437         &uvcg_default_camera_attr_w_terminal_type,
 438         &uvcg_default_camera_attr_b_assoc_terminal,
 439         &uvcg_default_camera_attr_i_terminal,
 440         &uvcg_default_camera_attr_w_objective_focal_length_min,
 441         &uvcg_default_camera_attr_w_objective_focal_length_max,
 442         &uvcg_default_camera_attr_w_ocular_focal_length,
 443         &uvcg_default_camera_attr_bm_controls,
 444         NULL,
 445 };
 446
 447 static const struct uvcg_config_group_type uvcg_default_camera_type = {
 448         .type = {
 449                 .ct_item_ops    = &uvcg_config_item_ops,
 450                 .ct_attrs       = uvcg_default_camera_attrs,
 451                 .ct_owner       = THIS_MODULE,
 452         },
 453         .name = "default",
 454 };
 455
 456 /* -----------------------------------------------------------------------------
 457  * control/terminal/camera
 458  */
 459
 460 static const struct uvcg_config_group_type uvcg_camera_grp_type = {
 461         .type = {
 462                 .ct_item_ops    = &uvcg_config_item_ops,
 463                 .ct_owner       = THIS_MODULE,
 464         },
 465         .name = "camera",
 466         .children = (const struct uvcg_config_group_type*[]) {
 467                 &uvcg_default_camera_type,
 468                 NULL,
 469         },
 470 };
 471
 472 /* -----------------------------------------------------------------------------
 473  * control/terminal/output/default
 474  */
 475
 476 #define UVCG_DEFAULT_OUTPUT_ATTR(cname, aname, bits)                    \
 477 static ssize_t uvcg_default_output_##cname##_show(                      \
 478         struct config_item *item, char *page)                           \
 479 {                                                                       \
 480         struct config_group *group = to_config_group(item);             \
 481         struct f_uvc_opts *opts;                                        \
 482         struct config_item *opts_item;                                  \
 483         struct mutex *su_mutex = &group->cg_subsys->su_mutex;           \
 484         struct uvc_output_terminal_descriptor *cd;                      \
 485         int result;                                                     \
 486                                                                         \
 487         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
 488                                                                         \
 489         opts_item = group->cg_item.ci_parent->ci_parent->               \
 490                         ci_parent->ci_parent;                           \
 491         opts = to_f_uvc_opts(opts_item);                                \
 492         cd = &opts->uvc_output_terminal;                                \
 493                                                                         \
 494         mutex_lock(&opts->lock);                                        \
 495         result = sprintf(page, "%u\n", le##bits##_to_cpu(cd->aname));   \
 496         mutex_unlock(&opts->lock);                                      \
 497                                                                         \
 498         mutex_unlock(su_mutex);                                         \
 499                                                                         \
 500         return result;                                                  \
 501 }                                                                       \
 502                                                                         \
 503 UVC_ATTR_RO(uvcg_default_output_, cname, aname)
 504
 505 UVCG_DEFAULT_OUTPUT_ATTR(b_terminal_id, bTerminalID, 8);
 506 UVCG_DEFAULT_OUTPUT_ATTR(w_terminal_type, wTerminalType, 16);
 507 UVCG_DEFAULT_OUTPUT_ATTR(b_assoc_terminal, bAssocTerminal, 8);
 508 UVCG_DEFAULT_OUTPUT_ATTR(b_source_id, bSourceID, 8);
 509 UVCG_DEFAULT_OUTPUT_ATTR(i_terminal, iTerminal, 8);
 510
 511 #undef UVCG_DEFAULT_OUTPUT_ATTR
 512
 513 static struct configfs_attribute *uvcg_default_output_attrs[] = {
 514         &uvcg_default_output_attr_b_terminal_id,
 515         &uvcg_default_output_attr_w_terminal_type,
 516         &uvcg_default_output_attr_b_assoc_terminal,
 517         &uvcg_default_output_attr_b_source_id,
 518         &uvcg_default_output_attr_i_terminal,
 519         NULL,
 520 };
 521
 522 static const struct uvcg_config_group_type uvcg_default_output_type = {
 523         .type = {
 524                 .ct_item_ops    = &uvcg_config_item_ops,
 525                 .ct_attrs       = uvcg_default_output_attrs,
 526                 .ct_owner       = THIS_MODULE,
 527         },
 528         .name = "default",
 529 };
 530
 531 /* -----------------------------------------------------------------------------
 532  * control/terminal/output
 533  */
 534
 535 static const struct uvcg_config_group_type uvcg_output_grp_type = {
 536         .type = {
 537                 .ct_item_ops    = &uvcg_config_item_ops,
 538                 .ct_owner       = THIS_MODULE,
 539         },
 540         .name = "output",
 541         .children = (const struct uvcg_config_group_type*[]) {
 542                 &uvcg_default_output_type,
 543                 NULL,
 544         },
 545 };
 546
 547 /* -----------------------------------------------------------------------------
 548  * control/terminal
 549  */
 550
 551 static const struct uvcg_config_group_type uvcg_terminal_grp_type = {
 552         .type = {
 553                 .ct_item_ops    = &uvcg_config_item_ops,
 554                 .ct_owner       = THIS_MODULE,
 555         },
 556         .name = "terminal",
 557         .children = (const struct uvcg_config_group_type*[]) {
 558                 &uvcg_camera_grp_type,
 559                 &uvcg_output_grp_type,
 560                 NULL,
 561         },
 562 };
 563
 564 /* -----------------------------------------------------------------------------
 565  * control/class/{fs|ss}
 566  */
 567
 568 struct uvcg_control_class_group {
 569         struct config_group group;
 570         const char *name;
 571 };
 572
 573 static inline struct uvc_descriptor_header
 574 **uvcg_get_ctl_class_arr(struct config_item *i, struct f_uvc_opts *o)
 575 {
 576         struct uvcg_control_class_group *group =
 577                 container_of(i, struct uvcg_control_class_group,
 578                              group.cg_item);
 579
 580         if (!strcmp(group->name, "fs"))
 581                 return o->uvc_fs_control_cls;
 582
 583         if (!strcmp(group->name, "ss"))
 584                 return o->uvc_ss_control_cls;
 585
 586         return NULL;
 587 }
 588
 589 static int uvcg_control_class_allow_link(struct config_item *src,
 590                                          struct config_item *target)
 591 {
 592         struct config_item *control, *header;
 593         struct f_uvc_opts *opts;
 594         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 595         struct uvc_descriptor_header **class_array;
 596         struct uvcg_control_header *target_hdr;
 597         int ret = -EINVAL;
 598
 599         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 600
 601         control = src->ci_parent->ci_parent;
 602         header = config_group_find_item(to_config_group(control), "header");
 603         if (!header || target->ci_parent != header)
 604                 goto out;
 605
 606         opts = to_f_uvc_opts(control->ci_parent);
 607
 608         mutex_lock(&opts->lock);
 609
 610         class_array = uvcg_get_ctl_class_arr(src, opts);
 611         if (!class_array)
 612                 goto unlock;
 613         if (opts->refcnt || class_array[0]) {
 614                 ret = -EBUSY;
 615                 goto unlock;
 616         }
 617
 618         target_hdr = to_uvcg_control_header(target);
 619         ++target_hdr->linked;
 620         class_array[0] = (struct uvc_descriptor_header *)&target_hdr->desc;
 621         ret = 0;
 622
 623 unlock:
 624         mutex_unlock(&opts->lock);
 625 out:
 626         config_item_put(header);
 627         mutex_unlock(su_mutex);
 628         return ret;
 629 }
 630
 631 static void uvcg_control_class_drop_link(struct config_item *src,
 632                                         struct config_item *target)
 633 {
 634         struct config_item *control, *header;
 635         struct f_uvc_opts *opts;
 636         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 637         struct uvc_descriptor_header **class_array;
 638         struct uvcg_control_header *target_hdr;
 639
 640         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 641
 642         control = src->ci_parent->ci_parent;
 643         header = config_group_find_item(to_config_group(control), "header");
 644         if (!header || target->ci_parent != header)
 645                 goto out;
 646
 647         opts = to_f_uvc_opts(control->ci_parent);
 648
 649         mutex_lock(&opts->lock);
 650
 651         class_array = uvcg_get_ctl_class_arr(src, opts);
 652         if (!class_array || opts->refcnt)
 653                 goto unlock;
 654
 655         target_hdr = to_uvcg_control_header(target);
 656         --target_hdr->linked;
 657         class_array[0] = NULL;
 658
 659 unlock:
 660         mutex_unlock(&opts->lock);
 661 out:
 662         config_item_put(header);
 663         mutex_unlock(su_mutex);
 664 }
 665
 666 static struct configfs_item_operations uvcg_control_class_item_ops = {
 667         .release        = uvcg_config_item_release,
 668         .allow_link     = uvcg_control_class_allow_link,
 669         .drop_link      = uvcg_control_class_drop_link,
 670 };
 671
 672 static const struct config_item_type uvcg_control_class_type = {
 673         .ct_item_ops    = &uvcg_control_class_item_ops,
 674         .ct_owner       = THIS_MODULE,
 675 };
 676
 677 /* -----------------------------------------------------------------------------
 678  * control/class
 679  */
 680
 681 static int uvcg_control_class_create_children(struct config_group *parent)
 682 {
 683         static const char * const names[] = { "fs", "ss" };
 684         unsigned int i;
 685
 686         for (i = 0; i < ARRAY_SIZE(names); ++i) {
 687                 struct uvcg_control_class_group *group;
 688
 689                 group = kzalloc(sizeof(*group), GFP_KERNEL);
 690                 if (!group)
 691                         return -ENOMEM;
 692
 693                 group->name = names[i];
 694
 695                 config_group_init_type_name(&group->group, group->name,
 696                                             &uvcg_control_class_type);
 697                 configfs_add_default_group(&group->group, parent);
 698         }
 699
 700         return 0;
 701 }
 702
 703 static const struct uvcg_config_group_type uvcg_control_class_grp_type = {
 704         .type = {
 705                 .ct_item_ops    = &uvcg_config_item_ops,
 706                 .ct_owner       = THIS_MODULE,
 707         },
 708         .name = "class",
 709         .create_children = uvcg_control_class_create_children,
 710 };
 711
 712 /* -----------------------------------------------------------------------------
 713  * control
 714  */
 715
 716 static ssize_t uvcg_default_control_b_interface_number_show(
 717         struct config_item *item, char *page)
 718 {
 719         struct config_group *group = to_config_group(item);
 720         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 721         struct config_item *opts_item;
 722         struct f_uvc_opts *opts;
 723         int result = 0;
 724
 725         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 726
 727         opts_item = item->ci_parent;
 728         opts = to_f_uvc_opts(opts_item);
 729
 730         mutex_lock(&opts->lock);
 731         result += sprintf(page, "%u\n", opts->control_interface);
 732         mutex_unlock(&opts->lock);
 733
 734         mutex_unlock(su_mutex);
 735
 736         return result;
 737 }
 738
 739 UVC_ATTR_RO(uvcg_default_control_, b_interface_number, bInterfaceNumber);
 740
 741 static struct configfs_attribute *uvcg_default_control_attrs[] = {
 742         &uvcg_default_control_attr_b_interface_number,
 743         NULL,
 744 };
 745
 746 static const struct uvcg_config_group_type uvcg_control_grp_type = {
 747         .type = {
 748                 .ct_item_ops    = &uvcg_config_item_ops,
 749                 .ct_attrs       = uvcg_default_control_attrs,
 750                 .ct_owner       = THIS_MODULE,
 751         },
 752         .name = "control",
 753         .children = (const struct uvcg_config_group_type*[]) {
 754                 &uvcg_control_header_grp_type,
 755                 &uvcg_processing_grp_type,
 756                 &uvcg_terminal_grp_type,
 757                 &uvcg_control_class_grp_type,
 758                 NULL,
 759         },
 760 };
 761
 762 /* -----------------------------------------------------------------------------
 763  * streaming/uncompressed
 764  * streaming/mjpeg
 765  */
 766
 767 static const char * const uvcg_format_names[] = {
 768         "uncompressed",
 769         "mjpeg",
 770 };
 771
 772 enum uvcg_format_type {
 773         UVCG_UNCOMPRESSED = 0,
 774         UVCG_MJPEG,
 775 };
 776
 777 struct uvcg_format {
 778         struct config_group     group;
 779         enum uvcg_format_type   type;
 780         unsigned                linked;
 781         unsigned                num_frames;
 782         __u8                    bmaControls[UVCG_STREAMING_CONTROL_SIZE];
 783 };
 784
 785 static struct uvcg_format *to_uvcg_format(struct config_item *item)
 786 {
 787         return container_of(to_config_group(item), struct uvcg_format, group);
 788 }
 789
 790 static ssize_t uvcg_format_bma_controls_show(struct uvcg_format *f, char *page)
 791 {
 792         struct f_uvc_opts *opts;
 793         struct config_item *opts_item;
 794         struct mutex *su_mutex = &f->group.cg_subsys->su_mutex;
 795         int result, i;
 796         char *pg = page;
 797
 798         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 799
 800         opts_item = f->group.cg_item.ci_parent->ci_parent->ci_parent;
 801         opts = to_f_uvc_opts(opts_item);
 802
 803         mutex_lock(&opts->lock);
 804         result = sprintf(pg, "0x");
 805         pg += result;
 806         for (i = 0; i < UVCG_STREAMING_CONTROL_SIZE; ++i) {
 807                 result += sprintf(pg, "%x\n", f->bmaControls[i]);
 808                 pg = page + result;
 809         }
 810         mutex_unlock(&opts->lock);
 811
 812         mutex_unlock(su_mutex);
 813         return result;
 814 }
 815
 816 static ssize_t uvcg_format_bma_controls_store(struct uvcg_format *ch,
 817                                               const char *page, size_t len)
 818 {
 819         struct f_uvc_opts *opts;
 820         struct config_item *opts_item;
 821         struct mutex *su_mutex = &ch->group.cg_subsys->su_mutex;
 822         int ret = -EINVAL;
 823
 824         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 825
 826         opts_item = ch->group.cg_item.ci_parent->ci_parent->ci_parent;
 827         opts = to_f_uvc_opts(opts_item);
 828
 829         mutex_lock(&opts->lock);
 830         if (ch->linked || opts->refcnt) {
 831                 ret = -EBUSY;
 832                 goto end;
 833         }
 834
 835         if (len < 4 || *page != '0' ||
 836             (*(page + 1) != 'x' && *(page + 1) != 'X'))
 837                 goto end;
 838         ret = hex2bin(ch->bmaControls, page + 2, 1);
 839         if (ret < 0)
 840                 goto end;
 841         ret = len;
 842 end:
 843         mutex_unlock(&opts->lock);
 844         mutex_unlock(su_mutex);
 845         return ret;
 846 }
 847
 848 struct uvcg_format_ptr {
 849         struct uvcg_format      *fmt;
 850         struct list_head        entry;
 851 };
 852
 853 /* -----------------------------------------------------------------------------
 854  * streaming/header/<NAME>
 855  * streaming/header
 856  */
 857
 858 struct uvcg_streaming_header {
 859         struct config_item                              item;
 860         struct uvc_input_header_descriptor              desc;
 861         unsigned                                        linked;
 862         struct list_head                                formats;
 863         unsigned                                        num_fmt;
 864 };
 865
 866 static struct uvcg_streaming_header *to_uvcg_streaming_header(struct config_item *item)
 867 {
 868         return container_of(item, struct uvcg_streaming_header, item);
 869 }
 870
 871 static void uvcg_format_set_indices(struct config_group *fmt);
 872
 873 static int uvcg_streaming_header_allow_link(struct config_item *src,
 874                                             struct config_item *target)
 875 {
 876         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 877         struct config_item *opts_item;
 878         struct f_uvc_opts *opts;
 879         struct uvcg_streaming_header *src_hdr;
 880         struct uvcg_format *target_fmt = NULL;
 881         struct uvcg_format_ptr *format_ptr;
 882         int i, ret = -EINVAL;
 883
 884         src_hdr = to_uvcg_streaming_header(src);
 885         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 886
 887         opts_item = src->ci_parent->ci_parent->ci_parent;
 888         opts = to_f_uvc_opts(opts_item);
 889
 890         mutex_lock(&opts->lock);
 891
 892         if (src_hdr->linked) {
 893                 ret = -EBUSY;
 894                 goto out;
 895         }
 896
 897         /*
 898          * Linking is only allowed to direct children of the format nodes
 899          * (streaming/uncompressed or streaming/mjpeg nodes). First check that
 900          * the grand-parent of the target matches the grand-parent of the source
 901          * (the streaming node), and then verify that the target parent is a
 902          * format node.
 903          */
 904         if (src->ci_parent->ci_parent != target->ci_parent->ci_parent)
 905                 goto out;
 906
 907         for (i = 0; i < ARRAY_SIZE(uvcg_format_names); ++i) {
 908                 if (!strcmp(target->ci_parent->ci_name, uvcg_format_names[i]))
 909                         break;
 910         }
 911
 912         if (i == ARRAY_SIZE(uvcg_format_names))
 913                 goto out;
 914
 915         target_fmt = container_of(to_config_group(target), struct uvcg_format,
 916                                   group);
 917         if (!target_fmt)
 918                 goto out;
 919
 920         uvcg_format_set_indices(to_config_group(target));
 921
 922         format_ptr = kzalloc(sizeof(*format_ptr), GFP_KERNEL);
 923         if (!format_ptr) {
 924                 ret = -ENOMEM;
 925                 goto out;
 926         }
 927         ret = 0;
 928         format_ptr->fmt = target_fmt;
 929         list_add_tail(&format_ptr->entry, &src_hdr->formats);
 930         ++src_hdr->num_fmt;
 931         ++target_fmt->linked;
 932
 933 out:
 934         mutex_unlock(&opts->lock);
 935         mutex_unlock(su_mutex);
 936         return ret;
 937 }
 938
 939 static void uvcg_streaming_header_drop_link(struct config_item *src,
 940                                            struct config_item *target)
 941 {
 942         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 943         struct config_item *opts_item;
 944         struct f_uvc_opts *opts;
 945         struct uvcg_streaming_header *src_hdr;
 946         struct uvcg_format *target_fmt = NULL;
 947         struct uvcg_format_ptr *format_ptr, *tmp;
 948
 949         src_hdr = to_uvcg_streaming_header(src);
 950         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 951
 952         opts_item = src->ci_parent->ci_parent->ci_parent;
 953         opts = to_f_uvc_opts(opts_item);
 954
 955         mutex_lock(&opts->lock);
 956         target_fmt = container_of(to_config_group(target), struct uvcg_format,
 957                                   group);
 958         if (!target_fmt)
 959                 goto out;
 960
 961         list_for_each_entry_safe(format_ptr, tmp, &src_hdr->formats, entry)
 962                 if (format_ptr->fmt == target_fmt) {
 963                         list_del(&format_ptr->entry);
 964                         kfree(format_ptr);
 965                         --src_hdr->num_fmt;
 966                         break;
 967                 }
 968
 969         --target_fmt->linked;
 970
 971 out:
 972         mutex_unlock(&opts->lock);
 973         mutex_unlock(su_mutex);
 974 }
 975
 976 static struct configfs_item_operations uvcg_streaming_header_item_ops = {
 977         .release        = uvcg_config_item_release,
 978         .allow_link     = uvcg_streaming_header_allow_link,
 979         .drop_link      = uvcg_streaming_header_drop_link,
 980 };
 981
 982 #define UVCG_STREAMING_HEADER_ATTR(cname, aname, bits)                  \
 983 static ssize_t uvcg_streaming_header_##cname##_show(                    \
 984         struct config_item *item, char *page)                           \
 985 {                                                                       \
 986         struct uvcg_streaming_header *sh = to_uvcg_streaming_header(item); \
 987         struct f_uvc_opts *opts;                                        \
 988         struct config_item *opts_item;                                  \
 989         struct mutex *su_mutex = &sh->item.ci_group->cg_subsys->su_mutex;\
 990         int result;                                                     \
 991                                                                         \
 992         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
 993                                                                         \
 994         opts_item = sh->item.ci_parent->ci_parent->ci_parent;           \
 995         opts = to_f_uvc_opts(opts_item);                                \
 996                                                                         \
 997         mutex_lock(&opts->lock);                                        \
 998         result = sprintf(page, "%u\n", le##bits##_to_cpu(sh->desc.aname));\
 999         mutex_unlock(&opts->lock);                                      \
1000                                                                         \
1001         mutex_unlock(su_mutex);                                         \
1002         return result;                                                  \
1003 }                                                                       \
1004                                                                         \
1005 UVC_ATTR_RO(uvcg_streaming_header_, cname, aname)
1006
1007 UVCG_STREAMING_HEADER_ATTR(bm_info, bmInfo, 8);
1008 UVCG_STREAMING_HEADER_ATTR(b_terminal_link, bTerminalLink, 8);
1009 UVCG_STREAMING_HEADER_ATTR(b_still_capture_method, bStillCaptureMethod, 8);
1010 UVCG_STREAMING_HEADER_ATTR(b_trigger_support, bTriggerSupport, 8);
1011 UVCG_STREAMING_HEADER_ATTR(b_trigger_usage, bTriggerUsage, 8);
1012
1013 #undef UVCG_STREAMING_HEADER_ATTR
1014
1015 static struct configfs_attribute *uvcg_streaming_header_attrs[] = {
1016         &uvcg_streaming_header_attr_bm_info,
1017         &uvcg_streaming_header_attr_b_terminal_link,
1018         &uvcg_streaming_header_attr_b_still_capture_method,
1019         &uvcg_streaming_header_attr_b_trigger_support,
1020         &uvcg_streaming_header_attr_b_trigger_usage,
1021         NULL,
1022 };
1023
1024 static const struct config_item_type uvcg_streaming_header_type = {
1025         .ct_item_ops    = &uvcg_streaming_header_item_ops,
1026         .ct_attrs       = uvcg_streaming_header_attrs,
1027         .ct_owner       = THIS_MODULE,
1028 };
1029
1030 static struct config_item
1031 *uvcg_streaming_header_make(struct config_group *group, const char *name)
1032 {
1033         struct uvcg_streaming_header *h;
1034
1035         h = kzalloc(sizeof(*h), GFP_KERNEL);
1036         if (!h)
1037                 return ERR_PTR(-ENOMEM);
1038
1039         INIT_LIST_HEAD(&h->formats);
1040         h->desc.bDescriptorType         = USB_DT_CS_INTERFACE;
1041         h->desc.bDescriptorSubType      = UVC_VS_INPUT_HEADER;
1042         h->desc.bTerminalLink           = 3;
1043         h->desc.bControlSize            = UVCG_STREAMING_CONTROL_SIZE;
1044
1045         config_item_init_type_name(&h->item, name, &uvcg_streaming_header_type);
1046
1047         return &h->item;
1048 }
1049
1050 static struct configfs_group_operations uvcg_streaming_header_grp_ops = {
1051         .make_item              = uvcg_streaming_header_make,
1052 };
1053
1054 static const struct uvcg_config_group_type uvcg_streaming_header_grp_type = {
1055         .type = {
1056                 .ct_item_ops    = &uvcg_config_item_ops,
1057                 .ct_group_ops   = &uvcg_streaming_header_grp_ops,
1058                 .ct_owner       = THIS_MODULE,
1059         },
1060         .name = "header",
1061 };
1062
1063 /* -----------------------------------------------------------------------------
1064  * streaming/<mode>/<format>/<NAME>
1065  */
1066
1067 struct uvcg_frame {
1068         struct config_item      item;
1069         enum uvcg_format_type   fmt_type;
1070         struct {
1071                 u8      b_length;
1072                 u8      b_descriptor_type;
1073                 u8      b_descriptor_subtype;
1074                 u8      b_frame_index;
1075                 u8      bm_capabilities;
1076                 u16     w_width;
1077                 u16     w_height;
1078                 u32     dw_min_bit_rate;
1079                 u32     dw_max_bit_rate;
1080                 u32     dw_max_video_frame_buffer_size;
1081                 u32     dw_default_frame_interval;
1082                 u8      b_frame_interval_type;
1083         } __attribute__((packed)) frame;
1084         u32 *dw_frame_interval;
1085 };
1086
1087 static struct uvcg_frame *to_uvcg_frame(struct config_item *item)
1088 {
1089         return container_of(item, struct uvcg_frame, item);
1090 }
1091
1092 #define UVCG_FRAME_ATTR(cname, aname, bits) \
1093 static ssize_t uvcg_frame_##cname##_show(struct config_item *item, char *page)\
1094 {                                                                       \
1095         struct uvcg_frame *f = to_uvcg_frame(item);                     \
1096         struct f_uvc_opts *opts;                                        \
1097         struct config_item *opts_item;                                  \
1098         struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
1099         int result;                                                     \
1100                                                                         \
1101         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1102                                                                         \
1103         opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
1104         opts = to_f_uvc_opts(opts_item);                                \
1105                                                                         \
1106         mutex_lock(&opts->lock);                                        \
1107         result = sprintf(page, "%u\n", f->frame.cname);                 \
1108         mutex_unlock(&opts->lock);                                      \
1109                                                                         \
1110         mutex_unlock(su_mutex);                                         \
1111         return result;                                                  \
1112 }                                                                       \
1113                                                                         \
1114 static ssize_t  uvcg_frame_##cname##_store(struct config_item *item,    \
1115                                            const char *page, size_t len)\
1116 {                                                                       \
1117         struct uvcg_frame *f = to_uvcg_frame(item);                     \
1118         struct f_uvc_opts *opts;                                        \
1119         struct config_item *opts_item;                                  \
1120         struct uvcg_format *fmt;                                        \
1121         struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
1122         typeof(f->frame.cname) num;                                     \
1123         int ret;                                                        \
1124                                                                         \
1125         ret = kstrtou##bits(page, 0, &num);                             \
1126         if (ret)                                                        \
1127                 return ret;                                             \
1128                                                                         \
1129         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1130                                                                         \
1131         opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
1132         opts = to_f_uvc_opts(opts_item);                                \
1133         fmt = to_uvcg_format(f->item.ci_parent);                        \
1134                                                                         \
1135         mutex_lock(&opts->lock);                                        \
1136         if (fmt->linked || opts->refcnt) {                              \
1137                 ret = -EBUSY;                                           \
1138                 goto end;                                               \
1139         }                                                               \
1140                                                                         \
1141         f->frame.cname = num;                                           \
1142         ret = len;                                                      \
1143 end:                                                                    \
1144         mutex_unlock(&opts->lock);                                      \
1145         mutex_unlock(su_mutex);                                         \
1146         return ret;                                                     \
1147 }                                                                       \
1148                                                                         \
1149 UVC_ATTR(uvcg_frame_, cname, aname);
1150
1151 static ssize_t uvcg_frame_b_frame_index_show(struct config_item *item,
1152                                              char *page)
1153 {
1154         struct uvcg_frame *f = to_uvcg_frame(item);
1155         struct uvcg_format *fmt;
1156         struct f_uvc_opts *opts;
1157         struct config_item *opts_item;
1158         struct config_item *fmt_item;
1159         struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;
1160         int result;
1161
1162         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1163
1164         fmt_item = f->item.ci_parent;
1165         fmt = to_uvcg_format(fmt_item);
1166
1167         if (!fmt->linked) {
1168                 result = -EBUSY;
1169                 goto out;
1170         }
1171
1172         opts_item = fmt_item->ci_parent->ci_parent->ci_parent;
1173         opts = to_f_uvc_opts(opts_item);
1174
1175         mutex_lock(&opts->lock);
1176         result = sprintf(page, "%u\n", f->frame.b_frame_index);
1177         mutex_unlock(&opts->lock);
1178
1179 out:
1180         mutex_unlock(su_mutex);
1181         return result;
1182 }
1183
1184 UVC_ATTR_RO(uvcg_frame_, b_frame_index, bFrameIndex);
1185
1186 UVCG_FRAME_ATTR(bm_capabilities, bmCapabilities, 8);
1187 UVCG_FRAME_ATTR(w_width, wWidth, 16);
1188 UVCG_FRAME_ATTR(w_height, wHeight, 16);
1189 UVCG_FRAME_ATTR(dw_min_bit_rate, dwMinBitRate, 32);
1190 UVCG_FRAME_ATTR(dw_max_bit_rate, dwMaxBitRate, 32);
1191 UVCG_FRAME_ATTR(dw_max_video_frame_buffer_size, dwMaxVideoFrameBufferSize, 32);
1192 UVCG_FRAME_ATTR(dw_default_frame_interval, dwDefaultFrameInterval, 32);
1193
1194 #undef UVCG_FRAME_ATTR
1195
1196 static ssize_t uvcg_frame_dw_frame_interval_show(struct config_item *item,
1197                                                  char *page)
1198 {
1199         struct uvcg_frame *frm = to_uvcg_frame(item);
1200         struct f_uvc_opts *opts;
1201         struct config_item *opts_item;
1202         struct mutex *su_mutex = &frm->item.ci_group->cg_subsys->su_mutex;
1203         int result, i;
1204         char *pg = page;
1205
1206         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1207
1208         opts_item = frm->item.ci_parent->ci_parent->ci_parent->ci_parent;
1209         opts = to_f_uvc_opts(opts_item);
1210
1211         mutex_lock(&opts->lock);
1212         for (result = 0, i = 0; i < frm->frame.b_frame_interval_type; ++i) {
1213                 result += sprintf(pg, "%u\n", frm->dw_frame_interval[i]);
1214                 pg = page + result;
1215         }
1216         mutex_unlock(&opts->lock);
1217
1218         mutex_unlock(su_mutex);
1219         return result;
1220 }
1221
1222 static inline int __uvcg_count_frm_intrv(char *buf, void *priv)
1223 {
1224         ++*((int *)priv);
1225         return 0;
1226 }
1227
1228 static inline int __uvcg_fill_frm_intrv(char *buf, void *priv)
1229 {
1230         u32 num, **interv;
1231         int ret;
1232
1233         ret = kstrtou32(buf, 0, &num);
1234         if (ret)
1235                 return ret;
1236
1237         interv = priv;
1238         **interv = num;
1239         ++*interv;
1240
1241         return 0;
1242 }
1243
1244 static int __uvcg_iter_frm_intrv(const char *page, size_t len,
1245                                  int (*fun)(char *, void *), void *priv)
1246 {
1247         /* sign, base 2 representation, newline, terminator */
1248         char buf[1 + sizeof(u32) * 8 + 1 + 1];
1249         const char *pg = page;
1250         int i, ret;
1251
1252         if (!fun)
1253                 return -EINVAL;
1254
1255         while (pg - page < len) {
1256                 i = 0;
1257                 while (i < sizeof(buf) && (pg - page < len) &&
1258                                 *pg != '\0' && *pg != '\n')
1259                         buf[i++] = *pg++;
1260                 if (i == sizeof(buf))
1261                         return -EINVAL;
1262                 while ((pg - page < len) && (*pg == '\0' || *pg == '\n'))
1263                         ++pg;
1264                 buf[i] = '\0';
1265                 ret = fun(buf, priv);
1266                 if (ret)
1267                         return ret;
1268         }
1269
1270         return 0;
1271 }
1272
1273 static ssize_t uvcg_frame_dw_frame_interval_store(struct config_item *item,
1274                                                   const char *page, size_t len)
1275 {
1276         struct uvcg_frame *ch = to_uvcg_frame(item);
1277         struct f_uvc_opts *opts;
1278         struct config_item *opts_item;
1279         struct uvcg_format *fmt;
1280         struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;
1281         int ret = 0, n = 0;
1282         u32 *frm_intrv, *tmp;
1283
1284         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1285
1286         opts_item = ch->item.ci_parent->ci_parent->ci_parent->ci_parent;
1287         opts = to_f_uvc_opts(opts_item);
1288         fmt = to_uvcg_format(ch->item.ci_parent);
1289
1290         mutex_lock(&opts->lock);
1291         if (fmt->linked || opts->refcnt) {
1292                 ret = -EBUSY;
1293                 goto end;
1294         }
1295
1296         ret = __uvcg_iter_frm_intrv(page, len, __uvcg_count_frm_intrv, &n);
1297         if (ret)
1298                 goto end;
1299
1300         tmp = frm_intrv = kcalloc(n, sizeof(u32), GFP_KERNEL);
1301         if (!frm_intrv) {
1302                 ret = -ENOMEM;
1303                 goto end;
1304         }
1305
1306         ret = __uvcg_iter_frm_intrv(page, len, __uvcg_fill_frm_intrv, &tmp);
1307         if (ret) {
1308                 kfree(frm_intrv);
1309                 goto end;
1310         }
1311
1312         kfree(ch->dw_frame_interval);
1313         ch->dw_frame_interval = frm_intrv;
1314         ch->frame.b_frame_interval_type = n;
1315         sort(ch->dw_frame_interval, n, sizeof(*ch->dw_frame_interval),
1316              uvcg_config_compare_u32, NULL);
1317         ret = len;
1318
1319 end:
1320         mutex_unlock(&opts->lock);
1321         mutex_unlock(su_mutex);
1322         return ret;
1323 }
1324
1325 UVC_ATTR(uvcg_frame_, dw_frame_interval, dwFrameInterval);
1326
1327 static struct configfs_attribute *uvcg_frame_attrs[] = {
1328         &uvcg_frame_attr_b_frame_index,
1329         &uvcg_frame_attr_bm_capabilities,
1330         &uvcg_frame_attr_w_width,
1331         &uvcg_frame_attr_w_height,
1332         &uvcg_frame_attr_dw_min_bit_rate,
1333         &uvcg_frame_attr_dw_max_bit_rate,
1334         &uvcg_frame_attr_dw_max_video_frame_buffer_size,
1335         &uvcg_frame_attr_dw_default_frame_interval,
1336         &uvcg_frame_attr_dw_frame_interval,
1337         NULL,
1338 };
1339
1340 static const struct config_item_type uvcg_frame_type = {
1341         .ct_item_ops    = &uvcg_config_item_ops,
1342         .ct_attrs       = uvcg_frame_attrs,
1343         .ct_owner       = THIS_MODULE,
1344 };
1345
1346 static struct config_item *uvcg_frame_make(struct config_group *group,
1347                                            const char *name)
1348 {
1349         struct uvcg_frame *h;
1350         struct uvcg_format *fmt;
1351         struct f_uvc_opts *opts;
1352         struct config_item *opts_item;
1353
1354         h = kzalloc(sizeof(*h), GFP_KERNEL);
1355         if (!h)
1356                 return ERR_PTR(-ENOMEM);
1357
1358         h->frame.b_descriptor_type              = USB_DT_CS_INTERFACE;
1359         h->frame.b_frame_index                  = 1;
1360         h->frame.w_width                        = 640;
1361         h->frame.w_height                       = 360;
1362         h->frame.dw_min_bit_rate                = 18432000;
1363         h->frame.dw_max_bit_rate                = 55296000;
1364         h->frame.dw_max_video_frame_buffer_size = 460800;
1365         h->frame.dw_default_frame_interval      = 666666;
1366
1367         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
1368         opts = to_f_uvc_opts(opts_item);
1369
1370         mutex_lock(&opts->lock);
1371         fmt = to_uvcg_format(&group->cg_item);
1372         if (fmt->type == UVCG_UNCOMPRESSED) {
1373                 h->frame.b_descriptor_subtype = UVC_VS_FRAME_UNCOMPRESSED;
1374                 h->fmt_type = UVCG_UNCOMPRESSED;
1375         } else if (fmt->type == UVCG_MJPEG) {
1376                 h->frame.b_descriptor_subtype = UVC_VS_FRAME_MJPEG;
1377                 h->fmt_type = UVCG_MJPEG;
1378         } else {
1379                 mutex_unlock(&opts->lock);
1380                 kfree(h);
1381                 return ERR_PTR(-EINVAL);
1382         }
1383         ++fmt->num_frames;
1384         mutex_unlock(&opts->lock);
1385
1386         config_item_init_type_name(&h->item, name, &uvcg_frame_type);
1387
1388         return &h->item;
1389 }
1390
1391 static void uvcg_frame_drop(struct config_group *group, struct config_item *item)
1392 {
1393         struct uvcg_format *fmt;
1394         struct f_uvc_opts *opts;
1395         struct config_item *opts_item;
1396
1397         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
1398         opts = to_f_uvc_opts(opts_item);
1399
1400         mutex_lock(&opts->lock);
1401         fmt = to_uvcg_format(&group->cg_item);
1402         --fmt->num_frames;
1403         mutex_unlock(&opts->lock);
1404
1405         config_item_put(item);
1406 }
1407
1408 static void uvcg_format_set_indices(struct config_group *fmt)
1409 {
1410         struct config_item *ci;
1411         unsigned int i = 1;
1412
1413         list_for_each_entry(ci, &fmt->cg_children, ci_entry) {
1414                 struct uvcg_frame *frm;
1415
1416                 if (ci->ci_type != &uvcg_frame_type)
1417                         continue;
1418
1419                 frm = to_uvcg_frame(ci);
1420                 frm->frame.b_frame_index = i++;
1421         }
1422 }
1423
1424 /* -----------------------------------------------------------------------------
1425  * streaming/uncompressed/<NAME>
1426  */
1427
1428 struct uvcg_uncompressed {
1429         struct uvcg_format              fmt;
1430         struct uvc_format_uncompressed  desc;
1431 };
1432
1433 static struct uvcg_uncompressed *to_uvcg_uncompressed(struct config_item *item)
1434 {
1435         return container_of(
1436                 container_of(to_config_group(item), struct uvcg_format, group),
1437                 struct uvcg_uncompressed, fmt);
1438 }
1439
1440 static struct configfs_group_operations uvcg_uncompressed_group_ops = {
1441         .make_item              = uvcg_frame_make,
1442         .drop_item              = uvcg_frame_drop,
1443 };
1444
1445 static ssize_t uvcg_uncompressed_guid_format_show(struct config_item *item,
1446                                                         char *page)
1447 {
1448         struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
1449         struct f_uvc_opts *opts;
1450         struct config_item *opts_item;
1451         struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;
1452
1453         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1454
1455         opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
1456         opts = to_f_uvc_opts(opts_item);
1457
1458         mutex_lock(&opts->lock);
1459         memcpy(page, ch->desc.guidFormat, sizeof(ch->desc.guidFormat));
1460         mutex_unlock(&opts->lock);
1461
1462         mutex_unlock(su_mutex);
1463
1464         return sizeof(ch->desc.guidFormat);
1465 }
1466
1467 static ssize_t uvcg_uncompressed_guid_format_store(struct config_item *item,
1468                                                    const char *page, size_t len)
1469 {
1470         struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
1471         struct f_uvc_opts *opts;
1472         struct config_item *opts_item;
1473         struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;
1474         int ret;
1475
1476         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1477
1478         opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
1479         opts = to_f_uvc_opts(opts_item);
1480
1481         mutex_lock(&opts->lock);
1482         if (ch->fmt.linked || opts->refcnt) {
1483                 ret = -EBUSY;
1484                 goto end;
1485         }
1486
1487         memcpy(ch->desc.guidFormat, page,
1488                min(sizeof(ch->desc.guidFormat), len));
1489         ret = sizeof(ch->desc.guidFormat);
1490
1491 end:
1492         mutex_unlock(&opts->lock);
1493         mutex_unlock(su_mutex);
1494         return ret;
1495 }
1496
1497 UVC_ATTR(uvcg_uncompressed_, guid_format, guidFormat);
1498
1499 #define UVCG_UNCOMPRESSED_ATTR_RO(cname, aname, bits)                   \
1500 static ssize_t uvcg_uncompressed_##cname##_show(                        \
1501         struct config_item *item, char *page)                           \
1502 {                                                                       \
1503         struct uvcg_uncompressed *u = to_uvcg_uncompressed(item);       \
1504         struct f_uvc_opts *opts;                                        \
1505         struct config_item *opts_item;                                  \
1506         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
1507         int result;                                                     \
1508                                                                         \
1509         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1510                                                                         \
1511         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1512         opts = to_f_uvc_opts(opts_item);                                \
1513                                                                         \
1514         mutex_lock(&opts->lock);                                        \
1515         result = sprintf(page, "%u\n", le##bits##_to_cpu(u->desc.aname));\
1516         mutex_unlock(&opts->lock);                                      \
1517                                                                         \
1518         mutex_unlock(su_mutex);                                         \
1519         return result;                                                  \
1520 }                                                                       \
1521                                                                         \
1522 UVC_ATTR_RO(uvcg_uncompressed_, cname, aname);
1523
1524 #define UVCG_UNCOMPRESSED_ATTR(cname, aname, bits)                      \
1525 static ssize_t uvcg_uncompressed_##cname##_show(                        \
1526         struct config_item *item, char *page)                           \
1527 {                                                                       \
1528         struct uvcg_uncompressed *u = to_uvcg_uncompressed(item);       \
1529         struct f_uvc_opts *opts;                                        \
1530         struct config_item *opts_item;                                  \
1531         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
1532         int result;                                                     \
1533                                                                         \
1534         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1535                                                                         \
1536         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1537         opts = to_f_uvc_opts(opts_item);                                \
1538                                                                         \
1539         mutex_lock(&opts->lock);                                        \
1540         result = sprintf(page, "%u\n", le##bits##_to_cpu(u->desc.aname));\
1541         mutex_unlock(&opts->lock);                                      \
1542                                                                         \
1543         mutex_unlock(su_mutex);                                         \
1544         return result;                                                  \
1545 }                                                                       \
1546                                                                         \
1547 static ssize_t                                                          \
1548 uvcg_uncompressed_##cname##_store(struct config_item *item,             \
1549                                     const char *page, size_t len)       \
1550 {                                                                       \
1551         struct uvcg_uncompressed *u = to_uvcg_uncompressed(item);       \
1552         struct f_uvc_opts *opts;                                        \
1553         struct config_item *opts_item;                                  \
1554         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
1555         int ret;                                                        \
1556         u8 num;                                                         \
1557                                                                         \
1558         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1559                                                                         \
1560         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1561         opts = to_f_uvc_opts(opts_item);                                \
1562                                                                         \
1563         mutex_lock(&opts->lock);                                        \
1564         if (u->fmt.linked || opts->refcnt) {                            \
1565                 ret = -EBUSY;                                           \
1566                 goto end;                                               \
1567         }                                                               \
1568                                                                         \
1569         ret = kstrtou8(page, 0, &num);                                  \
1570         if (ret)                                                        \
1571                 goto end;                                               \
1572                                                                         \
1573         u->desc.aname = num;                                            \
1574         ret = len;                                                      \
1575 end:                                                                    \
1576         mutex_unlock(&opts->lock);                                      \
1577         mutex_unlock(su_mutex);                                         \
1578         return ret;                                                     \
1579 }                                                                       \
1580                                                                         \
1581 UVC_ATTR(uvcg_uncompressed_, cname, aname);
1582
1583 UVCG_UNCOMPRESSED_ATTR_RO(b_format_index, bFormatIndex, 8);
1584 UVCG_UNCOMPRESSED_ATTR(b_bits_per_pixel, bBitsPerPixel, 8);
1585 UVCG_UNCOMPRESSED_ATTR(b_default_frame_index, bDefaultFrameIndex, 8);
1586 UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_x, bAspectRatioX, 8);
1587 UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_y, bAspectRatioY, 8);
1588 UVCG_UNCOMPRESSED_ATTR_RO(bm_interface_flags, bmInterfaceFlags, 8);
1589
1590 #undef UVCG_UNCOMPRESSED_ATTR
1591 #undef UVCG_UNCOMPRESSED_ATTR_RO
1592
1593 static inline ssize_t
1594 uvcg_uncompressed_bma_controls_show(struct config_item *item, char *page)
1595 {
1596         struct uvcg_uncompressed *unc = to_uvcg_uncompressed(item);
1597         return uvcg_format_bma_controls_show(&unc->fmt, page);
1598 }
1599
1600 static inline ssize_t
1601 uvcg_uncompressed_bma_controls_store(struct config_item *item,
1602                                      const char *page, size_t len)
1603 {
1604         struct uvcg_uncompressed *unc = to_uvcg_uncompressed(item);
1605         return uvcg_format_bma_controls_store(&unc->fmt, page, len);
1606 }
1607
1608 UVC_ATTR(uvcg_uncompressed_, bma_controls, bmaControls);
1609
1610 static struct configfs_attribute *uvcg_uncompressed_attrs[] = {
1611         &uvcg_uncompressed_attr_b_format_index,
1612         &uvcg_uncompressed_attr_guid_format,
1613         &uvcg_uncompressed_attr_b_bits_per_pixel,
1614         &uvcg_uncompressed_attr_b_default_frame_index,
1615         &uvcg_uncompressed_attr_b_aspect_ratio_x,
1616         &uvcg_uncompressed_attr_b_aspect_ratio_y,
1617         &uvcg_uncompressed_attr_bm_interface_flags,
1618         &uvcg_uncompressed_attr_bma_controls,
1619         NULL,
1620 };
1621
1622 static const struct config_item_type uvcg_uncompressed_type = {
1623         .ct_item_ops    = &uvcg_config_item_ops,
1624         .ct_group_ops   = &uvcg_uncompressed_group_ops,
1625         .ct_attrs       = uvcg_uncompressed_attrs,
1626         .ct_owner       = THIS_MODULE,
1627 };
1628
1629 static struct config_group *uvcg_uncompressed_make(struct config_group *group,
1630                                                    const char *name)
1631 {
1632         static char guid[] = {
1633                 'Y',  'U',  'Y',  '2', 0x00, 0x00, 0x10, 0x00,
1634                  0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71
1635         };
1636         struct uvcg_uncompressed *h;
1637
1638         h = kzalloc(sizeof(*h), GFP_KERNEL);
1639         if (!h)
1640                 return ERR_PTR(-ENOMEM);
1641
1642         h->desc.bLength                 = UVC_DT_FORMAT_UNCOMPRESSED_SIZE;
1643         h->desc.bDescriptorType         = USB_DT_CS_INTERFACE;
1644         h->desc.bDescriptorSubType      = UVC_VS_FORMAT_UNCOMPRESSED;
1645         memcpy(h->desc.guidFormat, guid, sizeof(guid));
1646         h->desc.bBitsPerPixel           = 16;
1647         h->desc.bDefaultFrameIndex      = 1;
1648         h->desc.bAspectRatioX           = 0;
1649         h->desc.bAspectRatioY           = 0;
1650         h->desc.bmInterfaceFlags        = 0;
1651         h->desc.bCopyProtect            = 0;
1652
1653         h->fmt.type = UVCG_UNCOMPRESSED;
1654         config_group_init_type_name(&h->fmt.group, name,
1655                                     &uvcg_uncompressed_type);
1656
1657         return &h->fmt.group;
1658 }
1659
1660 static struct configfs_group_operations uvcg_uncompressed_grp_ops = {
1661         .make_group             = uvcg_uncompressed_make,
1662 };
1663
1664 static const struct uvcg_config_group_type uvcg_uncompressed_grp_type = {
1665         .type = {
1666                 .ct_item_ops    = &uvcg_config_item_ops,
1667                 .ct_group_ops   = &uvcg_uncompressed_grp_ops,
1668                 .ct_owner       = THIS_MODULE,
1669         },
1670         .name = "uncompressed",
1671 };
1672
1673 /* -----------------------------------------------------------------------------
1674  * streaming/mjpeg/<NAME>
1675  */
1676
1677 struct uvcg_mjpeg {
1678         struct uvcg_format              fmt;
1679         struct uvc_format_mjpeg         desc;
1680 };
1681
1682 static struct uvcg_mjpeg *to_uvcg_mjpeg(struct config_item *item)
1683 {
1684         return container_of(
1685                 container_of(to_config_group(item), struct uvcg_format, group),
1686                 struct uvcg_mjpeg, fmt);
1687 }
1688
1689 static struct configfs_group_operations uvcg_mjpeg_group_ops = {
1690         .make_item              = uvcg_frame_make,
1691         .drop_item              = uvcg_frame_drop,
1692 };
1693
1694 #define UVCG_MJPEG_ATTR_RO(cname, aname, bits)                          \
1695 static ssize_t uvcg_mjpeg_##cname##_show(struct config_item *item, char *page)\
1696 {                                                                       \
1697         struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);                     \
1698         struct f_uvc_opts *opts;                                        \
1699         struct config_item *opts_item;                                  \
1700         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
1701         int result;                                                     \
1702                                                                         \
1703         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1704                                                                         \
1705         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1706         opts = to_f_uvc_opts(opts_item);                                \
1707                                                                         \
1708         mutex_lock(&opts->lock);                                        \
1709         result = sprintf(page, "%u\n", le##bits##_to_cpu(u->desc.aname));\
1710         mutex_unlock(&opts->lock);                                      \
1711                                                                         \
1712         mutex_unlock(su_mutex);                                         \
1713         return result;                                                  \
1714 }                                                                       \
1715                                                                         \
1716 UVC_ATTR_RO(uvcg_mjpeg_, cname, aname)
1717
1718 #define UVCG_MJPEG_ATTR(cname, aname, bits)                             \
1719 static ssize_t uvcg_mjpeg_##cname##_show(struct config_item *item, char *page)\
1720 {                                                                       \
1721         struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);                     \
1722         struct f_uvc_opts *opts;                                        \
1723         struct config_item *opts_item;                                  \
1724         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
1725         int result;                                                     \
1726                                                                         \
1727         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1728                                                                         \
1729         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1730         opts = to_f_uvc_opts(opts_item);                                \
1731                                                                         \
1732         mutex_lock(&opts->lock);                                        \
1733         result = sprintf(page, "%u\n", le##bits##_to_cpu(u->desc.aname));\
1734         mutex_unlock(&opts->lock);                                      \
1735                                                                         \
1736         mutex_unlock(su_mutex);                                         \
1737         return result;                                                  \
1738 }                                                                       \
1739                                                                         \
1740 static ssize_t                                                          \
1741 uvcg_mjpeg_##cname##_store(struct config_item *item,                    \
1742                            const char *page, size_t len)                \
1743 {                                                                       \
1744         struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);                     \
1745         struct f_uvc_opts *opts;                                        \
1746         struct config_item *opts_item;                                  \
1747         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
1748         int ret;                                                        \
1749         u8 num;                                                         \
1750                                                                         \
1751         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1752                                                                         \
1753         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
1754         opts = to_f_uvc_opts(opts_item);                                \
1755                                                                         \
1756         mutex_lock(&opts->lock);                                        \
1757         if (u->fmt.linked || opts->refcnt) {                            \
1758                 ret = -EBUSY;                                           \
1759                 goto end;                                               \
1760         }                                                               \
1761                                                                         \
1762         ret = kstrtou8(page, 0, &num);                                  \
1763         if (ret)                                                        \
1764                 goto end;                                               \
1765                                                                         \
1766         u->desc.aname = num;                                            \
1767         ret = len;                                                      \
1768 end:                                                                    \
1769         mutex_unlock(&opts->lock);                                      \
1770         mutex_unlock(su_mutex);                                         \
1771         return ret;                                                     \
1772 }                                                                       \
1773                                                                         \
1774 UVC_ATTR(uvcg_mjpeg_, cname, aname)
1775
1776 UVCG_MJPEG_ATTR_RO(b_format_index, bFormatIndex, 8);
1777 UVCG_MJPEG_ATTR(b_default_frame_index, bDefaultFrameIndex, 8);
1778 UVCG_MJPEG_ATTR_RO(bm_flags, bmFlags, 8);
1779 UVCG_MJPEG_ATTR_RO(b_aspect_ratio_x, bAspectRatioX, 8);
1780 UVCG_MJPEG_ATTR_RO(b_aspect_ratio_y, bAspectRatioY, 8);
1781 UVCG_MJPEG_ATTR_RO(bm_interface_flags, bmInterfaceFlags, 8);
1782
1783 #undef UVCG_MJPEG_ATTR
1784 #undef UVCG_MJPEG_ATTR_RO
1785
1786 static inline ssize_t
1787 uvcg_mjpeg_bma_controls_show(struct config_item *item, char *page)
1788 {
1789         struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);
1790         return uvcg_format_bma_controls_show(&u->fmt, page);
1791 }
1792
1793 static inline ssize_t
1794 uvcg_mjpeg_bma_controls_store(struct config_item *item,
1795                                      const char *page, size_t len)
1796 {
1797         struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);
1798         return uvcg_format_bma_controls_store(&u->fmt, page, len);
1799 }
1800
1801 UVC_ATTR(uvcg_mjpeg_, bma_controls, bmaControls);
1802
1803 static struct configfs_attribute *uvcg_mjpeg_attrs[] = {
1804         &uvcg_mjpeg_attr_b_format_index,
1805         &uvcg_mjpeg_attr_b_default_frame_index,
1806         &uvcg_mjpeg_attr_bm_flags,
1807         &uvcg_mjpeg_attr_b_aspect_ratio_x,
1808         &uvcg_mjpeg_attr_b_aspect_ratio_y,
1809         &uvcg_mjpeg_attr_bm_interface_flags,
1810         &uvcg_mjpeg_attr_bma_controls,
1811         NULL,
1812 };
1813
1814 static const struct config_item_type uvcg_mjpeg_type = {
1815         .ct_item_ops    = &uvcg_config_item_ops,
1816         .ct_group_ops   = &uvcg_mjpeg_group_ops,
1817         .ct_attrs       = uvcg_mjpeg_attrs,
1818         .ct_owner       = THIS_MODULE,
1819 };
1820
1821 static struct config_group *uvcg_mjpeg_make(struct config_group *group,
1822                                                    const char *name)
1823 {
1824         struct uvcg_mjpeg *h;
1825
1826         h = kzalloc(sizeof(*h), GFP_KERNEL);
1827         if (!h)
1828                 return ERR_PTR(-ENOMEM);
1829
1830         h->desc.bLength                 = UVC_DT_FORMAT_MJPEG_SIZE;
1831         h->desc.bDescriptorType         = USB_DT_CS_INTERFACE;
1832         h->desc.bDescriptorSubType      = UVC_VS_FORMAT_MJPEG;
1833         h->desc.bDefaultFrameIndex      = 1;
1834         h->desc.bAspectRatioX           = 0;
1835         h->desc.bAspectRatioY           = 0;
1836         h->desc.bmInterfaceFlags        = 0;
1837         h->desc.bCopyProtect            = 0;
1838
1839         h->fmt.type = UVCG_MJPEG;
1840         config_group_init_type_name(&h->fmt.group, name,
1841                                     &uvcg_mjpeg_type);
1842
1843         return &h->fmt.group;
1844 }
1845
1846 static struct configfs_group_operations uvcg_mjpeg_grp_ops = {
1847         .make_group             = uvcg_mjpeg_make,
1848 };
1849
1850 static const struct uvcg_config_group_type uvcg_mjpeg_grp_type = {
1851         .type = {
1852                 .ct_item_ops    = &uvcg_config_item_ops,
1853                 .ct_group_ops   = &uvcg_mjpeg_grp_ops,
1854                 .ct_owner       = THIS_MODULE,
1855         },
1856         .name = "mjpeg",
1857 };
1858
1859 /* -----------------------------------------------------------------------------
1860  * streaming/color_matching/default
1861  */
1862
1863 #define UVCG_DEFAULT_COLOR_MATCHING_ATTR(cname, aname, bits)            \
1864 static ssize_t uvcg_default_color_matching_##cname##_show(              \
1865         struct config_item *item, char *page)                           \
1866 {                                                                       \
1867         struct config_group *group = to_config_group(item);             \
1868         struct f_uvc_opts *opts;                                        \
1869         struct config_item *opts_item;                                  \
1870         struct mutex *su_mutex = &group->cg_subsys->su_mutex;           \
1871         struct uvc_color_matching_descriptor *cd;                       \
1872         int result;                                                     \
1873                                                                         \
1874         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1875                                                                         \
1876         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;     \
1877         opts = to_f_uvc_opts(opts_item);                                \
1878         cd = &opts->uvc_color_matching;                                 \
1879                                                                         \
1880         mutex_lock(&opts->lock);                                        \
1881         result = sprintf(page, "%u\n", le##bits##_to_cpu(cd->aname));   \
1882         mutex_unlock(&opts->lock);                                      \
1883                                                                         \
1884         mutex_unlock(su_mutex);                                         \
1885         return result;                                                  \
1886 }                                                                       \
1887                                                                         \
1888 UVC_ATTR_RO(uvcg_default_color_matching_, cname, aname)
1889
1890 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_color_primaries, bColorPrimaries, 8);
1891 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_transfer_characteristics,
1892                                  bTransferCharacteristics, 8);
1893 UVCG_DEFAULT_COLOR_MATCHING_ATTR(b_matrix_coefficients, bMatrixCoefficients, 8);
1894
1895 #undef UVCG_DEFAULT_COLOR_MATCHING_ATTR
1896
1897 static struct configfs_attribute *uvcg_default_color_matching_attrs[] = {
1898         &uvcg_default_color_matching_attr_b_color_primaries,
1899         &uvcg_default_color_matching_attr_b_transfer_characteristics,
1900         &uvcg_default_color_matching_attr_b_matrix_coefficients,
1901         NULL,
1902 };
1903
1904 static const struct uvcg_config_group_type uvcg_default_color_matching_type = {
1905         .type = {
1906                 .ct_item_ops    = &uvcg_config_item_ops,
1907                 .ct_attrs       = uvcg_default_color_matching_attrs,
1908                 .ct_owner       = THIS_MODULE,
1909         },
1910         .name = "default",
1911 };
1912
1913 /* -----------------------------------------------------------------------------
1914  * streaming/color_matching
1915  */
1916
1917 static const struct uvcg_config_group_type uvcg_color_matching_grp_type = {
1918         .type = {
1919                 .ct_item_ops    = &uvcg_config_item_ops,
1920                 .ct_owner       = THIS_MODULE,
1921         },
1922         .name = "color_matching",
1923         .children = (const struct uvcg_config_group_type*[]) {
1924                 &uvcg_default_color_matching_type,
1925                 NULL,
1926         },
1927 };
1928
1929 /* -----------------------------------------------------------------------------
1930  * streaming/class/{fs|hs|ss}
1931  */
1932
1933 struct uvcg_streaming_class_group {
1934         struct config_group group;
1935         const char *name;
1936 };
1937
1938 static inline struct uvc_descriptor_header
1939 ***__uvcg_get_stream_class_arr(struct config_item *i, struct f_uvc_opts *o)
1940 {
1941         struct uvcg_streaming_class_group *group =
1942                 container_of(i, struct uvcg_streaming_class_group,
1943                              group.cg_item);
1944
1945         if (!strcmp(group->name, "fs"))
1946                 return &o->uvc_fs_streaming_cls;
1947
1948         if (!strcmp(group->name, "hs"))
1949                 return &o->uvc_hs_streaming_cls;
1950
1951         if (!strcmp(group->name, "ss"))
1952                 return &o->uvc_ss_streaming_cls;
1953
1954         return NULL;
1955 }
1956
1957 enum uvcg_strm_type {
1958         UVCG_HEADER = 0,
1959         UVCG_FORMAT,
1960         UVCG_FRAME
1961 };
1962
1963 /*
1964  * Iterate over a hierarchy of streaming descriptors' config items.
1965  * The items are created by the user with configfs.
1966  *
1967  * It "processes" the header pointed to by @priv1, then for each format
1968  * that follows the header "processes" the format itself and then for
1969  * each frame inside a format "processes" the frame.
1970  *
1971  * As a "processing" function the @fun is used.
1972  *
1973  * __uvcg_iter_strm_cls() is used in two context: first, to calculate
1974  * the amount of memory needed for an array of streaming descriptors
1975  * and second, to actually fill the array.
1976  *
1977  * @h: streaming header pointer
1978  * @priv2: an "inout" parameter (the caller might want to see the changes to it)
1979  * @priv3: an "inout" parameter (the caller might want to see the changes to it)
1980  * @fun: callback function for processing each level of the hierarchy
1981  */
1982 static int __uvcg_iter_strm_cls(struct uvcg_streaming_header *h,
1983         void *priv2, void *priv3,
1984         int (*fun)(void *, void *, void *, int, enum uvcg_strm_type type))
1985 {
1986         struct uvcg_format_ptr *f;
1987         struct config_group *grp;
1988         struct config_item *item;
1989         struct uvcg_frame *frm;
1990         int ret, i, j;
1991
1992         if (!fun)
1993                 return -EINVAL;
1994
1995         i = j = 0;
1996         ret = fun(h, priv2, priv3, 0, UVCG_HEADER);
1997         if (ret)
1998                 return ret;
1999         list_for_each_entry(f, &h->formats, entry) {
2000                 ret = fun(f->fmt, priv2, priv3, i++, UVCG_FORMAT);
2001                 if (ret)
2002                         return ret;
2003                 grp = &f->fmt->group;
2004                 list_for_each_entry(item, &grp->cg_children, ci_entry) {
2005                         frm = to_uvcg_frame(item);
2006                         ret = fun(frm, priv2, priv3, j++, UVCG_FRAME);
2007                         if (ret)
2008                                 return ret;
2009                 }
2010         }
2011
2012         return ret;
2013 }
2014
2015 /*
2016  * Count how many bytes are needed for an array of streaming descriptors.
2017  *
2018  * @priv1: pointer to a header, format or frame
2019  * @priv2: inout parameter, accumulated size of the array
2020  * @priv3: inout parameter, accumulated number of the array elements
2021  * @n: unused, this function's prototype must match @fun in __uvcg_iter_strm_cls
2022  */
2023 static int __uvcg_cnt_strm(void *priv1, void *priv2, void *priv3, int n,
2024                            enum uvcg_strm_type type)
2025 {
2026         size_t *size = priv2;
2027         size_t *count = priv3;
2028
2029         switch (type) {
2030         case UVCG_HEADER: {
2031                 struct uvcg_streaming_header *h = priv1;
2032
2033                 *size += sizeof(h->desc);
2034                 /* bmaControls */
2035                 *size += h->num_fmt * UVCG_STREAMING_CONTROL_SIZE;
2036         }
2037         break;
2038         case UVCG_FORMAT: {
2039                 struct uvcg_format *fmt = priv1;
2040
2041                 if (fmt->type == UVCG_UNCOMPRESSED) {
2042                         struct uvcg_uncompressed *u =
2043                                 container_of(fmt, struct uvcg_uncompressed,
2044                                              fmt);
2045
2046                         *size += sizeof(u->desc);
2047                 } else if (fmt->type == UVCG_MJPEG) {
2048                         struct uvcg_mjpeg *m =
2049                                 container_of(fmt, struct uvcg_mjpeg, fmt);
2050
2051                         *size += sizeof(m->desc);
2052                 } else {
2053                         return -EINVAL;
2054                 }
2055         }
2056         break;
2057         case UVCG_FRAME: {
2058                 struct uvcg_frame *frm = priv1;
2059                 int sz = sizeof(frm->dw_frame_interval);
2060
2061                 *size += sizeof(frm->frame);
2062                 *size += frm->frame.b_frame_interval_type * sz;
2063         }
2064         break;
2065         }
2066
2067         ++*count;
2068
2069         return 0;
2070 }
2071
2072 /*
2073  * Fill an array of streaming descriptors.
2074  *
2075  * @priv1: pointer to a header, format or frame
2076  * @priv2: inout parameter, pointer into a block of memory
2077  * @priv3: inout parameter, pointer to a 2-dimensional array
2078  */
2079 static int __uvcg_fill_strm(void *priv1, void *priv2, void *priv3, int n,
2080                             enum uvcg_strm_type type)
2081 {
2082         void **dest = priv2;
2083         struct uvc_descriptor_header ***array = priv3;
2084         size_t sz;
2085
2086         **array = *dest;
2087         ++*array;
2088
2089         switch (type) {
2090         case UVCG_HEADER: {
2091                 struct uvc_input_header_descriptor *ihdr = *dest;
2092                 struct uvcg_streaming_header *h = priv1;
2093                 struct uvcg_format_ptr *f;
2094
2095                 memcpy(*dest, &h->desc, sizeof(h->desc));
2096                 *dest += sizeof(h->desc);
2097                 sz = UVCG_STREAMING_CONTROL_SIZE;
2098                 list_for_each_entry(f, &h->formats, entry) {
2099                         memcpy(*dest, f->fmt->bmaControls, sz);
2100                         *dest += sz;
2101                 }
2102                 ihdr->bLength = sizeof(h->desc) + h->num_fmt * sz;
2103                 ihdr->bNumFormats = h->num_fmt;
2104         }
2105         break;
2106         case UVCG_FORMAT: {
2107                 struct uvcg_format *fmt = priv1;
2108
2109                 if (fmt->type == UVCG_UNCOMPRESSED) {
2110                         struct uvcg_uncompressed *u =
2111                                 container_of(fmt, struct uvcg_uncompressed,
2112                                              fmt);
2113
2114                         u->desc.bFormatIndex = n + 1;
2115                         u->desc.bNumFrameDescriptors = fmt->num_frames;
2116                         memcpy(*dest, &u->desc, sizeof(u->desc));
2117                         *dest += sizeof(u->desc);
2118                 } else if (fmt->type == UVCG_MJPEG) {
2119                         struct uvcg_mjpeg *m =
2120                                 container_of(fmt, struct uvcg_mjpeg, fmt);
2121
2122                         m->desc.bFormatIndex = n + 1;
2123                         m->desc.bNumFrameDescriptors = fmt->num_frames;
2124                         memcpy(*dest, &m->desc, sizeof(m->desc));
2125                         *dest += sizeof(m->desc);
2126                 } else {
2127                         return -EINVAL;
2128                 }
2129         }
2130         break;
2131         case UVCG_FRAME: {
2132                 struct uvcg_frame *frm = priv1;
2133                 struct uvc_descriptor_header *h = *dest;
2134
2135                 sz = sizeof(frm->frame);
2136                 memcpy(*dest, &frm->frame, sz);
2137                 *dest += sz;
2138                 sz = frm->frame.b_frame_interval_type *
2139                         sizeof(*frm->dw_frame_interval);
2140                 memcpy(*dest, frm->dw_frame_interval, sz);
2141                 *dest += sz;
2142                 if (frm->fmt_type == UVCG_UNCOMPRESSED)
2143                         h->bLength = UVC_DT_FRAME_UNCOMPRESSED_SIZE(
2144                                 frm->frame.b_frame_interval_type);
2145                 else if (frm->fmt_type == UVCG_MJPEG)
2146                         h->bLength = UVC_DT_FRAME_MJPEG_SIZE(
2147                                 frm->frame.b_frame_interval_type);
2148         }
2149         break;
2150         }
2151
2152         return 0;
2153 }
2154
2155 static int uvcg_streaming_class_allow_link(struct config_item *src,
2156                                            struct config_item *target)
2157 {
2158         struct config_item *streaming, *header;
2159         struct f_uvc_opts *opts;
2160         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
2161         struct uvc_descriptor_header ***class_array, **cl_arr;
2162         struct uvcg_streaming_header *target_hdr;
2163         void *data, *data_save;
2164         size_t size = 0, count = 0;
2165         int ret = -EINVAL;
2166
2167         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
2168
2169         streaming = src->ci_parent->ci_parent;
2170         header = config_group_find_item(to_config_group(streaming), "header");
2171         if (!header || target->ci_parent != header)
2172                 goto out;
2173
2174         opts = to_f_uvc_opts(streaming->ci_parent);
2175
2176         mutex_lock(&opts->lock);
2177
2178         class_array = __uvcg_get_stream_class_arr(src, opts);
2179         if (!class_array || *class_array || opts->refcnt) {
2180                 ret = -EBUSY;
2181                 goto unlock;
2182         }
2183
2184         target_hdr = to_uvcg_streaming_header(target);
2185         ret = __uvcg_iter_strm_cls(target_hdr, &size, &count, __uvcg_cnt_strm);
2186         if (ret)
2187                 goto unlock;
2188
2189         count += 2; /* color_matching, NULL */
2190         *class_array = kcalloc(count, sizeof(void *), GFP_KERNEL);
2191         if (!*class_array) {
2192                 ret = -ENOMEM;
2193                 goto unlock;
2194         }
2195
2196         data = data_save = kzalloc(size, GFP_KERNEL);
2197         if (!data) {
2198                 kfree(*class_array);
2199                 *class_array = NULL;
2200                 ret = -ENOMEM;
2201                 goto unlock;
2202         }
2203         cl_arr = *class_array;
2204         ret = __uvcg_iter_strm_cls(target_hdr, &data, &cl_arr,
2205                                    __uvcg_fill_strm);
2206         if (ret) {
2207                 kfree(*class_array);
2208                 *class_array = NULL;
2209                 /*
2210                  * __uvcg_fill_strm() called from __uvcg_iter_stream_cls()
2211                  * might have advanced the "data", so use a backup copy
2212                  */
2213                 kfree(data_save);
2214                 goto unlock;
2215         }
2216         *cl_arr = (struct uvc_descriptor_header *)&opts->uvc_color_matching;
2217
2218         ++target_hdr->linked;
2219         ret = 0;
2220
2221 unlock:
2222         mutex_unlock(&opts->lock);
2223 out:
2224         config_item_put(header);
2225         mutex_unlock(su_mutex);
2226         return ret;
2227 }
2228
2229 static void uvcg_streaming_class_drop_link(struct config_item *src,
2230                                           struct config_item *target)
2231 {
2232         struct config_item *streaming, *header;
2233         struct f_uvc_opts *opts;
2234         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
2235         struct uvc_descriptor_header ***class_array;
2236         struct uvcg_streaming_header *target_hdr;
2237
2238         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
2239
2240         streaming = src->ci_parent->ci_parent;
2241         header = config_group_find_item(to_config_group(streaming), "header");
2242         if (!header || target->ci_parent != header)
2243                 goto out;
2244
2245         opts = to_f_uvc_opts(streaming->ci_parent);
2246
2247         mutex_lock(&opts->lock);
2248
2249         class_array = __uvcg_get_stream_class_arr(src, opts);
2250         if (!class_array || !*class_array)
2251                 goto unlock;
2252
2253         if (opts->refcnt)
2254                 goto unlock;
2255
2256         target_hdr = to_uvcg_streaming_header(target);
2257         --target_hdr->linked;
2258         kfree(**class_array);
2259         kfree(*class_array);
2260         *class_array = NULL;
2261
2262 unlock:
2263         mutex_unlock(&opts->lock);
2264 out:
2265         config_item_put(header);
2266         mutex_unlock(su_mutex);
2267 }
2268
2269 static struct configfs_item_operations uvcg_streaming_class_item_ops = {
2270         .release        = uvcg_config_item_release,
2271         .allow_link     = uvcg_streaming_class_allow_link,
2272         .drop_link      = uvcg_streaming_class_drop_link,
2273 };
2274
2275 static const struct config_item_type uvcg_streaming_class_type = {
2276         .ct_item_ops    = &uvcg_streaming_class_item_ops,
2277         .ct_owner       = THIS_MODULE,
2278 };
2279
2280 /* -----------------------------------------------------------------------------
2281  * streaming/class
2282  */
2283
2284 static int uvcg_streaming_class_create_children(struct config_group *parent)
2285 {
2286         static const char * const names[] = { "fs", "hs", "ss" };
2287         unsigned int i;
2288
2289         for (i = 0; i < ARRAY_SIZE(names); ++i) {
2290                 struct uvcg_streaming_class_group *group;
2291
2292                 group = kzalloc(sizeof(*group), GFP_KERNEL);
2293                 if (!group)
2294                         return -ENOMEM;
2295
2296                 group->name = names[i];
2297
2298                 config_group_init_type_name(&group->group, group->name,
2299                                             &uvcg_streaming_class_type);
2300                 configfs_add_default_group(&group->group, parent);
2301         }
2302
2303         return 0;
2304 }
2305
2306 static const struct uvcg_config_group_type uvcg_streaming_class_grp_type = {
2307         .type = {
2308                 .ct_item_ops    = &uvcg_config_item_ops,
2309                 .ct_owner       = THIS_MODULE,
2310         },
2311         .name = "class",
2312         .create_children = uvcg_streaming_class_create_children,
2313 };
2314
2315 /* -----------------------------------------------------------------------------
2316  * streaming
2317  */
2318
2319 static ssize_t uvcg_default_streaming_b_interface_number_show(
2320         struct config_item *item, char *page)
2321 {
2322         struct config_group *group = to_config_group(item);
2323         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
2324         struct config_item *opts_item;
2325         struct f_uvc_opts *opts;
2326         int result = 0;
2327
2328         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
2329
2330         opts_item = item->ci_parent;
2331         opts = to_f_uvc_opts(opts_item);
2332
2333         mutex_lock(&opts->lock);
2334         result += sprintf(page, "%u\n", opts->streaming_interface);
2335         mutex_unlock(&opts->lock);
2336
2337         mutex_unlock(su_mutex);
2338
2339         return result;
2340 }
2341
2342 UVC_ATTR_RO(uvcg_default_streaming_, b_interface_number, bInterfaceNumber);
2343
2344 static struct configfs_attribute *uvcg_default_streaming_attrs[] = {
2345         &uvcg_default_streaming_attr_b_interface_number,
2346         NULL,
2347 };
2348
2349 static const struct uvcg_config_group_type uvcg_streaming_grp_type = {
2350         .type = {
2351                 .ct_item_ops    = &uvcg_config_item_ops,
2352                 .ct_attrs       = uvcg_default_streaming_attrs,
2353                 .ct_owner       = THIS_MODULE,
2354         },
2355         .name = "streaming",
2356         .children = (const struct uvcg_config_group_type*[]) {
2357                 &uvcg_streaming_header_grp_type,
2358                 &uvcg_uncompressed_grp_type,
2359                 &uvcg_mjpeg_grp_type,
2360                 &uvcg_color_matching_grp_type,
2361                 &uvcg_streaming_class_grp_type,
2362                 NULL,
2363         },
2364 };
2365
2366 /* -----------------------------------------------------------------------------
2367  * UVC function
2368  */
2369
2370 static void uvc_func_item_release(struct config_item *item)
2371 {
2372         struct f_uvc_opts *opts = to_f_uvc_opts(item);
2373
2374         uvcg_config_remove_children(to_config_group(item));
2375         usb_put_function_instance(&opts->func_inst);
2376 }
2377
2378 static struct configfs_item_operations uvc_func_item_ops = {
2379         .release        = uvc_func_item_release,
2380 };
2381
2382 #define UVCG_OPTS_ATTR(cname, aname, limit)                             \
2383 static ssize_t f_uvc_opts_##cname##_show(                               \
2384         struct config_item *item, char *page)                           \
2385 {                                                                       \
2386         struct f_uvc_opts *opts = to_f_uvc_opts(item);                  \
2387         int result;                                                     \
2388                                                                         \
2389         mutex_lock(&opts->lock);                                        \
2390         result = sprintf(page, "%u\n", opts->cname);                    \
2391         mutex_unlock(&opts->lock);                                      \
2392                                                                         \
2393         return result;                                                  \
2394 }                                                                       \
2395                                                                         \
2396 static ssize_t                                                          \
2397 f_uvc_opts_##cname##_store(struct config_item *item,                    \
2398                            const char *page, size_t len)                \
2399 {                                                                       \
2400         struct f_uvc_opts *opts = to_f_uvc_opts(item);                  \
2401         unsigned int num;                                               \
2402         int ret;                                                        \
2403                                                                         \
2404         mutex_lock(&opts->lock);                                        \
2405         if (opts->refcnt) {                                             \
2406                 ret = -EBUSY;                                           \
2407                 goto end;                                               \
2408         }                                                               \
2409                                                                         \
2410         ret = kstrtouint(page, 0, &num);                                \
2411         if (ret)                                                        \
2412                 goto end;                                               \
2413                                                                         \
2414         if (num > limit) {                                              \
2415                 ret = -EINVAL;                                          \
2416                 goto end;                                               \
2417         }                                                               \
2418         opts->cname = num;                                              \
2419         ret = len;                                                      \
2420 end:                                                                    \
2421         mutex_unlock(&opts->lock);                                      \
2422         return ret;                                                     \
2423 }                                                                       \
2424                                                                         \
2425 UVC_ATTR(f_uvc_opts_, cname, cname)
2426
2427 UVCG_OPTS_ATTR(streaming_interval, streaming_interval, 16);
2428 UVCG_OPTS_ATTR(streaming_maxpacket, streaming_maxpacket, 3072);
2429 UVCG_OPTS_ATTR(streaming_maxburst, streaming_maxburst, 15);
2430
2431 #undef UVCG_OPTS_ATTR
2432
2433 static struct configfs_attribute *uvc_attrs[] = {
2434         &f_uvc_opts_attr_streaming_interval,
2435         &f_uvc_opts_attr_streaming_maxpacket,
2436         &f_uvc_opts_attr_streaming_maxburst,
2437         NULL,
2438 };
2439
2440 static const struct uvcg_config_group_type uvc_func_type = {
2441         .type = {
2442                 .ct_item_ops    = &uvc_func_item_ops,
2443                 .ct_attrs       = uvc_attrs,
2444                 .ct_owner       = THIS_MODULE,
2445         },
2446         .name = "",
2447         .children = (const struct uvcg_config_group_type*[]) {
2448                 &uvcg_control_grp_type,
2449                 &uvcg_streaming_grp_type,
2450                 NULL,
2451         },
2452 };
2453
2454 int uvcg_attach_configfs(struct f_uvc_opts *opts)
2455 {
2456         int ret;
2457
2458         config_group_init_type_name(&opts->func_inst.group, uvc_func_type.name,
2459                                     &uvc_func_type.type);
2460
2461         ret = uvcg_config_create_children(&opts->func_inst.group,
2462                                           &uvc_func_type);
2463         if (ret < 0)
2464                 config_group_put(&opts->func_inst.group);
2465
2466         return ret;
2467 }