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
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
|
/*
* Copyright 2019 NXP
*
* SPDX-License-Identifier: BSD-3-Clause
*/
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <common/debug.h>
#include <drivers/arm/tzc380.h>
#include <drivers/delay_timer.h>
#include <lib/mmio.h>
#include <lib/psci/psci.h>
#include <lib/smccc.h>
#include <platform_def.h>
#include <services/std_svc.h>
#include <gpc.h>
#include <imx_sip_svc.h>
#include <plat_imx8.h>
#define MIPI_PWR_REQ BIT(0)
#define OTG1_PWR_REQ BIT(2)
#define HSIOMIX_PWR_REQ BIT(4)
#define GPUMIX_PWR_REQ BIT(7)
#define DISPMIX_PWR_REQ BIT(10)
#define HSIOMIX_ADB400_SYNC BIT(5)
#define DISPMIX_ADB400_SYNC BIT(7)
#define GPUMIX_ADB400_SYNC (0x5 << 9)
#define HSIOMIX_ADB400_ACK BIT(23)
#define DISPMIX_ADB400_ACK BIT(25)
#define GPUMIX_ADB400_ACK (0x5 << 27)
#define MIPI_PGC 0xc00
#define OTG1_PGC 0xc80
#define HSIOMIX_PGC 0xd00
#define GPUMIX_PGC 0xdc0
#define DISPMIX_PGC 0xe80
#define CCGR(x) (0x4000 + (x) * 16)
enum pu_domain_id {
HSIOMIX,
OTG1 = 2,
GPUMIX = 4,
DISPMIX = 9,
MIPI,
};
/* PU domain, add some hole to minimize the uboot change */
static struct imx_pwr_domain pu_domains[11] = {
[HSIOMIX] = IMX_MIX_DOMAIN(HSIOMIX),
[OTG1] = IMX_PD_DOMAIN(OTG1),
[GPUMIX] = IMX_MIX_DOMAIN(GPUMIX),
[DISPMIX] = IMX_MIX_DOMAIN(DISPMIX),
[MIPI] = IMX_PD_DOMAIN(MIPI),
};
static unsigned int pu_domain_status;
void imx_gpc_pm_domain_enable(uint32_t domain_id, bool on)
{
struct imx_pwr_domain *pwr_domain = &pu_domains[domain_id];
if (on) {
pu_domain_status |= (1 << domain_id);
/* HSIOMIX has no PU bit, so skip for it */
if (domain_id != HSIOMIX) {
/* clear the PGC bit */
mmio_clrbits_32(IMX_GPC_BASE + pwr_domain->pgc_offset, 0x1);
/* power up the domain */
mmio_setbits_32(IMX_GPC_BASE + PU_PGC_UP_TRG, pwr_domain->pwr_req);
/* wait for power request done */
while (mmio_read_32(IMX_GPC_BASE + PU_PGC_UP_TRG) & pwr_domain->pwr_req);
}
if (domain_id == DISPMIX) {
/* de-reset bus_blk clk and
* enable bus_blk clk
*/
mmio_write_32(0x32e28000, 0x100);
mmio_write_32(0x32e28004, 0x100);
}
/* handle the ADB400 sync */
if (!pwr_domain->init_on && pwr_domain->need_sync) {
/* clear adb power down request */
mmio_setbits_32(IMX_GPC_BASE + GPC_PU_PWRHSK, pwr_domain->adb400_sync);
/* wait for adb power request ack */
while (!(mmio_read_32(IMX_GPC_BASE + GPC_PU_PWRHSK) & pwr_domain->adb400_ack))
;
}
} else {
pu_domain_status &= ~(1 << domain_id);
if (domain_id == OTG1)
return;
/* handle the ADB400 sync */
if (!pwr_domain->init_on && pwr_domain->need_sync) {
/* set adb power down request */
mmio_clrbits_32(IMX_GPC_BASE + GPC_PU_PWRHSK, pwr_domain->adb400_sync);
/* wait for adb power request ack */
while ((mmio_read_32(IMX_GPC_BASE + GPC_PU_PWRHSK) & pwr_domain->adb400_ack))
;
}
/* HSIOMIX has no PU bit, so skip for it */
if (domain_id != HSIOMIX) {
/* set the PGC bit */
mmio_setbits_32(IMX_GPC_BASE + pwr_domain->pgc_offset, 0x1);
/* power down the domain */
mmio_setbits_32(IMX_GPC_BASE + PU_PGC_DN_TRG, pwr_domain->pwr_req);
/* wait for power request done */
while (mmio_read_32(IMX_GPC_BASE + PU_PGC_DN_TRG) & pwr_domain->pwr_req);
}
}
pwr_domain->init_on = false;
}
static void imx8mm_tz380_init(void)
{
unsigned int val;
val = mmio_read_32(IMX_IOMUX_GPR_BASE + 0x28);
if ((val & GPR_TZASC_EN) != GPR_TZASC_EN)
return;
tzc380_init(IMX_TZASC_BASE);
/* Enable 1G-5G S/NS RW */
tzc380_configure_region(0, 0x00000000, TZC_ATTR_REGION_SIZE(TZC_REGION_SIZE_4G)
| TZC_ATTR_REGION_EN_MASK | TZC_ATTR_SP_ALL);
}
void imx_noc_wrapper_pre_suspend(unsigned int proc_num)
{
/* enable MASTER1 & MASTER2 power down in A53 LPM mode */
mmio_clrbits_32(IMX_GPC_BASE + LPCR_A53_BSC, MASTER1_LPM_HSK | MASTER2_LPM_HSK);
mmio_setbits_32(IMX_GPC_BASE+ MST_CPU_MAPPING, MASTER1_MAPPING | MASTER2_MAPPING);
/* noc can only be power down when all the pu domain is off */
if (!pu_domain_status) {
/* enable noc power down */
imx_noc_slot_config(true);
/*
* below clocks must be enabled to make sure RDC MRCs
* can be successfully reloaded.
*/
mmio_setbits_32(IMX_CCM_BASE + 0xa300, (0x1 << 28));
mmio_write_32(IMX_CCM_BASE + CCGR(5), 0x3);
mmio_write_32(IMX_CCM_BASE + CCGR(87), 0x3);
}
/*
* gic redistributor context save must be called when
* the GIC CPU interface is disabled and before distributor save.
*/
plat_gic_save(proc_num, &imx_gicv3_ctx);
}
void imx_noc_wrapper_post_resume(unsigned int proc_num)
{
/* disable MASTER1 & MASTER2 power down in A53 LPM mode */
mmio_setbits_32(IMX_GPC_BASE + LPCR_A53_BSC, MASTER1_LPM_HSK | MASTER2_LPM_HSK);
mmio_clrbits_32(IMX_GPC_BASE + MST_CPU_MAPPING, MASTER1_MAPPING | MASTER2_MAPPING);
/* noc can only be power down when all the pu domain is off */
if (!pu_domain_status) {
/* re-init the tz380 if resume from noc power down */
imx8mm_tz380_init();
/* disable noc power down */
imx_noc_slot_config(false);
}
/* restore gic context */
plat_gic_restore(proc_num, &imx_gicv3_ctx);
}
void imx_gpc_init(void)
{
unsigned int val;
int i;
/* mask all the wakeup irq by default */
for (i = 0; i < 4; i++) {
mmio_write_32(IMX_GPC_BASE + IMR1_CORE0_A53 + i * 4, ~0x0);
mmio_write_32(IMX_GPC_BASE + IMR1_CORE1_A53 + i * 4, ~0x0);
mmio_write_32(IMX_GPC_BASE + IMR1_CORE2_A53 + i * 4, ~0x0);
mmio_write_32(IMX_GPC_BASE + IMR1_CORE3_A53 + i * 4, ~0x0);
mmio_write_32(IMX_GPC_BASE + IMR1_CORE0_M4 + i * 4, ~0x0);
}
val = mmio_read_32(IMX_GPC_BASE + LPCR_A53_BSC);
/* use GIC wake_request to wakeup C0~C3 from LPM */
val |= 0x30c00000;
/* clear the MASTER0 LPM handshake */
val &= ~(1 << 6);
mmio_write_32(IMX_GPC_BASE + LPCR_A53_BSC, val);
/* clear MASTER1 & MASTER2 mapping in CPU0(A53) */
mmio_clrbits_32(IMX_GPC_BASE + MST_CPU_MAPPING, (MASTER1_MAPPING |
MASTER2_MAPPING));
/* set all mix/PU in A53 domain */
mmio_write_32(IMX_GPC_BASE + PGC_CPU_0_1_MAPPING, 0xffff);
/*
* Set the CORE & SCU power up timing:
* SW = 0x1, SW2ISO = 0x1;
* the CPU CORE and SCU power up timming counter
* is drived by 32K OSC, each domain's power up
* latency is (SW + SW2ISO) / 32768
*/
mmio_write_32(IMX_GPC_BASE + COREx_PGC_PCR(0) + 0x4, 0x401);
mmio_write_32(IMX_GPC_BASE + COREx_PGC_PCR(1) + 0x4, 0x401);
mmio_write_32(IMX_GPC_BASE + COREx_PGC_PCR(2) + 0x4, 0x401);
mmio_write_32(IMX_GPC_BASE + COREx_PGC_PCR(3) + 0x4, 0x401);
mmio_write_32(IMX_GPC_BASE + PLAT_PGC_PCR + 0x4, 0x401);
mmio_write_32(IMX_GPC_BASE + PGC_SCU_TIMING,
(0x59 << 10) | 0x5B | (0x2 << 20));
/* set DUMMY PDN/PUP ACK by default for A53 domain */
mmio_write_32(IMX_GPC_BASE + PGC_ACK_SEL_A53,
A53_DUMMY_PUP_ACK | A53_DUMMY_PDN_ACK);
/* clear DSM by default */
val = mmio_read_32(IMX_GPC_BASE + SLPCR);
val &= ~SLPCR_EN_DSM;
/* enable the fast wakeup wait/stop mode */
val |= SLPCR_A53_FASTWUP_WAIT_MODE;
val |= SLPCR_A53_FASTWUP_STOP_MODE;
/* clear the RBC */
val &= ~(0x3f << SLPCR_RBC_COUNT_SHIFT);
/* set the STBY_COUNT to 0x5, (128 * 30)us */
val &= ~(0x7 << SLPCR_STBY_COUNT_SHFT);
val |= (0x5 << SLPCR_STBY_COUNT_SHFT);
mmio_write_32(IMX_GPC_BASE + SLPCR, val);
/*
* USB PHY power up needs to make sure RESET bit in SRC is clear,
* otherwise, the PU power up bit in GPC will NOT self-cleared.
* only need to do it once.
*/
mmio_clrbits_32(IMX_SRC_BASE + SRC_OTG1PHY_SCR, 0x1);
}
|
