// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * altera.c
 *
 * altera FPGA driver
 *
 * Copyright (C) Altera Corporation 1998-2001
 * Copyright (C) 2010,2011 NetUP Inc.
 * Copyright (C) 2010,2011 Igor M. Liplianin <liplianin@netup.ru>
 */

#include <linux/unaligned.h>
#include <linux/ctype.h>
#include <linux/string.h>
#include <linux/firmware.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <misc/altera.h>
#include "altera-exprt.h"
#include "altera-jtag.h"

static int debug = 1;
module_param(debug, int, 0644);
MODULE_PARM_DESC(debug, "enable debugging information");

MODULE_DESCRIPTION("altera FPGA kernel module");
MODULE_AUTHOR("Igor M. Liplianin  <liplianin@netup.ru>");
MODULE_LICENSE("GPL");

#define dprintk(args...) \
        if (debug) { \
                printk(KERN_DEBUG args); \
        }

enum altera_fpga_opcode {
        OP_NOP = 0,
        OP_DUP,
        OP_SWP,
        OP_ADD,
        OP_SUB,
        OP_MULT,
        OP_DIV,
        OP_MOD,
        OP_SHL,
        OP_SHR,
        OP_NOT,
        OP_AND,
        OP_OR,
        OP_XOR,
        OP_INV,
        OP_GT,
        OP_LT,
        OP_RET,
        OP_CMPS,
        OP_PINT,
        OP_PRNT,
        OP_DSS,
        OP_DSSC,
        OP_ISS,
        OP_ISSC,
        OP_DPR = 0x1c,
        OP_DPRL,
        OP_DPO,
        OP_DPOL,
        OP_IPR,
        OP_IPRL,
        OP_IPO,
        OP_IPOL,
        OP_PCHR,
        OP_EXIT,
        OP_EQU,
        OP_POPT,
        OP_ABS = 0x2c,
        OP_BCH0,
        OP_PSH0 = 0x2f,
        OP_PSHL = 0x40,
        OP_PSHV,
        OP_JMP,
        OP_CALL,
        OP_NEXT,
        OP_PSTR,
        OP_SINT = 0x47,
        OP_ST,
        OP_ISTP,
        OP_DSTP,
        OP_SWPN,
        OP_DUPN,
        OP_POPV,
        OP_POPE,
        OP_POPA,
        OP_JMPZ,
        OP_DS,
        OP_IS,
        OP_DPRA,
        OP_DPOA,
        OP_IPRA,
        OP_IPOA,
        OP_EXPT,
        OP_PSHE,
        OP_PSHA,
        OP_DYNA,
        OP_EXPV = 0x5c,
        OP_COPY = 0x80,
        OP_REVA,
        OP_DSC,
        OP_ISC,
        OP_WAIT,
        OP_VS,
        OP_CMPA = 0xc0,
        OP_VSC,
};

struct altera_procinfo {
        char                    *name;
        u8                      attrs;
        struct altera_procinfo  *next;
};

/* This function checks if enough parameters are available on the stack. */
static int altera_check_stack(int stack_ptr, int count, int *status)
{
        if (stack_ptr < count) {
                *status = -EOVERFLOW;
                return 0;
        }

        return 1;
}

static void altera_export_int(char *key, s32 value)
{
        dprintk("Export: key = \"%s\", value = %d\n", key, value);
}

#define HEX_LINE_CHARS 72
#define HEX_LINE_BITS (HEX_LINE_CHARS * 4)

static void altera_export_bool_array(char *key, u8 *data, s32 count)
{
        char string[HEX_LINE_CHARS + 1];
        s32 i, offset;
        u32 size, line, lines, linebits, value, j, k;

        if (count > HEX_LINE_BITS) {
                dprintk("Export: key = \"%s\", %d bits, value = HEX\n",
                                                        key, count);
                lines = (count + (HEX_LINE_BITS - 1)) / HEX_LINE_BITS;

                for (line = 0; line < lines; ++line) {
                        if (line < (lines - 1)) {
                                linebits = HEX_LINE_BITS;
                                size = HEX_LINE_CHARS;
                                offset = count - ((line + 1) * HEX_LINE_BITS);
                        } else {
                                linebits =
                                        count - ((lines - 1) * HEX_LINE_BITS);
                                size = (linebits + 3) / 4;
                                offset = 0L;
                        }

                        string[size] = '\0';
                        j = size - 1;
                        value = 0;

                        for (k = 0; k < linebits; ++k) {
                                i = k + offset;
                                if (data[i >> 3] & (1 << (i & 7)))
                                        value |= (1 << (i & 3));
                                if ((i & 3) == 3) {
                                        sprintf(&string[j], "%1x", value);
                                        value = 0;
                                        --j;
                                }
                        }
                        if ((k & 3) > 0)
                                sprintf(&string[j], "%1x", value);

                        dprintk("%s\n", string);
                }

        } else {
                size = (count + 3) / 4;
                string[size] = '\0';
                j = size - 1;
                value = 0;

                for (i = 0; i < count; ++i) {
                        if (data[i >> 3] & (1 << (i & 7)))
                                value |= (1 << (i & 3));
                        if ((i & 3) == 3) {
                                sprintf(&string[j], "%1x", value);
                                value = 0;
                                --j;
                        }
                }
                if ((i & 3) > 0)
                        sprintf(&string[j], "%1x", value);

                dprintk("Export: key = \"%s\", %d bits, value = HEX %s\n",
                        key, count, string);
        }
}

static int altera_execute(struct altera_state *astate,
                                u8 *p,
                                s32 program_size,
                                s32 *error_address,
                                int *exit_code,
                                int *format_version)
{
        struct altera_config *aconf = astate->config;
        char *msg_buff = astate->msg_buff;
        long *stack = astate->stack;
        int status = 0;
        u32 first_word = 0L;
        u32 action_table = 0L;
        u32 proc_table = 0L;
        u32 str_table = 0L;
        u32 sym_table = 0L;
        u32 data_sect = 0L;
        u32 code_sect = 0L;
        u32 debug_sect = 0L;
        u32 action_count = 0L;
        u32 proc_count = 0L;
        u32 sym_count = 0L;
        long *vars = NULL;
        s32 *var_size = NULL;
        char *attrs = NULL;
        u8 *proc_attributes = NULL;
        u32 pc;
        u32 opcode_address;
        u32 args[3];
        u32 opcode;
        u32 name_id;
        u8 charbuf[4];
        long long_tmp;
        u32 variable_id;
        u8 *charptr_tmp;
        u8 *charptr_tmp2;
        long *longptr_tmp;
        int version = 0;
        int delta = 0;
        int stack_ptr = 0;
        u32 arg_count;
        int done = 0;
        int bad_opcode = 0;
        u32 count;
        u32 index;
        u32 index2;
        s32 long_count;
        s32 long_idx;
        s32 long_idx2;
        u32 i;
        u32 j;
        u32 uncomp_size;
        u32 offset;
        u32 value;
        int current_proc = 0;
        int reverse;

        char *name;

        dprintk("%s\n", __func__);

        /* Read header information */
        if (program_size > 52L) {
                first_word    = get_unaligned_be32(&p[0]);
                version = (first_word & 1L);
                *format_version = version + 1;
                delta = version * 8;

                action_table  = get_unaligned_be32(&p[4]);
                proc_table    = get_unaligned_be32(&p[8]);
                str_table  = get_unaligned_be32(&p[4 + delta]);
                sym_table  = get_unaligned_be32(&p[16 + delta]);
                data_sect  = get_unaligned_be32(&p[20 + delta]);
                code_sect  = get_unaligned_be32(&p[24 + delta]);
                debug_sect = get_unaligned_be32(&p[28 + delta]);
                action_count  = get_unaligned_be32(&p[40 + delta]);
                proc_count    = get_unaligned_be32(&p[44 + delta]);
                sym_count  = get_unaligned_be32(&p[48 + (2 * delta)]);
        }

        if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L)) {
                done = 1;
                status = -EIO;
                goto exit_done;
        }

        if (sym_count <= 0)
                goto exit_done;

        vars = kzalloc_objs(long, sym_count);

        if (vars == NULL)
                status = -ENOMEM;

        if (status == 0) {
                var_size = kzalloc_objs(s32, sym_count);

                if (var_size == NULL)
                        status = -ENOMEM;
        }

        if (status == 0) {
                attrs = kzalloc(sym_count, GFP_KERNEL);

                if (attrs == NULL)
                        status = -ENOMEM;
        }

        if ((status == 0) && (version > 0)) {
                proc_attributes = kzalloc(proc_count, GFP_KERNEL);

                if (proc_attributes == NULL)
                        status = -ENOMEM;
        }

        if (status != 0)
                goto exit_done;

        delta = version * 2;

        for (i = 0; i < sym_count; ++i) {
                offset = (sym_table + ((11 + delta) * i));

                value = get_unaligned_be32(&p[offset + 3 + delta]);

                attrs[i] = p[offset];

                /*
                 * use bit 7 of attribute byte to indicate that
                 * this buffer was dynamically allocated
                 * and should be freed later
                 */
                attrs[i] &= 0x7f;

                var_size[i] = get_unaligned_be32(&p[offset + 7 + delta]);

                /*
                 * Attribute bits:
                 * bit 0: 0 = read-only, 1 = read-write
                 * bit 1: 0 = not compressed, 1 = compressed
                 * bit 2: 0 = not initialized, 1 = initialized
                 * bit 3: 0 = scalar, 1 = array
                 * bit 4: 0 = Boolean, 1 = integer
                 * bit 5: 0 = declared variable,
                 *      1 = compiler created temporary variable
                 */

                if ((attrs[i] & 0x0c) == 0x04)
                        /* initialized scalar variable */
                        vars[i] = value;
                else if ((attrs[i] & 0x1e) == 0x0e) {
                        /* initialized compressed Boolean array */
                        uncomp_size = get_unaligned_le32(&p[data_sect + value]);

                        /* allocate a buffer for the uncompressed data */
                        vars[i] = (long)kzalloc(uncomp_size, GFP_KERNEL);
                        if (vars[i] == 0L)
                                status = -ENOMEM;
                        else {
                                /* set flag so buffer will be freed later */
                                attrs[i] |= 0x80;

                                /* uncompress the data */
                                if (altera_shrink(&p[data_sect + value],
                                                var_size[i],
                                                (u8 *)vars[i],
                                                uncomp_size,
                                                version) != uncomp_size)
                                        /* decompression failed */
                                        status = -EIO;
                                else
                                        var_size[i] = uncomp_size * 8L;

                        }
                } else if ((attrs[i] & 0x1e) == 0x0c) {
                        /* initialized Boolean array */
                        vars[i] = value + data_sect + (long)p;
                } else if ((attrs[i] & 0x1c) == 0x1c) {
                        /* initialized integer array */
                        vars[i] = value + data_sect;
                } else if ((attrs[i] & 0x0c) == 0x08) {
                        /* uninitialized array */

                        /* flag attrs so that memory is freed */
                        attrs[i] |= 0x80;

                        if (var_size[i] > 0) {
                                u32 size;

                                if (attrs[i] & 0x10)
                                        /* integer array */
                                        size = (var_size[i] * sizeof(s32));
                                else
                                        /* Boolean array */
                                        size = ((var_size[i] + 7L) / 8L);

                                vars[i] = (long)kzalloc(size, GFP_KERNEL);

                                if (vars[i] == 0) {
                                        status = -ENOMEM;
                                } else {
                                        /* zero out memory */
                                        for (j = 0; j < size; ++j)
                                                ((u8 *)(vars[i]))[j] = 0;

                                }
                        } else
                                vars[i] = 0;

                } else
                        vars[i] = 0;

        }

