?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
rt2800: initialize BBP_R104 on proper subroutines
[linux/fpc-iii.git] / drivers / media / pci / saa7164 / saa7164-encoder.c
blob0b74fb2300dda8c74a01f3e1b73f901c47207bfd
1 /*
2 * Driver for the NXP SAA7164 PCIe bridge
3 *
4 * Copyright (c) 2010 Steven Toth <stoth@kernellabs.com>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 *
15 * GNU General Public License for more details.
16 *
17 * 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.
20 */
21
22 #include "saa7164.h"
23
24 #define ENCODER_MAX_BITRATE 6500000
25 #define ENCODER_MIN_BITRATE 1000000
26 #define ENCODER_DEF_BITRATE 5000000
27
28 static struct saa7164_tvnorm saa7164_tvnorms[] = {
29 {
30 .name = "NTSC-M",
31 .id = V4L2_STD_NTSC_M,
32 }, {
33 .name = "NTSC-JP",
34 .id = V4L2_STD_NTSC_M_JP,
35 }
36 };
37
38 static const u32 saa7164_v4l2_ctrls[] = {
39 V4L2_CID_BRIGHTNESS,
40 V4L2_CID_CONTRAST,
41 V4L2_CID_SATURATION,
42 V4L2_CID_HUE,
43 V4L2_CID_AUDIO_VOLUME,
44 V4L2_CID_SHARPNESS,
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,
53 0
54 };
55
56 /* Take the encoder configuration form the port struct and
57 * flush it to the hardware.
58 */
59 static void saa7164_encoder_configure(struct saa7164_port *port)
60 {
61 struct saa7164_dev *dev = port->dev;
62 dprintk(DBGLVL_ENC, "%s()\n", __func__);
63
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;
68
69 /* Set up the DIF (enable it) for analog mode by default */
70 saa7164_api_initialize_dif(port);
71
72 /* Configure the correct video standard */
73 saa7164_api_configure_dif(port, port->encodernorm.id);
74
75 /* Ensure the audio decoder is correct configured */
76 saa7164_api_set_audio_std(port);
77 }
78
79 static int saa7164_encoder_buffers_dealloc(struct saa7164_port *port)
80 {
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;
85
86 /* Remove any allocated buffers */
87 mutex_lock(&port->dmaqueue_lock);
88
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);
92 list_del(c);
93 saa7164_buffer_dealloc(buf);
94 }
95
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);
99 list_del(p);
100 saa7164_buffer_dealloc_user(ubuf);
101 }
102
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);
106 list_del(l);
107 saa7164_buffer_dealloc_user(ubuf);
108 }
109
110 mutex_unlock(&port->dmaqueue_lock);
111 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
112
113 return 0;
114 }
115
116 /* Dynamic buffer switch at encoder start time */
117 static int saa7164_encoder_buffers_alloc(struct saa7164_port *port)
118 {
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;
124 int len = 0;
125
126 dprintk(DBGLVL_ENC, "%s()\n", __func__);
127
128 if (port->encoder_params.stream_type ==
129 V4L2_MPEG_STREAM_TYPE_MPEG2_PS) {
130 dprintk(DBGLVL_ENC,
131 "%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_PS\n",
132 __func__);
133 params->samplesperline = 128;
134 params->numberoflines = 256;
135 params->pitch = 128;
136 params->numpagetables = 2 +
137 ((SAA7164_PS_NUMBER_OF_LINES * 128) / PAGE_SIZE);
138 } else
139 if (port->encoder_params.stream_type ==
140 V4L2_MPEG_STREAM_TYPE_MPEG2_TS) {
141 dprintk(DBGLVL_ENC,
142 "%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_TS\n",
143 __func__);
144 params->samplesperline = 188;
145 params->numberoflines = 312;
146 params->pitch = 188;
147 params->numpagetables = 2 +
148 ((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
149 } else
150 BUG();
151
152 /* Init and establish defaults */
153 params->bitspersample = 8;
154 params->linethreshold = 0;
155 params->pagetablelistvirt = NULL;
156 params->pagetablelistphys = NULL;
157 params->numpagetableentries = port->hwcfg.buffercount;
158
159 /* Allocate the PCI resources, buffers (hard) */
160 for (i = 0; i < port->hwcfg.buffercount; i++) {
161 buf = saa7164_buffer_alloc(port,
162 params->numberoflines *
163 params->pitch);
164
165 if (!buf) {
166 printk(KERN_ERR "%s() failed "
167 "(errno = %d), unable to allocate buffer\n",
168 __func__, result);
169 result = -ENOMEM;
170 goto failed;
171 } else {
172
173 mutex_lock(&port->dmaqueue_lock);
174 list_add_tail(&buf->list, &port->dmaqueue.list);
175 mutex_unlock(&port->dmaqueue_lock);
176
177 }
178 }
179
180 /* Allocate some kernel buffers for copying
181 * to userpsace.
182 */
183 len = params->numberoflines * params->pitch;
184
185 if (encoder_buffers < 16)
186 encoder_buffers = 16;
187 if (encoder_buffers > 512)
188 encoder_buffers = 512;
189
190 for (i = 0; i < encoder_buffers; i++) {
191
192 ubuf = saa7164_buffer_alloc_user(dev, len);
193 if (ubuf) {
194 mutex_lock(&port->dmaqueue_lock);
195 list_add_tail(&ubuf->list, &port->list_buf_free.list);
196 mutex_unlock(&port->dmaqueue_lock);
197 }
198
199 }
200
201 result = 0;
202
203 failed:
204 return result;
205 }
206
207 static int saa7164_encoder_initialize(struct saa7164_port *port)
208 {
209 saa7164_encoder_configure(port);
210 return 0;
211 }
212
213 /* -- V4L2 --------------------------------------------------------- */
214 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
215 {
216 struct saa7164_encoder_fh *fh = file->private_data;
217 struct saa7164_port *port = fh->port;
218 struct saa7164_dev *dev = port->dev;
219 unsigned int i;
220
221 dprintk(DBGLVL_ENC, "%s(id=0x%x)\n", __func__, (u32)id);
222
223 for (i = 0; i < ARRAY_SIZE(saa7164_tvnorms); i++) {
224 if (id & saa7164_tvnorms[i].id)
225 break;
226 }
227 if (i == ARRAY_SIZE(saa7164_tvnorms))
228 return -EINVAL;
229
230 port->encodernorm = saa7164_tvnorms[i];
231
232 /* Update the audio decoder while is not running in
233 * auto detect mode.
234 */
235 saa7164_api_set_audio_std(port);
236
237 dprintk(DBGLVL_ENC, "%s(id=0x%x) OK\n", __func__, (u32)id);
238
239 return 0;
240 }
241
242 static int vidioc_enum_input(struct file *file, void *priv,
243 struct v4l2_input *i)
244 {
245 int n;
246
247 char *inputs[] = { "tuner", "composite", "svideo", "aux",
248 "composite 2", "svideo 2", "aux 2" };
249
250 if (i->index >= 7)
251 return -EINVAL;
252
253 strcpy(i->name, inputs[i->index]);
254
255 if (i->index == 0)
256 i->type = V4L2_INPUT_TYPE_TUNER;
257 else
258 i->type = V4L2_INPUT_TYPE_CAMERA;
259
260 for (n = 0; n < ARRAY_SIZE(saa7164_tvnorms); n++)
261 i->std |= saa7164_tvnorms[n].id;
262
263 return 0;
264 }
265
266 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
267 {
268 struct saa7164_encoder_fh *fh = file->private_data;
269 struct saa7164_port *port = fh->port;
270 struct saa7164_dev *dev = port->dev;
271
272 if (saa7164_api_get_videomux(port) != SAA_OK)
273 return -EIO;
274
275 *i = (port->mux_input - 1);
276
277 dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, *i);
278
279 return 0;
280 }
281
282 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
283 {
284 struct saa7164_encoder_fh *fh = file->private_data;
285 struct saa7164_port *port = fh->port;
286 struct saa7164_dev *dev = port->dev;
287
288 dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, i);
289
290 if (i >= 7)
291 return -EINVAL;
292
293 port->mux_input = i + 1;
294
295 if (saa7164_api_set_videomux(port) != SAA_OK)
296 return -EIO;
297
298 return 0;
299 }
300
301 static int vidioc_g_tuner(struct file *file, void *priv,
302 struct v4l2_tuner *t)
303 {
304 struct saa7164_encoder_fh *fh = file->private_data;
305 struct saa7164_port *port = fh->port;
306 struct saa7164_dev *dev = port->dev;
307
308 if (0 != t->index)
309 return -EINVAL;
310
311 strcpy(t->name, "tuner");
312 t->type = V4L2_TUNER_ANALOG_TV;
313 t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO;
314
315 dprintk(DBGLVL_ENC, "VIDIOC_G_TUNER: tuner type %d\n", t->type);
316
317 return 0;
318 }
319
320 static int vidioc_s_tuner(struct file *file, void *priv,
321 const struct v4l2_tuner *t)
322 {
323 /* Update the A/V core */
324 return 0;
325 }
326
327 static int vidioc_g_frequency(struct file *file, void *priv,
328 struct v4l2_frequency *f)
329 {
330 struct saa7164_encoder_fh *fh = file->private_data;
331 struct saa7164_port *port = fh->port;
332
333 f->type = V4L2_TUNER_ANALOG_TV;
334 f->frequency = port->freq;
335
336 return 0;
337 }
338
339 static int vidioc_s_frequency(struct file *file, void *priv,
340 const struct v4l2_frequency *f)
341 {
342 struct saa7164_encoder_fh *fh = file->private_data;
343 struct saa7164_port *port = fh->port;
344 struct saa7164_dev *dev = port->dev;
345 struct saa7164_port *tsport;
346 struct dvb_frontend *fe;
347
348 /* TODO: Pull this for the std */
349 struct analog_parameters params = {
350 .mode = V4L2_TUNER_ANALOG_TV,
351 .audmode = V4L2_TUNER_MODE_STEREO,
352 .std = port->encodernorm.id,
353 .frequency = f->frequency
354 };
355
356 /* Stop the encoder */
357 dprintk(DBGLVL_ENC, "%s() frequency=%d tuner=%d\n", __func__,
358 f->frequency, f->tuner);
359
360 if (f->tuner != 0)
361 return -EINVAL;
362
363 if (f->type != V4L2_TUNER_ANALOG_TV)
364 return -EINVAL;
365
366 port->freq = f->frequency;
367
368 /* Update the hardware */
369 if (port->nr == SAA7164_PORT_ENC1)
370 tsport = &dev->ports[SAA7164_PORT_TS1];
371 else
372 if (port->nr == SAA7164_PORT_ENC2)
373 tsport = &dev->ports[SAA7164_PORT_TS2];
374 else
375 BUG();
376
377 fe = tsport->dvb.frontend;
378
379 if (fe && fe->ops.tuner_ops.set_analog_params)
380 fe->ops.tuner_ops.set_analog_params(fe, &params);
381 else
382 printk(KERN_ERR "%s() No analog tuner, aborting\n", __func__);
383
384 saa7164_encoder_initialize(port);
385
386 return 0;
387 }
388
389 static int vidioc_g_ctrl(struct file *file, void *priv,
390 struct v4l2_control *ctl)
391 {
392 struct saa7164_encoder_fh *fh = file->private_data;
393 struct saa7164_port *port = fh->port;
394 struct saa7164_dev *dev = port->dev;
395
396 dprintk(DBGLVL_ENC, "%s(id=%d, value=%d)\n", __func__,
397 ctl->id, ctl->value);
398
399 switch (ctl->id) {
400 case V4L2_CID_BRIGHTNESS:
401 ctl->value = port->ctl_brightness;
402 break;
403 case V4L2_CID_CONTRAST:
404 ctl->value = port->ctl_contrast;
405 break;
406 case V4L2_CID_SATURATION:
407 ctl->value = port->ctl_saturation;
408 break;
409 case V4L2_CID_HUE:
410 ctl->value = port->ctl_hue;
411 break;
412 case V4L2_CID_SHARPNESS:
413 ctl->value = port->ctl_sharpness;
414 break;
415 case V4L2_CID_AUDIO_VOLUME:
416 ctl->value = port->ctl_volume;
417 break;
418 default:
419 return -EINVAL;
420 }
421
422 return 0;
423 }
424
425 static int vidioc_s_ctrl(struct file *file, void *priv,
426 struct v4l2_control *ctl)
427 {
428 struct saa7164_encoder_fh *fh = file->private_data;
429 struct saa7164_port *port = fh->port;
430 struct saa7164_dev *dev = port->dev;
431 int ret = 0;
432
433 dprintk(DBGLVL_ENC, "%s(id=%d, value=%d)\n", __func__,
434 ctl->id, ctl->value);
435
436 switch (ctl->id) {
437 case V4L2_CID_BRIGHTNESS:
438 if ((ctl->value >= 0) && (ctl->value <= 255)) {
439 port->ctl_brightness = ctl->value;
440 saa7164_api_set_usercontrol(port,
441 PU_BRIGHTNESS_CONTROL);
442 } else
443 ret = -EINVAL;
444 break;
445 case V4L2_CID_CONTRAST:
446 if ((ctl->value >= 0) && (ctl->value <= 255)) {
447 port->ctl_contrast = ctl->value;
448 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
449 } else
450 ret = -EINVAL;
451 break;
452 case V4L2_CID_SATURATION:
453 if ((ctl->value >= 0) && (ctl->value <= 255)) {
454 port->ctl_saturation = ctl->value;
455 saa7164_api_set_usercontrol(port,
456 PU_SATURATION_CONTROL);
457 } else
458 ret = -EINVAL;
459 break;
460 case V4L2_CID_HUE:
461 if ((ctl->value >= 0) && (ctl->value <= 255)) {
462 port->ctl_hue = ctl->value;
463 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
464 } else
465 ret = -EINVAL;
466 break;
467 case V4L2_CID_SHARPNESS:
468 if ((ctl->value >= 0) && (ctl->value <= 255)) {
469 port->ctl_sharpness = ctl->value;
470 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
471 } else
472 ret = -EINVAL;
473 break;
474 case V4L2_CID_AUDIO_VOLUME:
475 if ((ctl->value >= -83) && (ctl->value <= 24)) {
476 port->ctl_volume = ctl->value;
477 saa7164_api_set_audio_volume(port, port->ctl_volume);
478 } else
479 ret = -EINVAL;
480 break;
481 default:
482 ret = -EINVAL;
483 }
484
485 return ret;
486 }
487
488 static int saa7164_get_ctrl(struct saa7164_port *port,
489 struct v4l2_ext_control *ctrl)
490 {
491 struct saa7164_encoder_params *params = &port->encoder_params;
492
493 switch (ctrl->id) {
494 case V4L2_CID_MPEG_VIDEO_BITRATE:
495 ctrl->value = params->bitrate;
496 break;
497 case V4L2_CID_MPEG_STREAM_TYPE:
498 ctrl->value = params->stream_type;
499 break;
500 case V4L2_CID_MPEG_AUDIO_MUTE:
501 ctrl->value = params->ctl_mute;
502 break;
503 case V4L2_CID_MPEG_VIDEO_ASPECT:
504 ctrl->value = params->ctl_aspect;
505 break;
506 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
507 ctrl->value = params->bitrate_mode;
508 break;
509 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
510 ctrl->value = params->refdist;
511 break;
512 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
513 ctrl->value = params->bitrate_peak;
514 break;
515 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
516 ctrl->value = params->gop_size;
517 break;
518 default:
519 return -EINVAL;
520 }
521 return 0;
522 }
523
524 static int vidioc_g_ext_ctrls(struct file *file, void *priv,
525 struct v4l2_ext_controls *ctrls)
526 {
527 struct saa7164_encoder_fh *fh = file->private_data;
528 struct saa7164_port *port = fh->port;
529 int i, err = 0;
530
531 if (ctrls->ctrl_class == V4L2_CTRL_CLASS_MPEG) {
532 for (i = 0; i < ctrls->count; i++) {
533 struct v4l2_ext_control *ctrl = ctrls->controls + i;
534
535 err = saa7164_get_ctrl(port, ctrl);
536 if (err) {
537 ctrls->error_idx = i;
538 break;
539 }
540 }
541 return err;
542
543 }
544
545 return -EINVAL;
546 }
547
548 static int saa7164_try_ctrl(struct v4l2_ext_control *ctrl, int ac3)
549 {
550 int ret = -EINVAL;
551
552 switch (ctrl->id) {
553 case V4L2_CID_MPEG_VIDEO_BITRATE:
554 if ((ctrl->value >= ENCODER_MIN_BITRATE) &&
555 (ctrl->value <= ENCODER_MAX_BITRATE))
556 ret = 0;
557 break;
558 case V4L2_CID_MPEG_STREAM_TYPE:
559 if ((ctrl->value == V4L2_MPEG_STREAM_TYPE_MPEG2_PS) ||
560 (ctrl->value == V4L2_MPEG_STREAM_TYPE_MPEG2_TS))
561 ret = 0;
562 break;
563 case V4L2_CID_MPEG_AUDIO_MUTE:
564 if ((ctrl->value >= 0) &&
565 (ctrl->value <= 1))
566 ret = 0;
567 break;
568 case V4L2_CID_MPEG_VIDEO_ASPECT:
569 if ((ctrl->value >= V4L2_MPEG_VIDEO_ASPECT_1x1) &&
570 (ctrl->value <= V4L2_MPEG_VIDEO_ASPECT_221x100))
571 ret = 0;
572 break;
573 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
574 if ((ctrl->value >= 0) &&
575 (ctrl->value <= 255))
576 ret = 0;
577 break;
578 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
579 if ((ctrl->value == V4L2_MPEG_VIDEO_BITRATE_MODE_VBR) ||
580 (ctrl->value == V4L2_MPEG_VIDEO_BITRATE_MODE_CBR))
581 ret = 0;
582 break;
583 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
584 if ((ctrl->value >= 1) &&
585 (ctrl->value <= 3))
586 ret = 0;
587 break;
588 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
589 if ((ctrl->value >= ENCODER_MIN_BITRATE) &&
590 (ctrl->value <= ENCODER_MAX_BITRATE))
591 ret = 0;
592 break;
593 default:
594 ret = -EINVAL;
595 }
596
597 return ret;
598 }
599
600 static int vidioc_try_ext_ctrls(struct file *file, void *priv,
601 struct v4l2_ext_controls *ctrls)
602 {
603 int i, err = 0;
604
605 if (ctrls->ctrl_class == V4L2_CTRL_CLASS_MPEG) {
606 for (i = 0; i < ctrls->count; i++) {
607 struct v4l2_ext_control *ctrl = ctrls->controls + i;
608
609 err = saa7164_try_ctrl(ctrl, 0);
610 if (err) {
611 ctrls->error_idx = i;
612 break;
613 }
614 }
615 return err;
616 }
617
618 return -EINVAL;
619 }
620
621 static int saa7164_set_ctrl(struct saa7164_port *port,
622 struct v4l2_ext_control *ctrl)
623 {
624 struct saa7164_encoder_params *params = &port->encoder_params;
625 int ret = 0;
626
627 switch (ctrl->id) {
628 case V4L2_CID_MPEG_VIDEO_BITRATE:
629 params->bitrate = ctrl->value;
630 break;
631 case V4L2_CID_MPEG_STREAM_TYPE:
632 params->stream_type = ctrl->value;
633 break;
634 case V4L2_CID_MPEG_AUDIO_MUTE:
635 params->ctl_mute = ctrl->value;
636 ret = saa7164_api_audio_mute(port, params->ctl_mute);
637 if (ret != SAA_OK) {
638 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
639 ret);
640 ret = -EIO;
641 }
642 break;
643 case V4L2_CID_MPEG_VIDEO_ASPECT:
644 params->ctl_aspect = ctrl->value;
645 ret = saa7164_api_set_aspect_ratio(port);
646 if (ret != SAA_OK) {
647 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
648 ret);
649 ret = -EIO;
650 }
651 break;
652 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
653 params->bitrate_mode = ctrl->value;
654 break;
655 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
656 params->refdist = ctrl->value;
657 break;
658 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
659 params->bitrate_peak = ctrl->value;
660 break;
661 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
662 params->gop_size = ctrl->value;
663 break;
664 default:
665 return -EINVAL;
666 }
667
668 /* TODO: Update the hardware */
669
670 return ret;
671 }
672
673 static int vidioc_s_ext_ctrls(struct file *file, void *priv,
674 struct v4l2_ext_controls *ctrls)
675 {
676 struct saa7164_encoder_fh *fh = file->private_data;
677 struct saa7164_port *port = fh->port;
678 int i, err = 0;
679
680 if (ctrls->ctrl_class == V4L2_CTRL_CLASS_MPEG) {
681 for (i = 0; i < ctrls->count; i++) {
682 struct v4l2_ext_control *ctrl = ctrls->controls + i;
683
684 err = saa7164_try_ctrl(ctrl, 0);
685 if (err) {
686 ctrls->error_idx = i;
687 break;
688 }
689 err = saa7164_set_ctrl(port, ctrl);
690 if (err) {
691 ctrls->error_idx = i;
692 break;
693 }
694 }
695 return err;
696
697 }
698
699 return -EINVAL;
700 }
701
702 static int vidioc_querycap(struct file *file, void *priv,
703 struct v4l2_capability *cap)
704 {
705 struct saa7164_encoder_fh *fh = file->private_data;
706 struct saa7164_port *port = fh->port;
707 struct saa7164_dev *dev = port->dev;
708
709 strcpy(cap->driver, dev->name);
710 strlcpy(cap->card, saa7164_boards[dev->board].name,
711 sizeof(cap->card));
712 sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
713
714 cap->capabilities =
715 V4L2_CAP_VIDEO_CAPTURE |
716 V4L2_CAP_READWRITE |
717 0;
718
719 cap->capabilities |= V4L2_CAP_TUNER;
720 cap->version = 0;
721
722 return 0;
723 }
724
725 static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
726 struct v4l2_fmtdesc *f)
727 {
728 if (f->index != 0)
729 return -EINVAL;
730
731 strlcpy(f->description, "MPEG", sizeof(f->description));
732 f->pixelformat = V4L2_PIX_FMT_MPEG;
733
734 return 0;
735 }
736
737 static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
738 struct v4l2_format *f)
739 {
740 struct saa7164_encoder_fh *fh = file->private_data;
741 struct saa7164_port *port = fh->port;
742 struct saa7164_dev *dev = port->dev;
743
744 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
745 f->fmt.pix.bytesperline = 0;
746 f->fmt.pix.sizeimage =
747 port->ts_packet_size * port->ts_packet_count;
748 f->fmt.pix.colorspace = 0;
749 f->fmt.pix.width = port->width;
750 f->fmt.pix.height = port->height;
751
752 dprintk(DBGLVL_ENC, "VIDIOC_G_FMT: w: %d, h: %d\n",
753 port->width, port->height);
754
755 return 0;
756 }
757
758 static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
759 struct v4l2_format *f)
760 {
761 struct saa7164_encoder_fh *fh = file->private_data;
762 struct saa7164_port *port = fh->port;
763 struct saa7164_dev *dev = port->dev;
764
765 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
766 f->fmt.pix.bytesperline = 0;
767 f->fmt.pix.sizeimage =
768 port->ts_packet_size * port->ts_packet_count;
769 f->fmt.pix.colorspace = 0;
770 dprintk(DBGLVL_ENC, "VIDIOC_TRY_FMT: w: %d, h: %d\n",
771 port->width, port->height);
772 return 0;
773 }
774
775 static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
776 struct v4l2_format *f)
777 {
778 struct saa7164_encoder_fh *fh = file->private_data;
779 struct saa7164_port *port = fh->port;
780 struct saa7164_dev *dev = port->dev;
781
782 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
783 f->fmt.pix.bytesperline = 0;
784 f->fmt.pix.sizeimage =
785 port->ts_packet_size * port->ts_packet_count;
786 f->fmt.pix.colorspace = 0;
787
788 dprintk(DBGLVL_ENC, "VIDIOC_S_FMT: w: %d, h: %d, f: %d\n",
789 f->fmt.pix.width, f->fmt.pix.height, f->fmt.pix.field);
790
791 return 0;
792 }
793
794 static int fill_queryctrl(struct saa7164_encoder_params *params,
795 struct v4l2_queryctrl *c)
796 {
797 switch (c->id) {
798 case V4L2_CID_BRIGHTNESS:
799 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 127);
800 case V4L2_CID_CONTRAST:
801 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 66);
802 case V4L2_CID_SATURATION:
803 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 62);
804 case V4L2_CID_HUE:
805 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 128);
806 case V4L2_CID_SHARPNESS:
807 return v4l2_ctrl_query_fill(c, 0x0, 0x0f, 1, 8);
808 case V4L2_CID_MPEG_AUDIO_MUTE:
809 return v4l2_ctrl_query_fill(c, 0x0, 0x01, 1, 0);
810 case V4L2_CID_AUDIO_VOLUME:
811 return v4l2_ctrl_query_fill(c, -83, 24, 1, 20);
812 case V4L2_CID_MPEG_VIDEO_BITRATE:
813 return v4l2_ctrl_query_fill(c,
814 ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
815 100000, ENCODER_DEF_BITRATE);
816 case V4L2_CID_MPEG_STREAM_TYPE:
817 return v4l2_ctrl_query_fill(c,
818 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
819 V4L2_MPEG_STREAM_TYPE_MPEG2_TS,
820 1, V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
821 case V4L2_CID_MPEG_VIDEO_ASPECT:
822 return v4l2_ctrl_query_fill(c,
823 V4L2_MPEG_VIDEO_ASPECT_1x1,
824 V4L2_MPEG_VIDEO_ASPECT_221x100,
825 1, V4L2_MPEG_VIDEO_ASPECT_4x3);
826 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
827 return v4l2_ctrl_query_fill(c, 1, 255, 1, 15);
828 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
829 return v4l2_ctrl_query_fill(c,
830 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
831 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
832 1, V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
833 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
834 return v4l2_ctrl_query_fill(c,
835 1, 3, 1, 1);
836 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
837 return v4l2_ctrl_query_fill(c,
838 ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
839 100000, ENCODER_DEF_BITRATE);
840 default:
841 return -EINVAL;
842 }
843 }
844
845 static int vidioc_queryctrl(struct file *file, void *priv,
846 struct v4l2_queryctrl *c)
847 {
848 struct saa7164_encoder_fh *fh = priv;
849 struct saa7164_port *port = fh->port;
850 int i, next;
851 u32 id = c->id;
852
853 memset(c, 0, sizeof(*c));
854
855 next = !!(id & V4L2_CTRL_FLAG_NEXT_CTRL);
856 c->id = id & ~V4L2_CTRL_FLAG_NEXT_CTRL;
857
858 for (i = 0; i < ARRAY_SIZE(saa7164_v4l2_ctrls); i++) {
859 if (next) {
860 if (c->id < saa7164_v4l2_ctrls[i])
861 c->id = saa7164_v4l2_ctrls[i];
862 else
863 continue;
864 }
865
866 if (c->id == saa7164_v4l2_ctrls[i])
867 return fill_queryctrl(&port->encoder_params, c);
868
869 if (c->id < saa7164_v4l2_ctrls[i])
870 break;
871 }
872
873 return -EINVAL;
874 }
875
876 static int saa7164_encoder_stop_port(struct saa7164_port *port)
877 {
878 struct saa7164_dev *dev = port->dev;
879 int ret;
880
881 ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
882 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
883 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
884 __func__, ret);
885 ret = -EIO;
886 } else {
887 dprintk(DBGLVL_ENC, "%s() Stopped\n", __func__);
888 ret = 0;
889 }
890
891 return ret;
892 }
893
894 static int saa7164_encoder_acquire_port(struct saa7164_port *port)
895 {
896 struct saa7164_dev *dev = port->dev;
897 int ret;
898
899 ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
900 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
901 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
902 __func__, ret);
903 ret = -EIO;
904 } else {
905 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
906 ret = 0;
907 }
908
909 return ret;
910 }
911
912 static int saa7164_encoder_pause_port(struct saa7164_port *port)
913 {
914 struct saa7164_dev *dev = port->dev;
915 int ret;
916
917 ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
918 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
919 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
920 __func__, ret);
921 ret = -EIO;
922 } else {
923 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__);
924 ret = 0;
925 }
926
927 return ret;
928 }
929
930 /* Firmware is very windows centric, meaning you have to transition
931 * the part through AVStream / KS Windows stages, forwards or backwards.
932 * States are: stopped, acquired (h/w), paused, started.
933 * We have to leave here will all of the soft buffers on the free list,
934 * else the cfg_post() func won't have soft buffers to correctly configure.
935 */
936 static int saa7164_encoder_stop_streaming(struct saa7164_port *port)
937 {
938 struct saa7164_dev *dev = port->dev;
939 struct saa7164_buffer *buf;
940 struct saa7164_user_buffer *ubuf;
941 struct list_head *c, *n;
942 int ret;
943
944 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
945
946 ret = saa7164_encoder_pause_port(port);
947 ret = saa7164_encoder_acquire_port(port);
948 ret = saa7164_encoder_stop_port(port);
949
950 dprintk(DBGLVL_ENC, "%s(port=%d) Hardware stopped\n", __func__,
951 port->nr);
952
953 /* Reset the state of any allocated buffer resources */
954 mutex_lock(&port->dmaqueue_lock);
955
956 /* Reset the hard and soft buffer state */
957 list_for_each_safe(c, n, &port->dmaqueue.list) {
958 buf = list_entry(c, struct saa7164_buffer, list);
959 buf->flags = SAA7164_BUFFER_FREE;
960 buf->pos = 0;
961 }
962
963 list_for_each_safe(c, n, &port->list_buf_used.list) {
964 ubuf = list_entry(c, struct saa7164_user_buffer, list);
965 ubuf->pos = 0;
966 list_move_tail(&ubuf->list, &port->list_buf_free.list);
967 }
968
969 mutex_unlock(&port->dmaqueue_lock);
970
971 /* Free any allocated resources */
972 saa7164_encoder_buffers_dealloc(port);
973
974 dprintk(DBGLVL_ENC, "%s(port=%d) Released\n", __func__, port->nr);
975
976 return ret;
977 }
978
979 static int saa7164_encoder_start_streaming(struct saa7164_port *port)
980 {
981 struct saa7164_dev *dev = port->dev;
982 int result, ret = 0;
983
984 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
985
986 port->done_first_interrupt = 0;
987
988 /* allocate all of the PCIe DMA buffer resources on the fly,
989 * allowing switching between TS and PS payloads without
990 * requiring a complete driver reload.
991 */
992 saa7164_encoder_buffers_alloc(port);
993
994 /* Configure the encoder with any cache values */
995 saa7164_api_set_encoder(port);
996 saa7164_api_get_encoder(port);
997
998 /* Place the empty buffers on the hardware */
999 saa7164_buffer_cfg_port(port);
1000
1001 /* Acquire the hardware */
1002 result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
1003 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1004 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
1005 __func__, result);
1006
1007 /* Stop the hardware, regardless */
1008 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
1009 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1010 printk(KERN_ERR "%s() acquire/forced stop transition "
1011 "failed, res = 0x%x\n", __func__, result);
1012 }
1013 ret = -EIO;
1014 goto out;
1015 } else
1016 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
1017
1018 /* Pause the hardware */
1019 result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
1020 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1021 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
1022 __func__, result);
1023
1024 /* Stop the hardware, regardless */
1025 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
1026 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1027 printk(KERN_ERR "%s() pause/forced stop transition "
1028 "failed, res = 0x%x\n", __func__, result);
1029 }
1030
1031 ret = -EIO;
1032 goto out;
1033 } else
1034 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__);
1035
1036 /* Start the hardware */
1037 result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
1038 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1039 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
1040 __func__, result);
1041
1042 /* Stop the hardware, regardless */
1043 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
1044 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1045 printk(KERN_ERR "%s() run/forced stop transition "
1046 "failed, res = 0x%x\n", __func__, result);
1047 }
1048
1049 ret = -EIO;
1050 } else
1051 dprintk(DBGLVL_ENC, "%s() Running\n", __func__);
1052
1053 out:
1054 return ret;
1055 }
1056
1057 static int fops_open(struct file *file)
1058 {
1059 struct saa7164_dev *dev;
1060 struct saa7164_port *port;
1061 struct saa7164_encoder_fh *fh;
1062
1063 port = (struct saa7164_port *)video_get_drvdata(video_devdata(file));
1064 if (!port)
1065 return -ENODEV;
1066
1067 dev = port->dev;
1068
1069 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1070
1071 /* allocate + initialize per filehandle data */
1072 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1073 if (NULL == fh)
1074 return -ENOMEM;
1075
1076 file->private_data = fh;
1077 fh->port = port;
1078
1079 return 0;
1080 }
1081
1082 static int fops_release(struct file *file)
1083 {
1084 struct saa7164_encoder_fh *fh = file->private_data;
1085 struct saa7164_port *port = fh->port;
1086 struct saa7164_dev *dev = port->dev;
1087
1088 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1089
1090 /* Shut device down on last close */
1091 if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) {
1092 if (atomic_dec_return(&port->v4l_reader_count) == 0) {
1093 /* stop mpeg capture then cancel buffers */
1094 saa7164_encoder_stop_streaming(port);
1095 }
1096 }
1097
1098 file->private_data = NULL;
1099 kfree(fh);
1100
1101 return 0;
1102 }
1103
1104 static struct
1105 saa7164_user_buffer *saa7164_enc_next_buf(struct saa7164_port *port)
1106 {
1107 struct saa7164_user_buffer *ubuf = NULL;
1108 struct saa7164_dev *dev = port->dev;
1109 u32 crc;
1110
1111 mutex_lock(&port->dmaqueue_lock);
1112 if (!list_empty(&port->list_buf_used.list)) {
1113 ubuf = list_first_entry(&port->list_buf_used.list,
1114 struct saa7164_user_buffer, list);
1115
1116 if (crc_checking) {
1117 crc = crc32(0, ubuf->data, ubuf->actual_size);
1118 if (crc != ubuf->crc) {
1119 printk(KERN_ERR
1120 "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n",
1121 __func__,
1122 ubuf, ubuf->crc, crc);
1123 }
1124 }
1125
1126 }
1127 mutex_unlock(&port->dmaqueue_lock);
1128
1129 dprintk(DBGLVL_ENC, "%s() returns %p\n", __func__, ubuf);
1130
1131 return ubuf;
1132 }
1133
1134 static ssize_t fops_read(struct file *file, char __user *buffer,
1135 size_t count, loff_t *pos)
1136 {
1137 struct saa7164_encoder_fh *fh = file->private_data;
1138 struct saa7164_port *port = fh->port;
1139 struct saa7164_user_buffer *ubuf = NULL;
1140 struct saa7164_dev *dev = port->dev;
1141 int ret = 0;
1142 int rem, cnt;
1143 u8 *p;
1144
1145 port->last_read_msecs_diff = port->last_read_msecs;
1146 port->last_read_msecs = jiffies_to_msecs(jiffies);
1147 port->last_read_msecs_diff = port->last_read_msecs -
1148 port->last_read_msecs_diff;
1149
1150 saa7164_histogram_update(&port->read_interval,
1151 port->last_read_msecs_diff);
1152
1153 if (*pos) {
1154 printk(KERN_ERR "%s() ESPIPE\n", __func__);
1155 return -ESPIPE;
1156 }
1157
1158 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
1159 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
1160
1161 if (saa7164_encoder_initialize(port) < 0) {
1162 printk(KERN_ERR "%s() EINVAL\n", __func__);
1163 return -EINVAL;
1164 }
1165
1166 saa7164_encoder_start_streaming(port);
1167 msleep(200);
1168 }
1169 }
1170
1171 /* blocking wait for buffer */
1172 if ((file->f_flags & O_NONBLOCK) == 0) {
1173 if (wait_event_interruptible(port->wait_read,
1174 saa7164_enc_next_buf(port))) {
1175 printk(KERN_ERR "%s() ERESTARTSYS\n", __func__);
1176 return -ERESTARTSYS;
1177 }
1178 }
1179
1180 /* Pull the first buffer from the used list */
1181 ubuf = saa7164_enc_next_buf(port);
1182
1183 while ((count > 0) && ubuf) {
1184
1185 /* set remaining bytes to copy */
1186 rem = ubuf->actual_size - ubuf->pos;
1187 cnt = rem > count ? count : rem;
1188
1189 p = ubuf->data + ubuf->pos;
1190
1191 dprintk(DBGLVL_ENC,
1192 "%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n",
1193 __func__, (int)count, cnt, rem, ubuf, ubuf->pos);
1194
1195 if (copy_to_user(buffer, p, cnt)) {
1196 printk(KERN_ERR "%s() copy_to_user failed\n", __func__);
1197 if (!ret) {
1198 printk(KERN_ERR "%s() EFAULT\n", __func__);
1199 ret = -EFAULT;
1200 }
1201 goto err;
1202 }
1203
1204 ubuf->pos += cnt;
1205 count -= cnt;
1206 buffer += cnt;
1207 ret += cnt;
1208
1209 if (ubuf->pos > ubuf->actual_size)
1210 printk(KERN_ERR "read() pos > actual, huh?\n");
1211
1212 if (ubuf->pos == ubuf->actual_size) {
1213
1214 /* finished with current buffer, take next buffer */
1215
1216 /* Requeue the buffer on the free list */
1217 ubuf->pos = 0;
1218
1219 mutex_lock(&port->dmaqueue_lock);
1220 list_move_tail(&ubuf->list, &port->list_buf_free.list);
1221 mutex_unlock(&port->dmaqueue_lock);
1222
1223 /* Dequeue next */
1224 if ((file->f_flags & O_NONBLOCK) == 0) {
1225 if (wait_event_interruptible(port->wait_read,
1226 saa7164_enc_next_buf(port))) {
1227 break;
1228 }
1229 }
1230 ubuf = saa7164_enc_next_buf(port);
1231 }
1232 }
1233 err:
1234 if (!ret && !ubuf)
1235 ret = -EAGAIN;
1236
1237 return ret;
1238 }
1239
1240 static unsigned int fops_poll(struct file *file, poll_table *wait)
1241 {
1242 struct saa7164_encoder_fh *fh =
1243 (struct saa7164_encoder_fh *)file->private_data;
1244 struct saa7164_port *port = fh->port;
1245 unsigned int mask = 0;
1246
1247 port->last_poll_msecs_diff = port->last_poll_msecs;
1248 port->last_poll_msecs = jiffies_to_msecs(jiffies);
1249 port->last_poll_msecs_diff = port->last_poll_msecs -
1250 port->last_poll_msecs_diff;
1251
1252 saa7164_histogram_update(&port->poll_interval,
1253 port->last_poll_msecs_diff);
1254
1255 if (!video_is_registered(port->v4l_device))
1256 return -EIO;
1257
1258 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
1259 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
1260 if (saa7164_encoder_initialize(port) < 0)
1261 return -EINVAL;
1262 saa7164_encoder_start_streaming(port);
1263 msleep(200);
1264 }
1265 }
1266
1267 /* blocking wait for buffer */
1268 if ((file->f_flags & O_NONBLOCK) == 0) {
1269 if (wait_event_interruptible(port->wait_read,
1270 saa7164_enc_next_buf(port))) {
1271 return -ERESTARTSYS;
1272 }
1273 }
1274
1275 /* Pull the first buffer from the used list */
1276 if (!list_empty(&port->list_buf_used.list))
1277 mask |= POLLIN | POLLRDNORM;
1278
1279 return mask;
1280 }
1281
1282 static const struct v4l2_file_operations mpeg_fops = {
1283 .owner = THIS_MODULE,
1284 .open = fops_open,
1285 .release = fops_release,
1286 .read = fops_read,
1287 .poll = fops_poll,
1288 .unlocked_ioctl = video_ioctl2,
1289 };
1290
1291 static int saa7164_g_chip_ident(struct file *file, void *fh,
1292 struct v4l2_dbg_chip_ident *chip)
1293 {
1294 struct saa7164_port *port = ((struct saa7164_encoder_fh *)fh)->port;
1295 struct saa7164_dev *dev = port->dev;
1296 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1297
1298 return 0;
1299 }
1300
1301 #ifdef CONFIG_VIDEO_ADV_DEBUG
1302 static int saa7164_g_register(struct file *file, void *fh,
1303 struct v4l2_dbg_register *reg)
1304 {
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__);
1308
1309 if (!capable(CAP_SYS_ADMIN))
1310 return -EPERM;
1311
1312 return 0;
1313 }
1314
1315 static int saa7164_s_register(struct file *file, void *fh,
1316 const struct v4l2_dbg_register *reg)
1317 {
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__);
1321
1322 if (!capable(CAP_SYS_ADMIN))
1323 return -EPERM;
1324
1325 return 0;
1326 }
1327 #endif
1328
1329 static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
1330 .vidioc_s_std = vidioc_s_std,
1331 .vidioc_enum_input = vidioc_enum_input,
1332 .vidioc_g_input = vidioc_g_input,
1333 .vidioc_s_input = vidioc_s_input,
1334 .vidioc_g_tuner = vidioc_g_tuner,
1335 .vidioc_s_tuner = vidioc_s_tuner,
1336 .vidioc_g_frequency = vidioc_g_frequency,
1337 .vidioc_s_frequency = vidioc_s_frequency,
1338 .vidioc_s_ctrl = vidioc_s_ctrl,
1339 .vidioc_g_ctrl = vidioc_g_ctrl,
1340 .vidioc_querycap = vidioc_querycap,
1341 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1342 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1343 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1344 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1345 .vidioc_g_ext_ctrls = vidioc_g_ext_ctrls,
1346 .vidioc_s_ext_ctrls = vidioc_s_ext_ctrls,
1347 .vidioc_try_ext_ctrls = vidioc_try_ext_ctrls,
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,
1353 #endif
1354 };
1355
1356 static struct video_device saa7164_mpeg_template = {
1357 .name = "saa7164",
1358 .fops = &mpeg_fops,
1359 .ioctl_ops = &mpeg_ioctl_ops,
1360 .minor = -1,
1361 .tvnorms = SAA7164_NORMS,
1362 .current_norm = V4L2_STD_NTSC_M,
1363 };
1364
1365 static struct video_device *saa7164_encoder_alloc(
1366 struct saa7164_port *port,
1367 struct pci_dev *pci,
1368 struct video_device *template,
1369 char *type)
1370 {
1371 struct video_device *vfd;
1372 struct saa7164_dev *dev = port->dev;
1373
1374 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1375
1376 vfd = video_device_alloc();
1377 if (NULL == vfd)
1378 return NULL;
1379
1380 *vfd = *template;
1381 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
1382 type, saa7164_boards[dev->board].name);
1383
1384 vfd->parent = &pci->dev;
1385 vfd->release = video_device_release;
1386 return vfd;
1387 }
1388
1389 int saa7164_encoder_register(struct saa7164_port *port)
1390 {
1391 struct saa7164_dev *dev = port->dev;
1392 int result = -ENODEV;
1393
1394 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1395
1396 if (port->type != SAA7164_MPEG_ENCODER)
1397 BUG();
1398
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",
1403 __func__, result);
1404 result = -ENOMEM;
1405 goto failed;
1406 }
1407
1408 /* Establish encoder defaults here */
1409 /* Set default TV standard */
1410 port->encodernorm = saa7164_tvnorms[0];
1411 port->width = 720;
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;
1429
1430 if (port->encodernorm.id & V4L2_STD_525_60)
1431 port->height = 480;
1432 else
1433 port->height = 576;
1434
1435 /* Allocate and register the video device node */
1436 port->v4l_device = saa7164_encoder_alloc(port,
1437 dev->pci, &saa7164_mpeg_template, "mpeg");
1438
1439 if (!port->v4l_device) {
1440 printk(KERN_INFO "%s: can't allocate mpeg device\n",
1441 dev->name);
1442 result = -ENOMEM;
1443 goto failed;
1444 }
1445
1446 video_set_drvdata(port->v4l_device, port);
1447 result = video_register_device(port->v4l_device,
1448 VFL_TYPE_GRABBER, -1);
1449 if (result < 0) {
1450 printk(KERN_INFO "%s: can't register mpeg device\n",
1451 dev->name);
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.
1454 */
1455 goto failed;
1456 }
1457
1458 printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
1459 dev->name, port->v4l_device->num);
1460
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);
1471
1472 /* Disable audio standard detection, it's buggy */
1473 saa7164_api_set_audio_detection(port, 0);
1474
1475 saa7164_api_set_encoder(port);
1476 saa7164_api_get_encoder(port);
1477
1478 result = 0;
1479 failed:
1480 return result;
1481 }
1482
1483 void saa7164_encoder_unregister(struct saa7164_port *port)
1484 {
1485 struct saa7164_dev *dev = port->dev;
1486
1487 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
1488
1489 if (port->type != SAA7164_MPEG_ENCODER)
1490 BUG();
1491
1492 if (port->v4l_device) {
1493 if (port->v4l_device->minor != -1)
1494 video_unregister_device(port->v4l_device);
1495 else
1496 video_device_release(port->v4l_device);
1497
1498 port->v4l_device = NULL;
1499 }
1500
1501 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
1502 }
1503
Linux with added FPC-III support