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