exit_done:
        if (status != 0)
                done = 1;

        altera_jinit(astate);

        pc = code_sect;
        msg_buff[0] = '\0';

        /*
         * For JBC version 2, we will execute the procedures corresponding to
         * the selected ACTION
         */
        if (version > 0) {
                if (aconf->action == NULL) {
                        status = -EINVAL;
                        done = 1;
                } else {
                        int action_found = 0;
                        for (i = 0; (i < action_count) && !action_found; ++i) {
                                name_id = get_unaligned_be32(&p[action_table +
                                                                (12 * i)]);

                                name = &p[str_table + name_id];

                                if (strncasecmp(aconf->action, name, strlen(name)) == 0) {
                                        action_found = 1;
                                        current_proc =
                                                get_unaligned_be32(&p[action_table +
                                                                (12 * i) + 8]);
                                }
                        }

                        if (!action_found) {
                                status = -EINVAL;
                                done = 1;
                        }
                }

                if (status == 0) {
                        int first_time = 1;
                        i = current_proc;
                        while ((i != 0) || first_time) {
                                first_time = 0;
                                /* check procedure attribute byte */
                                proc_attributes[i] =
                                                (p[proc_table +
                                                                (13 * i) + 8] &
                                                                        0x03);

                                /*
                                 * BIT0 - OPTIONAL
                                 * BIT1 - RECOMMENDED
                                 * BIT6 - FORCED OFF
                                 * BIT7 - FORCED ON
                                 */

                                i = get_unaligned_be32(&p[proc_table +
                                                        (13 * i) + 4]);
                        }

                        /*
                         * Set current_proc to the first procedure
                         * to be executed
                         */
                        i = current_proc;
                        while ((i != 0) &&
                                ((proc_attributes[i] == 1) ||
                                ((proc_attributes[i] & 0xc0) == 0x40))) {
                                i = get_unaligned_be32(&p[proc_table +
                                                        (13 * i) + 4]);
                        }

                        if ((i != 0) || ((i == 0) && (current_proc == 0) &&
                                ((proc_attributes[0] != 1) &&
                                ((proc_attributes[0] & 0xc0) != 0x40)))) {
                                current_proc = i;
                                pc = code_sect +
                                        get_unaligned_be32(&p[proc_table +
                                                                (13 * i) + 9]);
                                if ((pc < code_sect) || (pc >= debug_sect))
                                        status = -ERANGE;
                        } else
                                /* there are no procedures to execute! */
                                done = 1;

                }
        }

        msg_buff[0] = '\0';

        while (!done) {
                opcode = (p[pc] & 0xff);
                opcode_address = pc;
                ++pc;

                if (debug > 1)
                        printk("opcode: %02x\n", opcode);

                arg_count = (opcode >> 6) & 3;
                for (i = 0; i < arg_count; ++i) {
                        args[i] = get_unaligned_be32(&p[pc]);
                        pc += 4;
                }

                switch (opcode) {
                case OP_NOP:
                        break;
                case OP_DUP:
                        if (altera_check_stack(stack_ptr, 1, &status)) {
                                stack[stack_ptr] = stack[stack_ptr - 1];
                                ++stack_ptr;
                        }
                        break;
                case OP_SWP:
                        if (altera_check_stack(stack_ptr, 2, &status))
                                swap(stack[stack_ptr - 2], stack[stack_ptr - 1]);
                        break;
                case OP_ADD:
                        if (altera_check_stack(stack_ptr, 2, &status)) {
                                --stack_ptr;
                                stack[stack_ptr - 1] += stack[stack_ptr];
                        }
                        break;
                case OP_SUB:
                        if (altera_check_stack(stack_ptr, 2, &status)) {
                                --stack_ptr;
                                stack[stack_ptr - 1] -= stack[stack_ptr];
                        }
                        break;
                case OP_MULT:
                        if (altera_check_stack(stack_ptr, 2, &status)) {
                                --stack_ptr;
                                stack[stack_ptr - 1] *= stack[stack_ptr];
                        }
                        break;
                case OP_DIV:
                        if (altera_check_stack(stack_ptr, 2, &status)) {
                                --stack_ptr;
                                stack[stack_ptr - 1] /= stack[stack_ptr];
                        }
                        break;
                case OP_MOD:
                        if (altera_check_stack(stack_ptr, 2, &status)) {
                                --stack_ptr;
                                stack[stack_ptr - 1] %= stack[stack_ptr];
                        }
                        break;
                case OP_SHL:
                        if (altera_check_stack(stack_ptr, 2, &status)) {
                                --stack_ptr;
                                stack[stack_ptr - 1] <<= stack[stack_ptr];
                        }
                        break;
                case OP_SHR:
                        if (altera_check_stack(stack_ptr, 2, &status)) {
                                --stack_ptr;
                                stack[stack_ptr - 1] >>= stack[stack_ptr];
                        }
                        break;
                case OP_NOT:
                        if (altera_check_stack(stack_ptr, 1, &status))
                                stack[stack_ptr - 1] ^= (-1L);

                        break;
                case OP_AND:
                        if (altera_check_stack(stack_ptr, 2, &status)) {
                                --stack_ptr;
                                stack[stack_ptr - 1] &= stack[stack_ptr];
                        }
                        break;
                case OP_OR:
                        if (altera_check_stack(stack_ptr, 2, &status)) {
                                --stack_ptr;
                                stack[stack_ptr - 1] |= stack[stack_ptr];
                        }
                        break;
                case OP_XOR:
                        if (altera_check_stack(stack_ptr, 2, &status)) {
                                --stack_ptr;
                                stack[stack_ptr - 1] ^= stack[stack_ptr];
                        }
                        break;
                case OP_INV:
                        if (!altera_check_stack(stack_ptr, 1, &status))
                                break;
                        stack[stack_ptr - 1] = stack[stack_ptr - 1] ? 0L : 1L;
                        break;
                case OP_GT:
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        --stack_ptr;
                        stack[stack_ptr - 1] =
                                (stack[stack_ptr - 1] > stack[stack_ptr]) ?
                                                                        1L : 0L;

                        break;
                case OP_LT:
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        --stack_ptr;
                        stack[stack_ptr - 1] =
                                (stack[stack_ptr - 1] < stack[stack_ptr]) ?
                                                                        1L : 0L;

                        break;
                case OP_RET:
                        if ((version > 0) && (stack_ptr == 0)) {
                                /*
                                 * We completed one of the main procedures
                                 * of an ACTION.
                                 * Find the next procedure
                                 * to be executed and jump to it.
                                 * If there are no more procedures, then EXIT.
                                 */
                                i = get_unaligned_be32(&p[proc_table +
                                                (13 * current_proc) + 4]);
                                while ((i != 0) &&
                                        ((proc_attributes[i] == 1) ||
                                        ((proc_attributes[i] & 0xc0) == 0x40)))
                                        i = get_unaligned_be32(&p[proc_table +
                                                                (13 * i) + 4]);

                                if (i == 0) {
                                        /* no procedures to execute! */
                                        done = 1;
                                        *exit_code = 0; /* success */
                                } else {
                                        current_proc = i;
                                        pc = code_sect + get_unaligned_be32(
                                                                &p[proc_table +
                                                                (13 * i) + 9]);
                                        if ((pc < code_sect) ||
                                            (pc >= debug_sect))
                                                status = -ERANGE;
                                }

                        } else
                                if (altera_check_stack(stack_ptr, 1, &status)) {
                                        pc = stack[--stack_ptr] + code_sect;
                                        if ((pc <= code_sect) ||
                                            (pc >= debug_sect))
                                                status = -ERANGE;

                                }

                        break;
                case OP_CMPS:
                        /*
                         * Array short compare
                         * ...stack 0 is source 1 value
                         * ...stack 1 is source 2 value
                         * ...stack 2 is mask value
                         * ...stack 3 is count
                         */
                        if (altera_check_stack(stack_ptr, 4, &status)) {
                                s32 a = stack[--stack_ptr];
                                s32 b = stack[--stack_ptr];
                                long_tmp = stack[--stack_ptr];
                                count = stack[stack_ptr - 1];

                                if ((count < 1) || (count > 32))
                                        status = -ERANGE;
                                else {
                                        long_tmp &= ((-1L) >> (32 - count));

                                        stack[stack_ptr - 1] =
                                        ((a & long_tmp) == (b & long_tmp))
                                                                ? 1L : 0L;
                                }
                        }
                        break;
                case OP_PINT:
                        /*
                         * PRINT add integer
                         * ...stack 0 is integer value
                         */
                        if (!altera_check_stack(stack_ptr, 1, &status))
                                break;
                        sprintf(&msg_buff[strlen(msg_buff)],
                                        "%ld", stack[--stack_ptr]);
                        break;
                case OP_PRNT:
                        /* PRINT finish */
                        if (debug)
                                printk(msg_buff, "\n");

                        msg_buff[0] = '\0';
                        break;
                case OP_DSS:
                        /*
                         * DRSCAN short
                         * ...stack 0 is scan data
                         * ...stack 1 is count
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        long_tmp = stack[--stack_ptr];
                        count = stack[--stack_ptr];
                        put_unaligned_le32(long_tmp, &charbuf[0]);
                        status = altera_drscan(astate, count, charbuf, 0);
                        break;
                case OP_DSSC:
                        /*
                         * DRSCAN short with capture
                         * ...stack 0 is scan data
                         * ...stack 1 is count
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        long_tmp = stack[--stack_ptr];
                        count = stack[stack_ptr - 1];
                        put_unaligned_le32(long_tmp, &charbuf[0]);
                        status = altera_swap_dr(astate, count, charbuf,
                                                        0, charbuf, 0);
                        stack[stack_ptr - 1] = get_unaligned_le32(&charbuf[0]);
                        break;
                case OP_ISS:
                        /*
                         * IRSCAN short
                         * ...stack 0 is scan data
                         * ...stack 1 is count
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        long_tmp = stack[--stack_ptr];
                        count = stack[--stack_ptr];
                        put_unaligned_le32(long_tmp, &charbuf[0]);
                        status = altera_irscan(astate, count, charbuf, 0);
                        break;
                case OP_ISSC:
                        /*
                         * IRSCAN short with capture
                         * ...stack 0 is scan data
                         * ...stack 1 is count
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        long_tmp = stack[--stack_ptr];
                        count = stack[stack_ptr - 1];
                        put_unaligned_le32(long_tmp, &charbuf[0]);
                        status = altera_swap_ir(astate, count, charbuf,
                                                        0, charbuf, 0);
                        stack[stack_ptr - 1] = get_unaligned_le32(&charbuf[0]);
                        break;
                case OP_DPR:
                        if (!altera_check_stack(stack_ptr, 1, &status))
                                break;
                        count = stack[--stack_ptr];
                        status = altera_set_dr_pre(&astate->js, count, 0, NULL);
                        break;
                case OP_DPRL:
                        /*
                         * DRPRE with literal data
                         * ...stack 0 is count
                         * ...stack 1 is literal data
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        count = stack[--stack_ptr];
                        long_tmp = stack[--stack_ptr];
                        put_unaligned_le32(long_tmp, &charbuf[0]);
                        status = altera_set_dr_pre(&astate->js, count, 0,
                                                charbuf);
                        break;
                case OP_DPO:
                        /*
                         * DRPOST
                         * ...stack 0 is count
                         */
                        if (altera_check_stack(stack_ptr, 1, &status)) {
                                count = stack[--stack_ptr];
                                status = altera_set_dr_post(&astate->js, count,
                                                                0, NULL);
                        }
                        break;
                case OP_DPOL:
                        /*
                         * DRPOST with literal data
                         * ...stack 0 is count
                         * ...stack 1 is literal data
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        count = stack[--stack_ptr];
                        long_tmp = stack[--stack_ptr];
                        put_unaligned_le32(long_tmp, &charbuf[0]);
                        status = altera_set_dr_post(&astate->js, count, 0,
                                                        charbuf);
                        break;
                case OP_IPR:
                        if (altera_check_stack(stack_ptr, 1, &status)) {
                                count = stack[--stack_ptr];
                                status = altera_set_ir_pre(&astate->js, count,
                                                                0, NULL);
                        }
                        break;
                case OP_IPRL:
                        /*
                         * IRPRE with literal data
                         * ...stack 0 is count
                         * ...stack 1 is literal data
                         */
                        if (altera_check_stack(stack_ptr, 2, &status)) {
                                count = stack[--stack_ptr];
                                long_tmp = stack[--stack_ptr];
                                put_unaligned_le32(long_tmp, &charbuf[0]);
                                status = altera_set_ir_pre(&astate->js, count,
                                                        0, charbuf);
                        }
                        break;
                case OP_IPO:
                        /*
                         * IRPOST
                         * ...stack 0 is count
                         */
                        if (altera_check_stack(stack_ptr, 1, &status)) {
                                count = stack[--stack_ptr];
                                status = altera_set_ir_post(&astate->js, count,
                                                        0, NULL);
                        }
                        break;
                case OP_IPOL:
                        /*
                         * IRPOST with literal data
                         * ...stack 0 is count
                         * ...stack 1 is literal data
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        count = stack[--stack_ptr];
                        long_tmp = stack[--stack_ptr];
                        put_unaligned_le32(long_tmp, &charbuf[0]);
                        status = altera_set_ir_post(&astate->js, count, 0,
                                                        charbuf);
                        break;
                case OP_PCHR:
                        if (altera_check_stack(stack_ptr, 1, &status)) {
                                u8 ch;
                                count = strlen(msg_buff);
                                ch = (char) stack[--stack_ptr];
                                if ((ch < 1) || (ch > 127)) {
                                        /*
                                         * character code out of range
                                         * instead of flagging an error,
                                         * force the value to 127
                                         */
                                        ch = 127;
                                }
                                msg_buff[count] = ch;
                                msg_buff[count + 1] = '\0';
                        }
                        break;
                case OP_EXIT:
                        if (altera_check_stack(stack_ptr, 1, &status))
                                *exit_code = stack[--stack_ptr];

                        done = 1;
                        break;
                case OP_EQU:
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        --stack_ptr;
                        stack[stack_ptr - 1] =
                                (stack[stack_ptr - 1] == stack[stack_ptr]) ?
                                                                        1L : 0L;
                        break;
                case OP_POPT:
                        if (altera_check_stack(stack_ptr, 1, &status))
                                --stack_ptr;

                        break;
                case OP_ABS:
                        if (!altera_check_stack(stack_ptr, 1, &status))
                                break;
                        if (stack[stack_ptr - 1] < 0)
                                stack[stack_ptr - 1] = 0 - stack[stack_ptr - 1];

                        break;
                case OP_BCH0:
                        /*
                         * Batch operation 0
                         * SWP
                         * SWPN 7
                         * SWP
                         * SWPN 6
                         * DUPN 8
                         * SWPN 2
                         * SWP
                         * DUPN 6
                         * DUPN 6
                         */

                        /* SWP  */
                        if (altera_check_stack(stack_ptr, 2, &status))
                                swap(stack[stack_ptr - 2], stack[stack_ptr - 1]);

                        /* SWPN 7 */
                        index = 7 + 1;
                        if (altera_check_stack(stack_ptr, index, &status))
                                swap(stack[stack_ptr - index], stack[stack_ptr - 1]);

                        /* SWP  */
                        if (altera_check_stack(stack_ptr, 2, &status))
                                swap(stack[stack_ptr - 2], stack[stack_ptr - 1]);

                        /* SWPN 6 */
                        index = 6 + 1;
                        if (altera_check_stack(stack_ptr, index, &status))
                                swap(stack[stack_ptr - index], stack[stack_ptr - 1]);

                        /* DUPN 8 */
                        index = 8 + 1;
                        if (altera_check_stack(stack_ptr, index, &status)) {
                                stack[stack_ptr] = stack[stack_ptr - index];
                                ++stack_ptr;
                        }

                        /* SWPN 2 */
                        index = 2 + 1;
                        if (altera_check_stack(stack_ptr, index, &status))
                                swap(stack[stack_ptr - index], stack[stack_ptr - 1]);

                        /* SWP  */
                        if (altera_check_stack(stack_ptr, 2, &status))
                                swap(stack[stack_ptr - 2], stack[stack_ptr - 1]);

                        /* DUPN 6 */
                        index = 6 + 1;
                        if (altera_check_stack(stack_ptr, index, &status)) {
                                stack[stack_ptr] = stack[stack_ptr - index];
                                ++stack_ptr;
                        }

                        /* DUPN 6 */
                        index = 6 + 1;
                        if (altera_check_stack(stack_ptr, index, &status)) {
                                stack[stack_ptr] = stack[stack_ptr - index];
                                ++stack_ptr;
                        }
                        break;
                case OP_PSH0:
                        stack[stack_ptr++] = 0;
                        break;
                case OP_PSHL:
                        stack[stack_ptr++] = (s32) args[0];
                        break;
                case OP_PSHV:
                        stack[stack_ptr++] = vars[args[0]];
                        break;
                case OP_JMP:
                        pc = args[0] + code_sect;
                        if ((pc < code_sect) || (pc >= debug_sect))
                                status = -ERANGE;
                        break;
                case OP_CALL:
                        stack[stack_ptr++] = pc;
                        pc = args[0] + code_sect;
                        if ((pc < code_sect) || (pc >= debug_sect))
                                status = -ERANGE;
                        break;
                case OP_NEXT:
                        /*
                         * Process FOR / NEXT loop
                         * ...argument 0 is variable ID
                         * ...stack 0 is step value
                         * ...stack 1 is end value
                         * ...stack 2 is top address
                         */
                        if (altera_check_stack(stack_ptr, 3, &status)) {
                                s32 step = stack[stack_ptr - 1];
                                s32 end = stack[stack_ptr - 2];
                                s32 top = stack[stack_ptr - 3];
                                s32 iterator = vars[args[0]];
                                int break_out = 0;

                                if (step < 0) {
                                        if (iterator <= end)
                                                break_out = 1;
                                } else if (iterator >= end)
                                        break_out = 1;

                                if (break_out) {
                                        stack_ptr -= 3;
                                } else {
                                        vars[args[0]] = iterator + step;
                                        pc = top + code_sect;
                                        if ((pc < code_sect) ||
                                            (pc >= debug_sect))
                                                status = -ERANGE;
                                }
                        }
                        break;
                case OP_PSTR:
                        /*
                         * PRINT add string
                         * ...argument 0 is string ID
                         */
                        count = strlen(msg_buff);
                        strscpy(&msg_buff[count],
                                &p[str_table + args[0]],
                                ALTERA_MESSAGE_LENGTH - count);
                        break;
                case OP_SINT:
                        /*
                         * STATE intermediate state
                         * ...argument 0 is state code
                         */
                        status = altera_goto_jstate(astate, args[0]);
                        break;
                case OP_ST:
                        /*
                         * STATE final state
                         * ...argument 0 is state code
                         */
                        status = altera_goto_jstate(astate, args[0]);
                        break;
                case OP_ISTP:
                        /*
                         * IRSTOP state
                         * ...argument 0 is state code
                         */
                        status = altera_set_irstop(&astate->js, args[0]);
                        break;
                case OP_DSTP:
                        /*
                         * DRSTOP state
                         * ...argument 0 is state code
                         */
                        status = altera_set_drstop(&astate->js, args[0]);
                        break;

                case OP_SWPN:
                        /*
                         * Exchange top with Nth stack value
                         * ...argument 0 is 0-based stack entry
                         * to swap with top element
                         */
                        index = (args[0]) + 1;
                        if (altera_check_stack(stack_ptr, index, &status))
                                swap(stack[stack_ptr - index], stack[stack_ptr - 1]);
                        break;
                case OP_DUPN:
                        /*
                         * Duplicate Nth stack value
                         * ...argument 0 is 0-based stack entry to duplicate
                         */
                        index = (args[0]) + 1;
                        if (altera_check_stack(stack_ptr, index, &status)) {
                                stack[stack_ptr] = stack[stack_ptr - index];
                                ++stack_ptr;
                        }
                        break;
                case OP_POPV:
                        /*
                         * Pop stack into scalar variable
                         * ...argument 0 is variable ID
                         * ...stack 0 is value
                         */
                        if (altera_check_stack(stack_ptr, 1, &status))
                                vars[args[0]] = stack[--stack_ptr];

                        break;
                case OP_POPE:
                        /*
                         * Pop stack into integer array element
                         * ...argument 0 is variable ID
                         * ...stack 0 is array index
                         * ...stack 1 is value
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        variable_id = args[0];

                        /*
                         * If variable is read-only,
                         * convert to writable array
                         */
                        if ((version > 0) &&
                                ((attrs[variable_id] & 0x9c) == 0x1c)) {
                                /* Allocate a writable buffer for this array */
                                count = var_size[variable_id];
                                long_tmp = vars[variable_id];
                                longptr_tmp = kzalloc_objs(long, count);
                                vars[variable_id] = (long)longptr_tmp;

                                if (vars[variable_id] == 0) {
                                        status = -ENOMEM;
                                        break;
                                }

                                /* copy previous contents into buffer */
                                for (i = 0; i < count; ++i) {
                                        longptr_tmp[i] =
                                                get_unaligned_be32(&p[long_tmp]);
                                        long_tmp += sizeof(long);
                                }

                                /*
                                 * set bit 7 - buffer was
                                 * dynamically allocated
                                 */
                                attrs[variable_id] |= 0x80;

                                /* clear bit 2 - variable is writable */
                                attrs[variable_id] &= ~0x04;
                                attrs[variable_id] |= 0x01;

                        }

                        /* check that variable is a writable integer array */
                        if ((attrs[variable_id] & 0x1c) != 0x18)
                                status = -ERANGE;
                        else {
                                longptr_tmp = (long *)vars[variable_id];

                                /* pop the array index */
                                index = stack[--stack_ptr];

                                /* pop the value and store it into the array */
                                longptr_tmp[index] = stack[--stack_ptr];
                        }

                        break;
                case OP_POPA:
                        /*
                         * Pop stack into Boolean array
                         * ...argument 0 is variable ID
                         * ...stack 0 is count
                         * ...stack 1 is array index
                         * ...stack 2 is value
                         */
                        if (!altera_check_stack(stack_ptr, 3, &status))
                                break;
                        variable_id = args[0];

                        /*
                         * If variable is read-only,
                         * convert to writable array
                         */
                        if ((version > 0) &&
                                ((attrs[variable_id] & 0x9c) == 0x0c)) {
                                /* Allocate a writable buffer for this array */
                                long_tmp =
                                        (var_size[variable_id] + 7L) >> 3L;
                                charptr_tmp2 = (u8 *)vars[variable_id];
                                charptr_tmp =
                                        kzalloc(long_tmp, GFP_KERNEL);
                                vars[variable_id] = (long)charptr_tmp;

                                if (vars[variable_id] == 0) {
                                        status = -ENOMEM;
                                        break;
                                }

                                /* zero the buffer */
                                for (long_idx = 0L;
                                        long_idx < long_tmp;
                                        ++long_idx) {
                                        charptr_tmp[long_idx] = 0;
                                }

                                /* copy previous contents into buffer */
                                for (long_idx = 0L;
                                        long_idx < var_size[variable_id];
                                        ++long_idx) {
                                        long_idx2 = long_idx;

                                        if (charptr_tmp2[long_idx2 >> 3] &
                                                (1 << (long_idx2 & 7))) {
                                                charptr_tmp[long_idx >> 3] |=
                                                        (1 << (long_idx & 7));
                                        }
                                }

                                /*
                                 * set bit 7 - buffer was
                                 * dynamically allocated
                                 */
                                attrs[variable_id] |= 0x80;

                                /* clear bit 2 - variable is writable */
                                attrs[variable_id] &= ~0x04;
                                attrs[variable_id] |= 0x01;

                        }

                        /*
                         * check that variable is
                         * a writable Boolean array
                         */
                        if ((attrs[variable_id] & 0x1c) != 0x08) {
                                status = -ERANGE;
                                break;
                        }

                        charptr_tmp = (u8 *)vars[variable_id];

                        /* pop the count (number of bits to copy) */
                        long_count = stack[--stack_ptr];

                        /* pop the array index */
                        long_idx = stack[--stack_ptr];

                        reverse = 0;

                        if (version > 0) {
                                /*
                                 * stack 0 = array right index
                                 * stack 1 = array left index
                                 */

                                if (long_idx > long_count) {
                                        reverse = 1;
                                        long_tmp = long_count;
                                        long_count = 1 + long_idx -
                                                                long_count;
                                        long_idx = long_tmp;

                                        /* reverse POPA is not supported */
                                        status = -ERANGE;
                                        break;
                                } else
                                        long_count = 1 + long_count -
                                                                long_idx;

                        }

                        /* pop the data */
                        long_tmp = stack[--stack_ptr];

                        if (long_count < 1) {
                                status = -ERANGE;
                                break;
                        }

                        for (i = 0; i < long_count; ++i) {
                                if (long_tmp & (1L << (s32) i))
                                        charptr_tmp[long_idx >> 3L] |=
                                                (1L << (long_idx & 7L));
                                else
                                        charptr_tmp[long_idx >> 3L] &=
                                                ~(1L << (long_idx & 7L));

                                ++long_idx;
                        }

                        break;
                case OP_JMPZ:
                        /*
                         * Pop stack and branch if zero
                         * ...argument 0 is address
                         * ...stack 0 is condition value
                         */
                        if (altera_check_stack(stack_ptr, 1, &status)) {
                                if (stack[--stack_ptr] == 0) {
                                        pc = args[0] + code_sect;
                                        if ((pc < code_sect) ||
                                            (pc >= debug_sect))
                                                status = -ERANGE;
                                }
                        }
                        break;
                case OP_DS:
                case OP_IS:
                        /*
                         * DRSCAN
                         * IRSCAN
                         * ...argument 0 is scan data variable ID
                         * ...stack 0 is array index
                         * ...stack 1 is count
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        long_idx = stack[--stack_ptr];
                        long_count = stack[--stack_ptr];
                        reverse = 0;
                        if (version > 0) {
                                /*
                                 * stack 0 = array right index
                                 * stack 1 = array left index
                                 * stack 2 = count
                                 */
                                long_tmp = long_count;
                                long_count = stack[--stack_ptr];

                                if (long_idx > long_tmp) {
                                        reverse = 1;
                                        long_idx = long_tmp;
                                }
                        }

                        charptr_tmp = (u8 *)vars[args[0]];

                        if (reverse) {
                                /*
                                 * allocate a buffer
                                 * and reverse the data order
                                 */
                                charptr_tmp2 = charptr_tmp;
                                charptr_tmp = kzalloc((long_count >> 3) + 1,
                                                                GFP_KERNEL);
                                if (charptr_tmp == NULL) {
                                        status = -ENOMEM;
                                        break;
                                }

                                long_tmp = long_idx + long_count - 1;
                                long_idx2 = 0;
                                while (long_idx2 < long_count) {
                                        if (charptr_tmp2[long_tmp >> 3] &
                                                        (1 << (long_tmp & 7)))
                                                charptr_tmp[long_idx2 >> 3] |=
                                                        (1 << (long_idx2 & 7));
                                        else
                                                charptr_tmp[long_idx2 >> 3] &=
                                                        ~(1 << (long_idx2 & 7));

                                        --long_tmp;
                                        ++long_idx2;
                                }
                        }

                        if (opcode == 0x51) /* DS */
                                status = altera_drscan(astate, long_count,
                                                charptr_tmp, long_idx);
                        else /* IS */
                                status = altera_irscan(astate, long_count,
                                                charptr_tmp, long_idx);

                        if (reverse)
                                kfree(charptr_tmp);

                        break;
                case OP_DPRA:
                        /*
                         * DRPRE with array data
                         * ...argument 0 is variable ID
                         * ...stack 0 is array index
                         * ...stack 1 is count
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        index = stack[--stack_ptr];
                        count = stack[--stack_ptr];

                        if (version > 0)
                                /*
                                 * stack 0 = array right index
                                 * stack 1 = array left index
                                 */
                                count = 1 + count - index;

                        charptr_tmp = (u8 *)vars[args[0]];
                        status = altera_set_dr_pre(&astate->js, count, index,
                                                        charptr_tmp);
                        break;
                case OP_DPOA:
                        /*
                         * DRPOST with array data
                         * ...argument 0 is variable ID
                         * ...stack 0 is array index
                         * ...stack 1 is count
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        index = stack[--stack_ptr];
                        count = stack[--stack_ptr];

                        if (version > 0)
                                /*
                                 * stack 0 = array right index
                                 * stack 1 = array left index
                                 */
                                count = 1 + count - index;

                        charptr_tmp = (u8 *)vars[args[0]];
                        status = altera_set_dr_post(&astate->js, count, index,
                                                        charptr_tmp);
                        break;
                case OP_IPRA:
                        /*
                         * IRPRE with array data
                         * ...argument 0 is variable ID
                         * ...stack 0 is array index
                         * ...stack 1 is count
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        index = stack[--stack_ptr];
                        count = stack[--stack_ptr];

                        if (version > 0)
                                /*
                                 * stack 0 = array right index
                                 * stack 1 = array left index
                                 */
                                count = 1 + count - index;

                        charptr_tmp = (u8 *)vars[args[0]];
                        status = altera_set_ir_pre(&astate->js, count, index,
                                                        charptr_tmp);

                        break;
                case OP_IPOA:
                        /*
                         * IRPOST with array data
                         * ...argument 0 is variable ID
                         * ...stack 0 is array index
                         * ...stack 1 is count
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        index = stack[--stack_ptr];
                        count = stack[--stack_ptr];

                        if (version > 0)
                                /*
                                 * stack 0 = array right index
                                 * stack 1 = array left index
                                 */
                                count = 1 + count - index;

                        charptr_tmp = (u8 *)vars[args[0]];
                        status = altera_set_ir_post(&astate->js, count, index,
                                                        charptr_tmp);

                        break;
                case OP_EXPT:
                        /*
                         * EXPORT
                         * ...argument 0 is string ID
                         * ...stack 0 is integer expression
                         */
                        if (altera_check_stack(stack_ptr, 1, &status)) {
                                name = &p[str_table + args[0]];
                                long_tmp = stack[--stack_ptr];
                                altera_export_int(name, long_tmp);
                        }
                        break;
                case OP_PSHE:
                        /*
                         * Push integer array element
                         * ...argument 0 is variable ID
                         * ...stack 0 is array index
                         */
                        if (!altera_check_stack(stack_ptr, 1, &status))
                                break;
                        variable_id = args[0];
                        index = stack[stack_ptr - 1];

                        /* check variable type */
                        if ((attrs[variable_id] & 0x1f) == 0x19) {
                                /* writable integer array */
                                longptr_tmp = (long *)vars[variable_id];
                                stack[stack_ptr - 1] = longptr_tmp[index];
                        } else if ((attrs[variable_id] & 0x1f) == 0x1c) {
                                /* read-only integer array */
                                long_tmp = vars[variable_id] +
                                                (index * sizeof(long));
                                stack[stack_ptr - 1] =
                                        get_unaligned_be32(&p[long_tmp]);
                        } else
                                status = -ERANGE;

                        break;
                case OP_PSHA:
                        /*
                         * Push Boolean array
                         * ...argument 0 is variable ID
                         * ...stack 0 is count
                         * ...stack 1 is array index
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        variable_id = args[0];

                        /* check that variable is a Boolean array */
                        if ((attrs[variable_id] & 0x18) != 0x08) {
                                status = -ERANGE;
                                break;
                        }

                        charptr_tmp = (u8 *)vars[variable_id];

                        /* pop the count (number of bits to copy) */
                        count = stack[--stack_ptr];

                        /* pop the array index */
                        index = stack[stack_ptr - 1];

                        if (version > 0)
                                /*
                                 * stack 0 = array right index
                                 * stack 1 = array left index
                                 */
                                count = 1 + count - index;

                        if ((count < 1) || (count > 32)) {
                                status = -ERANGE;
                                break;
                        }

                        long_tmp = 0L;

                        for (i = 0; i < count; ++i)
                                if (charptr_tmp[(i + index) >> 3] &
                                                (1 << ((i + index) & 7)))
                                        long_tmp |= (1L << i);

                        stack[stack_ptr - 1] = long_tmp;

                        break;
                case OP_DYNA:
                        /*
                         * Dynamically change size of array
                         * ...argument 0 is variable ID
                         * ...stack 0 is new size
                         */
                        if (!altera_check_stack(stack_ptr, 1, &status))
                                break;
                        variable_id = args[0];
                        long_tmp = stack[--stack_ptr];

                        if (long_tmp > var_size[variable_id]) {
                                var_size[variable_id] = long_tmp;

                                if (attrs[variable_id] & 0x10)
                                        /* allocate integer array */
                                        long_tmp *= sizeof(long);
                                else
                                        /* allocate Boolean array */
                                        long_tmp = (long_tmp + 7) >> 3;

                                /*
                                 * If the buffer was previously allocated,
                                 * free it
                                 */
                                if (attrs[variable_id] & 0x80) {
                                        kfree((void *)vars[variable_id]);
                                        vars[variable_id] = 0;
                                }

                                /*
                                 * Allocate a new buffer
                                 * of the requested size
                                 */
                                vars[variable_id] = (long)
                                        kzalloc(long_tmp, GFP_KERNEL);

                                if (vars[variable_id] == 0) {
                                        status = -ENOMEM;
                                        break;
                                }

                                /*
                                 * Set the attribute bit to indicate that
                                 * this buffer was dynamically allocated and
                                 * should be freed later
                                 */
                                attrs[variable_id] |= 0x80;

                                /* zero out memory */
                                count = ((var_size[variable_id] + 7L) /
                                                                        8L);
                                charptr_tmp = (u8 *)(vars[variable_id]);
                                for (index = 0; index < count; ++index)
                                        charptr_tmp[index] = 0;

                        }

                        break;
                case OP_EXPV:
                        /*
                         * Export Boolean array
                         * ...argument 0 is string ID
                         * ...stack 0 is variable ID
                         * ...stack 1 is array right index
                         * ...stack 2 is array left index
                         */
                        if (!altera_check_stack(stack_ptr, 3, &status))
                                break;
                        if (version == 0) {
                                /* EXPV is not supported in JBC 1.0 */
                                bad_opcode = 1;
                                break;
                        }
                        name = &p[str_table + args[0]];
                        variable_id = stack[--stack_ptr];
                        long_idx = stack[--stack_ptr];/* right indx */
                        long_idx2 = stack[--stack_ptr];/* left indx */

                        if (long_idx > long_idx2) {
                                /* reverse indices not supported */
                                status = -ERANGE;
                                break;
                        }

                        long_count = 1 + long_idx2 - long_idx;

                        charptr_tmp = (u8 *)vars[variable_id];
                        charptr_tmp2 = NULL;

                        if ((long_idx & 7L) != 0) {
                                s32 k = long_idx;
                                charptr_tmp2 =
                                        kzalloc(((long_count + 7L) / 8L),
                                                        GFP_KERNEL);
                                if (charptr_tmp2 == NULL) {
                                        status = -ENOMEM;
                                        break;
                                }

                                for (i = 0; i < long_count; ++i) {
                                        if (charptr_tmp[k >> 3] &
                                                        (1 << (k & 7)))
                                                charptr_tmp2[i >> 3] |=
                                                                (1 << (i & 7));
                                        else
                                                charptr_tmp2[i >> 3] &=
                                                                ~(1 << (i & 7));

                                        ++k;
                                }
                                charptr_tmp = charptr_tmp2;

                        } else if (long_idx != 0)
                                charptr_tmp = &charptr_tmp[long_idx >> 3];

                        altera_export_bool_array(name, charptr_tmp,
                                                        long_count);

                        /* free allocated buffer */
                        if ((long_idx & 7L) != 0)
                                kfree(charptr_tmp2);

                        break;
                case OP_COPY: {
                        /*
                         * Array copy
                         * ...argument 0 is dest ID
                         * ...argument 1 is source ID
                         * ...stack 0 is count
                         * ...stack 1 is dest index
                         * ...stack 2 is source index
                         */
                        s32 copy_count;
                        s32 copy_index;
                        s32 copy_index2;
                        s32 destleft;
                        s32 src_count;
                        s32 dest_count;
                        int src_reverse = 0;
                        int dest_reverse = 0;

                        if (!altera_check_stack(stack_ptr, 3, &status))
                                break;

                        copy_count = stack[--stack_ptr];
                        copy_index = stack[--stack_ptr];
                        copy_index2 = stack[--stack_ptr];
                        reverse = 0;

                        if (version > 0) {
                                /*
                                 * stack 0 = source right index
                                 * stack 1 = source left index
                                 * stack 2 = destination right index
                                 * stack 3 = destination left index
                                 */
                                destleft = stack[--stack_ptr];

                                if (copy_count > copy_index) {
                                        src_reverse = 1;
                                        reverse = 1;
                                        src_count = 1 + copy_count - copy_index;
                                        /* copy_index = source start index */
                                } else {
                                        src_count = 1 + copy_index - copy_count;
                                        /* source start index */
                                        copy_index = copy_count;
                                }

                                if (copy_index2 > destleft) {
                                        dest_reverse = 1;
                                        reverse = !reverse;
                                        dest_count = 1 + copy_index2 - destleft;
                                        /* destination start index */
                                        copy_index2 = destleft;
                                } else
                                        dest_count = 1 + destleft - copy_index2;

                                copy_count = (src_count < dest_count) ?
                                                        src_count : dest_count;

                                if ((src_reverse || dest_reverse) &&
                                        (src_count != dest_count))
                                        /*
                                         * If either the source or destination
                                         * is reversed, we can't tolerate
                                         * a length mismatch, because we
                                         * "left justify" arrays when copying.
                                         * This won't work correctly
                                         * with reversed arrays.
                                         */
                                        status = -ERANGE;

                        }

                        count = copy_count;
                        index = copy_index;
                        index2 = copy_index2;

                        /*
                         * If destination is a read-only array,
                         * allocate a buffer and convert it to a writable array
                         */
                        variable_id = args[1];
                        if ((version > 0) &&
                                ((attrs[variable_id] & 0x9c) == 0x0c)) {
                                /* Allocate a writable buffer for this array */
                                long_tmp =
                                        (var_size[variable_id] + 7L) >> 3L;
                                charptr_tmp2 = (u8 *)vars[variable_id];
                                charptr_tmp =
                                        kzalloc(long_tmp, GFP_KERNEL);
                                vars[variable_id] = (long)charptr_tmp;

                                if (vars[variable_id] == 0) {
                                        status = -ENOMEM;
                                        break;
                                }

                                /* zero the buffer */
                                for (long_idx = 0L; long_idx < long_tmp;
                                                                ++long_idx)
                                        charptr_tmp[long_idx] = 0;

                                /* copy previous contents into buffer */
                                for (long_idx = 0L;
                                        long_idx < var_size[variable_id];
                                                                ++long_idx) {
                                        long_idx2 = long_idx;

                                        if (charptr_tmp2[long_idx2 >> 3] &
                                                (1 << (long_idx2 & 7)))
                                                charptr_tmp[long_idx >> 3] |=
                                                        (1 << (long_idx & 7));

                                }

                                /*
                                set bit 7 - buffer was dynamically allocated */
                                attrs[variable_id] |= 0x80;

                                /* clear bit 2 - variable is writable */
                                attrs[variable_id] &= ~0x04;
                                attrs[variable_id] |= 0x01;
                        }

                        charptr_tmp = (u8 *)vars[args[1]];
                        charptr_tmp2 = (u8 *)vars[args[0]];

                        /* check if destination is a writable Boolean array */
                        if ((attrs[args[1]] & 0x1c) != 0x08) {
                                status = -ERANGE;
                                break;
                        }

                        if (count < 1) {
                                status = -ERANGE;
                                break;
                        }

                        if (reverse)
                                index2 += (count - 1);

                        for (i = 0; i < count; ++i) {
                                if (charptr_tmp2[index >> 3] &
                                                        (1 << (index & 7)))
                                        charptr_tmp[index2 >> 3] |=
                                                        (1 << (index2 & 7));
                                else
                                        charptr_tmp[index2 >> 3] &=
                                                ~(1 << (index2 & 7));

                                ++index;
                                if (reverse)
                                        --index2;
                                else
                                        ++index2;
                        }

                        break;
                }
                case OP_DSC:
                case OP_ISC: {
                        /*
                         * DRSCAN with capture
                         * IRSCAN with capture
                         * ...argument 0 is scan data variable ID
                         * ...argument 1 is capture variable ID
                         * ...stack 0 is capture index
                         * ...stack 1 is scan data index
                         * ...stack 2 is count
                         */
                        s32 scan_right, scan_left;
                        s32 capture_count = 0;
                        s32 scan_count = 0;
                        s32 capture_index;
                        s32 scan_index;

                        if (!altera_check_stack(stack_ptr, 3, &status))
                                break;

                        capture_index = stack[--stack_ptr];
                        scan_index = stack[--stack_ptr];

                        if (version > 0) {
                                /*
                                 * stack 0 = capture right index
                                 * stack 1 = capture left index
                                 * stack 2 = scan right index
                                 * stack 3 = scan left index
                                 * stack 4 = count
                                 */
                                scan_right = stack[--stack_ptr];
                                scan_left = stack[--stack_ptr];
                                capture_count = 1 + scan_index - capture_index;
                                scan_count = 1 + scan_left - scan_right;
                                scan_index = scan_right;
                        }

                        long_count = stack[--stack_ptr];
                        /*
                         * If capture array is read-only, allocate a buffer
                         * and convert it to a writable array
                         */
                        variable_id = args[1];
                        if ((version > 0) &&
                                ((attrs[variable_id] & 0x9c) == 0x0c)) {
                                /* Allocate a writable buffer for this array */
                                long_tmp =
                                        (var_size[variable_id] + 7L) >> 3L;
                                charptr_tmp2 = (u8 *)vars[variable_id];
                                charptr_tmp =
                                        kzalloc(long_tmp, GFP_KERNEL);
                                vars[variable_id] = (long)charptr_tmp;

                                if (vars[variable_id] == 0) {
                                        status = -ENOMEM;
                                        break;
                                }

                                /* zero the buffer */
                                for (long_idx = 0L; long_idx < long_tmp;
                                                                ++long_idx)
                                        charptr_tmp[long_idx] = 0;

                                /* copy previous contents into buffer */
                                for (long_idx = 0L;
                                        long_idx < var_size[variable_id];
                                                                ++long_idx) {
                                        long_idx2 = long_idx;

                                        if (charptr_tmp2[long_idx2 >> 3] &
                                                (1 << (long_idx2 & 7)))
                                                charptr_tmp[long_idx >> 3] |=
                                                        (1 << (long_idx & 7));

                                }

                                /*
                                 * set bit 7 - buffer was
                                 * dynamically allocated
                                 */
                                attrs[variable_id] |= 0x80;

                                /* clear bit 2 - variable is writable */
                                attrs[variable_id] &= ~0x04;
                                attrs[variable_id] |= 0x01;

                        }

                        charptr_tmp = (u8 *)vars[args[0]];
                        charptr_tmp2 = (u8 *)vars[args[1]];

                        if ((version > 0) &&
                                        ((long_count > capture_count) ||
                                        (long_count > scan_count))) {
                                status = -ERANGE;
                                break;
                        }

                        /*
                         * check that capture array
                         * is a writable Boolean array
                         */
                        if ((attrs[args[1]] & 0x1c) != 0x08) {
                                status = -ERANGE;
                                break;
                        }

                        if (status == 0) {
                                if (opcode == 0x82) /* DSC */
                                        status = altera_swap_dr(astate,
                                                        long_count,
                                                        charptr_tmp,
                                                        scan_index,
                                                        charptr_tmp2,
                                                        capture_index);
                                else /* ISC */
                                        status = altera_swap_ir(astate,
                                                        long_count,
                                                        charptr_tmp,
                                                        scan_index,
                                                        charptr_tmp2,
                                                        capture_index);

                        }

                        break;
                }
                case OP_WAIT:
                        /*
                         * WAIT
                         * ...argument 0 is wait state
                         * ...argument 1 is end state
                         * ...stack 0 is cycles
                         * ...stack 1 is microseconds
                         */
                        if (!altera_check_stack(stack_ptr, 2, &status))
                                break;
                        long_tmp = stack[--stack_ptr];

                        if (long_tmp != 0L)
                                status = altera_wait_cycles(astate, long_tmp,
                                                                args[0]);

                        long_tmp = stack[--stack_ptr];

                        if ((status == 0) && (long_tmp != 0L))
                                status = altera_wait_msecs(astate,
                                                                long_tmp,
                                                                args[0]);

                        if ((status == 0) && (args[1] != args[0]))
                                status = altera_goto_jstate(astate,
                                                                args[1]);

                        if (version > 0) {
                                --stack_ptr; /* throw away MAX cycles */
                                --stack_ptr; /* throw away MAX microseconds */
                        }
                        break;
                case OP_CMPA: {
                        /*
                         * Array compare
                         * ...argument 0 is source 1 ID
                         * ...argument 1 is source 2 ID
                         * ...argument 2 is mask ID
                         * ...stack 0 is source 1 index
                         * ...stack 1 is source 2 index
                         * ...stack 2 is mask index
                         * ...stack 3 is count
                         */
                        s32 a, b;
                        u8 *source1 = (u8 *)vars[args[0]];
                        u8 *source2 = (u8 *)vars[args[1]];
                        u8 *mask = (u8 *)vars[args[2]];
                        u32 index1;
                        u32 index2;
                        u32 mask_index;

                        if (!altera_check_stack(stack_ptr, 4, &status))
                                break;

                        index1 = stack[--stack_ptr];
                        index2 = stack[--stack_ptr];
                        mask_index = stack[--stack_ptr];
                        long_count = stack[--stack_ptr];

                        if (version > 0) {
                                /*
                                 * stack 0 = source 1 right index
                                 * stack 1 = source 1 left index
                                 * stack 2 = source 2 right index
                                 * stack 3 = source 2 left index
                                 * stack 4 = mask right index
                                 * stack 5 = mask left index
                                 */
                                s32 mask_right = stack[--stack_ptr];
                                s32 mask_left = stack[--stack_ptr];
                                /* source 1 count */
                                a = 1 + index2 - index1;
                                /* source 2 count */
                                b = 1 + long_count - mask_index;
                                a = (a < b) ? a : b;
                                /* mask count */
                                b = 1 + mask_left - mask_right;
                                a = (a < b) ? a : b;
                                /* source 2 start index */
                                index2 = mask_index;
                                /* mask start index */
                                mask_index = mask_right;
                                long_count = a;
                        }

                        long_tmp = 1L;

                        if (long_count < 1)
                                status = -ERANGE;
                        else {
                                count = long_count;

                                for (i = 0; i < count; ++i) {
                                        if (mask[mask_index >> 3] &
                                                (1 << (mask_index & 7))) {
                                                a = source1[index1 >> 3] &
                                                        (1 << (index1 & 7))
                                                                ? 1 : 0;
                                                b = source2[index2 >> 3] &
                                                        (1 << (index2 & 7))
                                                                ? 1 : 0;

                                                if (a != b) /* failure */
                                                        long_tmp = 0L;
                                        }
                                        ++index1;
                                        ++index2;
                                        ++mask_index;
                                }
                        }

                        stack[stack_ptr++] = long_tmp;

                        break;
                }
                default:
                        /* Unrecognized opcode -- ERROR! */
                        bad_opcode = 1;
                        break;
                }

                if (bad_opcode)
                        status = -ENOSYS;

                if ((stack_ptr < 0) || (stack_ptr >= ALTERA_STACK_SIZE))
                        status = -EOVERFLOW;

                if (status != 0) {
                        done = 1;
                        *error_address = (s32)(opcode_address - code_sect);
                }
        }

        altera_free_buffers(astate);

        /* Free all dynamically allocated arrays */
        if ((attrs != NULL) && (vars != NULL))
                for (i = 0; i < sym_count; ++i)
                        if (attrs[i] & 0x80)
                                kfree((void *)vars[i]);

        kfree(vars);
        kfree(var_size);
        kfree(attrs);
        kfree(proc_attributes);

        return status;
}

