UrmPlatformAL.h

// Copyright (c) Qualcomm Technologies, Inc. and/or its subsidiaries.
// SPDX-License-Identifier: BSD-3-Clause-Clear
 
#ifndef COMMON_UTILS_H
#define COMMON_UTILS_H
 
#ifdef __cplusplus
#include <cstdint>
#include <cstring>
#else
#include <stdint.h>
#include <string.h>
#endif
 
// Use these options to configure a well defined value
#define OPT_WITHMAX 0x00000001
#define OPT_WITHMIN 0x00000002
 
// Used to define the new config value, relative to the already configured value
#define OPT_WITHREL 0X00000004
 
typedef struct {
    uint32_t mResCode;
    int32_t mResInfo;
    int32_t mOptionalInfo; 
    int32_t mNumValues;
 
    union {
        int32_t value; 
        int32_t* values; 
    } mResValue; 
} SysResource;
 
enum RequestPriority {
    REQ_PRIORITY_HIGH = 0,
    REQ_PRIORITY_LOW,
    NUMBER_OF_RQUEST_PRIORITIES
};
 
enum Modes {
    MODE_RESUME = 0x01, 
    MODE_SUSPEND = 0x02, 
    MODE_DOZE = 0x04 
};
 
// Helper Macros to set Request and SysResource attributes.
#define SET_REQUEST_PRIORITY(properties, priority)({                                          \
    int32_t retVal;                                                                           \
    if(properties < 0 || priority < 0 || priority >= NUMBER_OF_RQUEST_PRIORITIES) {           \
        retVal = -1;                                                                          \
    } else {                                                                                  \
        retVal = (int32_t) ((properties | priority));                                         \
    }                                                                                         \
    retVal;                                                                                   \
})                                                                                            \
 
#define ADD_ALLOWED_MODE(properties, mode)({                                                  \
    int32_t retVal;                                                                           \
    if(properties < 0 || mode < MODE_RESUME || mode > MODE_DOZE) {                            \
        retVal = -1;                                                                          \
    } else {                                                                                  \
        retVal = (int32_t) (properties | (((properties >> 8) | mode) << 8));                  \
    }                                                                                         \
    retVal;                                                                                   \
})                                                                                            \
 
#define EXTRACT_REQUEST_PRIORITY(properties)({                                                \
    (int8_t) ((properties) & ((1 << 8) - 1));                                                 \
})
 
#define EXTRACT_ALLOWED_MODES(properties)({                                                   \
    (int8_t) ((properties >> 8) & ((1 << 8) - 1));                                            \
})                                                                                            \
 
// Define Utilities to parse and set the mResInfo field in Resource struct.
#define EXTRACT_RESOURCE_CORE_VALUE(resInfo)({                                                \
    (int8_t) ((resInfo) & ((1 << 8) - 1));                                                    \
})                                                                                            \
 
#define EXTRACT_RESOURCE_CLUSTER_VALUE(resInfo)({                                             \
    (int8_t) ((resInfo >> 8) & ((1 << 8) - 1));                                               \
})                                                                                            \
 
#define EXTRACT_RESOURCE_MPAM_VALUE(resInfo)({                                                \
    (int8_t) ((resInfo >> 16) & ((1 << 8) - 1));                                              \
})                                                                                            \
 
#define SET_RESOURCE_CORE_VALUE(resInfo, newValue)({                                          \
    (int32_t) ((resInfo ^ EXTRACT_RESOURCE_CORE_VALUE(resInfo)) | newValue);                  \
})                                                                                            \
 
#define SET_RESOURCE_CLUSTER_VALUE(resInfo, newValue)({                                       \
    (int32_t) ((resInfo ^ (EXTRACT_RESOURCE_CLUSTER_VALUE(resInfo) << 8)) | (newValue << 8)); \
})                                                                                            \
 
#define SET_RESOURCE_MPAM_VALUE(resInfo, newValue)({                                          \
    (int32_t) ((resInfo ^ (EXTRACT_RESOURCE_MPAM_VALUE(resInfo) << 16)) | (newValue << 16));  \
})                                                                                            \
 
