Quelle  uvc_configfs.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * uvc_configfs.c
 *
 * Configfs support for the uvc function.
 *
 * Copyright (c) 2014 Samsung Electronics Co., Ltd.
 * http://www.samsung.com
 *
 * Author: Andrzej Pietrasiewicz <andrzejtp2010@gmail.com>
 */

#include "uvc_configfs.h"

#include <linux/sort.h>
#include <linux/usb/uvc.h>
#include <linux/usb/video.h>

/* -----------------------------------------------------------------------------
 * Global Utility Structures and Macros
 */

#define UVC_ATTR(prefix, cname, aname) \
static struct configfs_attribute prefix##attr_##cname = { \
 .ca_name = __stringify(aname),    \
 .ca_mode = S_IRUGO | S_IWUGO,    \
 .ca_owner = THIS_MODULE,     \
 .show  = prefix##cname##_show,    \
 .store  = prefix##cname##_store,   \
}

#define UVC_ATTR_RO(prefix, cname, aname) \
static struct configfs_attribute prefix##attr_##cname = { \
 .ca_name = __stringify(aname),    \
 .ca_mode = S_IRUGO,     \
 .ca_owner = THIS_MODULE,     \
 .show  = prefix##cname##_show,    \
}

#define le8_to_cpu(x) (x)
#define cpu_to_le8(x) (x)

static int uvcg_config_compare_u32(const void *l, const void *r)
{
 u32 li = *(const u32 *)l;
 u32 ri = *(const u32 *)r;

 return li < ri ? -1 : li == ri ? 0 : 1;
}

static inline int __uvcg_count_item_entries(char *buf, void *priv, unsigned int size)
{
 ++*((int *)priv);
 return 0;
}

static inline int __uvcg_fill_item_entries(char *buf, void *priv, unsigned int size)
{
 unsigned int num;
 u8 **values;
 int ret;

 ret = kstrtouint(buf, 0, &num);
 if (ret)
  return ret;

 if (num != (num & GENMASK((size * 8) - 1, 0)))
  return -ERANGE;

 values = priv;
 memcpy(*values, &num, size);
 *values += size;

 return 0;
}

static int __uvcg_iter_item_entries(const char *page, size_t len,
        int (*fun)(char *, void *, unsigned int),
        void *priv, unsigned int size)
{
 /* sign, base 2 representation, newline, terminator */
 unsigned int bufsize = 1 + size * 8 + 1 + 1;
 const char *pg = page;
 int i, ret = 0;
 char *buf;

 if (!fun)
  return -EINVAL;

 buf = kzalloc(bufsize, GFP_KERNEL);
 if (!buf)
  return -ENOMEM;

 while (pg - page < len) {
  i = 0;
  while (i < bufsize && (pg - page < len) &&
         *pg != '\0' && *pg != '\n')
   buf[i++] = *pg++;
  if (i == bufsize) {
   ret = -EINVAL;
   goto out_free_buf;
  }
  while ((pg - page < len) && (*pg == '\0' || *pg == '\n'))
   ++pg;
  buf[i] = '\0';
  ret = fun(buf, priv, size);
  if (ret)
   goto out_free_buf;
 }

out_free_buf:
 kfree(buf);
 return ret;
}

struct uvcg_config_group_type {
 struct config_item_type type;
 const char *name;
 const struct uvcg_config_group_type **children;
 int (*create_children)(struct config_group *group);
};

static void uvcg_config_item_release(struct config_item *item)
{
 struct config_group *group = to_config_group(item);

 kfree(group);
}

static struct configfs_item_operations uvcg_config_item_ops = {
 .release = uvcg_config_item_release,
};

static int uvcg_config_create_group(struct config_group *parent,
        const struct uvcg_config_group_type *type);

static int uvcg_config_create_children(struct config_group *group,
    const struct uvcg_config_group_type *type)
{
 const struct uvcg_config_group_type **child;
 int ret;

 if (type->create_children)
  return type->create_children(group);

 for (child = type->children; child && *child; ++child) {
  ret = uvcg_config_create_group(group, *child);
  if (ret < 0)
   return ret;
 }

 return 0;
}

static int uvcg_config_create_group(struct config_group *parent,
        const struct uvcg_config_group_type *type)
{
 struct config_group *group;

 group = kzalloc(sizeof(*group), GFP_KERNEL);
 if (!group)
  return -ENOMEM;

 config_group_init_type_name(group, type->name, &type->type);
 configfs_add_default_group(group, parent);

 return uvcg_config_create_children(group, type);
}

static void uvcg_config_remove_children(struct config_group *group)
{
 struct config_group *child, *n;

 list_for_each_entry_safe(child, n, &group->default_groups, group_entry) {
  list_del(&child->group_entry);
  uvcg_config_remove_children(child);
  config_item_put(&child->cg_item);
 }
}

/* -----------------------------------------------------------------------------
 * control/header/<NAME>
 * control/header
 */

#define UVCG_CTRL_HDR_ATTR(cname, aname, bits, limit)   \
static ssize_t uvcg_control_header_##cname##_show(   \
 struct config_item *item, char *page)    \
{         \
 struct uvcg_control_header *ch = to_uvcg_control_header(item); \
 struct f_uvc_opts *opts;     \
 struct config_item *opts_item;     \
 struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;\
 int result;       \
         \
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
         \
 opts_item = ch->item.ci_parent->ci_parent->ci_parent;  \
 opts = to_f_uvc_opts(opts_item);    \
         \
 mutex_lock(&opts->lock);     \
 result = sprintf(page, "%u\n", le##bits##_to_cpu(ch->desc.aname));\
 mutex_unlock(&opts->lock);     \
         \
 mutex_unlock(su_mutex);      \
 return result;       \
}         \
         \
static ssize_t        \
uvcg_control_header_##cname##_store(struct config_item *item,  \
      const char *page, size_t len)  \
{         \
 struct uvcg_control_header *ch = to_uvcg_control_header(item); \
 struct f_uvc_opts *opts;     \
 struct config_item *opts_item;     \
 struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;\
 int ret;       \
 u##bits num;       \
         \
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
         \
 opts_item = ch->item.ci_parent->ci_parent->ci_parent;  \
 opts = to_f_uvc_opts(opts_item);    \
         \
 mutex_lock(&opts->lock);     \
 if (ch->linked || opts->refcnt) {    \
  ret = -EBUSY;      \
  goto end;      \
 }        \
         \
 ret = kstrtou##bits(page, 0, &num);    \
 if (ret)       \
  goto end;      \
         \
 if (num > limit) {      \
  ret = -EINVAL;      \
  goto end;      \
 }        \
 ch->desc.aname = cpu_to_le##bits(num);    \
 ret = len;       \
end:         \
 mutex_unlock(&opts->lock);     \
 mutex_unlock(su_mutex);      \
 return ret;       \
}         \
         \
UVC_ATTR(uvcg_control_header_, cname, aname)

UVCG_CTRL_HDR_ATTR(bcd_uvc, bcdUVC, 16, 0xffff);

UVCG_CTRL_HDR_ATTR(dw_clock_frequency, dwClockFrequency, 32, 0x7fffffff);

#undef UVCG_CTRL_HDR_ATTR

static struct configfs_attribute *uvcg_control_header_attrs[] = {
 &uvcg_control_header_attr_bcd_uvc,
 &uvcg_control_header_attr_dw_clock_frequency,
 NULL,
};

static const struct config_item_type uvcg_control_header_type = {
 .ct_item_ops = &uvcg_config_item_ops,
 .ct_attrs = uvcg_control_header_attrs,
 .ct_owner = THIS_MODULE,
};

static struct config_item *uvcg_control_header_make(struct config_group *group,
          const char *name)
{
 struct uvcg_control_header *h;

 h = kzalloc(sizeof(*h), GFP_KERNEL);
 if (!h)
  return ERR_PTR(-ENOMEM);

 h->desc.bLength   = UVC_DT_HEADER_SIZE(1);
 h->desc.bDescriptorType  = USB_DT_CS_INTERFACE;
 h->desc.bDescriptorSubType = UVC_VC_HEADER;
 h->desc.bcdUVC   = cpu_to_le16(0x0110);
 h->desc.dwClockFrequency = cpu_to_le32(48000000);

 config_item_init_type_name(&h->item, name, &uvcg_control_header_type);

 return &h->item;
}

static struct configfs_group_operations uvcg_control_header_grp_ops = {
 .make_item  = uvcg_control_header_make,
};

static const struct uvcg_config_group_type uvcg_control_header_grp_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_group_ops = &uvcg_control_header_grp_ops,
  .ct_owner = THIS_MODULE,
 },
 .name = "header",
};

