WebSVN – Kolibri OS – Diff – /drivers/video/drm/radeon/atom.c

  * Author: Stanislaw Skowronek
  */
 #include
+#include
 #include
 #include
 #define ATOM_DEBUG
+#include "atom.h"
-#include "atom.h"
+#include "atom-names.h"
-#include "atom-names.h"
+#include "atom-bits.h"
-#include "atom-bits.h"
+#include "radeon.h"
 #define PLL_INDEX	2
 #define PLL_DATA	3
 typedef struct {
-	struct atom_context *ctx;
 	struct atom_context *ctx;
 	uint32_t *ps, *ws;
 	int ps_shift;
+	uint16_t start;
+	unsigned last_jump;
+	unsigned long last_jump_jiffies;
-	uint16_t start;
+	bool abort;
 } atom_exec_context;
 int atom_debug = 0;
-static void atom_execute_table_locked(struct atom_context *ctx, int index, uint32_t * params);
+static int atom_execute_table_locked(struct atom_context *ctx, int index, uint32_t * params);
-void atom_execute_table(struct atom_context *ctx, int index, uint32_t * params);
+int atom_execute_table(struct atom_context *ctx, int index, uint32_t * params);
 static uint32_t atom_arg_mask[8] =
 #endif
 static uint32_t atom_iio_execute(struct atom_context *ctx, int base,
 				 uint32_t index, uint32_t data)
+{
 	struct radeon_device *rdev = ctx->card->dev->dev_private;
+	uint32_t temp = 0xCDCDCDCD;
 	uint32_t temp = 0xCDCDCDCD;
 	while (1)
 		switch (CU8(base)) {
 		case ATOM_IIO_NOP:
 			base++;
 			break;
 		case ATOM_IIO_READ:
-			temp = ctx->card->reg_read(ctx->card, CU16(base + 1));
+			temp = ctx->card->ioreg_read(ctx->card, CU16(base + 1));
 			base += 3;
 			break;
+		case ATOM_IIO_WRITE:
-		case ATOM_IIO_WRITE:
+			if (rdev->family == CHIP_RV515)
-			(void)ctx->card->reg_read(ctx->card, CU16(base + 1));
+			(void)ctx->card->ioreg_read(ctx->card, CU16(base + 1));
-			ctx->card->reg_write(ctx->card, CU16(base + 1), temp);
+			ctx->card->ioreg_write(ctx->card, CU16(base + 1), temp);
 			base += 3;
 			break;
 		case ATOM_IIO_CLEAR:
 			temp &=
 			base += 3;
 			break;
 		case ATOM_IIO_MOVE_INDEX:
 			temp &=
 			    ~((0xFFFFFFFF >> (32 - CU8(base + 1))) <<
-			      CU8(base + 2));
+			      CU8(base + 3));
 			temp |=
 			    ((index >> CU8(base + 2)) &
 			     (0xFFFFFFFF >> (32 - CU8(base + 1)))) << CU8(base +
 );
 			base += 4;
 			break;
 		case ATOM_IIO_MOVE_DATA:
 			temp &=
 			    ~((0xFFFFFFFF >> (32 - CU8(base + 1))) <<
-			      CU8(base + 2));
+			      CU8(base + 3));
 			temp |=
 			    ((data >> CU8(base + 2)) &
 			     (0xFFFFFFFF >> (32 - CU8(base + 1)))) << CU8(base +
 );
 			base += 4;
 			break;
 		case ATOM_IIO_MOVE_ATTR:
 			temp &=
 			    ~((0xFFFFFFFF >> (32 - CU8(base + 1))) <<
-			      CU8(base + 2));
+			      CU8(base + 3));
 			temp |=
 			    ((ctx->
 			      io_attr >> CU8(base + 2)) & (0xFFFFFFFF >> (32 -
 									  CU8
 									  (base
+}
 static void atom_op_calltable(atom_exec_context *ctx, int *ptr, int arg)
+{
+	int idx = U8((*ptr)++);
+	int r = 0;
 	int idx = U8((*ptr)++);
 	if (idx < ATOM_TABLE_NAMES_CNT)
 		SDEBUG("   table: %d (%s)\n", idx, atom_table_names[idx]);
 	else
 		SDEBUG("   table: %d\n", idx);
 	if (U16(ctx->ctx->cmd_table + 4 + 2 * idx))
+		r = atom_execute_table_locked(ctx->ctx, idx, ctx->ps + ctx->ps_shift);
+	if (r) {
+		ctx->abort = true;
 		atom_execute_table_locked(ctx->ctx, idx, ctx->ps + ctx->ps_shift);
+}
 static void atom_op_clear(atom_exec_context *ctx, int *ptr, int arg)
 	       ctx->ctx->cs_above ? "GT" : "LE");
+}
 static void atom_op_delay(atom_exec_context *ctx, int *ptr, int arg)
 {
-	uint8_t count = U8((*ptr)++);
+	unsigned count = U8((*ptr)++);
 	SDEBUG("   count: %d\n", count);
     if (arg == ATOM_UNIT_MICROSEC)
        udelay(count);
     else
-       mdelay(count);
+		msleep(count);
+}
 static void atom_op_div(atom_exec_context *ctx, int *ptr, int arg)
+}
 static void atom_op_jump(atom_exec_context *ctx, int *ptr, int arg)
+{
+	int execute = 0, target = U16(*ptr);
+	unsigned long cjiffies;
 	int execute = 0, target = U16(*ptr);
 	(*ptr) += 2;
 	switch (arg) {
 	case ATOM_COND_ABOVE:
 		execute = ctx->ctx->cs_above;
+}
 static void atom_op_mask(atom_exec_context *ctx, int *ptr, int arg)
+{
 	uint8_t attr = U8((*ptr)++);
-	uint32_t dst, src1, src2, saved;
+	uint32_t dst, mask, src, saved;
 	int dptr = *ptr;
 	SDEBUG("   dst: ");
-	dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);
-	SDEBUG("   src1: ");
+	dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);
+	mask = atom_get_src_direct(ctx, ((attr >> 3) & 7), ptr);
-	src1 = atom_get_src_direct(ctx, ((attr >> 3) & 7), ptr);
+	SDEBUG("   mask: 0x%08x", mask);
-	SDEBUG("   src2: ");
+	SDEBUG("   src: ");
-	src2 = atom_get_src(ctx, attr, ptr);
+	src = atom_get_src(ctx, attr, ptr);
-	dst &= src1;
+	dst &= mask;
-	dst |= src2;
+	dst |= src;
 	SDEBUG("   dst: ");
 	atom_put_dst(ctx, arg, attr, &dptr, dst, saved);
+}
 static void atom_op_shl(atom_exec_context *ctx, int *ptr, int arg)
