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