static int altera_get_note(u8 *p, s32 program_size, s32 *offset,
                           char *key, char *value, int keylen, int vallen)
/*
 * Gets key and value of NOTE fields in the JBC file.
 * Can be called in two modes:  if offset pointer is NULL,
 * then the function searches for note fields which match
 * the key string provided.  If offset is not NULL, then
 * the function finds the next note field of any key,
 * starting at the offset specified by the offset pointer.
 * Returns 0 for success, else appropriate error code
 */
{
        int status = -ENODATA;
        u32 note_strings = 0L;
        u32 note_table = 0L;
        u32 note_count = 0L;
        u32 first_word = 0L;
        int version = 0;
        int delta = 0;
        char *key_ptr;
        char *value_ptr;
        int i;

        /* Read header information */
        if (program_size > 52L) {
                first_word    = get_unaligned_be32(&p[0]);
                version = (first_word & 1L);
                delta = version * 8;

                note_strings  = get_unaligned_be32(&p[8 + delta]);
                note_table    = get_unaligned_be32(&p[12 + delta]);
                note_count    = get_unaligned_be32(&p[44 + (2 * delta)]);
        }

        if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L))
                return -EIO;

        if (note_count <= 0L)
                return status;

        if (offset == NULL) {
                /*
                 * We will search for the first note with a specific key,
                 * and return only the value
                 */
                for (i = 0; (i < note_count) &&
                                                (status != 0); ++i) {
                        key_ptr = &p[note_strings +
                                        get_unaligned_be32(
                                        &p[note_table + (8 * i)])];
                        if (key && !strncasecmp(key, key_ptr, strlen(key_ptr))) {
                                status = 0;

                                value_ptr = &p[note_strings +
                                                get_unaligned_be32(
                                                &p[note_table + (8 * i) + 4])];

                                if (value != NULL)
                                        strscpy(value, value_ptr, vallen);

                        }
                }
        } else {
                /*
                 * We will search for the next note, regardless of the key,
                 * and return both the value and the key
                 */

                i = *offset;

                if ((i >= 0) && (i < note_count)) {
                        status = 0;

                        if (key != NULL)
                                strscpy(key, &p[note_strings +
                                                get_unaligned_be32(
                                                &p[note_table + (8 * i)])],
                                        keylen);

                        if (value != NULL)
                                strscpy(value, &p[note_strings +
                                                get_unaligned_be32(
                                                &p[note_table + (8 * i) + 4])],
                                        vallen);

                        *offset = i + 1;
                }
        }

        return status;
}

