?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Full support for Ginger Console
[linux-ginger.git] / drivers / media / video / ivtv / ivtv-yuv.c
blobc0875378acc2ffa372426c8ea05ed8497cddd7a8
1 /*
2 yuv support
3
4 Copyright (C) 2007 Ian Armstrong <ian@iarmst.demon.co.uk>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #include "ivtv-driver.h"
22 #include "ivtv-udma.h"
23 #include "ivtv-yuv.h"
24
25 /* YUV buffer offsets */
26 const u32 yuv_offset[IVTV_YUV_BUFFERS] = {
27 0x001a8600,
28 0x00240400,
29 0x002d8200,
30 0x00370000,
31 0x00029000,
32 0x000C0E00,
33 0x006B0400,
34 0x00748200
35 };
36
37 static int ivtv_yuv_prep_user_dma(struct ivtv *itv, struct ivtv_user_dma *dma,
38 struct ivtv_dma_frame *args)
39 {
40 struct ivtv_dma_page_info y_dma;
41 struct ivtv_dma_page_info uv_dma;
42 struct yuv_playback_info *yi = &itv->yuv_info;
43 u8 frame = yi->draw_frame;
44 struct yuv_frame_info *f = &yi->new_frame_info[frame];
45 int i;
46 int y_pages, uv_pages;
47 unsigned long y_buffer_offset, uv_buffer_offset;
48 int y_decode_height, uv_decode_height, y_size;
49
50 y_buffer_offset = IVTV_DECODER_OFFSET + yuv_offset[frame];
51 uv_buffer_offset = y_buffer_offset + IVTV_YUV_BUFFER_UV_OFFSET;
52
53 y_decode_height = uv_decode_height = f->src_h + f->src_y;
54
55 if (f->offset_y)
56 y_buffer_offset += 720 * 16;
57
58 if (y_decode_height & 15)
59 y_decode_height = (y_decode_height + 16) & ~15;
60
61 if (uv_decode_height & 31)
62 uv_decode_height = (uv_decode_height + 32) & ~31;
63
64 y_size = 720 * y_decode_height;
65
66 /* Still in USE */
67 if (dma->SG_length || dma->page_count) {
68 IVTV_DEBUG_WARN
69 ("prep_user_dma: SG_length %d page_count %d still full?\n",
70 dma->SG_length, dma->page_count);
71 return -EBUSY;
72 }
73
74 ivtv_udma_get_page_info (&y_dma, (unsigned long)args->y_source, 720 * y_decode_height);
75 ivtv_udma_get_page_info (&uv_dma, (unsigned long)args->uv_source, 360 * uv_decode_height);
76
77 /* Get user pages for DMA Xfer */
78 down_read(&current->mm->mmap_sem);
79 y_pages = get_user_pages(current, current->mm, y_dma.uaddr, y_dma.page_count, 0, 1, &dma->map[0], NULL);
80 uv_pages = get_user_pages(current, current->mm, uv_dma.uaddr, uv_dma.page_count, 0, 1, &dma->map[y_pages], NULL);
81 up_read(&current->mm->mmap_sem);
82
83 dma->page_count = y_dma.page_count + uv_dma.page_count;
84
85 if (y_pages + uv_pages != dma->page_count) {
86 IVTV_DEBUG_WARN
87 ("failed to map user pages, returned %d instead of %d\n",
88 y_pages + uv_pages, dma->page_count);
89
90 for (i = 0; i < dma->page_count; i++) {
91 put_page(dma->map[i]);
92 }
93 dma->page_count = 0;
94 return -EINVAL;
95 }
96
97 /* Fill & map SG List */
98 if (ivtv_udma_fill_sg_list (dma, &uv_dma, ivtv_udma_fill_sg_list (dma, &y_dma, 0)) < 0) {
99 IVTV_DEBUG_WARN("could not allocate bounce buffers for highmem userspace buffers\n");
100 for (i = 0; i < dma->page_count; i++) {
101 put_page(dma->map[i]);
102 }
103 dma->page_count = 0;
104 return -ENOMEM;
105 }
106 dma->SG_length = pci_map_sg(itv->pdev, dma->SGlist, dma->page_count, PCI_DMA_TODEVICE);
107
108 /* Fill SG Array with new values */
109 ivtv_udma_fill_sg_array(dma, y_buffer_offset, uv_buffer_offset, y_size);
110
111 /* If we've offset the y plane, ensure top area is blanked */
112 if (f->offset_y && yi->blanking_dmaptr) {
113 dma->SGarray[dma->SG_length].size = cpu_to_le32(720*16);
114 dma->SGarray[dma->SG_length].src = cpu_to_le32(yi->blanking_dmaptr);
115 dma->SGarray[dma->SG_length].dst = cpu_to_le32(IVTV_DECODER_OFFSET + yuv_offset[frame]);
116 dma->SG_length++;
117 }
118
119 /* Tag SG Array with Interrupt Bit */
120 dma->SGarray[dma->SG_length - 1].size |= cpu_to_le32(0x80000000);
121
122 ivtv_udma_sync_for_device(itv);
123 return 0;
124 }
125
126 /* We rely on a table held in the firmware - Quick check. */
127 int ivtv_yuv_filter_check(struct ivtv *itv)
128 {
129 int i, y, uv;
130
131 for (i = 0, y = 16, uv = 4; i < 16; i++, y += 24, uv += 12) {
132 if ((read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + y) != i << 16) ||
133 (read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + uv) != i << 16)) {
134 IVTV_WARN ("YUV filter table not found in firmware.\n");
135 return -1;
136 }
137 }
138 return 0;
139 }
140
141 static void ivtv_yuv_filter(struct ivtv *itv, int h_filter, int v_filter_1, int v_filter_2)
142 {
143 u32 i, line;
144
145 /* If any filter is -1, then don't update it */
146 if (h_filter > -1) {
147 if (h_filter > 4)
148 h_filter = 4;
149 i = IVTV_YUV_HORIZONTAL_FILTER_OFFSET + (h_filter * 384);
150 for (line = 0; line < 16; line++) {
151 write_reg(read_dec(i), 0x02804);
152 write_reg(read_dec(i), 0x0281c);
153 i += 4;
154 write_reg(read_dec(i), 0x02808);
155 write_reg(read_dec(i), 0x02820);
156 i += 4;
157 write_reg(read_dec(i), 0x0280c);
158 write_reg(read_dec(i), 0x02824);
159 i += 4;
160 write_reg(read_dec(i), 0x02810);
161 write_reg(read_dec(i), 0x02828);
162 i += 4;
163 write_reg(read_dec(i), 0x02814);
164 write_reg(read_dec(i), 0x0282c);
165 i += 8;
166 write_reg(0, 0x02818);
167 write_reg(0, 0x02830);
168 }
169 IVTV_DEBUG_YUV("h_filter -> %d\n", h_filter);
170 }
171
172 if (v_filter_1 > -1) {
173 if (v_filter_1 > 4)
174 v_filter_1 = 4;
175 i = IVTV_YUV_VERTICAL_FILTER_OFFSET + (v_filter_1 * 192);
176 for (line = 0; line < 16; line++) {
177 write_reg(read_dec(i), 0x02900);
178 i += 4;
179 write_reg(read_dec(i), 0x02904);
180 i += 8;
181 write_reg(0, 0x02908);
182 }
183 IVTV_DEBUG_YUV("v_filter_1 -> %d\n", v_filter_1);
184 }
185
186 if (v_filter_2 > -1) {
187 if (v_filter_2 > 4)
188 v_filter_2 = 4;
189 i = IVTV_YUV_VERTICAL_FILTER_OFFSET + (v_filter_2 * 192);
190 for (line = 0; line < 16; line++) {
191 write_reg(read_dec(i), 0x0290c);
192 i += 4;
193 write_reg(read_dec(i), 0x02910);
194 i += 8;
195 write_reg(0, 0x02914);
196 }
197 IVTV_DEBUG_YUV("v_filter_2 -> %d\n", v_filter_2);
198 }
199 }
200
201 static void ivtv_yuv_handle_horizontal(struct ivtv *itv, struct yuv_frame_info *f)
202 {
203 struct yuv_playback_info *yi = &itv->yuv_info;
204 u32 reg_2834, reg_2838, reg_283c;
205 u32 reg_2844, reg_2854, reg_285c;
206 u32 reg_2864, reg_2874, reg_2890;
207 u32 reg_2870, reg_2870_base, reg_2870_offset;
208 int x_cutoff;
209 int h_filter;
210 u32 master_width;
211
212 IVTV_DEBUG_WARN
213 ("Adjust to width %d src_w %d dst_w %d src_x %d dst_x %d\n",
214 f->tru_w, f->src_w, f->dst_w, f->src_x, f->dst_x);
215
216 /* How wide is the src image */
217 x_cutoff = f->src_w + f->src_x;
218
219 /* Set the display width */
220 reg_2834 = f->dst_w;
221 reg_2838 = reg_2834;
222
223 /* Set the display position */
224 reg_2890 = f->dst_x;
225
226 /* Index into the image horizontally */
227 reg_2870 = 0;
228
229 /* 2870 is normally fudged to align video coords with osd coords.
230 If running full screen, it causes an unwanted left shift
231 Remove the fudge if we almost fill the screen.
232 Gradually adjust the offset to avoid the video 'snapping'
233 left/right if it gets dragged through this region.
234 Only do this if osd is full width. */
235 if (f->vis_w == 720) {
236 if ((f->tru_x - f->pan_x > -1) && (f->tru_x - f->pan_x <= 40) && (f->dst_w >= 680))
237 reg_2870 = 10 - (f->tru_x - f->pan_x) / 4;
238 else if ((f->tru_x - f->pan_x < 0) && (f->tru_x - f->pan_x >= -20) && (f->dst_w >= 660))
239 reg_2870 = (10 + (f->tru_x - f->pan_x) / 2);
240
241 if (f->dst_w >= f->src_w)
242 reg_2870 = reg_2870 << 16 | reg_2870;
243 else
244 reg_2870 = ((reg_2870 & ~1) << 15) | (reg_2870 & ~1);
245 }
246
247 if (f->dst_w < f->src_w)
248 reg_2870 = 0x000d000e - reg_2870;
249 else
250 reg_2870 = 0x0012000e - reg_2870;
251
252 /* We're also using 2870 to shift the image left (src_x & negative dst_x) */
253 reg_2870_offset = (f->src_x * ((f->dst_w << 21) / f->src_w)) >> 19;
254
255 if (f->dst_w >= f->src_w) {
256 x_cutoff &= ~1;
257 master_width = (f->src_w * 0x00200000) / (f->dst_w);
258 if (master_width * f->dst_w != f->src_w * 0x00200000)
259 master_width++;
260 reg_2834 = (reg_2834 << 16) | x_cutoff;
261 reg_2838 = (reg_2838 << 16) | x_cutoff;
262 reg_283c = master_width >> 2;
263 reg_2844 = master_width >> 2;
264 reg_2854 = master_width;
265 reg_285c = master_width >> 1;
266 reg_2864 = master_width >> 1;
267
268 /* We also need to factor in the scaling
269 (src_w - dst_w) / (src_w / 4) */
270 if (f->dst_w > f->src_w)
271 reg_2870_base = ((f->dst_w - f->src_w)<<16) / (f->src_w <<14);
272 else
273 reg_2870_base = 0;
274
275 reg_2870 += (((reg_2870_offset << 14) & 0xFFFF0000) | reg_2870_offset >> 2) + (reg_2870_base << 17 | reg_2870_base);
276 reg_2874 = 0;
277 } else if (f->dst_w < f->src_w / 2) {
278 master_width = (f->src_w * 0x00080000) / f->dst_w;
279 if (master_width * f->dst_w != f->src_w * 0x00080000)
280 master_width++;
281 reg_2834 = (reg_2834 << 16) | x_cutoff;
282 reg_2838 = (reg_2838 << 16) | x_cutoff;
283 reg_283c = master_width >> 2;
284 reg_2844 = master_width >> 1;
285 reg_2854 = master_width;
286 reg_285c = master_width >> 1;
287 reg_2864 = master_width >> 1;
288 reg_2870 += ((reg_2870_offset << 15) & 0xFFFF0000) | reg_2870_offset;
289 reg_2870 += (5 - (((f->src_w + f->src_w / 2) - 1) / f->dst_w)) << 16;
290 reg_2874 = 0x00000012;
291 } else {
292 master_width = (f->src_w * 0x00100000) / f->dst_w;
293 if (master_width * f->dst_w != f->src_w * 0x00100000)
294 master_width++;
295 reg_2834 = (reg_2834 << 16) | x_cutoff;
296 reg_2838 = (reg_2838 << 16) | x_cutoff;
297 reg_283c = master_width >> 2;
298 reg_2844 = master_width >> 1;
299 reg_2854 = master_width;
300 reg_285c = master_width >> 1;
301 reg_2864 = master_width >> 1;
302 reg_2870 += ((reg_2870_offset << 14) & 0xFFFF0000) | reg_2870_offset >> 1;
303 reg_2870 += (5 - (((f->src_w * 3) - 1) / f->dst_w)) << 16;
304 reg_2874 = 0x00000001;
305 }
306
307 /* Select the horizontal filter */
308 if (f->src_w == f->dst_w) {
309 /* An exact size match uses filter 0 */
310 h_filter = 0;
311 } else {
312 /* Figure out which filter to use */
313 h_filter = ((f->src_w << 16) / f->dst_w) >> 15;
314 h_filter = (h_filter >> 1) + (h_filter & 1);
315 /* Only an exact size match can use filter 0 */
316 h_filter += !h_filter;
317 }
318
319 write_reg(reg_2834, 0x02834);
320 write_reg(reg_2838, 0x02838);
321 IVTV_DEBUG_YUV("Update reg 0x2834 %08x->%08x 0x2838 %08x->%08x\n",
322 yi->reg_2834, reg_2834, yi->reg_2838, reg_2838);
323
324 write_reg(reg_283c, 0x0283c);
325 write_reg(reg_2844, 0x02844);
326
327 IVTV_DEBUG_YUV("Update reg 0x283c %08x->%08x 0x2844 %08x->%08x\n",
328 yi->reg_283c, reg_283c, yi->reg_2844, reg_2844);
329
330 write_reg(0x00080514, 0x02840);
331 write_reg(0x00100514, 0x02848);
332 IVTV_DEBUG_YUV("Update reg 0x2840 %08x->%08x 0x2848 %08x->%08x\n",
333 yi->reg_2840, 0x00080514, yi->reg_2848, 0x00100514);
334
335 write_reg(reg_2854, 0x02854);
336 IVTV_DEBUG_YUV("Update reg 0x2854 %08x->%08x \n",
337 yi->reg_2854, reg_2854);
338
339 write_reg(reg_285c, 0x0285c);
340 write_reg(reg_2864, 0x02864);
341 IVTV_DEBUG_YUV("Update reg 0x285c %08x->%08x 0x2864 %08x->%08x\n",
342 yi->reg_285c, reg_285c, yi->reg_2864, reg_2864);
343
344 write_reg(reg_2874, 0x02874);
345 IVTV_DEBUG_YUV("Update reg 0x2874 %08x->%08x\n",
346 yi->reg_2874, reg_2874);
347
348 write_reg(reg_2870, 0x02870);
349 IVTV_DEBUG_YUV("Update reg 0x2870 %08x->%08x\n",
350 yi->reg_2870, reg_2870);
351
352 write_reg(reg_2890, 0x02890);
353 IVTV_DEBUG_YUV("Update reg 0x2890 %08x->%08x\n",
354 yi->reg_2890, reg_2890);
355
356 /* Only update the filter if we really need to */
357 if (h_filter != yi->h_filter) {
358 ivtv_yuv_filter(itv, h_filter, -1, -1);
359 yi->h_filter = h_filter;
360 }
361 }
362
363 static void ivtv_yuv_handle_vertical(struct ivtv *itv, struct yuv_frame_info *f)
364 {
365 struct yuv_playback_info *yi = &itv->yuv_info;
366 u32 master_height;
367 u32 reg_2918, reg_291c, reg_2920, reg_2928;
368 u32 reg_2930, reg_2934, reg_293c;
369 u32 reg_2940, reg_2944, reg_294c;
370 u32 reg_2950, reg_2954, reg_2958, reg_295c;
371 u32 reg_2960, reg_2964, reg_2968, reg_296c;
372 u32 reg_289c;
373 u32 src_major_y, src_minor_y;
374 u32 src_major_uv, src_minor_uv;
375 u32 reg_2964_base, reg_2968_base;
376 int v_filter_1, v_filter_2;
377
378 IVTV_DEBUG_WARN
379 ("Adjust to height %d src_h %d dst_h %d src_y %d dst_y %d\n",
380 f->tru_h, f->src_h, f->dst_h, f->src_y, f->dst_y);
381
382 /* What scaling mode is being used... */
383 IVTV_DEBUG_YUV("Scaling mode Y: %s\n",
384 f->interlaced_y ? "Interlaced" : "Progressive");
385
386 IVTV_DEBUG_YUV("Scaling mode UV: %s\n",
387 f->interlaced_uv ? "Interlaced" : "Progressive");
388
389 /* What is the source video being treated as... */
390 IVTV_DEBUG_WARN("Source video: %s\n",
391 f->interlaced ? "Interlaced" : "Progressive");
392
393 /* We offset into the image using two different index methods, so split
394 the y source coord into two parts. */
395 if (f->src_y < 8) {
396 src_minor_uv = f->src_y;
397 src_major_uv = 0;
398 } else {
399 src_minor_uv = 8;
400 src_major_uv = f->src_y - 8;
401 }
402
403 src_minor_y = src_minor_uv;
404 src_major_y = src_major_uv;
405
406 if (f->offset_y)
407 src_minor_y += 16;
408
409 if (f->interlaced_y)
410 reg_2918 = (f->dst_h << 16) | (f->src_h + src_minor_y);
411 else
412 reg_2918 = (f->dst_h << 16) | ((f->src_h + src_minor_y) << 1);
413
414 if (f->interlaced_uv)
415 reg_291c = (f->dst_h << 16) | ((f->src_h + src_minor_uv) >> 1);
416 else
417 reg_291c = (f->dst_h << 16) | (f->src_h + src_minor_uv);
418
419 reg_2964_base = (src_minor_y * ((f->dst_h << 16) / f->src_h)) >> 14;
420 reg_2968_base = (src_minor_uv * ((f->dst_h << 16) / f->src_h)) >> 14;
421
422 if (f->dst_h / 2 >= f->src_h && !f->interlaced_y) {
423 master_height = (f->src_h * 0x00400000) / f->dst_h;
424 if ((f->src_h * 0x00400000) - (master_height * f->dst_h) >= f->dst_h / 2)
425 master_height++;
426 reg_2920 = master_height >> 2;
427 reg_2928 = master_height >> 3;
428 reg_2930 = master_height;
429 reg_2940 = master_height >> 1;
430 reg_2964_base >>= 3;
431 reg_2968_base >>= 3;
432 reg_296c = 0x00000000;
433 } else if (f->dst_h >= f->src_h) {
434 master_height = (f->src_h * 0x00400000) / f->dst_h;
435 master_height = (master_height >> 1) + (master_height & 1);
436 reg_2920 = master_height >> 2;
437 reg_2928 = master_height >> 2;
438 reg_2930 = master_height;
439 reg_2940 = master_height >> 1;
440 reg_296c = 0x00000000;
441 if (f->interlaced_y) {
442 reg_2964_base >>= 3;
443 } else {
444 reg_296c++;
445 reg_2964_base >>= 2;
446 }
447 if (f->interlaced_uv)
448 reg_2928 >>= 1;
449 reg_2968_base >>= 3;
450 } else if (f->dst_h >= f->src_h / 2) {
451 master_height = (f->src_h * 0x00200000) / f->dst_h;
452 master_height = (master_height >> 1) + (master_height & 1);
453 reg_2920 = master_height >> 2;
454 reg_2928 = master_height >> 2;
455 reg_2930 = master_height;
456 reg_2940 = master_height;
457 reg_296c = 0x00000101;
458 if (f->interlaced_y) {
459 reg_2964_base >>= 2;
460 } else {
461 reg_296c++;
462 reg_2964_base >>= 1;
463 }
464 if (f->interlaced_uv)
465 reg_2928 >>= 1;
466 reg_2968_base >>= 2;
467 } else {
468 master_height = (f->src_h * 0x00100000) / f->dst_h;
469 master_height = (master_height >> 1) + (master_height & 1);
470 reg_2920 = master_height >> 2;
471 reg_2928 = master_height >> 2;
472 reg_2930 = master_height;
473 reg_2940 = master_height;
474 reg_2964_base >>= 1;
475 reg_2968_base >>= 2;
476 reg_296c = 0x00000102;
477 }
478
479 /* FIXME These registers change depending on scaled / unscaled output
480 We really need to work out what they should be */
481 if (f->src_h == f->dst_h) {
482 reg_2934 = 0x00020000;
483 reg_293c = 0x00100000;
484 reg_2944 = 0x00040000;
485 reg_294c = 0x000b0000;
486 } else {
487 reg_2934 = 0x00000FF0;
488 reg_293c = 0x00000FF0;
489 reg_2944 = 0x00000FF0;
490 reg_294c = 0x00000FF0;
491 }
492
493 /* The first line to be displayed */
494 reg_2950 = 0x00010000 + src_major_y;
495 if (f->interlaced_y)
496 reg_2950 += 0x00010000;
497 reg_2954 = reg_2950 + 1;
498
499 reg_2958 = 0x00010000 + (src_major_y >> 1);
500 if (f->interlaced_uv)
501 reg_2958 += 0x00010000;
502 reg_295c = reg_2958 + 1;
503
504 if (yi->decode_height == 480)
505 reg_289c = 0x011e0017;
506 else
507 reg_289c = 0x01500017;
508
509 if (f->dst_y < 0)
510 reg_289c = (reg_289c - ((f->dst_y & ~1)<<15))-(f->dst_y >>1);
511 else
512 reg_289c = (reg_289c + ((f->dst_y & ~1)<<15))+(f->dst_y >>1);
513
514 /* How much of the source to decode.
515 Take into account the source offset */
516 reg_2960 = ((src_minor_y + f->src_h + src_major_y) - 1) |
517 (((src_minor_uv + f->src_h + src_major_uv - 1) & ~1) << 15);
518
519 /* Calculate correct value for register 2964 */
520 if (f->src_h == f->dst_h) {
521 reg_2964 = 1;
522 } else {
523 reg_2964 = 2 + ((f->dst_h << 1) / f->src_h);
524 reg_2964 = (reg_2964 >> 1) + (reg_2964 & 1);
525 }
526 reg_2968 = (reg_2964 << 16) + reg_2964 + (reg_2964 >> 1);
527 reg_2964 = (reg_2964 << 16) + reg_2964 + (reg_2964 * 46 / 94);
528
529 /* Okay, we've wasted time working out the correct value,
530 but if we use it, it fouls the the window alignment.
531 Fudge it to what we want... */
532 reg_2964 = 0x00010001 + ((reg_2964 & 0x0000FFFF) - (reg_2964 >> 16));
533 reg_2968 = 0x00010001 + ((reg_2968 & 0x0000FFFF) - (reg_2968 >> 16));
534
535 /* Deviate further from what it should be. I find the flicker headache
536 inducing so try to reduce it slightly. Leave 2968 as-is otherwise
537 colours foul. */
538 if ((reg_2964 != 0x00010001) && (f->dst_h / 2 <= f->src_h))
539 reg_2964 = (reg_2964 & 0xFFFF0000) + ((reg_2964 & 0x0000FFFF) / 2);
540
541 if (!f->interlaced_y)
542 reg_2964 -= 0x00010001;
543 if (!f->interlaced_uv)
544 reg_2968 -= 0x00010001;
545
546 reg_2964 += ((reg_2964_base << 16) | reg_2964_base);
547 reg_2968 += ((reg_2968_base << 16) | reg_2968_base);
548
549 /* Select the vertical filter */
550 if (f->src_h == f->dst_h) {
551 /* An exact size match uses filter 0/1 */
552 v_filter_1 = 0;
553 v_filter_2 = 1;
554 } else {
555 /* Figure out which filter to use */
556 v_filter_1 = ((f->src_h << 16) / f->dst_h) >> 15;
557 v_filter_1 = (v_filter_1 >> 1) + (v_filter_1 & 1);
558 /* Only an exact size match can use filter 0 */
559 v_filter_1 += !v_filter_1;
560 v_filter_2 = v_filter_1;
561 }
562
563 write_reg(reg_2934, 0x02934);
564 write_reg(reg_293c, 0x0293c);
565 IVTV_DEBUG_YUV("Update reg 0x2934 %08x->%08x 0x293c %08x->%08x\n",
566 yi->reg_2934, reg_2934, yi->reg_293c, reg_293c);
567 write_reg(reg_2944, 0x02944);
568 write_reg(reg_294c, 0x0294c);
569 IVTV_DEBUG_YUV("Update reg 0x2944 %08x->%08x 0x294c %08x->%08x\n",
570 yi->reg_2944, reg_2944, yi->reg_294c, reg_294c);
571
572 /* Ensure 2970 is 0 (does it ever change ?) */
573 /* write_reg(0,0x02970); */
574 /* IVTV_DEBUG_YUV("Update reg 0x2970 %08x->%08x\n", yi->reg_2970, 0); */
575
576 write_reg(reg_2930, 0x02938);
577 write_reg(reg_2930, 0x02930);
578 IVTV_DEBUG_YUV("Update reg 0x2930 %08x->%08x 0x2938 %08x->%08x\n",
579 yi->reg_2930, reg_2930, yi->reg_2938, reg_2930);
580
581 write_reg(reg_2928, 0x02928);
582 write_reg(reg_2928 + 0x514, 0x0292C);
583 IVTV_DEBUG_YUV("Update reg 0x2928 %08x->%08x 0x292c %08x->%08x\n",
584 yi->reg_2928, reg_2928, yi->reg_292c, reg_2928 + 0x514);
585
586 write_reg(reg_2920, 0x02920);
587 write_reg(reg_2920 + 0x514, 0x02924);
588 IVTV_DEBUG_YUV("Update reg 0x2920 %08x->%08x 0x2924 %08x->%08x\n",
589 yi->reg_2920, reg_2920, yi->reg_2924, reg_2920 + 0x514);
590
591 write_reg(reg_2918, 0x02918);
592 write_reg(reg_291c, 0x0291C);
593 IVTV_DEBUG_YUV("Update reg 0x2918 %08x->%08x 0x291C %08x->%08x\n",
594 yi->reg_2918, reg_2918, yi->reg_291c, reg_291c);
595
596 write_reg(reg_296c, 0x0296c);
597 IVTV_DEBUG_YUV("Update reg 0x296c %08x->%08x\n",
598 yi->reg_296c, reg_296c);
599
600 write_reg(reg_2940, 0x02948);
601 write_reg(reg_2940, 0x02940);
602 IVTV_DEBUG_YUV("Update reg 0x2940 %08x->%08x 0x2948 %08x->%08x\n",
603 yi->reg_2940, reg_2940, yi->reg_2948, reg_2940);
604
605 write_reg(reg_2950, 0x02950);
606 write_reg(reg_2954, 0x02954);
607 IVTV_DEBUG_YUV("Update reg 0x2950 %08x->%08x 0x2954 %08x->%08x\n",
608 yi->reg_2950, reg_2950, yi->reg_2954, reg_2954);
609
610 write_reg(reg_2958, 0x02958);
611 write_reg(reg_295c, 0x0295C);
612 IVTV_DEBUG_YUV("Update reg 0x2958 %08x->%08x 0x295C %08x->%08x\n",
613 yi->reg_2958, reg_2958, yi->reg_295c, reg_295c);
614
615 write_reg(reg_2960, 0x02960);
616 IVTV_DEBUG_YUV("Update reg 0x2960 %08x->%08x \n",
617 yi->reg_2960, reg_2960);
618
619 write_reg(reg_2964, 0x02964);
620 write_reg(reg_2968, 0x02968);
621 IVTV_DEBUG_YUV("Update reg 0x2964 %08x->%08x 0x2968 %08x->%08x\n",
622 yi->reg_2964, reg_2964, yi->reg_2968, reg_2968);
623
624 write_reg(reg_289c, 0x0289c);
625 IVTV_DEBUG_YUV("Update reg 0x289c %08x->%08x\n",
626 yi->reg_289c, reg_289c);
627
628 /* Only update filter 1 if we really need to */
629 if (v_filter_1 != yi->v_filter_1) {
630 ivtv_yuv_filter(itv, -1, v_filter_1, -1);
631 yi->v_filter_1 = v_filter_1;
632 }
633
634 /* Only update filter 2 if we really need to */
635 if (v_filter_2 != yi->v_filter_2) {
636 ivtv_yuv_filter(itv, -1, -1, v_filter_2);
637 yi->v_filter_2 = v_filter_2;
638 }
639 }
640
641 /* Modify the supplied coordinate information to fit the visible osd area */
642 static u32 ivtv_yuv_window_setup(struct ivtv *itv, struct yuv_frame_info *f)
643 {
644 struct yuv_frame_info *of = &itv->yuv_info.old_frame_info;
645 int osd_crop;
646 u32 osd_scale;
647 u32 yuv_update = 0;
648
649 /* Sorry, but no negative coords for src */
650 if (f->src_x < 0)
651 f->src_x = 0;
652 if (f->src_y < 0)
653 f->src_y = 0;
654
655 /* Can only reduce width down to 1/4 original size */
656 if ((osd_crop = f->src_w - 4 * f->dst_w) > 0) {
657 f->src_x += osd_crop / 2;
658 f->src_w = (f->src_w - osd_crop) & ~3;
659 f->dst_w = f->src_w / 4;
660 f->dst_w += f->dst_w & 1;
661 }
662
663 /* Can only reduce height down to 1/4 original size */
664 if (f->src_h / f->dst_h >= 2) {
665 /* Overflow may be because we're running progressive,
666 so force mode switch */
667 f->interlaced_y = 1;
668 /* Make sure we're still within limits for interlace */
669 if ((osd_crop = f->src_h - 4 * f->dst_h) > 0) {
670 /* If we reach here we'll have to force the height. */
671 f->src_y += osd_crop / 2;
672 f->src_h = (f->src_h - osd_crop) & ~3;
673 f->dst_h = f->src_h / 4;
674 f->dst_h += f->dst_h & 1;
675 }
676 }
677
678 /* If there's nothing to safe to display, we may as well stop now */
679 if ((int)f->dst_w <= 2 || (int)f->dst_h <= 2 ||
680 (int)f->src_w <= 2 || (int)f->src_h <= 2) {
681 return IVTV_YUV_UPDATE_INVALID;
682 }
683
684 /* Ensure video remains inside OSD area */
685 osd_scale = (f->src_h << 16) / f->dst_h;
686
687 if ((osd_crop = f->pan_y - f->dst_y) > 0) {
688 /* Falls off the upper edge - crop */
689 f->src_y += (osd_scale * osd_crop) >> 16;
690 f->src_h -= (osd_scale * osd_crop) >> 16;
691 f->dst_h -= osd_crop;
692 f->dst_y = 0;
693 } else {
694 f->dst_y -= f->pan_y;
695 }
696
697 if ((osd_crop = f->dst_h + f->dst_y - f->vis_h) > 0) {
698 /* Falls off the lower edge - crop */
699 f->dst_h -= osd_crop;
700 f->src_h -= (osd_scale * osd_crop) >> 16;
701 }
702
703 osd_scale = (f->src_w << 16) / f->dst_w;
704
705 if ((osd_crop = f->pan_x - f->dst_x) > 0) {
706 /* Fall off the left edge - crop */
707 f->src_x += (osd_scale * osd_crop) >> 16;
708 f->src_w -= (osd_scale * osd_crop) >> 16;
709 f->dst_w -= osd_crop;
710 f->dst_x = 0;
711 } else {
712 f->dst_x -= f->pan_x;
713 }
714
715 if ((osd_crop = f->dst_w + f->dst_x - f->vis_w) > 0) {
716 /* Falls off the right edge - crop */
717 f->dst_w -= osd_crop;
718 f->src_w -= (osd_scale * osd_crop) >> 16;
719 }
720
721 if (itv->yuv_info.track_osd) {
722 /* The OSD can be moved. Track to it */
723 f->dst_x += itv->yuv_info.osd_x_offset;
724 f->dst_y += itv->yuv_info.osd_y_offset;
725 }
726
727 /* Width & height for both src & dst must be even.
728 Same for coordinates. */
729 f->dst_w &= ~1;
730 f->dst_x &= ~1;
731
732 f->src_w += f->src_x & 1;
733 f->src_x &= ~1;
734
735 f->src_w &= ~1;
736 f->dst_w &= ~1;
737
738 f->dst_h &= ~1;
739 f->dst_y &= ~1;
740
741 f->src_h += f->src_y & 1;
742 f->src_y &= ~1;
743
744 f->src_h &= ~1;
745 f->dst_h &= ~1;
746
747 /* Due to rounding, we may have reduced the output size to <1/4 of
748 the source. Check again, but this time just resize. Don't change
749 source coordinates */
750 if (f->dst_w < f->src_w / 4) {
751 f->src_w &= ~3;
752 f->dst_w = f->src_w / 4;
753 f->dst_w += f->dst_w & 1;
754 }
755 if (f->dst_h < f->src_h / 4) {
756 f->src_h &= ~3;
757 f->dst_h = f->src_h / 4;
758 f->dst_h += f->dst_h & 1;
759 }
760
761 /* Check again. If there's nothing to safe to display, stop now */
762 if ((int)f->dst_w <= 2 || (int)f->dst_h <= 2 ||
763 (int)f->src_w <= 2 || (int)f->src_h <= 2) {
764 return IVTV_YUV_UPDATE_INVALID;
765 }
766
767 /* Both x offset & width are linked, so they have to be done together */
768 if ((of->dst_w != f->dst_w) || (of->src_w != f->src_w) ||
769 (of->dst_x != f->dst_x) || (of->src_x != f->src_x) ||
770 (of->pan_x != f->pan_x) || (of->vis_w != f->vis_w)) {
771 yuv_update |= IVTV_YUV_UPDATE_HORIZONTAL;
772 }
773
774 if ((of->src_h != f->src_h) || (of->dst_h != f->dst_h) ||
775 (of->dst_y != f->dst_y) || (of->src_y != f->src_y) ||
776 (of->pan_y != f->pan_y) || (of->vis_h != f->vis_h) ||
777 (of->lace_mode != f->lace_mode) ||
778 (of->interlaced_y != f->interlaced_y) ||
779 (of->interlaced_uv != f->interlaced_uv)) {
780 yuv_update |= IVTV_YUV_UPDATE_VERTICAL;
781 }
782
783 return yuv_update;
784 }
785
786 /* Update the scaling register to the requested value */
787 void ivtv_yuv_work_handler(struct ivtv *itv)
788 {
789 struct yuv_playback_info *yi = &itv->yuv_info;
790 struct yuv_frame_info f;
791 int frame = yi->update_frame;
792 u32 yuv_update;
793
794 IVTV_DEBUG_YUV("Update yuv registers for frame %d\n", frame);
795 f = yi->new_frame_info[frame];
796
797 if (yi->track_osd) {
798 /* Snapshot the osd pan info */
799 f.pan_x = yi->osd_x_pan;
800 f.pan_y = yi->osd_y_pan;
801 f.vis_w = yi->osd_vis_w;
802 f.vis_h = yi->osd_vis_h;
803 } else {
804 /* Not tracking the osd, so assume full screen */
805 f.pan_x = 0;
806 f.pan_y = 0;
807 f.vis_w = 720;
808 f.vis_h = yi->decode_height;
809 }
810
811 /* Calculate the display window coordinates. Exit if nothing left */
812 if (!(yuv_update = ivtv_yuv_window_setup(itv, &f)))
813 return;
814
815 if (yuv_update & IVTV_YUV_UPDATE_INVALID) {
816 write_reg(0x01008080, 0x2898);
817 } else if (yuv_update) {
818 write_reg(0x00108080, 0x2898);
819
820 if (yuv_update & IVTV_YUV_UPDATE_HORIZONTAL)
821 ivtv_yuv_handle_horizontal(itv, &f);
822
823 if (yuv_update & IVTV_YUV_UPDATE_VERTICAL)
824 ivtv_yuv_handle_vertical(itv, &f);
825 }
826 yi->old_frame_info = f;
827 }
828
829 static void ivtv_yuv_init(struct ivtv *itv)
830 {
831 struct yuv_playback_info *yi = &itv->yuv_info;
832
833 IVTV_DEBUG_YUV("ivtv_yuv_init\n");
834
835 /* Take a snapshot of the current register settings */
836 yi->reg_2834 = read_reg(0x02834);
837 yi->reg_2838 = read_reg(0x02838);
838 yi->reg_283c = read_reg(0x0283c);
839 yi->reg_2840 = read_reg(0x02840);
840 yi->reg_2844 = read_reg(0x02844);
841 yi->reg_2848 = read_reg(0x02848);
842 yi->reg_2854 = read_reg(0x02854);
843 yi->reg_285c = read_reg(0x0285c);
844 yi->reg_2864 = read_reg(0x02864);
845 yi->reg_2870 = read_reg(0x02870);
846 yi->reg_2874 = read_reg(0x02874);
847 yi->reg_2898 = read_reg(0x02898);
848 yi->reg_2890 = read_reg(0x02890);
849
850 yi->reg_289c = read_reg(0x0289c);
851 yi->reg_2918 = read_reg(0x02918);
852 yi->reg_291c = read_reg(0x0291c);
853 yi->reg_2920 = read_reg(0x02920);
854 yi->reg_2924 = read_reg(0x02924);
855 yi->reg_2928 = read_reg(0x02928);
856 yi->reg_292c = read_reg(0x0292c);
857 yi->reg_2930 = read_reg(0x02930);
858 yi->reg_2934 = read_reg(0x02934);
859 yi->reg_2938 = read_reg(0x02938);
860 yi->reg_293c = read_reg(0x0293c);
861 yi->reg_2940 = read_reg(0x02940);
862 yi->reg_2944 = read_reg(0x02944);
863 yi->reg_2948 = read_reg(0x02948);
864 yi->reg_294c = read_reg(0x0294c);
865 yi->reg_2950 = read_reg(0x02950);
866 yi->reg_2954 = read_reg(0x02954);
867 yi->reg_2958 = read_reg(0x02958);
868 yi->reg_295c = read_reg(0x0295c);
869 yi->reg_2960 = read_reg(0x02960);
870 yi->reg_2964 = read_reg(0x02964);
871 yi->reg_2968 = read_reg(0x02968);
872 yi->reg_296c = read_reg(0x0296c);
873 yi->reg_2970 = read_reg(0x02970);
874
875 yi->v_filter_1 = -1;
876 yi->v_filter_2 = -1;
877 yi->h_filter = -1;
878
879 /* Set some valid size info */
880 yi->osd_x_offset = read_reg(0x02a04) & 0x00000FFF;
881 yi->osd_y_offset = (read_reg(0x02a04) >> 16) & 0x00000FFF;
882
883 /* Bit 2 of reg 2878 indicates current decoder output format
884 0 : NTSC 1 : PAL */
885 if (read_reg(0x2878) & 4)
886 yi->decode_height = 576;
887 else
888 yi->decode_height = 480;
889
890 if (!itv->osd_info) {
891 yi->osd_vis_w = 720 - yi->osd_x_offset;
892 yi->osd_vis_h = yi->decode_height - yi->osd_y_offset;
893 } else {
894 /* If no visible size set, assume full size */
895 if (!yi->osd_vis_w)
896 yi->osd_vis_w = 720 - yi->osd_x_offset;
897
898 if (!yi->osd_vis_h) {
899 yi->osd_vis_h = yi->decode_height - yi->osd_y_offset;
900 } else if (yi->osd_vis_h + yi->osd_y_offset > yi->decode_height) {
901 /* If output video standard has changed, requested height may
902 not be legal */
903 IVTV_DEBUG_WARN("Clipping yuv output - fb size (%d) exceeds video standard limit (%d)\n",
904 yi->osd_vis_h + yi->osd_y_offset,
905 yi->decode_height);
906 yi->osd_vis_h = yi->decode_height - yi->osd_y_offset;
907 }
908 }
909
910 /* We need a buffer for blanking when Y plane is offset - non-fatal if we can't get one */
911 yi->blanking_ptr = kzalloc(720 * 16, GFP_KERNEL|__GFP_NOWARN);
912 if (yi->blanking_ptr) {
913 yi->blanking_dmaptr = pci_map_single(itv->pdev, yi->blanking_ptr, 720*16, PCI_DMA_TODEVICE);
914 } else {
915 yi->blanking_dmaptr = 0;
916 IVTV_DEBUG_WARN("Failed to allocate yuv blanking buffer\n");
917 }
918
919 /* Enable YUV decoder output */
920 write_reg_sync(0x01, IVTV_REG_VDM);
921
922 set_bit(IVTV_F_I_DECODING_YUV, &itv->i_flags);
923 atomic_set(&yi->next_dma_frame, 0);
924 }
925
926 /* Get next available yuv buffer on PVR350 */
927 static void ivtv_yuv_next_free(struct ivtv *itv)
928 {
929 int draw, display;
930 struct yuv_playback_info *yi = &itv->yuv_info;
931
932 if (atomic_read(&yi->next_dma_frame) == -1)
933 ivtv_yuv_init(itv);
934
935 draw = atomic_read(&yi->next_fill_frame);
936 display = atomic_read(&yi->next_dma_frame);
937
938 if (display > draw)
939 display -= IVTV_YUV_BUFFERS;
940
941 if (draw - display >= yi->max_frames_buffered)
942 draw = (u8)(draw - 1) % IVTV_YUV_BUFFERS;
943 else
944 yi->new_frame_info[draw].update = 0;
945
946 yi->draw_frame = draw;
947 }
948
949 /* Set up frame according to ivtv_dma_frame parameters */
950 static void ivtv_yuv_setup_frame(struct ivtv *itv, struct ivtv_dma_frame *args)
951 {
952 struct yuv_playback_info *yi = &itv->yuv_info;
953 u8 frame = yi->draw_frame;
954 u8 last_frame = (u8)(frame - 1) % IVTV_YUV_BUFFERS;
955 struct yuv_frame_info *nf = &yi->new_frame_info[frame];
956 struct yuv_frame_info *of = &yi->new_frame_info[last_frame];
957 int lace_threshold = yi->lace_threshold;
958
959 /* Preserve old update flag in case we're overwriting a queued frame */
960 int update = nf->update;
961
962 /* Take a snapshot of the yuv coordinate information */
963 nf->src_x = args->src.left;
964 nf->src_y = args->src.top;
965 nf->src_w = args->src.width;
966 nf->src_h = args->src.height;
967 nf->dst_x = args->dst.left;
968 nf->dst_y = args->dst.top;
969 nf->dst_w = args->dst.width;
970 nf->dst_h = args->dst.height;
971 nf->tru_x = args->dst.left;
972 nf->tru_w = args->src_width;
973 nf->tru_h = args->src_height;
974
975 /* Are we going to offset the Y plane */
976 nf->offset_y = (nf->tru_h + nf->src_x < 512 - 16) ? 1 : 0;
977
978 nf->update = 0;
979 nf->interlaced_y = 0;
980 nf->interlaced_uv = 0;
981 nf->delay = 0;
982 nf->sync_field = 0;
983 nf->lace_mode = yi->lace_mode & IVTV_YUV_MODE_MASK;
984
985 if (lace_threshold < 0)
986 lace_threshold = yi->decode_height - 1;
987
988 /* Work out the lace settings */
989 switch (nf->lace_mode) {
990 case IVTV_YUV_MODE_PROGRESSIVE: /* Progressive mode */
991 nf->interlaced = 0;
992 if (nf->tru_h < 512 || (nf->tru_h > 576 && nf->tru_h < 1021))
993 nf->interlaced_y = 0;
994 else
995 nf->interlaced_y = 1;
996
997 if (nf->tru_h < 1021 && (nf->dst_h >= nf->src_h / 2))
998 nf->interlaced_uv = 0;
999 else
1000 nf->interlaced_uv = 1;
1001 break;
1002
1003 case IVTV_YUV_MODE_AUTO:
1004 if (nf->tru_h <= lace_threshold || nf->tru_h > 576 || nf->tru_w > 720) {
1005 nf->interlaced = 0;
1006 if ((nf->tru_h < 512) ||
1007 (nf->tru_h > 576 && nf->tru_h < 1021) ||
1008 (nf->tru_w > 720 && nf->tru_h < 1021))
1009 nf->interlaced_y = 0;
1010 else
1011 nf->interlaced_y = 1;
1012 if (nf->tru_h < 1021 && (nf->dst_h >= nf->src_h / 2))
1013 nf->interlaced_uv = 0;
1014 else
1015 nf->interlaced_uv = 1;
1016 } else {
1017 nf->interlaced = 1;
1018 nf->interlaced_y = 1;
1019 nf->interlaced_uv = 1;
1020 }
1021 break;
1022
1023 case IVTV_YUV_MODE_INTERLACED: /* Interlace mode */
1024 default:
1025 nf->interlaced = 1;
1026 nf->interlaced_y = 1;
1027 nf->interlaced_uv = 1;
1028 break;
1029 }
1030
1031 if (memcmp(&yi->old_frame_info_args, nf, sizeof(*nf))) {
1032 yi->old_frame_info_args = *nf;
1033 nf->update = 1;
1034 IVTV_DEBUG_YUV("Requesting reg update for frame %d\n", frame);
1035 }
1036
1037 nf->update |= update;
1038 nf->sync_field = yi->lace_sync_field;
1039 nf->delay = nf->sync_field != of->sync_field;
1040 }
1041
1042 /* Frame is complete & ready for display */
1043 void ivtv_yuv_frame_complete(struct ivtv *itv)
1044 {
1045 atomic_set(&itv->yuv_info.next_fill_frame,
1046 (itv->yuv_info.draw_frame + 1) % IVTV_YUV_BUFFERS);
1047 }
1048
1049 static int ivtv_yuv_udma_frame(struct ivtv *itv, struct ivtv_dma_frame *args)
1050 {
1051 DEFINE_WAIT(wait);
1052 int rc = 0;
1053 int got_sig = 0;
1054 /* DMA the frame */
1055 mutex_lock(&itv->udma.lock);
1056
1057 if ((rc = ivtv_yuv_prep_user_dma(itv, &itv->udma, args)) != 0) {
1058 mutex_unlock(&itv->udma.lock);
1059 return rc;
1060 }
1061
1062 ivtv_udma_prepare(itv);
1063 prepare_to_wait(&itv->dma_waitq, &wait, TASK_INTERRUPTIBLE);
1064 /* if no UDMA is pending and no UDMA is in progress, then the DMA
1065 is finished */
1066 while (test_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags) ||
1067 test_bit(IVTV_F_I_UDMA, &itv->i_flags)) {
1068 /* don't interrupt if the DMA is in progress but break off
1069 a still pending DMA. */
1070 got_sig = signal_pending(current);
1071 if (got_sig && test_and_clear_bit(IVTV_F_I_UDMA_PENDING, &itv->i_flags))
1072 break;
1073 got_sig = 0;
1074 schedule();
1075 }
1076 finish_wait(&itv->dma_waitq, &wait);
1077
1078 /* Unmap Last DMA Xfer */
1079 ivtv_udma_unmap(itv);
1080
1081 if (got_sig) {
1082 IVTV_DEBUG_INFO("User stopped YUV UDMA\n");
1083 mutex_unlock(&itv->udma.lock);
1084 return -EINTR;
1085 }
1086
1087 ivtv_yuv_frame_complete(itv);
1088
1089 mutex_unlock(&itv->udma.lock);
1090 return rc;
1091 }
1092
1093 /* Setup frame according to V4L2 parameters */
1094 void ivtv_yuv_setup_stream_frame(struct ivtv *itv)
1095 {
1096 struct yuv_playback_info *yi = &itv->yuv_info;
1097 struct ivtv_dma_frame dma_args;
1098
1099 ivtv_yuv_next_free(itv);
1100
1101 /* Copy V4L2 parameters to an ivtv_dma_frame struct... */
1102 dma_args.y_source = NULL;
1103 dma_args.uv_source = NULL;
1104 dma_args.src.left = 0;
1105 dma_args.src.top = 0;
1106 dma_args.src.width = yi->v4l2_src_w;
1107 dma_args.src.height = yi->v4l2_src_h;
1108 dma_args.dst = yi->main_rect;
1109 dma_args.src_width = yi->v4l2_src_w;
1110 dma_args.src_height = yi->v4l2_src_h;
1111
1112 /* ... and use the same setup routine as ivtv_yuv_prep_frame */
1113 ivtv_yuv_setup_frame(itv, &dma_args);
1114
1115 if (!itv->dma_data_req_offset)
1116 itv->dma_data_req_offset = yuv_offset[yi->draw_frame];
1117 }
1118
1119 /* Attempt to dma a frame from a user buffer */
1120 int ivtv_yuv_udma_stream_frame(struct ivtv *itv, void __user *src)
1121 {
1122 struct yuv_playback_info *yi = &itv->yuv_info;
1123 struct ivtv_dma_frame dma_args;
1124
1125 ivtv_yuv_setup_stream_frame(itv);
1126
1127 /* We only need to supply source addresses for this */
1128 dma_args.y_source = src;
1129 dma_args.uv_source = src + 720 * ((yi->v4l2_src_h + 31) & ~31);
1130 return ivtv_yuv_udma_frame(itv, &dma_args);
1131 }
1132
1133 /* IVTV_IOC_DMA_FRAME ioctl handler */
1134 int ivtv_yuv_prep_frame(struct ivtv *itv, struct ivtv_dma_frame *args)
1135 {
1136 /* IVTV_DEBUG_INFO("yuv_prep_frame\n"); */
1137
1138 ivtv_yuv_next_free(itv);
1139 ivtv_yuv_setup_frame(itv, args);
1140 return ivtv_yuv_udma_frame(itv, args);
1141 }
1142
1143 void ivtv_yuv_close(struct ivtv *itv)
1144 {
1145 struct yuv_playback_info *yi = &itv->yuv_info;
1146 int h_filter, v_filter_1, v_filter_2;
1147
1148 IVTV_DEBUG_YUV("ivtv_yuv_close\n");
1149 ivtv_waitq(&itv->vsync_waitq);
1150
1151 yi->running = 0;
1152 atomic_set(&yi->next_dma_frame, -1);
1153 atomic_set(&yi->next_fill_frame, 0);
1154
1155 /* Reset registers we have changed so mpeg playback works */
1156
1157 /* If we fully restore this register, the display may remain active.
1158 Restore, but set one bit to blank the video. Firmware will always
1159 clear this bit when needed, so not a problem. */
1160 write_reg(yi->reg_2898 | 0x01000000, 0x2898);
1161
1162 write_reg(yi->reg_2834, 0x02834);
1163 write_reg(yi->reg_2838, 0x02838);
1164 write_reg(yi->reg_283c, 0x0283c);
1165 write_reg(yi->reg_2840, 0x02840);
1166 write_reg(yi->reg_2844, 0x02844);
1167 write_reg(yi->reg_2848, 0x02848);
1168 write_reg(yi->reg_2854, 0x02854);
1169 write_reg(yi->reg_285c, 0x0285c);
1170 write_reg(yi->reg_2864, 0x02864);
1171 write_reg(yi->reg_2870, 0x02870);
1172 write_reg(yi->reg_2874, 0x02874);
1173 write_reg(yi->reg_2890, 0x02890);
1174 write_reg(yi->reg_289c, 0x0289c);
1175
1176 write_reg(yi->reg_2918, 0x02918);
1177 write_reg(yi->reg_291c, 0x0291c);
1178 write_reg(yi->reg_2920, 0x02920);
1179 write_reg(yi->reg_2924, 0x02924);
1180 write_reg(yi->reg_2928, 0x02928);
1181 write_reg(yi->reg_292c, 0x0292c);
1182 write_reg(yi->reg_2930, 0x02930);
1183 write_reg(yi->reg_2934, 0x02934);
1184 write_reg(yi->reg_2938, 0x02938);
1185 write_reg(yi->reg_293c, 0x0293c);
1186 write_reg(yi->reg_2940, 0x02940);
1187 write_reg(yi->reg_2944, 0x02944);
1188 write_reg(yi->reg_2948, 0x02948);
1189 write_reg(yi->reg_294c, 0x0294c);
1190 write_reg(yi->reg_2950, 0x02950);
1191 write_reg(yi->reg_2954, 0x02954);
1192 write_reg(yi->reg_2958, 0x02958);
1193 write_reg(yi->reg_295c, 0x0295c);
1194 write_reg(yi->reg_2960, 0x02960);
1195 write_reg(yi->reg_2964, 0x02964);
1196 write_reg(yi->reg_2968, 0x02968);
1197 write_reg(yi->reg_296c, 0x0296c);
1198 write_reg(yi->reg_2970, 0x02970);
1199
1200 /* Prepare to restore filters */
1201
1202 /* First the horizontal filter */
1203 if ((yi->reg_2834 & 0x0000FFFF) == (yi->reg_2834 >> 16)) {
1204 /* An exact size match uses filter 0 */
1205 h_filter = 0;
1206 } else {
1207 /* Figure out which filter to use */
1208 h_filter = ((yi->reg_2834 << 16) / (yi->reg_2834 >> 16)) >> 15;
1209 h_filter = (h_filter >> 1) + (h_filter & 1);
1210 /* Only an exact size match can use filter 0. */
1211 h_filter += !h_filter;
1212 }
1213
1214 /* Now the vertical filter */
1215 if ((yi->reg_2918 & 0x0000FFFF) == (yi->reg_2918 >> 16)) {
1216 /* An exact size match uses filter 0/1 */
1217 v_filter_1 = 0;
1218 v_filter_2 = 1;
1219 } else {
1220 /* Figure out which filter to use */
1221 v_filter_1 = ((yi->reg_2918 << 16) / (yi->reg_2918 >> 16)) >> 15;
1222 v_filter_1 = (v_filter_1 >> 1) + (v_filter_1 & 1);
1223 /* Only an exact size match can use filter 0 */
1224 v_filter_1 += !v_filter_1;
1225 v_filter_2 = v_filter_1;
1226 }
1227
1228 /* Now restore the filters */
1229 ivtv_yuv_filter(itv, h_filter, v_filter_1, v_filter_2);
1230
1231 /* and clear a few registers */
1232 write_reg(0, 0x02814);
1233 write_reg(0, 0x0282c);
1234 write_reg(0, 0x02904);
1235 write_reg(0, 0x02910);
1236
1237 /* Release the blanking buffer */
1238 if (yi->blanking_ptr) {
1239 kfree(yi->blanking_ptr);
1240 yi->blanking_ptr = NULL;
1241 pci_unmap_single(itv->pdev, yi->blanking_dmaptr, 720*16, PCI_DMA_TODEVICE);
1242 }
1243
1244 /* Invalidate the old dimension information */
1245 yi->old_frame_info.src_w = 0;
1246 yi->old_frame_info.src_h = 0;
1247 yi->old_frame_info_args.src_w = 0;
1248 yi->old_frame_info_args.src_h = 0;
1249
1250 /* All done. */
1251 clear_bit(IVTV_F_I_DECODING_YUV, &itv->i_flags);
1252 }
Linux for Ginger Game Console