1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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
28static 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
38static 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
57
58
59static 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
70 saa7164_api_initialize_dif(port);
71
72
73 saa7164_api_configure_dif(port, port->encodernorm.id);
74
75
76 saa7164_api_set_audio_std(port);
77}
78
79static 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
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
117static 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
153 params->bitspersample = 8;
154 params->linethreshold = 0;
155 params->pagetablelistvirt = 0;
156 params->pagetablelistphys = 0;
157 params->numpagetableentries = port->hwcfg.buffercount;
158
159
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
181
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
203failed:
204 return result;
205}
206
207static int saa7164_encoder_initialize(struct saa7164_port *port)
208{
209 saa7164_encoder_configure(port);
210 return 0;
211}
212
213
214static 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
233
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
242static 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
266static 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
282static 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
301static 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
320static int vidioc_s_tuner(struct file *file, void *priv,
321 struct v4l2_tuner *t)
322{
323
324 return 0;
325}
326
327static 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
339static int vidioc_s_frequency(struct file *file, void *priv,
340 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
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
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
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, ¶ms);
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
389static 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
425static 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
488static 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
524static 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
548static 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
600static 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
621static 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
669
670 return ret;
671}
672
673static 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
702static 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
725static 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
737static 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
758static 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
775static 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
794static int vidioc_log_status(struct file *file, void *priv)
795{
796 return 0;
797}
798
799static int fill_queryctrl(struct saa7164_encoder_params *params,
800 struct v4l2_queryctrl *c)
801{
802 switch (c->id) {
803 case V4L2_CID_BRIGHTNESS:
804 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 127);
805 case V4L2_CID_CONTRAST:
806 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 66);
807 case V4L2_CID_SATURATION:
808 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 62);
809 case V4L2_CID_HUE:
810 return v4l2_ctrl_query_fill(c, 0x0, 0xff, 1, 128);
811 case V4L2_CID_SHARPNESS:
812 return v4l2_ctrl_query_fill(c, 0x0, 0x0f, 1, 8);
813 case V4L2_CID_MPEG_AUDIO_MUTE:
814 return v4l2_ctrl_query_fill(c, 0x0, 0x01, 1, 0);
815 case V4L2_CID_AUDIO_VOLUME:
816 return v4l2_ctrl_query_fill(c, -83, 24, 1, 20);
817 case V4L2_CID_MPEG_VIDEO_BITRATE:
818 return v4l2_ctrl_query_fill(c,
819 ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
820 100000, ENCODER_DEF_BITRATE);
821 case V4L2_CID_MPEG_STREAM_TYPE:
822 return v4l2_ctrl_query_fill(c,
823 V4L2_MPEG_STREAM_TYPE_MPEG2_PS,
824 V4L2_MPEG_STREAM_TYPE_MPEG2_TS,
825 1, V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
826 case V4L2_CID_MPEG_VIDEO_ASPECT:
827 return v4l2_ctrl_query_fill(c,
828 V4L2_MPEG_VIDEO_ASPECT_1x1,
829 V4L2_MPEG_VIDEO_ASPECT_221x100,
830 1, V4L2_MPEG_VIDEO_ASPECT_4x3);
831 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
832 return v4l2_ctrl_query_fill(c, 1, 255, 1, 15);
833 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
834 return v4l2_ctrl_query_fill(c,
835 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR,
836 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR,
837 1, V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
838 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
839 return v4l2_ctrl_query_fill(c,
840 1, 3, 1, 1);
841 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
842 return v4l2_ctrl_query_fill(c,
843 ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
844 100000, ENCODER_DEF_BITRATE);
845 default:
846 return -EINVAL;
847 }
848}
849
850static int vidioc_queryctrl(struct file *file, void *priv,
851 struct v4l2_queryctrl *c)
852{
853 struct saa7164_encoder_fh *fh = priv;
854 struct saa7164_port *port = fh->port;
855 int i, next;
856 u32 id = c->id;
857
858 memset(c, 0, sizeof(*c));
859
860 next = !!(id & V4L2_CTRL_FLAG_NEXT_CTRL);
861 c->id = id & ~V4L2_CTRL_FLAG_NEXT_CTRL;
862
863 for (i = 0; i < ARRAY_SIZE(saa7164_v4l2_ctrls); i++) {
864 if (next) {
865 if (c->id < saa7164_v4l2_ctrls[i])
866 c->id = saa7164_v4l2_ctrls[i];
867 else
868 continue;
869 }
870
871 if (c->id == saa7164_v4l2_ctrls[i])
872 return fill_queryctrl(&port->encoder_params, c);
873
874 if (c->id < saa7164_v4l2_ctrls[i])
875 break;
876 }
877
878 return -EINVAL;
879}
880
881static int saa7164_encoder_stop_port(struct saa7164_port *port)
882{
883 struct saa7164_dev *dev = port->dev;
884 int ret;
885
886 ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
887 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
888 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
889 __func__, ret);
890 ret = -EIO;
891 } else {
892 dprintk(DBGLVL_ENC, "%s() Stopped\n", __func__);
893 ret = 0;
894 }
895
896 return ret;
897}
898
899static int saa7164_encoder_acquire_port(struct saa7164_port *port)
900{
901 struct saa7164_dev *dev = port->dev;
902 int ret;
903
904 ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
905 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
906 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
907 __func__, ret);
908 ret = -EIO;
909 } else {
910 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
911 ret = 0;
912 }
913
914 return ret;
915}
916
917static int saa7164_encoder_pause_port(struct saa7164_port *port)
918{
919 struct saa7164_dev *dev = port->dev;
920 int ret;
921
922 ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
923 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
924 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
925 __func__, ret);
926 ret = -EIO;
927 } else {
928 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__);
929 ret = 0;
930 }
931
932 return ret;
933}
934
935
936
937
938
939
940
941static int saa7164_encoder_stop_streaming(struct saa7164_port *port)
942{
943 struct saa7164_dev *dev = port->dev;
944 struct saa7164_buffer *buf;
945 struct saa7164_user_buffer *ubuf;
946 struct list_head *c, *n;
947 int ret;
948
949 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
950
951 ret = saa7164_encoder_pause_port(port);
952 ret = saa7164_encoder_acquire_port(port);
953 ret = saa7164_encoder_stop_port(port);
954
955 dprintk(DBGLVL_ENC, "%s(port=%d) Hardware stopped\n", __func__,
956 port->nr);
957
958
959 mutex_lock(&port->dmaqueue_lock);
960
961
962 list_for_each_safe(c, n, &port->dmaqueue.list) {
963 buf = list_entry(c, struct saa7164_buffer, list);
964 buf->flags = SAA7164_BUFFER_FREE;
965 buf->pos = 0;
966 }
967
968 list_for_each_safe(c, n, &port->list_buf_used.list) {
969 ubuf = list_entry(c, struct saa7164_user_buffer, list);
970 ubuf->pos = 0;
971 list_move_tail(&ubuf->list, &port->list_buf_free.list);
972 }
973
974 mutex_unlock(&port->dmaqueue_lock);
975
976
977 saa7164_encoder_buffers_dealloc(port);
978
979 dprintk(DBGLVL_ENC, "%s(port=%d) Released\n", __func__, port->nr);
980
981 return ret;
982}
983
984static int saa7164_encoder_start_streaming(struct saa7164_port *port)
985{
986 struct saa7164_dev *dev = port->dev;
987 int result, ret = 0;
988
989 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
990
991 port->done_first_interrupt = 0;
992
993
994
995
996
997 saa7164_encoder_buffers_alloc(port);
998
999
1000 saa7164_api_set_encoder(port);
1001 saa7164_api_get_encoder(port);
1002
1003
1004 saa7164_buffer_cfg_port(port);
1005
1006
1007 result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
1008 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1009 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
1010 __func__, result);
1011
1012
1013 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
1014 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1015 printk(KERN_ERR "%s() acquire/forced stop transition "
1016 "failed, res = 0x%x\n", __func__, result);
1017 }
1018 ret = -EIO;
1019 goto out;
1020 } else
1021 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
1022
1023
1024 result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
1025 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1026 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
1027 __func__, result);
1028
1029
1030 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
1031 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1032 printk(KERN_ERR "%s() pause/forced stop transition "
1033 "failed, res = 0x%x\n", __func__, result);
1034 }
1035
1036 ret = -EIO;
1037 goto out;
1038 } else
1039 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__);
1040
1041
1042 result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
1043 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1044 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
1045 __func__, result);
1046
1047
1048 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
1049 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
1050 printk(KERN_ERR "%s() run/forced stop transition "
1051 "failed, res = 0x%x\n", __func__, result);
1052 }
1053
1054 ret = -EIO;
1055 } else
1056 dprintk(DBGLVL_ENC, "%s() Running\n", __func__);
1057
1058out:
1059 return ret;
1060}
1061
1062static int fops_open(struct file *file)
1063{
1064 struct saa7164_dev *dev;
1065 struct saa7164_port *port;
1066 struct saa7164_encoder_fh *fh;
1067
1068 port = (struct saa7164_port *)video_get_drvdata(video_devdata(file));
1069 if (!port)
1070 return -ENODEV;
1071
1072 dev = port->dev;
1073
1074 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1075
1076
1077 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
1078 if (NULL == fh)
1079 return -ENOMEM;
1080
1081 file->private_data = fh;
1082 fh->port = port;
1083
1084 return 0;
1085}
1086
1087static int fops_release(struct file *file)
1088{
1089 struct saa7164_encoder_fh *fh = file->private_data;
1090 struct saa7164_port *port = fh->port;
1091 struct saa7164_dev *dev = port->dev;
1092
1093 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1094
1095
1096 if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) {
1097 if (atomic_dec_return(&port->v4l_reader_count) == 0) {
1098
1099 saa7164_encoder_stop_streaming(port);
1100 }
1101 }
1102
1103 file->private_data = NULL;
1104 kfree(fh);
1105
1106 return 0;
1107}
1108
1109struct saa7164_user_buffer *saa7164_enc_next_buf(struct saa7164_port *port)
1110{
1111 struct saa7164_user_buffer *ubuf = 0;
1112 struct saa7164_dev *dev = port->dev;
1113 u32 crc;
1114
1115 mutex_lock(&port->dmaqueue_lock);
1116 if (!list_empty(&port->list_buf_used.list)) {
1117 ubuf = list_first_entry(&port->list_buf_used.list,
1118 struct saa7164_user_buffer, list);
1119
1120 if (crc_checking) {
1121 crc = crc32(0, ubuf->data, ubuf->actual_size);
1122 if (crc != ubuf->crc) {
1123 printk(KERN_ERR
1124 "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n",
1125 __func__,
1126 ubuf, ubuf->crc, crc);
1127 }
1128 }
1129
1130 }
1131 mutex_unlock(&port->dmaqueue_lock);
1132
1133 dprintk(DBGLVL_ENC, "%s() returns %p\n", __func__, ubuf);
1134
1135 return ubuf;
1136}
1137
1138static ssize_t fops_read(struct file *file, char __user *buffer,
1139 size_t count, loff_t *pos)
1140{
1141 struct saa7164_encoder_fh *fh = file->private_data;
1142 struct saa7164_port *port = fh->port;
1143 struct saa7164_user_buffer *ubuf = NULL;
1144 struct saa7164_dev *dev = port->dev;
1145 int ret = 0;
1146 int rem, cnt;
1147 u8 *p;
1148
1149 port->last_read_msecs_diff = port->last_read_msecs;
1150 port->last_read_msecs = jiffies_to_msecs(jiffies);
1151 port->last_read_msecs_diff = port->last_read_msecs -
1152 port->last_read_msecs_diff;
1153
1154 saa7164_histogram_update(&port->read_interval,
1155 port->last_read_msecs_diff);
1156
1157 if (*pos) {
1158 printk(KERN_ERR "%s() ESPIPE\n", __func__);
1159 return -ESPIPE;
1160 }
1161
1162 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
1163 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
1164
1165 if (saa7164_encoder_initialize(port) < 0) {
1166 printk(KERN_ERR "%s() EINVAL\n", __func__);
1167 return -EINVAL;
1168 }
1169
1170 saa7164_encoder_start_streaming(port);
1171 msleep(200);
1172 }
1173 }
1174
1175
1176 if ((file->f_flags & O_NONBLOCK) == 0) {
1177 if (wait_event_interruptible(port->wait_read,
1178 saa7164_enc_next_buf(port))) {
1179 printk(KERN_ERR "%s() ERESTARTSYS\n", __func__);
1180 return -ERESTARTSYS;
1181 }
1182 }
1183
1184
1185 ubuf = saa7164_enc_next_buf(port);
1186
1187 while ((count > 0) && ubuf) {
1188
1189
1190 rem = ubuf->actual_size - ubuf->pos;
1191 cnt = rem > count ? count : rem;
1192
1193 p = ubuf->data + ubuf->pos;
1194
1195 dprintk(DBGLVL_ENC,
1196 "%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n",
1197 __func__, (int)count, cnt, rem, ubuf, ubuf->pos);
1198
1199 if (copy_to_user(buffer, p, cnt)) {
1200 printk(KERN_ERR "%s() copy_to_user failed\n", __func__);
1201 if (!ret) {
1202 printk(KERN_ERR "%s() EFAULT\n", __func__);
1203 ret = -EFAULT;
1204 }
1205 goto err;
1206 }
1207
1208 ubuf->pos += cnt;
1209 count -= cnt;
1210 buffer += cnt;
1211 ret += cnt;
1212
1213 if (ubuf->pos > ubuf->actual_size)
1214 printk(KERN_ERR "read() pos > actual, huh?\n");
1215
1216 if (ubuf->pos == ubuf->actual_size) {
1217
1218
1219
1220
1221 ubuf->pos = 0;
1222
1223 mutex_lock(&port->dmaqueue_lock);
1224 list_move_tail(&ubuf->list, &port->list_buf_free.list);
1225 mutex_unlock(&port->dmaqueue_lock);
1226
1227
1228 if ((file->f_flags & O_NONBLOCK) == 0) {
1229 if (wait_event_interruptible(port->wait_read,
1230 saa7164_enc_next_buf(port))) {
1231 break;
1232 }
1233 }
1234 ubuf = saa7164_enc_next_buf(port);
1235 }
1236 }
1237err:
1238 if (!ret && !ubuf)
1239 ret = -EAGAIN;
1240
1241 return ret;
1242}
1243
1244static unsigned int fops_poll(struct file *file, poll_table *wait)
1245{
1246 struct saa7164_encoder_fh *fh =
1247 (struct saa7164_encoder_fh *)file->private_data;
1248 struct saa7164_port *port = fh->port;
1249 struct saa7164_user_buffer *ubuf;
1250 unsigned int mask = 0;
1251
1252 port->last_poll_msecs_diff = port->last_poll_msecs;
1253 port->last_poll_msecs = jiffies_to_msecs(jiffies);
1254 port->last_poll_msecs_diff = port->last_poll_msecs -
1255 port->last_poll_msecs_diff;
1256
1257 saa7164_histogram_update(&port->poll_interval,
1258 port->last_poll_msecs_diff);
1259
1260 if (!video_is_registered(port->v4l_device))
1261 return -EIO;
1262
1263 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
1264 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
1265 if (saa7164_encoder_initialize(port) < 0)
1266 return -EINVAL;
1267 saa7164_encoder_start_streaming(port);
1268 msleep(200);
1269 }
1270 }
1271
1272
1273 if ((file->f_flags & O_NONBLOCK) == 0) {
1274 if (wait_event_interruptible(port->wait_read,
1275 saa7164_enc_next_buf(port))) {
1276 return -ERESTARTSYS;
1277 }
1278 }
1279
1280
1281 ubuf = list_first_entry(&port->list_buf_used.list,
1282 struct saa7164_user_buffer, list);
1283
1284 if (ubuf)
1285 mask |= POLLIN | POLLRDNORM;
1286
1287 return mask;
1288}
1289
1290static const struct v4l2_file_operations mpeg_fops = {
1291 .owner = THIS_MODULE,
1292 .open = fops_open,
1293 .release = fops_release,
1294 .read = fops_read,
1295 .poll = fops_poll,
1296 .unlocked_ioctl = video_ioctl2,
1297};
1298
1299int saa7164_g_chip_ident(struct file *file, void *fh,
1300 struct v4l2_dbg_chip_ident *chip)
1301{
1302 struct saa7164_port *port = ((struct saa7164_encoder_fh *)fh)->port;
1303 struct saa7164_dev *dev = port->dev;
1304 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1305
1306 return 0;
1307}
1308
1309int saa7164_g_register(struct file *file, void *fh,
1310 struct v4l2_dbg_register *reg)
1311{
1312 struct saa7164_port *port = ((struct saa7164_encoder_fh *)fh)->port;
1313 struct saa7164_dev *dev = port->dev;
1314 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1315
1316 if (!capable(CAP_SYS_ADMIN))
1317 return -EPERM;
1318
1319 return 0;
1320}
1321
1322int saa7164_s_register(struct file *file, void *fh,
1323 struct v4l2_dbg_register *reg)
1324{
1325 struct saa7164_port *port = ((struct saa7164_encoder_fh *)fh)->port;
1326 struct saa7164_dev *dev = port->dev;
1327 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1328
1329 if (!capable(CAP_SYS_ADMIN))
1330 return -EPERM;
1331
1332 return 0;
1333}
1334
1335static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
1336 .vidioc_s_std = vidioc_s_std,
1337 .vidioc_enum_input = vidioc_enum_input,
1338 .vidioc_g_input = vidioc_g_input,
1339 .vidioc_s_input = vidioc_s_input,
1340 .vidioc_g_tuner = vidioc_g_tuner,
1341 .vidioc_s_tuner = vidioc_s_tuner,
1342 .vidioc_g_frequency = vidioc_g_frequency,
1343 .vidioc_s_frequency = vidioc_s_frequency,
1344 .vidioc_s_ctrl = vidioc_s_ctrl,
1345 .vidioc_g_ctrl = vidioc_g_ctrl,
1346 .vidioc_querycap = vidioc_querycap,
1347 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1348 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1349 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1350 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1351 .vidioc_g_ext_ctrls = vidioc_g_ext_ctrls,
1352 .vidioc_s_ext_ctrls = vidioc_s_ext_ctrls,
1353 .vidioc_try_ext_ctrls = vidioc_try_ext_ctrls,
1354 .vidioc_log_status = vidioc_log_status,
1355 .vidioc_queryctrl = vidioc_queryctrl,
1356 .vidioc_g_chip_ident = saa7164_g_chip_ident,
1357#ifdef CONFIG_VIDEO_ADV_DEBUG
1358 .vidioc_g_register = saa7164_g_register,
1359 .vidioc_s_register = saa7164_s_register,
1360#endif
1361};
1362
1363static struct video_device saa7164_mpeg_template = {
1364 .name = "saa7164",
1365 .fops = &mpeg_fops,
1366 .ioctl_ops = &mpeg_ioctl_ops,
1367 .minor = -1,
1368 .tvnorms = SAA7164_NORMS,
1369 .current_norm = V4L2_STD_NTSC_M,
1370};
1371
1372static struct video_device *saa7164_encoder_alloc(
1373 struct saa7164_port *port,
1374 struct pci_dev *pci,
1375 struct video_device *template,
1376 char *type)
1377{
1378 struct video_device *vfd;
1379 struct saa7164_dev *dev = port->dev;
1380
1381 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1382
1383 vfd = video_device_alloc();
1384 if (NULL == vfd)
1385 return NULL;
1386
1387 *vfd = *template;
1388 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
1389 type, saa7164_boards[dev->board].name);
1390
1391 vfd->parent = &pci->dev;
1392 vfd->release = video_device_release;
1393 return vfd;
1394}
1395
1396int saa7164_encoder_register(struct saa7164_port *port)
1397{
1398 struct saa7164_dev *dev = port->dev;
1399 int result = -ENODEV;
1400
1401 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1402
1403 if (port->type != SAA7164_MPEG_ENCODER)
1404 BUG();
1405
1406
1407 if (port->hwcfg.BARLocation == 0) {
1408 printk(KERN_ERR "%s() failed "
1409 "(errno = %d), NO PCI configuration\n",
1410 __func__, result);
1411 result = -ENOMEM;
1412 goto failed;
1413 }
1414
1415
1416
1417 port->encodernorm = saa7164_tvnorms[0];
1418 port->width = 720;
1419 port->mux_input = 1;
1420 port->video_format = EU_VIDEO_FORMAT_MPEG_2;
1421 port->audio_format = 0;
1422 port->video_resolution = 0;
1423 port->ctl_brightness = 127;
1424 port->ctl_contrast = 66;
1425 port->ctl_hue = 128;
1426 port->ctl_saturation = 62;
1427 port->ctl_sharpness = 8;
1428 port->encoder_params.bitrate = ENCODER_DEF_BITRATE;
1429 port->encoder_params.bitrate_peak = ENCODER_DEF_BITRATE;
1430 port->encoder_params.bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
1431 port->encoder_params.stream_type = V4L2_MPEG_STREAM_TYPE_MPEG2_PS;
1432 port->encoder_params.ctl_mute = 0;
1433 port->encoder_params.ctl_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3;
1434 port->encoder_params.refdist = 1;
1435 port->encoder_params.gop_size = SAA7164_ENCODER_DEFAULT_GOP_SIZE;
1436
1437 if (port->encodernorm.id & V4L2_STD_525_60)
1438 port->height = 480;
1439 else
1440 port->height = 576;
1441
1442
1443 port->v4l_device = saa7164_encoder_alloc(port,
1444 dev->pci, &saa7164_mpeg_template, "mpeg");
1445
1446 if (port->v4l_device == NULL) {
1447 printk(KERN_INFO "%s: can't allocate mpeg device\n",
1448 dev->name);
1449 result = -ENOMEM;
1450 goto failed;
1451 }
1452
1453 video_set_drvdata(port->v4l_device, port);
1454 result = video_register_device(port->v4l_device,
1455 VFL_TYPE_GRABBER, -1);
1456 if (result < 0) {
1457 printk(KERN_INFO "%s: can't register mpeg device\n",
1458 dev->name);
1459
1460
1461
1462 goto failed;
1463 }
1464
1465 printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
1466 dev->name, port->v4l_device->num);
1467
1468
1469 saa7164_api_set_videomux(port);
1470 saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
1471 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
1472 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
1473 saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
1474 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
1475 saa7164_api_audio_mute(port, 0);
1476 saa7164_api_set_audio_volume(port, 20);
1477 saa7164_api_set_aspect_ratio(port);
1478
1479
1480 saa7164_api_set_audio_detection(port, 0);
1481
1482 saa7164_api_set_encoder(port);
1483 saa7164_api_get_encoder(port);
1484
1485 result = 0;
1486failed:
1487 return result;
1488}
1489
1490void saa7164_encoder_unregister(struct saa7164_port *port)
1491{
1492 struct saa7164_dev *dev = port->dev;
1493
1494 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
1495
1496 if (port->type != SAA7164_MPEG_ENCODER)
1497 BUG();
1498
1499 if (port->v4l_device) {
1500 if (port->v4l_device->minor != -1)
1501 video_unregister_device(port->v4l_device);
1502 else
1503 video_device_release(port->v4l_device);
1504
1505 port->v4l_device = NULL;
1506 }
1507
1508 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
1509}
1510
1511
