drivers/misc/altera-stapl/altera.c

   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
  36 static int debug = 1;
  37 module_param(debug, int, 0644);
  38 MODULE_PARM_DESC(debug, "enable debugging information");
  39
  40 MODULE_DESCRIPTION("altera FPGA kernel module");
  41 MODULE_AUTHOR("Igor M. Liplianin  <liplianin@netup.ru>");
  42 MODULE_LICENSE("GPL");
  43
  44 #define dprintk(args...) \
  45         if (debug) { \
  46                 printk(KERN_DEBUG args); \
  47         }
  48
  49 enum 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
 127 struct 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. */
 134 static 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
 144 static 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
 152 static 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
 218 static 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
 432 exit_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
2129 static 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
2222 static 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
2302 static 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
2332 static 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
2417 int 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);
2530 free_value:
2531         kfree(value);
2532 free_key:
2533         kfree(key);
2534 out:
2535         return retval;
2536 }
2537 EXPORT_SYMBOL(altera_init);