projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] media: remove emacs editor variables
[deliverable/linux.git] / drivers / media / pci / bt8xx / bttv-risc.c
CommitLineData
1da177e4 1/*
1da177e4
LT		 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
8af443e5
JP		 27#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28
1da177e4
LT		 29#include <linux/module.h>
30#include <linux/init.h>
5a0e3ad6 31#include <linux/slab.h>
1da177e4
LT		 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>
35ea11ff 37#include <media/v4l2-ioctl.h>
1da177e4
LT		 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,
e5bd0260
MS		 50 unsigned int padding, unsigned int skip_lines,
51 unsigned int store_lines)
1da177e4
LT		 52{
53 u32 instructions,line,todo;
54 struct scatterlist *sg;
d8eaa58b 55 __le32 *rp;
1da177e4
LT		 56 int rc;
57
58 /* estimate risc mem: worst case is one write per page border +
4a287cfe
DS		 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 */
e5bd0260
MS		 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)
1da177e4
LT		 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
e5bd0260
MS		 74 while (skip_lines-- > 0) {
75 *(rp++) = cpu_to_le32(BT848_RISC_SKIP | BT848_RISC_SOL |
76 BT848_RISC_EOL | bpl);
77 }
78
1da177e4
LT		 79 /* scan lines */
80 sg = sglist;
e5bd0260 81 for (line = 0; line < store_lines; line++) {
1da177e4 82 if ((btv->opt_vcr_hack) &&
e5bd0260 83 (line >= (store_lines - VCR_HACK_LINES)))
1da177e4
LT		 84 continue;
85 while (offset && offset >= sg_dma_len(sg)) {
86 offset -= sg_dma_len(sg);
872dfcfe 87 sg = sg_next(sg);
1da177e4
LT		 88 }
89 if (bpl <= sg_dma_len(sg)-offset) {
90 /* fits into current chunk */
4ac97914 91 *(rp++)=cpu_to_le32(BT848_RISC_WRITE|BT848_RISC_SOL|
1da177e4 92 BT848_RISC_EOL|bpl);
4ac97914
MCC		 93 *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset);
94 offset+=bpl;
1da177e4
LT		 95 } else {
96 /* scanline needs to be splitted */
4ac97914
MCC		 97 todo = bpl;
98 *(rp++)=cpu_to_le32(BT848_RISC_WRITE|BT848_RISC_SOL|
1da177e4 99 (sg_dma_len(sg)-offset));
4ac97914
MCC		 100 *(rp++)=cpu_to_le32(sg_dma_address(sg)+offset);
101 todo -= (sg_dma_len(sg)-offset);
102 offset = 0;
872dfcfe 103 sg = sg_next(sg);
4ac97914 104 while (todo > sg_dma_len(sg)) {
f2421ca3 105 *(rp++)=cpu_to_le32(BT848_RISC_WRITE|
1da177e4 106 sg_dma_len(sg));
f2421ca3 107 *(rp++)=cpu_to_le32(sg_dma_address(sg));
1da177e4 108 todo -= sg_dma_len(sg);
872dfcfe 109 sg = sg_next(sg);
1da177e4 110 }
4ac97914 111 *(rp++)=cpu_to_le32(BT848_RISC_WRITE|BT848_RISC_EOL|
1da177e4
LT		 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;
4a287cfe 121 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1da177e4
LT		 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;
d8eaa58b
AV		 135 __le32 *rp;
136 u32 ri;
1da177e4
LT		 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) */
e5bd0260
MS		 146 instructions = ((3 + (ybpl + ypadding) * ylines * 2)
147 / PAGE_SIZE) + ylines;
1da177e4
LT		 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);
872dfcfe 190 ysg = sg_next(ysg);
1da177e4
LT		 191 }
192 while (uoffset && uoffset >= sg_dma_len(usg)) {
193 uoffset -= sg_dma_len(usg);
872dfcfe 194 usg = sg_next(usg);
1da177e4
LT		 195 }
196 while (voffset && voffset >= sg_dma_len(vsg)) {
197 voffset -= sg_dma_len(vsg);
872dfcfe 198 vsg = sg_next(vsg);
1da177e4
LT		 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 */
4ac97914
MCC		 220 *(rp++)=cpu_to_le32(ri | ylen);
221 *(rp++)=cpu_to_le32(((ylen >> hshift) << 16) |
1da177e4
LT		 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;
4a287cfe 241 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1da177e4
LT		 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{
c6eb8eaf
HV		 250 int dwords, rc, line, maxy, start, end;
251 unsigned skip, nskips;
1da177e4 252 struct btcx_skiplist *skips;
d8eaa58b
AV		 253 __le32 *rp;
254 u32 ri,ra;
1da177e4
LT		 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
3203f94a 261 /* estimate risc mem: worst case is (1.5*clip+1) * lines instructions
1da177e4 262 + sync + jump (all 2 dwords) */
3203f94a
DS		 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) {
1da177e4
LT		 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;
4a287cfe 328 BUG_ON((risc->jmp - risc->cpu + 2) * sizeof(*risc->cpu) > risc->size);
1da177e4
LT		 329 kfree(skips);
330 return 0;
331}
332
333/* ---------------------------------------------------------- */
334
335static void
e5bd0260
MS		 336bttv_calc_geo_old(struct bttv *btv, struct bttv_geometry *geo,
337 int width, int height, int interleaved,
338 const struct bttv_tvnorm *tvnorm)
1da177e4 339{
4ac97914 340 u32 xsf, sr;
1da177e4
LT		 341 int vdelay;
342
343 int swidth = tvnorm->swidth;
344 int totalwidth = tvnorm->totalwidth;
345 int scaledtwidth = tvnorm->scaledtwidth;
346
5221e21e 347 if (btv->input == btv->dig) {
1da177e4
LT		 348 swidth = 720;
349 totalwidth = 858;
350 scaledtwidth = 858;
351 }
352
353 vdelay = tvnorm->vdelay;
1da177e4 354
4ac97914
MCC		 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;
1da177e4
LT		 368 geo->vtotal = tvnorm->vtotal;
369
4ac97914
MCC		 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 }
1da177e4
LT		 377}
378
e5bd0260
MS		 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 */)
5221e21e 397 || btv->input == btv->dig) {
e5bd0260
MS		 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
1da177e4
LT		 435static void
436bttv_apply_geo(struct bttv *btv, struct bttv_geometry *geo, int odd)
437{
4ac97914 438 int off = odd ? 0x80 : 0x00;
1da177e4
LT		 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
4ac97914
MCC		 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);
1da177e4 455 btwrite(geo->vtotal>>8, BT848_VTOTAL_HI);
4ac97914 456 btwrite(geo->vtotal & 0xff, BT848_VTOTAL_LO);
1da177e4
LT		 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
8af443e5 478 d2printk("%d: capctl=%x lirq=%d top=%08llx/%08llx even=%08llx/%08llx\n",
1da177e4
LT		 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 }
4ac97914 496 btv->main.cpu[RISC_SLOT_LOOP] = cpu_to_le32(cmd);
1da177e4
LT		 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;
4ac97914 508 btand(~3, BT848_GPIO_DMA_CTL);
1da177e4
LT		 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;
8af443e5
JP		 521 dprintk("%d: risc main @ %08llx\n",
522 btv->c.nr, (unsigned long long)btv->main.dma);
1da177e4
LT		 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
4ac97914 536 btv->main.cpu[8] = cpu_to_le32(BT848_RISC_SYNC | BT848_RISC_RESYNC |
1da177e4 537 BT848_FIFO_STATUS_VRO);
4ac97914 538 btv->main.cpu[9] = cpu_to_le32(0);
1da177e4
LT		 539
540 /* bottom field */
4ac97914 541 btv->main.cpu[10] = cpu_to_le32(BT848_RISC_JUMP);
1da177e4 542 btv->main.cpu[11] = cpu_to_le32(btv->main.dma + (12<<2));
4ac97914 543 btv->main.cpu[12] = cpu_to_le32(BT848_RISC_JUMP);
1da177e4
LT		 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);
4ac97914 548 btv->main.cpu[15] = cpu_to_le32(btv->main.dma + (0<<2));
1da177e4
LT		 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) {
8af443e5 561 d2printk("%d: risc=%p slot[%d]=NULL\n", btv->c.nr, risc, slot);
1da177e4
LT		 562 btv->main.cpu[slot+1] = cpu_to_le32(next);
563 } else {
8af443e5
JP		 564 d2printk("%d: risc=%p slot[%d]=%08llx irq=%d\n",
565 btv->c.nr, risc, slot,
566 (unsigned long long)risc->dma, irqflags);
1da177e4
LT		 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
c7b0ac05 581bttv_dma_free(struct videobuf_queue *q,struct bttv *btv, struct bttv_buffer *buf)
1da177e4 582{
c1accaa2
MCC		 583 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
584
ae24601b 585 BUG_ON(in_interrupt());
0e0809a5 586 videobuf_waiton(q, &buf->vb, 0, 0);
95268403 587 videobuf_dma_unmap(q->dev, dma);
c1accaa2 588 videobuf_dma_free(dma);
1da177e4
LT		 589 btcx_riscmem_free(btv->c.pci,&buf->bottom);
590 btcx_riscmem_free(btv->c.pci,&buf->top);
0fc0686e 591 buf->vb.state = VIDEOBUF_NEEDS_INIT;
1da177e4
LT		 592}
593
594int
595bttv_buffer_activate_vbi(struct bttv *btv,
596 struct bttv_buffer *vbi)
597{
e5bd0260
MS		 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
1da177e4 608 if (vbi) {
e5bd0260
MS		 609 unsigned int crop, vdelay;
610
0fc0686e 611 vbi->vb.state = VIDEOBUF_ACTIVE;
1da177e4 612 list_del(&vbi->vb.queue);
e5bd0260
MS		 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 }
1da177e4 638 }
e5bd0260
MS		 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
1da177e4
LT		 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) {
0fc0686e 653 set->top->vb.state = VIDEOBUF_ACTIVE;
1da177e4
LT		 654 if (set->top->vb.queue.next)
655 list_del(&set->top->vb.queue);
656 } else {
0fc0686e
BP		 657 set->top->vb.state = VIDEOBUF_ACTIVE;
658 set->bottom->vb.state = VIDEOBUF_ACTIVE;
1da177e4
LT		 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) {
0fc0686e 675 set->top->vb.state = VIDEOBUF_ACTIVE;
1da177e4
LT		 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) {
0fc0686e 686 set->bottom->vb.state = VIDEOBUF_ACTIVE;
1da177e4
LT		 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;
c1accaa2 710 struct videobuf_dmabuf *dma=videobuf_to_dma(&buf->vb);
1da177e4 711
8af443e5 712 dprintk("%d: buffer field: %s format: %s size: %dx%d\n",
1da177e4
LT		 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,
e5bd0260
MS		 722 V4L2_FIELD_HAS_BOTH(buf->vb.field),
723 tvnorm,&buf->crop);
1da177e4
LT		 724
725 switch (buf->vb.field) {
726 case V4L2_FIELD_TOP:
c1accaa2 727 bttv_risc_packed(btv,&buf->top,dma->sglist,
e5bd0260
MS		 728 /* offset */ 0,bpl,
729 /* padding */ 0,/* skip_lines */ 0,
730 buf->vb.height);
1da177e4
LT		 731 break;
732 case V4L2_FIELD_BOTTOM:
c1accaa2 733 bttv_risc_packed(btv,&buf->bottom,dma->sglist,
e5bd0260 734 0,bpl,0,0,buf->vb.height);
1da177e4
LT		 735 break;
736 case V4L2_FIELD_INTERLACED:
c1accaa2 737 bttv_risc_packed(btv,&buf->top,dma->sglist,
e5bd0260 738 0,bpl,bpl,0,buf->vb.height >> 1);
c1accaa2 739 bttv_risc_packed(btv,&buf->bottom,dma->sglist,
e5bd0260 740 bpl,bpl,bpl,0,buf->vb.height >> 1);
1da177e4
LT		 741 break;
742 case V4L2_FIELD_SEQ_TB:
c1accaa2 743 bttv_risc_packed(btv,&buf->top,dma->sglist,
e5bd0260 744 0,bpl,0,0,buf->vb.height >> 1);
c1accaa2 745 bttv_risc_packed(btv,&buf->bottom,dma->sglist,
e5bd0260 746 bpf,bpl,0,0,buf->vb.height >> 1);
1da177e4
LT		 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,
e5bd0260
MS		 776 buf->vb.height,/* both_fields */ 0,
777 tvnorm,&buf->crop);
c1accaa2 778 bttv_risc_planar(btv, &buf->top, dma->sglist,
1da177e4
LT		 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,
e5bd0260
MS		 785 buf->vb.height,0,
786 tvnorm,&buf->crop);
c1accaa2 787 bttv_risc_planar(btv, &buf->bottom, dma->sglist,
1da177e4
LT		 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,
e5bd0260
MS		 794 buf->vb.height,1,
795 tvnorm,&buf->crop);
1da177e4
LT		 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,
c1accaa2 800 dma->sglist,
1da177e4
LT		 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,
c1accaa2 807 dma->sglist,
1da177e4
LT		 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,
e5bd0260
MS		 817 buf->vb.height,1,
818 tvnorm,&buf->crop);
1da177e4
LT		 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,
c1accaa2 823 dma->sglist,
1da177e4
LT		 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,
c1accaa2 831 dma->sglist,
1da177e4
LT		 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,
e5bd0260 849 1,tvnorm,&buf->crop);
c1accaa2 850 bttv_risc_packed(btv, &buf->top, dma->sglist,
e5bd0260
MS		 851 /* offset */ 0, RAW_BPL, /* padding */ 0,
852 /* skip_lines */ 0, RAW_LINES);
c1accaa2 853 bttv_risc_packed(btv, &buf->bottom, dma->sglist,
e5bd0260 854 buf->vb.size/2 , RAW_BPL, 0, 0, RAW_LINES);
1da177e4
LT		 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 */
8af443e5 873 dprintk("%d: overlay fields: %s format: %s size: %dx%d\n",
1da177e4 874 btv->c.nr, v4l2_field_names[buf->vb.field],
8af443e5 875 fmt->name, ov->w.width, ov->w.height);
1da177e4
LT		 876
877 /* calculate geometry */
878 bttv_calc_geo(btv,&buf->geo,ov->w.width,ov->w.height,
e5bd0260
MS		 879 V4L2_FIELD_HAS_BOTH(ov->field),
880 &bttv_tvnorms[ov->tvnorm],&buf->crop);
1da177e4
LT		 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:
1da177e4
LT		 891 bttv_risc_overlay(btv, &buf->top, fmt, ov, 0, 1);
892 bttv_risc_overlay(btv, &buf->bottom, fmt, ov, 1, 0);
1da177e4
LT		 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}
Linux kernel - Deliverables
This page took 0.841656 seconds and 5 git commands to generate.