// SPDX-License-Identifier: GPL-2.0
#define _GNU_SOURCE

#include <cpuid.h>
#include <err.h>
#include <getopt.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define ARRAY_SIZE(x)   (sizeof(x) / sizeof((x)[0]))
#define min(a, b)       (((a) < (b)) ? (a) : (b))
#define __noreturn      __attribute__((__noreturn__))

typedef unsigned int u32;
typedef unsigned long long u64;

char *def_csv = "/usr/share/misc/cpuid.csv";
char *user_csv;


/* Cover both single-bit flag and multiple-bits fields */
struct bits_desc {
        /* start and end bits */
        int start, end;
        /* 0 or 1 for 1-bit flag */
        int value;
        char simp[32];
        char detail[256];
};

/* descriptor info for eax/ebx/ecx/edx */
struct reg_desc {
        /* number of valid entries */
        int nr;
        struct bits_desc descs[32];
};

enum cpuid_reg {
        R_EAX = 0,
        R_EBX,
        R_ECX,
        R_EDX,
        NR_REGS
};

static const char * const reg_names[] = {
        "EAX", "EBX", "ECX", "EDX",
};

struct subleaf {
        u32 index;
        u32 sub;
        u32 output[NR_REGS];
        struct reg_desc info[NR_REGS];
};

/* Represent one leaf (basic or extended) */
struct cpuid_func {
        /*
         * Array of subleafs for this func, if there is no subleafs
         * then the leafs[0] is the main leaf
         */
        struct subleaf *leafs;
        int nr;
};

enum range_index {
        RANGE_STD = 0,                  /* Standard */
        RANGE_EXT = 0x80000000,         /* Extended */
        RANGE_TSM = 0x80860000,         /* Transmeta */
        RANGE_CTR = 0xc0000000,         /* Centaur/Zhaoxin */
};

#define CPUID_INDEX_MASK                0xffff0000
#define CPUID_FUNCTION_MASK             (~CPUID_INDEX_MASK)

struct cpuid_range {
        /* array of main leafs */
        struct cpuid_func *funcs;
        /* number of valid leafs */
        int nr;
        enum range_index index;
};

static struct cpuid_range ranges[] = {
        {       .index          = RANGE_STD,    },
        {       .index          = RANGE_EXT,    },
        {       .index          = RANGE_TSM,    },
        {       .index          = RANGE_CTR,    },
};

static char *range_to_str(struct cpuid_range *range)
{
        switch (range->index) {
        case RANGE_STD:         return "Standard";
        case RANGE_EXT:         return "Extended";
        case RANGE_TSM:         return "Transmeta";
        case RANGE_CTR:         return "Centaur";
        default:                return NULL;
        }
}

#define __for_each_cpuid_range(range, __condition)                              \
        for (unsigned int i = 0;                                                \
             i < ARRAY_SIZE(ranges) && ((range) = &ranges[i]) && (__condition); \
             i++)

#define for_each_valid_cpuid_range(range)       __for_each_cpuid_range(range, (range)->nr != 0)
#define for_each_cpuid_range(range)             __for_each_cpuid_range(range, true)

struct cpuid_range *index_to_cpuid_range(u32 index)
{
        u32 func_idx = index & CPUID_FUNCTION_MASK;
        u32 range_idx = index & CPUID_INDEX_MASK;
        struct cpuid_range *range;

        for_each_valid_cpuid_range(range) {
                if (range->index == range_idx && (u32)range->nr > func_idx)
                        return range;
        }

        return NULL;
}

static bool show_details;
static bool show_raw;
static bool show_flags_only = true;
static u32 user_index = 0xFFFFFFFF;
static u32 user_sub = 0xFFFFFFFF;
static int flines;

/*
 * Force using <cpuid.h> __cpuid_count() instead of __cpuid(). The
 * latter leaves ECX uninitialized, which can break CPUID queries.
 */

#define cpuid(leaf, a, b, c, d)                         \
        __cpuid_count(leaf, 0, a, b, c, d)

