drivers/media/video/bt8xx/bttv-vbi.c

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