1
2
3
4
5
6
7
8#include "saa7164.h"
9
10#define ENCODER_MAX_BITRATE 6500000
11#define ENCODER_MIN_BITRATE 1000000
12#define ENCODER_DEF_BITRATE 5000000
13
14
15
16
17
18
19
20
21
22
23
24#define SAA7164_SIZEIMAGE (0x10000)
25
26static struct saa7164_tvnorm saa7164_tvnorms[] = {
27 {
28 .name = "NTSC-M",
29 .id = V4L2_STD_NTSC_M,
30 }, {
31 .name = "NTSC-JP",
32 .id = V4L2_STD_NTSC_M_JP,
33 }
34};
35
36
37
38
39static void saa7164_encoder_configure(struct saa7164_port *port)
40{
41 struct saa7164_dev *dev = port->dev;
42 dprintk(DBGLVL_ENC, "%s()\n", __func__);
43
44 port->encoder_params.width = port->width;
45 port->encoder_params.height = port->height;
46 port->encoder_params.is_50hz =
47 (port->encodernorm.id & V4L2_STD_625_50) != 0;
48
49
50 saa7164_api_initialize_dif(port);
51
52
53 saa7164_api_configure_dif(port, port->encodernorm.id);
54
55
56 saa7164_api_set_audio_std(port);
57}
58
59static int saa7164_encoder_buffers_dealloc(struct saa7164_port *port)
60{
61 struct list_head *c, *n, *p, *q, *l, *v;
62 struct saa7164_dev *dev = port->dev;
63 struct saa7164_buffer *buf;
64 struct saa7164_user_buffer *ubuf;
65
66
67 mutex_lock(&port->dmaqueue_lock);
68
69 dprintk(DBGLVL_ENC, "%s(port=%d) dmaqueue\n", __func__, port->nr);
70 list_for_each_safe(c, n, &port->dmaqueue.list) {
71 buf = list_entry(c, struct saa7164_buffer, list);
72 list_del(c);
73 saa7164_buffer_dealloc(buf);
74 }
75
76 dprintk(DBGLVL_ENC, "%s(port=%d) used\n", __func__, port->nr);
77 list_for_each_safe(p, q, &port->list_buf_used.list) {
78 ubuf = list_entry(p, struct saa7164_user_buffer, list);
79 list_del(p);
80 saa7164_buffer_dealloc_user(ubuf);
81 }
82
83 dprintk(DBGLVL_ENC, "%s(port=%d) free\n", __func__, port->nr);
84 list_for_each_safe(l, v, &port->list_buf_free.list) {
85 ubuf = list_entry(l, struct saa7164_user_buffer, list);
86 list_del(l);
87 saa7164_buffer_dealloc_user(ubuf);
88 }
89
90 mutex_unlock(&port->dmaqueue_lock);
91 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
92
93 return 0;
94}
95
96
97static int saa7164_encoder_buffers_alloc(struct saa7164_port *port)
98{
99 struct saa7164_dev *dev = port->dev;
100 struct saa7164_buffer *buf;
101 struct saa7164_user_buffer *ubuf;
102 struct tmHWStreamParameters *params = &port->hw_streamingparams;
103 int result = -ENODEV, i;
104 int len = 0;
105
106 dprintk(DBGLVL_ENC, "%s()\n", __func__);
107
108 if (port->encoder_params.stream_type ==
109 V4L2_MPEG_STREAM_TYPE_MPEG2_PS) {
110 dprintk(DBGLVL_ENC,
111 "%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_PS\n",
112 __func__);
113 params->samplesperline = 128;
114 params->numberoflines = 256;
115 params->pitch = 128;
116 params->numpagetables = 2 +
117 ((SAA7164_PS_NUMBER_OF_LINES * 128) / PAGE_SIZE);
118 } else
119 if (port->encoder_params.stream_type ==
120 V4L2_MPEG_STREAM_TYPE_MPEG2_TS) {
121 dprintk(DBGLVL_ENC,
122 "%s() type=V4L2_MPEG_STREAM_TYPE_MPEG2_TS\n",
123 __func__);
124 params->samplesperline = 188;
125 params->numberoflines = 312;
126 params->pitch = 188;
127 params->numpagetables = 2 +
128 ((SAA7164_TS_NUMBER_OF_LINES * 188) / PAGE_SIZE);
129 } else
130 BUG();
131
132
133 params->bitspersample = 8;
134 params->linethreshold = 0;
135 params->pagetablelistvirt = NULL;
136 params->pagetablelistphys = NULL;
137 params->numpagetableentries = port->hwcfg.buffercount;
138
139
140 for (i = 0; i < port->hwcfg.buffercount; i++) {
141 buf = saa7164_buffer_alloc(port,
142 params->numberoflines *
143 params->pitch);
144
145 if (!buf) {
146 printk(KERN_ERR "%s() failed (errno = %d), unable to allocate buffer\n",
147 __func__, result);
148 result = -ENOMEM;
149 goto failed;
150 } else {
151
152 mutex_lock(&port->dmaqueue_lock);
153 list_add_tail(&buf->list, &port->dmaqueue.list);
154 mutex_unlock(&port->dmaqueue_lock);
155
156 }
157 }
158
159
160
161
162 len = params->numberoflines * params->pitch;
163
164 if (encoder_buffers < 16)
165 encoder_buffers = 16;
166 if (encoder_buffers > 512)
167 encoder_buffers = 512;
168
169 for (i = 0; i < encoder_buffers; i++) {
170
171 ubuf = saa7164_buffer_alloc_user(dev, len);
172 if (ubuf) {
173 mutex_lock(&port->dmaqueue_lock);
174 list_add_tail(&ubuf->list, &port->list_buf_free.list);
175 mutex_unlock(&port->dmaqueue_lock);
176 }
177
178 }
179
180 result = 0;
181
182failed:
183 return result;
184}
185
186static int saa7164_encoder_initialize(struct saa7164_port *port)
187{
188 saa7164_encoder_configure(port);
189 return 0;
190}
191
192
193int saa7164_s_std(struct saa7164_port *port, v4l2_std_id id)
194{
195 struct saa7164_dev *dev = port->dev;
196 unsigned int i;
197
198 dprintk(DBGLVL_ENC, "%s(id=0x%x)\n", __func__, (u32)id);
199
200 for (i = 0; i < ARRAY_SIZE(saa7164_tvnorms); i++) {
201 if (id & saa7164_tvnorms[i].id)
202 break;
203 }
204 if (i == ARRAY_SIZE(saa7164_tvnorms))
205 return -EINVAL;
206
207 port->encodernorm = saa7164_tvnorms[i];
208 port->std = id;
209
210
211
212
213 saa7164_api_set_audio_std(port);
214
215 dprintk(DBGLVL_ENC, "%s(id=0x%x) OK\n", __func__, (u32)id);
216
217 return 0;
218}
219
220static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
221{
222 struct saa7164_encoder_fh *fh = file->private_data;
223
224 return saa7164_s_std(fh->port, id);
225}
226
227int saa7164_g_std(struct saa7164_port *port, v4l2_std_id *id)
228{
229 *id = port->std;
230 return 0;
231}
232
233static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
234{
235 struct saa7164_encoder_fh *fh = file->private_data;
236
237 return saa7164_g_std(fh->port, id);
238}
239
240int saa7164_enum_input(struct file *file, void *priv, struct v4l2_input *i)
241{
242 static const char * const inputs[] = {
243 "tuner", "composite", "svideo", "aux",
244 "composite 2", "svideo 2", "aux 2"
245 };
246 int n;
247
248 if (i->index >= 7)
249 return -EINVAL;
250
251 strscpy(i->name, inputs[i->index], sizeof(i->name));
252
253 if (i->index == 0)
254 i->type = V4L2_INPUT_TYPE_TUNER;
255 else
256 i->type = V4L2_INPUT_TYPE_CAMERA;
257
258 for (n = 0; n < ARRAY_SIZE(saa7164_tvnorms); n++)
259 i->std |= saa7164_tvnorms[n].id;
260
261 return 0;
262}
263
264int saa7164_g_input(struct saa7164_port *port, unsigned int *i)
265{
266 struct saa7164_dev *dev = port->dev;
267
268 if (saa7164_api_get_videomux(port) != SAA_OK)
269 return -EIO;
270
271 *i = (port->mux_input - 1);
272
273 dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, *i);
274
275 return 0;
276}
277
278static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
279{
280 struct saa7164_encoder_fh *fh = file->private_data;
281
282 return saa7164_g_input(fh->port, i);
283}
284
285int saa7164_s_input(struct saa7164_port *port, unsigned int i)
286{
287 struct saa7164_dev *dev = port->dev;
288
289 dprintk(DBGLVL_ENC, "%s() input=%d\n", __func__, i);
290
291 if (i >= 7)
292 return -EINVAL;
293
294 port->mux_input = i + 1;
295
296 if (saa7164_api_set_videomux(port) != SAA_OK)
297 return -EIO;
298
299 return 0;
300}
301
302static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
303{
304 struct saa7164_encoder_fh *fh = file->private_data;
305
306 return saa7164_s_input(fh->port, i);
307}
308
309int saa7164_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
310{
311 struct saa7164_encoder_fh *fh = file->private_data;
312 struct saa7164_port *port = fh->port;
313 struct saa7164_dev *dev = port->dev;
314
315 if (0 != t->index)
316 return -EINVAL;
317
318 strscpy(t->name, "tuner", sizeof(t->name));
319 t->capability = V4L2_TUNER_CAP_NORM | V4L2_TUNER_CAP_STEREO;
320 t->rangelow = SAA7164_TV_MIN_FREQ;
321 t->rangehigh = SAA7164_TV_MAX_FREQ;
322
323 dprintk(DBGLVL_ENC, "VIDIOC_G_TUNER: tuner type %d\n", t->type);
324
325 return 0;
326}
327
328int saa7164_s_tuner(struct file *file, void *priv,
329 const struct v4l2_tuner *t)
330{
331 if (0 != t->index)
332 return -EINVAL;
333
334
335 return 0;
336}
337
338int saa7164_g_frequency(struct saa7164_port *port, struct v4l2_frequency *f)
339{
340 if (f->tuner)
341 return -EINVAL;
342
343 f->frequency = port->freq;
344 return 0;
345}
346
347static int vidioc_g_frequency(struct file *file, void *priv,
348 struct v4l2_frequency *f)
349{
350 struct saa7164_encoder_fh *fh = file->private_data;
351
352 return saa7164_g_frequency(fh->port, f);
353}
354
355int saa7164_s_frequency(struct saa7164_port *port,
356 const struct v4l2_frequency *f)
357{
358 struct saa7164_dev *dev = port->dev;
359 struct saa7164_port *tsport;
360 struct dvb_frontend *fe;
361
362
363 struct analog_parameters params = {
364 .mode = V4L2_TUNER_ANALOG_TV,
365 .audmode = V4L2_TUNER_MODE_STEREO,
366 .std = port->encodernorm.id,
367 .frequency = f->frequency
368 };
369
370
371 dprintk(DBGLVL_ENC, "%s() frequency=%d tuner=%d\n", __func__,
372 f->frequency, f->tuner);
373
374 if (f->tuner != 0)
375 return -EINVAL;
376
377 port->freq = clamp(f->frequency,
378 SAA7164_TV_MIN_FREQ, SAA7164_TV_MAX_FREQ);
379
380
381 if (port->nr == SAA7164_PORT_ENC1)
382 tsport = &dev->ports[SAA7164_PORT_TS1];
383 else if (port->nr == SAA7164_PORT_ENC2)
384 tsport = &dev->ports[SAA7164_PORT_TS2];
385 else
386 BUG();
387
388 fe = tsport->dvb.frontend;
389
390 if (fe && fe->ops.tuner_ops.set_analog_params)
391 fe->ops.tuner_ops.set_analog_params(fe, ¶ms);
392 else
393 printk(KERN_ERR "%s() No analog tuner, aborting\n", __func__);
394
395 saa7164_encoder_initialize(port);
396
397 return 0;
398}
399
400static int vidioc_s_frequency(struct file *file, void *priv,
401 const struct v4l2_frequency *f)
402{
403 struct saa7164_encoder_fh *fh = file->private_data;
404
405 return saa7164_s_frequency(fh->port, f);
406}
407
408static int saa7164_s_ctrl(struct v4l2_ctrl *ctrl)
409{
410 struct saa7164_port *port =
411 container_of(ctrl->handler, struct saa7164_port, ctrl_handler);
412 struct saa7164_encoder_params *params = &port->encoder_params;
413 int ret = 0;
414
415 switch (ctrl->id) {
416 case V4L2_CID_BRIGHTNESS:
417 port->ctl_brightness = ctrl->val;
418 saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
419 break;
420 case V4L2_CID_CONTRAST:
421 port->ctl_contrast = ctrl->val;
422 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
423 break;
424 case V4L2_CID_SATURATION:
425 port->ctl_saturation = ctrl->val;
426 saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
427 break;
428 case V4L2_CID_HUE:
429 port->ctl_hue = ctrl->val;
430 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
431 break;
432 case V4L2_CID_SHARPNESS:
433 port->ctl_sharpness = ctrl->val;
434 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
435 break;
436 case V4L2_CID_AUDIO_VOLUME:
437 port->ctl_volume = ctrl->val;
438 saa7164_api_set_audio_volume(port, port->ctl_volume);
439 break;
440 case V4L2_CID_MPEG_VIDEO_BITRATE:
441 params->bitrate = ctrl->val;
442 break;
443 case V4L2_CID_MPEG_STREAM_TYPE:
444 params->stream_type = ctrl->val;
445 break;
446 case V4L2_CID_MPEG_AUDIO_MUTE:
447 params->ctl_mute = ctrl->val;
448 ret = saa7164_api_audio_mute(port, params->ctl_mute);
449 if (ret != SAA_OK) {
450 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
451 ret);
452 ret = -EIO;
453 }
454 break;
455 case V4L2_CID_MPEG_VIDEO_ASPECT:
456 params->ctl_aspect = ctrl->val;
457 ret = saa7164_api_set_aspect_ratio(port);
458 if (ret != SAA_OK) {
459 printk(KERN_ERR "%s() error, ret = 0x%x\n", __func__,
460 ret);
461 ret = -EIO;
462 }
463 break;
464 case V4L2_CID_MPEG_VIDEO_BITRATE_MODE:
465 params->bitrate_mode = ctrl->val;
466 break;
467 case V4L2_CID_MPEG_VIDEO_B_FRAMES:
468 params->refdist = ctrl->val;
469 break;
470 case V4L2_CID_MPEG_VIDEO_BITRATE_PEAK:
471 params->bitrate_peak = ctrl->val;
472 break;
473 case V4L2_CID_MPEG_VIDEO_GOP_SIZE:
474 params->gop_size = ctrl->val;
475 break;
476 default:
477 ret = -EINVAL;
478 }
479
480 return ret;
481}
482
483static int vidioc_querycap(struct file *file, void *priv,
484 struct v4l2_capability *cap)
485{
486 struct saa7164_encoder_fh *fh = file->private_data;
487 struct saa7164_port *port = fh->port;
488 struct saa7164_dev *dev = port->dev;
489
490 strscpy(cap->driver, dev->name, sizeof(cap->driver));
491 strscpy(cap->card, saa7164_boards[dev->board].name,
492 sizeof(cap->card));
493 sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
494 cap->capabilities = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
495 V4L2_CAP_TUNER | V4L2_CAP_VBI_CAPTURE |
496 V4L2_CAP_DEVICE_CAPS;
497 return 0;
498}
499
500static int vidioc_enum_fmt_vid_cap(struct file *file, void *priv,
501 struct v4l2_fmtdesc *f)
502{
503 if (f->index != 0)
504 return -EINVAL;
505
506 f->pixelformat = V4L2_PIX_FMT_MPEG;
507
508 return 0;
509}
510
511static int vidioc_fmt_vid_cap(struct file *file, void *priv,
512 struct v4l2_format *f)
513{
514 struct saa7164_encoder_fh *fh = file->private_data;
515 struct saa7164_port *port = fh->port;
516
517 f->fmt.pix.pixelformat = V4L2_PIX_FMT_MPEG;
518 f->fmt.pix.bytesperline = 0;
519 f->fmt.pix.sizeimage = SAA7164_SIZEIMAGE;
520 f->fmt.pix.field = V4L2_FIELD_INTERLACED;
521 f->fmt.pix.colorspace = V4L2_COLORSPACE_SMPTE170M;
522 f->fmt.pix.width = port->width;
523 f->fmt.pix.height = port->height;
524 return 0;
525}
526
527static int saa7164_encoder_stop_port(struct saa7164_port *port)
528{
529 struct saa7164_dev *dev = port->dev;
530 int ret;
531
532 ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
533 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
534 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
535 __func__, ret);
536 ret = -EIO;
537 } else {
538 dprintk(DBGLVL_ENC, "%s() Stopped\n", __func__);
539 ret = 0;
540 }
541
542 return ret;
543}
544
545static int saa7164_encoder_acquire_port(struct saa7164_port *port)
546{
547 struct saa7164_dev *dev = port->dev;
548 int ret;
549
550 ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
551 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
552 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
553 __func__, ret);
554 ret = -EIO;
555 } else {
556 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
557 ret = 0;
558 }
559
560 return ret;
561}
562
563static int saa7164_encoder_pause_port(struct saa7164_port *port)
564{
565 struct saa7164_dev *dev = port->dev;
566 int ret;
567
568 ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
569 if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
570 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
571 __func__, ret);
572 ret = -EIO;
573 } else {
574 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__);
575 ret = 0;
576 }
577
578 return ret;
579}
580
581
582
583
584
585
586
587static int saa7164_encoder_stop_streaming(struct saa7164_port *port)
588{
589 struct saa7164_dev *dev = port->dev;
590 struct saa7164_buffer *buf;
591 struct saa7164_user_buffer *ubuf;
592 struct list_head *c, *n;
593 int ret;
594
595 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
596
597 ret = saa7164_encoder_pause_port(port);
598 ret = saa7164_encoder_acquire_port(port);
599 ret = saa7164_encoder_stop_port(port);
600
601 dprintk(DBGLVL_ENC, "%s(port=%d) Hardware stopped\n", __func__,
602 port->nr);
603
604
605 mutex_lock(&port->dmaqueue_lock);
606
607
608 list_for_each_safe(c, n, &port->dmaqueue.list) {
609 buf = list_entry(c, struct saa7164_buffer, list);
610 buf->flags = SAA7164_BUFFER_FREE;
611 buf->pos = 0;
612 }
613
614 list_for_each_safe(c, n, &port->list_buf_used.list) {
615 ubuf = list_entry(c, struct saa7164_user_buffer, list);
616 ubuf->pos = 0;
617 list_move_tail(&ubuf->list, &port->list_buf_free.list);
618 }
619
620 mutex_unlock(&port->dmaqueue_lock);
621
622
623 saa7164_encoder_buffers_dealloc(port);
624
625 dprintk(DBGLVL_ENC, "%s(port=%d) Released\n", __func__, port->nr);
626
627 return ret;
628}
629
630static int saa7164_encoder_start_streaming(struct saa7164_port *port)
631{
632 struct saa7164_dev *dev = port->dev;
633 int result, ret = 0;
634
635 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
636
637 port->done_first_interrupt = 0;
638
639
640
641
642
643 saa7164_encoder_buffers_alloc(port);
644
645
646 saa7164_api_set_encoder(port);
647 saa7164_api_get_encoder(port);
648
649
650 saa7164_buffer_cfg_port(port);
651
652
653 result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
654 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
655 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
656 __func__, result);
657
658
659 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
660 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
661 printk(KERN_ERR "%s() acquire/forced stop transition failed, res = 0x%x\n",
662 __func__, result);
663 }
664 ret = -EIO;
665 goto out;
666 } else
667 dprintk(DBGLVL_ENC, "%s() Acquired\n", __func__);
668
669
670 result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
671 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
672 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
673 __func__, result);
674
675
676 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
677 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
678 printk(KERN_ERR "%s() pause/forced stop transition failed, res = 0x%x\n",
679 __func__, result);
680 }
681
682 ret = -EIO;
683 goto out;
684 } else
685 dprintk(DBGLVL_ENC, "%s() Paused\n", __func__);
686
687
688 result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
689 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
690 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
691 __func__, result);
692
693
694 result = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
695 if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
696 printk(KERN_ERR "%s() run/forced stop transition failed, res = 0x%x\n",
697 __func__, result);
698 }
699
700 ret = -EIO;
701 } else
702 dprintk(DBGLVL_ENC, "%s() Running\n", __func__);
703
704out:
705 return ret;
706}
707
708static int fops_open(struct file *file)
709{
710 struct saa7164_dev *dev;
711 struct saa7164_port *port;
712 struct saa7164_encoder_fh *fh;
713
714 port = (struct saa7164_port *)video_get_drvdata(video_devdata(file));
715 if (!port)
716 return -ENODEV;
717
718 dev = port->dev;
719
720 dprintk(DBGLVL_ENC, "%s()\n", __func__);
721
722
723 fh = kzalloc(sizeof(*fh), GFP_KERNEL);
724 if (NULL == fh)
725 return -ENOMEM;
726
727 fh->port = port;
728 v4l2_fh_init(&fh->fh, video_devdata(file));
729 v4l2_fh_add(&fh->fh);
730 file->private_data = fh;
731
732 return 0;
733}
734
735static int fops_release(struct file *file)
736{
737 struct saa7164_encoder_fh *fh = file->private_data;
738 struct saa7164_port *port = fh->port;
739 struct saa7164_dev *dev = port->dev;
740
741 dprintk(DBGLVL_ENC, "%s()\n", __func__);
742
743
744 if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) {
745 if (atomic_dec_return(&port->v4l_reader_count) == 0) {
746
747 saa7164_encoder_stop_streaming(port);
748 }
749 }
750
751 v4l2_fh_del(&fh->fh);
752 v4l2_fh_exit(&fh->fh);
753 kfree(fh);
754
755 return 0;
756}
757
758static struct
759saa7164_user_buffer *saa7164_enc_next_buf(struct saa7164_port *port)
760{
761 struct saa7164_user_buffer *ubuf = NULL;
762 struct saa7164_dev *dev = port->dev;
763 u32 crc;
764
765 mutex_lock(&port->dmaqueue_lock);
766 if (!list_empty(&port->list_buf_used.list)) {
767 ubuf = list_first_entry(&port->list_buf_used.list,
768 struct saa7164_user_buffer, list);
769
770 if (crc_checking) {
771 crc = crc32(0, ubuf->data, ubuf->actual_size);
772 if (crc != ubuf->crc) {
773 printk(KERN_ERR
774 "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n",
775 __func__,
776 ubuf, ubuf->crc, crc);
777 }
778 }
779
780 }
781 mutex_unlock(&port->dmaqueue_lock);
782
783 dprintk(DBGLVL_ENC, "%s() returns %p\n", __func__, ubuf);
784
785 return ubuf;
786}
787
788static ssize_t fops_read(struct file *file, char __user *buffer,
789 size_t count, loff_t *pos)
790{
791 struct saa7164_encoder_fh *fh = file->private_data;
792 struct saa7164_port *port = fh->port;
793 struct saa7164_user_buffer *ubuf = NULL;
794 struct saa7164_dev *dev = port->dev;
795 int ret = 0;
796 int rem, cnt;
797 u8 *p;
798
799 port->last_read_msecs_diff = port->last_read_msecs;
800 port->last_read_msecs = jiffies_to_msecs(jiffies);
801 port->last_read_msecs_diff = port->last_read_msecs -
802 port->last_read_msecs_diff;
803
804 saa7164_histogram_update(&port->read_interval,
805 port->last_read_msecs_diff);
806
807 if (*pos) {
808 printk(KERN_ERR "%s() ESPIPE\n", __func__);
809 return -ESPIPE;
810 }
811
812 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
813 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
814
815 if (saa7164_encoder_initialize(port) < 0) {
816 printk(KERN_ERR "%s() EINVAL\n", __func__);
817 return -EINVAL;
818 }
819
820 saa7164_encoder_start_streaming(port);
821 msleep(200);
822 }
823 }
824
825
826 if ((file->f_flags & O_NONBLOCK) == 0) {
827 if (wait_event_interruptible(port->wait_read,
828 saa7164_enc_next_buf(port))) {
829 printk(KERN_ERR "%s() ERESTARTSYS\n", __func__);
830 return -ERESTARTSYS;
831 }
832 }
833
834
835 ubuf = saa7164_enc_next_buf(port);
836
837 while ((count > 0) && ubuf) {
838
839
840 rem = ubuf->actual_size - ubuf->pos;
841 cnt = rem > count ? count : rem;
842
843 p = ubuf->data + ubuf->pos;
844
845 dprintk(DBGLVL_ENC,
846 "%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n",
847 __func__, (int)count, cnt, rem, ubuf, ubuf->pos);
848
849 if (copy_to_user(buffer, p, cnt)) {
850 printk(KERN_ERR "%s() copy_to_user failed\n", __func__);
851 if (!ret) {
852 printk(KERN_ERR "%s() EFAULT\n", __func__);
853 ret = -EFAULT;
854 }
855 goto err;
856 }
857
858 ubuf->pos += cnt;
859 count -= cnt;
860 buffer += cnt;
861 ret += cnt;
862
863 if (ubuf->pos > ubuf->actual_size)
864 printk(KERN_ERR "read() pos > actual, huh?\n");
865
866 if (ubuf->pos == ubuf->actual_size) {
867
868
869
870
871 ubuf->pos = 0;
872
873 mutex_lock(&port->dmaqueue_lock);
874 list_move_tail(&ubuf->list, &port->list_buf_free.list);
875 mutex_unlock(&port->dmaqueue_lock);
876
877
878 if ((file->f_flags & O_NONBLOCK) == 0) {
879 if (wait_event_interruptible(port->wait_read,
880 saa7164_enc_next_buf(port))) {
881 break;
882 }
883 }
884 ubuf = saa7164_enc_next_buf(port);
885 }
886 }
887err:
888 if (!ret && !ubuf)
889 ret = -EAGAIN;
890
891 return ret;
892}
893
894static __poll_t fops_poll(struct file *file, poll_table *wait)
895{
896 __poll_t req_events = poll_requested_events(wait);
897 struct saa7164_encoder_fh *fh =
898 (struct saa7164_encoder_fh *)file->private_data;
899 struct saa7164_port *port = fh->port;
900 __poll_t mask = v4l2_ctrl_poll(file, wait);
901
902 port->last_poll_msecs_diff = port->last_poll_msecs;
903 port->last_poll_msecs = jiffies_to_msecs(jiffies);
904 port->last_poll_msecs_diff = port->last_poll_msecs -
905 port->last_poll_msecs_diff;
906
907 saa7164_histogram_update(&port->poll_interval,
908 port->last_poll_msecs_diff);
909
910 if (!(req_events & (EPOLLIN | EPOLLRDNORM)))
911 return mask;
912
913 if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
914 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
915 if (saa7164_encoder_initialize(port) < 0)
916 return mask | EPOLLERR;
917 saa7164_encoder_start_streaming(port);
918 msleep(200);
919 }
920 }
921
922
923 if (!list_empty(&port->list_buf_used.list))
924 mask |= EPOLLIN | EPOLLRDNORM;
925
926 return mask;
927}
928
929static const struct v4l2_ctrl_ops saa7164_ctrl_ops = {
930 .s_ctrl = saa7164_s_ctrl,
931};
932
933static const struct v4l2_file_operations mpeg_fops = {
934 .owner = THIS_MODULE,
935 .open = fops_open,
936 .release = fops_release,
937 .read = fops_read,
938 .poll = fops_poll,
939 .unlocked_ioctl = video_ioctl2,
940};
941
942static const struct v4l2_ioctl_ops mpeg_ioctl_ops = {
943 .vidioc_s_std = vidioc_s_std,
944 .vidioc_g_std = vidioc_g_std,
945 .vidioc_enum_input = saa7164_enum_input,
946 .vidioc_g_input = vidioc_g_input,
947 .vidioc_s_input = vidioc_s_input,
948 .vidioc_g_tuner = saa7164_g_tuner,
949 .vidioc_s_tuner = saa7164_s_tuner,
950 .vidioc_g_frequency = vidioc_g_frequency,
951 .vidioc_s_frequency = vidioc_s_frequency,
952 .vidioc_querycap = vidioc_querycap,
953 .vidioc_enum_fmt_vid_cap = vidioc_enum_fmt_vid_cap,
954 .vidioc_g_fmt_vid_cap = vidioc_fmt_vid_cap,
955 .vidioc_try_fmt_vid_cap = vidioc_fmt_vid_cap,
956 .vidioc_s_fmt_vid_cap = vidioc_fmt_vid_cap,
957 .vidioc_log_status = v4l2_ctrl_log_status,
958 .vidioc_subscribe_event = v4l2_ctrl_subscribe_event,
959 .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
960};
961
962static struct video_device saa7164_mpeg_template = {
963 .name = "saa7164",
964 .fops = &mpeg_fops,
965 .ioctl_ops = &mpeg_ioctl_ops,
966 .minor = -1,
967 .tvnorms = SAA7164_NORMS,
968 .device_caps = V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_READWRITE |
969 V4L2_CAP_TUNER,
970};
971
972static struct video_device *saa7164_encoder_alloc(
973 struct saa7164_port *port,
974 struct pci_dev *pci,
975 struct video_device *template,
976 char *type)
977{
978 struct video_device *vfd;
979 struct saa7164_dev *dev = port->dev;
980
981 dprintk(DBGLVL_ENC, "%s()\n", __func__);
982
983 vfd = video_device_alloc();
984 if (NULL == vfd)
985 return NULL;
986
987 *vfd = *template;
988 snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
989 type, saa7164_boards[dev->board].name);
990
991 vfd->v4l2_dev = &dev->v4l2_dev;
992 vfd->release = video_device_release;
993 return vfd;
994}
995
996int saa7164_encoder_register(struct saa7164_port *port)
997{
998 struct saa7164_dev *dev = port->dev;
999 struct v4l2_ctrl_handler *hdl = &port->ctrl_handler;
1000 int result = -ENODEV;
1001
1002 dprintk(DBGLVL_ENC, "%s()\n", __func__);
1003
1004 BUG_ON(port->type != SAA7164_MPEG_ENCODER);
1005
1006
1007 if (port->hwcfg.BARLocation == 0) {
1008 printk(KERN_ERR "%s() failed (errno = %d), NO PCI configuration\n",
1009 __func__, result);
1010 result = -ENOMEM;
1011 goto fail_pci;
1012 }
1013
1014
1015
1016 port->encodernorm = saa7164_tvnorms[0];
1017 port->width = 720;
1018 port->mux_input = 1;
1019 port->video_format = EU_VIDEO_FORMAT_MPEG_2;
1020 port->audio_format = 0;
1021 port->video_resolution = 0;
1022 port->freq = SAA7164_TV_MIN_FREQ;
1023
1024 v4l2_ctrl_handler_init(hdl, 14);
1025 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1026 V4L2_CID_BRIGHTNESS, 0, 255, 1, 127);
1027 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1028 V4L2_CID_CONTRAST, 0, 255, 1, 66);
1029 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1030 V4L2_CID_SATURATION, 0, 255, 1, 62);
1031 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1032 V4L2_CID_HUE, 0, 255, 1, 128);
1033 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1034 V4L2_CID_SHARPNESS, 0x0, 0x0f, 1, 8);
1035 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1036 V4L2_CID_MPEG_AUDIO_MUTE, 0x0, 0x01, 1, 0);
1037 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1038 V4L2_CID_AUDIO_VOLUME, -83, 24, 1, 20);
1039 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1040 V4L2_CID_MPEG_VIDEO_BITRATE,
1041 ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
1042 100000, ENCODER_DEF_BITRATE);
1043 v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1044 V4L2_CID_MPEG_STREAM_TYPE,
1045 V4L2_MPEG_STREAM_TYPE_MPEG2_TS, 0,
1046 V4L2_MPEG_STREAM_TYPE_MPEG2_PS);
1047 v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1048 V4L2_CID_MPEG_VIDEO_ASPECT,
1049 V4L2_MPEG_VIDEO_ASPECT_221x100, 0,
1050 V4L2_MPEG_VIDEO_ASPECT_4x3);
1051 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1052 V4L2_CID_MPEG_VIDEO_GOP_SIZE, 1, 255, 1, 15);
1053 v4l2_ctrl_new_std_menu(hdl, &saa7164_ctrl_ops,
1054 V4L2_CID_MPEG_VIDEO_BITRATE_MODE,
1055 V4L2_MPEG_VIDEO_BITRATE_MODE_CBR, 0,
1056 V4L2_MPEG_VIDEO_BITRATE_MODE_VBR);
1057 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1058 V4L2_CID_MPEG_VIDEO_B_FRAMES, 1, 3, 1, 1);
1059 v4l2_ctrl_new_std(hdl, &saa7164_ctrl_ops,
1060 V4L2_CID_MPEG_VIDEO_BITRATE_PEAK,
1061 ENCODER_MIN_BITRATE, ENCODER_MAX_BITRATE,
1062 100000, ENCODER_DEF_BITRATE);
1063 if (hdl->error) {
1064 result = hdl->error;
1065 goto fail_hdl;
1066 }
1067
1068 port->std = V4L2_STD_NTSC_M;
1069
1070 if (port->encodernorm.id & V4L2_STD_525_60)
1071 port->height = 480;
1072 else
1073 port->height = 576;
1074
1075
1076 port->v4l_device = saa7164_encoder_alloc(port,
1077 dev->pci, &saa7164_mpeg_template, "mpeg");
1078
1079 if (!port->v4l_device) {
1080 printk(KERN_INFO "%s: can't allocate mpeg device\n",
1081 dev->name);
1082 result = -ENOMEM;
1083 goto fail_hdl;
1084 }
1085
1086 port->v4l_device->ctrl_handler = hdl;
1087 v4l2_ctrl_handler_setup(hdl);
1088 video_set_drvdata(port->v4l_device, port);
1089 result = video_register_device(port->v4l_device,
1090 VFL_TYPE_VIDEO, -1);
1091 if (result < 0) {
1092 printk(KERN_INFO "%s: can't register mpeg device\n",
1093 dev->name);
1094 goto fail_reg;
1095 }
1096
1097 printk(KERN_INFO "%s: registered device video%d [mpeg]\n",
1098 dev->name, port->v4l_device->num);
1099
1100
1101 saa7164_api_set_videomux(port);
1102 saa7164_api_set_usercontrol(port, PU_BRIGHTNESS_CONTROL);
1103 saa7164_api_set_usercontrol(port, PU_CONTRAST_CONTROL);
1104 saa7164_api_set_usercontrol(port, PU_HUE_CONTROL);
1105 saa7164_api_set_usercontrol(port, PU_SATURATION_CONTROL);
1106 saa7164_api_set_usercontrol(port, PU_SHARPNESS_CONTROL);
1107 saa7164_api_audio_mute(port, 0);
1108 saa7164_api_set_audio_volume(port, 20);
1109 saa7164_api_set_aspect_ratio(port);
1110
1111
1112 saa7164_api_set_audio_detection(port, 0);
1113
1114 saa7164_api_set_encoder(port);
1115 saa7164_api_get_encoder(port);
1116 return 0;
1117
1118fail_reg:
1119 video_device_release(port->v4l_device);
1120 port->v4l_device = NULL;
1121fail_hdl:
1122 v4l2_ctrl_handler_free(hdl);
1123fail_pci:
1124 return result;
1125}
1126
1127void saa7164_encoder_unregister(struct saa7164_port *port)
1128{
1129 struct saa7164_dev *dev = port->dev;
1130
1131 dprintk(DBGLVL_ENC, "%s(port=%d)\n", __func__, port->nr);
1132
1133 BUG_ON(port->type != SAA7164_MPEG_ENCODER);
1134
1135 if (port->v4l_device) {
1136 if (port->v4l_device->minor != -1)
1137 video_unregister_device(port->v4l_device);
1138 else
1139 video_device_release(port->v4l_device);
1140
1141 port->v4l_device = NULL;
1142 }
1143 v4l2_ctrl_handler_free(&port->ctrl_handler);
1144
1145 dprintk(DBGLVL_ENC, "%s(port=%d) done\n", __func__, port->nr);
1146}
1147
1148
