drivers/usb/gadget/function/uvc_configfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * uvc_configfs.c
   4  *
   5  * Configfs support for the uvc function.
   6  *
   7  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   8  *              http://www.samsung.com
   9  *
  10  * Author: Andrzej Pietrasiewicz <[email protected]>
  11  */
  12
  13 #include "uvc_configfs.h"
  14
  15 #include <linux/sort.h>
  16 #include <linux/usb/uvc.h>
  17 #include <linux/usb/video.h>
  18
  19 /* -----------------------------------------------------------------------------
  20  * Global Utility Structures and Macros
  21  */
  22
  23 #define UVC_ATTR(prefix, cname, aname) \
  24 static struct configfs_attribute prefix##attr_##cname = { \
  25         .ca_name        = __stringify(aname),                           \
  26         .ca_mode        = S_IRUGO | S_IWUGO,                            \
  27         .ca_owner       = THIS_MODULE,                                  \
  28         .show           = prefix##cname##_show,                         \
  29         .store          = prefix##cname##_store,                        \
  30 }
  31
  32 #define UVC_ATTR_RO(prefix, cname, aname) \
  33 static struct configfs_attribute prefix##attr_##cname = { \
  34         .ca_name        = __stringify(aname),                           \
  35         .ca_mode        = S_IRUGO,                                      \
  36         .ca_owner       = THIS_MODULE,                                  \
  37         .show           = prefix##cname##_show,                         \
  38 }
  39
  40 #define le8_to_cpu(x)   (x)
  41 #define cpu_to_le8(x)   (x)
  42
  43 static int uvcg_config_compare_u32(const void *l, const void *r)
  44 {
  45         u32 li = *(const u32 *)l;
  46         u32 ri = *(const u32 *)r;
  47
  48         return li < ri ? -1 : li == ri ? 0 : 1;
  49 }
  50
  51 static inline int __uvcg_count_item_entries(char *buf, void *priv, unsigned int size)
  52 {
  53         ++*((int *)priv);
  54         return 0;
  55 }
  56
  57 static inline int __uvcg_fill_item_entries(char *buf, void *priv, unsigned int size)
  58 {
  59         unsigned int num;
  60         u8 **values;
  61         int ret;
  62
  63         ret = kstrtouint(buf, 0, &num);
  64         if (ret)
  65                 return ret;
  66
  67         if (num != (num & GENMASK((size * 8) - 1, 0)))
  68                 return -ERANGE;
  69
  70         values = priv;
  71         memcpy(*values, &num, size);
  72         *values += size;
  73
  74         return 0;
  75 }
  76
  77 static int __uvcg_iter_item_entries(const char *page, size_t len,
  78                                     int (*fun)(char *, void *, unsigned int),
  79                                     void *priv, unsigned int size)
  80 {
  81         /* sign, base 2 representation, newline, terminator */
  82         unsigned int bufsize = 1 + size * 8 + 1 + 1;
  83         const char *pg = page;
  84         int i, ret = 0;
  85         char *buf;
  86
  87         if (!fun)
  88                 return -EINVAL;
  89
  90         buf = kzalloc(bufsize, GFP_KERNEL);
  91         if (!buf)
  92                 return -ENOMEM;
  93
  94         while (pg - page < len) {
  95                 i = 0;
  96                 while (i < bufsize && (pg - page < len) &&
  97                        *pg != '\0' && *pg != '\n')
  98                         buf[i++] = *pg++;
  99                 if (i == bufsize) {
 100                         ret = -EINVAL;
 101                         goto out_free_buf;
 102                 }
 103                 while ((pg - page < len) && (*pg == '\0' || *pg == '\n'))
 104                         ++pg;
 105                 buf[i] = '\0';
 106                 ret = fun(buf, priv, size);
 107                 if (ret)
 108                         goto out_free_buf;
 109         }
 110
 111 out_free_buf:
 112         kfree(buf);
 113         return ret;
 114 }
 115
 116 struct uvcg_config_group_type {
 117         struct config_item_type type;
 118         const char *name;
 119         const struct uvcg_config_group_type **children;
 120         int (*create_children)(struct config_group *group);
 121 };
 122
 123 static void uvcg_config_item_release(struct config_item *item)
 124 {
 125         struct config_group *group = to_config_group(item);
 126
 127         kfree(group);
 128 }
 129
 130 static struct configfs_item_operations uvcg_config_item_ops = {
 131         .release        = uvcg_config_item_release,
 132 };
 133
 134 static int uvcg_config_create_group(struct config_group *parent,
 135                                     const struct uvcg_config_group_type *type);
 136
 137 static int uvcg_config_create_children(struct config_group *group,
 138                                 const struct uvcg_config_group_type *type)
 139 {
 140         const struct uvcg_config_group_type **child;
 141         int ret;
 142
 143         if (type->create_children)
 144                 return type->create_children(group);
 145
 146         for (child = type->children; child && *child; ++child) {
 147                 ret = uvcg_config_create_group(group, *child);
 148                 if (ret < 0)
 149                         return ret;
 150         }
 151
 152         return 0;
 153 }
 154
 155 static int uvcg_config_create_group(struct config_group *parent,
 156                                     const struct uvcg_config_group_type *type)
 157 {
 158         struct config_group *group;
 159
 160         group = kzalloc(sizeof(*group), GFP_KERNEL);
 161         if (!group)
 162                 return -ENOMEM;
 163
 164         config_group_init_type_name(group, type->name, &type->type);
 165         configfs_add_default_group(group, parent);
 166
 167         return uvcg_config_create_children(group, type);
 168 }
 169
 170 static void uvcg_config_remove_children(struct config_group *group)
 171 {
 172         struct config_group *child, *n;
 173
 174         list_for_each_entry_safe(child, n, &group->default_groups, group_entry) {
 175                 list_del(&child->group_entry);
 176                 uvcg_config_remove_children(child);
 177                 config_item_put(&child->cg_item);
 178         }
 179 }
 180
 181 /* -----------------------------------------------------------------------------
 182  * control/header/<NAME>
 183  * control/header
 184  */
 185
 186 #define UVCG_CTRL_HDR_ATTR(cname, aname, bits, limit)                   \
 187 static ssize_t uvcg_control_header_##cname##_show(                      \
 188         struct config_item *item, char *page)                           \
 189 {                                                                       \
 190         struct uvcg_control_header *ch = to_uvcg_control_header(item);  \
 191         struct f_uvc_opts *opts;                                        \
 192         struct config_item *opts_item;                                  \
 193         struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;\
 194         int result;                                                     \
 195                                                                         \
 196         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
 197                                                                         \
 198         opts_item = ch->item.ci_parent->ci_parent->ci_parent;           \
 199         opts = to_f_uvc_opts(opts_item);                                \
 200                                                                         \
 201         mutex_lock(&opts->lock);                                        \
 202         result = sprintf(page, "%u\n", le##bits##_to_cpu(ch->desc.aname));\
 203         mutex_unlock(&opts->lock);                                      \
 204                                                                         \
 205         mutex_unlock(su_mutex);                                         \
 206         return result;                                                  \
 207 }                                                                       \
 208                                                                         \
 209 static ssize_t                                                          \
 210 uvcg_control_header_##cname##_store(struct config_item *item,           \
 211                            const char *page, size_t len)                \
 212 {                                                                       \
 213         struct uvcg_control_header *ch = to_uvcg_control_header(item);  \
 214         struct f_uvc_opts *opts;                                        \
 215         struct config_item *opts_item;                                  \
 216         struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;\
 217         int ret;                                                        \
 218         u##bits num;                                                    \
 219                                                                         \
 220         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
 221                                                                         \
 222         opts_item = ch->item.ci_parent->ci_parent->ci_parent;           \
 223         opts = to_f_uvc_opts(opts_item);                                \
 224                                                                         \
 225         mutex_lock(&opts->lock);                                        \
 226         if (ch->linked || opts->refcnt) {                               \
 227                 ret = -EBUSY;                                           \
 228                 goto end;                                               \
 229         }                                                               \
 230                                                                         \
 231         ret = kstrtou##bits(page, 0, &num);                             \
 232         if (ret)                                                        \
 233                 goto end;                                               \
 234                                                                         \
 235         if (num > limit) {                                              \
 236                 ret = -EINVAL;                                          \
 237                 goto end;                                               \
 238         }                                                               \
 239         ch->desc.aname = cpu_to_le##bits(num);                          \
 240         ret = len;                                                      \
 241 end:                                                                    \
 242         mutex_unlock(&opts->lock);                                      \
 243         mutex_unlock(su_mutex);                                         \
 244         return ret;                                                     \
 245 }                                                                       \
 246                                                                         \
 247 UVC_ATTR(uvcg_control_header_, cname, aname)
 248
 249 UVCG_CTRL_HDR_ATTR(bcd_uvc, bcdUVC, 16, 0xffff);
 250
 251 UVCG_CTRL_HDR_ATTR(dw_clock_frequency, dwClockFrequency, 32, 0x7fffffff);
 252
 253 #undef UVCG_CTRL_HDR_ATTR
 254
 255 static struct configfs_attribute *uvcg_control_header_attrs[] = {
 256         &uvcg_control_header_attr_bcd_uvc,
 257         &uvcg_control_header_attr_dw_clock_frequency,
 258         NULL,
 259 };
 260
 261 static const struct config_item_type uvcg_control_header_type = {
 262         .ct_item_ops    = &uvcg_config_item_ops,
 263         .ct_attrs       = uvcg_control_header_attrs,
 264         .ct_owner       = THIS_MODULE,
 265 };
 266
 267 static struct config_item *uvcg_control_header_make(struct config_group *group,
 268                                                     const char *name)
 269 {
 270         struct uvcg_control_header *h;
 271
 272         h = kzalloc(sizeof(*h), GFP_KERNEL);
 273         if (!h)
 274                 return ERR_PTR(-ENOMEM);
 275
 276         h->desc.bLength                 = UVC_DT_HEADER_SIZE(1);
 277         h->desc.bDescriptorType         = USB_DT_CS_INTERFACE;
 278         h->desc.bDescriptorSubType      = UVC_VC_HEADER;
 279         h->desc.bcdUVC                  = cpu_to_le16(0x0110);
 280         h->desc.dwClockFrequency        = cpu_to_le32(48000000);
 281
 282         config_item_init_type_name(&h->item, name, &uvcg_control_header_type);
 283
 284         return &h->item;
 285 }
 286
 287 static struct configfs_group_operations uvcg_control_header_grp_ops = {
 288         .make_item              = uvcg_control_header_make,
 289 };
 290
 291 static const struct uvcg_config_group_type uvcg_control_header_grp_type = {
 292         .type = {
 293                 .ct_item_ops    = &uvcg_config_item_ops,
 294                 .ct_group_ops   = &uvcg_control_header_grp_ops,
 295                 .ct_owner       = THIS_MODULE,
 296         },
 297         .name = "header",
 298 };
 299
 300 /* -----------------------------------------------------------------------------
 301  * control/processing/default
 302  */
 303
 304 #define UVCG_DEFAULT_PROCESSING_ATTR(cname, aname, bits)                \
 305 static ssize_t uvcg_default_processing_##cname##_show(                  \
 306         struct config_item *item, char *page)                           \
 307 {                                                                       \
 308         struct config_group *group = to_config_group(item);             \
 309         struct f_uvc_opts *opts;                                        \
 310         struct config_item *opts_item;                                  \
 311         struct mutex *su_mutex = &group->cg_subsys->su_mutex;           \
 312         struct uvc_processing_unit_descriptor *pd;                      \
 313         int result;                                                     \
 314                                                                         \
 315         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
 316                                                                         \
 317         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;     \
 318         opts = to_f_uvc_opts(opts_item);                                \
 319         pd = &opts->uvc_processing;                                     \
 320                                                                         \
 321         mutex_lock(&opts->lock);                                        \
 322         result = sprintf(page, "%u\n", le##bits##_to_cpu(pd->aname));   \
 323         mutex_unlock(&opts->lock);                                      \
 324                                                                         \
 325         mutex_unlock(su_mutex);                                         \
 326         return result;                                                  \
 327 }                                                                       \
 328                                                                         \
 329 UVC_ATTR_RO(uvcg_default_processing_, cname, aname)
 330
 331 UVCG_DEFAULT_PROCESSING_ATTR(b_unit_id, bUnitID, 8);
 332 UVCG_DEFAULT_PROCESSING_ATTR(b_source_id, bSourceID, 8);
 333 UVCG_DEFAULT_PROCESSING_ATTR(w_max_multiplier, wMaxMultiplier, 16);
 334 UVCG_DEFAULT_PROCESSING_ATTR(i_processing, iProcessing, 8);
 335
 336 #undef UVCG_DEFAULT_PROCESSING_ATTR
 337
 338 static ssize_t uvcg_default_processing_bm_controls_store(
 339         struct config_item *item, const char *page, size_t len)
 340 {
 341         struct config_group *group = to_config_group(item);
 342         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 343         struct uvc_processing_unit_descriptor *pd;
 344         struct config_item *opts_item;
 345         struct f_uvc_opts *opts;
 346         u8 *bm_controls, *tmp;
 347         unsigned int i;
 348         int ret, n = 0;
 349
 350         mutex_lock(su_mutex);
 351
 352         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
 353         opts = to_f_uvc_opts(opts_item);
 354         pd = &opts->uvc_processing;
 355
 356         mutex_lock(&opts->lock);
 357         if (opts->refcnt) {
 358                 ret = -EBUSY;
 359                 goto unlock;
 360         }
 361
 362         ret = __uvcg_iter_item_entries(page, len, __uvcg_count_item_entries, &n,
 363                                        sizeof(u8));
 364         if (ret)
 365                 goto unlock;
 366
 367         if (n > pd->bControlSize) {
 368                 ret = -EINVAL;
 369                 goto unlock;
 370         }
 371
 372         tmp = bm_controls = kcalloc(n, sizeof(u8), GFP_KERNEL);
 373         if (!bm_controls) {
 374                 ret = -ENOMEM;
 375                 goto unlock;
 376         }
 377
 378         ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &tmp,
 379                                        sizeof(u8));
 380         if (ret)
 381                 goto free_mem;
 382
 383         for (i = 0; i < n; i++)
 384                 pd->bmControls[i] = bm_controls[i];
 385
 386         ret = len;
 387
 388 free_mem:
 389         kfree(bm_controls);
 390 unlock:
 391         mutex_unlock(&opts->lock);
 392         mutex_unlock(su_mutex);
 393         return ret;
 394 }
 395
 396 static ssize_t uvcg_default_processing_bm_controls_show(
 397         struct config_item *item, char *page)
 398 {
 399         struct config_group *group = to_config_group(item);
 400         struct f_uvc_opts *opts;
 401         struct config_item *opts_item;
 402         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 403         struct uvc_processing_unit_descriptor *pd;
 404         int result, i;
 405         char *pg = page;
 406
 407         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 408
 409         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
 410         opts = to_f_uvc_opts(opts_item);
 411         pd = &opts->uvc_processing;
 412
 413         mutex_lock(&opts->lock);
 414         for (result = 0, i = 0; i < pd->bControlSize; ++i) {
 415                 result += sprintf(pg, "%u\n", pd->bmControls[i]);
 416                 pg = page + result;
 417         }
 418         mutex_unlock(&opts->lock);
 419
 420         mutex_unlock(su_mutex);
 421
 422         return result;
 423 }
 424
 425 UVC_ATTR(uvcg_default_processing_, bm_controls, bmControls);
 426
 427 static struct configfs_attribute *uvcg_default_processing_attrs[] = {
 428         &uvcg_default_processing_attr_b_unit_id,
 429         &uvcg_default_processing_attr_b_source_id,
 430         &uvcg_default_processing_attr_w_max_multiplier,
 431         &uvcg_default_processing_attr_bm_controls,
 432         &uvcg_default_processing_attr_i_processing,
 433         NULL,
 434 };
 435
 436 static const struct uvcg_config_group_type uvcg_default_processing_type = {
 437         .type = {
 438                 .ct_item_ops    = &uvcg_config_item_ops,
 439                 .ct_attrs       = uvcg_default_processing_attrs,
 440                 .ct_owner       = THIS_MODULE,
 441         },
 442         .name = "default",
 443 };
 444
 445 /* -----------------------------------------------------------------------------
 446  * control/processing
 447  */
 448
 449 static const struct uvcg_config_group_type uvcg_processing_grp_type = {
 450         .type = {
 451                 .ct_item_ops    = &uvcg_config_item_ops,
 452                 .ct_owner       = THIS_MODULE,
 453         },
 454         .name = "processing",
 455         .children = (const struct uvcg_config_group_type*[]) {
 456                 &uvcg_default_processing_type,
 457                 NULL,
 458         },
 459 };
 460
 461 /* -----------------------------------------------------------------------------
 462  * control/terminal/camera/default
 463  */
 464
 465 #define UVCG_DEFAULT_CAMERA_ATTR(cname, aname, bits)                    \
 466 static ssize_t uvcg_default_camera_##cname##_show(                      \
 467         struct config_item *item, char *page)                           \
 468 {                                                                       \
 469         struct config_group *group = to_config_group(item);             \
 470         struct f_uvc_opts *opts;                                        \
 471         struct config_item *opts_item;                                  \
 472         struct mutex *su_mutex = &group->cg_subsys->su_mutex;           \
 473         struct uvc_camera_terminal_descriptor *cd;                      \
 474         int result;                                                     \
 475                                                                         \
 476         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
 477                                                                         \
 478         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent->    \
 479                         ci_parent;                                      \
 480         opts = to_f_uvc_opts(opts_item);                                \
 481         cd = &opts->uvc_camera_terminal;                                \
 482                                                                         \
 483         mutex_lock(&opts->lock);                                        \
 484         result = sprintf(page, "%u\n", le##bits##_to_cpu(cd->aname));   \
 485         mutex_unlock(&opts->lock);                                      \
 486                                                                         \
 487         mutex_unlock(su_mutex);                                         \
 488                                                                         \
 489         return result;                                                  \
 490 }                                                                       \
 491                                                                         \
 492 UVC_ATTR_RO(uvcg_default_camera_, cname, aname)
 493
 494 UVCG_DEFAULT_CAMERA_ATTR(b_terminal_id, bTerminalID, 8);
 495 UVCG_DEFAULT_CAMERA_ATTR(w_terminal_type, wTerminalType, 16);
 496 UVCG_DEFAULT_CAMERA_ATTR(b_assoc_terminal, bAssocTerminal, 8);
 497 UVCG_DEFAULT_CAMERA_ATTR(i_terminal, iTerminal, 8);
 498 UVCG_DEFAULT_CAMERA_ATTR(w_objective_focal_length_min, wObjectiveFocalLengthMin,
 499                          16);
 500 UVCG_DEFAULT_CAMERA_ATTR(w_objective_focal_length_max, wObjectiveFocalLengthMax,
 501                          16);
 502 UVCG_DEFAULT_CAMERA_ATTR(w_ocular_focal_length, wOcularFocalLength,
 503                          16);
 504
 505 #undef UVCG_DEFAULT_CAMERA_ATTR
 506
 507 static ssize_t uvcg_default_camera_bm_controls_store(
 508         struct config_item *item, const char *page, size_t len)
 509 {
 510         struct config_group *group = to_config_group(item);
 511         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 512         struct uvc_camera_terminal_descriptor *cd;
 513         struct config_item *opts_item;
 514         struct f_uvc_opts *opts;
 515         u8 *bm_controls, *tmp;
 516         unsigned int i;
 517         int ret, n = 0;
 518
 519         mutex_lock(su_mutex);
 520
 521         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent->
 522                         ci_parent;
 523         opts = to_f_uvc_opts(opts_item);
 524         cd = &opts->uvc_camera_terminal;
 525
 526         mutex_lock(&opts->lock);
 527         if (opts->refcnt) {
 528                 ret = -EBUSY;
 529                 goto unlock;
 530         }
 531
 532         ret = __uvcg_iter_item_entries(page, len, __uvcg_count_item_entries, &n,
 533                                        sizeof(u8));
 534         if (ret)
 535                 goto unlock;
 536
 537         if (n > cd->bControlSize) {
 538                 ret = -EINVAL;
 539                 goto unlock;
 540         }
 541
 542         tmp = bm_controls = kcalloc(n, sizeof(u8), GFP_KERNEL);
 543         if (!bm_controls) {
 544                 ret = -ENOMEM;
 545                 goto unlock;
 546         }
 547
 548         ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &tmp,
 549                                        sizeof(u8));
 550         if (ret)
 551                 goto free_mem;
 552
 553         for (i = 0; i < n; i++)
 554                 cd->bmControls[i] = bm_controls[i];
 555
 556         ret = len;
 557
 558 free_mem:
 559         kfree(bm_controls);
 560 unlock:
 561         mutex_unlock(&opts->lock);
 562         mutex_unlock(su_mutex);
 563         return ret;
 564 }
 565
 566 static ssize_t uvcg_default_camera_bm_controls_show(
 567         struct config_item *item, char *page)
 568 {
 569         struct config_group *group = to_config_group(item);
 570         struct f_uvc_opts *opts;
 571         struct config_item *opts_item;
 572         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 573         struct uvc_camera_terminal_descriptor *cd;
 574         int result, i;
 575         char *pg = page;
 576
 577         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 578
 579         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent->
 580                         ci_parent;
 581         opts = to_f_uvc_opts(opts_item);
 582         cd = &opts->uvc_camera_terminal;
 583
 584         mutex_lock(&opts->lock);
 585         for (result = 0, i = 0; i < cd->bControlSize; ++i) {
 586                 result += sprintf(pg, "%u\n", cd->bmControls[i]);
 587                 pg = page + result;
 588         }
 589         mutex_unlock(&opts->lock);
 590
 591         mutex_unlock(su_mutex);
 592         return result;
 593 }
 594
 595 UVC_ATTR(uvcg_default_camera_, bm_controls, bmControls);
 596
 597 static struct configfs_attribute *uvcg_default_camera_attrs[] = {
 598         &uvcg_default_camera_attr_b_terminal_id,
 599         &uvcg_default_camera_attr_w_terminal_type,
 600         &uvcg_default_camera_attr_b_assoc_terminal,
 601         &uvcg_default_camera_attr_i_terminal,
 602         &uvcg_default_camera_attr_w_objective_focal_length_min,
 603         &uvcg_default_camera_attr_w_objective_focal_length_max,
 604         &uvcg_default_camera_attr_w_ocular_focal_length,
 605         &uvcg_default_camera_attr_bm_controls,
 606         NULL,
 607 };
 608
 609 static const struct uvcg_config_group_type uvcg_default_camera_type = {
 610         .type = {
 611                 .ct_item_ops    = &uvcg_config_item_ops,
 612                 .ct_attrs       = uvcg_default_camera_attrs,
 613                 .ct_owner       = THIS_MODULE,
 614         },
 615         .name = "default",
 616 };
 617
 618 /* -----------------------------------------------------------------------------
 619  * control/terminal/camera
 620  */
 621
 622 static const struct uvcg_config_group_type uvcg_camera_grp_type = {
 623         .type = {
 624                 .ct_item_ops    = &uvcg_config_item_ops,
 625                 .ct_owner       = THIS_MODULE,
 626         },
 627         .name = "camera",
 628         .children = (const struct uvcg_config_group_type*[]) {
 629                 &uvcg_default_camera_type,
 630                 NULL,
 631         },
 632 };
 633
 634 /* -----------------------------------------------------------------------------
 635  * control/terminal/output/default
 636  */
 637
 638 #define UVCG_DEFAULT_OUTPUT_ATTR(cname, aname, bits)                    \
 639 static ssize_t uvcg_default_output_##cname##_show(                      \
 640         struct config_item *item, char *page)                           \
 641 {                                                                       \
 642         struct config_group *group = to_config_group(item);             \
 643         struct f_uvc_opts *opts;                                        \
 644         struct config_item *opts_item;                                  \
 645         struct mutex *su_mutex = &group->cg_subsys->su_mutex;           \
 646         struct uvc_output_terminal_descriptor *cd;                      \
 647         int result;                                                     \
 648                                                                         \
 649         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
 650                                                                         \
 651         opts_item = group->cg_item.ci_parent->ci_parent->               \
 652                         ci_parent->ci_parent;                           \
 653         opts = to_f_uvc_opts(opts_item);                                \
 654         cd = &opts->uvc_output_terminal;                                \
 655                                                                         \
 656         mutex_lock(&opts->lock);                                        \
 657         result = sprintf(page, "%u\n", le##bits##_to_cpu(cd->aname));   \
 658         mutex_unlock(&opts->lock);                                      \
 659                                                                         \
 660         mutex_unlock(su_mutex);                                         \
 661                                                                         \
 662         return result;                                                  \
 663 }                                                                       \
 664                                                                         \
 665 UVC_ATTR_RO(uvcg_default_output_, cname, aname)
 666
 667 UVCG_DEFAULT_OUTPUT_ATTR(b_terminal_id, bTerminalID, 8);
 668 UVCG_DEFAULT_OUTPUT_ATTR(w_terminal_type, wTerminalType, 16);
 669 UVCG_DEFAULT_OUTPUT_ATTR(b_assoc_terminal, bAssocTerminal, 8);
 670 UVCG_DEFAULT_OUTPUT_ATTR(i_terminal, iTerminal, 8);
 671
 672 #undef UVCG_DEFAULT_OUTPUT_ATTR
 673
 674 static ssize_t uvcg_default_output_b_source_id_show(struct config_item *item,
 675                                                     char *page)
 676 {
 677         struct config_group *group = to_config_group(item);
 678         struct f_uvc_opts *opts;
 679         struct config_item *opts_item;
 680         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 681         struct uvc_output_terminal_descriptor *cd;
 682         int result;
 683
 684         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 685
 686         opts_item = group->cg_item.ci_parent->ci_parent->
 687                         ci_parent->ci_parent;
 688         opts = to_f_uvc_opts(opts_item);
 689         cd = &opts->uvc_output_terminal;
 690
 691         mutex_lock(&opts->lock);
 692         result = sprintf(page, "%u\n", le8_to_cpu(cd->bSourceID));
 693         mutex_unlock(&opts->lock);
 694
 695         mutex_unlock(su_mutex);
 696
 697         return result;
 698 }
 699
 700 static ssize_t uvcg_default_output_b_source_id_store(struct config_item *item,
 701                                                      const char *page, size_t len)
 702 {
 703         struct config_group *group = to_config_group(item);
 704         struct f_uvc_opts *opts;
 705         struct config_item *opts_item;
 706         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 707         struct uvc_output_terminal_descriptor *cd;
 708         int result;
 709         u8 num;
 710
 711         result = kstrtou8(page, 0, &num);
 712         if (result)
 713                 return result;
 714
 715         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
 716
 717         opts_item = group->cg_item.ci_parent->ci_parent->
 718                         ci_parent->ci_parent;
 719         opts = to_f_uvc_opts(opts_item);
 720         cd = &opts->uvc_output_terminal;
 721
 722         mutex_lock(&opts->lock);
 723         cd->bSourceID = num;
 724         mutex_unlock(&opts->lock);
 725
 726         mutex_unlock(su_mutex);
 727
 728         return len;
 729 }
 730 UVC_ATTR(uvcg_default_output_, b_source_id, bSourceID);
 731
 732 static struct configfs_attribute *uvcg_default_output_attrs[] = {
 733         &uvcg_default_output_attr_b_terminal_id,
 734         &uvcg_default_output_attr_w_terminal_type,
 735         &uvcg_default_output_attr_b_assoc_terminal,
 736         &uvcg_default_output_attr_b_source_id,
 737         &uvcg_default_output_attr_i_terminal,
 738         NULL,
 739 };
 740
 741 static const struct uvcg_config_group_type uvcg_default_output_type = {
 742         .type = {
 743                 .ct_item_ops    = &uvcg_config_item_ops,
 744                 .ct_attrs       = uvcg_default_output_attrs,
 745                 .ct_owner       = THIS_MODULE,
 746         },
 747         .name = "default",
 748 };
 749
 750 /* -----------------------------------------------------------------------------
 751  * control/terminal/output
 752  */
 753
 754 static const struct uvcg_config_group_type uvcg_output_grp_type = {
 755         .type = {
 756                 .ct_item_ops    = &uvcg_config_item_ops,
 757                 .ct_owner       = THIS_MODULE,
 758         },
 759         .name = "output",
 760         .children = (const struct uvcg_config_group_type*[]) {
 761                 &uvcg_default_output_type,
 762                 NULL,
 763         },
 764 };
 765
 766 /* -----------------------------------------------------------------------------
 767  * control/terminal
 768  */
 769
 770 static const struct uvcg_config_group_type uvcg_terminal_grp_type = {
 771         .type = {
 772                 .ct_item_ops    = &uvcg_config_item_ops,
 773                 .ct_owner       = THIS_MODULE,
 774         },
 775         .name = "terminal",
 776         .children = (const struct uvcg_config_group_type*[]) {
 777                 &uvcg_camera_grp_type,
 778                 &uvcg_output_grp_type,
 779                 NULL,
 780         },
 781 };
 782
 783 /* -----------------------------------------------------------------------------
 784  * control/extensions
 785  */
 786
 787 #define UVCG_EXTENSION_ATTR(cname, aname, ro...)                        \
 788 static ssize_t uvcg_extension_##cname##_show(struct config_item *item,  \
 789                                              char *page)                \
 790 {                                                                       \
 791         struct config_group *group = to_config_group(item->ci_parent);  \
 792         struct mutex *su_mutex = &group->cg_subsys->su_mutex;           \
 793         struct uvcg_extension *xu = to_uvcg_extension(item);            \
 794         struct config_item *opts_item;                                  \
 795         struct f_uvc_opts *opts;                                        \
 796         int ret;                                                        \
 797                                                                         \
 798         mutex_lock(su_mutex);                                           \
 799                                                                         \
 800         opts_item = item->ci_parent->ci_parent->ci_parent;              \
 801         opts = to_f_uvc_opts(opts_item);                                \
 802                                                                         \
 803         mutex_lock(&opts->lock);                                        \
 804         ret = sprintf(page, "%u\n", xu->desc.aname);                    \
 805         mutex_unlock(&opts->lock);                                      \
 806                                                                         \
 807         mutex_unlock(su_mutex);                                         \
 808                                                                         \
 809         return ret;                                                     \
 810 }                                                                       \
 811 UVC_ATTR##ro(uvcg_extension_, cname, aname)
 812
 813 UVCG_EXTENSION_ATTR(b_length, bLength, _RO);
 814 UVCG_EXTENSION_ATTR(b_unit_id, bUnitID, _RO);
 815 UVCG_EXTENSION_ATTR(i_extension, iExtension, _RO);
 816
 817 static ssize_t uvcg_extension_b_num_controls_store(struct config_item *item,
 818                                                    const char *page, size_t len)
 819 {
 820         struct config_group *group = to_config_group(item->ci_parent);
 821         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 822         struct uvcg_extension *xu = to_uvcg_extension(item);
 823         struct config_item *opts_item;
 824         struct f_uvc_opts *opts;
 825         int ret;
 826         u8 num;
 827
 828         ret = kstrtou8(page, 0, &num);
 829         if (ret)
 830                 return ret;
 831
 832         mutex_lock(su_mutex);
 833
 834         opts_item = item->ci_parent->ci_parent->ci_parent;
 835         opts = to_f_uvc_opts(opts_item);
 836
 837         mutex_lock(&opts->lock);
 838         xu->desc.bNumControls = num;
 839         mutex_unlock(&opts->lock);
 840
 841         mutex_unlock(su_mutex);
 842
 843         return len;
 844 }
 845 UVCG_EXTENSION_ATTR(b_num_controls, bNumControls);
 846
 847 /*
 848  * In addition to storing bNrInPins, this function needs to realloc the
 849  * memory for the baSourceID array and additionally expand bLength.
 850  */
 851 static ssize_t uvcg_extension_b_nr_in_pins_store(struct config_item *item,
 852                                                  const char *page, size_t len)
 853 {
 854         struct config_group *group = to_config_group(item->ci_parent);
 855         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 856         struct uvcg_extension *xu = to_uvcg_extension(item);
 857         struct config_item *opts_item;
 858         struct f_uvc_opts *opts;
 859         void *tmp_buf;
 860         int ret;
 861         u8 num;
 862
 863         ret = kstrtou8(page, 0, &num);
 864         if (ret)
 865                 return ret;
 866
 867         mutex_lock(su_mutex);
 868
 869         opts_item = item->ci_parent->ci_parent->ci_parent;
 870         opts = to_f_uvc_opts(opts_item);
 871
 872         mutex_lock(&opts->lock);
 873
 874         if (num == xu->desc.bNrInPins) {
 875                 ret = len;
 876                 goto unlock;
 877         }
 878
 879         tmp_buf = krealloc_array(xu->desc.baSourceID, num, sizeof(u8),
 880                                  GFP_KERNEL | __GFP_ZERO);
 881         if (!tmp_buf) {
 882                 ret = -ENOMEM;
 883                 goto unlock;
 884         }
 885
 886         xu->desc.baSourceID = tmp_buf;
 887         xu->desc.bNrInPins = num;
 888         xu->desc.bLength = UVC_DT_EXTENSION_UNIT_SIZE(xu->desc.bNrInPins,
 889                                                       xu->desc.bControlSize);
 890
 891         ret = len;
 892
 893 unlock:
 894         mutex_unlock(&opts->lock);
 895         mutex_unlock(su_mutex);
 896         return ret;
 897 }
 898 UVCG_EXTENSION_ATTR(b_nr_in_pins, bNrInPins);
 899
 900 /*
 901  * In addition to storing bControlSize, this function needs to realloc the
 902  * memory for the bmControls array and additionally expand bLength.
 903  */
 904 static ssize_t uvcg_extension_b_control_size_store(struct config_item *item,
 905                                                    const char *page, size_t len)
 906 {
 907         struct config_group *group = to_config_group(item->ci_parent);
 908         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 909         struct uvcg_extension *xu = to_uvcg_extension(item);
 910         struct config_item *opts_item;
 911         struct f_uvc_opts *opts;
 912         void *tmp_buf;
 913         int ret;
 914         u8 num;
 915
 916         ret = kstrtou8(page, 0, &num);
 917         if (ret)
 918                 return ret;
 919
 920         mutex_lock(su_mutex);
 921
 922         opts_item = item->ci_parent->ci_parent->ci_parent;
 923         opts = to_f_uvc_opts(opts_item);
 924
 925         mutex_lock(&opts->lock);
 926
 927         if (num == xu->desc.bControlSize) {
 928                 ret = len;
 929                 goto unlock;
 930         }
 931
 932         tmp_buf = krealloc_array(xu->desc.bmControls, num, sizeof(u8),
 933                                  GFP_KERNEL | __GFP_ZERO);
 934         if (!tmp_buf) {
 935                 ret = -ENOMEM;
 936                 goto unlock;
 937         }
 938
 939         xu->desc.bmControls = tmp_buf;
 940         xu->desc.bControlSize = num;
 941         xu->desc.bLength = UVC_DT_EXTENSION_UNIT_SIZE(xu->desc.bNrInPins,
 942                                                       xu->desc.bControlSize);
 943
 944         ret = len;
 945
 946 unlock:
 947         mutex_unlock(&opts->lock);
 948         mutex_unlock(su_mutex);
 949         return ret;
 950 }
 951
 952 UVCG_EXTENSION_ATTR(b_control_size, bControlSize);
 953
 954 static ssize_t uvcg_extension_guid_extension_code_show(struct config_item *item,
 955                                                        char *page)
 956 {
 957         struct config_group *group = to_config_group(item->ci_parent);
 958         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 959         struct uvcg_extension *xu = to_uvcg_extension(item);
 960         struct config_item *opts_item;
 961         struct f_uvc_opts *opts;
 962
 963         mutex_lock(su_mutex);
 964
 965         opts_item = item->ci_parent->ci_parent->ci_parent;
 966         opts = to_f_uvc_opts(opts_item);
 967
 968         mutex_lock(&opts->lock);
 969         memcpy(page, xu->desc.guidExtensionCode, sizeof(xu->desc.guidExtensionCode));
 970         mutex_unlock(&opts->lock);
 971
 972         mutex_unlock(su_mutex);
 973
 974         return sizeof(xu->desc.guidExtensionCode);
 975 }
 976
 977 static ssize_t uvcg_extension_guid_extension_code_store(struct config_item *item,
 978                                                         const char *page, size_t len)
 979 {
 980         struct config_group *group = to_config_group(item->ci_parent);
 981         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 982         struct uvcg_extension *xu = to_uvcg_extension(item);
 983         struct config_item *opts_item;
 984         struct f_uvc_opts *opts;
 985         int ret;
 986
 987         mutex_lock(su_mutex);
 988
 989         opts_item = item->ci_parent->ci_parent->ci_parent;
 990         opts = to_f_uvc_opts(opts_item);
 991
 992         mutex_lock(&opts->lock);
 993         memcpy(xu->desc.guidExtensionCode, page,
 994                min(sizeof(xu->desc.guidExtensionCode), len));
 995         mutex_unlock(&opts->lock);
 996
 997         mutex_unlock(su_mutex);
 998
 999         ret = sizeof(xu->desc.guidExtensionCode);
1000
1001         return ret;
1002 }
1003
1004 UVC_ATTR(uvcg_extension_, guid_extension_code, guidExtensionCode);
1005
1006 static ssize_t uvcg_extension_ba_source_id_show(struct config_item *item,
1007                                                 char *page)
1008 {
1009         struct config_group *group = to_config_group(item->ci_parent);
1010         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
1011         struct uvcg_extension *xu = to_uvcg_extension(item);
1012         struct config_item *opts_item;
1013         struct f_uvc_opts *opts;
1014         char *pg = page;
1015         int ret, i;
1016
1017         mutex_lock(su_mutex);
1018
1019         opts_item = item->ci_parent->ci_parent->ci_parent;
1020         opts = to_f_uvc_opts(opts_item);
1021
1022         mutex_lock(&opts->lock);
1023         for (ret = 0, i = 0; i < xu->desc.bNrInPins; ++i) {
1024                 ret += sprintf(pg, "%u\n", xu->desc.baSourceID[i]);
1025                 pg = page + ret;
1026         }
1027         mutex_unlock(&opts->lock);
1028
1029         mutex_unlock(su_mutex);
1030
1031         return ret;
1032 }
1033
1034 static ssize_t uvcg_extension_ba_source_id_store(struct config_item *item,
1035                                                  const char *page, size_t len)
1036 {
1037         struct config_group *group = to_config_group(item->ci_parent);
1038         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
1039         struct uvcg_extension *xu = to_uvcg_extension(item);
1040         struct config_item *opts_item;
1041         struct f_uvc_opts *opts;
1042         u8 *source_ids, *iter;
1043         int ret, n = 0;
1044
1045         mutex_lock(su_mutex);
1046
1047         opts_item = item->ci_parent->ci_parent->ci_parent;
1048         opts = to_f_uvc_opts(opts_item);
1049
1050         mutex_lock(&opts->lock);
1051
1052         ret = __uvcg_iter_item_entries(page, len, __uvcg_count_item_entries, &n,
1053                                        sizeof(u8));
1054         if (ret)
1055                 goto unlock;
1056
1057         iter = source_ids = kcalloc(n, sizeof(u8), GFP_KERNEL);
1058         if (!source_ids) {
1059                 ret = -ENOMEM;
1060                 goto unlock;
1061         }
1062
1063         ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &iter,
1064                                        sizeof(u8));
1065         if (ret) {
1066                 kfree(source_ids);
1067                 goto unlock;
1068         }
1069
1070         kfree(xu->desc.baSourceID);
1071         xu->desc.baSourceID = source_ids;
1072         xu->desc.bNrInPins = n;
1073         xu->desc.bLength = UVC_DT_EXTENSION_UNIT_SIZE(xu->desc.bNrInPins,
1074                                                       xu->desc.bControlSize);
1075
1076         ret = len;
1077
1078 unlock:
1079         mutex_unlock(&opts->lock);
1080         mutex_unlock(su_mutex);
1081         return ret;
1082 }
1083 UVC_ATTR(uvcg_extension_, ba_source_id, baSourceID);
1084
1085 static ssize_t uvcg_extension_bm_controls_show(struct config_item *item,
1086                                                char *page)
1087 {
1088         struct config_group *group = to_config_group(item->ci_parent);
1089         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
1090         struct uvcg_extension *xu = to_uvcg_extension(item);
1091         struct config_item *opts_item;
1092         struct f_uvc_opts *opts;
1093         char *pg = page;
1094         int ret, i;
1095
1096         mutex_lock(su_mutex);
1097
1098         opts_item = item->ci_parent->ci_parent->ci_parent;
1099         opts = to_f_uvc_opts(opts_item);
1100
1101         mutex_lock(&opts->lock);
1102         for (ret = 0, i = 0; i < xu->desc.bControlSize; ++i) {
1103                 ret += sprintf(pg, "0x%02x\n", xu->desc.bmControls[i]);
1104                 pg = page + ret;
1105         }
1106         mutex_unlock(&opts->lock);
1107
1108         mutex_unlock(su_mutex);
1109
1110         return ret;
1111 }
1112
1113 static ssize_t uvcg_extension_bm_controls_store(struct config_item *item,
1114                                                 const char *page, size_t len)
1115 {
1116         struct config_group *group = to_config_group(item->ci_parent);
1117         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
1118         struct uvcg_extension *xu = to_uvcg_extension(item);
1119         struct config_item *opts_item;
1120         struct f_uvc_opts *opts;
1121         u8 *bm_controls, *iter;
1122         int ret, n = 0;
1123
1124         mutex_lock(su_mutex);
1125
1126         opts_item = item->ci_parent->ci_parent->ci_parent;
1127         opts = to_f_uvc_opts(opts_item);
1128
1129         mutex_lock(&opts->lock);
1130
1131         ret = __uvcg_iter_item_entries(page, len, __uvcg_count_item_entries, &n,
1132                                        sizeof(u8));
1133         if (ret)
1134                 goto unlock;
1135
1136         iter = bm_controls = kcalloc(n, sizeof(u8), GFP_KERNEL);
1137         if (!bm_controls) {
1138                 ret = -ENOMEM;
1139                 goto unlock;
1140         }
1141
1142         ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &iter,
1143                                        sizeof(u8));
1144         if (ret) {
1145                 kfree(bm_controls);
1146                 goto unlock;
1147         }
1148
1149         kfree(xu->desc.bmControls);
1150         xu->desc.bmControls = bm_controls;
1151         xu->desc.bControlSize = n;
1152         xu->desc.bLength = UVC_DT_EXTENSION_UNIT_SIZE(xu->desc.bNrInPins,
1153                                                       xu->desc.bControlSize);
1154
1155         ret = len;
1156
1157 unlock:
1158         mutex_unlock(&opts->lock);
1159         mutex_unlock(su_mutex);
1160         return ret;
1161 }
1162
1163 UVC_ATTR(uvcg_extension_, bm_controls, bmControls);
1164
1165 static struct configfs_attribute *uvcg_extension_attrs[] = {
1166         &uvcg_extension_attr_b_length,
1167         &uvcg_extension_attr_b_unit_id,
1168         &uvcg_extension_attr_b_num_controls,
1169         &uvcg_extension_attr_b_nr_in_pins,
1170         &uvcg_extension_attr_b_control_size,
1171         &uvcg_extension_attr_guid_extension_code,
1172         &uvcg_extension_attr_ba_source_id,
1173         &uvcg_extension_attr_bm_controls,
1174         &uvcg_extension_attr_i_extension,
1175         NULL,
1176 };
1177
1178 static void uvcg_extension_release(struct config_item *item)
1179 {
1180         struct uvcg_extension *xu = container_of(item, struct uvcg_extension, item);
1181
1182         kfree(xu);
1183 }
1184
1185 static int uvcg_extension_allow_link(struct config_item *src, struct config_item *tgt)
1186 {
1187         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
1188         struct uvcg_extension *xu = to_uvcg_extension(src);
1189         struct config_item *gadget_item;
1190         struct gadget_string *string;
1191         struct config_item *strings;
1192         int ret = 0;
1193
1194         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1195
1196         /* Validate that the target of the link is an entry in strings/<langid> */
1197         gadget_item = src->ci_parent->ci_parent->ci_parent->ci_parent->ci_parent;
1198         strings = config_group_find_item(to_config_group(gadget_item), "strings");
1199         if (!strings || tgt->ci_parent->ci_parent != strings) {
1200                 ret = -EINVAL;
1201                 goto put_strings;
1202         }
1203
1204         string = to_gadget_string(tgt);
1205         xu->string_descriptor_index = string->usb_string.id;
1206
1207 put_strings:
1208         config_item_put(strings);
1209         mutex_unlock(su_mutex);
1210
1211         return ret;
1212 }
1213
1214 static void uvcg_extension_drop_link(struct config_item *src, struct config_item *tgt)
1215 {
1216         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
1217         struct uvcg_extension *xu = to_uvcg_extension(src);
1218         struct config_item *opts_item;
1219         struct f_uvc_opts *opts;
1220
1221         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1222
1223         opts_item = src->ci_parent->ci_parent->ci_parent;
1224         opts = to_f_uvc_opts(opts_item);
1225
1226         mutex_lock(&opts->lock);
1227
1228         xu->string_descriptor_index = 0;
1229
1230         mutex_unlock(&opts->lock);
1231
1232         mutex_unlock(su_mutex);
1233 }
1234
1235 static struct configfs_item_operations uvcg_extension_item_ops = {
1236         .release        = uvcg_extension_release,
1237         .allow_link     = uvcg_extension_allow_link,
1238         .drop_link      = uvcg_extension_drop_link,
1239 };
1240
1241 static const struct config_item_type uvcg_extension_type = {
1242         .ct_item_ops    = &uvcg_extension_item_ops,
1243         .ct_attrs       = uvcg_extension_attrs,
1244         .ct_owner       = THIS_MODULE,
1245 };
1246
1247 static void uvcg_extension_drop(struct config_group *group, struct config_item *item)
1248 {
1249         struct uvcg_extension *xu = container_of(item, struct uvcg_extension, item);
1250         struct config_item *opts_item;
1251         struct f_uvc_opts *opts;
1252
1253         opts_item = group->cg_item.ci_parent->ci_parent;
1254         opts = to_f_uvc_opts(opts_item);
1255
1256         mutex_lock(&opts->lock);
1257
1258         config_item_put(item);
1259         list_del(&xu->list);
1260         kfree(xu->desc.baSourceID);
1261         kfree(xu->desc.bmControls);
1262
1263         mutex_unlock(&opts->lock);
1264 }
1265
1266 static struct config_item *uvcg_extension_make(struct config_group *group, const char *name)
1267 {
1268         struct config_item *opts_item;
1269         struct uvcg_extension *xu;
1270         struct f_uvc_opts *opts;
1271
1272         opts_item = group->cg_item.ci_parent->ci_parent;
1273         opts = to_f_uvc_opts(opts_item);
1274
1275         xu = kzalloc(sizeof(*xu), GFP_KERNEL);
1276         if (!xu)
1277                 return ERR_PTR(-ENOMEM);
1278
1279         xu->desc.bLength = UVC_DT_EXTENSION_UNIT_SIZE(0, 0);
1280         xu->desc.bDescriptorType = USB_DT_CS_INTERFACE;
1281         xu->desc.bDescriptorSubType = UVC_VC_EXTENSION_UNIT;
1282         xu->desc.bNumControls = 0;
1283         xu->desc.bNrInPins = 0;
1284         xu->desc.baSourceID = NULL;
1285         xu->desc.bControlSize = 0;
1286         xu->desc.bmControls = NULL;
1287
1288         mutex_lock(&opts->lock);
1289
1290         xu->desc.bUnitID = ++opts->last_unit_id;
1291
1292         config_item_init_type_name(&xu->item, name, &uvcg_extension_type);
1293         list_add_tail(&xu->list, &opts->extension_units);
1294
1295         mutex_unlock(&opts->lock);
1296
1297         return &xu->item;
1298 }
1299
1300 static struct configfs_group_operations uvcg_extensions_grp_ops = {
1301         .make_item      = uvcg_extension_make,
1302         .drop_item      = uvcg_extension_drop,
1303 };
1304
1305 static const struct uvcg_config_group_type uvcg_extensions_grp_type = {
1306         .type = {
1307                 .ct_item_ops    = &uvcg_config_item_ops,
1308                 .ct_group_ops   = &uvcg_extensions_grp_ops,
1309                 .ct_owner       = THIS_MODULE,
1310         },
1311         .name = "extensions",
1312 };
1313
1314 /* -----------------------------------------------------------------------------
1315  * control/class/{fs|ss}
1316  */
1317
1318 struct uvcg_control_class_group {
1319         struct config_group group;
1320         const char *name;
1321 };
1322
1323 static inline struct uvc_descriptor_header
1324 **uvcg_get_ctl_class_arr(struct config_item *i, struct f_uvc_opts *o)
1325 {
1326         struct uvcg_control_class_group *group =
1327                 container_of(i, struct uvcg_control_class_group,
1328                              group.cg_item);
1329
1330         if (!strcmp(group->name, "fs"))
1331                 return o->uvc_fs_control_cls;
1332
1333         if (!strcmp(group->name, "ss"))
1334                 return o->uvc_ss_control_cls;
1335
1336         return NULL;
1337 }
1338
1339 static int uvcg_control_class_allow_link(struct config_item *src,
1340                                          struct config_item *target)
1341 {
1342         struct config_item *control, *header;
1343         struct f_uvc_opts *opts;
1344         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
1345         struct uvc_descriptor_header **class_array;
1346         struct uvcg_control_header *target_hdr;
1347         int ret = -EINVAL;
1348
1349         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1350
1351         control = src->ci_parent->ci_parent;
1352         header = config_group_find_item(to_config_group(control), "header");
1353         if (!header || target->ci_parent != header)
1354                 goto out;
1355
1356         opts = to_f_uvc_opts(control->ci_parent);
1357
1358         mutex_lock(&opts->lock);
1359
1360         class_array = uvcg_get_ctl_class_arr(src, opts);
1361         if (!class_array)
1362                 goto unlock;
1363         if (opts->refcnt || class_array[0]) {
1364                 ret = -EBUSY;
1365                 goto unlock;
1366         }
1367
1368         target_hdr = to_uvcg_control_header(target);
1369         ++target_hdr->linked;
1370         class_array[0] = (struct uvc_descriptor_header *)&target_hdr->desc;
1371         ret = 0;
1372
1373 unlock:
1374         mutex_unlock(&opts->lock);
1375 out:
1376         config_item_put(header);
1377         mutex_unlock(su_mutex);
1378         return ret;
1379 }
1380
1381 static void uvcg_control_class_drop_link(struct config_item *src,
1382                                         struct config_item *target)
1383 {
1384         struct config_item *control, *header;
1385         struct f_uvc_opts *opts;
1386         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
1387         struct uvc_descriptor_header **class_array;
1388         struct uvcg_control_header *target_hdr;
1389
1390         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1391
1392         control = src->ci_parent->ci_parent;
1393         header = config_group_find_item(to_config_group(control), "header");
1394         if (!header || target->ci_parent != header)
1395                 goto out;
1396
1397         opts = to_f_uvc_opts(control->ci_parent);
1398
1399         mutex_lock(&opts->lock);
1400
1401         class_array = uvcg_get_ctl_class_arr(src, opts);
1402         if (!class_array || opts->refcnt)
1403                 goto unlock;
1404
1405         target_hdr = to_uvcg_control_header(target);
1406         --target_hdr->linked;
1407         class_array[0] = NULL;
1408
1409 unlock:
1410         mutex_unlock(&opts->lock);
1411 out:
1412         config_item_put(header);
1413         mutex_unlock(su_mutex);
1414 }
1415
1416 static struct configfs_item_operations uvcg_control_class_item_ops = {
1417         .release        = uvcg_config_item_release,
1418         .allow_link     = uvcg_control_class_allow_link,
1419         .drop_link      = uvcg_control_class_drop_link,
1420 };
1421
1422 static const struct config_item_type uvcg_control_class_type = {
1423         .ct_item_ops    = &uvcg_control_class_item_ops,
1424         .ct_owner       = THIS_MODULE,
1425 };
1426
1427 /* -----------------------------------------------------------------------------
1428  * control/class
1429  */
1430
1431 static int uvcg_control_class_create_children(struct config_group *parent)
1432 {
1433         static const char * const names[] = { "fs", "ss" };
1434         unsigned int i;
1435
1436         for (i = 0; i < ARRAY_SIZE(names); ++i) {
1437                 struct uvcg_control_class_group *group;
1438
1439                 group = kzalloc(sizeof(*group), GFP_KERNEL);
1440                 if (!group)
1441                         return -ENOMEM;
1442
1443                 group->name = names[i];
1444
1445                 config_group_init_type_name(&group->group, group->name,
1446                                             &uvcg_control_class_type);
1447                 configfs_add_default_group(&group->group, parent);
1448         }
1449
1450         return 0;
1451 }
1452
1453 static const struct uvcg_config_group_type uvcg_control_class_grp_type = {
1454         .type = {
1455                 .ct_item_ops    = &uvcg_config_item_ops,
1456                 .ct_owner       = THIS_MODULE,
1457         },
1458         .name = "class",
1459         .create_children = uvcg_control_class_create_children,
1460 };
1461
1462 /* -----------------------------------------------------------------------------
1463  * control
1464  */
1465
1466 static ssize_t uvcg_default_control_b_interface_number_show(
1467         struct config_item *item, char *page)
1468 {
1469         struct config_group *group = to_config_group(item);
1470         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
1471         struct config_item *opts_item;
1472         struct f_uvc_opts *opts;
1473         int result = 0;
1474
1475         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1476
1477         opts_item = item->ci_parent;
1478         opts = to_f_uvc_opts(opts_item);
1479
1480         mutex_lock(&opts->lock);
1481         result += sprintf(page, "%u\n", opts->control_interface);
1482         mutex_unlock(&opts->lock);
1483
1484         mutex_unlock(su_mutex);
1485
1486         return result;
1487 }
1488
1489 UVC_ATTR_RO(uvcg_default_control_, b_interface_number, bInterfaceNumber);
1490
1491 static ssize_t uvcg_default_control_enable_interrupt_ep_show(
1492         struct config_item *item, char *page)
1493 {
1494         struct config_group *group = to_config_group(item);
1495         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
1496         struct config_item *opts_item;
1497         struct f_uvc_opts *opts;
1498         int result = 0;
1499
1500         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1501
1502         opts_item = item->ci_parent;
1503         opts = to_f_uvc_opts(opts_item);
1504
1505         mutex_lock(&opts->lock);
1506         result += sprintf(page, "%u\n", opts->enable_interrupt_ep);
1507         mutex_unlock(&opts->lock);
1508
1509         mutex_unlock(su_mutex);
1510
1511         return result;
1512 }
1513
1514 static ssize_t uvcg_default_control_enable_interrupt_ep_store(
1515         struct config_item *item, const char *page, size_t len)
1516 {
1517         struct config_group *group = to_config_group(item);
1518         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
1519         struct config_item *opts_item;
1520         struct f_uvc_opts *opts;
1521         ssize_t ret;
1522         u8 num;
1523
1524         ret = kstrtou8(page, 0, &num);
1525         if (ret)
1526                 return ret;
1527
1528         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1529
1530         opts_item = item->ci_parent;
1531         opts = to_f_uvc_opts(opts_item);
1532
1533         mutex_lock(&opts->lock);
1534         opts->enable_interrupt_ep = num;
1535         mutex_unlock(&opts->lock);
1536
1537         mutex_unlock(su_mutex);
1538
1539         return len;
1540 }
1541 UVC_ATTR(uvcg_default_control_, enable_interrupt_ep, enable_interrupt_ep);
1542
1543 static struct configfs_attribute *uvcg_default_control_attrs[] = {
1544         &uvcg_default_control_attr_b_interface_number,
1545         &uvcg_default_control_attr_enable_interrupt_ep,
1546         NULL,
1547 };
1548
1549 static const struct uvcg_config_group_type uvcg_control_grp_type = {
1550         .type = {
1551                 .ct_item_ops    = &uvcg_config_item_ops,
1552                 .ct_attrs       = uvcg_default_control_attrs,
1553                 .ct_owner       = THIS_MODULE,
1554         },
1555         .name = "control",
1556         .children = (const struct uvcg_config_group_type*[]) {
1557                 &uvcg_control_header_grp_type,
1558                 &uvcg_processing_grp_type,
1559                 &uvcg_terminal_grp_type,
1560                 &uvcg_control_class_grp_type,
1561                 &uvcg_extensions_grp_type,
1562                 NULL,
1563         },
1564 };
1565
1566 /* -----------------------------------------------------------------------------
1567  * streaming/uncompressed
1568  * streaming/mjpeg
1569  */
1570
1571 static const char * const uvcg_format_names[] = {
1572         "uncompressed",
1573         "mjpeg",
1574 };
1575
1576 static struct uvcg_color_matching *
1577 uvcg_format_get_default_color_match(struct config_item *streaming)
1578 {
1579         struct config_item *color_matching_item, *cm_default;
1580         struct uvcg_color_matching *color_match;
1581
1582         color_matching_item = config_group_find_item(to_config_group(streaming),
1583                                                      "color_matching");
1584         if (!color_matching_item)
1585                 return NULL;
1586
1587         cm_default = config_group_find_item(to_config_group(color_matching_item),
1588                                             "default");
1589         config_item_put(color_matching_item);
1590         if (!cm_default)
1591                 return NULL;
1592
1593         color_match = to_uvcg_color_matching(to_config_group(cm_default));
1594         config_item_put(cm_default);
1595
1596         return color_match;
1597 }
1598
1599 static int uvcg_format_allow_link(struct config_item *src, struct config_item *tgt)
1600 {
1601         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
1602         struct uvcg_color_matching *color_matching_desc;
1603         struct config_item *streaming, *color_matching;
1604         struct uvcg_format *fmt;
1605         int ret = 0;
1606
1607         mutex_lock(su_mutex);
1608
1609         streaming = src->ci_parent->ci_parent;
1610         color_matching = config_group_find_item(to_config_group(streaming), "color_matching");
1611         if (!color_matching || color_matching != tgt->ci_parent) {
1612                 ret = -EINVAL;
1613                 goto out_put_cm;
1614         }
1615
1616         fmt = to_uvcg_format(src);
1617
1618         /*
1619          * There's always a color matching descriptor associated with the format
1620          * but without a symlink it should only ever be the default one. If it's
1621          * not the default, there's already a symlink and we should bail out.
1622          */
1623         color_matching_desc = uvcg_format_get_default_color_match(streaming);
1624         if (fmt->color_matching != color_matching_desc) {
1625                 ret = -EBUSY;
1626                 goto out_put_cm;
1627         }
1628
1629         color_matching_desc->refcnt--;
1630
1631         color_matching_desc = to_uvcg_color_matching(to_config_group(tgt));
1632         fmt->color_matching = color_matching_desc;
1633         color_matching_desc->refcnt++;
1634
1635 out_put_cm:
1636         config_item_put(color_matching);
1637         mutex_unlock(su_mutex);
1638
1639         return ret;
1640 }
1641
1642 static void uvcg_format_drop_link(struct config_item *src, struct config_item *tgt)
1643 {
1644         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
1645         struct uvcg_color_matching *color_matching_desc;
1646         struct config_item *streaming;
1647         struct uvcg_format *fmt;
1648
1649         mutex_lock(su_mutex);
1650
1651         color_matching_desc = to_uvcg_color_matching(to_config_group(tgt));
1652         color_matching_desc->refcnt--;
1653
1654         streaming = src->ci_parent->ci_parent;
1655         color_matching_desc = uvcg_format_get_default_color_match(streaming);
1656
1657         fmt = to_uvcg_format(src);
1658         fmt->color_matching = color_matching_desc;
1659         color_matching_desc->refcnt++;
1660
1661         mutex_unlock(su_mutex);
1662 }
1663
1664 static struct configfs_item_operations uvcg_format_item_operations = {
1665         .release        = uvcg_config_item_release,
1666         .allow_link     = uvcg_format_allow_link,
1667         .drop_link      = uvcg_format_drop_link,
1668 };
1669
1670 static ssize_t uvcg_format_bma_controls_show(struct uvcg_format *f, char *page)
1671 {
1672         struct f_uvc_opts *opts;
1673         struct config_item *opts_item;
1674         struct mutex *su_mutex = &f->group.cg_subsys->su_mutex;
1675         int result, i;
1676         char *pg = page;
1677
1678         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1679
1680         opts_item = f->group.cg_item.ci_parent->ci_parent->ci_parent;
1681         opts = to_f_uvc_opts(opts_item);
1682
1683         mutex_lock(&opts->lock);
1684         result = sprintf(pg, "0x");
1685         pg += result;
1686         for (i = 0; i < UVCG_STREAMING_CONTROL_SIZE; ++i) {
1687                 result += sprintf(pg, "%x\n", f->bmaControls[i]);
1688                 pg = page + result;
1689         }
1690         mutex_unlock(&opts->lock);
1691
1692         mutex_unlock(su_mutex);
1693         return result;
1694 }
1695
1696 static ssize_t uvcg_format_bma_controls_store(struct uvcg_format *ch,
1697                                               const char *page, size_t len)
1698 {
1699         struct f_uvc_opts *opts;
1700         struct config_item *opts_item;
1701         struct mutex *su_mutex = &ch->group.cg_subsys->su_mutex;
1702         int ret = -EINVAL;
1703
1704         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1705
1706         opts_item = ch->group.cg_item.ci_parent->ci_parent->ci_parent;
1707         opts = to_f_uvc_opts(opts_item);
1708
1709         mutex_lock(&opts->lock);
1710         if (ch->linked || opts->refcnt) {
1711                 ret = -EBUSY;
1712                 goto end;
1713         }
1714
1715         if (len < 4 || *page != '0' ||
1716             (*(page + 1) != 'x' && *(page + 1) != 'X'))
1717                 goto end;
1718         ret = hex2bin(ch->bmaControls, page + 2, 1);
1719         if (ret < 0)
1720                 goto end;
1721         ret = len;
1722 end:
1723         mutex_unlock(&opts->lock);
1724         mutex_unlock(su_mutex);
1725         return ret;
1726 }
1727
1728 /* -----------------------------------------------------------------------------
1729  * streaming/header/<NAME>
1730  * streaming/header
1731  */
1732
1733 static void uvcg_format_set_indices(struct config_group *fmt);
1734
1735 static int uvcg_streaming_header_allow_link(struct config_item *src,
1736                                             struct config_item *target)
1737 {
1738         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
1739         struct config_item *opts_item;
1740         struct f_uvc_opts *opts;
1741         struct uvcg_streaming_header *src_hdr;
1742         struct uvcg_format *target_fmt = NULL;
1743         struct uvcg_format_ptr *format_ptr;
1744         int i, ret = -EINVAL;
1745
1746         src_hdr = to_uvcg_streaming_header(src);
1747         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1748
1749         opts_item = src->ci_parent->ci_parent->ci_parent;
1750         opts = to_f_uvc_opts(opts_item);
1751
1752         mutex_lock(&opts->lock);
1753
1754         if (src_hdr->linked) {
1755                 ret = -EBUSY;
1756                 goto out;
1757         }
1758
1759         /*
1760          * Linking is only allowed to direct children of the format nodes
1761          * (streaming/uncompressed or streaming/mjpeg nodes). First check that
1762          * the grand-parent of the target matches the grand-parent of the source
1763          * (the streaming node), and then verify that the target parent is a
1764          * format node.
1765          */
1766         if (src->ci_parent->ci_parent != target->ci_parent->ci_parent)
1767                 goto out;
1768
1769         for (i = 0; i < ARRAY_SIZE(uvcg_format_names); ++i) {
1770                 if (!strcmp(target->ci_parent->ci_name, uvcg_format_names[i]))
1771                         break;
1772         }
1773
1774         if (i == ARRAY_SIZE(uvcg_format_names))
1775                 goto out;
1776
1777         target_fmt = container_of(to_config_group(target), struct uvcg_format,
1778                                   group);
1779
1780         uvcg_format_set_indices(to_config_group(target));
1781
1782         format_ptr = kzalloc(sizeof(*format_ptr), GFP_KERNEL);
1783         if (!format_ptr) {
1784                 ret = -ENOMEM;
1785                 goto out;
1786         }
1787         ret = 0;
1788         format_ptr->fmt = target_fmt;
1789         list_add_tail(&format_ptr->entry, &src_hdr->formats);
1790         ++src_hdr->num_fmt;
1791         ++target_fmt->linked;
1792
1793 out:
1794         mutex_unlock(&opts->lock);
1795         mutex_unlock(su_mutex);
1796         return ret;
1797 }
1798
1799 static void uvcg_streaming_header_drop_link(struct config_item *src,
1800                                            struct config_item *target)
1801 {
1802         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
1803         struct config_item *opts_item;
1804         struct f_uvc_opts *opts;
1805         struct uvcg_streaming_header *src_hdr;
1806         struct uvcg_format *target_fmt = NULL;
1807         struct uvcg_format_ptr *format_ptr, *tmp;
1808
1809         src_hdr = to_uvcg_streaming_header(src);
1810         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1811
1812         opts_item = src->ci_parent->ci_parent->ci_parent;
1813         opts = to_f_uvc_opts(opts_item);
1814
1815         mutex_lock(&opts->lock);
1816         target_fmt = container_of(to_config_group(target), struct uvcg_format,
1817                                   group);
1818
1819         list_for_each_entry_safe(format_ptr, tmp, &src_hdr->formats, entry)
1820                 if (format_ptr->fmt == target_fmt) {
1821                         list_del(&format_ptr->entry);
1822                         kfree(format_ptr);
1823                         --src_hdr->num_fmt;
1824                         break;
1825                 }
1826
1827         --target_fmt->linked;
1828
1829         mutex_unlock(&opts->lock);
1830         mutex_unlock(su_mutex);
1831 }
1832
1833 static struct configfs_item_operations uvcg_streaming_header_item_ops = {
1834         .release        = uvcg_config_item_release,
1835         .allow_link     = uvcg_streaming_header_allow_link,
1836         .drop_link      = uvcg_streaming_header_drop_link,
1837 };
1838
1839 #define UVCG_STREAMING_HEADER_ATTR(cname, aname, bits)                  \
1840 static ssize_t uvcg_streaming_header_##cname##_show(                    \
1841         struct config_item *item, char *page)                           \
1842 {                                                                       \
1843         struct uvcg_streaming_header *sh = to_uvcg_streaming_header(item); \
1844         struct f_uvc_opts *opts;                                        \
1845         struct config_item *opts_item;                                  \
1846         struct mutex *su_mutex = &sh->item.ci_group->cg_subsys->su_mutex;\
1847         int result;                                                     \
1848                                                                         \
1849         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1850                                                                         \
1851         opts_item = sh->item.ci_parent->ci_parent->ci_parent;           \
1852         opts = to_f_uvc_opts(opts_item);                                \
1853                                                                         \
1854         mutex_lock(&opts->lock);                                        \
1855         result = sprintf(page, "%u\n", le##bits##_to_cpu(sh->desc.aname));\
1856         mutex_unlock(&opts->lock);                                      \
1857                                                                         \
1858         mutex_unlock(su_mutex);                                         \
1859         return result;                                                  \
1860 }                                                                       \
1861                                                                         \
1862 UVC_ATTR_RO(uvcg_streaming_header_, cname, aname)
1863
1864 UVCG_STREAMING_HEADER_ATTR(bm_info, bmInfo, 8);
1865 UVCG_STREAMING_HEADER_ATTR(b_terminal_link, bTerminalLink, 8);
1866 UVCG_STREAMING_HEADER_ATTR(b_still_capture_method, bStillCaptureMethod, 8);
1867 UVCG_STREAMING_HEADER_ATTR(b_trigger_support, bTriggerSupport, 8);
1868 UVCG_STREAMING_HEADER_ATTR(b_trigger_usage, bTriggerUsage, 8);
1869
1870 #undef UVCG_STREAMING_HEADER_ATTR
1871
1872 static struct configfs_attribute *uvcg_streaming_header_attrs[] = {
1873         &uvcg_streaming_header_attr_bm_info,
1874         &uvcg_streaming_header_attr_b_terminal_link,
1875         &uvcg_streaming_header_attr_b_still_capture_method,
1876         &uvcg_streaming_header_attr_b_trigger_support,
1877         &uvcg_streaming_header_attr_b_trigger_usage,
1878         NULL,
1879 };
1880
1881 static const struct config_item_type uvcg_streaming_header_type = {
1882         .ct_item_ops    = &uvcg_streaming_header_item_ops,
1883         .ct_attrs       = uvcg_streaming_header_attrs,
1884         .ct_owner       = THIS_MODULE,
1885 };
1886
1887 static struct config_item
1888 *uvcg_streaming_header_make(struct config_group *group, const char *name)
1889 {
1890         struct uvcg_streaming_header *h;
1891
1892         h = kzalloc(sizeof(*h), GFP_KERNEL);
1893         if (!h)
1894                 return ERR_PTR(-ENOMEM);
1895
1896         INIT_LIST_HEAD(&h->formats);
1897         h->desc.bDescriptorType         = USB_DT_CS_INTERFACE;
1898         h->desc.bDescriptorSubType      = UVC_VS_INPUT_HEADER;
1899         h->desc.bTerminalLink           = 3;
1900         h->desc.bControlSize            = UVCG_STREAMING_CONTROL_SIZE;
1901
1902         config_item_init_type_name(&h->item, name, &uvcg_streaming_header_type);
1903
1904         return &h->item;
1905 }
1906
1907 static struct configfs_group_operations uvcg_streaming_header_grp_ops = {
1908         .make_item              = uvcg_streaming_header_make,
1909 };
1910
1911 static const struct uvcg_config_group_type uvcg_streaming_header_grp_type = {
1912         .type = {
1913                 .ct_item_ops    = &uvcg_config_item_ops,
1914                 .ct_group_ops   = &uvcg_streaming_header_grp_ops,
1915                 .ct_owner       = THIS_MODULE,
1916         },
1917         .name = "header",
1918 };
1919
1920 /* -----------------------------------------------------------------------------
1921  * streaming/<mode>/<format>/<NAME>
1922  */
1923
1924 #define UVCG_FRAME_ATTR(cname, aname, bits) \
1925 static ssize_t uvcg_frame_##cname##_show(struct config_item *item, char *page)\
1926 {                                                                       \
1927         struct uvcg_frame *f = to_uvcg_frame(item);                     \
1928         struct f_uvc_opts *opts;                                        \
1929         struct config_item *opts_item;                                  \
1930         struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
1931         int result;                                                     \
1932                                                                         \
1933         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1934                                                                         \
1935         opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
1936         opts = to_f_uvc_opts(opts_item);                                \
1937                                                                         \
1938         mutex_lock(&opts->lock);                                        \
1939         result = sprintf(page, "%u\n", f->frame.cname);                 \
1940         mutex_unlock(&opts->lock);                                      \
1941                                                                         \
1942         mutex_unlock(su_mutex);                                         \
1943         return result;                                                  \
1944 }                                                                       \
1945                                                                         \
1946 static ssize_t  uvcg_frame_##cname##_store(struct config_item *item,    \
1947                                            const char *page, size_t len)\
1948 {                                                                       \
1949         struct uvcg_frame *f = to_uvcg_frame(item);                     \
1950         struct f_uvc_opts *opts;                                        \
1951         struct config_item *opts_item;                                  \
1952         struct uvcg_format *fmt;                                        \
1953         struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
1954         typeof(f->frame.cname) num;                                     \
1955         int ret;                                                        \
1956                                                                         \
1957         ret = kstrtou##bits(page, 0, &num);                             \
1958         if (ret)                                                        \
1959                 return ret;                                             \
1960                                                                         \
1961         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
1962                                                                         \
1963         opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
1964         opts = to_f_uvc_opts(opts_item);                                \
1965         fmt = to_uvcg_format(f->item.ci_parent);                        \
1966                                                                         \
1967         mutex_lock(&opts->lock);                                        \
1968         if (fmt->linked || opts->refcnt) {                              \
1969                 ret = -EBUSY;                                           \
1970                 goto end;                                               \
1971         }                                                               \
1972                                                                         \
1973         f->frame.cname = num;                                           \
1974         ret = len;                                                      \
1975 end:                                                                    \
1976         mutex_unlock(&opts->lock);                                      \
1977         mutex_unlock(su_mutex);                                         \
1978         return ret;                                                     \
1979 }                                                                       \
1980                                                                         \
1981 UVC_ATTR(uvcg_frame_, cname, aname);
1982
1983 static ssize_t uvcg_frame_b_frame_index_show(struct config_item *item,
1984                                              char *page)
1985 {
1986         struct uvcg_frame *f = to_uvcg_frame(item);
1987         struct uvcg_format *fmt;
1988         struct f_uvc_opts *opts;
1989         struct config_item *opts_item;
1990         struct config_item *fmt_item;
1991         struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;
1992         int result;
1993
1994         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
1995
1996         fmt_item = f->item.ci_parent;
1997         fmt = to_uvcg_format(fmt_item);
1998
1999         if (!fmt->linked) {
2000                 result = -EBUSY;
2001                 goto out;
2002         }
2003
2004         opts_item = fmt_item->ci_parent->ci_parent->ci_parent;
2005         opts = to_f_uvc_opts(opts_item);
2006
2007         mutex_lock(&opts->lock);
2008         result = sprintf(page, "%u\n", f->frame.b_frame_index);
2009         mutex_unlock(&opts->lock);
2010
2011 out:
2012         mutex_unlock(su_mutex);
2013         return result;
2014 }
2015
2016 UVC_ATTR_RO(uvcg_frame_, b_frame_index, bFrameIndex);
2017
2018 UVCG_FRAME_ATTR(bm_capabilities, bmCapabilities, 8);
2019 UVCG_FRAME_ATTR(w_width, wWidth, 16);
2020 UVCG_FRAME_ATTR(w_height, wHeight, 16);
2021 UVCG_FRAME_ATTR(dw_min_bit_rate, dwMinBitRate, 32);
2022 UVCG_FRAME_ATTR(dw_max_bit_rate, dwMaxBitRate, 32);
2023 UVCG_FRAME_ATTR(dw_max_video_frame_buffer_size, dwMaxVideoFrameBufferSize, 32);
2024 UVCG_FRAME_ATTR(dw_default_frame_interval, dwDefaultFrameInterval, 32);
2025
2026 #undef UVCG_FRAME_ATTR
2027
2028 static ssize_t uvcg_frame_dw_frame_interval_show(struct config_item *item,
2029                                                  char *page)
2030 {
2031         struct uvcg_frame *frm = to_uvcg_frame(item);
2032         struct f_uvc_opts *opts;
2033         struct config_item *opts_item;
2034         struct mutex *su_mutex = &frm->item.ci_group->cg_subsys->su_mutex;
2035         int result, i;
2036         char *pg = page;
2037
2038         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
2039
2040         opts_item = frm->item.ci_parent->ci_parent->ci_parent->ci_parent;
2041         opts = to_f_uvc_opts(opts_item);
2042
2043         mutex_lock(&opts->lock);
2044         for (result = 0, i = 0; i < frm->frame.b_frame_interval_type; ++i) {
2045                 result += sprintf(pg, "%u\n", frm->dw_frame_interval[i]);
2046                 pg = page + result;
2047         }
2048         mutex_unlock(&opts->lock);
2049
2050         mutex_unlock(su_mutex);
2051         return result;
2052 }
2053
2054 static ssize_t uvcg_frame_dw_frame_interval_store(struct config_item *item,
2055                                                   const char *page, size_t len)
2056 {
2057         struct uvcg_frame *ch = to_uvcg_frame(item);
2058         struct f_uvc_opts *opts;
2059         struct config_item *opts_item;
2060         struct uvcg_format *fmt;
2061         struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;
2062         int ret = 0, n = 0;
2063         u32 *frm_intrv, *tmp;
2064
2065         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
2066
2067         opts_item = ch->item.ci_parent->ci_parent->ci_parent->ci_parent;
2068         opts = to_f_uvc_opts(opts_item);
2069         fmt = to_uvcg_format(ch->item.ci_parent);
2070
2071         mutex_lock(&opts->lock);
2072         if (fmt->linked || opts->refcnt) {
2073                 ret = -EBUSY;
2074                 goto end;
2075         }
2076
2077         ret = __uvcg_iter_item_entries(page, len, __uvcg_count_item_entries, &n, sizeof(u32));
2078         if (ret)
2079                 goto end;
2080
2081         tmp = frm_intrv = kcalloc(n, sizeof(u32), GFP_KERNEL);
2082         if (!frm_intrv) {
2083                 ret = -ENOMEM;
2084                 goto end;
2085         }
2086
2087         ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &tmp, sizeof(u32));
2088         if (ret) {
2089                 kfree(frm_intrv);
2090                 goto end;
2091         }
2092
2093         kfree(ch->dw_frame_interval);
2094         ch->dw_frame_interval = frm_intrv;
2095         ch->frame.b_frame_interval_type = n;
2096         sort(ch->dw_frame_interval, n, sizeof(*ch->dw_frame_interval),
2097              uvcg_config_compare_u32, NULL);
2098         ret = len;
2099
2100 end:
2101         mutex_unlock(&opts->lock);
2102         mutex_unlock(su_mutex);
2103         return ret;
2104 }
2105
2106 UVC_ATTR(uvcg_frame_, dw_frame_interval, dwFrameInterval);
2107
2108 static struct configfs_attribute *uvcg_frame_attrs[] = {
2109         &uvcg_frame_attr_b_frame_index,
2110         &uvcg_frame_attr_bm_capabilities,
2111         &uvcg_frame_attr_w_width,
2112         &uvcg_frame_attr_w_height,
2113         &uvcg_frame_attr_dw_min_bit_rate,
2114         &uvcg_frame_attr_dw_max_bit_rate,
2115         &uvcg_frame_attr_dw_max_video_frame_buffer_size,
2116         &uvcg_frame_attr_dw_default_frame_interval,
2117         &uvcg_frame_attr_dw_frame_interval,
2118         NULL,
2119 };
2120
2121 static const struct config_item_type uvcg_frame_type = {
2122         .ct_item_ops    = &uvcg_config_item_ops,
2123         .ct_attrs       = uvcg_frame_attrs,
2124         .ct_owner       = THIS_MODULE,
2125 };
2126
2127 static struct config_item *uvcg_frame_make(struct config_group *group,
2128                                            const char *name)
2129 {
2130         struct uvcg_frame *h;
2131         struct uvcg_format *fmt;
2132         struct f_uvc_opts *opts;
2133         struct config_item *opts_item;
2134         struct uvcg_frame_ptr *frame_ptr;
2135
2136         h = kzalloc(sizeof(*h), GFP_KERNEL);
2137         if (!h)
2138                 return ERR_PTR(-ENOMEM);
2139
2140         h->frame.b_descriptor_type              = USB_DT_CS_INTERFACE;
2141         h->frame.b_frame_index                  = 1;
2142         h->frame.w_width                        = 640;
2143         h->frame.w_height                       = 360;
2144         h->frame.dw_min_bit_rate                = 18432000;
2145         h->frame.dw_max_bit_rate                = 55296000;
2146         h->frame.dw_max_video_frame_buffer_size = 460800;
2147         h->frame.dw_default_frame_interval      = 666666;
2148
2149         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
2150         opts = to_f_uvc_opts(opts_item);
2151
2152         mutex_lock(&opts->lock);
2153         fmt = to_uvcg_format(&group->cg_item);
2154         if (fmt->type == UVCG_UNCOMPRESSED) {
2155                 h->frame.b_descriptor_subtype = UVC_VS_FRAME_UNCOMPRESSED;
2156                 h->fmt_type = UVCG_UNCOMPRESSED;
2157         } else if (fmt->type == UVCG_MJPEG) {
2158                 h->frame.b_descriptor_subtype = UVC_VS_FRAME_MJPEG;
2159                 h->fmt_type = UVCG_MJPEG;
2160         } else {
2161                 mutex_unlock(&opts->lock);
2162                 kfree(h);
2163                 return ERR_PTR(-EINVAL);
2164         }
2165
2166         frame_ptr = kzalloc(sizeof(*frame_ptr), GFP_KERNEL);
2167         if (!frame_ptr) {
2168                 mutex_unlock(&opts->lock);
2169                 kfree(h);
2170                 return ERR_PTR(-ENOMEM);
2171         }
2172
2173         frame_ptr->frm = h;
2174         list_add_tail(&frame_ptr->entry, &fmt->frames);
2175         ++fmt->num_frames;
2176         mutex_unlock(&opts->lock);
2177
2178         config_item_init_type_name(&h->item, name, &uvcg_frame_type);
2179
2180         return &h->item;
2181 }
2182
2183 static void uvcg_frame_drop(struct config_group *group, struct config_item *item)
2184 {
2185         struct uvcg_format *fmt;
2186         struct f_uvc_opts *opts;
2187         struct config_item *opts_item;
2188         struct uvcg_frame *target_frm = NULL;
2189         struct uvcg_frame_ptr *frame_ptr, *tmp;
2190
2191         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
2192         opts = to_f_uvc_opts(opts_item);
2193
2194         mutex_lock(&opts->lock);
2195         target_frm = container_of(item, struct uvcg_frame, item);
2196         fmt = to_uvcg_format(&group->cg_item);
2197
2198         list_for_each_entry_safe(frame_ptr, tmp, &fmt->frames, entry)
2199                 if (frame_ptr->frm == target_frm) {
2200                         list_del(&frame_ptr->entry);
2201                         kfree(frame_ptr);
2202                         --fmt->num_frames;
2203                         break;
2204                 }
2205         mutex_unlock(&opts->lock);
2206
2207         config_item_put(item);
2208 }
2209
2210 static void uvcg_format_set_indices(struct config_group *fmt)
2211 {
2212         struct config_item *ci;
2213         unsigned int i = 1;
2214
2215         list_for_each_entry(ci, &fmt->cg_children, ci_entry) {
2216                 struct uvcg_frame *frm;
2217
2218                 if (ci->ci_type != &uvcg_frame_type)
2219                         continue;
2220
2221                 frm = to_uvcg_frame(ci);
2222                 frm->frame.b_frame_index = i++;
2223         }
2224 }
2225
2226 /* -----------------------------------------------------------------------------
2227  * streaming/uncompressed/<NAME>
2228  */
2229
2230 static struct configfs_group_operations uvcg_uncompressed_group_ops = {
2231         .make_item              = uvcg_frame_make,
2232         .drop_item              = uvcg_frame_drop,
2233 };
2234
2235 static ssize_t uvcg_uncompressed_guid_format_show(struct config_item *item,
2236                                                         char *page)
2237 {
2238         struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
2239         struct f_uvc_opts *opts;
2240         struct config_item *opts_item;
2241         struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;
2242
2243         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
2244
2245         opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
2246         opts = to_f_uvc_opts(opts_item);
2247
2248         mutex_lock(&opts->lock);
2249         memcpy(page, ch->desc.guidFormat, sizeof(ch->desc.guidFormat));
2250         mutex_unlock(&opts->lock);
2251
2252         mutex_unlock(su_mutex);
2253
2254         return sizeof(ch->desc.guidFormat);
2255 }
2256
2257 static ssize_t uvcg_uncompressed_guid_format_store(struct config_item *item,
2258                                                    const char *page, size_t len)
2259 {
2260         struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
2261         struct f_uvc_opts *opts;
2262         struct config_item *opts_item;
2263         struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;
2264         const struct uvc_format_desc *format;
2265         u8 tmpguidFormat[sizeof(ch->desc.guidFormat)];
2266         int ret;
2267
2268         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
2269
2270         opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
2271         opts = to_f_uvc_opts(opts_item);
2272
2273         mutex_lock(&opts->lock);
2274         if (ch->fmt.linked || opts->refcnt) {
2275                 ret = -EBUSY;
2276                 goto end;
2277         }
2278
2279         memcpy(tmpguidFormat, page,
2280                min(sizeof(tmpguidFormat), len));
2281
2282         format = uvc_format_by_guid(tmpguidFormat);
2283         if (!format) {
2284                 ret = -EINVAL;
2285                 goto end;
2286         }
2287
2288         memcpy(ch->desc.guidFormat, tmpguidFormat,
2289                min(sizeof(ch->desc.guidFormat), len));
2290         ret = sizeof(ch->desc.guidFormat);
2291
2292 end:
2293         mutex_unlock(&opts->lock);
2294         mutex_unlock(su_mutex);
2295         return ret;
2296 }
2297
2298 UVC_ATTR(uvcg_uncompressed_, guid_format, guidFormat);
2299
2300 #define UVCG_UNCOMPRESSED_ATTR_RO(cname, aname, bits)                   \
2301 static ssize_t uvcg_uncompressed_##cname##_show(                        \
2302         struct config_item *item, char *page)                           \
2303 {                                                                       \
2304         struct uvcg_uncompressed *u = to_uvcg_uncompressed(item);       \
2305         struct f_uvc_opts *opts;                                        \
2306         struct config_item *opts_item;                                  \
2307         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
2308         int result;                                                     \
2309                                                                         \
2310         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
2311                                                                         \
2312         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
2313         opts = to_f_uvc_opts(opts_item);                                \
2314                                                                         \
2315         mutex_lock(&opts->lock);                                        \
2316         result = sprintf(page, "%u\n", le##bits##_to_cpu(u->desc.aname));\
2317         mutex_unlock(&opts->lock);                                      \
2318                                                                         \
2319         mutex_unlock(su_mutex);                                         \
2320         return result;                                                  \
2321 }                                                                       \
2322                                                                         \
2323 UVC_ATTR_RO(uvcg_uncompressed_, cname, aname);
2324
2325 #define UVCG_UNCOMPRESSED_ATTR(cname, aname, bits)                      \
2326 static ssize_t uvcg_uncompressed_##cname##_show(                        \
2327         struct config_item *item, char *page)                           \
2328 {                                                                       \
2329         struct uvcg_uncompressed *u = to_uvcg_uncompressed(item);       \
2330         struct f_uvc_opts *opts;                                        \
2331         struct config_item *opts_item;                                  \
2332         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
2333         int result;                                                     \
2334                                                                         \
2335         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
2336                                                                         \
2337         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
2338         opts = to_f_uvc_opts(opts_item);                                \
2339                                                                         \
2340         mutex_lock(&opts->lock);                                        \
2341         result = sprintf(page, "%u\n", le##bits##_to_cpu(u->desc.aname));\
2342         mutex_unlock(&opts->lock);                                      \
2343                                                                         \
2344         mutex_unlock(su_mutex);                                         \
2345         return result;                                                  \
2346 }                                                                       \
2347                                                                         \
2348 static ssize_t                                                          \
2349 uvcg_uncompressed_##cname##_store(struct config_item *item,             \
2350                                     const char *page, size_t len)       \
2351 {                                                                       \
2352         struct uvcg_uncompressed *u = to_uvcg_uncompressed(item);       \
2353         struct f_uvc_opts *opts;                                        \
2354         struct config_item *opts_item;                                  \
2355         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
2356         int ret;                                                        \
2357         u8 num;                                                         \
2358                                                                         \
2359         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
2360                                                                         \
2361         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
2362         opts = to_f_uvc_opts(opts_item);                                \
2363                                                                         \
2364         mutex_lock(&opts->lock);                                        \
2365         if (u->fmt.linked || opts->refcnt) {                            \
2366                 ret = -EBUSY;                                           \
2367                 goto end;                                               \
2368         }                                                               \
2369                                                                         \
2370         ret = kstrtou8(page, 0, &num);                                  \
2371         if (ret)                                                        \
2372                 goto end;                                               \
2373                                                                         \
2374         /* index values in uvc are never 0 */                           \
2375         if (!num) {                                                     \
2376                 ret = -EINVAL;                                          \
2377                 goto end;                                               \
2378         }                                                               \
2379                                                                         \
2380         u->desc.aname = num;                                            \
2381         ret = len;                                                      \
2382 end:                                                                    \
2383         mutex_unlock(&opts->lock);                                      \
2384         mutex_unlock(su_mutex);                                         \
2385         return ret;                                                     \
2386 }                                                                       \
2387                                                                         \
2388 UVC_ATTR(uvcg_uncompressed_, cname, aname);
2389
2390 UVCG_UNCOMPRESSED_ATTR_RO(b_format_index, bFormatIndex, 8);
2391 UVCG_UNCOMPRESSED_ATTR(b_bits_per_pixel, bBitsPerPixel, 8);
2392 UVCG_UNCOMPRESSED_ATTR(b_default_frame_index, bDefaultFrameIndex, 8);
2393 UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_x, bAspectRatioX, 8);
2394 UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_y, bAspectRatioY, 8);
2395 UVCG_UNCOMPRESSED_ATTR_RO(bm_interlace_flags, bmInterlaceFlags, 8);
2396
2397 #undef UVCG_UNCOMPRESSED_ATTR
2398 #undef UVCG_UNCOMPRESSED_ATTR_RO
2399
2400 static inline ssize_t
2401 uvcg_uncompressed_bma_controls_show(struct config_item *item, char *page)
2402 {
2403         struct uvcg_uncompressed *unc = to_uvcg_uncompressed(item);
2404         return uvcg_format_bma_controls_show(&unc->fmt, page);
2405 }
2406
2407 static inline ssize_t
2408 uvcg_uncompressed_bma_controls_store(struct config_item *item,
2409                                      const char *page, size_t len)
2410 {
2411         struct uvcg_uncompressed *unc = to_uvcg_uncompressed(item);
2412         return uvcg_format_bma_controls_store(&unc->fmt, page, len);
2413 }
2414
2415 UVC_ATTR(uvcg_uncompressed_, bma_controls, bmaControls);
2416
2417 static struct configfs_attribute *uvcg_uncompressed_attrs[] = {
2418         &uvcg_uncompressed_attr_b_format_index,
2419         &uvcg_uncompressed_attr_guid_format,
2420         &uvcg_uncompressed_attr_b_bits_per_pixel,
2421         &uvcg_uncompressed_attr_b_default_frame_index,
2422         &uvcg_uncompressed_attr_b_aspect_ratio_x,
2423         &uvcg_uncompressed_attr_b_aspect_ratio_y,
2424         &uvcg_uncompressed_attr_bm_interlace_flags,
2425         &uvcg_uncompressed_attr_bma_controls,
2426         NULL,
2427 };
2428
2429 static const struct config_item_type uvcg_uncompressed_type = {
2430         .ct_item_ops    = &uvcg_format_item_operations,
2431         .ct_group_ops   = &uvcg_uncompressed_group_ops,
2432         .ct_attrs       = uvcg_uncompressed_attrs,
2433         .ct_owner       = THIS_MODULE,
2434 };
2435
2436 static struct config_group *uvcg_uncompressed_make(struct config_group *group,
2437                                                    const char *name)
2438 {
2439         static char guid[] = {
2440                 'Y',  'U',  'Y',  '2', 0x00, 0x00, 0x10, 0x00,
2441                  0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71
2442         };
2443         struct uvcg_color_matching *color_match;
2444         struct config_item *streaming;
2445         struct uvcg_uncompressed *h;
2446
2447         streaming = group->cg_item.ci_parent;
2448         color_match = uvcg_format_get_default_color_match(streaming);
2449         if (!color_match)
2450                 return ERR_PTR(-EINVAL);
2451
2452         h = kzalloc(sizeof(*h), GFP_KERNEL);
2453         if (!h)
2454                 return ERR_PTR(-ENOMEM);
2455
2456         h->desc.bLength                 = UVC_DT_FORMAT_UNCOMPRESSED_SIZE;
2457         h->desc.bDescriptorType         = USB_DT_CS_INTERFACE;
2458         h->desc.bDescriptorSubType      = UVC_VS_FORMAT_UNCOMPRESSED;
2459         memcpy(h->desc.guidFormat, guid, sizeof(guid));
2460         h->desc.bBitsPerPixel           = 16;
2461         h->desc.bDefaultFrameIndex      = 1;
2462         h->desc.bAspectRatioX           = 0;
2463         h->desc.bAspectRatioY           = 0;
2464         h->desc.bmInterlaceFlags        = 0;
2465         h->desc.bCopyProtect            = 0;
2466
2467         INIT_LIST_HEAD(&h->fmt.frames);
2468         h->fmt.type = UVCG_UNCOMPRESSED;
2469         h->fmt.color_matching = color_match;
2470         color_match->refcnt++;
2471         config_group_init_type_name(&h->fmt.group, name,
2472                                     &uvcg_uncompressed_type);
2473
2474         return &h->fmt.group;
2475 }
2476
2477 static struct configfs_group_operations uvcg_uncompressed_grp_ops = {
2478         .make_group             = uvcg_uncompressed_make,
2479 };
2480
2481 static const struct uvcg_config_group_type uvcg_uncompressed_grp_type = {
2482         .type = {
2483                 .ct_item_ops    = &uvcg_config_item_ops,
2484                 .ct_group_ops   = &uvcg_uncompressed_grp_ops,
2485                 .ct_owner       = THIS_MODULE,
2486         },
2487         .name = "uncompressed",
2488 };
2489
2490 /* -----------------------------------------------------------------------------
2491  * streaming/mjpeg/<NAME>
2492  */
2493
2494 static struct configfs_group_operations uvcg_mjpeg_group_ops = {
2495         .make_item              = uvcg_frame_make,
2496         .drop_item              = uvcg_frame_drop,
2497 };
2498
2499 #define UVCG_MJPEG_ATTR_RO(cname, aname, bits)                          \
2500 static ssize_t uvcg_mjpeg_##cname##_show(struct config_item *item, char *page)\
2501 {                                                                       \
2502         struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);                     \
2503         struct f_uvc_opts *opts;                                        \
2504         struct config_item *opts_item;                                  \
2505         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
2506         int result;                                                     \
2507                                                                         \
2508         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
2509                                                                         \
2510         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
2511         opts = to_f_uvc_opts(opts_item);                                \
2512                                                                         \
2513         mutex_lock(&opts->lock);                                        \
2514         result = sprintf(page, "%u\n", le##bits##_to_cpu(u->desc.aname));\
2515         mutex_unlock(&opts->lock);                                      \
2516                                                                         \
2517         mutex_unlock(su_mutex);                                         \
2518         return result;                                                  \
2519 }                                                                       \
2520                                                                         \
2521 UVC_ATTR_RO(uvcg_mjpeg_, cname, aname)
2522
2523 #define UVCG_MJPEG_ATTR(cname, aname, bits)                             \
2524 static ssize_t uvcg_mjpeg_##cname##_show(struct config_item *item, char *page)\
2525 {                                                                       \
2526         struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);                     \
2527         struct f_uvc_opts *opts;                                        \
2528         struct config_item *opts_item;                                  \
2529         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
2530         int result;                                                     \
2531                                                                         \
2532         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
2533                                                                         \
2534         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
2535         opts = to_f_uvc_opts(opts_item);                                \
2536                                                                         \
2537         mutex_lock(&opts->lock);                                        \
2538         result = sprintf(page, "%u\n", le##bits##_to_cpu(u->desc.aname));\
2539         mutex_unlock(&opts->lock);                                      \
2540                                                                         \
2541         mutex_unlock(su_mutex);                                         \
2542         return result;                                                  \
2543 }                                                                       \
2544                                                                         \
2545 static ssize_t                                                          \
2546 uvcg_mjpeg_##cname##_store(struct config_item *item,                    \
2547                            const char *page, size_t len)                \
2548 {                                                                       \
2549         struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);                     \
2550         struct f_uvc_opts *opts;                                        \
2551         struct config_item *opts_item;                                  \
2552         struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex;     \
2553         int ret;                                                        \
2554         u8 num;                                                         \
2555                                                                         \
2556         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
2557                                                                         \
2558         opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
2559         opts = to_f_uvc_opts(opts_item);                                \
2560                                                                         \
2561         mutex_lock(&opts->lock);                                        \
2562         if (u->fmt.linked || opts->refcnt) {                            \
2563                 ret = -EBUSY;                                           \
2564                 goto end;                                               \
2565         }                                                               \
2566                                                                         \
2567         ret = kstrtou8(page, 0, &num);                                  \
2568         if (ret)                                                        \
2569                 goto end;                                               \
2570                                                                         \
2571         /* index values in uvc are never 0 */                           \
2572         if (!num) {                                                     \
2573                 ret = -EINVAL;                                          \
2574                 goto end;                                               \
2575         }                                                               \
2576                                                                         \
2577         u->desc.aname = num;                                            \
2578         ret = len;                                                      \
2579 end:                                                                    \
2580         mutex_unlock(&opts->lock);                                      \
2581         mutex_unlock(su_mutex);                                         \
2582         return ret;                                                     \
2583 }                                                                       \
2584                                                                         \
2585 UVC_ATTR(uvcg_mjpeg_, cname, aname)
2586
2587 UVCG_MJPEG_ATTR_RO(b_format_index, bFormatIndex, 8);
2588 UVCG_MJPEG_ATTR(b_default_frame_index, bDefaultFrameIndex, 8);
2589 UVCG_MJPEG_ATTR_RO(bm_flags, bmFlags, 8);
2590 UVCG_MJPEG_ATTR_RO(b_aspect_ratio_x, bAspectRatioX, 8);
2591 UVCG_MJPEG_ATTR_RO(b_aspect_ratio_y, bAspectRatioY, 8);
2592 UVCG_MJPEG_ATTR_RO(bm_interlace_flags, bmInterlaceFlags, 8);
2593
2594 #undef UVCG_MJPEG_ATTR
2595 #undef UVCG_MJPEG_ATTR_RO
2596
2597 static inline ssize_t
2598 uvcg_mjpeg_bma_controls_show(struct config_item *item, char *page)
2599 {
2600         struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);
2601         return uvcg_format_bma_controls_show(&u->fmt, page);
2602 }
2603
2604 static inline ssize_t
2605 uvcg_mjpeg_bma_controls_store(struct config_item *item,
2606                                      const char *page, size_t len)
2607 {
2608         struct uvcg_mjpeg *u = to_uvcg_mjpeg(item);
2609         return uvcg_format_bma_controls_store(&u->fmt, page, len);
2610 }
2611
2612 UVC_ATTR(uvcg_mjpeg_, bma_controls, bmaControls);
2613
2614 static struct configfs_attribute *uvcg_mjpeg_attrs[] = {
2615         &uvcg_mjpeg_attr_b_format_index,
2616         &uvcg_mjpeg_attr_b_default_frame_index,
2617         &uvcg_mjpeg_attr_bm_flags,
2618         &uvcg_mjpeg_attr_b_aspect_ratio_x,
2619         &uvcg_mjpeg_attr_b_aspect_ratio_y,
2620         &uvcg_mjpeg_attr_bm_interlace_flags,
2621         &uvcg_mjpeg_attr_bma_controls,
2622         NULL,
2623 };
2624
2625 static const struct config_item_type uvcg_mjpeg_type = {
2626         .ct_item_ops    = &uvcg_format_item_operations,
2627         .ct_group_ops   = &uvcg_mjpeg_group_ops,
2628         .ct_attrs       = uvcg_mjpeg_attrs,
2629         .ct_owner       = THIS_MODULE,
2630 };
2631
2632 static struct config_group *uvcg_mjpeg_make(struct config_group *group,
2633                                                    const char *name)
2634 {
2635         struct uvcg_color_matching *color_match;
2636         struct config_item *streaming;
2637         struct uvcg_mjpeg *h;
2638
2639         streaming = group->cg_item.ci_parent;
2640         color_match = uvcg_format_get_default_color_match(streaming);
2641         if (!color_match)
2642                 return ERR_PTR(-EINVAL);
2643
2644         h = kzalloc(sizeof(*h), GFP_KERNEL);
2645         if (!h)
2646                 return ERR_PTR(-ENOMEM);
2647
2648         h->desc.bLength                 = UVC_DT_FORMAT_MJPEG_SIZE;
2649         h->desc.bDescriptorType         = USB_DT_CS_INTERFACE;
2650         h->desc.bDescriptorSubType      = UVC_VS_FORMAT_MJPEG;
2651         h->desc.bDefaultFrameIndex      = 1;
2652         h->desc.bAspectRatioX           = 0;
2653         h->desc.bAspectRatioY           = 0;
2654         h->desc.bmInterlaceFlags        = 0;
2655         h->desc.bCopyProtect            = 0;
2656
2657         INIT_LIST_HEAD(&h->fmt.frames);
2658         h->fmt.type = UVCG_MJPEG;
2659         h->fmt.color_matching = color_match;
2660         color_match->refcnt++;
2661         config_group_init_type_name(&h->fmt.group, name,
2662                                     &uvcg_mjpeg_type);
2663
2664         return &h->fmt.group;
2665 }
2666
2667 static struct configfs_group_operations uvcg_mjpeg_grp_ops = {
2668         .make_group             = uvcg_mjpeg_make,
2669 };
2670
2671 static const struct uvcg_config_group_type uvcg_mjpeg_grp_type = {
2672         .type = {
2673                 .ct_item_ops    = &uvcg_config_item_ops,
2674                 .ct_group_ops   = &uvcg_mjpeg_grp_ops,
2675                 .ct_owner       = THIS_MODULE,
2676         },
2677         .name = "mjpeg",
2678 };
2679
2680 /* -----------------------------------------------------------------------------
2681  * streaming/color_matching/default
2682  */
2683
2684 #define UVCG_COLOR_MATCHING_ATTR(cname, aname, bits)                    \
2685 static ssize_t uvcg_color_matching_##cname##_show(                      \
2686         struct config_item *item, char *page)                           \
2687 {                                                                       \
2688         struct config_group *group = to_config_group(item);             \
2689         struct uvcg_color_matching *color_match =                       \
2690                 to_uvcg_color_matching(group);                          \
2691         struct f_uvc_opts *opts;                                        \
2692         struct config_item *opts_item;                                  \
2693         struct mutex *su_mutex = &group->cg_subsys->su_mutex;           \
2694         int result;                                                     \
2695                                                                         \
2696         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
2697                                                                         \
2698         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;     \
2699         opts = to_f_uvc_opts(opts_item);                                \
2700                                                                         \
2701         mutex_lock(&opts->lock);                                        \
2702         result = sprintf(page, "%u\n",                                  \
2703                          le##bits##_to_cpu(color_match->desc.aname));   \
2704         mutex_unlock(&opts->lock);                                      \
2705                                                                         \
2706         mutex_unlock(su_mutex);                                         \
2707         return result;                                                  \
2708 }                                                                       \
2709                                                                         \
2710 static ssize_t uvcg_color_matching_##cname##_store(                     \
2711         struct config_item *item, const char *page, size_t len)         \
2712 {                                                                       \
2713         struct config_group *group = to_config_group(item);             \
2714         struct mutex *su_mutex = &group->cg_subsys->su_mutex;           \
2715         struct uvcg_color_matching *color_match =                       \
2716                 to_uvcg_color_matching(group);                          \
2717         struct f_uvc_opts *opts;                                        \
2718         struct config_item *opts_item;                                  \
2719         int ret;                                                        \
2720         u##bits num;                                                    \
2721                                                                         \
2722         ret = kstrtou##bits(page, 0, &num);                             \
2723         if (ret)                                                        \
2724                 return ret;                                             \
2725                                                                         \
2726         mutex_lock(su_mutex); /* for navigating configfs hierarchy */   \
2727                                                                         \
2728         if (color_match->refcnt) {                                      \
2729                 ret = -EBUSY;                                           \
2730                 goto unlock_su;                                         \
2731         }                                                               \
2732                                                                         \
2733         opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;     \
2734         opts = to_f_uvc_opts(opts_item);                                \
2735                                                                         \
2736         mutex_lock(&opts->lock);                                        \
2737                                                                         \
2738         color_match->desc.aname = num;                                  \
2739         ret = len;                                                      \
2740                                                                         \
2741         mutex_unlock(&opts->lock);                                      \
2742 unlock_su:                                                              \
2743         mutex_unlock(su_mutex);                                         \
2744                                                                         \
2745         return ret;                                                     \
2746 }                                                                       \
2747 UVC_ATTR(uvcg_color_matching_, cname, aname)
2748
2749 UVCG_COLOR_MATCHING_ATTR(b_color_primaries, bColorPrimaries, 8);
2750 UVCG_COLOR_MATCHING_ATTR(b_transfer_characteristics, bTransferCharacteristics, 8);
2751 UVCG_COLOR_MATCHING_ATTR(b_matrix_coefficients, bMatrixCoefficients, 8);
2752
2753 #undef UVCG_COLOR_MATCHING_ATTR
2754
2755 static struct configfs_attribute *uvcg_color_matching_attrs[] = {
2756         &uvcg_color_matching_attr_b_color_primaries,
2757         &uvcg_color_matching_attr_b_transfer_characteristics,
2758         &uvcg_color_matching_attr_b_matrix_coefficients,
2759         NULL,
2760 };
2761
2762 static void uvcg_color_matching_release(struct config_item *item)
2763 {
2764         struct uvcg_color_matching *color_match =
2765                 to_uvcg_color_matching(to_config_group(item));
2766
2767         kfree(color_match);
2768 }
2769
2770 static struct configfs_item_operations uvcg_color_matching_item_ops = {
2771         .release        = uvcg_color_matching_release,
2772 };
2773
2774 static const struct config_item_type uvcg_color_matching_type = {
2775         .ct_item_ops    = &uvcg_color_matching_item_ops,
2776         .ct_attrs       = uvcg_color_matching_attrs,
2777         .ct_owner       = THIS_MODULE,
2778 };
2779
2780 /* -----------------------------------------------------------------------------
2781  * streaming/color_matching
2782  */
2783
2784 static struct config_group *uvcg_color_matching_make(struct config_group *group,
2785                                                      const char *name)
2786 {
2787         struct uvcg_color_matching *color_match;
2788
2789         color_match = kzalloc(sizeof(*color_match), GFP_KERNEL);
2790         if (!color_match)
2791                 return ERR_PTR(-ENOMEM);
2792
2793         color_match->desc.bLength = UVC_DT_COLOR_MATCHING_SIZE;
2794         color_match->desc.bDescriptorType = USB_DT_CS_INTERFACE;
2795         color_match->desc.bDescriptorSubType = UVC_VS_COLORFORMAT;
2796
2797         config_group_init_type_name(&color_match->group, name,
2798                                     &uvcg_color_matching_type);
2799
2800         return &color_match->group;
2801 }
2802
2803 static struct configfs_group_operations uvcg_color_matching_grp_group_ops = {
2804         .make_group     = uvcg_color_matching_make,
2805 };
2806
2807 static int uvcg_color_matching_create_children(struct config_group *parent)
2808 {
2809         struct uvcg_color_matching *color_match;
2810
2811         color_match = kzalloc(sizeof(*color_match), GFP_KERNEL);
2812         if (!color_match)
2813                 return -ENOMEM;
2814
2815         color_match->desc.bLength = UVC_DT_COLOR_MATCHING_SIZE;
2816         color_match->desc.bDescriptorType = USB_DT_CS_INTERFACE;
2817         color_match->desc.bDescriptorSubType = UVC_VS_COLORFORMAT;
2818         color_match->desc.bColorPrimaries = UVC_COLOR_PRIMARIES_BT_709_SRGB;
2819         color_match->desc.bTransferCharacteristics = UVC_TRANSFER_CHARACTERISTICS_BT_709;
2820         color_match->desc.bMatrixCoefficients = UVC_MATRIX_COEFFICIENTS_SMPTE_170M;
2821
2822         config_group_init_type_name(&color_match->group, "default",
2823                                     &uvcg_color_matching_type);
2824         configfs_add_default_group(&color_match->group, parent);
2825
2826         return 0;
2827 }
2828
2829 static const struct uvcg_config_group_type uvcg_color_matching_grp_type = {
2830         .type = {
2831                 .ct_item_ops    = &uvcg_config_item_ops,
2832                 .ct_group_ops   = &uvcg_color_matching_grp_group_ops,
2833                 .ct_owner       = THIS_MODULE,
2834         },
2835         .name = "color_matching",
2836         .create_children = uvcg_color_matching_create_children,
2837 };
2838
2839 /* -----------------------------------------------------------------------------
2840  * streaming/class/{fs|hs|ss}
2841  */
2842
2843 struct uvcg_streaming_class_group {
2844         struct config_group group;
2845         const char *name;
2846 };
2847
2848 static inline struct uvc_descriptor_header
2849 ***__uvcg_get_stream_class_arr(struct config_item *i, struct f_uvc_opts *o)
2850 {
2851         struct uvcg_streaming_class_group *group =
2852                 container_of(i, struct uvcg_streaming_class_group,
2853                              group.cg_item);
2854
2855         if (!strcmp(group->name, "fs"))
2856                 return &o->uvc_fs_streaming_cls;
2857
2858         if (!strcmp(group->name, "hs"))
2859                 return &o->uvc_hs_streaming_cls;
2860
2861         if (!strcmp(group->name, "ss"))
2862                 return &o->uvc_ss_streaming_cls;
2863
2864         return NULL;
2865 }
2866
2867 enum uvcg_strm_type {
2868         UVCG_HEADER = 0,
2869         UVCG_FORMAT,
2870         UVCG_FRAME,
2871         UVCG_COLOR_MATCHING,
2872 };
2873
2874 /*
2875  * Iterate over a hierarchy of streaming descriptors' config items.
2876  * The items are created by the user with configfs.
2877  *
2878  * It "processes" the header pointed to by @priv1, then for each format
2879  * that follows the header "processes" the format itself and then for
2880  * each frame inside a format "processes" the frame.
2881  *
2882  * As a "processing" function the @fun is used.
2883  *
2884  * __uvcg_iter_strm_cls() is used in two context: first, to calculate
2885  * the amount of memory needed for an array of streaming descriptors
2886  * and second, to actually fill the array.
2887  *
2888  * @h: streaming header pointer
2889  * @priv2: an "inout" parameter (the caller might want to see the changes to it)
2890  * @priv3: an "inout" parameter (the caller might want to see the changes to it)
2891  * @fun: callback function for processing each level of the hierarchy
2892  */
2893 static int __uvcg_iter_strm_cls(struct uvcg_streaming_header *h,
2894         void *priv2, void *priv3,
2895         int (*fun)(void *, void *, void *, int, enum uvcg_strm_type type))
2896 {
2897         struct uvcg_format_ptr *f;
2898         struct config_group *grp;
2899         struct config_item *item;
2900         struct uvcg_frame *frm;
2901         int ret, i, j;
2902
2903         if (!fun)
2904                 return -EINVAL;
2905
2906         i = j = 0;
2907         ret = fun(h, priv2, priv3, 0, UVCG_HEADER);
2908         if (ret)
2909                 return ret;
2910         list_for_each_entry(f, &h->formats, entry) {
2911                 ret = fun(f->fmt, priv2, priv3, i++, UVCG_FORMAT);
2912                 if (ret)
2913                         return ret;
2914                 grp = &f->fmt->group;
2915                 list_for_each_entry(item, &grp->cg_children, ci_entry) {
2916                         frm = to_uvcg_frame(item);
2917                         ret = fun(frm, priv2, priv3, j++, UVCG_FRAME);
2918                         if (ret)
2919                                 return ret;
2920                 }
2921
2922                 ret = fun(f->fmt->color_matching, priv2, priv3, 0,
2923                           UVCG_COLOR_MATCHING);
2924                 if (ret)
2925                         return ret;
2926         }
2927
2928         return ret;
2929 }
2930
2931 /*
2932  * Count how many bytes are needed for an array of streaming descriptors.
2933  *
2934  * @priv1: pointer to a header, format or frame
2935  * @priv2: inout parameter, accumulated size of the array
2936  * @priv3: inout parameter, accumulated number of the array elements
2937  * @n: unused, this function's prototype must match @fun in __uvcg_iter_strm_cls
2938  */
2939 static int __uvcg_cnt_strm(void *priv1, void *priv2, void *priv3, int n,
2940                            enum uvcg_strm_type type)
2941 {
2942         size_t *size = priv2;
2943         size_t *count = priv3;
2944
2945         switch (type) {
2946         case UVCG_HEADER: {
2947                 struct uvcg_streaming_header *h = priv1;
2948
2949                 *size += sizeof(h->desc);
2950                 /* bmaControls */
2951                 *size += h->num_fmt * UVCG_STREAMING_CONTROL_SIZE;
2952         }
2953         break;
2954         case UVCG_FORMAT: {
2955                 struct uvcg_format *fmt = priv1;
2956
2957                 if (fmt->type == UVCG_UNCOMPRESSED) {
2958                         struct uvcg_uncompressed *u =
2959                                 container_of(fmt, struct uvcg_uncompressed,
2960                                              fmt);
2961
2962                         *size += sizeof(u->desc);
2963                 } else if (fmt->type == UVCG_MJPEG) {
2964                         struct uvcg_mjpeg *m =
2965                                 container_of(fmt, struct uvcg_mjpeg, fmt);
2966
2967                         *size += sizeof(m->desc);
2968                 } else {
2969                         return -EINVAL;
2970                 }
2971         }
2972         break;
2973         case UVCG_FRAME: {
2974                 struct uvcg_frame *frm = priv1;
2975                 int sz = sizeof(frm->dw_frame_interval);
2976
2977                 *size += sizeof(frm->frame);
2978                 *size += frm->frame.b_frame_interval_type * sz;
2979         }
2980         break;
2981         case UVCG_COLOR_MATCHING: {
2982                 struct uvcg_color_matching *color_match = priv1;
2983
2984                 *size += sizeof(color_match->desc);
2985         }
2986         break;
2987         }
2988
2989         ++*count;
2990
2991         return 0;
2992 }
2993
2994 /*
2995  * Fill an array of streaming descriptors.
2996  *
2997  * @priv1: pointer to a header, format or frame
2998  * @priv2: inout parameter, pointer into a block of memory
2999  * @priv3: inout parameter, pointer to a 2-dimensional array
3000  */
3001 static int __uvcg_fill_strm(void *priv1, void *priv2, void *priv3, int n,
3002                             enum uvcg_strm_type type)
3003 {
3004         void **dest = priv2;
3005         struct uvc_descriptor_header ***array = priv3;
3006         size_t sz;
3007
3008         **array = *dest;
3009         ++*array;
3010
3011         switch (type) {
3012         case UVCG_HEADER: {
3013                 struct uvc_input_header_descriptor *ihdr = *dest;
3014                 struct uvcg_streaming_header *h = priv1;
3015                 struct uvcg_format_ptr *f;
3016
3017                 memcpy(*dest, &h->desc, sizeof(h->desc));
3018                 *dest += sizeof(h->desc);
3019                 sz = UVCG_STREAMING_CONTROL_SIZE;
3020                 list_for_each_entry(f, &h->formats, entry) {
3021                         memcpy(*dest, f->fmt->bmaControls, sz);
3022                         *dest += sz;
3023                 }
3024                 ihdr->bLength = sizeof(h->desc) + h->num_fmt * sz;
3025                 ihdr->bNumFormats = h->num_fmt;
3026         }
3027         break;
3028         case UVCG_FORMAT: {
3029                 struct uvcg_format *fmt = priv1;
3030
3031                 if (fmt->type == UVCG_UNCOMPRESSED) {
3032                         struct uvcg_uncompressed *u =
3033                                 container_of(fmt, struct uvcg_uncompressed,
3034                                              fmt);
3035
3036                         u->desc.bFormatIndex = n + 1;
3037                         u->desc.bNumFrameDescriptors = fmt->num_frames;
3038                         memcpy(*dest, &u->desc, sizeof(u->desc));
3039                         *dest += sizeof(u->desc);
3040                 } else if (fmt->type == UVCG_MJPEG) {
3041                         struct uvcg_mjpeg *m =
3042                                 container_of(fmt, struct uvcg_mjpeg, fmt);
3043
3044                         m->desc.bFormatIndex = n + 1;
3045                         m->desc.bNumFrameDescriptors = fmt->num_frames;
3046                         memcpy(*dest, &m->desc, sizeof(m->desc));
3047                         *dest += sizeof(m->desc);
3048                 } else {
3049                         return -EINVAL;
3050                 }
3051         }
3052         break;
3053         case UVCG_FRAME: {
3054                 struct uvcg_frame *frm = priv1;
3055                 struct uvc_descriptor_header *h = *dest;
3056
3057                 sz = sizeof(frm->frame);
3058                 memcpy(*dest, &frm->frame, sz);
3059                 *dest += sz;
3060                 sz = frm->frame.b_frame_interval_type *
3061                         sizeof(*frm->dw_frame_interval);
3062                 memcpy(*dest, frm->dw_frame_interval, sz);
3063                 *dest += sz;
3064                 if (frm->fmt_type == UVCG_UNCOMPRESSED)
3065                         h->bLength = UVC_DT_FRAME_UNCOMPRESSED_SIZE(
3066                                 frm->frame.b_frame_interval_type);
3067                 else if (frm->fmt_type == UVCG_MJPEG)
3068                         h->bLength = UVC_DT_FRAME_MJPEG_SIZE(
3069                                 frm->frame.b_frame_interval_type);
3070         }
3071         break;
3072         case UVCG_COLOR_MATCHING: {
3073                 struct uvcg_color_matching *color_match = priv1;
3074
3075                 memcpy(*dest, &color_match->desc, sizeof(color_match->desc));
3076                 *dest += sizeof(color_match->desc);
3077         }
3078         break;
3079         }
3080
3081         return 0;
3082 }
3083
3084 static int uvcg_streaming_class_allow_link(struct config_item *src,
3085                                            struct config_item *target)
3086 {
3087         struct config_item *streaming, *header;
3088         struct f_uvc_opts *opts;
3089         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
3090         struct uvc_descriptor_header ***class_array, **cl_arr;
3091         struct uvcg_streaming_header *target_hdr;
3092         void *data, *data_save;
3093         size_t size = 0, count = 0;
3094         int ret = -EINVAL;
3095
3096         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
3097
3098         streaming = src->ci_parent->ci_parent;
3099         header = config_group_find_item(to_config_group(streaming), "header");
3100         if (!header || target->ci_parent != header)
3101                 goto out;
3102
3103         opts = to_f_uvc_opts(streaming->ci_parent);
3104
3105         mutex_lock(&opts->lock);
3106
3107         class_array = __uvcg_get_stream_class_arr(src, opts);
3108         if (!class_array || *class_array || opts->refcnt) {
3109                 ret = -EBUSY;
3110                 goto unlock;
3111         }
3112
3113         target_hdr = to_uvcg_streaming_header(target);
3114         ret = __uvcg_iter_strm_cls(target_hdr, &size, &count, __uvcg_cnt_strm);
3115         if (ret)
3116                 goto unlock;
3117
3118         count += 1; /* NULL */
3119         *class_array = kcalloc(count, sizeof(void *), GFP_KERNEL);
3120         if (!*class_array) {
3121                 ret = -ENOMEM;
3122                 goto unlock;
3123         }
3124
3125         data = data_save = kzalloc(size, GFP_KERNEL);
3126         if (!data) {
3127                 kfree(*class_array);
3128                 *class_array = NULL;
3129                 ret = -ENOMEM;
3130                 goto unlock;
3131         }
3132         cl_arr = *class_array;
3133         ret = __uvcg_iter_strm_cls(target_hdr, &data, &cl_arr,
3134                                    __uvcg_fill_strm);
3135         if (ret) {
3136                 kfree(*class_array);
3137                 *class_array = NULL;
3138                 /*
3139                  * __uvcg_fill_strm() called from __uvcg_iter_stream_cls()
3140                  * might have advanced the "data", so use a backup copy
3141                  */
3142                 kfree(data_save);
3143                 goto unlock;
3144         }
3145
3146         ++target_hdr->linked;
3147         ret = 0;
3148
3149 unlock:
3150         mutex_unlock(&opts->lock);
3151 out:
3152         config_item_put(header);
3153         mutex_unlock(su_mutex);
3154         return ret;
3155 }
3156
3157 static void uvcg_streaming_class_drop_link(struct config_item *src,
3158                                           struct config_item *target)
3159 {
3160         struct config_item *streaming, *header;
3161         struct f_uvc_opts *opts;
3162         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
3163         struct uvc_descriptor_header ***class_array;
3164         struct uvcg_streaming_header *target_hdr;
3165
3166         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
3167
3168         streaming = src->ci_parent->ci_parent;
3169         header = config_group_find_item(to_config_group(streaming), "header");
3170         if (!header || target->ci_parent != header)
3171                 goto out;
3172
3173         opts = to_f_uvc_opts(streaming->ci_parent);
3174
3175         mutex_lock(&opts->lock);
3176
3177         class_array = __uvcg_get_stream_class_arr(src, opts);
3178         if (!class_array || !*class_array)
3179                 goto unlock;
3180
3181         if (opts->refcnt)
3182                 goto unlock;
3183
3184         target_hdr = to_uvcg_streaming_header(target);
3185         --target_hdr->linked;
3186         kfree(**class_array);
3187         kfree(*class_array);
3188         *class_array = NULL;
3189
3190 unlock:
3191         mutex_unlock(&opts->lock);
3192 out:
3193         config_item_put(header);
3194         mutex_unlock(su_mutex);
3195 }
3196
3197 static struct configfs_item_operations uvcg_streaming_class_item_ops = {
3198         .release        = uvcg_config_item_release,
3199         .allow_link     = uvcg_streaming_class_allow_link,
3200         .drop_link      = uvcg_streaming_class_drop_link,
3201 };
3202
3203 static const struct config_item_type uvcg_streaming_class_type = {
3204         .ct_item_ops    = &uvcg_streaming_class_item_ops,
3205         .ct_owner       = THIS_MODULE,
3206 };
3207
3208 /* -----------------------------------------------------------------------------
3209  * streaming/class
3210  */
3211
3212 static int uvcg_streaming_class_create_children(struct config_group *parent)
3213 {
3214         static const char * const names[] = { "fs", "hs", "ss" };
3215         unsigned int i;
3216
3217         for (i = 0; i < ARRAY_SIZE(names); ++i) {
3218                 struct uvcg_streaming_class_group *group;
3219
3220                 group = kzalloc(sizeof(*group), GFP_KERNEL);
3221                 if (!group)
3222                         return -ENOMEM;
3223
3224                 group->name = names[i];
3225
3226                 config_group_init_type_name(&group->group, group->name,
3227                                             &uvcg_streaming_class_type);
3228                 configfs_add_default_group(&group->group, parent);
3229         }
3230
3231         return 0;
3232 }
3233
3234 static const struct uvcg_config_group_type uvcg_streaming_class_grp_type = {
3235         .type = {
3236                 .ct_item_ops    = &uvcg_config_item_ops,
3237                 .ct_owner       = THIS_MODULE,
3238         },
3239         .name = "class",
3240         .create_children = uvcg_streaming_class_create_children,
3241 };
3242
3243 /* -----------------------------------------------------------------------------
3244  * streaming
3245  */
3246
3247 static ssize_t uvcg_default_streaming_b_interface_number_show(
3248         struct config_item *item, char *page)
3249 {
3250         struct config_group *group = to_config_group(item);
3251         struct mutex *su_mutex = &group->cg_subsys->su_mutex;
3252         struct config_item *opts_item;
3253         struct f_uvc_opts *opts;
3254         int result = 0;
3255
3256         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
3257
3258         opts_item = item->ci_parent;
3259         opts = to_f_uvc_opts(opts_item);
3260
3261         mutex_lock(&opts->lock);
3262         result += sprintf(page, "%u\n", opts->streaming_interface);
3263         mutex_unlock(&opts->lock);
3264
3265         mutex_unlock(su_mutex);
3266
3267         return result;
3268 }
3269
3270 UVC_ATTR_RO(uvcg_default_streaming_, b_interface_number, bInterfaceNumber);
3271
3272 static struct configfs_attribute *uvcg_default_streaming_attrs[] = {
3273         &uvcg_default_streaming_attr_b_interface_number,
3274         NULL,
3275 };
3276
3277 static const struct uvcg_config_group_type uvcg_streaming_grp_type = {
3278         .type = {
3279                 .ct_item_ops    = &uvcg_config_item_ops,
3280                 .ct_attrs       = uvcg_default_streaming_attrs,
3281                 .ct_owner       = THIS_MODULE,
3282         },
3283         .name = "streaming",
3284         .children = (const struct uvcg_config_group_type*[]) {
3285                 &uvcg_streaming_header_grp_type,
3286                 &uvcg_uncompressed_grp_type,
3287                 &uvcg_mjpeg_grp_type,
3288                 &uvcg_color_matching_grp_type,
3289                 &uvcg_streaming_class_grp_type,
3290                 NULL,
3291         },
3292 };
3293
3294 /* -----------------------------------------------------------------------------
3295  * UVC function
3296  */
3297
3298 static void uvc_func_item_release(struct config_item *item)
3299 {
3300         struct f_uvc_opts *opts = to_f_uvc_opts(item);
3301
3302         uvcg_config_remove_children(to_config_group(item));
3303         usb_put_function_instance(&opts->func_inst);
3304 }
3305
3306 static int uvc_func_allow_link(struct config_item *src, struct config_item *tgt)
3307 {
3308         struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
3309         struct gadget_string *string;
3310         struct config_item *strings;
3311         struct f_uvc_opts *opts;
3312         int ret = 0;
3313
3314         mutex_lock(su_mutex); /* for navigating configfs hierarchy */
3315
3316         /* Validate that the target is an entry in strings/<langid> */
3317         strings = config_group_find_item(to_config_group(src->ci_parent->ci_parent),
3318                                          "strings");
3319         if (!strings || tgt->ci_parent->ci_parent != strings) {
3320                 ret = -EINVAL;
3321                 goto put_strings;
3322         }
3323
3324         string = to_gadget_string(tgt);
3325
3326         opts = to_f_uvc_opts(src);
3327         mutex_lock(&opts->lock);
3328
3329         if (!strcmp(tgt->ci_name, "iad_desc"))
3330                 opts->iad_index = string->usb_string.id;
3331         else if (!strcmp(tgt->ci_name, "vs0_desc"))
3332                 opts->vs0_index = string->usb_string.id;
3333         else if (!strcmp(tgt->ci_name, "vs1_desc"))
3334                 opts->vs1_index = string->usb_string.id;
3335         else
3336                 ret = -EINVAL;
3337
3338         mutex_unlock(&opts->lock);
3339
3340 put_strings:
3341         config_item_put(strings);
3342         mutex_unlock(su_mutex);
3343
3344         return ret;
3345 }
3346
3347 static void uvc_func_drop_link(struct config_item *src, struct config_item *tgt)
3348 {
3349         struct f_uvc_opts *opts;
3350
3351         opts = to_f_uvc_opts(src);
3352         mutex_lock(&opts->lock);
3353
3354         if (!strcmp(tgt->ci_name, "iad_desc"))
3355                 opts->iad_index = 0;
3356         else if (!strcmp(tgt->ci_name, "vs0_desc"))
3357                 opts->vs0_index = 0;
3358         else if (!strcmp(tgt->ci_name, "vs1_desc"))
3359                 opts->vs1_index = 0;
3360
3361         mutex_unlock(&opts->lock);
3362 }
3363
3364 static struct configfs_item_operations uvc_func_item_ops = {
3365         .release        = uvc_func_item_release,
3366         .allow_link     = uvc_func_allow_link,
3367         .drop_link      = uvc_func_drop_link,
3368 };
3369
3370 #define UVCG_OPTS_ATTR(cname, aname, limit)                             \
3371 static ssize_t f_uvc_opts_##cname##_show(                               \
3372         struct config_item *item, char *page)                           \
3373 {                                                                       \
3374         struct f_uvc_opts *opts = to_f_uvc_opts(item);                  \
3375         int result;                                                     \
3376                                                                         \
3377         mutex_lock(&opts->lock);                                        \
3378         result = sprintf(page, "%u\n", opts->cname);                    \
3379         mutex_unlock(&opts->lock);                                      \
3380                                                                         \
3381         return result;                                                  \
3382 }                                                                       \
3383                                                                         \
3384 static ssize_t                                                          \
3385 f_uvc_opts_##cname##_store(struct config_item *item,                    \
3386                            const char *page, size_t len)                \
3387 {                                                                       \
3388         struct f_uvc_opts *opts = to_f_uvc_opts(item);                  \
3389         unsigned int num;                                               \
3390         int ret;                                                        \
3391                                                                         \
3392         mutex_lock(&opts->lock);                                        \
3393         if (opts->refcnt) {                                             \
3394                 ret = -EBUSY;                                           \
3395                 goto end;                                               \
3396         }                                                               \
3397                                                                         \
3398         ret = kstrtouint(page, 0, &num);                                \
3399         if (ret)                                                        \
3400                 goto end;                                               \
3401                                                                         \
3402         if (num > limit) {                                              \
3403                 ret = -EINVAL;                                          \
3404                 goto end;                                               \
3405         }                                                               \
3406         opts->cname = num;                                              \
3407         ret = len;                                                      \
3408 end:                                                                    \
3409         mutex_unlock(&opts->lock);                                      \
3410         return ret;                                                     \
3411 }                                                                       \
3412                                                                         \
3413 UVC_ATTR(f_uvc_opts_, cname, cname)
3414
3415 UVCG_OPTS_ATTR(streaming_interval, streaming_interval, 16);
3416 UVCG_OPTS_ATTR(streaming_maxpacket, streaming_maxpacket, 3072);
3417 UVCG_OPTS_ATTR(streaming_maxburst, streaming_maxburst, 15);
3418
3419 #undef UVCG_OPTS_ATTR
3420
3421 #define UVCG_OPTS_STRING_ATTR(cname, aname)                             \
3422 static ssize_t f_uvc_opts_string_##cname##_show(struct config_item *item,\
3423                                          char *page)                    \
3424 {                                                                       \
3425         struct f_uvc_opts *opts = to_f_uvc_opts(item);                  \
3426         int result;                                                     \
3427                                                                         \
3428         mutex_lock(&opts->lock);                                        \
3429         result = scnprintf(page, sizeof(opts->aname), "%s", opts->aname);\
3430         mutex_unlock(&opts->lock);                                      \
3431                                                                         \
3432         return result;                                                  \
3433 }                                                                       \
3434                                                                         \
3435 static ssize_t f_uvc_opts_string_##cname##_store(struct config_item *item,\
3436                                           const char *page, size_t len) \
3437 {                                                                       \
3438         struct f_uvc_opts *opts = to_f_uvc_opts(item);                  \
3439         int size = min(sizeof(opts->aname), len + 1);                   \
3440         int ret = 0;                                                    \
3441                                                                         \
3442         mutex_lock(&opts->lock);                                        \
3443         if (opts->refcnt) {                                             \
3444                 ret = -EBUSY;                                           \
3445                 goto end;                                               \
3446         }                                                               \
3447                                                                         \
3448         ret = strscpy(opts->aname, page, size);                         \
3449         if (ret == -E2BIG)                                              \
3450                 ret = size - 1;                                         \
3451                                                                         \
3452 end:                                                                    \
3453         mutex_unlock(&opts->lock);                                      \
3454         return ret;                                                     \
3455 }                                                                       \
3456                                                                         \
3457 UVC_ATTR(f_uvc_opts_string_, cname, aname)
3458
3459 UVCG_OPTS_STRING_ATTR(function_name, function_name);
3460
3461 #undef UVCG_OPTS_STRING_ATTR
3462
3463 static struct configfs_attribute *uvc_attrs[] = {
3464         &f_uvc_opts_attr_streaming_interval,
3465         &f_uvc_opts_attr_streaming_maxpacket,
3466         &f_uvc_opts_attr_streaming_maxburst,
3467         &f_uvc_opts_string_attr_function_name,
3468         NULL,
3469 };
3470
3471 static const struct uvcg_config_group_type uvc_func_type = {
3472         .type = {
3473                 .ct_item_ops    = &uvc_func_item_ops,
3474                 .ct_attrs       = uvc_attrs,
3475                 .ct_owner       = THIS_MODULE,
3476         },
3477         .name = "",
3478         .children = (const struct uvcg_config_group_type*[]) {
3479                 &uvcg_control_grp_type,
3480                 &uvcg_streaming_grp_type,
3481                 NULL,
3482         },
3483 };
3484
3485 int uvcg_attach_configfs(struct f_uvc_opts *opts)
3486 {
3487         int ret;
3488
3489         config_group_init_type_name(&opts->func_inst.group, uvc_func_type.name,
3490                                     &uvc_func_type.type);
3491
3492         ret = uvcg_config_create_children(&opts->func_inst.group,
3493                                           &uvc_func_type);
3494         if (ret < 0)
3495                 config_group_put(&opts->func_inst.group);
3496
3497         return ret;
3498 }