// SPDX-License-Identifier: BSD-3-Clause

//

// Copyright(c) 2022 Intel Corporation. All rights reserved.

//

// Author: Liam Girdwood <liam.r.girdwood@linux.intel.com>

/*

* SOF pipeline in userspace.

*/

#define _GNU_SOURCE

#include <stdio.h>

#include <sys/poll.h>

#include <string.h>

#include <sys/types.h>

#include <unistd.h>

#include <stdlib.h>

#include <sys/wait.h>

#include <sys/stat.h>

#include <signal.h>

#include <mqueue.h>

#include <fcntl.h>

#include <sys/mman.h>

#include <semaphore.h>

#include <assert.h>

#include <errno.h>

#include <pthread.h>

#include <limits.h>

#include <getopt.h>

#include <dlfcn.h>

#include <rtos/sof.h>

#include <rtos/task.h>

#include <sof/lib/notifier.h>

#include <sof/ipc/driver.h>

#include <sof/ipc/topology.h>

#include <sof/lib/agent.h>

#include <sof/lib/dai.h>

#include <sof/lib/dma.h>

#include <sof/schedule/edf_schedule.h>

#include <sof/schedule/ll_schedule.h>

#include <sof/schedule/ll_schedule_domain.h>

#include <sof/schedule/schedule.h>

#include <sof/audio/pipeline.h>

#include <sof/audio/component.h>

#include <sof/audio/component_ext.h>

#include "common.h"

#include "pipe.h"

// TODO: take prefix from ALSA prefix

#define COMP_PREFIX "./sof_ep/install/lib/libsof_"

#define COMP_SUFFIX ".so"

#define UUID_STR_SIZE 32

struct sof_pipe_module_library_map {

int module_id;

const char *name;

};

static const struct sof_pipe_module_library_map library_map[] = {

{0x6, "libsof_volume.so"},

{0x2, "libsof_mixer.so"},

{0x3, "libsof_mixer.so"},

/*FIXME: hack for now to set up ALSA and SHM components */

{0x96, "libsof_mod_shm.so"}, /* host playback */

{0x97, "libsof_mod_alsa.so"}, /* dai playback */

{0x98, "libsof_mod_shm.so"}, /* host capture */

{0x99, "libsof_mod_alsa.so"}, /* dai capture */

};

static int pipe_register_comp(struct sof_pipe *sp, uint16_t module_id)

{

const struct sof_pipe_module_library_map *lib;

int i;

/* check if module already loaded */

for (i = 0; i < sp->mod_idx; i++) {

if (sp->module[i].module_id == module_id)

return 0; /* module found and already loaded */

}

for (i = 0; i < ARRAY_SIZE(library_map); i++) {

lib = &library_map[i];

if (module_id == lib->module_id)

break;

}

if (i == ARRAY_SIZE(library_map)) {

fprintf(stderr, "module ID: %d not supported\n", module_id);

return -ENOTSUP;

}

/* not loaded, so load module */

sp->module[sp->mod_idx].handle = dlopen(lib->name, RTLD_NOW);

if (!sp->module[sp->mod_idx].handle) {

fprintf(stderr, "error: cant load module %s: %s\n",

lib->name, dlerror());

return -errno;

}

sp->mod_idx++;

return 0;

}

#define iCS(x) ((x) & SOF_CMD_TYPE_MASK)

#define iGS(x) ((x) & SOF_GLB_TYPE_MASK)

static int pipe_sof_ipc_cmd_before(struct sof_pipe *sp, void *mailbox, size_t bytes)

{

struct ipc4_message_request *in = mailbox;

enum ipc4_message_target target = in->primary.r.msg_tgt;

int ret = 0;

switch (target) {

case SOF_IPC4_MESSAGE_TARGET_MODULE_MSG:

{

uint32_t type = in->primary.r.type;

switch (type) {

case SOF_IPC4_MOD_INIT_INSTANCE:

struct ipc4_module_init_instance *module_init =

(struct ipc4_module_init_instance *)in;

ret = pipe_register_comp(sp, module_init->primary.r.module_id);

break;

default:

break;

}

break;

}

case SOF_IPC4_MESSAGE_TARGET_FW_GEN_MSG:

{

uint32_t type = in->primary.r.type;

switch (type) {

case SOF_IPC4_GLB_SET_PIPELINE_STATE:

{

struct ipc4_pipeline_set_state *state;

struct ipc_comp_dev *ipc_pipe;

struct ipc *ipc = ipc_get();

unsigned int pipeline_id;

state = (struct ipc4_pipeline_set_state *)in;

pipeline_id = (unsigned int)state->primary.r.ppl_id;

if (state->primary.r.ppl_state == SOF_IPC4_PIPELINE_STATE_PAUSED) {

ipc_pipe = ipc_get_pipeline_by_id(ipc, pipeline_id);

if (!ipc_pipe) {

fprintf(stderr, "No pipeline with instance_id = %u",

pipeline_id);

return -EINVAL;

}

/* stop the pipeline thread */

ret = pipe_thread_stop(sp, ipc_pipe->pipeline);

if (ret < 0) {

printf("error: can't start pipeline %d thread\n",

ipc_pipe->pipeline->comp_id);

return ret;

}

}

break;

}

default:

break;

}

break;

}

default:

fprintf(sp->log, "ipc: unknown command target %u size %ld",

target, bytes);

ret = -EINVAL;

break;

}

return ret;

}

