1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Driver for the NXP SAA7164 PCIe bridge
5 * Copyright (c) 2010-2015 Steven Toth <stoth@kernellabs.com>
10 #define ENCODER_MAX_BITRATE 6500000
11 #define ENCODER_MIN_BITRATE 1000000
12 #define ENCODER_DEF_BITRATE 5000000
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.
21 * If we ever change this driver to support stream I/O, then this field
22 * will be the size of the streaming buffers.
24 #define SAA7164_SIZEIMAGE (0x10000)
26 static struct saa7164_tvnorm saa7164_tvnorms[] = {
29 .id = V4L2_STD_NTSC_M,
32 .id = V4L2_STD_NTSC_M_JP,
36 /* Take the encoder configuration form the port struct and
37 * flush it to the hardware.
39 static void saa7164_encoder_configure(struct saa7164_port *port)
41 struct saa7164_dev *dev = port->dev;
42 dprintk(DBGLVL_ENC, "%s()\n", __func__);
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;
49 /* Set up the DIF (enable it) for analog mode by default */
50 saa7164_api_initialize_dif(port);
52 /* Configure the correct video standard */
53 saa7164_api_configure_dif(port, port->encodernorm.id);
55 /* Ensure the audio decoder is correct configured */
56 saa7164_api_set_audio_std(port);
59 static int saa7164_encoder_buffers_dealloc(struct saa7164_port *port)
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;
66 /* Remove any allocated buffers */
67 mutex_lock(&port->dmaqueue_lock);
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);
73 saa7164_buffer_dealloc(buf);
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);
80 saa7164_buffer_dealloc_user(ubuf);
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);
87 saa7164_buffer_dealloc_user(ubuf);
90 mutex_unlock(&port->dmaqueue_lock);
91 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
96 /* Dynamic buffer switch at encoder start time */
97 static int saa7164_encoder_buffers_alloc(struct saa7164_port *port)
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;
106 dprintk(DBGLVL_ENC, "%s()\n", __func__);
108 if (port->encoder_params.stream_type ==
109 V4L2_MPEG_STREAM_TYPE_MPEG2_PS) {
111 "%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_PS\n",
113 params->samplesperline = 128;
114 params->numberoflines = 256;
116 params->numpagetables = 2 +
117 ((SAA7164_PS_NUMBER_OF_LINES * 128) / PAGE_SIZE);
119 if (port->encoder_params.stream_type ==
120 V4L2_MPEG_STREAM_TYPE_MPEG2_TS) {
122 "%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_TS\n",
124 params->samplesperline = 188;
125 params->numberoflines = 312;
127 params->numpagetables = 2 +
128 ((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
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;
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 *
146 printk(KERN_ERR "%s() failed (errno = %d), unable to allocate buffer\n",
152 mutex_lock(&port->dmaqueue_lock);
153 list_add_tail(&buf->list, &port->dmaqueue.list);
154 mutex_unlock(&port->dmaqueue_lock);
159 /* Allocate some kernel buffers for copying
162 len = params->numberoflines * params->pitch;
164 if (encoder_buffers < 16)
165 encoder_buffers = 16;
166 if (encoder_buffers > 512)
167 encoder_buffers = 512;
169 for (i = 0; i < encoder_buffers; i++) {
171 ubuf = saa7164_buffer_alloc_user(dev, len);
173 mutex_lock(&port->dmaqueue_lock);
174 list_add_tail(&ubuf->list, &port->list_buf_free.list);
175 mutex_unlock(&port->dmaqueue_lock);
186 static int saa7164_encoder_initialize(struct saa7164_port *port)
188 saa7164_encoder_configure(port);
192 /* -- V4L2 --------------------------------------------------------- */
193 int saa7164_s_std(struct saa7164_port *port, v4l2_std_id id)
195 struct saa7164_dev *dev = port->dev;
198 dprintk(DBGLVL_ENC, "%s(id=0x%x)\n", __func__, (u32)id);
200 for (i = 0; i < ARRAY_SIZE(saa7164_tvnorms); i++) {
201 if (id & saa7164_tvnorms[i].id)
204 if (i == ARRAY_SIZE(saa7164_tvnorms))
207 port->encodernorm = saa7164_tvnorms[i];
210 /* Update the audio decoder while is not running in
213 saa7164_api_set_audio_std(port);
215 dprintk(DBGLVL_ENC, "%s(id=0x%x) OK\n", __func__, (u32)id);
220 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
222 struct saa7164_encoder_fh *fh = file->private_data;
224 return saa7164_s_std(fh->port, id);
227 int saa7164_g_std(struct saa7164_port *port, v4l2_std_id *id)
233 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
235 struct saa7164_encoder_fh *fh = file->private_data;
237 return saa7164_g_std(fh->port, id);
240 int saa7164_enum_input(struct file *file, void *priv, struct v4l2_input *i)
242 static const char * const inputs[] = {
243 "tuner", "composite", "svideo", "aux",
244 "composite 2", "svideo 2", "aux 2"
251 strscpy(i->name, inputs[i->index], sizeof(i->name));
254 i->type = V4L2_INPUT_TYPE_TUNER;
256 i->type = V4L2_INPUT_TYPE_CAMERA;
258 for (n = 0; n < ARRAY_SIZE(saa7164_tvnorms); n++)
259 i->std |= saa7164_tvnorms[n].id;
264 int saa7164_g_input(struct saa7164_port *port, unsigned int *i)
266 struct saa7164_dev *dev = port->dev;
268 if (saa7164_api_get_videomux(port) != SAA_OK)
271 *i = (port->mux_input - 1);
273 dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, *i);
278 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
280 struct saa7164_encoder_fh *fh = file->private_data;
282 return saa7164_g_input(fh->port, i);
285 int saa7164_s_input(struct saa7164_port *port, unsigned int i)
287 struct saa7164_dev *dev = port->dev;
289 dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, i);
294 port->mux_input = i + 1;
296 if (saa7164_api_set_videomux(port) != SAA_OK)
302 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
304 struct saa7164_encoder_fh *fh = file->private_data;
306 return saa7164_s_input(fh->port, i);
309 int saa7164_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
311 struct saa7164_encoder_fh *fh = file->private_data;
312 struct saa7164_port *port = fh->port;
313 struct saa7164_dev *dev = port->dev;
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;
323 dprintk(DBGLVL_ENC, "VIDIOC_G_TUNER: tuner type %d\n", t->type);
328 int saa7164_s_tuner(struct file *file, void *priv,
329 const struct v4l2_tuner *t)
334 /* Update the A/V core */
338 int saa7164_g_frequency(struct saa7164_port *port, struct v4l2_frequency *f)
343 f->frequency = port->freq;
347 static int vidioc_g_frequency(struct file *file, void *priv,
348 struct v4l2_frequency *f)
350 struct saa7164_encoder_fh *fh = file->private_data;
352 return saa7164_g_frequency(fh->port, f);
355 int saa7164_s_frequency(struct saa7164_port *port,
356 const struct v4l2_frequency *f)
358 struct saa7164_dev *dev = port->dev;
359 struct saa7164_port *tsport;
360 struct dvb_frontend *fe;
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
370 /* Stop the encoder */
371 dprintk(DBGLVL_ENC, "%s() frequency=%d tuner=%d\n", __func__,
372 f->frequency, f->tuner);
377 port->freq = clamp(f->frequency,
378 SAA7164_TV_MIN_FREQ, SAA7164_TV_MAX_FREQ);
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];
388 fe = tsport->dvb.frontend;
390 if (fe && fe->ops.tuner_ops.set_analog_params)
391 fe->ops.tuner_ops.set_analog_params(fe, ¶ms);
393 printk(KERN_ERR "%s() No analog tuner, aborting\n", __func__);
395 saa7164_encoder_initialize(port);
400 static int vidioc_s_frequency(struct file *file, void *priv,
401 const struct v4l2_frequency *f)
403 struct saa7164_encoder_fh *fh = file->private_data;
405 return saa7164_s_frequency(fh->port, f);
408 static int saa7164_s_ctrl(struct v4l2_ctrl *ctrl)
410 struct saa7164_port *port =
411 container_of(ctrl->handler, struct saa7164_port, ctrl_handler);
412 struct saa7164_encoder_params *params = &port->encoder_params;
416 case V4L2_CID_BRIGHTNESS:
417 port->ctl_brightness = ctrl->val;
418 saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
420 case V4L2_CID_CONTRAST:
421 port->ctl_contrast = ctrl->val;
422 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
424 case V4L2_CID_SATURATION:
425 port->ctl_saturation = ctrl->val;
426 saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
429 port->ctl_hue = ctrl->val;
430 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
432 case V4L2_CID_SHARPNESS:
433 port->ctl_sharpness = ctrl->val;
434 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
436 case V4L2_CID_AUDIO_VOLUME:
437 port->ctl_volume = ctrl->val;
438 saa7164_api_set_audio_volume(port, port->ctl_volume);
440 case V4L2_CID_MPEG_VIDEO_BITRATE:
441 params->bitrate = ctrl->val;
443 case V4L2_CID_MPEG_STREAM_TYPE:
444 params->stream_type = ctrl->val;
446 case V4L2_CID_MPEG_AUDIO_MUTE:
447 params->ctl_mute = ctrl->val;
448 ret = saa7164_api_audio_mute(port, params->ctl_mute);
450 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
455 case V4L2_CID_MPEG_VIDEO_ASPECT:
456 params->ctl_aspect = ctrl->val;
457 ret = saa7164_api_set_aspect_ratio(port);
459 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
464 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
465 params->bitrate_mode = ctrl->val;
467 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
468 params->refdist = ctrl->val;
470 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
471 params->bitrate_peak = ctrl->val;
473 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
474 params->gop_size = ctrl->val;
483 static int vidioc_querycap(struct file *file, void *priv,
484 struct v4l2_capability *cap)
486 struct saa7164_encoder_fh *fh = file->private_data;
487 struct saa7164_port *port = fh->port;
488 struct saa7164_dev *dev = port->dev;
490 strscpy(cap->driver, dev->name, sizeof(cap->driver));
491 strscpy(cap->card, saa7164_boards[dev->board].name,
493 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
494 V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE |
495 V4L2_CAP_DEVICE_CAPS;
499 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
500 struct v4l2_fmtdesc *f)
505 f->pixelformat = V4L2_PIX_FMT_MPEG;
510 static int vidioc_fmt_vid_cap(struct file *file, void *priv,
511 struct v4l2_format *f)
513 struct saa7164_encoder_fh *fh = file->private_data;
514 struct saa7164_port *port = fh->port;
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;
526 static int saa7164_encoder_stop_port(struct saa7164_port *port)
528 struct saa7164_dev *dev = port->dev;
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",
537 dprintk(DBGLVL_ENC, "%s() Stopped\n", __func__);
544 static int saa7164_encoder_acquire_port(struct saa7164_port *port)
546 struct saa7164_dev *dev = port->dev;
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",
555 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
562 static int saa7164_encoder_pause_port(struct saa7164_port *port)
564 struct saa7164_dev *dev = port->dev;
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",
573 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__);
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.
586 static int saa7164_encoder_stop_streaming(struct saa7164_port *port)
588 struct saa7164_dev *dev = port->dev;
589 struct saa7164_buffer *buf;
590 struct saa7164_user_buffer *ubuf;
591 struct list_head *c, *n;
594 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
596 ret = saa7164_encoder_pause_port(port);
597 ret = saa7164_encoder_acquire_port(port);
598 ret = saa7164_encoder_stop_port(port);
600 dprintk(DBGLVL_ENC, "%s(port=%d) Hardware stopped\n", __func__,
603 /* Reset the state of any allocated buffer resources */
604 mutex_lock(&port->dmaqueue_lock);
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;
613 list_for_each_safe(c, n, &port->list_buf_used.list) {
614 ubuf = list_entry(c, struct saa7164_user_buffer, list);
616 list_move_tail(&ubuf->list, &port->list_buf_free.list);
619 mutex_unlock(&port->dmaqueue_lock);
621 /* Free any allocated resources */
622 saa7164_encoder_buffers_dealloc(port);
624 dprintk(DBGLVL_ENC, "%s(port=%d) Released\n", __func__, port->nr);
629 static int saa7164_encoder_start_streaming(struct saa7164_port *port)
631 struct saa7164_dev *dev = port->dev;
634 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
636 port->done_first_interrupt = 0;
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.
642 saa7164_encoder_buffers_alloc(port);
644 /* Configure the encoder with any cache values */
645 saa7164_api_set_encoder(port);
646 saa7164_api_get_encoder(port);
648 /* Place the empty buffers on the hardware */
649 saa7164_buffer_cfg_port(port);
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",
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",
666 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
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",
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",
684 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__);
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",
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",
701 dprintk(DBGLVL_ENC, "%s() Running\n", __func__);
707 static int fops_open(struct file *file)
709 struct saa7164_dev *dev;
710 struct saa7164_port *port;
711 struct saa7164_encoder_fh *fh;
713 port = (struct saa7164_port *)video_get_drvdata(video_devdata(file));
719 dprintk(DBGLVL_ENC, "%s()\n", __func__);
721 /* allocate + initialize per filehandle data */
722 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
727 v4l2_fh_init(&fh->fh, video_devdata(file));
728 v4l2_fh_add(&fh->fh);
729 file->private_data = fh;
734 static int fops_release(struct file *file)
736 struct saa7164_encoder_fh *fh = file->private_data;
737 struct saa7164_port *port = fh->port;
738 struct saa7164_dev *dev = port->dev;
740 dprintk(DBGLVL_ENC, "%s()\n", __func__);
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);
750 v4l2_fh_del(&fh->fh);
751 v4l2_fh_exit(&fh->fh);
758 saa7164_user_buffer *saa7164_enc_next_buf(struct saa7164_port *port)
760 struct saa7164_user_buffer *ubuf = NULL;
761 struct saa7164_dev *dev = port->dev;
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);
770 crc = crc32(0, ubuf->data, ubuf->actual_size);
771 if (crc != ubuf->crc) {
773 "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n",
775 ubuf, ubuf->crc, crc);
780 mutex_unlock(&port->dmaqueue_lock);
782 dprintk(DBGLVL_ENC, "%s() returns %p\n", __func__, ubuf);
787 static ssize_t fops_read(struct file *file, char __user *buffer,
788 size_t count, loff_t *pos)
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;
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;
803 saa7164_histogram_update(&port->read_interval,
804 port->last_read_msecs_diff);
807 printk(KERN_ERR "%s() ESPIPE\n", __func__);
811 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
812 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
814 if (saa7164_encoder_initialize(port) < 0) {
815 printk(KERN_ERR "%s() EINVAL\n", __func__);
819 saa7164_encoder_start_streaming(port);
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__);
833 /* Pull the first buffer from the used list */
834 ubuf = saa7164_enc_next_buf(port);
836 while ((count > 0) && ubuf) {
838 /* set remaining bytes to copy */
839 rem = ubuf->actual_size - ubuf->pos;
840 cnt = rem > count ? count : rem;
842 p = ubuf->data + ubuf->pos;
845 "%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n",
846 __func__, (int)count, cnt, rem, ubuf, ubuf->pos);
848 if (copy_to_user(buffer, p, cnt)) {
849 printk(KERN_ERR "%s() copy_to_user failed\n", __func__);
851 printk(KERN_ERR "%s() EFAULT\n", __func__);
862 if (ubuf->pos > ubuf->actual_size)
863 printk(KERN_ERR "read() pos > actual, huh?\n");
865 if (ubuf->pos == ubuf->actual_size) {
867 /* finished with current buffer, take next buffer */
869 /* Requeue the buffer on the free list */
872 mutex_lock(&port->dmaqueue_lock);
873 list_move_tail(&ubuf->list, &port->list_buf_free.list);
874 mutex_unlock(&port->dmaqueue_lock);
877 if ((file->f_flags & O_NONBLOCK) == 0) {
878 if (wait_event_interruptible(port->wait_read,
879 saa7164_enc_next_buf(port))) {
883 ubuf = saa7164_enc_next_buf(port);
893 static __poll_t fops_poll(struct file *file, poll_table *wait)
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);
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;
906 saa7164_histogram_update(&port->poll_interval,
907 port->last_poll_msecs_diff);
909 if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
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);
921 /* Pull the first buffer from the used list */
922 if (!list_empty(&port->list_buf_used.list))
923 mask |= EPOLLIN | EPOLLRDNORM;
928 static const struct v4l2_ctrl_ops saa7164_ctrl_ops = {
929 .s_ctrl = saa7164_s_ctrl,
932 static const struct v4l2_file_operations mpeg_fops = {
933 .owner = THIS_MODULE,
935 .release = fops_release,
938 .unlocked_ioctl = video_ioctl2,
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,
961 static struct video_device saa7164_mpeg_template = {
964 .ioctl_ops = &mpeg_ioctl_ops,
966 .tvnorms = SAA7164_NORMS,
967 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
971 static struct video_device *saa7164_encoder_alloc(
972 struct saa7164_port *port,
974 struct video_device *template,
977 struct video_device *vfd;
978 struct saa7164_dev *dev = port->dev;
980 dprintk(DBGLVL_ENC, "%s()\n", __func__);
982 vfd = video_device_alloc();
987 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
988 type, saa7164_boards[dev->board].name);
990 vfd->v4l2_dev = &dev->v4l2_dev;
991 vfd->release = video_device_release;
995 int saa7164_encoder_register(struct saa7164_port *port)
997 struct saa7164_dev *dev = port->dev;
998 struct v4l2_ctrl_handler *hdl = &port->ctrl_handler;
999 int result = -ENODEV;
1001 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1003 BUG_ON(port->type != SAA7164_MPEG_ENCODER);
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",
1013 /* Establish encoder defaults here */
1014 /* Set default TV standard */
1015 port->encodernorm = saa7164_tvnorms[0];
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;
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);
1063 result = hdl->error;
1067 port->std = V4L2_STD_NTSC_M;
1069 if (port->encodernorm.id & V4L2_STD_525_60)
1074 /* Allocate and register the video device node */
1075 port->v4l_device = saa7164_encoder_alloc(port,
1076 dev->pci, &saa7164_mpeg_template, "mpeg");
1078 if (!port->v4l_device) {
1079 printk(KERN_INFO "%s: can't allocate mpeg device\n",
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);
1091 printk(KERN_INFO "%s: can't register mpeg device\n",
1096 printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
1097 dev->name, port->v4l_device->num);
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);
1110 /* Disable audio standard detection, it's buggy */
1111 saa7164_api_set_audio_detection(port, 0);
1113 saa7164_api_set_encoder(port);
1114 saa7164_api_get_encoder(port);
1118 video_device_release(port->v4l_device);
1119 port->v4l_device = NULL;
1121 v4l2_ctrl_handler_free(hdl);
1126 void saa7164_encoder_unregister(struct saa7164_port *port)
1128 struct saa7164_dev *dev = port->dev;
1130 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
1132 BUG_ON(port->type != SAA7164_MPEG_ENCODER);
1134 if (port->v4l_device) {
1135 if (port->v4l_device->minor != -1)
1136 video_unregister_device(port->v4l_device);
1138 video_device_release(port->v4l_device);
1140 port->v4l_device = NULL;
1142 v4l2_ctrl_handler_free(&port->ctrl_handler);
1144 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);