/*      $NetBSD: haudfw.c,v 1.1 2026/06/11 08:16:44 rumble Exp $        */

/*
 * Copyright (c) 2025 Stephen M. Rumble <rumble@ephemeral.org>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

/*
 * This program facilitates loading the SGI Indigo's "Hollywood Audio" Motorola
 * 56K DSP firmware by translating a loadable text file into a binary blob.
 *
 * The input is a .lod text file and the output is a 128KiB binary that the
 * sgimips/haud(4) driver can copy directly into the DSP's SRAM at byte offset
 * zero.
 *
 * The DSP's memory space is provided by three 8-bit 32KiB SRAMs, which are
 * combined to provide 32768 24-bit DSP words. On the CPU side, this memory is
 * mapped onto 32768 contiguous 32-bit words via the HPC chip.
 *
 * The DSP's X, Y, and P address spaces map on to different subsets of the SRAM
 * memory space. The .lod file specifies where words are loaded into each DSP
 * address space. These addresses need to be translated into offsets into the
 * raw SRAM mapped into the CPU's address space in order to load code and data
 * in the correct locations.
 *
 * Mappings between the DSP addresses and CPU/SRAM addresses were determined by
 * using a test .lod file and IRIX's /usr/etc/audio/dsploader. Dumps of the SRAM
 * showed where the utility wrote test various patterns defined in the test
 * file's fabricated _DATA entries. The results are as follows below and appear
 * to indicate that the DSP is configured in mode 2 ("normal expanded mode"),
 * with 0xe000 as the post-reset start address. The ranges are inclusive.
 *
 *             Section      DSP Word Addr        CPU Word Addr
 *                P        0xd000 - 0xefff      0x1000 - 0x2fff
 *                X        0xb000 - 0xbfff      0x7000 - 0x7fff
 *                X        0xc000 - 0xcfff      0x0000 - 0x0fff
 *                Y        0xb000 - 0xefff      0x3000 - 0x6fff
 *
 * Note that the above CPU addresses are 32-bit word offsets from the HPC's
 * SRAM base address. So multiply by 4 to get the CPU byte address offset.
 */

#include <err.h>
#include <errno.h>
#include <limits.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>

// Dump a C array representing the data to load into SRAM to stdout.
bool c_output = false;

// Larger values > 0 increase debugging output to stderr.
int verbosity = 0;

const char whitespace[] = " \t\r\n";

static void
debug_printf(int level, const char *format, ...)
{
        if (verbosity >= level) {
                va_list ap;
                va_start(ap, format);
                vfprintf(stderr, format, ap);
                va_end(ap);
        }
}

static void
check(bool constraint, const char *format, ...)
{
        if (!constraint) {
                va_list ap;
                va_start(ap, format);
                fprintf(stderr, "error: ");
                verrx(1, format, ap);
                va_end(ap);
        }
}

__attribute__((noreturn))
static void 
fail(const char *format, ...)
{
        va_list ap;
        va_start(ap, format);
        check(false, format, ap);
        // Never hit. exit() squelches warning.
        va_end(ap);
        exit(1);
}

static void
usage(void)
{
        fprintf(stderr, "usage: %s [-cv] input.lod output.bin\n",
            getprogname());
        exit(1);
}

static int
dsp_to_cpu_address(char section, int dsp_addr)
{
        switch (section) {
        case 'P':
                check(0xd000 <= dsp_addr && dsp_addr <= 0xefff,
                      "P section dsp_addr 0x%04x not in [0xd000,0xefff]",
                      dsp_addr);
                return dsp_addr - 0xc000;
        case 'X':
                if (0xb000 <= dsp_addr && dsp_addr <= 0xbfff) {
                        return dsp_addr - 0x4000;
                } else if (0xc000 <= dsp_addr && dsp_addr <= 0xcfff) {
                        return dsp_addr - 0xc000;
                } else {
                        fail("X section dsp_addr 0x%04x not in either "
                            "[0xb000,0xbfff] or [0xc000,0xcfff]", dsp_addr);
                }
        case 'Y':
                check(0xb000 <= dsp_addr && dsp_addr <= 0xefff,
                      "Y section dsp_addr 0x%04x not in [0xb000,0xefff)",
                      dsp_addr);
                return dsp_addr - 0x8000;
        default:
                fail("unknown section type '%c'", section);
        }
}

static void
parse_data_line(const char *line, char *section, int *dsp_data_offset,
    int* section_data_count) {
        char *line_copy = strdup(line);
        char *field = strtok(line_copy, whitespace);
        for (int i = 0; field != NULL; i++, field = strtok(NULL, whitespace)) {
                switch (i) {
                case 0:
                        check(strcmp(field, "_DATA") == 0,
                            "unexpected _DATA header: \"%s\"", field);
                        break;
                case 1:
                        *section = field[0];
                        check(strlen(field) == 1 && strspn(field, "XYPL") == 1,
                            "unexpected section type: \"%s\"", field);
                        break;
                case 2:
                        *dsp_data_offset = strtol(field, NULL, 16);
                        break;
                default:
                        fail("too many fields in _DATA line: \"%s\", "
                           "expected 3", line);
                }
        }
        *section_data_count = 0;
        free(line_copy);
}

