1 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
2 
3 #include <media/drv-intf/saa7146_vv.h>
4 #include <media/v4l2-event.h>
5 #include <media/v4l2-ctrls.h>
6 #include <linux/module.h>
7 #include <linux/kernel.h>
8 
9 /* format descriptions for capture and preview */
10 static struct saa7146_format formats[] = {
11 	{
12 		.pixelformat	= V4L2_PIX_FMT_RGB332,
13 		.trans		= RGB08_COMPOSED,
14 		.depth		= 8,
15 		.flags		= 0,
16 	}, {
17 		.pixelformat	= V4L2_PIX_FMT_RGB565,
18 		.trans		= RGB16_COMPOSED,
19 		.depth		= 16,
20 		.flags		= 0,
21 	}, {
22 		.pixelformat	= V4L2_PIX_FMT_BGR24,
23 		.trans		= RGB24_COMPOSED,
24 		.depth		= 24,
25 		.flags		= 0,
26 	}, {
27 		.pixelformat	= V4L2_PIX_FMT_BGR32,
28 		.trans		= RGB32_COMPOSED,
29 		.depth		= 32,
30 		.flags		= 0,
31 	}, {
32 		.pixelformat	= V4L2_PIX_FMT_RGB32,
33 		.trans		= RGB32_COMPOSED,
34 		.depth		= 32,
35 		.flags		= 0,
36 		.swap		= 0x2,
37 	}, {
38 		.pixelformat	= V4L2_PIX_FMT_GREY,
39 		.trans		= Y8,
40 		.depth		= 8,
41 		.flags		= 0,
42 	}, {
43 		.pixelformat	= V4L2_PIX_FMT_YUV422P,
44 		.trans		= YUV422_DECOMPOSED,
45 		.depth		= 16,
46 		.flags		= FORMAT_IS_PLANAR,
47 	}, {
48 		.pixelformat	= V4L2_PIX_FMT_YVU420,
49 		.trans		= YUV420_DECOMPOSED,
50 		.depth		= 12,
51 		.flags		= FORMAT_BYTE_SWAP|FORMAT_IS_PLANAR,
52 	}, {
53 		.pixelformat	= V4L2_PIX_FMT_YUV420,
54 		.trans		= YUV420_DECOMPOSED,
55 		.depth		= 12,
56 		.flags		= FORMAT_IS_PLANAR,
57 	}, {
58 		.pixelformat	= V4L2_PIX_FMT_UYVY,
59 		.trans		= YUV422_COMPOSED,
60 		.depth		= 16,
61 		.flags		= 0,
62 	}
63 };
64 
65 /* unfortunately, the saa7146 contains a bug which prevents it from doing on-the-fly byte swaps.
66    due to this, it's impossible to provide additional *packed* formats, which are simply byte swapped
67    (like V4L2_PIX_FMT_YUYV) ... 8-( */
68 
69 struct saa7146_format* saa7146_format_by_fourcc(struct saa7146_dev *dev, int fourcc)
70 {
71 	int i;
72 
73 	for (i = 0; i < ARRAY_SIZE(formats); i++) {
74 		if (formats[i].pixelformat == fourcc) {
75 			return formats+i;
76 		}
77 	}
78 
79 	DEB_D("unknown pixelformat:'%4.4s'\n", (char *)&fourcc);
80 	return NULL;
81 }
82 
83 /********************************************************************************/
84 /* common pagetable functions */
85 
86 static int saa7146_pgtable_build(struct saa7146_dev *dev, struct saa7146_buf *buf)
87 {
88 	struct saa7146_vv *vv = dev->vv_data;
89 	struct pci_dev *pci = dev->pci;
90 	struct sg_table *sgt = vb2_dma_sg_plane_desc(&buf->vb.vb2_buf, 0);
91 	struct scatterlist *list = sgt->sgl;
92 	int length = sgt->nents;
93 	struct v4l2_pix_format *pix = &vv->video_fmt;
94 	struct saa7146_format *sfmt = saa7146_format_by_fourcc(dev, pix->pixelformat);
95 
96 	DEB_EE("dev:%p, buf:%p, sg_len:%d\n", dev, buf, length);
97 
98 	if( 0 != IS_PLANAR(sfmt->trans)) {
99 		struct saa7146_pgtable *pt1 = &buf->pt[0];
100 		struct saa7146_pgtable *pt2 = &buf->pt[1];
101 		struct saa7146_pgtable *pt3 = &buf->pt[2];
102 		struct sg_dma_page_iter dma_iter;
103 		__le32  *ptr1, *ptr2, *ptr3;
104 		__le32 fill;
105 
106 		int size = pix->width * pix->height;
107 		int i, m1, m2, m3, o1, o2;
108 
109 		switch( sfmt->depth ) {
110 			case 12: {
111 				/* create some offsets inside the page table */
112 				m1 = ((size + PAGE_SIZE) / PAGE_SIZE) - 1;
113 				m2 = ((size + (size / 4) + PAGE_SIZE) / PAGE_SIZE) - 1;
114 				m3 = ((size + (size / 2) + PAGE_SIZE) / PAGE_SIZE) - 1;
115 				o1 = size % PAGE_SIZE;
116 				o2 = (size + (size / 4)) % PAGE_SIZE;
117 				DEB_CAP("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n",
118 					size, m1, m2, m3, o1, o2);
119 				break;
120 			}
121 			case 16: {
122 				/* create some offsets inside the page table */
123 				m1 = ((size + PAGE_SIZE) / PAGE_SIZE) - 1;
124 				m2 = ((size + (size / 2) + PAGE_SIZE) / PAGE_SIZE) - 1;
125 				m3 = ((2 * size + PAGE_SIZE) / PAGE_SIZE) - 1;
126 				o1 = size % PAGE_SIZE;
127 				o2 = (size + (size / 2)) % PAGE_SIZE;
128 				DEB_CAP("size:%d, m1:%d, m2:%d, m3:%d, o1:%d, o2:%d\n",
129 					size, m1, m2, m3, o1, o2);
130 				break;
131 			}
132 			default: {
133 				return -1;
134 			}
135 		}
136 
137 		ptr1 = pt1->cpu;
138 		ptr2 = pt2->cpu;
139 		ptr3 = pt3->cpu;
140 
141 		for_each_sg_dma_page(list, &dma_iter, length, 0)
142 			*ptr1++ = cpu_to_le32(sg_page_iter_dma_address(&dma_iter) - list->offset);
143 
144 		/* if we have a user buffer, the first page may not be
145 		   aligned to a page boundary. */
146 		pt1->offset = sgt->sgl->offset;
147 		pt2->offset = pt1->offset + o1;
148 		pt3->offset = pt1->offset + o2;
149 
150 		/* create video-dma2 page table */
151 		ptr1 = pt1->cpu;
152 		for (i = m1; i <= m2; i++, ptr2++)
153 			*ptr2 = ptr1[i];
154 		fill = *(ptr2 - 1);
155 		for (; i < 1024; i++, ptr2++)
156 			*ptr2 = fill;
157 		/* create video-dma3 page table */
158 		ptr1 = pt1->cpu;
159 		for (i = m2; i <= m3; i++, ptr3++)
160 			*ptr3 = ptr1[i];
161 		fill = *(ptr3 - 1);
162 		for (; i < 1024; i++, ptr3++)
163 			*ptr3 = fill;
164 		/* finally: finish up video-dma1 page table */
165 		ptr1 = pt1->cpu + m1;
166 		fill = pt1->cpu[m1];
167 		for (i = m1; i < 1024; i++, ptr1++)
168 			*ptr1 = fill;
169 	} else {
170 		struct saa7146_pgtable *pt = &buf->pt[0];
171 
172 		return saa7146_pgtable_build_single(pci, pt, list, length);
173 	}
174 
175 	return 0;
176 }
177 
178 
179 /********************************************************************************/
180 /* file operations */
181 
182 static int video_begin(struct saa7146_dev *dev)
183 {
184 	struct saa7146_vv *vv = dev->vv_data;
185 	struct saa7146_format *fmt = NULL;
186 	unsigned int resource;
187 	int ret = 0;
188 
189 	DEB_EE("dev:%p\n", dev);
190 
191 	fmt = saa7146_format_by_fourcc(dev, vv->video_fmt.pixelformat);
192 	/* we need to have a valid format set here */
193 	if (!fmt)
194 		return -EINVAL;
195 
196 	if (0 != (fmt->flags & FORMAT_IS_PLANAR)) {
197 		resource = RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP|RESOURCE_DMA3_BRS;
198 	} else {
199 		resource = RESOURCE_DMA1_HPS;
200 	}
201 
202 	ret = saa7146_res_get(dev, resource);
203 	if (0 == ret) {
204 		DEB_S("cannot get capture resource %d\n", resource);
205 		return -EBUSY;
206 	}
207 
208 	/* clear out beginning of streaming bit (rps register 0)*/
209 	saa7146_write(dev, MC2, MASK_27 );
210 
211 	/* enable rps0 irqs */
212 	SAA7146_IER_ENABLE(dev, MASK_27);
213 
214 	return 0;
215 }
216 
217 static void video_end(struct saa7146_dev *dev)
218 {
219 	struct saa7146_vv *vv = dev->vv_data;
220 	struct saa7146_format *fmt = NULL;
221 	unsigned long flags;
222 	unsigned int resource;
223 	u32 dmas = 0;
224 	DEB_EE("dev:%p\n", dev);
225 
226 	fmt = saa7146_format_by_fourcc(dev, vv->video_fmt.pixelformat);
227 	/* we need to have a valid format set here */
228 	if (!fmt)
229 		return;
230 
231 	if (0 != (fmt->flags & FORMAT_IS_PLANAR)) {
232 		resource = RESOURCE_DMA1_HPS|RESOURCE_DMA2_CLP|RESOURCE_DMA3_BRS;
233 		dmas = MASK_22 | MASK_21 | MASK_20;
234 	} else {
235 		resource = RESOURCE_DMA1_HPS;
236 		dmas = MASK_22;
237 	}
238 	spin_lock_irqsave(&dev->slock,flags);
239 
240 	/* disable rps0  */
241 	saa7146_write(dev, MC1, MASK_28);
242 
243 	/* disable rps0 irqs */
244 	SAA7146_IER_DISABLE(dev, MASK_27);
245 
246 	/* shut down all used video dma transfers */
247 	saa7146_write(dev, MC1, dmas);
248 
249 	spin_unlock_irqrestore(&dev->slock, flags);
250 
251 	saa7146_res_free(dev, resource);
252 }
253 
254 static int vidioc_querycap(struct file *file, void *fh, struct v4l2_capability *cap)
255 {
256 	struct saa7146_dev *dev = video_drvdata(file);
257 
258 	strscpy((char *)cap->driver, "saa7146 v4l2", sizeof(cap->driver));
259 	strscpy((char *)cap->card, dev->ext->name, sizeof(cap->card));
260 	cap->capabilities = V4L2_CAP_VIDEO_CAPTURE |
261 			    V4L2_CAP_READWRITE | V4L2_CAP_STREAMING |
262 			    V4L2_CAP_DEVICE_CAPS;
263 	cap->capabilities |= dev->ext_vv_data->capabilities;
264 	return 0;
265 }
266 
267 static int vidioc_enum_fmt_vid_cap(struct file *file, void *fh, struct v4l2_fmtdesc *f)
268 {
269 	if (f->index >= ARRAY_SIZE(formats))
270 		return -EINVAL;
271 	f->pixelformat = formats[f->index].pixelformat;
272 	return 0;
273 }
274 
275 int saa7146_s_ctrl(struct v4l2_ctrl *ctrl)
276 {
277 	struct saa7146_dev *dev = container_of(ctrl->handler,
278 				struct saa7146_dev, ctrl_handler);
279 	struct saa7146_vv *vv = dev->vv_data;
280 	u32 val;
281 
282 	switch (ctrl->id) {
283 	case V4L2_CID_BRIGHTNESS:
284 		val = saa7146_read(dev, BCS_CTRL);
285 		val &= 0x00ffffff;
286 		val |= (ctrl->val << 24);
287 		saa7146_write(dev, BCS_CTRL, val);
288 		saa7146_write(dev, MC2, MASK_22 | MASK_06);
289 		break;
290 
291 	case V4L2_CID_CONTRAST:
292 		val = saa7146_read(dev, BCS_CTRL);
293 		val &= 0xff00ffff;
294 		val |= (ctrl->val << 16);
295 		saa7146_write(dev, BCS_CTRL, val);
296 		saa7146_write(dev, MC2, MASK_22 | MASK_06);
297 		break;
298 
299 	case V4L2_CID_SATURATION:
300 		val = saa7146_read(dev, BCS_CTRL);
301 		val &= 0xffffff00;
302 		val |= (ctrl->val << 0);
303 		saa7146_write(dev, BCS_CTRL, val);
304 		saa7146_write(dev, MC2, MASK_22 | MASK_06);
305 		break;
306 
307 	case V4L2_CID_HFLIP:
308 		/* fixme: we can support changing VFLIP and HFLIP here... */
309 		if (vb2_is_busy(&vv->video_dmaq.q))
310 			return -EBUSY;
311 		vv->hflip = ctrl->val;
312 		break;
313 
314 	case V4L2_CID_VFLIP:
315 		if (vb2_is_busy(&vv->video_dmaq.q))
316 			return -EBUSY;
317 		vv->vflip = ctrl->val;
318 		break;
319 
320 	default:
321 		return -EINVAL;
322 	}
323 	return 0;
324 }
325 
326 static int vidioc_g_parm(struct file *file, void *fh,
327 		struct v4l2_streamparm *parm)
328 {
329 	struct saa7146_dev *dev = video_drvdata(file);
330 	struct saa7146_vv *vv = dev->vv_data;
331 
332 	if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
333 		return -EINVAL;
334 	parm->parm.capture.readbuffers = 1;
335 	v4l2_video_std_frame_period(vv->standard->id,
336 				    &parm->parm.capture.timeperframe);
337 	return 0;
338 }
339 
340 static int vidioc_g_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *f)
341 {
342 	struct saa7146_dev *dev = video_drvdata(file);
343 	struct saa7146_vv *vv = dev->vv_data;
344 
345 	f->fmt.pix = vv->video_fmt;
346 	return 0;
347 }
348 
349 static int vidioc_g_fmt_vbi_cap(struct file *file, void *fh, struct v4l2_format *f)
350 {
351 	struct saa7146_dev *dev = video_drvdata(file);
352 	struct saa7146_vv *vv = dev->vv_data;
353 
354 	f->fmt.vbi = vv->vbi_fmt;
355 	return 0;
356 }
357 
358 static int vidioc_try_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *f)
359 {
360 	struct saa7146_dev *dev = video_drvdata(file);
361 	struct saa7146_vv *vv = dev->vv_data;
362 	struct saa7146_format *fmt;
363 	enum v4l2_field field;
364 	int maxw, maxh;
365 	int calc_bpl;
366 
367 	DEB_EE("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p, fh:%p\n", dev, fh);
368 
369 	fmt = saa7146_format_by_fourcc(dev, f->fmt.pix.pixelformat);
370 	if (NULL == fmt)
371 		return -EINVAL;
372 
373 	field = f->fmt.pix.field;
374 	maxw  = vv->standard->h_max_out;
375 	maxh  = vv->standard->v_max_out;
376 
377 	if (V4L2_FIELD_ANY == field) {
378 		field = (f->fmt.pix.height > maxh / 2)
379 			? V4L2_FIELD_INTERLACED
380 			: V4L2_FIELD_BOTTOM;
381 	}
382 	switch (field) {
383 	case V4L2_FIELD_ALTERNATE:
384 	case V4L2_FIELD_TOP:
385 	case V4L2_FIELD_BOTTOM:
386 		maxh = maxh / 2;
387 		break;
388 	default:
389 		field = V4L2_FIELD_INTERLACED;
390 		break;
391 	}
392 
393 	f->fmt.pix.field = field;
394 	f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
395 	if (f->fmt.pix.width < 48)
396 		f->fmt.pix.width = 48;
397 	if (f->fmt.pix.height < 32)
398 		f->fmt.pix.height = 32;
399 	if (f->fmt.pix.width > maxw)
400 		f->fmt.pix.width = maxw;
401 	if (f->fmt.pix.height > maxh)
402 		f->fmt.pix.height = maxh;
403 
404 	calc_bpl = (f->fmt.pix.width * fmt->depth) / 8;
405 
406 	if (f->fmt.pix.bytesperline < calc_bpl)
407 		f->fmt.pix.bytesperline = calc_bpl;
408 
409 	if (f->fmt.pix.bytesperline > (2 * PAGE_SIZE * fmt->depth) / 8) /* arbitrary constraint */
410 		f->fmt.pix.bytesperline = calc_bpl;
411 
412 	f->fmt.pix.sizeimage = f->fmt.pix.bytesperline * f->fmt.pix.height;
413 	DEB_D("w:%d, h:%d, bytesperline:%d, sizeimage:%d\n",
414 	      f->fmt.pix.width, f->fmt.pix.height,
415 	      f->fmt.pix.bytesperline, f->fmt.pix.sizeimage);
416 
417 	return 0;
418 }
419 
420 static int vidioc_s_fmt_vid_cap(struct file *file, void *fh, struct v4l2_format *f)
421 {
422 	struct saa7146_dev *dev = video_drvdata(file);
423 	struct saa7146_vv *vv = dev->vv_data;
424 	int err;
425 
426 	DEB_EE("V4L2_BUF_TYPE_VIDEO_CAPTURE: dev:%p\n", dev);
427 	if (vb2_is_busy(&vv->video_dmaq.q)) {
428 		DEB_EE("streaming capture is active\n");
429 		return -EBUSY;
430 	}
431 	err = vidioc_try_fmt_vid_cap(file, fh, f);
432 	if (0 != err)
433 		return err;
434 	switch (f->fmt.pix.field) {
435 	case V4L2_FIELD_ALTERNATE:
436 		vv->last_field = V4L2_FIELD_TOP;
437 		break;
438 	default:
439 		vv->last_field = V4L2_FIELD_INTERLACED;
440 		break;
441 	}
442 	vv->video_fmt = f->fmt.pix;
443 	DEB_EE("set to pixelformat '%4.4s'\n",
444 	       (char *)&vv->video_fmt.pixelformat);
445 	return 0;
446 }
447 
448 static int vidioc_g_std(struct file *file, void *fh, v4l2_std_id *norm)
449 {
450 	struct saa7146_dev *dev = video_drvdata(file);
451 	struct saa7146_vv *vv = dev->vv_data;
452 
453 	*norm = vv->standard->id;
454 	return 0;
455 }
456 
457 static int vidioc_s_std(struct file *file, void *fh, v4l2_std_id id)
458 {
459 	struct saa7146_dev *dev = video_drvdata(file);
460 	struct saa7146_vv *vv = dev->vv_data;
461 	int found = 0;
462 	int i;
463 
464 	DEB_EE("VIDIOC_S_STD\n");
465 
466 	for (i = 0; i < dev->ext_vv_data->num_stds; i++)
467 		if (id & dev->ext_vv_data->stds[i].id)
468 			break;
469 
470 	if (i != dev->ext_vv_data->num_stds &&
471 	    vv->standard == &dev->ext_vv_data->stds[i])
472 		return 0;
473 
474 	if (vb2_is_busy(&vv->video_dmaq.q) || vb2_is_busy(&vv->vbi_dmaq.q)) {
475 		DEB_D("cannot change video standard while streaming capture is active\n");
476 		return -EBUSY;
477 	}
478 
479 	if (i != dev->ext_vv_data->num_stds) {
480 		vv->standard = &dev->ext_vv_data->stds[i];
481 		if (NULL != dev->ext_vv_data->std_callback)
482 			dev->ext_vv_data->std_callback(dev, vv->standard);
483 		found = 1;
484 	}
485 
486 	if (!found) {
487 		DEB_EE("VIDIOC_S_STD: standard not found\n");
488 		return -EINVAL;
489 	}
490 
491 	DEB_EE("VIDIOC_S_STD: set to standard to '%s'\n", vv->standard->name);
492 	return 0;
493 }
494 
495 const struct v4l2_ioctl_ops saa7146_video_ioctl_ops = {
496 	.vidioc_querycap             = vidioc_querycap,
497 	.vidioc_enum_fmt_vid_cap     = vidioc_enum_fmt_vid_cap,
498 	.vidioc_g_fmt_vid_cap        = vidioc_g_fmt_vid_cap,
499 	.vidioc_try_fmt_vid_cap      = vidioc_try_fmt_vid_cap,
500 	.vidioc_s_fmt_vid_cap        = vidioc_s_fmt_vid_cap,
501 	.vidioc_g_std                = vidioc_g_std,
502 	.vidioc_s_std                = vidioc_s_std,
503 	.vidioc_g_parm		     = vidioc_g_parm,
504 	.vidioc_reqbufs		     = vb2_ioctl_reqbufs,
505 	.vidioc_create_bufs	     = vb2_ioctl_create_bufs,
506 	.vidioc_querybuf	     = vb2_ioctl_querybuf,
507 	.vidioc_qbuf		     = vb2_ioctl_qbuf,
508 	.vidioc_dqbuf		     = vb2_ioctl_dqbuf,
509 	.vidioc_streamon	     = vb2_ioctl_streamon,
510 	.vidioc_streamoff	     = vb2_ioctl_streamoff,
511 	.vidioc_subscribe_event      = v4l2_ctrl_subscribe_event,
512 	.vidioc_unsubscribe_event    = v4l2_event_unsubscribe,
513 };
514 
515 const struct v4l2_ioctl_ops saa7146_vbi_ioctl_ops = {
516 	.vidioc_querycap             = vidioc_querycap,
517 	.vidioc_g_fmt_vbi_cap        = vidioc_g_fmt_vbi_cap,
518 	.vidioc_try_fmt_vbi_cap      = vidioc_g_fmt_vbi_cap,
519 	.vidioc_s_fmt_vbi_cap        = vidioc_g_fmt_vbi_cap,
520 	.vidioc_g_std                = vidioc_g_std,
521 	.vidioc_s_std                = vidioc_s_std,
522 	.vidioc_g_parm		     = vidioc_g_parm,
523 	.vidioc_reqbufs		     = vb2_ioctl_reqbufs,
524 	.vidioc_create_bufs	     = vb2_ioctl_create_bufs,
525 	.vidioc_querybuf	     = vb2_ioctl_querybuf,
526 	.vidioc_qbuf		     = vb2_ioctl_qbuf,
527 	.vidioc_dqbuf		     = vb2_ioctl_dqbuf,
528 	.vidioc_streamon	     = vb2_ioctl_streamon,
529 	.vidioc_streamoff	     = vb2_ioctl_streamoff,
530 	.vidioc_subscribe_event      = v4l2_ctrl_subscribe_event,
531 	.vidioc_unsubscribe_event    = v4l2_event_unsubscribe,
532 };
533 
534 /*********************************************************************************/
535 /* buffer handling functions                                                  */
536 
537 static int buffer_activate (struct saa7146_dev *dev,
538 		     struct saa7146_buf *buf,
539 		     struct saa7146_buf *next)
540 {
541 	struct saa7146_vv *vv = dev->vv_data;
542 
543 	saa7146_set_capture(dev,buf,next);
544 
545 	mod_timer(&vv->video_dmaq.timeout, jiffies+BUFFER_TIMEOUT);
546 	return 0;
547 }
548 
549 static void release_all_pagetables(struct saa7146_dev *dev, struct saa7146_buf *buf)
550 {
551 	saa7146_pgtable_free(dev->pci, &buf->pt[0]);
552 	saa7146_pgtable_free(dev->pci, &buf->pt[1]);
553 	saa7146_pgtable_free(dev->pci, &buf->pt[2]);
554 }
555 
556 static int queue_setup(struct vb2_queue *q,
557 		       unsigned int *num_buffers, unsigned int *num_planes,
558 		       unsigned int sizes[], struct device *alloc_devs[])
559 {
560 	struct saa7146_dev *dev = vb2_get_drv_priv(q);
561 	unsigned int size = dev->vv_data->video_fmt.sizeimage;
562 
563 	if (*num_planes)
564 		return sizes[0] < size ? -EINVAL : 0;
565 	*num_planes = 1;
566 	sizes[0] = size;
567 
568 	return 0;
569 }
570 
571 static void buf_queue(struct vb2_buffer *vb)
572 {
573 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
574 	struct vb2_queue *vq = vb->vb2_queue;
575 	struct saa7146_dev *dev = vb2_get_drv_priv(vq);
576 	struct saa7146_buf *buf = container_of(vbuf, struct saa7146_buf, vb);
577 	unsigned long flags;
578 
579 	spin_lock_irqsave(&dev->slock, flags);
580 
581 	saa7146_buffer_queue(dev, &dev->vv_data->video_dmaq, buf);
582 	spin_unlock_irqrestore(&dev->slock, flags);
583 }
584 
585 static int buf_init(struct vb2_buffer *vb)
586 {
587 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
588 	struct saa7146_buf *buf = container_of(vbuf, struct saa7146_buf, vb);
589 	struct vb2_queue *vq = vb->vb2_queue;
590 	struct saa7146_dev *dev = vb2_get_drv_priv(vq);
591 	struct saa7146_vv *vv = dev->vv_data;
592 	struct saa7146_format *sfmt;
593 	int ret;
594 
595 	buf->activate = buffer_activate;
596 	sfmt = saa7146_format_by_fourcc(dev, vv->video_fmt.pixelformat);
597 
598 	if (IS_PLANAR(sfmt->trans)) {
599 		saa7146_pgtable_alloc(dev->pci, &buf->pt[0]);
600 		saa7146_pgtable_alloc(dev->pci, &buf->pt[1]);
601 		saa7146_pgtable_alloc(dev->pci, &buf->pt[2]);
602 	} else {
603 		saa7146_pgtable_alloc(dev->pci, &buf->pt[0]);
604 	}
605 
606 	ret = saa7146_pgtable_build(dev, buf);
607 	if (ret)
608 		release_all_pagetables(dev, buf);
609 	return ret;
610 }
611 
612 static int buf_prepare(struct vb2_buffer *vb)
613 {
614 	struct vb2_queue *vq = vb->vb2_queue;
615 	struct saa7146_dev *dev = vb2_get_drv_priv(vq);
616 	struct saa7146_vv *vv = dev->vv_data;
617 	unsigned int size = vv->video_fmt.sizeimage;
618 
619 	if (vb2_plane_size(vb, 0) < size)
620 		return -EINVAL;
621 	vb2_set_plane_payload(vb, 0, size);
622 	return 0;
623 }
624 
625 static void buf_cleanup(struct vb2_buffer *vb)
626 {
627 	struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
628 	struct saa7146_buf *buf = container_of(vbuf, struct saa7146_buf, vb);
629 	struct vb2_queue *vq = vb->vb2_queue;
630 	struct saa7146_dev *dev = vb2_get_drv_priv(vq);
631 
632 	release_all_pagetables(dev, buf);
633 }
634 
635 static void return_buffers(struct vb2_queue *q, int state)
636 {
637 	struct saa7146_dev *dev = vb2_get_drv_priv(q);
638 	struct saa7146_dmaqueue *dq = &dev->vv_data->video_dmaq;
639 	struct saa7146_buf *buf;
640 
641 	if (dq->curr) {
642 		buf = dq->curr;
643 		dq->curr = NULL;
644 		vb2_buffer_done(&buf->vb.vb2_buf, state);
645 	}
646 	while (!list_empty(&dq->queue)) {
647 		buf = list_entry(dq->queue.next, struct saa7146_buf, list);
648 		list_del(&buf->list);
649 		vb2_buffer_done(&buf->vb.vb2_buf, state);
650 	}
651 }
652 
653 static int start_streaming(struct vb2_queue *q, unsigned int count)
654 {
655 	struct saa7146_dev *dev = vb2_get_drv_priv(q);
656 	int ret;
657 
658 	if (!vb2_is_streaming(&dev->vv_data->video_dmaq.q))
659 		dev->vv_data->seqnr = 0;
660 	ret = video_begin(dev);
661 	if (ret)
662 		return_buffers(q, VB2_BUF_STATE_QUEUED);
663 	return ret;
664 }
665 
666 static void stop_streaming(struct vb2_queue *q)
667 {
668 	struct saa7146_dev *dev = vb2_get_drv_priv(q);
669 	struct saa7146_dmaqueue *dq = &dev->vv_data->video_dmaq;
670 
671 	del_timer(&dq->timeout);
672 	video_end(dev);
673 	return_buffers(q, VB2_BUF_STATE_ERROR);
674 }
675 
676 const struct vb2_ops video_qops = {
677 	.queue_setup	= queue_setup,
678 	.buf_queue	= buf_queue,
679 	.buf_init	= buf_init,
680 	.buf_prepare	= buf_prepare,
681 	.buf_cleanup	= buf_cleanup,
682 	.start_streaming = start_streaming,
683 	.stop_streaming = stop_streaming,
684 	.wait_prepare	= vb2_ops_wait_prepare,
685 	.wait_finish	= vb2_ops_wait_finish,
686 };
687 
688 /********************************************************************************/
689 /* file operations */
690 
691 static void video_init(struct saa7146_dev *dev, struct saa7146_vv *vv)
692 {
693 	INIT_LIST_HEAD(&vv->video_dmaq.queue);
694 
695 	timer_setup(&vv->video_dmaq.timeout, saa7146_buffer_timeout, 0);
696 	vv->video_dmaq.dev              = dev;
697 
698 	/* set some default values */
699 	vv->standard = &dev->ext_vv_data->stds[0];
700 
701 	/* FIXME: what's this? */
702 	vv->current_hps_source = SAA7146_HPS_SOURCE_PORT_A;
703 	vv->current_hps_sync = SAA7146_HPS_SYNC_PORT_A;
704 }
705 
706 static void video_irq_done(struct saa7146_dev *dev, unsigned long st)
707 {
708 	struct saa7146_vv *vv = dev->vv_data;
709 	struct saa7146_dmaqueue *q = &vv->video_dmaq;
710 
711 	spin_lock(&dev->slock);
712 	DEB_CAP("called\n");
713 
714 	/* only finish the buffer if we have one... */
715 	if (q->curr)
716 		saa7146_buffer_finish(dev, q, VB2_BUF_STATE_DONE);
717 	saa7146_buffer_next(dev,q,0);
718 
719 	spin_unlock(&dev->slock);
720 }
721 
722 const struct saa7146_use_ops saa7146_video_uops = {
723 	.init = video_init,
724 	.irq_done = video_irq_done,
725 };
726