+{
 	uint8_t attr = U8((*ptr)++), shift;
 	uint32_t saved, dst;
 	int dptr = *ptr;
+	uint32_t dst_align = atom_dst_to_src[(attr >> 3) & 7][(attr >> 6) & 3];
 	SDEBUG("   dst: ");
 	dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);
+	/* op needs to full dst value */
+	dst = saved;
 	shift = atom_get_src(ctx, attr, ptr);
 	SDEBUG("   shift: %d\n", shift);
 	dst <<= shift;
+	dst &= atom_arg_mask[dst_align];
+	dst >>= atom_arg_shift[dst_align];
 	SDEBUG("   dst: ");
 	atom_put_dst(ctx, arg, attr, &dptr, dst, saved);
+}
 static void atom_op_shr(atom_exec_context *ctx, int *ptr, int arg)
+{
 	uint8_t attr = U8((*ptr)++), shift;
 	uint32_t saved, dst;
+	int dptr = *ptr;
-	int dptr = *ptr;
+	uint32_t dst_align = atom_dst_to_src[(attr >> 3) & 7][(attr >> 6) & 3];
 	SDEBUG("   dst: ");
+	dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);
+	/* op needs to full dst value */
-	dst = atom_get_dst(ctx, arg, attr, ptr, &saved, 1);
+	dst = saved;
 	shift = atom_get_src(ctx, attr, ptr);
 	SDEBUG("   shift: %d\n", shift);
+	dst >>= shift;
+	dst &= atom_arg_mask[dst_align];
-	dst >>= shift;
+	dst >>= atom_arg_shift[dst_align];
 	SDEBUG("   dst: ");
 	atom_put_dst(ctx, arg, attr, &dptr, dst, saved);
+}
 	atom_op_shr, ATOM_ARG_FB}, {
 	atom_op_shr, ATOM_ARG_PLL}, {
 	atom_op_shr, ATOM_ARG_MC}, {
 atom_op_debug, 0},};
-static void atom_execute_table_locked(struct atom_context *ctx, int index, uint32_t * params)
+static int atom_execute_table_locked(struct atom_context *ctx, int index, uint32_t * params)
+{
 	int base = CU16(ctx->cmd_table + 4 + 2 * index);
 	int len, ws, ps, ptr;
 	unsigned char op;
+	atom_exec_context ectx;
-	atom_exec_context ectx;
+	int ret = 0;
 	if (!base)
-		return;
+		return -EINVAL;
 	len = CU16(base + ATOM_CT_SIZE_PTR);
 	ectx.ctx = ctx;
 	ectx.ps_shift = ps / 4;
 	ectx.start = base;
+	ectx.ps = params;
+	ectx.abort = false;
-	ectx.ps = params;
+	ectx.last_jump = 0;
 	if (ws)
 		ectx.ws = kzalloc(4 * ws, GFP_KERNEL);
 	else
 		op = CU8(ptr++);
 		if (op < ATOM_OP_NAMES_CNT)
 			SDEBUG("%s @ 0x%04X\n", atom_op_names[op], ptr - 1);
 		else
 			SDEBUG("[%d] @ 0x%04X\n", op, ptr - 1);
+		if (ectx.abort) {
+			DRM_ERROR("atombios stuck executing %04X (len %d, WS %d, PS %d) @ 0x%04X\n",
+				base, len, ws, ps, ptr - 1);
+			ret = -EINVAL;
+			goto free;
+		}
 		if (op < ATOM_OP_CNT && op > 0)
 			opcode_table[op].func(&ectx, &ptr,
 					      opcode_table[op].arg);
 			break;
+	}
 	debug_depth--;
 	SDEBUG("<<\n");
 free:
 	if (ws)