static int pipe_sof_ipc_cmd_after(struct sof_pipe *sp, void *mailbox, size_t bytes)

{

struct ipc4_message_request *in = mailbox;

enum ipc4_message_target target = in->primary.r.msg_tgt;

int ret = 0;

switch (target) {

case SOF_IPC4_MESSAGE_TARGET_MODULE_MSG:

break;

case SOF_IPC4_MESSAGE_TARGET_FW_GEN_MSG:

{

uint32_t type = in->primary.r.type;

switch (type) {

case SOF_IPC4_GLB_CREATE_PIPELINE:

{

struct ipc4_pipeline_create *pipe_desc = (struct ipc4_pipeline_create *)in;

struct ipc_comp_dev *ipc_pipe;

struct ipc *ipc = ipc_get();

unsigned int pipeline_id = (unsigned int)pipe_desc->primary.r.instance_id;

ipc_pipe = ipc_get_pipeline_by_id(ipc, pipeline_id);

if (!ipc_pipe) {

fprintf(stderr, "No pipeline with instance_id = %u\n",

pipeline_id);

return -EINVAL;

}

/* create new pipeline thread */

ret = pipe_thread_new(sp, ipc_pipe->pipeline);

if (ret < 0) {

printf("error: can't create pipeline %d thread\n",

ipc_pipe->pipeline->pipeline_id);

return ret;

}

break;

}

case SOF_IPC4_GLB_SET_PIPELINE_STATE:

{

struct ipc4_pipeline_set_state *state;

struct ipc_comp_dev *ipc_pipe;

struct ipc *ipc = ipc_get();

unsigned int pipeline_id;

state = (struct ipc4_pipeline_set_state *)in;

pipeline_id = (unsigned int)state->primary.r.ppl_id;

if (state->primary.r.ppl_state == SOF_IPC4_PIPELINE_STATE_RUNNING) {

ipc_pipe = ipc_get_pipeline_by_id(ipc, pipeline_id);

if (!ipc_pipe) {

fprintf(stderr, "No pipeline with instance_id = %u\n",

pipeline_id);

return -EINVAL;

}

/* start the pipeline thread */

ret = pipe_thread_start(sp, ipc_pipe->pipeline);

if (ret < 0) {

printf("error: can't start pipeline %d thread\n",

ipc_pipe->pipeline->comp_id);

return ret;

}

}

break;

}

case SOF_IPC4_GLB_DELETE_PIPELINE:

{

struct ipc4_pipeline_create *pipe_desc = (struct ipc4_pipeline_create *)in;

unsigned int pipeline_id = (unsigned int)pipe_desc->primary.r.instance_id;

/* free pipeline thread */

ret = pipe_thread_free(sp, pipeline_id);

if (ret < 0) {

printf("error: can't free pipeline %d thread\n",

pipeline_id);

return ret;

}

break;

}

default:

break;

}

break;

}

default:

fprintf(sp->log, "ipc: unknown command target %u size %ld",

target, bytes);

ret = -EINVAL;

break;

}

return ret;

}

int pipe_ipc_do(struct sof_pipe *sp, void *mailbox, size_t bytes)

{

char mailbox_copy[IPC3_MAX_MSG_SIZE] = {0};

int err = 0;

/* preserve mailbox contents for local "after" config */

memcpy(mailbox_copy, mailbox, bytes);

/* some IPCs require pipe to perform actions before core */

/* mailbox can be re-written here by local pipe if needed */

err = pipe_sof_ipc_cmd_before(sp, mailbox, bytes);

if (err < 0) {

fprintf(sp->log, "error: local IPC processing failed\n");

return err;

}

/* is the IPC local only or do we need send to infra ? */

err = pipe_ipc_message(sp, mailbox, bytes);

if (err < 0) {

fprintf(sp->log, "error: infra IPC processing failed\n");

return err;

}

/* some IPCs require pipe to perform actions before core */

err = pipe_sof_ipc_cmd_after(sp, mailbox_copy, bytes);

if (err < 0) {

fprintf(sp->log, "error: local IPC processing failed\n");

return err;

}

return err;

}