/* -----------------------------------------------------------------------------
 * control/processing/default
 */

#define UVCG_DEFAULT_PROCESSING_ATTR(cname, aname, bits)  \
static ssize_t uvcg_default_processing_##cname##_show(   \
 struct config_item *item, char *page)    \
{         \
 struct config_group *group = to_config_group(item);  \
 struct f_uvc_opts *opts;     \
 struct config_item *opts_item;     \
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;  \
 struct uvc_processing_unit_descriptor *pd;   \
 int result;       \
         \
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
         \
 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent; \
 opts = to_f_uvc_opts(opts_item);    \
 pd = &opts->uvc_processing;     \
         \
 mutex_lock(&opts->lock);     \
 result = sprintf(page, "%u\n", le##bits##_to_cpu(pd->aname)); \
 mutex_unlock(&opts->lock);     \
         \
 mutex_unlock(su_mutex);      \
 return result;       \
}         \
         \
UVC_ATTR_RO(uvcg_default_processing_, cname, aname)

UVCG_DEFAULT_PROCESSING_ATTR(b_unit_id, bUnitID, 8);
UVCG_DEFAULT_PROCESSING_ATTR(b_source_id, bSourceID, 8);
UVCG_DEFAULT_PROCESSING_ATTR(w_max_multiplier, wMaxMultiplier, 16);
UVCG_DEFAULT_PROCESSING_ATTR(i_processing, iProcessing, 8);

#undef UVCG_DEFAULT_PROCESSING_ATTR

static ssize_t uvcg_default_processing_bm_controls_store(
 struct config_item *item, const char *page, size_t len)
{
 struct config_group *group = to_config_group(item);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvc_processing_unit_descriptor *pd;
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 u8 *bm_controls, *tmp;
 unsigned int i;
 int ret, n = 0;

 mutex_lock(su_mutex);

 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);
 pd = &opts->uvc_processing;

 mutex_lock(&opts->lock);
 if (opts->refcnt) {
  ret = -EBUSY;
  goto unlock;
 }

 ret = __uvcg_iter_item_entries(page, len, __uvcg_count_item_entries, &n,
           sizeof(u8));
 if (ret)
  goto unlock;

 if (n > pd->bControlSize) {
  ret = -EINVAL;
  goto unlock;
 }

 tmp = bm_controls = kcalloc(n, sizeof(u8), GFP_KERNEL);
 if (!bm_controls) {
  ret = -ENOMEM;
  goto unlock;
 }

 ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &tmp,
           sizeof(u8));
 if (ret)
  goto free_mem;

 for (i = 0; i < n; i++)
  pd->bmControls[i] = bm_controls[i];

 ret = len;

free_mem:
 kfree(bm_controls);
unlock:
 mutex_unlock(&opts->lock);
 mutex_unlock(su_mutex);
 return ret;
}

static ssize_t uvcg_default_processing_bm_controls_show(
 struct config_item *item, char *page)
{
 struct config_group *group = to_config_group(item);
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvc_processing_unit_descriptor *pd;
 int result, i;
 char *pg = page;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);
 pd = &opts->uvc_processing;

 mutex_lock(&opts->lock);
 for (result = 0, i = 0; i < pd->bControlSize; ++i) {
  result += sprintf(pg, "%u\n", pd->bmControls[i]);
  pg = page + result;
 }
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 return result;
}

UVC_ATTR(uvcg_default_processing_, bm_controls, bmControls);

static struct configfs_attribute *uvcg_default_processing_attrs[] = {
 &uvcg_default_processing_attr_b_unit_id,
 &uvcg_default_processing_attr_b_source_id,
 &uvcg_default_processing_attr_w_max_multiplier,
 &uvcg_default_processing_attr_bm_controls,
 &uvcg_default_processing_attr_i_processing,
 NULL,
};

static const struct uvcg_config_group_type uvcg_default_processing_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_attrs = uvcg_default_processing_attrs,
  .ct_owner = THIS_MODULE,
 },
 .name = "default",
};

/* -----------------------------------------------------------------------------
 * control/processing
 */

static const struct uvcg_config_group_type uvcg_processing_grp_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_owner = THIS_MODULE,
 },
 .name = "processing",
 .children = (const struct uvcg_config_group_type*[]) {
  &uvcg_default_processing_type,
  NULL,
 },
};

/* -----------------------------------------------------------------------------
 * control/terminal/camera/default
 */

#define UVCG_DEFAULT_CAMERA_ATTR(cname, aname, bits)   \
static ssize_t uvcg_default_camera_##cname##_show(   \
 struct config_item *item, char *page)    \
{         \
 struct config_group *group = to_config_group(item);  \
 struct f_uvc_opts *opts;     \
 struct config_item *opts_item;     \
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;  \
 struct uvc_camera_terminal_descriptor *cd;   \
 int result;       \
         \
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
         \
 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent-> \
   ci_parent;     \
 opts = to_f_uvc_opts(opts_item);    \
 cd = &opts->uvc_camera_terminal;    \
         \
 mutex_lock(&opts->lock);     \
 result = sprintf(page, "%u\n", le##bits##_to_cpu(cd->aname)); \
 mutex_unlock(&opts->lock);     \
         \
 mutex_unlock(su_mutex);      \
         \
 return result;       \
}         \
         \
UVC_ATTR_RO(uvcg_default_camera_, cname, aname)

UVCG_DEFAULT_CAMERA_ATTR(b_terminal_id, bTerminalID, 8);
UVCG_DEFAULT_CAMERA_ATTR(w_terminal_type, wTerminalType, 16);
UVCG_DEFAULT_CAMERA_ATTR(b_assoc_terminal, bAssocTerminal, 8);
UVCG_DEFAULT_CAMERA_ATTR(i_terminal, iTerminal, 8);
UVCG_DEFAULT_CAMERA_ATTR(w_objective_focal_length_min, wObjectiveFocalLengthMin,
    16);
UVCG_DEFAULT_CAMERA_ATTR(w_objective_focal_length_max, wObjectiveFocalLengthMax,
    16);
UVCG_DEFAULT_CAMERA_ATTR(w_ocular_focal_length, wOcularFocalLength,
    16);

#undef UVCG_DEFAULT_CAMERA_ATTR

static ssize_t uvcg_default_camera_bm_controls_store(
 struct config_item *item, const char *page, size_t len)
{
 struct config_group *group = to_config_group(item);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvc_camera_terminal_descriptor *cd;
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 u8 *bm_controls, *tmp;
 unsigned int i;
 int ret, n = 0;

 mutex_lock(su_mutex);

 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent->
   ci_parent;
 opts = to_f_uvc_opts(opts_item);
 cd = &opts->uvc_camera_terminal;

 mutex_lock(&opts->lock);
 if (opts->refcnt) {
  ret = -EBUSY;
  goto unlock;
 }

 ret = __uvcg_iter_item_entries(page, len, __uvcg_count_item_entries, &n,
           sizeof(u8));
 if (ret)
  goto unlock;

 if (n > cd->bControlSize) {
  ret = -EINVAL;
  goto unlock;
 }

 tmp = bm_controls = kcalloc(n, sizeof(u8), GFP_KERNEL);
 if (!bm_controls) {
  ret = -ENOMEM;
  goto unlock;
 }

 ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &tmp,
           sizeof(u8));
 if (ret)
  goto free_mem;

 for (i = 0; i < n; i++)
  cd->bmControls[i] = bm_controls[i];

 ret = len;

free_mem:
 kfree(bm_controls);
unlock:
 mutex_unlock(&opts->lock);
 mutex_unlock(su_mutex);
 return ret;
}

static ssize_t uvcg_default_camera_bm_controls_show(
 struct config_item *item, char *page)
{
 struct config_group *group = to_config_group(item);
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvc_camera_terminal_descriptor *cd;
 int result, i;
 char *pg = page;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent->
   ci_parent;
 opts = to_f_uvc_opts(opts_item);
 cd = &opts->uvc_camera_terminal;

 mutex_lock(&opts->lock);
 for (result = 0, i = 0; i < cd->bControlSize; ++i) {
  result += sprintf(pg, "%u\n", cd->bmControls[i]);
  pg = page + result;
 }
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);
 return result;
}

UVC_ATTR(uvcg_default_camera_, bm_controls, bmControls);

static struct configfs_attribute *uvcg_default_camera_attrs[] = {
 &uvcg_default_camera_attr_b_terminal_id,
 &uvcg_default_camera_attr_w_terminal_type,
 &uvcg_default_camera_attr_b_assoc_terminal,
 &uvcg_default_camera_attr_i_terminal,
 &uvcg_default_camera_attr_w_objective_focal_length_min,
 &uvcg_default_camera_attr_w_objective_focal_length_max,
 &uvcg_default_camera_attr_w_ocular_focal_length,
 &uvcg_default_camera_attr_bm_controls,
 NULL,
};