static int altera_check_crc(u8 *p, s32 program_size)
{
        int status = 0;
        u16 local_expected = 0,
            local_actual = 0,
            shift_reg = 0xffff;
        int bit, feedback;
        u8 databyte;
        u32 i;
        u32 crc_section = 0L;
        u32 first_word = 0L;
        int version = 0;
        int delta = 0;

        if (program_size > 52L) {
                first_word  = get_unaligned_be32(&p[0]);
                version = (first_word & 1L);
                delta = version * 8;

                crc_section = get_unaligned_be32(&p[32 + delta]);
        }

        if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L))
                status = -EIO;

        if (crc_section >= program_size)
                status = -EIO;

        if (status == 0) {
                local_expected = (u16)get_unaligned_be16(&p[crc_section]);

                for (i = 0; i < crc_section; ++i) {
                        databyte = p[i];
                        for (bit = 0; bit < 8; bit++) {
                                feedback = (databyte ^ shift_reg) & 0x01;
                                shift_reg >>= 1;
                                if (feedback)
                                        shift_reg ^= 0x8408;

                                databyte >>= 1;
                        }
                }

                local_actual = (u16)~shift_reg;

                if (local_expected != local_actual)
                        status = -EILSEQ;

        }

        if (debug || status) {
                switch (status) {
                case 0:
                        printk(KERN_INFO "%s: CRC matched: %04x\n", __func__,
                                local_actual);
                        break;
                case -EILSEQ:
                        printk(KERN_ERR "%s: CRC mismatch: expected %04x, "
                                "actual %04x\n", __func__, local_expected,
                                local_actual);
                        break;
                case -EIO:
                        printk(KERN_ERR "%s: error: format isn't "
                                "recognized.\n", __func__);
                        break;
                default:
                        printk(KERN_ERR "%s: CRC function returned error "
                                "code %d\n", __func__, status);
                        break;
                }
        }

        return status;
}

