text: /*
   * altera.c
   *
   * altera FPGA driver
   *
   * Copyright (C) Altera Corporation 1998-2001
   * Copyright (C) 2010,2011 NetUP Inc.
   * Copyright (C) 2010,2011 Igor M. Liplianin <liplianin@netup.ru>
   *
   * This program is free software; you can redistribute it and/or modify
   * it under the terms of the GNU General Public License as published by
   * the Free Software Foundation; either version 2 of the License, or
   * (at your option) any later version.
   *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   *
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with this program; if not, write to the Free Software
   * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
   */
  
  #include <asm/unaligned.h>
  #include <linux/ctype.h>
  #include <linux/string.h>
  #include <linux/firmware.h>
  #include <linux/slab.h>
  #include <linux/module.h>
  #include <misc/altera.h>
  #include "altera-exprt.h"
  #include "altera-jtag.h"
  
  static int debug = 1;
  module_param(debug, int, 0644);
  MODULE_PARM_DESC(debug, "enable debugging information");
  
  MODULE_DESCRIPTION("altera FPGA kernel module");
  MODULE_AUTHOR("Igor M. Liplianin  <liplianin@netup.ru>");
  MODULE_LICENSE("GPL");
  
  #define dprintk(args...) \
  	if (debug) { \
  		printk(KERN_DEBUG args); \
  	}
  
  enum altera_fpga_opcode {
  	OP_NOP = 0,
  	OP_DUP,
  	OP_SWP,
  	OP_ADD,
  	OP_SUB,
  	OP_MULT,
  	OP_DIV,
  	OP_MOD,
  	OP_SHL,
  	OP_SHR,
  	OP_NOT,
  	OP_AND,
  	OP_OR,
  	OP_XOR,
  	OP_INV,
  	OP_GT,
  	OP_LT,
  	OP_RET,
  	OP_CMPS,
  	OP_PINT,
  	OP_PRNT,
  	OP_DSS,
  	OP_DSSC,
  	OP_ISS,
  	OP_ISSC,
  	OP_DPR = 0x1c,
  	OP_DPRL,
  	OP_DPO,
  	OP_DPOL,
  	OP_IPR,
  	OP_IPRL,
  	OP_IPO,
  	OP_IPOL,
  	OP_PCHR,
  	OP_EXIT,
  	OP_EQU,
  	OP_POPT,
  	OP_ABS = 0x2c,
  	OP_BCH0,
  	OP_PSH0 = 0x2f,
  	OP_PSHL = 0x40,
  	OP_PSHV,
  	OP_JMP,
  	OP_CALL,
  	OP_NEXT,
  	OP_PSTR,
  	OP_SINT = 0x47,
  	OP_ST,
  	OP_ISTP,
  	OP_DSTP,
  	OP_SWPN,
  	OP_DUPN,
  	OP_POPV,
  	OP_POPE,
  	OP_POPA,
  	OP_JMPZ,
  	OP_DS,
  	OP_IS,
  	OP_DPRA,
  	OP_DPOA,
  	OP_IPRA,
  	OP_IPOA,
  	OP_EXPT,
  	OP_PSHE,
  	OP_PSHA,
  	OP_DYNA,
  	OP_EXPV = 0x5c,
  	OP_COPY = 0x80,
  	OP_REVA,
  	OP_DSC,
  	OP_ISC,
  	OP_WAIT,
  	OP_VS,
  	OP_CMPA = 0xc0,
  	OP_VSC,
  };
  
  struct altera_procinfo {
  	char			*name;
  	u8			attrs;
  	struct altera_procinfo	*next;
  };
  
  /* This function checks if enough parameters are available on the stack. */
  static int altera_check_stack(int stack_ptr, int count, int *status)
  {
  	if (stack_ptr < count) {
  		*status = -EOVERFLOW;
  		return 0;
  	}
  
  	return 1;
  }
  
  static void altera_export_int(char *key, s32 value)
  {
  	dprintk("Export: key = \"%s\", value = %d\n", key, value);
  }
  
  #define HEX_LINE_CHARS 72
  #define HEX_LINE_BITS (HEX_LINE_CHARS * 4)
  
  static void altera_export_bool_array(char *key, u8 *data, s32 count)
  {
  	char string[HEX_LINE_CHARS + 1];
  	s32 i, offset;
  	u32 size, line, lines, linebits, value, j, k;
  
  	if (count > HEX_LINE_BITS) {
  		dprintk("Export: key = \"%s\", %d bits, value = HEX\n",
  							key, count);
  		lines = (count + (HEX_LINE_BITS - 1)) / HEX_LINE_BITS;
  
  		for (line = 0; line < lines; ++line) {
  			if (line < (lines - 1)) {
  				linebits = HEX_LINE_BITS;
  				size = HEX_LINE_CHARS;
  				offset = count - ((line + 1) * HEX_LINE_BITS);
  			} else {
  				linebits =
  					count - ((lines - 1) * HEX_LINE_BITS);
  				size = (linebits + 3) / 4;
  				offset = 0L;
  			}
  
  			string[size] = '\0';
  			j = size - 1;
  			value = 0;
  
  			for (k = 0; k < linebits; ++k) {
  				i = k + offset;
  				if (data[i >> 3] & (1 << (i & 7)))
  					value |= (1 << (i & 3));
  				if ((i & 3) == 3) {
  					sprintf(&string[j], "%1x", value);
  					value = 0;
  					--j;
  				}
  			}
  			if ((k & 3) > 0)
  				sprintf(&string[j], "%1x", value);
  
  			dprintk("%s\n", string);
  		}
  
  	} else {
  		size = (count + 3) / 4;
  		string[size] = '\0';
  		j = size - 1;
  		value = 0;
  
  		for (i = 0; i < count; ++i) {
  			if (data[i >> 3] & (1 << (i & 7)))
  				value |= (1 << (i & 3));
  			if ((i & 3) == 3) {
  				sprintf(&string[j], "%1x", value);
  				value = 0;
  				--j;
  			}
  		}
  		if ((i & 3) > 0)
  			sprintf(&string[j], "%1x", value);
  
  		dprintk("Export: key = \"%s\", %d bits, value = HEX %s\n",
  			key, count, string);
  	}
  }
  
  static int altera_execute(struct altera_state *astate,
  				u8 *p,
  				s32 program_size,
  				s32 *error_address,
  				int *exit_code,
  				int *format_version)
  {
  	struct altera_config *aconf = astate->config;
  	char *msg_buff = astate->msg_buff;
  	long *stack = astate->stack;
  	int status = 0;
  	u32 first_word = 0L;
  	u32 action_table = 0L;
  	u32 proc_table = 0L;
  	u32 str_table = 0L;
  	u32 sym_table = 0L;
  	u32 data_sect = 0L;
  	u32 code_sect = 0L;
  	u32 debug_sect = 0L;
  	u32 action_count = 0L;
  	u32 proc_count = 0L;
  	u32 sym_count = 0L;
  	long *vars = NULL;
  	s32 *var_size = NULL;
  	char *attrs = NULL;
  	u8 *proc_attributes = NULL;
  	u32 pc;
  	u32 opcode_address;
  	u32 args[3];
  	u32 opcode;
  	u32 name_id;
  	u8 charbuf[4];
  	long long_tmp;
  	u32 variable_id;
  	u8 *charptr_tmp;
  	u8 *charptr_tmp2;
  	long *longptr_tmp;
  	int version = 0;
  	int delta = 0;
  	int stack_ptr = 0;
  	u32 arg_count;
  	int done = 0;
  	int bad_opcode = 0;
  	u32 count;
  	u32 index;
  	u32 index2;
  	s32 long_count;
  	s32 long_idx;
  	s32 long_idx2;
  	u32 i;
  	u32 j;
  	u32 uncomp_size;
  	u32 offset;
  	u32 value;
  	int current_proc = 0;
  	int reverse;
  
  	char *name;
  
  	dprintk("%s\n", __func__);
  
  	/* Read header information */
  	if (program_size > 52L) {
  		first_word    = get_unaligned_be32(&p[0]);
  		version = (first_word & 1L);
  		*format_version = version + 1;
  		delta = version * 8;
  
  		action_table  = get_unaligned_be32(&p[4]);
  		proc_table    = get_unaligned_be32(&p[8]);
  		str_table  = get_unaligned_be32(&p[4 + delta]);
  		sym_table  = get_unaligned_be32(&p[16 + delta]);
  		data_sect  = get_unaligned_be32(&p[20 + delta]);
  		code_sect  = get_unaligned_be32(&p[24 + delta]);
  		debug_sect = get_unaligned_be32(&p[28 + delta]);
  		action_count  = get_unaligned_be32(&p[40 + delta]);
  		proc_count    = get_unaligned_be32(&p[44 + delta]);
  		sym_count  = get_unaligned_be32(&p[48 + (2 * delta)]);
  	}
  
  	if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L)) {
  		done = 1;
  		status = -EIO;
  		goto exit_done;
  	}
  
  	if (sym_count <= 0)
  		goto exit_done;
  
  	vars = kzalloc(sym_count * sizeof(long), GFP_KERNEL);
  
  	if (vars == NULL)
  		status = -ENOMEM;
  
  	if (status == 0) {
  		var_size = kzalloc(sym_count * sizeof(s32), GFP_KERNEL);
  
  		if (var_size == NULL)
  			status = -ENOMEM;
  	}
  
  	if (status == 0) {
  		attrs = kzalloc(sym_count, GFP_KERNEL);
  
  		if (attrs == NULL)
  			status = -ENOMEM;
  	}
  
  	if ((status == 0) && (version > 0)) {
  		proc_attributes = kzalloc(proc_count, GFP_KERNEL);
  
  		if (proc_attributes == NULL)
  			status = -ENOMEM;
  	}
  
  	if (status != 0)
  		goto exit_done;
  
  	delta = version * 2;
  
  	for (i = 0; i < sym_count; ++i) {
  		offset = (sym_table + ((11 + delta) * i));
  
  		value = get_unaligned_be32(&p[offset + 3 + delta]);
  
  		attrs[i] = p[offset];
  
  		/*
  		 * use bit 7 of attribute byte to indicate that
  		 * this buffer was dynamically allocated
  		 * and should be freed later
  		 */
  		attrs[i] &= 0x7f;
  
  		var_size[i] = get_unaligned_be32(&p[offset + 7 + delta]);
  
  		/*
  		 * Attribute bits:
  		 * bit 0: 0 = read-only, 1 = read-write
  		 * bit 1: 0 = not compressed, 1 = compressed
  		 * bit 2: 0 = not initialized, 1 = initialized
  		 * bit 3: 0 = scalar, 1 = array
  		 * bit 4: 0 = Boolean, 1 = integer
  		 * bit 5: 0 = declared variable,
  		 *	1 = compiler created temporary variable
  		 */
  
  		if ((attrs[i] & 0x0c) == 0x04)
  			/* initialized scalar variable */
  			vars[i] = value;
  		else if ((attrs[i] & 0x1e) == 0x0e) {
  			/* initialized compressed Boolean array */
  			uncomp_size = get_unaligned_le32(&p[data_sect + value]);
  
  			/* allocate a buffer for the uncompressed data */
  			vars[i] = (long)kzalloc(uncomp_size, GFP_KERNEL);
  			if (vars[i] == 0L)
  				status = -ENOMEM;
  			else {
  				/* set flag so buffer will be freed later */
  				attrs[i] |= 0x80;
  
  				/* uncompress the data */
  				if (altera_shrink(&p[data_sect + value],
  						var_size[i],
  						(u8 *)vars[i],
  						uncomp_size,
  						version) != uncomp_size)
  					/* decompression failed */
  					status = -EIO;
  				else
  					var_size[i] = uncomp_size * 8L;
  
  			}
  		} else if ((attrs[i] & 0x1e) == 0x0c) {
  			/* initialized Boolean array */
  			vars[i] = value + data_sect + (long)p;
  		} else if ((attrs[i] & 0x1c) == 0x1c) {
  			/* initialized integer array */
  			vars[i] = value + data_sect;
  		} else if ((attrs[i] & 0x0c) == 0x08) {
  			/* uninitialized array */
  
  			/* flag attrs so that memory is freed */
  			attrs[i] |= 0x80;
  
  			if (var_size[i] > 0) {
  				u32 size;
  
  				if (attrs[i] & 0x10)
  					/* integer array */
  					size = (var_size[i] * sizeof(s32));
  				else
  					/* Boolean array */
  					size = ((var_size[i] + 7L) / 8L);
  
  				vars[i] = (long)kzalloc(size, GFP_KERNEL);
  
  				if (vars[i] == 0) {
  					status = -ENOMEM;
  				} else {
  					/* zero out memory */
  					for (j = 0; j < size; ++j)
  						((u8 *)(vars[i]))[j] = 0;
  
  				}
  			} else
  				vars[i] = 0;
  
  		} else
  			vars[i] = 0;
  
  	}
  
  exit_done:
  	if (status != 0)
  		done = 1;
  
  	altera_jinit(astate);
  
  	pc = code_sect;
  	msg_buff[0] = '\0';
  
  	/*
  	 * For JBC version 2, we will execute the procedures corresponding to
  	 * the selected ACTION
  	 */
  	if (version > 0) {
  		if (aconf->action == NULL) {
  			status = -EINVAL;
  			done = 1;
  		} else {
  			int action_found = 0;
  			for (i = 0; (i < action_count) && !action_found; ++i) {
  				name_id = get_unaligned_be32(&p[action_table +
  								(12 * i)]);
  
  				name = &p[str_table + name_id];
  
  				if (strncasecmp(aconf->action, name, strlen(name)) == 0) {
  					action_found = 1;
  					current_proc =
  						get_unaligned_be32(&p[action_table +
  								(12 * i) + 8]);
  				}
  			}
  
  			if (!action_found) {
  				status = -EINVAL;
  				done = 1;
  			}
  		}
  
  		if (status == 0) {
  			int first_time = 1;
  			i = current_proc;
  			while ((i != 0) || first_time) {
  				first_time = 0;
  				/* check procedure attribute byte */
  				proc_attributes[i] =
  						(p[proc_table +
  								(13 * i) + 8] &
  									0x03);
  
  				/*
  				 * BIT0 - OPTIONAL
  				 * BIT1 - RECOMMENDED
  				 * BIT6 - FORCED OFF
  				 * BIT7 - FORCED ON
  				 */
  
  				i = get_unaligned_be32(&p[proc_table +
  							(13 * i) + 4]);
  			}
  
  			/*
  			 * Set current_proc to the first procedure
  			 * to be executed
  			 */
  			i = current_proc;
  			while ((i != 0) &&
  				((proc_attributes[i] == 1) ||
  				((proc_attributes[i] & 0xc0) == 0x40))) {
  				i = get_unaligned_be32(&p[proc_table +
  							(13 * i) + 4]);
  			}
  
  			if ((i != 0) || ((i == 0) && (current_proc == 0) &&
  				((proc_attributes[0] != 1) &&
  				((proc_attributes[0] & 0xc0) != 0x40)))) {
  				current_proc = i;
  				pc = code_sect +
  					get_unaligned_be32(&p[proc_table +
  								(13 * i) + 9]);
  				if ((pc < code_sect) || (pc >= debug_sect))
  					status = -ERANGE;
  			} else
  				/* there are no procedures to execute! */
  				done = 1;
  
  		}
  	}
  
  	msg_buff[0] = '\0';
  
  	while (!done) {
  		opcode = (p[pc] & 0xff);
  		opcode_address = pc;
  		++pc;
  
  		if (debug > 1)
  			printk("opcode: %02x\n", opcode);
  
  		arg_count = (opcode >> 6) & 3;
  		for (i = 0; i < arg_count; ++i) {
  			args[i] = get_unaligned_be32(&p[pc]);
  			pc += 4;
  		}
  
  		switch (opcode) {
  		case OP_NOP:
  			break;
  		case OP_DUP:
  			if (altera_check_stack(stack_ptr, 1, &status)) {
  				stack[stack_ptr] = stack[stack_ptr - 1];
  				++stack_ptr;
  			}
  			break;
  		case OP_SWP:
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				long_tmp = stack[stack_ptr - 2];
  				stack[stack_ptr - 2] = stack[stack_ptr - 1];
  				stack[stack_ptr - 1] = long_tmp;
  			}
  			break;
  		case OP_ADD:
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				--stack_ptr;
  				stack[stack_ptr - 1] += stack[stack_ptr];
  			}
  			break;
  		case OP_SUB:
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				--stack_ptr;
  				stack[stack_ptr - 1] -= stack[stack_ptr];
  			}
  			break;
  		case OP_MULT:
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				--stack_ptr;
  				stack[stack_ptr - 1] *= stack[stack_ptr];
  			}
  			break;
  		case OP_DIV:
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				--stack_ptr;
  				stack[stack_ptr - 1] /= stack[stack_ptr];
  			}
  			break;
  		case OP_MOD:
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				--stack_ptr;
  				stack[stack_ptr - 1] %= stack[stack_ptr];
  			}
  			break;
  		case OP_SHL:
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				--stack_ptr;
  				stack[stack_ptr - 1] <<= stack[stack_ptr];
  			}
  			break;
  		case OP_SHR:
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				--stack_ptr;
  				stack[stack_ptr - 1] >>= stack[stack_ptr];
  			}
  			break;
  		case OP_NOT:
  			if (altera_check_stack(stack_ptr, 1, &status))
  				stack[stack_ptr - 1] ^= (-1L);
  
  			break;
  		case OP_AND:
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				--stack_ptr;
  				stack[stack_ptr - 1] &= stack[stack_ptr];
  			}
  			break;
  		case OP_OR:
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				--stack_ptr;
  				stack[stack_ptr - 1] |= stack[stack_ptr];
  			}
  			break;
  		case OP_XOR:
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				--stack_ptr;
  				stack[stack_ptr - 1] ^= stack[stack_ptr];
  			}
  			break;
  		case OP_INV:
  			if (!altera_check_stack(stack_ptr, 1, &status))
  				break;
  			stack[stack_ptr - 1] = stack[stack_ptr - 1] ? 0L : 1L;
  			break;
  		case OP_GT:
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			--stack_ptr;
  			stack[stack_ptr - 1] =
  				(stack[stack_ptr - 1] > stack[stack_ptr]) ?
  									1L : 0L;
  
  			break;
  		case OP_LT:
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			--stack_ptr;
  			stack[stack_ptr - 1] =
  				(stack[stack_ptr - 1] < stack[stack_ptr]) ?
  									1L : 0L;
  
  			break;
  		case OP_RET:
  			if ((version > 0) && (stack_ptr == 0)) {
  				/*
  				 * We completed one of the main procedures
  				 * of an ACTION.
  				 * Find the next procedure
  				 * to be executed and jump to it.
  				 * If there are no more procedures, then EXIT.
  				 */
  				i = get_unaligned_be32(&p[proc_table +
  						(13 * current_proc) + 4]);
  				while ((i != 0) &&
  					((proc_attributes[i] == 1) ||
  					((proc_attributes[i] & 0xc0) == 0x40)))
  					i = get_unaligned_be32(&p[proc_table +
  								(13 * i) + 4]);
  
  				if (i == 0) {
  					/* no procedures to execute! */
  					done = 1;
  					*exit_code = 0;	/* success */
  				} else {
  					current_proc = i;
  					pc = code_sect + get_unaligned_be32(
  								&p[proc_table +
  								(13 * i) + 9]);
  					if ((pc < code_sect) ||
  					    (pc >= debug_sect))
  						status = -ERANGE;
  				}
  
  			} else
  				if (altera_check_stack(stack_ptr, 1, &status)) {
  					pc = stack[--stack_ptr] + code_sect;
  					if ((pc <= code_sect) ||
  					    (pc >= debug_sect))
  						status = -ERANGE;
  
  				}
  
  			break;
  		case OP_CMPS:
  			/*
  			 * Array short compare
  			 * ...stack 0 is source 1 value
  			 * ...stack 1 is source 2 value
  			 * ...stack 2 is mask value
  			 * ...stack 3 is count
  			 */
  			if (altera_check_stack(stack_ptr, 4, &status)) {
  				s32 a = stack[--stack_ptr];
  				s32 b = stack[--stack_ptr];
  				long_tmp = stack[--stack_ptr];
  				count = stack[stack_ptr - 1];
  
  				if ((count < 1) || (count > 32))
  					status = -ERANGE;
  				else {
  					long_tmp &= ((-1L) >> (32 - count));
  
  					stack[stack_ptr - 1] =
  					((a & long_tmp) == (b & long_tmp))
  								? 1L : 0L;
  				}
  			}
  			break;
  		case OP_PINT:
  			/*
  			 * PRINT add integer
  			 * ...stack 0 is integer value
  			 */
  			if (!altera_check_stack(stack_ptr, 1, &status))
  				break;
  			sprintf(&msg_buff[strlen(msg_buff)],
  					"%ld", stack[--stack_ptr]);
  			break;
  		case OP_PRNT:
  			/* PRINT finish */
  			if (debug)
  				printk(msg_buff, "\n");
  
  			msg_buff[0] = '\0';
  			break;
  		case OP_DSS:
  			/*
  			 * DRSCAN short
  			 * ...stack 0 is scan data
  			 * ...stack 1 is count
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			long_tmp = stack[--stack_ptr];
  			count = stack[--stack_ptr];
  			put_unaligned_le32(long_tmp, &charbuf[0]);
  			status = altera_drscan(astate, count, charbuf, 0);
  			break;
  		case OP_DSSC:
  			/*
  			 * DRSCAN short with capture
  			 * ...stack 0 is scan data
  			 * ...stack 1 is count
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			long_tmp = stack[--stack_ptr];
  			count = stack[stack_ptr - 1];
  			put_unaligned_le32(long_tmp, &charbuf[0]);
  			status = altera_swap_dr(astate, count, charbuf,
  							0, charbuf, 0);
  			stack[stack_ptr - 1] = get_unaligned_le32(&charbuf[0]);
  			break;
  		case OP_ISS:
  			/*
  			 * IRSCAN short
  			 * ...stack 0 is scan data
  			 * ...stack 1 is count
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			long_tmp = stack[--stack_ptr];
  			count = stack[--stack_ptr];
  			put_unaligned_le32(long_tmp, &charbuf[0]);
  			status = altera_irscan(astate, count, charbuf, 0);
  			break;
  		case OP_ISSC:
  			/*
  			 * IRSCAN short with capture
  			 * ...stack 0 is scan data
  			 * ...stack 1 is count
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			long_tmp = stack[--stack_ptr];
  			count = stack[stack_ptr - 1];
  			put_unaligned_le32(long_tmp, &charbuf[0]);
  			status = altera_swap_ir(astate, count, charbuf,
  							0, charbuf, 0);
  			stack[stack_ptr - 1] = get_unaligned_le32(&charbuf[0]);
  			break;
  		case OP_DPR:
  			if (!altera_check_stack(stack_ptr, 1, &status))
  				break;
  			count = stack[--stack_ptr];
  			status = altera_set_dr_pre(&astate->js, count, 0, NULL);
  			break;
  		case OP_DPRL:
  			/*
  			 * DRPRE with literal data
  			 * ...stack 0 is count
  			 * ...stack 1 is literal data
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			count = stack[--stack_ptr];
  			long_tmp = stack[--stack_ptr];
  			put_unaligned_le32(long_tmp, &charbuf[0]);
  			status = altera_set_dr_pre(&astate->js, count, 0,
  						charbuf);
  			break;
  		case OP_DPO:
  			/*
  			 * DRPOST
  			 * ...stack 0 is count
  			 */
  			if (altera_check_stack(stack_ptr, 1, &status)) {
  				count = stack[--stack_ptr];
  				status = altera_set_dr_post(&astate->js, count,
  								0, NULL);
  			}
  			break;
  		case OP_DPOL:
  			/*
  			 * DRPOST with literal data
  			 * ...stack 0 is count
  			 * ...stack 1 is literal data
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			count = stack[--stack_ptr];
  			long_tmp = stack[--stack_ptr];
  			put_unaligned_le32(long_tmp, &charbuf[0]);
  			status = altera_set_dr_post(&astate->js, count, 0,
  							charbuf);
  			break;
  		case OP_IPR:
  			if (altera_check_stack(stack_ptr, 1, &status)) {
  				count = stack[--stack_ptr];
  				status = altera_set_ir_pre(&astate->js, count,
  								0, NULL);
  			}
  			break;
  		case OP_IPRL:
  			/*
  			 * IRPRE with literal data
  			 * ...stack 0 is count
  			 * ...stack 1 is literal data
  			 */
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				count = stack[--stack_ptr];
  				long_tmp = stack[--stack_ptr];
  				put_unaligned_le32(long_tmp, &charbuf[0]);
  				status = altera_set_ir_pre(&astate->js, count,
  							0, charbuf);
  			}
  			break;
  		case OP_IPO:
  			/*
  			 * IRPOST
  			 * ...stack 0 is count
  			 */
  			if (altera_check_stack(stack_ptr, 1, &status)) {
  				count = stack[--stack_ptr];
  				status = altera_set_ir_post(&astate->js, count,
  							0, NULL);
  			}
  			break;
  		case OP_IPOL:
  			/*
  			 * IRPOST with literal data
  			 * ...stack 0 is count
  			 * ...stack 1 is literal data
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			count = stack[--stack_ptr];
  			long_tmp = stack[--stack_ptr];
  			put_unaligned_le32(long_tmp, &charbuf[0]);
  			status = altera_set_ir_post(&astate->js, count, 0,
  							charbuf);
  			break;
  		case OP_PCHR:
  			if (altera_check_stack(stack_ptr, 1, &status)) {
  				u8 ch;
  				count = strlen(msg_buff);
  				ch = (char) stack[--stack_ptr];
  				if ((ch < 1) || (ch > 127)) {
  					/*
  					 * character code out of range
  					 * instead of flagging an error,
  					 * force the value to 127
  					 */
  					ch = 127;
  				}
  				msg_buff[count] = ch;
  				msg_buff[count + 1] = '\0';
  			}
  			break;
  		case OP_EXIT:
  			if (altera_check_stack(stack_ptr, 1, &status))
  				*exit_code = stack[--stack_ptr];
  
  			done = 1;
  			break;
  		case OP_EQU:
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			--stack_ptr;
  			stack[stack_ptr - 1] =
  				(stack[stack_ptr - 1] == stack[stack_ptr]) ?
  									1L : 0L;
  			break;
  		case OP_POPT:
  			if (altera_check_stack(stack_ptr, 1, &status))
  				--stack_ptr;
  
  			break;
  		case OP_ABS:
  			if (!altera_check_stack(stack_ptr, 1, &status))
  				break;
  			if (stack[stack_ptr - 1] < 0)
  				stack[stack_ptr - 1] = 0 - stack[stack_ptr - 1];
  
  			break;
  		case OP_BCH0:
  			/*
  			 * Batch operation 0
  			 * SWP
  			 * SWPN 7
  			 * SWP
  			 * SWPN 6
  			 * DUPN 8
  			 * SWPN 2
  			 * SWP
  			 * DUPN 6
  			 * DUPN 6
  			 */
  
  			/* SWP  */
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				long_tmp = stack[stack_ptr - 2];
  				stack[stack_ptr - 2] = stack[stack_ptr - 1];
  				stack[stack_ptr - 1] = long_tmp;
  			}
  
  			/* SWPN 7 */
  			index = 7 + 1;
  			if (altera_check_stack(stack_ptr, index, &status)) {
  				long_tmp = stack[stack_ptr - index];
  				stack[stack_ptr - index] = stack[stack_ptr - 1];
  				stack[stack_ptr - 1] = long_tmp;
  			}
  
  			/* SWP  */
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				long_tmp = stack[stack_ptr - 2];
  				stack[stack_ptr - 2] = stack[stack_ptr - 1];
  				stack[stack_ptr - 1] = long_tmp;
  			}
  
  			/* SWPN 6 */
  			index = 6 + 1;
  			if (altera_check_stack(stack_ptr, index, &status)) {
  				long_tmp = stack[stack_ptr - index];
  				stack[stack_ptr - index] = stack[stack_ptr - 1];
  				stack[stack_ptr - 1] = long_tmp;
  			}
  
  			/* DUPN 8 */
  			index = 8 + 1;
  			if (altera_check_stack(stack_ptr, index, &status)) {
  				stack[stack_ptr] = stack[stack_ptr - index];
  				++stack_ptr;
  			}
  
  			/* SWPN 2 */
  			index = 2 + 1;
  			if (altera_check_stack(stack_ptr, index, &status)) {
  				long_tmp = stack[stack_ptr - index];
  				stack[stack_ptr - index] = stack[stack_ptr - 1];
  				stack[stack_ptr - 1] = long_tmp;
  			}
  
  			/* SWP  */
  			if (altera_check_stack(stack_ptr, 2, &status)) {
  				long_tmp = stack[stack_ptr - 2];
  				stack[stack_ptr - 2] = stack[stack_ptr - 1];
  				stack[stack_ptr - 1] = long_tmp;
  			}
  
  			/* DUPN 6 */
  			index = 6 + 1;
  			if (altera_check_stack(stack_ptr, index, &status)) {
  				stack[stack_ptr] = stack[stack_ptr - index];
  				++stack_ptr;
  			}
  
  			/* DUPN 6 */
  			index = 6 + 1;
  			if (altera_check_stack(stack_ptr, index, &status)) {
  				stack[stack_ptr] = stack[stack_ptr - index];
  				++stack_ptr;
  			}
  			break;
  		case OP_PSH0:
  			stack[stack_ptr++] = 0;
  			break;
  		case OP_PSHL:
  			stack[stack_ptr++] = (s32) args[0];
  			break;
  		case OP_PSHV:
  			stack[stack_ptr++] = vars[args[0]];
  			break;
  		case OP_JMP:
  			pc = args[0] + code_sect;
  			if ((pc < code_sect) || (pc >= debug_sect))
  				status = -ERANGE;
  			break;
  		case OP_CALL:
  			stack[stack_ptr++] = pc;
  			pc = args[0] + code_sect;
  			if ((pc < code_sect) || (pc >= debug_sect))
  				status = -ERANGE;
  			break;
  		case OP_NEXT:
  			/*
  			 * Process FOR / NEXT loop
  			 * ...argument 0 is variable ID
  			 * ...stack 0 is step value
  			 * ...stack 1 is end value
  			 * ...stack 2 is top address
  			 */
  			if (altera_check_stack(stack_ptr, 3, &status)) {
  				s32 step = stack[stack_ptr - 1];
  				s32 end = stack[stack_ptr - 2];
  				s32 top = stack[stack_ptr - 3];
  				s32 iterator = vars[args[0]];
  				int break_out = 0;
  
  				if (step < 0) {
  					if (iterator <= end)
  						break_out = 1;
  				} else if (iterator >= end)
  					break_out = 1;
  
  				if (break_out) {
  					stack_ptr -= 3;
  				} else {
  					vars[args[0]] = iterator + step;
  					pc = top + code_sect;
  					if ((pc < code_sect) ||
  					    (pc >= debug_sect))
  						status = -ERANGE;
  				}
  			}
  			break;
  		case OP_PSTR:
  			/*
  			 * PRINT add string
  			 * ...argument 0 is string ID
  			 */
  			count = strlen(msg_buff);
  			strlcpy(&msg_buff[count],
  				&p[str_table + args[0]],
  				ALTERA_MESSAGE_LENGTH - count);
  			break;
  		case OP_SINT:
  			/*
  			 * STATE intermediate state
  			 * ...argument 0 is state code
  			 */
  			status = altera_goto_jstate(astate, args[0]);
  			break;
  		case OP_ST:
  			/*
  			 * STATE final state
  			 * ...argument 0 is state code
  			 */
  			status = altera_goto_jstate(astate, args[0]);
  			break;
  		case OP_ISTP:
  			/*
  			 * IRSTOP state
  			 * ...argument 0 is state code
  			 */
  			status = altera_set_irstop(&astate->js, args[0]);
  			break;
  		case OP_DSTP:
  			/*
  			 * DRSTOP state
  			 * ...argument 0 is state code
  			 */
  			status = altera_set_drstop(&astate->js, args[0]);
  			break;
  
  		case OP_SWPN:
  			/*
  			 * Exchange top with Nth stack value
  			 * ...argument 0 is 0-based stack entry
  			 * to swap with top element
  			 */
  			index = (args[0]) + 1;
  			if (altera_check_stack(stack_ptr, index, &status)) {
  				long_tmp = stack[stack_ptr - index];
  				stack[stack_ptr - index] = stack[stack_ptr - 1];
  				stack[stack_ptr - 1] = long_tmp;
  			}
  			break;
  		case OP_DUPN:
  			/*
  			 * Duplicate Nth stack value
  			 * ...argument 0 is 0-based stack entry to duplicate
  			 */
  			index = (args[0]) + 1;
  			if (altera_check_stack(stack_ptr, index, &status)) {
  				stack[stack_ptr] = stack[stack_ptr - index];
  				++stack_ptr;
  			}
  			break;
  		case OP_POPV:
  			/*
  			 * Pop stack into scalar variable
  			 * ...argument 0 is variable ID
  			 * ...stack 0 is value
  			 */
  			if (altera_check_stack(stack_ptr, 1, &status))
  				vars[args[0]] = stack[--stack_ptr];
  
  			break;
  		case OP_POPE:
  			/*
  			 * Pop stack into integer array element
  			 * ...argument 0 is variable ID
  			 * ...stack 0 is array index
  			 * ...stack 1 is value
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			variable_id = args[0];
  
  			/*
  			 * If variable is read-only,
  			 * convert to writable array
  			 */
  			if ((version > 0) &&
  				((attrs[variable_id] & 0x9c) == 0x1c)) {
  				/* Allocate a writable buffer for this array */
  				count = var_size[variable_id];
  				long_tmp = vars[variable_id];
  				longptr_tmp = kzalloc(count * sizeof(long),
  								GFP_KERNEL);
  				vars[variable_id] = (long)longptr_tmp;
  
  				if (vars[variable_id] == 0) {
  					status = -ENOMEM;
  					break;
  				}
  
  				/* copy previous contents into buffer */
  				for (i = 0; i < count; ++i) {
  					longptr_tmp[i] =
  						get_unaligned_be32(&p[long_tmp]);
  					long_tmp += sizeof(long);
  				}
  
  				/*
  				 * set bit 7 - buffer was
  				 * dynamically allocated
  				 */
  				attrs[variable_id] |= 0x80;
  
  				/* clear bit 2 - variable is writable */
  				attrs[variable_id] &= ~0x04;
  				attrs[variable_id] |= 0x01;
  
  			}
  
  			/* check that variable is a writable integer array */
  			if ((attrs[variable_id] & 0x1c) != 0x18)
  				status = -ERANGE;
  			else {
  				longptr_tmp = (long *)vars[variable_id];
  
  				/* pop the array index */
  				index = stack[--stack_ptr];
  
  				/* pop the value and store it into the array */
  				longptr_tmp[index] = stack[--stack_ptr];
  			}
  
  			break;
  		case OP_POPA:
  			/*
  			 * Pop stack into Boolean array
  			 * ...argument 0 is variable ID
  			 * ...stack 0 is count
  			 * ...stack 1 is array index
  			 * ...stack 2 is value
  			 */
  			if (!altera_check_stack(stack_ptr, 3, &status))
  				break;
  			variable_id = args[0];
  
  			/*
  			 * If variable is read-only,
  			 * convert to writable array
  			 */
  			if ((version > 0) &&
  				((attrs[variable_id] & 0x9c) == 0x0c)) {
  				/* Allocate a writable buffer for this array */
  				long_tmp =
  					(var_size[variable_id] + 7L) >> 3L;
  				charptr_tmp2 = (u8 *)vars[variable_id];
  				charptr_tmp =
  					kzalloc(long_tmp, GFP_KERNEL);
  				vars[variable_id] = (long)charptr_tmp;
  
  				if (vars[variable_id] == 0) {
  					status = -ENOMEM;
  					break;
  				}
  
  				/* zero the buffer */
  				for (long_idx = 0L;
  					long_idx < long_tmp;
  					++long_idx) {
  					charptr_tmp[long_idx] = 0;
  				}
  
  				/* copy previous contents into buffer */
  				for (long_idx = 0L;
  					long_idx < var_size[variable_id];
  					++long_idx) {
  					long_idx2 = long_idx;
  
  					if (charptr_tmp2[long_idx2 >> 3] &
  						(1 << (long_idx2 & 7))) {
  						charptr_tmp[long_idx >> 3] |=
  							(1 << (long_idx & 7));
  					}
  				}
  
  				/*
  				 * set bit 7 - buffer was
  				 * dynamically allocated
  				 */
  				attrs[variable_id] |= 0x80;
  
  				/* clear bit 2 - variable is writable */
  				attrs[variable_id] &= ~0x04;
  				attrs[variable_id] |= 0x01;
  
  			}
  
  			/*
  			 * check that variable is
  			 * a writable Boolean array
  			 */
  			if ((attrs[variable_id] & 0x1c) != 0x08) {
  				status = -ERANGE;
  				break;
  			}
  
  			charptr_tmp = (u8 *)vars[variable_id];
  
  			/* pop the count (number of bits to copy) */
  			long_count = stack[--stack_ptr];
  
  			/* pop the array index */
  			long_idx = stack[--stack_ptr];
  
  			reverse = 0;
  
  			if (version > 0) {
  				/*
  				 * stack 0 = array right index
  				 * stack 1 = array left index
  				 */
  
  				if (long_idx > long_count) {
  					reverse = 1;
  					long_tmp = long_count;
  					long_count = 1 + long_idx -
  								long_count;
  					long_idx = long_tmp;
  
  					/* reverse POPA is not supported */
  					status = -ERANGE;
  					break;
  				} else
  					long_count = 1 + long_count -
  								long_idx;
  
  			}
  
  			/* pop the data */
  			long_tmp = stack[--stack_ptr];
  
  			if (long_count < 1) {
  				status = -ERANGE;
  				break;
  			}
  
  			for (i = 0; i < long_count; ++i) {
  				if (long_tmp & (1L << (s32) i))
  					charptr_tmp[long_idx >> 3L] |=
  						(1L << (long_idx & 7L));
  				else
  					charptr_tmp[long_idx >> 3L] &=
  						~(1L << (long_idx & 7L));
  
  				++long_idx;
  			}
  
  			break;
  		case OP_JMPZ:
  			/*
  			 * Pop stack and branch if zero
  			 * ...argument 0 is address
  			 * ...stack 0 is condition value
  			 */
  			if (altera_check_stack(stack_ptr, 1, &status)) {
  				if (stack[--stack_ptr] == 0) {
  					pc = args[0] + code_sect;
  					if ((pc < code_sect) ||
  					    (pc >= debug_sect))
  						status = -ERANGE;
  				}
  			}
  			break;
  		case OP_DS:
  		case OP_IS:
  			/*
  			 * DRSCAN
  			 * IRSCAN
  			 * ...argument 0 is scan data variable ID
  			 * ...stack 0 is array index
  			 * ...stack 1 is count
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			long_idx = stack[--stack_ptr];
  			long_count = stack[--stack_ptr];
  			reverse = 0;
  			if (version > 0) {
  				/*
  				 * stack 0 = array right index
  				 * stack 1 = array left index
  				 * stack 2 = count
  				 */
  				long_tmp = long_count;
  				long_count = stack[--stack_ptr];
  
  				if (long_idx > long_tmp) {
  					reverse = 1;
  					long_idx = long_tmp;
  				}
  			}
  
  			charptr_tmp = (u8 *)vars[args[0]];
  
  			if (reverse) {
  				/*
  				 * allocate a buffer
  				 * and reverse the data order
  				 */
  				charptr_tmp2 = charptr_tmp;
  				charptr_tmp = kzalloc((long_count >> 3) + 1,
  								GFP_KERNEL);
  				if (charptr_tmp == NULL) {
  					status = -ENOMEM;
  					break;
  				}
  
  				long_tmp = long_idx + long_count - 1;
  				long_idx2 = 0;
  				while (long_idx2 < long_count) {
  					if (charptr_tmp2[long_tmp >> 3] &
  							(1 << (long_tmp & 7)))
  						charptr_tmp[long_idx2 >> 3] |=
  							(1 << (long_idx2 & 7));
  					else
  						charptr_tmp[long_idx2 >> 3] &=
  							~(1 << (long_idx2 & 7));
  
  					--long_tmp;
  					++long_idx2;
  				}
  			}
  
  			if (opcode == 0x51) /* DS */
  				status = altera_drscan(astate, long_count,
  						charptr_tmp, long_idx);
  			else /* IS */
  				status = altera_irscan(astate, long_count,
  						charptr_tmp, long_idx);
  
  			if (reverse)
  				kfree(charptr_tmp);
  
  			break;
  		case OP_DPRA:
  			/*
  			 * DRPRE with array data
  			 * ...argument 0 is variable ID
  			 * ...stack 0 is array index
  			 * ...stack 1 is count
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			index = stack[--stack_ptr];
  			count = stack[--stack_ptr];
  
  			if (version > 0)
  				/*
  				 * stack 0 = array right index
  				 * stack 1 = array left index
  				 */
  				count = 1 + count - index;
  
  			charptr_tmp = (u8 *)vars[args[0]];
  			status = altera_set_dr_pre(&astate->js, count, index,
  							charptr_tmp);
  			break;
  		case OP_DPOA:
  			/*
  			 * DRPOST with array data
  			 * ...argument 0 is variable ID
  			 * ...stack 0 is array index
  			 * ...stack 1 is count
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			index = stack[--stack_ptr];
  			count = stack[--stack_ptr];
  
  			if (version > 0)
  				/*
  				 * stack 0 = array right index
  				 * stack 1 = array left index
  				 */
  				count = 1 + count - index;
  
  			charptr_tmp = (u8 *)vars[args[0]];
  			status = altera_set_dr_post(&astate->js, count, index,
  							charptr_tmp);
  			break;
  		case OP_IPRA:
  			/*
  			 * IRPRE with array data
  			 * ...argument 0 is variable ID
  			 * ...stack 0 is array index
  			 * ...stack 1 is count
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			index = stack[--stack_ptr];
  			count = stack[--stack_ptr];
  
  			if (version > 0)
  				/*
  				 * stack 0 = array right index
  				 * stack 1 = array left index
  				 */
  				count = 1 + count - index;
  
  			charptr_tmp = (u8 *)vars[args[0]];
  			status = altera_set_ir_pre(&astate->js, count, index,
  							charptr_tmp);
  
  			break;
  		case OP_IPOA:
  			/*
  			 * IRPOST with array data
  			 * ...argument 0 is variable ID
  			 * ...stack 0 is array index
  			 * ...stack 1 is count
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			index = stack[--stack_ptr];
  			count = stack[--stack_ptr];
  
  			if (version > 0)
  				/*
  				 * stack 0 = array right index
  				 * stack 1 = array left index
  				 */
  				count = 1 + count - index;
  
  			charptr_tmp = (u8 *)vars[args[0]];
  			status = altera_set_ir_post(&astate->js, count, index,
  							charptr_tmp);
  
  			break;
  		case OP_EXPT:
  			/*
  			 * EXPORT
  			 * ...argument 0 is string ID
  			 * ...stack 0 is integer expression
  			 */
  			if (altera_check_stack(stack_ptr, 1, &status)) {
  				name = &p[str_table + args[0]];
  				long_tmp = stack[--stack_ptr];
  				altera_export_int(name, long_tmp);
  			}
  			break;
  		case OP_PSHE:
  			/*
  			 * Push integer array element
  			 * ...argument 0 is variable ID
  			 * ...stack 0 is array index
  			 */
  			if (!altera_check_stack(stack_ptr, 1, &status))
  				break;
  			variable_id = args[0];
  			index = stack[stack_ptr - 1];
  
  			/* check variable type */
  			if ((attrs[variable_id] & 0x1f) == 0x19) {
  				/* writable integer array */
  				longptr_tmp = (long *)vars[variable_id];
  				stack[stack_ptr - 1] = longptr_tmp[index];
  			} else if ((attrs[variable_id] & 0x1f) == 0x1c) {
  				/* read-only integer array */
  				long_tmp = vars[variable_id] +
  						(index * sizeof(long));
  				stack[stack_ptr - 1] =
  					get_unaligned_be32(&p[long_tmp]);
  			} else
  				status = -ERANGE;
  
  			break;
  		case OP_PSHA:
  			/*
  			 * Push Boolean array
  			 * ...argument 0 is variable ID
  			 * ...stack 0 is count
  			 * ...stack 1 is array index
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			variable_id = args[0];
  
  			/* check that variable is a Boolean array */
  			if ((attrs[variable_id] & 0x18) != 0x08) {
  				status = -ERANGE;
  				break;
  			}
  
  			charptr_tmp = (u8 *)vars[variable_id];
  
  			/* pop the count (number of bits to copy) */
  			count = stack[--stack_ptr];
  
  			/* pop the array index */
  			index = stack[stack_ptr - 1];
  
  			if (version > 0)
  				/*
  				 * stack 0 = array right index
  				 * stack 1 = array left index
  				 */
  				count = 1 + count - index;
  
  			if ((count < 1) || (count > 32)) {
  				status = -ERANGE;
  				break;
  			}
  
  			long_tmp = 0L;
  
  			for (i = 0; i < count; ++i)
  				if (charptr_tmp[(i + index) >> 3] &
  						(1 << ((i + index) & 7)))
  					long_tmp |= (1L << i);
  
  			stack[stack_ptr - 1] = long_tmp;
  
  			break;
  		case OP_DYNA:
  			/*
  			 * Dynamically change size of array
  			 * ...argument 0 is variable ID
  			 * ...stack 0 is new size
  			 */
  			if (!altera_check_stack(stack_ptr, 1, &status))
  				break;
  			variable_id = args[0];
  			long_tmp = stack[--stack_ptr];
  
  			if (long_tmp > var_size[variable_id]) {
  				var_size[variable_id] = long_tmp;
  
  				if (attrs[variable_id] & 0x10)
  					/* allocate integer array */
  					long_tmp *= sizeof(long);
  				else
  					/* allocate Boolean array */
  					long_tmp = (long_tmp + 7) >> 3;
  
  				/*
  				 * If the buffer was previously allocated,
  				 * free it
  				 */
  				if (attrs[variable_id] & 0x80) {
  					kfree((void *)vars[variable_id]);
  					vars[variable_id] = 0;
  				}
  
  				/*
  				 * Allocate a new buffer
  				 * of the requested size
  				 */
  				vars[variable_id] = (long)
  					kzalloc(long_tmp, GFP_KERNEL);
  
  				if (vars[variable_id] == 0) {
  					status = -ENOMEM;
  					break;
  				}
  
  				/*
  				 * Set the attribute bit to indicate that
  				 * this buffer was dynamically allocated and
  				 * should be freed later
  				 */
  				attrs[variable_id] |= 0x80;
  
  				/* zero out memory */
  				count = ((var_size[variable_id] + 7L) /
  									8L);
  				charptr_tmp = (u8 *)(vars[variable_id]);
  				for (index = 0; index < count; ++index)
  					charptr_tmp[index] = 0;
  
  			}
  
  			break;
  		case OP_EXPV:
  			/*
  			 * Export Boolean array
  			 * ...argument 0 is string ID
  			 * ...stack 0 is variable ID
  			 * ...stack 1 is array right index
  			 * ...stack 2 is array left index
  			 */
  			if (!altera_check_stack(stack_ptr, 3, &status))
  				break;
  			if (version == 0) {
  				/* EXPV is not supported in JBC 1.0 */
  				bad_opcode = 1;
  				break;
  			}
  			name = &p[str_table + args[0]];
  			variable_id = stack[--stack_ptr];
  			long_idx = stack[--stack_ptr];/* right indx */
  			long_idx2 = stack[--stack_ptr];/* left indx */
  
  			if (long_idx > long_idx2) {
  				/* reverse indices not supported */
  				status = -ERANGE;
  				break;
  			}
  
  			long_count = 1 + long_idx2 - long_idx;
  
  			charptr_tmp = (u8 *)vars[variable_id];
  			charptr_tmp2 = NULL;
  
  			if ((long_idx & 7L) != 0) {
  				s32 k = long_idx;
  				charptr_tmp2 =
  					kzalloc(((long_count + 7L) / 8L),
  							GFP_KERNEL);
  				if (charptr_tmp2 == NULL) {
  					status = -ENOMEM;
  					break;
  				}
  
  				for (i = 0; i < long_count; ++i) {
  					if (charptr_tmp[k >> 3] &
  							(1 << (k & 7)))
  						charptr_tmp2[i >> 3] |=
  								(1 << (i & 7));
  					else
  						charptr_tmp2[i >> 3] &=
  								~(1 << (i & 7));
  
  					++k;
  				}
  				charptr_tmp = charptr_tmp2;
  
  			} else if (long_idx != 0)
  				charptr_tmp = &charptr_tmp[long_idx >> 3];
  
  			altera_export_bool_array(name, charptr_tmp,
  							long_count);
  
  			/* free allocated buffer */
  			if ((long_idx & 7L) != 0)
  				kfree(charptr_tmp2);
  
  			break;
  		case OP_COPY: {
  			/*
  			 * Array copy
  			 * ...argument 0 is dest ID
  			 * ...argument 1 is source ID
  			 * ...stack 0 is count
  			 * ...stack 1 is dest index
  			 * ...stack 2 is source index
  			 */
  			s32 copy_count;
  			s32 copy_index;
  			s32 copy_index2;
  			s32 destleft;
  			s32 src_count;
  			s32 dest_count;
  			int src_reverse = 0;
  			int dest_reverse = 0;
  
  			if (!altera_check_stack(stack_ptr, 3, &status))
  				break;
  
  			copy_count = stack[--stack_ptr];
  			copy_index = stack[--stack_ptr];
  			copy_index2 = stack[--stack_ptr];
  			reverse = 0;
  
  			if (version > 0) {
  				/*
  				 * stack 0 = source right index
  				 * stack 1 = source left index
  				 * stack 2 = destination right index
  				 * stack 3 = destination left index
  				 */
  				destleft = stack[--stack_ptr];
  
  				if (copy_count > copy_index) {
  					src_reverse = 1;
  					reverse = 1;
  					src_count = 1 + copy_count - copy_index;
  					/* copy_index = source start index */
  				} else {
  					src_count = 1 + copy_index - copy_count;
  					/* source start index */
  					copy_index = copy_count;
  				}
  
  				if (copy_index2 > destleft) {
  					dest_reverse = 1;
  					reverse = !reverse;
  					dest_count = 1 + copy_index2 - destleft;
  					/* destination start index */
  					copy_index2 = destleft;
  				} else
  					dest_count = 1 + destleft - copy_index2;
  
  				copy_count = (src_count < dest_count) ?
  							src_count : dest_count;
  
  				if ((src_reverse || dest_reverse) &&
  					(src_count != dest_count))
  					/*
  					 * If either the source or destination
  					 * is reversed, we can't tolerate
  					 * a length mismatch, because we
  					 * "left justify" arrays when copying.
  					 * This won't work correctly
  					 * with reversed arrays.
  					 */
  					status = -ERANGE;
  
  			}
  
  			count = copy_count;
  			index = copy_index;
  			index2 = copy_index2;
  
  			/*
  			 * If destination is a read-only array,
  			 * allocate a buffer and convert it to a writable array
  			 */
  			variable_id = args[1];
  			if ((version > 0) &&
  				((attrs[variable_id] & 0x9c) == 0x0c)) {
  				/* Allocate a writable buffer for this array */
  				long_tmp =
  					(var_size[variable_id] + 7L) >> 3L;
  				charptr_tmp2 = (u8 *)vars[variable_id];
  				charptr_tmp =
  					kzalloc(long_tmp, GFP_KERNEL);
  				vars[variable_id] = (long)charptr_tmp;
  
  				if (vars[variable_id] == 0) {
  					status = -ENOMEM;
  					break;
  				}
  
  				/* zero the buffer */
  				for (long_idx = 0L; long_idx < long_tmp;
  								++long_idx)
  					charptr_tmp[long_idx] = 0;
  
  				/* copy previous contents into buffer */
  				for (long_idx = 0L;
  					long_idx < var_size[variable_id];
  								++long_idx) {
  					long_idx2 = long_idx;
  
  					if (charptr_tmp2[long_idx2 >> 3] &
  						(1 << (long_idx2 & 7)))
  						charptr_tmp[long_idx >> 3] |=
  							(1 << (long_idx & 7));
  
  				}
  
  				/*
  				set bit 7 - buffer was dynamically allocated */
  				attrs[variable_id] |= 0x80;
  
  				/* clear bit 2 - variable is writable */
  				attrs[variable_id] &= ~0x04;
  				attrs[variable_id] |= 0x01;
  			}
  
  			charptr_tmp = (u8 *)vars[args[1]];
  			charptr_tmp2 = (u8 *)vars[args[0]];
  
  			/* check if destination is a writable Boolean array */
  			if ((attrs[args[1]] & 0x1c) != 0x08) {
  				status = -ERANGE;
  				break;
  			}
  
  			if (count < 1) {
  				status = -ERANGE;
  				break;
  			}
  
  			if (reverse)
  				index2 += (count - 1);
  
  			for (i = 0; i < count; ++i) {
  				if (charptr_tmp2[index >> 3] &
  							(1 << (index & 7)))
  					charptr_tmp[index2 >> 3] |=
  							(1 << (index2 & 7));
  				else
  					charptr_tmp[index2 >> 3] &=
  						~(1 << (index2 & 7));
  
  				++index;
  				if (reverse)
  					--index2;
  				else
  					++index2;
  			}
  
  			break;
  		}
  		case OP_DSC:
  		case OP_ISC: {
  			/*
  			 * DRSCAN with capture
  			 * IRSCAN with capture
  			 * ...argument 0 is scan data variable ID
  			 * ...argument 1 is capture variable ID
  			 * ...stack 0 is capture index
  			 * ...stack 1 is scan data index
  			 * ...stack 2 is count
  			 */
  			s32 scan_right, scan_left;
  			s32 capture_count = 0;
  			s32 scan_count = 0;
  			s32 capture_index;
  			s32 scan_index;
  
  			if (!altera_check_stack(stack_ptr, 3, &status))
  				break;
  
  			capture_index = stack[--stack_ptr];
  			scan_index = stack[--stack_ptr];
  
  			if (version > 0) {
  				/*
  				 * stack 0 = capture right index
  				 * stack 1 = capture left index
  				 * stack 2 = scan right index
  				 * stack 3 = scan left index
  				 * stack 4 = count
  				 */
  				scan_right = stack[--stack_ptr];
  				scan_left = stack[--stack_ptr];
  				capture_count = 1 + scan_index - capture_index;
  				scan_count = 1 + scan_left - scan_right;
  				scan_index = scan_right;
  			}
  
  			long_count = stack[--stack_ptr];
  			/*
  			 * If capture array is read-only, allocate a buffer
  			 * and convert it to a writable array
  			 */
  			variable_id = args[1];
  			if ((version > 0) &&
  				((attrs[variable_id] & 0x9c) == 0x0c)) {
  				/* Allocate a writable buffer for this array */
  				long_tmp =
  					(var_size[variable_id] + 7L) >> 3L;
  				charptr_tmp2 = (u8 *)vars[variable_id];
  				charptr_tmp =
  					kzalloc(long_tmp, GFP_KERNEL);
  				vars[variable_id] = (long)charptr_tmp;
  
  				if (vars[variable_id] == 0) {
  					status = -ENOMEM;
  					break;
  				}
  
  				/* zero the buffer */
  				for (long_idx = 0L; long_idx < long_tmp;
  								++long_idx)
  					charptr_tmp[long_idx] = 0;
  
  				/* copy previous contents into buffer */
  				for (long_idx = 0L;
  					long_idx < var_size[variable_id];
  								++long_idx) {
  					long_idx2 = long_idx;
  
  					if (charptr_tmp2[long_idx2 >> 3] &
  						(1 << (long_idx2 & 7)))
  						charptr_tmp[long_idx >> 3] |=
  							(1 << (long_idx & 7));
  
  				}
  
  				/*
  				 * set bit 7 - buffer was
  				 * dynamically allocated
  				 */
  				attrs[variable_id] |= 0x80;
  
  				/* clear bit 2 - variable is writable */
  				attrs[variable_id] &= ~0x04;
  				attrs[variable_id] |= 0x01;
  
  			}
  
  			charptr_tmp = (u8 *)vars[args[0]];
  			charptr_tmp2 = (u8 *)vars[args[1]];
  
  			if ((version > 0) &&
  					((long_count > capture_count) ||
  					(long_count > scan_count))) {
  				status = -ERANGE;
  				break;
  			}
  
  			/*
  			 * check that capture array
  			 * is a writable Boolean array
  			 */
  			if ((attrs[args[1]] & 0x1c) != 0x08) {
  				status = -ERANGE;
  				break;
  			}
  
  			if (status == 0) {
  				if (opcode == 0x82) /* DSC */
  					status = altera_swap_dr(astate,
  							long_count,
  							charptr_tmp,
  							scan_index,
  							charptr_tmp2,
  							capture_index);
  				else /* ISC */
  					status = altera_swap_ir(astate,
  							long_count,
  							charptr_tmp,
  							scan_index,
  							charptr_tmp2,
  							capture_index);
  
  			}
  
  			break;
  		}
  		case OP_WAIT:
  			/*
  			 * WAIT
  			 * ...argument 0 is wait state
  			 * ...argument 1 is end state
  			 * ...stack 0 is cycles
  			 * ...stack 1 is microseconds
  			 */
  			if (!altera_check_stack(stack_ptr, 2, &status))
  				break;
  			long_tmp = stack[--stack_ptr];
  
  			if (long_tmp != 0L)
  				status = altera_wait_cycles(astate, long_tmp,
  								args[0]);
  
  			long_tmp = stack[--stack_ptr];
  
  			if ((status == 0) && (long_tmp != 0L))
  				status = altera_wait_msecs(astate,
  								long_tmp,
  								args[0]);
  
  			if ((status == 0) && (args[1] != args[0]))
  				status = altera_goto_jstate(astate,
  								args[1]);
  
  			if (version > 0) {
  				--stack_ptr; /* throw away MAX cycles */
  				--stack_ptr; /* throw away MAX microseconds */
  			}
  			break;
  		case OP_CMPA: {
  			/*
  			 * Array compare
  			 * ...argument 0 is source 1 ID
  			 * ...argument 1 is source 2 ID
  			 * ...argument 2 is mask ID
  			 * ...stack 0 is source 1 index
  			 * ...stack 1 is source 2 index
  			 * ...stack 2 is mask index
  			 * ...stack 3 is count
  			 */
  			s32 a, b;
  			u8 *source1 = (u8 *)vars[args[0]];
  			u8 *source2 = (u8 *)vars[args[1]];
  			u8 *mask = (u8 *)vars[args[2]];
  			u32 index1;
  			u32 index2;
  			u32 mask_index;
  
  			if (!altera_check_stack(stack_ptr, 4, &status))
  				break;
  
  			index1 = stack[--stack_ptr];
  			index2 = stack[--stack_ptr];
  			mask_index = stack[--stack_ptr];
  			long_count = stack[--stack_ptr];
  
  			if (version > 0) {
  				/*
  				 * stack 0 = source 1 right index
  				 * stack 1 = source 1 left index
  				 * stack 2 = source 2 right index
  				 * stack 3 = source 2 left index
  				 * stack 4 = mask right index
  				 * stack 5 = mask left index
  				 */
  				s32 mask_right = stack[--stack_ptr];
  				s32 mask_left = stack[--stack_ptr];
  				/* source 1 count */
  				a = 1 + index2 - index1;
  				/* source 2 count */
  				b = 1 + long_count - mask_index;
  				a = (a < b) ? a : b;
  				/* mask count */
  				b = 1 + mask_left - mask_right;
  				a = (a < b) ? a : b;
  				/* source 2 start index */
  				index2 = mask_index;
  				/* mask start index */
  				mask_index = mask_right;
  				long_count = a;
  			}
  
  			long_tmp = 1L;
  
  			if (long_count < 1)
  				status = -ERANGE;
  			else {
  				count = long_count;
  
  				for (i = 0; i < count; ++i) {
  					if (mask[mask_index >> 3] &
  						(1 << (mask_index & 7))) {
  						a = source1[index1 >> 3] &
  							(1 << (index1 & 7))
  								? 1 : 0;
  						b = source2[index2 >> 3] &
  							(1 << (index2 & 7))
  								? 1 : 0;
  
  						if (a != b) /* failure */
  							long_tmp = 0L;
  					}
  					++index1;
  					++index2;
  					++mask_index;
  				}
  			}
  
  			stack[stack_ptr++] = long_tmp;
  
  			break;
  		}
  		default:
  			/* Unrecognized opcode -- ERROR! */
  			bad_opcode = 1;
  			break;
  		}
  
  		if (bad_opcode)
  			status = -ENOSYS;
  
  		if ((stack_ptr < 0) || (stack_ptr >= ALTERA_STACK_SIZE))
  			status = -EOVERFLOW;
  
  		if (status != 0) {
  			done = 1;
  			*error_address = (s32)(opcode_address - code_sect);
  		}
  	}
  
  	altera_free_buffers(astate);
  
  	/* Free all dynamically allocated arrays */
  	if ((attrs != NULL) && (vars != NULL))
  		for (i = 0; i < sym_count; ++i)
  			if (attrs[i] & 0x80)
  				kfree((void *)vars[i]);
  
  	kfree(vars);
  	kfree(var_size);
  	kfree(attrs);
  	kfree(proc_attributes);
  
  	return status;
  }
  
  static int altera_get_note(u8 *p, s32 program_size, s32 *offset,
  			   char *key, char *value, int keylen, int vallen)
  /*
   * Gets key and value of NOTE fields in the JBC file.
   * Can be called in two modes:  if offset pointer is NULL,
   * then the function searches for note fields which match
   * the key string provided.  If offset is not NULL, then
   * the function finds the next note field of any key,
   * starting at the offset specified by the offset pointer.
   * Returns 0 for success, else appropriate error code
   */
  {
  	int status = -ENODATA;
  	u32 note_strings = 0L;
  	u32 note_table = 0L;
  	u32 note_count = 0L;
  	u32 first_word = 0L;
  	int version = 0;
  	int delta = 0;
  	char *key_ptr;
  	char *value_ptr;
  	int i;
  
  	/* Read header information */
  	if (program_size > 52L) {
  		first_word    = get_unaligned_be32(&p[0]);
  		version = (first_word & 1L);
  		delta = version * 8;
  
  		note_strings  = get_unaligned_be32(&p[8 + delta]);
  		note_table    = get_unaligned_be32(&p[12 + delta]);
  		note_count    = get_unaligned_be32(&p[44 + (2 * delta)]);
  	}
  
  	if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L))
  		return -EIO;
  
  	if (note_count <= 0L)
  		return status;
  
  	if (offset == NULL) {
  		/*
  		 * We will search for the first note with a specific key,
  		 * and return only the value
  		 */
  		for (i = 0; (i < note_count) &&
  						(status != 0); ++i) {
  			key_ptr = &p[note_strings +
  					get_unaligned_be32(
  					&p[note_table + (8 * i)])];
  			if (key && !strncasecmp(key, key_ptr, strlen(key_ptr))) {
  				status = 0;
  
  				value_ptr = &p[note_strings +
  						get_unaligned_be32(
  						&p[note_table + (8 * i) + 4])];
  
  				if (value != NULL)
  					strlcpy(value, value_ptr, vallen);
  
  			}
  		}
  	} else {
  		/*
  		 * We will search for the next note, regardless of the key,
  		 * and return both the value and the key
  		 */
  
  		i = *offset;
  
  		if ((i >= 0) && (i < note_count)) {
  			status = 0;
  
  			if (key != NULL)
  				strlcpy(key, &p[note_strings +
  						get_unaligned_be32(
  						&p[note_table + (8 * i)])],
  					keylen);
  
  			if (value != NULL)
  				strlcpy(value, &p[note_strings +
  						get_unaligned_be32(
  						&p[note_table + (8 * i) + 4])],
  					vallen);
  
  			*offset = i + 1;
  		}
  	}
  
  	return status;
  }
  
  static int altera_check_crc(u8 *p, s32 program_size)
  {
  	int status = 0;
  	u16 local_expected = 0,
  	    local_actual = 0,
  	    shift_reg = 0xffff;
  	int bit, feedback;
  	u8 databyte;
  	u32 i;
  	u32 crc_section = 0L;
  	u32 first_word = 0L;
  	int version = 0;
  	int delta = 0;
  
  	if (program_size > 52L) {
  		first_word  = get_unaligned_be32(&p[0]);
  		version = (first_word & 1L);
  		delta = version * 8;
  
  		crc_section = get_unaligned_be32(&p[32 + delta]);
  	}
  
  	if ((first_word != 0x4A414D00L) && (first_word != 0x4A414D01L))
  		status = -EIO;
  
  	if (crc_section >= program_size)
  		status = -EIO;
  
  	if (status == 0) {
  		local_expected = (u16)get_unaligned_be16(&p[crc_section]);
  
  		for (i = 0; i < crc_section; ++i) {
  			databyte = p[i];
  			for (bit = 0; bit < 8; bit++) {
  				feedback = (databyte ^ shift_reg) & 0x01;
  				shift_reg >>= 1;
  				if (feedback)
  					shift_reg ^= 0x8408;
  
  				databyte >>= 1;
  			}
  		}
  
  		local_actual = (u16)~shift_reg;
  
  		if (local_expected != local_actual)
  			status = -EILSEQ;
  
  	}
  
  	if (debug || status) {
  		switch (status) {
  		case 0:
  			printk(KERN_INFO "%s: CRC matched: %04x\n", __func__,
  				local_actual);
  			break;
  		case -EILSEQ:
  			printk(KERN_ERR "%s: CRC mismatch: expected %04x, "
  				"actual %04x\n", __func__, local_expected,
  				local_actual);
  			break;
  		case -ENODATA:
  			printk(KERN_ERR "%s: expected CRC not found, "
  				"actual CRC = %04x\n", __func__,
  				local_actual);
  			break;
  		case -EIO:
  			printk(KERN_ERR "%s: error: format isn't "
  				"recognized.\n", __func__);
  			break;
  		default:
  			printk(KERN_ERR "%s: CRC function returned error "
  				"code %d\n", __func__, status);
  			break;
  		}
  	}
  
  	return status;
  }
  
  static int altera_get_file_info(u8 *p,
  					s32 program_size,
  					int *format_version,
  					int *action_count,
  					int *procedure_count)
  {
  	int status = -EIO;
  	u32 first_word = 0;
  	int version = 0;
  
  	if (program_size <= 52L)
  		return status;
  
  	first_word = get_unaligned_be32(&p[0]);
  
  	if ((first_word == 0x4A414D00L) || (first_word == 0x4A414D01L)) {
  		status = 0;
  
  		version = (first_word & 1L);
  		*format_version = version + 1;
  
  		if (version > 0) {
  			*action_count = get_unaligned_be32(&p[48]);
  			*procedure_count = get_unaligned_be32(&p[52]);
  		}
  	}
  
  	return status;
  }
  
  static int altera_get_act_info(u8 *p,
  					s32 program_size,
  					int index,
  					char **name,
  					char **description,
  					struct altera_procinfo **proc_list)
  {
  	int status = -EIO;
  	struct altera_procinfo *procptr = NULL;
  	struct altera_procinfo *tmpptr = NULL;
  	u32 first_word = 0L;
  	u32 action_table = 0L;
  	u32 proc_table = 0L;
  	u32 str_table = 0L;
  	u32 note_strings = 0L;
  	u32 action_count = 0L;
  	u32 proc_count = 0L;
  	u32 act_name_id = 0L;
  	u32 act_desc_id = 0L;
  	u32 act_proc_id = 0L;
  	u32 act_proc_name = 0L;
  	u8 act_proc_attribute = 0;
  
  	if (program_size <= 52L)
  		return status;
  	/* Read header information */
  	first_word = get_unaligned_be32(&p[0]);
  
  	if (first_word != 0x4A414D01L)
  		return status;
  
  	action_table = get_unaligned_be32(&p[4]);
  	proc_table   = get_unaligned_be32(&p[8]);
  	str_table = get_unaligned_be32(&p[12]);
  	note_strings = get_unaligned_be32(&p[16]);
  	action_count = get_unaligned_be32(&p[48]);
  	proc_count   = get_unaligned_be32(&p[52]);
  
  	if (index >= action_count)
  		return status;
  
  	act_name_id = get_unaligned_be32(&p[action_table + (12 * index)]);
  	act_desc_id = get_unaligned_be32(&p[action_table + (12 * index) + 4]);
  	act_proc_id = get_unaligned_be32(&p[action_table + (12 * index) + 8]);
  
  	*name = &p[str_table + act_name_id];
  
  	if (act_desc_id < (note_strings - str_table))
  		*description = &p[str_table + act_desc_id];
  
  	do {
  		act_proc_name = get_unaligned_be32(
  					&p[proc_table + (13 * act_proc_id)]);
  		act_proc_attribute =
  			(p[proc_table + (13 * act_proc_id) + 8] & 0x03);
  
  		procptr =
  				kzalloc(sizeof(struct altera_procinfo),
  								GFP_KERNEL);
  
  		if (procptr == NULL)
  			status = -ENOMEM;
  		else {
  			procptr->name = &p[str_table + act_proc_name];
  			procptr->attrs = act_proc_attribute;
  			procptr->next = NULL;
  
  			/* add record to end of linked list */
  			if (*proc_list == NULL)
  				*proc_list = procptr;
  			else {
  				tmpptr = *proc_list;
  				while (tmpptr->next != NULL)
  					tmpptr = tmpptr->next;
  				tmpptr->next = procptr;
  			}
  		}
  
  		act_proc_id = get_unaligned_be32(
  				&p[proc_table + (13 * act_proc_id) + 4]);
  	} while ((act_proc_id != 0) && (act_proc_id < proc_count));
  
  	return status;
  }
  
  int altera_init(struct altera_config *config, const struct firmware *fw)
  {
  	struct altera_state *astate = NULL;
  	struct altera_procinfo *proc_list = NULL;
  	struct altera_procinfo *procptr = NULL;
  	char *key = NULL;
  	char *value = NULL;
  	char *action_name = NULL;
  	char *description = NULL;
  	int exec_result = 0;
  	int exit_code = 0;
  	int format_version = 0;
  	int action_count = 0;
  	int procedure_count = 0;
  	int index = 0;
  	s32 offset = 0L;
  	s32 error_address = 0L;
  	int retval = 0;
  
  	key = kzalloc(33, GFP_KERNEL);
  	if (!key) {
  		retval = -ENOMEM;
  		goto out;
  	}
  	value = kzalloc(257, GFP_KERNEL);
  	if (!value) {
  		retval = -ENOMEM;
  		goto free_key;
  	}
  	astate = kzalloc(sizeof(struct altera_state), GFP_KERNEL);
  	if (!astate) {
  		retval = -ENOMEM;
  		goto free_value;
  	}
  
  	astate->config = config;
  	if (!astate->config->jtag_io) {
  		dprintk("%s: using byteblaster!\n", __func__);
  		astate->config->jtag_io = netup_jtag_io_lpt;
  	}
  
  	altera_check_crc((u8 *)fw->data, fw->size);
  
  	if (debug) {
  		altera_get_file_info((u8 *)fw->data, fw->size, &format_version,
  					&action_count, &procedure_count);
  		printk(KERN_INFO "%s: File format is %s ByteCode format\n",
  			__func__, (format_version == 2) ? "Jam STAPL" :
  						"pre-standardized Jam 1.1");
  		while (altera_get_note((u8 *)fw->data, fw->size,
  					&offset, key, value, 32, 256) == 0)
  			printk(KERN_INFO "%s: NOTE \"%s\" = \"%s\"\n",
  					__func__, key, value);
  	}
  
  	if (debug && (format_version == 2) && (action_count > 0)) {
  		printk(KERN_INFO "%s: Actions available:\n", __func__);
  		for (index = 0; index < action_count; ++index) {
  			altera_get_act_info((u8 *)fw->data, fw->size,
  						index, &action_name,
  						&description,
  						&proc_list);
  
  			if (description == NULL)
  				printk(KERN_INFO "%s: %s\n",
  						__func__,
  						action_name);
  			else
  				printk(KERN_INFO "%s: %s \"%s\"\n",
  						__func__,
  						action_name,
  						description);
  
  			procptr = proc_list;
  			while (procptr != NULL) {
  				if (procptr->attrs != 0)
  					printk(KERN_INFO "%s:    %s (%s)\n",
  						__func__,
  						procptr->name,
  						(procptr->attrs == 1) ?
  						"optional" : "recommended");
  
  				proc_list = procptr->next;
  				kfree(procptr);
  				procptr = proc_list;
  			}
  		}
  
  		printk(KERN_INFO "\n");
  	}
  
  	exec_result = altera_execute(astate, (u8 *)fw->data, fw->size,
  				&error_address, &exit_code, &format_version);
  
  	if (exit_code)
  		exec_result = -EREMOTEIO;
  
  	if ((format_version == 2) && (exec_result == -EINVAL)) {
  		if (astate->config->action == NULL)
  			printk(KERN_ERR "%s: error: no action specified for "
  				"Jam STAPL file.\nprogram terminated.\n",
  				__func__);
  		else
  			printk(KERN_ERR "%s: error: action \"%s\""
  				" is not supported "
  				"for this Jam STAPL file.\n"
  				"Program terminated.\n", __func__,
  				astate->config->action);
  
  	} else if (exec_result)
  		printk(KERN_ERR "%s: error %d\n", __func__, exec_result);
  
  	kfree(astate);
  free_value:
  	kfree(value);
  free_key:
  	kfree(key);
  out:
  	return retval;
  }
  EXPORT_SYMBOL(altera_init);
  