#define cpuid_count(leaf, subleaf, a, b, c, d)          \
        __cpuid_count(leaf, subleaf, a, b, c, d)

static inline bool has_subleafs(u32 f)
{
        u32 with_subleaves[] = {
                0x4,  0x7,  0xb,  0xd,  0xf,  0x10, 0x12,
                0x14, 0x17, 0x18, 0x1b, 0x1d, 0x1f, 0x23,
                0x8000001d, 0x80000020, 0x80000026,
        };

        for (unsigned i = 0; i < ARRAY_SIZE(with_subleaves); i++)
                if (f == with_subleaves[i])
                        return true;

        return false;
}

static void leaf_print_raw(struct subleaf *leaf)
{
        if (has_subleafs(leaf->index)) {
                if (leaf->sub == 0)
                        printf("0x%08x: subleafs:\n", leaf->index);

                printf(" %2d: EAX=0x%08x, EBX=0x%08x, ECX=0x%08x, EDX=0x%08x\n", leaf->sub,
                       leaf->output[0], leaf->output[1], leaf->output[2], leaf->output[3]);
        } else {
                printf("0x%08x: EAX=0x%08x, EBX=0x%08x, ECX=0x%08x, EDX=0x%08x\n", leaf->index,
                       leaf->output[0], leaf->output[1], leaf->output[2], leaf->output[3]);
        }
}

/* Return true is the input eax/ebx/ecx/edx are all zero */
static bool cpuid_store(struct cpuid_range *range, u32 f, int subleaf,
                        u32 a, u32 b, u32 c, u32 d)
{
        struct cpuid_func *func;
        struct subleaf *leaf;
        int s = 0;

        if (a == 0 && b == 0 && c == 0 && d == 0)
                return true;

        /*
         * Cut off vendor-prefix from CPUID function as we're using it as an
         * index into ->funcs.
         */
        func = &range->funcs[f & CPUID_FUNCTION_MASK];

        if (!func->leafs) {
                func->leafs = malloc(sizeof(struct subleaf));
                if (!func->leafs)
                        err(EXIT_FAILURE, NULL);

                func->nr = 1;
        } else {
                s = func->nr;
                func->leafs = realloc(func->leafs, (s + 1) * sizeof(*leaf));
                if (!func->leafs)
                        err(EXIT_FAILURE, NULL);

                func->nr++;
        }

        leaf = &func->leafs[s];

        leaf->index = f;
        leaf->sub = subleaf;
        leaf->output[R_EAX] = a;
        leaf->output[R_EBX] = b;
        leaf->output[R_ECX] = c;
        leaf->output[R_EDX] = d;

        return false;
}

static void raw_dump_range(struct cpuid_range *range)
{
        printf("%s Leafs :\n", range_to_str(range));
        printf("================\n");

        for (u32 f = 0; (int)f < range->nr; f++) {
                struct cpuid_func *func = &range->funcs[f];

                /* Skip leaf without valid items */
                if (!func->nr)
                        continue;

                /* First item is the main leaf, followed by all subleafs */
                for (int i = 0; i < func->nr; i++)
                        leaf_print_raw(&func->leafs[i]);
        }
}

