1 // SPDX-License-Identifier: (GPL-2.0-only 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) 2022 Intel Corporation. All rights reserved. 7 // 8 // Authors: Rander Wang <rander.wang@linux.intel.com> 9 // Peter Ujfalusi <peter.ujfalusi@linux.intel.com> 10 // 11 #include <sound/sof/header.h> 12 #include <sound/sof/ipc4/header.h> 13 #include "sof-priv.h" 14 #include "sof-audio.h" 15 #include "ipc4-priv.h" 16 #include "ops.h" 17 18 #ifdef DEBUG_VERBOSE 19 #define sof_ipc4_dump_payload(sdev, ipc_data, size) \ 20 print_hex_dump_debug("Message payload: ", \ 21 DUMP_PREFIX_OFFSET, \ 22 16, 4, ipc_data, size, false) 23 #else 24 #define sof_ipc4_dump_payload(sdev, ipc_data, size) do { } while (0) 25 #endif 26 27 static const struct sof_ipc4_fw_status { 28 int status; 29 char *msg; 30 } ipc4_status[] = { 31 {0, "The operation was successful"}, 32 {1, "Invalid parameter specified"}, 33 {2, "Unknown message type specified"}, 34 {3, "Not enough space in the IPC reply buffer to complete the request"}, 35 {4, "The system or resource is busy"}, 36 {5, "Replaced ADSP IPC PENDING (unused)"}, 37 {6, "Unknown error while processing the request"}, 38 {7, "Unsupported operation requested"}, 39 {8, "Reserved (ADSP_STAGE_UNINITIALIZED removed)"}, 40 {9, "Specified resource not found"}, 41 {10, "A resource's ID requested to be created is already assigned"}, 42 {11, "Reserved (ADSP_IPC_OUT_OF_MIPS removed)"}, 43 {12, "Required resource is in invalid state"}, 44 {13, "Requested power transition failed to complete"}, 45 {14, "Manifest of the library being loaded is invalid"}, 46 {15, "Requested service or data is unavailable on the target platform"}, 47 {42, "Library target address is out of storage memory range"}, 48 {43, "Reserved"}, 49 {44, "Image verification by CSE failed"}, 50 {100, "General module management error"}, 51 {101, "Module loading failed"}, 52 {102, "Integrity check of the loaded module content failed"}, 53 {103, "Attempt to unload code of the module in use"}, 54 {104, "Other failure of module instance initialization request"}, 55 {105, "Reserved (ADSP_IPC_OUT_OF_MIPS removed)"}, 56 {106, "Reserved (ADSP_IPC_CONFIG_GET_ERROR removed)"}, 57 {107, "Reserved (ADSP_IPC_CONFIG_SET_ERROR removed)"}, 58 {108, "Reserved (ADSP_IPC_LARGE_CONFIG_GET_ERROR removed)"}, 59 {109, "Reserved (ADSP_IPC_LARGE_CONFIG_SET_ERROR removed)"}, 60 {110, "Invalid (out of range) module ID provided"}, 61 {111, "Invalid module instance ID provided"}, 62 {112, "Invalid queue (pin) ID provided"}, 63 {113, "Invalid destination queue (pin) ID provided"}, 64 {114, "Reserved (ADSP_IPC_BIND_UNBIND_DST_SINK_UNSUPPORTED removed)"}, 65 {115, "Reserved (ADSP_IPC_UNLOAD_INST_EXISTS removed)"}, 66 {116, "Invalid target code ID provided"}, 67 {117, "Injection DMA buffer is too small for probing the input pin"}, 68 {118, "Extraction DMA buffer is too small for probing the output pin"}, 69 {120, "Invalid ID of configuration item provided in TLV list"}, 70 {121, "Invalid length of configuration item provided in TLV list"}, 71 {122, "Invalid structure of configuration item provided"}, 72 {140, "Initialization of DMA Gateway failed"}, 73 {141, "Invalid ID of gateway provided"}, 74 {142, "Setting state of DMA Gateway failed"}, 75 {143, "DMA_CONTROL message targeting gateway not allocated yet"}, 76 {150, "Attempt to configure SCLK while I2S port is running"}, 77 {151, "Attempt to configure MCLK while I2S port is running"}, 78 {152, "Attempt to stop SCLK that is not running"}, 79 {153, "Attempt to stop MCLK that is not running"}, 80 {160, "Reserved (ADSP_IPC_PIPELINE_NOT_INITIALIZED removed)"}, 81 {161, "Reserved (ADSP_IPC_PIPELINE_NOT_EXIST removed)"}, 82 {162, "Reserved (ADSP_IPC_PIPELINE_SAVE_FAILED removed)"}, 83 {163, "Reserved (ADSP_IPC_PIPELINE_RESTORE_FAILED removed)"}, 84 {165, "Reserved (ADSP_IPC_PIPELINE_ALREADY_EXISTS removed)"}, 85 }; 86 87 static int sof_ipc4_check_reply_status(struct snd_sof_dev *sdev, u32 status) 88 { 89 int i, ret; 90 91 status &= SOF_IPC4_REPLY_STATUS; 92 93 if (!status) 94 return 0; 95 96 for (i = 0; i < ARRAY_SIZE(ipc4_status); i++) { 97 if (ipc4_status[i].status == status) { 98 dev_err(sdev->dev, "FW reported error: %u - %s\n", 99 status, ipc4_status[i].msg); 100 goto to_errno; 101 } 102 } 103 104 if (i == ARRAY_SIZE(ipc4_status)) 105 dev_err(sdev->dev, "FW reported error: %u - Unknown\n", status); 106 107 to_errno: 108 switch (status) { 109 case 8: 110 case 11: 111 case 105 ... 109: 112 case 114 ... 115: 113 case 160 ... 163: 114 case 165: 115 ret = -ENOENT; 116 break; 117 case 4: 118 case 150: 119 case 151: 120 ret = -EBUSY; 121 break; 122 default: 123 ret = -EINVAL; 124 break; 125 } 126 127 return ret; 128 } 129 130 #if IS_ENABLED(CONFIG_SND_SOC_SOF_DEBUG_VERBOSE_IPC) 131 #define DBG_IPC4_MSG_TYPE_ENTRY(type) [SOF_IPC4_##type] = #type 132 static const char * const ipc4_dbg_mod_msg_type[] = { 133 DBG_IPC4_MSG_TYPE_ENTRY(MOD_INIT_INSTANCE), 134 DBG_IPC4_MSG_TYPE_ENTRY(MOD_CONFIG_GET), 135 DBG_IPC4_MSG_TYPE_ENTRY(MOD_CONFIG_SET), 136 DBG_IPC4_MSG_TYPE_ENTRY(MOD_LARGE_CONFIG_GET), 137 DBG_IPC4_MSG_TYPE_ENTRY(MOD_LARGE_CONFIG_SET), 138 DBG_IPC4_MSG_TYPE_ENTRY(MOD_BIND), 139 DBG_IPC4_MSG_TYPE_ENTRY(MOD_UNBIND), 140 DBG_IPC4_MSG_TYPE_ENTRY(MOD_SET_DX), 141 DBG_IPC4_MSG_TYPE_ENTRY(MOD_SET_D0IX), 142 DBG_IPC4_MSG_TYPE_ENTRY(MOD_ENTER_MODULE_RESTORE), 143 DBG_IPC4_MSG_TYPE_ENTRY(MOD_EXIT_MODULE_RESTORE), 144 DBG_IPC4_MSG_TYPE_ENTRY(MOD_DELETE_INSTANCE), 145 }; 146 147 static const char * const ipc4_dbg_glb_msg_type[] = { 148 DBG_IPC4_MSG_TYPE_ENTRY(GLB_BOOT_CONFIG), 149 DBG_IPC4_MSG_TYPE_ENTRY(GLB_ROM_CONTROL), 150 DBG_IPC4_MSG_TYPE_ENTRY(GLB_IPCGATEWAY_CMD), 151 DBG_IPC4_MSG_TYPE_ENTRY(GLB_PERF_MEASUREMENTS_CMD), 152 DBG_IPC4_MSG_TYPE_ENTRY(GLB_CHAIN_DMA), 153 DBG_IPC4_MSG_TYPE_ENTRY(GLB_LOAD_MULTIPLE_MODULES), 154 DBG_IPC4_MSG_TYPE_ENTRY(GLB_UNLOAD_MULTIPLE_MODULES), 155 DBG_IPC4_MSG_TYPE_ENTRY(GLB_CREATE_PIPELINE), 156 DBG_IPC4_MSG_TYPE_ENTRY(GLB_DELETE_PIPELINE), 157 DBG_IPC4_MSG_TYPE_ENTRY(GLB_SET_PIPELINE_STATE), 158 DBG_IPC4_MSG_TYPE_ENTRY(GLB_GET_PIPELINE_STATE), 159 DBG_IPC4_MSG_TYPE_ENTRY(GLB_GET_PIPELINE_CONTEXT_SIZE), 160 DBG_IPC4_MSG_TYPE_ENTRY(GLB_SAVE_PIPELINE), 161 DBG_IPC4_MSG_TYPE_ENTRY(GLB_RESTORE_PIPELINE), 162 DBG_IPC4_MSG_TYPE_ENTRY(GLB_LOAD_LIBRARY), 163 DBG_IPC4_MSG_TYPE_ENTRY(GLB_INTERNAL_MESSAGE), 164 DBG_IPC4_MSG_TYPE_ENTRY(GLB_NOTIFICATION), 165 }; 166 167 #define DBG_IPC4_NOTIFICATION_TYPE_ENTRY(type) [SOF_IPC4_NOTIFY_##type] = #type 168 static const char * const ipc4_dbg_notification_type[] = { 169 DBG_IPC4_NOTIFICATION_TYPE_ENTRY(PHRASE_DETECTED), 170 DBG_IPC4_NOTIFICATION_TYPE_ENTRY(RESOURCE_EVENT), 171 DBG_IPC4_NOTIFICATION_TYPE_ENTRY(LOG_BUFFER_STATUS), 172 DBG_IPC4_NOTIFICATION_TYPE_ENTRY(TIMESTAMP_CAPTURED), 173 DBG_IPC4_NOTIFICATION_TYPE_ENTRY(FW_READY), 174 DBG_IPC4_NOTIFICATION_TYPE_ENTRY(FW_AUD_CLASS_RESULT), 175 DBG_IPC4_NOTIFICATION_TYPE_ENTRY(EXCEPTION_CAUGHT), 176 DBG_IPC4_NOTIFICATION_TYPE_ENTRY(MODULE_NOTIFICATION), 177 DBG_IPC4_NOTIFICATION_TYPE_ENTRY(PROBE_DATA_AVAILABLE), 178 DBG_IPC4_NOTIFICATION_TYPE_ENTRY(ASYNC_MSG_SRVC_MESSAGE), 179 }; 180 181 static void sof_ipc4_log_header(struct device *dev, u8 *text, struct sof_ipc4_msg *msg, 182 bool data_size_valid) 183 { 184 u32 val, type; 185 const u8 *str2 = NULL; 186 const u8 *str = NULL; 187 188 val = msg->primary & SOF_IPC4_MSG_TARGET_MASK; 189 type = SOF_IPC4_MSG_TYPE_GET(msg->primary); 190 191 if (val == SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG)) { 192 /* Module message */ 193 if (type < SOF_IPC4_MOD_TYPE_LAST) 194 str = ipc4_dbg_mod_msg_type[type]; 195 if (!str) 196 str = "Unknown Module message type"; 197 } else { 198 /* Global FW message */ 199 if (type < SOF_IPC4_GLB_TYPE_LAST) 200 str = ipc4_dbg_glb_msg_type[type]; 201 if (!str) 202 str = "Unknown Global message type"; 203 204 if (type == SOF_IPC4_GLB_NOTIFICATION) { 205 /* Notification message */ 206 u32 notif = SOF_IPC4_NOTIFICATION_TYPE_GET(msg->primary); 207 208 /* Do not print log buffer notification if not desired */ 209 if (notif == SOF_IPC4_NOTIFY_LOG_BUFFER_STATUS && 210 !sof_debug_check_flag(SOF_DBG_PRINT_DMA_POSITION_UPDATE_LOGS)) 211 return; 212 213 if (notif < SOF_IPC4_NOTIFY_TYPE_LAST) 214 str2 = ipc4_dbg_notification_type[notif]; 215 if (!str2) 216 str2 = "Unknown Global notification"; 217 } 218 } 219 220 if (str2) { 221 if (data_size_valid && msg->data_size) 222 dev_dbg(dev, "%s: %#x|%#x: %s|%s [data size: %zu]\n", 223 text, msg->primary, msg->extension, str, str2, 224 msg->data_size); 225 else 226 dev_dbg(dev, "%s: %#x|%#x: %s|%s\n", text, msg->primary, 227 msg->extension, str, str2); 228 } else { 229 if (data_size_valid && msg->data_size) 230 dev_dbg(dev, "%s: %#x|%#x: %s [data size: %zu]\n", 231 text, msg->primary, msg->extension, str, 232 msg->data_size); 233 else 234 dev_dbg(dev, "%s: %#x|%#x: %s\n", text, msg->primary, 235 msg->extension, str); 236 } 237 } 238 #else /* CONFIG_SND_SOC_SOF_DEBUG_VERBOSE_IPC */ 239 static void sof_ipc4_log_header(struct device *dev, u8 *text, struct sof_ipc4_msg *msg, 240 bool data_size_valid) 241 { 242 /* Do not print log buffer notification if not desired */ 243 if (!sof_debug_check_flag(SOF_DBG_PRINT_DMA_POSITION_UPDATE_LOGS) && 244 !SOF_IPC4_MSG_IS_MODULE_MSG(msg->primary) && 245 SOF_IPC4_MSG_TYPE_GET(msg->primary) == SOF_IPC4_GLB_NOTIFICATION && 246 SOF_IPC4_NOTIFICATION_TYPE_GET(msg->primary) == SOF_IPC4_NOTIFY_LOG_BUFFER_STATUS) 247 return; 248 249 if (data_size_valid && msg->data_size) 250 dev_dbg(dev, "%s: %#x|%#x [data size: %zu]\n", text, 251 msg->primary, msg->extension, msg->data_size); 252 else 253 dev_dbg(dev, "%s: %#x|%#x\n", text, msg->primary, msg->extension); 254 } 255 #endif 256 257 static int sof_ipc4_get_reply(struct snd_sof_dev *sdev) 258 { 259 struct snd_sof_ipc_msg *msg = sdev->msg; 260 struct sof_ipc4_msg *ipc4_reply; 261 int ret; 262 263 /* get the generic reply */ 264 ipc4_reply = msg->reply_data; 265 266 sof_ipc4_log_header(sdev->dev, "ipc tx reply", ipc4_reply, false); 267 268 ret = sof_ipc4_check_reply_status(sdev, ipc4_reply->primary); 269 if (ret) 270 return ret; 271 272 /* No other information is expected for non large config get replies */ 273 if (!msg->reply_size || !SOF_IPC4_MSG_IS_MODULE_MSG(ipc4_reply->primary) || 274 (SOF_IPC4_MSG_TYPE_GET(ipc4_reply->primary) != SOF_IPC4_MOD_LARGE_CONFIG_GET)) 275 return 0; 276 277 /* Read the requested payload */ 278 snd_sof_dsp_mailbox_read(sdev, sdev->dsp_box.offset, ipc4_reply->data_ptr, 279 msg->reply_size); 280 281 return 0; 282 } 283 284 /* wait for IPC message reply */ 285 static int ipc4_wait_tx_done(struct snd_sof_ipc *ipc, void *reply_data) 286 { 287 struct snd_sof_ipc_msg *msg = &ipc->msg; 288 struct sof_ipc4_msg *ipc4_msg = msg->msg_data; 289 struct snd_sof_dev *sdev = ipc->sdev; 290 int ret; 291 292 /* wait for DSP IPC completion */ 293 ret = wait_event_timeout(msg->waitq, msg->ipc_complete, 294 msecs_to_jiffies(sdev->ipc_timeout)); 295 if (ret == 0) { 296 dev_err(sdev->dev, "ipc timed out for %#x|%#x\n", 297 ipc4_msg->primary, ipc4_msg->extension); 298 return -ETIMEDOUT; 299 } 300 301 if (msg->reply_error) { 302 dev_err(sdev->dev, "ipc error for msg %#x|%#x\n", 303 ipc4_msg->primary, ipc4_msg->extension); 304 ret = msg->reply_error; 305 } else { 306 if (reply_data) { 307 struct sof_ipc4_msg *ipc4_reply = msg->reply_data; 308 struct sof_ipc4_msg *ipc4_reply_data = reply_data; 309 310 /* Copy the header */ 311 ipc4_reply_data->header_u64 = ipc4_reply->header_u64; 312 if (msg->reply_size && ipc4_reply_data->data_ptr) { 313 /* copy the payload returned from DSP */ 314 memcpy(ipc4_reply_data->data_ptr, ipc4_reply->data_ptr, 315 msg->reply_size); 316 ipc4_reply_data->data_size = msg->reply_size; 317 } 318 } 319 320 ret = 0; 321 sof_ipc4_log_header(sdev->dev, "ipc tx done ", ipc4_msg, true); 322 } 323 324 /* re-enable dumps after successful IPC tx */ 325 if (sdev->ipc_dump_printed) { 326 sdev->dbg_dump_printed = false; 327 sdev->ipc_dump_printed = false; 328 } 329 330 return ret; 331 } 332 333 static int ipc4_tx_msg_unlocked(struct snd_sof_ipc *ipc, 334 void *msg_data, size_t msg_bytes, 335 void *reply_data, size_t reply_bytes) 336 { 337 struct sof_ipc4_msg *ipc4_msg = msg_data; 338 struct snd_sof_dev *sdev = ipc->sdev; 339 int ret; 340 341 if (msg_bytes > ipc->max_payload_size || reply_bytes > ipc->max_payload_size) 342 return -EINVAL; 343 344 ret = sof_ipc_send_msg(sdev, msg_data, msg_bytes, reply_bytes); 345 if (ret) { 346 dev_err_ratelimited(sdev->dev, 347 "%s: ipc message send for %#x|%#x failed: %d\n", 348 __func__, ipc4_msg->primary, ipc4_msg->extension, ret); 349 return ret; 350 } 351 352 sof_ipc4_log_header(sdev->dev, "ipc tx ", msg_data, true); 353 354 /* now wait for completion */ 355 return ipc4_wait_tx_done(ipc, reply_data); 356 } 357 358 static int sof_ipc4_tx_msg(struct snd_sof_dev *sdev, void *msg_data, size_t msg_bytes, 359 void *reply_data, size_t reply_bytes, bool no_pm) 360 { 361 struct snd_sof_ipc *ipc = sdev->ipc; 362 #ifdef DEBUG_VERBOSE 363 struct sof_ipc4_msg *msg = NULL; 364 #endif 365 int ret; 366 367 if (!msg_data) 368 return -EINVAL; 369 370 /* Serialise IPC TX */ 371 mutex_lock(&ipc->tx_mutex); 372 373 ret = ipc4_tx_msg_unlocked(ipc, msg_data, msg_bytes, reply_data, reply_bytes); 374 375 mutex_unlock(&ipc->tx_mutex); 376 377 #ifdef DEBUG_VERBOSE 378 /* payload is indicated by non zero msg/reply_bytes */ 379 if (msg_bytes) 380 msg = msg_data; 381 else if (reply_bytes) 382 msg = reply_data; 383 384 if (msg) 385 sof_ipc4_dump_payload(sdev, msg->data_ptr, msg->data_size); 386 #endif 387 388 return ret; 389 } 390 391 static int sof_ipc4_set_get_data(struct snd_sof_dev *sdev, void *data, 392 size_t payload_bytes, bool set) 393 { 394 size_t payload_limit = sdev->ipc->max_payload_size; 395 struct sof_ipc4_msg *ipc4_msg = data; 396 struct sof_ipc4_msg tx = {{ 0 }}; 397 struct sof_ipc4_msg rx = {{ 0 }}; 398 size_t remaining = payload_bytes; 399 size_t offset = 0; 400 size_t chunk_size; 401 int ret; 402 403 if (!data) 404 return -EINVAL; 405 406 if ((ipc4_msg->primary & SOF_IPC4_MSG_TARGET_MASK) != 407 SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG)) 408 return -EINVAL; 409 410 ipc4_msg->primary &= ~SOF_IPC4_MSG_TYPE_MASK; 411 tx.primary = ipc4_msg->primary; 412 tx.extension = ipc4_msg->extension; 413 414 if (set) 415 tx.primary |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_LARGE_CONFIG_SET); 416 else 417 tx.primary |= SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_LARGE_CONFIG_GET); 418 419 tx.extension &= ~SOF_IPC4_MOD_EXT_MSG_SIZE_MASK; 420 tx.extension |= SOF_IPC4_MOD_EXT_MSG_SIZE(payload_bytes); 421 422 tx.extension |= SOF_IPC4_MOD_EXT_MSG_FIRST_BLOCK(1); 423 424 /* Serialise IPC TX */ 425 mutex_lock(&sdev->ipc->tx_mutex); 426 427 do { 428 size_t tx_size, rx_size; 429 430 if (remaining > payload_limit) { 431 chunk_size = payload_limit; 432 } else { 433 chunk_size = remaining; 434 if (set) 435 tx.extension |= SOF_IPC4_MOD_EXT_MSG_LAST_BLOCK(1); 436 } 437 438 if (offset) { 439 tx.extension &= ~SOF_IPC4_MOD_EXT_MSG_FIRST_BLOCK_MASK; 440 tx.extension &= ~SOF_IPC4_MOD_EXT_MSG_SIZE_MASK; 441 tx.extension |= SOF_IPC4_MOD_EXT_MSG_SIZE(offset); 442 } 443 444 if (set) { 445 tx.data_size = chunk_size; 446 tx.data_ptr = ipc4_msg->data_ptr + offset; 447 448 tx_size = chunk_size; 449 rx_size = 0; 450 } else { 451 rx.primary = 0; 452 rx.extension = 0; 453 rx.data_size = chunk_size; 454 rx.data_ptr = ipc4_msg->data_ptr + offset; 455 456 tx_size = 0; 457 rx_size = chunk_size; 458 } 459 460 /* Send the message for the current chunk */ 461 ret = ipc4_tx_msg_unlocked(sdev->ipc, &tx, tx_size, &rx, rx_size); 462 if (ret < 0) { 463 dev_err(sdev->dev, 464 "%s: large config %s failed at offset %zu: %d\n", 465 __func__, set ? "set" : "get", offset, ret); 466 goto out; 467 } 468 469 if (!set && rx.extension & SOF_IPC4_MOD_EXT_MSG_FIRST_BLOCK_MASK) { 470 /* Verify the firmware reported total payload size */ 471 rx_size = rx.extension & SOF_IPC4_MOD_EXT_MSG_SIZE_MASK; 472 473 if (rx_size > payload_bytes) { 474 dev_err(sdev->dev, 475 "%s: Receive buffer (%zu) is too small for %zu\n", 476 __func__, payload_bytes, rx_size); 477 ret = -ENOMEM; 478 goto out; 479 } 480 481 if (rx_size < chunk_size) { 482 chunk_size = rx_size; 483 remaining = rx_size; 484 } else if (rx_size < payload_bytes) { 485 remaining = rx_size; 486 } 487 } 488 489 offset += chunk_size; 490 remaining -= chunk_size; 491 } while (remaining); 492 493 /* Adjust the received data size if needed */ 494 if (!set && payload_bytes != offset) 495 ipc4_msg->data_size = offset; 496 497 sof_ipc4_dump_payload(sdev, ipc4_msg->data_ptr, ipc4_msg->data_size); 498 499 out: 500 mutex_unlock(&sdev->ipc->tx_mutex); 501 502 return ret; 503 } 504 505 static int sof_ipc4_init_msg_memory(struct snd_sof_dev *sdev) 506 { 507 struct sof_ipc4_msg *ipc4_msg; 508 struct snd_sof_ipc_msg *msg = &sdev->ipc->msg; 509 510 /* TODO: get max_payload_size from firmware */ 511 sdev->ipc->max_payload_size = SOF_IPC4_MSG_MAX_SIZE; 512 513 /* Allocate memory for the ipc4 container and the maximum payload */ 514 msg->reply_data = devm_kzalloc(sdev->dev, sdev->ipc->max_payload_size + 515 sizeof(struct sof_ipc4_msg), GFP_KERNEL); 516 if (!msg->reply_data) 517 return -ENOMEM; 518 519 ipc4_msg = msg->reply_data; 520 ipc4_msg->data_ptr = msg->reply_data + sizeof(struct sof_ipc4_msg); 521 522 return 0; 523 } 524 525 static int ipc4_fw_ready(struct snd_sof_dev *sdev, struct sof_ipc4_msg *ipc4_msg) 526 { 527 int inbox_offset, inbox_size, outbox_offset, outbox_size; 528 529 /* no need to re-check version/ABI for subsequent boots */ 530 if (!sdev->first_boot) 531 return 0; 532 533 /* Set up the windows for IPC communication */ 534 inbox_offset = snd_sof_dsp_get_mailbox_offset(sdev); 535 if (inbox_offset < 0) { 536 dev_err(sdev->dev, "%s: No mailbox offset\n", __func__); 537 return inbox_offset; 538 } 539 inbox_size = SOF_IPC4_MSG_MAX_SIZE; 540 outbox_offset = snd_sof_dsp_get_window_offset(sdev, 1); 541 outbox_size = SOF_IPC4_MSG_MAX_SIZE; 542 543 sdev->dsp_box.offset = inbox_offset; 544 sdev->dsp_box.size = inbox_size; 545 sdev->host_box.offset = outbox_offset; 546 sdev->host_box.size = outbox_size; 547 548 dev_dbg(sdev->dev, "mailbox upstream 0x%x - size 0x%x\n", 549 inbox_offset, inbox_size); 550 dev_dbg(sdev->dev, "mailbox downstream 0x%x - size 0x%x\n", 551 outbox_offset, outbox_size); 552 553 return sof_ipc4_init_msg_memory(sdev); 554 } 555 556 static void sof_ipc4_rx_msg(struct snd_sof_dev *sdev) 557 { 558 struct sof_ipc4_msg *ipc4_msg = sdev->ipc->msg.rx_data; 559 size_t data_size = 0; 560 int err; 561 562 if (!ipc4_msg || !SOF_IPC4_MSG_IS_NOTIFICATION(ipc4_msg->primary)) 563 return; 564 565 ipc4_msg->data_ptr = NULL; 566 ipc4_msg->data_size = 0; 567 568 sof_ipc4_log_header(sdev->dev, "ipc rx ", ipc4_msg, false); 569 570 switch (SOF_IPC4_NOTIFICATION_TYPE_GET(ipc4_msg->primary)) { 571 case SOF_IPC4_NOTIFY_FW_READY: 572 /* check for FW boot completion */ 573 if (sdev->fw_state == SOF_FW_BOOT_IN_PROGRESS) { 574 err = ipc4_fw_ready(sdev, ipc4_msg); 575 if (err < 0) 576 sof_set_fw_state(sdev, SOF_FW_BOOT_READY_FAILED); 577 else 578 sof_set_fw_state(sdev, SOF_FW_BOOT_READY_OK); 579 580 /* wake up firmware loader */ 581 wake_up(&sdev->boot_wait); 582 } 583 584 break; 585 case SOF_IPC4_NOTIFY_RESOURCE_EVENT: 586 data_size = sizeof(struct sof_ipc4_notify_resource_data); 587 break; 588 default: 589 dev_dbg(sdev->dev, "Unhandled DSP message: %#x|%#x\n", 590 ipc4_msg->primary, ipc4_msg->extension); 591 break; 592 } 593 594 if (data_size) { 595 ipc4_msg->data_ptr = kmalloc(data_size, GFP_KERNEL); 596 if (!ipc4_msg->data_ptr) 597 return; 598 599 ipc4_msg->data_size = data_size; 600 snd_sof_ipc_msg_data(sdev, NULL, ipc4_msg->data_ptr, ipc4_msg->data_size); 601 } 602 603 sof_ipc4_log_header(sdev->dev, "ipc rx done ", ipc4_msg, true); 604 605 if (data_size) { 606 kfree(ipc4_msg->data_ptr); 607 ipc4_msg->data_ptr = NULL; 608 ipc4_msg->data_size = 0; 609 } 610 } 611 612 static int sof_ipc4_set_core_state(struct snd_sof_dev *sdev, int core_idx, bool on) 613 { 614 struct sof_ipc4_dx_state_info dx_state; 615 struct sof_ipc4_msg msg; 616 617 dx_state.core_mask = BIT(core_idx); 618 if (on) 619 dx_state.dx_mask = BIT(core_idx); 620 else 621 dx_state.dx_mask = 0; 622 623 msg.primary = SOF_IPC4_MSG_TYPE_SET(SOF_IPC4_MOD_SET_DX); 624 msg.primary |= SOF_IPC4_MSG_DIR(SOF_IPC4_MSG_REQUEST); 625 msg.primary |= SOF_IPC4_MSG_TARGET(SOF_IPC4_MODULE_MSG); 626 msg.extension = 0; 627 msg.data_ptr = &dx_state; 628 msg.data_size = sizeof(dx_state); 629 630 return sof_ipc4_tx_msg(sdev, &msg, msg.data_size, NULL, 0, false); 631 } 632 633 /* 634 * The context save callback is used to send a message to the firmware notifying 635 * it that the primary core is going to be turned off, which is used as an 636 * indication to prepare for a full power down, thus preparing for IMR boot 637 * (when supported) 638 * 639 * Note: in IPC4 there is no message used to restore context, thus no context 640 * restore callback is implemented 641 */ 642 static int sof_ipc4_ctx_save(struct snd_sof_dev *sdev) 643 { 644 return sof_ipc4_set_core_state(sdev, SOF_DSP_PRIMARY_CORE, false); 645 } 646 647 static const struct sof_ipc_pm_ops ipc4_pm_ops = { 648 .ctx_save = sof_ipc4_ctx_save, 649 .set_core_state = sof_ipc4_set_core_state, 650 }; 651 652 const struct sof_ipc_ops ipc4_ops = { 653 .tx_msg = sof_ipc4_tx_msg, 654 .rx_msg = sof_ipc4_rx_msg, 655 .set_get_data = sof_ipc4_set_get_data, 656 .get_reply = sof_ipc4_get_reply, 657 .pm = &ipc4_pm_ops, 658 .fw_loader = &ipc4_loader_ops, 659 .tplg = &ipc4_tplg_ops, 660 .pcm = &ipc4_pcm_ops, 661 }; 662