?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
sfc: Don't use enums as a bitmask.
[zen-stable.git] / drivers / media / video / saa7164 / saa7164-encoder.c
blobf9d5946988323c5e125c7d1a8bb70de9a34e8a8e
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 kenrel 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 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 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 vidioc_log_status(struct file *file, void *priv)
795 {
796 return 0;
797 }
798
799 static 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
850 static 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
881 static 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
899 static 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
917 static 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 /* Firmware is very windows centric, meaning you have to transition
936 * the part through AVStream / KS Windows stages, forwards or backwards.
937 * States are: stopped, acquired (h/w), paused, started.
938 * We have to leave here will all of the soft buffers on the free list,
939 * else the cfg_post() func won't have soft buffers to correctly configure.
940 */
941 static 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 /* Reset the state of any allocated buffer resources */
959 mutex_lock(&port->dmaqueue_lock);
960
961 /* Reset the hard and soft buffer state */
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 /* Free any allocated resources */
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
984 static 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 /* allocate all of the PCIe DMA buffer resources on the fly,
994 * allowing switching between TS and PS payloads without
995 * requiring a complete driver reload.
996 */
997 saa7164_encoder_buffers_alloc(port);
998
999 /* Configure the encoder with any cache values */
1000 saa7164_api_set_encoder(port);
1001 saa7164_api_get_encoder(port);
1002
1003 /* Place the empty buffers on the hardware */
1004 saa7164_buffer_cfg_port(port);
1005
1006 /* Acquire the hardware */
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 /* Stop the hardware, regardless */
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 /* Pause the hardware */
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 /* Stop the hardware, regardless */
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 /* Start the hardware */
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 /* Stop the hardware, regardless */
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
1058 out:
1059 return ret;
1060 }
1061
1062 static 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 /* allocate + initialize per filehandle data */
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
1087 static 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 /* Shut device down on last close */
1096 if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) {
1097 if (atomic_dec_return(&port->v4l_reader_count) == 0) {
1098 /* stop mpeg capture then cancel buffers */
1099 saa7164_encoder_stop_streaming(port);
1100 }
1101 }
1102
1103 file->private_data = NULL;
1104 kfree(fh);
1105
1106 return 0;
1107 }
1108
1109 struct saa7164_user_buffer *saa7164_enc_next_buf(struct saa7164_port *port)
1110 {
1111 struct saa7164_user_buffer *ubuf = NULL;
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
1138 static 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 /* blocking wait for buffer */
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 /* Pull the first buffer from the used list */
1185 ubuf = saa7164_enc_next_buf(port);
1186
1187 while ((count > 0) && ubuf) {
1188
1189 /* set remaining bytes to copy */
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 /* finished with current buffer, take next buffer */
1219
1220 /* Requeue the buffer on the free list */
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 /* Dequeue next */
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 }
1237 err:
1238 if (!ret && !ubuf)
1239 ret = -EAGAIN;
1240
1241 return ret;
1242 }
1243
1244 static 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 /* blocking wait for buffer */
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 /* Pull the first buffer from the used list */
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
1290 static 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
1299 int 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
1309 int 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
1322 int 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
1335 static 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
1363 static 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
1372 static 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
1396 int 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 /* Sanity check that the PCI configuration space is active */
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 /* Establish encoder defaults here */
1416 /* Set default TV standard */
1417 port->encodernorm = saa7164_tvnorms[0];
1418 port->width = 720;
1419 port->mux_input = 1; /* Composite */
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 /* Allocate and register the video device node */
1443 port->v4l_device = saa7164_encoder_alloc(port,
1444 dev->pci, &saa7164_mpeg_template, "mpeg");
1445
1446 if (!port->v4l_device) {
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 /* TODO: We're going to leak here if we don't dealloc
1460 The buffers above. The unreg function can't deal wit it.
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 /* Configure the hardware defaults */
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 /* Disable audio standard detection, it's buggy */
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;
1486 failed:
1487 return result;
1488 }
1489
1490 void 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