evie/android_kernel_oneplus_msm8998
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

V4L/DVB (6719): ivtv: ivtv-yuv clean-up + source cropping bug-fix

Browse source 
ivtv-yuv code clean up & reformat. Includes minor changes to some debug lines.

Also fixes a bug found during the reformatting, which would cause the
incorrect amount of yuv data to be sent to the card if source cropping
coordinates were used.

Apart from the bug-fix, there should be no functional difference to the
previous version.

Signed-off-by: Ian Armstrong <ian@iarmst.demon.co.uk>
Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
This commit is contained in:
Ian Armstrong 2007-11-13 19:15:25 -03:00 • committed by Mauro Carvalho Chehab
parent 368f080b68
commit 2b057e8dc6
1 changed files with 318 additions and 313 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

589
drivers/media/video/ivtv/ivtv-yuv.c
View file

@ -50,7 +50,7 @@ static int ivtv_yuv_prep_user_dma(struct ivtv *itv, struct ivtv_user_dma *dma,
y_buffer_offset = IVTV_DECODER_OFFSET + yuv_offset[frame]; y_buffer_offset = IVTV_DECODER_OFFSET + yuv_offset[frame];
uv_buffer_offset = y_buffer_offset + IVTV_YUV_BUFFER_UV_OFFSET; uv_buffer_offset = y_buffer_offset + IVTV_YUV_BUFFER_UV_OFFSET;
y_decode_height = uv_decode_height = f->src_h + f->src_x; y_decode_height = uv_decode_height = f->src_h + f->src_y;
if (f->offset_y) if (f->offset_y)
y_buffer_offset += 720 * 16; y_buffer_offset += 720 * 16;
@ -65,7 +65,8 @@ static int ivtv_yuv_prep_user_dma(struct ivtv *itv, struct ivtv_user_dma *dma,
/* Still in USE */ /* Still in USE */
if (dma->SG_length || dma->page_count) { if (dma->SG_length || dma->page_count) {
IVTV_DEBUG_WARN("prep_user_dma: SG_length %d page_count %d still full?\n", IVTV_DEBUG_WARN
("prep_user_dma: SG_length %d page_count %d still full?\n",
dma->SG_length, dma->page_count); dma->SG_length, dma->page_count);
return -EBUSY; return -EBUSY;
} }
@ -82,7 +83,8 @@ static int ivtv_yuv_prep_user_dma(struct ivtv *itv, struct ivtv_user_dma *dma,
dma->page_count = y_dma.page_count + uv_dma.page_count; dma->page_count = y_dma.page_count + uv_dma.page_count;
if (y_pages + uv_pages != dma->page_count) { if (y_pages + uv_pages != dma->page_count) {
IVTV_DEBUG_WARN("failed to map user pages, returned %d instead of %d\n", IVTV_DEBUG_WARN
("failed to map user pages, returned %d instead of %d\n",
y_pages + uv_pages, dma->page_count); y_pages + uv_pages, dma->page_count);
for (i = 0; i < dma->page_count; i++) { for (i = 0; i < dma->page_count; i++) {
@ -104,12 +106,12 @@ static int ivtv_yuv_prep_user_dma(struct ivtv *itv, struct ivtv_user_dma *dma,
dma->SG_length = pci_map_sg(itv->dev, dma->SGlist, dma->page_count, PCI_DMA_TODEVICE); dma->SG_length = pci_map_sg(itv->dev, dma->SGlist, dma->page_count, PCI_DMA_TODEVICE);
/* Fill SG Array with new values */ /* Fill SG Array with new values */
ivtv_udma_fill_sg_array (dma, y_buffer_offset, uv_buffer_offset, y_size); ivtv_udma_fill_sg_array(dma, y_buffer_offset, uv_buffer_offset, y_size);
/* If we've offset the y plane, ensure top area is blanked */ /* If we've offset the y plane, ensure top area is blanked */
if (f->offset_y && itv->yuv_info.blanking_dmaptr) { if (f->offset_y && yi->blanking_dmaptr) {
dma->SGarray[dma->SG_length].size = cpu_to_le32(720*16); dma->SGarray[dma->SG_length].size = cpu_to_le32(720*16);
dma->SGarray[dma->SG_length].src = cpu_to_le32(itv->yuv_info.blanking_dmaptr); dma->SGarray[dma->SG_length].src = cpu_to_le32(yi->blanking_dmaptr);
dma->SGarray[dma->SG_length].dst = cpu_to_le32(IVTV_DECODER_OFFSET + yuv_offset[frame]); dma->SGarray[dma->SG_length].dst = cpu_to_le32(IVTV_DECODER_OFFSET + yuv_offset[frame]);
dma->SG_length++; dma->SG_length++;
} }
@ -124,11 +126,11 @@ static int ivtv_yuv_prep_user_dma(struct ivtv *itv, struct ivtv_user_dma *dma,
/* We rely on a table held in the firmware - Quick check. */ /* We rely on a table held in the firmware - Quick check. */
int ivtv_yuv_filter_check(struct ivtv *itv) int ivtv_yuv_filter_check(struct ivtv *itv)
{ {
int i, offset_y, offset_uv; int i, y, uv;
for (i=0, offset_y = 16, offset_uv = 4; i<16; i++, offset_y += 24, offset_uv += 12) { for (i = 0, y = 16, uv = 4; i < 16; i++, y += 24, uv += 12) {
if ((read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + offset_y) != i << 16) || if ((read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + y) != i << 16) ||
(read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + offset_uv) != i << 16)) { (read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + uv) != i << 16)) {
IVTV_WARN ("YUV filter table not found in firmware.\n"); IVTV_WARN ("YUV filter table not found in firmware.\n");
return -1; return -1;
} }
@ -138,69 +140,67 @@ int ivtv_yuv_filter_check(struct ivtv *itv)
static void ivtv_yuv_filter(struct ivtv *itv, int h_filter, int v_filter_1, int v_filter_2) static void ivtv_yuv_filter(struct ivtv *itv, int h_filter, int v_filter_1, int v_filter_2)
{ {
int filter_index, filter_line; u32 i, line;
/* If any filter is -1, then don't update it */ /* If any filter is -1, then don't update it */
if (h_filter > -1) { if (h_filter > -1) {
if (h_filter > 4) h_filter = 4; if (h_filter > 4)
filter_index = h_filter * 384; h_filter = 4;
filter_line = 0; i = IVTV_YUV_HORIZONTAL_FILTER_OFFSET + (h_filter * 384);
while (filter_line < 16) { for (line = 0; line < 16; line++) {
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02804); write_reg(read_dec(i), 0x02804);
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x0281c); write_reg(read_dec(i), 0x0281c);
filter_index += 4; i += 4;
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02808); write_reg(read_dec(i), 0x02808);
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02820); write_reg(read_dec(i), 0x02820);
filter_index += 4; i += 4;
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x0280c); write_reg(read_dec(i), 0x0280c);
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02824); write_reg(read_dec(i), 0x02824);
filter_index += 4; i += 4;
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02810); write_reg(read_dec(i), 0x02810);
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02828); write_reg(read_dec(i), 0x02828);
filter_index += 4; i += 4;
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02814); write_reg(read_dec(i), 0x02814);
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x0282c); write_reg(read_dec(i), 0x0282c);
filter_index += 8; i += 8;
write_reg(0, 0x02818); write_reg(0, 0x02818);
write_reg(0, 0x02830); write_reg(0, 0x02830);
filter_line ++;
} }
IVTV_DEBUG_YUV("h_filter -> %d\n",h_filter); IVTV_DEBUG_YUV("h_filter -> %d\n", h_filter);
} }
if (v_filter_1 > -1) { if (v_filter_1 > -1) {
if (v_filter_1 > 4) v_filter_1 = 4; if (v_filter_1 > 4)
filter_index = v_filter_1 * 192; v_filter_1 = 4;
filter_line = 0; i = IVTV_YUV_VERTICAL_FILTER_OFFSET + (v_filter_1 * 192);
while (filter_line < 16) { for (line = 0; line < 16; line++) {
write_reg(read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + filter_index), 0x02900); write_reg(read_dec(i), 0x02900);
filter_index += 4; i += 4;
write_reg(read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + filter_index), 0x02904); write_reg(read_dec(i), 0x02904);
filter_index += 8; i += 8;
write_reg(0, 0x02908); write_reg(0, 0x02908);
filter_line ++;
} }
IVTV_DEBUG_YUV("v_filter_1 -> %d\n",v_filter_1); IVTV_DEBUG_YUV("v_filter_1 -> %d\n", v_filter_1);
} }
if (v_filter_2 > -1) { if (v_filter_2 > -1) {
if (v_filter_2 > 4) v_filter_2 = 4; if (v_filter_2 > 4)
filter_index = v_filter_2 * 192; v_filter_2 = 4;
filter_line = 0; i = IVTV_YUV_VERTICAL_FILTER_OFFSET + (v_filter_2 * 192);
while (filter_line < 16) { for (line = 0; line < 16; line++) {
write_reg(read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + filter_index), 0x0290c); write_reg(read_dec(i), 0x0290c);
filter_index += 4; i += 4;
write_reg(read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + filter_index), 0x02910); write_reg(read_dec(i), 0x02910);
filter_index += 8; i += 8;
write_reg(0, 0x02914); write_reg(0, 0x02914);
filter_line ++;
} }
IVTV_DEBUG_YUV("v_filter_2 -> %d\n",v_filter_2); IVTV_DEBUG_YUV("v_filter_2 -> %d\n", v_filter_2);
} }
} }
static void ivtv_yuv_handle_horizontal(struct ivtv *itv, struct yuv_frame_info *window) static void ivtv_yuv_handle_horizontal(struct ivtv *itv, struct yuv_frame_info *f)
{ {
struct yuv_playback_info *yi = &itv->yuv_info;
u32 reg_2834, reg_2838, reg_283c; u32 reg_2834, reg_2838, reg_283c;
u32 reg_2844, reg_2854, reg_285c; u32 reg_2844, reg_2854, reg_285c;
u32 reg_2864, reg_2874, reg_2890; u32 reg_2864, reg_2874, reg_2890;
@ -209,18 +209,19 @@ static void ivtv_yuv_handle_horizontal(struct ivtv *itv, struct yuv_frame_info *
int h_filter; int h_filter;
u32 master_width; u32 master_width;
IVTV_DEBUG_WARN( "Need to adjust to width %d src_w %d dst_w %d src_x %d dst_x %d\n", IVTV_DEBUG_WARN
window->tru_w, window->src_w, window->dst_w,window->src_x, window->dst_x); ("Adjust to width %d src_w %d dst_w %d src_x %d dst_x %d\n",
f->tru_w, f->src_w, f->dst_w, f->src_x, f->dst_x);
/* How wide is the src image */ /* How wide is the src image */
x_cutoff = window->src_w + window->src_x; x_cutoff = f->src_w + f->src_x;
/* Set the display width */ /* Set the display width */
reg_2834 = window->dst_w; reg_2834 = f->dst_w;
reg_2838 = reg_2834; reg_2838 = reg_2834;
/* Set the display position */ /* Set the display position */
reg_2890 = window->dst_x; reg_2890 = f->dst_x;
/* Index into the image horizontally */ /* Index into the image horizontally */
reg_2870 = 0; reg_2870 = 0;
@ -231,32 +232,31 @@ static void ivtv_yuv_handle_horizontal(struct ivtv *itv, struct yuv_frame_info *
Gradually adjust the offset to avoid the video 'snapping' Gradually adjust the offset to avoid the video 'snapping'
left/right if it gets dragged through this region. left/right if it gets dragged through this region.
Only do this if osd is full width. */ Only do this if osd is full width. */
if (window->vis_w == 720) { if (f->vis_w == 720) {
if ((window->tru_x - window->pan_x > -1) && (window->tru_x - window->pan_x <= 40) && (window->dst_w >= 680)){ if ((f->tru_x - f->pan_x > -1) && (f->tru_x - f->pan_x <= 40) && (f->dst_w >= 680))
reg_2870 = 10 - (window->tru_x - window->pan_x) / 4; reg_2870 = 10 - (f->tru_x - f->pan_x) / 4;
} else if ((f->tru_x - f->pan_x < 0) && (f->tru_x - f->pan_x >= -20) && (f->dst_w >= 660))
else if ((window->tru_x - window->pan_x < 0) && (window->tru_x - window->pan_x >= -20) && (window->dst_w >= 660)) { reg_2870 = (10 + (f->tru_x - f->pan_x) / 2);
reg_2870 = (10 + (window->tru_x - window->pan_x) / 2);
}
if (window->dst_w >= window->src_w) if (f->dst_w >= f->src_w)
reg_2870 = reg_2870 << 16 | reg_2870; reg_2870 = reg_2870 << 16 | reg_2870;
else else
reg_2870 = ((reg_2870 & ~1) << 15) | (reg_2870 & ~1); reg_2870 = ((reg_2870 & ~1) << 15) | (reg_2870 & ~1);
} }
if (window->dst_w < window->src_w) if (f->dst_w < f->src_w)
reg_2870 = 0x000d000e - reg_2870; reg_2870 = 0x000d000e - reg_2870;
else else
reg_2870 = 0x0012000e - reg_2870; reg_2870 = 0x0012000e - reg_2870;
/* We're also using 2870 to shift the image left (src_x & negative dst_x) */ /* We're also using 2870 to shift the image left (src_x & negative dst_x) */
reg_2870_offset = (window->src_x*((window->dst_w << 21)/window->src_w))>>19; reg_2870_offset = (f->src_x * ((f->dst_w << 21) / f->src_w)) >> 19;
if (window->dst_w >= window->src_w) { if (f->dst_w >= f->src_w) {
x_cutoff &= ~1; x_cutoff &= ~1;
master_width = (window->src_w * 0x00200000) / (window->dst_w); master_width = (f->src_w * 0x00200000) / (f->dst_w);
if (master_width * window->dst_w != window->src_w * 0x00200000) master_width ++; if (master_width * f->dst_w != f->src_w * 0x00200000)
master_width++;
reg_2834 = (reg_2834 << 16) | x_cutoff; reg_2834 = (reg_2834 << 16) | x_cutoff;
reg_2838 = (reg_2838 << 16) | x_cutoff; reg_2838 = (reg_2838 << 16) | x_cutoff;
reg_283c = master_width >> 2; reg_283c = master_width >> 2;
@ -267,17 +267,17 @@ static void ivtv_yuv_handle_horizontal(struct ivtv *itv, struct yuv_frame_info *
/* We also need to factor in the scaling /* We also need to factor in the scaling
(src_w - dst_w) / (src_w / 4) */ (src_w - dst_w) / (src_w / 4) */
if (window->dst_w > window->src_w) if (f->dst_w > f->src_w)
reg_2870_base = ((window->dst_w - window->src_w)<<16) / (window->src_w <<14); reg_2870_base = ((f->dst_w - f->src_w)<<16) / (f->src_w <<14);
else else
reg_2870_base = 0; reg_2870_base = 0;
reg_2870 += (((reg_2870_offset << 14) & 0xFFFF0000) | reg_2870_offset >> 2) + (reg_2870_base << 17 | reg_2870_base); reg_2870 += (((reg_2870_offset << 14) & 0xFFFF0000) | reg_2870_offset >> 2) + (reg_2870_base << 17 | reg_2870_base);
reg_2874 = 0; reg_2874 = 0;
} } else if (f->dst_w < f->src_w / 2) {
else if (window->dst_w < window->src_w / 2) { master_width = (f->src_w * 0x00080000) / f->dst_w;
master_width = (window->src_w * 0x00080000) / window->dst_w; if (master_width * f->dst_w != f->src_w * 0x00080000)
if (master_width * window->dst_w != window->src_w * 0x00080000) master_width ++; master_width++;
reg_2834 = (reg_2834 << 16) | x_cutoff; reg_2834 = (reg_2834 << 16) | x_cutoff;
reg_2838 = (reg_2838 << 16) | x_cutoff; reg_2838 = (reg_2838 << 16) | x_cutoff;
reg_283c = master_width >> 2; reg_283c = master_width >> 2;
@ -285,13 +285,13 @@ static void ivtv_yuv_handle_horizontal(struct ivtv *itv, struct yuv_frame_info *
reg_2854 = master_width; reg_2854 = master_width;
reg_285c = master_width >> 1; reg_285c = master_width >> 1;
reg_2864 = master_width >> 1; reg_2864 = master_width >> 1;
reg_2870 += (((reg_2870_offset << 15) & 0xFFFF0000) | reg_2870_offset); reg_2870 += ((reg_2870_offset << 15) & 0xFFFF0000) | reg_2870_offset;
reg_2870 += (5 - (((window->src_w + window->src_w / 2) - 1) / window->dst_w)) << 16; reg_2870 += (5 - (((f->src_w + f->src_w / 2) - 1) / f->dst_w)) << 16;
reg_2874 = 0x00000012; reg_2874 = 0x00000012;
} } else {
else { master_width = (f->src_w * 0x00100000) / f->dst_w;
master_width = (window->src_w * 0x00100000) / window->dst_w; if (master_width * f->dst_w != f->src_w * 0x00100000)
if (master_width * window->dst_w != window->src_w * 0x00100000) master_width ++; master_width++;
reg_2834 = (reg_2834 << 16) | x_cutoff; reg_2834 = (reg_2834 << 16) | x_cutoff;
reg_2838 = (reg_2838 << 16) | x_cutoff; reg_2838 = (reg_2838 << 16) | x_cutoff;
reg_283c = master_width >> 2; reg_283c = master_width >> 2;
@ -299,62 +299,70 @@ static void ivtv_yuv_handle_horizontal(struct ivtv *itv, struct yuv_frame_info *
reg_2854 = master_width; reg_2854 = master_width;
reg_285c = master_width >> 1; reg_285c = master_width >> 1;
reg_2864 = master_width >> 1; reg_2864 = master_width >> 1;
reg_2870 += (((reg_2870_offset << 14) & 0xFFFF0000) | reg_2870_offset >> 1); reg_2870 += ((reg_2870_offset << 14) & 0xFFFF0000) | reg_2870_offset >> 1;
reg_2870 += (5 - (((window->src_w * 3) - 1) / window->dst_w)) << 16; reg_2870 += (5 - (((f->src_w * 3) - 1) / f->dst_w)) << 16;
reg_2874 = 0x00000001; reg_2874 = 0x00000001;
} }
/* Select the horizontal filter */ /* Select the horizontal filter */
if (window->src_w == window->dst_w) { if (f->src_w == f->dst_w) {
/* An exact size match uses filter 0 */ /* An exact size match uses filter 0 */
h_filter = 0; h_filter = 0;
} } else {
else {
/* Figure out which filter to use */ /* Figure out which filter to use */
h_filter = ((window->src_w << 16) / window->dst_w) >> 15; h_filter = ((f->src_w << 16) / f->dst_w) >> 15;
h_filter = (h_filter >> 1) + (h_filter & 1); h_filter = (h_filter >> 1) + (h_filter & 1);
/* Only an exact size match can use filter 0 */ /* Only an exact size match can use filter 0 */
if (h_filter == 0) h_filter = 1; h_filter += !h_filter;
} }
write_reg(reg_2834, 0x02834); write_reg(reg_2834, 0x02834);
write_reg(reg_2838, 0x02838); write_reg(reg_2838, 0x02838);
IVTV_DEBUG_YUV("Update reg 0x2834 %08x->%08x 0x2838 %08x->%08x\n",itv->yuv_info.reg_2834, reg_2834, itv->yuv_info.reg_2838, reg_2838); IVTV_DEBUG_YUV("Update reg 0x2834 %08x->%08x 0x2838 %08x->%08x\n",
yi->reg_2834, reg_2834, yi->reg_2838, reg_2838);
write_reg(reg_283c, 0x0283c); write_reg(reg_283c, 0x0283c);
write_reg(reg_2844, 0x02844); write_reg(reg_2844, 0x02844);
IVTV_DEBUG_YUV("Update reg 0x283c %08x->%08x 0x2844 %08x->%08x\n",itv->yuv_info.reg_283c, reg_283c, itv->yuv_info.reg_2844, reg_2844); IVTV_DEBUG_YUV("Update reg 0x283c %08x->%08x 0x2844 %08x->%08x\n",
yi->reg_283c, reg_283c, yi->reg_2844, reg_2844);
write_reg(0x00080514, 0x02840); write_reg(0x00080514, 0x02840);
write_reg(0x00100514, 0x02848); write_reg(0x00100514, 0x02848);
IVTV_DEBUG_YUV("Update reg 0x2840 %08x->%08x 0x2848 %08x->%08x\n",itv->yuv_info.reg_2840, 0x00080514, itv->yuv_info.reg_2848, 0x00100514); IVTV_DEBUG_YUV("Update reg 0x2840 %08x->%08x 0x2848 %08x->%08x\n",
yi->reg_2840, 0x00080514, yi->reg_2848, 0x00100514);
write_reg(reg_2854, 0x02854); write_reg(reg_2854, 0x02854);
IVTV_DEBUG_YUV("Update reg 0x2854 %08x->%08x \n",itv->yuv_info.reg_2854, reg_2854); IVTV_DEBUG_YUV("Update reg 0x2854 %08x->%08x \n",
yi->reg_2854, reg_2854);
write_reg(reg_285c, 0x0285c); write_reg(reg_285c, 0x0285c);
write_reg(reg_2864, 0x02864); write_reg(reg_2864, 0x02864);
IVTV_DEBUG_YUV("Update reg 0x285c %08x->%08x 0x2864 %08x->%08x\n",itv->yuv_info.reg_285c, reg_285c, itv->yuv_info.reg_2864, reg_2864); IVTV_DEBUG_YUV("Update reg 0x285c %08x->%08x 0x2864 %08x->%08x\n",
yi->reg_285c, reg_285c, yi->reg_2864, reg_2864);
write_reg(reg_2874, 0x02874); write_reg(reg_2874, 0x02874);
IVTV_DEBUG_YUV("Update reg 0x2874 %08x->%08x\n",itv->yuv_info.reg_2874, reg_2874); IVTV_DEBUG_YUV("Update reg 0x2874 %08x->%08x\n",
yi->reg_2874, reg_2874);
write_reg(reg_2870, 0x02870); write_reg(reg_2870, 0x02870);
IVTV_DEBUG_YUV("Update reg 0x2870 %08x->%08x\n",itv->yuv_info.reg_2870, reg_2870); IVTV_DEBUG_YUV("Update reg 0x2870 %08x->%08x\n",
yi->reg_2870, reg_2870);
write_reg( reg_2890,0x02890); write_reg(reg_2890, 0x02890);
IVTV_DEBUG_YUV("Update reg 0x2890 %08x->%08x\n",itv->yuv_info.reg_2890, reg_2890); IVTV_DEBUG_YUV("Update reg 0x2890 %08x->%08x\n",
yi->reg_2890, reg_2890);
/* Only update the filter if we really need to */ /* Only update the filter if we really need to */
if (h_filter != itv->yuv_info.h_filter) { if (h_filter != yi->h_filter) {
ivtv_yuv_filter (itv,h_filter,-1,-1); ivtv_yuv_filter(itv, h_filter, -1, -1);
itv->yuv_info.h_filter = h_filter; yi->h_filter = h_filter;
} }
} }
static void ivtv_yuv_handle_vertical(struct ivtv *itv, struct yuv_frame_info *window) static void ivtv_yuv_handle_vertical(struct ivtv *itv, struct yuv_frame_info *f)
{ {
struct yuv_playback_info *yi = &itv->yuv_info;
u32 master_height; u32 master_height;
u32 reg_2918, reg_291c, reg_2920, reg_2928; u32 reg_2918, reg_291c, reg_2920, reg_2928;
u32 reg_2930, reg_2934, reg_293c; u32 reg_2930, reg_2934, reg_293c;
@ -362,69 +370,59 @@ static void ivtv_yuv_handle_vertical(struct ivtv *itv, struct yuv_frame_info *wi
u32 reg_2950, reg_2954, reg_2958, reg_295c; u32 reg_2950, reg_2954, reg_2958, reg_295c;
u32 reg_2960, reg_2964, reg_2968, reg_296c; u32 reg_2960, reg_2964, reg_2968, reg_296c;
u32 reg_289c; u32 reg_289c;
u32 src_y_major_y, src_y_minor_y; u32 src_major_y, src_minor_y;
u32 src_y_major_uv, src_y_minor_uv; u32 src_major_uv, src_minor_uv;
u32 reg_2964_base, reg_2968_base; u32 reg_2964_base, reg_2968_base;
int v_filter_1, v_filter_2; int v_filter_1, v_filter_2;
IVTV_DEBUG_WARN("Need to adjust to height %d src_h %d dst_h %d src_y %d dst_y %d\n", IVTV_DEBUG_WARN
window->tru_h, window->src_h, window->dst_h,window->src_y, window->dst_y); ("Adjust to height %d src_h %d dst_h %d src_y %d dst_y %d\n",
f->tru_h, f->src_h, f->dst_h, f->src_y, f->dst_y);
/* What scaling mode is being used... */ /* What scaling mode is being used... */
if (window->interlaced_y) { IVTV_DEBUG_YUV("Scaling mode Y: %s\n",
IVTV_DEBUG_YUV("Scaling mode Y: Interlaced\n"); f->interlaced_y ? "Interlaced" : "Progressive");
}
else {
IVTV_DEBUG_YUV("Scaling mode Y: Progressive\n");
}
if (window->interlaced_uv) { IVTV_DEBUG_YUV("Scaling mode UV: %s\n",
IVTV_DEBUG_YUV("Scaling mode UV: Interlaced\n"); f->interlaced_uv ? "Interlaced" : "Progressive");
}
else {
IVTV_DEBUG_YUV("Scaling mode UV: Progressive\n");
}
/* What is the source video being treated as... */ /* What is the source video being treated as... */
if (window->interlaced) { IVTV_DEBUG_WARN("Source video: %s\n",
IVTV_DEBUG_WARN("Source video: Interlaced\n"); f->interlaced ? "Interlaced" : "Progressive");
}
else {
IVTV_DEBUG_WARN("Source video: Non-interlaced\n");
}
/* We offset into the image using two different index methods, so split /* We offset into the image using two different index methods, so split
the y source coord into two parts. */ the y source coord into two parts. */
if (window->src_y < 8) { if (f->src_y < 8) {
src_y_minor_uv = window->src_y; src_minor_uv = f->src_y;
src_y_major_uv = 0; src_major_uv = 0;
} } else {
else { src_minor_uv = 8;
src_y_minor_uv = 8; src_major_uv = f->src_y - 8;
src_y_major_uv = window->src_y - 8;
} }
src_y_minor_y = src_y_minor_uv; src_minor_y = src_minor_uv;
src_y_major_y = src_y_major_uv; src_major_y = src_major_uv;
if (window->offset_y) src_y_minor_y += 16; if (f->offset_y)
src_minor_y += 16;
if (window->interlaced_y) if (f->interlaced_y)
reg_2918 = (window->dst_h << 16) | (window->src_h + src_y_minor_y); reg_2918 = (f->dst_h << 16) | (f->src_h + src_minor_y);
else else
reg_2918 = (window->dst_h << 16) | ((window->src_h + src_y_minor_y) << 1); reg_2918 = (f->dst_h << 16) | ((f->src_h + src_minor_y) << 1);
if (window->interlaced_uv) if (f->interlaced_uv)
reg_291c = (window->dst_h << 16) | ((window->src_h + src_y_minor_uv) >> 1); reg_291c = (f->dst_h << 16) | ((f->src_h + src_minor_uv) >> 1);
else else
reg_291c = (window->dst_h << 16) | (window->src_h + src_y_minor_uv); reg_291c = (f->dst_h << 16) | (f->src_h + src_minor_uv);
reg_2964_base = (src_y_minor_y * ((window->dst_h << 16)/window->src_h)) >> 14; reg_2964_base = (src_minor_y * ((f->dst_h << 16) / f->src_h)) >> 14;
reg_2968_base = (src_y_minor_uv * ((window->dst_h << 16)/window->src_h)) >> 14; reg_2968_base = (src_minor_uv * ((f->dst_h << 16) / f->src_h)) >> 14;
if (window->dst_h / 2 >= window->src_h && !window->interlaced_y) { if (f->dst_h / 2 >= f->src_h && !f->interlaced_y) {
master_height = (window->src_h * 0x00400000) / window->dst_h; master_height = (f->src_h * 0x00400000) / f->dst_h;
if ((window->src_h * 0x00400000) - (master_height * window->dst_h) >= window->dst_h / 2) master_height ++; if ((f->src_h * 0x00400000) - (master_height * f->dst_h) >= f->dst_h / 2)
master_height++;
reg_2920 = master_height >> 2; reg_2920 = master_height >> 2;
reg_2928 = master_height >> 3; reg_2928 = master_height >> 3;
reg_2930 = master_height; reg_2930 = master_height;
@ -432,45 +430,42 @@ static void ivtv_yuv_handle_vertical(struct ivtv *itv, struct yuv_frame_info *wi
reg_2964_base >>= 3; reg_2964_base >>= 3;
reg_2968_base >>= 3; reg_2968_base >>= 3;
reg_296c = 0x00000000; reg_296c = 0x00000000;
} } else if (f->dst_h >= f->src_h) {
else if (window->dst_h >= window->src_h) { master_height = (f->src_h * 0x00400000) / f->dst_h;
master_height = (window->src_h * 0x00400000) / window->dst_h;
master_height = (master_height >> 1) + (master_height & 1); master_height = (master_height >> 1) + (master_height & 1);
reg_2920 = master_height >> 2; reg_2920 = master_height >> 2;
reg_2928 = master_height >> 2; reg_2928 = master_height >> 2;
reg_2930 = master_height; reg_2930 = master_height;
reg_2940 = master_height >> 1; reg_2940 = master_height >> 1;
reg_296c = 0x00000000; reg_296c = 0x00000000;
if (window->interlaced_y) { if (f->interlaced_y) {
reg_2964_base >>= 3; reg_2964_base >>= 3;
} } else {
else { reg_296c++;
reg_296c ++;
reg_2964_base >>= 2; reg_2964_base >>= 2;
} }
if (window->interlaced_uv) reg_2928 >>= 1; if (f->interlaced_uv)
reg_2928 >>= 1;
reg_2968_base >>= 3; reg_2968_base >>= 3;
} } else if (f->dst_h >= f->src_h / 2) {
else if (window->dst_h >= window->src_h / 2) { master_height = (f->src_h * 0x00200000) / f->dst_h;
master_height = (window->src_h * 0x00200000) / window->dst_h;
master_height = (master_height >> 1) + (master_height & 1); master_height = (master_height >> 1) + (master_height & 1);
reg_2920 = master_height >> 2; reg_2920 = master_height >> 2;
reg_2928 = master_height >> 2; reg_2928 = master_height >> 2;
reg_2930 = master_height; reg_2930 = master_height;
reg_2940 = master_height; reg_2940 = master_height;
reg_296c = 0x00000101; reg_296c = 0x00000101;
if (window->interlaced_y) { if (f->interlaced_y) {
reg_2964_base >>= 2; reg_2964_base >>= 2;
} } else {
else { reg_296c++;
reg_296c ++;
reg_2964_base >>= 1; reg_2964_base >>= 1;
} }
if (window->interlaced_uv) reg_2928 >>= 1; if (f->interlaced_uv)
reg_2928 >>= 1;
reg_2968_base >>= 2; reg_2968_base >>= 2;
} } else {
else { master_height = (f->src_h * 0x00100000) / f->dst_h;
master_height = (window->src_h * 0x00100000) / window->dst_h;
master_height = (master_height >> 1) + (master_height & 1); master_height = (master_height >> 1) + (master_height & 1);
reg_2920 = master_height >> 2; reg_2920 = master_height >> 2;
reg_2928 = master_height >> 2; reg_2928 = master_height >> 2;
@ -483,13 +478,12 @@ static void ivtv_yuv_handle_vertical(struct ivtv *itv, struct yuv_frame_info *wi
/* FIXME These registers change depending on scaled / unscaled output /* FIXME These registers change depending on scaled / unscaled output
We really need to work out what they should be */ We really need to work out what they should be */
if (window->src_h == window->dst_h){ if (f->src_h == f->dst_h) {
reg_2934 = 0x00020000; reg_2934 = 0x00020000;
reg_293c = 0x00100000; reg_293c = 0x00100000;
reg_2944 = 0x00040000; reg_2944 = 0x00040000;
reg_294c = 0x000b0000; reg_294c = 0x000b0000;
} } else {
else {
reg_2934 = 0x00000FF0; reg_2934 = 0x00000FF0;
reg_293c = 0x00000FF0; reg_293c = 0x00000FF0;
reg_2944 = 0x00000FF0; reg_2944 = 0x00000FF0;
@ -497,34 +491,36 @@ static void ivtv_yuv_handle_vertical(struct ivtv *itv, struct yuv_frame_info *wi
} }
/* The first line to be displayed */ /* The first line to be displayed */
reg_2950 = 0x00010000 + src_y_major_y; reg_2950 = 0x00010000 + src_major_y;
if (window->interlaced_y) reg_2950 += 0x00010000; if (f->interlaced_y)
reg_2950 += 0x00010000;
reg_2954 = reg_2950 + 1; reg_2954 = reg_2950 + 1;
reg_2958 = 0x00010000 + (src_y_major_y >> 1); reg_2958 = 0x00010000 + (src_major_y >> 1);
if (window->interlaced_uv) reg_2958 += 0x00010000; if (f->interlaced_uv)
reg_2958 += 0x00010000;
reg_295c = reg_2958 + 1; reg_295c = reg_2958 + 1;
if (itv->yuv_info.decode_height == 480) if (yi->decode_height == 480)
reg_289c = 0x011e0017; reg_289c = 0x011e0017;
else else
reg_289c = 0x01500017; reg_289c = 0x01500017;
if (window->dst_y < 0) if (f->dst_y < 0)
reg_289c = (reg_289c - ((window->dst_y & ~1)<<15))-(window->dst_y >>1); reg_289c = (reg_289c - ((f->dst_y & ~1)<<15))-(f->dst_y >>1);
else else
reg_289c = (reg_289c + ((window->dst_y & ~1)<<15))+(window->dst_y >>1); reg_289c = (reg_289c + ((f->dst_y & ~1)<<15))+(f->dst_y >>1);
/* How much of the source to decode. /* How much of the source to decode.
Take into account the source offset */ Take into account the source offset */
reg_2960 = ((src_y_minor_y + window->src_h + src_y_major_y) - 1 ) | reg_2960 = ((src_minor_y + f->src_h + src_major_y) - 1) |
((((src_y_minor_uv + window->src_h + src_y_major_uv) - 1) & ~1) << 15); (((src_minor_uv + f->src_h + src_major_uv - 1) & ~1) << 15);
/* Calculate correct value for register 2964 */ /* Calculate correct value for register 2964 */
if (window->src_h == window->dst_h) if (f->src_h == f->dst_h) {
reg_2964 = 1; reg_2964 = 1;
else { } else {
reg_2964 = 2 + ((window->dst_h << 1) / window->src_h); reg_2964 = 2 + ((f->dst_h << 1) / f->src_h);
reg_2964 = (reg_2964 >> 1) + (reg_2964 & 1); reg_2964 = (reg_2964 >> 1) + (reg_2964 & 1);
} }
reg_2968 = (reg_2964 << 16) + reg_2964 + (reg_2964 >> 1); reg_2968 = (reg_2964 << 16) + reg_2964 + (reg_2964 >> 1);
@ -539,94 +535,107 @@ static void ivtv_yuv_handle_vertical(struct ivtv *itv, struct yuv_frame_info *wi
/* Deviate further from what it should be. I find the flicker headache /* Deviate further from what it should be. I find the flicker headache
inducing so try to reduce it slightly. Leave 2968 as-is otherwise inducing so try to reduce it slightly. Leave 2968 as-is otherwise
colours foul. */ colours foul. */
if ((reg_2964 != 0x00010001) && (window->dst_h / 2 <= window->src_h)) if ((reg_2964 != 0x00010001) && (f->dst_h / 2 <= f->src_h))
reg_2964 = (reg_2964 & 0xFFFF0000) + ((reg_2964 & 0x0000FFFF)/2); reg_2964 = (reg_2964 & 0xFFFF0000) + ((reg_2964 & 0x0000FFFF) / 2);
if (!window->interlaced_y) reg_2964 -= 0x00010001; if (!f->interlaced_y)
if (!window->interlaced_uv) reg_2968 -= 0x00010001; reg_2964 -= 0x00010001;
if (!f->interlaced_uv)
reg_2968 -= 0x00010001;
reg_2964 += ((reg_2964_base << 16) | reg_2964_base); reg_2964 += ((reg_2964_base << 16) | reg_2964_base);
reg_2968 += ((reg_2968_base << 16) | reg_2968_base); reg_2968 += ((reg_2968_base << 16) | reg_2968_base);
/* Select the vertical filter */ /* Select the vertical filter */
if (window->src_h == window->dst_h) { if (f->src_h == f->dst_h) {
/* An exact size match uses filter 0/1 */ /* An exact size match uses filter 0/1 */
v_filter_1 = 0; v_filter_1 = 0;
v_filter_2 = 1; v_filter_2 = 1;
} } else {
else {
/* Figure out which filter to use */ /* Figure out which filter to use */
v_filter_1 = ((window->src_h << 16) / window->dst_h) >> 15; v_filter_1 = ((f->src_h << 16) / f->dst_h) >> 15;
v_filter_1 = (v_filter_1 >> 1) + (v_filter_1 & 1); v_filter_1 = (v_filter_1 >> 1) + (v_filter_1 & 1);
/* Only an exact size match can use filter 0 */ /* Only an exact size match can use filter 0 */
if (v_filter_1 == 0) v_filter_1 = 1; v_filter_1 += !v_filter_1;
v_filter_2 = v_filter_1; v_filter_2 = v_filter_1;
} }
write_reg(reg_2934, 0x02934); write_reg(reg_2934, 0x02934);
write_reg(reg_293c, 0x0293c); write_reg(reg_293c, 0x0293c);
IVTV_DEBUG_YUV("Update reg 0x2934 %08x->%08x 0x293c %08x->%08x\n",itv->yuv_info.reg_2934, reg_2934, itv->yuv_info.reg_293c, reg_293c); IVTV_DEBUG_YUV("Update reg 0x2934 %08x->%08x 0x293c %08x->%08x\n",
yi->reg_2934, reg_2934, yi->reg_293c, reg_293c);
write_reg(reg_2944, 0x02944); write_reg(reg_2944, 0x02944);
write_reg(reg_294c, 0x0294c); write_reg(reg_294c, 0x0294c);
IVTV_DEBUG_YUV("Update reg 0x2944 %08x->%08x 0x294c %08x->%08x\n",itv->yuv_info.reg_2944, reg_2944, itv->yuv_info.reg_294c, reg_294c); IVTV_DEBUG_YUV("Update reg 0x2944 %08x->%08x 0x294c %08x->%08x\n",
yi->reg_2944, reg_2944, yi->reg_294c, reg_294c);
/* Ensure 2970 is 0 (does it ever change ?) */ /* Ensure 2970 is 0 (does it ever change ?) */
/* write_reg(0,0x02970); */ /* write_reg(0,0x02970); */
/* IVTV_DEBUG_YUV("Update reg 0x2970 %08x->%08x\n",itv->yuv_info.reg_2970, 0); */ /* IVTV_DEBUG_YUV("Update reg 0x2970 %08x->%08x\n", yi->reg_2970, 0); */
write_reg(reg_2930, 0x02938); write_reg(reg_2930, 0x02938);
write_reg(reg_2930, 0x02930); write_reg(reg_2930, 0x02930);
IVTV_DEBUG_YUV("Update reg 0x2930 %08x->%08x 0x2938 %08x->%08x\n",itv->yuv_info.reg_2930, reg_2930, itv->yuv_info.reg_2938, reg_2930); IVTV_DEBUG_YUV("Update reg 0x2930 %08x->%08x 0x2938 %08x->%08x\n",
yi->reg_2930, reg_2930, yi->reg_2938, reg_2930);
write_reg(reg_2928, 0x02928); write_reg(reg_2928, 0x02928);
write_reg(reg_2928+0x514, 0x0292C); write_reg(reg_2928 + 0x514, 0x0292C);
IVTV_DEBUG_YUV("Update reg 0x2928 %08x->%08x 0x292c %08x->%08x\n",itv->yuv_info.reg_2928, reg_2928, itv->yuv_info.reg_292c, reg_2928+0x514); IVTV_DEBUG_YUV("Update reg 0x2928 %08x->%08x 0x292c %08x->%08x\n",
yi->reg_2928, reg_2928, yi->reg_292c, reg_2928 + 0x514);
write_reg(reg_2920, 0x02920); write_reg(reg_2920, 0x02920);
write_reg(reg_2920+0x514, 0x02924); write_reg(reg_2920 + 0x514, 0x02924);
IVTV_DEBUG_YUV("Update reg 0x2920 %08x->%08x 0x2924 %08x->%08x\n",itv->yuv_info.reg_2920, reg_2920, itv->yuv_info.reg_2924, 0x514+reg_2920); IVTV_DEBUG_YUV("Update reg 0x2920 %08x->%08x 0x2924 %08x->%08x\n",
yi->reg_2920, reg_2920, yi->reg_2924, reg_2920 + 0x514);
write_reg (reg_2918,0x02918); write_reg(reg_2918, 0x02918);
write_reg (reg_291c,0x0291C); write_reg(reg_291c, 0x0291C);
IVTV_DEBUG_YUV("Update reg 0x2918 %08x->%08x 0x291C %08x->%08x\n",itv->yuv_info.reg_2918,reg_2918,itv->yuv_info.reg_291c,reg_291c); IVTV_DEBUG_YUV("Update reg 0x2918 %08x->%08x 0x291C %08x->%08x\n",
yi->reg_2918, reg_2918, yi->reg_291c, reg_291c);
write_reg(reg_296c, 0x0296c); write_reg(reg_296c, 0x0296c);
IVTV_DEBUG_YUV("Update reg 0x296c %08x->%08x\n",itv->yuv_info.reg_296c, reg_296c); IVTV_DEBUG_YUV("Update reg 0x296c %08x->%08x\n",
yi->reg_296c, reg_296c);
write_reg(reg_2940, 0x02948); write_reg(reg_2940, 0x02948);
write_reg(reg_2940, 0x02940); write_reg(reg_2940, 0x02940);
IVTV_DEBUG_YUV("Update reg 0x2940 %08x->%08x 0x2948 %08x->%08x\n",itv->yuv_info.reg_2940, reg_2940, itv->yuv_info.reg_2948, reg_2940); IVTV_DEBUG_YUV("Update reg 0x2940 %08x->%08x 0x2948 %08x->%08x\n",
yi->reg_2940, reg_2940, yi->reg_2948, reg_2940);
write_reg(reg_2950, 0x02950); write_reg(reg_2950, 0x02950);
write_reg(reg_2954, 0x02954); write_reg(reg_2954, 0x02954);
IVTV_DEBUG_YUV("Update reg 0x2950 %08x->%08x 0x2954 %08x->%08x\n",itv->yuv_info.reg_2950, reg_2950, itv->yuv_info.reg_2954, reg_2954); IVTV_DEBUG_YUV("Update reg 0x2950 %08x->%08x 0x2954 %08x->%08x\n",
yi->reg_2950, reg_2950, yi->reg_2954, reg_2954);
write_reg(reg_2958, 0x02958); write_reg(reg_2958, 0x02958);
write_reg(reg_295c, 0x0295C); write_reg(reg_295c, 0x0295C);
IVTV_DEBUG_YUV("Update reg 0x2958 %08x->%08x 0x295C %08x->%08x\n",itv->yuv_info.reg_2958, reg_2958, itv->yuv_info.reg_295c, reg_295c); IVTV_DEBUG_YUV("Update reg 0x2958 %08x->%08x 0x295C %08x->%08x\n",
yi->reg_2958, reg_2958, yi->reg_295c, reg_295c);
write_reg(reg_2960, 0x02960); write_reg(reg_2960, 0x02960);
IVTV_DEBUG_YUV("Update reg 0x2960 %08x->%08x \n",itv->yuv_info.reg_2960, reg_2960); IVTV_DEBUG_YUV("Update reg 0x2960 %08x->%08x \n",
yi->reg_2960, reg_2960);
write_reg(reg_2964, 0x02964); write_reg(reg_2964, 0x02964);
write_reg(reg_2968, 0x02968); write_reg(reg_2968, 0x02968);
IVTV_DEBUG_YUV("Update reg 0x2964 %08x->%08x 0x2968 %08x->%08x\n",itv->yuv_info.reg_2964, reg_2964, itv->yuv_info.reg_2968, reg_2968); IVTV_DEBUG_YUV("Update reg 0x2964 %08x->%08x 0x2968 %08x->%08x\n",
yi->reg_2964, reg_2964, yi->reg_2968, reg_2968);
write_reg( reg_289c,0x0289c); write_reg(reg_289c, 0x0289c);
IVTV_DEBUG_YUV("Update reg 0x289c %08x->%08x\n",itv->yuv_info.reg_289c, reg_289c); IVTV_DEBUG_YUV("Update reg 0x289c %08x->%08x\n",
yi->reg_289c, reg_289c);
/* Only update filter 1 if we really need to */ /* Only update filter 1 if we really need to */
if (v_filter_1 != itv->yuv_info.v_filter_1) { if (v_filter_1 != yi->v_filter_1) {
ivtv_yuv_filter (itv,-1,v_filter_1,-1); ivtv_yuv_filter(itv, -1, v_filter_1, -1);
itv->yuv_info.v_filter_1 = v_filter_1; yi->v_filter_1 = v_filter_1;
} }
/* Only update filter 2 if we really need to */ /* Only update filter 2 if we really need to */
if (v_filter_2 != itv->yuv_info.v_filter_2) { if (v_filter_2 != yi->v_filter_2) {
ivtv_yuv_filter (itv,-1,-1,v_filter_2); ivtv_yuv_filter(itv, -1, -1, v_filter_2);
itv->yuv_info.v_filter_2 = v_filter_2; yi->v_filter_2 = v_filter_2;
} }
} }
/* Modify the supplied coordinate information to fit the visible osd area */ /* Modify the supplied coordinate information to fit the visible osd area */
@ -773,24 +782,24 @@ static u32 ivtv_yuv_window_setup(struct ivtv *itv, struct yuv_frame_info *f)
} }
/* Update the scaling register to the requested value */ /* Update the scaling register to the requested value */
void ivtv_yuv_work_handler (struct ivtv *itv) void ivtv_yuv_work_handler(struct ivtv *itv)
{ {
struct yuv_playback_info *yi = &itv->yuv_info; struct yuv_playback_info *yi = &itv->yuv_info;
struct yuv_frame_info f; struct yuv_frame_info f;
int frame = yi->update_frame; int frame = yi->update_frame;
u32 yuv_update; u32 yuv_update;
/* IVTV_DEBUG_YUV("Update yuv registers for frame %d\n",frame); */ IVTV_DEBUG_YUV("Update yuv registers for frame %d\n", frame);
f = yi->new_frame_info[frame]; f = yi->new_frame_info[frame];
/* Update the osd pan info */ /* Update the osd pan info */
f.pan_x = itv->yuv_info.osd_x_pan; f.pan_x = yi->osd_x_pan;
f.pan_y = itv->yuv_info.osd_y_pan; f.pan_y = yi->osd_y_pan;
f.vis_w = itv->yuv_info.osd_vis_w; f.vis_w = yi->osd_vis_w;
f.vis_h = itv->yuv_info.osd_vis_h; f.vis_h = yi->osd_vis_h;
/* Calculate the display window coordinates. Exit if nothing left */ /* Calculate the display window coordinates. Exit if nothing left */
if (!(yuv_update = ivtv_yuv_window_setup (itv, &f))) if (!(yuv_update = ivtv_yuv_window_setup(itv, &f)))
return; return;
if (yuv_update & IVTV_YUV_UPDATE_INVALID) { if (yuv_update & IVTV_YUV_UPDATE_INVALID) {
@ -807,7 +816,7 @@ void ivtv_yuv_work_handler (struct ivtv *itv)
yi->old_frame_info = f; yi->old_frame_info = f;
} }
static void ivtv_yuv_init (struct ivtv *itv) static void ivtv_yuv_init(struct ivtv *itv)
{ {
struct yuv_playback_info *yi = &itv->yuv_info; struct yuv_playback_info *yi = &itv->yuv_info;
@ -876,25 +885,23 @@ static void ivtv_yuv_init (struct ivtv *itv)
if (!yi->osd_vis_w) if (!yi->osd_vis_w)
yi->osd_vis_w = 720 - yi->osd_x_offset; yi->osd_vis_w = 720 - yi->osd_x_offset;
if (!yi->osd_vis_h) if (!yi->osd_vis_h) {
yi->osd_vis_h = yi->decode_height - yi->osd_y_offset; yi->osd_vis_h = yi->decode_height - yi->osd_y_offset;
else { } else if (yi->osd_vis_h + yi->osd_y_offset > yi->decode_height) {
/* If output video standard has changed, requested height may /* If output video standard has changed, requested height may
not be legal */ not be legal */
if (yi->osd_vis_h + yi->osd_y_offset > yi->decode_height) {
IVTV_DEBUG_WARN("Clipping yuv output - fb size (%d) exceeds video standard limit (%d)\n", IVTV_DEBUG_WARN("Clipping yuv output - fb size (%d) exceeds video standard limit (%d)\n",
yi->osd_vis_h + yi->osd_y_offset, yi->osd_vis_h + yi->osd_y_offset,
yi->decode_height); yi->decode_height);
yi->osd_vis_h = yi->decode_height - yi->osd_y_offset; yi->osd_vis_h = yi->decode_height - yi->osd_y_offset;
} }
} }
}
/* We need a buffer for blanking when Y plane is offset - non-fatal if we can't get one */ /* We need a buffer for blanking when Y plane is offset - non-fatal if we can't get one */
yi->blanking_ptr = kzalloc(720*16, GFP_KERNEL); yi->blanking_ptr = kzalloc(720 * 16, GFP_KERNEL);
if (yi->blanking_ptr) if (yi->blanking_ptr) {
yi->blanking_dmaptr = pci_map_single(itv->dev, yi->blanking_ptr, 720*16, PCI_DMA_TODEVICE); yi->blanking_dmaptr = pci_map_single(itv->dev, yi->blanking_ptr, 720*16, PCI_DMA_TODEVICE);
else { } else {
yi->blanking_dmaptr = 0; yi->blanking_dmaptr = 0;
IVTV_DEBUG_WARN("Failed to allocate yuv blanking buffer\n"); IVTV_DEBUG_WARN("Failed to allocate yuv blanking buffer\n");
} }
@ -1020,7 +1027,7 @@ void ivtv_yuv_setup_frame(struct ivtv *itv, struct ivtv_dma_frame *args)
if (memcmp(&yi->old_frame_info_args, nf, sizeof(*nf))) { if (memcmp(&yi->old_frame_info_args, nf, sizeof(*nf))) {
yi->old_frame_info_args = *nf; yi->old_frame_info_args = *nf;
nf->update = 1; nf->update = 1;
/* IVTV_DEBUG_YUV ("Requesting register update for frame %d\n",frame); */ IVTV_DEBUG_YUV("Requesting reg update for frame %d\n", frame);
} }
nf->update |= update; nf->update |= update;
@ -1121,7 +1128,7 @@ int ivtv_yuv_udma_stream_frame(struct ivtv *itv, void *src)
/* IVTV_IOC_DMA_FRAME ioctl handler */ /* IVTV_IOC_DMA_FRAME ioctl handler */
int ivtv_yuv_prep_frame(struct ivtv *itv, struct ivtv_dma_frame *args) int ivtv_yuv_prep_frame(struct ivtv *itv, struct ivtv_dma_frame *args)
{ {
IVTV_DEBUG_INFO("yuv_prep_frame\n"); /* IVTV_DEBUG_INFO("yuv_prep_frame\n"); */
ivtv_yuv_next_free(itv); ivtv_yuv_next_free(itv);
ivtv_yuv_setup_frame(itv, args); ivtv_yuv_setup_frame(itv, args);
@ -1130,91 +1137,90 @@ int ivtv_yuv_prep_frame(struct ivtv *itv, struct ivtv_dma_frame *args)
void ivtv_yuv_close(struct ivtv *itv) void ivtv_yuv_close(struct ivtv *itv)
{ {
struct yuv_playback_info *yi = &itv->yuv_info;
int h_filter, v_filter_1, v_filter_2; int h_filter, v_filter_1, v_filter_2;
IVTV_DEBUG_YUV("ivtv_yuv_close\n"); IVTV_DEBUG_YUV("ivtv_yuv_close\n");
ivtv_waitq(&itv->vsync_waitq); ivtv_waitq(&itv->vsync_waitq);
atomic_set(&itv->yuv_info.next_dma_frame, -1); atomic_set(&yi->next_dma_frame, -1);
atomic_set(&itv->yuv_info.next_fill_frame, 0); atomic_set(&yi->next_fill_frame, 0);
/* Reset registers we have changed so mpeg playback works */ /* Reset registers we have changed so mpeg playback works */
/* If we fully restore this register, the display may remain active. /* If we fully restore this register, the display may remain active.
Restore, but set one bit to blank the video. Firmware will always Restore, but set one bit to blank the video. Firmware will always
clear this bit when needed, so not a problem. */ clear this bit when needed, so not a problem. */
write_reg(itv->yuv_info.reg_2898 | 0x01000000, 0x2898); write_reg(yi->reg_2898 | 0x01000000, 0x2898);
write_reg(itv->yuv_info.reg_2834, 0x02834); write_reg(yi->reg_2834, 0x02834);
write_reg(itv->yuv_info.reg_2838, 0x02838); write_reg(yi->reg_2838, 0x02838);
write_reg(itv->yuv_info.reg_283c, 0x0283c); write_reg(yi->reg_283c, 0x0283c);
write_reg(itv->yuv_info.reg_2840, 0x02840); write_reg(yi->reg_2840, 0x02840);
write_reg(itv->yuv_info.reg_2844, 0x02844); write_reg(yi->reg_2844, 0x02844);
write_reg(itv->yuv_info.reg_2848, 0x02848); write_reg(yi->reg_2848, 0x02848);
write_reg(itv->yuv_info.reg_2854, 0x02854); write_reg(yi->reg_2854, 0x02854);
write_reg(itv->yuv_info.reg_285c, 0x0285c); write_reg(yi->reg_285c, 0x0285c);
write_reg(itv->yuv_info.reg_2864, 0x02864); write_reg(yi->reg_2864, 0x02864);
write_reg(itv->yuv_info.reg_2870, 0x02870); write_reg(yi->reg_2870, 0x02870);
write_reg(itv->yuv_info.reg_2874, 0x02874); write_reg(yi->reg_2874, 0x02874);
write_reg(itv->yuv_info.reg_2890, 0x02890); write_reg(yi->reg_2890, 0x02890);
write_reg(itv->yuv_info.reg_289c, 0x0289c); write_reg(yi->reg_289c, 0x0289c);
write_reg(itv->yuv_info.reg_2918, 0x02918); write_reg(yi->reg_2918, 0x02918);
write_reg(itv->yuv_info.reg_291c, 0x0291c); write_reg(yi->reg_291c, 0x0291c);
write_reg(itv->yuv_info.reg_2920, 0x02920); write_reg(yi->reg_2920, 0x02920);
write_reg(itv->yuv_info.reg_2924, 0x02924); write_reg(yi->reg_2924, 0x02924);
write_reg(itv->yuv_info.reg_2928, 0x02928); write_reg(yi->reg_2928, 0x02928);
write_reg(itv->yuv_info.reg_292c, 0x0292c); write_reg(yi->reg_292c, 0x0292c);
write_reg(itv->yuv_info.reg_2930, 0x02930); write_reg(yi->reg_2930, 0x02930);
write_reg(itv->yuv_info.reg_2934, 0x02934); write_reg(yi->reg_2934, 0x02934);
write_reg(itv->yuv_info.reg_2938, 0x02938); write_reg(yi->reg_2938, 0x02938);
write_reg(itv->yuv_info.reg_293c, 0x0293c); write_reg(yi->reg_293c, 0x0293c);
write_reg(itv->yuv_info.reg_2940, 0x02940); write_reg(yi->reg_2940, 0x02940);
write_reg(itv->yuv_info.reg_2944, 0x02944); write_reg(yi->reg_2944, 0x02944);
write_reg(itv->yuv_info.reg_2948, 0x02948); write_reg(yi->reg_2948, 0x02948);
write_reg(itv->yuv_info.reg_294c, 0x0294c); write_reg(yi->reg_294c, 0x0294c);
write_reg(itv->yuv_info.reg_2950, 0x02950); write_reg(yi->reg_2950, 0x02950);
write_reg(itv->yuv_info.reg_2954, 0x02954); write_reg(yi->reg_2954, 0x02954);
write_reg(itv->yuv_info.reg_2958, 0x02958); write_reg(yi->reg_2958, 0x02958);
write_reg(itv->yuv_info.reg_295c, 0x0295c); write_reg(yi->reg_295c, 0x0295c);
write_reg(itv->yuv_info.reg_2960, 0x02960); write_reg(yi->reg_2960, 0x02960);
write_reg(itv->yuv_info.reg_2964, 0x02964); write_reg(yi->reg_2964, 0x02964);
write_reg(itv->yuv_info.reg_2968, 0x02968); write_reg(yi->reg_2968, 0x02968);
write_reg(itv->yuv_info.reg_296c, 0x0296c); write_reg(yi->reg_296c, 0x0296c);
write_reg(itv->yuv_info.reg_2970, 0x02970); write_reg(yi->reg_2970, 0x02970);
/* Prepare to restore filters */ /* Prepare to restore filters */
/* First the horizontal filter */ /* First the horizontal filter */
if ((itv->yuv_info.reg_2834 & 0x0000FFFF) == (itv->yuv_info.reg_2834 >> 16)) { if ((yi->reg_2834 & 0x0000FFFF) == (yi->reg_2834 >> 16)) {
/* An exact size match uses filter 0 */ /* An exact size match uses filter 0 */
h_filter = 0; h_filter = 0;
} } else {
else {
/* Figure out which filter to use */ /* Figure out which filter to use */
h_filter = ((itv->yuv_info.reg_2834 << 16) / (itv->yuv_info.reg_2834 >> 16)) >> 15; h_filter = ((yi->reg_2834 << 16) / (yi->reg_2834 >> 16)) >> 15;
h_filter = (h_filter >> 1) + (h_filter & 1); h_filter = (h_filter >> 1) + (h_filter & 1);
/* Only an exact size match can use filter 0. */ /* Only an exact size match can use filter 0. */
if (h_filter < 1) h_filter = 1; h_filter += !h_filter;
} }
/* Now the vertical filter */ /* Now the vertical filter */
if ((itv->yuv_info.reg_2918 & 0x0000FFFF) == (itv->yuv_info.reg_2918 >> 16)) { if ((yi->reg_2918 & 0x0000FFFF) == (yi->reg_2918 >> 16)) {
/* An exact size match uses filter 0/1 */ /* An exact size match uses filter 0/1 */
v_filter_1 = 0; v_filter_1 = 0;
v_filter_2 = 1; v_filter_2 = 1;
} } else {
else {
/* Figure out which filter to use */ /* Figure out which filter to use */
v_filter_1 = ((itv->yuv_info.reg_2918 << 16) / (itv->yuv_info.reg_2918 >> 16)) >> 15; v_filter_1 = ((yi->reg_2918 << 16) / (yi->reg_2918 >> 16)) >> 15;
v_filter_1 = (v_filter_1 >> 1) + (v_filter_1 & 1); v_filter_1 = (v_filter_1 >> 1) + (v_filter_1 & 1);
/* Only an exact size match can use filter 0 */ /* Only an exact size match can use filter 0 */
if (v_filter_1 == 0) v_filter_1 = 1; v_filter_1 += !v_filter_1;
v_filter_2 = v_filter_1; v_filter_2 = v_filter_1;
} }
/* Now restore the filters */ /* Now restore the filters */
ivtv_yuv_filter (itv,h_filter,v_filter_1,v_filter_2); ivtv_yuv_filter(itv, h_filter, v_filter_1, v_filter_2);
/* and clear a few registers */ /* and clear a few registers */
write_reg(0, 0x02814); write_reg(0, 0x02814);
@ -1223,19 +1229,18 @@ void ivtv_yuv_close(struct ivtv *itv)
write_reg(0, 0x02910); write_reg(0, 0x02910);
/* Release the blanking buffer */ /* Release the blanking buffer */
if (itv->yuv_info.blanking_ptr) { if (yi->blanking_ptr) {
kfree (itv->yuv_info.blanking_ptr); kfree(yi->blanking_ptr);
itv->yuv_info.blanking_ptr = NULL; yi->blanking_ptr = NULL;
pci_unmap_single(itv->dev, itv->yuv_info.blanking_dmaptr, 720*16, PCI_DMA_TODEVICE); pci_unmap_single(itv->dev, yi->blanking_dmaptr, 720*16, PCI_DMA_TODEVICE);
} }
/* Invalidate the old dimension information */ /* Invalidate the old dimension information */
itv->yuv_info.old_frame_info.src_w = 0; yi->old_frame_info.src_w = 0;
itv->yuv_info.old_frame_info.src_h = 0; yi->old_frame_info.src_h = 0;
itv->yuv_info.old_frame_info_args.src_w = 0; yi->old_frame_info_args.src_w = 0;
itv->yuv_info.old_frame_info_args.src_h = 0; yi->old_frame_info_args.src_h = 0;
/* All done. */ /* All done. */
clear_bit(IVTV_F_I_DECODING_YUV, &itv->i_flags); clear_bit(IVTV_F_I_DECODING_YUV, &itv->i_flags);
} }