Skip to content

L
linux
Commit 2b057e8d authored by Ian Armstrong's avatar Ian Armstrong Committed by Mauro Carvalho Chehab
Browse files
Options

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

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: default avatarIan Armstrong <ian@iarmst.demon.co.uk>
Signed-off-by: default avatarHans Verkuil <hverkuil@xs4all.nl>
Signed-off-by: default avatarMauro Carvalho Chehab <mchehab@infradead.org>
parent 368f080b
Show whitespace changes
Inline Side-by-side
Showing with 320 additions and 315 deletions
drivers/media/video/ivtv/ivtv-yuv.c
View file @ 2b057e8d
......@@ -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];
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)
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 */
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);
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;
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);
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);
/* 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 (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].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->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. */
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) {
if ((read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + offset_y) != i << 16) ||
(read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + offset_uv) != i << 16)) {
for (i = 0, y = 16, uv = 4; i < 16; i++, y += 24, uv += 12) {
if ((read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + y) != i << 16) ||
(read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + uv) != i << 16)) {
IVTV_WARN ("YUV filter table not found in firmware.\n");
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)
{
int filter_index, filter_line;
u32 i, line;
/* If any filter is -1, then don't update it */
if (h_filter > -1) {
if (h_filter > 4) h_filter = 4;
filter_index = h_filter * 384;
filter_line = 0;
while (filter_line < 16) {
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02804);
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x0281c);
filter_index += 4;
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02808);
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02820);
filter_index += 4;
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x0280c);
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02824);
filter_index += 4;
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02810);
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02828);
filter_index += 4;
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x02814);
write_reg(read_dec(IVTV_YUV_HORIZONTAL_FILTER_OFFSET + filter_index), 0x0282c);
filter_index += 8;
if (h_filter > 4)
h_filter = 4;
i = IVTV_YUV_HORIZONTAL_FILTER_OFFSET + (h_filter * 384);
for (line = 0; line < 16; line++) {
write_reg(read_dec(i), 0x02804);
write_reg(read_dec(i), 0x0281c);
i += 4;
write_reg(read_dec(i), 0x02808);
write_reg(read_dec(i), 0x02820);
i += 4;
write_reg(read_dec(i), 0x0280c);
write_reg(read_dec(i), 0x02824);
i += 4;
write_reg(read_dec(i), 0x02810);
write_reg(read_dec(i), 0x02828);
i += 4;
write_reg(read_dec(i), 0x02814);
write_reg(read_dec(i), 0x0282c);
i += 8;
write_reg(0, 0x02818);
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 > 4) v_filter_1 = 4;
filter_index = v_filter_1 * 192;
filter_line = 0;
while (filter_line < 16) {
write_reg(read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + filter_index), 0x02900);
filter_index += 4;
write_reg(read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + filter_index), 0x02904);
filter_index += 8;
if (v_filter_1 > 4)
v_filter_1 = 4;
i = IVTV_YUV_VERTICAL_FILTER_OFFSET + (v_filter_1 * 192);
for (line = 0; line < 16; line++) {
write_reg(read_dec(i), 0x02900);
i += 4;
write_reg(read_dec(i), 0x02904);
i += 8;
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 > 4) v_filter_2 = 4;
filter_index = v_filter_2 * 192;
filter_line = 0;
while (filter_line < 16) {
write_reg(read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + filter_index), 0x0290c);
filter_index += 4;
write_reg(read_dec(IVTV_YUV_VERTICAL_FILTER_OFFSET + filter_index), 0x02910);
filter_index += 8;
if (v_filter_2 > 4)
v_filter_2 = 4;
i = IVTV_YUV_VERTICAL_FILTER_OFFSET + (v_filter_2 * 192);
for (line = 0; line < 16; line++) {
write_reg(read_dec(i), 0x0290c);
i += 4;
write_reg(read_dec(i), 0x02910);
i += 8;
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_2844, reg_2854, reg_285c;
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;
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",
window->tru_w, window->src_w, window->dst_w,window->src_x, window->dst_x);
IVTV_DEBUG_WARN
("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 */
x_cutoff = window->src_w + window->src_x;
x_cutoff = f->src_w + f->src_x;
/* Set the display width */
reg_2834 = window->dst_w;
reg_2834 = f->dst_w;
reg_2838 = reg_2834;
/* Set the display position */
reg_2890 = window->dst_x;
reg_2890 = f->dst_x;
/* Index into the image horizontally */
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'
left/right if it gets dragged through this region.
Only do this if osd is full width. */
if (window->vis_w == 720) {
if ((window->tru_x - window->pan_x > -1) && (window->tru_x - window->pan_x <= 40) && (window->dst_w >= 680)){
reg_2870 = 10 - (window->tru_x - window->pan_x) / 4;
}
else if ((window->tru_x - window->pan_x < 0) && (window->tru_x - window->pan_x >= -20) && (window->dst_w >= 660)) {
reg_2870 = (10 + (window->tru_x - window->pan_x) / 2);
}
if (f->vis_w == 720) {
if ((f->tru_x - f->pan_x > -1) && (f->tru_x - f->pan_x <= 40) && (f->dst_w >= 680))
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))
reg_2870 = (10 + (f->tru_x - f->pan_x) / 2);
if (window->dst_w >= window->src_w)
if (f->dst_w >= f->src_w)
reg_2870 = reg_2870 << 16 | reg_2870;
else
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;
else
reg_2870 = 0x0012000e - reg_2870;
/* 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;
master_width = (window->src_w * 0x00200000) / (window->dst_w);
if (master_width * window->dst_w != window->src_w * 0x00200000) master_width ++;
master_width = (f->src_w * 0x00200000) / (f->dst_w);
if (master_width * f->dst_w != f->src_w * 0x00200000)
master_width++;
reg_2834 = (reg_2834 << 16) | x_cutoff;
reg_2838 = (reg_2838 << 16) | x_cutoff;
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
(src_w - dst_w) / (src_w / 4) */
if (window->dst_w > window->src_w)
reg_2870_base = ((window->dst_w - window->src_w)<<16) / (window->src_w <<14);
if (f->dst_w > f->src_w)
reg_2870_base = ((f->dst_w - f->src_w)<<16) / (f->src_w <<14);
else
reg_2870_base = 0;
reg_2870 += (((reg_2870_offset << 14) & 0xFFFF0000) | reg_2870_offset >> 2) + (reg_2870_base << 17 | reg_2870_base);
reg_2874 = 0;
}
else if (window->dst_w < window->src_w / 2) {
master_width = (window->src_w * 0x00080000) / window->dst_w;
if (master_width * window->dst_w != window->src_w * 0x00080000) master_width ++;
} else if (f->dst_w < f->src_w / 2) {
master_width = (f->src_w * 0x00080000) / f->dst_w;
if (master_width * f->dst_w != f->src_w * 0x00080000)
master_width++;
reg_2834 = (reg_2834 << 16) | x_cutoff;
reg_2838 = (reg_2838 << 16) | x_cutoff;
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_285c = master_width >> 1;
reg_2864 = master_width >> 1;
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 += ((reg_2870_offset << 15) & 0xFFFF0000) | reg_2870_offset;
reg_2870 += (5 - (((f->src_w + f->src_w / 2) - 1) / f->dst_w)) << 16;
reg_2874 = 0x00000012;
}
else {
master_width = (window->src_w * 0x00100000) / window->dst_w;
if (master_width * window->dst_w != window->src_w * 0x00100000) master_width ++;
} else {
master_width = (f->src_w * 0x00100000) / f->dst_w;
if (master_width * f->dst_w != f->src_w * 0x00100000)
master_width++;
reg_2834 = (reg_2834 << 16) | x_cutoff;
reg_2838 = (reg_2838 << 16) | x_cutoff;
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_285c = master_width >> 1;
reg_2864 = master_width >> 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 += ((reg_2870_offset << 14) & 0xFFFF0000) | reg_2870_offset >> 1;
reg_2870 += (5 - (((f->src_w * 3) - 1) / f->dst_w)) << 16;
reg_2874 = 0x00000001;
}
/* 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 */
h_filter = 0;
}
else {
} else {
/* 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);
/* 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_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_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(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);
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_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);
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);
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);
IVTV_DEBUG_YUV("Update reg 0x2890 %08x->%08x\n",itv->yuv_info.reg_2890, reg_2890);
write_reg(reg_2890, 0x02890);
IVTV_DEBUG_YUV("Update reg 0x2890 %08x->%08x\n",
yi->reg_2890, reg_2890);
/* Only update the filter if we really need to */
if (h_filter != itv->yuv_info.h_filter) {
ivtv_yuv_filter (itv,h_filter,-1,-1);
itv->yuv_info.h_filter = h_filter;
if (h_filter != yi->h_filter) {
ivtv_yuv_filter(itv, h_filter, -1, -1);
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 reg_2918, reg_291c, reg_2920, reg_2928;
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_2960, reg_2964, reg_2968, reg_296c;
u32 reg_289c;
u32 src_y_major_y, src_y_minor_y;
u32 src_y_major_uv, src_y_minor_uv;
u32 src_major_y, src_minor_y;
u32 src_major_uv, src_minor_uv;
u32 reg_2964_base, reg_2968_base;
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",
window->tru_h, window->src_h, window->dst_h,window->src_y, window->dst_y);
IVTV_DEBUG_WARN
("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... */
if (window->interlaced_y) {
IVTV_DEBUG_YUV("Scaling mode Y: Interlaced\n");
}
else {
IVTV_DEBUG_YUV("Scaling mode Y: Progressive\n");
}
IVTV_DEBUG_YUV("Scaling mode Y: %s\n",
f->interlaced_y ? "Interlaced" : "Progressive");
if (window->interlaced_uv) {
IVTV_DEBUG_YUV("Scaling mode UV: Interlaced\n");
}
else {
IVTV_DEBUG_YUV("Scaling mode UV: Progressive\n");
}
IVTV_DEBUG_YUV("Scaling mode UV: %s\n",
f->interlaced_uv ? "Interlaced" : "Progressive");
/* What is the source video being treated as... */
if (window->interlaced) {
IVTV_DEBUG_WARN("Source video: Interlaced\n");
}
else {
IVTV_DEBUG_WARN("Source video: Non-interlaced\n");
}
IVTV_DEBUG_WARN("Source video: %s\n",
f->interlaced ? "Interlaced" : "Progressive");
/* We offset into the image using two different index methods, so split
the y source coord into two parts. */
if (window->src_y < 8) {
src_y_minor_uv = window->src_y;
src_y_major_uv = 0;
}
else {
src_y_minor_uv = 8;
src_y_major_uv = window->src_y - 8;
if (f->src_y < 8) {
src_minor_uv = f->src_y;
src_major_uv = 0;
} else {
src_minor_uv = 8;
src_major_uv = f->src_y - 8;
}
src_y_minor_y = src_y_minor_uv;
src_y_major_y = src_y_major_uv;
src_minor_y = src_minor_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)
reg_2918 = (window->dst_h << 16) | (window->src_h + src_y_minor_y);
if (f->interlaced_y)
reg_2918 = (f->dst_h << 16) | (f->src_h + src_minor_y);
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)
reg_291c = (window->dst_h << 16) | ((window->src_h + src_y_minor_uv) >> 1);
if (f->interlaced_uv)
reg_291c = (f->dst_h << 16) | ((f->src_h + src_minor_uv) >> 1);
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_2968_base = (src_y_minor_uv * ((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_minor_uv * ((f->dst_h << 16) / f->src_h)) >> 14;
if (window->dst_h / 2 >= window->src_h && !window->interlaced_y) {
master_height = (window->src_h * 0x00400000) / window->dst_h;
if ((window->src_h * 0x00400000) - (master_height * window->dst_h) >= window->dst_h / 2) master_height ++;
if (f->dst_h / 2 >= f->src_h && !f->interlaced_y) {
master_height = (f->src_h * 0x00400000) / f->dst_h;
if ((f->src_h * 0x00400000) - (master_height * f->dst_h) >= f->dst_h / 2)
master_height++;
reg_2920 = master_height >> 2;
reg_2928 = master_height >> 3;
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_2968_base >>= 3;
reg_296c = 0x00000000;
}
else if (window->dst_h >= window->src_h) {
master_height = (window->src_h * 0x00400000) / window->dst_h;
} else if (f->dst_h >= f->src_h) {
master_height = (f->src_h * 0x00400000) / f->dst_h;
master_height = (master_height >> 1) + (master_height & 1);
reg_2920 = master_height >> 2;
reg_2928 = master_height >> 2;
reg_2930 = master_height;
reg_2940 = master_height >> 1;
reg_296c = 0x00000000;
if (window->interlaced_y) {
if (f->interlaced_y) {
reg_2964_base >>= 3;
}
else {
reg_296c ++;
} else {
reg_296c++;
reg_2964_base >>= 2;
}
if (window->interlaced_uv) reg_2928 >>= 1;
if (f->interlaced_uv)
reg_2928 >>= 1;
reg_2968_base >>= 3;
}
else if (window->dst_h >= window->src_h / 2) {
master_height = (window->src_h * 0x00200000) / window->dst_h;
} else if (f->dst_h >= f->src_h / 2) {
master_height = (f->src_h * 0x00200000) / f->dst_h;
master_height = (master_height >> 1) + (master_height & 1);
reg_2920 = master_height >> 2;
reg_2928 = master_height >> 2;
reg_2930 = master_height;
reg_2940 = master_height;
reg_296c = 0x00000101;
if (window->interlaced_y) {
if (f->interlaced_y) {
reg_2964_base >>= 2;
}
else {
reg_296c ++;
} else {
reg_296c++;
reg_2964_base >>= 1;
}
if (window->interlaced_uv) reg_2928 >>= 1;
if (f->interlaced_uv)
reg_2928 >>= 1;
reg_2968_base >>= 2;
}
else {
master_height = (window->src_h * 0x00100000) / window->dst_h;
} else {
master_height = (f->src_h * 0x00100000) / f->dst_h;
master_height = (master_height >> 1) + (master_height & 1);
reg_2920 = 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
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_293c = 0x00100000;
reg_2944 = 0x00040000;
reg_294c = 0x000b0000;
}
else {
} else {
reg_2934 = 0x00000FF0;
reg_293c = 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 */
reg_2950 = 0x00010000 + src_y_major_y;
if (window->interlaced_y) reg_2950 += 0x00010000;
reg_2950 = 0x00010000 + src_major_y;
if (f->interlaced_y)
reg_2950 += 0x00010000;
reg_2954 = reg_2950 + 1;
reg_2958 = 0x00010000 + (src_y_major_y >> 1);
if (window->interlaced_uv) reg_2958 += 0x00010000;
reg_2958 = 0x00010000 + (src_major_y >> 1);
if (f->interlaced_uv)
reg_2958 += 0x00010000;
reg_295c = reg_2958 + 1;
if (itv->yuv_info.decode_height == 480)
if (yi->decode_height == 480)
reg_289c = 0x011e0017;
else
reg_289c = 0x01500017;
if (window->dst_y < 0)
reg_289c = (reg_289c - ((window->dst_y & ~1)<<15))-(window->dst_y >>1);
if (f->dst_y < 0)
reg_289c = (reg_289c - ((f->dst_y & ~1)<<15))-(f->dst_y >>1);
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.
Take into account the source offset */
reg_2960 = ((src_y_minor_y + window->src_h + src_y_major_y) - 1 ) |
((((src_y_minor_uv + window->src_h + src_y_major_uv) - 1) & ~1) << 15);
reg_2960 = ((src_minor_y + f->src_h + src_major_y) - 1) |
(((src_minor_uv + f->src_h + src_major_uv - 1) & ~1) << 15);
/* Calculate correct value for register 2964 */
if (window->src_h == window->dst_h)
if (f->src_h == f->dst_h) {
reg_2964 = 1;
else {
reg_2964 = 2 + ((window->dst_h << 1) / window->src_h);
} else {
reg_2964 = 2 + ((f->dst_h << 1) / f->src_h);
reg_2964 = (reg_2964 >> 1) + (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
inducing so try to reduce it slightly. Leave 2968 as-is otherwise
colours foul. */
if ((reg_2964 != 0x00010001) && (window->dst_h / 2 <= window->src_h))
reg_2964 = (reg_2964 & 0xFFFF0000) + ((reg_2964 & 0x0000FFFF)/2);
if ((reg_2964 != 0x00010001) && (f->dst_h / 2 <= f->src_h))
reg_2964 = (reg_2964 & 0xFFFF0000) + ((reg_2964 & 0x0000FFFF) / 2);
if (!window->interlaced_y) reg_2964 -= 0x00010001;
if (!window->interlaced_uv) reg_2968 -= 0x00010001;
if (!f->interlaced_y)
reg_2964 -= 0x00010001;
if (!f->interlaced_uv)
reg_2968 -= 0x00010001;
reg_2964 += ((reg_2964_base << 16) | reg_2964_base);
reg_2968 += ((reg_2968_base << 16) | reg_2968_base);
/* 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 */
v_filter_1 = 0;
v_filter_2 = 1;
}
else {
} else {
/* 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);
/* 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;
}
write_reg(reg_2934, 0x02934);
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_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 ?) */
/* 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, 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+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);
write_reg(reg_2928 + 0x514, 0x0292C);
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+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);
write_reg(reg_2920 + 0x514, 0x02924);
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_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);
write_reg(reg_2918, 0x02918);
write_reg(reg_291c, 0x0291C);
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);
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, 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_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_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);
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_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);
IVTV_DEBUG_YUV("Update reg 0x289c %08x->%08x\n",itv->yuv_info.reg_289c, reg_289c);
write_reg(reg_289c, 0x0289c);
IVTV_DEBUG_YUV("Update reg 0x289c %08x->%08x\n",
yi->reg_289c, reg_289c);
/* Only update filter 1 if we really need to */
if (v_filter_1 != itv->yuv_info.v_filter_1) {
ivtv_yuv_filter (itv,-1,v_filter_1,-1);
itv->yuv_info.v_filter_1 = v_filter_1;
if (v_filter_1 != yi->v_filter_1) {
ivtv_yuv_filter(itv, -1, v_filter_1, -1);
yi->v_filter_1 = v_filter_1;
}
/* Only update filter 2 if we really need to */
if (v_filter_2 != itv->yuv_info.v_filter_2) {
ivtv_yuv_filter (itv,-1,-1,v_filter_2);
itv->yuv_info.v_filter_2 = v_filter_2;
if (v_filter_2 != yi->v_filter_2) {
ivtv_yuv_filter(itv, -1, -1, v_filter_2);
yi->v_filter_2 = v_filter_2;
}
}
/* 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 */
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_frame_info f;
int frame = yi->update_frame;
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];
/* Update the osd pan info */
f.pan_x = itv->yuv_info.osd_x_pan;
f.pan_y = itv->yuv_info.osd_y_pan;
f.vis_w = itv->yuv_info.osd_vis_w;
f.vis_h = itv->yuv_info.osd_vis_h;
f.pan_x = yi->osd_x_pan;
f.pan_y = yi->osd_y_pan;
f.vis_w = yi->osd_vis_w;
f.vis_h = yi->osd_vis_h;
/* 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;
if (yuv_update & IVTV_YUV_UPDATE_INVALID) {
......@@ -807,7 +816,7 @@ void ivtv_yuv_work_handler (struct ivtv *itv)
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;
......@@ -876,25 +885,23 @@ static void ivtv_yuv_init (struct ivtv *itv)
if (!yi->osd_vis_w)
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;
else {
} else if (yi->osd_vis_h + yi->osd_y_offset > yi->decode_height) {
/* If output video standard has changed, requested height may
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",
yi->osd_vis_h + yi->osd_y_offset,
yi->decode_height);
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 */
yi->blanking_ptr = kzalloc(720*16, GFP_KERNEL);
if (yi->blanking_ptr)
yi->blanking_ptr = kzalloc(720 * 16, GFP_KERNEL);
if (yi->blanking_ptr) {
yi->blanking_dmaptr = pci_map_single(itv->dev, yi->blanking_ptr, 720*16, PCI_DMA_TODEVICE);
else {
} else {
yi->blanking_dmaptr = 0;
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))) {
yi->old_frame_info_args = *nf;
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;
......@@ -1121,7 +1128,7 @@ int ivtv_yuv_udma_stream_frame(struct ivtv *itv, void *src)
/* IVTV_IOC_DMA_FRAME ioctl handler */
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_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)
{
struct yuv_playback_info *yi = &itv->yuv_info;
int h_filter, v_filter_1, v_filter_2;
IVTV_DEBUG_YUV("ivtv_yuv_close\n");
ivtv_waitq(&itv->vsync_waitq);
atomic_set(&itv->yuv_info.next_dma_frame, -1);
atomic_set(&itv->yuv_info.next_fill_frame, 0);
atomic_set(&yi->next_dma_frame, -1);
atomic_set(&yi->next_fill_frame, 0);
/* Reset registers we have changed so mpeg playback works */
/* If we fully restore this register, the display may remain active.
Restore, but set one bit to blank the video. Firmware will always
clear this bit when needed, so not a problem. */
write_reg(itv->yuv_info.reg_2898 | 0x01000000, 0x2898);
write_reg(itv->yuv_info.reg_2834, 0x02834);
write_reg(itv->yuv_info.reg_2838, 0x02838);
write_reg(itv->yuv_info.reg_283c, 0x0283c);
write_reg(itv->yuv_info.reg_2840, 0x02840);
write_reg(itv->yuv_info.reg_2844, 0x02844);
write_reg(itv->yuv_info.reg_2848, 0x02848);
write_reg(itv->yuv_info.reg_2854, 0x02854);
write_reg(itv->yuv_info.reg_285c, 0x0285c);
write_reg(itv->yuv_info.reg_2864, 0x02864);
write_reg(itv->yuv_info.reg_2870, 0x02870);
write_reg(itv->yuv_info.reg_2874, 0x02874);
write_reg(itv->yuv_info.reg_2890, 0x02890);
write_reg(itv->yuv_info.reg_289c, 0x0289c);
write_reg(itv->yuv_info.reg_2918, 0x02918);
write_reg(itv->yuv_info.reg_291c, 0x0291c);
write_reg(itv->yuv_info.reg_2920, 0x02920);
write_reg(itv->yuv_info.reg_2924, 0x02924);
write_reg(itv->yuv_info.reg_2928, 0x02928);
write_reg(itv->yuv_info.reg_292c, 0x0292c);
write_reg(itv->yuv_info.reg_2930, 0x02930);
write_reg(itv->yuv_info.reg_2934, 0x02934);
write_reg(itv->yuv_info.reg_2938, 0x02938);
write_reg(itv->yuv_info.reg_293c, 0x0293c);
write_reg(itv->yuv_info.reg_2940, 0x02940);
write_reg(itv->yuv_info.reg_2944, 0x02944);
write_reg(itv->yuv_info.reg_2948, 0x02948);
write_reg(itv->yuv_info.reg_294c, 0x0294c);
write_reg(itv->yuv_info.reg_2950, 0x02950);
write_reg(itv->yuv_info.reg_2954, 0x02954);
write_reg(itv->yuv_info.reg_2958, 0x02958);
write_reg(itv->yuv_info.reg_295c, 0x0295c);
write_reg(itv->yuv_info.reg_2960, 0x02960);
write_reg(itv->yuv_info.reg_2964, 0x02964);
write_reg(itv->yuv_info.reg_2968, 0x02968);
write_reg(itv->yuv_info.reg_296c, 0x0296c);
write_reg(itv->yuv_info.reg_2970, 0x02970);
write_reg(yi->reg_2898 | 0x01000000, 0x2898);
write_reg(yi->reg_2834, 0x02834);
write_reg(yi->reg_2838, 0x02838);
write_reg(yi->reg_283c, 0x0283c);
write_reg(yi->reg_2840, 0x02840);
write_reg(yi->reg_2844, 0x02844);
write_reg(yi->reg_2848, 0x02848);
write_reg(yi->reg_2854, 0x02854);
write_reg(yi->reg_285c, 0x0285c);
write_reg(yi->reg_2864, 0x02864);
write_reg(yi->reg_2870, 0x02870);
write_reg(yi->reg_2874, 0x02874);
write_reg(yi->reg_2890, 0x02890);
write_reg(yi->reg_289c, 0x0289c);
write_reg(yi->reg_2918, 0x02918);
write_reg(yi->reg_291c, 0x0291c);
write_reg(yi->reg_2920, 0x02920);
write_reg(yi->reg_2924, 0x02924);
write_reg(yi->reg_2928, 0x02928);
write_reg(yi->reg_292c, 0x0292c);
write_reg(yi->reg_2930, 0x02930);
write_reg(yi->reg_2934, 0x02934);
write_reg(yi->reg_2938, 0x02938);
write_reg(yi->reg_293c, 0x0293c);
write_reg(yi->reg_2940, 0x02940);
write_reg(yi->reg_2944, 0x02944);
write_reg(yi->reg_2948, 0x02948);
write_reg(yi->reg_294c, 0x0294c);
write_reg(yi->reg_2950, 0x02950);
write_reg(yi->reg_2954, 0x02954);
write_reg(yi->reg_2958, 0x02958);
write_reg(yi->reg_295c, 0x0295c);
write_reg(yi->reg_2960, 0x02960);
write_reg(yi->reg_2964, 0x02964);
write_reg(yi->reg_2968, 0x02968);
write_reg(yi->reg_296c, 0x0296c);
write_reg(yi->reg_2970, 0x02970);
/* Prepare to restore filters */
/* 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 */
h_filter = 0;
}
else {
} else {
/* 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);
/* Only an exact size match can use filter 0. */
if (h_filter < 1) h_filter = 1;
h_filter += !h_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 */
v_filter_1 = 0;
v_filter_2 = 1;
}
else {
} else {
/* 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);
/* 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;
}
/* 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 */
write_reg(0, 0x02814);
......@@ -1223,19 +1229,18 @@ void ivtv_yuv_close(struct ivtv *itv)
write_reg(0, 0x02910);
/* Release the blanking buffer */
if (itv->yuv_info.blanking_ptr) {
kfree (itv->yuv_info.blanking_ptr);
itv->yuv_info.blanking_ptr = NULL;
pci_unmap_single(itv->dev, itv->yuv_info.blanking_dmaptr, 720*16, PCI_DMA_TODEVICE);
if (yi->blanking_ptr) {
kfree(yi->blanking_ptr);
yi->blanking_ptr = NULL;
pci_unmap_single(itv->dev, yi->blanking_dmaptr, 720*16, PCI_DMA_TODEVICE);
}
/* Invalidate the old dimension information */
itv->yuv_info.old_frame_info.src_w = 0;
itv->yuv_info.old_frame_info.src_h = 0;
itv->yuv_info.old_frame_info_args.src_w = 0;
itv->yuv_info.old_frame_info_args.src_h = 0;
yi->old_frame_info.src_w = 0;
yi->old_frame_info.src_h = 0;
yi->old_frame_info_args.src_w = 0;
yi->old_frame_info_args.src_h = 0;
/* All done. */
clear_bit(IVTV_F_I_DECODING_YUV, &itv->i_flags);
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7