1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause) 2 // 3 // This file is provided under a dual BSD/GPLv2 license. When using or 4 // redistributing this file, you may do so under either license. 5 // 6 // Copyright(c) 2018 Intel Corporation. All rights reserved. 7 // 8 // Author: Liam Girdwood <liam.r.girdwood@linux.intel.com> 9 // 10 11 #include "ops.h" 12 #include "sof-priv.h" 13 #include "sof-audio.h" 14 15 static int sof_send_pm_ctx_ipc(struct snd_sof_dev *sdev, int cmd) 16 { 17 struct sof_ipc_pm_ctx pm_ctx; 18 struct sof_ipc_reply reply; 19 20 memset(&pm_ctx, 0, sizeof(pm_ctx)); 21 22 /* configure ctx save ipc message */ 23 pm_ctx.hdr.size = sizeof(pm_ctx); 24 pm_ctx.hdr.cmd = SOF_IPC_GLB_PM_MSG | cmd; 25 26 /* send ctx save ipc to dsp */ 27 return sof_ipc_tx_message(sdev->ipc, pm_ctx.hdr.cmd, &pm_ctx, 28 sizeof(pm_ctx), &reply, sizeof(reply)); 29 } 30 31 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_ENABLE_DEBUGFS_CACHE) 32 static void sof_cache_debugfs(struct snd_sof_dev *sdev) 33 { 34 struct snd_sof_dfsentry *dfse; 35 36 list_for_each_entry(dfse, &sdev->dfsentry_list, list) { 37 38 /* nothing to do if debugfs buffer is not IO mem */ 39 if (dfse->type == SOF_DFSENTRY_TYPE_BUF) 40 continue; 41 42 /* cache memory that is only accessible in D0 */ 43 if (dfse->access_type == SOF_DEBUGFS_ACCESS_D0_ONLY) 44 memcpy_fromio(dfse->cache_buf, dfse->io_mem, 45 dfse->size); 46 } 47 } 48 #endif 49 50 static int sof_resume(struct device *dev, bool runtime_resume) 51 { 52 struct snd_sof_dev *sdev = dev_get_drvdata(dev); 53 int ret; 54 55 /* do nothing if dsp resume callbacks are not set */ 56 if (!sof_ops(sdev)->resume || !sof_ops(sdev)->runtime_resume) 57 return 0; 58 59 /* 60 * if the runtime_resume flag is set, call the runtime_resume routine 61 * or else call the system resume routine 62 */ 63 if (runtime_resume) 64 ret = snd_sof_dsp_runtime_resume(sdev); 65 else 66 ret = snd_sof_dsp_resume(sdev); 67 if (ret < 0) { 68 dev_err(sdev->dev, 69 "error: failed to power up DSP after resume\n"); 70 return ret; 71 } 72 73 sdev->fw_state = SOF_FW_BOOT_PREPARE; 74 75 /* load the firmware */ 76 ret = snd_sof_load_firmware(sdev); 77 if (ret < 0) { 78 dev_err(sdev->dev, 79 "error: failed to load DSP firmware after resume %d\n", 80 ret); 81 return ret; 82 } 83 84 sdev->fw_state = SOF_FW_BOOT_IN_PROGRESS; 85 86 /* 87 * Boot the firmware. The FW boot status will be modified 88 * in snd_sof_run_firmware() depending on the outcome. 89 */ 90 ret = snd_sof_run_firmware(sdev); 91 if (ret < 0) { 92 dev_err(sdev->dev, 93 "error: failed to boot DSP firmware after resume %d\n", 94 ret); 95 return ret; 96 } 97 98 /* resume DMA trace, only need send ipc */ 99 ret = snd_sof_init_trace_ipc(sdev); 100 if (ret < 0) { 101 /* non fatal */ 102 dev_warn(sdev->dev, 103 "warning: failed to init trace after resume %d\n", 104 ret); 105 } 106 107 /* restore pipelines */ 108 ret = sof_restore_pipelines(sdev->dev); 109 if (ret < 0) { 110 dev_err(sdev->dev, 111 "error: failed to restore pipeline after resume %d\n", 112 ret); 113 return ret; 114 } 115 116 /* notify DSP of system resume */ 117 ret = sof_send_pm_ctx_ipc(sdev, SOF_IPC_PM_CTX_RESTORE); 118 if (ret < 0) 119 dev_err(sdev->dev, 120 "error: ctx_restore ipc error during resume %d\n", 121 ret); 122 123 /* initialize default D0 sub-state */ 124 sdev->d0_substate = SOF_DSP_D0I0; 125 126 return ret; 127 } 128 129 static int sof_suspend(struct device *dev, bool runtime_suspend) 130 { 131 struct snd_sof_dev *sdev = dev_get_drvdata(dev); 132 int ret; 133 134 /* do nothing if dsp suspend callback is not set */ 135 if (!sof_ops(sdev)->suspend) 136 return 0; 137 138 if (sdev->fw_state != SOF_FW_BOOT_COMPLETE) 139 goto power_down; 140 141 /* release trace */ 142 snd_sof_release_trace(sdev); 143 144 /* set restore_stream for all streams during system suspend */ 145 if (!runtime_suspend) { 146 ret = sof_set_hw_params_upon_resume(sdev->dev); 147 if (ret < 0) { 148 dev_err(sdev->dev, 149 "error: setting hw_params flag during suspend %d\n", 150 ret); 151 return ret; 152 } 153 } 154 155 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_ENABLE_DEBUGFS_CACHE) 156 /* cache debugfs contents during runtime suspend */ 157 if (runtime_suspend) 158 sof_cache_debugfs(sdev); 159 #endif 160 /* notify DSP of upcoming power down */ 161 ret = sof_send_pm_ctx_ipc(sdev, SOF_IPC_PM_CTX_SAVE); 162 if (ret == -EBUSY || ret == -EAGAIN) { 163 /* 164 * runtime PM has logic to handle -EBUSY/-EAGAIN so 165 * pass these errors up 166 */ 167 dev_err(sdev->dev, 168 "error: ctx_save ipc error during suspend %d\n", 169 ret); 170 return ret; 171 } else if (ret < 0) { 172 /* FW in unexpected state, continue to power down */ 173 dev_warn(sdev->dev, 174 "ctx_save ipc error %d, proceeding with suspend\n", 175 ret); 176 } 177 178 power_down: 179 180 /* return if the DSP was not probed successfully */ 181 if (sdev->fw_state == SOF_FW_BOOT_NOT_STARTED) 182 return 0; 183 184 /* power down all DSP cores */ 185 if (runtime_suspend) 186 ret = snd_sof_dsp_runtime_suspend(sdev); 187 else 188 ret = snd_sof_dsp_suspend(sdev); 189 if (ret < 0) 190 dev_err(sdev->dev, 191 "error: failed to power down DSP during suspend %d\n", 192 ret); 193 194 /* reset FW state */ 195 sdev->fw_state = SOF_FW_BOOT_NOT_STARTED; 196 197 return ret; 198 } 199 200 int snd_sof_runtime_suspend(struct device *dev) 201 { 202 return sof_suspend(dev, true); 203 } 204 EXPORT_SYMBOL(snd_sof_runtime_suspend); 205 206 int snd_sof_runtime_idle(struct device *dev) 207 { 208 struct snd_sof_dev *sdev = dev_get_drvdata(dev); 209 210 return snd_sof_dsp_runtime_idle(sdev); 211 } 212 EXPORT_SYMBOL(snd_sof_runtime_idle); 213 214 int snd_sof_runtime_resume(struct device *dev) 215 { 216 return sof_resume(dev, true); 217 } 218 EXPORT_SYMBOL(snd_sof_runtime_resume); 219 220 int snd_sof_set_d0_substate(struct snd_sof_dev *sdev, 221 enum sof_d0_substate d0_substate) 222 { 223 int ret; 224 225 if (sdev->d0_substate == d0_substate) 226 return 0; 227 228 /* do platform specific set_state */ 229 ret = snd_sof_dsp_set_power_state(sdev, d0_substate); 230 if (ret < 0) 231 return ret; 232 233 /* update dsp D0 sub-state */ 234 sdev->d0_substate = d0_substate; 235 236 return 0; 237 } 238 EXPORT_SYMBOL(snd_sof_set_d0_substate); 239 240 /* 241 * Audio DSP states may transform as below:- 242 * 243 * D0I3 compatible stream 244 * Runtime +---------------------+ opened only, timeout 245 * suspend | +--------------------+ 246 * +------------+ D0(active) | | 247 * | | <---------------+ | 248 * | +--------> | | | 249 * | |Runtime +--^--+---------^--+--+ The last | | 250 * | |resume | | | | opened D0I3 | | 251 * | | | | | | compatible | | 252 * | | resume| | | | stream closed | | 253 * | | from | | D3 | | | | 254 * | | D3 | |suspend | | d0i3 | | 255 * | | | | | |suspend | | 256 * | | | | | | | | 257 * | | | | | | | | 258 * +-v---+-----------+--v-------+ | | +------+----v----+ 259 * | | | +-----------> | 260 * | D3 (suspended) | | | D0I3 +-----+ 261 * | | +--------------+ | | 262 * | | resume from | | | 263 * +-------------------^--------+ d0i3 suspend +----------------+ | 264 * | | 265 * | D3 suspend | 266 * +------------------------------------------------+ 267 * 268 * d0i3_suspend = s0_suspend && D0I3 stream opened, 269 * D3 suspend = !d0i3_suspend, 270 */ 271 272 int snd_sof_resume(struct device *dev) 273 { 274 struct snd_sof_dev *sdev = dev_get_drvdata(dev); 275 int ret; 276 277 if (snd_sof_dsp_d0i3_on_suspend(sdev)) { 278 /* resume from D0I3 */ 279 dev_dbg(sdev->dev, "DSP will exit from D0i3...\n"); 280 ret = snd_sof_set_d0_substate(sdev, SOF_DSP_D0I0); 281 if (ret == -ENOTSUPP) { 282 /* fallback to resume from D3 */ 283 dev_dbg(sdev->dev, "D0i3 not supported, fall back to resume from D3...\n"); 284 goto d3_resume; 285 } else if (ret < 0) { 286 dev_err(sdev->dev, "error: failed to exit from D0I3 %d\n", 287 ret); 288 return ret; 289 } 290 291 /* platform-specific resume from D0i3 */ 292 return snd_sof_dsp_resume(sdev); 293 } 294 295 d3_resume: 296 /* resume from D3 */ 297 return sof_resume(dev, false); 298 } 299 EXPORT_SYMBOL(snd_sof_resume); 300 301 int snd_sof_suspend(struct device *dev) 302 { 303 struct snd_sof_dev *sdev = dev_get_drvdata(dev); 304 int ret; 305 306 if (snd_sof_dsp_d0i3_on_suspend(sdev)) { 307 /* suspend to D0i3 */ 308 dev_dbg(sdev->dev, "DSP is trying to enter D0i3...\n"); 309 ret = snd_sof_set_d0_substate(sdev, SOF_DSP_D0I3); 310 if (ret == -ENOTSUPP) { 311 /* fallback to D3 suspend */ 312 dev_dbg(sdev->dev, "D0i3 not supported, fall back to D3...\n"); 313 goto d3_suspend; 314 } else if (ret < 0) { 315 dev_err(sdev->dev, "error: failed to enter D0I3, %d\n", 316 ret); 317 return ret; 318 } 319 320 /* platform-specific suspend to D0i3 */ 321 return snd_sof_dsp_suspend(sdev); 322 } 323 324 d3_suspend: 325 /* suspend to D3 */ 326 return sof_suspend(dev, false); 327 } 328 EXPORT_SYMBOL(snd_sof_suspend); 329 330 int snd_sof_prepare(struct device *dev) 331 { 332 struct snd_sof_dev *sdev = dev_get_drvdata(dev); 333 334 #if defined(CONFIG_ACPI) 335 sdev->s0_suspend = acpi_target_system_state() == ACPI_STATE_S0; 336 #else 337 /* will suspend to S3 by default */ 338 sdev->s0_suspend = false; 339 #endif 340 341 return 0; 342 } 343 EXPORT_SYMBOL(snd_sof_prepare); 344 345 void snd_sof_complete(struct device *dev) 346 { 347 struct snd_sof_dev *sdev = dev_get_drvdata(dev); 348 349 sdev->s0_suspend = false; 350 } 351 EXPORT_SYMBOL(snd_sof_complete); 352