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