1 /*
2  *  Driver for the NXP SAA7164 PCIe bridge
3  *
4  *  Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *
15  *  GNU General Public License for more details.
16  */
17 
18 #include "saa7164.h"
19 
20 #define ENCODER_MAX_BITRATE 6500000
21 #define ENCODER_MIN_BITRATE 1000000
22 #define ENCODER_DEF_BITRATE 5000000
23 
24 /*
25  * This is a dummy non-zero value for the sizeimage field of v4l2_pix_format.
26  * It is not actually used for anything since this driver does not support
27  * stream I/O, only read(), and because this driver produces an MPEG stream
28  * and not discrete frames. But the V4L2 spec doesn't allow for this value
29  * to be 0, so set it to 0x10000 instead.
30  *
31  * If we ever change this driver to support stream I/O, then this field
32  * will be the size of the streaming buffers.
33  */
34 #define SAA7164_SIZEIMAGE (0x10000)
35 
36 static struct saa7164_tvnorm saa7164_tvnorms[] = {
37 	{
38 		.name      = "NTSC-M",
39 		.id        = V4L2_STD_NTSC_M,
40 	}, {
41 		.name      = "NTSC-JP",
42 		.id        = V4L2_STD_NTSC_M_JP,
43 	}
44 };
45 
46 /* Take the encoder configuration form the port struct and
47  * flush it to the hardware.
48  */
49 static void saa7164_encoder_configure(struct saa7164_port *port)
50 {
51 	struct saa7164_dev *dev = port->dev;
52 	dprintk(DBGLVL_ENC, "%s()\n", __func__);
53 
54 	port->encoder_params.width = port->width;
55 	port->encoder_params.height = port->height;
56 	port->encoder_params.is_50hz =
57 		(port->encodernorm.id & V4L2_STD_625_50) != 0;
58 
59 	/* Set up the DIF (enable it) for analog mode by default */
60 	saa7164_api_initialize_dif(port);
61 
62 	/* Configure the correct video standard */
63 	saa7164_api_configure_dif(port, port->encodernorm.id);
64 
65 	/* Ensure the audio decoder is correct configured */
66 	saa7164_api_set_audio_std(port);
67 }
68 
69 static int saa7164_encoder_buffers_dealloc(struct saa7164_port *port)
70 {
71 	struct list_head *c, *n, *p, *q, *l, *v;
72 	struct saa7164_dev *dev = port->dev;
73 	struct saa7164_buffer *buf;
74 	struct saa7164_user_buffer *ubuf;
75 
76 	/* Remove any allocated buffers */
77 	mutex_lock(&port->dmaqueue_lock);
78 
79 	dprintk(DBGLVL_ENC, "%s(port=%d) dmaqueue\n", __func__, port->nr);
80 	list_for_each_safe(c, n, &port->dmaqueue.list) {
81 		buf = list_entry(c, struct saa7164_buffer, list);
82 		list_del(c);
83 		saa7164_buffer_dealloc(buf);
84 	}
85 
86 	dprintk(DBGLVL_ENC, "%s(port=%d) used\n", __func__, port->nr);
87 	list_for_each_safe(p, q, &port->list_buf_used.list) {
88 		ubuf = list_entry(p, struct saa7164_user_buffer, list);
89 		list_del(p);
90 		saa7164_buffer_dealloc_user(ubuf);
91 	}
92 
93 	dprintk(DBGLVL_ENC, "%s(port=%d) free\n", __func__, port->nr);
94 	list_for_each_safe(l, v, &port->list_buf_free.list) {
95 		ubuf = list_entry(l, struct saa7164_user_buffer, list);
96 		list_del(l);
97 		saa7164_buffer_dealloc_user(ubuf);
98 	}
99 
100 	mutex_unlock(&port->dmaqueue_lock);
101 	dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
102 
103 	return 0;
104 }
105 
106 /* Dynamic buffer switch at encoder start time */
107 static int saa7164_encoder_buffers_alloc(struct saa7164_port *port)
108 {
109 	struct saa7164_dev *dev = port->dev;
110 	struct saa7164_buffer *buf;
111 	struct saa7164_user_buffer *ubuf;
112 	struct tmHWStreamParameters *params = &port->hw_streamingparams;
113 	int result = -ENODEV, i;
114 	int len = 0;
115 
116 	dprintk(DBGLVL_ENC, "%s()\n", __func__);
117 
118 	if (port->encoder_params.stream_type ==
119 		V4L2_MPEG_STREAM_TYPE_MPEG2_PS) {
120 		dprintk(DBGLVL_ENC,
121 			"%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_PS\n",
122 			__func__);
123 		params->samplesperline = 128;
124 		params->numberoflines = 256;
125 		params->pitch = 128;
126 		params->numpagetables = 2 +
127 			((SAA7164_PS_NUMBER_OF_LINES * 128) / PAGE_SIZE);
128 	} else
129 	if (port->encoder_params.stream_type ==
130 		V4L2_MPEG_STREAM_TYPE_MPEG2_TS) {
131 		dprintk(DBGLVL_ENC,
132 			"%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_TS\n",
133 			__func__);
134 		params->samplesperline = 188;
135 		params->numberoflines = 312;
136 		params->pitch = 188;
137 		params->numpagetables = 2 +
138 			((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
139 	} else
140 		BUG();
141 
142 	/* Init and establish defaults */
143 	params->bitspersample = 8;
144 	params->linethreshold = 0;
145 	params->pagetablelistvirt = NULL;
146 	params->pagetablelistphys = NULL;
147 	params->numpagetableentries = port->hwcfg.buffercount;
148 
149 	/* Allocate the PCI resources, buffers (hard) */
150 	for (i = 0; i < port->hwcfg.buffercount; i++) {
151 		buf = saa7164_buffer_alloc(port,
152 			params->numberoflines *
153 			params->pitch);
154 
155 		if (!buf) {
156 			printk(KERN_ERR "%s() failed (errno = %d), unable to allocate buffer\n",
157 				__func__, result);
158 			result = -ENOMEM;
159 			goto failed;
160 		} else {
161 
162 			mutex_lock(&port->dmaqueue_lock);
163 			list_add_tail(&buf->list, &port->dmaqueue.list);
164 			mutex_unlock(&port->dmaqueue_lock);
165 
166 		}
167 	}
168 
169 	/* Allocate some kernel buffers for copying
170 	 * to userpsace.
171 	 */
172 	len = params->numberoflines * params->pitch;
173 
174 	if (encoder_buffers < 16)
175 		encoder_buffers = 16;
176 	if (encoder_buffers > 512)
177 		encoder_buffers = 512;
178 
179 	for (i = 0; i < encoder_buffers; i++) {
180 
181 		ubuf = saa7164_buffer_alloc_user(dev, len);
182 		if (ubuf) {
183 			mutex_lock(&port->dmaqueue_lock);
184 			list_add_tail(&ubuf->list, &port->list_buf_free.list);
185 			mutex_unlock(&port->dmaqueue_lock);
186 		}
187 
188 	}
189 
190 	result = 0;
191 
192 failed:
193 	return result;
194 }
195 
196 static int saa7164_encoder_initialize(struct saa7164_port *port)
197 {
198 	saa7164_encoder_configure(port);
199 	return 0;
200 }
201 
202 /* -- V4L2 --------------------------------------------------------- */
203 int saa7164_s_std(struct saa7164_port *port, v4l2_std_id id)
204 {
205 	struct saa7164_dev *dev = port->dev;
206 	unsigned int i;
207 
208 	dprintk(DBGLVL_ENC, "%s(id=0x%x)\n", __func__, (u32)id);
209 
210 	for (i = 0; i < ARRAY_SIZE(saa7164_tvnorms); i++) {
211 		if (id & saa7164_tvnorms[i].id)
212 			break;
213 	}
214 	if (i == ARRAY_SIZE(saa7164_tvnorms))
215 		return -EINVAL;
216 
217 	port->encodernorm = saa7164_tvnorms[i];
218 	port->std = id;
219 
220 	/* Update the audio decoder while is not running in
221 	 * auto detect mode.
222 	 */
223 	saa7164_api_set_audio_std(port);
224 
225 	dprintk(DBGLVL_ENC, "%s(id=0x%x) OK\n", __func__, (u32)id);
226 
227 	return 0;
228 }
229 
230 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
231 {
232 	struct saa7164_encoder_fh *fh = file->private_data;
233 
234 	return saa7164_s_std(fh->port, id);
235 }
236 
237 int saa7164_g_std(struct saa7164_port *port, v4l2_std_id *id)
238 {
239 	*id = port->std;
240 	return 0;
241 }
242 
243 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
244 {
245 	struct saa7164_encoder_fh *fh = file->private_data;
246 
247 	return saa7164_g_std(fh->port, id);
248 }
249 
250 int saa7164_enum_input(struct file *file, void *priv, struct v4l2_input *i)
251 {
252 	static const char * const inputs[] = {
253 		"tuner", "composite", "svideo", "aux",
254 		"composite 2", "svideo 2", "aux 2"
255 	};
256 	int n;
257 
258 	if (i->index >= 7)
259 		return -EINVAL;
260 
261 	strcpy(i->name, inputs[i->index]);
262 
263 	if (i->index == 0)
264 		i->type = V4L2_INPUT_TYPE_TUNER;
265 	else
266 		i->type  = V4L2_INPUT_TYPE_CAMERA;
267 
268 	for (n = 0; n < ARRAY_SIZE(saa7164_tvnorms); n++)
269 		i->std |= saa7164_tvnorms[n].id;
270 
271 	return 0;
272 }
273 
274 int saa7164_g_input(struct saa7164_port *port, unsigned int *i)
275 {
276 	struct saa7164_dev *dev = port->dev;
277 
278 	if (saa7164_api_get_videomux(port) != SAA_OK)
279 		return -EIO;
280 
281 	*i = (port->mux_input - 1);
282 
283 	dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, *i);
284 
285 	return 0;
286 }
287 
288 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
289 {
290 	struct saa7164_encoder_fh *fh = file->private_data;
291 
292 	return saa7164_g_input(fh->port, i);
293 }
294 
295 int saa7164_s_input(struct saa7164_port *port, unsigned int i)
296 {
297 	struct saa7164_dev *dev = port->dev;
298 
299 	dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, i);
300 
301 	if (i >= 7)
302 		return -EINVAL;
303 
304 	port->mux_input = i + 1;
305 
306 	if (saa7164_api_set_videomux(port) != SAA_OK)
307 		return -EIO;
308 
309 	return 0;
310 }
311 
312 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
313 {
314 	struct saa7164_encoder_fh *fh = file->private_data;
315 
316 	return saa7164_s_input(fh->port, i);
317 }
318 
319 int saa7164_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
320 {
321 	struct saa7164_encoder_fh *fh = file->private_data;
322 	struct saa7164_port *port = fh->port;
323 	struct saa7164_dev *dev = port->dev;
324 
325 	if (0 != t->index)
326 		return -EINVAL;
327 
328 	strcpy(t->name, "tuner");
329 	t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO;
330 	t->rangelow = SAA7164_TV_MIN_FREQ;
331 	t->rangehigh = SAA7164_TV_MAX_FREQ;
332 
333 	dprintk(DBGLVL_ENC, "VIDIOC_G_TUNER: tuner type %d\n", t->type);
334 
335 	return 0;
336 }
337 
338 int saa7164_s_tuner(struct file *file, void *priv,
339 			   const struct v4l2_tuner *t)
340 {
341 	if (0 != t->index)
342 		return -EINVAL;
343 
344 	/* Update the A/V core */
345 	return 0;
346 }
347 
348 int saa7164_g_frequency(struct saa7164_port *port, struct v4l2_frequency *f)
349 {
350 	if (f->tuner)
351 		return -EINVAL;
352 
353 	f->frequency = port->freq;
354 	return 0;
355 }
356 
357 static int vidioc_g_frequency(struct file *file, void *priv,
358 	struct v4l2_frequency *f)
359 {
360 	struct saa7164_encoder_fh *fh = file->private_data;
361 
362 	return saa7164_g_frequency(fh->port, f);
363 }
364 
365 int saa7164_s_frequency(struct saa7164_port *port,
366 			const struct v4l2_frequency *f)
367 {
368 	struct saa7164_dev *dev = port->dev;
369 	struct saa7164_port *tsport;
370 	struct dvb_frontend *fe;
371 
372 	/* TODO: Pull this for the std */
373 	struct analog_parameters params = {
374 		.mode      = V4L2_TUNER_ANALOG_TV,
375 		.audmode   = V4L2_TUNER_MODE_STEREO,
376 		.std       = port->encodernorm.id,
377 		.frequency = f->frequency
378 	};
379 
380 	/* Stop the encoder */
381 	dprintk(DBGLVL_ENC, "%s() frequency=%d tuner=%d\n", __func__,
382 		f->frequency, f->tuner);
383 
384 	if (f->tuner != 0)
385 		return -EINVAL;
386 
387 	port->freq = clamp(f->frequency,
388 			   SAA7164_TV_MIN_FREQ, SAA7164_TV_MAX_FREQ);
389 
390 	/* Update the hardware */
391 	if (port->nr == SAA7164_PORT_ENC1)
392 		tsport = &dev->ports[SAA7164_PORT_TS1];
393 	else if (port->nr == SAA7164_PORT_ENC2)
394 		tsport = &dev->ports[SAA7164_PORT_TS2];
395 	else
396 		BUG();
397 
398 	fe = tsport->dvb.frontend;
399 
400 	if (fe && fe->ops.tuner_ops.set_analog_params)
401 		fe->ops.tuner_ops.set_analog_params(fe, &params);
402 	else
403 		printk(KERN_ERR "%s() No analog tuner, aborting\n", __func__);
404 
405 	saa7164_encoder_initialize(port);
406 
407 	return 0;
408 }
409 
410 static int vidioc_s_frequency(struct file *file, void *priv,
411 			      const struct v4l2_frequency *f)
412 {
413 	struct saa7164_encoder_fh *fh = file->private_data;
414 
415 	return saa7164_s_frequency(fh->port, f);
416 }
417 
418 static int saa7164_s_ctrl(struct v4l2_ctrl *ctrl)
419 {
420 	struct saa7164_port *port =
421 		container_of(ctrl->handler, struct saa7164_port, ctrl_handler);
422 	struct saa7164_encoder_params *params = &port->encoder_params;
423 	int ret = 0;
424 
425 	switch (ctrl->id) {
426 	case V4L2_CID_BRIGHTNESS:
427 		port->ctl_brightness = ctrl->val;
428 		saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
429 		break;
430 	case V4L2_CID_CONTRAST:
431 		port->ctl_contrast = ctrl->val;
432 		saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
433 		break;
434 	case V4L2_CID_SATURATION:
435 		port->ctl_saturation = ctrl->val;
436 		saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
437 		break;
438 	case V4L2_CID_HUE:
439 		port->ctl_hue = ctrl->val;
440 		saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
441 		break;
442 	case V4L2_CID_SHARPNESS:
443 		port->ctl_sharpness = ctrl->val;
444 		saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
445 		break;
446 	case V4L2_CID_AUDIO_VOLUME:
447 		port->ctl_volume = ctrl->val;
448 		saa7164_api_set_audio_volume(port, port->ctl_volume);
449 		break;
450 	case V4L2_CID_MPEG_VIDEO_BITRATE:
451 		params->bitrate = ctrl->val;
452 		break;
453 	case V4L2_CID_MPEG_STREAM_TYPE:
454 		params->stream_type = ctrl->val;
455 		break;
456 	case V4L2_CID_MPEG_AUDIO_MUTE:
457 		params->ctl_mute = ctrl->val;
458 		ret = saa7164_api_audio_mute(port, params->ctl_mute);
459 		if (ret != SAA_OK) {
460 			printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
461 				ret);
462 			ret = -EIO;
463 		}
464 		break;
465 	case V4L2_CID_MPEG_VIDEO_ASPECT:
466 		params->ctl_aspect = ctrl->val;
467 		ret = saa7164_api_set_aspect_ratio(port);
468 		if (ret != SAA_OK) {
469 			printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
470 				ret);
471 			ret = -EIO;
472 		}
473 		break;
474 	case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
475 		params->bitrate_mode = ctrl->val;
476 		break;
477 	case V4L2_CID_MPEG_VIDEO_B_FRAMES:
478 		params->refdist = ctrl->val;
479 		break;
480 	case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
481 		params->bitrate_peak = ctrl->val;
482 		break;
483 	case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
484 		params->gop_size = ctrl->val;
485 		break;
486 	default:
487 		ret = -EINVAL;
488 	}
489 
490 	return ret;
491 }
492 
493 static int vidioc_querycap(struct file *file, void  *priv,
494 	struct v4l2_capability *cap)
495 {
496 	struct saa7164_encoder_fh *fh = file->private_data;
497 	struct saa7164_port *port = fh->port;
498 	struct saa7164_dev *dev = port->dev;
499 
500 	strcpy(cap->driver, dev->name);
501 	strlcpy(cap->card, saa7164_boards[dev->board].name,
502 		sizeof(cap->card));
503 	sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
504 
505 	cap->device_caps =
506 		V4L2_CAP_VIDEO_CAPTURE |
507 		V4L2_CAP_READWRITE |
508 		V4L2_CAP_TUNER;
509 
510 	cap->capabilities = cap->device_caps |
511 		V4L2_CAP_VBI_CAPTURE |
512 		V4L2_CAP_DEVICE_CAPS;
513 
514 	return 0;
515 }
516 
517 static int vidioc_enum_fmt_vid_cap(struct file *file, void  *priv,
518 	struct v4l2_fmtdesc *f)
519 {
520 	if (f->index != 0)
521 		return -EINVAL;
522 
523 	strlcpy(f->description, "MPEG", sizeof(f->description));
524 	f->pixelformat = V4L2_PIX_FMT_MPEG;
525 
526 	return 0;
527 }
528 
529 static int vidioc_fmt_vid_cap(struct file *file, void *priv,
530 				struct v4l2_format *f)
531 {
532 	struct saa7164_encoder_fh *fh = file->private_data;
533 	struct saa7164_port *port = fh->port;
534 
535 	f->fmt.pix.pixelformat  = V4L2_PIX_FMT_MPEG;
536 	f->fmt.pix.bytesperline = 0;
537 	f->fmt.pix.sizeimage    = SAA7164_SIZEIMAGE;
538 	f->fmt.pix.field        = V4L2_FIELD_INTERLACED;
539 	f->fmt.pix.colorspace   = V4L2_COLORSPACE_SMPTE170M;
540 	f->fmt.pix.width        = port->width;
541 	f->fmt.pix.height       = port->height;
542 	return 0;
543 }
544 
545 static int saa7164_encoder_stop_port(struct saa7164_port *port)
546 {
547 	struct saa7164_dev *dev = port->dev;
548 	int ret;
549 
550 	ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
551 	if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
552 		printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
553 			__func__, ret);
554 		ret = -EIO;
555 	} else {
556 		dprintk(DBGLVL_ENC, "%s()    Stopped\n", __func__);
557 		ret = 0;
558 	}
559 
560 	return ret;
561 }
562 
563 static int saa7164_encoder_acquire_port(struct saa7164_port *port)
564 {
565 	struct saa7164_dev *dev = port->dev;
566 	int ret;
567 
568 	ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
569 	if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
570 		printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
571 			__func__, ret);
572 		ret = -EIO;
573 	} else {
574 		dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
575 		ret = 0;
576 	}
577 
578 	return ret;
579 }
580 
581 static int saa7164_encoder_pause_port(struct saa7164_port *port)
582 {
583 	struct saa7164_dev *dev = port->dev;
584 	int ret;
585 
586 	ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
587 	if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
588 		printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
589 			__func__, ret);
590 		ret = -EIO;
591 	} else {
592 		dprintk(DBGLVL_ENC, "%s()   Paused\n", __func__);
593 		ret = 0;
594 	}
595 
596 	return ret;
597 }
598 
599 /* Firmware is very windows centric, meaning you have to transition
600  * the part through AVStream / KS Windows stages, forwards or backwards.
601  * States are: stopped, acquired (h/w), paused, started.
602  * We have to leave here will all of the soft buffers on the free list,
603  * else the cfg_post() func won't have soft buffers to correctly configure.
604  */
605 static int saa7164_encoder_stop_streaming(struct saa7164_port *port)
606 {
607 	struct saa7164_dev *dev = port->dev;
608 	struct saa7164_buffer *buf;
609 	struct saa7164_user_buffer *ubuf;
610 	struct list_head *c, *n;
611 	int ret;
612 
613 	dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
614 
615 	ret = saa7164_encoder_pause_port(port);
616 	ret = saa7164_encoder_acquire_port(port);
617 	ret = saa7164_encoder_stop_port(port);
618 
619 	dprintk(DBGLVL_ENC, "%s(port=%d) Hardware stopped\n", __func__,
620 		port->nr);
621 
622 	/* Reset the state of any allocated buffer resources */
623 	mutex_lock(&port->dmaqueue_lock);
624 
625 	/* Reset the hard and soft buffer state */
626 	list_for_each_safe(c, n, &port->dmaqueue.list) {
627 		buf = list_entry(c, struct saa7164_buffer, list);
628 		buf->flags = SAA7164_BUFFER_FREE;
629 		buf->pos = 0;
630 	}
631 
632 	list_for_each_safe(c, n, &port->list_buf_used.list) {
633 		ubuf = list_entry(c, struct saa7164_user_buffer, list);
634 		ubuf->pos = 0;
635 		list_move_tail(&ubuf->list, &port->list_buf_free.list);
636 	}
637 
638 	mutex_unlock(&port->dmaqueue_lock);
639 
640 	/* Free any allocated resources */
641 	saa7164_encoder_buffers_dealloc(port);
642 
643 	dprintk(DBGLVL_ENC, "%s(port=%d) Released\n", __func__, port->nr);
644 
645 	return ret;
646 }
647 
648 static int saa7164_encoder_start_streaming(struct saa7164_port *port)
649 {
650 	struct saa7164_dev *dev = port->dev;
651 	int result, ret = 0;
652 
653 	dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
654 
655 	port->done_first_interrupt = 0;
656 
657 	/* allocate all of the PCIe DMA buffer resources on the fly,
658 	 * allowing switching between TS and PS payloads without
659 	 * requiring a complete driver reload.
660 	 */
661 	saa7164_encoder_buffers_alloc(port);
662 
663 	/* Configure the encoder with any cache values */
664 	saa7164_api_set_encoder(port);
665 	saa7164_api_get_encoder(port);
666 
667 	/* Place the empty buffers on the hardware */
668 	saa7164_buffer_cfg_port(port);
669 
670 	/* Acquire the hardware */
671 	result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
672 	if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
673 		printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
674 			__func__, result);
675 
676 		/* Stop the hardware, regardless */
677 		result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
678 		if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
679 			printk(KERN_ERR "%s() acquire/forced stop transition failed, res = 0x%x\n",
680 			       __func__, result);
681 		}
682 		ret = -EIO;
683 		goto out;
684 	} else
685 		dprintk(DBGLVL_ENC, "%s()   Acquired\n", __func__);
686 
687 	/* Pause the hardware */
688 	result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
689 	if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
690 		printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
691 				__func__, result);
692 
693 		/* Stop the hardware, regardless */
694 		result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
695 		if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
696 			printk(KERN_ERR "%s() pause/forced stop transition failed, res = 0x%x\n",
697 			       __func__, result);
698 		}
699 
700 		ret = -EIO;
701 		goto out;
702 	} else
703 		dprintk(DBGLVL_ENC, "%s()   Paused\n", __func__);
704 
705 	/* Start the hardware */
706 	result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
707 	if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
708 		printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
709 				__func__, result);
710 
711 		/* Stop the hardware, regardless */
712 		result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
713 		if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
714 			printk(KERN_ERR "%s() run/forced stop transition failed, res = 0x%x\n",
715 			       __func__, result);
716 		}
717 
718 		ret = -EIO;
719 	} else
720 		dprintk(DBGLVL_ENC, "%s()   Running\n", __func__);
721 
722 out:
723 	return ret;
724 }
725 
726 static int fops_open(struct file *file)
727 {
728 	struct saa7164_dev *dev;
729 	struct saa7164_port *port;
730 	struct saa7164_encoder_fh *fh;
731 
732 	port = (struct saa7164_port *)video_get_drvdata(video_devdata(file));
733 	if (!port)
734 		return -ENODEV;
735 
736 	dev = port->dev;
737 
738 	dprintk(DBGLVL_ENC, "%s()\n", __func__);
739 
740 	/* allocate + initialize per filehandle data */
741 	fh = kzalloc(sizeof(*fh), GFP_KERNEL);
742 	if (NULL == fh)
743 		return -ENOMEM;
744 
745 	fh->port = port;
746 	v4l2_fh_init(&fh->fh, video_devdata(file));
747 	v4l2_fh_add(&fh->fh);
748 	file->private_data = fh;
749 
750 	return 0;
751 }
752 
753 static int fops_release(struct file *file)
754 {
755 	struct saa7164_encoder_fh *fh = file->private_data;
756 	struct saa7164_port *port = fh->port;
757 	struct saa7164_dev *dev = port->dev;
758 
759 	dprintk(DBGLVL_ENC, "%s()\n", __func__);
760 
761 	/* Shut device down on last close */
762 	if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) {
763 		if (atomic_dec_return(&port->v4l_reader_count) == 0) {
764 			/* stop mpeg capture then cancel buffers */
765 			saa7164_encoder_stop_streaming(port);
766 		}
767 	}
768 
769 	v4l2_fh_del(&fh->fh);
770 	v4l2_fh_exit(&fh->fh);
771 	kfree(fh);
772 
773 	return 0;
774 }
775 
776 static struct
777 saa7164_user_buffer *saa7164_enc_next_buf(struct saa7164_port *port)
778 {
779 	struct saa7164_user_buffer *ubuf = NULL;
780 	struct saa7164_dev *dev = port->dev;
781 	u32 crc;
782 
783 	mutex_lock(&port->dmaqueue_lock);
784 	if (!list_empty(&port->list_buf_used.list)) {
785 		ubuf = list_first_entry(&port->list_buf_used.list,
786 			struct saa7164_user_buffer, list);
787 
788 		if (crc_checking) {
789 			crc = crc32(0, ubuf->data, ubuf->actual_size);
790 			if (crc != ubuf->crc) {
791 				printk(KERN_ERR
792 		"%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n",
793 					__func__,
794 					ubuf, ubuf->crc, crc);
795 			}
796 		}
797 
798 	}
799 	mutex_unlock(&port->dmaqueue_lock);
800 
801 	dprintk(DBGLVL_ENC, "%s() returns %p\n", __func__, ubuf);
802 
803 	return ubuf;
804 }
805 
806 static ssize_t fops_read(struct file *file, char __user *buffer,
807 	size_t count, loff_t *pos)
808 {
809 	struct saa7164_encoder_fh *fh = file->private_data;
810 	struct saa7164_port *port = fh->port;
811 	struct saa7164_user_buffer *ubuf = NULL;
812 	struct saa7164_dev *dev = port->dev;
813 	int ret = 0;
814 	int rem, cnt;
815 	u8 *p;
816 
817 	port->last_read_msecs_diff = port->last_read_msecs;
818 	port->last_read_msecs = jiffies_to_msecs(jiffies);
819 	port->last_read_msecs_diff = port->last_read_msecs -
820 		port->last_read_msecs_diff;
821 
822 	saa7164_histogram_update(&port->read_interval,
823 		port->last_read_msecs_diff);
824 
825 	if (*pos) {
826 		printk(KERN_ERR "%s() ESPIPE\n", __func__);
827 		return -ESPIPE;
828 	}
829 
830 	if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
831 		if (atomic_inc_return(&port->v4l_reader_count) == 1) {
832 
833 			if (saa7164_encoder_initialize(port) < 0) {
834 				printk(KERN_ERR "%s() EINVAL\n", __func__);
835 				return -EINVAL;
836 			}
837 
838 			saa7164_encoder_start_streaming(port);
839 			msleep(200);
840 		}
841 	}
842 
843 	/* blocking wait for buffer */
844 	if ((file->f_flags & O_NONBLOCK) == 0) {
845 		if (wait_event_interruptible(port->wait_read,
846 			saa7164_enc_next_buf(port))) {
847 				printk(KERN_ERR "%s() ERESTARTSYS\n", __func__);
848 				return -ERESTARTSYS;
849 		}
850 	}
851 
852 	/* Pull the first buffer from the used list */
853 	ubuf = saa7164_enc_next_buf(port);
854 
855 	while ((count > 0) && ubuf) {
856 
857 		/* set remaining bytes to copy */
858 		rem = ubuf->actual_size - ubuf->pos;
859 		cnt = rem > count ? count : rem;
860 
861 		p = ubuf->data + ubuf->pos;
862 
863 		dprintk(DBGLVL_ENC,
864 			"%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n",
865 			__func__, (int)count, cnt, rem, ubuf, ubuf->pos);
866 
867 		if (copy_to_user(buffer, p, cnt)) {
868 			printk(KERN_ERR "%s() copy_to_user failed\n", __func__);
869 			if (!ret) {
870 				printk(KERN_ERR "%s() EFAULT\n", __func__);
871 				ret = -EFAULT;
872 			}
873 			goto err;
874 		}
875 
876 		ubuf->pos += cnt;
877 		count -= cnt;
878 		buffer += cnt;
879 		ret += cnt;
880 
881 		if (ubuf->pos > ubuf->actual_size)
882 			printk(KERN_ERR "read() pos > actual, huh?\n");
883 
884 		if (ubuf->pos == ubuf->actual_size) {
885 
886 			/* finished with current buffer, take next buffer */
887 
888 			/* Requeue the buffer on the free list */
889 			ubuf->pos = 0;
890 
891 			mutex_lock(&port->dmaqueue_lock);
892 			list_move_tail(&ubuf->list, &port->list_buf_free.list);
893 			mutex_unlock(&port->dmaqueue_lock);
894 
895 			/* Dequeue next */
896 			if ((file->f_flags & O_NONBLOCK) == 0) {
897 				if (wait_event_interruptible(port->wait_read,
898 					saa7164_enc_next_buf(port))) {
899 						break;
900 				}
901 			}
902 			ubuf = saa7164_enc_next_buf(port);
903 		}
904 	}
905 err:
906 	if (!ret && !ubuf)
907 		ret = -EAGAIN;
908 
909 	return ret;
910 }
911 
912 static unsigned int fops_poll(struct file *file, poll_table *wait)
913 {
914 	unsigned long req_events = poll_requested_events(wait);
915 	struct saa7164_encoder_fh *fh =
916 		(struct saa7164_encoder_fh *)file->private_data;
917 	struct saa7164_port *port = fh->port;
918 	unsigned int mask = v4l2_ctrl_poll(file, wait);
919 
920 	port->last_poll_msecs_diff = port->last_poll_msecs;
921 	port->last_poll_msecs = jiffies_to_msecs(jiffies);
922 	port->last_poll_msecs_diff = port->last_poll_msecs -
923 		port->last_poll_msecs_diff;
924 
925 	saa7164_histogram_update(&port->poll_interval,
926 		port->last_poll_msecs_diff);
927 
928 	if (!(req_events & (POLLIN | POLLRDNORM)))
929 		return mask;
930 
931 	if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
932 		if (atomic_inc_return(&port->v4l_reader_count) == 1) {
933 			if (saa7164_encoder_initialize(port) < 0)
934 				return mask | POLLERR;
935 			saa7164_encoder_start_streaming(port);
936 			msleep(200);
937 		}
938 	}
939 
940 	/* Pull the first buffer from the used list */
941 	if (!list_empty(&port->list_buf_used.list))
942 		mask |= POLLIN | POLLRDNORM;
943 
944 	return mask;
945 }
946 
947 static const struct v4l2_ctrl_ops saa7164_ctrl_ops = {
948 	.s_ctrl = saa7164_s_ctrl,
949 };
950 
951 static const struct v4l2_file_operations mpeg_fops = {
952 	.owner		= THIS_MODULE,
953 	.open		= fops_open,
954 	.release	= fops_release,
955 	.read		= fops_read,
956 	.poll		= fops_poll,
957 	.unlocked_ioctl	= video_ioctl2,
958 };
959 
960 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
961 	.vidioc_s_std		 = vidioc_s_std,
962 	.vidioc_g_std		 = vidioc_g_std,
963 	.vidioc_enum_input	 = saa7164_enum_input,
964 	.vidioc_g_input		 = vidioc_g_input,
965 	.vidioc_s_input		 = vidioc_s_input,
966 	.vidioc_g_tuner		 = saa7164_g_tuner,
967 	.vidioc_s_tuner		 = saa7164_s_tuner,
968 	.vidioc_g_frequency	 = vidioc_g_frequency,
969 	.vidioc_s_frequency	 = vidioc_s_frequency,
970 	.vidioc_querycap	 = vidioc_querycap,
971 	.vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
972 	.vidioc_g_fmt_vid_cap	 = vidioc_fmt_vid_cap,
973 	.vidioc_try_fmt_vid_cap	 = vidioc_fmt_vid_cap,
974 	.vidioc_s_fmt_vid_cap	 = vidioc_fmt_vid_cap,
975 	.vidioc_log_status	 = v4l2_ctrl_log_status,
976 	.vidioc_subscribe_event  = v4l2_ctrl_subscribe_event,
977 	.vidioc_unsubscribe_event = v4l2_event_unsubscribe,
978 };
979 
980 static struct video_device saa7164_mpeg_template = {
981 	.name          = "saa7164",
982 	.fops          = &mpeg_fops,
983 	.ioctl_ops     = &mpeg_ioctl_ops,
984 	.minor         = -1,
985 	.tvnorms       = SAA7164_NORMS,
986 };
987 
988 static struct video_device *saa7164_encoder_alloc(
989 	struct saa7164_port *port,
990 	struct pci_dev *pci,
991 	struct video_device *template,
992 	char *type)
993 {
994 	struct video_device *vfd;
995 	struct saa7164_dev *dev = port->dev;
996 
997 	dprintk(DBGLVL_ENC, "%s()\n", __func__);
998 
999 	vfd = video_device_alloc();
1000 	if (NULL == vfd)
1001 		return NULL;
1002 
1003 	*vfd = *template;
1004 	snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
1005 		type, saa7164_boards[dev->board].name);
1006 
1007 	vfd->v4l2_dev  = &dev->v4l2_dev;
1008 	vfd->release = video_device_release;
1009 	return vfd;
1010 }
1011 
1012 int saa7164_encoder_register(struct saa7164_port *port)
1013 {
1014 	struct saa7164_dev *dev = port->dev;
1015 	struct v4l2_ctrl_handler *hdl = &port->ctrl_handler;
1016 	int result = -ENODEV;
1017 
1018 	dprintk(DBGLVL_ENC, "%s()\n", __func__);
1019 
1020 	BUG_ON(port->type != SAA7164_MPEG_ENCODER);
1021 
1022 	/* Sanity check that the PCI configuration space is active */
1023 	if (port->hwcfg.BARLocation == 0) {
1024 		printk(KERN_ERR "%s() failed (errno = %d), NO PCI configuration\n",
1025 			__func__, result);
1026 		result = -ENOMEM;
1027 		goto failed;
1028 	}
1029 
1030 	/* Establish encoder defaults here */
1031 	/* Set default TV standard */
1032 	port->encodernorm = saa7164_tvnorms[0];
1033 	port->width = 720;
1034 	port->mux_input = 1; /* Composite */
1035 	port->video_format = EU_VIDEO_FORMAT_MPEG_2;
1036 	port->audio_format = 0;
1037 	port->video_resolution = 0;
1038 	port->freq = SAA7164_TV_MIN_FREQ;
1039 
1040 	v4l2_ctrl_handler_init(hdl, 14);
1041 	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1042 			  V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1043 	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1044 			  V4L2_CID_CONTRAST, 0, 255, 1, 66);
1045 	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1046 			  V4L2_CID_SATURATION, 0, 255, 1, 62);
1047 	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1048 			  V4L2_CID_HUE, 0, 255, 1, 128);
1049 	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1050 			  V4L2_CID_SHARPNESS, 0x0, 0x0f, 1, 8);
1051 	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1052 			  V4L2_CID_MPEG_AUDIO_MUTE, 0x0, 0x01, 1, 0);
1053 	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1054 			  V4L2_CID_AUDIO_VOLUME, -83, 24, 1, 20);
1055 	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1056 			  V4L2_CID_MPEG_VIDEO_BITRATE,
1057 			  ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
1058 			  100000, ENCODER_DEF_BITRATE);
1059 	v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1060 			       V4L2_CID_MPEG_STREAM_TYPE,
1061 			       V4L2_MPEG_STREAM_TYPE_MPEG2_TS, 0,
1062 			       V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
1063 	v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1064 			       V4L2_CID_MPEG_VIDEO_ASPECT,
1065 			       V4L2_MPEG_VIDEO_ASPECT_221x100, 0,
1066 			       V4L2_MPEG_VIDEO_ASPECT_4x3);
1067 	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1068 			  V4L2_CID_MPEG_VIDEO_GOP_SIZE, 1, 255, 1, 15);
1069 	v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1070 			       V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
1071 			       V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 0,
1072 			       V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
1073 	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1074 			  V4L2_CID_MPEG_VIDEO_B_FRAMES, 1, 3, 1, 1);
1075 	v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1076 			  V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
1077 			  ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
1078 			  100000, ENCODER_DEF_BITRATE);
1079 	if (hdl->error) {
1080 		result = hdl->error;
1081 		goto failed;
1082 	}
1083 
1084 	port->std = V4L2_STD_NTSC_M;
1085 
1086 	if (port->encodernorm.id & V4L2_STD_525_60)
1087 		port->height = 480;
1088 	else
1089 		port->height = 576;
1090 
1091 	/* Allocate and register the video device node */
1092 	port->v4l_device = saa7164_encoder_alloc(port,
1093 		dev->pci, &saa7164_mpeg_template, "mpeg");
1094 
1095 	if (!port->v4l_device) {
1096 		printk(KERN_INFO "%s: can't allocate mpeg device\n",
1097 			dev->name);
1098 		result = -ENOMEM;
1099 		goto failed;
1100 	}
1101 
1102 	port->v4l_device->ctrl_handler = hdl;
1103 	v4l2_ctrl_handler_setup(hdl);
1104 	video_set_drvdata(port->v4l_device, port);
1105 	result = video_register_device(port->v4l_device,
1106 		VFL_TYPE_GRABBER, -1);
1107 	if (result < 0) {
1108 		printk(KERN_INFO "%s: can't register mpeg device\n",
1109 			dev->name);
1110 		/* TODO: We're going to leak here if we don't dealloc
1111 		 The buffers above. The unreg function can't deal wit it.
1112 		*/
1113 		goto failed;
1114 	}
1115 
1116 	printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
1117 		dev->name, port->v4l_device->num);
1118 
1119 	/* Configure the hardware defaults */
1120 	saa7164_api_set_videomux(port);
1121 	saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
1122 	saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
1123 	saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
1124 	saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
1125 	saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
1126 	saa7164_api_audio_mute(port, 0);
1127 	saa7164_api_set_audio_volume(port, 20);
1128 	saa7164_api_set_aspect_ratio(port);
1129 
1130 	/* Disable audio standard detection, it's buggy */
1131 	saa7164_api_set_audio_detection(port, 0);
1132 
1133 	saa7164_api_set_encoder(port);
1134 	saa7164_api_get_encoder(port);
1135 
1136 	result = 0;
1137 failed:
1138 	return result;
1139 }
1140 
1141 void saa7164_encoder_unregister(struct saa7164_port *port)
1142 {
1143 	struct saa7164_dev *dev = port->dev;
1144 
1145 	dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
1146 
1147 	BUG_ON(port->type != SAA7164_MPEG_ENCODER);
1148 
1149 	if (port->v4l_device) {
1150 		if (port->v4l_device->minor != -1)
1151 			video_unregister_device(port->v4l_device);
1152 		else
1153 			video_device_release(port->v4l_device);
1154 
1155 		port->v4l_device = NULL;
1156 	}
1157 	v4l2_ctrl_handler_free(&port->ctrl_handler);
1158 
1159 	dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
1160 }
1161 
1162