amd-gpu: use Qualcomm's register definitions

This is a BIG hack.

Logging (as in kgsl_log.c) won't work anymore as it uses some weird
way to define registers based on the old register definitions.

Some FBC interrupt thing is really odd, there are no docs for it..

MMU config may be a little screwy - or not :)

Freescale's kernel driver does some things the Qualcomm driver
doesn't in some registers Qualcomm doesn't use. Odd, but kept the
FSL way since userspace may need to match and it's not worth the
work right now.
This commit is contained in:
Matt Sealey
2012-11-26 12:10:35 -06:00
parent 6734683032
commit bd2d54da05
11 changed files with 879 additions and 284 deletions

View File

@@ -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 */

View File

@@ -43,14 +43,14 @@ struct kgsl_device;
#include "gsl_klibapi.h"
// Z430
#include <reg/yamato.h>
#include <yamato_reg.h>
#include "gsl_pm4types.h"
#include "gsl_utils.h"
#include "gsl_drawctxt.h"
#include "gsl_ringbuffer.h"
// Z160/Z180
#include <reg/g12_reg.h>
#include <g12_reg.h>
#include "gsl_cmdwindow.h"
#include "gsl_debug.h"

View File

@@ -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,

View File

@@ -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 */

View File

@@ -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 */

View File

@@ -22,6 +22,7 @@
#include "gsl.h"
#include "gsl_hal.h"
#include "gsl_cmdstream.h"
#include "kgsl_g12_vgv3types.h"
// functions

View File

@@ -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)

View File

@@ -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);

View File

@@ -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 */

View File

@@ -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)
{

View File

@@ -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);