path: root/src/radeon.c

/*
 * Copyright © 2009 Jerome Glisse <glisse@freedesktop.org>
 *
 * This file is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
 */
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <errno.h>
#include "xf86drm.h"
#include "radeon_bo_gem.h"
#include "radeon_cs_gem.h"
#include "radeon_priv.h"
#include "r600d.h"

int radeon_get_device(struct radeon *radeon)
{
	struct drm_radeon_info info;
	int r;

	radeon->device = 0;
	info.request = RADEON_INFO_DEVICE_ID;
	info.value = (uintptr_t)&radeon->device;
	r = drmCommandWriteRead(radeon->fd, DRM_RADEON_INFO, &info,
			sizeof(struct drm_radeon_info));
	return r;
}

int radeon_open_fd(void)
{
	return drmOpen("radeon", NULL);
}

struct radeon *radeon_new(int fd, unsigned device)
{
	struct radeon *radeon;
	int r;

	radeon = calloc(1, sizeof(*radeon));
	if (radeon == NULL)
		return NULL;
	radeon->fd = fd;
	radeon->device = device;
	radeon->refcount = 1;
	if (fd >= 0) {
		r = radeon_get_device(radeon);
		if (r) {
			fprintf(stderr, "Failed to get device id\n");
			return radeon_decref(radeon);
		}
	}
	radeon->family = radeon_family_from_device(radeon->device);
	if (radeon->family == CHIP_UNKNOWN) {
		fprintf(stderr, "Unknown chipset 0x%04X\n", radeon->device);
		return radeon_decref(radeon);
	}
	radeon->csm = radeon_cs_manager_gem_ctor(radeon->fd);
	if (radeon->csm == NULL) {
		fprintf(stderr, "Failed to create CS manager\n");
		return radeon_decref(radeon);
	}
	radeon->bom = radeon_bo_manager_gem_ctor(radeon->fd);
	if (radeon->bom == NULL) {
		fprintf(stderr, "Failed to create BO manager\n");
		return radeon_decref(radeon);
	}
	switch (radeon->family) {
	case CHIP_R600:
	case CHIP_RV610:
	case CHIP_RV630:
	case CHIP_RV670:
	case CHIP_RV620:
	case CHIP_RV635:
	case CHIP_RS780:
	case CHIP_RS880:
	case CHIP_RV770:
	case CHIP_RV730:
	case CHIP_RV710:
	case CHIP_RV740:
		if (r600_init(radeon)) {
			return radeon_decref(radeon);
		}
		break;
	case CHIP_R100:
	case CHIP_RV100:
	case CHIP_RS100:
	case CHIP_RV200:
	case CHIP_RS200:
	case CHIP_R200:
	case CHIP_RV250:
	case CHIP_RS300:
	case CHIP_RV280:
	case CHIP_R300:
	case CHIP_R350:
	case CHIP_RV350:
	case CHIP_RV380:
	case CHIP_R420:
	case CHIP_R423:
	case CHIP_RV410:
	case CHIP_RS400:
	case CHIP_RS480:
	case CHIP_RS600:
	case CHIP_RS690:
	case CHIP_RS740:
	case CHIP_RV515:
	case CHIP_R520:
	case CHIP_RV530:
	case CHIP_RV560:
	case CHIP_RV570:
	case CHIP_R580:
	case CHIP_CEDAR:
	case CHIP_REDWOOD:
	case CHIP_JUNIPER:
	case CHIP_CYPRESS:
	case CHIP_HEMLOCK:
	default:
		fprintf(stderr, "%s unknown or unsupported chipset 0x%04X\n",
			__func__, radeon->device);
		break;
	}
	if (radeon->fd >= 0) {
		/* FIXME compile time enable */
		r = radeon_mode_configure(radeon);
		if (r) {
			return radeon_decref(radeon);
		}
	}
	return radeon;
}

