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