int
main(int argc, char **argv)
{
        int ch;
        while ((ch = getopt(argc, argv, "cv")) != -1) {
                switch (ch) {
                case 'c':
                        c_output = true;
                        break;
                case 'v':
                        verbosity++;
                        break;
                case '?':
                default:
                        usage();
                }
        }
        argv += optind;
        argc -= optind;
        if (argc != 2) {
                usage();
        }

        check(strcmp(argv[0], argv[1]) != 0,
            "input and output files must be different");

        const int firmware_words = 32768;
        u_int32_t *firmware = malloc(firmware_words * sizeof(u_int32_t));
        check(firmware != NULL, "unable to malloc buffer for firmware: %s",
            strerror(errno));
        memset(firmware, 0, firmware_words * sizeof(u_int32_t));

        FILE *fp = fopen(argv[0], "r");
        check(fp != NULL, "unable to open input file %s: %s",
            argv[0], strerror(errno));

        int dsp_data_offset = 0;
        int section_data_count = 0;
        char section = '\0';
        char line[100];
        for (int lineno = 1; fgets(line, sizeof(line), fp) != NULL; lineno++) {
                if (strspn(line, whitespace) == strlen(line)) {
                        // skip blank lines
                } else if (strncmp(line, "_START", 6) == 0) {
                        debug_printf(1, "_START on line %d\n", lineno);
                } else if (strncmp(line, "_END", 4) == 0) {
                        if (section != '\0') {
                                debug_printf(1, "%c section had %d words\n",
                                    section, section_data_count);
                        }
                        debug_printf(1, "_END on line %d\n", lineno);
                        break;
                } else if (strncmp(line, "_DATA", 5) == 0) {
                        if (section != '\0') {
                                debug_printf(1, "%c section had %d words\n",
                                    section, section_data_count);
                        }
                        debug_printf(1, "_DATA on line %d\n", lineno);
                        parse_data_line(line, &section, &dsp_data_offset,
                                        &section_data_count);
                        debug_printf(1, "%c data section starting at dsp "
                            "offset 0x%04x\n", section, dsp_data_offset);
                } else {
                        // We must be in a _DATA section
                        check(section != '\0', "parse error on line %d: not in "
                            "a _DATA section", lineno);

                        char *word_str = strtok(line, whitespace);
                        while (word_str != NULL) {
                                u_int32_t word = strtol(word_str, NULL, 16);

                                int cpu_offset = dsp_to_cpu_address(
                                    section != 'L' ? section : (
                                    section_data_count % 2 ?  'Y' : 'X'),
                                    dsp_data_offset);
                                if (section_data_count == 0 || section == 'L') {
                                        debug_printf(1, "  cpu offset 0x%04x "
                                            " (KSEG1 address 0x%08x)\n",
                                            cpu_offset,
                                            0xbfbe0000 + cpu_offset * 4);
                                }

                                check(cpu_offset >= 0 &&
                                    cpu_offset < firmware_words,
                                    "cpu_offset %d is out of bounds for "
                                    "section %c, on line %d", cpu_offset,
                                    section, lineno);

                                firmware[cpu_offset] = word;

                                section_data_count++;
                                dsp_data_offset++;

                                word_str = strtok(NULL, whitespace);
                        }
                }
        }
        fclose(fp);

        if (c_output) {
                printf("// Firmware in big-endian format:\n");
                printf("u_int32_t firmware[%d] = {\n", firmware_words);
                u_int32_t zeroes[16];
                memset(zeroes, 0, sizeof(zeroes));
                for (int i = 0; i < firmware_words; i += 4) { 
                        if (i > 0) {
                                printf(",\n");
                        }
                        if (i < firmware_words - 16 &&
                            memcmp(&firmware[i], zeroes, sizeof(zeroes)) == 0) {
                                // Make empty ranges more compact.
                                printf("\t/* 0x%04x */  0, 0, 0, 0, 0, 0, 0, "
                                    "0, 0, 0, 0, 0, 0, 0, 0, 0", i);
                                i += (16 - 4);
                        } else {
                                printf("\t/* 0x%04x */  0x%08x, 0x%08x, "
                                    "0x%08x, 0x%08x", i,
                                    firmware[i+0], firmware[i+1],
                                    firmware[i+2], firmware[i+3]);
                        }
                }
                printf("\n};\n");
        }

        // Output needs to be big-endian, so swap if we're not on a BE machine.
        for (int i = 0; i < firmware_words; i++) {
                firmware[i] = htonl(firmware[i]);
        }

        FILE *fpout = fopen(argv[1], "w");
        check(fpout != NULL, "unable to open output file %s: %s",
            argv[1], strerror(errno));
        check(fwrite(firmware, sizeof(u_int32_t), firmware_words, fpout) ==
            firmware_words, "failed to write entire output to file %s: %s",
            argv[1], strerror(errno));
        fclose(fpout);

        return 0;
}