struct radeon *radeon_incref(struct radeon *radeon)
{
	if (radeon == NULL)
		return NULL;
	radeon->refcount++;
	return radeon;
}

struct radeon *radeon_decref(struct radeon *radeon)
{
	if (radeon == NULL)
		return NULL;
	if (--radeon->refcount > 0) {
		return NULL;
	}
	radeon_mode_cleanup(radeon);
	radeon_bo_manager_gem_dtor(radeon->bom);
	radeon_cs_manager_gem_dtor(radeon->csm);
	drmClose(radeon->fd);
	free(radeon);
	return NULL;
}

void memset_bo(struct radeon_bo *bo, u32 value)
{
	u32 *ptr;
	int r;

	r = radeon_bo_map(bo, 1);
	if (r) {
		fprintf(stderr, "Failed to map buffer\n");
		perror(NULL);
		return;
	}
	ptr = (u32*)bo->ptr;
	for (r = 0; r < (bo->size / 4); r++)
		ptr[r] = value;
	radeon_bo_unmap(bo);
}

void memcpy_bo(struct radeon_bo *bo, u32 *src, u32 size)
{
	u32 *ptr, tmp;
	int r;

	r = radeon_bo_map(bo, 1);
	if (r) {
		fprintf(stderr, "Failed to map buffer\n");
		perror(NULL);
		return;
	}
	ptr = (u32*)bo->ptr;
	for (r = 0; r < size; r++)
		ptr[r] = src[r];
	for (r = 0; r < size; r++)
		ptr[r] = src[r];
	for (r = 0, tmp = 0; r < size; r++)
		tmp += ptr[r];
	radeon_bo_unmap(bo);
}

void radeon_blit(struct radeon_surface *dst, struct radeon_surface *src,
		unsigned sx, unsigned sy, unsigned dx, unsigned dy,
		unsigned w, unsigned h)
{
	unsigned y;
	u8 *dptr, *sptr;

	if (sx >= src->width || sy >= src->height)
		return;
	if (dx >= dst->width || dy >= dst->height)
		return;
	if ((sx + w) > src->width)
		w = src->width - sx;
	if ((dx + w) > dst->width)
		w = dst->width - dx;
	if ((sy + h) > src->height)
		h = src->height - sy;
	if ((dy + h) > dst->height)
		h = dst->height - dy;
	if (!w || !h)
		return;
	if (radeon_bo_map(dst->bo, 1))
		return;
	if (radeon_bo_map(src->bo, 0))
		return;
	sptr = src->bo->ptr;
	dptr = dst->bo->ptr;
	sptr = &sptr[(sy * src->pitch + sx) * src->bpe];
	dptr = &dptr[(dy * dst->pitch + dx) * dst->bpe];
	for (y = 0; y < h; y++) {
		memcpy(dptr, sptr, w * src->bpe);
		dptr += dst->pitch * dst->bpe;
		sptr += src->pitch * src->bpe;
	}
	radeon_bo_unmap(dst->bo);
	radeon_bo_unmap(src->bo);
}

int radeon_flush(struct radeon *radeon)
{
	struct radeon_ctx *ctx = radeon->ctx;
	unsigned i;
	int r;

	free(ctx->pm4);
	ctx->pm4 = malloc(ctx->cpm4 * 4);
	if (ctx->pm4 == NULL)
		return -EINVAL;
	for (i = 0, ctx->id = 0; i < ctx->nstate; i++) {
		r = radeon_ctx_state_schedule(ctx, ctx->state[i]);
		if (r)
			return r;
	}
	if (ctx->id != ctx->cpm4) {
		fprintf(stderr, "%s miss predicted pm4 size %d for %d\n",
			__func__, ctx->cpm4, ctx->id);
		return -EINVAL;
	}
	r = radeon_ctx_submit(ctx);
	radeon_ctx_destroy(ctx);
	radeon->ctx = radeon_ctx(radeon, 0);
	return r;
}

