Lines Matching refs:dev
48 static inline void i2c_gate_ctrl(struct au0828_dev *dev, int val)
50 if (dev->dvb.frontend && dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl)
51 dev->dvb.frontend->ops.analog_ops.i2c_gate_ctrl(dev->dvb.frontend, val);
54 static inline void print_err_status(struct au0828_dev *dev,
93 static int check_dev(struct au0828_dev *dev)
95 if (test_bit(DEV_DISCONNECTED, &dev->dev_state)) {
100 if (test_bit(DEV_MISCONFIGURED, &dev->dev_state)) {
113 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
132 spin_lock_irqsave(&dev->slock, flags);
133 dev->isoc_ctl.isoc_copy(dev, urb);
134 spin_unlock_irqrestore(&dev->slock, flags);
148 dev->stream_state = STREAM_ON;
154 static void au0828_uninit_isoc(struct au0828_dev *dev)
161 dev->isoc_ctl.nfields = -1;
162 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
163 urb = dev->isoc_ctl.urb[i];
170 if (dev->isoc_ctl.transfer_buffer[i]) {
171 usb_free_coherent(dev->usbdev,
173 dev->isoc_ctl.transfer_buffer[i],
177 dev->isoc_ctl.urb[i] = NULL;
179 dev->isoc_ctl.transfer_buffer[i] = NULL;
182 kfree(dev->isoc_ctl.urb);
183 kfree(dev->isoc_ctl.transfer_buffer);
185 dev->isoc_ctl.urb = NULL;
186 dev->isoc_ctl.transfer_buffer = NULL;
187 dev->isoc_ctl.num_bufs = 0;
189 dev->stream_state = STREAM_OFF;
195 static int au0828_init_isoc(struct au0828_dev *dev, int max_packets,
197 int (*isoc_copy) (struct au0828_dev *dev, struct urb *urb))
199 struct au0828_dmaqueue *dma_q = &dev->vidq;
208 dev->isoc_ctl.isoc_copy = isoc_copy;
209 dev->isoc_ctl.num_bufs = num_bufs;
211 dev->isoc_ctl.urb = kcalloc(num_bufs, sizeof(void *), GFP_KERNEL);
212 if (!dev->isoc_ctl.urb) {
217 dev->isoc_ctl.transfer_buffer = kcalloc(num_bufs, sizeof(void *),
219 if (!dev->isoc_ctl.transfer_buffer) {
221 kfree(dev->isoc_ctl.urb);
225 dev->isoc_ctl.max_pkt_size = max_pkt_size;
226 dev->isoc_ctl.buf = NULL;
228 sb_size = max_packets * dev->isoc_ctl.max_pkt_size;
231 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
234 au0828_uninit_isoc(dev);
237 dev->isoc_ctl.urb[i] = urb;
239 dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->usbdev,
241 if (!dev->isoc_ctl.transfer_buffer[i]) {
245 au0828_uninit_isoc(dev);
248 memset(dev->isoc_ctl.transfer_buffer[i], 0, sb_size);
250 pipe = usb_rcvisocpipe(dev->usbdev,
251 dev->isoc_in_endpointaddr),
253 usb_fill_int_urb(urb, dev->usbdev, pipe,
254 dev->isoc_ctl.transfer_buffer[i], sb_size,
264 dev->isoc_ctl.max_pkt_size;
265 k += dev->isoc_ctl.max_pkt_size;
270 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
271 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
275 au0828_uninit_isoc(dev);
286 static inline void buffer_filled(struct au0828_dev *dev,
297 vb->sequence = dev->frame_count++;
299 vb->sequence = dev->vbi_frame_count++;
309 static void au0828_copy_video(struct au0828_dev *dev,
317 int bytesperline = dev->width << 1; /* Assumes 16-bit depth @@@@ */
381 dev->greenscreen_detected = 1;
393 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vidq);
397 dev->isoc_ctl.buf = NULL;
408 dev->isoc_ctl.buf = *buf;
413 static void au0828_copy_vbi(struct au0828_dev *dev,
423 if (dev == NULL) {
424 au0828_isocdbg("dev is null\n");
443 bytesperline = dev->vbi_width;
453 startwrite += bytesperline * dev->vbi_height;
468 struct au0828_dev *dev = container_of(dma_q, struct au0828_dev, vbiq);
472 dev->isoc_ctl.vbi_buf = NULL;
483 dev->isoc_ctl.vbi_buf = *buf;
490 static inline int au0828_isoc_copy(struct au0828_dev *dev, struct urb *urb)
495 struct au0828_dmaqueue *vbi_dma_q = &dev->vbiq;
504 if (!dev)
507 if (test_bit(DEV_DISCONNECTED, &dev->dev_state) ||
508 test_bit(DEV_MISCONFIGURED, &dev->dev_state))
512 print_err_status(dev, -1, urb->status);
517 buf = dev->isoc_ctl.buf;
521 vbi_buf = dev->isoc_ctl.vbi_buf;
529 print_err_status(dev, i, status);
538 dev->max_pkt_size) {
556 buffer_filled(dev, vbi_dma_q, vbi_buf);
566 buffer_filled(dev, dma_q, buf);
576 if (dev->vid_timeout_running)
577 mod_timer(&dev->vid_timeout,
579 if (dev->vbi_timeout_running)
580 mod_timer(&dev->vbi_timeout,
598 dev->vbi_read = 0;
603 vbi_field_size = dev->vbi_width * dev->vbi_height * 2;
604 if (dev->vbi_read < vbi_field_size) {
605 remain = vbi_field_size - dev->vbi_read;
612 au0828_copy_vbi(dev, vbi_dma_q, vbi_buf, p,
617 dev->vbi_read += lencopy;
620 if (dev->vbi_read >= vbi_field_size && buf != NULL)
621 au0828_copy_video(dev, dma_q, buf, p, outp, len);
626 void au0828_usb_v4l2_media_release(struct au0828_dev *dev)
634 media_device_unregister_entity(&dev->input_ent[i]);
641 struct au0828_dev *dev =
644 v4l2_ctrl_handler_free(&dev->v4l2_ctrl_hdl);
645 v4l2_device_unregister(&dev->v4l2_dev);
646 au0828_usb_v4l2_media_release(dev);
647 au0828_usb_release(dev);
651 struct au0828_dev *dev)
660 dev->v4l2_dev.mdev = dev->media_dev;
662 retval = v4l2_device_register(&interface->dev, &dev->v4l2_dev);
669 dev->v4l2_dev.release = au0828_usb_v4l2_release;
672 retval = v4l2_ctrl_handler_init(&dev->v4l2_ctrl_hdl, 4);
678 dev->v4l2_dev.ctrl_handler = &dev->v4l2_ctrl_hdl;
687 struct au0828_dev *dev = vb2_get_drv_priv(vq);
688 unsigned long size = dev->height * dev->bytesperline;
703 struct au0828_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
705 buf->length = dev->height * dev->bytesperline;
723 struct au0828_dev *dev = vb2_get_drv_priv(vb->vb2_queue);
724 struct au0828_dmaqueue *vidq = &dev->vidq;
730 spin_lock_irqsave(&dev->slock, flags);
732 spin_unlock_irqrestore(&dev->slock, flags);
735 static int au0828_i2s_init(struct au0828_dev *dev)
738 au0828_writereg(dev, AU0828_AUDIOCTRL_50C, 0x01);
793 static void au0828_analog_stream_reset(struct au0828_dev *dev)
796 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0x0);
798 au0828_writereg(dev, AU0828_SENSORCTRL_100, 0xb3);
804 static int au0828_stream_interrupt(struct au0828_dev *dev)
806 dev->stream_state = STREAM_INTERRUPT;
807 if (test_bit(DEV_DISCONNECTED, &dev->dev_state))
814 struct au0828_dev *dev = vb2_get_drv_priv(vq);
818 dev->streaming_users);
821 dev->frame_count = 0;
823 dev->vbi_frame_count = 0;
825 if (dev->streaming_users == 0) {
827 au0828_i2s_init(dev);
828 rc = au0828_init_isoc(dev, AU0828_ISO_PACKETS_PER_URB,
829 AU0828_MAX_ISO_BUFS, dev->max_pkt_size,
836 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 1);
839 dev->vid_timeout_running = 1;
840 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
842 dev->vbi_timeout_running = 1;
843 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
846 dev->streaming_users++;
852 struct au0828_dev *dev = vb2_get_drv_priv(vq);
853 struct au0828_dmaqueue *vidq = &dev->vidq;
856 dprintk(1, "au0828_stop_streaming called %d\n", dev->streaming_users);
858 if (dev->streaming_users-- == 1) {
859 au0828_uninit_isoc(dev);
860 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
863 dev->vid_timeout_running = 0;
864 del_timer_sync(&dev->vid_timeout);
866 spin_lock_irqsave(&dev->slock, flags);
867 if (dev->isoc_ctl.buf != NULL) {
868 vb2_buffer_done(&dev->isoc_ctl.buf->vb.vb2_buf,
870 dev->isoc_ctl.buf = NULL;
879 spin_unlock_irqrestore(&dev->slock, flags);
884 struct au0828_dev *dev = vb2_get_drv_priv(vq);
885 struct au0828_dmaqueue *vbiq = &dev->vbiq;
889 dev->streaming_users);
891 if (dev->streaming_users-- == 1) {
892 au0828_uninit_isoc(dev);
893 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_stream, 0);
896 spin_lock_irqsave(&dev->slock, flags);
897 if (dev->isoc_ctl.vbi_buf != NULL) {
898 vb2_buffer_done(&dev->isoc_ctl.vbi_buf->vb.vb2_buf,
900 dev->isoc_ctl.vbi_buf = NULL;
909 spin_unlock_irqrestore(&dev->slock, flags);
911 dev->vbi_timeout_running = 0;
912 del_timer_sync(&dev->vbi_timeout);
932 int au0828_analog_unregister(struct au0828_dev *dev)
941 vb2_video_unregister_device(&dev->vdev);
942 vb2_video_unregister_device(&dev->vbi_dev);
945 v4l2_device_disconnect(&dev->v4l2_dev);
946 v4l2_device_put(&dev->v4l2_dev);
956 struct au0828_dev *dev = from_timer(dev, t, vid_timeout);
957 struct au0828_dmaqueue *dma_q = &dev->vidq;
962 spin_lock_irqsave(&dev->slock, flags);
964 buf = dev->isoc_ctl.buf;
968 buffer_filled(dev, dma_q, buf);
972 if (dev->vid_timeout_running == 1)
973 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
975 spin_unlock_irqrestore(&dev->slock, flags);
980 struct au0828_dev *dev = from_timer(dev, t, vbi_timeout);
981 struct au0828_dmaqueue *dma_q = &dev->vbiq;
986 spin_lock_irqsave(&dev->slock, flags);
988 buf = dev->isoc_ctl.vbi_buf;
992 buffer_filled(dev, dma_q, buf);
996 if (dev->vbi_timeout_running == 1)
997 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
998 spin_unlock_irqrestore(&dev->slock, flags);
1003 struct au0828_dev *dev = video_drvdata(filp);
1008 __func__, dev->std_set_in_tuner_core, dev->dev_state,
1009 dev->streaming_users, dev->users);
1011 if (mutex_lock_interruptible(&dev->lock))
1018 mutex_unlock(&dev->lock);
1022 if (dev->users == 0) {
1023 au0828_analog_stream_enable(dev);
1024 au0828_analog_stream_reset(dev);
1025 dev->stream_state = STREAM_OFF;
1026 set_bit(DEV_INITIALIZED, &dev->dev_state);
1028 dev->users++;
1029 mutex_unlock(&dev->lock);
1036 struct au0828_dev *dev = video_drvdata(filp);
1041 __func__, dev->std_set_in_tuner_core, dev->dev_state,
1042 dev->streaming_users, dev->users);
1044 mutex_lock(&dev->lock);
1045 if (vdev->vfl_type == VFL_TYPE_VIDEO && dev->vid_timeout_running) {
1047 dev->vid_timeout_running = 0;
1048 del_timer_sync(&dev->vid_timeout);
1050 dev->vbi_timeout_running) {
1052 dev->vbi_timeout_running = 0;
1053 del_timer_sync(&dev->vbi_timeout);
1056 if (test_bit(DEV_DISCONNECTED, &dev->dev_state))
1059 if (dev->users == 1) {
1091 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner,
1093 dev->std_set_in_tuner_core = 0;
1097 ret = usb_set_interface(dev->usbdev, 0, 0);
1103 dev->users--;
1104 mutex_unlock(&dev->lock);
1108 /* Must be called with dev->lock held */
1109 static void au0828_init_tuner(struct au0828_dev *dev)
1112 .frequency = dev->ctrl_freq,
1117 dev->std_set_in_tuner_core, dev->dev_state);
1119 if (dev->std_set_in_tuner_core)
1121 dev->std_set_in_tuner_core = 1;
1122 i2c_gate_ctrl(dev, 1);
1126 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, dev->std);
1127 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, &f);
1128 i2c_gate_ctrl(dev, 0);
1131 static int au0828_set_format(struct au0828_dev *dev, unsigned int cmd,
1161 dev->width = width;
1162 dev->height = height;
1163 dev->frame_size = width * height * 2;
1164 dev->field_size = width * height;
1165 dev->bytesperline = width * 2;
1167 if (dev->stream_state == STREAM_ON) {
1169 ret = au0828_stream_interrupt(dev);
1176 au0828_analog_stream_enable(dev);
1184 struct au0828_dev *dev = video_drvdata(file);
1187 dev->std_set_in_tuner_core, dev->dev_state);
1190 strscpy(cap->card, dev->board.name, sizeof(cap->card));
1191 usb_make_path(dev->usbdev, cap->bus_info, sizeof(cap->bus_info));
1217 struct au0828_dev *dev = video_drvdata(file);
1220 dev->std_set_in_tuner_core, dev->dev_state);
1222 f->fmt.pix.width = dev->width;
1223 f->fmt.pix.height = dev->height;
1225 f->fmt.pix.bytesperline = dev->bytesperline;
1226 f->fmt.pix.sizeimage = dev->frame_size;
1235 struct au0828_dev *dev = video_drvdata(file);
1238 dev->std_set_in_tuner_core, dev->dev_state);
1240 return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
1246 struct au0828_dev *dev = video_drvdata(file);
1250 dev->std_set_in_tuner_core, dev->dev_state);
1252 rc = check_dev(dev);
1256 if (vb2_is_busy(&dev->vb_vidq)) {
1262 rc = au0828_set_format(dev, VIDIOC_S_FMT, f);
1269 struct au0828_dev *dev = video_drvdata(file);
1272 dev->std_set_in_tuner_core, dev->dev_state);
1274 if (norm == dev->std)
1277 if (dev->streaming_users > 0)
1280 dev->std = norm;
1282 au0828_init_tuner(dev);
1284 i2c_gate_ctrl(dev, 1);
1292 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_std, norm);
1294 i2c_gate_ctrl(dev, 0);
1301 struct au0828_dev *dev = video_drvdata(file);
1304 dev->std_set_in_tuner_core, dev->dev_state);
1306 *norm = dev->std;
1313 struct au0828_dev *dev = video_drvdata(file);
1326 dev->std_set_in_tuner_core, dev->dev_state);
1346 input->std = dev->vdev.tvnorms;
1353 struct au0828_dev *dev = video_drvdata(file);
1356 dev->std_set_in_tuner_core, dev->dev_state);
1358 *i = dev->ctrl_input;
1362 static void au0828_s_input(struct au0828_dev *dev, int index)
1367 dev->std_set_in_tuner_core, dev->dev_state);
1371 dev->input_type = AU0828_VMUX_SVIDEO;
1372 dev->ctrl_ainput = 1;
1375 dev->input_type = AU0828_VMUX_COMPOSITE;
1376 dev->ctrl_ainput = 1;
1379 dev->input_type = AU0828_VMUX_TELEVISION;
1380 dev->ctrl_ainput = 0;
1388 dev->ctrl_input = index;
1390 v4l2_device_call_all(&dev->v4l2_dev, 0, video, s_routing,
1403 (AUVI_INPUT(i).audio_setup)(dev, enable);
1409 (AUVI_INPUT(i).audio_setup)(dev, enable);
1414 v4l2_device_call_all(&dev->v4l2_dev, 0, audio, s_routing,
1420 struct au0828_dev *dev = video_drvdata(file);
1430 if (dev->ctrl_input == index)
1433 au0828_s_input(dev, index);
1462 struct au0828_dev *dev = video_drvdata(file);
1465 dev->std_set_in_tuner_core, dev->dev_state);
1467 a->index = dev->ctrl_ainput;
1479 struct au0828_dev *dev = video_drvdata(file);
1481 if (a->index != dev->ctrl_ainput)
1485 dev->std_set_in_tuner_core, dev->dev_state);
1491 struct au0828_dev *dev = video_drvdata(file);
1503 dev->std_set_in_tuner_core, dev->dev_state);
1507 au0828_init_tuner(dev);
1508 i2c_gate_ctrl(dev, 1);
1509 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_tuner, t);
1510 i2c_gate_ctrl(dev, 0);
1517 struct au0828_dev *dev = video_drvdata(file);
1523 dev->std_set_in_tuner_core, dev->dev_state);
1525 au0828_init_tuner(dev);
1526 i2c_gate_ctrl(dev, 1);
1527 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_tuner, t);
1528 i2c_gate_ctrl(dev, 0);
1540 struct au0828_dev *dev = video_drvdata(file);
1545 dev->std_set_in_tuner_core, dev->dev_state);
1546 freq->frequency = dev->ctrl_freq;
1553 struct au0828_dev *dev = video_drvdata(file);
1560 dev->std_set_in_tuner_core, dev->dev_state);
1562 au0828_init_tuner(dev);
1563 i2c_gate_ctrl(dev, 1);
1565 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, s_frequency, freq);
1567 v4l2_device_call_all(&dev->v4l2_dev, 0, tuner, g_frequency, &new_freq);
1568 dev->ctrl_freq = new_freq.frequency;
1570 i2c_gate_ctrl(dev, 0);
1572 au0828_analog_stream_reset(dev);
1583 struct au0828_dev *dev = video_drvdata(file);
1586 dev->std_set_in_tuner_core, dev->dev_state);
1588 format->fmt.vbi.samples_per_line = dev->vbi_width;
1594 format->fmt.vbi.count[0] = dev->vbi_height;
1595 format->fmt.vbi.count[1] = dev->vbi_height;
1606 struct au0828_dev *dev = video_drvdata(file);
1612 dev->std_set_in_tuner_core, dev->dev_state);
1623 struct au0828_dev *dev = video_drvdata(file);
1633 s->r.width = dev->width;
1634 s->r.height = dev->height;
1646 struct au0828_dev *dev = video_drvdata(file);
1649 dev->std_set_in_tuner_core, dev->dev_state);
1651 reg->val = au0828_read(dev, reg->reg);
1659 struct au0828_dev *dev = video_drvdata(file);
1662 dev->std_set_in_tuner_core, dev->dev_state);
1664 return au0828_writereg(dev, reg->reg, reg->val);
1679 void au0828_v4l2_suspend(struct au0828_dev *dev)
1686 if (dev->stream_state == STREAM_ON) {
1688 au0828_analog_stream_disable(dev);
1690 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
1691 urb = dev->isoc_ctl.urb[i];
1701 if (dev->vid_timeout_running)
1702 del_timer_sync(&dev->vid_timeout);
1703 if (dev->vbi_timeout_running)
1704 del_timer_sync(&dev->vbi_timeout);
1707 void au0828_v4l2_resume(struct au0828_dev *dev)
1713 if (dev->stream_state == STREAM_ON) {
1714 au0828_stream_interrupt(dev);
1715 au0828_init_tuner(dev);
1718 if (dev->vid_timeout_running)
1719 mod_timer(&dev->vid_timeout, jiffies + (HZ / 10));
1720 if (dev->vbi_timeout_running)
1721 mod_timer(&dev->vbi_timeout, jiffies + (HZ / 10));
1724 au0828_i2s_init(dev);
1726 au0828_analog_stream_enable(dev);
1728 if (!(dev->stream_state == STREAM_ON)) {
1729 au0828_analog_stream_reset(dev);
1731 for (i = 0; i < dev->isoc_ctl.num_bufs; i++) {
1732 rc = usb_submit_urb(dev->isoc_ctl.urb[i], GFP_ATOMIC);
1736 au0828_uninit_isoc(dev);
1804 static int au0828_vb2_setup(struct au0828_dev *dev)
1810 q = &dev->vb_vidq;
1814 q->drv_priv = dev;
1824 q = &dev->vb_vbiq;
1828 q->drv_priv = dev;
1840 static void au0828_analog_create_entities(struct au0828_dev *dev)
1853 dev->video_pad.flags = MEDIA_PAD_FL_SINK;
1854 ret = media_entity_pads_init(&dev->vdev.entity, 1, &dev->video_pad);
1858 dev->vbi_pad.flags = MEDIA_PAD_FL_SINK;
1859 ret = media_entity_pads_init(&dev->vbi_dev.entity, 1, &dev->vbi_pad);
1865 struct media_entity *ent = &dev->input_ent[i];
1872 dev->input_pad[i].flags = MEDIA_PAD_FL_SOURCE;
1889 ret = media_entity_pads_init(ent, 1, &dev->input_pad[i]);
1893 ret = media_device_register_entity(dev->media_dev, ent);
1902 int au0828_analog_register(struct au0828_dev *dev,
1918 retval = usb_set_interface(dev->usbdev,
1936 dev->max_pkt_size = (tmp & 0x07ff) *
1938 dev->isoc_in_endpointaddr = endpoint->bEndpointAddress;
1941 dev->isoc_in_endpointaddr, dev->max_pkt_size);
1944 if (!(dev->isoc_in_endpointaddr)) {
1949 init_waitqueue_head(&dev->open);
1950 spin_lock_init(&dev->slock);
1953 INIT_LIST_HEAD(&dev->vidq.active);
1954 INIT_LIST_HEAD(&dev->vbiq.active);
1956 timer_setup(&dev->vid_timeout, au0828_vid_buffer_timeout, 0);
1957 timer_setup(&dev->vbi_timeout, au0828_vbi_buffer_timeout, 0);
1959 dev->width = NTSC_STD_W;
1960 dev->height = NTSC_STD_H;
1961 dev->field_size = dev->width * dev->height;
1962 dev->frame_size = dev->field_size << 1;
1963 dev->bytesperline = dev->width << 1;
1964 dev->vbi_width = 720;
1965 dev->vbi_height = 1;
1966 dev->ctrl_ainput = 0;
1967 dev->ctrl_freq = 960;
1968 dev->std = V4L2_STD_NTSC_M;
1970 au0828_s_input(dev, 0);
1972 mutex_init(&dev->vb_queue_lock);
1973 mutex_init(&dev->vb_vbi_queue_lock);
1976 dev->vdev = au0828_video_template;
1977 dev->vdev.v4l2_dev = &dev->v4l2_dev;
1978 dev->vdev.lock = &dev->lock;
1979 dev->vdev.queue = &dev->vb_vidq;
1980 dev->vdev.queue->lock = &dev->vb_queue_lock;
1981 dev->vdev.device_caps =
1984 strscpy(dev->vdev.name, "au0828a video", sizeof(dev->vdev.name));
1987 dev->vbi_dev = au0828_video_template;
1988 dev->vbi_dev.v4l2_dev = &dev->v4l2_dev;
1989 dev->vbi_dev.lock = &dev->lock;
1990 dev->vbi_dev.queue = &dev->vb_vbiq;
1991 dev->vbi_dev.queue->lock = &dev->vb_vbi_queue_lock;
1992 dev->vbi_dev.device_caps =
1995 strscpy(dev->vbi_dev.name, "au0828a vbi", sizeof(dev->vbi_dev.name));
1998 au0828_analog_create_entities(dev);
2001 retval = au0828_vb2_setup(dev);
2009 video_set_drvdata(&dev->vdev, dev);
2010 retval = video_register_device(&dev->vdev, VFL_TYPE_VIDEO, -1);
2018 video_set_drvdata(&dev->vbi_dev, dev);
2019 retval = video_register_device(&dev->vbi_dev, VFL_TYPE_VBI, -1);
2028 retval = v4l2_mc_create_media_graph(dev->media_dev);
2042 vb2_video_unregister_device(&dev->vdev);