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