static const struct uvcg_config_group_type uvcg_default_camera_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_attrs = uvcg_default_camera_attrs,
  .ct_owner = THIS_MODULE,
 },
 .name = "default",
};

/* -----------------------------------------------------------------------------
 * control/terminal/camera
 */

static const struct uvcg_config_group_type uvcg_camera_grp_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_owner = THIS_MODULE,
 },
 .name = "camera",
 .children = (const struct uvcg_config_group_type*[]) {
  &uvcg_default_camera_type,
  NULL,
 },
};

/* -----------------------------------------------------------------------------
 * control/terminal/output/default
 */

#define UVCG_DEFAULT_OUTPUT_ATTR(cname, aname, bits)   \
static ssize_t uvcg_default_output_##cname##_show(   \
 struct config_item *item, char *page)    \
{         \
 struct config_group *group = to_config_group(item);  \
 struct f_uvc_opts *opts;     \
 struct config_item *opts_item;     \
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;  \
 struct uvc_output_terminal_descriptor *cd;   \
 int result;       \
         \
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
         \
 opts_item = group->cg_item.ci_parent->ci_parent->  \
   ci_parent->ci_parent;    \
 opts = to_f_uvc_opts(opts_item);    \
 cd = &opts->uvc_output_terminal;    \
         \
 mutex_lock(&opts->lock);     \
 result = sprintf(page, "%u\n", le##bits##_to_cpu(cd->aname)); \
 mutex_unlock(&opts->lock);     \
         \
 mutex_unlock(su_mutex);      \
         \
 return result;       \
}         \
         \
UVC_ATTR_RO(uvcg_default_output_, cname, aname)

UVCG_DEFAULT_OUTPUT_ATTR(b_terminal_id, bTerminalID, 8);
UVCG_DEFAULT_OUTPUT_ATTR(w_terminal_type, wTerminalType, 16);
UVCG_DEFAULT_OUTPUT_ATTR(b_assoc_terminal, bAssocTerminal, 8);
UVCG_DEFAULT_OUTPUT_ATTR(i_terminal, iTerminal, 8);

#undef UVCG_DEFAULT_OUTPUT_ATTR

static ssize_t uvcg_default_output_b_source_id_show(struct config_item *item,
          char *page)
{
 struct config_group *group = to_config_group(item);
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvc_output_terminal_descriptor *cd;
 int result;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = group->cg_item.ci_parent->ci_parent->
   ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);
 cd = &opts->uvc_output_terminal;

 mutex_lock(&opts->lock);
 result = sprintf(page, "%u\n", le8_to_cpu(cd->bSourceID));
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 return result;
}

static ssize_t uvcg_default_output_b_source_id_store(struct config_item *item,
           const char *page, size_t len)
{
 struct config_group *group = to_config_group(item);
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvc_output_terminal_descriptor *cd;
 int result;
 u8 num;

 result = kstrtou8(page, 0, &num);
 if (result)
  return result;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = group->cg_item.ci_parent->ci_parent->
   ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);
 cd = &opts->uvc_output_terminal;

 mutex_lock(&opts->lock);
 cd->bSourceID = num;
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 return len;
}
UVC_ATTR(uvcg_default_output_, b_source_id, bSourceID);

static struct configfs_attribute *uvcg_default_output_attrs[] = {
 &uvcg_default_output_attr_b_terminal_id,
 &uvcg_default_output_attr_w_terminal_type,
 &uvcg_default_output_attr_b_assoc_terminal,
 &uvcg_default_output_attr_b_source_id,
 &uvcg_default_output_attr_i_terminal,
 NULL,
};

static const struct uvcg_config_group_type uvcg_default_output_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_attrs = uvcg_default_output_attrs,
  .ct_owner = THIS_MODULE,
 },
 .name = "default",
};

/* -----------------------------------------------------------------------------
 * control/terminal/output
 */

static const struct uvcg_config_group_type uvcg_output_grp_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_owner = THIS_MODULE,
 },
 .name = "output",
 .children = (const struct uvcg_config_group_type*[]) {
  &uvcg_default_output_type,
  NULL,
 },
};

/* -----------------------------------------------------------------------------
 * control/terminal
 */

static const struct uvcg_config_group_type uvcg_terminal_grp_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_owner = THIS_MODULE,
 },
 .name = "terminal",
 .children = (const struct uvcg_config_group_type*[]) {
  &uvcg_camera_grp_type,
  &uvcg_output_grp_type,
  NULL,
 },
};

/* -----------------------------------------------------------------------------
 * control/extensions
 */

#define UVCG_EXTENSION_ATTR(cname, aname, ro...)   \
static ssize_t uvcg_extension_##cname##_show(struct config_item *item, \
          char *page)  \
{         \
 struct config_group *group = to_config_group(item->ci_parent); \
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;  \
 struct uvcg_extension *xu = to_uvcg_extension(item);  \
 struct config_item *opts_item;     \
 struct f_uvc_opts *opts;     \
 int ret;       \
         \
 mutex_lock(su_mutex);      \
         \
 opts_item = item->ci_parent->ci_parent->ci_parent;  \
 opts = to_f_uvc_opts(opts_item);    \
         \
 mutex_lock(&opts->lock);     \
 ret = sprintf(page, "%u\n", xu->desc.aname);   \
 mutex_unlock(&opts->lock);     \
         \
 mutex_unlock(su_mutex);      \
         \
 return ret;       \
}         \
UVC_ATTR##ro(uvcg_extension_, cname, aname)

UVCG_EXTENSION_ATTR(b_length, bLength, _RO);
UVCG_EXTENSION_ATTR(b_unit_id, bUnitID, _RO);
UVCG_EXTENSION_ATTR(i_extension, iExtension, _RO);

static ssize_t uvcg_extension_b_num_controls_store(struct config_item *item,
         const char *page, size_t len)
{
 struct config_group *group = to_config_group(item->ci_parent);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvcg_extension *xu = to_uvcg_extension(item);
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 int ret;
 u8 num;

 ret = kstrtou8(page, 0, &num);
 if (ret)
  return ret;

 mutex_lock(su_mutex);

 opts_item = item->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 xu->desc.bNumControls = num;
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 return len;
}
UVCG_EXTENSION_ATTR(b_num_controls, bNumControls);

/*
 * In addition to storing bNrInPins, this function needs to realloc the
 * memory for the baSourceID array and additionally expand bLength.
 */
static ssize_t uvcg_extension_b_nr_in_pins_store(struct config_item *item,
       const char *page, size_t len)
{
 struct config_group *group = to_config_group(item->ci_parent);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvcg_extension *xu = to_uvcg_extension(item);
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 void *tmp_buf;
 int ret;
 u8 num;

 ret = kstrtou8(page, 0, &num);
 if (ret)
  return ret;

 mutex_lock(su_mutex);

 opts_item = item->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);

 if (num == xu->desc.bNrInPins) {
  ret = len;
  goto unlock;
 }

 tmp_buf = krealloc_array(xu->desc.baSourceID, num, sizeof(u8),
     GFP_KERNEL | __GFP_ZERO);
 if (!tmp_buf) {
  ret = -ENOMEM;
  goto unlock;
 }

 xu->desc.baSourceID = tmp_buf;
 xu->desc.bNrInPins = num;
 xu->desc.bLength = UVC_DT_EXTENSION_UNIT_SIZE(xu->desc.bNrInPins,
            xu->desc.bControlSize);

 ret = len;

unlock:
 mutex_unlock(&opts->lock);
 mutex_unlock(su_mutex);
 return ret;
}
UVCG_EXTENSION_ATTR(b_nr_in_pins, bNrInPins);

/*
 * In addition to storing bControlSize, this function needs to realloc the
 * memory for the bmControls array and additionally expand bLength.
 */
static ssize_t uvcg_extension_b_control_size_store(struct config_item *item,
         const char *page, size_t len)
{
 struct config_group *group = to_config_group(item->ci_parent);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvcg_extension *xu = to_uvcg_extension(item);
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 void *tmp_buf;
 int ret;
 u8 num;

 ret = kstrtou8(page, 0, &num);
 if (ret)
  return ret;

 mutex_lock(su_mutex);

 opts_item = item->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);

 if (num == xu->desc.bControlSize) {
  ret = len;
  goto unlock;
 }

 tmp_buf = krealloc_array(xu->desc.bmControls, num, sizeof(u8),
     GFP_KERNEL | __GFP_ZERO);
 if (!tmp_buf) {
  ret = -ENOMEM;
  goto unlock;
 }

 xu->desc.bmControls = tmp_buf;
 xu->desc.bControlSize = num;
 xu->desc.bLength = UVC_DT_EXTENSION_UNIT_SIZE(xu->desc.bNrInPins,
            xu->desc.bControlSize);

 ret = len;

