root/drivers/media/pci/bt8xx/bttv-vbi.c

DEFINITIONS

1. vbi_buffer_setup
2. vbi_buffer_prepare
3. vbi_buffer_queue
4. vbi_buffer_release
5. try_fmt
6. bttv_try_fmt_vbi_cap
7. bttv_s_fmt_vbi_cap
8. bttv_g_fmt_vbi_cap
9. bttv_vbi_fmt_reset

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3 
   4     bttv - Bt848 frame grabber driver
   5     vbi interface
   6 
   7     (c) 2002 Gerd Knorr <kraxel@bytesex.org>
   8 
   9     Copyright (C) 2005, 2006 Michael H. Schimek <mschimek@gmx.at>
  10     Sponsored by OPQ Systems AB
  11 
  12 */
  13 
  14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  15 
  16 #include <linux/module.h>
  17 #include <linux/errno.h>
  18 #include <linux/fs.h>
  19 #include <linux/kernel.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/kdev_t.h>
  22 #include <media/v4l2-ioctl.h>
  23 #include <asm/io.h>
  24 #include "bttvp.h"
  25 
  26 /* Offset from line sync pulse leading edge (0H) to start of VBI capture,
  27    in fCLKx2 pixels.  According to the datasheet, VBI capture starts
  28    VBI_HDELAY fCLKx1 pixels from the tailing edgeof /HRESET, and /HRESET
  29    is 64 fCLKx1 pixels wide.  VBI_HDELAY is set to 0, so this should be
  30    (64 + 0) * 2 = 128 fCLKx2 pixels.  But it's not!  The datasheet is
  31    Just Plain Wrong.  The real value appears to be different for
  32    different revisions of the bt8x8 chips, and to be affected by the
  33    horizontal scaling factor.  Experimentally, the value is measured
  34    to be about 244.  */
  35 #define VBI_OFFSET 244
  36 
  37 /* 2048 for compatibility with earlier driver versions. The driver
  38    really stores 1024 + tvnorm->vbipack * 4 samples per line in the
  39    buffer. Note tvnorm->vbipack is <= 0xFF (limit of VBIPACK_LO + HI
  40    is 0x1FF DWORDs) and VBI read()s store a frame counter in the last
  41    four bytes of the VBI image. */
  42 #define VBI_BPL 2048
  43 
  44 /* Compatibility. */
  45 #define VBI_DEFLINES 16
  46 
  47 static unsigned int vbibufs = 4;
  48 static unsigned int vbi_debug;
  49 
  50 module_param(vbibufs,   int, 0444);
  51 module_param(vbi_debug, int, 0644);
  52 MODULE_PARM_DESC(vbibufs,"number of vbi buffers, range 2-32, default 4");
  53 MODULE_PARM_DESC(vbi_debug,"vbi code debug messages, default is 0 (no)");
  54 
  55 #ifdef dprintk
  56 # undef dprintk
  57 #endif
  58 #define dprintk(fmt, ...)                                               \
  59 do {                                                                    \
  60         if (vbi_debug)                                                  \
  61                 pr_debug("%d: " fmt, btv->c.nr, ##__VA_ARGS__);         \
  62 } while (0)
  63 
  64 #define IMAGE_SIZE(fmt) \
  65         (((fmt)->count[0] + (fmt)->count[1]) * (fmt)->samples_per_line)
  66 
  67 /* ----------------------------------------------------------------------- */
  68 /* vbi risc code + mm                                                      */
  69 
  70 static int vbi_buffer_setup(struct videobuf_queue *q,
  71                             unsigned int *count, unsigned int *size)
  72 {
  73         struct bttv_fh *fh = q->priv_data;
  74         struct bttv *btv = fh->btv;
  75 
  76         if (0 == *count)
  77                 *count = vbibufs;
  78 
  79         *size = IMAGE_SIZE(&fh->vbi_fmt.fmt);
  80 
  81         dprintk("setup: samples=%u start=%d,%d count=%u,%u\n",
  82                 fh->vbi_fmt.fmt.samples_per_line,
  83                 fh->vbi_fmt.fmt.start[0],
  84                 fh->vbi_fmt.fmt.start[1],
  85                 fh->vbi_fmt.fmt.count[0],
  86                 fh->vbi_fmt.fmt.count[1]);
  87 
  88         return 0;
  89 }
  90 
  91 static int vbi_buffer_prepare(struct videobuf_queue *q,
  92                               struct videobuf_buffer *vb,
  93                               enum v4l2_field field)
  94 {
  95         struct bttv_fh *fh = q->priv_data;
  96         struct bttv *btv = fh->btv;
  97         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
  98         const struct bttv_tvnorm *tvnorm;
  99         unsigned int skip_lines0, skip_lines1, min_vdelay;
 100         int redo_dma_risc;
 101         int rc;
 102 
 103         buf->vb.size = IMAGE_SIZE(&fh->vbi_fmt.fmt);
 104         if (0 != buf->vb.baddr  &&  buf->vb.bsize < buf->vb.size)
 105                 return -EINVAL;
 106 
 107         tvnorm = fh->vbi_fmt.tvnorm;
 108 
 109         /* There's no VBI_VDELAY register, RISC must skip the lines
 110            we don't want. With default parameters we skip zero lines
 111            as earlier driver versions did. The driver permits video
 112            standard changes while capturing, so we use vbi_fmt.tvnorm
 113            instead of btv->tvnorm to skip zero lines after video
 114            standard changes as well. */
 115 
 116         skip_lines0 = 0;
 117         skip_lines1 = 0;
 118 
 119         if (fh->vbi_fmt.fmt.count[0] > 0)
 120                 skip_lines0 = max(0, (fh->vbi_fmt.fmt.start[0]
 121                                       - tvnorm->vbistart[0]));
 122         if (fh->vbi_fmt.fmt.count[1] > 0)
 123                 skip_lines1 = max(0, (fh->vbi_fmt.fmt.start[1]
 124                                       - tvnorm->vbistart[1]));
 125 
 126         redo_dma_risc = 0;
 127 
 128         if (buf->vbi_skip[0] != skip_lines0 ||
 129             buf->vbi_skip[1] != skip_lines1 ||
 130             buf->vbi_count[0] != fh->vbi_fmt.fmt.count[0] ||
 131             buf->vbi_count[1] != fh->vbi_fmt.fmt.count[1]) {
 132                 buf->vbi_skip[0] = skip_lines0;
 133                 buf->vbi_skip[1] = skip_lines1;
 134                 buf->vbi_count[0] = fh->vbi_fmt.fmt.count[0];
 135                 buf->vbi_count[1] = fh->vbi_fmt.fmt.count[1];
 136                 redo_dma_risc = 1;
 137         }
 138 
 139         if (VIDEOBUF_NEEDS_INIT == buf->vb.state) {
 140                 redo_dma_risc = 1;
 141                 if (0 != (rc = videobuf_iolock(q, &buf->vb, NULL)))
 142                         goto fail;
 143         }
 144 
 145         if (redo_dma_risc) {
 146                 unsigned int bpl, padding, offset;
 147                 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
 148 
 149                 bpl = 2044; /* max. vbipack */
 150                 padding = VBI_BPL - bpl;
 151 
 152                 if (fh->vbi_fmt.fmt.count[0] > 0) {
 153                         rc = bttv_risc_packed(btv, &buf->top,
 154                                               dma->sglist,
 155                                               /* offset */ 0, bpl,
 156                                               padding, skip_lines0,
 157                                               fh->vbi_fmt.fmt.count[0]);
 158                         if (0 != rc)
 159                                 goto fail;
 160                 }
 161 
 162                 if (fh->vbi_fmt.fmt.count[1] > 0) {
 163                         offset = fh->vbi_fmt.fmt.count[0] * VBI_BPL;
 164 
 165                         rc = bttv_risc_packed(btv, &buf->bottom,
 166                                               dma->sglist,
 167                                               offset, bpl,
 168                                               padding, skip_lines1,
 169                                               fh->vbi_fmt.fmt.count[1]);
 170                         if (0 != rc)
 171                                 goto fail;
 172                 }
 173         }
 174 
 175         /* VBI capturing ends at VDELAY, start of video capturing,
 176            no matter where the RISC program ends. VDELAY minimum is 2,
 177            bounds.top is the corresponding first field line number
 178            times two. VDELAY counts half field lines. */
 179         min_vdelay = MIN_VDELAY;
 180         if (fh->vbi_fmt.end >= tvnorm->cropcap.bounds.top)
 181                 min_vdelay += fh->vbi_fmt.end - tvnorm->cropcap.bounds.top;
 182 
 183         /* For bttv_buffer_activate_vbi(). */
 184         buf->geo.vdelay = min_vdelay;
 185 
 186         buf->vb.state = VIDEOBUF_PREPARED;
 187         buf->vb.field = field;
 188         dprintk("buf prepare %p: top=%p bottom=%p field=%s\n",
 189                 vb, &buf->top, &buf->bottom,
 190                 v4l2_field_names[buf->vb.field]);
 191         return 0;
 192 
 193  fail:
 194         bttv_dma_free(q,btv,buf);
 195         return rc;
 196 }
 197 
 198 static void
 199 vbi_buffer_queue(struct videobuf_queue *q, struct videobuf_buffer *vb)
 200 {
 201         struct bttv_fh *fh = q->priv_data;
 202         struct bttv *btv = fh->btv;
 203         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
 204 
 205         dprintk("queue %p\n",vb);
 206         buf->vb.state = VIDEOBUF_QUEUED;
 207         list_add_tail(&buf->vb.queue,&btv->vcapture);
 208         if (NULL == btv->cvbi) {
 209                 fh->btv->loop_irq |= 4;
 210                 bttv_set_dma(btv,0x0c);
 211         }
 212 }
 213 
 214 static void vbi_buffer_release(struct videobuf_queue *q, struct videobuf_buffer *vb)
 215 {
 216         struct bttv_fh *fh = q->priv_data;
 217         struct bttv *btv = fh->btv;
 218         struct bttv_buffer *buf = container_of(vb,struct bttv_buffer,vb);
 219 
 220         dprintk("free %p\n",vb);
 221         bttv_dma_free(q,fh->btv,buf);
 222 }
 223 
 224 const struct videobuf_queue_ops bttv_vbi_qops = {
 225         .buf_setup    = vbi_buffer_setup,
 226         .buf_prepare  = vbi_buffer_prepare,
 227         .buf_queue    = vbi_buffer_queue,
 228         .buf_release  = vbi_buffer_release,
 229 };
 230 
 231 /* ----------------------------------------------------------------------- */
 232 
 233 static int try_fmt(struct v4l2_vbi_format *f, const struct bttv_tvnorm *tvnorm,
 234                         __s32 crop_start)
 235 {
 236         __s32 min_start, max_start, max_end, f2_offset;
 237         unsigned int i;
 238 
 239         /* For compatibility with earlier driver versions we must pretend
 240            the VBI and video capture window may overlap. In reality RISC
 241            magic aborts VBI capturing at the first line of video capturing,
 242            leaving the rest of the buffer unchanged, usually all zero.
 243            VBI capturing must always start before video capturing. >> 1
 244            because cropping counts field lines times two. */
 245         min_start = tvnorm->vbistart[0];
 246         max_start = (crop_start >> 1) - 1;
 247         max_end = (tvnorm->cropcap.bounds.top
 248                    + tvnorm->cropcap.bounds.height) >> 1;
 249 
 250         if (min_start > max_start)
 251                 return -EBUSY;
 252 
 253         BUG_ON(max_start >= max_end);
 254 
 255         f->sampling_rate    = tvnorm->Fsc;
 256         f->samples_per_line = VBI_BPL;
 257         f->sample_format    = V4L2_PIX_FMT_GREY;
 258         f->offset           = VBI_OFFSET;
 259 
 260         f2_offset = tvnorm->vbistart[1] - tvnorm->vbistart[0];
 261 
 262         for (i = 0; i < 2; ++i) {
 263                 if (0 == f->count[i]) {
 264                         /* No data from this field. We leave f->start[i]
 265                            alone because VIDIOCSVBIFMT is w/o and EINVALs
 266                            when a driver does not support exactly the
 267                            requested parameters. */
 268                 } else {
 269                         s64 start, count;
 270 
 271                         start = clamp(f->start[i], min_start, max_start);
 272                         /* s64 to prevent overflow. */
 273                         count = (s64) f->start[i] + f->count[i] - start;
 274                         f->start[i] = start;
 275                         f->count[i] = clamp(count, (s64) 1,
 276                                             max_end - start);
 277                 }
 278 
 279                 min_start += f2_offset;
 280                 max_start += f2_offset;
 281                 max_end += f2_offset;
 282         }
 283 
 284         if (0 == (f->count[0] | f->count[1])) {
 285                 /* As in earlier driver versions. */
 286                 f->start[0] = tvnorm->vbistart[0];
 287                 f->start[1] = tvnorm->vbistart[1];
 288                 f->count[0] = 1;
 289                 f->count[1] = 1;
 290         }
 291 
 292         f->flags = 0;
 293 
 294         f->reserved[0] = 0;
 295         f->reserved[1] = 0;
 296 
 297         return 0;
 298 }
 299 
 300 int bttv_try_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
 301 {
 302         struct bttv_fh *fh = f;
 303         struct bttv *btv = fh->btv;
 304         const struct bttv_tvnorm *tvnorm;
 305         __s32 crop_start;
 306 
 307         mutex_lock(&btv->lock);
 308 
 309         tvnorm = &bttv_tvnorms[btv->tvnorm];
 310         crop_start = btv->crop_start;
 311 
 312         mutex_unlock(&btv->lock);
 313 
 314         return try_fmt(&frt->fmt.vbi, tvnorm, crop_start);
 315 }
 316 
 317 
 318 int bttv_s_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
 319 {
 320         struct bttv_fh *fh = f;
 321         struct bttv *btv = fh->btv;
 322         const struct bttv_tvnorm *tvnorm;
 323         __s32 start1, end;
 324         int rc;
 325 
 326         mutex_lock(&btv->lock);
 327 
 328         rc = -EBUSY;
 329         if (fh->resources & RESOURCE_VBI)
 330                 goto fail;
 331 
 332         tvnorm = &bttv_tvnorms[btv->tvnorm];
 333 
 334         rc = try_fmt(&frt->fmt.vbi, tvnorm, btv->crop_start);
 335         if (0 != rc)
 336                 goto fail;
 337 
 338         start1 = frt->fmt.vbi.start[1] - tvnorm->vbistart[1] +
 339                 tvnorm->vbistart[0];
 340 
 341         /* First possible line of video capturing. Should be
 342            max(f->start[0] + f->count[0], start1 + f->count[1]) * 2
 343            when capturing both fields. But for compatibility we must
 344            pretend the VBI and video capture window may overlap,
 345            so end = start + 1, the lowest possible value, times two
 346            because vbi_fmt.end counts field lines times two. */
 347         end = max(frt->fmt.vbi.start[0], start1) * 2 + 2;
 348 
 349         mutex_lock(&fh->vbi.vb_lock);
 350 
 351         fh->vbi_fmt.fmt    = frt->fmt.vbi;
 352         fh->vbi_fmt.tvnorm = tvnorm;
 353         fh->vbi_fmt.end    = end;
 354 
 355         mutex_unlock(&fh->vbi.vb_lock);
 356 
 357         rc = 0;
 358 
 359  fail:
 360         mutex_unlock(&btv->lock);
 361 
 362         return rc;
 363 }
 364 
 365 
 366 int bttv_g_fmt_vbi_cap(struct file *file, void *f, struct v4l2_format *frt)
 367 {
 368         struct bttv_fh *fh = f;
 369         const struct bttv_tvnorm *tvnorm;
 370 
 371         frt->fmt.vbi = fh->vbi_fmt.fmt;
 372 
 373         tvnorm = &bttv_tvnorms[fh->btv->tvnorm];
 374 
 375         if (tvnorm != fh->vbi_fmt.tvnorm) {
 376                 __s32 max_end;
 377                 unsigned int i;
 378 
 379                 /* As in vbi_buffer_prepare() this imitates the
 380                    behaviour of earlier driver versions after video
 381                    standard changes, with default parameters anyway. */
 382 
 383                 max_end = (tvnorm->cropcap.bounds.top
 384                            + tvnorm->cropcap.bounds.height) >> 1;
 385 
 386                 frt->fmt.vbi.sampling_rate = tvnorm->Fsc;
 387 
 388                 for (i = 0; i < 2; ++i) {
 389                         __s32 new_start;
 390 
 391                         new_start = frt->fmt.vbi.start[i]
 392                                 + tvnorm->vbistart[i]
 393                                 - fh->vbi_fmt.tvnorm->vbistart[i];
 394 
 395                         frt->fmt.vbi.start[i] = min(new_start, max_end - 1);
 396                         frt->fmt.vbi.count[i] =
 397                                 min((__s32) frt->fmt.vbi.count[i],
 398                                           max_end - frt->fmt.vbi.start[i]);
 399 
 400                         max_end += tvnorm->vbistart[1]
 401                                 - tvnorm->vbistart[0];
 402                 }
 403         }
 404         return 0;
 405 }
 406 
 407 void bttv_vbi_fmt_reset(struct bttv_vbi_fmt *f, unsigned int norm)
 408 {
 409         const struct bttv_tvnorm *tvnorm;
 410         unsigned int real_samples_per_line;
 411         unsigned int real_count;
 412 
 413         tvnorm = &bttv_tvnorms[norm];
 414 
 415         f->fmt.sampling_rate    = tvnorm->Fsc;
 416         f->fmt.samples_per_line = VBI_BPL;
 417         f->fmt.sample_format    = V4L2_PIX_FMT_GREY;
 418         f->fmt.offset           = VBI_OFFSET;
 419         f->fmt.start[0]         = tvnorm->vbistart[0];
 420         f->fmt.start[1]         = tvnorm->vbistart[1];
 421         f->fmt.count[0]         = VBI_DEFLINES;
 422         f->fmt.count[1]         = VBI_DEFLINES;
 423         f->fmt.flags            = 0;
 424         f->fmt.reserved[0]      = 0;
 425         f->fmt.reserved[1]      = 0;
 426 
 427         /* For compatibility the buffer size must be 2 * VBI_DEFLINES *
 428            VBI_BPL regardless of the current video standard. */
 429         real_samples_per_line   = 1024 + tvnorm->vbipack * 4;
 430         real_count              = ((tvnorm->cropcap.defrect.top >> 1)
 431                                    - tvnorm->vbistart[0]);
 432 
 433         BUG_ON(real_samples_per_line > VBI_BPL);
 434         BUG_ON(real_count > VBI_DEFLINES);
 435 
 436         f->tvnorm               = tvnorm;
 437 
 438         /* See bttv_vbi_fmt_set(). */
 439         f->end                  = tvnorm->vbistart[0] * 2 + 2;
 440 }