1 /*
2 * Copyright (c) 2018-2020, ARM Limited and Contributors. All rights reserved.
3 *
4 * SPDX-License-Identifier: BSD-3-Clause
5 */
6
7 #include <assert.h>
8 #include <errno.h>
9
10 #include <platform_def.h>
11
12 #include <arch_helpers.h>
13 #include <common/debug.h>
14 #include <drivers/delay_timer.h>
15 #include <drivers/generic_delay_timer.h>
16 #include <lib/cassert.h>
17 #include <lib/psci/psci.h>
18
19 #include <sq_common.h>
20 #include "sq_scpi.h"
21
22 uintptr_t sq_sec_entrypoint;
23
sq_pwr_domain_on(u_register_t mpidr)24 int sq_pwr_domain_on(u_register_t mpidr)
25 {
26 #if SQ_USE_SCMI_DRIVER
27 sq_scmi_on(mpidr);
28 #else
29 /*
30 * SCP takes care of powering up parent power domains so we
31 * only need to care about level 0
32 */
33 scpi_set_sq_power_state(mpidr, scpi_power_on, scpi_power_on,
34 scpi_power_on);
35 #endif
36
37 return PSCI_E_SUCCESS;
38 }
39
sq_pwr_domain_on_finisher_common(const psci_power_state_t * target_state)40 static void sq_pwr_domain_on_finisher_common(
41 const psci_power_state_t *target_state)
42 {
43 assert(SQ_CORE_PWR_STATE(target_state) == SQ_LOCAL_STATE_OFF);
44
45 /*
46 * Perform the common cluster specific operations i.e enable coherency
47 * if this cluster was off.
48 */
49 if (SQ_CLUSTER_PWR_STATE(target_state) == SQ_LOCAL_STATE_OFF)
50 plat_sq_interconnect_enter_coherency();
51 }
52
sq_pwr_domain_on_finish(const psci_power_state_t * target_state)53 void sq_pwr_domain_on_finish(const psci_power_state_t *target_state)
54 {
55 /* Assert that the system power domain need not be initialized */
56 assert(SQ_SYSTEM_PWR_STATE(target_state) == SQ_LOCAL_STATE_RUN);
57
58 sq_pwr_domain_on_finisher_common(target_state);
59
60 /* Program the gic per-cpu distributor or re-distributor interface */
61 sq_gic_pcpu_init();
62
63 /* Enable the gic cpu interface */
64 sq_gic_cpuif_enable();
65 }
66
67 #if !SQ_USE_SCMI_DRIVER
sq_power_down_common(const psci_power_state_t * target_state)68 static void sq_power_down_common(const psci_power_state_t *target_state)
69 {
70 uint32_t cluster_state = scpi_power_on;
71 uint32_t system_state = scpi_power_on;
72
73 /* Prevent interrupts from spuriously waking up this cpu */
74 sq_gic_cpuif_disable();
75
76 /* Check if power down at system power domain level is requested */
77 if (SQ_SYSTEM_PWR_STATE(target_state) == SQ_LOCAL_STATE_OFF)
78 system_state = scpi_power_retention;
79
80 /* Cluster is to be turned off, so disable coherency */
81 if (SQ_CLUSTER_PWR_STATE(target_state) == SQ_LOCAL_STATE_OFF) {
82 plat_sq_interconnect_exit_coherency();
83 cluster_state = scpi_power_off;
84 }
85
86 /*
87 * Ask the SCP to power down the appropriate components depending upon
88 * their state.
89 */
90 scpi_set_sq_power_state(read_mpidr_el1(),
91 scpi_power_off,
92 cluster_state,
93 system_state);
94 }
95 #endif
96
sq_pwr_domain_off(const psci_power_state_t * target_state)97 void sq_pwr_domain_off(const psci_power_state_t *target_state)
98 {
99 #if SQ_USE_SCMI_DRIVER
100 /* Prevent interrupts from spuriously waking up this cpu */
101 sq_gic_cpuif_disable();
102
103 /* Cluster is to be turned off, so disable coherency */
104 if (SQ_CLUSTER_PWR_STATE(target_state) == SQ_LOCAL_STATE_OFF) {
105 plat_sq_interconnect_exit_coherency();
106 }
107
108 sq_scmi_off(target_state);
109 #else
110 sq_power_down_common(target_state);
111 #endif
112 }
113
sq_system_off(void)114 void __dead2 sq_system_off(void)
115 {
116 volatile uint32_t *gpio = (uint32_t *)PLAT_SQ_GPIO_BASE;
117
118 /* set PD[9] high to power off the system */
119 gpio[5] |= 0x2; /* set output */
120 gpio[1] |= 0x2; /* set high */
121 dmbst();
122
123 generic_delay_timer_init();
124
125 mdelay(1);
126
127 while (1) {
128 gpio[1] &= ~0x2; /* set low */
129 dmbst();
130
131 mdelay(1);
132
133 gpio[1] |= 0x2; /* set high */
134 dmbst();
135
136 mdelay(100);
137 }
138
139 wfi();
140 ERROR("SQ System Off: operation not handled.\n");
141 panic();
142 }
143
sq_system_reset(void)144 void __dead2 sq_system_reset(void)
145 {
146 #if SQ_USE_SCMI_DRIVER
147 sq_scmi_sys_reboot();
148 #else
149 uint32_t response;
150
151 /* Send the system reset request to the SCP */
152 response = scpi_sys_power_state(scpi_system_reboot);
153
154 if (response != SCP_OK) {
155 ERROR("SQ System Reset: SCP error %u.\n", response);
156 panic();
157 }
158 wfi();
159 ERROR("SQ System Reset: operation not handled.\n");
160 panic();
161 #endif
162 }
163
sq_cpu_standby(plat_local_state_t cpu_state)164 void sq_cpu_standby(plat_local_state_t cpu_state)
165 {
166 u_register_t scr;
167
168 assert(cpu_state == SQ_LOCAL_STATE_RET);
169
170 scr = read_scr_el3();
171 /* Enable PhysicalIRQ bit for NS world to wake the CPU */
172 write_scr_el3(scr | SCR_IRQ_BIT);
173 isb();
174 dsb();
175 wfi();
176
177 /*
178 * Restore SCR to the original value, synchronisation of scr_el3 is
179 * done by eret while el3_exit to save some execution cycles.
180 */
181 write_scr_el3(scr);
182 }
183
184 const plat_psci_ops_t sq_psci_ops = {
185 .pwr_domain_on = sq_pwr_domain_on,
186 .pwr_domain_off = sq_pwr_domain_off,
187 .pwr_domain_on_finish = sq_pwr_domain_on_finish,
188 .cpu_standby = sq_cpu_standby,
189 .system_off = sq_system_off,
190 .system_reset = sq_system_reset,
191 };
192
plat_setup_psci_ops(uintptr_t sec_entrypoint,const struct plat_psci_ops ** psci_ops)193 int plat_setup_psci_ops(uintptr_t sec_entrypoint,
194 const struct plat_psci_ops **psci_ops)
195 {
196 sq_sec_entrypoint = sec_entrypoint;
197 flush_dcache_range((uint64_t)&sq_sec_entrypoint,
198 sizeof(sq_sec_entrypoint));
199
200 *psci_ops = &sq_psci_ops;
201
202 return 0;
203 }
204