// 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 "common.h"

#include "pipe.h"

#define VERSION "v0.1"

/* global needed for signal handler */

struct sof_pipe *_sp;

static void shutdown(struct sof_pipe *sp)

{

struct pipethread_data *pipeline_ctx = sp->pipeline_ctx;

int i;

/* free everything */

munmap(sp->shm_context.addr, sp->shm_context.size);

shm_unlink(sp->shm_context.name);

/* cancel all threads, free locks and message queues */

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

struct pipethread_data *pd = &pipeline_ctx[i];

pthread_cancel(pd->ipc_thread);

pthread_cancel(pd->pcm_thread);

plug_mq_free(&pd->ipc_tx_mq);

plug_mq_free(&pd->ipc_rx_mq);

plug_lock_free(&pd->ready);

plug_lock_free(&pd->done);

}

/* free the sof-pipe IPC tx/rx message queues */

plug_mq_free(&sp->ipc_tx_mq);

plug_mq_free(&sp->ipc_rx_mq);

pthread_mutex_destroy(&sp->ipc_lock);

fflush(sp->log);

fflush(stdout);

fflush(stderr);

}

/* signals from the ALSA PCM plugin or something has gone wrong */

static void signal_handler(int sig)

{

switch (sig) {

case SIGTERM:

fprintf(_sp->log, "Pipe caught SIGTERM - shutdown\n");

break;

case SIGINT:

fprintf(_sp->log, "Pipe caught SIGINT - shutdown\n");

break;

default:

fprintf(_sp->log, "Pipe caught signal %d, something went wrong\n", sig);

break;

}

fprintf(_sp->log, "Pipe shutdown signal\n");

/* try and clean up if we can */

shutdown(_sp);

exit(EXIT_FAILURE);

}

static int pipe_init_signals(struct sof_pipe *sp)

{

struct sigaction *action = &sp->action;

int err;

/*

* signals - currently only check for SIGCHLD. TODO: handle more

*/

sigemptyset(&action->sa_mask);

action->sa_handler = signal_handler;

err = sigaction(SIGTERM, action, NULL);

if (err < 0) {

fprintf(sp->log, "failed to register signal action: %s",

strerror(errno));

return err;

}

err = sigaction(SIGSEGV, action, NULL);

if (err < 0) {

fprintf(sp->log, "failed to register signal action: %s",

strerror(errno));

return err;

}

err = sigaction(SIGINT, action, NULL);

if (err < 0) {

fprintf(sp->log, "failed to register signal action: %s",

strerror(errno));

return err;

}

return 0;

}

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

{

struct ipc *ipc = ipc_get();

/* reply is copied back to mailbox */

pthread_mutex_lock(&sp->ipc_lock);

memcpy(ipc->comp_data, mailbox, bytes);

ipc_cmd(mailbox);

memcpy(mailbox, ipc->comp_data, bytes);

pthread_mutex_unlock(&sp->ipc_lock);

return 0;

}

/*

* Create and open a new semaphore using the lock object.

*/

int plug_lock_create(struct plug_sem_desc *lock)

{

/* delete any old stale resources that use our resource name */

sem_unlink(lock->name);

/* RW blocking lock */

lock->sem = sem_open(lock->name, O_CREAT | O_RDWR | O_EXCL, SEM_PERMS, 0);

if (lock->sem == SEM_FAILED) {

SNDERR("failed to create semaphore %s: %s", lock->name, strerror(errno));

return -errno;

}

return 0;

}

/*

* Free and delete semaphore resourses in lock object.

*/

void plug_lock_free(struct plug_sem_desc *lock)

{

sem_close(lock->sem);

sem_unlink(lock->name);

}

/*

* Create and open a new shared memory region using the SHM object.

*/

int plug_shm_create(struct plug_shm_desc *shm)

{

int err;

/* delete any old stale resources that use our resource name */

shm_unlink(shm->name);

/* open SHM to be used for low latency position */

shm->fd = shm_open(shm->name, O_RDWR | O_CREAT, S_IRWXU | S_IRWXG);

if (shm->fd < 0) {

SNDERR("failed to create SHM position %s: %s", shm->name, strerror(errno));

return -errno;

}

/* set SHM size */

err = ftruncate(shm->fd, shm->size);

if (err < 0) {

SNDERR("failed to truncate SHM position %s: %s", shm->name, strerror(errno));

shm_unlink(shm->name);

return -errno;

}

/* map it locally for context readback */

shm->addr = mmap(NULL, shm->size, PROT_READ | PROT_WRITE, MAP_SHARED, shm->fd, 0);

if (!shm->addr) {

SNDERR("failed to mmap SHM position%s: %s", shm->name, strerror(errno));

shm_unlink(shm->name);

return -errno;

}

return 0;

}

/*

* Free and delete shared memory region resourses in SHM object.

*/

void plug_shm_free(struct plug_shm_desc *shm)

