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