int pipe_ipc_process(struct sof_pipe *sp, struct plug_mq_desc *tx_mq, struct plug_mq_desc *rx_mq)

{

ssize_t ipc_size;

char mailbox[IPC3_MAX_MSG_SIZE] = {0};

int err;

struct timespec ts;

/* IPC thread should not preempt processing thread */

err = pipe_set_ipc_lowpri(sp);

if (err < 0)

fprintf(sp->log, "error: cant set PCM IPC thread to low priority");

/* create the IPC message queue */

err = plug_mq_create(tx_mq);

if (err < 0) {

fprintf(sp->log, "error: can't create TX IPC message queue : %s\n",

strerror(errno));

return -errno;

}

/* create the IPC message queue */

err = plug_mq_create(rx_mq);

if (err < 0) {

fprintf(sp->log, "error: can't create PCM IPC message queue : %s\n",

strerror(errno));

return -errno;

}

/* let main() know we are ready */

fprintf(sp->log, "sof-pipe: IPC TX %s thread ready\n", tx_mq->queue_name);

fprintf(sp->log, "sof-pipe: IPC RX %s thread ready\n", rx_mq->queue_name);

/* main PCM IPC handling loop */

while (1) {

memset(mailbox, 0, IPC3_MAX_MSG_SIZE);

/* is client dead ? */

if (sp->glb->state == SOF_PLUGIN_STATE_DEAD) {

fprintf(sp->log, "sof-pipe: IPC %s client complete\n", tx_mq->queue_name);

break;

}

ipc_size = mq_receive(tx_mq->mq, mailbox, IPC3_MAX_MSG_SIZE, NULL);

if (ipc_size < 0) {

fprintf(sp->log, "error: can't read PCM IPC message queue %s : %s\n",

tx_mq->queue_name, strerror(errno));

break;

}

/* TODO: properly validate message and continue if garbage */

if (*((uint32_t *)mailbox) == 0) {

fprintf(sp->log, "sof-pipe: IPC %s garbage read\n", tx_mq->queue_name);

ts.tv_sec = 0;

ts.tv_nsec = 20 * 1000 * 1000; /* 20 ms */

nanosleep(&ts, NULL);

continue;

}

/* do the message work */

//data_dump(mailbox, IPC3_MAX_MSG_SIZE);

err = pipe_ipc_do(sp, mailbox, ipc_size);

if (err < 0)

fprintf(sp->log, "error: local IPC processing failed\n");

/* now return message completion status found in mailbox */

err = mq_send(rx_mq->mq, mailbox, IPC3_MAX_MSG_SIZE, 0);

if (err < 0) {

fprintf(sp->log, "error: can't send PCM IPC message queue %s : %s\n",

rx_mq->queue_name, strerror(errno));

break;

}

}

fprintf(sp->log, "***sof-pipe: IPC %s thread finished !!\n", tx_mq->queue_name);

return 0;

}

int plug_mq_cmd(struct plug_mq_desc *ipc, void *msg, size_t len, void *reply, size_t rlen)

{

struct timespec ts;

ssize_t ipc_size;

char mailbox[IPC3_MAX_MSG_SIZE];

int err;

if (len > IPC3_MAX_MSG_SIZE) {

SNDERR("ipc: message too big %d\n", len);

return -EINVAL;

}

memset(mailbox, 0, IPC3_MAX_MSG_SIZE);

memcpy(mailbox, msg, len);

/* wait for sof-pipe reader to consume data or timeout */

err = clock_gettime(CLOCK_REALTIME, &ts);

if (err == -1) {

SNDERR("ipc: cant get time: %s", strerror(errno));

return -errno;

}

/* IPCs should be read under 10ms */

plug_timespec_add_ms(&ts, 10);

/* now return message completion status */

err = mq_timedsend(ipc->mq, mailbox, IPC3_MAX_MSG_SIZE, 0, &ts);

if (err < 0) {

SNDERR("error: can't send IPC message queue %s : %s\n",

ipc->queue_name, strerror(errno));

return -errno;

}

/* wait for sof-pipe reader to consume data or timeout */

err = clock_gettime(CLOCK_REALTIME, &ts);

if (err == -1) {

SNDERR("ipc: cant get time: %s", strerror(errno));

return -errno;

}

/* IPCs should be processed under 20ms */

plug_timespec_add_ms(&ts, 20);

ipc_size = mq_timedreceive(ipc->mq, mailbox, IPC3_MAX_MSG_SIZE, NULL, &ts);

if (ipc_size < 0) {

SNDERR("error: can't read IPC message queue %s : %s\n",

ipc->queue_name, strerror(errno));

return -errno;

}

/* do the message work */

//printf("cmd got IPC %ld reply bytes\n", ipc_size);

if (rlen && reply)

memcpy(reply, mailbox, rlen);

return 0;

}