1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45#include <media/v4l2-ioctl.h>
46#include <media/videobuf2-v4l2.h>
47
48#include "usbtv.h"
49
50static struct usbtv_norm_params norm_params[] = {
51 {
52 .norm = V4L2_STD_525_60,
53 .cap_width = 720,
54 .cap_height = 480,
55 },
56 {
57 .norm = V4L2_STD_PAL,
58 .cap_width = 720,
59 .cap_height = 576,
60 }
61};
62
63static int usbtv_configure_for_norm(struct usbtv *usbtv, v4l2_std_id norm)
64{
65 int i, ret = 0;
66 struct usbtv_norm_params *params = NULL;
67
68 for (i = 0; i < ARRAY_SIZE(norm_params); i++) {
69 if (norm_params[i].norm & norm) {
70 params = &norm_params[i];
71 break;
72 }
73 }
74
75 if (params) {
76 usbtv->width = params->cap_width;
77 usbtv->height = params->cap_height;
78 usbtv->n_chunks = usbtv->width * usbtv->height
79 / 4 / USBTV_CHUNK;
80 usbtv->norm = params->norm;
81 } else
82 ret = -EINVAL;
83
84 return ret;
85}
86
87static int usbtv_select_input(struct usbtv *usbtv, int input)
88{
89 int ret;
90
91 static const u16 composite[][2] = {
92 { USBTV_BASE + 0x0105, 0x0060 },
93 { USBTV_BASE + 0x011f, 0x00f2 },
94 { USBTV_BASE + 0x0127, 0x0060 },
95 { USBTV_BASE + 0x00ae, 0x0010 },
96 { USBTV_BASE + 0x0239, 0x0060 },
97 };
98
99 static const u16 svideo[][2] = {
100 { USBTV_BASE + 0x0105, 0x0010 },
101 { USBTV_BASE + 0x011f, 0x00ff },
102 { USBTV_BASE + 0x0127, 0x0060 },
103 { USBTV_BASE + 0x00ae, 0x0030 },
104 { USBTV_BASE + 0x0239, 0x0060 },
105 };
106
107 switch (input) {
108 case USBTV_COMPOSITE_INPUT:
109 ret = usbtv_set_regs(usbtv, composite, ARRAY_SIZE(composite));
110 break;
111 case USBTV_SVIDEO_INPUT:
112 ret = usbtv_set_regs(usbtv, svideo, ARRAY_SIZE(svideo));
113 break;
114 default:
115 ret = -EINVAL;
116 }
117
118 if (!ret)
119 usbtv->input = input;
120
121 return ret;
122}
123
124static int usbtv_select_norm(struct usbtv *usbtv, v4l2_std_id norm)
125{
126 int ret;
127 static const u16 pal[][2] = {
128 { USBTV_BASE + 0x001a, 0x0068 },
129 { USBTV_BASE + 0x010e, 0x0072 },
130 { USBTV_BASE + 0x010f, 0x00a2 },
131 { USBTV_BASE + 0x0112, 0x00b0 },
132 { USBTV_BASE + 0x0117, 0x0001 },
133 { USBTV_BASE + 0x0118, 0x002c },
134 { USBTV_BASE + 0x012d, 0x0010 },
135 { USBTV_BASE + 0x012f, 0x0020 },
136 { USBTV_BASE + 0x024f, 0x0002 },
137 { USBTV_BASE + 0x0254, 0x0059 },
138 { USBTV_BASE + 0x025a, 0x0016 },
139 { USBTV_BASE + 0x025b, 0x0035 },
140 { USBTV_BASE + 0x0263, 0x0017 },
141 { USBTV_BASE + 0x0266, 0x0016 },
142 { USBTV_BASE + 0x0267, 0x0036 }
143 };
144
145 static const u16 ntsc[][2] = {
146 { USBTV_BASE + 0x001a, 0x0079 },
147 { USBTV_BASE + 0x010e, 0x0068 },
148 { USBTV_BASE + 0x010f, 0x009c },
149 { USBTV_BASE + 0x0112, 0x00f0 },
150 { USBTV_BASE + 0x0117, 0x0000 },
151 { USBTV_BASE + 0x0118, 0x00fc },
152 { USBTV_BASE + 0x012d, 0x0004 },
153 { USBTV_BASE + 0x012f, 0x0008 },
154 { USBTV_BASE + 0x024f, 0x0001 },
155 { USBTV_BASE + 0x0254, 0x005f },
156 { USBTV_BASE + 0x025a, 0x0012 },
157 { USBTV_BASE + 0x025b, 0x0001 },
158 { USBTV_BASE + 0x0263, 0x001c },
159 { USBTV_BASE + 0x0266, 0x0011 },
160 { USBTV_BASE + 0x0267, 0x0005 }
161 };
162
163 ret = usbtv_configure_for_norm(usbtv, norm);
164
165 if (!ret) {
166 if (norm & V4L2_STD_525_60)
167 ret = usbtv_set_regs(usbtv, ntsc, ARRAY_SIZE(ntsc));
168 else if (norm & V4L2_STD_PAL)
169 ret = usbtv_set_regs(usbtv, pal, ARRAY_SIZE(pal));
170 }
171
172 return ret;
173}
174
175static int usbtv_setup_capture(struct usbtv *usbtv)
176{
177 int ret;
178 static const u16 setup[][2] = {
179
180 { USBTV_BASE + 0x0008, 0x0001 },
181 { USBTV_BASE + 0x01d0, 0x00ff },
182 { USBTV_BASE + 0x01d9, 0x0002 },
183
184
185
186 { USBTV_BASE + 0x0239, 0x0040 },
187 { USBTV_BASE + 0x0240, 0x0000 },
188 { USBTV_BASE + 0x0241, 0x0000 },
189 { USBTV_BASE + 0x0242, 0x0002 },
190 { USBTV_BASE + 0x0243, 0x0080 },
191 { USBTV_BASE + 0x0244, 0x0012 },
192 { USBTV_BASE + 0x0245, 0x0090 },
193 { USBTV_BASE + 0x0246, 0x0000 },
194
195 { USBTV_BASE + 0x0278, 0x002d },
196 { USBTV_BASE + 0x0279, 0x000a },
197 { USBTV_BASE + 0x027a, 0x0032 },
198 { 0xf890, 0x000c },
199 { 0xf894, 0x0086 },
200
201 { USBTV_BASE + 0x00ac, 0x00c0 },
202 { USBTV_BASE + 0x00ad, 0x0000 },
203 { USBTV_BASE + 0x00a2, 0x0012 },
204 { USBTV_BASE + 0x00a3, 0x00e0 },
205 { USBTV_BASE + 0x00a4, 0x0028 },
206 { USBTV_BASE + 0x00a5, 0x0082 },
207 { USBTV_BASE + 0x00a7, 0x0080 },
208 { USBTV_BASE + 0x0000, 0x0014 },
209 { USBTV_BASE + 0x0006, 0x0003 },
210 { USBTV_BASE + 0x0090, 0x0099 },
211 { USBTV_BASE + 0x0091, 0x0090 },
212 { USBTV_BASE + 0x0094, 0x0068 },
213 { USBTV_BASE + 0x0095, 0x0070 },
214 { USBTV_BASE + 0x009c, 0x0030 },
215 { USBTV_BASE + 0x009d, 0x00c0 },
216 { USBTV_BASE + 0x009e, 0x00e0 },
217 { USBTV_BASE + 0x0019, 0x0006 },
218 { USBTV_BASE + 0x008c, 0x00ba },
219 { USBTV_BASE + 0x0101, 0x00ff },
220 { USBTV_BASE + 0x010c, 0x00b3 },
221 { USBTV_BASE + 0x01b2, 0x0080 },
222 { USBTV_BASE + 0x01b4, 0x00a0 },
223 { USBTV_BASE + 0x014c, 0x00ff },
224 { USBTV_BASE + 0x014d, 0x00ca },
225 { USBTV_BASE + 0x0113, 0x0053 },
226 { USBTV_BASE + 0x0119, 0x008a },
227 { USBTV_BASE + 0x013c, 0x0003 },
228 { USBTV_BASE + 0x0150, 0x009c },
229 { USBTV_BASE + 0x0151, 0x0071 },
230 { USBTV_BASE + 0x0152, 0x00c6 },
231 { USBTV_BASE + 0x0153, 0x0084 },
232 { USBTV_BASE + 0x0154, 0x00bc },
233 { USBTV_BASE + 0x0155, 0x00a0 },
234 { USBTV_BASE + 0x0156, 0x00a0 },
235 { USBTV_BASE + 0x0157, 0x009c },
236 { USBTV_BASE + 0x0158, 0x001f },
237 { USBTV_BASE + 0x0159, 0x0006 },
238 { USBTV_BASE + 0x015d, 0x0000 },
239
240 { USBTV_BASE + 0x0003, 0x0004 },
241 { USBTV_BASE + 0x0100, 0x00d3 },
242 { USBTV_BASE + 0x0115, 0x0015 },
243 { USBTV_BASE + 0x0220, 0x002e },
244 { USBTV_BASE + 0x0225, 0x0008 },
245 { USBTV_BASE + 0x024e, 0x0002 },
246 { USBTV_BASE + 0x024e, 0x0002 },
247 { USBTV_BASE + 0x024f, 0x0002 },
248 };
249
250 ret = usbtv_set_regs(usbtv, setup, ARRAY_SIZE(setup));
251 if (ret)
252 return ret;
253
254 ret = usbtv_select_norm(usbtv, usbtv->norm);
255 if (ret)
256 return ret;
257
258 ret = usbtv_select_input(usbtv, usbtv->input);
259 if (ret)
260 return ret;
261
262 return 0;
263}
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285static void usbtv_chunk_to_vbuf(u32 *frame, __be32 *src, int chunk_no, int odd)
286{
287 int half;
288
289 for (half = 0; half < 2; half++) {
290 int part_no = chunk_no * 2 + half;
291 int line = part_no / 3;
292 int part_index = (line * 2 + !odd) * 3 + (part_no % 3);
293
294 u32 *dst = &frame[part_index * USBTV_CHUNK/2];
295
296 memcpy(dst, src, USBTV_CHUNK/2 * sizeof(*src));
297 src += USBTV_CHUNK/2;
298 }
299}
300
301
302
303
304static void usbtv_image_chunk(struct usbtv *usbtv, __be32 *chunk)
305{
306 int frame_id, odd, chunk_no;
307 u32 *frame;
308 struct usbtv_buf *buf;
309 unsigned long flags;
310
311
312 if (!USBTV_MAGIC_OK(chunk))
313 return;
314 frame_id = USBTV_FRAME_ID(chunk);
315 odd = USBTV_ODD(chunk);
316 chunk_no = USBTV_CHUNK_NO(chunk);
317 if (chunk_no >= usbtv->n_chunks)
318 return;
319
320
321 if (chunk_no == 0) {
322 usbtv->frame_id = frame_id;
323 usbtv->chunks_done = 0;
324 }
325
326 if (usbtv->frame_id != frame_id)
327 return;
328
329 spin_lock_irqsave(&usbtv->buflock, flags);
330 if (list_empty(&usbtv->bufs)) {
331
332 spin_unlock_irqrestore(&usbtv->buflock, flags);
333 return;
334 }
335
336
337 buf = list_first_entry(&usbtv->bufs, struct usbtv_buf, list);
338 frame = vb2_plane_vaddr(&buf->vb.vb2_buf, 0);
339
340
341 usbtv_chunk_to_vbuf(frame, &chunk[1], chunk_no, odd);
342 usbtv->chunks_done++;
343
344
345 if (chunk_no == usbtv->n_chunks-1) {
346
347 if (odd && !usbtv->last_odd) {
348 int size = vb2_plane_size(&buf->vb.vb2_buf, 0);
349 enum vb2_buffer_state state = usbtv->chunks_done ==
350 usbtv->n_chunks ?
351 VB2_BUF_STATE_DONE :
352 VB2_BUF_STATE_ERROR;
353
354 buf->vb.field = V4L2_FIELD_INTERLACED;
355 buf->vb.sequence = usbtv->sequence++;
356 buf->vb.vb2_buf.timestamp = ktime_get_ns();
357 vb2_set_plane_payload(&buf->vb.vb2_buf, 0, size);
358 vb2_buffer_done(&buf->vb.vb2_buf, state);
359 list_del(&buf->list);
360 }
361 usbtv->last_odd = odd;
362 }
363
364 spin_unlock_irqrestore(&usbtv->buflock, flags);
365}
366
367
368
369static void usbtv_iso_cb(struct urb *ip)
370{
371 int ret;
372 int i;
373 struct usbtv *usbtv = (struct usbtv *)ip->context;
374
375 switch (ip->status) {
376
377 case 0:
378 break;
379
380 case -ENODEV:
381 case -ENOENT:
382 case -ECONNRESET:
383 case -ESHUTDOWN:
384 return;
385
386 default:
387 dev_warn(usbtv->dev, "Bad response for ISO request.\n");
388 goto resubmit;
389 }
390
391 for (i = 0; i < ip->number_of_packets; i++) {
392 int size = ip->iso_frame_desc[i].actual_length;
393 unsigned char *data = ip->transfer_buffer +
394 ip->iso_frame_desc[i].offset;
395 int offset;
396
397 for (offset = 0; USBTV_CHUNK_SIZE * offset < size; offset++)
398 usbtv_image_chunk(usbtv,
399 (__be32 *)&data[USBTV_CHUNK_SIZE * offset]);
400 }
401
402resubmit:
403 ret = usb_submit_urb(ip, GFP_ATOMIC);
404 if (ret < 0)
405 dev_warn(usbtv->dev, "Could not resubmit ISO URB\n");
406}
407
408static struct urb *usbtv_setup_iso_transfer(struct usbtv *usbtv)
409{
410 struct urb *ip;
411 int size = usbtv->iso_size;
412 int i;
413
414 ip = usb_alloc_urb(USBTV_ISOC_PACKETS, GFP_KERNEL);
415 if (ip == NULL)
416 return NULL;
417
418 ip->dev = usbtv->udev;
419 ip->context = usbtv;
420 ip->pipe = usb_rcvisocpipe(usbtv->udev, USBTV_VIDEO_ENDP);
421 ip->interval = 1;
422 ip->transfer_flags = URB_ISO_ASAP;
423 ip->transfer_buffer = kzalloc(size * USBTV_ISOC_PACKETS,
424 GFP_KERNEL);
425 if (!ip->transfer_buffer) {
426 usb_free_urb(ip);
427 return NULL;
428 }
429 ip->complete = usbtv_iso_cb;
430 ip->number_of_packets = USBTV_ISOC_PACKETS;
431 ip->transfer_buffer_length = size * USBTV_ISOC_PACKETS;
432 for (i = 0; i < USBTV_ISOC_PACKETS; i++) {
433 ip->iso_frame_desc[i].offset = size * i;
434 ip->iso_frame_desc[i].length = size;
435 }
436
437 return ip;
438}
439
440static void usbtv_stop(struct usbtv *usbtv)
441{
442 int i;
443 unsigned long flags;
444
445
446 for (i = 0; i < USBTV_ISOC_TRANSFERS; i++) {
447 struct urb *ip = usbtv->isoc_urbs[i];
448
449 if (ip == NULL)
450 continue;
451 usb_kill_urb(ip);
452 kfree(ip->transfer_buffer);
453 usb_free_urb(ip);
454 usbtv->isoc_urbs[i] = NULL;
455 }
456
457
458 spin_lock_irqsave(&usbtv->buflock, flags);
459 while (!list_empty(&usbtv->bufs)) {
460 struct usbtv_buf *buf = list_first_entry(&usbtv->bufs,
461 struct usbtv_buf, list);
462 vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
463 list_del(&buf->list);
464 }
465 spin_unlock_irqrestore(&usbtv->buflock, flags);
466}
467
468static int usbtv_start(struct usbtv *usbtv)
469{
470 int i;
471 int ret;
472
473 usbtv_audio_suspend(usbtv);
474
475 ret = usb_set_interface(usbtv->udev, 0, 0);
476 if (ret < 0)
477 return ret;
478
479 ret = usbtv_setup_capture(usbtv);
480 if (ret < 0)
481 return ret;
482
483 ret = usb_set_interface(usbtv->udev, 0, 1);
484 if (ret < 0)
485 return ret;
486
487 usbtv_audio_resume(usbtv);
488
489 for (i = 0; i < USBTV_ISOC_TRANSFERS; i++) {
490 struct urb *ip;
491
492 ip = usbtv_setup_iso_transfer(usbtv);
493 if (ip == NULL) {
494 ret = -ENOMEM;
495 goto start_fail;
496 }
497 usbtv->isoc_urbs[i] = ip;
498
499 ret = usb_submit_urb(ip, GFP_KERNEL);
500 if (ret < 0)
501 goto start_fail;
502 }
503
504 return 0;
505
506start_fail:
507 usbtv_stop(usbtv);
508 return ret;
509}
510
511static int usbtv_querycap(struct file *file, void *priv,
512 struct v4l2_capability *cap)
513{
514 struct usbtv *dev = video_drvdata(file);
515
516 strlcpy(cap->driver, "usbtv", sizeof(cap->driver));
517 strlcpy(cap->card, "usbtv", sizeof(cap->card));
518 usb_make_path(dev->udev, cap->bus_info, sizeof(cap->bus_info));
519 cap->device_caps = V4L2_CAP_VIDEO_CAPTURE;
520 cap->device_caps |= V4L2_CAP_READWRITE | V4L2_CAP_STREAMING;
521 cap->capabilities = cap->device_caps | V4L2_CAP_DEVICE_CAPS;
522 return 0;
523}
524
525static int usbtv_enum_input(struct file *file, void *priv,
526 struct v4l2_input *i)
527{
528 struct usbtv *dev = video_drvdata(file);
529
530 switch (i->index) {
531 case USBTV_COMPOSITE_INPUT:
532 strlcpy(i->name, "Composite", sizeof(i->name));
533 break;
534 case USBTV_SVIDEO_INPUT:
535 strlcpy(i->name, "S-Video", sizeof(i->name));
536 break;
537 default:
538 return -EINVAL;
539 }
540
541 i->type = V4L2_INPUT_TYPE_CAMERA;
542 i->std = dev->vdev.tvnorms;
543 return 0;
544}
545
546static int usbtv_enum_fmt_vid_cap(struct file *file, void *priv,
547 struct v4l2_fmtdesc *f)
548{
549 if (f->index > 0)
550 return -EINVAL;
551
552 strlcpy(f->description, "16 bpp YUY2, 4:2:2, packed",
553 sizeof(f->description));
554 f->pixelformat = V4L2_PIX_FMT_YUYV;
555 return 0;
556}
557
558static int usbtv_fmt_vid_cap(struct file *file, void *priv,
559 struct v4l2_format *f)
560{
561 struct usbtv *usbtv = video_drvdata(file);
562
563 f->fmt.pix.width = usbtv->width;
564 f->fmt.pix.height = usbtv->height;
565 f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUYV;
566 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
567 f->fmt.pix.bytesperline = usbtv->width * 2;
568 f->fmt.pix.sizeimage = (f->fmt.pix.bytesperline * f->fmt.pix.height);
569 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
570
571 return 0;
572}
573
574static int usbtv_g_std(struct file *file, void *priv, v4l2_std_id *norm)
575{
576 struct usbtv *usbtv = video_drvdata(file);
577 *norm = usbtv->norm;
578 return 0;
579}
580
581static int usbtv_s_std(struct file *file, void *priv, v4l2_std_id norm)
582{
583 int ret = -EINVAL;
584 struct usbtv *usbtv = video_drvdata(file);
585
586 if ((norm & V4L2_STD_525_60) || (norm & V4L2_STD_PAL))
587 ret = usbtv_select_norm(usbtv, norm);
588
589 return ret;
590}
591
592static int usbtv_g_input(struct file *file, void *priv, unsigned int *i)
593{
594 struct usbtv *usbtv = video_drvdata(file);
595 *i = usbtv->input;
596 return 0;
597}
598
599static int usbtv_s_input(struct file *file, void *priv, unsigned int i)
600{
601 struct usbtv *usbtv = video_drvdata(file);
602
603 return usbtv_select_input(usbtv, i);
604}
605
606static struct v4l2_ioctl_ops usbtv_ioctl_ops = {
607 .vidioc_querycap = usbtv_querycap,
608 .vidioc_enum_input = usbtv_enum_input,
609 .vidioc_enum_fmt_vid_cap = usbtv_enum_fmt_vid_cap,
610 .vidioc_g_fmt_vid_cap = usbtv_fmt_vid_cap,
611 .vidioc_try_fmt_vid_cap = usbtv_fmt_vid_cap,
612 .vidioc_s_fmt_vid_cap = usbtv_fmt_vid_cap,
613 .vidioc_g_std = usbtv_g_std,
614 .vidioc_s_std = usbtv_s_std,
615 .vidioc_g_input = usbtv_g_input,
616 .vidioc_s_input = usbtv_s_input,
617
618 .vidioc_reqbufs = vb2_ioctl_reqbufs,
619 .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
620 .vidioc_querybuf = vb2_ioctl_querybuf,
621 .vidioc_create_bufs = vb2_ioctl_create_bufs,
622 .vidioc_qbuf = vb2_ioctl_qbuf,
623 .vidioc_dqbuf = vb2_ioctl_dqbuf,
624 .vidioc_streamon = vb2_ioctl_streamon,
625 .vidioc_streamoff = vb2_ioctl_streamoff,
626};
627
628static struct v4l2_file_operations usbtv_fops = {
629 .owner = THIS_MODULE,
630 .unlocked_ioctl = video_ioctl2,
631 .mmap = vb2_fop_mmap,
632 .open = v4l2_fh_open,
633 .release = vb2_fop_release,
634 .read = vb2_fop_read,
635 .poll = vb2_fop_poll,
636};
637
638static int usbtv_queue_setup(struct vb2_queue *vq,
639 unsigned int *nbuffers,
640 unsigned int *nplanes, unsigned int sizes[], struct device *alloc_devs[])
641{
642 struct usbtv *usbtv = vb2_get_drv_priv(vq);
643 unsigned size = USBTV_CHUNK * usbtv->n_chunks * 2 * sizeof(u32);
644
645 if (vq->num_buffers + *nbuffers < 2)
646 *nbuffers = 2 - vq->num_buffers;
647 if (*nplanes)
648 return sizes[0] < size ? -EINVAL : 0;
649 *nplanes = 1;
650 sizes[0] = size;
651
652 return 0;
653}
654
655static void usbtv_buf_queue(struct vb2_buffer *vb)
656{
657 struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
658 struct usbtv *usbtv = vb2_get_drv_priv(vb->vb2_queue);
659 struct usbtv_buf *buf = container_of(vbuf, struct usbtv_buf, vb);
660 unsigned long flags;
661
662 if (usbtv->udev == NULL) {
663 vb2_buffer_done(vb, VB2_BUF_STATE_ERROR);
664 return;
665 }
666
667 spin_lock_irqsave(&usbtv->buflock, flags);
668 list_add_tail(&buf->list, &usbtv->bufs);
669 spin_unlock_irqrestore(&usbtv->buflock, flags);
670}
671
672static int usbtv_start_streaming(struct vb2_queue *vq, unsigned int count)
673{
674 struct usbtv *usbtv = vb2_get_drv_priv(vq);
675
676 if (usbtv->udev == NULL)
677 return -ENODEV;
678
679 usbtv->last_odd = 1;
680 usbtv->sequence = 0;
681 return usbtv_start(usbtv);
682}
683
684static void usbtv_stop_streaming(struct vb2_queue *vq)
685{
686 struct usbtv *usbtv = vb2_get_drv_priv(vq);
687
688 if (usbtv->udev)
689 usbtv_stop(usbtv);
690}
691
692static const struct vb2_ops usbtv_vb2_ops = {
693 .queue_setup = usbtv_queue_setup,
694 .buf_queue = usbtv_buf_queue,
695 .start_streaming = usbtv_start_streaming,
696 .stop_streaming = usbtv_stop_streaming,
697};
698
699static void usbtv_release(struct v4l2_device *v4l2_dev)
700{
701 struct usbtv *usbtv = container_of(v4l2_dev, struct usbtv, v4l2_dev);
702
703 v4l2_device_unregister(&usbtv->v4l2_dev);
704 vb2_queue_release(&usbtv->vb2q);
705 kfree(usbtv);
706}
707
708int usbtv_video_init(struct usbtv *usbtv)
709{
710 int ret;
711
712 (void)usbtv_configure_for_norm(usbtv, V4L2_STD_525_60);
713
714 spin_lock_init(&usbtv->buflock);
715 mutex_init(&usbtv->v4l2_lock);
716 mutex_init(&usbtv->vb2q_lock);
717 INIT_LIST_HEAD(&usbtv->bufs);
718
719
720 usbtv->vb2q.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
721 usbtv->vb2q.io_modes = VB2_MMAP | VB2_USERPTR | VB2_READ;
722 usbtv->vb2q.drv_priv = usbtv;
723 usbtv->vb2q.buf_struct_size = sizeof(struct usbtv_buf);
724 usbtv->vb2q.ops = &usbtv_vb2_ops;
725 usbtv->vb2q.mem_ops = &vb2_vmalloc_memops;
726 usbtv->vb2q.timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
727 usbtv->vb2q.lock = &usbtv->vb2q_lock;
728 ret = vb2_queue_init(&usbtv->vb2q);
729 if (ret < 0) {
730 dev_warn(usbtv->dev, "Could not initialize videobuf2 queue\n");
731 return ret;
732 }
733
734
735 usbtv->v4l2_dev.release = usbtv_release;
736 ret = v4l2_device_register(usbtv->dev, &usbtv->v4l2_dev);
737 if (ret < 0) {
738 dev_warn(usbtv->dev, "Could not register v4l2 device\n");
739 goto v4l2_fail;
740 }
741
742
743 strlcpy(usbtv->vdev.name, "usbtv", sizeof(usbtv->vdev.name));
744 usbtv->vdev.v4l2_dev = &usbtv->v4l2_dev;
745 usbtv->vdev.release = video_device_release_empty;
746 usbtv->vdev.fops = &usbtv_fops;
747 usbtv->vdev.ioctl_ops = &usbtv_ioctl_ops;
748 usbtv->vdev.tvnorms = USBTV_TV_STD;
749 usbtv->vdev.queue = &usbtv->vb2q;
750 usbtv->vdev.lock = &usbtv->v4l2_lock;
751 video_set_drvdata(&usbtv->vdev, usbtv);
752 ret = video_register_device(&usbtv->vdev, VFL_TYPE_GRABBER, -1);
753 if (ret < 0) {
754 dev_warn(usbtv->dev, "Could not register video device\n");
755 goto vdev_fail;
756 }
757
758 return 0;
759
760vdev_fail:
761 v4l2_device_unregister(&usbtv->v4l2_dev);
762v4l2_fail:
763 vb2_queue_release(&usbtv->vb2q);
764
765 return ret;
766}
767
768void usbtv_video_free(struct usbtv *usbtv)
769{
770 mutex_lock(&usbtv->vb2q_lock);
771 mutex_lock(&usbtv->v4l2_lock);
772
773 usbtv_stop(usbtv);
774 video_unregister_device(&usbtv->vdev);
775 v4l2_device_disconnect(&usbtv->v4l2_dev);
776
777 mutex_unlock(&usbtv->v4l2_lock);
778 mutex_unlock(&usbtv->vb2q_lock);
779
780 v4l2_device_put(&usbtv->v4l2_dev);
781}
782
