1/* 2 3 bttv-risc.c -- interfaces to other kernel modules 4 5 bttv risc code handling 6 - memory management 7 - generation 8 9 (c) 2000-2003 Gerd Knorr <kraxel@bytesex.org> 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 27#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 28 29#include <linux/module.h> 30#include <linux/init.h> 31#include <linux/slab.h> 32#include <linux/pci.h> 33#include <linux/vmalloc.h> 34#include <linux/interrupt.h> 35#include <asm/page.h> 36#include <asm/pgtable.h> 37#include <media/v4l2-ioctl.h> 38 39#include "bttvp.h" 40 41#define VCR_HACK_LINES 4 42 43/* ---------------------------------------------------------- */ 44/* risc code generators */ 45 46int 47bttv_risc_packed(struct bttv *btv, struct btcx_riscmem *risc, 48 struct scatterlist *sglist, 49 unsigned int offset, unsigned int bpl, 50 unsigned int padding, unsigned int skip_lines, 51 unsigned int store_lines) 52{ 53 u32 instructions,line,todo; 54 struct scatterlist *sg; 55 __le32 *rp; 56 int rc; 57 58 /* estimate risc mem: worst case is one write per page border + 59 one write per scan line + sync + jump (all 2 dwords). padding 60 can cause next bpl to start close to a page border. First DMA 61 region may be smaller than PAGE_SIZE */ 62 instructions = skip_lines * 4; 63 instructions += (1 + ((bpl + padding) * store_lines) 64 / PAGE_SIZE + store_lines) * 8; 65 instructions += 2 * 8; 66 if ((rc = btcx_riscmem_alloc(btv->c.pci,risc,instructions)) < 0) 67 return rc; 68 69 /* sync instruction */ 70 rp = risc->cpu; 71 *(rp++) = cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM1); 72 *(rp++) = cpu_to_le32(0); 73 74 while (skip_lines-- > 0) { 75 *(rp++) = cpu_to_le32(BT848_RISC_SKIP | BT848_RISC_SOL | 76 BT848_RISC_EOL | bpl); 77 } 78 79 /* scan lines */ 80 sg = sglist; 81 for (line = 0; line < store_lines; line++) { 82 if ((btv->opt_vcr_hack) && 83 (line >= (store_lines - VCR_HACK_LINES))) 84 continue; 85 while (offset && offset >= sg_dma_len(sg)) { 86 offset -= sg_dma_len(sg); 87 sg = sg_next(sg); 88 } 89 if (bpl <= sg_dma_len(sg)-offset) { 90 /* fits into current chunk */ 91 *(rp++)=cpu_to_le32(BT848_RISC_WRITE|BT848_RISC_SOL| 92 BT848_RISC_EOL|bpl); 93 *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset); 94 offset+=bpl; 95 } else { 96 /* scanline needs to be splitted */ 97 todo = bpl; 98 *(rp++)=cpu_to_le32(BT848_RISC_WRITE|BT848_RISC_SOL| 99 (sg_dma_len(sg)-offset)); 100 *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset); 101 todo -= (sg_dma_len(sg)-offset); 102 offset = 0; 103 sg = sg_next(sg); 104 while (todo > sg_dma_len(sg)) { 105 *(rp++)=cpu_to_le32(BT848_RISC_WRITE| 106 sg_dma_len(sg)); 107 *(rp++)=cpu_to_le32(sg_dma_address(sg)); 108 todo -= sg_dma_len(sg); 109 sg = sg_next(sg); 110 } 111 *(rp++)=cpu_to_le32(BT848_RISC_WRITE|BT848_RISC_EOL| 112 todo); 113 *(rp++)=cpu_to_le32(sg_dma_address(sg)); 114 offset += todo; 115 } 116 offset += padding; 117 } 118 119 /* save pointer to jmp instruction address */ 120 risc->jmp = rp; 121 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size); 122 return 0; 123} 124 125static int 126bttv_risc_planar(struct bttv *btv, struct btcx_riscmem *risc, 127 struct scatterlist *sglist, 128 unsigned int yoffset, unsigned int ybpl, 129 unsigned int ypadding, unsigned int ylines, 130 unsigned int uoffset, unsigned int voffset, 131 unsigned int hshift, unsigned int vshift, 132 unsigned int cpadding) 133{ 134 unsigned int instructions,line,todo,ylen,chroma; 135 __le32 *rp; 136 u32 ri; 137 struct scatterlist *ysg; 138 struct scatterlist *usg; 139 struct scatterlist *vsg; 140 int topfield = (0 == yoffset); 141 int rc; 142 143 /* estimate risc mem: worst case is one write per page border + 144 one write per scan line (5 dwords) 145 plus sync + jump (2 dwords) */ 146 instructions = ((3 + (ybpl + ypadding) * ylines * 2) 147 / PAGE_SIZE) + ylines; 148 instructions += 2; 149 if ((rc = btcx_riscmem_alloc(btv->c.pci,risc,instructions*4*5)) < 0) 150 return rc; 151 152 /* sync instruction */ 153 rp = risc->cpu; 154 *(rp++) = cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM3); 155 *(rp++) = cpu_to_le32(0); 156 157 /* scan lines */ 158 ysg = sglist; 159 usg = sglist; 160 vsg = sglist; 161 for (line = 0; line < ylines; line++) { 162 if ((btv->opt_vcr_hack) && 163 (line >= (ylines - VCR_HACK_LINES))) 164 continue; 165 switch (vshift) { 166 case 0: 167 chroma = 1; 168 break; 169 case 1: 170 if (topfield) 171 chroma = ((line & 1) == 0); 172 else 173 chroma = ((line & 1) == 1); 174 break; 175 case 2: 176 if (topfield) 177 chroma = ((line & 3) == 0); 178 else 179 chroma = ((line & 3) == 2); 180 break; 181 default: 182 chroma = 0; 183 break; 184 } 185 186 for (todo = ybpl; todo > 0; todo -= ylen) { 187 /* go to next sg entry if needed */ 188 while (yoffset && yoffset >= sg_dma_len(ysg)) { 189 yoffset -= sg_dma_len(ysg); 190 ysg = sg_next(ysg); 191 } 192 while (uoffset && uoffset >= sg_dma_len(usg)) { 193 uoffset -= sg_dma_len(usg); 194 usg = sg_next(usg); 195 } 196 while (voffset && voffset >= sg_dma_len(vsg)) { 197 voffset -= sg_dma_len(vsg); 198 vsg = sg_next(vsg); 199 } 200 201 /* calculate max number of bytes we can write */ 202 ylen = todo; 203 if (yoffset + ylen > sg_dma_len(ysg)) 204 ylen = sg_dma_len(ysg) - yoffset; 205 if (chroma) { 206 if (uoffset + (ylen>>hshift) > sg_dma_len(usg)) 207 ylen = (sg_dma_len(usg) - uoffset) << hshift; 208 if (voffset + (ylen>>hshift) > sg_dma_len(vsg)) 209 ylen = (sg_dma_len(vsg) - voffset) << hshift; 210 ri = BT848_RISC_WRITE123; 211 } else { 212 ri = BT848_RISC_WRITE1S23; 213 } 214 if (ybpl == todo) 215 ri |= BT848_RISC_SOL; 216 if (ylen == todo) 217 ri |= BT848_RISC_EOL; 218 219 /* write risc instruction */ 220 *(rp++)=cpu_to_le32(ri | ylen); 221 *(rp++)=cpu_to_le32(((ylen >> hshift) << 16) | 222 (ylen >> hshift)); 223 *(rp++)=cpu_to_le32(sg_dma_address(ysg)+yoffset); 224 yoffset += ylen; 225 if (chroma) { 226 *(rp++)=cpu_to_le32(sg_dma_address(usg)+uoffset); 227 uoffset += ylen >> hshift; 228 *(rp++)=cpu_to_le32(sg_dma_address(vsg)+voffset); 229 voffset += ylen >> hshift; 230 } 231 } 232 yoffset += ypadding; 233 if (chroma) { 234 uoffset += cpadding; 235 voffset += cpadding; 236 } 237 } 238 239 /* save pointer to jmp instruction address */ 240 risc->jmp = rp; 241 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size); 242 return 0; 243} 244 245static int 246bttv_risc_overlay(struct bttv *btv, struct btcx_riscmem *risc, 247 const struct bttv_format *fmt, struct bttv_overlay *ov, 248 int skip_even, int skip_odd) 249{ 250 int dwords, rc, line, maxy, start, end; 251 unsigned skip, nskips; 252 struct btcx_skiplist *skips; 253 __le32 *rp; 254 u32 ri,ra; 255 u32 addr; 256 257 /* skip list for window clipping */ 258 if (NULL == (skips = kmalloc(sizeof(*skips) * ov->nclips,GFP_KERNEL))) 259 return -ENOMEM; 260 261 /* estimate risc mem: worst case is (1.5*clip+1) * lines instructions 262 + sync + jump (all 2 dwords) */ 263 dwords = (3 * ov->nclips + 2) * 264 ((skip_even || skip_odd) ? (ov->w.height+1)>>1 : ov->w.height); 265 dwords += 4; 266 if ((rc = btcx_riscmem_alloc(btv->c.pci,risc,dwords*4)) < 0) { 267 kfree(skips); 268 return rc; 269 } 270 271 /* sync instruction */ 272 rp = risc->cpu; 273 *(rp++) = cpu_to_le32(BT848_RISC_SYNC|BT848_FIFO_STATUS_FM1); 274 *(rp++) = cpu_to_le32(0); 275 276 addr = (unsigned long)btv->fbuf.base; 277 addr += btv->fbuf.fmt.bytesperline * ov->w.top; 278 addr += (fmt->depth >> 3) * ov->w.left; 279 280 /* scan lines */ 281 for (maxy = -1, line = 0; line < ov->w.height; 282 line++, addr += btv->fbuf.fmt.bytesperline) { 283 if ((btv->opt_vcr_hack) && 284 (line >= (ov->w.height - VCR_HACK_LINES))) 285 continue; 286 if ((line%2) == 0 && skip_even) 287 continue; 288 if ((line%2) == 1 && skip_odd) 289 continue; 290 291 /* calculate clipping */ 292 if (line > maxy) 293 btcx_calc_skips(line, ov->w.width, &maxy, 294 skips, &nskips, ov->clips, ov->nclips); 295 296 /* write out risc code */ 297 for (start = 0, skip = 0; start < ov->w.width; start = end) { 298 if (skip >= nskips) { 299 ri = BT848_RISC_WRITE; 300 end = ov->w.width; 301 } else if (start < skips[skip].start) { 302 ri = BT848_RISC_WRITE; 303 end = skips[skip].start; 304 } else { 305 ri = BT848_RISC_SKIP; 306 end = skips[skip].end; 307 skip++; 308 } 309 if (BT848_RISC_WRITE == ri) 310 ra = addr + (fmt->depth>>3)*start; 311 else 312 ra = 0; 313 314 if (0 == start) 315 ri |= BT848_RISC_SOL; 316 if (ov->w.width == end) 317 ri |= BT848_RISC_EOL; 318 ri |= (fmt->depth>>3) * (end-start); 319 320 *(rp++)=cpu_to_le32(ri); 321 if (0 != ra) 322 *(rp++)=cpu_to_le32(ra); 323 } 324 } 325 326 /* save pointer to jmp instruction address */ 327 risc->jmp = rp; 328 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size); 329 kfree(skips); 330 return 0; 331} 332 333/* ---------------------------------------------------------- */ 334 335static void 336bttv_calc_geo_old(struct bttv *btv, struct bttv_geometry *geo, 337 int width, int height, int interleaved, 338 const struct bttv_tvnorm *tvnorm) 339{ 340 u32 xsf, sr; 341 int vdelay; 342 343 int swidth = tvnorm->swidth; 344 int totalwidth = tvnorm->totalwidth; 345 int scaledtwidth = tvnorm->scaledtwidth; 346 347 if (btv->input == btv->dig) { 348 swidth = 720; 349 totalwidth = 858; 350 scaledtwidth = 858; 351 } 352 353 vdelay = tvnorm->vdelay; 354 355 xsf = (width*scaledtwidth)/swidth; 356 geo->hscale = ((totalwidth*4096UL)/xsf-4096); 357 geo->hdelay = tvnorm->hdelayx1; 358 geo->hdelay = (geo->hdelay*width)/swidth; 359 geo->hdelay &= 0x3fe; 360 sr = ((tvnorm->sheight >> (interleaved?0:1))*512)/height - 512; 361 geo->vscale = (0x10000UL-sr) & 0x1fff; 362 geo->crop = ((width>>8)&0x03) | ((geo->hdelay>>6)&0x0c) | 363 ((tvnorm->sheight>>4)&0x30) | ((vdelay>>2)&0xc0); 364 geo->vscale |= interleaved ? (BT848_VSCALE_INT<<8) : 0; 365 geo->vdelay = vdelay; 366 geo->width = width; 367 geo->sheight = tvnorm->sheight; 368 geo->vtotal = tvnorm->vtotal; 369 370 if (btv->opt_combfilter) { 371 geo->vtc = (width < 193) ? 2 : ((width < 385) ? 1 : 0); 372 geo->comb = (width < 769) ? 1 : 0; 373 } else { 374 geo->vtc = 0; 375 geo->comb = 0; 376 } 377} 378 379static void 380bttv_calc_geo (struct bttv * btv, 381 struct bttv_geometry * geo, 382 unsigned int width, 383 unsigned int height, 384 int both_fields, 385 const struct bttv_tvnorm * tvnorm, 386 const struct v4l2_rect * crop) 387{ 388 unsigned int c_width; 389 unsigned int c_height; 390 u32 sr; 391 392 if ((crop->left == tvnorm->cropcap.defrect.left 393 && crop->top == tvnorm->cropcap.defrect.top 394 && crop->width == tvnorm->cropcap.defrect.width 395 && crop->height == tvnorm->cropcap.defrect.height 396 && width <= tvnorm->swidth /* see PAL-Nc et al */) 397 || btv->input == btv->dig) { 398 bttv_calc_geo_old(btv, geo, width, height, 399 both_fields, tvnorm); 400 return; 401 } 402 403 /* For bug compatibility the image size checks permit scale 404 factors > 16. See bttv_crop_calc_limits(). */ 405 c_width = min((unsigned int) crop->width, width * 16); 406 c_height = min((unsigned int) crop->height, height * 16); 407 408 geo->width = width; 409 geo->hscale = (c_width * 4096U + (width >> 1)) / width - 4096; 410 /* Even to store Cb first, odd for Cr. */ 411 geo->hdelay = ((crop->left * width + c_width) / c_width) & ~1; 412 413 geo->sheight = c_height; 414 geo->vdelay = crop->top - tvnorm->cropcap.bounds.top + MIN_VDELAY; 415 sr = c_height >> !both_fields; 416 sr = (sr * 512U + (height >> 1)) / height - 512; 417 geo->vscale = (0x10000UL - sr) & 0x1fff; 418 geo->vscale |= both_fields ? (BT848_VSCALE_INT << 8) : 0; 419 geo->vtotal = tvnorm->vtotal; 420 421 geo->crop = (((geo->width >> 8) & 0x03) | 422 ((geo->hdelay >> 6) & 0x0c) | 423 ((geo->sheight >> 4) & 0x30) | 424 ((geo->vdelay >> 2) & 0xc0)); 425 426 if (btv->opt_combfilter) { 427 geo->vtc = (width < 193) ? 2 : ((width < 385) ? 1 : 0); 428 geo->comb = (width < 769) ? 1 : 0; 429 } else { 430 geo->vtc = 0; 431 geo->comb = 0; 432 } 433} 434 435static void 436bttv_apply_geo(struct bttv *btv, struct bttv_geometry *geo, int odd) 437{ 438 int off = odd ? 0x80 : 0x00; 439 440 if (geo->comb) 441 btor(BT848_VSCALE_COMB, BT848_E_VSCALE_HI+off); 442 else 443 btand(~BT848_VSCALE_COMB, BT848_E_VSCALE_HI+off); 444 445 btwrite(geo->vtc, BT848_E_VTC+off); 446 btwrite(geo->hscale >> 8, BT848_E_HSCALE_HI+off); 447 btwrite(geo->hscale & 0xff, BT848_E_HSCALE_LO+off); 448 btaor((geo->vscale>>8), 0xe0, BT848_E_VSCALE_HI+off); 449 btwrite(geo->vscale & 0xff, BT848_E_VSCALE_LO+off); 450 btwrite(geo->width & 0xff, BT848_E_HACTIVE_LO+off); 451 btwrite(geo->hdelay & 0xff, BT848_E_HDELAY_LO+off); 452 btwrite(geo->sheight & 0xff, BT848_E_VACTIVE_LO+off); 453 btwrite(geo->vdelay & 0xff, BT848_E_VDELAY_LO+off); 454 btwrite(geo->crop, BT848_E_CROP+off); 455 btwrite(geo->vtotal>>8, BT848_VTOTAL_HI); 456 btwrite(geo->vtotal & 0xff, BT848_VTOTAL_LO); 457} 458 459/* ---------------------------------------------------------- */ 460/* risc group / risc main loop / dma management */ 461 462void 463bttv_set_dma(struct bttv *btv, int override) 464{ 465 unsigned long cmd; 466 int capctl; 467 468 btv->cap_ctl = 0; 469 if (NULL != btv->curr.top) btv->cap_ctl |= 0x02; 470 if (NULL != btv->curr.bottom) btv->cap_ctl |= 0x01; 471 if (NULL != btv->cvbi) btv->cap_ctl |= 0x0c; 472 473 capctl = 0; 474 capctl |= (btv->cap_ctl & 0x03) ? 0x03 : 0x00; /* capture */ 475 capctl |= (btv->cap_ctl & 0x0c) ? 0x0c : 0x00; /* vbi data */ 476 capctl |= override; 477 478 d2printk("%d: capctl=%x lirq=%d top=%08llx/%08llx even=%08llx/%08llx\n", 479 btv->c.nr,capctl,btv->loop_irq, 480 btv->cvbi ? (unsigned long long)btv->cvbi->top.dma : 0, 481 btv->curr.top ? (unsigned long long)btv->curr.top->top.dma : 0, 482 btv->cvbi ? (unsigned long long)btv->cvbi->bottom.dma : 0, 483 btv->curr.bottom ? (unsigned long long)btv->curr.bottom->bottom.dma : 0); 484 485 cmd = BT848_RISC_JUMP; 486 if (btv->loop_irq) { 487 cmd |= BT848_RISC_IRQ; 488 cmd |= (btv->loop_irq & 0x0f) << 16; 489 cmd |= (~btv->loop_irq & 0x0f) << 20; 490 } 491 if (btv->curr.frame_irq || btv->loop_irq || btv->cvbi) { 492 mod_timer(&btv->timeout, jiffies+BTTV_TIMEOUT); 493 } else { 494 del_timer(&btv->timeout); 495 } 496 btv->main.cpu[RISC_SLOT_LOOP] = cpu_to_le32(cmd); 497 498 btaor(capctl, ~0x0f, BT848_CAP_CTL); 499 if (capctl) { 500 if (btv->dma_on) 501 return; 502 btwrite(btv->main.dma, BT848_RISC_STRT_ADD); 503 btor(3, BT848_GPIO_DMA_CTL); 504 btv->dma_on = 1; 505 } else { 506 if (!btv->dma_on) 507 return; 508 btand(~3, BT848_GPIO_DMA_CTL); 509 btv->dma_on = 0; 510 } 511 return; 512} 513 514int 515bttv_risc_init_main(struct bttv *btv) 516{ 517 int rc; 518 519 if ((rc = btcx_riscmem_alloc(btv->c.pci,&btv->main,PAGE_SIZE)) < 0) 520 return rc; 521 dprintk("%d: risc main @ %08llx\n", 522 btv->c.nr, (unsigned long long)btv->main.dma); 523 524 btv->main.cpu[0] = cpu_to_le32(BT848_RISC_SYNC | BT848_RISC_RESYNC | 525 BT848_FIFO_STATUS_VRE); 526 btv->main.cpu[1] = cpu_to_le32(0); 527 btv->main.cpu[2] = cpu_to_le32(BT848_RISC_JUMP); 528 btv->main.cpu[3] = cpu_to_le32(btv->main.dma + (4<<2)); 529 530 /* top field */ 531 btv->main.cpu[4] = cpu_to_le32(BT848_RISC_JUMP); 532 btv->main.cpu[5] = cpu_to_le32(btv->main.dma + (6<<2)); 533 btv->main.cpu[6] = cpu_to_le32(BT848_RISC_JUMP); 534 btv->main.cpu[7] = cpu_to_le32(btv->main.dma + (8<<2)); 535 536 btv->main.cpu[8] = cpu_to_le32(BT848_RISC_SYNC | BT848_RISC_RESYNC | 537 BT848_FIFO_STATUS_VRO); 538 btv->main.cpu[9] = cpu_to_le32(0); 539 540 /* bottom field */ 541 btv->main.cpu[10] = cpu_to_le32(BT848_RISC_JUMP); 542 btv->main.cpu[11] = cpu_to_le32(btv->main.dma + (12<<2)); 543 btv->main.cpu[12] = cpu_to_le32(BT848_RISC_JUMP); 544 btv->main.cpu[13] = cpu_to_le32(btv->main.dma + (14<<2)); 545 546 /* jump back to top field */ 547 btv->main.cpu[14] = cpu_to_le32(BT848_RISC_JUMP); 548 btv->main.cpu[15] = cpu_to_le32(btv->main.dma + (0<<2)); 549 550 return 0; 551} 552 553int 554bttv_risc_hook(struct bttv *btv, int slot, struct btcx_riscmem *risc, 555 int irqflags) 556{ 557 unsigned long cmd; 558 unsigned long next = btv->main.dma + ((slot+2) << 2); 559 560 if (NULL == risc) { 561 d2printk("%d: risc=%p slot[%d]=NULL\n", btv->c.nr, risc, slot); 562 btv->main.cpu[slot+1] = cpu_to_le32(next); 563 } else { 564 d2printk("%d: risc=%p slot[%d]=%08llx irq=%d\n", 565 btv->c.nr, risc, slot, 566 (unsigned long long)risc->dma, irqflags); 567 cmd = BT848_RISC_JUMP; 568 if (irqflags) { 569 cmd |= BT848_RISC_IRQ; 570 cmd |= (irqflags & 0x0f) << 16; 571 cmd |= (~irqflags & 0x0f) << 20; 572 } 573 risc->jmp[0] = cpu_to_le32(cmd); 574 risc->jmp[1] = cpu_to_le32(next); 575 btv->main.cpu[slot+1] = cpu_to_le32(risc->dma); 576 } 577 return 0; 578} 579 580void 581bttv_dma_free(struct videobuf_queue *q,struct bttv *btv, struct bttv_buffer *buf) 582{ 583 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb); 584 585 BUG_ON(in_interrupt()); 586 videobuf_waiton(q, &buf->vb, 0, 0); 587 videobuf_dma_unmap(q->dev, dma); 588 videobuf_dma_free(dma); 589 btcx_riscmem_free(btv->c.pci,&buf->bottom); 590 btcx_riscmem_free(btv->c.pci,&buf->top); 591 buf->vb.state = VIDEOBUF_NEEDS_INIT; 592} 593 594int 595bttv_buffer_activate_vbi(struct bttv *btv, 596 struct bttv_buffer *vbi) 597{ 598 struct btcx_riscmem *top; 599 struct btcx_riscmem *bottom; 600 int top_irq_flags; 601 int bottom_irq_flags; 602 603 top = NULL; 604 bottom = NULL; 605 top_irq_flags = 0; 606 bottom_irq_flags = 0; 607 608 if (vbi) { 609 unsigned int crop, vdelay; 610 611 vbi->vb.state = VIDEOBUF_ACTIVE; 612 list_del(&vbi->vb.queue); 613 614 /* VDELAY is start of video, end of VBI capturing. */ 615 crop = btread(BT848_E_CROP); 616 vdelay = btread(BT848_E_VDELAY_LO) + ((crop & 0xc0) << 2); 617 618 if (vbi->geo.vdelay > vdelay) { 619 vdelay = vbi->geo.vdelay & 0xfe; 620 crop = (crop & 0x3f) | ((vbi->geo.vdelay >> 2) & 0xc0); 621 622 btwrite(vdelay, BT848_E_VDELAY_LO); 623 btwrite(crop, BT848_E_CROP); 624 btwrite(vdelay, BT848_O_VDELAY_LO); 625 btwrite(crop, BT848_O_CROP); 626 } 627 628 if (vbi->vbi_count[0] > 0) { 629 top = &vbi->top; 630 top_irq_flags = 4; 631 } 632 633 if (vbi->vbi_count[1] > 0) { 634 top_irq_flags = 0; 635 bottom = &vbi->bottom; 636 bottom_irq_flags = 4; 637 } 638 } 639 640 bttv_risc_hook(btv, RISC_SLOT_O_VBI, top, top_irq_flags); 641 bttv_risc_hook(btv, RISC_SLOT_E_VBI, bottom, bottom_irq_flags); 642 643 return 0; 644} 645 646int 647bttv_buffer_activate_video(struct bttv *btv, 648 struct bttv_buffer_set *set) 649{ 650 /* video capture */ 651 if (NULL != set->top && NULL != set->bottom) { 652 if (set->top == set->bottom) { 653 set->top->vb.state = VIDEOBUF_ACTIVE; 654 if (set->top->vb.queue.next) 655 list_del(&set->top->vb.queue); 656 } else { 657 set->top->vb.state = VIDEOBUF_ACTIVE; 658 set->bottom->vb.state = VIDEOBUF_ACTIVE; 659 if (set->top->vb.queue.next) 660 list_del(&set->top->vb.queue); 661 if (set->bottom->vb.queue.next) 662 list_del(&set->bottom->vb.queue); 663 } 664 bttv_apply_geo(btv, &set->top->geo, 1); 665 bttv_apply_geo(btv, &set->bottom->geo,0); 666 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, &set->top->top, 667 set->top_irq); 668 bttv_risc_hook(btv, RISC_SLOT_E_FIELD, &set->bottom->bottom, 669 set->frame_irq); 670 btaor((set->top->btformat & 0xf0) | (set->bottom->btformat & 0x0f), 671 ~0xff, BT848_COLOR_FMT); 672 btaor((set->top->btswap & 0x0a) | (set->bottom->btswap & 0x05), 673 ~0x0f, BT848_COLOR_CTL); 674 } else if (NULL != set->top) { 675 set->top->vb.state = VIDEOBUF_ACTIVE; 676 if (set->top->vb.queue.next) 677 list_del(&set->top->vb.queue); 678 bttv_apply_geo(btv, &set->top->geo,1); 679 bttv_apply_geo(btv, &set->top->geo,0); 680 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, &set->top->top, 681 set->frame_irq); 682 bttv_risc_hook(btv, RISC_SLOT_E_FIELD, NULL, 0); 683 btaor(set->top->btformat & 0xff, ~0xff, BT848_COLOR_FMT); 684 btaor(set->top->btswap & 0x0f, ~0x0f, BT848_COLOR_CTL); 685 } else if (NULL != set->bottom) { 686 set->bottom->vb.state = VIDEOBUF_ACTIVE; 687 if (set->bottom->vb.queue.next) 688 list_del(&set->bottom->vb.queue); 689 bttv_apply_geo(btv, &set->bottom->geo,1); 690 bttv_apply_geo(btv, &set->bottom->geo,0); 691 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0); 692 bttv_risc_hook(btv, RISC_SLOT_E_FIELD, &set->bottom->bottom, 693 set->frame_irq); 694 btaor(set->bottom->btformat & 0xff, ~0xff, BT848_COLOR_FMT); 695 btaor(set->bottom->btswap & 0x0f, ~0x0f, BT848_COLOR_CTL); 696 } else { 697 bttv_risc_hook(btv, RISC_SLOT_O_FIELD, NULL, 0); 698 bttv_risc_hook(btv, RISC_SLOT_E_FIELD, NULL, 0); 699 } 700 return 0; 701} 702 703/* ---------------------------------------------------------- */ 704 705/* calculate geometry, build risc code */ 706int 707bttv_buffer_risc(struct bttv *btv, struct bttv_buffer *buf) 708{ 709 const struct bttv_tvnorm *tvnorm = bttv_tvnorms + buf->tvnorm; 710 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb); 711 712 dprintk("%d: buffer field: %s format: %s size: %dx%d\n", 713 btv->c.nr, v4l2_field_names[buf->vb.field], 714 buf->fmt->name, buf->vb.width, buf->vb.height); 715 716 /* packed pixel modes */ 717 if (buf->fmt->flags & FORMAT_FLAGS_PACKED) { 718 int bpl = (buf->fmt->depth >> 3) * buf->vb.width; 719 int bpf = bpl * (buf->vb.height >> 1); 720 721 bttv_calc_geo(btv,&buf->geo,buf->vb.width,buf->vb.height, 722 V4L2_FIELD_HAS_BOTH(buf->vb.field), 723 tvnorm,&buf->crop); 724 725 switch (buf->vb.field) { 726 case V4L2_FIELD_TOP: 727 bttv_risc_packed(btv,&buf->top,dma->sglist, 728 /* offset */ 0,bpl, 729 /* padding */ 0,/* skip_lines */ 0, 730 buf->vb.height); 731 break; 732 case V4L2_FIELD_BOTTOM: 733 bttv_risc_packed(btv,&buf->bottom,dma->sglist, 734 0,bpl,0,0,buf->vb.height); 735 break; 736 case V4L2_FIELD_INTERLACED: 737 bttv_risc_packed(btv,&buf->top,dma->sglist, 738 0,bpl,bpl,0,buf->vb.height >> 1); 739 bttv_risc_packed(btv,&buf->bottom,dma->sglist, 740 bpl,bpl,bpl,0,buf->vb.height >> 1); 741 break; 742 case V4L2_FIELD_SEQ_TB: 743 bttv_risc_packed(btv,&buf->top,dma->sglist, 744 0,bpl,0,0,buf->vb.height >> 1); 745 bttv_risc_packed(btv,&buf->bottom,dma->sglist, 746 bpf,bpl,0,0,buf->vb.height >> 1); 747 break; 748 default: 749 BUG(); 750 } 751 } 752 753 /* planar modes */ 754 if (buf->fmt->flags & FORMAT_FLAGS_PLANAR) { 755 int uoffset, voffset; 756 int ypadding, cpadding, lines; 757 758 /* calculate chroma offsets */ 759 uoffset = buf->vb.width * buf->vb.height; 760 voffset = buf->vb.width * buf->vb.height; 761 if (buf->fmt->flags & FORMAT_FLAGS_CrCb) { 762 /* Y-Cr-Cb plane order */ 763 uoffset >>= buf->fmt->hshift; 764 uoffset >>= buf->fmt->vshift; 765 uoffset += voffset; 766 } else { 767 /* Y-Cb-Cr plane order */ 768 voffset >>= buf->fmt->hshift; 769 voffset >>= buf->fmt->vshift; 770 voffset += uoffset; 771 } 772 773 switch (buf->vb.field) { 774 case V4L2_FIELD_TOP: 775 bttv_calc_geo(btv,&buf->geo,buf->vb.width, 776 buf->vb.height,/* both_fields */ 0, 777 tvnorm,&buf->crop); 778 bttv_risc_planar(btv, &buf->top, dma->sglist, 779 0,buf->vb.width,0,buf->vb.height, 780 uoffset,voffset,buf->fmt->hshift, 781 buf->fmt->vshift,0); 782 break; 783 case V4L2_FIELD_BOTTOM: 784 bttv_calc_geo(btv,&buf->geo,buf->vb.width, 785 buf->vb.height,0, 786 tvnorm,&buf->crop); 787 bttv_risc_planar(btv, &buf->bottom, dma->sglist, 788 0,buf->vb.width,0,buf->vb.height, 789 uoffset,voffset,buf->fmt->hshift, 790 buf->fmt->vshift,0); 791 break; 792 case V4L2_FIELD_INTERLACED: 793 bttv_calc_geo(btv,&buf->geo,buf->vb.width, 794 buf->vb.height,1, 795 tvnorm,&buf->crop); 796 lines = buf->vb.height >> 1; 797 ypadding = buf->vb.width; 798 cpadding = buf->vb.width >> buf->fmt->hshift; 799 bttv_risc_planar(btv,&buf->top, 800 dma->sglist, 801 0,buf->vb.width,ypadding,lines, 802 uoffset,voffset, 803 buf->fmt->hshift, 804 buf->fmt->vshift, 805 cpadding); 806 bttv_risc_planar(btv,&buf->bottom, 807 dma->sglist, 808 ypadding,buf->vb.width,ypadding,lines, 809 uoffset+cpadding, 810 voffset+cpadding, 811 buf->fmt->hshift, 812 buf->fmt->vshift, 813 cpadding); 814 break; 815 case V4L2_FIELD_SEQ_TB: 816 bttv_calc_geo(btv,&buf->geo,buf->vb.width, 817 buf->vb.height,1, 818 tvnorm,&buf->crop); 819 lines = buf->vb.height >> 1; 820 ypadding = buf->vb.width; 821 cpadding = buf->vb.width >> buf->fmt->hshift; 822 bttv_risc_planar(btv,&buf->top, 823 dma->sglist, 824 0,buf->vb.width,0,lines, 825 uoffset >> 1, 826 voffset >> 1, 827 buf->fmt->hshift, 828 buf->fmt->vshift, 829 0); 830 bttv_risc_planar(btv,&buf->bottom, 831 dma->sglist, 832 lines * ypadding,buf->vb.width,0,lines, 833 lines * ypadding + (uoffset >> 1), 834 lines * ypadding + (voffset >> 1), 835 buf->fmt->hshift, 836 buf->fmt->vshift, 837 0); 838 break; 839 default: 840 BUG(); 841 } 842 } 843 844 /* raw data */ 845 if (buf->fmt->flags & FORMAT_FLAGS_RAW) { 846 /* build risc code */ 847 buf->vb.field = V4L2_FIELD_SEQ_TB; 848 bttv_calc_geo(btv,&buf->geo,tvnorm->swidth,tvnorm->sheight, 849 1,tvnorm,&buf->crop); 850 bttv_risc_packed(btv, &buf->top, dma->sglist, 851 /* offset */ 0, RAW_BPL, /* padding */ 0, 852 /* skip_lines */ 0, RAW_LINES); 853 bttv_risc_packed(btv, &buf->bottom, dma->sglist, 854 buf->vb.size/2 , RAW_BPL, 0, 0, RAW_LINES); 855 } 856 857 /* copy format info */ 858 buf->btformat = buf->fmt->btformat; 859 buf->btswap = buf->fmt->btswap; 860 return 0; 861} 862 863/* ---------------------------------------------------------- */ 864 865/* calculate geometry, build risc code */ 866int 867bttv_overlay_risc(struct bttv *btv, 868 struct bttv_overlay *ov, 869 const struct bttv_format *fmt, 870 struct bttv_buffer *buf) 871{ 872 /* check interleave, bottom+top fields */ 873 dprintk("%d: overlay fields: %s format: %s size: %dx%d\n", 874 btv->c.nr, v4l2_field_names[buf->vb.field], 875 fmt->name, ov->w.width, ov->w.height); 876 877 /* calculate geometry */ 878 bttv_calc_geo(btv,&buf->geo,ov->w.width,ov->w.height, 879 V4L2_FIELD_HAS_BOTH(ov->field), 880 &bttv_tvnorms[ov->tvnorm],&buf->crop); 881 882 /* build risc code */ 883 switch (ov->field) { 884 case V4L2_FIELD_TOP: 885 bttv_risc_overlay(btv, &buf->top, fmt, ov, 0, 0); 886 break; 887 case V4L2_FIELD_BOTTOM: 888 bttv_risc_overlay(btv, &buf->bottom, fmt, ov, 0, 0); 889 break; 890 case V4L2_FIELD_INTERLACED: 891 bttv_risc_overlay(btv, &buf->top, fmt, ov, 0, 1); 892 bttv_risc_overlay(btv, &buf->bottom, fmt, ov, 1, 0); 893 break; 894 default: 895 BUG(); 896 } 897 898 /* copy format info */ 899 buf->btformat = fmt->btformat; 900 buf->btswap = fmt->btswap; 901 buf->vb.field = ov->field; 902 return 0; 903} 904