type stringclasses 5
values | content stringlengths 9 163k |
|---|---|
functions | int set_and_activate_threshold(uint32_t sensor_id,
struct sensor_threshold *threshold)
{
int ret = 0;
ret = sensor_set_trip(sensor_id, threshold);
if (ret != 0) {
pr_err("sensor:%u Error in setting trip:%d. err:%d\n",
sensor_id, threshold->trip, ret);
goto set_done;
} |
functions | int therm_get_temp(uint32_t id, enum sensor_id_type type, long *temp)
{
int ret = 0;
struct tsens_device tsens_dev;
if (!temp) {
pr_err("Invalid value\n");
ret = -EINVAL;
goto get_temp_exit;
} |
functions | int msm_thermal_panic_callback(struct notifier_block *nfb,
unsigned long event, void *data)
{
int i;
for (i = 0; i < max_tsens_num; i++)
therm_get_temp(tsens_id_map[i],
THERM_TSENS_ID,
&tsens_temp_at_panic[i]);
return NOTIFY_OK;
} |
functions | int set_threshold(uint32_t zone_id,
struct sensor_threshold *threshold)
{
int i = 0, ret = 0;
long temp;
if (!threshold) {
pr_err("Invalid input\n");
ret = -EINVAL;
goto set_threshold_exit;
} |
functions | int apply_vdd_mx_restriction(void)
{
int ret = 0;
if (mx_restr_applied)
goto done;
ret = regulator_set_voltage(vdd_mx, msm_thermal_info.vdd_mx_min,
INT_MAX);
if (ret) {
pr_err("Failed to add mx vote, error %d\n", ret);
goto done;
} |
functions | int remove_vdd_mx_restriction(void)
{
int ret = 0;
if (!mx_restr_applied)
goto done;
ret = regulator_disable(vdd_mx);
if (ret) {
pr_err("Failed to disable mx voting, error %d\n", ret);
goto done;
} |
functions | int do_vdd_mx(void)
{
long temp = 0;
int ret = 0;
int i = 0;
int dis_cnt = 0;
if (!vdd_mx_enabled)
return ret;
mutex_lock(&vdd_mx_mutex);
for (i = 0; i < thresh[MSM_VDD_MX_RESTRICTION].thresh_ct; i++) {
ret = therm_get_temp(
thresh[MSM_VDD_MX_RESTRICTION].thresh_list[i].sensor_id,
thresh[MSM_VDD_MX_R... |
functions | void vdd_mx_notify(struct therm_threshold *trig_thresh)
{
static uint32_t mx_sens_status;
int ret;
pr_debug("Sensor%d trigger recevied for type %d\n",
trig_thresh->sensor_id,
trig_thresh->trip_triggered);
if (!vdd_mx_enabled)
return;
mutex_lock(&vdd_mx_mutex);
switch (trig_thresh->trip_triggered) {
cas... |
functions | else if (!mx_sens_status) {
ret = remove_vdd_mx_restriction();
if (ret)
pr_err("Failed to remove vdd mx restriction\n");
} |
functions | void msm_thermal_bite(int tsens_id, long temp)
{
struct scm_desc desc;
pr_err("TSENS:%d reached temperature:%ld. System reset\n",
tsens_id, temp);
if (!is_scm_armv8()) {
scm_call_atomic1(SCM_SVC_BOOT, THERM_SECURE_BITE_CMD, 0);
} |
functions | int do_therm_reset(void)
{
int ret = 0, i;
long temp = 0;
if (!therm_reset_enabled)
return ret;
for (i = 0; i < thresh[MSM_THERM_RESET].thresh_ct; i++) {
ret = therm_get_temp(
thresh[MSM_THERM_RESET].thresh_list[i].sensor_id,
thresh[MSM_THERM_RESET].thresh_list[i].id_type,
&temp);
if (ret) {
pr_... |
functions | void therm_reset_notify(struct therm_threshold *thresh_data)
{
long temp;
int ret = 0;
if (!therm_reset_enabled)
return;
if (!thresh_data) {
pr_err("Invalid input\n");
return;
} |
functions | __ref do_core_control(long temp)
{
int i = 0;
int ret = 0;
if (!core_control_enabled)
return;
mutex_lock(&core_control_mutex);
if (msm_thermal_info.core_control_mask &&
temp >= msm_thermal_info.core_limit_temp_degC) {
for (i = num_possible_cpus(); i > 0; i--) {
if (!(msm_thermal_info.core_control_mask &... |
functions | __ref update_offline_cores(int val)
{
uint32_t cpu = 0;
int ret = 0;
uint32_t previous_cpus_offlined = 0;
if (!core_control_enabled)
return 0;
previous_cpus_offlined = cpus_offlined;
cpus_offlined = msm_thermal_info.core_control_mask & val;
for_each_possible_cpu(cpu) {
if (cpus_offlined & BIT(cpu)) {
i... |
functions | int do_hotplug(void *data)
{
int ret = 0;
uint32_t cpu = 0, mask = 0;
struct device_clnt_data *clnt = NULL;
struct sched_param param = {.sched_priority = MAX_RT_PRIO-2} |
functions | __ref do_core_control(long temp)
{
return;
} |
functions | int do_hotplug(void *data)
{
return 0;
} |
functions | __ref update_offline_cores(int val)
{
return 0;
} |
functions | int do_gfx_phase_cond(void)
{
long temp = 0;
int ret = 0;
uint32_t new_req_band = curr_gfx_band;
if (!gfx_warm_phase_ctrl_enabled && !gfx_crit_phase_ctrl_enabled)
return ret;
mutex_lock(&gfx_mutex);
if (gfx_warm_phase_ctrl_enabled) {
ret = therm_get_temp(
thresh[MSM_GFX_PHASE_CTRL_WARM].thresh_list->sens... |
functions | int do_cx_phase_cond(void)
{
long temp = 0;
int i, ret = 0, dis_cnt = 0;
if (!cx_phase_ctrl_enabled)
return ret;
mutex_lock(&cx_mutex);
for (i = 0; i < thresh[MSM_CX_PHASE_CTRL_HOT].thresh_ct; i++) {
ret = therm_get_temp(
thresh[MSM_CX_PHASE_CTRL_HOT].thresh_list[i].sensor_id,
thresh[MSM_CX_PHASE_CTRL_... |
functions | int do_ocr(void)
{
long temp = 0;
int ret = 0;
int i = 0, j = 0;
int pfm_cnt = 0;
if (!ocr_enabled)
return ret;
mutex_lock(&ocr_mutex);
for (i = 0; i < thresh[MSM_OCR].thresh_ct; i++) {
ret = therm_get_temp(
thresh[MSM_OCR].thresh_list[i].sensor_id,
thresh[MSM_OCR].thresh_list[i].id_type,
&temp);
... |
functions | int do_vdd_restriction(void)
{
long temp = 0;
int ret = 0;
int i = 0;
int dis_cnt = 0;
if (!vdd_rstr_enabled)
return ret;
if (usefreq && !freq_table_get) {
if (check_freq_table() && !core_ptr)
return ret;
} |
functions | int do_psm(void)
{
long temp = 0;
int ret = 0;
int i = 0;
int auto_cnt = 0;
mutex_lock(&psm_mutex);
for (i = 0; i < max_tsens_num; i++) {
ret = therm_get_temp(tsens_id_map[i], THERM_TSENS_ID, &temp);
if (ret) {
pr_err("Unable to read TSENS sensor:%d. err:%d\n",
tsens_id_map[i], ret);
auto_cnt++;
... |
functions | void do_freq_control(long temp)
{
uint32_t cpu = 0;
uint32_t max_freq = cpus[cpu].limited_max_freq;
if (core_ptr)
return do_cluster_freq_ctrl(temp);
if (!freq_table_get)
return;
if (temp >= temp_threshold) {
if (limit_idx == limit_idx_low)
return;
limit_idx -= msm_thermal_info.bootup_freq_step;
if ... |
functions | else if (temp < temp_threshold - msm_thermal_info.temp_hysteresis_degC) {
if (limit_idx == limit_idx_high)
return;
limit_idx += msm_thermal_info.bootup_freq_step;
if (limit_idx >= limit_idx_high) {
limit_idx = limit_idx_high;
max_freq = UINT_MAX;
} |
functions | void check_temp(struct work_struct *work)
{
long temp = 0;
int ret = 0;
do_therm_reset();
ret = therm_get_temp(msm_thermal_info.sensor_id, THERM_TSENS_ID, &temp);
if (ret) {
pr_err("Unable to read TSENS sensor:%d. err:%d\n",
msm_thermal_info.sensor_id, ret);
goto reschedule;
} |
functions | __ref msm_thermal_cpu_callback(struct notifier_block *nfb,
unsigned long action, void *hcpu)
{
uint32_t cpu = (uintptr_t)hcpu;
if (action == CPU_UP_PREPARE || action == CPU_UP_PREPARE_FROZEN) {
if (core_control_enabled &&
(msm_thermal_info.core_control_mask & BIT(cpu)) &&
(cpus_offlined & BIT(cpu))) {
p... |
functions | int hotplug_notify(enum thermal_trip_type type, int temp, void *data)
{
struct cpu_info *cpu_node = (struct cpu_info *)data;
pr_info("%s reach temp threshold: %d\n", cpu_node->sensor_type, temp);
if (!(msm_thermal_info.core_control_mask & BIT(cpu_node->cpu)))
return 0;
switch (type) {
case THERMAL_TRIP_CONFIGU... |
functions | int hotplug_init_cpu_offlined(void)
{
long temp = 0;
uint32_t cpu = 0;
if (!hotplug_enabled)
return 0;
mutex_lock(&core_control_mutex);
for_each_possible_cpu(cpu) {
if (!(msm_thermal_info.core_control_mask & BIT(cpus[cpu].cpu)))
continue;
if (therm_get_temp(cpus[cpu].sensor_id, cpus[cpu].id_type,
&... |
functions | void hotplug_init(void)
{
uint32_t cpu = 0;
struct sensor_threshold *hi_thresh = NULL, *low_thresh = NULL;
if (hotplug_task)
return;
if (!hotplug_enabled)
goto init_kthread;
for_each_possible_cpu(cpu) {
cpus[cpu].sensor_id =
sensor_get_id((char *)cpus[cpu].sensor_type);
cpus[cpu].id_type = THERM_ZONE... |
functions | int do_freq_mitigation(void *data)
{
int ret = 0;
uint32_t cpu = 0, max_freq_req = 0, min_freq_req = 0;
struct sched_param param = {.sched_priority = MAX_RT_PRIO-1} |
functions | int freq_mitigation_notify(enum thermal_trip_type type,
int temp, void *data)
{
struct cpu_info *cpu_node = (struct cpu_info *) data;
pr_debug("%s reached temp threshold: %d\n",
cpu_node->sensor_type, temp);
if (!(msm_thermal_info.freq_mitig_control_mask &
BIT(cpu_node->cpu)))
return 0;
switch (type) {
c... |
functions | void freq_mitigation_init(void)
{
uint32_t cpu = 0;
struct sensor_threshold *hi_thresh = NULL, *low_thresh = NULL;
if (freq_mitigation_task)
return;
if (!freq_mitigation_enabled)
goto init_freq_thread;
for_each_possible_cpu(cpu) {
if (!(msm_thermal_info.freq_mitig_control_mask & BIT(cpu)))
continue;
h... |
functions | int msm_thermal_get_freq_plan_size(uint32_t cluster, unsigned int *table_len)
{
uint32_t i = 0;
struct cluster_info *cluster_ptr = NULL;
if (!core_ptr) {
pr_err("Topology ptr not initialized\n");
return -ENODEV;
} |
functions | int msm_thermal_get_cluster_freq_plan(uint32_t cluster, unsigned int *table_ptr)
{
uint32_t i = 0;
struct cluster_info *cluster_ptr = NULL;
if (!core_ptr) {
pr_err("Topology ptr not initialized\n");
return -ENODEV;
} |
functions | int msm_thermal_set_cluster_freq(uint32_t cluster, uint32_t freq, bool is_max)
{
int ret = 0;
uint32_t i = 0;
struct cluster_info *cluster_ptr = NULL;
bool notify = false;
if (!core_ptr) {
pr_err("Topology ptr not initialized\n");
return -ENODEV;
} |
functions | int msm_thermal_set_frequency(uint32_t cpu, uint32_t freq, bool is_max)
{
int ret = 0;
if (cpu >= num_possible_cpus()) {
pr_err("Invalid input\n");
ret = -EINVAL;
goto set_freq_exit;
} |
functions | int therm_set_threshold(struct threshold_info *thresh_inp)
{
int ret = 0, i = 0, err = 0;
struct therm_threshold *thresh_ptr;
if (!thresh_inp) {
pr_err("Invalid input\n");
ret = -EINVAL;
goto therm_set_exit;
} |
functions | void cx_phase_ctrl_notify(struct therm_threshold *trig_thresh)
{
static uint32_t cx_sens_status;
int ret = 0;
if (!cx_phase_ctrl_enabled)
return;
if (trig_thresh->trip_triggered < 0)
goto cx_phase_ctrl_exit;
mutex_lock(&cx_mutex);
pr_debug("sensor:%d reached %s thresh for CX\n",
tsens_id_map[trig_thresh-... |
functions | void gfx_phase_ctrl_notify(struct therm_threshold *trig_thresh)
{
uint32_t new_req_band = curr_gfx_band;
int ret = 0;
if (!gfx_warm_phase_ctrl_enabled && !gfx_crit_phase_ctrl_enabled)
return;
if (trig_thresh->trip_triggered < 0)
goto gfx_phase_ctrl_exit;
mutex_lock(&gfx_mutex);
if (gfx_crit_phase_ctrl_enab... |
functions | void vdd_restriction_notify(struct therm_threshold *trig_thresh)
{
int ret = 0;
static uint32_t vdd_sens_status;
if (!vdd_rstr_enabled)
return;
if (!trig_thresh) {
pr_err("Invalid input\n");
return;
} |
functions | void ocr_notify(struct therm_threshold *trig_thresh)
{
int ret = 0;
static uint32_t ocr_sens_status;
if (!ocr_enabled)
return;
if (!trig_thresh) {
pr_err("Invalid input\n");
return;
} |
functions | int do_thermal_monitor(void *data)
{
int ret = 0, i, j;
struct therm_threshold *sensor_list;
while (!kthread_should_stop()) {
while (wait_for_completion_interruptible(
&thermal_monitor_complete) != 0)
;
INIT_COMPLETION(thermal_monitor_complete);
for (i = 0; i < MSM_LIST_MAX_NR; i++) {
if (!thresh[i]... |
functions | int convert_to_zone_id(struct threshold_info *thresh_inp)
{
int ret = 0, i, zone_id;
struct therm_threshold *thresh_array;
if (!thresh_inp) {
pr_err("Invalid input\n");
ret = -EINVAL;
goto convert_to_exit;
} |
functions | void thermal_monitor_init(void)
{
if (thermal_monitor_task)
return;
init_completion(&thermal_monitor_complete);
thermal_monitor_task = kthread_run(do_thermal_monitor, NULL,
"msm_thermal:therm_monitor");
if (IS_ERR(thermal_monitor_task)) {
pr_err("Failed to create thermal monitor thread. err:%ld\n",
PTR_E... |
functions | int msm_thermal_notify(enum thermal_trip_type type, int temp, void *data)
{
struct therm_threshold *thresh_data = (struct therm_threshold *)data;
if (thermal_monitor_task) {
thresh_data->trip_triggered = type;
thresh_data->parent->thresh_triggered = true;
complete(&thermal_monitor_complete);
} |
functions | int msm_thermal_add_gfx_nodes(void)
{
struct kobject *module_kobj = NULL;
struct kobject *gfx_kobj = NULL;
int ret = 0;
if (!gfx_warm_phase_ctrl_enabled && !gfx_crit_phase_ctrl_enabled)
return -EINVAL;
module_kobj = kset_find_obj(module_kset, KBUILD_MODNAME);
if (!module_kobj) {
pr_err("cannot find kobject\... |
functions | int msm_thermal_add_cx_nodes(void)
{
struct kobject *module_kobj = NULL;
struct kobject *cx_kobj = NULL;
int ret = 0;
if (!cx_phase_ctrl_enabled)
return -EINVAL;
module_kobj = kset_find_obj(module_kset, KBUILD_MODNAME);
if (!module_kobj) {
pr_err("cannot find kobject\n");
ret = -ENOENT;
goto cx_node_exi... |
functions | __ref disable_msm_thermal(void)
{
uint32_t cpu = 0;
/* make sure check_temp is no longer running */
cancel_delayed_work_sync(&check_temp_work);
get_online_cpus();
for_each_possible_cpu(cpu) {
if (cpus[cpu].limited_max_freq == UINT_MAX &&
cpus[cpu].limited_min_freq == 0)
continue;
pr_info("Max frequency... |
functions | void interrupt_mode_init(void)
{
if (!msm_thermal_probed) {
interrupt_mode_enable = true;
return;
} |
functions | __ref set_enabled(const char *val, const struct kernel_param *kp)
{
int ret = 0;
ret = param_set_bool(val, kp);
if (!enabled)
interrupt_mode_init();
else
pr_info("no action for enabled = %d\n",
enabled);
pr_info("enabled = %d\n", enabled);
return ret;
} |
functions | ssize_t show_cc_enabled(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%d\n", core_control_enabled);
} |
functions | __ref store_cc_enabled(struct kobject *kobj,
struct kobj_attribute *attr, const char *buf, size_t count)
{
int ret = 0;
int val = 0;
uint32_t cpu = 0;
ret = kstrtoint(buf, 10, &val);
if (ret) {
pr_err("Invalid input %s. err:%d\n", buf, ret);
goto done_store_cc;
} |
functions | ssize_t show_cpus_offlined(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%d\n", cpus_offlined);
} |
functions | __ref store_cpus_offlined(struct kobject *kobj,
struct kobj_attribute *attr, const char *buf, size_t count)
{
int ret = 0;
uint32_t val = 0;
uint32_t cpu;
mutex_lock(&core_control_mutex);
ret = kstrtouint(buf, 10, &val);
if (ret) {
pr_err("Invalid input %s. err:%d\n", buf, ret);
goto done_cc;
} |
functions | int msm_thermal_add_cc_nodes(void)
{
struct kobject *module_kobj = NULL;
int ret = 0;
module_kobj = kset_find_obj(module_kset, KBUILD_MODNAME);
if (!module_kobj) {
pr_err("cannot find kobject\n");
ret = -ENOENT;
goto done_cc_nodes;
} |
functions | ssize_t show_mx_enabled(struct kobject *kobj,
struct kobj_attribute *attr, char *buf)
{
return snprintf(buf, PAGE_SIZE, "%d\n", vdd_mx_enabled);
} |
functions | __ref store_mx_enabled(struct kobject *kobj,
struct kobj_attribute *attr, const char *buf, size_t count)
{
int ret = 0;
int val = 0;
ret = kstrtoint(buf, 10, &val);
if (ret) {
pr_err("Invalid input %s\n", buf);
goto done_store_mx;
} |
functions | int msm_thermal_add_mx_nodes(void)
{
struct kobject *module_kobj = NULL;
int ret = 0;
if (!vdd_mx_enabled)
return -EINVAL;
module_kobj = kset_find_obj(module_kset, KBUILD_MODNAME);
if (!module_kobj) {
pr_err("cannot find kobject for module\n");
ret = -ENOENT;
goto done_mx_nodes;
} |
functions | void msm_thermal_panic_notifier_init(struct device *dev)
{
int i;
tsens_temp_at_panic = devm_kzalloc(dev,
sizeof(long) * max_tsens_num,
GFP_KERNEL);
if (!tsens_temp_at_panic) {
pr_err("kzalloc failed\n");
return;
} |
functions | int msm_thermal_pre_init(struct device *dev)
{
int ret = 0;
if (tsens_is_ready() <= 0) {
pr_err("Tsens driver is not ready yet\n");
return -EPROBE_DEFER;
} |
functions | int devmgr_devices_init(struct platform_device *pdev)
{
int ret = 0;
uint32_t cpu;
struct device_manager_data *dev_mgr = NULL;
devices = devm_kzalloc(&pdev->dev,
sizeof(struct devmgr_devices),
GFP_KERNEL);
if (!devices) {
pr_err("Malloc failed for devmgr devices\n");
ret = -ENOMEM;
goto device_exit;... |
functions | int msm_thermal_init(struct msm_thermal_data *pdata)
{
int ret = 0;
uint32_t cpu;
ret = devmgr_devices_init(pdata->pdev);
if (ret)
pr_err("cannot initialize devm devices. err:%d\n", ret);
for_each_possible_cpu(cpu) {
cpus[cpu].cpu = cpu;
cpus[cpu].offline = 0;
cpus[cpu].user_offline = 0;
cpus[cpu].hotp... |
functions | int ocr_reg_init(struct platform_device *pdev)
{
int ret = 0;
int i, j;
for (i = 0; i < ocr_rail_cnt; i++) {
/* Check if vdd_restriction has already initialized any
* regualtor handle. If so use the same handle.*/
for (j = 0; j < rails_cnt; j++) {
if (!strcmp(ocr_rails[i].name, rails[j].name)) {
if (r... |
functions | int vdd_restriction_reg_init(struct platform_device *pdev)
{
int ret = 0;
int i;
for (i = 0; i < rails_cnt; i++) {
if (rails[i].freq_req == 1) {
usefreq |= BIT(i);
check_freq_table();
/*
* Restrict frequency by default until we have made
* our first temp reading
*/
if (freq_table_get)
... |
functions | int psm_reg_init(struct platform_device *pdev)
{
int ret = 0;
int i = 0;
int j = 0;
for (i = 0; i < psm_rails_cnt; i++) {
psm_rails[i].reg = rpm_regulator_get(&pdev->dev,
psm_rails[i].name);
if (IS_ERR_OR_NULL(psm_rails[i].reg)) {
ret = PTR_ERR(psm_rails[i].reg);
if (ret != -EPROBE_DEFER) {
pr_er... |
functions | int msm_thermal_add_sensor_info_nodes(void)
{
struct kobject *module_kobj = NULL;
int ret = 0;
if (!sensor_info_probed) {
sensor_info_nodes_called = true;
return ret;
} |
functions | int msm_thermal_add_vdd_rstr_nodes(void)
{
struct kobject *module_kobj = NULL;
struct kobject *vdd_rstr_kobj = NULL;
struct kobject *vdd_rstr_reg_kobj[MAX_RAILS] = {0} |
functions | int msm_thermal_add_ocr_nodes(void)
{
struct kobject *module_kobj = NULL;
struct kobject *ocr_kobj = NULL;
struct kobject *ocr_reg_kobj[MAX_RAILS] = {0} |
functions | int msm_thermal_add_psm_nodes(void)
{
struct kobject *module_kobj = NULL;
struct kobject *psm_kobj = NULL;
struct kobject *psm_reg_kobj[MAX_RAILS] = {0} |
functions | int probe_vdd_mx(struct device_node *node,
struct msm_thermal_data *data, struct platform_device *pdev)
{
int ret = 0;
char *key = NULL;
key = "qcom,disable-vdd-mx";
if (of_property_read_bool(node, key)) {
vdd_mx_enabled = false;
return ret;
} |
functions | int probe_vdd_rstr(struct device_node *node,
struct msm_thermal_data *data, struct platform_device *pdev)
{
int ret = 0;
int i = 0;
int arr_size;
char *key = NULL;
struct device_node *child_node = NULL;
rails = NULL;
key = "qcom,disable-vdd-rstr";
if (of_property_read_bool(node, key)) {
vdd_rstr_probed = ... |
functions | void probe_sensor_info(struct device_node *node,
struct msm_thermal_data *data, struct platform_device *pdev)
{
int err = 0;
int i = 0;
char *key = NULL;
struct device_node *child_node = NULL;
struct device_node *np = NULL;
key = "qcom,disable-sensor-info";
if (of_property_read_bool(node, key)) {
sensor_inf... |
functions | int probe_ocr(struct device_node *node, struct msm_thermal_data *data,
struct platform_device *pdev)
{
int ret = 0;
int j = 0;
char *key = NULL;
if (ocr_probed) {
pr_info("Nodes already probed\n");
goto read_ocr_exit;
} |
functions | int probe_psm(struct device_node *node, struct msm_thermal_data *data,
struct platform_device *pdev)
{
int ret = 0;
int j = 0;
char *key = NULL;
psm_rails = NULL;
key = "qcom,disable-psm";
if (of_property_read_bool(node, key)) {
psm_probed = true;
psm_enabled = false;
psm_rails_cnt = 0;
return ret;
} |
functions | int probe_cc(struct device_node *node, struct msm_thermal_data *data,
struct platform_device *pdev)
{
char *key = NULL;
uint32_t cpu_cnt = 0;
int ret = 0;
uint32_t cpu = 0;
if (num_possible_cpus() > 1) {
core_control_enabled = 1;
hotplug_enabled = 1;
} |
functions | int probe_gfx_phase_ctrl(struct device_node *node,
struct msm_thermal_data *data,
struct platform_device *pdev)
{
char *key = NULL;
const char *tmp_str = NULL;
int ret = 0;
key = "qcom,disable-gfx-phase-ctrl";
if (of_property_read_bool(node, key)) {
gfx_crit_phase_ctrl_enabled = false;
gfx_warm_phase_ctrl... |
functions | int probe_cx_phase_ctrl(struct device_node *node,
struct msm_thermal_data *data,
struct platform_device *pdev)
{
char *key = NULL;
const char *tmp_str;
int ret = 0;
key = "qcom,disable-cx-phase-ctrl";
if (of_property_read_bool(node, key)) {
cx_phase_ctrl_enabled = false;
return ret;
} |
functions | int probe_therm_reset(struct device_node *node,
struct msm_thermal_data *data,
struct platform_device *pdev)
{
char *key = NULL;
int ret = 0;
key = "qcom,therm-reset-temp";
ret = of_property_read_u32(node, key, &data->therm_reset_temp_degC);
if (ret)
goto PROBE_RESET_EXIT;
ret = init_threshold(MSM_THERM_R... |
functions | int probe_freq_mitigation(struct device_node *node,
struct msm_thermal_data *data,
struct platform_device *pdev)
{
char *key = NULL;
int ret = 0;
key = "qcom,freq-mitigation-temp";
ret = of_property_read_u32(node, key, &data->freq_mitig_temp_degc);
if (ret)
goto PROBE_FREQ_EXIT;
key = "qcom,freq-mitigatio... |
functions | int msm_thermal_dev_probe(struct platform_device *pdev)
{
int ret = 0;
char *key = NULL;
struct device_node *node = pdev->dev.of_node;
struct msm_thermal_data data;
memset(&data, 0, sizeof(struct msm_thermal_data));
data.pdev = pdev;
ret = msm_thermal_pre_init(&pdev->dev);
if (ret) {
pr_err("thermal pre ini... |
functions | int msm_thermal_dev_exit(struct platform_device *inp_dev)
{
int i = 0;
msm_thermal_ioctl_cleanup();
if (thresh) {
if (vdd_rstr_enabled)
kfree(thresh[MSM_VDD_RESTRICTION].thresh_list);
if (cx_phase_ctrl_enabled)
kfree(thresh[MSM_CX_PHASE_CTRL_HOT].thresh_list);
if (gfx_warm_phase_ctrl_enabled)
kfree(t... |
functions | __init msm_thermal_device_init(void)
{
return platform_driver_register(&msm_thermal_device_driver);
} |
functions | __init msm_thermal_late_init(void)
{
if (num_possible_cpus() > 1)
msm_thermal_add_cc_nodes();
msm_thermal_add_psm_nodes();
msm_thermal_add_vdd_rstr_nodes();
msm_thermal_add_sensor_info_nodes();
if (ocr_reg_init_defer) {
if (!ocr_reg_init(msm_thermal_info.pdev)) {
ocr_enabled = true;
msm_thermal_add_ocr_n... |
includes |
#include <string.h> |
includes |
#include <X11/X.h> |
includes | #include <X11/Xlib.h> |
includes | #include <X11/Xutil.h> |
includes | #include <X11/Xatom.h> |
includes | #include <X11/extensions/shape.h> |
includes |
#include <glib.h> |
includes | #include <gdk/gdk.h> |
includes | #include <gdk/gdkx.h> |
includes | #include <gtk/gtk.h> |
includes | #include <X11/extensions/Xrandr.h> |
includes | #include <libxfce4util/libxfce4util.h> |
includes | #include <libxfce4ui/libxfce4ui.h> |
includes |
#include <common/xfwm-common.h> |
defines | #define CHECK_BUTTON_TIME 0 |
defines |
#define WIN_IS_BUTTON(win) ((win == MYWINDOW_XWINDOW(c->buttons[HIDE_BUTTON])) || \ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.