linux/drivers/misc/altera-stapl/altera.c
<<
>>
Prefs
   1/*
   2 * altera.c
   3 *
   4 * altera FPGA driver
   5 *
   6 * Copyright (C) Altera Corporation 1998-2001
   7 * Copyright (C) 2010,2011 NetUP Inc.
   8 * Copyright (C) 2010,2011 Igor M. Liplianin <liplianin@netup.ru>
   9 *
  10 * This program is free software; you can redistribute it and/or modify
  11 * it under the terms of the GNU General Public License as published by
  12 * the Free Software Foundation; either version 2 of the License, or
  13 * (at your option) any later version.
  14 *
  15 * This program is distributed in the hope that it will be useful,
  16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18 *
  19 * GNU General Public License for more details.
  20 *
  21 * You should have received a copy of the GNU General Public License
  22 * along with this program; if not, write to the Free Software
  23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  24 */
  25
  26#include <asm/unaligned.h>
  27#include <linux/ctype.h>
  28#include <linux/string.h>
  29#include <linux/firmware.h>
  30#include <linux/slab.h>
  31#include <linux/module.h>
  32#include <misc/altera.h>
  33#include "altera-exprt.h"
  34#include "altera-jtag.h"
  35
  36static int debug = 1;
  37module_param(debug, int, 0644);
  38MODULE_PARM_DESC(debug, "enable debugging information");
  39
  40MODULE_DESCRIPTION("altera FPGA kernel module");
  41MODULE_AUTHOR("Igor M. Liplianin  <liplianin@netup.ru>");
  42MODULE_LICENSE("GPL");
  43
  44#define dprintk(args...) \
  45        if (debug) { \
  46                printk(KERN_DEBUG args); \
  47        }
  48
  49enum altera_fpga_opcode {
  50        OP_NOP = 0,
  51        OP_DUP,
  52        OP_SWP,
  53        OP_ADD,
  54        OP_SUB,
  55        OP_MULT,
  56        OP_DIV,
  57        OP_MOD,
  58        OP_SHL,
  59        OP_SHR,
  60        OP_NOT,
  61        OP_AND,
  62        OP_OR,
  63        OP_XOR,
  64        OP_INV,
  65        OP_GT,
  66        OP_LT,
  67        OP_RET,
  68        OP_CMPS,
  69        OP_PINT,
  70        OP_PRNT,
  71        OP_DSS,
  72        OP_DSSC,
  73        OP_ISS,
  74        OP_ISSC,
  75        OP_DPR = 0x1c,
  76        OP_DPRL,
  77        OP_DPO,
  78        OP_DPOL,
  79        OP_IPR,
  80        OP_IPRL,
  81        OP_IPO,
  82        OP_IPOL,
  83        OP_PCHR,
  84        OP_EXIT,
  85        OP_EQU,
  86        OP_POPT,
  87        OP_ABS = 0x2c,
  88        OP_BCH0,
  89        OP_PSH0 = 0x2f,
  90        OP_PSHL = 0x40,
  91        OP_PSHV,
  92        OP_JMP,
  93        OP_CALL,
  94        OP_NEXT,
  95        OP_PSTR,
  96        OP_SINT = 0x47,
  97        OP_ST,
  98        OP_ISTP,
  99        OP_DSTP,
 100        OP_SWPN,
 101        OP_DUPN,
 102        OP_POPV,
 103        OP_POPE,
 104        OP_POPA,
 105        OP_JMPZ,
 106        OP_DS,
 107        OP_IS,
 108        OP_DPRA,
 109        OP_DPOA,
 110        OP_IPRA,
 111        OP_IPOA,
 112        OP_EXPT,
 113        OP_PSHE,
 114        OP_PSHA,
 115        OP_DYNA,
 116        OP_EXPV = 0x5c,
 117        OP_COPY = 0x80,
 118        OP_REVA,
 119        OP_DSC,
 120        OP_ISC,
 121        OP_WAIT,
 122        OP_VS,
 123        OP_CMPA = 0xc0,
 124        OP_VSC,
 125};
 126
 127struct altera_procinfo {
 128        char                    *name;
 129        u8                      attrs;
 130        struct altera_procinfo  *next;
 131};
 132
 133/* This function checks if enough parameters are available on the stack. */
 134static int altera_check_stack(int stack_ptr, int count, int *status)
 135{
 136        if (stack_ptr < count) {
 137                *status = -EOVERFLOW;
 138                return 0;
 139        }
 140
 141        return 1;
 142}
 143
 144static void altera_export_int(char *key, s32 value)
 145{
 146        dprintk("Export: key = \"%s\", value = %d\n", key, value);
 147}
 148
 149#define HEX_LINE_CHARS 72
 150#define HEX_LINE_BITS (HEX_LINE_CHARS * 4)
 151
 152static void altera_export_bool_array(char *key, u8 *data, s32 count)
 153{
 154        char string[HEX_LINE_CHARS + 1];
 155        s32 i, offset;
 156        u32 size, line, lines, linebits, value, j, k;
 157
 158        if (count > HEX_LINE_BITS) {
 159                dprintk("Export: key = \"%s\", %d bits, value = HEX\n",
 160                                                        key, count);
 161                lines = (count + (HEX_LINE_BITS - 1)) / HEX_LINE_BITS;
 162
 163                for (line = 0; line < lines; ++line) {
 164                        if (line < (lines - 1)) {
 165                                linebits = HEX_LINE_BITS;
 166                                size = HEX_LINE_CHARS;
 167                                offset = count - ((line + 1) * HEX_LINE_BITS);
 168                        } else {
 169                                linebits =
 170                                        count - ((lines - 1) * HEX_LINE_BITS);
 171                                size = (linebits + 3) / 4;
 172                                offset = 0L;
 173                        }
 174
 175                        string[size] = '\0';
 176                        j = size - 1;
 177                        value = 0;
 178
 179                        for (k = 0; k < linebits; ++k) {
 180                                i = k + offset;
 181                                if (data[i >> 3] & (1 << (i & 7)))
 182                                        value |= (1 << (i & 3));
 183                                if ((i & 3) == 3) {
 184                                        sprintf(&string[j], "%1x", value);
 185                                        value = 0;
 186                                        --j;
 187                                }
 188                        }
 189                        if ((k & 3) > 0)
 190                                sprintf(&string[j], "%1x", value);
 191
 192                        dprintk("%s\n", string);
 193                }
 194
 195        } else {
 196                size = (count + 3) / 4;
 197                string[size] = '\0';
 198                j = size - 1;
 199                value = 0;
 200
 201                for (i = 0; i < count; ++i) {
 202                        if (data[i >> 3] & (1 << (i & 7)))
 203                                value |= (1 << (i & 3));
 204                        if ((i & 3) == 3) {
 205                                sprintf(&string[j], "%1x", value);
 206                                value = 0;
 207                                --j;
 208                        }
 209                }
 210                if ((i & 3) > 0)
 211                        sprintf(&string[j], "%1x", value);
 212
 213                dprintk("Export: key = \"%s\", %d bits, value = HEX %s\n",
 214                        key, count, string);
 215        }
 216}
 217
 218static int altera_execute(struct altera_state *astate,
 219                                u8 *p,
 220                                s32 program_size,
 221                                s32 *error_address,
 222                                int *exit_code,
 223                                int *format_version)
 224{
 225        struct altera_config *aconf = astate->config;
 226        char *msg_buff = astate->msg_buff;
 227        long *stack = astate->stack;
 228        int status = 0;
 229        u32 first_word = 0L;
 230        u32 action_table = 0L;
 231        u32 proc_table = 0L;
 232        u32 str_table = 0L;
 233        u32 sym_table = 0L;
 234        u32 data_sect = 0L;
 235        u32 code_sect = 0L;
 236        u32 debug_sect = 0L;
 237        u32 action_count = 0L;
 238        u32 proc_count = 0L;
 239        u32 sym_count = 0L;
 240        long *vars = NULL;
 241        s32 *var_size = NULL;
 242        char *attrs = NULL;
 243        u8 *proc_attributes = NULL;
 244        u32 pc;
 245        u32 opcode_address;
 246        u32 args[3];
 247        u32 opcode;
 248        u32 name_id;
 249        u8 charbuf[4];
 250        long long_tmp;
 251        u32 variable_id;
 252        u8 *charptr_tmp;
 253        u8 *charptr_tmp2;
 254        long *longptr_tmp;
 255        int version = 0;
 256        int delta = 0;
 257        int stack_ptr = 0;
 258        u32 arg_count;
 259        int done = 0;
 260        int bad_opcode = 0;
 261        u32 count;
 262        u32 index;
 263        u32 index2;
 264        s32 long_count;
 265        s32 long_idx;
 266        s32 long_idx2;
 267        u32 i;
 268        u32 j;
 269        u32 uncomp_size;
 270        u32 offset;
 271        u32 value;
 272        int current_proc = 0;
 273        int reverse;
 274
 275        char *name;
 276
 277        dprintk("%s\n", __func__);
 278
 279        /* Read header information */
 280        if (program_size > 52L) {
 281                first_word    = get_unaligned_be32(&p[0]);
 282                version = (first_word & 1L);
 283                *format_version = version + 1;
 284                delta = version * 8;
 285
 286                action_table  = get_unaligned_be32(&p[4]);
 287                proc_table    = get_unaligned_be32(&p[8]);
 288                str_table  = get_unaligned_be32(&p[4 + delta]);
 289                sym_table  = get_unaligned_be32(&p[16 + delta]);
 290                data_sect  = get_unaligned_be32(&p[20 + delta]);
 291                code_sect  = get_unaligned_be32(&p[24 + delta]);
 292                debug_sect = get_unaligned_be32(&p[28 + delta]);
 293                action_count  = get_unaligned_be32(&p[40 + delta]);
 294                proc_count    = get_unaligned_be32(&p[44 + delta]);
 295                sym_count  = get_unaligned_be32(&p[48 + (2 * delta)]);
 296        }
 297
 298        if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L)) {
 299                done = 1;
 300                status = -EIO;
 301                goto exit_done;
 302        }
 303
 304        if (sym_count <= 0)
 305                goto exit_done;
 306
 307        vars = kzalloc(sym_count * sizeof(long), GFP_KERNEL);
 308
 309        if (vars == NULL)
 310                status = -ENOMEM;
 311
 312        if (status == 0) {
 313                var_size = kzalloc(sym_count * sizeof(s32), GFP_KERNEL);
 314
 315                if (var_size == NULL)
 316                        status = -ENOMEM;
 317        }
 318
 319        if (status == 0) {
 320                attrs = kzalloc(sym_count, GFP_KERNEL);
 321
 322                if (attrs == NULL)
 323                        status = -ENOMEM;
 324        }
 325
 326        if ((status == 0) && (version > 0)) {
 327                proc_attributes = kzalloc(proc_count, GFP_KERNEL);
 328
 329                if (proc_attributes == NULL)
 330                        status = -ENOMEM;
 331        }
 332
 333        if (status != 0)
 334                goto exit_done;
 335
 336        delta = version * 2;
 337
 338        for (i = 0; i < sym_count; ++i) {
 339                offset = (sym_table + ((11 + delta) * i));
 340
 341                value = get_unaligned_be32(&p[offset + 3 + delta]);
 342
 343                attrs[i] = p[offset];
 344
 345                /*
 346                 * use bit 7 of attribute byte to indicate that
 347                 * this buffer was dynamically allocated
 348                 * and should be freed later
 349                 */
 350                attrs[i] &= 0x7f;
 351
 352                var_size[i] = get_unaligned_be32(&p[offset + 7 + delta]);
 353
 354                /*
 355                 * Attribute bits:
 356                 * bit 0: 0 = read-only, 1 = read-write
 357                 * bit 1: 0 = not compressed, 1 = compressed
 358                 * bit 2: 0 = not initialized, 1 = initialized
 359                 * bit 3: 0 = scalar, 1 = array
 360                 * bit 4: 0 = Boolean, 1 = integer
 361                 * bit 5: 0 = declared variable,
 362                 *      1 = compiler created temporary variable
 363                 */
 364
 365                if ((attrs[i] & 0x0c) == 0x04)
 366                        /* initialized scalar variable */
 367                        vars[i] = value;
 368                else if ((attrs[i] & 0x1e) == 0x0e) {
 369                        /* initialized compressed Boolean array */
 370                        uncomp_size = get_unaligned_le32(&p[data_sect + value]);
 371
 372                        /* allocate a buffer for the uncompressed data */
 373                        vars[i] = (long)kzalloc(uncomp_size, GFP_KERNEL);
 374                        if (vars[i] == 0L)
 375                                status = -ENOMEM;
 376                        else {
 377                                /* set flag so buffer will be freed later */
 378                                attrs[i] |= 0x80;
 379
 380                                /* uncompress the data */
 381                                if (altera_shrink(&p[data_sect + value],
 382                                                var_size[i],
 383                                                (u8 *)vars[i],
 384                                                uncomp_size,
 385                                                version) != uncomp_size)
 386                                        /* decompression failed */
 387                                        status = -EIO;
 388                                else
 389                                        var_size[i] = uncomp_size * 8L;
 390
 391                        }
 392                } else if ((attrs[i] & 0x1e) == 0x0c) {
 393                        /* initialized Boolean array */
 394                        vars[i] = value + data_sect + (long)p;
 395                } else if ((attrs[i] & 0x1c) == 0x1c) {
 396                        /* initialized integer array */
 397                        vars[i] = value + data_sect;
 398                } else if ((attrs[i] & 0x0c) == 0x08) {
 399                        /* uninitialized array */
 400
 401                        /* flag attrs so that memory is freed */
 402                        attrs[i] |= 0x80;
 403
 404                        if (var_size[i] > 0) {
 405                                u32 size;
 406
 407                                if (attrs[i] & 0x10)
 408                                        /* integer array */
 409                                        size = (var_size[i] * sizeof(s32));
 410                                else
 411                                        /* Boolean array */
 412                                        size = ((var_size[i] + 7L) / 8L);
 413
 414                                vars[i] = (long)kzalloc(size, GFP_KERNEL);
 415
 416                                if (vars[i] == 0) {
 417                                        status = -ENOMEM;
 418                                } else {
 419                                        /* zero out memory */
 420                                        for (j = 0; j < size; ++j)
 421                                                ((u8 *)(vars[i]))[j] = 0;
 422
 423                                }
 424                        } else
 425                                vars[i] = 0;
 426
 427                } else
 428                        vars[i] = 0;
 429
 430        }
 431
 432exit_done:
 433        if (status != 0)
 434                done = 1;
 435
 436        altera_jinit(astate);
 437
 438        pc = code_sect;
 439        msg_buff[0] = '\0';
 440
 441        /*
 442         * For JBC version 2, we will execute the procedures corresponding to
 443         * the selected ACTION
 444         */
 445        if (version > 0) {
 446                if (aconf->action == NULL) {
 447                        status = -EINVAL;
 448                        done = 1;
 449                } else {
 450                        int action_found = 0;
 451                        for (i = 0; (i < action_count) && !action_found; ++i) {
 452                                name_id = get_unaligned_be32(&p[action_table +
 453                                                                (12 * i)]);
 454
 455                                name = &p[str_table + name_id];
 456
 457                                if (strnicmp(aconf->action, name, strlen(name)) == 0) {
 458                                        action_found = 1;
 459                                        current_proc =
 460                                                get_unaligned_be32(&p[action_table +
 461                                                                (12 * i) + 8]);
 462                                }
 463                        }
 464
 465                        if (!action_found) {
 466                                status = -EINVAL;
 467                                done = 1;
 468                        }
 469                }
 470
 471                if (status == 0) {
 472                        int first_time = 1;
 473                        i = current_proc;
 474                        while ((i != 0) || first_time) {
 475                                first_time = 0;
 476                                /* check procedure attribute byte */
 477                                proc_attributes[i] =
 478                                                (p[proc_table +
 479                                                                (13 * i) + 8] &
 480                                                                        0x03);
 481
 482                                /*
 483                                 * BIT0 - OPTIONAL
 484                                 * BIT1 - RECOMMENDED
 485                                 * BIT6 - FORCED OFF
 486                                 * BIT7 - FORCED ON
 487                                 */
 488
 489                                i = get_unaligned_be32(&p[proc_table +
 490                                                        (13 * i) + 4]);
 491                        }
 492
 493                        /*
 494                         * Set current_proc to the first procedure
 495                         * to be executed
 496                         */
 497                        i = current_proc;
 498                        while ((i != 0) &&
 499                                ((proc_attributes[i] == 1) ||
 500                                ((proc_attributes[i] & 0xc0) == 0x40))) {
 501                                i = get_unaligned_be32(&p[proc_table +
 502                                                        (13 * i) + 4]);
 503                        }
 504
 505                        if ((i != 0) || ((i == 0) && (current_proc == 0) &&
 506                                ((proc_attributes[0] != 1) &&
 507                                ((proc_attributes[0] & 0xc0) != 0x40)))) {
 508                                current_proc = i;
 509                                pc = code_sect +
 510                                        get_unaligned_be32(&p[proc_table +
 511                                                                (13 * i) + 9]);
 512                                if ((pc < code_sect) || (pc >= debug_sect))
 513                                        status = -ERANGE;
 514                        } else
 515                                /* there are no procedures to execute! */
 516                                done = 1;
 517
 518                }
 519        }
 520
 521        msg_buff[0] = '\0';
 522
 523        while (!done) {
 524                opcode = (p[pc] & 0xff);
 525                opcode_address = pc;
 526                ++pc;
 527
 528                if (debug > 1)
 529                        printk("opcode: %02x\n", opcode);
 530
 531                arg_count = (opcode >> 6) & 3;
 532                for (i = 0; i < arg_count; ++i) {
 533                        args[i] = get_unaligned_be32(&p[pc]);
 534                        pc += 4;
 535                }
 536
 537                switch (opcode) {
 538                case OP_NOP:
 539                        break;
 540                case OP_DUP:
 541                        if (altera_check_stack(stack_ptr, 1, &status)) {
 542                                stack[stack_ptr] = stack[stack_ptr - 1];
 543                                ++stack_ptr;
 544                        }
 545                        break;
 546                case OP_SWP:
 547                        if (altera_check_stack(stack_ptr, 2, &status)) {
 548                                long_tmp = stack[stack_ptr - 2];
 549                                stack[stack_ptr - 2] = stack[stack_ptr - 1];
 550                                stack[stack_ptr - 1] = long_tmp;
 551                        }
 552                        break;
 553                case OP_ADD:
 554                        if (altera_check_stack(stack_ptr, 2, &status)) {
 555                                --stack_ptr;
 556                                stack[stack_ptr - 1] += stack[stack_ptr];
 557                        }
 558                        break;
 559                case OP_SUB:
 560                        if (altera_check_stack(stack_ptr, 2, &status)) {
 561                                --stack_ptr;
 562                                stack[stack_ptr - 1] -= stack[stack_ptr];
 563                        }
 564                        break;
 565                case OP_MULT:
 566                        if (altera_check_stack(stack_ptr, 2, &status)) {
 567                                --stack_ptr;
 568                                stack[stack_ptr - 1] *= stack[stack_ptr];
 569                        }
 570                        break;
 571                case OP_DIV:
 572                        if (altera_check_stack(stack_ptr, 2, &status)) {
 573                                --stack_ptr;
 574                                stack[stack_ptr - 1] /= stack[stack_ptr];
 575                        }
 576                        break;
 577                case OP_MOD:
 578                        if (altera_check_stack(stack_ptr, 2, &status)) {
 579                                --stack_ptr;
 580                                stack[stack_ptr - 1] %= stack[stack_ptr];
 581                        }
 582                        break;
 583                case OP_SHL:
 584                        if (altera_check_stack(stack_ptr, 2, &status)) {
 585                                --stack_ptr;
 586                                stack[stack_ptr - 1] <<= stack[stack_ptr];
 587                        }
 588                        break;
 589                case OP_SHR:
 590                        if (altera_check_stack(stack_ptr, 2, &status)) {
 591                                --stack_ptr;
 592                                stack[stack_ptr - 1] >>= stack[stack_ptr];
 593                        }
 594                        break;
 595                case OP_NOT:
 596                        if (altera_check_stack(stack_ptr, 1, &status))
 597                                stack[stack_ptr - 1] ^= (-1L);
 598
 599                        break;
 600                case OP_AND:
 601                        if (altera_check_stack(stack_ptr, 2, &status)) {
 602                                --stack_ptr;
 603                                stack[stack_ptr - 1] &= stack[stack_ptr];
 604                        }
 605                        break;
 606                case OP_OR:
 607                        if (altera_check_stack(stack_ptr, 2, &status)) {
 608                                --stack_ptr;
 609                                stack[stack_ptr - 1] |= stack[stack_ptr];
 610                        }
 611                        break;
 612                case OP_XOR:
 613                        if (altera_check_stack(stack_ptr, 2, &status)) {
 614                                --stack_ptr;
 615                                stack[stack_ptr - 1] ^= stack[stack_ptr];
 616                        }
 617                        break;
 618                case OP_INV:
 619                        if (!altera_check_stack(stack_ptr, 1, &status))
 620                                break;
 621                        stack[stack_ptr - 1] = stack[stack_ptr - 1] ? 0L : 1L;
 622                        break;
 623                case OP_GT:
 624                        if (!altera_check_stack(stack_ptr, 2, &status))
 625                                break;
 626                        --stack_ptr;
 627                        stack[stack_ptr - 1] =
 628                                (stack[stack_ptr - 1] > stack[stack_ptr]) ?
 629                                                                        1L : 0L;
 630
 631                        break;
 632                case OP_LT:
 633                        if (!altera_check_stack(stack_ptr, 2, &status))
 634                                break;
 635                        --stack_ptr;
 636                        stack[stack_ptr - 1] =
 637                                (stack[stack_ptr - 1] < stack[stack_ptr]) ?
 638                                                                        1L : 0L;
 639
 640                        break;
 641                case OP_RET:
 642                        if ((version > 0) && (stack_ptr == 0)) {
 643                                /*
 644                                 * We completed one of the main procedures
 645                                 * of an ACTION.
 646                                 * Find the next procedure
 647                                 * to be executed and jump to it.
 648                                 * If there are no more procedures, then EXIT.
 649                                 */
 650                                i = get_unaligned_be32(&p[proc_table +
 651                                                (13 * current_proc) + 4]);
 652                                while ((i != 0) &&
 653                                        ((proc_attributes[i] == 1) ||
 654                                        ((proc_attributes[i] & 0xc0) == 0x40)))
 655                                        i = get_unaligned_be32(&p[proc_table +
 656                                                                (13 * i) + 4]);
 657
 658                                if (i == 0) {
 659                                        /* no procedures to execute! */
 660                                        done = 1;
 661                                        *exit_code = 0; /* success */
 662                                } else {
 663                                        current_proc = i;
 664                                        pc = code_sect + get_unaligned_be32(
 665                                                                &p[proc_table +
 666                                                                (13 * i) + 9]);
 667                                        if ((pc < code_sect) ||
 668                                            (pc >= debug_sect))
 669                                                status = -ERANGE;
 670                                }
 671
 672                        } else
 673                                if (altera_check_stack(stack_ptr, 1, &status)) {
 674                                        pc = stack[--stack_ptr] + code_sect;
 675                                        if ((pc <= code_sect) ||
 676                                            (pc >= debug_sect))
 677                                                status = -ERANGE;
 678
 679                                }
 680
 681                        break;
 682                case OP_CMPS:
 683                        /*
 684                         * Array short compare
 685                         * ...stack 0 is source 1 value
 686                         * ...stack 1 is source 2 value
 687                         * ...stack 2 is mask value
 688                         * ...stack 3 is count
 689                         */
 690                        if (altera_check_stack(stack_ptr, 4, &status)) {
 691                                s32 a = stack[--stack_ptr];
 692                                s32 b = stack[--stack_ptr];
 693                                long_tmp = stack[--stack_ptr];
 694                                count = stack[stack_ptr - 1];
 695
 696                                if ((count < 1) || (count > 32))
 697                                        status = -ERANGE;
 698                                else {
 699                                        long_tmp &= ((-1L) >> (32 - count));
 700
 701                                        stack[stack_ptr - 1] =
 702                                        ((a & long_tmp) == (b & long_tmp))
 703                                                                ? 1L : 0L;
 704                                }
 705                        }
 706                        break;
 707                case OP_PINT:
 708                        /*
 709                         * PRINT add integer
 710                         * ...stack 0 is integer value
 711                         */
 712                        if (!altera_check_stack(stack_ptr, 1, &status))
 713                                break;
 714                        sprintf(&msg_buff[strlen(msg_buff)],
 715                                        "%ld", stack[--stack_ptr]);
 716                        break;
 717                case OP_PRNT:
 718                        /* PRINT finish */
 719                        if (debug)
 720                                printk(msg_buff, "\n");
 721
 722                        msg_buff[0] = '\0';
 723                        break;
 724                case OP_DSS:
 725                        /*
 726                         * DRSCAN short
 727                         * ...stack 0 is scan data
 728                         * ...stack 1 is count
 729                         */
 730                        if (!altera_check_stack(stack_ptr, 2, &status))
 731                                break;
 732                        long_tmp = stack[--stack_ptr];
 733                        count = stack[--stack_ptr];
 734                        put_unaligned_le32(long_tmp, &charbuf[0]);
 735                        status = altera_drscan(astate, count, charbuf, 0);
 736                        break;
 737                case OP_DSSC:
 738                        /*
 739                         * DRSCAN short with capture
 740                         * ...stack 0 is scan data
 741                         * ...stack 1 is count
 742                         */
 743                        if (!altera_check_stack(stack_ptr, 2, &status))
 744                                break;
 745                        long_tmp = stack[--stack_ptr];
 746                        count = stack[stack_ptr - 1];
 747                        put_unaligned_le32(long_tmp, &charbuf[0]);
 748                        status = altera_swap_dr(astate, count, charbuf,
 749                                                        0, charbuf, 0);
 750                        stack[stack_ptr - 1] = get_unaligned_le32(&charbuf[0]);
 751                        break;
 752                case OP_ISS:
 753                        /*
 754                         * IRSCAN short
 755                         * ...stack 0 is scan data
 756                         * ...stack 1 is count
 757                         */
 758                        if (!altera_check_stack(stack_ptr, 2, &status))
 759                                break;
 760                        long_tmp = stack[--stack_ptr];
 761                        count = stack[--stack_ptr];
 762                        put_unaligned_le32(long_tmp, &charbuf[0]);
 763                        status = altera_irscan(astate, count, charbuf, 0);
 764                        break;
 765                case OP_ISSC:
 766                        /*
 767                         * IRSCAN short with capture
 768                         * ...stack 0 is scan data
 769                         * ...stack 1 is count
 770                         */
 771                        if (!altera_check_stack(stack_ptr, 2, &status))
 772                                break;
 773                        long_tmp = stack[--stack_ptr];
 774                        count = stack[stack_ptr - 1];
 775                        put_unaligned_le32(long_tmp, &charbuf[0]);
 776                        status = altera_swap_ir(astate, count, charbuf,
 777                                                        0, charbuf, 0);
 778                        stack[stack_ptr - 1] = get_unaligned_le32(&charbuf[0]);
 779                        break;
 780                case OP_DPR:
 781                        if (!altera_check_stack(stack_ptr, 1, &status))
 782                                break;
 783                        count = stack[--stack_ptr];
 784                        status = altera_set_dr_pre(&astate->js, count, 0, NULL);
 785                        break;
 786                case OP_DPRL:
 787                        /*
 788                         * DRPRE with literal data
 789                         * ...stack 0 is count
 790                         * ...stack 1 is literal data
 791                         */
 792                        if (!altera_check_stack(stack_ptr, 2, &status))
 793                                break;
 794                        count = stack[--stack_ptr];
 795                        long_tmp = stack[--stack_ptr];
 796                        put_unaligned_le32(long_tmp, &charbuf[0]);
 797                        status = altera_set_dr_pre(&astate->js, count, 0,
 798                                                charbuf);
 799                        break;
 800                case OP_DPO:
 801                        /*
 802                         * DRPOST
 803                         * ...stack 0 is count
 804                         */
 805                        if (altera_check_stack(stack_ptr, 1, &status)) {
 806                                count = stack[--stack_ptr];
 807                                status = altera_set_dr_post(&astate->js, count,
 808                                                                0, NULL);
 809                        }
 810                        break;
 811                case OP_DPOL:
 812                        /*
 813                         * DRPOST with literal data
 814                         * ...stack 0 is count
 815                         * ...stack 1 is literal data
 816                         */
 817                        if (!altera_check_stack(stack_ptr, 2, &status))
 818                                break;
 819                        count = stack[--stack_ptr];
 820                        long_tmp = stack[--stack_ptr];
 821                        put_unaligned_le32(long_tmp, &charbuf[0]);
 822                        status = altera_set_dr_post(&astate->js, count, 0,
 823                                                        charbuf);
 824                        break;
 825                case OP_IPR:
 826                        if (altera_check_stack(stack_ptr, 1, &status)) {
 827                                count = stack[--stack_ptr];
 828                                status = altera_set_ir_pre(&astate->js, count,
 829                                                                0, NULL);
 830                        }
 831                        break;
 832                case OP_IPRL:
 833                        /*
 834                         * IRPRE with literal data
 835                         * ...stack 0 is count
 836                         * ...stack 1 is literal data
 837                         */
 838                        if (altera_check_stack(stack_ptr, 2, &status)) {
 839                                count = stack[--stack_ptr];
 840                                long_tmp = stack[--stack_ptr];
 841                                put_unaligned_le32(long_tmp, &charbuf[0]);
 842                                status = altera_set_ir_pre(&astate->js, count,
 843                                                        0, charbuf);
 844                        }
 845                        break;
 846                case OP_IPO:
 847                        /*
 848                         * IRPOST
 849                         * ...stack 0 is count
 850                         */
 851                        if (altera_check_stack(stack_ptr, 1, &status)) {
 852                                count = stack[--stack_ptr];
 853                                status = altera_set_ir_post(&astate->js, count,
 854                                                        0, NULL);
 855                        }
 856                        break;
 857                case OP_IPOL:
 858                        /*
 859                         * IRPOST with literal data
 860                         * ...stack 0 is count
 861                         * ...stack 1 is literal data
 862                         */
 863                        if (!altera_check_stack(stack_ptr, 2, &status))
 864                                break;
 865                        count = stack[--stack_ptr];
 866                        long_tmp = stack[--stack_ptr];
 867                        put_unaligned_le32(long_tmp, &charbuf[0]);
 868                        status = altera_set_ir_post(&astate->js, count, 0,
 869                                                        charbuf);
 870                        break;
 871                case OP_PCHR:
 872                        if (altera_check_stack(stack_ptr, 1, &status)) {
 873                                u8 ch;
 874                                count = strlen(msg_buff);
 875                                ch = (char) stack[--stack_ptr];
 876                                if ((ch < 1) || (ch > 127)) {
 877                                        /*
 878                                         * character code out of range
 879                                         * instead of flagging an error,
 880                                         * force the value to 127
 881                                         */
 882                                        ch = 127;
 883                                }
 884                                msg_buff[count] = ch;
 885                                msg_buff[count + 1] = '\0';
 886                        }
 887                        break;
 888                case OP_EXIT:
 889                        if (altera_check_stack(stack_ptr, 1, &status))
 890                                *exit_code = stack[--stack_ptr];
 891
 892                        done = 1;
 893                        break;
 894                case OP_EQU:
 895                        if (!altera_check_stack(stack_ptr, 2, &status))
 896                                break;
 897                        --stack_ptr;
 898                        stack[stack_ptr - 1] =
 899                                (stack[stack_ptr - 1] == stack[stack_ptr]) ?
 900                                                                        1L : 0L;
 901                        break;
 902                case OP_POPT:
 903                        if (altera_check_stack(stack_ptr, 1, &status))
 904                                --stack_ptr;
 905
 906                        break;
 907                case OP_ABS:
 908                        if (!altera_check_stack(stack_ptr, 1, &status))
 909                                break;
 910                        if (stack[stack_ptr - 1] < 0)
 911                                stack[stack_ptr - 1] = 0 - stack[stack_ptr - 1];
 912
 913                        break;
 914                case OP_BCH0:
 915                        /*
 916                         * Batch operation 0
 917                         * SWP
 918                         * SWPN 7
 919                         * SWP
 920                         * SWPN 6
 921                         * DUPN 8
 922                         * SWPN 2
 923                         * SWP
 924                         * DUPN 6
 925                         * DUPN 6
 926                         */
 927
 928                        /* SWP  */
 929                        if (altera_check_stack(stack_ptr, 2, &status)) {
 930                                long_tmp = stack[stack_ptr - 2];
 931                                stack[stack_ptr - 2] = stack[stack_ptr - 1];
 932                                stack[stack_ptr - 1] = long_tmp;
 933                        }
 934
 935                        /* SWPN 7 */
 936                        index = 7 + 1;
 937                        if (altera_check_stack(stack_ptr, index, &status)) {
 938                                long_tmp = stack[stack_ptr - index];
 939                                stack[stack_ptr - index] = stack[stack_ptr - 1];
 940                                stack[stack_ptr - 1] = long_tmp;
 941                        }
 942
 943                        /* SWP  */
 944                        if (altera_check_stack(stack_ptr, 2, &status)) {
 945                                long_tmp = stack[stack_ptr - 2];
 946                                stack[stack_ptr - 2] = stack[stack_ptr - 1];
 947                                stack[stack_ptr - 1] = long_tmp;
 948                        }
 949
 950                        /* SWPN 6 */
 951                        index = 6 + 1;
 952                        if (altera_check_stack(stack_ptr, index, &status)) {
 953                                long_tmp = stack[stack_ptr - index];
 954                                stack[stack_ptr - index] = stack[stack_ptr - 1];
 955                                stack[stack_ptr - 1] = long_tmp;
 956                        }
 957
 958                        /* DUPN 8 */
 959                        index = 8 + 1;
 960                        if (altera_check_stack(stack_ptr, index, &status)) {
 961                                stack[stack_ptr] = stack[stack_ptr - index];
 962                                ++stack_ptr;
 963                        }
 964
 965                        /* SWPN 2 */
 966                        index = 2 + 1;
 967                        if (altera_check_stack(stack_ptr, index, &status)) {
 968                                long_tmp = stack[stack_ptr - index];
 969                                stack[stack_ptr - index] = stack[stack_ptr - 1];
 970                                stack[stack_ptr - 1] = long_tmp;
 971                        }
 972
 973                        /* SWP  */
 974                        if (altera_check_stack(stack_ptr, 2, &status)) {
 975                                long_tmp = stack[stack_ptr - 2];
 976                                stack[stack_ptr - 2] = stack[stack_ptr - 1];
 977                                stack[stack_ptr - 1] = long_tmp;
 978                        }
 979
 980                        /* DUPN 6 */
 981                        index = 6 + 1;
 982                        if (altera_check_stack(stack_ptr, index, &status)) {
 983                                stack[stack_ptr] = stack[stack_ptr - index];
 984                                ++stack_ptr;
 985                        }
 986
 987                        /* DUPN 6 */
 988                        index = 6 + 1;
 989                        if (altera_check_stack(stack_ptr, index, &status)) {
 990                                stack[stack_ptr] = stack[stack_ptr - index];
 991                                ++stack_ptr;
 992                        }
 993                        break;
 994                case OP_PSH0:
 995                        stack[stack_ptr++] = 0;
 996                        break;
 997                case OP_PSHL:
 998                        stack[stack_ptr++] = (s32) args[0];
 999                        break;
1000                case OP_PSHV:
1001                        stack[stack_ptr++] = vars[args[0]];
1002                        break;
1003                case OP_JMP:
1004                        pc = args[0] + code_sect;
1005                        if ((pc < code_sect) || (pc >= debug_sect))
1006                                status = -ERANGE;
1007                        break;
1008                case OP_CALL:
1009                        stack[stack_ptr++] = pc;
1010                        pc = args[0] + code_sect;
1011                        if ((pc < code_sect) || (pc >= debug_sect))
1012                                status = -ERANGE;
1013                        break;
1014                case OP_NEXT:
1015                        /*
1016                         * Process FOR / NEXT loop
1017                         * ...argument 0 is variable ID
1018                         * ...stack 0 is step value
1019                         * ...stack 1 is end value
1020                         * ...stack 2 is top address
1021                         */
1022                        if (altera_check_stack(stack_ptr, 3, &status)) {
1023                                s32 step = stack[stack_ptr - 1];
1024                                s32 end = stack[stack_ptr - 2];
1025                                s32 top = stack[stack_ptr - 3];
1026                                s32 iterator = vars[args[0]];
1027                                int break_out = 0;
1028
1029                                if (step < 0) {
1030                                        if (iterator <= end)
1031                                                break_out = 1;
1032                                } else if (iterator >= end)
1033                                        break_out = 1;
1034
1035                                if (break_out) {
1036                                        stack_ptr -= 3;
1037                                } else {
1038                                        vars[args[0]] = iterator + step;
1039                                        pc = top + code_sect;
1040                                        if ((pc < code_sect) ||
1041                                            (pc >= debug_sect))
1042                                                status = -ERANGE;
1043                                }
1044                        }
1045                        break;
1046                case OP_PSTR:
1047                        /*
1048                         * PRINT add string
1049                         * ...argument 0 is string ID
1050                         */
1051                        count = strlen(msg_buff);
1052                        strlcpy(&msg_buff[count],
1053                                &p[str_table + args[0]],
1054                                ALTERA_MESSAGE_LENGTH - count);
1055                        break;
1056                case OP_SINT:
1057                        /*
1058                         * STATE intermediate state
1059                         * ...argument 0 is state code
1060                         */
1061                        status = altera_goto_jstate(astate, args[0]);
1062                        break;
1063                case OP_ST:
1064                        /*
1065                         * STATE final state
1066                         * ...argument 0 is state code
1067                         */
1068                        status = altera_goto_jstate(astate, args[0]);
1069                        break;
1070                case OP_ISTP:
1071                        /*
1072                         * IRSTOP state
1073                         * ...argument 0 is state code
1074                         */
1075                        status = altera_set_irstop(&astate->js, args[0]);
1076                        break;
1077                case OP_DSTP:
1078                        /*
1079                         * DRSTOP state
1080                         * ...argument 0 is state code
1081                         */
1082                        status = altera_set_drstop(&astate->js, args[0]);
1083                        break;
1084
1085                case OP_SWPN:
1086                        /*
1087                         * Exchange top with Nth stack value
1088                         * ...argument 0 is 0-based stack entry
1089                         * to swap with top element
1090                         */
1091                        index = (args[0]) + 1;
1092                        if (altera_check_stack(stack_ptr, index, &status)) {
1093                                long_tmp = stack[stack_ptr - index];
1094                                stack[stack_ptr - index] = stack[stack_ptr - 1];
1095                                stack[stack_ptr - 1] = long_tmp;
1096                        }
1097                        break;
1098                case OP_DUPN:
1099                        /*
1100                         * Duplicate Nth stack value
1101                         * ...argument 0 is 0-based stack entry to duplicate
1102                         */
1103                        index = (args[0]) + 1;
1104                        if (altera_check_stack(stack_ptr, index, &status)) {
1105                                stack[stack_ptr] = stack[stack_ptr - index];
1106                                ++stack_ptr;
1107                        }
1108                        break;
1109                case OP_POPV:
1110                        /*
1111                         * Pop stack into scalar variable
1112                         * ...argument 0 is variable ID
1113                         * ...stack 0 is value
1114                         */
1115                        if (altera_check_stack(stack_ptr, 1, &status))
1116                                vars[args[0]] = stack[--stack_ptr];
1117
1118                        break;
1119                case OP_POPE:
1120                        /*
1121                         * Pop stack into integer array element
1122                         * ...argument 0 is variable ID
1123                         * ...stack 0 is array index
1124                         * ...stack 1 is value
1125                         */
1126                        if (!altera_check_stack(stack_ptr, 2, &status))
1127                                break;
1128                        variable_id = args[0];
1129
1130                        /*
1131                         * If variable is read-only,
1132                         * convert to writable array
1133                         */
1134                        if ((version > 0) &&
1135                                ((attrs[variable_id] & 0x9c) == 0x1c)) {
1136                                /* Allocate a writable buffer for this array */
1137                                count = var_size[variable_id];
1138                                long_tmp = vars[variable_id];
1139                                longptr_tmp = kzalloc(count * sizeof(long),
1140                                                                GFP_KERNEL);
1141                                vars[variable_id] = (long)longptr_tmp;
1142
1143                                if (vars[variable_id] == 0) {
1144                                        status = -ENOMEM;
1145                                        break;
1146                                }
1147
1148                                /* copy previous contents into buffer */
1149                                for (i = 0; i < count; ++i) {
1150                                        longptr_tmp[i] =
1151                                                get_unaligned_be32(&p[long_tmp]);
1152                                        long_tmp += sizeof(long);
1153                                }
1154
1155                                /*
1156                                 * set bit 7 - buffer was
1157                                 * dynamically allocated
1158                                 */
1159                                attrs[variable_id] |= 0x80;
1160
1161                                /* clear bit 2 - variable is writable */
1162                                attrs[variable_id] &= ~0x04;
1163                                attrs[variable_id] |= 0x01;
1164
1165                        }
1166
1167                        /* check that variable is a writable integer array */
1168                        if ((attrs[variable_id] & 0x1c) != 0x18)
1169                                status = -ERANGE;
1170                        else {
1171                                longptr_tmp = (long *)vars[variable_id];
1172
1173                                /* pop the array index */
1174                                index = stack[--stack_ptr];
1175
1176                                /* pop the value and store it into the array */
1177                                longptr_tmp[index] = stack[--stack_ptr];
1178                        }
1179
1180                        break;
1181                case OP_POPA:
1182                        /*
1183                         * Pop stack into Boolean array
1184                         * ...argument 0 is variable ID
1185                         * ...stack 0 is count
1186                         * ...stack 1 is array index
1187                         * ...stack 2 is value
1188                         */
1189                        if (!altera_check_stack(stack_ptr, 3, &status))
1190                                break;
1191                        variable_id = args[0];
1192
1193                        /*
1194                         * If variable is read-only,
1195                         * convert to writable array
1196                         */
1197                        if ((version > 0) &&
1198                                ((attrs[variable_id] & 0x9c) == 0x0c)) {
1199                                /* Allocate a writable buffer for this array */
1200                                long_tmp =
1201                                        (var_size[variable_id] + 7L) >> 3L;
1202                                charptr_tmp2 = (u8 *)vars[variable_id];
1203                                charptr_tmp =
1204                                        kzalloc(long_tmp, GFP_KERNEL);
1205                                vars[variable_id] = (long)charptr_tmp;
1206
1207                                if (vars[variable_id] == 0) {
1208                                        status = -ENOMEM;
1209                                        break;
1210                                }
1211
1212                                /* zero the buffer */
1213                                for (long_idx = 0L;
1214                                        long_idx < long_tmp;
1215                                        ++long_idx) {
1216                                        charptr_tmp[long_idx] = 0;
1217                                }
1218
1219                                /* copy previous contents into buffer */
1220                                for (long_idx = 0L;
1221                                        long_idx < var_size[variable_id];
1222                                        ++long_idx) {
1223                                        long_idx2 = long_idx;
1224
1225                                        if (charptr_tmp2[long_idx2 >> 3] &
1226                                                (1 << (long_idx2 & 7))) {
1227                                                charptr_tmp[long_idx >> 3] |=
1228                                                        (1 << (long_idx & 7));
1229                                        }
1230                                }
1231
1232                                /*
1233                                 * set bit 7 - buffer was
1234                                 * dynamically allocated
1235                                 */
1236                                attrs[variable_id] |= 0x80;
1237
1238                                /* clear bit 2 - variable is writable */
1239                                attrs[variable_id] &= ~0x04;
1240                                attrs[variable_id] |= 0x01;
1241
1242                        }
1243
1244                        /*
1245                         * check that variable is
1246                         * a writable Boolean array
1247                         */
1248                        if ((attrs[variable_id] & 0x1c) != 0x08) {
1249                                status = -ERANGE;
1250                                break;
1251                        }
1252
1253                        charptr_tmp = (u8 *)vars[variable_id];
1254
1255                        /* pop the count (number of bits to copy) */
1256                        long_count = stack[--stack_ptr];
1257
1258                        /* pop the array index */
1259                        long_idx = stack[--stack_ptr];
1260
1261                        reverse = 0;
1262
1263                        if (version > 0) {
1264                                /*
1265                                 * stack 0 = array right index
1266                                 * stack 1 = array left index
1267                                 */
1268
1269                                if (long_idx > long_count) {
1270                                        reverse = 1;
1271                                        long_tmp = long_count;
1272                                        long_count = 1 + long_idx -
1273                                                                long_count;
1274                                        long_idx = long_tmp;
1275
1276                                        /* reverse POPA is not supported */
1277                                        status = -ERANGE;
1278                                        break;
1279                                } else
1280                                        long_count = 1 + long_count -
1281                                                                long_idx;
1282
1283                        }
1284
1285                        /* pop the data */
1286                        long_tmp = stack[--stack_ptr];
1287
1288                        if (long_count < 1) {
1289                                status = -ERANGE;
1290                                break;
1291                        }
1292
1293                        for (i = 0; i < long_count; ++i) {
1294                                if (long_tmp & (1L << (s32) i))
1295                                        charptr_tmp[long_idx >> 3L] |=
1296                                                (1L << (long_idx & 7L));
1297                                else
1298                                        charptr_tmp[long_idx >> 3L] &=
1299                                                ~(1L << (long_idx & 7L));
1300
1301                                ++long_idx;
1302                        }
1303
1304                        break;
1305                case OP_JMPZ:
1306                        /*
1307                         * Pop stack and branch if zero
1308                         * ...argument 0 is address
1309                         * ...stack 0 is condition value
1310                         */
1311                        if (altera_check_stack(stack_ptr, 1, &status)) {
1312                                if (stack[--stack_ptr] == 0) {
1313                                        pc = args[0] + code_sect;
1314                                        if ((pc < code_sect) ||
1315                                            (pc >= debug_sect))
1316                                                status = -ERANGE;
1317                                }
1318                        }
1319                        break;
1320                case OP_DS:
1321                case OP_IS:
1322                        /*
1323                         * DRSCAN
1324                         * IRSCAN
1325                         * ...argument 0 is scan data variable ID
1326                         * ...stack 0 is array index
1327                         * ...stack 1 is count
1328                         */
1329                        if (!altera_check_stack(stack_ptr, 2, &status))
1330                                break;
1331                        long_idx = stack[--stack_ptr];
1332                        long_count = stack[--stack_ptr];
1333                        reverse = 0;
1334                        if (version > 0) {
1335                                /*
1336                                 * stack 0 = array right index
1337                                 * stack 1 = array left index
1338                                 * stack 2 = count
1339                                 */
1340                                long_tmp = long_count;
1341                                long_count = stack[--stack_ptr];
1342
1343                                if (long_idx > long_tmp) {
1344                                        reverse = 1;
1345                                        long_idx = long_tmp;
1346                                }
1347                        }
1348
1349                        charptr_tmp = (u8 *)vars[args[0]];
1350
1351                        if (reverse) {
1352                                /*
1353                                 * allocate a buffer
1354                                 * and reverse the data order
1355                                 */
1356                                charptr_tmp2 = charptr_tmp;
1357                                charptr_tmp = kzalloc((long_count >> 3) + 1,
1358                                                                GFP_KERNEL);
1359                                if (charptr_tmp == NULL) {
1360                                        status = -ENOMEM;
1361                                        break;
1362                                }
1363
1364                                long_tmp = long_idx + long_count - 1;
1365                                long_idx2 = 0;
1366                                while (long_idx2 < long_count) {
1367                                        if (charptr_tmp2[long_tmp >> 3] &
1368                                                        (1 << (long_tmp & 7)))
1369                                                charptr_tmp[long_idx2 >> 3] |=
1370                                                        (1 << (long_idx2 & 7));
1371                                        else
1372                                                charptr_tmp[long_idx2 >> 3] &=
1373                                                        ~(1 << (long_idx2 & 7));
1374
1375                                        --long_tmp;
1376                                        ++long_idx2;
1377                                }
1378                        }
1379
1380                        if (opcode == 0x51) /* DS */
1381                                status = altera_drscan(astate, long_count,
1382                                                charptr_tmp, long_idx);
1383                        else /* IS */
1384                                status = altera_irscan(astate, long_count,
1385                                                charptr_tmp, long_idx);
1386
1387                        if (reverse)
1388                                kfree(charptr_tmp);
1389
1390                        break;
1391                case OP_DPRA:
1392                        /*
1393                         * DRPRE with array data
1394                         * ...argument 0 is variable ID
1395                         * ...stack 0 is array index
1396                         * ...stack 1 is count
1397                         */
1398                        if (!altera_check_stack(stack_ptr, 2, &status))
1399                                break;
1400                        index = stack[--stack_ptr];
1401                        count = stack[--stack_ptr];
1402
1403                        if (version > 0)
1404                                /*
1405                                 * stack 0 = array right index
1406                                 * stack 1 = array left index
1407                                 */
1408                                count = 1 + count - index;
1409
1410                        charptr_tmp = (u8 *)vars[args[0]];
1411                        status = altera_set_dr_pre(&astate->js, count, index,
1412                                                        charptr_tmp);
1413                        break;
1414                case OP_DPOA:
1415                        /*
1416                         * DRPOST with array data
1417                         * ...argument 0 is variable ID
1418                         * ...stack 0 is array index
1419                         * ...stack 1 is count
1420                         */
1421                        if (!altera_check_stack(stack_ptr, 2, &status))
1422                                break;
1423                        index = stack[--stack_ptr];
1424                        count = stack[--stack_ptr];
1425
1426                        if (version > 0)
1427                                /*
1428                                 * stack 0 = array right index
1429                                 * stack 1 = array left index
1430                                 */
1431                                count = 1 + count - index;
1432
1433                        charptr_tmp = (u8 *)vars[args[0]];
1434                        status = altera_set_dr_post(&astate->js, count, index,
1435                                                        charptr_tmp);
1436                        break;
1437                case OP_IPRA:
1438                        /*
1439                         * IRPRE with array data
1440                         * ...argument 0 is variable ID
1441                         * ...stack 0 is array index
1442                         * ...stack 1 is count
1443                         */
1444                        if (!altera_check_stack(stack_ptr, 2, &status))
1445                                break;
1446                        index = stack[--stack_ptr];
1447                        count = stack[--stack_ptr];
1448
1449                        if (version > 0)
1450                                /*
1451                                 * stack 0 = array right index
1452                                 * stack 1 = array left index
1453                                 */
1454                                count = 1 + count - index;
1455
1456                        charptr_tmp = (u8 *)vars[args[0]];
1457                        status = altera_set_ir_pre(&astate->js, count, index,
1458                                                        charptr_tmp);
1459
1460                        break;
1461                case OP_IPOA:
1462                        /*
1463                         * IRPOST with array data
1464                         * ...argument 0 is variable ID
1465                         * ...stack 0 is array index
1466                         * ...stack 1 is count
1467                         */
1468                        if (!altera_check_stack(stack_ptr, 2, &status))
1469                                break;
1470                        index = stack[--stack_ptr];
1471                        count = stack[--stack_ptr];
1472
1473                        if (version > 0)
1474                                /*
1475                                 * stack 0 = array right index
1476                                 * stack 1 = array left index
1477                                 */
1478                                count = 1 + count - index;
1479
1480                        charptr_tmp = (u8 *)vars[args[0]];
1481                        status = altera_set_ir_post(&astate->js, count, index,
1482                                                        charptr_tmp);
1483
1484                        break;
1485                case OP_EXPT:
1486                        /*
1487                         * EXPORT
1488                         * ...argument 0 is string ID
1489                         * ...stack 0 is integer expression
1490                         */
1491                        if (altera_check_stack(stack_ptr, 1, &status)) {
1492                                name = &p[str_table + args[0]];
1493                                long_tmp = stack[--stack_ptr];
1494                                altera_export_int(name, long_tmp);
1495                        }
1496                        break;
1497                case OP_PSHE:
1498                        /*
1499                         * Push integer array element
1500                         * ...argument 0 is variable ID
1501                         * ...stack 0 is array index
1502                         */
1503                        if (!altera_check_stack(stack_ptr, 1, &status))
1504                                break;
1505                        variable_id = args[0];
1506                        index = stack[stack_ptr - 1];
1507
1508                        /* check variable type */
1509                        if ((attrs[variable_id] & 0x1f) == 0x19) {
1510                                /* writable integer array */
1511                                longptr_tmp = (long *)vars[variable_id];
1512                                stack[stack_ptr - 1] = longptr_tmp[index];
1513                        } else if ((attrs[variable_id] & 0x1f) == 0x1c) {
1514                                /* read-only integer array */
1515                                long_tmp = vars[variable_id] +
1516                                                (index * sizeof(long));
1517                                stack[stack_ptr - 1] =
1518                                        get_unaligned_be32(&p[long_tmp]);
1519                        } else
1520                                status = -ERANGE;
1521
1522                        break;
1523                case OP_PSHA:
1524                        /*
1525                         * Push Boolean array
1526                         * ...argument 0 is variable ID
1527                         * ...stack 0 is count
1528                         * ...stack 1 is array index
1529                         */
1530                        if (!altera_check_stack(stack_ptr, 2, &status))
1531                                break;
1532                        variable_id = args[0];
1533
1534                        /* check that variable is a Boolean array */
1535                        if ((attrs[variable_id] & 0x18) != 0x08) {
1536                                status = -ERANGE;
1537                                break;
1538                        }
1539
1540                        charptr_tmp = (u8 *)vars[variable_id];
1541
1542                        /* pop the count (number of bits to copy) */
1543                        count = stack[--stack_ptr];
1544
1545                        /* pop the array index */
1546                        index = stack[stack_ptr - 1];
1547
1548                        if (version > 0)
1549                                /*
1550                                 * stack 0 = array right index
1551                                 * stack 1 = array left index
1552                                 */
1553                                count = 1 + count - index;
1554
1555                        if ((count < 1) || (count > 32)) {
1556                                status = -ERANGE;
1557                                break;
1558                        }
1559
1560                        long_tmp = 0L;
1561
1562                        for (i = 0; i < count; ++i)
1563                                if (charptr_tmp[(i + index) >> 3] &
1564                                                (1 << ((i + index) & 7)))
1565                                        long_tmp |= (1L << i);
1566
1567                        stack[stack_ptr - 1] = long_tmp;
1568
1569                        break;
1570                case OP_DYNA:
1571                        /*
1572                         * Dynamically change size of array
1573                         * ...argument 0 is variable ID
1574                         * ...stack 0 is new size
1575                         */
1576                        if (!altera_check_stack(stack_ptr, 1, &status))
1577                                break;
1578                        variable_id = args[0];
1579                        long_tmp = stack[--stack_ptr];
1580
1581                        if (long_tmp > var_size[variable_id]) {
1582                                var_size[variable_id] = long_tmp;
1583
1584                                if (attrs[variable_id] & 0x10)
1585                                        /* allocate integer array */
1586                                        long_tmp *= sizeof(long);
1587                                else
1588                                        /* allocate Boolean array */
1589                                        long_tmp = (long_tmp + 7) >> 3;
1590
1591                                /*
1592                                 * If the buffer was previously allocated,
1593                                 * free it
1594                                 */
1595                                if (attrs[variable_id] & 0x80) {
1596                                        kfree((void *)vars[variable_id]);
1597                                        vars[variable_id] = 0;
1598                                }
1599
1600                                /*
1601                                 * Allocate a new buffer
1602                                 * of the requested size
1603                                 */
1604                                vars[variable_id] = (long)
1605                                        kzalloc(long_tmp, GFP_KERNEL);
1606
1607                                if (vars[variable_id] == 0) {
1608                                        status = -ENOMEM;
1609                                        break;
1610                                }
1611
1612                                /*
1613                                 * Set the attribute bit to indicate that
1614                                 * this buffer was dynamically allocated and
1615                                 * should be freed later
1616                                 */
1617                                attrs[variable_id] |= 0x80;
1618
1619                                /* zero out memory */
1620                                count = ((var_size[variable_id] + 7L) /
1621                                                                        8L);
1622                                charptr_tmp = (u8 *)(vars[variable_id]);
1623                                for (index = 0; index < count; ++index)
1624                                        charptr_tmp[index] = 0;
1625
1626                        }
1627
1628                        break;
1629                case OP_EXPV:
1630                        /*
1631                         * Export Boolean array
1632                         * ...argument 0 is string ID
1633                         * ...stack 0 is variable ID
1634                         * ...stack 1 is array right index
1635                         * ...stack 2 is array left index
1636                         */
1637                        if (!altera_check_stack(stack_ptr, 3, &status))
1638                                break;
1639                        if (version == 0) {
1640                                /* EXPV is not supported in JBC 1.0 */
1641                                bad_opcode = 1;
1642                                break;
1643                        }
1644                        name = &p[str_table + args[0]];
1645                        variable_id = stack[--stack_ptr];
1646                        long_idx = stack[--stack_ptr];/* right indx */
1647                        long_idx2 = stack[--stack_ptr];/* left indx */
1648
1649                        if (long_idx > long_idx2) {
1650                                /* reverse indices not supported */
1651                                status = -ERANGE;
1652                                break;
1653                        }
1654
1655                        long_count = 1 + long_idx2 - long_idx;
1656
1657                        charptr_tmp = (u8 *)vars[variable_id];
1658                        charptr_tmp2 = NULL;
1659
1660                        if ((long_idx & 7L) != 0) {
1661                                s32 k = long_idx;
1662                                charptr_tmp2 =
1663                                        kzalloc(((long_count + 7L) / 8L),
1664                                                        GFP_KERNEL);
1665                                if (charptr_tmp2 == NULL) {
1666                                        status = -ENOMEM;
1667                                        break;
1668                                }
1669
1670                                for (i = 0; i < long_count; ++i) {
1671                                        if (charptr_tmp[k >> 3] &
1672                                                        (1 << (k & 7)))
1673                                                charptr_tmp2[i >> 3] |=
1674                                                                (1 << (i & 7));
1675                                        else
1676                                                charptr_tmp2[i >> 3] &=
1677                                                                ~(1 << (i & 7));
1678
1679                                        ++k;
1680                                }
1681                                charptr_tmp = charptr_tmp2;
1682
1683                        } else if (long_idx != 0)
1684                                charptr_tmp = &charptr_tmp[long_idx >> 3];
1685
1686                        altera_export_bool_array(name, charptr_tmp,
1687                                                        long_count);
1688
1689                        /* free allocated buffer */
1690                        if ((long_idx & 7L) != 0)
1691                                kfree(charptr_tmp2);
1692
1693                        break;
1694                case OP_COPY: {
1695                        /*
1696                         * Array copy
1697                         * ...argument 0 is dest ID
1698                         * ...argument 1 is source ID
1699                         * ...stack 0 is count
1700                         * ...stack 1 is dest index
1701                         * ...stack 2 is source index
1702                         */
1703                        s32 copy_count;
1704                        s32 copy_index;
1705                        s32 copy_index2;
1706                        s32 destleft;
1707                        s32 src_count;
1708                        s32 dest_count;
1709                        int src_reverse = 0;
1710                        int dest_reverse = 0;
1711
1712                        if (!altera_check_stack(stack_ptr, 3, &status))
1713                                break;
1714
1715                        copy_count = stack[--stack_ptr];
1716                        copy_index = stack[--stack_ptr];
1717                        copy_index2 = stack[--stack_ptr];
1718                        reverse = 0;
1719
1720                        if (version > 0) {
1721                                /*
1722                                 * stack 0 = source right index
1723                                 * stack 1 = source left index
1724                                 * stack 2 = destination right index
1725                                 * stack 3 = destination left index
1726                                 */
1727                                destleft = stack[--stack_ptr];
1728
1729                                if (copy_count > copy_index) {
1730                                        src_reverse = 1;
1731                                        reverse = 1;
1732                                        src_count = 1 + copy_count - copy_index;
1733                                        /* copy_index = source start index */
1734                                } else {
1735                                        src_count = 1 + copy_index - copy_count;
1736                                        /* source start index */
1737                                        copy_index = copy_count;
1738                                }
1739
1740                                if (copy_index2 > destleft) {
1741                                        dest_reverse = 1;
1742                                        reverse = !reverse;
1743                                        dest_count = 1 + copy_index2 - destleft;
1744                                        /* destination start index */
1745                                        copy_index2 = destleft;
1746                                } else
1747                                        dest_count = 1 + destleft - copy_index2;
1748
1749                                copy_count = (src_count < dest_count) ?
1750                                                        src_count : dest_count;
1751
1752                                if ((src_reverse || dest_reverse) &&
1753                                        (src_count != dest_count))
1754                                        /*
1755                                         * If either the source or destination
1756                                         * is reversed, we can't tolerate
1757                                         * a length mismatch, because we
1758                                         * "left justify" arrays when copying.
1759                                         * This won't work correctly
1760                                         * with reversed arrays.
1761                                         */
1762                                        status = -ERANGE;
1763
1764                        }
1765
1766                        count = copy_count;
1767                        index = copy_index;
1768                        index2 = copy_index2;
1769
1770                        /*
1771                         * If destination is a read-only array,
1772                         * allocate a buffer and convert it to a writable array
1773                         */
1774                        variable_id = args[1];
1775                        if ((version > 0) &&
1776                                ((attrs[variable_id] & 0x9c) == 0x0c)) {
1777                                /* Allocate a writable buffer for this array */
1778                                long_tmp =
1779                                        (var_size[variable_id] + 7L) >> 3L;
1780                                charptr_tmp2 = (u8 *)vars[variable_id];
1781                                charptr_tmp =
1782                                        kzalloc(long_tmp, GFP_KERNEL);
1783                                vars[variable_id] = (long)charptr_tmp;
1784
1785                                if (vars[variable_id] == 0) {
1786                                        status = -ENOMEM;
1787                                        break;
1788                                }
1789
1790                                /* zero the buffer */
1791                                for (long_idx = 0L; long_idx < long_tmp;
1792                                                                ++long_idx)
1793                                        charptr_tmp[long_idx] = 0;
1794
1795                                /* copy previous contents into buffer */
1796                                for (long_idx = 0L;
1797                                        long_idx < var_size[variable_id];
1798                                                                ++long_idx) {
1799                                        long_idx2 = long_idx;
1800
1801                                        if (charptr_tmp2[long_idx2 >> 3] &
1802                                                (1 << (long_idx2 & 7)))
1803                                                charptr_tmp[long_idx >> 3] |=
1804                                                        (1 << (long_idx & 7));
1805
1806                                }
1807
1808                                /*
1809                                set bit 7 - buffer was dynamically allocated */
1810                                attrs[variable_id] |= 0x80;
1811
1812                                /* clear bit 2 - variable is writable */
1813                                attrs[variable_id] &= ~0x04;
1814                                attrs[variable_id] |= 0x01;
1815                        }
1816
1817                        charptr_tmp = (u8 *)vars[args[1]];
1818                        charptr_tmp2 = (u8 *)vars[args[0]];
1819
1820                        /* check if destination is a writable Boolean array */
1821                        if ((attrs[args[1]] & 0x1c) != 0x08) {
1822                                status = -ERANGE;
1823                                break;
1824                        }
1825
1826                        if (count < 1) {
1827                                status = -ERANGE;
1828                                break;
1829                        }
1830
1831                        if (reverse)
1832                                index2 += (count - 1);
1833
1834                        for (i = 0; i < count; ++i) {
1835                                if (charptr_tmp2[index >> 3] &
1836                                                        (1 << (index & 7)))
1837                                        charptr_tmp[index2 >> 3] |=
1838                                                        (1 << (index2 & 7));
1839                                else
1840                                        charptr_tmp[index2 >> 3] &=
1841                                                ~(1 << (index2 & 7));
1842
1843                                ++index;
1844                                if (reverse)
1845                                        --index2;
1846                                else
1847                                        ++index2;
1848                        }
1849
1850                        break;
1851                }
1852                case OP_DSC:
1853                case OP_ISC: {
1854                        /*
1855                         * DRSCAN with capture
1856                         * IRSCAN with capture
1857                         * ...argument 0 is scan data variable ID
1858                         * ...argument 1 is capture variable ID
1859                         * ...stack 0 is capture index
1860                         * ...stack 1 is scan data index
1861                         * ...stack 2 is count
1862                         */
1863                        s32 scan_right, scan_left;
1864                        s32 capture_count = 0;
1865                        s32 scan_count = 0;
1866                        s32 capture_index;
1867                        s32 scan_index;
1868
1869                        if (!altera_check_stack(stack_ptr, 3, &status))
1870                                break;
1871
1872                        capture_index = stack[--stack_ptr];
1873                        scan_index = stack[--stack_ptr];
1874
1875                        if (version > 0) {
1876                                /*
1877                                 * stack 0 = capture right index
1878                                 * stack 1 = capture left index
1879                                 * stack 2 = scan right index
1880                                 * stack 3 = scan left index
1881                                 * stack 4 = count
1882                                 */
1883                                scan_right = stack[--stack_ptr];
1884                                scan_left = stack[--stack_ptr];
1885                                capture_count = 1 + scan_index - capture_index;
1886                                scan_count = 1 + scan_left - scan_right;
1887                                scan_index = scan_right;
1888                        }
1889
1890                        long_count = stack[--stack_ptr];
1891                        /*
1892                         * If capture array is read-only, allocate a buffer
1893                         * and convert it to a writable array
1894                         */
1895                        variable_id = args[1];
1896                        if ((version > 0) &&
1897                                ((attrs[variable_id] & 0x9c) == 0x0c)) {
1898                                /* Allocate a writable buffer for this array */
1899                                long_tmp =
1900                                        (var_size[variable_id] + 7L) >> 3L;
1901                                charptr_tmp2 = (u8 *)vars[variable_id];
1902                                charptr_tmp =
1903                                        kzalloc(long_tmp, GFP_KERNEL);
1904                                vars[variable_id] = (long)charptr_tmp;
1905
1906                                if (vars[variable_id] == 0) {
1907                                        status = -ENOMEM;
1908                                        break;
1909                                }
1910
1911                                /* zero the buffer */
1912                                for (long_idx = 0L; long_idx < long_tmp;
1913                                                                ++long_idx)
1914                                        charptr_tmp[long_idx] = 0;
1915
1916                                /* copy previous contents into buffer */
1917                                for (long_idx = 0L;
1918                                        long_idx < var_size[variable_id];
1919                                                                ++long_idx) {
1920                                        long_idx2 = long_idx;
1921
1922                                        if (charptr_tmp2[long_idx2 >> 3] &
1923                                                (1 << (long_idx2 & 7)))
1924                                                charptr_tmp[long_idx >> 3] |=
1925                                                        (1 << (long_idx & 7));
1926
1927                                }
1928
1929                                /*
1930                                 * set bit 7 - buffer was
1931                                 * dynamically allocated
1932                                 */
1933                                attrs[variable_id] |= 0x80;
1934
1935                                /* clear bit 2 - variable is writable */
1936                                attrs[variable_id] &= ~0x04;
1937                                attrs[variable_id] |= 0x01;
1938
1939                        }
1940
1941                        charptr_tmp = (u8 *)vars[args[0]];
1942                        charptr_tmp2 = (u8 *)vars[args[1]];
1943
1944                        if ((version > 0) &&
1945                                        ((long_count > capture_count) ||
1946                                        (long_count > scan_count))) {
1947                                status = -ERANGE;
1948                                break;
1949                        }
1950
1951                        /*
1952                         * check that capture array
1953                         * is a writable Boolean array
1954                         */
1955                        if ((attrs[args[1]] & 0x1c) != 0x08) {
1956                                status = -ERANGE;
1957                                break;
1958                        }
1959
1960                        if (status == 0) {
1961                                if (opcode == 0x82) /* DSC */
1962                                        status = altera_swap_dr(astate,
1963                                                        long_count,
1964                                                        charptr_tmp,
1965                                                        scan_index,
1966                                                        charptr_tmp2,
1967                                                        capture_index);
1968                                else /* ISC */
1969                                        status = altera_swap_ir(astate,
1970                                                        long_count,
1971                                                        charptr_tmp,
1972                                                        scan_index,
1973                                                        charptr_tmp2,
1974                                                        capture_index);
1975
1976                        }
1977
1978                        break;
1979                }
1980                case OP_WAIT:
1981                        /*
1982                         * WAIT
1983                         * ...argument 0 is wait state
1984                         * ...argument 1 is end state
1985                         * ...stack 0 is cycles
1986                         * ...stack 1 is microseconds
1987                         */
1988                        if (!altera_check_stack(stack_ptr, 2, &status))
1989                                break;
1990                        long_tmp = stack[--stack_ptr];
1991
1992                        if (long_tmp != 0L)
1993                                status = altera_wait_cycles(astate, long_tmp,
1994                                                                args[0]);
1995
1996                        long_tmp = stack[--stack_ptr];
1997
1998                        if ((status == 0) && (long_tmp != 0L))
1999                                status = altera_wait_msecs(astate,
2000                                                                long_tmp,
2001                                                                args[0]);
2002
2003                        if ((status == 0) && (args[1] != args[0]))
2004                                status = altera_goto_jstate(astate,
2005                                                                args[1]);
2006
2007                        if (version > 0) {
2008                                --stack_ptr; /* throw away MAX cycles */
2009                                --stack_ptr; /* throw away MAX microseconds */
2010                        }
2011                        break;
2012                case OP_CMPA: {
2013                        /*
2014                         * Array compare
2015                         * ...argument 0 is source 1 ID
2016                         * ...argument 1 is source 2 ID
2017                         * ...argument 2 is mask ID
2018                         * ...stack 0 is source 1 index
2019                         * ...stack 1 is source 2 index
2020                         * ...stack 2 is mask index
2021                         * ...stack 3 is count
2022                         */
2023                        s32 a, b;
2024                        u8 *source1 = (u8 *)vars[args[0]];
2025                        u8 *source2 = (u8 *)vars[args[1]];
2026                        u8 *mask = (u8 *)vars[args[2]];
2027                        u32 index1;
2028                        u32 index2;
2029                        u32 mask_index;
2030
2031                        if (!altera_check_stack(stack_ptr, 4, &status))
2032                                break;
2033
2034                        index1 = stack[--stack_ptr];
2035                        index2 = stack[--stack_ptr];
2036                        mask_index = stack[--stack_ptr];
2037                        long_count = stack[--stack_ptr];
2038
2039                        if (version > 0) {
2040                                /*
2041                                 * stack 0 = source 1 right index
2042                                 * stack 1 = source 1 left index
2043                                 * stack 2 = source 2 right index
2044                                 * stack 3 = source 2 left index
2045                                 * stack 4 = mask right index
2046                                 * stack 5 = mask left index
2047                                 */
2048                                s32 mask_right = stack[--stack_ptr];
2049                                s32 mask_left = stack[--stack_ptr];
2050                                /* source 1 count */
2051                                a = 1 + index2 - index1;
2052                                /* source 2 count */
2053                                b = 1 + long_count - mask_index;
2054                                a = (a < b) ? a : b;
2055                                /* mask count */
2056                                b = 1 + mask_left - mask_right;
2057                                a = (a < b) ? a : b;
2058                                /* source 2 start index */
2059                                index2 = mask_index;
2060                                /* mask start index */
2061                                mask_index = mask_right;
2062                                long_count = a;
2063                        }
2064
2065                        long_tmp = 1L;
2066
2067                        if (long_count < 1)
2068                                status = -ERANGE;
2069                        else {
2070                                count = long_count;
2071
2072                                for (i = 0; i < count; ++i) {
2073                                        if (mask[mask_index >> 3] &
2074                                                (1 << (mask_index & 7))) {
2075                                                a = source1[index1 >> 3] &
2076                                                        (1 << (index1 & 7))
2077                                                                ? 1 : 0;
2078                                                b = source2[index2 >> 3] &
2079                                                        (1 << (index2 & 7))
2080                                                                ? 1 : 0;
2081
2082                                                if (a != b) /* failure */
2083                                                        long_tmp = 0L;
2084                                        }
2085                                        ++index1;
2086                                        ++index2;
2087                                        ++mask_index;
2088                                }
2089                        }
2090
2091                        stack[stack_ptr++] = long_tmp;
2092
2093                        break;
2094                }
2095                default:
2096                        /* Unrecognized opcode -- ERROR! */
2097                        bad_opcode = 1;
2098                        break;
2099                }
2100
2101                if (bad_opcode)
2102                        status = -ENOSYS;
2103
2104                if ((stack_ptr < 0) || (stack_ptr >= ALTERA_STACK_SIZE))
2105                        status = -EOVERFLOW;
2106
2107                if (status != 0) {
2108                        done = 1;
2109                        *error_address = (s32)(opcode_address - code_sect);
2110                }
2111        }
2112
2113        altera_free_buffers(astate);
2114
2115        /* Free all dynamically allocated arrays */
2116        if ((attrs != NULL) && (vars != NULL))
2117                for (i = 0; i < sym_count; ++i)
2118                        if (attrs[i] & 0x80)
2119                                kfree((void *)vars[i]);
2120
2121        kfree(vars);
2122        kfree(var_size);
2123        kfree(attrs);
2124        kfree(proc_attributes);
2125
2126        return status;
2127}
2128
2129static int altera_get_note(u8 *p, s32 program_size,
2130                        s32 *offset, char *key, char *value, int length)
2131/*
2132 * Gets key and value of NOTE fields in the JBC file.
2133 * Can be called in two modes:  if offset pointer is NULL,
2134 * then the function searches for note fields which match
2135 * the key string provided.  If offset is not NULL, then
2136 * the function finds the next note field of any key,
2137 * starting at the offset specified by the offset pointer.
2138 * Returns 0 for success, else appropriate error code
2139 */
2140{
2141        int status = -ENODATA;
2142        u32 note_strings = 0L;
2143        u32 note_table = 0L;
2144        u32 note_count = 0L;
2145        u32 first_word = 0L;
2146        int version = 0;
2147        int delta = 0;
2148        char *key_ptr;
2149        char *value_ptr;
2150        int i;
2151
2152        /* Read header information */
2153        if (program_size > 52L) {
2154                first_word    = get_unaligned_be32(&p[0]);
2155                version = (first_word & 1L);
2156                delta = version * 8;
2157
2158                note_strings  = get_unaligned_be32(&p[8 + delta]);
2159                note_table    = get_unaligned_be32(&p[12 + delta]);
2160                note_count    = get_unaligned_be32(&p[44 + (2 * delta)]);
2161        }
2162
2163        if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L))
2164                return -EIO;
2165
2166        if (note_count <= 0L)
2167                return status;
2168
2169        if (offset == NULL) {
2170                /*
2171                 * We will search for the first note with a specific key,
2172                 * and return only the value
2173                 */
2174                for (i = 0; (i < note_count) &&
2175                                                (status != 0); ++i) {
2176                        key_ptr = &p[note_strings +
2177                                        get_unaligned_be32(
2178                                        &p[note_table + (8 * i)])];
2179                        if ((strnicmp(key, key_ptr, strlen(key_ptr)) == 0) &&
2180                                                (key != NULL)) {
2181                                status = 0;
2182
2183                                value_ptr = &p[note_strings +
2184                                                get_unaligned_be32(
2185                                                &p[note_table + (8 * i) + 4])];
2186
2187                                if (value != NULL)
2188                                        strlcpy(value, value_ptr, length);
2189
2190                        }
2191                }
2192        } else {
2193                /*
2194                 * We will search for the next note, regardless of the key,
2195                 * and return both the value and the key
2196                 */
2197
2198                i = *offset;
2199
2200                if ((i >= 0) && (i < note_count)) {
2201                        status = 0;
2202
2203                        if (key != NULL)
2204                                strlcpy(key, &p[note_strings +
2205                                                get_unaligned_be32(
2206                                                &p[note_table + (8 * i)])],
2207                                        length);
2208
2209                        if (value != NULL)
2210                                strlcpy(value, &p[note_strings +
2211                                                get_unaligned_be32(
2212                                                &p[note_table + (8 * i) + 4])],
2213                                        length);
2214
2215                        *offset = i + 1;
2216                }
2217        }
2218
2219        return status;
2220}
2221
2222static int altera_check_crc(u8 *p, s32 program_size)
2223{
2224        int status = 0;
2225        u16 local_expected = 0,
2226            local_actual = 0,
2227            shift_reg = 0xffff;
2228        int bit, feedback;
2229        u8 databyte;
2230        u32 i;
2231        u32 crc_section = 0L;
2232        u32 first_word = 0L;
2233        int version = 0;
2234        int delta = 0;
2235
2236        if (program_size > 52L) {
2237                first_word  = get_unaligned_be32(&p[0]);
2238                version = (first_word & 1L);
2239                delta = version * 8;
2240
2241                crc_section = get_unaligned_be32(&p[32 + delta]);
2242        }
2243
2244        if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L))
2245                status = -EIO;
2246
2247        if (crc_section >= program_size)
2248                status = -EIO;
2249
2250        if (status == 0) {
2251                local_expected = (u16)get_unaligned_be16(&p[crc_section]);
2252
2253                for (i = 0; i < crc_section; ++i) {
2254                        databyte = p[i];
2255                        for (bit = 0; bit < 8; bit++) {
2256                                feedback = (databyte ^ shift_reg) & 0x01;
2257                                shift_reg >>= 1;
2258                                if (feedback)
2259                                        shift_reg ^= 0x8408;
2260
2261                                databyte >>= 1;
2262                        }
2263                }
2264
2265                local_actual = (u16)~shift_reg;
2266
2267                if (local_expected != local_actual)
2268                        status = -EILSEQ;
2269
2270        }
2271
2272        if (debug || status) {
2273                switch (status) {
2274                case 0:
2275                        printk(KERN_INFO "%s: CRC matched: %04x\n", __func__,
2276                                local_actual);
2277                        break;
2278                case -EILSEQ:
2279                        printk(KERN_ERR "%s: CRC mismatch: expected %04x, "
2280                                "actual %04x\n", __func__, local_expected,
2281                                local_actual);
2282                        break;
2283                case -ENODATA:
2284                        printk(KERN_ERR "%s: expected CRC not found, "
2285                                "actual CRC = %04x\n", __func__,
2286                                local_actual);
2287                        break;
2288                case -EIO:
2289                        printk(KERN_ERR "%s: error: format isn't "
2290                                "recognized.\n", __func__);
2291                        break;
2292                default:
2293                        printk(KERN_ERR "%s: CRC function returned error "
2294                                "code %d\n", __func__, status);
2295                        break;
2296                }
2297        }
2298
2299        return status;
2300}
2301
2302static int altera_get_file_info(u8 *p,
2303                                        s32 program_size,
2304                                        int *format_version,
2305                                        int *action_count,
2306                                        int *procedure_count)
2307{
2308        int status = -EIO;
2309        u32 first_word = 0;
2310        int version = 0;
2311
2312        if (program_size <= 52L)
2313                return status;
2314
2315        first_word = get_unaligned_be32(&p[0]);
2316
2317        if ((first_word == 0x4A414D00L) || (first_word == 0x4A414D01L)) {
2318                status = 0;
2319
2320                version = (first_word & 1L);
2321                *format_version = version + 1;
2322
2323                if (version > 0) {
2324                        *action_count = get_unaligned_be32(&p[48]);
2325                        *procedure_count = get_unaligned_be32(&p[52]);
2326                }
2327        }
2328
2329        return status;
2330}
2331
2332static int altera_get_act_info(u8 *p,
2333                                        s32 program_size,
2334                                        int index,
2335                                        char **name,
2336                                        char **description,
2337                                        struct altera_procinfo **proc_list)
2338{
2339        int status = -EIO;
2340        struct altera_procinfo *procptr = NULL;
2341        struct altera_procinfo *tmpptr = NULL;
2342        u32 first_word = 0L;
2343        u32 action_table = 0L;
2344        u32 proc_table = 0L;
2345        u32 str_table = 0L;
2346        u32 note_strings = 0L;
2347        u32 action_count = 0L;
2348        u32 proc_count = 0L;
2349        u32 act_name_id = 0L;
2350        u32 act_desc_id = 0L;
2351        u32 act_proc_id = 0L;
2352        u32 act_proc_name = 0L;
2353        u8 act_proc_attribute = 0;
2354
2355        if (program_size <= 52L)
2356                return status;
2357        /* Read header information */
2358        first_word = get_unaligned_be32(&p[0]);
2359
2360        if (first_word != 0x4A414D01L)
2361                return status;
2362
2363        action_table = get_unaligned_be32(&p[4]);
2364        proc_table   = get_unaligned_be32(&p[8]);
2365        str_table = get_unaligned_be32(&p[12]);
2366        note_strings = get_unaligned_be32(&p[16]);
2367        action_count = get_unaligned_be32(&p[48]);
2368        proc_count   = get_unaligned_be32(&p[52]);
2369
2370        if (index >= action_count)
2371                return status;
2372
2373        act_name_id = get_unaligned_be32(&p[action_table + (12 * index)]);
2374        act_desc_id = get_unaligned_be32(&p[action_table + (12 * index) + 4]);
2375        act_proc_id = get_unaligned_be32(&p[action_table + (12 * index) + 8]);
2376
2377        *name = &p[str_table + act_name_id];
2378
2379        if (act_desc_id < (note_strings - str_table))
2380                *description = &p[str_table + act_desc_id];
2381
2382        do {
2383                act_proc_name = get_unaligned_be32(
2384                                        &p[proc_table + (13 * act_proc_id)]);
2385                act_proc_attribute =
2386                        (p[proc_table + (13 * act_proc_id) + 8] & 0x03);
2387
2388                procptr =
2389                                kzalloc(sizeof(struct altera_procinfo),
2390                                                                GFP_KERNEL);
2391
2392                if (procptr == NULL)
2393                        status = -ENOMEM;
2394                else {
2395                        procptr->name = &p[str_table + act_proc_name];
2396                        procptr->attrs = act_proc_attribute;
2397                        procptr->next = NULL;
2398
2399                        /* add record to end of linked list */
2400                        if (*proc_list == NULL)
2401                                *proc_list = procptr;
2402                        else {
2403                                tmpptr = *proc_list;
2404                                while (tmpptr->next != NULL)
2405                                        tmpptr = tmpptr->next;
2406                                tmpptr->next = procptr;
2407                        }
2408                }
2409
2410                act_proc_id = get_unaligned_be32(
2411                                &p[proc_table + (13 * act_proc_id) + 4]);
2412        } while ((act_proc_id != 0) && (act_proc_id < proc_count));
2413
2414        return status;
2415}
2416
2417int altera_init(struct altera_config *config, const struct firmware *fw)
2418{
2419        struct altera_state *astate = NULL;
2420        struct altera_procinfo *proc_list = NULL;
2421        struct altera_procinfo *procptr = NULL;
2422        char *key = NULL;
2423        char *value = NULL;
2424        char *action_name = NULL;
2425        char *description = NULL;
2426        int exec_result = 0;
2427        int exit_code = 0;
2428        int format_version = 0;
2429        int action_count = 0;
2430        int procedure_count = 0;
2431        int index = 0;
2432        s32 offset = 0L;
2433        s32 error_address = 0L;
2434        int retval = 0;
2435
2436        key = kzalloc(33, GFP_KERNEL);
2437        if (!key) {
2438                retval = -ENOMEM;
2439                goto out;
2440        }
2441        value = kzalloc(257, GFP_KERNEL);
2442        if (!value) {
2443                retval = -ENOMEM;
2444                goto free_key;
2445        }
2446        astate = kzalloc(sizeof(struct altera_state), GFP_KERNEL);
2447        if (!astate) {
2448                retval = -ENOMEM;
2449                goto free_value;
2450        }
2451
2452        astate->config = config;
2453        if (!astate->config->jtag_io) {
2454                dprintk(KERN_INFO "%s: using byteblaster!\n", __func__);
2455                astate->config->jtag_io = netup_jtag_io_lpt;
2456        }
2457
2458        altera_check_crc((u8 *)fw->data, fw->size);
2459
2460        if (debug) {
2461                altera_get_file_info((u8 *)fw->data, fw->size, &format_version,
2462                                        &action_count, &procedure_count);
2463                printk(KERN_INFO "%s: File format is %s ByteCode format\n",
2464                        __func__, (format_version == 2) ? "Jam STAPL" :
2465                                                "pre-standardized Jam 1.1");
2466                while (altera_get_note((u8 *)fw->data, fw->size,
2467                                        &offset, key, value, 256) == 0)
2468                        printk(KERN_INFO "%s: NOTE \"%s\" = \"%s\"\n",
2469                                        __func__, key, value);
2470        }
2471
2472        if (debug && (format_version == 2) && (action_count > 0)) {
2473                printk(KERN_INFO "%s: Actions available:\n", __func__);
2474                for (index = 0; index < action_count; ++index) {
2475                        altera_get_act_info((u8 *)fw->data, fw->size,
2476                                                index, &action_name,
2477                                                &description,
2478                                                &proc_list);
2479
2480                        if (description == NULL)
2481                                printk(KERN_INFO "%s: %s\n",
2482                                                __func__,
2483                                                action_name);
2484                        else
2485                                printk(KERN_INFO "%s: %s \"%s\"\n",
2486                                                __func__,
2487                                                action_name,
2488                                                description);
2489
2490                        procptr = proc_list;
2491                        while (procptr != NULL) {
2492                                if (procptr->attrs != 0)
2493                                        printk(KERN_INFO "%s:    %s (%s)\n",
2494                                                __func__,
2495                                                procptr->name,
2496                                                (procptr->attrs == 1) ?
2497                                                "optional" : "recommended");
2498
2499                                proc_list = procptr->next;
2500                                kfree(procptr);
2501                                procptr = proc_list;
2502                        }
2503                }
2504
2505                printk(KERN_INFO "\n");
2506        }
2507
2508        exec_result = altera_execute(astate, (u8 *)fw->data, fw->size,
2509                                &error_address, &exit_code, &format_version);
2510
2511        if (exit_code)
2512                exec_result = -EREMOTEIO;
2513
2514        if ((format_version == 2) && (exec_result == -EINVAL)) {
2515                if (astate->config->action == NULL)
2516                        printk(KERN_ERR "%s: error: no action specified for "
2517                                "Jam STAPL file.\nprogram terminated.\n",
2518                                __func__);
2519                else
2520                        printk(KERN_ERR "%s: error: action \"%s\""
2521                                " is not supported "
2522                                "for this Jam STAPL file.\n"
2523                                "Program terminated.\n", __func__,
2524                                astate->config->action);
2525
2526        } else if (exec_result)
2527                printk(KERN_ERR "%s: error %d\n", __func__, exec_result);
2528
2529        kfree(astate);
2530free_value:
2531        kfree(value);
2532free_key:
2533        kfree(key);
2534out:
2535        return retval;
2536}
2537EXPORT_SYMBOL(altera_init);
2538