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 <linux/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 = kzalloc_objs(long, sym_count); 294 295 if (vars == NULL) 296 status = -ENOMEM; 297 298 if (status == 0) { 299 var_size = kzalloc_objs(s32, sym_count); 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 swap(stack[stack_ptr - 2], stack[stack_ptr - 1]); 535 break; 536 case OP_ADD: 537 if (altera_check_stack(stack_ptr, 2, &status)) { 538 --stack_ptr; 539 stack[stack_ptr - 1] += stack[stack_ptr]; 540 } 541 break; 542 case OP_SUB: 543 if (altera_check_stack(stack_ptr, 2, &status)) { 544 --stack_ptr; 545 stack[stack_ptr - 1] -= stack[stack_ptr]; 546 } 547 break; 548 case OP_MULT: 549 if (altera_check_stack(stack_ptr, 2, &status)) { 550 --stack_ptr; 551 stack[stack_ptr - 1] *= stack[stack_ptr]; 552 } 553 break; 554 case OP_DIV: 555 if (altera_check_stack(stack_ptr, 2, &status)) { 556 --stack_ptr; 557 stack[stack_ptr - 1] /= stack[stack_ptr]; 558 } 559 break; 560 case OP_MOD: 561 if (altera_check_stack(stack_ptr, 2, &status)) { 562 --stack_ptr; 563 stack[stack_ptr - 1] %= stack[stack_ptr]; 564 } 565 break; 566 case OP_SHL: 567 if (altera_check_stack(stack_ptr, 2, &status)) { 568 --stack_ptr; 569 stack[stack_ptr - 1] <<= stack[stack_ptr]; 570 } 571 break; 572 case OP_SHR: 573 if (altera_check_stack(stack_ptr, 2, &status)) { 574 --stack_ptr; 575 stack[stack_ptr - 1] >>= stack[stack_ptr]; 576 } 577 break; 578 case OP_NOT: 579 if (altera_check_stack(stack_ptr, 1, &status)) 580 stack[stack_ptr - 1] ^= (-1L); 581 582 break; 583 case OP_AND: 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_OR: 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_XOR: 596 if (altera_check_stack(stack_ptr, 2, &status)) { 597 --stack_ptr; 598 stack[stack_ptr - 1] ^= stack[stack_ptr]; 599 } 600 break; 601 case OP_INV: 602 if (!altera_check_stack(stack_ptr, 1, &status)) 603 break; 604 stack[stack_ptr - 1] = stack[stack_ptr - 1] ? 0L : 1L; 605 break; 606 case OP_GT: 607 if (!altera_check_stack(stack_ptr, 2, &status)) 608 break; 609 --stack_ptr; 610 stack[stack_ptr - 1] = 611 (stack[stack_ptr - 1] > stack[stack_ptr]) ? 612 1L : 0L; 613 614 break; 615 case OP_LT: 616 if (!altera_check_stack(stack_ptr, 2, &status)) 617 break; 618 --stack_ptr; 619 stack[stack_ptr - 1] = 620 (stack[stack_ptr - 1] < stack[stack_ptr]) ? 621 1L : 0L; 622 623 break; 624 case OP_RET: 625 if ((version > 0) && (stack_ptr == 0)) { 626 /* 627 * We completed one of the main procedures 628 * of an ACTION. 629 * Find the next procedure 630 * to be executed and jump to it. 631 * If there are no more procedures, then EXIT. 632 */ 633 i = get_unaligned_be32(&p[proc_table + 634 (13 * current_proc) + 4]); 635 while ((i != 0) && 636 ((proc_attributes[i] == 1) || 637 ((proc_attributes[i] & 0xc0) == 0x40))) 638 i = get_unaligned_be32(&p[proc_table + 639 (13 * i) + 4]); 640 641 if (i == 0) { 642 /* no procedures to execute! */ 643 done = 1; 644 *exit_code = 0; /* success */ 645 } else { 646 current_proc = i; 647 pc = code_sect + get_unaligned_be32( 648 &p[proc_table + 649 (13 * i) + 9]); 650 if ((pc < code_sect) || 651 (pc >= debug_sect)) 652 status = -ERANGE; 653 } 654 655 } else 656 if (altera_check_stack(stack_ptr, 1, &status)) { 657 pc = stack[--stack_ptr] + code_sect; 658 if ((pc <= code_sect) || 659 (pc >= debug_sect)) 660 status = -ERANGE; 661 662 } 663 664 break; 665 case OP_CMPS: 666 /* 667 * Array short compare 668 * ...stack 0 is source 1 value 669 * ...stack 1 is source 2 value 670 * ...stack 2 is mask value 671 * ...stack 3 is count 672 */ 673 if (altera_check_stack(stack_ptr, 4, &status)) { 674 s32 a = stack[--stack_ptr]; 675 s32 b = stack[--stack_ptr]; 676 long_tmp = stack[--stack_ptr]; 677 count = stack[stack_ptr - 1]; 678 679 if ((count < 1) || (count > 32)) 680 status = -ERANGE; 681 else { 682 long_tmp &= ((-1L) >> (32 - count)); 683 684 stack[stack_ptr - 1] = 685 ((a & long_tmp) == (b & long_tmp)) 686 ? 1L : 0L; 687 } 688 } 689 break; 690 case OP_PINT: 691 /* 692 * PRINT add integer 693 * ...stack 0 is integer value 694 */ 695 if (!altera_check_stack(stack_ptr, 1, &status)) 696 break; 697 sprintf(&msg_buff[strlen(msg_buff)], 698 "%ld", stack[--stack_ptr]); 699 break; 700 case OP_PRNT: 701 /* PRINT finish */ 702 if (debug) 703 printk(msg_buff, "\n"); 704 705 msg_buff[0] = '\0'; 706 break; 707 case OP_DSS: 708 /* 709 * DRSCAN short 710 * ...stack 0 is scan data 711 * ...stack 1 is count 712 */ 713 if (!altera_check_stack(stack_ptr, 2, &status)) 714 break; 715 long_tmp = stack[--stack_ptr]; 716 count = stack[--stack_ptr]; 717 put_unaligned_le32(long_tmp, &charbuf[0]); 718 status = altera_drscan(astate, count, charbuf, 0); 719 break; 720 case OP_DSSC: 721 /* 722 * DRSCAN short with capture 723 * ...stack 0 is scan data 724 * ...stack 1 is count 725 */ 726 if (!altera_check_stack(stack_ptr, 2, &status)) 727 break; 728 long_tmp = stack[--stack_ptr]; 729 count = stack[stack_ptr - 1]; 730 put_unaligned_le32(long_tmp, &charbuf[0]); 731 status = altera_swap_dr(astate, count, charbuf, 732 0, charbuf, 0); 733 stack[stack_ptr - 1] = get_unaligned_le32(&charbuf[0]); 734 break; 735 case OP_ISS: 736 /* 737 * IRSCAN short 738 * ...stack 0 is scan data 739 * ...stack 1 is count 740 */ 741 if (!altera_check_stack(stack_ptr, 2, &status)) 742 break; 743 long_tmp = stack[--stack_ptr]; 744 count = stack[--stack_ptr]; 745 put_unaligned_le32(long_tmp, &charbuf[0]); 746 status = altera_irscan(astate, count, charbuf, 0); 747 break; 748 case OP_ISSC: 749 /* 750 * IRSCAN short with capture 751 * ...stack 0 is scan data 752 * ...stack 1 is count 753 */ 754 if (!altera_check_stack(stack_ptr, 2, &status)) 755 break; 756 long_tmp = stack[--stack_ptr]; 757 count = stack[stack_ptr - 1]; 758 put_unaligned_le32(long_tmp, &charbuf[0]); 759 status = altera_swap_ir(astate, count, charbuf, 760 0, charbuf, 0); 761 stack[stack_ptr - 1] = get_unaligned_le32(&charbuf[0]); 762 break; 763 case OP_DPR: 764 if (!altera_check_stack(stack_ptr, 1, &status)) 765 break; 766 count = stack[--stack_ptr]; 767 status = altera_set_dr_pre(&astate->js, count, 0, NULL); 768 break; 769 case OP_DPRL: 770 /* 771 * DRPRE with literal data 772 * ...stack 0 is count 773 * ...stack 1 is literal data 774 */ 775 if (!altera_check_stack(stack_ptr, 2, &status)) 776 break; 777 count = stack[--stack_ptr]; 778 long_tmp = stack[--stack_ptr]; 779 put_unaligned_le32(long_tmp, &charbuf[0]); 780 status = altera_set_dr_pre(&astate->js, count, 0, 781 charbuf); 782 break; 783 case OP_DPO: 784 /* 785 * DRPOST 786 * ...stack 0 is count 787 */ 788 if (altera_check_stack(stack_ptr, 1, &status)) { 789 count = stack[--stack_ptr]; 790 status = altera_set_dr_post(&astate->js, count, 791 0, NULL); 792 } 793 break; 794 case OP_DPOL: 795 /* 796 * DRPOST with literal data 797 * ...stack 0 is count 798 * ...stack 1 is literal data 799 */ 800 if (!altera_check_stack(stack_ptr, 2, &status)) 801 break; 802 count = stack[--stack_ptr]; 803 long_tmp = stack[--stack_ptr]; 804 put_unaligned_le32(long_tmp, &charbuf[0]); 805 status = altera_set_dr_post(&astate->js, count, 0, 806 charbuf); 807 break; 808 case OP_IPR: 809 if (altera_check_stack(stack_ptr, 1, &status)) { 810 count = stack[--stack_ptr]; 811 status = altera_set_ir_pre(&astate->js, count, 812 0, NULL); 813 } 814 break; 815 case OP_IPRL: 816 /* 817 * IRPRE with literal data 818 * ...stack 0 is count 819 * ...stack 1 is literal data 820 */ 821 if (altera_check_stack(stack_ptr, 2, &status)) { 822 count = stack[--stack_ptr]; 823 long_tmp = stack[--stack_ptr]; 824 put_unaligned_le32(long_tmp, &charbuf[0]); 825 status = altera_set_ir_pre(&astate->js, count, 826 0, charbuf); 827 } 828 break; 829 case OP_IPO: 830 /* 831 * IRPOST 832 * ...stack 0 is count 833 */ 834 if (altera_check_stack(stack_ptr, 1, &status)) { 835 count = stack[--stack_ptr]; 836 status = altera_set_ir_post(&astate->js, count, 837 0, NULL); 838 } 839 break; 840 case OP_IPOL: 841 /* 842 * IRPOST with literal data 843 * ...stack 0 is count 844 * ...stack 1 is literal data 845 */ 846 if (!altera_check_stack(stack_ptr, 2, &status)) 847 break; 848 count = stack[--stack_ptr]; 849 long_tmp = stack[--stack_ptr]; 850 put_unaligned_le32(long_tmp, &charbuf[0]); 851 status = altera_set_ir_post(&astate->js, count, 0, 852 charbuf); 853 break; 854 case OP_PCHR: 855 if (altera_check_stack(stack_ptr, 1, &status)) { 856 u8 ch; 857 count = strlen(msg_buff); 858 ch = (char) stack[--stack_ptr]; 859 if ((ch < 1) || (ch > 127)) { 860 /* 861 * character code out of range 862 * instead of flagging an error, 863 * force the value to 127 864 */ 865 ch = 127; 866 } 867 msg_buff[count] = ch; 868 msg_buff[count + 1] = '\0'; 869 } 870 break; 871 case OP_EXIT: 872 if (altera_check_stack(stack_ptr, 1, &status)) 873 *exit_code = stack[--stack_ptr]; 874 875 done = 1; 876 break; 877 case OP_EQU: 878 if (!altera_check_stack(stack_ptr, 2, &status)) 879 break; 880 --stack_ptr; 881 stack[stack_ptr - 1] = 882 (stack[stack_ptr - 1] == stack[stack_ptr]) ? 883 1L : 0L; 884 break; 885 case OP_POPT: 886 if (altera_check_stack(stack_ptr, 1, &status)) 887 --stack_ptr; 888 889 break; 890 case OP_ABS: 891 if (!altera_check_stack(stack_ptr, 1, &status)) 892 break; 893 if (stack[stack_ptr - 1] < 0) 894 stack[stack_ptr - 1] = 0 - stack[stack_ptr - 1]; 895 896 break; 897 case OP_BCH0: 898 /* 899 * Batch operation 0 900 * SWP 901 * SWPN 7 902 * SWP 903 * SWPN 6 904 * DUPN 8 905 * SWPN 2 906 * SWP 907 * DUPN 6 908 * DUPN 6 909 */ 910 911 /* SWP */ 912 if (altera_check_stack(stack_ptr, 2, &status)) 913 swap(stack[stack_ptr - 2], stack[stack_ptr - 1]); 914 915 /* SWPN 7 */ 916 index = 7 + 1; 917 if (altera_check_stack(stack_ptr, index, &status)) 918 swap(stack[stack_ptr - index], stack[stack_ptr - 1]); 919 920 /* SWP */ 921 if (altera_check_stack(stack_ptr, 2, &status)) 922 swap(stack[stack_ptr - 2], stack[stack_ptr - 1]); 923 924 /* SWPN 6 */ 925 index = 6 + 1; 926 if (altera_check_stack(stack_ptr, index, &status)) 927 swap(stack[stack_ptr - index], stack[stack_ptr - 1]); 928 929 /* DUPN 8 */ 930 index = 8 + 1; 931 if (altera_check_stack(stack_ptr, index, &status)) { 932 stack[stack_ptr] = stack[stack_ptr - index]; 933 ++stack_ptr; 934 } 935 936 /* SWPN 2 */ 937 index = 2 + 1; 938 if (altera_check_stack(stack_ptr, index, &status)) 939 swap(stack[stack_ptr - index], stack[stack_ptr - 1]); 940 941 /* SWP */ 942 if (altera_check_stack(stack_ptr, 2, &status)) 943 swap(stack[stack_ptr - 2], stack[stack_ptr - 1]); 944 945 /* DUPN 6 */ 946 index = 6 + 1; 947 if (altera_check_stack(stack_ptr, index, &status)) { 948 stack[stack_ptr] = stack[stack_ptr - index]; 949 ++stack_ptr; 950 } 951 952 /* DUPN 6 */ 953 index = 6 + 1; 954 if (altera_check_stack(stack_ptr, index, &status)) { 955 stack[stack_ptr] = stack[stack_ptr - index]; 956 ++stack_ptr; 957 } 958 break; 959 case OP_PSH0: 960 stack[stack_ptr++] = 0; 961 break; 962 case OP_PSHL: 963 stack[stack_ptr++] = (s32) args[0]; 964 break; 965 case OP_PSHV: 966 stack[stack_ptr++] = vars[args[0]]; 967 break; 968 case OP_JMP: 969 pc = args[0] + code_sect; 970 if ((pc < code_sect) || (pc >= debug_sect)) 971 status = -ERANGE; 972 break; 973 case OP_CALL: 974 stack[stack_ptr++] = pc; 975 pc = args[0] + code_sect; 976 if ((pc < code_sect) || (pc >= debug_sect)) 977 status = -ERANGE; 978 break; 979 case OP_NEXT: 980 /* 981 * Process FOR / NEXT loop 982 * ...argument 0 is variable ID 983 * ...stack 0 is step value 984 * ...stack 1 is end value 985 * ...stack 2 is top address 986 */ 987 if (altera_check_stack(stack_ptr, 3, &status)) { 988 s32 step = stack[stack_ptr - 1]; 989 s32 end = stack[stack_ptr - 2]; 990 s32 top = stack[stack_ptr - 3]; 991 s32 iterator = vars[args[0]]; 992 int break_out = 0; 993 994 if (step < 0) { 995 if (iterator <= end) 996 break_out = 1; 997 } else if (iterator >= end) 998 break_out = 1; 999 1000 if (break_out) { 1001 stack_ptr -= 3; 1002 } else { 1003 vars[args[0]] = iterator + step; 1004 pc = top + code_sect; 1005 if ((pc < code_sect) || 1006 (pc >= debug_sect)) 1007 status = -ERANGE; 1008 } 1009 } 1010 break; 1011 case OP_PSTR: 1012 /* 1013 * PRINT add string 1014 * ...argument 0 is string ID 1015 */ 1016 count = strlen(msg_buff); 1017 strscpy(&msg_buff[count], 1018 &p[str_table + args[0]], 1019 ALTERA_MESSAGE_LENGTH - count); 1020 break; 1021 case OP_SINT: 1022 /* 1023 * STATE intermediate state 1024 * ...argument 0 is state code 1025 */ 1026 status = altera_goto_jstate(astate, args[0]); 1027 break; 1028 case OP_ST: 1029 /* 1030 * STATE final state 1031 * ...argument 0 is state code 1032 */ 1033 status = altera_goto_jstate(astate, args[0]); 1034 break; 1035 case OP_ISTP: 1036 /* 1037 * IRSTOP state 1038 * ...argument 0 is state code 1039 */ 1040 status = altera_set_irstop(&astate->js, args[0]); 1041 break; 1042 case OP_DSTP: 1043 /* 1044 * DRSTOP state 1045 * ...argument 0 is state code 1046 */ 1047 status = altera_set_drstop(&astate->js, args[0]); 1048 break; 1049 1050 case OP_SWPN: 1051 /* 1052 * Exchange top with Nth stack value 1053 * ...argument 0 is 0-based stack entry 1054 * to swap with top element 1055 */ 1056 index = (args[0]) + 1; 1057 if (altera_check_stack(stack_ptr, index, &status)) 1058 swap(stack[stack_ptr - index], stack[stack_ptr - 1]); 1059 break; 1060 case OP_DUPN: 1061 /* 1062 * Duplicate Nth stack value 1063 * ...argument 0 is 0-based stack entry to duplicate 1064 */ 1065 index = (args[0]) + 1; 1066 if (altera_check_stack(stack_ptr, index, &status)) { 1067 stack[stack_ptr] = stack[stack_ptr - index]; 1068 ++stack_ptr; 1069 } 1070 break; 1071 case OP_POPV: 1072 /* 1073 * Pop stack into scalar variable 1074 * ...argument 0 is variable ID 1075 * ...stack 0 is value 1076 */ 1077 if (altera_check_stack(stack_ptr, 1, &status)) 1078 vars[args[0]] = stack[--stack_ptr]; 1079 1080 break; 1081 case OP_POPE: 1082 /* 1083 * Pop stack into integer array element 1084 * ...argument 0 is variable ID 1085 * ...stack 0 is array index 1086 * ...stack 1 is value 1087 */ 1088 if (!altera_check_stack(stack_ptr, 2, &status)) 1089 break; 1090 variable_id = args[0]; 1091 1092 /* 1093 * If variable is read-only, 1094 * convert to writable array 1095 */ 1096 if ((version > 0) && 1097 ((attrs[variable_id] & 0x9c) == 0x1c)) { 1098 /* Allocate a writable buffer for this array */ 1099 count = var_size[variable_id]; 1100 long_tmp = vars[variable_id]; 1101 longptr_tmp = kzalloc_objs(long, count); 1102 vars[variable_id] = (long)longptr_tmp; 1103 1104 if (vars[variable_id] == 0) { 1105 status = -ENOMEM; 1106 break; 1107 } 1108 1109 /* copy previous contents into buffer */ 1110 for (i = 0; i < count; ++i) { 1111 longptr_tmp[i] = 1112 get_unaligned_be32(&p[long_tmp]); 1113 long_tmp += sizeof(long); 1114 } 1115 1116 /* 1117 * set bit 7 - buffer was 1118 * dynamically allocated 1119 */ 1120 attrs[variable_id] |= 0x80; 1121 1122 /* clear bit 2 - variable is writable */ 1123 attrs[variable_id] &= ~0x04; 1124 attrs[variable_id] |= 0x01; 1125 1126 } 1127 1128 /* check that variable is a writable integer array */ 1129 if ((attrs[variable_id] & 0x1c) != 0x18) 1130 status = -ERANGE; 1131 else { 1132 longptr_tmp = (long *)vars[variable_id]; 1133 1134 /* pop the array index */ 1135 index = stack[--stack_ptr]; 1136 1137 /* pop the value and store it into the array */ 1138 longptr_tmp[index] = stack[--stack_ptr]; 1139 } 1140 1141 break; 1142 case OP_POPA: 1143 /* 1144 * Pop stack into Boolean array 1145 * ...argument 0 is variable ID 1146 * ...stack 0 is count 1147 * ...stack 1 is array index 1148 * ...stack 2 is value 1149 */ 1150 if (!altera_check_stack(stack_ptr, 3, &status)) 1151 break; 1152 variable_id = args[0]; 1153 1154 /* 1155 * If variable is read-only, 1156 * convert to writable array 1157 */ 1158 if ((version > 0) && 1159 ((attrs[variable_id] & 0x9c) == 0x0c)) { 1160 /* Allocate a writable buffer for this array */ 1161 long_tmp = 1162 (var_size[variable_id] + 7L) >> 3L; 1163 charptr_tmp2 = (u8 *)vars[variable_id]; 1164 charptr_tmp = 1165 kzalloc(long_tmp, GFP_KERNEL); 1166 vars[variable_id] = (long)charptr_tmp; 1167 1168 if (vars[variable_id] == 0) { 1169 status = -ENOMEM; 1170 break; 1171 } 1172 1173 /* zero the buffer */ 1174 for (long_idx = 0L; 1175 long_idx < long_tmp; 1176 ++long_idx) { 1177 charptr_tmp[long_idx] = 0; 1178 } 1179 1180 /* copy previous contents into buffer */ 1181 for (long_idx = 0L; 1182 long_idx < var_size[variable_id]; 1183 ++long_idx) { 1184 long_idx2 = long_idx; 1185 1186 if (charptr_tmp2[long_idx2 >> 3] & 1187 (1 << (long_idx2 & 7))) { 1188 charptr_tmp[long_idx >> 3] |= 1189 (1 << (long_idx & 7)); 1190 } 1191 } 1192 1193 /* 1194 * set bit 7 - buffer was 1195 * dynamically allocated 1196 */ 1197 attrs[variable_id] |= 0x80; 1198 1199 /* clear bit 2 - variable is writable */ 1200 attrs[variable_id] &= ~0x04; 1201 attrs[variable_id] |= 0x01; 1202 1203 } 1204 1205 /* 1206 * check that variable is 1207 * a writable Boolean array 1208 */ 1209 if ((attrs[variable_id] & 0x1c) != 0x08) { 1210 status = -ERANGE; 1211 break; 1212 } 1213 1214 charptr_tmp = (u8 *)vars[variable_id]; 1215 1216 /* pop the count (number of bits to copy) */ 1217 long_count = stack[--stack_ptr]; 1218 1219 /* pop the array index */ 1220 long_idx = stack[--stack_ptr]; 1221 1222 reverse = 0; 1223 1224 if (version > 0) { 1225 /* 1226 * stack 0 = array right index 1227 * stack 1 = array left index 1228 */ 1229 1230 if (long_idx > long_count) { 1231 reverse = 1; 1232 long_tmp = long_count; 1233 long_count = 1 + long_idx - 1234 long_count; 1235 long_idx = long_tmp; 1236 1237 /* reverse POPA is not supported */ 1238 status = -ERANGE; 1239 break; 1240 } else 1241 long_count = 1 + long_count - 1242 long_idx; 1243 1244 } 1245 1246 /* pop the data */ 1247 long_tmp = stack[--stack_ptr]; 1248 1249 if (long_count < 1) { 1250 status = -ERANGE; 1251 break; 1252 } 1253 1254 for (i = 0; i < long_count; ++i) { 1255 if (long_tmp & (1L << (s32) i)) 1256 charptr_tmp[long_idx >> 3L] |= 1257 (1L << (long_idx & 7L)); 1258 else 1259 charptr_tmp[long_idx >> 3L] &= 1260 ~(1L << (long_idx & 7L)); 1261 1262 ++long_idx; 1263 } 1264 1265 break; 1266 case OP_JMPZ: 1267 /* 1268 * Pop stack and branch if zero 1269 * ...argument 0 is address 1270 * ...stack 0 is condition value 1271 */ 1272 if (altera_check_stack(stack_ptr, 1, &status)) { 1273 if (stack[--stack_ptr] == 0) { 1274 pc = args[0] + code_sect; 1275 if ((pc < code_sect) || 1276 (pc >= debug_sect)) 1277 status = -ERANGE; 1278 } 1279 } 1280 break; 1281 case OP_DS: 1282 case OP_IS: 1283 /* 1284 * DRSCAN 1285 * IRSCAN 1286 * ...argument 0 is scan data variable ID 1287 * ...stack 0 is array index 1288 * ...stack 1 is count 1289 */ 1290 if (!altera_check_stack(stack_ptr, 2, &status)) 1291 break; 1292 long_idx = stack[--stack_ptr]; 1293 long_count = stack[--stack_ptr]; 1294 reverse = 0; 1295 if (version > 0) { 1296 /* 1297 * stack 0 = array right index 1298 * stack 1 = array left index 1299 * stack 2 = count 1300 */ 1301 long_tmp = long_count; 1302 long_count = stack[--stack_ptr]; 1303 1304 if (long_idx > long_tmp) { 1305 reverse = 1; 1306 long_idx = long_tmp; 1307 } 1308 } 1309 1310 charptr_tmp = (u8 *)vars[args[0]]; 1311 1312 if (reverse) { 1313 /* 1314 * allocate a buffer 1315 * and reverse the data order 1316 */ 1317 charptr_tmp2 = charptr_tmp; 1318 charptr_tmp = kzalloc((long_count >> 3) + 1, 1319 GFP_KERNEL); 1320 if (charptr_tmp == NULL) { 1321 status = -ENOMEM; 1322 break; 1323 } 1324 1325 long_tmp = long_idx + long_count - 1; 1326 long_idx2 = 0; 1327 while (long_idx2 < long_count) { 1328 if (charptr_tmp2[long_tmp >> 3] & 1329 (1 << (long_tmp & 7))) 1330 charptr_tmp[long_idx2 >> 3] |= 1331 (1 << (long_idx2 & 7)); 1332 else 1333 charptr_tmp[long_idx2 >> 3] &= 1334 ~(1 << (long_idx2 & 7)); 1335 1336 --long_tmp; 1337 ++long_idx2; 1338 } 1339 } 1340 1341 if (opcode == 0x51) /* DS */ 1342 status = altera_drscan(astate, long_count, 1343 charptr_tmp, long_idx); 1344 else /* IS */ 1345 status = altera_irscan(astate, long_count, 1346 charptr_tmp, long_idx); 1347 1348 if (reverse) 1349 kfree(charptr_tmp); 1350 1351 break; 1352 case OP_DPRA: 1353 /* 1354 * DRPRE with array data 1355 * ...argument 0 is variable ID 1356 * ...stack 0 is array index 1357 * ...stack 1 is count 1358 */ 1359 if (!altera_check_stack(stack_ptr, 2, &status)) 1360 break; 1361 index = stack[--stack_ptr]; 1362 count = stack[--stack_ptr]; 1363 1364 if (version > 0) 1365 /* 1366 * stack 0 = array right index 1367 * stack 1 = array left index 1368 */ 1369 count = 1 + count - index; 1370 1371 charptr_tmp = (u8 *)vars[args[0]]; 1372 status = altera_set_dr_pre(&astate->js, count, index, 1373 charptr_tmp); 1374 break; 1375 case OP_DPOA: 1376 /* 1377 * DRPOST with array data 1378 * ...argument 0 is variable ID 1379 * ...stack 0 is array index 1380 * ...stack 1 is count 1381 */ 1382 if (!altera_check_stack(stack_ptr, 2, &status)) 1383 break; 1384 index = stack[--stack_ptr]; 1385 count = stack[--stack_ptr]; 1386 1387 if (version > 0) 1388 /* 1389 * stack 0 = array right index 1390 * stack 1 = array left index 1391 */ 1392 count = 1 + count - index; 1393 1394 charptr_tmp = (u8 *)vars[args[0]]; 1395 status = altera_set_dr_post(&astate->js, count, index, 1396 charptr_tmp); 1397 break; 1398 case OP_IPRA: 1399 /* 1400 * IRPRE with array data 1401 * ...argument 0 is variable ID 1402 * ...stack 0 is array index 1403 * ...stack 1 is count 1404 */ 1405 if (!altera_check_stack(stack_ptr, 2, &status)) 1406 break; 1407 index = stack[--stack_ptr]; 1408 count = stack[--stack_ptr]; 1409 1410 if (version > 0) 1411 /* 1412 * stack 0 = array right index 1413 * stack 1 = array left index 1414 */ 1415 count = 1 + count - index; 1416 1417 charptr_tmp = (u8 *)vars[args[0]]; 1418 status = altera_set_ir_pre(&astate->js, count, index, 1419 charptr_tmp); 1420 1421 break; 1422 case OP_IPOA: 1423 /* 1424 * IRPOST with array data 1425 * ...argument 0 is variable ID 1426 * ...stack 0 is array index 1427 * ...stack 1 is count 1428 */ 1429 if (!altera_check_stack(stack_ptr, 2, &status)) 1430 break; 1431 index = stack[--stack_ptr]; 1432 count = stack[--stack_ptr]; 1433 1434 if (version > 0) 1435 /* 1436 * stack 0 = array right index 1437 * stack 1 = array left index 1438 */ 1439 count = 1 + count - index; 1440 1441 charptr_tmp = (u8 *)vars[args[0]]; 1442 status = altera_set_ir_post(&astate->js, count, index, 1443 charptr_tmp); 1444 1445 break; 1446 case OP_EXPT: 1447 /* 1448 * EXPORT 1449 * ...argument 0 is string ID 1450 * ...stack 0 is integer expression 1451 */ 1452 if (altera_check_stack(stack_ptr, 1, &status)) { 1453 name = &p[str_table + args[0]]; 1454 long_tmp = stack[--stack_ptr]; 1455 altera_export_int(name, long_tmp); 1456 } 1457 break; 1458 case OP_PSHE: 1459 /* 1460 * Push integer array element 1461 * ...argument 0 is variable ID 1462 * ...stack 0 is array index 1463 */ 1464 if (!altera_check_stack(stack_ptr, 1, &status)) 1465 break; 1466 variable_id = args[0]; 1467 index = stack[stack_ptr - 1]; 1468 1469 /* check variable type */ 1470 if ((attrs[variable_id] & 0x1f) == 0x19) { 1471 /* writable integer array */ 1472 longptr_tmp = (long *)vars[variable_id]; 1473 stack[stack_ptr - 1] = longptr_tmp[index]; 1474 } else if ((attrs[variable_id] & 0x1f) == 0x1c) { 1475 /* read-only integer array */ 1476 long_tmp = vars[variable_id] + 1477 (index * sizeof(long)); 1478 stack[stack_ptr - 1] = 1479 get_unaligned_be32(&p[long_tmp]); 1480 } else 1481 status = -ERANGE; 1482 1483 break; 1484 case OP_PSHA: 1485 /* 1486 * Push Boolean array 1487 * ...argument 0 is variable ID 1488 * ...stack 0 is count 1489 * ...stack 1 is array index 1490 */ 1491 if (!altera_check_stack(stack_ptr, 2, &status)) 1492 break; 1493 variable_id = args[0]; 1494 1495 /* check that variable is a Boolean array */ 1496 if ((attrs[variable_id] & 0x18) != 0x08) { 1497 status = -ERANGE; 1498 break; 1499 } 1500 1501 charptr_tmp = (u8 *)vars[variable_id]; 1502 1503 /* pop the count (number of bits to copy) */ 1504 count = stack[--stack_ptr]; 1505 1506 /* pop the array index */ 1507 index = stack[stack_ptr - 1]; 1508 1509 if (version > 0) 1510 /* 1511 * stack 0 = array right index 1512 * stack 1 = array left index 1513 */ 1514 count = 1 + count - index; 1515 1516 if ((count < 1) || (count > 32)) { 1517 status = -ERANGE; 1518 break; 1519 } 1520 1521 long_tmp = 0L; 1522 1523 for (i = 0; i < count; ++i) 1524 if (charptr_tmp[(i + index) >> 3] & 1525 (1 << ((i + index) & 7))) 1526 long_tmp |= (1L << i); 1527 1528 stack[stack_ptr - 1] = long_tmp; 1529 1530 break; 1531 case OP_DYNA: 1532 /* 1533 * Dynamically change size of array 1534 * ...argument 0 is variable ID 1535 * ...stack 0 is new size 1536 */ 1537 if (!altera_check_stack(stack_ptr, 1, &status)) 1538 break; 1539 variable_id = args[0]; 1540 long_tmp = stack[--stack_ptr]; 1541 1542 if (long_tmp > var_size[variable_id]) { 1543 var_size[variable_id] = long_tmp; 1544 1545 if (attrs[variable_id] & 0x10) 1546 /* allocate integer array */ 1547 long_tmp *= sizeof(long); 1548 else 1549 /* allocate Boolean array */ 1550 long_tmp = (long_tmp + 7) >> 3; 1551 1552 /* 1553 * If the buffer was previously allocated, 1554 * free it 1555 */ 1556 if (attrs[variable_id] & 0x80) { 1557 kfree((void *)vars[variable_id]); 1558 vars[variable_id] = 0; 1559 } 1560 1561 /* 1562 * Allocate a new buffer 1563 * of the requested size 1564 */ 1565 vars[variable_id] = (long) 1566 kzalloc(long_tmp, GFP_KERNEL); 1567 1568 if (vars[variable_id] == 0) { 1569 status = -ENOMEM; 1570 break; 1571 } 1572 1573 /* 1574 * Set the attribute bit to indicate that 1575 * this buffer was dynamically allocated and 1576 * should be freed later 1577 */ 1578 attrs[variable_id] |= 0x80; 1579 1580 /* zero out memory */ 1581 count = ((var_size[variable_id] + 7L) / 1582 8L); 1583 charptr_tmp = (u8 *)(vars[variable_id]); 1584 for (index = 0; index < count; ++index) 1585 charptr_tmp[index] = 0; 1586 1587 } 1588 1589 break; 1590 case OP_EXPV: 1591 /* 1592 * Export Boolean array 1593 * ...argument 0 is string ID 1594 * ...stack 0 is variable ID 1595 * ...stack 1 is array right index 1596 * ...stack 2 is array left index 1597 */ 1598 if (!altera_check_stack(stack_ptr, 3, &status)) 1599 break; 1600 if (version == 0) { 1601 /* EXPV is not supported in JBC 1.0 */ 1602 bad_opcode = 1; 1603 break; 1604 } 1605 name = &p[str_table + args[0]]; 1606 variable_id = stack[--stack_ptr]; 1607 long_idx = stack[--stack_ptr];/* right indx */ 1608 long_idx2 = stack[--stack_ptr];/* left indx */ 1609 1610 if (long_idx > long_idx2) { 1611 /* reverse indices not supported */ 1612 status = -ERANGE; 1613 break; 1614 } 1615 1616 long_count = 1 + long_idx2 - long_idx; 1617 1618 charptr_tmp = (u8 *)vars[variable_id]; 1619 charptr_tmp2 = NULL; 1620 1621 if ((long_idx & 7L) != 0) { 1622 s32 k = long_idx; 1623 charptr_tmp2 = 1624 kzalloc(((long_count + 7L) / 8L), 1625 GFP_KERNEL); 1626 if (charptr_tmp2 == NULL) { 1627 status = -ENOMEM; 1628 break; 1629 } 1630 1631 for (i = 0; i < long_count; ++i) { 1632 if (charptr_tmp[k >> 3] & 1633 (1 << (k & 7))) 1634 charptr_tmp2[i >> 3] |= 1635 (1 << (i & 7)); 1636 else 1637 charptr_tmp2[i >> 3] &= 1638 ~(1 << (i & 7)); 1639 1640 ++k; 1641 } 1642 charptr_tmp = charptr_tmp2; 1643 1644 } else if (long_idx != 0) 1645 charptr_tmp = &charptr_tmp[long_idx >> 3]; 1646 1647 altera_export_bool_array(name, charptr_tmp, 1648 long_count); 1649 1650 /* free allocated buffer */ 1651 if ((long_idx & 7L) != 0) 1652 kfree(charptr_tmp2); 1653 1654 break; 1655 case OP_COPY: { 1656 /* 1657 * Array copy 1658 * ...argument 0 is dest ID 1659 * ...argument 1 is source ID 1660 * ...stack 0 is count 1661 * ...stack 1 is dest index 1662 * ...stack 2 is source index 1663 */ 1664 s32 copy_count; 1665 s32 copy_index; 1666 s32 copy_index2; 1667 s32 destleft; 1668 s32 src_count; 1669 s32 dest_count; 1670 int src_reverse = 0; 1671 int dest_reverse = 0; 1672 1673 if (!altera_check_stack(stack_ptr, 3, &status)) 1674 break; 1675 1676 copy_count = stack[--stack_ptr]; 1677 copy_index = stack[--stack_ptr]; 1678 copy_index2 = stack[--stack_ptr]; 1679 reverse = 0; 1680 1681 if (version > 0) { 1682 /* 1683 * stack 0 = source right index 1684 * stack 1 = source left index 1685 * stack 2 = destination right index 1686 * stack 3 = destination left index 1687 */ 1688 destleft = stack[--stack_ptr]; 1689 1690 if (copy_count > copy_index) { 1691 src_reverse = 1; 1692 reverse = 1; 1693 src_count = 1 + copy_count - copy_index; 1694 /* copy_index = source start index */ 1695 } else { 1696 src_count = 1 + copy_index - copy_count; 1697 /* source start index */ 1698 copy_index = copy_count; 1699 } 1700 1701 if (copy_index2 > destleft) { 1702 dest_reverse = 1; 1703 reverse = !reverse; 1704 dest_count = 1 + copy_index2 - destleft; 1705 /* destination start index */ 1706 copy_index2 = destleft; 1707 } else 1708 dest_count = 1 + destleft - copy_index2; 1709 1710 copy_count = (src_count < dest_count) ? 1711 src_count : dest_count; 1712 1713 if ((src_reverse || dest_reverse) && 1714 (src_count != dest_count)) 1715 /* 1716 * If either the source or destination 1717 * is reversed, we can't tolerate 1718 * a length mismatch, because we 1719 * "left justify" arrays when copying. 1720 * This won't work correctly 1721 * with reversed arrays. 1722 */ 1723 status = -ERANGE; 1724 1725 } 1726 1727 count = copy_count; 1728 index = copy_index; 1729 index2 = copy_index2; 1730 1731 /* 1732 * If destination is a read-only array, 1733 * allocate a buffer and convert it to a writable array 1734 */ 1735 variable_id = args[1]; 1736 if ((version > 0) && 1737 ((attrs[variable_id] & 0x9c) == 0x0c)) { 1738 /* Allocate a writable buffer for this array */ 1739 long_tmp = 1740 (var_size[variable_id] + 7L) >> 3L; 1741 charptr_tmp2 = (u8 *)vars[variable_id]; 1742 charptr_tmp = 1743 kzalloc(long_tmp, GFP_KERNEL); 1744 vars[variable_id] = (long)charptr_tmp; 1745 1746 if (vars[variable_id] == 0) { 1747 status = -ENOMEM; 1748 break; 1749 } 1750 1751 /* zero the buffer */ 1752 for (long_idx = 0L; long_idx < long_tmp; 1753 ++long_idx) 1754 charptr_tmp[long_idx] = 0; 1755 1756 /* copy previous contents into buffer */ 1757 for (long_idx = 0L; 1758 long_idx < var_size[variable_id]; 1759 ++long_idx) { 1760 long_idx2 = long_idx; 1761 1762 if (charptr_tmp2[long_idx2 >> 3] & 1763 (1 << (long_idx2 & 7))) 1764 charptr_tmp[long_idx >> 3] |= 1765 (1 << (long_idx & 7)); 1766 1767 } 1768 1769 /* 1770 set bit 7 - buffer was dynamically allocated */ 1771 attrs[variable_id] |= 0x80; 1772 1773 /* clear bit 2 - variable is writable */ 1774 attrs[variable_id] &= ~0x04; 1775 attrs[variable_id] |= 0x01; 1776 } 1777 1778 charptr_tmp = (u8 *)vars[args[1]]; 1779 charptr_tmp2 = (u8 *)vars[args[0]]; 1780 1781 /* check if destination is a writable Boolean array */ 1782 if ((attrs[args[1]] & 0x1c) != 0x08) { 1783 status = -ERANGE; 1784 break; 1785 } 1786 1787 if (count < 1) { 1788 status = -ERANGE; 1789 break; 1790 } 1791 1792 if (reverse) 1793 index2 += (count - 1); 1794 1795 for (i = 0; i < count; ++i) { 1796 if (charptr_tmp2[index >> 3] & 1797 (1 << (index & 7))) 1798 charptr_tmp[index2 >> 3] |= 1799 (1 << (index2 & 7)); 1800 else 1801 charptr_tmp[index2 >> 3] &= 1802 ~(1 << (index2 & 7)); 1803 1804 ++index; 1805 if (reverse) 1806 --index2; 1807 else 1808 ++index2; 1809 } 1810 1811 break; 1812 } 1813 case OP_DSC: 1814 case OP_ISC: { 1815 /* 1816 * DRSCAN with capture 1817 * IRSCAN with capture 1818 * ...argument 0 is scan data variable ID 1819 * ...argument 1 is capture variable ID 1820 * ...stack 0 is capture index 1821 * ...stack 1 is scan data index 1822 * ...stack 2 is count 1823 */ 1824 s32 scan_right, scan_left; 1825 s32 capture_count = 0; 1826 s32 scan_count = 0; 1827 s32 capture_index; 1828 s32 scan_index; 1829 1830 if (!altera_check_stack(stack_ptr, 3, &status)) 1831 break; 1832 1833 capture_index = stack[--stack_ptr]; 1834 scan_index = stack[--stack_ptr]; 1835 1836 if (version > 0) { 1837 /* 1838 * stack 0 = capture right index 1839 * stack 1 = capture left index 1840 * stack 2 = scan right index 1841 * stack 3 = scan left index 1842 * stack 4 = count 1843 */ 1844 scan_right = stack[--stack_ptr]; 1845 scan_left = stack[--stack_ptr]; 1846 capture_count = 1 + scan_index - capture_index; 1847 scan_count = 1 + scan_left - scan_right; 1848 scan_index = scan_right; 1849 } 1850 1851 long_count = stack[--stack_ptr]; 1852 /* 1853 * If capture array is read-only, allocate a buffer 1854 * and convert it to a writable array 1855 */ 1856 variable_id = args[1]; 1857 if ((version > 0) && 1858 ((attrs[variable_id] & 0x9c) == 0x0c)) { 1859 /* Allocate a writable buffer for this array */ 1860 long_tmp = 1861 (var_size[variable_id] + 7L) >> 3L; 1862 charptr_tmp2 = (u8 *)vars[variable_id]; 1863 charptr_tmp = 1864 kzalloc(long_tmp, GFP_KERNEL); 1865 vars[variable_id] = (long)charptr_tmp; 1866 1867 if (vars[variable_id] == 0) { 1868 status = -ENOMEM; 1869 break; 1870 } 1871 1872 /* zero the buffer */ 1873 for (long_idx = 0L; long_idx < long_tmp; 1874 ++long_idx) 1875 charptr_tmp[long_idx] = 0; 1876 1877 /* copy previous contents into buffer */ 1878 for (long_idx = 0L; 1879 long_idx < var_size[variable_id]; 1880 ++long_idx) { 1881 long_idx2 = long_idx; 1882 1883 if (charptr_tmp2[long_idx2 >> 3] & 1884 (1 << (long_idx2 & 7))) 1885 charptr_tmp[long_idx >> 3] |= 1886 (1 << (long_idx & 7)); 1887 1888 } 1889 1890 /* 1891 * set bit 7 - buffer was 1892 * dynamically allocated 1893 */ 1894 attrs[variable_id] |= 0x80; 1895 1896 /* clear bit 2 - variable is writable */ 1897 attrs[variable_id] &= ~0x04; 1898 attrs[variable_id] |= 0x01; 1899 1900 } 1901 1902 charptr_tmp = (u8 *)vars[args[0]]; 1903 charptr_tmp2 = (u8 *)vars[args[1]]; 1904 1905 if ((version > 0) && 1906 ((long_count > capture_count) || 1907 (long_count > scan_count))) { 1908 status = -ERANGE; 1909 break; 1910 } 1911 1912 /* 1913 * check that capture array 1914 * is a writable Boolean array 1915 */ 1916 if ((attrs[args[1]] & 0x1c) != 0x08) { 1917 status = -ERANGE; 1918 break; 1919 } 1920 1921 if (status == 0) { 1922 if (opcode == 0x82) /* DSC */ 1923 status = altera_swap_dr(astate, 1924 long_count, 1925 charptr_tmp, 1926 scan_index, 1927 charptr_tmp2, 1928 capture_index); 1929 else /* ISC */ 1930 status = altera_swap_ir(astate, 1931 long_count, 1932 charptr_tmp, 1933 scan_index, 1934 charptr_tmp2, 1935 capture_index); 1936 1937 } 1938 1939 break; 1940 } 1941 case OP_WAIT: 1942 /* 1943 * WAIT 1944 * ...argument 0 is wait state 1945 * ...argument 1 is end state 1946 * ...stack 0 is cycles 1947 * ...stack 1 is microseconds 1948 */ 1949 if (!altera_check_stack(stack_ptr, 2, &status)) 1950 break; 1951 long_tmp = stack[--stack_ptr]; 1952 1953 if (long_tmp != 0L) 1954 status = altera_wait_cycles(astate, long_tmp, 1955 args[0]); 1956 1957 long_tmp = stack[--stack_ptr]; 1958 1959 if ((status == 0) && (long_tmp != 0L)) 1960 status = altera_wait_msecs(astate, 1961 long_tmp, 1962 args[0]); 1963 1964 if ((status == 0) && (args[1] != args[0])) 1965 status = altera_goto_jstate(astate, 1966 args[1]); 1967 1968 if (version > 0) { 1969 --stack_ptr; /* throw away MAX cycles */ 1970 --stack_ptr; /* throw away MAX microseconds */ 1971 } 1972 break; 1973 case OP_CMPA: { 1974 /* 1975 * Array compare 1976 * ...argument 0 is source 1 ID 1977 * ...argument 1 is source 2 ID 1978 * ...argument 2 is mask ID 1979 * ...stack 0 is source 1 index 1980 * ...stack 1 is source 2 index 1981 * ...stack 2 is mask index 1982 * ...stack 3 is count 1983 */ 1984 s32 a, b; 1985 u8 *source1 = (u8 *)vars[args[0]]; 1986 u8 *source2 = (u8 *)vars[args[1]]; 1987 u8 *mask = (u8 *)vars[args[2]]; 1988 u32 index1; 1989 u32 index2; 1990 u32 mask_index; 1991 1992 if (!altera_check_stack(stack_ptr, 4, &status)) 1993 break; 1994 1995 index1 = stack[--stack_ptr]; 1996 index2 = stack[--stack_ptr]; 1997 mask_index = stack[--stack_ptr]; 1998 long_count = stack[--stack_ptr]; 1999 2000 if (version > 0) { 2001 /* 2002 * stack 0 = source 1 right index 2003 * stack 1 = source 1 left index 2004 * stack 2 = source 2 right index 2005 * stack 3 = source 2 left index 2006 * stack 4 = mask right index 2007 * stack 5 = mask left index 2008 */ 2009 s32 mask_right = stack[--stack_ptr]; 2010 s32 mask_left = stack[--stack_ptr]; 2011 /* source 1 count */ 2012 a = 1 + index2 - index1; 2013 /* source 2 count */ 2014 b = 1 + long_count - mask_index; 2015 a = (a < b) ? a : b; 2016 /* mask count */ 2017 b = 1 + mask_left - mask_right; 2018 a = (a < b) ? a : b; 2019 /* source 2 start index */ 2020 index2 = mask_index; 2021 /* mask start index */ 2022 mask_index = mask_right; 2023 long_count = a; 2024 } 2025 2026 long_tmp = 1L; 2027 2028 if (long_count < 1) 2029 status = -ERANGE; 2030 else { 2031 count = long_count; 2032 2033 for (i = 0; i < count; ++i) { 2034 if (mask[mask_index >> 3] & 2035 (1 << (mask_index & 7))) { 2036 a = source1[index1 >> 3] & 2037 (1 << (index1 & 7)) 2038 ? 1 : 0; 2039 b = source2[index2 >> 3] & 2040 (1 << (index2 & 7)) 2041 ? 1 : 0; 2042 2043 if (a != b) /* failure */ 2044 long_tmp = 0L; 2045 } 2046 ++index1; 2047 ++index2; 2048 ++mask_index; 2049 } 2050 } 2051 2052 stack[stack_ptr++] = long_tmp; 2053 2054 break; 2055 } 2056 default: 2057 /* Unrecognized opcode -- ERROR! */ 2058 bad_opcode = 1; 2059 break; 2060 } 2061 2062 if (bad_opcode) 2063 status = -ENOSYS; 2064 2065 if ((stack_ptr < 0) || (stack_ptr >= ALTERA_STACK_SIZE)) 2066 status = -EOVERFLOW; 2067 2068 if (status != 0) { 2069 done = 1; 2070 *error_address = (s32)(opcode_address - code_sect); 2071 } 2072 } 2073 2074 altera_free_buffers(astate); 2075 2076 /* Free all dynamically allocated arrays */ 2077 if ((attrs != NULL) && (vars != NULL)) 2078 for (i = 0; i < sym_count; ++i) 2079 if (attrs[i] & 0x80) 2080 kfree((void *)vars[i]); 2081 2082 kfree(vars); 2083 kfree(var_size); 2084 kfree(attrs); 2085 kfree(proc_attributes); 2086 2087 return status; 2088 } 2089 2090 static int altera_get_note(u8 *p, s32 program_size, s32 *offset, 2091 char *key, char *value, int keylen, int vallen) 2092 /* 2093 * Gets key and value of NOTE fields in the JBC file. 2094 * Can be called in two modes: if offset pointer is NULL, 2095 * then the function searches for note fields which match 2096 * the key string provided. If offset is not NULL, then 2097 * the function finds the next note field of any key, 2098 * starting at the offset specified by the offset pointer. 2099 * Returns 0 for success, else appropriate error code 2100 */ 2101 { 2102 int status = -ENODATA; 2103 u32 note_strings = 0L; 2104 u32 note_table = 0L; 2105 u32 note_count = 0L; 2106 u32 first_word = 0L; 2107 int version = 0; 2108 int delta = 0; 2109 char *key_ptr; 2110 char *value_ptr; 2111 int i; 2112 2113 /* Read header information */ 2114 if (program_size > 52L) { 2115 first_word = get_unaligned_be32(&p[0]); 2116 version = (first_word & 1L); 2117 delta = version * 8; 2118 2119 note_strings = get_unaligned_be32(&p[8 + delta]); 2120 note_table = get_unaligned_be32(&p[12 + delta]); 2121 note_count = get_unaligned_be32(&p[44 + (2 * delta)]); 2122 } 2123 2124 if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L)) 2125 return -EIO; 2126 2127 if (note_count <= 0L) 2128 return status; 2129 2130 if (offset == NULL) { 2131 /* 2132 * We will search for the first note with a specific key, 2133 * and return only the value 2134 */ 2135 for (i = 0; (i < note_count) && 2136 (status != 0); ++i) { 2137 key_ptr = &p[note_strings + 2138 get_unaligned_be32( 2139 &p[note_table + (8 * i)])]; 2140 if (key && !strncasecmp(key, key_ptr, strlen(key_ptr))) { 2141 status = 0; 2142 2143 value_ptr = &p[note_strings + 2144 get_unaligned_be32( 2145 &p[note_table + (8 * i) + 4])]; 2146 2147 if (value != NULL) 2148 strscpy(value, value_ptr, vallen); 2149 2150 } 2151 } 2152 } else { 2153 /* 2154 * We will search for the next note, regardless of the key, 2155 * and return both the value and the key 2156 */ 2157 2158 i = *offset; 2159 2160 if ((i >= 0) && (i < note_count)) { 2161 status = 0; 2162 2163 if (key != NULL) 2164 strscpy(key, &p[note_strings + 2165 get_unaligned_be32( 2166 &p[note_table + (8 * i)])], 2167 keylen); 2168 2169 if (value != NULL) 2170 strscpy(value, &p[note_strings + 2171 get_unaligned_be32( 2172 &p[note_table + (8 * i) + 4])], 2173 vallen); 2174 2175 *offset = i + 1; 2176 } 2177 } 2178 2179 return status; 2180 } 2181 2182 static int altera_check_crc(u8 *p, s32 program_size) 2183 { 2184 int status = 0; 2185 u16 local_expected = 0, 2186 local_actual = 0, 2187 shift_reg = 0xffff; 2188 int bit, feedback; 2189 u8 databyte; 2190 u32 i; 2191 u32 crc_section = 0L; 2192 u32 first_word = 0L; 2193 int version = 0; 2194 int delta = 0; 2195 2196 if (program_size > 52L) { 2197 first_word = get_unaligned_be32(&p[0]); 2198 version = (first_word & 1L); 2199 delta = version * 8; 2200 2201 crc_section = get_unaligned_be32(&p[32 + delta]); 2202 } 2203 2204 if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L)) 2205 status = -EIO; 2206 2207 if (crc_section >= program_size) 2208 status = -EIO; 2209 2210 if (status == 0) { 2211 local_expected = (u16)get_unaligned_be16(&p[crc_section]); 2212 2213 for (i = 0; i < crc_section; ++i) { 2214 databyte = p[i]; 2215 for (bit = 0; bit < 8; bit++) { 2216 feedback = (databyte ^ shift_reg) & 0x01; 2217 shift_reg >>= 1; 2218 if (feedback) 2219 shift_reg ^= 0x8408; 2220 2221 databyte >>= 1; 2222 } 2223 } 2224 2225 local_actual = (u16)~shift_reg; 2226 2227 if (local_expected != local_actual) 2228 status = -EILSEQ; 2229 2230 } 2231 2232 if (debug || status) { 2233 switch (status) { 2234 case 0: 2235 printk(KERN_INFO "%s: CRC matched: %04x\n", __func__, 2236 local_actual); 2237 break; 2238 case -EILSEQ: 2239 printk(KERN_ERR "%s: CRC mismatch: expected %04x, " 2240 "actual %04x\n", __func__, local_expected, 2241 local_actual); 2242 break; 2243 case -EIO: 2244 printk(KERN_ERR "%s: error: format isn't " 2245 "recognized.\n", __func__); 2246 break; 2247 default: 2248 printk(KERN_ERR "%s: CRC function returned error " 2249 "code %d\n", __func__, status); 2250 break; 2251 } 2252 } 2253 2254 return status; 2255 } 2256 2257 static int altera_get_file_info(u8 *p, 2258 s32 program_size, 2259 int *format_version, 2260 int *action_count, 2261 int *procedure_count) 2262 { 2263 int status = -EIO; 2264 u32 first_word = 0; 2265 int version = 0; 2266 2267 if (program_size <= 52L) 2268 return status; 2269 2270 first_word = get_unaligned_be32(&p[0]); 2271 2272 if ((first_word == 0x4A414D00L) || (first_word == 0x4A414D01L)) { 2273 status = 0; 2274 2275 version = (first_word & 1L); 2276 *format_version = version + 1; 2277 2278 if (version > 0) { 2279 *action_count = get_unaligned_be32(&p[48]); 2280 *procedure_count = get_unaligned_be32(&p[52]); 2281 } 2282 } 2283 2284 return status; 2285 } 2286 2287 static int altera_get_act_info(u8 *p, 2288 s32 program_size, 2289 int index, 2290 char **name, 2291 char **description, 2292 struct altera_procinfo **proc_list) 2293 { 2294 int status = -EIO; 2295 struct altera_procinfo *procptr = NULL; 2296 struct altera_procinfo *tmpptr = NULL; 2297 u32 first_word = 0L; 2298 u32 action_table = 0L; 2299 u32 proc_table = 0L; 2300 u32 str_table = 0L; 2301 u32 note_strings = 0L; 2302 u32 action_count = 0L; 2303 u32 proc_count = 0L; 2304 u32 act_name_id = 0L; 2305 u32 act_desc_id = 0L; 2306 u32 act_proc_id = 0L; 2307 u32 act_proc_name = 0L; 2308 u8 act_proc_attribute = 0; 2309 2310 if (program_size <= 52L) 2311 return status; 2312 /* Read header information */ 2313 first_word = get_unaligned_be32(&p[0]); 2314 2315 if (first_word != 0x4A414D01L) 2316 return status; 2317 2318 action_table = get_unaligned_be32(&p[4]); 2319 proc_table = get_unaligned_be32(&p[8]); 2320 str_table = get_unaligned_be32(&p[12]); 2321 note_strings = get_unaligned_be32(&p[16]); 2322 action_count = get_unaligned_be32(&p[48]); 2323 proc_count = get_unaligned_be32(&p[52]); 2324 2325 if (index >= action_count) 2326 return status; 2327 2328 act_name_id = get_unaligned_be32(&p[action_table + (12 * index)]); 2329 act_desc_id = get_unaligned_be32(&p[action_table + (12 * index) + 4]); 2330 act_proc_id = get_unaligned_be32(&p[action_table + (12 * index) + 8]); 2331 2332 *name = &p[str_table + act_name_id]; 2333 2334 if (act_desc_id < (note_strings - str_table)) 2335 *description = &p[str_table + act_desc_id]; 2336 2337 do { 2338 act_proc_name = get_unaligned_be32( 2339 &p[proc_table + (13 * act_proc_id)]); 2340 act_proc_attribute = 2341 (p[proc_table + (13 * act_proc_id) + 8] & 0x03); 2342 2343 procptr = 2344 kzalloc_obj(struct altera_procinfo); 2345 2346 if (procptr == NULL) 2347 status = -ENOMEM; 2348 else { 2349 procptr->name = &p[str_table + act_proc_name]; 2350 procptr->attrs = act_proc_attribute; 2351 procptr->next = NULL; 2352 2353 /* add record to end of linked list */ 2354 if (*proc_list == NULL) 2355 *proc_list = procptr; 2356 else { 2357 tmpptr = *proc_list; 2358 while (tmpptr->next != NULL) 2359 tmpptr = tmpptr->next; 2360 tmpptr->next = procptr; 2361 } 2362 } 2363 2364 act_proc_id = get_unaligned_be32( 2365 &p[proc_table + (13 * act_proc_id) + 4]); 2366 } while ((act_proc_id != 0) && (act_proc_id < proc_count)); 2367 2368 return status; 2369 } 2370 2371 int altera_init(struct altera_config *config, const struct firmware *fw) 2372 { 2373 struct altera_state *astate = NULL; 2374 struct altera_procinfo *proc_list = NULL; 2375 struct altera_procinfo *procptr = NULL; 2376 char *key = NULL; 2377 char *value = NULL; 2378 char *action_name = NULL; 2379 char *description = NULL; 2380 int exec_result = 0; 2381 int exit_code = 0; 2382 int format_version = 0; 2383 int action_count = 0; 2384 int procedure_count = 0; 2385 int index = 0; 2386 s32 offset = 0L; 2387 s32 error_address = 0L; 2388 int retval = 0; 2389 2390 key = kzalloc(33, GFP_KERNEL); 2391 if (!key) { 2392 retval = -ENOMEM; 2393 goto out; 2394 } 2395 value = kzalloc(257, GFP_KERNEL); 2396 if (!value) { 2397 retval = -ENOMEM; 2398 goto free_key; 2399 } 2400 astate = kzalloc_obj(struct altera_state); 2401 if (!astate) { 2402 retval = -ENOMEM; 2403 goto free_value; 2404 } 2405 2406 astate->config = config; 2407 if (!astate->config->jtag_io) { 2408 if (!IS_ENABLED(CONFIG_HAS_IOPORT)) { 2409 retval = -ENODEV; 2410 goto free_state; 2411 } 2412 dprintk("%s: using byteblaster!\n", __func__); 2413 astate->config->jtag_io = netup_jtag_io_lpt; 2414 } 2415 2416 altera_check_crc((u8 *)fw->data, fw->size); 2417 2418 if (debug) { 2419 altera_get_file_info((u8 *)fw->data, fw->size, &format_version, 2420 &action_count, &procedure_count); 2421 printk(KERN_INFO "%s: File format is %s ByteCode format\n", 2422 __func__, (format_version == 2) ? "Jam STAPL" : 2423 "pre-standardized Jam 1.1"); 2424 while (altera_get_note((u8 *)fw->data, fw->size, 2425 &offset, key, value, 32, 256) == 0) 2426 printk(KERN_INFO "%s: NOTE \"%s\" = \"%s\"\n", 2427 __func__, key, value); 2428 } 2429 2430 if (debug && (format_version == 2) && (action_count > 0)) { 2431 printk(KERN_INFO "%s: Actions available:\n", __func__); 2432 for (index = 0; index < action_count; ++index) { 2433 altera_get_act_info((u8 *)fw->data, fw->size, 2434 index, &action_name, 2435 &description, 2436 &proc_list); 2437 2438 if (description == NULL) 2439 printk(KERN_INFO "%s: %s\n", 2440 __func__, 2441 action_name); 2442 else 2443 printk(KERN_INFO "%s: %s \"%s\"\n", 2444 __func__, 2445 action_name, 2446 description); 2447 2448 procptr = proc_list; 2449 while (procptr != NULL) { 2450 if (procptr->attrs != 0) 2451 printk(KERN_INFO "%s: %s (%s)\n", 2452 __func__, 2453 procptr->name, 2454 (procptr->attrs == 1) ? 2455 "optional" : "recommended"); 2456 2457 proc_list = procptr->next; 2458 kfree(procptr); 2459 procptr = proc_list; 2460 } 2461 } 2462 2463 printk(KERN_INFO "\n"); 2464 } 2465 2466 exec_result = altera_execute(astate, (u8 *)fw->data, fw->size, 2467 &error_address, &exit_code, &format_version); 2468 2469 if (exit_code) 2470 exec_result = -EREMOTEIO; 2471 2472 if ((format_version == 2) && (exec_result == -EINVAL)) { 2473 if (astate->config->action == NULL) 2474 printk(KERN_ERR "%s: error: no action specified for " 2475 "Jam STAPL file.\nprogram terminated.\n", 2476 __func__); 2477 else 2478 printk(KERN_ERR "%s: error: action \"%s\"" 2479 " is not supported " 2480 "for this Jam STAPL file.\n" 2481 "Program terminated.\n", __func__, 2482 astate->config->action); 2483 2484 } else if (exec_result) 2485 printk(KERN_ERR "%s: error %d\n", __func__, exec_result); 2486 free_state: 2487 kfree(astate); 2488 free_value: 2489 kfree(value); 2490 free_key: 2491 kfree(key); 2492 out: 2493 return retval; 2494 } 2495 EXPORT_SYMBOL(altera_init); 2496