#define GET_SIGNAL_ID(sigCode)({                                                              \
    (uint32_t) ((uint64_t)sigCode >> 32);                                                     \
})                                                                                            \
 
#define GET_SIGNAL_TYPE(sigCode)({                                                            \
    (uint32_t) (((uint64_t)sigCode) & 0xffffffff);                                            \
})                                                                                            \
 
#define CONSTRUCT_RES_CODE(resType, resCode) ({                                               \
    uint32_t resourceBitmap = 0;                                                              \
    resourceBitmap |= ((uint32_t)resCode);                                                    \
    resourceBitmap |= ((uint32_t)resType << 16);                                              \
    resourceBitmap;                                                                           \
})                                                                                            \
 
#define CONSTRUCT_SIG_CODE(sigCat, sigID) ({                                                  \
    uint32_t signalBitmap = 0;                                                                \
    signalBitmap |= ((uint32_t)sigID);                                                        \
    signalBitmap |= ((uint32_t)sigCat << 16);                                                 \
    signalBitmap;                                                                             \
})                                                                                            \
 
#define CUSTOM(opCode) ({                                                                     \
    uint32_t opBitmap = opCode;                                                               \
    opBitmap |= (1 << 31);                                                                    \
    opBitmap;                                                                                 \
})                                                                                            \
 
// Common ResCode and ResInfo codes
// These enums can be used directly as part of tuneResources API, to uniquely
// specify the resource to be tuned.
// For target-specific resources use the custom ResourcesConfig.yaml file for
// declaration. These values are only applicable for upstream resources.
#define RES_CODE_LIST                     \
/* Resources */                           \
X(RES_SCALE_MIN_FREQ,         0x00040000) \
X(RES_SCALE_MAX_FREQ,         0x00040001) \
X(RES_RATE_LIMIT_US,          0x00040002) \
X(RES_CPU_IDLE_DISABLE_ST0,   0x00040003) \
X(RES_CPU_IDLE_DISABLE_ST1,   0x00040004) \
X(RES_CPU_IDLE_DISABLE_ST2,   0x00040005) \
X(RES_SCHED_UTIL_CLAMP_MIN,   0x00030000) \
X(RES_SCHED_UTIL_CLAMP_MAX,   0x00030001) \
X(RES_SCHED_ENERGY_AWARE,     0x00030002) \
X(RES_SCHED_RT_RUNTIME,       0x00030003) \
X(RES_CPU_DMA_LATENCY,        0x00010000) \
X(RES_PM_QOS_LATENCY,         0x00010001) \
X(RES_DEVFREQ_GPU_MAX,        0x00050000) \
X(RES_DEVFREQ_GPU_MIN,        0x00050001) \
X(RES_DEVFREQ_GPU_POLL_INTV,  0x00050002) \
X(RES_DEVFREQ_UFS_MAX,        0x000a0000) \
X(RES_DEVFREQ_UFS_MIN,        0x000a0001) \
X(RES_DEVFREQ_UFS_POLL_INTV,  0x000a0002) \
/* cgroup resources */                    \
X(RES_CGRP_MOVE_PID,          0x00090000) \
X(RES_CGRP_MOVE_TID,          0x00090001) \
X(RES_CGRP_RUN_CORES,         0x00090002) \
X(RES_CGRP_RUN_CORES_EXCL,    0x00090003) \
X(RES_CGRP_FREEZE,            0x00090004) \
X(RES_CGRP_LIMIT_CPU_TIME,    0x00090005) \
X(RES_CGRP_RUN_WHEN_CPU_IDLE, 0x00090006) \
X(RES_CGRP_UCLAMP_MIN,        0x00090007) \
X(RES_CGRP_UCLAMP_MAX,        0x00090008) \
X(RES_CGRP_REL_CPU_WEIGHT,    0x00090009) \
X(RES_CGRP_HIGH_MEM,          0x0009000a) \
X(RES_CGRP_MAX_MEM,           0x0009000b) \
X(RES_CGRP_LOW_MEM,           0x0009000c) \
X(RES_CGRP_MIN_MEM,           0x0009000d) \
X(RES_CGRP_SWAP_MAX_MEMORY,   0x0009000e) \
X(RES_CGRP_IO_WEIGHT,         0x0009000f) \
X(RES_CGRP_BFQ_IO_WEIGHT,     0x00090010) \
X(RES_CGRP_CPU_LATENCY,       0x00090011) \
X(FOCUSED_CGROUP_IDENTIFIER,  0x00000004) \
/* Cluster and Core Configurations */     \
X(CLUSTER_LITTLE_ALL_CORES,   0x00000000) \
X(CLUSTER_LITTLE_CORE_0,      0x00000001) \
X(CLUSTER_LITTLE_CORE_1,      0x00000002) \
X(CLUSTER_LITTLE_CORE_2,      0x00000003) \
X(CLUSTER_LITTLE_CORE_3,      0x00000004) \
X(CLUSTER_BIG_ALL_CORES,      0x00000100) \
X(CLUSTER_BIG_CORE_0,         0x00000101) \
X(CLUSTER_BIG_CORE_1,         0x00000102) \
X(CLUSTER_BIG_CORE_2,         0x00000103) \
X(CLUSTER_BIG_CORE_3,         0x00000104) \
X(CLUSTER_PLUS_ALL_CORES,     0x00000200) \
X(CLUSTER_PLUS_CORE_0,        0x00000201) \
X(CLUSTER_PLUS_CORE_1,        0x00000202) \
X(CLUSTER_PLUS_CORE_2,        0x00000203) \
X(CLUSTER_PLUS_CORE_3,        0x00000204) \
/* misc */                                \
X(DEFAULT_SIGNAL_TYPE,        0x00000000) \
 