unlock:
 mutex_unlock(&opts->lock);
 mutex_unlock(su_mutex);
 return ret;
}

UVCG_EXTENSION_ATTR(b_control_size, bControlSize);

static ssize_t uvcg_extension_guid_extension_code_show(struct config_item *item,
             char *page)
{
 struct config_group *group = to_config_group(item->ci_parent);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvcg_extension *xu = to_uvcg_extension(item);
 struct config_item *opts_item;
 struct f_uvc_opts *opts;

 mutex_lock(su_mutex);

 opts_item = item->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 memcpy(page, xu->desc.guidExtensionCode, sizeof(xu->desc.guidExtensionCode));
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 return sizeof(xu->desc.guidExtensionCode);
}

static ssize_t uvcg_extension_guid_extension_code_store(struct config_item *item,
       const char *page, size_t len)
{
 struct config_group *group = to_config_group(item->ci_parent);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvcg_extension *xu = to_uvcg_extension(item);
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 int ret;

 mutex_lock(su_mutex);

 opts_item = item->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 memcpy(xu->desc.guidExtensionCode, page,
        min(sizeof(xu->desc.guidExtensionCode), len));
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 ret = sizeof(xu->desc.guidExtensionCode);

 return ret;
}

UVC_ATTR(uvcg_extension_, guid_extension_code, guidExtensionCode);

static ssize_t uvcg_extension_ba_source_id_show(struct config_item *item,
      char *page)
{
 struct config_group *group = to_config_group(item->ci_parent);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvcg_extension *xu = to_uvcg_extension(item);
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 char *pg = page;
 int ret, i;

 mutex_lock(su_mutex);

 opts_item = item->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 for (ret = 0, i = 0; i < xu->desc.bNrInPins; ++i) {
  ret += sprintf(pg, "%u\n", xu->desc.baSourceID[i]);
  pg = page + ret;
 }
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 return ret;
}

static ssize_t uvcg_extension_ba_source_id_store(struct config_item *item,
       const char *page, size_t len)
{
 struct config_group *group = to_config_group(item->ci_parent);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvcg_extension *xu = to_uvcg_extension(item);
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 u8 *source_ids, *iter;
 int ret, n = 0;

 mutex_lock(su_mutex);

 opts_item = item->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);

 ret = __uvcg_iter_item_entries(page, len, __uvcg_count_item_entries, &n,
           sizeof(u8));
 if (ret)
  goto unlock;

 iter = source_ids = kcalloc(n, sizeof(u8), GFP_KERNEL);
 if (!source_ids) {
  ret = -ENOMEM;
  goto unlock;
 }

 ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &iter,
           sizeof(u8));
 if (ret) {
  kfree(source_ids);
  goto unlock;
 }

 kfree(xu->desc.baSourceID);
 xu->desc.baSourceID = source_ids;
 xu->desc.bNrInPins = n;
 xu->desc.bLength = UVC_DT_EXTENSION_UNIT_SIZE(xu->desc.bNrInPins,
            xu->desc.bControlSize);

 ret = len;

unlock:
 mutex_unlock(&opts->lock);
 mutex_unlock(su_mutex);
 return ret;
}
UVC_ATTR(uvcg_extension_, ba_source_id, baSourceID);

static ssize_t uvcg_extension_bm_controls_show(struct config_item *item,
            char *page)
{
 struct config_group *group = to_config_group(item->ci_parent);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvcg_extension *xu = to_uvcg_extension(item);
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 char *pg = page;
 int ret, i;

 mutex_lock(su_mutex);

 opts_item = item->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 for (ret = 0, i = 0; i < xu->desc.bControlSize; ++i) {
  ret += sprintf(pg, "0x%02x\n", xu->desc.bmControls[i]);
  pg = page + ret;
 }
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 return ret;
}

static ssize_t uvcg_extension_bm_controls_store(struct config_item *item,
      const char *page, size_t len)
{
 struct config_group *group = to_config_group(item->ci_parent);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct uvcg_extension *xu = to_uvcg_extension(item);
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 u8 *bm_controls, *iter;
 int ret, n = 0;

 mutex_lock(su_mutex);

 opts_item = item->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);

 ret = __uvcg_iter_item_entries(page, len, __uvcg_count_item_entries, &n,
           sizeof(u8));
 if (ret)
  goto unlock;

 iter = bm_controls = kcalloc(n, sizeof(u8), GFP_KERNEL);
 if (!bm_controls) {
  ret = -ENOMEM;
  goto unlock;
 }

 ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &iter,
           sizeof(u8));
 if (ret) {
  kfree(bm_controls);
  goto unlock;
 }

 kfree(xu->desc.bmControls);
 xu->desc.bmControls = bm_controls;
 xu->desc.bControlSize = n;
 xu->desc.bLength = UVC_DT_EXTENSION_UNIT_SIZE(xu->desc.bNrInPins,
            xu->desc.bControlSize);

 ret = len;

unlock:
 mutex_unlock(&opts->lock);
 mutex_unlock(su_mutex);
 return ret;
}

UVC_ATTR(uvcg_extension_, bm_controls, bmControls);

static struct configfs_attribute *uvcg_extension_attrs[] = {
 &uvcg_extension_attr_b_length,
 &uvcg_extension_attr_b_unit_id,
 &uvcg_extension_attr_b_num_controls,
 &uvcg_extension_attr_b_nr_in_pins,
 &uvcg_extension_attr_b_control_size,
 &uvcg_extension_attr_guid_extension_code,
 &uvcg_extension_attr_ba_source_id,
 &uvcg_extension_attr_bm_controls,
 &uvcg_extension_attr_i_extension,
 NULL,
};

static void uvcg_extension_release(struct config_item *item)
{
 struct uvcg_extension *xu = container_of(item, struct uvcg_extension, item);

 kfree(xu);
}

static int uvcg_extension_allow_link(struct config_item *src, struct config_item *tgt)
{
 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 struct uvcg_extension *xu = to_uvcg_extension(src);
 struct config_item *gadget_item;
 struct gadget_string *string;
 struct config_item *strings;
 int ret = 0;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 /* Validate that the target of the link is an entry in strings/<langid> */
 gadget_item = src->ci_parent->ci_parent->ci_parent->ci_parent->ci_parent;
 strings = config_group_find_item(to_config_group(gadget_item), "strings");
 if (!strings || tgt->ci_parent->ci_parent != strings) {
  ret = -EINVAL;
  goto put_strings;
 }

 string = to_gadget_string(tgt);
 xu->string_descriptor_index = string->usb_string.id;

put_strings:
 config_item_put(strings);
 mutex_unlock(su_mutex);

 return ret;
}

static void uvcg_extension_drop_link(struct config_item *src, struct config_item *tgt)
{
 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 struct uvcg_extension *xu = to_uvcg_extension(src);
 struct config_item *opts_item;
 struct f_uvc_opts *opts;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = src->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);

 xu->string_descriptor_index = 0;

 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);
}

static struct configfs_item_operations uvcg_extension_item_ops = {
 .release = uvcg_extension_release,
 .allow_link = uvcg_extension_allow_link,
 .drop_link = uvcg_extension_drop_link,
};

static const struct config_item_type uvcg_extension_type = {
 .ct_item_ops = &uvcg_extension_item_ops,
 .ct_attrs = uvcg_extension_attrs,
 .ct_owner = THIS_MODULE,
};

static void uvcg_extension_drop(struct config_group *group, struct config_item *item)
{
 struct uvcg_extension *xu = container_of(item, struct uvcg_extension, item);
 struct config_item *opts_item;
 struct f_uvc_opts *opts;

 opts_item = group->cg_item.ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);

 config_item_put(item);
 list_del(&xu->list);
 kfree(xu->desc.baSourceID);
 kfree(xu->desc.bmControls);

 mutex_unlock(&opts->lock);
}

static struct config_item *uvcg_extension_make(struct config_group *group, const char *name)
{
 struct config_item *opts_item;
 struct uvcg_extension *xu;
 struct f_uvc_opts *opts;

 opts_item = group->cg_item.ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 xu = kzalloc(sizeof(*xu), GFP_KERNEL);
 if (!xu)
  return ERR_PTR(-ENOMEM);