#define MAX_SUBLEAF_NUM         64
#define MAX_RANGE_INDEX_OFFSET  0xff
void setup_cpuid_range(struct cpuid_range *range)
{
        u32 max_func, range_funcs_sz;
        u32 eax, ebx, ecx, edx;

        cpuid(range->index, max_func, ebx, ecx, edx);

        /*
         * If the CPUID range's maximum function value is garbage, then it
         * is not recognized by this CPU.  Set the range's number of valid
         * leaves to zero so that for_each_valid_cpu_range() can ignore it.
         */
        if (max_func < range->index || max_func > (range->index + MAX_RANGE_INDEX_OFFSET)) {
                range->nr = 0;
                return;
        }

        range->nr = (max_func & CPUID_FUNCTION_MASK) + 1;
        range_funcs_sz = range->nr * sizeof(struct cpuid_func);

        range->funcs = malloc(range_funcs_sz);
        if (!range->funcs)
                err(EXIT_FAILURE, NULL);

        memset(range->funcs, 0, range_funcs_sz);

        for (u32 f = range->index; f <= max_func; f++) {
                u32 max_subleaf = MAX_SUBLEAF_NUM;
                bool allzero;

                cpuid(f, eax, ebx, ecx, edx);

                allzero = cpuid_store(range, f, 0, eax, ebx, ecx, edx);
                if (allzero)
                        continue;

                if (!has_subleafs(f))
                        continue;

                /*
                 * Some can provide the exact number of subleafs,
                 * others have to be tried (0xf)
                 */
                if (f == 0x7 || f == 0x14 || f == 0x17 || f == 0x18 || f == 0x1d)
                        max_subleaf = min((eax & 0xff) + 1, max_subleaf);
                if (f == 0xb)
                        max_subleaf = 2;
                if (f == 0x1f)
                        max_subleaf = 6;
                if (f == 0x23)
                        max_subleaf = 4;
                if (f == 0x80000020)
                        max_subleaf = 4;
                if (f == 0x80000026)
                        max_subleaf = 5;

                for (u32 subleaf = 1; subleaf < max_subleaf; subleaf++) {
                        cpuid_count(f, subleaf, eax, ebx, ecx, edx);

                        allzero = cpuid_store(range, f, subleaf, eax, ebx, ecx, edx);
                        if (allzero)
                                continue;
                }

        }
}

/*
 * The basic row format for cpuid.csv  is
 *      LEAF,SUBLEAF,register_name,bits,short name,long description
 *
 * like:
 *      0,    0,  EAX,   31:0, max_basic_leafs,  Max input value for supported subleafs
 *      1,    0,  ECX,      0, sse3,  Streaming SIMD Extensions 3(SSE3)
 */
static void parse_line(char *line)
{
        char *str;
        struct cpuid_range *range;
        struct cpuid_func *func;
        struct subleaf *leaf;
        u32 index;
        char buffer[512];
        char *buf;
        /*
         * Tokens:
         *  1. leaf
         *  2. subleaf
         *  3. register
         *  4. bits
         *  5. short name
         *  6. long detail
         */
        char *tokens[6];
        struct reg_desc *reg;
        struct bits_desc *bdesc;
        int reg_index;
        char *start, *end;
        u32 subleaf_start, subleaf_end;
        unsigned bit_start, bit_end;

        /* Skip comments and NULL line */
        if (line[0] == '#' || line[0] == '\n')
                return;

        strncpy(buffer, line, 511);
        buffer[511] = 0;
        str = buffer;
        for (int i = 0; i < 5; i++) {
                tokens[i] = strtok(str, ",");
                if (!tokens[i])
                        goto err_exit;
                str = NULL;
        }
        tokens[5] = strtok(str, "\n");
        if (!tokens[5])
                goto err_exit;

        /* index/main-leaf */
        index = strtoull(tokens[0], NULL, 0);

        /*
         * Skip line parsing if the index is not covered by known-valid
         * CPUID ranges on this CPU.
         */
        range = index_to_cpuid_range(index);
        if (!range)
                return;

        /* Skip line parsing if the index CPUID output is all zero */
        index &= CPUID_FUNCTION_MASK;
        func = &range->funcs[index];
        if (!func->nr)
                return;

        /* subleaf */
        buf = tokens[1];
        end = strtok(buf, ":");
        start = strtok(NULL, ":");
        subleaf_end = strtoul(end, NULL, 0);

        /* A subleaf range is given? */
        if (start) {
                subleaf_start = strtoul(start, NULL, 0);
                subleaf_end = min(subleaf_end, (u32)(func->nr - 1));
                if (subleaf_start > subleaf_end)
                        return;
        } else {
                subleaf_start = subleaf_end;
                if (subleaf_start > (u32)(func->nr - 1))
                        return;
        }

        /* register */
        buf = tokens[2];
        if (strcasestr(buf, "EAX"))
                reg_index = R_EAX;
        else if (strcasestr(buf, "EBX"))
                reg_index = R_EBX;
        else if (strcasestr(buf, "ECX"))
                reg_index = R_ECX;
        else if (strcasestr(buf, "EDX"))
                reg_index = R_EDX;
        else
                goto err_exit;

        /* bit flag or bits field */
        buf = tokens[3];
        end = strtok(buf, ":");
        start = strtok(NULL, ":");
        bit_end = strtoul(end, NULL, 0);
        bit_start = (start) ? strtoul(start, NULL, 0) : bit_end;

        for (u32 sub = subleaf_start; sub <= subleaf_end; sub++) {
                leaf = &func->leafs[sub];
                reg = &leaf->info[reg_index];
                bdesc = &reg->descs[reg->nr++];

                bdesc->end = bit_end;
                bdesc->start = bit_start;
                strcpy(bdesc->simp, strtok(tokens[4], " \t"));
                strcpy(bdesc->detail, tokens[5]);
        }
        return;

err_exit:
        warnx("Wrong line format:\n"
              "\tline[%d]: %s", flines, line);
}

