pa-fazil
/
dragonheart_kernel_oneplus_sm8150
mirror of https://github.com/fazilsheik96/dragonheart_kernel_oneplus_sm8150.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
dragonheart_kernel_oneplus_.../drivers/soc/qcom/rpmh_master_stat.c

306 lines
7.8 KiB
C
Raw Permalink Blame History

/* Copyright (c) 2017-2020, The Linux Foundation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 and
* only version 2 as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*/
#define pr_fmt(fmt) "%s: " fmt, KBUILD_MODNAME
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/types.h>
#include <linux/mm.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/uaccess.h>
#include <linux/soc/qcom/smem.h>
#include <asm/arch_timer.h>
#include <linux/kobject.h>
#include <linux/sysfs.h>
#include "rpmh_master_stat.h"
#define UNIT_DIST 0x14
#define REG_VALID 0x0
#define REG_DATA_LO 0x4
#define REG_DATA_HI 0x8
#define GET_ADDR(REG, UNIT_NO) (REG + (UNIT_DIST * UNIT_NO))
enum master_smem_id {
MPSS = 605,
ADSP,
CDSP,
SLPI,
GPU,
DISPLAY,
};
enum master_pid {
PID_APSS = 0,
PID_MPSS = 1,
PID_ADSP = 2,
PID_SLPI = 3,
PID_CDSP = 5,
PID_GPU = PID_APSS,
PID_DISPLAY = PID_APSS,
};
enum profile_data {
POWER_DOWN_START,
POWER_UP_END,
POWER_DOWN_END,
POWER_UP_START,
NUM_UNIT,
};
struct msm_rpmh_master_data {
char *master_name;
enum master_smem_id smem_id;
enum master_pid pid;
};
static const struct msm_rpmh_master_data rpmh_masters[] = {
{"MPSS", MPSS, PID_MPSS},
{"ADSP", ADSP, PID_ADSP},
{"CDSP", CDSP, PID_CDSP},
{"SLPI", SLPI, PID_SLPI},
{"GPU", GPU, PID_GPU},
{"DISPLAY", DISPLAY, PID_DISPLAY},
};
struct msm_rpmh_master_stats {
uint32_t version_id;
uint32_t counts;
uint64_t last_entered;
uint64_t last_exited;
uint64_t accumulated_duration;
};
struct msm_rpmh_profile_unit {
uint64_t value;
uint64_t valid;
};
struct rpmh_master_stats_prv_data {
struct kobj_attribute ka;
struct kobject *kobj;
};
static struct msm_rpmh_master_stats apss_master_stats;
static void __iomem *rpmh_unit_base;
static DEFINE_MUTEX(rpmh_stats_mutex);
static void msm_rpmh_master_stats_print_data(struct seq_file *s,
struct msm_rpmh_master_stats *record,
const char *name)
{
uint64_t temp_accumulated_duration = record->accumulated_duration;
/*
* If a master is in sleep when reading the sleep stats from SMEM
* adjust the accumulated sleep duration to show actual sleep time.
* This ensures that the displayed stats are real when used for
* the purpose of computing battery utilization.
*/
if (record->last_entered > record->last_exited)
temp_accumulated_duration +=
(arch_counter_get_cntvct()
- record->last_entered);
seq_printf(s, "%s\n\tVersion:0x%x\n"
"\tSleep Count:0x%x\n"
"\tSleep Last Entered At:0x%llx\n"
"\tSleep Last Exited At:0x%llx\n"
"\tSleep Accumulated Duration:0x%llx\n\n",
name, record->version_id,
record->counts, record->last_entered,
record->last_exited, temp_accumulated_duration);
}
static int rpmh_master_stats_show(struct seq_file *s, void *data)
{
int i = 0;
size_t size = 0;
struct msm_rpmh_master_stats *record = NULL;
mutex_lock(&rpmh_stats_mutex);
/* First Read APSS master stats */
msm_rpmh_master_stats_print_data(s, &apss_master_stats,
"APSS");
/*
* Read SMEM data written by masters
*/
for (i = 0; i < ARRAY_SIZE(rpmh_masters); i++) {
record = (struct msm_rpmh_master_stats *) qcom_smem_get(
rpmh_masters[i].pid,
rpmh_masters[i].smem_id, &size);
if (!IS_ERR_OR_NULL(record))
msm_rpmh_master_stats_print_data(s, record,
rpmh_masters[i].master_name);
}
mutex_unlock(&rpmh_stats_mutex);
return 0;
}
int rpmh_master_stats_open(struct inode *inode, struct file *file)
{
return single_open(file, rpmh_master_stats_show, inode->i_private);
}
static inline void msm_rpmh_apss_master_stats_update(
struct msm_rpmh_profile_unit *profile_unit)
{
apss_master_stats.counts++;
apss_master_stats.last_entered = profile_unit[POWER_DOWN_END].value;
apss_master_stats.last_exited = profile_unit[POWER_UP_START].value;
apss_master_stats.accumulated_duration +=
(apss_master_stats.last_exited
- apss_master_stats.last_entered);
}
void msm_rpmh_master_stats_update(void)
{
int i;
struct msm_rpmh_profile_unit profile_unit[NUM_UNIT];
if (!rpmh_unit_base)
return;
for (i = POWER_DOWN_END; i < NUM_UNIT; i++) {
profile_unit[i].valid = readl_relaxed(rpmh_unit_base +
GET_ADDR(REG_VALID, i));
/*
* Do not update APSS stats if valid bit is not set.
* It means APSS did not execute cx-off sequence.
* This can be due to fall through at some point.
*/
if (!(profile_unit[i].valid & BIT(REG_VALID)))
return;
profile_unit[i].value = readl_relaxed(rpmh_unit_base +
GET_ADDR(REG_DATA_LO, i));
profile_unit[i].value |= ((uint64_t)
readl_relaxed(rpmh_unit_base +
GET_ADDR(REG_DATA_HI, i)) << 32);
}
msm_rpmh_apss_master_stats_update(profile_unit);
}
EXPORT_SYMBOL(msm_rpmh_master_stats_update);
ssize_t master_stats_show(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
int i = 0;
size_t size = 0;
struct msm_rpmh_master_stats *record = NULL;
char stats_buf[1024];
uint64_t temp_accumulated_duration = 0;
mutex_lock(&rpmh_stats_mutex);
/* First Read APSS master stats */
temp_accumulated_duration = apss_master_stats.accumulated_duration;
if (apss_master_stats.last_entered > apss_master_stats.last_exited)
temp_accumulated_duration +=
(arch_counter_get_cntvct()
- apss_master_stats.last_entered);
snprintf(stats_buf, sizeof(stats_buf),
"APSS\n\tVersion:0x%x\n"
"\tSleep Count:0x%x\n"
"\tSleep Last Entered At:0x%llx\n"
"\tSleep Last Exited At:0x%llx\n"
"\tSleep Accumulated Duration:0x%llx\n\n",
apss_master_stats.version_id,
apss_master_stats.counts, apss_master_stats.last_entered,
apss_master_stats.last_exited, temp_accumulated_duration);
/*
* Read SMEM data written by masters
*/
for (i = 0; i < ARRAY_SIZE(rpmh_masters); i++) {
record = (struct msm_rpmh_master_stats *) qcom_smem_get(
rpmh_masters[i].pid,
rpmh_masters[i].smem_id, &size);
if (!IS_ERR_OR_NULL(record)) {
temp_accumulated_duration = record->accumulated_duration;
if (record->last_entered > record->last_exited)
temp_accumulated_duration +=
(arch_counter_get_cntvct()
- record->last_entered);
snprintf(stats_buf + strlen(stats_buf), sizeof(stats_buf),
"%s\n\tVersion:0x%x\n"
"\tSleep Count:0x%x\n"
"\tSleep Last Entered At:0x%llx\n"
"\tSleep Last Exited At:0x%llx\n"
"\tSleep Accumulated Duration:0x%llx\n\n",
rpmh_masters[i].master_name, record->version_id,
record->counts, record->last_entered,
record->last_exited, temp_accumulated_duration);
}
}
mutex_unlock(&rpmh_stats_mutex);
return snprintf(buf, sizeof(stats_buf), "%s", stats_buf);
}
static int msm_rpmh_master_stats_probe(struct platform_device *pdev)
{
rpmh_unit_base = of_iomap(pdev->dev.of_node, 0);
if (!rpmh_unit_base) {
pr_err("Failed to get rpmh_unit_base\n");
return -ENOMEM;
}
apss_master_stats.version_id = 0x1;
return 0;
}
static int msm_rpmh_master_stats_remove(struct platform_device *pdev)
{
iounmap(rpmh_unit_base);
return 0;
}
static const struct of_device_id rpmh_master_table[] = {
{.compatible = "qcom,rpmh-master-stats-v1"},
{},
};
static struct platform_driver msm_rpmh_master_stats_driver = {
.probe = msm_rpmh_master_stats_probe,
.remove = msm_rpmh_master_stats_remove,
.driver = {
.name = "msm_rpmh_master_stats",
.of_match_table = rpmh_master_table,
},
};
module_platform_driver(msm_rpmh_master_stats_driver);
MODULE_LICENSE("GPL v2");
MODULE_DESCRIPTION("MSM RPMH Master Statistics driver");
MODULE_ALIAS("platform:msm_rpmh_master_stat_log");
Reference in New Issue View Git Blame Copy Permalink