 xu->desc.bLength = UVC_DT_EXTENSION_UNIT_SIZE(0, 0);
 xu->desc.bDescriptorType = USB_DT_CS_INTERFACE;
 xu->desc.bDescriptorSubType = UVC_VC_EXTENSION_UNIT;
 xu->desc.bNumControls = 0;
 xu->desc.bNrInPins = 0;
 xu->desc.baSourceID = NULL;
 xu->desc.bControlSize = 0;
 xu->desc.bmControls = NULL;

 mutex_lock(&opts->lock);

 xu->desc.bUnitID = ++opts->last_unit_id;

 config_item_init_type_name(&xu->item, name, &uvcg_extension_type);
 list_add_tail(&xu->list, &opts->extension_units);

 mutex_unlock(&opts->lock);

 return &xu->item;
}

static struct configfs_group_operations uvcg_extensions_grp_ops = {
 .make_item = uvcg_extension_make,
 .drop_item = uvcg_extension_drop,
};

static const struct uvcg_config_group_type uvcg_extensions_grp_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_group_ops = &uvcg_extensions_grp_ops,
  .ct_owner = THIS_MODULE,
 },
 .name = "extensions",
};

/* -----------------------------------------------------------------------------
 * control/class/{fs|ss}
 */

struct uvcg_control_class_group {
 struct config_group group;
 const char *name;
};

static inline struct uvc_descriptor_header
**uvcg_get_ctl_class_arr(struct config_item *i, struct f_uvc_opts *o)
{
 struct uvcg_control_class_group *group =
  container_of(i, struct uvcg_control_class_group,
        group.cg_item);

 if (!strcmp(group->name, "fs"))
  return o->uvc_fs_control_cls;

 if (!strcmp(group->name, "ss"))
  return o->uvc_ss_control_cls;

 return NULL;
}

static int uvcg_control_class_allow_link(struct config_item *src,
      struct config_item *target)
{
 struct config_item *control, *header;
 struct f_uvc_opts *opts;
 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 struct uvc_descriptor_header **class_array;
 struct uvcg_control_header *target_hdr;
 int ret = -EINVAL;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 control = src->ci_parent->ci_parent;
 header = config_group_find_item(to_config_group(control), "header");
 if (!header || target->ci_parent != header)
  goto out;

 opts = to_f_uvc_opts(control->ci_parent);

 mutex_lock(&opts->lock);

 class_array = uvcg_get_ctl_class_arr(src, opts);
 if (!class_array)
  goto unlock;
 if (opts->refcnt || class_array[0]) {
  ret = -EBUSY;
  goto unlock;
 }

 target_hdr = to_uvcg_control_header(target);
 ++target_hdr->linked;
 class_array[0] = (struct uvc_descriptor_header *)&target_hdr->desc;
 ret = 0;

unlock:
 mutex_unlock(&opts->lock);
out:
 config_item_put(header);
 mutex_unlock(su_mutex);
 return ret;
}

static void uvcg_control_class_drop_link(struct config_item *src,
     struct config_item *target)
{
 struct config_item *control, *header;
 struct f_uvc_opts *opts;
 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 struct uvc_descriptor_header **class_array;
 struct uvcg_control_header *target_hdr;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 control = src->ci_parent->ci_parent;
 header = config_group_find_item(to_config_group(control), "header");
 if (!header || target->ci_parent != header)
  goto out;

 opts = to_f_uvc_opts(control->ci_parent);

 mutex_lock(&opts->lock);

 class_array = uvcg_get_ctl_class_arr(src, opts);
 if (!class_array || opts->refcnt)
  goto unlock;

 target_hdr = to_uvcg_control_header(target);
 --target_hdr->linked;
 class_array[0] = NULL;

unlock:
 mutex_unlock(&opts->lock);
out:
 config_item_put(header);
 mutex_unlock(su_mutex);
}

static struct configfs_item_operations uvcg_control_class_item_ops = {
 .release = uvcg_config_item_release,
 .allow_link = uvcg_control_class_allow_link,
 .drop_link = uvcg_control_class_drop_link,
};

static const struct config_item_type uvcg_control_class_type = {
 .ct_item_ops = &uvcg_control_class_item_ops,
 .ct_owner = THIS_MODULE,
};

/* -----------------------------------------------------------------------------
 * control/class
 */

static int uvcg_control_class_create_children(struct config_group *parent)
{
 static const char * const names[] = { "fs", "ss" };
 unsigned int i;

 for (i = 0; i < ARRAY_SIZE(names); ++i) {
  struct uvcg_control_class_group *group;

  group = kzalloc(sizeof(*group), GFP_KERNEL);
  if (!group)
   return -ENOMEM;

  group->name = names[i];

  config_group_init_type_name(&group->group, group->name,
         &uvcg_control_class_type);
  configfs_add_default_group(&group->group, parent);
 }

 return 0;
}

static const struct uvcg_config_group_type uvcg_control_class_grp_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_owner = THIS_MODULE,
 },
 .name = "class",
 .create_children = uvcg_control_class_create_children,
};

/* -----------------------------------------------------------------------------
 * control
 */

static ssize_t uvcg_default_control_b_interface_number_show(
 struct config_item *item, char *page)
{
 struct config_group *group = to_config_group(item);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 int result = 0;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = item->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 result += sprintf(page, "%u\n", opts->control_interface);
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 return result;
}

UVC_ATTR_RO(uvcg_default_control_, b_interface_number, bInterfaceNumber);

static ssize_t uvcg_default_control_enable_interrupt_ep_show(
 struct config_item *item, char *page)
{
 struct config_group *group = to_config_group(item);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 int result = 0;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = item->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 result += sprintf(page, "%u\n", opts->enable_interrupt_ep);
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 return result;
}

static ssize_t uvcg_default_control_enable_interrupt_ep_store(
 struct config_item *item, const char *page, size_t len)
{
 struct config_group *group = to_config_group(item);
 struct mutex *su_mutex = &group->cg_subsys->su_mutex;
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 ssize_t ret;
 u8 num;

 ret = kstrtou8(page, 0, &num);
 if (ret)
  return ret;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = item->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 opts->enable_interrupt_ep = num;
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 return len;
}
UVC_ATTR(uvcg_default_control_, enable_interrupt_ep, enable_interrupt_ep);

static struct configfs_attribute *uvcg_default_control_attrs[] = {
 &uvcg_default_control_attr_b_interface_number,
 &uvcg_default_control_attr_enable_interrupt_ep,
 NULL,
};

static const struct uvcg_config_group_type uvcg_control_grp_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_attrs = uvcg_default_control_attrs,
  .ct_owner = THIS_MODULE,
 },
 .name = "control",
 .children = (const struct uvcg_config_group_type*[]) {
  &uvcg_control_header_grp_type,
  &uvcg_processing_grp_type,
  &uvcg_terminal_grp_type,
  &uvcg_control_class_grp_type,
  &uvcg_extensions_grp_type,
  NULL,
 },
};

/* -----------------------------------------------------------------------------
 * streaming/uncompressed
 * streaming/mjpeg
 * streaming/framebased
 */

static const char * const uvcg_format_names[] = {
 "uncompressed",
 "mjpeg",
 "framebased",
};

static struct uvcg_color_matching *
uvcg_format_get_default_color_match(struct config_item *streaming)
{
 struct config_item *color_matching_item, *cm_default;
 struct uvcg_color_matching *color_match;

 color_matching_item = config_group_find_item(to_config_group(streaming),
           "color_matching");
 if (!color_matching_item)
  return NULL;

 cm_default = config_group_find_item(to_config_group(color_matching_item),
         "default");
 config_item_put(color_matching_item);
 if (!cm_default)
  return NULL;

 color_match = to_uvcg_color_matching(to_config_group(cm_default));
 config_item_put(cm_default);

 return color_match;
}

static int uvcg_format_allow_link(struct config_item *src, struct config_item *tgt)
{
 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 struct uvcg_color_matching *color_matching_desc;
 struct config_item *streaming, *color_matching;
 struct uvcg_format *fmt;
 int ret = 0;

 mutex_lock(su_mutex);

 streaming = src->ci_parent->ci_parent;
 color_matching = config_group_find_item(to_config_group(streaming), "color_matching");
 if (!color_matching || color_matching != tgt->ci_parent) {
  ret = -EINVAL;
  goto out_put_cm;
 }

 fmt = to_uvcg_format(src);

 /*
 * There's always a color matching descriptor associated with the format
 * but without a symlink it should only ever be the default one. If it's
 * not the default, there's already a symlink and we should bail out.
 */
 color_matching_desc = uvcg_format_get_default_color_match(streaming);
 if (fmt->color_matching != color_matching_desc) {
  ret = -EBUSY;
  goto out_put_cm;
 }

 color_matching_desc->refcnt--;

 color_matching_desc = to_uvcg_color_matching(to_config_group(tgt));
 fmt->color_matching = color_matching_desc;
 color_matching_desc->refcnt++;

out_put_cm:
 config_item_put(color_matching);
 mutex_unlock(su_mutex);

 return ret;
}

