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