drivers/usb/gadget/function/uvc_configfs.c

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