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