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