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