/* Parse csv file, and construct the array of all leafs and subleafs */
static void parse_text(void)
{
        FILE *file;
        char *filename, *line = NULL;
        size_t len = 0;
        int ret;

        if (show_raw)
                return;

        filename = user_csv ? user_csv : def_csv;
        file = fopen(filename, "r");
        if (!file) {
                /* Fallback to a csv in the same dir */
                file = fopen("./cpuid.csv", "r");
        }

        if (!file)
                err(EXIT_FAILURE, "%s", filename);

        while (1) {
                ret = getline(&line, &len, file);
                flines++;
                if (ret > 0)
                        parse_line(line);

                if (feof(file))
                        break;
        }

        fclose(file);
}

static void show_reg(const struct reg_desc *rdesc, u32 value)
{
        const struct bits_desc *bdesc;
        int start, end;
        u32 mask;

        for (int i = 0; i < rdesc->nr; i++) {
                bdesc = &rdesc->descs[i];

                start = bdesc->start;
                end = bdesc->end;
                if (start == end) {
                        /* single bit flag */
                        if (value & (1 << start))
                                printf("\t%-20s %s%s%s\n",
                                        bdesc->simp,
                                        show_flags_only ? "" : "\t\t\t",
                                        show_details ? "-" : "",
                                        show_details ? bdesc->detail : ""
                                        );
                } else {
                        /* bit fields */
                        if (show_flags_only)
                                continue;

                        mask = ((u64)1 << (end - start + 1)) - 1;
                        printf("\t%-20s\t: 0x%-8x\t%s%s\n",
                                        bdesc->simp,
                                        (value >> start) & mask,
                                        show_details ? "-" : "",
                                        show_details ? bdesc->detail : ""
                                        );
                }
        }
}

static void show_reg_header(bool has_entries, u32 leaf, u32 subleaf, const char *reg_name)
{
        if (show_details && has_entries)
                printf("CPUID_0x%x_%s[0x%x]:\n", leaf, reg_name, subleaf);
}

static void show_leaf(struct subleaf *leaf)
{
        if (show_raw)
                leaf_print_raw(leaf);

        for (int i = R_EAX; i < NR_REGS; i++) {
                show_reg_header((leaf->info[i].nr > 0), leaf->index, leaf->sub, reg_names[i]);
                show_reg(&leaf->info[i], leaf->output[i]);
        }

        if (!show_raw && show_details)
                printf("\n");
}

static void show_func(struct cpuid_func *func)
{
        for (int i = 0; i < func->nr; i++)
                show_leaf(&func->leafs[i]);
}

static void show_range(struct cpuid_range *range)
{
        for (int i = 0; i < range->nr; i++)
                show_func(&range->funcs[i]);
}

static inline struct cpuid_func *index_to_func(u32 index)
{
        u32 func_idx = index & CPUID_FUNCTION_MASK;
        struct cpuid_range *range;

        range = index_to_cpuid_range(index);
        if (!range)
                return NULL;

        return &range->funcs[func_idx];
}

