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