2 * Driver for the NXP SAA7164 PCIe bridge
4 * Copyright (c) 2010 Steven Toth <stoth@kernellabs.com>
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.
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
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 #define ENCODER_MAX_BITRATE 6500000
25 #define ENCODER_MIN_BITRATE 1000000
26 #define ENCODER_DEF_BITRATE 5000000
28 static struct saa7164_tvnorm saa7164_tvnorms[] = {
31 .id = V4L2_STD_NTSC_M,
34 .id = V4L2_STD_NTSC_M_JP,
38 static const u32 saa7164_v4l2_ctrls[] = {
43 V4L2_CID_AUDIO_VOLUME,
45 V4L2_CID_MPEG_STREAM_TYPE,
46 V4L2_CID_MPEG_VIDEO_ASPECT,
47 V4L2_CID_MPEG_VIDEO_B_FRAMES,
48 V4L2_CID_MPEG_VIDEO_GOP_SIZE,
49 V4L2_CID_MPEG_AUDIO_MUTE,
50 V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
51 V4L2_CID_MPEG_VIDEO_BITRATE,
52 V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
56 /* Take the encoder configuration form the port struct and
57 * flush it to the hardware.
59 static void saa7164_encoder_configure(struct saa7164_port *port)
61 struct saa7164_dev *dev = port->dev;
62 dprintk(DBGLVL_ENC, "%s()\n", __func__);
64 port->encoder_params.width = port->width;
65 port->encoder_params.height = port->height;
66 port->encoder_params.is_50hz =
67 (port->encodernorm.id & V4L2_STD_625_50) != 0;
69 /* Set up the DIF (enable it) for analog mode by default */
70 saa7164_api_initialize_dif(port);
72 /* Configure the correct video standard */
73 saa7164_api_configure_dif(port, port->encodernorm.id);
75 /* Ensure the audio decoder is correct configured */
76 saa7164_api_set_audio_std(port);
79 static int saa7164_encoder_buffers_dealloc(struct saa7164_port *port)
81 struct list_head *c, *n, *p, *q, *l, *v;
82 struct saa7164_dev *dev = port->dev;
83 struct saa7164_buffer *buf;
84 struct saa7164_user_buffer *ubuf;
86 /* Remove any allocated buffers */
87 mutex_lock(&port->dmaqueue_lock);
89 dprintk(DBGLVL_ENC, "%s(port=%d) dmaqueue\n", __func__, port->nr);
90 list_for_each_safe(c, n, &port->dmaqueue.list) {
91 buf = list_entry(c, struct saa7164_buffer, list);
93 saa7164_buffer_dealloc(buf);
96 dprintk(DBGLVL_ENC, "%s(port=%d) used\n", __func__, port->nr);
97 list_for_each_safe(p, q, &port->list_buf_used.list) {
98 ubuf = list_entry(p, struct saa7164_user_buffer, list);
100 saa7164_buffer_dealloc_user(ubuf);
103 dprintk(DBGLVL_ENC, "%s(port=%d) free\n", __func__, port->nr);
104 list_for_each_safe(l, v, &port->list_buf_free.list) {
105 ubuf = list_entry(l, struct saa7164_user_buffer, list);
107 saa7164_buffer_dealloc_user(ubuf);
110 mutex_unlock(&port->dmaqueue_lock);
111 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
116 /* Dynamic buffer switch at encoder start time */
117 static int saa7164_encoder_buffers_alloc(struct saa7164_port *port)
119 struct saa7164_dev *dev = port->dev;
120 struct saa7164_buffer *buf;
121 struct saa7164_user_buffer *ubuf;
122 struct tmHWStreamParameters *params = &port->hw_streamingparams;
123 int result = -ENODEV, i;
126 dprintk(DBGLVL_ENC, "%s()\n", __func__);
128 if (port->encoder_params.stream_type == V4L2_MPEG_STREAM_TYPE_MPEG2_PS) {
129 dprintk(DBGLVL_ENC, "%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_PS\n", __func__);
130 params->samplesperline = 128;
131 params->numberoflines = 256;
133 params->numpagetables = 2 +
134 ((SAA7164_PS_NUMBER_OF_LINES * 128) / PAGE_SIZE);
136 if (port->encoder_params.stream_type == V4L2_MPEG_STREAM_TYPE_MPEG2_TS) {
137 dprintk(DBGLVL_ENC, "%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_TS\n", __func__);
138 params->samplesperline = 188;
139 params->numberoflines = 312;
141 params->numpagetables = 2 +
142 ((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
146 /* Init and establish defaults */
147 params->bitspersample = 8;
148 params->linethreshold = 0;
149 params->pagetablelistvirt = 0;
150 params->pagetablelistphys = 0;
151 params->numpagetableentries = port->hwcfg.buffercount;
153 /* Allocate the PCI resources, buffers (hard) */
154 for (i = 0; i < port->hwcfg.buffercount; i++) {
155 buf = saa7164_buffer_alloc(port,
156 params->numberoflines *
160 printk(KERN_ERR "%s() failed "
161 "(errno = %d), unable to allocate buffer\n",
167 mutex_lock(&port->dmaqueue_lock);
168 list_add_tail(&buf->list, &port->dmaqueue.list);
169 mutex_unlock(&port->dmaqueue_lock);
174 /* Allocate some kenrel kernel buffers for copying
177 len = params->numberoflines * params->pitch;
179 if (encoder_buffers < 16)
180 encoder_buffers = 16;
181 if (encoder_buffers > 512)
182 encoder_buffers = 512;
184 for (i = 0; i < encoder_buffers; i++) {
186 ubuf = saa7164_buffer_alloc_user(dev, len);
188 mutex_lock(&port->dmaqueue_lock);
189 list_add_tail(&ubuf->list, &port->list_buf_free.list);
190 mutex_unlock(&port->dmaqueue_lock);
201 static int saa7164_encoder_initialize(struct saa7164_port *port)
203 saa7164_encoder_configure(port);
207 /* -- V4L2 --------------------------------------------------------- */
208 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id *id)
210 struct saa7164_encoder_fh *fh = file->private_data;
211 struct saa7164_port *port = fh->port;
212 struct saa7164_dev *dev = port->dev;
215 dprintk(DBGLVL_ENC, "%s(id=0x%x)\n", __func__, (u32)*id);
217 for (i = 0; i < ARRAY_SIZE(saa7164_tvnorms); i++) {
218 if (*id & saa7164_tvnorms[i].id)
221 if (i == ARRAY_SIZE(saa7164_tvnorms))
224 port->encodernorm = saa7164_tvnorms[i];
226 /* Update the audio decoder while is not running in
229 saa7164_api_set_audio_std(port);
231 dprintk(DBGLVL_ENC, "%s(id=0x%x) OK\n", __func__, (u32)*id);
236 static int vidioc_enum_input(struct file *file, void *priv,
237 struct v4l2_input *i)
241 char *inputs[] = { "tuner", "composite", "svideo", "aux",
242 "composite 2", "svideo 2", "aux 2" };
247 strcpy(i->name, inputs[i->index]);
250 i->type = V4L2_INPUT_TYPE_TUNER;
252 i->type = V4L2_INPUT_TYPE_CAMERA;
254 for (n = 0; n < ARRAY_SIZE(saa7164_tvnorms); n++)
255 i->std |= saa7164_tvnorms[n].id;
260 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
262 struct saa7164_encoder_fh *fh = file->private_data;
263 struct saa7164_port *port = fh->port;
264 struct saa7164_dev *dev = port->dev;
266 if (saa7164_api_get_videomux(port) != SAA_OK)
269 *i = (port->mux_input - 1);
271 dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, *i);
276 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
278 struct saa7164_encoder_fh *fh = file->private_data;
279 struct saa7164_port *port = fh->port;
280 struct saa7164_dev *dev = port->dev;
282 dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, i);
287 port->mux_input = i + 1;
289 if (saa7164_api_set_videomux(port) != SAA_OK)
295 static int vidioc_g_tuner(struct file *file, void *priv,
296 struct v4l2_tuner *t)
298 struct saa7164_encoder_fh *fh = file->private_data;
299 struct saa7164_port *port = fh->port;
300 struct saa7164_dev *dev = port->dev;
305 strcpy(t->name, "tuner");
306 t->type = V4L2_TUNER_ANALOG_TV;
307 t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO;
309 dprintk(DBGLVL_ENC, "VIDIOC_G_TUNER: tuner type %d\n", t->type);
314 static int vidioc_s_tuner(struct file *file, void *priv,
315 struct v4l2_tuner *t)
317 /* Update the A/V core */
321 static int vidioc_g_frequency(struct file *file, void *priv,
322 struct v4l2_frequency *f)
324 struct saa7164_encoder_fh *fh = file->private_data;
325 struct saa7164_port *port = fh->port;
327 f->type = V4L2_TUNER_ANALOG_TV;
328 f->frequency = port->freq;
333 static int vidioc_s_frequency(struct file *file, void *priv,
334 struct v4l2_frequency *f)
336 struct saa7164_encoder_fh *fh = file->private_data;
337 struct saa7164_port *port = fh->port;
338 struct saa7164_dev *dev = port->dev;
339 struct saa7164_port *tsport;
340 struct dvb_frontend *fe;
342 /* TODO: Pull this for the std */
343 struct analog_parameters params = {
344 .mode = V4L2_TUNER_ANALOG_TV,
345 .audmode = V4L2_TUNER_MODE_STEREO,
346 .std = port->encodernorm.id,
347 .frequency = f->frequency
350 /* Stop the encoder */
351 dprintk(DBGLVL_ENC, "%s() frequency=%d tuner=%d\n", __func__,
352 f->frequency, f->tuner);
357 if (f->type != V4L2_TUNER_ANALOG_TV)
360 port->freq = f->frequency;
362 /* Update the hardware */
363 if (port->nr == SAA7164_PORT_ENC1)
364 tsport = &dev->ports[SAA7164_PORT_TS1];
366 if (port->nr == SAA7164_PORT_ENC2)
367 tsport = &dev->ports[SAA7164_PORT_TS2];
371 fe = tsport->dvb.frontend;
373 if (fe && fe->ops.tuner_ops.set_analog_params)
374 fe->ops.tuner_ops.set_analog_params(fe, ¶ms);
376 printk(KERN_ERR "%s() No analog tuner, aborting\n", __func__);
378 saa7164_encoder_initialize(port);
383 static int vidioc_g_ctrl(struct file *file, void *priv,
384 struct v4l2_control *ctl)
386 struct saa7164_encoder_fh *fh = file->private_data;
387 struct saa7164_port *port = fh->port;
388 struct saa7164_dev *dev = port->dev;
390 dprintk(DBGLVL_ENC, "%s(id=%d, value=%d)\n", __func__,
391 ctl->id, ctl->value);
394 case V4L2_CID_BRIGHTNESS:
395 ctl->value = port->ctl_brightness;
397 case V4L2_CID_CONTRAST:
398 ctl->value = port->ctl_contrast;
400 case V4L2_CID_SATURATION:
401 ctl->value = port->ctl_saturation;
404 ctl->value = port->ctl_hue;
406 case V4L2_CID_SHARPNESS:
407 ctl->value = port->ctl_sharpness;
409 case V4L2_CID_AUDIO_VOLUME:
410 ctl->value = port->ctl_volume;
419 static int vidioc_s_ctrl(struct file *file, void *priv,
420 struct v4l2_control *ctl)
422 struct saa7164_encoder_fh *fh = file->private_data;
423 struct saa7164_port *port = fh->port;
424 struct saa7164_dev *dev = port->dev;
427 dprintk(DBGLVL_ENC, "%s(id=%d, value=%d)\n", __func__,
428 ctl->id, ctl->value);
431 case V4L2_CID_BRIGHTNESS:
432 if ((ctl->value >= 0) && (ctl->value <= 255)) {
433 port->ctl_brightness = ctl->value;
434 saa7164_api_set_usercontrol(port,
435 PU_BRIGHTNESS_CONTROL);
439 case V4L2_CID_CONTRAST:
440 if ((ctl->value >= 0) && (ctl->value <= 255)) {
441 port->ctl_contrast = ctl->value;
442 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
446 case V4L2_CID_SATURATION:
447 if ((ctl->value >= 0) && (ctl->value <= 255)) {
448 port->ctl_saturation = ctl->value;
449 saa7164_api_set_usercontrol(port,
450 PU_SATURATION_CONTROL);
455 if ((ctl->value >= 0) && (ctl->value <= 255)) {
456 port->ctl_hue = ctl->value;
457 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
461 case V4L2_CID_SHARPNESS:
462 if ((ctl->value >= 0) && (ctl->value <= 255)) {
463 port->ctl_sharpness = ctl->value;
464 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
468 case V4L2_CID_AUDIO_VOLUME:
469 if ((ctl->value >= -83) && (ctl->value <= 24)) {
470 port->ctl_volume = ctl->value;
471 saa7164_api_set_audio_volume(port, port->ctl_volume);
482 static int saa7164_get_ctrl(struct saa7164_port *port,
483 struct v4l2_ext_control *ctrl)
485 struct saa7164_encoder_params *params = &port->encoder_params;
488 case V4L2_CID_MPEG_VIDEO_BITRATE:
489 ctrl->value = params->bitrate;
491 case V4L2_CID_MPEG_STREAM_TYPE:
492 ctrl->value = params->stream_type;
494 case V4L2_CID_MPEG_AUDIO_MUTE:
495 ctrl->value = params->ctl_mute;
497 case V4L2_CID_MPEG_VIDEO_ASPECT:
498 ctrl->value = params->ctl_aspect;
500 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
501 ctrl->value = params->bitrate_mode;
503 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
504 ctrl->value = params->refdist;
506 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
507 ctrl->value = params->bitrate_peak;
509 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
510 ctrl->value = params->gop_size;
518 static int vidioc_g_ext_ctrls(struct file *file, void *priv,
519 struct v4l2_ext_controls *ctrls)
521 struct saa7164_encoder_fh *fh = file->private_data;
522 struct saa7164_port *port = fh->port;
525 if (ctrls->ctrl_class == V4L2_CTRL_CLASS_MPEG) {
526 for (i = 0; i < ctrls->count; i++) {
527 struct v4l2_ext_control *ctrl = ctrls->controls + i;
529 err = saa7164_get_ctrl(port, ctrl);
531 ctrls->error_idx = i;
542 static int saa7164_try_ctrl(struct v4l2_ext_control *ctrl, int ac3)
547 case V4L2_CID_MPEG_VIDEO_BITRATE:
548 if ((ctrl->value >= ENCODER_MIN_BITRATE) &&
549 (ctrl->value <= ENCODER_MAX_BITRATE))
552 case V4L2_CID_MPEG_STREAM_TYPE:
553 if ((ctrl->value == V4L2_MPEG_STREAM_TYPE_MPEG2_PS) ||
554 (ctrl->value == V4L2_MPEG_STREAM_TYPE_MPEG2_TS))
557 case V4L2_CID_MPEG_AUDIO_MUTE:
558 if ((ctrl->value >= 0) &&
562 case V4L2_CID_MPEG_VIDEO_ASPECT:
563 if ((ctrl->value >= V4L2_MPEG_VIDEO_ASPECT_1x1) &&
564 (ctrl->value <= V4L2_MPEG_VIDEO_ASPECT_221x100))
567 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
568 if ((ctrl->value >= 0) &&
569 (ctrl->value <= 255))
572 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
573 if ((ctrl->value == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) ||
574 (ctrl->value == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR))
577 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
578 if ((ctrl->value >= 1) &&
582 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
583 if ((ctrl->value >= ENCODER_MIN_BITRATE) &&
584 (ctrl->value <= ENCODER_MAX_BITRATE))
594 static int vidioc_try_ext_ctrls(struct file *file, void *priv,
595 struct v4l2_ext_controls *ctrls)
599 if (ctrls->ctrl_class == V4L2_CTRL_CLASS_MPEG) {
600 for (i = 0; i < ctrls->count; i++) {
601 struct v4l2_ext_control *ctrl = ctrls->controls + i;
603 err = saa7164_try_ctrl(ctrl, 0);
605 ctrls->error_idx = i;
615 static int saa7164_set_ctrl(struct saa7164_port *port,
616 struct v4l2_ext_control *ctrl)
618 struct saa7164_encoder_params *params = &port->encoder_params;
622 case V4L2_CID_MPEG_VIDEO_BITRATE:
623 params->bitrate = ctrl->value;
625 case V4L2_CID_MPEG_STREAM_TYPE:
626 params->stream_type = ctrl->value;
628 case V4L2_CID_MPEG_AUDIO_MUTE:
629 params->ctl_mute = ctrl->value;
630 ret = saa7164_api_audio_mute(port, params->ctl_mute);
632 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
637 case V4L2_CID_MPEG_VIDEO_ASPECT:
638 params->ctl_aspect = ctrl->value;
639 ret = saa7164_api_set_aspect_ratio(port);
641 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
646 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
647 params->bitrate_mode = ctrl->value;
649 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
650 params->refdist = ctrl->value;
652 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
653 params->bitrate_peak = ctrl->value;
655 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
656 params->gop_size = ctrl->value;
662 /* TODO: Update the hardware */
667 static int vidioc_s_ext_ctrls(struct file *file, void *priv,
668 struct v4l2_ext_controls *ctrls)
670 struct saa7164_encoder_fh *fh = file->private_data;
671 struct saa7164_port *port = fh->port;
674 if (ctrls->ctrl_class == V4L2_CTRL_CLASS_MPEG) {
675 for (i = 0; i < ctrls->count; i++) {
676 struct v4l2_ext_control *ctrl = ctrls->controls + i;
678 err = saa7164_try_ctrl(ctrl, 0);
680 ctrls->error_idx = i;
683 err = saa7164_set_ctrl(port, ctrl);
685 ctrls->error_idx = i;
696 static int vidioc_querycap(struct file *file, void *priv,
697 struct v4l2_capability *cap)
699 struct saa7164_encoder_fh *fh = file->private_data;
700 struct saa7164_port *port = fh->port;
701 struct saa7164_dev *dev = port->dev;
703 strcpy(cap->driver, dev->name);
704 strlcpy(cap->card, saa7164_boards[dev->board].name,
706 sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
709 V4L2_CAP_VIDEO_CAPTURE |
713 cap->capabilities |= V4L2_CAP_TUNER;
719 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
720 struct v4l2_fmtdesc *f)
725 strlcpy(f->description, "MPEG", sizeof(f->description));
726 f->pixelformat = V4L2_PIX_FMT_MPEG;
731 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
732 struct v4l2_format *f)
734 struct saa7164_encoder_fh *fh = file->private_data;
735 struct saa7164_port *port = fh->port;
736 struct saa7164_dev *dev = port->dev;
738 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
739 f->fmt.pix.bytesperline = 0;
740 f->fmt.pix.sizeimage =
741 port->ts_packet_size * port->ts_packet_count;
742 f->fmt.pix.colorspace = 0;
743 f->fmt.pix.width = port->width;
744 f->fmt.pix.height = port->height;
746 dprintk(DBGLVL_ENC, "VIDIOC_G_FMT: w: %d, h: %d\n",
747 port->width, port->height);
752 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
753 struct v4l2_format *f)
755 struct saa7164_encoder_fh *fh = file->private_data;
756 struct saa7164_port *port = fh->port;
757 struct saa7164_dev *dev = port->dev;
759 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
760 f->fmt.pix.bytesperline = 0;
761 f->fmt.pix.sizeimage =
762 port->ts_packet_size * port->ts_packet_count;
763 f->fmt.pix.colorspace = 0;
764 dprintk(DBGLVL_ENC, "VIDIOC_TRY_FMT: w: %d, h: %d\n",
765 port->width, port->height);
769 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
770 struct v4l2_format *f)
772 struct saa7164_encoder_fh *fh = file->private_data;
773 struct saa7164_port *port = fh->port;
774 struct saa7164_dev *dev = port->dev;
776 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
777 f->fmt.pix.bytesperline = 0;
778 f->fmt.pix.sizeimage =
779 port->ts_packet_size * port->ts_packet_count;
780 f->fmt.pix.colorspace = 0;
782 dprintk(DBGLVL_ENC, "VIDIOC_S_FMT: w: %d, h: %d, f: %d\n",
783 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
788 static int vidioc_log_status(struct file *file, void *priv)
793 static int fill_queryctrl(struct saa7164_encoder_params *params,
794 struct v4l2_queryctrl *c)
797 case V4L2_CID_BRIGHTNESS:
798 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 127);
799 case V4L2_CID_CONTRAST:
800 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 66);
801 case V4L2_CID_SATURATION:
802 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 62);
804 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 128);
805 case V4L2_CID_SHARPNESS:
806 return v4l2_ctrl_query_fill(c, 0x0, 0x0f, 1, 8);
807 case V4L2_CID_MPEG_AUDIO_MUTE:
808 return v4l2_ctrl_query_fill(c, 0x0, 0x01, 1, 0);
809 case V4L2_CID_AUDIO_VOLUME:
810 return v4l2_ctrl_query_fill(c, -83, 24, 1, 20);
811 case V4L2_CID_MPEG_VIDEO_BITRATE:
812 return v4l2_ctrl_query_fill(c,
813 ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
814 100000, ENCODER_DEF_BITRATE);
815 case V4L2_CID_MPEG_STREAM_TYPE:
816 return v4l2_ctrl_query_fill(c,
817 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
818 V4L2_MPEG_STREAM_TYPE_MPEG2_TS,
819 1, V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
820 case V4L2_CID_MPEG_VIDEO_ASPECT:
821 return v4l2_ctrl_query_fill(c,
822 V4L2_MPEG_VIDEO_ASPECT_1x1,
823 V4L2_MPEG_VIDEO_ASPECT_221x100,
824 1, V4L2_MPEG_VIDEO_ASPECT_4x3);
825 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
826 return v4l2_ctrl_query_fill(c, 1, 255, 1, 15);
827 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
828 return v4l2_ctrl_query_fill(c,
829 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR, V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
830 1, V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
831 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
832 return v4l2_ctrl_query_fill(c,
834 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
835 return v4l2_ctrl_query_fill(c,
836 ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
837 100000, ENCODER_DEF_BITRATE);
843 static int vidioc_queryctrl(struct file *file, void *priv,
844 struct v4l2_queryctrl *c)
846 struct saa7164_encoder_fh *fh = priv;
847 struct saa7164_port *port = fh->port;
851 memset(c, 0, sizeof(*c));
853 next = !!(id & V4L2_CTRL_FLAG_NEXT_CTRL);
854 c->id = id & ~V4L2_CTRL_FLAG_NEXT_CTRL;
856 for (i = 0; i < ARRAY_SIZE(saa7164_v4l2_ctrls); i++) {
858 if (c->id < saa7164_v4l2_ctrls[i])
859 c->id = saa7164_v4l2_ctrls[i];
864 if (c->id == saa7164_v4l2_ctrls[i])
865 return fill_queryctrl(&port->encoder_params, c);
867 if (c->id < saa7164_v4l2_ctrls[i])
874 static int saa7164_encoder_stop_port(struct saa7164_port *port)
876 struct saa7164_dev *dev = port->dev;
879 ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
880 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
881 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
885 dprintk(DBGLVL_ENC, "%s() Stopped\n", __func__);
892 static int saa7164_encoder_acquire_port(struct saa7164_port *port)
894 struct saa7164_dev *dev = port->dev;
897 ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
898 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
899 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
903 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
910 static int saa7164_encoder_pause_port(struct saa7164_port *port)
912 struct saa7164_dev *dev = port->dev;
915 ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
916 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
917 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
921 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__);
928 /* Firmware is very windows centric, meaning you have to transition
929 * the part through AVStream / KS Windows stages, forwards or backwards.
930 * States are: stopped, acquired (h/w), paused, started.
931 * We have to leave here will all of the soft buffers on the free list,
932 * else the cfg_post() func won't have soft buffers to correctly configure.
934 static int saa7164_encoder_stop_streaming(struct saa7164_port *port)
936 struct saa7164_dev *dev = port->dev;
937 struct saa7164_buffer *buf;
938 struct saa7164_user_buffer *ubuf;
939 struct list_head *c, *n;
942 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
944 ret = saa7164_encoder_pause_port(port);
945 ret = saa7164_encoder_acquire_port(port);
946 ret = saa7164_encoder_stop_port(port);
948 dprintk(DBGLVL_ENC, "%s(port=%d) Hardware stopped\n", __func__,
951 /* Reset the state of any allocated buffer resources */
952 mutex_lock(&port->dmaqueue_lock);
954 /* Reset the hard and soft buffer state */
955 list_for_each_safe(c, n, &port->dmaqueue.list) {
956 buf = list_entry(c, struct saa7164_buffer, list);
957 buf->flags = SAA7164_BUFFER_FREE;
961 list_for_each_safe(c, n, &port->list_buf_used.list) {
962 ubuf = list_entry(c, struct saa7164_user_buffer, list);
964 list_move_tail(&ubuf->list, &port->list_buf_free.list);
967 mutex_unlock(&port->dmaqueue_lock);
969 /* Free any allocated resources */
970 saa7164_encoder_buffers_dealloc(port);
972 dprintk(DBGLVL_ENC, "%s(port=%d) Released\n", __func__, port->nr);
977 static int saa7164_encoder_start_streaming(struct saa7164_port *port)
979 struct saa7164_dev *dev = port->dev;
982 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
984 port->done_first_interrupt = 0;
986 /* allocate all of the PCIe DMA buffer resources on the fly,
987 * allowing switching between TS and PS payloads without
988 * requiring a complete driver reload.
990 saa7164_encoder_buffers_alloc(port);
992 /* Configure the encoder with any cache values */
993 saa7164_api_set_encoder(port);
994 saa7164_api_get_encoder(port);
996 /* Place the empty buffers on the hardware */
997 saa7164_buffer_cfg_port(port);
999 /* Acquire the hardware */
1000 result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
1001 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1002 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
1005 /* Stop the hardware, regardless */
1006 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
1007 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1008 printk(KERN_ERR "%s() acquire/forced stop transition "
1009 "failed, res = 0x%x\n", __func__, result);
1014 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
1016 /* Pause the hardware */
1017 result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
1018 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1019 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
1022 /* Stop the hardware, regardless */
1023 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
1024 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1025 printk(KERN_ERR "%s() pause/forced stop transition "
1026 "failed, res = 0x%x\n", __func__, result);
1032 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__);
1034 /* Start the hardware */
1035 result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
1036 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1037 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
1040 /* Stop the hardware, regardless */
1041 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
1042 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1043 printk(KERN_ERR "%s() run/forced stop transition "
1044 "failed, res = 0x%x\n", __func__, result);
1049 dprintk(DBGLVL_ENC, "%s() Running\n", __func__);
1055 static int fops_open(struct file *file)
1057 struct saa7164_dev *dev;
1058 struct saa7164_port *port;
1059 struct saa7164_encoder_fh *fh;
1061 port = (struct saa7164_port *)video_get_drvdata(video_devdata(file));
1067 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1069 /* allocate + initialize per filehandle data */
1070 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1074 file->private_data = fh;
1080 static int fops_release(struct file *file)
1082 struct saa7164_encoder_fh *fh = file->private_data;
1083 struct saa7164_port *port = fh->port;
1084 struct saa7164_dev *dev = port->dev;
1086 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1088 /* Shut device down on last close */
1089 if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) {
1090 if (atomic_dec_return(&port->v4l_reader_count) == 0) {
1091 /* stop mpeg capture then cancel buffers */
1092 saa7164_encoder_stop_streaming(port);
1096 file->private_data = NULL;
1102 struct saa7164_user_buffer *saa7164_enc_next_buf(struct saa7164_port *port)
1104 struct saa7164_user_buffer *ubuf = 0;
1105 struct saa7164_dev *dev = port->dev;
1108 mutex_lock(&port->dmaqueue_lock);
1109 if (!list_empty(&port->list_buf_used.list)) {
1110 ubuf = list_first_entry(&port->list_buf_used.list,
1111 struct saa7164_user_buffer, list);
1114 crc = crc32(0, ubuf->data, ubuf->actual_size);
1115 if (crc != ubuf->crc) {
1116 printk(KERN_ERR "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n", __func__,
1117 ubuf, ubuf->crc, crc);
1122 mutex_unlock(&port->dmaqueue_lock);
1124 dprintk(DBGLVL_ENC, "%s() returns %p\n", __func__, ubuf);
1129 static ssize_t fops_read(struct file *file, char __user *buffer,
1130 size_t count, loff_t *pos)
1132 struct saa7164_encoder_fh *fh = file->private_data;
1133 struct saa7164_port *port = fh->port;
1134 struct saa7164_user_buffer *ubuf = NULL;
1135 struct saa7164_dev *dev = port->dev;
1140 port->last_read_msecs_diff = port->last_read_msecs;
1141 port->last_read_msecs = jiffies_to_msecs(jiffies);
1142 port->last_read_msecs_diff = port->last_read_msecs -
1143 port->last_read_msecs_diff;
1145 saa7164_histogram_update(&port->read_interval,
1146 port->last_read_msecs_diff);
1149 printk(KERN_ERR "%s() ESPIPE\n", __func__);
1153 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
1154 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
1156 if (saa7164_encoder_initialize(port) < 0) {
1157 printk(KERN_ERR "%s() EINVAL\n", __func__);
1161 saa7164_encoder_start_streaming(port);
1166 /* blocking wait for buffer */
1167 if ((file->f_flags & O_NONBLOCK) == 0) {
1168 if (wait_event_interruptible(port->wait_read,
1169 saa7164_enc_next_buf(port))) {
1170 printk(KERN_ERR "%s() ERESTARTSYS\n", __func__);
1171 return -ERESTARTSYS;
1175 /* Pull the first buffer from the used list */
1176 ubuf = saa7164_enc_next_buf(port);
1178 while ((count > 0) && ubuf) {
1180 /* set remaining bytes to copy */
1181 rem = ubuf->actual_size - ubuf->pos;
1182 cnt = rem > count ? count : rem;
1184 p = ubuf->data + ubuf->pos;
1187 "%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n",
1188 __func__, (int)count, cnt, rem, ubuf, ubuf->pos);
1190 if (copy_to_user(buffer, p, cnt)) {
1191 printk(KERN_ERR "%s() copy_to_user failed\n", __func__);
1193 printk(KERN_ERR "%s() EFAULT\n", __func__);
1204 if (ubuf->pos > ubuf->actual_size) {
1205 printk(KERN_ERR "read() pos > actual, huh?\n");
1208 if (ubuf->pos == ubuf->actual_size) {
1210 /* finished with current buffer, take next buffer */
1212 /* Requeue the buffer on the free list */
1215 mutex_lock(&port->dmaqueue_lock);
1216 list_move_tail(&ubuf->list, &port->list_buf_free.list);
1217 mutex_unlock(&port->dmaqueue_lock);
1220 if ((file->f_flags & O_NONBLOCK) == 0) {
1221 if (wait_event_interruptible(port->wait_read,
1222 saa7164_enc_next_buf(port))) {
1226 ubuf = saa7164_enc_next_buf(port);
1230 if (!ret && !ubuf) {
1237 static unsigned int fops_poll(struct file *file, poll_table *wait)
1239 struct saa7164_encoder_fh *fh = (struct saa7164_encoder_fh *)file->private_data;
1240 struct saa7164_port *port = fh->port;
1241 struct saa7164_user_buffer *ubuf;
1242 unsigned int mask = 0;
1244 port->last_poll_msecs_diff = port->last_poll_msecs;
1245 port->last_poll_msecs = jiffies_to_msecs(jiffies);
1246 port->last_poll_msecs_diff = port->last_poll_msecs -
1247 port->last_poll_msecs_diff;
1249 saa7164_histogram_update(&port->poll_interval,
1250 port->last_poll_msecs_diff);
1252 if (!video_is_registered(port->v4l_device)) {
1256 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
1257 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
1258 if (saa7164_encoder_initialize(port) < 0)
1260 saa7164_encoder_start_streaming(port);
1265 /* blocking wait for buffer */
1266 if ((file->f_flags & O_NONBLOCK) == 0) {
1267 if (wait_event_interruptible(port->wait_read,
1268 saa7164_enc_next_buf(port))) {
1269 return -ERESTARTSYS;
1273 /* Pull the first buffer from the used list */
1274 ubuf = list_first_entry(&port->list_buf_used.list,
1275 struct saa7164_user_buffer, list);
1278 mask |= POLLIN | POLLRDNORM;
1283 static const struct v4l2_file_operations mpeg_fops = {
1284 .owner = THIS_MODULE,
1286 .release = fops_release,
1289 .unlocked_ioctl = video_ioctl2,
1292 int saa7164_g_chip_ident(struct file *file, void *fh,
1293 struct v4l2_dbg_chip_ident *chip)
1295 struct saa7164_port *port = ((struct saa7164_encoder_fh *)fh)->port;
1296 struct saa7164_dev *dev = port->dev;
1297 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1302 int saa7164_g_register(struct file *file, void *fh,
1303 struct v4l2_dbg_register *reg)
1305 struct saa7164_port *port = ((struct saa7164_encoder_fh *)fh)->port;
1306 struct saa7164_dev *dev = port->dev;
1307 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1309 if (!capable(CAP_SYS_ADMIN))
1315 int saa7164_s_register(struct file *file, void *fh,
1316 struct v4l2_dbg_register *reg)
1318 struct saa7164_port *port = ((struct saa7164_encoder_fh *)fh)->port;
1319 struct saa7164_dev *dev = port->dev;
1320 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1322 if (!capable(CAP_SYS_ADMIN))
1328 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
1329 .vidioc_s_std = vidioc_s_std,
1330 .vidioc_enum_input = vidioc_enum_input,
1331 .vidioc_g_input = vidioc_g_input,
1332 .vidioc_s_input = vidioc_s_input,
1333 .vidioc_g_tuner = vidioc_g_tuner,
1334 .vidioc_s_tuner = vidioc_s_tuner,
1335 .vidioc_g_frequency = vidioc_g_frequency,
1336 .vidioc_s_frequency = vidioc_s_frequency,
1337 .vidioc_s_ctrl = vidioc_s_ctrl,
1338 .vidioc_g_ctrl = vidioc_g_ctrl,
1339 .vidioc_querycap = vidioc_querycap,
1340 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1341 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1342 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1343 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1344 .vidioc_g_ext_ctrls = vidioc_g_ext_ctrls,
1345 .vidioc_s_ext_ctrls = vidioc_s_ext_ctrls,
1346 .vidioc_try_ext_ctrls = vidioc_try_ext_ctrls,
1347 .vidioc_log_status = vidioc_log_status,
1348 .vidioc_queryctrl = vidioc_queryctrl,
1349 .vidioc_g_chip_ident = saa7164_g_chip_ident,
1350 #ifdef CONFIG_VIDEO_ADV_DEBUG
1351 .vidioc_g_register = saa7164_g_register,
1352 .vidioc_s_register = saa7164_s_register,
1356 static struct video_device saa7164_mpeg_template = {
1359 .ioctl_ops = &mpeg_ioctl_ops,
1361 .tvnorms = SAA7164_NORMS,
1362 .current_norm = V4L2_STD_NTSC_M,
1365 static struct video_device *saa7164_encoder_alloc(
1366 struct saa7164_port *port,
1367 struct pci_dev *pci,
1368 struct video_device *template,
1371 struct video_device *vfd;
1372 struct saa7164_dev *dev = port->dev;
1374 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1376 vfd = video_device_alloc();
1381 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
1382 type, saa7164_boards[dev->board].name);
1384 vfd->parent = &pci->dev;
1385 vfd->release = video_device_release;
1389 int saa7164_encoder_register(struct saa7164_port *port)
1391 struct saa7164_dev *dev = port->dev;
1392 int result = -ENODEV;
1394 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1396 if (port->type != SAA7164_MPEG_ENCODER)
1399 /* Sanity check that the PCI configuration space is active */
1400 if (port->hwcfg.BARLocation == 0) {
1401 printk(KERN_ERR "%s() failed "
1402 "(errno = %d), NO PCI configuration\n",
1408 /* Establish encoder defaults here */
1409 /* Set default TV standard */
1410 port->encodernorm = saa7164_tvnorms[0];
1412 port->mux_input = 1; /* Composite */
1413 port->video_format = EU_VIDEO_FORMAT_MPEG_2;
1414 port->audio_format = 0;
1415 port->video_resolution = 0;
1416 port->ctl_brightness = 127;
1417 port->ctl_contrast = 66;
1418 port->ctl_hue = 128;
1419 port->ctl_saturation = 62;
1420 port->ctl_sharpness = 8;
1421 port->encoder_params.bitrate = ENCODER_DEF_BITRATE;
1422 port->encoder_params.bitrate_peak = ENCODER_DEF_BITRATE;
1423 port->encoder_params.bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
1424 port->encoder_params.stream_type = V4L2_MPEG_STREAM_TYPE_MPEG2_PS;
1425 port->encoder_params.ctl_mute = 0;
1426 port->encoder_params.ctl_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3;
1427 port->encoder_params.refdist = 1;
1428 port->encoder_params.gop_size = SAA7164_ENCODER_DEFAULT_GOP_SIZE;
1430 if (port->encodernorm.id & V4L2_STD_525_60)
1435 /* Allocate and register the video device node */
1436 port->v4l_device = saa7164_encoder_alloc(port,
1437 dev->pci, &saa7164_mpeg_template, "mpeg");
1439 if (port->v4l_device == NULL) {
1440 printk(KERN_INFO "%s: can't allocate mpeg device\n",
1446 video_set_drvdata(port->v4l_device, port);
1447 result = video_register_device(port->v4l_device,
1448 VFL_TYPE_GRABBER, -1);
1450 printk(KERN_INFO "%s: can't register mpeg device\n",
1452 /* TODO: We're going to leak here if we don't dealloc
1453 The buffers above. The unreg function can't deal wit it.
1458 printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
1459 dev->name, port->v4l_device->num);
1461 /* Configure the hardware defaults */
1462 saa7164_api_set_videomux(port);
1463 saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
1464 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
1465 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
1466 saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
1467 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
1468 saa7164_api_audio_mute(port, 0);
1469 saa7164_api_set_audio_volume(port, 20);
1470 saa7164_api_set_aspect_ratio(port);
1472 /* Disable audio standard detection, it's buggy */
1473 saa7164_api_set_audio_detection(port, 0);
1475 saa7164_api_set_encoder(port);
1476 saa7164_api_get_encoder(port);
1483 void saa7164_encoder_unregister(struct saa7164_port *port)
1485 struct saa7164_dev *dev = port->dev;
1487 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
1489 if (port->type != SAA7164_MPEG_ENCODER)
1492 if (port->v4l_device) {
1493 if (port->v4l_device->minor != -1)
1494 video_unregister_device(port->v4l_device);
1496 video_device_release(port->v4l_device);
1498 port->v4l_device = NULL;
1501 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);