static void show_info(void)
{
        struct cpuid_range *range;
        struct cpuid_func *func;

        if (show_raw) {
                /* Show all of the raw output of 'cpuid' instr */
                for_each_valid_cpuid_range(range)
                        raw_dump_range(range);
                return;
        }

        if (user_index != 0xFFFFFFFF) {
                /* Only show specific leaf/subleaf info */
                func = index_to_func(user_index);
                if (!func)
                        errx(EXIT_FAILURE, "Invalid input leaf (0x%x)", user_index);

                /* Dump the raw data also */
                show_raw = true;

                if (user_sub != 0xFFFFFFFF) {
                        if (user_sub + 1 > (u32)func->nr) {
                                errx(EXIT_FAILURE, "Leaf 0x%x has no valid subleaf = 0x%x",
                                     user_index, user_sub);
                        }

                        show_leaf(&func->leafs[user_sub]);
                        return;
                }

                show_func(func);
                return;
        }

        printf("CPU features:\n=============\n\n");
        for_each_valid_cpuid_range(range)
                show_range(range);
}

static void __noreturn usage(int exit_code)
{
        errx(exit_code, "kcpuid [-abdfhr] [-l leaf] [-s subleaf]\n"
             "\t-a|--all             Show both bit flags and complex bit fields info\n"
             "\t-b|--bitflags        Show boolean flags only\n"
             "\t-d|--detail          Show details of the flag/fields (default)\n"
             "\t-f|--flags           Specify the CPUID CSV file\n"
             "\t-h|--help            Show usage info\n"
             "\t-l|--leaf=index      Specify the leaf you want to check\n"
             "\t-r|--raw             Show raw CPUID data\n"
             "\t-s|--subleaf=sub     Specify the subleaf you want to check"
        );
}

static struct option opts[] = {
        { "all", no_argument, NULL, 'a' },              /* show both bit flags and fields */
        { "bitflags", no_argument, NULL, 'b' },         /* only show bit flags, default on */
        { "detail", no_argument, NULL, 'd' },           /* show detail descriptions */
        { "file", required_argument, NULL, 'f' },       /* use user's cpuid file */
        { "help", no_argument, NULL, 'h'},              /* show usage */
        { "leaf", required_argument, NULL, 'l'},        /* only check a specific leaf */
        { "raw", no_argument, NULL, 'r'},               /* show raw CPUID leaf data */
        { "subleaf", required_argument, NULL, 's'},     /* check a specific subleaf */
        { NULL, 0, NULL, 0 }
};

static void parse_options(int argc, char *argv[])
{
        int c;

        while ((c = getopt_long(argc, argv, "abdf:hl:rs:",
                                        opts, NULL)) != -1)
                switch (c) {
                case 'a':
                        show_flags_only = false;
                        break;
                case 'b':
                        show_flags_only = true;
                        break;
                case 'd':
                        show_details = true;
                        break;
                case 'f':
                        user_csv = optarg;
                        break;
                case 'h':
                        usage(EXIT_SUCCESS);
                case 'l':
                        /* main leaf */
                        user_index = strtoul(optarg, NULL, 0);
                        break;
                case 'r':
                        show_raw = true;
                        break;
                case 's':
                        /* subleaf */
                        user_sub = strtoul(optarg, NULL, 0);
                        break;
                default:
                        usage(EXIT_FAILURE);
                }
}

/*
 * Do 4 things in turn:
 * 1. Parse user options
 * 2. Parse and store all the CPUID leaf data supported on this platform
 * 2. Parse the csv file, while skipping leafs which are not available
 *    on this platform
 * 3. Print leafs info based on user options
 */
int main(int argc, char *argv[])
{
        struct cpuid_range *range;

        parse_options(argc, argv);

        /* Setup the cpuid leafs of current platform */
        for_each_cpuid_range(range)
                setup_cpuid_range(range);

        /* Read and parse the 'cpuid.csv' */
        parse_text();

        show_info();
        return 0;
}