aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/media/video/saa7164/saa7164-encoder.c
diff options
context:
space:
mode:
authorMauro Carvalho Chehab <mchehab@redhat.com>2012-08-14 11:13:30 -0400
committerMauro Carvalho Chehab <mchehab@redhat.com>2012-08-15 15:36:22 -0400
commitb285192a43f0432d82c2c10974204e78af0da596 (patch)
tree618aa87e760c9c949eca9e4df6ae0eeffa11dcfc /drivers/media/video/saa7164/saa7164-encoder.c
parent68de959f773a1d49096835c411390bceff5d1549 (diff)
[media] rename most media/video pci drivers to media/pci
Rename all PCI drivers with their own directory under drivers/media/video into drivers/media/pci and update the building system. Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
Diffstat (limited to 'drivers/media/video/saa7164/saa7164-encoder.c')
-rw-r--r--drivers/media/video/saa7164/saa7164-encoder.c1500
1 files changed, 0 insertions, 1500 deletions
diff --git a/drivers/media/video/saa7164/saa7164-encoder.c b/drivers/media/video/saa7164/saa7164-encoder.c
deleted file mode 100644
index a9ed686ad08a..000000000000
--- a/drivers/media/video/saa7164/saa7164-encoder.c
+++ /dev/null
@@ -1,1500 +0,0 @@
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
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/* Take the encoder configuration form the port struct and
57 * flush it to the hardware.
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 /* 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
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 /* 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 */
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 /* 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
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/* -- V4L2 --------------------------------------------------------- */
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 /* 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
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 /* Update the A/V core */
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 /* 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
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 /* TODO: Update the hardware */
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 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
845static 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
876static 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
894static 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
912static 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 */
936static 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
979static 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
1053out:
1054 return ret;
1055}
1056
1057static 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
1082static 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
1104struct saa7164_user_buffer *saa7164_enc_next_buf(struct saa7164_port *port)
1105{
1106 struct saa7164_user_buffer *ubuf = NULL;
1107 struct saa7164_dev *dev = port->dev;
1108 u32 crc;
1109
1110 mutex_lock(&port->dmaqueue_lock);
1111 if (!list_empty(&port->list_buf_used.list)) {
1112 ubuf = list_first_entry(&port->list_buf_used.list,
1113 struct saa7164_user_buffer, list);
1114
1115 if (crc_checking) {
1116 crc = crc32(0, ubuf->data, ubuf->actual_size);
1117 if (crc != ubuf->crc) {
1118 printk(KERN_ERR
1119 "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n",
1120 __func__,
1121 ubuf, ubuf->crc, crc);
1122 }
1123 }
1124
1125 }
1126 mutex_unlock(&port->dmaqueue_lock);
1127
1128 dprintk(DBGLVL_ENC, "%s() returns %p\n", __func__, ubuf);
1129
1130 return ubuf;
1131}
1132
1133static ssize_t fops_read(struct file *file, char __user *buffer,
1134 size_t count, loff_t *pos)
1135{
1136 struct saa7164_encoder_fh *fh = file->private_data;
1137 struct saa7164_port *port = fh->port;
1138 struct saa7164_user_buffer *ubuf = NULL;
1139 struct saa7164_dev *dev = port->dev;
1140 int ret = 0;
1141 int rem, cnt;
1142 u8 *p;
1143
1144 port->last_read_msecs_diff = port->last_read_msecs;
1145 port->last_read_msecs = jiffies_to_msecs(jiffies);
1146 port->last_read_msecs_diff = port->last_read_msecs -
1147 port->last_read_msecs_diff;
1148
1149 saa7164_histogram_update(&port->read_interval,
1150 port->last_read_msecs_diff);
1151
1152 if (*pos) {
1153 printk(KERN_ERR "%s() ESPIPE\n", __func__);
1154 return -ESPIPE;
1155 }
1156
1157 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
1158 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
1159
1160 if (saa7164_encoder_initialize(port) < 0) {
1161 printk(KERN_ERR "%s() EINVAL\n", __func__);
1162 return -EINVAL;
1163 }
1164
1165 saa7164_encoder_start_streaming(port);
1166 msleep(200);
1167 }
1168 }
1169
1170 /* blocking wait for buffer */
1171 if ((file->f_flags & O_NONBLOCK) == 0) {
1172 if (wait_event_interruptible(port->wait_read,
1173 saa7164_enc_next_buf(port))) {
1174 printk(KERN_ERR "%s() ERESTARTSYS\n", __func__);
1175 return -ERESTARTSYS;
1176 }
1177 }
1178
1179 /* Pull the first buffer from the used list */
1180 ubuf = saa7164_enc_next_buf(port);
1181
1182 while ((count > 0) && ubuf) {
1183
1184 /* set remaining bytes to copy */
1185 rem = ubuf->actual_size - ubuf->pos;
1186 cnt = rem > count ? count : rem;
1187
1188 p = ubuf->data + ubuf->pos;
1189
1190 dprintk(DBGLVL_ENC,
1191 "%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n",
1192 __func__, (int)count, cnt, rem, ubuf, ubuf->pos);
1193
1194 if (copy_to_user(buffer, p, cnt)) {
1195 printk(KERN_ERR "%s() copy_to_user failed\n", __func__);
1196 if (!ret) {
1197 printk(KERN_ERR "%s() EFAULT\n", __func__);
1198 ret = -EFAULT;
1199 }
1200 goto err;
1201 }
1202
1203 ubuf->pos += cnt;
1204 count -= cnt;
1205 buffer += cnt;
1206 ret += cnt;
1207
1208 if (ubuf->pos > ubuf->actual_size)
1209 printk(KERN_ERR "read() pos > actual, huh?\n");
1210
1211 if (ubuf->pos == ubuf->actual_size) {
1212
1213 /* finished with current buffer, take next buffer */
1214
1215 /* Requeue the buffer on the free list */
1216 ubuf->pos = 0;
1217
1218 mutex_lock(&port->dmaqueue_lock);
1219 list_move_tail(&ubuf->list, &port->list_buf_free.list);
1220 mutex_unlock(&port->dmaqueue_lock);
1221
1222 /* Dequeue next */
1223 if ((file->f_flags & O_NONBLOCK) == 0) {
1224 if (wait_event_interruptible(port->wait_read,
1225 saa7164_enc_next_buf(port))) {
1226 break;
1227 }
1228 }
1229 ubuf = saa7164_enc_next_buf(port);
1230 }
1231 }
1232err:
1233 if (!ret && !ubuf)
1234 ret = -EAGAIN;
1235
1236 return ret;
1237}
1238
1239static unsigned int fops_poll(struct file *file, poll_table *wait)
1240{
1241 struct saa7164_encoder_fh *fh =
1242 (struct saa7164_encoder_fh *)file->private_data;
1243 struct saa7164_port *port = fh->port;
1244 unsigned int mask = 0;
1245
1246 port->last_poll_msecs_diff = port->last_poll_msecs;
1247 port->last_poll_msecs = jiffies_to_msecs(jiffies);
1248 port->last_poll_msecs_diff = port->last_poll_msecs -
1249 port->last_poll_msecs_diff;
1250
1251 saa7164_histogram_update(&port->poll_interval,
1252 port->last_poll_msecs_diff);
1253
1254 if (!video_is_registered(port->v4l_device))
1255 return -EIO;
1256
1257 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
1258 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
1259 if (saa7164_encoder_initialize(port) < 0)
1260 return -EINVAL;
1261 saa7164_encoder_start_streaming(port);
1262 msleep(200);
1263 }
1264 }
1265
1266 /* blocking wait for buffer */
1267 if ((file->f_flags & O_NONBLOCK) == 0) {
1268 if (wait_event_interruptible(port->wait_read,
1269 saa7164_enc_next_buf(port))) {
1270 return -ERESTARTSYS;
1271 }
1272 }
1273
1274 /* Pull the first buffer from the used list */
1275 if (!list_empty(&port->list_buf_used.list))
1276 mask |= POLLIN | POLLRDNORM;
1277
1278 return mask;
1279}
1280
1281static const struct v4l2_file_operations mpeg_fops = {
1282 .owner = THIS_MODULE,
1283 .open = fops_open,
1284 .release = fops_release,
1285 .read = fops_read,
1286 .poll = fops_poll,
1287 .unlocked_ioctl = video_ioctl2,
1288};
1289
1290int saa7164_g_chip_ident(struct file *file, void *fh,
1291 struct v4l2_dbg_chip_ident *chip)
1292{
1293 struct saa7164_port *port = ((struct saa7164_encoder_fh *)fh)->port;
1294 struct saa7164_dev *dev = port->dev;
1295 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1296
1297 return 0;
1298}
1299
1300int saa7164_g_register(struct file *file, void *fh,
1301 struct v4l2_dbg_register *reg)
1302{
1303 struct saa7164_port *port = ((struct saa7164_encoder_fh *)fh)->port;
1304 struct saa7164_dev *dev = port->dev;
1305 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1306
1307 if (!capable(CAP_SYS_ADMIN))
1308 return -EPERM;
1309
1310 return 0;
1311}
1312
1313int saa7164_s_register(struct file *file, void *fh,
1314 struct v4l2_dbg_register *reg)
1315{
1316 struct saa7164_port *port = ((struct saa7164_encoder_fh *)fh)->port;
1317 struct saa7164_dev *dev = port->dev;
1318 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1319
1320 if (!capable(CAP_SYS_ADMIN))
1321 return -EPERM;
1322
1323 return 0;
1324}
1325
1326static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
1327 .vidioc_s_std = vidioc_s_std,
1328 .vidioc_enum_input = vidioc_enum_input,
1329 .vidioc_g_input = vidioc_g_input,
1330 .vidioc_s_input = vidioc_s_input,
1331 .vidioc_g_tuner = vidioc_g_tuner,
1332 .vidioc_s_tuner = vidioc_s_tuner,
1333 .vidioc_g_frequency = vidioc_g_frequency,
1334 .vidioc_s_frequency = vidioc_s_frequency,
1335 .vidioc_s_ctrl = vidioc_s_ctrl,
1336 .vidioc_g_ctrl = vidioc_g_ctrl,
1337 .vidioc_querycap = vidioc_querycap,
1338 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
1339 .vidioc_g_fmt_vid_cap = vidioc_g_fmt_vid_cap,
1340 .vidioc_try_fmt_vid_cap = vidioc_try_fmt_vid_cap,
1341 .vidioc_s_fmt_vid_cap = vidioc_s_fmt_vid_cap,
1342 .vidioc_g_ext_ctrls = vidioc_g_ext_ctrls,
1343 .vidioc_s_ext_ctrls = vidioc_s_ext_ctrls,
1344 .vidioc_try_ext_ctrls = vidioc_try_ext_ctrls,
1345 .vidioc_queryctrl = vidioc_queryctrl,
1346 .vidioc_g_chip_ident = saa7164_g_chip_ident,
1347#ifdef CONFIG_VIDEO_ADV_DEBUG
1348 .vidioc_g_register = saa7164_g_register,
1349 .vidioc_s_register = saa7164_s_register,
1350#endif
1351};
1352
1353static struct video_device saa7164_mpeg_template = {
1354 .name = "saa7164",
1355 .fops = &mpeg_fops,
1356 .ioctl_ops = &mpeg_ioctl_ops,
1357 .minor = -1,
1358 .tvnorms = SAA7164_NORMS,
1359 .current_norm = V4L2_STD_NTSC_M,
1360};
1361
1362static struct video_device *saa7164_encoder_alloc(
1363 struct saa7164_port *port,
1364 struct pci_dev *pci,
1365 struct video_device *template,
1366 char *type)
1367{
1368 struct video_device *vfd;
1369 struct saa7164_dev *dev = port->dev;
1370
1371 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1372
1373 vfd = video_device_alloc();
1374 if (NULL == vfd)
1375 return NULL;
1376
1377 *vfd = *template;
1378 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
1379 type, saa7164_boards[dev->board].name);
1380
1381 vfd->parent = &pci->dev;
1382 vfd->release = video_device_release;
1383 return vfd;
1384}
1385
1386int saa7164_encoder_register(struct saa7164_port *port)
1387{
1388 struct saa7164_dev *dev = port->dev;
1389 int result = -ENODEV;
1390
1391 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1392
1393 if (port->type != SAA7164_MPEG_ENCODER)
1394 BUG();
1395
1396 /* Sanity check that the PCI configuration space is active */
1397 if (port->hwcfg.BARLocation == 0) {
1398 printk(KERN_ERR "%s() failed "
1399 "(errno = %d), NO PCI configuration\n",
1400 __func__, result);
1401 result = -ENOMEM;
1402 goto failed;
1403 }
1404
1405 /* Establish encoder defaults here */
1406 /* Set default TV standard */
1407 port->encodernorm = saa7164_tvnorms[0];
1408 port->width = 720;
1409 port->mux_input = 1; /* Composite */
1410 port->video_format = EU_VIDEO_FORMAT_MPEG_2;
1411 port->audio_format = 0;
1412 port->video_resolution = 0;
1413 port->ctl_brightness = 127;
1414 port->ctl_contrast = 66;
1415 port->ctl_hue = 128;
1416 port->ctl_saturation = 62;
1417 port->ctl_sharpness = 8;
1418 port->encoder_params.bitrate = ENCODER_DEF_BITRATE;
1419 port->encoder_params.bitrate_peak = ENCODER_DEF_BITRATE;
1420 port->encoder_params.bitrate_mode = V4L2_MPEG_VIDEO_BITRATE_MODE_CBR;
1421 port->encoder_params.stream_type = V4L2_MPEG_STREAM_TYPE_MPEG2_PS;
1422 port->encoder_params.ctl_mute = 0;
1423 port->encoder_params.ctl_aspect = V4L2_MPEG_VIDEO_ASPECT_4x3;
1424 port->encoder_params.refdist = 1;
1425 port->encoder_params.gop_size = SAA7164_ENCODER_DEFAULT_GOP_SIZE;
1426
1427 if (port->encodernorm.id & V4L2_STD_525_60)
1428 port->height = 480;
1429 else
1430 port->height = 576;
1431
1432 /* Allocate and register the video device node */
1433 port->v4l_device = saa7164_encoder_alloc(port,
1434 dev->pci, &saa7164_mpeg_template, "mpeg");
1435
1436 if (!port->v4l_device) {
1437 printk(KERN_INFO "%s: can't allocate mpeg device\n",
1438 dev->name);
1439 result = -ENOMEM;
1440 goto failed;
1441 }
1442
1443 video_set_drvdata(port->v4l_device, port);
1444 result = video_register_device(port->v4l_device,
1445 VFL_TYPE_GRABBER, -1);
1446 if (result < 0) {
1447 printk(KERN_INFO "%s: can't register mpeg device\n",
1448 dev->name);
1449 /* TODO: We're going to leak here if we don't dealloc
1450 The buffers above. The unreg function can't deal wit it.
1451 */
1452 goto failed;
1453 }
1454
1455 printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
1456 dev->name, port->v4l_device->num);
1457
1458 /* Configure the hardware defaults */
1459 saa7164_api_set_videomux(port);
1460 saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
1461 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
1462 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
1463 saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
1464 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
1465 saa7164_api_audio_mute(port, 0);
1466 saa7164_api_set_audio_volume(port, 20);
1467 saa7164_api_set_aspect_ratio(port);
1468
1469 /* Disable audio standard detection, it's buggy */
1470 saa7164_api_set_audio_detection(port, 0);
1471
1472 saa7164_api_set_encoder(port);
1473 saa7164_api_get_encoder(port);
1474
1475 result = 0;
1476failed:
1477 return result;
1478}
1479
1480void saa7164_encoder_unregister(struct saa7164_port *port)
1481{
1482 struct saa7164_dev *dev = port->dev;
1483
1484 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
1485
1486 if (port->type != SAA7164_MPEG_ENCODER)
1487 BUG();
1488
1489 if (port->v4l_device) {
1490 if (port->v4l_device->minor != -1)
1491 video_unregister_device(port->v4l_device);
1492 else
1493 video_device_release(port->v4l_device);
1494
1495 port->v4l_device = NULL;
1496 }
1497
1498 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
1499}
1500
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-29 08:44:25 -0500