static int altera_get_file_info(u8 *p,
                                        s32 program_size,
                                        int *format_version,
                                        int *action_count,
                                        int *procedure_count)
{
        int status = -EIO;
        u32 first_word = 0;
        int version = 0;

        if (program_size <= 52L)
                return status;

        first_word = get_unaligned_be32(&p[0]);

        if ((first_word == 0x4A414D00L) || (first_word == 0x4A414D01L)) {
                status = 0;

                version = (first_word & 1L);
                *format_version = version + 1;

                if (version > 0) {
                        *action_count = get_unaligned_be32(&p[48]);
                        *procedure_count = get_unaligned_be32(&p[52]);
                }
        }

        return status;
}

static int altera_get_act_info(u8 *p,
                                        s32 program_size,
                                        int index,
                                        char **name,
                                        char **description,
                                        struct altera_procinfo **proc_list)
{
        int status = -EIO;
        struct altera_procinfo *procptr = NULL;
        struct altera_procinfo *tmpptr = NULL;
        u32 first_word = 0L;
        u32 action_table = 0L;
        u32 proc_table = 0L;
        u32 str_table = 0L;
        u32 note_strings = 0L;
        u32 action_count = 0L;
        u32 proc_count = 0L;
        u32 act_name_id = 0L;
        u32 act_desc_id = 0L;
        u32 act_proc_id = 0L;
        u32 act_proc_name = 0L;
        u8 act_proc_attribute = 0;

