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

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