Commit | Line | Data |
---|---|---|
530f9216 AE |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | ||
3 | /* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved. | |
a4388da5 | 4 | * Copyright (C) 2019-2022 Linaro Ltd. |
530f9216 AE |
5 | */ |
6 | ||
7 | #include <linux/types.h> | |
8 | #include <linux/device.h> | |
9 | #include <linux/interrupt.h> | |
10 | #include <linux/notifier.h> | |
f39650de | 11 | #include <linux/panic_notifier.h> |
0d08026a | 12 | #include <linux/pm_runtime.h> |
530f9216 AE |
13 | #include <linux/soc/qcom/smem.h> |
14 | #include <linux/soc/qcom/smem_state.h> | |
15 | ||
16 | #include "ipa_smp2p.h" | |
17 | #include "ipa.h" | |
18 | #include "ipa_uc.h" | |
530f9216 AE |
19 | |
20 | /** | |
21 | * DOC: IPA SMP2P communication with the modem | |
22 | * | |
23 | * SMP2P is a primitive communication mechanism available between the AP and | |
24 | * the modem. The IPA driver uses this for two purposes: to enable the modem | |
25 | * to state that the GSI hardware is ready to use; and to communicate the | |
7aa0e8b8 | 26 | * state of IPA power in the event of a crash. |
530f9216 AE |
27 | * |
28 | * GSI needs to have early initialization completed before it can be used. | |
29 | * This initialization is done either by Trust Zone or by the modem. In the | |
30 | * latter case, the modem uses an SMP2P interrupt to tell the AP IPA driver | |
31 | * when the GSI is ready to use. | |
32 | * | |
7aa0e8b8 AE |
33 | * The modem is also able to inquire about the current state of IPA |
34 | * power by trigging another SMP2P interrupt to the AP. We communicate | |
35 | * whether power is enabled using two SMP2P state bits--one to indicate | |
36 | * the power state (on or off), and a second to indicate the power state | |
37 | * bit is valid. The modem will poll the valid bit until it is set, and | |
38 | * at that time records whether the AP has IPA power enabled. | |
530f9216 AE |
39 | * |
40 | * Finally, if the AP kernel panics, we update the SMP2P state bits even if | |
41 | * we never receive an interrupt from the modem requesting this. | |
42 | */ | |
43 | ||
44 | /** | |
45 | * struct ipa_smp2p - IPA SMP2P information | |
46 | * @ipa: IPA pointer | |
47 | * @valid_state: SMEM state indicating enabled state is valid | |
7aa0e8b8 | 48 | * @enabled_state: SMEM state to indicate power is enabled |
530f9216 AE |
49 | * @valid_bit: Valid bit in 32-bit SMEM state mask |
50 | * @enabled_bit: Enabled bit in 32-bit SMEM state mask | |
51 | * @enabled_bit: Enabled bit in 32-bit SMEM state mask | |
7aa0e8b8 | 52 | * @clock_query_irq: IPA interrupt triggered by modem for power query |
530f9216 | 53 | * @setup_ready_irq: IPA interrupt triggered by modem to signal GSI ready |
7aa0e8b8 AE |
54 | * @power_on: Whether IPA power is on |
55 | * @notified: Whether modem has been notified of power state | |
33a15310 | 56 | * @setup_disabled: Whether setup ready interrupt handler is disabled |
16bb1b50 | 57 | * @mutex: Mutex protecting ready-interrupt/shutdown interlock |
530f9216 AE |
58 | * @panic_notifier: Panic notifier structure |
59 | */ | |
60 | struct ipa_smp2p { | |
61 | struct ipa *ipa; | |
62 | struct qcom_smem_state *valid_state; | |
63 | struct qcom_smem_state *enabled_state; | |
64 | u32 valid_bit; | |
65 | u32 enabled_bit; | |
66 | u32 clock_query_irq; | |
67 | u32 setup_ready_irq; | |
7aa0e8b8 | 68 | bool power_on; |
530f9216 | 69 | bool notified; |
33a15310 | 70 | bool setup_disabled; |
530f9216 AE |
71 | struct mutex mutex; |
72 | struct notifier_block panic_notifier; | |
73 | }; | |
74 | ||
75 | /** | |
7aa0e8b8 | 76 | * ipa_smp2p_notify() - use SMP2P to tell modem about IPA power state |
530f9216 AE |
77 | * @smp2p: SMP2P information |
78 | * | |
79 | * This is called either when the modem has requested it (by triggering | |
7aa0e8b8 | 80 | * the modem power query IPA interrupt) or whenever the AP is shutting down |
530f9216 | 81 | * (via a panic notifier). It sets the two SMP2P state bits--one saying |
7aa0e8b8 | 82 | * whether the IPA power is on, and the other indicating the first bit |
530f9216 AE |
83 | * is valid. |
84 | */ | |
85 | static void ipa_smp2p_notify(struct ipa_smp2p *smp2p) | |
86 | { | |
0d08026a | 87 | struct device *dev; |
530f9216 AE |
88 | u32 value; |
89 | u32 mask; | |
90 | ||
91 | if (smp2p->notified) | |
92 | return; | |
93 | ||
0d08026a | 94 | dev = &smp2p->ipa->pdev->dev; |
7aa0e8b8 | 95 | smp2p->power_on = pm_runtime_get_if_active(dev, true) > 0; |
530f9216 | 96 | |
7aa0e8b8 | 97 | /* Signal whether the IPA power is enabled */ |
530f9216 | 98 | mask = BIT(smp2p->enabled_bit); |
7aa0e8b8 | 99 | value = smp2p->power_on ? mask : 0; |
530f9216 AE |
100 | qcom_smem_state_update_bits(smp2p->enabled_state, mask, value); |
101 | ||
102 | /* Now indicate that the enabled flag is valid */ | |
103 | mask = BIT(smp2p->valid_bit); | |
104 | value = mask; | |
105 | qcom_smem_state_update_bits(smp2p->valid_state, mask, value); | |
106 | ||
107 | smp2p->notified = true; | |
108 | } | |
109 | ||
110 | /* Threaded IRQ handler for modem "ipa-clock-query" SMP2P interrupt */ | |
111 | static irqreturn_t ipa_smp2p_modem_clk_query_isr(int irq, void *dev_id) | |
112 | { | |
113 | struct ipa_smp2p *smp2p = dev_id; | |
114 | ||
115 | ipa_smp2p_notify(smp2p); | |
116 | ||
117 | return IRQ_HANDLED; | |
118 | } | |
119 | ||
120 | static int ipa_smp2p_panic_notifier(struct notifier_block *nb, | |
121 | unsigned long action, void *data) | |
122 | { | |
123 | struct ipa_smp2p *smp2p; | |
124 | ||
125 | smp2p = container_of(nb, struct ipa_smp2p, panic_notifier); | |
126 | ||
127 | ipa_smp2p_notify(smp2p); | |
128 | ||
7aa0e8b8 | 129 | if (smp2p->power_on) |
530f9216 AE |
130 | ipa_uc_panic_notifier(smp2p->ipa); |
131 | ||
132 | return NOTIFY_DONE; | |
133 | } | |
134 | ||
135 | static int ipa_smp2p_panic_notifier_register(struct ipa_smp2p *smp2p) | |
136 | { | |
137 | /* IPA panic handler needs to run before modem shuts down */ | |
138 | smp2p->panic_notifier.notifier_call = ipa_smp2p_panic_notifier; | |
139 | smp2p->panic_notifier.priority = INT_MAX; /* Do it early */ | |
140 | ||
141 | return atomic_notifier_chain_register(&panic_notifier_list, | |
142 | &smp2p->panic_notifier); | |
143 | } | |
144 | ||
145 | static void ipa_smp2p_panic_notifier_unregister(struct ipa_smp2p *smp2p) | |
146 | { | |
147 | atomic_notifier_chain_unregister(&panic_notifier_list, | |
148 | &smp2p->panic_notifier); | |
149 | } | |
150 | ||
151 | /* Threaded IRQ handler for modem "ipa-setup-ready" SMP2P interrupt */ | |
152 | static irqreturn_t ipa_smp2p_modem_setup_ready_isr(int irq, void *dev_id) | |
153 | { | |
154 | struct ipa_smp2p *smp2p = dev_id; | |
c43adc75 | 155 | struct device *dev; |
7ebd168c | 156 | int ret; |
530f9216 | 157 | |
33a15310 AE |
158 | /* Ignore any (spurious) interrupts received after the first */ |
159 | if (smp2p->ipa->setup_complete) | |
160 | return IRQ_HANDLED; | |
cf8dfe6a | 161 | |
c43adc75 AE |
162 | /* Power needs to be active for setup */ |
163 | dev = &smp2p->ipa->pdev->dev; | |
164 | ret = pm_runtime_get_sync(dev); | |
165 | if (ret < 0) { | |
166 | dev_err(dev, "error %d getting power for setup\n", ret); | |
167 | goto out_power_put; | |
168 | } | |
cf8dfe6a | 169 | |
7ebd168c AE |
170 | /* An error here won't cause driver shutdown, so warn if one occurs */ |
171 | ret = ipa_setup(smp2p->ipa); | |
172 | WARN(ret != 0, "error %d from ipa_setup()\n", ret); | |
530f9216 | 173 | |
c43adc75 | 174 | out_power_put: |
1aac309d AE |
175 | pm_runtime_mark_last_busy(dev); |
176 | (void)pm_runtime_put_autosuspend(dev); | |
530f9216 AE |
177 | |
178 | return IRQ_HANDLED; | |
179 | } | |
180 | ||
181 | /* Initialize SMP2P interrupts */ | |
182 | static int ipa_smp2p_irq_init(struct ipa_smp2p *smp2p, const char *name, | |
183 | irq_handler_t handler) | |
184 | { | |
185 | struct device *dev = &smp2p->ipa->pdev->dev; | |
186 | unsigned int irq; | |
187 | int ret; | |
188 | ||
189 | ret = platform_get_irq_byname(smp2p->ipa->pdev, name); | |
950fd045 | 190 | if (ret <= 0) |
530f9216 | 191 | return ret ? : -EINVAL; |
530f9216 AE |
192 | irq = ret; |
193 | ||
194 | ret = request_threaded_irq(irq, NULL, handler, 0, name, smp2p); | |
195 | if (ret) { | |
196 | dev_err(dev, "error %d requesting \"%s\" IRQ\n", ret, name); | |
197 | return ret; | |
198 | } | |
199 | ||
200 | return irq; | |
201 | } | |
202 | ||
203 | static void ipa_smp2p_irq_exit(struct ipa_smp2p *smp2p, u32 irq) | |
204 | { | |
205 | free_irq(irq, smp2p); | |
206 | } | |
207 | ||
7aa0e8b8 AE |
208 | /* Drop the power reference if it was taken in ipa_smp2p_notify() */ |
209 | static void ipa_smp2p_power_release(struct ipa *ipa) | |
530f9216 | 210 | { |
1aac309d AE |
211 | struct device *dev = &ipa->pdev->dev; |
212 | ||
7aa0e8b8 | 213 | if (!ipa->smp2p->power_on) |
530f9216 AE |
214 | return; |
215 | ||
1aac309d AE |
216 | pm_runtime_mark_last_busy(dev); |
217 | (void)pm_runtime_put_autosuspend(dev); | |
7aa0e8b8 | 218 | ipa->smp2p->power_on = false; |
530f9216 AE |
219 | } |
220 | ||
221 | /* Initialize the IPA SMP2P subsystem */ | |
222 | int ipa_smp2p_init(struct ipa *ipa, bool modem_init) | |
223 | { | |
224 | struct qcom_smem_state *enabled_state; | |
225 | struct device *dev = &ipa->pdev->dev; | |
226 | struct qcom_smem_state *valid_state; | |
227 | struct ipa_smp2p *smp2p; | |
228 | u32 enabled_bit; | |
229 | u32 valid_bit; | |
230 | int ret; | |
231 | ||
232 | valid_state = qcom_smem_state_get(dev, "ipa-clock-enabled-valid", | |
233 | &valid_bit); | |
234 | if (IS_ERR(valid_state)) | |
235 | return PTR_ERR(valid_state); | |
236 | if (valid_bit >= 32) /* BITS_PER_U32 */ | |
237 | return -EINVAL; | |
238 | ||
239 | enabled_state = qcom_smem_state_get(dev, "ipa-clock-enabled", | |
240 | &enabled_bit); | |
241 | if (IS_ERR(enabled_state)) | |
242 | return PTR_ERR(enabled_state); | |
243 | if (enabled_bit >= 32) /* BITS_PER_U32 */ | |
244 | return -EINVAL; | |
245 | ||
246 | smp2p = kzalloc(sizeof(*smp2p), GFP_KERNEL); | |
247 | if (!smp2p) | |
248 | return -ENOMEM; | |
249 | ||
250 | smp2p->ipa = ipa; | |
251 | ||
7aa0e8b8 | 252 | /* These fields are needed by the power query interrupt |
530f9216 AE |
253 | * handler, so initialize them now. |
254 | */ | |
255 | mutex_init(&smp2p->mutex); | |
256 | smp2p->valid_state = valid_state; | |
257 | smp2p->valid_bit = valid_bit; | |
258 | smp2p->enabled_state = enabled_state; | |
259 | smp2p->enabled_bit = enabled_bit; | |
260 | ||
261 | /* We have enough information saved to handle notifications */ | |
262 | ipa->smp2p = smp2p; | |
263 | ||
264 | ret = ipa_smp2p_irq_init(smp2p, "ipa-clock-query", | |
265 | ipa_smp2p_modem_clk_query_isr); | |
266 | if (ret < 0) | |
267 | goto err_null_smp2p; | |
268 | smp2p->clock_query_irq = ret; | |
269 | ||
270 | ret = ipa_smp2p_panic_notifier_register(smp2p); | |
271 | if (ret) | |
272 | goto err_irq_exit; | |
273 | ||
274 | if (modem_init) { | |
275 | /* Result will be non-zero (negative for error) */ | |
276 | ret = ipa_smp2p_irq_init(smp2p, "ipa-setup-ready", | |
277 | ipa_smp2p_modem_setup_ready_isr); | |
278 | if (ret < 0) | |
279 | goto err_notifier_unregister; | |
280 | smp2p->setup_ready_irq = ret; | |
281 | } | |
282 | ||
283 | return 0; | |
284 | ||
285 | err_notifier_unregister: | |
286 | ipa_smp2p_panic_notifier_unregister(smp2p); | |
287 | err_irq_exit: | |
288 | ipa_smp2p_irq_exit(smp2p, smp2p->clock_query_irq); | |
289 | err_null_smp2p: | |
290 | ipa->smp2p = NULL; | |
291 | mutex_destroy(&smp2p->mutex); | |
292 | kfree(smp2p); | |
293 | ||
294 | return ret; | |
295 | } | |
296 | ||
297 | void ipa_smp2p_exit(struct ipa *ipa) | |
298 | { | |
299 | struct ipa_smp2p *smp2p = ipa->smp2p; | |
300 | ||
301 | if (smp2p->setup_ready_irq) | |
302 | ipa_smp2p_irq_exit(smp2p, smp2p->setup_ready_irq); | |
303 | ipa_smp2p_panic_notifier_unregister(smp2p); | |
304 | ipa_smp2p_irq_exit(smp2p, smp2p->clock_query_irq); | |
7aa0e8b8 AE |
305 | /* We won't get notified any more; drop power reference (if any) */ |
306 | ipa_smp2p_power_release(ipa); | |
530f9216 AE |
307 | ipa->smp2p = NULL; |
308 | mutex_destroy(&smp2p->mutex); | |
309 | kfree(smp2p); | |
310 | } | |
311 | ||
8afc7e47 | 312 | void ipa_smp2p_irq_disable_setup(struct ipa *ipa) |
530f9216 AE |
313 | { |
314 | struct ipa_smp2p *smp2p = ipa->smp2p; | |
315 | ||
316 | if (!smp2p->setup_ready_irq) | |
317 | return; | |
318 | ||
319 | mutex_lock(&smp2p->mutex); | |
320 | ||
33a15310 AE |
321 | if (!smp2p->setup_disabled) { |
322 | disable_irq(smp2p->setup_ready_irq); | |
323 | smp2p->setup_disabled = true; | |
324 | } | |
530f9216 AE |
325 | |
326 | mutex_unlock(&smp2p->mutex); | |
327 | } | |
328 | ||
329 | /* Reset state tracking whether we have notified the modem */ | |
330 | void ipa_smp2p_notify_reset(struct ipa *ipa) | |
331 | { | |
332 | struct ipa_smp2p *smp2p = ipa->smp2p; | |
333 | u32 mask; | |
334 | ||
335 | if (!smp2p->notified) | |
336 | return; | |
337 | ||
7aa0e8b8 | 338 | ipa_smp2p_power_release(ipa); |
530f9216 | 339 | |
7aa0e8b8 | 340 | /* Reset the power enabled valid flag */ |
530f9216 AE |
341 | mask = BIT(smp2p->valid_bit); |
342 | qcom_smem_state_update_bits(smp2p->valid_state, mask, 0); | |
343 | ||
7aa0e8b8 | 344 | /* Mark the power disabled for good measure... */ |
530f9216 AE |
345 | mask = BIT(smp2p->enabled_bit); |
346 | qcom_smem_state_update_bits(smp2p->enabled_state, mask, 0); | |
347 | ||
348 | smp2p->notified = false; | |
349 | } |