        if (program_size <= 52L)
                return status;
        /* Read header information */
        first_word = get_unaligned_be32(&p[0]);

        if (first_word != 0x4A414D01L)
                return status;

        action_table = get_unaligned_be32(&p[4]);
        proc_table   = get_unaligned_be32(&p[8]);
        str_table = get_unaligned_be32(&p[12]);
        note_strings = get_unaligned_be32(&p[16]);
        action_count = get_unaligned_be32(&p[48]);
        proc_count   = get_unaligned_be32(&p[52]);

        if (index >= action_count)
                return status;

        act_name_id = get_unaligned_be32(&p[action_table + (12 * index)]);
        act_desc_id = get_unaligned_be32(&p[action_table + (12 * index) + 4]);
        act_proc_id = get_unaligned_be32(&p[action_table + (12 * index) + 8]);

        *name = &p[str_table + act_name_id];

        if (act_desc_id < (note_strings - str_table))
                *description = &p[str_table + act_desc_id];

        do {
                act_proc_name = get_unaligned_be32(
                                        &p[proc_table + (13 * act_proc_id)]);
                act_proc_attribute =
                        (p[proc_table + (13 * act_proc_id) + 8] & 0x03);

                procptr =
                                kzalloc_obj(struct altera_procinfo);

                if (procptr == NULL)
                        status = -ENOMEM;
                else {
                        procptr->name = &p[str_table + act_proc_name];
                        procptr->attrs = act_proc_attribute;
                        procptr->next = NULL;

                        /* add record to end of linked list */
                        if (*proc_list == NULL)
                                *proc_list = procptr;
                        else {
                                tmpptr = *proc_list;
                                while (tmpptr->next != NULL)
                                        tmpptr = tmpptr->next;
                                tmpptr->next = procptr;
                        }
                }

                act_proc_id = get_unaligned_be32(
                                &p[proc_table + (13 * act_proc_id) + 4]);
        } while ((act_proc_id != 0) && (act_proc_id < proc_count));

