drivers/media/pci/saa7164/saa7164-vbi.c

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