#include "intel_buffers.h"
#include "intel_fbo.h"
#include "intel_reg.h"
-#include "intel_regions.h"
#include "intel_batchbuffer.h"
#include "intel_mipmap_tree.h"
return BR13_8;
break;
default:
- assert(0);
- return 0;
+ unreachable("not reached");
}
}
* pitches < 32k.
*
* As a result of these two limitations, we can only use the blitter to do
- * this copy when the region's pitch is less than 32k.
+ * this copy when the miptree's pitch is less than 32k.
*/
- if (src_mt->region->pitch >= 32768 ||
- dst_mt->region->pitch >= 32768) {
+ if (src_mt->pitch >= 32768 ||
+ dst_mt->pitch >= 32768) {
perf_debug("Falling back due to >=32k pitch\n");
return false;
}
if (dst_flip)
dst_y = minify(dst_mt->physical_height0, dst_level - dst_mt->first_level) - dst_y - height;
- int src_pitch = src_mt->region->pitch;
+ int src_pitch = src_mt->pitch;
if (src_flip != dst_flip)
src_pitch = -src_pitch;
- uint32_t src_image_x, src_image_y;
+ uint32_t src_image_x, src_image_y, dst_image_x, dst_image_y;
intel_miptree_get_image_offset(src_mt, src_level, src_slice,
&src_image_x, &src_image_y);
- src_x += src_image_x;
- src_y += src_image_y;
-
- /* The blitter interprets the 16-bit src x/y as a signed 16-bit value,
- * where negative values are invalid. The values we're working with are
- * unsigned, so make sure we don't overflow.
- */
- if (src_x >= 32768 || src_y >= 32768) {
- perf_debug("Falling back due to >=32k src offset (%d, %d)\n",
- src_x, src_y);
- return false;
- }
-
- uint32_t dst_image_x, dst_image_y;
intel_miptree_get_image_offset(dst_mt, dst_level, dst_slice,
&dst_image_x, &dst_image_y);
+ src_x += src_image_x;
+ src_y += src_image_y;
dst_x += dst_image_x;
dst_y += dst_image_y;
/* The blitter interprets the 16-bit destination x/y as a signed 16-bit
- * value. The values we're working with are unsigned, so make sure we
- * don't overflow.
+ * value. The values we're working with are unsigned, so make sure we don't
+ * overflow.
*/
- if (dst_x >= 32768 || dst_y >= 32768) {
- perf_debug("Falling back due to >=32k dst offset (%d, %d)\n",
- dst_x, dst_y);
+ if (src_x >= 32768 || src_y >= 32768 || dst_x >= 32768 || dst_y >= 32768) {
+ perf_debug("Falling back due to >=32k offset [src(%d, %d) dst(%d, %d)]\n",
+ src_x, src_y, dst_x, dst_y);
return false;
}
if (!intelEmitCopyBlit(brw,
src_mt->cpp,
src_pitch,
- src_mt->region->bo, src_mt->offset,
- src_mt->region->tiling,
- dst_mt->region->pitch,
- dst_mt->region->bo, dst_mt->offset,
- dst_mt->region->tiling,
+ src_mt->bo, src_mt->offset,
+ src_mt->tiling,
+ dst_mt->pitch,
+ dst_mt->bo, dst_mt->offset,
+ dst_mt->tiling,
src_x, src_y,
dst_x, dst_y,
width, height,
if ((dst_y_tiled || src_y_tiled) && brw->gen < 6)
return false;
+ assert(!dst_y_tiled || (dst_pitch % 128) == 0);
+ assert(!src_y_tiled || (src_pitch % 128) == 0);
+
/* do space check before going any further */
do {
aper_array[0] = brw->batch.bo;
if (pass >= 2)
return false;
- intel_batchbuffer_require_space(brw, 8 * 4, BLT_RING);
+ unsigned length = brw->gen >= 8 ? 10 : 8;
+
+ intel_batchbuffer_require_space(brw, length * 4, BLT_RING);
DBG("%s src:buf(%p)/%d+%d %d,%d dst:buf(%p)/%d+%d %d,%d sz:%dx%d\n",
__FUNCTION__,
src_buffer, src_pitch, src_offset, src_x, src_y,
dst_buffer, dst_pitch, dst_offset, dst_x, dst_y, w, h);
/* Blit pitch must be dword-aligned. Otherwise, the hardware appears to drop
- * the low bits.
+ * the low bits. Offsets must be naturally aligned.
*/
- if (src_pitch % 4 != 0 || dst_pitch % 4 != 0)
+ if (src_pitch % 4 != 0 || src_offset % cpp != 0 ||
+ dst_pitch % 4 != 0 || dst_offset % cpp != 0)
return false;
/* For big formats (such as floating point), do the copy using 16 or 32bpp
assert(dst_offset + (dst_y + h - 1) * abs(dst_pitch) +
(w * cpp) <= dst_buffer->size);
- unsigned length = brw->gen >= 8 ? 10 : 8;
-
BEGIN_BATCH_BLT_TILED(length, dst_y_tiled, src_y_tiled);
OUT_BATCH(CMD | (length - 2));
OUT_BATCH(BR13 | (uint16_t)dst_pitch);
__FUNCTION__,
dst_buffer, dst_pitch, dst_offset, x, y, w, h, src_size, dwords);
- intel_batchbuffer_require_space(brw, (8 * 4) + (3 * 4) + dwords * 4, BLT_RING);
+ unsigned xy_setup_blt_length = brw->gen >= 8 ? 10 : 8;
+ intel_batchbuffer_require_space(brw, (xy_setup_blt_length * 4) +
+ (3 * 4) + dwords * 4, BLT_RING);
opcode = XY_SETUP_BLT_CMD;
if (cpp == 4)
if (dst_tiling != I915_TILING_NONE)
blit_cmd |= XY_DST_TILED;
- unsigned xy_setup_blt_length = brw->gen >= 8 ? 10 : 8;
-
BEGIN_BATCH_BLT(xy_setup_blt_length + 3);
OUT_BATCH(opcode | (xy_setup_blt_length - 2));
OUT_BATCH(br13);
struct intel_mipmap_tree *mt,
int x, int y, int width, int height)
{
- struct intel_region *region = mt->region;
uint32_t BR13, CMD;
int pitch, cpp;
drm_intel_bo *aper_array[2];
- pitch = region->pitch;
- cpp = region->cpp;
+ pitch = mt->pitch;
+ cpp = mt->cpp;
DBG("%s dst:buf(%p)/%d %d,%d sz:%dx%d\n",
- __FUNCTION__, region->bo, pitch, x, y, width, height);
+ __FUNCTION__, mt->bo, pitch, x, y, width, height);
BR13 = br13_for_cpp(cpp) | 0xf0 << 16;
CMD = XY_COLOR_BLT_CMD;
CMD |= XY_BLT_WRITE_ALPHA;
- if (region->tiling != I915_TILING_NONE) {
+ if (mt->tiling != I915_TILING_NONE) {
CMD |= XY_DST_TILED;
pitch /= 4;
}
/* do space check before going any further */
aper_array[0] = brw->batch.bo;
- aper_array[1] = region->bo;
+ aper_array[1] = mt->bo;
if (drm_intel_bufmgr_check_aperture_space(aper_array,
ARRAY_SIZE(aper_array)) != 0) {
}
unsigned length = brw->gen >= 8 ? 7 : 6;
- bool dst_y_tiled = region->tiling == I915_TILING_Y;
+ bool dst_y_tiled = mt->tiling == I915_TILING_Y;
BEGIN_BATCH_BLT_TILED(length, dst_y_tiled, false);
OUT_BATCH(CMD | (length - 2));
OUT_BATCH(SET_FIELD(y, BLT_Y) | SET_FIELD(x, BLT_X));
OUT_BATCH(SET_FIELD(y + height, BLT_Y) | SET_FIELD(x + width, BLT_X));
if (brw->gen >= 8) {
- OUT_RELOC64(region->bo,
+ OUT_RELOC64(mt->bo,
I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER,
0);
} else {
- OUT_RELOC(region->bo,
+ OUT_RELOC(mt->bo,
I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER,
0);
}