drivers/media/pci/ivtv/ivtv-yuv.c

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