drivers/usb/gadget/function/uvc_configfs.c

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