{

close(shm->fd);

shm_unlink(shm->name);

}

/*

* Create and open a new message queue using the IPC object.

*/

int plug_mq_create(struct plug_mq_desc *ipc)

{

/* delete any old stale resources that use our resource name */

mq_unlink(ipc->queue_name);

memset(&ipc->attr, 0, sizeof(ipc->attr));

ipc->attr.mq_msgsize = IPC3_MAX_MSG_SIZE;

ipc->attr.mq_maxmsg = 1;

/* now open new queue for Tx/Rx */

ipc->mq = mq_open(ipc->queue_name, O_CREAT | O_RDWR | O_EXCL,

S_IRWXU | S_IRWXG, &ipc->attr);

if (ipc->mq < 0) {

fprintf(stderr, "failed to create IPC queue %s: %s\n",

ipc->queue_name, strerror(errno));

return -errno;

}

return 0;

}

/*

* Free and delete message queue resources in IPC object.

*/

void plug_mq_free(struct plug_mq_desc *ipc)

{

mq_close(ipc->mq);

mq_unlink(ipc->queue_name);

}

/*

* -D ALSA device. e.g.

* -R realtime (needs parent to set uid)

* -p Force run on P core

* -e Force run on E core

* -t topology name.

* -L log file (otherwise stdout)

* -h help

*/

static void usage(char *name)

{

fprintf(stdout, "Usage: %s -D ALSA device -T topology\n", name);

}

int main(int argc, char *argv[], char *env[])

{

struct sof_pipe sp = {0};

int option = 0;

int ret = 0;

/* default config */

sp.log = stdout;

sp.alsa_name = "default"; /* default sound device */

_sp = &sp;

/* parse all args */

while ((option = getopt(argc, argv, "hD:RpeT:")) != -1) {

switch (option) {

/* Alsa device */

case 'D':

sp.alsa_name = strdup(optarg);

break;

case 'R':

sp.realtime = 1;

break;

case 'p':

sp.use_P_core = 1;

sp.use_E_core = 0;

break;

case 'e':

sp.use_E_core = 1;

sp.use_P_core = 0;

break;

case 'T':

snprintf(sp.topology_name, NAME_SIZE, "%s", optarg);

break;

/* print usage */

default:

fprintf(sp.log, "unknown option %c\n", option);

__attribute__ ((fallthrough));

case 'h':

usage(argv[0]);

exit(EXIT_SUCCESS);

}

}

/* validate cmd line params */

if (strlen(sp.topology_name) == 0) {

fprintf(sp.log, "error: no IPC topology name specified\n");

exit(EXIT_FAILURE);

}

/* global IPC access serialisation mutex */

ret = pthread_mutex_init(&sp.ipc_lock, NULL);

if (ret < 0) {

fprintf(sp.log, "error: cant create mutex %s\n", strerror(errno));

exit(EXIT_FAILURE);

}

fprintf(sp.log, "sof-pipe-%s: using topology %s\n", VERSION, sp.topology_name);

/* set CPU affinity */

if (sp.use_E_core || sp.use_P_core) {

ret = pipe_set_affinity(&sp);

if (ret < 0)

goto out;

}

/* initialize ipc and scheduler */

if (pipe_sof_setup(sof_get()) < 0) {

fprintf(stderr, "error: pipeline init\n");

exit(EXIT_FAILURE);

}

/* global context - plugin clients open this first */

ret = plug_shm_init(&sp.shm_context, sp.topology_name, "ctx", 0);

if (ret < 0)

goto out;

/* cleanup any lingering global IPC files */

shm_unlink(sp.shm_context.name);

/* make sure we can cleanly shutdown */

ret = pipe_init_signals(&sp);

if (ret < 0)

goto out;

/* mmap context on successful topology load */

ret = plug_shm_create(&sp.shm_context);

if (ret < 0)

goto out;

/* now prep the global context for client plugin access */

sp.glb = sp.shm_context.addr;

memset(sp.glb, 0, sizeof(*sp.glb));

sprintf(sp.glb->magic, "%s", SOF_MAGIC);

sp.glb->size = sizeof(*sp.glb);

sp.glb->state = SOF_PLUGIN_STATE_INIT;

sp.tplg.tplg_file = sp.topology_name;

sp.tplg.ipc_major = 4; //HACK hard code to v4

/* sofpipe is now ready */

sp.glb->state = SOF_PLUGIN_STATE_INIT;

ret = plug_mq_init(&sp.ipc_tx_mq, "sof", "ipc-tx", 0);

if (ret < 0)

goto out;

ret = plug_mq_init(&sp.ipc_rx_mq, "sof", "ipc-rx", 0);

if (ret < 0)

goto out;

/* now process IPCs as they arrive from plugins */

ret = pipe_ipc_process(&sp, &sp.ipc_tx_mq, &sp.ipc_rx_mq);

out:

fprintf(sp.log, "shutdown main\n");

shutdown(&sp);

return ret;

}