static void uvcg_format_drop_link(struct config_item *src, struct config_item *tgt)
{
 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 struct uvcg_color_matching *color_matching_desc;
 struct config_item *streaming;
 struct uvcg_format *fmt;

 mutex_lock(su_mutex);

 color_matching_desc = to_uvcg_color_matching(to_config_group(tgt));
 color_matching_desc->refcnt--;

 streaming = src->ci_parent->ci_parent;
 color_matching_desc = uvcg_format_get_default_color_match(streaming);

 fmt = to_uvcg_format(src);
 fmt->color_matching = color_matching_desc;
 color_matching_desc->refcnt++;

 mutex_unlock(su_mutex);
}

static struct configfs_item_operations uvcg_format_item_operations = {
 .release = uvcg_config_item_release,
 .allow_link = uvcg_format_allow_link,
 .drop_link = uvcg_format_drop_link,
};

static ssize_t uvcg_format_bma_controls_show(struct uvcg_format *f, char *page)
{
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct mutex *su_mutex = &f->group.cg_subsys->su_mutex;
 int result, i;
 char *pg = page;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = f->group.cg_item.ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 result = sprintf(pg, "0x");
 pg += result;
 for (i = 0; i < UVCG_STREAMING_CONTROL_SIZE; ++i) {
  result += sprintf(pg, "%x\n", f->bmaControls[i]);
  pg = page + result;
 }
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);
 return result;
}

static ssize_t uvcg_format_bma_controls_store(struct uvcg_format *ch,
           const char *page, size_t len)
{
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct mutex *su_mutex = &ch->group.cg_subsys->su_mutex;
 int ret = -EINVAL;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = ch->group.cg_item.ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 if (ch->linked || opts->refcnt) {
  ret = -EBUSY;
  goto end;
 }

 if (len < 4 || *page != '0' ||
     (*(page + 1) != 'x' && *(page + 1) != 'X'))
  goto end;
 ret = hex2bin(ch->bmaControls, page + 2, 1);
 if (ret < 0)
  goto end;
 ret = len;
end:
 mutex_unlock(&opts->lock);
 mutex_unlock(su_mutex);
 return ret;
}

/* -----------------------------------------------------------------------------
 * streaming/header/<NAME>
 * streaming/header
 */

static void uvcg_format_set_indices(struct config_group *fmt);

static int uvcg_streaming_header_allow_link(struct config_item *src,
         struct config_item *target)
{
 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 struct uvcg_streaming_header *src_hdr;
 struct uvcg_format *target_fmt = NULL;
 struct uvcg_format_ptr *format_ptr;
 int i, ret = -EINVAL;

 src_hdr = to_uvcg_streaming_header(src);
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = src->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);

 if (src_hdr->linked) {
  ret = -EBUSY;
  goto out;
 }

 /*
 * Linking is only allowed to direct children of the format nodes
 * (streaming/uncompressed or streaming/mjpeg nodes). First check that
 * the grand-parent of the target matches the grand-parent of the source
 * (the streaming node), and then verify that the target parent is a
 * format node.
 */
 if (src->ci_parent->ci_parent != target->ci_parent->ci_parent)
  goto out;

 for (i = 0; i < ARRAY_SIZE(uvcg_format_names); ++i) {
  if (!strcmp(target->ci_parent->ci_name, uvcg_format_names[i]))
   break;
 }

 if (i == ARRAY_SIZE(uvcg_format_names))
  goto out;

 target_fmt = container_of(to_config_group(target), struct uvcg_format,
      group);

 if (!target_fmt)
  goto out;

 uvcg_format_set_indices(to_config_group(target));

 format_ptr = kzalloc(sizeof(*format_ptr), GFP_KERNEL);
 if (!format_ptr) {
  ret = -ENOMEM;
  goto out;
 }
 ret = 0;
 format_ptr->fmt = target_fmt;
 list_add_tail(&format_ptr->entry, &src_hdr->formats);
 ++src_hdr->num_fmt;
 ++target_fmt->linked;

out:
 mutex_unlock(&opts->lock);
 mutex_unlock(su_mutex);
 return ret;
}

static void uvcg_streaming_header_drop_link(struct config_item *src,
        struct config_item *target)
{
 struct mutex *su_mutex = &src->ci_group->cg_subsys->su_mutex;
 struct config_item *opts_item;
 struct f_uvc_opts *opts;
 struct uvcg_streaming_header *src_hdr;
 struct uvcg_format *target_fmt = NULL;
 struct uvcg_format_ptr *format_ptr, *tmp;

 src_hdr = to_uvcg_streaming_header(src);
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = src->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 target_fmt = container_of(to_config_group(target), struct uvcg_format,
      group);

 if (!target_fmt)
  goto out;

 list_for_each_entry_safe(format_ptr, tmp, &src_hdr->formats, entry)
  if (format_ptr->fmt == target_fmt) {
   list_del(&format_ptr->entry);
   kfree(format_ptr);
   --src_hdr->num_fmt;
   break;
  }

 --target_fmt->linked;

out:
 mutex_unlock(&opts->lock);
 mutex_unlock(su_mutex);
}

static struct configfs_item_operations uvcg_streaming_header_item_ops = {
 .release = uvcg_config_item_release,
 .allow_link = uvcg_streaming_header_allow_link,
 .drop_link = uvcg_streaming_header_drop_link,
};

#define UVCG_STREAMING_HEADER_ATTR(cname, aname, bits)   \
static ssize_t uvcg_streaming_header_##cname##_show(   \
 struct config_item *item, char *page)    \
{         \
 struct uvcg_streaming_header *sh = to_uvcg_streaming_header(item); \
 struct f_uvc_opts *opts;     \
 struct config_item *opts_item;     \
 struct mutex *su_mutex = &sh->item.ci_group->cg_subsys->su_mutex;\
 int result;       \
         \
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
         \
 opts_item = sh->item.ci_parent->ci_parent->ci_parent;  \
 opts = to_f_uvc_opts(opts_item);    \
         \
 mutex_lock(&opts->lock);     \
 result = sprintf(page, "%u\n", le##bits##_to_cpu(sh->desc.aname));\
 mutex_unlock(&opts->lock);     \
         \
 mutex_unlock(su_mutex);      \
 return result;       \
}         \
         \
UVC_ATTR_RO(uvcg_streaming_header_, cname, aname)

UVCG_STREAMING_HEADER_ATTR(bm_info, bmInfo, 8);
UVCG_STREAMING_HEADER_ATTR(b_terminal_link, bTerminalLink, 8);
UVCG_STREAMING_HEADER_ATTR(b_still_capture_method, bStillCaptureMethod, 8);
UVCG_STREAMING_HEADER_ATTR(b_trigger_support, bTriggerSupport, 8);
UVCG_STREAMING_HEADER_ATTR(b_trigger_usage, bTriggerUsage, 8);

#undef UVCG_STREAMING_HEADER_ATTR

static struct configfs_attribute *uvcg_streaming_header_attrs[] = {
 &uvcg_streaming_header_attr_bm_info,
 &uvcg_streaming_header_attr_b_terminal_link,
 &uvcg_streaming_header_attr_b_still_capture_method,
 &uvcg_streaming_header_attr_b_trigger_support,
 &uvcg_streaming_header_attr_b_trigger_usage,
 NULL,
};

static const struct config_item_type uvcg_streaming_header_type = {
 .ct_item_ops = &uvcg_streaming_header_item_ops,
 .ct_attrs = uvcg_streaming_header_attrs,
 .ct_owner = THIS_MODULE,
};

static struct config_item
*uvcg_streaming_header_make(struct config_group *group, const char *name)
{
 struct uvcg_streaming_header *h;

 h = kzalloc(sizeof(*h), GFP_KERNEL);
 if (!h)
  return ERR_PTR(-ENOMEM);

 INIT_LIST_HEAD(&h->formats);
 h->desc.bDescriptorType  = USB_DT_CS_INTERFACE;
 h->desc.bDescriptorSubType = UVC_VS_INPUT_HEADER;
 h->desc.bTerminalLink  = 3;
 h->desc.bControlSize  = UVCG_STREAMING_CONTROL_SIZE;

 config_item_init_type_name(&h->item, name, &uvcg_streaming_header_type);

 return &h->item;
}

static struct configfs_group_operations uvcg_streaming_header_grp_ops = {
 .make_item  = uvcg_streaming_header_make,
};

static const struct uvcg_config_group_type uvcg_streaming_header_grp_type = {
 .type = {
  .ct_item_ops = &uvcg_config_item_ops,
  .ct_group_ops = &uvcg_streaming_header_grp_ops,
  .ct_owner = THIS_MODULE,
 },
 .name = "header",
};

/* -----------------------------------------------------------------------------
 * streaming/<mode>/<format>/<NAME>
 */

#define UVCG_FRAME_ATTR(cname, aname, bits) \
static ssize_t uvcg_frame_##cname##_show(struct config_item *item, char *page)\
{         \
 struct uvcg_frame *f = to_uvcg_frame(item);   \
 struct f_uvc_opts *opts;     \
 struct config_item *opts_item;     \
 struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
 int result;       \
         \
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
         \
 opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
 opts = to_f_uvc_opts(opts_item);    \
         \
 mutex_lock(&opts->lock);     \
 result = sprintf(page, "%u\n", f->frame.cname);   \
 mutex_unlock(&opts->lock);     \
         \
 mutex_unlock(su_mutex);      \
 return result;       \
}         \
         \
static ssize_t  uvcg_frame_##cname##_store(struct config_item *item, \
        const char *page, size_t len)\
{         \
 struct uvcg_frame *f = to_uvcg_frame(item);   \
 struct f_uvc_opts *opts;     \
 struct config_item *opts_item;     \
 struct uvcg_format *fmt;     \
 struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;\
 typeof(f->frame.cname) num;     \
 int ret;       \
         \
 ret = kstrtou##bits(page, 0, &num);    \
 if (ret)       \
  return ret;      \
         \
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
         \
 opts_item = f->item.ci_parent->ci_parent->ci_parent->ci_parent; \
 opts = to_f_uvc_opts(opts_item);    \
 fmt = to_uvcg_format(f->item.ci_parent);   \
         \
 mutex_lock(&opts->lock);     \
 if (fmt->linked || opts->refcnt) {    \
  ret = -EBUSY;      \
  goto end;      \
 }        \
         \
 f->frame.cname = num;      \
 ret = len;       \
end:         \
 mutex_unlock(&opts->lock);     \
 mutex_unlock(su_mutex);      \
 return ret;       \
}         \
         \
