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