        return status;
}

int altera_init(struct altera_config *config, const struct firmware *fw)
{
        struct altera_state *astate = NULL;
        struct altera_procinfo *proc_list = NULL;
        struct altera_procinfo *procptr = NULL;
        char *key = NULL;
        char *value = NULL;
        char *action_name = NULL;
        char *description = NULL;
        int exec_result = 0;
        int exit_code = 0;
        int format_version = 0;
        int action_count = 0;
        int procedure_count = 0;
        int index = 0;
        s32 offset = 0L;
        s32 error_address = 0L;
        int retval = 0;

        key = kzalloc(33, GFP_KERNEL);
        if (!key) {
                retval = -ENOMEM;
                goto out;
        }
        value = kzalloc(257, GFP_KERNEL);
        if (!value) {
                retval = -ENOMEM;
                goto free_key;
        }
        astate = kzalloc_obj(struct altera_state);
        if (!astate) {
                retval = -ENOMEM;
                goto free_value;
        }

        astate->config = config;
        if (!astate->config->jtag_io) {
                if (!IS_ENABLED(CONFIG_HAS_IOPORT)) {
                        retval = -ENODEV;
                        goto free_state;
                }
                dprintk("%s: using byteblaster!\n", __func__);
                astate->config->jtag_io = netup_jtag_io_lpt;
        }

        altera_check_crc((u8 *)fw->data, fw->size);

        if (debug) {
                altera_get_file_info((u8 *)fw->data, fw->size, &format_version,
                                        &action_count, &procedure_count);
                printk(KERN_INFO "%s: File format is %s ByteCode format\n",
                        __func__, (format_version == 2) ? "Jam STAPL" :
                                                "pre-standardized Jam 1.1");
                while (altera_get_note((u8 *)fw->data, fw->size,
                                        &offset, key, value, 32, 256) == 0)
                        printk(KERN_INFO "%s: NOTE \"%s\" = \"%s\"\n",
                                        __func__, key, value);
        }

        if (debug && (format_version == 2) && (action_count > 0)) {
                printk(KERN_INFO "%s: Actions available:\n", __func__);
                for (index = 0; index < action_count; ++index) {
                        altera_get_act_info((u8 *)fw->data, fw->size,
                                                index, &action_name,
                                                &description,
                                                &proc_list);

                        if (description == NULL)
                                printk(KERN_INFO "%s: %s\n",
                                                __func__,
                                                action_name);
                        else
                                printk(KERN_INFO "%s: %s \"%s\"\n",
                                                __func__,
                                                action_name,
                                                description);

                        procptr = proc_list;
                        while (procptr != NULL) {
                                if (procptr->attrs != 0)
                                        printk(KERN_INFO "%s:    %s (%s)\n",
                                                __func__,
                                                procptr->name,
                                                (procptr->attrs == 1) ?
                                                "optional" : "recommended");

                                proc_list = procptr->next;
                                kfree(procptr);
                                procptr = proc_list;
                        }
                }

                printk(KERN_INFO "\n");
        }

        exec_result = altera_execute(astate, (u8 *)fw->data, fw->size,
                                &error_address, &exit_code, &format_version);

        if (exit_code)
                exec_result = -EREMOTEIO;

        if ((format_version == 2) && (exec_result == -EINVAL)) {
                if (astate->config->action == NULL)
                        printk(KERN_ERR "%s: error: no action specified for "
                                "Jam STAPL file.\nprogram terminated.\n",
                                __func__);
                else
                        printk(KERN_ERR "%s: error: action \"%s\""
                                " is not supported "
                                "for this Jam STAPL file.\n"
                                "Program terminated.\n", __func__,
                                astate->config->action);

        } else if (exec_result)
                printk(KERN_ERR "%s: error %d\n", __func__, exec_result);
free_state:
        kfree(astate);
free_value:
        kfree(value);
free_key:
        kfree(key);
out:
        return retval;
}
EXPORT_SYMBOL(altera_init);