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