antifallobst
/
lineage_kernel_xcoverpro
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
lineage_kernel_xcoverpro/drivers/bts/bts-exynos9610.c

3461 lines
94 KiB
C
Raw Normal View History

initial commit
2023-06-18 22:53:49 +00:00
/*
* Copyright (c) 2016 Samsung Electronics Co., Ltd.
* http://www.samsung.com
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*/
#include <linux/io.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/dma-mapping.h>
#include <linux/pm_qos.h>
#include <linux/suspend.h>
#include <linux/debugfs.h>
#include <linux/slab.h>
#include <linux/syscore_ops.h>
#include <asm/uaccess.h>
#include <soc/samsung/bts.h>
#include "cal_bts9610.h"
#define BTS_DBG(x...) \
do { \
if (exynos_bts_log) \
pr_info(x); \
} while (0)
#define MIF_UTIL 65
#define DEFAULT_QMAX_R 0x12
#define DEFAULT_QMAX_W 0x3
#define NO_QMAX 0x0
static int exynos_bts_log;
static unsigned int exynos_mif_util = MIF_UTIL;
static unsigned int exynos_qmax_r[2] = {DEFAULT_QMAX_R, NO_QMAX};
static unsigned int exynos_qmax_w[2] = {DEFAULT_QMAX_W, NO_QMAX};
enum bts_index {
BTS_IDX_ABOX,
BTS_IDX_COREX,
BTS_IDX_CAM,
BTS_IDX_DPU,
BTS_IDX_DIT,
BTS_IDX_FSYS,
BTS_IDX_G2D,
BTS_IDX_G3D,
BTS_IDX_GNSS,
BTS_IDX_ISP0,
BTS_IDX_ISP1,
BTS_IDX_MFC0,
BTS_IDX_MFC1,
BTS_IDX_MODEM0,
BTS_IDX_MODEM1,
BTS_IDX_WLBT,
BTS_IDX_USB,
BTS_IDX_VIPX1,
BTS_IDX_VIPX2,
BTS_IDX_SIREX,
BTS_IDX_CPU_DMC0,
BTS_IDX_CPU_DMC1,
};
enum exynos_bts_type {
BT_TREX,
};
struct bts_table {
struct bts_status stat;
struct bts_info *next_bts;
int prev_scen;
int next_scen;
};
struct bts_info {
const char *name;
unsigned int pa_base;
void __iomem *va_base;
bool enable;
enum exynos_bts_type type;
struct bts_table table[BS_MAX];
enum bts_scen_type top_scen;
};
enum drex_index {
DREX_IDX_0,
DREX_IDX_1,
};
struct drex_status {
bool scen_en;
unsigned int write_flush_config[2];
unsigned int drex_timeout[BTS_PRIORITY_MAX + 1];
unsigned int vc_timer_th[BTS_VC_TIMER_TH_NR];
/* BRB [0]:CPU, [1]:RT, [2]:NRT, [3]:CP */
/* RDBUF [4]:CPU, [5]:RT, [6]:NRT, [7]:CP */
unsigned int cutoff_con;
/* [7:0]:CPU, [15:8]:RT, [23:16]:NRT, [31:24]:CP */
unsigned int brb_cutoff_config;
/* [7:0]:CPU, [15:8]:RT, [23:16]:NRT, [31:24]:CP */
unsigned int rdbuf_cutoff_config;
};
struct drex_table {
struct drex_status stat;
struct drex_info *next_drex;
int prev_scen;
int next_scen;
};
struct drex_info {
const char *name;
unsigned int pa_base;
void __iomem *va_base;
bool enable;
struct drex_table table[BS_MAX];
enum bts_scen_type top_scen;
};
enum drex_pf_index {
DREX_PF_IDX_0,
DREX_PF_IDX_1,
};
struct drex_pf_status {
bool scen_en;
unsigned int pf_rreq_thrt_con;
unsigned int allow_mo_for_region;
unsigned int pf_qos_timer[BTS_PF_TIMER_NR];
};
struct drex_pf_table {
struct drex_pf_status stat;
struct drex_pf_info *next_drex_pf;
int prev_scen;
int next_scen;
};
struct drex_pf_info {
const char *name;
unsigned int pa_base;
void __iomem *va_base;
bool enable;
struct drex_pf_table table[BS_MAX];
enum bts_scen_type top_scen;
};
struct bts_scenario {
const char *name;
struct bts_info *head;
struct drex_info *drex_head;
struct drex_pf_info *drex_pf_head;
};
struct trex_info {
unsigned int pa_base;
void __iomem *va_base;
unsigned int value;
unsigned int read;
unsigned int write;
};
static struct pm_qos_request exynos_mif_bts_qos;
static DEFINE_SPINLOCK(bts_lock);
static DEFINE_MUTEX(media_mutex);
static struct trex_info trex_snode[] = {
{ .pa_base = EXYNOS9610_PA_S_NRT0, },
{ .pa_base = EXYNOS9610_PA_S_NRT1, },
{ .pa_base = EXYNOS9610_PA_RT_MEM0, },
{ .pa_base = EXYNOS9610_PA_RT_MEM1, },
{ .pa_base = EXYNOS9610_PA_CP_MEM0, },
{ .pa_base = EXYNOS9610_PA_CP_MEM1, },
};
static struct bts_info exynos_bts[] = {
[BTS_IDX_ABOX] = {
.name = "abox",
.pa_base = EXYNOS9610_PA_ABOX,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0xC,
.table[BS_MFC_UHD].stat.scen_en = true,
.table[BS_MFC_UHD].stat.priority = 0xC,
.table[BS_G3D_PERFORMANCE].stat.scen_en = true,
.table[BS_G3D_PERFORMANCE].stat.priority = 0xC,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.priority = 0xA,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.priority = 0xC,
.table[BS_FHD_480_ENCODING].stat.rmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.wmo = 0x4,
},
[BTS_IDX_COREX] = {
.name = "corex",
.pa_base = EXYNOS9610_PA_COREX,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x4,
.table[BS_DEFAULT].stat.wmo = 0x4,
.table[BS_DEFAULT].stat.max_rmo = 0x1,
.table[BS_DEFAULT].stat.max_wmo = 0x1,
},
[BTS_IDX_CAM] = {
.name = "cam",
.pa_base = EXYNOS9610_PA_CAM,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0xC,
.table[BS_DEFAULT].stat.rmo = 0x18,
.table[BS_DEFAULT].stat.wmo = 0x18,
.table[BS_DEFAULT].stat.timeout_en = true,
.table[BS_DEFAULT].stat.timeout_r = 0xc,
.table[BS_DEFAULT].stat.timeout_w = 0xc,
.table[BS_MFC_UHD].stat.scen_en = true,
.table[BS_MFC_UHD].stat.priority = 0xC,
.table[BS_MFC_UHD].stat.rmo = 0x18,
.table[BS_MFC_UHD].stat.wmo = 0x18,
.table[BS_MFC_UHD].stat.timeout_en = true,
.table[BS_MFC_UHD].stat.timeout_r = 0xc,
.table[BS_MFC_UHD].stat.timeout_w = 0xc,
.table[BS_G3D_PERFORMANCE].stat.scen_en = true,
.table[BS_G3D_PERFORMANCE].stat.priority = 0xC,
.table[BS_G3D_PERFORMANCE].stat.rmo = 0x18,
.table[BS_G3D_PERFORMANCE].stat.wmo = 0x18,
.table[BS_G3D_PERFORMANCE].stat.timeout_en = true,
.table[BS_G3D_PERFORMANCE].stat.timeout_r = 0xc,
.table[BS_G3D_PERFORMANCE].stat.timeout_w = 0xc,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.priority = 0xC,
.table[BS_CAMERA_DEFAULT].stat.rmo = 0x18,
.table[BS_CAMERA_DEFAULT].stat.wmo = 0x18,
.table[BS_CAMERA_DEFAULT].stat.timeout_en = true,
.table[BS_CAMERA_DEFAULT].stat.timeout_r = 0xc,
.table[BS_CAMERA_DEFAULT].stat.timeout_w = 0xc,
.table[BS_CAMERA_REMOSAIC].stat.scen_en = true,
.table[BS_CAMERA_REMOSAIC].stat.priority = 0xC,
.table[BS_CAMERA_REMOSAIC].stat.rmo = 0x10,
.table[BS_CAMERA_REMOSAIC].stat.wmo = 0x10,
.table[BS_CAMERA_REMOSAIC].stat.timeout_en = true,
.table[BS_CAMERA_REMOSAIC].stat.timeout_r = 0xc,
.table[BS_CAMERA_REMOSAIC].stat.timeout_w = 0xc,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.priority = 0xC,
.table[BS_FHD_480_ENCODING].stat.rmo = 0x16,
.table[BS_FHD_480_ENCODING].stat.wmo = 0x16,
.table[BS_FHD_480_ENCODING].stat.timeout_en = true,
.table[BS_FHD_480_ENCODING].stat.timeout_r = 0xc,
.table[BS_FHD_480_ENCODING].stat.timeout_w = 0xc,
},
[BTS_IDX_DPU] = {
.name = "dpu",
.pa_base = EXYNOS9610_PA_DPU,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0xA,
.table[BS_DEFAULT].stat.rmo = 0x20,
.table[BS_DEFAULT].stat.wmo = 0x20,
.table[BS_DEFAULT].stat.timeout_en = true,
.table[BS_DEFAULT].stat.timeout_r = 0x20,
.table[BS_DEFAULT].stat.timeout_w = 0x20,
.table[BS_MFC_UHD].stat.scen_en = true,
.table[BS_MFC_UHD].stat.priority = 0xA,
.table[BS_MFC_UHD].stat.rmo = 0x20,
.table[BS_MFC_UHD].stat.wmo = 0x20,
.table[BS_MFC_UHD].stat.timeout_en = true,
.table[BS_MFC_UHD].stat.timeout_r = 0x20,
.table[BS_MFC_UHD].stat.timeout_w = 0x20,
.table[BS_G3D_PERFORMANCE].stat.scen_en = true,
.table[BS_G3D_PERFORMANCE].stat.priority = 0xA,
.table[BS_G3D_PERFORMANCE].stat.rmo = 0x20,
.table[BS_G3D_PERFORMANCE].stat.wmo = 0x20,
.table[BS_G3D_PERFORMANCE].stat.timeout_en = true,
.table[BS_G3D_PERFORMANCE].stat.timeout_r = 0x20,
.table[BS_G3D_PERFORMANCE].stat.timeout_w = 0x20,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.priority = 0xA,
.table[BS_CAMERA_DEFAULT].stat.rmo = 0x20,
.table[BS_CAMERA_DEFAULT].stat.wmo = 0x20,
.table[BS_CAMERA_DEFAULT].stat.timeout_en = true,
.table[BS_CAMERA_DEFAULT].stat.timeout_r = 0x20,
.table[BS_CAMERA_DEFAULT].stat.timeout_w = 0x20,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.priority = 0xA,
.table[BS_FHD_480_ENCODING].stat.rmo = 0x18,
.table[BS_FHD_480_ENCODING].stat.wmo = 0x18,
.table[BS_FHD_480_ENCODING].stat.timeout_en = true,
.table[BS_FHD_480_ENCODING].stat.timeout_r = 0x20,
.table[BS_FHD_480_ENCODING].stat.timeout_w = 0x20,
},
[BTS_IDX_DIT] = {
.name = "dit",
.pa_base = EXYNOS9610_PA_DIT,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x4,
.table[BS_DEFAULT].stat.wmo = 0x4,
.table[BS_DEFAULT].stat.max_rmo = 0x1,
.table[BS_DEFAULT].stat.max_wmo = 0x1,
},
[BTS_IDX_FSYS] = {
.name = "fsys",
.pa_base = EXYNOS9610_PA_FSYS,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x4,
.table[BS_DEFAULT].stat.wmo = 0x4,
.table[BS_DEFAULT].stat.max_rmo = 0x1,
.table[BS_DEFAULT].stat.max_wmo = 0x1,
},
[BTS_IDX_G2D] = {
.name = "g2d",
.pa_base = EXYNOS9610_PA_G2D,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x10,
.table[BS_DEFAULT].stat.wmo = 0x10,
.table[BS_DEFAULT].stat.max_rmo = 0x1,
.table[BS_DEFAULT].stat.max_wmo = 0x1,
.table[BS_MFC_UHD].stat.scen_en = true,
.table[BS_MFC_UHD].stat.priority = 0x4,
.table[BS_MFC_UHD].stat.rmo = 0x10,
.table[BS_MFC_UHD].stat.wmo = 0x10,
.table[BS_MFC_UHD].stat.max_rmo = 0x1,
.table[BS_MFC_UHD].stat.max_wmo = 0x1,
.table[BS_G3D_PERFORMANCE].stat.scen_en = true,
.table[BS_G3D_PERFORMANCE].stat.priority = 0x4,
.table[BS_G3D_PERFORMANCE].stat.rmo = 0x10,
.table[BS_G3D_PERFORMANCE].stat.wmo = 0x10,
.table[BS_G3D_PERFORMANCE].stat.max_rmo = 0x1,
.table[BS_G3D_PERFORMANCE].stat.max_wmo = 0x1,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.priority = 0x4,
.table[BS_CAMERA_DEFAULT].stat.rmo = 0x8,
.table[BS_CAMERA_DEFAULT].stat.wmo = 0x8,
.table[BS_CAMERA_DEFAULT].stat.max_rmo = 0x1,
.table[BS_CAMERA_DEFAULT].stat.max_wmo = 0x1,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.priority = 0x4,
.table[BS_FHD_480_ENCODING].stat.rmo = 0x6,
.table[BS_FHD_480_ENCODING].stat.wmo = 0x6,
.table[BS_FHD_480_ENCODING].stat.max_rmo = 0x1,
.table[BS_FHD_480_ENCODING].stat.max_wmo = 0x1,
},
[BTS_IDX_G3D] = {
.name = "g3d",
.pa_base = EXYNOS9610_PA_G3D,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x8,
.table[BS_DEFAULT].stat.wmo = 0x8,
.table[BS_DEFAULT].stat.max_rmo = 0x1,
.table[BS_DEFAULT].stat.max_wmo = 0x1,
.table[BS_MFC_UHD].stat.scen_en = true,
.table[BS_MFC_UHD].stat.priority = 0x4,
.table[BS_MFC_UHD].stat.rmo = 0x8,
.table[BS_MFC_UHD].stat.wmo = 0x8,
.table[BS_MFC_UHD].stat.max_rmo = 0x1,
.table[BS_MFC_UHD].stat.max_wmo = 0x1,
.table[BS_G3D_PERFORMANCE].stat.scen_en = true,
.table[BS_G3D_PERFORMANCE].stat.priority = 0x4,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.priority = 0x4,
.table[BS_CAMERA_DEFAULT].stat.rmo = 0x4,
.table[BS_CAMERA_DEFAULT].stat.wmo = 0x4,
.table[BS_CAMERA_DEFAULT].stat.max_rmo = 0x1,
.table[BS_CAMERA_DEFAULT].stat.max_wmo = 0x1,
.table[BS_CAMERA_REMOSAIC].stat.scen_en = true,
.table[BS_CAMERA_REMOSAIC].stat.priority = 0x4,
.table[BS_CAMERA_REMOSAIC].stat.rmo = 0x3,
.table[BS_CAMERA_REMOSAIC].stat.wmo = 0x3,
.table[BS_CAMERA_REMOSAIC].stat.max_rmo = 0x1,
.table[BS_CAMERA_REMOSAIC].stat.max_wmo = 0x1,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.priority = 0x4,
.table[BS_FHD_480_ENCODING].stat.rmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.wmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.max_rmo = 0x1,
.table[BS_FHD_480_ENCODING].stat.max_wmo = 0x1,
},
[BTS_IDX_GNSS] = {
.name = "gnss",
.pa_base = EXYNOS9610_PA_GNSS,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x4,
.table[BS_DEFAULT].stat.wmo = 0x4,
.table[BS_DEFAULT].stat.max_rmo = 0x1,
.table[BS_DEFAULT].stat.max_wmo = 0x1,
},
[BTS_IDX_ISP0] = {
.name = "isp0",
.pa_base = EXYNOS9610_PA_ISP0,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x10,
.table[BS_DEFAULT].stat.wmo = 0x10,
.table[BS_DEFAULT].stat.max_rmo = 0x4,
.table[BS_DEFAULT].stat.max_wmo = 0x4,
.table[BS_MFC_UHD].stat.scen_en = true,
.table[BS_MFC_UHD].stat.priority = 0x4,
.table[BS_MFC_UHD].stat.rmo = 0x10,
.table[BS_MFC_UHD].stat.wmo = 0x10,
.table[BS_MFC_UHD].stat.max_rmo = 0x4,
.table[BS_MFC_UHD].stat.max_wmo = 0x4,
.table[BS_G3D_PERFORMANCE].stat.scen_en = true,
.table[BS_G3D_PERFORMANCE].stat.priority = 0x4,
.table[BS_G3D_PERFORMANCE].stat.rmo = 0x10,
.table[BS_G3D_PERFORMANCE].stat.wmo = 0x10,
.table[BS_G3D_PERFORMANCE].stat.max_rmo = 0x4,
.table[BS_G3D_PERFORMANCE].stat.max_wmo = 0x4,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.priority = 0x4,
.table[BS_CAMERA_DEFAULT].stat.rmo = 0x10,
.table[BS_CAMERA_DEFAULT].stat.wmo = 0x10,
.table[BS_CAMERA_DEFAULT].stat.max_rmo = 0x4,
.table[BS_CAMERA_DEFAULT].stat.max_wmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.priority = 0xC,
.table[BS_FHD_480_ENCODING].stat.rmo = 0x10,
.table[BS_FHD_480_ENCODING].stat.wmo = 0x10,
.table[BS_FHD_480_ENCODING].stat.max_rmo = 0x1,
.table[BS_FHD_480_ENCODING].stat.max_wmo = 0x1,
},
[BTS_IDX_ISP1] = {
.name = "isp1",
.pa_base = EXYNOS9610_PA_ISP1,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x10,
.table[BS_DEFAULT].stat.wmo = 0x10,
.table[BS_DEFAULT].stat.max_rmo = 0x4,
.table[BS_DEFAULT].stat.max_wmo = 0x4,
.table[BS_MFC_UHD].stat.scen_en = true,
.table[BS_MFC_UHD].stat.priority = 0x4,
.table[BS_MFC_UHD].stat.rmo = 0x10,
.table[BS_MFC_UHD].stat.wmo = 0x10,
.table[BS_MFC_UHD].stat.max_rmo = 0x4,
.table[BS_MFC_UHD].stat.max_wmo = 0x4,
.table[BS_G3D_PERFORMANCE].stat.scen_en = true,
.table[BS_G3D_PERFORMANCE].stat.priority = 0x4,
.table[BS_G3D_PERFORMANCE].stat.rmo = 0x10,
.table[BS_G3D_PERFORMANCE].stat.wmo = 0x10,
.table[BS_G3D_PERFORMANCE].stat.max_rmo = 0x4,
.table[BS_G3D_PERFORMANCE].stat.max_wmo = 0x4,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.priority = 0x4,
.table[BS_CAMERA_DEFAULT].stat.rmo = 0x10,
.table[BS_CAMERA_DEFAULT].stat.wmo = 0x10,
.table[BS_CAMERA_DEFAULT].stat.max_rmo = 0x4,
.table[BS_CAMERA_DEFAULT].stat.max_wmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.priority = 0xC,
.table[BS_FHD_480_ENCODING].stat.rmo = 0x10,
.table[BS_FHD_480_ENCODING].stat.wmo = 0x10,
.table[BS_FHD_480_ENCODING].stat.max_rmo = 0x1,
.table[BS_FHD_480_ENCODING].stat.max_wmo = 0x1,
},
[BTS_IDX_MFC0] = {
.name = "mfc0",
.pa_base = EXYNOS9610_PA_MFC0,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x8,
.table[BS_DEFAULT].stat.wmo = 0x8,
.table[BS_DEFAULT].stat.max_rmo = 0x1,
.table[BS_DEFAULT].stat.max_wmo = 0x1,
.table[BS_MFC_UHD].stat.scen_en = true,
.table[BS_MFC_UHD].stat.priority = 0x4,
.table[BS_MFC_UHD].stat.rmo = 0x14,
.table[BS_MFC_UHD].stat.wmo = 0x14,
.table[BS_MFC_UHD].stat.max_rmo = 0x1,
.table[BS_MFC_UHD].stat.max_wmo = 0x1,
.table[BS_G3D_PERFORMANCE].stat.scen_en = true,
.table[BS_G3D_PERFORMANCE].stat.priority = 0x4,
.table[BS_G3D_PERFORMANCE].stat.rmo = 0x8,
.table[BS_G3D_PERFORMANCE].stat.wmo = 0x8,
.table[BS_G3D_PERFORMANCE].stat.max_rmo = 0x1,
.table[BS_G3D_PERFORMANCE].stat.max_wmo = 0x1,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.priority = 0x4,
.table[BS_CAMERA_DEFAULT].stat.rmo = 0x8,
.table[BS_CAMERA_DEFAULT].stat.wmo = 0x8,
.table[BS_CAMERA_DEFAULT].stat.max_rmo = 0x1,
.table[BS_CAMERA_DEFAULT].stat.max_wmo = 0x1,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.priority = 0x4,
.table[BS_FHD_480_ENCODING].stat.rmo = 0x10,
.table[BS_FHD_480_ENCODING].stat.wmo = 0x10,
.table[BS_FHD_480_ENCODING].stat.max_rmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.max_wmo = 0x4,
},
[BTS_IDX_MFC1] = {
.name = "mfc1",
.pa_base = EXYNOS9610_PA_MFC1,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x8,
.table[BS_DEFAULT].stat.wmo = 0x8,
.table[BS_DEFAULT].stat.max_rmo = 0x1,
.table[BS_DEFAULT].stat.max_wmo = 0x1,
.table[BS_MFC_UHD].stat.scen_en = true,
.table[BS_MFC_UHD].stat.priority = 0x4,
.table[BS_MFC_UHD].stat.rmo = 0x14,
.table[BS_MFC_UHD].stat.wmo = 0x14,
.table[BS_MFC_UHD].stat.max_rmo = 0x1,
.table[BS_MFC_UHD].stat.max_wmo = 0x1,
.table[BS_G3D_PERFORMANCE].stat.scen_en = true,
.table[BS_G3D_PERFORMANCE].stat.priority = 0x4,
.table[BS_G3D_PERFORMANCE].stat.rmo = 0x8,
.table[BS_G3D_PERFORMANCE].stat.wmo = 0x8,
.table[BS_G3D_PERFORMANCE].stat.max_rmo = 0x1,
.table[BS_G3D_PERFORMANCE].stat.max_wmo = 0x1,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.priority = 0x4,
.table[BS_CAMERA_DEFAULT].stat.rmo = 0x8,
.table[BS_CAMERA_DEFAULT].stat.wmo = 0x8,
.table[BS_CAMERA_DEFAULT].stat.max_rmo = 0x1,
.table[BS_CAMERA_DEFAULT].stat.max_wmo = 0x1,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.priority = 0x4,
.table[BS_FHD_480_ENCODING].stat.rmo = 0x10,
.table[BS_FHD_480_ENCODING].stat.wmo = 0x10,
.table[BS_FHD_480_ENCODING].stat.max_rmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.max_wmo = 0x4,
},
[BTS_IDX_MODEM0] = {
.name = "modem0",
.pa_base = EXYNOS9610_PA_MODEM0,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0xD,
.table[BS_DEFAULT].stat.timeout_en = true,
.table[BS_DEFAULT].stat.timeout_r = 0xc,
.table[BS_DEFAULT].stat.timeout_w = 0xa,
},
[BTS_IDX_MODEM1] = {
.name = "modem1",
.pa_base = EXYNOS9610_PA_MODEM1,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
},
[BTS_IDX_WLBT] = {
.name = "wlbt",
.pa_base = EXYNOS9610_PA_WLBT,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x4,
.table[BS_DEFAULT].stat.wmo = 0x4,
.table[BS_DEFAULT].stat.max_rmo = 0x1,
.table[BS_DEFAULT].stat.max_wmo = 0x1,
},
[BTS_IDX_USB] = {
.name = "usb",
.pa_base = EXYNOS9610_PA_USB,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x4,
.table[BS_DEFAULT].stat.wmo = 0x4,
.table[BS_DEFAULT].stat.max_rmo = 0x1,
.table[BS_DEFAULT].stat.max_wmo = 0x1,
},
[BTS_IDX_VIPX1] = {
.name = "vipx1",
.pa_base = EXYNOS9610_PA_VIPX1,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x10,
.table[BS_DEFAULT].stat.wmo = 0x10,
.table[BS_DEFAULT].stat.max_rmo = 0x4,
.table[BS_DEFAULT].stat.max_wmo = 0x4,
.table[BS_MFC_UHD].stat.scen_en = true,
.table[BS_MFC_UHD].stat.priority = 0x4,
.table[BS_MFC_UHD].stat.rmo = 0x10,
.table[BS_MFC_UHD].stat.wmo = 0x10,
.table[BS_MFC_UHD].stat.max_rmo = 0x4,
.table[BS_MFC_UHD].stat.max_wmo = 0x4,
.table[BS_G3D_PERFORMANCE].stat.scen_en = true,
.table[BS_G3D_PERFORMANCE].stat.priority = 0x4,
.table[BS_G3D_PERFORMANCE].stat.rmo = 0x10,
.table[BS_G3D_PERFORMANCE].stat.wmo = 0x10,
.table[BS_G3D_PERFORMANCE].stat.max_rmo = 0x4,
.table[BS_G3D_PERFORMANCE].stat.max_wmo = 0x4,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.priority = 0x4,
.table[BS_CAMERA_DEFAULT].stat.rmo = 0x10,
.table[BS_CAMERA_DEFAULT].stat.wmo = 0x10,
.table[BS_CAMERA_DEFAULT].stat.max_rmo = 0x4,
.table[BS_CAMERA_DEFAULT].stat.max_wmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.priority = 0x8,
.table[BS_FHD_480_ENCODING].stat.rmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.wmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.max_rmo = 0x1,
.table[BS_FHD_480_ENCODING].stat.max_wmo = 0x1,
},
[BTS_IDX_VIPX2] = {
.name = "vipx2",
.pa_base = EXYNOS9610_PA_VIPX2,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x10,
.table[BS_DEFAULT].stat.wmo = 0x10,
.table[BS_DEFAULT].stat.max_rmo = 0x4,
.table[BS_DEFAULT].stat.max_wmo = 0x4,
.table[BS_MFC_UHD].stat.scen_en = true,
.table[BS_MFC_UHD].stat.priority = 0x4,
.table[BS_MFC_UHD].stat.rmo = 0x10,
.table[BS_MFC_UHD].stat.wmo = 0x10,
.table[BS_MFC_UHD].stat.max_rmo = 0x4,
.table[BS_MFC_UHD].stat.max_wmo = 0x4,
.table[BS_G3D_PERFORMANCE].stat.scen_en = true,
.table[BS_G3D_PERFORMANCE].stat.priority = 0x4,
.table[BS_G3D_PERFORMANCE].stat.rmo = 0x10,
.table[BS_G3D_PERFORMANCE].stat.wmo = 0x10,
.table[BS_G3D_PERFORMANCE].stat.max_rmo = 0x4,
.table[BS_G3D_PERFORMANCE].stat.max_wmo = 0x4,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.priority = 0x4,
.table[BS_CAMERA_DEFAULT].stat.rmo = 0x10,
.table[BS_CAMERA_DEFAULT].stat.wmo = 0x10,
.table[BS_CAMERA_DEFAULT].stat.max_rmo = 0x4,
.table[BS_CAMERA_DEFAULT].stat.max_wmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.priority = 0x8,
.table[BS_FHD_480_ENCODING].stat.rmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.wmo = 0x4,
.table[BS_FHD_480_ENCODING].stat.max_rmo = 0x1,
.table[BS_FHD_480_ENCODING].stat.max_wmo = 0x1,
},
[BTS_IDX_SIREX] = {
.name = "sirex",
.pa_base = EXYNOS9610_PA_SIREX,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x4,
.table[BS_DEFAULT].stat.rmo = 0x4,
.table[BS_DEFAULT].stat.wmo = 0x4,
.table[BS_DEFAULT].stat.max_rmo = 0x1,
.table[BS_DEFAULT].stat.max_wmo = 0x1,
},
[BTS_IDX_CPU_DMC0] = {
.name = "cpu_dmc0",
.pa_base = EXYNOS9610_PA_CPU_DMC0,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x0,
},
[BTS_IDX_CPU_DMC1] = {
.name = "cpu_dmc1",
.pa_base = EXYNOS9610_PA_CPU_DMC1,
.type = BT_TREX,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.priority = 0x0,
},
};
static struct drex_info exynos_drex[] = {
[DREX_IDX_0] = {
.name = "drex0",
.pa_base = EXYNOS9610_PA_DREX0,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.write_flush_config[0] = 0xB4301606,
.table[BS_DEFAULT].stat.write_flush_config[1] = 0x1810100A,
.table[BS_DEFAULT].stat.drex_timeout[0x0] = 0x000A0180,
.table[BS_DEFAULT].stat.drex_timeout[0x1] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x2] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x3] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x4] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x5] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x6] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x7] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x8] = 0x000A0080,
.table[BS_DEFAULT].stat.drex_timeout[0x9] = 0x000A0060,
.table[BS_DEFAULT].stat.drex_timeout[0xA] = 0x000A0040,
.table[BS_DEFAULT].stat.drex_timeout[0xB] = 0x000A0020,
.table[BS_DEFAULT].stat.drex_timeout[0xC] = 0x000A0010,
.table[BS_DEFAULT].stat.drex_timeout[0xD] = 0x000A0008,
.table[BS_DEFAULT].stat.drex_timeout[0xE] = 0x000A0004,
.table[BS_DEFAULT].stat.drex_timeout[0xF] = 0x000A0001,
.table[BS_DEFAULT].stat.vc_timer_th[0] = 0x00C100C1,
.table[BS_DEFAULT].stat.vc_timer_th[1] = 0x00C100C1,
.table[BS_DEFAULT].stat.vc_timer_th[2] = 0x00C100C1,
.table[BS_DEFAULT].stat.vc_timer_th[3] = 0x00C100C1,
.table[BS_DEFAULT].stat.vc_timer_th[4] = 0x00C100C1,
.table[BS_DEFAULT].stat.vc_timer_th[5] = 0x000D001A,
.table[BS_DEFAULT].stat.vc_timer_th[6] = 0x00030007,
.table[BS_DEFAULT].stat.vc_timer_th[7] = 0x00010001,
.table[BS_DEFAULT].stat.cutoff_con = 0x00000005,
.table[BS_DEFAULT].stat.brb_cutoff_config = 0x00020002,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.write_flush_config[0] = 0xB4301606,
.table[BS_CAMERA_DEFAULT].stat.write_flush_config[1] = 0x1820200A,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x0] = 0x000A0180,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x1] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x2] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x3] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x4] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x5] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x6] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x7] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x8] = 0x000A0080,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x9] = 0x000A0060,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xA] = 0x000A0040,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xB] = 0x000A0020,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xC] = 0x000A0010,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xD] = 0x000A0008,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xE] = 0x000A0004,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xF] = 0x000A0001,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[0] = 0x00C100C1,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[1] = 0x00C100C1,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[2] = 0x00C100C1,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[3] = 0x00C100C1,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[4] = 0x00C100C1,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[5] = 0x000D001A,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[6] = 0x00030007,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[7] = 0x00010001,
.table[BS_CAMERA_DEFAULT].stat.cutoff_con = 0x00000005,
.table[BS_CAMERA_DEFAULT].stat.brb_cutoff_config = 0x00030003,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.write_flush_config[0] = 0xB4301606,
.table[BS_FHD_480_ENCODING].stat.write_flush_config[1] = 0x1810100A,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x0] = 0x000A0180,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x1] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x2] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x3] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x4] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x5] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x6] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x7] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x8] = 0x000A0011,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x9] = 0x000A0060,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xA] = 0x000A0040,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xB] = 0x000A0020,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xC] = 0x000A0010,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xD] = 0x000A0008,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xE] = 0x000A0004,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xF] = 0x000A0001,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[0] = 0x00C100C1,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[1] = 0x00C100C1,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[2] = 0x00C100C1,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[3] = 0x00C100C1,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[4] = 0x00C10009,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[5] = 0x000D0022,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[6] = 0x00030007,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[7] = 0x00010001,
.table[BS_FHD_480_ENCODING].stat.cutoff_con = 0x00000005,
.table[BS_FHD_480_ENCODING].stat.brb_cutoff_config = 0x00020002,
},
[DREX_IDX_1] = {
.name = "drex1",
.pa_base = EXYNOS9610_PA_DREX1,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.write_flush_config[0] = 0xB4301606,
.table[BS_DEFAULT].stat.write_flush_config[1] = 0x1810100A,
.table[BS_DEFAULT].stat.drex_timeout[0x0] = 0x000A0180,
.table[BS_DEFAULT].stat.drex_timeout[0x1] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x2] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x3] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x4] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x5] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x6] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x7] = 0x000A0100,
.table[BS_DEFAULT].stat.drex_timeout[0x8] = 0x000A0080,
.table[BS_DEFAULT].stat.drex_timeout[0x9] = 0x000A0060,
.table[BS_DEFAULT].stat.drex_timeout[0xA] = 0x000A0040,
.table[BS_DEFAULT].stat.drex_timeout[0xB] = 0x000A0020,
.table[BS_DEFAULT].stat.drex_timeout[0xC] = 0x000A0010,
.table[BS_DEFAULT].stat.drex_timeout[0xD] = 0x000A0008,
.table[BS_DEFAULT].stat.drex_timeout[0xE] = 0x000A0004,
.table[BS_DEFAULT].stat.drex_timeout[0xF] = 0x000A0001,
.table[BS_DEFAULT].stat.vc_timer_th[0] = 0x00C100C1,
.table[BS_DEFAULT].stat.vc_timer_th[1] = 0x00C100C1,
.table[BS_DEFAULT].stat.vc_timer_th[2] = 0x00C100C1,
.table[BS_DEFAULT].stat.vc_timer_th[3] = 0x00C100C1,
.table[BS_DEFAULT].stat.vc_timer_th[4] = 0x00C100C1,
.table[BS_DEFAULT].stat.vc_timer_th[5] = 0x000D001A,
.table[BS_DEFAULT].stat.vc_timer_th[6] = 0x00030007,
.table[BS_DEFAULT].stat.vc_timer_th[7] = 0x00010001,
.table[BS_DEFAULT].stat.cutoff_con = 0x00000005,
.table[BS_DEFAULT].stat.brb_cutoff_config = 0x00020002,
.table[BS_CAMERA_DEFAULT].stat.scen_en = true,
.table[BS_CAMERA_DEFAULT].stat.write_flush_config[0] = 0xB4301606,
.table[BS_CAMERA_DEFAULT].stat.write_flush_config[1] = 0x1820200A,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x0] = 0x000A0180,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x1] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x2] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x3] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x4] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x5] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x6] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x7] = 0x000A0100,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x8] = 0x000A0080,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0x9] = 0x000A0060,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xA] = 0x000A0040,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xB] = 0x000A0020,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xC] = 0x000A0010,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xD] = 0x000A0008,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xE] = 0x000A0004,
.table[BS_CAMERA_DEFAULT].stat.drex_timeout[0xF] = 0x000A0001,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[0] = 0x00C100C1,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[1] = 0x00C100C1,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[2] = 0x00C100C1,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[3] = 0x00C100C1,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[4] = 0x00C100C1,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[5] = 0x000D001A,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[6] = 0x00030007,
.table[BS_CAMERA_DEFAULT].stat.vc_timer_th[7] = 0x00010001,
.table[BS_CAMERA_DEFAULT].stat.cutoff_con = 0x00000005,
.table[BS_CAMERA_DEFAULT].stat.brb_cutoff_config = 0x00030003,
.table[BS_FHD_480_ENCODING].stat.scen_en = true,
.table[BS_FHD_480_ENCODING].stat.write_flush_config[0] = 0xB4301606,
.table[BS_FHD_480_ENCODING].stat.write_flush_config[1] = 0x1810100A,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x0] = 0x000A0180,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x1] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x2] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x3] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x4] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x5] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x6] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x7] = 0x000A0100,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x8] = 0x000A0011,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0x9] = 0x000A0060,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xA] = 0x000A0040,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xB] = 0x000A0020,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xC] = 0x000A0010,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xD] = 0x000A0008,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xE] = 0x000A0004,
.table[BS_FHD_480_ENCODING].stat.drex_timeout[0xF] = 0x000A0001,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[0] = 0x00C100C1,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[1] = 0x00C100C1,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[2] = 0x00C100C1,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[3] = 0x00C100C1,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[4] = 0x00C10009,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[5] = 0x000D0022,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[6] = 0x00030007,
.table[BS_FHD_480_ENCODING].stat.vc_timer_th[7] = 0x00010001,
.table[BS_FHD_480_ENCODING].stat.cutoff_con = 0x00000005,
.table[BS_FHD_480_ENCODING].stat.brb_cutoff_config = 0x00020002,
},
};
static struct drex_pf_info exynos_drex_pf[] = {
[DREX_PF_IDX_0] = {
.name = "drex0_pf",
.pa_base = EXYNOS9610_PA_DREX0_PF,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.pf_rreq_thrt_con = 0x00008000,
.table[BS_DEFAULT].stat.allow_mo_for_region = 0x00000000,
.table[BS_DEFAULT].stat.pf_qos_timer[0] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[1] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[2] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[3] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[4] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[5] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[6] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[7] = 0x00050005,
},
[DREX_PF_IDX_1] = {
.name = "drex1_pf",
.pa_base = EXYNOS9610_PA_DREX1_PF,
.enable = true,
.table[BS_DEFAULT].stat.scen_en = true,
.table[BS_DEFAULT].stat.pf_rreq_thrt_con = 0x00008000,
.table[BS_DEFAULT].stat.allow_mo_for_region = 0x00000000,
.table[BS_DEFAULT].stat.pf_qos_timer[0] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[1] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[2] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[3] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[4] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[5] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[6] = 0x00050005,
.table[BS_DEFAULT].stat.pf_qos_timer[7] = 0x00050005,
},
};
static struct bts_scenario bts_scen[BS_MAX] = {
[BS_DEFAULT] = {
.name = "default",
},
[BS_MFC_UHD] = {
.name = "mfc uhd",
},
[BS_G3D_PERFORMANCE] = {
.name = "g3d per",
},
[BS_CAMERA_DEFAULT] = {
.name = "camscen",
},
[BS_CAMERA_REMOSAIC] = {
.name = "camremo",
},
[BS_FHD_480_ENCODING] = {
.name = "fhd-480",
},
};
static void bts_set_ip_table(struct bts_info *bts)
{
enum bts_scen_type scen = bts->top_scen;
BTS_DBG("[BTS] %s bts scen: [%s]->[%s]\n", bts->name,
bts_scen[scen].name, bts_scen[scen].name);
switch (bts->type) {
case BT_TREX:
bts_setqos(bts->va_base, &bts->table[scen].stat);
break;
default:
break;
}
}
static void bts_set_drex_table(struct drex_info *drex)
{
enum bts_scen_type scen = drex->top_scen;
int i;
BTS_DBG("[BTS] %s bts scen: [%s]->[%s]\n", drex->name,
bts_scen[scen].name, bts_scen[scen].name);
__raw_writel(drex->table[scen].stat.write_flush_config[0],
drex->va_base + WRITE_FLUSH_CONFIG0);
__raw_writel(drex->table[scen].stat.write_flush_config[1],
drex->va_base + WRITE_FLUSH_CONFIG1);
for (i = 0; i <= BTS_PRIORITY_MAX; i++)
__raw_writel(drex->table[scen].stat.drex_timeout[i],
drex->va_base + QOS_TIMEOUT_0 + (4 * i));
for (i = 0; i < BTS_VC_TIMER_TH_NR; i++)
__raw_writel(drex->table[scen].stat.vc_timer_th[i],
drex->va_base + VC_TIMER_TH_0 + (4 * i));
__raw_writel(drex->table[scen].stat.cutoff_con,
drex->va_base + CUTOFF_CONTROL);
__raw_writel(drex->table[scen].stat.brb_cutoff_config,
drex->va_base + BRB_CUTOFF_CONFIG0);
__raw_writel(drex->table[scen].stat.rdbuf_cutoff_config,
drex->va_base + RDBUF_CUTOFF_CONFIG0);
}
static void bts_set_drex_pf_table(struct drex_pf_info *drex_pf)
{
enum bts_scen_type scen = drex_pf->top_scen;
int i;
BTS_DBG("[BTS] %s bts scen: [%s]->[%s]\n", drex_pf->name,
bts_scen[scen].name, bts_scen[scen].name);
__raw_writel(drex_pf->table[scen].stat.pf_rreq_thrt_con,
drex_pf->va_base + PF_RREQ_THROTTLE_CONTROL);
__raw_writel(drex_pf->table[scen].stat.allow_mo_for_region,
drex_pf->va_base + PF_RREQ_THROTTLE_MO_P2);
for (i = 0; i < BTS_PF_TIMER_NR; i++)
__raw_writel(drex_pf->table[scen].stat.pf_qos_timer[i],
drex_pf->va_base + PF_QOS_TIMER_0 + (4 * i));
}
static void bts_drex_add_scen(enum bts_scen_type scen)
{
struct drex_info *first = bts_scen[scen].drex_head;
struct drex_info *drex = bts_scen[scen].drex_head;
int next = 0;
int prev = 0;
if (!drex)
return;
do {
if (drex->enable && !drex->table[scen].next_scen) {
if (scen >= drex->top_scen) {
/* insert at top priority */
drex->table[scen].prev_scen = drex->top_scen;
drex->table[drex->top_scen].next_scen = scen;
drex->top_scen = scen;
drex->table[scen].next_scen = -1;
bts_set_drex_table(drex);
} else {
/* insert at middle */
for (prev = drex->top_scen; prev > scen;
prev = drex->table[prev].prev_scen)
next = prev;
drex->table[scen].prev_scen =
drex->table[next].prev_scen;
drex->table[scen].next_scen =
drex->table[prev].next_scen;
drex->table[next].prev_scen = scen;
drex->table[prev].next_scen = scen;
}
}
drex = drex->table[scen].next_drex;
/* set all DREX in the current scenario */
} while (drex && drex != first);
}
static void bts_drex_pf_add_scen(enum bts_scen_type scen)
{
struct drex_pf_info *first = bts_scen[scen].drex_pf_head;
struct drex_pf_info *drex_pf = bts_scen[scen].drex_pf_head;
int next = 0;
int prev = 0;
if (!drex_pf)
return;
do {
if (drex_pf->enable && !drex_pf->table[scen].next_scen) {
if (scen >= drex_pf->top_scen) {
/* insert at top priority */
drex_pf->table[scen].prev_scen = drex_pf->top_scen;
drex_pf->table[drex_pf->top_scen].next_scen = scen;
drex_pf->top_scen = scen;
drex_pf->table[scen].next_scen = -1;
bts_set_drex_pf_table(drex_pf);
} else {
/* insert at middle */
for (prev = drex_pf->top_scen; prev > scen;
prev = drex_pf->table[prev].prev_scen)
next = prev;
drex_pf->table[scen].prev_scen =
drex_pf->table[next].prev_scen;
drex_pf->table[scen].next_scen =
drex_pf->table[prev].next_scen;
drex_pf->table[next].prev_scen = scen;
drex_pf->table[prev].next_scen = scen;
}
}
drex_pf = drex_pf->table[scen].next_drex_pf;
/* set all DREX_PF in the current scenario */
} while (drex_pf && drex_pf != first);
}
static void bts_add_scen(enum bts_scen_type scen)
{
struct bts_info *first = bts_scen[scen].head;
struct bts_info *bts = bts_scen[scen].head;
int next = 0;
int prev = 0;
if (!bts)
return;
BTS_DBG("[BTS] scen %s on\n", bts_scen[scen].name);
do {
if (bts->enable && !bts->table[scen].next_scen) {
if (scen >= bts->top_scen) {
/* insert at top priority */
bts->table[scen].prev_scen = bts->top_scen;
bts->table[bts->top_scen].next_scen = scen;
bts->top_scen = scen;
bts->table[scen].next_scen = -1;
bts_set_ip_table(bts);
} else {
/* insert at middle */
for (prev = bts->top_scen; prev > scen;
prev = bts->table[prev].prev_scen)
next = prev;
bts->table[scen].prev_scen =
bts->table[next].prev_scen;
bts->table[scen].next_scen =
bts->table[prev].next_scen;
bts->table[next].prev_scen = scen;
bts->table[prev].next_scen = scen;
}
}
bts = bts->table[scen].next_bts;
/* set all bts ip in the current scenario */
} while (bts && bts != first);
bts_drex_add_scen(scen);
bts_drex_pf_add_scen(scen);
}
static void bts_drex_del_scen(enum bts_scen_type scen)
{
struct drex_info *first = bts_scen[scen].drex_head;
struct drex_info *drex = bts_scen[scen].drex_head;
int next = 0;
int prev = 0;
if (!drex)
return;
do {
if (drex->enable && drex->table[scen].next_scen) {
if (scen == drex->top_scen) {
/* revert to prev scenario */
prev = drex->table[scen].prev_scen;
drex->top_scen = prev;
drex->table[prev].next_scen = -1;
drex->table[scen].next_scen = 0;
drex->table[scen].prev_scen = 0;
bts_set_drex_table(drex);
} else if (scen < drex->top_scen) {
/* delete mid scenario */
prev = drex->table[scen].prev_scen;
next = drex->table[scen].next_scen;
drex->table[next].prev_scen =
drex->table[scen].prev_scen;
drex->table[prev].next_scen =
drex->table[scen].next_scen;
drex->table[scen].prev_scen = 0;
drex->table[scen].next_scen = 0;
} else {
BTS_DBG("[BTS]%s scenario couldn't exist above top_scen\n",
bts_scen[scen].name);
}
}
drex = drex->table[scen].next_drex;
/* revert all DREX to prev in the current scenario */
} while (drex && drex != first);
}
static void bts_drex_pf_del_scen(enum bts_scen_type scen)
{
struct drex_pf_info *first = bts_scen[scen].drex_pf_head;
struct drex_pf_info *drex_pf = bts_scen[scen].drex_pf_head;
int next = 0;
int prev = 0;
if (!drex_pf)
return;
do {
if (drex_pf->enable && drex_pf->table[scen].next_scen) {
if (scen == drex_pf->top_scen) {
/* revert to prev scenario */
prev = drex_pf->table[scen].prev_scen;
drex_pf->top_scen = prev;
drex_pf->table[prev].next_scen = -1;
drex_pf->table[scen].next_scen = 0;
drex_pf->table[scen].prev_scen = 0;
bts_set_drex_pf_table(drex_pf);
} else if (scen < drex_pf->top_scen) {
/* delete mid scenario */
prev = drex_pf->table[scen].prev_scen;
next = drex_pf->table[scen].next_scen;
drex_pf->table[next].prev_scen =
drex_pf->table[scen].prev_scen;
drex_pf->table[prev].next_scen =
drex_pf->table[scen].next_scen;
drex_pf->table[scen].prev_scen = 0;
drex_pf->table[scen].next_scen = 0;
} else {
BTS_DBG("[BTS]%s scenario couldn't exist above top_scen\n",
bts_scen[scen].name);
}
}
drex_pf = drex_pf->table[scen].next_drex_pf;
/* revert all DREX_PF to prev in the current scenario */
} while (drex_pf && drex_pf != first);
}
static void bts_del_scen(enum bts_scen_type scen)
{
struct bts_info *first = bts_scen[scen].head;
struct bts_info *bts = bts_scen[scen].head;
int next = 0;
int prev = 0;
if (!bts)
return;
BTS_DBG("[BTS] scen %s off\n", bts_scen[scen].name);
do {
if (bts->enable && bts->table[scen].next_scen) {
if (scen == bts->top_scen) {
/* revert to prev scenario */
prev = bts->table[scen].prev_scen;
bts->top_scen = prev;
bts->table[prev].next_scen = -1;
bts->table[scen].next_scen = 0;
bts->table[scen].prev_scen = 0;
bts_set_ip_table(bts);
} else if (scen < bts->top_scen) {
/* delete mid scenario */
prev = bts->table[scen].prev_scen;
next = bts->table[scen].next_scen;
bts->table[next].prev_scen =
bts->table[scen].prev_scen;
bts->table[prev].next_scen =
bts->table[scen].next_scen;
bts->table[scen].prev_scen = 0;
bts->table[scen].next_scen = 0;
} else {
BTS_DBG("[BTS]%s scenario couldn't exist above top_scen\n",
bts_scen[scen].name);
}
}
bts = bts->table[scen].next_bts;
/* revert all bts ip to prev in the current scenario */
} while (bts && bts != first);
bts_drex_del_scen(scen);
bts_drex_pf_del_scen(scen);
}
void bts_update_scen(enum bts_scen_type scen, unsigned int val)
{
bool on = val ? 1 : 0;
if (scen <= BS_DEFAULT || scen >= BS_MAX)
return;
switch (scen) {
default:
spin_lock(&bts_lock);
if (on)
bts_add_scen(scen);
else
bts_del_scen(scen);
spin_unlock(&bts_lock);
break;
}
}
static void scen_chaining(enum bts_scen_type scen)
{
struct bts_info *prev = NULL;
struct bts_info *first = NULL;
struct bts_info *bts;
struct drex_info *drex_prev = NULL;
struct drex_info *drex_first = NULL;
struct drex_info *drex;
struct drex_pf_info *drex_pf_prev = NULL;
struct drex_pf_info *drex_pf_first = NULL;
struct drex_pf_info *drex_pf;
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
if (bts->table[scen].stat.scen_en) {
if (!first)
first = bts;
if (prev)
prev->table[scen].next_bts = bts;
prev = bts;
}
}
if (prev)
prev->table[scen].next_bts = first;
bts_scen[scen].head = first;
for (drex = exynos_drex;
drex <= &exynos_drex[ARRAY_SIZE(exynos_drex) - 1]; drex++) {
if (drex->table[scen].stat.scen_en) {
if (!drex_first)
drex_first = drex;
if (drex_prev)
drex_prev->table[scen].next_drex = drex;
drex_prev = drex;
}
}
if (drex_prev)
drex_prev->table[scen].next_drex = drex_first;
bts_scen[scen].drex_head = drex_first;
for (drex_pf = exynos_drex_pf;
drex_pf <= &exynos_drex_pf[ARRAY_SIZE(exynos_drex_pf) - 1]; drex_pf++) {
if (drex_pf->table[scen].stat.scen_en) {
if (!drex_pf_first)
drex_pf_first = drex_pf;
if (drex_pf_prev)
drex_pf_prev->table[scen].next_drex_pf = drex_pf;
drex_pf_prev = drex_pf;
}
}
if (drex_pf_prev)
drex_pf_prev->table[scen].next_drex_pf = drex_pf_first;
bts_scen[scen].drex_pf_head = drex_pf_first;
}
#define BIT_PER_BYTE 8
static unsigned int bts_bw_calc(struct bts_decon_info *decon, int idx)
{
struct bts_dpp_info *dpp = &decon->dpp[idx];
unsigned int bw;
unsigned int dst_w, dst_h;
dst_w = dpp->dst.x2 - dpp->dst.x1;
dst_h = dpp->dst.y2 - dpp->dst.y1;
if (!(dst_w && dst_h))
return 0;
/* use multifactor for KB/s */
bw = ((u64)dpp->src_h * dpp->src_w * dpp->bpp * decon->vclk) *
(decon->lcd_w*11 + 480) / decon->lcd_w / 10 /
(BIT_PER_BYTE * dst_h * decon->lcd_w);
return bw;
}
static unsigned int bts_find_max_bw(struct bts_decon_info *decon,
const struct bts_layer_position *input, int idx)
{
struct bts_layer_position output;
struct bts_dpp_info *dpp;
unsigned int max = 0;
int i;
for (i = idx; i < BTS_DPP_MAX; i++) {
dpp = &decon->dpp[i];
if (!dpp->used)
continue;
output.y1 = input->y1 < dpp->dst.y1 ? dpp->dst.y1 : input->y1;
output.y2 = input->y2 > dpp->dst.y2 ? dpp->dst.y2 : input->y2;
output.x1 = input->x1 < dpp->dst.x1 ? dpp->dst.x1 : input->x1;
output.x2 = input->x2 > dpp->dst.x2 ? dpp->dst.x2 : input->x2;
if (output.y1 < output.y2) {
unsigned int bw;
bw = dpp->bw + bts_find_max_bw(decon, &output, i + 1);
if (bw > max)
max = bw;
}
}
return max;
}
static unsigned int bts_update_decon_bw(struct bts_decon_info *decon)
{
unsigned int max = 0;
struct bts_dpp_info *dpp;
int i;
for (i = 0; i < BTS_DPP_MAX; i++) {
dpp = &decon->dpp[i];
if (!dpp->used)
continue;
dpp->bw = bts_bw_calc(decon, i);
}
for (i = 0; i < BTS_DPP_MAX; i++) {
unsigned int bw;
dpp = &decon->dpp[i];
if (!dpp->used)
continue;
bw = dpp->bw + bts_find_max_bw(decon, &dpp->dst, i + 1);
if (bw > max)
max = bw;
}
return max;
}
unsigned int bts_calc_bw(enum bts_bw_type type, void *data)
{
unsigned int bw;
switch (type) {
case BTS_BW_DECON0:
case BTS_BW_DECON1:
case BTS_BW_DECON2:
bw = bts_update_decon_bw(data);
break;
default:
bw = 0;
break;
}
return bw;
}
void bts_update_bw(enum bts_bw_type type, struct bts_bw bw)
{
static struct bts_bw ip_bw[BTS_BW_MAX];
unsigned int mif_freq;
unsigned int total_bw = 0;
unsigned int bw_r = 0;
unsigned int bw_w = 0;
int i;
if (type >= BTS_BW_MAX)
return;
if (ip_bw[type].peak == bw.peak
&& ip_bw[type].read == bw.read
&& ip_bw[type].write == bw.write)
return;
mutex_lock(&media_mutex);
ip_bw[type] = bw;
for (i = 0; i < BTS_BW_MAX; i++) {
bw_r += ip_bw[i].read;
bw_w += ip_bw[i].write;
}
total_bw = bw_r + bw_w;
/* MIF minimum frequency calculation as per BTS guide */
mif_freq = total_bw * 100 / BUS_WIDTH / exynos_mif_util;
pm_qos_update_request(&exynos_mif_bts_qos, mif_freq);
BTS_DBG("[BTS] BW(KB/s): type%i bw %up %ur %uw,\n",
type, bw.peak, bw.read, bw.write);
BTS_DBG("[BTS] BW(KB/s, calc): total %u, read %u, write %u,\n",
total_bw, bw_r, bw_w);
BTS_DBG("[BTS] freq(Khz): mif %u\n", mif_freq);
mutex_unlock(&media_mutex);
}
static void bts_initialize_domains(void)
{
struct bts_info *bts;
struct drex_info *drex;
struct drex_pf_info *drex_pf;
int i;
spin_lock(&bts_lock);
for (drex = exynos_drex;
drex <= &exynos_drex[ARRAY_SIZE(exynos_drex) - 1]; drex++) {
if (!drex->enable)
continue;
bts_set_drex_table(drex);
}
for (drex_pf = exynos_drex_pf;
drex_pf <= &exynos_drex_pf[ARRAY_SIZE(exynos_drex_pf) - 1]; drex_pf++) {
if (!drex_pf->enable)
continue;
bts_set_drex_pf_table(drex_pf);
}
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
if (!bts->enable)
continue;
bts_set_ip_table(bts);
}
for (i = 0; i < ARRAY_SIZE(trex_snode); i++)
bts_set_qmax(trex_snode[i].va_base, exynos_qmax_r[0],
exynos_qmax_r[1], exynos_qmax_w[0], exynos_qmax_w[1]);
spin_unlock(&bts_lock);
}
static int exynos_bts_syscore_suspend(void)
{
return 0;
}
static void exynos_bts_syscore_resume(void)
{
bts_initialize_domains();
}
static struct syscore_ops exynos_bts_syscore_ops = {
.suspend = exynos_bts_syscore_suspend,
.resume = exynos_bts_syscore_resume,
};
#if defined(CONFIG_DEBUG_FS)
static int exynos_qos_status_open_show(struct seq_file *buf, void *d)
{
struct bts_info *bts;
spin_lock(&bts_lock);
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
if (!bts->enable) {
seq_printf(buf, "%5s(disabled):\n", bts->name);
continue;
} else {
seq_printf(buf, "%5s(%s): ",
bts->name, bts_scen[bts->top_scen].name);
}
switch (bts->type) {
case BT_TREX:
bts_showqos(bts->va_base, buf);
break;
default:
seq_puts(buf, "none\n");
}
}
spin_unlock(&bts_lock);
return 0;
}
static int exynos_dmc_timeout_status_open_show(struct seq_file *buf, void *d)
{
struct drex_info *drex;
int i, j, nr_drex = 0;
seq_puts(buf, "\tDREX/Scen/qos/timeout\nex)echo 0 0 0 0x100 > dmc_timeout\n");
spin_lock(&bts_lock);
for (drex = exynos_drex;
drex <= &exynos_drex[ARRAY_SIZE(exynos_drex) - 1]; drex++) {
if (!drex->enable) {
seq_printf(buf, "[%2d]DREX: %s is disabled\n", nr_drex++, drex->name);
continue;
} else {
seq_printf(buf, "[%2d]DREX: %s\n", nr_drex++, drex->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s:\n", bts_scen[i].name);
for (j = 0; j <= BTS_PRIORITY_MAX; j++)
seq_printf(buf, "[0x%x]: 0x%08x\n", j,
drex->table[i].stat.drex_timeout[j]);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_dmc_timeout_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct drex_info *drex;
char *buf;
int drex_ip, scen, qos, ret;
unsigned int timeout;
int nr_drex = ARRAY_SIZE(exynos_drex) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %d %x\n", &drex_ip, &scen, &qos, &timeout);
if (ret != 4) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (drex_ip < 0 || drex_ip > nr_drex || scen < 0 ||
scen > nr_scen || qos < 0 || qos > BTS_PRIORITY_MAX) {
pr_err("Invalid variable\n");
goto out;
}
drex = &exynos_drex[drex_ip];
spin_lock(&bts_lock);
drex->table[scen].stat.drex_timeout[qos] = timeout;
if (!drex->table[scen].stat.scen_en) {
drex->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == drex->top_scen)
bts_set_drex_table(drex);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_mo_status_open_show(struct seq_file *buf, void *d)
{
struct bts_info *bts;
int i, nr_ip = 0;
seq_puts(buf, "\tIP/Scen/RW/MO\nex)echo 0 0 0 16 > mo\n");
spin_lock(&bts_lock);
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
if (!bts->enable) {
seq_printf(buf, "[%2d]IP: %s is disabled\n", nr_ip++, bts->name);
continue;
} else {
seq_printf(buf, "[%2d]IP: %s\n", nr_ip++, bts->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s: rmo:0x%x wmo:0x%x\n",
bts_scen[i].name,
bts->table[i].stat.rmo,
bts->table[i].stat.wmo);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_mo_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct bts_info *bts = NULL;
char *buf;
int ip, scen, rw, mo, ret;
int nr_ip = ARRAY_SIZE(exynos_bts) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %d %d\n", &ip, &scen, &rw, &mo);
if (ret != 4) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (ip < 0 || ip > nr_ip || scen < 0 ||
scen > nr_scen || rw < 0 || mo < 0) {
pr_info("Invalid variable\n");
goto out;
}
bts = &exynos_bts[ip];
spin_lock(&bts_lock);
if (!rw)
bts->table[scen].stat.rmo = mo;
else
bts->table[scen].stat.wmo = mo;
if (!bts->table[scen].stat.scen_en) {
bts->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == bts->top_scen)
bts_setqos(bts->va_base, &bts->table[scen].stat);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_max_mo_status_open_show(struct seq_file *buf, void *d)
{
struct bts_info *bts;
int i, nr_ip = 0;
seq_puts(buf, "\tIP/Scen/RW/MO\nex)echo 0 0 0 16 > max_mo\n");
spin_lock(&bts_lock);
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
if (!bts->enable) {
seq_printf(buf, "[%2d]IP: %s is disabled\n", nr_ip++, bts->name);
continue;
} else {
seq_printf(buf, "[%2d]IP: %s\n", nr_ip++, bts->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s: max_rmo:0x%x max_wmo:0x%x\n",
bts_scen[i].name,
bts->table[i].stat.max_rmo,
bts->table[i].stat.max_wmo);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_max_mo_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct bts_info *bts = NULL;
char *buf;
int ip, scen, rw, mo, ret;
int nr_ip = ARRAY_SIZE(exynos_bts) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %d %d\n", &ip, &scen, &rw, &mo);
if (ret != 4) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (ip < 0 || ip > nr_ip || scen < 0 ||
scen > nr_scen || rw < 0 || mo < 0) {
pr_info("Invalid variable\n");
goto out;
}
bts = &exynos_bts[ip];
spin_lock(&bts_lock);
if (!rw)
bts->table[scen].stat.max_rmo = mo;
else
bts->table[scen].stat.max_wmo = mo;
if (!bts->table[scen].stat.scen_en) {
bts->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == bts->top_scen)
bts_setqos(bts->va_base, &bts->table[scen].stat);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_full_mo_status_open_show(struct seq_file *buf, void *d)
{
struct bts_info *bts;
int i, nr_ip = 0;
seq_puts(buf, "\tIP/Scen/RW/MO\nex)echo 0 0 0 16 > full_mo\n");
spin_lock(&bts_lock);
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
if (!bts->enable) {
seq_printf(buf, "[%2d]IP: %s is disabled\n", nr_ip++, bts->name);
continue;
} else {
seq_printf(buf, "[%2d]IP: %s\n", nr_ip++, bts->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s: full_rmo:0x%x full_wmo:0x%x\n",
bts_scen[i].name,
bts->table[i].stat.full_rmo,
bts->table[i].stat.full_wmo);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_full_mo_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct bts_info *bts = NULL;
char *buf;
int ip, scen, rw, mo, ret;
int nr_ip = ARRAY_SIZE(exynos_bts) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %d %d\n", &ip, &scen, &rw, &mo);
if (ret != 4) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (ip < 0 || ip > nr_ip || scen < 0 ||
scen > nr_scen || rw < 0 || mo < 0) {
pr_info("Invalid variable\n");
goto out;
}
bts = &exynos_bts[ip];
spin_lock(&bts_lock);
if (!rw)
bts->table[scen].stat.full_rmo = mo;
else
bts->table[scen].stat.full_wmo = mo;
if (!bts->table[scen].stat.scen_en) {
bts->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == bts->top_scen)
bts_setqos(bts->va_base, &bts->table[scen].stat);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_prio_status_open_show(struct seq_file *buf, void *d)
{
struct bts_info *bts;
int i, nr_ip = 0;
seq_puts(buf, "\tqos IP/Scen/Prio\nex)echo 0 0 8 > priority\n");
spin_lock(&bts_lock);
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
if (!bts->enable) {
seq_printf(buf, "[%2d]IP: %s is disabled\n", nr_ip++, bts->name);
continue;
} else {
seq_printf(buf, "[%2d]IP: %s\n", nr_ip++, bts->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s: %d\n",
bts_scen[i].name, bts->table[i].stat.priority);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_prio_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct bts_info *bts = NULL;
char *buf;
int ip, scen, prio, ret;
int nr_ip = ARRAY_SIZE(exynos_bts) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %d\n", &ip, &scen, &prio);
if (ret != 3) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (ip < 0 || ip > nr_ip || scen < 0 ||
scen > nr_scen || prio < 0 || prio > 0xf) {
pr_info("Invalid variable\n");
goto out;
}
bts = &exynos_bts[ip];
spin_lock(&bts_lock);
bts->table[scen].stat.priority = prio;
if (!bts->table[scen].stat.scen_en) {
bts->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == bts->top_scen)
bts_setqos(bts->va_base, &bts->table[scen].stat);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_scen_status_open_show(struct seq_file *buf, void *d)
{
int i;
seq_puts(buf, "\tqos Scen/On\nex)echo 1 1 > scenario\n");
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "[%2d]%9s\n", i, bts_scen[i].name);
}
return 0;
}
static ssize_t exynos_scen_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
char *buf;
int ret;
u32 scen, on;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%u %u", &scen, &on);
if (ret != 2) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (scen >= BS_MAX) {
pr_err("Invalid variable\n");
goto out;
}
bts_update_scen((enum bts_scen_type)scen, on);
out:
kfree(buf);
return count;
}
static int exynos_addr_status_open_show(struct seq_file *buf, void *d)
{
struct bts_info *bts;
spin_lock(&bts_lock);
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
if (!bts->enable)
continue;
seq_printf(buf, "[IP: %9s]:0x%x\n", bts->name, bts->pa_base);
}
spin_unlock(&bts_lock);
return 0;
}
static int exynos_qmax_status_open_show(struct seq_file *buf, void *d)
{
int i;
seq_puts(buf, "\tr0_thrd\\r1_thrd\\w0_thrd\\w1_thrd\nex)echo 20 20 12 12 > qmax\n");
spin_lock(&bts_lock);
for (i = 0; i < ARRAY_SIZE(trex_snode); i++) {
seq_printf(buf, "[0x%08x]: ", trex_snode[i].pa_base);
bts_show_qmax(trex_snode[i].va_base, buf);
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_qmax_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
char *buf;
unsigned int r0, r1, w0, w1;
int i, ret;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%u %u %u %u\n", &r0, &r1, &w0, &w1);
if (ret != 4) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (r0 > BTS_QMAX_MAX_THRESHOLD || r1 > BTS_QMAX_MAX_THRESHOLD ||
w0 > BTS_QMAX_MAX_THRESHOLD || w1 > BTS_QMAX_MAX_THRESHOLD) {
pr_err("Invalid variable\n");
goto out;
}
spin_lock(&bts_lock);
exynos_qmax_r[0] = r0;
exynos_qmax_r[1] = r1;
exynos_qmax_w[0] = w0;
exynos_qmax_w[1] = w1;
for (i = 0; i < ARRAY_SIZE(trex_snode); i++)
bts_set_qmax(trex_snode[i].va_base, r0, r1, w0, w1);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_timeout_status_open_show(struct seq_file *buf, void *d)
{
struct bts_info *bts;
int i, nr_ip = 0;
seq_puts(buf, "\tIP/Scen/RW/timeout\nex)echo 0 0 0 16 > timeout\n");
spin_lock(&bts_lock);
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
if (!bts->enable) {
seq_printf(buf, "[%2d]IP: %s is disabled\n", nr_ip++, bts->name);
continue;
} else {
seq_printf(buf, "[%2d]IP: %s\n", nr_ip++, bts->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s: timeout_r:0x%x timeout_w:0x%x\n",
bts_scen[i].name,
bts->table[i].stat.timeout_r,
bts->table[i].stat.timeout_w);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_timeout_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct bts_info *bts = NULL;
char *buf;
int ip, scen, rw, timeout, ret;
int nr_ip = ARRAY_SIZE(exynos_bts) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %d %d\n", &ip, &scen, &rw, &timeout);
if (ret != 4) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (ip < 0 || ip > nr_ip || scen < 0 ||
scen > nr_scen || rw < 0 || timeout < 0) {
pr_info("Invalid variable\n");
goto out;
}
bts = &exynos_bts[ip];
spin_lock(&bts_lock);
if (!rw)
bts->table[scen].stat.timeout_r = timeout;
else
bts->table[scen].stat.timeout_w = timeout;
if (!bts->table[scen].stat.scen_en) {
bts->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == bts->top_scen)
bts_setqos(bts->va_base, &bts->table[scen].stat);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_timeout_en_status_open_show(struct seq_file *buf, void *d)
{
struct bts_info *bts;
int i, nr_ip = 0;
seq_puts(buf, "\tIP/Scen/Enable\nex)echo 0 0 1 > timeout_en\n");
spin_lock(&bts_lock);
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
if (!bts->enable) {
seq_printf(buf, "[%2d]IP: %s is disabled\n", nr_ip++, bts->name);
continue;
} else {
seq_printf(buf, "[%2d]IP: %s\n", nr_ip++, bts->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s: timeout_en:%d\n",
bts_scen[i].name,
bts->table[i].stat.timeout_en);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_timeout_en_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct bts_info *bts = NULL;
char *buf;
int ip, scen, timeout_en, ret;
int nr_ip = ARRAY_SIZE(exynos_bts) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %d\n", &ip, &scen, &timeout_en);
if (ret != 3) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (ip < 0 || ip > nr_ip || scen < 0 ||
scen > nr_scen || timeout_en < 0) {
pr_info("Invalid variable\n");
goto out;
}
bts = &exynos_bts[ip];
spin_lock(&bts_lock);
bts->table[scen].stat.timeout_en = timeout_en;
if (!bts->table[scen].stat.scen_en) {
bts->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == bts->top_scen)
bts_setqos(bts->va_base, &bts->table[scen].stat);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_write_flush_status_open_show(struct seq_file *buf, void *d)
{
struct drex_info *drex;
int i, j, nr_drex = 0;
seq_puts(buf, "\tDREX/Scen/set/config\nex)echo 0 0 0 0xA0201404 > write_flush\n");
spin_lock(&bts_lock);
for (drex = exynos_drex;
drex <= &exynos_drex[ARRAY_SIZE(exynos_drex) - 1]; drex++) {
if (!drex->enable) {
seq_printf(buf, "[%2d]DREX: %s is disabled\n", nr_drex++, drex->name);
continue;
} else {
seq_printf(buf, "[%2d]DREX: %s\n", nr_drex++, drex->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s:\n", bts_scen[i].name);
for (j = 0; j < 2; j++)
seq_printf(buf, "[%d]: 0x%08x\n", j,
drex->table[i].stat.write_flush_config[j]);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_write_flush_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct drex_info *drex;
char *buf;
int drex_ip, scen, set, ret;
unsigned int config;
int nr_drex = ARRAY_SIZE(exynos_drex) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %d %x\n", &drex_ip, &scen, &set, &config);
if (ret != 4) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (drex_ip < 0 || drex_ip > nr_drex || scen < 0 ||
scen > nr_scen || set < 0 || set >= 2) {
pr_err("Invalid variable\n");
goto out;
}
drex = &exynos_drex[drex_ip];
spin_lock(&bts_lock);
drex->table[scen].stat.write_flush_config[set] = config;
if (!drex->table[scen].stat.scen_en) {
drex->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == drex->top_scen)
bts_set_drex_table(drex);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_vc_timer_th_status_open_show(struct seq_file *buf, void *d)
{
struct drex_info *drex;
int i, j, nr_drex = 0;
seq_puts(buf, "\tDREX/Scen/qos/threshold\nex)echo 0 0 0 0x1D > vc_timer_th\n");
spin_lock(&bts_lock);
for (drex = exynos_drex;
drex <= &exynos_drex[ARRAY_SIZE(exynos_drex) - 1]; drex++) {
if (!drex->enable) {
seq_printf(buf, "[%2d]DREX: %s is disabled\n", nr_drex++, drex->name);
continue;
} else {
seq_printf(buf, "[%2d]DREX: %s\n", nr_drex++, drex->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s:\n", bts_scen[i].name);
for (j = 0; j < BTS_VC_TIMER_TH_NR; j++) {
seq_printf(buf, "[0x%x]: 0x%04x\n", j * 2,
drex->table[i].stat.vc_timer_th[j] & BTS_VC_TIMER_TH_MASK);
seq_printf(buf, "[0x%x]: 0x%04x\n", j * 2 + 1,
(drex->table[i].stat.vc_timer_th[j] >>
BTS_VC_TIMER_TH_H_SHIFT) & BTS_VC_TIMER_TH_MASK);
}
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_vc_timer_th_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct drex_info *drex;
char *buf;
int drex_ip, scen, qos, set, ret;
unsigned int threshold;
int nr_drex = ARRAY_SIZE(exynos_drex) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %d %x\n", &drex_ip, &scen, &qos, &threshold);
if (ret != 4) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (drex_ip < 0 || drex_ip > nr_drex || scen < 0 ||
scen > nr_scen || qos < 0 || qos > BTS_PRIORITY_MAX) {
pr_err("Invalid variable\n");
goto out;
}
drex = &exynos_drex[drex_ip];
spin_lock(&bts_lock);
set = qos / 2;
if (qos % 2) {
drex->table[scen].stat.vc_timer_th[set] &=
~(BTS_VC_TIMER_TH_MASK << BTS_VC_TIMER_TH_H_SHIFT);
drex->table[scen].stat.vc_timer_th[set] |=
(threshold & BTS_VC_TIMER_TH_MASK) << BTS_VC_TIMER_TH_H_SHIFT;
} else {
drex->table[scen].stat.vc_timer_th[set] &=
~(BTS_VC_TIMER_TH_MASK);
drex->table[scen].stat.vc_timer_th[set] |=
(threshold & BTS_VC_TIMER_TH_MASK);
}
if (!drex->table[scen].stat.scen_en) {
drex->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == drex->top_scen)
bts_set_drex_table(drex);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_cutoff_con_status_open_show(struct seq_file *buf, void *d)
{
struct drex_info *drex;
int i, nr_drex = 0;
seq_puts(buf, "\tDREX/Scen/control\nex)echo 0 0 0x00000005 > cutoff_con\n");
spin_lock(&bts_lock);
for (drex = exynos_drex;
drex <= &exynos_drex[ARRAY_SIZE(exynos_drex) - 1]; drex++) {
if (!drex->enable) {
seq_printf(buf, "[%2d]DREX: %s is disabled\n", nr_drex++, drex->name);
continue;
} else {
seq_printf(buf, "[%2d]DREX: %s\n", nr_drex++, drex->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s:\n", bts_scen[i].name);
seq_printf(buf, " : 0x%08x\n", drex->table[i].stat.cutoff_con);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_cutoff_con_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct drex_info *drex;
char *buf;
int drex_ip, scen, ret;
unsigned int control;
int nr_drex = ARRAY_SIZE(exynos_drex) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %x\n", &drex_ip, &scen, &control);
if (ret != 3) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (drex_ip < 0 || drex_ip > nr_drex || scen < 0 ||
scen > nr_scen) {
pr_err("Invalid variable\n");
goto out;
}
drex = &exynos_drex[drex_ip];
spin_lock(&bts_lock);
drex->table[scen].stat.cutoff_con = control;
if (!drex->table[scen].stat.scen_en) {
drex->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == drex->top_scen)
bts_set_drex_table(drex);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_brb_cutoff_status_open_show(struct seq_file *buf, void *d)
{
struct drex_info *drex;
int i, nr_drex = 0;
seq_puts(buf, "\tDREX/Scen/config\nex)echo 0 0 0x00080008 > brb_cutoff\n");
spin_lock(&bts_lock);
for (drex = exynos_drex;
drex <= &exynos_drex[ARRAY_SIZE(exynos_drex) - 1]; drex++) {
if (!drex->enable) {
seq_printf(buf, "[%2d]DREX: %s is disabled\n", nr_drex++, drex->name);
continue;
} else {
seq_printf(buf, "[%2d]DREX: %s\n", nr_drex++, drex->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s:\n", bts_scen[i].name);
seq_printf(buf, " : 0x%08x\n", drex->table[i].stat.brb_cutoff_config);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_brb_cutoff_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct drex_info *drex;
char *buf;
int drex_ip, scen, ret;
unsigned int config;
int nr_drex = ARRAY_SIZE(exynos_drex) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %x\n", &drex_ip, &scen, &config);
if (ret != 3) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (drex_ip < 0 || drex_ip > nr_drex || scen < 0 ||
scen > nr_scen) {
pr_err("Invalid variable\n");
goto out;
}
drex = &exynos_drex[drex_ip];
spin_lock(&bts_lock);
drex->table[scen].stat.brb_cutoff_config = config;
if (!drex->table[scen].stat.scen_en) {
drex->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == drex->top_scen)
bts_set_drex_table(drex);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_rdbuf_cutoff_status_open_show(struct seq_file *buf, void *d)
{
struct drex_info *drex;
int i, nr_drex = 0;
seq_puts(buf, "\tDREX/Scen/config\nex)echo 0 0 0x00080008 > rdbuf_cutoff\n");
spin_lock(&bts_lock);
for (drex = exynos_drex;
drex <= &exynos_drex[ARRAY_SIZE(exynos_drex) - 1]; drex++) {
if (!drex->enable) {
seq_printf(buf, "[%2d]DREX: %s is disabled\n", nr_drex++, drex->name);
continue;
} else {
seq_printf(buf, "[%2d]DREX: %s\n", nr_drex++, drex->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s:\n", bts_scen[i].name);
seq_printf(buf, " : 0x%08x\n", drex->table[i].stat.rdbuf_cutoff_config);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_rdbuf_cutoff_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct drex_info *drex;
char *buf;
int drex_ip, scen, ret;
unsigned int config;
int nr_drex = ARRAY_SIZE(exynos_drex) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %x\n", &drex_ip, &scen, &config);
if (ret != 3) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (drex_ip < 0 || drex_ip > nr_drex || scen < 0 ||
scen > nr_scen) {
pr_err("Invalid variable\n");
goto out;
}
drex = &exynos_drex[drex_ip];
spin_lock(&bts_lock);
drex->table[scen].stat.rdbuf_cutoff_config = config;
if (!drex->table[scen].stat.scen_en) {
drex->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == drex->top_scen)
bts_set_drex_table(drex);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_rreq_thrt_con_status_open_show(struct seq_file *buf, void *d)
{
struct drex_pf_info *drex_pf;
int i, nr_drex_pf = 0;
seq_puts(buf, "\tDREX/Scen/control\nex)echo 0 0 0x00008000 > rreq_thrt_con\n");
spin_lock(&bts_lock);
for (drex_pf = exynos_drex_pf;
drex_pf <= &exynos_drex_pf[ARRAY_SIZE(exynos_drex_pf) - 1]; drex_pf++) {
if (!drex_pf->enable) {
seq_printf(buf, "[%2d]DREX: %s is disabled\n", nr_drex_pf++, drex_pf->name);
continue;
} else {
seq_printf(buf, "[%2d]DREX: %s\n", nr_drex_pf++, drex_pf->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s:\n", bts_scen[i].name);
seq_printf(buf, " : 0x%08x\n", drex_pf->table[i].stat.pf_rreq_thrt_con);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_rreq_thrt_con_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct drex_pf_info *drex_pf;
char *buf;
int drex_pf_ip, scen, ret;
unsigned int control;
int nr_drex_pf = ARRAY_SIZE(exynos_drex_pf) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %x\n", &drex_pf_ip, &scen, &control);
if (ret != 3) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (drex_pf_ip < 0 || drex_pf_ip > nr_drex_pf || scen < 0 ||
scen > nr_scen) {
pr_err("Invalid variable\n");
goto out;
}
drex_pf = &exynos_drex_pf[drex_pf_ip];
spin_lock(&bts_lock);
drex_pf->table[scen].stat.pf_rreq_thrt_con = control;
if (!drex_pf->table[scen].stat.scen_en) {
drex_pf->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == drex_pf->top_scen)
bts_set_drex_pf_table(drex_pf);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_allow_mo_region_status_open_show(struct seq_file *buf, void *d)
{
struct drex_pf_info *drex_pf;
int i, nr_drex_pf = 0;
seq_puts(buf, "\tDREX/Scen/config\nex)echo 0 0 0x02040608 > allow_mo_region\n");
spin_lock(&bts_lock);
for (drex_pf = exynos_drex_pf;
drex_pf <= &exynos_drex_pf[ARRAY_SIZE(exynos_drex_pf) - 1]; drex_pf++) {
if (!drex_pf->enable) {
seq_printf(buf, "[%2d]DREX: %s is disabled\n", nr_drex_pf++, drex_pf->name);
continue;
} else {
seq_printf(buf, "[%2d]DREX: %s\n", nr_drex_pf++, drex_pf->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s:\n", bts_scen[i].name);
seq_printf(buf, " : 0x%08x\n", drex_pf->table[i].stat.allow_mo_for_region);
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_allow_mo_region_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct drex_pf_info *drex_pf;
char *buf;
int drex_pf_ip, scen, ret;
unsigned int config;
int nr_drex_pf = ARRAY_SIZE(exynos_drex_pf) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %x\n", &drex_pf_ip, &scen, &config);
if (ret != 3) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (drex_pf_ip < 0 || drex_pf_ip > nr_drex_pf || scen < 0 ||
scen > nr_scen) {
pr_err("Invalid variable\n");
goto out;
}
drex_pf = &exynos_drex_pf[drex_pf_ip];
spin_lock(&bts_lock);
drex_pf->table[scen].stat.allow_mo_for_region = config;
if (!drex_pf->table[scen].stat.scen_en) {
drex_pf->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == drex_pf->top_scen)
bts_set_drex_pf_table(drex_pf);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_pf_qos_timer_status_open_show(struct seq_file *buf, void *d)
{
struct drex_pf_info *drex_pf;
int i, j, nr_drex_pf = 0;
seq_puts(buf, "\tDREX/Scen/qos/timeout\nex)echo 0 0 0 0x5 > pf_qos_timer\n");
spin_lock(&bts_lock);
for (drex_pf = exynos_drex_pf;
drex_pf <= &exynos_drex_pf[ARRAY_SIZE(exynos_drex_pf) - 1]; drex_pf++) {
if (!drex_pf->enable) {
seq_printf(buf, "[%2d]DREX: %s is disabled\n", nr_drex_pf++, drex_pf->name);
continue;
} else {
seq_printf(buf, "[%2d]DREX: %s\n", nr_drex_pf++, drex_pf->name);
}
for (i = 0; i < BS_MAX; i++) {
if (!bts_scen[i].name)
continue;
seq_printf(buf, "%6s:\n", bts_scen[i].name);
for (j = 0; j < BTS_PF_TIMER_NR; j++) {
seq_printf(buf, "[0x%x]: 0x%04x\n", j * 2,
drex_pf->table[i].stat.pf_qos_timer[j] & BTS_PF_TIMER_MASK);
seq_printf(buf, "[0x%x]: 0x%04x\n", j * 2 + 1,
(drex_pf->table[i].stat.pf_qos_timer[j] >>
BTS_PF_TIMER_H_SHIFT) & BTS_PF_TIMER_MASK);
}
}
}
spin_unlock(&bts_lock);
return 0;
}
static ssize_t exynos_pf_qos_timer_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
struct drex_pf_info *drex_pf;
char *buf;
int drex_pf_ip, scen, qos, set, ret;
unsigned int timeout;
int nr_drex_pf = ARRAY_SIZE(exynos_drex_pf) - 1;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d %d %x\n", &drex_pf_ip, &scen, &qos, &timeout);
if (ret != 4) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (drex_pf_ip < 0 || drex_pf_ip > nr_drex_pf || scen < 0 ||
scen > nr_scen || qos < 0 || qos > BTS_PRIORITY_MAX) {
pr_err("Invalid variable\n");
goto out;
}
drex_pf = &exynos_drex_pf[drex_pf_ip];
spin_lock(&bts_lock);
set = qos / 2;
if (qos % 2) {
drex_pf->table[scen].stat.pf_qos_timer[set] &=
~(BTS_PF_TIMER_MASK << BTS_PF_TIMER_H_SHIFT);
drex_pf->table[scen].stat.pf_qos_timer[set] |=
(timeout & BTS_PF_TIMER_MASK) << BTS_PF_TIMER_H_SHIFT;
} else {
drex_pf->table[scen].stat.pf_qos_timer[set] &=
~(BTS_PF_TIMER_MASK);
drex_pf->table[scen].stat.pf_qos_timer[set] |=
(timeout & BTS_PF_TIMER_MASK);
}
if (!drex_pf->table[scen].stat.scen_en) {
drex_pf->table[scen].stat.scen_en = true;
scen_chaining(scen);
}
if (scen == drex_pf->top_scen)
bts_set_drex_pf_table(drex_pf);
spin_unlock(&bts_lock);
out:
kfree(buf);
return count;
}
static int exynos_bts_scen_test_status_open_show(struct seq_file *buf, void *d)
{
seq_puts(buf, "\tScen/control\nex)echo 0 1 > bts_scen_test\n");
return 0;
}
static ssize_t exynos_bts_scen_test_write(struct file *file, const char __user *user_buf,
size_t count, loff_t *ppos)
{
char *buf;
int scen, control, ret;
int nr_scen = ARRAY_SIZE(bts_scen) - 1;
ssize_t len;
buf = kmalloc(count, GFP_KERNEL);
if (buf == NULL)
return -ENOMEM;
len = simple_write_to_buffer(buf, count, ppos, user_buf, count);
if (len < 0) {
kfree(buf);
return len;
}
buf[len] = '\0';
ret = sscanf(buf, "%d %d\n", &scen, &control);
if (ret != 2) {
pr_err("%s, Failed at sscanf function: %d\n", __func__, ret);
goto out;
}
if (scen < 0 || scen > nr_scen || control < 0) {
pr_err("Invalid variable\n");
goto out;
}
bts_update_scen((enum bts_scen_type)scen, control);
out:
kfree(buf);
return count;
}
static int exynos_qos_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_qos_status_open_show, inode->i_private);
}
static int exynos_dmc_timeout_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_dmc_timeout_status_open_show, inode->i_private);
}
static int exynos_mo_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_mo_status_open_show, inode->i_private);
}
static int exynos_max_mo_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_max_mo_status_open_show, inode->i_private);
}
static int exynos_full_mo_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_full_mo_status_open_show, inode->i_private);
}
static int exynos_prio_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_prio_status_open_show, inode->i_private);
}
static int exynos_scen_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_scen_status_open_show, inode->i_private);
}
static int exynos_addr_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_addr_status_open_show, inode->i_private);
}
static int exynos_qmax_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_qmax_status_open_show, inode->i_private);
}
static int exynos_timeout_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_timeout_status_open_show, inode->i_private);
}
static int exynos_timeout_en_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_timeout_en_status_open_show, inode->i_private);
}
static int exynos_write_flush_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_write_flush_status_open_show, inode->i_private);
}
static int exynos_vc_timer_th_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_vc_timer_th_status_open_show, inode->i_private);
}
static int exynos_cutoff_con_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_cutoff_con_status_open_show, inode->i_private);
}
static int exynos_brb_cutoff_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_brb_cutoff_status_open_show, inode->i_private);
}
static int exynos_rdbuf_cutoff_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_rdbuf_cutoff_status_open_show, inode->i_private);
}
static int exynos_rreq_thrt_con_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_rreq_thrt_con_status_open_show, inode->i_private);
}
static int exynos_allow_mo_region_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_allow_mo_region_status_open_show, inode->i_private);
}
static int exynos_pf_qos_timer_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_pf_qos_timer_status_open_show, inode->i_private);
}
static int exynos_bts_scen_test_open(struct inode *inode, struct file *file)
{
return single_open(file, exynos_bts_scen_test_status_open_show, inode->i_private);
}
static const struct file_operations debug_qos_status_fops = {
.open = exynos_qos_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_dmc_timeout_status_fops = {
.open = exynos_dmc_timeout_open,
.read = seq_read,
.write = exynos_dmc_timeout_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_mo_status_fops = {
.open = exynos_mo_open,
.read = seq_read,
.write = exynos_mo_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_max_mo_status_fops = {
.open = exynos_max_mo_open,
.read = seq_read,
.write = exynos_max_mo_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_full_mo_status_fops = {
.open = exynos_full_mo_open,
.read = seq_read,
.write = exynos_full_mo_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_prio_status_fops = {
.open = exynos_prio_open,
.read = seq_read,
.write = exynos_prio_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_scen_status_fops = {
.open = exynos_scen_open,
.read = seq_read,
.write = exynos_scen_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_addr_status_fops = {
.open = exynos_addr_open,
.read = seq_read,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_qmax_status_fops = {
.open = exynos_qmax_open,
.read = seq_read,
.write = exynos_qmax_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_timeout_status_fops = {
.open = exynos_timeout_open,
.read = seq_read,
.write = exynos_timeout_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_timeout_en_status_fops = {
.open = exynos_timeout_en_open,
.read = seq_read,
.write = exynos_timeout_en_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_write_flush_status_fops = {
.open = exynos_write_flush_open,
.read = seq_read,
.write = exynos_write_flush_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_vc_timer_th_status_fops = {
.open = exynos_vc_timer_th_open,
.read = seq_read,
.write = exynos_vc_timer_th_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_cutoff_con_status_fops = {
.open = exynos_cutoff_con_open,
.read = seq_read,
.write = exynos_cutoff_con_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_brb_cutoff_status_fops = {
.open = exynos_brb_cutoff_open,
.read = seq_read,
.write = exynos_brb_cutoff_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_rdbuf_cutoff_status_fops = {
.open = exynos_rdbuf_cutoff_open,
.read = seq_read,
.write = exynos_rdbuf_cutoff_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_rreq_thrt_con_status_fops = {
.open = exynos_rreq_thrt_con_open,
.read = seq_read,
.write = exynos_rreq_thrt_con_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_allow_mo_region_status_fops = {
.open = exynos_allow_mo_region_open,
.read = seq_read,
.write = exynos_allow_mo_region_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_pf_qos_timer_status_fops = {
.open = exynos_pf_qos_timer_open,
.read = seq_read,
.write = exynos_pf_qos_timer_write,
.llseek = seq_lseek,
.release = single_release,
};
static const struct file_operations debug_bts_scen_test_status_fops = {
.open = exynos_bts_scen_test_open,
.read = seq_read,
.write = exynos_bts_scen_test_write,
.llseek = seq_lseek,
.release = single_release,
};
static void bts_debugfs(void)
{
struct dentry *den;
den = debugfs_create_dir("bts", NULL);
if (IS_ERR_OR_NULL(den)) {
pr_err("%s debugfs create directory failed\n", __func__);
return;
}
debugfs_create_file("qos", 0440, den, NULL, &debug_qos_status_fops);
debugfs_create_file("mo", 0644, den, NULL, &debug_mo_status_fops);
debugfs_create_file("max_mo", 0644, den, NULL, &debug_max_mo_status_fops);
debugfs_create_file("full_mo", 0644, den, NULL, &debug_full_mo_status_fops);
debugfs_create_file("dmc_timeout", 0644, den, NULL,
&debug_dmc_timeout_status_fops);
debugfs_create_file("priority", 0644, den, NULL, &debug_prio_status_fops);
debugfs_create_file("scenario", 0640, den, NULL, &debug_scen_status_fops);
debugfs_create_file("address", 0440, den, NULL, &debug_addr_status_fops);
debugfs_create_file("qmax", 0640, den, NULL, &debug_qmax_status_fops);
debugfs_create_file("timeout", 0640, den, NULL, &debug_timeout_status_fops);
debugfs_create_file("timeout_en", 0640, den, NULL, &debug_timeout_en_status_fops);
debugfs_create_file("write_flush", 0640, den, NULL, &debug_write_flush_status_fops);
debugfs_create_file("vc_timer_th", 0640, den, NULL, &debug_vc_timer_th_status_fops);
debugfs_create_file("cutoff_con", 0640, den, NULL, &debug_cutoff_con_status_fops);
debugfs_create_file("brb_cutoff", 0640, den, NULL, &debug_brb_cutoff_status_fops);
debugfs_create_file("rdbuf_cutoff", 0640, den, NULL, &debug_rdbuf_cutoff_status_fops);
debugfs_create_file("rreq_thrt_con", 0640, den, NULL, &debug_rreq_thrt_con_status_fops);
debugfs_create_file("allow_mo_region", 0640, den, NULL, &debug_allow_mo_region_status_fops);
debugfs_create_file("pf_qos_timer", 0640, den, NULL, &debug_pf_qos_timer_status_fops);
debugfs_create_file("bts_scen_test", 0640, den, NULL, &debug_bts_scen_test_status_fops);
if (!debugfs_create_u32("log", 0644, den, &exynos_bts_log))
pr_err("[BTS]: could't create debugfs bts log\n");
if (!debugfs_create_u32("mif_util", 0644, den, &exynos_mif_util))
pr_err("[BTS]: could't create debugfs mif util\n");
}
#else
static void bts_debugfs(void)
{
pr_info("%s is disabled, check configuration\n", __func__);
}
#endif
static int __init exynos_bts_init(void)
{
unsigned int i;
int ret = 0;
struct bts_info *bts;
struct drex_info *drex;
struct drex_pf_info *drex_pf;
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
bts->va_base = ioremap(bts->pa_base, SZ_2K);
if (!bts->va_base) {
pr_err("failed to map bts physical address\n");
bts->enable = false;
}
}
for (drex = exynos_drex;
drex <= &exynos_drex[ARRAY_SIZE(exynos_drex) - 1]; drex++) {
drex->va_base = ioremap(drex->pa_base, SZ_4K);
if (!drex->va_base) {
pr_err("failed to map %s physical address\n", drex->name);
ret = -ENOMEM;
goto err_drex;
}
}
for (drex_pf = exynos_drex_pf;
drex_pf <= &exynos_drex_pf[ARRAY_SIZE(exynos_drex_pf) - 1]; drex_pf++) {
drex_pf->va_base = ioremap(drex_pf->pa_base, SZ_4K);
if (!drex_pf->va_base) {
pr_err("failed to map %s physical address\n", drex_pf->name);
ret = -ENOMEM;
goto err_drex_pf;
}
}
for (i = 0; i < ARRAY_SIZE(trex_snode); i++) {
trex_snode[i].va_base = ioremap(trex_snode[i].pa_base, SZ_1K);
if (!trex_snode[i].va_base) {
pr_err("failed to map trex_snode physical address\n");
ret = -ENOMEM;
goto err_trex_snode;
}
}
for (i = BS_DEFAULT + 1; i < BS_MAX; i++)
scen_chaining(i);
bts_initialize_domains();
pm_qos_add_request(&exynos_mif_bts_qos, PM_QOS_BUS_THROUGHPUT, 0);
register_syscore_ops(&exynos_bts_syscore_ops);
bts_debugfs();
pr_info("BTS: driver is initialized\n");
return 0;
err_trex_snode:
for (i = 0; i < ARRAY_SIZE(trex_snode); i++) {
if (trex_snode[i].va_base)
iounmap(trex_snode[i].va_base);
}
err_drex_pf:
for (drex_pf = exynos_drex_pf;
drex_pf <= &exynos_drex_pf[ARRAY_SIZE(exynos_drex_pf) - 1]; drex_pf++) {
if (drex_pf->va_base)
iounmap(drex_pf->va_base);
}
err_drex:
for (drex = exynos_drex;
drex <= &exynos_drex[ARRAY_SIZE(exynos_drex) - 1]; drex++) {
if (drex->va_base)
iounmap(drex->va_base);
}
for (bts = exynos_bts;
bts <= &exynos_bts[ARRAY_SIZE(exynos_bts) - 1]; bts++) {
if (bts->enable)
iounmap(bts->va_base);
}
return ret;
}
arch_initcall(exynos_bts_init);