int radeon_reg_id(struct radeon *radeon, unsigned offset, unsigned *typeid, unsigned *stateid, unsigned *id)
{
	unsigned i, j;

	for (i = 0; i < radeon->ntype; i++) {
		if (radeon->type[i].range_start) {
			if (offset >= radeon->type[i].range_start && offset < radeon->type[i].range_end) {
				*typeid = i;
				j = offset - radeon->type[i].range_start;
				j /= radeon->type[i].stride;
				*stateid = radeon->type[i].id + j;
				*id = (offset - radeon->type[i].range_start - radeon->type[i].stride * j) / 4;
				return 0;
			}
		} else {
			for (j = 0; j < radeon->type[i].nstates; j++) {
				if (radeon->type[i].regs[j].offset == offset) {
					*typeid = i;
					*stateid = radeon->type[i].id;
					*id = j;
					return 0;
				}
			}
		}
	}
	fprintf(stderr, "%s unknown register 0x%08X\n", __func__, offset);
	return -EINVAL;
}

unsigned radeon_type_from_id(struct radeon *radeon, unsigned id)
{
	unsigned i;

	for (i = 0; i < radeon->ntype - 1; i++) {
		if (radeon->type[i].id == id)
			return i;
		if (id > radeon->type[i].id && id < radeon->type[i + 1].id)
			return i;
	}
	if (radeon->type[i].id == id)
		return i;
	return -1;
}

int radeon_schedule_draw(struct radeon *radeon, struct radeon_draw *draw)
{
	struct radeon_ctx *ctx = radeon->ctx;
	struct radeon_draw *pdraw = NULL;
	struct radeon_state *nstate, *ostate;
	unsigned cpm4, i, cstate;
	void *tmp;
	int r = 0;

	if (ctx == NULL) {
		ctx = radeon_ctx(radeon, 0);
		if (ctx == NULL)
			return -ENOMEM;
		radeon->ctx = ctx;
	}
	r = radeon_draw_check(draw);
	if (r)
		return r;
	if (draw->cpm4 >= RADEON_CTX_MAX_PM4) {
		fprintf(stderr, "%s single draw too big %d, max %d\n",
			__func__, draw->cpm4, RADEON_CTX_MAX_PM4);
		return -EINVAL;
	}
reprocess:
	tmp = realloc(ctx->state, (ctx->nstate + draw->nstate) * sizeof(void*));
	if (tmp == NULL)
		return -ENOMEM;
	ctx->state = tmp;
	pdraw = ctx->cdraw;
	for (i = 0, cpm4 = 0, cstate = ctx->nstate; i < draw->nstate - 1; i++) {
		nstate = draw->state[i];
		if (nstate) {
			if (pdraw && pdraw->state[i]) {
				ostate = pdraw->state[i];
				if (ostate->pm4_crc == nstate->pm4_crc) {
//					ctx->state[cstate++] = nstate;
//					cpm4 += nstate->cpm4;
				} else {
					ctx->state[cstate++] = nstate;
					cpm4 += nstate->cpm4;
				}
			} else {
				ctx->state[cstate++] = nstate;
				cpm4 += nstate->cpm4;
			}
		}
	}
	/* The last state is the draw state always add it */
	if (draw->state[i] == NULL) {
		fprintf(stderr, "%s no draw command\n", __func__);
		return -EINVAL;
	}
	ctx->state[cstate++] = draw->state[i];
	cpm4 += draw->state[i]->cpm4;
	if ((ctx->cpm4 + cpm4) > RADEON_CTX_MAX_PM4) {
		r = radeon_flush(radeon);
		if (r)
			goto out_err;
		goto reprocess;
	}
	r = radeon_ctx_set_draw_new(ctx, draw);
	if (r)
		goto out_err;
	radeon_draw_incref(draw);
	ctx->cpm4 += cpm4;
	ctx->nstate = cstate;
out_err:
	return r;
}