tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
fork atom

[media] media: remove the setting of the flag V4L2_FL_USE_FH_PRIO

Since all the drivers that use `struct v4l2_fh' use the core
priority checking, the setting of the flag in the drivers can
be removed.

Signed-off-by: Ramakrishnan Muthukrishnan <ramakrmu@cisco.com>
Reviewed-by: Hans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com>
Signed-off-by: Mauro Carvalho Chehab <m.chehab@samsung.com>

authored by

Ramakrishnan Muthukrishnan and committed by
Mauro Carvalho Chehab 95cd5d5e b7284bb0

-64
-1
drivers/media/common/saa7146/saa7146_fops.c
··· 613 613 vfd->lock = &dev->v4l2_lock; 614 614 vfd->v4l2_dev = &dev->v4l2_dev; 615 615 vfd->tvnorms = 0; 616 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 617 616 for (i = 0; i < dev->ext_vv_data->num_stds; i++) 618 617 vfd->tvnorms |= dev->ext_vv_data->stds[i].id; 619 618 strlcpy(vfd->name, name, sizeof(vfd->name));
-1
drivers/media/parport/bw-qcam.c
··· 990 990 qcam->vdev.fops = &qcam_fops; 991 991 qcam->vdev.lock = &qcam->lock; 992 992 qcam->vdev.ioctl_ops = &qcam_ioctl_ops; 993 - set_bit(V4L2_FL_USE_FH_PRIO, &qcam->vdev.flags); 994 993 qcam->vdev.release = video_device_release_empty; 995 994 video_set_drvdata(&qcam->vdev, qcam); 996 995
-1
drivers/media/parport/c-qcam.c
··· 761 761 qcam->vdev.ioctl_ops = &qcam_ioctl_ops; 762 762 qcam->vdev.release = video_device_release_empty; 763 763 qcam->vdev.ctrl_handler = &qcam->hdl; 764 - set_bit(V4L2_FL_USE_FH_PRIO, &qcam->vdev.flags); 765 764 video_set_drvdata(&qcam->vdev, qcam); 766 765 767 766 mutex_init(&qcam->lock);
-1
drivers/media/parport/pms.c
··· 1091 1091 dev->vdev.release = video_device_release_empty; 1092 1092 dev->vdev.lock = &dev->lock; 1093 1093 dev->vdev.tvnorms = V4L2_STD_NTSC | V4L2_STD_PAL | V4L2_STD_SECAM; 1094 - set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev.flags); 1095 1094 video_set_drvdata(&dev->vdev, dev); 1096 1095 dev->std = V4L2_STD_NTSC_M; 1097 1096 dev->height = 240;
-1
drivers/media/parport/w9966.c
··· 883 883 cam->vdev.ioctl_ops = &w9966_ioctl_ops; 884 884 cam->vdev.release = video_device_release_empty; 885 885 cam->vdev.ctrl_handler = &cam->hdl; 886 - set_bit(V4L2_FL_USE_FH_PRIO, &cam->vdev.flags); 887 886 video_set_drvdata(&cam->vdev, cam); 888 887 889 888 mutex_init(&cam->lock);
-1
drivers/media/pci/bt8xx/bttv-driver.c
··· 3886 3886 vfd->v4l2_dev = &btv->c.v4l2_dev; 3887 3887 vfd->release = video_device_release; 3888 3888 vfd->debug = bttv_debug; 3889 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 3890 3889 video_set_drvdata(vfd, btv); 3891 3890 snprintf(vfd->name, sizeof(vfd->name), "BT%d%s %s (%s)", 3892 3891 btv->id, (btv->id==848 && btv->revision==0x12) ? "A" : "",
-1
drivers/media/pci/cx18/cx18-streams.c
··· 375 375 s->video_dev->release = video_device_release; 376 376 s->video_dev->tvnorms = V4L2_STD_ALL; 377 377 s->video_dev->lock = &cx->serialize_lock; 378 - set_bit(V4L2_FL_USE_FH_PRIO, &s->video_dev->flags); 379 378 cx18_set_funcs(s->video_dev); 380 379 return 0; 381 380 }
-1
drivers/media/pci/cx25821/cx25821-video.c
··· 1109 1109 else 1110 1110 vdev->vfl_dir = VFL_DIR_TX; 1111 1111 vdev->lock = &dev->lock; 1112 - set_bit(V4L2_FL_USE_FH_PRIO, &vdev->flags); 1113 1112 snprintf(vdev->name, sizeof(vdev->name), "%s #%d", dev->name, i); 1114 1113 video_set_drvdata(vdev, chan); 1115 1114
-1
drivers/media/pci/cx88/cx88-core.c
··· 1045 1045 vfd->release = video_device_release; 1046 1046 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", 1047 1047 core->name, type, core->board.name); 1048 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 1049 1048 return vfd; 1050 1049 } 1051 1050
-1
drivers/media/pci/ivtv/ivtv-streams.c
··· 251 251 v4l2_disable_ioctl(s->vdev, VIDIOC_G_TUNER); 252 252 v4l2_disable_ioctl(s->vdev, VIDIOC_S_STD); 253 253 } 254 - set_bit(V4L2_FL_USE_FH_PRIO, &s->vdev->flags); 255 254 ivtv_set_funcs(s->vdev); 256 255 return 0; 257 256 }
-1
drivers/media/pci/meye/meye.c
··· 1749 1749 1750 1750 v4l2_ctrl_handler_setup(&meye.hdl); 1751 1751 meye.vdev->ctrl_handler = &meye.hdl; 1752 - set_bit(V4L2_FL_USE_FH_PRIO, &meye.vdev->flags); 1753 1752 1754 1753 if (video_register_device(meye.vdev, VFL_TYPE_GRABBER, 1755 1754 video_nr) < 0) {
-1
drivers/media/pci/saa7134/saa7134-core.c
··· 811 811 vfd->release = video_device_release; 812 812 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", 813 813 dev->name, type, saa7134_boards[dev->board].name); 814 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 815 814 video_set_drvdata(vfd, dev); 816 815 return vfd; 817 816 }
-1
drivers/media/pci/saa7134/saa7134-empress.c
··· 270 270 snprintf(dev->empress_dev->name, sizeof(dev->empress_dev->name), 271 271 "%s empress (%s)", dev->name, 272 272 saa7134_boards[dev->board].name); 273 - set_bit(V4L2_FL_USE_FH_PRIO, &dev->empress_dev->flags); 274 273 v4l2_ctrl_handler_init(hdl, 21); 275 274 v4l2_ctrl_add_handler(hdl, &dev->ctrl_handler, empress_ctrl_filter); 276 275 if (dev->empress_sd)
-1
drivers/media/pci/sta2x11/sta2x11_vip.c
··· 1093 1093 vip->video_dev = &video_dev_template; 1094 1094 vip->video_dev->v4l2_dev = &vip->v4l2_dev; 1095 1095 vip->video_dev->queue = &vip->vb_vidq; 1096 - set_bit(V4L2_FL_USE_FH_PRIO, &vip->video_dev->flags); 1097 1096 video_set_drvdata(vip->video_dev, vip); 1098 1097 1099 1098 ret = video_register_device(vip->video_dev, VFL_TYPE_GRABBER, -1);
-1
drivers/media/platform/arv.c
··· 773 773 ar->vdev.fops = &ar_fops; 774 774 ar->vdev.ioctl_ops = &ar_ioctl_ops; 775 775 ar->vdev.release = video_device_release_empty; 776 - set_bit(V4L2_FL_USE_FH_PRIO, &ar->vdev.flags); 777 776 video_set_drvdata(&ar->vdev, ar); 778 777 779 778 if (vga) {
-1
drivers/media/platform/blackfin/bfin_capture.c
··· 966 966 vfd->ioctl_ops = &bcap_ioctl_ops; 967 967 vfd->tvnorms = 0; 968 968 vfd->v4l2_dev = &bcap_dev->v4l2_dev; 969 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 970 969 strncpy(vfd->name, CAPTURE_DRV_NAME, sizeof(vfd->name)); 971 970 bcap_dev->video_dev = vfd; 972 971
-1
drivers/media/platform/davinci/vpbe_display.c
··· 1709 1709 vpbe_display_layer->disp_dev = disp_dev; 1710 1710 /* set the driver data in platform device */ 1711 1711 platform_set_drvdata(pdev, disp_dev); 1712 - set_bit(V4L2_FL_USE_FH_PRIO, &vpbe_display_layer->video_dev.flags); 1713 1712 video_set_drvdata(&vpbe_display_layer->video_dev, 1714 1713 vpbe_display_layer); 1715 1714
-1
drivers/media/platform/davinci/vpfe_capture.c
··· 1916 1916 v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, 1917 1917 "video_dev=%x\n", (int)&vpfe_dev->video_dev); 1918 1918 vpfe_dev->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; 1919 - set_bit(V4L2_FL_USE_FH_PRIO, &vpfe_dev->video_dev->flags); 1920 1919 ret = video_register_device(vpfe_dev->video_dev, 1921 1920 VFL_TYPE_GRABBER, -1); 1922 1921
-1
drivers/media/platform/davinci/vpif_capture.c
··· 1397 1397 vdev->vfl_dir = VFL_DIR_RX; 1398 1398 vdev->queue = q; 1399 1399 vdev->lock = &common->lock; 1400 - set_bit(V4L2_FL_USE_FH_PRIO, &vdev->flags); 1401 1400 video_set_drvdata(ch->video_dev, ch); 1402 1401 err = video_register_device(vdev, 1403 1402 VFL_TYPE_GRABBER, (j ? 1 : 0));
-1
drivers/media/platform/davinci/vpif_display.c
··· 1223 1223 vdev->vfl_dir = VFL_DIR_TX; 1224 1224 vdev->queue = q; 1225 1225 vdev->lock = &common->lock; 1226 - set_bit(V4L2_FL_USE_FH_PRIO, &vdev->flags); 1227 1226 video_set_drvdata(ch->video_dev, ch); 1228 1227 err = video_register_device(vdev, VFL_TYPE_GRABBER, 1229 1228 (j ? 3 : 2));
-1
drivers/media/platform/s3c-camif/camif-capture.c
··· 1172 1172 goto err_vd_rel; 1173 1173 1174 1174 video_set_drvdata(vfd, vp); 1175 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 1176 1175 1177 1176 v4l2_ctrl_handler_init(&vp->ctrl_handler, 1); 1178 1177 ctrl = v4l2_ctrl_new_std(&vp->ctrl_handler, &s3c_camif_video_ctrl_ops,
-2
drivers/media/platform/s5p-tv/mixer_video.c
··· 1109 1109 .ioctl_ops = &mxr_ioctl_ops, 1110 1110 }; 1111 1111 strlcpy(layer->vfd.name, name, sizeof(layer->vfd.name)); 1112 - /* let framework control PRIORITY */ 1113 - set_bit(V4L2_FL_USE_FH_PRIO, &layer->vfd.flags); 1114 1112 1115 1113 video_set_drvdata(&layer->vfd, layer); 1116 1114 layer->vfd.lock = &layer->mutex;
-1
drivers/media/platform/vivi.c
··· 1459 1459 vfd->debug = debug; 1460 1460 vfd->v4l2_dev = &dev->v4l2_dev; 1461 1461 vfd->queue = q; 1462 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 1463 1462 1464 1463 /* 1465 1464 * Provide a mutex to v4l2 core. It will be used to protect
-1
drivers/media/radio/dsbr100.c
··· 390 390 radio->videodev.release = video_device_release_empty; 391 391 radio->videodev.lock = &radio->v4l2_lock; 392 392 radio->videodev.ctrl_handler = &radio->hdl; 393 - set_bit(V4L2_FL_USE_FH_PRIO, &radio->videodev.flags); 394 393 395 394 radio->usbdev = interface_to_usbdev(intf); 396 395 radio->curfreq = FREQ_MIN * FREQ_MUL;
-1
drivers/media/radio/radio-cadet.c
··· 650 650 dev->vdev.ioctl_ops = &cadet_ioctl_ops; 651 651 dev->vdev.release = video_device_release_empty; 652 652 dev->vdev.lock = &dev->lock; 653 - set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev.flags); 654 653 video_set_drvdata(&dev->vdev, dev); 655 654 656 655 res = video_register_device(&dev->vdev, VFL_TYPE_RADIO, radio_nr);
-1
drivers/media/radio/radio-isa.c
··· 253 253 isa->vdev.fops = &radio_isa_fops; 254 254 isa->vdev.ioctl_ops = &radio_isa_ioctl_ops; 255 255 isa->vdev.release = video_device_release_empty; 256 - set_bit(V4L2_FL_USE_FH_PRIO, &isa->vdev.flags); 257 256 video_set_drvdata(&isa->vdev, isa); 258 257 isa->freq = FREQ_LOW; 259 258 isa->stereo = drv->has_stereo;
-1
drivers/media/radio/radio-keene.c
··· 380 380 usb_set_intfdata(intf, &radio->v4l2_dev); 381 381 382 382 video_set_drvdata(&radio->vdev, radio); 383 - set_bit(V4L2_FL_USE_FH_PRIO, &radio->vdev.flags); 384 383 385 384 /* at least 11ms is needed in order to settle hardware */ 386 385 msleep(20);
-1
drivers/media/radio/radio-ma901.c
··· 411 411 radio->vdev.ioctl_ops = &usb_ma901radio_ioctl_ops; 412 412 radio->vdev.release = video_device_release_empty; 413 413 radio->vdev.lock = &radio->lock; 414 - set_bit(V4L2_FL_USE_FH_PRIO, &radio->vdev.flags); 415 414 416 415 radio->usbdev = interface_to_usbdev(intf); 417 416 radio->intf = intf;
-1
drivers/media/radio/radio-miropcm20.c
··· 210 210 dev->vdev.ioctl_ops = &pcm20_ioctl_ops; 211 211 dev->vdev.release = video_device_release_empty; 212 212 dev->vdev.lock = &dev->lock; 213 - set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev.flags); 214 213 video_set_drvdata(&dev->vdev, dev); 215 214 snd_aci_cmd(dev->aci, ACI_SET_TUNERMONO, 216 215 dev->audmode == V4L2_TUNER_MODE_MONO, -1);
-1
drivers/media/radio/radio-mr800.c
··· 558 558 radio->vdev.ioctl_ops = &usb_amradio_ioctl_ops; 559 559 radio->vdev.release = video_device_release_empty; 560 560 radio->vdev.lock = &radio->lock; 561 - set_bit(V4L2_FL_USE_FH_PRIO, &radio->vdev.flags); 562 561 563 562 radio->usbdev = interface_to_usbdev(intf); 564 563 radio->intf = intf;
-1
drivers/media/radio/radio-raremono.c
··· 361 361 usb_set_intfdata(intf, &radio->v4l2_dev); 362 362 363 363 video_set_drvdata(&radio->vdev, radio); 364 - set_bit(V4L2_FL_USE_FH_PRIO, &radio->vdev.flags); 365 364 366 365 raremono_cmd_main(radio, BAND_FM, 95160); 367 366
-1
drivers/media/radio/radio-sf16fmi.c
··· 344 344 fmi->vdev.fops = &fmi_fops; 345 345 fmi->vdev.ioctl_ops = &fmi_ioctl_ops; 346 346 fmi->vdev.release = video_device_release_empty; 347 - set_bit(V4L2_FL_USE_FH_PRIO, &fmi->vdev.flags); 348 347 video_set_drvdata(&fmi->vdev, fmi); 349 348 350 349 mutex_init(&fmi->lock);
-1
drivers/media/radio/radio-si476x.c
··· 1470 1470 video_set_drvdata(&radio->videodev, radio); 1471 1471 platform_set_drvdata(pdev, radio); 1472 1472 1473 - set_bit(V4L2_FL_USE_FH_PRIO, &radio->videodev.flags); 1474 1473 1475 1474 radio->v4l2dev.ctrl_handler = &radio->ctrl_handler; 1476 1475 v4l2_ctrl_handler_init(&radio->ctrl_handler,
-1
drivers/media/radio/radio-tea5764.c
··· 478 478 video_set_drvdata(&radio->vdev, radio); 479 479 radio->vdev.lock = &radio->mutex; 480 480 radio->vdev.v4l2_dev = v4l2_dev; 481 - set_bit(V4L2_FL_USE_FH_PRIO, &radio->vdev.flags); 482 481 483 482 /* initialize and power off the chip */ 484 483 tea5764_i2c_read(radio);
-1
drivers/media/radio/radio-tea5777.c
··· 570 570 tea->fops = tea575x_fops; 571 571 tea->fops.owner = owner; 572 572 tea->vd.fops = &tea->fops; 573 - set_bit(V4L2_FL_USE_FH_PRIO, &tea->vd.flags); 574 573 575 574 tea->vd.ctrl_handler = &tea->ctrl_handler; 576 575 v4l2_ctrl_handler_init(&tea->ctrl_handler, 1);
-1
drivers/media/radio/radio-timb.c
··· 126 126 tr->video_dev.release = video_device_release_empty; 127 127 tr->video_dev.minor = -1; 128 128 tr->video_dev.lock = &tr->lock; 129 - set_bit(V4L2_FL_USE_FH_PRIO, &tr->video_dev.flags); 130 129 131 130 strlcpy(tr->v4l2_dev.name, DRIVER_NAME, sizeof(tr->v4l2_dev.name)); 132 131 err = v4l2_device_register(NULL, &tr->v4l2_dev);
-1
drivers/media/radio/si470x/radio-si470x-usb.c
··· 680 680 radio->videodev.lock = &radio->lock; 681 681 radio->videodev.v4l2_dev = &radio->v4l2_dev; 682 682 radio->videodev.release = video_device_release_empty; 683 - set_bit(V4L2_FL_USE_FH_PRIO, &radio->videodev.flags); 684 683 video_set_drvdata(&radio->videodev, radio); 685 684 686 685 /* get device and chip versions */
-1
drivers/media/radio/si4713/radio-platform-si4713.c
··· 196 196 rsdev->radio_dev = radio_si4713_vdev_template; 197 197 rsdev->radio_dev.v4l2_dev = &rsdev->v4l2_dev; 198 198 rsdev->radio_dev.ctrl_handler = sd->ctrl_handler; 199 - set_bit(V4L2_FL_USE_FH_PRIO, &rsdev->radio_dev.flags); 200 199 /* Serialize all access to the si4713 */ 201 200 rsdev->radio_dev.lock = &rsdev->lock; 202 201 video_set_drvdata(&rsdev->radio_dev, rsdev);
-1
drivers/media/radio/si4713/radio-usb-si4713.c
··· 492 492 radio->vdev.vfl_dir = VFL_DIR_TX; 493 493 494 494 video_set_drvdata(&radio->vdev, radio); 495 - set_bit(V4L2_FL_USE_FH_PRIO, &radio->vdev.flags); 496 495 497 496 retval = video_register_device(&radio->vdev, VFL_TYPE_RADIO, -1); 498 497 if (retval < 0) {
-1
drivers/media/radio/tea575x.c
··· 523 523 tea->fops = tea575x_fops; 524 524 tea->fops.owner = owner; 525 525 tea->vd.fops = &tea->fops; 526 - set_bit(V4L2_FL_USE_FH_PRIO, &tea->vd.flags); 527 526 /* disable hw_freq_seek if we can't use it */ 528 527 if (tea->cannot_read_data) 529 528 v4l2_disable_ioctl(&tea->vd, VIDIOC_S_HW_FREQ_SEEK);
-2
drivers/media/usb/au0828/au0828-video.c
··· 2016 2016 *dev->vdev = au0828_video_template; 2017 2017 dev->vdev->v4l2_dev = &dev->v4l2_dev; 2018 2018 dev->vdev->lock = &dev->lock; 2019 - set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev->flags); 2020 2019 strcpy(dev->vdev->name, "au0828a video"); 2021 2020 2022 2021 /* Setup the VBI device */ 2023 2022 *dev->vbi_dev = au0828_video_template; 2024 2023 dev->vbi_dev->v4l2_dev = &dev->v4l2_dev; 2025 2024 dev->vbi_dev->lock = &dev->lock; 2026 - set_bit(V4L2_FL_USE_FH_PRIO, &dev->vbi_dev->flags); 2027 2025 strcpy(dev->vbi_dev->name, "au0828a vbi"); 2028 2026 2029 2027 /* Register the v4l2 device */
-1
drivers/media/usb/cpia2/cpia2_v4l.c
··· 1169 1169 cam->vdev.lock = &cam->v4l2_lock; 1170 1170 cam->vdev.ctrl_handler = hdl; 1171 1171 cam->vdev.v4l2_dev = &cam->v4l2_dev; 1172 - set_bit(V4L2_FL_USE_FH_PRIO, &cam->vdev.flags); 1173 1172 1174 1173 reset_camera_struct_v4l(cam); 1175 1174
-1
drivers/media/usb/cx231xx/cx231xx-417.c
··· 1923 1923 vfd->v4l2_dev = &dev->v4l2_dev; 1924 1924 vfd->lock = &dev->lock; 1925 1925 vfd->release = video_device_release; 1926 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 1927 1926 vfd->ctrl_handler = &dev->mpeg_ctrl_handler.hdl; 1928 1927 video_set_drvdata(vfd, dev); 1929 1928 if (dev->tuner_type == TUNER_ABSENT) {
-1
drivers/media/usb/cx231xx/cx231xx-video.c
··· 2065 2065 vfd->release = video_device_release; 2066 2066 vfd->debug = video_debug; 2067 2067 vfd->lock = &dev->lock; 2068 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 2069 2068 2070 2069 snprintf(vfd->name, sizeof(vfd->name), "%s %s", dev->name, type_name); 2071 2070
-1
drivers/media/usb/em28xx/em28xx-video.c
··· 2208 2208 vfd->v4l2_dev = &dev->v4l2->v4l2_dev; 2209 2209 vfd->debug = video_debug; 2210 2210 vfd->lock = &dev->lock; 2211 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 2212 2211 if (dev->board.is_webcam) 2213 2212 vfd->tvnorms = 0; 2214 2213
-1
drivers/media/usb/gspca/gspca.c
··· 2066 2066 gspca_dev->vdev = gspca_template; 2067 2067 gspca_dev->vdev.v4l2_dev = &gspca_dev->v4l2_dev; 2068 2068 video_set_drvdata(&gspca_dev->vdev, gspca_dev); 2069 - set_bit(V4L2_FL_USE_FH_PRIO, &gspca_dev->vdev.flags); 2070 2069 gspca_dev->module = module; 2071 2070 gspca_dev->present = 1; 2072 2071
-1
drivers/media/usb/hdpvr/hdpvr-video.c
··· 1240 1240 strcpy(dev->video_dev->name, "Hauppauge HD PVR"); 1241 1241 dev->video_dev->v4l2_dev = &dev->v4l2_dev; 1242 1242 video_set_drvdata(dev->video_dev, dev); 1243 - set_bit(V4L2_FL_USE_FH_PRIO, &dev->video_dev->flags); 1244 1243 1245 1244 res = video_register_device(dev->video_dev, VFL_TYPE_GRABBER, devnum); 1246 1245 if (res < 0) {
-1
drivers/media/usb/pwc/pwc-if.c
··· 1013 1013 strcpy(pdev->vdev.name, name); 1014 1014 pdev->vdev.queue = &pdev->vb_queue; 1015 1015 pdev->vdev.queue->lock = &pdev->vb_queue_lock; 1016 - set_bit(V4L2_FL_USE_FH_PRIO, &pdev->vdev.flags); 1017 1016 video_set_drvdata(&pdev->vdev, pdev); 1018 1017 1019 1018 pdev->release = le16_to_cpu(udev->descriptor.bcdDevice);
-1
drivers/media/usb/s2255/s2255drv.c
··· 1676 1676 vc->vdev.ctrl_handler = &vc->hdl; 1677 1677 vc->vdev.lock = &dev->lock; 1678 1678 vc->vdev.v4l2_dev = &dev->v4l2_dev; 1679 - set_bit(V4L2_FL_USE_FH_PRIO, &vc->vdev.flags); 1680 1679 video_set_drvdata(&vc->vdev, vc); 1681 1680 if (video_nr == -1) 1682 1681 ret = video_register_device(&vc->vdev,
-1
drivers/media/usb/stk1160/stk1160-v4l.c
··· 671 671 672 672 /* This will be used to set video_device parent */ 673 673 dev->vdev.v4l2_dev = &dev->v4l2_dev; 674 - set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev.flags); 675 674 676 675 /* NTSC is default */ 677 676 dev->norm = V4L2_STD_NTSC_M;
-1
drivers/media/usb/stkwebcam/stk-webcam.c
··· 1266 1266 dev->vdev.lock = &dev->lock; 1267 1267 dev->vdev.debug = debug; 1268 1268 dev->vdev.v4l2_dev = &dev->v4l2_dev; 1269 - set_bit(V4L2_FL_USE_FH_PRIO, &dev->vdev.flags); 1270 1269 video_set_drvdata(&dev->vdev, dev); 1271 1270 err = video_register_device(&dev->vdev, VFL_TYPE_GRABBER, -1); 1272 1271 if (err)
-1
drivers/media/usb/tlg2300/pd-radio.c
··· 327 327 } 328 328 vfd->v4l2_dev = &p->v4l2_dev; 329 329 vfd->ctrl_handler = hdl; 330 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 331 330 video_set_drvdata(vfd, p); 332 331 return video_register_device(vfd, VFL_TYPE_RADIO, -1); 333 332 }
-1
drivers/media/usb/tm6000/tm6000-video.c
··· 1626 1626 vfd->release = video_device_release; 1627 1627 vfd->debug = tm6000_debug; 1628 1628 vfd->lock = &dev->lock; 1629 - set_bit(V4L2_FL_USE_FH_PRIO, &vfd->flags); 1630 1629 1631 1630 snprintf(vfd->name, sizeof(vfd->name), "%s %s", dev->name, type_name); 1632 1631
-1
drivers/media/usb/usbtv/usbtv-video.c
··· 701 701 usbtv->vdev.tvnorms = USBTV_TV_STD; 702 702 usbtv->vdev.queue = &usbtv->vb2q; 703 703 usbtv->vdev.lock = &usbtv->v4l2_lock; 704 - set_bit(V4L2_FL_USE_FH_PRIO, &usbtv->vdev.flags); 705 704 video_set_drvdata(&usbtv->vdev, usbtv); 706 705 ret = video_register_device(&usbtv->vdev, VFL_TYPE_GRABBER, -1); 707 706 if (ret < 0) {
-1
drivers/media/usb/uvc/uvc_driver.c
··· 1746 1746 vdev->fops = &uvc_fops; 1747 1747 vdev->release = uvc_release; 1748 1748 vdev->prio = &stream->chain->prio; 1749 - set_bit(V4L2_FL_USE_FH_PRIO, &vdev->flags); 1750 1749 if (stream->type == V4L2_BUF_TYPE_VIDEO_OUTPUT) 1751 1750 vdev->vfl_dir = VFL_DIR_TX; 1752 1751 strlcpy(vdev->name, dev->name, sizeof vdev->name);
-1
drivers/media/usb/zr364xx/zr364xx.c
··· 1456 1456 cam->vdev.lock = &cam->lock; 1457 1457 cam->vdev.v4l2_dev = &cam->v4l2_dev; 1458 1458 cam->vdev.ctrl_handler = &cam->ctrl_handler; 1459 - set_bit(V4L2_FL_USE_FH_PRIO, &cam->vdev.flags); 1460 1459 video_set_drvdata(&cam->vdev, cam); 1461 1460 if (debug) 1462 1461 cam->vdev.debug = V4L2_DEBUG_IOCTL | V4L2_DEBUG_IOCTL_ARG;
-1
drivers/staging/media/davinci_vpfe/vpfe_video.c
··· 1606 1606 if (ret < 0) 1607 1607 return ret; 1608 1608 1609 - set_bit(V4L2_FL_USE_FH_PRIO, &video->video_dev.flags); 1610 1609 video_set_drvdata(&video->video_dev, video); 1611 1610 1612 1611 return 0;
-1
drivers/staging/media/go7007/go7007-v4l2.c
··· 1001 1001 *vdev = go7007_template; 1002 1002 vdev->lock = &go->serialize_lock; 1003 1003 vdev->queue = &go->vidq; 1004 - set_bit(V4L2_FL_USE_FH_PRIO, &vdev->flags); 1005 1004 video_set_drvdata(vdev, go); 1006 1005 vdev->v4l2_dev = &go->v4l2_dev; 1007 1006 if (!v4l2_device_has_op(&go->v4l2_dev, video, querystd))
-1
drivers/staging/media/msi3101/sdr-msi3101.c
··· 1418 1418 s->vdev = msi3101_template; 1419 1419 s->vdev.queue = &s->vb_queue; 1420 1420 s->vdev.queue->lock = &s->vb_queue_lock; 1421 - set_bit(V4L2_FL_USE_FH_PRIO, &s->vdev.flags); 1422 1421 video_set_drvdata(&s->vdev, s); 1423 1422 1424 1423 /* Register the v4l2_device structure */
-1
drivers/staging/media/rtl2832u_sdr/rtl2832_sdr.c
··· 1480 1480 s->vdev = rtl2832_sdr_template; 1481 1481 s->vdev.queue = &s->vb_queue; 1482 1482 s->vdev.queue->lock = &s->vb_queue_lock; 1483 - set_bit(V4L2_FL_USE_FH_PRIO, &s->vdev.flags); 1484 1483 video_set_drvdata(&s->vdev, s); 1485 1484 1486 1485 /* Register the v4l2_device structure */
-1
drivers/staging/media/solo6x10/solo6x10-v4l2-enc.c
··· 1326 1326 solo_enc->vfd->ctrl_handler = hdl; 1327 1327 solo_enc->vfd->queue = &solo_enc->vidq; 1328 1328 solo_enc->vfd->lock = &solo_enc->lock; 1329 - set_bit(V4L2_FL_USE_FH_PRIO, &solo_enc->vfd->flags); 1330 1329 video_set_drvdata(solo_enc->vfd, solo_enc); 1331 1330 ret = video_register_device(solo_enc->vfd, VFL_TYPE_GRABBER, nr); 1332 1331 if (ret < 0)
-1
drivers/staging/media/solo6x10/solo6x10-v4l2.c
··· 666 666 goto fail; 667 667 } 668 668 solo_dev->vfd->ctrl_handler = &solo_dev->disp_hdl; 669 - set_bit(V4L2_FL_USE_FH_PRIO, &solo_dev->vfd->flags); 670 669 671 670 video_set_drvdata(solo_dev->vfd, solo_dev); 672 671