1 // SPDX-License-Identifier: GPL-2.0
3 /* Copyright (c) 2012-2018, The Linux Foundation. All rights reserved.
4 * Copyright (C) 2019-2020 Linaro Ltd.
7 #include <linux/types.h>
8 #include <linux/device.h>
9 #include <linux/interrupt.h>
10 #include <linux/notifier.h>
11 #include <linux/soc/qcom/smem.h>
12 #include <linux/soc/qcom/smem_state.h>
14 #include "ipa_smp2p.h"
17 #include "ipa_clock.h"
20 * DOC: IPA SMP2P communication with the modem
22 * SMP2P is a primitive communication mechanism available between the AP and
23 * the modem. The IPA driver uses this for two purposes: to enable the modem
24 * to state that the GSI hardware is ready to use; and to communicate the
25 * state of the IPA clock in the event of a crash.
27 * GSI needs to have early initialization completed before it can be used.
28 * This initialization is done either by Trust Zone or by the modem. In the
29 * latter case, the modem uses an SMP2P interrupt to tell the AP IPA driver
30 * when the GSI is ready to use.
32 * The modem is also able to inquire about the current state of the IPA
33 * clock by trigging another SMP2P interrupt to the AP. We communicate
34 * whether the clock is enabled using two SMP2P state bits--one to
35 * indicate the clock state (on or off), and a second to indicate the
36 * clock state bit is valid. The modem will poll the valid bit until it
37 * is set, and at that time records whether the AP has the IPA clock enabled.
39 * Finally, if the AP kernel panics, we update the SMP2P state bits even if
40 * we never receive an interrupt from the modem requesting this.
44 * struct ipa_smp2p - IPA SMP2P information
46 * @valid_state: SMEM state indicating enabled state is valid
47 * @enabled_state: SMEM state to indicate clock is enabled
48 * @valid_bit: Valid bit in 32-bit SMEM state mask
49 * @enabled_bit: Enabled bit in 32-bit SMEM state mask
50 * @enabled_bit: Enabled bit in 32-bit SMEM state mask
51 * @clock_query_irq: IPA interrupt triggered by modem for clock query
52 * @setup_ready_irq: IPA interrupt triggered by modem to signal GSI ready
53 * @clock_on: Whether IPA clock is on
54 * @notified: Whether modem has been notified of clock state
55 * @disabled: Whether setup ready interrupt handling is disabled
56 * @mutex mutex: Motex protecting ready interrupt/shutdown interlock
57 * @panic_notifier: Panic notifier structure
61 struct qcom_smem_state
*valid_state
;
62 struct qcom_smem_state
*enabled_state
;
71 struct notifier_block panic_notifier
;
75 * ipa_smp2p_notify() - use SMP2P to tell modem about IPA clock state
76 * @smp2p: SMP2P information
78 * This is called either when the modem has requested it (by triggering
79 * the modem clock query IPA interrupt) or whenever the AP is shutting down
80 * (via a panic notifier). It sets the two SMP2P state bits--one saying
81 * whether the IPA clock is running, and the other indicating the first bit
84 static void ipa_smp2p_notify(struct ipa_smp2p
*smp2p
)
92 smp2p
->clock_on
= ipa_clock_get_additional(smp2p
->ipa
);
94 /* Signal whether the clock is enabled */
95 mask
= BIT(smp2p
->enabled_bit
);
96 value
= smp2p
->clock_on
? mask
: 0;
97 qcom_smem_state_update_bits(smp2p
->enabled_state
, mask
, value
);
99 /* Now indicate that the enabled flag is valid */
100 mask
= BIT(smp2p
->valid_bit
);
102 qcom_smem_state_update_bits(smp2p
->valid_state
, mask
, value
);
104 smp2p
->notified
= true;
107 /* Threaded IRQ handler for modem "ipa-clock-query" SMP2P interrupt */
108 static irqreturn_t
ipa_smp2p_modem_clk_query_isr(int irq
, void *dev_id
)
110 struct ipa_smp2p
*smp2p
= dev_id
;
112 ipa_smp2p_notify(smp2p
);
117 static int ipa_smp2p_panic_notifier(struct notifier_block
*nb
,
118 unsigned long action
, void *data
)
120 struct ipa_smp2p
*smp2p
;
122 smp2p
= container_of(nb
, struct ipa_smp2p
, panic_notifier
);
124 ipa_smp2p_notify(smp2p
);
127 ipa_uc_panic_notifier(smp2p
->ipa
);
132 static int ipa_smp2p_panic_notifier_register(struct ipa_smp2p
*smp2p
)
134 /* IPA panic handler needs to run before modem shuts down */
135 smp2p
->panic_notifier
.notifier_call
= ipa_smp2p_panic_notifier
;
136 smp2p
->panic_notifier
.priority
= INT_MAX
; /* Do it early */
138 return atomic_notifier_chain_register(&panic_notifier_list
,
139 &smp2p
->panic_notifier
);
142 static void ipa_smp2p_panic_notifier_unregister(struct ipa_smp2p
*smp2p
)
144 atomic_notifier_chain_unregister(&panic_notifier_list
,
145 &smp2p
->panic_notifier
);
148 /* Threaded IRQ handler for modem "ipa-setup-ready" SMP2P interrupt */
149 static irqreturn_t
ipa_smp2p_modem_setup_ready_isr(int irq
, void *dev_id
)
151 struct ipa_smp2p
*smp2p
= dev_id
;
153 mutex_lock(&smp2p
->mutex
);
155 if (!smp2p
->disabled
) {
158 ret
= ipa_setup(smp2p
->ipa
);
160 dev_err(&smp2p
->ipa
->pdev
->dev
,
161 "error %d from ipa_setup()\n", ret
);
162 smp2p
->disabled
= true;
165 mutex_unlock(&smp2p
->mutex
);
170 /* Initialize SMP2P interrupts */
171 static int ipa_smp2p_irq_init(struct ipa_smp2p
*smp2p
, const char *name
,
172 irq_handler_t handler
)
174 struct device
*dev
= &smp2p
->ipa
->pdev
->dev
;
178 ret
= platform_get_irq_byname(smp2p
->ipa
->pdev
, name
);
180 dev_err(dev
, "DT error %d getting \"%s\" IRQ property\n",
182 return ret
? : -EINVAL
;
186 ret
= request_threaded_irq(irq
, NULL
, handler
, 0, name
, smp2p
);
188 dev_err(dev
, "error %d requesting \"%s\" IRQ\n", ret
, name
);
195 static void ipa_smp2p_irq_exit(struct ipa_smp2p
*smp2p
, u32 irq
)
197 free_irq(irq
, smp2p
);
200 /* Drop the clock reference if it was taken in ipa_smp2p_notify() */
201 static void ipa_smp2p_clock_release(struct ipa
*ipa
)
203 if (!ipa
->smp2p
->clock_on
)
207 ipa
->smp2p
->clock_on
= false;
210 /* Initialize the IPA SMP2P subsystem */
211 int ipa_smp2p_init(struct ipa
*ipa
, bool modem_init
)
213 struct qcom_smem_state
*enabled_state
;
214 struct device
*dev
= &ipa
->pdev
->dev
;
215 struct qcom_smem_state
*valid_state
;
216 struct ipa_smp2p
*smp2p
;
221 valid_state
= qcom_smem_state_get(dev
, "ipa-clock-enabled-valid",
223 if (IS_ERR(valid_state
))
224 return PTR_ERR(valid_state
);
225 if (valid_bit
>= 32) /* BITS_PER_U32 */
228 enabled_state
= qcom_smem_state_get(dev
, "ipa-clock-enabled",
230 if (IS_ERR(enabled_state
))
231 return PTR_ERR(enabled_state
);
232 if (enabled_bit
>= 32) /* BITS_PER_U32 */
235 smp2p
= kzalloc(sizeof(*smp2p
), GFP_KERNEL
);
241 /* These fields are needed by the clock query interrupt
242 * handler, so initialize them now.
244 mutex_init(&smp2p
->mutex
);
245 smp2p
->valid_state
= valid_state
;
246 smp2p
->valid_bit
= valid_bit
;
247 smp2p
->enabled_state
= enabled_state
;
248 smp2p
->enabled_bit
= enabled_bit
;
250 /* We have enough information saved to handle notifications */
253 ret
= ipa_smp2p_irq_init(smp2p
, "ipa-clock-query",
254 ipa_smp2p_modem_clk_query_isr
);
257 smp2p
->clock_query_irq
= ret
;
259 ret
= ipa_smp2p_panic_notifier_register(smp2p
);
264 /* Result will be non-zero (negative for error) */
265 ret
= ipa_smp2p_irq_init(smp2p
, "ipa-setup-ready",
266 ipa_smp2p_modem_setup_ready_isr
);
268 goto err_notifier_unregister
;
269 smp2p
->setup_ready_irq
= ret
;
274 err_notifier_unregister
:
275 ipa_smp2p_panic_notifier_unregister(smp2p
);
277 ipa_smp2p_irq_exit(smp2p
, smp2p
->clock_query_irq
);
280 mutex_destroy(&smp2p
->mutex
);
286 void ipa_smp2p_exit(struct ipa
*ipa
)
288 struct ipa_smp2p
*smp2p
= ipa
->smp2p
;
290 if (smp2p
->setup_ready_irq
)
291 ipa_smp2p_irq_exit(smp2p
, smp2p
->setup_ready_irq
);
292 ipa_smp2p_panic_notifier_unregister(smp2p
);
293 ipa_smp2p_irq_exit(smp2p
, smp2p
->clock_query_irq
);
294 /* We won't get notified any more; drop clock reference (if any) */
295 ipa_smp2p_clock_release(ipa
);
297 mutex_destroy(&smp2p
->mutex
);
301 void ipa_smp2p_disable(struct ipa
*ipa
)
303 struct ipa_smp2p
*smp2p
= ipa
->smp2p
;
305 if (!smp2p
->setup_ready_irq
)
308 mutex_lock(&smp2p
->mutex
);
310 smp2p
->disabled
= true;
312 mutex_unlock(&smp2p
->mutex
);
315 /* Reset state tracking whether we have notified the modem */
316 void ipa_smp2p_notify_reset(struct ipa
*ipa
)
318 struct ipa_smp2p
*smp2p
= ipa
->smp2p
;
321 if (!smp2p
->notified
)
324 ipa_smp2p_clock_release(ipa
);
326 /* Reset the clock enabled valid flag */
327 mask
= BIT(smp2p
->valid_bit
);
328 qcom_smem_state_update_bits(smp2p
->valid_state
, mask
, 0);
330 /* Mark the clock disabled for good measure... */
331 mask
= BIT(smp2p
->enabled_bit
);
332 qcom_smem_state_update_bits(smp2p
->enabled_state
, mask
, 0);
334 smp2p
->notified
= false;