540 lines
16 KiB
C
540 lines
16 KiB
C
/**
|
|
* file psb_msvdx_ec.c
|
|
* MSVDX error concealment I/O operations
|
|
*
|
|
*/
|
|
|
|
/**************************************************************************
|
|
*
|
|
* Copyright (c) 2007 Intel Corporation, Hillsboro, OR, USA
|
|
* Copyright (c) Imagination Technologies Limited, UK
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
* under the terms and conditions of the GNU General Public License,
|
|
* version 2, as published by the Free Software Foundation.
|
|
*
|
|
* This program is distributed in the hope 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.
|
|
*
|
|
* Authors:
|
|
* Li Zeng <li.zeng@intel.com>
|
|
*
|
|
**************************************************************************/
|
|
|
|
#ifdef CONFIG_DRM_VXD_BYT
|
|
#include "vxd_drv.h"
|
|
#else
|
|
#include "psb_drv.h"
|
|
#endif
|
|
|
|
#include "psb_msvdx.h"
|
|
#include "psb_msvdx_msg.h"
|
|
#include "psb_msvdx_reg.h"
|
|
#include "psb_msvdx_ec.h"
|
|
|
|
#define MAX_SIZE_IN_MB (4096 / 16)
|
|
|
|
static inline int psb_msvdx_cmd_port_write(struct drm_psb_private *dev_priv,
|
|
uint32_t offset, uint32_t value, uint32_t *cmd_space)
|
|
{
|
|
uint32_t max_attempts = 0xff;
|
|
uint32_t attempts = 0;
|
|
|
|
max_attempts = 0xff;
|
|
while (*cmd_space == 0) {
|
|
*cmd_space = PSB_RMSVDX32(
|
|
MSVDX_CORE_CR_MSVDX_COMMAND_SPACE_OFFSET +
|
|
MSVDX_CORE_BASE);
|
|
if (*cmd_space)
|
|
break;
|
|
PSB_UDELAY(2);
|
|
attempts++;
|
|
if (attempts > max_attempts) {
|
|
printk(KERN_ERR "MSVDX: poll cmd space timeout\n");
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
PSB_WMSVDX32(value, offset + MSVDX_CMDS_BASE);
|
|
(*cmd_space)--;
|
|
/*
|
|
*printk(KERN_DEBUG "MSVDX: poll cmd space attempts %d\n", attempts);
|
|
*/
|
|
return 0;
|
|
}
|
|
|
|
#define PSB_CMDPORT_WRITE(_dev_priv_, _offset_, _cmd_, _cmd_space_) \
|
|
do { \
|
|
ret = psb_msvdx_cmd_port_write(_dev_priv_, \
|
|
_offset_, _cmd_, &_cmd_space_); \
|
|
if (ret) { \
|
|
printk(KERN_DEBUG "write cmd fail, abort\n"); \
|
|
goto ec_done; \
|
|
} \
|
|
} while (0);
|
|
|
|
#define PSB_CMDPORT_WRITE_FAST(_dev_priv_, _offset_, _cmd_, _cmd_space_) \
|
|
psb_msvdx_cmd_port_write(_dev_priv_, \
|
|
_offset_, _cmd_, &_cmd_space_); \
|
|
|
|
void psb_msvdx_do_concealment(struct work_struct *work)
|
|
{
|
|
struct msvdx_private *msvdx_priv =
|
|
container_of(work, struct msvdx_private, ec_work);
|
|
struct drm_psb_private *dev_priv = NULL;
|
|
struct psb_msvdx_ec_ctx *msvdx_ec_ctx = msvdx_priv->cur_msvdx_ec_ctx;
|
|
drm_psb_msvdx_decode_status_t *fault_region = NULL;
|
|
struct fw_deblock_msg *deblock_msg =
|
|
(struct fw_deblock_msg *)(msvdx_ec_ctx->unfenced_cmd +
|
|
msvdx_ec_ctx->deblock_cmd_offset);
|
|
uint32_t width_in_mb, height_in_mb, cmd;
|
|
int conceal_above_row = 0, loop, mb_loop;
|
|
uint32_t cmd_space = 0;
|
|
int ret = 0;
|
|
|
|
#ifdef CONFIG_VIDEO_MRFLD
|
|
if (!power_island_get(OSPM_VIDEO_DEC_ISLAND)) {
|
|
#else
|
|
if (!ospm_power_using_video_begin(OSPM_VIDEO_DEC_ISLAND)) {
|
|
#endif
|
|
printk(KERN_ERR "MSVDX: fail to power on ved for ec\n");
|
|
return;
|
|
}
|
|
|
|
dev_priv = msvdx_priv->dev_priv;
|
|
fault_region = &msvdx_ec_ctx->decode_status;
|
|
|
|
/* Concealment should be done in time,
|
|
* otherwise panic msg will be signaled in msvdx
|
|
*/
|
|
preempt_disable();
|
|
|
|
if (msvdx_ec_ctx->deblock_cmd_offset == PSB_MSVDX_INVALID_OFFSET) {
|
|
printk(KERN_ERR "invalid msg offset, abort concealment\n");
|
|
goto ec_done;
|
|
}
|
|
|
|
if (fault_region->num_region == 0) {
|
|
PSB_DEBUG_MSVDX("no fault region\n");
|
|
goto ec_done;
|
|
}
|
|
|
|
|
|
width_in_mb = deblock_msg->pic_size.bits.pic_width_mb;
|
|
height_in_mb = deblock_msg->pic_size.bits.frame_height_mb;
|
|
|
|
{
|
|
int i;
|
|
for (i = 0; i < fault_region->num_region; i++)
|
|
PSB_DEBUG_MSVDX("[region %d] is %d to %d\n",
|
|
i,
|
|
fault_region->mb_regions[i].start,
|
|
fault_region->mb_regions[i].end);
|
|
PSB_DEBUG_MSVDX("MSVDX: MSGID_DEBLOCK:"
|
|
" - fence: %08x"
|
|
" - flags: %08x - slice_field_type: %08x"
|
|
" - operating_mode: %08x"
|
|
" - context: %08x - mmu_ptd: %08x"
|
|
" - frame_height_mb: %08x - pic_width_mb: %08x"
|
|
" - address_a0: %08x - address_a1: %08x"
|
|
" - mb_param_address: %08x"
|
|
" - ext_stride_a: %08x"
|
|
" - address_b0: %08x - address_b1: %08x"
|
|
" - alt_output_flags_b: %08x.\n",
|
|
deblock_msg->header.bits.msg_fence,
|
|
deblock_msg->flag_type.bits.flags,
|
|
deblock_msg->flag_type.bits.slice_field_type,
|
|
deblock_msg->operating_mode,
|
|
deblock_msg->mmu_context.bits.context,
|
|
deblock_msg->mmu_context.bits.mmu_ptd,
|
|
deblock_msg->pic_size.bits.frame_height_mb,
|
|
deblock_msg->pic_size.bits.pic_width_mb,
|
|
deblock_msg->address_a0,
|
|
deblock_msg->address_a1,
|
|
deblock_msg->mb_param_address,
|
|
deblock_msg->ext_stride_a,
|
|
deblock_msg->address_b0,
|
|
deblock_msg->address_b1,
|
|
deblock_msg->alt_output_flags_b);
|
|
PSB_DEBUG_MSVDX("deblock addr_c0 is 0x%08x\n",
|
|
deblock_msg->address_c0);
|
|
PSB_DEBUG_MSVDX("deblock addr_c1 is 0x%08x\n",
|
|
deblock_msg->address_c1);
|
|
}
|
|
|
|
if (unlikely(!width_in_mb || !height_in_mb ||
|
|
width_in_mb > MAX_SIZE_IN_MB ||
|
|
height_in_mb > MAX_SIZE_IN_MB)) {
|
|
PSB_DEBUG_MSVDX("wrong pic size\n");
|
|
goto ec_done;
|
|
}
|
|
|
|
cmd = 0;
|
|
REGIO_WRITE_FIELD_LITE(cmd, MSVDX_CMDS,
|
|
DISPLAY_PICTURE_SIZE_DISPLAY_PICTURE_HEIGHT,
|
|
(height_in_mb * 16) - 1);
|
|
REGIO_WRITE_FIELD_LITE(cmd, MSVDX_CMDS,
|
|
DISPLAY_PICTURE_SIZE_DISPLAY_PICTURE_WIDTH,
|
|
(width_in_mb * 16) - 1);
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_DISPLAY_PICTURE_SIZE_OFFSET,
|
|
cmd, cmd_space);
|
|
|
|
cmd = 0;
|
|
REGIO_WRITE_FIELD_LITE(cmd, MSVDX_CMDS,
|
|
CODED_PICTURE_SIZE_CODED_PICTURE_HEIGHT,
|
|
(height_in_mb * 16) - 1);
|
|
REGIO_WRITE_FIELD_LITE(cmd, MSVDX_CMDS,
|
|
CODED_PICTURE_SIZE_CODED_PICTURE_WIDTH,
|
|
(width_in_mb * 16) - 1);
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_CODED_PICTURE_SIZE_OFFSET,
|
|
cmd, cmd_space);
|
|
|
|
cmd = deblock_msg->operating_mode;
|
|
REGIO_WRITE_FIELD(cmd, MSVDX_CMDS_OPERATING_MODE,
|
|
CHROMA_FORMAT, 1);
|
|
REGIO_WRITE_FIELD(cmd, MSVDX_CMDS_OPERATING_MODE,
|
|
ASYNC_MODE, 1);
|
|
REGIO_WRITE_FIELD(cmd, MSVDX_CMDS_OPERATING_MODE,
|
|
CODEC_MODE, 3);
|
|
REGIO_WRITE_FIELD(cmd, MSVDX_CMDS_OPERATING_MODE,
|
|
CODEC_PROFILE, 1);
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_OPERATING_MODE_OFFSET,
|
|
cmd, cmd_space);
|
|
|
|
/* dest frame address */
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_LUMA_RECONSTRUCTED_PICTURE_BASE_ADDRESSES_OFFSET,
|
|
deblock_msg->address_a0,
|
|
cmd_space);
|
|
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_CHROMA_RECONSTRUCTED_PICTURE_BASE_ADDRESSES_OFFSET,
|
|
deblock_msg->address_a1,
|
|
cmd_space);
|
|
|
|
/* conceal frame address */
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_REFERENCE_PICTURE_BASE_ADDRESSES_OFFSET,
|
|
deblock_msg->address_b0,
|
|
cmd_space);
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_REFERENCE_PICTURE_BASE_ADDRESSES_OFFSET + 4,
|
|
deblock_msg->address_b1,
|
|
cmd_space);
|
|
cmd = 0;
|
|
REGIO_WRITE_FIELD(cmd, MSVDX_CMDS_SLICE_PARAMS, SLICE_FIELD_TYPE, 2);
|
|
REGIO_WRITE_FIELD(cmd, MSVDX_CMDS_SLICE_PARAMS, SLICE_CODE_TYPE, 1);
|
|
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_SLICE_PARAMS_OFFSET,
|
|
cmd, cmd_space);
|
|
|
|
cmd = deblock_msg->alt_output_flags_b;
|
|
if ((cmd & 3) != 0) {
|
|
PSB_DEBUG_MSVDX("MSVDX: conceal to rotate surface\n");
|
|
} else {
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_ALTERNATIVE_OUTPUT_PICTURE_ROTATION_OFFSET,
|
|
cmd, cmd_space);
|
|
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_VC1_LUMA_RANGE_MAPPING_BASE_ADDRESS_OFFSET,
|
|
0, cmd_space);
|
|
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_VC1_CHROMA_RANGE_MAPPING_BASE_ADDRESS_OFFSET,
|
|
0, cmd_space);
|
|
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_VC1_RANGE_MAPPING_FLAGS_OFFSET,
|
|
0, cmd_space);
|
|
}
|
|
|
|
cmd = deblock_msg->ext_stride_a;
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_EXTENDED_ROW_STRIDE_OFFSET,
|
|
cmd, cmd_space);
|
|
|
|
for (loop = 0; loop < fault_region->num_region; loop++) {
|
|
|
|
uint32_t start = fault_region->mb_regions[loop].start;
|
|
uint32_t end = fault_region->mb_regions[loop].end;
|
|
uint32_t x, y;
|
|
|
|
PSB_DEBUG_MSVDX("MSVDX: region(%d) is %d~%d\n",
|
|
loop, start, end);
|
|
|
|
if (conceal_above_row)
|
|
start -= width_in_mb;
|
|
if (end > (width_in_mb * height_in_mb - 1))
|
|
end = (width_in_mb * height_in_mb - 1);
|
|
if (start > end)
|
|
start = 0;
|
|
|
|
PSB_DEBUG_MSVDX("MSVDX: modify region(%d) is %d~%d\n",
|
|
loop, start, end);
|
|
|
|
x = start % width_in_mb;
|
|
y = start / width_in_mb;
|
|
|
|
for (mb_loop = start; mb_loop <= end; mb_loop++, x++) {
|
|
if (x >= width_in_mb) {
|
|
x = 0;
|
|
y++;
|
|
}
|
|
|
|
/* PSB_DEBUG_MSVDX("MSVDX: concleament (%d,%d)\n",
|
|
x, y); */
|
|
if ((x == 0) && (mb_loop != start))
|
|
PSB_CMDPORT_WRITE_FAST(dev_priv,
|
|
MSVDX_CMDS_END_SLICE_PICTURE_OFFSET,
|
|
0, cmd_space);
|
|
cmd = 0;
|
|
REGIO_WRITE_FIELD_LITE(cmd,
|
|
MSVDX_CMDS_MACROBLOCK_NUMBER,
|
|
MB_CODE_TYPE, 1);
|
|
REGIO_WRITE_FIELD_LITE(cmd,
|
|
MSVDX_CMDS_MACROBLOCK_NUMBER,
|
|
MB_NO_X, x);
|
|
REGIO_WRITE_FIELD_LITE(cmd,
|
|
MSVDX_CMDS_MACROBLOCK_NUMBER,
|
|
MB_NO_Y, y);
|
|
PSB_CMDPORT_WRITE_FAST(dev_priv,
|
|
MSVDX_CMDS_MACROBLOCK_NUMBER_OFFSET,
|
|
cmd, cmd_space);
|
|
PSB_CMDPORT_WRITE_FAST(dev_priv,
|
|
MSVDX_CMDS_MACROBLOCK_RESIDUAL_FORMAT_OFFSET,
|
|
0, cmd_space);
|
|
cmd = 0;
|
|
REGIO_WRITE_FIELD_LITE(cmd,
|
|
MSVDX_CMDS_INTER_BLOCK_PREDICTION,
|
|
REF_INDEX_A_VALID, 1);
|
|
REGIO_WRITE_FIELD_LITE(cmd,
|
|
MSVDX_CMDS_INTER_BLOCK_PREDICTION,
|
|
INTER_PRED_BLOCK_SIZE, 0);
|
|
REGIO_WRITE_FIELD_LITE(cmd,
|
|
MSVDX_CMDS_INTER_BLOCK_PREDICTION,
|
|
REF_INDEX_A, 0);
|
|
REGIO_WRITE_FIELD_LITE(cmd,
|
|
MSVDX_CMDS_INTER_BLOCK_PREDICTION,
|
|
REF_INDEX_B, 0);
|
|
PSB_CMDPORT_WRITE_FAST(dev_priv,
|
|
MSVDX_CMDS_INTER_BLOCK_PREDICTION_OFFSET,
|
|
cmd, cmd_space);
|
|
PSB_CMDPORT_WRITE_FAST(dev_priv,
|
|
MSVDX_CMDS_MOTION_VECTOR_OFFSET,
|
|
0, cmd_space);
|
|
}
|
|
|
|
PSB_CMDPORT_WRITE(dev_priv,
|
|
MSVDX_CMDS_END_SLICE_PICTURE_OFFSET,
|
|
0, cmd_space);
|
|
}
|
|
|
|
ec_done:
|
|
/* try to unblock rendec */
|
|
ret = PSB_CMDPORT_WRITE_FAST(dev_priv,
|
|
MSVDX_CMDS_END_SLICE_PICTURE_OFFSET,
|
|
1, cmd_space);
|
|
|
|
fault_region->num_region = 0;
|
|
|
|
preempt_enable();
|
|
|
|
#ifdef CONFIG_VIDEO_MRFLD
|
|
power_island_put(OSPM_VIDEO_DEC_ISLAND);
|
|
#else
|
|
ospm_power_using_video_end(OSPM_VIDEO_DEC_ISLAND);
|
|
#endif
|
|
printk(KERN_DEBUG "MSVDX: EC done, unlock msvdx ret %d\n",
|
|
ret);
|
|
|
|
return;
|
|
}
|
|
|
|
struct psb_msvdx_ec_ctx *psb_msvdx_find_ec_ctx(
|
|
struct msvdx_private *msvdx_priv,
|
|
struct ttm_object_file *tfile,
|
|
void *cmd)
|
|
{
|
|
int i, free_idx;
|
|
struct psb_msvdx_ec_ctx *ec_ctx = NULL;
|
|
struct fw_deblock_msg *deblock_msg = (struct fw_deblock_msg *)cmd;
|
|
|
|
free_idx = -1;
|
|
for (i = 0; i < PSB_MAX_EC_INSTANCE; i++) {
|
|
if (msvdx_priv->msvdx_ec_ctx[i]->tfile == tfile)
|
|
break;
|
|
else if (free_idx < 0 &&
|
|
msvdx_priv->msvdx_ec_ctx[i]->tfile == NULL)
|
|
free_idx = i;
|
|
}
|
|
|
|
if (i < PSB_MAX_EC_INSTANCE)
|
|
ec_ctx = msvdx_priv->msvdx_ec_ctx[i];
|
|
else if (free_idx >= 0 && cmd) {
|
|
PSB_DEBUG_MSVDX("acquire ec ctx idx %d for tfile %p\n",
|
|
free_idx, tfile);
|
|
ec_ctx = msvdx_priv->msvdx_ec_ctx[free_idx];
|
|
memset(ec_ctx, 0, sizeof(*ec_ctx));
|
|
ec_ctx->tfile = tfile;
|
|
ec_ctx->context_id = deblock_msg->mmu_context.bits.context;
|
|
} else {
|
|
PSB_DEBUG_MSVDX("Available ec ctx is not found\n");
|
|
}
|
|
|
|
return ec_ctx;
|
|
}
|
|
|
|
void psb_msvdx_update_frame_info(struct msvdx_private *msvdx_priv,
|
|
struct ttm_object_file *tfile,
|
|
void *cmd)
|
|
{
|
|
|
|
int i, free_idx;
|
|
drm_psb_msvdx_frame_info_t *frame_info;
|
|
struct fw_deblock_msg *deblock_msg = (struct fw_deblock_msg *)cmd;
|
|
uint32_t buffer_handle = deblock_msg->mb_param_address;
|
|
|
|
struct psb_msvdx_ec_ctx *ec_ctx;
|
|
|
|
PSB_DEBUG_MSVDX(
|
|
"update frame info (handle 0x%08x) for error concealment\n",
|
|
buffer_handle);
|
|
|
|
ec_ctx = psb_msvdx_find_ec_ctx(msvdx_priv, tfile, cmd);
|
|
|
|
if (!ec_ctx)
|
|
return;
|
|
|
|
free_idx = -1;
|
|
for (i = 0; i < MAX_DECODE_BUFFERS; i++) {
|
|
if (buffer_handle == ec_ctx->frame_info[i].handle)
|
|
break;
|
|
if (free_idx < 0 && ec_ctx->frame_info[i].handle == 0)
|
|
free_idx = i;
|
|
}
|
|
|
|
if (i < MAX_DECODE_BUFFERS)
|
|
frame_info = &ec_ctx->frame_info[i];
|
|
else if (free_idx >= 0) {
|
|
PSB_DEBUG_MSVDX("acquire frame_info solt idx %d\n", free_idx);
|
|
frame_info = &ec_ctx->frame_info[free_idx];
|
|
} else {
|
|
PSB_DEBUG_MSVDX("%d solts occupied, abort update frame_info\n",
|
|
MAX_DECODE_BUFFERS);
|
|
return;
|
|
}
|
|
|
|
frame_info->fw_status = 0;
|
|
frame_info->handle = buffer_handle;
|
|
frame_info->fence = (deblock_msg->header.bits.msg_fence & (~0xf));
|
|
frame_info->decode_status.num_region = 0;
|
|
ec_ctx->cur_frame_info = frame_info;
|
|
}
|
|
|
|
void psb_msvdx_backup_cmd(struct msvdx_private *msvdx_priv,
|
|
struct ttm_object_file *tfile,
|
|
void *cmd,
|
|
uint32_t cmd_size,
|
|
uint32_t deblock_cmd_offset)
|
|
{
|
|
struct fw_deblock_msg *deblock_msg = NULL;
|
|
|
|
struct psb_msvdx_ec_ctx *ec_ctx;
|
|
union msg_header *header;
|
|
|
|
PSB_DEBUG_MSVDX("backup cmd for ved error concealment\n");
|
|
|
|
ec_ctx = psb_msvdx_find_ec_ctx(msvdx_priv, tfile, NULL);
|
|
|
|
if (!ec_ctx) {
|
|
PSB_DEBUG_MSVDX("this is not a ec ctx, abort backup cmd\n");
|
|
return;
|
|
}
|
|
|
|
|
|
if (deblock_cmd_offset != PSB_MSVDX_INVALID_OFFSET)
|
|
deblock_msg = (struct fw_deblock_msg *)(cmd + deblock_cmd_offset);
|
|
|
|
if (deblock_msg &&
|
|
ec_ctx->context_id != deblock_msg->mmu_context.bits.context) {
|
|
PSB_DEBUG_MSVDX("backup cmd but find mis-match context id\n");
|
|
return;
|
|
}
|
|
|
|
ec_ctx->cmd_size = cmd_size;
|
|
ec_ctx->deblock_cmd_offset = deblock_cmd_offset;
|
|
memcpy(ec_ctx->unfenced_cmd, cmd, cmd_size);
|
|
ec_ctx->fence = PSB_MSVDX_INVALID_FENCE;
|
|
header = (union msg_header *)ec_ctx->unfenced_cmd;
|
|
if (cmd_size)
|
|
ec_ctx->fence = header->bits.msg_fence;
|
|
ec_ctx->fence &= (~0xf);
|
|
PSB_DEBUG_MSVDX("backup cmd for ved: fence 0x%08x, cmd_size %d\n",
|
|
ec_ctx->fence, cmd_size);
|
|
}
|
|
|
|
void psb_msvdx_mtx_message_dump(struct drm_device *dev)
|
|
{
|
|
struct drm_psb_private *dev_priv = psb_priv(dev);
|
|
int i, buf_size, buf_offset;
|
|
buf_size = PSB_RMSVDX32(MSVDX_COMMS_TO_HOST_BUF_SIZE) & ((1 << 16) - 1);
|
|
buf_offset =
|
|
(PSB_RMSVDX32(MSVDX_COMMS_TO_HOST_BUF_SIZE) >> 16) + 0x2000;
|
|
|
|
printk(KERN_DEBUG "Dump to HOST message buffer (offset:size)%04x:%04x\n",
|
|
buf_offset, buf_size);
|
|
for (i = 0; i < buf_size; i += 4) {
|
|
uint32_t reg1, reg2, reg3, reg4;
|
|
reg1 = PSB_RMSVDX32(buf_offset + i * 4);
|
|
reg2 = PSB_RMSVDX32(buf_offset + i * 4 + 4);
|
|
reg3 = PSB_RMSVDX32(buf_offset + i * 4 + 8);
|
|
reg4 = PSB_RMSVDX32(buf_offset + i * 4 + 12);
|
|
printk(KERN_DEBUG "0x%04x: 0x%08x 0x%08x 0x%08x 0x%08x\n",
|
|
(buf_offset + i * 4), reg1, reg2, reg3, reg4);
|
|
}
|
|
|
|
buf_size = PSB_RMSVDX32(MSVDX_COMMS_TO_MTX_BUF_SIZE) & ((1 << 16) - 1);
|
|
buf_offset = (PSB_RMSVDX32(MSVDX_COMMS_TO_MTX_BUF_SIZE) >> 16) + 0x2000;
|
|
|
|
printk(KERN_DEBUG "Dump to MTX message buffer (offset:size)%04x:%04x\n",
|
|
buf_offset, buf_size);
|
|
for (i = 0; i < buf_size; i += 4) {
|
|
uint32_t reg1, reg2, reg3, reg4;
|
|
reg1 = PSB_RMSVDX32(buf_offset + i * 4);
|
|
reg2 = PSB_RMSVDX32(buf_offset + i * 4 + 4);
|
|
reg3 = PSB_RMSVDX32(buf_offset + i * 4 + 8);
|
|
reg4 = PSB_RMSVDX32(buf_offset + i * 4 + 12);
|
|
printk(KERN_DEBUG "0x%04x: 0x%08x 0x%08x 0x%08x 0x%08x\n",
|
|
(buf_offset + i * 4), reg1, reg2, reg3, reg4);
|
|
}
|
|
|
|
buf_size = 12;
|
|
buf_offset = 0xFD0 + 0x2000;
|
|
|
|
printk(KERN_DEBUG "Comm header (offset:size)%04x:%04x\n",
|
|
buf_offset, buf_size);
|
|
for (i = 0; i < buf_size; i += 4) {
|
|
uint32_t reg1, reg2, reg3, reg4;
|
|
reg1 = PSB_RMSVDX32(buf_offset + i * 4);
|
|
reg2 = PSB_RMSVDX32(buf_offset + i * 4 + 4);
|
|
reg3 = PSB_RMSVDX32(buf_offset + i * 4 + 8);
|
|
reg4 = PSB_RMSVDX32(buf_offset + i * 4 + 12);
|
|
printk(KERN_DEBUG "0x%04x: 0x%08x 0x%08x 0x%08x 0x%08x\n",
|
|
(buf_offset + i * 4), reg1, reg2, reg3, reg4);
|
|
}
|
|
|
|
printk(KERN_DEBUG "Error status 0x2cc4: 0x%08x\n",
|
|
PSB_RMSVDX32(0x2cc4));
|
|
}
|