1 // SPDX-License-Identifier: GPL-2.0-only
3 // Copyright(c) 2021-2022 Intel Corporation
9 #include <linux/io-64-nonatomic-lo-hi.h>
10 #include <linux/slab.h>
11 #include <sound/hdaudio_ext.h>
14 #include "registers.h"
17 #define AVS_IPC_TIMEOUT_MS 300
18 #define AVS_D0IX_DELAY_MS 300
21 avs_dsp_set_d0ix(struct avs_dev *adev, bool enable)
23 struct avs_ipc *ipc = adev->ipc;
26 /* Is transition required? */
27 if (ipc->in_d0ix == enable)
30 ret = avs_dsp_op(adev, set_d0ix, enable);
32 /* Prevent further d0ix attempts on conscious IPC failure. */
34 atomic_inc(&ipc->d0ix_disable_depth);
40 ipc->in_d0ix = enable;
44 static void avs_dsp_schedule_d0ix(struct avs_dev *adev, struct avs_ipc_msg *tx)
46 if (atomic_read(&adev->ipc->d0ix_disable_depth))
49 mod_delayed_work(system_power_efficient_wq, &adev->ipc->d0ix_work,
50 msecs_to_jiffies(AVS_D0IX_DELAY_MS));
53 static void avs_dsp_d0ix_work(struct work_struct *work)
55 struct avs_ipc *ipc = container_of(work, struct avs_ipc, d0ix_work.work);
57 avs_dsp_set_d0ix(to_avs_dev(ipc->dev), true);
60 static int avs_dsp_wake_d0i0(struct avs_dev *adev, struct avs_ipc_msg *tx)
62 struct avs_ipc *ipc = adev->ipc;
64 if (!atomic_read(&ipc->d0ix_disable_depth)) {
65 cancel_delayed_work_sync(&ipc->d0ix_work);
66 return avs_dsp_set_d0ix(adev, false);
72 int avs_dsp_disable_d0ix(struct avs_dev *adev)
74 struct avs_ipc *ipc = adev->ipc;
76 /* Prevent PG only on the first disable. */
77 if (atomic_inc_return(&ipc->d0ix_disable_depth) == 1) {
78 cancel_delayed_work_sync(&ipc->d0ix_work);
79 return avs_dsp_set_d0ix(adev, false);
85 int avs_dsp_enable_d0ix(struct avs_dev *adev)
87 struct avs_ipc *ipc = adev->ipc;
89 if (atomic_dec_and_test(&ipc->d0ix_disable_depth))
90 queue_delayed_work(system_power_efficient_wq, &ipc->d0ix_work,
91 msecs_to_jiffies(AVS_D0IX_DELAY_MS));
95 static void avs_dsp_recovery(struct avs_dev *adev)
97 struct avs_soc_component *acomp;
98 unsigned int core_mask;
101 mutex_lock(&adev->comp_list_mutex);
102 /* disconnect all running streams */
103 list_for_each_entry(acomp, &adev->comp_list, node) {
104 struct snd_soc_pcm_runtime *rtd;
105 struct snd_soc_card *card;
107 card = acomp->base.card;
111 for_each_card_rtds(card, rtd) {
116 if (!pcm || rtd->dai_link->no_pcm)
119 for_each_pcm_streams(dir) {
120 struct snd_pcm_substream *substream;
122 substream = pcm->streams[dir].substream;
123 if (!substream || !substream->runtime)
126 /* No need for _irq() as we are in nonatomic context. */
127 snd_pcm_stream_lock(substream);
128 snd_pcm_stop(substream, SNDRV_PCM_STATE_DISCONNECTED);
129 snd_pcm_stream_unlock(substream);
133 mutex_unlock(&adev->comp_list_mutex);
135 /* forcibly shutdown all cores */
136 core_mask = GENMASK(adev->hw_cfg.dsp_cores - 1, 0);
137 avs_dsp_core_disable(adev, core_mask);
139 /* attempt dsp reboot */
140 ret = avs_dsp_boot_firmware(adev, true);
142 dev_err(adev->dev, "dsp reboot failed: %d\n", ret);
144 pm_runtime_mark_last_busy(adev->dev);
145 pm_runtime_enable(adev->dev);
146 pm_request_autosuspend(adev->dev);
148 atomic_set(&adev->ipc->recovering, 0);
151 static void avs_dsp_recovery_work(struct work_struct *work)
153 struct avs_ipc *ipc = container_of(work, struct avs_ipc, recovery_work);
155 avs_dsp_recovery(to_avs_dev(ipc->dev));
158 static void avs_dsp_exception_caught(struct avs_dev *adev, union avs_notify_msg *msg)
160 struct avs_ipc *ipc = adev->ipc;
162 /* Account for the double-exception case. */
165 if (!atomic_add_unless(&ipc->recovering, 1, 1)) {
166 dev_err(adev->dev, "dsp recovery is already in progress\n");
170 dev_crit(adev->dev, "communication severed, rebooting dsp..\n");
172 cancel_delayed_work_sync(&ipc->d0ix_work);
173 ipc->in_d0ix = false;
174 /* Re-enabled on recovery completion. */
175 pm_runtime_disable(adev->dev);
177 /* Process received notification. */
178 avs_dsp_op(adev, coredump, msg);
180 schedule_work(&ipc->recovery_work);
183 static void avs_dsp_receive_rx(struct avs_dev *adev, u64 header)
185 struct avs_ipc *ipc = adev->ipc;
186 union avs_reply_msg msg = AVS_MSG(header);
189 sts = snd_hdac_adsp_readl(adev, AVS_FW_REG_STATUS(adev));
190 lec = snd_hdac_adsp_readl(adev, AVS_FW_REG_ERROR(adev));
191 trace_avs_ipc_reply_msg(header, sts, lec);
193 ipc->rx.header = header;
194 /* Abort copying payload if request processing was unsuccessful. */
196 /* update size in case of LARGE_CONFIG_GET */
197 if (msg.msg_target == AVS_MOD_MSG &&
198 msg.global_msg_type == AVS_MOD_LARGE_CONFIG_GET)
199 ipc->rx.size = min_t(u32, AVS_MAILBOX_SIZE,
200 msg.ext.large_config.data_off_size);
202 memcpy_fromio(ipc->rx.data, avs_uplink_addr(adev), ipc->rx.size);
203 trace_avs_msg_payload(ipc->rx.data, ipc->rx.size);
207 static void avs_dsp_process_notification(struct avs_dev *adev, u64 header)
209 struct avs_notify_mod_data mod_data;
210 union avs_notify_msg msg = AVS_MSG(header);
211 size_t data_size = 0;
215 sts = snd_hdac_adsp_readl(adev, AVS_FW_REG_STATUS(adev));
216 lec = snd_hdac_adsp_readl(adev, AVS_FW_REG_ERROR(adev));
217 trace_avs_ipc_notify_msg(header, sts, lec);
219 /* Ignore spurious notifications until handshake is established. */
220 if (!adev->ipc->ready && msg.notify_msg_type != AVS_NOTIFY_FW_READY) {
221 dev_dbg(adev->dev, "FW not ready, skip notification: 0x%08x\n", msg.primary);
225 /* Calculate notification payload size. */
226 switch (msg.notify_msg_type) {
227 case AVS_NOTIFY_FW_READY:
230 case AVS_NOTIFY_PHRASE_DETECTED:
231 data_size = sizeof(struct avs_notify_voice_data);
234 case AVS_NOTIFY_RESOURCE_EVENT:
235 data_size = sizeof(struct avs_notify_res_data);
238 case AVS_NOTIFY_LOG_BUFFER_STATUS:
239 case AVS_NOTIFY_EXCEPTION_CAUGHT:
242 case AVS_NOTIFY_MODULE_EVENT:
243 /* To know the total payload size, header needs to be read first. */
244 memcpy_fromio(&mod_data, avs_uplink_addr(adev), sizeof(mod_data));
245 data_size = sizeof(mod_data) + mod_data.data_size;
249 dev_info(adev->dev, "unknown notification: 0x%08x\n", msg.primary);
254 data = kmalloc(data_size, GFP_KERNEL);
258 memcpy_fromio(data, avs_uplink_addr(adev), data_size);
259 trace_avs_msg_payload(data, data_size);
262 /* Perform notification-specific operations. */
263 switch (msg.notify_msg_type) {
264 case AVS_NOTIFY_FW_READY:
265 dev_dbg(adev->dev, "FW READY 0x%08x\n", msg.primary);
266 adev->ipc->ready = true;
267 complete(&adev->fw_ready);
270 case AVS_NOTIFY_LOG_BUFFER_STATUS:
271 avs_log_buffer_status_locked(adev, &msg);
274 case AVS_NOTIFY_EXCEPTION_CAUGHT:
275 avs_dsp_exception_caught(adev, &msg);
285 void avs_dsp_process_response(struct avs_dev *adev, u64 header)
287 struct avs_ipc *ipc = adev->ipc;
290 * Response may either be solicited - a reply for a request that has
291 * been sent beforehand - or unsolicited (notification).
293 if (avs_msg_is_reply(header)) {
294 /* Response processing is invoked from IRQ thread. */
295 spin_lock_irq(&ipc->rx_lock);
296 avs_dsp_receive_rx(adev, header);
297 ipc->rx_completed = true;
298 spin_unlock_irq(&ipc->rx_lock);
300 avs_dsp_process_notification(adev, header);
303 complete(&ipc->busy_completion);
306 static bool avs_ipc_is_busy(struct avs_ipc *ipc)
308 struct avs_dev *adev = to_avs_dev(ipc->dev);
309 const struct avs_spec *const spec = adev->spec;
312 hipc_rsp = snd_hdac_adsp_readl(adev, spec->hipc->rsp_offset);
313 return hipc_rsp & spec->hipc->rsp_busy_mask;
316 static int avs_ipc_wait_busy_completion(struct avs_ipc *ipc, int timeout)
318 u32 repeats_left = 128; /* to avoid infinite looping */
322 ret = wait_for_completion_timeout(&ipc->busy_completion, msecs_to_jiffies(timeout));
324 /* DSP could be unresponsive at this point. */
329 if (!avs_ipc_is_busy(ipc))
332 * Firmware did its job, either notification or reply
333 * has been received - now wait until it's processed.
335 wait_for_completion_killable(&ipc->busy_completion);
338 /* Ongoing notification's bottom-half may cause early wakeup */
339 spin_lock(&ipc->rx_lock);
340 if (!ipc->rx_completed) {
342 /* Reply delayed due to notification. */
344 reinit_completion(&ipc->busy_completion);
345 spin_unlock(&ipc->rx_lock);
349 spin_unlock(&ipc->rx_lock);
353 spin_unlock(&ipc->rx_lock);
357 static void avs_ipc_msg_init(struct avs_ipc *ipc, struct avs_ipc_msg *reply)
359 lockdep_assert_held(&ipc->rx_lock);
362 ipc->rx.size = reply ? reply->size : 0;
363 ipc->rx_completed = false;
365 reinit_completion(&ipc->done_completion);
366 reinit_completion(&ipc->busy_completion);
369 static void avs_dsp_send_tx(struct avs_dev *adev, struct avs_ipc_msg *tx, bool read_fwregs)
371 const struct avs_spec *const spec = adev->spec;
375 tx->header |= spec->hipc->req_busy_mask;
377 sts = snd_hdac_adsp_readl(adev, AVS_FW_REG_STATUS(adev));
378 lec = snd_hdac_adsp_readl(adev, AVS_FW_REG_ERROR(adev));
381 trace_avs_request(tx, sts, lec);
384 memcpy_toio(avs_downlink_addr(adev), tx->data, tx->size);
385 snd_hdac_adsp_writel(adev, spec->hipc->req_ext_offset, tx->header >> 32);
386 snd_hdac_adsp_writel(adev, spec->hipc->req_offset, tx->header & UINT_MAX);
389 static int avs_dsp_do_send_msg(struct avs_dev *adev, struct avs_ipc_msg *request,
390 struct avs_ipc_msg *reply, int timeout, const char *name)
392 struct avs_ipc *ipc = adev->ipc;
398 mutex_lock(&ipc->msg_mutex);
400 spin_lock(&ipc->rx_lock);
401 avs_ipc_msg_init(ipc, reply);
402 avs_dsp_send_tx(adev, request, true);
403 spin_unlock(&ipc->rx_lock);
405 ret = avs_ipc_wait_busy_completion(ipc, timeout);
407 if (ret == -ETIMEDOUT) {
408 union avs_notify_msg msg = AVS_NOTIFICATION(EXCEPTION_CAUGHT);
410 /* Same treatment as on exception, just stack_dump=0. */
411 avs_dsp_exception_caught(adev, &msg);
416 ret = ipc->rx.rsp.status;
418 * If IPC channel is blocked e.g.: due to ongoing recovery,
419 * -EPERM error code is expected and thus it's not an actual error.
421 * Unsupported IPCs are of no harm either.
423 if (ret == -EPERM || ret == AVS_IPC_NOT_SUPPORTED)
424 dev_dbg(adev->dev, "%s (0x%08x 0x%08x) failed: %d\n",
425 name, request->glb.primary, request->glb.ext.val, ret);
427 dev_err(adev->dev, "%s (0x%08x 0x%08x) failed: %d\n",
428 name, request->glb.primary, request->glb.ext.val, ret);
431 reply->header = ipc->rx.header;
432 reply->size = ipc->rx.size;
433 if (reply->data && ipc->rx.size)
434 memcpy(reply->data, ipc->rx.data, reply->size);
438 mutex_unlock(&ipc->msg_mutex);
442 static int avs_dsp_send_msg_sequence(struct avs_dev *adev, struct avs_ipc_msg *request,
443 struct avs_ipc_msg *reply, int timeout, bool wake_d0i0,
444 bool schedule_d0ix, const char *name)
448 trace_avs_d0ix("wake", wake_d0i0, request->header);
450 ret = avs_dsp_wake_d0i0(adev, request);
455 ret = avs_dsp_do_send_msg(adev, request, reply, timeout, name);
459 trace_avs_d0ix("schedule", schedule_d0ix, request->header);
461 avs_dsp_schedule_d0ix(adev, request);
466 int avs_dsp_send_msg_timeout(struct avs_dev *adev, struct avs_ipc_msg *request,
467 struct avs_ipc_msg *reply, int timeout, const char *name)
469 bool wake_d0i0 = avs_dsp_op(adev, d0ix_toggle, request, true);
470 bool schedule_d0ix = avs_dsp_op(adev, d0ix_toggle, request, false);
472 return avs_dsp_send_msg_sequence(adev, request, reply, timeout, wake_d0i0, schedule_d0ix,
476 int avs_dsp_send_msg(struct avs_dev *adev, struct avs_ipc_msg *request,
477 struct avs_ipc_msg *reply, const char *name)
479 return avs_dsp_send_msg_timeout(adev, request, reply, adev->ipc->default_timeout_ms, name);
482 int avs_dsp_send_pm_msg_timeout(struct avs_dev *adev, struct avs_ipc_msg *request,
483 struct avs_ipc_msg *reply, int timeout, bool wake_d0i0,
486 return avs_dsp_send_msg_sequence(adev, request, reply, timeout, wake_d0i0, false, name);
489 int avs_dsp_send_pm_msg(struct avs_dev *adev, struct avs_ipc_msg *request,
490 struct avs_ipc_msg *reply, bool wake_d0i0, const char *name)
492 return avs_dsp_send_pm_msg_timeout(adev, request, reply, adev->ipc->default_timeout_ms,
496 static int avs_dsp_do_send_rom_msg(struct avs_dev *adev, struct avs_ipc_msg *request, int timeout,
499 struct avs_ipc *ipc = adev->ipc;
502 mutex_lock(&ipc->msg_mutex);
504 spin_lock(&ipc->rx_lock);
505 avs_ipc_msg_init(ipc, NULL);
507 * with hw still stalled, memory windows may not be
508 * configured properly so avoid accessing SRAM
510 avs_dsp_send_tx(adev, request, false);
511 spin_unlock(&ipc->rx_lock);
513 /* ROM messages must be sent before main core is unstalled */
514 ret = avs_dsp_op(adev, stall, AVS_MAIN_CORE_MASK, false);
516 ret = wait_for_completion_timeout(&ipc->done_completion, msecs_to_jiffies(timeout));
517 ret = ret ? 0 : -ETIMEDOUT;
520 dev_err(adev->dev, "%s (0x%08x 0x%08x) failed: %d\n",
521 name, request->glb.primary, request->glb.ext.val, ret);
523 mutex_unlock(&ipc->msg_mutex);
528 int avs_dsp_send_rom_msg_timeout(struct avs_dev *adev, struct avs_ipc_msg *request, int timeout,
531 return avs_dsp_do_send_rom_msg(adev, request, timeout, name);
534 int avs_dsp_send_rom_msg(struct avs_dev *adev, struct avs_ipc_msg *request, const char *name)
536 return avs_dsp_send_rom_msg_timeout(adev, request, adev->ipc->default_timeout_ms, name);
539 void avs_dsp_interrupt_control(struct avs_dev *adev, bool enable)
541 const struct avs_spec *const spec = adev->spec;
545 * No particular bit setting order. All of these are required
546 * to have a functional SW <-> FW communication.
548 value = enable ? AVS_ADSP_ADSPIC_IPC : 0;
549 snd_hdac_adsp_updatel(adev, AVS_ADSP_REG_ADSPIC, AVS_ADSP_ADSPIC_IPC, value);
551 mask = AVS_ADSP_HIPCCTL_DONE | AVS_ADSP_HIPCCTL_BUSY;
552 value = enable ? mask : 0;
553 snd_hdac_adsp_updatel(adev, spec->hipc->ctl_offset, mask, value);
556 int avs_ipc_init(struct avs_ipc *ipc, struct device *dev)
558 ipc->rx.data = devm_kzalloc(dev, AVS_MAILBOX_SIZE, GFP_KERNEL);
564 ipc->default_timeout_ms = AVS_IPC_TIMEOUT_MS;
565 INIT_WORK(&ipc->recovery_work, avs_dsp_recovery_work);
566 INIT_DELAYED_WORK(&ipc->d0ix_work, avs_dsp_d0ix_work);
567 init_completion(&ipc->done_completion);
568 init_completion(&ipc->busy_completion);
569 spin_lock_init(&ipc->rx_lock);
570 mutex_init(&ipc->msg_mutex);
575 void avs_ipc_block(struct avs_ipc *ipc)
578 cancel_work_sync(&ipc->recovery_work);
579 cancel_delayed_work_sync(&ipc->d0ix_work);
580 ipc->in_d0ix = false;