openkylin
/
linux
mirror of https://gitee.com/openkylin/linux.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

Rename i2f() to int2float(), and make it global so one copy can be removed. 

Remove the copy of i2f() in r600_blit_kms.c
We rename the function to something longer now that it is a global
symbol.  This reduces the likelyhood of unintended clashes later.

This might be a candidate for inclusion inside general drm infrastructure.
However, at the moment only the radeon driver uses it.

Signed-off-by: Steven Fuerst <svfuerst@gmail.com>
This commit is contained in:
Steven Fuerst 2012-08-15 15:07:14 -07:00 committed by Alex Deucher
parent ee93b86be1
commit 7ff64fcaa7
3 changed files with 40 additions and 79 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

66
drivers/gpu/drm/radeon/r600_blit.c
View File

@ -489,7 +489,7 @@ set_default_state(drm_radeon_private_t *dev_priv)
ADVANCE_RING(); ADVANCE_RING();
} }
static uint32_t i2f(uint32_t input) uint32_t int2float(uint32_t input)
{ {
u32 result, i, exponent, fraction; u32 result, i, exponent, fraction;
@ -632,20 +632,20 @@ r600_blit_copy(struct drm_device *dev,
vb = r600_nomm_get_vb_ptr(dev); vb = r600_nomm_get_vb_ptr(dev);
} }
vb[0] = i2f(dst_x); vb[0] = int2float(dst_x);
vb[1] = 0; vb[1] = 0;
vb[2] = i2f(src_x); vb[2] = int2float(src_x);
vb[3] = 0; vb[3] = 0;
vb[4] = i2f(dst_x); vb[4] = int2float(dst_x);
vb[5] = i2f(h); vb[5] = int2float(h);
vb[6] = i2f(src_x); vb[6] = int2float(src_x);
vb[7] = i2f(h); vb[7] = int2float(h);
vb[8] = i2f(dst_x + cur_size); vb[8] = int2float(dst_x + cur_size);
vb[9] = i2f(h); vb[9] = int2float(h);
vb[10] = i2f(src_x + cur_size); vb[10] = int2float(src_x + cur_size);
vb[11] = i2f(h); vb[11] = int2float(h);
/* src */ /* src */
set_tex_resource(dev_priv, FMT_8, set_tex_resource(dev_priv, FMT_8,
@ -721,20 +721,20 @@ r600_blit_copy(struct drm_device *dev,
vb = r600_nomm_get_vb_ptr(dev); vb = r600_nomm_get_vb_ptr(dev);
} }
vb[0] = i2f(dst_x / 4); vb[0] = int2float(dst_x / 4);
vb[1] = 0; vb[1] = 0;
vb[2] = i2f(src_x / 4); vb[2] = int2float(src_x / 4);
vb[3] = 0; vb[3] = 0;
vb[4] = i2f(dst_x / 4); vb[4] = int2float(dst_x / 4);
vb[5] = i2f(h); vb[5] = int2float(h);
vb[6] = i2f(src_x / 4); vb[6] = int2float(src_x / 4);
vb[7] = i2f(h); vb[7] = int2float(h);
vb[8] = i2f((dst_x + cur_size) / 4); vb[8] = int2float((dst_x + cur_size) / 4);
vb[9] = i2f(h); vb[9] = int2float(h);
vb[10] = i2f((src_x + cur_size) / 4); vb[10] = int2float((src_x + cur_size) / 4);
vb[11] = i2f(h); vb[11] = int2float(h);
/* src */ /* src */
set_tex_resource(dev_priv, FMT_8_8_8_8, set_tex_resource(dev_priv, FMT_8_8_8_8,
@ -804,20 +804,20 @@ r600_blit_swap(struct drm_device *dev,
dx2 = dx + w; dx2 = dx + w;
dy2 = dy + h; dy2 = dy + h;
vb[0] = i2f(dx); vb[0] = int2float(dx);
vb[1] = i2f(dy); vb[1] = int2float(dy);
vb[2] = i2f(sx); vb[2] = int2float(sx);
vb[3] = i2f(sy); vb[3] = int2float(sy);
vb[4] = i2f(dx); vb[4] = int2float(dx);
vb[5] = i2f(dy2); vb[5] = int2float(dy2);
vb[6] = i2f(sx); vb[6] = int2float(sx);
vb[7] = i2f(sy2); vb[7] = int2float(sy2);
vb[8] = i2f(dx2); vb[8] = int2float(dx2);
vb[9] = i2f(dy2); vb[9] = int2float(dy2);
vb[10] = i2f(sx2); vb[10] = int2float(sx2);
vb[11] = i2f(sy2); vb[11] = int2float(sy2);
switch(cpp) { switch(cpp) {
case 4: case 4:

52
drivers/gpu/drm/radeon/r600_blit_kms.c
View File

@ -455,46 +455,6 @@ set_default_state(struct radeon_device *rdev)
radeon_ring_write(ring, sq_stack_resource_mgmt_2); radeon_ring_write(ring, sq_stack_resource_mgmt_2);
} }
#define I2F_MAX_BITS 15
#define I2F_MAX_INPUT ((1 << I2F_MAX_BITS) - 1)
#define I2F_SHIFT (24 - I2F_MAX_BITS)
/*
* Converts unsigned integer into 32-bit IEEE floating point representation.
* Conversion is not universal and only works for the range from 0
* to 2^I2F_MAX_BITS-1. Currently we only use it with inputs between
* 0 and 16384 (inclusive), so I2F_MAX_BITS=15 is enough. If necessary,
* I2F_MAX_BITS can be increased, but that will add to the loop iterations
* and slow us down. Conversion is done by shifting the input and counting
* down until the first 1 reaches bit position 23. The resulting counter
* and the shifted input are, respectively, the exponent and the fraction.
* The sign is always zero.
*/
static uint32_t i2f(uint32_t input)
{
u32 result, i, exponent, fraction;
WARN_ON_ONCE(input > I2F_MAX_INPUT);
if ((input & I2F_MAX_INPUT) == 0)
result = 0;
else {
exponent = 126 + I2F_MAX_BITS;
fraction = (input & I2F_MAX_INPUT) << I2F_SHIFT;
for (i = 0; i < I2F_MAX_BITS; i++) {
if (fraction & 0x800000)
break;
else {
fraction = fraction << 1;
exponent = exponent - 1;
}
}
result = exponent << 23 | (fraction & 0x7fffff);
}
return result;
}
int r600_blit_init(struct radeon_device *rdev) int r600_blit_init(struct radeon_device *rdev)
{ {
u32 obj_size; u32 obj_size;
@ -766,14 +726,14 @@ void r600_kms_blit_copy(struct radeon_device *rdev,
vb_cpu_addr[3] = 0; vb_cpu_addr[3] = 0;
vb_cpu_addr[4] = 0; vb_cpu_addr[4] = 0;
vb_cpu_addr[5] = i2f(h); vb_cpu_addr[5] = int2float(h);
vb_cpu_addr[6] = 0; vb_cpu_addr[6] = 0;
vb_cpu_addr[7] = i2f(h); vb_cpu_addr[7] = int2float(h);
vb_cpu_addr[8] = i2f(w); vb_cpu_addr[8] = int2float(w);
vb_cpu_addr[9] = i2f(h); vb_cpu_addr[9] = int2float(h);
vb_cpu_addr[10] = i2f(w); vb_cpu_addr[10] = int2float(w);
vb_cpu_addr[11] = i2f(h); vb_cpu_addr[11] = int2float(h);
rdev->r600_blit.primitives.set_tex_resource(rdev, FMT_8_8_8_8, rdev->r600_blit.primitives.set_tex_resource(rdev, FMT_8_8_8_8,
w, h, w, src_gpu_addr, size_in_bytes); w, h, w, src_gpu_addr, size_in_bytes);

1
drivers/gpu/drm/radeon/r600_blit_shaders.h
View File

@ -35,4 +35,5 @@ extern const u32 r6xx_default_state[];
extern const u32 r6xx_ps_size, r6xx_vs_size; extern const u32 r6xx_ps_size, r6xx_vs_size;
extern const u32 r6xx_default_size, r7xx_default_size; extern const u32 r6xx_default_size, r7xx_default_size;
uint32_t int2float(uint32_t x);
#endif #endif