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