+		kfree(ectx.ws);
-		kfree(ectx.ws);
+	return ret;
 }
+int atom_execute_table(struct atom_context *ctx, int index, uint32_t * params)
+{
-void atom_execute_table(struct atom_context *ctx, int index, uint32_t * params)
+	int r;
 	mutex_lock(&ctx->mutex);
 	/* reset reg block */
 	ctx->reg_block = 0;
 	/* reset fb window */
 	ctx->fb_base = 0;
 	/* reset io mode */
 	ctx->io_mode = ATOM_IO_MM;
+	r = atom_execute_table_locked(ctx, index, params);
-	atom_execute_table_locked(ctx, index, params);
+	mutex_unlock(&ctx->mutex);
-	mutex_unlock(&ctx->mutex);
+	return r;
+}
 	if (!ps[0] || !ps[1])
 		return 1;
 	if (!CU16(ctx->cmd_table + 4 + 2 * ATOM_CMD_INIT))
 		return 1;
-	atom_execute_table(ctx, ATOM_CMD_INIT, ps);
-	return 0;
+	return atom_execute_table(ctx, ATOM_CMD_INIT, ps);
+}
 void atom_destroy(struct atom_context *ctx)
+{
 	if (ctx->iio)
 		kfree(ctx->iio);
 	kfree(ctx);
+}
-void atom_parse_data_header(struct atom_context *ctx, int index,
+bool atom_parse_data_header(struct atom_context *ctx, int index,
 			    uint16_t * size, uint8_t * frev, uint8_t * crev,
 			    uint16_t * data_start)
+{
+	int offset = index * 2 + 4;
+	int idx = CU16(ctx->data_table + offset);
+	u16 *mdt = (u16 *)(ctx->bios + ctx->data_table + 4);
-	int offset = index * 2 + 4;
+	if (!mdt[index])
-	int idx = CU16(ctx->data_table + offset);
+		return false;
 	if (size)
 		*size = CU16(idx);
 	if (frev)
 		*frev = CU8(idx + 2);
 	if (crev)
 		*crev = CU8(idx + 3);
 	*data_start = idx;
-	return;
+	return true;
+}
+bool atom_parse_cmd_header(struct atom_context *ctx, int index, uint8_t * frev,
+			   uint8_t * crev)
+{
+	int offset = index * 2 + 4;
-void atom_parse_cmd_header(struct atom_context *ctx, int index, uint8_t * frev,
+	int idx = CU16(ctx->cmd_table + offset);
-			   uint8_t * crev)
+	u16 *mct = (u16 *)(ctx->bios + ctx->cmd_table + 4);
-	int offset = index * 2 + 4;
+	if (!mct[index])
-	int idx = CU16(ctx->cmd_table + offset);
+		return false;
 	if (frev)
 		*frev = CU8(idx + 2);
 	if (crev)
 		*crev = CU8(idx + 3);
-	return;
+	return true;
+}
-int atom_allocate_fb_scratch(struct atom_context *ctx)
 int atom_allocate_fb_scratch(struct atom_context *ctx)
 	int index = GetIndexIntoMasterTable(DATA, VRAM_UsageByFirmware);
-	uint16_t data_offset;
+	int index = GetIndexIntoMasterTable(DATA, VRAM_UsageByFirmware);
-	int usage_bytes;
+	uint16_t data_offset;
-	struct _ATOM_VRAM_USAGE_BY_FIRMWARE *firmware_usage;
+	int usage_bytes = 0;
+	struct _ATOM_VRAM_USAGE_BY_FIRMWARE *firmware_usage;
-	atom_parse_data_header(ctx, index, NULL, NULL, NULL, &data_offset);
+	if (atom_parse_data_header(ctx, index, NULL, NULL, NULL, &data_offset)) {
 	firmware_usage = (struct _ATOM_VRAM_USAGE_BY_FIRMWARE *)(ctx->bios + data_offset);
 	firmware_usage = (struct _ATOM_VRAM_USAGE_BY_FIRMWARE *)(ctx->bios + data_offset);
 	DRM_DEBUG("atom firmware requested %08x %dkb\n",

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/radeon/atom.c – Rev 1430 → 1963