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 } 441