enum ResCodesDef {
#define X(name, value) name = value,
    RES_CODE_LIST
#undef X
};
 
typedef struct {
    const char* name;
    uint32_t code;
} ResPair;
 
static ResPair resCodeMapping[] = {
#define X(name, value) {#name, (uint32_t)value,},
    RES_CODE_LIST
#undef X
};
 
static inline uint32_t getResCodeFromString(const char* strCode, int8_t* found) {
    int32_t size = sizeof(resCodeMapping) / sizeof(resCodeMapping[0]);
    for(int32_t i = 0; i < size; i++) {
        if(strcmp(resCodeMapping[i].name, strCode) == 0) {
            *found = true;
            return resCodeMapping[i].code;
        }
    }
 
    return 0;
}
 
//Predefined Resource Types
enum {
    CPU_LPM    = 0x00,
    CACHE_MGMT = 0x01,
    CPU_SCHED  = 0x02,
    CPU_FREQ   = 0x03,
    GPU_OPP    = 0x04,
    NPU_OPP    = 0x06,
    MEMORY_QOS = 0x07,
    MPAM_QOS   = 0x08,
    CGRP_OPS   = 0x09,
    STORAGE_IO = 0x0a,
    CUSTOM     = 0x80
};
 
// Predefined Signal Categories
enum {
    URM_SIG_CAT_TEST       = 0x01,
    URM_SIG_CAT_GENERIC    = 0x02,
    URM_SIG_CAT_MULTIMEDIA = 0x03,
    URM_SIG_CAT_GAMING     = 0x04,
    URM_SIG_CAT_BROWSER    = 0x05,
    URM_SIG_CAT_CUSTOM     = 0x80
};
 
//Signal codes
enum {
    // Generic
    URM_SIG_APP_OPEN                    = 0x00020001,
    URM_SIG_BROWSER_APP_OPEN            = 0x00020002,
    URM_SIG_GAME_APP_OPEN               = 0x00020003,
    URM_SIG_MULTIMEDIA_APP_OPEN         = 0x00020004,
 
    // Multimedia
    URM_SIG_VIDEO_DECODE                = 0x00030001,
    URM_SIG_CAMERA_PREVIEW              = 0x00030002,
    URM_SIG_CAMERA_ENCODE               = 0x00030003,
    URM_SIG_CAMERA_ENCODE_MULTI_STREAMS = 0x00030004,
    URM_SIG_ENCODE_DECODE               = 0x00030005,
};
 
#endif