msg.h

Go to the documentation of this file.

/* SPDX-License-Identifier: BSD-3-Clause
 *
 * Copyright(c) 2016 Intel Corporation. All rights reserved.
 *
 * Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>
 *         Keyon Jie <yang.jie@linux.intel.com>
 */
 
#ifndef __SOF_IPC_MSG_H__
#define __SOF_IPC_MSG_H__
 
#include <sof/audio/buffer.h>
#include <sof/audio/component.h>
#include <sof/audio/pipeline.h>
#include <rtos/alloc.h>
#include <sof/lib/memory.h>
#include <sof/list.h>
#include <sof/platform.h>
#include <rtos/task.h>
#include <rtos/sof.h>
#include <rtos/spinlock.h>
#include <sof/trace/trace.h>
#include <sof/ipc/common.h>
#include <ipc/trace.h>
 
#include <stdbool.h>
#include <stdint.h>
 
struct dai_config;
struct dma;
struct dma_sg_elem_array;
 
struct ipc_msg {
    uint32_t header;    /* specific to platform */
    uint32_t extension; /* extension specific to platform */
    uint32_t tx_size;   /* payload size in bytes */
    void *tx_data;      /* pointer to payload data, must be in a non-cached memory */
    struct list_item list;
    void (*callback)(struct ipc_msg *msg); /* Function called after sending the message */
};

static inline struct ipc_msg *ipc_msg_w_ext_init(uint32_t header, uint32_t extension,
                         uint32_t size)
{
    struct ipc_msg *msg;
 
    msg = rzalloc(SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT, sizeof(*msg));
    if (!msg)
        return NULL;
 
    if (size) {
        msg->tx_data = rzalloc(SOF_MEM_FLAG_USER | SOF_MEM_FLAG_COHERENT, size);
        if (!msg->tx_data) {
            rfree(msg);
            return NULL;
        }
    }
 
    msg->header = header;
    msg->extension = extension;
    msg->tx_size = size;
    list_init(&msg->list);
 
    return msg;
}

static inline struct ipc_msg *ipc_msg_init(uint32_t header, uint32_t size)
{
    return ipc_msg_w_ext_init(header, 0, size);
}

static inline void ipc_msg_free(struct ipc_msg *msg)
{
    if (!msg)
        return;
 
    struct ipc *ipc = ipc_get();
    k_spinlock_key_t key;
 
    key = k_spin_lock(&ipc->lock);
 
    list_item_del(&msg->list);
    rfree(msg->tx_data);
    rfree(msg);
 
    k_spin_unlock(&ipc->lock, key);
}

void ipc_send_queued_msg(void);

void ipc_msg_send(struct ipc_msg *msg, void *data, bool high_priority);

void ipc_msg_send_direct(struct ipc_msg *msg, void *data);

void ipc_build_stream_posn(struct sof_ipc_stream_posn *posn, uint32_t type,
               uint32_t id);

void ipc_build_comp_event(struct sof_ipc_comp_event *event, uint32_t type,
              uint32_t id);

bool ipc_trigger_trace_xfer(uint32_t avail);

void ipc_build_trace_posn(struct sof_ipc_dma_trace_posn *posn);
 
#endif