kernel/drivers/usb/gadget/function/uvc_configfs.c

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