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

Mauro Carvalho Chehab
2010-10-17T17:52:49Z

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@netup.ru>
> Signed-off-by: Mauro Carvalho Chehab <mchehab@redhat.com>
> ---
> 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@netup.ru>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + *
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +#include <asm/unaligned.h>
> +#include <linux/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@netup.ru>");
> +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.

> + 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@netup.ru>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + *
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +#include <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@netup.ru>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + *
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +#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@netup.ru>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + *
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +#include <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@netup.ru>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + *
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +#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@netup.ru>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + *
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +#include <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@netup.ru>
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License as published by
> + * the Free Software Foundation; either version 2 of the License, or
> + * (at your option) any later version.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + *
> + * GNU General Public License for more details.
> + *
> + * You should have received a copy of the GNU General Public License
> + * along with this program; if not, write to the Free Software
> + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
> + */
> +
> +#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