Re: [GIT PATCHES FOR 2.6.37] Support for NetUP Dual DVB-T/C CI RF card V.2

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Ð ÑÐÐÐÑÐÐÐÐ ÐÑ 17 ÐÐÑÑÐÑÑ 2010 20:52:28 ÐÐÑÐÑ Mauro Carvalho Chehab ÐÐÐÐÑÐÐ:
> Em 17-10-2010 14:55, Igor M. Liplianin escreveu:
> > Patches to support for NetUP Dual DVB-T/C-CI RF from NetUP Inc.
> > 
> >         http://linuxtv.org/wiki/index.php/NetUP_Dual_DVB_T_C_CI_RF
> > 
> > Version 2,  Altera FPGA firmware download module reworked.
> > 
> > Features:
> > 
> > PCI-e x1
> > Supports two DVB-T/DVB-C transponders simultaneously
> > Supports two analog audio/video channels simultaneously
> > Independent descrambling of two transponders
> > Hardware PID filtering
> > 
> > Components:
> > 
> > Conexant CX23885
> > STM STV0367 low-power and ultra-compact combo DVB-T/C single-chip
> > receiver Xceive XC5000 silicon TV tuner
> > Altera FPGA for Common Interafce
> > 
> > The following changes since commit 1c8c51f7413ec522c7b729c8ebc5ce815fb7d4a8:
> >   V4L/DVB: drivers/media/IR/ene_ir.c: fix NULL dereference (2010-10-17
> >   09:50:42 -0200)
> > 
> > are available in the git repository at:
> >   http://udev.netup.ru/git/v4l-dvb.git netup-for-media-tree-2
> > 
> > Abylay Ospan (6):
> >       cx23885: Altera FPGA CI interface reworked.
> >       stv0367: change default value for AGC register.
> >       stv0367: implement uncorrected blocks counter.
> >       cx23885, cimax2.c: Fix case of two CAM insertion irq.
> >       Fix CI code for NetUP Dual  DVB-T/C CI RF card
> >       Force xc5000 firmware loading for NetUP Dual  DVB-T/C CI RF card
> > 
> > Igor M. Liplianin (14):
> >       Altera FPGA firmware download module.
> >       Altera FPGA based CI driver module.
> >       Support for stv0367 multi-standard demodulator.
> >       xc5000: add support for DVB-C tuning.
> >       Initial commit to support NetUP Dual DVB-T/C CI RF card.
> >       cx23885: implement tuner_bus parameter for cx23885_board structure.
> >       cx23885: implement num_fds_portb, num_fds_portc parameters for
> >       cx23885_board structure. stv0367: Fix potential divide error
> >       cx23885: remove duplicate set interrupt mask
> >       stv0367: coding style corrections
> >       cx25840: Fix subdev registration and typo in cx25840-core.c
> >       cx23885: 0xe becomes 0xc again for NetUP Dual DVB-S2
> >       cx23885: disable MSI for NetUP cards, otherwise CI is not working
> >       cx23885, altera-ci: enable all PID's less than 0x20 in hardware PID
> >       filter.
> >  
> >  drivers/media/common/tuners/xc5000.c        |   18 +
> >  drivers/media/dvb/frontends/Kconfig         |    7 +
> >  drivers/media/dvb/frontends/Makefile        |    1 +
> >  drivers/media/dvb/frontends/stv0367.c       | 3419
> >  +++++++++++++++++++++++++ drivers/media/dvb/frontends/stv0367.h       |
> >    62 +
> >  drivers/media/dvb/frontends/stv0367_priv.h  |  211 ++
> >  drivers/media/dvb/frontends/stv0367_regs.h  | 3614
> >  +++++++++++++++++++++++++++ drivers/media/video/cx23885/Kconfig        
> >  |   12 +-
> >  drivers/media/video/cx23885/Makefile        |    1 +
> >  drivers/media/video/cx23885/altera-ci.c     |  841 +++++++
> >  drivers/media/video/cx23885/altera-ci.h     |  102 +
> >  drivers/media/video/cx23885/cimax2.c        |   24 +-
> >  drivers/media/video/cx23885/cx23885-cards.c |  116 +-
> >  drivers/media/video/cx23885/cx23885-core.c  |   35 +-
> >  drivers/media/video/cx23885/cx23885-dvb.c   |  175 ++-
> >  drivers/media/video/cx23885/cx23885-reg.h   |    1 +
> >  drivers/media/video/cx23885/cx23885-video.c |    7 +-
> >  drivers/media/video/cx23885/cx23885.h       |    7 +-
> >  drivers/media/video/cx25840/cx25840-core.c  |    4 +-
> >  drivers/misc/Kconfig                        |    1 +
> >  drivers/misc/Makefile                       |    1 +
> >  drivers/misc/stapl-altera/Kconfig           |    8 +
> >  drivers/misc/stapl-altera/Makefile          |    3 +
> >  drivers/misc/stapl-altera/altera.c          | 2603 +++++++++++++++++++
> >  drivers/misc/stapl-altera/jbicomp.c         |  163 ++
> >  drivers/misc/stapl-altera/jbiexprt.h        |   32 +
> >  drivers/misc/stapl-altera/jbijtag.c         | 1038 ++++++++
> >  drivers/misc/stapl-altera/jbijtag.h         |   83 +
> >  drivers/misc/stapl-altera/jbistub.c         |   70 +
> >  include/misc/altera.h                       |   49 +
> >  30 files changed, 12674 insertions(+), 34 deletions(-)
> >  create mode 100644 drivers/media/dvb/frontends/stv0367.c
> >  create mode 100644 drivers/media/dvb/frontends/stv0367.h
> >  create mode 100644 drivers/media/dvb/frontends/stv0367_priv.h
> >  create mode 100644 drivers/media/dvb/frontends/stv0367_regs.h
> >  create mode 100644 drivers/media/video/cx23885/altera-ci.c
> >  create mode 100644 drivers/media/video/cx23885/altera-ci.h
> >  create mode 100644 drivers/misc/stapl-altera/Kconfig
> >  create mode 100644 drivers/misc/stapl-altera/Makefile
> >  create mode 100644 drivers/misc/stapl-altera/altera.c
> >  create mode 100644 drivers/misc/stapl-altera/jbicomp.c
> >  create mode 100644 drivers/misc/stapl-altera/jbiexprt.h
> >  create mode 100644 drivers/misc/stapl-altera/jbijtag.c
> >  create mode 100644 drivers/misc/stapl-altera/jbijtag.h
> >  create mode 100644 drivers/misc/stapl-altera/jbistub.c
> >  create mode 100644 include/misc/altera.h
> 
> There are still a few issues at FPGA patch.
> 
> > Altera FPGA firmware download module.
> > 
> > It uses STAPL files and programs Altera FPGA through JTAG.
> > Interface to JTAG must be provided from main device module,
> > for example through cx23885 GPIO.
> > 
> > Signed-off-by: Igor M. Liplianin <liplianin@xxxxxxxx>
> > Signed-off-by: Mauro Carvalho Chehab <mchehab@xxxxxxxxxx>
> > ---
> > 
> >  drivers/misc/Kconfig                 |    1 +
> >  drivers/misc/Makefile                |    1 +
> >  drivers/misc/stapl-altera/Kconfig    |    8 +
> >  drivers/misc/stapl-altera/Makefile   |    3 +
> >  drivers/misc/stapl-altera/altera.c   | 2603
> >  ++++++++++++++++++++++++++++++++++ drivers/misc/stapl-altera/jbicomp.c 
> >  |  163 +++
> >  drivers/misc/stapl-altera/jbiexprt.h |   32 +
> >  drivers/misc/stapl-altera/jbijtag.c  | 1038 ++++++++++++++
> >  drivers/misc/stapl-altera/jbijtag.h  |   83 ++
> >  drivers/misc/stapl-altera/jbistub.c  |   70 +
> >  include/misc/altera.h                |   49 +
> >  11 files changed, 4051 insertions(+), 0 deletions(-)
> >  create mode 100644 drivers/misc/stapl-altera/Kconfig
> >  create mode 100644 drivers/misc/stapl-altera/Makefile
> >  create mode 100644 drivers/misc/stapl-altera/altera.c
> >  create mode 100644 drivers/misc/stapl-altera/jbicomp.c
> >  create mode 100644 drivers/misc/stapl-altera/jbiexprt.h
> >  create mode 100644 drivers/misc/stapl-altera/jbijtag.c
> >  create mode 100644 drivers/misc/stapl-altera/jbijtag.h
> >  create mode 100644 drivers/misc/stapl-altera/jbistub.c
> >  create mode 100644 include/misc/altera.h
> > 
> > diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
> > index 9b089df..3cfc47c 100644
> > --- a/drivers/misc/Kconfig
> > +++ b/drivers/misc/Kconfig
> > @@ -367,5 +367,6 @@ source "drivers/misc/c2port/Kconfig"
> > 
> >  source "drivers/misc/eeprom/Kconfig"
> >  source "drivers/misc/cb710/Kconfig"
> >  source "drivers/misc/iwmc3200top/Kconfig"
> > 
> > +source "drivers/misc/stapl-altera/Kconfig"
> > 
> >  endif # MISC_DEVICES
> > 
> > diff --git a/drivers/misc/Makefile b/drivers/misc/Makefile
> > index 67552d6..58e794c 100644
> > --- a/drivers/misc/Makefile
> > +++ b/drivers/misc/Makefile
> > @@ -32,3 +32,4 @@ obj-y				+= eeprom/
> > 
> >  obj-y				+= cb710/
> >  obj-$(CONFIG_VMWARE_BALLOON)	+= vmware_balloon.o
> >  obj-$(CONFIG_ARM_CHARLCD)	+= arm-charlcd.o
> > 
> > +obj-y				+= stapl-altera/
> > diff --git a/drivers/misc/stapl-altera/Kconfig
> > b/drivers/misc/stapl-altera/Kconfig new file mode 100644
> > index 0000000..19ba4a9
> > --- /dev/null
> > +++ b/drivers/misc/stapl-altera/Kconfig
> > @@ -0,0 +1,8 @@
> > +comment "Altera FPGA firmware download module"
> > +
> > +config STAPL_ALTERA
> > +	tristate "Altera FPGA firmware download module"
> > +	depends on I2C
> > +	default m
> > +	help
> > +	  An Altera FPGA module. Say Y when you want to support this tool.
> > diff --git a/drivers/misc/stapl-altera/Makefile
> > b/drivers/misc/stapl-altera/Makefile new file mode 100644
> > index 0000000..db56178
> > --- /dev/null
> > +++ b/drivers/misc/stapl-altera/Makefile
> > @@ -0,0 +1,3 @@
> > +stapl-altera-objs = jbistub.o jbijtag.o jbicomp.o altera.o
> > +
> > +obj-$(CONFIG_STAPL_ALTERA) += stapl-altera.o
> > diff --git a/drivers/misc/stapl-altera/altera.c
> > b/drivers/misc/stapl-altera/altera.c new file mode 100644
> > index 0000000..989bb79
> > --- /dev/null
> > +++ b/drivers/misc/stapl-altera/altera.c
> > @@ -0,0 +1,2603 @@
> > +/*
> > + * altera.c
> > + *
> > + * altera FPGA driver
> > + *
> > + * Copyright (C) Altera Corporation 1998-2001
> > + * Copyright (C) 2010 NetUP Inc.
> > + * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
> > + *
> > + * 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/string.h>
> > +#include <linux/firmware.h>
> > +#include <linux/slab.h>
> > +#include <misc/altera.h>
> > +#include "jbiexprt.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@xxxxxxxx>");
> > +MODULE_LICENSE("GPL");
> > +
> > +#include "jbijtag.h"
> > +
> > +#define JBI_STACK_SIZE 128
> > +
> > +#define JBIC_MESSAGE_LENGTH 1024
> > +
> > +#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 jbi_procinfo {
> > +	char *name;
> > +	u8 attrs;
> > +	struct jbi_procinfo *next;
> > +};
> > +
> > +/* This function checks if enough parameters are available on the stack.
> > */ +static int jbi_check_stack(int stack_ptr, int count, int *status) +{
> > +	if (stack_ptr < count) {
> > +		*status = -EOVERFLOW;
> > +		return 0;
> > +	}
> > +
> > +	return 1;
> > +}
> > +
> > +static void jbi_export_integer(char *key, s32 value)
> > +{
> > +	dprintk("Export: key = \"\", value = 0\n", key, value);
> > +}
> > +
> > +#define HEX_LINE_CHARS 72
> > +#define HEX_LINE_BITS (HEX_LINE_CHARS * 4)
> > +
> > +static void jbi_export_boolean_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 = \"\", 0 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], "0", value);
> > +					value = 0;
> > +					--j;
> > +				}
> > +			}
> > +			if ((k & 3) > 0)
> > +				sprintf(&string[j], "0", value);
> > +
> > +			dprintk("\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], "0", value);
> > +				value = 0;
> > +				--j;
> > +			}
> > +		}
> > +		if ((i & 3) > 0)
> > +			sprintf(&string[j], "0", value);
> > +
> > +		dprintk("Export: key = \"\", 0 bits, value = HEX \n",
> > +			key, count, string);
> > +	}
> > +}
> > +
> > +static int jbi_execute(struct altera_config *astate,
> > +				u8 *p,
> > +				s32 program_size,
> > +				s32 *error_address,
> > +				int *exit_code,
> > +				int *format_version)
> > +{
> > +	static char msg_buff[JBIC_MESSAGE_LENGTH + 1];
> > +	static long stack[JBI_STACK_SIZE] = {0L};/*64 bits*/
> 
> On Linux, long int doesn't mean 64 bits. If you want to use a data with 64
> bits, use, instead: u64, for unsigned (or s64, for signed).
> 
> Also, it doesn't seem to be a good idea to define those two data static.
> The proper way is to move those two data to some struct, for example, to
> astate. You may declare it as:
> 
> struct altera_config {
> 	void *dev;
> 	u8 *action;
> 	int (*jtag_io) (void *dev, int tms, int tdi, int tdo);
> 	char msg_buff[JBIC_MESSAGE_LENGTH + 1];
> 	u64 stack[JBI_STACK_SIZE];
> };
> 
> when you'll alloc it with kzconfig, stack will be initialized to zero
> already.
> 
> One advantage is that, if you have two devices, a FPGA init of one device
> wouldn't interfere in the other, even if they happen in parallel.
> 
> If you do that, you can just do here:
> 
> char *msg_buf = astate->msg_buf;
> u64 *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;/*64bits*/
> 
> u64.
> 
> > +	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_temp;/*64bits*/
> 
> u64.
> 
> > +	u32 variable_id;
> > +	u8 *charptr_temp;
> > +	u8 *charptr_temp2;
> > +	long *longptr_temp;
> > +	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_index;
> > +	s32 long_index2;
> > +	u32 i;
> > +	u32 j;
> > +	u32 uncomp_size;
> > +	u32 offset;
> > +	u32 value;
> > +	int current_proc = 0;
> > +	int reverse;
> > +
> > +	char *name;
> > +
> > +	dprintk("\n", __func__);
> > +
> > +	/* Read header information */
> > +	if (program_size > 52L) {
> > +		first_word    = get_unaligned_be32(&p[0]);
> > +		version = (int)(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;
> > +	/* 64 bits */
> > +	vars = kmalloc((u32)sym_count * sizeof(long), GFP_KERNEL);
> > +
> > +	if (vars == NULL)
> > +		status = -ENOMEM;
> > +
> > +	if (status == 0) {
> > +		var_size = kmalloc((u32)sym_count * sizeof(s32), GFP_KERNEL);
> > +
> > +		if (var_size == NULL)
> > +			status = -ENOMEM;
> > +	}
> > +
> > +	if (status == 0) {
> > +		attrs = (char *)kmalloc((u32)sym_count, GFP_KERNEL);
> > +
> > +		if (attrs == NULL)
> > +			status = -ENOMEM;
> > +	}
> > +
> > +	if ((status == 0) && (version > 0)) {
> > +		proc_attributes = (u8 *)kmalloc((u32)proc_count, GFP_KERNEL);
> > +
> > +		if (proc_attributes == NULL)
> > +			status = -ENOMEM;
> > +	}
> 
> Hmm... are you initializing proc_attributes at the loop bellow? Otherwise,
> the better is to use kzalloc.
> 
> > +
> > +	if (status != 0)
> > +		goto exit_done;
> > +
> > +	delta = version * 2;
> > +
> > +	for (i = 0; i < (u32)sym_count; ++i) {
> > +		offset = (u32)(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)kmalloc(uncomp_size, GFP_KERNEL);
> 
> kzalloc?
> 
> > +			if (vars[i] == 0L)
> > +				status = -ENOMEM;
> > +			else {
> > +				/* set flag so buffer
> > +				will be freed later */
> > +				attrs[i] |= 0x80;
> > +
> > +				/* uncompress the data */
> > +				if (jbi_uncompress(&p[data_sect + value],
> > +						var_size[i],
> > +						(u8 *)vars[i],/*64 bits*/
> > +						uncomp_size,
> > +						version) != uncomp_size)
> > +					/* decompression failed */
> > +					status = -EIO;
> > +				else /*64 bits?*/
> > +					var_size[i] = uncomp_size * 8L;
> > +
> > +			}
> > +		} else if ((attrs[i] & 0x1e) == 0x0c) {
> > +			/* initialized Boolean array */
> > +			/*64 bits*/
> > +			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 = (u32)(var_size[i] *
> > +								sizeof(s32));
> > +				else
> > +					/* Boolean array */
> > +					size = (u32)
> > +						((var_size[i] + 7L) / 8L);
> > +				/*64 bits*/
> > +				vars[i] = (long)kmalloc(size, GFP_KERNEL);
> 
> kzalloc?
> 
> > +
> > +				if (vars[i] == 0) {
> > +					status = -ENOMEM;
> > +				} else {
> > +					/* zero out memory */
> > +					for (j = 0; j < size; ++j)
> > +						/*64 bits*/
> > +						((u8 *)(vars[i]))[j] = 0;
> > +
> > +				}
> > +			} else
> > +				vars[i] = 0;
> > +
> > +		} else
> > +			vars[i] = 0;
> > +
> > +	}
> > +
> > +exit_done:
> > +	if (status != 0)
> > +		done = 1;
> > +
> > +	jbi_init_jtag();
> > +
> > +	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 (astate->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 = (char *)&p[str_table + name_id];
> > +
> > +				if (strnicmp(astate->action, name, strlen(name)) == 0) {
> > +					action_found = 1;
> > +					current_proc = (int)
> > +							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] = (u8)
> > +						(p[proc_table +
> > +								(13 * i) + 8] &
> > +									0x03);
> > +
> > +				/*
> > +				BIT0 - OPTIONAL
> > +				BIT1 - RECOMMENDED
> > +				BIT6 - FORCED OFF
> > +				BIT7 - FORCED ON
> > +				*/
> > +
> > +				i = (u32)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 = (u32)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 = (u32)(p[pc] & 0xff);
> > +		opcode_address = pc;
> > +		++pc;
> > +
> > +		if (debug > 1)
> > +			printk("opcode: 00\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 (jbi_check_stack(stack_ptr, 1, &status)) {
> > +				stack[stack_ptr] = stack[stack_ptr - 1];
> > +				++stack_ptr;
> > +			}
> > +			break;
> > +		case OP_SWP:
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				long_temp = stack[stack_ptr - 2];
> > +				stack[stack_ptr - 2] = stack[stack_ptr - 1];
> > +				stack[stack_ptr - 1] = long_temp;
> > +			}
> > +			break;
> > +		case OP_ADD:
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				--stack_ptr;
> > +				stack[stack_ptr - 1] += stack[stack_ptr];
> > +			}
> > +			break;
> > +		case OP_SUB:
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				--stack_ptr;
> > +				stack[stack_ptr - 1] -= stack[stack_ptr];
> > +			}
> > +			break;
> > +		case OP_MULT:
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				--stack_ptr;
> > +				stack[stack_ptr - 1] *= stack[stack_ptr];
> > +			}
> > +			break;
> > +		case OP_DIV:
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				--stack_ptr;
> > +				stack[stack_ptr - 1] /= stack[stack_ptr];
> > +			}
> > +			break;
> > +		case OP_MOD:
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				--stack_ptr;
> > +				stack[stack_ptr - 1] %= stack[stack_ptr];
> > +			}
> > +			break;
> > +		case OP_SHL:
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				--stack_ptr;
> > +				stack[stack_ptr - 1] <<= stack[stack_ptr];
> > +			}
> > +			break;
> > +		case OP_SHR:
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				--stack_ptr;
> > +				stack[stack_ptr - 1] >>= stack[stack_ptr];
> > +			}
> > +			break;
> > +		case OP_NOT:
> > +			if (jbi_check_stack(stack_ptr, 1, &status))
> > +				stack[stack_ptr - 1] ^= (-1L);
> > +
> > +			break;
> > +		case OP_AND:
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				--stack_ptr;
> > +				stack[stack_ptr - 1] &= stack[stack_ptr];
> > +			}
> > +			break;
> > +		case OP_OR:
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				--stack_ptr;
> > +				stack[stack_ptr - 1] |= stack[stack_ptr];
> > +			}
> > +			break;
> > +		case OP_XOR:
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				--stack_ptr;
> > +				stack[stack_ptr - 1] ^= stack[stack_ptr];
> > +			}
> > +			break;
> > +		case OP_INV:
> > +			if (!jbi_check_stack(stack_ptr, 1, &status))
> > +				break;
> > +			stack[stack_ptr - 1] = stack[stack_ptr - 1] ? 0L : 1L;
> > +			break;
> > +		case OP_GT:
> > +			if (!jbi_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 (!jbi_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 = (u32)
> > +					get_unaligned_be32(&p[proc_table +
> > +						(13 * current_proc) + 4]);
> > +				while ((i != 0) &&
> > +					((proc_attributes[i] == 1) ||
> > +					((proc_attributes[i] & 0xc0) == 0x40)))
> > +					i = (u32)
> > +						get_unaligned_be32(&p[proc_table +
> > +								(13 * i) + 4]);
> > +
> > +				if (i == 0) {
> > +					/*
> > +					there are 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 (jbi_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 (jbi_check_stack(stack_ptr, 4, &status)) {
> > +				s32 a = stack[--stack_ptr];
> > +				s32 b = stack[--stack_ptr];
> > +				long_temp = stack[--stack_ptr];
> > +				count = (u32)stack[stack_ptr - 1];
> > +
> > +				if ((count < 1) || (count > 32))
> > +					status = -ERANGE;
> > +				else {
> > +					long_temp &= ((-1L) >> (32 - count));
> > +
> > +					stack[stack_ptr - 1] =
> > +					((a & long_temp) == (b & long_temp))
> > +								? 1L : 0L;
> > +				}
> > +			}
> > +			break;
> > +		case OP_PINT:
> > +			/*
> > +			PRINT add integer
> > +			...stack 0 is integer value
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 1, &status))
> > +				break;
> > +			sprintf(&msg_buff[strlen(msg_buff)],
> > +					"0", 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 (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			long_temp = stack[--stack_ptr];
> > +			count = (u32)stack[--stack_ptr];
> > +			put_unaligned_le32(long_temp, &charbuf[0]);
> > +			status = jbi_do_drscan(astate, count, charbuf, 0);
> > +			break;
> > +		case OP_DSSC:
> > +			/*
> > +			DRSCAN short with capture
> > +			...stack 0 is scan data
> > +			...stack 1 is count
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			long_temp = stack[--stack_ptr];
> > +			count = (u32)stack[stack_ptr - 1];
> > +			put_unaligned_le32(long_temp, &charbuf[0]);
> > +			status = jbi_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 (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			long_temp = stack[--stack_ptr];
> > +			count = (u32)stack[--stack_ptr];
> > +			put_unaligned_le32(long_temp, &charbuf[0]);
> > +			status = jbi_do_irscan(astate, count, charbuf, 0);
> > +			break;
> > +		case OP_ISSC:
> > +			/*
> > +			IRSCAN short with capture
> > +			...stack 0 is scan data
> > +			...stack 1 is count
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			long_temp = stack[--stack_ptr];
> > +			count = (u32)stack[stack_ptr - 1];
> > +			put_unaligned_le32(long_temp, &charbuf[0]);
> > +			status = jbi_swap_ir(astate, count, charbuf,
> > +							0, charbuf, 0);
> > +			stack[stack_ptr - 1] = get_unaligned_le32(&charbuf[0]);
> > +			break;
> > +		case OP_DPR:
> > +			if (!jbi_check_stack(stack_ptr, 1, &status))
> > +				break;
> > +			count = (u32)stack[--stack_ptr];
> > +			status = jbi_set_dr_preamble(count, 0, NULL);
> > +			break;
> > +		case OP_DPRL:
> > +			/*
> > +			DRPRE with literal data
> > +			...stack 0 is count
> > +			...stack 1 is literal data
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			count = (u32)stack[--stack_ptr];
> > +			long_temp = stack[--stack_ptr];
> > +			put_unaligned_le32(long_temp, &charbuf[0]);
> > +			status = jbi_set_dr_preamble(count, 0, charbuf);
> > +			break;
> > +		case OP_DPO:
> > +			/*
> > +			DRPOST
> > +			...stack 0 is count
> > +			*/
> > +			if (jbi_check_stack(stack_ptr, 1, &status)) {
> > +				count = (u32)stack[--stack_ptr];
> > +				status = jbi_set_dr_postamble(count, 0, NULL);
> > +			}
> > +			break;
> > +		case OP_DPOL:
> > +			/*
> > +			DRPOST with literal data
> > +			...stack 0 is count
> > +			...stack 1 is literal data
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			count = (u32)stack[--stack_ptr];
> > +			long_temp = stack[--stack_ptr];
> > +			put_unaligned_le32(long_temp, &charbuf[0]);
> > +			status = jbi_set_dr_postamble(count, 0, charbuf);
> > +			break;
> > +		case OP_IPR:
> > +			if (jbi_check_stack(stack_ptr, 1, &status)) {
> > +				count = (u32)stack[--stack_ptr];
> > +				status = jbi_set_ir_preamble(count, 0, NULL);
> > +			}
> > +			break;
> > +		case OP_IPRL:
> > +			/*
> > +			IRPRE with literal data
> > +			...stack 0 is count
> > +			...stack 1 is literal data
> > +			*/
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				count = (u32)stack[--stack_ptr];
> > +				long_temp = stack[--stack_ptr];
> > +				put_unaligned_le32(long_temp, &charbuf[0]);
> > +				status = jbi_set_ir_preamble(count, 0, charbuf);
> > +			}
> > +			break;
> > +		case OP_IPO:
> > +			/*
> > +			IRPOST
> > +			...stack 0 is count
> > +			*/
> > +			if (jbi_check_stack(stack_ptr, 1, &status)) {
> > +				count = (u32)stack[--stack_ptr];
> > +				status = jbi_set_ir_postamble(count, 0, NULL);
> > +			}
> > +			break;
> > +		case OP_IPOL:
> > +			/*
> > +			IRPOST with literal data
> > +			...stack 0 is count
> > +			...stack 1 is literal data
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			count = (u32)stack[--stack_ptr];
> > +			long_temp = stack[--stack_ptr];
> > +			put_unaligned_le32(long_temp, &charbuf[0]);
> > +			status = jbi_set_ir_postamble(count, 0, charbuf);
> > +			break;
> > +		case OP_PCHR:
> > +			if (jbi_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 (jbi_check_stack(stack_ptr, 1, &status))
> > +				*exit_code = (int) stack[--stack_ptr];
> > +
> > +			done = 1;
> > +			break;
> > +		case OP_EQU:
> > +			if (!jbi_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 (jbi_check_stack(stack_ptr, 1, &status))
> > +				--stack_ptr;
> > +
> > +			break;
> > +		case OP_ABS:
> > +			if (!jbi_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 (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				long_temp = stack[stack_ptr - 2];
> > +				stack[stack_ptr - 2] = stack[stack_ptr - 1];
> > +				stack[stack_ptr - 1] = long_temp;
> > +			}
> > +
> > +			/* SWPN 7 */
> > +			index = 7 + 1;
> > +			if (jbi_check_stack(stack_ptr, index, &status)) {
> > +				long_temp = stack[stack_ptr - index];
> > +				stack[stack_ptr - index] = stack[stack_ptr - 1];
> > +				stack[stack_ptr - 1] = long_temp;
> > +			}
> > +
> > +			/* SWP  */
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				long_temp = stack[stack_ptr - 2];
> > +				stack[stack_ptr - 2] = stack[stack_ptr - 1];
> > +				stack[stack_ptr - 1] = long_temp;
> > +			}
> > +
> > +			/* SWPN 6 */
> > +			index = 6 + 1;
> > +			if (jbi_check_stack(stack_ptr, index, &status)) {
> > +				long_temp = stack[stack_ptr - index];
> > +				stack[stack_ptr - index] = stack[stack_ptr - 1];
> > +				stack[stack_ptr - 1] = long_temp;
> > +			}
> > +
> > +			/* DUPN 8 */
> > +			index = 8 + 1;
> > +			if (jbi_check_stack(stack_ptr, index, &status)) {
> > +				stack[stack_ptr] = stack[stack_ptr - index];
> > +				++stack_ptr;
> > +			}
> > +
> > +			/* SWPN 2 */
> > +			index = 2 + 1;
> > +			if (jbi_check_stack(stack_ptr, index, &status)) {
> > +				long_temp = stack[stack_ptr - index];
> > +				stack[stack_ptr - index] = stack[stack_ptr - 1];
> > +				stack[stack_ptr - 1] = long_temp;
> > +			}
> > +
> > +			/* SWP  */
> > +			if (jbi_check_stack(stack_ptr, 2, &status)) {
> > +				long_temp = stack[stack_ptr - 2];
> > +				stack[stack_ptr - 2] = stack[stack_ptr - 1];
> > +				stack[stack_ptr - 1] = long_temp;
> > +			}
> > +
> > +			/* DUPN 6 */
> > +			index = 6 + 1;
> > +			if (jbi_check_stack(stack_ptr, index, &status)) {
> > +				stack[stack_ptr] = stack[stack_ptr - index];
> > +				++stack_ptr;
> > +			}
> > +
> > +			/* DUPN 6 */
> > +			index = 6 + 1;
> > +			if (jbi_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 (jbi_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],
> > +				(char *)&p[str_table + args[0]],
> > +				JBIC_MESSAGE_LENGTH - count);
> > +			break;
> > +		case OP_SINT:
> > +			/*
> > +			STATE intermediate state
> > +			...argument 0 is state code
> > +			*/
> > +			status = jbi_goto_jtag_state(astate, (int) args[0]);
> > +			break;
> > +		case OP_ST:
> > +			/*
> > +			STATE final state
> > +			...argument 0 is state code
> > +			*/
> > +			status = jbi_goto_jtag_state(astate, (int) args[0]);
> > +			break;
> > +		case OP_ISTP:
> > +			/*
> > +			IRSTOP state
> > +			...argument 0 is state code
> > +			*/
> > +			status = jbi_set_irstop_state((int) args[0]);
> > +			break;
> > +		case OP_DSTP:
> > +			/*
> > +			DRSTOP state
> > +			...argument 0 is state code
> > +			*/
> > +			status = jbi_set_drstop_state((int) 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 = ((int) args[0]) + 1;
> > +			if (jbi_check_stack(stack_ptr, index, &status)) {
> > +				long_temp = stack[stack_ptr - index];
> > +				stack[stack_ptr - index] = stack[stack_ptr - 1];
> > +				stack[stack_ptr - 1] = long_temp;
> > +			}
> > +			break;
> > +		case OP_DUPN:
> > +			/*
> > +			Duplicate Nth stack value
> > +			...argument 0 is 0-based stack entry to duplicate
> > +			*/
> > +			index = ((int) args[0]) + 1;
> > +			if (jbi_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 (jbi_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 (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			variable_id = (u32)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 = (u32)var_size[variable_id];
> > +				long_temp = vars[variable_id];
> > +				/*64 bits*/
> > +				longptr_temp = (long *)
> > +					kmalloc(count * sizeof(long),
> > +								GFP_KERNEL);
> > +				/*64 bits*/
> > +				vars[variable_id] = (long)longptr_temp;
> > +
> > +				if (vars[variable_id] == 0) {
> > +					status = -ENOMEM;
> > +					break;
> > +				}
> > +
> > +				/* copy previous contents into buffer */
> > +				for (i = 0; i < count; ++i) {
> > +					/*64 QWORD?*/
> > +					longptr_temp[i] = get_unaligned_be32(&p[long_temp]);
> > +					long_temp += sizeof(long);/*64*/
> > +				}
> > +
> > +				/*
> > +				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 {
> > +				/*64 bits*/
> > +				longptr_temp = (long *)vars[variable_id];
> > +
> > +				/* pop the array index */
> > +				index = (u32)stack[--stack_ptr];
> > +
> > +				/* pop the value and store it into the array */
> > +				longptr_temp[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 (!jbi_check_stack(stack_ptr, 3, &status))
> > +				break;
> > +			variable_id = (u32)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_temp =
> > +					(var_size[variable_id] + 7L) >> 3L;
> > +				charptr_temp2 = (u8 *)vars[variable_id];
> > +				charptr_temp =
> > +					kmalloc((u32)long_temp, GFP_KERNEL);
> > +				/*64 bits*/
> > +				vars[variable_id] = (long)charptr_temp;
> > +
> > +				if (vars[variable_id] == 0) {
> > +					status = -ENOMEM;
> > +					break;
> > +				}
> > +
> > +				/* zero the buffer */
> > +				for (long_index = 0L;
> > +					long_index < long_temp;
> > +					++long_index) {
> > +					charptr_temp[long_index] = 0;
> > +				}
> > +
> > +				/* copy previous contents into buffer */
> > +				for (long_index = 0L;
> > +					long_index < var_size[variable_id];
> > +					++long_index) {
> > +					long_index2 = long_index;
> > +
> > +					if (charptr_temp2[long_index2 >> 3] &
> > +						(1 << (long_index2 & 7))) {
> > +						charptr_temp[long_index >> 3] |=
> > +							(1 << (long_index & 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_temp = (u8 *)vars[variable_id];
> > +
> > +			/* pop the count (number of bits to copy) */
> > +			long_count = stack[--stack_ptr];
> > +
> > +			/* pop the array index */
> > +			long_index = stack[--stack_ptr];
> > +
> > +			reverse = 0;
> > +
> > +			if (version > 0) {
> > +				/*
> > +				stack 0 = array right index
> > +				stack 1 = array left index */
> > +
> > +				if (long_index > long_count) {
> > +					reverse = 1;
> > +					long_temp = long_count;
> > +					long_count = 1 + long_index -
> > +								long_count;
> > +					long_index = long_temp;
> > +
> > +					/* reverse POPA is not supported */
> > +					status = -ERANGE;
> > +					break;
> > +				} else
> > +					long_count = 1 + long_count -
> > +								long_index;
> > +
> > +			}
> > +
> > +			/* pop the data */
> > +			long_temp = stack[--stack_ptr];
> > +
> > +			if (long_count < 1) {
> > +				status = -ERANGE;
> > +				break;
> > +			}
> > +
> > +			for (i = 0; i < (u32)long_count; ++i) {
> > +				if (long_temp & (1L << (s32) i))
> > +					charptr_temp[long_index >> 3L] |=
> > +						(1L << (long_index & 7L));
> > +				else
> > +					charptr_temp[long_index >> 3L] &=
> > +						~(u32)(1L << (long_index & 7L));
> > +
> > +				++long_index;
> > +			}
> > +
> > +			break;
> > +		case OP_JMPZ:
> > +			/*
> > +			Pop stack and branch if zero
> > +			...argument 0 is address
> > +			...stack 0 is condition value
> > +			*/
> > +			if (jbi_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 (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			long_index = 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_temp = long_count;
> > +				long_count = stack[--stack_ptr];
> > +
> > +				if (long_index > long_temp) {
> > +					reverse = 1;
> > +					long_index = long_temp;
> > +				}
> > +			}
> > +
> > +			charptr_temp = (u8 *)vars[args[0]];
> > +
> > +			if (reverse) {
> > +				/*
> > +				allocate a buffer and reverse the data order */
> > +				charptr_temp2 = charptr_temp;
> > +				charptr_temp = kmalloc((long_count >> 3) + 1,
> > +								GFP_KERNEL);
> > +				if (charptr_temp == NULL) {
> > +					status = -ENOMEM;
> > +					break;
> > +				}
> > +
> > +				long_temp = long_index + long_count - 1;
> > +				long_index2 = 0;
> > +				while (long_index2 < long_count) {
> > +					if (charptr_temp2[long_temp >> 3] &
> > +							(1 << (long_temp & 7)))
> > +						charptr_temp[long_index2 >> 3] |= (1 << (long_index2 & 7));
> > +					else
> > +						charptr_temp[long_index2 >> 3] &= ~(1 << (long_index2 & 7));
> > +
> > +					--long_temp;
> > +					++long_index2;
> > +				}
> > +			}
> > +
> > +			if (opcode == 0x51) /* DS */
> > +				status = jbi_do_drscan(astate, (u32)long_count,
> > +						charptr_temp, (u32)long_index);
> > +			else /* IS */
> > +				status = jbi_do_irscan(astate, (u32)long_count,
> > +						charptr_temp, (u32)long_index);
> > +
> > +			if (reverse && (charptr_temp != NULL))
> > +				kfree(charptr_temp);
> > +
> > +			break;
> > +		case OP_DPRA:
> > +			/*
> > +			DRPRE with array data
> > +			...argument 0 is variable ID
> > +			...stack 0 is array index
> > +			...stack 1 is count
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			index = (u32)stack[--stack_ptr];
> > +			count = (u32)stack[--stack_ptr];
> > +
> > +			if (version > 0)
> > +				/*
> > +				stack 0 = array right index
> > +				stack 1 = array left index */
> > +				count = 1 + count - index;
> > +
> > +			charptr_temp = (u8 *)vars[args[0]];
> > +			status = jbi_set_dr_preamble(count, index,
> > +							charptr_temp);
> > +			break;
> > +		case OP_DPOA:
> > +			/*
> > +			DRPOST with array data
> > +			...argument 0 is variable ID
> > +			...stack 0 is array index
> > +			...stack 1 is count
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			index = (u32)stack[--stack_ptr];
> > +			count = (u32)stack[--stack_ptr];
> > +
> > +			if (version > 0)
> > +				/*
> > +				stack 0 = array right index
> > +				stack 1 = array left index */
> > +				count = 1 + count - index;
> > +
> > +			charptr_temp = (u8 *)vars[args[0]];
> > +			status = jbi_set_dr_postamble(count, index,
> > +							charptr_temp);
> > +			break;
> > +		case OP_IPRA:
> > +			/*
> > +			IRPRE with array data
> > +			...argument 0 is variable ID
> > +			...stack 0 is array index
> > +			...stack 1 is count
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			index = (u32)stack[--stack_ptr];
> > +			count = (u32)stack[--stack_ptr];
> > +
> > +			if (version > 0)
> > +				/*
> > +				stack 0 = array right index
> > +				stack 1 = array left index */
> > +				count = 1 + count - index;
> > +
> > +			charptr_temp = (u8 *)vars[args[0]];
> > +			status = jbi_set_ir_preamble(count, index,
> > +							charptr_temp);
> > +
> > +			break;
> > +		case OP_IPOA:
> > +			/*
> > +			IRPOST with array data
> > +			...argument 0 is variable ID
> > +			...stack 0 is array index
> > +			...stack 1 is count
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			index = (u32)stack[--stack_ptr];
> > +			count = (u32)stack[--stack_ptr];
> > +
> > +			if (version > 0)
> > +				/*
> > +				stack 0 = array right index
> > +				stack 1 = array left index */
> > +				count = 1 + count - index;
> > +
> > +			charptr_temp = (u8 *)vars[args[0]];
> > +			status = jbi_set_ir_postamble(count, index,
> > +							charptr_temp);
> > +
> > +			break;
> > +		case OP_EXPT:
> > +			/*
> > +			EXPORT
> > +			...argument 0 is string ID
> > +			...stack 0 is integer expression
> > +			*/
> > +			if (jbi_check_stack(stack_ptr, 1, &status)) {
> > +				name = (char *)&p[str_table + args[0]];
> > +				long_temp = stack[--stack_ptr];
> > +				jbi_export_integer(name, long_temp);
> > +			}
> > +			break;
> > +		case OP_PSHE:
> > +			/*
> > +			Push integer array element
> > +			...argument 0 is variable ID
> > +			...stack 0 is array index
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 1, &status))
> > +				break;
> > +			variable_id = (u32)args[0];
> > +			index = (u32)stack[stack_ptr - 1];
> > +
> > +			/* check variable type */
> > +			if ((attrs[variable_id] & 0x1f) == 0x19) {
> > +				/* writable integer array */
> > +				longptr_temp = (long *)vars[variable_id];
> > +				stack[stack_ptr - 1] = longptr_temp[index];
> > +			} else if ((attrs[variable_id] & 0x1f) == 0x1c) {
> > +				/* read-only integer array */
> > +				long_temp = vars[variable_id] +
> > +						(sizeof(long) * index);/*64*/
> > +				stack[stack_ptr - 1] = get_unaligned_be32(&p[long_temp]);
> > +			} 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 (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			variable_id = (u32)args[0];
> > +
> > +			/* check that variable is a Boolean array */
> > +			if ((attrs[variable_id] & 0x18) != 0x08) {
> > +				status = -ERANGE;
> > +				break;
> > +			}
> > +
> > +			charptr_temp = (u8 *)vars[variable_id];
> > +
> > +			/* pop the count (number of bits to copy) */
> > +			count = (u32)stack[--stack_ptr];
> > +
> > +			/* pop the array index */
> > +			index = (u32)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_temp = 0L;
> > +
> > +			for (i = 0; i < count; ++i)
> > +				if (charptr_temp[(i + index) >> 3] &
> > +						(1 << ((i + index) & 7)))
> > +					long_temp |= (1L << i);
> > +
> > +			stack[stack_ptr - 1] = long_temp;
> > +
> > +			break;
> > +		case OP_DYNA:
> > +			/*
> > +			Dynamically change size of array
> > +			...argument 0 is variable ID
> > +			...stack 0 is new size
> > +			*/
> > +			if (!jbi_check_stack(stack_ptr, 1, &status))
> > +				break;
> > +			variable_id = (u32)args[0];
> > +			long_temp = stack[--stack_ptr];
> > +
> > +			if (long_temp > var_size[variable_id]) {
> > +				var_size[variable_id] = long_temp;
> > +
> > +				if (attrs[variable_id] & 0x10)
> > +					/* allocate integer array */
> > +					long_temp *= sizeof(long);
> > +				else
> > +					/* allocate Boolean array */
> > +					long_temp = (long_temp + 7) >> 3;
> > +
> > +				/*
> > +				If the buffer was previously allocated,
> > +				free it */
> > +				if ((attrs[variable_id] & 0x80) &&
> > +						(vars[variable_id] != 0)) {
> > +					kfree((void *)vars[variable_id]);
> > +					vars[variable_id] = 0;
> > +				}
> > +
> > +				/*
> > +				Allocate a new buffer
> > +				of the requested size */
> > +				/*64 bits*/
> > +				vars[variable_id] = (long)
> > +					kmalloc((u32)long_temp, 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 = (u32)
> > +					((var_size[variable_id] + 7L) /
> > +									8L);
> > +				charptr_temp = (u8 *)(vars[variable_id]);
> > +				for (index = 0; index < count; ++index)
> > +					charptr_temp[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 (!jbi_check_stack(stack_ptr, 3, &status))
> > +				break;
> > +			if (version == 0) {
> > +				/* EXPV is not supported in JBC 1.0 */
> > +				bad_opcode = 1;
> > +				break;
> > +			}
> > +			name = (char *)&p[str_table + args[0]];
> > +			variable_id = (u32)stack[--stack_ptr];
> > +			long_index = stack[--stack_ptr];/* right indx */
> > +			long_index2 = stack[--stack_ptr];/* left indx */
> > +
> > +			if (long_index > long_index2) {
> > +				/* reverse indices not supported */
> > +				status = -ERANGE;
> > +				break;
> > +			}
> > +
> > +			long_count = 1 + long_index2 - long_index;
> > +
> > +			charptr_temp = (u8 *)vars[variable_id];
> > +			charptr_temp2 = NULL;
> > +
> > +			if ((long_index & 7L) != 0) {
> > +				s32 k = long_index;
> > +				charptr_temp2 = kmalloc((u32)
> > +					((long_count + 7L) / 8L), GFP_KERNEL);
> > +				if (charptr_temp2 == NULL) {
> > +					status = -ENOMEM;
> > +					break;
> > +				}
> > +
> > +				for (i = 0; i < (u32)long_count; ++i) {
> > +					if (charptr_temp[k >> 3] &
> > +							(1 << (k & 7)))
> > +						charptr_temp2[i >> 3] |=
> > +								(1 << (i & 7));
> > +					else
> > +						charptr_temp2[i >> 3] &=
> > +								~(1 << (i & 7));
> > +
> > +					++k;
> > +				}
> > +				charptr_temp = charptr_temp2;
> > +
> > +			} else if (long_index != 0)
> > +				charptr_temp = &charptr_temp[long_index >> 3];
> > +
> > +			jbi_export_boolean_array(name, charptr_temp,
> > +							long_count);
> > +
> > +			/* free allocated buffer */
> > +			if (((long_index & 7L) != 0) && (charptr_temp2 != NULL))
> > +				kfree(charptr_temp2);
> > +
> > +			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 (!jbi_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_index2 = destination start index */
> > +
> > +				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" the arrays when copying.
> > +					This won't work correctly
> > +					with reversed arrays. */
> > +					status = -ERANGE;
> > +
> > +			}
> > +
> > +			count = (u32)copy_count;
> > +			index = (u32)copy_index;
> > +			index2 = (u32)copy_index2;
> > +
> > +			/*
> > +			If destination is a read-only array, allocate a buffer
> > +			and convert it to a writable array */
> > +			variable_id = (u32)args[1];
> > +			if ((version > 0) &&
> > +				((attrs[variable_id] & 0x9c) == 0x0c)) {
> > +				/* Allocate a writable buffer for this array */
> > +				long_temp =
> > +					(var_size[variable_id] + 7L) >> 3L;
> > +				charptr_temp2 = (u8 *)vars[variable_id];
> > +				charptr_temp =
> > +					kmalloc((u32)long_temp, GFP_KERNEL);
> > +				/*64 bits*/
> > +				vars[variable_id] = (long)charptr_temp;
> > +
> > +				if (vars[variable_id] == 0) {
> > +					status = -ENOMEM;
> > +					break;
> > +				}
> > +
> > +				/* zero the buffer */
> > +				for (long_index = 0L; long_index < long_temp;
> > +								++long_index)
> > +					charptr_temp[long_index] = 0;
> > +
> > +				/* copy previous contents into buffer */
> > +				for (long_index = 0L;
> > +					long_index < var_size[variable_id];
> > +								++long_index) {
> > +					long_index2 = long_index;
> > +
> > +					if (charptr_temp2[long_index2 >> 3] &
> > +						(1 << (long_index2 & 7)))
> > +						charptr_temp[long_index >> 3] |=
> > +							(1 << (long_index & 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_temp = (u8 *)vars[args[1]];
> > +			charptr_temp2 = (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_temp2[index >> 3] &
> > +							(1 << (index & 7)))
> > +					charptr_temp[index2 >> 3] |=
> > +							(1 << (index2 & 7));
> > +				else
> > +					charptr_temp[index2 >> 3] &=
> > +						~(u32)(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 (!jbi_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 = (u32)args[1];
> > +			if ((version > 0) &&
> > +				((attrs[variable_id] & 0x9c) == 0x0c)) {
> > +				/* Allocate a writable buffer for this array */
> > +				long_temp =
> > +					(var_size[variable_id] + 7L) >> 3L;
> > +				charptr_temp2 = (u8 *)vars[variable_id];
> > +				charptr_temp =
> > +					kmalloc((u32)long_temp, GFP_KERNEL);
> > +				vars[variable_id] = (long)charptr_temp;
> > +
> > +				if (vars[variable_id] == 0) {
> > +					status = -ENOMEM;
> > +					break;
> > +				}
> > +
> > +				/* zero the buffer */
> > +				for (long_index = 0L; long_index < long_temp;
> > +								++long_index)
> > +					charptr_temp[long_index] = 0;
> > +
> > +				/* copy previous contents into buffer */
> > +				for (long_index = 0L;
> > +					long_index < var_size[variable_id];
> > +								++long_index) {
> > +					long_index2 = long_index;
> > +
> > +					if (charptr_temp2[long_index2 >> 3] &
> > +						(1 << (long_index2 & 7)))
> > +						charptr_temp[long_index >> 3] |=
> > +							(1 << (long_index & 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_temp = (u8 *)vars[args[0]];
> > +			charptr_temp2 = (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 = jbi_swap_dr(astate,
> > +							(u32)long_count,
> > +							charptr_temp,
> > +							(u32)scan_index,
> > +							charptr_temp2,
> > +							(u32)capture_index);
> > +				else /* ISC */
> > +					status = jbi_swap_ir(astate,
> > +							(u32)long_count,
> > +							charptr_temp,
> > +							(u32)scan_index,
> > +							charptr_temp2,
> > +							(u32)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 (!jbi_check_stack(stack_ptr, 2, &status))
> > +				break;
> > +			long_temp = stack[--stack_ptr];
> > +
> > +			if (long_temp != 0L)
> > +				status = jbi_do_wait_cycles(astate, long_temp,
> > +								(u32)args[0]);
> > +
> > +			long_temp = stack[--stack_ptr];
> > +
> > +			if ((status == 0) && (long_temp != 0L))
> > +				status = jbi_do_wait_microseconds(astate,
> > +								long_temp,
> > +								(u32)args[0]);
> > +
> > +			if ((status == 0) && (args[1] != args[0]))
> > +				status = jbi_goto_jtag_state(astate,
> > +								(u32)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 (!jbi_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_temp = 1L;
> > +
> > +			if (long_count < 1)
> > +				status = -ERANGE;
> > +			else {
> > +				count = (u32)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_temp = 0L;
> > +					}
> > +					++index1;
> > +					++index2;
> > +					++mask_index;
> > +				}
> > +			}
> > +
> > +			stack[stack_ptr++] = long_temp;
> > +
> > +			break;
> > +		}
> > +		default:
> > +			/* Unrecognized opcode -- ERROR! */
> > +			bad_opcode = 1;
> > +			break;
> > +		}
> > +
> > +		if (bad_opcode)
> > +			status = -ENOSYS;
> > +
> > +		if ((stack_ptr < 0) || (stack_ptr >= JBI_STACK_SIZE))
> > +			status = -EOVERFLOW;
> > +
> > +		if (status != 0) {
> > +			done = 1;
> > +			*error_address = (s32)(opcode_address - code_sect);
> > +		}
> > +	}
> > +
> > +	jbi_free_jtag_padding_buffers(astate/*, reset_jtag*/);
> > +
> > +	/* Free all dynamically allocated arrays */
> > +	if ((attrs != NULL) && (vars != NULL)) {
> > +		for (i = 0; i < (u32)sym_count; ++i) {
> > +			if ((attrs[i] & 0x80) && (vars[i] != 0))
> > +				kfree((void *)vars[i]);
> 
> Just do:
> 
> 	if (vars != NULL) {
> 		for (i = 0; i < (u32)sym_count; ++i)
> 			kfree(vars[i]);
> 	}
> 
> > +
> > +		}
> > +	}
> > +
> > +	if (vars != NULL)
> > +		kfree(vars);
> 
> It is safe to call kfree(NULL), so just do:
> 	kfree(vars);
> 
> > +
> > +	if (var_size != NULL)
> > +		kfree(var_size);
> > +
> > +	if (attrs != NULL)
> > +		kfree(attrs);
> > +
> > +	if (proc_attributes != NULL)
> > +		kfree(proc_attributes);
> 
> Same here.
> 
> Hmm... checkpatch.pl should have warned you about this...
> 
> > +
> > +	return status;
> > +}
> > +
> > +static int jbi_get_note(u8 *p, s32 program_size,
> > +			s32 *offset, char *key, char *value, int length)
> > +/*
> > +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 = (int)(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 < (int)note_count) &&
> > +						(status != 0); ++i) {
> > +			key_ptr = (char *)&p[note_strings +
> > +					get_unaligned_be32(
> > +					&p[note_table + (8 * i)])];
> > +			if ((key != NULL) &&
> > +				(strnicmp(key, key_ptr, strlen(key_ptr)) == 0)) {
> > +				status = 0;
> > +
> > +				value_ptr = (char *)&p[note_strings +
> > +						get_unaligned_be32(
> > +						&p[note_table + (8 * i) + 4])];
> > +
> > +				if (value != NULL)
> > +					strlcpy(value, value_ptr, length);
> > +
> > +			}
> > +		}
> > +	} else {
> > +		/*
> > +		We will search for the next note, regardless of the key,
> > +		and return both the value and the key */
> > +
> > +		i = (int)*offset;
> > +
> > +		if ((i >= 0) && (i < (int) note_count)) {
> > +			status = 0;
> > +
> > +			if (key != NULL)
> > +				strlcpy(key, (char *)&p[note_strings +
> > +						get_unaligned_be32(
> > +						&p[note_table + (8 * i)])],
> > +					length);
> > +
> > +			if (value != NULL)
> > +				strlcpy(value, (char *)&p[note_strings +
> > +						get_unaligned_be32(
> > +						&p[note_table + (8 * i) + 4])],
> > +					length);
> > +
> > +			*offset = i + 1;
> > +		}
> > +	}
> > +
> > +	return status;
> > +}
> > +
> > +static int jbi_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 = (int)(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 >= (u32)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 ": CRC matched: 0000\n", __func__,
> > +				local_actual);
> > +			break;
> > +		case -EILSEQ:
> > +			printk(KERN_ERR ": CRC mismatch: expected 0000, "
> > +				"actual 0000\n", __func__, local_expected,
> > +				local_actual);
> > +			break;
> > +		case -ENODATA:
> > +			printk(KERN_ERR ": expected CRC not found, "
> > +				"actual CRC = 0000\n", __func__,
> > +				local_actual);
> > +			break;
> > +		case -EIO:
> > +			printk(KERN_ERR ": error: format isn't "
> > +				"recognized.\n", __func__);
> > +			break;
> > +		default:
> > +			printk(KERN_ERR ": CRC function returned error "
> > +				"code 0\n", __func__, status);
> > +			break;
> > +		}
> > +	}
> > +
> > +	return status;
> > +}
> > +
> > +static int jbi_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 = (int)(first_word & 1L);
> > +		*format_version = version + 1;
> > +
> > +		if (version > 0) {
> > +			*action_count = (int)get_unaligned_be32(&p[48]);
> > +			*procedure_count = (int)get_unaligned_be32(&p[52]);
> > +		}
> > +	}
> > +
> > +	return status;
> > +}
> > +
> > +static int jbi_get_action_info(u8 *p,
> > +					s32 program_size,
> > +					int index,
> > +					char **name,
> > +					char **description,
> > +					struct jbi_procinfo **proc_list)
> > +{
> > +	int status = -EIO;
> > +	struct jbi_procinfo *procptr = NULL;
> > +	struct jbi_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 >= (int)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 = (char *)&p[str_table + act_name_id];
> > +
> > +	if (act_desc_id < (note_strings - str_table))
> > +		*description = (char *)&p[str_table + act_desc_id];
> > +
> > +	do {
> > +		act_proc_name = get_unaligned_be32(
> > +					&p[proc_table + (13 * act_proc_id)]);
> > +		act_proc_attribute = (u8)
> > +			(p[proc_table + (13 * act_proc_id) + 8] & 0x03);
> > +
> > +		procptr = (struct jbi_procinfo *)
> > +				kmalloc(sizeof(struct jbi_procinfo),
> > +								GFP_KERNEL);
> > +
> > +		if (procptr == NULL)
> > +			status = -ENOMEM;
> > +		else {
> > +			procptr->name = (char *)
> > +					&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)
> > +{
> > +	static struct altera_config *astate;
> > +	static u8 key[33] = {0};
> > +	static u8 value[257] = {0};
> > +	char *action_name = NULL;
> > +	char *description = NULL;
> > +	char *exit_string = NULL;
> > +	struct jbi_procinfo *proc_list = NULL;
> > +	struct jbi_procinfo *procptr = 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;
> > +
> > +	astate = kzalloc(sizeof(struct altera_config), GFP_KERNEL);
> > +	if (!astate)
> > +		return -ENOMEM;
> > +
> > +	memcpy(astate, config, sizeof(struct altera_config));
> > +	if (!astate->jtag_io) {
> > +		dprintk(KERN_INFO ": using byteblaster!\n", __func__);
> > +		astate->jtag_io = netup_jtag_io_lpt;
> > +	}
> > +
> > +	jbi_check_crc((u8 *)fw->data, fw->size);
> > +
> > +	if (debug) {
> > +		jbi_get_file_info((u8 *)fw->data, fw->size, &format_version,
> > +					&action_count, &procedure_count);
> > +		printk(KERN_INFO ": File format is  ByteCode format\n",
> > +			__func__, (format_version == 2) ? "Jam STAPL" :
> > +						"pre-standardized Jam 1.1");
> > +		while (jbi_get_note((u8 *)fw->data, fw->size,
> > +					&offset, key, value, 256) == 0)
> > +			printk(KERN_INFO ": NOTE \"\" = \"\"\n",
> > +					__func__, key, value);
> > +	}
> > +
> > +	if (debug && (format_version == 2) && (action_count > 0)) {
> > +		printk(KERN_INFO ": Actions available:\n", __func__);
> > +		for (index = 0; index < action_count; ++index) {
> > +			jbi_get_action_info((u8 *)fw->data, fw->size,
> > +						index, &action_name,
> > +						&description,
> > +						&proc_list);
> > +
> > +			if (description == NULL)
> > +				printk(KERN_INFO ": \n",
> > +						__func__,
> > +						action_name);
> > +			else
> > +				printk(KERN_INFO ":  \"\"\n",
> > +						__func__,
> > +						action_name,
> > +						description);
> > +
> > +			procptr = proc_list;
> > +			while (procptr != NULL) {
> > +				if (procptr->attrs != 0)
> > +					printk(KERN_INFO ":     ()\n",
> > +						__func__,
> > +						procptr->name,
> > +						(procptr->attrs == 1) ?
> > +						"optional" : "recommended");
> > +
> > +				proc_list = procptr->next;
> > +				kfree(procptr);
> > +				procptr = proc_list;
> > +			}
> > +		}
> > +
> > +		printk(KERN_INFO "\n");
> > +	}
> > +
> > +	exec_result = jbi_execute(astate, (u8 *)fw->data, fw->size,
> > +				&error_address, &exit_code, &format_version);
> > +
> > +	if (exec_result == 0) {
> > +		if (format_version == 2) {
> > +			switch (exit_code) {
> > +			case  0:
> > +				exit_string = "Success";
> > +				break;
> > +			case  1:
> > +				exit_string = "Checking chain failure";
> > +				break;
> 
> Huh? Haven't you replace the errors code already by standard Unix errors?
> You don't need this error translation logic. Instead, just return the
> error code to the caller.
It's not related to Unix errors.
Firmware like program itself sets value for exit_code, and I do not control firmware for that 
matter.
To simlify code I can drop it, naturally.
exec_result is related and controlled by.

> 
> > +			case  2:
> > +				exit_string = "Reading IDCODE failure";
> > +				break;
> > +			case  3:
> > +				exit_string = "Reading USERCODE failure";
> > +				break;
> > +			case  4:
> > +				exit_string = "Reading UESCODE failure";
> > +				break;
> > +			case  5:
> > +				exit_string = "Entering ISP failure";
> > +				break;
> > +			case  6:
> > +				exit_string = "Unrecognized device";
> > +				break;
> > +			case  7:
> > +				exit_string = "Device revision is "
> > +						"not supported";
> > +				break;
> > +			case  8:
> > +				exit_string = "Erase failure";
> > +				break;
> > +			case  9:
> > +				exit_string = "Device is not blank";
> > +				break;
> > +			case 10:
> > +				exit_string = "Device programming failure";
> > +				break;
> > +			case 11:
> > +				exit_string = "Device verify failure";
> > +				break;
> > +			case 12:
> > +				exit_string = "Read failure";
> > +				break;
> > +			case 13:
> > +				exit_string = "Calculating checksum failure";
> > +				break;
> > +			case 14:
> > +				exit_string = "Setting security bit failure";
> > +				break;
> > +			case 15:
> > +				exit_string = "Querying security bit failure";
> > +				break;
> > +			case 16:
> > +				exit_string = "Exiting ISP failure";
> > +				break;
> > +			case 17:
> > +				exit_string = "Performing system test failure";
> > +				break;
> > +			default:
> > +				exit_string = "Unknown exit code";
> > +				break;
> > +			}
> > +		} else {
> > +			switch (exit_code) {
> > +			case 0:
> > +				exit_string = "Success";
> > +				break;
> > +			case 1:
> > +				exit_string = "Illegal initialization values";
> > +				break;
> > +			case 2:
> > +				exit_string = "Unrecognized device";
> > +				break;
> > +			case 3:
> > +				exit_string = "Device revision is "
> > +						"not supported";
> > +				break;
> > +			case 4:
> > +				exit_string = "Device programming failure";
> > +				break;
> > +			case 5:
> > +				exit_string = "Device is not blank";
> > +				break;
> > +			case 6:
> > +				exit_string = "Device verify failure";
> > +				break;
> > +			case 7:
> > +				exit_string = "SRAM configuration failure";
> > +				break;
> > +			default:
> > +				exit_string = "Unknown exit code";
> > +				break;
> > +			}
> > +		}
> > +
> > +		printk(KERN_INFO ": exit code = 0... \n", __func__,
> > +						exit_code, exit_string);
> > +	} else if ((format_version == 2) &&
> > +			(exec_result == -EINVAL)) {
> > +		if ((astate->action == NULL) || (*astate->action == '\0'))
> > +			printk(KERN_ERR ": error: no action specified for "
> > +				"Jam STAPL file.\nprogram terminated.\n",
> > +				__func__);
> > +		else
> > +			printk(KERN_ERR ": error: action \"\""
> > +				" is not supported "
> > +				"for this Jam STAPL file.\n"
> > +				"Program terminated.\n", __func__,
> > +				astate->action);
> > +
> > +	} else
> > +		printk(KERN_ERR ": error 0\n", __func__, exec_result);
> > +
> > +	if (astate != NULL) {
> > +		kfree(astate);
> > +		astate = NULL;
> > +	}
> > +
> > +	return 0;
> > +}
> > +EXPORT_SYMBOL(altera_init);
> > diff --git a/drivers/misc/stapl-altera/jbicomp.c
> > b/drivers/misc/stapl-altera/jbicomp.c new file mode 100644
> > index 0000000..5e09ec7
> > --- /dev/null
> > +++ b/drivers/misc/stapl-altera/jbicomp.c
> > @@ -0,0 +1,163 @@
> > +/*
> > + * jbicomp.c
> > + *
> > + * altera FPGA driver
> > + *
> > + * Copyright (C) Altera Corporation 1998-2001
> > + * Copyright (C) 2010 NetUP Inc.
> > + * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
> > + *
> > + * 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 <linux/kernel.h>
> > +#include "jbiexprt.h"
> > +
> > +#define	SHORT_BITS		16
> > +#define	CHAR_BITS		8
> > +#define	DATA_BLOB_LENGTH	3
> > +#define	MATCH_DATA_LENGTH	8192
> > +#define JBI_ACA_REQUEST_SIZE	1024
> > +#define JBI_ACA_BUFFER_SIZE	(MATCH_DATA_LENGTH + JBI_ACA_REQUEST_SIZE)
> > +
> > +u32 jbi_in_length = 0L;
> > +u32 jbi_in_index = 0L;	/* byte index into compressed array */
> > +u32 jbi_bits_avail = CHAR_BITS;
> 
> Hmm... global vars? This doesn't seem right... what happens if you have two
> devices simultaneously using those vars? The better is to encapsulete them
> into some per-device struct.
> 
> Also, global vars should generally use EXPORT_SYMBOL_GPL().
> 
> > +
> > +/*
> > +The following functions implement incremental decompression of Boolean
> > +array data, using a small memory window.
> > +This algorithm works by searching previous bytes in the data that match
> > +the current data. If a match is found, then the offset and length of
> > +the matching data can replace the actual data in the output.
> > +Memory usage is reduced by maintaining a "window" buffer which contains/
> > +the uncompressed data for one 8K page, plus some extra amount specified/
> > +by JBI_ACA_REQUEST_SIZE.  The function jbi_uncompress_page() is used to/
> > +request a subrange of the uncompressed data, starting at a particular
> > +bit position and extending a maximum of JBI_ACA_REQUEST_SIZE bytes. */
> > +
> > +static u32 jbi_bits_required(u32 n)
> > +/*
> > +Calculate the minimum number of bits required to represent n.
> > +Returns number of bits. */
> > +{
> > +	u32 result = SHORT_BITS;
> > +
> > +	if (n == 0)
> > +		result = 1;
> > +	else {
> > +		/* Look for the highest non-zero bit position */
> > +		while ((n & (1 << (SHORT_BITS - 1))) == 0) {
> > +			n <<= 1;
> > +			--result;
> > +		}
> > +	}
> > +
> > +	return result;
> > +}
> 
> Hmm... I think there are some functions for this already.
> 
> > +
> > +static u32 jbi_read_packed(u8 *buffer, u32 bits)
> > +/*
> > +Read the next value from the input array "buffer"
> > +Read only "bits" bits from the array. The amount of
> > +bits that have already been read from "buffer" is
> > +stored internally to this function.
> > +Returns up to 16 bit value or -1 if buffer overrun. */
> > +{
> > +	u32 result = 0;
> > +	u32 shift = 0;
> > +	u32 databyte = 0;
> > +
> > +	while (bits > 0) {
> > +		databyte = buffer[jbi_in_index];
> > +		result |= (((databyte >> (CHAR_BITS - jbi_bits_avail))
> > +			& (0xff >> (CHAR_BITS - jbi_bits_avail))) << shift);
> > +
> > +		if (bits <= jbi_bits_avail) {
> > +			result &= (0xffff >> (SHORT_BITS - (bits + shift)));
> > +			jbi_bits_avail -= bits;
> > +			bits = 0;
> > +		} else {
> > +			++jbi_in_index;
> > +			shift += jbi_bits_avail;
> > +			bits -= jbi_bits_avail;
> > +			jbi_bits_avail = CHAR_BITS;
> > +		}
> > +	}
> > +
> > +	return result;
> > +}
> > +
> > +u32 jbi_uncompress(u8 *in, u32 in_length, u8 *out, u32 out_length, s32
> > version) +/*
> > +Uncompress data in "in" and write result to "out".
> > +Returns length of uncompressed data or -1 if:
> > +	1) out_length is too small
> > +	2) Internal error in the code
> > +	3) in doesn't contain ACA compressed data. */
> > +{
> > +	u32 i, j, data_length = 0L;
> > +	u32 offset, length;
> > +	u32 match_data_length = MATCH_DATA_LENGTH;
> > +
> > +	if (version > 0)
> > +		--match_data_length;
> > +
> > +	jbi_in_length = in_length;
> > +	jbi_bits_avail = CHAR_BITS;
> > +	jbi_in_index = 0L;
> > +	for (i = 0; i < out_length; ++i)
> > +		out[i] = 0;
> > +
> > +	/* Read number of bytes in data. */
> > +	for (i = 0; i < sizeof(in_length); ++i) {
> > +		data_length = data_length | ((u32)
> > +			jbi_read_packed(in, CHAR_BITS) << (i * CHAR_BITS));
> > +	}
> > +
> > +	if (data_length > out_length) {
> > +		data_length = 0L;
> > +		return data_length;
> > +	}
> > +
> > +	i = 0;
> > +	while (i < data_length) {
> > +		/* A 0 bit indicates literal data. */
> > +		if (jbi_read_packed(in, 1) == 0) {
> > +			for (j = 0; j < DATA_BLOB_LENGTH; ++j) {
> > +				if (i < data_length) {
> > +					out[i] = (u8)jbi_read_packed(in,
> > +								CHAR_BITS);
> > +					i++;
> > +				}
> > +			}
> > +		} else {
> > +			/* A 1 bit indicates offset/length to follow. */
> > +			offset = jbi_read_packed(in, jbi_bits_required((s16)
> > +					(i > match_data_length ?
> > +						match_data_length : i)));
> > +			length = jbi_read_packed(in, CHAR_BITS);
> > +			for (j = 0; j < length; ++j) {
> > +				if (i < data_length) {
> > +					out[i] = out[i - offset];
> > +					i++;
> > +				}
> > +			}
> > +		}
> > +	}
> > +
> > +	return data_length;
> > +}
> > diff --git a/drivers/misc/stapl-altera/jbiexprt.h
> > b/drivers/misc/stapl-altera/jbiexprt.h new file mode 100644
> > index 0000000..c71fd75
> > --- /dev/null
> > +++ b/drivers/misc/stapl-altera/jbiexprt.h
> > @@ -0,0 +1,32 @@
> > +/*
> > + * jbiexprt.h
> > + *
> > + * altera FPGA driver
> > + *
> > + * Copyright (C) Altera Corporation 1998-2001
> > + * Copyright (C) 2010 NetUP Inc.
> > + * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
> > + *
> > + * 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.
> > + */
> > +
> > +#ifndef INC_JBIEXPRT_H
> > +#define INC_JBIEXPRT_H
> > +
> > +u32 jbi_uncompress(u8 *in, u32 in_length, u8 *out, u32 out_length, s32
> > version); +int netup_jtag_io_lpt(void *device, int tms, int tdi, int
> > read_tdo); +
> > +#endif /* INC_JBIEXPRT_H */
> > diff --git a/drivers/misc/stapl-altera/jbijtag.c
> > b/drivers/misc/stapl-altera/jbijtag.c new file mode 100644
> > index 0000000..a2cf842
> > --- /dev/null
> > +++ b/drivers/misc/stapl-altera/jbijtag.c
> > @@ -0,0 +1,1038 @@
> > +/*
> > + * jbijtag.c
> > + *
> > + * altera FPGA driver
> > + *
> > + * Copyright (C) Altera Corporation 1998-2001
> > + * Copyright (C) 2010 NetUP Inc.
> > + * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
> > + *
> > + * 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 <linux/firmware.h>
> > +#include <linux/slab.h>
> > +#include <misc/altera.h>
> > +#include "jbiexprt.h"
> > +#include "jbijtag.h"
> > +
> > +/* maximum JTAG IR and DR lengths (in bits) */
> > +#define JBIC_MAX_JTAG_IR_PREAMBLE   256
> > +#define JBIC_MAX_JTAG_IR_POSTAMBLE  256
> > +#define JBIC_MAX_JTAG_IR_LENGTH     512
> > +#define JBIC_MAX_JTAG_DR_PREAMBLE  1024
> > +#define JBIC_MAX_JTAG_DR_POSTAMBLE 1024
> > +#define JBIC_MAX_JTAG_DR_LENGTH    2048
> > +
> > +#define		jbi_jtag_io(a, b, c)\
> > +			astate->jtag_io(astate->dev, a, b, c);
> > +
> > +#define		jbi_malloc(a)	kzalloc(a, GFP_KERNEL);
> > +
> > +/* Global variable to store the current JTAG state */
> > +enum JBIE_JTAG_STATE jbi_jtag_state = JBI_ILLEGAL_JTAG_STATE;
> > +
> > +/* Store current stop-state for DR and IR scan commands */
> > +enum JBIE_JTAG_STATE jbi_drstop_state = IDLE;
> > +enum JBIE_JTAG_STATE jbi_irstop_state = IDLE;
> > +
> > +/* Store current padding values */
> > +u32 jbi_dr_preamble;
> > +u32 jbi_dr_postamble;
> > +u32 jbi_ir_preamble;
> > +u32 jbi_ir_postamble;
> > +u32 jbi_dr_length;
> > +u32 jbi_ir_length;
> > +u8 *jbi_dr_preamble_data;
> > +u8 *jbi_dr_postamble_data;
> > +u8 *jbi_ir_preamble_data;
> > +u8 *jbi_ir_postamble_data;
> > +u8 *jbi_dr_buffer;
> > +u8 *jbi_ir_buffer;
> 
> The better is to encapsulate all those global vars into an struct, like
> altera_config, otherwise you'll have serious problems if more than one
> device is connected.
> 
> Do they need to be global?
> 
> > +
> > +/*
> > +This structure shows, for each JTAG state, which state is reached after
> > +a single TCK clock cycle with TMS high or TMS low, respectively.  This
> > +describes all possible state transitions in the JTAG state machine.
> > +*/
> > +struct JBIS_JTAG_MACHINE {
> > +	enum JBIE_JTAG_STATE tms_high;
> > +	enum JBIE_JTAG_STATE tms_low;
> > +} jbi_jtag_state_transitions[] = {
> > +	/* RESET     */	{ RESET,	IDLE },
> > +	/* IDLE      */	{ DRSELECT,	IDLE },
> > +	/* DRSELECT  */	{ IRSELECT,	DRCAPTURE },
> > +	/* DRCAPTURE */	{ DREXIT1,	DRSHIFT },
> > +	/* DRSHIFT   */	{ DREXIT1,	DRSHIFT },
> > +	/* DREXIT1   */	{ DRUPDATE,	DRPAUSE },
> > +	/* DRPAUSE   */	{ DREXIT2,	DRPAUSE },
> > +	/* DREXIT2   */	{ DRUPDATE,	DRSHIFT },
> > +	/* DRUPDATE  */	{ DRSELECT,	IDLE },
> > +	/* IRSELECT  */	{ RESET,	IRCAPTURE },
> > +	/* IRCAPTURE */	{ IREXIT1,	IRSHIFT },
> > +	/* IRSHIFT   */	{ IREXIT1,	IRSHIFT },
> > +	/* IREXIT1   */	{ IRUPDATE,	IRPAUSE },
> > +	/* IRPAUSE   */	{ IREXIT2,	IRPAUSE },
> > +	/* IREXIT2   */	{ IRUPDATE,	IRSHIFT },
> > +	/* IRUPDATE  */	{ DRSELECT,	IDLE }
> > +};
> > +
> > +/*
> > +This table contains the TMS value to be used to take the NEXT STEP on
> > +the path to the desired state.  The array index is the current state,
> > +and the bit position is the desired endstate.  To find out which state
> > +is used as the intermediate state, look up the TMS value in the
> > +jbi_jtag_state_transitions[] table.
> > +*/
> > +u16 jbi_jtag_path_map[16] = {
> > +	/* RST	RTI	SDRS	CDR	SDR	E1DR	PDR	E2DR */
> > +	0x0001,	0xFFFD,	0xFE01,	0xFFE7,	0xFFEF,	0xFF0F,	0xFFBF,	0xFFFF,
> > +	/* UDR	SIRS	CIR	SIR	E1IR	PIR	E2IR	UIR */
> > +	0xFEFD,	0x0001,	0xF3FF,	0xF7FF,	0x87FF,	0xDFFF,	0xFFFF,	0x7FFD
> > +};
> 
> Are those global vars const? If so, declare as const.
> 
> If they are local, declare as "static".
> 
> > +
> > +/* Flag bits for jbi_jtag_io() function */
> > +#define TMS_HIGH   1
> > +#define TMS_LOW    0
> > +#define TDI_HIGH   1
> > +#define TDI_LOW    0
> > +#define READ_TDO   1
> > +#define IGNORE_TDO 0
> > +
> > +int jbi_init_jtag()
> > +{
> > +	/* initial JTAG state is unknown */
> > +	jbi_jtag_state = JBI_ILLEGAL_JTAG_STATE;
> > +
> > +	/* initialize global variables to default state */
> > +	jbi_drstop_state = IDLE;
> > +	jbi_irstop_state = IDLE;
> > +	jbi_dr_preamble  = 0;
> > +	jbi_dr_postamble = 0;
> > +	jbi_ir_preamble  = 0;
> > +	jbi_ir_postamble = 0;
> > +	jbi_dr_length    = 0;
> > +	jbi_ir_length    = 0;
> > +
> > +	jbi_dr_preamble_data  = NULL;
> > +	jbi_dr_postamble_data = NULL;
> > +	jbi_ir_preamble_data  = NULL;
> > +	jbi_ir_postamble_data = NULL;
> > +	jbi_dr_buffer	 = NULL;
> > +	jbi_ir_buffer	 = NULL;
> > +
> > +	return 0;
> > +}
> > +
> > +int jbi_set_drstop_state(enum JBIE_JTAG_STATE state)
> > +{
> > +	jbi_drstop_state = state;
> > +
> > +	return 0;
> > +}
> > +
> > +int jbi_set_irstop_state(enum JBIE_JTAG_STATE state)
> > +{
> > +	jbi_irstop_state = state;
> > +
> > +	return 0;
> > +}
> > +
> > +int jbi_set_dr_preamble(u32 count, u32 start_index,
> > +				    u8 *preamble_data)
> > +{
> > +	int status = 0;
> > +	u32 i;
> > +	u32 j;
> > +
> > +	if (count > jbi_dr_preamble) {
> > +		kfree(jbi_dr_preamble_data);
> > +		jbi_dr_preamble_data = (u8 *)jbi_malloc((count + 7) >> 3);
> > +		if (jbi_dr_preamble_data == NULL)
> > +			status = -ENOMEM;
> > +		else
> > +			jbi_dr_preamble = count;
> > +	} else
> > +		jbi_dr_preamble = count;
> > +
> > +	if (status == 0) {
> > +		for (i = 0; i < count; ++i) {
> > +			j = i + start_index;
> > +
> > +			if (preamble_data == NULL)
> > +				jbi_dr_preamble_data[i >> 3] |= (1 << (i & 7));
> > +			else {
> > +				if (preamble_data[j >> 3] & (1 << (j & 7)))
> > +					jbi_dr_preamble_data[i >> 3] |=
> > +							(1 << (i & 7));
> > +				else
> > +					jbi_dr_preamble_data[i >> 3] &=
> > +							~(u32)(1 << (i & 7));
> > +
> > +			}
> > +		}
> > +	}
> > +
> > +	return status;
> > +}
> > +
> > +int jbi_set_ir_preamble(u32 count, u32 start_index,
> > +							u8 *preamble_data)
> > +{
> > +	int status = 0;
> > +	u32 i;
> > +	u32 j;
> > +
> > +	if (count > jbi_ir_preamble) {
> > +		kfree(jbi_ir_preamble_data);
> > +		jbi_ir_preamble_data = (u8 *)jbi_malloc((count + 7) >> 3);
> > +		if (jbi_ir_preamble_data == NULL)
> > +			status = -ENOMEM;
> > +		else
> > +			jbi_ir_preamble = count;
> > +
> > +	} else
> > +		jbi_ir_preamble = count;
> > +
> > +	if (status == 0) {
> > +		for (i = 0; i < count; ++i) {
> > +			j = i + start_index;
> > +			if (preamble_data == NULL)
> > +				jbi_ir_preamble_data[i >> 3] |= (1 << (i & 7));
> > +			else {
> > +				if (preamble_data[j >> 3] & (1 << (j & 7)))
> > +					jbi_ir_preamble_data[i >> 3] |=
> > +							(1 << (i & 7));
> > +				else
> > +					jbi_ir_preamble_data[i >> 3] &=
> > +							~(u32)(1 << (i & 7));
> > +
> > +			}
> > +		}
> > +	}
> > +
> > +	return status;
> > +}
> > +
> > +int jbi_set_dr_postamble(u32 count, u32 start_index,
> > +						u8 *postamble_data)
> > +{
> > +	int status = 0;
> > +	u32 i;
> > +	u32 j;
> > +
> > +	if (count > jbi_dr_postamble) {
> > +		kfree(jbi_dr_postamble_data);
> > +		jbi_dr_postamble_data = (u8 *)jbi_malloc((count + 7) >> 3);
> > +
> > +		if (jbi_dr_postamble_data == NULL)
> > +			status = -ENOMEM;
> > +		else
> > +			jbi_dr_postamble = count;
> > +
> > +	} else
> > +		jbi_dr_postamble = count;
> > +
> > +	if (status == 0) {
> > +		for (i = 0; i < count; ++i) {
> > +			j = i + start_index;
> > +
> > +			if (postamble_data == NULL)
> > +				jbi_dr_postamble_data[i >> 3] |= (1 << (i & 7));
> > +			else {
> > +				if (postamble_data[j >> 3] & (1 << (j & 7)))
> > +					jbi_dr_postamble_data[i >> 3] |=
> > +								(1 << (i & 7));
> > +				else
> > +					jbi_dr_postamble_data[i >> 3] &=
> > +					    ~(u32)(1 << (i & 7));
> > +
> > +			}
> > +		}
> > +	}
> > +
> > +	return status;
> > +}
> > +
> > +int jbi_set_ir_postamble(u32 count, u32 start_index,
> > +						u8 *postamble_data)
> > +{
> > +	int status = 0;
> > +	u32 i;
> > +	u32 j;
> > +
> > +	if (count > jbi_ir_postamble) {
> > +		kfree(jbi_ir_postamble_data);
> > +		jbi_ir_postamble_data = (u8 *)jbi_malloc((count + 7) >> 3);
> > +		if (jbi_ir_postamble_data == NULL)
> > +			status = -ENOMEM;
> > +		else
> > +			jbi_ir_postamble = count;
> > +
> > +	} else
> > +		jbi_ir_postamble = count;
> > +
> > +	if (status != 0)
> > +		return status;
> > +
> > +	for (i = 0; i < count; ++i) {
> > +		j = i + start_index;
> > +
> > +		if (postamble_data == NULL)
> > +			jbi_ir_postamble_data[i >> 3] |= (1 << (i & 7));
> > +		else {
> > +			if (postamble_data[j >> 3] & (1 << (j & 7)))
> > +				jbi_ir_postamble_data[i >> 3] |= (1 << (i & 7));
> > +			else
> > +				jbi_ir_postamble_data[i >> 3] &=
> > +				    ~(u32)(1 << (i & 7));
> > +
> > +		}
> > +	}
> > +
> > +	return status;
> > +}
> > +
> > +static void jbi_jtag_reset_idle(struct altera_config *astate)
> > +{
> > +	int i;
> > +	/* Go to Test Logic Reset (no matter what the starting state may be) */
> > +	for (i = 0; i < 5; ++i)
> > +		jbi_jtag_io(TMS_HIGH, TDI_LOW, IGNORE_TDO);
> > +
> > +	/* Now step to Run Test / Idle */
> > +	jbi_jtag_io(TMS_LOW, TDI_LOW, IGNORE_TDO);
> > +	jbi_jtag_state = IDLE;
> > +}
> > +
> > +int jbi_goto_jtag_state(struct altera_config *astate,
> > +					enum JBIE_JTAG_STATE state)
> > +{
> > +	int tms;
> > +	int count = 0;
> > +	int status = 0;
> > +
> > +	if (jbi_jtag_state == JBI_ILLEGAL_JTAG_STATE)
> > +		/* initialize JTAG chain to known state */
> > +		jbi_jtag_reset_idle(astate);
> > +
> > +	if (jbi_jtag_state == state) {
> > +		/*
> > +		We are already in the desired state.  If it is a stable state,
> > +		loop here.  Otherwise do nothing (no clock cycles).
> > +		*/
> > +		if ((state == IDLE) || (state == DRSHIFT) ||
> > +			(state == DRPAUSE) || (state == IRSHIFT) ||
> > +				(state == IRPAUSE)) {
> > +			jbi_jtag_io(TMS_LOW, TDI_LOW, IGNORE_TDO);
> > +		} else if (state == RESET)
> > +			jbi_jtag_io(TMS_HIGH, TDI_LOW, IGNORE_TDO);
> > +
> > +	} else {
> > +		while ((jbi_jtag_state != state) && (count < 9)) {
> > +			/* Get TMS value to take a step toward desired state */
> > +			tms = (jbi_jtag_path_map[jbi_jtag_state] & (1 << state))
> > +							? TMS_HIGH : TMS_LOW;
> > +
> > +			/* Take a step */
> > +			jbi_jtag_io(tms, TDI_LOW, IGNORE_TDO);
> > +
> > +			if (tms)
> > +				jbi_jtag_state =
> > +					jbi_jtag_state_transitions[jbi_jtag_state].tms_high;
> > +			else
> > +				jbi_jtag_state =
> > +					jbi_jtag_state_transitions[jbi_jtag_state].tms_low;
> > +
> > +			++count;
> > +		}
> > +	}
> > +
> > +	if (jbi_jtag_state != state)
> > +		status = -EREMOTEIO;
> > +
> > +	return status;
> > +}
> > +
> > +int jbi_do_wait_cycles(struct altera_config *astate,
> > +					s32 cycles,
> > +					enum JBIE_JTAG_STATE wait_state)
> > +{
> > +	int tms;
> > +	s32 count;
> > +	int status = 0;
> > +
> > +	if (jbi_jtag_state != wait_state)
> > +		status = jbi_goto_jtag_state(astate, wait_state);
> > +
> > +	if (status == 0) {
> > +		/*
> > +		Set TMS high to loop in RESET state
> > +		Set TMS low to loop in any other stable state
> > +		*/
> > +		tms = (wait_state == RESET) ? TMS_HIGH : TMS_LOW;
> > +
> > +		for (count = 0L; count < cycles; count++)
> > +			jbi_jtag_io(tms, TDI_LOW, IGNORE_TDO);
> > +
> > +	}
> > +
> > +	return status;
> > +}
> > +
> > +int jbi_do_wait_microseconds(struct altera_config *astate,
> > +			s32 microseconds, enum JBIE_JTAG_STATE wait_state)
> > +/*
> > +Causes JTAG hardware to sit in the specified stable
> > +state for the specified duration of real time.  If
> > +no JTAG operations have been performed yet, then only
> > +a delay is performed.  This permits the WAIT USECS
> > +statement to be used in VECTOR programs without causing
> > +any JTAG operations.
> > +Returns 0 for success, else appropriate error code. */
> > +{
> > +	int status = 0;
> > +
> > +	if ((jbi_jtag_state != JBI_ILLEGAL_JTAG_STATE) &&
> > +	    (jbi_jtag_state != wait_state))
> > +		status = jbi_goto_jtag_state(astate, wait_state);
> > +
> > +	if (status == 0)
> > +		/* Wait for specified time interval */
> > +		udelay(microseconds);
> > +
> > +	return status;
> > +}
> > +
> > +static void jbi_jtag_concatenate_data(u8 *buffer,
> > +				u8 *preamble_data,
> > +				u32 preamble_count,
> > +				u8 *target_data,
> > +				u32 start_index,
> > +				u32 target_count,
> > +				u8 *postamble_data,
> > +				u32 postamble_count)
> > +/*
> > +Copies preamble data, target data, and postamble data
> > +into one buffer for IR or DR scans. */
> > +{
> > +	u32 i, j, k;
> > +
> > +	for (i = 0L; i < preamble_count; ++i) {
> > +		if (preamble_data[i >> 3L] & (1L << (i & 7L)))
> > +			buffer[i >> 3L] |= (1L << (i & 7L));
> > +		else
> > +			buffer[i >> 3L] &= ~(u32)(1L << (i & 7L));
> > +
> > +	}
> > +
> > +	j = start_index;
> > +	k = preamble_count + target_count;
> > +	for (; i < k; ++i, ++j) {
> > +		if (target_data[j >> 3L] & (1L << (j & 7L)))
> > +			buffer[i >> 3L] |= (1L << (i & 7L));
> > +		else
> > +			buffer[i >> 3L] &= ~(u32)(1L << (i & 7L));
> > +
> > +	}
> > +
> > +	j = 0L;
> > +	k = preamble_count + target_count + postamble_count;
> > +	for (; i < k; ++i, ++j) {
> > +		if (postamble_data[j >> 3L] & (1L << (j & 7L)))
> > +			buffer[i >> 3L] |= (1L << (i & 7L));
> > +		else
> > +			buffer[i >> 3L] &= ~(u32)(1L << (i & 7L));
> > +
> > +	}
> > +}
> > +
> > +static int jbi_jtag_drscan(struct altera_config *astate,
> > +			int start_state,
> > +			int count,
> > +			u8 *tdi,
> > +			u8 *tdo)
> > +{
> > +	int i = 0;
> > +	int tdo_bit = 0;
> > +	int status = 1;
> > +
> > +	/* First go to DRSHIFT state */
> > +	switch (start_state) {
> > +	case 0:						/* IDLE */
> > +		jbi_jtag_io(1, 0, 0);	/* DRSELECT */
> > +		jbi_jtag_io(0, 0, 0);	/* DRCAPTURE */
> > +		jbi_jtag_io(0, 0, 0);	/* DRSHIFT */
> > +		break;
> > +
> > +	case 1:						/* DRPAUSE */
> > +		jbi_jtag_io(1, 0, 0);	/* DREXIT2 */
> > +		jbi_jtag_io(1, 0, 0);	/* DRUPDATE */
> > +		jbi_jtag_io(1, 0, 0);	/* DRSELECT */
> > +		jbi_jtag_io(0, 0, 0);	/* DRCAPTURE */
> > +		jbi_jtag_io(0, 0, 0);	/* DRSHIFT */
> > +		break;
> > +
> > +	case 2:						/* IRPAUSE */
> > +		jbi_jtag_io(1, 0, 0);	/* IREXIT2 */
> > +		jbi_jtag_io(1, 0, 0);	/* IRUPDATE */
> > +		jbi_jtag_io(1, 0, 0);	/* DRSELECT */
> > +		jbi_jtag_io(0, 0, 0);	/* DRCAPTURE */
> > +		jbi_jtag_io(0, 0, 0);	/* DRSHIFT */
> > +		break;
> > +
> > +	default:
> > +		status = 0;
> > +	}
> > +
> > +	if (status) {
> > +		/* loop in the SHIFT-DR state */
> > +		for (i = 0; i < count; i++) {
> > +			tdo_bit = jbi_jtag_io(
> > +					(i == count - 1),
> > +					tdi[i >> 3] & (1 << (i & 7)),
> > +					(tdo != NULL));
> > +
> > +			if (tdo != NULL) {
> > +				if (tdo_bit)
> > +					tdo[i >> 3] |= (1 << (i & 7));
> > +				else
> > +					tdo[i >> 3] &= ~(u32)(1 << (i & 7));
> > +
> > +			}
> > +		}
> > +
> > +		jbi_jtag_io(0, 0, 0);	/* DRPAUSE */
> > +	}
> > +
> > +	return status;
> > +}
> > +
> > +static int jbi_jtag_irscan(struct altera_config *astate,
> > +		    int start_state,
> > +		    int count,
> > +		    u8 *tdi,
> > +		    u8 *tdo)
> > +{
> > +	int i = 0;
> > +	int tdo_bit = 0;
> > +	int status = 1;
> > +
> > +	/* First go to IRSHIFT state */
> > +	switch (start_state) {
> > +	case 0:						/* IDLE */
> > +		jbi_jtag_io(1, 0, 0);	/* DRSELECT */
> > +		jbi_jtag_io(1, 0, 0);	/* IRSELECT */
> > +		jbi_jtag_io(0, 0, 0);	/* IRCAPTURE */
> > +		jbi_jtag_io(0, 0, 0);	/* IRSHIFT */
> > +		break;
> > +
> > +	case 1:						/* DRPAUSE */
> > +		jbi_jtag_io(1, 0, 0);	/* DREXIT2 */
> > +		jbi_jtag_io(1, 0, 0);	/* DRUPDATE */
> > +		jbi_jtag_io(1, 0, 0);	/* DRSELECT */
> > +		jbi_jtag_io(1, 0, 0);	/* IRSELECT */
> > +		jbi_jtag_io(0, 0, 0);	/* IRCAPTURE */
> > +		jbi_jtag_io(0, 0, 0);	/* IRSHIFT */
> > +		break;
> > +
> > +	case 2:						/* IRPAUSE */
> > +		jbi_jtag_io(1, 0, 0);	/* IREXIT2 */
> > +		jbi_jtag_io(1, 0, 0);	/* IRUPDATE */
> > +		jbi_jtag_io(1, 0, 0);	/* DRSELECT */
> > +		jbi_jtag_io(1, 0, 0);	/* IRSELECT */
> > +		jbi_jtag_io(0, 0, 0);	/* IRCAPTURE */
> > +		jbi_jtag_io(0, 0, 0);	/* IRSHIFT */
> > +		break;
> > +
> > +	default:
> > +		status = 0;
> > +	}
> > +
> > +	if (status) {
> > +		/* loop in the SHIFT-IR state */
> > +		for (i = 0; i < count; i++) {
> > +			tdo_bit = jbi_jtag_io(
> > +				      (i == count - 1),
> > +				      tdi[i >> 3] & (1 << (i & 7)),
> > +				      (tdo != NULL));
> > +			if (tdo != NULL) {
> > +				if (tdo_bit)
> > +					tdo[i >> 3] |= (1 << (i & 7));
> > +				else
> > +					tdo[i >> 3] &= ~(u32)(1 << (i & 7));
> > +
> > +			}
> > +		}
> > +
> > +		jbi_jtag_io(0, 0, 0);	/* IRPAUSE */
> > +	}
> > +
> > +	return status;
> > +}
> > +
> > +static void jbi_jtag_extract_target_data(u8 *buffer,
> > +				u8 *target_data,
> > +				u32 start_index,
> > +				u32 preamble_count,
> > +				u32 target_count)
> > +/*
> > +Copies target data from scan buffer, filtering out
> > +preamble and postamble data. */
> > +{
> > +	u32 i;
> > +	u32 j;
> > +	u32 k;
> > +
> > +	j = preamble_count;
> > +	k = start_index + target_count;
> > +	for (i = start_index; i < k; ++i, ++j) {
> > +		if (buffer[j >> 3] & (1 << (j & 7)))
> > +			target_data[i >> 3] |= (1 << (i & 7));
> > +		else
> > +			target_data[i >> 3] &= ~(u32)(1 << (i & 7));
> > +
> > +	}
> > +}
> > +
> > +int jbi_do_irscan(struct altera_config *astate,
> > +				u32 count,
> > +				u8 *tdi_data,
> > +				u32 start_index)
> > +/* Shifts data into instruction register */
> > +{
> > +	int start_code = 0;
> > +	u32 alloc_chars = 0;
> > +	u32 shift_count = jbi_ir_preamble + count + jbi_ir_postamble;
> > +	int status = 0;
> > +	enum JBIE_JTAG_STATE start_state = JBI_ILLEGAL_JTAG_STATE;
> > +
> > +	switch (jbi_jtag_state) {
> > +	case JBI_ILLEGAL_JTAG_STATE:
> > +	case RESET:
> > +	case IDLE:
> > +		start_code = 0;
> > +		start_state = IDLE;
> > +		break;
> > +
> > +	case DRSELECT:
> > +	case DRCAPTURE:
> > +	case DRSHIFT:
> > +	case DREXIT1:
> > +	case DRPAUSE:
> > +	case DREXIT2:
> > +	case DRUPDATE:
> > +		start_code = 1;
> > +		start_state = DRPAUSE;
> > +		break;
> > +
> > +	case IRSELECT:
> > +	case IRCAPTURE:
> > +	case IRSHIFT:
> > +	case IREXIT1:
> > +	case IRPAUSE:
> > +	case IREXIT2:
> > +	case IRUPDATE:
> > +		start_code = 2;
> > +		start_state = IRPAUSE;
> > +		break;
> > +
> > +	default:
> > +		status = -EREMOTEIO;
> > +		break;
> > +	}
> > +
> > +	if (status == 0)
> > +		if (jbi_jtag_state != start_state)
> > +			status = jbi_goto_jtag_state(astate, start_state);
> > +
> > +	if (status == 0) {
> > +		if (shift_count > jbi_ir_length) {
> > +			alloc_chars = (shift_count + 7) >> 3;
> > +			kfree(jbi_ir_buffer);
> > +			jbi_ir_buffer = (u8 *)jbi_malloc(alloc_chars);
> > +			if (jbi_ir_buffer == NULL)
> > +				status = -ENOMEM;
> > +			else
> > +				jbi_ir_length = alloc_chars * 8;
> > +
> > +		}
> > +	}
> > +
> > +	if (status == 0) {
> > +		/* Copy preamble data, IR data,
> > +		and postamble data into a buffer */
> > +		jbi_jtag_concatenate_data(jbi_ir_buffer,
> > +					jbi_ir_preamble_data,
> > +					jbi_ir_preamble,
> > +					tdi_data,
> > +					start_index,
> > +					count,
> > +					jbi_ir_postamble_data,
> > +					jbi_ir_postamble);
> > +		/* Do the IRSCAN */
> > +		jbi_jtag_irscan(astate,
> > +				start_code,
> > +				shift_count,
> > +				jbi_ir_buffer,
> > +				NULL);
> > +
> > +		/* jbi_jtag_irscan() always ends in IRPAUSE state */
> > +		jbi_jtag_state = IRPAUSE;
> > +	}
> > +
> > +	if (status == 0)
> > +		if (jbi_irstop_state != IRPAUSE)
> > +			status = jbi_goto_jtag_state(astate, jbi_irstop_state);
> > +
> > +
> > +	return status;
> > +}
> > +
> > +int jbi_swap_ir(struct altera_config *astate,
> > +			    u32 count,
> > +			    u8 *in_data,
> > +			    u32 in_index,
> > +			    u8 *out_data,
> > +			    u32 out_index)
> > +/* Shifts data into instruction register, capturing output data */
> > +{
> > +	int start_code = 0;
> > +	u32 alloc_chars = 0;
> > +	u32 shift_count = jbi_ir_preamble + count + jbi_ir_postamble;
> > +	int status = 0;
> > +	enum JBIE_JTAG_STATE start_state = JBI_ILLEGAL_JTAG_STATE;
> > +
> > +	switch (jbi_jtag_state) {
> > +	case JBI_ILLEGAL_JTAG_STATE:
> > +	case RESET:
> > +	case IDLE:
> > +		start_code = 0;
> > +		start_state = IDLE;
> > +		break;
> > +
> > +	case DRSELECT:
> > +	case DRCAPTURE:
> > +	case DRSHIFT:
> > +	case DREXIT1:
> > +	case DRPAUSE:
> > +	case DREXIT2:
> > +	case DRUPDATE:
> > +		start_code = 1;
> > +		start_state = DRPAUSE;
> > +		break;
> > +
> > +	case IRSELECT:
> > +	case IRCAPTURE:
> > +	case IRSHIFT:
> > +	case IREXIT1:
> > +	case IRPAUSE:
> > +	case IREXIT2:
> > +	case IRUPDATE:
> > +		start_code = 2;
> > +		start_state = IRPAUSE;
> > +		break;
> > +
> > +	default:
> > +		status = -EREMOTEIO;
> > +		break;
> > +	}
> > +
> > +	if (status == 0)
> > +		if (jbi_jtag_state != start_state)
> > +			status = jbi_goto_jtag_state(astate, start_state);
> > +
> > +	if (status == 0) {
> > +		if (shift_count > jbi_ir_length) {
> > +			alloc_chars = (shift_count + 7) >> 3;
> > +			kfree(jbi_ir_buffer);
> > +			jbi_ir_buffer = (u8 *)jbi_malloc(alloc_chars);
> > +			if (jbi_ir_buffer == NULL)
> > +				status = -ENOMEM;
> > +			else
> > +				jbi_ir_length = alloc_chars * 8;
> > +
> > +		}
> > +	}
> > +
> > +	if (status == 0) {
> > +		/*
> > +		Copy preamble data, IR data,
> > +		and postamble data into a buffer */
> > +		jbi_jtag_concatenate_data(jbi_ir_buffer,
> > +					jbi_ir_preamble_data,
> > +					jbi_ir_preamble,
> > +					in_data,
> > +					in_index,
> > +					count,
> > +					jbi_ir_postamble_data,
> > +					jbi_ir_postamble);
> > +
> > +		/* Do the IRSCAN */
> > +		jbi_jtag_irscan(astate,
> > +				start_code,
> > +				shift_count,
> > +				jbi_ir_buffer,
> > +				jbi_ir_buffer);
> > +
> > +		/* jbi_jtag_irscan() always ends in IRPAUSE state */
> > +		jbi_jtag_state = IRPAUSE;
> > +	}
> > +
> > +	if (status == 0)
> > +		if (jbi_irstop_state != IRPAUSE)
> > +			status = jbi_goto_jtag_state(astate, jbi_irstop_state);
> > +
> > +
> > +	if (status == 0)
> > +		/* Now extract the returned data from the buffer */
> > +		jbi_jtag_extract_target_data(jbi_ir_buffer,
> > +					out_data, out_index,
> > +					jbi_ir_preamble, count);
> > +
> > +	return status;
> > +}
> > +
> > +int jbi_do_drscan(struct altera_config *astate,
> > +				u32 count,
> > +				u8 *tdi_data,
> > +				u32 start_index)
> > +/* Shifts data into data register (ignoring output data) */
> > +{
> > +	int start_code = 0;
> > +	u32 alloc_chars = 0;
> > +	u32 shift_count = jbi_dr_preamble + count + jbi_dr_postamble;
> > +	int status = 0;
> > +	enum JBIE_JTAG_STATE start_state = JBI_ILLEGAL_JTAG_STATE;
> > +
> > +	switch (jbi_jtag_state) {
> > +	case JBI_ILLEGAL_JTAG_STATE:
> > +	case RESET:
> > +	case IDLE:
> > +		start_code = 0;
> > +		start_state = IDLE;
> > +		break;
> > +
> > +	case DRSELECT:
> > +	case DRCAPTURE:
> > +	case DRSHIFT:
> > +	case DREXIT1:
> > +	case DRPAUSE:
> > +	case DREXIT2:
> > +	case DRUPDATE:
> > +		start_code = 1;
> > +		start_state = DRPAUSE;
> > +		break;
> > +
> > +	case IRSELECT:
> > +	case IRCAPTURE:
> > +	case IRSHIFT:
> > +	case IREXIT1:
> > +	case IRPAUSE:
> > +	case IREXIT2:
> > +	case IRUPDATE:
> > +		start_code = 2;
> > +		start_state = IRPAUSE;
> > +		break;
> > +
> > +	default:
> > +		status = -EREMOTEIO;
> > +		break;
> > +	}
> > +
> > +	if (status == 0)
> > +		if (jbi_jtag_state != start_state)
> > +			status = jbi_goto_jtag_state(astate, start_state);
> > +
> > +	if (status == 0) {
> > +		if (shift_count > jbi_dr_length) {
> > +			alloc_chars = (shift_count + 7) >> 3;
> > +			kfree(jbi_dr_buffer);
> > +			jbi_dr_buffer = (u8 *)jbi_malloc(alloc_chars);
> > +			if (jbi_dr_buffer == NULL)
> > +				status = -ENOMEM;
> > +			else
> > +				jbi_dr_length = alloc_chars * 8;
> > +
> > +		}
> > +	}
> > +
> > +	if (status == 0) {
> > +		/*
> > +		Copy preamble data, DR data,
> > +		and postamble data into a buffer */
> > +		jbi_jtag_concatenate_data(jbi_dr_buffer,
> > +					jbi_dr_preamble_data,
> > +					jbi_dr_preamble,
> > +					tdi_data,
> > +					start_index,
> > +					count,
> > +					jbi_dr_postamble_data,
> > +					jbi_dr_postamble);
> > +		/* Do the DRSCAN */
> > +		jbi_jtag_drscan(astate, start_code, shift_count,
> > +				jbi_dr_buffer, NULL);
> > +		/* jbi_jtag_drscan() always ends in DRPAUSE state */
> > +		jbi_jtag_state = DRPAUSE;
> > +	}
> > +
> > +	if (status == 0)
> > +		if (jbi_drstop_state != DRPAUSE)
> > +			status = jbi_goto_jtag_state(astate, jbi_drstop_state);
> > +
> > +	return status;
> > +}
> > +
> > +int jbi_swap_dr(struct altera_config *astate, u32 count,
> > +				u8 *in_data, u32 in_index,
> > +				u8 *out_data, u32 out_index)
> > +/* Shifts data into data register, capturing output data */
> > +{
> > +	int start_code = 0;
> > +	u32 alloc_chars = 0;
> > +	u32 shift_count = jbi_dr_preamble + count + jbi_dr_postamble;
> > +	int status = 0;
> > +	enum JBIE_JTAG_STATE start_state = JBI_ILLEGAL_JTAG_STATE;
> > +
> > +	switch (jbi_jtag_state) {
> > +	case JBI_ILLEGAL_JTAG_STATE:
> > +	case RESET:
> > +	case IDLE:
> > +		start_code = 0;
> > +		start_state = IDLE;
> > +		break;
> > +
> > +	case DRSELECT:
> > +	case DRCAPTURE:
> > +	case DRSHIFT:
> > +	case DREXIT1:
> > +	case DRPAUSE:
> > +	case DREXIT2:
> > +	case DRUPDATE:
> > +		start_code = 1;
> > +		start_state = DRPAUSE;
> > +		break;
> > +
> > +	case IRSELECT:
> > +	case IRCAPTURE:
> > +	case IRSHIFT:
> > +	case IREXIT1:
> > +	case IRPAUSE:
> > +	case IREXIT2:
> > +	case IRUPDATE:
> > +		start_code = 2;
> > +		start_state = IRPAUSE;
> > +		break;
> > +
> > +	default:
> > +		status = -EREMOTEIO;
> > +		break;
> > +	}
> > +
> > +	if (status == 0)
> > +		if (jbi_jtag_state != start_state)
> > +			status = jbi_goto_jtag_state(astate, start_state);
> > +
> > +	if (status == 0) {
> > +		if (shift_count > jbi_dr_length) {
> > +			alloc_chars = (shift_count + 7) >> 3;
> > +			kfree(jbi_dr_buffer);
> > +			jbi_dr_buffer = (u8 *)jbi_malloc(alloc_chars);
> > +
> > +			if (jbi_dr_buffer == NULL)
> > +				status = -ENOMEM;
> > +			else
> > +				jbi_dr_length = alloc_chars * 8;
> > +
> > +		}
> > +	}
> > +
> > +	if (status == 0) {
> > +		/* Copy preamble data, DR data,
> > +		and postamble data into a buffer */
> > +		jbi_jtag_concatenate_data(jbi_dr_buffer,
> > +				jbi_dr_preamble_data,
> > +				jbi_dr_preamble,
> > +				in_data,
> > +				in_index,
> > +				count,
> > +				jbi_dr_postamble_data,
> > +				jbi_dr_postamble);
> > +
> > +		/* Do the DRSCAN */
> > +		jbi_jtag_drscan(astate,
> > +				start_code,
> > +				shift_count,
> > +				jbi_dr_buffer,
> > +				jbi_dr_buffer);
> > +
> > +		/* jbi_jtag_drscan() always ends in DRPAUSE state */
> > +		jbi_jtag_state = DRPAUSE;
> > +	}
> > +
> > +	if (status == 0)
> > +		if (jbi_drstop_state != DRPAUSE)
> > +			status = jbi_goto_jtag_state(astate, jbi_drstop_state);
> > +
> > +	if (status == 0)
> > +		/* Now extract the returned data from the buffer */
> > +		jbi_jtag_extract_target_data(jbi_dr_buffer,
> > +					out_data,
> > +					out_index,
> > +					jbi_dr_preamble,
> > +					count);
> > +
> > +	return status;
> > +}
> > +
> > +void jbi_free_jtag_padding_buffers(struct altera_config *astate/*,
> > +							int reset_jtag*/)
> > +/* Frees memory allocated for JTAG IR and DR buffers */
> > +{
> > +	/* If the JTAG interface was used, reset it to TLR */
> > +	if (/*reset_jtag && (*/jbi_jtag_state != JBI_ILLEGAL_JTAG_STATE/*)*/)
> > +		jbi_jtag_reset_idle(astate);
> > +
> > +	if (jbi_dr_preamble_data != NULL) {
> > +		kfree(jbi_dr_preamble_data);
> > +		jbi_dr_preamble_data = NULL;
> > +	}
> > +
> > +	if (jbi_dr_postamble_data != NULL) {
> > +		kfree(jbi_dr_postamble_data);
> > +		jbi_dr_postamble_data = NULL;
> > +	}
> > +
> > +	if (jbi_dr_buffer != NULL) {
> > +		kfree(jbi_dr_buffer);
> > +		jbi_dr_buffer = NULL;
> > +	}
> > +
> > +	if (jbi_ir_preamble_data != NULL) {
> > +		kfree(jbi_ir_preamble_data);
> > +		jbi_ir_preamble_data = NULL;
> > +	}
> > +
> > +	if (jbi_ir_postamble_data != NULL) {
> > +		kfree(jbi_ir_postamble_data);
> > +		jbi_ir_postamble_data = NULL;
> > +	}
> > +
> > +	if (jbi_ir_buffer != NULL) {
> > +		kfree(jbi_ir_buffer);
> > +		jbi_ir_buffer = NULL;
> > +	}
> 
> Just do
> 	kfree(var);
> 	var = NULL;
> 
> > +}
> > diff --git a/drivers/misc/stapl-altera/jbijtag.h
> > b/drivers/misc/stapl-altera/jbijtag.h new file mode 100644
> > index 0000000..61fd123
> > --- /dev/null
> > +++ b/drivers/misc/stapl-altera/jbijtag.h
> > @@ -0,0 +1,83 @@
> > +/*
> > + * jbijtag.h
> > + *
> > + * altera FPGA driver
> > + *
> > + * Copyright (C) Altera Corporation 1998-2001
> > + * Copyright (C) 2010 NetUP Inc.
> > + * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
> > + *
> > + * 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.
> > + */
> > +
> > +#ifndef INC_JBIJTAG_H
> > +#define INC_JBIJTAG_H
> > +
> > +/* Function Prototypes */
> > +enum JBIE_JTAG_STATE {
> > +	JBI_ILLEGAL_JTAG_STATE = -1,
> > +	RESET = 0,
> > +	IDLE = 1,
> > +	DRSELECT = 2,
> > +	DRCAPTURE = 3,
> > +	DRSHIFT = 4,
> > +	DREXIT1 = 5,
> > +	DRPAUSE = 6,
> > +	DREXIT2 = 7,
> > +	DRUPDATE = 8,
> > +	IRSELECT = 9,
> > +	IRCAPTURE = 10,
> > +	IRSHIFT = 11,
> > +	IREXIT1 = 12,
> > +	IRPAUSE = 13,
> > +	IREXIT2 = 14,
> > +	IRUPDATE = 15
> > +
> > +};
> > +
> > +
> > +int jbi_init_jtag(void);
> > +int jbi_set_drstop_state(enum JBIE_JTAG_STATE state);
> > +int jbi_set_irstop_state(enum JBIE_JTAG_STATE state);
> > +int jbi_set_dr_preamble(u32 count, u32 start_index,
> > +				u8 *preamble_data);
> > +int jbi_set_ir_preamble(u32 count, u32 start_index,
> > +				u8 *preamble_data);
> > +int jbi_set_dr_postamble(u32 count, u32 start_index,
> > +				u8 *postamble_data);
> > +int jbi_set_ir_postamble(u32 count, u32 start_index,
> > +				u8 *postamble_data);
> > +int jbi_goto_jtag_state(struct altera_config *astate,
> > +				enum JBIE_JTAG_STATE state);
> > +int jbi_do_wait_cycles(struct altera_config *astate,
> > +				s32 cycles, enum JBIE_JTAG_STATE wait_state);
> > +int jbi_do_wait_microseconds(struct altera_config *astate,
> > +				s32 microseconds,
> > +				enum JBIE_JTAG_STATE wait_state);
> > +int jbi_do_irscan(struct altera_config *astate, u32 count,
> > +				u8 *tdi_data, u32 start_index);
> > +int jbi_swap_ir(struct altera_config *astate,
> > +				u32 count, u8 *in_data,
> > +				u32 in_index, u8 *out_data,
> > +				u32 out_index);
> > +int jbi_do_drscan(struct altera_config *astate, u32 count,
> > +				u8 *tdi_data, u32 start_index);
> > +int jbi_swap_dr(struct altera_config *astate, u32 count,
> > +				u8 *in_data, u32 in_index,
> > +				u8 *out_data, u32 out_index);
> > +void jbi_free_jtag_padding_buffers(struct altera_config *astate/*,
> > +				int reset_jtag*/);
> > +#endif /* INC_JBIJTAG_H */
> > diff --git a/drivers/misc/stapl-altera/jbistub.c
> > b/drivers/misc/stapl-altera/jbistub.c new file mode 100644
> > index 0000000..9194afe
> > --- /dev/null
> > +++ b/drivers/misc/stapl-altera/jbistub.c
> > @@ -0,0 +1,70 @@
> > +/*
> > + * jbistub.c
> > + *
> > + * altera FPGA driver
> > + *
> > + * Copyright (C) Altera Corporation 1998-2001
> > + * Copyright (C) 2010 NetUP Inc.
> > + * Copyright (C) 2010 Abylay Ospan <aospan@xxxxxxxx>
> > + *
> > + * 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 <linux/io.h>
> > +#include <linux/kernel.h>
> > +#include "jbiexprt.h"
> > +
> > +int jtag_hardware_initialized;
> > +
> > +static void write_byteblaster(int port, int data)
> > +{
> > +	outb((u8)data, (u16)(port + 0x378));
> > +};
> > +
> > +static int read_byteblaster(int port)
> > +{
> > +	int data = 0;
> > +	data = inb((u16)(port + 0x378));
> > +	return data & 0xff;
> > +};
> > +
> > +int netup_jtag_io_lpt(void *device, int tms, int tdi, int read_tdo)
> > +{
> > +	int data = 0;
> > +	int tdo = 0;
> > +	int initial_lpt_ctrl = 0;
> > +
> > +	if (!jtag_hardware_initialized) {
> > +		initial_lpt_ctrl = read_byteblaster(2);
> > +		write_byteblaster(2, (initial_lpt_ctrl | 0x02) & 0xdf);
> > +		jtag_hardware_initialized = 1;
> > +	}
> > +
> > +	data = ((tdi ? 0x40 : 0) | (tms ? 0x02 : 0));
> > +
> > +	write_byteblaster(0, data);
> > +
> > +	if (read_tdo) {
> > +		tdo = read_byteblaster(1);
> > +		tdo = ((tdo & 0x80) ? 0 : 1);
> > +	}
> > +
> > +	write_byteblaster(0, data | 0x01);
> > +
> > +	write_byteblaster(0, data);
> > +
> > +	return tdo;
> > +}
> > diff --git a/include/misc/altera.h b/include/misc/altera.h
> > new file mode 100644
> > index 0000000..bf6d878
> > --- /dev/null
> > +++ b/include/misc/altera.h
> > @@ -0,0 +1,49 @@
> > +/*
> > + * altera.h
> > + *
> > + * altera FPGA driver
> > + *
> > + * Copyright (C) Altera Corporation 1998-2001
> > + * Copyright (C) 2010 NetUP Inc.
> > + * Copyright (C) 2010 Igor M. Liplianin <liplianin@xxxxxxxx>
> > + *
> > + * 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.
> > + */
> > +
> > +#ifndef __ALTERA_H
> > +#define __ALTERA_H
> > +
> > +struct altera_config {
> > +	void *dev;
> > +	u8 *action;
> > +	int (*jtag_io) (void *dev, int tms, int tdi, int tdo);
> > +};
> > +
> > +#if defined(CONFIG_STAPL_ALTERA) || \
> > +		(defined(CONFIG_STAPL_ALTERA_MODULE) && defined(MODULE))
> > +
> > +extern int altera_init(struct altera_config *config, const struct
> > firmware *fw); +#else
> > +
> > +static inline int altera_init(struct altera_config *config,
> > +						const struct firmware *fw)
> > +{
> > +	printk(KERN_WARNING ": driver disabled by Kconfig\n", __func__);
> > +	return 0;
> > +}
> > +#endif /* CONFIG_STAPL_ALTERA */
> > +
> > +#endif /* __ALTERA_H */
> 
> PS.: I noticed that you've declare a large number of symbols as global. You
> need to be sure that those names won't conflict with other symbols in
> Linux, otherwise, kernel won't compile with allyesconfig. What we
> generally do for driver symbols is to start all of them with the driver
> name.
> 
> So, for example, a better name for jbi_init_jtag() would be
> altera_jbi_init_jtag().
> 
> Btw, checkpatch got two warnings:
> 
> WARNING: unnecessary cast may hide bugs, see
> http://c-faq.com/malloc/mallocnocast.html #407: FILE:
> drivers/misc/stapl-altera/altera.c:322:
> +		attrs = (char *)kmalloc((u32)sym_count, GFP_KERNEL);
> 
> WARNING: unnecessary cast may hide bugs, see
> http://c-faq.com/malloc/mallocnocast.html #414: FILE:
> drivers/misc/stapl-altera/altera.c:329:
> +		proc_attributes = (u8 *)kmalloc((u32)proc_count, GFP_KERNEL);
> 
> Please, use typecasts only when it is _really_ needed.
> 
> Cheers,
> Mauro

-- 
Igor M. Liplianin
Microsoft Windows Free Zone - Linux used for all Computing Tasks
--
To unsubscribe from this list: send the line "unsubscribe linux-media" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html


[Index of Archives]     [Linux Input]     [Video for Linux]     [Gstreamer Embedded]     [Mplayer Users]     [Linux USB Devel]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [Yosemite Backpacking]
  Powered by Linux