GNU Linux-libre 4.9.331-gnu1
[releases.git] / drivers / media / pci / saa7164 / saa7164-vbi.c
1 /*
2  *  Driver for the NXP SAA7164 PCIe bridge
3  *
4  *  Copyright (c) 2010-2015 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 /* Take the encoder configuration from the port struct and
25  * flush it to the hardware.
26  */
27 static void saa7164_vbi_configure(struct saa7164_port *port)
28 {
29         struct saa7164_dev *dev = port->dev;
30         dprintk(DBGLVL_VBI, "%s()\n", __func__);
31
32         port->vbi_params.width = port->enc_port->width;
33         port->vbi_params.height = port->enc_port->height;
34         port->vbi_params.is_50hz =
35                 (port->enc_port->encodernorm.id & V4L2_STD_625_50) != 0;
36
37         /* Set up the DIF (enable it) for analog mode by default */
38         saa7164_api_initialize_dif(port);
39         dprintk(DBGLVL_VBI, "%s() ends\n", __func__);
40 }
41
42 static int saa7164_vbi_buffers_dealloc(struct saa7164_port *port)
43 {
44         struct list_head *c, *n, *p, *q, *l, *v;
45         struct saa7164_dev *dev = port->dev;
46         struct saa7164_buffer *buf;
47         struct saa7164_user_buffer *ubuf;
48
49         /* Remove any allocated buffers */
50         mutex_lock(&port->dmaqueue_lock);
51
52         dprintk(DBGLVL_VBI, "%s(port=%d) dmaqueue\n", __func__, port->nr);
53         list_for_each_safe(c, n, &port->dmaqueue.list) {
54                 buf = list_entry(c, struct saa7164_buffer, list);
55                 list_del(c);
56                 saa7164_buffer_dealloc(buf);
57         }
58
59         dprintk(DBGLVL_VBI, "%s(port=%d) used\n", __func__, port->nr);
60         list_for_each_safe(p, q, &port->list_buf_used.list) {
61                 ubuf = list_entry(p, struct saa7164_user_buffer, list);
62                 list_del(p);
63                 saa7164_buffer_dealloc_user(ubuf);
64         }
65
66         dprintk(DBGLVL_VBI, "%s(port=%d) free\n", __func__, port->nr);
67         list_for_each_safe(l, v, &port->list_buf_free.list) {
68                 ubuf = list_entry(l, struct saa7164_user_buffer, list);
69                 list_del(l);
70                 saa7164_buffer_dealloc_user(ubuf);
71         }
72
73         mutex_unlock(&port->dmaqueue_lock);
74         dprintk(DBGLVL_VBI, "%s(port=%d) done\n", __func__, port->nr);
75
76         return 0;
77 }
78
79 /* Dynamic buffer switch at vbi start time */
80 static int saa7164_vbi_buffers_alloc(struct saa7164_port *port)
81 {
82         struct saa7164_dev *dev = port->dev;
83         struct saa7164_buffer *buf;
84         struct saa7164_user_buffer *ubuf;
85         struct tmHWStreamParameters *params = &port->hw_streamingparams;
86         int result = -ENODEV, i;
87         int len = 0;
88
89         dprintk(DBGLVL_VBI, "%s()\n", __func__);
90
91         /* TODO: NTSC SPECIFIC */
92         /* Init and establish defaults */
93         params->samplesperline = 1440;
94         params->numberoflines = 12;
95         params->numberoflines = 18;
96         params->pitch = 1600;
97         params->pitch = 1440;
98         params->numpagetables = 2 +
99                 ((params->numberoflines * params->pitch) / PAGE_SIZE);
100         params->bitspersample = 8;
101         params->linethreshold = 0;
102         params->pagetablelistvirt = NULL;
103         params->pagetablelistphys = NULL;
104         params->numpagetableentries = port->hwcfg.buffercount;
105
106         /* Allocate the PCI resources, buffers (hard) */
107         for (i = 0; i < port->hwcfg.buffercount; i++) {
108                 buf = saa7164_buffer_alloc(port,
109                         params->numberoflines *
110                         params->pitch);
111
112                 if (!buf) {
113                         printk(KERN_ERR "%s() failed "
114                                "(errno = %d), unable to allocate buffer\n",
115                                 __func__, result);
116                         result = -ENOMEM;
117                         goto failed;
118                 } else {
119
120                         mutex_lock(&port->dmaqueue_lock);
121                         list_add_tail(&buf->list, &port->dmaqueue.list);
122                         mutex_unlock(&port->dmaqueue_lock);
123
124                 }
125         }
126
127         /* Allocate some kernel buffers for copying
128          * to userpsace.
129          */
130         len = params->numberoflines * params->pitch;
131
132         if (vbi_buffers < 16)
133                 vbi_buffers = 16;
134         if (vbi_buffers > 512)
135                 vbi_buffers = 512;
136
137         for (i = 0; i < vbi_buffers; i++) {
138
139                 ubuf = saa7164_buffer_alloc_user(dev, len);
140                 if (ubuf) {
141                         mutex_lock(&port->dmaqueue_lock);
142                         list_add_tail(&ubuf->list, &port->list_buf_free.list);
143                         mutex_unlock(&port->dmaqueue_lock);
144                 }
145
146         }
147
148         result = 0;
149
150 failed:
151         return result;
152 }
153
154
155 static int saa7164_vbi_initialize(struct saa7164_port *port)
156 {
157         saa7164_vbi_configure(port);
158         return 0;
159 }
160
161 /* -- V4L2 --------------------------------------------------------- */
162 static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id id)
163 {
164         struct saa7164_vbi_fh *fh = file->private_data;
165
166         return saa7164_s_std(fh->port->enc_port, id);
167 }
168
169 static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *id)
170 {
171         struct saa7164_encoder_fh *fh = file->private_data;
172
173         return saa7164_g_std(fh->port->enc_port, id);
174 }
175
176 static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
177 {
178         struct saa7164_vbi_fh *fh = file->private_data;
179
180         return saa7164_g_input(fh->port->enc_port, i);
181 }
182
183 static int vidioc_s_input(struct file *file, void *priv, unsigned int i)
184 {
185         struct saa7164_vbi_fh *fh = file->private_data;
186
187         return saa7164_s_input(fh->port->enc_port, i);
188 }
189
190 static int vidioc_g_frequency(struct file *file, void *priv,
191         struct v4l2_frequency *f)
192 {
193         struct saa7164_vbi_fh *fh = file->private_data;
194
195         return saa7164_g_frequency(fh->port->enc_port, f);
196 }
197
198 static int vidioc_s_frequency(struct file *file, void *priv,
199         const struct v4l2_frequency *f)
200 {
201         struct saa7164_vbi_fh *fh = file->private_data;
202         int ret = saa7164_s_frequency(fh->port->enc_port, f);
203
204         if (ret == 0)
205                 saa7164_vbi_initialize(fh->port);
206         return ret;
207 }
208
209 static int vidioc_querycap(struct file *file, void  *priv,
210         struct v4l2_capability *cap)
211 {
212         struct saa7164_vbi_fh *fh = file->private_data;
213         struct saa7164_port *port = fh->port;
214         struct saa7164_dev *dev = port->dev;
215
216         strcpy(cap->driver, dev->name);
217         strlcpy(cap->card, saa7164_boards[dev->board].name,
218                 sizeof(cap->card));
219         sprintf(cap->bus_info, "PCI:%s", pci_name(dev->pci));
220
221         cap->device_caps =
222                 V4L2_CAP_VBI_CAPTURE |
223                 V4L2_CAP_READWRITE |
224                 V4L2_CAP_TUNER;
225
226         cap->capabilities = cap->device_caps |
227                 V4L2_CAP_VIDEO_CAPTURE |
228                 V4L2_CAP_DEVICE_CAPS;
229
230         return 0;
231 }
232
233 static int saa7164_vbi_stop_port(struct saa7164_port *port)
234 {
235         struct saa7164_dev *dev = port->dev;
236         int ret;
237
238         ret = saa7164_api_transition_port(port, SAA_DMASTATE_STOP);
239         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
240                 printk(KERN_ERR "%s() stop transition failed, ret = 0x%x\n",
241                         __func__, ret);
242                 ret = -EIO;
243         } else {
244                 dprintk(DBGLVL_VBI, "%s()    Stopped\n", __func__);
245                 ret = 0;
246         }
247
248         return ret;
249 }
250
251 static int saa7164_vbi_acquire_port(struct saa7164_port *port)
252 {
253         struct saa7164_dev *dev = port->dev;
254         int ret;
255
256         ret = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
257         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
258                 printk(KERN_ERR "%s() acquire transition failed, ret = 0x%x\n",
259                         __func__, ret);
260                 ret = -EIO;
261         } else {
262                 dprintk(DBGLVL_VBI, "%s() Acquired\n", __func__);
263                 ret = 0;
264         }
265
266         return ret;
267 }
268
269 static int saa7164_vbi_pause_port(struct saa7164_port *port)
270 {
271         struct saa7164_dev *dev = port->dev;
272         int ret;
273
274         ret = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
275         if ((ret != SAA_OK) && (ret != SAA_ERR_ALREADY_STOPPED)) {
276                 printk(KERN_ERR "%s() pause transition failed, ret = 0x%x\n",
277                         __func__, ret);
278                 ret = -EIO;
279         } else {
280                 dprintk(DBGLVL_VBI, "%s()   Paused\n", __func__);
281                 ret = 0;
282         }
283
284         return ret;
285 }
286
287 /* Firmware is very windows centric, meaning you have to transition
288  * the part through AVStream / KS Windows stages, forwards or backwards.
289  * States are: stopped, acquired (h/w), paused, started.
290  * We have to leave here will all of the soft buffers on the free list,
291  * else the cfg_post() func won't have soft buffers to correctly configure.
292  */
293 static int saa7164_vbi_stop_streaming(struct saa7164_port *port)
294 {
295         struct saa7164_dev *dev = port->dev;
296         struct saa7164_buffer *buf;
297         struct saa7164_user_buffer *ubuf;
298         struct list_head *c, *n;
299         int ret;
300
301         dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr);
302
303         ret = saa7164_vbi_pause_port(port);
304         ret = saa7164_vbi_acquire_port(port);
305         ret = saa7164_vbi_stop_port(port);
306
307         dprintk(DBGLVL_VBI, "%s(port=%d) Hardware stopped\n", __func__,
308                 port->nr);
309
310         /* Reset the state of any allocated buffer resources */
311         mutex_lock(&port->dmaqueue_lock);
312
313         /* Reset the hard and soft buffer state */
314         list_for_each_safe(c, n, &port->dmaqueue.list) {
315                 buf = list_entry(c, struct saa7164_buffer, list);
316                 buf->flags = SAA7164_BUFFER_FREE;
317                 buf->pos = 0;
318         }
319
320         list_for_each_safe(c, n, &port->list_buf_used.list) {
321                 ubuf = list_entry(c, struct saa7164_user_buffer, list);
322                 ubuf->pos = 0;
323                 list_move_tail(&ubuf->list, &port->list_buf_free.list);
324         }
325
326         mutex_unlock(&port->dmaqueue_lock);
327
328         /* Free any allocated resources */
329         saa7164_vbi_buffers_dealloc(port);
330
331         dprintk(DBGLVL_VBI, "%s(port=%d) Released\n", __func__, port->nr);
332
333         return ret;
334 }
335
336 static int saa7164_vbi_start_streaming(struct saa7164_port *port)
337 {
338         struct saa7164_dev *dev = port->dev;
339         int result, ret = 0;
340
341         dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr);
342
343         port->done_first_interrupt = 0;
344
345         /* allocate all of the PCIe DMA buffer resources on the fly,
346          * allowing switching between TS and PS payloads without
347          * requiring a complete driver reload.
348          */
349         saa7164_vbi_buffers_alloc(port);
350
351         /* Configure the encoder with any cache values */
352 #if 0
353         saa7164_api_set_encoder(port);
354         saa7164_api_get_encoder(port);
355 #endif
356
357         /* Place the empty buffers on the hardware */
358         saa7164_buffer_cfg_port(port);
359
360         /* Negotiate format */
361         if (saa7164_api_set_vbi_format(port) != SAA_OK) {
362                 printk(KERN_ERR "%s() No supported VBI format\n", __func__);
363                 ret = -EIO;
364                 goto out;
365         }
366
367         /* Acquire the hardware */
368         result = saa7164_api_transition_port(port, SAA_DMASTATE_ACQUIRE);
369         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
370                 printk(KERN_ERR "%s() acquire transition failed, res = 0x%x\n",
371                         __func__, result);
372
373                 ret = -EIO;
374                 goto out;
375         } else
376                 dprintk(DBGLVL_VBI, "%s()   Acquired\n", __func__);
377
378         /* Pause the hardware */
379         result = saa7164_api_transition_port(port, SAA_DMASTATE_PAUSE);
380         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
381                 printk(KERN_ERR "%s() pause transition failed, res = 0x%x\n",
382                                 __func__, result);
383
384                 /* Stop the hardware, regardless */
385                 result = saa7164_vbi_stop_port(port);
386                 if (result != SAA_OK) {
387                         printk(KERN_ERR "%s() pause/forced stop transition "
388                                 "failed, res = 0x%x\n", __func__, result);
389                 }
390
391                 ret = -EIO;
392                 goto out;
393         } else
394                 dprintk(DBGLVL_VBI, "%s()   Paused\n", __func__);
395
396         /* Start the hardware */
397         result = saa7164_api_transition_port(port, SAA_DMASTATE_RUN);
398         if ((result != SAA_OK) && (result != SAA_ERR_ALREADY_STOPPED)) {
399                 printk(KERN_ERR "%s() run transition failed, result = 0x%x\n",
400                                 __func__, result);
401
402                 /* Stop the hardware, regardless */
403                 result = saa7164_vbi_acquire_port(port);
404                 result = saa7164_vbi_stop_port(port);
405                 if (result != SAA_OK) {
406                         printk(KERN_ERR "%s() run/forced stop transition "
407                                 "failed, res = 0x%x\n", __func__, result);
408                 }
409
410                 ret = -EIO;
411         } else
412                 dprintk(DBGLVL_VBI, "%s()   Running\n", __func__);
413
414 out:
415         return ret;
416 }
417
418 static int saa7164_vbi_fmt(struct file *file, void *priv,
419                            struct v4l2_format *f)
420 {
421         /* ntsc */
422         f->fmt.vbi.samples_per_line = 1440;
423         f->fmt.vbi.sampling_rate = 27000000;
424         f->fmt.vbi.sample_format = V4L2_PIX_FMT_GREY;
425         f->fmt.vbi.offset = 0;
426         f->fmt.vbi.flags = 0;
427         f->fmt.vbi.start[0] = 10;
428         f->fmt.vbi.count[0] = 18;
429         f->fmt.vbi.start[1] = 263 + 10 + 1;
430         f->fmt.vbi.count[1] = 18;
431         memset(f->fmt.vbi.reserved, 0, sizeof(f->fmt.vbi.reserved));
432         return 0;
433 }
434
435 static int fops_open(struct file *file)
436 {
437         struct saa7164_dev *dev;
438         struct saa7164_port *port;
439         struct saa7164_vbi_fh *fh;
440
441         port = (struct saa7164_port *)video_get_drvdata(video_devdata(file));
442         if (!port)
443                 return -ENODEV;
444
445         dev = port->dev;
446
447         dprintk(DBGLVL_VBI, "%s()\n", __func__);
448
449         /* allocate + initialize per filehandle data */
450         fh = kzalloc(sizeof(*fh), GFP_KERNEL);
451         if (NULL == fh)
452                 return -ENOMEM;
453
454         fh->port = port;
455         v4l2_fh_init(&fh->fh, video_devdata(file));
456         v4l2_fh_add(&fh->fh);
457         file->private_data = fh;
458
459         return 0;
460 }
461
462 static int fops_release(struct file *file)
463 {
464         struct saa7164_vbi_fh *fh = file->private_data;
465         struct saa7164_port *port = fh->port;
466         struct saa7164_dev *dev = port->dev;
467
468         dprintk(DBGLVL_VBI, "%s()\n", __func__);
469
470         /* Shut device down on last close */
471         if (atomic_cmpxchg(&fh->v4l_reading, 1, 0) == 1) {
472                 if (atomic_dec_return(&port->v4l_reader_count) == 0) {
473                         /* stop vbi capture then cancel buffers */
474                         saa7164_vbi_stop_streaming(port);
475                 }
476         }
477
478         v4l2_fh_del(&fh->fh);
479         v4l2_fh_exit(&fh->fh);
480         kfree(fh);
481
482         return 0;
483 }
484
485 static struct
486 saa7164_user_buffer *saa7164_vbi_next_buf(struct saa7164_port *port)
487 {
488         struct saa7164_user_buffer *ubuf = NULL;
489         struct saa7164_dev *dev = port->dev;
490         u32 crc;
491
492         mutex_lock(&port->dmaqueue_lock);
493         if (!list_empty(&port->list_buf_used.list)) {
494                 ubuf = list_first_entry(&port->list_buf_used.list,
495                         struct saa7164_user_buffer, list);
496
497                 if (crc_checking) {
498                         crc = crc32(0, ubuf->data, ubuf->actual_size);
499                         if (crc != ubuf->crc) {
500                                 printk(KERN_ERR "%s() ubuf %p crc became invalid, was 0x%x became 0x%x\n",
501                                         __func__,
502                                         ubuf, ubuf->crc, crc);
503                         }
504                 }
505
506         }
507         mutex_unlock(&port->dmaqueue_lock);
508
509         dprintk(DBGLVL_VBI, "%s() returns %p\n", __func__, ubuf);
510
511         return ubuf;
512 }
513
514 static ssize_t fops_read(struct file *file, char __user *buffer,
515         size_t count, loff_t *pos)
516 {
517         struct saa7164_vbi_fh *fh = file->private_data;
518         struct saa7164_port *port = fh->port;
519         struct saa7164_user_buffer *ubuf = NULL;
520         struct saa7164_dev *dev = port->dev;
521         int ret = 0;
522         int rem, cnt;
523         u8 *p;
524
525         port->last_read_msecs_diff = port->last_read_msecs;
526         port->last_read_msecs = jiffies_to_msecs(jiffies);
527         port->last_read_msecs_diff = port->last_read_msecs -
528                 port->last_read_msecs_diff;
529
530         saa7164_histogram_update(&port->read_interval,
531                 port->last_read_msecs_diff);
532
533         if (*pos) {
534                 printk(KERN_ERR "%s() ESPIPE\n", __func__);
535                 return -ESPIPE;
536         }
537
538         if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
539                 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
540
541                         if (saa7164_vbi_initialize(port) < 0) {
542                                 printk(KERN_ERR "%s() EINVAL\n", __func__);
543                                 return -EINVAL;
544                         }
545
546                         saa7164_vbi_start_streaming(port);
547                         msleep(200);
548                 }
549         }
550
551         /* blocking wait for buffer */
552         if ((file->f_flags & O_NONBLOCK) == 0) {
553                 if (wait_event_interruptible(port->wait_read,
554                         saa7164_vbi_next_buf(port))) {
555                                 printk(KERN_ERR "%s() ERESTARTSYS\n", __func__);
556                                 return -ERESTARTSYS;
557                 }
558         }
559
560         /* Pull the first buffer from the used list */
561         ubuf = saa7164_vbi_next_buf(port);
562
563         while ((count > 0) && ubuf) {
564
565                 /* set remaining bytes to copy */
566                 rem = ubuf->actual_size - ubuf->pos;
567                 cnt = rem > count ? count : rem;
568
569                 p = ubuf->data + ubuf->pos;
570
571                 dprintk(DBGLVL_VBI,
572                         "%s() count=%d cnt=%d rem=%d buf=%p buf->pos=%d\n",
573                         __func__, (int)count, cnt, rem, ubuf, ubuf->pos);
574
575                 if (copy_to_user(buffer, p, cnt)) {
576                         printk(KERN_ERR "%s() copy_to_user failed\n", __func__);
577                         if (!ret) {
578                                 printk(KERN_ERR "%s() EFAULT\n", __func__);
579                                 ret = -EFAULT;
580                         }
581                         goto err;
582                 }
583
584                 ubuf->pos += cnt;
585                 count -= cnt;
586                 buffer += cnt;
587                 ret += cnt;
588
589                 if (ubuf->pos > ubuf->actual_size)
590                         printk(KERN_ERR "read() pos > actual, huh?\n");
591
592                 if (ubuf->pos == ubuf->actual_size) {
593
594                         /* finished with current buffer, take next buffer */
595
596                         /* Requeue the buffer on the free list */
597                         ubuf->pos = 0;
598
599                         mutex_lock(&port->dmaqueue_lock);
600                         list_move_tail(&ubuf->list, &port->list_buf_free.list);
601                         mutex_unlock(&port->dmaqueue_lock);
602
603                         /* Dequeue next */
604                         if ((file->f_flags & O_NONBLOCK) == 0) {
605                                 if (wait_event_interruptible(port->wait_read,
606                                         saa7164_vbi_next_buf(port))) {
607                                                 break;
608                                 }
609                         }
610                         ubuf = saa7164_vbi_next_buf(port);
611                 }
612         }
613 err:
614         if (!ret && !ubuf) {
615                 printk(KERN_ERR "%s() EAGAIN\n", __func__);
616                 ret = -EAGAIN;
617         }
618
619         return ret;
620 }
621
622 static unsigned int fops_poll(struct file *file, poll_table *wait)
623 {
624         struct saa7164_vbi_fh *fh = (struct saa7164_vbi_fh *)file->private_data;
625         struct saa7164_port *port = fh->port;
626         unsigned int mask = 0;
627
628         port->last_poll_msecs_diff = port->last_poll_msecs;
629         port->last_poll_msecs = jiffies_to_msecs(jiffies);
630         port->last_poll_msecs_diff = port->last_poll_msecs -
631                 port->last_poll_msecs_diff;
632
633         saa7164_histogram_update(&port->poll_interval,
634                 port->last_poll_msecs_diff);
635
636         if (!video_is_registered(port->v4l_device))
637                 return -EIO;
638
639         if (atomic_cmpxchg(&fh->v4l_reading, 0, 1) == 0) {
640                 if (atomic_inc_return(&port->v4l_reader_count) == 1) {
641                         if (saa7164_vbi_initialize(port) < 0)
642                                 return -EINVAL;
643                         saa7164_vbi_start_streaming(port);
644                         msleep(200);
645                 }
646         }
647
648         /* blocking wait for buffer */
649         if ((file->f_flags & O_NONBLOCK) == 0) {
650                 if (wait_event_interruptible(port->wait_read,
651                         saa7164_vbi_next_buf(port))) {
652                                 return -ERESTARTSYS;
653                 }
654         }
655
656         /* Pull the first buffer from the used list */
657         if (!list_empty(&port->list_buf_used.list))
658                 mask |= POLLIN | POLLRDNORM;
659
660         return mask;
661 }
662 static const struct v4l2_file_operations vbi_fops = {
663         .owner          = THIS_MODULE,
664         .open           = fops_open,
665         .release        = fops_release,
666         .read           = fops_read,
667         .poll           = fops_poll,
668         .unlocked_ioctl = video_ioctl2,
669 };
670
671 static const struct v4l2_ioctl_ops vbi_ioctl_ops = {
672         .vidioc_s_std            = vidioc_s_std,
673         .vidioc_g_std            = vidioc_g_std,
674         .vidioc_enum_input       = saa7164_enum_input,
675         .vidioc_g_input          = vidioc_g_input,
676         .vidioc_s_input          = vidioc_s_input,
677         .vidioc_g_tuner          = saa7164_g_tuner,
678         .vidioc_s_tuner          = saa7164_s_tuner,
679         .vidioc_g_frequency      = vidioc_g_frequency,
680         .vidioc_s_frequency      = vidioc_s_frequency,
681         .vidioc_querycap         = vidioc_querycap,
682         .vidioc_g_fmt_vbi_cap    = saa7164_vbi_fmt,
683         .vidioc_try_fmt_vbi_cap  = saa7164_vbi_fmt,
684         .vidioc_s_fmt_vbi_cap    = saa7164_vbi_fmt,
685 };
686
687 static struct video_device saa7164_vbi_template = {
688         .name          = "saa7164",
689         .fops          = &vbi_fops,
690         .ioctl_ops     = &vbi_ioctl_ops,
691         .minor         = -1,
692         .tvnorms       = SAA7164_NORMS,
693 };
694
695 static struct video_device *saa7164_vbi_alloc(
696         struct saa7164_port *port,
697         struct pci_dev *pci,
698         struct video_device *template,
699         char *type)
700 {
701         struct video_device *vfd;
702         struct saa7164_dev *dev = port->dev;
703
704         dprintk(DBGLVL_VBI, "%s()\n", __func__);
705
706         vfd = video_device_alloc();
707         if (NULL == vfd)
708                 return NULL;
709
710         *vfd = *template;
711         snprintf(vfd->name, sizeof(vfd->name), "%s %s (%s)", dev->name,
712                 type, saa7164_boards[dev->board].name);
713
714         vfd->v4l2_dev  = &dev->v4l2_dev;
715         vfd->release = video_device_release;
716         return vfd;
717 }
718
719 int saa7164_vbi_register(struct saa7164_port *port)
720 {
721         struct saa7164_dev *dev = port->dev;
722         int result = -ENODEV;
723
724         dprintk(DBGLVL_VBI, "%s()\n", __func__);
725
726         if (port->type != SAA7164_MPEG_VBI)
727                 BUG();
728
729         /* Sanity check that the PCI configuration space is active */
730         if (port->hwcfg.BARLocation == 0) {
731                 printk(KERN_ERR "%s() failed "
732                        "(errno = %d), NO PCI configuration\n",
733                         __func__, result);
734                 result = -ENOMEM;
735                 goto failed;
736         }
737
738         /* Establish VBI defaults here */
739
740         /* Allocate and register the video device node */
741         port->v4l_device = saa7164_vbi_alloc(port,
742                 dev->pci, &saa7164_vbi_template, "vbi");
743
744         if (!port->v4l_device) {
745                 printk(KERN_INFO "%s: can't allocate vbi device\n",
746                         dev->name);
747                 result = -ENOMEM;
748                 goto failed;
749         }
750
751         port->enc_port = &dev->ports[port->nr - 2];
752         video_set_drvdata(port->v4l_device, port);
753         result = video_register_device(port->v4l_device,
754                 VFL_TYPE_VBI, -1);
755         if (result < 0) {
756                 printk(KERN_INFO "%s: can't register vbi device\n",
757                         dev->name);
758                 /* TODO: We're going to leak here if we don't dealloc
759                  The buffers above. The unreg function can't deal wit it.
760                 */
761                 goto failed;
762         }
763
764         printk(KERN_INFO "%s: registered device vbi%d [vbi]\n",
765                 dev->name, port->v4l_device->num);
766
767         /* Configure the hardware defaults */
768
769         result = 0;
770 failed:
771         return result;
772 }
773
774 void saa7164_vbi_unregister(struct saa7164_port *port)
775 {
776         struct saa7164_dev *dev = port->dev;
777
778         dprintk(DBGLVL_VBI, "%s(port=%d)\n", __func__, port->nr);
779
780         if (port->type != SAA7164_MPEG_VBI)
781                 BUG();
782
783         if (port->v4l_device) {
784                 if (port->v4l_device->minor != -1)
785                         video_unregister_device(port->v4l_device);
786                 else
787                         video_device_release(port->v4l_device);
788
789                 port->v4l_device = NULL;
790         }
791
792 }