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