diff --git a/drivers/mxc/amd-gpu/include/g12_reg.h b/drivers/mxc/amd-gpu/include/g12_reg.h new file mode 100644 index 00000000000..40bbfb2eb96 --- /dev/null +++ b/drivers/mxc/amd-gpu/include/g12_reg.h @@ -0,0 +1,100 @@ +/* Copyright (c) 2002,2007-2010, Code Aurora Forum. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Code Aurora Forum, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#ifndef _G12_REG_H +#define _G12_REG_H + +#define REG_VGC_IRQSTATUS__MH_MASK 0x00000001L +#define REG_VGC_IRQSTATUS__G2D_MASK 0x00000002L +#define REG_VGC_IRQSTATUS__FIFO_MASK 0x00000004L +#define REG_VGC_IRQSTATUS__FBC_MASK 0x00000001L // this is a weird one.. not in the docs?! + +#define MH_INTERRUPT_MASK__AXI_READ_ERROR 0x00000001L +#define MH_INTERRUPT_MASK__AXI_WRITE_ERROR 0x00000002L +#define MH_INTERRUPT_MASK__MMU_PAGE_FAULT 0x00000004L + +#define MH_ARBITER_CONFIG__SAME_PAGE_GRANULARITY__SHIFT 0x00000006 +#define MH_ARBITER_CONFIG__L1_ARB_ENABLE__SHIFT 0x00000007 +#define MH_ARBITER_CONFIG__L1_ARB_HOLD_ENABLE__SHIFT 0x00000008 +#define MH_ARBITER_CONFIG__L2_ARB_CONTROL__SHIFT 0x00000009 +#define MH_ARBITER_CONFIG__PAGE_SIZE__SHIFT 0x0000000a +#define MH_ARBITER_CONFIG__TC_REORDER_ENABLE__SHIFT 0x0000000d +#define MH_ARBITER_CONFIG__TC_ARB_HOLD_ENABLE__SHIFT 0x0000000e +#define MH_ARBITER_CONFIG__IN_FLIGHT_LIMIT_ENABLE__SHIFT 0x0000000f +#define MH_ARBITER_CONFIG__IN_FLIGHT_LIMIT__SHIFT 0x00000010 +#define MH_ARBITER_CONFIG__CP_CLNT_ENABLE__SHIFT 0x00000016 +#define MH_ARBITER_CONFIG__VGT_CLNT_ENABLE__SHIFT 0x00000017 +#define MH_ARBITER_CONFIG__TC_CLNT_ENABLE__SHIFT 0x00000018 +#define MH_ARBITER_CONFIG__RB_CLNT_ENABLE__SHIFT 0x00000019 +#define MH_ARBITER_CONFIG__PA_CLNT_ENABLE__SHIFT 0x0000001a + +#define MH_MMU_CONFIG__RB_W_CLNT_BEHAVIOR__SHIFT 0x00000004 +#define MH_MMU_CONFIG__CP_W_CLNT_BEHAVIOR__SHIFT 0x00000006 +#define MH_MMU_CONFIG__CP_R0_CLNT_BEHAVIOR__SHIFT 0x00000008 +#define MH_MMU_CONFIG__CP_R1_CLNT_BEHAVIOR__SHIFT 0x0000000a +#define MH_MMU_CONFIG__CP_R2_CLNT_BEHAVIOR__SHIFT 0x0000000c +#define MH_MMU_CONFIG__CP_R3_CLNT_BEHAVIOR__SHIFT 0x0000000e +#define MH_MMU_CONFIG__CP_R4_CLNT_BEHAVIOR__SHIFT 0x00000010 +#define MH_MMU_CONFIG__VGT_R0_CLNT_BEHAVIOR__SHIFT 0x00000012 +#define MH_MMU_CONFIG__VGT_R1_CLNT_BEHAVIOR__SHIFT 0x00000014 +#define MH_MMU_CONFIG__TC_R_CLNT_BEHAVIOR__SHIFT 0x00000016 +#define MH_MMU_CONFIG__PA_W_CLNT_BEHAVIOR__SHIFT 0x00000018 + +#define ADDR_MH_ARBITER_CONFIG 0x0A40 +#define ADDR_MH_INTERRUPT_CLEAR 0x0A44 +#define ADDR_MH_INTERRUPT_MASK 0x0A42 +#define ADDR_MH_INTERRUPT_STATUS 0x0A43 +#define ADDR_MH_AXI_ERROR 0x0A45 +#define ADDR_MH_AXI_HALT_CONTROL 0x0A50 +#define ADDR_MH_CLNT_INTF_CTRL_CONFIG1 0x0A54 +#define ADDR_MH_CLNT_INTF_CTRL_CONFIG2 0x0A55 +#define ADDR_MH_MMU_CONFIG 0x0040 +#define ADDR_MH_MMU_INVALIDATE 0x0045 +#define ADDR_MH_MMU_MPU_BASE 0x0046 +#define ADDR_MH_MMU_MPU_END 0x0047 +#define ADDR_MH_MMU_PT_BASE 0x0042 +#define ADDR_MH_MMU_TRAN_ERROR 0x0044 +#define ADDR_MH_MMU_VA_RANGE 0x0041 +#define ADDR_VGC_MH_READ_ADDR 0x0510 +#define ADDR_VGC_MH_DATA_ADDR 0x0518 +#define ADDR_MH_MMU_PAGE_FAULT 0x0043 +#define ADDR_VGC_COMMANDSTREAM 0x0000 +#define ADDR_VGC_IRQENABLE 0x0438 +#define ADDR_VGC_IRQSTATUS 0x0418 +#define ADDR_VGC_IRQ_ACTIVE_CNT 0x04E0 +#define ADDR_VGC_MMUCOMMANDSTREAM 0x03FC +#define ADDR_VGV3_CONTROL 0x0070 +#define ADDR_VGV3_LAST 0x007F +#define ADDR_VGV3_MODE 0x0071 +#define ADDR_VGV3_NEXTADDR 0x0075 +#define ADDR_VGV3_NEXTCMD 0x0076 +#define ADDR_VGV3_WRITEADDR 0x0072 + +#define ADDR_VGV1_CBASE1 0x002a //fsl +#define ADDR_VGV1_UBASE2 0x002b //fsl +#endif /* _G12_REG_H */ diff --git a/drivers/mxc/amd-gpu/include/gsl.h b/drivers/mxc/amd-gpu/include/gsl.h index 3266ea2dca9..1e4a3c0288e 100644 --- a/drivers/mxc/amd-gpu/include/gsl.h +++ b/drivers/mxc/amd-gpu/include/gsl.h @@ -43,14 +43,14 @@ struct kgsl_device; #include "gsl_klibapi.h" // Z430 -#include +#include #include "gsl_pm4types.h" #include "gsl_utils.h" #include "gsl_drawctxt.h" #include "gsl_ringbuffer.h" // Z160/Z180 -#include +#include #include "gsl_cmdwindow.h" #include "gsl_debug.h" diff --git a/drivers/mxc/amd-gpu/include/gsl_config.h b/drivers/mxc/amd-gpu/include/gsl_config.h index f921ef7eeeb..07a69150867 100644 --- a/drivers/mxc/amd-gpu/include/gsl_config.h +++ b/drivers/mxc/amd-gpu/include/gsl_config.h @@ -39,48 +39,6 @@ static const unsigned int gsl_cfg_rb_sizelog2quadwords = GSL_RB_SIZE_32K; static const unsigned int gsl_cfg_rb_blksizequadwords = GSL_RB_SIZE_16; -/* ------------------------ - * Yamato MH arbiter config - * ------------------------ */ -static const mh_arbiter_config_t gsl_cfg_yamato_mharb = { - 0x10, /* same_page_limit */ - 0, /* same_page_granularity */ - 1, /* l1_arb_enable */ - 1, /* l1_arb_hold_enable */ - 0, /* l2_arb_control */ - 1, /* page_size */ - 1, /* tc_reorder_enable */ - 1, /* tc_arb_hold_enable */ - 1, /* in_flight_limit_enable */ - 0x8, /* in_flight_limit */ - 1, /* cp_clnt_enable */ - 1, /* vgt_clnt_enable */ - 1, /* tc_clnt_enable */ - 1, /* rb_clnt_enable */ - 1, /* pa_clnt_enable */ -}; - -/* --------------------- - * G12 MH arbiter config - * --------------------- */ -static const REG_MH_ARBITER_CONFIG gsl_cfg_g12_mharb = { - 0x10, /* SAME_PAGE_LIMIT */ - 0, /* SAME_PAGE_GRANULARITY */ - 1, /* L1_ARB_ENABLE */ - 1, /* L1_ARB_HOLD_ENABLE */ - 0, /* L2_ARB_CONTROL */ - 1, /* PAGE_SIZE */ - 1, /* TC_REORDER_ENABLE */ - 1, /* TC_ARB_HOLD_ENABLE */ - 1, /* IN_FLIGHT_LIMIT_ENABLE */ - 0x8, /* IN_FLIGHT_LIMIT */ - 1, /* CP_CLNT_ENABLE */ - 1, /* VGT_CLNT_ENABLE */ - 1, /* TC_CLNT_ENABLE */ - 1, /* RB_CLNT_ENABLE */ - 1, /* PA_CLNT_ENABLE */ -}; - /* ----------------------------- * interrupt block register data * ----------------------------- */ @@ -89,33 +47,33 @@ static const gsl_intrblock_reg_t gsl_cfg_intrblock_reg[GSL_INTR_BLOCK_COUNT] = { GSL_INTR_BLOCK_YDX_MH, GSL_INTR_YDX_MH_AXI_READ_ERROR, GSL_INTR_YDX_MH_MMU_PAGE_FAULT, - mmMH_INTERRUPT_STATUS, - mmMH_INTERRUPT_CLEAR, - mmMH_INTERRUPT_MASK + REG_MH_INTERRUPT_STATUS, + REG_MH_INTERRUPT_CLEAR, + REG_MH_INTERRUPT_MASK }, { /* Yamato CP */ GSL_INTR_BLOCK_YDX_CP, GSL_INTR_YDX_CP_SW_INT, GSL_INTR_YDX_CP_RING_BUFFER, - mmCP_INT_STATUS, - mmCP_INT_ACK, - mmCP_INT_CNTL + REG_CP_INT_STATUS, + REG_CP_INT_ACK, + REG_CP_INT_CNTL }, { /* Yamato RBBM */ GSL_INTR_BLOCK_YDX_RBBM, GSL_INTR_YDX_RBBM_READ_ERROR, GSL_INTR_YDX_RBBM_GUI_IDLE, - mmRBBM_INT_STATUS, - mmRBBM_INT_ACK, - mmRBBM_INT_CNTL + REG_RBBM_INT_STATUS, + REG_RBBM_INT_ACK, + REG_RBBM_INT_CNTL }, { /* Yamato SQ */ GSL_INTR_BLOCK_YDX_SQ, GSL_INTR_YDX_SQ_PS_WATCHDOG, GSL_INTR_YDX_SQ_VS_WATCHDOG, - mmSQ_INT_STATUS, - mmSQ_INT_ACK, - mmSQ_INT_CNTL + REG_SQ_INT_STATUS, + REG_SQ_INT_ACK, + REG_SQ_INT_CNTL }, { /* G12 */ GSL_INTR_BLOCK_G12, @@ -164,15 +122,15 @@ static const int gsl_cfg_intr_mask[GSL_INTR_COUNT] = { SQ_INT_CNTL__PS_WATCHDOG_MASK, SQ_INT_CNTL__VS_WATCHDOG_MASK, - (1 << VGC_IRQENABLE_MH_FSHIFT), - (1 << VGC_IRQENABLE_G2D_FSHIFT), - (1 << VGC_IRQENABLE_FIFO_FSHIFT), + REG_VGC_IRQSTATUS__MH_MASK, + REG_VGC_IRQSTATUS__G2D_MASK, + REG_VGC_IRQSTATUS__FIFO_MASK, #ifndef _Z180 - (1 << VGC_IRQENABLE_FBC_FSHIFT), + REG_VGC_IRQSTATUS__FBC_MASK, #endif - (1 << MH_INTERRUPT_MASK_AXI_READ_ERROR_FSHIFT), - (1 << MH_INTERRUPT_MASK_AXI_WRITE_ERROR_FSHIFT), - (1 << MH_INTERRUPT_MASK_MMU_PAGE_FAULT_FSHIFT), + MH_INTERRUPT_MASK__AXI_READ_ERROR, + MH_INTERRUPT_MASK__AXI_WRITE_ERROR, + MH_INTERRUPT_MASK__MMU_PAGE_FAULT, }; /* ----------------- @@ -180,14 +138,14 @@ static const int gsl_cfg_intr_mask[GSL_INTR_COUNT] = { * ----------------- */ static const gsl_mmu_reg_t gsl_cfg_mmu_reg[GSL_DEVICE_MAX] = { { /* Yamato */ - mmMH_MMU_CONFIG, - mmMH_MMU_MPU_BASE, - mmMH_MMU_MPU_END, - mmMH_MMU_VA_RANGE, - mmMH_MMU_PT_BASE, - mmMH_MMU_PAGE_FAULT, - mmMH_MMU_TRAN_ERROR, - mmMH_MMU_INVALIDATE, + REG_MH_MMU_CONFIG, + REG_MH_MMU_MPU_BASE, + REG_MH_MMU_MPU_END, + REG_MH_MMU_VA_RANGE, + REG_MH_MMU_PT_BASE, + REG_MH_MMU_PAGE_FAULT, + REG_MH_MMU_TRAN_ERROR, + REG_MH_MMU_INVALIDATE, }, { /* G12 - MH offsets are considered to be dword based, therefore no down shift */ ADDR_MH_MMU_CONFIG, diff --git a/drivers/mxc/amd-gpu/include/kgsl_g12_vgv3types.h b/drivers/mxc/amd-gpu/include/kgsl_g12_vgv3types.h new file mode 100644 index 00000000000..74e5be99e12 --- /dev/null +++ b/drivers/mxc/amd-gpu/include/kgsl_g12_vgv3types.h @@ -0,0 +1,40 @@ +/* Copyright (c) 2002,2007-2010, Code Aurora Forum. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Code Aurora Forum, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#ifndef _KGSL_G12_VGV3TYPES_H +#define _KGSL_G12_VGV3TYPES_H + +#define VGV3_NEXTCMD_JUMP 0x01 + +#define VGV3_NEXTCMD_NEXTCMD_FSHIFT 12 +#define VGV3_NEXTCMD_NEXTCMD_FMASK 0x7 + +#define VGV3_CONTROL_MARKADD_FSHIFT 0 +#define VGV3_CONTROL_MARKADD_FMASK 0xfff + +#endif /* KGSL_G12_VGV3TYPES_H */ diff --git a/drivers/mxc/amd-gpu/include/yamato_reg.h b/drivers/mxc/amd-gpu/include/yamato_reg.h new file mode 100644 index 00000000000..798eac82dfe --- /dev/null +++ b/drivers/mxc/amd-gpu/include/yamato_reg.h @@ -0,0 +1,441 @@ +/* Copyright (c) 2002,2007-2009, Code Aurora Forum. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are + * met: + * * Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above + * copyright notice, this list of conditions and the following + * disclaimer in the documentation and/or other materials provided + * with the distribution. + * * Neither the name of Code Aurora Forum, Inc. nor the names of its + * contributors may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR + * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE + * OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN + * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + */ +#ifndef _YAMATO_REG_H +#define _YAMATO_REG_H + +enum VGT_EVENT_TYPE { + VS_DEALLOC = 0, + PS_DEALLOC = 1, + VS_DONE_TS = 2, + PS_DONE_TS = 3, + CACHE_FLUSH_TS = 4, + CONTEXT_DONE = 5, + CACHE_FLUSH = 6, + VIZQUERY_START = 7, + VIZQUERY_END = 8, + SC_WAIT_WC = 9, + RST_PIX_CNT = 13, + RST_VTX_CNT = 14, + TILE_FLUSH = 15, + CACHE_FLUSH_AND_INV_TS_EVENT = 20, + ZPASS_DONE = 21, + CACHE_FLUSH_AND_INV_EVENT = 22, + PERFCOUNTER_START = 23, + PERFCOUNTER_STOP = 24, + VS_FETCH_DONE = 27, + FACENESS_FLUSH = 28, +}; + +enum COLORFORMATX { + COLORX_4_4_4_4 = 0, + COLORX_1_5_5_5 = 1, + COLORX_5_6_5 = 2, + COLORX_8 = 3, + COLORX_8_8 = 4, + COLORX_8_8_8_8 = 5, + COLORX_S8_8_8_8 = 6, + COLORX_16_FLOAT = 7, + COLORX_16_16_FLOAT = 8, + COLORX_16_16_16_16_FLOAT = 9, + COLORX_32_FLOAT = 10, + COLORX_32_32_FLOAT = 11, + COLORX_32_32_32_32_FLOAT = 12, + COLORX_2_3_3 = 13, + COLORX_8_8_8 = 14, +}; + +enum SURFACEFORMAT { + FMT_1_REVERSE = 0, + FMT_1 = 1, + FMT_8 = 2, + FMT_1_5_5_5 = 3, + FMT_5_6_5 = 4, + FMT_6_5_5 = 5, + FMT_8_8_8_8 = 6, + FMT_2_10_10_10 = 7, + FMT_8_A = 8, + FMT_8_B = 9, + FMT_8_8 = 10, + FMT_Cr_Y1_Cb_Y0 = 11, + FMT_Y1_Cr_Y0_Cb = 12, + FMT_5_5_5_1 = 13, + FMT_8_8_8_8_A = 14, + FMT_4_4_4_4 = 15, + FMT_10_11_11 = 16, + FMT_11_11_10 = 17, + FMT_DXT1 = 18, + FMT_DXT2_3 = 19, + FMT_DXT4_5 = 20, + FMT_24_8 = 22, + FMT_24_8_FLOAT = 23, + FMT_16 = 24, + FMT_16_16 = 25, + FMT_16_16_16_16 = 26, + FMT_16_EXPAND = 27, + FMT_16_16_EXPAND = 28, + FMT_16_16_16_16_EXPAND = 29, + FMT_16_FLOAT = 30, + FMT_16_16_FLOAT = 31, + FMT_16_16_16_16_FLOAT = 32, + FMT_32 = 33, + FMT_32_32 = 34, + FMT_32_32_32_32 = 35, + FMT_32_FLOAT = 36, + FMT_32_32_FLOAT = 37, + FMT_32_32_32_32_FLOAT = 38, + FMT_32_AS_8 = 39, + FMT_32_AS_8_8 = 40, + FMT_16_MPEG = 41, + FMT_16_16_MPEG = 42, + FMT_8_INTERLACED = 43, + FMT_32_AS_8_INTERLACED = 44, + FMT_32_AS_8_8_INTERLACED = 45, + FMT_16_INTERLACED = 46, + FMT_16_MPEG_INTERLACED = 47, + FMT_16_16_MPEG_INTERLACED = 48, + FMT_DXN = 49, + FMT_8_8_8_8_AS_16_16_16_16 = 50, + FMT_DXT1_AS_16_16_16_16 = 51, + FMT_DXT2_3_AS_16_16_16_16 = 52, + FMT_DXT4_5_AS_16_16_16_16 = 53, + FMT_2_10_10_10_AS_16_16_16_16 = 54, + FMT_10_11_11_AS_16_16_16_16 = 55, + FMT_11_11_10_AS_16_16_16_16 = 56, + FMT_32_32_32_FLOAT = 57, + FMT_DXT3A = 58, + FMT_DXT5A = 59, + FMT_CTX1 = 60, + FMT_DXT3A_AS_1_1_1_1 = 61 +}; + +#define RB_EDRAM_INFO_EDRAM_SIZE_SIZE 4 +#define RB_EDRAM_INFO_EDRAM_MAPPING_MODE_SIZE 2 +#define RB_EDRAM_INFO_UNUSED0_SIZE 8 +#define RB_EDRAM_INFO_EDRAM_RANGE_SIZE 18 + +struct rb_edram_info_t { + unsigned int edram_size:RB_EDRAM_INFO_EDRAM_SIZE_SIZE; + unsigned int edram_mapping_mode:RB_EDRAM_INFO_EDRAM_MAPPING_MODE_SIZE; + unsigned int unused0:RB_EDRAM_INFO_UNUSED0_SIZE; + unsigned int edram_range:RB_EDRAM_INFO_EDRAM_RANGE_SIZE; +}; + +union reg_rb_edram_info { + unsigned int val; + struct rb_edram_info_t f; +}; + +#define RBBM_READ_ERROR_UNUSED0_SIZE 2 +#define RBBM_READ_ERROR_READ_ADDRESS_SIZE 15 +#define RBBM_READ_ERROR_UNUSED1_SIZE 13 +#define RBBM_READ_ERROR_READ_REQUESTER_SIZE 1 +#define RBBM_READ_ERROR_READ_ERROR_SIZE 1 + +struct rbbm_read_error_t { + unsigned int unused0:RBBM_READ_ERROR_UNUSED0_SIZE; + unsigned int read_address:RBBM_READ_ERROR_READ_ADDRESS_SIZE; + unsigned int unused1:RBBM_READ_ERROR_UNUSED1_SIZE; + unsigned int read_requester:RBBM_READ_ERROR_READ_REQUESTER_SIZE; + unsigned int read_error:RBBM_READ_ERROR_READ_ERROR_SIZE; +}; + +union rbbm_read_error_u { + unsigned int val:32; + struct rbbm_read_error_t f; +}; + +#define CP_RB_CNTL_RB_BUFSZ_SIZE 6 +#define CP_RB_CNTL_UNUSED0_SIZE 2 +#define CP_RB_CNTL_RB_BLKSZ_SIZE 6 +#define CP_RB_CNTL_UNUSED1_SIZE 2 +#define CP_RB_CNTL_BUF_SWAP_SIZE 2 +#define CP_RB_CNTL_UNUSED2_SIZE 2 +#define CP_RB_CNTL_RB_POLL_EN_SIZE 1 +#define CP_RB_CNTL_UNUSED3_SIZE 6 +#define CP_RB_CNTL_RB_NO_UPDATE_SIZE 1 +#define CP_RB_CNTL_UNUSED4_SIZE 3 +#define CP_RB_CNTL_RB_RPTR_WR_ENA_SIZE 1 + +struct cp_rb_cntl_t { + unsigned int rb_bufsz:CP_RB_CNTL_RB_BUFSZ_SIZE; + unsigned int unused0:CP_RB_CNTL_UNUSED0_SIZE; + unsigned int rb_blksz:CP_RB_CNTL_RB_BLKSZ_SIZE; + unsigned int unused1:CP_RB_CNTL_UNUSED1_SIZE; + unsigned int buf_swap:CP_RB_CNTL_BUF_SWAP_SIZE; + unsigned int unused2:CP_RB_CNTL_UNUSED2_SIZE; + unsigned int rb_poll_en:CP_RB_CNTL_RB_POLL_EN_SIZE; + unsigned int unused3:CP_RB_CNTL_UNUSED3_SIZE; + unsigned int rb_no_update:CP_RB_CNTL_RB_NO_UPDATE_SIZE; + unsigned int unused4:CP_RB_CNTL_UNUSED4_SIZE; + unsigned int rb_rptr_wr_ena:CP_RB_CNTL_RB_RPTR_WR_ENA_SIZE; +}; + +union reg_cp_rb_cntl { + unsigned int val:32; + struct cp_rb_cntl_t f; +}; + +#define RB_COLOR_INFO__COLOR_FORMAT_MASK 0x0000000fL +#define RB_COPY_DEST_INFO__COPY_DEST_FORMAT__SHIFT 0x00000004 + + +#define SQ_INT_CNTL__PS_WATCHDOG_MASK 0x00000001L +#define SQ_INT_CNTL__VS_WATCHDOG_MASK 0x00000002L + +#define MH_INTERRUPT_MASK__AXI_READ_ERROR 0x00000001L +#define MH_INTERRUPT_MASK__AXI_WRITE_ERROR 0x00000002L +#define MH_INTERRUPT_MASK__MMU_PAGE_FAULT 0x00000004L + +#define RBBM_INT_CNTL__RDERR_INT_MASK 0x00000001L +#define RBBM_INT_CNTL__DISPLAY_UPDATE_INT_MASK 0x00000002L +#define RBBM_INT_CNTL__GUI_IDLE_INT_MASK 0x00080000L + +#define RBBM_STATUS__CMDFIFO_AVAIL_MASK 0x0000001fL +#define RBBM_STATUS__TC_BUSY_MASK 0x00000020L +#define RBBM_STATUS__HIRQ_PENDING_MASK 0x00000100L +#define RBBM_STATUS__CPRQ_PENDING_MASK 0x00000200L +#define RBBM_STATUS__CFRQ_PENDING_MASK 0x00000400L +#define RBBM_STATUS__PFRQ_PENDING_MASK 0x00000800L +#define RBBM_STATUS__VGT_BUSY_NO_DMA_MASK 0x00001000L +#define RBBM_STATUS__RBBM_WU_BUSY_MASK 0x00004000L +#define RBBM_STATUS__CP_NRT_BUSY_MASK 0x00010000L +#define RBBM_STATUS__MH_BUSY_MASK 0x00040000L +#define RBBM_STATUS__MH_COHERENCY_BUSY_MASK 0x00080000L +#define RBBM_STATUS__SX_BUSY_MASK 0x00200000L +#define RBBM_STATUS__TPC_BUSY_MASK 0x00400000L +#define RBBM_STATUS__SC_CNTX_BUSY_MASK 0x01000000L +#define RBBM_STATUS__PA_BUSY_MASK 0x02000000L +#define RBBM_STATUS__VGT_BUSY_MASK 0x04000000L +#define RBBM_STATUS__SQ_CNTX17_BUSY_MASK 0x08000000L +#define RBBM_STATUS__SQ_CNTX0_BUSY_MASK 0x10000000L +#define RBBM_STATUS__RB_CNTX_BUSY_MASK 0x40000000L +#define RBBM_STATUS__GUI_ACTIVE_MASK 0x80000000L + +#define CP_INT_CNTL__SW_INT_MASK 0x00080000L +#define CP_INT_CNTL__T0_PACKET_IN_IB_MASK 0x00800000L +#define CP_INT_CNTL__OPCODE_ERROR_MASK 0x01000000L +#define CP_INT_CNTL__PROTECTED_MODE_ERROR_MASK 0x02000000L +#define CP_INT_CNTL__RESERVED_BIT_ERROR_MASK 0x04000000L +#define CP_INT_CNTL__IB_ERROR_MASK 0x08000000L +#define CP_INT_CNTL__IB2_INT_MASK 0x20000000L +#define CP_INT_CNTL__IB1_INT_MASK 0x40000000L +#define CP_INT_CNTL__RB_INT_MASK 0x80000000L + +#define MASTER_INT_SIGNAL__MH_INT_STAT 0x00000020L +#define MASTER_INT_SIGNAL__SQ_INT_STAT 0x04000000L +#define MASTER_INT_SIGNAL__CP_INT_STAT 0x40000000L +#define MASTER_INT_SIGNAL__RBBM_INT_STAT 0x80000000L + +#define RB_EDRAM_INFO__EDRAM_SIZE_MASK 0x0000000fL +#define RB_EDRAM_INFO__EDRAM_RANGE_MASK 0xffffc000L + +#define MH_ARBITER_CONFIG__SAME_PAGE_GRANULARITY__SHIFT 0x00000006 +#define MH_ARBITER_CONFIG__L1_ARB_ENABLE__SHIFT 0x00000007 +#define MH_ARBITER_CONFIG__L1_ARB_HOLD_ENABLE__SHIFT 0x00000008 +#define MH_ARBITER_CONFIG__L2_ARB_CONTROL__SHIFT 0x00000009 +#define MH_ARBITER_CONFIG__PAGE_SIZE__SHIFT 0x0000000a +#define MH_ARBITER_CONFIG__TC_REORDER_ENABLE__SHIFT 0x0000000d +#define MH_ARBITER_CONFIG__TC_ARB_HOLD_ENABLE__SHIFT 0x0000000e +#define MH_ARBITER_CONFIG__IN_FLIGHT_LIMIT_ENABLE__SHIFT 0x0000000f +#define MH_ARBITER_CONFIG__IN_FLIGHT_LIMIT__SHIFT 0x00000010 +#define MH_ARBITER_CONFIG__CP_CLNT_ENABLE__SHIFT 0x00000016 +#define MH_ARBITER_CONFIG__VGT_CLNT_ENABLE__SHIFT 0x00000017 +#define MH_ARBITER_CONFIG__TC_CLNT_ENABLE__SHIFT 0x00000018 +#define MH_ARBITER_CONFIG__RB_CLNT_ENABLE__SHIFT 0x00000019 +#define MH_ARBITER_CONFIG__PA_CLNT_ENABLE__SHIFT 0x0000001a + +#define MH_MMU_CONFIG__RB_W_CLNT_BEHAVIOR__SHIFT 0x00000004 +#define MH_MMU_CONFIG__CP_W_CLNT_BEHAVIOR__SHIFT 0x00000006 +#define MH_MMU_CONFIG__CP_R0_CLNT_BEHAVIOR__SHIFT 0x00000008 +#define MH_MMU_CONFIG__CP_R1_CLNT_BEHAVIOR__SHIFT 0x0000000a +#define MH_MMU_CONFIG__CP_R2_CLNT_BEHAVIOR__SHIFT 0x0000000c +#define MH_MMU_CONFIG__CP_R3_CLNT_BEHAVIOR__SHIFT 0x0000000e +#define MH_MMU_CONFIG__CP_R4_CLNT_BEHAVIOR__SHIFT 0x00000010 +#define MH_MMU_CONFIG__VGT_R0_CLNT_BEHAVIOR__SHIFT 0x00000012 +#define MH_MMU_CONFIG__VGT_R1_CLNT_BEHAVIOR__SHIFT 0x00000014 +#define MH_MMU_CONFIG__TC_R_CLNT_BEHAVIOR__SHIFT 0x00000016 +#define MH_MMU_CONFIG__PA_W_CLNT_BEHAVIOR__SHIFT 0x00000018 + +#define CP_RB_CNTL__RB_BUFSZ__SHIFT 0x00000000 +#define CP_RB_CNTL__RB_BLKSZ__SHIFT 0x00000008 +#define CP_RB_CNTL__RB_POLL_EN__SHIFT 0x00000014 +#define CP_RB_CNTL__RB_NO_UPDATE__SHIFT 0x0000001b + +#define RB_COLOR_INFO__COLOR_FORMAT__SHIFT 0x00000000 +#define RB_EDRAM_INFO__EDRAM_MAPPING_MODE__SHIFT 0x00000004 +#define RB_EDRAM_INFO__EDRAM_RANGE__SHIFT 0x0000000e + +#define REG_CP_CSQ_IB1_STAT 0x01FE +#define REG_CP_CSQ_IB2_STAT 0x01FF +#define REG_CP_CSQ_RB_STAT 0x01FD +#define REG_CP_DEBUG 0x01FC +#define REG_CP_IB1_BASE 0x0458 +#define REG_CP_IB1_BUFSZ 0x0459 +#define REG_CP_IB2_BASE 0x045A +#define REG_CP_IB2_BUFSZ 0x045B +#define REG_CP_INT_ACK 0x01F4 +#define REG_CP_INT_CNTL 0x01F2 +#define REG_CP_INT_STATUS 0x01F3 +#define REG_CP_ME_CNTL 0x01F6 +#define REG_CP_ME_RAM_DATA 0x01FA +#define REG_CP_ME_RAM_WADDR 0x01F8 +#define REG_CP_ME_STATUS 0x01F7 +#define REG_CP_PFP_UCODE_ADDR 0x00C0 +#define REG_CP_PFP_UCODE_DATA 0x00C1 +#define REG_CP_QUEUE_THRESHOLDS 0x01D5 +#define REG_CP_RB_BASE 0x01C0 +#define REG_CP_RB_CNTL 0x01C1 +#define REG_CP_RB_RPTR 0x01C4 +#define REG_CP_RB_RPTR_ADDR 0x01C3 +#define REG_CP_RB_RPTR_WR 0x01C7 +#define REG_CP_RB_WPTR 0x01C5 +#define REG_CP_RB_WPTR_BASE 0x01C8 +#define REG_CP_RB_WPTR_DELAY 0x01C6 +#define REG_CP_STAT 0x047F +#define REG_CP_STATE_DEBUG_DATA 0x01ED +#define REG_CP_STATE_DEBUG_INDEX 0x01EC +#define REG_CP_ST_BASE 0x044D +#define REG_CP_ST_BUFSZ 0x044E + +#define REG_MASTER_INT_SIGNAL 0x03B7 + +#define REG_MH_ARBITER_CONFIG 0x0A40 +#define REG_MH_INTERRUPT_CLEAR 0x0A44 +#define REG_MH_INTERRUPT_MASK 0x0A42 +#define REG_MH_INTERRUPT_STATUS 0x0A43 +#define REG_MH_MMU_CONFIG 0x0040 +#define REG_MH_MMU_INVALIDATE 0x0045 +#define REG_MH_MMU_MPU_BASE 0x0046 +#define REG_MH_MMU_MPU_END 0x0047 +#define REG_MH_MMU_PAGE_FAULT 0x0043 +#define REG_MH_MMU_PT_BASE 0x0042 +#define REG_MH_MMU_TRAN_ERROR 0x0044 +#define REG_MH_MMU_VA_RANGE 0x0041 +#define REG_MH_CLNT_INTF_CTRL_CONFIG1 0x0A54 +#define REG_MH_CLNT_INTF_CTRL_CONFIG2 0x0A55 + +#define REG_PA_CL_VPORT_XSCALE 0x210F +#define REG_PA_CL_VPORT_ZOFFSET 0x2114 +#define REG_PA_CL_VPORT_ZSCALE 0x2113 +#define REG_RA_CL_CLIP_CNTL 0x2204 +#define REG_PA_CL_VTE_CNTL 0x2206 +#define REG_PA_SC_AA_MASK 0x2312 +#define REG_PA_SC_LINE_CNTL 0x2300 +#define REG_PA_SC_SCREEN_SCISSOR_BR 0x200F +#define REG_PA_SC_SCREEN_SCISSOR_TL 0x200E +#define REG_PA_SC_VIZ_QUERY 0x2293 +#define REG_PA_SC_VIZ_QUERY_STATUS 0x0C44 +#define REG_PA_SC_WINDOW_OFFSET 0x2080 +#define REG_PA_SC_WINDOW_SCISSOR_BR 0x2082 +#define REG_PA_SC_WINDOW_SCISSOR_TL 0x2081 +#define REG_PA_SU_FACE_DATA 0x0C86 +#define REG_PA_SU_POINT_SIZE 0x2280 +#define REG_PA_SU_LINE_CNTL 0x2282 +#define REG_PA_SU_POLY_OFFSET_BACK_OFFSET 0x2383 +#define REG_PA_SU_POLY_OFFSET_FRONT_SCALE 0x2380 +#define REG_PA_SU_SC_MODE_CNTL 0x2205 + +#define REG_PC_INDEX_OFFSET 0x2102 + +#define REG_RBBM_CNTL 0x003B +#define REG_RBBM_INT_ACK 0x03B6 +#define REG_RBBM_INT_CNTL 0x03B4 +#define REG_RBBM_INT_STATUS 0x03B5 +#define REG_RBBM_PATCH_RELEASE 0x0001 +#define REG_RBBM_PERIPHID1 0x03F9 +#define REG_RBBM_PERIPHID2 0x03FA +#define REG_RBBM_DEBUG 0x039B +#define REG_RBBM_PM_OVERRIDE1 0x039C +#define REG_RBBM_PM_OVERRIDE2 0x039D +#define REG_RBBM_READ_ERROR 0x03B3 +#define REG_RBBM_SOFT_RESET 0x003C +#define REG_RBBM_STATUS 0x05D0 + +#define REG_RB_COLORCONTROL 0x2202 +#define REG_RB_COLOR_DEST_MASK 0x2326 +#define REG_RB_COLOR_MASK 0x2104 +#define REG_RB_COPY_CONTROL 0x2318 +#define REG_RB_DEPTHCONTROL 0x2200 +#define REG_RB_EDRAM_INFO 0x0F02 +#define REG_RB_MODECONTROL 0x2208 +#define REG_RB_SURFACE_INFO 0x2000 +#define REG_RB_SAMPLE_POS 0x220a + +#define REG_SCRATCH_ADDR 0x01DD +#define REG_SCRATCH_REG0 0x0578 +#define REG_CP_TIMESTAMP REG_SCRATCH_REG0 // hack for fsl/qcom compat +#define REG_SCRATCH_REG2 0x057A +#define REG_SCRATCH_REG7 0x057F // fsl +#define REG_SCRATCH_UMSK 0x01DC + +#define REG_SQ_CF_BOOLEANS 0x4900 +#define REG_SQ_CF_LOOP 0x4908 +#define REG_SQ_GPR_MANAGEMENT 0x0D00 +#define REG_SQ_INST_STORE_MANAGMENT 0x0D02 +#define REG_SQ_INT_ACK 0x0D36 +#define REG_SQ_INT_CNTL 0x0D34 +#define REG_SQ_INT_STATUS 0x0D35 +#define REG_SQ_PROGRAM_CNTL 0x2180 +#define REG_SQ_PS_PROGRAM 0x21F6 +#define REG_SQ_VS_PROGRAM 0x21F7 +#define REG_SQ_WRAPPING_0 0x2183 +#define REG_SQ_WRAPPING_1 0x2184 + +#define REG_VGT_ENHANCE 0x2294 +#define REG_VGT_INDX_OFFSET 0x2102 +#define REG_VGT_MAX_VTX_INDX 0x2100 +#define REG_VGT_MIN_VTX_INDX 0x2101 + +#define REG_TP0_CHICKEN 0x0E1E +#define REG_TC_CNTL_STATUS 0x0E00 +#define REG_PA_SC_AA_CONFIG 0x2301 +#define REG_VGT_VERTEX_REUSE_BLOCK_CNTL 0x2316 +#define REG_SQ_INTERPOLATOR_CNTL 0x2182 +#define REG_RB_DEPTH_INFO 0x2002 +#define REG_COHER_DEST_BASE_0 0x2006 +#define REG_PA_SC_SCREEN_SCISSOR_BR 0x200F +#define REG_RB_FOG_COLOR 0x2109 +#define REG_RB_STENCILREFMASK_BF 0x210C +#define REG_PA_SC_LINE_STIPPLE 0x2283 +#define REG_SQ_PS_CONST 0x2308 +#define REG_VGT_VERTEX_REUSE_BLOCK_CNTL 0x2316 +#define REG_RB_DEPTH_CLEAR 0x231D +#define REG_RB_SAMPLE_COUNT_CTL 0x2324 +#define REG_SQ_CONSTANT_0 0x4000 +#define REG_SQ_FETCH_0 0x4800 + +#define REG_MH_AXI_ERROR 0xA45 +#define REG_COHER_BASE_PM4 0xA2A +#define REG_COHER_STATUS_PM4 0xA2B +#define REG_COHER_SIZE_PM4 0xA29 + +#define REG_WAIT_UNTIL 0x05C8 //fsl +#define REG_RBBM_DSPLY 0x0391//fsl +#define REG_RBBM_RENDER_LATEST 0x0392//fsl +#endif /* _YAMATO_REG_H */ diff --git a/drivers/mxc/amd-gpu/kgsl_cmdstream.c b/drivers/mxc/amd-gpu/kgsl_cmdstream.c index 96cb5459f70..aafa6670016 100644 --- a/drivers/mxc/amd-gpu/kgsl_cmdstream.c +++ b/drivers/mxc/amd-gpu/kgsl_cmdstream.c @@ -22,6 +22,7 @@ #include "gsl.h" #include "gsl_hal.h" #include "gsl_cmdstream.h" +#include "kgsl_g12_vgv3types.h" // functions diff --git a/drivers/mxc/amd-gpu/kgsl_drawctxt.c b/drivers/mxc/amd-gpu/kgsl_drawctxt.c index 41123cdc204..e2f18d5b372 100644 --- a/drivers/mxc/amd-gpu/kgsl_drawctxt.c +++ b/drivers/mxc/amd-gpu/kgsl_drawctxt.c @@ -21,6 +21,7 @@ #include "gsl.h" #include "gsl_hal.h" +#include "kgsl_g12_vgv3types.h" ////////////////////////////////////////////////////////////////////////////// // @@ -371,7 +372,7 @@ static unsigned int gmem_copy_texcoord[TEXCOORD_LEN] = { #define NUM_COLOR_FORMATS 13 -static SurfaceFormat surface_format_table[NUM_COLOR_FORMATS] = +static enum SURFACEFORMAT surface_format_table[NUM_COLOR_FORMATS] = { FMT_4_4_4_4, // COLORX_4_4_4_4 FMT_1_5_5_5, // COLORX_1_5_5_5 @@ -532,7 +533,7 @@ build_chicken_restore_cmds(gsl_drawctxt_t *drawctxt, ctx_t *ctx) *cmds++ = pm4_type3_packet(PM4_WAIT_FOR_IDLE, 1); *cmds++ = 0; - *cmds++ = pm4_type0_packet(mmTP0_CHICKEN, 1); + *cmds++ = pm4_type0_packet(REG_TP0_CHICKEN, 1); ctx->chicken_restore = gpuaddr(cmds, &drawctxt->gpustate); *cmds++ = 0x00000000; @@ -563,26 +564,26 @@ build_regsave_cmds(gsl_drawctxt_t *drawctxt, ctx_t *ctx) #ifdef DISABLE_SHADOW_WRITES // Write HW registers into shadow - build_reg_to_mem_range(mmRB_SURFACE_INFO, mmRB_DEPTH_INFO, &cmd, drawctxt); - build_reg_to_mem_range(mmCOHER_DEST_BASE_0, mmPA_SC_SCREEN_SCISSOR_BR, &cmd, drawctxt); - build_reg_to_mem_range(mmPA_SC_WINDOW_OFFSET, mmPA_SC_WINDOW_SCISSOR_BR, &cmd, drawctxt); - build_reg_to_mem_range(mmVGT_MAX_VTX_INDX, mmRB_FOG_COLOR, &cmd, drawctxt); - build_reg_to_mem_range(mmRB_STENCILREFMASK_BF, mmPA_CL_VPORT_ZOFFSET, &cmd, drawctxt); - build_reg_to_mem_range(mmSQ_PROGRAM_CNTL, mmSQ_WRAPPING_1, &cmd, drawctxt); - build_reg_to_mem_range(mmRB_DEPTHCONTROL, mmRB_MODECONTROL, &cmd, drawctxt); - build_reg_to_mem_range(mmPA_SU_POINT_SIZE, mmPA_SC_LINE_STIPPLE, &cmd, drawctxt); - build_reg_to_mem_range(mmPA_SC_VIZ_QUERY, mmPA_SC_VIZ_QUERY, &cmd, drawctxt); - build_reg_to_mem_range(mmPA_SC_LINE_CNTL, mmSQ_PS_CONST, &cmd, drawctxt); - build_reg_to_mem_range(mmPA_SC_AA_MASK, mmPA_SC_AA_MASK, &cmd, drawctxt); - build_reg_to_mem_range(mmVGT_VERTEX_REUSE_BLOCK_CNTL, mmRB_DEPTH_CLEAR, &cmd, drawctxt); - build_reg_to_mem_range(mmRB_SAMPLE_COUNT_CTL, mmRB_COLOR_DEST_MASK, &cmd, drawctxt); - build_reg_to_mem_range(mmPA_SU_POLY_OFFSET_FRONT_SCALE, mmPA_SU_POLY_OFFSET_BACK_OFFSET, &cmd, drawctxt); + build_reg_to_mem_range(REG_RB_SURFACE_INFO, REG_RB_DEPTH_INFO, &cmd, drawctxt); + build_reg_to_mem_range(REG_COHER_DEST_BASE_0, REG_PA_SC_SCREEN_SCISSOR_BR, &cmd, drawctxt); + build_reg_to_mem_range(REG_PA_SC_WINDOW_OFFSET, REG_PA_SC_WINDOW_SCISSOR_BR, &cmd, drawctxt); + build_reg_to_mem_range(REG_VGT_MAX_VTX_INDX, REG_RB_FOG_COLOR, &cmd, drawctxt); + build_reg_to_mem_range(REG_RB_STENCILREFMASK_BF, REG_PA_CL_VPORT_ZOFFSET, &cmd, drawctxt); + build_reg_to_mem_range(REG_SQ_PROGRAM_CNTL, REG_SQ_WRAPPING_1, &cmd, drawctxt); + build_reg_to_mem_range(REG_RB_DEPTHCONTROL, REG_RB_MODECONTROL, &cmd, drawctxt); + build_reg_to_mem_range(REG_PA_SU_POINT_SIZE, REG_PA_SC_LINE_STIPPLE, &cmd, drawctxt); + build_reg_to_mem_range(REG_PA_SC_VIZ_QUERY, REG_PA_SC_VIZ_QUERY, &cmd, drawctxt); + build_reg_to_mem_range(REG_PA_SC_LINE_CNTL, REG_SQ_PS_CONST, &cmd, drawctxt); + build_reg_to_mem_range(REG_PA_SC_AA_MASK, REG_PA_SC_AA_MASK, &cmd, drawctxt); + build_reg_to_mem_range(REG_VGT_VERTEX_REUSE_BLOCK_CNTL, REG_RB_DEPTH_CLEAR, &cmd, drawctxt); + build_reg_to_mem_range(REG_RB_SAMPLE_COUNT_CTL, REG_RB_COLOR_DEST_MASK, &cmd, drawctxt); + build_reg_to_mem_range(REG_PA_SU_POLY_OFFSET_FRONT_SCALE, REG_PA_SU_POLY_OFFSET_BACK_OFFSET, &cmd, drawctxt); // Copy ALU constants - cmd = reg_to_mem(cmd, (drawctxt->gpustate.gpuaddr) & 0xFFFFE000, mmSQ_CONSTANT_0, ALU_CONSTANTS); + cmd = reg_to_mem(cmd, (drawctxt->gpustate.gpuaddr) & 0xFFFFE000, REG_SQ_CONSTANT_0, ALU_CONSTANTS); // Copy Tex constants - cmd = reg_to_mem(cmd, (drawctxt->gpustate.gpuaddr + TEX_OFFSET) & 0xFFFFE000, mmSQ_FETCH_0, TEX_CONSTANTS); + cmd = reg_to_mem(cmd, (drawctxt->gpustate.gpuaddr + TEX_OFFSET) & 0xFFFFE000, REG_SQ_FETCH_0, TEX_CONSTANTS); #else // insert a wait for idle (adreno.c:542 from qualcomm kernel) // *cmd++ = pm4_type3_packet(PM4_WAIT_FOR_IDLE, 1); @@ -612,17 +613,17 @@ build_regsave_cmds(gsl_drawctxt_t *drawctxt, ctx_t *ctx) // Need to handle some of the registers separately *cmd++ = pm4_type3_packet(PM4_REG_TO_MEM, 2); - *cmd++ = mmSQ_GPR_MANAGEMENT; + *cmd++ = REG_SQ_GPR_MANAGEMENT; *cmd++ = ctx->reg_values[0]; *cmd++ = pm4_type3_packet(PM4_REG_TO_MEM, 2); - *cmd++ = mmTP0_CHICKEN; + *cmd++ = REG_TP0_CHICKEN; *cmd++ = ctx->reg_values[1]; // Copy Boolean constants - cmd = reg_to_mem(cmd, ctx->bool_shadow, mmSQ_CF_BOOLEANS, BOOL_CONSTANTS); + cmd = reg_to_mem(cmd, ctx->bool_shadow, REG_SQ_CF_BOOLEANS, BOOL_CONSTANTS); // Copy Loop constants - cmd = reg_to_mem(cmd, ctx->loop_shadow, mmSQ_CF_LOOP, LOOP_CONSTANTS); + cmd = reg_to_mem(cmd, ctx->loop_shadow, REG_SQ_CF_LOOP, LOOP_CONSTANTS); // create indirect buffer command for above command sequence create_ib1(drawctxt, drawctxt->reg_save, start, cmd); @@ -643,7 +644,7 @@ build_gmem2sys_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) // Store TP0_CHICKEN register *cmds++ = pm4_type3_packet(PM4_REG_TO_MEM, 2); - *cmds++ = mmTP0_CHICKEN; + *cmds++ = REG_TP0_CHICKEN; if( ctx ) *cmds++ = ctx->chicken_restore; else @@ -653,11 +654,11 @@ build_gmem2sys_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) *cmds++ = 0; // Set TP0_CHICKEN to zero - *cmds++ = pm4_type0_packet(mmTP0_CHICKEN, 1); + *cmds++ = pm4_type0_packet(REG_TP0_CHICKEN, 1); *cmds++ = 0x00000000; /* Set PA_SC_AA_CONFIG to 0 - from Qualcomm*/ - //*cmds++ = pm4_type0_packet(mmPA_SC_AA_CONFIG, 1); + //*cmds++ = pm4_type0_packet(REG_PA_SC_AA_CONFIG, 1); //*cmds++ = 0x00000000; // -------------- @@ -672,18 +673,18 @@ build_gmem2sys_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) *cmds++ = 0x00000030; // limit = 12 dwords // Invalidate L2 cache to make sure vertices are updated - *cmds++ = pm4_type0_packet(mmTC_CNTL_STATUS, 1); + *cmds++ = pm4_type0_packet(REG_TC_CNTL_STATUS, 1); *cmds++ = 0x1; *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 4); - *cmds++ = PM4_REG(mmVGT_MAX_VTX_INDX); - *cmds++ = 0x00ffffff; //mmVGT_MAX_VTX_INDX - *cmds++ = 0x0; //mmVGT_MIN_VTX_INDX - *cmds++ = 0x00000000; //mmVGT_INDX_OFFSET + *cmds++ = PM4_REG(REG_VGT_MAX_VTX_INDX); + *cmds++ = 0x00ffffff; //REG_VGT_MAX_VTX_INDX + *cmds++ = 0x0; //REG_VGT_MIN_VTX_INDX + *cmds++ = 0x00000000; //REG_VGT_INDX_OFFSET *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmPA_SC_AA_MASK); - *cmds++ = 0x0000ffff; //mmPA_SC_AA_MASK + *cmds++ = PM4_REG(REG_PA_SC_AA_MASK); + *cmds++ = 0x0000ffff; //REG_PA_SC_AA_MASK // load the patched vertex shader stream @@ -694,7 +695,7 @@ build_gmem2sys_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) // SQ_PROGRAM_CNTL / SQ_CONTEXT_MISC *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmSQ_PROGRAM_CNTL); + *cmds++ = PM4_REG(REG_SQ_PROGRAM_CNTL); *cmds++ = 0x10010001; *cmds++ = 0x00000008; @@ -705,12 +706,12 @@ build_gmem2sys_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) // PA_CL_VTE_CNTL *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmPA_CL_VTE_CNTL); + *cmds++ = PM4_REG(REG_PA_CL_VTE_CNTL); *cmds++ = 0x00000b00; // disable X/Y/Z transforms, X/Y/Z are premultiplied by W // change colour buffer to RGBA8888, MSAA = 1, and matching pitch *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmRB_SURFACE_INFO); + *cmds++ = PM4_REG(REG_RB_SURFACE_INFO); *cmds++ = shadow->gmem_pitch; // RB_COLOR_INFO Endian=none, Linear, Format=RGBA8888, Swap=0, Base=gmem_base @@ -727,36 +728,36 @@ build_gmem2sys_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) // disable Z *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmRB_DEPTHCONTROL); + *cmds++ = PM4_REG(REG_RB_DEPTHCONTROL); *cmds++ = 0; - // set mmPA_SU_SC_MODE_CNTL + // set REG_PA_SU_SC_MODE_CNTL // Front_ptype = draw triangles // Back_ptype = draw triangles // Provoking vertex = last *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmPA_SU_SC_MODE_CNTL); + *cmds++ = PM4_REG(REG_PA_SU_SC_MODE_CNTL); *cmds++ = 0x00080240; // set the scissor to the extents of the draw surface *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmPA_SC_SCREEN_SCISSOR_TL); + *cmds++ = PM4_REG(REG_PA_SC_SCREEN_SCISSOR_TL); *cmds++ = (shadow->gmem_offset_y << 16) | shadow->gmem_offset_x; *cmds++ = (shadow->gmem_height << 16) | shadow->gmem_width; *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmPA_SC_WINDOW_SCISSOR_TL); + *cmds++ = PM4_REG(REG_PA_SC_WINDOW_SCISSOR_TL); *cmds++ = (1U << 31) | (0 << 16) | 0; *cmds++ = (shadow->height << 16) | shadow->width; // load the viewport so that z scale = clear depth and z offset = 0.0f *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmPA_CL_VPORT_ZSCALE); + *cmds++ = PM4_REG(REG_PA_CL_VPORT_ZSCALE); *cmds++ = 0xbf800000; // -1.0f *cmds++ = 0x0; // load the COPY state *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 6); - *cmds++ = PM4_REG(mmRB_COPY_CONTROL); + *cmds++ = PM4_REG(REG_RB_COPY_CONTROL); *cmds++ = 0; // RB_COPY_CONTROL { @@ -774,12 +775,12 @@ build_gmem2sys_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) } *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmRB_MODECONTROL); + *cmds++ = PM4_REG(REG_RB_MODECONTROL); *cmds++ = 0x6; // EDRAM copy // gleaned from qualcomm source //*cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - //*cmds++ = PM4_REG(mmPA_CL_CLIP_CNTL); + //*cmds++ = PM4_REG(REG_PA_CL_CLIP_CNTL); //*cmds++ = 0x00010000; // queue the draw packet @@ -811,7 +812,7 @@ build_sys2gmem_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) // Store TP0_CHICKEN register *cmds++ = pm4_type3_packet(PM4_REG_TO_MEM, 2); - *cmds++ = mmTP0_CHICKEN; + *cmds++ = REG_TP0_CHICKEN; if( ctx ) *cmds++ = ctx->chicken_restore; else @@ -821,11 +822,11 @@ build_sys2gmem_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) *cmds++ = 0; // Set TP0_CHICKEN to zero - *cmds++ = pm4_type0_packet(mmTP0_CHICKEN, 1); + *cmds++ = pm4_type0_packet(REG_TP0_CHICKEN, 1); *cmds++ = 0x00000000; /* Set PA_SC_AA_CONFIG to 0 */ - //*cmds++ = pm4_type0_packet(mmPA_SC_AA_CONFIG, 1); + //*cmds++ = pm4_type0_packet(REG_PA_SC_AA_CONFIG, 1); //*cmds++ = 0x00000000; // ---------------- @@ -844,7 +845,7 @@ build_sys2gmem_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) *cmds++ = 0; // Invalidate L2 cache to make sure vertices and texture coordinates are updated - *cmds++ = pm4_type0_packet(mmTC_CNTL_STATUS, 1); + *cmds++ = pm4_type0_packet(REG_TC_CNTL_STATUS, 1); *cmds++ = 0x1; // load the patched vertex shader stream @@ -855,50 +856,50 @@ build_sys2gmem_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) // SQ_PROGRAM_CNTL / SQ_CONTEXT_MISC *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmSQ_PROGRAM_CNTL); + *cmds++ = PM4_REG(REG_SQ_PROGRAM_CNTL); *cmds++ = 0x10030002; *cmds++ = 0x00000008; *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmPA_SC_AA_MASK); - *cmds++ = 0x0000ffff; //mmPA_SC_AA_MASK + *cmds++ = PM4_REG(REG_PA_SC_AA_MASK); + *cmds++ = 0x0000ffff; //REG_PA_SC_AA_MASK *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmPA_SC_VIZ_QUERY); - *cmds++ = 0x0; //mmPA_SC_VIZ_QUERY + *cmds++ = PM4_REG(REG_PA_SC_VIZ_QUERY); + *cmds++ = 0x0; //REG_PA_SC_VIZ_QUERY *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmRB_COLORCONTROL); + *cmds++ = PM4_REG(REG_RB_COLORCONTROL); *cmds++ = 0x00000c20; // RB_COLORCONTROL *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 4); - *cmds++ = PM4_REG(mmVGT_MAX_VTX_INDX); - *cmds++ = 0x00ffffff; //mmVGT_MAX_VTX_INDX - *cmds++ = 0x0; //mmVGT_MIN_VTX_INDX - *cmds++ = 0x00000000; //mmVGT_INDX_OFFSET + *cmds++ = PM4_REG(REG_VGT_MAX_VTX_INDX); + *cmds++ = 0x00ffffff; //REG_VGT_MAX_VTX_INDX + *cmds++ = 0x0; //REG_VGT_MIN_VTX_INDX + *cmds++ = 0x00000000; //REG_VGT_INDX_OFFSET *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmVGT_VERTEX_REUSE_BLOCK_CNTL); - *cmds++ = 0x00000002; //mmVGT_VERTEX_REUSE_BLOCK_CNTL - *cmds++ = 0x00000002; //mmVGT_OUT_DEALLOC_CNTL + *cmds++ = PM4_REG(REG_VGT_VERTEX_REUSE_BLOCK_CNTL); + *cmds++ = 0x00000002; //REG_VGT_VERTEX_REUSE_BLOCK_CNTL + *cmds++ = 0x00000002; //REG_VGT_OUT_DEALLOC_CNTL *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmSQ_INTERPOLATOR_CNTL); - *cmds++ = 0xffffffff; //mmSQ_INTERPOLATOR_CNTL + *cmds++ = PM4_REG(REG_SQ_INTERPOLATOR_CNTL); + *cmds++ = 0xffffffff; //REG_SQ_INTERPOLATOR_CNTL *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmPA_SC_AA_CONFIG); - *cmds++ = 0x00000000; //mmPA_SC_AA_CONFIG + *cmds++ = PM4_REG(REG_PA_SC_AA_CONFIG); + *cmds++ = 0x00000000; //REG_PA_SC_AA_CONFIG - // set mmPA_SU_SC_MODE_CNTL + // set REG_PA_SU_SC_MODE_CNTL // Front_ptype = draw triangles // Back_ptype = draw triangles // Provoking vertex = last *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmPA_SU_SC_MODE_CNTL); + *cmds++ = PM4_REG(REG_PA_SU_SC_MODE_CNTL); *cmds++ = 0x00080240; // texture constants @@ -912,7 +913,7 @@ build_sys2gmem_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) // change colour buffer to RGBA8888, MSAA = 1, and matching pitch *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmRB_SURFACE_INFO); + *cmds++ = PM4_REG(REG_RB_SURFACE_INFO); *cmds++ = shadow->gmem_pitch; // GMEM pitch is equal to context GMEM shadow pitch // RB_COLOR_INFO Endian=none, Linear, Format=RGBA8888, Swap=0, Base=gmem_base @@ -928,45 +929,45 @@ build_sys2gmem_cmds(gsl_drawctxt_t *drawctxt, ctx_t* ctx, gmem_shadow_t *shadow) // RB_DEPTHCONTROL *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmRB_DEPTHCONTROL); + *cmds++ = PM4_REG(REG_RB_DEPTHCONTROL); *cmds++ = 0; // disable Z // set the scissor to the extents of the draw surface *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmPA_SC_SCREEN_SCISSOR_TL); + *cmds++ = PM4_REG(REG_PA_SC_SCREEN_SCISSOR_TL); *cmds++ = (0 << 16) | 0; *cmds++ = (shadow->height << 16) | shadow->width; *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmPA_SC_WINDOW_SCISSOR_TL); + *cmds++ = PM4_REG(REG_PA_SC_WINDOW_SCISSOR_TL); *cmds++ = (1U << 31) | (shadow->gmem_offset_y << 16) | shadow->gmem_offset_x; *cmds++ = (shadow->gmem_height << 16) | shadow->gmem_width; // PA_CL_VTE_CNTL *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmPA_CL_VTE_CNTL); + *cmds++ = PM4_REG(REG_PA_CL_VTE_CNTL); *cmds++ = 0x00000b00; // disable X/Y/Z transforms, X/Y/Z are premultiplied by W // load the viewport so that z scale = clear depth and z offset = 0.0f *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmPA_CL_VPORT_ZSCALE); + *cmds++ = PM4_REG(REG_PA_CL_VPORT_ZSCALE); *cmds++ = 0xbf800000; *cmds++ = 0x0; *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmRB_COLOR_MASK); + *cmds++ = PM4_REG(REG_RB_COLOR_MASK); *cmds++ = 0x0000000f; // R = G = B = 1:enabled *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmRB_COLOR_DEST_MASK); + *cmds++ = PM4_REG(REG_RB_COLOR_DEST_MASK); *cmds++ = 0xffffffff; *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 3); - *cmds++ = PM4_REG(mmSQ_WRAPPING_0); + *cmds++ = PM4_REG(REG_SQ_WRAPPING_0); *cmds++ = 0x00000000; *cmds++ = 0x00000000; *cmds++ = pm4_type3_packet(PM4_SET_CONSTANT, 2); - *cmds++ = PM4_REG(mmRB_MODECONTROL); + *cmds++ = PM4_REG(REG_RB_MODECONTROL); *cmds++ = 0x4; // draw pixels with color and depth/stencil component // queue the draw packet @@ -1010,14 +1011,14 @@ build_regrestore_cmds(gsl_drawctxt_t *drawctxt, ctx_t *ctx) *cmd++ = (drawctxt->gpustate.gpuaddr + REG_OFFSET) & 0xFFFFE000; #endif - cmd = reg_range(cmd, mmRB_SURFACE_INFO, mmPA_SC_SCREEN_SCISSOR_BR); - cmd = reg_range(cmd, mmPA_SC_WINDOW_OFFSET, mmPA_SC_WINDOW_SCISSOR_BR); - cmd = reg_range(cmd, mmVGT_MAX_VTX_INDX, mmPA_CL_VPORT_ZOFFSET); - cmd = reg_range(cmd, mmSQ_PROGRAM_CNTL, mmSQ_WRAPPING_1); - cmd = reg_range(cmd, mmRB_DEPTHCONTROL, mmRB_MODECONTROL); - cmd = reg_range(cmd, mmPA_SU_POINT_SIZE, mmPA_SC_VIZ_QUERY); - cmd = reg_range(cmd, mmPA_SC_LINE_CNTL, mmRB_COLOR_DEST_MASK); - cmd = reg_range(cmd, mmPA_SU_POLY_OFFSET_FRONT_SCALE, mmPA_SU_POLY_OFFSET_BACK_OFFSET); + cmd = reg_range(cmd, REG_RB_SURFACE_INFO, REG_PA_SC_SCREEN_SCISSOR_BR); + cmd = reg_range(cmd, REG_PA_SC_WINDOW_OFFSET, REG_PA_SC_WINDOW_SCISSOR_BR); + cmd = reg_range(cmd, REG_VGT_MAX_VTX_INDX, REG_PA_CL_VPORT_ZOFFSET); + cmd = reg_range(cmd, REG_SQ_PROGRAM_CNTL, REG_SQ_WRAPPING_1); + cmd = reg_range(cmd, REG_RB_DEPTHCONTROL, REG_RB_MODECONTROL); + cmd = reg_range(cmd, REG_PA_SU_POINT_SIZE, REG_PA_SC_VIZ_QUERY); + cmd = reg_range(cmd, REG_PA_SC_LINE_CNTL, REG_RB_COLOR_DEST_MASK); + cmd = reg_range(cmd, REG_PA_SU_POLY_OFFSET_FRONT_SCALE, REG_PA_SU_POLY_OFFSET_BACK_OFFSET); // Now we know how many register blocks we have, we can compute command length start[0] = pm4_type3_packet(PM4_LOAD_CONSTANT_CONTEXT, (cmd-start)-1); @@ -1028,13 +1029,13 @@ build_regrestore_cmds(gsl_drawctxt_t *drawctxt, ctx_t *ctx) #endif // Need to handle some of the registers separately - *cmd++ = pm4_type0_packet(mmSQ_GPR_MANAGEMENT, 1); + *cmd++ = pm4_type0_packet(REG_SQ_GPR_MANAGEMENT, 1); ctx->reg_values[0] = gpuaddr(cmd, &drawctxt->gpustate); *cmd++ = 0x00040400; *cmd++ = pm4_type3_packet(PM4_WAIT_FOR_IDLE, 1); *cmd++ = 0; - *cmd++ = pm4_type0_packet(mmTP0_CHICKEN, 1); + *cmd++ = pm4_type0_packet(REG_TP0_CHICKEN, 1); ctx->reg_values[1] = gpuaddr(cmd, &drawctxt->gpustate); *cmd++ = 0x00000000; @@ -1178,7 +1179,7 @@ build_shader_save_restore_cmds(gsl_drawctxt_t *drawctxt, ctx_t *ctx) shaderBases = cmd++; // TBD #5: shader bases (from fixup) // write the shader partition information to a scratch register - *cmd++ = pm4_type0_packet(mmSQ_INST_STORE_MANAGMENT, 1); + *cmd++ = pm4_type0_packet(REG_SQ_INST_STORE_MANAGMENT, 1); partition1 = cmd++; // TBD #4a: partition info (from save) #if defined(PM4_IM_STORE) @@ -1214,18 +1215,18 @@ build_shader_save_restore_cmds(gsl_drawctxt_t *drawctxt, ctx_t *ctx) fixup = cmd; // start address // write the shader partition information to a scratch register - *cmd++ = pm4_type0_packet(mmSCRATCH_REG2, 1); + *cmd++ = pm4_type0_packet(REG_SCRATCH_REG2, 1); partition2 = cmd++; // TBD #4b: partition info (from save) // mask off unused bits, then OR with shader instruction memory size *cmd++ = pm4_type3_packet(PM4_REG_RMW, 3); - *cmd++ = mmSCRATCH_REG2; + *cmd++ = REG_SCRATCH_REG2; *cmd++ = 0x0FFF0FFF; // AND off invalid bits. *cmd++ = (unsigned int)((SHADER_INSTRUCT_LOG2-5U) << 29); // OR in instruction memory size // write the computed value to the SET_SHADER_BASES data field *cmd++ = pm4_type3_packet(PM4_REG_TO_MEM, 2); - *cmd++ = mmSCRATCH_REG2; + *cmd++ = REG_SCRATCH_REG2; *cmd++ = gpuaddr(shaderBases, &drawctxt->gpustate); // TBD #5: shader bases (to restore) // create indirect buffer command for above command sequence @@ -1244,10 +1245,10 @@ build_shader_save_restore_cmds(gsl_drawctxt_t *drawctxt, ctx_t *ctx) // Fetch the SQ_INST_STORE_MANAGMENT register value, // Store the value in the data fields of the SET_CONSTANT commands above. *cmd++ = pm4_type3_packet(PM4_REG_TO_MEM, 2); - *cmd++ = mmSQ_INST_STORE_MANAGMENT; + *cmd++ = REG_SQ_INST_STORE_MANAGMENT; *cmd++ = gpuaddr(partition1, &drawctxt->gpustate); // TBD #4a: partition info (to restore) *cmd++ = pm4_type3_packet(PM4_REG_TO_MEM, 2); - *cmd++ = mmSQ_INST_STORE_MANAGMENT; + *cmd++ = REG_SQ_INST_STORE_MANAGMENT; *cmd++ = gpuaddr(partition2, &drawctxt->gpustate); // TBD #4b: partition info (to fixup) #if defined(PM4_IM_STORE) diff --git a/drivers/mxc/amd-gpu/kgsl_g12.c b/drivers/mxc/amd-gpu/kgsl_g12.c index 1196e2fa5d9..295c93c6f52 100644 --- a/drivers/mxc/amd-gpu/kgsl_g12.c +++ b/drivers/mxc/amd-gpu/kgsl_g12.c @@ -22,6 +22,7 @@ #include "gsl.h" #include "gsl_hal.h" #include "gsl_cmdstream.h" +#include "kgsl_g12_vgv3types.h" #ifdef CONFIG_ARCH_MX35 #define V3_SYNC @@ -35,6 +36,24 @@ #define GSL_HAL_NUMCMDBUFFERS 5 #define GSL_HAL_CMDBUFFERSIZE (1024 + 13) * sizeof(unsigned int) +/* G12 MH arbiter config*/ +#define KGSL_G12_CFG_G12_MHARB \ + (0x10 \ + | (0 << MH_ARBITER_CONFIG__SAME_PAGE_GRANULARITY__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__L1_ARB_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__L1_ARB_HOLD_ENABLE__SHIFT) \ + | (0 << MH_ARBITER_CONFIG__L2_ARB_CONTROL__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__PAGE_SIZE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__TC_REORDER_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__TC_ARB_HOLD_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__IN_FLIGHT_LIMIT_ENABLE__SHIFT) \ + | (0x8 << MH_ARBITER_CONFIG__IN_FLIGHT_LIMIT__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__CP_CLNT_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__VGT_CLNT_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__TC_CLNT_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__RB_CLNT_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__PA_CLNT_ENABLE__SHIFT)) + #define ALIGN_IN_BYTES( dim, alignment ) ( ( (dim) + (alignment-1) ) & ~(alignment-1) ) @@ -161,7 +180,7 @@ kgsl_g12_isr(struct kgsl_device *device) if (status) { // if G12 MH is interrupting, clear MH block interrupt first, then master G12 MH interrupt - if (status & (1 << VGC_IRQSTATUS_MH_FSHIFT)) + if (status & REG_VGC_IRQSTATUS__MH_MASK) { #ifdef _DEBUG // obtain mh error information @@ -184,13 +203,10 @@ int kgsl_g12_tlbinvalidate(struct kgsl_device *device, unsigned int reg_invalidate, unsigned int pid) { #ifndef GSL_NO_MMU - REG_MH_MMU_INVALIDATE mh_mmu_invalidate = {0}; + unsigned int mh_mmu_invalidate = 0x00000003L; // invalidate all and tc // unreferenced formal parameter - (void) pid; - - mh_mmu_invalidate.INVALIDATE_ALL = 1; - mh_mmu_invalidate.INVALIDATE_TC = 1; + (void) pid; device->ftbl.regwrite(device, reg_invalidate, *(unsigned int *) &mh_mmu_invalidate); #else @@ -226,7 +242,7 @@ static void kgsl_g12_updatetimestamp(struct kgsl_device *device) device->ftbl.regread(device, (ADDR_VGC_IRQ_ACTIVE_CNT >> 2), &count); count >>= 8; count &= 255; - device->timestamp += count; + device->timestamp += count; #ifdef V3_SYNC if (device->current_timestamp > device->timestamp) { @@ -258,14 +274,14 @@ static void kgsl_g12_irqerr(struct work_struct *work) int kgsl_g12_init(struct kgsl_device *device) { - int status = GSL_FAILURE; + int status = GSL_FAILURE; device->flags |= GSL_FLAGS_INITIALIZED; kgsl_hal_setpowerstate(device->id, GSL_PWRFLAGS_POWER_ON, 100); // setup MH arbiter - MH offsets are considered to be dword based, therefore no down shift - device->ftbl.regwrite(device, ADDR_MH_ARBITER_CONFIG, *(unsigned int *) &gsl_cfg_g12_mharb); + device->ftbl.regwrite(device, ADDR_MH_ARBITER_CONFIG, KGSL_G12_CFG_G12_MHARB); // init interrupt status = kgsl_intr_init(device); @@ -525,8 +541,8 @@ kgsl_g12_regread(struct kgsl_device *device, unsigned int offsetwords, unsigned device->ftbl.regwrite(device, (ADDR_VGC_MH_READ_ADDR >> 2), offsetwords); kgsl_hwaccess_regread(device->id, (unsigned int) device->regspace.mmio_virt_base, (ADDR_VGC_MH_READ_ADDR >> 2), value); #else - device->ftbl.regwrite(device, (ADDR_MMU_READ_ADDR >> 2), offsetwords); - kgsl_hwaccess_regread(device->id, (unsigned int) device->regspace.mmio_virt_base, (ADDR_MMU_READ_DATA >> 2), value); + device->ftbl.regwrite(device, (ADDR_VGC_MH_READ_ADDR >> 2), offsetwords); + kgsl_hwaccess_regread(device->id, (unsigned int) device->regspace.mmio_virt_base, (ADDR_VGC_MH_DATA_ADDR >> 2), value); #endif } else @@ -814,7 +830,7 @@ kgsl_g12_context_create(struct kgsl_device* device, gsl_context_type_t type, uns DEBUG_ASSERT(status == GSL_SUCCESS); } g_z1xx.curr = 0; - cmd = (int)(((VGV3_NEXTCMD_JUMP) & VGV3_NEXTCMD_NEXTCMD_FMASK)<< VGV3_NEXTCMD_NEXTCMD_FSHIFT); + cmd = VGV3_NEXTCMD_JUMP << VGV3_NEXTCMD_NEXTCMD_FSHIFT; /* set cmd stream buffer to hw */ status |= kgsl_cmdwindow_write0(GSL_DEVICE_G12, GSL_CMDWINDOW_2D, ADDR_VGV3_MODE, 4); diff --git a/drivers/mxc/amd-gpu/kgsl_hal.c b/drivers/mxc/amd-gpu/kgsl_hal.c index 8be53bb5c85..bc6d666f961 100644 --- a/drivers/mxc/amd-gpu/kgsl_hal.c +++ b/drivers/mxc/amd-gpu/kgsl_hal.c @@ -312,6 +312,7 @@ kgsl_hal_getshmemconfig(gsl_shmemconfig_t *config) KGSLHAL_API int kgsl_hal_getdevconfig(unsigned int device_id, struct kgsl_devconfig *config) { +#define MMU_CONFIG 1 // set to 2 if you want any mistranslations to page fault instead of just doing PA=VA int status = GSL_FAILURE_DEVICEERROR; gsl_hal_t *hal = (gsl_hal_t *) gsl_driver.hal; @@ -322,7 +323,7 @@ kgsl_hal_getdevconfig(unsigned int device_id, struct kgsl_devconfig *config) case GSL_DEVICE_YAMATO: { if (hal->has_z430) { - mh_mmu_config_u mmu_config = {0}; + unsigned int mmu_config; config->gmemspace.gpu_base = 0; config->gmemspace.mmio_virt_base = 0; @@ -338,24 +339,25 @@ kgsl_hal_getdevconfig(unsigned int device_id, struct kgsl_devconfig *config) config->regspace.mmio_phys_base = (unsigned int) hal->z430_regspace.mmio_phys_base; config->regspace.sizebytes = GSL_HAL_SIZE_REG_YDX; - mmu_config.f.mmu_enable = 1; + // we enable the MMU (actually the MH part) regardless of configuration + mmu_config = 1; if (gsl_driver.enable_mmu) { - mmu_config.f.split_mode_enable = 0; - mmu_config.f.rb_w_clnt_behavior = 1; - mmu_config.f.cp_w_clnt_behavior = 1; - mmu_config.f.cp_r0_clnt_behavior = 1; - mmu_config.f.cp_r1_clnt_behavior = 1; - mmu_config.f.cp_r2_clnt_behavior = 1; - mmu_config.f.cp_r3_clnt_behavior = 1; - mmu_config.f.cp_r4_clnt_behavior = 1; - mmu_config.f.vgt_r0_clnt_behavior = 1; - mmu_config.f.vgt_r1_clnt_behavior = 1; - mmu_config.f.tc_r_clnt_behavior = 1; - mmu_config.f.pa_w_clnt_behavior = 1; + mmu_config = mmu_config + | (MMU_CONFIG << MH_MMU_CONFIG__RB_W_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_W_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_R0_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_R1_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_R2_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_R3_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_R4_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__VGT_R0_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__VGT_R1_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__TC_R_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__PA_W_CLNT_BEHAVIOR__SHIFT); } - config->mmu_config = mmu_config.val; + config->mmu_config = mmu_config; if (gsl_driver.enable_mmu) { config->va_base = hal->memspace[GSL_HAL_MEM1].gpu_base; @@ -375,21 +377,36 @@ kgsl_hal_getdevconfig(unsigned int device_id, struct kgsl_devconfig *config) case GSL_DEVICE_G12: { - mh_mmu_config_u mmu_config = {0}; + unsigned int mmu_config; config->regspace.gpu_base = 0; config->regspace.mmio_virt_base = (unsigned char *)hal->z160_regspace.mmio_virt_base; config->regspace.mmio_phys_base = (unsigned int) hal->z160_regspace.mmio_phys_base; config->regspace.sizebytes = GSL_HAL_SIZE_REG_G12; - mmu_config.f.mmu_enable = 1; + // we enable the MMU (actually the MH part) regardless of configuration + mmu_config = 1; + +/* and then qualcomm does this if the MMU is enabled?? + | (MMU_CONFIG << MH_MMU_CONFIG__RB_W_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_W_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_R0_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_R1_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_R2_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_R3_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__CP_R4_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__VGT_R0_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__VGT_R1_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__TC_R_CLNT_BEHAVIOR__SHIFT) + | (MMU_CONFIG << MH_MMU_CONFIG__PA_W_CLNT_BEHAVIOR__SHIFT); +*/ if (gsl_driver.enable_mmu) { config->mmu_config = 0x00555551; config->va_base = hal->memspace[GSL_HAL_MEM1].gpu_base; config->va_range = hal->memspace[GSL_HAL_MEM1].sizebytes; } else { - config->mmu_config = mmu_config.val; + config->mmu_config = mmu_config; config->va_base = 0x00000000; config->va_range = 0x00000000; } @@ -424,13 +441,13 @@ kgsl_hal_getchipid(unsigned int device_id) unsigned int coreid, majorid, minorid, patchid, revid; if (hal->has_z430 && (device_id == GSL_DEVICE_YAMATO)) { - device->ftbl.regread(device, mmRBBM_PERIPHID1, &coreid); + device->ftbl.regread(device, REG_RBBM_PERIPHID1, &coreid); coreid &= 0xF; - device->ftbl.regread(device, mmRBBM_PERIPHID2, &majorid); + device->ftbl.regread(device, REG_RBBM_PERIPHID2, &majorid); majorid = (majorid >> 4) & 0xF; - device->ftbl.regread(device, mmRBBM_PATCH_RELEASE, &revid); + device->ftbl.regread(device, REG_RBBM_PATCH_RELEASE, &revid); minorid = ((revid >> 0) & 0xFF); /* this is a 16bit field, but extremely unlikely it would ever get this high */ diff --git a/drivers/mxc/amd-gpu/kgsl_ringbuffer.c b/drivers/mxc/amd-gpu/kgsl_ringbuffer.c index 150998e262e..6b023c129b2 100644 --- a/drivers/mxc/amd-gpu/kgsl_ringbuffer.c +++ b/drivers/mxc/amd-gpu/kgsl_ringbuffer.c @@ -352,7 +352,7 @@ kgsl_ringbuffer_submit(gsl_ringbuffer_t *rb) GSL_RB_UPDATE_WPTR_POLLING(rb); // send the wptr to the hw - rb->device->ftbl.regwrite(rb->device, mmCP_RB_WPTR, rb->wptr); + rb->device->ftbl.regwrite(rb->device, REG_CP_RB_WPTR, rb->wptr); rb->flags |= GSL_FLAGS_ACTIVE; @@ -474,7 +474,8 @@ int kgsl_ringbuffer_start(gsl_ringbuffer_t *rb) { int status; - cp_rb_cntl_u cp_rb_cntl; + /*cp_rb_cntl_u cp_rb_cntl;*/ + union reg_cp_rb_cntl cp_rb_cntl; int i; unsigned int *cmds; struct kgsl_device *device = rb->device; @@ -495,60 +496,60 @@ kgsl_ringbuffer_start(gsl_ringbuffer_t *rb) kgsl_sharedmem_set0(&rb->buffer_desc, 0, 0x12341234, (rb->sizedwords << 2)); // setup WPTR polling address - device->ftbl.regwrite(device, mmCP_RB_WPTR_BASE, (rb->memptrs_desc.gpuaddr + GSL_RB_MEMPTRS_WPTRPOLL_OFFSET)); + device->ftbl.regwrite(device, REG_CP_RB_WPTR_BASE, (rb->memptrs_desc.gpuaddr + GSL_RB_MEMPTRS_WPTRPOLL_OFFSET)); // setup WPTR delay - device->ftbl.regwrite(device, mmCP_RB_WPTR_DELAY, 0/*0x70000010*/); + device->ftbl.regwrite(device, REG_CP_RB_WPTR_DELAY, 0/*0x70000010*/); // setup RB_CNTL - device->ftbl.regread(device, mmCP_RB_CNTL, (unsigned int *)&cp_rb_cntl); + device->ftbl.regread(device, REG_CP_RB_CNTL, (unsigned int *)&cp_rb_cntl); cp_rb_cntl.f.rb_bufsz = gsl_ringbuffer_sizelog2quadwords(rb->sizedwords); // size of ringbuffer cp_rb_cntl.f.rb_blksz = rb->blksizequadwords; // quadwords to read before updating mem RPTR cp_rb_cntl.f.rb_poll_en = GSL_RB_CNTL_POLL_EN; // WPTR polling cp_rb_cntl.f.rb_no_update = GSL_RB_CNTL_NO_UPDATE; // mem RPTR writebacks - device->ftbl.regwrite(device, mmCP_RB_CNTL, cp_rb_cntl.val); + device->ftbl.regwrite(device, REG_CP_RB_CNTL, cp_rb_cntl.val); // setup RB_BASE - device->ftbl.regwrite(device, mmCP_RB_BASE, rb->buffer_desc.gpuaddr); + device->ftbl.regwrite(device, REG_CP_RB_BASE, rb->buffer_desc.gpuaddr); // setup RPTR_ADDR - device->ftbl.regwrite(device, mmCP_RB_RPTR_ADDR, rb->memptrs_desc.gpuaddr + GSL_RB_MEMPTRS_RPTR_OFFSET); + device->ftbl.regwrite(device, REG_CP_RB_RPTR_ADDR, rb->memptrs_desc.gpuaddr + GSL_RB_MEMPTRS_RPTR_OFFSET); // explicitly clear all cp interrupts when running in safe mode if (rb->device->flags & GSL_FLAGS_SAFEMODE) { - device->ftbl.regwrite(device, mmCP_INT_ACK, 0xFFFFFFFF); + device->ftbl.regwrite(device, REG_CP_INT_ACK, 0xFFFFFFFF); } // setup scratch/timestamp addr - device->ftbl.regwrite(device, mmSCRATCH_ADDR, device->memstore.gpuaddr + GSL_DEVICE_MEMSTORE_OFFSET(soptimestamp)); + device->ftbl.regwrite(device, REG_SCRATCH_ADDR, device->memstore.gpuaddr + GSL_DEVICE_MEMSTORE_OFFSET(soptimestamp)); // setup scratch/timestamp mask - device->ftbl.regwrite(device, mmSCRATCH_UMSK, GSL_RB_MEMPTRS_SCRATCH_MASK); + device->ftbl.regwrite(device, REG_SCRATCH_UMSK, GSL_RB_MEMPTRS_SCRATCH_MASK); // load the CP ucode - device->ftbl.regwrite(device, mmCP_DEBUG, 0x02000000); - device->ftbl.regwrite(device, mmCP_ME_RAM_WADDR, 0); + device->ftbl.regwrite(device, REG_CP_DEBUG, 0x02000000); + device->ftbl.regwrite(device, REG_CP_ME_RAM_WADDR, 0); for (i = 0; i < PM4_MICROCODE_SIZE; i++ ) { - device->ftbl.regwrite(device, mmCP_ME_RAM_DATA, aPM4_Microcode[i][0]); - device->ftbl.regwrite(device, mmCP_ME_RAM_DATA, aPM4_Microcode[i][1]); - device->ftbl.regwrite(device, mmCP_ME_RAM_DATA, aPM4_Microcode[i][2]); + device->ftbl.regwrite(device, REG_CP_ME_RAM_DATA, aPM4_Microcode[i][0]); + device->ftbl.regwrite(device, REG_CP_ME_RAM_DATA, aPM4_Microcode[i][1]); + device->ftbl.regwrite(device, REG_CP_ME_RAM_DATA, aPM4_Microcode[i][2]); } // load the prefetch parser ucode - device->ftbl.regwrite(device, mmCP_PFP_UCODE_ADDR, 0); + device->ftbl.regwrite(device, REG_CP_PFP_UCODE_ADDR, 0); for ( i = 0; i < PFP_MICROCODE_SIZE_NRT; i++ ) { - device->ftbl.regwrite(device, mmCP_PFP_UCODE_DATA, aPFP_Microcode_nrt[i]); + device->ftbl.regwrite(device, REG_CP_PFP_UCODE_DATA, aPFP_Microcode_nrt[i]); } // queue thresholds ??? - device->ftbl.regwrite(device, mmCP_QUEUE_THRESHOLDS, 0x000C0804); + device->ftbl.regwrite(device, REG_CP_QUEUE_THRESHOLDS, 0x000C0804); // reset pointers rb->rptr = 0; @@ -559,7 +560,7 @@ kgsl_ringbuffer_start(gsl_ringbuffer_t *rb) GSL_RB_INIT_TIMESTAMP(rb); // clear ME_HALT to start micro engine - device->ftbl.regwrite(device, mmCP_ME_CNTL, 0); + device->ftbl.regwrite(device, REG_CP_ME_CNTL, 0); // ME_INIT cmds = kgsl_ringbuffer_addcmds(rb, 19); @@ -568,14 +569,14 @@ kgsl_ringbuffer_start(gsl_ringbuffer_t *rb) GSL_RB_WRITE(cmds, 0x000003ff); // All fields present (bits 9:0) GSL_RB_WRITE(cmds, 0x00000000); // Disable/Enable Real-Time Stream processing (present but ignored) GSL_RB_WRITE(cmds, 0x00000000); // Enable (2D to 3D) and (3D to 2D) implicit synchronization (present but ignored) - GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(mmRB_SURFACE_INFO)); - GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(mmPA_SC_WINDOW_OFFSET)); - GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(mmVGT_MAX_VTX_INDX)); - GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(mmSQ_PROGRAM_CNTL)); - GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(mmRB_DEPTHCONTROL)); - GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(mmPA_SU_POINT_SIZE)); - GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(mmPA_SC_LINE_CNTL)); - GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(mmPA_SU_POLY_OFFSET_FRONT_SCALE)); + GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(REG_RB_SURFACE_INFO)); + GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(REG_PA_SC_WINDOW_OFFSET)); + GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(REG_VGT_MAX_VTX_INDX)); + GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(REG_SQ_PROGRAM_CNTL)); + GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(REG_RB_DEPTHCONTROL)); + GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(REG_PA_SU_POINT_SIZE)); + GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(REG_PA_SC_LINE_CNTL)); + GSL_RB_WRITE(cmds, GSL_HAL_SUBBLOCK_OFFSET(REG_PA_SU_POLY_OFFSET_FRONT_SCALE)); GSL_RB_WRITE(cmds, 0x80000180); // Vertex and Pixel Shader Start Addresses in instructions (3 DWORDS per instruction) GSL_RB_WRITE(cmds, 0x00000001); // Maximum Contexts GSL_RB_WRITE(cmds, 0x00000000); // Write Confirm Interval and The CP will wait the wait_interval * 16 clocks between polling @@ -644,7 +645,7 @@ kgsl_ringbuffer_stop(gsl_ringbuffer_t *rb) kgsl_intr_detach(&rb->device->intr, GSL_INTR_YDX_CP_RING_BUFFER); // ME_HALT - rb->device->ftbl.regwrite(rb->device, mmCP_ME_CNTL, 0x10000000); + rb->device->ftbl.regwrite(rb->device, REG_CP_ME_CNTL, 0x10000000); rb->flags &= ~GSL_FLAGS_STARTED; } @@ -829,7 +830,7 @@ kgsl_ringbuffer_issuecmds(struct kgsl_device *device, int pmodeoff, unsigned int timestamp = rb->timestamp; // start-of-pipeline and end-of-pipeline timestamps - *ringcmds++ = pm4_type0_packet(mmCP_TIMESTAMP, 1); + *ringcmds++ = pm4_type0_packet(REG_CP_TIMESTAMP, 1); *ringcmds++ = rb->timestamp; *ringcmds++ = pm4_type3_packet(PM4_EVENT_WRITE, 3); *ringcmds++ = CACHE_FLUSH_TS; @@ -931,19 +932,19 @@ kgsl_ringbuffer_debug(gsl_ringbuffer_t *rb, gsl_rb_debug_t *rb_debug) rb_debug->pm4_ucode_rel = PM4_MICROCODE_VERSION; rb_debug->pfp_ucode_rel = PFP_MICROCODE_VERSION; - rb->device->ftbl.regread(rb->device, mmCP_RB_BASE, (unsigned int *)&rb_debug->cp_rb_base); - rb->device->ftbl.regread(rb->device, mmCP_RB_CNTL, (unsigned int *)&rb_debug->cp_rb_cntl); - rb->device->ftbl.regread(rb->device, mmCP_RB_RPTR_ADDR, (unsigned int *)&rb_debug->cp_rb_rptr_addr); - rb->device->ftbl.regread(rb->device, mmCP_RB_RPTR, (unsigned int *)&rb_debug->cp_rb_rptr); - rb->device->ftbl.regread(rb->device, mmCP_RB_WPTR, (unsigned int *)&rb_debug->cp_rb_wptr); - rb->device->ftbl.regread(rb->device, mmCP_RB_WPTR_BASE, (unsigned int *)&rb_debug->cp_rb_wptr_base); - rb->device->ftbl.regread(rb->device, mmSCRATCH_UMSK, (unsigned int *)&rb_debug->scratch_umsk); - rb->device->ftbl.regread(rb->device, mmSCRATCH_ADDR, (unsigned int *)&rb_debug->scratch_addr); - rb->device->ftbl.regread(rb->device, mmCP_ME_CNTL, (unsigned int *)&rb_debug->cp_me_cntl); - rb->device->ftbl.regread(rb->device, mmCP_ME_STATUS, (unsigned int *)&rb_debug->cp_me_status); - rb->device->ftbl.regread(rb->device, mmCP_DEBUG, (unsigned int *)&rb_debug->cp_debug); - rb->device->ftbl.regread(rb->device, mmCP_STAT, (unsigned int *)&rb_debug->cp_stat); - rb->device->ftbl.regread(rb->device, mmRBBM_STATUS, (unsigned int *)&rb_debug->rbbm_status); + rb->device->ftbl.regread(rb->device, REG_CP_RB_BASE, (unsigned int *)&rb_debug->cp_rb_base); + rb->device->ftbl.regread(rb->device, REG_CP_RB_CNTL, (unsigned int *)&rb_debug->cp_rb_cntl); + rb->device->ftbl.regread(rb->device, REG_CP_RB_RPTR_ADDR, (unsigned int *)&rb_debug->cp_rb_rptr_addr); + rb->device->ftbl.regread(rb->device, REG_CP_RB_RPTR, (unsigned int *)&rb_debug->cp_rb_rptr); + rb->device->ftbl.regread(rb->device, REG_CP_RB_WPTR, (unsigned int *)&rb_debug->cp_rb_wptr); + rb->device->ftbl.regread(rb->device, REG_CP_RB_WPTR_BASE, (unsigned int *)&rb_debug->cp_rb_wptr_base); + rb->device->ftbl.regread(rb->device, REG_SCRATCH_UMSK, (unsigned int *)&rb_debug->scratch_umsk); + rb->device->ftbl.regread(rb->device, REG_SCRATCH_ADDR, (unsigned int *)&rb_debug->scratch_addr); + rb->device->ftbl.regread(rb->device, REG_CP_ME_CNTL, (unsigned int *)&rb_debug->cp_me_cntl); + rb->device->ftbl.regread(rb->device, REG_CP_ME_STATUS, (unsigned int *)&rb_debug->cp_me_status); + rb->device->ftbl.regread(rb->device, REG_CP_DEBUG, (unsigned int *)&rb_debug->cp_debug); + rb->device->ftbl.regread(rb->device, REG_CP_STAT, (unsigned int *)&rb_debug->cp_stat); + rb->device->ftbl.regread(rb->device, REG_RBBM_STATUS, (unsigned int *)&rb_debug->rbbm_status); rb_debug->sop_timestamp = kgsl_cmdstream_readtimestamp(rb->device->id, GSL_TIMESTAMP_CONSUMED); rb_debug->eop_timestamp = kgsl_cmdstream_readtimestamp(rb->device->id, GSL_TIMESTAMP_RETIRED); } @@ -1035,7 +1036,7 @@ kgsl_ringbuffer_bist(gsl_ringbuffer_t *rb) return (GSL_FAILURE); } - GSL_RB_WRITE(cmds, pm4_type0_packet(mmSCRATCH_REG7, 1)); + GSL_RB_WRITE(cmds, pm4_type0_packet(REG_SCRATCH_REG7, 1)); GSL_RB_WRITE(cmds, 0xFEEDF00D); kgsl_ringbuffer_submit(rb); @@ -1051,7 +1052,7 @@ kgsl_ringbuffer_bist(gsl_ringbuffer_t *rb) return (status); } - rb->device->ftbl.regread(rb->device, mmSCRATCH_REG7, &temp); + rb->device->ftbl.regread(rb->device, REG_SCRATCH_REG7, &temp); if (temp != 0xFEEDF00D) { @@ -1082,7 +1083,7 @@ kgsl_ringbuffer_bist(gsl_ringbuffer_t *rb) while (k < j) { k+=2; - GSL_RB_WRITE(cmds, pm4_type0_packet(mmSCRATCH_REG7, 1)); + GSL_RB_WRITE(cmds, pm4_type0_packet(REG_SCRATCH_REG7, 1)); GSL_RB_WRITE(cmds, k); } @@ -1099,7 +1100,7 @@ kgsl_ringbuffer_bist(gsl_ringbuffer_t *rb) return (status); } - rb->device->ftbl.regread(rb->device, mmSCRATCH_REG7, &temp); + rb->device->ftbl.regread(rb->device, REG_SCRATCH_REG7, &temp); if (temp != k) { diff --git a/drivers/mxc/amd-gpu/kgsl_yamato.c b/drivers/mxc/amd-gpu/kgsl_yamato.c index e2b56a9fe49..e6273e2f9e2 100644 --- a/drivers/mxc/amd-gpu/kgsl_yamato.c +++ b/drivers/mxc/amd-gpu/kgsl_yamato.c @@ -25,6 +25,26 @@ #include "gsl_ringbuffer.h" #include "gsl_drawctxt.h" + +/* Yamato MH arbiter config*/ +#define KGSL_CFG_YAMATO_MHARB \ + (0x10 \ + | (0 << MH_ARBITER_CONFIG__SAME_PAGE_GRANULARITY__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__L1_ARB_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__L1_ARB_HOLD_ENABLE__SHIFT) \ + | (0 << MH_ARBITER_CONFIG__L2_ARB_CONTROL__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__PAGE_SIZE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__TC_REORDER_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__TC_ARB_HOLD_ENABLE__SHIFT) \ + | (0 << MH_ARBITER_CONFIG__IN_FLIGHT_LIMIT_ENABLE__SHIFT) \ + | (0x8 << MH_ARBITER_CONFIG__IN_FLIGHT_LIMIT__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__CP_CLNT_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__VGT_CLNT_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__TC_CLNT_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__RB_CLNT_ENABLE__SHIFT) \ + | (1 << MH_ARBITER_CONFIG__PA_CLNT_ENABLE__SHIFT)) + + ////////////////////////////////////////////////////////////////////////////// // functions ////////////////////////////////////////////////////////////////////////////// @@ -32,7 +52,8 @@ static int kgsl_yamato_gmeminit(struct kgsl_device *device) { - rb_edram_info_u rb_edram_info = {0}; + /* rb_edram_info_u rb_edram_info = {0}; */ + union reg_rb_edram_info rb_edram_info; unsigned int gmem_size; unsigned int edram_value = 0; @@ -50,7 +71,7 @@ kgsl_yamato_gmeminit(struct kgsl_device *device) rb_edram_info.f.edram_mapping_mode = 0; // EDRAM_MAP_UPPER rb_edram_info.f.edram_range = (device->gmemspace.gpu_base >> 14); // must be aligned to size - device->ftbl.regwrite(device, mmRB_EDRAM_INFO, (unsigned int)rb_edram_info.val); + device->ftbl.regwrite(device, REG_RB_EDRAM_INFO, (unsigned int)rb_edram_info.val); return (GSL_SUCCESS); } @@ -60,7 +81,7 @@ kgsl_yamato_gmeminit(struct kgsl_device *device) static int kgsl_yamato_gmemclose(struct kgsl_device *device) { - device->ftbl.regwrite(device, mmRB_EDRAM_INFO, 0x00000000); + device->ftbl.regwrite(device, REG_RB_EDRAM_INFO, 0x00000000); return (GSL_SUCCESS); } @@ -183,15 +204,15 @@ kgsl_yamato_isr(struct kgsl_device *device) #endif // DEBUG // determine if yamato is interrupting, and if so, which block - device->ftbl.regread(device, mmMASTER_INT_SIGNAL, &status); + device->ftbl.regread(device, REG_MASTER_INT_SIGNAL, &status); if (status & MASTER_INT_SIGNAL__MH_INT_STAT) { #ifdef _DEBUG // obtain mh error information - device->ftbl.regread(device, mmMH_MMU_PAGE_FAULT, (unsigned int *)&page_fault); - device->ftbl.regread(device, mmMH_AXI_ERROR, (unsigned int *)&axi_error); - device->ftbl.regread(device, mmMH_CLNT_AXI_ID_REUSE, (unsigned int *)&clnt_axi_id_reuse); + device->ftbl.regread(device, REG_MH_MMU_PAGE_FAULT, (unsigned int *)&page_fault); + device->ftbl.regread(device, REG_MH_AXI_ERROR, (unsigned int *)&axi_error); + device->ftbl.regread(device, REG_MH_CLNT_AXI_ID_REUSE, (unsigned int *)&clnt_axi_id_reuse); #endif // DEBUG kgsl_intr_decode(device, GSL_INTR_BLOCK_YDX_MH); @@ -206,7 +227,7 @@ kgsl_yamato_isr(struct kgsl_device *device) { #ifdef _DEBUG // obtain rbbm error information - device->ftbl.regread(device, mmRBBM_READ_ERROR, (unsigned int *)&read_error); + device->ftbl.regread(device, REG_RBBM_READ_ERROR, (unsigned int *)&read_error); #endif // DEBUG kgsl_intr_decode(device, GSL_INTR_BLOCK_YDX_RBBM); @@ -226,23 +247,21 @@ int kgsl_yamato_tlbinvalidate(struct kgsl_device *device, unsigned int reg_invalidate, unsigned int pid) { unsigned int link[2]; - mh_mmu_invalidate_u mh_mmu_invalidate = {0}; - - mh_mmu_invalidate.f.invalidate_all = 1; - mh_mmu_invalidate.f.invalidate_tc = 1; + unsigned int mh_mmu_invalidate = 0x00000003L; // invalidate all and tc // if possible, invalidate via command stream, otherwise via direct register writes if (device->flags & GSL_FLAGS_STARTED) { + // there's a wait for idle packet up front here in qcom code link[0] = pm4_type0_packet(reg_invalidate, 1); - link[1] = mh_mmu_invalidate.val; + link[1] = mh_mmu_invalidate; kgsl_ringbuffer_issuecmds(device, 1, &link[0], 2, pid); } else { - device->ftbl.regwrite(device, reg_invalidate, mh_mmu_invalidate.val); + device->ftbl.regwrite(device, reg_invalidate, mh_mmu_invalidate); } return (GSL_SUCCESS); @@ -276,7 +295,7 @@ kgsl_yamato_setpagetable(struct kgsl_device *device, unsigned int reg_ptbase, ui // fifo and prevent any further vertex/bin updates from occurring until the wait // has finished. link[4] = pm4_type3_packet(PM4_SET_CONSTANT, 2); - link[5] = (0x4 << 16) | (mmPA_SU_SC_MODE_CNTL - 0x2000); + link[5] = (0x4 << 16) | (REG_PA_SU_SC_MODE_CNTL - 0x2000); link[6] = 0; // disable faceness generation link[7] = pm4_type3_packet(PM4_SET_BIN_BASE_OFFSET, 1); link[8] = device->mmu.dummyspace.gpuaddr; @@ -328,23 +347,23 @@ kgsl_yamato_init(struct kgsl_device *device) //We need to make sure all blocks are powered up and clocked before //issuing a soft reset. The overrides will be turned off (set to 0) //later in kgsl_yamato_start. - device->ftbl.regwrite(device, mmRBBM_PM_OVERRIDE1, 0xfffffffe); - device->ftbl.regwrite(device, mmRBBM_PM_OVERRIDE2, 0xffffffff); + device->ftbl.regwrite(device, REG_RBBM_PM_OVERRIDE1, 0xfffffffe); + device->ftbl.regwrite(device, REG_RBBM_PM_OVERRIDE2, 0xffffffff); // soft reset - device->ftbl.regwrite(device, mmRBBM_SOFT_RESET, 0xFFFFFFFF); + device->ftbl.regwrite(device, REG_RBBM_SOFT_RESET, 0xFFFFFFFF); msleep(50); - device->ftbl.regwrite(device, mmRBBM_SOFT_RESET, 0x00000000); + device->ftbl.regwrite(device, REG_RBBM_SOFT_RESET, 0x00000000); // RBBM control - device->ftbl.regwrite(device, mmRBBM_CNTL, 0x00004442); + device->ftbl.regwrite(device, REG_RBBM_CNTL, 0x00004442); // setup MH arbiter - device->ftbl.regwrite(device, mmMH_ARBITER_CONFIG, *(unsigned int *) &gsl_cfg_yamato_mharb); + device->ftbl.regwrite(device, REG_MH_ARBITER_CONFIG, KGSL_CFG_YAMATO_MHARB); // SQ_*_PROGRAM - device->ftbl.regwrite(device, mmSQ_VS_PROGRAM, 0x00000000); - device->ftbl.regwrite(device, mmSQ_PS_PROGRAM, 0x00000000); + device->ftbl.regwrite(device, REG_SQ_VS_PROGRAM, 0x00000000); + device->ftbl.regwrite(device, REG_SQ_PS_PROGRAM, 0x00000000); // init interrupt status = kgsl_intr_init(device); @@ -438,8 +457,8 @@ kgsl_yamato_start(struct kgsl_device *device, gsl_flags_t flags) // default power management override when running in safe mode pm1 = (device->flags & GSL_FLAGS_SAFEMODE) ? 0xFFFFFFFE : 0x00000000; pm2 = (device->flags & GSL_FLAGS_SAFEMODE) ? 0x000000FF : 0x00000000; - device->ftbl.regwrite(device, mmRBBM_PM_OVERRIDE1, pm1); - device->ftbl.regwrite(device, mmRBBM_PM_OVERRIDE2, pm2); + device->ftbl.regwrite(device, REG_RBBM_PM_OVERRIDE1, pm1); + device->ftbl.regwrite(device, REG_RBBM_PM_OVERRIDE2, pm2); // enable rbbm interrupts kgsl_intr_attach(&device->intr, GSL_INTR_YDX_RBBM_READ_ERROR, kgsl_yamato_rbbmintrcallback, (void *) device); @@ -580,13 +599,13 @@ kgsl_yamato_setproperty(struct kgsl_device *device, gsl_property_type_t type, vo { if (power->flags & GSL_PWRFLAGS_OVERRIDE_ON) { - device->ftbl.regwrite(device, mmRBBM_PM_OVERRIDE1, 0xfffffffe); - device->ftbl.regwrite(device, mmRBBM_PM_OVERRIDE2, 0xffffffff); + device->ftbl.regwrite(device, REG_RBBM_PM_OVERRIDE1, 0xfffffffe); + device->ftbl.regwrite(device, REG_RBBM_PM_OVERRIDE2, 0xffffffff); } else if (power->flags & GSL_PWRFLAGS_OVERRIDE_OFF) { - device->ftbl.regwrite(device, mmRBBM_PM_OVERRIDE1, 0x00000000); - device->ftbl.regwrite(device, mmRBBM_PM_OVERRIDE2, 0x00000000); + device->ftbl.regwrite(device, REG_RBBM_PM_OVERRIDE1, 0x00000000); + device->ftbl.regwrite(device, REG_RBBM_PM_OVERRIDE2, 0x00000000); } else { @@ -644,7 +663,7 @@ kgsl_yamato_setproperty(struct kgsl_device *device, gsl_property_type_t type, vo { size = 8; - *cmds++ = pm4_type0_packet(mmRBBM_DSPLY, 1); + *cmds++ = pm4_type0_packet(REG_RBBM_DSPLY, 1); switch (gsl_driver.dmi_mode) { case GSL_DMIFLAGS_ENABLE_SINGLE: @@ -670,14 +689,14 @@ kgsl_yamato_setproperty(struct kgsl_device *device, gsl_property_type_t type, vo // // Wait for 3D core to be idle and wait for vsync // - *cmds++ = pm4_type0_packet(mmWAIT_UNTIL, 1); + *cmds++ = pm4_type0_packet(REG_WAIT_UNTIL, 1); *cmds++ = 0x00008000; // 3d idle // *cmds++ = 0x00008008; // 3d idle & vsync // // Update the render latest register. // - *cmds++ = pm4_type0_packet(mmRBBM_RENDER_LATEST, 1); + *cmds++ = pm4_type0_packet(REG_RBBM_RENDER_LATEST, 1); switch (gsl_driver.dmi_frame) { case 0: @@ -688,7 +707,7 @@ kgsl_yamato_setproperty(struct kgsl_device *device, gsl_property_type_t type, vo // // Wait for our max frame # indicator to be de-asserted // - *cmds++ = pm4_type0_packet(mmWAIT_UNTIL, 1); + *cmds++ = pm4_type0_packet(REG_WAIT_UNTIL, 1); *cmds++ = 0x00000008 << gsl_driver.dmi_max_frame; gsl_driver.dmi_frame = 1; break; @@ -698,7 +717,7 @@ kgsl_yamato_setproperty(struct kgsl_device *device, gsl_property_type_t type, vo // Render frame 1 // *cmds++ = 1; - *cmds++ = pm4_type0_packet(mmWAIT_UNTIL, 1); + *cmds++ = pm4_type0_packet(REG_WAIT_UNTIL, 1); *cmds++ = 0x00000010; // Wait for frame 0 to be deasserted gsl_driver.dmi_frame = 2; break; @@ -707,7 +726,7 @@ kgsl_yamato_setproperty(struct kgsl_device *device, gsl_property_type_t type, vo // Render frame 2 // *cmds++ = 2; - *cmds++ = pm4_type0_packet(mmWAIT_UNTIL, 1); + *cmds++ = pm4_type0_packet(REG_WAIT_UNTIL, 1); *cmds++ = 0x00000020; // Wait for frame 1 to be deasserted gsl_driver.dmi_frame = 0; break; @@ -736,11 +755,11 @@ kgsl_yamato_idle(struct kgsl_device *device, unsigned int timeout) { int status = GSL_FAILURE; gsl_ringbuffer_t *rb = &device->ringbuffer; - rbbm_status_u rbbm_status; + unsigned int rbbm_status; (void) timeout; // unreferenced formal parameter - KGSL_DEBUG(GSL_DBGFLAGS_DUMPX, KGSL_DEBUG_DUMPX(BB_DUMP_REGPOLL, device->id, mmRBBM_STATUS, 0x80000000, "kgsl_yamato_idle")); + KGSL_DEBUG(GSL_DBGFLAGS_DUMPX, KGSL_DEBUG_DUMPX(BB_DUMP_REGPOLL, device->id, REG_RBBM_STATUS, 0x80000000, "kgsl_yamato_idle")); // first, wait until the CP has consumed all the commands in the ring buffer if (rb->flags & GSL_FLAGS_STARTED) @@ -755,9 +774,10 @@ kgsl_yamato_idle(struct kgsl_device *device, unsigned int timeout) // now, wait for the GPU to finish its operations for ( ; ; ) { - device->ftbl.regread(device, mmRBBM_STATUS, (unsigned int *)&rbbm_status); + device->ftbl.regread(device, REG_RBBM_STATUS, (unsigned int *)&rbbm_status); - if (!(rbbm_status.val & 0x80000000)) + // qcom uses 0x110 + if (!(rbbm_status & 0x80000000)) { status = GSL_SUCCESS; break; @@ -777,7 +797,7 @@ kgsl_yamato_regread(struct kgsl_device *device, unsigned int offsetwords, unsign { if (!(gsl_driver.flags_debug & GSL_DBGFLAGS_DUMPX_WITHOUT_IFH)) { - if(offsetwords == mmCP_RB_RPTR || offsetwords == mmCP_RB_WPTR) + if(offsetwords == REG_CP_RB_RPTR || offsetwords == REG_CP_RB_WPTR) { *value = device->ringbuffer.wptr; return (GSL_SUCCESS);