UVC_ATTR(uvcg_frame_, cname, aname);

static ssize_t uvcg_frame_b_frame_index_show(struct config_item *item,
          char *page)
{
 struct uvcg_frame *f = to_uvcg_frame(item);
 struct uvcg_format *fmt;
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct config_item *fmt_item;
 struct mutex *su_mutex = &f->item.ci_group->cg_subsys->su_mutex;
 int result;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 fmt_item = f->item.ci_parent;
 fmt = to_uvcg_format(fmt_item);

 if (!fmt->linked) {
  result = -EBUSY;
  goto out;
 }

 opts_item = fmt_item->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 result = sprintf(page, "%u\n", f->frame.b_frame_index);
 mutex_unlock(&opts->lock);

out:
 mutex_unlock(su_mutex);
 return result;
}

UVC_ATTR_RO(uvcg_frame_, b_frame_index, bFrameIndex);

UVCG_FRAME_ATTR(bm_capabilities, bmCapabilities, 8);
UVCG_FRAME_ATTR(w_width, wWidth, 16);
UVCG_FRAME_ATTR(w_height, wHeight, 16);
UVCG_FRAME_ATTR(dw_min_bit_rate, dwMinBitRate, 32);
UVCG_FRAME_ATTR(dw_max_bit_rate, dwMaxBitRate, 32);
UVCG_FRAME_ATTR(dw_max_video_frame_buffer_size, dwMaxVideoFrameBufferSize, 32);
UVCG_FRAME_ATTR(dw_default_frame_interval, dwDefaultFrameInterval, 32);
UVCG_FRAME_ATTR(dw_bytes_perline, dwBytesPerLine, 32);

#undef UVCG_FRAME_ATTR

static ssize_t uvcg_frame_dw_frame_interval_show(struct config_item *item,
       char *page)
{
 struct uvcg_frame *frm = to_uvcg_frame(item);
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct mutex *su_mutex = &frm->item.ci_group->cg_subsys->su_mutex;
 int result, i;
 char *pg = page;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = frm->item.ci_parent->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 for (result = 0, i = 0; i < frm->frame.b_frame_interval_type; ++i) {
  result += sprintf(pg, "%u\n", frm->dw_frame_interval[i]);
  pg = page + result;
 }
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);
 return result;
}

static ssize_t uvcg_frame_dw_frame_interval_store(struct config_item *item,
        const char *page, size_t len)
{
 struct uvcg_frame *ch = to_uvcg_frame(item);
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct uvcg_format *fmt;
 struct mutex *su_mutex = &ch->item.ci_group->cg_subsys->su_mutex;
 int ret = 0, n = 0;
 u32 *frm_intrv, *tmp;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = ch->item.ci_parent->ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);
 fmt = to_uvcg_format(ch->item.ci_parent);

 mutex_lock(&opts->lock);
 if (fmt->linked || opts->refcnt) {
  ret = -EBUSY;
  goto end;
 }

 ret = __uvcg_iter_item_entries(page, len, __uvcg_count_item_entries, &n, sizeof(u32));
 if (ret)
  goto end;

 tmp = frm_intrv = kcalloc(n, sizeof(u32), GFP_KERNEL);
 if (!frm_intrv) {
  ret = -ENOMEM;
  goto end;
 }

 ret = __uvcg_iter_item_entries(page, len, __uvcg_fill_item_entries, &tmp, sizeof(u32));
 if (ret) {
  kfree(frm_intrv);
  goto end;
 }

 kfree(ch->dw_frame_interval);
 ch->dw_frame_interval = frm_intrv;
 ch->frame.b_frame_interval_type = n;
 sort(ch->dw_frame_interval, n, sizeof(*ch->dw_frame_interval),
      uvcg_config_compare_u32, NULL);
 ret = len;

end:
 mutex_unlock(&opts->lock);
 mutex_unlock(su_mutex);
 return ret;
}

UVC_ATTR(uvcg_frame_, dw_frame_interval, dwFrameInterval);

static struct configfs_attribute *uvcg_frame_attrs1[] = {
 &uvcg_frame_attr_b_frame_index,
 &uvcg_frame_attr_bm_capabilities,
 &uvcg_frame_attr_w_width,
 &uvcg_frame_attr_w_height,
 &uvcg_frame_attr_dw_min_bit_rate,
 &uvcg_frame_attr_dw_max_bit_rate,
 &uvcg_frame_attr_dw_max_video_frame_buffer_size,
 &uvcg_frame_attr_dw_default_frame_interval,
 &uvcg_frame_attr_dw_frame_interval,
 NULL,
};

static struct configfs_attribute *uvcg_frame_attrs2[] = {
 &uvcg_frame_attr_b_frame_index,
 &uvcg_frame_attr_bm_capabilities,
 &uvcg_frame_attr_w_width,
 &uvcg_frame_attr_w_height,
 &uvcg_frame_attr_dw_min_bit_rate,
 &uvcg_frame_attr_dw_max_bit_rate,
 &uvcg_frame_attr_dw_default_frame_interval,
 &uvcg_frame_attr_dw_frame_interval,
 &uvcg_frame_attr_dw_bytes_perline,
 NULL,
};

static const struct config_item_type uvcg_frame_type1 = {
 .ct_item_ops = &uvcg_config_item_ops,
 .ct_attrs = uvcg_frame_attrs1,
 .ct_owner = THIS_MODULE,
};

static const struct config_item_type uvcg_frame_type2 = {
 .ct_item_ops    = &uvcg_config_item_ops,
 .ct_attrs       = uvcg_frame_attrs2,
 .ct_owner       = THIS_MODULE,
};

