liyujie
2025-08-28 d9927380ed7c8366f762049be9f3fee225860833
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
/*
 * Copyright (C) 2018 The Allwinnertech
 *
 *
 * Author:jiangbin@allwinnertech.com
 * Time:2090715
 *
 * description:
 *     Target TARGET_BOARD_PLATFORM: default(frome A50)
 *     power_hint-policy
 */
 
#include <string.h>
#include <stdio.h>
#include <errno.h>
#define  LOG_TAG "AW_PowerHAL_Platform"
#include <hardware/hardware.h>
#include <hardware/power.h>
#include <utils/Log.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include "../power-common.h"
 
#ifndef CPUMAXCORENUM
#define CPUMAXCORENUM    "4"
#endif
 
#ifndef CPUMAXFREQ
#define CPUMAXFREQ       "1800000"
#endif
 
#ifndef CPUMINFREQ
#define CPUMINFREQ       "480000"
#endif
 
#ifndef CPULOWPOWERFREQ
#define CPULOWPOWERFREQ  "1200000"
#endif
 
#ifndef CPUNORMALFREQ
#define CPUNORMALFREQ  cpu0_max_freq
#endif
 
#ifndef CPU0OPP
#define CPU0OPP     "/sys/devices/system/cpu/cpufreq/policy0/scaling_available_frequencies"
#endif
 
#ifdef  NSI_BANDWIDTH_LIMIT
#define NSIBANDWIDTH "/dev/nsi"
#define DISABLE_BANDWIDTH_LIMIT  0x102
#define ENABLE_BANDWIDTH_LIMIT  0x101
#endif
 
void power_set_interactive_platform(int enable)
{
    (void)enable;
}
 
 
/*
 *return: false -check fail
 *        true  -check success
*/
static bool check_policy_platform(unsigned int hint, int parmdata)
{
    (void)hint;
    (void)parmdata;
    return true;
}
 
static char cpu0_max_freq[16] = {0};
 
 
#ifdef  NSI_BANDWIDTH_LIMIT
static bool nsi_bandwidth_limit = true;
static void set_nsi_bandwidth_limit(bool enable) {
 
    int fd = open(NSIBANDWIDTH, O_WRONLY);
    if (fd < 0) {
        ALOGW("Could not open nsi-bw: %s", strerror(errno));
        return;
    }
 
    if(ioctl(fd,enable? ENABLE_BANDWIDTH_LIMIT:DISABLE_BANDWIDTH_LIMIT,1)) {
        ALOGE("ioctl %s limit %d eroor %s",NSIBANDWIDTH,enable, strerror(errno));
    } else {
        nsi_bandwidth_limit = enable;
    }
 
    close(fd);
}
#endif
 
 
 
bool power_hint_platform(unsigned int hint, int parmdata)
{
    Power_Perfromance_State current_state = get_cur_power_state();
 
    if (!check_policy_platform(hint, parmdata)) {
        ALOGI("==default check policy fail,do nothing==");
        return false;
    }
 
    if (!cpu0_max_freq[0])
        cpufreq_max_get(CPU0OPP, cpu0_max_freq);
 
    bool hitcase = true;
    switch (hint) {
        case POWER_HINT_LAUNCH:
            ALOGI("==LAUNCH_MODE==");
            sysfs_write(CPU0GOV,PERFORMANCE_GOVERNOR);
            set_power_state(POWER_STATE_LAUNCH);
            //sysfs_write(ROOMAGE,ROOMAGE_LAUNCH);
            //sysfs_write(CPULOCK,CPUMAXCORENUM);
            //sysfs_write(CPUMINFREQCONTROL, cpu0_max_freq);
            //sysfs_write(CPUMAXFREQCONTROL, cpu0_max_freq);
            break;
 
        case POWER_HINT_HOME:
            ALOGI("==HOME MODE==");
            sysfs_write(THERMAL_EMUL_TEMP,THERMAL_OPEN_EMUL_TEMP);
            sysfs_write(CPU0GOV,SCHEDUTIL_GOVERNOR);
            //sysfs_write(CPULOCK,"0");
            sysfs_write(CPUMAXFREQCONTROL,CPULOWPOWERFREQ);
            set_power_state(POWER_STATE_HOME);
            break;
 
        case POWER_HINT_BOOTCOMPLETE:
            ALOGI("==BOOTCOMPLETE MODE==");
            sysfs_write(CPU0GOV,SCHEDUTIL_GOVERNOR);
            //sysfs_write(CPUHOT,"1"); //tmp reserve;do not use hotplug, replace cpuidle
            break;
 
        case POWER_HINT_BENCHMARK:
            if (current_state == POWER_STATE_BENCHMARK) {
                ALOGD("HINT_BENCHMARK:same state");
                return hitcase;
            }
 
            if (parmdata == 0) {
                ALOGE("HINT_BENCHMARK:data==NULL");
                return hitcase;
            } else {
                 ALOGD("HINT_BENCHMARK:data =%d",parmdata);
            }
 
            sysfs_write(THERMAL_EMUL_TEMP,THERMAL_CLOSE_EMUL_TEMP);
            //sysfs_write(ROOMAGE,ROOMAGE_BENCHMARK);
            //sysfs_write(CPULOCK,CPUMAXCORENUM);
            //sysfs_write(CPUMINFREQCONTROL, cpu0_max_freq);
            //sysfs_write(CPUMAXFREQCONTROL, cpu0_max_freq);
 
            sysfs_write(CPU0GOV,PERFORMANCE_GOVERNOR);
            set_power_state(POWER_STATE_BENCHMARK);
            ALOGI("==BENCHMARK MODE==");
 
#ifdef  NSI_BANDWIDTH_LIMIT
            set_nsi_bandwidth_limit(0);
#endif
            break;
 
        case POWER_HINT_NORMAL:
            ALOGI("==NORMAL MODE==");
            sysfs_write(CPU0GOV,SCHEDUTIL_GOVERNOR);
            sysfs_write(THERMAL_EMUL_TEMP,THERMAL_OPEN_EMUL_TEMP);
            //sysfs_write(ROOMAGE,ROOMAGE_NORMAL);
            //sysfs_write(CPULOCK,"0");
 
#ifdef  NSI_BANDWIDTH_LIMIT
            if(!nsi_bandwidth_limit) {
                set_nsi_bandwidth_limit(1);
            }
#endif
 
 
            sysfs_write(CPUMINFREQCONTROL,CPUMINFREQ);
            sysfs_write(CPUMAXFREQCONTROL,CPUNORMALFREQ);
            set_power_state(POWER_STATE_NORMAL);
            break;
 
        case POWER_HINT_BG_MUSIC:
            ALOGI("==BG_MUSIC MODE==");
            sysfs_write(THERMAL_EMUL_TEMP,THERMAL_OPEN_EMUL_TEMP);
            //sysfs_write(ROOMAGE, ROOMAGE_MUSIC);
            //sysfs_write(CPULOCK,"0");
            sysfs_write(CPUMAXFREQCONTROL,CPULOWPOWERFREQ);
            set_power_state(POWER_STATE_MUSIC);
            break;
 
        case POWER_HINT_DISABLE_TOUCH:
            ALOGI("==DISABLE TOUCH==");
            char tp_state[2]= {0};
            sprintf(tp_state,"%d", parmdata);
            sysfs_write(TP_SUSPEND, tp_state);
            break;
 
        default:
            hitcase = false;
            break;
 
    }
 
    return hitcase;
}