1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) 2 // 3 // Copyright(c) 2022 Intel Corporation. All rights reserved. 4 // 5 // Authors: Ranjani Sridharan <ranjani.sridharan@linux.intel.com> 6 // 7 8 /* 9 * Hardware interface for audio DSP on Meteorlake. 10 */ 11 12 #include <linux/firmware.h> 13 #include <sound/sof/ipc4/header.h> 14 #include <trace/events/sof_intel.h> 15 #include "../ipc4-priv.h" 16 #include "../ops.h" 17 #include "hda.h" 18 #include "hda-ipc.h" 19 #include "../sof-audio.h" 20 #include "mtl.h" 21 22 static const struct snd_sof_debugfs_map mtl_dsp_debugfs[] = { 23 {"hda", HDA_DSP_HDA_BAR, 0, 0x4000, SOF_DEBUGFS_ACCESS_ALWAYS}, 24 {"pp", HDA_DSP_PP_BAR, 0, 0x1000, SOF_DEBUGFS_ACCESS_ALWAYS}, 25 {"dsp", HDA_DSP_BAR, 0, 0x10000, SOF_DEBUGFS_ACCESS_ALWAYS}, 26 }; 27 28 static void mtl_ipc_host_done(struct snd_sof_dev *sdev) 29 { 30 /* 31 * clear busy interrupt to tell dsp controller this interrupt has been accepted, 32 * not trigger it again 33 */ 34 snd_sof_dsp_update_bits_forced(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXTDR, 35 MTL_DSP_REG_HFIPCXTDR_BUSY, MTL_DSP_REG_HFIPCXTDR_BUSY); 36 /* 37 * clear busy bit to ack dsp the msg has been processed and send reply msg to dsp 38 */ 39 snd_sof_dsp_update_bits_forced(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXTDA, 40 MTL_DSP_REG_HFIPCXTDA_BUSY, 0); 41 } 42 43 static void mtl_ipc_dsp_done(struct snd_sof_dev *sdev) 44 { 45 /* 46 * set DONE bit - tell DSP we have received the reply msg from DSP, and processed it, 47 * don't send more reply to host 48 */ 49 snd_sof_dsp_update_bits_forced(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXIDA, 50 MTL_DSP_REG_HFIPCXIDA_DONE, MTL_DSP_REG_HFIPCXIDA_DONE); 51 52 /* unmask Done interrupt */ 53 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXCTL, 54 MTL_DSP_REG_HFIPCXCTL_DONE, MTL_DSP_REG_HFIPCXCTL_DONE); 55 } 56 57 /* Check if an IPC IRQ occurred */ 58 static bool mtl_dsp_check_ipc_irq(struct snd_sof_dev *sdev) 59 { 60 u32 irq_status; 61 u32 hfintipptr; 62 63 /* read Interrupt IP Pointer */ 64 hfintipptr = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_HFINTIPPTR) & MTL_HFINTIPPTR_PTR_MASK; 65 irq_status = snd_sof_dsp_read(sdev, HDA_DSP_BAR, hfintipptr + MTL_DSP_IRQSTS); 66 67 trace_sof_intel_hda_irq_ipc_check(sdev, irq_status); 68 69 if (irq_status != U32_MAX && (irq_status & MTL_DSP_IRQSTS_IPC)) 70 return true; 71 72 return false; 73 } 74 75 /* Check if an SDW IRQ occurred */ 76 static bool mtl_dsp_check_sdw_irq(struct snd_sof_dev *sdev) 77 { 78 u32 irq_status; 79 u32 hfintipptr; 80 81 /* read Interrupt IP Pointer */ 82 hfintipptr = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_HFINTIPPTR) & MTL_HFINTIPPTR_PTR_MASK; 83 irq_status = snd_sof_dsp_read(sdev, HDA_DSP_BAR, hfintipptr + MTL_DSP_IRQSTS); 84 85 if (irq_status != U32_MAX && (irq_status & MTL_DSP_IRQSTS_SDW)) 86 return true; 87 88 return false; 89 } 90 91 static int mtl_ipc_send_msg(struct snd_sof_dev *sdev, struct snd_sof_ipc_msg *msg) 92 { 93 struct sof_intel_hda_dev *hdev = sdev->pdata->hw_pdata; 94 struct sof_ipc4_msg *msg_data = msg->msg_data; 95 96 if (hda_ipc4_tx_is_busy(sdev)) { 97 hdev->delayed_ipc_tx_msg = msg; 98 return 0; 99 } 100 101 hdev->delayed_ipc_tx_msg = NULL; 102 103 /* send the message via mailbox */ 104 if (msg_data->data_size) 105 sof_mailbox_write(sdev, sdev->host_box.offset, msg_data->data_ptr, 106 msg_data->data_size); 107 108 snd_sof_dsp_write(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXIDDY, 109 msg_data->extension); 110 snd_sof_dsp_write(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXIDR, 111 msg_data->primary | MTL_DSP_REG_HFIPCXIDR_BUSY); 112 113 hda_dsp_ipc4_schedule_d0i3_work(hdev, msg); 114 115 return 0; 116 } 117 118 static void mtl_enable_ipc_interrupts(struct snd_sof_dev *sdev) 119 { 120 struct sof_intel_hda_dev *hda = sdev->pdata->hw_pdata; 121 const struct sof_intel_dsp_desc *chip = hda->desc; 122 123 /* enable IPC DONE and BUSY interrupts */ 124 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, chip->ipc_ctl, 125 MTL_DSP_REG_HFIPCXCTL_BUSY | MTL_DSP_REG_HFIPCXCTL_DONE, 126 MTL_DSP_REG_HFIPCXCTL_BUSY | MTL_DSP_REG_HFIPCXCTL_DONE); 127 } 128 129 static void mtl_disable_ipc_interrupts(struct snd_sof_dev *sdev) 130 { 131 struct sof_intel_hda_dev *hda = sdev->pdata->hw_pdata; 132 const struct sof_intel_dsp_desc *chip = hda->desc; 133 134 /* disable IPC DONE and BUSY interrupts */ 135 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, chip->ipc_ctl, 136 MTL_DSP_REG_HFIPCXCTL_BUSY | MTL_DSP_REG_HFIPCXCTL_DONE, 0); 137 } 138 139 static void mtl_enable_sdw_irq(struct snd_sof_dev *sdev, bool enable) 140 { 141 u32 hipcie; 142 u32 mask; 143 u32 val; 144 int ret; 145 146 /* Enable/Disable SoundWire interrupt */ 147 mask = MTL_DSP_REG_HfSNDWIE_IE_MASK; 148 if (enable) 149 val = mask; 150 else 151 val = 0; 152 153 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, MTL_DSP_REG_HfSNDWIE, mask, val); 154 155 /* check if operation was successful */ 156 ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR, MTL_DSP_REG_HfSNDWIE, hipcie, 157 (hipcie & mask) == val, 158 HDA_DSP_REG_POLL_INTERVAL_US, HDA_DSP_RESET_TIMEOUT_US); 159 if (ret < 0) 160 dev_err(sdev->dev, "failed to set SoundWire IPC interrupt %s\n", 161 enable ? "enable" : "disable"); 162 } 163 164 static int mtl_enable_interrupts(struct snd_sof_dev *sdev, bool enable) 165 { 166 u32 hfintipptr; 167 u32 irqinten; 168 u32 hipcie; 169 u32 mask; 170 u32 val; 171 int ret; 172 173 /* read Interrupt IP Pointer */ 174 hfintipptr = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_HFINTIPPTR) & MTL_HFINTIPPTR_PTR_MASK; 175 176 /* Enable/Disable Host IPC and SOUNDWIRE */ 177 mask = MTL_IRQ_INTEN_L_HOST_IPC_MASK | MTL_IRQ_INTEN_L_SOUNDWIRE_MASK; 178 if (enable) 179 val = mask; 180 else 181 val = 0; 182 183 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, hfintipptr, mask, val); 184 185 /* check if operation was successful */ 186 ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR, hfintipptr, irqinten, 187 (irqinten & mask) == val, 188 HDA_DSP_REG_POLL_INTERVAL_US, HDA_DSP_RESET_TIMEOUT_US); 189 if (ret < 0) { 190 dev_err(sdev->dev, "failed to %s Host IPC and/or SOUNDWIRE\n", 191 enable ? "enable" : "disable"); 192 return ret; 193 } 194 195 /* Enable/Disable Host IPC interrupt*/ 196 mask = MTL_DSP_REG_HfHIPCIE_IE_MASK; 197 if (enable) 198 val = mask; 199 else 200 val = 0; 201 202 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, MTL_DSP_REG_HfHIPCIE, mask, val); 203 204 /* check if operation was successful */ 205 ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR, MTL_DSP_REG_HfHIPCIE, hipcie, 206 (hipcie & mask) == val, 207 HDA_DSP_REG_POLL_INTERVAL_US, HDA_DSP_RESET_TIMEOUT_US); 208 if (ret < 0) { 209 dev_err(sdev->dev, "failed to set Host IPC interrupt %s\n", 210 enable ? "enable" : "disable"); 211 return ret; 212 } 213 214 return ret; 215 } 216 217 /* pre fw run operations */ 218 static int mtl_dsp_pre_fw_run(struct snd_sof_dev *sdev) 219 { 220 u32 dsphfpwrsts; 221 u32 dsphfdsscs; 222 u32 cpa; 223 u32 pgs; 224 int ret; 225 226 /* Set the DSP subsystem power on */ 227 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, MTL_HFDSSCS, 228 MTL_HFDSSCS_SPA_MASK, MTL_HFDSSCS_SPA_MASK); 229 230 /* Wait for unstable CPA read (1 then 0 then 1) just after setting SPA bit */ 231 usleep_range(1000, 1010); 232 233 /* poll with timeout to check if operation successful */ 234 cpa = MTL_HFDSSCS_CPA_MASK; 235 ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR, MTL_HFDSSCS, dsphfdsscs, 236 (dsphfdsscs & cpa) == cpa, HDA_DSP_REG_POLL_INTERVAL_US, 237 HDA_DSP_RESET_TIMEOUT_US); 238 if (ret < 0) { 239 dev_err(sdev->dev, "failed to enable DSP subsystem\n"); 240 return ret; 241 } 242 243 /* Power up gated-DSP-0 domain in order to access the DSP shim register block. */ 244 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, MTL_HFPWRCTL, 245 MTL_HFPWRCTL_WPDSPHPXPG, MTL_HFPWRCTL_WPDSPHPXPG); 246 247 usleep_range(1000, 1010); 248 249 /* poll with timeout to check if operation successful */ 250 pgs = MTL_HFPWRSTS_DSPHPXPGS_MASK; 251 ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR, MTL_HFPWRSTS, dsphfpwrsts, 252 (dsphfpwrsts & pgs) == pgs, 253 HDA_DSP_REG_POLL_INTERVAL_US, 254 HDA_DSP_RESET_TIMEOUT_US); 255 if (ret < 0) 256 dev_err(sdev->dev, "failed to power up gated DSP domain\n"); 257 258 /* make sure SoundWire is not power-gated */ 259 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, MTL_HFPWRCTL, 260 MTL_HfPWRCTL_WPIOXPG(1), MTL_HfPWRCTL_WPIOXPG(1)); 261 return ret; 262 } 263 264 static int mtl_dsp_post_fw_run(struct snd_sof_dev *sdev) 265 { 266 int ret; 267 268 if (sdev->first_boot) { 269 struct sof_intel_hda_dev *hdev = sdev->pdata->hw_pdata; 270 271 ret = hda_sdw_startup(sdev); 272 if (ret < 0) { 273 dev_err(sdev->dev, "could not startup SoundWire links\n"); 274 return ret; 275 } 276 277 /* Check if IMR boot is usable */ 278 if (!sof_debug_check_flag(SOF_DBG_IGNORE_D3_PERSISTENT)) 279 hdev->imrboot_supported = true; 280 } 281 282 hda_sdw_int_enable(sdev, true); 283 284 /* enable DMI L1 */ 285 snd_sof_dsp_update_bits(sdev, HDA_DSP_HDA_BAR, MTL_EM2, MTL_EM2_L1SEN, MTL_EM2_L1SEN); 286 return 0; 287 } 288 289 static void mtl_dsp_dump(struct snd_sof_dev *sdev, u32 flags) 290 { 291 char *level = (flags & SOF_DBG_DUMP_OPTIONAL) ? KERN_DEBUG : KERN_ERR; 292 u32 romdbgsts; 293 u32 romdbgerr; 294 u32 fwsts; 295 u32 fwlec; 296 297 fwsts = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_ROM_STS); 298 fwlec = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_ROM_ERROR); 299 romdbgsts = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFFLGPXQWY); 300 romdbgerr = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFFLGPXQWY_ERROR); 301 302 dev_err(sdev->dev, "ROM status: %#x, ROM error: %#x\n", fwsts, fwlec); 303 dev_err(sdev->dev, "ROM debug status: %#x, ROM debug error: %#x\n", romdbgsts, 304 romdbgerr); 305 romdbgsts = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFFLGPXQWY + 0x8 * 3); 306 dev_printk(level, sdev->dev, "ROM feature bit%s enabled\n", 307 romdbgsts & BIT(24) ? "" : " not"); 308 } 309 310 static bool mtl_dsp_primary_core_is_enabled(struct snd_sof_dev *sdev) 311 { 312 int val; 313 314 val = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP2CXCTL_PRIMARY_CORE); 315 if (val != U32_MAX && val & MTL_DSP2CXCTL_PRIMARY_CORE_CPA_MASK) 316 return true; 317 318 return false; 319 } 320 321 static int mtl_dsp_core_power_up(struct snd_sof_dev *sdev, int core) 322 { 323 unsigned int cpa; 324 u32 dspcxctl; 325 int ret; 326 327 /* Only the primary core can be powered up by the host */ 328 if (core != SOF_DSP_PRIMARY_CORE || mtl_dsp_primary_core_is_enabled(sdev)) 329 return 0; 330 331 /* Program the owner of the IP & shim registers (10: Host CPU) */ 332 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, MTL_DSP2CXCTL_PRIMARY_CORE, 333 MTL_DSP2CXCTL_PRIMARY_CORE_OSEL, 334 0x2 << MTL_DSP2CXCTL_PRIMARY_CORE_OSEL_SHIFT); 335 336 /* enable SPA bit */ 337 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, MTL_DSP2CXCTL_PRIMARY_CORE, 338 MTL_DSP2CXCTL_PRIMARY_CORE_SPA_MASK, 339 MTL_DSP2CXCTL_PRIMARY_CORE_SPA_MASK); 340 341 /* Wait for unstable CPA read (1 then 0 then 1) just after setting SPA bit */ 342 usleep_range(1000, 1010); 343 344 /* poll with timeout to check if operation successful */ 345 cpa = MTL_DSP2CXCTL_PRIMARY_CORE_CPA_MASK; 346 ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR, MTL_DSP2CXCTL_PRIMARY_CORE, dspcxctl, 347 (dspcxctl & cpa) == cpa, HDA_DSP_REG_POLL_INTERVAL_US, 348 HDA_DSP_RESET_TIMEOUT_US); 349 if (ret < 0) 350 dev_err(sdev->dev, "%s: timeout on MTL_DSP2CXCTL_PRIMARY_CORE read\n", 351 __func__); 352 353 return ret; 354 } 355 356 static int mtl_dsp_core_power_down(struct snd_sof_dev *sdev, int core) 357 { 358 u32 dspcxctl; 359 int ret; 360 361 /* Only the primary core can be powered down by the host */ 362 if (core != SOF_DSP_PRIMARY_CORE || !mtl_dsp_primary_core_is_enabled(sdev)) 363 return 0; 364 365 /* disable SPA bit */ 366 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, MTL_DSP2CXCTL_PRIMARY_CORE, 367 MTL_DSP2CXCTL_PRIMARY_CORE_SPA_MASK, 0); 368 369 /* Wait for unstable CPA read (0 then 1 then 0) just after setting SPA bit */ 370 usleep_range(1000, 1010); 371 372 ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR, MTL_DSP2CXCTL_PRIMARY_CORE, dspcxctl, 373 !(dspcxctl & MTL_DSP2CXCTL_PRIMARY_CORE_CPA_MASK), 374 HDA_DSP_REG_POLL_INTERVAL_US, 375 HDA_DSP_PD_TIMEOUT * USEC_PER_MSEC); 376 if (ret < 0) 377 dev_err(sdev->dev, "failed to power down primary core\n"); 378 379 return ret; 380 } 381 382 static int mtl_power_down_dsp(struct snd_sof_dev *sdev) 383 { 384 u32 dsphfdsscs, cpa; 385 int ret; 386 387 /* first power down core */ 388 ret = mtl_dsp_core_power_down(sdev, SOF_DSP_PRIMARY_CORE); 389 if (ret) { 390 dev_err(sdev->dev, "mtl dsp power down error, %d\n", ret); 391 return ret; 392 } 393 394 /* Set the DSP subsystem power down */ 395 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, MTL_HFDSSCS, 396 MTL_HFDSSCS_SPA_MASK, 0); 397 398 /* Wait for unstable CPA read (0 then 1 then 0) just after setting SPA bit */ 399 usleep_range(1000, 1010); 400 401 /* poll with timeout to check if operation successful */ 402 cpa = MTL_HFDSSCS_CPA_MASK; 403 dsphfdsscs = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_HFDSSCS); 404 return snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR, MTL_HFDSSCS, dsphfdsscs, 405 (dsphfdsscs & cpa) == 0, HDA_DSP_REG_POLL_INTERVAL_US, 406 HDA_DSP_RESET_TIMEOUT_US); 407 } 408 409 static int mtl_dsp_cl_init(struct snd_sof_dev *sdev, int stream_tag, bool imr_boot) 410 { 411 struct sof_intel_hda_dev *hda = sdev->pdata->hw_pdata; 412 const struct sof_intel_dsp_desc *chip = hda->desc; 413 unsigned int status; 414 u32 ipc_hdr; 415 int ret; 416 417 /* step 1: purge FW request */ 418 ipc_hdr = chip->ipc_req_mask | HDA_DSP_ROM_IPC_CONTROL; 419 if (!imr_boot) 420 ipc_hdr |= HDA_DSP_ROM_IPC_PURGE_FW | ((stream_tag - 1) << 9); 421 422 snd_sof_dsp_write(sdev, HDA_DSP_BAR, chip->ipc_req, ipc_hdr); 423 424 /* step 2: power up primary core */ 425 ret = mtl_dsp_core_power_up(sdev, SOF_DSP_PRIMARY_CORE); 426 if (ret < 0) { 427 if (hda->boot_iteration == HDA_FW_BOOT_ATTEMPTS) 428 dev_err(sdev->dev, "dsp core 0/1 power up failed\n"); 429 goto err; 430 } 431 432 dev_dbg(sdev->dev, "Primary core power up successful\n"); 433 434 /* step 3: wait for IPC DONE bit from ROM */ 435 ret = snd_sof_dsp_read_poll_timeout(sdev, HDA_DSP_BAR, chip->ipc_ack, status, 436 ((status & chip->ipc_ack_mask) == chip->ipc_ack_mask), 437 HDA_DSP_REG_POLL_INTERVAL_US, MTL_DSP_PURGE_TIMEOUT_US); 438 if (ret < 0) { 439 if (hda->boot_iteration == HDA_FW_BOOT_ATTEMPTS) 440 dev_err(sdev->dev, "timeout waiting for purge IPC done\n"); 441 goto err; 442 } 443 444 /* set DONE bit to clear the reply IPC message */ 445 snd_sof_dsp_update_bits_forced(sdev, HDA_DSP_BAR, chip->ipc_ack, chip->ipc_ack_mask, 446 chip->ipc_ack_mask); 447 448 /* step 4: enable interrupts */ 449 ret = mtl_enable_interrupts(sdev, true); 450 if (ret < 0) { 451 if (hda->boot_iteration == HDA_FW_BOOT_ATTEMPTS) 452 dev_err(sdev->dev, "%s: failed to enable interrupts\n", __func__); 453 goto err; 454 } 455 456 mtl_enable_ipc_interrupts(sdev); 457 458 /* 459 * ACE workaround: don't wait for ROM INIT. 460 * The platform cannot catch ROM_INIT_DONE because of a very short 461 * timing window. Follow the recommendations and skip this part. 462 */ 463 464 return 0; 465 466 err: 467 snd_sof_dsp_dbg_dump(sdev, "MTL DSP init fail", 0); 468 mtl_dsp_core_power_down(sdev, SOF_DSP_PRIMARY_CORE); 469 return ret; 470 } 471 472 static irqreturn_t mtl_ipc_irq_thread(int irq, void *context) 473 { 474 struct sof_ipc4_msg notification_data = {{ 0 }}; 475 struct snd_sof_dev *sdev = context; 476 bool ack_received = false; 477 bool ipc_irq = false; 478 u32 hipcida; 479 u32 hipctdr; 480 481 hipcida = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXIDA); 482 hipctdr = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXTDR); 483 484 /* reply message from DSP */ 485 if (hipcida & MTL_DSP_REG_HFIPCXIDA_DONE) { 486 /* DSP received the message */ 487 snd_sof_dsp_update_bits(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXCTL, 488 MTL_DSP_REG_HFIPCXCTL_DONE, 0); 489 490 mtl_ipc_dsp_done(sdev); 491 492 ipc_irq = true; 493 ack_received = true; 494 } 495 496 if (hipctdr & MTL_DSP_REG_HFIPCXTDR_BUSY) { 497 /* Message from DSP (reply or notification) */ 498 u32 extension = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXTDDY); 499 u32 primary = hipctdr & MTL_DSP_REG_HFIPCXTDR_MSG_MASK; 500 501 /* 502 * ACE fw sends a new fw ipc message to host to 503 * notify the status of the last host ipc message 504 */ 505 if (primary & SOF_IPC4_MSG_DIR_MASK) { 506 /* Reply received */ 507 if (likely(sdev->fw_state == SOF_FW_BOOT_COMPLETE)) { 508 struct sof_ipc4_msg *data = sdev->ipc->msg.reply_data; 509 510 data->primary = primary; 511 data->extension = extension; 512 513 spin_lock_irq(&sdev->ipc_lock); 514 515 snd_sof_ipc_get_reply(sdev); 516 mtl_ipc_host_done(sdev); 517 snd_sof_ipc_reply(sdev, data->primary); 518 519 spin_unlock_irq(&sdev->ipc_lock); 520 } else { 521 dev_dbg_ratelimited(sdev->dev, 522 "IPC reply before FW_READY: %#x|%#x\n", 523 primary, extension); 524 } 525 } else { 526 /* Notification received */ 527 notification_data.primary = primary; 528 notification_data.extension = extension; 529 530 sdev->ipc->msg.rx_data = ¬ification_data; 531 snd_sof_ipc_msgs_rx(sdev); 532 sdev->ipc->msg.rx_data = NULL; 533 534 mtl_ipc_host_done(sdev); 535 } 536 537 ipc_irq = true; 538 } 539 540 if (!ipc_irq) { 541 /* This interrupt is not shared so no need to return IRQ_NONE. */ 542 dev_dbg_ratelimited(sdev->dev, "nothing to do in IPC IRQ thread\n"); 543 } 544 545 if (ack_received) { 546 struct sof_intel_hda_dev *hdev = sdev->pdata->hw_pdata; 547 548 if (hdev->delayed_ipc_tx_msg) 549 mtl_ipc_send_msg(sdev, hdev->delayed_ipc_tx_msg); 550 } 551 552 return IRQ_HANDLED; 553 } 554 555 static int mtl_dsp_ipc_get_mailbox_offset(struct snd_sof_dev *sdev) 556 { 557 return MTL_DSP_MBOX_UPLINK_OFFSET; 558 } 559 560 static int mtl_dsp_ipc_get_window_offset(struct snd_sof_dev *sdev, u32 id) 561 { 562 return MTL_SRAM_WINDOW_OFFSET(id); 563 } 564 565 static void mtl_ipc_dump(struct snd_sof_dev *sdev) 566 { 567 u32 hipcidr, hipcidd, hipcida, hipctdr, hipctdd, hipctda, hipcctl; 568 569 hipcidr = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXIDR); 570 hipcidd = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXIDDY); 571 hipcida = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXIDA); 572 hipctdr = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXTDR); 573 hipctdd = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXTDDY); 574 hipctda = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXTDA); 575 hipcctl = snd_sof_dsp_read(sdev, HDA_DSP_BAR, MTL_DSP_REG_HFIPCXCTL); 576 577 dev_err(sdev->dev, 578 "Host IPC initiator: %#x|%#x|%#x, target: %#x|%#x|%#x, ctl: %#x\n", 579 hipcidr, hipcidd, hipcida, hipctdr, hipctdd, hipctda, hipcctl); 580 } 581 582 static int mtl_dsp_disable_interrupts(struct snd_sof_dev *sdev) 583 { 584 mtl_enable_sdw_irq(sdev, false); 585 mtl_disable_ipc_interrupts(sdev); 586 return mtl_enable_interrupts(sdev, false); 587 } 588 589 static u64 mtl_dsp_get_stream_hda_link_position(struct snd_sof_dev *sdev, 590 struct snd_soc_component *component, 591 struct snd_pcm_substream *substream) 592 { 593 struct hdac_stream *hstream = substream->runtime->private_data; 594 u32 llp_l, llp_u; 595 596 llp_l = snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, MTL_PPLCLLPL(hstream->index)); 597 llp_u = snd_sof_dsp_read(sdev, HDA_DSP_HDA_BAR, MTL_PPLCLLPU(hstream->index)); 598 return ((u64)llp_u << 32) | llp_l; 599 } 600 601 /* Meteorlake ops */ 602 struct snd_sof_dsp_ops sof_mtl_ops; 603 EXPORT_SYMBOL_NS(sof_mtl_ops, SND_SOC_SOF_INTEL_HDA_COMMON); 604 605 int sof_mtl_ops_init(struct snd_sof_dev *sdev) 606 { 607 struct sof_ipc4_fw_data *ipc4_data; 608 609 /* common defaults */ 610 memcpy(&sof_mtl_ops, &sof_hda_common_ops, sizeof(struct snd_sof_dsp_ops)); 611 612 /* shutdown */ 613 sof_mtl_ops.shutdown = hda_dsp_shutdown; 614 615 /* doorbell */ 616 sof_mtl_ops.irq_thread = mtl_ipc_irq_thread; 617 618 /* ipc */ 619 sof_mtl_ops.send_msg = mtl_ipc_send_msg; 620 sof_mtl_ops.get_mailbox_offset = mtl_dsp_ipc_get_mailbox_offset; 621 sof_mtl_ops.get_window_offset = mtl_dsp_ipc_get_window_offset; 622 623 /* debug */ 624 sof_mtl_ops.debug_map = mtl_dsp_debugfs; 625 sof_mtl_ops.debug_map_count = ARRAY_SIZE(mtl_dsp_debugfs); 626 sof_mtl_ops.dbg_dump = mtl_dsp_dump; 627 sof_mtl_ops.ipc_dump = mtl_ipc_dump; 628 629 /* pre/post fw run */ 630 sof_mtl_ops.pre_fw_run = mtl_dsp_pre_fw_run; 631 sof_mtl_ops.post_fw_run = mtl_dsp_post_fw_run; 632 633 /* parse platform specific extended manifest */ 634 sof_mtl_ops.parse_platform_ext_manifest = NULL; 635 636 /* dsp core get/put */ 637 /* TODO: add core_get and core_put */ 638 639 sof_mtl_ops.get_stream_position = mtl_dsp_get_stream_hda_link_position; 640 641 sdev->private = devm_kzalloc(sdev->dev, sizeof(struct sof_ipc4_fw_data), GFP_KERNEL); 642 if (!sdev->private) 643 return -ENOMEM; 644 645 ipc4_data = sdev->private; 646 ipc4_data->manifest_fw_hdr_offset = SOF_MAN4_FW_HDR_OFFSET; 647 648 ipc4_data->mtrace_type = SOF_IPC4_MTRACE_INTEL_CAVS_2; 649 650 /* External library loading support */ 651 ipc4_data->load_library = hda_dsp_ipc4_load_library; 652 653 /* set DAI ops */ 654 hda_set_dai_drv_ops(sdev, &sof_mtl_ops); 655 656 return 0; 657 }; 658 EXPORT_SYMBOL_NS(sof_mtl_ops_init, SND_SOC_SOF_INTEL_HDA_COMMON); 659 660 const struct sof_intel_dsp_desc mtl_chip_info = { 661 .cores_num = 3, 662 .init_core_mask = BIT(0), 663 .host_managed_cores_mask = BIT(0), 664 .ipc_req = MTL_DSP_REG_HFIPCXIDR, 665 .ipc_req_mask = MTL_DSP_REG_HFIPCXIDR_BUSY, 666 .ipc_ack = MTL_DSP_REG_HFIPCXIDA, 667 .ipc_ack_mask = MTL_DSP_REG_HFIPCXIDA_DONE, 668 .ipc_ctl = MTL_DSP_REG_HFIPCXCTL, 669 .rom_status_reg = MTL_DSP_ROM_STS, 670 .rom_init_timeout = 300, 671 .ssp_count = MTL_SSP_COUNT, 672 .ssp_base_offset = CNL_SSP_BASE_OFFSET, 673 .sdw_shim_base = SDW_SHIM_BASE_ACE, 674 .sdw_alh_base = SDW_ALH_BASE_ACE, 675 .d0i3_offset = MTL_HDA_VS_D0I3C, 676 .read_sdw_lcount = hda_sdw_check_lcount_common, 677 .enable_sdw_irq = mtl_enable_sdw_irq, 678 .check_sdw_irq = mtl_dsp_check_sdw_irq, 679 .check_ipc_irq = mtl_dsp_check_ipc_irq, 680 .cl_init = mtl_dsp_cl_init, 681 .power_down_dsp = mtl_power_down_dsp, 682 .disable_interrupts = mtl_dsp_disable_interrupts, 683 .hw_ip_version = SOF_INTEL_ACE_1_0, 684 }; 685 EXPORT_SYMBOL_NS(mtl_chip_info, SND_SOC_SOF_INTEL_HDA_COMMON); 686