static struct config_item *uvcg_frame_make(struct config_group *group,
        const char *name)
{
 struct uvcg_frame *h;
 struct uvcg_format *fmt;
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct uvcg_frame_ptr *frame_ptr;

 h = kzalloc(sizeof(*h), GFP_KERNEL);
 if (!h)
  return ERR_PTR(-ENOMEM);

 h->frame.b_descriptor_type  = USB_DT_CS_INTERFACE;
 h->frame.b_frame_index   = 1;
 h->frame.w_width   = 640;
 h->frame.w_height   = 360;
 h->frame.dw_min_bit_rate  = 18432000;
 h->frame.dw_max_bit_rate  = 55296000;
 h->frame.dw_max_video_frame_buffer_size = 460800;
 h->frame.dw_default_frame_interval = 666666;
 h->frame.dw_bytes_perline  = 0;

 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 fmt = to_uvcg_format(&group->cg_item);
 if (fmt->type == UVCG_UNCOMPRESSED) {
  h->frame.b_descriptor_subtype = UVC_VS_FRAME_UNCOMPRESSED;
  h->fmt_type = UVCG_UNCOMPRESSED;
 } else if (fmt->type == UVCG_MJPEG) {
  h->frame.b_descriptor_subtype = UVC_VS_FRAME_MJPEG;
  h->fmt_type = UVCG_MJPEG;
 } else if (fmt->type == UVCG_FRAMEBASED) {
  h->frame.b_descriptor_subtype = UVC_VS_FRAME_FRAME_BASED;
  h->fmt_type = UVCG_FRAMEBASED;
 } else {
  mutex_unlock(&opts->lock);
  kfree(h);
  return ERR_PTR(-EINVAL);
 }

 frame_ptr = kzalloc(sizeof(*frame_ptr), GFP_KERNEL);
 if (!frame_ptr) {
  mutex_unlock(&opts->lock);
  kfree(h);
  return ERR_PTR(-ENOMEM);
 }

 frame_ptr->frm = h;
 list_add_tail(&frame_ptr->entry, &fmt->frames);
 ++fmt->num_frames;
 mutex_unlock(&opts->lock);

 if (fmt->type == UVCG_FRAMEBASED)
  config_item_init_type_name(&h->item, name, &uvcg_frame_type2);
 else
  config_item_init_type_name(&h->item, name, &uvcg_frame_type1);

 return &h->item;
}

static void uvcg_frame_drop(struct config_group *group, struct config_item *item)
{
 struct uvcg_format *fmt;
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct uvcg_frame *target_frm = NULL;
 struct uvcg_frame_ptr *frame_ptr, *tmp;

 opts_item = group->cg_item.ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 target_frm = container_of(item, struct uvcg_frame, item);
 fmt = to_uvcg_format(&group->cg_item);

 list_for_each_entry_safe(frame_ptr, tmp, &fmt->frames, entry)
  if (frame_ptr->frm == target_frm) {
   list_del(&frame_ptr->entry);
   kfree(frame_ptr);
   --fmt->num_frames;
   break;
  }
 mutex_unlock(&opts->lock);

 config_item_put(item);
}

static void uvcg_format_set_indices(struct config_group *fmt)
{
 struct config_item *ci;
 unsigned int i = 1;

 list_for_each_entry(ci, &fmt->cg_children, ci_entry) {
  struct uvcg_frame *frm;

  frm = to_uvcg_frame(ci);
  frm->frame.b_frame_index = i++;
 }
}

/* -----------------------------------------------------------------------------
 * streaming/uncompressed/<NAME>
 */

static struct configfs_group_operations uvcg_uncompressed_group_ops = {
 .make_item  = uvcg_frame_make,
 .drop_item  = uvcg_frame_drop,
};

static ssize_t uvcg_uncompressed_guid_format_show(struct config_item *item,
       char *page)
{
 struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 memcpy(page, ch->desc.guidFormat, sizeof(ch->desc.guidFormat));
 mutex_unlock(&opts->lock);

 mutex_unlock(su_mutex);

 return sizeof(ch->desc.guidFormat);
}

static ssize_t uvcg_uncompressed_guid_format_store(struct config_item *item,
         const char *page, size_t len)
{
 struct uvcg_uncompressed *ch = to_uvcg_uncompressed(item);
 struct f_uvc_opts *opts;
 struct config_item *opts_item;
 struct mutex *su_mutex = &ch->fmt.group.cg_subsys->su_mutex;
 const struct uvc_format_desc *format;
 u8 tmpguidFormat[sizeof(ch->desc.guidFormat)];
 int ret;

 mutex_lock(su_mutex); /* for navigating configfs hierarchy */

 opts_item = ch->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;
 opts = to_f_uvc_opts(opts_item);

 mutex_lock(&opts->lock);
 if (ch->fmt.linked || opts->refcnt) {
  ret = -EBUSY;
  goto end;
 }

 memcpy(tmpguidFormat, page,
        min(sizeof(tmpguidFormat), len));

 format = uvc_format_by_guid(tmpguidFormat);
 if (!format) {
  ret = -EINVAL;
  goto end;
 }

 memcpy(ch->desc.guidFormat, tmpguidFormat,
        min(sizeof(ch->desc.guidFormat), len));
 ret = sizeof(ch->desc.guidFormat);

end:
 mutex_unlock(&opts->lock);
 mutex_unlock(su_mutex);
 return ret;
}

UVC_ATTR(uvcg_uncompressed_, guid_format, guidFormat);

#define UVCG_UNCOMPRESSED_ATTR_RO(cname, aname, bits)   \
static ssize_t uvcg_uncompressed_##cname##_show(   \
 struct config_item *item, char *page)    \
{         \
 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
 struct f_uvc_opts *opts;     \
 struct config_item *opts_item;     \
 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
 int result;       \
         \
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
         \
 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
 opts = to_f_uvc_opts(opts_item);    \
         \
 mutex_lock(&opts->lock);     \
 result = sprintf(page, "%u\n", le##bits##_to_cpu(u->desc.aname));\
 mutex_unlock(&opts->lock);     \
         \
 mutex_unlock(su_mutex);      \
 return result;       \
}         \
         \
UVC_ATTR_RO(uvcg_uncompressed_, cname, aname);

#define UVCG_UNCOMPRESSED_ATTR(cname, aname, bits)   \
static ssize_t uvcg_uncompressed_##cname##_show(   \
 struct config_item *item, char *page)    \
{         \
 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
 struct f_uvc_opts *opts;     \
 struct config_item *opts_item;     \
 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
 int result;       \
         \
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
         \
 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
 opts = to_f_uvc_opts(opts_item);    \
         \
 mutex_lock(&opts->lock);     \
 result = sprintf(page, "%u\n", le##bits##_to_cpu(u->desc.aname));\
 mutex_unlock(&opts->lock);     \
         \
 mutex_unlock(su_mutex);      \
 return result;       \
}         \
         \
static ssize_t        \
uvcg_uncompressed_##cname##_store(struct config_item *item,  \
        const char *page, size_t len) \
{         \
 struct uvcg_uncompressed *u = to_uvcg_uncompressed(item); \
 struct f_uvc_opts *opts;     \
 struct config_item *opts_item;     \
 struct mutex *su_mutex = &u->fmt.group.cg_subsys->su_mutex; \
 int ret;       \
 u8 num;        \
         \
 mutex_lock(su_mutex); /* for navigating configfs hierarchy */ \
         \
 opts_item = u->fmt.group.cg_item.ci_parent->ci_parent->ci_parent;\
 opts = to_f_uvc_opts(opts_item);    \
         \
 mutex_lock(&opts->lock);     \
 if (u->fmt.linked || opts->refcnt) {    \
  ret = -EBUSY;      \
  goto end;      \
 }        \
         \
 ret = kstrtou8(page, 0, &num);     \
 if (ret)       \
  goto end;      \
         \
 /* index values in uvc are never 0 */ \
 if (!num) {       \
  ret = -EINVAL;      \
  goto end;      \
 }        \
         \
 u->desc.aname = num;      \
 ret = len;       \
end:         \
 mutex_unlock(&opts->lock);     \
 mutex_unlock(su_mutex);      \
 return ret;       \
}         \
         \
UVC_ATTR(uvcg_uncompressed_, cname, aname);

UVCG_UNCOMPRESSED_ATTR_RO(b_format_index, bFormatIndex, 8);
UVCG_UNCOMPRESSED_ATTR(b_bits_per_pixel, bBitsPerPixel, 8);
UVCG_UNCOMPRESSED_ATTR(b_default_frame_index, bDefaultFrameIndex, 8);
UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_x, bAspectRatioX, 8);
UVCG_UNCOMPRESSED_ATTR_RO(b_aspect_ratio_y, bAspectRatioY, 8);
UVCG_UNCOMPRESSED_ATTR_RO(bm_interlace_flags, bmInterlaceFlags, 8);

#undef UVCG_UNCOMPRESSED_ATTR
#undef UVCG_UNCOMPRESSED_ATTR_RO

static inline ssize_t
uvcg_uncompressed_bma_controls_show(struct config_item *item, char *page)
{
 struct uvcg_uncompressed *unc = to_uvcg_uncompressed(item);
 return uvcg_format_bma_controls_show(&unc->fmt, page);
}

static inline ssize_t
--> --------------------

--> maximum size reached

--> --------------------