// 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 <fcntl.h>

#include <sys/mman.h>

#include <assert.h>

#include <errno.h>

#include <pthread.h>

#include <limits.h>

#include <dlfcn.h>

#include "common.h"

#include "pipe.h"

/* read the CPU ID register data on x86 */

static inline void x86_cpuid(unsigned int *eax, unsigned int *ebx,

unsigned int *ecx, unsigned int *edx)

{

/* data type is passed in on eax (and sometimes ecx) */

asm volatile("cpuid"

: "=a" (*eax), "=b" (*ebx), "=c" (*ecx), "=d" (*edx)

: "0" (*eax), "2" (*ecx));

}

/*

* Check core type for E cores. If non hybrid then it does not matter.

*/

static inline int use_this_core(struct sof_pipe *sp)

{

/* CPUID - set eax to 0x1a for hybrid core types */

unsigned int eax = 0x1a, ebx = 0, ecx = 0, edx = 0;

char core_mask;

/* get the processor core type we are running on now */

x86_cpuid(&eax, &ebx, &ecx, &edx);

/* core type 0x20 is atom, 0x40 is core */

core_mask = (eax >> 24) & 0xFF;

switch (core_mask) {

case 0x20:

fprintf(sp->log, "found E core\n");

if (sp->use_E_core)

return 1;

return 0;

case 0x40:

fprintf(sp->log, "found P core\n");

if (sp->use_P_core)

return 1;

return 0;

default:

/* non hybrid arch, just use first core */

fprintf(sp->log, "found non hybrid core topology\n");

return 1;

}

}

/* sof-pipe needs to be sticky to the current core for low latency */

int pipe_set_affinity(struct sof_pipe *sp)

{

cpu_set_t cpuset;

pthread_t thread;

long core_count = sysconf(_SC_NPROCESSORS_ONLN);

int i;

int err;

/* Set affinity mask to core */

thread = pthread_self();

CPU_ZERO(&cpuset);

/* find the first E core (usually come after the P cores ?) */

for (i = core_count - 1; i >= 0; i--) {

CPU_ZERO(&cpuset);

CPU_SET(i, &cpuset);

/* change our core to i */

err = pthread_setaffinity_np(thread, sizeof(cpuset), &cpuset);

if (err != 0) {

fprintf(sp->log, "error: failed to set CPU affinity to core %d: %s\n",

i, strerror(err));

return err;

}

/* should we use this core ? */

if (use_this_core(sp))

break;

}

return 0;

}

/* set ipc thread to low priority */

int pipe_set_ipc_lowpri(struct sof_pipe *sp)

{

pthread_attr_t attr;

struct sched_param param;

int err;

/* attempt to set thread priority - needs suid */

fprintf(sp->log, "pipe: set IPC low priority\n");

err = pthread_attr_init(&attr);

if (err < 0) {

fprintf(sp->log, "error: can't create thread attr %d %s\n", err, strerror(errno));

return err;

}

err = pthread_attr_setschedpolicy(&attr, SCHED_OTHER);

if (err < 0) {

fprintf(sp->log, "error: can't set thread policy %d %s\n", err, strerror(errno));

return err;

}

param.sched_priority = 0;

err = pthread_attr_setschedparam(&attr, &param);

if (err < 0) {

fprintf(sp->log, "error: can't set thread sched param %d %s\n",

err, strerror(errno));

return err;

}

return 0;

}

/* set pipeline to realtime priority */

int pipe_set_rt(struct sof_pipe *sp)

{

pthread_attr_t attr;

struct sched_param param;

int err;

uid_t uid = getuid();

uid_t euid = geteuid();

/* do we have elevated privileges to attempt RT priority */

if (uid < 0 || uid != euid) {

/* attempt to set thread priority - needs suid */

fprintf(sp->log, "pipe: set RT priority\n");

err = pthread_attr_init(&attr);

if (err < 0) {

fprintf(sp->log, "error: can't create thread attr %d %s\n",

err, strerror(errno));

return err;

}

err = pthread_attr_setschedpolicy(&attr, SCHED_FIFO);

if (err < 0) {

fprintf(sp->log, "error: can't set thread policy %d %s\n",

err, strerror(errno));

return err;

}

param.sched_priority = 80;

err = pthread_attr_setschedparam(&attr, &param);

if (err < 0) {

fprintf(sp->log, "error: can't set thread sched param %d %s\n",

err, strerror(errno));

return err;

}

err = pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED);

if (err < 0) {

fprintf(sp->log, "error: can't set thread inherit %d %s\n",

err, strerror(errno));

return err;

}

} else {

fprintf(sp->log, "error: no elevated privileges for RT. uid %d euid %d\n",

uid, euid);

}

return 0;

}